1 /* //device/libs/telephony/ril.cpp 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 #define LOG_TAG "RILC" 19 20 #include <hardware_legacy/power.h> 21 #include <telephony/ril.h> 22 #include <telephony/ril_cdma_sms.h> 23 #include <cutils/sockets.h> 24 #include <cutils/jstring.h> 25 #include <telephony/record_stream.h> 26 #include <utils/Log.h> 27 #include <utils/SystemClock.h> 28 #include <pthread.h> 29 #include <binder/Parcel.h> 30 #include <cutils/jstring.h> 31 #include <sys/types.h> 32 #include <sys/limits.h> 33 #include <pwd.h> 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <stdarg.h> 37 #include <string.h> 38 #include <unistd.h> 39 #include <fcntl.h> 40 #include <time.h> 41 #include <errno.h> 42 #include <assert.h> 43 #include <ctype.h> 44 #include <alloca.h> 45 #include <sys/un.h> 46 #include <assert.h> 47 #include <netinet/in.h> 48 #include <cutils/properties.h> 49 #include <RilSapSocket.h> 50 51 extern "C" void 52 RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen); 53 namespace android { 54 55 #define PHONE_PROCESS "radio" 56 #define BLUETOOTH_PROCESS "bluetooth" 57 58 #define SOCKET_NAME_RIL "rild" 59 #define SOCKET2_NAME_RIL "rild2" 60 #define SOCKET3_NAME_RIL "rild3" 61 #define SOCKET4_NAME_RIL "rild4" 62 63 #define SOCKET_NAME_RIL_DEBUG "rild-debug" 64 65 #define ANDROID_WAKE_LOCK_NAME "radio-interface" 66 67 #define ANDROID_WAKE_LOCK_SECS 0 68 #define ANDROID_WAKE_LOCK_USECS 200000 69 70 #define PROPERTY_RIL_IMPL "gsm.version.ril-impl" 71 72 // match with constant in RIL.java 73 #define MAX_COMMAND_BYTES (8 * 1024) 74 75 // Basically: memset buffers that the client library 76 // shouldn't be using anymore in an attempt to find 77 // memory usage issues sooner. 78 #define MEMSET_FREED 1 79 80 #define NUM_ELEMS(a) (sizeof (a) / sizeof (a)[0]) 81 82 #define MIN(a,b) ((a)<(b) ? (a) : (b)) 83 84 /* Constants for response types */ 85 #define RESPONSE_SOLICITED 0 86 #define RESPONSE_UNSOLICITED 1 87 88 /* Negative values for private RIL errno's */ 89 #define RIL_ERRNO_INVALID_RESPONSE -1 90 91 // request, response, and unsolicited msg print macro 92 #define PRINTBUF_SIZE 8096 93 94 // Enable verbose logging 95 #define VDBG 0 96 97 // Enable RILC log 98 #define RILC_LOG 0 99 100 #if RILC_LOG 101 #define startRequest sprintf(printBuf, "(") 102 #define closeRequest sprintf(printBuf, "%s)", printBuf) 103 #define printRequest(token, req) \ 104 RLOGD("[%04d]> %s %s", token, requestToString(req), printBuf) 105 106 #define startResponse sprintf(printBuf, "%s {", printBuf) 107 #define closeResponse sprintf(printBuf, "%s}", printBuf) 108 #define printResponse RLOGD("%s", printBuf) 109 110 #define clearPrintBuf printBuf[0] = 0 111 #define removeLastChar printBuf[strlen(printBuf)-1] = 0 112 #define appendPrintBuf(x...) sprintf(printBuf, x) 113 #else 114 #define startRequest 115 #define closeRequest 116 #define printRequest(token, req) 117 #define startResponse 118 #define closeResponse 119 #define printResponse 120 #define clearPrintBuf 121 #define removeLastChar 122 #define appendPrintBuf(x...) 123 #endif 124 125 enum WakeType {DONT_WAKE, WAKE_PARTIAL}; 126 127 typedef struct { 128 int requestNumber; 129 void (*dispatchFunction) (Parcel &p, struct RequestInfo *pRI); 130 int(*responseFunction) (Parcel &p, void *response, size_t responselen); 131 } CommandInfo; 132 133 typedef struct { 134 int requestNumber; 135 int (*responseFunction) (Parcel &p, void *response, size_t responselen); 136 WakeType wakeType; 137 } UnsolResponseInfo; 138 139 typedef struct RequestInfo { 140 int32_t token; //this is not RIL_Token 141 CommandInfo *pCI; 142 struct RequestInfo *p_next; 143 char cancelled; 144 char local; // responses to local commands do not go back to command process 145 RIL_SOCKET_ID socket_id; 146 } RequestInfo; 147 148 typedef struct UserCallbackInfo { 149 RIL_TimedCallback p_callback; 150 void *userParam; 151 struct ril_event event; 152 struct UserCallbackInfo *p_next; 153 } UserCallbackInfo; 154 155 extern "C" const char * requestToString(int request); 156 extern "C" const char * failCauseToString(RIL_Errno); 157 extern "C" const char * callStateToString(RIL_CallState); 158 extern "C" const char * radioStateToString(RIL_RadioState); 159 extern "C" const char * rilSocketIdToString(RIL_SOCKET_ID socket_id); 160 161 extern "C" 162 char rild[MAX_SOCKET_NAME_LENGTH] = SOCKET_NAME_RIL; 163 /*******************************************************************/ 164 165 RIL_RadioFunctions s_callbacks = {0, NULL, NULL, NULL, NULL, NULL}; 166 static int s_registerCalled = 0; 167 168 static pthread_t s_tid_dispatch; 169 static pthread_t s_tid_reader; 170 static int s_started = 0; 171 172 static int s_fdDebug = -1; 173 static int s_fdDebug_socket2 = -1; 174 175 static int s_fdWakeupRead; 176 static int s_fdWakeupWrite; 177 178 static struct ril_event s_commands_event; 179 static struct ril_event s_wakeupfd_event; 180 static struct ril_event s_listen_event; 181 static SocketListenParam s_ril_param_socket; 182 183 static pthread_mutex_t s_pendingRequestsMutex = PTHREAD_MUTEX_INITIALIZER; 184 static pthread_mutex_t s_writeMutex = PTHREAD_MUTEX_INITIALIZER; 185 static RequestInfo *s_pendingRequests = NULL; 186 187 #if (SIM_COUNT >= 2) 188 static struct ril_event s_commands_event_socket2; 189 static struct ril_event s_listen_event_socket2; 190 static SocketListenParam s_ril_param_socket2; 191 192 static pthread_mutex_t s_pendingRequestsMutex_socket2 = PTHREAD_MUTEX_INITIALIZER; 193 static pthread_mutex_t s_writeMutex_socket2 = PTHREAD_MUTEX_INITIALIZER; 194 static RequestInfo *s_pendingRequests_socket2 = NULL; 195 #endif 196 197 #if (SIM_COUNT >= 3) 198 static struct ril_event s_commands_event_socket3; 199 static struct ril_event s_listen_event_socket3; 200 static SocketListenParam s_ril_param_socket3; 201 202 static pthread_mutex_t s_pendingRequestsMutex_socket3 = PTHREAD_MUTEX_INITIALIZER; 203 static pthread_mutex_t s_writeMutex_socket3 = PTHREAD_MUTEX_INITIALIZER; 204 static RequestInfo *s_pendingRequests_socket3 = NULL; 205 #endif 206 207 #if (SIM_COUNT >= 4) 208 static struct ril_event s_commands_event_socket4; 209 static struct ril_event s_listen_event_socket4; 210 static SocketListenParam s_ril_param_socket4; 211 212 static pthread_mutex_t s_pendingRequestsMutex_socket4 = PTHREAD_MUTEX_INITIALIZER; 213 static pthread_mutex_t s_writeMutex_socket4 = PTHREAD_MUTEX_INITIALIZER; 214 static RequestInfo *s_pendingRequests_socket4 = NULL; 215 #endif 216 217 static struct ril_event s_wake_timeout_event; 218 static struct ril_event s_debug_event; 219 220 221 static const struct timeval TIMEVAL_WAKE_TIMEOUT = {ANDROID_WAKE_LOCK_SECS,ANDROID_WAKE_LOCK_USECS}; 222 223 224 static pthread_mutex_t s_startupMutex = PTHREAD_MUTEX_INITIALIZER; 225 static pthread_cond_t s_startupCond = PTHREAD_COND_INITIALIZER; 226 227 static pthread_mutex_t s_dispatchMutex = PTHREAD_MUTEX_INITIALIZER; 228 static pthread_cond_t s_dispatchCond = PTHREAD_COND_INITIALIZER; 229 230 static RequestInfo *s_toDispatchHead = NULL; 231 static RequestInfo *s_toDispatchTail = NULL; 232 233 static UserCallbackInfo *s_last_wake_timeout_info = NULL; 234 235 static void *s_lastNITZTimeData = NULL; 236 static size_t s_lastNITZTimeDataSize; 237 238 #if RILC_LOG 239 static char printBuf[PRINTBUF_SIZE]; 240 #endif 241 242 /*******************************************************************/ 243 static int sendResponse (Parcel &p, RIL_SOCKET_ID socket_id); 244 245 static void dispatchVoid (Parcel& p, RequestInfo *pRI); 246 static void dispatchString (Parcel& p, RequestInfo *pRI); 247 static void dispatchStrings (Parcel& p, RequestInfo *pRI); 248 static void dispatchInts (Parcel& p, RequestInfo *pRI); 249 static void dispatchDial (Parcel& p, RequestInfo *pRI); 250 static void dispatchSIM_IO (Parcel& p, RequestInfo *pRI); 251 static void dispatchSIM_APDU (Parcel& p, RequestInfo *pRI); 252 static void dispatchCallForward(Parcel& p, RequestInfo *pRI); 253 static void dispatchRaw(Parcel& p, RequestInfo *pRI); 254 static void dispatchSmsWrite (Parcel &p, RequestInfo *pRI); 255 static void dispatchDataCall (Parcel& p, RequestInfo *pRI); 256 static void dispatchVoiceRadioTech (Parcel& p, RequestInfo *pRI); 257 static void dispatchSetInitialAttachApn (Parcel& p, RequestInfo *pRI); 258 static void dispatchCdmaSubscriptionSource (Parcel& p, RequestInfo *pRI); 259 260 static void dispatchCdmaSms(Parcel &p, RequestInfo *pRI); 261 static void dispatchImsSms(Parcel &p, RequestInfo *pRI); 262 static void dispatchImsCdmaSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef); 263 static void dispatchImsGsmSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef); 264 static void dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI); 265 static void dispatchGsmBrSmsCnf(Parcel &p, RequestInfo *pRI); 266 static void dispatchCdmaBrSmsCnf(Parcel &p, RequestInfo *pRI); 267 static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI); 268 static void dispatchNVReadItem(Parcel &p, RequestInfo *pRI); 269 static void dispatchNVWriteItem(Parcel &p, RequestInfo *pRI); 270 static void dispatchUiccSubscripton(Parcel &p, RequestInfo *pRI); 271 static void dispatchSimAuthentication(Parcel &p, RequestInfo *pRI); 272 static void dispatchDataProfile(Parcel &p, RequestInfo *pRI); 273 static void dispatchRadioCapability(Parcel &p, RequestInfo *pRI); 274 static int responseInts(Parcel &p, void *response, size_t responselen); 275 static int responseFailCause(Parcel &p, void *response, size_t responselen); 276 static int responseStrings(Parcel &p, void *response, size_t responselen); 277 static int responseString(Parcel &p, void *response, size_t responselen); 278 static int responseVoid(Parcel &p, void *response, size_t responselen); 279 static int responseCallList(Parcel &p, void *response, size_t responselen); 280 static int responseSMS(Parcel &p, void *response, size_t responselen); 281 static int responseSIM_IO(Parcel &p, void *response, size_t responselen); 282 static int responseCallForwards(Parcel &p, void *response, size_t responselen); 283 static int responseDataCallList(Parcel &p, void *response, size_t responselen); 284 static int responseSetupDataCall(Parcel &p, void *response, size_t responselen); 285 static int responseRaw(Parcel &p, void *response, size_t responselen); 286 static int responseSsn(Parcel &p, void *response, size_t responselen); 287 static int responseSimStatus(Parcel &p, void *response, size_t responselen); 288 static int responseGsmBrSmsCnf(Parcel &p, void *response, size_t responselen); 289 static int responseCdmaBrSmsCnf(Parcel &p, void *response, size_t responselen); 290 static int responseCdmaSms(Parcel &p, void *response, size_t responselen); 291 static int responseCellList(Parcel &p, void *response, size_t responselen); 292 static int responseCdmaInformationRecords(Parcel &p,void *response, size_t responselen); 293 static int responseRilSignalStrength(Parcel &p,void *response, size_t responselen); 294 static int responseCallRing(Parcel &p, void *response, size_t responselen); 295 static int responseCdmaSignalInfoRecord(Parcel &p,void *response, size_t responselen); 296 static int responseCdmaCallWaiting(Parcel &p,void *response, size_t responselen); 297 static int responseSimRefresh(Parcel &p, void *response, size_t responselen); 298 static int responseCellInfoList(Parcel &p, void *response, size_t responselen); 299 static int responseHardwareConfig(Parcel &p, void *response, size_t responselen); 300 static int responseDcRtInfo(Parcel &p, void *response, size_t responselen); 301 static int responseRadioCapability(Parcel &p, void *response, size_t responselen); 302 static int responseSSData(Parcel &p, void *response, size_t responselen); 303 static int responseLceStatus(Parcel &p, void *response, size_t responselen); 304 static int responseLceData(Parcel &p, void *response, size_t responselen); 305 static int responseActivityData(Parcel &p, void *response, size_t responselen); 306 307 static int decodeVoiceRadioTechnology (RIL_RadioState radioState); 308 static int decodeCdmaSubscriptionSource (RIL_RadioState radioState); 309 static RIL_RadioState processRadioState(RIL_RadioState newRadioState); 310 311 static bool isServiceTypeCfQuery(RIL_SsServiceType serType, RIL_SsRequestType reqType); 312 313 #ifdef RIL_SHLIB 314 #if defined(ANDROID_MULTI_SIM) 315 extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, const void *data, 316 size_t datalen, RIL_SOCKET_ID socket_id); 317 #else 318 extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, const void *data, 319 size_t datalen); 320 #endif 321 #endif 322 323 #if defined(ANDROID_MULTI_SIM) 324 #define RIL_UNSOL_RESPONSE(a, b, c, d) RIL_onUnsolicitedResponse((a), (b), (c), (d)) 325 #define CALL_ONREQUEST(a, b, c, d, e) s_callbacks.onRequest((a), (b), (c), (d), (e)) 326 #define CALL_ONSTATEREQUEST(a) s_callbacks.onStateRequest(a) 327 #else 328 #define RIL_UNSOL_RESPONSE(a, b, c, d) RIL_onUnsolicitedResponse((a), (b), (c)) 329 #define CALL_ONREQUEST(a, b, c, d, e) s_callbacks.onRequest((a), (b), (c), (d)) 330 #define CALL_ONSTATEREQUEST(a) s_callbacks.onStateRequest() 331 #endif 332 333 static UserCallbackInfo * internalRequestTimedCallback 334 (RIL_TimedCallback callback, void *param, 335 const struct timeval *relativeTime); 336 337 /** Index == requestNumber */ 338 static CommandInfo s_commands[] = { 339 #include "ril_commands.h" 340 }; 341 342 static UnsolResponseInfo s_unsolResponses[] = { 343 #include "ril_unsol_commands.h" 344 }; 345 346 /* For older RILs that do not support new commands RIL_REQUEST_VOICE_RADIO_TECH and 347 RIL_UNSOL_VOICE_RADIO_TECH_CHANGED messages, decode the voice radio tech from 348 radio state message and store it. Every time there is a change in Radio State 349 check to see if voice radio tech changes and notify telephony 350 */ 351 int voiceRadioTech = -1; 352 353 /* For older RILs that do not support new commands RIL_REQUEST_GET_CDMA_SUBSCRIPTION_SOURCE 354 and RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED messages, decode the subscription 355 source from radio state and store it. Every time there is a change in Radio State 356 check to see if subscription source changed and notify telephony 357 */ 358 int cdmaSubscriptionSource = -1; 359 360 /* For older RILs that do not send RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, decode the 361 SIM/RUIM state from radio state and store it. Every time there is a change in Radio State, 362 check to see if SIM/RUIM status changed and notify telephony 363 */ 364 int simRuimStatus = -1; 365 366 static char * RIL_getRilSocketName() { 367 return rild; 368 } 369 370 extern "C" 371 void RIL_setRilSocketName(const char * s) { 372 strncpy(rild, s, MAX_SOCKET_NAME_LENGTH); 373 } 374 375 static char * 376 strdupReadString(Parcel &p) { 377 size_t stringlen; 378 const char16_t *s16; 379 380 s16 = p.readString16Inplace(&stringlen); 381 382 return strndup16to8(s16, stringlen); 383 } 384 385 static status_t 386 readStringFromParcelInplace(Parcel &p, char *str, size_t maxLen) { 387 size_t s16Len; 388 const char16_t *s16; 389 390 s16 = p.readString16Inplace(&s16Len); 391 if (s16 == NULL) { 392 return NO_MEMORY; 393 } 394 size_t strLen = strnlen16to8(s16, s16Len); 395 if ((strLen + 1) > maxLen) { 396 return NO_MEMORY; 397 } 398 if (strncpy16to8(str, s16, strLen) == NULL) { 399 return NO_MEMORY; 400 } else { 401 return NO_ERROR; 402 } 403 } 404 405 static void writeStringToParcel(Parcel &p, const char *s) { 406 char16_t *s16; 407 size_t s16_len; 408 s16 = strdup8to16(s, &s16_len); 409 p.writeString16(s16, s16_len); 410 free(s16); 411 } 412 413 414 static void 415 memsetString (char *s) { 416 if (s != NULL) { 417 memset (s, 0, strlen(s)); 418 } 419 } 420 421 void nullParcelReleaseFunction (const uint8_t* data, size_t dataSize, 422 const size_t* objects, size_t objectsSize, 423 void* cookie) { 424 // do nothing -- the data reference lives longer than the Parcel object 425 } 426 427 /** 428 * To be called from dispatch thread 429 * Issue a single local request, ensuring that the response 430 * is not sent back up to the command process 431 */ 432 static void 433 issueLocalRequest(int request, void *data, int len, RIL_SOCKET_ID socket_id) { 434 RequestInfo *pRI; 435 int ret; 436 /* Hook for current context */ 437 /* pendingRequestsMutextHook refer to &s_pendingRequestsMutex */ 438 pthread_mutex_t* pendingRequestsMutexHook = &s_pendingRequestsMutex; 439 /* pendingRequestsHook refer to &s_pendingRequests */ 440 RequestInfo** pendingRequestsHook = &s_pendingRequests; 441 442 #if (SIM_COUNT == 2) 443 if (socket_id == RIL_SOCKET_2) { 444 pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2; 445 pendingRequestsHook = &s_pendingRequests_socket2; 446 } 447 #endif 448 449 pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo)); 450 451 pRI->local = 1; 452 pRI->token = 0xffffffff; // token is not used in this context 453 pRI->pCI = &(s_commands[request]); 454 pRI->socket_id = socket_id; 455 456 ret = pthread_mutex_lock(pendingRequestsMutexHook); 457 assert (ret == 0); 458 459 pRI->p_next = *pendingRequestsHook; 460 *pendingRequestsHook = pRI; 461 462 ret = pthread_mutex_unlock(pendingRequestsMutexHook); 463 assert (ret == 0); 464 465 RLOGD("C[locl]> %s", requestToString(request)); 466 467 CALL_ONREQUEST(request, data, len, pRI, pRI->socket_id); 468 } 469 470 471 472 static int 473 processCommandBuffer(void *buffer, size_t buflen, RIL_SOCKET_ID socket_id) { 474 Parcel p; 475 status_t status; 476 int32_t request; 477 int32_t token; 478 RequestInfo *pRI; 479 int ret; 480 /* Hook for current context */ 481 /* pendingRequestsMutextHook refer to &s_pendingRequestsMutex */ 482 pthread_mutex_t* pendingRequestsMutexHook = &s_pendingRequestsMutex; 483 /* pendingRequestsHook refer to &s_pendingRequests */ 484 RequestInfo** pendingRequestsHook = &s_pendingRequests; 485 486 p.setData((uint8_t *) buffer, buflen); 487 488 // status checked at end 489 status = p.readInt32(&request); 490 status = p.readInt32 (&token); 491 492 #if (SIM_COUNT >= 2) 493 if (socket_id == RIL_SOCKET_2) { 494 pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2; 495 pendingRequestsHook = &s_pendingRequests_socket2; 496 } 497 #if (SIM_COUNT >= 3) 498 else if (socket_id == RIL_SOCKET_3) { 499 pendingRequestsMutexHook = &s_pendingRequestsMutex_socket3; 500 pendingRequestsHook = &s_pendingRequests_socket3; 501 } 502 #endif 503 #if (SIM_COUNT >= 4) 504 else if (socket_id == RIL_SOCKET_4) { 505 pendingRequestsMutexHook = &s_pendingRequestsMutex_socket4; 506 pendingRequestsHook = &s_pendingRequests_socket4; 507 } 508 #endif 509 #endif 510 511 if (status != NO_ERROR) { 512 RLOGE("invalid request block"); 513 return 0; 514 } 515 516 if (request < 1 || request >= (int32_t)NUM_ELEMS(s_commands)) { 517 Parcel pErr; 518 RLOGE("unsupported request code %d token %d", request, token); 519 // FIXME this should perhaps return a response 520 pErr.writeInt32 (RESPONSE_SOLICITED); 521 pErr.writeInt32 (token); 522 pErr.writeInt32 (RIL_E_GENERIC_FAILURE); 523 524 sendResponse(pErr, socket_id); 525 return 0; 526 } 527 528 529 pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo)); 530 531 pRI->token = token; 532 pRI->pCI = &(s_commands[request]); 533 pRI->socket_id = socket_id; 534 535 ret = pthread_mutex_lock(pendingRequestsMutexHook); 536 assert (ret == 0); 537 538 pRI->p_next = *pendingRequestsHook; 539 *pendingRequestsHook = pRI; 540 541 ret = pthread_mutex_unlock(pendingRequestsMutexHook); 542 assert (ret == 0); 543 544 /* sLastDispatchedToken = token; */ 545 546 pRI->pCI->dispatchFunction(p, pRI); 547 548 return 0; 549 } 550 551 static void 552 invalidCommandBlock (RequestInfo *pRI) { 553 RLOGE("invalid command block for token %d request %s", 554 pRI->token, requestToString(pRI->pCI->requestNumber)); 555 } 556 557 /** Callee expects NULL */ 558 static void 559 dispatchVoid (Parcel& p, RequestInfo *pRI) { 560 clearPrintBuf; 561 printRequest(pRI->token, pRI->pCI->requestNumber); 562 CALL_ONREQUEST(pRI->pCI->requestNumber, NULL, 0, pRI, pRI->socket_id); 563 } 564 565 /** Callee expects const char * */ 566 static void 567 dispatchString (Parcel& p, RequestInfo *pRI) { 568 status_t status; 569 size_t datalen; 570 size_t stringlen; 571 char *string8 = NULL; 572 573 string8 = strdupReadString(p); 574 575 startRequest; 576 appendPrintBuf("%s%s", printBuf, string8); 577 closeRequest; 578 printRequest(pRI->token, pRI->pCI->requestNumber); 579 580 CALL_ONREQUEST(pRI->pCI->requestNumber, string8, 581 sizeof(char *), pRI, pRI->socket_id); 582 583 #ifdef MEMSET_FREED 584 memsetString(string8); 585 #endif 586 587 free(string8); 588 return; 589 invalid: 590 invalidCommandBlock(pRI); 591 return; 592 } 593 594 /** Callee expects const char ** */ 595 static void 596 dispatchStrings (Parcel &p, RequestInfo *pRI) { 597 int32_t countStrings; 598 status_t status; 599 size_t datalen; 600 char **pStrings; 601 602 status = p.readInt32 (&countStrings); 603 604 if (status != NO_ERROR) { 605 goto invalid; 606 } 607 608 startRequest; 609 if (countStrings == 0) { 610 // just some non-null pointer 611 pStrings = (char **)alloca(sizeof(char *)); 612 datalen = 0; 613 } else if (((int)countStrings) == -1) { 614 pStrings = NULL; 615 datalen = 0; 616 } else { 617 datalen = sizeof(char *) * countStrings; 618 619 pStrings = (char **)alloca(datalen); 620 621 for (int i = 0 ; i < countStrings ; i++) { 622 pStrings[i] = strdupReadString(p); 623 appendPrintBuf("%s%s,", printBuf, pStrings[i]); 624 } 625 } 626 removeLastChar; 627 closeRequest; 628 printRequest(pRI->token, pRI->pCI->requestNumber); 629 630 CALL_ONREQUEST(pRI->pCI->requestNumber, pStrings, datalen, pRI, pRI->socket_id); 631 632 if (pStrings != NULL) { 633 for (int i = 0 ; i < countStrings ; i++) { 634 #ifdef MEMSET_FREED 635 memsetString (pStrings[i]); 636 #endif 637 free(pStrings[i]); 638 } 639 640 #ifdef MEMSET_FREED 641 memset(pStrings, 0, datalen); 642 #endif 643 } 644 645 return; 646 invalid: 647 invalidCommandBlock(pRI); 648 return; 649 } 650 651 /** Callee expects const int * */ 652 static void 653 dispatchInts (Parcel &p, RequestInfo *pRI) { 654 int32_t count; 655 status_t status; 656 size_t datalen; 657 int *pInts; 658 659 status = p.readInt32 (&count); 660 661 if (status != NO_ERROR || count == 0) { 662 goto invalid; 663 } 664 665 datalen = sizeof(int) * count; 666 pInts = (int *)alloca(datalen); 667 668 startRequest; 669 for (int i = 0 ; i < count ; i++) { 670 int32_t t; 671 672 status = p.readInt32(&t); 673 pInts[i] = (int)t; 674 appendPrintBuf("%s%d,", printBuf, t); 675 676 if (status != NO_ERROR) { 677 goto invalid; 678 } 679 } 680 removeLastChar; 681 closeRequest; 682 printRequest(pRI->token, pRI->pCI->requestNumber); 683 684 CALL_ONREQUEST(pRI->pCI->requestNumber, const_cast<int *>(pInts), 685 datalen, pRI, pRI->socket_id); 686 687 #ifdef MEMSET_FREED 688 memset(pInts, 0, datalen); 689 #endif 690 691 return; 692 invalid: 693 invalidCommandBlock(pRI); 694 return; 695 } 696 697 698 /** 699 * Callee expects const RIL_SMS_WriteArgs * 700 * Payload is: 701 * int32_t status 702 * String pdu 703 */ 704 static void 705 dispatchSmsWrite (Parcel &p, RequestInfo *pRI) { 706 RIL_SMS_WriteArgs args; 707 int32_t t; 708 status_t status; 709 710 RLOGD("dispatchSmsWrite"); 711 memset (&args, 0, sizeof(args)); 712 713 status = p.readInt32(&t); 714 args.status = (int)t; 715 716 args.pdu = strdupReadString(p); 717 718 if (status != NO_ERROR || args.pdu == NULL) { 719 goto invalid; 720 } 721 722 args.smsc = strdupReadString(p); 723 724 startRequest; 725 appendPrintBuf("%s%d,%s,smsc=%s", printBuf, args.status, 726 (char*)args.pdu, (char*)args.smsc); 727 closeRequest; 728 printRequest(pRI->token, pRI->pCI->requestNumber); 729 730 CALL_ONREQUEST(pRI->pCI->requestNumber, &args, sizeof(args), pRI, pRI->socket_id); 731 732 #ifdef MEMSET_FREED 733 memsetString (args.pdu); 734 #endif 735 736 free (args.pdu); 737 738 #ifdef MEMSET_FREED 739 memset(&args, 0, sizeof(args)); 740 #endif 741 742 return; 743 invalid: 744 invalidCommandBlock(pRI); 745 return; 746 } 747 748 /** 749 * Callee expects const RIL_Dial * 750 * Payload is: 751 * String address 752 * int32_t clir 753 */ 754 static void 755 dispatchDial (Parcel &p, RequestInfo *pRI) { 756 RIL_Dial dial; 757 RIL_UUS_Info uusInfo; 758 int32_t sizeOfDial; 759 int32_t t; 760 int32_t uusPresent; 761 status_t status; 762 763 RLOGD("dispatchDial"); 764 memset (&dial, 0, sizeof(dial)); 765 766 dial.address = strdupReadString(p); 767 768 status = p.readInt32(&t); 769 dial.clir = (int)t; 770 771 if (status != NO_ERROR || dial.address == NULL) { 772 goto invalid; 773 } 774 775 if (s_callbacks.version < 3) { // Remove when partners upgrade to version 3 776 uusPresent = 0; 777 sizeOfDial = sizeof(dial) - sizeof(RIL_UUS_Info *); 778 } else { 779 status = p.readInt32(&uusPresent); 780 781 if (status != NO_ERROR) { 782 goto invalid; 783 } 784 785 if (uusPresent == 0) { 786 dial.uusInfo = NULL; 787 } else { 788 int32_t len; 789 790 memset(&uusInfo, 0, sizeof(RIL_UUS_Info)); 791 792 status = p.readInt32(&t); 793 uusInfo.uusType = (RIL_UUS_Type) t; 794 795 status = p.readInt32(&t); 796 uusInfo.uusDcs = (RIL_UUS_DCS) t; 797 798 status = p.readInt32(&len); 799 if (status != NO_ERROR) { 800 goto invalid; 801 } 802 803 // The java code writes -1 for null arrays 804 if (((int) len) == -1) { 805 uusInfo.uusData = NULL; 806 len = 0; 807 } else { 808 uusInfo.uusData = (char*) p.readInplace(len); 809 } 810 811 uusInfo.uusLength = len; 812 dial.uusInfo = &uusInfo; 813 } 814 sizeOfDial = sizeof(dial); 815 } 816 817 startRequest; 818 appendPrintBuf("%snum=%s,clir=%d", printBuf, dial.address, dial.clir); 819 if (uusPresent) { 820 appendPrintBuf("%s,uusType=%d,uusDcs=%d,uusLen=%d", printBuf, 821 dial.uusInfo->uusType, dial.uusInfo->uusDcs, 822 dial.uusInfo->uusLength); 823 } 824 closeRequest; 825 printRequest(pRI->token, pRI->pCI->requestNumber); 826 827 CALL_ONREQUEST(pRI->pCI->requestNumber, &dial, sizeOfDial, pRI, pRI->socket_id); 828 829 #ifdef MEMSET_FREED 830 memsetString (dial.address); 831 #endif 832 833 free (dial.address); 834 835 #ifdef MEMSET_FREED 836 memset(&uusInfo, 0, sizeof(RIL_UUS_Info)); 837 memset(&dial, 0, sizeof(dial)); 838 #endif 839 840 return; 841 invalid: 842 invalidCommandBlock(pRI); 843 return; 844 } 845 846 /** 847 * Callee expects const RIL_SIM_IO * 848 * Payload is: 849 * int32_t command 850 * int32_t fileid 851 * String path 852 * int32_t p1, p2, p3 853 * String data 854 * String pin2 855 * String aidPtr 856 */ 857 static void 858 dispatchSIM_IO (Parcel &p, RequestInfo *pRI) { 859 union RIL_SIM_IO { 860 RIL_SIM_IO_v6 v6; 861 RIL_SIM_IO_v5 v5; 862 } simIO; 863 864 int32_t t; 865 int size; 866 status_t status; 867 868 #if VDBG 869 RLOGD("dispatchSIM_IO"); 870 #endif 871 memset (&simIO, 0, sizeof(simIO)); 872 873 // note we only check status at the end 874 875 status = p.readInt32(&t); 876 simIO.v6.command = (int)t; 877 878 status = p.readInt32(&t); 879 simIO.v6.fileid = (int)t; 880 881 simIO.v6.path = strdupReadString(p); 882 883 status = p.readInt32(&t); 884 simIO.v6.p1 = (int)t; 885 886 status = p.readInt32(&t); 887 simIO.v6.p2 = (int)t; 888 889 status = p.readInt32(&t); 890 simIO.v6.p3 = (int)t; 891 892 simIO.v6.data = strdupReadString(p); 893 simIO.v6.pin2 = strdupReadString(p); 894 simIO.v6.aidPtr = strdupReadString(p); 895 896 startRequest; 897 appendPrintBuf("%scmd=0x%X,efid=0x%X,path=%s,%d,%d,%d,%s,pin2=%s,aid=%s", printBuf, 898 simIO.v6.command, simIO.v6.fileid, (char*)simIO.v6.path, 899 simIO.v6.p1, simIO.v6.p2, simIO.v6.p3, 900 (char*)simIO.v6.data, (char*)simIO.v6.pin2, simIO.v6.aidPtr); 901 closeRequest; 902 printRequest(pRI->token, pRI->pCI->requestNumber); 903 904 if (status != NO_ERROR) { 905 goto invalid; 906 } 907 908 size = (s_callbacks.version < 6) ? sizeof(simIO.v5) : sizeof(simIO.v6); 909 CALL_ONREQUEST(pRI->pCI->requestNumber, &simIO, size, pRI, pRI->socket_id); 910 911 #ifdef MEMSET_FREED 912 memsetString (simIO.v6.path); 913 memsetString (simIO.v6.data); 914 memsetString (simIO.v6.pin2); 915 memsetString (simIO.v6.aidPtr); 916 #endif 917 918 free (simIO.v6.path); 919 free (simIO.v6.data); 920 free (simIO.v6.pin2); 921 free (simIO.v6.aidPtr); 922 923 #ifdef MEMSET_FREED 924 memset(&simIO, 0, sizeof(simIO)); 925 #endif 926 927 return; 928 invalid: 929 invalidCommandBlock(pRI); 930 return; 931 } 932 933 /** 934 * Callee expects const RIL_SIM_APDU * 935 * Payload is: 936 * int32_t sessionid 937 * int32_t cla 938 * int32_t instruction 939 * int32_t p1, p2, p3 940 * String data 941 */ 942 static void 943 dispatchSIM_APDU (Parcel &p, RequestInfo *pRI) { 944 int32_t t; 945 status_t status; 946 RIL_SIM_APDU apdu; 947 948 #if VDBG 949 RLOGD("dispatchSIM_APDU"); 950 #endif 951 memset (&apdu, 0, sizeof(RIL_SIM_APDU)); 952 953 // Note we only check status at the end. Any single failure leads to 954 // subsequent reads filing. 955 status = p.readInt32(&t); 956 apdu.sessionid = (int)t; 957 958 status = p.readInt32(&t); 959 apdu.cla = (int)t; 960 961 status = p.readInt32(&t); 962 apdu.instruction = (int)t; 963 964 status = p.readInt32(&t); 965 apdu.p1 = (int)t; 966 967 status = p.readInt32(&t); 968 apdu.p2 = (int)t; 969 970 status = p.readInt32(&t); 971 apdu.p3 = (int)t; 972 973 apdu.data = strdupReadString(p); 974 975 startRequest; 976 appendPrintBuf("%ssessionid=%d,cla=%d,ins=%d,p1=%d,p2=%d,p3=%d,data=%s", 977 printBuf, apdu.sessionid, apdu.cla, apdu.instruction, apdu.p1, apdu.p2, 978 apdu.p3, (char*)apdu.data); 979 closeRequest; 980 printRequest(pRI->token, pRI->pCI->requestNumber); 981 982 if (status != NO_ERROR) { 983 goto invalid; 984 } 985 986 CALL_ONREQUEST(pRI->pCI->requestNumber, &apdu, sizeof(RIL_SIM_APDU), pRI, pRI->socket_id); 987 988 #ifdef MEMSET_FREED 989 memsetString(apdu.data); 990 #endif 991 free(apdu.data); 992 993 #ifdef MEMSET_FREED 994 memset(&apdu, 0, sizeof(RIL_SIM_APDU)); 995 #endif 996 997 return; 998 invalid: 999 invalidCommandBlock(pRI); 1000 return; 1001 } 1002 1003 1004 /** 1005 * Callee expects const RIL_CallForwardInfo * 1006 * Payload is: 1007 * int32_t status/action 1008 * int32_t reason 1009 * int32_t serviceCode 1010 * int32_t toa 1011 * String number (0 length -> null) 1012 * int32_t timeSeconds 1013 */ 1014 static void 1015 dispatchCallForward(Parcel &p, RequestInfo *pRI) { 1016 RIL_CallForwardInfo cff; 1017 int32_t t; 1018 status_t status; 1019 1020 RLOGD("dispatchCallForward"); 1021 memset (&cff, 0, sizeof(cff)); 1022 1023 // note we only check status at the end 1024 1025 status = p.readInt32(&t); 1026 cff.status = (int)t; 1027 1028 status = p.readInt32(&t); 1029 cff.reason = (int)t; 1030 1031 status = p.readInt32(&t); 1032 cff.serviceClass = (int)t; 1033 1034 status = p.readInt32(&t); 1035 cff.toa = (int)t; 1036 1037 cff.number = strdupReadString(p); 1038 1039 status = p.readInt32(&t); 1040 cff.timeSeconds = (int)t; 1041 1042 if (status != NO_ERROR) { 1043 goto invalid; 1044 } 1045 1046 // special case: number 0-length fields is null 1047 1048 if (cff.number != NULL && strlen (cff.number) == 0) { 1049 cff.number = NULL; 1050 } 1051 1052 startRequest; 1053 appendPrintBuf("%sstat=%d,reason=%d,serv=%d,toa=%d,%s,tout=%d", printBuf, 1054 cff.status, cff.reason, cff.serviceClass, cff.toa, 1055 (char*)cff.number, cff.timeSeconds); 1056 closeRequest; 1057 printRequest(pRI->token, pRI->pCI->requestNumber); 1058 1059 CALL_ONREQUEST(pRI->pCI->requestNumber, &cff, sizeof(cff), pRI, pRI->socket_id); 1060 1061 #ifdef MEMSET_FREED 1062 memsetString(cff.number); 1063 #endif 1064 1065 free (cff.number); 1066 1067 #ifdef MEMSET_FREED 1068 memset(&cff, 0, sizeof(cff)); 1069 #endif 1070 1071 return; 1072 invalid: 1073 invalidCommandBlock(pRI); 1074 return; 1075 } 1076 1077 1078 static void 1079 dispatchRaw(Parcel &p, RequestInfo *pRI) { 1080 int32_t len; 1081 status_t status; 1082 const void *data; 1083 1084 status = p.readInt32(&len); 1085 1086 if (status != NO_ERROR) { 1087 goto invalid; 1088 } 1089 1090 // The java code writes -1 for null arrays 1091 if (((int)len) == -1) { 1092 data = NULL; 1093 len = 0; 1094 } 1095 1096 data = p.readInplace(len); 1097 1098 startRequest; 1099 appendPrintBuf("%sraw_size=%d", printBuf, len); 1100 closeRequest; 1101 printRequest(pRI->token, pRI->pCI->requestNumber); 1102 1103 CALL_ONREQUEST(pRI->pCI->requestNumber, const_cast<void *>(data), len, pRI, pRI->socket_id); 1104 1105 return; 1106 invalid: 1107 invalidCommandBlock(pRI); 1108 return; 1109 } 1110 1111 static status_t 1112 constructCdmaSms(Parcel &p, RequestInfo *pRI, RIL_CDMA_SMS_Message& rcsm) { 1113 int32_t t; 1114 uint8_t ut; 1115 status_t status; 1116 int32_t digitCount; 1117 int digitLimit; 1118 1119 memset(&rcsm, 0, sizeof(rcsm)); 1120 1121 status = p.readInt32(&t); 1122 rcsm.uTeleserviceID = (int) t; 1123 1124 status = p.read(&ut,sizeof(ut)); 1125 rcsm.bIsServicePresent = (uint8_t) ut; 1126 1127 status = p.readInt32(&t); 1128 rcsm.uServicecategory = (int) t; 1129 1130 status = p.readInt32(&t); 1131 rcsm.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) t; 1132 1133 status = p.readInt32(&t); 1134 rcsm.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) t; 1135 1136 status = p.readInt32(&t); 1137 rcsm.sAddress.number_type = (RIL_CDMA_SMS_NumberType) t; 1138 1139 status = p.readInt32(&t); 1140 rcsm.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) t; 1141 1142 status = p.read(&ut,sizeof(ut)); 1143 rcsm.sAddress.number_of_digits= (uint8_t) ut; 1144 1145 digitLimit= MIN((rcsm.sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX); 1146 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) { 1147 status = p.read(&ut,sizeof(ut)); 1148 rcsm.sAddress.digits[digitCount] = (uint8_t) ut; 1149 } 1150 1151 status = p.readInt32(&t); 1152 rcsm.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) t; 1153 1154 status = p.read(&ut,sizeof(ut)); 1155 rcsm.sSubAddress.odd = (uint8_t) ut; 1156 1157 status = p.read(&ut,sizeof(ut)); 1158 rcsm.sSubAddress.number_of_digits = (uint8_t) ut; 1159 1160 digitLimit= MIN((rcsm.sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX); 1161 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) { 1162 status = p.read(&ut,sizeof(ut)); 1163 rcsm.sSubAddress.digits[digitCount] = (uint8_t) ut; 1164 } 1165 1166 status = p.readInt32(&t); 1167 rcsm.uBearerDataLen = (int) t; 1168 1169 digitLimit= MIN((rcsm.uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX); 1170 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) { 1171 status = p.read(&ut, sizeof(ut)); 1172 rcsm.aBearerData[digitCount] = (uint8_t) ut; 1173 } 1174 1175 if (status != NO_ERROR) { 1176 return status; 1177 } 1178 1179 startRequest; 1180 appendPrintBuf("%suTeleserviceID=%d, bIsServicePresent=%d, uServicecategory=%d, \ 1181 sAddress.digit_mode=%d, sAddress.Number_mode=%d, sAddress.number_type=%d, ", 1182 printBuf, rcsm.uTeleserviceID,rcsm.bIsServicePresent,rcsm.uServicecategory, 1183 rcsm.sAddress.digit_mode, rcsm.sAddress.number_mode,rcsm.sAddress.number_type); 1184 closeRequest; 1185 1186 printRequest(pRI->token, pRI->pCI->requestNumber); 1187 1188 return status; 1189 } 1190 1191 static void 1192 dispatchCdmaSms(Parcel &p, RequestInfo *pRI) { 1193 RIL_CDMA_SMS_Message rcsm; 1194 1195 RLOGD("dispatchCdmaSms"); 1196 if (NO_ERROR != constructCdmaSms(p, pRI, rcsm)) { 1197 goto invalid; 1198 } 1199 1200 CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsm, sizeof(rcsm),pRI, pRI->socket_id); 1201 1202 #ifdef MEMSET_FREED 1203 memset(&rcsm, 0, sizeof(rcsm)); 1204 #endif 1205 1206 return; 1207 1208 invalid: 1209 invalidCommandBlock(pRI); 1210 return; 1211 } 1212 1213 static void 1214 dispatchImsCdmaSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef) { 1215 RIL_IMS_SMS_Message rism; 1216 RIL_CDMA_SMS_Message rcsm; 1217 1218 RLOGD("dispatchImsCdmaSms: retry=%d, messageRef=%d", retry, messageRef); 1219 1220 if (NO_ERROR != constructCdmaSms(p, pRI, rcsm)) { 1221 goto invalid; 1222 } 1223 memset(&rism, 0, sizeof(rism)); 1224 rism.tech = RADIO_TECH_3GPP2; 1225 rism.retry = retry; 1226 rism.messageRef = messageRef; 1227 rism.message.cdmaMessage = &rcsm; 1228 1229 CALL_ONREQUEST(pRI->pCI->requestNumber, &rism, 1230 sizeof(RIL_RadioTechnologyFamily)+sizeof(uint8_t)+sizeof(int32_t) 1231 +sizeof(rcsm),pRI, pRI->socket_id); 1232 1233 #ifdef MEMSET_FREED 1234 memset(&rcsm, 0, sizeof(rcsm)); 1235 memset(&rism, 0, sizeof(rism)); 1236 #endif 1237 1238 return; 1239 1240 invalid: 1241 invalidCommandBlock(pRI); 1242 return; 1243 } 1244 1245 static void 1246 dispatchImsGsmSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef) { 1247 RIL_IMS_SMS_Message rism; 1248 int32_t countStrings; 1249 status_t status; 1250 size_t datalen; 1251 char **pStrings; 1252 RLOGD("dispatchImsGsmSms: retry=%d, messageRef=%d", retry, messageRef); 1253 1254 status = p.readInt32 (&countStrings); 1255 1256 if (status != NO_ERROR) { 1257 goto invalid; 1258 } 1259 1260 memset(&rism, 0, sizeof(rism)); 1261 rism.tech = RADIO_TECH_3GPP; 1262 rism.retry = retry; 1263 rism.messageRef = messageRef; 1264 1265 startRequest; 1266 appendPrintBuf("%stech=%d, retry=%d, messageRef=%d, ", printBuf, 1267 (int)rism.tech, (int)rism.retry, rism.messageRef); 1268 if (countStrings == 0) { 1269 // just some non-null pointer 1270 pStrings = (char **)alloca(sizeof(char *)); 1271 datalen = 0; 1272 } else if (((int)countStrings) == -1) { 1273 pStrings = NULL; 1274 datalen = 0; 1275 } else { 1276 datalen = sizeof(char *) * countStrings; 1277 1278 pStrings = (char **)alloca(datalen); 1279 1280 for (int i = 0 ; i < countStrings ; i++) { 1281 pStrings[i] = strdupReadString(p); 1282 appendPrintBuf("%s%s,", printBuf, pStrings[i]); 1283 } 1284 } 1285 removeLastChar; 1286 closeRequest; 1287 printRequest(pRI->token, pRI->pCI->requestNumber); 1288 1289 rism.message.gsmMessage = pStrings; 1290 CALL_ONREQUEST(pRI->pCI->requestNumber, &rism, 1291 sizeof(RIL_RadioTechnologyFamily)+sizeof(uint8_t)+sizeof(int32_t) 1292 +datalen, pRI, pRI->socket_id); 1293 1294 if (pStrings != NULL) { 1295 for (int i = 0 ; i < countStrings ; i++) { 1296 #ifdef MEMSET_FREED 1297 memsetString (pStrings[i]); 1298 #endif 1299 free(pStrings[i]); 1300 } 1301 1302 #ifdef MEMSET_FREED 1303 memset(pStrings, 0, datalen); 1304 #endif 1305 } 1306 1307 #ifdef MEMSET_FREED 1308 memset(&rism, 0, sizeof(rism)); 1309 #endif 1310 return; 1311 invalid: 1312 ALOGE("dispatchImsGsmSms invalid block"); 1313 invalidCommandBlock(pRI); 1314 return; 1315 } 1316 1317 static void 1318 dispatchImsSms(Parcel &p, RequestInfo *pRI) { 1319 int32_t t; 1320 status_t status = p.readInt32(&t); 1321 RIL_RadioTechnologyFamily format; 1322 uint8_t retry; 1323 int32_t messageRef; 1324 1325 RLOGD("dispatchImsSms"); 1326 if (status != NO_ERROR) { 1327 goto invalid; 1328 } 1329 format = (RIL_RadioTechnologyFamily) t; 1330 1331 // read retry field 1332 status = p.read(&retry,sizeof(retry)); 1333 if (status != NO_ERROR) { 1334 goto invalid; 1335 } 1336 // read messageRef field 1337 status = p.read(&messageRef,sizeof(messageRef)); 1338 if (status != NO_ERROR) { 1339 goto invalid; 1340 } 1341 1342 if (RADIO_TECH_3GPP == format) { 1343 dispatchImsGsmSms(p, pRI, retry, messageRef); 1344 } else if (RADIO_TECH_3GPP2 == format) { 1345 dispatchImsCdmaSms(p, pRI, retry, messageRef); 1346 } else { 1347 ALOGE("requestImsSendSMS invalid format value =%d", format); 1348 } 1349 1350 return; 1351 1352 invalid: 1353 invalidCommandBlock(pRI); 1354 return; 1355 } 1356 1357 static void 1358 dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI) { 1359 RIL_CDMA_SMS_Ack rcsa; 1360 int32_t t; 1361 status_t status; 1362 int32_t digitCount; 1363 1364 RLOGD("dispatchCdmaSmsAck"); 1365 memset(&rcsa, 0, sizeof(rcsa)); 1366 1367 status = p.readInt32(&t); 1368 rcsa.uErrorClass = (RIL_CDMA_SMS_ErrorClass) t; 1369 1370 status = p.readInt32(&t); 1371 rcsa.uSMSCauseCode = (int) t; 1372 1373 if (status != NO_ERROR) { 1374 goto invalid; 1375 } 1376 1377 startRequest; 1378 appendPrintBuf("%suErrorClass=%d, uTLStatus=%d, ", 1379 printBuf, rcsa.uErrorClass, rcsa.uSMSCauseCode); 1380 closeRequest; 1381 1382 printRequest(pRI->token, pRI->pCI->requestNumber); 1383 1384 CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsa, sizeof(rcsa),pRI, pRI->socket_id); 1385 1386 #ifdef MEMSET_FREED 1387 memset(&rcsa, 0, sizeof(rcsa)); 1388 #endif 1389 1390 return; 1391 1392 invalid: 1393 invalidCommandBlock(pRI); 1394 return; 1395 } 1396 1397 static void 1398 dispatchGsmBrSmsCnf(Parcel &p, RequestInfo *pRI) { 1399 int32_t t; 1400 status_t status; 1401 int32_t num; 1402 1403 status = p.readInt32(&num); 1404 if (status != NO_ERROR) { 1405 goto invalid; 1406 } 1407 1408 { 1409 RIL_GSM_BroadcastSmsConfigInfo gsmBci[num]; 1410 RIL_GSM_BroadcastSmsConfigInfo *gsmBciPtrs[num]; 1411 1412 startRequest; 1413 for (int i = 0 ; i < num ; i++ ) { 1414 gsmBciPtrs[i] = &gsmBci[i]; 1415 1416 status = p.readInt32(&t); 1417 gsmBci[i].fromServiceId = (int) t; 1418 1419 status = p.readInt32(&t); 1420 gsmBci[i].toServiceId = (int) t; 1421 1422 status = p.readInt32(&t); 1423 gsmBci[i].fromCodeScheme = (int) t; 1424 1425 status = p.readInt32(&t); 1426 gsmBci[i].toCodeScheme = (int) t; 1427 1428 status = p.readInt32(&t); 1429 gsmBci[i].selected = (uint8_t) t; 1430 1431 appendPrintBuf("%s [%d: fromServiceId=%d, toServiceId =%d, \ 1432 fromCodeScheme=%d, toCodeScheme=%d, selected =%d]", printBuf, i, 1433 gsmBci[i].fromServiceId, gsmBci[i].toServiceId, 1434 gsmBci[i].fromCodeScheme, gsmBci[i].toCodeScheme, 1435 gsmBci[i].selected); 1436 } 1437 closeRequest; 1438 1439 if (status != NO_ERROR) { 1440 goto invalid; 1441 } 1442 1443 CALL_ONREQUEST(pRI->pCI->requestNumber, 1444 gsmBciPtrs, 1445 num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *), 1446 pRI, pRI->socket_id); 1447 1448 #ifdef MEMSET_FREED 1449 memset(gsmBci, 0, num * sizeof(RIL_GSM_BroadcastSmsConfigInfo)); 1450 memset(gsmBciPtrs, 0, num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *)); 1451 #endif 1452 } 1453 1454 return; 1455 1456 invalid: 1457 invalidCommandBlock(pRI); 1458 return; 1459 } 1460 1461 static void 1462 dispatchCdmaBrSmsCnf(Parcel &p, RequestInfo *pRI) { 1463 int32_t t; 1464 status_t status; 1465 int32_t num; 1466 1467 status = p.readInt32(&num); 1468 if (status != NO_ERROR) { 1469 goto invalid; 1470 } 1471 1472 { 1473 RIL_CDMA_BroadcastSmsConfigInfo cdmaBci[num]; 1474 RIL_CDMA_BroadcastSmsConfigInfo *cdmaBciPtrs[num]; 1475 1476 startRequest; 1477 for (int i = 0 ; i < num ; i++ ) { 1478 cdmaBciPtrs[i] = &cdmaBci[i]; 1479 1480 status = p.readInt32(&t); 1481 cdmaBci[i].service_category = (int) t; 1482 1483 status = p.readInt32(&t); 1484 cdmaBci[i].language = (int) t; 1485 1486 status = p.readInt32(&t); 1487 cdmaBci[i].selected = (uint8_t) t; 1488 1489 appendPrintBuf("%s [%d: service_category=%d, language =%d, \ 1490 entries.bSelected =%d]", printBuf, i, cdmaBci[i].service_category, 1491 cdmaBci[i].language, cdmaBci[i].selected); 1492 } 1493 closeRequest; 1494 1495 if (status != NO_ERROR) { 1496 goto invalid; 1497 } 1498 1499 CALL_ONREQUEST(pRI->pCI->requestNumber, 1500 cdmaBciPtrs, 1501 num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *), 1502 pRI, pRI->socket_id); 1503 1504 #ifdef MEMSET_FREED 1505 memset(cdmaBci, 0, num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo)); 1506 memset(cdmaBciPtrs, 0, num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *)); 1507 #endif 1508 } 1509 1510 return; 1511 1512 invalid: 1513 invalidCommandBlock(pRI); 1514 return; 1515 } 1516 1517 static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI) { 1518 RIL_CDMA_SMS_WriteArgs rcsw; 1519 int32_t t; 1520 uint32_t ut; 1521 uint8_t uct; 1522 status_t status; 1523 int32_t digitCount; 1524 1525 memset(&rcsw, 0, sizeof(rcsw)); 1526 1527 status = p.readInt32(&t); 1528 rcsw.status = t; 1529 1530 status = p.readInt32(&t); 1531 rcsw.message.uTeleserviceID = (int) t; 1532 1533 status = p.read(&uct,sizeof(uct)); 1534 rcsw.message.bIsServicePresent = (uint8_t) uct; 1535 1536 status = p.readInt32(&t); 1537 rcsw.message.uServicecategory = (int) t; 1538 1539 status = p.readInt32(&t); 1540 rcsw.message.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) t; 1541 1542 status = p.readInt32(&t); 1543 rcsw.message.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) t; 1544 1545 status = p.readInt32(&t); 1546 rcsw.message.sAddress.number_type = (RIL_CDMA_SMS_NumberType) t; 1547 1548 status = p.readInt32(&t); 1549 rcsw.message.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) t; 1550 1551 status = p.read(&uct,sizeof(uct)); 1552 rcsw.message.sAddress.number_of_digits = (uint8_t) uct; 1553 1554 for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_ADDRESS_MAX; digitCount ++) { 1555 status = p.read(&uct,sizeof(uct)); 1556 rcsw.message.sAddress.digits[digitCount] = (uint8_t) uct; 1557 } 1558 1559 status = p.readInt32(&t); 1560 rcsw.message.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) t; 1561 1562 status = p.read(&uct,sizeof(uct)); 1563 rcsw.message.sSubAddress.odd = (uint8_t) uct; 1564 1565 status = p.read(&uct,sizeof(uct)); 1566 rcsw.message.sSubAddress.number_of_digits = (uint8_t) uct; 1567 1568 for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_SUBADDRESS_MAX; digitCount ++) { 1569 status = p.read(&uct,sizeof(uct)); 1570 rcsw.message.sSubAddress.digits[digitCount] = (uint8_t) uct; 1571 } 1572 1573 status = p.readInt32(&t); 1574 rcsw.message.uBearerDataLen = (int) t; 1575 1576 for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_BEARER_DATA_MAX; digitCount ++) { 1577 status = p.read(&uct, sizeof(uct)); 1578 rcsw.message.aBearerData[digitCount] = (uint8_t) uct; 1579 } 1580 1581 if (status != NO_ERROR) { 1582 goto invalid; 1583 } 1584 1585 startRequest; 1586 appendPrintBuf("%sstatus=%d, message.uTeleserviceID=%d, message.bIsServicePresent=%d, \ 1587 message.uServicecategory=%d, message.sAddress.digit_mode=%d, \ 1588 message.sAddress.number_mode=%d, \ 1589 message.sAddress.number_type=%d, ", 1590 printBuf, rcsw.status, rcsw.message.uTeleserviceID, rcsw.message.bIsServicePresent, 1591 rcsw.message.uServicecategory, rcsw.message.sAddress.digit_mode, 1592 rcsw.message.sAddress.number_mode, 1593 rcsw.message.sAddress.number_type); 1594 closeRequest; 1595 1596 printRequest(pRI->token, pRI->pCI->requestNumber); 1597 1598 CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsw, sizeof(rcsw),pRI, pRI->socket_id); 1599 1600 #ifdef MEMSET_FREED 1601 memset(&rcsw, 0, sizeof(rcsw)); 1602 #endif 1603 1604 return; 1605 1606 invalid: 1607 invalidCommandBlock(pRI); 1608 return; 1609 1610 } 1611 1612 // For backwards compatibility in RIL_REQUEST_SETUP_DATA_CALL. 1613 // Version 4 of the RIL interface adds a new PDP type parameter to support 1614 // IPv6 and dual-stack PDP contexts. When dealing with a previous version of 1615 // RIL, remove the parameter from the request. 1616 static void dispatchDataCall(Parcel& p, RequestInfo *pRI) { 1617 // In RIL v3, REQUEST_SETUP_DATA_CALL takes 6 parameters. 1618 const int numParamsRilV3 = 6; 1619 1620 // The first bytes of the RIL parcel contain the request number and the 1621 // serial number - see processCommandBuffer(). Copy them over too. 1622 int pos = p.dataPosition(); 1623 1624 int numParams = p.readInt32(); 1625 if (s_callbacks.version < 4 && numParams > numParamsRilV3) { 1626 Parcel p2; 1627 p2.appendFrom(&p, 0, pos); 1628 p2.writeInt32(numParamsRilV3); 1629 for(int i = 0; i < numParamsRilV3; i++) { 1630 p2.writeString16(p.readString16()); 1631 } 1632 p2.setDataPosition(pos); 1633 dispatchStrings(p2, pRI); 1634 } else { 1635 p.setDataPosition(pos); 1636 dispatchStrings(p, pRI); 1637 } 1638 } 1639 1640 // For backwards compatibility with RILs that dont support RIL_REQUEST_VOICE_RADIO_TECH. 1641 // When all RILs handle this request, this function can be removed and 1642 // the request can be sent directly to the RIL using dispatchVoid. 1643 static void dispatchVoiceRadioTech(Parcel& p, RequestInfo *pRI) { 1644 RIL_RadioState state = CALL_ONSTATEREQUEST((RIL_SOCKET_ID)pRI->socket_id); 1645 1646 if ((RADIO_STATE_UNAVAILABLE == state) || (RADIO_STATE_OFF == state)) { 1647 RIL_onRequestComplete(pRI, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); 1648 } 1649 1650 // RILs that support RADIO_STATE_ON should support this request. 1651 if (RADIO_STATE_ON == state) { 1652 dispatchVoid(p, pRI); 1653 return; 1654 } 1655 1656 // For Older RILs, that do not support RADIO_STATE_ON, assume that they 1657 // will not support this new request either and decode Voice Radio Technology 1658 // from Radio State 1659 voiceRadioTech = decodeVoiceRadioTechnology(state); 1660 1661 if (voiceRadioTech < 0) 1662 RIL_onRequestComplete(pRI, RIL_E_GENERIC_FAILURE, NULL, 0); 1663 else 1664 RIL_onRequestComplete(pRI, RIL_E_SUCCESS, &voiceRadioTech, sizeof(int)); 1665 } 1666 1667 // For backwards compatibility in RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE:. 1668 // When all RILs handle this request, this function can be removed and 1669 // the request can be sent directly to the RIL using dispatchVoid. 1670 static void dispatchCdmaSubscriptionSource(Parcel& p, RequestInfo *pRI) { 1671 RIL_RadioState state = CALL_ONSTATEREQUEST((RIL_SOCKET_ID)pRI->socket_id); 1672 1673 if ((RADIO_STATE_UNAVAILABLE == state) || (RADIO_STATE_OFF == state)) { 1674 RIL_onRequestComplete(pRI, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); 1675 } 1676 1677 // RILs that support RADIO_STATE_ON should support this request. 1678 if (RADIO_STATE_ON == state) { 1679 dispatchVoid(p, pRI); 1680 return; 1681 } 1682 1683 // For Older RILs, that do not support RADIO_STATE_ON, assume that they 1684 // will not support this new request either and decode CDMA Subscription Source 1685 // from Radio State 1686 cdmaSubscriptionSource = decodeCdmaSubscriptionSource(state); 1687 1688 if (cdmaSubscriptionSource < 0) 1689 RIL_onRequestComplete(pRI, RIL_E_GENERIC_FAILURE, NULL, 0); 1690 else 1691 RIL_onRequestComplete(pRI, RIL_E_SUCCESS, &cdmaSubscriptionSource, sizeof(int)); 1692 } 1693 1694 static void dispatchSetInitialAttachApn(Parcel &p, RequestInfo *pRI) 1695 { 1696 RIL_InitialAttachApn pf; 1697 int32_t t; 1698 status_t status; 1699 1700 memset(&pf, 0, sizeof(pf)); 1701 1702 pf.apn = strdupReadString(p); 1703 pf.protocol = strdupReadString(p); 1704 1705 status = p.readInt32(&t); 1706 pf.authtype = (int) t; 1707 1708 pf.username = strdupReadString(p); 1709 pf.password = strdupReadString(p); 1710 1711 startRequest; 1712 appendPrintBuf("%sapn=%s, protocol=%s, authtype=%d, username=%s, password=%s", 1713 printBuf, pf.apn, pf.protocol, pf.authtype, pf.username, pf.password); 1714 closeRequest; 1715 printRequest(pRI->token, pRI->pCI->requestNumber); 1716 1717 if (status != NO_ERROR) { 1718 goto invalid; 1719 } 1720 CALL_ONREQUEST(pRI->pCI->requestNumber, &pf, sizeof(pf), pRI, pRI->socket_id); 1721 1722 #ifdef MEMSET_FREED 1723 memsetString(pf.apn); 1724 memsetString(pf.protocol); 1725 memsetString(pf.username); 1726 memsetString(pf.password); 1727 #endif 1728 1729 free(pf.apn); 1730 free(pf.protocol); 1731 free(pf.username); 1732 free(pf.password); 1733 1734 #ifdef MEMSET_FREED 1735 memset(&pf, 0, sizeof(pf)); 1736 #endif 1737 1738 return; 1739 invalid: 1740 invalidCommandBlock(pRI); 1741 return; 1742 } 1743 1744 static void dispatchNVReadItem(Parcel &p, RequestInfo *pRI) { 1745 RIL_NV_ReadItem nvri; 1746 int32_t t; 1747 status_t status; 1748 1749 memset(&nvri, 0, sizeof(nvri)); 1750 1751 status = p.readInt32(&t); 1752 nvri.itemID = (RIL_NV_Item) t; 1753 1754 if (status != NO_ERROR) { 1755 goto invalid; 1756 } 1757 1758 startRequest; 1759 appendPrintBuf("%snvri.itemID=%d, ", printBuf, nvri.itemID); 1760 closeRequest; 1761 1762 printRequest(pRI->token, pRI->pCI->requestNumber); 1763 1764 CALL_ONREQUEST(pRI->pCI->requestNumber, &nvri, sizeof(nvri), pRI, pRI->socket_id); 1765 1766 #ifdef MEMSET_FREED 1767 memset(&nvri, 0, sizeof(nvri)); 1768 #endif 1769 1770 return; 1771 1772 invalid: 1773 invalidCommandBlock(pRI); 1774 return; 1775 } 1776 1777 static void dispatchNVWriteItem(Parcel &p, RequestInfo *pRI) { 1778 RIL_NV_WriteItem nvwi; 1779 int32_t t; 1780 status_t status; 1781 1782 memset(&nvwi, 0, sizeof(nvwi)); 1783 1784 status = p.readInt32(&t); 1785 nvwi.itemID = (RIL_NV_Item) t; 1786 1787 nvwi.value = strdupReadString(p); 1788 1789 if (status != NO_ERROR || nvwi.value == NULL) { 1790 goto invalid; 1791 } 1792 1793 startRequest; 1794 appendPrintBuf("%snvwi.itemID=%d, value=%s, ", printBuf, nvwi.itemID, 1795 nvwi.value); 1796 closeRequest; 1797 1798 printRequest(pRI->token, pRI->pCI->requestNumber); 1799 1800 CALL_ONREQUEST(pRI->pCI->requestNumber, &nvwi, sizeof(nvwi), pRI, pRI->socket_id); 1801 1802 #ifdef MEMSET_FREED 1803 memsetString(nvwi.value); 1804 #endif 1805 1806 free(nvwi.value); 1807 1808 #ifdef MEMSET_FREED 1809 memset(&nvwi, 0, sizeof(nvwi)); 1810 #endif 1811 1812 return; 1813 1814 invalid: 1815 invalidCommandBlock(pRI); 1816 return; 1817 } 1818 1819 1820 static void dispatchUiccSubscripton(Parcel &p, RequestInfo *pRI) { 1821 RIL_SelectUiccSub uicc_sub; 1822 status_t status; 1823 int32_t t; 1824 memset(&uicc_sub, 0, sizeof(uicc_sub)); 1825 1826 status = p.readInt32(&t); 1827 if (status != NO_ERROR) { 1828 goto invalid; 1829 } 1830 uicc_sub.slot = (int) t; 1831 1832 status = p.readInt32(&t); 1833 if (status != NO_ERROR) { 1834 goto invalid; 1835 } 1836 uicc_sub.app_index = (int) t; 1837 1838 status = p.readInt32(&t); 1839 if (status != NO_ERROR) { 1840 goto invalid; 1841 } 1842 uicc_sub.sub_type = (RIL_SubscriptionType) t; 1843 1844 status = p.readInt32(&t); 1845 if (status != NO_ERROR) { 1846 goto invalid; 1847 } 1848 uicc_sub.act_status = (RIL_UiccSubActStatus) t; 1849 1850 startRequest; 1851 appendPrintBuf("slot=%d, app_index=%d, act_status = %d", uicc_sub.slot, uicc_sub.app_index, 1852 uicc_sub.act_status); 1853 RLOGD("dispatchUiccSubscription, slot=%d, app_index=%d, act_status = %d", uicc_sub.slot, 1854 uicc_sub.app_index, uicc_sub.act_status); 1855 closeRequest; 1856 printRequest(pRI->token, pRI->pCI->requestNumber); 1857 1858 CALL_ONREQUEST(pRI->pCI->requestNumber, &uicc_sub, sizeof(uicc_sub), pRI, pRI->socket_id); 1859 1860 #ifdef MEMSET_FREED 1861 memset(&uicc_sub, 0, sizeof(uicc_sub)); 1862 #endif 1863 return; 1864 1865 invalid: 1866 invalidCommandBlock(pRI); 1867 return; 1868 } 1869 1870 static void dispatchSimAuthentication(Parcel &p, RequestInfo *pRI) 1871 { 1872 RIL_SimAuthentication pf; 1873 int32_t t; 1874 status_t status; 1875 1876 memset(&pf, 0, sizeof(pf)); 1877 1878 status = p.readInt32(&t); 1879 pf.authContext = (int) t; 1880 pf.authData = strdupReadString(p); 1881 pf.aid = strdupReadString(p); 1882 1883 startRequest; 1884 appendPrintBuf("authContext=%s, authData=%s, aid=%s", pf.authContext, pf.authData, pf.aid); 1885 closeRequest; 1886 printRequest(pRI->token, pRI->pCI->requestNumber); 1887 1888 if (status != NO_ERROR) { 1889 goto invalid; 1890 } 1891 CALL_ONREQUEST(pRI->pCI->requestNumber, &pf, sizeof(pf), pRI, pRI->socket_id); 1892 1893 #ifdef MEMSET_FREED 1894 memsetString(pf.authData); 1895 memsetString(pf.aid); 1896 #endif 1897 1898 free(pf.authData); 1899 free(pf.aid); 1900 1901 #ifdef MEMSET_FREED 1902 memset(&pf, 0, sizeof(pf)); 1903 #endif 1904 1905 return; 1906 invalid: 1907 invalidCommandBlock(pRI); 1908 return; 1909 } 1910 1911 static void dispatchDataProfile(Parcel &p, RequestInfo *pRI) { 1912 int32_t t; 1913 status_t status; 1914 int32_t num; 1915 1916 status = p.readInt32(&num); 1917 if (status != NO_ERROR) { 1918 goto invalid; 1919 } 1920 1921 { 1922 RIL_DataProfileInfo dataProfiles[num]; 1923 RIL_DataProfileInfo *dataProfilePtrs[num]; 1924 1925 startRequest; 1926 for (int i = 0 ; i < num ; i++ ) { 1927 dataProfilePtrs[i] = &dataProfiles[i]; 1928 1929 status = p.readInt32(&t); 1930 dataProfiles[i].profileId = (int) t; 1931 1932 dataProfiles[i].apn = strdupReadString(p); 1933 dataProfiles[i].protocol = strdupReadString(p); 1934 status = p.readInt32(&t); 1935 dataProfiles[i].authType = (int) t; 1936 1937 dataProfiles[i].user = strdupReadString(p); 1938 dataProfiles[i].password = strdupReadString(p); 1939 1940 status = p.readInt32(&t); 1941 dataProfiles[i].type = (int) t; 1942 1943 status = p.readInt32(&t); 1944 dataProfiles[i].maxConnsTime = (int) t; 1945 status = p.readInt32(&t); 1946 dataProfiles[i].maxConns = (int) t; 1947 status = p.readInt32(&t); 1948 dataProfiles[i].waitTime = (int) t; 1949 1950 status = p.readInt32(&t); 1951 dataProfiles[i].enabled = (int) t; 1952 1953 appendPrintBuf("%s [%d: profileId=%d, apn =%s, protocol =%s, authType =%d, \ 1954 user =%s, password =%s, type =%d, maxConnsTime =%d, maxConns =%d, \ 1955 waitTime =%d, enabled =%d]", printBuf, i, dataProfiles[i].profileId, 1956 dataProfiles[i].apn, dataProfiles[i].protocol, dataProfiles[i].authType, 1957 dataProfiles[i].user, dataProfiles[i].password, dataProfiles[i].type, 1958 dataProfiles[i].maxConnsTime, dataProfiles[i].maxConns, 1959 dataProfiles[i].waitTime, dataProfiles[i].enabled); 1960 } 1961 closeRequest; 1962 printRequest(pRI->token, pRI->pCI->requestNumber); 1963 1964 if (status != NO_ERROR) { 1965 goto invalid; 1966 } 1967 CALL_ONREQUEST(pRI->pCI->requestNumber, 1968 dataProfilePtrs, 1969 num * sizeof(RIL_DataProfileInfo *), 1970 pRI, pRI->socket_id); 1971 1972 #ifdef MEMSET_FREED 1973 memset(dataProfiles, 0, num * sizeof(RIL_DataProfileInfo)); 1974 memset(dataProfilePtrs, 0, num * sizeof(RIL_DataProfileInfo *)); 1975 #endif 1976 } 1977 1978 return; 1979 1980 invalid: 1981 invalidCommandBlock(pRI); 1982 return; 1983 } 1984 1985 static void dispatchRadioCapability(Parcel &p, RequestInfo *pRI){ 1986 RIL_RadioCapability rc; 1987 int32_t t; 1988 status_t status; 1989 1990 memset (&rc, 0, sizeof(RIL_RadioCapability)); 1991 1992 status = p.readInt32(&t); 1993 rc.version = (int)t; 1994 if (status != NO_ERROR) { 1995 goto invalid; 1996 } 1997 1998 status = p.readInt32(&t); 1999 rc.session= (int)t; 2000 if (status != NO_ERROR) { 2001 goto invalid; 2002 } 2003 2004 status = p.readInt32(&t); 2005 rc.phase= (int)t; 2006 if (status != NO_ERROR) { 2007 goto invalid; 2008 } 2009 2010 status = p.readInt32(&t); 2011 rc.rat = (int)t; 2012 if (status != NO_ERROR) { 2013 goto invalid; 2014 } 2015 2016 status = readStringFromParcelInplace(p, rc.logicalModemUuid, sizeof(rc.logicalModemUuid)); 2017 if (status != NO_ERROR) { 2018 goto invalid; 2019 } 2020 2021 status = p.readInt32(&t); 2022 rc.status = (int)t; 2023 2024 if (status != NO_ERROR) { 2025 goto invalid; 2026 } 2027 2028 startRequest; 2029 appendPrintBuf("%s [version:%d, session:%d, phase:%d, rat:%d, \ 2030 logicalModemUuid:%s, status:%d", printBuf, rc.version, rc.session 2031 rc.phase, rc.rat, rc.logicalModemUuid, rc.session); 2032 2033 closeRequest; 2034 printRequest(pRI->token, pRI->pCI->requestNumber); 2035 2036 CALL_ONREQUEST(pRI->pCI->requestNumber, 2037 &rc, 2038 sizeof(RIL_RadioCapability), 2039 pRI, pRI->socket_id); 2040 return; 2041 invalid: 2042 invalidCommandBlock(pRI); 2043 return; 2044 } 2045 2046 static int 2047 blockingWrite(int fd, const void *buffer, size_t len) { 2048 size_t writeOffset = 0; 2049 const uint8_t *toWrite; 2050 2051 toWrite = (const uint8_t *)buffer; 2052 2053 while (writeOffset < len) { 2054 ssize_t written; 2055 do { 2056 written = write (fd, toWrite + writeOffset, 2057 len - writeOffset); 2058 } while (written < 0 && ((errno == EINTR) || (errno == EAGAIN))); 2059 2060 if (written >= 0) { 2061 writeOffset += written; 2062 } else { // written < 0 2063 RLOGE ("RIL Response: unexpected error on write errno:%d", errno); 2064 close(fd); 2065 return -1; 2066 } 2067 } 2068 #if VDBG 2069 RLOGE("RIL Response bytes written:%d", writeOffset); 2070 #endif 2071 return 0; 2072 } 2073 2074 static int 2075 sendResponseRaw (const void *data, size_t dataSize, RIL_SOCKET_ID socket_id) { 2076 int fd = s_ril_param_socket.fdCommand; 2077 int ret; 2078 uint32_t header; 2079 pthread_mutex_t * writeMutexHook = &s_writeMutex; 2080 2081 #if VDBG 2082 RLOGE("Send Response to %s", rilSocketIdToString(socket_id)); 2083 #endif 2084 2085 #if (SIM_COUNT >= 2) 2086 if (socket_id == RIL_SOCKET_2) { 2087 fd = s_ril_param_socket2.fdCommand; 2088 writeMutexHook = &s_writeMutex_socket2; 2089 } 2090 #if (SIM_COUNT >= 3) 2091 else if (socket_id == RIL_SOCKET_3) { 2092 fd = s_ril_param_socket3.fdCommand; 2093 writeMutexHook = &s_writeMutex_socket3; 2094 } 2095 #endif 2096 #if (SIM_COUNT >= 4) 2097 else if (socket_id == RIL_SOCKET_4) { 2098 fd = s_ril_param_socket4.fdCommand; 2099 writeMutexHook = &s_writeMutex_socket4; 2100 } 2101 #endif 2102 #endif 2103 if (fd < 0) { 2104 return -1; 2105 } 2106 2107 if (dataSize > MAX_COMMAND_BYTES) { 2108 RLOGE("RIL: packet larger than %u (%u)", 2109 MAX_COMMAND_BYTES, (unsigned int )dataSize); 2110 2111 return -1; 2112 } 2113 2114 pthread_mutex_lock(writeMutexHook); 2115 2116 header = htonl(dataSize); 2117 2118 ret = blockingWrite(fd, (void *)&header, sizeof(header)); 2119 2120 if (ret < 0) { 2121 pthread_mutex_unlock(writeMutexHook); 2122 return ret; 2123 } 2124 2125 ret = blockingWrite(fd, data, dataSize); 2126 2127 if (ret < 0) { 2128 pthread_mutex_unlock(writeMutexHook); 2129 return ret; 2130 } 2131 2132 pthread_mutex_unlock(writeMutexHook); 2133 2134 return 0; 2135 } 2136 2137 static int 2138 sendResponse (Parcel &p, RIL_SOCKET_ID socket_id) { 2139 printResponse; 2140 return sendResponseRaw(p.data(), p.dataSize(), socket_id); 2141 } 2142 2143 /** response is an int* pointing to an array of ints */ 2144 2145 static int 2146 responseInts(Parcel &p, void *response, size_t responselen) { 2147 int numInts; 2148 2149 if (response == NULL && responselen != 0) { 2150 RLOGE("invalid response: NULL"); 2151 return RIL_ERRNO_INVALID_RESPONSE; 2152 } 2153 if (responselen % sizeof(int) != 0) { 2154 RLOGE("responseInts: invalid response length %d expected multiple of %d\n", 2155 (int)responselen, (int)sizeof(int)); 2156 return RIL_ERRNO_INVALID_RESPONSE; 2157 } 2158 2159 int *p_int = (int *) response; 2160 2161 numInts = responselen / sizeof(int); 2162 p.writeInt32 (numInts); 2163 2164 /* each int*/ 2165 startResponse; 2166 for (int i = 0 ; i < numInts ; i++) { 2167 appendPrintBuf("%s%d,", printBuf, p_int[i]); 2168 p.writeInt32(p_int[i]); 2169 } 2170 removeLastChar; 2171 closeResponse; 2172 2173 return 0; 2174 } 2175 2176 // Response is an int or RIL_LastCallFailCauseInfo. 2177 // Currently, only Shamu plans to use RIL_LastCallFailCauseInfo. 2178 // TODO(yjl): Let all implementations use RIL_LastCallFailCauseInfo. 2179 static int responseFailCause(Parcel &p, void *response, size_t responselen) { 2180 if (response == NULL && responselen != 0) { 2181 RLOGE("invalid response: NULL"); 2182 return RIL_ERRNO_INVALID_RESPONSE; 2183 } 2184 2185 if (responselen == sizeof(int)) { 2186 startResponse; 2187 int *p_int = (int *) response; 2188 appendPrintBuf("%s%d,", printBuf, p_int[0]); 2189 p.writeInt32(p_int[0]); 2190 removeLastChar; 2191 closeResponse; 2192 } else if (responselen == sizeof(RIL_LastCallFailCauseInfo)) { 2193 startResponse; 2194 RIL_LastCallFailCauseInfo *p_fail_cause_info = (RIL_LastCallFailCauseInfo *) response; 2195 appendPrintBuf("%s[cause_code=%d,vendor_cause=%s]", printBuf, p_fail_cause_info->cause_code, 2196 p_fail_cause_info->vendor_cause); 2197 p.writeInt32(p_fail_cause_info->cause_code); 2198 writeStringToParcel(p, p_fail_cause_info->vendor_cause); 2199 removeLastChar; 2200 closeResponse; 2201 } else { 2202 RLOGE("responseFailCause: invalid response length %d expected an int or " 2203 "RIL_LastCallFailCauseInfo", (int)responselen); 2204 return RIL_ERRNO_INVALID_RESPONSE; 2205 } 2206 2207 return 0; 2208 } 2209 2210 /** response is a char **, pointing to an array of char *'s 2211 The parcel will begin with the version */ 2212 static int responseStringsWithVersion(int version, Parcel &p, void *response, size_t responselen) { 2213 p.writeInt32(version); 2214 return responseStrings(p, response, responselen); 2215 } 2216 2217 /** response is a char **, pointing to an array of char *'s */ 2218 static int responseStrings(Parcel &p, void *response, size_t responselen) { 2219 int numStrings; 2220 2221 if (response == NULL && responselen != 0) { 2222 RLOGE("invalid response: NULL"); 2223 return RIL_ERRNO_INVALID_RESPONSE; 2224 } 2225 if (responselen % sizeof(char *) != 0) { 2226 RLOGE("responseStrings: invalid response length %d expected multiple of %d\n", 2227 (int)responselen, (int)sizeof(char *)); 2228 return RIL_ERRNO_INVALID_RESPONSE; 2229 } 2230 2231 if (response == NULL) { 2232 p.writeInt32 (0); 2233 } else { 2234 char **p_cur = (char **) response; 2235 2236 numStrings = responselen / sizeof(char *); 2237 p.writeInt32 (numStrings); 2238 2239 /* each string*/ 2240 startResponse; 2241 for (int i = 0 ; i < numStrings ; i++) { 2242 appendPrintBuf("%s%s,", printBuf, (char*)p_cur[i]); 2243 writeStringToParcel (p, p_cur[i]); 2244 } 2245 removeLastChar; 2246 closeResponse; 2247 } 2248 return 0; 2249 } 2250 2251 2252 /** 2253 * NULL strings are accepted 2254 * FIXME currently ignores responselen 2255 */ 2256 static int responseString(Parcel &p, void *response, size_t responselen) { 2257 /* one string only */ 2258 startResponse; 2259 appendPrintBuf("%s%s", printBuf, (char*)response); 2260 closeResponse; 2261 2262 writeStringToParcel(p, (const char *)response); 2263 2264 return 0; 2265 } 2266 2267 static int responseVoid(Parcel &p, void *response, size_t responselen) { 2268 startResponse; 2269 removeLastChar; 2270 return 0; 2271 } 2272 2273 static int responseCallList(Parcel &p, void *response, size_t responselen) { 2274 int num; 2275 2276 if (response == NULL && responselen != 0) { 2277 RLOGE("invalid response: NULL"); 2278 return RIL_ERRNO_INVALID_RESPONSE; 2279 } 2280 2281 if (responselen % sizeof (RIL_Call *) != 0) { 2282 RLOGE("responseCallList: invalid response length %d expected multiple of %d\n", 2283 (int)responselen, (int)sizeof (RIL_Call *)); 2284 return RIL_ERRNO_INVALID_RESPONSE; 2285 } 2286 2287 startResponse; 2288 /* number of call info's */ 2289 num = responselen / sizeof(RIL_Call *); 2290 p.writeInt32(num); 2291 2292 for (int i = 0 ; i < num ; i++) { 2293 RIL_Call *p_cur = ((RIL_Call **) response)[i]; 2294 /* each call info */ 2295 p.writeInt32(p_cur->state); 2296 p.writeInt32(p_cur->index); 2297 p.writeInt32(p_cur->toa); 2298 p.writeInt32(p_cur->isMpty); 2299 p.writeInt32(p_cur->isMT); 2300 p.writeInt32(p_cur->als); 2301 p.writeInt32(p_cur->isVoice); 2302 p.writeInt32(p_cur->isVoicePrivacy); 2303 writeStringToParcel(p, p_cur->number); 2304 p.writeInt32(p_cur->numberPresentation); 2305 writeStringToParcel(p, p_cur->name); 2306 p.writeInt32(p_cur->namePresentation); 2307 // Remove when partners upgrade to version 3 2308 if ((s_callbacks.version < 3) || (p_cur->uusInfo == NULL || p_cur->uusInfo->uusData == NULL)) { 2309 p.writeInt32(0); /* UUS Information is absent */ 2310 } else { 2311 RIL_UUS_Info *uusInfo = p_cur->uusInfo; 2312 p.writeInt32(1); /* UUS Information is present */ 2313 p.writeInt32(uusInfo->uusType); 2314 p.writeInt32(uusInfo->uusDcs); 2315 p.writeInt32(uusInfo->uusLength); 2316 p.write(uusInfo->uusData, uusInfo->uusLength); 2317 } 2318 appendPrintBuf("%s[id=%d,%s,toa=%d,", 2319 printBuf, 2320 p_cur->index, 2321 callStateToString(p_cur->state), 2322 p_cur->toa); 2323 appendPrintBuf("%s%s,%s,als=%d,%s,%s,", 2324 printBuf, 2325 (p_cur->isMpty)?"conf":"norm", 2326 (p_cur->isMT)?"mt":"mo", 2327 p_cur->als, 2328 (p_cur->isVoice)?"voc":"nonvoc", 2329 (p_cur->isVoicePrivacy)?"evp":"noevp"); 2330 appendPrintBuf("%s%s,cli=%d,name='%s',%d]", 2331 printBuf, 2332 p_cur->number, 2333 p_cur->numberPresentation, 2334 p_cur->name, 2335 p_cur->namePresentation); 2336 } 2337 removeLastChar; 2338 closeResponse; 2339 2340 return 0; 2341 } 2342 2343 static int responseSMS(Parcel &p, void *response, size_t responselen) { 2344 if (response == NULL) { 2345 RLOGE("invalid response: NULL"); 2346 return RIL_ERRNO_INVALID_RESPONSE; 2347 } 2348 2349 if (responselen != sizeof (RIL_SMS_Response) ) { 2350 RLOGE("invalid response length %d expected %d", 2351 (int)responselen, (int)sizeof (RIL_SMS_Response)); 2352 return RIL_ERRNO_INVALID_RESPONSE; 2353 } 2354 2355 RIL_SMS_Response *p_cur = (RIL_SMS_Response *) response; 2356 2357 p.writeInt32(p_cur->messageRef); 2358 writeStringToParcel(p, p_cur->ackPDU); 2359 p.writeInt32(p_cur->errorCode); 2360 2361 startResponse; 2362 appendPrintBuf("%s%d,%s,%d", printBuf, p_cur->messageRef, 2363 (char*)p_cur->ackPDU, p_cur->errorCode); 2364 closeResponse; 2365 2366 return 0; 2367 } 2368 2369 static int responseDataCallListV4(Parcel &p, void *response, size_t responselen) 2370 { 2371 if (response == NULL && responselen != 0) { 2372 RLOGE("invalid response: NULL"); 2373 return RIL_ERRNO_INVALID_RESPONSE; 2374 } 2375 2376 if (responselen % sizeof(RIL_Data_Call_Response_v4) != 0) { 2377 RLOGE("responseDataCallListV4: invalid response length %d expected multiple of %d", 2378 (int)responselen, (int)sizeof(RIL_Data_Call_Response_v4)); 2379 return RIL_ERRNO_INVALID_RESPONSE; 2380 } 2381 2382 // Write version 2383 p.writeInt32(4); 2384 2385 int num = responselen / sizeof(RIL_Data_Call_Response_v4); 2386 p.writeInt32(num); 2387 2388 RIL_Data_Call_Response_v4 *p_cur = (RIL_Data_Call_Response_v4 *) response; 2389 startResponse; 2390 int i; 2391 for (i = 0; i < num; i++) { 2392 p.writeInt32(p_cur[i].cid); 2393 p.writeInt32(p_cur[i].active); 2394 writeStringToParcel(p, p_cur[i].type); 2395 // apn is not used, so don't send. 2396 writeStringToParcel(p, p_cur[i].address); 2397 appendPrintBuf("%s[cid=%d,%s,%s,%s],", printBuf, 2398 p_cur[i].cid, 2399 (p_cur[i].active==0)?"down":"up", 2400 (char*)p_cur[i].type, 2401 (char*)p_cur[i].address); 2402 } 2403 removeLastChar; 2404 closeResponse; 2405 2406 return 0; 2407 } 2408 2409 static int responseDataCallListV6(Parcel &p, void *response, size_t responselen) 2410 { 2411 if (response == NULL && responselen != 0) { 2412 RLOGE("invalid response: NULL"); 2413 return RIL_ERRNO_INVALID_RESPONSE; 2414 } 2415 2416 if (responselen % sizeof(RIL_Data_Call_Response_v6) != 0) { 2417 RLOGE("responseDataCallListV6: invalid response length %d expected multiple of %d", 2418 (int)responselen, (int)sizeof(RIL_Data_Call_Response_v6)); 2419 return RIL_ERRNO_INVALID_RESPONSE; 2420 } 2421 2422 // Write version 2423 p.writeInt32(6); 2424 2425 int num = responselen / sizeof(RIL_Data_Call_Response_v6); 2426 p.writeInt32(num); 2427 2428 RIL_Data_Call_Response_v6 *p_cur = (RIL_Data_Call_Response_v6 *) response; 2429 startResponse; 2430 int i; 2431 for (i = 0; i < num; i++) { 2432 p.writeInt32((int)p_cur[i].status); 2433 p.writeInt32(p_cur[i].suggestedRetryTime); 2434 p.writeInt32(p_cur[i].cid); 2435 p.writeInt32(p_cur[i].active); 2436 writeStringToParcel(p, p_cur[i].type); 2437 writeStringToParcel(p, p_cur[i].ifname); 2438 writeStringToParcel(p, p_cur[i].addresses); 2439 writeStringToParcel(p, p_cur[i].dnses); 2440 writeStringToParcel(p, p_cur[i].gateways); 2441 appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s],", printBuf, 2442 p_cur[i].status, 2443 p_cur[i].suggestedRetryTime, 2444 p_cur[i].cid, 2445 (p_cur[i].active==0)?"down":"up", 2446 (char*)p_cur[i].type, 2447 (char*)p_cur[i].ifname, 2448 (char*)p_cur[i].addresses, 2449 (char*)p_cur[i].dnses, 2450 (char*)p_cur[i].gateways); 2451 } 2452 removeLastChar; 2453 closeResponse; 2454 2455 return 0; 2456 } 2457 2458 static int responseDataCallListV9(Parcel &p, void *response, size_t responselen) 2459 { 2460 if (response == NULL && responselen != 0) { 2461 RLOGE("invalid response: NULL"); 2462 return RIL_ERRNO_INVALID_RESPONSE; 2463 } 2464 2465 if (responselen % sizeof(RIL_Data_Call_Response_v9) != 0) { 2466 RLOGE("responseDataCallListV9: invalid response length %d expected multiple of %d", 2467 (int)responselen, (int)sizeof(RIL_Data_Call_Response_v9)); 2468 return RIL_ERRNO_INVALID_RESPONSE; 2469 } 2470 2471 // Write version 2472 p.writeInt32(10); 2473 2474 int num = responselen / sizeof(RIL_Data_Call_Response_v9); 2475 p.writeInt32(num); 2476 2477 RIL_Data_Call_Response_v9 *p_cur = (RIL_Data_Call_Response_v9 *) response; 2478 startResponse; 2479 int i; 2480 for (i = 0; i < num; i++) { 2481 p.writeInt32((int)p_cur[i].status); 2482 p.writeInt32(p_cur[i].suggestedRetryTime); 2483 p.writeInt32(p_cur[i].cid); 2484 p.writeInt32(p_cur[i].active); 2485 writeStringToParcel(p, p_cur[i].type); 2486 writeStringToParcel(p, p_cur[i].ifname); 2487 writeStringToParcel(p, p_cur[i].addresses); 2488 writeStringToParcel(p, p_cur[i].dnses); 2489 writeStringToParcel(p, p_cur[i].gateways); 2490 writeStringToParcel(p, p_cur[i].pcscf); 2491 appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s,%s],", printBuf, 2492 p_cur[i].status, 2493 p_cur[i].suggestedRetryTime, 2494 p_cur[i].cid, 2495 (p_cur[i].active==0)?"down":"up", 2496 (char*)p_cur[i].type, 2497 (char*)p_cur[i].ifname, 2498 (char*)p_cur[i].addresses, 2499 (char*)p_cur[i].dnses, 2500 (char*)p_cur[i].gateways, 2501 (char*)p_cur[i].pcscf); 2502 } 2503 removeLastChar; 2504 closeResponse; 2505 2506 return 0; 2507 } 2508 2509 2510 static int responseDataCallList(Parcel &p, void *response, size_t responselen) 2511 { 2512 if (s_callbacks.version < 5) { 2513 RLOGD("responseDataCallList: v4"); 2514 return responseDataCallListV4(p, response, responselen); 2515 } else if (responselen % sizeof(RIL_Data_Call_Response_v6) == 0) { 2516 return responseDataCallListV6(p, response, responselen); 2517 } else if (responselen % sizeof(RIL_Data_Call_Response_v9) == 0) { 2518 return responseDataCallListV9(p, response, responselen); 2519 } else { 2520 if (response == NULL && responselen != 0) { 2521 RLOGE("invalid response: NULL"); 2522 return RIL_ERRNO_INVALID_RESPONSE; 2523 } 2524 2525 if (responselen % sizeof(RIL_Data_Call_Response_v11) != 0) { 2526 RLOGE("invalid response length %d expected multiple of %d", 2527 (int)responselen, (int)sizeof(RIL_Data_Call_Response_v11)); 2528 return RIL_ERRNO_INVALID_RESPONSE; 2529 } 2530 2531 // Write version 2532 p.writeInt32(11); 2533 2534 int num = responselen / sizeof(RIL_Data_Call_Response_v11); 2535 p.writeInt32(num); 2536 2537 RIL_Data_Call_Response_v11 *p_cur = (RIL_Data_Call_Response_v11 *) response; 2538 startResponse; 2539 int i; 2540 for (i = 0; i < num; i++) { 2541 p.writeInt32((int)p_cur[i].status); 2542 p.writeInt32(p_cur[i].suggestedRetryTime); 2543 p.writeInt32(p_cur[i].cid); 2544 p.writeInt32(p_cur[i].active); 2545 writeStringToParcel(p, p_cur[i].type); 2546 writeStringToParcel(p, p_cur[i].ifname); 2547 writeStringToParcel(p, p_cur[i].addresses); 2548 writeStringToParcel(p, p_cur[i].dnses); 2549 writeStringToParcel(p, p_cur[i].gateways); 2550 writeStringToParcel(p, p_cur[i].pcscf); 2551 p.writeInt32(p_cur[i].mtu); 2552 appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s,%s,mtu=%d],", printBuf, 2553 p_cur[i].status, 2554 p_cur[i].suggestedRetryTime, 2555 p_cur[i].cid, 2556 (p_cur[i].active==0)?"down":"up", 2557 (char*)p_cur[i].type, 2558 (char*)p_cur[i].ifname, 2559 (char*)p_cur[i].addresses, 2560 (char*)p_cur[i].dnses, 2561 (char*)p_cur[i].gateways, 2562 (char*)p_cur[i].pcscf, 2563 p_cur[i].mtu); 2564 } 2565 removeLastChar; 2566 closeResponse; 2567 } 2568 2569 return 0; 2570 } 2571 2572 static int responseSetupDataCall(Parcel &p, void *response, size_t responselen) 2573 { 2574 if (s_callbacks.version < 5) { 2575 return responseStringsWithVersion(s_callbacks.version, p, response, responselen); 2576 } else { 2577 return responseDataCallList(p, response, responselen); 2578 } 2579 } 2580 2581 static int responseRaw(Parcel &p, void *response, size_t responselen) { 2582 if (response == NULL && responselen != 0) { 2583 RLOGE("invalid response: NULL with responselen != 0"); 2584 return RIL_ERRNO_INVALID_RESPONSE; 2585 } 2586 2587 // The java code reads -1 size as null byte array 2588 if (response == NULL) { 2589 p.writeInt32(-1); 2590 } else { 2591 p.writeInt32(responselen); 2592 p.write(response, responselen); 2593 } 2594 2595 return 0; 2596 } 2597 2598 2599 static int responseSIM_IO(Parcel &p, void *response, size_t responselen) { 2600 if (response == NULL) { 2601 RLOGE("invalid response: NULL"); 2602 return RIL_ERRNO_INVALID_RESPONSE; 2603 } 2604 2605 if (responselen != sizeof (RIL_SIM_IO_Response) ) { 2606 RLOGE("invalid response length was %d expected %d", 2607 (int)responselen, (int)sizeof (RIL_SIM_IO_Response)); 2608 return RIL_ERRNO_INVALID_RESPONSE; 2609 } 2610 2611 RIL_SIM_IO_Response *p_cur = (RIL_SIM_IO_Response *) response; 2612 p.writeInt32(p_cur->sw1); 2613 p.writeInt32(p_cur->sw2); 2614 writeStringToParcel(p, p_cur->simResponse); 2615 2616 startResponse; 2617 appendPrintBuf("%ssw1=0x%X,sw2=0x%X,%s", printBuf, p_cur->sw1, p_cur->sw2, 2618 (char*)p_cur->simResponse); 2619 closeResponse; 2620 2621 2622 return 0; 2623 } 2624 2625 static int responseCallForwards(Parcel &p, void *response, size_t responselen) { 2626 int num; 2627 2628 if (response == NULL && responselen != 0) { 2629 RLOGE("invalid response: NULL"); 2630 return RIL_ERRNO_INVALID_RESPONSE; 2631 } 2632 2633 if (responselen % sizeof(RIL_CallForwardInfo *) != 0) { 2634 RLOGE("responseCallForwards: invalid response length %d expected multiple of %d", 2635 (int)responselen, (int)sizeof(RIL_CallForwardInfo *)); 2636 return RIL_ERRNO_INVALID_RESPONSE; 2637 } 2638 2639 /* number of call info's */ 2640 num = responselen / sizeof(RIL_CallForwardInfo *); 2641 p.writeInt32(num); 2642 2643 startResponse; 2644 for (int i = 0 ; i < num ; i++) { 2645 RIL_CallForwardInfo *p_cur = ((RIL_CallForwardInfo **) response)[i]; 2646 2647 p.writeInt32(p_cur->status); 2648 p.writeInt32(p_cur->reason); 2649 p.writeInt32(p_cur->serviceClass); 2650 p.writeInt32(p_cur->toa); 2651 writeStringToParcel(p, p_cur->number); 2652 p.writeInt32(p_cur->timeSeconds); 2653 appendPrintBuf("%s[%s,reason=%d,cls=%d,toa=%d,%s,tout=%d],", printBuf, 2654 (p_cur->status==1)?"enable":"disable", 2655 p_cur->reason, p_cur->serviceClass, p_cur->toa, 2656 (char*)p_cur->number, 2657 p_cur->timeSeconds); 2658 } 2659 removeLastChar; 2660 closeResponse; 2661 2662 return 0; 2663 } 2664 2665 static int responseSsn(Parcel &p, void *response, size_t responselen) { 2666 if (response == NULL) { 2667 RLOGE("invalid response: NULL"); 2668 return RIL_ERRNO_INVALID_RESPONSE; 2669 } 2670 2671 if (responselen != sizeof(RIL_SuppSvcNotification)) { 2672 RLOGE("invalid response length was %d expected %d", 2673 (int)responselen, (int)sizeof (RIL_SuppSvcNotification)); 2674 return RIL_ERRNO_INVALID_RESPONSE; 2675 } 2676 2677 RIL_SuppSvcNotification *p_cur = (RIL_SuppSvcNotification *) response; 2678 p.writeInt32(p_cur->notificationType); 2679 p.writeInt32(p_cur->code); 2680 p.writeInt32(p_cur->index); 2681 p.writeInt32(p_cur->type); 2682 writeStringToParcel(p, p_cur->number); 2683 2684 startResponse; 2685 appendPrintBuf("%s%s,code=%d,id=%d,type=%d,%s", printBuf, 2686 (p_cur->notificationType==0)?"mo":"mt", 2687 p_cur->code, p_cur->index, p_cur->type, 2688 (char*)p_cur->number); 2689 closeResponse; 2690 2691 return 0; 2692 } 2693 2694 static int responseCellList(Parcel &p, void *response, size_t responselen) { 2695 int num; 2696 2697 if (response == NULL && responselen != 0) { 2698 RLOGE("invalid response: NULL"); 2699 return RIL_ERRNO_INVALID_RESPONSE; 2700 } 2701 2702 if (responselen % sizeof (RIL_NeighboringCell *) != 0) { 2703 RLOGE("responseCellList: invalid response length %d expected multiple of %d\n", 2704 (int)responselen, (int)sizeof (RIL_NeighboringCell *)); 2705 return RIL_ERRNO_INVALID_RESPONSE; 2706 } 2707 2708 startResponse; 2709 /* number of records */ 2710 num = responselen / sizeof(RIL_NeighboringCell *); 2711 p.writeInt32(num); 2712 2713 for (int i = 0 ; i < num ; i++) { 2714 RIL_NeighboringCell *p_cur = ((RIL_NeighboringCell **) response)[i]; 2715 2716 p.writeInt32(p_cur->rssi); 2717 writeStringToParcel (p, p_cur->cid); 2718 2719 appendPrintBuf("%s[cid=%s,rssi=%d],", printBuf, 2720 p_cur->cid, p_cur->rssi); 2721 } 2722 removeLastChar; 2723 closeResponse; 2724 2725 return 0; 2726 } 2727 2728 /** 2729 * Marshall the signalInfoRecord into the parcel if it exists. 2730 */ 2731 static void marshallSignalInfoRecord(Parcel &p, 2732 RIL_CDMA_SignalInfoRecord &p_signalInfoRecord) { 2733 p.writeInt32(p_signalInfoRecord.isPresent); 2734 p.writeInt32(p_signalInfoRecord.signalType); 2735 p.writeInt32(p_signalInfoRecord.alertPitch); 2736 p.writeInt32(p_signalInfoRecord.signal); 2737 } 2738 2739 static int responseCdmaInformationRecords(Parcel &p, 2740 void *response, size_t responselen) { 2741 int num; 2742 char* string8 = NULL; 2743 int buffer_lenght; 2744 RIL_CDMA_InformationRecord *infoRec; 2745 2746 if (response == NULL && responselen != 0) { 2747 RLOGE("invalid response: NULL"); 2748 return RIL_ERRNO_INVALID_RESPONSE; 2749 } 2750 2751 if (responselen != sizeof (RIL_CDMA_InformationRecords)) { 2752 RLOGE("responseCdmaInformationRecords: invalid response length %d expected multiple of %d\n", 2753 (int)responselen, (int)sizeof (RIL_CDMA_InformationRecords *)); 2754 return RIL_ERRNO_INVALID_RESPONSE; 2755 } 2756 2757 RIL_CDMA_InformationRecords *p_cur = 2758 (RIL_CDMA_InformationRecords *) response; 2759 num = MIN(p_cur->numberOfInfoRecs, RIL_CDMA_MAX_NUMBER_OF_INFO_RECS); 2760 2761 startResponse; 2762 p.writeInt32(num); 2763 2764 for (int i = 0 ; i < num ; i++) { 2765 infoRec = &p_cur->infoRec[i]; 2766 p.writeInt32(infoRec->name); 2767 switch (infoRec->name) { 2768 case RIL_CDMA_DISPLAY_INFO_REC: 2769 case RIL_CDMA_EXTENDED_DISPLAY_INFO_REC: 2770 if (infoRec->rec.display.alpha_len > 2771 CDMA_ALPHA_INFO_BUFFER_LENGTH) { 2772 RLOGE("invalid display info response length %d \ 2773 expected not more than %d\n", 2774 (int)infoRec->rec.display.alpha_len, 2775 CDMA_ALPHA_INFO_BUFFER_LENGTH); 2776 return RIL_ERRNO_INVALID_RESPONSE; 2777 } 2778 string8 = (char*) malloc((infoRec->rec.display.alpha_len + 1) 2779 * sizeof(char) ); 2780 for (int i = 0 ; i < infoRec->rec.display.alpha_len ; i++) { 2781 string8[i] = infoRec->rec.display.alpha_buf[i]; 2782 } 2783 string8[(int)infoRec->rec.display.alpha_len] = '\0'; 2784 writeStringToParcel(p, (const char*)string8); 2785 free(string8); 2786 string8 = NULL; 2787 break; 2788 case RIL_CDMA_CALLED_PARTY_NUMBER_INFO_REC: 2789 case RIL_CDMA_CALLING_PARTY_NUMBER_INFO_REC: 2790 case RIL_CDMA_CONNECTED_NUMBER_INFO_REC: 2791 if (infoRec->rec.number.len > CDMA_NUMBER_INFO_BUFFER_LENGTH) { 2792 RLOGE("invalid display info response length %d \ 2793 expected not more than %d\n", 2794 (int)infoRec->rec.number.len, 2795 CDMA_NUMBER_INFO_BUFFER_LENGTH); 2796 return RIL_ERRNO_INVALID_RESPONSE; 2797 } 2798 string8 = (char*) malloc((infoRec->rec.number.len + 1) 2799 * sizeof(char) ); 2800 for (int i = 0 ; i < infoRec->rec.number.len; i++) { 2801 string8[i] = infoRec->rec.number.buf[i]; 2802 } 2803 string8[(int)infoRec->rec.number.len] = '\0'; 2804 writeStringToParcel(p, (const char*)string8); 2805 free(string8); 2806 string8 = NULL; 2807 p.writeInt32(infoRec->rec.number.number_type); 2808 p.writeInt32(infoRec->rec.number.number_plan); 2809 p.writeInt32(infoRec->rec.number.pi); 2810 p.writeInt32(infoRec->rec.number.si); 2811 break; 2812 case RIL_CDMA_SIGNAL_INFO_REC: 2813 p.writeInt32(infoRec->rec.signal.isPresent); 2814 p.writeInt32(infoRec->rec.signal.signalType); 2815 p.writeInt32(infoRec->rec.signal.alertPitch); 2816 p.writeInt32(infoRec->rec.signal.signal); 2817 2818 appendPrintBuf("%sisPresent=%X, signalType=%X, \ 2819 alertPitch=%X, signal=%X, ", 2820 printBuf, (int)infoRec->rec.signal.isPresent, 2821 (int)infoRec->rec.signal.signalType, 2822 (int)infoRec->rec.signal.alertPitch, 2823 (int)infoRec->rec.signal.signal); 2824 removeLastChar; 2825 break; 2826 case RIL_CDMA_REDIRECTING_NUMBER_INFO_REC: 2827 if (infoRec->rec.redir.redirectingNumber.len > 2828 CDMA_NUMBER_INFO_BUFFER_LENGTH) { 2829 RLOGE("invalid display info response length %d \ 2830 expected not more than %d\n", 2831 (int)infoRec->rec.redir.redirectingNumber.len, 2832 CDMA_NUMBER_INFO_BUFFER_LENGTH); 2833 return RIL_ERRNO_INVALID_RESPONSE; 2834 } 2835 string8 = (char*) malloc((infoRec->rec.redir.redirectingNumber 2836 .len + 1) * sizeof(char) ); 2837 for (int i = 0; 2838 i < infoRec->rec.redir.redirectingNumber.len; 2839 i++) { 2840 string8[i] = infoRec->rec.redir.redirectingNumber.buf[i]; 2841 } 2842 string8[(int)infoRec->rec.redir.redirectingNumber.len] = '\0'; 2843 writeStringToParcel(p, (const char*)string8); 2844 free(string8); 2845 string8 = NULL; 2846 p.writeInt32(infoRec->rec.redir.redirectingNumber.number_type); 2847 p.writeInt32(infoRec->rec.redir.redirectingNumber.number_plan); 2848 p.writeInt32(infoRec->rec.redir.redirectingNumber.pi); 2849 p.writeInt32(infoRec->rec.redir.redirectingNumber.si); 2850 p.writeInt32(infoRec->rec.redir.redirectingReason); 2851 break; 2852 case RIL_CDMA_LINE_CONTROL_INFO_REC: 2853 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlPolarityIncluded); 2854 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlToggle); 2855 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlReverse); 2856 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlPowerDenial); 2857 2858 appendPrintBuf("%slineCtrlPolarityIncluded=%d, \ 2859 lineCtrlToggle=%d, lineCtrlReverse=%d, \ 2860 lineCtrlPowerDenial=%d, ", printBuf, 2861 (int)infoRec->rec.lineCtrl.lineCtrlPolarityIncluded, 2862 (int)infoRec->rec.lineCtrl.lineCtrlToggle, 2863 (int)infoRec->rec.lineCtrl.lineCtrlReverse, 2864 (int)infoRec->rec.lineCtrl.lineCtrlPowerDenial); 2865 removeLastChar; 2866 break; 2867 case RIL_CDMA_T53_CLIR_INFO_REC: 2868 p.writeInt32((int)(infoRec->rec.clir.cause)); 2869 2870 appendPrintBuf("%scause%d", printBuf, infoRec->rec.clir.cause); 2871 removeLastChar; 2872 break; 2873 case RIL_CDMA_T53_AUDIO_CONTROL_INFO_REC: 2874 p.writeInt32(infoRec->rec.audioCtrl.upLink); 2875 p.writeInt32(infoRec->rec.audioCtrl.downLink); 2876 2877 appendPrintBuf("%supLink=%d, downLink=%d, ", printBuf, 2878 infoRec->rec.audioCtrl.upLink, 2879 infoRec->rec.audioCtrl.downLink); 2880 removeLastChar; 2881 break; 2882 case RIL_CDMA_T53_RELEASE_INFO_REC: 2883 // TODO(Moto): See David Krause, he has the answer:) 2884 RLOGE("RIL_CDMA_T53_RELEASE_INFO_REC: return INVALID_RESPONSE"); 2885 return RIL_ERRNO_INVALID_RESPONSE; 2886 default: 2887 RLOGE("Incorrect name value"); 2888 return RIL_ERRNO_INVALID_RESPONSE; 2889 } 2890 } 2891 closeResponse; 2892 2893 return 0; 2894 } 2895 2896 static int responseRilSignalStrength(Parcel &p, 2897 void *response, size_t responselen) { 2898 if (response == NULL && responselen != 0) { 2899 RLOGE("invalid response: NULL"); 2900 return RIL_ERRNO_INVALID_RESPONSE; 2901 } 2902 2903 if (responselen >= sizeof (RIL_SignalStrength_v5)) { 2904 RIL_SignalStrength_v10 *p_cur = ((RIL_SignalStrength_v10 *) response); 2905 2906 p.writeInt32(p_cur->GW_SignalStrength.signalStrength); 2907 p.writeInt32(p_cur->GW_SignalStrength.bitErrorRate); 2908 p.writeInt32(p_cur->CDMA_SignalStrength.dbm); 2909 p.writeInt32(p_cur->CDMA_SignalStrength.ecio); 2910 p.writeInt32(p_cur->EVDO_SignalStrength.dbm); 2911 p.writeInt32(p_cur->EVDO_SignalStrength.ecio); 2912 p.writeInt32(p_cur->EVDO_SignalStrength.signalNoiseRatio); 2913 if (responselen >= sizeof (RIL_SignalStrength_v6)) { 2914 /* 2915 * Fixup LTE for backwards compatibility 2916 */ 2917 if (s_callbacks.version <= 6) { 2918 // signalStrength: -1 -> 99 2919 if (p_cur->LTE_SignalStrength.signalStrength == -1) { 2920 p_cur->LTE_SignalStrength.signalStrength = 99; 2921 } 2922 // rsrp: -1 -> INT_MAX all other negative value to positive. 2923 // So remap here 2924 if (p_cur->LTE_SignalStrength.rsrp == -1) { 2925 p_cur->LTE_SignalStrength.rsrp = INT_MAX; 2926 } else if (p_cur->LTE_SignalStrength.rsrp < -1) { 2927 p_cur->LTE_SignalStrength.rsrp = -p_cur->LTE_SignalStrength.rsrp; 2928 } 2929 // rsrq: -1 -> INT_MAX 2930 if (p_cur->LTE_SignalStrength.rsrq == -1) { 2931 p_cur->LTE_SignalStrength.rsrq = INT_MAX; 2932 } 2933 // Not remapping rssnr is already using INT_MAX 2934 2935 // cqi: -1 -> INT_MAX 2936 if (p_cur->LTE_SignalStrength.cqi == -1) { 2937 p_cur->LTE_SignalStrength.cqi = INT_MAX; 2938 } 2939 } 2940 p.writeInt32(p_cur->LTE_SignalStrength.signalStrength); 2941 p.writeInt32(p_cur->LTE_SignalStrength.rsrp); 2942 p.writeInt32(p_cur->LTE_SignalStrength.rsrq); 2943 p.writeInt32(p_cur->LTE_SignalStrength.rssnr); 2944 p.writeInt32(p_cur->LTE_SignalStrength.cqi); 2945 if (responselen >= sizeof (RIL_SignalStrength_v10)) { 2946 p.writeInt32(p_cur->TD_SCDMA_SignalStrength.rscp); 2947 } else { 2948 p.writeInt32(INT_MAX); 2949 } 2950 } else { 2951 p.writeInt32(99); 2952 p.writeInt32(INT_MAX); 2953 p.writeInt32(INT_MAX); 2954 p.writeInt32(INT_MAX); 2955 p.writeInt32(INT_MAX); 2956 p.writeInt32(INT_MAX); 2957 } 2958 2959 startResponse; 2960 appendPrintBuf("%s[signalStrength=%d,bitErrorRate=%d,\ 2961 CDMA_SS.dbm=%d,CDMA_SSecio=%d,\ 2962 EVDO_SS.dbm=%d,EVDO_SS.ecio=%d,\ 2963 EVDO_SS.signalNoiseRatio=%d,\ 2964 LTE_SS.signalStrength=%d,LTE_SS.rsrp=%d,LTE_SS.rsrq=%d,\ 2965 LTE_SS.rssnr=%d,LTE_SS.cqi=%d,TDSCDMA_SS.rscp=%d]", 2966 printBuf, 2967 p_cur->GW_SignalStrength.signalStrength, 2968 p_cur->GW_SignalStrength.bitErrorRate, 2969 p_cur->CDMA_SignalStrength.dbm, 2970 p_cur->CDMA_SignalStrength.ecio, 2971 p_cur->EVDO_SignalStrength.dbm, 2972 p_cur->EVDO_SignalStrength.ecio, 2973 p_cur->EVDO_SignalStrength.signalNoiseRatio, 2974 p_cur->LTE_SignalStrength.signalStrength, 2975 p_cur->LTE_SignalStrength.rsrp, 2976 p_cur->LTE_SignalStrength.rsrq, 2977 p_cur->LTE_SignalStrength.rssnr, 2978 p_cur->LTE_SignalStrength.cqi, 2979 p_cur->TD_SCDMA_SignalStrength.rscp); 2980 closeResponse; 2981 2982 } else { 2983 RLOGE("invalid response length"); 2984 return RIL_ERRNO_INVALID_RESPONSE; 2985 } 2986 2987 return 0; 2988 } 2989 2990 static int responseCallRing(Parcel &p, void *response, size_t responselen) { 2991 if ((response == NULL) || (responselen == 0)) { 2992 return responseVoid(p, response, responselen); 2993 } else { 2994 return responseCdmaSignalInfoRecord(p, response, responselen); 2995 } 2996 } 2997 2998 static int responseCdmaSignalInfoRecord(Parcel &p, void *response, size_t responselen) { 2999 if (response == NULL || responselen == 0) { 3000 RLOGE("invalid response: NULL"); 3001 return RIL_ERRNO_INVALID_RESPONSE; 3002 } 3003 3004 if (responselen != sizeof (RIL_CDMA_SignalInfoRecord)) { 3005 RLOGE("invalid response length %d expected sizeof (RIL_CDMA_SignalInfoRecord) of %d\n", 3006 (int)responselen, (int)sizeof (RIL_CDMA_SignalInfoRecord)); 3007 return RIL_ERRNO_INVALID_RESPONSE; 3008 } 3009 3010 startResponse; 3011 3012 RIL_CDMA_SignalInfoRecord *p_cur = ((RIL_CDMA_SignalInfoRecord *) response); 3013 marshallSignalInfoRecord(p, *p_cur); 3014 3015 appendPrintBuf("%s[isPresent=%d,signalType=%d,alertPitch=%d\ 3016 signal=%d]", 3017 printBuf, 3018 p_cur->isPresent, 3019 p_cur->signalType, 3020 p_cur->alertPitch, 3021 p_cur->signal); 3022 3023 closeResponse; 3024 return 0; 3025 } 3026 3027 static int responseCdmaCallWaiting(Parcel &p, void *response, 3028 size_t responselen) { 3029 if (response == NULL && responselen != 0) { 3030 RLOGE("invalid response: NULL"); 3031 return RIL_ERRNO_INVALID_RESPONSE; 3032 } 3033 3034 if (responselen < sizeof(RIL_CDMA_CallWaiting_v6)) { 3035 RLOGW("Upgrade to ril version %d\n", RIL_VERSION); 3036 } 3037 3038 RIL_CDMA_CallWaiting_v6 *p_cur = ((RIL_CDMA_CallWaiting_v6 *) response); 3039 3040 writeStringToParcel(p, p_cur->number); 3041 p.writeInt32(p_cur->numberPresentation); 3042 writeStringToParcel(p, p_cur->name); 3043 marshallSignalInfoRecord(p, p_cur->signalInfoRecord); 3044 3045 if (responselen >= sizeof(RIL_CDMA_CallWaiting_v6)) { 3046 p.writeInt32(p_cur->number_type); 3047 p.writeInt32(p_cur->number_plan); 3048 } else { 3049 p.writeInt32(0); 3050 p.writeInt32(0); 3051 } 3052 3053 startResponse; 3054 appendPrintBuf("%snumber=%s,numberPresentation=%d, name=%s,\ 3055 signalInfoRecord[isPresent=%d,signalType=%d,alertPitch=%d\ 3056 signal=%d,number_type=%d,number_plan=%d]", 3057 printBuf, 3058 p_cur->number, 3059 p_cur->numberPresentation, 3060 p_cur->name, 3061 p_cur->signalInfoRecord.isPresent, 3062 p_cur->signalInfoRecord.signalType, 3063 p_cur->signalInfoRecord.alertPitch, 3064 p_cur->signalInfoRecord.signal, 3065 p_cur->number_type, 3066 p_cur->number_plan); 3067 closeResponse; 3068 3069 return 0; 3070 } 3071 3072 static int responseSimRefresh(Parcel &p, void *response, size_t responselen) { 3073 if (response == NULL && responselen != 0) { 3074 RLOGE("responseSimRefresh: invalid response: NULL"); 3075 return RIL_ERRNO_INVALID_RESPONSE; 3076 } 3077 3078 startResponse; 3079 if (s_callbacks.version == 7) { 3080 RIL_SimRefreshResponse_v7 *p_cur = ((RIL_SimRefreshResponse_v7 *) response); 3081 p.writeInt32(p_cur->result); 3082 p.writeInt32(p_cur->ef_id); 3083 writeStringToParcel(p, p_cur->aid); 3084 3085 appendPrintBuf("%sresult=%d, ef_id=%d, aid=%s", 3086 printBuf, 3087 p_cur->result, 3088 p_cur->ef_id, 3089 p_cur->aid); 3090 } else { 3091 int *p_cur = ((int *) response); 3092 p.writeInt32(p_cur[0]); 3093 p.writeInt32(p_cur[1]); 3094 writeStringToParcel(p, NULL); 3095 3096 appendPrintBuf("%sresult=%d, ef_id=%d", 3097 printBuf, 3098 p_cur[0], 3099 p_cur[1]); 3100 } 3101 closeResponse; 3102 3103 return 0; 3104 } 3105 3106 static int responseCellInfoList(Parcel &p, void *response, size_t responselen) 3107 { 3108 if (response == NULL && responselen != 0) { 3109 RLOGE("invalid response: NULL"); 3110 return RIL_ERRNO_INVALID_RESPONSE; 3111 } 3112 3113 if (responselen % sizeof(RIL_CellInfo) != 0) { 3114 RLOGE("responseCellInfoList: invalid response length %d expected multiple of %d", 3115 (int)responselen, (int)sizeof(RIL_CellInfo)); 3116 return RIL_ERRNO_INVALID_RESPONSE; 3117 } 3118 3119 int num = responselen / sizeof(RIL_CellInfo); 3120 p.writeInt32(num); 3121 3122 RIL_CellInfo *p_cur = (RIL_CellInfo *) response; 3123 startResponse; 3124 int i; 3125 for (i = 0; i < num; i++) { 3126 appendPrintBuf("%s[%d: type=%d,registered=%d,timeStampType=%d,timeStamp=%lld", printBuf, i, 3127 p_cur->cellInfoType, p_cur->registered, p_cur->timeStampType, p_cur->timeStamp); 3128 p.writeInt32((int)p_cur->cellInfoType); 3129 p.writeInt32(p_cur->registered); 3130 p.writeInt32(p_cur->timeStampType); 3131 p.writeInt64(p_cur->timeStamp); 3132 switch(p_cur->cellInfoType) { 3133 case RIL_CELL_INFO_TYPE_GSM: { 3134 appendPrintBuf("%s GSM id: mcc=%d,mnc=%d,lac=%d,cid=%d,", printBuf, 3135 p_cur->CellInfo.gsm.cellIdentityGsm.mcc, 3136 p_cur->CellInfo.gsm.cellIdentityGsm.mnc, 3137 p_cur->CellInfo.gsm.cellIdentityGsm.lac, 3138 p_cur->CellInfo.gsm.cellIdentityGsm.cid); 3139 appendPrintBuf("%s gsmSS: ss=%d,ber=%d],", printBuf, 3140 p_cur->CellInfo.gsm.signalStrengthGsm.signalStrength, 3141 p_cur->CellInfo.gsm.signalStrengthGsm.bitErrorRate); 3142 3143 p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.mcc); 3144 p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.mnc); 3145 p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.lac); 3146 p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.cid); 3147 p.writeInt32(p_cur->CellInfo.gsm.signalStrengthGsm.signalStrength); 3148 p.writeInt32(p_cur->CellInfo.gsm.signalStrengthGsm.bitErrorRate); 3149 break; 3150 } 3151 case RIL_CELL_INFO_TYPE_WCDMA: { 3152 appendPrintBuf("%s WCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,psc=%d,", printBuf, 3153 p_cur->CellInfo.wcdma.cellIdentityWcdma.mcc, 3154 p_cur->CellInfo.wcdma.cellIdentityWcdma.mnc, 3155 p_cur->CellInfo.wcdma.cellIdentityWcdma.lac, 3156 p_cur->CellInfo.wcdma.cellIdentityWcdma.cid, 3157 p_cur->CellInfo.wcdma.cellIdentityWcdma.psc); 3158 appendPrintBuf("%s wcdmaSS: ss=%d,ber=%d],", printBuf, 3159 p_cur->CellInfo.wcdma.signalStrengthWcdma.signalStrength, 3160 p_cur->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate); 3161 3162 p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.mcc); 3163 p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.mnc); 3164 p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.lac); 3165 p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.cid); 3166 p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.psc); 3167 p.writeInt32(p_cur->CellInfo.wcdma.signalStrengthWcdma.signalStrength); 3168 p.writeInt32(p_cur->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate); 3169 break; 3170 } 3171 case RIL_CELL_INFO_TYPE_CDMA: { 3172 appendPrintBuf("%s CDMA id: nId=%d,sId=%d,bsId=%d,long=%d,lat=%d", printBuf, 3173 p_cur->CellInfo.cdma.cellIdentityCdma.networkId, 3174 p_cur->CellInfo.cdma.cellIdentityCdma.systemId, 3175 p_cur->CellInfo.cdma.cellIdentityCdma.basestationId, 3176 p_cur->CellInfo.cdma.cellIdentityCdma.longitude, 3177 p_cur->CellInfo.cdma.cellIdentityCdma.latitude); 3178 3179 p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.networkId); 3180 p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.systemId); 3181 p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.basestationId); 3182 p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.longitude); 3183 p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.latitude); 3184 3185 appendPrintBuf("%s cdmaSS: dbm=%d ecio=%d evdoSS: dbm=%d,ecio=%d,snr=%d", printBuf, 3186 p_cur->CellInfo.cdma.signalStrengthCdma.dbm, 3187 p_cur->CellInfo.cdma.signalStrengthCdma.ecio, 3188 p_cur->CellInfo.cdma.signalStrengthEvdo.dbm, 3189 p_cur->CellInfo.cdma.signalStrengthEvdo.ecio, 3190 p_cur->CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio); 3191 3192 p.writeInt32(p_cur->CellInfo.cdma.signalStrengthCdma.dbm); 3193 p.writeInt32(p_cur->CellInfo.cdma.signalStrengthCdma.ecio); 3194 p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.dbm); 3195 p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.ecio); 3196 p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio); 3197 break; 3198 } 3199 case RIL_CELL_INFO_TYPE_LTE: { 3200 appendPrintBuf("%s LTE id: mcc=%d,mnc=%d,ci=%d,pci=%d,tac=%d", printBuf, 3201 p_cur->CellInfo.lte.cellIdentityLte.mcc, 3202 p_cur->CellInfo.lte.cellIdentityLte.mnc, 3203 p_cur->CellInfo.lte.cellIdentityLte.ci, 3204 p_cur->CellInfo.lte.cellIdentityLte.pci, 3205 p_cur->CellInfo.lte.cellIdentityLte.tac); 3206 3207 p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.mcc); 3208 p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.mnc); 3209 p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.ci); 3210 p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.pci); 3211 p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.tac); 3212 3213 appendPrintBuf("%s lteSS: ss=%d,rsrp=%d,rsrq=%d,rssnr=%d,cqi=%d,ta=%d", printBuf, 3214 p_cur->CellInfo.lte.signalStrengthLte.signalStrength, 3215 p_cur->CellInfo.lte.signalStrengthLte.rsrp, 3216 p_cur->CellInfo.lte.signalStrengthLte.rsrq, 3217 p_cur->CellInfo.lte.signalStrengthLte.rssnr, 3218 p_cur->CellInfo.lte.signalStrengthLte.cqi, 3219 p_cur->CellInfo.lte.signalStrengthLte.timingAdvance); 3220 p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.signalStrength); 3221 p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rsrp); 3222 p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rsrq); 3223 p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rssnr); 3224 p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.cqi); 3225 p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.timingAdvance); 3226 break; 3227 } 3228 case RIL_CELL_INFO_TYPE_TD_SCDMA: { 3229 appendPrintBuf("%s TDSCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,cpid=%d,", printBuf, 3230 p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc, 3231 p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc, 3232 p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac, 3233 p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cid, 3234 p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cpid); 3235 appendPrintBuf("%s tdscdmaSS: rscp=%d],", printBuf, 3236 p_cur->CellInfo.tdscdma.signalStrengthTdscdma.rscp); 3237 3238 p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc); 3239 p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc); 3240 p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac); 3241 p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cid); 3242 p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cpid); 3243 p.writeInt32(p_cur->CellInfo.tdscdma.signalStrengthTdscdma.rscp); 3244 break; 3245 } 3246 } 3247 p_cur += 1; 3248 } 3249 removeLastChar; 3250 closeResponse; 3251 3252 return 0; 3253 } 3254 3255 static int responseHardwareConfig(Parcel &p, void *response, size_t responselen) 3256 { 3257 if (response == NULL && responselen != 0) { 3258 RLOGE("invalid response: NULL"); 3259 return RIL_ERRNO_INVALID_RESPONSE; 3260 } 3261 3262 if (responselen % sizeof(RIL_HardwareConfig) != 0) { 3263 RLOGE("responseHardwareConfig: invalid response length %d expected multiple of %d", 3264 (int)responselen, (int)sizeof(RIL_HardwareConfig)); 3265 return RIL_ERRNO_INVALID_RESPONSE; 3266 } 3267 3268 int num = responselen / sizeof(RIL_HardwareConfig); 3269 int i; 3270 RIL_HardwareConfig *p_cur = (RIL_HardwareConfig *) response; 3271 3272 p.writeInt32(num); 3273 3274 startResponse; 3275 for (i = 0; i < num; i++) { 3276 switch (p_cur[i].type) { 3277 case RIL_HARDWARE_CONFIG_MODEM: { 3278 writeStringToParcel(p, p_cur[i].uuid); 3279 p.writeInt32((int)p_cur[i].state); 3280 p.writeInt32(p_cur[i].cfg.modem.rat); 3281 p.writeInt32(p_cur[i].cfg.modem.maxVoice); 3282 p.writeInt32(p_cur[i].cfg.modem.maxData); 3283 p.writeInt32(p_cur[i].cfg.modem.maxStandby); 3284 3285 appendPrintBuf("%s modem: uuid=%s,state=%d,rat=%08x,maxV=%d,maxD=%d,maxS=%d", printBuf, 3286 p_cur[i].uuid, (int)p_cur[i].state, p_cur[i].cfg.modem.rat, 3287 p_cur[i].cfg.modem.maxVoice, p_cur[i].cfg.modem.maxData, p_cur[i].cfg.modem.maxStandby); 3288 break; 3289 } 3290 case RIL_HARDWARE_CONFIG_SIM: { 3291 writeStringToParcel(p, p_cur[i].uuid); 3292 p.writeInt32((int)p_cur[i].state); 3293 writeStringToParcel(p, p_cur[i].cfg.sim.modemUuid); 3294 3295 appendPrintBuf("%s sim: uuid=%s,state=%d,modem-uuid=%s", printBuf, 3296 p_cur[i].uuid, (int)p_cur[i].state, p_cur[i].cfg.sim.modemUuid); 3297 break; 3298 } 3299 } 3300 } 3301 removeLastChar; 3302 closeResponse; 3303 return 0; 3304 } 3305 3306 static int responseRadioCapability(Parcel &p, void *response, size_t responselen) { 3307 if (response == NULL) { 3308 RLOGE("invalid response: NULL"); 3309 return RIL_ERRNO_INVALID_RESPONSE; 3310 } 3311 3312 if (responselen != sizeof (RIL_RadioCapability) ) { 3313 RLOGE("invalid response length was %d expected %d", 3314 (int)responselen, (int)sizeof (RIL_SIM_IO_Response)); 3315 return RIL_ERRNO_INVALID_RESPONSE; 3316 } 3317 3318 RIL_RadioCapability *p_cur = (RIL_RadioCapability *) response; 3319 p.writeInt32(p_cur->version); 3320 p.writeInt32(p_cur->session); 3321 p.writeInt32(p_cur->phase); 3322 p.writeInt32(p_cur->rat); 3323 writeStringToParcel(p, p_cur->logicalModemUuid); 3324 p.writeInt32(p_cur->status); 3325 3326 startResponse; 3327 appendPrintBuf("%s[version=%d,session=%d,phase=%d,\ 3328 rat=%s,logicalModemUuid=%s,status=%d]", 3329 printBuf, 3330 p_cur->version, 3331 p_cur->session, 3332 p_cur->phase, 3333 p_cur->rat, 3334 p_cur->logicalModemUuid, 3335 p_cur->status); 3336 closeResponse; 3337 return 0; 3338 } 3339 3340 static int responseSSData(Parcel &p, void *response, size_t responselen) { 3341 RLOGD("In responseSSData"); 3342 int num; 3343 3344 if (response == NULL && responselen != 0) { 3345 RLOGE("invalid response length was %d expected %d", 3346 (int)responselen, (int)sizeof (RIL_SIM_IO_Response)); 3347 return RIL_ERRNO_INVALID_RESPONSE; 3348 } 3349 3350 if (responselen != sizeof(RIL_StkCcUnsolSsResponse)) { 3351 RLOGE("invalid response length %d, expected %d", 3352 (int)responselen, (int)sizeof(RIL_StkCcUnsolSsResponse)); 3353 return RIL_ERRNO_INVALID_RESPONSE; 3354 } 3355 3356 startResponse; 3357 RIL_StkCcUnsolSsResponse *p_cur = (RIL_StkCcUnsolSsResponse *) response; 3358 p.writeInt32(p_cur->serviceType); 3359 p.writeInt32(p_cur->requestType); 3360 p.writeInt32(p_cur->teleserviceType); 3361 p.writeInt32(p_cur->serviceClass); 3362 p.writeInt32(p_cur->result); 3363 3364 if (isServiceTypeCfQuery(p_cur->serviceType, p_cur->requestType)) { 3365 RLOGD("responseSSData CF type, num of Cf elements %d", p_cur->cfData.numValidIndexes); 3366 if (p_cur->cfData.numValidIndexes > NUM_SERVICE_CLASSES) { 3367 RLOGE("numValidIndexes is greater than max value %d, " 3368 "truncating it to max value", NUM_SERVICE_CLASSES); 3369 p_cur->cfData.numValidIndexes = NUM_SERVICE_CLASSES; 3370 } 3371 /* number of call info's */ 3372 p.writeInt32(p_cur->cfData.numValidIndexes); 3373 3374 for (int i = 0; i < p_cur->cfData.numValidIndexes; i++) { 3375 RIL_CallForwardInfo cf = p_cur->cfData.cfInfo[i]; 3376 3377 p.writeInt32(cf.status); 3378 p.writeInt32(cf.reason); 3379 p.writeInt32(cf.serviceClass); 3380 p.writeInt32(cf.toa); 3381 writeStringToParcel(p, cf.number); 3382 p.writeInt32(cf.timeSeconds); 3383 appendPrintBuf("%s[%s,reason=%d,cls=%d,toa=%d,%s,tout=%d],", printBuf, 3384 (cf.status==1)?"enable":"disable", cf.reason, cf.serviceClass, cf.toa, 3385 (char*)cf.number, cf.timeSeconds); 3386 RLOGD("Data: %d,reason=%d,cls=%d,toa=%d,num=%s,tout=%d],", cf.status, 3387 cf.reason, cf.serviceClass, cf.toa, (char*)cf.number, cf.timeSeconds); 3388 } 3389 } else { 3390 p.writeInt32 (SS_INFO_MAX); 3391 3392 /* each int*/ 3393 for (int i = 0; i < SS_INFO_MAX; i++) { 3394 appendPrintBuf("%s%d,", printBuf, p_cur->ssInfo[i]); 3395 RLOGD("Data: %d",p_cur->ssInfo[i]); 3396 p.writeInt32(p_cur->ssInfo[i]); 3397 } 3398 } 3399 removeLastChar; 3400 closeResponse; 3401 3402 return 0; 3403 } 3404 3405 static bool isServiceTypeCfQuery(RIL_SsServiceType serType, RIL_SsRequestType reqType) { 3406 if ((reqType == SS_INTERROGATION) && 3407 (serType == SS_CFU || 3408 serType == SS_CF_BUSY || 3409 serType == SS_CF_NO_REPLY || 3410 serType == SS_CF_NOT_REACHABLE || 3411 serType == SS_CF_ALL || 3412 serType == SS_CF_ALL_CONDITIONAL)) { 3413 return true; 3414 } 3415 return false; 3416 } 3417 3418 static void triggerEvLoop() { 3419 int ret; 3420 if (!pthread_equal(pthread_self(), s_tid_dispatch)) { 3421 /* trigger event loop to wakeup. No reason to do this, 3422 * if we're in the event loop thread */ 3423 do { 3424 ret = write (s_fdWakeupWrite, " ", 1); 3425 } while (ret < 0 && errno == EINTR); 3426 } 3427 } 3428 3429 static void rilEventAddWakeup(struct ril_event *ev) { 3430 ril_event_add(ev); 3431 triggerEvLoop(); 3432 } 3433 3434 static void sendSimStatusAppInfo(Parcel &p, int num_apps, RIL_AppStatus appStatus[]) { 3435 p.writeInt32(num_apps); 3436 startResponse; 3437 for (int i = 0; i < num_apps; i++) { 3438 p.writeInt32(appStatus[i].app_type); 3439 p.writeInt32(appStatus[i].app_state); 3440 p.writeInt32(appStatus[i].perso_substate); 3441 writeStringToParcel(p, (const char*)(appStatus[i].aid_ptr)); 3442 writeStringToParcel(p, (const char*) 3443 (appStatus[i].app_label_ptr)); 3444 p.writeInt32(appStatus[i].pin1_replaced); 3445 p.writeInt32(appStatus[i].pin1); 3446 p.writeInt32(appStatus[i].pin2); 3447 appendPrintBuf("%s[app_type=%d,app_state=%d,perso_substate=%d,\ 3448 aid_ptr=%s,app_label_ptr=%s,pin1_replaced=%d,pin1=%d,pin2=%d],", 3449 printBuf, 3450 appStatus[i].app_type, 3451 appStatus[i].app_state, 3452 appStatus[i].perso_substate, 3453 appStatus[i].aid_ptr, 3454 appStatus[i].app_label_ptr, 3455 appStatus[i].pin1_replaced, 3456 appStatus[i].pin1, 3457 appStatus[i].pin2); 3458 } 3459 closeResponse; 3460 } 3461 3462 static int responseSimStatus(Parcel &p, void *response, size_t responselen) { 3463 int i; 3464 3465 if (response == NULL && responselen != 0) { 3466 RLOGE("invalid response: NULL"); 3467 return RIL_ERRNO_INVALID_RESPONSE; 3468 } 3469 3470 if (responselen == sizeof (RIL_CardStatus_v6)) { 3471 RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response); 3472 3473 p.writeInt32(p_cur->card_state); 3474 p.writeInt32(p_cur->universal_pin_state); 3475 p.writeInt32(p_cur->gsm_umts_subscription_app_index); 3476 p.writeInt32(p_cur->cdma_subscription_app_index); 3477 p.writeInt32(p_cur->ims_subscription_app_index); 3478 3479 sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications); 3480 } else if (responselen == sizeof (RIL_CardStatus_v5)) { 3481 RIL_CardStatus_v5 *p_cur = ((RIL_CardStatus_v5 *) response); 3482 3483 p.writeInt32(p_cur->card_state); 3484 p.writeInt32(p_cur->universal_pin_state); 3485 p.writeInt32(p_cur->gsm_umts_subscription_app_index); 3486 p.writeInt32(p_cur->cdma_subscription_app_index); 3487 p.writeInt32(-1); 3488 3489 sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications); 3490 } else { 3491 RLOGE("responseSimStatus: A RilCardStatus_v6 or _v5 expected\n"); 3492 return RIL_ERRNO_INVALID_RESPONSE; 3493 } 3494 3495 return 0; 3496 } 3497 3498 static int responseGsmBrSmsCnf(Parcel &p, void *response, size_t responselen) { 3499 int num = responselen / sizeof(RIL_GSM_BroadcastSmsConfigInfo *); 3500 p.writeInt32(num); 3501 3502 startResponse; 3503 RIL_GSM_BroadcastSmsConfigInfo **p_cur = 3504 (RIL_GSM_BroadcastSmsConfigInfo **) response; 3505 for (int i = 0; i < num; i++) { 3506 p.writeInt32(p_cur[i]->fromServiceId); 3507 p.writeInt32(p_cur[i]->toServiceId); 3508 p.writeInt32(p_cur[i]->fromCodeScheme); 3509 p.writeInt32(p_cur[i]->toCodeScheme); 3510 p.writeInt32(p_cur[i]->selected); 3511 3512 appendPrintBuf("%s [%d: fromServiceId=%d, toServiceId=%d, \ 3513 fromCodeScheme=%d, toCodeScheme=%d, selected =%d]", 3514 printBuf, i, p_cur[i]->fromServiceId, p_cur[i]->toServiceId, 3515 p_cur[i]->fromCodeScheme, p_cur[i]->toCodeScheme, 3516 p_cur[i]->selected); 3517 } 3518 closeResponse; 3519 3520 return 0; 3521 } 3522 3523 static int responseCdmaBrSmsCnf(Parcel &p, void *response, size_t responselen) { 3524 RIL_CDMA_BroadcastSmsConfigInfo **p_cur = 3525 (RIL_CDMA_BroadcastSmsConfigInfo **) response; 3526 3527 int num = responselen / sizeof (RIL_CDMA_BroadcastSmsConfigInfo *); 3528 p.writeInt32(num); 3529 3530 startResponse; 3531 for (int i = 0 ; i < num ; i++ ) { 3532 p.writeInt32(p_cur[i]->service_category); 3533 p.writeInt32(p_cur[i]->language); 3534 p.writeInt32(p_cur[i]->selected); 3535 3536 appendPrintBuf("%s [%d: srvice_category=%d, language =%d, \ 3537 selected =%d], ", 3538 printBuf, i, p_cur[i]->service_category, p_cur[i]->language, 3539 p_cur[i]->selected); 3540 } 3541 closeResponse; 3542 3543 return 0; 3544 } 3545 3546 static int responseCdmaSms(Parcel &p, void *response, size_t responselen) { 3547 int num; 3548 int digitCount; 3549 int digitLimit; 3550 uint8_t uct; 3551 void* dest; 3552 3553 RLOGD("Inside responseCdmaSms"); 3554 3555 if (response == NULL && responselen != 0) { 3556 RLOGE("invalid response: NULL"); 3557 return RIL_ERRNO_INVALID_RESPONSE; 3558 } 3559 3560 if (responselen != sizeof(RIL_CDMA_SMS_Message)) { 3561 RLOGE("invalid response length was %d expected %d", 3562 (int)responselen, (int)sizeof(RIL_CDMA_SMS_Message)); 3563 return RIL_ERRNO_INVALID_RESPONSE; 3564 } 3565 3566 RIL_CDMA_SMS_Message *p_cur = (RIL_CDMA_SMS_Message *) response; 3567 p.writeInt32(p_cur->uTeleserviceID); 3568 p.write(&(p_cur->bIsServicePresent),sizeof(uct)); 3569 p.writeInt32(p_cur->uServicecategory); 3570 p.writeInt32(p_cur->sAddress.digit_mode); 3571 p.writeInt32(p_cur->sAddress.number_mode); 3572 p.writeInt32(p_cur->sAddress.number_type); 3573 p.writeInt32(p_cur->sAddress.number_plan); 3574 p.write(&(p_cur->sAddress.number_of_digits), sizeof(uct)); 3575 digitLimit= MIN((p_cur->sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX); 3576 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) { 3577 p.write(&(p_cur->sAddress.digits[digitCount]),sizeof(uct)); 3578 } 3579 3580 p.writeInt32(p_cur->sSubAddress.subaddressType); 3581 p.write(&(p_cur->sSubAddress.odd),sizeof(uct)); 3582 p.write(&(p_cur->sSubAddress.number_of_digits),sizeof(uct)); 3583 digitLimit= MIN((p_cur->sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX); 3584 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) { 3585 p.write(&(p_cur->sSubAddress.digits[digitCount]),sizeof(uct)); 3586 } 3587 3588 digitLimit= MIN((p_cur->uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX); 3589 p.writeInt32(p_cur->uBearerDataLen); 3590 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) { 3591 p.write(&(p_cur->aBearerData[digitCount]), sizeof(uct)); 3592 } 3593 3594 startResponse; 3595 appendPrintBuf("%suTeleserviceID=%d, bIsServicePresent=%d, uServicecategory=%d, \ 3596 sAddress.digit_mode=%d, sAddress.number_mode=%d, sAddress.number_type=%d, ", 3597 printBuf, p_cur->uTeleserviceID,p_cur->bIsServicePresent,p_cur->uServicecategory, 3598 p_cur->sAddress.digit_mode, p_cur->sAddress.number_mode,p_cur->sAddress.number_type); 3599 closeResponse; 3600 3601 return 0; 3602 } 3603 3604 static int responseDcRtInfo(Parcel &p, void *response, size_t responselen) 3605 { 3606 int num = responselen / sizeof(RIL_DcRtInfo); 3607 if ((responselen % sizeof(RIL_DcRtInfo) != 0) || (num != 1)) { 3608 RLOGE("responseDcRtInfo: invalid response length %d expected multiple of %d", 3609 (int)responselen, (int)sizeof(RIL_DcRtInfo)); 3610 return RIL_ERRNO_INVALID_RESPONSE; 3611 } 3612 3613 startResponse; 3614 RIL_DcRtInfo *pDcRtInfo = (RIL_DcRtInfo *)response; 3615 p.writeInt64(pDcRtInfo->time); 3616 p.writeInt32(pDcRtInfo->powerState); 3617 appendPrintBuf("%s[time=%d,powerState=%d]", printBuf, 3618 pDcRtInfo->time, 3619 pDcRtInfo->powerState); 3620 closeResponse; 3621 3622 return 0; 3623 } 3624 3625 static int responseLceStatus(Parcel &p, void *response, size_t responselen) { 3626 if (response == NULL || responselen != sizeof(RIL_LceStatusInfo)) { 3627 if (response == NULL) { 3628 RLOGE("invalid response: NULL"); 3629 } 3630 else { 3631 RLOGE("responseLceStatus: invalid response length %d expecting len: d%", 3632 sizeof(RIL_LceStatusInfo), responselen); 3633 } 3634 return RIL_ERRNO_INVALID_RESPONSE; 3635 } 3636 3637 RIL_LceStatusInfo *p_cur = (RIL_LceStatusInfo *)response; 3638 p.write((void *)p_cur, 1); // p_cur->lce_status takes one byte. 3639 p.writeInt32(p_cur->actual_interval_ms); 3640 3641 startResponse; 3642 appendPrintBuf("LCE Status: %d, actual_interval_ms: %d", 3643 p_cur->lce_status, p_cur->actual_interval_ms); 3644 closeResponse; 3645 3646 return 0; 3647 } 3648 3649 static int responseLceData(Parcel &p, void *response, size_t responselen) { 3650 if (response == NULL || responselen != sizeof(RIL_LceDataInfo)) { 3651 if (response == NULL) { 3652 RLOGE("invalid response: NULL"); 3653 } 3654 else { 3655 RLOGE("responseLceData: invalid response length %d expecting len: d%", 3656 sizeof(RIL_LceDataInfo), responselen); 3657 } 3658 return RIL_ERRNO_INVALID_RESPONSE; 3659 } 3660 3661 RIL_LceDataInfo *p_cur = (RIL_LceDataInfo *)response; 3662 p.writeInt32(p_cur->last_hop_capacity_kbps); 3663 3664 /* p_cur->confidence_level and p_cur->lce_suspended take 1 byte each.*/ 3665 p.write((void *)&(p_cur->confidence_level), 1); 3666 p.write((void *)&(p_cur->lce_suspended), 1); 3667 3668 startResponse; 3669 appendPrintBuf("LCE info received: capacity %d confidence level %d 3670 and suspended %d", 3671 p_cur->last_hop_capacity_kbps, p_cur->confidence_level, 3672 p_cur->lce_suspended); 3673 closeResponse; 3674 3675 return 0; 3676 } 3677 3678 static int responseActivityData(Parcel &p, void *response, size_t responselen) { 3679 if (response == NULL || responselen != sizeof(RIL_ActivityStatsInfo)) { 3680 if (response == NULL) { 3681 RLOGE("invalid response: NULL"); 3682 } 3683 else { 3684 RLOGE("responseActivityData: invalid response length %d expecting len: d%", 3685 sizeof(RIL_ActivityStatsInfo), responselen); 3686 } 3687 return RIL_ERRNO_INVALID_RESPONSE; 3688 } 3689 3690 RIL_ActivityStatsInfo *p_cur = (RIL_ActivityStatsInfo *)response; 3691 p.writeInt32(p_cur->sleep_mode_time_ms); 3692 p.writeInt32(p_cur->idle_mode_time_ms); 3693 for(int i = 0; i < RIL_NUM_TX_POWER_LEVELS; i++) { 3694 p.writeInt32(p_cur->tx_mode_time_ms[i]); 3695 } 3696 p.writeInt32(p_cur->rx_mode_time_ms); 3697 3698 startResponse; 3699 appendPrintBuf("Modem activity info received: sleep_mode_time_ms %d idle_mode_time_ms %d 3700 tx_mode_time_ms %d %d %d %d %d and rx_mode_time_ms %d", 3701 p_cur->sleep_mode_time_ms, p_cur->idle_mode_time_ms, p_cur->tx_mode_time_ms[0], 3702 p_cur->tx_mode_time_ms[1], p_cur->tx_mode_time_ms[2], p_cur->tx_mode_time_ms[3], 3703 p_cur->tx_mode_time_ms[4], p_cur->rx_mode_time_ms); 3704 closeResponse; 3705 3706 return 0; 3707 } 3708 3709 /** 3710 * A write on the wakeup fd is done just to pop us out of select() 3711 * We empty the buffer here and then ril_event will reset the timers on the 3712 * way back down 3713 */ 3714 static void processWakeupCallback(int fd, short flags, void *param) { 3715 char buff[16]; 3716 int ret; 3717 3718 RLOGV("processWakeupCallback"); 3719 3720 /* empty our wakeup socket out */ 3721 do { 3722 ret = read(s_fdWakeupRead, &buff, sizeof(buff)); 3723 } while (ret > 0 || (ret < 0 && errno == EINTR)); 3724 } 3725 3726 static void onCommandsSocketClosed(RIL_SOCKET_ID socket_id) { 3727 int ret; 3728 RequestInfo *p_cur; 3729 /* Hook for current context 3730 pendingRequestsMutextHook refer to &s_pendingRequestsMutex */ 3731 pthread_mutex_t * pendingRequestsMutexHook = &s_pendingRequestsMutex; 3732 /* pendingRequestsHook refer to &s_pendingRequests */ 3733 RequestInfo ** pendingRequestsHook = &s_pendingRequests; 3734 3735 #if (SIM_COUNT >= 2) 3736 if (socket_id == RIL_SOCKET_2) { 3737 pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2; 3738 pendingRequestsHook = &s_pendingRequests_socket2; 3739 } 3740 #if (SIM_COUNT >= 3) 3741 else if (socket_id == RIL_SOCKET_3) { 3742 pendingRequestsMutexHook = &s_pendingRequestsMutex_socket3; 3743 pendingRequestsHook = &s_pendingRequests_socket3; 3744 } 3745 #endif 3746 #if (SIM_COUNT >= 4) 3747 else if (socket_id == RIL_SOCKET_4) { 3748 pendingRequestsMutexHook = &s_pendingRequestsMutex_socket4; 3749 pendingRequestsHook = &s_pendingRequests_socket4; 3750 } 3751 #endif 3752 #endif 3753 /* mark pending requests as "cancelled" so we dont report responses */ 3754 ret = pthread_mutex_lock(pendingRequestsMutexHook); 3755 assert (ret == 0); 3756 3757 p_cur = *pendingRequestsHook; 3758 3759 for (p_cur = *pendingRequestsHook 3760 ; p_cur != NULL 3761 ; p_cur = p_cur->p_next 3762 ) { 3763 p_cur->cancelled = 1; 3764 } 3765 3766 ret = pthread_mutex_unlock(pendingRequestsMutexHook); 3767 assert (ret == 0); 3768 } 3769 3770 static void processCommandsCallback(int fd, short flags, void *param) { 3771 RecordStream *p_rs; 3772 void *p_record; 3773 size_t recordlen; 3774 int ret; 3775 SocketListenParam *p_info = (SocketListenParam *)param; 3776 3777 assert(fd == p_info->fdCommand); 3778 3779 p_rs = p_info->p_rs; 3780 3781 for (;;) { 3782 /* loop until EAGAIN/EINTR, end of stream, or other error */ 3783 ret = record_stream_get_next(p_rs, &p_record, &recordlen); 3784 3785 if (ret == 0 && p_record == NULL) { 3786 /* end-of-stream */ 3787 break; 3788 } else if (ret < 0) { 3789 break; 3790 } else if (ret == 0) { /* && p_record != NULL */ 3791 processCommandBuffer(p_record, recordlen, p_info->socket_id); 3792 } 3793 } 3794 3795 if (ret == 0 || !(errno == EAGAIN || errno == EINTR)) { 3796 /* fatal error or end-of-stream */ 3797 if (ret != 0) { 3798 RLOGE("error on reading command socket errno:%d\n", errno); 3799 } else { 3800 RLOGW("EOS. Closing command socket."); 3801 } 3802 3803 close(fd); 3804 p_info->fdCommand = -1; 3805 3806 ril_event_del(p_info->commands_event); 3807 3808 record_stream_free(p_rs); 3809 3810 /* start listening for new connections again */ 3811 rilEventAddWakeup(&s_listen_event); 3812 3813 onCommandsSocketClosed(p_info->socket_id); 3814 } 3815 } 3816 3817 3818 static void onNewCommandConnect(RIL_SOCKET_ID socket_id) { 3819 // Inform we are connected and the ril version 3820 int rilVer = s_callbacks.version; 3821 RIL_UNSOL_RESPONSE(RIL_UNSOL_RIL_CONNECTED, 3822 &rilVer, sizeof(rilVer), socket_id); 3823 3824 // implicit radio state changed 3825 RIL_UNSOL_RESPONSE(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED, 3826 NULL, 0, socket_id); 3827 3828 // Send last NITZ time data, in case it was missed 3829 if (s_lastNITZTimeData != NULL) { 3830 sendResponseRaw(s_lastNITZTimeData, s_lastNITZTimeDataSize, socket_id); 3831 3832 free(s_lastNITZTimeData); 3833 s_lastNITZTimeData = NULL; 3834 } 3835 3836 // Get version string 3837 if (s_callbacks.getVersion != NULL) { 3838 const char *version; 3839 version = s_callbacks.getVersion(); 3840 RLOGI("RIL Daemon version: %s\n", version); 3841 3842 property_set(PROPERTY_RIL_IMPL, version); 3843 } else { 3844 RLOGI("RIL Daemon version: unavailable\n"); 3845 property_set(PROPERTY_RIL_IMPL, "unavailable"); 3846 } 3847 3848 } 3849 3850 static void listenCallback (int fd, short flags, void *param) { 3851 int ret; 3852 int err; 3853 int is_phone_socket; 3854 int fdCommand = -1; 3855 char* processName; 3856 RecordStream *p_rs; 3857 MySocketListenParam* listenParam; 3858 RilSocket *sapSocket = NULL; 3859 socketClient *sClient = NULL; 3860 3861 SocketListenParam *p_info = (SocketListenParam *)param; 3862 3863 if(RIL_SAP_SOCKET == p_info->type) { 3864 listenParam = (MySocketListenParam *)param; 3865 sapSocket = listenParam->socket; 3866 } 3867 3868 struct sockaddr_un peeraddr; 3869 socklen_t socklen = sizeof (peeraddr); 3870 3871 struct ucred creds; 3872 socklen_t szCreds = sizeof(creds); 3873 3874 struct passwd *pwd = NULL; 3875 3876 if(NULL == sapSocket) { 3877 assert (*p_info->fdCommand < 0); 3878 assert (fd == *p_info->fdListen); 3879 processName = PHONE_PROCESS; 3880 } else { 3881 assert (sapSocket->commandFd < 0); 3882 assert (fd == sapSocket->listenFd); 3883 processName = BLUETOOTH_PROCESS; 3884 } 3885 3886 3887 fdCommand = accept(fd, (sockaddr *) &peeraddr, &socklen); 3888 3889 if (fdCommand < 0 ) { 3890 RLOGE("Error on accept() errno:%d", errno); 3891 /* start listening for new connections again */ 3892 if(NULL == sapSocket) { 3893 rilEventAddWakeup(p_info->listen_event); 3894 } else { 3895 rilEventAddWakeup(sapSocket->getListenEvent()); 3896 } 3897 return; 3898 } 3899 3900 /* check the credential of the other side and only accept socket from 3901 * phone process 3902 */ 3903 errno = 0; 3904 is_phone_socket = 0; 3905 3906 err = getsockopt(fdCommand, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds); 3907 3908 if (err == 0 && szCreds > 0) { 3909 errno = 0; 3910 pwd = getpwuid(creds.uid); 3911 if (pwd != NULL) { 3912 if (strcmp(pwd->pw_name, processName) == 0) { 3913 is_phone_socket = 1; 3914 } else { 3915 RLOGE("RILD can't accept socket from process %s", pwd->pw_name); 3916 } 3917 } else { 3918 RLOGE("Error on getpwuid() errno: %d", errno); 3919 } 3920 } else { 3921 RLOGD("Error on getsockopt() errno: %d", errno); 3922 } 3923 3924 if (!is_phone_socket) { 3925 RLOGE("RILD must accept socket from %s", processName); 3926 3927 close(fdCommand); 3928 fdCommand = -1; 3929 3930 if(NULL == sapSocket) { 3931 onCommandsSocketClosed(p_info->socket_id); 3932 3933 /* start listening for new connections again */ 3934 rilEventAddWakeup(p_info->listen_event); 3935 } else { 3936 sapSocket->onCommandsSocketClosed(); 3937 3938 /* start listening for new connections again */ 3939 rilEventAddWakeup(sapSocket->getListenEvent()); 3940 } 3941 3942 return; 3943 } 3944 3945 ret = fcntl(fdCommand, F_SETFL, O_NONBLOCK); 3946 3947 if (ret < 0) { 3948 RLOGE ("Error setting O_NONBLOCK errno:%d", errno); 3949 } 3950 3951 if(NULL == sapSocket) { 3952 RLOGI("libril: new connection to %s", rilSocketIdToString(p_info->socket_id)); 3953 3954 p_info->fdCommand = fdCommand; 3955 p_rs = record_stream_new(p_info->fdCommand, MAX_COMMAND_BYTES); 3956 p_info->p_rs = p_rs; 3957 3958 ril_event_set (p_info->commands_event, p_info->fdCommand, 1, 3959 p_info->processCommandsCallback, p_info); 3960 rilEventAddWakeup (p_info->commands_event); 3961 3962 onNewCommandConnect(p_info->socket_id); 3963 } else { 3964 RLOGI("libril: new connection"); 3965 3966 sapSocket->setCommandFd(fdCommand); 3967 p_rs = record_stream_new(sapSocket->getCommandFd(), MAX_COMMAND_BYTES); 3968 sClient = new socketClient(sapSocket,p_rs); 3969 ril_event_set (sapSocket->getCallbackEvent(), sapSocket->getCommandFd(), 1, 3970 sapSocket->getCommandCb(), sClient); 3971 3972 rilEventAddWakeup(sapSocket->getCallbackEvent()); 3973 sapSocket->onNewCommandConnect(); 3974 } 3975 } 3976 3977 static void freeDebugCallbackArgs(int number, char **args) { 3978 for (int i = 0; i < number; i++) { 3979 if (args[i] != NULL) { 3980 free(args[i]); 3981 } 3982 } 3983 free(args); 3984 } 3985 3986 static void debugCallback (int fd, short flags, void *param) { 3987 int acceptFD, option; 3988 struct sockaddr_un peeraddr; 3989 socklen_t socklen = sizeof (peeraddr); 3990 int data; 3991 unsigned int qxdm_data[6]; 3992 const char *deactData[1] = {"1"}; 3993 char *actData[1]; 3994 RIL_Dial dialData; 3995 int hangupData[1] = {1}; 3996 int number; 3997 char **args; 3998 RIL_SOCKET_ID socket_id = RIL_SOCKET_1; 3999 int sim_id = 0; 4000 4001 RLOGI("debugCallback for socket %s", rilSocketIdToString(socket_id)); 4002 4003 acceptFD = accept (fd, (sockaddr *) &peeraddr, &socklen); 4004 4005 if (acceptFD < 0) { 4006 RLOGE ("error accepting on debug port: %d\n", errno); 4007 return; 4008 } 4009 4010 if (recv(acceptFD, &number, sizeof(int), 0) != sizeof(int)) { 4011 RLOGE ("error reading on socket: number of Args: \n"); 4012 return; 4013 } 4014 args = (char **) malloc(sizeof(char*) * number); 4015 4016 for (int i = 0; i < number; i++) { 4017 int len; 4018 if (recv(acceptFD, &len, sizeof(int), 0) != sizeof(int)) { 4019 RLOGE ("error reading on socket: Len of Args: \n"); 4020 freeDebugCallbackArgs(i, args); 4021 return; 4022 } 4023 // +1 for null-term 4024 args[i] = (char *) malloc((sizeof(char) * len) + 1); 4025 if (recv(acceptFD, args[i], sizeof(char) * len, 0) 4026 != (int)sizeof(char) * len) { 4027 RLOGE ("error reading on socket: Args[%d] \n", i); 4028 freeDebugCallbackArgs(i, args); 4029 return; 4030 } 4031 char * buf = args[i]; 4032 buf[len] = 0; 4033 if ((i+1) == number) { 4034 /* The last argument should be sim id 0(SIM1)~3(SIM4) */ 4035 sim_id = atoi(args[i]); 4036 switch (sim_id) { 4037 case 0: 4038 socket_id = RIL_SOCKET_1; 4039 break; 4040 #if (SIM_COUNT >= 2) 4041 case 1: 4042 socket_id = RIL_SOCKET_2; 4043 break; 4044 #endif 4045 #if (SIM_COUNT >= 3) 4046 case 2: 4047 socket_id = RIL_SOCKET_3; 4048 break; 4049 #endif 4050 #if (SIM_COUNT >= 4) 4051 case 3: 4052 socket_id = RIL_SOCKET_4; 4053 break; 4054 #endif 4055 default: 4056 socket_id = RIL_SOCKET_1; 4057 break; 4058 } 4059 } 4060 } 4061 4062 switch (atoi(args[0])) { 4063 case 0: 4064 RLOGI ("Connection on debug port: issuing reset."); 4065 issueLocalRequest(RIL_REQUEST_RESET_RADIO, NULL, 0, socket_id); 4066 break; 4067 case 1: 4068 RLOGI ("Connection on debug port: issuing radio power off."); 4069 data = 0; 4070 issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int), socket_id); 4071 // Close the socket 4072 if (socket_id == RIL_SOCKET_1 && s_ril_param_socket.fdCommand > 0) { 4073 close(s_ril_param_socket.fdCommand); 4074 s_ril_param_socket.fdCommand = -1; 4075 } 4076 #if (SIM_COUNT == 2) 4077 else if (socket_id == RIL_SOCKET_2 && s_ril_param_socket2.fdCommand > 0) { 4078 close(s_ril_param_socket2.fdCommand); 4079 s_ril_param_socket2.fdCommand = -1; 4080 } 4081 #endif 4082 break; 4083 case 2: 4084 RLOGI ("Debug port: issuing unsolicited voice network change."); 4085 RIL_UNSOL_RESPONSE(RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, NULL, 0, socket_id); 4086 break; 4087 case 3: 4088 RLOGI ("Debug port: QXDM log enable."); 4089 qxdm_data[0] = 65536; // head.func_tag 4090 qxdm_data[1] = 16; // head.len 4091 qxdm_data[2] = 1; // mode: 1 for 'start logging' 4092 qxdm_data[3] = 32; // log_file_size: 32megabytes 4093 qxdm_data[4] = 0; // log_mask 4094 qxdm_data[5] = 8; // log_max_fileindex 4095 issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data, 4096 6 * sizeof(int), socket_id); 4097 break; 4098 case 4: 4099 RLOGI ("Debug port: QXDM log disable."); 4100 qxdm_data[0] = 65536; 4101 qxdm_data[1] = 16; 4102 qxdm_data[2] = 0; // mode: 0 for 'stop logging' 4103 qxdm_data[3] = 32; 4104 qxdm_data[4] = 0; 4105 qxdm_data[5] = 8; 4106 issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data, 4107 6 * sizeof(int), socket_id); 4108 break; 4109 case 5: 4110 RLOGI("Debug port: Radio On"); 4111 data = 1; 4112 issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int), socket_id); 4113 sleep(2); 4114 // Set network selection automatic. 4115 issueLocalRequest(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, NULL, 0, socket_id); 4116 break; 4117 case 6: 4118 RLOGI("Debug port: Setup Data Call, Apn :%s\n", args[1]); 4119 actData[0] = args[1]; 4120 issueLocalRequest(RIL_REQUEST_SETUP_DATA_CALL, &actData, 4121 sizeof(actData), socket_id); 4122 break; 4123 case 7: 4124 RLOGI("Debug port: Deactivate Data Call"); 4125 issueLocalRequest(RIL_REQUEST_DEACTIVATE_DATA_CALL, &deactData, 4126 sizeof(deactData), socket_id); 4127 break; 4128 case 8: 4129 RLOGI("Debug port: Dial Call"); 4130 dialData.clir = 0; 4131 dialData.address = args[1]; 4132 issueLocalRequest(RIL_REQUEST_DIAL, &dialData, sizeof(dialData), socket_id); 4133 break; 4134 case 9: 4135 RLOGI("Debug port: Answer Call"); 4136 issueLocalRequest(RIL_REQUEST_ANSWER, NULL, 0, socket_id); 4137 break; 4138 case 10: 4139 RLOGI("Debug port: End Call"); 4140 issueLocalRequest(RIL_REQUEST_HANGUP, &hangupData, 4141 sizeof(hangupData), socket_id); 4142 break; 4143 default: 4144 RLOGE ("Invalid request"); 4145 break; 4146 } 4147 freeDebugCallbackArgs(number, args); 4148 close(acceptFD); 4149 } 4150 4151 4152 static void userTimerCallback (int fd, short flags, void *param) { 4153 UserCallbackInfo *p_info; 4154 4155 p_info = (UserCallbackInfo *)param; 4156 4157 p_info->p_callback(p_info->userParam); 4158 4159 4160 // FIXME generalize this...there should be a cancel mechanism 4161 if (s_last_wake_timeout_info != NULL && s_last_wake_timeout_info == p_info) { 4162 s_last_wake_timeout_info = NULL; 4163 } 4164 4165 free(p_info); 4166 } 4167 4168 4169 static void * 4170 eventLoop(void *param) { 4171 int ret; 4172 int filedes[2]; 4173 4174 ril_event_init(); 4175 4176 pthread_mutex_lock(&s_startupMutex); 4177 4178 s_started = 1; 4179 pthread_cond_broadcast(&s_startupCond); 4180 4181 pthread_mutex_unlock(&s_startupMutex); 4182 4183 ret = pipe(filedes); 4184 4185 if (ret < 0) { 4186 RLOGE("Error in pipe() errno:%d", errno); 4187 return NULL; 4188 } 4189 4190 s_fdWakeupRead = filedes[0]; 4191 s_fdWakeupWrite = filedes[1]; 4192 4193 fcntl(s_fdWakeupRead, F_SETFL, O_NONBLOCK); 4194 4195 ril_event_set (&s_wakeupfd_event, s_fdWakeupRead, true, 4196 processWakeupCallback, NULL); 4197 4198 rilEventAddWakeup (&s_wakeupfd_event); 4199 4200 // Only returns on error 4201 ril_event_loop(); 4202 RLOGE ("error in event_loop_base errno:%d", errno); 4203 // kill self to restart on error 4204 kill(0, SIGKILL); 4205 4206 return NULL; 4207 } 4208 4209 extern "C" void 4210 RIL_startEventLoop(void) { 4211 /* spin up eventLoop thread and wait for it to get started */ 4212 s_started = 0; 4213 pthread_mutex_lock(&s_startupMutex); 4214 4215 pthread_attr_t attr; 4216 pthread_attr_init(&attr); 4217 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); 4218 4219 int result = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL); 4220 if (result != 0) { 4221 RLOGE("Failed to create dispatch thread: %s", strerror(result)); 4222 goto done; 4223 } 4224 4225 while (s_started == 0) { 4226 pthread_cond_wait(&s_startupCond, &s_startupMutex); 4227 } 4228 4229 done: 4230 pthread_mutex_unlock(&s_startupMutex); 4231 } 4232 4233 // Used for testing purpose only. 4234 extern "C" void RIL_setcallbacks (const RIL_RadioFunctions *callbacks) { 4235 memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions)); 4236 } 4237 4238 static void startListen(RIL_SOCKET_ID socket_id, SocketListenParam* socket_listen_p) { 4239 int fdListen = -1; 4240 int ret; 4241 char socket_name[10]; 4242 4243 memset(socket_name, 0, sizeof(char)*10); 4244 4245 switch(socket_id) { 4246 case RIL_SOCKET_1: 4247 strncpy(socket_name, RIL_getRilSocketName(), 9); 4248 break; 4249 #if (SIM_COUNT >= 2) 4250 case RIL_SOCKET_2: 4251 strncpy(socket_name, SOCKET2_NAME_RIL, 9); 4252 break; 4253 #endif 4254 #if (SIM_COUNT >= 3) 4255 case RIL_SOCKET_3: 4256 strncpy(socket_name, SOCKET3_NAME_RIL, 9); 4257 break; 4258 #endif 4259 #if (SIM_COUNT >= 4) 4260 case RIL_SOCKET_4: 4261 strncpy(socket_name, SOCKET4_NAME_RIL, 9); 4262 break; 4263 #endif 4264 default: 4265 RLOGE("Socket id is wrong!!"); 4266 return; 4267 } 4268 4269 RLOGI("Start to listen %s", rilSocketIdToString(socket_id)); 4270 4271 fdListen = android_get_control_socket(socket_name); 4272 if (fdListen < 0) { 4273 RLOGE("Failed to get socket %s", socket_name); 4274 exit(-1); 4275 } 4276 4277 ret = listen(fdListen, 4); 4278 4279 if (ret < 0) { 4280 RLOGE("Failed to listen on control socket '%d': %s", 4281 fdListen, strerror(errno)); 4282 exit(-1); 4283 } 4284 socket_listen_p->fdListen = fdListen; 4285 4286 /* note: non-persistent so we can accept only one connection at a time */ 4287 ril_event_set (socket_listen_p->listen_event, fdListen, false, 4288 listenCallback, socket_listen_p); 4289 4290 rilEventAddWakeup (socket_listen_p->listen_event); 4291 } 4292 4293 extern "C" void 4294 RIL_register (const RIL_RadioFunctions *callbacks) { 4295 int ret; 4296 int flags; 4297 4298 RLOGI("SIM_COUNT: %d", SIM_COUNT); 4299 4300 if (callbacks == NULL) { 4301 RLOGE("RIL_register: RIL_RadioFunctions * null"); 4302 return; 4303 } 4304 if (callbacks->version < RIL_VERSION_MIN) { 4305 RLOGE("RIL_register: version %d is to old, min version is %d", 4306 callbacks->version, RIL_VERSION_MIN); 4307 return; 4308 } 4309 if (callbacks->version > RIL_VERSION) { 4310 RLOGE("RIL_register: version %d is too new, max version is %d", 4311 callbacks->version, RIL_VERSION); 4312 return; 4313 } 4314 RLOGE("RIL_register: RIL version %d", callbacks->version); 4315 4316 if (s_registerCalled > 0) { 4317 RLOGE("RIL_register has been called more than once. " 4318 "Subsequent call ignored"); 4319 return; 4320 } 4321 4322 memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions)); 4323 4324 /* Initialize socket1 parameters */ 4325 s_ril_param_socket = { 4326 RIL_SOCKET_1, /* socket_id */ 4327 -1, /* fdListen */ 4328 -1, /* fdCommand */ 4329 PHONE_PROCESS, /* processName */ 4330 &s_commands_event, /* commands_event */ 4331 &s_listen_event, /* listen_event */ 4332 processCommandsCallback, /* processCommandsCallback */ 4333 NULL /* p_rs */ 4334 }; 4335 4336 #if (SIM_COUNT >= 2) 4337 s_ril_param_socket2 = { 4338 RIL_SOCKET_2, /* socket_id */ 4339 -1, /* fdListen */ 4340 -1, /* fdCommand */ 4341 PHONE_PROCESS, /* processName */ 4342 &s_commands_event_socket2, /* commands_event */ 4343 &s_listen_event_socket2, /* listen_event */ 4344 processCommandsCallback, /* processCommandsCallback */ 4345 NULL /* p_rs */ 4346 }; 4347 #endif 4348 4349 #if (SIM_COUNT >= 3) 4350 s_ril_param_socket3 = { 4351 RIL_SOCKET_3, /* socket_id */ 4352 -1, /* fdListen */ 4353 -1, /* fdCommand */ 4354 PHONE_PROCESS, /* processName */ 4355 &s_commands_event_socket3, /* commands_event */ 4356 &s_listen_event_socket3, /* listen_event */ 4357 processCommandsCallback, /* processCommandsCallback */ 4358 NULL /* p_rs */ 4359 }; 4360 #endif 4361 4362 #if (SIM_COUNT >= 4) 4363 s_ril_param_socket4 = { 4364 RIL_SOCKET_4, /* socket_id */ 4365 -1, /* fdListen */ 4366 -1, /* fdCommand */ 4367 PHONE_PROCESS, /* processName */ 4368 &s_commands_event_socket4, /* commands_event */ 4369 &s_listen_event_socket4, /* listen_event */ 4370 processCommandsCallback, /* processCommandsCallback */ 4371 NULL /* p_rs */ 4372 }; 4373 #endif 4374 4375 4376 s_registerCalled = 1; 4377 4378 RLOGI("s_registerCalled flag set, %d", s_started); 4379 // Little self-check 4380 4381 for (int i = 0; i < (int)NUM_ELEMS(s_commands); i++) { 4382 assert(i == s_commands[i].requestNumber); 4383 } 4384 4385 for (int i = 0; i < (int)NUM_ELEMS(s_unsolResponses); i++) { 4386 assert(i + RIL_UNSOL_RESPONSE_BASE 4387 == s_unsolResponses[i].requestNumber); 4388 } 4389 4390 // New rild impl calls RIL_startEventLoop() first 4391 // old standalone impl wants it here. 4392 4393 if (s_started == 0) { 4394 RIL_startEventLoop(); 4395 } 4396 4397 // start listen socket1 4398 startListen(RIL_SOCKET_1, &s_ril_param_socket); 4399 4400 #if (SIM_COUNT >= 2) 4401 // start listen socket2 4402 startListen(RIL_SOCKET_2, &s_ril_param_socket2); 4403 #endif /* (SIM_COUNT == 2) */ 4404 4405 #if (SIM_COUNT >= 3) 4406 // start listen socket3 4407 startListen(RIL_SOCKET_3, &s_ril_param_socket3); 4408 #endif /* (SIM_COUNT == 3) */ 4409 4410 #if (SIM_COUNT >= 4) 4411 // start listen socket4 4412 startListen(RIL_SOCKET_4, &s_ril_param_socket4); 4413 #endif /* (SIM_COUNT == 4) */ 4414 4415 4416 #if 1 4417 // start debug interface socket 4418 4419 char *inst = NULL; 4420 if (strlen(RIL_getRilSocketName()) >= strlen(SOCKET_NAME_RIL)) { 4421 inst = RIL_getRilSocketName() + strlen(SOCKET_NAME_RIL); 4422 } 4423 4424 char rildebug[MAX_DEBUG_SOCKET_NAME_LENGTH] = SOCKET_NAME_RIL_DEBUG; 4425 if (inst != NULL) { 4426 strlcat(rildebug, inst, MAX_DEBUG_SOCKET_NAME_LENGTH); 4427 } 4428 4429 s_fdDebug = android_get_control_socket(rildebug); 4430 if (s_fdDebug < 0) { 4431 RLOGE("Failed to get socket : %s errno:%d", rildebug, errno); 4432 exit(-1); 4433 } 4434 4435 ret = listen(s_fdDebug, 4); 4436 4437 if (ret < 0) { 4438 RLOGE("Failed to listen on ril debug socket '%d': %s", 4439 s_fdDebug, strerror(errno)); 4440 exit(-1); 4441 } 4442 4443 ril_event_set (&s_debug_event, s_fdDebug, true, 4444 debugCallback, NULL); 4445 4446 rilEventAddWakeup (&s_debug_event); 4447 #endif 4448 4449 } 4450 4451 extern "C" void 4452 RIL_register_socket (RIL_RadioFunctions *(*Init)(const struct RIL_Env *, int, char **),RIL_SOCKET_TYPE socketType, int argc, char **argv) { 4453 4454 RIL_RadioFunctions* UimFuncs = NULL; 4455 4456 if(Init) { 4457 UimFuncs = Init(&RilSapSocket::uimRilEnv, argc, argv); 4458 4459 switch(socketType) { 4460 case RIL_SAP_SOCKET: 4461 RilSapSocket::initSapSocket("sap_uim_socket1", UimFuncs); 4462 4463 #if (SIM_COUNT >= 2) 4464 RilSapSocket::initSapSocket("sap_uim_socket2", UimFuncs); 4465 #endif 4466 4467 #if (SIM_COUNT >= 3) 4468 RilSapSocket::initSapSocket("sap_uim_socket3", UimFuncs); 4469 #endif 4470 4471 #if (SIM_COUNT >= 4) 4472 RilSapSocket::initSapSocket("sap_uim_socket4", UimFuncs); 4473 #endif 4474 } 4475 } 4476 } 4477 4478 static int 4479 checkAndDequeueRequestInfo(struct RequestInfo *pRI) { 4480 int ret = 0; 4481 /* Hook for current context 4482 pendingRequestsMutextHook refer to &s_pendingRequestsMutex */ 4483 pthread_mutex_t* pendingRequestsMutexHook = &s_pendingRequestsMutex; 4484 /* pendingRequestsHook refer to &s_pendingRequests */ 4485 RequestInfo ** pendingRequestsHook = &s_pendingRequests; 4486 4487 if (pRI == NULL) { 4488 return 0; 4489 } 4490 4491 #if (SIM_COUNT >= 2) 4492 if (pRI->socket_id == RIL_SOCKET_2) { 4493 pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2; 4494 pendingRequestsHook = &s_pendingRequests_socket2; 4495 } 4496 #if (SIM_COUNT >= 3) 4497 if (pRI->socket_id == RIL_SOCKET_3) { 4498 pendingRequestsMutexHook = &s_pendingRequestsMutex_socket3; 4499 pendingRequestsHook = &s_pendingRequests_socket3; 4500 } 4501 #endif 4502 #if (SIM_COUNT >= 4) 4503 if (pRI->socket_id == RIL_SOCKET_4) { 4504 pendingRequestsMutexHook = &s_pendingRequestsMutex_socket4; 4505 pendingRequestsHook = &s_pendingRequests_socket4; 4506 } 4507 #endif 4508 #endif 4509 pthread_mutex_lock(pendingRequestsMutexHook); 4510 4511 for(RequestInfo **ppCur = pendingRequestsHook 4512 ; *ppCur != NULL 4513 ; ppCur = &((*ppCur)->p_next) 4514 ) { 4515 if (pRI == *ppCur) { 4516 ret = 1; 4517 4518 *ppCur = (*ppCur)->p_next; 4519 break; 4520 } 4521 } 4522 4523 pthread_mutex_unlock(pendingRequestsMutexHook); 4524 4525 return ret; 4526 } 4527 4528 4529 extern "C" void 4530 RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen) { 4531 RequestInfo *pRI; 4532 int ret; 4533 int fd = s_ril_param_socket.fdCommand; 4534 size_t errorOffset; 4535 RIL_SOCKET_ID socket_id = RIL_SOCKET_1; 4536 4537 pRI = (RequestInfo *)t; 4538 4539 if (!checkAndDequeueRequestInfo(pRI)) { 4540 RLOGE ("RIL_onRequestComplete: invalid RIL_Token"); 4541 return; 4542 } 4543 4544 socket_id = pRI->socket_id; 4545 #if (SIM_COUNT >= 2) 4546 if (socket_id == RIL_SOCKET_2) { 4547 fd = s_ril_param_socket2.fdCommand; 4548 } 4549 #if (SIM_COUNT >= 3) 4550 if (socket_id == RIL_SOCKET_3) { 4551 fd = s_ril_param_socket3.fdCommand; 4552 } 4553 #endif 4554 #if (SIM_COUNT >= 4) 4555 if (socket_id == RIL_SOCKET_4) { 4556 fd = s_ril_param_socket4.fdCommand; 4557 } 4558 #endif 4559 #endif 4560 #if VDBG 4561 RLOGD("RequestComplete, %s", rilSocketIdToString(socket_id)); 4562 #endif 4563 4564 if (pRI->local > 0) { 4565 // Locally issued command...void only! 4566 // response does not go back up the command socket 4567 RLOGD("C[locl]< %s", requestToString(pRI->pCI->requestNumber)); 4568 4569 goto done; 4570 } 4571 4572 appendPrintBuf("[%04d]< %s", 4573 pRI->token, requestToString(pRI->pCI->requestNumber)); 4574 4575 if (pRI->cancelled == 0) { 4576 Parcel p; 4577 4578 p.writeInt32 (RESPONSE_SOLICITED); 4579 p.writeInt32 (pRI->token); 4580 errorOffset = p.dataPosition(); 4581 4582 p.writeInt32 (e); 4583 4584 if (response != NULL) { 4585 // there is a response payload, no matter success or not. 4586 ret = pRI->pCI->responseFunction(p, response, responselen); 4587 4588 /* if an error occurred, rewind and mark it */ 4589 if (ret != 0) { 4590 RLOGE ("responseFunction error, ret %d", ret); 4591 p.setDataPosition(errorOffset); 4592 p.writeInt32 (ret); 4593 } 4594 } 4595 4596 if (e != RIL_E_SUCCESS) { 4597 appendPrintBuf("%s fails by %s", printBuf, failCauseToString(e)); 4598 } 4599 4600 if (fd < 0) { 4601 RLOGD ("RIL onRequestComplete: Command channel closed"); 4602 } 4603 sendResponse(p, socket_id); 4604 } 4605 4606 done: 4607 free(pRI); 4608 } 4609 4610 4611 static void 4612 grabPartialWakeLock() { 4613 acquire_wake_lock(PARTIAL_WAKE_LOCK, ANDROID_WAKE_LOCK_NAME); 4614 } 4615 4616 static void 4617 releaseWakeLock() { 4618 release_wake_lock(ANDROID_WAKE_LOCK_NAME); 4619 } 4620 4621 /** 4622 * Timer callback to put us back to sleep before the default timeout 4623 */ 4624 static void 4625 wakeTimeoutCallback (void *param) { 4626 // We're using "param != NULL" as a cancellation mechanism 4627 if (param == NULL) { 4628 releaseWakeLock(); 4629 } 4630 } 4631 4632 static int 4633 decodeVoiceRadioTechnology (RIL_RadioState radioState) { 4634 switch (radioState) { 4635 case RADIO_STATE_SIM_NOT_READY: 4636 case RADIO_STATE_SIM_LOCKED_OR_ABSENT: 4637 case RADIO_STATE_SIM_READY: 4638 return RADIO_TECH_UMTS; 4639 4640 case RADIO_STATE_RUIM_NOT_READY: 4641 case RADIO_STATE_RUIM_READY: 4642 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT: 4643 case RADIO_STATE_NV_NOT_READY: 4644 case RADIO_STATE_NV_READY: 4645 return RADIO_TECH_1xRTT; 4646 4647 default: 4648 RLOGD("decodeVoiceRadioTechnology: Invoked with incorrect RadioState"); 4649 return -1; 4650 } 4651 } 4652 4653 static int 4654 decodeCdmaSubscriptionSource (RIL_RadioState radioState) { 4655 switch (radioState) { 4656 case RADIO_STATE_SIM_NOT_READY: 4657 case RADIO_STATE_SIM_LOCKED_OR_ABSENT: 4658 case RADIO_STATE_SIM_READY: 4659 case RADIO_STATE_RUIM_NOT_READY: 4660 case RADIO_STATE_RUIM_READY: 4661 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT: 4662 return CDMA_SUBSCRIPTION_SOURCE_RUIM_SIM; 4663 4664 case RADIO_STATE_NV_NOT_READY: 4665 case RADIO_STATE_NV_READY: 4666 return CDMA_SUBSCRIPTION_SOURCE_NV; 4667 4668 default: 4669 RLOGD("decodeCdmaSubscriptionSource: Invoked with incorrect RadioState"); 4670 return -1; 4671 } 4672 } 4673 4674 static int 4675 decodeSimStatus (RIL_RadioState radioState) { 4676 switch (radioState) { 4677 case RADIO_STATE_SIM_NOT_READY: 4678 case RADIO_STATE_RUIM_NOT_READY: 4679 case RADIO_STATE_NV_NOT_READY: 4680 case RADIO_STATE_NV_READY: 4681 return -1; 4682 case RADIO_STATE_SIM_LOCKED_OR_ABSENT: 4683 case RADIO_STATE_SIM_READY: 4684 case RADIO_STATE_RUIM_READY: 4685 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT: 4686 return radioState; 4687 default: 4688 RLOGD("decodeSimStatus: Invoked with incorrect RadioState"); 4689 return -1; 4690 } 4691 } 4692 4693 static bool is3gpp2(int radioTech) { 4694 switch (radioTech) { 4695 case RADIO_TECH_IS95A: 4696 case RADIO_TECH_IS95B: 4697 case RADIO_TECH_1xRTT: 4698 case RADIO_TECH_EVDO_0: 4699 case RADIO_TECH_EVDO_A: 4700 case RADIO_TECH_EVDO_B: 4701 case RADIO_TECH_EHRPD: 4702 return true; 4703 default: 4704 return false; 4705 } 4706 } 4707 4708 /* If RIL sends SIM states or RUIM states, store the voice radio 4709 * technology and subscription source information so that they can be 4710 * returned when telephony framework requests them 4711 */ 4712 static RIL_RadioState 4713 processRadioState(RIL_RadioState newRadioState, RIL_SOCKET_ID socket_id) { 4714 4715 if((newRadioState > RADIO_STATE_UNAVAILABLE) && (newRadioState < RADIO_STATE_ON)) { 4716 int newVoiceRadioTech; 4717 int newCdmaSubscriptionSource; 4718 int newSimStatus; 4719 4720 /* This is old RIL. Decode Subscription source and Voice Radio Technology 4721 from Radio State and send change notifications if there has been a change */ 4722 newVoiceRadioTech = decodeVoiceRadioTechnology(newRadioState); 4723 if(newVoiceRadioTech != voiceRadioTech) { 4724 voiceRadioTech = newVoiceRadioTech; 4725 RIL_UNSOL_RESPONSE(RIL_UNSOL_VOICE_RADIO_TECH_CHANGED, 4726 &voiceRadioTech, sizeof(voiceRadioTech), socket_id); 4727 } 4728 if(is3gpp2(newVoiceRadioTech)) { 4729 newCdmaSubscriptionSource = decodeCdmaSubscriptionSource(newRadioState); 4730 if(newCdmaSubscriptionSource != cdmaSubscriptionSource) { 4731 cdmaSubscriptionSource = newCdmaSubscriptionSource; 4732 RIL_UNSOL_RESPONSE(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED, 4733 &cdmaSubscriptionSource, sizeof(cdmaSubscriptionSource), socket_id); 4734 } 4735 } 4736 newSimStatus = decodeSimStatus(newRadioState); 4737 if(newSimStatus != simRuimStatus) { 4738 simRuimStatus = newSimStatus; 4739 RIL_UNSOL_RESPONSE(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0, socket_id); 4740 } 4741 4742 /* Send RADIO_ON to telephony */ 4743 newRadioState = RADIO_STATE_ON; 4744 } 4745 4746 return newRadioState; 4747 } 4748 4749 4750 #if defined(ANDROID_MULTI_SIM) 4751 extern "C" 4752 void RIL_onUnsolicitedResponse(int unsolResponse, const void *data, 4753 size_t datalen, RIL_SOCKET_ID socket_id) 4754 #else 4755 extern "C" 4756 void RIL_onUnsolicitedResponse(int unsolResponse, const void *data, 4757 size_t datalen) 4758 #endif 4759 { 4760 int unsolResponseIndex; 4761 int ret; 4762 int64_t timeReceived = 0; 4763 bool shouldScheduleTimeout = false; 4764 RIL_RadioState newState; 4765 RIL_SOCKET_ID soc_id = RIL_SOCKET_1; 4766 4767 #if defined(ANDROID_MULTI_SIM) 4768 soc_id = socket_id; 4769 #endif 4770 4771 4772 if (s_registerCalled == 0) { 4773 // Ignore RIL_onUnsolicitedResponse before RIL_register 4774 RLOGW("RIL_onUnsolicitedResponse called before RIL_register"); 4775 return; 4776 } 4777 4778 unsolResponseIndex = unsolResponse - RIL_UNSOL_RESPONSE_BASE; 4779 4780 if ((unsolResponseIndex < 0) 4781 || (unsolResponseIndex >= (int32_t)NUM_ELEMS(s_unsolResponses))) { 4782 RLOGE("unsupported unsolicited response code %d", unsolResponse); 4783 return; 4784 } 4785 4786 // Grab a wake lock if needed for this reponse, 4787 // as we exit we'll either release it immediately 4788 // or set a timer to release it later. 4789 switch (s_unsolResponses[unsolResponseIndex].wakeType) { 4790 case WAKE_PARTIAL: 4791 grabPartialWakeLock(); 4792 shouldScheduleTimeout = true; 4793 break; 4794 4795 case DONT_WAKE: 4796 default: 4797 // No wake lock is grabed so don't set timeout 4798 shouldScheduleTimeout = false; 4799 break; 4800 } 4801 4802 // Mark the time this was received, doing this 4803 // after grabing the wakelock incase getting 4804 // the elapsedRealTime might cause us to goto 4805 // sleep. 4806 if (unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) { 4807 timeReceived = elapsedRealtime(); 4808 } 4809 4810 appendPrintBuf("[UNSL]< %s", requestToString(unsolResponse)); 4811 4812 Parcel p; 4813 4814 p.writeInt32 (RESPONSE_UNSOLICITED); 4815 p.writeInt32 (unsolResponse); 4816 4817 ret = s_unsolResponses[unsolResponseIndex] 4818 .responseFunction(p, const_cast<void*>(data), datalen); 4819 if (ret != 0) { 4820 // Problem with the response. Don't continue; 4821 goto error_exit; 4822 } 4823 4824 // some things get more payload 4825 switch(unsolResponse) { 4826 case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: 4827 newState = processRadioState(CALL_ONSTATEREQUEST(soc_id), soc_id); 4828 p.writeInt32(newState); 4829 appendPrintBuf("%s {%s}", printBuf, 4830 radioStateToString(CALL_ONSTATEREQUEST(soc_id))); 4831 break; 4832 4833 4834 case RIL_UNSOL_NITZ_TIME_RECEIVED: 4835 // Store the time that this was received so the 4836 // handler of this message can account for 4837 // the time it takes to arrive and process. In 4838 // particular the system has been known to sleep 4839 // before this message can be processed. 4840 p.writeInt64(timeReceived); 4841 break; 4842 } 4843 4844 #if VDBG 4845 RLOGI("%s UNSOLICITED: %s length:%d", rilSocketIdToString(soc_id), requestToString(unsolResponse), p.dataSize()); 4846 #endif 4847 ret = sendResponse(p, soc_id); 4848 if (ret != 0 && unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) { 4849 4850 // Unfortunately, NITZ time is not poll/update like everything 4851 // else in the system. So, if the upstream client isn't connected, 4852 // keep a copy of the last NITZ response (with receive time noted 4853 // above) around so we can deliver it when it is connected 4854 4855 if (s_lastNITZTimeData != NULL) { 4856 free (s_lastNITZTimeData); 4857 s_lastNITZTimeData = NULL; 4858 } 4859 4860 s_lastNITZTimeData = malloc(p.dataSize()); 4861 s_lastNITZTimeDataSize = p.dataSize(); 4862 memcpy(s_lastNITZTimeData, p.data(), p.dataSize()); 4863 } 4864 4865 // For now, we automatically go back to sleep after TIMEVAL_WAKE_TIMEOUT 4866 // FIXME The java code should handshake here to release wake lock 4867 4868 if (shouldScheduleTimeout) { 4869 // Cancel the previous request 4870 if (s_last_wake_timeout_info != NULL) { 4871 s_last_wake_timeout_info->userParam = (void *)1; 4872 } 4873 4874 s_last_wake_timeout_info 4875 = internalRequestTimedCallback(wakeTimeoutCallback, NULL, 4876 &TIMEVAL_WAKE_TIMEOUT); 4877 } 4878 4879 // Normal exit 4880 return; 4881 4882 error_exit: 4883 if (shouldScheduleTimeout) { 4884 releaseWakeLock(); 4885 } 4886 } 4887 4888 /** FIXME generalize this if you track UserCAllbackInfo, clear it 4889 when the callback occurs 4890 */ 4891 static UserCallbackInfo * 4892 internalRequestTimedCallback (RIL_TimedCallback callback, void *param, 4893 const struct timeval *relativeTime) 4894 { 4895 struct timeval myRelativeTime; 4896 UserCallbackInfo *p_info; 4897 4898 p_info = (UserCallbackInfo *) malloc (sizeof(UserCallbackInfo)); 4899 4900 p_info->p_callback = callback; 4901 p_info->userParam = param; 4902 4903 if (relativeTime == NULL) { 4904 /* treat null parameter as a 0 relative time */ 4905 memset (&myRelativeTime, 0, sizeof(myRelativeTime)); 4906 } else { 4907 /* FIXME I think event_add's tv param is really const anyway */ 4908 memcpy (&myRelativeTime, relativeTime, sizeof(myRelativeTime)); 4909 } 4910 4911 ril_event_set(&(p_info->event), -1, false, userTimerCallback, p_info); 4912 4913 ril_timer_add(&(p_info->event), &myRelativeTime); 4914 4915 triggerEvLoop(); 4916 return p_info; 4917 } 4918 4919 4920 extern "C" void 4921 RIL_requestTimedCallback (RIL_TimedCallback callback, void *param, 4922 const struct timeval *relativeTime) { 4923 internalRequestTimedCallback (callback, param, relativeTime); 4924 } 4925 4926 const char * 4927 failCauseToString(RIL_Errno e) { 4928 switch(e) { 4929 case RIL_E_SUCCESS: return "E_SUCCESS"; 4930 case RIL_E_RADIO_NOT_AVAILABLE: return "E_RADIO_NOT_AVAILABLE"; 4931 case RIL_E_GENERIC_FAILURE: return "E_GENERIC_FAILURE"; 4932 case RIL_E_PASSWORD_INCORRECT: return "E_PASSWORD_INCORRECT"; 4933 case RIL_E_SIM_PIN2: return "E_SIM_PIN2"; 4934 case RIL_E_SIM_PUK2: return "E_SIM_PUK2"; 4935 case RIL_E_REQUEST_NOT_SUPPORTED: return "E_REQUEST_NOT_SUPPORTED"; 4936 case RIL_E_CANCELLED: return "E_CANCELLED"; 4937 case RIL_E_OP_NOT_ALLOWED_DURING_VOICE_CALL: return "E_OP_NOT_ALLOWED_DURING_VOICE_CALL"; 4938 case RIL_E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW: return "E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW"; 4939 case RIL_E_SMS_SEND_FAIL_RETRY: return "E_SMS_SEND_FAIL_RETRY"; 4940 case RIL_E_SIM_ABSENT:return "E_SIM_ABSENT"; 4941 case RIL_E_ILLEGAL_SIM_OR_ME:return "E_ILLEGAL_SIM_OR_ME"; 4942 #ifdef FEATURE_MULTIMODE_ANDROID 4943 case RIL_E_SUBSCRIPTION_NOT_AVAILABLE:return "E_SUBSCRIPTION_NOT_AVAILABLE"; 4944 case RIL_E_MODE_NOT_SUPPORTED:return "E_MODE_NOT_SUPPORTED"; 4945 #endif 4946 default: return "<unknown error>"; 4947 } 4948 } 4949 4950 const char * 4951 radioStateToString(RIL_RadioState s) { 4952 switch(s) { 4953 case RADIO_STATE_OFF: return "RADIO_OFF"; 4954 case RADIO_STATE_UNAVAILABLE: return "RADIO_UNAVAILABLE"; 4955 case RADIO_STATE_SIM_NOT_READY: return "RADIO_SIM_NOT_READY"; 4956 case RADIO_STATE_SIM_LOCKED_OR_ABSENT: return "RADIO_SIM_LOCKED_OR_ABSENT"; 4957 case RADIO_STATE_SIM_READY: return "RADIO_SIM_READY"; 4958 case RADIO_STATE_RUIM_NOT_READY:return"RADIO_RUIM_NOT_READY"; 4959 case RADIO_STATE_RUIM_READY:return"RADIO_RUIM_READY"; 4960 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:return"RADIO_RUIM_LOCKED_OR_ABSENT"; 4961 case RADIO_STATE_NV_NOT_READY:return"RADIO_NV_NOT_READY"; 4962 case RADIO_STATE_NV_READY:return"RADIO_NV_READY"; 4963 case RADIO_STATE_ON:return"RADIO_ON"; 4964 default: return "<unknown state>"; 4965 } 4966 } 4967 4968 const char * 4969 callStateToString(RIL_CallState s) { 4970 switch(s) { 4971 case RIL_CALL_ACTIVE : return "ACTIVE"; 4972 case RIL_CALL_HOLDING: return "HOLDING"; 4973 case RIL_CALL_DIALING: return "DIALING"; 4974 case RIL_CALL_ALERTING: return "ALERTING"; 4975 case RIL_CALL_INCOMING: return "INCOMING"; 4976 case RIL_CALL_WAITING: return "WAITING"; 4977 default: return "<unknown state>"; 4978 } 4979 } 4980 4981 const char * 4982 requestToString(int request) { 4983 /* 4984 cat libs/telephony/ril_commands.h \ 4985 | egrep "^ *{RIL_" \ 4986 | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/' 4987 4988 4989 cat libs/telephony/ril_unsol_commands.h \ 4990 | egrep "^ *{RIL_" \ 4991 | sed -re 's/\{RIL_([^,]+),([^}]+).+/case RIL_\1: return "\1";/' 4992 4993 */ 4994 switch(request) { 4995 case RIL_REQUEST_GET_SIM_STATUS: return "GET_SIM_STATUS"; 4996 case RIL_REQUEST_ENTER_SIM_PIN: return "ENTER_SIM_PIN"; 4997 case RIL_REQUEST_ENTER_SIM_PUK: return "ENTER_SIM_PUK"; 4998 case RIL_REQUEST_ENTER_SIM_PIN2: return "ENTER_SIM_PIN2"; 4999 case RIL_REQUEST_ENTER_SIM_PUK2: return "ENTER_SIM_PUK2"; 5000 case RIL_REQUEST_CHANGE_SIM_PIN: return "CHANGE_SIM_PIN"; 5001 case RIL_REQUEST_CHANGE_SIM_PIN2: return "CHANGE_SIM_PIN2"; 5002 case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: return "ENTER_NETWORK_DEPERSONALIZATION"; 5003 case RIL_REQUEST_GET_CURRENT_CALLS: return "GET_CURRENT_CALLS"; 5004 case RIL_REQUEST_DIAL: return "DIAL"; 5005 case RIL_REQUEST_GET_IMSI: return "GET_IMSI"; 5006 case RIL_REQUEST_HANGUP: return "HANGUP"; 5007 case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: return "HANGUP_WAITING_OR_BACKGROUND"; 5008 case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: return "HANGUP_FOREGROUND_RESUME_BACKGROUND"; 5009 case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: return "SWITCH_WAITING_OR_HOLDING_AND_ACTIVE"; 5010 case RIL_REQUEST_CONFERENCE: return "CONFERENCE"; 5011 case RIL_REQUEST_UDUB: return "UDUB"; 5012 case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: return "LAST_CALL_FAIL_CAUSE"; 5013 case RIL_REQUEST_SIGNAL_STRENGTH: return "SIGNAL_STRENGTH"; 5014 case RIL_REQUEST_VOICE_REGISTRATION_STATE: return "VOICE_REGISTRATION_STATE"; 5015 case RIL_REQUEST_DATA_REGISTRATION_STATE: return "DATA_REGISTRATION_STATE"; 5016 case RIL_REQUEST_OPERATOR: return "OPERATOR"; 5017 case RIL_REQUEST_RADIO_POWER: return "RADIO_POWER"; 5018 case RIL_REQUEST_DTMF: return "DTMF"; 5019 case RIL_REQUEST_SEND_SMS: return "SEND_SMS"; 5020 case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE"; 5021 case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL"; 5022 case RIL_REQUEST_SIM_IO: return "SIM_IO"; 5023 case RIL_REQUEST_SEND_USSD: return "SEND_USSD"; 5024 case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD"; 5025 case RIL_REQUEST_GET_CLIR: return "GET_CLIR"; 5026 case RIL_REQUEST_SET_CLIR: return "SET_CLIR"; 5027 case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: return "QUERY_CALL_FORWARD_STATUS"; 5028 case RIL_REQUEST_SET_CALL_FORWARD: return "SET_CALL_FORWARD"; 5029 case RIL_REQUEST_QUERY_CALL_WAITING: return "QUERY_CALL_WAITING"; 5030 case RIL_REQUEST_SET_CALL_WAITING: return "SET_CALL_WAITING"; 5031 case RIL_REQUEST_SMS_ACKNOWLEDGE: return "SMS_ACKNOWLEDGE"; 5032 case RIL_REQUEST_GET_IMEI: return "GET_IMEI"; 5033 case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV"; 5034 case RIL_REQUEST_ANSWER: return "ANSWER"; 5035 case RIL_REQUEST_DEACTIVATE_DATA_CALL: return "DEACTIVATE_DATA_CALL"; 5036 case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK"; 5037 case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK"; 5038 case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD"; 5039 case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: return "QUERY_NETWORK_SELECTION_MODE"; 5040 case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC"; 5041 case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL"; 5042 case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS "; 5043 case RIL_REQUEST_DTMF_START: return "DTMF_START"; 5044 case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP"; 5045 case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION"; 5046 case RIL_REQUEST_SEPARATE_CONNECTION: return "SEPARATE_CONNECTION"; 5047 case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: return "SET_PREFERRED_NETWORK_TYPE"; 5048 case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "GET_PREFERRED_NETWORK_TYPE"; 5049 case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "GET_NEIGHBORING_CELL_IDS"; 5050 case RIL_REQUEST_SET_MUTE: return "SET_MUTE"; 5051 case RIL_REQUEST_GET_MUTE: return "GET_MUTE"; 5052 case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP"; 5053 case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE"; 5054 case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST"; 5055 case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO"; 5056 case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW"; 5057 case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS"; 5058 case RIL_REQUEST_SET_BAND_MODE: return "SET_BAND_MODE"; 5059 case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: return "QUERY_AVAILABLE_BAND_MODE"; 5060 case RIL_REQUEST_STK_GET_PROFILE: return "STK_GET_PROFILE"; 5061 case RIL_REQUEST_STK_SET_PROFILE: return "STK_SET_PROFILE"; 5062 case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: return "STK_SEND_ENVELOPE_COMMAND"; 5063 case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: return "STK_SEND_TERMINAL_RESPONSE"; 5064 case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: return "STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM"; 5065 case RIL_REQUEST_SCREEN_STATE: return "SCREEN_STATE"; 5066 case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: return "EXPLICIT_CALL_TRANSFER"; 5067 case RIL_REQUEST_SET_LOCATION_UPDATES: return "SET_LOCATION_UPDATES"; 5068 case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:return"CDMA_SET_SUBSCRIPTION_SOURCE"; 5069 case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:return"CDMA_SET_ROAMING_PREFERENCE"; 5070 case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:return"CDMA_QUERY_ROAMING_PREFERENCE"; 5071 case RIL_REQUEST_SET_TTY_MODE:return"SET_TTY_MODE"; 5072 case RIL_REQUEST_QUERY_TTY_MODE:return"QUERY_TTY_MODE"; 5073 case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE"; 5074 case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE"; 5075 case RIL_REQUEST_CDMA_FLASH:return"CDMA_FLASH"; 5076 case RIL_REQUEST_CDMA_BURST_DTMF:return"CDMA_BURST_DTMF"; 5077 case RIL_REQUEST_CDMA_SEND_SMS:return"CDMA_SEND_SMS"; 5078 case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE:return"CDMA_SMS_ACKNOWLEDGE"; 5079 case RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG:return"GSM_GET_BROADCAST_SMS_CONFIG"; 5080 case RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG:return"GSM_SET_BROADCAST_SMS_CONFIG"; 5081 case RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG:return "CDMA_GET_BROADCAST_SMS_CONFIG"; 5082 case RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG:return "CDMA_SET_BROADCAST_SMS_CONFIG"; 5083 case RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION:return "CDMA_SMS_BROADCAST_ACTIVATION"; 5084 case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: return"CDMA_VALIDATE_AND_WRITE_AKEY"; 5085 case RIL_REQUEST_CDMA_SUBSCRIPTION: return"CDMA_SUBSCRIPTION"; 5086 case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: return "CDMA_WRITE_SMS_TO_RUIM"; 5087 case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: return "CDMA_DELETE_SMS_ON_RUIM"; 5088 case RIL_REQUEST_DEVICE_IDENTITY: return "DEVICE_IDENTITY"; 5089 case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: return "EXIT_EMERGENCY_CALLBACK_MODE"; 5090 case RIL_REQUEST_GET_SMSC_ADDRESS: return "GET_SMSC_ADDRESS"; 5091 case RIL_REQUEST_SET_SMSC_ADDRESS: return "SET_SMSC_ADDRESS"; 5092 case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: return "REPORT_SMS_MEMORY_STATUS"; 5093 case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: return "REPORT_STK_SERVICE_IS_RUNNING"; 5094 case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: return "CDMA_GET_SUBSCRIPTION_SOURCE"; 5095 case RIL_REQUEST_ISIM_AUTHENTICATION: return "ISIM_AUTHENTICATION"; 5096 case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU"; 5097 case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS"; 5098 case RIL_REQUEST_VOICE_RADIO_TECH: return "VOICE_RADIO_TECH"; 5099 case RIL_REQUEST_GET_CELL_INFO_LIST: return"GET_CELL_INFO_LIST"; 5100 case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: return"SET_UNSOL_CELL_INFO_LIST_RATE"; 5101 case RIL_REQUEST_SET_INITIAL_ATTACH_APN: return "RIL_REQUEST_SET_INITIAL_ATTACH_APN"; 5102 case RIL_REQUEST_IMS_REGISTRATION_STATE: return "IMS_REGISTRATION_STATE"; 5103 case RIL_REQUEST_IMS_SEND_SMS: return "IMS_SEND_SMS"; 5104 case RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC: return "SIM_TRANSMIT_APDU_BASIC"; 5105 case RIL_REQUEST_SIM_OPEN_CHANNEL: return "SIM_OPEN_CHANNEL"; 5106 case RIL_REQUEST_SIM_CLOSE_CHANNEL: return "SIM_CLOSE_CHANNEL"; 5107 case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: return "SIM_TRANSMIT_APDU_CHANNEL"; 5108 case RIL_REQUEST_GET_RADIO_CAPABILITY: return "RIL_REQUEST_GET_RADIO_CAPABILITY"; 5109 case RIL_REQUEST_SET_RADIO_CAPABILITY: return "RIL_REQUEST_SET_RADIO_CAPABILITY"; 5110 case RIL_REQUEST_SET_UICC_SUBSCRIPTION: return "SET_UICC_SUBSCRIPTION"; 5111 case RIL_REQUEST_ALLOW_DATA: return "ALLOW_DATA"; 5112 case RIL_REQUEST_GET_HARDWARE_CONFIG: return "GET_HARDWARE_CONFIG"; 5113 case RIL_REQUEST_SIM_AUTHENTICATION: return "SIM_AUTHENTICATION"; 5114 case RIL_REQUEST_GET_DC_RT_INFO: return "GET_DC_RT_INFO"; 5115 case RIL_REQUEST_SET_DC_RT_INFO_RATE: return "SET_DC_RT_INFO_RATE"; 5116 case RIL_REQUEST_SET_DATA_PROFILE: return "SET_DATA_PROFILE"; 5117 case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED"; 5118 case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED"; 5119 case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED"; 5120 case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS"; 5121 case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT"; 5122 case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM"; 5123 case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD"; 5124 case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)"; 5125 case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED"; 5126 case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH"; 5127 case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END"; 5128 case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND"; 5129 case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY"; 5130 case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP"; 5131 case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FUL"; 5132 case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH"; 5133 case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED"; 5134 case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING"; 5135 case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED"; 5136 case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_NEW_CDMA_SMS"; 5137 case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: return "UNSOL_NEW_BROADCAST_SMS"; 5138 case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL"; 5139 case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "UNSOL_RESTRICTED_STATE_CHANGED"; 5140 case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE"; 5141 case RIL_UNSOL_CDMA_CALL_WAITING: return "UNSOL_CDMA_CALL_WAITING"; 5142 case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: return "UNSOL_CDMA_OTA_PROVISION_STATUS"; 5143 case RIL_UNSOL_CDMA_INFO_REC: return "UNSOL_CDMA_INFO_REC"; 5144 case RIL_UNSOL_OEM_HOOK_RAW: return "UNSOL_OEM_HOOK_RAW"; 5145 case RIL_UNSOL_RINGBACK_TONE: return "UNSOL_RINGBACK_TONE"; 5146 case RIL_UNSOL_RESEND_INCALL_MUTE: return "UNSOL_RESEND_INCALL_MUTE"; 5147 case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: return "UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED"; 5148 case RIL_UNSOL_CDMA_PRL_CHANGED: return "UNSOL_CDMA_PRL_CHANGED"; 5149 case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE"; 5150 case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED"; 5151 case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: return "UNSOL_VOICE_RADIO_TECH_CHANGED"; 5152 case RIL_UNSOL_CELL_INFO_LIST: return "UNSOL_CELL_INFO_LIST"; 5153 case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED: return "RESPONSE_IMS_NETWORK_STATE_CHANGED"; 5154 case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED: return "UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED"; 5155 case RIL_UNSOL_SRVCC_STATE_NOTIFY: return "UNSOL_SRVCC_STATE_NOTIFY"; 5156 case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: return "HARDWARE_CONFIG_CHANGED"; 5157 case RIL_UNSOL_DC_RT_INFO_CHANGED: return "UNSOL_DC_RT_INFO_CHANGED"; 5158 case RIL_REQUEST_SHUTDOWN: return "SHUTDOWN"; 5159 case RIL_UNSOL_RADIO_CAPABILITY: return "RIL_UNSOL_RADIO_CAPABILITY"; 5160 default: return "<unknown request>"; 5161 } 5162 } 5163 5164 const char * 5165 rilSocketIdToString(RIL_SOCKET_ID socket_id) 5166 { 5167 switch(socket_id) { 5168 case RIL_SOCKET_1: 5169 return "RIL_SOCKET_1"; 5170 #if (SIM_COUNT >= 2) 5171 case RIL_SOCKET_2: 5172 return "RIL_SOCKET_2"; 5173 #endif 5174 #if (SIM_COUNT >= 3) 5175 case RIL_SOCKET_3: 5176 return "RIL_SOCKET_3"; 5177 #endif 5178 #if (SIM_COUNT >= 4) 5179 case RIL_SOCKET_4: 5180 return "RIL_SOCKET_4"; 5181 #endif 5182 default: 5183 return "not a valid RIL"; 5184 } 5185 } 5186 5187 } /* namespace android */ 5188 5189 void rilEventAddWakeup_helper(struct ril_event *ev) { 5190 android::rilEventAddWakeup(ev); 5191 } 5192 5193 void listenCallback_helper(int fd, short flags, void *param) { 5194 android::listenCallback(fd, flags, param); 5195 } 5196 5197 int blockingWrite_helper(int fd, void *buffer, size_t len) { 5198 return android::blockingWrite(fd, buffer, len); 5199 } 5200
