rild/rild.c

   1 /* //device/system/rild/rild.c
   2 **
   3 ** Copyright 2006 The Android Open Source Project
   4 **
   5 ** Licensed under the Apache License, Version 2.0 (the "License");
   6 ** you may not use this file except in compliance with the License.
   7 ** You may obtain a copy of the License at
   8 **
   9 **     http://www.apache.org/licenses/LICENSE-2.0
  10 **
  11 ** Unless required by applicable law or agreed to in writing, software
  12 ** distributed under the License is distributed on an "AS IS" BASIS,
  13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 ** See the License for the specific language governing permissions and
  15 ** limitations under the License.
  16 */
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <dlfcn.h>
  21 #include <string.h>
  22 #include <stdint.h>
  23 #include <unistd.h>
  24 #include <fcntl.h>
  25 #include <errno.h>
  26
  27 #include <telephony/ril.h>
  28 #define LOG_TAG "RILD"
  29 #include <utils/Log.h>
  30 #include <cutils/properties.h>
  31 #include <cutils/sockets.h>
  32 #include <sys/capability.h>
  33 #include <sys/prctl.h>
  34 #include <sys/stat.h>
  35 #include <sys/types.h>
  36 #include <libril/ril_ex.h>
  37
  38 #include <private/android_filesystem_config.h>
  39 #include "hardware/qemu_pipe.h"
  40
  41 #define LIB_PATH_PROPERTY   "rild.libpath"
  42 #define LIB_ARGS_PROPERTY   "rild.libargs"
  43 #define MAX_LIB_ARGS        16
  44 #define MAX_CAP_NUM         (CAP_TO_INDEX(CAP_LAST_CAP) + 1)
  45
  46 static void usage(const char *argv0) {
  47     fprintf(stderr, "Usage: %s -l <ril impl library> [-- <args for impl library>]\n", argv0);
  48     exit(EXIT_FAILURE);
  49 }
  50
  51 extern char rild[MAX_SOCKET_NAME_LENGTH];
  52
  53 extern void RIL_register (const RIL_RadioFunctions *callbacks);
  54
  55 extern void RIL_register_socket (RIL_RadioFunctions *(*rilUimInit)
  56         (const struct RIL_Env *, int, char **), RIL_SOCKET_TYPE socketType, int argc, char **argv);
  57
  58 extern void RIL_onRequestComplete(RIL_Token t, RIL_Errno e,
  59         void *response, size_t responselen);
  60
  61 extern void RIL_onRequestAck(RIL_Token t);
  62
  63 extern void RIL_setRilSocketName(char *);
  64
  65 #if defined(ANDROID_MULTI_SIM)
  66 extern void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
  67         size_t datalen, RIL_SOCKET_ID socket_id);
  68 #else
  69 extern void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
  70         size_t datalen);
  71 #endif
  72
  73 extern void RIL_requestTimedCallback (RIL_TimedCallback callback,
  74         void *param, const struct timeval *relativeTime);
  75
  76
  77 static struct RIL_Env s_rilEnv = {
  78     RIL_onRequestComplete,
  79     RIL_onUnsolicitedResponse,
  80     RIL_requestTimedCallback,
  81     RIL_onRequestAck
  82 };
  83
  84 extern void RIL_startEventLoop();
  85
  86 static int make_argv(char * args, char ** argv) {
  87     // Note: reserve argv[0]
  88     int count = 1;
  89     char * tok;
  90     char * s = args;
  91
  92     while ((tok = strtok(s, " \0"))) {
  93         argv[count] = tok;
  94         s = NULL;
  95         count++;
  96     }
  97     return count;
  98 }
  99
 100 /*
 101  * switchUser - Switches UID to radio, preserving CAP_NET_ADMIN capabilities.
 102  * Our group, cache, was set by init.
 103  */
 104 void switchUser() {
 105     char debuggable[PROP_VALUE_MAX];
 106
 107     prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0);
 108     if (setresuid(AID_RADIO, AID_RADIO, AID_RADIO) == -1) {
 109         RLOGE("setresuid failed: %s", strerror(errno));
 110         exit(EXIT_FAILURE);
 111     }
 112
 113     struct __user_cap_header_struct header;
 114     memset(&header, 0, sizeof(header));
 115     header.version = _LINUX_CAPABILITY_VERSION_3;
 116     header.pid = 0;
 117
 118     struct __user_cap_data_struct data[MAX_CAP_NUM];
 119     memset(&data, 0, sizeof(data));
 120
 121     data[CAP_TO_INDEX(CAP_NET_ADMIN)].effective |= CAP_TO_MASK(CAP_NET_ADMIN);
 122     data[CAP_TO_INDEX(CAP_NET_ADMIN)].permitted |= CAP_TO_MASK(CAP_NET_ADMIN);
 123
 124     data[CAP_TO_INDEX(CAP_NET_RAW)].effective |= CAP_TO_MASK(CAP_NET_RAW);
 125     data[CAP_TO_INDEX(CAP_NET_RAW)].permitted |= CAP_TO_MASK(CAP_NET_RAW);
 126
 127     data[CAP_TO_INDEX(CAP_BLOCK_SUSPEND)].effective |= CAP_TO_MASK(CAP_BLOCK_SUSPEND);
 128     data[CAP_TO_INDEX(CAP_BLOCK_SUSPEND)].permitted |= CAP_TO_MASK(CAP_BLOCK_SUSPEND);
 129
 130     if (capset(&header, &data[0]) == -1) {
 131         RLOGE("capset failed: %s", strerror(errno));
 132         exit(EXIT_FAILURE);
 133     }
 134
 135     /*
 136      * Debuggable build only:
 137      * Set DUMPABLE that was cleared by setuid() to have tombstone on RIL crash
 138      */
 139     property_get("ro.debuggable", debuggable, "0");
 140     if (strcmp(debuggable, "1") == 0) {
 141         prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);
 142     }
 143 }
 144
 145 int main(int argc, char **argv) {
 146     const char * rilLibPath = NULL;
 147     char **rilArgv;
 148     void *dlHandle;
 149     const RIL_RadioFunctions *(*rilInit)(const struct RIL_Env *, int, char **);
 150     const RIL_RadioFunctions *(*rilUimInit)(const struct RIL_Env *, int, char **);
 151     char *err_str = NULL;
 152
 153     const RIL_RadioFunctions *funcs;
 154     char libPath[PROPERTY_VALUE_MAX];
 155     unsigned char hasLibArgs = 0;
 156
 157     int i;
 158     const char *clientId = NULL;
 159     RLOGD("**RIL Daemon Started**");
 160     RLOGD("**RILd param count=%d**", argc);
 161
 162     umask(S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH);
 163     for (i = 1; i < argc ;) {
 164         if (0 == strcmp(argv[i], "-l") && (argc - i > 1)) {
 165             rilLibPath = argv[i + 1];
 166             i += 2;
 167         } else if (0 == strcmp(argv[i], "--")) {
 168             i++;
 169             hasLibArgs = 1;
 170             break;
 171         } else if (0 == strcmp(argv[i], "-c") &&  (argc - i > 1)) {
 172             clientId = argv[i+1];
 173             i += 2;
 174         } else {
 175             usage(argv[0]);
 176         }
 177     }
 178
 179     if (clientId == NULL) {
 180         clientId = "0";
 181     } else if (atoi(clientId) >= MAX_RILDS) {
 182         RLOGE("Max Number of rild's supported is: %d", MAX_RILDS);
 183         exit(0);
 184     }
 185     if (strncmp(clientId, "0", MAX_CLIENT_ID_LENGTH)) {
 186         strlcat(rild, clientId, MAX_SOCKET_NAME_LENGTH);
 187         RIL_setRilSocketName(rild);
 188     }
 189
 190     if (rilLibPath == NULL) {
 191         if ( 0 == property_get(LIB_PATH_PROPERTY, libPath, NULL)) {
 192             // No lib sepcified on the command line, and nothing set in props.
 193             // Assume "no-ril" case.
 194             goto done;
 195         } else {
 196             rilLibPath = libPath;
 197         }
 198     }
 199
 200     /* special override when in the emulator */
 201 #if 1
 202     {
 203         static char*  arg_overrides[5];
 204         static char   arg_device[32];
 205         int           done = 0;
 206
 207 #define  REFERENCE_RIL_PATH  "libreference-ril.so"
 208
 209         /* first, read /proc/cmdline into memory */
 210         char          buffer[1024] = {'\0'}, *p, *q;
 211         int           len;
 212         int           fd = open("/proc/cmdline",O_RDONLY);
 213
 214         if (fd < 0) {
 215             RLOGD("could not open /proc/cmdline:%s", strerror(errno));
 216             goto OpenLib;
 217         }
 218
 219         do {
 220             len = read(fd,buffer,sizeof(buffer)); }
 221         while (len == -1 && errno == EINTR);
 222
 223         if (len < 0) {
 224             RLOGD("could not read /proc/cmdline:%s", strerror(errno));
 225             close(fd);
 226             goto OpenLib;
 227         }
 228         close(fd);
 229
 230         if (strstr(buffer, "android.qemud=") != NULL)
 231         {
 232             /* the qemud daemon is launched after rild, so
 233             * give it some time to create its GSM socket
 234             */
 235             int  tries = 5;
 236 #define  QEMUD_SOCKET_NAME    "qemud"
 237
 238             while (1) {
 239                 int  fd;
 240
 241                 sleep(1);
 242
 243                 fd = qemu_pipe_open("qemud:gsm");
 244                 if (fd < 0) {
 245                     fd = socket_local_client(
 246                                 QEMUD_SOCKET_NAME,
 247                                 ANDROID_SOCKET_NAMESPACE_RESERVED,
 248                                 SOCK_STREAM );
 249                 }
 250                 if (fd >= 0) {
 251                     close(fd);
 252                     snprintf( arg_device, sizeof(arg_device), "%s/%s",
 253                                 ANDROID_SOCKET_DIR, QEMUD_SOCKET_NAME );
 254
 255                     arg_overrides[1] = "-s";
 256                     arg_overrides[2] = arg_device;
 257                     done = 1;
 258                     break;
 259                 }
 260                 RLOGD("could not connect to %s socket: %s",
 261                     QEMUD_SOCKET_NAME, strerror(errno));
 262                 if (--tries == 0)
 263                     break;
 264             }
 265             if (!done) {
 266                 RLOGE("could not connect to %s socket (giving up): %s",
 267                     QEMUD_SOCKET_NAME, strerror(errno));
 268                 while(1)
 269                     sleep(0x00ffffff);
 270             }
 271         }
 272
 273         /* otherwise, try to see if we passed a device name from the kernel */
 274         if (!done) do {
 275 #define  KERNEL_OPTION  "android.ril="
 276 #define  DEV_PREFIX     "/dev/"
 277
 278             p = strstr( buffer, KERNEL_OPTION );
 279             if (p == NULL)
 280                 break;
 281
 282             p += sizeof(KERNEL_OPTION)-1;
 283             q  = strpbrk( p, " \t\n\r" );
 284             if (q != NULL)
 285                 *q = 0;
 286
 287             snprintf( arg_device, sizeof(arg_device), DEV_PREFIX "%s", p );
 288             arg_device[sizeof(arg_device)-1] = 0;
 289             arg_overrides[1] = "-d";
 290             arg_overrides[2] = arg_device;
 291             done = 1;
 292
 293         } while (0);
 294
 295         if (done) {
 296             argv = arg_overrides;
 297             argc = 3;
 298             i    = 1;
 299             hasLibArgs = 1;
 300             rilLibPath = REFERENCE_RIL_PATH;
 301
 302             RLOGD("overriding with %s %s", arg_overrides[1], arg_overrides[2]);
 303         }
 304     }
 305 OpenLib:
 306 #endif
 307     switchUser();
 308
 309     dlHandle = dlopen(rilLibPath, RTLD_NOW);
 310
 311     if (dlHandle == NULL) {
 312         RLOGE("dlopen failed: %s", dlerror());
 313         exit(EXIT_FAILURE);
 314     }
 315
 316     RIL_startEventLoop();
 317
 318     rilInit =
 319         (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))
 320         dlsym(dlHandle, "RIL_Init");
 321
 322     if (rilInit == NULL) {
 323         RLOGE("RIL_Init not defined or exported in %s\n", rilLibPath);
 324         exit(EXIT_FAILURE);
 325     }
 326
 327     dlerror(); // Clear any previous dlerror
 328     rilUimInit =
 329         (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))
 330         dlsym(dlHandle, "RIL_SAP_Init");
 331     err_str = dlerror();
 332     if (err_str) {
 333         RLOGW("RIL_SAP_Init not defined or exported in %s: %s\n", rilLibPath, err_str);
 334     } else if (!rilUimInit) {
 335         RLOGW("RIL_SAP_Init defined as null in %s. SAP Not usable\n", rilLibPath);
 336     }
 337
 338     if (hasLibArgs) {
 339         rilArgv = argv + i - 1;
 340         argc = argc -i + 1;
 341     } else {
 342         static char * newArgv[MAX_LIB_ARGS];
 343         static char args[PROPERTY_VALUE_MAX];
 344         rilArgv = newArgv;
 345         property_get(LIB_ARGS_PROPERTY, args, "");
 346         argc = make_argv(args, rilArgv);
 347     }
 348
 349     rilArgv[argc++] = "-c";
 350     rilArgv[argc++] = clientId;
 351     RLOGD("RIL_Init argc = %d clientId = %s", argc, rilArgv[argc-1]);
 352
 353     // Make sure there's a reasonable argv[0]
 354     rilArgv[0] = argv[0];
 355
 356     funcs = rilInit(&s_rilEnv, argc, rilArgv);
 357     RLOGD("RIL_Init rilInit completed");
 358
 359     RIL_register(funcs);
 360
 361     RLOGD("RIL_Init RIL_register completed");
 362
 363     if (rilUimInit) {
 364         RLOGD("RIL_register_socket started");
 365         RIL_register_socket(rilUimInit, RIL_SAP_SOCKET, argc, rilArgv);
 366     }
 367
 368     RLOGD("RIL_register_socket completed");
 369
 370 done:
 371
 372     RLOGD("RIL_Init starting sleep loop");
 373     while (true) {
 374         sleep(UINT32_MAX);
 375     }
 376 }