reference-ril/atchannel.c

   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