412 lines
12 KiB
C
412 lines
12 KiB
C
/* //device/system/rild/rild.c
|
|
**
|
|
** Copyright 2006 The Android Open Source Project
|
|
**
|
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
|
** you may not use this file except in compliance with the License.
|
|
** You may obtain a copy of the License at
|
|
**
|
|
** http://www.apache.org/licenses/LICENSE-2.0
|
|
**
|
|
** Unless required by applicable law or agreed to in writing, software
|
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
** See the License for the specific language governing permissions and
|
|
** limitations under the License.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <dlfcn.h>
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
|
|
#include <telephony/ril.h>
|
|
#define LOG_TAG "RILD"
|
|
#include <utils/Log.h>
|
|
#include <cutils/properties.h>
|
|
#include <cutils/sockets.h>
|
|
#include <sys/capability.h>
|
|
#include <sys/prctl.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <libril/ril_ex.h>
|
|
|
|
#include <private/android_filesystem_config.h>
|
|
#include "hardware/qemu_pipe.h"
|
|
|
|
#define LIB_PATH_PROPERTY "rild.libpath"
|
|
#define LIB_ARGS_PROPERTY "rild.libargs"
|
|
#define MAX_LIB_ARGS 16
|
|
#define MAX_CAP_NUM (CAP_TO_INDEX(CAP_LAST_CAP) + 1)
|
|
|
|
static void usage(const char *argv0) {
|
|
fprintf(stderr, "Usage: %s -l <ril impl library> [-- <args for impl library>]\n", argv0);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
#ifdef QCOM_HARDWARE
|
|
extern char rild[MAX_SOCKET_NAME_LENGTH] __attribute__((weak));
|
|
#endif
|
|
|
|
extern void RIL_register (const RIL_RadioFunctions *callbacks);
|
|
|
|
extern void RIL_register_socket (RIL_RadioFunctions *(*rilUimInit)
|
|
(const struct RIL_Env *, int, char **), RIL_SOCKET_TYPE socketType, int argc, char **argv);
|
|
|
|
extern void RIL_onRequestComplete(RIL_Token t, RIL_Errno e,
|
|
void *response, size_t responselen);
|
|
|
|
extern void RIL_onRequestAck(RIL_Token t);
|
|
|
|
extern void RIL_setRilSocketName(char *);
|
|
|
|
#if defined(ANDROID_MULTI_SIM)
|
|
extern void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
|
|
size_t datalen, RIL_SOCKET_ID socket_id);
|
|
#else
|
|
extern void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
|
|
size_t datalen);
|
|
#endif
|
|
|
|
extern void RIL_requestTimedCallback (RIL_TimedCallback callback,
|
|
void *param, const struct timeval *relativeTime);
|
|
|
|
extern void RIL_setRilSocketName(char * s) __attribute__((weak));
|
|
|
|
static struct RIL_Env s_rilEnv = {
|
|
RIL_onRequestComplete,
|
|
RIL_onUnsolicitedResponse,
|
|
RIL_requestTimedCallback,
|
|
RIL_onRequestAck
|
|
};
|
|
|
|
extern void RIL_startEventLoop();
|
|
|
|
static int make_argv(char * args, char ** argv) {
|
|
// Note: reserve argv[0]
|
|
int count = 1;
|
|
char * tok;
|
|
char * s = args;
|
|
|
|
while ((tok = strtok(s, " \0"))) {
|
|
argv[count] = tok;
|
|
s = NULL;
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
/*
|
|
* switchUser - Switches UID to radio, preserving CAP_NET_ADMIN capabilities.
|
|
* Our group, cache, was set by init.
|
|
*/
|
|
void switchUser() {
|
|
char debuggable[PROP_VALUE_MAX];
|
|
|
|
prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0);
|
|
if (setresuid(AID_RADIO, AID_RADIO, AID_RADIO) == -1) {
|
|
RLOGE("setresuid failed: %s", strerror(errno));
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
struct __user_cap_header_struct header;
|
|
memset(&header, 0, sizeof(header));
|
|
header.version = _LINUX_CAPABILITY_VERSION_3;
|
|
header.pid = 0;
|
|
|
|
struct __user_cap_data_struct data[MAX_CAP_NUM];
|
|
memset(&data, 0, sizeof(data));
|
|
|
|
data[CAP_TO_INDEX(CAP_NET_ADMIN)].effective |= CAP_TO_MASK(CAP_NET_ADMIN);
|
|
data[CAP_TO_INDEX(CAP_NET_ADMIN)].permitted |= CAP_TO_MASK(CAP_NET_ADMIN);
|
|
|
|
data[CAP_TO_INDEX(CAP_NET_RAW)].effective |= CAP_TO_MASK(CAP_NET_RAW);
|
|
data[CAP_TO_INDEX(CAP_NET_RAW)].permitted |= CAP_TO_MASK(CAP_NET_RAW);
|
|
|
|
data[CAP_TO_INDEX(CAP_BLOCK_SUSPEND)].effective |= CAP_TO_MASK(CAP_BLOCK_SUSPEND);
|
|
data[CAP_TO_INDEX(CAP_BLOCK_SUSPEND)].permitted |= CAP_TO_MASK(CAP_BLOCK_SUSPEND);
|
|
|
|
if (capset(&header, &data[0]) == -1) {
|
|
RLOGE("capset failed: %s", strerror(errno));
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
/*
|
|
* Debuggable build only:
|
|
* Set DUMPABLE that was cleared by setuid() to have tombstone on RIL crash
|
|
*/
|
|
property_get("ro.debuggable", debuggable, "0");
|
|
if (strcmp(debuggable, "1") == 0) {
|
|
prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);
|
|
}
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
const char * rilLibPath = NULL;
|
|
char **rilArgv;
|
|
void *dlHandle;
|
|
const RIL_RadioFunctions *(*rilInit)(const struct RIL_Env *, int, char **);
|
|
RIL_RadioFunctions *(*rilUimInit)(const struct RIL_Env *, int, char **);
|
|
const char *err_str = NULL;
|
|
|
|
const RIL_RadioFunctions *funcs;
|
|
char libPath[PROPERTY_VALUE_MAX];
|
|
unsigned char hasLibArgs = 0;
|
|
|
|
int i;
|
|
const char *clientId = NULL;
|
|
RLOGD("**RIL Daemon Started**");
|
|
RLOGD("**RILd param count=%d**", argc);
|
|
|
|
umask(S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH);
|
|
for (i = 1; i < argc ;) {
|
|
if (0 == strcmp(argv[i], "-l") && (argc - i > 1)) {
|
|
rilLibPath = argv[i + 1];
|
|
i += 2;
|
|
} else if (0 == strcmp(argv[i], "--")) {
|
|
i++;
|
|
hasLibArgs = 1;
|
|
break;
|
|
} else if (0 == strcmp(argv[i], "-c") && (argc - i > 1)) {
|
|
clientId = argv[i+1];
|
|
i += 2;
|
|
} else {
|
|
usage(argv[0]);
|
|
}
|
|
}
|
|
|
|
#ifdef QCOM_HARDWARE
|
|
if (clientId == NULL) {
|
|
clientId = "0";
|
|
} else if (atoi(clientId) >= MAX_RILDS) {
|
|
RLOGE("Max Number of rild's supported is: %d", MAX_RILDS);
|
|
exit(0);
|
|
}
|
|
if (strncmp(clientId, "0", MAX_CLIENT_ID_LENGTH)) {
|
|
if (RIL_setRilSocketName) {
|
|
RIL_setRilSocketName(strncat(rild, clientId, MAX_SOCKET_NAME_LENGTH));
|
|
} else {
|
|
RLOGE("Trying to instantiate multiple rild sockets without a compatible libril!");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (rilLibPath == NULL) {
|
|
if ( 0 == property_get(LIB_PATH_PROPERTY, libPath, NULL)) {
|
|
// No lib sepcified on the command line, and nothing set in props.
|
|
// Assume "no-ril" case.
|
|
goto done;
|
|
} else {
|
|
rilLibPath = libPath;
|
|
}
|
|
}
|
|
|
|
/* special override when in the emulator */
|
|
#if 1
|
|
{
|
|
static char* arg_overrides[5];
|
|
static char arg_device[32];
|
|
int done = 0;
|
|
|
|
#define REFERENCE_RIL_PATH "libreference-ril.so"
|
|
|
|
/* first, read /proc/cmdline into memory */
|
|
char buffer[2048] = {'\0'}, *p, *q;
|
|
int len;
|
|
struct stat st;
|
|
int fd = open("/proc/cmdline",O_RDONLY);
|
|
|
|
if (fd < 0) {
|
|
RLOGE("could not open /proc/cmdline:%s", strerror(errno));
|
|
goto OpenLib;
|
|
}
|
|
|
|
if (fstat(fd, &st)) {
|
|
RLOGE("fstat error: %s", strerror(errno));
|
|
close(fd);
|
|
goto OpenLib;
|
|
}
|
|
|
|
if ((unsigned long)st.st_size > sizeof(buffer) - 1) {
|
|
RLOGE("Size of /proc/cmdline exceeds buffer");
|
|
close(fd);
|
|
goto OpenLib;
|
|
}
|
|
|
|
do {
|
|
len = read(fd,buffer,sizeof(buffer) - 1); }
|
|
while (len == -1 && errno == EINTR);
|
|
|
|
if (len < 0) {
|
|
RLOGE("could not read /proc/cmdline:%s", strerror(errno));
|
|
close(fd);
|
|
goto OpenLib;
|
|
}
|
|
close(fd);
|
|
|
|
if (strstr(buffer, "android.qemud=") != NULL)
|
|
{
|
|
/* the qemud daemon is launched after rild, so
|
|
* give it some time to create its GSM socket
|
|
*/
|
|
int tries = 5;
|
|
#define QEMUD_SOCKET_NAME "qemud"
|
|
|
|
while (1) {
|
|
int fd;
|
|
|
|
sleep(1);
|
|
|
|
fd = qemu_pipe_open("qemud:gsm");
|
|
if (fd < 0) {
|
|
fd = socket_local_client(
|
|
QEMUD_SOCKET_NAME,
|
|
ANDROID_SOCKET_NAMESPACE_RESERVED,
|
|
SOCK_STREAM );
|
|
}
|
|
if (fd >= 0) {
|
|
close(fd);
|
|
snprintf( arg_device, sizeof(arg_device), "%s/%s",
|
|
ANDROID_SOCKET_DIR, QEMUD_SOCKET_NAME );
|
|
|
|
arg_overrides[1] = "-s";
|
|
arg_overrides[2] = arg_device;
|
|
done = 1;
|
|
break;
|
|
}
|
|
RLOGD("could not connect to %s socket: %s",
|
|
QEMUD_SOCKET_NAME, strerror(errno));
|
|
if (--tries == 0)
|
|
break;
|
|
}
|
|
if (!done) {
|
|
RLOGE("could not connect to %s socket (giving up): %s",
|
|
QEMUD_SOCKET_NAME, strerror(errno));
|
|
while(1)
|
|
sleep(0x00ffffff);
|
|
}
|
|
}
|
|
|
|
/* otherwise, try to see if we passed a device name from the kernel */
|
|
if (!done) do {
|
|
#define KERNEL_OPTION "android.ril="
|
|
#define DEV_PREFIX "/dev/"
|
|
|
|
p = strstr( buffer, KERNEL_OPTION );
|
|
if (p == NULL)
|
|
break;
|
|
|
|
p += sizeof(KERNEL_OPTION)-1;
|
|
q = strpbrk( p, " \t\n\r" );
|
|
if (q != NULL)
|
|
*q = 0;
|
|
|
|
snprintf( arg_device, sizeof(arg_device), DEV_PREFIX "%s", p );
|
|
arg_device[sizeof(arg_device)-1] = 0;
|
|
arg_overrides[1] = "-d";
|
|
arg_overrides[2] = arg_device;
|
|
done = 1;
|
|
|
|
} while (0);
|
|
|
|
if (done) {
|
|
argv = arg_overrides;
|
|
argc = 3;
|
|
i = 1;
|
|
hasLibArgs = 1;
|
|
rilLibPath = REFERENCE_RIL_PATH;
|
|
|
|
RLOGD("overriding with %s %s", arg_overrides[1], arg_overrides[2]);
|
|
}
|
|
}
|
|
OpenLib:
|
|
#endif
|
|
switchUser();
|
|
|
|
dlHandle = dlopen(rilLibPath, RTLD_NOW);
|
|
|
|
if (dlHandle == NULL) {
|
|
RLOGE("dlopen failed: %s", dlerror());
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
RIL_startEventLoop();
|
|
|
|
rilInit =
|
|
(const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))
|
|
dlsym(dlHandle, "RIL_Init");
|
|
|
|
if (rilInit == NULL) {
|
|
RLOGE("RIL_Init not defined or exported in %s\n", rilLibPath);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
dlerror(); // Clear any previous dlerror
|
|
rilUimInit =
|
|
(RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))
|
|
dlsym(dlHandle, "RIL_SAP_Init");
|
|
err_str = dlerror();
|
|
if (err_str) {
|
|
RLOGW("RIL_SAP_Init not defined or exported in %s: %s\n", rilLibPath, err_str);
|
|
} else if (!rilUimInit) {
|
|
RLOGW("RIL_SAP_Init defined as null in %s. SAP Not usable\n", rilLibPath);
|
|
}
|
|
|
|
if (hasLibArgs) {
|
|
rilArgv = argv + i - 1;
|
|
argc = argc -i + 1;
|
|
} else {
|
|
static char * newArgv[MAX_LIB_ARGS];
|
|
static char args[PROPERTY_VALUE_MAX];
|
|
rilArgv = newArgv;
|
|
property_get(LIB_ARGS_PROPERTY, args, "");
|
|
argc = make_argv(args, rilArgv);
|
|
}
|
|
|
|
#ifdef QCOM_HARDWARE
|
|
rilArgv[argc++] = "-c";
|
|
rilArgv[argc++] = clientId;
|
|
RLOGD("RIL_Init argc = %d clientId = %s", argc, rilArgv[argc-1]);
|
|
#endif
|
|
|
|
// Make sure there's a reasonable argv[0]
|
|
rilArgv[0] = argv[0];
|
|
|
|
funcs = rilInit(&s_rilEnv, argc, rilArgv);
|
|
RLOGD("RIL_Init rilInit completed");
|
|
|
|
#ifdef QCOM_HARDWARE
|
|
if (funcs == NULL) {
|
|
/* Pre-multi-client qualcomm vendor libraries won't support "-c" either, so
|
|
* try again without it. This should only happen on ancient qcoms, so raise
|
|
* a big fat warning
|
|
*/
|
|
argc -= 2;
|
|
RLOGE("============= Retrying RIL_Init without a client id. This is only required for very old versions,");
|
|
RLOGE("============= and you're likely to have more radio breakage elsewhere!");
|
|
funcs = rilInit(&s_rilEnv, argc, rilArgv);
|
|
}
|
|
#endif
|
|
|
|
RIL_register(funcs);
|
|
|
|
RLOGD("RIL_Init RIL_register completed");
|
|
|
|
if (rilUimInit) {
|
|
RLOGD("RIL_register_socket started");
|
|
RIL_register_socket(rilUimInit, RIL_SAP_SOCKET, argc, rilArgv);
|
|
}
|
|
|
|
RLOGD("RIL_register_socket completed");
|
|
|
|
done:
|
|
|
|
RLOGD("RIL_Init starting sleep loop");
|
|
while (true) {
|
|
sleep(UINT32_MAX);
|
|
}
|
|
}
|