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