• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2 ** Copyright 2017, 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 ioogle/s 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 #include "guest/hals/ril/vsoc_ril.h"
18 
19 #include <cutils/properties.h>
20 #include <string.h>
21 #include <sys/types.h>
22 #include <time.h>
23 
24 #include <map>
25 #include <set>
26 #include <string>
27 #include <vector>
28 
29 #include "common/libs/net/netlink_client.h"
30 #include "common/libs/net/network_interface.h"
31 #include "common/libs/net/network_interface_manager.h"
32 #include "common/vsoc/lib/ril_region_view.h"
33 #include "guest/libs/platform_support/api_level_fixes.h"
34 
35 #define VSOC_RIL_VERSION_STRING "Android VSoC RIL 1.0"
36 
37 /* Modem Technology bits */
38 #define MDM_GSM 0x01
39 #define MDM_WCDMA 0x02
40 #define MDM_CDMA 0x04
41 #define MDM_EVDO 0x08
42 #define MDM_LTE 0x10
43 
44 #if VSOC_PLATFORM_SDK_BEFORE(K)
45 #define RADIO_TECH_3GPP 1
46 #define RADIO_TECH_3GPP2 2
47 #endif
48 
49 typedef enum {
50   SIM_ABSENT = 0,
51   SIM_NOT_READY = 1,
52   SIM_READY = 2,  // SIM_READY means the radio state is RADIO_STATE_SIM_READY
53   SIM_PIN = 3,
54   SIM_PUK = 4,
55   SIM_NETWORK_PERSONALIZATION = 5,
56   RUIM_ABSENT = 6,
57   RUIM_NOT_READY = 7,
58   RUIM_READY = 8,
59   RUIM_PIN = 9,
60   RUIM_PUK = 10,
61   RUIM_NETWORK_PERSONALIZATION = 11
62 } SIM_Status;
63 
64 static const struct RIL_Env* gce_ril_env;
65 
66 static const struct timeval TIMEVAL_SIMPOLL = {3, 0};
67 
68 static time_t gce_ril_start_time;
69 
70 static void pollSIMState(void* param);
71 
72 RIL_RadioState gRadioPowerState = RADIO_STATE_OFF;
73 
74 struct DataCall {
75   enum AllowedAuthenticationType { kNone = 0, kPap = 1, kChap = 2, kBoth = 3 };
76 
77   enum ConnectionType {
78     kConnTypeIPv4,
79     kConnTypeIPv6,
80     kConnTypeIPv4v6,
81     kConnTypePPP
82   };
83 
84   enum LinkState {
85     kLinkStateInactive = 0,
86     kLinkStateDown = 1,
87     kLinkStateUp = 2,
88   };
89 
90   RIL_RadioTechnology technology_;
91   RIL_DataProfile profile_;
92   std::string access_point_;
93   std::string username_;
94   std::string password_;
95   AllowedAuthenticationType auth_type_;
96   ConnectionType connection_type_;
97   LinkState link_state_;
98   RIL_DataCallFailCause fail_cause_;
99   std::string other_properties_;
100 };
101 
102 static std::string gSimPIN = "0000";
103 static const std::string gSimPUK = "11223344";
104 static int gSimPINAttempts = 0;
105 static const int gSimPINAttemptsMax = 3;
106 static SIM_Status gSimStatus = SIM_NOT_READY;
107 
108 // SetUpNetworkInterface configures IP and Broadcast addresses on a RIL
109 // controlled network interface.
110 // This call returns true, if operation was successful.
111 bool SetUpNetworkInterface(const char* ipaddr, int prefixlen,
112                            const char* bcaddr) {
113   auto factory = cvd::NetlinkClientFactory::Default();
114   std::unique_ptr<cvd::NetlinkClient> nl(factory->New(NETLINK_ROUTE));
115   std::unique_ptr<cvd::NetworkInterfaceManager> nm(
116       cvd::NetworkInterfaceManager::New(factory));
117   std::unique_ptr<cvd::NetworkInterface> ni(nm->Open("rmnet0", "eth0"));
118 
119   if (ni) {
120     ni->SetName("rmnet0");
121     ni->SetAddress(ipaddr);
122     ni->SetBroadcastAddress(bcaddr);
123     ni->SetPrefixLength(prefixlen);
124     ni->SetOperational(true);
125     bool res = nm->ApplyChanges(*ni);
126     if (!res) ALOGE("Could not configure rmnet0");
127     return res;
128   }
129   return false;
130 }
131 
132 // TearDownNetworkInterface disables network interface.
133 // This call returns true, if operation was successful.
134 bool TearDownNetworkInterface() {
135   auto nm(cvd::NetworkInterfaceManager::New(nullptr));
136   auto ni(nm->Open("rmnet0", "eth0"));
137 
138   if (ni) {
139     ni->SetOperational(false);
140     bool res = nm->ApplyChanges(*ni);
141     if (!res) ALOGE("Could not disable rmnet0");
142     return res;
143   }
144   return false;
145 }
146 
147 static int gNextDataCallId = 8;
148 static std::map<int, DataCall> gDataCalls;
149 static bool gRilConnected = false;
150 
151 static int request_or_send_data_calllist(RIL_Token* t) {
152 #if VSOC_PLATFORM_SDK_AFTER(N_MR1)
153   RIL_Data_Call_Response_v11* responses =
154       new RIL_Data_Call_Response_v11[gDataCalls.size()];
155 #else
156   RIL_Data_Call_Response_v6* responses =
157       new RIL_Data_Call_Response_v6[gDataCalls.size()];
158 #endif
159 
160   int index = 0;
161 
162   ALOGV("Query data call list: %zu data calls tracked.", gDataCalls.size());
163 
164   for (std::map<int, DataCall>::iterator iter = gDataCalls.begin();
165        iter != gDataCalls.end(); ++iter, ++index) {
166     responses[index].status = iter->second.fail_cause_;
167     responses[index].suggestedRetryTime = -1;
168     responses[index].cid = iter->first;
169     responses[index].active = iter->second.link_state_;
170 
171     switch (iter->second.connection_type_) {
172       case DataCall::kConnTypeIPv4:
173         responses[index].type = (char*)"IP";
174         break;
175       case DataCall::kConnTypeIPv6:
176         responses[index].type = (char*)"IPV6";
177         break;
178       case DataCall::kConnTypeIPv4v6:
179         responses[index].type = (char*)"IPV4V6";
180         break;
181       case DataCall::kConnTypePPP:
182         responses[index].type = (char*)"PPP";
183         break;
184       default:
185         responses[index].type = (char*)"IP";
186         break;
187     }
188 
189     auto ril_region_view = vsoc::ril::RilRegionView::GetInstance();
190 
191     responses[index].ifname = (char*)"rmnet0";
192     responses[index].addresses =
193       const_cast<char*>(ril_region_view->address_and_prefix_length());
194     responses[index].dnses = (char*)ril_region_view->data()->dns;
195     responses[index].gateways = (char*)ril_region_view->data()->gateway;
196 #if VSOC_PLATFORM_SDK_AFTER(N_MR1)
197     responses[index].pcscf = (char*)"";
198     responses[index].mtu = 1440;
199 #endif
200   }
201 
202   bool new_conn_state = (gDataCalls.size() > 0);
203 
204   if (gRilConnected != new_conn_state) {
205     time_t curr_time;
206     time(&curr_time);
207     double diff_in_secs = difftime(curr_time, gce_ril_start_time);
208 
209     gRilConnected = new_conn_state;
210 
211     if (new_conn_state) {
212       ALOGV("MOBILE_DATA_CONNECTED %.2lf seconds", diff_in_secs);
213     } else {
214       ALOGV("MOBILE_DATA_DISCONNECTED %.2lf seconds", diff_in_secs);
215     }
216 
217     if (property_set("ril.net_connected", new_conn_state ? "1" : "0")) {
218       ALOGE("Couldn't set a system property ril.net_connected.");
219     }
220   }
221 
222   if (t != NULL) {
223     gce_ril_env->OnRequestComplete(*t, RIL_E_SUCCESS, responses,
224                                    gDataCalls.size() * sizeof(*responses));
225   } else {
226     gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED,
227                                        responses,
228                                        gDataCalls.size() * sizeof(*responses));
229   }
230   delete[] responses;
231   return 0;
232 }
233 
234 static void request_datacall_fail_cause(RIL_Token t) {
235   RIL_DataCallFailCause fail = PDP_FAIL_DATA_REGISTRATION_FAIL;
236 
237   if (gDataCalls.size() > 0) {
238     fail = gDataCalls.rbegin()->second.fail_cause_;
239   }
240 
241   ALOGV("Requesting last data call setup fail cause (%d)", fail);
242   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &fail, sizeof(fail));
243 };
244 
245 static void request_data_calllist(void* /*data*/, size_t /*datalen*/,
246                                   RIL_Token t) {
247   request_or_send_data_calllist(&t);
248 }
249 
250 static void request_setup_data_call(void* data, size_t datalen, RIL_Token t) {
251   char** details = static_cast<char**>(data);
252   const size_t fields = datalen / sizeof(details[0]);
253 
254   // There are two different versions of this interface, one providing 7 strings
255   // and the other providing 8. The code below will assume the presence of 7
256   // strings in all cases, so bail out here if things appear to be wrong. We
257   // protect the 8 string case below.
258   if (fields < 7) {
259     ALOGE("%s returning: called with small datalen %zu", __FUNCTION__, datalen);
260     return;
261   }
262   DataCall call;
263   int tech = atoi(details[0]);
264   switch (tech) {
265     case 0:
266     case 2 + RADIO_TECH_1xRTT:
267       call.technology_ = RADIO_TECH_1xRTT;
268       break;
269 
270     case 1:
271     case 2 + RADIO_TECH_EDGE:
272       call.technology_ = RADIO_TECH_EDGE;
273       break;
274 
275     default:
276       call.technology_ = RIL_RadioTechnology(tech - 2);
277       break;
278   }
279 
280   int profile = atoi(details[1]);
281   call.profile_ = RIL_DataProfile(profile);
282 
283   if (details[2]) call.access_point_ = details[2];
284   if (details[3]) call.username_ = details[3];
285   if (details[4]) call.password_ = details[4];
286 
287   int auth_type = atoi(details[5]);
288   call.auth_type_ = DataCall::AllowedAuthenticationType(auth_type);
289 
290   if (!strcmp("IP", details[6])) {
291     call.connection_type_ = DataCall::kConnTypeIPv4;
292   } else if (!strcmp("IPV6", details[6])) {
293     call.connection_type_ = DataCall::kConnTypeIPv6;
294   } else if (!strcmp("IPV4V6", details[6])) {
295     call.connection_type_ = DataCall::kConnTypeIPv4v6;
296   } else if (!strcmp("PPP", details[6])) {
297     call.connection_type_ = DataCall::kConnTypePPP;
298   } else {
299     ALOGW("Unknown / unsupported connection type %s. Falling back to IPv4",
300           details[6]);
301     call.connection_type_ = DataCall::kConnTypeIPv4;
302   }
303 
304   if (call.connection_type_ != DataCall::kConnTypeIPv4) {
305     ALOGE("Non-IPv4 connections are not supported by VSOC RIL.");
306     gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
307     return;
308   }
309 
310   call.link_state_ = DataCall::kLinkStateUp;
311   call.fail_cause_ = PDP_FAIL_NONE;
312   if (fields > 7) {
313     if (details[7]) call.other_properties_ = details[7];
314   }
315 
316   if (gDataCalls.empty()) {
317     auto ril_region_view = vsoc::ril::RilRegionView::GetInstance();
318     SetUpNetworkInterface(ril_region_view->data()->ipaddr,
319                           ril_region_view->data()->prefixlen,
320                           ril_region_view->data()->broadcast);
321   }
322 
323   gDataCalls[gNextDataCallId] = call;
324   gNextDataCallId++;
325 
326   ALOGV("Requesting data call setup to APN %s, technology %s, prof %s",
327         details[2], details[0], details[1]);
328 
329   request_or_send_data_calllist(&t);
330 
331   gRilConnected = (gDataCalls.size() > 0);
332 }
333 
334 static void request_teardown_data_call(void* data, size_t /*datalen*/,
335                                        RIL_Token t) {
336   char** data_strs = (char**)data;
337   int call_id = atoi(data_strs[0]);
338   int reason = atoi(data_strs[1]);
339 
340   ALOGV("Tearing down data call %d, reason: %d", call_id, reason);
341 
342   gDataCalls.erase(call_id);
343   gRilConnected = (gDataCalls.size() > 0);
344 
345   if (!gRilConnected) {
346     TearDownNetworkInterface();
347   }
348   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
349 }
350 
351 static void set_radio_state(RIL_RadioState new_state, RIL_Token t) {
352   // From header:
353   // Toggle radio on and off (for "airplane" mode)
354   // If the radio is is turned off/on the radio modem subsystem
355   // is expected return to an initialized state. For instance,
356   // any voice and data calls will be terminated and all associated
357   // lists emptied.
358   gDataCalls.clear();
359 
360   gSimStatus = SIM_NOT_READY;
361   ALOGV("RIL_RadioState change %d to %d", gRadioPowerState, new_state);
362   gRadioPowerState = new_state;
363 
364   if (new_state == RADIO_STATE_OFF) {
365     TearDownNetworkInterface();
366   }
367 
368   if (t != NULL) {
369     gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
370   }
371 
372   gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
373                                      NULL, 0);
374 
375   pollSIMState(NULL);
376 }
377 
378 // returns 1 if on, 0 if off, and -1 on error
379 static void request_radio_power(void* data, size_t /*datalen*/, RIL_Token t) {
380   int on = ((int*)data)[0];
381   set_radio_state(on ? RADIO_STATE_ON : RADIO_STATE_OFF, t);
382 }
383 
384 // TODO(ender): this should be a class member. Move where it belongs.
385 struct CallState {
386   RIL_CallState state;  // e.g. RIL_CALL_HOLDING;
387   bool isInternational;
388   bool isMobileTerminated;
389   bool isVoice;
390   bool isMultiParty;
391 
392   std::string number;
393   std::string name;
394   std::string dtmf;
395 
396   bool canPresentNumber;
397   bool canPresentName;
398 
399   CallState()
400       : state(RIL_CallState(0)),
401         isInternational(false),
402         isMobileTerminated(true),
403         isVoice(true),
404         isMultiParty(false),
405         canPresentNumber(true),
406         canPresentName(true) {}
407 
408   CallState(const std::string& number)
409       : state(RIL_CALL_INCOMING),
410         isInternational(false),
411         isMobileTerminated(true),
412         isVoice(true),
413         isMultiParty(false),
414         number(number),
415         name(number),
416         canPresentNumber(true),
417         canPresentName(true) {}
418 
419   bool isBackground() { return state == RIL_CALL_HOLDING; }
420 
421   bool isActive() { return state == RIL_CALL_ACTIVE; }
422 
423   bool isDialing() { return state == RIL_CALL_DIALING; }
424 
425   bool isIncoming() { return state == RIL_CALL_INCOMING; }
426 
427   bool isWaiting() { return state == RIL_CALL_WAITING; }
428 
429   void addDtmfDigit(char c) {
430     dtmf.push_back(c);
431     ALOGV("Call to %s: DTMF %s", number.c_str(), dtmf.c_str());
432   }
433 
434   bool makeBackground() {
435     if (state == RIL_CALL_ACTIVE) {
436       state = RIL_CALL_HOLDING;
437       return true;
438     }
439 
440     return false;
441   }
442 
443   bool makeActive() {
444     if (state == RIL_CALL_INCOMING || state == RIL_CALL_WAITING ||
445         state == RIL_CALL_DIALING || state == RIL_CALL_HOLDING) {
446       state = RIL_CALL_ACTIVE;
447       return true;
448     }
449 
450     return false;
451   }
452 };
453 
454 static int gLastActiveCallIndex = 1;
455 static int gMicrophoneMute = 0;
456 static std::map<int, CallState> gActiveCalls;
457 
458 static void request_get_current_calls(void* /*data*/, size_t /*datalen*/,
459                                       RIL_Token t) {
460   const int countCalls = gActiveCalls.size();
461 
462   RIL_Call** pp_calls = (RIL_Call**)alloca(countCalls * sizeof(RIL_Call*));
463   RIL_Call* p_calls = (RIL_Call*)alloca(countCalls * sizeof(RIL_Call));
464 
465   memset(p_calls, 0, countCalls * sizeof(RIL_Call));
466 
467   /* init the pointer array */
468   for (int i = 0; i < countCalls; i++) {
469     pp_calls[i] = &(p_calls[i]);
470   }
471 
472   // TODO(ender): This should be built from calls requested via RequestDial.
473   for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
474        iter != gActiveCalls.end(); ++iter, ++p_calls) {
475     p_calls->state = iter->second.state;
476     p_calls->index = iter->first;
477     p_calls->toa = iter->second.isInternational ? 145 : 129;
478     p_calls->isMpty = iter->second.isMultiParty;
479     p_calls->isMT = iter->second.isMobileTerminated;
480     p_calls->als = iter->first;
481     p_calls->isVoice = iter->second.isVoice;
482     p_calls->isVoicePrivacy = 0;
483     p_calls->number = strdup(iter->second.number.c_str());
484     p_calls->numberPresentation = iter->second.canPresentNumber ? 0 : 1;
485     p_calls->name = strdup(iter->second.name.c_str());
486     p_calls->namePresentation = iter->second.canPresentName ? 0 : 1;
487     p_calls->uusInfo = NULL;
488 
489     ALOGV("Call to %s (%s): voice=%d mt=%d type=%d state=%d index=%d",
490           p_calls->name, p_calls->number, p_calls->isVoice, p_calls->isMT,
491           p_calls->toa, p_calls->state, p_calls->index);
492   }
493 
494   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, pp_calls,
495                                  countCalls * sizeof(RIL_Call*));
496 
497   ALOGV("Get Current calls: %d calls found.\n", countCalls);
498 }
499 
500 static void simulate_pending_calls_answered(void* /*ignore*/) {
501   ALOGV("Simulating outgoing call answered.");
502   // This also resumes held calls.
503   for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
504        iter != gActiveCalls.end(); ++iter) {
505     if (iter->second.isDialing()) {
506       iter->second.makeActive();
507     }
508   }
509 
510   // Only unsolicited here.
511   gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED,
512                                      NULL, 0);
513 }
514 
515 static void request_dial(void* data, size_t /*datalen*/, RIL_Token t) {
516   RIL_Dial* p_dial = (RIL_Dial*)data;
517 
518   ALOGV("Dialing %s, number presentation is %s.", p_dial->address,
519         (p_dial->clir == 0) ? "defined by operator"
520                             : (p_dial->clir == 1) ? "allowed" : "restricted");
521 
522   CallState state(p_dial->address);
523   state.isMobileTerminated = false;
524   state.state = RIL_CALL_DIALING;
525 
526   switch (p_dial->clir) {
527     case 0:  // default
528     case 1:  // allow
529       state.canPresentNumber = true;
530       break;
531 
532     case 2:  // restrict
533       state.canPresentNumber = false;
534       break;
535   }
536 
537   int call_index = gLastActiveCallIndex++;
538   gActiveCalls[call_index] = state;
539 
540   static const struct timeval kAnswerTime = {5, 0};
541   gce_ril_env->RequestTimedCallback(simulate_pending_calls_answered, NULL,
542                                     &kAnswerTime);
543 
544   // success or failure is ignored by the upper layer here.
545   // it will call GET_CURRENT_CALLS and determine success that way
546   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
547 }
548 
549 void request_set_mute(void* data, size_t /*datalen*/, RIL_Token t) {
550   gMicrophoneMute = ((int*)data)[0] != 0;
551   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
552 }
553 
554 void request_get_mute(RIL_Token t) {
555   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &gMicrophoneMute,
556                                  sizeof(gMicrophoneMute));
557 }
558 
559 // TODO(ender): this should be a class member. Move where it belongs.
560 struct SmsMessage {
561   enum SmsStatus { kUnread = 0, kRead = 1, kUnsent = 2, kSent = 3 };
562 
563   std::string message;
564   SmsStatus status;
565 };
566 
567 static int gNextMessageId = 1;
568 static std::map<int, SmsMessage> gMessagesOnSimCard;
569 
570 static void request_write_sms_to_sim(void* data, size_t /*datalen*/,
571                                      RIL_Token t) {
572   RIL_SMS_WriteArgs* p_args = (RIL_SMS_WriteArgs*)data;
573 
574   SmsMessage message;
575   message.status = SmsMessage::SmsStatus(p_args->status);
576   message.message = p_args->pdu;
577 
578   ALOGV("Storing SMS message: '%s' with state: %s.", message.message.c_str(),
579         (message.status < SmsMessage::kUnsent)
580             ? ((message.status == SmsMessage::kRead) ? "READ" : "UNREAD")
581             : ((message.status == SmsMessage::kSent) ? "SENT" : "UNSENT"));
582 
583   // TODO(ender): simulate SIM FULL?
584   int index = gNextMessageId++;
585   gMessagesOnSimCard[index] = message;
586 
587   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &index, sizeof(index));
588 }
589 
590 static void request_delete_sms_on_sim(void* data, size_t /*datalen*/,
591                                       RIL_Token t) {
592   int index = *(int*)data;
593 
594   ALOGV("Delete SMS message %d", index);
595 
596   if (gMessagesOnSimCard.erase(index) == 0) {
597     // No such message
598     gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
599     return;
600   }
601 
602   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
603 }
604 
605 static void request_hangup(void* data, size_t /*datalen*/, RIL_Token t) {
606   int* p_line = (int*)data;
607 
608   ALOGV("Hanging up call %d.", *p_line);
609   std::map<int, CallState>::iterator iter = gActiveCalls.find(*p_line);
610 
611   if (iter == gActiveCalls.end()) {
612     ALOGV("No such call: %d.", *p_line);
613     gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
614   } else {
615     gActiveCalls.erase(iter);
616     gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
617   }
618 }
619 
620 static void request_hangup_waiting(void* /*data*/, size_t /*datalen*/,
621                                    RIL_Token t) {
622   ALOGV("Hanging up background/held calls.");
623   for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
624        iter != gActiveCalls.end();) {
625     if (iter->second.isBackground()) {
626       // C++98 -- std::map::erase doesn't return iterator.
627       std::map<int, CallState>::iterator temp = iter++;
628       gActiveCalls.erase(temp);
629     } else {
630       ++iter;
631     }
632   }
633   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
634 }
635 
636 static void request_hangup_current(RIL_Token t) {
637   ALOGV("Hanging up foreground/active calls.");
638   // This also resumes held calls.
639   for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
640        iter != gActiveCalls.end();) {
641     if (iter->second.isBackground()) {
642       iter->second.makeActive();
643       ++iter;
644     } else {
645       // C++98 -- std::map::erase doesn't return iterator.
646       std::map<int, CallState>::iterator temp = iter++;
647       gActiveCalls.erase(temp);
648     }
649   }
650   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
651 }
652 
653 static void request_switch_current_and_waiting(RIL_Token t) {
654   ALOGV("Toggle foreground and background calls.");
655   // TODO(ender): fix all states. Max 2 calls.
656   //   BEFORE                               AFTER
657   // Call 1   Call 2                 Call 1       Call 2
658   // ACTIVE   HOLDING                HOLDING     ACTIVE
659   // ACTIVE   WAITING                HOLDING     ACTIVE
660   // HOLDING  WAITING                HOLDING     ACTIVE
661   // ACTIVE   IDLE                   HOLDING     IDLE
662   // IDLE     IDLE                   IDLE        IDLE
663   for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
664        iter != gActiveCalls.end(); ++iter) {
665     // TODO(ender): call could also be waiting or dialing or...
666     if (iter->second.isBackground()) {
667       iter->second.makeActive();
668     } else {
669       iter->second.makeBackground();
670     }
671   }
672   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
673 }
674 
675 static void request_answer_incoming(RIL_Token t) {
676   ALOGV("Answering incoming call.");
677 
678   // There's two types of incoming calls:
679   // - incoming: we are receiving this call while nothing happens,
680   // - waiting: we are receiving this call while we're already talking.
681   // We only accept the incoming ones.
682   for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
683        iter != gActiveCalls.end(); ++iter) {
684     if (iter->second.isIncoming()) {
685       iter->second.makeActive();
686     }
687   }
688   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
689 }
690 
691 static void request_combine_multiparty_call(void* /*data*/, size_t /*datalen*/,
692                                             RIL_Token t) {
693   ALOGW("Conference calls are not supported.");
694   gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
695 }
696 
697 static void request_split_multiparty_call(void* /*data*/, size_t /*datalen*/,
698                                           RIL_Token t) {
699   ALOGW("Conference calls are not supported.");
700   gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
701 }
702 
703 static void request_udub_on_incoming_calls(RIL_Token t) {
704   // UDUB = user determined user busy.
705   // We don't exactly do that. We simply drop these calls.
706   ALOGV("Reporting busy signal to incoming calls.");
707   for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
708        iter != gActiveCalls.end();) {
709     // If we have an incoming call, there should be no waiting call.
710     // If we have a waiting call, then previous incoming call has been answered.
711     if (iter->second.isIncoming() || iter->second.isWaiting()) {
712       // C++98 -- std::map::erase doesn't return iterator.
713       std::map<int, CallState>::iterator temp = iter++;
714       gActiveCalls.erase(temp);
715     } else {
716       ++iter;
717     }
718   }
719   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
720 }
721 
722 static void request_send_dtmf(void* data, size_t /*datalen*/, RIL_Token t) {
723   char c = ((char*)data)[0];
724   ALOGV("Sending DTMF digit '%c'", c);
725 
726   for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
727        iter != gActiveCalls.end(); ++iter) {
728     if (iter->second.isActive()) {
729       iter->second.addDtmfDigit(c);
730       break;
731     }
732   }
733 
734   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
735 }
736 
737 static void request_send_dtmf_stop(RIL_Token t) {
738   ALOGV("DTMF tone end.");
739 
740   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
741 }
742 
743 // Check SignalStrength.java file for more details on how these map to signal
744 // strength bars.
745 const int kGatewaySignalStrengthMin = 4;
746 const int kGatewaySignalStrengthMax = 30;
747 const int kCDMASignalStrengthMin = -110;
748 const int kCDMASignalStrengthMax = -60;
749 const int kEVDOSignalStrengthMin = -160;
750 const int kEVDOSignalStrengthMax = -70;
751 const int kLTESignalStrengthMin = 4;
752 const int kLTESignalStrengthMax = 30;
753 
754 static int gGatewaySignalStrength = kGatewaySignalStrengthMax;
755 static int gCDMASignalStrength = kCDMASignalStrengthMax;
756 static int gEVDOSignalStrength = kEVDOSignalStrengthMax;
757 static int gLTESignalStrength = kLTESignalStrengthMax;
758 
759 static void request_signal_strength(void* /*data*/, size_t /*datalen*/,
760                                     RIL_Token t) {
761   // TODO(ender): possible to support newer APIs here.
762 #if VSOC_PLATFORM_SDK_AFTER(N_MR1)
763   RIL_SignalStrength_v10 strength;
764 #else
765   RIL_SignalStrength_v6 strength;
766 #endif
767 
768   gGatewaySignalStrength += (rand() % 3 - 1);
769   gCDMASignalStrength += (rand() % 3 - 1);
770   gEVDOSignalStrength += (rand() % 3 - 1);
771   gLTESignalStrength += (rand() % 3 - 1);
772 
773   if (gGatewaySignalStrength < kGatewaySignalStrengthMin)
774     gGatewaySignalStrength = kGatewaySignalStrengthMin;
775   if (gGatewaySignalStrength > kGatewaySignalStrengthMax)
776     gGatewaySignalStrength = kGatewaySignalStrengthMax;
777   if (gCDMASignalStrength < kCDMASignalStrengthMin)
778     gCDMASignalStrength = kCDMASignalStrengthMin;
779   if (gCDMASignalStrength > kCDMASignalStrengthMax)
780     gCDMASignalStrength = kCDMASignalStrengthMax;
781   if (gEVDOSignalStrength < kEVDOSignalStrengthMin)
782     gEVDOSignalStrength = kEVDOSignalStrengthMin;
783   if (gEVDOSignalStrength > kEVDOSignalStrengthMax)
784     gEVDOSignalStrength = kEVDOSignalStrengthMax;
785   if (gLTESignalStrength < kLTESignalStrengthMin)
786     gLTESignalStrength = kLTESignalStrengthMin;
787   if (gLTESignalStrength > kLTESignalStrengthMax)
788     gLTESignalStrength = kLTESignalStrengthMax;
789 
790   strength.GW_SignalStrength.signalStrength = gGatewaySignalStrength;
791   strength.GW_SignalStrength.bitErrorRate = 0;  // 0..7%
792 
793   strength.CDMA_SignalStrength.dbm = gCDMASignalStrength;
794   strength.CDMA_SignalStrength.ecio = 0;  // Ec/Io; keep high to use dbm.
795 
796   strength.EVDO_SignalStrength.dbm = gEVDOSignalStrength;
797   strength.EVDO_SignalStrength.ecio = 0;  // Ec/Io; keep high to use dbm.
798 
799   strength.LTE_SignalStrength.signalStrength = gLTESignalStrength;
800   strength.LTE_SignalStrength.rsrp = INT_MAX;   // Invalid = Use signalStrength.
801   strength.LTE_SignalStrength.rsrq = INT_MAX;   // Invalid = Use signalStrength.
802   strength.LTE_SignalStrength.rssnr = INT_MAX;  // Invalid = Use signalStrength.
803   strength.LTE_SignalStrength.cqi = INT_MAX;    // Invalid = Use signalStrength.
804 
805   ALOGV("Reporting signal strength: GW=%d CDMA=%d EVDO=%d LTE=%d",
806         gGatewaySignalStrength, gCDMASignalStrength, gEVDOSignalStrength,
807         gLTESignalStrength);
808 
809   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &strength, sizeof(strength));
810 }
811 
812 static std::map<RIL_PreferredNetworkType, int> gModemSupportedNetworkTypes;
813 
814 static void init_modem_supported_network_types() {
815   gModemSupportedNetworkTypes[PREF_NET_TYPE_GSM_WCDMA] = MDM_GSM | MDM_WCDMA;
816   gModemSupportedNetworkTypes[PREF_NET_TYPE_GSM_ONLY] = MDM_GSM;
817   gModemSupportedNetworkTypes[PREF_NET_TYPE_WCDMA] = MDM_WCDMA;
818   gModemSupportedNetworkTypes[PREF_NET_TYPE_GSM_WCDMA_AUTO] =
819       MDM_GSM | MDM_WCDMA;
820   gModemSupportedNetworkTypes[PREF_NET_TYPE_CDMA_EVDO_AUTO] =
821       MDM_CDMA | MDM_EVDO;
822   gModemSupportedNetworkTypes[PREF_NET_TYPE_CDMA_ONLY] = MDM_CDMA;
823   gModemSupportedNetworkTypes[PREF_NET_TYPE_EVDO_ONLY] = MDM_EVDO;
824   gModemSupportedNetworkTypes[PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO] =
825       MDM_GSM | MDM_WCDMA | MDM_CDMA | MDM_EVDO;
826   gModemSupportedNetworkTypes[PREF_NET_TYPE_LTE_CDMA_EVDO] =
827       MDM_LTE | MDM_CDMA | MDM_EVDO;
828   gModemSupportedNetworkTypes[PREF_NET_TYPE_LTE_GSM_WCDMA] =
829       MDM_LTE | MDM_GSM | MDM_WCDMA;
830   gModemSupportedNetworkTypes[PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA] =
831       MDM_LTE | MDM_CDMA | MDM_EVDO | MDM_GSM | MDM_WCDMA;
832   gModemSupportedNetworkTypes[PREF_NET_TYPE_LTE_ONLY] = MDM_LTE;
833 }
834 
835 static std::map<RIL_PreferredNetworkType, int> gModemTechnologies;
836 
837 RIL_RadioTechnology gDataTechnologiesPreferenceOrder[] = {
838     RADIO_TECH_LTE,    RADIO_TECH_EHRPD, RADIO_TECH_HSPAP,  RADIO_TECH_HSPA,
839     RADIO_TECH_HSDPA,  RADIO_TECH_HSUPA, RADIO_TECH_EVDO_B, RADIO_TECH_EVDO_A,
840     RADIO_TECH_EVDO_0, RADIO_TECH_1xRTT, RADIO_TECH_UMTS,   RADIO_TECH_EDGE,
841     RADIO_TECH_GPRS};
842 
843 RIL_RadioTechnology gVoiceTechnologiesPreferenceOrder[] = {
844     RADIO_TECH_LTE,    RADIO_TECH_EHRPD, RADIO_TECH_EVDO_B, RADIO_TECH_EVDO_A,
845     RADIO_TECH_EVDO_0, RADIO_TECH_1xRTT, RADIO_TECH_IS95B,  RADIO_TECH_IS95A,
846     RADIO_TECH_UMTS,   RADIO_TECH_GSM};
847 
848 static void init_modem_technologies() {
849   gModemTechnologies[PREF_NET_TYPE_GSM_WCDMA] =
850       (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE) |
851       (1 << RADIO_TECH_UMTS);
852   gModemTechnologies[PREF_NET_TYPE_GSM_ONLY] =
853       (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE);
854   gModemTechnologies[PREF_NET_TYPE_WCDMA] =
855       (1 << RADIO_TECH_EDGE) | (1 << RADIO_TECH_UMTS);
856   gModemTechnologies[PREF_NET_TYPE_GSM_WCDMA_AUTO] =
857       (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE) |
858       (1 << RADIO_TECH_UMTS);
859   gModemTechnologies[PREF_NET_TYPE_CDMA_EVDO_AUTO] =
860       (1 << RADIO_TECH_IS95A) | (1 << RADIO_TECH_IS95B) |
861       (1 << RADIO_TECH_1xRTT) | (1 << RADIO_TECH_EVDO_0) |
862       (1 << RADIO_TECH_EVDO_A) | (1 << RADIO_TECH_HSDPA) |
863       (1 << RADIO_TECH_HSUPA) | (1 << RADIO_TECH_HSPA) |
864       (1 << RADIO_TECH_EVDO_B);
865   gModemTechnologies[PREF_NET_TYPE_CDMA_ONLY] = (1 << RADIO_TECH_IS95A) |
866                                                 (1 << RADIO_TECH_IS95B) |
867                                                 (1 << RADIO_TECH_1xRTT);
868   gModemTechnologies[PREF_NET_TYPE_EVDO_ONLY] =
869       (1 << RADIO_TECH_EVDO_0) | (1 << RADIO_TECH_EVDO_A) |
870       (1 << RADIO_TECH_EVDO_A) | (1 << RADIO_TECH_HSDPA) |
871       (1 << RADIO_TECH_HSUPA) | (1 << RADIO_TECH_HSPA) |
872       (1 << RADIO_TECH_EVDO_B);
873   gModemTechnologies[PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO] =
874       (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE) |
875       (1 << RADIO_TECH_UMTS) | (1 << RADIO_TECH_IS95A) |
876       (1 << RADIO_TECH_IS95B) | (1 << RADIO_TECH_1xRTT) |
877       (1 << RADIO_TECH_EVDO_0) | (1 << RADIO_TECH_EVDO_A) |
878       (1 << RADIO_TECH_HSDPA) | (1 << RADIO_TECH_HSUPA) |
879       (1 << RADIO_TECH_HSPA) | (1 << RADIO_TECH_EVDO_B);
880   gModemTechnologies[PREF_NET_TYPE_LTE_CDMA_EVDO] =
881       (1 << RADIO_TECH_HSPAP) | (1 << RADIO_TECH_LTE) |
882       (1 << RADIO_TECH_EHRPD) | (1 << RADIO_TECH_IS95A) |
883       (1 << RADIO_TECH_IS95B) | (1 << RADIO_TECH_1xRTT) |
884       (1 << RADIO_TECH_EVDO_0) | (1 << RADIO_TECH_EVDO_A) |
885       (1 << RADIO_TECH_HSDPA) | (1 << RADIO_TECH_HSUPA) |
886       (1 << RADIO_TECH_HSPA) | (1 << RADIO_TECH_EVDO_B);
887   gModemTechnologies[PREF_NET_TYPE_LTE_GSM_WCDMA] =
888       (1 << RADIO_TECH_HSPAP) | (1 << RADIO_TECH_LTE) |
889       (1 << RADIO_TECH_EHRPD) | (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) |
890       (1 << RADIO_TECH_EDGE) | (1 << RADIO_TECH_UMTS);
891 
892   gModemTechnologies[PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA] =
893       (1 << RADIO_TECH_HSPAP) | (1 << RADIO_TECH_LTE) |
894       (1 << RADIO_TECH_EHRPD) | (1 << RADIO_TECH_IS95A) |
895       (1 << RADIO_TECH_IS95B) | (1 << RADIO_TECH_1xRTT) |
896       (1 << RADIO_TECH_EVDO_0) | (1 << RADIO_TECH_EVDO_A) |
897       (1 << RADIO_TECH_HSDPA) | (1 << RADIO_TECH_HSUPA) |
898       (1 << RADIO_TECH_HSPA) | (1 << RADIO_TECH_EVDO_B) |
899       (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE) |
900       (1 << RADIO_TECH_UMTS);
901   gModemTechnologies[PREF_NET_TYPE_LTE_ONLY] =
902       (1 << RADIO_TECH_HSPAP) | (1 << RADIO_TECH_LTE) | (1 << RADIO_TECH_EHRPD);
903 }
904 
905 static const RIL_PreferredNetworkType gModemDefaultType =
906     PREF_NET_TYPE_LTE_GSM_WCDMA;
907 static RIL_PreferredNetworkType gModemCurrentType = gModemDefaultType;
908 static RIL_RadioTechnology gModemVoiceTechnology = RADIO_TECH_LTE;
909 
910 // Report technology change.
911 // Select best technology from the list of supported techs.
912 // Demotes RADIO_TECH_GSM as it's voice-only.
913 static RIL_RadioTechnology getBestDataTechnology(
914     RIL_PreferredNetworkType network_type) {
915   RIL_RadioTechnology technology = RADIO_TECH_GPRS;
916 
917   std::map<RIL_PreferredNetworkType, int>::iterator iter =
918       gModemTechnologies.find(network_type);
919 
920   ALOGV("Searching for best data technology for network type %d...",
921         network_type);
922 
923   // Find which technology bits are lit. Pick the top most.
924   for (size_t tech_index = 0;
925        tech_index < sizeof(gDataTechnologiesPreferenceOrder) /
926                         sizeof(gDataTechnologiesPreferenceOrder[0]);
927        ++tech_index) {
928     if (iter->second & (1 << gDataTechnologiesPreferenceOrder[tech_index])) {
929       technology = gDataTechnologiesPreferenceOrder[tech_index];
930       break;
931     }
932   }
933 
934   ALOGV("Best data technology: %d.", technology);
935   return technology;
936 }
937 
938 static RIL_RadioTechnology getBestVoiceTechnology(
939     RIL_PreferredNetworkType network_type) {
940   RIL_RadioTechnology technology = RADIO_TECH_GSM;
941 
942   std::map<RIL_PreferredNetworkType, int>::iterator iter =
943       gModemTechnologies.find(network_type);
944 
945   ALOGV("Searching for best voice technology for network type %d...",
946         network_type);
947 
948   // Find which technology bits are lit. Pick the top most.
949   for (size_t tech_index = 0;
950        tech_index < sizeof(gVoiceTechnologiesPreferenceOrder) /
951                         sizeof(gVoiceTechnologiesPreferenceOrder[0]);
952        ++tech_index) {
953     if (iter->second & (1 << gVoiceTechnologiesPreferenceOrder[tech_index])) {
954       technology = gVoiceTechnologiesPreferenceOrder[tech_index];
955       break;
956     }
957   }
958 
959   ALOGV("Best voice technology: %d.", technology);
960   return technology;
961 }
962 
963 static void setRadioTechnology(RIL_PreferredNetworkType network_type) {
964   RIL_RadioTechnology technology = getBestVoiceTechnology(network_type);
965 
966   if (technology != gModemVoiceTechnology) {
967     gModemVoiceTechnology = technology;
968     gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_VOICE_RADIO_TECH_CHANGED,
969                                        &gModemVoiceTechnology,
970                                        sizeof(gModemVoiceTechnology));
971   }
972 }
973 
974 #if VSOC_PLATFORM_SDK_AFTER(L)
975 static void request_get_radio_capability(RIL_Token t) {
976   ALOGV("Requesting radio capability.");
977   RIL_RadioCapability rc;
978   rc.version = RIL_RADIO_CAPABILITY_VERSION;
979   rc.session = 1;
980   rc.phase = RC_PHASE_CONFIGURED;
981   rc.rat = RAF_HSPAP;
982   strncpy(rc.logicalModemUuid, "com.google.cvdgce1.modem", MAX_UUID_LENGTH);
983   rc.status = RC_STATUS_SUCCESS;
984   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &rc, sizeof(rc));
985 }
986 
987 static void request_set_radio_capability(void* data, size_t datalen,
988                                          RIL_Token t) {
989   RIL_RadioCapability* rc = (RIL_RadioCapability*)data;
990   ALOGV(
991       "RadioCapability version %d session %d phase %d rat %d "
992       "logicalModemUuid %s status %d",
993       rc->version, rc->session, rc->phase, rc->rat, rc->logicalModemUuid,
994       rc->status);
995   // TODO(ender): do something about these numbers.
996   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, rc, datalen);
997 }
998 #endif
999 
1000 static void request_set_preferred_network_type(int /*request*/, void* data,
1001                                                size_t /*datalen*/,
1002                                                RIL_Token t) {
1003   RIL_PreferredNetworkType desired_type = *(RIL_PreferredNetworkType*)(data);
1004 
1005   // TODO(ender): telephony still believes this phone is GSM only.
1006   ALOGV("Requesting modem technology change -> %d", desired_type);
1007 
1008   if (gModemSupportedNetworkTypes.find(desired_type) ==
1009       gModemSupportedNetworkTypes.end()) {
1010     desired_type = gModemSupportedNetworkTypes.begin()->first;
1011   }
1012 
1013   if (gModemCurrentType == desired_type) {
1014     ALOGV("Modem technology already set to %d.", desired_type);
1015     gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1016     return;
1017   }
1018 
1019   int supported_technologies = gModemSupportedNetworkTypes[gModemDefaultType];
1020   int desired_technologies = gModemSupportedNetworkTypes[desired_type];
1021 
1022   ALOGV("Requesting modem technology change %d -> %d", gModemCurrentType,
1023         desired_type);
1024 
1025   // Check if we support this technology.
1026   if ((supported_technologies & desired_technologies) != desired_technologies) {
1027     ALOGV("Desired technology is not supported.");
1028     gce_ril_env->OnRequestComplete(t, RIL_E_MODE_NOT_SUPPORTED, NULL, 0);
1029     return;
1030   }
1031 
1032   gModemCurrentType = desired_type;
1033   setRadioTechnology(desired_type);
1034   ALOGV("Technology change successful.");
1035   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1036 }
1037 
1038 static void request_get_preferred_network_type(int /*request*/, void* /*data*/,
1039                                                size_t /*datalen*/,
1040                                                RIL_Token t) {
1041   gce_ril_env->OnRequestComplete(
1042       t, RIL_E_SUCCESS,
1043       const_cast<RIL_PreferredNetworkType*>(&gModemDefaultType),
1044       sizeof(gModemDefaultType));
1045 }
1046 
1047 enum RegistrationState {
1048   kUnregistered = 0,
1049   kRegisteredInHomeNetwork = 1,
1050   kSearchingForOperators = 2,
1051   kRegistrationDenied = 3,
1052   kUnknown = 4,
1053   kRegisteredInRoamingMode = 5,
1054 
1055   kUnregistered_EmergencyCallsOnly = 10,
1056   kSearchingForOperators_EmergencyCallsOnly = 12,
1057   kRegistrationDenied_EmergencyCallsOnly = 13,
1058   kUnknown_EmergencyCallsOnly = 14
1059 };
1060 
1061 static const char kCdmaMobileDeviceNumber[] = "5551234567";
1062 static const char kCdmaSID[] = "123";
1063 static const char kCdmaNID[] = "65535";  // special: indicates free roaming.
1064 
1065 static void request_registration_state(int request, void* /*data*/,
1066                                        size_t /*datalen*/, RIL_Token t) {
1067   char** responseStr = NULL;
1068   int numElements = 0;
1069 
1070   // See RIL_REQUEST_VOICE_REGISTRATION_STATE and
1071   // RIL_REQUEST_DATA_REGISTRATION_STATE.
1072   numElements = (request == RIL_REQUEST_VOICE_REGISTRATION_STATE) ? 15 : 6;
1073   responseStr = (char**)malloc(numElements * sizeof(char*));
1074 
1075   asprintf(&responseStr[0], "%d", kRegisteredInHomeNetwork);
1076   responseStr[1] = NULL;  // LAC - needed for GSM / WCDMA only.
1077   responseStr[2] = NULL;  // CID - needed for GSM / WCDMA only.
1078 
1079   // This is (and always has been) a huge memory leak.
1080   if (request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
1081     ALOGV("Requesting voice registration state.");
1082     asprintf(&responseStr[3], "%d", getBestVoiceTechnology(gModemCurrentType));
1083     responseStr[4] = strdup("1");       // BSID
1084     responseStr[5] = strdup("123");     // Latitude
1085     responseStr[6] = strdup("222");     // Longitude
1086     responseStr[7] = strdup("0");       // CSS Indicator
1087     responseStr[8] = strdup(kCdmaSID);  // SID
1088     responseStr[9] = strdup(kCdmaNID);  // NID
1089     responseStr[10] = strdup("0");      // Roaming indicator
1090     responseStr[11] = strdup("1");      // System is in PRL
1091     responseStr[12] = strdup("0");      // Default Roaming indicator
1092     responseStr[13] = strdup("0");      // Reason for denial
1093     responseStr[14] = strdup("0");      // Primary Scrambling Code of Current
1094   } else if (request == RIL_REQUEST_DATA_REGISTRATION_STATE) {
1095     ALOGV("Requesting data registration state.");
1096     asprintf(&responseStr[3], "%d", getBestDataTechnology(gModemCurrentType));
1097     responseStr[4] = strdup("");   // DataServiceDenyReason
1098     responseStr[5] = strdup("1");  // Max simultaneous data calls.
1099   } else {
1100     ALOGV("Unexpected request type: %d", request);
1101     return;
1102   }
1103 
1104   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, responseStr,
1105                                  numElements * sizeof(responseStr));
1106 }
1107 
1108 static void request_baseband_version(RIL_Token t) {
1109   const char* response_str = "CVD_R1.0.0";
1110 
1111   ALOGV("Requested phone baseband version.");
1112 
1113   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, strdup(response_str),
1114                                  sizeof(response_str));
1115 }
1116 
1117 // Returns true, if modem is CDMA capable.
1118 static bool isCDMA() {
1119   switch (gModemCurrentType) {
1120     case PREF_NET_TYPE_GSM_WCDMA:
1121     case PREF_NET_TYPE_GSM_ONLY:
1122     case PREF_NET_TYPE_WCDMA:
1123     case PREF_NET_TYPE_GSM_WCDMA_AUTO:
1124     case PREF_NET_TYPE_LTE_GSM_WCDMA:
1125     case PREF_NET_TYPE_LTE_ONLY:
1126       return false;
1127 
1128     case PREF_NET_TYPE_CDMA_EVDO_AUTO:
1129     case PREF_NET_TYPE_CDMA_ONLY:
1130     case PREF_NET_TYPE_EVDO_ONLY:
1131     case PREF_NET_TYPE_LTE_CDMA_EVDO:
1132     case PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA:
1133     case PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO:
1134       return true;
1135     default:
1136       break;
1137   }
1138 
1139   ALOGE("INVALID MODEM TYPE: %d", gModemCurrentType);
1140   return false;
1141 }
1142 
1143 // Returns true, if modem is GSM capable.
1144 // Note, this is not same as !isCDMA().
1145 static bool isGSM() {
1146   switch (gModemCurrentType) {
1147     case PREF_NET_TYPE_GSM_WCDMA:
1148     case PREF_NET_TYPE_GSM_ONLY:
1149     case PREF_NET_TYPE_WCDMA:
1150     case PREF_NET_TYPE_GSM_WCDMA_AUTO:
1151     case PREF_NET_TYPE_LTE_GSM_WCDMA:
1152     case PREF_NET_TYPE_LTE_ONLY:
1153     case PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO:
1154       return true;
1155 
1156     case PREF_NET_TYPE_CDMA_EVDO_AUTO:
1157     case PREF_NET_TYPE_CDMA_ONLY:
1158     case PREF_NET_TYPE_EVDO_ONLY:
1159     case PREF_NET_TYPE_LTE_CDMA_EVDO:
1160     case PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA:
1161       return false;
1162     default:
1163       break;
1164   }
1165 
1166   ALOGE("INVALID MODEM TYPE: %d", gModemCurrentType);
1167   return false;
1168 }
1169 
1170 static const char gIdentityGsmImei[] = "12345678902468";  // Luhn cksum = 0.
1171 static const char gIdentityGsmImeiSv[] = "01";            // Arbitrary version.
1172 static const char gIdentityCdmaEsn[] = "A0123456";        // 8 digits, ^[A-F].*
1173 static const char gIdentityCdmaMeid[] =
1174     "A0123456789012";  // 14 digits, ^[A-F].*
1175 
1176 static void request_get_imei(RIL_Token t) {
1177   ALOGV("Requesting IMEI");
1178   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS,
1179                                  const_cast<char*>(gIdentityGsmImei),
1180                                  strlen(gIdentityGsmImei));
1181 }
1182 
1183 static void request_get_imei_sv(RIL_Token t) {
1184   ALOGV("Requesting IMEI SV");
1185   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS,
1186                                  const_cast<char*>(gIdentityGsmImeiSv),
1187                                  strlen(gIdentityGsmImeiSv));
1188 }
1189 
1190 static void request_device_identity(int /*request*/, void* /*data*/,
1191                                     size_t /*datalen*/, RIL_Token t) {
1192   char* response[4] = {NULL};
1193 
1194   ALOGV("Requesting device identity...");
1195 
1196   if (isCDMA()) {
1197     response[2] = strdup(&gIdentityCdmaEsn[0]);
1198     response[3] = strdup(&gIdentityCdmaMeid[0]);
1199   }
1200 
1201   if (isGSM()) {
1202     response[0] = strdup(&gIdentityGsmImei[0]);
1203     response[1] = strdup(&gIdentityGsmImeiSv[0]);
1204   }
1205 
1206   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response));
1207 
1208   free(response[0]);
1209   free(response[1]);
1210 }
1211 
1212 // Let's pretend we have SIM for CDMA (by default).
1213 static bool gCdmaHasSim = true;
1214 static RIL_CdmaSubscriptionSource gCdmaSubscriptionType =
1215     CDMA_SUBSCRIPTION_SOURCE_RUIM_SIM;
1216 
1217 static void request_cdma_get_subscription_source(int /*request*/,
1218                                                  void* /*data*/,
1219                                                  size_t /*datalen*/,
1220                                                  RIL_Token t) {
1221   ALOGV("Requesting CDMA Subscription source.");
1222 
1223   if (!isCDMA()) {
1224     // No such radio.
1225     gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1226     return;
1227   }
1228 
1229   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &gCdmaSubscriptionType,
1230                                  sizeof(gCdmaSubscriptionType));
1231 }
1232 
1233 static void request_cdma_set_subscription_source(int /*request*/, void* data,
1234                                                  size_t /*datalen*/,
1235                                                  RIL_Token t) {
1236   ALOGV("Setting CDMA Subscription source.");
1237 
1238   if (!isCDMA()) {
1239     // No such radio.
1240     gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1241     return;
1242   }
1243 
1244   RIL_CdmaSubscriptionSource new_source = *(RIL_CdmaSubscriptionSource*)(data);
1245 
1246   if (new_source == CDMA_SUBSCRIPTION_SOURCE_RUIM_SIM && !gCdmaHasSim) {
1247     // No such radio.
1248     gce_ril_env->OnRequestComplete(t, RIL_E_SIM_ABSENT, NULL, 0);
1249     return;
1250   }
1251 
1252   ALOGV("Changed CDMA subscription type from %d to %d", gCdmaSubscriptionType,
1253         new_source);
1254   gCdmaSubscriptionType = new_source;
1255 
1256   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1257   gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED,
1258                                      &gCdmaSubscriptionType,
1259                                      sizeof(gCdmaSubscriptionType));
1260 }
1261 
1262 static void request_cdma_subscription(int /*request*/, void* /*data*/,
1263                                       size_t /*datalen*/, RIL_Token t) {
1264   ALOGV("Requesting CDMA Subscription.");
1265 
1266   if (!isCDMA()) {
1267     // No such radio.
1268     gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1269     return;
1270   }
1271 
1272   char* responseStr[5] = {NULL};
1273   responseStr[0] = strdup(&kCdmaMobileDeviceNumber[0]);  // MDN
1274   responseStr[1] = strdup(&kCdmaSID[0]);                 // SID
1275   responseStr[2] = strdup(&kCdmaNID[0]);                 // NID
1276   responseStr[3] = strdup(&kCdmaMobileDeviceNumber[0]);  // MIN
1277   responseStr[4] = strdup("1");                          // PRL Version
1278   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, responseStr,
1279                                  sizeof(responseStr));
1280 }
1281 
1282 static const int gMaxConcurrentVoiceCalls = 4;
1283 static const int gMaxConcurrentDataCalls = 4;
1284 static const int gMaxConcurrentStandbyConnections = 4;
1285 
1286 #if VSOC_PLATFORM_SDK_AFTER(K)
1287 static void request_hardware_config(RIL_Token t) {
1288   RIL_HardwareConfig hw_cfg[2];
1289 
1290   ALOGV("Requesting hardware configuration.");
1291 
1292   strncpy(hw_cfg[0].uuid, "com.google.cvdgce1.modem", sizeof(hw_cfg[0].uuid));
1293   strncpy(hw_cfg[1].uuid, "com.google.cvdgce1.sim", sizeof(hw_cfg[1].uuid));
1294 
1295   int technologies = 0;  // = unknown.
1296   std::map<RIL_PreferredNetworkType, int>::iterator iter =
1297       gModemTechnologies.find(gModemDefaultType);
1298   if (iter != gModemTechnologies.end()) {
1299     technologies = iter->second;
1300   }
1301 
1302   hw_cfg[0].type = RIL_HARDWARE_CONFIG_MODEM;
1303   hw_cfg[0].state = RIL_HARDWARE_CONFIG_STATE_ENABLED;
1304   hw_cfg[0].cfg.modem.rilModel = 0;
1305   hw_cfg[0].cfg.modem.rat = technologies;
1306   hw_cfg[0].cfg.modem.maxVoice = gMaxConcurrentVoiceCalls;
1307   hw_cfg[0].cfg.modem.maxData = gMaxConcurrentDataCalls;
1308   hw_cfg[0].cfg.modem.maxStandby = gMaxConcurrentStandbyConnections;
1309 
1310   hw_cfg[1].type = RIL_HARDWARE_CONFIG_SIM;
1311   hw_cfg[1].state = RIL_HARDWARE_CONFIG_STATE_ENABLED;
1312   memcpy(hw_cfg[1].cfg.sim.modemUuid, hw_cfg[0].uuid,
1313          sizeof(hw_cfg[1].cfg.sim.modemUuid));
1314 
1315   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &hw_cfg, sizeof(hw_cfg));
1316 }
1317 #endif
1318 
1319 // 0 = Home network only, 1 = preferred networks only, 2 = all networks.
1320 static int gCdmaRoamingPreference = 2;
1321 
1322 static void request_cdma_get_roaming_preference(int /*request*/, void* /*data*/,
1323                                                 size_t /*datalen*/,
1324                                                 RIL_Token t) {
1325   if (!isCDMA()) {
1326     // No such radio.
1327     gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1328     return;
1329   }
1330 
1331   ALOGV("Requesting CDMA Roaming preference");
1332 
1333   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &gCdmaRoamingPreference,
1334                                  sizeof(gCdmaRoamingPreference));
1335 }
1336 
1337 static void request_cdma_set_roaming_preference(int /*request*/, void* data,
1338                                                 size_t /*datalen*/,
1339                                                 RIL_Token t) {
1340   if (!isCDMA()) {
1341     // No such radio.
1342     gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1343     return;
1344   }
1345 
1346   int pref = *(int*)data;
1347   ALOGV("Changing CDMA roaming preference: %d -> %d", gCdmaRoamingPreference,
1348         pref);
1349 
1350   if ((pref < 0) || (pref > 2)) {
1351     ALOGV("Unsupported roaming preference: %d", pref);
1352     gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1353     return;
1354   }
1355 
1356   gCdmaRoamingPreference = pref;
1357   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1358 }
1359 
1360 static void request_send_ussd(void* /*data*/, size_t /*datalen*/, RIL_Token t) {
1361   ALOGV("Sending USSD code is currently not supported");
1362   // TODO(ender): support this feature
1363   gce_ril_env->OnRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
1364 }
1365 
1366 static void request_cancel_ussd(RIL_Token t) {
1367   ALOGV("Cancelling USSD code is currently not supported");
1368   // TODO(ender): support this feature
1369   gce_ril_env->OnRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
1370 }
1371 
1372 static void request_exit_emergency_mode(void* /*data*/, size_t /*datalen*/,
1373                                         RIL_Token t) {
1374   ALOGV("Exiting emergency callback mode.");
1375 
1376   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1377 }
1378 
1379 static RIL_RadioState gce_ril_current_state() {
1380   ALOGV("Reporting radio state %d", gRadioPowerState);
1381   return gRadioPowerState;
1382 }
1383 
1384 static int gce_ril_on_supports(int requestCode) {
1385   ALOGE("%s: Request code %d not implemented", __FUNCTION__, requestCode);
1386   return 1;
1387 }
1388 
1389 static void gce_ril_on_cancel(RIL_Token /*t*/) {
1390   ALOGE("Cancel operation not implemented");
1391 }
1392 
1393 static const char* gce_ril_get_version(void) {
1394   ALOGV("Reporting VSOC version " VSOC_RIL_VERSION_STRING);
1395   return VSOC_RIL_VERSION_STRING;
1396 }
1397 
1398 static int s_cell_info_rate_ms = INT_MAX;
1399 static int s_mcc = 0;
1400 static int s_mnc = 0;
1401 static int s_lac = 0;
1402 static int s_cid = 0;
1403 
1404 std::vector<RIL_NeighboringCell> gGSMNeighboringCells;
1405 
1406 static void request_get_neighboring_cell_ids(void* /*data*/, size_t /*datalen*/,
1407                                              RIL_Token t) {
1408   ALOGV("Requesting GSM neighboring cell ids");
1409 
1410   if (!isGSM() || gGSMNeighboringCells.empty()) {
1411     gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1412     return;
1413   }
1414 
1415   RIL_NeighboringCell** cells =
1416       new RIL_NeighboringCell*[gGSMNeighboringCells.size()];
1417 
1418   for (size_t index = 0; index < gGSMNeighboringCells.size(); ++index) {
1419     cells[index] = &gGSMNeighboringCells[index];
1420   }
1421 
1422   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, cells,
1423                                  sizeof(RIL_NeighboringCell*));
1424   delete[] cells;
1425 }
1426 
1427 #if VSOC_PLATFORM_SDK_AFTER(J_MR1)
1428 static void request_get_cell_info_list(void* /*data*/, size_t /*datalen*/,
1429                                        RIL_Token t) {
1430   struct timespec now;
1431   uint64_t curTime;
1432 
1433   ALOGV("Requesting Cell Info List");
1434 
1435   clock_gettime(CLOCK_MONOTONIC, &now);
1436   curTime = now.tv_sec * 1000000000LL + now.tv_nsec;
1437 
1438 #if VSOC_PLATFORM_SDK_AFTER(N_MR1)
1439   RIL_CellInfo_v12 ci;
1440 #else
1441   RIL_CellInfo ci;
1442 #endif
1443 
1444   if (isGSM()) {
1445     ci.cellInfoType = RIL_CELL_INFO_TYPE_GSM;
1446     ci.registered = 1;
1447     ci.timeStampType = RIL_TIMESTAMP_TYPE_ANTENNA;  // Our own timestamp.
1448     ci.timeStamp = curTime - 1000;                  // Fake time in the past.
1449     ci.CellInfo.gsm.cellIdentityGsm.mcc = s_mcc;
1450     ci.CellInfo.gsm.cellIdentityGsm.mnc = s_mnc;
1451     ci.CellInfo.gsm.cellIdentityGsm.lac = s_lac;
1452     ci.CellInfo.gsm.cellIdentityGsm.cid = s_cid;
1453     ci.CellInfo.gsm.signalStrengthGsm.signalStrength = 10;
1454     ci.CellInfo.gsm.signalStrengthGsm.bitErrorRate = 0;
1455 
1456     gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &ci, sizeof(ci));
1457   } else if (isCDMA()) {
1458     // TODO(ender): CDMA cell support. And LTE.
1459     gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1460   } else {
1461     gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1462   }
1463 }
1464 #endif
1465 
1466 struct NetworkOperator {
1467   std::string long_name;
1468   std::string short_name;
1469   bool is_accessible;
1470 
1471   NetworkOperator() {}
1472 
1473   NetworkOperator(const std::string& long_name, const std::string& short_name,
1474                   bool is_accessible)
1475       : long_name(long_name),
1476         short_name(short_name),
1477         is_accessible(is_accessible) {}
1478 };
1479 
1480 static std::map<std::string, NetworkOperator> gNetworkOperators;
1481 static std::string gCurrentNetworkOperator = "";
1482 
1483 enum OperatorSelectionMethod {
1484   kOperatorAutomatic = 0,
1485   kOperatorManual = 1,
1486   kOperatorDeregistered = 2,
1487   kOperatorManualThenAutomatic = 4
1488 };
1489 
1490 static void init_virtual_network() {
1491   gGSMNeighboringCells.resize(1);
1492   gGSMNeighboringCells[0].cid = (char*)"0000";
1493   gGSMNeighboringCells[0].rssi = 75;
1494 #if VSOC_PLATFORM_SDK_AFTER(O_MR1)
1495   gNetworkOperators["302780"] =
1496 #else
1497   gNetworkOperators["310260"] =
1498 #endif
1499       NetworkOperator("Android Virtual Operator", "Android", true);
1500   gNetworkOperators["310300"] =
1501       NetworkOperator("Alternative Operator", "Alternative", true);
1502   gNetworkOperators["310400"] =
1503       NetworkOperator("Hermetic Network Operator", "Hermetic", false);
1504 }
1505 
1506 static OperatorSelectionMethod gOperatorSelectionMethod = kOperatorDeregistered;
1507 
1508 static void request_query_network_selection_mode(void* /*data*/,
1509                                                  size_t /*datalen*/,
1510                                                  RIL_Token t) {
1511   ALOGV("Query operator selection mode (%d)", gOperatorSelectionMethod);
1512   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &gOperatorSelectionMethod,
1513                                  sizeof(gOperatorSelectionMethod));
1514 }
1515 
1516 static void request_operator(void* /*data*/, size_t /*datalen*/, RIL_Token t) {
1517   std::map<std::string, NetworkOperator>::iterator iter =
1518       gNetworkOperators.find(gCurrentNetworkOperator);
1519 
1520   ALOGV("Requesting current operator info");
1521 
1522   if (iter == gNetworkOperators.end()) {
1523     gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1524     return;
1525   }
1526 
1527   const char* response[] = {iter->second.long_name.c_str(),
1528                             iter->second.short_name.c_str(),
1529                             iter->first.c_str()};
1530 
1531   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response));
1532 }
1533 
1534 static void request_query_available_networks(void* /*data*/, size_t /*datalen*/,
1535                                              RIL_Token t) {
1536   const char** available_networks =
1537       new const char*[gNetworkOperators.size() * 4];
1538 
1539   ALOGV("Querying available networks.");
1540 
1541   // TODO(ender): this should only respond once operator is selected and
1542   // registered.
1543   int index = 0;
1544   for (std::map<std::string, NetworkOperator>::iterator iter =
1545            gNetworkOperators.begin();
1546        iter != gNetworkOperators.end(); ++iter) {
1547     // TODO(ender): wrap in a neat structure maybe?
1548     available_networks[index++] = iter->second.long_name.c_str();
1549     available_networks[index++] = iter->second.short_name.c_str();
1550     available_networks[index++] = iter->first.c_str();
1551     if (!iter->second.is_accessible) {
1552       available_networks[index++] = "forbidden";
1553     } else if (iter->first == gCurrentNetworkOperator) {
1554       available_networks[index++] = "current";
1555     } else {
1556       available_networks[index++] = "available";
1557     }
1558   }
1559 
1560   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &available_networks,
1561                                  4 * gNetworkOperators.size());
1562   delete[] available_networks;
1563 }
1564 
1565 static void request_set_automatic_network_selection(RIL_Token t) {
1566   ALOGV("Requesting automatic operator selection");
1567   gCurrentNetworkOperator = gNetworkOperators.begin()->first;
1568   gOperatorSelectionMethod = kOperatorAutomatic;
1569   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1570 }
1571 
1572 static void request_set_manual_network_selection(void* data, size_t /*datalen*/,
1573                                                  RIL_Token t) {
1574   char* mccmnc = (char*)data;
1575 
1576   ALOGV("Requesting manual operator selection: %s", mccmnc);
1577 
1578   std::map<std::string, NetworkOperator>::iterator iter =
1579       gNetworkOperators.find(mccmnc);
1580 
1581   if (iter == gNetworkOperators.end() || iter->second.is_accessible) {
1582     gce_ril_env->OnRequestComplete(t, RIL_E_ILLEGAL_SIM_OR_ME, NULL, 0);
1583     return;
1584   }
1585 
1586   gCurrentNetworkOperator = mccmnc;
1587   gOperatorSelectionMethod = kOperatorManual;
1588 
1589   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1590 }
1591 
1592 static const char kDefaultSMSC[] = "00";
1593 static int gNextSmsMessageId = 1;
1594 
1595 static void request_cdma_send_SMS(void* /*data*/, RIL_Token t) {
1596   RIL_SMS_Response response = {0, 0, 0};
1597   // RIL_CDMA_SMS_Message* rcsm = (RIL_CDMA_SMS_Message*) data;
1598 
1599   ALOGW("CDMA SMS Send is currently not implemented.");
1600 
1601   // Cdma Send SMS implementation will go here:
1602   // But it is not implemented yet.
1603   memset(&response, 0, sizeof(response));
1604   response.messageRef = -1;  // This must be BearerData MessageId.
1605   gce_ril_env->OnRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, &response,
1606                                  sizeof(response));
1607 }
1608 
1609 static void request_send_SMS(void* data, RIL_Token t) {
1610   RIL_SMS_Response response = {0, 0, 0};
1611 
1612   ALOGV("Send GSM SMS Message");
1613 
1614   // SMSC is an address of SMS center or NULL for default.
1615   const char* smsc = ((const char**)data)[0];
1616   if (smsc == NULL) smsc = &kDefaultSMSC[0];
1617 
1618   response.messageRef = gNextSmsMessageId++;
1619   response.ackPDU = NULL;
1620   response.errorCode = 0;
1621 
1622   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response));
1623 
1624   // response.messageRef = -1;
1625   // gce_ril_env->OnRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, &response,
1626   //                                sizeof(response));
1627 }
1628 
1629 #if VSOC_PLATFORM_SDK_AFTER(J_MR1)
1630 static void request_set_cell_info_list_rate(void* data, size_t /*datalen*/,
1631                                             RIL_Token t) {
1632   // For now we'll save the rate but no RIL_UNSOL_CELL_INFO_LIST messages
1633   // will be sent.
1634   ALOGV("Setting cell info list rate.");
1635   s_cell_info_rate_ms = ((int*)data)[0];
1636   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1637 }
1638 #endif
1639 #if VSOC_PLATFORM_SDK_AFTER(J_MR2)
1640 static void request_ims_send_SMS(void* data, size_t /*datalen*/, RIL_Token t) {
1641   RIL_IMS_SMS_Message* args = (RIL_IMS_SMS_Message*)data;
1642   RIL_SMS_Response response{};
1643 
1644   ALOGV("Send IMS SMS Message");
1645 
1646   switch (args->tech) {
1647     case RADIO_TECH_3GPP:
1648       return request_send_SMS(args->message.gsmMessage, t);
1649 
1650     case RADIO_TECH_3GPP2:
1651       return request_cdma_send_SMS(args->message.gsmMessage, t);
1652 
1653     default:
1654       ALOGE("Invalid SMS format value: %d", args->tech);
1655       response.messageRef = -2;
1656       gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, &response,
1657                                      sizeof(response));
1658   }
1659 }
1660 #endif
1661 
1662 static void request_SMS_acknowledge(void* data, size_t /*datalen*/,
1663                                     RIL_Token t) {
1664   int* ack = (int*)data;
1665 
1666   // TODO(ender): we should retain "incoming" sms for later reception.
1667   ALOGV("SMS receipt %ssuccessful (reason %d).", ack[0] ? "" : "un", ack[1]);
1668 
1669   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1670 }
1671 
1672 struct SimFileCommand {
1673   uint8_t command;
1674   uint16_t efid;
1675   uint8_t param1;
1676   uint8_t param2;
1677   uint8_t param3;
1678 
1679   bool operator<(const SimFileCommand& other) const {
1680     uint64_t sum1, sum2;
1681     sum1 = (command * 1ull << 40) | (efid * 1ull << 24) | (param1 << 16) |
1682            (param2 << 8) | (param3);
1683     sum2 = (other.command * 1ull << 40) | (other.efid * 1ull << 24) |
1684            (other.param1 << 16) | (other.param2 << 8) | (other.param3);
1685     return sum1 < sum2;
1686   }
1687 
1688   SimFileCommand(uint8_t cmd, uint16_t efid, uint8_t p1, uint8_t p2, uint8_t p3)
1689       : command(cmd), efid(efid), param1(p1), param2(p2), param3(p3) {}
1690 };
1691 
1692 struct SimFileResponse {
1693   uint8_t sw1;
1694   uint8_t sw2;
1695   const char* data;
1696 
1697   SimFileResponse() : sw1(0), sw2(0), data(NULL) {}
1698 
1699   SimFileResponse(uint8_t sw1, uint8_t sw2, const char* data)
1700       : sw1(sw1), sw2(sw2), data(data) {}
1701 };
1702 
1703 // TODO(ender): Double check & rewrite these.
1704 std::map<SimFileCommand, SimFileResponse> gSimFileSystem;
1705 
1706 static void init_sim_file_system() {
1707   gSimFileSystem[SimFileCommand(192, 28436, 0, 0, 15)] =
1708       SimFileResponse(144, 0, "000000146f1404001aa0aa01020000");
1709   gSimFileSystem[SimFileCommand(176, 28436, 0, 0, 20)] =
1710       SimFileResponse(144, 0, "416e64726f6964ffffffffffffffffffffffffff");
1711   gSimFileSystem[SimFileCommand(192, 28433, 0, 0, 15)] =
1712       SimFileResponse(144, 0, "000000016f11040011a0aa01020000");
1713   gSimFileSystem[SimFileCommand(176, 28433, 0, 0, 1)] =
1714       SimFileResponse(144, 0, "55");
1715   gSimFileSystem[SimFileCommand(192, 12258, 0, 0, 15)] =
1716       SimFileResponse(144, 0, "0000000a2fe204000fa0aa01020000");
1717   gSimFileSystem[SimFileCommand(176, 12258, 0, 0, 10)] =
1718       SimFileResponse(144, 0, "98101430121181157002");
1719   gSimFileSystem[SimFileCommand(192, 28435, 0, 0, 15)] =
1720       SimFileResponse(144, 0, "000000016f13040011a0aa01020000");
1721   gSimFileSystem[SimFileCommand(176, 28435, 0, 0, 1)] =
1722       SimFileResponse(144, 0, "55");
1723   gSimFileSystem[SimFileCommand(192, 28472, 0, 0, 15)] =
1724       SimFileResponse(144, 0, "0000000f6f3804001aa0aa01020000");
1725   gSimFileSystem[SimFileCommand(176, 28472, 0, 0, 15)] =
1726       SimFileResponse(144, 0, "ff30ffff3c003c03000c0000f03f00");
1727   gSimFileSystem[SimFileCommand(192, 28617, 0, 0, 15)] =
1728       SimFileResponse(144, 0, "000000086fc9040011a0aa01020104");
1729   gSimFileSystem[SimFileCommand(178, 28617, 1, 4, 4)] =
1730       SimFileResponse(144, 0, "01000000");
1731   gSimFileSystem[SimFileCommand(192, 28618, 0, 0, 15)] =
1732       SimFileResponse(144, 0, "0000000a6fca040011a0aa01020105");
1733   gSimFileSystem[SimFileCommand(178, 28618, 1, 4, 5)] =
1734       SimFileResponse(144, 0, "0000000000");
1735   gSimFileSystem[SimFileCommand(192, 28589, 0, 0, 15)] =
1736       SimFileResponse(144, 0, "000000046fad04000aa0aa01020000");
1737   gSimFileSystem[SimFileCommand(176, 28589, 0, 0, 4)] =
1738       SimFileResponse(144, 0, "00000003");
1739   gSimFileSystem[SimFileCommand(192, 28438, 0, 0, 15)] =
1740       SimFileResponse(144, 0, "000000026f1604001aa0aa01020000");
1741   gSimFileSystem[SimFileCommand(176, 28438, 0, 0, 2)] =
1742       SimFileResponse(144, 0, "0233");
1743   gSimFileSystem[SimFileCommand(192, 28486, 0, 0, 15)] =
1744       SimFileResponse(148, 4, NULL);
1745   gSimFileSystem[SimFileCommand(192, 28621, 0, 0, 15)] =
1746       SimFileResponse(148, 4, NULL);
1747   gSimFileSystem[SimFileCommand(192, 28613, 0, 0, 15)] =
1748       SimFileResponse(144, 0, "000000f06fc504000aa0aa01020118");
1749   gSimFileSystem[SimFileCommand(178, 28613, 1, 4, 24)] = SimFileResponse(
1750       144, 0, "43058441aa890affffffffffffffffffffffffffffffffff");
1751   gSimFileSystem[SimFileCommand(192, 28480, 0, 0, 15)] =
1752       SimFileResponse(144, 0, "000000806f40040011a0aa01020120");
1753   // Primary phone number encapsulated
1754   // [51][55][21][43][65][f7] = 1 555 1234 567$
1755   gSimFileSystem[SimFileCommand(178, 28480, 1, 4, 32)] = SimFileResponse(
1756       144, 0,
1757       "ffffffffffffffffffffffffffffffffffff07915155214365f7ffffffffffff");
1758   gSimFileSystem[SimFileCommand(192, 28615, 0, 0, 15)] =
1759       SimFileResponse(144, 0, "000000406fc7040011a0aa01020120");
1760   // Voice mail number encapsulated
1761   // [56][6f][69][63][65][6d][61][69][6c] = 'Voicemail'
1762   // [51][55][67][45][23][f1] = 1 555 7654 321$
1763   gSimFileSystem[SimFileCommand(178, 28615, 1, 4, 32)] = SimFileResponse(
1764       144, 0,
1765       "566f6963656d61696cffffffffffffffffff07915155674523f1ffffffffffff");
1766   gSimFileSystem[SimFileCommand(192, 12037, 0, 0, 15)] =
1767       SimFileResponse(148, 4, NULL);
1768   gSimFileSystem[SimFileCommand(192, 28437, 0, 0, 15)] =
1769       SimFileResponse(148, 4, NULL);
1770   gSimFileSystem[SimFileCommand(192, 28478, 0, 0, 15)] =
1771       SimFileResponse(148, 4, NULL);
1772   gSimFileSystem[SimFileCommand(192, 28450, 0, 0, 15)] =
1773       SimFileResponse(148, 4, NULL);
1774   gSimFileSystem[SimFileCommand(192, 28456, 0, 0, 15)] =
1775       SimFileResponse(148, 4, NULL);
1776   gSimFileSystem[SimFileCommand(192, 28474, 0, 0, 15)] =
1777       SimFileResponse(148, 4, NULL);
1778   gSimFileSystem[SimFileCommand(192, 28481, 0, 0, 15)] =
1779       SimFileResponse(148, 4, NULL);
1780   gSimFileSystem[SimFileCommand(192, 28484, 0, 0, 15)] =
1781       SimFileResponse(148, 4, NULL);
1782   gSimFileSystem[SimFileCommand(192, 28493, 0, 0, 15)] =
1783       SimFileResponse(148, 4, NULL);
1784   gSimFileSystem[SimFileCommand(192, 28619, 0, 0, 15)] =
1785       SimFileResponse(148, 4, NULL);
1786   gSimFileSystem[SimFileCommand(176, 28506, 0, 0, 4)] =
1787       SimFileResponse(144, 0, "00000013");
1788 }
1789 
1790 static void request_SIM_IO(void* data, size_t /*datalen*/, RIL_Token t) {
1791   const RIL_SIM_IO_v6& args = *(RIL_SIM_IO_v6*)data;
1792   RIL_SIM_IO_Response sr = {0, 0, 0};
1793 
1794   ALOGV(
1795       "Requesting SIM File IO: %d EFID %x, Params: %d, %d, %d, path: %s, "
1796       "data %s PIN: %s AID: %s",
1797       args.command, args.fileid, args.p1, args.p2, args.p3, args.path,
1798       args.data, args.pin2, args.aidPtr);
1799 
1800   SimFileCommand cmd(args.command, args.fileid, args.p1, args.p2, args.p3);
1801 
1802   std::map<SimFileCommand, SimFileResponse>::iterator resp =
1803       gSimFileSystem.find(cmd);
1804 
1805   if (resp != gSimFileSystem.end()) {
1806     sr.sw1 = resp->second.sw1;
1807     sr.sw2 = resp->second.sw2;
1808     if (resp->second.data) sr.simResponse = strdup(resp->second.data);
1809     gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &sr, sizeof(sr));
1810     return;
1811   }
1812 
1813   ALOGW("Unsupported SIM File IO command.");
1814   gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1815 }
1816 
1817 static void request_enter_sim_pin(void* data, size_t /*datalen*/, RIL_Token t) {
1818   const char** pin_aid = (const char**)data;
1819 
1820   ALOGV("Entering PIN: %s / %s", pin_aid[0], pin_aid[1]);
1821 
1822   ++gSimPINAttempts;
1823   int remaining_attempts = gSimPINAttemptsMax - gSimPINAttempts;
1824 
1825   bool is_valid = false;
1826 
1827   if (gSimStatus == SIM_PIN) {
1828     is_valid = (gSimPIN == pin_aid[0]);
1829   } else if (gSimStatus == SIM_PUK) {
1830     is_valid = (gSimPUK == pin_aid[0]);
1831   } else {
1832     ALOGV("Unexpected SIM status for unlock: %d", gSimStatus);
1833     gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1834     return;
1835   }
1836 
1837   if (!is_valid) {
1838     if (gSimPINAttempts == gSimPINAttemptsMax) {
1839       if (gSimStatus == SIM_PIN) {
1840         gSimStatus = SIM_PUK;
1841         gSimPINAttempts = 0;
1842       } else {
1843         ALOGV("PIN and PUK verification failed; locking SIM card.");
1844         gSimStatus = SIM_NOT_READY;
1845         gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1846         return;
1847       }
1848     }
1849 
1850     gce_ril_env->OnRequestComplete(t, RIL_E_PASSWORD_INCORRECT,
1851                                    &remaining_attempts,
1852                                    sizeof(remaining_attempts));
1853   } else {
1854     if (gSimStatus == SIM_PUK) {
1855       ALOGV("Resetting SIM PIN to %s", pin_aid[1]);
1856       gSimPIN = pin_aid[1];
1857     }
1858 
1859     gSimPINAttempts = 0;
1860     gSimStatus = SIM_READY;
1861     gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &remaining_attempts,
1862                                    sizeof(remaining_attempts));
1863   }
1864 
1865   pollSIMState(NULL);
1866 }
1867 
1868 /**
1869  * No longer POLL.
1870  */
1871 static void pollSIMState(void* /*param*/) {
1872   // TODO(ender): check radio state?
1873 
1874   ALOGV("Polling SIM Status.");
1875 
1876   switch (gSimStatus) {
1877     case SIM_ABSENT:
1878     case SIM_PIN:
1879     case SIM_PUK:
1880     case SIM_NETWORK_PERSONALIZATION:
1881     default:
1882       ALOGV("SIM Absent or Locked");
1883       break;
1884 
1885     case SIM_NOT_READY:
1886       // Transition directly to READY. Set default network operator.
1887       if (gRadioPowerState == RADIO_STATE_ON) {
1888         gSimStatus = SIM_READY;
1889 #if VSOC_PLATFORM_SDK_AFTER(O_MR1)
1890         gCurrentNetworkOperator = "302780";
1891 #else
1892         gCurrentNetworkOperator = "310260";
1893 #endif
1894       }
1895 
1896       gce_ril_env->RequestTimedCallback(pollSIMState, NULL, &TIMEVAL_SIMPOLL);
1897       break;
1898 
1899     case SIM_READY:
1900       ALOGV("SIM Ready. Notifying network state changed.");
1901       break;
1902   }
1903 
1904   if (gRadioPowerState != RADIO_STATE_OFF) {
1905     gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED,
1906                                        NULL, 0);
1907     gce_ril_env->OnUnsolicitedResponse(
1908         RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, NULL, 0);
1909   }
1910 }
1911 
1912 std::map<SIM_Status, RIL_AppStatus> gRilAppStatus;
1913 
1914 static void init_sim_status() {
1915   gRilAppStatus[SIM_ABSENT] = (RIL_AppStatus){RIL_APPTYPE_UNKNOWN,
1916                                               RIL_APPSTATE_UNKNOWN,
1917                                               RIL_PERSOSUBSTATE_UNKNOWN,
1918                                               NULL,
1919                                               NULL,
1920                                               0,
1921                                               RIL_PINSTATE_UNKNOWN,
1922                                               RIL_PINSTATE_UNKNOWN};
1923   gRilAppStatus[SIM_NOT_READY] =
1924       (RIL_AppStatus){RIL_APPTYPE_SIM,
1925                       RIL_APPSTATE_DETECTED,
1926                       RIL_PERSOSUBSTATE_UNKNOWN,
1927                       NULL,
1928                       NULL,
1929                       0,
1930                       RIL_PINSTATE_ENABLED_NOT_VERIFIED,
1931                       RIL_PINSTATE_ENABLED_NOT_VERIFIED};
1932   gRilAppStatus[SIM_READY] = (RIL_AppStatus){
1933       RIL_APPTYPE_SIM,
1934       RIL_APPSTATE_READY,
1935       RIL_PERSOSUBSTATE_READY,
1936       NULL,
1937       NULL,
1938       0,
1939       RIL_PINSTATE_ENABLED_VERIFIED,
1940       RIL_PINSTATE_ENABLED_VERIFIED,
1941   };
1942   gRilAppStatus[SIM_PIN] = (RIL_AppStatus){RIL_APPTYPE_SIM,
1943                                            RIL_APPSTATE_PIN,
1944                                            RIL_PERSOSUBSTATE_UNKNOWN,
1945                                            NULL,
1946                                            NULL,
1947                                            0,
1948                                            RIL_PINSTATE_ENABLED_NOT_VERIFIED,
1949                                            RIL_PINSTATE_UNKNOWN};
1950   gRilAppStatus[SIM_PUK] = (RIL_AppStatus){RIL_APPTYPE_SIM,
1951                                            RIL_APPSTATE_PUK,
1952                                            RIL_PERSOSUBSTATE_UNKNOWN,
1953                                            NULL,
1954                                            NULL,
1955                                            0,
1956                                            RIL_PINSTATE_ENABLED_BLOCKED,
1957                                            RIL_PINSTATE_UNKNOWN};
1958   gRilAppStatus[SIM_NETWORK_PERSONALIZATION] =
1959       (RIL_AppStatus){RIL_APPTYPE_SIM,
1960                       RIL_APPSTATE_SUBSCRIPTION_PERSO,
1961                       RIL_PERSOSUBSTATE_SIM_NETWORK,
1962                       NULL,
1963                       NULL,
1964                       0,
1965                       RIL_PINSTATE_ENABLED_NOT_VERIFIED,
1966                       RIL_PINSTATE_UNKNOWN};
1967   gRilAppStatus[RUIM_ABSENT] = (RIL_AppStatus){RIL_APPTYPE_UNKNOWN,
1968                                                RIL_APPSTATE_UNKNOWN,
1969                                                RIL_PERSOSUBSTATE_UNKNOWN,
1970                                                NULL,
1971                                                NULL,
1972                                                0,
1973                                                RIL_PINSTATE_UNKNOWN,
1974                                                RIL_PINSTATE_UNKNOWN};
1975   gRilAppStatus[RUIM_NOT_READY] = (RIL_AppStatus){RIL_APPTYPE_RUIM,
1976                                                   RIL_APPSTATE_DETECTED,
1977                                                   RIL_PERSOSUBSTATE_UNKNOWN,
1978                                                   NULL,
1979                                                   NULL,
1980                                                   0,
1981                                                   RIL_PINSTATE_UNKNOWN,
1982                                                   RIL_PINSTATE_UNKNOWN};
1983   gRilAppStatus[RUIM_READY] = (RIL_AppStatus){RIL_APPTYPE_RUIM,
1984                                               RIL_APPSTATE_READY,
1985                                               RIL_PERSOSUBSTATE_READY,
1986                                               NULL,
1987                                               NULL,
1988                                               0,
1989                                               RIL_PINSTATE_UNKNOWN,
1990                                               RIL_PINSTATE_UNKNOWN};
1991   gRilAppStatus[RUIM_PIN] = (RIL_AppStatus){RIL_APPTYPE_RUIM,
1992                                             RIL_APPSTATE_PIN,
1993                                             RIL_PERSOSUBSTATE_UNKNOWN,
1994                                             NULL,
1995                                             NULL,
1996                                             0,
1997                                             RIL_PINSTATE_ENABLED_NOT_VERIFIED,
1998                                             RIL_PINSTATE_UNKNOWN};
1999   gRilAppStatus[RUIM_PUK] = (RIL_AppStatus){RIL_APPTYPE_RUIM,
2000                                             RIL_APPSTATE_PUK,
2001                                             RIL_PERSOSUBSTATE_UNKNOWN,
2002                                             NULL,
2003                                             NULL,
2004                                             0,
2005                                             RIL_PINSTATE_ENABLED_BLOCKED,
2006                                             RIL_PINSTATE_UNKNOWN};
2007   gRilAppStatus[RUIM_NETWORK_PERSONALIZATION] =
2008       (RIL_AppStatus){RIL_APPTYPE_RUIM,
2009                       RIL_APPSTATE_SUBSCRIPTION_PERSO,
2010                       RIL_PERSOSUBSTATE_SIM_NETWORK,
2011                       NULL,
2012                       NULL,
2013                       0,
2014                       RIL_PINSTATE_ENABLED_NOT_VERIFIED,
2015                       RIL_PINSTATE_UNKNOWN};
2016 }
2017 
2018 /**
2019  * Get the current card status.
2020  */
2021 static void getCardStatus(RIL_Token t) {
2022   ALOGV("Querying SIM status.");
2023   RIL_CardStatus_v6 card_status;
2024 
2025   if (gSimStatus == SIM_ABSENT) {
2026     card_status.card_state = RIL_CARDSTATE_ABSENT;
2027     card_status.num_applications = 0;
2028   } else {
2029     card_status.card_state = RIL_CARDSTATE_PRESENT;
2030     card_status.num_applications = 1;
2031   }
2032 
2033   card_status.universal_pin_state = RIL_PINSTATE_UNKNOWN;
2034   card_status.gsm_umts_subscription_app_index = -1;
2035   card_status.cdma_subscription_app_index = -1;
2036   card_status.ims_subscription_app_index = -1;
2037 
2038   // Initialize application status
2039   for (int i = 0; i < RIL_CARD_MAX_APPS; i++) {
2040     card_status.applications[i] = gRilAppStatus[SIM_ABSENT];
2041   }
2042 
2043   if (card_status.num_applications > 0) {
2044     card_status.gsm_umts_subscription_app_index = 0;
2045 
2046     card_status.applications[0] = gRilAppStatus[gSimStatus];
2047     card_status.universal_pin_state = card_status.applications[0].pin1;
2048     // To enable basic CDMA (currently neither supported nor functional):
2049     //    card_status.num_applications = 2;
2050     //    card_status.cdma_subscription_app_index = 1;
2051     //    card_status.applications[1] =
2052     //        gRilAppStatus[SIM_Status(gSimStatus + RUIM_ABSENT)];
2053   }
2054 
2055   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &card_status,
2056                                  sizeof(card_status));
2057 }
2058 
2059 struct SimSession {
2060   std::string aid;
2061 };
2062 
2063 static int gNextSimSessionId = 1;
2064 static std::map<int, SimSession> gSimSessions;
2065 
2066 static void request_sim_open_channel(void* data, size_t /*datalen*/,
2067                                      RIL_Token t) {
2068   char* aid = (char*)data;
2069   SimSession session;
2070 
2071   ALOGV("Requesting new SIM session");
2072 
2073   if (aid != NULL) {
2074     session.aid = aid;
2075   }
2076 
2077   int response = gNextSimSessionId++;
2078   gSimSessions[response] = session;
2079 
2080   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response));
2081 }
2082 
2083 static void request_sim_close_channel(void* data, size_t /*datalen*/,
2084                                       RIL_Token t) {
2085   int session = *(int*)(data);
2086 
2087   ALOGV("Closing SIM session %d", session);
2088 
2089   if (gSimSessions.erase(session) == 0) {
2090     // No such session.
2091     gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
2092   } else {
2093     gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2094   }
2095 }
2096 
2097 #if VSOC_PLATFORM_SDK_AFTER(K)
2098 static void request_sim_apdu(void* data, size_t /*datalen*/, RIL_Token t) {
2099   RIL_SIM_APDU* apdu = (RIL_SIM_APDU*)data;
2100 
2101   ALOGV("Requesting APDU: Session %d CLA %d INST %d Params: %d %d %d, data %s",
2102         apdu->sessionid, apdu->cla, apdu->instruction, apdu->p1, apdu->p2,
2103         apdu->p3, apdu->data);
2104 
2105   if (gSimSessions.find(apdu->sessionid) != gSimSessions.end()) {
2106     RIL_SIM_IO_Response sr{};
2107 
2108     // Fallback / default behavior.
2109     sr.sw1 = 144;
2110     sr.sw2 = 0;
2111     sr.simResponse = NULL;
2112 
2113     gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &sr, sizeof(sr));
2114   } else {
2115     gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
2116   }
2117 }
2118 #endif
2119 
2120 // 0 = Lock is available, but disabled.
2121 // 1 = Lock is available and enabled,
2122 // 2 = lock is neither available nor enabled
2123 static const int kFacilityLockAllDisabled = 0;
2124 
2125 static void request_facility_lock(void* data, size_t /*datalen*/, RIL_Token t) {
2126   char** data_vec = (char**)data;
2127 
2128   // TODO(ender): implement this; essentially: AT+CLCK
2129   // See http://www.activexperts.com/sms-component/at/commands/?at=%2BCLCK
2130   // and
2131   // opt/telephony/src/java/com/android/internal/telephony/CommandsInterface.java
2132   // opt/telephony/src/java/com/android/internal/telephony/uicc/UiccCardApplication.java
2133 
2134   ALOGV("Query Facility Lock Code: %s PIN2: %s Service(s): %s AID: %s",
2135         data_vec[0], data_vec[1], data_vec[2], data_vec[3]);
2136 
2137   // TODO(ender): there should be a bit vector of responses for each of the
2138   // services requested.
2139   // Depending on lock code, facilities may be unlocked or locked. We report
2140   // these are all unlocked, regardless of the query.
2141   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS,
2142                                  const_cast<int*>(&kFacilityLockAllDisabled),
2143                                  sizeof(kFacilityLockAllDisabled));
2144 }
2145 
2146 static void request_international_subscriber_id_number(RIL_Token t) {
2147   // TODO(ender): Reuse MCC and MNC.
2148   std::string subscriber_id = gCurrentNetworkOperator.c_str();
2149   subscriber_id += "123456789";
2150 
2151   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS,
2152                                  strdup(subscriber_id.c_str()), sizeof(char*));
2153 }
2154 
2155 static bool gScreenIsOn = true;
2156 
2157 static void request_set_screen_state(void* data, size_t /*datalen*/,
2158                                      RIL_Token t) {
2159   gScreenIsOn = *(int*)data ? true : false;
2160   ALOGV("Screen is %s", gScreenIsOn ? "on" : "off");
2161   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2162 }
2163 
2164 // Unsure which section this belongs in.
2165 
2166 static int gModemTtyMode = 1;  // 0 = off, 1 = full, 2 = HCO, 3 = VCO.
2167 static void request_set_tty_mode(void* data, size_t /*datalen*/, RIL_Token t) {
2168   int new_tty_mode = *(int*)(data);
2169   ALOGV("Switching modem TTY mode %d -> %d", gModemTtyMode, new_tty_mode);
2170 
2171   if (new_tty_mode >= 0 && new_tty_mode <= 3) {
2172     gModemTtyMode = new_tty_mode;
2173     gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2174   } else {
2175     gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
2176   }
2177 }
2178 
2179 static void request_get_tty_mode(RIL_Token t) {
2180   ALOGV("Querying TTY mode");
2181   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &gModemTtyMode,
2182                                  sizeof(gModemTtyMode));
2183 }
2184 
2185 static bool gImsRegistered = false;
2186 static int gImsFormat = RADIO_TECH_3GPP;
2187 
2188 static void request_ims_registration_state(RIL_Token t) {
2189   ALOGV("Querying IMS mode");
2190   int reply[2];
2191   reply[0] = gImsRegistered;
2192   reply[1] = gImsFormat;
2193 
2194   ALOGV("Requesting IMS Registration state: %d, format=%d ", reply[0],
2195         reply[1]);
2196 
2197   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, reply, sizeof(reply));
2198 }
2199 
2200 static void gce_ril_on_request(int request, void* data, size_t datalen,
2201                                RIL_Token t) {
2202   // Ignore all requests except RIL_REQUEST_GET_SIM_STATUS
2203   // when RADIO_STATE_UNAVAILABLE.
2204   if (gRadioPowerState == RADIO_STATE_UNAVAILABLE &&
2205       request != RIL_REQUEST_GET_SIM_STATUS) {
2206     gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
2207     return;
2208   }
2209 
2210   // Ignore all non-power requests when RADIO_STATE_OFF (except
2211   // RIL_REQUEST_GET_SIM_STATUS)
2212   if (gRadioPowerState == RADIO_STATE_OFF &&
2213       !(request == RIL_REQUEST_RADIO_POWER ||
2214         request == RIL_REQUEST_GET_SIM_STATUS)) {
2215     gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
2216     return;
2217   }
2218 
2219   ALOGV("Received request %d", request);
2220 
2221   switch (request) {
2222     case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS:
2223       request_query_available_networks(data, datalen, t);
2224       break;
2225     case RIL_REQUEST_GET_IMEI:
2226       request_get_imei(t);
2227       break;
2228     case RIL_REQUEST_GET_IMEISV:
2229       request_get_imei_sv(t);
2230       break;
2231     case RIL_REQUEST_DEACTIVATE_DATA_CALL:
2232       request_teardown_data_call(data, datalen, t);
2233       break;
2234     case RIL_REQUEST_SCREEN_STATE:
2235       request_set_screen_state(data, datalen, t);
2236       break;
2237     case RIL_REQUEST_GET_SIM_STATUS:
2238       getCardStatus(t);
2239       break;
2240     case RIL_REQUEST_GET_CURRENT_CALLS:
2241       request_get_current_calls(data, datalen, t);
2242       break;
2243     case RIL_REQUEST_DIAL:
2244       request_dial(data, datalen, t);
2245       break;
2246     case RIL_REQUEST_HANGUP:
2247       request_hangup(data, datalen, t);
2248       break;
2249     case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND:
2250       request_hangup_waiting(data, datalen, t);
2251       break;
2252     case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND:
2253       request_hangup_current(t);
2254       break;
2255     case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE:
2256       request_switch_current_and_waiting(t);
2257       break;
2258     case RIL_REQUEST_ANSWER:
2259       request_answer_incoming(t);
2260       break;
2261     case RIL_REQUEST_SET_MUTE:
2262       request_set_mute(data, datalen, t);
2263       break;
2264     case RIL_REQUEST_GET_MUTE:
2265       request_get_mute(t);
2266       break;
2267     case RIL_REQUEST_CONFERENCE:
2268       request_combine_multiparty_call(data, datalen, t);
2269       break;
2270     case RIL_REQUEST_SEPARATE_CONNECTION:
2271       request_split_multiparty_call(data, datalen, t);
2272       break;
2273     case RIL_REQUEST_UDUB:
2274       request_udub_on_incoming_calls(t);
2275       break;
2276     case RIL_REQUEST_SIGNAL_STRENGTH:
2277       request_signal_strength(data, datalen, t);
2278       break;
2279     case RIL_REQUEST_VOICE_REGISTRATION_STATE:
2280     case RIL_REQUEST_DATA_REGISTRATION_STATE:
2281       request_registration_state(request, data, datalen, t);
2282       break;
2283     case RIL_REQUEST_OPERATOR:
2284       request_operator(data, datalen, t);
2285       break;
2286     case RIL_REQUEST_RADIO_POWER:
2287       request_radio_power(data, datalen, t);
2288       break;
2289     case RIL_REQUEST_DTMF:
2290     case RIL_REQUEST_DTMF_START:
2291       request_send_dtmf(data, datalen, t);
2292       break;
2293     case RIL_REQUEST_DTMF_STOP:
2294       request_send_dtmf_stop(t);
2295       break;
2296     case RIL_REQUEST_SEND_SMS:
2297       request_send_SMS(data, t);
2298       break;
2299     case RIL_REQUEST_CDMA_SEND_SMS:
2300       request_cdma_send_SMS(data, t);
2301       break;
2302     case RIL_REQUEST_SETUP_DATA_CALL:
2303       request_setup_data_call(data, datalen, t);
2304       break;
2305     case RIL_REQUEST_SMS_ACKNOWLEDGE:
2306       request_SMS_acknowledge(data, datalen, t);
2307       break;
2308     case RIL_REQUEST_GET_IMSI:
2309       request_international_subscriber_id_number(t);
2310       break;
2311     case RIL_REQUEST_QUERY_FACILITY_LOCK:
2312       request_facility_lock(data, datalen, t);
2313       break;
2314     case RIL_REQUEST_SIM_IO:
2315       request_SIM_IO(data, datalen, t);
2316       break;
2317     case RIL_REQUEST_SEND_USSD:
2318       request_send_ussd(data, datalen, t);
2319       break;
2320     case RIL_REQUEST_CANCEL_USSD:
2321       request_cancel_ussd(t);
2322       break;
2323     case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC:
2324       request_set_automatic_network_selection(t);
2325       break;
2326     case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL:
2327       request_set_manual_network_selection(data, datalen, t);
2328       break;
2329     case RIL_REQUEST_DATA_CALL_LIST:
2330       request_data_calllist(data, datalen, t);
2331       break;
2332     case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE:
2333       request_datacall_fail_cause(t);
2334       break;
2335     case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE:
2336       request_query_network_selection_mode(data, datalen, t);
2337       break;
2338     case RIL_REQUEST_OEM_HOOK_RAW:
2339     case RIL_REQUEST_OEM_HOOK_STRINGS:
2340       ALOGV("OEM Hooks not supported!");
2341       gce_ril_env->OnRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
2342       break;
2343     case RIL_REQUEST_WRITE_SMS_TO_SIM:
2344       request_write_sms_to_sim(data, datalen, t);
2345       break;
2346     case RIL_REQUEST_DELETE_SMS_ON_SIM:
2347       request_delete_sms_on_sim(data, datalen, t);
2348       break;
2349     case RIL_REQUEST_ENTER_SIM_PIN:
2350     case RIL_REQUEST_ENTER_SIM_PUK:
2351     case RIL_REQUEST_ENTER_SIM_PIN2:
2352     case RIL_REQUEST_ENTER_SIM_PUK2:
2353     case RIL_REQUEST_CHANGE_SIM_PIN:
2354     case RIL_REQUEST_CHANGE_SIM_PIN2:
2355       request_enter_sim_pin(data, datalen, t);
2356       break;
2357     case RIL_REQUEST_VOICE_RADIO_TECH: {
2358       RIL_RadioTechnology tech = getBestVoiceTechnology(gModemCurrentType);
2359       gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &tech, sizeof(tech));
2360       break;
2361     }
2362     case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE:
2363       request_set_preferred_network_type(request, data, datalen, t);
2364       break;
2365     case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE:
2366       request_get_preferred_network_type(request, data, datalen, t);
2367       break;
2368     case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS:
2369       request_get_neighboring_cell_ids(data, datalen, t);
2370       break;
2371 #if VSOC_PLATFORM_SDK_AFTER(J_MR1)
2372     case RIL_REQUEST_GET_CELL_INFO_LIST:
2373       request_get_cell_info_list(data, datalen, t);
2374       break;
2375     case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE:
2376       request_set_cell_info_list_rate(data, datalen, t);
2377       break;
2378 #endif
2379     case RIL_REQUEST_BASEBAND_VERSION:
2380       request_baseband_version(t);
2381       break;
2382     case RIL_REQUEST_SET_TTY_MODE:
2383       request_set_tty_mode(data, datalen, t);
2384       break;
2385     case RIL_REQUEST_QUERY_TTY_MODE:
2386       request_get_tty_mode(t);
2387       break;
2388 
2389 #if VSOC_PLATFORM_SDK_AFTER(L)
2390     case RIL_REQUEST_GET_RADIO_CAPABILITY:
2391       request_get_radio_capability(t);
2392       break;
2393     case RIL_REQUEST_SET_RADIO_CAPABILITY:
2394       request_set_radio_capability(data, datalen, t);
2395       break;
2396 #endif
2397 #if VSOC_PLATFORM_SDK_AFTER(K)
2398     case RIL_REQUEST_GET_HARDWARE_CONFIG:
2399       request_hardware_config(t);
2400       break;
2401     case RIL_REQUEST_IMS_REGISTRATION_STATE:
2402       request_ims_registration_state(t);
2403       break;
2404     case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL:
2405       request_sim_apdu(data, datalen, t);
2406       break;
2407     case RIL_REQUEST_SIM_OPEN_CHANNEL:
2408       request_sim_open_channel(data, datalen, t);
2409       break;
2410     case RIL_REQUEST_SIM_CLOSE_CHANNEL:
2411       request_sim_close_channel(data, datalen, t);
2412       break;
2413 #endif
2414 #if VSOC_PLATFORM_SDK_AFTER(J_MR2)
2415     case RIL_REQUEST_IMS_SEND_SMS:
2416       request_ims_send_SMS(data, datalen, t);
2417       break;
2418 
2419     case RIL_REQUEST_SET_INITIAL_ATTACH_APN:
2420       ALOGW("INITIAL ATTACH APN");
2421       gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2422       break;
2423 
2424 #endif
2425     case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING:
2426       gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2427       break;
2428     case RIL_REQUEST_DEVICE_IDENTITY:
2429       request_device_identity(request, data, datalen, t);
2430       break;
2431     case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE:
2432       request_cdma_get_subscription_source(request, data, datalen, t);
2433       break;
2434     case RIL_REQUEST_CDMA_SUBSCRIPTION:
2435       request_cdma_subscription(request, data, datalen, t);
2436       break;
2437     case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:
2438       request_cdma_set_subscription_source(request, data, datalen, t);
2439       break;
2440     case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:
2441       request_cdma_get_roaming_preference(request, data, datalen, t);
2442       break;
2443     case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:
2444       request_cdma_set_roaming_preference(request, data, datalen, t);
2445       break;
2446     case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE:
2447       request_exit_emergency_mode(data, datalen, t);
2448       break;
2449     default:
2450       ALOGE("Request %d not supported.", request);
2451       gce_ril_env->OnRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
2452       break;
2453   }
2454 }
2455 
2456 #define VSOC_RIL_VERSION 6
2457 
2458 static const RIL_RadioFunctions ril_callbacks = {
2459     VSOC_RIL_VERSION,     gce_ril_on_request, gce_ril_current_state,
2460     gce_ril_on_supports, gce_ril_on_cancel,  gce_ril_get_version};
2461 
2462 extern "C" {
2463 
2464 const RIL_RadioFunctions* RIL_Init(const struct RIL_Env* env, int /*argc*/,
2465                                    char** /*argv*/) {
2466   time(&gce_ril_start_time);
2467   gce_ril_env = env;
2468 
2469   TearDownNetworkInterface();
2470 
2471   init_modem_supported_network_types();
2472   init_modem_technologies();
2473   init_virtual_network();
2474   init_sim_file_system();
2475   init_sim_status();
2476 
2477   return &ril_callbacks;
2478 }
2479 
2480 }  // extern "C"
2481