reference-ril/reference-ril.c

   1 /* //device/system/reference-ril/reference-ril.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 <telephony/ril.h>
  19 #include <stdio.h>
  20 #include <assert.h>
  21 #include <string.h>
  22 #include <errno.h>
  23 #include <unistd.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <pthread.h>
  28 #include <alloca.h>
  29 #include "atchannel.h"
  30 #include "at_tok.h"
  31 #include "misc.h"
  32 #include <getopt.h>
  33 #include <sys/socket.h>
  34 #include <cutils/sockets.h>
  35 #include <termios.h>
  36
  37 #define LOG_TAG "RIL"
  38 #include <utils/Log.h>
  39
  40 #define MAX_AT_RESPONSE 0x1000
  41
  42 /* pathname returned from RIL_REQUEST_SETUP_DATA_CALL / RIL_REQUEST_SETUP_DEFAULT_PDP */
  43 #define PPP_TTY_PATH "/dev/omap_csmi_tty1"
  44
  45 #ifdef USE_TI_COMMANDS
  46
  47 // Enable a workaround
  48 // 1) Make incoming call, do not answer
  49 // 2) Hangup remote end
  50 // Expected: call should disappear from CLCC line
  51 // Actual: Call shows as "ACTIVE" before disappearing
  52 #define WORKAROUND_ERRONEOUS_ANSWER 1
  53
  54 // Some varients of the TI stack do not support the +CGEV unsolicited
  55 // response. However, they seem to send an unsolicited +CME ERROR: 150
  56 #define WORKAROUND_FAKE_CGEV 1
  57 #endif
  58
  59 typedef enum {
  60     SIM_ABSENT = 0,
  61     SIM_NOT_READY = 1,
  62     SIM_READY = 2, /* SIM_READY means the radio state is RADIO_STATE_SIM_READY */
  63     SIM_PIN = 3,
  64     SIM_PUK = 4,
  65     SIM_NETWORK_PERSONALIZATION = 5
  66 } SIM_Status;
  67
  68 static void onRequest (int request, void *data, size_t datalen, RIL_Token t);
  69 static RIL_RadioState currentState();
  70 static int onSupports (int requestCode);
  71 static void onCancel (RIL_Token t);
  72 static const char *getVersion();
  73 static int isRadioOn();
  74 static SIM_Status getSIMStatus();
  75 static int getCardStatus(RIL_CardStatus **pp_card_status);
  76 static void freeCardStatus(RIL_CardStatus *p_card_status);
  77 static void onDataCallListChanged(void *param);
  78
  79 extern const char * requestToString(int request);
  80
  81 /*** Static Variables ***/
  82 static const RIL_RadioFunctions s_callbacks = {
  83     RIL_VERSION,
  84     onRequest,
  85     currentState,
  86     onSupports,
  87     onCancel,
  88     getVersion
  89 };
  90
  91 #ifdef RIL_SHLIB
  92 static const struct RIL_Env *s_rilenv;
  93
  94 #define RIL_onRequestComplete(t, e, response, responselen) s_rilenv->OnRequestComplete(t,e, response, responselen)
  95 #define RIL_onUnsolicitedResponse(a,b,c) s_rilenv->OnUnsolicitedResponse(a,b,c)
  96 #define RIL_requestTimedCallback(a,b,c) s_rilenv->RequestTimedCallback(a,b,c)
  97 #endif
  98
  99 static RIL_RadioState sState = RADIO_STATE_UNAVAILABLE;
 100
 101 static pthread_mutex_t s_state_mutex = PTHREAD_MUTEX_INITIALIZER;
 102 static pthread_cond_t s_state_cond = PTHREAD_COND_INITIALIZER;
 103
 104 static int s_port = -1;
 105 static const char * s_device_path = NULL;
 106 static int          s_device_socket = 0;
 107
 108 /* trigger change to this with s_state_cond */
 109 static int s_closed = 0;
 110
 111 static int sFD;     /* file desc of AT channel */
 112 static char sATBuffer[MAX_AT_RESPONSE+1];
 113 static char *sATBufferCur = NULL;
 114
 115 static const struct timeval TIMEVAL_SIMPOLL = {1,0};
 116 static const struct timeval TIMEVAL_CALLSTATEPOLL = {0,500000};
 117 static const struct timeval TIMEVAL_0 = {0,0};
 118
 119 #ifdef WORKAROUND_ERRONEOUS_ANSWER
 120 // Max number of times we'll try to repoll when we think
 121 // we have a AT+CLCC race condition
 122 #define REPOLL_CALLS_COUNT_MAX 4
 123
 124 // Line index that was incoming or waiting at last poll, or -1 for none
 125 static int s_incomingOrWaitingLine = -1;
 126 // Number of times we've asked for a repoll of AT+CLCC
 127 static int s_repollCallsCount = 0;
 128 // Should we expect a call to be answered in the next CLCC?
 129 static int s_expectAnswer = 0;
 130 #endif /* WORKAROUND_ERRONEOUS_ANSWER */
 131
 132 static void pollSIMState (void *param);
 133 static void setRadioState(RIL_RadioState newState);
 134
 135 static int clccStateToRILState(int state, RIL_CallState *p_state)
 136
 137 {
 138     switch(state) {
 139         case 0: *p_state = RIL_CALL_ACTIVE;   return 0;
 140         case 1: *p_state = RIL_CALL_HOLDING;  return 0;
 141         case 2: *p_state = RIL_CALL_DIALING;  return 0;
 142         case 3: *p_state = RIL_CALL_ALERTING; return 0;
 143         case 4: *p_state = RIL_CALL_INCOMING; return 0;
 144         case 5: *p_state = RIL_CALL_WAITING;  return 0;
 145         default: return -1;
 146     }
 147 }
 148
 149 /**
 150  * Note: directly modified line and has *p_call point directly into
 151  * modified line
 152  */
 153 static int callFromCLCCLine(char *line, RIL_Call *p_call)
 154 {
 155         //+CLCC: 1,0,2,0,0,\"+18005551212\",145
 156         //     index,isMT,state,mode,isMpty(,number,TOA)?
 157
 158     int err;
 159     int state;
 160     int mode;
 161
 162     err = at_tok_start(&line);
 163     if (err < 0) goto error;
 164
 165     err = at_tok_nextint(&line, &(p_call->index));
 166     if (err < 0) goto error;
 167
 168     err = at_tok_nextbool(&line, &(p_call->isMT));
 169     if (err < 0) goto error;
 170
 171     err = at_tok_nextint(&line, &state);
 172     if (err < 0) goto error;
 173
 174     err = clccStateToRILState(state, &(p_call->state));
 175     if (err < 0) goto error;
 176
 177     err = at_tok_nextint(&line, &mode);
 178     if (err < 0) goto error;
 179
 180     p_call->isVoice = (mode == 0);
 181
 182     err = at_tok_nextbool(&line, &(p_call->isMpty));
 183     if (err < 0) goto error;
 184
 185     if (at_tok_hasmore(&line)) {
 186         err = at_tok_nextstr(&line, &(p_call->number));
 187
 188         /* tolerate null here */
 189         if (err < 0) return 0;
 190
 191         // Some lame implementations return strings
 192         // like "NOT AVAILABLE" in the CLCC line
 193         if (p_call->number != NULL
 194             && 0 == strspn(p_call->number, "+0123456789")
 195         ) {
 196             p_call->number = NULL;
 197         }
 198
 199         err = at_tok_nextint(&line, &p_call->toa);
 200         if (err < 0) goto error;
 201     }
 202
 203     p_call->uusInfo = NULL;
 204
 205     return 0;
 206
 207 error:
 208     LOGE("invalid CLCC line\n");
 209     return -1;
 210 }
 211
 212
 213 /** do post-AT+CFUN=1 initialization */
 214 static void onRadioPowerOn()
 215 {
 216 #ifdef USE_TI_COMMANDS
 217     /*  Must be after CFUN=1 */
 218     /*  TI specific -- notifications for CPHS things such */
 219     /*  as CPHS message waiting indicator */
 220
 221     at_send_command("AT%CPHS=1", NULL);
 222
 223     /*  TI specific -- enable NITZ unsol notifs */
 224     at_send_command("AT%CTZV=1", NULL);
 225 #endif
 226
 227     pollSIMState(NULL);
 228 }
 229
 230 /** do post- SIM ready initialization */
 231 static void onSIMReady()
 232 {
 233     at_send_command_singleline("AT+CSMS=1", "+CSMS:", NULL);
 234     /*
 235      * Always send SMS messages directly to the TE
 236      *
 237      * mode = 1 // discard when link is reserved (link should never be
 238      *             reserved)
 239      * mt = 2   // most messages routed to TE
 240      * bm = 2   // new cell BM's routed to TE
 241      * ds = 1   // Status reports routed to TE
 242      * bfr = 1  // flush buffer
 243      */
 244     at_send_command("AT+CNMI=1,2,2,1,1", NULL);
 245 }
 246
 247 static void requestRadioPower(void *data, size_t datalen, RIL_Token t)
 248 {
 249     int onOff;
 250
 251     int err;
 252     ATResponse *p_response = NULL;
 253
 254     assert (datalen >= sizeof(int *));
 255     onOff = ((int *)data)[0];
 256
 257     if (onOff == 0 && sState != RADIO_STATE_OFF) {
 258         err = at_send_command("AT+CFUN=0", &p_response);
 259        if (err < 0 || p_response->success == 0) goto error;
 260         setRadioState(RADIO_STATE_OFF);
 261     } else if (onOff > 0 && sState == RADIO_STATE_OFF) {
 262         err = at_send_command("AT+CFUN=1", &p_response);
 263         if (err < 0|| p_response->success == 0) {
 264             // Some stacks return an error when there is no SIM,
 265             // but they really turn the RF portion on
 266             // So, if we get an error, let's check to see if it
 267             // turned on anyway
 268
 269             if (isRadioOn() != 1) {
 270                 goto error;
 271             }
 272         }
 273         setRadioState(RADIO_STATE_SIM_NOT_READY);
 274     }
 275
 276     at_response_free(p_response);
 277     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 278     return;
 279 error:
 280     at_response_free(p_response);
 281     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 282 }
 283
 284 static void requestOrSendDataCallList(RIL_Token *t);
 285
 286 static void onDataCallListChanged(void *param)
 287 {
 288     requestOrSendDataCallList(NULL);
 289 }
 290
 291 static void requestDataCallList(void *data, size_t datalen, RIL_Token t)
 292 {
 293     requestOrSendDataCallList(&t);
 294 }
 295
 296 static void requestOrSendDataCallList(RIL_Token *t)
 297 {
 298     ATResponse *p_response;
 299     ATLine *p_cur;
 300     int err;
 301     int n = 0;
 302     char *out;
 303
 304     err = at_send_command_multiline ("AT+CGACT?", "+CGACT:", &p_response);
 305     if (err != 0 || p_response->success == 0) {
 306         if (t != NULL)
 307             RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0);
 308         else
 309             RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED,
 310                                       NULL, 0);
 311         return;
 312     }
 313
 314     for (p_cur = p_response->p_intermediates; p_cur != NULL;
 315          p_cur = p_cur->p_next)
 316         n++;
 317
 318     RIL_Data_Call_Response *responses =
 319         alloca(n * sizeof(RIL_Data_Call_Response));
 320
 321     int i;
 322     for (i = 0; i < n; i++) {
 323         responses[i].cid = -1;
 324         responses[i].active = -1;
 325         responses[i].type = "";
 326         responses[i].apn = "";
 327         responses[i].address = "";
 328     }
 329
 330     RIL_Data_Call_Response *response = responses;
 331     for (p_cur = p_response->p_intermediates; p_cur != NULL;
 332          p_cur = p_cur->p_next) {
 333         char *line = p_cur->line;
 334
 335         err = at_tok_start(&line);
 336         if (err < 0)
 337             goto error;
 338
 339         err = at_tok_nextint(&line, &response->cid);
 340         if (err < 0)
 341             goto error;
 342
 343         err = at_tok_nextint(&line, &response->active);
 344         if (err < 0)
 345             goto error;
 346
 347         response++;
 348     }
 349
 350     at_response_free(p_response);
 351
 352     err = at_send_command_multiline ("AT+CGDCONT?", "+CGDCONT:", &p_response);
 353     if (err != 0 || p_response->success == 0) {
 354         if (t != NULL)
 355             RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0);
 356         else
 357             RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED,
 358                                       NULL, 0);
 359         return;
 360     }
 361
 362     for (p_cur = p_response->p_intermediates; p_cur != NULL;
 363          p_cur = p_cur->p_next) {
 364         char *line = p_cur->line;
 365         int cid;
 366         char *type;
 367         char *apn;
 368         char *address;
 369
 370
 371         err = at_tok_start(&line);
 372         if (err < 0)
 373             goto error;
 374
 375         err = at_tok_nextint(&line, &cid);
 376         if (err < 0)
 377             goto error;
 378
 379         for (i = 0; i < n; i++) {
 380             if (responses[i].cid == cid)
 381                 break;
 382         }
 383
 384         if (i >= n) {
 385             /* details for a context we didn't hear about in the last request */
 386             continue;
 387         }
 388
 389         err = at_tok_nextstr(&line, &out);
 390         if (err < 0)
 391             goto error;
 392
 393         responses[i].type = alloca(strlen(out) + 1);
 394         strcpy(responses[i].type, out);
 395
 396         err = at_tok_nextstr(&line, &out);
 397         if (err < 0)
 398             goto error;
 399
 400         responses[i].apn = alloca(strlen(out) + 1);
 401         strcpy(responses[i].apn, out);
 402
 403         err = at_tok_nextstr(&line, &out);
 404         if (err < 0)
 405             goto error;
 406
 407         responses[i].address = alloca(strlen(out) + 1);
 408         strcpy(responses[i].address, out);
 409     }
 410
 411     at_response_free(p_response);
 412
 413     if (t != NULL)
 414         RIL_onRequestComplete(*t, RIL_E_SUCCESS, responses,
 415                               n * sizeof(RIL_Data_Call_Response));
 416     else
 417         RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED,
 418                                   responses,
 419                                   n * sizeof(RIL_Data_Call_Response));
 420
 421     return;
 422
 423 error:
 424     if (t != NULL)
 425         RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0);
 426     else
 427         RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED,
 428                                   NULL, 0);
 429
 430     at_response_free(p_response);
 431 }
 432
 433 static void requestQueryNetworkSelectionMode(
 434                 void *data, size_t datalen, RIL_Token t)
 435 {
 436     int err;
 437     ATResponse *p_response = NULL;
 438     int response = 0;
 439     char *line;
 440
 441     err = at_send_command_singleline("AT+COPS?", "+COPS:", &p_response);
 442
 443     if (err < 0 || p_response->success == 0) {
 444         goto error;
 445     }
 446
 447     line = p_response->p_intermediates->line;
 448
 449     err = at_tok_start(&line);
 450
 451     if (err < 0) {
 452         goto error;
 453     }
 454
 455     err = at_tok_nextint(&line, &response);
 456
 457     if (err < 0) {
 458         goto error;
 459     }
 460
 461     RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(int));
 462     at_response_free(p_response);
 463     return;
 464 error:
 465     at_response_free(p_response);
 466     LOGE("requestQueryNetworkSelectionMode must never return error when radio is on");
 467     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 468 }
 469
 470 static void sendCallStateChanged(void *param)
 471 {
 472     RIL_onUnsolicitedResponse (
 473         RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED,
 474         NULL, 0);
 475 }
 476
 477 static void requestGetCurrentCalls(void *data, size_t datalen, RIL_Token t)
 478 {
 479     int err;
 480     ATResponse *p_response;
 481     ATLine *p_cur;
 482     int countCalls;
 483     int countValidCalls;
 484     RIL_Call *p_calls;
 485     RIL_Call **pp_calls;
 486     int i;
 487     int needRepoll = 0;
 488
 489 #ifdef WORKAROUND_ERRONEOUS_ANSWER
 490     int prevIncomingOrWaitingLine;
 491
 492     prevIncomingOrWaitingLine = s_incomingOrWaitingLine;
 493     s_incomingOrWaitingLine = -1;
 494 #endif /*WORKAROUND_ERRONEOUS_ANSWER*/
 495
 496     err = at_send_command_multiline ("AT+CLCC", "+CLCC:", &p_response);
 497
 498     if (err != 0 || p_response->success == 0) {
 499         RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 500         return;
 501     }
 502
 503     /* count the calls */
 504     for (countCalls = 0, p_cur = p_response->p_intermediates
 505             ; p_cur != NULL
 506             ; p_cur = p_cur->p_next
 507     ) {
 508         countCalls++;
 509     }
 510
 511     /* yes, there's an array of pointers and then an array of structures */
 512
 513     pp_calls = (RIL_Call **)alloca(countCalls * sizeof(RIL_Call *));
 514     p_calls = (RIL_Call *)alloca(countCalls * sizeof(RIL_Call));
 515     memset (p_calls, 0, countCalls * sizeof(RIL_Call));
 516
 517     /* init the pointer array */
 518     for(i = 0; i < countCalls ; i++) {
 519         pp_calls[i] = &(p_calls[i]);
 520     }
 521
 522     for (countValidCalls = 0, p_cur = p_response->p_intermediates
 523             ; p_cur != NULL
 524             ; p_cur = p_cur->p_next
 525     ) {
 526         err = callFromCLCCLine(p_cur->line, p_calls + countValidCalls);
 527
 528         if (err != 0) {
 529             continue;
 530         }
 531
 532 #ifdef WORKAROUND_ERRONEOUS_ANSWER
 533         if (p_calls[countValidCalls].state == RIL_CALL_INCOMING
 534             || p_calls[countValidCalls].state == RIL_CALL_WAITING
 535         ) {
 536             s_incomingOrWaitingLine = p_calls[countValidCalls].index;
 537         }
 538 #endif /*WORKAROUND_ERRONEOUS_ANSWER*/
 539
 540         if (p_calls[countValidCalls].state != RIL_CALL_ACTIVE
 541             && p_calls[countValidCalls].state != RIL_CALL_HOLDING
 542         ) {
 543             needRepoll = 1;
 544         }
 545
 546         countValidCalls++;
 547     }
 548
 549 #ifdef WORKAROUND_ERRONEOUS_ANSWER
 550     // Basically:
 551     // A call was incoming or waiting
 552     // Now it's marked as active
 553     // But we never answered it
 554     //
 555     // This is probably a bug, and the call will probably
 556     // disappear from the call list in the next poll
 557     if (prevIncomingOrWaitingLine >= 0
 558             && s_incomingOrWaitingLine < 0
 559             && s_expectAnswer == 0
 560     ) {
 561         for (i = 0; i < countValidCalls ; i++) {
 562
 563             if (p_calls[i].index == prevIncomingOrWaitingLine
 564                     && p_calls[i].state == RIL_CALL_ACTIVE
 565                     && s_repollCallsCount < REPOLL_CALLS_COUNT_MAX
 566             ) {
 567                 LOGI(
 568                     "Hit WORKAROUND_ERRONOUS_ANSWER case."
 569                     " Repoll count: %d\n", s_repollCallsCount);
 570                 s_repollCallsCount++;
 571                 goto error;
 572             }
 573         }
 574     }
 575
 576     s_expectAnswer = 0;
 577     s_repollCallsCount = 0;
 578 #endif /*WORKAROUND_ERRONEOUS_ANSWER*/
 579
 580     RIL_onRequestComplete(t, RIL_E_SUCCESS, pp_calls,
 581             countValidCalls * sizeof (RIL_Call *));
 582
 583     at_response_free(p_response);
 584
 585 #ifdef POLL_CALL_STATE
 586     if (countValidCalls) {  // We don't seem to get a "NO CARRIER" message from
 587                             // smd, so we're forced to poll until the call ends.
 588 #else
 589     if (needRepoll) {
 590 #endif
 591         RIL_requestTimedCallback (sendCallStateChanged, NULL, &TIMEVAL_CALLSTATEPOLL);
 592     }
 593
 594     return;
 595 error:
 596     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 597     at_response_free(p_response);
 598 }
 599
 600 static void requestDial(void *data, size_t datalen, RIL_Token t)
 601 {
 602     RIL_Dial *p_dial;
 603     char *cmd;
 604     const char *clir;
 605     int ret;
 606
 607     p_dial = (RIL_Dial *)data;
 608
 609     switch (p_dial->clir) {
 610         case 1: clir = "I"; break;  /*invocation*/
 611         case 2: clir = "i"; break;  /*suppression*/
 612         default:
 613         case 0: clir = ""; break;   /*subscription default*/
 614     }
 615
 616     asprintf(&cmd, "ATD%s%s;", p_dial->address, clir);
 617
 618     ret = at_send_command(cmd, NULL);
 619
 620     free(cmd);
 621
 622     /* success or failure is ignored by the upper layer here.
 623        it will call GET_CURRENT_CALLS and determine success that way */
 624     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 625 }
 626
 627 static void requestWriteSmsToSim(void *data, size_t datalen, RIL_Token t)
 628 {
 629     RIL_SMS_WriteArgs *p_args;
 630     char *cmd;
 631     int length;
 632     int err;
 633     ATResponse *p_response = NULL;
 634
 635     p_args = (RIL_SMS_WriteArgs *)data;
 636
 637     length = strlen(p_args->pdu)/2;
 638     asprintf(&cmd, "AT+CMGW=%d,%d", length, p_args->status);
 639
 640     err = at_send_command_sms(cmd, p_args->pdu, "+CMGW:", &p_response);
 641
 642     if (err != 0 || p_response->success == 0) goto error;
 643
 644     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 645     at_response_free(p_response);
 646
 647     return;
 648 error:
 649     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 650     at_response_free(p_response);
 651 }
 652
 653 static void requestHangup(void *data, size_t datalen, RIL_Token t)
 654 {
 655     int *p_line;
 656
 657     int ret;
 658     char *cmd;
 659
 660     p_line = (int *)data;
 661
 662     // 3GPP 22.030 6.5.5
 663     // "Releases a specific active call X"
 664     asprintf(&cmd, "AT+CHLD=1%d", p_line[0]);
 665
 666     ret = at_send_command(cmd, NULL);
 667
 668     free(cmd);
 669
 670     /* success or failure is ignored by the upper layer here.
 671        it will call GET_CURRENT_CALLS and determine success that way */
 672     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 673 }
 674
 675 static void requestSignalStrength(void *data, size_t datalen, RIL_Token t)
 676 {
 677     ATResponse *p_response = NULL;
 678     int err;
 679     int response[2];
 680     char *line;
 681
 682     err = at_send_command_singleline("AT+CSQ", "+CSQ:", &p_response);
 683
 684     if (err < 0 || p_response->success == 0) {
 685         RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 686         goto error;
 687     }
 688
 689     line = p_response->p_intermediates->line;
 690
 691     err = at_tok_start(&line);
 692     if (err < 0) goto error;
 693
 694     err = at_tok_nextint(&line, &(response[0]));
 695     if (err < 0) goto error;
 696
 697     err = at_tok_nextint(&line, &(response[1]));
 698     if (err < 0) goto error;
 699
 700     RIL_onRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response));
 701
 702     at_response_free(p_response);
 703     return;
 704
 705 error:
 706     LOGE("requestSignalStrength must never return an error when radio is on");
 707     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 708     at_response_free(p_response);
 709 }
 710
 711 static void requestRegistrationState(int request, void *data,
 712                                         size_t datalen, RIL_Token t)
 713 {
 714     int err;
 715     int response[4];
 716     char * responseStr[4];
 717     ATResponse *p_response = NULL;
 718     const char *cmd;
 719     const char *prefix;
 720     char *line, *p;
 721     int commas;
 722     int skip;
 723     int count = 3;
 724
 725
 726     if (request == RIL_REQUEST_REGISTRATION_STATE) {
 727         cmd = "AT+CREG?";
 728         prefix = "+CREG:";
 729     } else if (request == RIL_REQUEST_GPRS_REGISTRATION_STATE) {
 730         cmd = "AT+CGREG?";
 731         prefix = "+CGREG:";
 732     } else {
 733         assert(0);
 734         goto error;
 735     }
 736
 737     err = at_send_command_singleline(cmd, prefix, &p_response);
 738
 739     if (err != 0) goto error;
 740
 741     line = p_response->p_intermediates->line;
 742
 743     err = at_tok_start(&line);
 744     if (err < 0) goto error;
 745
 746     /* Ok you have to be careful here
 747      * The solicited version of the CREG response is
 748      * +CREG: n, stat, [lac, cid]
 749      * and the unsolicited version is
 750      * +CREG: stat, [lac, cid]
 751      * The <n> parameter is basically "is unsolicited creg on?"
 752      * which it should always be
 753      *
 754      * Now we should normally get the solicited version here,
 755      * but the unsolicited version could have snuck in
 756      * so we have to handle both
 757      *
 758      * Also since the LAC and CID are only reported when registered,
 759      * we can have 1, 2, 3, or 4 arguments here
 760      *
 761      * finally, a +CGREG: answer may have a fifth value that corresponds
 762      * to the network type, as in;
 763      *
 764      *   +CGREG: n, stat [,lac, cid [,networkType]]
 765      */
 766
 767     /* count number of commas */
 768     commas = 0;
 769     for (p = line ; *p != '\0' ;p++) {
 770         if (*p == ',') commas++;
 771     }
 772
 773     switch (commas) {
 774         case 0: /* +CREG: <stat> */
 775             err = at_tok_nextint(&line, &response[0]);
 776             if (err < 0) goto error;
 777             response[1] = -1;
 778             response[2] = -1;
 779         break;
 780
 781         case 1: /* +CREG: <n>, <stat> */
 782             err = at_tok_nextint(&line, &skip);
 783             if (err < 0) goto error;
 784             err = at_tok_nextint(&line, &response[0]);
 785             if (err < 0) goto error;
 786             response[1] = -1;
 787             response[2] = -1;
 788             if (err < 0) goto error;
 789         break;
 790
 791         case 2: /* +CREG: <stat>, <lac>, <cid> */
 792             err = at_tok_nextint(&line, &response[0]);
 793             if (err < 0) goto error;
 794             err = at_tok_nexthexint(&line, &response[1]);
 795             if (err < 0) goto error;
 796             err = at_tok_nexthexint(&line, &response[2]);
 797             if (err < 0) goto error;
 798         break;
 799         case 3: /* +CREG: <n>, <stat>, <lac>, <cid> */
 800             err = at_tok_nextint(&line, &skip);
 801             if (err < 0) goto error;
 802             err = at_tok_nextint(&line, &response[0]);
 803             if (err < 0) goto error;
 804             err = at_tok_nexthexint(&line, &response[1]);
 805             if (err < 0) goto error;
 806             err = at_tok_nexthexint(&line, &response[2]);
 807             if (err < 0) goto error;
 808         break;
 809         /* special case for CGREG, there is a fourth parameter
 810          * that is the network type (unknown/gprs/edge/umts)
 811          */
 812         case 4: /* +CGREG: <n>, <stat>, <lac>, <cid>, <networkType> */
 813             err = at_tok_nextint(&line, &skip);
 814             if (err < 0) goto error;
 815             err = at_tok_nextint(&line, &response[0]);
 816             if (err < 0) goto error;
 817             err = at_tok_nexthexint(&line, &response[1]);
 818             if (err < 0) goto error;
 819             err = at_tok_nexthexint(&line, &response[2]);
 820             if (err < 0) goto error;
 821             err = at_tok_nexthexint(&line, &response[3]);
 822             if (err < 0) goto error;
 823             count = 4;
 824         break;
 825         default:
 826             goto error;
 827     }
 828
 829     asprintf(&responseStr[0], "%d", response[0]);
 830     asprintf(&responseStr[1], "%x", response[1]);
 831     asprintf(&responseStr[2], "%x", response[2]);
 832
 833     if (count > 3)
 834         asprintf(&responseStr[3], "%d", response[3]);
 835
 836     RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, count*sizeof(char*));
 837     at_response_free(p_response);
 838
 839     return;
 840 error:
 841     LOGE("requestRegistrationState must never return an error when radio is on");
 842     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 843     at_response_free(p_response);
 844 }
 845
 846 static void requestOperator(void *data, size_t datalen, RIL_Token t)
 847 {
 848     int err;
 849     int i;
 850     int skip;
 851     ATLine *p_cur;
 852     char *response[3];
 853
 854     memset(response, 0, sizeof(response));
 855
 856     ATResponse *p_response = NULL;
 857
 858     err = at_send_command_multiline(
 859         "AT+COPS=3,0;+COPS?;+COPS=3,1;+COPS?;+COPS=3,2;+COPS?",
 860         "+COPS:", &p_response);
 861
 862     /* we expect 3 lines here:
 863      * +COPS: 0,0,"T - Mobile"
 864      * +COPS: 0,1,"TMO"
 865      * +COPS: 0,2,"310170"
 866      */
 867
 868     if (err != 0) goto error;
 869
 870     for (i = 0, p_cur = p_response->p_intermediates
 871             ; p_cur != NULL
 872             ; p_cur = p_cur->p_next, i++
 873     ) {
 874         char *line = p_cur->line;
 875
 876         err = at_tok_start(&line);
 877         if (err < 0) goto error;
 878
 879         err = at_tok_nextint(&line, &skip);
 880         if (err < 0) goto error;
 881
 882         // If we're unregistered, we may just get
 883         // a "+COPS: 0" response
 884         if (!at_tok_hasmore(&line)) {
 885             response[i] = NULL;
 886             continue;
 887         }
 888
 889         err = at_tok_nextint(&line, &skip);
 890         if (err < 0) goto error;
 891
 892         // a "+COPS: 0, n" response is also possible
 893         if (!at_tok_hasmore(&line)) {
 894             response[i] = NULL;
 895             continue;
 896         }
 897
 898         err = at_tok_nextstr(&line, &(response[i]));
 899         if (err < 0) goto error;
 900     }
 901
 902     if (i != 3) {
 903         /* expect 3 lines exactly */
 904         goto error;
 905     }
 906
 907     RIL_onRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response));
 908     at_response_free(p_response);
 909
 910     return;
 911 error:
 912     LOGE("requestOperator must not return error when radio is on");
 913     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 914     at_response_free(p_response);
 915 }
 916
 917 static void requestSendSMS(void *data, size_t datalen, RIL_Token t)
 918 {
 919     int err;
 920     const char *smsc;
 921     const char *pdu;
 922     int tpLayerLength;
 923     char *cmd1, *cmd2;
 924     RIL_SMS_Response response;
 925     ATResponse *p_response = NULL;
 926
 927     smsc = ((const char **)data)[0];
 928     pdu = ((const char **)data)[1];
 929
 930     tpLayerLength = strlen(pdu)/2;
 931
 932     // "NULL for default SMSC"
 933     if (smsc == NULL) {
 934         smsc= "00";
 935     }
 936
 937     asprintf(&cmd1, "AT+CMGS=%d", tpLayerLength);
 938     asprintf(&cmd2, "%s%s", smsc, pdu);
 939
 940     err = at_send_command_sms(cmd1, cmd2, "+CMGS:", &p_response);
 941
 942     if (err != 0 || p_response->success == 0) goto error;
 943
 944     memset(&response, 0, sizeof(response));
 945
 946     /* FIXME fill in messageRef and ackPDU */
 947
 948     RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response));
 949     at_response_free(p_response);
 950
 951     return;
 952 error:
 953     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 954     at_response_free(p_response);
 955 }
 956
 957 static void requestSetupDataCall(void *data, size_t datalen, RIL_Token t)
 958 {
 959     const char *apn;
 960     char *cmd;
 961     int err;
 962     ATResponse *p_response = NULL;
 963     char *response[2] = { "1", PPP_TTY_PATH };
 964
 965     apn = ((const char **)data)[2];
 966
 967 #ifdef USE_TI_COMMANDS
 968     // Config for multislot class 10 (probably default anyway eh?)
 969     err = at_send_command("AT%CPRIM=\"GMM\",\"CONFIG MULTISLOT_CLASS=<10>\"",
 970                         NULL);
 971
 972     err = at_send_command("AT%DATA=2,\"UART\",1,,\"SER\",\"UART\",0", NULL);
 973 #endif /* USE_TI_COMMANDS */
 974
 975     int fd, qmistatus;
 976     size_t cur = 0;
 977     size_t len;
 978     ssize_t written, rlen;
 979     char status[32] = {0};
 980     int retry = 10;
 981
 982     LOGD("requesting data connection to APN '%s'", apn);
 983
 984     fd = open ("/dev/qmi", O_RDWR);
 985     if (fd >= 0) { /* the device doesn't exist on the emulator */
 986
 987             LOGD("opened the qmi device\n");
 988             asprintf(&cmd, "up:%s", apn);
 989             len = strlen(cmd);
 990
 991             while (cur < len) {
 992                     do {
 993                     written = write (fd, cmd + cur, len - cur);
 994                 } while (written < 0 && errno == EINTR);
 995
 996                 if (written < 0) {
 997                 LOGE("### ERROR writing to /dev/qmi");
 998                 close(fd);
 999                 goto error;
1000             }
1001
1002             cur += written;
1003         }
1004
1005         // wait for interface to come online
1006
1007         do {
1008             sleep(1);
1009             do {
1010                 rlen = read(fd, status, 31);
1011             } while (rlen < 0 && errno == EINTR);
1012
1013             if (rlen < 0) {
1014                 LOGE("### ERROR reading from /dev/qmi");
1015                 close(fd);
1016                 goto error;
1017             } else {
1018                 status[rlen] = '\0';
1019                 LOGD("### status: %s", status);
1020             }
1021         } while (strncmp(status, "STATE=up", 8) && strcmp(status, "online") && --retry);
1022
1023         close(fd);
1024
1025         if (retry == 0) {
1026             LOGE("### Failed to get data connection up\n");
1027                 goto error;
1028                 }
1029
1030         qmistatus = system("netcfg rmnet0 dhcp");
1031
1032         LOGD("netcfg rmnet0 dhcp: status %d\n", qmistatus);
1033
1034             if (qmistatus < 0) goto error;
1035
1036         } else {
1037
1038         asprintf(&cmd, "AT+CGDCONT=1,\"IP\",\"%s\",,0,0", apn);
1039             //FIXME check for error here
1040             err = at_send_command(cmd, NULL);
1041             free(cmd);
1042
1043             // Set required QoS params to default
1044             err = at_send_command("AT+CGQREQ=1", NULL);
1045
1046             // Set minimum QoS params to default
1047             err = at_send_command("AT+CGQMIN=1", NULL);
1048
1049             // packet-domain event reporting
1050             err = at_send_command("AT+CGEREP=1,0", NULL);
1051
1052             // Hangup anything that's happening there now
1053             err = at_send_command("AT+CGACT=1,0", NULL);
1054
1055             // Start data on PDP context 1
1056             err = at_send_command("ATD*99***1#", &p_response);
1057
1058             if (err < 0 || p_response->success == 0) {
1059                 goto error;
1060             }
1061     }
1062
1063     RIL_onRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response));
1064     at_response_free(p_response);
1065
1066     return;
1067 error:
1068     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1069     at_response_free(p_response);
1070
1071 }
1072
1073 static void requestSMSAcknowledge(void *data, size_t datalen, RIL_Token t)
1074 {
1075     int ackSuccess;
1076     int err;
1077
1078     ackSuccess = ((int *)data)[0];
1079
1080     if (ackSuccess == 1) {
1081         err = at_send_command("AT+CNMA=1", NULL);
1082     } else if (ackSuccess == 0)  {
1083         err = at_send_command("AT+CNMA=2", NULL);
1084     } else {
1085         LOGE("unsupported arg to RIL_REQUEST_SMS_ACKNOWLEDGE\n");
1086         goto error;
1087     }
1088
1089     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1090 error:
1091     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1092
1093 }
1094
1095 static void  requestSIM_IO(void *data, size_t datalen, RIL_Token t)
1096 {
1097     ATResponse *p_response = NULL;
1098     RIL_SIM_IO_Response sr;
1099     int err;
1100     char *cmd = NULL;
1101     RIL_SIM_IO *p_args;
1102     char *line;
1103
1104     memset(&sr, 0, sizeof(sr));
1105
1106     p_args = (RIL_SIM_IO *)data;
1107
1108     /* FIXME handle pin2 */
1109
1110     if (p_args->data == NULL) {
1111         asprintf(&cmd, "AT+CRSM=%d,%d,%d,%d,%d",
1112                     p_args->command, p_args->fileid,
1113                     p_args->p1, p_args->p2, p_args->p3);
1114     } else {
1115         asprintf(&cmd, "AT+CRSM=%d,%d,%d,%d,%d,%s",
1116                     p_args->command, p_args->fileid,
1117                     p_args->p1, p_args->p2, p_args->p3, p_args->data);
1118     }
1119
1120     err = at_send_command_singleline(cmd, "+CRSM:", &p_response);
1121
1122     if (err < 0 || p_response->success == 0) {
1123         goto error;
1124     }
1125
1126     line = p_response->p_intermediates->line;
1127
1128     err = at_tok_start(&line);
1129     if (err < 0) goto error;
1130
1131     err = at_tok_nextint(&line, &(sr.sw1));
1132     if (err < 0) goto error;
1133
1134     err = at_tok_nextint(&line, &(sr.sw2));
1135     if (err < 0) goto error;
1136
1137     if (at_tok_hasmore(&line)) {
1138         err = at_tok_nextstr(&line, &(sr.simResponse));
1139         if (err < 0) goto error;
1140     }
1141
1142     RIL_onRequestComplete(t, RIL_E_SUCCESS, &sr, sizeof(sr));
1143     at_response_free(p_response);
1144     free(cmd);
1145
1146     return;
1147 error:
1148     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1149     at_response_free(p_response);
1150     free(cmd);
1151
1152 }
1153
1154 static void  requestEnterSimPin(void*  data, size_t  datalen, RIL_Token  t)
1155 {
1156     ATResponse   *p_response = NULL;
1157     int           err;
1158     char*         cmd = NULL;
1159     const char**  strings = (const char**)data;;
1160
1161     if ( datalen == sizeof(char*) ) {
1162         asprintf(&cmd, "AT+CPIN=%s", strings[0]);
1163     } else if ( datalen == 2*sizeof(char*) ) {
1164         asprintf(&cmd, "AT+CPIN=%s,%s", strings[0], strings[1]);
1165     } else
1166         goto error;
1167
1168     err = at_send_command_singleline(cmd, "+CPIN:", &p_response);
1169     free(cmd);
1170
1171     if (err < 0 || p_response->success == 0) {
1172 error:
1173         RIL_onRequestComplete(t, RIL_E_PASSWORD_INCORRECT, NULL, 0);
1174     } else {
1175         RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1176     }
1177     at_response_free(p_response);
1178 }
1179
1180
1181 static void  requestSendUSSD(void *data, size_t datalen, RIL_Token t)
1182 {
1183     const char *ussdRequest;
1184
1185     ussdRequest = (char *)(data);
1186
1187
1188     RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
1189
1190 // @@@ TODO
1191
1192 }
1193
1194
1195 /*** Callback methods from the RIL library to us ***/
1196
1197 /**
1198  * Call from RIL to us to make a RIL_REQUEST
1199  *
1200  * Must be completed with a call to RIL_onRequestComplete()
1201  *
1202  * RIL_onRequestComplete() may be called from any thread, before or after
1203  * this function returns.
1204  *
1205  * Will always be called from the same thread, so returning here implies
1206  * that the radio is ready to process another command (whether or not
1207  * the previous command has completed).
1208  */
1209 static void
1210 onRequest (int request, void *data, size_t datalen, RIL_Token t)
1211 {
1212     ATResponse *p_response;
1213     int err;
1214
1215     LOGD("onRequest: %s", requestToString(request));
1216
1217     /* Ignore all requests except RIL_REQUEST_GET_SIM_STATUS
1218      * when RADIO_STATE_UNAVAILABLE.
1219      */
1220     if (sState == RADIO_STATE_UNAVAILABLE
1221         && request != RIL_REQUEST_GET_SIM_STATUS
1222     ) {
1223         RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1224         return;
1225     }
1226
1227     /* Ignore all non-power requests when RADIO_STATE_OFF
1228      * (except RIL_REQUEST_GET_SIM_STATUS)
1229      */
1230     if (sState == RADIO_STATE_OFF
1231         && !(request == RIL_REQUEST_RADIO_POWER
1232             || request == RIL_REQUEST_GET_SIM_STATUS)
1233     ) {
1234         RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1235         return;
1236     }
1237
1238     switch (request) {
1239         case RIL_REQUEST_GET_SIM_STATUS: {
1240             RIL_CardStatus *p_card_status;
1241             char *p_buffer;
1242             int buffer_size;
1243
1244             int result = getCardStatus(&p_card_status);
1245             if (result == RIL_E_SUCCESS) {
1246                 p_buffer = (char *)p_card_status;
1247                 buffer_size = sizeof(*p_card_status);
1248             } else {
1249                 p_buffer = NULL;
1250                 buffer_size = 0;
1251             }
1252             RIL_onRequestComplete(t, result, p_buffer, buffer_size);
1253             freeCardStatus(p_card_status);
1254             break;
1255         }
1256         case RIL_REQUEST_GET_CURRENT_CALLS:
1257             requestGetCurrentCalls(data, datalen, t);
1258             break;
1259         case RIL_REQUEST_DIAL:
1260             requestDial(data, datalen, t);
1261             break;
1262         case RIL_REQUEST_HANGUP:
1263             requestHangup(data, datalen, t);
1264             break;
1265         case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND:
1266             // 3GPP 22.030 6.5.5
1267             // "Releases all held calls or sets User Determined User Busy
1268             //  (UDUB) for a waiting call."
1269             at_send_command("AT+CHLD=0", NULL);
1270
1271             /* success or failure is ignored by the upper layer here.
1272                it will call GET_CURRENT_CALLS and determine success that way */
1273             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1274             break;
1275         case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND:
1276             // 3GPP 22.030 6.5.5
1277             // "Releases all active calls (if any exist) and accepts
1278             //  the other (held or waiting) call."
1279             at_send_command("AT+CHLD=1", NULL);
1280
1281             /* success or failure is ignored by the upper layer here.
1282                it will call GET_CURRENT_CALLS and determine success that way */
1283             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1284             break;
1285         case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE:
1286             // 3GPP 22.030 6.5.5
1287             // "Places all active calls (if any exist) on hold and accepts
1288             //  the other (held or waiting) call."
1289             at_send_command("AT+CHLD=2", NULL);
1290
1291 #ifdef WORKAROUND_ERRONEOUS_ANSWER
1292             s_expectAnswer = 1;
1293 #endif /* WORKAROUND_ERRONEOUS_ANSWER */
1294
1295             /* success or failure is ignored by the upper layer here.
1296                it will call GET_CURRENT_CALLS and determine success that way */
1297             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1298             break;
1299         case RIL_REQUEST_ANSWER:
1300             at_send_command("ATA", NULL);
1301
1302 #ifdef WORKAROUND_ERRONEOUS_ANSWER
1303             s_expectAnswer = 1;
1304 #endif /* WORKAROUND_ERRONEOUS_ANSWER */
1305
1306             /* success or failure is ignored by the upper layer here.
1307                it will call GET_CURRENT_CALLS and determine success that way */
1308             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1309             break;
1310         case RIL_REQUEST_CONFERENCE:
1311             // 3GPP 22.030 6.5.5
1312             // "Adds a held call to the conversation"
1313             at_send_command("AT+CHLD=3", NULL);
1314
1315             /* success or failure is ignored by the upper layer here.
1316                it will call GET_CURRENT_CALLS and determine success that way */
1317             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1318             break;
1319         case RIL_REQUEST_UDUB:
1320             /* user determined user busy */
1321             /* sometimes used: ATH */
1322             at_send_command("ATH", NULL);
1323
1324             /* success or failure is ignored by the upper layer here.
1325                it will call GET_CURRENT_CALLS and determine success that way */
1326             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1327             break;
1328
1329         case RIL_REQUEST_SEPARATE_CONNECTION:
1330             {
1331                 char  cmd[12];
1332                 int   party = ((int*)data)[0];
1333
1334                 // Make sure that party is in a valid range.
1335                 // (Note: The Telephony middle layer imposes a range of 1 to 7.
1336                 // It's sufficient for us to just make sure it's single digit.)
1337                 if (party > 0 && party < 10) {
1338                     sprintf(cmd, "AT+CHLD=2%d", party);
1339                     at_send_command(cmd, NULL);
1340                     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1341                 } else {
1342                     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1343                 }
1344             }
1345             break;
1346
1347         case RIL_REQUEST_SIGNAL_STRENGTH:
1348             requestSignalStrength(data, datalen, t);
1349             break;
1350         case RIL_REQUEST_REGISTRATION_STATE:
1351         case RIL_REQUEST_GPRS_REGISTRATION_STATE:
1352             requestRegistrationState(request, data, datalen, t);
1353             break;
1354         case RIL_REQUEST_OPERATOR:
1355             requestOperator(data, datalen, t);
1356             break;
1357         case RIL_REQUEST_RADIO_POWER:
1358             requestRadioPower(data, datalen, t);
1359             break;
1360         case RIL_REQUEST_DTMF: {
1361             char c = ((char *)data)[0];
1362             char *cmd;
1363             asprintf(&cmd, "AT+VTS=%c", (int)c);
1364             at_send_command(cmd, NULL);
1365             free(cmd);
1366             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1367             break;
1368         }
1369         case RIL_REQUEST_SEND_SMS:
1370             requestSendSMS(data, datalen, t);
1371             break;
1372         case RIL_REQUEST_SETUP_DATA_CALL:
1373             requestSetupDataCall(data, datalen, t);
1374             break;
1375         case RIL_REQUEST_SMS_ACKNOWLEDGE:
1376             requestSMSAcknowledge(data, datalen, t);
1377             break;
1378
1379         case RIL_REQUEST_GET_IMSI:
1380             p_response = NULL;
1381             err = at_send_command_numeric("AT+CIMI", &p_response);
1382
1383             if (err < 0 || p_response->success == 0) {
1384                 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1385             } else {
1386                 RIL_onRequestComplete(t, RIL_E_SUCCESS,
1387                     p_response->p_intermediates->line, sizeof(char *));
1388             }
1389             at_response_free(p_response);
1390             break;
1391
1392         case RIL_REQUEST_GET_IMEI:
1393             p_response = NULL;
1394             err = at_send_command_numeric("AT+CGSN", &p_response);
1395
1396             if (err < 0 || p_response->success == 0) {
1397                 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1398             } else {
1399                 RIL_onRequestComplete(t, RIL_E_SUCCESS,
1400                     p_response->p_intermediates->line, sizeof(char *));
1401             }
1402             at_response_free(p_response);
1403             break;
1404
1405         case RIL_REQUEST_SIM_IO:
1406             requestSIM_IO(data,datalen,t);
1407             break;
1408
1409         case RIL_REQUEST_SEND_USSD:
1410             requestSendUSSD(data, datalen, t);
1411             break;
1412
1413         case RIL_REQUEST_CANCEL_USSD:
1414             p_response = NULL;
1415             err = at_send_command_numeric("AT+CUSD=2", &p_response);
1416
1417             if (err < 0 || p_response->success == 0) {
1418                 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1419             } else {
1420                 RIL_onRequestComplete(t, RIL_E_SUCCESS,
1421                     p_response->p_intermediates->line, sizeof(char *));
1422             }
1423             at_response_free(p_response);
1424             break;
1425
1426         case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC:
1427             at_send_command("AT+COPS=0", NULL);
1428             break;
1429
1430         case RIL_REQUEST_DATA_CALL_LIST:
1431             requestDataCallList(data, datalen, t);
1432             break;
1433
1434         case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE:
1435             requestQueryNetworkSelectionMode(data, datalen, t);
1436             break;
1437
1438         case RIL_REQUEST_OEM_HOOK_RAW:
1439             // echo back data
1440             RIL_onRequestComplete(t, RIL_E_SUCCESS, data, datalen);
1441             break;
1442
1443
1444         case RIL_REQUEST_OEM_HOOK_STRINGS: {
1445             int i;
1446             const char ** cur;
1447
1448             LOGD("got OEM_HOOK_STRINGS: 0x%8p %lu", data, (long)datalen);
1449
1450
1451             for (i = (datalen / sizeof (char *)), cur = (const char **)data ;
1452                     i > 0 ; cur++, i --) {
1453                 LOGD("> '%s'", *cur);
1454             }
1455
1456             // echo back strings
1457             RIL_onRequestComplete(t, RIL_E_SUCCESS, data, datalen);
1458             break;
1459         }
1460
1461         case RIL_REQUEST_WRITE_SMS_TO_SIM:
1462             requestWriteSmsToSim(data, datalen, t);
1463             break;
1464
1465         case RIL_REQUEST_DELETE_SMS_ON_SIM: {
1466             char * cmd;
1467             p_response = NULL;
1468             asprintf(&cmd, "AT+CMGD=%d", ((int *)data)[0]);
1469             err = at_send_command(cmd, &p_response);
1470             free(cmd);
1471             if (err < 0 || p_response->success == 0) {
1472                 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1473             } else {
1474                 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1475             }
1476             at_response_free(p_response);
1477             break;
1478         }
1479
1480         case RIL_REQUEST_ENTER_SIM_PIN:
1481         case RIL_REQUEST_ENTER_SIM_PUK:
1482         case RIL_REQUEST_ENTER_SIM_PIN2:
1483         case RIL_REQUEST_ENTER_SIM_PUK2:
1484         case RIL_REQUEST_CHANGE_SIM_PIN:
1485         case RIL_REQUEST_CHANGE_SIM_PIN2:
1486             requestEnterSimPin(data, datalen, t);
1487             break;
1488
1489         default:
1490             RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
1491             break;
1492     }
1493 }
1494
1495 /**
1496  * Synchronous call from the RIL to us to return current radio state.
1497  * RADIO_STATE_UNAVAILABLE should be the initial state.
1498  */
1499 static RIL_RadioState
1500 currentState()
1501 {
1502     return sState;
1503 }
1504 /**
1505  * Call from RIL to us to find out whether a specific request code
1506  * is supported by this implementation.
1507  *
1508  * Return 1 for "supported" and 0 for "unsupported"
1509  */
1510
1511 static int
1512 onSupports (int requestCode)
1513 {
1514     //@@@ todo
1515
1516     return 1;
1517 }
1518
1519 static void onCancel (RIL_Token t)
1520 {
1521     //@@@todo
1522
1523 }
1524
1525 static const char * getVersion(void)
1526 {
1527     return "android reference-ril 1.0";
1528 }
1529
1530 static void
1531 setRadioState(RIL_RadioState newState)
1532 {
1533     RIL_RadioState oldState;
1534
1535     pthread_mutex_lock(&s_state_mutex);
1536
1537     oldState = sState;
1538
1539     if (s_closed > 0) {
1540         // If we're closed, the only reasonable state is
1541         // RADIO_STATE_UNAVAILABLE
1542         // This is here because things on the main thread
1543         // may attempt to change the radio state after the closed
1544         // event happened in another thread
1545         newState = RADIO_STATE_UNAVAILABLE;
1546     }
1547
1548     if (sState != newState || s_closed > 0) {
1549         sState = newState;
1550
1551         pthread_cond_broadcast (&s_state_cond);
1552     }
1553
1554     pthread_mutex_unlock(&s_state_mutex);
1555
1556
1557     /* do these outside of the mutex */
1558     if (sState != oldState) {
1559         RIL_onUnsolicitedResponse (RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
1560                                     NULL, 0);
1561
1562         /* FIXME onSimReady() and onRadioPowerOn() cannot be called
1563          * from the AT reader thread
1564          * Currently, this doesn't happen, but if that changes then these
1565          * will need to be dispatched on the request thread
1566          */
1567         if (sState == RADIO_STATE_SIM_READY) {
1568             onSIMReady();
1569         } else if (sState == RADIO_STATE_SIM_NOT_READY) {
1570             onRadioPowerOn();
1571         }
1572     }
1573 }
1574
1575 /** Returns SIM_NOT_READY on error */
1576 static SIM_Status
1577 getSIMStatus()
1578 {
1579     ATResponse *p_response = NULL;
1580     int err;
1581     int ret;
1582     char *cpinLine;
1583     char *cpinResult;
1584
1585     if (sState == RADIO_STATE_OFF || sState == RADIO_STATE_UNAVAILABLE) {
1586         ret = SIM_NOT_READY;
1587         goto done;
1588     }
1589
1590     err = at_send_command_singleline("AT+CPIN?", "+CPIN:", &p_response);
1591
1592     if (err != 0) {
1593         ret = SIM_NOT_READY;
1594         goto done;
1595     }
1596
1597     switch (at_get_cme_error(p_response)) {
1598         case CME_SUCCESS:
1599             break;
1600
1601         case CME_SIM_NOT_INSERTED:
1602             ret = SIM_ABSENT;
1603             goto done;
1604
1605         default:
1606             ret = SIM_NOT_READY;
1607             goto done;
1608     }
1609
1610     /* CPIN? has succeeded, now look at the result */
1611
1612     cpinLine = p_response->p_intermediates->line;
1613     err = at_tok_start (&cpinLine);
1614
1615     if (err < 0) {
1616         ret = SIM_NOT_READY;
1617         goto done;
1618     }
1619
1620     err = at_tok_nextstr(&cpinLine, &cpinResult);
1621
1622     if (err < 0) {
1623         ret = SIM_NOT_READY;
1624         goto done;
1625     }
1626
1627     if (0 == strcmp (cpinResult, "SIM PIN")) {
1628         ret = SIM_PIN;
1629         goto done;
1630     } else if (0 == strcmp (cpinResult, "SIM PUK")) {
1631         ret = SIM_PUK;
1632         goto done;
1633     } else if (0 == strcmp (cpinResult, "PH-NET PIN")) {
1634         return SIM_NETWORK_PERSONALIZATION;
1635     } else if (0 != strcmp (cpinResult, "READY"))  {
1636         /* we're treating unsupported lock types as "sim absent" */
1637         ret = SIM_ABSENT;
1638         goto done;
1639     }
1640
1641     at_response_free(p_response);
1642     p_response = NULL;
1643     cpinResult = NULL;
1644
1645     ret = SIM_READY;
1646
1647 done:
1648     at_response_free(p_response);
1649     return ret;
1650 }
1651
1652
1653 /**
1654  * Get the current card status.
1655  *
1656  * This must be freed using freeCardStatus.
1657  * @return: On success returns RIL_E_SUCCESS
1658  */
1659 static int getCardStatus(RIL_CardStatus **pp_card_status) {
1660     static RIL_AppStatus app_status_array[] = {
1661         // SIM_ABSENT = 0
1662         { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN,
1663           NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },
1664         // SIM_NOT_READY = 1
1665         { RIL_APPTYPE_SIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN,
1666           NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },
1667         // SIM_READY = 2
1668         { RIL_APPTYPE_SIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY,
1669           NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },
1670         // SIM_PIN = 3
1671         { RIL_APPTYPE_SIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN,
1672           NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN },
1673         // SIM_PUK = 4
1674         { RIL_APPTYPE_SIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN,
1675           NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN },
1676         // SIM_NETWORK_PERSONALIZATION = 5
1677         { RIL_APPTYPE_SIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK,
1678           NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }
1679     };
1680     RIL_CardState card_state;
1681     int num_apps;
1682
1683     int sim_status = getSIMStatus();
1684     if (sim_status == SIM_ABSENT) {
1685         card_state = RIL_CARDSTATE_ABSENT;
1686         num_apps = 0;
1687     } else {
1688         card_state = RIL_CARDSTATE_PRESENT;
1689         num_apps = 1;
1690     }
1691
1692     // Allocate and initialize base card status.
1693     RIL_CardStatus *p_card_status = malloc(sizeof(RIL_CardStatus));
1694     p_card_status->card_state = card_state;
1695     p_card_status->universal_pin_state = RIL_PINSTATE_UNKNOWN;
1696     p_card_status->gsm_umts_subscription_app_index = RIL_CARD_MAX_APPS;
1697     p_card_status->cdma_subscription_app_index = RIL_CARD_MAX_APPS;
1698     p_card_status->num_applications = num_apps;
1699
1700     // Initialize application status
1701     int i;
1702     for (i = 0; i < RIL_CARD_MAX_APPS; i++) {
1703         p_card_status->applications[i] = app_status_array[SIM_ABSENT];
1704     }
1705
1706     // Pickup the appropriate application status
1707     // that reflects sim_status for gsm.
1708     if (num_apps != 0) {
1709         // Only support one app, gsm
1710         p_card_status->num_applications = 1;
1711         p_card_status->gsm_umts_subscription_app_index = 0;
1712
1713         // Get the correct app status
1714         p_card_status->applications[0] = app_status_array[sim_status];
1715     }
1716
1717     *pp_card_status = p_card_status;
1718     return RIL_E_SUCCESS;
1719 }
1720
1721 /**
1722  * Free the card status returned by getCardStatus
1723  */
1724 static void freeCardStatus(RIL_CardStatus *p_card_status) {
1725     free(p_card_status);
1726 }
1727
1728 /**
1729  * SIM ready means any commands that access the SIM will work, including:
1730  *  AT+CPIN, AT+CSMS, AT+CNMI, AT+CRSM
1731  *  (all SMS-related commands)
1732  */
1733
1734 static void pollSIMState (void *param)
1735 {
1736     ATResponse *p_response;
1737     int ret;
1738
1739     if (sState != RADIO_STATE_SIM_NOT_READY) {
1740         // no longer valid to poll
1741         return;
1742     }
1743
1744     switch(getSIMStatus()) {
1745         case SIM_ABSENT:
1746         case SIM_PIN:
1747         case SIM_PUK:
1748         case SIM_NETWORK_PERSONALIZATION:
1749         default:
1750             setRadioState(RADIO_STATE_SIM_LOCKED_OR_ABSENT);
1751         return;
1752
1753         case SIM_NOT_READY:
1754             RIL_requestTimedCallback (pollSIMState, NULL, &TIMEVAL_SIMPOLL);
1755         return;
1756
1757         case SIM_READY:
1758             setRadioState(RADIO_STATE_SIM_READY);
1759         return;
1760     }
1761 }
1762
1763 /** returns 1 if on, 0 if off, and -1 on error */
1764 static int isRadioOn()
1765 {
1766     ATResponse *p_response = NULL;
1767     int err;
1768     char *line;
1769     char ret;
1770
1771     err = at_send_command_singleline("AT+CFUN?", "+CFUN:", &p_response);
1772
1773     if (err < 0 || p_response->success == 0) {
1774         // assume radio is off
1775         goto error;
1776     }
1777
1778     line = p_response->p_intermediates->line;
1779
1780     err = at_tok_start(&line);
1781     if (err < 0) goto error;
1782
1783     err = at_tok_nextbool(&line, &ret);
1784     if (err < 0) goto error;
1785
1786     at_response_free(p_response);
1787
1788     return (int)ret;
1789
1790 error:
1791
1792     at_response_free(p_response);
1793     return -1;
1794 }
1795
1796 /**
1797  * Initialize everything that can be configured while we're still in
1798  * AT+CFUN=0
1799  */
1800 static void initializeCallback(void *param)
1801 {
1802     ATResponse *p_response = NULL;
1803     int err;
1804
1805     setRadioState (RADIO_STATE_OFF);
1806
1807     at_handshake();
1808
1809     /* note: we don't check errors here. Everything important will
1810        be handled in onATTimeout and onATReaderClosed */
1811
1812     /*  atchannel is tolerant of echo but it must */
1813     /*  have verbose result codes */
1814     at_send_command("ATE0Q0V1", NULL);
1815
1816     /*  No auto-answer */
1817     at_send_command("ATS0=0", NULL);
1818
1819     /*  Extended errors */
1820     at_send_command("AT+CMEE=1", NULL);
1821
1822     /*  Network registration events */
1823     err = at_send_command("AT+CREG=2", &p_response);
1824
1825     /* some handsets -- in tethered mode -- don't support CREG=2 */
1826     if (err < 0 || p_response->success == 0) {
1827         at_send_command("AT+CREG=1", NULL);
1828     }
1829
1830     at_response_free(p_response);
1831
1832     /*  GPRS registration events */
1833     at_send_command("AT+CGREG=1", NULL);
1834
1835     /*  Call Waiting notifications */
1836     at_send_command("AT+CCWA=1", NULL);
1837
1838     /*  Alternating voice/data off */
1839     at_send_command("AT+CMOD=0", NULL);
1840
1841     /*  Not muted */
1842     at_send_command("AT+CMUT=0", NULL);
1843
1844     /*  +CSSU unsolicited supp service notifications */
1845     at_send_command("AT+CSSN=0,1", NULL);
1846
1847     /*  no connected line identification */
1848     at_send_command("AT+COLP=0", NULL);
1849
1850     /*  HEX character set */
1851     at_send_command("AT+CSCS=\"HEX\"", NULL);
1852
1853     /*  USSD unsolicited */
1854     at_send_command("AT+CUSD=1", NULL);
1855
1856     /*  Enable +CGEV GPRS event notifications, but don't buffer */
1857     at_send_command("AT+CGEREP=1,0", NULL);
1858
1859     /*  SMS PDU mode */
1860     at_send_command("AT+CMGF=0", NULL);
1861
1862 #ifdef USE_TI_COMMANDS
1863
1864     at_send_command("AT%CPI=3", NULL);
1865
1866     /*  TI specific -- notifications when SMS is ready (currently ignored) */
1867     at_send_command("AT%CSTAT=1", NULL);
1868
1869 #endif /* USE_TI_COMMANDS */
1870
1871
1872     /* assume radio is off on error */
1873     if (isRadioOn() > 0) {
1874         setRadioState (RADIO_STATE_SIM_NOT_READY);
1875     }
1876 }
1877
1878 static void waitForClose()
1879 {
1880     pthread_mutex_lock(&s_state_mutex);
1881
1882     while (s_closed == 0) {
1883         pthread_cond_wait(&s_state_cond, &s_state_mutex);
1884     }
1885
1886     pthread_mutex_unlock(&s_state_mutex);
1887 }
1888
1889 /**
1890  * Called by atchannel when an unsolicited line appears
1891  * This is called on atchannel's reader thread. AT commands may
1892  * not be issued here
1893  */
1894 static void onUnsolicited (const char *s, const char *sms_pdu)
1895 {
1896     char *line = NULL;
1897     int err;
1898
1899     /* Ignore unsolicited responses until we're initialized.
1900      * This is OK because the RIL library will poll for initial state
1901      */
1902     if (sState == RADIO_STATE_UNAVAILABLE) {
1903         return;
1904     }
1905
1906     if (strStartsWith(s, "%CTZV:")) {
1907         /* TI specific -- NITZ time */
1908         char *response;
1909
1910         line = strdup(s);
1911         at_tok_start(&line);
1912
1913         err = at_tok_nextstr(&line, &response);
1914
1915         if (err != 0) {
1916             LOGE("invalid NITZ line %s\n", s);
1917         } else {
1918             RIL_onUnsolicitedResponse (
1919                 RIL_UNSOL_NITZ_TIME_RECEIVED,
1920                 response, strlen(response));
1921         }
1922     } else if (strStartsWith(s,"+CRING:")
1923                 || strStartsWith(s,"RING")
1924                 || strStartsWith(s,"NO CARRIER")
1925                 || strStartsWith(s,"+CCWA")
1926     ) {
1927         RIL_onUnsolicitedResponse (
1928             RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED,
1929             NULL, 0);
1930 #ifdef WORKAROUND_FAKE_CGEV
1931         RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); //TODO use new function
1932 #endif /* WORKAROUND_FAKE_CGEV */
1933     } else if (strStartsWith(s,"+CREG:")
1934                 || strStartsWith(s,"+CGREG:")
1935     ) {
1936         RIL_onUnsolicitedResponse (
1937             RIL_UNSOL_RESPONSE_NETWORK_STATE_CHANGED,
1938             NULL, 0);
1939 #ifdef WORKAROUND_FAKE_CGEV
1940         RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL);
1941 #endif /* WORKAROUND_FAKE_CGEV */
1942     } else if (strStartsWith(s, "+CMT:")) {
1943         RIL_onUnsolicitedResponse (
1944             RIL_UNSOL_RESPONSE_NEW_SMS,
1945             sms_pdu, strlen(sms_pdu));
1946     } else if (strStartsWith(s, "+CDS:")) {
1947         RIL_onUnsolicitedResponse (
1948             RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT,
1949             sms_pdu, strlen(sms_pdu));
1950     } else if (strStartsWith(s, "+CGEV:")) {
1951         /* Really, we can ignore NW CLASS and ME CLASS events here,
1952          * but right now we don't since extranous
1953          * RIL_UNSOL_DATA_CALL_LIST_CHANGED calls are tolerated
1954          */
1955         /* can't issue AT commands here -- call on main thread */
1956         RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL);
1957 #ifdef WORKAROUND_FAKE_CGEV
1958     } else if (strStartsWith(s, "+CME ERROR: 150")) {
1959         RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL);
1960 #endif /* WORKAROUND_FAKE_CGEV */
1961     }
1962 }
1963
1964 /* Called on command or reader thread */
1965 static void onATReaderClosed()
1966 {
1967     LOGI("AT channel closed\n");
1968     at_close();
1969     s_closed = 1;
1970
1971     setRadioState (RADIO_STATE_UNAVAILABLE);
1972 }
1973
1974 /* Called on command thread */
1975 static void onATTimeout()
1976 {
1977     LOGI("AT channel timeout; closing\n");
1978     at_close();
1979
1980     s_closed = 1;
1981
1982     /* FIXME cause a radio reset here */
1983
1984     setRadioState (RADIO_STATE_UNAVAILABLE);
1985 }
1986
1987 static void usage(char *s)
1988 {
1989 #ifdef RIL_SHLIB
1990     fprintf(stderr, "reference-ril requires: -p <tcp port> or -d /dev/tty_device\n");
1991 #else
1992     fprintf(stderr, "usage: %s [-p <tcp port>] [-d /dev/tty_device]\n", s);
1993     exit(-1);
1994 #endif
1995 }
1996
1997 static void *
1998 mainLoop(void *param)
1999 {
2000     int fd;
2001     int ret;
2002
2003     AT_DUMP("== ", "entering mainLoop()", -1 );
2004     at_set_on_reader_closed(onATReaderClosed);
2005     at_set_on_timeout(onATTimeout);
2006
2007     for (;;) {
2008         fd = -1;
2009         while  (fd < 0) {
2010             if (s_port > 0) {
2011                 fd = socket_loopback_client(s_port, SOCK_STREAM);
2012             } else if (s_device_socket) {
2013                 if (!strcmp(s_device_path, "/dev/socket/qemud")) {
2014                     /* Qemu-specific control socket */
2015                     fd = socket_local_client( "qemud",
2016                                               ANDROID_SOCKET_NAMESPACE_RESERVED,
2017                                               SOCK_STREAM );
2018                     if (fd >= 0 ) {
2019                         char  answer[2];
2020
2021                         if ( write(fd, "gsm", 3) != 3 ||
2022                              read(fd, answer, 2) != 2 ||
2023                              memcmp(answer, "OK", 2) != 0)
2024                         {
2025                             close(fd);
2026                             fd = -1;
2027                         }
2028                    }
2029                 }
2030                 else
2031                     fd = socket_local_client( s_device_path,
2032                                             ANDROID_SOCKET_NAMESPACE_FILESYSTEM,
2033                                             SOCK_STREAM );
2034             } else if (s_device_path != NULL) {
2035                 fd = open (s_device_path, O_RDWR);
2036                 if ( fd >= 0 && !memcmp( s_device_path, "/dev/ttyS", 9 ) ) {
2037                     /* disable echo on serial ports */
2038                     struct termios  ios;
2039                     tcgetattr( fd, &ios );
2040                     ios.c_lflag = 0;  /* disable ECHO, ICANON, etc... */
2041                     tcsetattr( fd, TCSANOW, &ios );
2042                 }
2043             }
2044
2045             if (fd < 0) {
2046                 perror ("opening AT interface. retrying...");
2047                 sleep(10);
2048                 /* never returns */
2049             }
2050         }
2051
2052         s_closed = 0;
2053         ret = at_open(fd, onUnsolicited);
2054
2055         if (ret < 0) {
2056             LOGE ("AT error %d on at_open\n", ret);
2057             return 0;
2058         }
2059
2060         RIL_requestTimedCallback(initializeCallback, NULL, &TIMEVAL_0);
2061
2062         // Give initializeCallback a chance to dispatched, since
2063         // we don't presently have a cancellation mechanism
2064         sleep(1);
2065
2066         waitForClose();
2067         LOGI("Re-opening after close");
2068     }
2069 }
2070
2071 #ifdef RIL_SHLIB
2072
2073 pthread_t s_tid_mainloop;
2074
2075 const RIL_RadioFunctions *RIL_Init(const struct RIL_Env *env, int argc, char **argv)
2076 {
2077     int ret;
2078     int fd = -1;
2079     int opt;
2080     pthread_attr_t attr;
2081
2082     s_rilenv = env;
2083
2084     while ( -1 != (opt = getopt(argc, argv, "p:d:s:"))) {
2085         switch (opt) {
2086             case 'p':
2087                 s_port = atoi(optarg);
2088                 if (s_port == 0) {
2089                     usage(argv[0]);
2090                     return NULL;
2091                 }
2092                 LOGI("Opening loopback port %d\n", s_port);
2093             break;
2094
2095             case 'd':
2096                 s_device_path = optarg;
2097                 LOGI("Opening tty device %s\n", s_device_path);
2098             break;
2099
2100             case 's':
2101                 s_device_path   = optarg;
2102                 s_device_socket = 1;
2103                 LOGI("Opening socket %s\n", s_device_path);
2104             break;
2105
2106             default:
2107                 usage(argv[0]);
2108                 return NULL;
2109         }
2110     }
2111
2112     if (s_port < 0 && s_device_path == NULL) {
2113         usage(argv[0]);
2114         return NULL;
2115     }
2116
2117     pthread_attr_init (&attr);
2118     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
2119     ret = pthread_create(&s_tid_mainloop, &attr, mainLoop, NULL);
2120
2121     return &s_callbacks;
2122 }
2123 #else /* RIL_SHLIB */
2124 int main (int argc, char **argv)
2125 {
2126     int ret;
2127     int fd = -1;
2128     int opt;
2129
2130     while ( -1 != (opt = getopt(argc, argv, "p:d:"))) {
2131         switch (opt) {
2132             case 'p':
2133                 s_port = atoi(optarg);
2134                 if (s_port == 0) {
2135                     usage(argv[0]);
2136                 }
2137                 LOGI("Opening loopback port %d\n", s_port);
2138             break;
2139
2140             case 'd':
2141                 s_device_path = optarg;
2142                 LOGI("Opening tty device %s\n", s_device_path);
2143             break;
2144
2145             case 's':
2146                 s_device_path   = optarg;
2147                 s_device_socket = 1;
2148                 LOGI("Opening socket %s\n", s_device_path);
2149             break;
2150
2151             default:
2152                 usage(argv[0]);
2153         }
2154     }
2155
2156     if (s_port < 0 && s_device_path == NULL) {
2157         usage(argv[0]);
2158     }
2159
2160     RIL_register(&s_callbacks);
2161
2162     mainLoop(NULL);
2163
2164     return 0;
2165 }
2166
2167 #endif /* RIL_SHLIB */