开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > android开发 > 查看源码
ril.cpp
资源名称：ril.rar　[点击查看]
上传用户：rftzhifu
上传日期：2017-02-21
资源大小：229k
文件大小：60k
源码类别：

android开发

开发平台：

Unix_Linux

ril.cpp：源码内容
  1. /* //device/libs/telephony/ril.cpp
  2. **
  3. ** Copyright 2006, The Android Open Source Project
  4. **
  5. ** Licensed under the Apache License, Version 2.0 (the "License"); 
  6. ** you may not use this file except in compliance with the License. 
  7. ** You may obtain a copy of the License at 
  8. **
  9. **     http://www.apache.org/licenses/LICENSE-2.0 
  10. **
  11. ** Unless required by applicable law or agreed to in writing, software 
  12. ** distributed under the License is distributed on an "AS IS" BASIS, 
  13. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  14. ** See the License for the specific language governing permissions and 
  15. ** limitations under the License.
  16. */
  18. #define LOG_TAG "RILC"
  20. #include <telephony/ril.h>
  21. #include <cutils/sockets.h>
  22. #include <cutils/jstring.h>
  23. #include <cutils/record_stream.h>
  24. #include <utils/Log.h>
  25. #include <utils/SystemClock.h>
  26. #include <pthread.h>
  27. #include <utils/Parcel.h>
  28. #include <cutils/jstring.h>
  30. #include <sys/types.h>
  31. #include <pwd.h>
  33. #include <stdio.h>
  34. #include <stdlib.h>
  35. #include <stdarg.h>
  36. #include <string.h>
  37. #include <unistd.h>
  38. #include <fcntl.h>
  39. #include <time.h>
  40. #include <errno.h>
  41. #include <assert.h>
  42. #include <ctype.h>
  43. #include <alloca.h>
  44. #include <sys/un.h>
  45. #include <assert.h>
  46. #include <netinet/in.h>
  47. #include <cutils/properties.h>
  49. #include <ril_event.h>
  51. namespace android {
  53. #define PHONE_PROCESS "radio"
  55. #define SOCKET_NAME_RIL "rild"
  56. #define SOCKET_NAME_RIL_DEBUG "rild-debug"
  58. #define ANDROID_WAKE_LOCK_NAME "radio-interface"
  61. #define ANDROID_PARTIAL_WAKE_LOCK_PATH "/sys/android_power/acquire_partial_wake_lock"
  62. #define ANDROID_FULL_WAKE_LOCK_PATH "/sys/android_power/acquire_full_wake_lock"
  63. #define ANDROID_WAKE_UNLOCK_PATH "/sys/android_power/release_wake_lock"
  65. #define PROPERTY_RIL_IMPL "gsm.version.ril-impl"
  67. // match with constant in RIL.java
  68. #define MAX_COMMAND_BYTES (8 * 1024)
  70. // Basically: memset buffers that the client library
  71. // shouldn't be using anymore in an attempt to find
  72. // memory usage issues sooner.
  73. #define MEMSET_FREED 1
  75. #define NUM_ELEMS(a)     (sizeof (a) / sizeof (a)[0])
  77. /* Constants for response types */
  78. #define RESPONSE_SOLICITED 0
  79. #define RESPONSE_UNSOLICITED 1
  81. /* Negative values for private RIL errno's */
  82. #define RIL_ERRNO_INVALID_RESPONSE -1
  84. // request, response, and unsolicited msg print macro
  85. #define PRINTBUF_SIZE 8096
  87. // Enable RILC log
  88. #define RILC_LOG 0
  90. #if RILC_LOG
  91.     #define startRequest           sprintf(printBuf, "(")
  92.     #define closeRequest           sprintf(printBuf, "%s)", printBuf)
  93.     #define printRequest(token, req)           
  94.             LOGD("[%04d]> %s %s", token, requestToString(req), printBuf)
  96.     #define startResponse           sprintf(printBuf, "%s {", printBuf)
  97.     #define closeResponse           sprintf(printBuf, "%s}", printBuf)
  98.     #define printResponse           LOGD("%s", printBuf)
  100.     #define clearPrintBuf           printBuf[0] = 0
  101.     #define removeLastChar          printBuf[strlen(printBuf)-1] = 0
  102.     #define appendPrintBuf(x...)    sprintf(printBuf, x)
  103. #else
  104.     #define startRequest
  105.     #define closeRequest
  106.     #define printRequest(token, req)
  107.     #define startResponse
  108.     #define closeResponse
  109.     #define printResponse
  110.     #define clearPrintBuf
  111.     #define removeLastChar
  112.     #define appendPrintBuf(x...)
  113. #endif
  115. enum WakeType {DONT_WAKE, WAKE_PARTIAL, WAKE_FULL};
  117. typedef struct {
  118.     int requestNumber;
  119.     void (*dispatchFunction) (Parcel &p, struct RequestInfo *pRI);
  120.     int(*responseFunction) (Parcel &p, void *response, size_t responselen);
  121. } CommandInfo;
  123. typedef struct {
  124.     int requestNumber;
  125.     int (*responseFunction) (Parcel &p, void *response, size_t responselen);
  126.     WakeType wakeType;
  127. } UnsolResponseInfo;
  129. typedef struct RequestInfo {
  130.     int32_t token;      //this is not RIL_Token 
  131.     CommandInfo *pCI;
  132.     struct RequestInfo *p_next;
  133.     char cancelled;
  134.     char local;         // responses to local commands do not go back to command process
  135. } RequestInfo;
  137. typedef struct UserCallbackInfo{
  138.     RIL_TimedCallback p_callback;
  139.     void *userParam;
  140.     struct ril_event event;
  141.     struct UserCallbackInfo *p_next;
  142. } UserCallbackInfo;
  145. /*******************************************************************/
  147. RIL_RadioFunctions s_callbacks = {0, NULL, NULL, NULL, NULL, NULL};
  148. static int s_registerCalled = 0;
  150. static pthread_t s_tid_dispatch;
  151. static pthread_t s_tid_reader;
  152. static int s_started = 0;
  154. static int s_fdListen = -1;
  155. static int s_fdCommand = -1;
  156. static int s_fdDebug = -1;
  158. static int s_fdWakeupRead;
  159. static int s_fdWakeupWrite;
  161. static struct ril_event s_commands_event;
  162. static struct ril_event s_wakeupfd_event;
  163. static struct ril_event s_listen_event;
  164. static struct ril_event s_wake_timeout_event;
  165. static struct ril_event s_debug_event;
  168. static const struct timeval TIMEVAL_WAKE_TIMEOUT = {1,0};
  170. static pthread_mutex_t s_pendingRequestsMutex = PTHREAD_MUTEX_INITIALIZER;
  171. static pthread_mutex_t s_writeMutex = PTHREAD_MUTEX_INITIALIZER;
  172. static pthread_mutex_t s_startupMutex = PTHREAD_MUTEX_INITIALIZER;
  173. static pthread_cond_t s_startupCond = PTHREAD_COND_INITIALIZER;
  175. static pthread_mutex_t s_dispatchMutex = PTHREAD_MUTEX_INITIALIZER;
  176. static pthread_cond_t s_dispatchCond = PTHREAD_COND_INITIALIZER;
  178. static RequestInfo *s_pendingRequests = NULL;
  180. static RequestInfo *s_toDispatchHead = NULL;
  181. static RequestInfo *s_toDispatchTail = NULL;
  183. static UserCallbackInfo *s_last_wake_timeout_info = NULL;
  185. static void *s_lastNITZTimeData = NULL;
  186. static size_t s_lastNITZTimeDataSize;
  188. #if RILC_LOG
  189.     static char printBuf[PRINTBUF_SIZE];
  190. #endif
  192. /*******************************************************************/
  194. static void dispatchVoid (Parcel& p, RequestInfo *pRI);
  195. static void dispatchString (Parcel& p, RequestInfo *pRI);
  196. static void dispatchStrings (Parcel& p, RequestInfo *pRI);
  197. static void dispatchInts (Parcel& p, RequestInfo *pRI);
  198. static void dispatchDial (Parcel& p, RequestInfo *pRI);
  199. static void dispatchSIM_IO (Parcel& p, RequestInfo *pRI);
  200. static void dispatchCallForward(Parcel& p, RequestInfo *pRI);
  201. static void dispatchRaw(Parcel& p, RequestInfo *pRI);
  202. static void dispatchSmsWrite (Parcel &p, RequestInfo *pRI);
  204. static int responseInts(Parcel &p, void *response, size_t responselen);
  205. static int responseStrings(Parcel &p, void *response, size_t responselen);
  206. static int responseString(Parcel &p, void *response, size_t responselen);
  207. static int responseVoid(Parcel &p, void *response, size_t responselen);
  208. static int responseCallList(Parcel &p, void *response, size_t responselen);
  209. static int responseSMS(Parcel &p, void *response, size_t responselen);
  210. static int responseSIM_IO(Parcel &p, void *response, size_t responselen);
  211. static int responseCallForwards(Parcel &p, void *response, size_t responselen);
  212. static int responseContexts(Parcel &p, void *response, size_t responselen);
  213. static int responseRaw(Parcel &p, void *response, size_t responselen);
  214. static int responseSsn(Parcel &p, void *response, size_t responselen);
  215. static int responseCellList(Parcel &p, void *response, size_t responselen);
  217. extern "C" const char * requestToString(int request);
  218. extern "C" const char * failCauseToString(RIL_Errno);
  219. extern "C" const char * callStateToString(RIL_CallState);
  220. extern "C" const char * radioStateToString(RIL_RadioState);
  222. #ifdef RIL_SHLIB
  223. extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, void *data, 
  224.                                 size_t datalen);
  225. #endif
  227. static UserCallbackInfo * internalRequestTimedCallback 
  228.     (RIL_TimedCallback callback, void *param, 
  229.         const struct timeval *relativeTime);
  231. /** Index == requestNumber */
  232. static CommandInfo s_commands[] = {
  233. #include "ril_commands.h"
  234. };
  236. static UnsolResponseInfo s_unsolResponses[] = {
  237. #include "ril_unsol_commands.h"
  238. };
  241. static char *
  242. strdupReadString(Parcel &p)
  243. {
  244.     size_t stringlen;
  245.     const char16_t *s16;
  246.             
  247.     s16 = p.readString16Inplace(&stringlen);
  248.     
  249.     return strndup16to8(s16, stringlen);
  250. }
  252. static void writeStringToParcel(Parcel &p, const char *s)
  253. {
  254.     char16_t *s16;
  255.     size_t s16_len;
  256.     s16 = strdup8to16(s, &s16_len);
  257.     p.writeString16(s16, s16_len);
  258.     free(s16);
  259. }
  262. static void
  263. memsetString (char *s)
  264. {
  265.     if (s != NULL) {
  266.         memset (s, 0, strlen(s));
  267.     }
  268. }
  270. void   nullParcelReleaseFunction (const uint8_t* data, size_t dataSize,
  271.                                     const size_t* objects, size_t objectsSize,
  272.                                         void* cookie)
  273. {
  274.     // do nothing -- the data reference lives longer than the Parcel object
  275. }
  277. /** 
  278.  * To be called from dispatch thread
  279.  * Issue a single local request, ensuring that the response
  280.  * is not sent back up to the command process 
  281.  */
  282. static void
  283. issueLocalRequest(int request, void *data, int len)
  284. {
  285.     RequestInfo *pRI;
  286.     int ret;
  288.     pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
  290.     pRI->local = 1;
  291.     pRI->token = 0xffffffff;        // token is not used in this context
  292.     pRI->pCI = &(s_commands[request]);
  294.     ret = pthread_mutex_lock(&s_pendingRequestsMutex);
  295.     assert (ret == 0);
  297.     pRI->p_next = s_pendingRequests;
  298.     s_pendingRequests = pRI;
  300.     ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
  301.     assert (ret == 0);
  303.     LOGD("C[locl]> %s", requestToString(request));
  305.     s_callbacks.onRequest(request, data, len, pRI);
  306. }
  310. static int
  311. processCommandBuffer(void *buffer, size_t buflen)
  312. {
  313.     Parcel p;
  314.     status_t status;
  315.     int32_t request;
  316.     int32_t token;
  317.     RequestInfo *pRI;
  318.     int ret;
  320.     p.setData((uint8_t *) buffer, buflen);
  322.     // status checked at end
  323.     status = p.readInt32(&request);
  324.     status = p.readInt32 (&token);
  326.     if (status != NO_ERROR) {
  327.         LOGE("invalid request block");
  328.         return 0;
  329.     }
  331.     if (request < 1 || request >= (int32_t)NUM_ELEMS(s_commands)) {
  332.         LOGE("unsupported request code %d token %d", request, token);
  333.         // FIXME this should perhaps return a response
  334.         return 0;
  335.     }
  338.     pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
  340.     pRI->token = token;
  341.     pRI->pCI = &(s_commands[request]);
  343.     ret = pthread_mutex_lock(&s_pendingRequestsMutex);
  344.     assert (ret == 0);
  346.     pRI->p_next = s_pendingRequests;
  347.     s_pendingRequests = pRI;
  349.     ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
  350.     assert (ret == 0);
  352. /*    sLastDispatchedToken = token; */
  354.     pRI->pCI->dispatchFunction(p, pRI);    
  356.     return 0;
  357. }
  359. static void
  360. invalidCommandBlock (RequestInfo *pRI)
  361. {
  362.     LOGE("invalid command block for token %d request %s", 
  363.                 pRI->token, requestToString(pRI->pCI->requestNumber));
  364. }
  366. /** Callee expects NULL */
  367. static void 
  368. dispatchVoid (Parcel& p, RequestInfo *pRI)
  369. {
  370.     clearPrintBuf;
  371.     printRequest(pRI->token, pRI->pCI->requestNumber);
  372.     s_callbacks.onRequest(pRI->pCI->requestNumber, NULL, 0, pRI);
  373. }
  375. /** Callee expects const char * */
  376. static void
  377. dispatchString (Parcel& p, RequestInfo *pRI)
  378. {
  379.     status_t status;
  380.     size_t datalen;
  381.     size_t stringlen;
  382.     char *string8 = NULL;
  384.     string8 = strdupReadString(p);
  386.     startRequest;
  387.     appendPrintBuf("%s%s", printBuf, string8);
  388.     closeRequest;
  389.     printRequest(pRI->token, pRI->pCI->requestNumber);
  391.     s_callbacks.onRequest(pRI->pCI->requestNumber, string8,
  392.                        sizeof(char *), pRI);
  394. #ifdef MEMSET_FREED
  395.     memsetString(string8);
  396. #endif
  398.     free(string8);
  399.     return;
  400. invalid:
  401.     invalidCommandBlock(pRI);
  402.     return;
  403. }
  405. /** Callee expects const char ** */
  406. static void
  407. dispatchStrings (Parcel &p, RequestInfo *pRI)
  408. {
  409.     int32_t countStrings;
  410.     status_t status;
  411.     size_t datalen;
  412.     char **pStrings;
  414.     status = p.readInt32 (&countStrings);
  416.     if (status != NO_ERROR) {
  417.         goto invalid;
  418.     }
  420.     startRequest;
  421.     if (countStrings == 0) {
  422.         // just some non-null pointer
  423.         pStrings = (char **)alloca(sizeof(char *));
  424.         datalen = 0;
  425.     } else if (((int)countStrings) == -1) {
  426.         pStrings = NULL;
  427.         datalen = 0;
  428.     } else {
  429.         datalen = sizeof(char *) * countStrings;
  430.     
  431.         pStrings = (char **)alloca(datalen);
  433.         for (int i = 0 ; i < countStrings ; i++) {
  434.             pStrings[i] = strdupReadString(p);
  435.             appendPrintBuf("%s%s,", printBuf, pStrings[i]);
  436.         }
  437.     }
  438.     removeLastChar;
  439.     closeRequest;
  440.     printRequest(pRI->token, pRI->pCI->requestNumber);
  442.     s_callbacks.onRequest(pRI->pCI->requestNumber, pStrings, datalen, pRI);
  444.     if (pStrings != NULL) {
  445.         for (int i = 0 ; i < countStrings ; i++) {
  446. #ifdef MEMSET_FREED
  447.             memsetString (pStrings[i]);
  448. #endif
  449.             free(pStrings[i]);
  450.         }
  452. #ifdef MEMSET_FREED
  453.         memset(pStrings, 0, datalen);
  454. #endif
  455.     }
  456.     
  457.     return;
  458. invalid:
  459.     invalidCommandBlock(pRI);
  460.     return;
  461. }
  463. /** Callee expects const int * */
  464. static void
  465. dispatchInts (Parcel &p, RequestInfo *pRI)
  466. {
  467.     int32_t count;
  468.     status_t status;
  469.     size_t datalen;
  470.     int *pInts;
  472.     status = p.readInt32 (&count);
  474.     if (status != NO_ERROR || count == 0) {
  475.         goto invalid;
  476.     }
  478.     datalen = sizeof(int) * count;
  479.     pInts = (int *)alloca(datalen);
  481.     startRequest;
  482.     for (int i = 0 ; i < count ; i++) {
  483.         int32_t t;
  485.         status = p.readInt32(&t);
  486.         pInts[i] = (int)t;
  487.         appendPrintBuf("%s%d,", printBuf, t);
  489.         if (status != NO_ERROR) {
  490.             goto invalid;
  491.         }
  492.    }
  493.    removeLastChar;
  494.    closeRequest;
  495.    printRequest(pRI->token, pRI->pCI->requestNumber);
  497.    s_callbacks.onRequest(pRI->pCI->requestNumber, const_cast<int *>(pInts), 
  498.                        datalen, pRI);
  500. #ifdef MEMSET_FREED
  501.     memset(pInts, 0, datalen);
  502. #endif
  504.     return;
  505. invalid:
  506.     invalidCommandBlock(pRI);
  507.     return;
  508. }
  511. /** 
  512.  * Callee expects const RIL_SMS_WriteArgs * 
  513.  * Payload is:
  514.  *   int32_t status
  515.  *   String pdu
  516.  */
  517. static void
  518. dispatchSmsWrite (Parcel &p, RequestInfo *pRI)
  519. {
  520.     RIL_SMS_WriteArgs args;
  521.     int32_t t;
  522.     status_t status;
  524.     memset (&args, 0, sizeof(args));
  526.     status = p.readInt32(&t);
  527.     args.status = (int)t;
  529.     args.pdu = strdupReadString(p);
  531.     if (status != NO_ERROR || args.pdu == NULL) {
  532.         goto invalid;
  533.     }
  535.     args.smsc = strdupReadString(p);
  537.     startRequest;
  538.     appendPrintBuf("%s%d,%s,smsc=%s", printBuf, args.status,
  539.         (char*)args.pdu,  (char*)args.smsc);
  540.     closeRequest;
  541.     printRequest(pRI->token, pRI->pCI->requestNumber);
  542.     
  543.     s_callbacks.onRequest(pRI->pCI->requestNumber, &args, sizeof(args), pRI);
  545. #ifdef MEMSET_FREED
  546.     memsetString (args.pdu);
  547. #endif
  549.     free (args.pdu);
  550.     
  551. #ifdef MEMSET_FREED
  552.     memset(&args, 0, sizeof(args));
  553. #endif
  555.     return;
  556. invalid:
  557.     invalidCommandBlock(pRI);
  558.     return;
  559. }
  561. /** 
  562.  * Callee expects const RIL_Dial * 
  563.  * Payload is:
  564.  *   String address
  565.  *   int32_t clir
  566.  */
  567. static void
  568. dispatchDial (Parcel &p, RequestInfo *pRI)
  569. {
  570.     RIL_Dial dial;
  571.     int32_t t;
  572.     status_t status;
  574.     memset (&dial, 0, sizeof(dial));
  576.     dial.address = strdupReadString(p);
  578.     status = p.readInt32(&t);
  579.     dial.clir = (int)t;
  581.     if (status != NO_ERROR || dial.address == NULL) {
  582.         goto invalid;
  583.     }
  585.     startRequest;
  586.     appendPrintBuf("%snum=%s,clir=%d", printBuf, dial.address, dial.clir);
  587.     closeRequest;
  588.     printRequest(pRI->token, pRI->pCI->requestNumber);
  590.     s_callbacks.onRequest(pRI->pCI->requestNumber, &dial, sizeof(dial), pRI);
  592. #ifdef MEMSET_FREED
  593.     memsetString (dial.address);
  594. #endif
  596.     free (dial.address);
  597.     
  598. #ifdef MEMSET_FREED
  599.     memset(&dial, 0, sizeof(dial));
  600. #endif
  602.     return;
  603. invalid:
  604.     invalidCommandBlock(pRI);
  605.     return;
  606. }
  608. /** 
  609.  * Callee expects const RIL_SIM_IO * 
  610.  * Payload is:
  611.  *   int32_t command
  612.  *   int32_t fileid
  613.  *   String path
  614.  *   int32_t p1, p2, p3
  615.  *   String data 
  616.  *   String pin2 
  617.  */
  618. static void
  619. dispatchSIM_IO (Parcel &p, RequestInfo *pRI)
  620. {
  621.     RIL_SIM_IO simIO;
  622.     int32_t t;
  623.     status_t status;
  625.     memset (&simIO, 0, sizeof(simIO));
  627.     // note we only check status at the end 
  628.     
  629.     status = p.readInt32(&t);
  630.     simIO.command = (int)t;
  632.     status = p.readInt32(&t);
  633.     simIO.fileid = (int)t;
  635.     simIO.path = strdupReadString(p);
  637.     status = p.readInt32(&t);
  638.     simIO.p1 = (int)t;
  640.     status = p.readInt32(&t);
  641.     simIO.p2 = (int)t;
  643.     status = p.readInt32(&t);
  644.     simIO.p3 = (int)t;
  646.     simIO.data = strdupReadString(p);
  647.     simIO.pin2 = strdupReadString(p);
  649.     startRequest;
  650.     appendPrintBuf("%scmd=0x%X,efid=0x%X,path=%s,%d,%d,%d,%s,pin2=%s", printBuf,
  651.         simIO.command, simIO.fileid, (char*)simIO.path,
  652.         simIO.p1, simIO.p2, simIO.p3,
  653.         (char*)simIO.data,  (char*)simIO.pin2);
  654.     closeRequest;
  655.     printRequest(pRI->token, pRI->pCI->requestNumber);
  656.     
  657.     if (status != NO_ERROR) {
  658.         goto invalid;
  659.     }
  661.        s_callbacks.onRequest(pRI->pCI->requestNumber, &simIO, sizeof(simIO), pRI);
  663. #ifdef MEMSET_FREED
  664.     memsetString (simIO.path);
  665.     memsetString (simIO.data);
  666.     memsetString (simIO.pin2);
  667. #endif
  669.     free (simIO.path);
  670.     free (simIO.data);
  671.     free (simIO.pin2);
  672.     
  673. #ifdef MEMSET_FREED
  674.     memset(&simIO, 0, sizeof(simIO));
  675. #endif
  677.     return;
  678. invalid:
  679.     invalidCommandBlock(pRI);
  680.     return;
  681. }
  683. /**
  684.  * Callee expects const RIL_CallForwardInfo *
  685.  * Payload is:
  686.  *  int32_t status/action
  687.  *  int32_t reason
  688.  *  int32_t serviceCode
  689.  *  int32_t toa
  690.  *  String number  (0 length -> null)
  691.  *  int32_t timeSeconds
  692.  */
  693. static void 
  694. dispatchCallForward(Parcel &p, RequestInfo *pRI)
  695. {
  696.     RIL_CallForwardInfo cff;
  697.     int32_t t;
  698.     status_t status;
  700.     memset (&cff, 0, sizeof(cff));
  702.     // note we only check status at the end 
  704.     status = p.readInt32(&t);
  705.     cff.status = (int)t;
  706.     
  707.     status = p.readInt32(&t);
  708.     cff.reason = (int)t;
  710.     status = p.readInt32(&t);
  711.     cff.serviceClass = (int)t;
  713.     status = p.readInt32(&t);
  714.     cff.toa = (int)t;
  716.     cff.number = strdupReadString(p);
  718.     status = p.readInt32(&t);
  719.     cff.timeSeconds = (int)t;
  721.     if (status != NO_ERROR) {
  722.         goto invalid;
  723.     }
  725.     // special case: number 0-length fields is null
  727.     if (cff.number != NULL && strlen (cff.number) == 0) {
  728.         cff.number = NULL;
  729.     }
  731.     startRequest;
  732.     appendPrintBuf("%sstat=%d,reason=%d,serv=%d,toa=%d,%s,tout=%d", printBuf,
  733.         cff.status, cff.reason, cff.serviceClass, cff.toa,
  734.         (char*)cff.number, cff.timeSeconds);
  735.     closeRequest;
  736.     printRequest(pRI->token, pRI->pCI->requestNumber);
  738.     s_callbacks.onRequest(pRI->pCI->requestNumber, &cff, sizeof(cff), pRI);
  740. #ifdef MEMSET_FREED
  741.     memsetString(cff.number);
  742. #endif
  744.     free (cff.number);
  746. #ifdef MEMSET_FREED
  747.     memset(&cff, 0, sizeof(cff));
  748. #endif
  750.     return;
  751. invalid:
  752.     invalidCommandBlock(pRI);
  753.     return;
  754. }
  757. static void 
  758. dispatchRaw(Parcel &p, RequestInfo *pRI)
  759. {
  760.     int32_t len;
  761.     status_t status;
  762.     const void *data;
  764.     status = p.readInt32(&len);
  766.     if (status != NO_ERROR) {
  767.         goto invalid;
  768.     }
  770.     // The java code writes -1 for null arrays
  771.     if (((int)len) == -1) {
  772.         data = NULL;
  773.         len = 0;
  774.     } 
  776.     data = p.readInplace(len);
  778.     startRequest;
  779.     appendPrintBuf("%sraw_size=%d", printBuf, len);
  780.     closeRequest;
  781.     printRequest(pRI->token, pRI->pCI->requestNumber);
  783.     s_callbacks.onRequest(pRI->pCI->requestNumber, const_cast<void *>(data), len, pRI);
  785.     return;
  786. invalid:
  787.     invalidCommandBlock(pRI);
  788.     return;
  789. }
  791. static int
  792. blockingWrite(int fd, const void *buffer, size_t len)
  793. {
  794.     size_t writeOffset = 0; 
  795.     const uint8_t *toWrite;
  797.     toWrite = (const uint8_t *)buffer;
  799.     while (writeOffset < len) {
  800.         ssize_t written;
  801.         do {
  802.             written = write (fd, toWrite + writeOffset,
  803.                                 len - writeOffset);
  804.         } while (written < 0 && errno == EINTR);
  806.         if (written >= 0) {
  807.             writeOffset += written;
  808.         } else {   // written < 0
  809.             LOGE ("RIL Response: unexpected error on write errno:%d", errno);
  810.             close(fd);
  811.             return -1;
  812.         }
  813.     }
  815.     return 0;
  816. }
  818. static int
  819. sendResponseRaw (const void *data, size_t dataSize)
  820. {
  821.     int fd = s_fdCommand;
  822.     int ret;
  823.     uint32_t header;
  825.     if (s_fdCommand < 0) {
  826.         return -1;
  827.     }
  829.     if (dataSize > MAX_COMMAND_BYTES) {
  830.         LOGE("RIL: packet larger than %u (%u)",
  831.                 MAX_COMMAND_BYTES, (unsigned int )dataSize);
  833.         return -1;
  834.     }
  835.     
  837.     // FIXME is blocking here ok? issue #550970
  839.     pthread_mutex_lock(&s_writeMutex);
  841.     header = htonl(dataSize);
  843.     ret = blockingWrite(fd, (void *)&header, sizeof(header));
  845.     if (ret < 0) {
  846.         return ret;
  847.     }
  849.     blockingWrite(fd, data, dataSize);
  851.     if (ret < 0) {
  852.         return ret;
  853.     }
  855.     pthread_mutex_unlock(&s_writeMutex);
  857.     return 0;
  858. }
  860. static int
  861. sendResponse (Parcel &p)
  862. {
  863.     printResponse;
  864.     return sendResponseRaw(p.data(), p.dataSize());
  865. }
  867. /** response is an int* pointing to an array of ints*/
  868.  
  869. static int 
  870. responseInts(Parcel &p, void *response, size_t responselen)
  871. {
  872.     int numInts;
  874.     if (response == NULL && responselen != 0) {
  875.         LOGE("invalid response: NULL");
  876.         return RIL_ERRNO_INVALID_RESPONSE;
  877.     }
  878.     if (responselen % sizeof(int) != 0) {
  879.         LOGE("invalid response length %d expected multiple of %dn", 
  880.             (int)responselen, (int)sizeof(int));
  881.         return RIL_ERRNO_INVALID_RESPONSE;
  882.     }
  884.     int *p_int = (int *) response;
  886.     numInts = responselen / sizeof(int *);
  887.     p.writeInt32 (numInts);
  889.     /* each int*/
  890.     startResponse;
  891.     for (int i = 0 ; i < numInts ; i++) {
  892.         appendPrintBuf("%s%d,", printBuf, p_int[i]);
  893.         p.writeInt32(p_int[i]);
  894.     }
  895.     removeLastChar;
  896.     closeResponse;
  898.     return 0;
  899. }
  901. /** response is a char **, pointing to an array of char *'s */
  902. static int responseStrings(Parcel &p, void *response, size_t responselen)
  903. {
  904.     int numStrings;
  905.     
  906.     if (response == NULL && responselen != 0) {
  907.         LOGE("invalid response: NULL");
  908.         return RIL_ERRNO_INVALID_RESPONSE;
  909.     }
  910.     if (responselen % sizeof(char *) != 0) {
  911.         LOGE("invalid response length %d expected multiple of %dn", 
  912.             (int)responselen, (int)sizeof(char *));
  913.         return RIL_ERRNO_INVALID_RESPONSE;
  914.     }
  916.     if (response == NULL) {
  917.         p.writeInt32 (0);
  918.     } else {
  919.         char **p_cur = (char **) response;
  921.         numStrings = responselen / sizeof(char *);
  922.         p.writeInt32 (numStrings);
  924.         /* each string*/
  925.         startResponse;
  926.         for (int i = 0 ; i < numStrings ; i++) {
  927.             appendPrintBuf("%s%s,", printBuf, (char*)p_cur[i]);
  928.             writeStringToParcel (p, p_cur[i]);
  929.         }
  930.         removeLastChar;
  931.         closeResponse;
  932.     }
  933.     return 0;
  934. }
  937. /**
  938.  * NULL strings are accepted 
  939.  * FIXME currently ignores responselen
  940.  */
  941. static int responseString(Parcel &p, void *response, size_t responselen)
  942. {
  943.     /* one string only */
  944.     startResponse;
  945.     appendPrintBuf("%s%s", printBuf, (char*)response);
  946.     closeResponse;
  948.     writeStringToParcel(p, (const char *)response);
  950.     return 0;
  951. }
  953. static int responseVoid(Parcel &p, void *response, size_t responselen)
  954. {
  955.     startResponse;
  956.     removeLastChar;
  957.     return 0;
  958. }
  960. static int responseCallList(Parcel &p, void *response, size_t responselen)
  961. {    
  962.     int num;
  964.     if (response == NULL && responselen != 0) {
  965.         LOGE("invalid response: NULL");
  966.         return RIL_ERRNO_INVALID_RESPONSE;
  967.     }
  969.     if (responselen % sizeof (RIL_Call *) != 0) {
  970.         LOGE("invalid response length %d expected multiple of %dn", 
  971.             (int)responselen, (int)sizeof (RIL_Call *));
  972.         return RIL_ERRNO_INVALID_RESPONSE;
  973.     }
  975.     startResponse;
  976.     /* number of call info's */
  977.     num = responselen / sizeof(RIL_Call *);
  978.     p.writeInt32(num);
  980.     for (int i = 0 ; i < num ; i++) {
  981.         RIL_Call *p_cur = ((RIL_Call **) response)[i];
  982.         /* each call info */
  983.         p.writeInt32(p_cur->state);
  984.         p.writeInt32(p_cur->index);
  985.         p.writeInt32(p_cur->toa);
  986.         p.writeInt32(p_cur->isMpty);
  987.         p.writeInt32(p_cur->isMT);
  988.         p.writeInt32(p_cur->als);
  989.         p.writeInt32(p_cur->isVoice);
  990.         writeStringToParcel (p, p_cur->number);
  991.         appendPrintBuf("%s[%s,id=%d,toa=%d,%s,%s,als=%d,%s,%s],", printBuf,
  992.             callStateToString(p_cur->state),
  993.             p_cur->index, p_cur->toa,
  994.             (p_cur->isMpty)?"mpty":"norm",
  995.             (p_cur->isMT)?"mt":"mo",
  996.             p_cur->als,
  997.             (p_cur->isVoice)?"voc":"nonvoc",
  998.             (char*)p_cur->number);
  999.     }
  1000.     removeLastChar;
  1001.     closeResponse;
  1003.     return 0;
  1004. }
  1006. static int responseSMS(Parcel &p, void *response, size_t responselen)
  1007. {
  1008.     if (response == NULL) {
  1009.         LOGE("invalid response: NULL");
  1010.         return RIL_ERRNO_INVALID_RESPONSE;
  1011.     }
  1013.     if (responselen != sizeof (RIL_SMS_Response) ) {
  1014.         LOGE("invalid response length %d expected %d", 
  1015.                 (int)responselen, (int)sizeof (RIL_SMS_Response));
  1016.         return RIL_ERRNO_INVALID_RESPONSE;
  1017.     }
  1019.     RIL_SMS_Response *p_cur = (RIL_SMS_Response *) response;
  1021.     p.writeInt32(p_cur->messageRef);
  1022.     writeStringToParcel(p, p_cur->ackPDU);
  1024.     startResponse;
  1025.     appendPrintBuf("%s%d,%s", printBuf, p_cur->messageRef,
  1026.         (char*)p_cur->ackPDU);
  1027.     closeResponse;
  1029.     return 0;
  1030. }
  1032. static int responseContexts(Parcel &p, void *response, size_t responselen)
  1033. {
  1034.     if (response == NULL && responselen != 0) {
  1035.         LOGE("invalid response: NULL");
  1036.         return RIL_ERRNO_INVALID_RESPONSE;
  1037.     }
  1039.     if (responselen % sizeof(RIL_PDP_Context_Response) != 0) {
  1040.         LOGE("invalid response length %d expected multiple of %d", 
  1041.                 (int)responselen, (int)sizeof(RIL_PDP_Context_Response));
  1042.         return RIL_ERRNO_INVALID_RESPONSE;
  1043.     }
  1045.     int num = responselen / sizeof(RIL_PDP_Context_Response);
  1046.     p.writeInt32(num);
  1048.     RIL_PDP_Context_Response *p_cur = (RIL_PDP_Context_Response *) response;
  1049.     startResponse;
  1050.     int i;
  1051.     for (i = 0; i < num; i++) {
  1052.         p.writeInt32(p_cur[i].cid);
  1053.         p.writeInt32(p_cur[i].active);
  1054.         writeStringToParcel(p, p_cur[i].type);
  1055.         writeStringToParcel(p, p_cur[i].apn);
  1056.         writeStringToParcel(p, p_cur[i].address);
  1057.         appendPrintBuf("%s[cid=%d,%s,%s,%s,%s],", printBuf,
  1058.             p_cur[i].cid,
  1059.             (p_cur[i].active==0)?"down":"up",
  1060.             (char*)p_cur[i].type,
  1061.             (char*)p_cur[i].apn,
  1062.             (char*)p_cur[i].address);
  1063.     }
  1064.     removeLastChar;
  1065.     closeResponse;
  1067.     return 0;
  1068. }
  1070. static int responseRaw(Parcel &p, void *response, size_t responselen)
  1071. {
  1072.     if (response == NULL && responselen != 0) {
  1073.         LOGE("invalid response: NULL with responselen != 0");
  1074.         return RIL_ERRNO_INVALID_RESPONSE;
  1075.     }
  1077.     // The java code reads -1 size as null byte array
  1078.     if (response == NULL) {
  1079.         p.writeInt32(-1);       
  1080.     } else {
  1081.         p.writeInt32(responselen);
  1082.         p.write(response, responselen);
  1083.     }
  1085.     return 0;
  1086. }
  1089. static int responseSIM_IO(Parcel &p, void *response, size_t responselen)
  1090. {
  1091.     if (response == NULL) {
  1092.         LOGE("invalid response: NULL");
  1093.         return RIL_ERRNO_INVALID_RESPONSE;
  1094.     }
  1096.     if (responselen != sizeof (RIL_SIM_IO_Response) ) {
  1097.         LOGE("invalid response length was %d expected %d",
  1098.                 (int)responselen, (int)sizeof (RIL_SIM_IO_Response));
  1099.         return RIL_ERRNO_INVALID_RESPONSE;
  1100.     }
  1102.     RIL_SIM_IO_Response *p_cur = (RIL_SIM_IO_Response *) response;
  1103.     p.writeInt32(p_cur->sw1);
  1104.     p.writeInt32(p_cur->sw2);
  1105.     writeStringToParcel(p, p_cur->simResponse);
  1107.     startResponse;
  1108.     appendPrintBuf("%ssw1=0x%X,sw2=0x%X,%s", printBuf, p_cur->sw1, p_cur->sw2,
  1109.         (char*)p_cur->simResponse);
  1110.     closeResponse;
  1113.     return 0;
  1114. }
  1116. static int responseCallForwards(Parcel &p, void *response, size_t responselen)
  1117. {
  1118.     int num;
  1119.     
  1120.     if (response == NULL && responselen != 0) {
  1121.         LOGE("invalid response: NULL");
  1122.         return RIL_ERRNO_INVALID_RESPONSE;
  1123.     }
  1125.     if (responselen % sizeof(RIL_CallForwardInfo *) != 0) {
  1126.         LOGE("invalid response length %d expected multiple of %d", 
  1127.                 (int)responselen, (int)sizeof(RIL_CallForwardInfo *));
  1128.         return RIL_ERRNO_INVALID_RESPONSE;
  1129.     }
  1131.     /* number of call info's */
  1132.     num = responselen / sizeof(RIL_CallForwardInfo *);
  1133.     p.writeInt32(num);
  1135.     startResponse;
  1136.     for (int i = 0 ; i < num ; i++) {
  1137.         RIL_CallForwardInfo *p_cur = ((RIL_CallForwardInfo **) response)[i];
  1139.         p.writeInt32(p_cur->status);
  1140.         p.writeInt32(p_cur->reason);
  1141.         p.writeInt32(p_cur->serviceClass);
  1142.         p.writeInt32(p_cur->toa);
  1143.         writeStringToParcel(p, p_cur->number);
  1144.         p.writeInt32(p_cur->timeSeconds);
  1145.         appendPrintBuf("%s[%s,reason=%d,cls=%d,toa=%d,%s,tout=%d],", printBuf,
  1146.             (p_cur->status==1)?"enable":"disable",
  1147.             p_cur->reason, p_cur->serviceClass, p_cur->toa,
  1148.             (char*)p_cur->number,
  1149.             p_cur->timeSeconds);
  1150.     }
  1151.     removeLastChar;
  1152.     closeResponse;
  1153.     
  1154.     return 0;
  1155. }
  1157. static int responseSsn(Parcel &p, void *response, size_t responselen)
  1158. {
  1159.     if (response == NULL) {
  1160.         LOGE("invalid response: NULL");
  1161.         return RIL_ERRNO_INVALID_RESPONSE;
  1162.     }
  1164.     if (responselen != sizeof(RIL_SuppSvcNotification)) {
  1165.         LOGE("invalid response length was %d expected %d",
  1166.                 (int)responselen, (int)sizeof (RIL_SuppSvcNotification));
  1167.         return RIL_ERRNO_INVALID_RESPONSE;
  1168.     }
  1170.     RIL_SuppSvcNotification *p_cur = (RIL_SuppSvcNotification *) response;
  1171.     p.writeInt32(p_cur->notificationType);
  1172.     p.writeInt32(p_cur->code);
  1173.     p.writeInt32(p_cur->index);
  1174.     p.writeInt32(p_cur->type);
  1175.     writeStringToParcel(p, p_cur->number);
  1177.     startResponse;
  1178.     appendPrintBuf("%s%s,code=%d,id=%d,type=%d,%s", printBuf,
  1179.         (p_cur->notificationType==0)?"mo":"mt",
  1180.          p_cur->code, p_cur->index, p_cur->type,
  1181.         (char*)p_cur->number);
  1182.     closeResponse;
  1184.     return 0;
  1185. }
  1187. static int responseCellList(Parcel &p, void *response, size_t responselen)
  1188. {
  1189.     int num;
  1191.     if (response == NULL && responselen != 0) {
  1192.         LOGE("invalid response: NULL");
  1193.         return RIL_ERRNO_INVALID_RESPONSE;
  1194.     }
  1196.     if (responselen % sizeof (RIL_NeighboringCell *) != 0) {
  1197.         LOGE("invalid response length %d expected multiple of %dn",
  1198.             (int)responselen, (int)sizeof (RIL_NeighboringCell *));
  1199.         return RIL_ERRNO_INVALID_RESPONSE;
  1200.     }
  1202.     startResponse;
  1203.     /* number of cell info's */
  1204.     num = responselen / sizeof(RIL_NeighboringCell *);
  1205.     p.writeInt32(num);
  1207.     for (int i = 0 ; i < num ; i++) {
  1208.         RIL_NeighboringCell *p_cur = ((RIL_NeighboringCell **) response)[i];
  1210.         /* each cell info */
  1211.         p.writeInt32(p_cur->rssi);
  1212.         writeStringToParcel (p, p_cur->cid);
  1214.         appendPrintBuf("%s[cid=%s,rssi=%d],", printBuf,
  1215.             p_cur->cid, p_cur->rssi);
  1216.     }
  1217.     removeLastChar;
  1218.     closeResponse;
  1220.     return 0;
  1221. }
  1223. static void triggerEvLoop()
  1224. {
  1225.     int ret;
  1226.     if (!pthread_equal(pthread_self(), s_tid_dispatch)) {
  1227.         /* trigger event loop to wakeup. No reason to do this,
  1228.          * if we're in the event loop thread */
  1229.          do {
  1230.             ret = write (s_fdWakeupWrite, " ", 1);
  1231.          } while (ret < 0 && errno == EINTR);
  1232.     }
  1233. }
  1235. static void rilEventAddWakeup(struct ril_event *ev)
  1236. {
  1237.     ril_event_add(ev);
  1238.     triggerEvLoop();
  1239. }
  1241. /**
  1242.  * A write on the wakeup fd is done just to pop us out of select()
  1243.  * We empty the buffer here and then ril_event will reset the timers on the
  1244.  * way back down
  1245.  */
  1246. static void processWakeupCallback(int fd, short flags, void *param)
  1247. {
  1248.     char buff[16];
  1249.     int ret;
  1251.     LOGV("processWakeupCallback");
  1253.     /* empty our wakeup socket out */
  1254.     do {
  1255.         ret = read(s_fdWakeupRead, &buff, sizeof(buff));
  1256.     } while (ret > 0 || (ret < 0 && errno == EINTR)); 
  1257. }
  1259. static void onCommandsSocketClosed()
  1260. {
  1261.     int ret;
  1262.     RequestInfo *p_cur;
  1264.     /* mark pending requests as "cancelled" so we dont report responses */
  1266.     ret = pthread_mutex_lock(&s_pendingRequestsMutex);
  1267.     assert (ret == 0);
  1269.     p_cur = s_pendingRequests;
  1271.     for (p_cur = s_pendingRequests 
  1272.             ; p_cur != NULL
  1273.             ; p_cur  = p_cur->p_next
  1274.     ) {
  1275.         p_cur->cancelled = 1;
  1276.     }
  1278.     ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
  1279.     assert (ret == 0);
  1280. }
  1282. static void processCommandsCallback(int fd, short flags, void *param)
  1283. {
  1284.     RecordStream *p_rs;
  1285.     void *p_record;
  1286.     size_t recordlen;
  1287.     int ret;
  1289.     assert(fd == s_fdCommand);
  1291.     p_rs = (RecordStream *)param;
  1293.     for (;;) {
  1294.         /* loop until EAGAIN/EINTR, end of stream, or other error */
  1295.         ret = record_stream_get_next(p_rs, &p_record, &recordlen);
  1297.         if (ret == 0 && p_record == NULL) {
  1298.             /* end-of-stream */
  1299.             break;
  1300.         } else if (ret < 0) {
  1301.             break;
  1302.         } else if (ret == 0) { /* && p_record != NULL */
  1303.             processCommandBuffer(p_record, recordlen);
  1304.         }
  1305.     }
  1307.     if (ret == 0 || !(errno == EAGAIN || errno == EINTR)) {
  1308.         /* fatal error or end-of-stream */
  1309.         if (ret != 0) {
  1310.             LOGE("error on reading command socket errno:%dn", errno);
  1311.         } else {
  1312.             LOGW("EOS.  Closing command socket.");
  1313.         }
  1314.         
  1315.         close(s_fdCommand);
  1316.         s_fdCommand = -1;
  1318.         ril_event_del(&s_commands_event);
  1320.         record_stream_free(p_rs);
  1322.         /* start listening for new connections again */
  1323.         rilEventAddWakeup(&s_listen_event);
  1325.         onCommandsSocketClosed();
  1326.     }
  1327. }
  1330. static void onNewCommandConnect()
  1331. {
  1332.     // implicit radio state changed
  1333.     RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
  1334.                                     NULL, 0);
  1336.     // Send last NITZ time data, in case it was missed
  1337.     if (s_lastNITZTimeData != NULL) {
  1338.         sendResponseRaw(s_lastNITZTimeData, s_lastNITZTimeDataSize);
  1340.         free(s_lastNITZTimeData);
  1341.         s_lastNITZTimeData = NULL;
  1342.     }
  1344.     // Get version string
  1345.     if (s_callbacks.getVersion != NULL) {
  1346.         const char *version;
  1347.         version = s_callbacks.getVersion();
  1348.         LOGI("RIL Daemon version: %sn", version);
  1349.         
  1350.         property_set(PROPERTY_RIL_IMPL, version);
  1351.     } else {
  1352.         LOGI("RIL Daemon version: unavailablen");
  1353.         property_set(PROPERTY_RIL_IMPL, "unavailable");
  1354.     }
  1356. }
  1358. static void listenCallback (int fd, short flags, void *param)
  1359. {
  1360.     int ret;
  1361.     int err;
  1362.     int is_phone_socket;
  1363.     RecordStream *p_rs;
  1365.     struct sockaddr_un peeraddr;
  1366.     socklen_t socklen = sizeof (peeraddr);
  1368.     struct ucred creds;
  1369.     socklen_t szCreds = sizeof(creds);
  1371.     struct passwd *pwd = NULL;
  1373.     assert (s_fdCommand < 0);
  1374.     assert (fd == s_fdListen);
  1375.     
  1376.     s_fdCommand = accept(s_fdListen, (sockaddr *) &peeraddr, &socklen);
  1378.     if (s_fdCommand < 0 ) {
  1379.         LOGE("Error on accept() errno:%d", errno);
  1380.         /* start listening for new connections again */
  1381.         rilEventAddWakeup(&s_listen_event);
  1382. return;
  1383.     }
  1385.     /* check the credential of the other side and only accept socket from
  1386.      * phone process
  1387.      */ 
  1388.     errno = 0;
  1389.     is_phone_socket = 0;
  1390.     
  1391.     err = getsockopt(s_fdCommand, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);
  1392.     
  1393.     if (err == 0 && szCreds > 0) {
  1394.       errno = 0;
  1395.       pwd = getpwuid(creds.uid);
  1396.       if (pwd != NULL) {
  1397. if (strcmp(pwd->pw_name, PHONE_PROCESS) == 0) {
  1398.   is_phone_socket = 1;
  1399. } else {
  1400.   LOGE("RILD can't accept socket from process %s", pwd->pw_name);
  1401. }
  1402.       } else {
  1403. LOGE("Error on getpwuid() errno: %d", errno);
  1404.       }
  1405.     } else {
  1406.       LOGD("Error on getsockopt() errno: %d", errno);
  1407.     }
  1409.     if ( !is_phone_socket ) {
  1410.       LOGE("RILD must accept socket from %s", PHONE_PROCESS);
  1411.         
  1412.       close(s_fdCommand);
  1413.       s_fdCommand = -1;
  1415.       onCommandsSocketClosed();
  1417.       /* start listening for new connections again */
  1418.       rilEventAddWakeup(&s_listen_event);
  1420.       return;
  1421.     }
  1423.     ret = fcntl(s_fdCommand, F_SETFL, O_NONBLOCK);
  1425.     if (ret < 0) {
  1426.         LOGE ("Error setting O_NONBLOCK errno:%d", errno);
  1427.     }
  1429.     LOGI("libril: new connection");
  1431.     p_rs = record_stream_new(s_fdCommand, MAX_COMMAND_BYTES);
  1433.     ril_event_set (&s_commands_event, s_fdCommand, 1, 
  1434.         processCommandsCallback, p_rs);
  1436.     rilEventAddWakeup (&s_commands_event);
  1438.     onNewCommandConnect();
  1439. }
  1441. static void freeDebugCallbackArgs(int number, char **args) {
  1442.     for (int i = 0; i < number; i++) {
  1443.         if (args[i] != NULL) {
  1444.             free(args[i]);
  1445.         }
  1446.     }
  1447.     free(args);
  1448. }
  1450. static void debugCallback (int fd, short flags, void *param)
  1451. {
  1452.     int acceptFD, option;
  1453.     struct sockaddr_un peeraddr;
  1454.     socklen_t socklen = sizeof (peeraddr);
  1455.     int data;
  1456.     unsigned int qxdm_data[6];
  1457.     const char *deactData[1] = {"1"};
  1458.     char *actData[1];
  1459.     RIL_Dial dialData;
  1460.     int hangupData[1] = {1};
  1461.     int number;
  1462.     char **args;
  1464.     acceptFD = accept (fd,  (sockaddr *) &peeraddr, &socklen);
  1466.     if (acceptFD < 0) {
  1467.         LOGE ("error accepting on debug port: %dn", errno);
  1468.         return;
  1469.     }
  1471.     if (recv(acceptFD, &number, sizeof(int), 0) != sizeof(int)) {
  1472.         LOGE ("error reading on socket: number of Args: n");
  1473.         return;
  1474.     }
  1475.     args = (char **) malloc(sizeof(char*) * number);
  1477.     for (int i = 0; i < number; i++) {
  1478.         int len;
  1479.         if (recv(acceptFD, &len, sizeof(int), 0) != sizeof(int)) {
  1480.             LOGE ("error reading on socket: Len of Args: n");
  1481.             freeDebugCallbackArgs(i, args);
  1482.             return;
  1483.         }
  1484.         // +1 for null-term
  1485.         args[i] = (char *) malloc((sizeof(char) * len) + 1);
  1486.         if (recv(acceptFD, args[i], sizeof(char) * len, 0) 
  1487.             != sizeof(char) * len) {
  1488.             LOGE ("error reading on socket: Args[%d] n", i);
  1489.             freeDebugCallbackArgs(i, args);
  1490.             return;
  1491.         }
  1492.         char * buf = args[i];
  1493.         buf[len] = 0;
  1494.     }
  1496.     switch (atoi(args[0])) {
  1497.         case 0:
  1498.             LOGI ("Connection on debug port: issuing reset.");
  1499.             issueLocalRequest(RIL_REQUEST_RESET_RADIO, NULL, 0);
  1500.             break;
  1501.         case 1:
  1502.             LOGI ("Connection on debug port: issuing radio power off.");
  1503.             data = 0;
  1504.             issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int));
  1505.             // Close the socket
  1506.             close(s_fdCommand);
  1507.             s_fdCommand = -1;
  1508.             break;
  1509.         case 2:
  1510.             LOGI ("Debug port: issuing unsolicited network change.");
  1511.             RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_NETWORK_STATE_CHANGED,
  1512.                                       NULL, 0);
  1513.             break;
  1514.         case 3:
  1515.             LOGI ("Debug port: QXDM log enable.");
  1516.             qxdm_data[0] = 65536;
  1517.             qxdm_data[1] = 16;
  1518.             qxdm_data[2] = 1;
  1519.             qxdm_data[3] = 32;
  1520.             qxdm_data[4] = 0;
  1521.             qxdm_data[4] = 8;
  1522.             issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data, 
  1523.                               6 * sizeof(int));
  1524.             break;
  1525.         case 4:
  1526.             LOGI ("Debug port: QXDM log disable.");
  1527.             qxdm_data[0] = 65536;
  1528.             qxdm_data[1] = 16;
  1529.             qxdm_data[2] = 0;
  1530.             qxdm_data[3] = 32;
  1531.             qxdm_data[4] = 0;
  1532.             qxdm_data[4] = 8;
  1533.             issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
  1534.                               6 * sizeof(int));
  1535.             break;
  1536.         case 5:
  1537.             LOGI("Debug port: Radio On");
  1538.             data = 1;
  1539.             issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int));
  1540.             sleep(2);
  1541.             // Set network selection automatic.
  1542.             issueLocalRequest(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, NULL, 0);
  1543.             break;
  1544.         case 6:
  1545.             LOGI("Debug port: Setup PDP, Apn :%sn", args[1]);
  1546.             actData[0] = args[1];
  1547.             issueLocalRequest(RIL_REQUEST_SETUP_DEFAULT_PDP, &actData, 
  1548.                               sizeof(actData));
  1549.             break;
  1550.         case 7:
  1551.             LOGI("Debug port: Deactivate PDP");
  1552.             issueLocalRequest(RIL_REQUEST_DEACTIVATE_DEFAULT_PDP, &deactData, 
  1553.                               sizeof(deactData));
  1554.             break;
  1555.         case 8:
  1556.             LOGI("Debug port: Dial Call");
  1557.             dialData.clir = 0;
  1558.             dialData.address = args[1];
  1559.             issueLocalRequest(RIL_REQUEST_DIAL, &dialData, sizeof(dialData));
  1560.             break;
  1561.         case 9:
  1562.             LOGI("Debug port: Answer Call");
  1563.             issueLocalRequest(RIL_REQUEST_ANSWER, NULL, 0);
  1564.             break;
  1565.         case 10:
  1566.             LOGI("Debug port: End Call");
  1567.             issueLocalRequest(RIL_REQUEST_HANGUP, &hangupData, 
  1568.                               sizeof(hangupData));
  1569.             break;
  1570.         default:
  1571.             LOGE ("Invalid request");
  1572.             break;
  1573.     }
  1574.     freeDebugCallbackArgs(number, args);
  1575.     close(acceptFD);
  1576. }
  1579. static void userTimerCallback (int fd, short flags, void *param)
  1580. {
  1581.     UserCallbackInfo *p_info;
  1583.     p_info = (UserCallbackInfo *)param;
  1585.     p_info->p_callback(p_info->userParam);
  1588.     // FIXME generalize this...there should be a cancel mechanism
  1589.     if (s_last_wake_timeout_info != NULL && s_last_wake_timeout_info == p_info) {
  1590.         s_last_wake_timeout_info = NULL;
  1591.     }
  1593.     free(p_info);
  1594. }
  1597. static void *
  1598. eventLoop(void *param)
  1599. {
  1600.     int ret;
  1601.     int filedes[2];
  1603.     ril_event_init();
  1605.     pthread_mutex_lock(&s_startupMutex);
  1607.     s_started = 1;
  1608.     pthread_cond_broadcast(&s_startupCond);
  1610.     pthread_mutex_unlock(&s_startupMutex);
  1612.     ret = pipe(filedes);
  1614.     if (ret < 0) {
  1615.         LOGE("Error in pipe() errno:%d", errno);
  1616.         return NULL;
  1617.     }
  1619.     s_fdWakeupRead = filedes[0];
  1620.     s_fdWakeupWrite = filedes[1];
  1622.     fcntl(s_fdWakeupRead, F_SETFL, O_NONBLOCK);
  1624.     ril_event_set (&s_wakeupfd_event, s_fdWakeupRead, true,
  1625.                 processWakeupCallback, NULL);
  1627.     rilEventAddWakeup (&s_wakeupfd_event);
  1629.     // Only returns on error
  1630.     ril_event_loop();
  1631.     LOGE ("error in event_loop_base errno:%d", errno);
  1633.     return NULL;
  1634. }
  1636. extern "C" void 
  1637. RIL_startEventLoop(void)
  1638. {
  1639.     int ret;
  1640.     pthread_attr_t attr;
  1641.     
  1642.     /* spin up eventLoop thread and wait for it to get started */
  1643.     s_started = 0;
  1644.     pthread_mutex_lock(&s_startupMutex);
  1646.     pthread_attr_init (&attr);
  1647.     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);    
  1648.     ret = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL);
  1650.     while (s_started == 0) {
  1651.         pthread_cond_wait(&s_startupCond, &s_startupMutex);
  1652.     }
  1654.     pthread_mutex_unlock(&s_startupMutex);
  1656.     if (ret < 0) {
  1657.         LOGE("Failed to create dispatch thread errno:%d", errno);
  1658.         return;
  1659.     }
  1660. }
  1662. // Used for testing purpose only.
  1663. extern "C" void RIL_setcallbacks (const RIL_RadioFunctions *callbacks) {
  1664.     memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
  1665. }
  1667. extern "C" void 
  1668. RIL_register (const RIL_RadioFunctions *callbacks)
  1669. {
  1670.     int ret;
  1671.     int flags;
  1673.     if (callbacks == NULL 
  1674.         || ! (callbacks->version == RIL_VERSION || callbacks->version == 1)
  1675.     ) {
  1676.         LOGE(
  1677.             "RIL_register: RIL_RadioFunctions * null or invalid version"
  1678.             " (expected %d)", RIL_VERSION);
  1679.         return;
  1680.     }
  1682.     if (s_registerCalled > 0) {
  1683.         LOGE("RIL_register has been called more than once. "
  1684.                 "Subsequent call ignored");
  1685.         return;
  1686.     }
  1688.     memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
  1690.     s_registerCalled = 1;
  1692.     // Little self-check
  1694.     for (int i = 0; i < (int)NUM_ELEMS(s_commands) ; i++) {
  1695.         assert(i == s_commands[i].requestNumber);
  1696.     }
  1698.     for (int i = 0; i < (int)NUM_ELEMS(s_unsolResponses) ; i++) {
  1699.         assert(i + RIL_UNSOL_RESPONSE_BASE 
  1700.                 == s_unsolResponses[i].requestNumber);
  1701.     }
  1703.     // New rild impl calls RIL_startEventLoop() first
  1704.     // old standalone impl wants it here.
  1706.     if (s_started == 0) {
  1707.         RIL_startEventLoop();
  1708.     }
  1710.     // start listen socket
  1712. #if 0
  1713.     ret = socket_local_server (SOCKET_NAME_RIL, 
  1714.             ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
  1716.     if (ret < 0) {
  1717.         LOGE("Unable to bind socket errno:%d", errno);
  1718.         exit (-1);
  1719.     }
  1720.     s_fdListen = ret;
  1722. #else
  1723.     s_fdListen = android_get_control_socket(SOCKET_NAME_RIL);
  1724.     if (s_fdListen < 0) {
  1725.         LOGE("Failed to get socket '" SOCKET_NAME_RIL "'");
  1726.         exit(-1);
  1727.     }
  1729.     ret = listen(s_fdListen, 4);
  1731.     if (ret < 0) {
  1732.         LOGE("Failed to listen on control socket '%d': %s",
  1733.              s_fdListen, strerror(errno));
  1734.         exit(-1);
  1735.     }
  1736. #endif
  1739.     /* note: non-persistent so we can accept only one connection at a time */
  1740.     ril_event_set (&s_listen_event, s_fdListen, false, 
  1741.                 listenCallback, NULL);
  1743.     rilEventAddWakeup (&s_listen_event);
  1745. #if 1
  1746.     // start debug interface socket
  1748.     s_fdDebug = android_get_control_socket(SOCKET_NAME_RIL_DEBUG);
  1749.     if (s_fdDebug < 0) {
  1750.         LOGE("Failed to get socket '" SOCKET_NAME_RIL_DEBUG "' errno:%d", errno);
  1751.         exit(-1);
  1752.     }
  1754.     ret = listen(s_fdDebug, 4);
  1756.     if (ret < 0) {
  1757.         LOGE("Failed to listen on ril debug socket '%d': %s",
  1758.              s_fdDebug, strerror(errno));
  1759.         exit(-1);
  1760.     }
  1762.     ril_event_set (&s_debug_event, s_fdDebug, true,
  1763.                 debugCallback, NULL);
  1765.     rilEventAddWakeup (&s_debug_event);
  1766. #endif
  1768. }
  1770. static int
  1771. checkAndDequeueRequestInfo(struct RequestInfo *pRI)
  1772. {
  1773.     int ret = 0;
  1774.     
  1775.     if (pRI == NULL) {
  1776.         return 0;
  1777.     }
  1779.     pthread_mutex_lock(&s_pendingRequestsMutex);
  1781.     for(RequestInfo **ppCur = &s_pendingRequests 
  1782.         ; *ppCur != NULL 
  1783.         ; ppCur = &((*ppCur)->p_next)
  1784.     ) {
  1785.         if (pRI == *ppCur) {
  1786.             ret = 1;
  1788.             *ppCur = (*ppCur)->p_next;
  1789.             break;
  1790.         }
  1791.     }
  1793.     pthread_mutex_unlock(&s_pendingRequestsMutex);
  1795.     return ret;
  1796. }
  1799. extern "C" void
  1800. RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen)
  1801. {
  1802.     RequestInfo *pRI;
  1803.     int ret;
  1804.     size_t errorOffset;
  1806.     pRI = (RequestInfo *)t;
  1808.     if (!checkAndDequeueRequestInfo(pRI)) {
  1809.         LOGE ("RIL_onRequestComplete: invalid RIL_Token");
  1810.         return;
  1811.     }
  1813.     if (pRI->local > 0) {
  1814.         // Locally issued command...void only!
  1815.         // response does not go back up the command socket
  1816.         LOGD("C[locl]< %s", requestToString(pRI->pCI->requestNumber));
  1818.         goto done;
  1819.     }
  1821.     appendPrintBuf("[%04d]< %s",
  1822.         pRI->token, requestToString(pRI->pCI->requestNumber));
  1824.     if (pRI->cancelled == 0) {
  1825.         Parcel p;
  1827.         p.writeInt32 (RESPONSE_SOLICITED);
  1828.         p.writeInt32 (pRI->token);
  1829.         errorOffset = p.dataPosition();
  1831.         p.writeInt32 (e);
  1833.         if (e == RIL_E_SUCCESS) {
  1834.             /* process response on success */
  1835.             ret = pRI->pCI->responseFunction(p, response, responselen);
  1837.             /* if an error occurred, rewind and mark it */
  1838.             if (ret != 0) {
  1839.                 p.setDataPosition(errorOffset);
  1840.                 p.writeInt32 (ret);
  1841.             }
  1842.         } else {
  1843.             appendPrintBuf("%s returns %s", printBuf, failCauseToString(e));
  1844.         }
  1846.         if (s_fdCommand < 0) {
  1847.             LOGD ("RIL onRequestComplete: Command channel closed");
  1848.         }
  1849.         sendResponse(p);
  1850.     }
  1852. done:
  1853.     free(pRI);
  1854. }
  1857. static void
  1858. grabFullWakeLock()
  1859. {
  1860.     int fd;
  1862.     fd = open (ANDROID_FULL_WAKE_LOCK_PATH, O_WRONLY);
  1864.     if (fd < 0) {
  1865.         LOGW ("Cannot open " ANDROID_FULL_WAKE_LOCK_PATH);
  1866.         return;
  1867.     }
  1869.     write (fd, ANDROID_WAKE_LOCK_NAME, strlen(ANDROID_WAKE_LOCK_NAME));
  1870.     close (fd);
  1871. }
  1873. static void
  1874. grabPartialWakeLock()
  1875. {
  1876.     int fd;
  1878.     fd = open (ANDROID_PARTIAL_WAKE_LOCK_PATH, O_WRONLY);
  1880.     if (fd < 0) {
  1881.         LOGW ("Cannot open " ANDROID_PARTIAL_WAKE_LOCK_PATH);
  1882.         return;
  1883.     }
  1885.     write (fd, ANDROID_WAKE_LOCK_NAME, strlen(ANDROID_WAKE_LOCK_NAME));
  1886.     close (fd);
  1887. }
  1889. static void
  1890. releaseWakeLock()
  1891. {
  1892.     int fd;
  1894.     fd = open (ANDROID_WAKE_UNLOCK_PATH, O_WRONLY);
  1896.     if (fd < 0) {
  1897.         LOGW ("Cannot open " ANDROID_WAKE_UNLOCK_PATH);
  1898.         return;
  1899.     }
  1901.     write (fd, ANDROID_WAKE_LOCK_NAME, strlen(ANDROID_WAKE_LOCK_NAME));
  1902.     close (fd);
  1903. }
  1905. /**
  1906.  * Timer callback to put us back to sleep before the default timeout
  1907.  */
  1908. static void
  1909. wakeTimeoutCallback (void *param)
  1910. {
  1911.     // We're using "param != NULL" as a cancellation mechanism
  1912.     if (param == NULL) {
  1913.         //LOGD("wakeTimeout: releasing wake lock");
  1915.         releaseWakeLock();
  1916.     } else {
  1917.         //LOGD("wakeTimeout: releasing wake lock CANCELLED");
  1918.     }
  1919. }
  1921. extern "C"
  1922. void RIL_onUnsolicitedResponse(int unsolResponse, void *data, 
  1923.                                 size_t datalen)
  1924. {
  1925.     int unsolResponseIndex;
  1926.     int ret;
  1928.     if (s_registerCalled == 0) {
  1929.         // Ignore RIL_onUnsolicitedResponse before RIL_register
  1930.         LOGW("RIL_onUnsolicitedResponse called before RIL_register");
  1931.         return;
  1932.     }
  1933.         
  1934.     unsolResponseIndex = unsolResponse - RIL_UNSOL_RESPONSE_BASE;
  1936.     if (unsolResponseIndex < 0 
  1937.         || unsolResponseIndex >= (int32_t)NUM_ELEMS(s_unsolResponses)) {
  1938.         LOGE("unsupported unsolicited response code %d", unsolResponse);
  1939.         return;
  1940.     }
  1942.     appendPrintBuf("[UNSL]< %s", requestToString(unsolResponse));
  1943.     
  1944.     Parcel p;
  1946.     p.writeInt32 (RESPONSE_UNSOLICITED);
  1947.     p.writeInt32 (unsolResponse);
  1949.     ret = s_unsolResponses[unsolResponseIndex]
  1950.                 .responseFunction(p, data, datalen);
  1952.     // some things get more payload
  1953.     switch(unsolResponse) {
  1954.         case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED:
  1955.             p.writeInt32(s_callbacks.onStateRequest());
  1956.             appendPrintBuf("%s {%s}", printBuf,
  1957.                 radioStateToString(s_callbacks.onStateRequest()));
  1958.         break;
  1961.         case RIL_UNSOL_NITZ_TIME_RECEIVED: 
  1962.             int64_t timeReceived = elapsedRealtime();
  1963.             // Store the time this was received in case it is delayed
  1964.             p.writeInt64(timeReceived);
  1965.         break;
  1966.     }    
  1967.     
  1968.     if (ret != 0) {
  1969.         // Problem with the response. Don't continue;        
  1970.         return;
  1971.     }
  1974.     ret = sendResponse(p);
  1976.     if (ret != 0 && unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {
  1978.         // Unfortunately, NITZ time is not poll/update like everything
  1979.         // else in the system. So, if the upstream client isn't connected,
  1980.         // keep a copy of the last NITZ response (with receive time noted
  1981.         // above) around so we can deliver it when it is connected
  1982.         
  1983.         if (s_lastNITZTimeData != NULL) {
  1984.             free (s_lastNITZTimeData);
  1985.             s_lastNITZTimeData = NULL;
  1986.         }
  1988.         s_lastNITZTimeData = malloc(p.dataSize());
  1989.         s_lastNITZTimeDataSize = p.dataSize();
  1990.         memcpy(s_lastNITZTimeData, p.data(), p.dataSize());
  1991.     }
  1993.     bool shouldScheduleTimeout = false;
  1994.     
  1995.     switch (s_unsolResponses[unsolResponseIndex].wakeType) {
  1996.         case WAKE_PARTIAL:
  1997.             grabPartialWakeLock();
  1998.             shouldScheduleTimeout = true;
  1999.         break;
  2001.         case WAKE_FULL:
  2002.             grabFullWakeLock();
  2003.             shouldScheduleTimeout = true;
  2004.         break;
  2006.         case DONT_WAKE:
  2007.         default:
  2008.             break;
  2009.     }
  2011.     // For now, we automatically go back to sleep after TIMEVAL_WAKE_TIMEOUT
  2012.     // FIXME The java code should handshake here to release wake lock
  2014.     if (shouldScheduleTimeout) {
  2015.         // Cancel the previous request
  2016.         if (s_last_wake_timeout_info != NULL) {
  2017.             s_last_wake_timeout_info->userParam = (void *)1;
  2018.         }
  2019.         
  2020.         s_last_wake_timeout_info 
  2021.             = internalRequestTimedCallback(wakeTimeoutCallback, NULL, 
  2022.                                             &TIMEVAL_WAKE_TIMEOUT);
  2023.     }
  2024. }
  2026. /** FIXME generalize this if you track UserCAllbackInfo, clear it  
  2027.     when the callback occurs 
  2028. */
  2029. static UserCallbackInfo *
  2030. internalRequestTimedCallback (RIL_TimedCallback callback, void *param, 
  2031.                                 const struct timeval *relativeTime)
  2033. {
  2034.     struct timeval myRelativeTime;
  2035.     UserCallbackInfo *p_info;
  2037.     p_info = (UserCallbackInfo *) malloc (sizeof(UserCallbackInfo));
  2039.     p_info->p_callback = callback; 
  2040.     p_info->userParam = param;
  2042.     if (relativeTime == NULL) {
  2043.         /* treat null parameter as a 0 relative time */
  2044.         memset (&myRelativeTime, 0, sizeof(myRelativeTime));
  2045.     } else {
  2046.         /* FIXME I think event_add's tv param is really const anyway */
  2047.         memcpy (&myRelativeTime, relativeTime, sizeof(myRelativeTime));
  2048.     }
  2050.     ril_event_set(&(p_info->event), -1, false, userTimerCallback, p_info);
  2052.     ril_timer_add(&(p_info->event), &myRelativeTime);
  2054.     triggerEvLoop();
  2055.     return p_info;
  2056. }
  2059. extern "C" void
  2060. RIL_requestTimedCallback (RIL_TimedCallback callback, void *param, 
  2061.                                 const struct timeval *relativeTime)
  2062. {
  2063.     internalRequestTimedCallback (callback, param, relativeTime);
  2064. }
  2066. const char *
  2067. failCauseToString(RIL_Errno e)
  2068. {
  2069.     switch(e) {
  2070.         case RIL_E_SUCCESS: return "E_SUCCESS";
  2071.         case RIL_E_RADIO_NOT_AVAILABLE: return "E_RAIDO_NOT_AVAILABLE";
  2072.         case RIL_E_GENERIC_FAILURE: return "E_GENERIC_FAILURE";
  2073.         case RIL_E_PASSWORD_INCORRECT: return "E_PASSWORD_INCORRECT";
  2074.         case RIL_E_SIM_PIN2: return "E_SIM_PIN2";
  2075.         case RIL_E_SIM_PUK2: return "E_SIM_PUK2";
  2076.         case RIL_E_REQUEST_NOT_SUPPORTED: return "E_REQUEST_NOT_SUPPORTED";
  2077.         case RIL_E_CANCELLED: return "E_CANCELLED";
  2078.         case RIL_E_OP_NOT_ALLOWED_DURING_VOICE_CALL: return "E_OP_NOT_ALLOWED_DURING_VOICE_CALL";
  2079.         case RIL_E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW: return "E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW";
  2080.         case RIL_E_SMS_SEND_FAIL_RETRY: return "E_SMS_SEND_FAIL_RETRY";
  2081.         default: return "<unknown error>";
  2082.     }
  2083. }
  2085. const char *
  2086. radioStateToString(RIL_RadioState s)
  2087. {
  2088.     switch(s) {
  2089.         case RADIO_STATE_OFF: return "RADIO_OFF";
  2090.         case RADIO_STATE_UNAVAILABLE: return "RADIO_UNAVAILABLE";
  2091.         case RADIO_STATE_SIM_NOT_READY: return "RADIO_SIM_NOT_READY";
  2092.         case RADIO_STATE_SIM_LOCKED_OR_ABSENT: return "RADIO_SIM_LOCKED_OR_ABSENT";
  2093.         case RADIO_STATE_SIM_READY: return "RADIO_SIM_READY";
  2094.         default: return "<unknown state>";
  2095.     }
  2096. }
  2098. const char *
  2099. callStateToString(RIL_CallState s)
  2100. {
  2101.     switch(s) {
  2102.         case RIL_CALL_ACTIVE : return "ACTIVE";
  2103.         case RIL_CALL_HOLDING: return "HOLDING";
  2104.         case RIL_CALL_DIALING: return "DIALING";
  2105.         case RIL_CALL_ALERTING: return "ALERTING";
  2106.         case RIL_CALL_INCOMING: return "INCOMING";
  2107.         case RIL_CALL_WAITING: return "WAITING";
  2108.         default: return "<unknown state>";
  2109.     }
  2110. }
  2112. const char *
  2113. requestToString(int request) 
  2114. {
  2115. /*
  2116.  cat libs/telephony/ril_commands.h 
  2117.  | egrep "^ *{RIL_" 
  2118.  | sed -re 's/{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_1: return "1";/'
  2121.  cat libs/telephony/ril_unsol_commands.h 
  2122.  | egrep "^ *{RIL_" 
  2123.  | sed -re 's/{RIL_([^,]+),([^}]+).+/case RIL_1: return "1";/'
  2125. */
  2126.     switch(request) {
  2127.         case RIL_REQUEST_GET_SIM_STATUS: return "GET_SIM_STATUS";
  2128.         case RIL_REQUEST_ENTER_SIM_PIN: return "ENTER_SIM_PIN";
  2129.         case RIL_REQUEST_ENTER_SIM_PUK: return "ENTER_SIM_PUK";
  2130.         case RIL_REQUEST_ENTER_SIM_PIN2: return "ENTER_SIM_PIN2";
  2131.         case RIL_REQUEST_ENTER_SIM_PUK2: return "ENTER_SIM_PUK2";
  2132.         case RIL_REQUEST_CHANGE_SIM_PIN: return "CHANGE_SIM_PIN";
  2133.         case RIL_REQUEST_CHANGE_SIM_PIN2: return "CHANGE_SIM_PIN2";
  2134.         case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: return "ENTER_NETWORK_DEPERSONALIZATION";
  2135.         case RIL_REQUEST_GET_CURRENT_CALLS: return "GET_CURRENT_CALLS";
  2136.         case RIL_REQUEST_DIAL: return "DIAL";
  2137.         case RIL_REQUEST_GET_IMSI: return "GET_IMSI";
  2138.         case RIL_REQUEST_HANGUP: return "HANGUP";
  2139.         case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: return "HANGUP_WAITING_OR_BACKGROUND";
  2140.         case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: return "HANGUP_FOREGROUND_RESUME_BACKGROUND";
  2141.         case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: return "SWITCH_WAITING_OR_HOLDING_AND_ACTIVE";
  2142.         case RIL_REQUEST_CONFERENCE: return "CONFERENCE";
  2143.         case RIL_REQUEST_UDUB: return "UDUB";
  2144.         case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: return "LAST_CALL_FAIL_CAUSE";
  2145.         case RIL_REQUEST_SIGNAL_STRENGTH: return "SIGNAL_STRENGTH";
  2146.         case RIL_REQUEST_REGISTRATION_STATE: return "REGISTRATION_STATE";
  2147.         case RIL_REQUEST_GPRS_REGISTRATION_STATE: return "GPRS_REGISTRATION_STATE";
  2148.         case RIL_REQUEST_OPERATOR: return "OPERATOR";
  2149.         case RIL_REQUEST_RADIO_POWER: return "RADIO_POWER";
  2150.         case RIL_REQUEST_DTMF: return "DTMF";
  2151.         case RIL_REQUEST_SEND_SMS: return "SEND_SMS";
  2152.         case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE";
  2153.         case RIL_REQUEST_SETUP_DEFAULT_PDP: return "SETUP_DEFAULT_PDP";
  2154.         case RIL_REQUEST_SIM_IO: return "SIM_IO";
  2155.         case RIL_REQUEST_SEND_USSD: return "SEND_USSD";
  2156.         case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD";
  2157.         case RIL_REQUEST_GET_CLIR: return "GET_CLIR";
  2158.         case RIL_REQUEST_SET_CLIR: return "SET_CLIR";
  2159.         case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: return "QUERY_CALL_FORWARD_STATUS";
  2160.         case RIL_REQUEST_SET_CALL_FORWARD: return "SET_CALL_FORWARD";
  2161.         case RIL_REQUEST_QUERY_CALL_WAITING: return "QUERY_CALL_WAITING";
  2162.         case RIL_REQUEST_SET_CALL_WAITING: return "SET_CALL_WAITING";
  2163.         case RIL_REQUEST_SMS_ACKNOWLEDGE: return "SMS_ACKNOWLEDGE";
  2164.         case RIL_REQUEST_GET_IMEI: return "GET_IMEI";
  2165.         case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV";
  2166.         case RIL_REQUEST_ANSWER: return "ANSWER";
  2167.         case RIL_REQUEST_DEACTIVATE_DEFAULT_PDP: return "DEACTIVATE_DEFAULT_PDP";
  2168.         case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK";
  2169.         case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK";
  2170.         case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD";
  2171.         case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: return "QUERY_NETWORK_SELECTION_MODE";
  2172.         case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC";
  2173.         case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL";
  2174.         case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS ";
  2175.         case RIL_REQUEST_DTMF_START: return "DTMF_START";
  2176.         case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP";
  2177.         case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION";
  2178.         case RIL_REQUEST_SEPARATE_CONNECTION: return "SEPARATE_CONNECTION";
  2179.         case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: return "SET_PREFERRED_NETWORK_TYPE";
  2180.         case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "GET_PREFERRED_NETWORK_TYPE";
  2181.         case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "GET_NEIGHBORING_CELL_IDS";
  2182.         case RIL_REQUEST_SET_MUTE: return "SET_MUTE";
  2183.         case RIL_REQUEST_GET_MUTE: return "GET_MUTE";
  2184.         case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP";
  2185.         case RIL_REQUEST_LAST_PDP_FAIL_CAUSE: return "LAST_PDP_FAIL_CAUSE";
  2186.         case RIL_REQUEST_PDP_CONTEXT_LIST: return "PDP_CONTEXT_LIST";
  2187.         case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO";
  2188.         case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW";
  2189.         case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS";
  2190.     case RIL_REQUEST_SET_BAND_MODE: return "SET_BAND_MODE";
  2191.     case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: return "QUERY_AVAILABLE_BAND_MODE";
  2192.         case RIL_REQUEST_STK_GET_PROFILE: return "STK_GET_PROFILE";
  2193.         case RIL_REQUEST_STK_SET_PROFILE: return "STK_SET_PROFILE";
  2194.         case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: return "STK_SEND_ENVELOPE_COMMAND";
  2195.         case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: return "STK_SEND_TERMINAL_RESPONSE";
  2196.         case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: return "STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM";
  2197.         case RIL_REQUEST_SCREEN_STATE: return "SCREEN_STATE";
  2198.         case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: return "EXPLICIT_CALL_TRANSFER";
  2199.         case RIL_REQUEST_SET_LOCATION_UPDATES: return "SET_LOCATION_UPDATES";
  2201.         case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
  2202.         case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
  2203.         case RIL_UNSOL_RESPONSE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_NETWORK_STATE_CHANGED";
  2204.         case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS";
  2205.         case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT";
  2206.         case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM";
  2207.         case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD";
  2208.         case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)";
  2209.         case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED";
  2210.         case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH";
  2211.         case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END";
  2212.         case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND";
  2213.         case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY";
  2214.         case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP";
  2215.         case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FUL";
  2216.         case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH";
  2217.         case RIL_UNSOL_PDP_CONTEXT_LIST_CHANGED: return "UNSOL_PDP_CONTEXT_LIST_CHANGED";
  2218.         case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING";
  2219.         default: return "<unknown request>";
  2220.     }
  2221. }
  2223. } /* namespace android */