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 22#include <telephony/ril.h> 23#include <telephony/ril_cdma_sms.h> 24#include <cutils/sockets.h> 25#include <cutils/jstring.h> 26#include <cutils/record_stream.h> 27#include <utils/Log.h> 28#include <utils/SystemClock.h> 29#include <pthread.h> 30#include <binder/Parcel.h> 31#include <cutils/jstring.h> 32 33#include <sys/types.h> 34#include <pwd.h> 35 36#include <stdio.h> 37#include <stdlib.h> 38#include <stdarg.h> 39#include <string.h> 40#include <unistd.h> 41#include <fcntl.h> 42#include <time.h> 43#include <errno.h> 44#include <assert.h> 45#include <ctype.h> 46#include <alloca.h> 47#include <sys/un.h> 48#include <assert.h> 49#include <netinet/in.h> 50#include <cutils/properties.h> 51 52#include <ril_event.h> 53 54namespace android { 55 56#define PHONE_PROCESS "radio" 57 58#define SOCKET_NAME_RIL "rild" 59#define SOCKET_NAME_RIL_DEBUG "rild-debug" 60 61#define ANDROID_WAKE_LOCK_NAME "radio-interface" 62 63 64#define PROPERTY_RIL_IMPL "gsm.version.ril-impl" 65 66// match with constant in RIL.java 67#define MAX_COMMAND_BYTES (8 * 1024) 68 69// Basically: memset buffers that the client library 70// shouldn't be using anymore in an attempt to find 71// memory usage issues sooner. 72#define MEMSET_FREED 1 73 74#define NUM_ELEMS(a) (sizeof (a) / sizeof (a)[0]) 75 76#define MIN(a,b) ((a)<(b) ? (a) : (b)) 77 78/* Constants for response types */ 79#define RESPONSE_SOLICITED 0 80#define RESPONSE_UNSOLICITED 1 81 82/* Negative values for private RIL errno's */ 83#define RIL_ERRNO_INVALID_RESPONSE -1 84 85// request, response, and unsolicited msg print macro 86#define PRINTBUF_SIZE 8096 87 88// Enable RILC log 89#define RILC_LOG 0 90 91#if RILC_LOG 92 #define startRequest sprintf(printBuf, "(") 93 #define closeRequest sprintf(printBuf, "%s)", printBuf) 94 #define printRequest(token, req) \ 95 ALOGD("[%04d]> %s %s", token, requestToString(req), printBuf) 96 97 #define startResponse sprintf(printBuf, "%s {", printBuf) 98 #define closeResponse sprintf(printBuf, "%s}", printBuf) 99 #define printResponse ALOGD("%s", printBuf) 100 101 #define clearPrintBuf printBuf[0] = 0 102 #define removeLastChar printBuf[strlen(printBuf)-1] = 0 103 #define appendPrintBuf(x...) sprintf(printBuf, x) 104#else 105 #define startRequest 106 #define closeRequest 107 #define printRequest(token, req) 108 #define startResponse 109 #define closeResponse 110 #define printResponse 111 #define clearPrintBuf 112 #define removeLastChar 113 #define appendPrintBuf(x...) 114#endif 115 116enum WakeType {DONT_WAKE, WAKE_PARTIAL}; 117 118typedef struct { 119 int requestNumber; 120 void (*dispatchFunction) (Parcel &p, struct RequestInfo *pRI); 121 int(*responseFunction) (Parcel &p, void *response, size_t responselen); 122} CommandInfo; 123 124typedef struct { 125 int requestNumber; 126 int (*responseFunction) (Parcel &p, void *response, size_t responselen); 127 WakeType wakeType; 128} UnsolResponseInfo; 129 130typedef struct RequestInfo { 131 int32_t token; //this is not RIL_Token 132 CommandInfo *pCI; 133 struct RequestInfo *p_next; 134 char cancelled; 135 char local; // responses to local commands do not go back to command process 136} RequestInfo; 137 138typedef struct UserCallbackInfo { 139 RIL_TimedCallback p_callback; 140 void *userParam; 141 struct ril_event event; 142 struct UserCallbackInfo *p_next; 143} UserCallbackInfo; 144 145 146/*******************************************************************/ 147 148RIL_RadioFunctions s_callbacks = {0, NULL, NULL, NULL, NULL, NULL}; 149static int s_registerCalled = 0; 150 151static pthread_t s_tid_dispatch; 152static pthread_t s_tid_reader; 153static int s_started = 0; 154 155static int s_fdListen = -1; 156static int s_fdCommand = -1; 157static int s_fdDebug = -1; 158 159static int s_fdWakeupRead; 160static int s_fdWakeupWrite; 161 162static struct ril_event s_commands_event; 163static struct ril_event s_wakeupfd_event; 164static struct ril_event s_listen_event; 165static struct ril_event s_wake_timeout_event; 166static struct ril_event s_debug_event; 167 168 169static const struct timeval TIMEVAL_WAKE_TIMEOUT = {1,0}; 170 171static pthread_mutex_t s_pendingRequestsMutex = PTHREAD_MUTEX_INITIALIZER; 172static pthread_mutex_t s_writeMutex = PTHREAD_MUTEX_INITIALIZER; 173static pthread_mutex_t s_startupMutex = PTHREAD_MUTEX_INITIALIZER; 174static pthread_cond_t s_startupCond = PTHREAD_COND_INITIALIZER; 175 176static pthread_mutex_t s_dispatchMutex = PTHREAD_MUTEX_INITIALIZER; 177static pthread_cond_t s_dispatchCond = PTHREAD_COND_INITIALIZER; 178 179static RequestInfo *s_pendingRequests = NULL; 180 181static RequestInfo *s_toDispatchHead = NULL; 182static RequestInfo *s_toDispatchTail = NULL; 183 184static UserCallbackInfo *s_last_wake_timeout_info = NULL; 185 186static void *s_lastNITZTimeData = NULL; 187static size_t s_lastNITZTimeDataSize; 188 189#if RILC_LOG 190 static char printBuf[PRINTBUF_SIZE]; 191#endif 192 193/*******************************************************************/ 194 195static void dispatchVoid (Parcel& p, RequestInfo *pRI); 196static void dispatchString (Parcel& p, RequestInfo *pRI); 197static void dispatchStrings (Parcel& p, RequestInfo *pRI); 198static void dispatchInts (Parcel& p, RequestInfo *pRI); 199static void dispatchDial (Parcel& p, RequestInfo *pRI); 200static void dispatchSIM_IO (Parcel& p, RequestInfo *pRI); 201static void dispatchCallForward(Parcel& p, RequestInfo *pRI); 202static void dispatchRaw(Parcel& p, RequestInfo *pRI); 203static void dispatchSmsWrite (Parcel &p, RequestInfo *pRI); 204static void dispatchDataCall (Parcel& p, RequestInfo *pRI); 205static void dispatchVoiceRadioTech (Parcel& p, RequestInfo *pRI); 206static void dispatchCdmaSubscriptionSource (Parcel& p, RequestInfo *pRI); 207 208static void dispatchCdmaSms(Parcel &p, RequestInfo *pRI); 209static void dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI); 210static void dispatchGsmBrSmsCnf(Parcel &p, RequestInfo *pRI); 211static void dispatchCdmaBrSmsCnf(Parcel &p, RequestInfo *pRI); 212static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI); 213static int responseInts(Parcel &p, void *response, size_t responselen); 214static int responseStrings(Parcel &p, void *response, size_t responselen); 215static int responseString(Parcel &p, void *response, size_t responselen); 216static int responseVoid(Parcel &p, void *response, size_t responselen); 217static int responseCallList(Parcel &p, void *response, size_t responselen); 218static int responseSMS(Parcel &p, void *response, size_t responselen); 219static int responseSIM_IO(Parcel &p, void *response, size_t responselen); 220static int responseCallForwards(Parcel &p, void *response, size_t responselen); 221static int responseDataCallList(Parcel &p, void *response, size_t responselen); 222static int responseSetupDataCall(Parcel &p, void *response, size_t responselen); 223static int responseRaw(Parcel &p, void *response, size_t responselen); 224static int responseSsn(Parcel &p, void *response, size_t responselen); 225static int responseSimStatus(Parcel &p, void *response, size_t responselen); 226static int responseGsmBrSmsCnf(Parcel &p, void *response, size_t responselen); 227static int responseCdmaBrSmsCnf(Parcel &p, void *response, size_t responselen); 228static int responseCdmaSms(Parcel &p, void *response, size_t responselen); 229static int responseCellList(Parcel &p, void *response, size_t responselen); 230static int responseCdmaInformationRecords(Parcel &p,void *response, size_t responselen); 231static int responseRilSignalStrength(Parcel &p,void *response, size_t responselen); 232static int responseCallRing(Parcel &p, void *response, size_t responselen); 233static int responseCdmaSignalInfoRecord(Parcel &p,void *response, size_t responselen); 234static int responseCdmaCallWaiting(Parcel &p,void *response, size_t responselen); 235static int responseSimRefresh(Parcel &p, void *response, size_t responselen); 236 237static int decodeVoiceRadioTechnology (RIL_RadioState radioState); 238static int decodeCdmaSubscriptionSource (RIL_RadioState radioState); 239static RIL_RadioState processRadioState(RIL_RadioState newRadioState); 240 241extern "C" const char * requestToString(int request); 242extern "C" const char * failCauseToString(RIL_Errno); 243extern "C" const char * callStateToString(RIL_CallState); 244extern "C" const char * radioStateToString(RIL_RadioState); 245 246#ifdef RIL_SHLIB 247extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, void *data, 248 size_t datalen); 249#endif 250 251static UserCallbackInfo * internalRequestTimedCallback 252 (RIL_TimedCallback callback, void *param, 253 const struct timeval *relativeTime); 254 255/** Index == requestNumber */ 256static CommandInfo s_commands[] = { 257#include "ril_commands.h" 258}; 259 260static UnsolResponseInfo s_unsolResponses[] = { 261#include "ril_unsol_commands.h" 262}; 263 264/* For older RILs that do not support new commands RIL_REQUEST_VOICE_RADIO_TECH and 265 RIL_UNSOL_VOICE_RADIO_TECH_CHANGED messages, decode the voice radio tech from 266 radio state message and store it. Every time there is a change in Radio State 267 check to see if voice radio tech changes and notify telephony 268 */ 269int voiceRadioTech = -1; 270 271/* For older RILs that do not support new commands RIL_REQUEST_GET_CDMA_SUBSCRIPTION_SOURCE 272 and RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED messages, decode the subscription 273 source from radio state and store it. Every time there is a change in Radio State 274 check to see if subscription source changed and notify telephony 275 */ 276int cdmaSubscriptionSource = -1; 277 278/* For older RILs that do not send RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, decode the 279 SIM/RUIM state from radio state and store it. Every time there is a change in Radio State, 280 check to see if SIM/RUIM status changed and notify telephony 281 */ 282int simRuimStatus = -1; 283 284static char * 285strdupReadString(Parcel &p) { 286 size_t stringlen; 287 const char16_t *s16; 288 289 s16 = p.readString16Inplace(&stringlen); 290 291 return strndup16to8(s16, stringlen); 292} 293 294static void writeStringToParcel(Parcel &p, const char *s) { 295 char16_t *s16; 296 size_t s16_len; 297 s16 = strdup8to16(s, &s16_len); 298 p.writeString16(s16, s16_len); 299 free(s16); 300} 301 302 303static void 304memsetString (char *s) { 305 if (s != NULL) { 306 memset (s, 0, strlen(s)); 307 } 308} 309 310void nullParcelReleaseFunction (const uint8_t* data, size_t dataSize, 311 const size_t* objects, size_t objectsSize, 312 void* cookie) { 313 // do nothing -- the data reference lives longer than the Parcel object 314} 315 316/** 317 * To be called from dispatch thread 318 * Issue a single local request, ensuring that the response 319 * is not sent back up to the command process 320 */ 321static void 322issueLocalRequest(int request, void *data, int len) { 323 RequestInfo *pRI; 324 int ret; 325 326 pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo)); 327 328 pRI->local = 1; 329 pRI->token = 0xffffffff; // token is not used in this context 330 pRI->pCI = &(s_commands[request]); 331 332 ret = pthread_mutex_lock(&s_pendingRequestsMutex); 333 assert (ret == 0); 334 335 pRI->p_next = s_pendingRequests; 336 s_pendingRequests = pRI; 337 338 ret = pthread_mutex_unlock(&s_pendingRequestsMutex); 339 assert (ret == 0); 340 341 ALOGD("C[locl]> %s", requestToString(request)); 342 343 s_callbacks.onRequest(request, data, len, pRI); 344} 345 346 347 348static int 349processCommandBuffer(void *buffer, size_t buflen) { 350 Parcel p; 351 status_t status; 352 int32_t request; 353 int32_t token; 354 RequestInfo *pRI; 355 int ret; 356 357 p.setData((uint8_t *) buffer, buflen); 358 359 // status checked at end 360 status = p.readInt32(&request); 361 status = p.readInt32 (&token); 362 363 if (status != NO_ERROR) { 364 ALOGE("invalid request block"); 365 return 0; 366 } 367 368 if (request < 1 || request >= (int32_t)NUM_ELEMS(s_commands)) { 369 ALOGE("unsupported request code %d token %d", request, token); 370 // FIXME this should perhaps return a response 371 return 0; 372 } 373 374 375 pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo)); 376 377 pRI->token = token; 378 pRI->pCI = &(s_commands[request]); 379 380 ret = pthread_mutex_lock(&s_pendingRequestsMutex); 381 assert (ret == 0); 382 383 pRI->p_next = s_pendingRequests; 384 s_pendingRequests = pRI; 385 386 ret = pthread_mutex_unlock(&s_pendingRequestsMutex); 387 assert (ret == 0); 388 389/* sLastDispatchedToken = token; */ 390 391 pRI->pCI->dispatchFunction(p, pRI); 392 393 return 0; 394} 395 396static void 397invalidCommandBlock (RequestInfo *pRI) { 398 ALOGE("invalid command block for token %d request %s", 399 pRI->token, requestToString(pRI->pCI->requestNumber)); 400} 401 402/** Callee expects NULL */ 403static void 404dispatchVoid (Parcel& p, RequestInfo *pRI) { 405 clearPrintBuf; 406 printRequest(pRI->token, pRI->pCI->requestNumber); 407 s_callbacks.onRequest(pRI->pCI->requestNumber, NULL, 0, pRI); 408} 409 410/** Callee expects const char * */ 411static void 412dispatchString (Parcel& p, RequestInfo *pRI) { 413 status_t status; 414 size_t datalen; 415 size_t stringlen; 416 char *string8 = NULL; 417 418 string8 = strdupReadString(p); 419 420 startRequest; 421 appendPrintBuf("%s%s", printBuf, string8); 422 closeRequest; 423 printRequest(pRI->token, pRI->pCI->requestNumber); 424 425 s_callbacks.onRequest(pRI->pCI->requestNumber, string8, 426 sizeof(char *), pRI); 427 428#ifdef MEMSET_FREED 429 memsetString(string8); 430#endif 431 432 free(string8); 433 return; 434invalid: 435 invalidCommandBlock(pRI); 436 return; 437} 438 439/** Callee expects const char ** */ 440static void 441dispatchStrings (Parcel &p, RequestInfo *pRI) { 442 int32_t countStrings; 443 status_t status; 444 size_t datalen; 445 char **pStrings; 446 447 status = p.readInt32 (&countStrings); 448 449 if (status != NO_ERROR) { 450 goto invalid; 451 } 452 453 startRequest; 454 if (countStrings == 0) { 455 // just some non-null pointer 456 pStrings = (char **)alloca(sizeof(char *)); 457 datalen = 0; 458 } else if (((int)countStrings) == -1) { 459 pStrings = NULL; 460 datalen = 0; 461 } else { 462 datalen = sizeof(char *) * countStrings; 463 464 pStrings = (char **)alloca(datalen); 465 466 for (int i = 0 ; i < countStrings ; i++) { 467 pStrings[i] = strdupReadString(p); 468 appendPrintBuf("%s%s,", printBuf, pStrings[i]); 469 } 470 } 471 removeLastChar; 472 closeRequest; 473 printRequest(pRI->token, pRI->pCI->requestNumber); 474 475 s_callbacks.onRequest(pRI->pCI->requestNumber, pStrings, datalen, pRI); 476 477 if (pStrings != NULL) { 478 for (int i = 0 ; i < countStrings ; i++) { 479#ifdef MEMSET_FREED 480 memsetString (pStrings[i]); 481#endif 482 free(pStrings[i]); 483 } 484 485#ifdef MEMSET_FREED 486 memset(pStrings, 0, datalen); 487#endif 488 } 489 490 return; 491invalid: 492 invalidCommandBlock(pRI); 493 return; 494} 495 496/** Callee expects const int * */ 497static void 498dispatchInts (Parcel &p, RequestInfo *pRI) { 499 int32_t count; 500 status_t status; 501 size_t datalen; 502 int *pInts; 503 504 status = p.readInt32 (&count); 505 506 if (status != NO_ERROR || count == 0) { 507 goto invalid; 508 } 509 510 datalen = sizeof(int) * count; 511 pInts = (int *)alloca(datalen); 512 513 startRequest; 514 for (int i = 0 ; i < count ; i++) { 515 int32_t t; 516 517 status = p.readInt32(&t); 518 pInts[i] = (int)t; 519 appendPrintBuf("%s%d,", printBuf, t); 520 521 if (status != NO_ERROR) { 522 goto invalid; 523 } 524 } 525 removeLastChar; 526 closeRequest; 527 printRequest(pRI->token, pRI->pCI->requestNumber); 528 529 s_callbacks.onRequest(pRI->pCI->requestNumber, const_cast<int *>(pInts), 530 datalen, pRI); 531 532#ifdef MEMSET_FREED 533 memset(pInts, 0, datalen); 534#endif 535 536 return; 537invalid: 538 invalidCommandBlock(pRI); 539 return; 540} 541 542 543/** 544 * Callee expects const RIL_SMS_WriteArgs * 545 * Payload is: 546 * int32_t status 547 * String pdu 548 */ 549static void 550dispatchSmsWrite (Parcel &p, RequestInfo *pRI) { 551 RIL_SMS_WriteArgs args; 552 int32_t t; 553 status_t status; 554 555 memset (&args, 0, sizeof(args)); 556 557 status = p.readInt32(&t); 558 args.status = (int)t; 559 560 args.pdu = strdupReadString(p); 561 562 if (status != NO_ERROR || args.pdu == NULL) { 563 goto invalid; 564 } 565 566 args.smsc = strdupReadString(p); 567 568 startRequest; 569 appendPrintBuf("%s%d,%s,smsc=%s", printBuf, args.status, 570 (char*)args.pdu, (char*)args.smsc); 571 closeRequest; 572 printRequest(pRI->token, pRI->pCI->requestNumber); 573 574 s_callbacks.onRequest(pRI->pCI->requestNumber, &args, sizeof(args), pRI); 575 576#ifdef MEMSET_FREED 577 memsetString (args.pdu); 578#endif 579 580 free (args.pdu); 581 582#ifdef MEMSET_FREED 583 memset(&args, 0, sizeof(args)); 584#endif 585 586 return; 587invalid: 588 invalidCommandBlock(pRI); 589 return; 590} 591 592/** 593 * Callee expects const RIL_Dial * 594 * Payload is: 595 * String address 596 * int32_t clir 597 */ 598static void 599dispatchDial (Parcel &p, RequestInfo *pRI) { 600 RIL_Dial dial; 601 RIL_UUS_Info uusInfo; 602 int32_t sizeOfDial; 603 int32_t t; 604 int32_t uusPresent; 605 status_t status; 606 607 memset (&dial, 0, sizeof(dial)); 608 609 dial.address = strdupReadString(p); 610 611 status = p.readInt32(&t); 612 dial.clir = (int)t; 613 614 if (status != NO_ERROR || dial.address == NULL) { 615 goto invalid; 616 } 617 618 if (s_callbacks.version < 3) { // Remove when partners upgrade to version 3 619 uusPresent = 0; 620 sizeOfDial = sizeof(dial) - sizeof(RIL_UUS_Info *); 621 } else { 622 status = p.readInt32(&uusPresent); 623 624 if (status != NO_ERROR) { 625 goto invalid; 626 } 627 628 if (uusPresent == 0) { 629 dial.uusInfo = NULL; 630 } else { 631 int32_t len; 632 633 memset(&uusInfo, 0, sizeof(RIL_UUS_Info)); 634 635 status = p.readInt32(&t); 636 uusInfo.uusType = (RIL_UUS_Type) t; 637 638 status = p.readInt32(&t); 639 uusInfo.uusDcs = (RIL_UUS_DCS) t; 640 641 status = p.readInt32(&len); 642 if (status != NO_ERROR) { 643 goto invalid; 644 } 645 646 // The java code writes -1 for null arrays 647 if (((int) len) == -1) { 648 uusInfo.uusData = NULL; 649 len = 0; 650 } else { 651 uusInfo.uusData = (char*) p.readInplace(len); 652 } 653 654 uusInfo.uusLength = len; 655 dial.uusInfo = &uusInfo; 656 } 657 sizeOfDial = sizeof(dial); 658 } 659 660 startRequest; 661 appendPrintBuf("%snum=%s,clir=%d", printBuf, dial.address, dial.clir); 662 if (uusPresent) { 663 appendPrintBuf("%s,uusType=%d,uusDcs=%d,uusLen=%d", printBuf, 664 dial.uusInfo->uusType, dial.uusInfo->uusDcs, 665 dial.uusInfo->uusLength); 666 } 667 closeRequest; 668 printRequest(pRI->token, pRI->pCI->requestNumber); 669 670 s_callbacks.onRequest(pRI->pCI->requestNumber, &dial, sizeOfDial, pRI); 671 672#ifdef MEMSET_FREED 673 memsetString (dial.address); 674#endif 675 676 free (dial.address); 677 678#ifdef MEMSET_FREED 679 memset(&uusInfo, 0, sizeof(RIL_UUS_Info)); 680 memset(&dial, 0, sizeof(dial)); 681#endif 682 683 return; 684invalid: 685 invalidCommandBlock(pRI); 686 return; 687} 688 689/** 690 * Callee expects const RIL_SIM_IO * 691 * Payload is: 692 * int32_t command 693 * int32_t fileid 694 * String path 695 * int32_t p1, p2, p3 696 * String data 697 * String pin2 698 * String aidPtr 699 */ 700static void 701dispatchSIM_IO (Parcel &p, RequestInfo *pRI) { 702 union RIL_SIM_IO { 703 RIL_SIM_IO_v6 v6; 704 RIL_SIM_IO_v5 v5; 705 } simIO; 706 707 int32_t t; 708 int size; 709 status_t status; 710 711 memset (&simIO, 0, sizeof(simIO)); 712 713 // note we only check status at the end 714 715 status = p.readInt32(&t); 716 simIO.v6.command = (int)t; 717 718 status = p.readInt32(&t); 719 simIO.v6.fileid = (int)t; 720 721 simIO.v6.path = strdupReadString(p); 722 723 status = p.readInt32(&t); 724 simIO.v6.p1 = (int)t; 725 726 status = p.readInt32(&t); 727 simIO.v6.p2 = (int)t; 728 729 status = p.readInt32(&t); 730 simIO.v6.p3 = (int)t; 731 732 simIO.v6.data = strdupReadString(p); 733 simIO.v6.pin2 = strdupReadString(p); 734 simIO.v6.aidPtr = strdupReadString(p); 735 736 startRequest; 737 appendPrintBuf("%scmd=0x%X,efid=0x%X,path=%s,%d,%d,%d,%s,pin2=%s,aid=%s", printBuf, 738 simIO.v6.command, simIO.v6.fileid, (char*)simIO.v6.path, 739 simIO.v6.p1, simIO.v6.p2, simIO.v6.p3, 740 (char*)simIO.v6.data, (char*)simIO.v6.pin2, simIO.v6.aidPtr); 741 closeRequest; 742 printRequest(pRI->token, pRI->pCI->requestNumber); 743 744 if (status != NO_ERROR) { 745 goto invalid; 746 } 747 748 size = (s_callbacks.version < 6) ? sizeof(simIO.v5) : sizeof(simIO.v6); 749 s_callbacks.onRequest(pRI->pCI->requestNumber, &simIO, size, pRI); 750 751#ifdef MEMSET_FREED 752 memsetString (simIO.v6.path); 753 memsetString (simIO.v6.data); 754 memsetString (simIO.v6.pin2); 755 memsetString (simIO.v6.aidPtr); 756#endif 757 758 free (simIO.v6.path); 759 free (simIO.v6.data); 760 free (simIO.v6.pin2); 761 free (simIO.v6.aidPtr); 762 763#ifdef MEMSET_FREED 764 memset(&simIO, 0, sizeof(simIO)); 765#endif 766 767 return; 768invalid: 769 invalidCommandBlock(pRI); 770 return; 771} 772 773/** 774 * Callee expects const RIL_CallForwardInfo * 775 * Payload is: 776 * int32_t status/action 777 * int32_t reason 778 * int32_t serviceCode 779 * int32_t toa 780 * String number (0 length -> null) 781 * int32_t timeSeconds 782 */ 783static void 784dispatchCallForward(Parcel &p, RequestInfo *pRI) { 785 RIL_CallForwardInfo cff; 786 int32_t t; 787 status_t status; 788 789 memset (&cff, 0, sizeof(cff)); 790 791 // note we only check status at the end 792 793 status = p.readInt32(&t); 794 cff.status = (int)t; 795 796 status = p.readInt32(&t); 797 cff.reason = (int)t; 798 799 status = p.readInt32(&t); 800 cff.serviceClass = (int)t; 801 802 status = p.readInt32(&t); 803 cff.toa = (int)t; 804 805 cff.number = strdupReadString(p); 806 807 status = p.readInt32(&t); 808 cff.timeSeconds = (int)t; 809 810 if (status != NO_ERROR) { 811 goto invalid; 812 } 813 814 // special case: number 0-length fields is null 815 816 if (cff.number != NULL && strlen (cff.number) == 0) { 817 cff.number = NULL; 818 } 819 820 startRequest; 821 appendPrintBuf("%sstat=%d,reason=%d,serv=%d,toa=%d,%s,tout=%d", printBuf, 822 cff.status, cff.reason, cff.serviceClass, cff.toa, 823 (char*)cff.number, cff.timeSeconds); 824 closeRequest; 825 printRequest(pRI->token, pRI->pCI->requestNumber); 826 827 s_callbacks.onRequest(pRI->pCI->requestNumber, &cff, sizeof(cff), pRI); 828 829#ifdef MEMSET_FREED 830 memsetString(cff.number); 831#endif 832 833 free (cff.number); 834 835#ifdef MEMSET_FREED 836 memset(&cff, 0, sizeof(cff)); 837#endif 838 839 return; 840invalid: 841 invalidCommandBlock(pRI); 842 return; 843} 844 845 846static void 847dispatchRaw(Parcel &p, RequestInfo *pRI) { 848 int32_t len; 849 status_t status; 850 const void *data; 851 852 status = p.readInt32(&len); 853 854 if (status != NO_ERROR) { 855 goto invalid; 856 } 857 858 // The java code writes -1 for null arrays 859 if (((int)len) == -1) { 860 data = NULL; 861 len = 0; 862 } 863 864 data = p.readInplace(len); 865 866 startRequest; 867 appendPrintBuf("%sraw_size=%d", printBuf, len); 868 closeRequest; 869 printRequest(pRI->token, pRI->pCI->requestNumber); 870 871 s_callbacks.onRequest(pRI->pCI->requestNumber, const_cast<void *>(data), len, pRI); 872 873 return; 874invalid: 875 invalidCommandBlock(pRI); 876 return; 877} 878 879static void 880dispatchCdmaSms(Parcel &p, RequestInfo *pRI) { 881 RIL_CDMA_SMS_Message rcsm; 882 int32_t t; 883 uint8_t ut; 884 status_t status; 885 int32_t digitCount; 886 int digitLimit; 887 888 memset(&rcsm, 0, sizeof(rcsm)); 889 890 status = p.readInt32(&t); 891 rcsm.uTeleserviceID = (int) t; 892 893 status = p.read(&ut,sizeof(ut)); 894 rcsm.bIsServicePresent = (uint8_t) ut; 895 896 status = p.readInt32(&t); 897 rcsm.uServicecategory = (int) t; 898 899 status = p.readInt32(&t); 900 rcsm.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) t; 901 902 status = p.readInt32(&t); 903 rcsm.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) t; 904 905 status = p.readInt32(&t); 906 rcsm.sAddress.number_type = (RIL_CDMA_SMS_NumberType) t; 907 908 status = p.readInt32(&t); 909 rcsm.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) t; 910 911 status = p.read(&ut,sizeof(ut)); 912 rcsm.sAddress.number_of_digits= (uint8_t) ut; 913 914 digitLimit= MIN((rcsm.sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX); 915 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) { 916 status = p.read(&ut,sizeof(ut)); 917 rcsm.sAddress.digits[digitCount] = (uint8_t) ut; 918 } 919 920 status = p.readInt32(&t); 921 rcsm.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) t; 922 923 status = p.read(&ut,sizeof(ut)); 924 rcsm.sSubAddress.odd = (uint8_t) ut; 925 926 status = p.read(&ut,sizeof(ut)); 927 rcsm.sSubAddress.number_of_digits = (uint8_t) ut; 928 929 digitLimit= MIN((rcsm.sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX); 930 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) { 931 status = p.read(&ut,sizeof(ut)); 932 rcsm.sSubAddress.digits[digitCount] = (uint8_t) ut; 933 } 934 935 status = p.readInt32(&t); 936 rcsm.uBearerDataLen = (int) t; 937 938 digitLimit= MIN((rcsm.uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX); 939 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) { 940 status = p.read(&ut, sizeof(ut)); 941 rcsm.aBearerData[digitCount] = (uint8_t) ut; 942 } 943 944 if (status != NO_ERROR) { 945 goto invalid; 946 } 947 948 startRequest; 949 appendPrintBuf("%suTeleserviceID=%d, bIsServicePresent=%d, uServicecategory=%d, \ 950 sAddress.digit_mode=%d, sAddress.Number_mode=%d, sAddress.number_type=%d, ", 951 printBuf, rcsm.uTeleserviceID,rcsm.bIsServicePresent,rcsm.uServicecategory, 952 rcsm.sAddress.digit_mode, rcsm.sAddress.number_mode,rcsm.sAddress.number_type); 953 closeRequest; 954 955 printRequest(pRI->token, pRI->pCI->requestNumber); 956 957 s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsm, sizeof(rcsm),pRI); 958 959#ifdef MEMSET_FREED 960 memset(&rcsm, 0, sizeof(rcsm)); 961#endif 962 963 return; 964 965invalid: 966 invalidCommandBlock(pRI); 967 return; 968} 969 970static void 971dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI) { 972 RIL_CDMA_SMS_Ack rcsa; 973 int32_t t; 974 status_t status; 975 int32_t digitCount; 976 977 memset(&rcsa, 0, sizeof(rcsa)); 978 979 status = p.readInt32(&t); 980 rcsa.uErrorClass = (RIL_CDMA_SMS_ErrorClass) t; 981 982 status = p.readInt32(&t); 983 rcsa.uSMSCauseCode = (int) t; 984 985 if (status != NO_ERROR) { 986 goto invalid; 987 } 988 989 startRequest; 990 appendPrintBuf("%suErrorClass=%d, uTLStatus=%d, ", 991 printBuf, rcsa.uErrorClass, rcsa.uSMSCauseCode); 992 closeRequest; 993 994 printRequest(pRI->token, pRI->pCI->requestNumber); 995 996 s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsa, sizeof(rcsa),pRI); 997 998#ifdef MEMSET_FREED 999 memset(&rcsa, 0, sizeof(rcsa)); 1000#endif 1001 1002 return; 1003 1004invalid: 1005 invalidCommandBlock(pRI); 1006 return; 1007} 1008 1009static void 1010dispatchGsmBrSmsCnf(Parcel &p, RequestInfo *pRI) { 1011 int32_t t; 1012 status_t status; 1013 int32_t num; 1014 1015 status = p.readInt32(&num); 1016 if (status != NO_ERROR) { 1017 goto invalid; 1018 } 1019 1020 { 1021 RIL_GSM_BroadcastSmsConfigInfo gsmBci[num]; 1022 RIL_GSM_BroadcastSmsConfigInfo *gsmBciPtrs[num]; 1023 1024 startRequest; 1025 for (int i = 0 ; i < num ; i++ ) { 1026 gsmBciPtrs[i] = &gsmBci[i]; 1027 1028 status = p.readInt32(&t); 1029 gsmBci[i].fromServiceId = (int) t; 1030 1031 status = p.readInt32(&t); 1032 gsmBci[i].toServiceId = (int) t; 1033 1034 status = p.readInt32(&t); 1035 gsmBci[i].fromCodeScheme = (int) t; 1036 1037 status = p.readInt32(&t); 1038 gsmBci[i].toCodeScheme = (int) t; 1039 1040 status = p.readInt32(&t); 1041 gsmBci[i].selected = (uint8_t) t; 1042 1043 appendPrintBuf("%s [%d: fromServiceId=%d, toServiceId =%d, \ 1044 fromCodeScheme=%d, toCodeScheme=%d, selected =%d]", printBuf, i, 1045 gsmBci[i].fromServiceId, gsmBci[i].toServiceId, 1046 gsmBci[i].fromCodeScheme, gsmBci[i].toCodeScheme, 1047 gsmBci[i].selected); 1048 } 1049 closeRequest; 1050 1051 if (status != NO_ERROR) { 1052 goto invalid; 1053 } 1054 1055 s_callbacks.onRequest(pRI->pCI->requestNumber, 1056 gsmBciPtrs, 1057 num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *), 1058 pRI); 1059 1060#ifdef MEMSET_FREED 1061 memset(gsmBci, 0, num * sizeof(RIL_GSM_BroadcastSmsConfigInfo)); 1062 memset(gsmBciPtrs, 0, num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *)); 1063#endif 1064 } 1065 1066 return; 1067 1068invalid: 1069 invalidCommandBlock(pRI); 1070 return; 1071} 1072 1073static void 1074dispatchCdmaBrSmsCnf(Parcel &p, RequestInfo *pRI) { 1075 int32_t t; 1076 status_t status; 1077 int32_t num; 1078 1079 status = p.readInt32(&num); 1080 if (status != NO_ERROR) { 1081 goto invalid; 1082 } 1083 1084 { 1085 RIL_CDMA_BroadcastSmsConfigInfo cdmaBci[num]; 1086 RIL_CDMA_BroadcastSmsConfigInfo *cdmaBciPtrs[num]; 1087 1088 startRequest; 1089 for (int i = 0 ; i < num ; i++ ) { 1090 cdmaBciPtrs[i] = &cdmaBci[i]; 1091 1092 status = p.readInt32(&t); 1093 cdmaBci[i].service_category = (int) t; 1094 1095 status = p.readInt32(&t); 1096 cdmaBci[i].language = (int) t; 1097 1098 status = p.readInt32(&t); 1099 cdmaBci[i].selected = (uint8_t) t; 1100 1101 appendPrintBuf("%s [%d: service_category=%d, language =%d, \ 1102 entries.bSelected =%d]", printBuf, i, cdmaBci[i].service_category, 1103 cdmaBci[i].language, cdmaBci[i].selected); 1104 } 1105 closeRequest; 1106 1107 if (status != NO_ERROR) { 1108 goto invalid; 1109 } 1110 1111 s_callbacks.onRequest(pRI->pCI->requestNumber, 1112 cdmaBciPtrs, 1113 num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *), 1114 pRI); 1115 1116#ifdef MEMSET_FREED 1117 memset(cdmaBci, 0, num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo)); 1118 memset(cdmaBciPtrs, 0, num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *)); 1119#endif 1120 } 1121 1122 return; 1123 1124invalid: 1125 invalidCommandBlock(pRI); 1126 return; 1127} 1128 1129static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI) { 1130 RIL_CDMA_SMS_WriteArgs rcsw; 1131 int32_t t; 1132 uint32_t ut; 1133 uint8_t uct; 1134 status_t status; 1135 int32_t digitCount; 1136 1137 memset(&rcsw, 0, sizeof(rcsw)); 1138 1139 status = p.readInt32(&t); 1140 rcsw.status = t; 1141 1142 status = p.readInt32(&t); 1143 rcsw.message.uTeleserviceID = (int) t; 1144 1145 status = p.read(&uct,sizeof(uct)); 1146 rcsw.message.bIsServicePresent = (uint8_t) uct; 1147 1148 status = p.readInt32(&t); 1149 rcsw.message.uServicecategory = (int) t; 1150 1151 status = p.readInt32(&t); 1152 rcsw.message.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) t; 1153 1154 status = p.readInt32(&t); 1155 rcsw.message.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) t; 1156 1157 status = p.readInt32(&t); 1158 rcsw.message.sAddress.number_type = (RIL_CDMA_SMS_NumberType) t; 1159 1160 status = p.readInt32(&t); 1161 rcsw.message.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) t; 1162 1163 status = p.read(&uct,sizeof(uct)); 1164 rcsw.message.sAddress.number_of_digits = (uint8_t) uct; 1165 1166 for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_ADDRESS_MAX; digitCount ++) { 1167 status = p.read(&uct,sizeof(uct)); 1168 rcsw.message.sAddress.digits[digitCount] = (uint8_t) uct; 1169 } 1170 1171 status = p.readInt32(&t); 1172 rcsw.message.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) t; 1173 1174 status = p.read(&uct,sizeof(uct)); 1175 rcsw.message.sSubAddress.odd = (uint8_t) uct; 1176 1177 status = p.read(&uct,sizeof(uct)); 1178 rcsw.message.sSubAddress.number_of_digits = (uint8_t) uct; 1179 1180 for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_SUBADDRESS_MAX; digitCount ++) { 1181 status = p.read(&uct,sizeof(uct)); 1182 rcsw.message.sSubAddress.digits[digitCount] = (uint8_t) uct; 1183 } 1184 1185 status = p.readInt32(&t); 1186 rcsw.message.uBearerDataLen = (int) t; 1187 1188 for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_BEARER_DATA_MAX; digitCount ++) { 1189 status = p.read(&uct, sizeof(uct)); 1190 rcsw.message.aBearerData[digitCount] = (uint8_t) uct; 1191 } 1192 1193 if (status != NO_ERROR) { 1194 goto invalid; 1195 } 1196 1197 startRequest; 1198 appendPrintBuf("%sstatus=%d, message.uTeleserviceID=%d, message.bIsServicePresent=%d, \ 1199 message.uServicecategory=%d, message.sAddress.digit_mode=%d, \ 1200 message.sAddress.number_mode=%d, \ 1201 message.sAddress.number_type=%d, ", 1202 printBuf, rcsw.status, rcsw.message.uTeleserviceID, rcsw.message.bIsServicePresent, 1203 rcsw.message.uServicecategory, rcsw.message.sAddress.digit_mode, 1204 rcsw.message.sAddress.number_mode, 1205 rcsw.message.sAddress.number_type); 1206 closeRequest; 1207 1208 printRequest(pRI->token, pRI->pCI->requestNumber); 1209 1210 s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsw, sizeof(rcsw),pRI); 1211 1212#ifdef MEMSET_FREED 1213 memset(&rcsw, 0, sizeof(rcsw)); 1214#endif 1215 1216 return; 1217 1218invalid: 1219 invalidCommandBlock(pRI); 1220 return; 1221 1222} 1223 1224// For backwards compatibility in RIL_REQUEST_SETUP_DATA_CALL. 1225// Version 4 of the RIL interface adds a new PDP type parameter to support 1226// IPv6 and dual-stack PDP contexts. When dealing with a previous version of 1227// RIL, remove the parameter from the request. 1228static void dispatchDataCall(Parcel& p, RequestInfo *pRI) { 1229 // In RIL v3, REQUEST_SETUP_DATA_CALL takes 6 parameters. 1230 const int numParamsRilV3 = 6; 1231 1232 // The first bytes of the RIL parcel contain the request number and the 1233 // serial number - see processCommandBuffer(). Copy them over too. 1234 int pos = p.dataPosition(); 1235 1236 int numParams = p.readInt32(); 1237 if (s_callbacks.version < 4 && numParams > numParamsRilV3) { 1238 Parcel p2; 1239 p2.appendFrom(&p, 0, pos); 1240 p2.writeInt32(numParamsRilV3); 1241 for(int i = 0; i < numParamsRilV3; i++) { 1242 p2.writeString16(p.readString16()); 1243 } 1244 p2.setDataPosition(pos); 1245 dispatchStrings(p2, pRI); 1246 } else { 1247 p.setDataPosition(pos); 1248 dispatchStrings(p, pRI); 1249 } 1250} 1251 1252// For backwards compatibility with RILs that dont support RIL_REQUEST_VOICE_RADIO_TECH. 1253// When all RILs handle this request, this function can be removed and 1254// the request can be sent directly to the RIL using dispatchVoid. 1255static void dispatchVoiceRadioTech(Parcel& p, RequestInfo *pRI) { 1256 RIL_RadioState state = s_callbacks.onStateRequest(); 1257 1258 if ((RADIO_STATE_UNAVAILABLE == state) || (RADIO_STATE_OFF == state)) { 1259 RIL_onRequestComplete(pRI, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); 1260 } 1261 1262 // RILs that support RADIO_STATE_ON should support this request. 1263 if (RADIO_STATE_ON == state) { 1264 dispatchVoid(p, pRI); 1265 return; 1266 } 1267 1268 // For Older RILs, that do not support RADIO_STATE_ON, assume that they 1269 // will not support this new request either and decode Voice Radio Technology 1270 // from Radio State 1271 voiceRadioTech = decodeVoiceRadioTechnology(state); 1272 1273 if (voiceRadioTech < 0) 1274 RIL_onRequestComplete(pRI, RIL_E_GENERIC_FAILURE, NULL, 0); 1275 else 1276 RIL_onRequestComplete(pRI, RIL_E_SUCCESS, &voiceRadioTech, sizeof(int)); 1277} 1278 1279// For backwards compatibility in RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE:. 1280// When all RILs handle this request, this function can be removed and 1281// the request can be sent directly to the RIL using dispatchVoid. 1282static void dispatchCdmaSubscriptionSource(Parcel& p, RequestInfo *pRI) { 1283 RIL_RadioState state = s_callbacks.onStateRequest(); 1284 1285 if ((RADIO_STATE_UNAVAILABLE == state) || (RADIO_STATE_OFF == state)) { 1286 RIL_onRequestComplete(pRI, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); 1287 } 1288 1289 // RILs that support RADIO_STATE_ON should support this request. 1290 if (RADIO_STATE_ON == state) { 1291 dispatchVoid(p, pRI); 1292 return; 1293 } 1294 1295 // For Older RILs, that do not support RADIO_STATE_ON, assume that they 1296 // will not support this new request either and decode CDMA Subscription Source 1297 // from Radio State 1298 cdmaSubscriptionSource = decodeCdmaSubscriptionSource(state); 1299 1300 if (cdmaSubscriptionSource < 0) 1301 RIL_onRequestComplete(pRI, RIL_E_GENERIC_FAILURE, NULL, 0); 1302 else 1303 RIL_onRequestComplete(pRI, RIL_E_SUCCESS, &cdmaSubscriptionSource, sizeof(int)); 1304} 1305 1306static int 1307blockingWrite(int fd, const void *buffer, size_t len) { 1308 size_t writeOffset = 0; 1309 const uint8_t *toWrite; 1310 1311 toWrite = (const uint8_t *)buffer; 1312 1313 while (writeOffset < len) { 1314 ssize_t written; 1315 do { 1316 written = write (fd, toWrite + writeOffset, 1317 len - writeOffset); 1318 } while (written < 0 && errno == EINTR); 1319 1320 if (written >= 0) { 1321 writeOffset += written; 1322 } else { // written < 0 1323 ALOGE ("RIL Response: unexpected error on write errno:%d", errno); 1324 close(fd); 1325 return -1; 1326 } 1327 } 1328 1329 return 0; 1330} 1331 1332static int 1333sendResponseRaw (const void *data, size_t dataSize) { 1334 int fd = s_fdCommand; 1335 int ret; 1336 uint32_t header; 1337 1338 if (s_fdCommand < 0) { 1339 return -1; 1340 } 1341 1342 if (dataSize > MAX_COMMAND_BYTES) { 1343 ALOGE("RIL: packet larger than %u (%u)", 1344 MAX_COMMAND_BYTES, (unsigned int )dataSize); 1345 1346 return -1; 1347 } 1348 1349 pthread_mutex_lock(&s_writeMutex); 1350 1351 header = htonl(dataSize); 1352 1353 ret = blockingWrite(fd, (void *)&header, sizeof(header)); 1354 1355 if (ret < 0) { 1356 pthread_mutex_unlock(&s_writeMutex); 1357 return ret; 1358 } 1359 1360 ret = blockingWrite(fd, data, dataSize); 1361 1362 if (ret < 0) { 1363 pthread_mutex_unlock(&s_writeMutex); 1364 return ret; 1365 } 1366 1367 pthread_mutex_unlock(&s_writeMutex); 1368 1369 return 0; 1370} 1371 1372static int 1373sendResponse (Parcel &p) { 1374 printResponse; 1375 return sendResponseRaw(p.data(), p.dataSize()); 1376} 1377 1378/** response is an int* pointing to an array of ints*/ 1379 1380static int 1381responseInts(Parcel &p, void *response, size_t responselen) { 1382 int numInts; 1383 1384 if (response == NULL && responselen != 0) { 1385 ALOGE("invalid response: NULL"); 1386 return RIL_ERRNO_INVALID_RESPONSE; 1387 } 1388 if (responselen % sizeof(int) != 0) { 1389 ALOGE("invalid response length %d expected multiple of %d\n", 1390 (int)responselen, (int)sizeof(int)); 1391 return RIL_ERRNO_INVALID_RESPONSE; 1392 } 1393 1394 int *p_int = (int *) response; 1395 1396 numInts = responselen / sizeof(int *); 1397 p.writeInt32 (numInts); 1398 1399 /* each int*/ 1400 startResponse; 1401 for (int i = 0 ; i < numInts ; i++) { 1402 appendPrintBuf("%s%d,", printBuf, p_int[i]); 1403 p.writeInt32(p_int[i]); 1404 } 1405 removeLastChar; 1406 closeResponse; 1407 1408 return 0; 1409} 1410 1411/** response is a char **, pointing to an array of char *'s 1412 The parcel will begin with the version */ 1413static int responseStringsWithVersion(int version, Parcel &p, void *response, size_t responselen) { 1414 p.writeInt32(version); 1415 return responseStrings(p, response, responselen); 1416} 1417 1418/** response is a char **, pointing to an array of char *'s */ 1419static int responseStrings(Parcel &p, void *response, size_t responselen) { 1420 int numStrings; 1421 1422 if (response == NULL && responselen != 0) { 1423 ALOGE("invalid response: NULL"); 1424 return RIL_ERRNO_INVALID_RESPONSE; 1425 } 1426 if (responselen % sizeof(char *) != 0) { 1427 ALOGE("invalid response length %d expected multiple of %d\n", 1428 (int)responselen, (int)sizeof(char *)); 1429 return RIL_ERRNO_INVALID_RESPONSE; 1430 } 1431 1432 if (response == NULL) { 1433 p.writeInt32 (0); 1434 } else { 1435 char **p_cur = (char **) response; 1436 1437 numStrings = responselen / sizeof(char *); 1438 p.writeInt32 (numStrings); 1439 1440 /* each string*/ 1441 startResponse; 1442 for (int i = 0 ; i < numStrings ; i++) { 1443 appendPrintBuf("%s%s,", printBuf, (char*)p_cur[i]); 1444 writeStringToParcel (p, p_cur[i]); 1445 } 1446 removeLastChar; 1447 closeResponse; 1448 } 1449 return 0; 1450} 1451 1452 1453/** 1454 * NULL strings are accepted 1455 * FIXME currently ignores responselen 1456 */ 1457static int responseString(Parcel &p, void *response, size_t responselen) { 1458 /* one string only */ 1459 startResponse; 1460 appendPrintBuf("%s%s", printBuf, (char*)response); 1461 closeResponse; 1462 1463 writeStringToParcel(p, (const char *)response); 1464 1465 return 0; 1466} 1467 1468static int responseVoid(Parcel &p, void *response, size_t responselen) { 1469 startResponse; 1470 removeLastChar; 1471 return 0; 1472} 1473 1474static int responseCallList(Parcel &p, void *response, size_t responselen) { 1475 int num; 1476 1477 if (response == NULL && responselen != 0) { 1478 ALOGE("invalid response: NULL"); 1479 return RIL_ERRNO_INVALID_RESPONSE; 1480 } 1481 1482 if (responselen % sizeof (RIL_Call *) != 0) { 1483 ALOGE("invalid response length %d expected multiple of %d\n", 1484 (int)responselen, (int)sizeof (RIL_Call *)); 1485 return RIL_ERRNO_INVALID_RESPONSE; 1486 } 1487 1488 startResponse; 1489 /* number of call info's */ 1490 num = responselen / sizeof(RIL_Call *); 1491 p.writeInt32(num); 1492 1493 for (int i = 0 ; i < num ; i++) { 1494 RIL_Call *p_cur = ((RIL_Call **) response)[i]; 1495 /* each call info */ 1496 p.writeInt32(p_cur->state); 1497 p.writeInt32(p_cur->index); 1498 p.writeInt32(p_cur->toa); 1499 p.writeInt32(p_cur->isMpty); 1500 p.writeInt32(p_cur->isMT); 1501 p.writeInt32(p_cur->als); 1502 p.writeInt32(p_cur->isVoice); 1503 p.writeInt32(p_cur->isVoicePrivacy); 1504 writeStringToParcel(p, p_cur->number); 1505 p.writeInt32(p_cur->numberPresentation); 1506 writeStringToParcel(p, p_cur->name); 1507 p.writeInt32(p_cur->namePresentation); 1508 // Remove when partners upgrade to version 3 1509 if ((s_callbacks.version < 3) || (p_cur->uusInfo == NULL || p_cur->uusInfo->uusData == NULL)) { 1510 p.writeInt32(0); /* UUS Information is absent */ 1511 } else { 1512 RIL_UUS_Info *uusInfo = p_cur->uusInfo; 1513 p.writeInt32(1); /* UUS Information is present */ 1514 p.writeInt32(uusInfo->uusType); 1515 p.writeInt32(uusInfo->uusDcs); 1516 p.writeInt32(uusInfo->uusLength); 1517 p.write(uusInfo->uusData, uusInfo->uusLength); 1518 } 1519 appendPrintBuf("%s[id=%d,%s,toa=%d,", 1520 printBuf, 1521 p_cur->index, 1522 callStateToString(p_cur->state), 1523 p_cur->toa); 1524 appendPrintBuf("%s%s,%s,als=%d,%s,%s,", 1525 printBuf, 1526 (p_cur->isMpty)?"conf":"norm", 1527 (p_cur->isMT)?"mt":"mo", 1528 p_cur->als, 1529 (p_cur->isVoice)?"voc":"nonvoc", 1530 (p_cur->isVoicePrivacy)?"evp":"noevp"); 1531 appendPrintBuf("%s%s,cli=%d,name='%s',%d]", 1532 printBuf, 1533 p_cur->number, 1534 p_cur->numberPresentation, 1535 p_cur->name, 1536 p_cur->namePresentation); 1537 } 1538 removeLastChar; 1539 closeResponse; 1540 1541 return 0; 1542} 1543 1544static int responseSMS(Parcel &p, void *response, size_t responselen) { 1545 if (response == NULL) { 1546 ALOGE("invalid response: NULL"); 1547 return RIL_ERRNO_INVALID_RESPONSE; 1548 } 1549 1550 if (responselen != sizeof (RIL_SMS_Response) ) { 1551 ALOGE("invalid response length %d expected %d", 1552 (int)responselen, (int)sizeof (RIL_SMS_Response)); 1553 return RIL_ERRNO_INVALID_RESPONSE; 1554 } 1555 1556 RIL_SMS_Response *p_cur = (RIL_SMS_Response *) response; 1557 1558 p.writeInt32(p_cur->messageRef); 1559 writeStringToParcel(p, p_cur->ackPDU); 1560 p.writeInt32(p_cur->errorCode); 1561 1562 startResponse; 1563 appendPrintBuf("%s%d,%s,%d", printBuf, p_cur->messageRef, 1564 (char*)p_cur->ackPDU, p_cur->errorCode); 1565 closeResponse; 1566 1567 return 0; 1568} 1569 1570static int responseDataCallListV4(Parcel &p, void *response, size_t responselen) 1571{ 1572 if (response == NULL && responselen != 0) { 1573 ALOGE("invalid response: NULL"); 1574 return RIL_ERRNO_INVALID_RESPONSE; 1575 } 1576 1577 if (responselen % sizeof(RIL_Data_Call_Response_v4) != 0) { 1578 ALOGE("invalid response length %d expected multiple of %d", 1579 (int)responselen, (int)sizeof(RIL_Data_Call_Response_v4)); 1580 return RIL_ERRNO_INVALID_RESPONSE; 1581 } 1582 1583 int num = responselen / sizeof(RIL_Data_Call_Response_v4); 1584 p.writeInt32(num); 1585 1586 RIL_Data_Call_Response_v4 *p_cur = (RIL_Data_Call_Response_v4 *) response; 1587 startResponse; 1588 int i; 1589 for (i = 0; i < num; i++) { 1590 p.writeInt32(p_cur[i].cid); 1591 p.writeInt32(p_cur[i].active); 1592 writeStringToParcel(p, p_cur[i].type); 1593 // apn is not used, so don't send. 1594 writeStringToParcel(p, p_cur[i].address); 1595 appendPrintBuf("%s[cid=%d,%s,%s,%s],", printBuf, 1596 p_cur[i].cid, 1597 (p_cur[i].active==0)?"down":"up", 1598 (char*)p_cur[i].type, 1599 (char*)p_cur[i].address); 1600 } 1601 removeLastChar; 1602 closeResponse; 1603 1604 return 0; 1605} 1606 1607static int responseDataCallList(Parcel &p, void *response, size_t responselen) 1608{ 1609 // Write version 1610 p.writeInt32(s_callbacks.version); 1611 1612 if (s_callbacks.version < 5) { 1613 return responseDataCallListV4(p, response, responselen); 1614 } else { 1615 if (response == NULL && responselen != 0) { 1616 ALOGE("invalid response: NULL"); 1617 return RIL_ERRNO_INVALID_RESPONSE; 1618 } 1619 1620 if (responselen % sizeof(RIL_Data_Call_Response_v6) != 0) { 1621 ALOGE("invalid response length %d expected multiple of %d", 1622 (int)responselen, (int)sizeof(RIL_Data_Call_Response_v6)); 1623 return RIL_ERRNO_INVALID_RESPONSE; 1624 } 1625 1626 int num = responselen / sizeof(RIL_Data_Call_Response_v6); 1627 p.writeInt32(num); 1628 1629 RIL_Data_Call_Response_v6 *p_cur = (RIL_Data_Call_Response_v6 *) response; 1630 startResponse; 1631 int i; 1632 for (i = 0; i < num; i++) { 1633 p.writeInt32((int)p_cur[i].status); 1634 p.writeInt32(p_cur[i].suggestedRetryTime); 1635 p.writeInt32(p_cur[i].cid); 1636 p.writeInt32(p_cur[i].active); 1637 writeStringToParcel(p, p_cur[i].type); 1638 writeStringToParcel(p, p_cur[i].ifname); 1639 writeStringToParcel(p, p_cur[i].addresses); 1640 writeStringToParcel(p, p_cur[i].dnses); 1641 writeStringToParcel(p, p_cur[i].gateways); 1642 appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s],", printBuf, 1643 p_cur[i].status, 1644 p_cur[i].suggestedRetryTime, 1645 p_cur[i].cid, 1646 (p_cur[i].active==0)?"down":"up", 1647 (char*)p_cur[i].type, 1648 (char*)p_cur[i].ifname, 1649 (char*)p_cur[i].addresses, 1650 (char*)p_cur[i].dnses, 1651 (char*)p_cur[i].gateways); 1652 } 1653 removeLastChar; 1654 closeResponse; 1655 } 1656 1657 return 0; 1658} 1659 1660static int responseSetupDataCall(Parcel &p, void *response, size_t responselen) 1661{ 1662 if (s_callbacks.version < 5) { 1663 return responseStringsWithVersion(s_callbacks.version, p, response, responselen); 1664 } else { 1665 return responseDataCallList(p, response, responselen); 1666 } 1667} 1668 1669static int responseRaw(Parcel &p, void *response, size_t responselen) { 1670 if (response == NULL && responselen != 0) { 1671 ALOGE("invalid response: NULL with responselen != 0"); 1672 return RIL_ERRNO_INVALID_RESPONSE; 1673 } 1674 1675 // The java code reads -1 size as null byte array 1676 if (response == NULL) { 1677 p.writeInt32(-1); 1678 } else { 1679 p.writeInt32(responselen); 1680 p.write(response, responselen); 1681 } 1682 1683 return 0; 1684} 1685 1686 1687static int responseSIM_IO(Parcel &p, void *response, size_t responselen) { 1688 if (response == NULL) { 1689 ALOGE("invalid response: NULL"); 1690 return RIL_ERRNO_INVALID_RESPONSE; 1691 } 1692 1693 if (responselen != sizeof (RIL_SIM_IO_Response) ) { 1694 ALOGE("invalid response length was %d expected %d", 1695 (int)responselen, (int)sizeof (RIL_SIM_IO_Response)); 1696 return RIL_ERRNO_INVALID_RESPONSE; 1697 } 1698 1699 RIL_SIM_IO_Response *p_cur = (RIL_SIM_IO_Response *) response; 1700 p.writeInt32(p_cur->sw1); 1701 p.writeInt32(p_cur->sw2); 1702 writeStringToParcel(p, p_cur->simResponse); 1703 1704 startResponse; 1705 appendPrintBuf("%ssw1=0x%X,sw2=0x%X,%s", printBuf, p_cur->sw1, p_cur->sw2, 1706 (char*)p_cur->simResponse); 1707 closeResponse; 1708 1709 1710 return 0; 1711} 1712 1713static int responseCallForwards(Parcel &p, void *response, size_t responselen) { 1714 int num; 1715 1716 if (response == NULL && responselen != 0) { 1717 ALOGE("invalid response: NULL"); 1718 return RIL_ERRNO_INVALID_RESPONSE; 1719 } 1720 1721 if (responselen % sizeof(RIL_CallForwardInfo *) != 0) { 1722 ALOGE("invalid response length %d expected multiple of %d", 1723 (int)responselen, (int)sizeof(RIL_CallForwardInfo *)); 1724 return RIL_ERRNO_INVALID_RESPONSE; 1725 } 1726 1727 /* number of call info's */ 1728 num = responselen / sizeof(RIL_CallForwardInfo *); 1729 p.writeInt32(num); 1730 1731 startResponse; 1732 for (int i = 0 ; i < num ; i++) { 1733 RIL_CallForwardInfo *p_cur = ((RIL_CallForwardInfo **) response)[i]; 1734 1735 p.writeInt32(p_cur->status); 1736 p.writeInt32(p_cur->reason); 1737 p.writeInt32(p_cur->serviceClass); 1738 p.writeInt32(p_cur->toa); 1739 writeStringToParcel(p, p_cur->number); 1740 p.writeInt32(p_cur->timeSeconds); 1741 appendPrintBuf("%s[%s,reason=%d,cls=%d,toa=%d,%s,tout=%d],", printBuf, 1742 (p_cur->status==1)?"enable":"disable", 1743 p_cur->reason, p_cur->serviceClass, p_cur->toa, 1744 (char*)p_cur->number, 1745 p_cur->timeSeconds); 1746 } 1747 removeLastChar; 1748 closeResponse; 1749 1750 return 0; 1751} 1752 1753static int responseSsn(Parcel &p, void *response, size_t responselen) { 1754 if (response == NULL) { 1755 ALOGE("invalid response: NULL"); 1756 return RIL_ERRNO_INVALID_RESPONSE; 1757 } 1758 1759 if (responselen != sizeof(RIL_SuppSvcNotification)) { 1760 ALOGE("invalid response length was %d expected %d", 1761 (int)responselen, (int)sizeof (RIL_SuppSvcNotification)); 1762 return RIL_ERRNO_INVALID_RESPONSE; 1763 } 1764 1765 RIL_SuppSvcNotification *p_cur = (RIL_SuppSvcNotification *) response; 1766 p.writeInt32(p_cur->notificationType); 1767 p.writeInt32(p_cur->code); 1768 p.writeInt32(p_cur->index); 1769 p.writeInt32(p_cur->type); 1770 writeStringToParcel(p, p_cur->number); 1771 1772 startResponse; 1773 appendPrintBuf("%s%s,code=%d,id=%d,type=%d,%s", printBuf, 1774 (p_cur->notificationType==0)?"mo":"mt", 1775 p_cur->code, p_cur->index, p_cur->type, 1776 (char*)p_cur->number); 1777 closeResponse; 1778 1779 return 0; 1780} 1781 1782static int responseCellList(Parcel &p, void *response, size_t responselen) { 1783 int num; 1784 1785 if (response == NULL && responselen != 0) { 1786 ALOGE("invalid response: NULL"); 1787 return RIL_ERRNO_INVALID_RESPONSE; 1788 } 1789 1790 if (responselen % sizeof (RIL_NeighboringCell *) != 0) { 1791 ALOGE("invalid response length %d expected multiple of %d\n", 1792 (int)responselen, (int)sizeof (RIL_NeighboringCell *)); 1793 return RIL_ERRNO_INVALID_RESPONSE; 1794 } 1795 1796 startResponse; 1797 /* number of records */ 1798 num = responselen / sizeof(RIL_NeighboringCell *); 1799 p.writeInt32(num); 1800 1801 for (int i = 0 ; i < num ; i++) { 1802 RIL_NeighboringCell *p_cur = ((RIL_NeighboringCell **) response)[i]; 1803 1804 p.writeInt32(p_cur->rssi); 1805 writeStringToParcel (p, p_cur->cid); 1806 1807 appendPrintBuf("%s[cid=%s,rssi=%d],", printBuf, 1808 p_cur->cid, p_cur->rssi); 1809 } 1810 removeLastChar; 1811 closeResponse; 1812 1813 return 0; 1814} 1815 1816/** 1817 * Marshall the signalInfoRecord into the parcel if it exists. 1818 */ 1819static void marshallSignalInfoRecord(Parcel &p, 1820 RIL_CDMA_SignalInfoRecord &p_signalInfoRecord) { 1821 p.writeInt32(p_signalInfoRecord.isPresent); 1822 p.writeInt32(p_signalInfoRecord.signalType); 1823 p.writeInt32(p_signalInfoRecord.alertPitch); 1824 p.writeInt32(p_signalInfoRecord.signal); 1825} 1826 1827static int responseCdmaInformationRecords(Parcel &p, 1828 void *response, size_t responselen) { 1829 int num; 1830 char* string8 = NULL; 1831 int buffer_lenght; 1832 RIL_CDMA_InformationRecord *infoRec; 1833 1834 if (response == NULL && responselen != 0) { 1835 ALOGE("invalid response: NULL"); 1836 return RIL_ERRNO_INVALID_RESPONSE; 1837 } 1838 1839 if (responselen != sizeof (RIL_CDMA_InformationRecords)) { 1840 ALOGE("invalid response length %d expected multiple of %d\n", 1841 (int)responselen, (int)sizeof (RIL_CDMA_InformationRecords *)); 1842 return RIL_ERRNO_INVALID_RESPONSE; 1843 } 1844 1845 RIL_CDMA_InformationRecords *p_cur = 1846 (RIL_CDMA_InformationRecords *) response; 1847 num = MIN(p_cur->numberOfInfoRecs, RIL_CDMA_MAX_NUMBER_OF_INFO_RECS); 1848 1849 startResponse; 1850 p.writeInt32(num); 1851 1852 for (int i = 0 ; i < num ; i++) { 1853 infoRec = &p_cur->infoRec[i]; 1854 p.writeInt32(infoRec->name); 1855 switch (infoRec->name) { 1856 case RIL_CDMA_DISPLAY_INFO_REC: 1857 case RIL_CDMA_EXTENDED_DISPLAY_INFO_REC: 1858 if (infoRec->rec.display.alpha_len > 1859 CDMA_ALPHA_INFO_BUFFER_LENGTH) { 1860 ALOGE("invalid display info response length %d \ 1861 expected not more than %d\n", 1862 (int)infoRec->rec.display.alpha_len, 1863 CDMA_ALPHA_INFO_BUFFER_LENGTH); 1864 return RIL_ERRNO_INVALID_RESPONSE; 1865 } 1866 string8 = (char*) malloc((infoRec->rec.display.alpha_len + 1) 1867 * sizeof(char) ); 1868 for (int i = 0 ; i < infoRec->rec.display.alpha_len ; i++) { 1869 string8[i] = infoRec->rec.display.alpha_buf[i]; 1870 } 1871 string8[(int)infoRec->rec.display.alpha_len] = '\0'; 1872 writeStringToParcel(p, (const char*)string8); 1873 free(string8); 1874 string8 = NULL; 1875 break; 1876 case RIL_CDMA_CALLED_PARTY_NUMBER_INFO_REC: 1877 case RIL_CDMA_CALLING_PARTY_NUMBER_INFO_REC: 1878 case RIL_CDMA_CONNECTED_NUMBER_INFO_REC: 1879 if (infoRec->rec.number.len > CDMA_NUMBER_INFO_BUFFER_LENGTH) { 1880 ALOGE("invalid display info response length %d \ 1881 expected not more than %d\n", 1882 (int)infoRec->rec.number.len, 1883 CDMA_NUMBER_INFO_BUFFER_LENGTH); 1884 return RIL_ERRNO_INVALID_RESPONSE; 1885 } 1886 string8 = (char*) malloc((infoRec->rec.number.len + 1) 1887 * sizeof(char) ); 1888 for (int i = 0 ; i < infoRec->rec.number.len; i++) { 1889 string8[i] = infoRec->rec.number.buf[i]; 1890 } 1891 string8[(int)infoRec->rec.number.len] = '\0'; 1892 writeStringToParcel(p, (const char*)string8); 1893 free(string8); 1894 string8 = NULL; 1895 p.writeInt32(infoRec->rec.number.number_type); 1896 p.writeInt32(infoRec->rec.number.number_plan); 1897 p.writeInt32(infoRec->rec.number.pi); 1898 p.writeInt32(infoRec->rec.number.si); 1899 break; 1900 case RIL_CDMA_SIGNAL_INFO_REC: 1901 p.writeInt32(infoRec->rec.signal.isPresent); 1902 p.writeInt32(infoRec->rec.signal.signalType); 1903 p.writeInt32(infoRec->rec.signal.alertPitch); 1904 p.writeInt32(infoRec->rec.signal.signal); 1905 1906 appendPrintBuf("%sisPresent=%X, signalType=%X, \ 1907 alertPitch=%X, signal=%X, ", 1908 printBuf, (int)infoRec->rec.signal.isPresent, 1909 (int)infoRec->rec.signal.signalType, 1910 (int)infoRec->rec.signal.alertPitch, 1911 (int)infoRec->rec.signal.signal); 1912 removeLastChar; 1913 break; 1914 case RIL_CDMA_REDIRECTING_NUMBER_INFO_REC: 1915 if (infoRec->rec.redir.redirectingNumber.len > 1916 CDMA_NUMBER_INFO_BUFFER_LENGTH) { 1917 ALOGE("invalid display info response length %d \ 1918 expected not more than %d\n", 1919 (int)infoRec->rec.redir.redirectingNumber.len, 1920 CDMA_NUMBER_INFO_BUFFER_LENGTH); 1921 return RIL_ERRNO_INVALID_RESPONSE; 1922 } 1923 string8 = (char*) malloc((infoRec->rec.redir.redirectingNumber 1924 .len + 1) * sizeof(char) ); 1925 for (int i = 0; 1926 i < infoRec->rec.redir.redirectingNumber.len; 1927 i++) { 1928 string8[i] = infoRec->rec.redir.redirectingNumber.buf[i]; 1929 } 1930 string8[(int)infoRec->rec.redir.redirectingNumber.len] = '\0'; 1931 writeStringToParcel(p, (const char*)string8); 1932 free(string8); 1933 string8 = NULL; 1934 p.writeInt32(infoRec->rec.redir.redirectingNumber.number_type); 1935 p.writeInt32(infoRec->rec.redir.redirectingNumber.number_plan); 1936 p.writeInt32(infoRec->rec.redir.redirectingNumber.pi); 1937 p.writeInt32(infoRec->rec.redir.redirectingNumber.si); 1938 p.writeInt32(infoRec->rec.redir.redirectingReason); 1939 break; 1940 case RIL_CDMA_LINE_CONTROL_INFO_REC: 1941 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlPolarityIncluded); 1942 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlToggle); 1943 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlReverse); 1944 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlPowerDenial); 1945 1946 appendPrintBuf("%slineCtrlPolarityIncluded=%d, \ 1947 lineCtrlToggle=%d, lineCtrlReverse=%d, \ 1948 lineCtrlPowerDenial=%d, ", printBuf, 1949 (int)infoRec->rec.lineCtrl.lineCtrlPolarityIncluded, 1950 (int)infoRec->rec.lineCtrl.lineCtrlToggle, 1951 (int)infoRec->rec.lineCtrl.lineCtrlReverse, 1952 (int)infoRec->rec.lineCtrl.lineCtrlPowerDenial); 1953 removeLastChar; 1954 break; 1955 case RIL_CDMA_T53_CLIR_INFO_REC: 1956 p.writeInt32((int)(infoRec->rec.clir.cause)); 1957 1958 appendPrintBuf("%scause%d", printBuf, infoRec->rec.clir.cause); 1959 removeLastChar; 1960 break; 1961 case RIL_CDMA_T53_AUDIO_CONTROL_INFO_REC: 1962 p.writeInt32(infoRec->rec.audioCtrl.upLink); 1963 p.writeInt32(infoRec->rec.audioCtrl.downLink); 1964 1965 appendPrintBuf("%supLink=%d, downLink=%d, ", printBuf, 1966 infoRec->rec.audioCtrl.upLink, 1967 infoRec->rec.audioCtrl.downLink); 1968 removeLastChar; 1969 break; 1970 case RIL_CDMA_T53_RELEASE_INFO_REC: 1971 // TODO(Moto): See David Krause, he has the answer:) 1972 ALOGE("RIL_CDMA_T53_RELEASE_INFO_REC: return INVALID_RESPONSE"); 1973 return RIL_ERRNO_INVALID_RESPONSE; 1974 default: 1975 ALOGE("Incorrect name value"); 1976 return RIL_ERRNO_INVALID_RESPONSE; 1977 } 1978 } 1979 closeResponse; 1980 1981 return 0; 1982} 1983 1984static int responseRilSignalStrength(Parcel &p, 1985 void *response, size_t responselen) { 1986 if (response == NULL && responselen != 0) { 1987 ALOGE("invalid response: NULL"); 1988 return RIL_ERRNO_INVALID_RESPONSE; 1989 } 1990 1991 if (responselen >= sizeof (RIL_SignalStrength_v5)) { 1992 RIL_SignalStrength_v6 *p_cur = ((RIL_SignalStrength_v6 *) response); 1993 1994 p.writeInt32(p_cur->GW_SignalStrength.signalStrength); 1995 p.writeInt32(p_cur->GW_SignalStrength.bitErrorRate); 1996 p.writeInt32(p_cur->CDMA_SignalStrength.dbm); 1997 p.writeInt32(p_cur->CDMA_SignalStrength.ecio); 1998 p.writeInt32(p_cur->EVDO_SignalStrength.dbm); 1999 p.writeInt32(p_cur->EVDO_SignalStrength.ecio); 2000 p.writeInt32(p_cur->EVDO_SignalStrength.signalNoiseRatio); 2001 if (responselen >= sizeof (RIL_SignalStrength_v6)) { 2002 p.writeInt32(p_cur->LTE_SignalStrength.signalStrength); 2003 2004 /* 2005 * ril version <=6 receives negative values for rsrp 2006 * workaround for backward compatibility 2007 */ 2008 p_cur->LTE_SignalStrength.rsrp = 2009 ((s_callbacks.version <= 6) && (p_cur->LTE_SignalStrength.rsrp < 0 )) ? 2010 -(p_cur->LTE_SignalStrength.rsrp) : p_cur->LTE_SignalStrength.rsrp; 2011 2012 p.writeInt32(p_cur->LTE_SignalStrength.rsrp); 2013 p.writeInt32(p_cur->LTE_SignalStrength.rsrq); 2014 p.writeInt32(p_cur->LTE_SignalStrength.rssnr); 2015 p.writeInt32(p_cur->LTE_SignalStrength.cqi); 2016 } else { 2017 memset(&p_cur->LTE_SignalStrength, sizeof (RIL_LTE_SignalStrength), 0); 2018 } 2019 2020 startResponse; 2021 appendPrintBuf("%s[signalStrength=%d,bitErrorRate=%d,\ 2022 CDMA_SS.dbm=%d,CDMA_SSecio=%d,\ 2023 EVDO_SS.dbm=%d,EVDO_SS.ecio=%d,\ 2024 EVDO_SS.signalNoiseRatio=%d,\ 2025 LTE_SS.signalStrength=%d,LTE_SS.rsrp=%d,LTE_SS.rsrq=%d,\ 2026 LTE_SS.rssnr=%d,LTE_SS.cqi=%d]", 2027 printBuf, 2028 p_cur->GW_SignalStrength.signalStrength, 2029 p_cur->GW_SignalStrength.bitErrorRate, 2030 p_cur->CDMA_SignalStrength.dbm, 2031 p_cur->CDMA_SignalStrength.ecio, 2032 p_cur->EVDO_SignalStrength.dbm, 2033 p_cur->EVDO_SignalStrength.ecio, 2034 p_cur->EVDO_SignalStrength.signalNoiseRatio, 2035 p_cur->LTE_SignalStrength.signalStrength, 2036 p_cur->LTE_SignalStrength.rsrp, 2037 p_cur->LTE_SignalStrength.rsrq, 2038 p_cur->LTE_SignalStrength.rssnr, 2039 p_cur->LTE_SignalStrength.cqi); 2040 closeResponse; 2041 2042 } else { 2043 ALOGE("invalid response length"); 2044 return RIL_ERRNO_INVALID_RESPONSE; 2045 } 2046 2047 return 0; 2048} 2049 2050static int responseCallRing(Parcel &p, void *response, size_t responselen) { 2051 if ((response == NULL) || (responselen == 0)) { 2052 return responseVoid(p, response, responselen); 2053 } else { 2054 return responseCdmaSignalInfoRecord(p, response, responselen); 2055 } 2056} 2057 2058static int responseCdmaSignalInfoRecord(Parcel &p, void *response, size_t responselen) { 2059 if (response == NULL || responselen == 0) { 2060 ALOGE("invalid response: NULL"); 2061 return RIL_ERRNO_INVALID_RESPONSE; 2062 } 2063 2064 if (responselen != sizeof (RIL_CDMA_SignalInfoRecord)) { 2065 ALOGE("invalid response length %d expected sizeof (RIL_CDMA_SignalInfoRecord) of %d\n", 2066 (int)responselen, (int)sizeof (RIL_CDMA_SignalInfoRecord)); 2067 return RIL_ERRNO_INVALID_RESPONSE; 2068 } 2069 2070 startResponse; 2071 2072 RIL_CDMA_SignalInfoRecord *p_cur = ((RIL_CDMA_SignalInfoRecord *) response); 2073 marshallSignalInfoRecord(p, *p_cur); 2074 2075 appendPrintBuf("%s[isPresent=%d,signalType=%d,alertPitch=%d\ 2076 signal=%d]", 2077 printBuf, 2078 p_cur->isPresent, 2079 p_cur->signalType, 2080 p_cur->alertPitch, 2081 p_cur->signal); 2082 2083 closeResponse; 2084 return 0; 2085} 2086 2087static int responseCdmaCallWaiting(Parcel &p, void *response, 2088 size_t responselen) { 2089 if (response == NULL && responselen != 0) { 2090 ALOGE("invalid response: NULL"); 2091 return RIL_ERRNO_INVALID_RESPONSE; 2092 } 2093 2094 if (responselen < sizeof(RIL_CDMA_CallWaiting_v6)) { 2095 ALOGW("Upgrade to ril version %d\n", RIL_VERSION); 2096 } 2097 2098 RIL_CDMA_CallWaiting_v6 *p_cur = ((RIL_CDMA_CallWaiting_v6 *) response); 2099 2100 writeStringToParcel(p, p_cur->number); 2101 p.writeInt32(p_cur->numberPresentation); 2102 writeStringToParcel(p, p_cur->name); 2103 marshallSignalInfoRecord(p, p_cur->signalInfoRecord); 2104 2105 if (responselen >= sizeof(RIL_CDMA_CallWaiting_v6)) { 2106 p.writeInt32(p_cur->number_type); 2107 p.writeInt32(p_cur->number_plan); 2108 } else { 2109 p.writeInt32(0); 2110 p.writeInt32(0); 2111 } 2112 2113 startResponse; 2114 appendPrintBuf("%snumber=%s,numberPresentation=%d, name=%s,\ 2115 signalInfoRecord[isPresent=%d,signalType=%d,alertPitch=%d\ 2116 signal=%d,number_type=%d,number_plan=%d]", 2117 printBuf, 2118 p_cur->number, 2119 p_cur->numberPresentation, 2120 p_cur->name, 2121 p_cur->signalInfoRecord.isPresent, 2122 p_cur->signalInfoRecord.signalType, 2123 p_cur->signalInfoRecord.alertPitch, 2124 p_cur->signalInfoRecord.signal, 2125 p_cur->number_type, 2126 p_cur->number_plan); 2127 closeResponse; 2128 2129 return 0; 2130} 2131 2132static int responseSimRefresh(Parcel &p, void *response, size_t responselen) { 2133 if (response == NULL && responselen != 0) { 2134 ALOGE("responseSimRefresh: invalid response: NULL"); 2135 return RIL_ERRNO_INVALID_RESPONSE; 2136 } 2137 2138 startResponse; 2139 if (s_callbacks.version == 7) { 2140 RIL_SimRefreshResponse_v7 *p_cur = ((RIL_SimRefreshResponse_v7 *) response); 2141 p.writeInt32(p_cur->result); 2142 p.writeInt32(p_cur->ef_id); 2143 writeStringToParcel(p, p_cur->aid); 2144 2145 appendPrintBuf("%sresult=%d, ef_id=%d, aid=%s", 2146 printBuf, 2147 p_cur->result, 2148 p_cur->ef_id, 2149 p_cur->aid); 2150 } else { 2151 int *p_cur = ((int *) response); 2152 p.writeInt32(p_cur[0]); 2153 p.writeInt32(p_cur[1]); 2154 writeStringToParcel(p, NULL); 2155 2156 appendPrintBuf("%sresult=%d, ef_id=%d", 2157 printBuf, 2158 p_cur[0], 2159 p_cur[1]); 2160 } 2161 closeResponse; 2162 2163 return 0; 2164} 2165 2166static void triggerEvLoop() { 2167 int ret; 2168 if (!pthread_equal(pthread_self(), s_tid_dispatch)) { 2169 /* trigger event loop to wakeup. No reason to do this, 2170 * if we're in the event loop thread */ 2171 do { 2172 ret = write (s_fdWakeupWrite, " ", 1); 2173 } while (ret < 0 && errno == EINTR); 2174 } 2175} 2176 2177static void rilEventAddWakeup(struct ril_event *ev) { 2178 ril_event_add(ev); 2179 triggerEvLoop(); 2180} 2181 2182static void sendSimStatusAppInfo(Parcel &p, int num_apps, RIL_AppStatus appStatus[]) { 2183 p.writeInt32(num_apps); 2184 startResponse; 2185 for (int i = 0; i < num_apps; i++) { 2186 p.writeInt32(appStatus[i].app_type); 2187 p.writeInt32(appStatus[i].app_state); 2188 p.writeInt32(appStatus[i].perso_substate); 2189 writeStringToParcel(p, (const char*)(appStatus[i].aid_ptr)); 2190 writeStringToParcel(p, (const char*) 2191 (appStatus[i].app_label_ptr)); 2192 p.writeInt32(appStatus[i].pin1_replaced); 2193 p.writeInt32(appStatus[i].pin1); 2194 p.writeInt32(appStatus[i].pin2); 2195 appendPrintBuf("%s[app_type=%d,app_state=%d,perso_substate=%d,\ 2196 aid_ptr=%s,app_label_ptr=%s,pin1_replaced=%d,pin1=%d,pin2=%d],", 2197 printBuf, 2198 appStatus[i].app_type, 2199 appStatus[i].app_state, 2200 appStatus[i].perso_substate, 2201 appStatus[i].aid_ptr, 2202 appStatus[i].app_label_ptr, 2203 appStatus[i].pin1_replaced, 2204 appStatus[i].pin1, 2205 appStatus[i].pin2); 2206 } 2207 closeResponse; 2208} 2209 2210static int responseSimStatus(Parcel &p, void *response, size_t responselen) { 2211 int i; 2212 2213 if (response == NULL && responselen != 0) { 2214 ALOGE("invalid response: NULL"); 2215 return RIL_ERRNO_INVALID_RESPONSE; 2216 } 2217 2218 if (responselen == sizeof (RIL_CardStatus_v6)) { 2219 RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response); 2220 2221 p.writeInt32(p_cur->card_state); 2222 p.writeInt32(p_cur->universal_pin_state); 2223 p.writeInt32(p_cur->gsm_umts_subscription_app_index); 2224 p.writeInt32(p_cur->cdma_subscription_app_index); 2225 p.writeInt32(p_cur->ims_subscription_app_index); 2226 2227 sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications); 2228 } else if (responselen == sizeof (RIL_CardStatus_v5)) { 2229 RIL_CardStatus_v5 *p_cur = ((RIL_CardStatus_v5 *) response); 2230 2231 p.writeInt32(p_cur->card_state); 2232 p.writeInt32(p_cur->universal_pin_state); 2233 p.writeInt32(p_cur->gsm_umts_subscription_app_index); 2234 p.writeInt32(p_cur->cdma_subscription_app_index); 2235 p.writeInt32(-1); 2236 2237 sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications); 2238 } else { 2239 ALOGE("responseSimStatus: A RilCardStatus_v6 or _v5 expected\n"); 2240 return RIL_ERRNO_INVALID_RESPONSE; 2241 } 2242 2243 return 0; 2244} 2245 2246static int responseGsmBrSmsCnf(Parcel &p, void *response, size_t responselen) { 2247 int num = responselen / sizeof(RIL_GSM_BroadcastSmsConfigInfo *); 2248 p.writeInt32(num); 2249 2250 startResponse; 2251 RIL_GSM_BroadcastSmsConfigInfo **p_cur = 2252 (RIL_GSM_BroadcastSmsConfigInfo **) response; 2253 for (int i = 0; i < num; i++) { 2254 p.writeInt32(p_cur[i]->fromServiceId); 2255 p.writeInt32(p_cur[i]->toServiceId); 2256 p.writeInt32(p_cur[i]->fromCodeScheme); 2257 p.writeInt32(p_cur[i]->toCodeScheme); 2258 p.writeInt32(p_cur[i]->selected); 2259 2260 appendPrintBuf("%s [%d: fromServiceId=%d, toServiceId=%d, \ 2261 fromCodeScheme=%d, toCodeScheme=%d, selected =%d]", 2262 printBuf, i, p_cur[i]->fromServiceId, p_cur[i]->toServiceId, 2263 p_cur[i]->fromCodeScheme, p_cur[i]->toCodeScheme, 2264 p_cur[i]->selected); 2265 } 2266 closeResponse; 2267 2268 return 0; 2269} 2270 2271static int responseCdmaBrSmsCnf(Parcel &p, void *response, size_t responselen) { 2272 RIL_CDMA_BroadcastSmsConfigInfo **p_cur = 2273 (RIL_CDMA_BroadcastSmsConfigInfo **) response; 2274 2275 int num = responselen / sizeof (RIL_CDMA_BroadcastSmsConfigInfo *); 2276 p.writeInt32(num); 2277 2278 startResponse; 2279 for (int i = 0 ; i < num ; i++ ) { 2280 p.writeInt32(p_cur[i]->service_category); 2281 p.writeInt32(p_cur[i]->language); 2282 p.writeInt32(p_cur[i]->selected); 2283 2284 appendPrintBuf("%s [%d: srvice_category=%d, language =%d, \ 2285 selected =%d], ", 2286 printBuf, i, p_cur[i]->service_category, p_cur[i]->language, 2287 p_cur[i]->selected); 2288 } 2289 closeResponse; 2290 2291 return 0; 2292} 2293 2294static int responseCdmaSms(Parcel &p, void *response, size_t responselen) { 2295 int num; 2296 int digitCount; 2297 int digitLimit; 2298 uint8_t uct; 2299 void* dest; 2300 2301 ALOGD("Inside responseCdmaSms"); 2302 2303 if (response == NULL && responselen != 0) { 2304 ALOGE("invalid response: NULL"); 2305 return RIL_ERRNO_INVALID_RESPONSE; 2306 } 2307 2308 if (responselen != sizeof(RIL_CDMA_SMS_Message)) { 2309 ALOGE("invalid response length was %d expected %d", 2310 (int)responselen, (int)sizeof(RIL_CDMA_SMS_Message)); 2311 return RIL_ERRNO_INVALID_RESPONSE; 2312 } 2313 2314 RIL_CDMA_SMS_Message *p_cur = (RIL_CDMA_SMS_Message *) response; 2315 p.writeInt32(p_cur->uTeleserviceID); 2316 p.write(&(p_cur->bIsServicePresent),sizeof(uct)); 2317 p.writeInt32(p_cur->uServicecategory); 2318 p.writeInt32(p_cur->sAddress.digit_mode); 2319 p.writeInt32(p_cur->sAddress.number_mode); 2320 p.writeInt32(p_cur->sAddress.number_type); 2321 p.writeInt32(p_cur->sAddress.number_plan); 2322 p.write(&(p_cur->sAddress.number_of_digits), sizeof(uct)); 2323 digitLimit= MIN((p_cur->sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX); 2324 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) { 2325 p.write(&(p_cur->sAddress.digits[digitCount]),sizeof(uct)); 2326 } 2327 2328 p.writeInt32(p_cur->sSubAddress.subaddressType); 2329 p.write(&(p_cur->sSubAddress.odd),sizeof(uct)); 2330 p.write(&(p_cur->sSubAddress.number_of_digits),sizeof(uct)); 2331 digitLimit= MIN((p_cur->sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX); 2332 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) { 2333 p.write(&(p_cur->sSubAddress.digits[digitCount]),sizeof(uct)); 2334 } 2335 2336 digitLimit= MIN((p_cur->uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX); 2337 p.writeInt32(p_cur->uBearerDataLen); 2338 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) { 2339 p.write(&(p_cur->aBearerData[digitCount]), sizeof(uct)); 2340 } 2341 2342 startResponse; 2343 appendPrintBuf("%suTeleserviceID=%d, bIsServicePresent=%d, uServicecategory=%d, \ 2344 sAddress.digit_mode=%d, sAddress.number_mode=%d, sAddress.number_type=%d, ", 2345 printBuf, p_cur->uTeleserviceID,p_cur->bIsServicePresent,p_cur->uServicecategory, 2346 p_cur->sAddress.digit_mode, p_cur->sAddress.number_mode,p_cur->sAddress.number_type); 2347 closeResponse; 2348 2349 return 0; 2350} 2351 2352/** 2353 * A write on the wakeup fd is done just to pop us out of select() 2354 * We empty the buffer here and then ril_event will reset the timers on the 2355 * way back down 2356 */ 2357static void processWakeupCallback(int fd, short flags, void *param) { 2358 char buff[16]; 2359 int ret; 2360 2361 ALOGV("processWakeupCallback"); 2362 2363 /* empty our wakeup socket out */ 2364 do { 2365 ret = read(s_fdWakeupRead, &buff, sizeof(buff)); 2366 } while (ret > 0 || (ret < 0 && errno == EINTR)); 2367} 2368 2369static void onCommandsSocketClosed() { 2370 int ret; 2371 RequestInfo *p_cur; 2372 2373 /* mark pending requests as "cancelled" so we dont report responses */ 2374 2375 ret = pthread_mutex_lock(&s_pendingRequestsMutex); 2376 assert (ret == 0); 2377 2378 p_cur = s_pendingRequests; 2379 2380 for (p_cur = s_pendingRequests 2381 ; p_cur != NULL 2382 ; p_cur = p_cur->p_next 2383 ) { 2384 p_cur->cancelled = 1; 2385 } 2386 2387 ret = pthread_mutex_unlock(&s_pendingRequestsMutex); 2388 assert (ret == 0); 2389} 2390 2391static void processCommandsCallback(int fd, short flags, void *param) { 2392 RecordStream *p_rs; 2393 void *p_record; 2394 size_t recordlen; 2395 int ret; 2396 2397 assert(fd == s_fdCommand); 2398 2399 p_rs = (RecordStream *)param; 2400 2401 for (;;) { 2402 /* loop until EAGAIN/EINTR, end of stream, or other error */ 2403 ret = record_stream_get_next(p_rs, &p_record, &recordlen); 2404 2405 if (ret == 0 && p_record == NULL) { 2406 /* end-of-stream */ 2407 break; 2408 } else if (ret < 0) { 2409 break; 2410 } else if (ret == 0) { /* && p_record != NULL */ 2411 processCommandBuffer(p_record, recordlen); 2412 } 2413 } 2414 2415 if (ret == 0 || !(errno == EAGAIN || errno == EINTR)) { 2416 /* fatal error or end-of-stream */ 2417 if (ret != 0) { 2418 ALOGE("error on reading command socket errno:%d\n", errno); 2419 } else { 2420 ALOGW("EOS. Closing command socket."); 2421 } 2422 2423 close(s_fdCommand); 2424 s_fdCommand = -1; 2425 2426 ril_event_del(&s_commands_event); 2427 2428 record_stream_free(p_rs); 2429 2430 /* start listening for new connections again */ 2431 rilEventAddWakeup(&s_listen_event); 2432 2433 onCommandsSocketClosed(); 2434 } 2435} 2436 2437 2438static void onNewCommandConnect() { 2439 // Inform we are connected and the ril version 2440 int rilVer = s_callbacks.version; 2441 RIL_onUnsolicitedResponse(RIL_UNSOL_RIL_CONNECTED, 2442 &rilVer, sizeof(rilVer)); 2443 2444 // implicit radio state changed 2445 RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED, 2446 NULL, 0); 2447 2448 // Send last NITZ time data, in case it was missed 2449 if (s_lastNITZTimeData != NULL) { 2450 sendResponseRaw(s_lastNITZTimeData, s_lastNITZTimeDataSize); 2451 2452 free(s_lastNITZTimeData); 2453 s_lastNITZTimeData = NULL; 2454 } 2455 2456 // Get version string 2457 if (s_callbacks.getVersion != NULL) { 2458 const char *version; 2459 version = s_callbacks.getVersion(); 2460 ALOGI("RIL Daemon version: %s\n", version); 2461 2462 property_set(PROPERTY_RIL_IMPL, version); 2463 } else { 2464 ALOGI("RIL Daemon version: unavailable\n"); 2465 property_set(PROPERTY_RIL_IMPL, "unavailable"); 2466 } 2467 2468} 2469 2470static void listenCallback (int fd, short flags, void *param) { 2471 int ret; 2472 int err; 2473 int is_phone_socket; 2474 RecordStream *p_rs; 2475 2476 struct sockaddr_un peeraddr; 2477 socklen_t socklen = sizeof (peeraddr); 2478 2479 struct ucred creds; 2480 socklen_t szCreds = sizeof(creds); 2481 2482 struct passwd *pwd = NULL; 2483 2484 assert (s_fdCommand < 0); 2485 assert (fd == s_fdListen); 2486 2487 s_fdCommand = accept(s_fdListen, (sockaddr *) &peeraddr, &socklen); 2488 2489 if (s_fdCommand < 0 ) { 2490 ALOGE("Error on accept() errno:%d", errno); 2491 /* start listening for new connections again */ 2492 rilEventAddWakeup(&s_listen_event); 2493 return; 2494 } 2495 2496 /* check the credential of the other side and only accept socket from 2497 * phone process 2498 */ 2499 errno = 0; 2500 is_phone_socket = 0; 2501 2502 err = getsockopt(s_fdCommand, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds); 2503 2504 if (err == 0 && szCreds > 0) { 2505 errno = 0; 2506 pwd = getpwuid(creds.uid); 2507 if (pwd != NULL) { 2508 if (strcmp(pwd->pw_name, PHONE_PROCESS) == 0) { 2509 is_phone_socket = 1; 2510 } else { 2511 ALOGE("RILD can't accept socket from process %s", pwd->pw_name); 2512 } 2513 } else { 2514 ALOGE("Error on getpwuid() errno: %d", errno); 2515 } 2516 } else { 2517 ALOGD("Error on getsockopt() errno: %d", errno); 2518 } 2519 2520 if ( !is_phone_socket ) { 2521 ALOGE("RILD must accept socket from %s", PHONE_PROCESS); 2522 2523 close(s_fdCommand); 2524 s_fdCommand = -1; 2525 2526 onCommandsSocketClosed(); 2527 2528 /* start listening for new connections again */ 2529 rilEventAddWakeup(&s_listen_event); 2530 2531 return; 2532 } 2533 2534 ret = fcntl(s_fdCommand, F_SETFL, O_NONBLOCK); 2535 2536 if (ret < 0) { 2537 ALOGE ("Error setting O_NONBLOCK errno:%d", errno); 2538 } 2539 2540 ALOGI("libril: new connection"); 2541 2542 p_rs = record_stream_new(s_fdCommand, MAX_COMMAND_BYTES); 2543 2544 ril_event_set (&s_commands_event, s_fdCommand, 1, 2545 processCommandsCallback, p_rs); 2546 2547 rilEventAddWakeup (&s_commands_event); 2548 2549 onNewCommandConnect(); 2550} 2551 2552static void freeDebugCallbackArgs(int number, char **args) { 2553 for (int i = 0; i < number; i++) { 2554 if (args[i] != NULL) { 2555 free(args[i]); 2556 } 2557 } 2558 free(args); 2559} 2560 2561static void debugCallback (int fd, short flags, void *param) { 2562 int acceptFD, option; 2563 struct sockaddr_un peeraddr; 2564 socklen_t socklen = sizeof (peeraddr); 2565 int data; 2566 unsigned int qxdm_data[6]; 2567 const char *deactData[1] = {"1"}; 2568 char *actData[1]; 2569 RIL_Dial dialData; 2570 int hangupData[1] = {1}; 2571 int number; 2572 char **args; 2573 2574 acceptFD = accept (fd, (sockaddr *) &peeraddr, &socklen); 2575 2576 if (acceptFD < 0) { 2577 ALOGE ("error accepting on debug port: %d\n", errno); 2578 return; 2579 } 2580 2581 if (recv(acceptFD, &number, sizeof(int), 0) != sizeof(int)) { 2582 ALOGE ("error reading on socket: number of Args: \n"); 2583 return; 2584 } 2585 args = (char **) malloc(sizeof(char*) * number); 2586 2587 for (int i = 0; i < number; i++) { 2588 int len; 2589 if (recv(acceptFD, &len, sizeof(int), 0) != sizeof(int)) { 2590 ALOGE ("error reading on socket: Len of Args: \n"); 2591 freeDebugCallbackArgs(i, args); 2592 return; 2593 } 2594 // +1 for null-term 2595 args[i] = (char *) malloc((sizeof(char) * len) + 1); 2596 if (recv(acceptFD, args[i], sizeof(char) * len, 0) 2597 != (int)sizeof(char) * len) { 2598 ALOGE ("error reading on socket: Args[%d] \n", i); 2599 freeDebugCallbackArgs(i, args); 2600 return; 2601 } 2602 char * buf = args[i]; 2603 buf[len] = 0; 2604 } 2605 2606 switch (atoi(args[0])) { 2607 case 0: 2608 ALOGI ("Connection on debug port: issuing reset."); 2609 issueLocalRequest(RIL_REQUEST_RESET_RADIO, NULL, 0); 2610 break; 2611 case 1: 2612 ALOGI ("Connection on debug port: issuing radio power off."); 2613 data = 0; 2614 issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int)); 2615 // Close the socket 2616 close(s_fdCommand); 2617 s_fdCommand = -1; 2618 break; 2619 case 2: 2620 ALOGI ("Debug port: issuing unsolicited voice network change."); 2621 RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, 2622 NULL, 0); 2623 break; 2624 case 3: 2625 ALOGI ("Debug port: QXDM log enable."); 2626 qxdm_data[0] = 65536; // head.func_tag 2627 qxdm_data[1] = 16; // head.len 2628 qxdm_data[2] = 1; // mode: 1 for 'start logging' 2629 qxdm_data[3] = 32; // log_file_size: 32megabytes 2630 qxdm_data[4] = 0; // log_mask 2631 qxdm_data[5] = 8; // log_max_fileindex 2632 issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data, 2633 6 * sizeof(int)); 2634 break; 2635 case 4: 2636 ALOGI ("Debug port: QXDM log disable."); 2637 qxdm_data[0] = 65536; 2638 qxdm_data[1] = 16; 2639 qxdm_data[2] = 0; // mode: 0 for 'stop logging' 2640 qxdm_data[3] = 32; 2641 qxdm_data[4] = 0; 2642 qxdm_data[5] = 8; 2643 issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data, 2644 6 * sizeof(int)); 2645 break; 2646 case 5: 2647 ALOGI("Debug port: Radio On"); 2648 data = 1; 2649 issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int)); 2650 sleep(2); 2651 // Set network selection automatic. 2652 issueLocalRequest(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, NULL, 0); 2653 break; 2654 case 6: 2655 ALOGI("Debug port: Setup Data Call, Apn :%s\n", args[1]); 2656 actData[0] = args[1]; 2657 issueLocalRequest(RIL_REQUEST_SETUP_DATA_CALL, &actData, 2658 sizeof(actData)); 2659 break; 2660 case 7: 2661 ALOGI("Debug port: Deactivate Data Call"); 2662 issueLocalRequest(RIL_REQUEST_DEACTIVATE_DATA_CALL, &deactData, 2663 sizeof(deactData)); 2664 break; 2665 case 8: 2666 ALOGI("Debug port: Dial Call"); 2667 dialData.clir = 0; 2668 dialData.address = args[1]; 2669 issueLocalRequest(RIL_REQUEST_DIAL, &dialData, sizeof(dialData)); 2670 break; 2671 case 9: 2672 ALOGI("Debug port: Answer Call"); 2673 issueLocalRequest(RIL_REQUEST_ANSWER, NULL, 0); 2674 break; 2675 case 10: 2676 ALOGI("Debug port: End Call"); 2677 issueLocalRequest(RIL_REQUEST_HANGUP, &hangupData, 2678 sizeof(hangupData)); 2679 break; 2680 default: 2681 ALOGE ("Invalid request"); 2682 break; 2683 } 2684 freeDebugCallbackArgs(number, args); 2685 close(acceptFD); 2686} 2687 2688 2689static void userTimerCallback (int fd, short flags, void *param) { 2690 UserCallbackInfo *p_info; 2691 2692 p_info = (UserCallbackInfo *)param; 2693 2694 p_info->p_callback(p_info->userParam); 2695 2696 2697 // FIXME generalize this...there should be a cancel mechanism 2698 if (s_last_wake_timeout_info != NULL && s_last_wake_timeout_info == p_info) { 2699 s_last_wake_timeout_info = NULL; 2700 } 2701 2702 free(p_info); 2703} 2704 2705 2706static void * 2707eventLoop(void *param) { 2708 int ret; 2709 int filedes[2]; 2710 2711 ril_event_init(); 2712 2713 pthread_mutex_lock(&s_startupMutex); 2714 2715 s_started = 1; 2716 pthread_cond_broadcast(&s_startupCond); 2717 2718 pthread_mutex_unlock(&s_startupMutex); 2719 2720 ret = pipe(filedes); 2721 2722 if (ret < 0) { 2723 ALOGE("Error in pipe() errno:%d", errno); 2724 return NULL; 2725 } 2726 2727 s_fdWakeupRead = filedes[0]; 2728 s_fdWakeupWrite = filedes[1]; 2729 2730 fcntl(s_fdWakeupRead, F_SETFL, O_NONBLOCK); 2731 2732 ril_event_set (&s_wakeupfd_event, s_fdWakeupRead, true, 2733 processWakeupCallback, NULL); 2734 2735 rilEventAddWakeup (&s_wakeupfd_event); 2736 2737 // Only returns on error 2738 ril_event_loop(); 2739 ALOGE ("error in event_loop_base errno:%d", errno); 2740 // kill self to restart on error 2741 kill(0, SIGKILL); 2742 2743 return NULL; 2744} 2745 2746extern "C" void 2747RIL_startEventLoop(void) { 2748 int ret; 2749 pthread_attr_t attr; 2750 2751 /* spin up eventLoop thread and wait for it to get started */ 2752 s_started = 0; 2753 pthread_mutex_lock(&s_startupMutex); 2754 2755 pthread_attr_init (&attr); 2756 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); 2757 ret = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL); 2758 2759 while (s_started == 0) { 2760 pthread_cond_wait(&s_startupCond, &s_startupMutex); 2761 } 2762 2763 pthread_mutex_unlock(&s_startupMutex); 2764 2765 if (ret < 0) { 2766 ALOGE("Failed to create dispatch thread errno:%d", errno); 2767 return; 2768 } 2769} 2770 2771// Used for testing purpose only. 2772extern "C" void RIL_setcallbacks (const RIL_RadioFunctions *callbacks) { 2773 memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions)); 2774} 2775 2776extern "C" void 2777RIL_register (const RIL_RadioFunctions *callbacks) { 2778 int ret; 2779 int flags; 2780 2781 if (callbacks == NULL) { 2782 ALOGE("RIL_register: RIL_RadioFunctions * null"); 2783 return; 2784 } 2785 if (callbacks->version < RIL_VERSION_MIN) { 2786 ALOGE("RIL_register: version %d is to old, min version is %d", 2787 callbacks->version, RIL_VERSION_MIN); 2788 return; 2789 } 2790 if (callbacks->version > RIL_VERSION) { 2791 ALOGE("RIL_register: version %d is too new, max version is %d", 2792 callbacks->version, RIL_VERSION); 2793 return; 2794 } 2795 ALOGE("RIL_register: RIL version %d", callbacks->version); 2796 2797 if (s_registerCalled > 0) { 2798 ALOGE("RIL_register has been called more than once. " 2799 "Subsequent call ignored"); 2800 return; 2801 } 2802 2803 memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions)); 2804 2805 s_registerCalled = 1; 2806 2807 // Little self-check 2808 2809 for (int i = 0; i < (int)NUM_ELEMS(s_commands); i++) { 2810 assert(i == s_commands[i].requestNumber); 2811 } 2812 2813 for (int i = 0; i < (int)NUM_ELEMS(s_unsolResponses); i++) { 2814 assert(i + RIL_UNSOL_RESPONSE_BASE 2815 == s_unsolResponses[i].requestNumber); 2816 } 2817 2818 // New rild impl calls RIL_startEventLoop() first 2819 // old standalone impl wants it here. 2820 2821 if (s_started == 0) { 2822 RIL_startEventLoop(); 2823 } 2824 2825 // start listen socket 2826 2827#if 0 2828 ret = socket_local_server (SOCKET_NAME_RIL, 2829 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM); 2830 2831 if (ret < 0) { 2832 ALOGE("Unable to bind socket errno:%d", errno); 2833 exit (-1); 2834 } 2835 s_fdListen = ret; 2836 2837#else 2838 s_fdListen = android_get_control_socket(SOCKET_NAME_RIL); 2839 if (s_fdListen < 0) { 2840 ALOGE("Failed to get socket '" SOCKET_NAME_RIL "'"); 2841 exit(-1); 2842 } 2843 2844 ret = listen(s_fdListen, 4); 2845 2846 if (ret < 0) { 2847 ALOGE("Failed to listen on control socket '%d': %s", 2848 s_fdListen, strerror(errno)); 2849 exit(-1); 2850 } 2851#endif 2852 2853 2854 /* note: non-persistent so we can accept only one connection at a time */ 2855 ril_event_set (&s_listen_event, s_fdListen, false, 2856 listenCallback, NULL); 2857 2858 rilEventAddWakeup (&s_listen_event); 2859 2860#if 1 2861 // start debug interface socket 2862 2863 s_fdDebug = android_get_control_socket(SOCKET_NAME_RIL_DEBUG); 2864 if (s_fdDebug < 0) { 2865 ALOGE("Failed to get socket '" SOCKET_NAME_RIL_DEBUG "' errno:%d", errno); 2866 exit(-1); 2867 } 2868 2869 ret = listen(s_fdDebug, 4); 2870 2871 if (ret < 0) { 2872 ALOGE("Failed to listen on ril debug socket '%d': %s", 2873 s_fdDebug, strerror(errno)); 2874 exit(-1); 2875 } 2876 2877 ril_event_set (&s_debug_event, s_fdDebug, true, 2878 debugCallback, NULL); 2879 2880 rilEventAddWakeup (&s_debug_event); 2881#endif 2882 2883} 2884 2885static int 2886checkAndDequeueRequestInfo(struct RequestInfo *pRI) { 2887 int ret = 0; 2888 2889 if (pRI == NULL) { 2890 return 0; 2891 } 2892 2893 pthread_mutex_lock(&s_pendingRequestsMutex); 2894 2895 for(RequestInfo **ppCur = &s_pendingRequests 2896 ; *ppCur != NULL 2897 ; ppCur = &((*ppCur)->p_next) 2898 ) { 2899 if (pRI == *ppCur) { 2900 ret = 1; 2901 2902 *ppCur = (*ppCur)->p_next; 2903 break; 2904 } 2905 } 2906 2907 pthread_mutex_unlock(&s_pendingRequestsMutex); 2908 2909 return ret; 2910} 2911 2912 2913extern "C" void 2914RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen) { 2915 RequestInfo *pRI; 2916 int ret; 2917 size_t errorOffset; 2918 2919 pRI = (RequestInfo *)t; 2920 2921 if (!checkAndDequeueRequestInfo(pRI)) { 2922 ALOGE ("RIL_onRequestComplete: invalid RIL_Token"); 2923 return; 2924 } 2925 2926 if (pRI->local > 0) { 2927 // Locally issued command...void only! 2928 // response does not go back up the command socket 2929 ALOGD("C[locl]< %s", requestToString(pRI->pCI->requestNumber)); 2930 2931 goto done; 2932 } 2933 2934 appendPrintBuf("[%04d]< %s", 2935 pRI->token, requestToString(pRI->pCI->requestNumber)); 2936 2937 if (pRI->cancelled == 0) { 2938 Parcel p; 2939 2940 p.writeInt32 (RESPONSE_SOLICITED); 2941 p.writeInt32 (pRI->token); 2942 errorOffset = p.dataPosition(); 2943 2944 p.writeInt32 (e); 2945 2946 if (response != NULL) { 2947 // there is a response payload, no matter success or not. 2948 ret = pRI->pCI->responseFunction(p, response, responselen); 2949 2950 /* if an error occurred, rewind and mark it */ 2951 if (ret != 0) { 2952 p.setDataPosition(errorOffset); 2953 p.writeInt32 (ret); 2954 } 2955 } 2956 2957 if (e != RIL_E_SUCCESS) { 2958 appendPrintBuf("%s fails by %s", printBuf, failCauseToString(e)); 2959 } 2960 2961 if (s_fdCommand < 0) { 2962 ALOGD ("RIL onRequestComplete: Command channel closed"); 2963 } 2964 sendResponse(p); 2965 } 2966 2967done: 2968 free(pRI); 2969} 2970 2971 2972static void 2973grabPartialWakeLock() { 2974 acquire_wake_lock(PARTIAL_WAKE_LOCK, ANDROID_WAKE_LOCK_NAME); 2975} 2976 2977static void 2978releaseWakeLock() { 2979 release_wake_lock(ANDROID_WAKE_LOCK_NAME); 2980} 2981 2982/** 2983 * Timer callback to put us back to sleep before the default timeout 2984 */ 2985static void 2986wakeTimeoutCallback (void *param) { 2987 // We're using "param != NULL" as a cancellation mechanism 2988 if (param == NULL) { 2989 //ALOGD("wakeTimeout: releasing wake lock"); 2990 2991 releaseWakeLock(); 2992 } else { 2993 //ALOGD("wakeTimeout: releasing wake lock CANCELLED"); 2994 } 2995} 2996 2997static int 2998decodeVoiceRadioTechnology (RIL_RadioState radioState) { 2999 switch (radioState) { 3000 case RADIO_STATE_SIM_NOT_READY: 3001 case RADIO_STATE_SIM_LOCKED_OR_ABSENT: 3002 case RADIO_STATE_SIM_READY: 3003 return RADIO_TECH_UMTS; 3004 3005 case RADIO_STATE_RUIM_NOT_READY: 3006 case RADIO_STATE_RUIM_READY: 3007 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT: 3008 case RADIO_STATE_NV_NOT_READY: 3009 case RADIO_STATE_NV_READY: 3010 return RADIO_TECH_1xRTT; 3011 3012 default: 3013 ALOGD("decodeVoiceRadioTechnology: Invoked with incorrect RadioState"); 3014 return -1; 3015 } 3016} 3017 3018static int 3019decodeCdmaSubscriptionSource (RIL_RadioState radioState) { 3020 switch (radioState) { 3021 case RADIO_STATE_SIM_NOT_READY: 3022 case RADIO_STATE_SIM_LOCKED_OR_ABSENT: 3023 case RADIO_STATE_SIM_READY: 3024 case RADIO_STATE_RUIM_NOT_READY: 3025 case RADIO_STATE_RUIM_READY: 3026 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT: 3027 return CDMA_SUBSCRIPTION_SOURCE_RUIM_SIM; 3028 3029 case RADIO_STATE_NV_NOT_READY: 3030 case RADIO_STATE_NV_READY: 3031 return CDMA_SUBSCRIPTION_SOURCE_NV; 3032 3033 default: 3034 ALOGD("decodeCdmaSubscriptionSource: Invoked with incorrect RadioState"); 3035 return -1; 3036 } 3037} 3038 3039static int 3040decodeSimStatus (RIL_RadioState radioState) { 3041 switch (radioState) { 3042 case RADIO_STATE_SIM_NOT_READY: 3043 case RADIO_STATE_RUIM_NOT_READY: 3044 case RADIO_STATE_NV_NOT_READY: 3045 case RADIO_STATE_NV_READY: 3046 return -1; 3047 case RADIO_STATE_SIM_LOCKED_OR_ABSENT: 3048 case RADIO_STATE_SIM_READY: 3049 case RADIO_STATE_RUIM_READY: 3050 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT: 3051 return radioState; 3052 default: 3053 ALOGD("decodeSimStatus: Invoked with incorrect RadioState"); 3054 return -1; 3055 } 3056} 3057 3058static bool is3gpp2(int radioTech) { 3059 switch (radioTech) { 3060 case RADIO_TECH_IS95A: 3061 case RADIO_TECH_IS95B: 3062 case RADIO_TECH_1xRTT: 3063 case RADIO_TECH_EVDO_0: 3064 case RADIO_TECH_EVDO_A: 3065 case RADIO_TECH_EVDO_B: 3066 case RADIO_TECH_EHRPD: 3067 return true; 3068 default: 3069 return false; 3070 } 3071} 3072 3073/* If RIL sends SIM states or RUIM states, store the voice radio 3074 * technology and subscription source information so that they can be 3075 * returned when telephony framework requests them 3076 */ 3077static RIL_RadioState 3078processRadioState(RIL_RadioState newRadioState) { 3079 3080 if((newRadioState > RADIO_STATE_UNAVAILABLE) && (newRadioState < RADIO_STATE_ON)) { 3081 int newVoiceRadioTech; 3082 int newCdmaSubscriptionSource; 3083 int newSimStatus; 3084 3085 /* This is old RIL. Decode Subscription source and Voice Radio Technology 3086 from Radio State and send change notifications if there has been a change */ 3087 newVoiceRadioTech = decodeVoiceRadioTechnology(newRadioState); 3088 if(newVoiceRadioTech != voiceRadioTech) { 3089 voiceRadioTech = newVoiceRadioTech; 3090 RIL_onUnsolicitedResponse (RIL_UNSOL_VOICE_RADIO_TECH_CHANGED, 3091 &voiceRadioTech, sizeof(voiceRadioTech)); 3092 } 3093 if(is3gpp2(newVoiceRadioTech)) { 3094 newCdmaSubscriptionSource = decodeCdmaSubscriptionSource(newRadioState); 3095 if(newCdmaSubscriptionSource != cdmaSubscriptionSource) { 3096 cdmaSubscriptionSource = newCdmaSubscriptionSource; 3097 RIL_onUnsolicitedResponse (RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED, 3098 &cdmaSubscriptionSource, sizeof(cdmaSubscriptionSource)); 3099 } 3100 } 3101 newSimStatus = decodeSimStatus(newRadioState); 3102 if(newSimStatus != simRuimStatus) { 3103 simRuimStatus = newSimStatus; 3104 RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0); 3105 } 3106 3107 /* Send RADIO_ON to telephony */ 3108 newRadioState = RADIO_STATE_ON; 3109 } 3110 3111 return newRadioState; 3112} 3113 3114extern "C" 3115void RIL_onUnsolicitedResponse(int unsolResponse, void *data, 3116 size_t datalen) 3117{ 3118 int unsolResponseIndex; 3119 int ret; 3120 int64_t timeReceived = 0; 3121 bool shouldScheduleTimeout = false; 3122 RIL_RadioState newState; 3123 3124 if (s_registerCalled == 0) { 3125 // Ignore RIL_onUnsolicitedResponse before RIL_register 3126 ALOGW("RIL_onUnsolicitedResponse called before RIL_register"); 3127 return; 3128 } 3129 3130 unsolResponseIndex = unsolResponse - RIL_UNSOL_RESPONSE_BASE; 3131 3132 if ((unsolResponseIndex < 0) 3133 || (unsolResponseIndex >= (int32_t)NUM_ELEMS(s_unsolResponses))) { 3134 ALOGE("unsupported unsolicited response code %d", unsolResponse); 3135 return; 3136 } 3137 3138 // Grab a wake lock if needed for this reponse, 3139 // as we exit we'll either release it immediately 3140 // or set a timer to release it later. 3141 switch (s_unsolResponses[unsolResponseIndex].wakeType) { 3142 case WAKE_PARTIAL: 3143 grabPartialWakeLock(); 3144 shouldScheduleTimeout = true; 3145 break; 3146 3147 case DONT_WAKE: 3148 default: 3149 // No wake lock is grabed so don't set timeout 3150 shouldScheduleTimeout = false; 3151 break; 3152 } 3153 3154 // Mark the time this was received, doing this 3155 // after grabing the wakelock incase getting 3156 // the elapsedRealTime might cause us to goto 3157 // sleep. 3158 if (unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) { 3159 timeReceived = elapsedRealtime(); 3160 } 3161 3162 appendPrintBuf("[UNSL]< %s", requestToString(unsolResponse)); 3163 3164 Parcel p; 3165 3166 p.writeInt32 (RESPONSE_UNSOLICITED); 3167 p.writeInt32 (unsolResponse); 3168 3169 ret = s_unsolResponses[unsolResponseIndex] 3170 .responseFunction(p, data, datalen); 3171 if (ret != 0) { 3172 // Problem with the response. Don't continue; 3173 goto error_exit; 3174 } 3175 3176 // some things get more payload 3177 switch(unsolResponse) { 3178 case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: 3179 newState = processRadioState(s_callbacks.onStateRequest()); 3180 p.writeInt32(newState); 3181 appendPrintBuf("%s {%s}", printBuf, 3182 radioStateToString(s_callbacks.onStateRequest())); 3183 break; 3184 3185 3186 case RIL_UNSOL_NITZ_TIME_RECEIVED: 3187 // Store the time that this was received so the 3188 // handler of this message can account for 3189 // the time it takes to arrive and process. In 3190 // particular the system has been known to sleep 3191 // before this message can be processed. 3192 p.writeInt64(timeReceived); 3193 break; 3194 } 3195 3196 ret = sendResponse(p); 3197 if (ret != 0 && unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) { 3198 3199 // Unfortunately, NITZ time is not poll/update like everything 3200 // else in the system. So, if the upstream client isn't connected, 3201 // keep a copy of the last NITZ response (with receive time noted 3202 // above) around so we can deliver it when it is connected 3203 3204 if (s_lastNITZTimeData != NULL) { 3205 free (s_lastNITZTimeData); 3206 s_lastNITZTimeData = NULL; 3207 } 3208 3209 s_lastNITZTimeData = malloc(p.dataSize()); 3210 s_lastNITZTimeDataSize = p.dataSize(); 3211 memcpy(s_lastNITZTimeData, p.data(), p.dataSize()); 3212 } 3213 3214 // For now, we automatically go back to sleep after TIMEVAL_WAKE_TIMEOUT 3215 // FIXME The java code should handshake here to release wake lock 3216 3217 if (shouldScheduleTimeout) { 3218 // Cancel the previous request 3219 if (s_last_wake_timeout_info != NULL) { 3220 s_last_wake_timeout_info->userParam = (void *)1; 3221 } 3222 3223 s_last_wake_timeout_info 3224 = internalRequestTimedCallback(wakeTimeoutCallback, NULL, 3225 &TIMEVAL_WAKE_TIMEOUT); 3226 } 3227 3228 // Normal exit 3229 return; 3230 3231error_exit: 3232 if (shouldScheduleTimeout) { 3233 releaseWakeLock(); 3234 } 3235} 3236 3237/** FIXME generalize this if you track UserCAllbackInfo, clear it 3238 when the callback occurs 3239*/ 3240static UserCallbackInfo * 3241internalRequestTimedCallback (RIL_TimedCallback callback, void *param, 3242 const struct timeval *relativeTime) 3243{ 3244 struct timeval myRelativeTime; 3245 UserCallbackInfo *p_info; 3246 3247 p_info = (UserCallbackInfo *) malloc (sizeof(UserCallbackInfo)); 3248 3249 p_info->p_callback = callback; 3250 p_info->userParam = param; 3251 3252 if (relativeTime == NULL) { 3253 /* treat null parameter as a 0 relative time */ 3254 memset (&myRelativeTime, 0, sizeof(myRelativeTime)); 3255 } else { 3256 /* FIXME I think event_add's tv param is really const anyway */ 3257 memcpy (&myRelativeTime, relativeTime, sizeof(myRelativeTime)); 3258 } 3259 3260 ril_event_set(&(p_info->event), -1, false, userTimerCallback, p_info); 3261 3262 ril_timer_add(&(p_info->event), &myRelativeTime); 3263 3264 triggerEvLoop(); 3265 return p_info; 3266} 3267 3268 3269extern "C" void 3270RIL_requestTimedCallback (RIL_TimedCallback callback, void *param, 3271 const struct timeval *relativeTime) { 3272 internalRequestTimedCallback (callback, param, relativeTime); 3273} 3274 3275const char * 3276failCauseToString(RIL_Errno e) { 3277 switch(e) { 3278 case RIL_E_SUCCESS: return "E_SUCCESS"; 3279 case RIL_E_RADIO_NOT_AVAILABLE: return "E_RAIDO_NOT_AVAILABLE"; 3280 case RIL_E_GENERIC_FAILURE: return "E_GENERIC_FAILURE"; 3281 case RIL_E_PASSWORD_INCORRECT: return "E_PASSWORD_INCORRECT"; 3282 case RIL_E_SIM_PIN2: return "E_SIM_PIN2"; 3283 case RIL_E_SIM_PUK2: return "E_SIM_PUK2"; 3284 case RIL_E_REQUEST_NOT_SUPPORTED: return "E_REQUEST_NOT_SUPPORTED"; 3285 case RIL_E_CANCELLED: return "E_CANCELLED"; 3286 case RIL_E_OP_NOT_ALLOWED_DURING_VOICE_CALL: return "E_OP_NOT_ALLOWED_DURING_VOICE_CALL"; 3287 case RIL_E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW: return "E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW"; 3288 case RIL_E_SMS_SEND_FAIL_RETRY: return "E_SMS_SEND_FAIL_RETRY"; 3289 case RIL_E_SIM_ABSENT:return "E_SIM_ABSENT"; 3290 case RIL_E_ILLEGAL_SIM_OR_ME:return "E_ILLEGAL_SIM_OR_ME"; 3291#ifdef FEATURE_MULTIMODE_ANDROID 3292 case RIL_E_SUBSCRIPTION_NOT_AVAILABLE:return "E_SUBSCRIPTION_NOT_AVAILABLE"; 3293 case RIL_E_MODE_NOT_SUPPORTED:return "E_MODE_NOT_SUPPORTED"; 3294#endif 3295 default: return "<unknown error>"; 3296 } 3297} 3298 3299const char * 3300radioStateToString(RIL_RadioState s) { 3301 switch(s) { 3302 case RADIO_STATE_OFF: return "RADIO_OFF"; 3303 case RADIO_STATE_UNAVAILABLE: return "RADIO_UNAVAILABLE"; 3304 case RADIO_STATE_SIM_NOT_READY: return "RADIO_SIM_NOT_READY"; 3305 case RADIO_STATE_SIM_LOCKED_OR_ABSENT: return "RADIO_SIM_LOCKED_OR_ABSENT"; 3306 case RADIO_STATE_SIM_READY: return "RADIO_SIM_READY"; 3307 case RADIO_STATE_RUIM_NOT_READY:return"RADIO_RUIM_NOT_READY"; 3308 case RADIO_STATE_RUIM_READY:return"RADIO_RUIM_READY"; 3309 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:return"RADIO_RUIM_LOCKED_OR_ABSENT"; 3310 case RADIO_STATE_NV_NOT_READY:return"RADIO_NV_NOT_READY"; 3311 case RADIO_STATE_NV_READY:return"RADIO_NV_READY"; 3312 case RADIO_STATE_ON:return"RADIO_ON"; 3313 default: return "<unknown state>"; 3314 } 3315} 3316 3317const char * 3318callStateToString(RIL_CallState s) { 3319 switch(s) { 3320 case RIL_CALL_ACTIVE : return "ACTIVE"; 3321 case RIL_CALL_HOLDING: return "HOLDING"; 3322 case RIL_CALL_DIALING: return "DIALING"; 3323 case RIL_CALL_ALERTING: return "ALERTING"; 3324 case RIL_CALL_INCOMING: return "INCOMING"; 3325 case RIL_CALL_WAITING: return "WAITING"; 3326 default: return "<unknown state>"; 3327 } 3328} 3329 3330const char * 3331requestToString(int request) { 3332/* 3333 cat libs/telephony/ril_commands.h \ 3334 | egrep "^ *{RIL_" \ 3335 | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/' 3336 3337 3338 cat libs/telephony/ril_unsol_commands.h \ 3339 | egrep "^ *{RIL_" \ 3340 | sed -re 's/\{RIL_([^,]+),([^}]+).+/case RIL_\1: return "\1";/' 3341 3342*/ 3343 switch(request) { 3344 case RIL_REQUEST_GET_SIM_STATUS: return "GET_SIM_STATUS"; 3345 case RIL_REQUEST_ENTER_SIM_PIN: return "ENTER_SIM_PIN"; 3346 case RIL_REQUEST_ENTER_SIM_PUK: return "ENTER_SIM_PUK"; 3347 case RIL_REQUEST_ENTER_SIM_PIN2: return "ENTER_SIM_PIN2"; 3348 case RIL_REQUEST_ENTER_SIM_PUK2: return "ENTER_SIM_PUK2"; 3349 case RIL_REQUEST_CHANGE_SIM_PIN: return "CHANGE_SIM_PIN"; 3350 case RIL_REQUEST_CHANGE_SIM_PIN2: return "CHANGE_SIM_PIN2"; 3351 case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: return "ENTER_NETWORK_DEPERSONALIZATION"; 3352 case RIL_REQUEST_GET_CURRENT_CALLS: return "GET_CURRENT_CALLS"; 3353 case RIL_REQUEST_DIAL: return "DIAL"; 3354 case RIL_REQUEST_GET_IMSI: return "GET_IMSI"; 3355 case RIL_REQUEST_HANGUP: return "HANGUP"; 3356 case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: return "HANGUP_WAITING_OR_BACKGROUND"; 3357 case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: return "HANGUP_FOREGROUND_RESUME_BACKGROUND"; 3358 case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: return "SWITCH_WAITING_OR_HOLDING_AND_ACTIVE"; 3359 case RIL_REQUEST_CONFERENCE: return "CONFERENCE"; 3360 case RIL_REQUEST_UDUB: return "UDUB"; 3361 case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: return "LAST_CALL_FAIL_CAUSE"; 3362 case RIL_REQUEST_SIGNAL_STRENGTH: return "SIGNAL_STRENGTH"; 3363 case RIL_REQUEST_VOICE_REGISTRATION_STATE: return "VOICE_REGISTRATION_STATE"; 3364 case RIL_REQUEST_DATA_REGISTRATION_STATE: return "DATA_REGISTRATION_STATE"; 3365 case RIL_REQUEST_OPERATOR: return "OPERATOR"; 3366 case RIL_REQUEST_RADIO_POWER: return "RADIO_POWER"; 3367 case RIL_REQUEST_DTMF: return "DTMF"; 3368 case RIL_REQUEST_SEND_SMS: return "SEND_SMS"; 3369 case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE"; 3370 case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL"; 3371 case RIL_REQUEST_SIM_IO: return "SIM_IO"; 3372 case RIL_REQUEST_SEND_USSD: return "SEND_USSD"; 3373 case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD"; 3374 case RIL_REQUEST_GET_CLIR: return "GET_CLIR"; 3375 case RIL_REQUEST_SET_CLIR: return "SET_CLIR"; 3376 case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: return "QUERY_CALL_FORWARD_STATUS"; 3377 case RIL_REQUEST_SET_CALL_FORWARD: return "SET_CALL_FORWARD"; 3378 case RIL_REQUEST_QUERY_CALL_WAITING: return "QUERY_CALL_WAITING"; 3379 case RIL_REQUEST_SET_CALL_WAITING: return "SET_CALL_WAITING"; 3380 case RIL_REQUEST_SMS_ACKNOWLEDGE: return "SMS_ACKNOWLEDGE"; 3381 case RIL_REQUEST_GET_IMEI: return "GET_IMEI"; 3382 case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV"; 3383 case RIL_REQUEST_ANSWER: return "ANSWER"; 3384 case RIL_REQUEST_DEACTIVATE_DATA_CALL: return "DEACTIVATE_DATA_CALL"; 3385 case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK"; 3386 case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK"; 3387 case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD"; 3388 case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: return "QUERY_NETWORK_SELECTION_MODE"; 3389 case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC"; 3390 case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL"; 3391 case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS "; 3392 case RIL_REQUEST_DTMF_START: return "DTMF_START"; 3393 case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP"; 3394 case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION"; 3395 case RIL_REQUEST_SEPARATE_CONNECTION: return "SEPARATE_CONNECTION"; 3396 case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: return "SET_PREFERRED_NETWORK_TYPE"; 3397 case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "GET_PREFERRED_NETWORK_TYPE"; 3398 case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "GET_NEIGHBORING_CELL_IDS"; 3399 case RIL_REQUEST_SET_MUTE: return "SET_MUTE"; 3400 case RIL_REQUEST_GET_MUTE: return "GET_MUTE"; 3401 case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP"; 3402 case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE"; 3403 case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST"; 3404 case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO"; 3405 case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW"; 3406 case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS"; 3407 case RIL_REQUEST_SET_BAND_MODE: return "SET_BAND_MODE"; 3408 case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: return "QUERY_AVAILABLE_BAND_MODE"; 3409 case RIL_REQUEST_STK_GET_PROFILE: return "STK_GET_PROFILE"; 3410 case RIL_REQUEST_STK_SET_PROFILE: return "STK_SET_PROFILE"; 3411 case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: return "STK_SEND_ENVELOPE_COMMAND"; 3412 case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: return "STK_SEND_TERMINAL_RESPONSE"; 3413 case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: return "STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM"; 3414 case RIL_REQUEST_SCREEN_STATE: return "SCREEN_STATE"; 3415 case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: return "EXPLICIT_CALL_TRANSFER"; 3416 case RIL_REQUEST_SET_LOCATION_UPDATES: return "SET_LOCATION_UPDATES"; 3417 case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:return"CDMA_SET_SUBSCRIPTION_SOURCE"; 3418 case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:return"CDMA_SET_ROAMING_PREFERENCE"; 3419 case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:return"CDMA_QUERY_ROAMING_PREFERENCE"; 3420 case RIL_REQUEST_SET_TTY_MODE:return"SET_TTY_MODE"; 3421 case RIL_REQUEST_QUERY_TTY_MODE:return"QUERY_TTY_MODE"; 3422 case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE"; 3423 case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE"; 3424 case RIL_REQUEST_CDMA_FLASH:return"CDMA_FLASH"; 3425 case RIL_REQUEST_CDMA_BURST_DTMF:return"CDMA_BURST_DTMF"; 3426 case RIL_REQUEST_CDMA_SEND_SMS:return"CDMA_SEND_SMS"; 3427 case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE:return"CDMA_SMS_ACKNOWLEDGE"; 3428 case RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG:return"GSM_GET_BROADCAST_SMS_CONFIG"; 3429 case RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG:return"GSM_SET_BROADCAST_SMS_CONFIG"; 3430 case RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG:return "CDMA_GET_BROADCAST_SMS_CONFIG"; 3431 case RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG:return "CDMA_SET_BROADCAST_SMS_CONFIG"; 3432 case RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION:return "CDMA_SMS_BROADCAST_ACTIVATION"; 3433 case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: return"CDMA_VALIDATE_AND_WRITE_AKEY"; 3434 case RIL_REQUEST_CDMA_SUBSCRIPTION: return"CDMA_SUBSCRIPTION"; 3435 case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: return "CDMA_WRITE_SMS_TO_RUIM"; 3436 case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: return "CDMA_DELETE_SMS_ON_RUIM"; 3437 case RIL_REQUEST_DEVICE_IDENTITY: return "DEVICE_IDENTITY"; 3438 case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: return "EXIT_EMERGENCY_CALLBACK_MODE"; 3439 case RIL_REQUEST_GET_SMSC_ADDRESS: return "GET_SMSC_ADDRESS"; 3440 case RIL_REQUEST_SET_SMSC_ADDRESS: return "SET_SMSC_ADDRESS"; 3441 case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: return "REPORT_SMS_MEMORY_STATUS"; 3442 case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: return "REPORT_STK_SERVICE_IS_RUNNING"; 3443 case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: return "CDMA_GET_SUBSCRIPTION_SOURCE"; 3444 case RIL_REQUEST_ISIM_AUTHENTICATION: return "ISIM_AUTHENTICATION"; 3445 case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU"; 3446 case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS"; 3447 case RIL_REQUEST_VOICE_RADIO_TECH: return "VOICE_RADIO_TECH"; 3448 case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED"; 3449 case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED"; 3450 case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED"; 3451 case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS"; 3452 case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT"; 3453 case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM"; 3454 case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD"; 3455 case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)"; 3456 case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED"; 3457 case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH"; 3458 case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END"; 3459 case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND"; 3460 case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY"; 3461 case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP"; 3462 case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FUL"; 3463 case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH"; 3464 case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED"; 3465 case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING"; 3466 case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED"; 3467 case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_NEW_CDMA_SMS"; 3468 case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: return "UNSOL_NEW_BROADCAST_SMS"; 3469 case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL"; 3470 case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "UNSOL_RESTRICTED_STATE_CHANGED"; 3471 case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE"; 3472 case RIL_UNSOL_CDMA_CALL_WAITING: return "UNSOL_CDMA_CALL_WAITING"; 3473 case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: return "UNSOL_CDMA_OTA_PROVISION_STATUS"; 3474 case RIL_UNSOL_CDMA_INFO_REC: return "UNSOL_CDMA_INFO_REC"; 3475 case RIL_UNSOL_OEM_HOOK_RAW: return "UNSOL_OEM_HOOK_RAW"; 3476 case RIL_UNSOL_RINGBACK_TONE: return "UNSOL_RINGBACK_TONE"; 3477 case RIL_UNSOL_RESEND_INCALL_MUTE: return "UNSOL_RESEND_INCALL_MUTE"; 3478 case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: return "UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED"; 3479 case RIL_UNSOL_CDMA_PRL_CHANGED: return "UNSOL_CDMA_PRL_CHANGED"; 3480 case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE"; 3481 case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED"; 3482 case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: return "UNSOL_VOICE_RADIO_TECH_CHANGED"; 3483 default: return "<unknown request>"; 3484 } 3485} 3486 3487} /* namespace android */ 3488