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