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_cdma_sms.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 #include <sys/system_properties.h>
  37
  38 #include "ril.h"
  39 #include "hardware/qemu_pipe.h"
  40
  41 #define LOG_TAG "RIL"
  42 #include <utils/Log.h>
  43
  44 #define MAX_AT_RESPONSE 0x1000
  45
  46 /* pathname returned from RIL_REQUEST_SETUP_DATA_CALL / RIL_REQUEST_SETUP_DEFAULT_PDP */
  47 #define PPP_TTY_PATH "eth0"
  48
  49 #ifdef USE_TI_COMMANDS
  50
  51 // Enable a workaround
  52 // 1) Make incoming call, do not answer
  53 // 2) Hangup remote end
  54 // Expected: call should disappear from CLCC line
  55 // Actual: Call shows as "ACTIVE" before disappearing
  56 #define WORKAROUND_ERRONEOUS_ANSWER 1
  57
  58 // Some varients of the TI stack do not support the +CGEV unsolicited
  59 // response. However, they seem to send an unsolicited +CME ERROR: 150
  60 #define WORKAROUND_FAKE_CGEV 1
  61 #endif
  62
  63 /* Modem Technology bits */
  64 #define MDM_GSM         0x01
  65 #define MDM_WCDMA       0x02
  66 #define MDM_CDMA        0x04
  67 #define MDM_EVDO        0x08
  68 #define MDM_LTE         0x10
  69
  70 typedef struct {
  71     int supportedTechs; // Bitmask of supported Modem Technology bits
  72     int currentTech;    // Technology the modem is currently using (in the format used by modem)
  73     int isMultimode;
  74
  75     // Preferred mode bitmask. This is actually 4 byte-sized bitmasks with different priority values,
  76     // in which the byte number from LSB to MSB give the priority.
  77     //
  78     //          |MSB|   |   |LSB
  79     // value:   |00 |00 |00 |00
  80     // byte #:  |3  |2  |1  |0
  81     //
  82     // Higher byte order give higher priority. Thus, a value of 0x0000000f represents
  83     // a preferred mode of GSM, WCDMA, CDMA, and EvDo in which all are equally preferrable, whereas
  84     // 0x00000201 represents a mode with GSM and WCDMA, in which WCDMA is preferred over GSM
  85     int32_t preferredNetworkMode;
  86     int subscription_source;
  87
  88 } ModemInfo;
  89
  90 static ModemInfo *sMdmInfo;
  91 // TECH returns the current technology in the format used by the modem.
  92 // It can be used as an l-value
  93 #define TECH(mdminfo)                 ((mdminfo)->currentTech)
  94 // TECH_BIT returns the bitmask equivalent of the current tech
  95 #define TECH_BIT(mdminfo)            (1 << ((mdminfo)->currentTech))
  96 #define IS_MULTIMODE(mdminfo)         ((mdminfo)->isMultimode)
  97 #define TECH_SUPPORTED(mdminfo, tech) ((mdminfo)->supportedTechs & (tech))
  98 #define PREFERRED_NETWORK(mdminfo)    ((mdminfo)->preferredNetworkMode)
  99 // CDMA Subscription Source
 100 #define SSOURCE(mdminfo)              ((mdminfo)->subscription_source)
 101
 102 static int net2modem[] = {
 103     MDM_GSM | MDM_WCDMA,                                 // 0  - GSM / WCDMA Pref
 104     MDM_GSM,                                             // 1  - GSM only
 105     MDM_WCDMA,                                           // 2  - WCDMA only
 106     MDM_GSM | MDM_WCDMA,                                 // 3  - GSM / WCDMA Auto
 107     MDM_CDMA | MDM_EVDO,                                 // 4  - CDMA / EvDo Auto
 108     MDM_CDMA,                                            // 5  - CDMA only
 109     MDM_EVDO,                                            // 6  - EvDo only
 110     MDM_GSM | MDM_WCDMA | MDM_CDMA | MDM_EVDO,           // 7  - GSM/WCDMA, CDMA, EvDo
 111     MDM_LTE | MDM_CDMA | MDM_EVDO,                       // 8  - LTE, CDMA and EvDo
 112     MDM_LTE | MDM_GSM | MDM_WCDMA,                       // 9  - LTE, GSM/WCDMA
 113     MDM_LTE | MDM_CDMA | MDM_EVDO | MDM_GSM | MDM_WCDMA, // 10 - LTE, CDMA, EvDo, GSM/WCDMA
 114     MDM_LTE,                                             // 11 - LTE only
 115 };
 116
 117 static int32_t net2pmask[] = {
 118     MDM_GSM | (MDM_WCDMA << 8),                          // 0  - GSM / WCDMA Pref
 119     MDM_GSM,                                             // 1  - GSM only
 120     MDM_WCDMA,                                           // 2  - WCDMA only
 121     MDM_GSM | MDM_WCDMA,                                 // 3  - GSM / WCDMA Auto
 122     MDM_CDMA | MDM_EVDO,                                 // 4  - CDMA / EvDo Auto
 123     MDM_CDMA,                                            // 5  - CDMA only
 124     MDM_EVDO,                                            // 6  - EvDo only
 125     MDM_GSM | MDM_WCDMA | MDM_CDMA | MDM_EVDO,           // 7  - GSM/WCDMA, CDMA, EvDo
 126     MDM_LTE | MDM_CDMA | MDM_EVDO,                       // 8  - LTE, CDMA and EvDo
 127     MDM_LTE | MDM_GSM | MDM_WCDMA,                       // 9  - LTE, GSM/WCDMA
 128     MDM_LTE | MDM_CDMA | MDM_EVDO | MDM_GSM | MDM_WCDMA, // 10 - LTE, CDMA, EvDo, GSM/WCDMA
 129     MDM_LTE,                                             // 11 - LTE only
 130 };
 131
 132 static int is3gpp2(int radioTech) {
 133     switch (radioTech) {
 134         case RADIO_TECH_IS95A:
 135         case RADIO_TECH_IS95B:
 136         case RADIO_TECH_1xRTT:
 137         case RADIO_TECH_EVDO_0:
 138         case RADIO_TECH_EVDO_A:
 139         case RADIO_TECH_EVDO_B:
 140         case RADIO_TECH_EHRPD:
 141             return 1;
 142         default:
 143             return 0;
 144     }
 145 }
 146
 147 typedef enum {
 148     SIM_ABSENT = 0,
 149     SIM_NOT_READY = 1,
 150     SIM_READY = 2, /* SIM_READY means the radio state is RADIO_STATE_SIM_READY */
 151     SIM_PIN = 3,
 152     SIM_PUK = 4,
 153     SIM_NETWORK_PERSONALIZATION = 5,
 154     RUIM_ABSENT = 6,
 155     RUIM_NOT_READY = 7,
 156     RUIM_READY = 8,
 157     RUIM_PIN = 9,
 158     RUIM_PUK = 10,
 159     RUIM_NETWORK_PERSONALIZATION = 11
 160 } SIM_Status;
 161
 162 static void onRequest (int request, void *data, size_t datalen, RIL_Token t);
 163 static RIL_RadioState currentState();
 164 static int onSupports (int requestCode);
 165 static void onCancel (RIL_Token t);
 166 static const char *getVersion();
 167 static int isRadioOn();
 168 static SIM_Status getSIMStatus();
 169 static int getCardStatus(RIL_CardStatus_v6 **pp_card_status);
 170 static void freeCardStatus(RIL_CardStatus_v6 *p_card_status);
 171 static void onDataCallListChanged(void *param);
 172
 173 extern const char * requestToString(int request);
 174
 175 /*** Static Variables ***/
 176 static const RIL_RadioFunctions s_callbacks = {
 177     RIL_VERSION,
 178     onRequest,
 179     currentState,
 180     onSupports,
 181     onCancel,
 182     getVersion
 183 };
 184
 185 #ifdef RIL_SHLIB
 186 static const struct RIL_Env *s_rilenv;
 187
 188 #define RIL_onRequestComplete(t, e, response, responselen) s_rilenv->OnRequestComplete(t,e, response, responselen)
 189 #define RIL_onUnsolicitedResponse(a,b,c) s_rilenv->OnUnsolicitedResponse(a,b,c)
 190 #define RIL_requestTimedCallback(a,b,c) s_rilenv->RequestTimedCallback(a,b,c)
 191 #endif
 192
 193 static RIL_RadioState sState = RADIO_STATE_UNAVAILABLE;
 194
 195 static pthread_mutex_t s_state_mutex = PTHREAD_MUTEX_INITIALIZER;
 196 static pthread_cond_t s_state_cond = PTHREAD_COND_INITIALIZER;
 197
 198 static int s_port = -1;
 199 static const char * s_device_path = NULL;
 200 static int          s_device_socket = 0;
 201
 202 /* trigger change to this with s_state_cond */
 203 static int s_closed = 0;
 204
 205 static int sFD;     /* file desc of AT channel */
 206 static char sATBuffer[MAX_AT_RESPONSE+1];
 207 static char *sATBufferCur = NULL;
 208
 209 static const struct timeval TIMEVAL_SIMPOLL = {1,0};
 210 static const struct timeval TIMEVAL_CALLSTATEPOLL = {0,500000};
 211 static const struct timeval TIMEVAL_0 = {0,0};
 212
 213 #ifdef WORKAROUND_ERRONEOUS_ANSWER
 214 // Max number of times we'll try to repoll when we think
 215 // we have a AT+CLCC race condition
 216 #define REPOLL_CALLS_COUNT_MAX 4
 217
 218 // Line index that was incoming or waiting at last poll, or -1 for none
 219 static int s_incomingOrWaitingLine = -1;
 220 // Number of times we've asked for a repoll of AT+CLCC
 221 static int s_repollCallsCount = 0;
 222 // Should we expect a call to be answered in the next CLCC?
 223 static int s_expectAnswer = 0;
 224 #endif /* WORKAROUND_ERRONEOUS_ANSWER */
 225
 226 static void pollSIMState (void *param);
 227 static void setRadioState(RIL_RadioState newState);
 228 static void setRadioTechnology(ModemInfo *mdm, int newtech);
 229 static int query_ctec(ModemInfo *mdm, int *current, int32_t *preferred);
 230 static int parse_technology_response(const char *response, int *current, int32_t *preferred);
 231 static int techFromModemType(int mdmtype);
 232
 233 static int clccStateToRILState(int state, RIL_CallState *p_state)
 234
 235 {
 236     switch(state) {
 237         case 0: *p_state = RIL_CALL_ACTIVE;   return 0;
 238         case 1: *p_state = RIL_CALL_HOLDING;  return 0;
 239         case 2: *p_state = RIL_CALL_DIALING;  return 0;
 240         case 3: *p_state = RIL_CALL_ALERTING; return 0;
 241         case 4: *p_state = RIL_CALL_INCOMING; return 0;
 242         case 5: *p_state = RIL_CALL_WAITING;  return 0;
 243         default: return -1;
 244     }
 245 }
 246
 247 /**
 248  * Note: directly modified line and has *p_call point directly into
 249  * modified line
 250  */
 251 static int callFromCLCCLine(char *line, RIL_Call *p_call)
 252 {
 253         //+CLCC: 1,0,2,0,0,\"+18005551212\",145
 254         //     index,isMT,state,mode,isMpty(,number,TOA)?
 255
 256     int err;
 257     int state;
 258     int mode;
 259
 260     err = at_tok_start(&line);
 261     if (err < 0) goto error;
 262
 263     err = at_tok_nextint(&line, &(p_call->index));
 264     if (err < 0) goto error;
 265
 266     err = at_tok_nextbool(&line, &(p_call->isMT));
 267     if (err < 0) goto error;
 268
 269     err = at_tok_nextint(&line, &state);
 270     if (err < 0) goto error;
 271
 272     err = clccStateToRILState(state, &(p_call->state));
 273     if (err < 0) goto error;
 274
 275     err = at_tok_nextint(&line, &mode);
 276     if (err < 0) goto error;
 277
 278     p_call->isVoice = (mode == 0);
 279
 280     err = at_tok_nextbool(&line, &(p_call->isMpty));
 281     if (err < 0) goto error;
 282
 283     if (at_tok_hasmore(&line)) {
 284         err = at_tok_nextstr(&line, &(p_call->number));
 285
 286         /* tolerate null here */
 287         if (err < 0) return 0;
 288
 289         // Some lame implementations return strings
 290         // like "NOT AVAILABLE" in the CLCC line
 291         if (p_call->number != NULL
 292             && 0 == strspn(p_call->number, "+0123456789")
 293         ) {
 294             p_call->number = NULL;
 295         }
 296
 297         err = at_tok_nextint(&line, &p_call->toa);
 298         if (err < 0) goto error;
 299     }
 300
 301     p_call->uusInfo = NULL;
 302
 303     return 0;
 304
 305 error:
 306     RLOGE("invalid CLCC line\n");
 307     return -1;
 308 }
 309
 310
 311 /** do post-AT+CFUN=1 initialization */
 312 static void onRadioPowerOn()
 313 {
 314 #ifdef USE_TI_COMMANDS
 315     /*  Must be after CFUN=1 */
 316     /*  TI specific -- notifications for CPHS things such */
 317     /*  as CPHS message waiting indicator */
 318
 319     at_send_command("AT%CPHS=1", NULL);
 320
 321     /*  TI specific -- enable NITZ unsol notifs */
 322     at_send_command("AT%CTZV=1", NULL);
 323 #endif
 324
 325     pollSIMState(NULL);
 326 }
 327
 328 /** do post- SIM ready initialization */
 329 static void onSIMReady()
 330 {
 331     at_send_command_singleline("AT+CSMS=1", "+CSMS:", NULL);
 332     /*
 333      * Always send SMS messages directly to the TE
 334      *
 335      * mode = 1 // discard when link is reserved (link should never be
 336      *             reserved)
 337      * mt = 2   // most messages routed to TE
 338      * bm = 2   // new cell BM's routed to TE
 339      * ds = 1   // Status reports routed to TE
 340      * bfr = 1  // flush buffer
 341      */
 342     at_send_command("AT+CNMI=1,2,2,1,1", NULL);
 343 }
 344
 345 static void requestRadioPower(void *data, size_t datalen, RIL_Token t)
 346 {
 347     int onOff;
 348
 349     int err;
 350     ATResponse *p_response = NULL;
 351
 352     assert (datalen >= sizeof(int *));
 353     onOff = ((int *)data)[0];
 354
 355     if (onOff == 0 && sState != RADIO_STATE_OFF) {
 356         err = at_send_command("AT+CFUN=0", &p_response);
 357        if (err < 0 || p_response->success == 0) goto error;
 358         setRadioState(RADIO_STATE_OFF);
 359     } else if (onOff > 0 && sState == RADIO_STATE_OFF) {
 360         err = at_send_command("AT+CFUN=1", &p_response);
 361         if (err < 0|| p_response->success == 0) {
 362             // Some stacks return an error when there is no SIM,
 363             // but they really turn the RF portion on
 364             // So, if we get an error, let's check to see if it
 365             // turned on anyway
 366
 367             if (isRadioOn() != 1) {
 368                 goto error;
 369             }
 370         }
 371         setRadioState(RADIO_STATE_ON);
 372     }
 373
 374     at_response_free(p_response);
 375     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 376     return;
 377 error:
 378     at_response_free(p_response);
 379     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 380 }
 381
 382 static void requestOrSendDataCallList(RIL_Token *t);
 383
 384 static void onDataCallListChanged(void *param)
 385 {
 386     requestOrSendDataCallList(NULL);
 387 }
 388
 389 static void requestDataCallList(void *data, size_t datalen, RIL_Token t)
 390 {
 391     requestOrSendDataCallList(&t);
 392 }
 393
 394 static void requestOrSendDataCallList(RIL_Token *t)
 395 {
 396     ATResponse *p_response;
 397     ATLine *p_cur;
 398     int err;
 399     int n = 0;
 400     char *out;
 401
 402     err = at_send_command_multiline ("AT+CGACT?", "+CGACT:", &p_response);
 403     if (err != 0 || p_response->success == 0) {
 404         if (t != NULL)
 405             RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0);
 406         else
 407             RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED,
 408                                       NULL, 0);
 409         return;
 410     }
 411
 412     for (p_cur = p_response->p_intermediates; p_cur != NULL;
 413          p_cur = p_cur->p_next)
 414         n++;
 415
 416     RIL_Data_Call_Response_v6 *responses =
 417         alloca(n * sizeof(RIL_Data_Call_Response_v6));
 418
 419     int i;
 420     for (i = 0; i < n; i++) {
 421         responses[i].status = -1;
 422         responses[i].suggestedRetryTime = -1;
 423         responses[i].cid = -1;
 424         responses[i].active = -1;
 425         responses[i].type = "";
 426         responses[i].ifname = "";
 427         responses[i].addresses = "";
 428         responses[i].dnses = "";
 429         responses[i].gateways = "";
 430     }
 431
 432     RIL_Data_Call_Response_v6 *response = responses;
 433     for (p_cur = p_response->p_intermediates; p_cur != NULL;
 434          p_cur = p_cur->p_next) {
 435         char *line = p_cur->line;
 436
 437         err = at_tok_start(&line);
 438         if (err < 0)
 439             goto error;
 440
 441         err = at_tok_nextint(&line, &response->cid);
 442         if (err < 0)
 443             goto error;
 444
 445         err = at_tok_nextint(&line, &response->active);
 446         if (err < 0)
 447             goto error;
 448
 449         response++;
 450     }
 451
 452     at_response_free(p_response);
 453
 454     err = at_send_command_multiline ("AT+CGDCONT?", "+CGDCONT:", &p_response);
 455     if (err != 0 || p_response->success == 0) {
 456         if (t != NULL)
 457             RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0);
 458         else
 459             RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED,
 460                                       NULL, 0);
 461         return;
 462     }
 463
 464     for (p_cur = p_response->p_intermediates; p_cur != NULL;
 465          p_cur = p_cur->p_next) {
 466         char *line = p_cur->line;
 467         int cid;
 468
 469         err = at_tok_start(&line);
 470         if (err < 0)
 471             goto error;
 472
 473         err = at_tok_nextint(&line, &cid);
 474         if (err < 0)
 475             goto error;
 476
 477         for (i = 0; i < n; i++) {
 478             if (responses[i].cid == cid)
 479                 break;
 480         }
 481
 482         if (i >= n) {
 483             /* details for a context we didn't hear about in the last request */
 484             continue;
 485         }
 486
 487         // Assume no error
 488         responses[i].status = 0;
 489
 490         // type
 491         err = at_tok_nextstr(&line, &out);
 492         if (err < 0)
 493             goto error;
 494         responses[i].type = alloca(strlen(out) + 1);
 495         strcpy(responses[i].type, out);
 496
 497         // APN ignored for v5
 498         err = at_tok_nextstr(&line, &out);
 499         if (err < 0)
 500             goto error;
 501
 502         responses[i].ifname = alloca(strlen(PPP_TTY_PATH) + 1);
 503         strcpy(responses[i].ifname, PPP_TTY_PATH);
 504
 505         err = at_tok_nextstr(&line, &out);
 506         if (err < 0)
 507             goto error;
 508
 509         responses[i].addresses = alloca(strlen(out) + 1);
 510         strcpy(responses[i].addresses, out);
 511
 512         {
 513             char  propValue[PROP_VALUE_MAX];
 514
 515             if (__system_property_get("ro.kernel.qemu", propValue) != 0) {
 516                 /* We are in the emulator - the dns servers are listed
 517                  * by the following system properties, setup in
 518                  * /system/etc/init.goldfish.sh:
 519                  *  - net.eth0.dns1
 520                  *  - net.eth0.dns2
 521                  *  - net.eth0.dns3
 522                  *  - net.eth0.dns4
 523                  */
 524                 const int   dnslist_sz = 128;
 525                 char*       dnslist = alloca(dnslist_sz);
 526                 const char* separator = "";
 527                 int         nn;
 528
 529                 dnslist[0] = 0;
 530                 for (nn = 1; nn <= 4; nn++) {
 531                     /* Probe net.eth0.dns<n> */
 532                     char  propName[PROP_NAME_MAX];
 533                     snprintf(propName, sizeof propName, "net.eth0.dns%d", nn);
 534
 535                     /* Ignore if undefined */
 536                     if (__system_property_get(propName, propValue) == 0) {
 537                         continue;
 538                     }
 539
 540                     /* Append the DNS IP address */
 541                     strlcat(dnslist, separator, dnslist_sz);
 542                     strlcat(dnslist, propValue, dnslist_sz);
 543                     separator = " ";
 544                 }
 545                 responses[i].dnses = dnslist;
 546
 547                 /* There is only on gateway in the emulator */
 548                 responses[i].gateways = "10.0.2.2";
 549             }
 550             else {
 551                 /* I don't know where we are, so use the public Google DNS
 552                  * servers by default and no gateway.
 553                  */
 554                 responses[i].dnses = "8.8.8.8 8.8.4.4";
 555                 responses[i].gateways = "";
 556             }
 557         }
 558     }
 559
 560     at_response_free(p_response);
 561
 562     if (t != NULL)
 563         RIL_onRequestComplete(*t, RIL_E_SUCCESS, responses,
 564                               n * sizeof(RIL_Data_Call_Response_v6));
 565     else
 566         RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED,
 567                                   responses,
 568                                   n * sizeof(RIL_Data_Call_Response_v6));
 569
 570     return;
 571
 572 error:
 573     if (t != NULL)
 574         RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0);
 575     else
 576         RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED,
 577                                   NULL, 0);
 578
 579     at_response_free(p_response);
 580 }
 581
 582 static void requestQueryNetworkSelectionMode(
 583                 void *data, size_t datalen, RIL_Token t)
 584 {
 585     int err;
 586     ATResponse *p_response = NULL;
 587     int response = 0;
 588     char *line;
 589
 590     err = at_send_command_singleline("AT+COPS?", "+COPS:", &p_response);
 591
 592     if (err < 0 || p_response->success == 0) {
 593         goto error;
 594     }
 595
 596     line = p_response->p_intermediates->line;
 597
 598     err = at_tok_start(&line);
 599
 600     if (err < 0) {
 601         goto error;
 602     }
 603
 604     err = at_tok_nextint(&line, &response);
 605
 606     if (err < 0) {
 607         goto error;
 608     }
 609
 610     RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(int));
 611     at_response_free(p_response);
 612     return;
 613 error:
 614     at_response_free(p_response);
 615     RLOGE("requestQueryNetworkSelectionMode must never return error when radio is on");
 616     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 617 }
 618
 619 static void sendCallStateChanged(void *param)
 620 {
 621     RIL_onUnsolicitedResponse (
 622         RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED,
 623         NULL, 0);
 624 }
 625
 626 static void requestGetCurrentCalls(void *data, size_t datalen, RIL_Token t)
 627 {
 628     int err;
 629     ATResponse *p_response;
 630     ATLine *p_cur;
 631     int countCalls;
 632     int countValidCalls;
 633     RIL_Call *p_calls;
 634     RIL_Call **pp_calls;
 635     int i;
 636     int needRepoll = 0;
 637
 638 #ifdef WORKAROUND_ERRONEOUS_ANSWER
 639     int prevIncomingOrWaitingLine;
 640
 641     prevIncomingOrWaitingLine = s_incomingOrWaitingLine;
 642     s_incomingOrWaitingLine = -1;
 643 #endif /*WORKAROUND_ERRONEOUS_ANSWER*/
 644
 645     err = at_send_command_multiline ("AT+CLCC", "+CLCC:", &p_response);
 646
 647     if (err != 0 || p_response->success == 0) {
 648         RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 649         return;
 650     }
 651
 652     /* count the calls */
 653     for (countCalls = 0, p_cur = p_response->p_intermediates
 654             ; p_cur != NULL
 655             ; p_cur = p_cur->p_next
 656     ) {
 657         countCalls++;
 658     }
 659
 660     /* yes, there's an array of pointers and then an array of structures */
 661
 662     pp_calls = (RIL_Call **)alloca(countCalls * sizeof(RIL_Call *));
 663     p_calls = (RIL_Call *)alloca(countCalls * sizeof(RIL_Call));
 664     memset (p_calls, 0, countCalls * sizeof(RIL_Call));
 665
 666     /* init the pointer array */
 667     for(i = 0; i < countCalls ; i++) {
 668         pp_calls[i] = &(p_calls[i]);
 669     }
 670
 671     for (countValidCalls = 0, p_cur = p_response->p_intermediates
 672             ; p_cur != NULL
 673             ; p_cur = p_cur->p_next
 674     ) {
 675         err = callFromCLCCLine(p_cur->line, p_calls + countValidCalls);
 676
 677         if (err != 0) {
 678             continue;
 679         }
 680
 681 #ifdef WORKAROUND_ERRONEOUS_ANSWER
 682         if (p_calls[countValidCalls].state == RIL_CALL_INCOMING
 683             || p_calls[countValidCalls].state == RIL_CALL_WAITING
 684         ) {
 685             s_incomingOrWaitingLine = p_calls[countValidCalls].index;
 686         }
 687 #endif /*WORKAROUND_ERRONEOUS_ANSWER*/
 688
 689         if (p_calls[countValidCalls].state != RIL_CALL_ACTIVE
 690             && p_calls[countValidCalls].state != RIL_CALL_HOLDING
 691         ) {
 692             needRepoll = 1;
 693         }
 694
 695         countValidCalls++;
 696     }
 697
 698 #ifdef WORKAROUND_ERRONEOUS_ANSWER
 699     // Basically:
 700     // A call was incoming or waiting
 701     // Now it's marked as active
 702     // But we never answered it
 703     //
 704     // This is probably a bug, and the call will probably
 705     // disappear from the call list in the next poll
 706     if (prevIncomingOrWaitingLine >= 0
 707             && s_incomingOrWaitingLine < 0
 708             && s_expectAnswer == 0
 709     ) {
 710         for (i = 0; i < countValidCalls ; i++) {
 711
 712             if (p_calls[i].index == prevIncomingOrWaitingLine
 713                     && p_calls[i].state == RIL_CALL_ACTIVE
 714                     && s_repollCallsCount < REPOLL_CALLS_COUNT_MAX
 715             ) {
 716                 RLOGI(
 717                     "Hit WORKAROUND_ERRONOUS_ANSWER case."
 718                     " Repoll count: %d\n", s_repollCallsCount);
 719                 s_repollCallsCount++;
 720                 goto error;
 721             }
 722         }
 723     }
 724
 725     s_expectAnswer = 0;
 726     s_repollCallsCount = 0;
 727 #endif /*WORKAROUND_ERRONEOUS_ANSWER*/
 728
 729     RIL_onRequestComplete(t, RIL_E_SUCCESS, pp_calls,
 730             countValidCalls * sizeof (RIL_Call *));
 731
 732     at_response_free(p_response);
 733
 734 #ifdef POLL_CALL_STATE
 735     if (countValidCalls) {  // We don't seem to get a "NO CARRIER" message from
 736                             // smd, so we're forced to poll until the call ends.
 737 #else
 738     if (needRepoll) {
 739 #endif
 740         RIL_requestTimedCallback (sendCallStateChanged, NULL, &TIMEVAL_CALLSTATEPOLL);
 741     }
 742
 743     return;
 744 error:
 745     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 746     at_response_free(p_response);
 747 }
 748
 749 static void requestDial(void *data, size_t datalen, RIL_Token t)
 750 {
 751     RIL_Dial *p_dial;
 752     char *cmd;
 753     const char *clir;
 754     int ret;
 755
 756     p_dial = (RIL_Dial *)data;
 757
 758     switch (p_dial->clir) {
 759         case 1: clir = "I"; break;  /*invocation*/
 760         case 2: clir = "i"; break;  /*suppression*/
 761         default:
 762         case 0: clir = ""; break;   /*subscription default*/
 763     }
 764
 765     asprintf(&cmd, "ATD%s%s;", p_dial->address, clir);
 766
 767     ret = at_send_command(cmd, NULL);
 768
 769     free(cmd);
 770
 771     /* success or failure is ignored by the upper layer here.
 772        it will call GET_CURRENT_CALLS and determine success that way */
 773     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 774 }
 775
 776 static void requestWriteSmsToSim(void *data, size_t datalen, RIL_Token t)
 777 {
 778     RIL_SMS_WriteArgs *p_args;
 779     char *cmd;
 780     int length;
 781     int err;
 782     ATResponse *p_response = NULL;
 783
 784     p_args = (RIL_SMS_WriteArgs *)data;
 785
 786     length = strlen(p_args->pdu)/2;
 787     asprintf(&cmd, "AT+CMGW=%d,%d", length, p_args->status);
 788
 789     err = at_send_command_sms(cmd, p_args->pdu, "+CMGW:", &p_response);
 790
 791     if (err != 0 || p_response->success == 0) goto error;
 792
 793     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 794     at_response_free(p_response);
 795
 796     return;
 797 error:
 798     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 799     at_response_free(p_response);
 800 }
 801
 802 static void requestHangup(void *data, size_t datalen, RIL_Token t)
 803 {
 804     int *p_line;
 805
 806     int ret;
 807     char *cmd;
 808
 809     p_line = (int *)data;
 810
 811     // 3GPP 22.030 6.5.5
 812     // "Releases a specific active call X"
 813     asprintf(&cmd, "AT+CHLD=1%d", p_line[0]);
 814
 815     ret = at_send_command(cmd, NULL);
 816
 817     free(cmd);
 818
 819     /* success or failure is ignored by the upper layer here.
 820        it will call GET_CURRENT_CALLS and determine success that way */
 821     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 822 }
 823
 824 static void requestSignalStrength(void *data, size_t datalen, RIL_Token t)
 825 {
 826     ATResponse *p_response = NULL;
 827     int err;
 828     char *line;
 829     int count =0;
 830     int numofElements=sizeof(RIL_SignalStrength_v6)/sizeof(int);
 831     int response[numofElements];
 832
 833     err = at_send_command_singleline("AT+CSQ", "+CSQ:", &p_response);
 834
 835     if (err < 0 || p_response->success == 0) {
 836         RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 837         goto error;
 838     }
 839
 840     line = p_response->p_intermediates->line;
 841
 842     err = at_tok_start(&line);
 843     if (err < 0) goto error;
 844
 845     for (count =0; count < numofElements; count ++) {
 846         err = at_tok_nextint(&line, &(response[count]));
 847         if (err < 0) goto error;
 848     }
 849
 850     RIL_onRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response));
 851
 852     at_response_free(p_response);
 853     return;
 854
 855 error:
 856     RLOGE("requestSignalStrength must never return an error when radio is on");
 857     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 858     at_response_free(p_response);
 859 }
 860
 861 /**
 862  * networkModePossible. Decides whether the network mode is appropriate for the
 863  * specified modem
 864  */
 865 static int networkModePossible(ModemInfo *mdm, int nm)
 866 {
 867     if ((net2modem[nm] & mdm->supportedTechs) == net2modem[nm]) {
 868        return 1;
 869     }
 870     return 0;
 871 }
 872 static void requestSetPreferredNetworkType( int request, void *data,
 873                                             size_t datalen, RIL_Token t )
 874 {
 875     ATResponse *p_response = NULL;
 876     char *cmd = NULL;
 877     int value = *(int *)data;
 878     int current, old;
 879     int err;
 880     int32_t preferred = net2pmask[value];
 881
 882     RLOGD("requestSetPreferredNetworkType: current: %x. New: %x", PREFERRED_NETWORK(sMdmInfo), preferred);
 883     if (!networkModePossible(sMdmInfo, value)) {
 884         RIL_onRequestComplete(t, RIL_E_MODE_NOT_SUPPORTED, NULL, 0);
 885         return;
 886     }
 887     if (query_ctec(sMdmInfo, &current, NULL) < 0) {
 888         RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 889         return;
 890     }
 891     old = PREFERRED_NETWORK(sMdmInfo);
 892     RLOGD("old != preferred: %d", old != preferred);
 893     if (old != preferred) {
 894         asprintf(&cmd, "AT+CTEC=%d,\"%x\"", current, preferred);
 895         RLOGD("Sending command: <%s>", cmd);
 896         err = at_send_command_singleline(cmd, "+CTEC:", &p_response);
 897         free(cmd);
 898         if (err || !p_response->success) {
 899             RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 900             return;
 901         }
 902         PREFERRED_NETWORK(sMdmInfo) = value;
 903         if (!strstr( p_response->p_intermediates->line, "DONE") ) {
 904             int current;
 905             int res = parse_technology_response(p_response->p_intermediates->line, &current, NULL);
 906             switch (res) {
 907                 case -1: // Error or unable to parse
 908                     break;
 909                 case 1: // Only able to parse current
 910                 case 0: // Both current and preferred were parsed
 911                     setRadioTechnology(sMdmInfo, current);
 912                     break;
 913             }
 914         }
 915     }
 916     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 917 }
 918
 919 static void requestGetPreferredNetworkType(int request, void *data,
 920                                    size_t datalen, RIL_Token t)
 921 {
 922     int preferred;
 923     unsigned i;
 924
 925     switch ( query_ctec(sMdmInfo, NULL, &preferred) ) {
 926         case -1: // Error or unable to parse
 927         case 1: // Only able to parse current
 928             RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 929             break;
 930         case 0: // Both current and preferred were parsed
 931             for ( i = 0 ; i < sizeof(net2pmask) / sizeof(int32_t) ; i++ ) {
 932                 if (preferred == net2pmask[i]) {
 933                     RIL_onRequestComplete(t, RIL_E_SUCCESS, &i, sizeof(int));
 934                     return;
 935                 }
 936             }
 937             RLOGE("Unknown preferred mode received from modem: %d", preferred);
 938             RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 939             break;
 940     }
 941
 942 }
 943
 944 static void requestCdmaPrlVersion(int request, void *data,
 945                                    size_t datalen, RIL_Token t)
 946 {
 947     int err;
 948     char * responseStr;
 949     ATResponse *p_response = NULL;
 950     const char *cmd;
 951     char *line;
 952
 953     err = at_send_command_singleline("AT+WPRL?", "+WPRL:", &p_response);
 954     if (err < 0 || !p_response->success) goto error;
 955     line = p_response->p_intermediates->line;
 956     err = at_tok_start(&line);
 957     if (err < 0) goto error;
 958     err = at_tok_nextstr(&line, &responseStr);
 959     if (err < 0 || !responseStr) goto error;
 960     RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, strlen(responseStr));
 961     at_response_free(p_response);
 962     return;
 963 error:
 964     at_response_free(p_response);
 965     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 966 }
 967
 968 static void requestCdmaBaseBandVersion(int request, void *data,
 969                                    size_t datalen, RIL_Token t)
 970 {
 971     int err;
 972     char * responseStr;
 973     ATResponse *p_response = NULL;
 974     const char *cmd;
 975     const char *prefix;
 976     char *line, *p;
 977     int commas;
 978     int skip;
 979     int count = 4;
 980
 981     // Fixed values. TODO: query modem
 982     responseStr = strdup("1.0.0.0");
 983     RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, sizeof(responseStr));
 984     free(responseStr);
 985 }
 986
 987 static void requestCdmaDeviceIdentity(int request, void *data,
 988                                         size_t datalen, RIL_Token t)
 989 {
 990     int err;
 991     int response[4];
 992     char * responseStr[4];
 993     ATResponse *p_response = NULL;
 994     const char *cmd;
 995     const char *prefix;
 996     char *line, *p;
 997     int commas;
 998     int skip;
 999     int count = 4;
1000
1001     // Fixed values. TODO: Query modem
1002     responseStr[0] = "----";
1003     responseStr[1] = "----";
1004     responseStr[2] = "77777777";
1005
1006     err = at_send_command_numeric("AT+CGSN", &p_response);
1007     if (err < 0 || p_response->success == 0) {
1008         RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1009         return;
1010     } else {
1011         responseStr[3] = p_response->p_intermediates->line;
1012     }
1013
1014     RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, count*sizeof(char*));
1015     at_response_free(p_response);
1016
1017     return;
1018 error:
1019     RLOGE("requestCdmaDeviceIdentity must never return an error when radio is on");
1020     at_response_free(p_response);
1021     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1022 }
1023
1024 static void requestCdmaGetSubscriptionSource(int request, void *data,
1025                                         size_t datalen, RIL_Token t)
1026 {
1027     int err;
1028     int *ss = (int *)data;
1029     ATResponse *p_response = NULL;
1030     char *cmd = NULL;
1031     char *line = NULL;
1032     int response;
1033
1034     asprintf(&cmd, "AT+CCSS?");
1035     if (!cmd) goto error;
1036
1037     err = at_send_command_singleline(cmd, "+CCSS:", &p_response);
1038     if (err < 0 || !p_response->success)
1039         goto error;
1040
1041     line = p_response->p_intermediates->line;
1042     err = at_tok_start(&line);
1043     if (err < 0) goto error;
1044
1045     err = at_tok_nextint(&line, &response);
1046     free(cmd);
1047     cmd = NULL;
1048
1049     RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response));
1050
1051     return;
1052 error:
1053     free(cmd);
1054     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1055 }
1056
1057 static void requestCdmaSetSubscriptionSource(int request, void *data,
1058                                         size_t datalen, RIL_Token t)
1059 {
1060     int err;
1061     int *ss = (int *)data;
1062     ATResponse *p_response = NULL;
1063     char *cmd = NULL;
1064
1065     if (!ss || !datalen) {
1066         RLOGE("RIL_REQUEST_CDMA_SET_SUBSCRIPTION without data!");
1067         RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1068         return;
1069     }
1070     asprintf(&cmd, "AT+CCSS=%d", ss[0]);
1071     if (!cmd) goto error;
1072
1073     err = at_send_command(cmd, &p_response);
1074     if (err < 0 || !p_response->success)
1075         goto error;
1076     free(cmd);
1077     cmd = NULL;
1078
1079     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1080
1081     RIL_onUnsolicitedResponse(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED, ss, sizeof(ss[0]));
1082
1083     return;
1084 error:
1085     free(cmd);
1086     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1087 }
1088
1089 static void requestCdmaSubscription(int request, void *data,
1090                                         size_t datalen, RIL_Token t)
1091 {
1092     int err;
1093     int response[5];
1094     char * responseStr[5];
1095     ATResponse *p_response = NULL;
1096     const char *cmd;
1097     const char *prefix;
1098     char *line, *p;
1099     int commas;
1100     int skip;
1101     int count = 5;
1102
1103     // Fixed values. TODO: Query modem
1104     responseStr[0] = "8587777777"; // MDN
1105     responseStr[1] = "1"; // SID
1106     responseStr[2] = "1"; // NID
1107     responseStr[3] = "8587777777"; // MIN
1108     responseStr[4] = "1"; // PRL Version
1109     RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, count*sizeof(char*));
1110
1111     return;
1112 error:
1113     RLOGE("requestRegistrationState must never return an error when radio is on");
1114     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1115 }
1116
1117 static void requestCdmaGetRoamingPreference(int request, void *data,
1118                                                  size_t datalen, RIL_Token t)
1119 {
1120     int roaming_pref = -1;
1121     ATResponse *p_response = NULL;
1122     char *line;
1123     int res;
1124
1125     res = at_send_command_singleline("AT+WRMP?", "+WRMP:", &p_response);
1126     if (res < 0 || !p_response->success) {
1127         goto error;
1128     }
1129     line = p_response->p_intermediates->line;
1130
1131     res = at_tok_start(&line);
1132     if (res < 0) goto error;
1133
1134     res = at_tok_nextint(&line, &roaming_pref);
1135     if (res < 0) goto error;
1136
1137      RIL_onRequestComplete(t, RIL_E_SUCCESS, &roaming_pref, sizeof(roaming_pref));
1138     return;
1139 error:
1140     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1141 }
1142
1143 static void requestCdmaSetRoamingPreference(int request, void *data,
1144                                                  size_t datalen, RIL_Token t)
1145 {
1146     int *pref = (int *)data;
1147     ATResponse *p_response = NULL;
1148     char *line;
1149     int res;
1150     char *cmd = NULL;
1151
1152     asprintf(&cmd, "AT+WRMP=%d", *pref);
1153     if (cmd == NULL) goto error;
1154
1155     res = at_send_command(cmd, &p_response);
1156     if (res < 0 || !p_response->success)
1157         goto error;
1158
1159     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1160     free(cmd);
1161     return;
1162 error:
1163     free(cmd);
1164     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1165 }
1166
1167 static int parseRegistrationState(char *str, int *type, int *items, int **response)
1168 {
1169     int err;
1170     char *line = str, *p;
1171     int *resp = NULL;
1172     int skip;
1173     int count = 3;
1174     int commas;
1175
1176     RLOGD("parseRegistrationState. Parsing: %s",str);
1177     err = at_tok_start(&line);
1178     if (err < 0) goto error;
1179
1180     /* Ok you have to be careful here
1181      * The solicited version of the CREG response is
1182      * +CREG: n, stat, [lac, cid]
1183      * and the unsolicited version is
1184      * +CREG: stat, [lac, cid]
1185      * The <n> parameter is basically "is unsolicited creg on?"
1186      * which it should always be
1187      *
1188      * Now we should normally get the solicited version here,
1189      * but the unsolicited version could have snuck in
1190      * so we have to handle both
1191      *
1192      * Also since the LAC and CID are only reported when registered,
1193      * we can have 1, 2, 3, or 4 arguments here
1194      *
1195      * finally, a +CGREG: answer may have a fifth value that corresponds
1196      * to the network type, as in;
1197      *
1198      *   +CGREG: n, stat [,lac, cid [,networkType]]
1199      */
1200
1201     /* count number of commas */
1202     commas = 0;
1203     for (p = line ; *p != '\0' ;p++) {
1204         if (*p == ',') commas++;
1205     }
1206
1207     resp = (int *)calloc(commas + 1, sizeof(int));
1208     if (!resp) goto error;
1209     switch (commas) {
1210         case 0: /* +CREG: <stat> */
1211             err = at_tok_nextint(&line, &resp[0]);
1212             if (err < 0) goto error;
1213             resp[1] = -1;
1214             resp[2] = -1;
1215         break;
1216
1217         case 1: /* +CREG: <n>, <stat> */
1218             err = at_tok_nextint(&line, &skip);
1219             if (err < 0) goto error;
1220             err = at_tok_nextint(&line, &resp[0]);
1221             if (err < 0) goto error;
1222             resp[1] = -1;
1223             resp[2] = -1;
1224             if (err < 0) goto error;
1225         break;
1226
1227         case 2: /* +CREG: <stat>, <lac>, <cid> */
1228             err = at_tok_nextint(&line, &resp[0]);
1229             if (err < 0) goto error;
1230             err = at_tok_nexthexint(&line, &resp[1]);
1231             if (err < 0) goto error;
1232             err = at_tok_nexthexint(&line, &resp[2]);
1233             if (err < 0) goto error;
1234         break;
1235         case 3: /* +CREG: <n>, <stat>, <lac>, <cid> */
1236             err = at_tok_nextint(&line, &skip);
1237             if (err < 0) goto error;
1238             err = at_tok_nextint(&line, &resp[0]);
1239             if (err < 0) goto error;
1240             err = at_tok_nexthexint(&line, &resp[1]);
1241             if (err < 0) goto error;
1242             err = at_tok_nexthexint(&line, &resp[2]);
1243             if (err < 0) goto error;
1244         break;
1245         /* special case for CGREG, there is a fourth parameter
1246          * that is the network type (unknown/gprs/edge/umts)
1247          */
1248         case 4: /* +CGREG: <n>, <stat>, <lac>, <cid>, <networkType> */
1249             err = at_tok_nextint(&line, &skip);
1250             if (err < 0) goto error;
1251             err = at_tok_nextint(&line, &resp[0]);
1252             if (err < 0) goto error;
1253             err = at_tok_nexthexint(&line, &resp[1]);
1254             if (err < 0) goto error;
1255             err = at_tok_nexthexint(&line, &resp[2]);
1256             if (err < 0) goto error;
1257             err = at_tok_nexthexint(&line, &resp[3]);
1258             if (err < 0) goto error;
1259             count = 4;
1260         break;
1261         default:
1262             goto error;
1263     }
1264     if (response)
1265         *response = resp;
1266     if (items)
1267         *items = commas + 1;
1268     if (type)
1269         *type = techFromModemType(TECH(sMdmInfo));
1270     return 0;
1271 error:
1272     free(resp);
1273     return -1;
1274 }
1275
1276 #define REG_STATE_LEN 15
1277 #define REG_DATA_STATE_LEN 6
1278 static void requestRegistrationState(int request, void *data,
1279                                         size_t datalen, RIL_Token t)
1280 {
1281     int err;
1282     int *registration;
1283     char **responseStr = NULL;
1284     ATResponse *p_response = NULL;
1285     const char *cmd;
1286     const char *prefix;
1287     char *line;
1288     int i = 0, j, numElements = 0;
1289     int count = 3;
1290     int type, startfrom;
1291
1292     RLOGD("requestRegistrationState");
1293     if (request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
1294         cmd = "AT+CREG?";
1295         prefix = "+CREG:";
1296         numElements = REG_STATE_LEN;
1297     } else if (request == RIL_REQUEST_DATA_REGISTRATION_STATE) {
1298         cmd = "AT+CGREG?";
1299         prefix = "+CGREG:";
1300         numElements = REG_DATA_STATE_LEN;
1301     } else {
1302         assert(0);
1303         goto error;
1304     }
1305
1306     err = at_send_command_singleline(cmd, prefix, &p_response);
1307
1308     if (err != 0) goto error;
1309
1310     line = p_response->p_intermediates->line;
1311
1312     if (parseRegistrationState(line, &type, &count, &registration)) goto error;
1313
1314     responseStr = malloc(numElements * sizeof(char *));
1315     if (!responseStr) goto error;
1316     memset(responseStr, 0, numElements * sizeof(char *));
1317     /**
1318      * The first '4' bytes for both registration states remain the same.
1319      * But if the request is 'DATA_REGISTRATION_STATE',
1320      * the 5th and 6th byte(s) are optional.
1321      */
1322     if (is3gpp2(type) == 1) {
1323         RLOGD("registration state type: 3GPP2");
1324         // TODO: Query modem
1325         startfrom = 3;
1326         if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
1327             asprintf(&responseStr[3], "8");     // EvDo revA
1328             asprintf(&responseStr[4], "1");     // BSID
1329             asprintf(&responseStr[5], "123");   // Latitude
1330             asprintf(&responseStr[6], "222");   // Longitude
1331             asprintf(&responseStr[7], "0");     // CSS Indicator
1332             asprintf(&responseStr[8], "4");     // SID
1333             asprintf(&responseStr[9], "65535"); // NID
1334             asprintf(&responseStr[10], "0");    // Roaming indicator
1335             asprintf(&responseStr[11], "1");    // System is in PRL
1336             asprintf(&responseStr[12], "0");    // Default Roaming indicator
1337             asprintf(&responseStr[13], "0");    // Reason for denial
1338             asprintf(&responseStr[14], "0");    // Primary Scrambling Code of Current cell
1339       } else if (request == RIL_REQUEST_DATA_REGISTRATION_STATE) {
1340             asprintf(&responseStr[3], "8");   // Available data radio technology
1341       }
1342     } else { // type == RADIO_TECH_3GPP
1343         RLOGD("registration state type: 3GPP");
1344         startfrom = 0;
1345         asprintf(&responseStr[1], "%x", registration[1]);
1346         asprintf(&responseStr[2], "%x", registration[2]);
1347         if (count > 3)
1348             asprintf(&responseStr[3], "%d", registration[3]);
1349     }
1350     asprintf(&responseStr[0], "%d", registration[0]);
1351
1352     /**
1353      * Optional bytes for DATA_REGISTRATION_STATE request
1354      * 4th byte : Registration denial code
1355      * 5th byte : The max. number of simultaneous Data Calls
1356      */
1357     if(request == RIL_REQUEST_DATA_REGISTRATION_STATE) {
1358         // asprintf(&responseStr[4], "3");
1359         // asprintf(&responseStr[5], "1");
1360     }
1361
1362     for (j = startfrom; j < numElements; j++) {
1363         if (!responseStr[i]) goto error;
1364     }
1365     free(registration);
1366     registration = NULL;
1367
1368     RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, numElements*sizeof(responseStr));
1369     for (j = 0; j < numElements; j++ ) {
1370         free(responseStr[j]);
1371         responseStr[j] = NULL;
1372     }
1373     free(responseStr);
1374     responseStr = NULL;
1375     at_response_free(p_response);
1376
1377     return;
1378 error:
1379     if (responseStr) {
1380         for (j = 0; j < numElements; j++) {
1381             free(responseStr[j]);
1382             responseStr[j] = NULL;
1383         }
1384         free(responseStr);
1385         responseStr = NULL;
1386     }
1387     RLOGE("requestRegistrationState must never return an error when radio is on");
1388     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1389     at_response_free(p_response);
1390 }
1391
1392 static void requestOperator(void *data, size_t datalen, RIL_Token t)
1393 {
1394     int err;
1395     int i;
1396     int skip;
1397     ATLine *p_cur;
1398     char *response[3];
1399
1400     memset(response, 0, sizeof(response));
1401
1402     ATResponse *p_response = NULL;
1403
1404     err = at_send_command_multiline(
1405         "AT+COPS=3,0;+COPS?;+COPS=3,1;+COPS?;+COPS=3,2;+COPS?",
1406         "+COPS:", &p_response);
1407
1408     /* we expect 3 lines here:
1409      * +COPS: 0,0,"T - Mobile"
1410      * +COPS: 0,1,"TMO"
1411      * +COPS: 0,2,"310170"
1412      */
1413
1414     if (err != 0) goto error;
1415
1416     for (i = 0, p_cur = p_response->p_intermediates
1417             ; p_cur != NULL
1418             ; p_cur = p_cur->p_next, i++
1419     ) {
1420         char *line = p_cur->line;
1421
1422         err = at_tok_start(&line);
1423         if (err < 0) goto error;
1424
1425         err = at_tok_nextint(&line, &skip);
1426         if (err < 0) goto error;
1427
1428         // If we're unregistered, we may just get
1429         // a "+COPS: 0" response
1430         if (!at_tok_hasmore(&line)) {
1431             response[i] = NULL;
1432             continue;
1433         }
1434
1435         err = at_tok_nextint(&line, &skip);
1436         if (err < 0) goto error;
1437
1438         // a "+COPS: 0, n" response is also possible
1439         if (!at_tok_hasmore(&line)) {
1440             response[i] = NULL;
1441             continue;
1442         }
1443
1444         err = at_tok_nextstr(&line, &(response[i]));
1445         if (err < 0) goto error;
1446     }
1447
1448     if (i != 3) {
1449         /* expect 3 lines exactly */
1450         goto error;
1451     }
1452
1453     RIL_onRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response));
1454     at_response_free(p_response);
1455
1456     return;
1457 error:
1458     RLOGE("requestOperator must not return error when radio is on");
1459     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1460     at_response_free(p_response);
1461 }
1462
1463 static void requestCdmaSendSMS(void *data, size_t datalen, RIL_Token t)
1464 {
1465     int err = 1; // Set to go to error:
1466     RIL_SMS_Response response;
1467     RIL_CDMA_SMS_Message* rcsm;
1468
1469     RLOGD("requestCdmaSendSMS datalen=%d, sizeof(RIL_CDMA_SMS_Message)=%d",
1470             datalen, sizeof(RIL_CDMA_SMS_Message));
1471
1472     // verify data content to test marshalling/unmarshalling:
1473     rcsm = (RIL_CDMA_SMS_Message*)data;
1474     RLOGD("TeleserviceID=%d, bIsServicePresent=%d, \
1475             uServicecategory=%d, sAddress.digit_mode=%d, \
1476             sAddress.Number_mode=%d, sAddress.number_type=%d, ",
1477             rcsm->uTeleserviceID,  rcsm->bIsServicePresent,
1478             rcsm->uServicecategory,rcsm->sAddress.digit_mode,
1479             rcsm->sAddress.number_mode,rcsm->sAddress.number_type);
1480
1481     if (err != 0) goto error;
1482
1483     // Cdma Send SMS implementation will go here:
1484     // But it is not implemented yet.
1485
1486     memset(&response, 0, sizeof(response));
1487     RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response));
1488     return;
1489
1490 error:
1491     // Cdma Send SMS will always cause send retry error.
1492     RIL_onRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, NULL, 0);
1493 }
1494
1495 static void requestSendSMS(void *data, size_t datalen, RIL_Token t)
1496 {
1497     int err;
1498     const char *smsc;
1499     const char *pdu;
1500     int tpLayerLength;
1501     char *cmd1, *cmd2;
1502     RIL_SMS_Response response;
1503     ATResponse *p_response = NULL;
1504
1505     smsc = ((const char **)data)[0];
1506     pdu = ((const char **)data)[1];
1507
1508     tpLayerLength = strlen(pdu)/2;
1509
1510     // "NULL for default SMSC"
1511     if (smsc == NULL) {
1512         smsc= "00";
1513     }
1514
1515     asprintf(&cmd1, "AT+CMGS=%d", tpLayerLength);
1516     asprintf(&cmd2, "%s%s", smsc, pdu);
1517
1518     err = at_send_command_sms(cmd1, cmd2, "+CMGS:", &p_response);
1519
1520     if (err != 0 || p_response->success == 0) goto error;
1521
1522     memset(&response, 0, sizeof(response));
1523
1524     /* FIXME fill in messageRef and ackPDU */
1525
1526     RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response));
1527     at_response_free(p_response);
1528
1529     return;
1530 error:
1531     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1532     at_response_free(p_response);
1533 }
1534
1535 static void requestSetupDataCall(void *data, size_t datalen, RIL_Token t)
1536 {
1537     const char *apn;
1538     char *cmd;
1539     int err;
1540     ATResponse *p_response = NULL;
1541
1542     apn = ((const char **)data)[2];
1543
1544 #ifdef USE_TI_COMMANDS
1545     // Config for multislot class 10 (probably default anyway eh?)
1546     err = at_send_command("AT%CPRIM=\"GMM\",\"CONFIG MULTISLOT_CLASS=<10>\"",
1547                         NULL);
1548
1549     err = at_send_command("AT%DATA=2,\"UART\",1,,\"SER\",\"UART\",0", NULL);
1550 #endif /* USE_TI_COMMANDS */
1551
1552     int fd, qmistatus;
1553     size_t cur = 0;
1554     size_t len;
1555     ssize_t written, rlen;
1556     char status[32] = {0};
1557     int retry = 10;
1558     const char *pdp_type;
1559
1560     RLOGD("requesting data connection to APN '%s'", apn);
1561
1562     fd = open ("/dev/qmi", O_RDWR);
1563     if (fd >= 0) { /* the device doesn't exist on the emulator */
1564
1565         RLOGD("opened the qmi device\n");
1566         asprintf(&cmd, "up:%s", apn);
1567         len = strlen(cmd);
1568
1569         while (cur < len) {
1570             do {
1571                 written = write (fd, cmd + cur, len - cur);
1572             } while (written < 0 && errno == EINTR);
1573
1574             if (written < 0) {
1575                 RLOGE("### ERROR writing to /dev/qmi");
1576                 close(fd);
1577                 goto error;
1578             }
1579
1580             cur += written;
1581         }
1582
1583         // wait for interface to come online
1584
1585         do {
1586             sleep(1);
1587             do {
1588                 rlen = read(fd, status, 31);
1589             } while (rlen < 0 && errno == EINTR);
1590
1591             if (rlen < 0) {
1592                 RLOGE("### ERROR reading from /dev/qmi");
1593                 close(fd);
1594                 goto error;
1595             } else {
1596                 status[rlen] = '\0';
1597                 RLOGD("### status: %s", status);
1598             }
1599         } while (strncmp(status, "STATE=up", 8) && strcmp(status, "online") && --retry);
1600
1601         close(fd);
1602
1603         if (retry == 0) {
1604             RLOGE("### Failed to get data connection up\n");
1605             goto error;
1606         }
1607
1608         qmistatus = system("netcfg rmnet0 dhcp");
1609
1610         RLOGD("netcfg rmnet0 dhcp: status %d\n", qmistatus);
1611
1612         if (qmistatus < 0) goto error;
1613
1614     } else {
1615
1616         if (datalen > 6 * sizeof(char *)) {
1617             pdp_type = ((const char **)data)[6];
1618         } else {
1619             pdp_type = "IP";
1620         }
1621
1622         asprintf(&cmd, "AT+CGDCONT=1,\"%s\",\"%s\",,0,0", pdp_type, apn);
1623         //FIXME check for error here
1624         err = at_send_command(cmd, NULL);
1625         free(cmd);
1626
1627         // Set required QoS params to default
1628         err = at_send_command("AT+CGQREQ=1", NULL);
1629
1630         // Set minimum QoS params to default
1631         err = at_send_command("AT+CGQMIN=1", NULL);
1632
1633         // packet-domain event reporting
1634         err = at_send_command("AT+CGEREP=1,0", NULL);
1635
1636         // Hangup anything that's happening there now
1637         err = at_send_command("AT+CGACT=1,0", NULL);
1638
1639         // Start data on PDP context 1
1640         err = at_send_command("ATD*99***1#", &p_response);
1641
1642         if (err < 0 || p_response->success == 0) {
1643             goto error;
1644         }
1645     }
1646
1647     requestOrSendDataCallList(&t);
1648
1649     at_response_free(p_response);
1650
1651     return;
1652 error:
1653     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1654     at_response_free(p_response);
1655
1656 }
1657
1658 static void requestSMSAcknowledge(void *data, size_t datalen, RIL_Token t)
1659 {
1660     int ackSuccess;
1661     int err;
1662
1663     ackSuccess = ((int *)data)[0];
1664
1665     if (ackSuccess == 1) {
1666         err = at_send_command("AT+CNMA=1", NULL);
1667     } else if (ackSuccess == 0)  {
1668         err = at_send_command("AT+CNMA=2", NULL);
1669     } else {
1670         RLOGE("unsupported arg to RIL_REQUEST_SMS_ACKNOWLEDGE\n");
1671         goto error;
1672     }
1673
1674     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1675 error:
1676     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1677
1678 }
1679
1680 static void  requestSIM_IO(void *data, size_t datalen, RIL_Token t)
1681 {
1682     ATResponse *p_response = NULL;
1683     RIL_SIM_IO_Response sr;
1684     int err;
1685     char *cmd = NULL;
1686     RIL_SIM_IO_v6 *p_args;
1687     char *line;
1688
1689     memset(&sr, 0, sizeof(sr));
1690
1691     p_args = (RIL_SIM_IO_v6 *)data;
1692
1693     /* FIXME handle pin2 */
1694
1695     if (p_args->data == NULL) {
1696         asprintf(&cmd, "AT+CRSM=%d,%d,%d,%d,%d",
1697                     p_args->command, p_args->fileid,
1698                     p_args->p1, p_args->p2, p_args->p3);
1699     } else {
1700         asprintf(&cmd, "AT+CRSM=%d,%d,%d,%d,%d,%s",
1701                     p_args->command, p_args->fileid,
1702                     p_args->p1, p_args->p2, p_args->p3, p_args->data);
1703     }
1704
1705     err = at_send_command_singleline(cmd, "+CRSM:", &p_response);
1706
1707     if (err < 0 || p_response->success == 0) {
1708         goto error;
1709     }
1710
1711     line = p_response->p_intermediates->line;
1712
1713     err = at_tok_start(&line);
1714     if (err < 0) goto error;
1715
1716     err = at_tok_nextint(&line, &(sr.sw1));
1717     if (err < 0) goto error;
1718
1719     err = at_tok_nextint(&line, &(sr.sw2));
1720     if (err < 0) goto error;
1721
1722     if (at_tok_hasmore(&line)) {
1723         err = at_tok_nextstr(&line, &(sr.simResponse));
1724         if (err < 0) goto error;
1725     }
1726
1727     RIL_onRequestComplete(t, RIL_E_SUCCESS, &sr, sizeof(sr));
1728     at_response_free(p_response);
1729     free(cmd);
1730
1731     return;
1732 error:
1733     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1734     at_response_free(p_response);
1735     free(cmd);
1736
1737 }
1738
1739 static void  requestEnterSimPin(void*  data, size_t  datalen, RIL_Token  t)
1740 {
1741     ATResponse   *p_response = NULL;
1742     int           err;
1743     char*         cmd = NULL;
1744     const char**  strings = (const char**)data;;
1745
1746     if ( datalen == sizeof(char*) ) {
1747         asprintf(&cmd, "AT+CPIN=%s", strings[0]);
1748     } else if ( datalen == 2*sizeof(char*) ) {
1749         asprintf(&cmd, "AT+CPIN=%s,%s", strings[0], strings[1]);
1750     } else
1751         goto error;
1752
1753     err = at_send_command_singleline(cmd, "+CPIN:", &p_response);
1754     free(cmd);
1755
1756     if (err < 0 || p_response->success == 0) {
1757 error:
1758         RIL_onRequestComplete(t, RIL_E_PASSWORD_INCORRECT, NULL, 0);
1759     } else {
1760         RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1761     }
1762     at_response_free(p_response);
1763 }
1764
1765
1766 static void  requestSendUSSD(void *data, size_t datalen, RIL_Token t)
1767 {
1768     const char *ussdRequest;
1769
1770     ussdRequest = (char *)(data);
1771
1772
1773     RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
1774
1775 // @@@ TODO
1776
1777 }
1778
1779 static void requestExitEmergencyMode(void *data, size_t datalen, RIL_Token t)
1780 {
1781     int err;
1782     ATResponse *p_response = NULL;
1783
1784     err = at_send_command("AT+WSOS=0", &p_response);
1785
1786     if (err < 0 || p_response->success == 0) {
1787         RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1788         return;
1789     }
1790
1791     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1792 }
1793
1794 // TODO: Use all radio types
1795 static int techFromModemType(int mdmtype)
1796 {
1797     int ret = -1;
1798     switch (1 << mdmtype) {
1799         case MDM_CDMA:
1800             ret = RADIO_TECH_1xRTT;
1801             break;
1802         case MDM_EVDO:
1803             ret = RADIO_TECH_EVDO_A;
1804             break;
1805         case MDM_GSM:
1806             ret = RADIO_TECH_GPRS;
1807             break;
1808         case MDM_WCDMA:
1809             ret = RADIO_TECH_HSPA;
1810             break;
1811         case MDM_LTE:
1812             ret = RADIO_TECH_LTE;
1813             break;
1814     }
1815     return ret;
1816 }
1817
1818 /*** Callback methods from the RIL library to us ***/
1819
1820 /**
1821  * Call from RIL to us to make a RIL_REQUEST
1822  *
1823  * Must be completed with a call to RIL_onRequestComplete()
1824  *
1825  * RIL_onRequestComplete() may be called from any thread, before or after
1826  * this function returns.
1827  *
1828  * Will always be called from the same thread, so returning here implies
1829  * that the radio is ready to process another command (whether or not
1830  * the previous command has completed).
1831  */
1832 static void
1833 onRequest (int request, void *data, size_t datalen, RIL_Token t)
1834 {
1835     ATResponse *p_response;
1836     int err;
1837
1838     RLOGD("onRequest: %s", requestToString(request));
1839
1840     /* Ignore all requests except RIL_REQUEST_GET_SIM_STATUS
1841      * when RADIO_STATE_UNAVAILABLE.
1842      */
1843     if (sState == RADIO_STATE_UNAVAILABLE
1844         && request != RIL_REQUEST_GET_SIM_STATUS
1845     ) {
1846         RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1847         return;
1848     }
1849
1850     /* Ignore all non-power requests when RADIO_STATE_OFF
1851      * (except RIL_REQUEST_GET_SIM_STATUS)
1852      */
1853     if (sState == RADIO_STATE_OFF
1854         && !(request == RIL_REQUEST_RADIO_POWER
1855             || request == RIL_REQUEST_GET_SIM_STATUS)
1856     ) {
1857         RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1858         return;
1859     }
1860
1861     switch (request) {
1862         case RIL_REQUEST_GET_SIM_STATUS: {
1863             RIL_CardStatus_v6 *p_card_status;
1864             char *p_buffer;
1865             int buffer_size;
1866
1867             int result = getCardStatus(&p_card_status);
1868             if (result == RIL_E_SUCCESS) {
1869                 p_buffer = (char *)p_card_status;
1870                 buffer_size = sizeof(*p_card_status);
1871             } else {
1872                 p_buffer = NULL;
1873                 buffer_size = 0;
1874             }
1875             RIL_onRequestComplete(t, result, p_buffer, buffer_size);
1876             freeCardStatus(p_card_status);
1877             break;
1878         }
1879         case RIL_REQUEST_GET_CURRENT_CALLS:
1880             requestGetCurrentCalls(data, datalen, t);
1881             break;
1882         case RIL_REQUEST_DIAL:
1883             requestDial(data, datalen, t);
1884             break;
1885         case RIL_REQUEST_HANGUP:
1886             requestHangup(data, datalen, t);
1887             break;
1888         case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND:
1889             // 3GPP 22.030 6.5.5
1890             // "Releases all held calls or sets User Determined User Busy
1891             //  (UDUB) for a waiting call."
1892             at_send_command("AT+CHLD=0", NULL);
1893
1894             /* success or failure is ignored by the upper layer here.
1895                it will call GET_CURRENT_CALLS and determine success that way */
1896             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1897             break;
1898         case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND:
1899             // 3GPP 22.030 6.5.5
1900             // "Releases all active calls (if any exist) and accepts
1901             //  the other (held or waiting) call."
1902             at_send_command("AT+CHLD=1", NULL);
1903
1904             /* success or failure is ignored by the upper layer here.
1905                it will call GET_CURRENT_CALLS and determine success that way */
1906             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1907             break;
1908         case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE:
1909             // 3GPP 22.030 6.5.5
1910             // "Places all active calls (if any exist) on hold and accepts
1911             //  the other (held or waiting) call."
1912             at_send_command("AT+CHLD=2", NULL);
1913
1914 #ifdef WORKAROUND_ERRONEOUS_ANSWER
1915             s_expectAnswer = 1;
1916 #endif /* WORKAROUND_ERRONEOUS_ANSWER */
1917
1918             /* success or failure is ignored by the upper layer here.
1919                it will call GET_CURRENT_CALLS and determine success that way */
1920             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1921             break;
1922         case RIL_REQUEST_ANSWER:
1923             at_send_command("ATA", NULL);
1924
1925 #ifdef WORKAROUND_ERRONEOUS_ANSWER
1926             s_expectAnswer = 1;
1927 #endif /* WORKAROUND_ERRONEOUS_ANSWER */
1928
1929             /* success or failure is ignored by the upper layer here.
1930                it will call GET_CURRENT_CALLS and determine success that way */
1931             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1932             break;
1933         case RIL_REQUEST_CONFERENCE:
1934             // 3GPP 22.030 6.5.5
1935             // "Adds a held call to the conversation"
1936             at_send_command("AT+CHLD=3", NULL);
1937
1938             /* success or failure is ignored by the upper layer here.
1939                it will call GET_CURRENT_CALLS and determine success that way */
1940             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1941             break;
1942         case RIL_REQUEST_UDUB:
1943             /* user determined user busy */
1944             /* sometimes used: ATH */
1945             at_send_command("ATH", NULL);
1946
1947             /* success or failure is ignored by the upper layer here.
1948                it will call GET_CURRENT_CALLS and determine success that way */
1949             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1950             break;
1951
1952         case RIL_REQUEST_SEPARATE_CONNECTION:
1953             {
1954                 char  cmd[12];
1955                 int   party = ((int*)data)[0];
1956
1957                 // Make sure that party is in a valid range.
1958                 // (Note: The Telephony middle layer imposes a range of 1 to 7.
1959                 // It's sufficient for us to just make sure it's single digit.)
1960                 if (party > 0 && party < 10) {
1961                     sprintf(cmd, "AT+CHLD=2%d", party);
1962                     at_send_command(cmd, NULL);
1963                     RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1964                 } else {
1965                     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1966                 }
1967             }
1968             break;
1969
1970         case RIL_REQUEST_SIGNAL_STRENGTH:
1971             requestSignalStrength(data, datalen, t);
1972             break;
1973         case RIL_REQUEST_VOICE_REGISTRATION_STATE:
1974         case RIL_REQUEST_DATA_REGISTRATION_STATE:
1975             requestRegistrationState(request, data, datalen, t);
1976             break;
1977         case RIL_REQUEST_OPERATOR:
1978             requestOperator(data, datalen, t);
1979             break;
1980         case RIL_REQUEST_RADIO_POWER:
1981             requestRadioPower(data, datalen, t);
1982             break;
1983         case RIL_REQUEST_DTMF: {
1984             char c = ((char *)data)[0];
1985             char *cmd;
1986             asprintf(&cmd, "AT+VTS=%c", (int)c);
1987             at_send_command(cmd, NULL);
1988             free(cmd);
1989             RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1990             break;
1991         }
1992         case RIL_REQUEST_SEND_SMS:
1993             requestSendSMS(data, datalen, t);
1994             break;
1995         case RIL_REQUEST_CDMA_SEND_SMS:
1996             requestCdmaSendSMS(data, datalen, t);
1997             break;
1998         case RIL_REQUEST_SETUP_DATA_CALL:
1999             requestSetupDataCall(data, datalen, t);
2000             break;
2001         case RIL_REQUEST_SMS_ACKNOWLEDGE:
2002             requestSMSAcknowledge(data, datalen, t);
2003             break;
2004
2005         case RIL_REQUEST_GET_IMSI:
2006             p_response = NULL;
2007             err = at_send_command_numeric("AT+CIMI", &p_response);
2008
2009             if (err < 0 || p_response->success == 0) {
2010                 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
2011             } else {
2012                 RIL_onRequestComplete(t, RIL_E_SUCCESS,
2013                     p_response->p_intermediates->line, sizeof(char *));
2014             }
2015             at_response_free(p_response);
2016             break;
2017
2018         case RIL_REQUEST_GET_IMEI:
2019             p_response = NULL;
2020             err = at_send_command_numeric("AT+CGSN", &p_response);
2021
2022             if (err < 0 || p_response->success == 0) {
2023                 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
2024             } else {
2025                 RIL_onRequestComplete(t, RIL_E_SUCCESS,
2026                     p_response->p_intermediates->line, sizeof(char *));
2027             }
2028             at_response_free(p_response);
2029             break;
2030
2031         case RIL_REQUEST_SIM_IO:
2032             requestSIM_IO(data,datalen,t);
2033             break;
2034
2035         case RIL_REQUEST_SEND_USSD:
2036             requestSendUSSD(data, datalen, t);
2037             break;
2038
2039         case RIL_REQUEST_CANCEL_USSD:
2040             p_response = NULL;
2041             err = at_send_command_numeric("AT+CUSD=2", &p_response);
2042
2043             if (err < 0 || p_response->success == 0) {
2044                 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
2045             } else {
2046                 RIL_onRequestComplete(t, RIL_E_SUCCESS,
2047                     p_response->p_intermediates->line, sizeof(char *));
2048             }
2049             at_response_free(p_response);
2050             break;
2051
2052         case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC:
2053             at_send_command("AT+COPS=0", NULL);
2054             break;
2055
2056         case RIL_REQUEST_DATA_CALL_LIST:
2057             requestDataCallList(data, datalen, t);
2058             break;
2059
2060         case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE:
2061             requestQueryNetworkSelectionMode(data, datalen, t);
2062             break;
2063
2064         case RIL_REQUEST_OEM_HOOK_RAW:
2065             // echo back data
2066             RIL_onRequestComplete(t, RIL_E_SUCCESS, data, datalen);
2067             break;
2068
2069
2070         case RIL_REQUEST_OEM_HOOK_STRINGS: {
2071             int i;
2072             const char ** cur;
2073
2074             RLOGD("got OEM_HOOK_STRINGS: 0x%8p %lu", data, (long)datalen);
2075
2076
2077             for (i = (datalen / sizeof (char *)), cur = (const char **)data ;
2078                     i > 0 ; cur++, i --) {
2079                 RLOGD("> '%s'", *cur);
2080             }
2081
2082             // echo back strings
2083             RIL_onRequestComplete(t, RIL_E_SUCCESS, data, datalen);
2084             break;
2085         }
2086
2087         case RIL_REQUEST_WRITE_SMS_TO_SIM:
2088             requestWriteSmsToSim(data, datalen, t);
2089             break;
2090
2091         case RIL_REQUEST_DELETE_SMS_ON_SIM: {
2092             char * cmd;
2093             p_response = NULL;
2094             asprintf(&cmd, "AT+CMGD=%d", ((int *)data)[0]);
2095             err = at_send_command(cmd, &p_response);
2096             free(cmd);
2097             if (err < 0 || p_response->success == 0) {
2098                 RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
2099             } else {
2100                 RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2101             }
2102             at_response_free(p_response);
2103             break;
2104         }
2105
2106         case RIL_REQUEST_ENTER_SIM_PIN:
2107         case RIL_REQUEST_ENTER_SIM_PUK:
2108         case RIL_REQUEST_ENTER_SIM_PIN2:
2109         case RIL_REQUEST_ENTER_SIM_PUK2:
2110         case RIL_REQUEST_CHANGE_SIM_PIN:
2111         case RIL_REQUEST_CHANGE_SIM_PIN2:
2112             requestEnterSimPin(data, datalen, t);
2113             break;
2114
2115         case RIL_REQUEST_VOICE_RADIO_TECH:
2116             {
2117                 int tech = techFromModemType(TECH(sMdmInfo));
2118                 if (tech < 0 )
2119                     RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
2120                 else
2121                     RIL_onRequestComplete(t, RIL_E_SUCCESS, &tech, sizeof(tech));
2122             }
2123             break;
2124         case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE:
2125             requestSetPreferredNetworkType(request, data, datalen, t);
2126             break;
2127
2128         case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE:
2129             requestGetPreferredNetworkType(request, data, datalen, t);
2130             break;
2131
2132         /* CDMA Specific Requests */
2133         case RIL_REQUEST_BASEBAND_VERSION:
2134             if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
2135                 requestCdmaBaseBandVersion(request, data, datalen, t);
2136                 break;
2137             } // Fall-through if tech is not cdma
2138
2139         case RIL_REQUEST_DEVICE_IDENTITY:
2140             if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
2141                 requestCdmaDeviceIdentity(request, data, datalen, t);
2142                 break;
2143             } // Fall-through if tech is not cdma
2144
2145         case RIL_REQUEST_CDMA_SUBSCRIPTION:
2146             if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
2147                 requestCdmaSubscription(request, data, datalen, t);
2148                 break;
2149             } // Fall-through if tech is not cdma
2150
2151         case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:
2152             if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
2153                 requestCdmaSetSubscriptionSource(request, data, datalen, t);
2154                 break;
2155             } // Fall-through if tech is not cdma
2156
2157         case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE:
2158             if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
2159                 requestCdmaGetSubscriptionSource(request, data, datalen, t);
2160                 break;
2161             } // Fall-through if tech is not cdma
2162
2163         case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:
2164             if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
2165                 requestCdmaGetRoamingPreference(request, data, datalen, t);
2166                 break;
2167             } // Fall-through if tech is not cdma
2168
2169         case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:
2170             if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
2171                 requestCdmaSetRoamingPreference(request, data, datalen, t);
2172                 break;
2173             } // Fall-through if tech is not cdma
2174
2175         case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE:
2176             if (TECH_BIT(sMdmInfo) == MDM_CDMA) {
2177                 requestExitEmergencyMode(data, datalen, t);
2178                 break;
2179             } // Fall-through if tech is not cdma
2180
2181         default:
2182             RLOGD("Request not supported. Tech: %d",TECH(sMdmInfo));
2183             RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
2184             break;
2185     }
2186 }
2187
2188 /**
2189  * Synchronous call from the RIL to us to return current radio state.
2190  * RADIO_STATE_UNAVAILABLE should be the initial state.
2191  */
2192 static RIL_RadioState
2193 currentState()
2194 {
2195     return sState;
2196 }
2197 /**
2198  * Call from RIL to us to find out whether a specific request code
2199  * is supported by this implementation.
2200  *
2201  * Return 1 for "supported" and 0 for "unsupported"
2202  */
2203
2204 static int
2205 onSupports (int requestCode)
2206 {
2207     //@@@ todo
2208
2209     return 1;
2210 }
2211
2212 static void onCancel (RIL_Token t)
2213 {
2214     //@@@todo
2215
2216 }
2217
2218 static const char * getVersion(void)
2219 {
2220     return "android reference-ril 1.0";
2221 }
2222
2223 static void
2224 setRadioTechnology(ModemInfo *mdm, int newtech)
2225 {
2226     RLOGD("setRadioTechnology(%d)", newtech);
2227
2228     int oldtech = TECH(mdm);
2229
2230     if (newtech != oldtech) {
2231         RLOGD("Tech change (%d => %d)", oldtech, newtech);
2232         TECH(mdm) = newtech;
2233         if (techFromModemType(newtech) != techFromModemType(oldtech)) {
2234             int tech = techFromModemType(TECH(sMdmInfo));
2235             if (tech > 0 ) {
2236                 RIL_onUnsolicitedResponse(RIL_UNSOL_VOICE_RADIO_TECH_CHANGED,
2237                                           &tech, sizeof(tech));
2238             }
2239         }
2240     }
2241 }
2242
2243 static void
2244 setRadioState(RIL_RadioState newState)
2245 {
2246     RLOGD("setRadioState(%d)", newState);
2247     RIL_RadioState oldState;
2248
2249     pthread_mutex_lock(&s_state_mutex);
2250
2251     oldState = sState;
2252
2253     if (s_closed > 0) {
2254         // If we're closed, the only reasonable state is
2255         // RADIO_STATE_UNAVAILABLE
2256         // This is here because things on the main thread
2257         // may attempt to change the radio state after the closed
2258         // event happened in another thread
2259         newState = RADIO_STATE_UNAVAILABLE;
2260     }
2261
2262     if (sState != newState || s_closed > 0) {
2263         sState = newState;
2264
2265         pthread_cond_broadcast (&s_state_cond);
2266     }
2267
2268     pthread_mutex_unlock(&s_state_mutex);
2269
2270
2271     /* do these outside of the mutex */
2272     if (sState != oldState) {
2273         RIL_onUnsolicitedResponse (RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
2274                                     NULL, 0);
2275
2276         /* FIXME onSimReady() and onRadioPowerOn() cannot be called
2277          * from the AT reader thread
2278          * Currently, this doesn't happen, but if that changes then these
2279          * will need to be dispatched on the request thread
2280          */
2281         if (sState == RADIO_STATE_ON) {
2282             onRadioPowerOn();
2283         }
2284     }
2285 }
2286
2287 /** Returns RUIM_NOT_READY on error */
2288 static SIM_Status
2289 getRUIMStatus()
2290 {
2291     ATResponse *p_response = NULL;
2292     int err;
2293     int ret;
2294     char *cpinLine;
2295     char *cpinResult;
2296
2297     if (sState == RADIO_STATE_OFF || sState == RADIO_STATE_UNAVAILABLE) {
2298         ret = SIM_NOT_READY;
2299         goto done;
2300     }
2301
2302     err = at_send_command_singleline("AT+CPIN?", "+CPIN:", &p_response);
2303
2304     if (err != 0) {
2305         ret = SIM_NOT_READY;
2306         goto done;
2307     }
2308
2309     switch (at_get_cme_error(p_response)) {
2310         case CME_SUCCESS:
2311             break;
2312
2313         case CME_SIM_NOT_INSERTED:
2314             ret = SIM_ABSENT;
2315             goto done;
2316
2317         default:
2318             ret = SIM_NOT_READY;
2319             goto done;
2320     }
2321
2322     /* CPIN? has succeeded, now look at the result */
2323
2324     cpinLine = p_response->p_intermediates->line;
2325     err = at_tok_start (&cpinLine);
2326
2327     if (err < 0) {
2328         ret = SIM_NOT_READY;
2329         goto done;
2330     }
2331
2332     err = at_tok_nextstr(&cpinLine, &cpinResult);
2333
2334     if (err < 0) {
2335         ret = SIM_NOT_READY;
2336         goto done;
2337     }
2338
2339     if (0 == strcmp (cpinResult, "SIM PIN")) {
2340         ret = SIM_PIN;
2341         goto done;
2342     } else if (0 == strcmp (cpinResult, "SIM PUK")) {
2343         ret = SIM_PUK;
2344         goto done;
2345     } else if (0 == strcmp (cpinResult, "PH-NET PIN")) {
2346         return SIM_NETWORK_PERSONALIZATION;
2347     } else if (0 != strcmp (cpinResult, "READY"))  {
2348         /* we're treating unsupported lock types as "sim absent" */
2349         ret = SIM_ABSENT;
2350         goto done;
2351     }
2352
2353     at_response_free(p_response);
2354     p_response = NULL;
2355     cpinResult = NULL;
2356
2357     ret = SIM_READY;
2358
2359 done:
2360     at_response_free(p_response);
2361     return ret;
2362 }
2363
2364 /** Returns SIM_NOT_READY on error */
2365 static SIM_Status
2366 getSIMStatus()
2367 {
2368     ATResponse *p_response = NULL;
2369     int err;
2370     int ret;
2371     char *cpinLine;
2372     char *cpinResult;
2373
2374     RLOGD("getSIMStatus(). sState: %d",sState);
2375     if (sState == RADIO_STATE_OFF || sState == RADIO_STATE_UNAVAILABLE) {
2376         ret = SIM_NOT_READY;
2377         goto done;
2378     }
2379
2380     err = at_send_command_singleline("AT+CPIN?", "+CPIN:", &p_response);
2381
2382     if (err != 0) {
2383         ret = SIM_NOT_READY;
2384         goto done;
2385     }
2386
2387     switch (at_get_cme_error(p_response)) {
2388         case CME_SUCCESS:
2389             break;
2390
2391         case CME_SIM_NOT_INSERTED:
2392             ret = SIM_ABSENT;
2393             goto done;
2394
2395         default:
2396             ret = SIM_NOT_READY;
2397             goto done;
2398     }
2399
2400     /* CPIN? has succeeded, now look at the result */
2401
2402     cpinLine = p_response->p_intermediates->line;
2403     err = at_tok_start (&cpinLine);
2404
2405     if (err < 0) {
2406         ret = SIM_NOT_READY;
2407         goto done;
2408     }
2409
2410     err = at_tok_nextstr(&cpinLine, &cpinResult);
2411
2412     if (err < 0) {
2413         ret = SIM_NOT_READY;
2414         goto done;
2415     }
2416
2417     if (0 == strcmp (cpinResult, "SIM PIN")) {
2418         ret = SIM_PIN;
2419         goto done;
2420     } else if (0 == strcmp (cpinResult, "SIM PUK")) {
2421         ret = SIM_PUK;
2422         goto done;
2423     } else if (0 == strcmp (cpinResult, "PH-NET PIN")) {
2424         return SIM_NETWORK_PERSONALIZATION;
2425     } else if (0 != strcmp (cpinResult, "READY"))  {
2426         /* we're treating unsupported lock types as "sim absent" */
2427         ret = SIM_ABSENT;
2428         goto done;
2429     }
2430
2431     at_response_free(p_response);
2432     p_response = NULL;
2433     cpinResult = NULL;
2434
2435     ret = SIM_READY;
2436
2437 done:
2438     at_response_free(p_response);
2439     return ret;
2440 }
2441
2442
2443 /**
2444  * Get the current card status.
2445  *
2446  * This must be freed using freeCardStatus.
2447  * @return: On success returns RIL_E_SUCCESS
2448  */
2449 static int getCardStatus(RIL_CardStatus_v6 **pp_card_status) {
2450     static RIL_AppStatus app_status_array[] = {
2451         // SIM_ABSENT = 0
2452         { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN,
2453           NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },
2454         // SIM_NOT_READY = 1
2455         { RIL_APPTYPE_SIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN,
2456           NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },
2457         // SIM_READY = 2
2458         { RIL_APPTYPE_SIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY,
2459           NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },
2460         // SIM_PIN = 3
2461         { RIL_APPTYPE_SIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN,
2462           NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN },
2463         // SIM_PUK = 4
2464         { RIL_APPTYPE_SIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN,
2465           NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN },
2466         // SIM_NETWORK_PERSONALIZATION = 5
2467         { RIL_APPTYPE_SIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK,
2468           NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN },
2469         // RUIM_ABSENT = 6
2470         { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN,
2471           NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },
2472         // RUIM_NOT_READY = 7
2473         { RIL_APPTYPE_RUIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN,
2474           NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },
2475         // RUIM_READY = 8
2476         { RIL_APPTYPE_RUIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY,
2477           NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN },
2478         // RUIM_PIN = 9
2479         { RIL_APPTYPE_RUIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN,
2480           NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN },
2481         // RUIM_PUK = 10
2482         { RIL_APPTYPE_RUIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN,
2483           NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN },
2484         // RUIM_NETWORK_PERSONALIZATION = 11
2485         { RIL_APPTYPE_RUIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK,
2486            NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }
2487     };
2488     RIL_CardState card_state;
2489     int num_apps;
2490
2491     int sim_status = getSIMStatus();
2492     if (sim_status == SIM_ABSENT) {
2493         card_state = RIL_CARDSTATE_ABSENT;
2494         num_apps = 0;
2495     } else {
2496         card_state = RIL_CARDSTATE_PRESENT;
2497         num_apps = 2;
2498     }
2499
2500     // Allocate and initialize base card status.
2501     RIL_CardStatus_v6 *p_card_status = malloc(sizeof(RIL_CardStatus_v6));
2502     p_card_status->card_state = card_state;
2503     p_card_status->universal_pin_state = RIL_PINSTATE_UNKNOWN;
2504     p_card_status->gsm_umts_subscription_app_index = RIL_CARD_MAX_APPS;
2505     p_card_status->cdma_subscription_app_index = RIL_CARD_MAX_APPS;
2506     p_card_status->ims_subscription_app_index = RIL_CARD_MAX_APPS;
2507     p_card_status->num_applications = num_apps;
2508
2509     // Initialize application status
2510     int i;
2511     for (i = 0; i < RIL_CARD_MAX_APPS; i++) {
2512         p_card_status->applications[i] = app_status_array[SIM_ABSENT];
2513     }
2514
2515     // Pickup the appropriate application status
2516     // that reflects sim_status for gsm.
2517     if (num_apps != 0) {
2518         // Only support one app, gsm
2519         p_card_status->num_applications = 2;
2520         p_card_status->gsm_umts_subscription_app_index = 0;
2521         p_card_status->cdma_subscription_app_index = 1;
2522
2523         // Get the correct app status
2524         p_card_status->applications[0] = app_status_array[sim_status];
2525         p_card_status->applications[1] = app_status_array[sim_status + RUIM_ABSENT];
2526     }
2527
2528     *pp_card_status = p_card_status;
2529     return RIL_E_SUCCESS;
2530 }
2531
2532 /**
2533  * Free the card status returned by getCardStatus
2534  */
2535 static void freeCardStatus(RIL_CardStatus_v6 *p_card_status) {
2536     free(p_card_status);
2537 }
2538
2539 /**
2540  * SIM ready means any commands that access the SIM will work, including:
2541  *  AT+CPIN, AT+CSMS, AT+CNMI, AT+CRSM
2542  *  (all SMS-related commands)
2543  */
2544
2545 static void pollSIMState (void *param)
2546 {
2547     ATResponse *p_response;
2548     int ret;
2549
2550     if (sState != RADIO_STATE_SIM_NOT_READY) {
2551         // no longer valid to poll
2552         return;
2553     }
2554
2555     switch(getSIMStatus()) {
2556         case SIM_ABSENT:
2557         case SIM_PIN:
2558         case SIM_PUK:
2559         case SIM_NETWORK_PERSONALIZATION:
2560         default:
2561             RLOGI("SIM ABSENT or LOCKED");
2562             RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0);
2563         return;
2564
2565         case SIM_NOT_READY:
2566             RIL_requestTimedCallback (pollSIMState, NULL, &TIMEVAL_SIMPOLL);
2567         return;
2568
2569         case SIM_READY:
2570             RLOGI("SIM_READY");
2571             onSIMReady();
2572             RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0);
2573         return;
2574     }
2575 }
2576
2577 /** returns 1 if on, 0 if off, and -1 on error */
2578 static int isRadioOn()
2579 {
2580     ATResponse *p_response = NULL;
2581     int err;
2582     char *line;
2583     char ret;
2584
2585     err = at_send_command_singleline("AT+CFUN?", "+CFUN:", &p_response);
2586
2587     if (err < 0 || p_response->success == 0) {
2588         // assume radio is off
2589         goto error;
2590     }
2591
2592     line = p_response->p_intermediates->line;
2593
2594     err = at_tok_start(&line);
2595     if (err < 0) goto error;
2596
2597     err = at_tok_nextbool(&line, &ret);
2598     if (err < 0) goto error;
2599
2600     at_response_free(p_response);
2601
2602     return (int)ret;
2603
2604 error:
2605
2606     at_response_free(p_response);
2607     return -1;
2608 }
2609
2610 /**
2611  * Parse the response generated by a +CTEC AT command
2612  * The values read from the response are stored in current and preferred.
2613  * Both current and preferred may be null. The corresponding value is ignored in that case.
2614  *
2615  * @return: -1 if some error occurs (or if the modem doesn't understand the +CTEC command)
2616  *          1 if the response includes the current technology only
2617  *          0 if the response includes both current technology and preferred mode
2618  */
2619 int parse_technology_response( const char *response, int *current, int32_t *preferred )
2620 {
2621     int err;
2622     char *line, *p;
2623     int ct;
2624     int32_t pt = 0;
2625     char *str_pt;
2626
2627     line = p = strdup(response);
2628     RLOGD("Response: %s", line);
2629     err = at_tok_start(&p);
2630     if (err || !at_tok_hasmore(&p)) {
2631         RLOGD("err: %d. p: %s", err, p);
2632         free(line);
2633         return -1;
2634     }
2635
2636     err = at_tok_nextint(&p, &ct);
2637     if (err) {
2638         free(line);
2639         return -1;
2640     }
2641     if (current) *current = ct;
2642
2643     RLOGD("line remaining after int: %s", p);
2644
2645     err = at_tok_nexthexint(&p, &pt);
2646     if (err) {
2647         free(line);
2648         return 1;
2649     }
2650     if (preferred) {
2651         *preferred = pt;
2652     }
2653     free(line);
2654
2655     return 0;
2656 }
2657
2658 int query_supported_techs( ModemInfo *mdm, int *supported )
2659 {
2660     ATResponse *p_response;
2661     int err, val, techs = 0;
2662     char *tok;
2663     char *line;
2664
2665     RLOGD("query_supported_techs");
2666     err = at_send_command_singleline("AT+CTEC=?", "+CTEC:", &p_response);
2667     if (err || !p_response->success)
2668         goto error;
2669     line = p_response->p_intermediates->line;
2670     err = at_tok_start(&line);
2671     if (err || !at_tok_hasmore(&line))
2672         goto error;
2673     while (!at_tok_nextint(&line, &val)) {
2674         techs |= ( 1 << val );
2675     }
2676     if (supported) *supported = techs;
2677     return 0;
2678 error:
2679     at_response_free(p_response);
2680     return -1;
2681 }
2682
2683 /**
2684  * query_ctec. Send the +CTEC AT command to the modem to query the current
2685  * and preferred modes. It leaves values in the addresses pointed to by
2686  * current and preferred. If any of those pointers are NULL, the corresponding value
2687  * is ignored, but the return value will still reflect if retreiving and parsing of the
2688  * values suceeded.
2689  *
2690  * @mdm Currently unused
2691  * @current A pointer to store the current mode returned by the modem. May be null.
2692  * @preferred A pointer to store the preferred mode returned by the modem. May be null.
2693  * @return -1 on error (or failure to parse)
2694  *         1 if only the current mode was returned by modem (or failed to parse preferred)
2695  *         0 if both current and preferred were returned correctly
2696  */
2697 int query_ctec(ModemInfo *mdm, int *current, int32_t *preferred)
2698 {
2699     ATResponse *response = NULL;
2700     int err;
2701     int res;
2702
2703     RLOGD("query_ctec. current: %d, preferred: %d", (int)current, (int) preferred);
2704     err = at_send_command_singleline("AT+CTEC?", "+CTEC:", &response);
2705     if (!err && response->success) {
2706         res = parse_technology_response(response->p_intermediates->line, current, preferred);
2707         at_response_free(response);
2708         return res;
2709     }
2710     RLOGE("Error executing command: %d. response: %x. status: %d", err, (int)response, response? response->success : -1);
2711     at_response_free(response);
2712     return -1;
2713 }
2714
2715 int is_multimode_modem(ModemInfo *mdm)
2716 {
2717     ATResponse *response;
2718     int err;
2719     char *line;
2720     int tech;
2721     int32_t preferred;
2722
2723     if (query_ctec(mdm, &tech, &preferred) == 0) {
2724         mdm->currentTech = tech;
2725         mdm->preferredNetworkMode = preferred;
2726         if (query_supported_techs(mdm, &mdm->supportedTechs)) {
2727             return 0;
2728         }
2729         return 1;
2730     }
2731     return 0;
2732 }
2733
2734 /**
2735  * Find out if our modem is GSM, CDMA or both (Multimode)
2736  */
2737 static void probeForModemMode(ModemInfo *info)
2738 {
2739     ATResponse *response;
2740     int err;
2741     assert (info);
2742     // Currently, our only known multimode modem is qemu's android modem,
2743     // which implements the AT+CTEC command to query and set mode.
2744     // Try that first
2745
2746     if (is_multimode_modem(info)) {
2747         RLOGI("Found Multimode Modem. Supported techs mask: %8.8x. Current tech: %d",
2748             info->supportedTechs, info->currentTech);
2749         return;
2750     }
2751
2752     /* Being here means that our modem is not multimode */
2753     info->isMultimode = 0;
2754
2755     /* CDMA Modems implement the AT+WNAM command */
2756     err = at_send_command_singleline("AT+WNAM","+WNAM:", &response);
2757     if (!err && response->success) {
2758         at_response_free(response);
2759         // TODO: find out if we really support EvDo
2760         info->supportedTechs = MDM_CDMA | MDM_EVDO;
2761         info->currentTech = MDM_CDMA;
2762         RLOGI("Found CDMA Modem");
2763         return;
2764     }
2765     if (!err) at_response_free(response);
2766     // TODO: find out if modem really supports WCDMA/LTE
2767     info->supportedTechs = MDM_GSM | MDM_WCDMA | MDM_LTE;
2768     info->currentTech = MDM_GSM;
2769     RLOGI("Found GSM Modem");
2770 }
2771
2772 /**
2773  * Initialize everything that can be configured while we're still in
2774  * AT+CFUN=0
2775  */
2776 static void initializeCallback(void *param)
2777 {
2778     ATResponse *p_response = NULL;
2779     int err;
2780
2781     setRadioState (RADIO_STATE_OFF);
2782
2783     at_handshake();
2784
2785     probeForModemMode(sMdmInfo);
2786     /* note: we don't check errors here. Everything important will
2787        be handled in onATTimeout and onATReaderClosed */
2788
2789     /*  atchannel is tolerant of echo but it must */
2790     /*  have verbose result codes */
2791     at_send_command("ATE0Q0V1", NULL);
2792
2793     /*  No auto-answer */
2794     at_send_command("ATS0=0", NULL);
2795
2796     /*  Extended errors */
2797     at_send_command("AT+CMEE=1", NULL);
2798
2799     /*  Network registration events */
2800     err = at_send_command("AT+CREG=2", &p_response);
2801
2802     /* some handsets -- in tethered mode -- don't support CREG=2 */
2803     if (err < 0 || p_response->success == 0) {
2804         at_send_command("AT+CREG=1", NULL);
2805     }
2806
2807     at_response_free(p_response);
2808
2809     /*  GPRS registration events */
2810     at_send_command("AT+CGREG=1", NULL);
2811
2812     /*  Call Waiting notifications */
2813     at_send_command("AT+CCWA=1", NULL);
2814
2815     /*  Alternating voice/data off */
2816     at_send_command("AT+CMOD=0", NULL);
2817
2818     /*  Not muted */
2819     at_send_command("AT+CMUT=0", NULL);
2820
2821     /*  +CSSU unsolicited supp service notifications */
2822     at_send_command("AT+CSSN=0,1", NULL);
2823
2824     /*  no connected line identification */
2825     at_send_command("AT+COLP=0", NULL);
2826
2827     /*  HEX character set */
2828     at_send_command("AT+CSCS=\"HEX\"", NULL);
2829
2830     /*  USSD unsolicited */
2831     at_send_command("AT+CUSD=1", NULL);
2832
2833     /*  Enable +CGEV GPRS event notifications, but don't buffer */
2834     at_send_command("AT+CGEREP=1,0", NULL);
2835
2836     /*  SMS PDU mode */
2837     at_send_command("AT+CMGF=0", NULL);
2838
2839 #ifdef USE_TI_COMMANDS
2840
2841     at_send_command("AT%CPI=3", NULL);
2842
2843     /*  TI specific -- notifications when SMS is ready (currently ignored) */
2844     at_send_command("AT%CSTAT=1", NULL);
2845
2846 #endif /* USE_TI_COMMANDS */
2847
2848
2849     /* assume radio is off on error */
2850     if (isRadioOn() > 0) {
2851         setRadioState (RADIO_STATE_ON);
2852     }
2853 }
2854
2855 static void waitForClose()
2856 {
2857     pthread_mutex_lock(&s_state_mutex);
2858
2859     while (s_closed == 0) {
2860         pthread_cond_wait(&s_state_cond, &s_state_mutex);
2861     }
2862
2863     pthread_mutex_unlock(&s_state_mutex);
2864 }
2865
2866 /**
2867  * Called by atchannel when an unsolicited line appears
2868  * This is called on atchannel's reader thread. AT commands may
2869  * not be issued here
2870  */
2871 static void onUnsolicited (const char *s, const char *sms_pdu)
2872 {
2873     char *line = NULL, *p;
2874     int err;
2875
2876     /* Ignore unsolicited responses until we're initialized.
2877      * This is OK because the RIL library will poll for initial state
2878      */
2879     if (sState == RADIO_STATE_UNAVAILABLE) {
2880         return;
2881     }
2882
2883     if (strStartsWith(s, "%CTZV:")) {
2884         /* TI specific -- NITZ time */
2885         char *response;
2886
2887         line = p = strdup(s);
2888         at_tok_start(&p);
2889
2890         err = at_tok_nextstr(&p, &response);
2891
2892         free(line);
2893         if (err != 0) {
2894             RLOGE("invalid NITZ line %s\n", s);
2895         } else {
2896             RIL_onUnsolicitedResponse (
2897                 RIL_UNSOL_NITZ_TIME_RECEIVED,
2898                 response, strlen(response));
2899         }
2900     } else if (strStartsWith(s,"+CRING:")
2901                 || strStartsWith(s,"RING")
2902                 || strStartsWith(s,"NO CARRIER")
2903                 || strStartsWith(s,"+CCWA")
2904     ) {
2905         RIL_onUnsolicitedResponse (
2906             RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED,
2907             NULL, 0);
2908 #ifdef WORKAROUND_FAKE_CGEV
2909         RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); //TODO use new function
2910 #endif /* WORKAROUND_FAKE_CGEV */
2911     } else if (strStartsWith(s,"+CREG:")
2912                 || strStartsWith(s,"+CGREG:")
2913     ) {
2914         RIL_onUnsolicitedResponse (
2915             RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED,
2916             NULL, 0);
2917 #ifdef WORKAROUND_FAKE_CGEV
2918         RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL);
2919 #endif /* WORKAROUND_FAKE_CGEV */
2920     } else if (strStartsWith(s, "+CMT:")) {
2921         RIL_onUnsolicitedResponse (
2922             RIL_UNSOL_RESPONSE_NEW_SMS,
2923             sms_pdu, strlen(sms_pdu));
2924     } else if (strStartsWith(s, "+CDS:")) {
2925         RIL_onUnsolicitedResponse (
2926             RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT,
2927             sms_pdu, strlen(sms_pdu));
2928     } else if (strStartsWith(s, "+CGEV:")) {
2929         /* Really, we can ignore NW CLASS and ME CLASS events here,
2930          * but right now we don't since extranous
2931          * RIL_UNSOL_DATA_CALL_LIST_CHANGED calls are tolerated
2932          */
2933         /* can't issue AT commands here -- call on main thread */
2934         RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL);
2935 #ifdef WORKAROUND_FAKE_CGEV
2936     } else if (strStartsWith(s, "+CME ERROR: 150")) {
2937         RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL);
2938 #endif /* WORKAROUND_FAKE_CGEV */
2939     } else if (strStartsWith(s, "+CTEC: ")) {
2940         int tech, mask;
2941         switch (parse_technology_response(s, &tech, NULL))
2942         {
2943             case -1: // no argument could be parsed.
2944                 RLOGE("invalid CTEC line %s\n", s);
2945                 break;
2946             case 1: // current mode correctly parsed
2947             case 0: // preferred mode correctly parsed
2948                 mask = 1 << tech;
2949                 if (mask != MDM_GSM && mask != MDM_CDMA &&
2950                      mask != MDM_WCDMA && mask != MDM_LTE) {
2951                     RLOGE("Unknown technology %d\n", tech);
2952                 } else {
2953                     setRadioTechnology(sMdmInfo, tech);
2954                 }
2955                 break;
2956         }
2957     } else if (strStartsWith(s, "+CCSS: ")) {
2958         int source = 0;
2959         line = p = strdup(s);
2960         if (!line) {
2961             RLOGE("+CCSS: Unable to allocate memory");
2962             return;
2963         }
2964         if (at_tok_start(&p) < 0) {
2965             free(line);
2966             return;
2967         }
2968         if (at_tok_nextint(&p, &source) < 0) {
2969             RLOGE("invalid +CCSS response: %s", line);
2970             free(line);
2971             return;
2972         }
2973         SSOURCE(sMdmInfo) = source;
2974         RIL_onUnsolicitedResponse(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED,
2975                                   &source, sizeof(source));
2976     } else if (strStartsWith(s, "+WSOS: ")) {
2977         char state = 0;
2978         int unsol;
2979         line = p = strdup(s);
2980         if (!line) {
2981             RLOGE("+WSOS: Unable to allocate memory");
2982             return;
2983         }
2984         if (at_tok_start(&p) < 0) {
2985             free(line);
2986             return;
2987         }
2988         if (at_tok_nextbool(&p, &state) < 0) {
2989             RLOGE("invalid +WSOS response: %s", line);
2990             free(line);
2991             return;
2992         }
2993         free(line);
2994
2995         unsol = state ?
2996                 RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE : RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE;
2997
2998         RIL_onUnsolicitedResponse(unsol, NULL, 0);
2999
3000     } else if (strStartsWith(s, "+WPRL: ")) {
3001         int version = -1;
3002         line = p = strdup(s);
3003         if (!line) {
3004             RLOGE("+WPRL: Unable to allocate memory");
3005             return;
3006         }
3007         if (at_tok_start(&p) < 0) {
3008             RLOGE("invalid +WPRL response: %s", s);
3009             free(line);
3010             return;
3011         }
3012         if (at_tok_nextint(&p, &version) < 0) {
3013             RLOGE("invalid +WPRL response: %s", s);
3014             free(line);
3015             return;
3016         }
3017         free(line);
3018         RIL_onUnsolicitedResponse(RIL_UNSOL_CDMA_PRL_CHANGED, &version, sizeof(version));
3019     } else if (strStartsWith(s, "+CFUN: 0")) {
3020         setRadioState(RADIO_STATE_OFF);
3021     }
3022 }
3023
3024 /* Called on command or reader thread */
3025 static void onATReaderClosed()
3026 {
3027     RLOGI("AT channel closed\n");
3028     at_close();
3029     s_closed = 1;
3030
3031     setRadioState (RADIO_STATE_UNAVAILABLE);
3032 }
3033
3034 /* Called on command thread */
3035 static void onATTimeout()
3036 {
3037     RLOGI("AT channel timeout; closing\n");
3038     at_close();
3039
3040     s_closed = 1;
3041
3042     /* FIXME cause a radio reset here */
3043
3044     setRadioState (RADIO_STATE_UNAVAILABLE);
3045 }
3046
3047 static void usage(char *s)
3048 {
3049 #ifdef RIL_SHLIB
3050     fprintf(stderr, "reference-ril requires: -p <tcp port> or -d /dev/tty_device\n");
3051 #else
3052     fprintf(stderr, "usage: %s [-p <tcp port>] [-d /dev/tty_device]\n", s);
3053     exit(-1);
3054 #endif
3055 }
3056
3057 static void *
3058 mainLoop(void *param)
3059 {
3060     int fd;
3061     int ret;
3062
3063     AT_DUMP("== ", "entering mainLoop()", -1 );
3064     at_set_on_reader_closed(onATReaderClosed);
3065     at_set_on_timeout(onATTimeout);
3066
3067     for (;;) {
3068         fd = -1;
3069         while  (fd < 0) {
3070             if (s_port > 0) {
3071                 fd = socket_loopback_client(s_port, SOCK_STREAM);
3072             } else if (s_device_socket) {
3073                 if (!strcmp(s_device_path, "/dev/socket/qemud")) {
3074                     /* Before trying to connect to /dev/socket/qemud (which is
3075                      * now another "legacy" way of communicating with the
3076                      * emulator), we will try to connecto to gsm service via
3077                      * qemu pipe. */
3078                     fd = qemu_pipe_open("qemud:gsm");
3079                     if (fd < 0) {
3080                         /* Qemu-specific control socket */
3081                         fd = socket_local_client( "qemud",
3082                                                   ANDROID_SOCKET_NAMESPACE_RESERVED,
3083                                                   SOCK_STREAM );
3084                         if (fd >= 0 ) {
3085                             char  answer[2];
3086
3087                             if ( write(fd, "gsm", 3) != 3 ||
3088                                  read(fd, answer, 2) != 2 ||
3089                                  memcmp(answer, "OK", 2) != 0)
3090                             {
3091                                 close(fd);
3092                                 fd = -1;
3093                             }
3094                        }
3095                     }
3096                 }
3097                 else
3098                     fd = socket_local_client( s_device_path,
3099                                             ANDROID_SOCKET_NAMESPACE_FILESYSTEM,
3100                                             SOCK_STREAM );
3101             } else if (s_device_path != NULL) {
3102                 fd = open (s_device_path, O_RDWR);
3103                 if ( fd >= 0 && !memcmp( s_device_path, "/dev/ttyS", 9 ) ) {
3104                     /* disable echo on serial ports */
3105                     struct termios  ios;
3106                     tcgetattr( fd, &ios );
3107                     ios.c_lflag = 0;  /* disable ECHO, ICANON, etc... */
3108                     tcsetattr( fd, TCSANOW, &ios );
3109                 }
3110             }
3111
3112             if (fd < 0) {
3113                 perror ("opening AT interface. retrying...");
3114                 sleep(10);
3115                 /* never returns */
3116             }
3117         }
3118
3119         s_closed = 0;
3120         ret = at_open(fd, onUnsolicited);
3121
3122         if (ret < 0) {
3123             RLOGE ("AT error %d on at_open\n", ret);
3124             return 0;
3125         }
3126
3127         RIL_requestTimedCallback(initializeCallback, NULL, &TIMEVAL_0);
3128
3129         // Give initializeCallback a chance to dispatched, since
3130         // we don't presently have a cancellation mechanism
3131         sleep(1);
3132
3133         waitForClose();
3134         RLOGI("Re-opening after close");
3135     }
3136 }
3137
3138 #ifdef RIL_SHLIB
3139
3140 pthread_t s_tid_mainloop;
3141
3142 const RIL_RadioFunctions *RIL_Init(const struct RIL_Env *env, int argc, char **argv)
3143 {
3144     int ret;
3145     int fd = -1;
3146     int opt;
3147     pthread_attr_t attr;
3148
3149     s_rilenv = env;
3150
3151     while ( -1 != (opt = getopt(argc, argv, "p:d:s:"))) {
3152         switch (opt) {
3153             case 'p':
3154                 s_port = atoi(optarg);
3155                 if (s_port == 0) {
3156                     usage(argv[0]);
3157                     return NULL;
3158                 }
3159                 RLOGI("Opening loopback port %d\n", s_port);
3160             break;
3161
3162             case 'd':
3163                 s_device_path = optarg;
3164                 RLOGI("Opening tty device %s\n", s_device_path);
3165             break;
3166
3167             case 's':
3168                 s_device_path   = optarg;
3169                 s_device_socket = 1;
3170                 RLOGI("Opening socket %s\n", s_device_path);
3171             break;
3172
3173             default:
3174                 usage(argv[0]);
3175                 return NULL;
3176         }
3177     }
3178
3179     if (s_port < 0 && s_device_path == NULL) {
3180         usage(argv[0]);
3181         return NULL;
3182     }
3183
3184     sMdmInfo = calloc(1, sizeof(ModemInfo));
3185     if (!sMdmInfo) {
3186         RLOGE("Unable to alloc memory for ModemInfo");
3187         return NULL;
3188     }
3189     pthread_attr_init (&attr);
3190     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
3191     ret = pthread_create(&s_tid_mainloop, &attr, mainLoop, NULL);
3192
3193     return &s_callbacks;
3194 }
3195 #else /* RIL_SHLIB */
3196 int main (int argc, char **argv)
3197 {
3198     int ret;
3199     int fd = -1;
3200     int opt;
3201
3202     while ( -1 != (opt = getopt(argc, argv, "p:d:"))) {
3203         switch (opt) {
3204             case 'p':
3205                 s_port = atoi(optarg);
3206                 if (s_port == 0) {
3207                     usage(argv[0]);
3208                 }
3209                 RLOGI("Opening loopback port %d\n", s_port);
3210             break;
3211
3212             case 'd':
3213                 s_device_path = optarg;
3214                 RLOGI("Opening tty device %s\n", s_device_path);
3215             break;
3216
3217             case 's':
3218                 s_device_path   = optarg;
3219                 s_device_socket = 1;
3220                 RLOGI("Opening socket %s\n", s_device_path);
3221             break;
3222
3223             default:
3224                 usage(argv[0]);
3225         }
3226     }
3227
3228     if (s_port < 0 && s_device_path == NULL) {
3229         usage(argv[0]);
3230     }
3231
3232     RIL_register(&s_callbacks);
3233
3234     mainLoop(NULL);
3235
3236     return 0;
3237 }
3238
3239 #endif /* RIL_SHLIB */