libril/ril_service.cpp

   1 /*
   2  * Copyright (c) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #define LOG_TAG "RILC"
  18
  19 #include <android/hardware/radio/1.0/IRadio.h>
  20 #include <android/hardware/radio/deprecated/1.0/IOemHook.h>
  21
  22 #include <hwbinder/IPCThreadState.h>
  23 #include <hwbinder/ProcessState.h>
  24 #include <ril_service.h>
  25 #include <hidl/HidlTransportSupport.h>
  26 #include <utils/SystemClock.h>
  27 #include <inttypes.h>
  28
  29 #define INVALID_HEX_CHAR 16
  30
  31 // Enable verbose logging
  32 #define VDBG 0
  33
  34 using namespace android::hardware::radio::V1_0;
  35 using namespace android::hardware::radio::deprecated::V1_0;
  36 using ::android::hardware::configureRpcThreadpool;
  37 using ::android::hardware::joinRpcThreadpool;
  38 using ::android::hardware::Return;
  39 using ::android::hardware::hidl_string;
  40 using ::android::hardware::hidl_vec;
  41 using ::android::hardware::hidl_array;
  42 using ::android::hardware::Void;
  43 using android::CommandInfo;
  44 using android::RequestInfo;
  45 using android::requestToString;
  46 using android::sp;
  47
  48 #define BOOL_TO_INT(x) (x ? 1 : 0)
  49 #define ATOI_NULL_HANDLED(x) (x ? atoi(x) : -1)
  50 #define ATOI_NULL_HANDLED_DEF(x, defaultVal) (x ? atoi(x) : defaultVal)
  51
  52 RIL_RadioFunctions *s_vendorFunctions = NULL;
  53 static CommandInfo *s_commands;
  54
  55 struct RadioImpl;
  56 struct OemHookImpl;
  57
  58 #if (SIM_COUNT >= 2)
  59 sp<RadioImpl> radioService[SIM_COUNT];
  60 sp<OemHookImpl> oemHookService[SIM_COUNT];
  61 // counter used for synchronization. It is incremented every time response callbacks are updated.
  62 volatile int32_t mCounterRadio[SIM_COUNT];
  63 volatile int32_t mCounterOemHook[SIM_COUNT];
  64 #else
  65 sp<RadioImpl> radioService[1];
  66 sp<OemHookImpl> oemHookService[1];
  67 // counter used for synchronization. It is incremented every time response callbacks are updated.
  68 volatile int32_t mCounterRadio[1];
  69 volatile int32_t mCounterOemHook[1];
  70 #endif
  71
  72 static pthread_rwlock_t radioServiceRwlock = PTHREAD_RWLOCK_INITIALIZER;
  73
  74 #if (SIM_COUNT >= 2)
  75 static pthread_rwlock_t radioServiceRwlock2 = PTHREAD_RWLOCK_INITIALIZER;
  76 #if (SIM_COUNT >= 3)
  77 static pthread_rwlock_t radioServiceRwlock3 = PTHREAD_RWLOCK_INITIALIZER;
  78 #if (SIM_COUNT >= 4)
  79 static pthread_rwlock_t radioServiceRwlock4 = PTHREAD_RWLOCK_INITIALIZER;
  80 #endif
  81 #endif
  82 #endif
  83
  84 void convertRilHardwareConfigListToHal(void *response, size_t responseLen,
  85         hidl_vec<HardwareConfig>& records);
  86
  87 void convertRilRadioCapabilityToHal(void *response, size_t responseLen, RadioCapability& rc);
  88
  89 void convertRilLceDataInfoToHal(void *response, size_t responseLen, LceDataInfo& lce);
  90
  91 void convertRilSignalStrengthToHal(void *response, size_t responseLen,
  92         SignalStrength& signalStrength);
  93
  94 void convertRilDataCallToHal(RIL_Data_Call_Response_v11 *dcResponse,
  95         SetupDataCallResult& dcResult);
  96
  97 void convertRilDataCallListToHal(void *response, size_t responseLen,
  98         hidl_vec<SetupDataCallResult>& dcResultList);
  99
 100 void convertRilCellInfoListToHal(void *response, size_t responseLen, hidl_vec<CellInfo>& records);
 101
 102 struct RadioImpl : public IRadio {
 103     int32_t mSlotId;
 104     sp<IRadioResponse> mRadioResponse;
 105     sp<IRadioIndication> mRadioIndication;
 106
 107     Return<void> setResponseFunctions(
 108             const ::android::sp<IRadioResponse>& radioResponse,
 109             const ::android::sp<IRadioIndication>& radioIndication);
 110
 111     Return<void> getIccCardStatus(int32_t serial);
 112
 113     Return<void> supplyIccPinForApp(int32_t serial, const hidl_string& pin,
 114             const hidl_string& aid);
 115
 116     Return<void> supplyIccPukForApp(int32_t serial, const hidl_string& puk,
 117             const hidl_string& pin, const hidl_string& aid);
 118
 119     Return<void> supplyIccPin2ForApp(int32_t serial,
 120             const hidl_string& pin2,
 121             const hidl_string& aid);
 122
 123     Return<void> supplyIccPuk2ForApp(int32_t serial, const hidl_string& puk2,
 124             const hidl_string& pin2, const hidl_string& aid);
 125
 126     Return<void> changeIccPinForApp(int32_t serial, const hidl_string& oldPin,
 127             const hidl_string& newPin, const hidl_string& aid);
 128
 129     Return<void> changeIccPin2ForApp(int32_t serial, const hidl_string& oldPin2,
 130             const hidl_string& newPin2, const hidl_string& aid);
 131
 132     Return<void> supplyNetworkDepersonalization(int32_t serial, const hidl_string& netPin);
 133
 134     Return<void> getCurrentCalls(int32_t serial);
 135
 136     Return<void> dial(int32_t serial, const Dial& dialInfo);
 137
 138     Return<void> getImsiForApp(int32_t serial,
 139             const ::android::hardware::hidl_string& aid);
 140
 141     Return<void> hangup(int32_t serial, int32_t gsmIndex);
 142
 143     Return<void> hangupWaitingOrBackground(int32_t serial);
 144
 145     Return<void> hangupForegroundResumeBackground(int32_t serial);
 146
 147     Return<void> switchWaitingOrHoldingAndActive(int32_t serial);
 148
 149     Return<void> conference(int32_t serial);
 150
 151     Return<void> rejectCall(int32_t serial);
 152
 153     Return<void> getLastCallFailCause(int32_t serial);
 154
 155     Return<void> getSignalStrength(int32_t serial);
 156
 157     Return<void> getVoiceRegistrationState(int32_t serial);
 158
 159     Return<void> getDataRegistrationState(int32_t serial);
 160
 161     Return<void> getOperator(int32_t serial);
 162
 163     Return<void> setRadioPower(int32_t serial, bool on);
 164
 165     Return<void> sendDtmf(int32_t serial,
 166             const ::android::hardware::hidl_string& s);
 167
 168     Return<void> sendSms(int32_t serial, const GsmSmsMessage& message);
 169
 170     Return<void> sendSMSExpectMore(int32_t serial, const GsmSmsMessage& message);
 171
 172     Return<void> setupDataCall(int32_t serial,
 173             RadioTechnology radioTechnology,
 174             const DataProfileInfo& profileInfo,
 175             bool modemCognitive,
 176             bool roamingAllowed,
 177             bool isRoaming);
 178
 179     Return<void> iccIOForApp(int32_t serial,
 180             const IccIo& iccIo);
 181
 182     Return<void> sendUssd(int32_t serial,
 183             const ::android::hardware::hidl_string& ussd);
 184
 185     Return<void> cancelPendingUssd(int32_t serial);
 186
 187     Return<void> getClir(int32_t serial);
 188
 189     Return<void> setClir(int32_t serial, int32_t status);
 190
 191     Return<void> getCallForwardStatus(int32_t serial,
 192             const CallForwardInfo& callInfo);
 193
 194     Return<void> setCallForward(int32_t serial,
 195             const CallForwardInfo& callInfo);
 196
 197     Return<void> getCallWaiting(int32_t serial, int32_t serviceClass);
 198
 199     Return<void> setCallWaiting(int32_t serial, bool enable, int32_t serviceClass);
 200
 201     Return<void> acknowledgeLastIncomingGsmSms(int32_t serial,
 202             bool success, SmsAcknowledgeFailCause cause);
 203
 204     Return<void> acceptCall(int32_t serial);
 205
 206     Return<void> deactivateDataCall(int32_t serial,
 207             int32_t cid, bool reasonRadioShutDown);
 208
 209     Return<void> getFacilityLockForApp(int32_t serial,
 210             const ::android::hardware::hidl_string& facility,
 211             const ::android::hardware::hidl_string& password,
 212             int32_t serviceClass,
 213             const ::android::hardware::hidl_string& appId);
 214
 215     Return<void> setFacilityLockForApp(int32_t serial,
 216             const ::android::hardware::hidl_string& facility,
 217             bool lockState,
 218             const ::android::hardware::hidl_string& password,
 219             int32_t serviceClass,
 220             const ::android::hardware::hidl_string& appId);
 221
 222     Return<void> setBarringPassword(int32_t serial,
 223             const ::android::hardware::hidl_string& facility,
 224             const ::android::hardware::hidl_string& oldPassword,
 225             const ::android::hardware::hidl_string& newPassword);
 226
 227     Return<void> getNetworkSelectionMode(int32_t serial);
 228
 229     Return<void> setNetworkSelectionModeAutomatic(int32_t serial);
 230
 231     Return<void> setNetworkSelectionModeManual(int32_t serial,
 232             const ::android::hardware::hidl_string& operatorNumeric);
 233
 234     Return<void> getAvailableNetworks(int32_t serial);
 235
 236     Return<void> startDtmf(int32_t serial,
 237             const ::android::hardware::hidl_string& s);
 238
 239     Return<void> stopDtmf(int32_t serial);
 240
 241     Return<void> getBasebandVersion(int32_t serial);
 242
 243     Return<void> separateConnection(int32_t serial, int32_t gsmIndex);
 244
 245     Return<void> setMute(int32_t serial, bool enable);
 246
 247     Return<void> getMute(int32_t serial);
 248
 249     Return<void> getClip(int32_t serial);
 250
 251     Return<void> getDataCallList(int32_t serial);
 252
 253     Return<void> setSuppServiceNotifications(int32_t serial, bool enable);
 254
 255     Return<void> writeSmsToSim(int32_t serial,
 256             const SmsWriteArgs& smsWriteArgs);
 257
 258     Return<void> deleteSmsOnSim(int32_t serial, int32_t index);
 259
 260     Return<void> setBandMode(int32_t serial, RadioBandMode mode);
 261
 262     Return<void> getAvailableBandModes(int32_t serial);
 263
 264     Return<void> sendEnvelope(int32_t serial,
 265             const ::android::hardware::hidl_string& command);
 266
 267     Return<void> sendTerminalResponseToSim(int32_t serial,
 268             const ::android::hardware::hidl_string& commandResponse);
 269
 270     Return<void> handleStkCallSetupRequestFromSim(int32_t serial, bool accept);
 271
 272     Return<void> explicitCallTransfer(int32_t serial);
 273
 274     Return<void> setPreferredNetworkType(int32_t serial, PreferredNetworkType nwType);
 275
 276     Return<void> getPreferredNetworkType(int32_t serial);
 277
 278     Return<void> getNeighboringCids(int32_t serial);
 279
 280     Return<void> setLocationUpdates(int32_t serial, bool enable);
 281
 282     Return<void> setCdmaSubscriptionSource(int32_t serial,
 283             CdmaSubscriptionSource cdmaSub);
 284
 285     Return<void> setCdmaRoamingPreference(int32_t serial, CdmaRoamingType type);
 286
 287     Return<void> getCdmaRoamingPreference(int32_t serial);
 288
 289     Return<void> setTTYMode(int32_t serial, TtyMode mode);
 290
 291     Return<void> getTTYMode(int32_t serial);
 292
 293     Return<void> setPreferredVoicePrivacy(int32_t serial, bool enable);
 294
 295     Return<void> getPreferredVoicePrivacy(int32_t serial);
 296
 297     Return<void> sendCDMAFeatureCode(int32_t serial,
 298             const ::android::hardware::hidl_string& featureCode);
 299
 300     Return<void> sendBurstDtmf(int32_t serial,
 301             const ::android::hardware::hidl_string& dtmf,
 302             int32_t on,
 303             int32_t off);
 304
 305     Return<void> sendCdmaSms(int32_t serial, const CdmaSmsMessage& sms);
 306
 307     Return<void> acknowledgeLastIncomingCdmaSms(int32_t serial,
 308             const CdmaSmsAck& smsAck);
 309
 310     Return<void> getGsmBroadcastConfig(int32_t serial);
 311
 312     Return<void> setGsmBroadcastConfig(int32_t serial,
 313             const hidl_vec<GsmBroadcastSmsConfigInfo>& configInfo);
 314
 315     Return<void> setGsmBroadcastActivation(int32_t serial, bool activate);
 316
 317     Return<void> getCdmaBroadcastConfig(int32_t serial);
 318
 319     Return<void> setCdmaBroadcastConfig(int32_t serial,
 320             const hidl_vec<CdmaBroadcastSmsConfigInfo>& configInfo);
 321
 322     Return<void> setCdmaBroadcastActivation(int32_t serial, bool activate);
 323
 324     Return<void> getCDMASubscription(int32_t serial);
 325
 326     Return<void> writeSmsToRuim(int32_t serial, const CdmaSmsWriteArgs& cdmaSms);
 327
 328     Return<void> deleteSmsOnRuim(int32_t serial, int32_t index);
 329
 330     Return<void> getDeviceIdentity(int32_t serial);
 331
 332     Return<void> exitEmergencyCallbackMode(int32_t serial);
 333
 334     Return<void> getSmscAddress(int32_t serial);
 335
 336     Return<void> setSmscAddress(int32_t serial,
 337             const ::android::hardware::hidl_string& smsc);
 338
 339     Return<void> reportSmsMemoryStatus(int32_t serial, bool available);
 340
 341     Return<void> reportStkServiceIsRunning(int32_t serial);
 342
 343     Return<void> getCdmaSubscriptionSource(int32_t serial);
 344
 345     Return<void> requestIsimAuthentication(int32_t serial,
 346             const ::android::hardware::hidl_string& challenge);
 347
 348     Return<void> acknowledgeIncomingGsmSmsWithPdu(int32_t serial,
 349             bool success,
 350             const ::android::hardware::hidl_string& ackPdu);
 351
 352     Return<void> sendEnvelopeWithStatus(int32_t serial,
 353             const ::android::hardware::hidl_string& contents);
 354
 355     Return<void> getVoiceRadioTechnology(int32_t serial);
 356
 357     Return<void> getCellInfoList(int32_t serial);
 358
 359     Return<void> setCellInfoListRate(int32_t serial, int32_t rate);
 360
 361     Return<void> setInitialAttachApn(int32_t serial, const DataProfileInfo& dataProfileInfo,
 362             bool modemCognitive, bool isRoaming);
 363
 364     Return<void> getImsRegistrationState(int32_t serial);
 365
 366     Return<void> sendImsSms(int32_t serial, const ImsSmsMessage& message);
 367
 368     Return<void> iccTransmitApduBasicChannel(int32_t serial, const SimApdu& message);
 369
 370     Return<void> iccOpenLogicalChannel(int32_t serial,
 371             const ::android::hardware::hidl_string& aid, int32_t p2);
 372
 373     Return<void> iccCloseLogicalChannel(int32_t serial, int32_t channelId);
 374
 375     Return<void> iccTransmitApduLogicalChannel(int32_t serial, const SimApdu& message);
 376
 377     Return<void> nvReadItem(int32_t serial, NvItem itemId);
 378
 379     Return<void> nvWriteItem(int32_t serial, const NvWriteItem& item);
 380
 381     Return<void> nvWriteCdmaPrl(int32_t serial,
 382             const ::android::hardware::hidl_vec<uint8_t>& prl);
 383
 384     Return<void> nvResetConfig(int32_t serial, ResetNvType resetType);
 385
 386     Return<void> setUiccSubscription(int32_t serial, const SelectUiccSub& uiccSub);
 387
 388     Return<void> setDataAllowed(int32_t serial, bool allow);
 389
 390     Return<void> getHardwareConfig(int32_t serial);
 391
 392     Return<void> requestIccSimAuthentication(int32_t serial,
 393             int32_t authContext,
 394             const ::android::hardware::hidl_string& authData,
 395             const ::android::hardware::hidl_string& aid);
 396
 397     Return<void> setDataProfile(int32_t serial,
 398             const ::android::hardware::hidl_vec<DataProfileInfo>& profiles, bool isRoaming);
 399
 400     Return<void> requestShutdown(int32_t serial);
 401
 402     Return<void> getRadioCapability(int32_t serial);
 403
 404     Return<void> setRadioCapability(int32_t serial, const RadioCapability& rc);
 405
 406     Return<void> startLceService(int32_t serial, int32_t reportInterval, bool pullMode);
 407
 408     Return<void> stopLceService(int32_t serial);
 409
 410     Return<void> pullLceData(int32_t serial);
 411
 412     Return<void> getModemActivityInfo(int32_t serial);
 413
 414     Return<void> setAllowedCarriers(int32_t serial,
 415             bool allAllowed,
 416             const CarrierRestrictions& carriers);
 417
 418     Return<void> getAllowedCarriers(int32_t serial);
 419
 420     Return<void> sendDeviceState(int32_t serial, DeviceStateType deviceStateType, bool state);
 421
 422     Return<void> setIndicationFilter(int32_t serial, int32_t indicationFilter);
 423
 424     Return<void> setSimCardPower(int32_t serial, bool powerUp);
 425
 426     Return<void> responseAcknowledgement();
 427
 428     void checkReturnStatus(Return<void>& ret);
 429 };
 430
 431 struct OemHookImpl : public IOemHook {
 432     int32_t mSlotId;
 433     sp<IOemHookResponse> mOemHookResponse;
 434     sp<IOemHookIndication> mOemHookIndication;
 435
 436     Return<void> setResponseFunctions(
 437             const ::android::sp<IOemHookResponse>& oemHookResponse,
 438             const ::android::sp<IOemHookIndication>& oemHookIndication);
 439
 440     Return<void> sendRequestRaw(int32_t serial,
 441             const ::android::hardware::hidl_vec<uint8_t>& data);
 442
 443     Return<void> sendRequestStrings(int32_t serial,
 444             const ::android::hardware::hidl_vec<::android::hardware::hidl_string>& data);
 445 };
 446
 447 void memsetAndFreeStrings(int numPointers, ...) {
 448     va_list ap;
 449     va_start(ap, numPointers);
 450     for (int i = 0; i < numPointers; i++) {
 451         char *ptr = va_arg(ap, char *);
 452         if (ptr) {
 453 #ifdef MEMSET_FREED
 454 #define MAX_STRING_LENGTH 4096
 455             memset(ptr, 0, strnlen(ptr, MAX_STRING_LENGTH));
 456 #endif
 457             free(ptr);
 458         }
 459     }
 460     va_end(ap);
 461 }
 462
 463 void sendErrorResponse(RequestInfo *pRI, RIL_Errno err) {
 464     pRI->pCI->responseFunction((int) pRI->socket_id,
 465             (int) RadioResponseType::SOLICITED, pRI->token, err, NULL, 0);
 466 }
 467
 468 /**
 469  * Copies over src to dest. If memory allocation fails, responseFunction() is called for the
 470  * request with error RIL_E_NO_MEMORY.
 471  * Returns true on success, and false on failure.
 472  */
 473 bool copyHidlStringToRil(char **dest, const hidl_string &src, RequestInfo *pRI) {
 474     size_t len = src.size();
 475     if (len == 0) {
 476         *dest = NULL;
 477         return true;
 478     }
 479     *dest = (char *) calloc(len + 1, sizeof(char));
 480     if (*dest == NULL) {
 481         RLOGE("Memory allocation failed for request %s", requestToString(pRI->pCI->requestNumber));
 482         sendErrorResponse(pRI, RIL_E_NO_MEMORY);
 483         return false;
 484     }
 485     strncpy(*dest, src.c_str(), len + 1);
 486     return true;
 487 }
 488
 489 hidl_string convertCharPtrToHidlString(const char *ptr) {
 490     hidl_string ret;
 491     if (ptr != NULL) {
 492         // TODO: replace this with strnlen
 493         ret.setToExternal(ptr, strlen(ptr));
 494     }
 495     return ret;
 496 }
 497
 498 bool dispatchVoid(int serial, int slotId, int request) {
 499     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 500     if (pRI == NULL) {
 501         return false;
 502     }
 503     s_vendorFunctions->onRequest(request, NULL, 0, pRI);
 504     return true;
 505 }
 506
 507 bool dispatchString(int serial, int slotId, int request, const char * str) {
 508     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 509     if (pRI == NULL) {
 510         return false;
 511     }
 512
 513     char *pString;
 514     if (!copyHidlStringToRil(&pString, str, pRI)) {
 515         return false;
 516     }
 517
 518     s_vendorFunctions->onRequest(request, pString, sizeof(char *), pRI);
 519
 520     memsetAndFreeStrings(1, pString);
 521     return true;
 522 }
 523
 524 bool dispatchStrings(int serial, int slotId, int request, int countStrings, ...) {
 525     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 526     if (pRI == NULL) {
 527         return false;
 528     }
 529
 530     char **pStrings;
 531     pStrings = (char **)calloc(countStrings, sizeof(char *));
 532     if (pStrings == NULL) {
 533         RLOGE("Memory allocation failed for request %s", requestToString(request));
 534         sendErrorResponse(pRI, RIL_E_NO_MEMORY);
 535         return false;
 536     }
 537     va_list ap;
 538     va_start(ap, countStrings);
 539     for (int i = 0; i < countStrings; i++) {
 540         const char* str = va_arg(ap, const char *);
 541         if (!copyHidlStringToRil(&pStrings[i], hidl_string(str), pRI)) {
 542             va_end(ap);
 543             for (int j = 0; j < i; j++) {
 544                 memsetAndFreeStrings(1, pStrings[j]);
 545             }
 546             free(pStrings);
 547             return false;
 548         }
 549     }
 550     va_end(ap);
 551
 552     s_vendorFunctions->onRequest(request, pStrings, countStrings * sizeof(char *), pRI);
 553
 554     if (pStrings != NULL) {
 555         for (int i = 0 ; i < countStrings ; i++) {
 556             memsetAndFreeStrings(1, pStrings[i]);
 557         }
 558
 559 #ifdef MEMSET_FREED
 560         memset(pStrings, 0, countStrings * sizeof(char *));
 561 #endif
 562         free(pStrings);
 563     }
 564     return true;
 565 }
 566
 567 bool dispatchStrings(int serial, int slotId, int request, const hidl_vec<hidl_string>& data) {
 568     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 569     if (pRI == NULL) {
 570         return false;
 571     }
 572
 573     int countStrings = data.size();
 574     char **pStrings;
 575     pStrings = (char **)calloc(countStrings, sizeof(char *));
 576     if (pStrings == NULL) {
 577         RLOGE("Memory allocation failed for request %s", requestToString(request));
 578         sendErrorResponse(pRI, RIL_E_NO_MEMORY);
 579         return false;
 580     }
 581
 582     for (int i = 0; i < countStrings; i++) {
 583         if (!copyHidlStringToRil(&pStrings[i], data[i], pRI)) {
 584             for (int j = 0; j < i; j++) {
 585                 memsetAndFreeStrings(1, pStrings[j]);
 586             }
 587             free(pStrings);
 588             return false;
 589         }
 590     }
 591
 592     s_vendorFunctions->onRequest(request, pStrings, countStrings * sizeof(char *), pRI);
 593
 594     if (pStrings != NULL) {
 595         for (int i = 0 ; i < countStrings ; i++) {
 596             memsetAndFreeStrings(1, pStrings[i]);
 597         }
 598
 599 #ifdef MEMSET_FREED
 600         memset(pStrings, 0, countStrings * sizeof(char *));
 601 #endif
 602         free(pStrings);
 603     }
 604     return true;
 605 }
 606
 607 bool dispatchInts(int serial, int slotId, int request, int countInts, ...) {
 608     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 609     if (pRI == NULL) {
 610         return false;
 611     }
 612
 613     int *pInts = (int *)calloc(countInts, sizeof(int));
 614
 615     if (pInts == NULL) {
 616         RLOGE("Memory allocation failed for request %s", requestToString(request));
 617         sendErrorResponse(pRI, RIL_E_NO_MEMORY);
 618         return false;
 619     }
 620     va_list ap;
 621     va_start(ap, countInts);
 622     for (int i = 0; i < countInts; i++) {
 623         pInts[i] = va_arg(ap, int);
 624     }
 625     va_end(ap);
 626
 627     s_vendorFunctions->onRequest(request, pInts, countInts * sizeof(int), pRI);
 628
 629     if (pInts != NULL) {
 630 #ifdef MEMSET_FREED
 631         memset(pInts, 0, countInts * sizeof(int));
 632 #endif
 633         free(pInts);
 634     }
 635     return true;
 636 }
 637
 638 bool dispatchCallForwardStatus(int serial, int slotId, int request,
 639                               const CallForwardInfo& callInfo) {
 640     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 641     if (pRI == NULL) {
 642         return false;
 643     }
 644
 645     RIL_CallForwardInfo cf;
 646     cf.status = (int) callInfo.status;
 647     cf.reason = callInfo.reason;
 648     cf.serviceClass = callInfo.serviceClass;
 649     cf.toa = callInfo.toa;
 650     cf.timeSeconds = callInfo.timeSeconds;
 651
 652     if (!copyHidlStringToRil(&cf.number, callInfo.number, pRI)) {
 653         return false;
 654     }
 655
 656     s_vendorFunctions->onRequest(request, &cf, sizeof(cf), pRI);
 657
 658     memsetAndFreeStrings(1, cf.number);
 659
 660     return true;
 661 }
 662
 663 bool dispatchRaw(int serial, int slotId, int request, const hidl_vec<uint8_t>& rawBytes) {
 664     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 665     if (pRI == NULL) {
 666         return false;
 667     }
 668
 669     const uint8_t *uData = rawBytes.data();
 670
 671     s_vendorFunctions->onRequest(request, (void *) uData, rawBytes.size(), pRI);
 672
 673     return true;
 674 }
 675
 676 bool dispatchIccApdu(int serial, int slotId, int request, const SimApdu& message) {
 677     RequestInfo *pRI = android::addRequestToList(serial, slotId, request);
 678     if (pRI == NULL) {
 679         return false;
 680     }
 681
 682     RIL_SIM_APDU apdu;
 683     memset (&apdu, 0, sizeof(RIL_SIM_APDU));
 684
 685     apdu.sessionid = message.sessionId;
 686     apdu.cla = message.cla;
 687     apdu.instruction = message.instruction;
 688     apdu.p1 = message.p1;
 689     apdu.p2 = message.p2;
 690     apdu.p3 = message.p3;
 691
 692     if (!copyHidlStringToRil(&apdu.data, message.data, pRI)) {
 693         return false;
 694     }
 695
 696     s_vendorFunctions->onRequest(request, &apdu, sizeof(apdu), pRI);
 697
 698     memsetAndFreeStrings(1, apdu.data);
 699
 700     return true;
 701 }
 702
 703 void checkReturnStatus(int32_t slotId, Return<void>& ret, bool isRadioService) {
 704     if (ret.isOk() == false) {
 705         RLOGE("checkReturnStatus: unable to call response/indication callback");
 706         // Remote process hosting the callbacks must be dead. Reset the callback objects;
 707         // there's no other recovery to be done here. When the client process is back up, it will
 708         // call setResponseFunctions()
 709
 710         // Caller should already hold rdlock, release that first
 711         // note the current counter to avoid overwriting updates made by another thread before
 712         // write lock is acquired.
 713         int counter = isRadioService ? mCounterRadio[slotId] : mCounterOemHook[slotId];
 714         pthread_rwlock_t *radioServiceRwlockPtr = radio::getRadioServiceRwlock(slotId);
 715         int ret = pthread_rwlock_unlock(radioServiceRwlockPtr);
 716         assert(ret == 0);
 717
 718         // acquire wrlock
 719         ret = pthread_rwlock_wrlock(radioServiceRwlockPtr);
 720         assert(ret == 0);
 721
 722         // make sure the counter value has not changed
 723         if (counter == (isRadioService ? mCounterRadio[slotId] : mCounterOemHook[slotId])) {
 724             if (isRadioService) {
 725                 radioService[slotId]->mRadioResponse = NULL;
 726                 radioService[slotId]->mRadioIndication = NULL;
 727             } else {
 728                 oemHookService[slotId]->mOemHookResponse = NULL;
 729                 oemHookService[slotId]->mOemHookIndication = NULL;
 730             }
 731             isRadioService ? mCounterRadio[slotId]++ : mCounterOemHook[slotId]++;
 732         } else {
 733             RLOGE("checkReturnStatus: not resetting responseFunctions as they likely "
 734                     "got updated on another thread");
 735         }
 736
 737         // release wrlock
 738         ret = pthread_rwlock_unlock(radioServiceRwlockPtr);
 739         assert(ret == 0);
 740
 741         // Reacquire rdlock
 742         ret = pthread_rwlock_rdlock(radioServiceRwlockPtr);
 743         assert(ret == 0);
 744     }
 745 }
 746
 747 void RadioImpl::checkReturnStatus(Return<void>& ret) {
 748     ::checkReturnStatus(mSlotId, ret, true);
 749 }
 750
 751 Return<void> RadioImpl::setResponseFunctions(
 752         const ::android::sp<IRadioResponse>& radioResponseParam,
 753         const ::android::sp<IRadioIndication>& radioIndicationParam) {
 754     RLOGD("setResponseFunctions");
 755
 756     pthread_rwlock_t *radioServiceRwlockPtr = radio::getRadioServiceRwlock(mSlotId);
 757     int ret = pthread_rwlock_wrlock(radioServiceRwlockPtr);
 758     assert(ret == 0);
 759
 760     mRadioResponse = radioResponseParam;
 761     mRadioIndication = radioIndicationParam;
 762     mCounterRadio[mSlotId]++;
 763
 764     ret = pthread_rwlock_unlock(radioServiceRwlockPtr);
 765     assert(ret == 0);
 766
 767     // client is connected. Send initial indications.
 768     android::onNewCommandConnect((RIL_SOCKET_ID) mSlotId);
 769
 770     return Void();
 771 }
 772
 773 Return<void> RadioImpl::getIccCardStatus(int32_t serial) {
 774 #if VDBG
 775     RLOGD("getIccCardStatus: serial %d", serial);
 776 #endif
 777     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_SIM_STATUS);
 778     return Void();
 779 }
 780
 781 Return<void> RadioImpl::supplyIccPinForApp(int32_t serial, const hidl_string& pin,
 782         const hidl_string& aid) {
 783 #if VDBG
 784     RLOGD("supplyIccPinForApp: serial %d", serial);
 785 #endif
 786     dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_SIM_PIN,
 787             2, pin.c_str(), aid.c_str());
 788     return Void();
 789 }
 790
 791 Return<void> RadioImpl::supplyIccPukForApp(int32_t serial, const hidl_string& puk,
 792                                            const hidl_string& pin, const hidl_string& aid) {
 793 #if VDBG
 794     RLOGD("supplyIccPukForApp: serial %d", serial);
 795 #endif
 796     dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_SIM_PUK,
 797             3, puk.c_str(), pin.c_str(), aid.c_str());
 798     return Void();
 799 }
 800
 801 Return<void> RadioImpl::supplyIccPin2ForApp(int32_t serial, const hidl_string& pin2,
 802                                             const hidl_string& aid) {
 803 #if VDBG
 804     RLOGD("supplyIccPin2ForApp: serial %d", serial);
 805 #endif
 806     dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_SIM_PIN2,
 807             2, pin2.c_str(), aid.c_str());
 808     return Void();
 809 }
 810
 811 Return<void> RadioImpl::supplyIccPuk2ForApp(int32_t serial, const hidl_string& puk2,
 812                                             const hidl_string& pin2, const hidl_string& aid) {
 813 #if VDBG
 814     RLOGD("supplyIccPuk2ForApp: serial %d", serial);
 815 #endif
 816     dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_SIM_PUK2,
 817             3, puk2.c_str(), pin2.c_str(), aid.c_str());
 818     return Void();
 819 }
 820
 821 Return<void> RadioImpl::changeIccPinForApp(int32_t serial, const hidl_string& oldPin,
 822                                            const hidl_string& newPin, const hidl_string& aid) {
 823 #if VDBG
 824     RLOGD("changeIccPinForApp: serial %d", serial);
 825 #endif
 826     dispatchStrings(serial, mSlotId, RIL_REQUEST_CHANGE_SIM_PIN,
 827             3, oldPin.c_str(), newPin.c_str(), aid.c_str());
 828     return Void();
 829 }
 830
 831 Return<void> RadioImpl::changeIccPin2ForApp(int32_t serial, const hidl_string& oldPin2,
 832                                             const hidl_string& newPin2, const hidl_string& aid) {
 833 #if VDBG
 834     RLOGD("changeIccPin2ForApp: serial %d", serial);
 835 #endif
 836     dispatchStrings(serial, mSlotId, RIL_REQUEST_CHANGE_SIM_PIN2,
 837             3, oldPin2.c_str(), newPin2.c_str(), aid.c_str());
 838     return Void();
 839 }
 840
 841 Return<void> RadioImpl::supplyNetworkDepersonalization(int32_t serial,
 842                                                        const hidl_string& netPin) {
 843 #if VDBG
 844     RLOGD("supplyNetworkDepersonalization: serial %d", serial);
 845 #endif
 846     dispatchStrings(serial, mSlotId, RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION,
 847             1, netPin.c_str());
 848     return Void();
 849 }
 850
 851 Return<void> RadioImpl::getCurrentCalls(int32_t serial) {
 852 #if VDBG
 853     RLOGD("getCurrentCalls: serial %d", serial);
 854 #endif
 855     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_CURRENT_CALLS);
 856     return Void();
 857 }
 858
 859 Return<void> RadioImpl::dial(int32_t serial, const Dial& dialInfo) {
 860 #if VDBG
 861     RLOGD("dial: serial %d", serial);
 862 #endif
 863     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_DIAL);
 864     if (pRI == NULL) {
 865         return Void();
 866     }
 867     RIL_Dial dial = {};
 868     RIL_UUS_Info uusInfo = {};
 869     int32_t sizeOfDial = sizeof(dial);
 870
 871     if (!copyHidlStringToRil(&dial.address, dialInfo.address, pRI)) {
 872         return Void();
 873     }
 874     dial.clir = (int) dialInfo.clir;
 875
 876     if (dialInfo.uusInfo.size() != 0) {
 877         uusInfo.uusType = (RIL_UUS_Type) dialInfo.uusInfo[0].uusType;
 878         uusInfo.uusDcs = (RIL_UUS_DCS) dialInfo.uusInfo[0].uusDcs;
 879
 880         if (dialInfo.uusInfo[0].uusData.size() == 0) {
 881             uusInfo.uusData = NULL;
 882             uusInfo.uusLength = 0;
 883         } else {
 884             if (!copyHidlStringToRil(&uusInfo.uusData, dialInfo.uusInfo[0].uusData, pRI)) {
 885                 memsetAndFreeStrings(1, dial.address);
 886                 return Void();
 887             }
 888             uusInfo.uusLength = dialInfo.uusInfo[0].uusData.size();
 889         }
 890
 891         dial.uusInfo = &uusInfo;
 892     }
 893
 894     s_vendorFunctions->onRequest(RIL_REQUEST_DIAL, &dial, sizeOfDial, pRI);
 895
 896     memsetAndFreeStrings(2, dial.address, uusInfo.uusData);
 897
 898     return Void();
 899 }
 900
 901 Return<void> RadioImpl::getImsiForApp(int32_t serial, const hidl_string& aid) {
 902 #if VDBG
 903     RLOGD("getImsiForApp: serial %d", serial);
 904 #endif
 905     dispatchStrings(serial, mSlotId, RIL_REQUEST_GET_IMSI,
 906             1, aid.c_str());
 907     return Void();
 908 }
 909
 910 Return<void> RadioImpl::hangup(int32_t serial, int32_t gsmIndex) {
 911 #if VDBG
 912     RLOGD("hangup: serial %d", serial);
 913 #endif
 914     dispatchInts(serial, mSlotId, RIL_REQUEST_HANGUP, 1, gsmIndex);
 915     return Void();
 916 }
 917
 918 Return<void> RadioImpl::hangupWaitingOrBackground(int32_t serial) {
 919 #if VDBG
 920     RLOGD("hangupWaitingOrBackground: serial %d", serial);
 921 #endif
 922     dispatchVoid(serial, mSlotId, RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND);
 923     return Void();
 924 }
 925
 926 Return<void> RadioImpl::hangupForegroundResumeBackground(int32_t serial) {
 927 #if VDBG
 928     RLOGD("hangupForegroundResumeBackground: serial %d", serial);
 929 #endif
 930     dispatchVoid(serial, mSlotId, RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND);
 931     return Void();
 932 }
 933
 934 Return<void> RadioImpl::switchWaitingOrHoldingAndActive(int32_t serial) {
 935 #if VDBG
 936     RLOGD("switchWaitingOrHoldingAndActive: serial %d", serial);
 937 #endif
 938     dispatchVoid(serial, mSlotId, RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE);
 939     return Void();
 940 }
 941
 942 Return<void> RadioImpl::conference(int32_t serial) {
 943 #if VDBG
 944     RLOGD("conference: serial %d", serial);
 945 #endif
 946     dispatchVoid(serial, mSlotId, RIL_REQUEST_CONFERENCE);
 947     return Void();
 948 }
 949
 950 Return<void> RadioImpl::rejectCall(int32_t serial) {
 951 #if VDBG
 952     RLOGD("rejectCall: serial %d", serial);
 953 #endif
 954     dispatchVoid(serial, mSlotId, RIL_REQUEST_UDUB);
 955     return Void();
 956 }
 957
 958 Return<void> RadioImpl::getLastCallFailCause(int32_t serial) {
 959 #if VDBG
 960     RLOGD("getLastCallFailCause: serial %d", serial);
 961 #endif
 962     dispatchVoid(serial, mSlotId, RIL_REQUEST_LAST_CALL_FAIL_CAUSE);
 963     return Void();
 964 }
 965
 966 Return<void> RadioImpl::getSignalStrength(int32_t serial) {
 967 #if VDBG
 968     RLOGD("getSignalStrength: serial %d", serial);
 969 #endif
 970     dispatchVoid(serial, mSlotId, RIL_REQUEST_SIGNAL_STRENGTH);
 971     return Void();
 972 }
 973
 974 Return<void> RadioImpl::getVoiceRegistrationState(int32_t serial) {
 975 #if VDBG
 976     RLOGD("getVoiceRegistrationState: serial %d", serial);
 977 #endif
 978     dispatchVoid(serial, mSlotId, RIL_REQUEST_VOICE_REGISTRATION_STATE);
 979     return Void();
 980 }
 981
 982 Return<void> RadioImpl::getDataRegistrationState(int32_t serial) {
 983 #if VDBG
 984     RLOGD("getDataRegistrationState: serial %d", serial);
 985 #endif
 986     dispatchVoid(serial, mSlotId, RIL_REQUEST_DATA_REGISTRATION_STATE);
 987     return Void();
 988 }
 989
 990 Return<void> RadioImpl::getOperator(int32_t serial) {
 991 #if VDBG
 992     RLOGD("getOperator: serial %d", serial);
 993 #endif
 994     dispatchVoid(serial, mSlotId, RIL_REQUEST_OPERATOR);
 995     return Void();
 996 }
 997
 998 Return<void> RadioImpl::setRadioPower(int32_t serial, bool on) {
 999     RLOGD("setRadioPower: serial %d on %d", serial, on);
1000     dispatchInts(serial, mSlotId, RIL_REQUEST_RADIO_POWER, 1, BOOL_TO_INT(on));
1001     return Void();
1002 }
1003
1004 Return<void> RadioImpl::sendDtmf(int32_t serial, const hidl_string& s) {
1005 #if VDBG
1006     RLOGD("sendDtmf: serial %d", serial);
1007 #endif
1008     dispatchString(serial, mSlotId, RIL_REQUEST_DTMF, s.c_str());
1009     return Void();
1010 }
1011
1012 Return<void> RadioImpl::sendSms(int32_t serial, const GsmSmsMessage& message) {
1013 #if VDBG
1014     RLOGD("sendSms: serial %d", serial);
1015 #endif
1016     dispatchStrings(serial, mSlotId, RIL_REQUEST_SEND_SMS,
1017             2, message.smscPdu.c_str(), message.pdu.c_str());
1018     return Void();
1019 }
1020
1021 Return<void> RadioImpl::sendSMSExpectMore(int32_t serial, const GsmSmsMessage& message) {
1022 #if VDBG
1023     RLOGD("sendSMSExpectMore: serial %d", serial);
1024 #endif
1025     dispatchStrings(serial, mSlotId, RIL_REQUEST_SEND_SMS_EXPECT_MORE,
1026             2, message.smscPdu.c_str(), message.pdu.c_str());
1027     return Void();
1028 }
1029
1030 static bool convertMvnoTypeToString(MvnoType type, char *&str) {
1031     switch (type) {
1032         case MvnoType::IMSI:
1033             str = (char *)"imsi";
1034             return true;
1035         case MvnoType::GID:
1036             str = (char *)"gid";
1037             return true;
1038         case MvnoType::SPN:
1039             str = (char *)"spn";
1040             return true;
1041         case MvnoType::NONE:
1042             str = (char *)"";
1043             return true;
1044     }
1045     return false;
1046 }
1047
1048 Return<void> RadioImpl::setupDataCall(int32_t serial, RadioTechnology radioTechnology,
1049                                       const DataProfileInfo& dataProfileInfo, bool modemCognitive,
1050                                       bool roamingAllowed, bool isRoaming) {
1051
1052 #if VDBG
1053     RLOGD("setupDataCall: serial %d", serial);
1054 #endif
1055
1056     if (s_vendorFunctions->version >= 4 && s_vendorFunctions->version <= 14) {
1057         const hidl_string &protocol =
1058                 (isRoaming ? dataProfileInfo.roamingProtocol : dataProfileInfo.protocol);
1059         dispatchStrings(serial, mSlotId, RIL_REQUEST_SETUP_DATA_CALL, 7,
1060             std::to_string((int) radioTechnology + 2).c_str(),
1061             std::to_string((int) dataProfileInfo.profileId).c_str(),
1062             dataProfileInfo.apn.c_str(),
1063             dataProfileInfo.user.c_str(),
1064             dataProfileInfo.password.c_str(),
1065             std::to_string((int) dataProfileInfo.authType).c_str(),
1066             protocol.c_str());
1067     } else if (s_vendorFunctions->version >= 15) {
1068         char *mvnoTypeStr = NULL;
1069         if (!convertMvnoTypeToString(dataProfileInfo.mvnoType, mvnoTypeStr)) {
1070             RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
1071                     RIL_REQUEST_SETUP_DATA_CALL);
1072             if (pRI != NULL) {
1073                 sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
1074             }
1075             return Void();
1076         }
1077         dispatchStrings(serial, mSlotId, RIL_REQUEST_SETUP_DATA_CALL, 15,
1078             std::to_string((int) radioTechnology + 2).c_str(),
1079             std::to_string((int) dataProfileInfo.profileId).c_str(),
1080             dataProfileInfo.apn.c_str(),
1081             dataProfileInfo.user.c_str(),
1082             dataProfileInfo.password.c_str(),
1083             std::to_string((int) dataProfileInfo.authType).c_str(),
1084             dataProfileInfo.protocol.c_str(),
1085             dataProfileInfo.roamingProtocol.c_str(),
1086             std::to_string(dataProfileInfo.supportedApnTypesBitmap).c_str(),
1087             std::to_string(dataProfileInfo.bearerBitmap).c_str(),
1088             modemCognitive ? "1" : "0",
1089             std::to_string(dataProfileInfo.mtu).c_str(),
1090             mvnoTypeStr,
1091             dataProfileInfo.mvnoMatchData.c_str(),
1092             roamingAllowed ? "1" : "0");
1093     } else {
1094         RLOGE("Unsupported RIL version %d, min version expected 4", s_vendorFunctions->version);
1095         RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
1096                 RIL_REQUEST_SETUP_DATA_CALL);
1097         if (pRI != NULL) {
1098             sendErrorResponse(pRI, RIL_E_REQUEST_NOT_SUPPORTED);
1099         }
1100     }
1101     return Void();
1102 }
1103
1104 Return<void> RadioImpl::iccIOForApp(int32_t serial, const IccIo& iccIo) {
1105 #if VDBG
1106     RLOGD("iccIOForApp: serial %d", serial);
1107 #endif
1108     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SIM_IO);
1109     if (pRI == NULL) {
1110         return Void();
1111     }
1112
1113     RIL_SIM_IO_v6 rilIccIo;
1114     rilIccIo.command = iccIo.command;
1115     rilIccIo.fileid = iccIo.fileId;
1116     if (!copyHidlStringToRil(&rilIccIo.path, iccIo.path, pRI)) {
1117         return Void();
1118     }
1119
1120     rilIccIo.p1 = iccIo.p1;
1121     rilIccIo.p2 = iccIo.p2;
1122     rilIccIo.p3 = iccIo.p3;
1123
1124     if (!copyHidlStringToRil(&rilIccIo.data, iccIo.data, pRI)) {
1125         memsetAndFreeStrings(1, rilIccIo.path);
1126         return Void();
1127     }
1128
1129     if (!copyHidlStringToRil(&rilIccIo.pin2, iccIo.pin2, pRI)) {
1130         memsetAndFreeStrings(2, rilIccIo.path, rilIccIo.data);
1131         return Void();
1132     }
1133
1134     if (!copyHidlStringToRil(&rilIccIo.aidPtr, iccIo.aid, pRI)) {
1135         memsetAndFreeStrings(3, rilIccIo.path, rilIccIo.data, rilIccIo.pin2);
1136         return Void();
1137     }
1138
1139     s_vendorFunctions->onRequest(RIL_REQUEST_SIM_IO, &rilIccIo, sizeof(rilIccIo), pRI);
1140
1141     memsetAndFreeStrings(4, rilIccIo.path, rilIccIo.data, rilIccIo.pin2, rilIccIo.aidPtr);
1142
1143     return Void();
1144 }
1145
1146 Return<void> RadioImpl::sendUssd(int32_t serial, const hidl_string& ussd) {
1147 #if VDBG
1148     RLOGD("sendUssd: serial %d", serial);
1149 #endif
1150     dispatchString(serial, mSlotId, RIL_REQUEST_SEND_USSD, ussd.c_str());
1151     return Void();
1152 }
1153
1154 Return<void> RadioImpl::cancelPendingUssd(int32_t serial) {
1155 #if VDBG
1156     RLOGD("cancelPendingUssd: serial %d", serial);
1157 #endif
1158     dispatchVoid(serial, mSlotId, RIL_REQUEST_CANCEL_USSD);
1159     return Void();
1160 }
1161
1162 Return<void> RadioImpl::getClir(int32_t serial) {
1163 #if VDBG
1164     RLOGD("getClir: serial %d", serial);
1165 #endif
1166     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_CLIR);
1167     return Void();
1168 }
1169
1170 Return<void> RadioImpl::setClir(int32_t serial, int32_t status) {
1171 #if VDBG
1172     RLOGD("setClir: serial %d", serial);
1173 #endif
1174     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_CLIR, 1, status);
1175     return Void();
1176 }
1177
1178 Return<void> RadioImpl::getCallForwardStatus(int32_t serial, const CallForwardInfo& callInfo) {
1179 #if VDBG
1180     RLOGD("getCallForwardStatus: serial %d", serial);
1181 #endif
1182     dispatchCallForwardStatus(serial, mSlotId, RIL_REQUEST_QUERY_CALL_FORWARD_STATUS,
1183             callInfo);
1184     return Void();
1185 }
1186
1187 Return<void> RadioImpl::setCallForward(int32_t serial, const CallForwardInfo& callInfo) {
1188 #if VDBG
1189     RLOGD("setCallForward: serial %d", serial);
1190 #endif
1191     dispatchCallForwardStatus(serial, mSlotId, RIL_REQUEST_SET_CALL_FORWARD,
1192             callInfo);
1193     return Void();
1194 }
1195
1196 Return<void> RadioImpl::getCallWaiting(int32_t serial, int32_t serviceClass) {
1197 #if VDBG
1198     RLOGD("getCallWaiting: serial %d", serial);
1199 #endif
1200     dispatchInts(serial, mSlotId, RIL_REQUEST_QUERY_CALL_WAITING, 1, serviceClass);
1201     return Void();
1202 }
1203
1204 Return<void> RadioImpl::setCallWaiting(int32_t serial, bool enable, int32_t serviceClass) {
1205 #if VDBG
1206     RLOGD("setCallWaiting: serial %d", serial);
1207 #endif
1208     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_CALL_WAITING, 2, BOOL_TO_INT(enable),
1209             serviceClass);
1210     return Void();
1211 }
1212
1213 Return<void> RadioImpl::acknowledgeLastIncomingGsmSms(int32_t serial,
1214                                                       bool success, SmsAcknowledgeFailCause cause) {
1215 #if VDBG
1216     RLOGD("acknowledgeLastIncomingGsmSms: serial %d", serial);
1217 #endif
1218     dispatchInts(serial, mSlotId, RIL_REQUEST_SMS_ACKNOWLEDGE, 2, BOOL_TO_INT(success),
1219             cause);
1220     return Void();
1221 }
1222
1223 Return<void> RadioImpl::acceptCall(int32_t serial) {
1224 #if VDBG
1225     RLOGD("acceptCall: serial %d", serial);
1226 #endif
1227     dispatchVoid(serial, mSlotId, RIL_REQUEST_ANSWER);
1228     return Void();
1229 }
1230
1231 Return<void> RadioImpl::deactivateDataCall(int32_t serial,
1232                                            int32_t cid, bool reasonRadioShutDown) {
1233 #if VDBG
1234     RLOGD("deactivateDataCall: serial %d", serial);
1235 #endif
1236     dispatchStrings(serial, mSlotId, RIL_REQUEST_DEACTIVATE_DATA_CALL,
1237             2, (std::to_string(cid)).c_str(), reasonRadioShutDown ? "1" : "0");
1238     return Void();
1239 }
1240
1241 Return<void> RadioImpl::getFacilityLockForApp(int32_t serial, const hidl_string& facility,
1242                                               const hidl_string& password, int32_t serviceClass,
1243                                               const hidl_string& appId) {
1244 #if VDBG
1245     RLOGD("getFacilityLockForApp: serial %d", serial);
1246 #endif
1247     dispatchStrings(serial, mSlotId, RIL_REQUEST_QUERY_FACILITY_LOCK,
1248             4, facility.c_str(), password.c_str(),
1249             (std::to_string(serviceClass)).c_str(), appId.c_str());
1250     return Void();
1251 }
1252
1253 Return<void> RadioImpl::setFacilityLockForApp(int32_t serial, const hidl_string& facility,
1254                                               bool lockState, const hidl_string& password,
1255                                               int32_t serviceClass, const hidl_string& appId) {
1256 #if VDBG
1257     RLOGD("setFacilityLockForApp: serial %d", serial);
1258 #endif
1259     dispatchStrings(serial, mSlotId, RIL_REQUEST_SET_FACILITY_LOCK,
1260             5, facility.c_str(), lockState ? "1" : "0", password.c_str(),
1261             (std::to_string(serviceClass)).c_str(), appId.c_str() );
1262     return Void();
1263 }
1264
1265 Return<void> RadioImpl::setBarringPassword(int32_t serial, const hidl_string& facility,
1266                                            const hidl_string& oldPassword,
1267                                            const hidl_string& newPassword) {
1268 #if VDBG
1269     RLOGD("setBarringPassword: serial %d", serial);
1270 #endif
1271     dispatchStrings(serial, mSlotId, RIL_REQUEST_CHANGE_BARRING_PASSWORD,
1272             2, oldPassword.c_str(), newPassword.c_str());
1273     return Void();
1274 }
1275
1276 Return<void> RadioImpl::getNetworkSelectionMode(int32_t serial) {
1277 #if VDBG
1278     RLOGD("getNetworkSelectionMode: serial %d", serial);
1279 #endif
1280     dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE);
1281     return Void();
1282 }
1283
1284 Return<void> RadioImpl::setNetworkSelectionModeAutomatic(int32_t serial) {
1285 #if VDBG
1286     RLOGD("setNetworkSelectionModeAutomatic: serial %d", serial);
1287 #endif
1288     dispatchVoid(serial, mSlotId, RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC);
1289     return Void();
1290 }
1291
1292 Return<void> RadioImpl::setNetworkSelectionModeManual(int32_t serial,
1293                                                       const hidl_string& operatorNumeric) {
1294 #if VDBG
1295     RLOGD("setNetworkSelectionModeManual: serial %d", serial);
1296 #endif
1297     dispatchString(serial, mSlotId, RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL,
1298             operatorNumeric.c_str());
1299     return Void();
1300 }
1301
1302 Return<void> RadioImpl::getAvailableNetworks(int32_t serial) {
1303 #if VDBG
1304     RLOGD("getAvailableNetworks: serial %d", serial);
1305 #endif
1306     dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_AVAILABLE_NETWORKS);
1307     return Void();
1308 }
1309
1310 Return<void> RadioImpl::startDtmf(int32_t serial, const hidl_string& s) {
1311 #if VDBG
1312     RLOGD("startDtmf: serial %d", serial);
1313 #endif
1314     dispatchString(serial, mSlotId, RIL_REQUEST_DTMF_START,
1315             s.c_str());
1316     return Void();
1317 }
1318
1319 Return<void> RadioImpl::stopDtmf(int32_t serial) {
1320 #if VDBG
1321     RLOGD("stopDtmf: serial %d", serial);
1322 #endif
1323     dispatchVoid(serial, mSlotId, RIL_REQUEST_DTMF_STOP);
1324     return Void();
1325 }
1326
1327 Return<void> RadioImpl::getBasebandVersion(int32_t serial) {
1328 #if VDBG
1329     RLOGD("getBasebandVersion: serial %d", serial);
1330 #endif
1331     dispatchVoid(serial, mSlotId, RIL_REQUEST_BASEBAND_VERSION);
1332     return Void();
1333 }
1334
1335 Return<void> RadioImpl::separateConnection(int32_t serial, int32_t gsmIndex) {
1336 #if VDBG
1337     RLOGD("separateConnection: serial %d", serial);
1338 #endif
1339     dispatchInts(serial, mSlotId, RIL_REQUEST_SEPARATE_CONNECTION, 1, gsmIndex);
1340     return Void();
1341 }
1342
1343 Return<void> RadioImpl::setMute(int32_t serial, bool enable) {
1344 #if VDBG
1345     RLOGD("setMute: serial %d", serial);
1346 #endif
1347     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_MUTE, 1, BOOL_TO_INT(enable));
1348     return Void();
1349 }
1350
1351 Return<void> RadioImpl::getMute(int32_t serial) {
1352 #if VDBG
1353     RLOGD("getMute: serial %d", serial);
1354 #endif
1355     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_MUTE);
1356     return Void();
1357 }
1358
1359 Return<void> RadioImpl::getClip(int32_t serial) {
1360 #if VDBG
1361     RLOGD("getClip: serial %d", serial);
1362 #endif
1363     dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_CLIP);
1364     return Void();
1365 }
1366
1367 Return<void> RadioImpl::getDataCallList(int32_t serial) {
1368 #if VDBG
1369     RLOGD("getDataCallList: serial %d", serial);
1370 #endif
1371     dispatchVoid(serial, mSlotId, RIL_REQUEST_DATA_CALL_LIST);
1372     return Void();
1373 }
1374
1375 Return<void> RadioImpl::setSuppServiceNotifications(int32_t serial, bool enable) {
1376 #if VDBG
1377     RLOGD("setSuppServiceNotifications: serial %d", serial);
1378 #endif
1379     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION, 1,
1380             BOOL_TO_INT(enable));
1381     return Void();
1382 }
1383
1384 Return<void> RadioImpl::writeSmsToSim(int32_t serial, const SmsWriteArgs& smsWriteArgs) {
1385 #if VDBG
1386     RLOGD("writeSmsToSim: serial %d", serial);
1387 #endif
1388     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_WRITE_SMS_TO_SIM);
1389     if (pRI == NULL) {
1390         return Void();
1391     }
1392
1393     RIL_SMS_WriteArgs args;
1394     args.status = (int) smsWriteArgs.status;
1395
1396     int len;
1397     if (!copyHidlStringToRil(&args.pdu, smsWriteArgs.pdu, pRI)) {
1398         return Void();
1399     }
1400
1401     if (!copyHidlStringToRil(&args.smsc, smsWriteArgs.smsc, pRI)) {
1402         memsetAndFreeStrings(1, args.pdu);
1403         return Void();
1404     }
1405
1406     s_vendorFunctions->onRequest(RIL_REQUEST_WRITE_SMS_TO_SIM, &args, sizeof(args), pRI);
1407
1408     memsetAndFreeStrings(2, args.smsc, args.pdu);
1409
1410     return Void();
1411 }
1412
1413 Return<void> RadioImpl::deleteSmsOnSim(int32_t serial, int32_t index) {
1414 #if VDBG
1415     RLOGD("deleteSmsOnSim: serial %d", serial);
1416 #endif
1417     dispatchInts(serial, mSlotId, RIL_REQUEST_DELETE_SMS_ON_SIM, 1, index);
1418     return Void();
1419 }
1420
1421 Return<void> RadioImpl::setBandMode(int32_t serial, RadioBandMode mode) {
1422 #if VDBG
1423     RLOGD("setBandMode: serial %d", serial);
1424 #endif
1425     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_BAND_MODE, 1, mode);
1426     return Void();
1427 }
1428
1429 Return<void> RadioImpl::getAvailableBandModes(int32_t serial) {
1430 #if VDBG
1431     RLOGD("getAvailableBandModes: serial %d", serial);
1432 #endif
1433     dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE);
1434     return Void();
1435 }
1436
1437 Return<void> RadioImpl::sendEnvelope(int32_t serial, const hidl_string& command) {
1438 #if VDBG
1439     RLOGD("sendEnvelope: serial %d", serial);
1440 #endif
1441     dispatchString(serial, mSlotId, RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND,
1442             command.c_str());
1443     return Void();
1444 }
1445
1446 Return<void> RadioImpl::sendTerminalResponseToSim(int32_t serial,
1447                                                   const hidl_string& commandResponse) {
1448 #if VDBG
1449     RLOGD("sendTerminalResponseToSim: serial %d", serial);
1450 #endif
1451     dispatchString(serial, mSlotId, RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE,
1452             commandResponse.c_str());
1453     return Void();
1454 }
1455
1456 Return<void> RadioImpl::handleStkCallSetupRequestFromSim(int32_t serial, bool accept) {
1457 #if VDBG
1458     RLOGD("handleStkCallSetupRequestFromSim: serial %d", serial);
1459 #endif
1460     dispatchInts(serial, mSlotId, RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM,
1461             1, BOOL_TO_INT(accept));
1462     return Void();
1463 }
1464
1465 Return<void> RadioImpl::explicitCallTransfer(int32_t serial) {
1466 #if VDBG
1467     RLOGD("explicitCallTransfer: serial %d", serial);
1468 #endif
1469     dispatchVoid(serial, mSlotId, RIL_REQUEST_EXPLICIT_CALL_TRANSFER);
1470     return Void();
1471 }
1472
1473 Return<void> RadioImpl::setPreferredNetworkType(int32_t serial, PreferredNetworkType nwType) {
1474 #if VDBG
1475     RLOGD("setPreferredNetworkType: serial %d", serial);
1476 #endif
1477     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE, 1, nwType);
1478     return Void();
1479 }
1480
1481 Return<void> RadioImpl::getPreferredNetworkType(int32_t serial) {
1482 #if VDBG
1483     RLOGD("getPreferredNetworkType: serial %d", serial);
1484 #endif
1485     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE);
1486     return Void();
1487 }
1488
1489 Return<void> RadioImpl::getNeighboringCids(int32_t serial) {
1490 #if VDBG
1491     RLOGD("getNeighboringCids: serial %d", serial);
1492 #endif
1493     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_NEIGHBORING_CELL_IDS);
1494     return Void();
1495 }
1496
1497 Return<void> RadioImpl::setLocationUpdates(int32_t serial, bool enable) {
1498 #if VDBG
1499     RLOGD("setLocationUpdates: serial %d", serial);
1500 #endif
1501     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_LOCATION_UPDATES, 1, BOOL_TO_INT(enable));
1502     return Void();
1503 }
1504
1505 Return<void> RadioImpl::setCdmaSubscriptionSource(int32_t serial, CdmaSubscriptionSource cdmaSub) {
1506 #if VDBG
1507     RLOGD("setCdmaSubscriptionSource: serial %d", serial);
1508 #endif
1509     dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE, 1, cdmaSub);
1510     return Void();
1511 }
1512
1513 Return<void> RadioImpl::setCdmaRoamingPreference(int32_t serial, CdmaRoamingType type) {
1514 #if VDBG
1515     RLOGD("setCdmaRoamingPreference: serial %d", serial);
1516 #endif
1517     dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE, 1, type);
1518     return Void();
1519 }
1520
1521 Return<void> RadioImpl::getCdmaRoamingPreference(int32_t serial) {
1522 #if VDBG
1523     RLOGD("getCdmaRoamingPreference: serial %d", serial);
1524 #endif
1525     dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE);
1526     return Void();
1527 }
1528
1529 Return<void> RadioImpl::setTTYMode(int32_t serial, TtyMode mode) {
1530 #if VDBG
1531     RLOGD("setTTYMode: serial %d", serial);
1532 #endif
1533     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_TTY_MODE, 1, mode);
1534     return Void();
1535 }
1536
1537 Return<void> RadioImpl::getTTYMode(int32_t serial) {
1538 #if VDBG
1539     RLOGD("getTTYMode: serial %d", serial);
1540 #endif
1541     dispatchVoid(serial, mSlotId, RIL_REQUEST_QUERY_TTY_MODE);
1542     return Void();
1543 }
1544
1545 Return<void> RadioImpl::setPreferredVoicePrivacy(int32_t serial, bool enable) {
1546 #if VDBG
1547     RLOGD("setPreferredVoicePrivacy: serial %d", serial);
1548 #endif
1549     dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE,
1550             1, BOOL_TO_INT(enable));
1551     return Void();
1552 }
1553
1554 Return<void> RadioImpl::getPreferredVoicePrivacy(int32_t serial) {
1555 #if VDBG
1556     RLOGD("getPreferredVoicePrivacy: serial %d", serial);
1557 #endif
1558     dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE);
1559     return Void();
1560 }
1561
1562 Return<void> RadioImpl::sendCDMAFeatureCode(int32_t serial, const hidl_string& featureCode) {
1563 #if VDBG
1564     RLOGD("sendCDMAFeatureCode: serial %d", serial);
1565 #endif
1566     dispatchString(serial, mSlotId, RIL_REQUEST_CDMA_FLASH,
1567             featureCode.c_str());
1568     return Void();
1569 }
1570
1571 Return<void> RadioImpl::sendBurstDtmf(int32_t serial, const hidl_string& dtmf, int32_t on,
1572                                       int32_t off) {
1573 #if VDBG
1574     RLOGD("sendBurstDtmf: serial %d", serial);
1575 #endif
1576     dispatchStrings(serial, mSlotId, RIL_REQUEST_CDMA_BURST_DTMF,
1577             3, dtmf.c_str(), (std::to_string(on)).c_str(),
1578             (std::to_string(off)).c_str());
1579     return Void();
1580 }
1581
1582 void constructCdmaSms(RIL_CDMA_SMS_Message &rcsm, const CdmaSmsMessage& sms) {
1583     memset(&rcsm, 0, sizeof(rcsm));
1584
1585     rcsm.uTeleserviceID = sms.teleserviceId;
1586     rcsm.bIsServicePresent = BOOL_TO_INT(sms.isServicePresent);
1587     rcsm.uServicecategory = sms.serviceCategory;
1588     rcsm.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) sms.address.digitMode;
1589     rcsm.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) sms.address.numberMode;
1590     rcsm.sAddress.number_type = (RIL_CDMA_SMS_NumberType) sms.address.numberType;
1591     rcsm.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) sms.address.numberPlan;
1592
1593     rcsm.sAddress.number_of_digits = sms.address.digits.size();
1594     int digitLimit= MIN((rcsm.sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
1595     for (int i = 0; i < digitLimit; i++) {
1596         rcsm.sAddress.digits[i] = sms.address.digits[i];
1597     }
1598
1599     rcsm.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) sms.subAddress.subaddressType;
1600     rcsm.sSubAddress.odd = BOOL_TO_INT(sms.subAddress.odd);
1601
1602     rcsm.sSubAddress.number_of_digits = sms.subAddress.digits.size();
1603     digitLimit= MIN((rcsm.sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
1604     for (int i = 0; i < digitLimit; i++) {
1605         rcsm.sSubAddress.digits[i] = sms.subAddress.digits[i];
1606     }
1607
1608     rcsm.uBearerDataLen = sms.bearerData.size();
1609     digitLimit= MIN((rcsm.uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
1610     for (int i = 0; i < digitLimit; i++) {
1611         rcsm.aBearerData[i] = sms.bearerData[i];
1612     }
1613 }
1614
1615 Return<void> RadioImpl::sendCdmaSms(int32_t serial, const CdmaSmsMessage& sms) {
1616 #if VDBG
1617     RLOGD("sendCdmaSms: serial %d", serial);
1618 #endif
1619     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_CDMA_SEND_SMS);
1620     if (pRI == NULL) {
1621         return Void();
1622     }
1623
1624     RIL_CDMA_SMS_Message rcsm;
1625     constructCdmaSms(rcsm, sms);
1626
1627     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &rcsm, sizeof(rcsm), pRI);
1628     return Void();
1629 }
1630
1631 Return<void> RadioImpl::acknowledgeLastIncomingCdmaSms(int32_t serial, const CdmaSmsAck& smsAck) {
1632 #if VDBG
1633     RLOGD("acknowledgeLastIncomingCdmaSms: serial %d", serial);
1634 #endif
1635     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE);
1636     if (pRI == NULL) {
1637         return Void();
1638     }
1639
1640     RIL_CDMA_SMS_Ack rcsa = {};
1641
1642     rcsa.uErrorClass = (RIL_CDMA_SMS_ErrorClass) smsAck.errorClass;
1643     rcsa.uSMSCauseCode = smsAck.smsCauseCode;
1644
1645     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &rcsa, sizeof(rcsa), pRI);
1646     return Void();
1647 }
1648
1649 Return<void> RadioImpl::getGsmBroadcastConfig(int32_t serial) {
1650 #if VDBG
1651     RLOGD("getGsmBroadcastConfig: serial %d", serial);
1652 #endif
1653     dispatchVoid(serial, mSlotId, RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG);
1654     return Void();
1655 }
1656
1657 Return<void> RadioImpl::setGsmBroadcastConfig(int32_t serial,
1658                                               const hidl_vec<GsmBroadcastSmsConfigInfo>&
1659                                               configInfo) {
1660 #if VDBG
1661     RLOGD("setGsmBroadcastConfig: serial %d", serial);
1662 #endif
1663     RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
1664             RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG);
1665     if (pRI == NULL) {
1666         return Void();
1667     }
1668
1669     int num = configInfo.size();
1670     RIL_GSM_BroadcastSmsConfigInfo gsmBci[num];
1671     RIL_GSM_BroadcastSmsConfigInfo *gsmBciPtrs[num];
1672
1673     for (int i = 0 ; i < num ; i++ ) {
1674         gsmBciPtrs[i] = &gsmBci[i];
1675         gsmBci[i].fromServiceId = configInfo[i].fromServiceId;
1676         gsmBci[i].toServiceId = configInfo[i].toServiceId;
1677         gsmBci[i].fromCodeScheme = configInfo[i].fromCodeScheme;
1678         gsmBci[i].toCodeScheme = configInfo[i].toCodeScheme;
1679         gsmBci[i].selected = BOOL_TO_INT(configInfo[i].selected);
1680     }
1681
1682     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, gsmBciPtrs,
1683             num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *), pRI);
1684     return Void();
1685 }
1686
1687 Return<void> RadioImpl::setGsmBroadcastActivation(int32_t serial, bool activate) {
1688 #if VDBG
1689     RLOGD("setGsmBroadcastActivation: serial %d", serial);
1690 #endif
1691     dispatchInts(serial, mSlotId, RIL_REQUEST_GSM_SMS_BROADCAST_ACTIVATION,
1692             1, BOOL_TO_INT(!activate));
1693     return Void();
1694 }
1695
1696 Return<void> RadioImpl::getCdmaBroadcastConfig(int32_t serial) {
1697 #if VDBG
1698     RLOGD("getCdmaBroadcastConfig: serial %d", serial);
1699 #endif
1700     dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG);
1701     return Void();
1702 }
1703
1704 Return<void> RadioImpl::setCdmaBroadcastConfig(int32_t serial,
1705                                                const hidl_vec<CdmaBroadcastSmsConfigInfo>&
1706                                                configInfo) {
1707 #if VDBG
1708     RLOGD("setCdmaBroadcastConfig: serial %d", serial);
1709 #endif
1710     RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
1711             RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG);
1712     if (pRI == NULL) {
1713         return Void();
1714     }
1715
1716     int num = configInfo.size();
1717     RIL_CDMA_BroadcastSmsConfigInfo cdmaBci[num];
1718     RIL_CDMA_BroadcastSmsConfigInfo *cdmaBciPtrs[num];
1719
1720     for (int i = 0 ; i < num ; i++ ) {
1721         cdmaBciPtrs[i] = &cdmaBci[i];
1722         cdmaBci[i].service_category = configInfo[i].serviceCategory;
1723         cdmaBci[i].language = configInfo[i].language;
1724         cdmaBci[i].selected = BOOL_TO_INT(configInfo[i].selected);
1725     }
1726
1727     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, cdmaBciPtrs,
1728             num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *), pRI);
1729     return Void();
1730 }
1731
1732 Return<void> RadioImpl::setCdmaBroadcastActivation(int32_t serial, bool activate) {
1733 #if VDBG
1734     RLOGD("setCdmaBroadcastActivation: serial %d", serial);
1735 #endif
1736     dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION,
1737             1, BOOL_TO_INT(!activate));
1738     return Void();
1739 }
1740
1741 Return<void> RadioImpl::getCDMASubscription(int32_t serial) {
1742 #if VDBG
1743     RLOGD("getCDMASubscription: serial %d", serial);
1744 #endif
1745     dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_SUBSCRIPTION);
1746     return Void();
1747 }
1748
1749 Return<void> RadioImpl::writeSmsToRuim(int32_t serial, const CdmaSmsWriteArgs& cdmaSms) {
1750 #if VDBG
1751     RLOGD("writeSmsToRuim: serial %d", serial);
1752 #endif
1753     RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
1754             RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM);
1755     if (pRI == NULL) {
1756         return Void();
1757     }
1758
1759     RIL_CDMA_SMS_WriteArgs rcsw = {};
1760     rcsw.status = (int) cdmaSms.status;
1761     constructCdmaSms(rcsw.message, cdmaSms.message);
1762
1763     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &rcsw, sizeof(rcsw), pRI);
1764     return Void();
1765 }
1766
1767 Return<void> RadioImpl::deleteSmsOnRuim(int32_t serial, int32_t index) {
1768 #if VDBG
1769     RLOGD("deleteSmsOnRuim: serial %d", serial);
1770 #endif
1771     dispatchInts(serial, mSlotId, RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM, 1, index);
1772     return Void();
1773 }
1774
1775 Return<void> RadioImpl::getDeviceIdentity(int32_t serial) {
1776 #if VDBG
1777     RLOGD("getDeviceIdentity: serial %d", serial);
1778 #endif
1779     dispatchVoid(serial, mSlotId, RIL_REQUEST_DEVICE_IDENTITY);
1780     return Void();
1781 }
1782
1783 Return<void> RadioImpl::exitEmergencyCallbackMode(int32_t serial) {
1784 #if VDBG
1785     RLOGD("exitEmergencyCallbackMode: serial %d", serial);
1786 #endif
1787     dispatchVoid(serial, mSlotId, RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE);
1788     return Void();
1789 }
1790
1791 Return<void> RadioImpl::getSmscAddress(int32_t serial) {
1792 #if VDBG
1793     RLOGD("getSmscAddress: serial %d", serial);
1794 #endif
1795     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_SMSC_ADDRESS);
1796     return Void();
1797 }
1798
1799 Return<void> RadioImpl::setSmscAddress(int32_t serial, const hidl_string& smsc) {
1800 #if VDBG
1801     RLOGD("setSmscAddress: serial %d", serial);
1802 #endif
1803     dispatchString(serial, mSlotId, RIL_REQUEST_SET_SMSC_ADDRESS,
1804             smsc.c_str());
1805     return Void();
1806 }
1807
1808 Return<void> RadioImpl::reportSmsMemoryStatus(int32_t serial, bool available) {
1809 #if VDBG
1810     RLOGD("reportSmsMemoryStatus: serial %d", serial);
1811 #endif
1812     dispatchInts(serial, mSlotId, RIL_REQUEST_REPORT_SMS_MEMORY_STATUS, 1,
1813             BOOL_TO_INT(available));
1814     return Void();
1815 }
1816
1817 Return<void> RadioImpl::reportStkServiceIsRunning(int32_t serial) {
1818 #if VDBG
1819     RLOGD("reportStkServiceIsRunning: serial %d", serial);
1820 #endif
1821     dispatchVoid(serial, mSlotId, RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING);
1822     return Void();
1823 }
1824
1825 Return<void> RadioImpl::getCdmaSubscriptionSource(int32_t serial) {
1826 #if VDBG
1827     RLOGD("getCdmaSubscriptionSource: serial %d", serial);
1828 #endif
1829     dispatchVoid(serial, mSlotId, RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE);
1830     return Void();
1831 }
1832
1833 Return<void> RadioImpl::requestIsimAuthentication(int32_t serial, const hidl_string& challenge) {
1834 #if VDBG
1835     RLOGD("requestIsimAuthentication: serial %d", serial);
1836 #endif
1837     dispatchString(serial, mSlotId, RIL_REQUEST_ISIM_AUTHENTICATION,
1838             challenge.c_str());
1839     return Void();
1840 }
1841
1842 Return<void> RadioImpl::acknowledgeIncomingGsmSmsWithPdu(int32_t serial, bool success,
1843                                                          const hidl_string& ackPdu) {
1844 #if VDBG
1845     RLOGD("acknowledgeIncomingGsmSmsWithPdu: serial %d", serial);
1846 #endif
1847     dispatchStrings(serial, mSlotId, RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU,
1848             2, success ? "1" : "0", ackPdu.c_str());
1849     return Void();
1850 }
1851
1852 Return<void> RadioImpl::sendEnvelopeWithStatus(int32_t serial, const hidl_string& contents) {
1853 #if VDBG
1854     RLOGD("sendEnvelopeWithStatus: serial %d", serial);
1855 #endif
1856     dispatchString(serial, mSlotId, RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS,
1857             contents.c_str());
1858     return Void();
1859 }
1860
1861 Return<void> RadioImpl::getVoiceRadioTechnology(int32_t serial) {
1862 #if VDBG
1863     RLOGD("getVoiceRadioTechnology: serial %d", serial);
1864 #endif
1865     dispatchVoid(serial, mSlotId, RIL_REQUEST_VOICE_RADIO_TECH);
1866     return Void();
1867 }
1868
1869 Return<void> RadioImpl::getCellInfoList(int32_t serial) {
1870 #if VDBG
1871     RLOGD("getCellInfoList: serial %d", serial);
1872 #endif
1873     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_CELL_INFO_LIST);
1874     return Void();
1875 }
1876
1877 Return<void> RadioImpl::setCellInfoListRate(int32_t serial, int32_t rate) {
1878 #if VDBG
1879     RLOGD("setCellInfoListRate: serial %d", serial);
1880 #endif
1881     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE, 1, rate);
1882     return Void();
1883 }
1884
1885 Return<void> RadioImpl::setInitialAttachApn(int32_t serial, const DataProfileInfo& dataProfileInfo,
1886                                             bool modemCognitive, bool isRoaming) {
1887 #if VDBG
1888     RLOGD("setInitialAttachApn: serial %d", serial);
1889 #endif
1890     RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
1891             RIL_REQUEST_SET_INITIAL_ATTACH_APN);
1892     if (pRI == NULL) {
1893         return Void();
1894     }
1895
1896     if (s_vendorFunctions->version <= 14) {
1897         RIL_InitialAttachApn iaa = {};
1898
1899         if (!copyHidlStringToRil(&iaa.apn, dataProfileInfo.apn, pRI)) {
1900             return Void();
1901         }
1902
1903         const hidl_string &protocol =
1904                 (isRoaming ? dataProfileInfo.roamingProtocol : dataProfileInfo.protocol);
1905
1906         if (!copyHidlStringToRil(&iaa.protocol, protocol, pRI)) {
1907             return Void();
1908         }
1909         iaa.authtype = (int) dataProfileInfo.authType;
1910         if (!copyHidlStringToRil(&iaa.username, dataProfileInfo.user, pRI)) {
1911             return Void();
1912         }
1913         if (!copyHidlStringToRil(&iaa.password, dataProfileInfo.password, pRI)) {
1914             return Void();
1915         }
1916
1917         s_vendorFunctions->onRequest(RIL_REQUEST_SET_INITIAL_ATTACH_APN, &iaa, sizeof(iaa), pRI);
1918
1919         memsetAndFreeStrings(4, iaa.apn, iaa.protocol, iaa.username, iaa.password);
1920     } else {
1921         RIL_InitialAttachApn_v15 iaa = {};
1922
1923         if (!copyHidlStringToRil(&iaa.apn, dataProfileInfo.apn, pRI)) {
1924             return Void();
1925         }
1926         if (!copyHidlStringToRil(&iaa.protocol, dataProfileInfo.protocol, pRI)) {
1927             return Void();
1928         }
1929         if (!copyHidlStringToRil(&iaa.roamingProtocol, dataProfileInfo.roamingProtocol, pRI)) {
1930             return Void();
1931         }
1932         iaa.authtype = (int) dataProfileInfo.authType;
1933         if (!copyHidlStringToRil(&iaa.username, dataProfileInfo.user, pRI)) {
1934             return Void();
1935         }
1936         if (!copyHidlStringToRil(&iaa.password, dataProfileInfo.password, pRI)) {
1937             return Void();
1938         }
1939         iaa.supportedTypesBitmask = dataProfileInfo.supportedApnTypesBitmap;
1940         iaa.bearerBitmask = dataProfileInfo.bearerBitmap;
1941         iaa.modemCognitive = BOOL_TO_INT(modemCognitive);
1942         iaa.mtu = dataProfileInfo.mtu;
1943
1944         if (!convertMvnoTypeToString(dataProfileInfo.mvnoType, iaa.mvnoType)) {
1945             sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
1946             return Void();
1947         }
1948
1949         if (!copyHidlStringToRil(&iaa.mvnoMatchData, dataProfileInfo.mvnoMatchData, pRI)) {
1950             return Void();
1951         }
1952
1953         s_vendorFunctions->onRequest(RIL_REQUEST_SET_INITIAL_ATTACH_APN, &iaa, sizeof(iaa), pRI);
1954
1955         memsetAndFreeStrings(6, iaa.apn, iaa.protocol, iaa.roamingProtocol, iaa.username,
1956                 iaa.password, iaa.mvnoMatchData);
1957     }
1958
1959     return Void();
1960 }
1961
1962 Return<void> RadioImpl::getImsRegistrationState(int32_t serial) {
1963 #if VDBG
1964     RLOGD("getImsRegistrationState: serial %d", serial);
1965 #endif
1966     dispatchVoid(serial, mSlotId, RIL_REQUEST_IMS_REGISTRATION_STATE);
1967     return Void();
1968 }
1969
1970 bool dispatchImsGsmSms(const ImsSmsMessage& message, RequestInfo *pRI) {
1971     RIL_IMS_SMS_Message rism = {};
1972     char **pStrings;
1973     int countStrings = 2;
1974     int dataLen = sizeof(char *) * countStrings;
1975
1976     rism.tech = RADIO_TECH_3GPP;
1977     rism.retry = BOOL_TO_INT(message.retry);
1978     rism.messageRef = message.messageRef;
1979
1980     if (message.gsmMessage.size() != 1) {
1981         RLOGE("dispatchImsGsmSms: Invalid len %s", requestToString(pRI->pCI->requestNumber));
1982         sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
1983         return false;
1984     }
1985
1986     pStrings = (char **)calloc(countStrings, sizeof(char *));
1987     if (pStrings == NULL) {
1988         RLOGE("dispatchImsGsmSms: Memory allocation failed for request %s",
1989                 requestToString(pRI->pCI->requestNumber));
1990         sendErrorResponse(pRI, RIL_E_NO_MEMORY);
1991         return false;
1992     }
1993
1994     if (!copyHidlStringToRil(&pStrings[0], message.gsmMessage[0].smscPdu, pRI)) {
1995 #ifdef MEMSET_FREED
1996         memset(pStrings, 0, dataLen);
1997 #endif
1998         free(pStrings);
1999         return false;
2000     }
2001
2002     if (!copyHidlStringToRil(&pStrings[1], message.gsmMessage[0].pdu, pRI)) {
2003         memsetAndFreeStrings(1, pStrings[0]);
2004 #ifdef MEMSET_FREED
2005         memset(pStrings, 0, dataLen);
2006 #endif
2007         free(pStrings);
2008         return false;
2009     }
2010
2011     rism.message.gsmMessage = pStrings;
2012     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &rism, sizeof(RIL_RadioTechnologyFamily) +
2013             sizeof(uint8_t) + sizeof(int32_t) + dataLen, pRI);
2014
2015     for (int i = 0 ; i < countStrings ; i++) {
2016         memsetAndFreeStrings(1, pStrings[i]);
2017     }
2018
2019 #ifdef MEMSET_FREED
2020     memset(pStrings, 0, dataLen);
2021 #endif
2022     free(pStrings);
2023
2024     return true;
2025 }
2026
2027 bool dispatchImsCdmaSms(const ImsSmsMessage& message, RequestInfo *pRI) {
2028     RIL_IMS_SMS_Message rism;
2029     RIL_CDMA_SMS_Message rcsm;
2030
2031     if (message.cdmaMessage.size() != 1) {
2032         RLOGE("dispatchImsCdmaSms: Invalid len %s", requestToString(pRI->pCI->requestNumber));
2033         sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
2034         return false;
2035     }
2036
2037     rism.tech = RADIO_TECH_3GPP2;
2038     rism.retry = BOOL_TO_INT(message.retry);
2039     rism.messageRef = message.messageRef;
2040     rism.message.cdmaMessage = &rcsm;
2041
2042     constructCdmaSms(rcsm, message.cdmaMessage[0]);
2043
2044     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &rism, sizeof(RIL_RadioTechnologyFamily) +
2045             sizeof(uint8_t) + sizeof(int32_t) + sizeof(rcsm), pRI);
2046
2047     return true;
2048 }
2049
2050 Return<void> RadioImpl::sendImsSms(int32_t serial, const ImsSmsMessage& message) {
2051 #if VDBG
2052     RLOGD("sendImsSms: serial %d", serial);
2053 #endif
2054     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_IMS_SEND_SMS);
2055     if (pRI == NULL) {
2056         return Void();
2057     }
2058
2059     RIL_RadioTechnologyFamily format = (RIL_RadioTechnologyFamily) message.tech;
2060
2061     if (RADIO_TECH_3GPP == format) {
2062         dispatchImsGsmSms(message, pRI);
2063     } else if (RADIO_TECH_3GPP2 == format) {
2064         dispatchImsCdmaSms(message, pRI);
2065     } else {
2066         RLOGE("sendImsSms: Invalid radio tech %s",
2067                 requestToString(pRI->pCI->requestNumber));
2068         sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
2069     }
2070     return Void();
2071 }
2072
2073 Return<void> RadioImpl::iccTransmitApduBasicChannel(int32_t serial, const SimApdu& message) {
2074 #if VDBG
2075     RLOGD("iccTransmitApduBasicChannel: serial %d", serial);
2076 #endif
2077     dispatchIccApdu(serial, mSlotId, RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC, message);
2078     return Void();
2079 }
2080
2081 Return<void> RadioImpl::iccOpenLogicalChannel(int32_t serial, const hidl_string& aid, int32_t p2) {
2082 #if VDBG
2083     RLOGD("iccOpenLogicalChannel: serial %d", serial);
2084 #endif
2085     if (s_vendorFunctions->version < 15) {
2086         dispatchString(serial, mSlotId, RIL_REQUEST_SIM_OPEN_CHANNEL, aid.c_str());
2087     } else {
2088         RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SIM_OPEN_CHANNEL);
2089         if (pRI == NULL) {
2090             return Void();
2091         }
2092
2093         RIL_OpenChannelParams params;
2094         memset (&params, 0, sizeof(RIL_OpenChannelParams));
2095
2096         params.p2 = p2;
2097
2098         if (!copyHidlStringToRil(&params.aidPtr, aid, pRI)) {
2099             return Void();
2100         }
2101
2102         s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &params, sizeof(params), pRI);
2103
2104         memsetAndFreeStrings(1, params.aidPtr);
2105     }
2106     return Void();
2107 }
2108
2109 Return<void> RadioImpl::iccCloseLogicalChannel(int32_t serial, int32_t channelId) {
2110 #if VDBG
2111     RLOGD("iccCloseLogicalChannel: serial %d", serial);
2112 #endif
2113     dispatchInts(serial, mSlotId, RIL_REQUEST_SIM_CLOSE_CHANNEL, 1, channelId);
2114     return Void();
2115 }
2116
2117 Return<void> RadioImpl::iccTransmitApduLogicalChannel(int32_t serial, const SimApdu& message) {
2118 #if VDBG
2119     RLOGD("iccTransmitApduLogicalChannel: serial %d", serial);
2120 #endif
2121     dispatchIccApdu(serial, mSlotId, RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL, message);
2122     return Void();
2123 }
2124
2125 Return<void> RadioImpl::nvReadItem(int32_t serial, NvItem itemId) {
2126 #if VDBG
2127     RLOGD("nvReadItem: serial %d", serial);
2128 #endif
2129     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_NV_READ_ITEM);
2130     if (pRI == NULL) {
2131         return Void();
2132     }
2133
2134     RIL_NV_ReadItem nvri;
2135     memset (&nvri, 0, sizeof(nvri));
2136     nvri.itemID = (RIL_NV_Item) itemId;
2137
2138     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &nvri, sizeof(nvri), pRI);
2139     return Void();
2140 }
2141
2142 Return<void> RadioImpl::nvWriteItem(int32_t serial, const NvWriteItem& item) {
2143 #if VDBG
2144     RLOGD("nvWriteItem: serial %d", serial);
2145 #endif
2146     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_NV_WRITE_ITEM);
2147     if (pRI == NULL) {
2148         return Void();
2149     }
2150
2151     RIL_NV_WriteItem nvwi;
2152     memset (&nvwi, 0, sizeof(nvwi));
2153
2154     nvwi.itemID = (RIL_NV_Item) item.itemId;
2155
2156     if (!copyHidlStringToRil(&nvwi.value, item.value, pRI)) {
2157         return Void();
2158     }
2159
2160     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &nvwi, sizeof(nvwi), pRI);
2161
2162     memsetAndFreeStrings(1, nvwi.value);
2163     return Void();
2164 }
2165
2166 Return<void> RadioImpl::nvWriteCdmaPrl(int32_t serial, const hidl_vec<uint8_t>& prl) {
2167 #if VDBG
2168     RLOGD("nvWriteCdmaPrl: serial %d", serial);
2169 #endif
2170     dispatchRaw(serial, mSlotId, RIL_REQUEST_NV_WRITE_CDMA_PRL, prl);
2171     return Void();
2172 }
2173
2174 Return<void> RadioImpl::nvResetConfig(int32_t serial, ResetNvType resetType) {
2175 #if VDBG
2176     RLOGD("nvResetConfig: serial %d", serial);
2177 #endif
2178     dispatchInts(serial, mSlotId, RIL_REQUEST_NV_RESET_CONFIG, 1, (int) resetType);
2179     return Void();
2180 }
2181
2182 Return<void> RadioImpl::setUiccSubscription(int32_t serial, const SelectUiccSub& uiccSub) {
2183 #if VDBG
2184     RLOGD("setUiccSubscription: serial %d", serial);
2185 #endif
2186     RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
2187             RIL_REQUEST_SET_UICC_SUBSCRIPTION);
2188     if (pRI == NULL) {
2189         return Void();
2190     }
2191
2192     RIL_SelectUiccSub rilUiccSub = {};
2193
2194     rilUiccSub.slot = uiccSub.slot;
2195     rilUiccSub.app_index = uiccSub.appIndex;
2196     rilUiccSub.sub_type = (RIL_SubscriptionType) uiccSub.subType;
2197     rilUiccSub.act_status = (RIL_UiccSubActStatus) uiccSub.actStatus;
2198
2199     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &rilUiccSub, sizeof(rilUiccSub), pRI);
2200     return Void();
2201 }
2202
2203 Return<void> RadioImpl::setDataAllowed(int32_t serial, bool allow) {
2204 #if VDBG
2205     RLOGD("setDataAllowed: serial %d", serial);
2206 #endif
2207     dispatchInts(serial, mSlotId, RIL_REQUEST_ALLOW_DATA, 1, BOOL_TO_INT(allow));
2208     return Void();
2209 }
2210
2211 Return<void> RadioImpl::getHardwareConfig(int32_t serial) {
2212 #if VDBG
2213     RLOGD("getHardwareConfig: serial %d", serial);
2214 #endif
2215     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_HARDWARE_CONFIG);
2216     return Void();
2217 }
2218
2219 Return<void> RadioImpl::requestIccSimAuthentication(int32_t serial, int32_t authContext,
2220         const hidl_string& authData, const hidl_string& aid) {
2221 #if VDBG
2222     RLOGD("requestIccSimAuthentication: serial %d", serial);
2223 #endif
2224     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SIM_AUTHENTICATION);
2225     if (pRI == NULL) {
2226         return Void();
2227     }
2228
2229     RIL_SimAuthentication pf;
2230     memset (&pf, 0, sizeof(pf));
2231
2232     pf.authContext = authContext;
2233
2234     int len;
2235     if (!copyHidlStringToRil(&pf.authData, authData, pRI)) {
2236         return Void();
2237     }
2238
2239     if (!copyHidlStringToRil(&pf.aid, aid, pRI)) {
2240         memsetAndFreeStrings(1, pf.authData);
2241         return Void();
2242     }
2243
2244     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &pf, sizeof(pf), pRI);
2245
2246     memsetAndFreeStrings(2, pf.authData, pf.aid);
2247     return Void();
2248 }
2249
2250 /**
2251  * @param numProfiles number of data profile
2252  * @param dataProfiles the pointer to the actual data profiles. The acceptable type is
2253           RIL_DataProfileInfo or RIL_DataProfileInfo_v15.
2254  * @param dataProfilePtrs the pointer to the pointers that point to each data profile structure
2255  * @param numfields number of string-type member in the data profile structure
2256  * @param ... the variadic parameters are pointers to each string-type member
2257  **/
2258 template <typename T>
2259 void freeSetDataProfileData(int numProfiles, T *dataProfiles, T **dataProfilePtrs,
2260                             int numfields, ...) {
2261     va_list args;
2262     va_start(args, numfields);
2263
2264     // Iterate through each string-type field that need to be free.
2265     for (int i = 0; i < numfields; i++) {
2266         // Iterate through each data profile and free that specific string-type field.
2267         // The type 'char *T::*' is a type of pointer to a 'char *' member inside T structure.
2268         char *T::*ptr = va_arg(args, char *T::*);
2269         for (int j = 0; j < numProfiles; j++) {
2270             memsetAndFreeStrings(1, dataProfiles[j].*ptr);
2271         }
2272     }
2273
2274     va_end(args);
2275
2276 #ifdef MEMSET_FREED
2277     memset(dataProfiles, 0, numProfiles * sizeof(T));
2278     memset(dataProfilePtrs, 0, numProfiles * sizeof(T *));
2279 #endif
2280     free(dataProfiles);
2281     free(dataProfilePtrs);
2282 }
2283
2284 Return<void> RadioImpl::setDataProfile(int32_t serial, const hidl_vec<DataProfileInfo>& profiles,
2285                                        bool isRoaming) {
2286 #if VDBG
2287     RLOGD("setDataProfile: serial %d", serial);
2288 #endif
2289     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SET_DATA_PROFILE);
2290     if (pRI == NULL) {
2291         return Void();
2292     }
2293
2294     size_t num = profiles.size();
2295     bool success = false;
2296
2297     if (s_vendorFunctions->version <= 14) {
2298
2299         RIL_DataProfileInfo *dataProfiles =
2300             (RIL_DataProfileInfo *) calloc(num, sizeof(RIL_DataProfileInfo));
2301
2302         if (dataProfiles == NULL) {
2303             RLOGE("Memory allocation failed for request %s",
2304                     requestToString(pRI->pCI->requestNumber));
2305             sendErrorResponse(pRI, RIL_E_NO_MEMORY);
2306             return Void();
2307         }
2308
2309         RIL_DataProfileInfo **dataProfilePtrs =
2310             (RIL_DataProfileInfo **) calloc(num, sizeof(RIL_DataProfileInfo *));
2311         if (dataProfilePtrs == NULL) {
2312             RLOGE("Memory allocation failed for request %s",
2313                     requestToString(pRI->pCI->requestNumber));
2314             free(dataProfiles);
2315             sendErrorResponse(pRI, RIL_E_NO_MEMORY);
2316             return Void();
2317         }
2318
2319         for (size_t i = 0; i < num; i++) {
2320             dataProfilePtrs[i] = &dataProfiles[i];
2321
2322             success = copyHidlStringToRil(&dataProfiles[i].apn, profiles[i].apn, pRI);
2323
2324             const hidl_string &protocol =
2325                     (isRoaming ? profiles[i].roamingProtocol : profiles[i].protocol);
2326
2327             if (success && !copyHidlStringToRil(&dataProfiles[i].protocol, protocol, pRI)) {
2328                 success = false;
2329             }
2330
2331             if (success && !copyHidlStringToRil(&dataProfiles[i].user, profiles[i].user, pRI)) {
2332                 success = false;
2333             }
2334             if (success && !copyHidlStringToRil(&dataProfiles[i].password, profiles[i].password,
2335                     pRI)) {
2336                 success = false;
2337             }
2338
2339             if (!success) {
2340                 freeSetDataProfileData(num, dataProfiles, dataProfilePtrs, 4,
2341                     &RIL_DataProfileInfo::apn, &RIL_DataProfileInfo::protocol,
2342                     &RIL_DataProfileInfo::user, &RIL_DataProfileInfo::password);
2343                 return Void();
2344             }
2345
2346             dataProfiles[i].profileId = (RIL_DataProfile) profiles[i].profileId;
2347             dataProfiles[i].authType = (int) profiles[i].authType;
2348             dataProfiles[i].type = (int) profiles[i].type;
2349             dataProfiles[i].maxConnsTime = profiles[i].maxConnsTime;
2350             dataProfiles[i].maxConns = profiles[i].maxConns;
2351             dataProfiles[i].waitTime = profiles[i].waitTime;
2352             dataProfiles[i].enabled = BOOL_TO_INT(profiles[i].enabled);
2353         }
2354
2355         s_vendorFunctions->onRequest(RIL_REQUEST_SET_DATA_PROFILE, dataProfilePtrs,
2356                 num * sizeof(RIL_DataProfileInfo *), pRI);
2357
2358         freeSetDataProfileData(num, dataProfiles, dataProfilePtrs, 4,
2359                 &RIL_DataProfileInfo::apn, &RIL_DataProfileInfo::protocol,
2360                 &RIL_DataProfileInfo::user, &RIL_DataProfileInfo::password);
2361     } else {
2362         RIL_DataProfileInfo_v15 *dataProfiles =
2363             (RIL_DataProfileInfo_v15 *) calloc(num, sizeof(RIL_DataProfileInfo_v15));
2364
2365         if (dataProfiles == NULL) {
2366             RLOGE("Memory allocation failed for request %s",
2367                     requestToString(pRI->pCI->requestNumber));
2368             sendErrorResponse(pRI, RIL_E_NO_MEMORY);
2369             return Void();
2370         }
2371
2372         RIL_DataProfileInfo_v15 **dataProfilePtrs =
2373             (RIL_DataProfileInfo_v15 **) calloc(num, sizeof(RIL_DataProfileInfo_v15 *));
2374         if (dataProfilePtrs == NULL) {
2375             RLOGE("Memory allocation failed for request %s",
2376                     requestToString(pRI->pCI->requestNumber));
2377             free(dataProfiles);
2378             sendErrorResponse(pRI, RIL_E_NO_MEMORY);
2379             return Void();
2380         }
2381
2382         for (size_t i = 0; i < num; i++) {
2383             dataProfilePtrs[i] = &dataProfiles[i];
2384
2385             success = copyHidlStringToRil(&dataProfiles[i].apn, profiles[i].apn, pRI);
2386             if (success && !copyHidlStringToRil(&dataProfiles[i].protocol, profiles[i].protocol,
2387                     pRI)) {
2388                 success = false;
2389             }
2390             if (success && !copyHidlStringToRil(&dataProfiles[i].roamingProtocol,
2391                     profiles[i].roamingProtocol, pRI)) {
2392                 success = false;
2393             }
2394             if (success && !copyHidlStringToRil(&dataProfiles[i].user, profiles[i].user, pRI)) {
2395                 success = false;
2396             }
2397             if (success && !copyHidlStringToRil(&dataProfiles[i].password, profiles[i].password,
2398                     pRI)) {
2399                 success = false;
2400             }
2401
2402             if (success && !copyHidlStringToRil(&dataProfiles[i].mvnoMatchData,
2403                     profiles[i].mvnoMatchData, pRI)) {
2404                 success = false;
2405             }
2406
2407             if (success && !convertMvnoTypeToString(profiles[i].mvnoType,
2408                     dataProfiles[i].mvnoType)) {
2409                 sendErrorResponse(pRI, RIL_E_INVALID_ARGUMENTS);
2410                 success = false;
2411             }
2412
2413             if (!success) {
2414                 freeSetDataProfileData(num, dataProfiles, dataProfilePtrs, 6,
2415                     &RIL_DataProfileInfo_v15::apn, &RIL_DataProfileInfo_v15::protocol,
2416                     &RIL_DataProfileInfo_v15::roamingProtocol, &RIL_DataProfileInfo_v15::user,
2417                     &RIL_DataProfileInfo_v15::password, &RIL_DataProfileInfo_v15::mvnoMatchData);
2418                 return Void();
2419             }
2420
2421             dataProfiles[i].profileId = (RIL_DataProfile) profiles[i].profileId;
2422             dataProfiles[i].authType = (int) profiles[i].authType;
2423             dataProfiles[i].type = (int) profiles[i].type;
2424             dataProfiles[i].maxConnsTime = profiles[i].maxConnsTime;
2425             dataProfiles[i].maxConns = profiles[i].maxConns;
2426             dataProfiles[i].waitTime = profiles[i].waitTime;
2427             dataProfiles[i].enabled = BOOL_TO_INT(profiles[i].enabled);
2428             dataProfiles[i].supportedTypesBitmask = profiles[i].supportedApnTypesBitmap;
2429             dataProfiles[i].bearerBitmask = profiles[i].bearerBitmap;
2430             dataProfiles[i].mtu = profiles[i].mtu;
2431         }
2432
2433         s_vendorFunctions->onRequest(RIL_REQUEST_SET_DATA_PROFILE, dataProfilePtrs,
2434                 num * sizeof(RIL_DataProfileInfo_v15 *), pRI);
2435
2436         freeSetDataProfileData(num, dataProfiles, dataProfilePtrs, 6,
2437                 &RIL_DataProfileInfo_v15::apn, &RIL_DataProfileInfo_v15::protocol,
2438                 &RIL_DataProfileInfo_v15::roamingProtocol, &RIL_DataProfileInfo_v15::user,
2439                 &RIL_DataProfileInfo_v15::password, &RIL_DataProfileInfo_v15::mvnoMatchData);
2440     }
2441
2442     return Void();
2443 }
2444
2445 Return<void> RadioImpl::requestShutdown(int32_t serial) {
2446 #if VDBG
2447     RLOGD("requestShutdown: serial %d", serial);
2448 #endif
2449     dispatchVoid(serial, mSlotId, RIL_REQUEST_SHUTDOWN);
2450     return Void();
2451 }
2452
2453 Return<void> RadioImpl::getRadioCapability(int32_t serial) {
2454 #if VDBG
2455     RLOGD("getRadioCapability: serial %d", serial);
2456 #endif
2457     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_RADIO_CAPABILITY);
2458     return Void();
2459 }
2460
2461 Return<void> RadioImpl::setRadioCapability(int32_t serial, const RadioCapability& rc) {
2462 #if VDBG
2463     RLOGD("setRadioCapability: serial %d", serial);
2464 #endif
2465     RequestInfo *pRI = android::addRequestToList(serial, mSlotId, RIL_REQUEST_SET_RADIO_CAPABILITY);
2466     if (pRI == NULL) {
2467         return Void();
2468     }
2469
2470     RIL_RadioCapability rilRc;
2471     memset (&rilRc, 0, sizeof(rilRc));
2472
2473     // TODO : set rilRc.version using HIDL version ?
2474     rilRc.session = rc.session;
2475     rilRc.phase = (int) rc.phase;
2476     rilRc.rat = (int) rc.raf;
2477     rilRc.status = (int) rc.status;
2478     strncpy(rilRc.logicalModemUuid, rc.logicalModemUuid.c_str(), MAX_UUID_LENGTH);
2479
2480     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &rilRc, sizeof(rilRc), pRI);
2481
2482     return Void();
2483 }
2484
2485 Return<void> RadioImpl::startLceService(int32_t serial, int32_t reportInterval, bool pullMode) {
2486 #if VDBG
2487     RLOGD("startLceService: serial %d", serial);
2488 #endif
2489     dispatchInts(serial, mSlotId, RIL_REQUEST_START_LCE, 2, reportInterval,
2490             BOOL_TO_INT(pullMode));
2491     return Void();
2492 }
2493
2494 Return<void> RadioImpl::stopLceService(int32_t serial) {
2495 #if VDBG
2496     RLOGD("stopLceService: serial %d", serial);
2497 #endif
2498     dispatchVoid(serial, mSlotId, RIL_REQUEST_STOP_LCE);
2499     return Void();
2500 }
2501
2502 Return<void> RadioImpl::pullLceData(int32_t serial) {
2503 #if VDBG
2504     RLOGD("pullLceData: serial %d", serial);
2505 #endif
2506     dispatchVoid(serial, mSlotId, RIL_REQUEST_PULL_LCEDATA);
2507     return Void();
2508 }
2509
2510 Return<void> RadioImpl::getModemActivityInfo(int32_t serial) {
2511 #if VDBG
2512     RLOGD("getModemActivityInfo: serial %d", serial);
2513 #endif
2514     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_ACTIVITY_INFO);
2515     return Void();
2516 }
2517
2518 Return<void> RadioImpl::setAllowedCarriers(int32_t serial, bool allAllowed,
2519                                            const CarrierRestrictions& carriers) {
2520 #if VDBG
2521     RLOGD("setAllowedCarriers: serial %d", serial);
2522 #endif
2523     RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
2524             RIL_REQUEST_SET_CARRIER_RESTRICTIONS);
2525     if (pRI == NULL) {
2526         return Void();
2527     }
2528
2529     RIL_CarrierRestrictions cr = {};
2530     RIL_Carrier *allowedCarriers = NULL;
2531     RIL_Carrier *excludedCarriers = NULL;
2532
2533     cr.len_allowed_carriers = carriers.allowedCarriers.size();
2534     allowedCarriers = (RIL_Carrier *)calloc(cr.len_allowed_carriers, sizeof(RIL_Carrier));
2535     if (allowedCarriers == NULL) {
2536         RLOGE("setAllowedCarriers: Memory allocation failed for request %s",
2537                 requestToString(pRI->pCI->requestNumber));
2538         sendErrorResponse(pRI, RIL_E_NO_MEMORY);
2539         return Void();
2540     }
2541     cr.allowed_carriers = allowedCarriers;
2542
2543     cr.len_excluded_carriers = carriers.excludedCarriers.size();
2544     excludedCarriers = (RIL_Carrier *)calloc(cr.len_excluded_carriers, sizeof(RIL_Carrier));
2545     if (excludedCarriers == NULL) {
2546         RLOGE("setAllowedCarriers: Memory allocation failed for request %s",
2547                 requestToString(pRI->pCI->requestNumber));
2548         sendErrorResponse(pRI, RIL_E_NO_MEMORY);
2549 #ifdef MEMSET_FREED
2550         memset(allowedCarriers, 0, cr.len_allowed_carriers * sizeof(RIL_Carrier));
2551 #endif
2552         free(allowedCarriers);
2553         return Void();
2554     }
2555     cr.excluded_carriers = excludedCarriers;
2556
2557     for (int i = 0; i < cr.len_allowed_carriers; i++) {
2558         allowedCarriers[i].mcc = carriers.allowedCarriers[i].mcc.c_str();
2559         allowedCarriers[i].mnc = carriers.allowedCarriers[i].mnc.c_str();
2560         allowedCarriers[i].match_type = (RIL_CarrierMatchType) carriers.allowedCarriers[i].matchType;
2561         allowedCarriers[i].match_data = carriers.allowedCarriers[i].matchData.c_str();
2562     }
2563
2564     for (int i = 0; i < cr.len_excluded_carriers; i++) {
2565         excludedCarriers[i].mcc = carriers.excludedCarriers[i].mcc.c_str();
2566         excludedCarriers[i].mnc = carriers.excludedCarriers[i].mnc.c_str();
2567         excludedCarriers[i].match_type =
2568                 (RIL_CarrierMatchType) carriers.excludedCarriers[i].matchType;
2569         excludedCarriers[i].match_data = carriers.excludedCarriers[i].matchData.c_str();
2570     }
2571
2572     s_vendorFunctions->onRequest(pRI->pCI->requestNumber, &cr, sizeof(RIL_CarrierRestrictions), pRI);
2573
2574 #ifdef MEMSET_FREED
2575     memset(allowedCarriers, 0, cr.len_allowed_carriers * sizeof(RIL_Carrier));
2576     memset(excludedCarriers, 0, cr.len_excluded_carriers * sizeof(RIL_Carrier));
2577 #endif
2578     free(allowedCarriers);
2579     free(excludedCarriers);
2580     return Void();
2581 }
2582
2583 Return<void> RadioImpl::getAllowedCarriers(int32_t serial) {
2584 #if VDBG
2585     RLOGD("getAllowedCarriers: serial %d", serial);
2586 #endif
2587     dispatchVoid(serial, mSlotId, RIL_REQUEST_GET_CARRIER_RESTRICTIONS);
2588     return Void();
2589 }
2590
2591 Return<void> RadioImpl::sendDeviceState(int32_t serial, DeviceStateType deviceStateType,
2592                                         bool state) {
2593 #if VDBG
2594     RLOGD("sendDeviceState: serial %d", serial);
2595 #endif
2596     if (s_vendorFunctions->version < 15) {
2597         if (deviceStateType ==  DeviceStateType::LOW_DATA_EXPECTED) {
2598             RLOGD("sendDeviceState: calling screen state %d", BOOL_TO_INT(!state));
2599             dispatchInts(serial, mSlotId, RIL_REQUEST_SCREEN_STATE, 1, BOOL_TO_INT(!state));
2600         } else {
2601             RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
2602                     RIL_REQUEST_SEND_DEVICE_STATE);
2603             sendErrorResponse(pRI, RIL_E_REQUEST_NOT_SUPPORTED);
2604         }
2605         return Void();
2606     }
2607     dispatchInts(serial, mSlotId, RIL_REQUEST_SEND_DEVICE_STATE, 2, (int) deviceStateType,
2608             BOOL_TO_INT(state));
2609     return Void();
2610 }
2611
2612 Return<void> RadioImpl::setIndicationFilter(int32_t serial, int32_t indicationFilter) {
2613 #if VDBG
2614     RLOGD("setIndicationFilter: serial %d", serial);
2615 #endif
2616     if (s_vendorFunctions->version < 15) {
2617         RequestInfo *pRI = android::addRequestToList(serial, mSlotId,
2618                 RIL_REQUEST_SET_UNSOLICITED_RESPONSE_FILTER);
2619         sendErrorResponse(pRI, RIL_E_REQUEST_NOT_SUPPORTED);
2620         return Void();
2621     }
2622     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_UNSOLICITED_RESPONSE_FILTER, 1, indicationFilter);
2623     return Void();
2624 }
2625
2626 Return<void> RadioImpl::setSimCardPower(int32_t serial, bool powerUp) {
2627 #if VDBG
2628     RLOGD("setSimCardPower: serial %d", serial);
2629 #endif
2630     dispatchInts(serial, mSlotId, RIL_REQUEST_SET_SIM_CARD_POWER, 1, BOOL_TO_INT(powerUp));
2631     return Void();
2632 }
2633
2634 Return<void> RadioImpl::responseAcknowledgement() {
2635     android::releaseWakeLock();
2636     return Void();
2637 }
2638
2639 Return<void> OemHookImpl::setResponseFunctions(
2640         const ::android::sp<IOemHookResponse>& oemHookResponseParam,
2641         const ::android::sp<IOemHookIndication>& oemHookIndicationParam) {
2642 #if VDBG
2643     RLOGD("OemHookImpl::setResponseFunctions");
2644 #endif
2645
2646     pthread_rwlock_t *radioServiceRwlockPtr = radio::getRadioServiceRwlock(mSlotId);
2647     int ret = pthread_rwlock_wrlock(radioServiceRwlockPtr);
2648     assert(ret == 0);
2649
2650     mOemHookResponse = oemHookResponseParam;
2651     mOemHookIndication = oemHookIndicationParam;
2652     mCounterOemHook[mSlotId]++;
2653
2654     ret = pthread_rwlock_unlock(radioServiceRwlockPtr);
2655     assert(ret == 0);
2656
2657     return Void();
2658 }
2659
2660 Return<void> OemHookImpl::sendRequestRaw(int32_t serial, const hidl_vec<uint8_t>& data) {
2661 #if VDBG
2662     RLOGD("OemHookImpl::sendRequestRaw: serial %d", serial);
2663 #endif
2664     dispatchRaw(serial, mSlotId, RIL_REQUEST_OEM_HOOK_RAW, data);
2665     return Void();
2666 }
2667
2668 Return<void> OemHookImpl::sendRequestStrings(int32_t serial,
2669         const hidl_vec<hidl_string>& data) {
2670 #if VDBG
2671     RLOGD("OemHookImpl::sendRequestStrings: serial %d", serial);
2672 #endif
2673     dispatchStrings(serial, mSlotId, RIL_REQUEST_OEM_HOOK_STRINGS, data);
2674     return Void();
2675 }
2676
2677 /***************************************************************************************************
2678  * RESPONSE FUNCTIONS
2679  * Functions above are used for requests going from framework to vendor code. The ones below are
2680  * responses for those requests coming back from the vendor code.
2681  **************************************************************************************************/
2682
2683 void radio::acknowledgeRequest(int slotId, int serial) {
2684     if (radioService[slotId]->mRadioResponse != NULL) {
2685         Return<void> retStatus = radioService[slotId]->mRadioResponse->acknowledgeRequest(serial);
2686         radioService[slotId]->checkReturnStatus(retStatus);
2687     } else {
2688         RLOGE("acknowledgeRequest: radioService[%d]->mRadioResponse == NULL", slotId);
2689     }
2690 }
2691
2692 void populateResponseInfo(RadioResponseInfo& responseInfo, int serial, int responseType,
2693                          RIL_Errno e) {
2694     responseInfo.serial = serial;
2695     switch (responseType) {
2696         case RESPONSE_SOLICITED:
2697             responseInfo.type = RadioResponseType::SOLICITED;
2698             break;
2699         case RESPONSE_SOLICITED_ACK_EXP:
2700             responseInfo.type = RadioResponseType::SOLICITED_ACK_EXP;
2701             break;
2702     }
2703     responseInfo.error = (RadioError) e;
2704 }
2705
2706 int responseIntOrEmpty(RadioResponseInfo& responseInfo, int serial, int responseType, RIL_Errno e,
2707                void *response, size_t responseLen) {
2708     populateResponseInfo(responseInfo, serial, responseType, e);
2709     int ret = -1;
2710
2711     if (response == NULL && responseLen == 0) {
2712         // Earlier RILs did not send a response for some cases although the interface
2713         // expected an integer as response. Do not return error if response is empty. Instead
2714         // Return -1 in those cases to maintain backward compatibility.
2715     } else if (response == NULL || responseLen != sizeof(int)) {
2716         RLOGE("responseIntOrEmpty: Invalid response");
2717         if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
2718     } else {
2719         int *p_int = (int *) response;
2720         ret = p_int[0];
2721     }
2722     return ret;
2723 }
2724
2725 int responseInt(RadioResponseInfo& responseInfo, int serial, int responseType, RIL_Errno e,
2726                void *response, size_t responseLen) {
2727     populateResponseInfo(responseInfo, serial, responseType, e);
2728     int ret = -1;
2729
2730     if (response == NULL || responseLen != sizeof(int)) {
2731         RLOGE("responseInt: Invalid response");
2732         if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
2733     } else {
2734         int *p_int = (int *) response;
2735         ret = p_int[0];
2736     }
2737     return ret;
2738 }
2739
2740 int radio::getIccCardStatusResponse(int slotId,
2741                                    int responseType, int serial, RIL_Errno e,
2742                                    void *response, size_t responseLen) {
2743     if (radioService[slotId]->mRadioResponse != NULL) {
2744         RadioResponseInfo responseInfo = {};
2745         populateResponseInfo(responseInfo, serial, responseType, e);
2746         CardStatus cardStatus = {};
2747         if (response == NULL || responseLen != sizeof(RIL_CardStatus_v6)) {
2748             RLOGE("getIccCardStatusResponse: Invalid response");
2749             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
2750         } else {
2751             RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response);
2752             cardStatus.cardState = (CardState) p_cur->card_state;
2753             cardStatus.universalPinState = (PinState) p_cur->universal_pin_state;
2754             cardStatus.gsmUmtsSubscriptionAppIndex = p_cur->gsm_umts_subscription_app_index;
2755             cardStatus.cdmaSubscriptionAppIndex = p_cur->cdma_subscription_app_index;
2756             cardStatus.imsSubscriptionAppIndex = p_cur->ims_subscription_app_index;
2757
2758             RIL_AppStatus *rilAppStatus = p_cur->applications;
2759             cardStatus.applications.resize(p_cur->num_applications);
2760             AppStatus *appStatus = cardStatus.applications.data();
2761 #if VDBG
2762             RLOGD("getIccCardStatusResponse: num_applications %d", p_cur->num_applications);
2763 #endif
2764             for (int i = 0; i < p_cur->num_applications; i++) {
2765                 appStatus[i].appType = (AppType) rilAppStatus[i].app_type;
2766                 appStatus[i].appState = (AppState) rilAppStatus[i].app_state;
2767                 appStatus[i].persoSubstate = (PersoSubstate) rilAppStatus[i].perso_substate;
2768                 appStatus[i].aidPtr = convertCharPtrToHidlString(rilAppStatus[i].aid_ptr);
2769                 appStatus[i].appLabelPtr = convertCharPtrToHidlString(
2770                         rilAppStatus[i].app_label_ptr);
2771                 appStatus[i].pin1Replaced = rilAppStatus[i].pin1_replaced;
2772                 appStatus[i].pin1 = (PinState) rilAppStatus[i].pin1;
2773                 appStatus[i].pin2 = (PinState) rilAppStatus[i].pin2;
2774             }
2775         }
2776
2777         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2778                 getIccCardStatusResponse(responseInfo, cardStatus);
2779         radioService[slotId]->checkReturnStatus(retStatus);
2780     } else {
2781         RLOGE("getIccCardStatusResponse: radioService[%d]->mRadioResponse == NULL", slotId);
2782     }
2783
2784     return 0;
2785 }
2786
2787 int radio::supplyIccPinForAppResponse(int slotId,
2788                                      int responseType, int serial, RIL_Errno e,
2789                                      void *response, size_t responseLen) {
2790 #if VDBG
2791     RLOGD("supplyIccPinForAppResponse: serial %d", serial);
2792 #endif
2793
2794     if (radioService[slotId]->mRadioResponse != NULL) {
2795         RadioResponseInfo responseInfo = {};
2796         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
2797         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2798                 supplyIccPinForAppResponse(responseInfo, ret);
2799         radioService[slotId]->checkReturnStatus(retStatus);
2800     } else {
2801         RLOGE("supplyIccPinForAppResponse: radioService[%d]->mRadioResponse == NULL",
2802                 slotId);
2803     }
2804
2805     return 0;
2806 }
2807
2808 int radio::supplyIccPukForAppResponse(int slotId,
2809                                      int responseType, int serial, RIL_Errno e,
2810                                      void *response, size_t responseLen) {
2811 #if VDBG
2812     RLOGD("supplyIccPukForAppResponse: serial %d", serial);
2813 #endif
2814
2815     if (radioService[slotId]->mRadioResponse != NULL) {
2816         RadioResponseInfo responseInfo = {};
2817         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
2818         Return<void> retStatus = radioService[slotId]->mRadioResponse->supplyIccPukForAppResponse(
2819                 responseInfo, ret);
2820         radioService[slotId]->checkReturnStatus(retStatus);
2821     } else {
2822         RLOGE("supplyIccPukForAppResponse: radioService[%d]->mRadioResponse == NULL",
2823                 slotId);
2824     }
2825
2826     return 0;
2827 }
2828
2829 int radio::supplyIccPin2ForAppResponse(int slotId,
2830                                       int responseType, int serial, RIL_Errno e,
2831                                       void *response, size_t responseLen) {
2832 #if VDBG
2833     RLOGD("supplyIccPin2ForAppResponse: serial %d", serial);
2834 #endif
2835
2836     if (radioService[slotId]->mRadioResponse != NULL) {
2837         RadioResponseInfo responseInfo = {};
2838         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
2839         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2840                 supplyIccPin2ForAppResponse(responseInfo, ret);
2841         radioService[slotId]->checkReturnStatus(retStatus);
2842     } else {
2843         RLOGE("supplyIccPin2ForAppResponse: radioService[%d]->mRadioResponse == NULL",
2844                 slotId);
2845     }
2846
2847     return 0;
2848 }
2849
2850 int radio::supplyIccPuk2ForAppResponse(int slotId,
2851                                       int responseType, int serial, RIL_Errno e,
2852                                       void *response, size_t responseLen) {
2853 #if VDBG
2854     RLOGD("supplyIccPuk2ForAppResponse: serial %d", serial);
2855 #endif
2856
2857     if (radioService[slotId]->mRadioResponse != NULL) {
2858         RadioResponseInfo responseInfo = {};
2859         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
2860         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2861                 supplyIccPuk2ForAppResponse(responseInfo, ret);
2862         radioService[slotId]->checkReturnStatus(retStatus);
2863     } else {
2864         RLOGE("supplyIccPuk2ForAppResponse: radioService[%d]->mRadioResponse == NULL",
2865                 slotId);
2866     }
2867
2868     return 0;
2869 }
2870
2871 int radio::changeIccPinForAppResponse(int slotId,
2872                                      int responseType, int serial, RIL_Errno e,
2873                                      void *response, size_t responseLen) {
2874 #if VDBG
2875     RLOGD("changeIccPinForAppResponse: serial %d", serial);
2876 #endif
2877
2878     if (radioService[slotId]->mRadioResponse != NULL) {
2879         RadioResponseInfo responseInfo = {};
2880         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
2881         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2882                 changeIccPinForAppResponse(responseInfo, ret);
2883         radioService[slotId]->checkReturnStatus(retStatus);
2884     } else {
2885         RLOGE("changeIccPinForAppResponse: radioService[%d]->mRadioResponse == NULL",
2886                 slotId);
2887     }
2888
2889     return 0;
2890 }
2891
2892 int radio::changeIccPin2ForAppResponse(int slotId,
2893                                       int responseType, int serial, RIL_Errno e,
2894                                       void *response, size_t responseLen) {
2895 #if VDBG
2896     RLOGD("changeIccPin2ForAppResponse: serial %d", serial);
2897 #endif
2898
2899     if (radioService[slotId]->mRadioResponse != NULL) {
2900         RadioResponseInfo responseInfo = {};
2901         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
2902         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2903                 changeIccPin2ForAppResponse(responseInfo, ret);
2904         radioService[slotId]->checkReturnStatus(retStatus);
2905     } else {
2906         RLOGE("changeIccPin2ForAppResponse: radioService[%d]->mRadioResponse == NULL",
2907                 slotId);
2908     }
2909
2910     return 0;
2911 }
2912
2913 int radio::supplyNetworkDepersonalizationResponse(int slotId,
2914                                                  int responseType, int serial, RIL_Errno e,
2915                                                  void *response, size_t responseLen) {
2916 #if VDBG
2917     RLOGD("supplyNetworkDepersonalizationResponse: serial %d", serial);
2918 #endif
2919
2920     if (radioService[slotId]->mRadioResponse != NULL) {
2921         RadioResponseInfo responseInfo = {};
2922         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
2923         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2924                 supplyNetworkDepersonalizationResponse(responseInfo, ret);
2925         radioService[slotId]->checkReturnStatus(retStatus);
2926     } else {
2927         RLOGE("supplyNetworkDepersonalizationResponse: radioService[%d]->mRadioResponse == "
2928                 "NULL", slotId);
2929     }
2930
2931     return 0;
2932 }
2933
2934 int radio::getCurrentCallsResponse(int slotId,
2935                                   int responseType, int serial, RIL_Errno e,
2936                                   void *response, size_t responseLen) {
2937 #if VDBG
2938     RLOGD("getCurrentCallsResponse: serial %d", serial);
2939 #endif
2940
2941     if (radioService[slotId]->mRadioResponse != NULL) {
2942         RadioResponseInfo responseInfo = {};
2943         populateResponseInfo(responseInfo, serial, responseType, e);
2944
2945         hidl_vec<Call> calls;
2946         if (response == NULL || (responseLen % sizeof(RIL_Call *)) != 0) {
2947             RLOGE("getCurrentCallsResponse: Invalid response");
2948             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
2949         } else {
2950             int num = responseLen / sizeof(RIL_Call *);
2951             calls.resize(num);
2952
2953             for (int i = 0 ; i < num ; i++) {
2954                 RIL_Call *p_cur = ((RIL_Call **) response)[i];
2955                 /* each call info */
2956                 calls[i].state = (CallState) p_cur->state;
2957                 calls[i].index = p_cur->index;
2958                 calls[i].toa = p_cur->toa;
2959                 calls[i].isMpty = p_cur->isMpty;
2960                 calls[i].isMT = p_cur->isMT;
2961                 calls[i].als = p_cur->als;
2962                 calls[i].isVoice = p_cur->isVoice;
2963                 calls[i].isVoicePrivacy = p_cur->isVoicePrivacy;
2964                 calls[i].number = convertCharPtrToHidlString(p_cur->number);
2965                 calls[i].numberPresentation = (CallPresentation) p_cur->numberPresentation;
2966                 calls[i].name = convertCharPtrToHidlString(p_cur->name);
2967                 calls[i].namePresentation = (CallPresentation) p_cur->namePresentation;
2968                 if (p_cur->uusInfo != NULL && p_cur->uusInfo->uusData != NULL) {
2969                     RIL_UUS_Info *uusInfo = p_cur->uusInfo;
2970                     calls[i].uusInfo[0].uusType = (UusType) uusInfo->uusType;
2971                     calls[i].uusInfo[0].uusDcs = (UusDcs) uusInfo->uusDcs;
2972                     // convert uusInfo->uusData to a null-terminated string
2973                     char *nullTermStr = strndup(uusInfo->uusData, uusInfo->uusLength);
2974                     calls[i].uusInfo[0].uusData = nullTermStr;
2975                     free(nullTermStr);
2976                 }
2977             }
2978         }
2979
2980         Return<void> retStatus = radioService[slotId]->mRadioResponse->
2981                 getCurrentCallsResponse(responseInfo, calls);
2982         radioService[slotId]->checkReturnStatus(retStatus);
2983     } else {
2984         RLOGE("getCurrentCallsResponse: radioService[%d]->mRadioResponse == NULL", slotId);
2985     }
2986
2987     return 0;
2988 }
2989
2990 int radio::dialResponse(int slotId,
2991                        int responseType, int serial, RIL_Errno e, void *response,
2992                        size_t responseLen) {
2993 #if VDBG
2994     RLOGD("dialResponse: serial %d", serial);
2995 #endif
2996
2997     if (radioService[slotId]->mRadioResponse != NULL) {
2998         RadioResponseInfo responseInfo = {};
2999         populateResponseInfo(responseInfo, serial, responseType, e);
3000         Return<void> retStatus = radioService[slotId]->mRadioResponse->dialResponse(responseInfo);
3001         radioService[slotId]->checkReturnStatus(retStatus);
3002     } else {
3003         RLOGE("dialResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3004     }
3005
3006     return 0;
3007 }
3008
3009 int radio::getIMSIForAppResponse(int slotId,
3010                                 int responseType, int serial, RIL_Errno e, void *response,
3011                                 size_t responseLen) {
3012 #if VDBG
3013     RLOGD("getIMSIForAppResponse: serial %d", serial);
3014 #endif
3015
3016     if (radioService[slotId]->mRadioResponse != NULL) {
3017         RadioResponseInfo responseInfo = {};
3018         populateResponseInfo(responseInfo, serial, responseType, e);
3019         Return<void> retStatus = radioService[slotId]->mRadioResponse->getIMSIForAppResponse(
3020                 responseInfo, convertCharPtrToHidlString((char *) response));
3021         radioService[slotId]->checkReturnStatus(retStatus);
3022     } else {
3023         RLOGE("getIMSIForAppResponse: radioService[%d]->mRadioResponse == NULL",
3024                 slotId);
3025     }
3026
3027     return 0;
3028 }
3029
3030 int radio::hangupConnectionResponse(int slotId,
3031                                    int responseType, int serial, RIL_Errno e,
3032                                    void *response, size_t responseLen) {
3033 #if VDBG
3034     RLOGD("hangupConnectionResponse: serial %d", serial);
3035 #endif
3036
3037     if (radioService[slotId]->mRadioResponse != NULL) {
3038         RadioResponseInfo responseInfo = {};
3039         populateResponseInfo(responseInfo, serial, responseType, e);
3040         Return<void> retStatus = radioService[slotId]->mRadioResponse->hangupConnectionResponse(
3041                 responseInfo);
3042         radioService[slotId]->checkReturnStatus(retStatus);
3043     } else {
3044         RLOGE("hangupConnectionResponse: radioService[%d]->mRadioResponse == NULL",
3045                 slotId);
3046     }
3047
3048     return 0;
3049 }
3050
3051 int radio::hangupWaitingOrBackgroundResponse(int slotId,
3052                                             int responseType, int serial, RIL_Errno e,
3053                                             void *response, size_t responseLen) {
3054 #if VDBG
3055     RLOGD("hangupWaitingOrBackgroundResponse: serial %d", serial);
3056 #endif
3057
3058     if (radioService[slotId]->mRadioResponse != NULL) {
3059         RadioResponseInfo responseInfo = {};
3060         populateResponseInfo(responseInfo, serial, responseType, e);
3061         Return<void> retStatus =
3062                 radioService[slotId]->mRadioResponse->hangupWaitingOrBackgroundResponse(
3063                 responseInfo);
3064         radioService[slotId]->checkReturnStatus(retStatus);
3065     } else {
3066         RLOGE("hangupWaitingOrBackgroundResponse: radioService[%d]->mRadioResponse == NULL",
3067                 slotId);
3068     }
3069
3070     return 0;
3071 }
3072
3073 int radio::hangupForegroundResumeBackgroundResponse(int slotId, int responseType, int serial,
3074                                                     RIL_Errno e, void *response,
3075                                                     size_t responseLen) {
3076 #if VDBG
3077     RLOGD("hangupWaitingOrBackgroundResponse: serial %d", serial);
3078 #endif
3079
3080     if (radioService[slotId]->mRadioResponse != NULL) {
3081         RadioResponseInfo responseInfo = {};
3082         populateResponseInfo(responseInfo, serial, responseType, e);
3083         Return<void> retStatus =
3084                 radioService[slotId]->mRadioResponse->hangupWaitingOrBackgroundResponse(
3085                 responseInfo);
3086         radioService[slotId]->checkReturnStatus(retStatus);
3087     } else {
3088         RLOGE("hangupWaitingOrBackgroundResponse: radioService[%d]->mRadioResponse == NULL",
3089                 slotId);
3090     }
3091
3092     return 0;
3093 }
3094
3095 int radio::switchWaitingOrHoldingAndActiveResponse(int slotId, int responseType, int serial,
3096                                                    RIL_Errno e, void *response,
3097                                                    size_t responseLen) {
3098 #if VDBG
3099     RLOGD("switchWaitingOrHoldingAndActiveResponse: serial %d", serial);
3100 #endif
3101
3102     if (radioService[slotId]->mRadioResponse != NULL) {
3103         RadioResponseInfo responseInfo = {};
3104         populateResponseInfo(responseInfo, serial, responseType, e);
3105         Return<void> retStatus =
3106                 radioService[slotId]->mRadioResponse->switchWaitingOrHoldingAndActiveResponse(
3107                 responseInfo);
3108         radioService[slotId]->checkReturnStatus(retStatus);
3109     } else {
3110         RLOGE("switchWaitingOrHoldingAndActiveResponse: radioService[%d]->mRadioResponse "
3111                 "== NULL", slotId);
3112     }
3113
3114     return 0;
3115 }
3116
3117 int radio::conferenceResponse(int slotId, int responseType,
3118                              int serial, RIL_Errno e, void *response, size_t responseLen) {
3119 #if VDBG
3120     RLOGD("conferenceResponse: serial %d", serial);
3121 #endif
3122
3123     if (radioService[slotId]->mRadioResponse != NULL) {
3124         RadioResponseInfo responseInfo = {};
3125         populateResponseInfo(responseInfo, serial, responseType, e);
3126         Return<void> retStatus = radioService[slotId]->mRadioResponse->conferenceResponse(
3127                 responseInfo);
3128         radioService[slotId]->checkReturnStatus(retStatus);
3129     } else {
3130         RLOGE("conferenceResponse: radioService[%d]->mRadioResponse == NULL",
3131                 slotId);
3132     }
3133
3134     return 0;
3135 }
3136
3137 int radio::rejectCallResponse(int slotId, int responseType,
3138                              int serial, RIL_Errno e, void *response, size_t responseLen) {
3139 #if VDBG
3140     RLOGD("rejectCallResponse: serial %d", serial);
3141 #endif
3142
3143     if (radioService[slotId]->mRadioResponse != NULL) {
3144         RadioResponseInfo responseInfo = {};
3145         populateResponseInfo(responseInfo, serial, responseType, e);
3146         Return<void> retStatus = radioService[slotId]->mRadioResponse->rejectCallResponse(
3147                 responseInfo);
3148         radioService[slotId]->checkReturnStatus(retStatus);
3149     } else {
3150         RLOGE("rejectCallResponse: radioService[%d]->mRadioResponse == NULL",
3151                 slotId);
3152     }
3153
3154     return 0;
3155 }
3156
3157 int radio::getLastCallFailCauseResponse(int slotId,
3158                                        int responseType, int serial, RIL_Errno e, void *response,
3159                                        size_t responseLen) {
3160 #if VDBG
3161     RLOGD("getLastCallFailCauseResponse: serial %d", serial);
3162 #endif
3163
3164     if (radioService[slotId]->mRadioResponse != NULL) {
3165         RadioResponseInfo responseInfo = {};
3166         populateResponseInfo(responseInfo, serial, responseType, e);
3167
3168         LastCallFailCauseInfo info = {};
3169         info.vendorCause = hidl_string();
3170         if (response == NULL) {
3171             RLOGE("getCurrentCallsResponse Invalid response: NULL");
3172             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3173         } else if (responseLen == sizeof(int)) {
3174             int *pInt = (int *) response;
3175             info.causeCode = (LastCallFailCause) pInt[0];
3176         } else if (responseLen == sizeof(RIL_LastCallFailCauseInfo))  {
3177             RIL_LastCallFailCauseInfo *pFailCauseInfo = (RIL_LastCallFailCauseInfo *) response;
3178             info.causeCode = (LastCallFailCause) pFailCauseInfo->cause_code;
3179             info.vendorCause = convertCharPtrToHidlString(pFailCauseInfo->vendor_cause);
3180         } else {
3181             RLOGE("getCurrentCallsResponse Invalid response: NULL");
3182             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3183         }
3184
3185         Return<void> retStatus = radioService[slotId]->mRadioResponse->getLastCallFailCauseResponse(
3186                 responseInfo, info);
3187         radioService[slotId]->checkReturnStatus(retStatus);
3188     } else {
3189         RLOGE("getLastCallFailCauseResponse: radioService[%d]->mRadioResponse == NULL",
3190                 slotId);
3191     }
3192
3193     return 0;
3194 }
3195
3196 int radio::getSignalStrengthResponse(int slotId,
3197                                      int responseType, int serial, RIL_Errno e,
3198                                      void *response, size_t responseLen) {
3199 #if VDBG
3200     RLOGD("getSignalStrengthResponse: serial %d", serial);
3201 #endif
3202
3203     if (radioService[slotId]->mRadioResponse != NULL) {
3204         RadioResponseInfo responseInfo = {};
3205         populateResponseInfo(responseInfo, serial, responseType, e);
3206         SignalStrength signalStrength = {};
3207         if (response == NULL || responseLen != sizeof(RIL_SignalStrength_v10)) {
3208             RLOGE("getSignalStrengthResponse: Invalid response");
3209             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3210         } else {
3211             convertRilSignalStrengthToHal(response, responseLen, signalStrength);
3212         }
3213
3214         Return<void> retStatus = radioService[slotId]->mRadioResponse->getSignalStrengthResponse(
3215                 responseInfo, signalStrength);
3216         radioService[slotId]->checkReturnStatus(retStatus);
3217     } else {
3218         RLOGE("getSignalStrengthResponse: radioService[%d]->mRadioResponse == NULL",
3219                 slotId);
3220     }
3221
3222     return 0;
3223 }
3224
3225 RIL_CellInfoType getCellInfoTypeRadioTechnology(char *rat) {
3226     if (rat == NULL) {
3227         return RIL_CELL_INFO_TYPE_NONE;
3228     }
3229
3230     int radioTech = atoi(rat);
3231
3232     switch(radioTech) {
3233
3234         case RADIO_TECH_GPRS:
3235         case RADIO_TECH_EDGE:
3236         case RADIO_TECH_GSM: {
3237             return RIL_CELL_INFO_TYPE_GSM;
3238         }
3239
3240         case RADIO_TECH_UMTS:
3241         case RADIO_TECH_HSDPA:
3242         case RADIO_TECH_HSUPA:
3243         case RADIO_TECH_HSPA:
3244         case RADIO_TECH_HSPAP: {
3245             return RIL_CELL_INFO_TYPE_WCDMA;
3246         }
3247
3248         case RADIO_TECH_IS95A:
3249         case RADIO_TECH_IS95B:
3250         case RADIO_TECH_1xRTT:
3251         case RADIO_TECH_EVDO_0:
3252         case RADIO_TECH_EVDO_A:
3253         case RADIO_TECH_EVDO_B:
3254         case RADIO_TECH_EHRPD: {
3255             return RIL_CELL_INFO_TYPE_CDMA;
3256         }
3257
3258         case RADIO_TECH_LTE:
3259         case RADIO_TECH_LTE_CA: {
3260             return RIL_CELL_INFO_TYPE_LTE;
3261         }
3262
3263         case RADIO_TECH_TD_SCDMA: {
3264             return RIL_CELL_INFO_TYPE_TD_SCDMA;
3265         }
3266
3267         default: {
3268             break;
3269         }
3270     }
3271
3272     return RIL_CELL_INFO_TYPE_NONE;
3273
3274 }
3275
3276 void fillCellIdentityResponse(CellIdentity &cellIdentity, RIL_CellIdentity_v16 &rilCellIdentity) {
3277
3278     cellIdentity.cellIdentityGsm.resize(0);
3279     cellIdentity.cellIdentityWcdma.resize(0);
3280     cellIdentity.cellIdentityCdma.resize(0);
3281     cellIdentity.cellIdentityTdscdma.resize(0);
3282     cellIdentity.cellIdentityLte.resize(0);
3283     cellIdentity.cellInfoType = (CellInfoType)rilCellIdentity.cellInfoType;
3284     switch(rilCellIdentity.cellInfoType) {
3285
3286         case RIL_CELL_INFO_TYPE_GSM: {
3287             cellIdentity.cellIdentityGsm.resize(1);
3288             cellIdentity.cellIdentityGsm[0].mcc =
3289                     std::to_string(rilCellIdentity.cellIdentityGsm.mcc);
3290             cellIdentity.cellIdentityGsm[0].mnc =
3291                     std::to_string(rilCellIdentity.cellIdentityGsm.mnc);
3292             cellIdentity.cellIdentityGsm[0].lac = rilCellIdentity.cellIdentityGsm.lac;
3293             cellIdentity.cellIdentityGsm[0].cid = rilCellIdentity.cellIdentityGsm.cid;
3294             cellIdentity.cellIdentityGsm[0].arfcn = rilCellIdentity.cellIdentityGsm.arfcn;
3295             cellIdentity.cellIdentityGsm[0].bsic = rilCellIdentity.cellIdentityGsm.bsic;
3296             break;
3297         }
3298
3299         case RIL_CELL_INFO_TYPE_WCDMA: {
3300             cellIdentity.cellIdentityWcdma.resize(1);
3301             cellIdentity.cellIdentityWcdma[0].mcc =
3302                     std::to_string(rilCellIdentity.cellIdentityWcdma.mcc);
3303             cellIdentity.cellIdentityWcdma[0].mnc =
3304                     std::to_string(rilCellIdentity.cellIdentityWcdma.mnc);
3305             cellIdentity.cellIdentityWcdma[0].lac = rilCellIdentity.cellIdentityWcdma.lac;
3306             cellIdentity.cellIdentityWcdma[0].cid = rilCellIdentity.cellIdentityWcdma.cid;
3307             cellIdentity.cellIdentityWcdma[0].psc = rilCellIdentity.cellIdentityWcdma.psc;
3308             cellIdentity.cellIdentityWcdma[0].uarfcn = rilCellIdentity.cellIdentityWcdma.uarfcn;
3309             break;
3310         }
3311
3312         case RIL_CELL_INFO_TYPE_CDMA: {
3313             cellIdentity.cellIdentityCdma.resize(1);
3314             cellIdentity.cellIdentityCdma[0].networkId = rilCellIdentity.cellIdentityCdma.networkId;
3315             cellIdentity.cellIdentityCdma[0].systemId = rilCellIdentity.cellIdentityCdma.systemId;
3316             cellIdentity.cellIdentityCdma[0].baseStationId =
3317                     rilCellIdentity.cellIdentityCdma.basestationId;
3318             cellIdentity.cellIdentityCdma[0].longitude = rilCellIdentity.cellIdentityCdma.longitude;
3319             cellIdentity.cellIdentityCdma[0].latitude = rilCellIdentity.cellIdentityCdma.latitude;
3320             break;
3321         }
3322
3323         case RIL_CELL_INFO_TYPE_LTE: {
3324             cellIdentity.cellIdentityLte.resize(1);
3325             cellIdentity.cellIdentityLte[0].mcc =
3326                     std::to_string(rilCellIdentity.cellIdentityLte.mcc);
3327             cellIdentity.cellIdentityLte[0].mnc =
3328                     std::to_string(rilCellIdentity.cellIdentityLte.mnc);
3329             cellIdentity.cellIdentityLte[0].ci = rilCellIdentity.cellIdentityLte.ci;
3330             cellIdentity.cellIdentityLte[0].pci = rilCellIdentity.cellIdentityLte.pci;
3331             cellIdentity.cellIdentityLte[0].tac = rilCellIdentity.cellIdentityLte.tac;
3332             cellIdentity.cellIdentityLte[0].earfcn = rilCellIdentity.cellIdentityLte.earfcn;
3333             break;
3334         }
3335
3336         case RIL_CELL_INFO_TYPE_TD_SCDMA: {
3337             cellIdentity.cellIdentityTdscdma.resize(1);
3338             cellIdentity.cellIdentityTdscdma[0].mcc =
3339                     std::to_string(rilCellIdentity.cellIdentityTdscdma.mcc);
3340             cellIdentity.cellIdentityTdscdma[0].mnc =
3341                     std::to_string(rilCellIdentity.cellIdentityTdscdma.mnc);
3342             cellIdentity.cellIdentityTdscdma[0].lac = rilCellIdentity.cellIdentityTdscdma.lac;
3343             cellIdentity.cellIdentityTdscdma[0].cid = rilCellIdentity.cellIdentityTdscdma.cid;
3344             cellIdentity.cellIdentityTdscdma[0].cpid = rilCellIdentity.cellIdentityTdscdma.cpid;
3345             break;
3346         }
3347
3348         default: {
3349             break;
3350         }
3351     }
3352 }
3353
3354 int convertResponseStringEntryToInt(char **response, int index, int numStrings) {
3355     if ((response != NULL) &&  (numStrings > index) && (response[index] != NULL)) {
3356         return atoi(response[index]);
3357     }
3358
3359     return -1;
3360 }
3361
3362 void fillCellIdentityFromVoiceRegStateResponseString(CellIdentity &cellIdentity,
3363         int numStrings, char** response) {
3364
3365     RIL_CellIdentity_v16 rilCellIdentity;
3366     int32_t *tmp = (int32_t*)&rilCellIdentity;
3367
3368     for (size_t i = 0; i < sizeof(RIL_CellIdentity_v16)/sizeof(int32_t); i++) {
3369         tmp[i] = -1;
3370     }
3371
3372     rilCellIdentity.cellInfoType = getCellInfoTypeRadioTechnology(response[3]);
3373     switch(rilCellIdentity.cellInfoType) {
3374
3375         case RIL_CELL_INFO_TYPE_GSM: {
3376             rilCellIdentity.cellIdentityGsm.lac =
3377                     convertResponseStringEntryToInt(response, 1, numStrings);
3378             rilCellIdentity.cellIdentityGsm.cid =
3379                     convertResponseStringEntryToInt(response, 2, numStrings);
3380             break;
3381         }
3382
3383         case RIL_CELL_INFO_TYPE_WCDMA: {
3384             rilCellIdentity.cellIdentityWcdma.lac =
3385                     convertResponseStringEntryToInt(response, 1, numStrings);
3386             rilCellIdentity.cellIdentityWcdma.cid =
3387                     convertResponseStringEntryToInt(response, 2, numStrings);
3388             rilCellIdentity.cellIdentityWcdma.psc =
3389                     convertResponseStringEntryToInt(response, 14, numStrings);
3390             break;
3391         }
3392
3393         case RIL_CELL_INFO_TYPE_TD_SCDMA:{
3394             rilCellIdentity.cellIdentityTdscdma.lac =
3395                     convertResponseStringEntryToInt(response, 1, numStrings);
3396             rilCellIdentity.cellIdentityTdscdma.cid =
3397                     convertResponseStringEntryToInt(response, 2, numStrings);
3398             break;
3399         }
3400
3401         case RIL_CELL_INFO_TYPE_CDMA:{
3402             rilCellIdentity.cellIdentityCdma.basestationId =
3403                     convertResponseStringEntryToInt(response, 4, numStrings);
3404             rilCellIdentity.cellIdentityCdma.longitude =
3405                     convertResponseStringEntryToInt(response, 5, numStrings);
3406             rilCellIdentity.cellIdentityCdma.latitude =
3407                     convertResponseStringEntryToInt(response, 6, numStrings);
3408             rilCellIdentity.cellIdentityCdma.systemId =
3409                     convertResponseStringEntryToInt(response, 8, numStrings);
3410             rilCellIdentity.cellIdentityCdma.networkId =
3411                     convertResponseStringEntryToInt(response, 9, numStrings);
3412             break;
3413         }
3414
3415         case RIL_CELL_INFO_TYPE_LTE:{
3416             rilCellIdentity.cellIdentityLte.tac =
3417                     convertResponseStringEntryToInt(response, 1, numStrings);
3418             rilCellIdentity.cellIdentityLte.ci =
3419                     convertResponseStringEntryToInt(response, 2, numStrings);
3420             break;
3421         }
3422
3423         default: {
3424             break;
3425         }
3426     }
3427
3428     fillCellIdentityResponse(cellIdentity, rilCellIdentity);
3429 }
3430
3431 void fillCellIdentityFromDataRegStateResponseString(CellIdentity &cellIdentity,
3432         int numStrings, char** response) {
3433
3434     RIL_CellIdentity_v16 rilCellIdentity;
3435     int32_t *tmp = (int32_t*)&rilCellIdentity;
3436
3437     for (size_t i = 0; i < sizeof(RIL_CellIdentity_v16)/sizeof(int32_t); i++) {
3438         tmp[i] = -1;
3439     }
3440
3441     rilCellIdentity.cellInfoType = getCellInfoTypeRadioTechnology(response[3]);
3442     switch(rilCellIdentity.cellInfoType) {
3443         case RIL_CELL_INFO_TYPE_GSM: {
3444             rilCellIdentity.cellIdentityGsm.lac =
3445                     convertResponseStringEntryToInt(response, 1, numStrings);
3446             rilCellIdentity.cellIdentityGsm.cid =
3447                     convertResponseStringEntryToInt(response, 2, numStrings);
3448             break;
3449         }
3450         case RIL_CELL_INFO_TYPE_WCDMA: {
3451             rilCellIdentity.cellIdentityWcdma.lac =
3452                     convertResponseStringEntryToInt(response, 1, numStrings);
3453             rilCellIdentity.cellIdentityWcdma.cid =
3454                     convertResponseStringEntryToInt(response, 2, numStrings);
3455             break;
3456         }
3457         case RIL_CELL_INFO_TYPE_TD_SCDMA:{
3458             rilCellIdentity.cellIdentityTdscdma.lac =
3459                     convertResponseStringEntryToInt(response, 1, numStrings);
3460             rilCellIdentity.cellIdentityTdscdma.cid =
3461                     convertResponseStringEntryToInt(response, 2, numStrings);
3462             break;
3463         }
3464         case RIL_CELL_INFO_TYPE_LTE: {
3465             rilCellIdentity.cellIdentityLte.tac =
3466                     convertResponseStringEntryToInt(response, 6, numStrings);
3467             rilCellIdentity.cellIdentityLte.pci =
3468                     convertResponseStringEntryToInt(response, 7, numStrings);
3469             rilCellIdentity.cellIdentityLte.ci =
3470                     convertResponseStringEntryToInt(response, 8, numStrings);
3471             break;
3472         }
3473         default: {
3474             break;
3475         }
3476     }
3477
3478     fillCellIdentityResponse(cellIdentity, rilCellIdentity);
3479 }
3480
3481 int radio::getVoiceRegistrationStateResponse(int slotId,
3482                                             int responseType, int serial, RIL_Errno e,
3483                                             void *response, size_t responseLen) {
3484 #if VDBG
3485     RLOGD("getVoiceRegistrationStateResponse: serial %d", serial);
3486 #endif
3487
3488     if (radioService[slotId]->mRadioResponse != NULL) {
3489         RadioResponseInfo responseInfo = {};
3490         populateResponseInfo(responseInfo, serial, responseType, e);
3491
3492         VoiceRegStateResult voiceRegResponse = {};
3493         int numStrings = responseLen / sizeof(char *);
3494         if (response == NULL) {
3495                RLOGE("getVoiceRegistrationStateResponse Invalid response: NULL");
3496                if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3497         } else if (s_vendorFunctions->version <= 14) {
3498             if (numStrings != 15) {
3499                 RLOGE("getVoiceRegistrationStateResponse Invalid response: NULL");
3500                 if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3501             } else {
3502                 char **resp = (char **) response;
3503                 voiceRegResponse.regState = (RegState) ATOI_NULL_HANDLED_DEF(resp[0], 4);
3504                 voiceRegResponse.rat = ATOI_NULL_HANDLED(resp[3]);
3505                 voiceRegResponse.cssSupported = ATOI_NULL_HANDLED_DEF(resp[7], 0);
3506                 voiceRegResponse.roamingIndicator = ATOI_NULL_HANDLED(resp[10]);
3507                 voiceRegResponse.systemIsInPrl = ATOI_NULL_HANDLED_DEF(resp[11], 0);
3508                 voiceRegResponse.defaultRoamingIndicator = ATOI_NULL_HANDLED_DEF(resp[12], 0);
3509                 voiceRegResponse.reasonForDenial = ATOI_NULL_HANDLED_DEF(resp[13], 0);
3510                 fillCellIdentityFromVoiceRegStateResponseString(voiceRegResponse.cellIdentity,
3511                         numStrings, resp);
3512             }
3513         } else {
3514             RIL_VoiceRegistrationStateResponse *voiceRegState =
3515                     (RIL_VoiceRegistrationStateResponse *)response;
3516
3517             if (responseLen != sizeof(RIL_VoiceRegistrationStateResponse)) {
3518                 RLOGE("getVoiceRegistrationStateResponse Invalid response: NULL");
3519                 if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3520             } else {
3521                 voiceRegResponse.regState = (RegState) voiceRegState->regState;
3522                 voiceRegResponse.rat = voiceRegState->rat;;
3523                 voiceRegResponse.cssSupported = voiceRegState->cssSupported;
3524                 voiceRegResponse.roamingIndicator = voiceRegState->roamingIndicator;
3525                 voiceRegResponse.systemIsInPrl = voiceRegState->systemIsInPrl;
3526                 voiceRegResponse.defaultRoamingIndicator = voiceRegState->defaultRoamingIndicator;
3527                 voiceRegResponse.reasonForDenial = voiceRegState->reasonForDenial;
3528                 fillCellIdentityResponse(voiceRegResponse.cellIdentity,
3529                         voiceRegState->cellIdentity);
3530             }
3531         }
3532
3533         Return<void> retStatus =
3534                 radioService[slotId]->mRadioResponse->getVoiceRegistrationStateResponse(
3535                 responseInfo, voiceRegResponse);
3536         radioService[slotId]->checkReturnStatus(retStatus);
3537     } else {
3538         RLOGE("getVoiceRegistrationStateResponse: radioService[%d]->mRadioResponse == NULL",
3539                 slotId);
3540     }
3541
3542     return 0;
3543 }
3544
3545 int radio::getDataRegistrationStateResponse(int slotId,
3546                                            int responseType, int serial, RIL_Errno e,
3547                                            void *response, size_t responseLen) {
3548 #if VDBG
3549     RLOGD("getDataRegistrationStateResponse: serial %d", serial);
3550 #endif
3551
3552     if (radioService[slotId]->mRadioResponse != NULL) {
3553         RadioResponseInfo responseInfo = {};
3554         populateResponseInfo(responseInfo, serial, responseType, e);
3555         DataRegStateResult dataRegResponse = {};
3556         if (response == NULL) {
3557             RLOGE("getDataRegistrationStateResponse Invalid response: NULL");
3558             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3559         } else if (s_vendorFunctions->version <= 14) {
3560             int numStrings = responseLen / sizeof(char *);
3561             if ((numStrings != 6) && (numStrings != 11)) {
3562                 RLOGE("getDataRegistrationStateResponse Invalid response: NULL");
3563                 if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3564             } else {
3565                 char **resp = (char **) response;
3566                 dataRegResponse.regState = (RegState) ATOI_NULL_HANDLED_DEF(resp[0], 4);
3567                 dataRegResponse.rat =  ATOI_NULL_HANDLED_DEF(resp[3], 0);
3568                 dataRegResponse.reasonDataDenied =  ATOI_NULL_HANDLED(resp[4]);
3569                 dataRegResponse.maxDataCalls =  ATOI_NULL_HANDLED_DEF(resp[5], 1);
3570                 fillCellIdentityFromDataRegStateResponseString(dataRegResponse.cellIdentity,
3571                         numStrings, resp);
3572             }
3573         } else {
3574             RIL_DataRegistrationStateResponse *dataRegState =
3575                     (RIL_DataRegistrationStateResponse *)response;
3576
3577             if (responseLen != sizeof(RIL_DataRegistrationStateResponse)) {
3578                 RLOGE("getDataRegistrationStateResponse Invalid response: NULL");
3579                 if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3580             } else {
3581                 dataRegResponse.regState = (RegState) dataRegState->regState;
3582                 dataRegResponse.rat = dataRegState->rat;;
3583                 dataRegResponse.reasonDataDenied = dataRegState->reasonDataDenied;
3584                 dataRegResponse.maxDataCalls = dataRegState->maxDataCalls;
3585                 fillCellIdentityResponse(dataRegResponse.cellIdentity, dataRegState->cellIdentity);
3586             }
3587         }
3588
3589         Return<void> retStatus =
3590                 radioService[slotId]->mRadioResponse->getDataRegistrationStateResponse(responseInfo,
3591                 dataRegResponse);
3592         radioService[slotId]->checkReturnStatus(retStatus);
3593     } else {
3594         RLOGE("getDataRegistrationStateResponse: radioService[%d]->mRadioResponse == NULL",
3595                 slotId);
3596     }
3597
3598     return 0;
3599 }
3600
3601 int radio::getOperatorResponse(int slotId,
3602                               int responseType, int serial, RIL_Errno e, void *response,
3603                               size_t responseLen) {
3604 #if VDBG
3605     RLOGD("getOperatorResponse: serial %d", serial);
3606 #endif
3607
3608     if (radioService[slotId]->mRadioResponse != NULL) {
3609         RadioResponseInfo responseInfo = {};
3610         populateResponseInfo(responseInfo, serial, responseType, e);
3611         hidl_string longName;
3612         hidl_string shortName;
3613         hidl_string numeric;
3614         int numStrings = responseLen / sizeof(char *);
3615         if (response == NULL || numStrings != 3) {
3616             RLOGE("getOperatorResponse Invalid response: NULL");
3617             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3618
3619         } else {
3620             char **resp = (char **) response;
3621             longName = convertCharPtrToHidlString(resp[0]);
3622             shortName = convertCharPtrToHidlString(resp[1]);
3623             numeric = convertCharPtrToHidlString(resp[2]);
3624         }
3625         Return<void> retStatus = radioService[slotId]->mRadioResponse->getOperatorResponse(
3626                 responseInfo, longName, shortName, numeric);
3627         radioService[slotId]->checkReturnStatus(retStatus);
3628     } else {
3629         RLOGE("getOperatorResponse: radioService[%d]->mRadioResponse == NULL",
3630                 slotId);
3631     }
3632
3633     return 0;
3634 }
3635
3636 int radio::setRadioPowerResponse(int slotId,
3637                                 int responseType, int serial, RIL_Errno e, void *response,
3638                                 size_t responseLen) {
3639     RLOGD("setRadioPowerResponse: serial %d", serial);
3640
3641     if (radioService[slotId]->mRadioResponse != NULL) {
3642         RadioResponseInfo responseInfo = {};
3643         populateResponseInfo(responseInfo, serial, responseType, e);
3644         Return<void> retStatus = radioService[slotId]->mRadioResponse->setRadioPowerResponse(
3645                 responseInfo);
3646         radioService[slotId]->checkReturnStatus(retStatus);
3647     } else {
3648         RLOGE("setRadioPowerResponse: radioService[%d]->mRadioResponse == NULL",
3649                 slotId);
3650     }
3651
3652     return 0;
3653 }
3654
3655 int radio::sendDtmfResponse(int slotId,
3656                            int responseType, int serial, RIL_Errno e, void *response,
3657                            size_t responseLen) {
3658 #if VDBG
3659     RLOGD("sendDtmfResponse: serial %d", serial);
3660 #endif
3661
3662     if (radioService[slotId]->mRadioResponse != NULL) {
3663         RadioResponseInfo responseInfo = {};
3664         populateResponseInfo(responseInfo, serial, responseType, e);
3665         Return<void> retStatus = radioService[slotId]->mRadioResponse->sendDtmfResponse(
3666                 responseInfo);
3667         radioService[slotId]->checkReturnStatus(retStatus);
3668     } else {
3669         RLOGE("sendDtmfResponse: radioService[%d]->mRadioResponse == NULL",
3670                 slotId);
3671     }
3672
3673     return 0;
3674 }
3675
3676 SendSmsResult makeSendSmsResult(RadioResponseInfo& responseInfo, int serial, int responseType,
3677                                 RIL_Errno e, void *response, size_t responseLen) {
3678     populateResponseInfo(responseInfo, serial, responseType, e);
3679     SendSmsResult result = {};
3680
3681     if (response == NULL || responseLen != sizeof(RIL_SMS_Response)) {
3682         RLOGE("Invalid response: NULL");
3683         if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3684         result.ackPDU = hidl_string();
3685     } else {
3686         RIL_SMS_Response *resp = (RIL_SMS_Response *) response;
3687         result.messageRef = resp->messageRef;
3688         result.ackPDU = convertCharPtrToHidlString(resp->ackPDU);
3689         result.errorCode = resp->errorCode;
3690     }
3691     return result;
3692 }
3693
3694 int radio::sendSmsResponse(int slotId,
3695                           int responseType, int serial, RIL_Errno e, void *response,
3696                           size_t responseLen) {
3697 #if VDBG
3698     RLOGD("sendSmsResponse: serial %d", serial);
3699 #endif
3700
3701     if (radioService[slotId]->mRadioResponse != NULL) {
3702         RadioResponseInfo responseInfo = {};
3703         SendSmsResult result = makeSendSmsResult(responseInfo, serial, responseType, e, response,
3704                 responseLen);
3705
3706         Return<void> retStatus = radioService[slotId]->mRadioResponse->sendSmsResponse(responseInfo,
3707                 result);
3708         radioService[slotId]->checkReturnStatus(retStatus);
3709     } else {
3710         RLOGE("sendSmsResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3711     }
3712
3713     return 0;
3714 }
3715
3716 int radio::sendSMSExpectMoreResponse(int slotId,
3717                                     int responseType, int serial, RIL_Errno e, void *response,
3718                                     size_t responseLen) {
3719 #if VDBG
3720     RLOGD("sendSMSExpectMoreResponse: serial %d", serial);
3721 #endif
3722
3723     if (radioService[slotId]->mRadioResponse != NULL) {
3724         RadioResponseInfo responseInfo = {};
3725         SendSmsResult result = makeSendSmsResult(responseInfo, serial, responseType, e, response,
3726                 responseLen);
3727
3728         Return<void> retStatus = radioService[slotId]->mRadioResponse->sendSMSExpectMoreResponse(
3729                 responseInfo, result);
3730         radioService[slotId]->checkReturnStatus(retStatus);
3731     } else {
3732         RLOGE("sendSMSExpectMoreResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3733     }
3734
3735     return 0;
3736 }
3737
3738 int radio::setupDataCallResponse(int slotId,
3739                                  int responseType, int serial, RIL_Errno e, void *response,
3740                                  size_t responseLen) {
3741 #if VDBG
3742     RLOGD("setupDataCallResponse: serial %d", serial);
3743 #endif
3744
3745     if (radioService[slotId]->mRadioResponse != NULL) {
3746         RadioResponseInfo responseInfo = {};
3747         populateResponseInfo(responseInfo, serial, responseType, e);
3748
3749         SetupDataCallResult result = {};
3750         if (response == NULL || responseLen != sizeof(RIL_Data_Call_Response_v11)) {
3751             RLOGE("setupDataCallResponse: Invalid response");
3752             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3753             result.status = DataCallFailCause::ERROR_UNSPECIFIED;
3754             result.type = hidl_string();
3755             result.ifname = hidl_string();
3756             result.addresses = hidl_string();
3757             result.dnses = hidl_string();
3758             result.gateways = hidl_string();
3759             result.pcscf = hidl_string();
3760         } else {
3761             convertRilDataCallToHal((RIL_Data_Call_Response_v11 *) response, result);
3762         }
3763
3764         Return<void> retStatus = radioService[slotId]->mRadioResponse->setupDataCallResponse(
3765                 responseInfo, result);
3766         radioService[slotId]->checkReturnStatus(retStatus);
3767     } else {
3768         RLOGE("setupDataCallResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3769     }
3770
3771     return 0;
3772 }
3773
3774 IccIoResult responseIccIo(RadioResponseInfo& responseInfo, int serial, int responseType,
3775                            RIL_Errno e, void *response, size_t responseLen) {
3776     populateResponseInfo(responseInfo, serial, responseType, e);
3777     IccIoResult result = {};
3778
3779     if (response == NULL || responseLen != sizeof(RIL_SIM_IO_Response)) {
3780         RLOGE("Invalid response: NULL");
3781         if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3782         result.simResponse = hidl_string();
3783     } else {
3784         RIL_SIM_IO_Response *resp = (RIL_SIM_IO_Response *) response;
3785         result.sw1 = resp->sw1;
3786         result.sw2 = resp->sw2;
3787         result.simResponse = convertCharPtrToHidlString(resp->simResponse);
3788     }
3789     return result;
3790 }
3791
3792 int radio::iccIOForAppResponse(int slotId,
3793                       int responseType, int serial, RIL_Errno e, void *response,
3794                       size_t responseLen) {
3795 #if VDBG
3796     RLOGD("iccIOForAppResponse: serial %d", serial);
3797 #endif
3798
3799     if (radioService[slotId]->mRadioResponse != NULL) {
3800         RadioResponseInfo responseInfo = {};
3801         IccIoResult result = responseIccIo(responseInfo, serial, responseType, e, response,
3802                 responseLen);
3803
3804         Return<void> retStatus = radioService[slotId]->mRadioResponse->iccIOForAppResponse(
3805                 responseInfo, result);
3806         radioService[slotId]->checkReturnStatus(retStatus);
3807     } else {
3808         RLOGE("iccIOForAppResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3809     }
3810
3811     return 0;
3812 }
3813
3814 int radio::sendUssdResponse(int slotId,
3815                            int responseType, int serial, RIL_Errno e, void *response,
3816                            size_t responseLen) {
3817 #if VDBG
3818     RLOGD("sendUssdResponse: serial %d", serial);
3819 #endif
3820
3821     if (radioService[slotId]->mRadioResponse != NULL) {
3822         RadioResponseInfo responseInfo = {};
3823         populateResponseInfo(responseInfo, serial, responseType, e);
3824         Return<void> retStatus = radioService[slotId]->mRadioResponse->sendUssdResponse(
3825                 responseInfo);
3826         radioService[slotId]->checkReturnStatus(retStatus);
3827     } else {
3828         RLOGE("sendUssdResponse: radioService[%d]->mRadioResponse == NULL",
3829                 slotId);
3830     }
3831
3832     return 0;
3833 }
3834
3835 int radio::cancelPendingUssdResponse(int slotId,
3836                                     int responseType, int serial, RIL_Errno e, void *response,
3837                                     size_t responseLen) {
3838 #if VDBG
3839     RLOGD("cancelPendingUssdResponse: serial %d", serial);
3840 #endif
3841
3842     if (radioService[slotId]->mRadioResponse != NULL) {
3843         RadioResponseInfo responseInfo = {};
3844         populateResponseInfo(responseInfo, serial, responseType, e);
3845         Return<void> retStatus = radioService[slotId]->mRadioResponse->cancelPendingUssdResponse(
3846                 responseInfo);
3847         radioService[slotId]->checkReturnStatus(retStatus);
3848     } else {
3849         RLOGE("cancelPendingUssdResponse: radioService[%d]->mRadioResponse == NULL",
3850                 slotId);
3851     }
3852
3853     return 0;
3854 }
3855
3856 int radio::getClirResponse(int slotId,
3857                               int responseType, int serial, RIL_Errno e, void *response,
3858                               size_t responseLen) {
3859 #if VDBG
3860     RLOGD("getClirResponse: serial %d", serial);
3861 #endif
3862
3863     if (radioService[slotId]->mRadioResponse != NULL) {
3864         RadioResponseInfo responseInfo = {};
3865         populateResponseInfo(responseInfo, serial, responseType, e);
3866         int n = -1, m = -1;
3867         int numInts = responseLen / sizeof(int);
3868         if (response == NULL || numInts != 2) {
3869             RLOGE("getClirResponse Invalid response: NULL");
3870             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3871         } else {
3872             int *pInt = (int *) response;
3873             n = pInt[0];
3874             m = pInt[1];
3875         }
3876         Return<void> retStatus = radioService[slotId]->mRadioResponse->getClirResponse(responseInfo,
3877                 n, m);
3878         radioService[slotId]->checkReturnStatus(retStatus);
3879     } else {
3880         RLOGE("getClirResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3881     }
3882
3883     return 0;
3884 }
3885
3886 int radio::setClirResponse(int slotId,
3887                           int responseType, int serial, RIL_Errno e, void *response,
3888                           size_t responseLen) {
3889 #if VDBG
3890     RLOGD("setClirResponse: serial %d", serial);
3891 #endif
3892
3893     if (radioService[slotId]->mRadioResponse != NULL) {
3894         RadioResponseInfo responseInfo = {};
3895         populateResponseInfo(responseInfo, serial, responseType, e);
3896         Return<void> retStatus = radioService[slotId]->mRadioResponse->setClirResponse(
3897                 responseInfo);
3898         radioService[slotId]->checkReturnStatus(retStatus);
3899     } else {
3900         RLOGE("setClirResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3901     }
3902
3903     return 0;
3904 }
3905
3906 int radio::getCallForwardStatusResponse(int slotId,
3907                                        int responseType, int serial, RIL_Errno e,
3908                                        void *response, size_t responseLen) {
3909 #if VDBG
3910     RLOGD("getCallForwardStatusResponse: serial %d", serial);
3911 #endif
3912
3913     if (radioService[slotId]->mRadioResponse != NULL) {
3914         RadioResponseInfo responseInfo = {};
3915         populateResponseInfo(responseInfo, serial, responseType, e);
3916         hidl_vec<CallForwardInfo> callForwardInfos;
3917
3918         if (response == NULL || responseLen % sizeof(RIL_CallForwardInfo *) != 0) {
3919             RLOGE("getCallForwardStatusResponse Invalid response: NULL");
3920             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3921         } else {
3922             int num = responseLen / sizeof(RIL_CallForwardInfo *);
3923             callForwardInfos.resize(num);
3924             for (int i = 0 ; i < num; i++) {
3925                 RIL_CallForwardInfo *resp = ((RIL_CallForwardInfo **) response)[i];
3926                 callForwardInfos[i].status = (CallForwardInfoStatus) resp->status;
3927                 callForwardInfos[i].reason = resp->reason;
3928                 callForwardInfos[i].serviceClass = resp->serviceClass;
3929                 callForwardInfos[i].toa = resp->toa;
3930                 callForwardInfos[i].number = convertCharPtrToHidlString(resp->number);
3931                 callForwardInfos[i].timeSeconds = resp->timeSeconds;
3932             }
3933         }
3934
3935         Return<void> retStatus = radioService[slotId]->mRadioResponse->getCallForwardStatusResponse(
3936                 responseInfo, callForwardInfos);
3937         radioService[slotId]->checkReturnStatus(retStatus);
3938     } else {
3939         RLOGE("getCallForwardStatusResponse: radioService[%d]->mRadioResponse == NULL",
3940                 slotId);
3941     }
3942
3943     return 0;
3944 }
3945
3946 int radio::setCallForwardResponse(int slotId,
3947                                  int responseType, int serial, RIL_Errno e, void *response,
3948                                  size_t responseLen) {
3949 #if VDBG
3950     RLOGD("setCallForwardResponse: serial %d", serial);
3951 #endif
3952
3953     if (radioService[slotId]->mRadioResponse != NULL) {
3954         RadioResponseInfo responseInfo = {};
3955         populateResponseInfo(responseInfo, serial, responseType, e);
3956         Return<void> retStatus = radioService[slotId]->mRadioResponse->setCallForwardResponse(
3957                 responseInfo);
3958         radioService[slotId]->checkReturnStatus(retStatus);
3959     } else {
3960         RLOGE("setCallForwardResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3961     }
3962
3963     return 0;
3964 }
3965
3966 int radio::getCallWaitingResponse(int slotId,
3967                                  int responseType, int serial, RIL_Errno e, void *response,
3968                                  size_t responseLen) {
3969 #if VDBG
3970     RLOGD("getCallWaitingResponse: serial %d", serial);
3971 #endif
3972
3973     if (radioService[slotId]->mRadioResponse != NULL) {
3974         RadioResponseInfo responseInfo = {};
3975         populateResponseInfo(responseInfo, serial, responseType, e);
3976         bool enable = false;
3977         int serviceClass = -1;
3978         int numInts = responseLen / sizeof(int);
3979         if (response == NULL || numInts != 2) {
3980             RLOGE("getCallWaitingResponse Invalid response: NULL");
3981             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
3982         } else {
3983             int *pInt = (int *) response;
3984             enable = pInt[0] == 1 ? true : false;
3985             serviceClass = pInt[1];
3986         }
3987         Return<void> retStatus = radioService[slotId]->mRadioResponse->getCallWaitingResponse(
3988                 responseInfo, enable, serviceClass);
3989         radioService[slotId]->checkReturnStatus(retStatus);
3990     } else {
3991         RLOGE("getCallWaitingResponse: radioService[%d]->mRadioResponse == NULL", slotId);
3992     }
3993
3994     return 0;
3995 }
3996
3997 int radio::setCallWaitingResponse(int slotId,
3998                                  int responseType, int serial, RIL_Errno e, void *response,
3999                                  size_t responseLen) {
4000 #if VDBG
4001     RLOGD("setCallWaitingResponse: serial %d", serial);
4002 #endif
4003
4004     if (radioService[slotId]->mRadioResponse != NULL) {
4005         RadioResponseInfo responseInfo = {};
4006         populateResponseInfo(responseInfo, serial, responseType, e);
4007         Return<void> retStatus = radioService[slotId]->mRadioResponse->setCallWaitingResponse(
4008                 responseInfo);
4009         radioService[slotId]->checkReturnStatus(retStatus);
4010     } else {
4011         RLOGE("setCallWaitingResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4012     }
4013
4014     return 0;
4015 }
4016
4017 int radio::acknowledgeLastIncomingGsmSmsResponse(int slotId,
4018                                                 int responseType, int serial, RIL_Errno e,
4019                                                 void *response, size_t responseLen) {
4020 #if VDBG
4021     RLOGD("acknowledgeLastIncomingGsmSmsResponse: serial %d", serial);
4022 #endif
4023
4024     if (radioService[slotId]->mRadioResponse != NULL) {
4025         RadioResponseInfo responseInfo = {};
4026         populateResponseInfo(responseInfo, serial, responseType, e);
4027         Return<void> retStatus =
4028                 radioService[slotId]->mRadioResponse->acknowledgeLastIncomingGsmSmsResponse(
4029                 responseInfo);
4030         radioService[slotId]->checkReturnStatus(retStatus);
4031     } else {
4032         RLOGE("acknowledgeLastIncomingGsmSmsResponse: radioService[%d]->mRadioResponse "
4033                 "== NULL", slotId);
4034     }
4035
4036     return 0;
4037 }
4038
4039 int radio::acceptCallResponse(int slotId,
4040                              int responseType, int serial, RIL_Errno e,
4041                              void *response, size_t responseLen) {
4042 #if VDBG
4043     RLOGD("acceptCallResponse: serial %d", serial);
4044 #endif
4045
4046     if (radioService[slotId]->mRadioResponse != NULL) {
4047         RadioResponseInfo responseInfo = {};
4048         populateResponseInfo(responseInfo, serial, responseType, e);
4049         Return<void> retStatus = radioService[slotId]->mRadioResponse->acceptCallResponse(
4050                 responseInfo);
4051         radioService[slotId]->checkReturnStatus(retStatus);
4052     } else {
4053         RLOGE("acceptCallResponse: radioService[%d]->mRadioResponse == NULL",
4054                 slotId);
4055     }
4056
4057     return 0;
4058 }
4059
4060 int radio::deactivateDataCallResponse(int slotId,
4061                                                 int responseType, int serial, RIL_Errno e,
4062                                                 void *response, size_t responseLen) {
4063 #if VDBG
4064     RLOGD("deactivateDataCallResponse: serial %d", serial);
4065 #endif
4066
4067     if (radioService[slotId]->mRadioResponse != NULL) {
4068         RadioResponseInfo responseInfo = {};
4069         populateResponseInfo(responseInfo, serial, responseType, e);
4070         Return<void> retStatus = radioService[slotId]->mRadioResponse->deactivateDataCallResponse(
4071                 responseInfo);
4072         radioService[slotId]->checkReturnStatus(retStatus);
4073     } else {
4074         RLOGE("deactivateDataCallResponse: radioService[%d]->mRadioResponse == NULL",
4075                 slotId);
4076     }
4077
4078     return 0;
4079 }
4080
4081 int radio::getFacilityLockForAppResponse(int slotId,
4082                                         int responseType, int serial, RIL_Errno e,
4083                                         void *response, size_t responseLen) {
4084 #if VDBG
4085     RLOGD("getFacilityLockForAppResponse: serial %d", serial);
4086 #endif
4087
4088     if (radioService[slotId]->mRadioResponse != NULL) {
4089         RadioResponseInfo responseInfo = {};
4090         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
4091         Return<void> retStatus = radioService[slotId]->mRadioResponse->
4092                 getFacilityLockForAppResponse(responseInfo, ret);
4093         radioService[slotId]->checkReturnStatus(retStatus);
4094     } else {
4095         RLOGE("getFacilityLockForAppResponse: radioService[%d]->mRadioResponse == NULL",
4096                 slotId);
4097     }
4098
4099     return 0;
4100 }
4101
4102 int radio::setFacilityLockForAppResponse(int slotId,
4103                                       int responseType, int serial, RIL_Errno e,
4104                                       void *response, size_t responseLen) {
4105 #if VDBG
4106     RLOGD("setFacilityLockForAppResponse: serial %d", serial);
4107 #endif
4108
4109     if (radioService[slotId]->mRadioResponse != NULL) {
4110         RadioResponseInfo responseInfo = {};
4111         int ret = responseIntOrEmpty(responseInfo, serial, responseType, e, response, responseLen);
4112         Return<void> retStatus
4113                 = radioService[slotId]->mRadioResponse->setFacilityLockForAppResponse(responseInfo,
4114                 ret);
4115         radioService[slotId]->checkReturnStatus(retStatus);
4116     } else {
4117         RLOGE("setFacilityLockForAppResponse: radioService[%d]->mRadioResponse == NULL",
4118                 slotId);
4119     }
4120
4121     return 0;
4122 }
4123
4124 int radio::setBarringPasswordResponse(int slotId,
4125                              int responseType, int serial, RIL_Errno e,
4126                              void *response, size_t responseLen) {
4127 #if VDBG
4128     RLOGD("acceptCallResponse: serial %d", serial);
4129 #endif
4130
4131     if (radioService[slotId]->mRadioResponse != NULL) {
4132         RadioResponseInfo responseInfo = {};
4133         populateResponseInfo(responseInfo, serial, responseType, e);
4134         Return<void> retStatus
4135                 = radioService[slotId]->mRadioResponse->setBarringPasswordResponse(responseInfo);
4136         radioService[slotId]->checkReturnStatus(retStatus);
4137     } else {
4138         RLOGE("setBarringPasswordResponse: radioService[%d]->mRadioResponse == NULL",
4139                 slotId);
4140     }
4141
4142     return 0;
4143 }
4144
4145 int radio::getNetworkSelectionModeResponse(int slotId,
4146                                           int responseType, int serial, RIL_Errno e, void *response,
4147                                           size_t responseLen) {
4148 #if VDBG
4149     RLOGD("getNetworkSelectionModeResponse: serial %d", serial);
4150 #endif
4151
4152     if (radioService[slotId]->mRadioResponse != NULL) {
4153         RadioResponseInfo responseInfo = {};
4154         populateResponseInfo(responseInfo, serial, responseType, e);
4155         bool manual = false;
4156         int serviceClass;
4157         if (response == NULL || responseLen != sizeof(int)) {
4158             RLOGE("getNetworkSelectionModeResponse Invalid response: NULL");
4159             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4160         } else {
4161             int *pInt = (int *) response;
4162             manual = pInt[0] == 1 ? true : false;
4163         }
4164         Return<void> retStatus
4165                 = radioService[slotId]->mRadioResponse->getNetworkSelectionModeResponse(
4166                 responseInfo,
4167                 manual);
4168         radioService[slotId]->checkReturnStatus(retStatus);
4169     } else {
4170         RLOGE("getNetworkSelectionModeResponse: radioService[%d]->mRadioResponse == NULL",
4171                 slotId);
4172     }
4173
4174     return 0;
4175 }
4176
4177 int radio::setNetworkSelectionModeAutomaticResponse(int slotId, int responseType, int serial,
4178                                                     RIL_Errno e, void *response,
4179                                                     size_t responseLen) {
4180 #if VDBG
4181     RLOGD("setNetworkSelectionModeAutomaticResponse: serial %d", serial);
4182 #endif
4183
4184     if (radioService[slotId]->mRadioResponse != NULL) {
4185         RadioResponseInfo responseInfo = {};
4186         populateResponseInfo(responseInfo, serial, responseType, e);
4187         Return<void> retStatus
4188                 = radioService[slotId]->mRadioResponse->setNetworkSelectionModeAutomaticResponse(
4189                 responseInfo);
4190         radioService[slotId]->checkReturnStatus(retStatus);
4191     } else {
4192         RLOGE("setNetworkSelectionModeAutomaticResponse: radioService[%d]->mRadioResponse "
4193                 "== NULL", slotId);
4194     }
4195
4196     return 0;
4197 }
4198
4199 int radio::setNetworkSelectionModeManualResponse(int slotId,
4200                              int responseType, int serial, RIL_Errno e,
4201                              void *response, size_t responseLen) {
4202 #if VDBG
4203     RLOGD("setNetworkSelectionModeManualResponse: serial %d", serial);
4204 #endif
4205
4206     if (radioService[slotId]->mRadioResponse != NULL) {
4207         RadioResponseInfo responseInfo = {};
4208         populateResponseInfo(responseInfo, serial, responseType, e);
4209         Return<void> retStatus
4210                 = radioService[slotId]->mRadioResponse->setNetworkSelectionModeManualResponse(
4211                 responseInfo);
4212         radioService[slotId]->checkReturnStatus(retStatus);
4213     } else {
4214         RLOGE("acceptCallResponse: radioService[%d]->setNetworkSelectionModeManualResponse "
4215                 "== NULL", slotId);
4216     }
4217
4218     return 0;
4219 }
4220
4221 int convertOperatorStatusToInt(const char *str) {
4222     if (strncmp("unknown", str, 9) == 0) {
4223         return (int) OperatorStatus::UNKNOWN;
4224     } else if (strncmp("available", str, 9) == 0) {
4225         return (int) OperatorStatus::AVAILABLE;
4226     } else if (strncmp("current", str, 9) == 0) {
4227         return (int) OperatorStatus::CURRENT;
4228     } else if (strncmp("forbidden", str, 9) == 0) {
4229         return (int) OperatorStatus::FORBIDDEN;
4230     } else {
4231         return -1;
4232     }
4233 }
4234
4235 int radio::getAvailableNetworksResponse(int slotId,
4236                               int responseType, int serial, RIL_Errno e, void *response,
4237                               size_t responseLen) {
4238 #if VDBG
4239     RLOGD("getAvailableNetworksResponse: serial %d", serial);
4240 #endif
4241
4242     if (radioService[slotId]->mRadioResponse != NULL) {
4243         RadioResponseInfo responseInfo = {};
4244         populateResponseInfo(responseInfo, serial, responseType, e);
4245         hidl_vec<OperatorInfo> networks;
4246         if (response == NULL || responseLen % (4 * sizeof(char *))!= 0) {
4247             RLOGE("getAvailableNetworksResponse Invalid response: NULL");
4248             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4249         } else {
4250             char **resp = (char **) response;
4251             int numStrings = responseLen / sizeof(char *);
4252             networks.resize(numStrings/4);
4253             for (int i = 0, j = 0; i < numStrings; i = i + 4, j++) {
4254                 networks[j].alphaLong = convertCharPtrToHidlString(resp[i]);
4255                 networks[j].alphaShort = convertCharPtrToHidlString(resp[i + 1]);
4256                 networks[j].operatorNumeric = convertCharPtrToHidlString(resp[i + 2]);
4257                 int status = convertOperatorStatusToInt(resp[i + 3]);
4258                 if (status == -1) {
4259                     if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4260                 } else {
4261                     networks[j].status = (OperatorStatus) status;
4262                 }
4263             }
4264         }
4265         Return<void> retStatus
4266                 = radioService[slotId]->mRadioResponse->getAvailableNetworksResponse(responseInfo,
4267                 networks);
4268         radioService[slotId]->checkReturnStatus(retStatus);
4269     } else {
4270         RLOGE("getAvailableNetworksResponse: radioService[%d]->mRadioResponse == NULL",
4271                 slotId);
4272     }
4273
4274     return 0;
4275 }
4276
4277 int radio::startDtmfResponse(int slotId,
4278                             int responseType, int serial, RIL_Errno e,
4279                             void *response, size_t responseLen) {
4280 #if VDBG
4281     RLOGD("startDtmfResponse: serial %d", serial);
4282 #endif
4283
4284     if (radioService[slotId]->mRadioResponse != NULL) {
4285         RadioResponseInfo responseInfo = {};
4286         populateResponseInfo(responseInfo, serial, responseType, e);
4287         Return<void> retStatus
4288                 = radioService[slotId]->mRadioResponse->startDtmfResponse(responseInfo);
4289         radioService[slotId]->checkReturnStatus(retStatus);
4290     } else {
4291         RLOGE("startDtmfResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4292     }
4293
4294     return 0;
4295 }
4296
4297 int radio::stopDtmfResponse(int slotId,
4298                            int responseType, int serial, RIL_Errno e,
4299                            void *response, size_t responseLen) {
4300 #if VDBG
4301     RLOGD("stopDtmfResponse: serial %d", serial);
4302 #endif
4303
4304     if (radioService[slotId]->mRadioResponse != NULL) {
4305         RadioResponseInfo responseInfo = {};
4306         populateResponseInfo(responseInfo, serial, responseType, e);
4307         Return<void> retStatus
4308                 = radioService[slotId]->mRadioResponse->stopDtmfResponse(responseInfo);
4309         radioService[slotId]->checkReturnStatus(retStatus);
4310     } else {
4311         RLOGE("stopDtmfResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4312     }
4313
4314     return 0;
4315 }
4316
4317 int radio::getBasebandVersionResponse(int slotId,
4318                                      int responseType, int serial, RIL_Errno e,
4319                                      void *response, size_t responseLen) {
4320 #if VDBG
4321     RLOGD("getBasebandVersionResponse: serial %d", serial);
4322 #endif
4323
4324     if (radioService[slotId]->mRadioResponse != NULL) {
4325         RadioResponseInfo responseInfo = {};
4326         populateResponseInfo(responseInfo, serial, responseType, e);
4327         Return<void> retStatus
4328                 = radioService[slotId]->mRadioResponse->getBasebandVersionResponse(responseInfo,
4329                 convertCharPtrToHidlString((char *) response));
4330         radioService[slotId]->checkReturnStatus(retStatus);
4331     } else {
4332         RLOGE("getBasebandVersionResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4333     }
4334
4335     return 0;
4336 }
4337
4338 int radio::separateConnectionResponse(int slotId,
4339                                      int responseType, int serial, RIL_Errno e,
4340                                      void *response, size_t responseLen) {
4341 #if VDBG
4342     RLOGD("separateConnectionResponse: serial %d", serial);
4343 #endif
4344
4345     if (radioService[slotId]->mRadioResponse != NULL) {
4346         RadioResponseInfo responseInfo = {};
4347         populateResponseInfo(responseInfo, serial, responseType, e);
4348         Return<void> retStatus
4349                 = radioService[slotId]->mRadioResponse->separateConnectionResponse(responseInfo);
4350         radioService[slotId]->checkReturnStatus(retStatus);
4351     } else {
4352         RLOGE("separateConnectionResponse: radioService[%d]->mRadioResponse == NULL",
4353                 slotId);
4354     }
4355
4356     return 0;
4357 }
4358
4359 int radio::setMuteResponse(int slotId,
4360                           int responseType, int serial, RIL_Errno e,
4361                           void *response, size_t responseLen) {
4362 #if VDBG
4363     RLOGD("setMuteResponse: serial %d", serial);
4364 #endif
4365
4366     if (radioService[slotId]->mRadioResponse != NULL) {
4367         RadioResponseInfo responseInfo = {};
4368         populateResponseInfo(responseInfo, serial, responseType, e);
4369         Return<void> retStatus
4370                 = radioService[slotId]->mRadioResponse->setMuteResponse(responseInfo);
4371         radioService[slotId]->checkReturnStatus(retStatus);
4372     } else {
4373         RLOGE("setMuteResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4374     }
4375
4376     return 0;
4377 }
4378
4379 int radio::getMuteResponse(int slotId,
4380                           int responseType, int serial, RIL_Errno e, void *response,
4381                           size_t responseLen) {
4382 #if VDBG
4383     RLOGD("getMuteResponse: serial %d", serial);
4384 #endif
4385
4386     if (radioService[slotId]->mRadioResponse != NULL) {
4387         RadioResponseInfo responseInfo = {};
4388         populateResponseInfo(responseInfo, serial, responseType, e);
4389         bool enable = false;
4390         int serviceClass;
4391         if (response == NULL || responseLen != sizeof(int)) {
4392             RLOGE("getMuteResponse Invalid response: NULL");
4393             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4394         } else {
4395             int *pInt = (int *) response;
4396             enable = pInt[0] == 1 ? true : false;
4397         }
4398         Return<void> retStatus = radioService[slotId]->mRadioResponse->getMuteResponse(responseInfo,
4399                 enable);
4400         radioService[slotId]->checkReturnStatus(retStatus);
4401     } else {
4402         RLOGE("getMuteResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4403     }
4404
4405     return 0;
4406 }
4407
4408 int radio::getClipResponse(int slotId,
4409                           int responseType, int serial, RIL_Errno e,
4410                           void *response, size_t responseLen) {
4411 #if VDBG
4412     RLOGD("getClipResponse: serial %d", serial);
4413 #endif
4414
4415     if (radioService[slotId]->mRadioResponse != NULL) {
4416         RadioResponseInfo responseInfo = {};
4417         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
4418         Return<void> retStatus = radioService[slotId]->mRadioResponse->getClipResponse(responseInfo,
4419                 (ClipStatus) ret);
4420         radioService[slotId]->checkReturnStatus(retStatus);
4421     } else {
4422         RLOGE("getClipResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4423     }
4424
4425     return 0;
4426 }
4427
4428 int radio::getDataCallListResponse(int slotId,
4429                                    int responseType, int serial, RIL_Errno e,
4430                                    void *response, size_t responseLen) {
4431 #if VDBG
4432     RLOGD("getDataCallListResponse: serial %d", serial);
4433 #endif
4434
4435     if (radioService[slotId]->mRadioResponse != NULL) {
4436         RadioResponseInfo responseInfo = {};
4437         populateResponseInfo(responseInfo, serial, responseType, e);
4438
4439         hidl_vec<SetupDataCallResult> ret;
4440         if (response == NULL || responseLen % sizeof(RIL_Data_Call_Response_v11) != 0) {
4441             RLOGE("getDataCallListResponse: invalid response");
4442             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4443         } else {
4444             convertRilDataCallListToHal(response, responseLen, ret);
4445         }
4446
4447         Return<void> retStatus = radioService[slotId]->mRadioResponse->getDataCallListResponse(
4448                 responseInfo, ret);
4449         radioService[slotId]->checkReturnStatus(retStatus);
4450     } else {
4451         RLOGE("getDataCallListResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4452     }
4453
4454     return 0;
4455 }
4456
4457 int radio::setSuppServiceNotificationsResponse(int slotId,
4458                                               int responseType, int serial, RIL_Errno e,
4459                                               void *response, size_t responseLen) {
4460 #if VDBG
4461     RLOGD("setSuppServiceNotificationsResponse: serial %d", serial);
4462 #endif
4463
4464     if (radioService[slotId]->mRadioResponse != NULL) {
4465         RadioResponseInfo responseInfo = {};
4466         populateResponseInfo(responseInfo, serial, responseType, e);
4467         Return<void> retStatus
4468                 = radioService[slotId]->mRadioResponse->setSuppServiceNotificationsResponse(
4469                 responseInfo);
4470         radioService[slotId]->checkReturnStatus(retStatus);
4471     } else {
4472         RLOGE("setSuppServiceNotificationsResponse: radioService[%d]->mRadioResponse "
4473                 "== NULL", slotId);
4474     }
4475
4476     return 0;
4477 }
4478
4479 int radio::deleteSmsOnSimResponse(int slotId,
4480                                  int responseType, int serial, RIL_Errno e,
4481                                  void *response, size_t responseLen) {
4482 #if VDBG
4483     RLOGD("deleteSmsOnSimResponse: serial %d", serial);
4484 #endif
4485
4486     if (radioService[slotId]->mRadioResponse != NULL) {
4487         RadioResponseInfo responseInfo = {};
4488         populateResponseInfo(responseInfo, serial, responseType, e);
4489         Return<void> retStatus
4490                 = radioService[slotId]->mRadioResponse->deleteSmsOnSimResponse(responseInfo);
4491         radioService[slotId]->checkReturnStatus(retStatus);
4492     } else {
4493         RLOGE("deleteSmsOnSimResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4494     }
4495
4496     return 0;
4497 }
4498
4499 int radio::setBandModeResponse(int slotId,
4500                               int responseType, int serial, RIL_Errno e,
4501                               void *response, size_t responseLen) {
4502 #if VDBG
4503     RLOGD("setBandModeResponse: serial %d", serial);
4504 #endif
4505
4506     if (radioService[slotId]->mRadioResponse != NULL) {
4507         RadioResponseInfo responseInfo = {};
4508         populateResponseInfo(responseInfo, serial, responseType, e);
4509         Return<void> retStatus
4510                 = radioService[slotId]->mRadioResponse->setBandModeResponse(responseInfo);
4511         radioService[slotId]->checkReturnStatus(retStatus);
4512     } else {
4513         RLOGE("setBandModeResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4514     }
4515
4516     return 0;
4517 }
4518
4519 int radio::writeSmsToSimResponse(int slotId,
4520                                 int responseType, int serial, RIL_Errno e,
4521                                 void *response, size_t responseLen) {
4522 #if VDBG
4523     RLOGD("writeSmsToSimResponse: serial %d", serial);
4524 #endif
4525
4526     if (radioService[slotId]->mRadioResponse != NULL) {
4527         RadioResponseInfo responseInfo = {};
4528         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
4529         Return<void> retStatus
4530                 = radioService[slotId]->mRadioResponse->writeSmsToSimResponse(responseInfo, ret);
4531         radioService[slotId]->checkReturnStatus(retStatus);
4532     } else {
4533         RLOGE("writeSmsToSimResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4534     }
4535
4536     return 0;
4537 }
4538
4539 int radio::getAvailableBandModesResponse(int slotId,
4540                                         int responseType, int serial, RIL_Errno e, void *response,
4541                                         size_t responseLen) {
4542 #if VDBG
4543     RLOGD("getAvailableBandModesResponse: serial %d", serial);
4544 #endif
4545
4546     if (radioService[slotId]->mRadioResponse != NULL) {
4547         RadioResponseInfo responseInfo = {};
4548         populateResponseInfo(responseInfo, serial, responseType, e);
4549         hidl_vec<RadioBandMode> modes;
4550         if (response == NULL || responseLen % sizeof(int) != 0) {
4551             RLOGE("getAvailableBandModesResponse Invalid response: NULL");
4552             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4553         } else {
4554             int *pInt = (int *) response;
4555             int numInts = responseLen / sizeof(int);
4556             modes.resize(numInts);
4557             for (int i = 0; i < numInts; i++) {
4558                 modes[i] = (RadioBandMode) pInt[i];
4559             }
4560         }
4561         Return<void> retStatus
4562                 = radioService[slotId]->mRadioResponse->getAvailableBandModesResponse(responseInfo,
4563                 modes);
4564         radioService[slotId]->checkReturnStatus(retStatus);
4565     } else {
4566         RLOGE("getAvailableBandModesResponse: radioService[%d]->mRadioResponse == NULL",
4567                 slotId);
4568     }
4569
4570     return 0;
4571 }
4572
4573 int radio::sendEnvelopeResponse(int slotId,
4574                                int responseType, int serial, RIL_Errno e,
4575                                void *response, size_t responseLen) {
4576 #if VDBG
4577     RLOGD("sendEnvelopeResponse: serial %d", serial);
4578 #endif
4579
4580     if (radioService[slotId]->mRadioResponse != NULL) {
4581         RadioResponseInfo responseInfo = {};
4582         populateResponseInfo(responseInfo, serial, responseType, e);
4583         Return<void> retStatus
4584                 = radioService[slotId]->mRadioResponse->sendEnvelopeResponse(responseInfo,
4585                 convertCharPtrToHidlString((char *) response));
4586         radioService[slotId]->checkReturnStatus(retStatus);
4587     } else {
4588         RLOGE("sendEnvelopeResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4589     }
4590
4591     return 0;
4592 }
4593
4594 int radio::sendTerminalResponseToSimResponse(int slotId,
4595                                             int responseType, int serial, RIL_Errno e,
4596                                             void *response, size_t responseLen) {
4597 #if VDBG
4598     RLOGD("sendTerminalResponseToSimResponse: serial %d", serial);
4599 #endif
4600
4601     if (radioService[slotId]->mRadioResponse != NULL) {
4602         RadioResponseInfo responseInfo = {};
4603         populateResponseInfo(responseInfo, serial, responseType, e);
4604         Return<void> retStatus
4605                 = radioService[slotId]->mRadioResponse->sendTerminalResponseToSimResponse(
4606                 responseInfo);
4607         radioService[slotId]->checkReturnStatus(retStatus);
4608     } else {
4609         RLOGE("sendTerminalResponseToSimResponse: radioService[%d]->mRadioResponse == NULL",
4610                 slotId);
4611     }
4612
4613     return 0;
4614 }
4615
4616 int radio::handleStkCallSetupRequestFromSimResponse(int slotId,
4617                                                    int responseType, int serial,
4618                                                    RIL_Errno e, void *response,
4619                                                    size_t responseLen) {
4620 #if VDBG
4621     RLOGD("handleStkCallSetupRequestFromSimResponse: serial %d", serial);
4622 #endif
4623
4624     if (radioService[slotId]->mRadioResponse != NULL) {
4625         RadioResponseInfo responseInfo = {};
4626         populateResponseInfo(responseInfo, serial, responseType, e);
4627         Return<void> retStatus
4628                 = radioService[slotId]->mRadioResponse->handleStkCallSetupRequestFromSimResponse(
4629                 responseInfo);
4630         radioService[slotId]->checkReturnStatus(retStatus);
4631     } else {
4632         RLOGE("handleStkCallSetupRequestFromSimResponse: radioService[%d]->mRadioResponse "
4633                 "== NULL", slotId);
4634     }
4635
4636     return 0;
4637 }
4638
4639 int radio::explicitCallTransferResponse(int slotId,
4640                                        int responseType, int serial, RIL_Errno e,
4641                                        void *response, size_t responseLen) {
4642 #if VDBG
4643     RLOGD("explicitCallTransferResponse: serial %d", serial);
4644 #endif
4645
4646     if (radioService[slotId]->mRadioResponse != NULL) {
4647         RadioResponseInfo responseInfo = {};
4648         populateResponseInfo(responseInfo, serial, responseType, e);
4649         Return<void> retStatus
4650                 = radioService[slotId]->mRadioResponse->explicitCallTransferResponse(responseInfo);
4651         radioService[slotId]->checkReturnStatus(retStatus);
4652     } else {
4653         RLOGE("explicitCallTransferResponse: radioService[%d]->mRadioResponse == NULL",
4654                 slotId);
4655     }
4656
4657     return 0;
4658 }
4659
4660 int radio::setPreferredNetworkTypeResponse(int slotId,
4661                                  int responseType, int serial, RIL_Errno e,
4662                                  void *response, size_t responseLen) {
4663 #if VDBG
4664     RLOGD("setPreferredNetworkTypeResponse: serial %d", serial);
4665 #endif
4666
4667     if (radioService[slotId]->mRadioResponse != NULL) {
4668         RadioResponseInfo responseInfo = {};
4669         populateResponseInfo(responseInfo, serial, responseType, e);
4670         Return<void> retStatus
4671                 = radioService[slotId]->mRadioResponse->setPreferredNetworkTypeResponse(
4672                 responseInfo);
4673         radioService[slotId]->checkReturnStatus(retStatus);
4674     } else {
4675         RLOGE("setPreferredNetworkTypeResponse: radioService[%d]->mRadioResponse == NULL",
4676                 slotId);
4677     }
4678
4679     return 0;
4680 }
4681
4682
4683 int radio::getPreferredNetworkTypeResponse(int slotId,
4684                                           int responseType, int serial, RIL_Errno e,
4685                                           void *response, size_t responseLen) {
4686 #if VDBG
4687     RLOGD("getPreferredNetworkTypeResponse: serial %d", serial);
4688 #endif
4689
4690     if (radioService[slotId]->mRadioResponse != NULL) {
4691         RadioResponseInfo responseInfo = {};
4692         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
4693         Return<void> retStatus
4694                 = radioService[slotId]->mRadioResponse->getPreferredNetworkTypeResponse(
4695                 responseInfo, (PreferredNetworkType) ret);
4696         radioService[slotId]->checkReturnStatus(retStatus);
4697     } else {
4698         RLOGE("getPreferredNetworkTypeResponse: radioService[%d]->mRadioResponse == NULL",
4699                 slotId);
4700     }
4701
4702     return 0;
4703 }
4704
4705 int radio::getNeighboringCidsResponse(int slotId,
4706                                      int responseType, int serial, RIL_Errno e,
4707                                      void *response, size_t responseLen) {
4708 #if VDBG
4709     RLOGD("getNeighboringCidsResponse: serial %d", serial);
4710 #endif
4711
4712     if (radioService[slotId]->mRadioResponse != NULL) {
4713         RadioResponseInfo responseInfo = {};
4714         populateResponseInfo(responseInfo, serial, responseType, e);
4715         hidl_vec<NeighboringCell> cells;
4716
4717         if (response == NULL || responseLen % sizeof(RIL_NeighboringCell *) != 0) {
4718             RLOGE("getNeighboringCidsResponse Invalid response: NULL");
4719             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4720         } else {
4721             int num = responseLen / sizeof(RIL_NeighboringCell *);
4722             cells.resize(num);
4723             for (int i = 0 ; i < num; i++) {
4724                 RIL_NeighboringCell *resp = ((RIL_NeighboringCell **) response)[i];
4725                 cells[i].cid = convertCharPtrToHidlString(resp->cid);
4726                 cells[i].rssi = resp->rssi;
4727             }
4728         }
4729
4730         Return<void> retStatus
4731                 = radioService[slotId]->mRadioResponse->getNeighboringCidsResponse(responseInfo,
4732                 cells);
4733         radioService[slotId]->checkReturnStatus(retStatus);
4734     } else {
4735         RLOGE("getNeighboringCidsResponse: radioService[%d]->mRadioResponse == NULL",
4736                 slotId);
4737     }
4738
4739     return 0;
4740 }
4741
4742 int radio::setLocationUpdatesResponse(int slotId,
4743                                      int responseType, int serial, RIL_Errno e,
4744                                      void *response, size_t responseLen) {
4745 #if VDBG
4746     RLOGD("setLocationUpdatesResponse: serial %d", serial);
4747 #endif
4748
4749     if (radioService[slotId]->mRadioResponse != NULL) {
4750         RadioResponseInfo responseInfo = {};
4751         populateResponseInfo(responseInfo, serial, responseType, e);
4752         Return<void> retStatus
4753                 = radioService[slotId]->mRadioResponse->setLocationUpdatesResponse(responseInfo);
4754         radioService[slotId]->checkReturnStatus(retStatus);
4755     } else {
4756         RLOGE("setLocationUpdatesResponse: radioService[%d]->mRadioResponse == NULL",
4757                 slotId);
4758     }
4759
4760     return 0;
4761 }
4762
4763 int radio::setCdmaSubscriptionSourceResponse(int slotId,
4764                                  int responseType, int serial, RIL_Errno e,
4765                                  void *response, size_t responseLen) {
4766 #if VDBG
4767     RLOGD("setCdmaSubscriptionSourceResponse: serial %d", serial);
4768 #endif
4769
4770     if (radioService[slotId]->mRadioResponse != NULL) {
4771         RadioResponseInfo responseInfo = {};
4772         populateResponseInfo(responseInfo, serial, responseType, e);
4773         Return<void> retStatus
4774                 = radioService[slotId]->mRadioResponse->setCdmaSubscriptionSourceResponse(
4775                 responseInfo);
4776         radioService[slotId]->checkReturnStatus(retStatus);
4777     } else {
4778         RLOGE("setCdmaSubscriptionSourceResponse: radioService[%d]->mRadioResponse == NULL",
4779                 slotId);
4780     }
4781
4782     return 0;
4783 }
4784
4785 int radio::setCdmaRoamingPreferenceResponse(int slotId,
4786                                  int responseType, int serial, RIL_Errno e,
4787                                  void *response, size_t responseLen) {
4788 #if VDBG
4789     RLOGD("setCdmaRoamingPreferenceResponse: serial %d", serial);
4790 #endif
4791
4792     if (radioService[slotId]->mRadioResponse != NULL) {
4793         RadioResponseInfo responseInfo = {};
4794         populateResponseInfo(responseInfo, serial, responseType, e);
4795         Return<void> retStatus
4796                 = radioService[slotId]->mRadioResponse->setCdmaRoamingPreferenceResponse(
4797                 responseInfo);
4798         radioService[slotId]->checkReturnStatus(retStatus);
4799     } else {
4800         RLOGE("setCdmaRoamingPreferenceResponse: radioService[%d]->mRadioResponse == NULL",
4801                 slotId);
4802     }
4803
4804     return 0;
4805 }
4806
4807 int radio::getCdmaRoamingPreferenceResponse(int slotId,
4808                                            int responseType, int serial, RIL_Errno e,
4809                                            void *response, size_t responseLen) {
4810 #if VDBG
4811     RLOGD("getCdmaRoamingPreferenceResponse: serial %d", serial);
4812 #endif
4813
4814     if (radioService[slotId]->mRadioResponse != NULL) {
4815         RadioResponseInfo responseInfo = {};
4816         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
4817         Return<void> retStatus
4818                 = radioService[slotId]->mRadioResponse->getCdmaRoamingPreferenceResponse(
4819                 responseInfo, (CdmaRoamingType) ret);
4820         radioService[slotId]->checkReturnStatus(retStatus);
4821     } else {
4822         RLOGE("getCdmaRoamingPreferenceResponse: radioService[%d]->mRadioResponse == NULL",
4823                 slotId);
4824     }
4825
4826     return 0;
4827 }
4828
4829 int radio::setTTYModeResponse(int slotId,
4830                              int responseType, int serial, RIL_Errno e,
4831                              void *response, size_t responseLen) {
4832 #if VDBG
4833     RLOGD("setTTYModeResponse: serial %d", serial);
4834 #endif
4835
4836     if (radioService[slotId]->mRadioResponse != NULL) {
4837         RadioResponseInfo responseInfo = {};
4838         populateResponseInfo(responseInfo, serial, responseType, e);
4839         Return<void> retStatus
4840                 = radioService[slotId]->mRadioResponse->setTTYModeResponse(responseInfo);
4841         radioService[slotId]->checkReturnStatus(retStatus);
4842     } else {
4843         RLOGE("setTTYModeResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4844     }
4845
4846     return 0;
4847 }
4848
4849 int radio::getTTYModeResponse(int slotId,
4850                              int responseType, int serial, RIL_Errno e,
4851                              void *response, size_t responseLen) {
4852 #if VDBG
4853     RLOGD("getTTYModeResponse: serial %d", serial);
4854 #endif
4855
4856     if (radioService[slotId]->mRadioResponse != NULL) {
4857         RadioResponseInfo responseInfo = {};
4858         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
4859         Return<void> retStatus
4860                 = radioService[slotId]->mRadioResponse->getTTYModeResponse(responseInfo,
4861                 (TtyMode) ret);
4862         radioService[slotId]->checkReturnStatus(retStatus);
4863     } else {
4864         RLOGE("getTTYModeResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4865     }
4866
4867     return 0;
4868 }
4869
4870 int radio::setPreferredVoicePrivacyResponse(int slotId,
4871                                  int responseType, int serial, RIL_Errno e,
4872                                  void *response, size_t responseLen) {
4873 #if VDBG
4874     RLOGD("setPreferredVoicePrivacyResponse: serial %d", serial);
4875 #endif
4876
4877     if (radioService[slotId]->mRadioResponse != NULL) {
4878         RadioResponseInfo responseInfo = {};
4879         populateResponseInfo(responseInfo, serial, responseType, e);
4880         Return<void> retStatus
4881                 = radioService[slotId]->mRadioResponse->setPreferredVoicePrivacyResponse(
4882                 responseInfo);
4883         radioService[slotId]->checkReturnStatus(retStatus);
4884     } else {
4885         RLOGE("setPreferredVoicePrivacyResponse: radioService[%d]->mRadioResponse == NULL",
4886                 slotId);
4887     }
4888
4889     return 0;
4890 }
4891
4892 int radio::getPreferredVoicePrivacyResponse(int slotId,
4893                                            int responseType, int serial, RIL_Errno e,
4894                                            void *response, size_t responseLen) {
4895 #if VDBG
4896     RLOGD("getPreferredVoicePrivacyResponse: serial %d", serial);
4897 #endif
4898
4899     if (radioService[slotId]->mRadioResponse != NULL) {
4900         RadioResponseInfo responseInfo = {};
4901         populateResponseInfo(responseInfo, serial, responseType, e);
4902         bool enable = false;
4903         int numInts = responseLen / sizeof(int);
4904         if (response == NULL || numInts != 1) {
4905             RLOGE("getPreferredVoicePrivacyResponse Invalid response: NULL");
4906             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
4907         } else {
4908             int *pInt = (int *) response;
4909             enable = pInt[0] == 1 ? true : false;
4910         }
4911         Return<void> retStatus
4912                 = radioService[slotId]->mRadioResponse->getPreferredVoicePrivacyResponse(
4913                 responseInfo, enable);
4914         radioService[slotId]->checkReturnStatus(retStatus);
4915     } else {
4916         RLOGE("getPreferredVoicePrivacyResponse: radioService[%d]->mRadioResponse == NULL",
4917                 slotId);
4918     }
4919
4920     return 0;
4921 }
4922
4923 int radio::sendCDMAFeatureCodeResponse(int slotId,
4924                                  int responseType, int serial, RIL_Errno e,
4925                                  void *response, size_t responseLen) {
4926 #if VDBG
4927     RLOGD("sendCDMAFeatureCodeResponse: serial %d", serial);
4928 #endif
4929
4930     if (radioService[slotId]->mRadioResponse != NULL) {
4931         RadioResponseInfo responseInfo = {};
4932         populateResponseInfo(responseInfo, serial, responseType, e);
4933         Return<void> retStatus
4934                 = radioService[slotId]->mRadioResponse->sendCDMAFeatureCodeResponse(responseInfo);
4935         radioService[slotId]->checkReturnStatus(retStatus);
4936     } else {
4937         RLOGE("sendCDMAFeatureCodeResponse: radioService[%d]->mRadioResponse == NULL",
4938                 slotId);
4939     }
4940
4941     return 0;
4942 }
4943
4944 int radio::sendBurstDtmfResponse(int slotId,
4945                                  int responseType, int serial, RIL_Errno e,
4946                                  void *response, size_t responseLen) {
4947 #if VDBG
4948     RLOGD("sendBurstDtmfResponse: serial %d", serial);
4949 #endif
4950
4951     if (radioService[slotId]->mRadioResponse != NULL) {
4952         RadioResponseInfo responseInfo = {};
4953         populateResponseInfo(responseInfo, serial, responseType, e);
4954         Return<void> retStatus
4955                 = radioService[slotId]->mRadioResponse->sendBurstDtmfResponse(responseInfo);
4956         radioService[slotId]->checkReturnStatus(retStatus);
4957     } else {
4958         RLOGE("sendBurstDtmfResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4959     }
4960
4961     return 0;
4962 }
4963
4964 int radio::sendCdmaSmsResponse(int slotId,
4965                               int responseType, int serial, RIL_Errno e, void *response,
4966                               size_t responseLen) {
4967 #if VDBG
4968     RLOGD("sendCdmaSmsResponse: serial %d", serial);
4969 #endif
4970
4971     if (radioService[slotId]->mRadioResponse != NULL) {
4972         RadioResponseInfo responseInfo = {};
4973         SendSmsResult result = makeSendSmsResult(responseInfo, serial, responseType, e, response,
4974                 responseLen);
4975
4976         Return<void> retStatus
4977                 = radioService[slotId]->mRadioResponse->sendCdmaSmsResponse(responseInfo, result);
4978         radioService[slotId]->checkReturnStatus(retStatus);
4979     } else {
4980         RLOGE("sendCdmaSmsResponse: radioService[%d]->mRadioResponse == NULL", slotId);
4981     }
4982
4983     return 0;
4984 }
4985
4986 int radio::acknowledgeLastIncomingCdmaSmsResponse(int slotId,
4987                                                  int responseType, int serial, RIL_Errno e,
4988                                                  void *response, size_t responseLen) {
4989 #if VDBG
4990     RLOGD("acknowledgeLastIncomingCdmaSmsResponse: serial %d", serial);
4991 #endif
4992
4993     if (radioService[slotId]->mRadioResponse != NULL) {
4994         RadioResponseInfo responseInfo = {};
4995         populateResponseInfo(responseInfo, serial, responseType, e);
4996         Return<void> retStatus
4997                 = radioService[slotId]->mRadioResponse->acknowledgeLastIncomingCdmaSmsResponse(
4998                 responseInfo);
4999         radioService[slotId]->checkReturnStatus(retStatus);
5000     } else {
5001         RLOGE("acknowledgeLastIncomingCdmaSmsResponse: radioService[%d]->mRadioResponse "
5002                 "== NULL", slotId);
5003     }
5004
5005     return 0;
5006 }
5007
5008 int radio::getGsmBroadcastConfigResponse(int slotId,
5009                                         int responseType, int serial, RIL_Errno e,
5010                                         void *response, size_t responseLen) {
5011 #if VDBG
5012     RLOGD("getGsmBroadcastConfigResponse: serial %d", serial);
5013 #endif
5014
5015     if (radioService[slotId]->mRadioResponse != NULL) {
5016         RadioResponseInfo responseInfo = {};
5017         populateResponseInfo(responseInfo, serial, responseType, e);
5018         hidl_vec<GsmBroadcastSmsConfigInfo> configs;
5019
5020         if (response == NULL || responseLen % sizeof(RIL_GSM_BroadcastSmsConfigInfo *) != 0) {
5021             RLOGE("getGsmBroadcastConfigResponse Invalid response: NULL");
5022             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5023         } else {
5024             int num = responseLen / sizeof(RIL_GSM_BroadcastSmsConfigInfo *);
5025             configs.resize(num);
5026             for (int i = 0 ; i < num; i++) {
5027                 RIL_GSM_BroadcastSmsConfigInfo *resp =
5028                         ((RIL_GSM_BroadcastSmsConfigInfo **) response)[i];
5029                 configs[i].fromServiceId = resp->fromServiceId;
5030                 configs[i].toServiceId = resp->toServiceId;
5031                 configs[i].fromCodeScheme = resp->fromCodeScheme;
5032                 configs[i].toCodeScheme = resp->toCodeScheme;
5033                 configs[i].selected = resp->selected == 1 ? true : false;
5034             }
5035         }
5036
5037         Return<void> retStatus
5038                 = radioService[slotId]->mRadioResponse->getGsmBroadcastConfigResponse(responseInfo,
5039                 configs);
5040         radioService[slotId]->checkReturnStatus(retStatus);
5041     } else {
5042         RLOGE("getGsmBroadcastConfigResponse: radioService[%d]->mRadioResponse == NULL",
5043                 slotId);
5044     }
5045
5046     return 0;
5047 }
5048
5049 int radio::setGsmBroadcastConfigResponse(int slotId,
5050                                         int responseType, int serial, RIL_Errno e,
5051                                         void *response, size_t responseLen) {
5052 #if VDBG
5053     RLOGD("setGsmBroadcastConfigResponse: serial %d", serial);
5054 #endif
5055
5056     if (radioService[slotId]->mRadioResponse != NULL) {
5057         RadioResponseInfo responseInfo = {};
5058         populateResponseInfo(responseInfo, serial, responseType, e);
5059         Return<void> retStatus
5060                 = radioService[slotId]->mRadioResponse->setGsmBroadcastConfigResponse(responseInfo);
5061         radioService[slotId]->checkReturnStatus(retStatus);
5062     } else {
5063         RLOGE("setGsmBroadcastConfigResponse: radioService[%d]->mRadioResponse == NULL",
5064                 slotId);
5065     }
5066
5067     return 0;
5068 }
5069
5070 int radio::setGsmBroadcastActivationResponse(int slotId,
5071                                             int responseType, int serial, RIL_Errno e,
5072                                             void *response, size_t responseLen) {
5073 #if VDBG
5074     RLOGD("setGsmBroadcastActivationResponse: serial %d", serial);
5075 #endif
5076
5077     if (radioService[slotId]->mRadioResponse != NULL) {
5078         RadioResponseInfo responseInfo = {};
5079         populateResponseInfo(responseInfo, serial, responseType, e);
5080         Return<void> retStatus
5081                 = radioService[slotId]->mRadioResponse->setGsmBroadcastActivationResponse(
5082                 responseInfo);
5083         radioService[slotId]->checkReturnStatus(retStatus);
5084     } else {
5085         RLOGE("setGsmBroadcastActivationResponse: radioService[%d]->mRadioResponse == NULL",
5086                 slotId);
5087     }
5088
5089     return 0;
5090 }
5091
5092 int radio::getCdmaBroadcastConfigResponse(int slotId,
5093                                          int responseType, int serial, RIL_Errno e,
5094                                          void *response, size_t responseLen) {
5095 #if VDBG
5096     RLOGD("getCdmaBroadcastConfigResponse: serial %d", serial);
5097 #endif
5098
5099     if (radioService[slotId]->mRadioResponse != NULL) {
5100         RadioResponseInfo responseInfo = {};
5101         populateResponseInfo(responseInfo, serial, responseType, e);
5102         hidl_vec<CdmaBroadcastSmsConfigInfo> configs;
5103
5104         if (response == NULL || responseLen % sizeof(RIL_CDMA_BroadcastSmsConfigInfo *) != 0) {
5105             RLOGE("getCdmaBroadcastConfigResponse Invalid response: NULL");
5106             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5107         } else {
5108             int num = responseLen / sizeof(RIL_CDMA_BroadcastSmsConfigInfo *);
5109             configs.resize(num);
5110             for (int i = 0 ; i < num; i++) {
5111                 RIL_CDMA_BroadcastSmsConfigInfo *resp =
5112                         ((RIL_CDMA_BroadcastSmsConfigInfo **) response)[i];
5113                 configs[i].serviceCategory = resp->service_category;
5114                 configs[i].language = resp->language;
5115                 configs[i].selected = resp->selected == 1 ? true : false;
5116             }
5117         }
5118
5119         Return<void> retStatus
5120                 = radioService[slotId]->mRadioResponse->getCdmaBroadcastConfigResponse(responseInfo,
5121                 configs);
5122         radioService[slotId]->checkReturnStatus(retStatus);
5123     } else {
5124         RLOGE("getCdmaBroadcastConfigResponse: radioService[%d]->mRadioResponse == NULL",
5125                 slotId);
5126     }
5127
5128     return 0;
5129 }
5130
5131 int radio::setCdmaBroadcastConfigResponse(int slotId,
5132                                          int responseType, int serial, RIL_Errno e,
5133                                          void *response, size_t responseLen) {
5134 #if VDBG
5135     RLOGD("setCdmaBroadcastConfigResponse: serial %d", serial);
5136 #endif
5137
5138     if (radioService[slotId]->mRadioResponse != NULL) {
5139         RadioResponseInfo responseInfo = {};
5140         populateResponseInfo(responseInfo, serial, responseType, e);
5141         Return<void> retStatus
5142                 = radioService[slotId]->mRadioResponse->setCdmaBroadcastConfigResponse(
5143                 responseInfo);
5144         radioService[slotId]->checkReturnStatus(retStatus);
5145     } else {
5146         RLOGE("setCdmaBroadcastConfigResponse: radioService[%d]->mRadioResponse == NULL",
5147                 slotId);
5148     }
5149
5150     return 0;
5151 }
5152
5153 int radio::setCdmaBroadcastActivationResponse(int slotId,
5154                                              int responseType, int serial, RIL_Errno e,
5155                                              void *response, size_t responseLen) {
5156 #if VDBG
5157     RLOGD("setCdmaBroadcastActivationResponse: serial %d", serial);
5158 #endif
5159
5160     if (radioService[slotId]->mRadioResponse != NULL) {
5161         RadioResponseInfo responseInfo = {};
5162         populateResponseInfo(responseInfo, serial, responseType, e);
5163         Return<void> retStatus
5164                 = radioService[slotId]->mRadioResponse->setCdmaBroadcastActivationResponse(
5165                 responseInfo);
5166         radioService[slotId]->checkReturnStatus(retStatus);
5167     } else {
5168         RLOGE("setCdmaBroadcastActivationResponse: radioService[%d]->mRadioResponse == NULL",
5169                 slotId);
5170     }
5171
5172     return 0;
5173 }
5174
5175 int radio::getCDMASubscriptionResponse(int slotId,
5176                                       int responseType, int serial, RIL_Errno e, void *response,
5177                                       size_t responseLen) {
5178 #if VDBG
5179     RLOGD("getCDMASubscriptionResponse: serial %d", serial);
5180 #endif
5181
5182     if (radioService[slotId]->mRadioResponse != NULL) {
5183         RadioResponseInfo responseInfo = {};
5184         populateResponseInfo(responseInfo, serial, responseType, e);
5185
5186         int numStrings = responseLen / sizeof(char *);
5187         hidl_string emptyString;
5188         if (response == NULL || numStrings != 5) {
5189             RLOGE("getOperatorResponse Invalid response: NULL");
5190             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5191             Return<void> retStatus
5192                     = radioService[slotId]->mRadioResponse->getCDMASubscriptionResponse(
5193                     responseInfo, emptyString, emptyString, emptyString, emptyString, emptyString);
5194             radioService[slotId]->checkReturnStatus(retStatus);
5195         } else {
5196             char **resp = (char **) response;
5197             Return<void> retStatus
5198                     = radioService[slotId]->mRadioResponse->getCDMASubscriptionResponse(
5199                     responseInfo,
5200                     convertCharPtrToHidlString(resp[0]),
5201                     convertCharPtrToHidlString(resp[1]),
5202                     convertCharPtrToHidlString(resp[2]),
5203                     convertCharPtrToHidlString(resp[3]),
5204                     convertCharPtrToHidlString(resp[4]));
5205             radioService[slotId]->checkReturnStatus(retStatus);
5206         }
5207     } else {
5208         RLOGE("getCDMASubscriptionResponse: radioService[%d]->mRadioResponse == NULL",
5209                 slotId);
5210     }
5211
5212     return 0;
5213 }
5214
5215 int radio::writeSmsToRuimResponse(int slotId,
5216                                  int responseType, int serial, RIL_Errno e,
5217                                  void *response, size_t responseLen) {
5218 #if VDBG
5219     RLOGD("writeSmsToRuimResponse: serial %d", serial);
5220 #endif
5221
5222     if (radioService[slotId]->mRadioResponse != NULL) {
5223         RadioResponseInfo responseInfo = {};
5224         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
5225         Return<void> retStatus
5226                 = radioService[slotId]->mRadioResponse->writeSmsToRuimResponse(responseInfo, ret);
5227         radioService[slotId]->checkReturnStatus(retStatus);
5228     } else {
5229         RLOGE("writeSmsToRuimResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5230     }
5231
5232     return 0;
5233 }
5234
5235 int radio::deleteSmsOnRuimResponse(int slotId,
5236                                   int responseType, int serial, RIL_Errno e,
5237                                   void *response, size_t responseLen) {
5238 #if VDBG
5239     RLOGD("deleteSmsOnRuimResponse: serial %d", serial);
5240 #endif
5241
5242     if (radioService[slotId]->mRadioResponse != NULL) {
5243         RadioResponseInfo responseInfo = {};
5244         populateResponseInfo(responseInfo, serial, responseType, e);
5245         Return<void> retStatus
5246                 = radioService[slotId]->mRadioResponse->deleteSmsOnRuimResponse(responseInfo);
5247         radioService[slotId]->checkReturnStatus(retStatus);
5248     } else {
5249         RLOGE("deleteSmsOnRuimResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5250     }
5251
5252     return 0;
5253 }
5254
5255 int radio::getDeviceIdentityResponse(int slotId,
5256                                     int responseType, int serial, RIL_Errno e, void *response,
5257                                     size_t responseLen) {
5258 #if VDBG
5259     RLOGD("getDeviceIdentityResponse: serial %d", serial);
5260 #endif
5261
5262     if (radioService[slotId]->mRadioResponse != NULL) {
5263         RadioResponseInfo responseInfo = {};
5264         populateResponseInfo(responseInfo, serial, responseType, e);
5265
5266         int numStrings = responseLen / sizeof(char *);
5267         hidl_string emptyString;
5268         if (response == NULL || numStrings != 4) {
5269             RLOGE("getDeviceIdentityResponse Invalid response: NULL");
5270             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5271             Return<void> retStatus
5272                     = radioService[slotId]->mRadioResponse->getDeviceIdentityResponse(responseInfo,
5273                     emptyString, emptyString, emptyString, emptyString);
5274             radioService[slotId]->checkReturnStatus(retStatus);
5275         } else {
5276             char **resp = (char **) response;
5277             Return<void> retStatus
5278                     = radioService[slotId]->mRadioResponse->getDeviceIdentityResponse(responseInfo,
5279                     convertCharPtrToHidlString(resp[0]),
5280                     convertCharPtrToHidlString(resp[1]),
5281                     convertCharPtrToHidlString(resp[2]),
5282                     convertCharPtrToHidlString(resp[3]));
5283             radioService[slotId]->checkReturnStatus(retStatus);
5284         }
5285     } else {
5286         RLOGE("getDeviceIdentityResponse: radioService[%d]->mRadioResponse == NULL",
5287                 slotId);
5288     }
5289
5290     return 0;
5291 }
5292
5293 int radio::exitEmergencyCallbackModeResponse(int slotId,
5294                                             int responseType, int serial, RIL_Errno e,
5295                                             void *response, size_t responseLen) {
5296 #if VDBG
5297     RLOGD("exitEmergencyCallbackModeResponse: serial %d", serial);
5298 #endif
5299
5300     if (radioService[slotId]->mRadioResponse != NULL) {
5301         RadioResponseInfo responseInfo = {};
5302         populateResponseInfo(responseInfo, serial, responseType, e);
5303         Return<void> retStatus
5304                 = radioService[slotId]->mRadioResponse->exitEmergencyCallbackModeResponse(
5305                 responseInfo);
5306         radioService[slotId]->checkReturnStatus(retStatus);
5307     } else {
5308         RLOGE("exitEmergencyCallbackModeResponse: radioService[%d]->mRadioResponse == NULL",
5309                 slotId);
5310     }
5311
5312     return 0;
5313 }
5314
5315 int radio::getSmscAddressResponse(int slotId,
5316                                   int responseType, int serial, RIL_Errno e,
5317                                   void *response, size_t responseLen) {
5318 #if VDBG
5319     RLOGD("getSmscAddressResponse: serial %d", serial);
5320 #endif
5321
5322     if (radioService[slotId]->mRadioResponse != NULL) {
5323         RadioResponseInfo responseInfo = {};
5324         populateResponseInfo(responseInfo, serial, responseType, e);
5325         Return<void> retStatus
5326                 = radioService[slotId]->mRadioResponse->getSmscAddressResponse(responseInfo,
5327                 convertCharPtrToHidlString((char *) response));
5328         radioService[slotId]->checkReturnStatus(retStatus);
5329     } else {
5330         RLOGE("getSmscAddressResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5331     }
5332
5333     return 0;
5334 }
5335
5336 int radio::setSmscAddressResponse(int slotId,
5337                                              int responseType, int serial, RIL_Errno e,
5338                                              void *response, size_t responseLen) {
5339 #if VDBG
5340     RLOGD("setSmscAddressResponse: serial %d", serial);
5341 #endif
5342
5343     if (radioService[slotId]->mRadioResponse != NULL) {
5344         RadioResponseInfo responseInfo = {};
5345         populateResponseInfo(responseInfo, serial, responseType, e);
5346         Return<void> retStatus
5347                 = radioService[slotId]->mRadioResponse->setSmscAddressResponse(responseInfo);
5348         radioService[slotId]->checkReturnStatus(retStatus);
5349     } else {
5350         RLOGE("setSmscAddressResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5351     }
5352
5353     return 0;
5354 }
5355
5356 int radio::reportSmsMemoryStatusResponse(int slotId,
5357                                         int responseType, int serial, RIL_Errno e,
5358                                         void *response, size_t responseLen) {
5359 #if VDBG
5360     RLOGD("reportSmsMemoryStatusResponse: serial %d", serial);
5361 #endif
5362
5363     if (radioService[slotId]->mRadioResponse != NULL) {
5364         RadioResponseInfo responseInfo = {};
5365         populateResponseInfo(responseInfo, serial, responseType, e);
5366         Return<void> retStatus
5367                 = radioService[slotId]->mRadioResponse->reportSmsMemoryStatusResponse(responseInfo);
5368         radioService[slotId]->checkReturnStatus(retStatus);
5369     } else {
5370         RLOGE("reportSmsMemoryStatusResponse: radioService[%d]->mRadioResponse == NULL",
5371                 slotId);
5372     }
5373
5374     return 0;
5375 }
5376
5377 int radio::reportStkServiceIsRunningResponse(int slotId,
5378                                              int responseType, int serial, RIL_Errno e,
5379                                              void *response, size_t responseLen) {
5380 #if VDBG
5381     RLOGD("reportStkServiceIsRunningResponse: serial %d", serial);
5382 #endif
5383
5384     if (radioService[slotId]->mRadioResponse != NULL) {
5385         RadioResponseInfo responseInfo = {};
5386         populateResponseInfo(responseInfo, serial, responseType, e);
5387         Return<void> retStatus = radioService[slotId]->mRadioResponse->
5388                 reportStkServiceIsRunningResponse(responseInfo);
5389         radioService[slotId]->checkReturnStatus(retStatus);
5390     } else {
5391         RLOGE("reportStkServiceIsRunningResponse: radioService[%d]->mRadioResponse == NULL",
5392                 slotId);
5393     }
5394
5395     return 0;
5396 }
5397
5398 int radio::getCdmaSubscriptionSourceResponse(int slotId,
5399                                             int responseType, int serial, RIL_Errno e,
5400                                             void *response, size_t responseLen) {
5401 #if VDBG
5402     RLOGD("getCdmaSubscriptionSourceResponse: serial %d", serial);
5403 #endif
5404
5405     if (radioService[slotId]->mRadioResponse != NULL) {
5406         RadioResponseInfo responseInfo = {};
5407         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
5408         Return<void> retStatus
5409                 = radioService[slotId]->mRadioResponse->getCdmaSubscriptionSourceResponse(
5410                 responseInfo, (CdmaSubscriptionSource) ret);
5411         radioService[slotId]->checkReturnStatus(retStatus);
5412     } else {
5413         RLOGE("getCdmaSubscriptionSourceResponse: radioService[%d]->mRadioResponse == NULL",
5414                 slotId);
5415     }
5416
5417     return 0;
5418 }
5419
5420 int radio::requestIsimAuthenticationResponse(int slotId,
5421                                             int responseType, int serial, RIL_Errno e,
5422                                             void *response, size_t responseLen) {
5423 #if VDBG
5424     RLOGD("requestIsimAuthenticationResponse: serial %d", serial);
5425 #endif
5426
5427     if (radioService[slotId]->mRadioResponse != NULL) {
5428         RadioResponseInfo responseInfo = {};
5429         populateResponseInfo(responseInfo, serial, responseType, e);
5430         Return<void> retStatus
5431                 = radioService[slotId]->mRadioResponse->requestIsimAuthenticationResponse(
5432                 responseInfo,
5433                 convertCharPtrToHidlString((char *) response));
5434         radioService[slotId]->checkReturnStatus(retStatus);
5435     } else {
5436         RLOGE("requestIsimAuthenticationResponse: radioService[%d]->mRadioResponse == NULL",
5437                 slotId);
5438     }
5439
5440     return 0;
5441 }
5442
5443 int radio::acknowledgeIncomingGsmSmsWithPduResponse(int slotId,
5444                                                    int responseType,
5445                                                    int serial, RIL_Errno e, void *response,
5446                                                    size_t responseLen) {
5447 #if VDBG
5448     RLOGD("acknowledgeIncomingGsmSmsWithPduResponse: serial %d", serial);
5449 #endif
5450
5451     if (radioService[slotId]->mRadioResponse != NULL) {
5452         RadioResponseInfo responseInfo = {};
5453         populateResponseInfo(responseInfo, serial, responseType, e);
5454         Return<void> retStatus
5455                 = radioService[slotId]->mRadioResponse->acknowledgeIncomingGsmSmsWithPduResponse(
5456                 responseInfo);
5457         radioService[slotId]->checkReturnStatus(retStatus);
5458     } else {
5459         RLOGE("acknowledgeIncomingGsmSmsWithPduResponse: radioService[%d]->mRadioResponse "
5460                 "== NULL", slotId);
5461     }
5462
5463     return 0;
5464 }
5465
5466 int radio::sendEnvelopeWithStatusResponse(int slotId,
5467                                          int responseType, int serial, RIL_Errno e, void *response,
5468                                          size_t responseLen) {
5469 #if VDBG
5470     RLOGD("sendEnvelopeWithStatusResponse: serial %d", serial);
5471 #endif
5472
5473     if (radioService[slotId]->mRadioResponse != NULL) {
5474         RadioResponseInfo responseInfo = {};
5475         IccIoResult result = responseIccIo(responseInfo, serial, responseType, e,
5476                 response, responseLen);
5477
5478         Return<void> retStatus
5479                 = radioService[slotId]->mRadioResponse->sendEnvelopeWithStatusResponse(responseInfo,
5480                 result);
5481         radioService[slotId]->checkReturnStatus(retStatus);
5482     } else {
5483         RLOGE("sendEnvelopeWithStatusResponse: radioService[%d]->mRadioResponse == NULL",
5484                 slotId);
5485     }
5486
5487     return 0;
5488 }
5489
5490 int radio::getVoiceRadioTechnologyResponse(int slotId,
5491                                           int responseType, int serial, RIL_Errno e,
5492                                           void *response, size_t responseLen) {
5493 #if VDBG
5494     RLOGD("getVoiceRadioTechnologyResponse: serial %d", serial);
5495 #endif
5496
5497     if (radioService[slotId]->mRadioResponse != NULL) {
5498         RadioResponseInfo responseInfo = {};
5499         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
5500         Return<void> retStatus
5501                 = radioService[slotId]->mRadioResponse->getVoiceRadioTechnologyResponse(
5502                 responseInfo, (RadioTechnology) ret);
5503         radioService[slotId]->checkReturnStatus(retStatus);
5504     } else {
5505         RLOGE("getVoiceRadioTechnologyResponse: radioService[%d]->mRadioResponse == NULL",
5506                 slotId);
5507     }
5508
5509     return 0;
5510 }
5511
5512 int radio::getCellInfoListResponse(int slotId,
5513                                    int responseType,
5514                                    int serial, RIL_Errno e, void *response,
5515                                    size_t responseLen) {
5516 #if VDBG
5517     RLOGD("getCellInfoListResponse: serial %d", serial);
5518 #endif
5519
5520     if (radioService[slotId]->mRadioResponse != NULL) {
5521         RadioResponseInfo responseInfo = {};
5522         populateResponseInfo(responseInfo, serial, responseType, e);
5523
5524         hidl_vec<CellInfo> ret;
5525         if (response == NULL || responseLen % sizeof(RIL_CellInfo_v12) != 0) {
5526             RLOGE("getCellInfoListResponse: Invalid response");
5527             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5528         } else {
5529             convertRilCellInfoListToHal(response, responseLen, ret);
5530         }
5531
5532         Return<void> retStatus = radioService[slotId]->mRadioResponse->getCellInfoListResponse(
5533                 responseInfo, ret);
5534         radioService[slotId]->checkReturnStatus(retStatus);
5535     } else {
5536         RLOGE("getCellInfoListResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5537     }
5538
5539     return 0;
5540 }
5541
5542 int radio::setCellInfoListRateResponse(int slotId,
5543                                        int responseType,
5544                                        int serial, RIL_Errno e, void *response,
5545                                        size_t responseLen) {
5546 #if VDBG
5547     RLOGD("setCellInfoListRateResponse: serial %d", serial);
5548 #endif
5549
5550     if (radioService[slotId]->mRadioResponse != NULL) {
5551         RadioResponseInfo responseInfo = {};
5552         populateResponseInfo(responseInfo, serial, responseType, e);
5553         Return<void> retStatus
5554                 = radioService[slotId]->mRadioResponse->setCellInfoListRateResponse(responseInfo);
5555         radioService[slotId]->checkReturnStatus(retStatus);
5556     } else {
5557         RLOGE("setCellInfoListRateResponse: radioService[%d]->mRadioResponse == NULL",
5558                 slotId);
5559     }
5560
5561     return 0;
5562 }
5563
5564 int radio::setInitialAttachApnResponse(int slotId,
5565                                        int responseType, int serial, RIL_Errno e,
5566                                        void *response, size_t responseLen) {
5567 #if VDBG
5568     RLOGD("setInitialAttachApnResponse: serial %d", serial);
5569 #endif
5570
5571     if (radioService[slotId]->mRadioResponse != NULL) {
5572         RadioResponseInfo responseInfo = {};
5573         populateResponseInfo(responseInfo, serial, responseType, e);
5574         Return<void> retStatus
5575                 = radioService[slotId]->mRadioResponse->setInitialAttachApnResponse(responseInfo);
5576         radioService[slotId]->checkReturnStatus(retStatus);
5577     } else {
5578         RLOGE("setInitialAttachApnResponse: radioService[%d]->mRadioResponse == NULL",
5579                 slotId);
5580     }
5581
5582     return 0;
5583 }
5584
5585 int radio::getImsRegistrationStateResponse(int slotId,
5586                                            int responseType, int serial, RIL_Errno e,
5587                                            void *response, size_t responseLen) {
5588 #if VDBG
5589     RLOGD("getImsRegistrationStateResponse: serial %d", serial);
5590 #endif
5591
5592     if (radioService[slotId]->mRadioResponse != NULL) {
5593         RadioResponseInfo responseInfo = {};
5594         populateResponseInfo(responseInfo, serial, responseType, e);
5595         bool isRegistered = false;
5596         int ratFamily = 0;
5597         int numInts = responseLen / sizeof(int);
5598         if (response == NULL || numInts != 2) {
5599             RLOGE("getImsRegistrationStateResponse Invalid response: NULL");
5600             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5601         } else {
5602             int *pInt = (int *) response;
5603             isRegistered = pInt[0] == 1 ? true : false;
5604             ratFamily = pInt[1];
5605         }
5606         Return<void> retStatus
5607                 = radioService[slotId]->mRadioResponse->getImsRegistrationStateResponse(
5608                 responseInfo, isRegistered, (RadioTechnologyFamily) ratFamily);
5609         radioService[slotId]->checkReturnStatus(retStatus);
5610     } else {
5611         RLOGE("getImsRegistrationStateResponse: radioService[%d]->mRadioResponse == NULL",
5612                 slotId);
5613     }
5614
5615     return 0;
5616 }
5617
5618 int radio::sendImsSmsResponse(int slotId,
5619                               int responseType, int serial, RIL_Errno e, void *response,
5620                               size_t responseLen) {
5621 #if VDBG
5622     RLOGD("sendImsSmsResponse: serial %d", serial);
5623 #endif
5624
5625     if (radioService[slotId]->mRadioResponse != NULL) {
5626         RadioResponseInfo responseInfo = {};
5627         SendSmsResult result = makeSendSmsResult(responseInfo, serial, responseType, e, response,
5628                 responseLen);
5629
5630         Return<void> retStatus
5631                 = radioService[slotId]->mRadioResponse->sendImsSmsResponse(responseInfo, result);
5632         radioService[slotId]->checkReturnStatus(retStatus);
5633     } else {
5634         RLOGE("sendSmsResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5635     }
5636
5637     return 0;
5638 }
5639
5640 int radio::iccTransmitApduBasicChannelResponse(int slotId,
5641                                                int responseType, int serial, RIL_Errno e,
5642                                                void *response, size_t responseLen) {
5643 #if VDBG
5644     RLOGD("iccTransmitApduBasicChannelResponse: serial %d", serial);
5645 #endif
5646
5647     if (radioService[slotId]->mRadioResponse != NULL) {
5648         RadioResponseInfo responseInfo = {};
5649         IccIoResult result = responseIccIo(responseInfo, serial, responseType, e, response,
5650                 responseLen);
5651
5652         Return<void> retStatus
5653                 = radioService[slotId]->mRadioResponse->iccTransmitApduBasicChannelResponse(
5654                 responseInfo, result);
5655         radioService[slotId]->checkReturnStatus(retStatus);
5656     } else {
5657         RLOGE("iccTransmitApduBasicChannelResponse: radioService[%d]->mRadioResponse "
5658                 "== NULL", slotId);
5659     }
5660
5661     return 0;
5662 }
5663
5664 int radio::iccOpenLogicalChannelResponse(int slotId,
5665                                          int responseType, int serial, RIL_Errno e, void *response,
5666                                          size_t responseLen) {
5667 #if VDBG
5668     RLOGD("iccOpenLogicalChannelResponse: serial %d", serial);
5669 #endif
5670
5671     if (radioService[slotId]->mRadioResponse != NULL) {
5672         RadioResponseInfo responseInfo = {};
5673         populateResponseInfo(responseInfo, serial, responseType, e);
5674         int channelId = -1;
5675         hidl_vec<int8_t> selectResponse;
5676         int numInts = responseLen / sizeof(int);
5677         if (response == NULL || responseLen % sizeof(int) != 0) {
5678             RLOGE("iccOpenLogicalChannelResponse Invalid response: NULL");
5679             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5680         } else {
5681             int *pInt = (int *) response;
5682             channelId = pInt[0];
5683             selectResponse.resize(numInts - 1);
5684             for (int i = 1; i < numInts; i++) {
5685                 selectResponse[i - 1] = (int8_t) pInt[i];
5686             }
5687         }
5688         Return<void> retStatus
5689                 = radioService[slotId]->mRadioResponse->iccOpenLogicalChannelResponse(responseInfo,
5690                 channelId, selectResponse);
5691         radioService[slotId]->checkReturnStatus(retStatus);
5692     } else {
5693         RLOGE("iccOpenLogicalChannelResponse: radioService[%d]->mRadioResponse == NULL",
5694                 slotId);
5695     }
5696
5697     return 0;
5698 }
5699
5700 int radio::iccCloseLogicalChannelResponse(int slotId,
5701                                           int responseType, int serial, RIL_Errno e,
5702                                           void *response, size_t responseLen) {
5703 #if VDBG
5704     RLOGD("iccCloseLogicalChannelResponse: serial %d", serial);
5705 #endif
5706
5707     if (radioService[slotId]->mRadioResponse != NULL) {
5708         RadioResponseInfo responseInfo = {};
5709         populateResponseInfo(responseInfo, serial, responseType, e);
5710         Return<void> retStatus
5711                 = radioService[slotId]->mRadioResponse->iccCloseLogicalChannelResponse(
5712                 responseInfo);
5713         radioService[slotId]->checkReturnStatus(retStatus);
5714     } else {
5715         RLOGE("iccCloseLogicalChannelResponse: radioService[%d]->mRadioResponse == NULL",
5716                 slotId);
5717     }
5718
5719     return 0;
5720 }
5721
5722 int radio::iccTransmitApduLogicalChannelResponse(int slotId,
5723                                                  int responseType, int serial, RIL_Errno e,
5724                                                  void *response, size_t responseLen) {
5725 #if VDBG
5726     RLOGD("iccTransmitApduLogicalChannelResponse: serial %d", serial);
5727 #endif
5728
5729     if (radioService[slotId]->mRadioResponse != NULL) {
5730         RadioResponseInfo responseInfo = {};
5731         IccIoResult result = responseIccIo(responseInfo, serial, responseType, e, response,
5732                 responseLen);
5733
5734         Return<void> retStatus
5735                 = radioService[slotId]->mRadioResponse->iccTransmitApduLogicalChannelResponse(
5736                 responseInfo, result);
5737         radioService[slotId]->checkReturnStatus(retStatus);
5738     } else {
5739         RLOGE("iccTransmitApduLogicalChannelResponse: radioService[%d]->mRadioResponse "
5740                 "== NULL", slotId);
5741     }
5742
5743     return 0;
5744 }
5745
5746 int radio::nvReadItemResponse(int slotId,
5747                               int responseType, int serial, RIL_Errno e,
5748                               void *response, size_t responseLen) {
5749 #if VDBG
5750     RLOGD("nvReadItemResponse: serial %d", serial);
5751 #endif
5752
5753     if (radioService[slotId]->mRadioResponse != NULL) {
5754         RadioResponseInfo responseInfo = {};
5755         populateResponseInfo(responseInfo, serial, responseType, e);
5756         Return<void> retStatus = radioService[slotId]->mRadioResponse->nvReadItemResponse(
5757                 responseInfo,
5758                 convertCharPtrToHidlString((char *) response));
5759         radioService[slotId]->checkReturnStatus(retStatus);
5760     } else {
5761         RLOGE("nvReadItemResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5762     }
5763
5764     return 0;
5765 }
5766
5767 int radio::nvWriteItemResponse(int slotId,
5768                                int responseType, int serial, RIL_Errno e,
5769                                void *response, size_t responseLen) {
5770 #if VDBG
5771     RLOGD("nvWriteItemResponse: serial %d", serial);
5772 #endif
5773
5774     if (radioService[slotId]->mRadioResponse != NULL) {
5775         RadioResponseInfo responseInfo = {};
5776         populateResponseInfo(responseInfo, serial, responseType, e);
5777         Return<void> retStatus
5778                 = radioService[slotId]->mRadioResponse->nvWriteItemResponse(responseInfo);
5779         radioService[slotId]->checkReturnStatus(retStatus);
5780     } else {
5781         RLOGE("nvWriteItemResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5782     }
5783
5784     return 0;
5785 }
5786
5787 int radio::nvWriteCdmaPrlResponse(int slotId,
5788                                   int responseType, int serial, RIL_Errno e,
5789                                   void *response, size_t responseLen) {
5790 #if VDBG
5791     RLOGD("nvWriteCdmaPrlResponse: serial %d", serial);
5792 #endif
5793
5794     if (radioService[slotId]->mRadioResponse != NULL) {
5795         RadioResponseInfo responseInfo = {};
5796         populateResponseInfo(responseInfo, serial, responseType, e);
5797         Return<void> retStatus
5798                 = radioService[slotId]->mRadioResponse->nvWriteCdmaPrlResponse(responseInfo);
5799         radioService[slotId]->checkReturnStatus(retStatus);
5800     } else {
5801         RLOGE("nvWriteCdmaPrlResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5802     }
5803
5804     return 0;
5805 }
5806
5807 int radio::nvResetConfigResponse(int slotId,
5808                                  int responseType, int serial, RIL_Errno e,
5809                                  void *response, size_t responseLen) {
5810 #if VDBG
5811     RLOGD("nvResetConfigResponse: serial %d", serial);
5812 #endif
5813
5814     if (radioService[slotId]->mRadioResponse != NULL) {
5815         RadioResponseInfo responseInfo = {};
5816         populateResponseInfo(responseInfo, serial, responseType, e);
5817         Return<void> retStatus
5818                 = radioService[slotId]->mRadioResponse->nvResetConfigResponse(responseInfo);
5819         radioService[slotId]->checkReturnStatus(retStatus);
5820     } else {
5821         RLOGE("nvResetConfigResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5822     }
5823
5824     return 0;
5825 }
5826
5827 int radio::setUiccSubscriptionResponse(int slotId,
5828                                        int responseType, int serial, RIL_Errno e,
5829                                        void *response, size_t responseLen) {
5830 #if VDBG
5831     RLOGD("setUiccSubscriptionResponse: serial %d", serial);
5832 #endif
5833
5834     if (radioService[slotId]->mRadioResponse != NULL) {
5835         RadioResponseInfo responseInfo = {};
5836         populateResponseInfo(responseInfo, serial, responseType, e);
5837         Return<void> retStatus
5838                 = radioService[slotId]->mRadioResponse->setUiccSubscriptionResponse(responseInfo);
5839         radioService[slotId]->checkReturnStatus(retStatus);
5840     } else {
5841         RLOGE("setUiccSubscriptionResponse: radioService[%d]->mRadioResponse == NULL",
5842                 slotId);
5843     }
5844
5845     return 0;
5846 }
5847
5848 int radio::setDataAllowedResponse(int slotId,
5849                                   int responseType, int serial, RIL_Errno e,
5850                                   void *response, size_t responseLen) {
5851 #if VDBG
5852     RLOGD("setDataAllowedResponse: serial %d", serial);
5853 #endif
5854
5855     if (radioService[slotId]->mRadioResponse != NULL) {
5856         RadioResponseInfo responseInfo = {};
5857         populateResponseInfo(responseInfo, serial, responseType, e);
5858         Return<void> retStatus
5859                 = radioService[slotId]->mRadioResponse->setDataAllowedResponse(responseInfo);
5860         radioService[slotId]->checkReturnStatus(retStatus);
5861     } else {
5862         RLOGE("setDataAllowedResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5863     }
5864
5865     return 0;
5866 }
5867
5868 int radio::getHardwareConfigResponse(int slotId,
5869                                      int responseType, int serial, RIL_Errno e,
5870                                      void *response, size_t responseLen) {
5871 #if VDBG
5872     RLOGD("getHardwareConfigResponse: serial %d", serial);
5873 #endif
5874
5875     if (radioService[slotId]->mRadioResponse != NULL) {
5876         RadioResponseInfo responseInfo = {};
5877         populateResponseInfo(responseInfo, serial, responseType, e);
5878
5879         hidl_vec<HardwareConfig> result;
5880         if (response == NULL || responseLen % sizeof(RIL_HardwareConfig) != 0) {
5881             RLOGE("hardwareConfigChangedInd: invalid response");
5882             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5883         } else {
5884             convertRilHardwareConfigListToHal(response, responseLen, result);
5885         }
5886
5887         Return<void> retStatus = radioService[slotId]->mRadioResponse->getHardwareConfigResponse(
5888                 responseInfo, result);
5889         radioService[slotId]->checkReturnStatus(retStatus);
5890     } else {
5891         RLOGE("getHardwareConfigResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5892     }
5893
5894     return 0;
5895 }
5896
5897 int radio::requestIccSimAuthenticationResponse(int slotId,
5898                                                int responseType, int serial, RIL_Errno e,
5899                                                void *response, size_t responseLen) {
5900 #if VDBG
5901     RLOGD("requestIccSimAuthenticationResponse: serial %d", serial);
5902 #endif
5903
5904     if (radioService[slotId]->mRadioResponse != NULL) {
5905         RadioResponseInfo responseInfo = {};
5906         IccIoResult result = responseIccIo(responseInfo, serial, responseType, e, response,
5907                 responseLen);
5908
5909         Return<void> retStatus
5910                 = radioService[slotId]->mRadioResponse->requestIccSimAuthenticationResponse(
5911                 responseInfo, result);
5912         radioService[slotId]->checkReturnStatus(retStatus);
5913     } else {
5914         RLOGE("requestIccSimAuthenticationResponse: radioService[%d]->mRadioResponse "
5915                 "== NULL", slotId);
5916     }
5917
5918     return 0;
5919 }
5920
5921 int radio::setDataProfileResponse(int slotId,
5922                                   int responseType, int serial, RIL_Errno e,
5923                                   void *response, size_t responseLen) {
5924 #if VDBG
5925     RLOGD("setDataProfileResponse: serial %d", serial);
5926 #endif
5927
5928     if (radioService[slotId]->mRadioResponse != NULL) {
5929         RadioResponseInfo responseInfo = {};
5930         populateResponseInfo(responseInfo, serial, responseType, e);
5931         Return<void> retStatus
5932                 = radioService[slotId]->mRadioResponse->setDataProfileResponse(responseInfo);
5933         radioService[slotId]->checkReturnStatus(retStatus);
5934     } else {
5935         RLOGE("setDataProfileResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5936     }
5937
5938     return 0;
5939 }
5940
5941 int radio::requestShutdownResponse(int slotId,
5942                                   int responseType, int serial, RIL_Errno e,
5943                                   void *response, size_t responseLen) {
5944 #if VDBG
5945     RLOGD("requestShutdownResponse: serial %d", serial);
5946 #endif
5947
5948     if (radioService[slotId]->mRadioResponse != NULL) {
5949         RadioResponseInfo responseInfo = {};
5950         populateResponseInfo(responseInfo, serial, responseType, e);
5951         Return<void> retStatus
5952                 = radioService[slotId]->mRadioResponse->requestShutdownResponse(responseInfo);
5953         radioService[slotId]->checkReturnStatus(retStatus);
5954     } else {
5955         RLOGE("requestShutdownResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5956     }
5957
5958     return 0;
5959 }
5960
5961 void responseRadioCapability(RadioResponseInfo& responseInfo, int serial,
5962         int responseType, RIL_Errno e, void *response, size_t responseLen, RadioCapability& rc) {
5963     populateResponseInfo(responseInfo, serial, responseType, e);
5964
5965     if (response == NULL || responseLen != sizeof(RIL_RadioCapability)) {
5966         RLOGE("responseRadioCapability: Invalid response");
5967         if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
5968         rc.logicalModemUuid = hidl_string();
5969     } else {
5970         convertRilRadioCapabilityToHal(response, responseLen, rc);
5971     }
5972 }
5973
5974 int radio::getRadioCapabilityResponse(int slotId,
5975                                      int responseType, int serial, RIL_Errno e,
5976                                      void *response, size_t responseLen) {
5977 #if VDBG
5978     RLOGD("getRadioCapabilityResponse: serial %d", serial);
5979 #endif
5980
5981     if (radioService[slotId]->mRadioResponse != NULL) {
5982         RadioResponseInfo responseInfo = {};
5983         RadioCapability result = {};
5984         responseRadioCapability(responseInfo, serial, responseType, e, response, responseLen,
5985                 result);
5986         Return<void> retStatus = radioService[slotId]->mRadioResponse->getRadioCapabilityResponse(
5987                 responseInfo, result);
5988         radioService[slotId]->checkReturnStatus(retStatus);
5989     } else {
5990         RLOGE("getRadioCapabilityResponse: radioService[%d]->mRadioResponse == NULL", slotId);
5991     }
5992
5993     return 0;
5994 }
5995
5996 int radio::setRadioCapabilityResponse(int slotId,
5997                                      int responseType, int serial, RIL_Errno e,
5998                                      void *response, size_t responseLen) {
5999 #if VDBG
6000     RLOGD("setRadioCapabilityResponse: serial %d", serial);
6001 #endif
6002
6003     if (radioService[slotId]->mRadioResponse != NULL) {
6004         RadioResponseInfo responseInfo = {};
6005         RadioCapability result = {};
6006         responseRadioCapability(responseInfo, serial, responseType, e, response, responseLen,
6007                 result);
6008         Return<void> retStatus = radioService[slotId]->mRadioResponse->setRadioCapabilityResponse(
6009                 responseInfo, result);
6010         radioService[slotId]->checkReturnStatus(retStatus);
6011     } else {
6012         RLOGE("setRadioCapabilityResponse: radioService[%d]->mRadioResponse == NULL", slotId);
6013     }
6014
6015     return 0;
6016 }
6017
6018 LceStatusInfo responseLceStatusInfo(RadioResponseInfo& responseInfo, int serial, int responseType,
6019                                     RIL_Errno e, void *response, size_t responseLen) {
6020     populateResponseInfo(responseInfo, serial, responseType, e);
6021     LceStatusInfo result = {};
6022
6023     if (response == NULL || responseLen != sizeof(RIL_LceStatusInfo)) {
6024         RLOGE("Invalid response: NULL");
6025         if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
6026     } else {
6027         RIL_LceStatusInfo *resp = (RIL_LceStatusInfo *) response;
6028         result.lceStatus = (LceStatus) resp->lce_status;
6029         result.actualIntervalMs = (uint8_t) resp->actual_interval_ms;
6030     }
6031     return result;
6032 }
6033
6034 int radio::startLceServiceResponse(int slotId,
6035                                    int responseType, int serial, RIL_Errno e,
6036                                    void *response, size_t responseLen) {
6037 #if VDBG
6038     RLOGD("startLceServiceResponse: serial %d", serial);
6039 #endif
6040
6041     if (radioService[slotId]->mRadioResponse != NULL) {
6042         RadioResponseInfo responseInfo = {};
6043         LceStatusInfo result = responseLceStatusInfo(responseInfo, serial, responseType, e,
6044                 response, responseLen);
6045
6046         Return<void> retStatus
6047                 = radioService[slotId]->mRadioResponse->startLceServiceResponse(responseInfo,
6048                 result);
6049         radioService[slotId]->checkReturnStatus(retStatus);
6050     } else {
6051         RLOGE("startLceServiceResponse: radioService[%d]->mRadioResponse == NULL", slotId);
6052     }
6053
6054     return 0;
6055 }
6056
6057 int radio::stopLceServiceResponse(int slotId,
6058                                   int responseType, int serial, RIL_Errno e,
6059                                   void *response, size_t responseLen) {
6060 #if VDBG
6061     RLOGD("stopLceServiceResponse: serial %d", serial);
6062 #endif
6063
6064     if (radioService[slotId]->mRadioResponse != NULL) {
6065         RadioResponseInfo responseInfo = {};
6066         LceStatusInfo result = responseLceStatusInfo(responseInfo, serial, responseType, e,
6067                 response, responseLen);
6068
6069         Return<void> retStatus
6070                 = radioService[slotId]->mRadioResponse->stopLceServiceResponse(responseInfo,
6071                 result);
6072         radioService[slotId]->checkReturnStatus(retStatus);
6073     } else {
6074         RLOGE("stopLceServiceResponse: radioService[%d]->mRadioResponse == NULL", slotId);
6075     }
6076
6077     return 0;
6078 }
6079
6080 int radio::pullLceDataResponse(int slotId,
6081                                int responseType, int serial, RIL_Errno e,
6082                                void *response, size_t responseLen) {
6083 #if VDBG
6084     RLOGD("pullLceDataResponse: serial %d", serial);
6085 #endif
6086
6087     if (radioService[slotId]->mRadioResponse != NULL) {
6088         RadioResponseInfo responseInfo = {};
6089         populateResponseInfo(responseInfo, serial, responseType, e);
6090
6091         LceDataInfo result = {};
6092         if (response == NULL || responseLen != sizeof(RIL_LceDataInfo)) {
6093             RLOGE("pullLceDataResponse: Invalid response");
6094             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
6095         } else {
6096             convertRilLceDataInfoToHal(response, responseLen, result);
6097         }
6098
6099         Return<void> retStatus = radioService[slotId]->mRadioResponse->pullLceDataResponse(
6100                 responseInfo, result);
6101         radioService[slotId]->checkReturnStatus(retStatus);
6102     } else {
6103         RLOGE("pullLceDataResponse: radioService[%d]->mRadioResponse == NULL", slotId);
6104     }
6105
6106     return 0;
6107 }
6108
6109 int radio::getModemActivityInfoResponse(int slotId,
6110                                         int responseType, int serial, RIL_Errno e,
6111                                         void *response, size_t responseLen) {
6112 #if VDBG
6113     RLOGD("getModemActivityInfoResponse: serial %d", serial);
6114 #endif
6115
6116     if (radioService[slotId]->mRadioResponse != NULL) {
6117         RadioResponseInfo responseInfo = {};
6118         populateResponseInfo(responseInfo, serial, responseType, e);
6119         ActivityStatsInfo info;
6120         if (response == NULL || responseLen != sizeof(RIL_ActivityStatsInfo)) {
6121             RLOGE("getModemActivityInfoResponse Invalid response: NULL");
6122             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
6123         } else {
6124             RIL_ActivityStatsInfo *resp = (RIL_ActivityStatsInfo *)response;
6125             info.sleepModeTimeMs = resp->sleep_mode_time_ms;
6126             info.idleModeTimeMs = resp->idle_mode_time_ms;
6127             for(int i = 0; i < RIL_NUM_TX_POWER_LEVELS; i++) {
6128                 info.txmModetimeMs[i] = resp->tx_mode_time_ms[i];
6129             }
6130             info.rxModeTimeMs = resp->rx_mode_time_ms;
6131         }
6132
6133         Return<void> retStatus
6134                 = radioService[slotId]->mRadioResponse->getModemActivityInfoResponse(responseInfo,
6135                 info);
6136         radioService[slotId]->checkReturnStatus(retStatus);
6137     } else {
6138         RLOGE("getModemActivityInfoResponse: radioService[%d]->mRadioResponse == NULL",
6139                 slotId);
6140     }
6141
6142     return 0;
6143 }
6144
6145 int radio::setAllowedCarriersResponse(int slotId,
6146                                       int responseType, int serial, RIL_Errno e,
6147                                       void *response, size_t responseLen) {
6148 #if VDBG
6149     RLOGD("setAllowedCarriersResponse: serial %d", serial);
6150 #endif
6151
6152     if (radioService[slotId]->mRadioResponse != NULL) {
6153         RadioResponseInfo responseInfo = {};
6154         int ret = responseInt(responseInfo, serial, responseType, e, response, responseLen);
6155         Return<void> retStatus
6156                 = radioService[slotId]->mRadioResponse->setAllowedCarriersResponse(responseInfo,
6157                 ret);
6158         radioService[slotId]->checkReturnStatus(retStatus);
6159     } else {
6160         RLOGE("setAllowedCarriersResponse: radioService[%d]->mRadioResponse == NULL",
6161                 slotId);
6162     }
6163
6164     return 0;
6165 }
6166
6167 int radio::getAllowedCarriersResponse(int slotId,
6168                                       int responseType, int serial, RIL_Errno e,
6169                                       void *response, size_t responseLen) {
6170 #if VDBG
6171     RLOGD("getAllowedCarriersResponse: serial %d", serial);
6172 #endif
6173
6174     if (radioService[slotId]->mRadioResponse != NULL) {
6175         RadioResponseInfo responseInfo = {};
6176         populateResponseInfo(responseInfo, serial, responseType, e);
6177         CarrierRestrictions carrierInfo = {};
6178         bool allAllowed = true;
6179         if (response == NULL || responseLen != sizeof(RIL_CarrierRestrictions)) {
6180             RLOGE("getAllowedCarriersResponse Invalid response: NULL");
6181             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
6182         } else {
6183             RIL_CarrierRestrictions *pCr = (RIL_CarrierRestrictions *)response;
6184             if (pCr->len_allowed_carriers > 0 || pCr->len_excluded_carriers > 0) {
6185                 allAllowed = false;
6186             }
6187
6188             carrierInfo.allowedCarriers.resize(pCr->len_allowed_carriers);
6189             for(int i = 0; i < pCr->len_allowed_carriers; i++) {
6190                 RIL_Carrier *carrier = pCr->allowed_carriers + i;
6191                 carrierInfo.allowedCarriers[i].mcc = convertCharPtrToHidlString(carrier->mcc);
6192                 carrierInfo.allowedCarriers[i].mnc = convertCharPtrToHidlString(carrier->mnc);
6193                 carrierInfo.allowedCarriers[i].matchType = (CarrierMatchType) carrier->match_type;
6194                 carrierInfo.allowedCarriers[i].matchData =
6195                         convertCharPtrToHidlString(carrier->match_data);
6196             }
6197
6198             carrierInfo.excludedCarriers.resize(pCr->len_excluded_carriers);
6199             for(int i = 0; i < pCr->len_excluded_carriers; i++) {
6200                 RIL_Carrier *carrier = pCr->excluded_carriers + i;
6201                 carrierInfo.excludedCarriers[i].mcc = convertCharPtrToHidlString(carrier->mcc);
6202                 carrierInfo.excludedCarriers[i].mnc = convertCharPtrToHidlString(carrier->mnc);
6203                 carrierInfo.excludedCarriers[i].matchType = (CarrierMatchType) carrier->match_type;
6204                 carrierInfo.excludedCarriers[i].matchData =
6205                         convertCharPtrToHidlString(carrier->match_data);
6206             }
6207         }
6208
6209         Return<void> retStatus
6210                 = radioService[slotId]->mRadioResponse->getAllowedCarriersResponse(responseInfo,
6211                 allAllowed, carrierInfo);
6212         radioService[slotId]->checkReturnStatus(retStatus);
6213     } else {
6214         RLOGE("getAllowedCarriersResponse: radioService[%d]->mRadioResponse == NULL",
6215                 slotId);
6216     }
6217
6218     return 0;
6219 }
6220
6221 int radio::sendDeviceStateResponse(int slotId,
6222                               int responseType, int serial, RIL_Errno e,
6223                               void *response, size_t responselen) {
6224 #if VDBG
6225     RLOGD("sendDeviceStateResponse: serial %d", serial);
6226 #endif
6227
6228     if (radioService[slotId]->mRadioResponse != NULL) {
6229         RadioResponseInfo responseInfo = {};
6230         populateResponseInfo(responseInfo, serial, responseType, e);
6231         Return<void> retStatus
6232                 = radioService[slotId]->mRadioResponse->sendDeviceStateResponse(responseInfo);
6233         radioService[slotId]->checkReturnStatus(retStatus);
6234     } else {
6235         RLOGE("sendDeviceStateResponse: radioService[%d]->mRadioResponse == NULL", slotId);
6236     }
6237
6238     return 0;
6239 }
6240
6241 int radio::setIndicationFilterResponse(int slotId,
6242                               int responseType, int serial, RIL_Errno e,
6243                               void *response, size_t responselen) {
6244 #if VDBG
6245     RLOGD("setIndicationFilterResponse: serial %d", serial);
6246 #endif
6247
6248     if (radioService[slotId]->mRadioResponse != NULL) {
6249         RadioResponseInfo responseInfo = {};
6250         populateResponseInfo(responseInfo, serial, responseType, e);
6251         Return<void> retStatus
6252                 = radioService[slotId]->mRadioResponse->setIndicationFilterResponse(responseInfo);
6253         radioService[slotId]->checkReturnStatus(retStatus);
6254     } else {
6255         RLOGE("setIndicationFilterResponse: radioService[%d]->mRadioResponse == NULL",
6256                 slotId);
6257     }
6258
6259     return 0;
6260 }
6261
6262
6263 int radio::setSimCardPowerResponse(int slotId,
6264                                    int responseType, int serial, RIL_Errno e,
6265                                    void *response, size_t responseLen) {
6266 #if VDBG
6267     RLOGD("setSimCardPowerResponse: serial %d", serial);
6268 #endif
6269
6270     if (radioService[slotId]->mRadioResponse != NULL) {
6271         RadioResponseInfo responseInfo = {};
6272         populateResponseInfo(responseInfo, serial, responseType, e);
6273         Return<void> retStatus
6274                 = radioService[slotId]->mRadioResponse->setSimCardPowerResponse(responseInfo);
6275         radioService[slotId]->checkReturnStatus(retStatus);
6276     } else {
6277         RLOGE("setSimCardPowerResponse: radioService[%d]->mRadioResponse == NULL", slotId);
6278     }
6279
6280     return 0;
6281 }
6282
6283 int radio::sendRequestRawResponse(int slotId,
6284                                   int responseType, int serial, RIL_Errno e,
6285                                   void *response, size_t responseLen) {
6286 #if VDBG
6287    RLOGD("sendRequestRawResponse: serial %d", serial);
6288 #endif
6289
6290     if (oemHookService[slotId]->mOemHookResponse != NULL) {
6291         RadioResponseInfo responseInfo = {};
6292         populateResponseInfo(responseInfo, serial, responseType, e);
6293         hidl_vec<uint8_t> data;
6294
6295         if (response == NULL) {
6296             RLOGE("sendRequestRawResponse: Invalid response");
6297             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
6298         } else {
6299             data.setToExternal((uint8_t *) response, responseLen);
6300         }
6301         Return<void> retStatus = oemHookService[slotId]->mOemHookResponse->
6302                 sendRequestRawResponse(responseInfo, data);
6303         checkReturnStatus(slotId, retStatus, false);
6304     } else {
6305         RLOGE("sendRequestRawResponse: oemHookService[%d]->mOemHookResponse == NULL",
6306                 slotId);
6307     }
6308
6309     return 0;
6310 }
6311
6312 int radio::sendRequestStringsResponse(int slotId,
6313                                       int responseType, int serial, RIL_Errno e,
6314                                       void *response, size_t responseLen) {
6315 #if VDBG
6316     RLOGD("sendRequestStringsResponse: serial %d", serial);
6317 #endif
6318
6319     if (oemHookService[slotId]->mOemHookResponse != NULL) {
6320         RadioResponseInfo responseInfo = {};
6321         populateResponseInfo(responseInfo, serial, responseType, e);
6322         hidl_vec<hidl_string> data;
6323
6324         if (response == NULL || responseLen % sizeof(char *) != 0) {
6325             RLOGE("sendRequestStringsResponse Invalid response: NULL");
6326             if (e == RIL_E_SUCCESS) responseInfo.error = RadioError::INVALID_RESPONSE;
6327         } else {
6328             char **resp = (char **) response;
6329             int numStrings = responseLen / sizeof(char *);
6330             data.resize(numStrings);
6331             for (int i = 0; i < numStrings; i++) {
6332                 data[i] = convertCharPtrToHidlString(resp[i]);
6333             }
6334         }
6335         Return<void> retStatus
6336                 = oemHookService[slotId]->mOemHookResponse->sendRequestStringsResponse(
6337                 responseInfo, data);
6338         checkReturnStatus(slotId, retStatus, false);
6339     } else {
6340         RLOGE("sendRequestStringsResponse: oemHookService[%d]->mOemHookResponse == "
6341                 "NULL", slotId);
6342     }
6343
6344     return 0;
6345 }
6346
6347 // Radio Indication functions
6348
6349 RadioIndicationType convertIntToRadioIndicationType(int indicationType) {
6350     return indicationType == RESPONSE_UNSOLICITED ? (RadioIndicationType::UNSOLICITED) :
6351             (RadioIndicationType::UNSOLICITED_ACK_EXP);
6352 }
6353
6354 int radio::radioStateChangedInd(int slotId,
6355                                  int indicationType, int token, RIL_Errno e, void *response,
6356                                  size_t responseLen) {
6357     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6358         RadioState radioState = (RadioState) s_vendorFunctions->onStateRequest();
6359         RLOGD("radioStateChangedInd: radioState %d", radioState);
6360         Return<void> retStatus = radioService[slotId]->mRadioIndication->radioStateChanged(
6361                 convertIntToRadioIndicationType(indicationType), radioState);
6362         radioService[slotId]->checkReturnStatus(retStatus);
6363     } else {
6364         RLOGE("radioStateChangedInd: radioService[%d]->mRadioIndication == NULL", slotId);
6365     }
6366
6367     return 0;
6368 }
6369
6370 int radio::callStateChangedInd(int slotId,
6371                                int indicationType, int token, RIL_Errno e, void *response,
6372                                size_t responseLen) {
6373     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6374 #if VDBG
6375         RLOGD("callStateChangedInd");
6376 #endif
6377         Return<void> retStatus = radioService[slotId]->mRadioIndication->callStateChanged(
6378                 convertIntToRadioIndicationType(indicationType));
6379         radioService[slotId]->checkReturnStatus(retStatus);
6380     } else {
6381         RLOGE("callStateChangedInd: radioService[%d]->mRadioIndication == NULL", slotId);
6382     }
6383
6384     return 0;
6385 }
6386
6387 int radio::networkStateChangedInd(int slotId,
6388                                   int indicationType, int token, RIL_Errno e, void *response,
6389                                   size_t responseLen) {
6390     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6391 #if VDBG
6392         RLOGD("networkStateChangedInd");
6393 #endif
6394         Return<void> retStatus = radioService[slotId]->mRadioIndication->networkStateChanged(
6395                 convertIntToRadioIndicationType(indicationType));
6396         radioService[slotId]->checkReturnStatus(retStatus);
6397     } else {
6398         RLOGE("networkStateChangedInd: radioService[%d]->mRadioIndication == NULL",
6399                 slotId);
6400     }
6401
6402     return 0;
6403 }
6404
6405 uint8_t hexCharToInt(uint8_t c) {
6406     if (c >= '0' && c <= '9') return (c - '0');
6407     if (c >= 'A' && c <= 'F') return (c - 'A' + 10);
6408     if (c >= 'a' && c <= 'f') return (c - 'a' + 10);
6409
6410     return INVALID_HEX_CHAR;
6411 }
6412
6413 uint8_t * convertHexStringToBytes(void *response, size_t responseLen) {
6414     if (responseLen % 2 != 0) {
6415         return NULL;
6416     }
6417
6418     uint8_t *bytes = (uint8_t *)calloc(responseLen/2, sizeof(uint8_t));
6419     if (bytes == NULL) {
6420         RLOGE("convertHexStringToBytes: cannot allocate memory for bytes string");
6421         return NULL;
6422     }
6423     uint8_t *hexString = (uint8_t *)response;
6424
6425     for (size_t i = 0; i < responseLen; i += 2) {
6426         uint8_t hexChar1 = hexCharToInt(hexString[i]);
6427         uint8_t hexChar2 = hexCharToInt(hexString[i + 1]);
6428
6429         if (hexChar1 == INVALID_HEX_CHAR || hexChar2 == INVALID_HEX_CHAR) {
6430             RLOGE("convertHexStringToBytes: invalid hex char %d %d",
6431                     hexString[i], hexString[i + 1]);
6432             free(bytes);
6433             return NULL;
6434         }
6435         bytes[i/2] = ((hexChar1 << 4) | hexChar2);
6436     }
6437
6438     return bytes;
6439 }
6440
6441 int radio::newSmsInd(int slotId, int indicationType,
6442                      int token, RIL_Errno e, void *response, size_t responseLen) {
6443     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6444         if (response == NULL || responseLen == 0) {
6445             RLOGE("newSmsInd: invalid response");
6446             return 0;
6447         }
6448
6449         uint8_t *bytes = convertHexStringToBytes(response, responseLen);
6450         if (bytes == NULL) {
6451             RLOGE("newSmsInd: convertHexStringToBytes failed");
6452             return 0;
6453         }
6454
6455         hidl_vec<uint8_t> pdu;
6456         pdu.setToExternal(bytes, responseLen/2);
6457 #if VDBG
6458         RLOGD("newSmsInd");
6459 #endif
6460         Return<void> retStatus = radioService[slotId]->mRadioIndication->newSms(
6461                 convertIntToRadioIndicationType(indicationType), pdu);
6462         radioService[slotId]->checkReturnStatus(retStatus);
6463         free(bytes);
6464     } else {
6465         RLOGE("newSmsInd: radioService[%d]->mRadioIndication == NULL", slotId);
6466     }
6467
6468     return 0;
6469 }
6470
6471 int radio::newSmsStatusReportInd(int slotId,
6472                                  int indicationType, int token, RIL_Errno e, void *response,
6473                                  size_t responseLen) {
6474     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6475         if (response == NULL || responseLen == 0) {
6476             RLOGE("newSmsStatusReportInd: invalid response");
6477             return 0;
6478         }
6479
6480         uint8_t *bytes = convertHexStringToBytes(response, responseLen);
6481         if (bytes == NULL) {
6482             RLOGE("newSmsStatusReportInd: convertHexStringToBytes failed");
6483             return 0;
6484         }
6485
6486         hidl_vec<uint8_t> pdu;
6487         pdu.setToExternal(bytes, responseLen/2);
6488 #if VDBG
6489         RLOGD("newSmsStatusReportInd");
6490 #endif
6491         Return<void> retStatus = radioService[slotId]->mRadioIndication->newSmsStatusReport(
6492                 convertIntToRadioIndicationType(indicationType), pdu);
6493         radioService[slotId]->checkReturnStatus(retStatus);
6494         free(bytes);
6495     } else {
6496         RLOGE("newSmsStatusReportInd: radioService[%d]->mRadioIndication == NULL", slotId);
6497     }
6498
6499     return 0;
6500 }
6501
6502 int radio::newSmsOnSimInd(int slotId, int indicationType,
6503                           int token, RIL_Errno e, void *response, size_t responseLen) {
6504     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6505         if (response == NULL || responseLen != sizeof(int)) {
6506             RLOGE("newSmsOnSimInd: invalid response");
6507             return 0;
6508         }
6509         int32_t recordNumber = ((int32_t *) response)[0];
6510 #if VDBG
6511         RLOGD("newSmsOnSimInd: slotIndex %d", recordNumber);
6512 #endif
6513         Return<void> retStatus = radioService[slotId]->mRadioIndication->newSmsOnSim(
6514                 convertIntToRadioIndicationType(indicationType), recordNumber);
6515         radioService[slotId]->checkReturnStatus(retStatus);
6516     } else {
6517         RLOGE("newSmsOnSimInd: radioService[%d]->mRadioIndication == NULL", slotId);
6518     }
6519
6520     return 0;
6521 }
6522
6523 int radio::onUssdInd(int slotId, int indicationType,
6524                      int token, RIL_Errno e, void *response, size_t responseLen) {
6525     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6526         if (response == NULL || responseLen != 2 * sizeof(char *)) {
6527             RLOGE("onUssdInd: invalid response");
6528             return 0;
6529         }
6530         char **strings = (char **) response;
6531         char *mode = strings[0];
6532         hidl_string msg = convertCharPtrToHidlString(strings[1]);
6533         UssdModeType modeType = (UssdModeType) atoi(mode);
6534 #if VDBG
6535         RLOGD("onUssdInd: mode %s", mode);
6536 #endif
6537         Return<void> retStatus = radioService[slotId]->mRadioIndication->onUssd(
6538                 convertIntToRadioIndicationType(indicationType), modeType, msg);
6539         radioService[slotId]->checkReturnStatus(retStatus);
6540     } else {
6541         RLOGE("onUssdInd: radioService[%d]->mRadioIndication == NULL", slotId);
6542     }
6543
6544     return 0;
6545 }
6546
6547 int radio::nitzTimeReceivedInd(int slotId,
6548                                int indicationType, int token, RIL_Errno e, void *response,
6549                                size_t responseLen) {
6550     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6551         if (response == NULL || responseLen == 0) {
6552             RLOGE("nitzTimeReceivedInd: invalid response");
6553             return 0;
6554         }
6555         hidl_string nitzTime = convertCharPtrToHidlString((char *) response);
6556         int64_t timeReceived = android::elapsedRealtime();
6557 #if VDBG
6558         RLOGD("nitzTimeReceivedInd: nitzTime %s receivedTime %" PRId64, nitzTime.c_str(),
6559                 timeReceived);
6560 #endif
6561         Return<void> retStatus = radioService[slotId]->mRadioIndication->nitzTimeReceived(
6562                 convertIntToRadioIndicationType(indicationType), nitzTime, timeReceived);
6563         radioService[slotId]->checkReturnStatus(retStatus);
6564     } else {
6565         RLOGE("nitzTimeReceivedInd: radioService[%d]->mRadioIndication == NULL", slotId);
6566         return -1;
6567     }
6568
6569     return 0;
6570 }
6571
6572 void convertRilSignalStrengthToHal(void *response, size_t responseLen,
6573         SignalStrength& signalStrength) {
6574     RIL_SignalStrength_v10 *rilSignalStrength = (RIL_SignalStrength_v10 *) response;
6575
6576     // Fixup LTE for backwards compatibility
6577     // signalStrength: -1 -> 99
6578     if (rilSignalStrength->LTE_SignalStrength.signalStrength == -1) {
6579         rilSignalStrength->LTE_SignalStrength.signalStrength = 99;
6580     }
6581     // rsrp: -1 -> INT_MAX all other negative value to positive.
6582     // So remap here
6583     if (rilSignalStrength->LTE_SignalStrength.rsrp == -1) {
6584         rilSignalStrength->LTE_SignalStrength.rsrp = INT_MAX;
6585     } else if (rilSignalStrength->LTE_SignalStrength.rsrp < -1) {
6586         rilSignalStrength->LTE_SignalStrength.rsrp = -rilSignalStrength->LTE_SignalStrength.rsrp;
6587     }
6588     // rsrq: -1 -> INT_MAX
6589     if (rilSignalStrength->LTE_SignalStrength.rsrq == -1) {
6590         rilSignalStrength->LTE_SignalStrength.rsrq = INT_MAX;
6591     }
6592     // Not remapping rssnr is already using INT_MAX
6593     // cqi: -1 -> INT_MAX
6594     if (rilSignalStrength->LTE_SignalStrength.cqi == -1) {
6595         rilSignalStrength->LTE_SignalStrength.cqi = INT_MAX;
6596     }
6597
6598     signalStrength.gw.signalStrength = rilSignalStrength->GW_SignalStrength.signalStrength;
6599     signalStrength.gw.bitErrorRate = rilSignalStrength->GW_SignalStrength.bitErrorRate;
6600     signalStrength.cdma.dbm = rilSignalStrength->CDMA_SignalStrength.dbm;
6601     signalStrength.cdma.ecio = rilSignalStrength->CDMA_SignalStrength.ecio;
6602     signalStrength.evdo.dbm = rilSignalStrength->EVDO_SignalStrength.dbm;
6603     signalStrength.evdo.ecio = rilSignalStrength->EVDO_SignalStrength.ecio;
6604     signalStrength.evdo.signalNoiseRatio =
6605             rilSignalStrength->EVDO_SignalStrength.signalNoiseRatio;
6606     signalStrength.lte.signalStrength = rilSignalStrength->LTE_SignalStrength.signalStrength;
6607     signalStrength.lte.rsrp = rilSignalStrength->LTE_SignalStrength.rsrp;
6608     signalStrength.lte.rsrq = rilSignalStrength->LTE_SignalStrength.rsrq;
6609     signalStrength.lte.rssnr = rilSignalStrength->LTE_SignalStrength.rssnr;
6610     signalStrength.lte.cqi = rilSignalStrength->LTE_SignalStrength.cqi;
6611     signalStrength.lte.timingAdvance = rilSignalStrength->LTE_SignalStrength.timingAdvance;
6612     signalStrength.tdScdma.rscp = rilSignalStrength->TD_SCDMA_SignalStrength.rscp;
6613 }
6614
6615 int radio::currentSignalStrengthInd(int slotId,
6616                                     int indicationType, int token, RIL_Errno e,
6617                                     void *response, size_t responseLen) {
6618     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6619         if (response == NULL || responseLen != sizeof(RIL_SignalStrength_v10)) {
6620             RLOGE("currentSignalStrengthInd: invalid response");
6621             return 0;
6622         }
6623
6624         SignalStrength signalStrength = {};
6625         convertRilSignalStrengthToHal(response, responseLen, signalStrength);
6626
6627 #if VDBG
6628         RLOGD("currentSignalStrengthInd");
6629 #endif
6630         Return<void> retStatus = radioService[slotId]->mRadioIndication->currentSignalStrength(
6631                 convertIntToRadioIndicationType(indicationType), signalStrength);
6632         radioService[slotId]->checkReturnStatus(retStatus);
6633     } else {
6634         RLOGE("currentSignalStrengthInd: radioService[%d]->mRadioIndication == NULL",
6635                 slotId);
6636     }
6637
6638     return 0;
6639 }
6640
6641 void convertRilDataCallToHal(RIL_Data_Call_Response_v11 *dcResponse,
6642         SetupDataCallResult& dcResult) {
6643     dcResult.status = (DataCallFailCause) dcResponse->status;
6644     dcResult.suggestedRetryTime = dcResponse->suggestedRetryTime;
6645     dcResult.cid = dcResponse->cid;
6646     dcResult.active = dcResponse->active;
6647     dcResult.type = convertCharPtrToHidlString(dcResponse->type);
6648     dcResult.ifname = convertCharPtrToHidlString(dcResponse->ifname);
6649     dcResult.addresses = convertCharPtrToHidlString(dcResponse->addresses);
6650     dcResult.dnses = convertCharPtrToHidlString(dcResponse->dnses);
6651     dcResult.gateways = convertCharPtrToHidlString(dcResponse->gateways);
6652     dcResult.pcscf = convertCharPtrToHidlString(dcResponse->pcscf);
6653     dcResult.mtu = dcResponse->mtu;
6654 }
6655
6656 void convertRilDataCallListToHal(void *response, size_t responseLen,
6657         hidl_vec<SetupDataCallResult>& dcResultList) {
6658     int num = responseLen / sizeof(RIL_Data_Call_Response_v11);
6659
6660     RIL_Data_Call_Response_v11 *dcResponse = (RIL_Data_Call_Response_v11 *) response;
6661     dcResultList.resize(num);
6662     for (int i = 0; i < num; i++) {
6663         convertRilDataCallToHal(&dcResponse[i], dcResultList[i]);
6664     }
6665 }
6666
6667 int radio::dataCallListChangedInd(int slotId,
6668                                   int indicationType, int token, RIL_Errno e, void *response,
6669                                   size_t responseLen) {
6670     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6671         if (response == NULL || responseLen % sizeof(RIL_Data_Call_Response_v11) != 0) {
6672             RLOGE("dataCallListChangedInd: invalid response");
6673             return 0;
6674         }
6675         hidl_vec<SetupDataCallResult> dcList;
6676         convertRilDataCallListToHal(response, responseLen, dcList);
6677 #if VDBG
6678         RLOGD("dataCallListChangedInd");
6679 #endif
6680         Return<void> retStatus = radioService[slotId]->mRadioIndication->dataCallListChanged(
6681                 convertIntToRadioIndicationType(indicationType), dcList);
6682         radioService[slotId]->checkReturnStatus(retStatus);
6683     } else {
6684         RLOGE("dataCallListChangedInd: radioService[%d]->mRadioIndication == NULL", slotId);
6685     }
6686
6687     return 0;
6688 }
6689
6690 int radio::suppSvcNotifyInd(int slotId, int indicationType,
6691                             int token, RIL_Errno e, void *response, size_t responseLen) {
6692     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6693         if (response == NULL || responseLen != sizeof(RIL_SuppSvcNotification)) {
6694             RLOGE("suppSvcNotifyInd: invalid response");
6695             return 0;
6696         }
6697
6698         SuppSvcNotification suppSvc = {};
6699         RIL_SuppSvcNotification *ssn = (RIL_SuppSvcNotification *) response;
6700         suppSvc.isMT = ssn->notificationType;
6701         suppSvc.code = ssn->code;
6702         suppSvc.index = ssn->index;
6703         suppSvc.type = ssn->type;
6704         suppSvc.number = convertCharPtrToHidlString(ssn->number);
6705
6706 #if VDBG
6707         RLOGD("suppSvcNotifyInd: isMT %d code %d index %d type %d",
6708                 suppSvc.isMT, suppSvc.code, suppSvc.index, suppSvc.type);
6709 #endif
6710         Return<void> retStatus = radioService[slotId]->mRadioIndication->suppSvcNotify(
6711                 convertIntToRadioIndicationType(indicationType), suppSvc);
6712         radioService[slotId]->checkReturnStatus(retStatus);
6713     } else {
6714         RLOGE("suppSvcNotifyInd: radioService[%d]->mRadioIndication == NULL", slotId);
6715     }
6716
6717     return 0;
6718 }
6719
6720 int radio::stkSessionEndInd(int slotId, int indicationType,
6721                             int token, RIL_Errno e, void *response, size_t responseLen) {
6722     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6723 #if VDBG
6724         RLOGD("stkSessionEndInd");
6725 #endif
6726         Return<void> retStatus = radioService[slotId]->mRadioIndication->stkSessionEnd(
6727                 convertIntToRadioIndicationType(indicationType));
6728         radioService[slotId]->checkReturnStatus(retStatus);
6729     } else {
6730         RLOGE("stkSessionEndInd: radioService[%d]->mRadioIndication == NULL", slotId);
6731     }
6732
6733     return 0;
6734 }
6735
6736 int radio::stkProactiveCommandInd(int slotId,
6737                                   int indicationType, int token, RIL_Errno e, void *response,
6738                                   size_t responseLen) {
6739     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6740         if (response == NULL || responseLen == 0) {
6741             RLOGE("stkProactiveCommandInd: invalid response");
6742             return 0;
6743         }
6744 #if VDBG
6745         RLOGD("stkProactiveCommandInd");
6746 #endif
6747         Return<void> retStatus = radioService[slotId]->mRadioIndication->stkProactiveCommand(
6748                 convertIntToRadioIndicationType(indicationType),
6749                 convertCharPtrToHidlString((char *) response));
6750         radioService[slotId]->checkReturnStatus(retStatus);
6751     } else {
6752         RLOGE("stkProactiveCommandInd: radioService[%d]->mRadioIndication == NULL", slotId);
6753     }
6754
6755     return 0;
6756 }
6757
6758 int radio::stkEventNotifyInd(int slotId, int indicationType,
6759                              int token, RIL_Errno e, void *response, size_t responseLen) {
6760     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6761         if (response == NULL || responseLen == 0) {
6762             RLOGE("stkEventNotifyInd: invalid response");
6763             return 0;
6764         }
6765 #if VDBG
6766         RLOGD("stkEventNotifyInd");
6767 #endif
6768         Return<void> retStatus = radioService[slotId]->mRadioIndication->stkEventNotify(
6769                 convertIntToRadioIndicationType(indicationType),
6770                 convertCharPtrToHidlString((char *) response));
6771         radioService[slotId]->checkReturnStatus(retStatus);
6772     } else {
6773         RLOGE("stkEventNotifyInd: radioService[%d]->mRadioIndication == NULL", slotId);
6774     }
6775
6776     return 0;
6777 }
6778
6779 int radio::stkCallSetupInd(int slotId, int indicationType,
6780                            int token, RIL_Errno e, void *response, size_t responseLen) {
6781     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6782         if (response == NULL || responseLen != sizeof(int)) {
6783             RLOGE("stkCallSetupInd: invalid response");
6784             return 0;
6785         }
6786         int32_t timeout = ((int32_t *) response)[0];
6787 #if VDBG
6788         RLOGD("stkCallSetupInd: timeout %d", timeout);
6789 #endif
6790         Return<void> retStatus = radioService[slotId]->mRadioIndication->stkCallSetup(
6791                 convertIntToRadioIndicationType(indicationType), timeout);
6792         radioService[slotId]->checkReturnStatus(retStatus);
6793     } else {
6794         RLOGE("stkCallSetupInd: radioService[%d]->mRadioIndication == NULL", slotId);
6795     }
6796
6797     return 0;
6798 }
6799
6800 int radio::simSmsStorageFullInd(int slotId,
6801                                 int indicationType, int token, RIL_Errno e, void *response,
6802                                 size_t responseLen) {
6803     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6804 #if VDBG
6805         RLOGD("simSmsStorageFullInd");
6806 #endif
6807         Return<void> retStatus = radioService[slotId]->mRadioIndication->simSmsStorageFull(
6808                 convertIntToRadioIndicationType(indicationType));
6809         radioService[slotId]->checkReturnStatus(retStatus);
6810     } else {
6811         RLOGE("simSmsStorageFullInd: radioService[%d]->mRadioIndication == NULL", slotId);
6812     }
6813
6814     return 0;
6815 }
6816
6817 int radio::simRefreshInd(int slotId, int indicationType,
6818                          int token, RIL_Errno e, void *response, size_t responseLen) {
6819     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6820         if (response == NULL || responseLen != sizeof(RIL_SimRefreshResponse_v7)) {
6821             RLOGE("simRefreshInd: invalid response");
6822             return 0;
6823         }
6824
6825         SimRefreshResult refreshResult = {};
6826         RIL_SimRefreshResponse_v7 *simRefreshResponse = ((RIL_SimRefreshResponse_v7 *) response);
6827         refreshResult.type =
6828                 (android::hardware::radio::V1_0::SimRefreshType) simRefreshResponse->result;
6829         refreshResult.efId = simRefreshResponse->ef_id;
6830         refreshResult.aid = convertCharPtrToHidlString(simRefreshResponse->aid);
6831
6832 #if VDBG
6833         RLOGD("simRefreshInd: type %d efId %d", refreshResult.type, refreshResult.efId);
6834 #endif
6835         Return<void> retStatus = radioService[slotId]->mRadioIndication->simRefresh(
6836                 convertIntToRadioIndicationType(indicationType), refreshResult);
6837         radioService[slotId]->checkReturnStatus(retStatus);
6838     } else {
6839         RLOGE("simRefreshInd: radioService[%d]->mRadioIndication == NULL", slotId);
6840     }
6841
6842     return 0;
6843 }
6844
6845 void convertRilCdmaSignalInfoRecordToHal(RIL_CDMA_SignalInfoRecord *signalInfoRecord,
6846         CdmaSignalInfoRecord& record) {
6847     record.isPresent = signalInfoRecord->isPresent;
6848     record.signalType = signalInfoRecord->signalType;
6849     record.alertPitch = signalInfoRecord->alertPitch;
6850     record.signal = signalInfoRecord->signal;
6851 }
6852
6853 int radio::callRingInd(int slotId, int indicationType,
6854                        int token, RIL_Errno e, void *response, size_t responseLen) {
6855     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6856         bool isGsm;
6857         CdmaSignalInfoRecord record = {};
6858         if (response == NULL || responseLen == 0) {
6859             isGsm = true;
6860         } else {
6861             isGsm = false;
6862             if (responseLen != sizeof (RIL_CDMA_SignalInfoRecord)) {
6863                 RLOGE("callRingInd: invalid response");
6864                 return 0;
6865             }
6866             convertRilCdmaSignalInfoRecordToHal((RIL_CDMA_SignalInfoRecord *) response, record);
6867         }
6868
6869 #if VDBG
6870         RLOGD("callRingInd: isGsm %d", isGsm);
6871 #endif
6872         Return<void> retStatus = radioService[slotId]->mRadioIndication->callRing(
6873                 convertIntToRadioIndicationType(indicationType), isGsm, record);
6874         radioService[slotId]->checkReturnStatus(retStatus);
6875     } else {
6876         RLOGE("callRingInd: radioService[%d]->mRadioIndication == NULL", slotId);
6877     }
6878
6879     return 0;
6880 }
6881
6882 int radio::simStatusChangedInd(int slotId,
6883                                int indicationType, int token, RIL_Errno e, void *response,
6884                                size_t responseLen) {
6885     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6886 #if VDBG
6887         RLOGD("simStatusChangedInd");
6888 #endif
6889         Return<void> retStatus = radioService[slotId]->mRadioIndication->simStatusChanged(
6890                 convertIntToRadioIndicationType(indicationType));
6891         radioService[slotId]->checkReturnStatus(retStatus);
6892     } else {
6893         RLOGE("simStatusChangedInd: radioService[%d]->mRadioIndication == NULL", slotId);
6894     }
6895
6896     return 0;
6897 }
6898
6899 int radio::cdmaNewSmsInd(int slotId, int indicationType,
6900                          int token, RIL_Errno e, void *response, size_t responseLen) {
6901     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6902         if (response == NULL || responseLen != sizeof(RIL_CDMA_SMS_Message)) {
6903             RLOGE("cdmaNewSmsInd: invalid response");
6904             return 0;
6905         }
6906
6907         CdmaSmsMessage msg = {};
6908         RIL_CDMA_SMS_Message *rilMsg = (RIL_CDMA_SMS_Message *) response;
6909         msg.teleserviceId = rilMsg->uTeleserviceID;
6910         msg.isServicePresent = rilMsg->bIsServicePresent;
6911         msg.serviceCategory = rilMsg->uServicecategory;
6912         msg.address.digitMode =
6913                 (android::hardware::radio::V1_0::CdmaSmsDigitMode) rilMsg->sAddress.digit_mode;
6914         msg.address.numberMode =
6915                 (android::hardware::radio::V1_0::CdmaSmsNumberMode) rilMsg->sAddress.number_mode;
6916         msg.address.numberType =
6917                 (android::hardware::radio::V1_0::CdmaSmsNumberType) rilMsg->sAddress.number_type;
6918         msg.address.numberPlan =
6919                 (android::hardware::radio::V1_0::CdmaSmsNumberPlan) rilMsg->sAddress.number_plan;
6920
6921         int digitLimit = MIN((rilMsg->sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
6922         msg.address.digits.setToExternal(rilMsg->sAddress.digits, digitLimit);
6923
6924         msg.subAddress.subaddressType = (android::hardware::radio::V1_0::CdmaSmsSubaddressType)
6925                 rilMsg->sSubAddress.subaddressType;
6926         msg.subAddress.odd = rilMsg->sSubAddress.odd;
6927
6928         digitLimit= MIN((rilMsg->sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
6929         msg.subAddress.digits.setToExternal(rilMsg->sSubAddress.digits, digitLimit);
6930
6931         digitLimit = MIN((rilMsg->uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
6932         msg.bearerData.setToExternal(rilMsg->aBearerData, digitLimit);
6933
6934 #if VDBG
6935         RLOGD("cdmaNewSmsInd");
6936 #endif
6937         Return<void> retStatus = radioService[slotId]->mRadioIndication->cdmaNewSms(
6938                 convertIntToRadioIndicationType(indicationType), msg);
6939         radioService[slotId]->checkReturnStatus(retStatus);
6940     } else {
6941         RLOGE("cdmaNewSmsInd: radioService[%d]->mRadioIndication == NULL", slotId);
6942     }
6943
6944     return 0;
6945 }
6946
6947 int radio::newBroadcastSmsInd(int slotId,
6948                               int indicationType, int token, RIL_Errno e, void *response,
6949                               size_t responseLen) {
6950     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6951         if (response == NULL || responseLen == 0) {
6952             RLOGE("newBroadcastSmsInd: invalid response");
6953             return 0;
6954         }
6955
6956         hidl_vec<uint8_t> data;
6957         data.setToExternal((uint8_t *) response, responseLen);
6958 #if VDBG
6959         RLOGD("newBroadcastSmsInd");
6960 #endif
6961         Return<void> retStatus = radioService[slotId]->mRadioIndication->newBroadcastSms(
6962                 convertIntToRadioIndicationType(indicationType), data);
6963         radioService[slotId]->checkReturnStatus(retStatus);
6964     } else {
6965         RLOGE("newBroadcastSmsInd: radioService[%d]->mRadioIndication == NULL", slotId);
6966     }
6967
6968     return 0;
6969 }
6970
6971 int radio::cdmaRuimSmsStorageFullInd(int slotId,
6972                                      int indicationType, int token, RIL_Errno e, void *response,
6973                                      size_t responseLen) {
6974     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6975 #if VDBG
6976         RLOGD("cdmaRuimSmsStorageFullInd");
6977 #endif
6978         Return<void> retStatus = radioService[slotId]->mRadioIndication->cdmaRuimSmsStorageFull(
6979                 convertIntToRadioIndicationType(indicationType));
6980         radioService[slotId]->checkReturnStatus(retStatus);
6981     } else {
6982         RLOGE("cdmaRuimSmsStorageFullInd: radioService[%d]->mRadioIndication == NULL",
6983                 slotId);
6984     }
6985
6986     return 0;
6987 }
6988
6989 int radio::restrictedStateChangedInd(int slotId,
6990                                      int indicationType, int token, RIL_Errno e, void *response,
6991                                      size_t responseLen) {
6992     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
6993         if (response == NULL || responseLen != sizeof(int)) {
6994             RLOGE("restrictedStateChangedInd: invalid response");
6995             return 0;
6996         }
6997         int32_t state = ((int32_t *) response)[0];
6998 #if VDBG
6999         RLOGD("restrictedStateChangedInd: state %d", state);
7000 #endif
7001         Return<void> retStatus = radioService[slotId]->mRadioIndication->restrictedStateChanged(
7002                 convertIntToRadioIndicationType(indicationType), (PhoneRestrictedState) state);
7003         radioService[slotId]->checkReturnStatus(retStatus);
7004     } else {
7005         RLOGE("restrictedStateChangedInd: radioService[%d]->mRadioIndication == NULL",
7006                 slotId);
7007     }
7008
7009     return 0;
7010 }
7011
7012 int radio::enterEmergencyCallbackModeInd(int slotId,
7013                                          int indicationType, int token, RIL_Errno e, void *response,
7014                                          size_t responseLen) {
7015     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7016 #if VDBG
7017         RLOGD("enterEmergencyCallbackModeInd");
7018 #endif
7019         Return<void> retStatus = radioService[slotId]->mRadioIndication->enterEmergencyCallbackMode(
7020                 convertIntToRadioIndicationType(indicationType));
7021         radioService[slotId]->checkReturnStatus(retStatus);
7022     } else {
7023         RLOGE("enterEmergencyCallbackModeInd: radioService[%d]->mRadioIndication == NULL",
7024                 slotId);
7025     }
7026
7027     return 0;
7028 }
7029
7030 int radio::cdmaCallWaitingInd(int slotId,
7031                               int indicationType, int token, RIL_Errno e, void *response,
7032                               size_t responseLen) {
7033     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7034         if (response == NULL || responseLen != sizeof(RIL_CDMA_CallWaiting_v6)) {
7035             RLOGE("cdmaCallWaitingInd: invalid response");
7036             return 0;
7037         }
7038
7039         CdmaCallWaiting callWaitingRecord = {};
7040         RIL_CDMA_CallWaiting_v6 *callWaitingRil = ((RIL_CDMA_CallWaiting_v6 *) response);
7041         callWaitingRecord.number = convertCharPtrToHidlString(callWaitingRil->number);
7042         callWaitingRecord.numberPresentation =
7043                 (CdmaCallWaitingNumberPresentation) callWaitingRil->numberPresentation;
7044         callWaitingRecord.name = convertCharPtrToHidlString(callWaitingRil->name);
7045         convertRilCdmaSignalInfoRecordToHal(&callWaitingRil->signalInfoRecord,
7046                 callWaitingRecord.signalInfoRecord);
7047         callWaitingRecord.numberType = (CdmaCallWaitingNumberType) callWaitingRil->number_type;
7048         callWaitingRecord.numberPlan = (CdmaCallWaitingNumberPlan) callWaitingRil->number_plan;
7049
7050 #if VDBG
7051         RLOGD("cdmaCallWaitingInd");
7052 #endif
7053         Return<void> retStatus = radioService[slotId]->mRadioIndication->cdmaCallWaiting(
7054                 convertIntToRadioIndicationType(indicationType), callWaitingRecord);
7055         radioService[slotId]->checkReturnStatus(retStatus);
7056     } else {
7057         RLOGE("cdmaCallWaitingInd: radioService[%d]->mRadioIndication == NULL", slotId);
7058     }
7059
7060     return 0;
7061 }
7062
7063 int radio::cdmaOtaProvisionStatusInd(int slotId,
7064                                      int indicationType, int token, RIL_Errno e, void *response,
7065                                      size_t responseLen) {
7066     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7067         if (response == NULL || responseLen != sizeof(int)) {
7068             RLOGE("cdmaOtaProvisionStatusInd: invalid response");
7069             return 0;
7070         }
7071         int32_t status = ((int32_t *) response)[0];
7072 #if VDBG
7073         RLOGD("cdmaOtaProvisionStatusInd: status %d", status);
7074 #endif
7075         Return<void> retStatus = radioService[slotId]->mRadioIndication->cdmaOtaProvisionStatus(
7076                 convertIntToRadioIndicationType(indicationType), (CdmaOtaProvisionStatus) status);
7077         radioService[slotId]->checkReturnStatus(retStatus);
7078     } else {
7079         RLOGE("cdmaOtaProvisionStatusInd: radioService[%d]->mRadioIndication == NULL",
7080                 slotId);
7081     }
7082
7083     return 0;
7084 }
7085
7086 int radio::cdmaInfoRecInd(int slotId,
7087                           int indicationType, int token, RIL_Errno e, void *response,
7088                           size_t responseLen) {
7089     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7090         if (response == NULL || responseLen != sizeof(RIL_CDMA_InformationRecords)) {
7091             RLOGE("cdmaInfoRecInd: invalid response");
7092             return 0;
7093         }
7094
7095         CdmaInformationRecords records = {};
7096         RIL_CDMA_InformationRecords *recordsRil = (RIL_CDMA_InformationRecords *) response;
7097
7098         char* string8 = NULL;
7099         int num = MIN(recordsRil->numberOfInfoRecs, RIL_CDMA_MAX_NUMBER_OF_INFO_RECS);
7100         if (recordsRil->numberOfInfoRecs > RIL_CDMA_MAX_NUMBER_OF_INFO_RECS) {
7101             RLOGE("cdmaInfoRecInd: received %d recs which is more than %d, dropping "
7102                     "additional ones", recordsRil->numberOfInfoRecs,
7103                     RIL_CDMA_MAX_NUMBER_OF_INFO_RECS);
7104         }
7105         records.infoRec.resize(num);
7106         for (int i = 0 ; i < num ; i++) {
7107             CdmaInformationRecord *record = &records.infoRec[i];
7108             RIL_CDMA_InformationRecord *infoRec = &recordsRil->infoRec[i];
7109             record->name = (CdmaInfoRecName) infoRec->name;
7110             // All vectors should be size 0 except one which will be size 1. Set everything to
7111             // size 0 initially.
7112             record->display.resize(0);
7113             record->number.resize(0);
7114             record->signal.resize(0);
7115             record->redir.resize(0);
7116             record->lineCtrl.resize(0);
7117             record->clir.resize(0);
7118             record->audioCtrl.resize(0);
7119             switch (infoRec->name) {
7120                 case RIL_CDMA_DISPLAY_INFO_REC:
7121                 case RIL_CDMA_EXTENDED_DISPLAY_INFO_REC: {
7122                     if (infoRec->rec.display.alpha_len > CDMA_ALPHA_INFO_BUFFER_LENGTH) {
7123                         RLOGE("cdmaInfoRecInd: invalid display info response length %d "
7124                                 "expected not more than %d", (int) infoRec->rec.display.alpha_len,
7125                                 CDMA_ALPHA_INFO_BUFFER_LENGTH);
7126                         return 0;
7127                     }
7128                     string8 = (char*) malloc((infoRec->rec.display.alpha_len + 1) * sizeof(char));
7129                     if (string8 == NULL) {
7130                         RLOGE("cdmaInfoRecInd: Memory allocation failed for "
7131                                 "responseCdmaInformationRecords");
7132                         return 0;
7133                     }
7134                     memcpy(string8, infoRec->rec.display.alpha_buf, infoRec->rec.display.alpha_len);
7135                     string8[(int)infoRec->rec.display.alpha_len] = '\0';
7136
7137                     record->display.resize(1);
7138                     record->display[0].alphaBuf = string8;
7139                     free(string8);
7140                     string8 = NULL;
7141                     break;
7142                 }
7143
7144                 case RIL_CDMA_CALLED_PARTY_NUMBER_INFO_REC:
7145                 case RIL_CDMA_CALLING_PARTY_NUMBER_INFO_REC:
7146                 case RIL_CDMA_CONNECTED_NUMBER_INFO_REC: {
7147                     if (infoRec->rec.number.len > CDMA_NUMBER_INFO_BUFFER_LENGTH) {
7148                         RLOGE("cdmaInfoRecInd: invalid display info response length %d "
7149                                 "expected not more than %d", (int) infoRec->rec.number.len,
7150                                 CDMA_NUMBER_INFO_BUFFER_LENGTH);
7151                         return 0;
7152                     }
7153                     string8 = (char*) malloc((infoRec->rec.number.len + 1) * sizeof(char));
7154                     if (string8 == NULL) {
7155                         RLOGE("cdmaInfoRecInd: Memory allocation failed for "
7156                                 "responseCdmaInformationRecords");
7157                         return 0;
7158                     }
7159                     memcpy(string8, infoRec->rec.number.buf, infoRec->rec.number.len);
7160                     string8[(int)infoRec->rec.number.len] = '\0';
7161
7162                     record->number.resize(1);
7163                     record->number[0].number = string8;
7164                     free(string8);
7165                     string8 = NULL;
7166                     record->number[0].numberType = infoRec->rec.number.number_type;
7167                     record->number[0].numberPlan = infoRec->rec.number.number_plan;
7168                     record->number[0].pi = infoRec->rec.number.pi;
7169                     record->number[0].si = infoRec->rec.number.si;
7170                     break;
7171                 }
7172
7173                 case RIL_CDMA_SIGNAL_INFO_REC: {
7174                     record->signal.resize(1);
7175                     record->signal[0].isPresent = infoRec->rec.signal.isPresent;
7176                     record->signal[0].signalType = infoRec->rec.signal.signalType;
7177                     record->signal[0].alertPitch = infoRec->rec.signal.alertPitch;
7178                     record->signal[0].signal = infoRec->rec.signal.signal;
7179                     break;
7180                 }
7181
7182                 case RIL_CDMA_REDIRECTING_NUMBER_INFO_REC: {
7183                     if (infoRec->rec.redir.redirectingNumber.len >
7184                                                   CDMA_NUMBER_INFO_BUFFER_LENGTH) {
7185                         RLOGE("cdmaInfoRecInd: invalid display info response length %d "
7186                                 "expected not more than %d\n",
7187                                 (int)infoRec->rec.redir.redirectingNumber.len,
7188                                 CDMA_NUMBER_INFO_BUFFER_LENGTH);
7189                         return 0;
7190                     }
7191                     string8 = (char*) malloc((infoRec->rec.redir.redirectingNumber.len + 1) *
7192                             sizeof(char));
7193                     if (string8 == NULL) {
7194                         RLOGE("cdmaInfoRecInd: Memory allocation failed for "
7195                                 "responseCdmaInformationRecords");
7196                         return 0;
7197                     }
7198                     memcpy(string8, infoRec->rec.redir.redirectingNumber.buf,
7199                             infoRec->rec.redir.redirectingNumber.len);
7200                     string8[(int)infoRec->rec.redir.redirectingNumber.len] = '\0';
7201
7202                     record->redir.resize(1);
7203                     record->redir[0].redirectingNumber.number = string8;
7204                     free(string8);
7205                     string8 = NULL;
7206                     record->redir[0].redirectingNumber.numberType =
7207                             infoRec->rec.redir.redirectingNumber.number_type;
7208                     record->redir[0].redirectingNumber.numberPlan =
7209                             infoRec->rec.redir.redirectingNumber.number_plan;
7210                     record->redir[0].redirectingNumber.pi = infoRec->rec.redir.redirectingNumber.pi;
7211                     record->redir[0].redirectingNumber.si = infoRec->rec.redir.redirectingNumber.si;
7212                     record->redir[0].redirectingReason =
7213                             (CdmaRedirectingReason) infoRec->rec.redir.redirectingReason;
7214                     break;
7215                 }
7216
7217                 case RIL_CDMA_LINE_CONTROL_INFO_REC: {
7218                     record->lineCtrl.resize(1);
7219                     record->lineCtrl[0].lineCtrlPolarityIncluded =
7220                             infoRec->rec.lineCtrl.lineCtrlPolarityIncluded;
7221                     record->lineCtrl[0].lineCtrlToggle = infoRec->rec.lineCtrl.lineCtrlToggle;
7222                     record->lineCtrl[0].lineCtrlReverse = infoRec->rec.lineCtrl.lineCtrlReverse;
7223                     record->lineCtrl[0].lineCtrlPowerDenial =
7224                             infoRec->rec.lineCtrl.lineCtrlPowerDenial;
7225                     break;
7226                 }
7227
7228                 case RIL_CDMA_T53_CLIR_INFO_REC: {
7229                     record->clir.resize(1);
7230                     record->clir[0].cause = infoRec->rec.clir.cause;
7231                     break;
7232                 }
7233
7234                 case RIL_CDMA_T53_AUDIO_CONTROL_INFO_REC: {
7235                     record->audioCtrl.resize(1);
7236                     record->audioCtrl[0].upLink = infoRec->rec.audioCtrl.upLink;
7237                     record->audioCtrl[0].downLink = infoRec->rec.audioCtrl.downLink;
7238                     break;
7239                 }
7240
7241                 case RIL_CDMA_T53_RELEASE_INFO_REC:
7242                     RLOGE("cdmaInfoRecInd: RIL_CDMA_T53_RELEASE_INFO_REC: INVALID");
7243                     return 0;
7244
7245                 default:
7246                     RLOGE("cdmaInfoRecInd: Incorrect name value");
7247                     return 0;
7248             }
7249         }
7250
7251 #if VDBG
7252         RLOGD("cdmaInfoRecInd");
7253 #endif
7254         Return<void> retStatus = radioService[slotId]->mRadioIndication->cdmaInfoRec(
7255                 convertIntToRadioIndicationType(indicationType), records);
7256         radioService[slotId]->checkReturnStatus(retStatus);
7257     } else {
7258         RLOGE("cdmaInfoRecInd: radioService[%d]->mRadioIndication == NULL", slotId);
7259     }
7260
7261     return 0;
7262 }
7263
7264 int radio::indicateRingbackToneInd(int slotId,
7265                                    int indicationType, int token, RIL_Errno e, void *response,
7266                                    size_t responseLen) {
7267     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7268         if (response == NULL || responseLen != sizeof(int)) {
7269             RLOGE("indicateRingbackToneInd: invalid response");
7270             return 0;
7271         }
7272         bool start = ((int32_t *) response)[0];
7273 #if VDBG
7274         RLOGD("indicateRingbackToneInd: start %d", start);
7275 #endif
7276         Return<void> retStatus = radioService[slotId]->mRadioIndication->indicateRingbackTone(
7277                 convertIntToRadioIndicationType(indicationType), start);
7278         radioService[slotId]->checkReturnStatus(retStatus);
7279     } else {
7280         RLOGE("indicateRingbackToneInd: radioService[%d]->mRadioIndication == NULL", slotId);
7281     }
7282
7283     return 0;
7284 }
7285
7286 int radio::resendIncallMuteInd(int slotId,
7287                                int indicationType, int token, RIL_Errno e, void *response,
7288                                size_t responseLen) {
7289     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7290 #if VDBG
7291         RLOGD("resendIncallMuteInd");
7292 #endif
7293         Return<void> retStatus = radioService[slotId]->mRadioIndication->resendIncallMute(
7294                 convertIntToRadioIndicationType(indicationType));
7295         radioService[slotId]->checkReturnStatus(retStatus);
7296     } else {
7297         RLOGE("resendIncallMuteInd: radioService[%d]->mRadioIndication == NULL", slotId);
7298     }
7299
7300     return 0;
7301 }
7302
7303 int radio::cdmaSubscriptionSourceChangedInd(int slotId,
7304                                             int indicationType, int token, RIL_Errno e,
7305                                             void *response, size_t responseLen) {
7306     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7307         if (response == NULL || responseLen != sizeof(int)) {
7308             RLOGE("cdmaSubscriptionSourceChangedInd: invalid response");
7309             return 0;
7310         }
7311         int32_t cdmaSource = ((int32_t *) response)[0];
7312 #if VDBG
7313         RLOGD("cdmaSubscriptionSourceChangedInd: cdmaSource %d", cdmaSource);
7314 #endif
7315         Return<void> retStatus = radioService[slotId]->mRadioIndication->
7316                 cdmaSubscriptionSourceChanged(convertIntToRadioIndicationType(indicationType),
7317                 (CdmaSubscriptionSource) cdmaSource);
7318         radioService[slotId]->checkReturnStatus(retStatus);
7319     } else {
7320         RLOGE("cdmaSubscriptionSourceChangedInd: radioService[%d]->mRadioIndication == NULL",
7321                 slotId);
7322     }
7323
7324     return 0;
7325 }
7326
7327 int radio::cdmaPrlChangedInd(int slotId,
7328                              int indicationType, int token, RIL_Errno e, void *response,
7329                              size_t responseLen) {
7330     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7331         if (response == NULL || responseLen != sizeof(int)) {
7332             RLOGE("cdmaPrlChangedInd: invalid response");
7333             return 0;
7334         }
7335         int32_t version = ((int32_t *) response)[0];
7336 #if VDBG
7337         RLOGD("cdmaPrlChangedInd: version %d", version);
7338 #endif
7339         Return<void> retStatus = radioService[slotId]->mRadioIndication->cdmaPrlChanged(
7340                 convertIntToRadioIndicationType(indicationType), version);
7341         radioService[slotId]->checkReturnStatus(retStatus);
7342     } else {
7343         RLOGE("cdmaPrlChangedInd: radioService[%d]->mRadioIndication == NULL", slotId);
7344     }
7345
7346     return 0;
7347 }
7348
7349 int radio::exitEmergencyCallbackModeInd(int slotId,
7350                                         int indicationType, int token, RIL_Errno e, void *response,
7351                                         size_t responseLen) {
7352     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7353 #if VDBG
7354         RLOGD("exitEmergencyCallbackModeInd");
7355 #endif
7356         Return<void> retStatus = radioService[slotId]->mRadioIndication->exitEmergencyCallbackMode(
7357                 convertIntToRadioIndicationType(indicationType));
7358         radioService[slotId]->checkReturnStatus(retStatus);
7359     } else {
7360         RLOGE("exitEmergencyCallbackModeInd: radioService[%d]->mRadioIndication == NULL",
7361                 slotId);
7362     }
7363
7364     return 0;
7365 }
7366
7367 int radio::rilConnectedInd(int slotId,
7368                            int indicationType, int token, RIL_Errno e, void *response,
7369                            size_t responseLen) {
7370     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7371         RLOGD("rilConnectedInd");
7372         Return<void> retStatus = radioService[slotId]->mRadioIndication->rilConnected(
7373                 convertIntToRadioIndicationType(indicationType));
7374         radioService[slotId]->checkReturnStatus(retStatus);
7375     } else {
7376         RLOGE("rilConnectedInd: radioService[%d]->mRadioIndication == NULL", slotId);
7377     }
7378
7379     return 0;
7380 }
7381
7382 int radio::voiceRadioTechChangedInd(int slotId,
7383                                     int indicationType, int token, RIL_Errno e, void *response,
7384                                     size_t responseLen) {
7385     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7386         if (response == NULL || responseLen != sizeof(int)) {
7387             RLOGE("voiceRadioTechChangedInd: invalid response");
7388             return 0;
7389         }
7390         int32_t rat = ((int32_t *) response)[0];
7391 #if VDBG
7392         RLOGD("voiceRadioTechChangedInd: rat %d", rat);
7393 #endif
7394         Return<void> retStatus = radioService[slotId]->mRadioIndication->voiceRadioTechChanged(
7395                 convertIntToRadioIndicationType(indicationType), (RadioTechnology) rat);
7396         radioService[slotId]->checkReturnStatus(retStatus);
7397     } else {
7398         RLOGE("voiceRadioTechChangedInd: radioService[%d]->mRadioIndication == NULL",
7399                 slotId);
7400     }
7401
7402     return 0;
7403 }
7404
7405 void convertRilCellInfoListToHal(void *response, size_t responseLen, hidl_vec<CellInfo>& records) {
7406     int num = responseLen / sizeof(RIL_CellInfo_v12);
7407     records.resize(num);
7408
7409     RIL_CellInfo_v12 *rillCellInfo = (RIL_CellInfo_v12 *) response;
7410     for (int i = 0; i < num; i++) {
7411         records[i].cellInfoType = (CellInfoType) rillCellInfo->cellInfoType;
7412         records[i].registered = rillCellInfo->registered;
7413         records[i].timeStampType = (TimeStampType) rillCellInfo->timeStampType;
7414         records[i].timeStamp = rillCellInfo->timeStamp;
7415         // All vectors should be size 0 except one which will be size 1. Set everything to
7416         // size 0 initially.
7417         records[i].gsm.resize(0);
7418         records[i].wcdma.resize(0);
7419         records[i].cdma.resize(0);
7420         records[i].lte.resize(0);
7421         records[i].tdscdma.resize(0);
7422         switch(rillCellInfo->cellInfoType) {
7423             case RIL_CELL_INFO_TYPE_GSM: {
7424                 records[i].gsm.resize(1);
7425                 CellInfoGsm *cellInfoGsm = &records[i].gsm[0];
7426                 cellInfoGsm->cellIdentityGsm.mcc =
7427                         std::to_string(rillCellInfo->CellInfo.gsm.cellIdentityGsm.mcc);
7428                 cellInfoGsm->cellIdentityGsm.mnc =
7429                         std::to_string(rillCellInfo->CellInfo.gsm.cellIdentityGsm.mnc);
7430                 cellInfoGsm->cellIdentityGsm.lac =
7431                         rillCellInfo->CellInfo.gsm.cellIdentityGsm.lac;
7432                 cellInfoGsm->cellIdentityGsm.cid =
7433                         rillCellInfo->CellInfo.gsm.cellIdentityGsm.cid;
7434                 cellInfoGsm->cellIdentityGsm.arfcn =
7435                         rillCellInfo->CellInfo.gsm.cellIdentityGsm.arfcn;
7436                 cellInfoGsm->cellIdentityGsm.bsic =
7437                         rillCellInfo->CellInfo.gsm.cellIdentityGsm.bsic;
7438                 cellInfoGsm->signalStrengthGsm.signalStrength =
7439                         rillCellInfo->CellInfo.gsm.signalStrengthGsm.signalStrength;
7440                 cellInfoGsm->signalStrengthGsm.bitErrorRate =
7441                         rillCellInfo->CellInfo.gsm.signalStrengthGsm.bitErrorRate;
7442                 cellInfoGsm->signalStrengthGsm.timingAdvance =
7443                         rillCellInfo->CellInfo.gsm.signalStrengthGsm.timingAdvance;
7444                 break;
7445             }
7446
7447             case RIL_CELL_INFO_TYPE_WCDMA: {
7448                 records[i].wcdma.resize(1);
7449                 CellInfoWcdma *cellInfoWcdma = &records[i].wcdma[0];
7450                 cellInfoWcdma->cellIdentityWcdma.mcc =
7451                         std::to_string(rillCellInfo->CellInfo.wcdma.cellIdentityWcdma.mcc);
7452                 cellInfoWcdma->cellIdentityWcdma.mnc =
7453                         std::to_string(rillCellInfo->CellInfo.wcdma.cellIdentityWcdma.mnc);
7454                 cellInfoWcdma->cellIdentityWcdma.lac =
7455                         rillCellInfo->CellInfo.wcdma.cellIdentityWcdma.lac;
7456                 cellInfoWcdma->cellIdentityWcdma.cid =
7457                         rillCellInfo->CellInfo.wcdma.cellIdentityWcdma.cid;
7458                 cellInfoWcdma->cellIdentityWcdma.psc =
7459                         rillCellInfo->CellInfo.wcdma.cellIdentityWcdma.psc;
7460                 cellInfoWcdma->cellIdentityWcdma.uarfcn =
7461                         rillCellInfo->CellInfo.wcdma.cellIdentityWcdma.uarfcn;
7462                 cellInfoWcdma->signalStrengthWcdma.signalStrength =
7463                         rillCellInfo->CellInfo.wcdma.signalStrengthWcdma.signalStrength;
7464                 cellInfoWcdma->signalStrengthWcdma.bitErrorRate =
7465                         rillCellInfo->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate;
7466                 break;
7467             }
7468
7469             case RIL_CELL_INFO_TYPE_CDMA: {
7470                 records[i].cdma.resize(1);
7471                 CellInfoCdma *cellInfoCdma = &records[i].cdma[0];
7472                 cellInfoCdma->cellIdentityCdma.networkId =
7473                         rillCellInfo->CellInfo.cdma.cellIdentityCdma.networkId;
7474                 cellInfoCdma->cellIdentityCdma.systemId =
7475                         rillCellInfo->CellInfo.cdma.cellIdentityCdma.systemId;
7476                 cellInfoCdma->cellIdentityCdma.baseStationId =
7477                         rillCellInfo->CellInfo.cdma.cellIdentityCdma.basestationId;
7478                 cellInfoCdma->cellIdentityCdma.longitude =
7479                         rillCellInfo->CellInfo.cdma.cellIdentityCdma.longitude;
7480                 cellInfoCdma->cellIdentityCdma.latitude =
7481                         rillCellInfo->CellInfo.cdma.cellIdentityCdma.latitude;
7482                 cellInfoCdma->signalStrengthCdma.dbm =
7483                         rillCellInfo->CellInfo.cdma.signalStrengthCdma.dbm;
7484                 cellInfoCdma->signalStrengthCdma.ecio =
7485                         rillCellInfo->CellInfo.cdma.signalStrengthCdma.ecio;
7486                 cellInfoCdma->signalStrengthEvdo.dbm =
7487                         rillCellInfo->CellInfo.cdma.signalStrengthEvdo.dbm;
7488                 cellInfoCdma->signalStrengthEvdo.ecio =
7489                         rillCellInfo->CellInfo.cdma.signalStrengthEvdo.ecio;
7490                 cellInfoCdma->signalStrengthEvdo.signalNoiseRatio =
7491                         rillCellInfo->CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio;
7492                 break;
7493             }
7494
7495             case RIL_CELL_INFO_TYPE_LTE: {
7496                 records[i].lte.resize(1);
7497                 CellInfoLte *cellInfoLte = &records[i].lte[0];
7498                 cellInfoLte->cellIdentityLte.mcc =
7499                         std::to_string(rillCellInfo->CellInfo.lte.cellIdentityLte.mcc);
7500                 cellInfoLte->cellIdentityLte.mnc =
7501                         std::to_string(rillCellInfo->CellInfo.lte.cellIdentityLte.mnc);
7502                 cellInfoLte->cellIdentityLte.ci =
7503                         rillCellInfo->CellInfo.lte.cellIdentityLte.ci;
7504                 cellInfoLte->cellIdentityLte.pci =
7505                         rillCellInfo->CellInfo.lte.cellIdentityLte.pci;
7506                 cellInfoLte->cellIdentityLte.tac =
7507                         rillCellInfo->CellInfo.lte.cellIdentityLte.tac;
7508                 cellInfoLte->cellIdentityLte.earfcn =
7509                         rillCellInfo->CellInfo.lte.cellIdentityLte.earfcn;
7510                 cellInfoLte->signalStrengthLte.signalStrength =
7511                         rillCellInfo->CellInfo.lte.signalStrengthLte.signalStrength;
7512                 cellInfoLte->signalStrengthLte.rsrp =
7513                         rillCellInfo->CellInfo.lte.signalStrengthLte.rsrp;
7514                 cellInfoLte->signalStrengthLte.rsrq =
7515                         rillCellInfo->CellInfo.lte.signalStrengthLte.rsrq;
7516                 cellInfoLte->signalStrengthLte.rssnr =
7517                         rillCellInfo->CellInfo.lte.signalStrengthLte.rssnr;
7518                 cellInfoLte->signalStrengthLte.cqi =
7519                         rillCellInfo->CellInfo.lte.signalStrengthLte.cqi;
7520                 cellInfoLte->signalStrengthLte.timingAdvance =
7521                         rillCellInfo->CellInfo.lte.signalStrengthLte.timingAdvance;
7522                 break;
7523             }
7524
7525             case RIL_CELL_INFO_TYPE_TD_SCDMA: {
7526                 records[i].tdscdma.resize(1);
7527                 CellInfoTdscdma *cellInfoTdscdma = &records[i].tdscdma[0];
7528                 cellInfoTdscdma->cellIdentityTdscdma.mcc =
7529                         std::to_string(rillCellInfo->CellInfo.tdscdma.cellIdentityTdscdma.mcc);
7530                 cellInfoTdscdma->cellIdentityTdscdma.mnc =
7531                         std::to_string(rillCellInfo->CellInfo.tdscdma.cellIdentityTdscdma.mnc);
7532                 cellInfoTdscdma->cellIdentityTdscdma.lac =
7533                         rillCellInfo->CellInfo.tdscdma.cellIdentityTdscdma.lac;
7534                 cellInfoTdscdma->cellIdentityTdscdma.cid =
7535                         rillCellInfo->CellInfo.tdscdma.cellIdentityTdscdma.cid;
7536                 cellInfoTdscdma->cellIdentityTdscdma.cpid =
7537                         rillCellInfo->CellInfo.tdscdma.cellIdentityTdscdma.cpid;
7538                 cellInfoTdscdma->signalStrengthTdscdma.rscp =
7539                         rillCellInfo->CellInfo.tdscdma.signalStrengthTdscdma.rscp;
7540                 break;
7541             }
7542             default: {
7543                 break;
7544             }
7545         }
7546         rillCellInfo += 1;
7547     }
7548 }
7549
7550 int radio::cellInfoListInd(int slotId,
7551                            int indicationType, int token, RIL_Errno e, void *response,
7552                            size_t responseLen) {
7553     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7554         if (response == NULL || responseLen % sizeof(RIL_CellInfo_v12) != 0) {
7555             RLOGE("cellInfoListInd: invalid response");
7556             return 0;
7557         }
7558
7559         hidl_vec<CellInfo> records;
7560         convertRilCellInfoListToHal(response, responseLen, records);
7561
7562 #if VDBG
7563         RLOGD("cellInfoListInd");
7564 #endif
7565         Return<void> retStatus = radioService[slotId]->mRadioIndication->cellInfoList(
7566                 convertIntToRadioIndicationType(indicationType), records);
7567         radioService[slotId]->checkReturnStatus(retStatus);
7568     } else {
7569         RLOGE("cellInfoListInd: radioService[%d]->mRadioIndication == NULL", slotId);
7570     }
7571
7572     return 0;
7573 }
7574
7575 int radio::imsNetworkStateChangedInd(int slotId,
7576                                      int indicationType, int token, RIL_Errno e, void *response,
7577                                      size_t responseLen) {
7578     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7579 #if VDBG
7580         RLOGD("imsNetworkStateChangedInd");
7581 #endif
7582         Return<void> retStatus = radioService[slotId]->mRadioIndication->imsNetworkStateChanged(
7583                 convertIntToRadioIndicationType(indicationType));
7584         radioService[slotId]->checkReturnStatus(retStatus);
7585     } else {
7586         RLOGE("imsNetworkStateChangedInd: radioService[%d]->mRadioIndication == NULL",
7587                 slotId);
7588     }
7589
7590     return 0;
7591 }
7592
7593 int radio::subscriptionStatusChangedInd(int slotId,
7594                                         int indicationType, int token, RIL_Errno e, void *response,
7595                                         size_t responseLen) {
7596     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7597         if (response == NULL || responseLen != sizeof(int)) {
7598             RLOGE("subscriptionStatusChangedInd: invalid response");
7599             return 0;
7600         }
7601         bool activate = ((int32_t *) response)[0];
7602 #if VDBG
7603         RLOGD("subscriptionStatusChangedInd: activate %d", activate);
7604 #endif
7605         Return<void> retStatus = radioService[slotId]->mRadioIndication->subscriptionStatusChanged(
7606                 convertIntToRadioIndicationType(indicationType), activate);
7607         radioService[slotId]->checkReturnStatus(retStatus);
7608     } else {
7609         RLOGE("subscriptionStatusChangedInd: radioService[%d]->mRadioIndication == NULL",
7610                 slotId);
7611     }
7612
7613     return 0;
7614 }
7615
7616 int radio::srvccStateNotifyInd(int slotId,
7617                                int indicationType, int token, RIL_Errno e, void *response,
7618                                size_t responseLen) {
7619     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7620         if (response == NULL || responseLen != sizeof(int)) {
7621             RLOGE("srvccStateNotifyInd: invalid response");
7622             return 0;
7623         }
7624         int32_t state = ((int32_t *) response)[0];
7625 #if VDBG
7626         RLOGD("srvccStateNotifyInd: rat %d", state);
7627 #endif
7628         Return<void> retStatus = radioService[slotId]->mRadioIndication->srvccStateNotify(
7629                 convertIntToRadioIndicationType(indicationType), (SrvccState) state);
7630         radioService[slotId]->checkReturnStatus(retStatus);
7631     } else {
7632         RLOGE("srvccStateNotifyInd: radioService[%d]->mRadioIndication == NULL", slotId);
7633     }
7634
7635     return 0;
7636 }
7637
7638 void convertRilHardwareConfigListToHal(void *response, size_t responseLen,
7639         hidl_vec<HardwareConfig>& records) {
7640     int num = responseLen / sizeof(RIL_HardwareConfig);
7641     records.resize(num);
7642
7643     RIL_HardwareConfig *rilHardwareConfig = (RIL_HardwareConfig *) response;
7644     for (int i = 0; i < num; i++) {
7645         records[i].type = (HardwareConfigType) rilHardwareConfig[i].type;
7646         records[i].uuid = convertCharPtrToHidlString(rilHardwareConfig[i].uuid);
7647         records[i].state = (HardwareConfigState) rilHardwareConfig[i].state;
7648         switch (rilHardwareConfig[i].type) {
7649             case RIL_HARDWARE_CONFIG_MODEM: {
7650                 records[i].modem.resize(1);
7651                 records[i].sim.resize(0);
7652                 HardwareConfigModem *hwConfigModem = &records[i].modem[0];
7653                 hwConfigModem->rat = rilHardwareConfig[i].cfg.modem.rat;
7654                 hwConfigModem->maxVoice = rilHardwareConfig[i].cfg.modem.maxVoice;
7655                 hwConfigModem->maxData = rilHardwareConfig[i].cfg.modem.maxData;
7656                 hwConfigModem->maxStandby = rilHardwareConfig[i].cfg.modem.maxStandby;
7657                 break;
7658             }
7659
7660             case RIL_HARDWARE_CONFIG_SIM: {
7661                 records[i].sim.resize(1);
7662                 records[i].modem.resize(0);
7663                 records[i].sim[0].modemUuid =
7664                         convertCharPtrToHidlString(rilHardwareConfig[i].cfg.sim.modemUuid);
7665                 break;
7666             }
7667         }
7668     }
7669 }
7670
7671 int radio::hardwareConfigChangedInd(int slotId,
7672                                     int indicationType, int token, RIL_Errno e, void *response,
7673                                     size_t responseLen) {
7674     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7675         if (response == NULL || responseLen % sizeof(RIL_HardwareConfig) != 0) {
7676             RLOGE("hardwareConfigChangedInd: invalid response");
7677             return 0;
7678         }
7679
7680         hidl_vec<HardwareConfig> configs;
7681         convertRilHardwareConfigListToHal(response, responseLen, configs);
7682
7683 #if VDBG
7684         RLOGD("hardwareConfigChangedInd");
7685 #endif
7686         Return<void> retStatus = radioService[slotId]->mRadioIndication->hardwareConfigChanged(
7687                 convertIntToRadioIndicationType(indicationType), configs);
7688         radioService[slotId]->checkReturnStatus(retStatus);
7689     } else {
7690         RLOGE("hardwareConfigChangedInd: radioService[%d]->mRadioIndication == NULL",
7691                 slotId);
7692     }
7693
7694     return 0;
7695 }
7696
7697 void convertRilRadioCapabilityToHal(void *response, size_t responseLen, RadioCapability& rc) {
7698     RIL_RadioCapability *rilRadioCapability = (RIL_RadioCapability *) response;
7699     rc.session = rilRadioCapability->session;
7700     rc.phase = (android::hardware::radio::V1_0::RadioCapabilityPhase) rilRadioCapability->phase;
7701     rc.raf = rilRadioCapability->rat;
7702     rc.logicalModemUuid = convertCharPtrToHidlString(rilRadioCapability->logicalModemUuid);
7703     rc.status = (android::hardware::radio::V1_0::RadioCapabilityStatus) rilRadioCapability->status;
7704 }
7705
7706 int radio::radioCapabilityIndicationInd(int slotId,
7707                                         int indicationType, int token, RIL_Errno e, void *response,
7708                                         size_t responseLen) {
7709     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7710         if (response == NULL || responseLen != sizeof(RIL_RadioCapability)) {
7711             RLOGE("radioCapabilityIndicationInd: invalid response");
7712             return 0;
7713         }
7714
7715         RadioCapability rc = {};
7716         convertRilRadioCapabilityToHal(response, responseLen, rc);
7717
7718 #if VDBG
7719         RLOGD("radioCapabilityIndicationInd");
7720 #endif
7721         Return<void> retStatus = radioService[slotId]->mRadioIndication->radioCapabilityIndication(
7722                 convertIntToRadioIndicationType(indicationType), rc);
7723         radioService[slotId]->checkReturnStatus(retStatus);
7724     } else {
7725         RLOGE("radioCapabilityIndicationInd: radioService[%d]->mRadioIndication == NULL",
7726                 slotId);
7727     }
7728
7729     return 0;
7730 }
7731
7732 bool isServiceTypeCfQuery(RIL_SsServiceType serType, RIL_SsRequestType reqType) {
7733     if ((reqType == SS_INTERROGATION) &&
7734         (serType == SS_CFU ||
7735          serType == SS_CF_BUSY ||
7736          serType == SS_CF_NO_REPLY ||
7737          serType == SS_CF_NOT_REACHABLE ||
7738          serType == SS_CF_ALL ||
7739          serType == SS_CF_ALL_CONDITIONAL)) {
7740         return true;
7741     }
7742     return false;
7743 }
7744
7745 int radio::onSupplementaryServiceIndicationInd(int slotId,
7746                                                int indicationType, int token, RIL_Errno e,
7747                                                void *response, size_t responseLen) {
7748     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7749         if (response == NULL || responseLen != sizeof(RIL_StkCcUnsolSsResponse)) {
7750             RLOGE("onSupplementaryServiceIndicationInd: invalid response");
7751             return 0;
7752         }
7753
7754         RIL_StkCcUnsolSsResponse *rilSsResponse = (RIL_StkCcUnsolSsResponse *) response;
7755         StkCcUnsolSsResult ss = {};
7756         ss.serviceType = (SsServiceType) rilSsResponse->serviceType;
7757         ss.requestType = (SsRequestType) rilSsResponse->requestType;
7758         ss.teleserviceType = (SsTeleserviceType) rilSsResponse->teleserviceType;
7759         ss.serviceClass = rilSsResponse->serviceClass;
7760         ss.result = (RadioError) rilSsResponse->result;
7761
7762         if (isServiceTypeCfQuery(rilSsResponse->serviceType, rilSsResponse->requestType)) {
7763 #if VDBG
7764             RLOGD("onSupplementaryServiceIndicationInd CF type, num of Cf elements %d",
7765                     rilSsResponse->cfData.numValidIndexes);
7766 #endif
7767             if (rilSsResponse->cfData.numValidIndexes > NUM_SERVICE_CLASSES) {
7768                 RLOGE("onSupplementaryServiceIndicationInd numValidIndexes is greater than "
7769                         "max value %d, truncating it to max value", NUM_SERVICE_CLASSES);
7770                 rilSsResponse->cfData.numValidIndexes = NUM_SERVICE_CLASSES;
7771             }
7772
7773             ss.cfData.resize(1);
7774             ss.ssInfo.resize(0);
7775
7776             /* number of call info's */
7777             ss.cfData[0].cfInfo.resize(rilSsResponse->cfData.numValidIndexes);
7778
7779             for (int i = 0; i < rilSsResponse->cfData.numValidIndexes; i++) {
7780                  RIL_CallForwardInfo cf = rilSsResponse->cfData.cfInfo[i];
7781                  CallForwardInfo *cfInfo = &ss.cfData[0].cfInfo[i];
7782
7783                  cfInfo->status = (CallForwardInfoStatus) cf.status;
7784                  cfInfo->reason = cf.reason;
7785                  cfInfo->serviceClass = cf.serviceClass;
7786                  cfInfo->toa = cf.toa;
7787                  cfInfo->number = convertCharPtrToHidlString(cf.number);
7788                  cfInfo->timeSeconds = cf.timeSeconds;
7789 #if VDBG
7790                  RLOGD("onSupplementaryServiceIndicationInd: "
7791                         "Data: %d,reason=%d,cls=%d,toa=%d,num=%s,tout=%d],", cf.status,
7792                         cf.reason, cf.serviceClass, cf.toa, (char*)cf.number, cf.timeSeconds);
7793 #endif
7794             }
7795         } else {
7796             ss.ssInfo.resize(1);
7797             ss.cfData.resize(0);
7798
7799             /* each int */
7800             ss.ssInfo[0].ssInfo.resize(SS_INFO_MAX);
7801             for (int i = 0; i < SS_INFO_MAX; i++) {
7802 #if VDBG
7803                  RLOGD("onSupplementaryServiceIndicationInd: Data: %d",
7804                         rilSsResponse->ssInfo[i]);
7805 #endif
7806                  ss.ssInfo[0].ssInfo[i] = rilSsResponse->ssInfo[i];
7807             }
7808         }
7809
7810 #if VDBG
7811         RLOGD("onSupplementaryServiceIndicationInd");
7812 #endif
7813         Return<void> retStatus = radioService[slotId]->mRadioIndication->
7814                 onSupplementaryServiceIndication(convertIntToRadioIndicationType(indicationType),
7815                 ss);
7816         radioService[slotId]->checkReturnStatus(retStatus);
7817     } else {
7818         RLOGE("onSupplementaryServiceIndicationInd: "
7819                 "radioService[%d]->mRadioIndication == NULL", slotId);
7820     }
7821
7822     return 0;
7823 }
7824
7825 int radio::stkCallControlAlphaNotifyInd(int slotId,
7826                                         int indicationType, int token, RIL_Errno e, void *response,
7827                                         size_t responseLen) {
7828     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7829         if (response == NULL || responseLen == 0) {
7830             RLOGE("stkCallControlAlphaNotifyInd: invalid response");
7831             return 0;
7832         }
7833 #if VDBG
7834         RLOGD("stkCallControlAlphaNotifyInd");
7835 #endif
7836         Return<void> retStatus = radioService[slotId]->mRadioIndication->stkCallControlAlphaNotify(
7837                 convertIntToRadioIndicationType(indicationType),
7838                 convertCharPtrToHidlString((char *) response));
7839         radioService[slotId]->checkReturnStatus(retStatus);
7840     } else {
7841         RLOGE("stkCallControlAlphaNotifyInd: radioService[%d]->mRadioIndication == NULL",
7842                 slotId);
7843     }
7844
7845     return 0;
7846 }
7847
7848 void convertRilLceDataInfoToHal(void *response, size_t responseLen, LceDataInfo& lce) {
7849     RIL_LceDataInfo *rilLceDataInfo = (RIL_LceDataInfo *)response;
7850     lce.lastHopCapacityKbps = rilLceDataInfo->last_hop_capacity_kbps;
7851     lce.confidenceLevel = rilLceDataInfo->confidence_level;
7852     lce.lceSuspended = rilLceDataInfo->lce_suspended;
7853 }
7854
7855 int radio::lceDataInd(int slotId,
7856                       int indicationType, int token, RIL_Errno e, void *response,
7857                       size_t responseLen) {
7858     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7859         if (response == NULL || responseLen != sizeof(RIL_LceDataInfo)) {
7860             RLOGE("lceDataInd: invalid response");
7861             return 0;
7862         }
7863
7864         LceDataInfo lce = {};
7865         convertRilLceDataInfoToHal(response, responseLen, lce);
7866 #if VDBG
7867         RLOGD("lceDataInd");
7868 #endif
7869         Return<void> retStatus = radioService[slotId]->mRadioIndication->lceData(
7870                 convertIntToRadioIndicationType(indicationType), lce);
7871         radioService[slotId]->checkReturnStatus(retStatus);
7872     } else {
7873         RLOGE("lceDataInd: radioService[%d]->mRadioIndication == NULL", slotId);
7874     }
7875
7876     return 0;
7877 }
7878
7879 int radio::pcoDataInd(int slotId,
7880                       int indicationType, int token, RIL_Errno e, void *response,
7881                       size_t responseLen) {
7882     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7883         if (response == NULL || responseLen != sizeof(RIL_PCO_Data)) {
7884             RLOGE("pcoDataInd: invalid response");
7885             return 0;
7886         }
7887
7888         PcoDataInfo pco = {};
7889         RIL_PCO_Data *rilPcoData = (RIL_PCO_Data *)response;
7890         pco.cid = rilPcoData->cid;
7891         pco.bearerProto = convertCharPtrToHidlString(rilPcoData->bearer_proto);
7892         pco.pcoId = rilPcoData->pco_id;
7893         pco.contents.setToExternal((uint8_t *) rilPcoData->contents, rilPcoData->contents_length);
7894
7895 #if VDBG
7896         RLOGD("pcoDataInd");
7897 #endif
7898         Return<void> retStatus = radioService[slotId]->mRadioIndication->pcoData(
7899                 convertIntToRadioIndicationType(indicationType), pco);
7900         radioService[slotId]->checkReturnStatus(retStatus);
7901     } else {
7902         RLOGE("pcoDataInd: radioService[%d]->mRadioIndication == NULL", slotId);
7903     }
7904
7905     return 0;
7906 }
7907
7908 int radio::modemResetInd(int slotId,
7909                          int indicationType, int token, RIL_Errno e, void *response,
7910                          size_t responseLen) {
7911     if (radioService[slotId] != NULL && radioService[slotId]->mRadioIndication != NULL) {
7912         if (response == NULL || responseLen == 0) {
7913             RLOGE("modemResetInd: invalid response");
7914             return 0;
7915         }
7916 #if VDBG
7917         RLOGD("modemResetInd");
7918 #endif
7919         Return<void> retStatus = radioService[slotId]->mRadioIndication->modemReset(
7920                 convertIntToRadioIndicationType(indicationType),
7921                 convertCharPtrToHidlString((char *) response));
7922         radioService[slotId]->checkReturnStatus(retStatus);
7923     } else {
7924         RLOGE("modemResetInd: radioService[%d]->mRadioIndication == NULL", slotId);
7925     }
7926
7927     return 0;
7928 }
7929
7930 int radio::oemHookRawInd(int slotId,
7931                          int indicationType, int token, RIL_Errno e, void *response,
7932                          size_t responseLen) {
7933     if (oemHookService[slotId] != NULL && oemHookService[slotId]->mOemHookIndication != NULL) {
7934         if (response == NULL || responseLen == 0) {
7935             RLOGE("oemHookRawInd: invalid response");
7936             return 0;
7937         }
7938
7939         hidl_vec<uint8_t> data;
7940         data.setToExternal((uint8_t *) response, responseLen);
7941 #if VDBG
7942         RLOGD("oemHookRawInd");
7943 #endif
7944         Return<void> retStatus = oemHookService[slotId]->mOemHookIndication->oemHookRaw(
7945                 convertIntToRadioIndicationType(indicationType), data);
7946         checkReturnStatus(slotId, retStatus, false);
7947     } else {
7948         RLOGE("oemHookRawInd: oemHookService[%d]->mOemHookIndication == NULL", slotId);
7949     }
7950
7951     return 0;
7952 }
7953
7954 void radio::registerService(RIL_RadioFunctions *callbacks, CommandInfo *commands) {
7955     using namespace android::hardware;
7956     int simCount = 1;
7957     const char *serviceNames[] = {
7958             android::RIL_getServiceName()
7959             #if (SIM_COUNT >= 2)
7960             , RIL2_SERVICE_NAME
7961             #if (SIM_COUNT >= 3)
7962             , RIL3_SERVICE_NAME
7963             #if (SIM_COUNT >= 4)
7964             , RIL4_SERVICE_NAME
7965             #endif
7966             #endif
7967             #endif
7968             };
7969
7970     #if (SIM_COUNT >= 2)
7971     simCount = SIM_COUNT;
7972     #endif
7973
7974     configureRpcThreadpool(1, true /* callerWillJoin */);
7975     for (int i = 0; i < simCount; i++) {
7976         pthread_rwlock_t *radioServiceRwlockPtr = getRadioServiceRwlock(i);
7977         int ret = pthread_rwlock_wrlock(radioServiceRwlockPtr);
7978         assert(ret == 0);
7979
7980         radioService[i] = new RadioImpl;
7981         radioService[i]->mSlotId = i;
7982         oemHookService[i] = new OemHookImpl;
7983         oemHookService[i]->mSlotId = i;
7984         RLOGD("registerService: starting IRadio %s", serviceNames[i]);
7985         android::status_t status = radioService[i]->registerAsService(serviceNames[i]);
7986         status = oemHookService[i]->registerAsService(serviceNames[i]);
7987
7988         ret = pthread_rwlock_unlock(radioServiceRwlockPtr);
7989         assert(ret == 0);
7990     }
7991
7992     s_vendorFunctions = callbacks;
7993     s_commands = commands;
7994 }
7995
7996 void rilc_thread_pool() {
7997     joinRpcThreadpool();
7998 }
7999
8000 pthread_rwlock_t * radio::getRadioServiceRwlock(int slotId) {
8001     pthread_rwlock_t *radioServiceRwlockPtr = &radioServiceRwlock;
8002
8003     #if (SIM_COUNT >= 2)
8004     if (slotId == 2) radioServiceRwlockPtr = &radioServiceRwlock2;
8005     #if (SIM_COUNT >= 3)
8006     if (slotId == 3) radioServiceRwlockPtr = &radioServiceRwlock3;
8007     #if (SIM_COUNT >= 4)
8008     if (slotId == 4) radioServiceRwlockPtr = &radioServiceRwlock4;
8009     #endif
8010     #endif
8011     #endif
8012
8013     return radioServiceRwlockPtr;
8014 }