rild.c revision f0c8ca7f09ed9a827e5c79e019526e8f2c77eeb4 
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
46static 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
51extern char rild[MAX_SOCKET_NAME_LENGTH];
52
53extern void RIL_register (const RIL_RadioFunctions *callbacks);
54
55extern void RIL_register_socket (RIL_RadioFunctions *(*rilUimInit)
56        (const struct RIL_Env *, int, char **), RIL_SOCKET_TYPE socketType, int argc, char **argv);
57
58extern void RIL_onRequestComplete(RIL_Token t, RIL_Errno e,
59        void *response, size_t responselen);
60
61extern void RIL_onRequestAck(RIL_Token t);
62
63extern void RIL_setRilSocketName(char *);
64
65#if defined(ANDROID_MULTI_SIM)
66extern void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
67        size_t datalen, RIL_SOCKET_ID socket_id);
68#else
69extern void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
70        size_t datalen);
71#endif
72
73extern void RIL_requestTimedCallback (RIL_TimedCallback callback,
74        void *param, const struct timeval *relativeTime);
75
76
77static struct RIL_Env s_rilEnv = {
78    RIL_onRequestComplete,
79    RIL_onUnsolicitedResponse,
80    RIL_requestTimedCallback,
81    RIL_onRequestAck
82};
83
84extern void RIL_startEventLoop();
85
86static 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 */
104void 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
145int 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    RIL_RadioFunctions *(*rilUimInit)(const struct RIL_Env *, int, char **);
151    const 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[2048] = {'\0'}, *p, *q;
211        int           len;
212        struct stat   st;
213        int           fd = open("/proc/cmdline",O_RDONLY);
214
215        if (fd < 0) {
216            RLOGE("could not open /proc/cmdline:%s", strerror(errno));
217            goto OpenLib;
218        }
219
220        if (fstat(fd, &st)) {
221            RLOGE("fstat error: %s", strerror(errno));
222            close(fd);
223            goto OpenLib;
224        }
225
226        if ((unsigned long)st.st_size > sizeof(buffer) - 1) {
227            RLOGE("Size of /proc/cmdline exceeds buffer");
228            close(fd);
229            goto OpenLib;
230        }
231
232        do {
233            len = read(fd,buffer,sizeof(buffer) - 1); }
234        while (len == -1 && errno == EINTR);
235
236        if (len < 0) {
237            RLOGE("could not read /proc/cmdline:%s", strerror(errno));
238            close(fd);
239            goto OpenLib;
240        }
241        close(fd);
242
243        if (strstr(buffer, "android.qemud=") != NULL)
244        {
245            /* the qemud daemon is launched after rild, so
246            * give it some time to create its GSM socket
247            */
248            int  tries = 5;
249#define  QEMUD_SOCKET_NAME    "qemud"
250
251            while (1) {
252                int  fd;
253
254                sleep(1);
255
256                fd = qemu_pipe_open("qemud:gsm");
257                if (fd < 0) {
258                    fd = socket_local_client(
259                                QEMUD_SOCKET_NAME,
260                                ANDROID_SOCKET_NAMESPACE_RESERVED,
261                                SOCK_STREAM );
262                }
263                if (fd >= 0) {
264                    close(fd);
265                    snprintf( arg_device, sizeof(arg_device), "%s/%s",
266                                ANDROID_SOCKET_DIR, QEMUD_SOCKET_NAME );
267
268                    arg_overrides[1] = "-s";
269                    arg_overrides[2] = arg_device;
270                    done = 1;
271                    break;
272                }
273                RLOGD("could not connect to %s socket: %s",
274                    QEMUD_SOCKET_NAME, strerror(errno));
275                if (--tries == 0)
276                    break;
277            }
278            if (!done) {
279                RLOGE("could not connect to %s socket (giving up): %s",
280                    QEMUD_SOCKET_NAME, strerror(errno));
281                while(1)
282                    sleep(0x00ffffff);
283            }
284        }
285
286        /* otherwise, try to see if we passed a device name from the kernel */
287        if (!done) do {
288#define  KERNEL_OPTION  "android.ril="
289#define  DEV_PREFIX     "/dev/"
290
291            p = strstr( buffer, KERNEL_OPTION );
292            if (p == NULL)
293                break;
294
295            p += sizeof(KERNEL_OPTION)-1;
296            q  = strpbrk( p, " \t\n\r" );
297            if (q != NULL)
298                *q = 0;
299
300            snprintf( arg_device, sizeof(arg_device), DEV_PREFIX "%s", p );
301            arg_device[sizeof(arg_device)-1] = 0;
302            arg_overrides[1] = "-d";
303            arg_overrides[2] = arg_device;
304            done = 1;
305
306        } while (0);
307
308        if (done) {
309            argv = arg_overrides;
310            argc = 3;
311            i    = 1;
312            hasLibArgs = 1;
313            rilLibPath = REFERENCE_RIL_PATH;
314
315            RLOGD("overriding with %s %s", arg_overrides[1], arg_overrides[2]);
316        }
317    }
318OpenLib:
319#endif
320    switchUser();
321
322    dlHandle = dlopen(rilLibPath, RTLD_NOW);
323
324    if (dlHandle == NULL) {
325        RLOGE("dlopen failed: %s", dlerror());
326        exit(EXIT_FAILURE);
327    }
328
329    RIL_startEventLoop();
330
331    rilInit =
332        (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))
333        dlsym(dlHandle, "RIL_Init");
334
335    if (rilInit == NULL) {
336        RLOGE("RIL_Init not defined or exported in %s\n", rilLibPath);
337        exit(EXIT_FAILURE);
338    }
339
340    dlerror(); // Clear any previous dlerror
341    rilUimInit =
342        (RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))
343        dlsym(dlHandle, "RIL_SAP_Init");
344    err_str = dlerror();
345    if (err_str) {
346        RLOGW("RIL_SAP_Init not defined or exported in %s: %s\n", rilLibPath, err_str);
347    } else if (!rilUimInit) {
348        RLOGW("RIL_SAP_Init defined as null in %s. SAP Not usable\n", rilLibPath);
349    }
350
351    if (hasLibArgs) {
352        rilArgv = argv + i - 1;
353        argc = argc -i + 1;
354    } else {
355        static char * newArgv[MAX_LIB_ARGS];
356        static char args[PROPERTY_VALUE_MAX];
357        rilArgv = newArgv;
358        property_get(LIB_ARGS_PROPERTY, args, "");
359        argc = make_argv(args, rilArgv);
360    }
361
362    rilArgv[argc++] = "-c";
363    rilArgv[argc++] = clientId;
364    RLOGD("RIL_Init argc = %d clientId = %s", argc, rilArgv[argc-1]);
365
366    // Make sure there's a reasonable argv[0]
367    rilArgv[0] = argv[0];
368
369    funcs = rilInit(&s_rilEnv, argc, rilArgv);
370    RLOGD("RIL_Init rilInit completed");
371
372    RIL_register(funcs);
373
374    RLOGD("RIL_Init RIL_register completed");
375
376    if (rilUimInit) {
377        RLOGD("RIL_register_socket started");
378        RIL_register_socket(rilUimInit, RIL_SAP_SOCKET, argc, rilArgv);
379    }
380
381    RLOGD("RIL_register_socket completed");
382
383done:
384
385    RLOGD("RIL_Init starting sleep loop");
386    while (true) {
387        sleep(UINT32_MAX);
388    }
389}
390