1 /* //device/system/reference-ril/atchannel.c 2 ** 3 ** Copyright 2006, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 #include "atchannel.h" 19 #include "at_tok.h" 20 21 #include <stdio.h> 22 #include <string.h> 23 #include <pthread.h> 24 #include <ctype.h> 25 #include <stdlib.h> 26 #include <errno.h> 27 #include <fcntl.h> 28 #include <sys/time.h> 29 #include <time.h> 30 #include <unistd.h> 31 32 #define LOG_NDEBUG 0 33 #define LOG_TAG "AT" 34 #include <utils/Log.h> 35 36 #ifdef HAVE_ANDROID_OS 37 /* for IOCTL's */ 38 #include <linux/omap_csmi.h> 39 #endif /*HAVE_ANDROID_OS*/ 40 41 #include "misc.h" 42 43 #ifdef HAVE_ANDROID_OS 44 #define USE_NP 1 45 #endif /* HAVE_ANDROID_OS */ 46 47 48 #define NUM_ELEMS(x) (sizeof(x)/sizeof(x[0])) 49 50 #define MAX_AT_RESPONSE (8 * 1024) 51 #define HANDSHAKE_RETRY_COUNT 8 52 #define HANDSHAKE_TIMEOUT_MSEC 250 53 54 static pthread_t s_tid_reader; 55 static int s_fd = -1; /* fd of the AT channel */ 56 static ATUnsolHandler s_unsolHandler; 57 58 /* for input buffering */ 59 60 static char s_ATBuffer[MAX_AT_RESPONSE+1]; 61 static char *s_ATBufferCur = s_ATBuffer; 62 63 static int s_ackPowerIoctl; /* true if TTY has android byte-count 64 handshake for low power*/ 65 static int s_readCount = 0; 66 67 #if AT_DEBUG 68 void AT_DUMP(const char* prefix, const char* buff, int len) 69 { 70 if (len < 0) 71 len = strlen(buff); 72 RLOGD("%.*s", len, buff); 73 } 74 #endif 75 76 /* 77 * for current pending command 78 * these are protected by s_commandmutex 79 */ 80 81 static pthread_mutex_t s_commandmutex = PTHREAD_MUTEX_INITIALIZER; 82 static pthread_cond_t s_commandcond = PTHREAD_COND_INITIALIZER; 83 84 static ATCommandType s_type; 85 static const char *s_responsePrefix = NULL; 86 static const char *s_smsPDU = NULL; 87 static ATResponse *sp_response = NULL; 88 89 static void (*s_onTimeout)(void) = NULL; 90 static void (*s_onReaderClosed)(void) = NULL; 91 static int s_readerClosed; 92 93 static void onReaderClosed(); 94 static int writeCtrlZ (const char *s); 95 static int writeline (const char *s); 96 97 #ifndef USE_NP 98 static void setTimespecRelative(struct timespec *p_ts, long long msec) 99 { 100 struct timeval tv; 101 102 gettimeofday(&tv, (struct timezone *) NULL); 103 104 /* what's really funny about this is that I know 105 pthread_cond_timedwait just turns around and makes this 106 a relative time again */ 107 p_ts->tv_sec = tv.tv_sec + (msec / 1000); 108 p_ts->tv_nsec = (tv.tv_usec + (msec % 1000) * 1000L ) * 1000L; 109 } 110 #endif /*USE_NP*/ 111 112 static void sleepMsec(long long msec) 113 { 114 struct timespec ts; 115 int err; 116 117 ts.tv_sec = (msec / 1000); 118 ts.tv_nsec = (msec % 1000) * 1000 * 1000; 119 120 do { 121 err = nanosleep (&ts, &ts); 122 } while (err < 0 && errno == EINTR); 123 } 124 125 126 127 /** add an intermediate response to sp_response*/ 128 static void addIntermediate(const char *line) 129 { 130 ATLine *p_new; 131 132 p_new = (ATLine *) malloc(sizeof(ATLine)); 133 134 p_new->line = strdup(line); 135 136 /* note: this adds to the head of the list, so the list 137 will be in reverse order of lines received. the order is flipped 138 again before passing on to the command issuer */ 139 p_new->p_next = sp_response->p_intermediates; 140 sp_response->p_intermediates = p_new; 141 } 142 143 144 /** 145 * returns 1 if line is a final response indicating error 146 * See 27.007 annex B 147 * WARNING: NO CARRIER and others are sometimes unsolicited 148 */ 149 static const char * s_finalResponsesError[] = { 150 "ERROR", 151 "+CMS ERROR:", 152 "+CME ERROR:", 153 "NO CARRIER", /* sometimes! */ 154 "NO ANSWER", 155 "NO DIALTONE", 156 }; 157 static int isFinalResponseError(const char *line) 158 { 159 size_t i; 160 161 for (i = 0 ; i < NUM_ELEMS(s_finalResponsesError) ; i++) { 162 if (strStartsWith(line, s_finalResponsesError[i])) { 163 return 1; 164 } 165 } 166 167 return 0; 168 } 169 170 /** 171 * returns 1 if line is a final response indicating success 172 * See 27.007 annex B 173 * WARNING: NO CARRIER and others are sometimes unsolicited 174 */ 175 static const char * s_finalResponsesSuccess[] = { 176 "OK", 177 "CONNECT" /* some stacks start up data on another channel */ 178 }; 179 static int isFinalResponseSuccess(const char *line) 180 { 181 size_t i; 182 183 for (i = 0 ; i < NUM_ELEMS(s_finalResponsesSuccess) ; i++) { 184 if (strStartsWith(line, s_finalResponsesSuccess[i])) { 185 return 1; 186 } 187 } 188 189 return 0; 190 } 191 192 /** 193 * returns 1 if line is a final response, either error or success 194 * See 27.007 annex B 195 * WARNING: NO CARRIER and others are sometimes unsolicited 196 */ 197 static int isFinalResponse(const char *line) 198 { 199 return isFinalResponseSuccess(line) || isFinalResponseError(line); 200 } 201 202 203 /** 204 * returns 1 if line is the first line in (what will be) a two-line 205 * SMS unsolicited response 206 */ 207 static const char * s_smsUnsoliciteds[] = { 208 "+CMT:", 209 "+CDS:", 210 "+CBM:" 211 }; 212 static int isSMSUnsolicited(const char *line) 213 { 214 size_t i; 215 216 for (i = 0 ; i < NUM_ELEMS(s_smsUnsoliciteds) ; i++) { 217 if (strStartsWith(line, s_smsUnsoliciteds[i])) { 218 return 1; 219 } 220 } 221 222 return 0; 223 } 224 225 226 /** assumes s_commandmutex is held */ 227 static void handleFinalResponse(const char *line) 228 { 229 sp_response->finalResponse = strdup(line); 230 231 pthread_cond_signal(&s_commandcond); 232 } 233 234 static void handleUnsolicited(const char *line) 235 { 236 if (s_unsolHandler != NULL) { 237 s_unsolHandler(line, NULL); 238 } 239 } 240 241 static void processLine(const char *line) 242 { 243 pthread_mutex_lock(&s_commandmutex); 244 245 if (sp_response == NULL) { 246 /* no command pending */ 247 handleUnsolicited(line); 248 } else if (isFinalResponseSuccess(line)) { 249 sp_response->success = 1; 250 handleFinalResponse(line); 251 } else if (isFinalResponseError(line)) { 252 sp_response->success = 0; 253 handleFinalResponse(line); 254 } else if (s_smsPDU != NULL && 0 == strcmp(line, "> ")) { 255 // See eg. TS 27.005 4.3 256 // Commands like AT+CMGS have a "> " prompt 257 writeCtrlZ(s_smsPDU); 258 s_smsPDU = NULL; 259 } else switch (s_type) { 260 case NO_RESULT: 261 handleUnsolicited(line); 262 break; 263 case NUMERIC: 264 if (sp_response->p_intermediates == NULL 265 && isdigit(line[0]) 266 ) { 267 addIntermediate(line); 268 } else { 269 /* either we already have an intermediate response or 270 the line doesn't begin with a digit */ 271 handleUnsolicited(line); 272 } 273 break; 274 case SINGLELINE: 275 if (sp_response->p_intermediates == NULL 276 && strStartsWith (line, s_responsePrefix) 277 ) { 278 addIntermediate(line); 279 } else { 280 /* we already have an intermediate response */ 281 handleUnsolicited(line); 282 } 283 break; 284 case MULTILINE: 285 if (strStartsWith (line, s_responsePrefix)) { 286 addIntermediate(line); 287 } else { 288 handleUnsolicited(line); 289 } 290 break; 291 292 default: /* this should never be reached */ 293 RLOGE("Unsupported AT command type %d\n", s_type); 294 handleUnsolicited(line); 295 break; 296 } 297 298 pthread_mutex_unlock(&s_commandmutex); 299 } 300 301 302 /** 303 * Returns a pointer to the end of the next line 304 * special-cases the "> " SMS prompt 305 * 306 * returns NULL if there is no complete line 307 */ 308 static char * findNextEOL(char *cur) 309 { 310 if (cur[0] == '>' && cur[1] == ' ' && cur[2] == '\0') { 311 /* SMS prompt character...not \r terminated */ 312 return cur+2; 313 } 314 315 // Find next newline 316 while (*cur != '\0' && *cur != '\r' && *cur != '\n') cur++; 317 318 return *cur == '\0' ? NULL : cur; 319 } 320 321 322 /** 323 * Reads a line from the AT channel, returns NULL on timeout. 324 * Assumes it has exclusive read access to the FD 325 * 326 * This line is valid only until the next call to readline 327 * 328 * This function exists because as of writing, android libc does not 329 * have buffered stdio. 330 */ 331 332 static const char *readline() 333 { 334 ssize_t count; 335 336 char *p_read = NULL; 337 char *p_eol = NULL; 338 char *ret; 339 340 /* this is a little odd. I use *s_ATBufferCur == 0 to 341 * mean "buffer consumed completely". If it points to a character, than 342 * the buffer continues until a \0 343 */ 344 if (*s_ATBufferCur == '\0') { 345 /* empty buffer */ 346 s_ATBufferCur = s_ATBuffer; 347 *s_ATBufferCur = '\0'; 348 p_read = s_ATBuffer; 349 } else { /* *s_ATBufferCur != '\0' */ 350 /* there's data in the buffer from the last read */ 351 352 // skip over leading newlines 353 while (*s_ATBufferCur == '\r' || *s_ATBufferCur == '\n') 354 s_ATBufferCur++; 355 356 p_eol = findNextEOL(s_ATBufferCur); 357 358 if (p_eol == NULL) { 359 /* a partial line. move it up and prepare to read more */ 360 size_t len; 361 362 len = strlen(s_ATBufferCur); 363 364 memmove(s_ATBuffer, s_ATBufferCur, len + 1); 365 p_read = s_ATBuffer + len; 366 s_ATBufferCur = s_ATBuffer; 367 } 368 /* Otherwise, (p_eol !- NULL) there is a complete line */ 369 /* that will be returned the while () loop below */ 370 } 371 372 while (p_eol == NULL) { 373 if (0 == MAX_AT_RESPONSE - (p_read - s_ATBuffer)) { 374 RLOGE("ERROR: Input line exceeded buffer\n"); 375 /* ditch buffer and start over again */ 376 s_ATBufferCur = s_ATBuffer; 377 *s_ATBufferCur = '\0'; 378 p_read = s_ATBuffer; 379 } 380 381 do { 382 count = read(s_fd, p_read, 383 MAX_AT_RESPONSE - (p_read - s_ATBuffer)); 384 } while (count < 0 && errno == EINTR); 385 386 if (count > 0) { 387 AT_DUMP( "<< ", p_read, count ); 388 s_readCount += count; 389 390 p_read[count] = '\0'; 391 392 // skip over leading newlines 393 while (*s_ATBufferCur == '\r' || *s_ATBufferCur == '\n') 394 s_ATBufferCur++; 395 396 p_eol = findNextEOL(s_ATBufferCur); 397 p_read += count; 398 } else if (count <= 0) { 399 /* read error encountered or EOF reached */ 400 if(count == 0) { 401 RLOGD("atchannel: EOF reached"); 402 } else { 403 RLOGD("atchannel: read error %s", strerror(errno)); 404 } 405 return NULL; 406 } 407 } 408 409 /* a full line in the buffer. Place a \0 over the \r and return */ 410 411 ret = s_ATBufferCur; 412 *p_eol = '\0'; 413 s_ATBufferCur = p_eol + 1; /* this will always be <= p_read, */ 414 /* and there will be a \0 at *p_read */ 415 416 RLOGD("AT< %s\n", ret); 417 return ret; 418 } 419 420 421 static void onReaderClosed() 422 { 423 if (s_onReaderClosed != NULL && s_readerClosed == 0) { 424 425 pthread_mutex_lock(&s_commandmutex); 426 427 s_readerClosed = 1; 428 429 pthread_cond_signal(&s_commandcond); 430 431 pthread_mutex_unlock(&s_commandmutex); 432 433 s_onReaderClosed(); 434 } 435 } 436 437 438 static void *readerLoop(void *arg) 439 { 440 for (;;) { 441 const char * line; 442 443 line = readline(); 444 445 if (line == NULL) { 446 break; 447 } 448 449 if(isSMSUnsolicited(line)) { 450 char *line1; 451 const char *line2; 452 453 // The scope of string returned by 'readline()' is valid only 454 // till next call to 'readline()' hence making a copy of line 455 // before calling readline again. 456 line1 = strdup(line); 457 line2 = readline(); 458 459 if (line2 == NULL) { 460 break; 461 } 462 463 if (s_unsolHandler != NULL) { 464 s_unsolHandler (line1, line2); 465 } 466 free(line1); 467 } else { 468 processLine(line); 469 } 470 471 #ifdef HAVE_ANDROID_OS 472 if (s_ackPowerIoctl > 0) { 473 /* acknowledge that bytes have been read and processed */ 474 ioctl(s_fd, OMAP_CSMI_TTY_ACK, &s_readCount); 475 s_readCount = 0; 476 } 477 #endif /*HAVE_ANDROID_OS*/ 478 } 479 480 onReaderClosed(); 481 482 return NULL; 483 } 484 485 /** 486 * Sends string s to the radio with a \r appended. 487 * Returns AT_ERROR_* on error, 0 on success 488 * 489 * This function exists because as of writing, android libc does not 490 * have buffered stdio. 491 */ 492 static int writeline (const char *s) 493 { 494 size_t cur = 0; 495 size_t len = strlen(s); 496 ssize_t written; 497 498 if (s_fd < 0 || s_readerClosed > 0) { 499 return AT_ERROR_CHANNEL_CLOSED; 500 } 501 502 RLOGD("AT> %s\n", s); 503 504 AT_DUMP( ">> ", s, strlen(s) ); 505 506 /* the main string */ 507 while (cur < len) { 508 do { 509 written = write (s_fd, s + cur, len - cur); 510 } while (written < 0 && errno == EINTR); 511 512 if (written < 0) { 513 return AT_ERROR_GENERIC; 514 } 515 516 cur += written; 517 } 518 519 /* the \r */ 520 521 do { 522 written = write (s_fd, "\r" , 1); 523 } while ((written < 0 && errno == EINTR) || (written == 0)); 524 525 if (written < 0) { 526 return AT_ERROR_GENERIC; 527 } 528 529 return 0; 530 } 531 static int writeCtrlZ (const char *s) 532 { 533 size_t cur = 0; 534 size_t len = strlen(s); 535 ssize_t written; 536 537 if (s_fd < 0 || s_readerClosed > 0) { 538 return AT_ERROR_CHANNEL_CLOSED; 539 } 540 541 RLOGD("AT> %s^Z\n", s); 542 543 AT_DUMP( ">* ", s, strlen(s) ); 544 545 /* the main string */ 546 while (cur < len) { 547 do { 548 written = write (s_fd, s + cur, len - cur); 549 } while (written < 0 && errno == EINTR); 550 551 if (written < 0) { 552 return AT_ERROR_GENERIC; 553 } 554 555 cur += written; 556 } 557 558 /* the ^Z */ 559 560 do { 561 written = write (s_fd, "\032" , 1); 562 } while ((written < 0 && errno == EINTR) || (written == 0)); 563 564 if (written < 0) { 565 return AT_ERROR_GENERIC; 566 } 567 568 return 0; 569 } 570 571 static void clearPendingCommand() 572 { 573 if (sp_response != NULL) { 574 at_response_free(sp_response); 575 } 576 577 sp_response = NULL; 578 s_responsePrefix = NULL; 579 s_smsPDU = NULL; 580 } 581 582 583 /** 584 * Starts AT handler on stream "fd' 585 * returns 0 on success, -1 on error 586 */ 587 int at_open(int fd, ATUnsolHandler h) 588 { 589 int ret; 590 pthread_t tid; 591 pthread_attr_t attr; 592 593 s_fd = fd; 594 s_unsolHandler = h; 595 s_readerClosed = 0; 596 597 s_responsePrefix = NULL; 598 s_smsPDU = NULL; 599 sp_response = NULL; 600 601 /* Android power control ioctl */ 602 #ifdef HAVE_ANDROID_OS 603 #ifdef OMAP_CSMI_POWER_CONTROL 604 ret = ioctl(fd, OMAP_CSMI_TTY_ENABLE_ACK); 605 if(ret == 0) { 606 int ack_count; 607 int read_count; 608 int old_flags; 609 char sync_buf[256]; 610 old_flags = fcntl(fd, F_GETFL, 0); 611 fcntl(fd, F_SETFL, old_flags | O_NONBLOCK); 612 do { 613 ioctl(fd, OMAP_CSMI_TTY_READ_UNACKED, &ack_count); 614 read_count = 0; 615 do { 616 ret = read(fd, sync_buf, sizeof(sync_buf)); 617 if(ret > 0) 618 read_count += ret; 619 } while(ret > 0 || (ret < 0 && errno == EINTR)); 620 ioctl(fd, OMAP_CSMI_TTY_ACK, &ack_count); 621 } while(ack_count > 0 || read_count > 0); 622 fcntl(fd, F_SETFL, old_flags); 623 s_readCount = 0; 624 s_ackPowerIoctl = 1; 625 } 626 else 627 s_ackPowerIoctl = 0; 628 629 #else // OMAP_CSMI_POWER_CONTROL 630 s_ackPowerIoctl = 0; 631 632 #endif // OMAP_CSMI_POWER_CONTROL 633 #endif /*HAVE_ANDROID_OS*/ 634 635 pthread_attr_init (&attr); 636 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); 637 638 ret = pthread_create(&s_tid_reader, &attr, readerLoop, &attr); 639 640 if (ret < 0) { 641 perror ("pthread_create"); 642 return -1; 643 } 644 645 646 return 0; 647 } 648 649 /* FIXME is it ok to call this from the reader and the command thread? */ 650 void at_close() 651 { 652 if (s_fd >= 0) { 653 close(s_fd); 654 } 655 s_fd = -1; 656 657 pthread_mutex_lock(&s_commandmutex); 658 659 s_readerClosed = 1; 660 661 pthread_cond_signal(&s_commandcond); 662 663 pthread_mutex_unlock(&s_commandmutex); 664 665 /* the reader thread should eventually die */ 666 } 667 668 static ATResponse * at_response_new() 669 { 670 return (ATResponse *) calloc(1, sizeof(ATResponse)); 671 } 672 673 void at_response_free(ATResponse *p_response) 674 { 675 ATLine *p_line; 676 677 if (p_response == NULL) return; 678 679 p_line = p_response->p_intermediates; 680 681 while (p_line != NULL) { 682 ATLine *p_toFree; 683 684 p_toFree = p_line; 685 p_line = p_line->p_next; 686 687 free(p_toFree->line); 688 free(p_toFree); 689 } 690 691 free (p_response->finalResponse); 692 free (p_response); 693 } 694 695 /** 696 * The line reader places the intermediate responses in reverse order 697 * here we flip them back 698 */ 699 static void reverseIntermediates(ATResponse *p_response) 700 { 701 ATLine *pcur,*pnext; 702 703 pcur = p_response->p_intermediates; 704 p_response->p_intermediates = NULL; 705 706 while (pcur != NULL) { 707 pnext = pcur->p_next; 708 pcur->p_next = p_response->p_intermediates; 709 p_response->p_intermediates = pcur; 710 pcur = pnext; 711 } 712 } 713 714 /** 715 * Internal send_command implementation 716 * Doesn't lock or call the timeout callback 717 * 718 * timeoutMsec == 0 means infinite timeout 719 */ 720 721 static int at_send_command_full_nolock (const char *command, ATCommandType type, 722 const char *responsePrefix, const char *smspdu, 723 long long timeoutMsec, ATResponse **pp_outResponse) 724 { 725 int err = 0; 726 #ifndef USE_NP 727 struct timespec ts; 728 #endif /*USE_NP*/ 729 730 if(sp_response != NULL) { 731 err = AT_ERROR_COMMAND_PENDING; 732 goto error; 733 } 734 735 err = writeline (command); 736 737 if (err < 0) { 738 goto error; 739 } 740 741 s_type = type; 742 s_responsePrefix = responsePrefix; 743 s_smsPDU = smspdu; 744 sp_response = at_response_new(); 745 746 #ifndef USE_NP 747 if (timeoutMsec != 0) { 748 setTimespecRelative(&ts, timeoutMsec); 749 } 750 #endif /*USE_NP*/ 751 752 while (sp_response->finalResponse == NULL && s_readerClosed == 0) { 753 if (timeoutMsec != 0) { 754 #ifdef USE_NP 755 err = pthread_cond_timeout_np(&s_commandcond, &s_commandmutex, timeoutMsec); 756 #else 757 err = pthread_cond_timedwait(&s_commandcond, &s_commandmutex, &ts); 758 #endif /*USE_NP*/ 759 } else { 760 err = pthread_cond_wait(&s_commandcond, &s_commandmutex); 761 } 762 763 if (err == ETIMEDOUT) { 764 err = AT_ERROR_TIMEOUT; 765 goto error; 766 } 767 } 768 769 if (pp_outResponse == NULL) { 770 at_response_free(sp_response); 771 } else { 772 /* line reader stores intermediate responses in reverse order */ 773 reverseIntermediates(sp_response); 774 *pp_outResponse = sp_response; 775 } 776 777 sp_response = NULL; 778 779 if(s_readerClosed > 0) { 780 err = AT_ERROR_CHANNEL_CLOSED; 781 goto error; 782 } 783 784 err = 0; 785 error: 786 clearPendingCommand(); 787 788 return err; 789 } 790 791 /** 792 * Internal send_command implementation 793 * 794 * timeoutMsec == 0 means infinite timeout 795 */ 796 static int at_send_command_full (const char *command, ATCommandType type, 797 const char *responsePrefix, const char *smspdu, 798 long long timeoutMsec, ATResponse **pp_outResponse) 799 { 800 int err; 801 802 if (0 != pthread_equal(s_tid_reader, pthread_self())) { 803 /* cannot be called from reader thread */ 804 return AT_ERROR_INVALID_THREAD; 805 } 806 807 pthread_mutex_lock(&s_commandmutex); 808 809 err = at_send_command_full_nolock(command, type, 810 responsePrefix, smspdu, 811 timeoutMsec, pp_outResponse); 812 813 pthread_mutex_unlock(&s_commandmutex); 814 815 if (err == AT_ERROR_TIMEOUT && s_onTimeout != NULL) { 816 s_onTimeout(); 817 } 818 819 return err; 820 } 821 822 823 /** 824 * Issue a single normal AT command with no intermediate response expected 825 * 826 * "command" should not include \r 827 * pp_outResponse can be NULL 828 * 829 * if non-NULL, the resulting ATResponse * must be eventually freed with 830 * at_response_free 831 */ 832 int at_send_command (const char *command, ATResponse **pp_outResponse) 833 { 834 int err; 835 836 err = at_send_command_full (command, NO_RESULT, NULL, 837 NULL, 0, pp_outResponse); 838 839 return err; 840 } 841 842 843 int at_send_command_singleline (const char *command, 844 const char *responsePrefix, 845 ATResponse **pp_outResponse) 846 { 847 int err; 848 849 err = at_send_command_full (command, SINGLELINE, responsePrefix, 850 NULL, 0, pp_outResponse); 851 852 if (err == 0 && pp_outResponse != NULL 853 && (*pp_outResponse)->success > 0 854 && (*pp_outResponse)->p_intermediates == NULL 855 ) { 856 /* successful command must have an intermediate response */ 857 at_response_free(*pp_outResponse); 858 *pp_outResponse = NULL; 859 return AT_ERROR_INVALID_RESPONSE; 860 } 861 862 return err; 863 } 864 865 866 int at_send_command_numeric (const char *command, 867 ATResponse **pp_outResponse) 868 { 869 int err; 870 871 err = at_send_command_full (command, NUMERIC, NULL, 872 NULL, 0, pp_outResponse); 873 874 if (err == 0 && pp_outResponse != NULL 875 && (*pp_outResponse)->success > 0 876 && (*pp_outResponse)->p_intermediates == NULL 877 ) { 878 /* successful command must have an intermediate response */ 879 at_response_free(*pp_outResponse); 880 *pp_outResponse = NULL; 881 return AT_ERROR_INVALID_RESPONSE; 882 } 883 884 return err; 885 } 886 887 888 int at_send_command_sms (const char *command, 889 const char *pdu, 890 const char *responsePrefix, 891 ATResponse **pp_outResponse) 892 { 893 int err; 894 895 err = at_send_command_full (command, SINGLELINE, responsePrefix, 896 pdu, 0, pp_outResponse); 897 898 if (err == 0 && pp_outResponse != NULL 899 && (*pp_outResponse)->success > 0 900 && (*pp_outResponse)->p_intermediates == NULL 901 ) { 902 /* successful command must have an intermediate response */ 903 at_response_free(*pp_outResponse); 904 *pp_outResponse = NULL; 905 return AT_ERROR_INVALID_RESPONSE; 906 } 907 908 return err; 909 } 910 911 912 int at_send_command_multiline (const char *command, 913 const char *responsePrefix, 914 ATResponse **pp_outResponse) 915 { 916 int err; 917 918 err = at_send_command_full (command, MULTILINE, responsePrefix, 919 NULL, 0, pp_outResponse); 920 921 return err; 922 } 923 924 925 /** This callback is invoked on the command thread */ 926 void at_set_on_timeout(void (*onTimeout)(void)) 927 { 928 s_onTimeout = onTimeout; 929 } 930 931 /** 932 * This callback is invoked on the reader thread (like ATUnsolHandler) 933 * when the input stream closes before you call at_close 934 * (not when you call at_close()) 935 * You should still call at_close() 936 */ 937 938 void at_set_on_reader_closed(void (*onClose)(void)) 939 { 940 s_onReaderClosed = onClose; 941 } 942 943 944 /** 945 * Periodically issue an AT command and wait for a response. 946 * Used to ensure channel has start up and is active 947 */ 948 949 int at_handshake() 950 { 951 int i; 952 int err = 0; 953 954 if (0 != pthread_equal(s_tid_reader, pthread_self())) { 955 /* cannot be called from reader thread */ 956 return AT_ERROR_INVALID_THREAD; 957 } 958 959 pthread_mutex_lock(&s_commandmutex); 960 961 for (i = 0 ; i < HANDSHAKE_RETRY_COUNT ; i++) { 962 /* some stacks start with verbose off */ 963 err = at_send_command_full_nolock ("ATE0Q0V1", NO_RESULT, 964 NULL, NULL, HANDSHAKE_TIMEOUT_MSEC, NULL); 965 966 if (err == 0) { 967 break; 968 } 969 } 970 971 if (err == 0) { 972 /* pause for a bit to let the input buffer drain any unmatched OK's 973 (they will appear as extraneous unsolicited responses) */ 974 975 sleepMsec(HANDSHAKE_TIMEOUT_MSEC); 976 } 977 978 pthread_mutex_unlock(&s_commandmutex); 979 980 return err; 981 } 982 983 /** 984 * Returns error code from response 985 * Assumes AT+CMEE=1 (numeric) mode 986 */ 987 AT_CME_Error at_get_cme_error(const ATResponse *p_response) 988 { 989 int ret; 990 int err; 991 char *p_cur; 992 993 if (p_response->success > 0) { 994 return CME_SUCCESS; 995 } 996 997 if (p_response->finalResponse == NULL 998 || !strStartsWith(p_response->finalResponse, "+CME ERROR:") 999 ) { 1000 return CME_ERROR_NON_CME; 1001 } 1002 1003 p_cur = p_response->finalResponse; 1004 err = at_tok_start(&p_cur); 1005 1006 if (err < 0) { 1007 return CME_ERROR_NON_CME; 1008 } 1009 1010 err = at_tok_nextint(&p_cur, &ret); 1011 1012 if (err < 0) { 1013 return CME_ERROR_NON_CME; 1014 } 1015 1016 return (AT_CME_Error) ret; 1017 } 1018 1019
