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 <linux/capability.h>
  33 #include <linux/prctl.h>
  34
  35 #include <private/android_filesystem_config.h>
  36
  37 #define LIB_PATH_PROPERTY   "rild.libpath"
  38 #define LIB_ARGS_PROPERTY   "rild.libargs"
  39 #define MAX_LIB_ARGS        16
  40
  41 static void usage(const char *argv0)
  42 {
  43     fprintf(stderr, "Usage: %s -l <ril impl library> [-- <args for impl library>]\n", argv0);
  44     exit(-1);
  45 }
  46
  47 extern void RIL_register (const RIL_RadioFunctions *callbacks);
  48
  49 extern void RIL_onRequestComplete(RIL_Token t, RIL_Errno e,
  50                            void *response, size_t responselen);
  51
  52 extern void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
  53                                 size_t datalen);
  54
  55 extern void* RIL_requestTimedCallback (RIL_TimedCallback callback,
  56                                void *param, const struct timeval *relativeTime);
  57
  58 extern void RIL_removeTimedCallback(void *callbackInfo);
  59
  60 static struct RIL_Env s_rilEnv = {
  61     RIL_onRequestComplete,
  62     RIL_onUnsolicitedResponse,
  63     RIL_requestTimedCallback,
  64     RIL_removeTimedCallback
  65 };
  66
  67 extern void RIL_startEventLoop();
  68
  69 static int make_argv(char * args, char ** argv)
  70 {
  71     // Note: reserve argv[0]
  72     int count = 1;
  73     char * tok;
  74     char * s = args;
  75
  76     while ((tok = strtok(s, " \0"))) {
  77         argv[count] = tok;
  78         s = NULL;
  79         count++;
  80     }
  81     return count;
  82 }
  83
  84 /*
  85  * switchUser - Switches UID to radio, preserving CAP_NET_ADMIN capabilities.
  86  * Our group, cache, was set by init.
  87  */
  88 void switchUser() {
  89     prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0);
  90     setuid(AID_RADIO);
  91
  92     struct __user_cap_header_struct header;
  93     struct __user_cap_data_struct cap;
  94     header.version = _LINUX_CAPABILITY_VERSION;
  95     header.pid = 0;
  96     cap.effective = cap.permitted = (1 << CAP_NET_ADMIN) | (1 << CAP_NET_RAW);
  97     cap.inheritable = 0;
  98     capset(&header, &cap);
  99 }
 100
 101 int main(int argc, char **argv)
 102 {
 103     const char * rilLibPath = NULL;
 104     char **rilArgv;
 105     void *dlHandle;
 106     const RIL_RadioFunctions *(*rilInit)(const struct RIL_Env *, int, char **);
 107     const RIL_RadioFunctions *funcs;
 108     char libPath[PROPERTY_VALUE_MAX];
 109     unsigned char hasLibArgs = 0;
 110
 111     int i;
 112
 113     umask(S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH);
 114     for (i = 1; i < argc ;) {
 115         if (0 == strcmp(argv[i], "-l") && (argc - i > 1)) {
 116             rilLibPath = argv[i + 1];
 117             i += 2;
 118         } else if (0 == strcmp(argv[i], "--")) {
 119             i++;
 120             hasLibArgs = 1;
 121             break;
 122         } else {
 123             usage(argv[0]);
 124         }
 125     }
 126
 127     if (rilLibPath == NULL) {
 128         if ( 0 == property_get(LIB_PATH_PROPERTY, libPath, NULL)) {
 129             // No lib sepcified on the command line, and nothing set in props.
 130             // Assume "no-ril" case.
 131             goto done;
 132         } else {
 133             rilLibPath = libPath;
 134         }
 135     }
 136
 137     /* special override when in the emulator */
 138 #if 1
 139     {
 140         static char*  arg_overrides[3];
 141         static char   arg_device[32];
 142         int           done = 0;
 143
 144 #define  REFERENCE_RIL_PATH  "/system/lib/libreference-ril.so"
 145
 146         /* first, read /proc/cmdline into memory */
 147         char          buffer[1024], *p, *q;
 148         int           len;
 149         int           fd = open("/proc/cmdline",O_RDONLY);
 150
 151         if (fd < 0) {
 152             LOGD("could not open /proc/cmdline:%s", strerror(errno));
 153             goto OpenLib;
 154         }
 155
 156         do {
 157             len = read(fd,buffer,sizeof(buffer)); }
 158         while (len == -1 && errno == EINTR);
 159
 160         if (len < 0) {
 161             LOGD("could not read /proc/cmdline:%s", strerror(errno));
 162             close(fd);
 163             goto OpenLib;
 164         }
 165         close(fd);
 166
 167         if (strstr(buffer, "android.qemud=") != NULL)
 168         {
 169             /* the qemud daemon is launched after rild, so
 170             * give it some time to create its GSM socket
 171             */
 172             int  tries = 5;
 173 #define  QEMUD_SOCKET_NAME    "qemud"
 174
 175             while (1) {
 176                 int  fd;
 177
 178                 sleep(1);
 179
 180                 fd = socket_local_client(
 181                             QEMUD_SOCKET_NAME,
 182                             ANDROID_SOCKET_NAMESPACE_RESERVED,
 183                             SOCK_STREAM );
 184
 185                 if (fd >= 0) {
 186                     close(fd);
 187                     snprintf( arg_device, sizeof(arg_device), "%s/%s",
 188                                 ANDROID_SOCKET_DIR, QEMUD_SOCKET_NAME );
 189
 190                     arg_overrides[1] = "-s";
 191                     arg_overrides[2] = arg_device;
 192                     done = 1;
 193                     break;
 194                 }
 195                 LOGD("could not connect to %s socket: %s",
 196                     QEMUD_SOCKET_NAME, strerror(errno));
 197                 if (--tries == 0)
 198                     break;
 199             }
 200             if (!done) {
 201                 LOGE("could not connect to %s socket (giving up): %s",
 202                     QEMUD_SOCKET_NAME, strerror(errno));
 203                 while(1)
 204                     sleep(0x00ffffff);
 205             }
 206         }
 207
 208         /* otherwise, try to see if we passed a device name from the kernel */
 209         if (!done) do {
 210 #define  KERNEL_OPTION  "android.ril="
 211 #define  DEV_PREFIX     "/dev/"
 212
 213             p = strstr( buffer, KERNEL_OPTION );
 214             if (p == NULL)
 215                 break;
 216
 217             p += sizeof(KERNEL_OPTION)-1;
 218             q  = strpbrk( p, " \t\n\r" );
 219             if (q != NULL)
 220                 *q = 0;
 221
 222             snprintf( arg_device, sizeof(arg_device), DEV_PREFIX "%s", p );
 223             arg_device[sizeof(arg_device)-1] = 0;
 224             arg_overrides[1] = "-d";
 225             arg_overrides[2] = arg_device;
 226             done = 1;
 227
 228         } while (0);
 229
 230         if (done) {
 231             argv = arg_overrides;
 232             argc = 3;
 233             i    = 1;
 234             hasLibArgs = 1;
 235             rilLibPath = REFERENCE_RIL_PATH;
 236
 237             LOGD("overriding with %s %s", arg_overrides[1], arg_overrides[2]);
 238         }
 239     }
 240 OpenLib:
 241 #endif
 242     switchUser();
 243
 244     dlHandle = dlopen(rilLibPath, RTLD_NOW);
 245
 246     if (dlHandle == NULL) {
 247         fprintf(stderr, "dlopen failed: %s\n", dlerror());
 248         exit(-1);
 249     }
 250
 251     RIL_startEventLoop();
 252
 253     rilInit = (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))dlsym(dlHandle, "RIL_Init");
 254
 255     if (rilInit == NULL) {
 256         fprintf(stderr, "RIL_Init not defined or exported in %s\n", rilLibPath);
 257         exit(-1);
 258     }
 259
 260     if (hasLibArgs) {
 261         rilArgv = argv + i - 1;
 262         argc = argc -i + 1;
 263     } else {
 264         static char * newArgv[MAX_LIB_ARGS];
 265         static char args[PROPERTY_VALUE_MAX];
 266         rilArgv = newArgv;
 267         property_get(LIB_ARGS_PROPERTY, args, "");
 268         argc = make_argv(args, rilArgv);
 269     }
 270
 271     // Make sure there's a reasonable argv[0]
 272     rilArgv[0] = argv[0];
 273
 274     funcs = rilInit(&s_rilEnv, argc, rilArgv);
 275
 276     RIL_register(funcs);
 277
 278 done:
 279
 280     while(1) {
 281         // sleep(UINT32_MAX) seems to return immediately on bionic
 282         sleep(0x00ffffff);
 283     }
 284 }
 285