int main(int argc, char **argv)
{
const char * rilLibPath = NULL;
char **rilArgv;
void *dlHandle;
const RIL_RadioFunctions *(*rilInit)(const struct RIL_Env *, int, char **);
const RIL_RadioFunctions *(*rilInitSocket)(const struct RIL_EnvSocket *, int, char **);
const RIL_RadioFunctions *funcs;
const RIL_RadioFunctionsSocket *funcsSocket;
char libPath[PROPERTY_VALUE_MAX];
char socPath[PROPERTY_VALUE_MAX];
unsigned char hasLibArgs = 0;
int i;
const char *clientId = NULL;
RLOGD("**RIL Daemon Started**");
RLOGD("**RILd param count=%d**", argc);
#ifdef MTK_RIL_MD2
RLOGD("RILD started (MD2)");
#else
RLOGD("RILD started");
#endif
if (mtkInit() == -1) goto done;
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]);
}
}
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)) {
RIL_setRilSocketName(strncat(rild, clientId, MAX_SOCKET_NAME_LENGTH));
}
if (rilLibPath == NULL) {
#ifdef MTK_RIL_MD2
if ( 0 == property_get(LIB_PATH_PROPERTY, libPath, "/system/lib/mtk-rilmd2.so")) {
#else
if ( 0 == property_get(LIB_PATH_PROPERTY, libPath, "/system/lib/mtk-ril.so")) {
#endif
// 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;
#ifdef MTK_RIL_MD2
#define REFERENCE_RIL_PATH "/system/lib/mtk-rilmd2.so"
#else
#define REFERENCE_RIL_PATH "/system/lib/mtk-ril.so"
#endif
/* first, read /proc/cmdline into memory */
char buffer[1024], *p, *q;
int len;
int fd = open("/proc/cmdline",O_RDONLY);
if (fd < 0) {
RLOGD("could not open /proc/cmdline:%s", strerror(errno));
goto OpenLib;
}
do {
len = read(fd,buffer,sizeof(buffer));
}
while (len == -1 && errno == EINTR);
if (len < 0) {
RLOGD("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();
#ifdef MTK_RIL_MD2
rilLibPath = "/system/lib/mtk-rilmd2.so";
#endif
RLOGD("Open ril lib path: %s", rilLibPath);
dlHandle = dlopen(rilLibPath, RTLD_NOW);
if (dlHandle == NULL) {
RLOGE("dlopen failed: %s", dlerror());
exit(EXIT_FAILURE);
}
RIL_startEventLoop();
rilInitSocket = (const int(*)(void))dlsym(dlHandle, "RIL_InitSocket");
if (rilInitSocket == NULL) {
RLOGD("Vendor RIL do not need socket id!");
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);
}
} else {
RLOGD("vendor RIL need socket id");
}
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;
#ifdef MTK_RIL_MD2
property_get(LIB_ARGS_PROPERTY, args, "-d /dev/ccci2_tty0");
#else
property_get(LIB_ARGS_PROPERTY, args, "-d /dev/ttyC0");
#endif
argc = make_argv(args, rilArgv);
}
rilArgv[argc++] = "-c";
rilArgv[argc++] = clientId;
RLOGD("RIL_Init argc = %d clientId = %s", argc, rilArgv[argc-1]);
// Make sure there's a reasonable argv[0]
rilArgv[0] = argv[0];
if (rilInitSocket == NULL) {
RLOGD("Old vendor ril! so RIL_register is called");
funcs = rilInit(&s_rilEnv, argc, rilArgv);
RIL_register(funcs);
} else {
RLOGD("New vendor ril! so RIL_registerSocket is called");
funcsSocket = rilInitSocket(&s_rilEnvSocket, argc, rilArgv);
RIL_registerSocket(funcsSocket);
}
done:
RLOGD("RIL_Init starting sleep loop");
while (true) {
sleep(UINT32_MAX);
}
}
//---------------------------------------------------------------------------------------------
static void run_cmd(void)
{
int i, argc;
char cmd_tmp[UIF_MAX_LINE];
char *argv[UIF_MAX_ARGS + 1];
cmd_args.len = 0;
strcpy(cmd_tmp, cmd_args.cmdline);
if (!(argc = make_argv(cmd_tmp, argv)))
goto out;
for (i = 0; i < array_size(uif_cmdtab); ++i)
{
if (!strcasecmp(uif_cmdtab[i].cmd, argv[0]))
{
if (argc - 1 > uif_cmdtab[i].max_args)
{
printf("Usage: %s\n\r", uif_cmdtab[i].usage);
goto out;
}
uif_cmdtab[i].func(argc, argv);
goto out;
}
}
printf("Error: No such command: %s\n\r", argv[0]);
out:
printf(PROMPT);
}
static int join_hook(int argc, char *argv[])
{
assert(argc == 2);
/**********************************************
* allow something like:
* /join #channel1 #channel2
**********************************************/
if (strstr(argv[1], " ")) {
int i;
char **tmp_argv;
int tmp_argc;
char *orig = argv[1];
make_argv(&tmp_argc, &tmp_argv, argv[1]);
for (i = 0; i < tmp_argc; i++) {
argv[1] = tmp_argv[i];
join_hook(argc, argv);
}
free_argv(tmp_argc, tmp_argv);
argv[1] = orig;
return 0;
}
channel_t *tmp;
tmp = find_channel(argv[1], irc_pick_server());
if (tmp == NULL)
tmp = new_channel(argv[1], irc_pick_server());
tmp->set_window(tmp, active_window <= window_max
&& active_window > 0 ? active_window : 0);
tmp->join(tmp);
return 0;
}
static int names_hook(int argc, char *argv[])
{
char **my_argv;
int my_argc;
size_t i;
user_t *u;
make_argv(&my_argc, &my_argv, argv[5]);
for (i = 0; i < my_argc; i++) {
assert(my_argv[i] != NULL);
if (my_argv[i][0] != '@' && my_argv[i][0] != '+') {
u = find_user(my_argv[i], irc_pick_server());
u->flags |= USER_IS_OP;
} else {
u = find_user(&my_argv[i][1], irc_pick_server());
}
assert(u);
u->add_channel(u, argv[4]);
}
channel_t *ch = find_channel(argv[4], irc_pick_server());
if (!ch)
return -1;
// wio_colored_out(ch->win, USER_RED, "[%s] ", argv[4]);
// wio_colored_out(ch->win, USER_WHITE, "%s\n", argv[5]);
return 0;
}
static int rrd_common_call (lua_State *L, const char *cmd,
RRD_FUNCTION rrd_function) {
char **argv;
int argc = lua_gettop(L) + 1;
if(ntop->getGlobals()->isShutdown()) return(CONST_LUA_PARAM_ERROR);
ntop->rrdLock(__FILE__, __LINE__);
rrd_clear_error();
argv = make_argv(cmd, L);
reset_rrd_state();
rrd_function(argc, argv);
free(argv);
if(rrd_test_error()) {
char *err = rrd_get_error();
if(err != NULL) {
/*
IMPORTANT
It is important to unlock now as if luaL_error is called the
function returns and no unlock will take place
*/
ntop->rrdUnlock(__FILE__, __LINE__);
luaL_error(L, err);
}
}
ntop->rrdUnlock(__FILE__, __LINE__);
return 0;
}
void
run_cmd (void)
{
/*
* Global array of pointers to emulate C argc,argv interface
*/
int argc;
char *argv[UIF_MAX_ARGS + 1]; /* one extra for null terminator */
get_line(cmdline1);
if (!(argc = make_argv(cmdline1,argv)))
{
/* no command entered, just a blank line */
strcpy(cmdline1,cmdline2);
argc = make_argv(cmdline1,argv);
}
cmdline2[0] = '\0';
if (argc)
{
int i;
for (i = 0; i < UIF_NUM_CMD; i++)
{
if (strcasecmp(UIF_CMDTAB[i].cmd,argv[0]) == 0)
{
if (((argc-1) >= UIF_CMDTAB[i].min_args) &&
((argc-1) <= UIF_CMDTAB[i].max_args))
{
if (UIF_CMDTAB[i].flags & UIF_CMD_FLAG_REPEAT)
{
strcpy(cmdline2,argv[0]);
}
UIF_CMDTAB[i].func(argc,argv);
return;
}
else
{
printf(SYNTAX,argv[0]);
return;
}
}
}
printf(INVCMD,argv[0]);
printf(HELPMSG);
}
}
void exec_mon_cmd(char *ptr)
{
char *sargv[10];
int sargc;
sargc = make_argv(ptr, sizeof(sargv)/sizeof(sargv[0]), sargv);
if(sargc != 0) anal_command(sargc, sargv);
}
int cmd_attach(int argc, char *const argv[]) {
int opt, index;
while((opt = getopt_long(argc, argv, "+n:h", options, &index)) != -1) {
switch(opt) {
case '?':
goto err;
case 'n':
opt_name = optarg;
break;
case 'h':
show_usage();
break;
default:
flags |= opt;
break;
}
}
BADOPT(!opt_name, "missing name\n");
setenv("USERNS_NAME", opt_name, 1);
char *rundir = getenv("XDG_RUNTIME_DIR");
ERROR(!rundir, "environment XDG_RUNTIME_DIR is not set\n");
char pid_filename[PATH_MAX] = {0};
snprintf(pid_filename, PATH_MAX, "%s/userns/%s/pid", rundir, opt_name);
int pid_fd = -1;
PERROR(==-1, pid_fd = open, pid_filename, O_RDONLY);
ERROR(flock(pid_fd, LOCK_EX|LOCK_NB) != -1, "namespace '%s' has gone\n", opt_name);
ERROR(errno != EWOULDBLOCK, "flock: %s\n", strerror(errno));
FILE *pid_file = fdopen(pid_fd, "r");
fseek(pid_file, 0, SEEK_END);
size_t size = ftell(pid_file);
rewind(pid_file);
char *pid_str = malloc(size+1);
PERROR(==size, fread, pid_str, size, 1, pid_file);
errno = 0;
char *endptr = NULL;
strtol(pid_str, &endptr, 10);
ERROR(errno || (endptr == pid_str), "bad pid '%s'\n", pid_str);
return attach(pid_str, make_argv(optind, argc, argv));
err:
fprintf(stderr, "Try '%s %s --help'\n", executable, cmd_name);
exit(EXIT_FAILURE);
}
static int run(char *command, char **args) {
int status;
pid_t pid = vfork();
if (pid == -1) {
abort();
} else if (pid == 0) {
execvp(command, make_argv(command, args));
_exit(1);
} else {
wait(&status);
return status;
}
}
END_TEST
START_TEST(test_make_argv)
{
#define MAX_ARGV_LEN 16
int argc;
char *vect[MAX_ARGV_LEN + 1] = {};
/* 0: "qsub" 1 2 3 4 5 6 7 8 */
char const * line = "simple_arg \"quoted ' arg\" \'s\"quoted \" arg\' \\\\ \\\" \\\' \\ end";
make_argv(&argc, vect, line);
fail_unless(argc == 9);
fail_unless(strcmp(vect[0], "qsub") == 0);
fail_unless(strcmp(vect[1], "simple_arg") == 0);
fail_unless(strcmp(vect[2], "quoted ' arg") == 0);
fail_unless(strcmp(vect[3], "s\"quoted \" arg") == 0);
fail_unless(strcmp(vect[4], "\\") == 0);
fail_unless(strcmp(vect[5], "\"") == 0);
fail_unless(strcmp(vect[6], "\'") == 0);
fail_unless(strcmp(vect[7], " ") == 0);
fail_unless(strcmp(vect[8], "end") == 0);
fail_unless(vect[9] == NULL);
/* two args that are (escaped) spaces + test mem free/alloc no-fail test */
line = "\\ \\\t";
make_argv(&argc, vect, line);
fail_unless(argc == 3);
fail_unless(strcmp(vect[0], "qsub") == 0);
fail_unless(strcmp(vect[1], " ") == 0);
fail_unless(strcmp(vect[2], "\t") == 0);
/* no arguments + mem free/alloc no-fail test */
line = " \t ";
make_argv(&argc, vect, line);
fail_unless(argc == 1);
fail_unless(strcmp(vect[0], "qsub") == 0);
}
static int ntop_rrd_fetch(lua_State* L) {
int argc = lua_gettop(L) + 1;
char **argv = make_argv("fetch", L);
unsigned long i, j, step, ds_cnt;
rrd_value_t *data, *p;
char **names;
time_t t, start, end;
ntop->rrdLock(__FILE__, __LINE__);
reset_rrd_state();
rrd_fetch(argc, argv, &start, &end, &step, &ds_cnt, &names, &data);
free(argv);
if (rrd_test_error()) luaL_error(L, rrd_get_error());
lua_pushnumber(L, (lua_Number) start);
lua_pushnumber(L, (lua_Number) step);
/* fprintf(stderr, "%lu, %lu, %lu, %lu\n", start, end, step, num_points); */
/* create the ds names array */
lua_newtable(L);
for (i=0; i<ds_cnt; i++) {
lua_pushstring(L, names[i]);
lua_rawseti(L, -2, i+1);
rrd_freemem(names[i]);
}
rrd_freemem(names);
/* create the data points array */
lua_newtable(L);
p = data;
for (t=start, i=0; t<end; t+=step, i++) {
lua_newtable(L);
for (j=0; j<ds_cnt; j++) {
/*fprintf(stderr, "Point #%lu\n", j+1); */
lua_pushnumber(L, (lua_Number) *p++);
lua_rawseti(L, -2, j+1);
}
lua_rawseti(L, -2, i+1);
}
rrd_freemem(data);
ntop->rrdUnlock(__FILE__, __LINE__);
/* return the end as the last value */
lua_pushnumber(L, (lua_Number) end);
return 5;
}
static
size_t audit_log_audit_record(char *buf, size_t buflen,
const char *name, time_t t)
{
char id_str[MAX_RECORD_ID_SIZE];
char timestamp[MAX_TIMESTAMP_SIZE];
char arg_buf[512];
const char *format_string[] = {
"<AUDIT_RECORD\n"
" NAME=\"%s\"\n"
" RECORD=\"%s\"\n"
" TIMESTAMP=\"%s\"\n"
" MYSQL_VERSION=\"%s\"\n"
" STARTUP_OPTIONS=\"%s\"\n"
" OS_VERSION=\""MACHINE_TYPE"-"SYSTEM_TYPE"\"\n"
"/>\n",
"<AUDIT_RECORD>\n"
" <NAME>%s</NAME>\n"
" <RECORD>%s</RECORD>\n"
" <TIMESTAMP>%s</TIMESTAMP>\n"
" <MYSQL_VERSION>%s</MYSQL_VERSION>\n"
" <STARTUP_OPTIONS>%s</STARTUP_OPTIONS>\n"
" <OS_VERSION>"MACHINE_TYPE"-"SYSTEM_TYPE"</OS_VERSION>\n"
"</AUDIT_RECORD>\n",
"{\"audit_record\":{\"name\":\"%s\",\"record\":\"%s\","
"\"timestamp\":\"%s\",\"mysql_version\":\"%s\","
"\"startup_optionsi\":\"%s\","
"\"os_version\":\""MACHINE_TYPE"-"SYSTEM_TYPE"\"}}\n",
"\"%s\",\"%s\",\"%s\",\"%s\",\"%s\","
"\""MACHINE_TYPE"-"SYSTEM_TYPE"\"\n" };
return my_snprintf(buf, buflen,
format_string[audit_log_format],
name,
make_record_id(id_str, sizeof(id_str)),
make_timestamp(timestamp, sizeof(timestamp), t),
server_version,
make_argv(arg_buf, sizeof(arg_buf),
orig_argc - 1, orig_argv + 1));
}
struct plugin_cycle *
plugin_run(struct plugin_list *list, const char *const*args,
plugin_callback_t callback, void *callback_data)
{
struct plugin_cycle *cycle = g_new(struct plugin_cycle, 1);
assert(args != NULL);
cycle->list = list;
cycle->argv = make_argv(args);
cycle->callback = callback;
cycle->callback_data = callback_data;
cycle->next_plugin = 0;
cycle->pid = -1;
cycle->pipe_stdout.fd = -1;
cycle->pipe_stderr.fd = -1;
cycle->pipe_stdout.data = NULL;
cycle->pipe_stderr.data = NULL;
cycle->all_errors = g_string_new(NULL);
next_plugin(cycle);
return cycle;
}
void
commandinterpreter(char Buffer[])
{
int argc;
char *argv[MAX_ARGS + 1]; /* One extra for NULL terminator */
removeBsDel(Buffer);
argc = make_argv(Buffer,argv);
if (argc)
{
int i;
for (i = 0; i < NUM_CMDSHELL; i++)
{
if (strcasecmp(CMDSHELLTAB[i].cmd,argv[0]) == 0)
{
if (((argc-1) >= CMDSHELLTAB[i].min_args) && ((argc-1) <= CMDSHELLTAB[i].max_args))
{
CMDSHELLTAB[i].func(argc,argv);
return;
}
else
{
ShellPrintf(SYNTAXSHELL,argv[0]);
ShellPrintf(PROMPT);
return;
}
}
}
ShellPrintf(INVCMD,argv[0]);
ShellPrintf(HELPMSG);
}
ShellPrintf(PROMPT);
}
// TODO: log to syslog
// TODO: parameterize syslog or stderr on cmdline
int main(int argc, char* argv[])
{
uid_t uid;
gid_t gid;
int nice_val;
int oom_adj;
char* cmdline;
if (parse_args(argc, argv, &uid, &gid, &nice_val, &oom_adj, &cmdline)) {
non_async_signal_safe_child_setup(cmdline, uid, gid, nice_val, oom_adj);
char** args = 0;
char* buf = 0;
if (make_argv(cmdline, &args, &buf)) {
fflush(0);
execvp(args[0], args);
fprintf(stderr,
"'%s' exec() failed: %s\n",
cmdline,
strerror(errno));
free(buf);
free(args);
} else {
fprintf(stderr, "'%s': building args failed\n", cmdline);
}
} else {
fprintf(stderr, "%s: parsing args failed\n", argv[0]);
}
/* if we get here, it means the exec() failed */
return EXIT_FAILURE;
}
void Monitor(void)
{
char tmp_buf[100];
int index;
int i;
int minute, prev_min, sec, prev_sec;
minute = prev_min = sec = prev_sec = 0;
print_log("\nTask MONI Start...\n");
for(cnt=0; cnt<10; cnt++) hist_buf[cnt][0] = '\0';
cnt = 0;
while ( 1 )
{
print_log("[%s] ", PROMPT);
fgets(buf, 100, stdin );
if(buf[0] == '.') /* Previous command */
{
strcpy(buf, "!!");
}
if(buf[0] == '!') /* History command */
{
if(buf[1] == '!' || (buf[1] >='0' && buf[1] <='9'))
{
if(buf[1] == '!') index = (cnt+9) % 10;
else index = buf[1] - '0';
if(buf[2] == '\0' || buf[3] == '\0')
{
strcpy(buf, hist_buf[index]);
}
else
{
sprintf(tmp_buf, "%s %s", hist_buf[index], &buf[3]);
strcpy(buf, tmp_buf);
}
print_log("\n%s", (int)buf);
}
else
{
for(i=0 ; i<10 ; i++)
{
print_log("%d %s\n", i, hist_buf[i]);
}
continue;
}
}
strcpy(tmp_buf, buf);
argc = make_argv(buf, sizeof(argv)/sizeof(argv[0]), argv);
if ( argc != 0 )
{
anal_command(argc, argv);
strcpy(hist_buf[cnt], tmp_buf);
cnt++;
if(cnt == 10) cnt = 0;
}
}
}
int parse_server_string ( const char *str )
{
assert(str);
if(bool_option("show_all_server_strings"))
cio_out(str);
current_server_string = str;
size_t i;
char **argv;
int argc;
char *buf = NULL;
server_string_t *si;
server_string_list_t *sl;
/* make a buffer */
buf = copy_string(str);
assert(buf != NULL);
buf[strlen(buf) - 1] = 0;
if(strlen(buf) == 0) {
return -1;
}
make_argv(&argc, &argv, buf);
assert(argc != 0);
// we want a consistent format regardless of whether or not a prefix
// was sent, so if one wasn't we fake it
if(argv[0][0] != ':') { // no prefix was found
char **tmp = malloc(sizeof(char *) * (argc + 1));
tmp[0] = malloc(strlen(irc_pick_server()) + 2);
tmp[0][0] = ':';
strcpy(&tmp[0][1], irc_pick_server());
for(i = 0; i < argc; i++) {
tmp[i + 1] = copy_string(argv[i]);
}
free_argv(argc, argv);
argc++;
argv = tmp;
}
// run hooks
rcv_hook_t *rcvp = &hook_head;
for(list_next(rcvp); rcvp != &hook_head; list_next(rcvp)) {
rcvp->func(argc, argv);
}
// find a function to run
sl = (server_string_list_t *)(head.head.next);
find_next_string_handler:
for( ; (list_t *)sl != (list_t *)&head; list_next(sl)) {
si = sl->strings;
while(si->keystring != NULL) {
if(strcmp_nc(argv[1], si->keystring) == 0) {
goto found_string_handler;
}
si++;
}
}
// nothing was found
if(bool_option("verbose") || bool_option("show_unhandled_msgs")) {
cio_out("unhandled string sent from server: %s\n", str);
}
free_argv(argc, argv);
free(buf);
return -1;
found_string_handler:
free_argv(argc, argv);
if(buf[0] == ':') {
make_max_argv(&argc, &argv, buf, si->argc);
} else {
make_max_argv(&argc, &argv, buf, si->argc - 1);
char **tmp = malloc(sizeof(char *) * (argc + 1));
//tmp[0] = copy_string(irc_pick_server());
tmp[0] = malloc(strlen(irc_pick_server()) + 2);
tmp[0][0] = ':';
strcpy(&tmp[0][1], irc_pick_server());
//add_char_to_str(tmp[0], 0, ':');
for(i = 0; i < argc; i++) {
tmp[i + 1] = copy_string(argv[i]);
}
free_argv(argc, argv);
argc++;
argv = tmp;
}
if(si->strip_colon && strlen(argv[argc - 1]) != 0 && argv[argc - 1][0] == ':') {
remove_char_from_str(argv[argc - 1], 0);
}
/**********************************************
* make sure argc is correct, so that the
* callbacks don't get any suprises
**********************************************/
assert(!(argc > si->argc));
if(argc < si->argc) {
char **tmp = argv;
argv = malloc(sizeof(char *) * si->argc);
for(i = 0; i < argc; i++) {
argv[i] = tmp[i];
}
for(i = argc; i < si->argc; i++) {
argv[i] = malloc(1);
argv[i][0] = 0;
}
argc = si->argc;
}
int retval = si->hook(argc, argv);
if(retval) {
list_next(sl);
goto find_next_string_handler;
}
free_argv(argc, argv);
current_server_string = NULL;
return retval;
}
/* Runs a handler process specified by full command line <data> (with arguments).
* Before running:
* Replaces environment variables.
* Replaces special MimeRun variables (see above) with the detected values taken from <mres>.
* Replaces %* and %N with the appropriate bits of <lpfile> and <einfo>->lpParameters.
* If <executable> is TRUE, waits until the handler process terminates, otherwise returns
* (almost) immediately.
*/
int run_handler (wchar_t *logfile, wchar_t *data, MimeResults *mres, LPSHELLEXECUTEINFOW einfo, wchar_t *lpfile, wchar_t *lpdir, int executable, int fix_redir)
{
BOOL ret = 0;
PVOID redir;
HMODULE kernel32 = NULL;
Wow64DisableWow64FsRedirectionFunction disablewow64 = NULL;
Wow64RevertWow64FsRedirectionFunction revertwow64 = NULL;
DWORD err;
int i;
int depth = 0;
size_t dupdatalen;
wchar_t *exp_data = NULL;
wchar_t *dupdata = NULL;
wchar_t *dupparams = NULL;
wchar_t **old_argv = NULL, **newargv = NULL;
STARTUPINFOW si;
PROCESS_INFORMATION pi;
DWORD applelen, typelen, enclen, namelen;
wchar_t *store_apple = NULL, *store_type = NULL, *store_enc = NULL, *store_name = NULL;
logtofilew (logfile, L">run_handler\n");
if (einfo->lpParameters != NULL)
{
i = wcslen (einfo->lpParameters) + 1 + wcslen (lpfile);
logtofilew (logfile, L"Fake commandline length is %d + 1 + %d == %d\n", wcslen (einfo->lpParameters), wcslen (lpfile), i);
dupparams = (wchar_t *) malloc (sizeof (wchar_t *) * (i + 1));
if (dupparams == NULL)
{
logtofilew (logfile, L"Failed to allocate %d bytes\n", sizeof (wchar_t *) * (i + 1));
return 1;
}
dupparams[0] = L'\0';
wcscat (dupparams, lpfile);
wcscat (dupparams, L" ");
wcscat (dupparams, einfo->lpParameters);
logtofilew (logfile, L"Fake commandline is %s\n", dupparams);
if (make_argv (dupparams, &i, NULL) == 0 && i >= 1)
{
old_argv = (wchar_t **) malloc (sizeof (wchar_t *) * (i + 1));
make_argv (dupparams, NULL, old_argv);
old_argv[i] = NULL;
logtofilew (logfile, L"Old arguments:\n");
for (i = 0; old_argv[i] != NULL; i++)
logtofilew (logfile, L"%2d: %s\n", i, old_argv[i]);
logtofilew (logfile, L"\n");
}
else
{
logtofilew (logfile, L"First call to make_argv() have failed or argc <= 0\n");
free (dupparams);
return 2;
}
}
else
{
old_argv = (wchar_t **) malloc (sizeof (wchar_t *) * 2);
old_argv[0] = lpfile;
old_argv[1] = NULL;
logtofilew (logfile, L"Old arguments:\n");
for (i = 0; old_argv[i] != NULL; i++)
logtofilew (logfile, L"%2d: %s\n", i, old_argv[i]);
logtofilew (logfile, L"\n");
}
store_name = store_var (NAME_VARW, &namelen);
store_type = store_var (TYPE_VARW, &typelen);
store_enc = store_var (ENC_VARW, &enclen);
store_apple = store_var (APPLE_VARW, &applelen);
logtofilew (logfile, L"Backed up variables: {%s}, {%s}, {%s}, {%s}\n", store_name, store_type, store_enc, store_apple);
SetEnvironmentVariableW (NAME_VARW, mres->wname == NULL ? L"" : mres->wname);
SetEnvironmentVariableW (TYPE_VARW, mres->wtype == NULL ? L"" : mres->wtype);
SetEnvironmentVariableW (ENC_VARW, mres->wenc == NULL ? L"" : mres->wenc);
SetEnvironmentVariableW (APPLE_VARW, mres->wapple == NULL ? L"" : mres->wapple);
exp_data = expand_vars (data, old_argv);
logtofilew (logfile, L"Commandline with expanded variables: %s\n", exp_data);
if (dupparams != NULL)
free (dupparams);
if (old_argv != NULL)
free (old_argv);
SetEnvironmentVariableW (NAME_VARW, store_name);
SetEnvironmentVariableW (TYPE_VARW, store_type);
SetEnvironmentVariableW (ENC_VARW, store_enc);
SetEnvironmentVariableW (APPLE_VARW, store_apple);
if (store_apple != NULL)
free (store_apple);
if (store_type != NULL)
free (store_type);
if (store_enc != NULL)
free (store_enc);
if (store_name != NULL)
free (store_name);
dupdata = (wchar_t *) wcsdup (exp_data);
if (make_argv (dupdata, &i, NULL) == 0 && i >= 1)
{
newargv = (wchar_t **) malloc (sizeof (wchar_t *) * (i + 1));
make_argv (dupdata, NULL, newargv);
newargv[i] = NULL;
}
else
{
logtofilew (logfile, L"First call to make_argv() have failed or argc <= 0\n");
free (dupdata);
return 3;
}
memset (&si, 0, sizeof (si));
si.cb = sizeof (si);
if (einfo->nShow != SW_SHOWDEFAULT)
{
si.dwFlags |= STARTF_USESHOWWINDOW;
si.wShowWindow = einfo->nShow;
logtofilew (logfile, L"Using nShow == %d\n", si.wShowWindow);
}
if (einfo->fMask & SEE_MASK_NO_CONSOLE)
{
logtofilew (logfile, L"We will create new console and will not inherit in/out/err handles\n");
}
else
{
logtofilew (logfile, L"We will not create new console, child process will inherit in/out/err handles\n");
si.dwFlags |= STARTF_USESTDHANDLES;
si.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
si.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
si.hStdError = GetStdHandle (STD_ERROR_HANDLE);
}
if (fix_redir && iam32on64 ())
{
kernel32 = LoadLibraryW (L"kernel32.dll");
if (kernel32 != NULL)
{
disablewow64 = (Wow64DisableWow64FsRedirectionFunction) GetProcAddress (kernel32, "Wow64DisableWow64FsRedirection");
revertwow64 = (Wow64RevertWow64FsRedirectionFunction) GetProcAddress (kernel32, "Wow64RevertWow64FsRedirection");
if (disablewow64 == NULL || revertwow64 == NULL)
fix_redir = 0;
else
fix_redir = disablewow64 (&redir);
}
else
fix_redir = 0;
}
else
fix_redir = 0;
ret = CreateProcessW (newargv[0], exp_data, NULL, NULL, TRUE, einfo->fMask & SEE_MASK_NO_CONSOLE ? CREATE_NEW_CONSOLE : 0, NULL, lpdir, &si, &pi);
err = GetLastError();
if (fix_redir != 0)
revertwow64 (redir);
if (kernel32 != NULL)
FreeLibrary (kernel32);
if (ret != 0)
{
logtofilew (logfile, L"CreateProcessW() succeeded\n");
ret = 0;
if (executable)
{
logtofilew (logfile, L"Waiting until executable process terminates...\n");
WaitForSingleObject (pi.hProcess, INFINITE);
logtofilew (logfile, L"Finished waiting until executable process terminates\n");
}
else
{
if (einfo->fMask & SEE_MASK_NOCLOSEPROCESS)
{
einfo->hProcess = pi.hProcess;
logtofilew (logfile, L"Will return process handle %08X\n", pi.hProcess);
}
if (einfo->fMask & SEE_MASK_WAITFORINPUTIDLE)
{
logtofilew (logfile, L"Waiting until non-executable process' input idles...\n");
WaitForInputIdle (pi.hProcess, 60*1000);
logtofilew (logfile, L"Finished waiting until non-executable process' input idles\n");
}
}
einfo->hInstApp = (HINSTANCE) 33;
}
else
{
logtofilew (logfile, L"CreateProcessW() have failed with %d\n", err);
switch (err)
{
case ERROR_FILE_NOT_FOUND:
einfo->hInstApp = (HINSTANCE) SE_ERR_FNF;
break;
case ERROR_PATH_NOT_FOUND:
einfo->hInstApp = (HINSTANCE) SE_ERR_PNF;
break;
case ERROR_ACCESS_DENIED:
einfo->hInstApp = (HINSTANCE) SE_ERR_ACCESSDENIED;
break;
case ERROR_NOT_ENOUGH_MEMORY:
einfo->hInstApp = (HINSTANCE) SE_ERR_OOM;
break;
default:
einfo->hInstApp = (HINSTANCE) 33;
}
ret = 1;
}
logtofilew (logfile, L"hInstApp is set to %d\n", einfo->hInstApp);
free (exp_data);
if (dupdata != NULL)
free (dupdata);
if (newargv != NULL)
free (newargv);
logtofilew (logfile, L"<run_handler %d\n", ret);
return ret;
}
int
run_program(int flags, const char *cmd, ...)
{
va_list ap;
struct winsize win;
int ret;
WINDOW *actionwin = NULL;
char *scmd;
char **args;
const char *errstr = NULL;
va_start(ap, cmd);
vasprintf(&scmd, cmd, ap);
va_end(ap);
if (scmd == NULL)
err(1, "vasprintf(&scmd, \"%s\", ...)", cmd);
args = make_argv(scmd);
/* Make curses save tty settings */
def_prog_mode();
(void)ioctl(STDIN_FILENO, TIOCGWINSZ, &win);
/* Apparently, we sometimes get 0x0 back, and that's not useful */
if (win.ws_row == 0)
win.ws_row = 24;
if (win.ws_col == 0)
win.ws_col = 80;
if ((flags & RUN_DISPLAY) != 0) {
if (flags & RUN_FULLSCREEN) {
wclear(stdscr);
clearok(stdscr, 1);
touchwin(stdscr);
refresh();
actionwin = stdscr;
} else
actionwin = show_cmd(scmd, &win);
} else
win.ws_row -= 4;
ret = launch_subwin(&actionwin, args, &win, flags, scmd, &errstr);
fpurge(stdin);
/* If the command failed, show command name */
if (actionwin == NULL && ret != 0 && !(flags & RUN_ERROR_OK))
actionwin = show_cmd(scmd, &win);
if (actionwin != NULL) {
int y, x;
getyx(actionwin, y, x);
if (actionwin != stdscr)
mvaddstr(0, 4, msg_string(MSG_Status));
if (ret != 0) {
if (actionwin == stdscr && x != 0)
addstr("\n");
x = 1; /* force newline below */
standout();
addstr(errstr);
standend();
} else {
if (actionwin != stdscr) {
standout();
addstr(msg_string(MSG_Finished));
standend();
}
}
clrtoeol();
refresh();
if ((ret != 0 && !(flags & RUN_ERROR_OK)) ||
(y + x != 0 && !(flags & RUN_PROGRESS))) {
if (actionwin != stdscr)
move(getbegy(actionwin) - 2, 5);
else if (x != 0)
addstr("\n");
addstr(msg_string(MSG_Hit_enter_to_continue));
refresh();
getchar();
} else {
if (y + x != 0) {
/* give user 1 second to see messages */
refresh();
sleep(1);
}
}
}
/* restore tty setting we saved earlier */
reset_prog_mode();
/* clean things up */
if (actionwin != NULL) {
if (actionwin != stdscr)
delwin(actionwin);
if (errstr == 0 || !(flags & RUN_NO_CLEAR)) {
wclear(stdscr);
touchwin(stdscr);
clearok(stdscr, 1);
refresh();
}
}
free(scmd);
free_argv(args);
if (ret != 0 && flags & RUN_FATAL)
exit(ret);
return ret;
}
IProcess* UnixProcessImpl::Execute(
wxEvtHandler* parent, const wxString& cmd, size_t flags, const wxString& workingDirectory, IProcessCallback* cb)
{
wxUnusedVar(flags);
make_argv(cmd);
if(argc == 0) {
return NULL;
}
// fork the child process
wxString curdir = wxGetCwd();
// Prentend that we are a terminal...
int master, slave;
openpty(&master, &slave, NULL, NULL, NULL);
int rc = fork();
if(rc == 0) {
login_tty(slave);
close(master); // close the un-needed master end
// at this point, slave is used as stdin/stdout/stderr
// Child process
if(workingDirectory.IsEmpty() == false) {
wxSetWorkingDirectory(workingDirectory);
}
// execute the process
execvp(argv[0], argv);
// if we got here, we failed...
exit(0);
} else if(rc < 0) {
// Error
// restore the working directory
wxSetWorkingDirectory(curdir);
return NULL;
} else {
// Parent
close(slave);
freeargv(argv);
argc = 0;
// disable ECHO
struct termios termio;
tcgetattr(master, &termio);
termio.c_lflag = ICANON;
termio.c_oflag = ONOCR | ONLRET;
tcsetattr(master, TCSANOW, &termio);
// restore the working directory
wxSetWorkingDirectory(curdir);
UnixProcessImpl* proc = new UnixProcessImpl(parent);
proc->m_callback = cb;
proc->SetReadHandle(master);
proc->SetWriteHandler(master);
proc->SetPid(rc);
proc->m_flags = flags; // Keep the creation flags
if(!(proc->m_flags & IProcessCreateSync)) {
proc->StartReaderThread();
}
return proc;
}
}
int main(int argc, char **argv)
{
const char * rilLibPath = NULL;
char **rilArgv;
static char * s_argv[MAX_LIB_ARGS] = {NULL};
void *dlHandle;
const RIL_RadioFunctions *(*rilInit)(const struct RIL_Env *, int, char **);
const RIL_RadioFunctions *funcs;
char libPath[PROPERTY_VALUE_MAX];
unsigned char hasLibArgs = 0;
int j = 0;
int i;
static char clientId[3] = {'0'};
RLOGD("**RIL Daemon Started**");
RLOGD("**RILd param count=%d**", argc);
memset(s_argv, 0, sizeof(s_argv));
s_argv[0] = argv[0];
umask(S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH);
for (i = 1, j = 1; i < argc ;) {
if (0 == strcmp(argv[i], "-l") && (argc - i > 1)) {
rilLibPath = argv[i + 1];
i += 2;
} else if (0 == strcmp(argv[i], "-c") && (argc - i > 1)) {
strncpy(clientId, argv[i+1], strlen(clientId));
i += 2;
} else if (0 == strcmp(argv[i], "--")) {
i++;
hasLibArgs = 1;
memcpy(&s_argv[j], &argv[i], argc-i);
break;
} else {
usage(argv[0]);
}
}
#ifdef QCOM_HARDWARE
if (atoi(clientId) >= MAX_RILDS) {
RLOGE("Max Number of rild's supported is: %d", MAX_RILDS);
exit(0);
}
RLOGD ("RIL Client Id:=%s", clientId);
if (strncmp(clientId, "0", MAX_CLIENT_ID_LENGTH)) {
if (RIL_setRilSocketName) {
RIL_setRilSocketName(clientId);
} 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_device[32];
int done = 0;
//连接库地址：/system/lib/libreference-ril.so
#define REFERENCE_RIL_PATH "/system/lib/libreference-ril.so"
/* first, read /proc/cmdline into memory */
char buffer[1024], *p, *q;
int len;
int fd = open("/proc/cmdline",O_RDONLY);
if (fd < 0) {
RLOGD("could not open /proc/cmdline:%s", strerror(errno));
goto OpenLib;
}
do {
len = read(fd,buffer,sizeof(buffer)); }
while (len == -1 && errno == EINTR);
if (len < 0) {
RLOGD("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 );
memset(s_argv, 0, sizeof(s_argv));
s_argv[1] = "-s";
s_argv[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;
memset(s_argv, 0, sizeof(s_argv));
s_argv[1] = "-d";
s_argv[2] = arg_device;
done = 1;
} while (0);
if (done) {
argc = 3;
i = 1;
hasLibArgs = 1;
rilLibPath = REFERENCE_RIL_PATH;
RLOGD("overriding with %s %s", s_argv[1], s_argv[2]);
}
}
OpenLib:
#endif
//切换UID为AID_RADIO
switchUser();
// 打开链接库
dlHandle = dlopen(rilLibPath, RTLD_NOW);
if (dlHandle == NULL) {
RLOGE("dlopen failed: %s", dlerror());
exit(-1);
}
// 开启EventLoop循环
RIL_startEventLoop();
// 从链接库中（也就是reference-ril.c）寻找RIL_Init函数地址
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(-1);
}
if (hasLibArgs) {
argc = argc-i+1;
} else {
static char * newArgv[MAX_LIB_ARGS];
static char args[PROPERTY_VALUE_MAX];
property_get(LIB_ARGS_PROPERTY, args, "");
argc = make_argv(args, s_argv);
}
// Make sure there's a reasonable argv[0]
s_argv[0] = argv[0];
if (argc >= MAX_LIB_ARGS - 2) {
RLOGE("Max arguments are passed for rild, args count = %d", argc);
exit(0);
}
#ifdef QCOM_HARDWARE
/* Client-id is a qualcomm thing */
s_argv[argc++] = "-c";
s_argv[argc++] = clientId;
#endif
RLOGD("RIL_Init argc = %d clientId = %s", argc, s_argv[argc-1]);
// 初始化过程将s_rilEnv全局变量传递给了reference，然后在reference-ril.c内部将这个值传给了s_rilenv
// 而s_rilEnv的各个处理函数是在ril.cpp中实现的
// 调用reference-ril.c中的RIL_Init函数进行初始化INIT，同时得到reference-ril的回调函数
funcs = rilInit(&s_rilEnv, argc, s_argv);
#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, s_argv);
}
#endif
//注册得到的reference的回调函数
RIL_register(funcs);
done:
while(1) {
// sleep(UINT32_MAX) seems to return immediately on bionic
sleep(0x00ffffff);
}
}
int execute( const List_t* list) {
Node_t* curr = list->head->next;
int files = -1;
int** pipes = make_pipes( list->count - 1);
if( !pipes)
return 0;
int outPipe[2] = {};
pipe( outPipe);
if( outPipe[0] < 0 || outPipe[1] < 0) {
warn( "Error while creating outPipe");
return 0;
}
char* argv[ARGUMENTS_NUMBER] = {};
int i = 0;
pid_t pid = 0;
int status = -1;
while( curr) {
make_argv( curr->program, argv);
files = open_files( curr->program);
if( (pid = fork()) == 0) {
if( curr->program->input >= 0) {
if( dup2( curr->program->input, 0) < 0)
warn( "Error while getting input from file %s", curr->program->input_name);
} else if( i > 0) {
if( dup2( pipes[i - 1][0], 0) < 0)
warn( "Error while piping input for program %d", i);
}
if( curr->program->output >= 0)
if( dup2( curr->program->output, 1) < 0)
warn( "Error while sending output to file %s", curr->program->output_name);
if( curr->type == last && curr->program->output < 0)
if( dup2( outPipe[1], 1) < 0)
warn( "Error while sending output to final pipe");
if( curr->type != last && curr->program->output < 0)
if( dup2( pipes[i][1], 1) < 0)
warn( "Error while piping output for program %d", i);
close_pipes( pipes, list->count - 1);
if( outPipe[0] > 0)
close( outPipe[0]);
if( outPipe[1] > 0)
close( outPipe[1]);
free_pipes( pipes, list->count - 1);
if( files != close_files( curr->program))
warn( "Error while closing files in child");
if( execvp( curr->program->name, argv) < 0) {
warn( "Error while executing %s", curr->program->name);
exit( -1);
}
}
if( curr->type == last) {
close_pipes( pipes, list->count - 1);
if( outPipe[1] > 0)
close( outPipe[1]);
print_output( outPipe[0]);
if( outPipe[0] > 0)
close( outPipe[0]);
waitpid( pid, &status, 0);
printf("Process exited with status %d\n", status);
}
if( files != close_files( curr->program))
warn( "Error while closing files in parrent");
curr = curr->next;
++i;
}
free_pipes( pipes, list->count - 1);
return 1;
}
static int handle_request(request_rec *r)
{
tmcdreq_t tmcdreq, *reqp = &tmcdreq;
tmcdresp_t *response = NULL;
char *command;
struct in_addr local_addr;
struct in_addr remote_addr;
struct sockaddr_in redir_client;
int tmcd_status;
int status = OK;
char *status_line = NULL;
char *args = NULL;
char *function_args = NULL;
char *p;
char **argv = NULL;
int argc, i;
reqp->istcp = 1;
reqp->isssl = 1; /* FIXME */
if (strcmp(r->handler, "tmcd")) {
status = DECLINED;
goto err;
}
#if 0
r->allowed |= (AP_METHOD_BIT << M_GET);
if (r->method_number != M_GET) {
status = DECLINED;
goto err;
}
#endif
memset(reqp, 0, sizeof(*reqp));
local_addr = r->connection->local_addr.sin_addr;
remote_addr = r->connection->remote_addr.sin_addr;
reqp->version = 1; /* FIXME need sane default */
tmcd_init(reqp, &local_addr, NULL);
command = r->path_info;
while (*command && *command == '/') {
command++;
}
if (command[0] == '\0') {
status = HTTP_BAD_REQUEST;
goto err;
}
if (r->args) {
args = malloc(strlen(r->args) + 1);
if (args == NULL) {
status = HTTP_INTERNAL_SERVER_ERROR;
goto err;
}
strcpy(args, r->args);
argv = make_argv(args, &argc, '&');
if (argv == NULL) {
status = HTTP_INTERNAL_SERVER_ERROR;
goto err;
}
for (i = 0; i < argc; i++) {
/* Unescape the arguments */
p = args;
while (*p) {
if (*p == '+')
*p = ' ';
p++;
}
status = ap_unescape_url(args);
if (status != OK) {
goto err;
}
if (strncasecmp(argv[i], "version=", 8) == 0) {
long version;
char *end;
version = strtol(argv[i] + 8, &end, 10);
if (*end != '\0' || *(argv[i] + 8) == '\0') {
status = HTTP_BAD_REQUEST;
status_line = "Invalid Version";
goto err;
}
reqp->version = version;
} else if (strncasecmp(argv[i], "redirect=", 9) == 0) {
if (inet_pton(AF_INET, argv[i] + 9,
&redir_client.sin_addr) <= 0) {
status = HTTP_BAD_REQUEST;
status_line = "Invalid IP Address";
goto err;
}
/* FIXME info message */
if (remote_addr.s_addr != local_addr.s_addr) {
status = HTTP_FORBIDDEN;
status_line = "Redirection Not Allowed";
goto err;
}
remote_addr =
redir_client.sin_addr;
} else if (strncasecmp(argv[i], "vnodeid=", 8) == 0) {
if (strlen(argv[i] + 8) >=
sizeof(reqp->vnodeid)) {
status = HTTP_BAD_REQUEST;
status_line =
"Virtual Node ID Too Long";
goto err;
}
reqp->isvnode = 1;
strcpy(reqp->vnodeid, argv[i] + 8);
} else if (strncasecmp(argv[i], "args=", 5) == 0) {
function_args = argv[i] + 5;
}
}
}
/* FIXME handle wanodekey */
if ((tmcd_status = iptonodeid(reqp, remote_addr, NULL))) {
if (reqp->isvnode) {
status_line = "Invalid Virtual Node";
}
else {
status_line = "Invalid Node";
}
status = HTTP_NOT_FOUND;
goto err;
}
if (reqp->tmcd_redirect[0]) {
/* FIXME what if https should be used? */
/* FIXME do I need to specify the args should be passed too? */
char *uri = ap_psprintf(r->pool, "http://%s%s?%s", reqp->tmcd_redirect,
r->uri, r->args);
ap_table_setn(r->headers_out, "Location", uri);
status = HTTP_MOVED_TEMPORARILY;
goto done;
}
tmcd_status = tmcd_handle_request(reqp, &response, command,
function_args);
if (tmcd_status == TMCD_STATUS_OK) {
r->content_type = response->type;
ap_set_content_length(r, response->length);
/* FIXME doctype */
ap_soft_timeout("tmcd response call trace", r);
ap_send_http_header(r);
ap_rprintf(r, "%s", response->data);
ap_kill_timeout(r);
status = OK;
goto done;
} else {
switch(tmcd_status) {
case TMCD_STATUS_UNKNOWN_COMMAND:
status = HTTP_NOT_FOUND;
status_line = "Unknown Command";
break;
case TMCD_STATUS_REQUIRES_ENCRYPTION:
status = HTTP_FORBIDDEN;
status_line = "SSL Required";
break;
case TMCD_STATUS_NODE_NOT_ALLOCATED:
status = HTTP_FORBIDDEN;
status_line = "Node Not Allocated";
break;
case TMCD_STATUS_COMMAND_FAILED:
status = HTTP_INTERNAL_SERVER_ERROR;
if (response && response->data) {
status_line = response->data;
}
break;
case TMCD_STATUS_MALLOC_FAILED:
status = HTTP_INTERNAL_SERVER_ERROR;
break;
}
goto err;
}
err:
done:
if (argv)
free(argv);
if (args)
free(args);
if (response)
tmcd_free_response(response);
if (status_line) {
r->status_line = ap_psprintf(r->pool, "%3.3u %s", status,
status_line);
}
return status;
}
void rbenv_exec_subcommand(char *command, char **argv) {
char *subcommand = rbenv_subcommand_name(command);
execvp(subcommand, make_argv(subcommand, argv));
fprintf(stderr, "rbenv: no such command `%s'\n", command);
exit(1);
}
int cmd_handle(int UNUSED(sd), char *line)
{
int argc, func;
char *argv[10];
dev_info_t *pdev;
argc = make_argv(line, ARRAY_SIZE(argv), argv);
if (argc <= 0)
return ERROR;
DBG_OUT("argc is %d", argc);
func = get_cmdid(argv[0]);
if (func < 0) {
printf("unknown command: %s\r\n", argv[0]);
return ERROR;
}
switch (func) {
case SERV_REQ_KICKCLI:
case SERV_REQ_REBOOT:
case SERV_REQ_FACTORY:
{
PMIFI_PACKET p;
int i, datalen, packetlen;
u8 sum;
i = 0;
datalen = 0;
packetlen = sizeof(MIFI_PACKET ) + datalen;
p = (PMIFI_PACKET)malloc(packetlen + 1);
if (argc == 2) {
devid_t devid;
hex2bin((u8 *)argv[1], (u8 *)&devid, sizeof(devid_t));
i = find_device_by_id(&devid);
if (i < 0) {
printf("cannot find device: %s\r\n", argv[1]);
break;
}
}
pdev = get_device(i);
build_packet_header(p, pdev, func);
p->datalen = htons(datalen);
sum = get_checksum((u8 *)p, packetlen);
*(((u8 *)p) + packetlen) = sum;
push_data(pdev->sd, (u8 *)p, packetlen + 1);
free(p);
}
break;
case SERV_REQ_UPGRADE:
{
PMIFI_PACKET p;
char *url = "http://url.cn/QyCLQu";
int i, url_len, datalen, packetlen;
u8 sum;
i = 0;
url_len = strlen(url);
datalen = url_len + 2;
packetlen = sizeof(MIFI_PACKET ) + datalen;
p = (PMIFI_PACKET)malloc(packetlen + 1);
pdev = get_device(i);
build_packet_header(p, pdev, func);
p->datalen = htons(datalen);
p->data[0] = ((u8*)&url_len)[1];
p->data[1] = ((u8*)&url_len)[0];
memcpy(p->data + 2, url, datalen);
sum = get_checksum((u8 *)p, packetlen);
*(((u8 *)p) + packetlen) = sum;
push_data(pdev->sd, (u8 *)p, packetlen + 1);
free(p);
}
break;
case SERV_REQ_KICKUSR:
{
PMIFI_PACKET p;
int i, datalen, packetlen;
u8 sum;
i = 0;
datalen = sizeof(macadr_t);
packetlen = sizeof(MIFI_PACKET ) + datalen;
p = (PMIFI_PACKET)malloc(packetlen + 1);
if (argc == 3) {
devid_t devid;
hex2bin((u8 *)argv[2], (u8 *)&devid, sizeof(devid_t));
i = find_device_by_id(&devid);
if (i < 0) {
printf("cannot find device: %s\r\n", argv[2]);
break;
}
}
pdev = get_device(i);
build_packet_header(p, pdev, func);
p->datalen = htons(datalen);
if (argc == 1) {
i = find_first_valid_user(pdev);
} else {
macadr_t user;
hex2bin((u8 *)argv[1], (u8 *)&user, sizeof(macadr_t));
i = find_user(pdev, &user);
if (i < 0) {
printf("cannot find user: %s\r\n", argv[1]);
break;
}
}
memcpy(p->data, pdev->users[i], datalen);
clean_user(&pdev->users[i]); // should be clean after got the response from client
sum = get_checksum((u8 *)p, packetlen);
*(((u8 *)p) + packetlen) = sum;
push_data(pdev->sd, (u8 *)p, packetlen + 1);
free(p);
}
break;
case MIFI_CMD_LDEV:
{
int i = 0;
devid_t freedev = {0};
for (i = 0; i < ARRAY_SIZE(dev_map); i++)
{
if (dev_map[i].valid && (memcmp(&dev_map[i].devid, &freedev, sizeof(devid_t)) != 0))
{
printf("DevID: ");
dump_data((u8 *)&dev_map[i].devid, sizeof(devid_t), 0);
printf("IMSI: ");
dump_data((u8 *)&dev_map[i].imsi, sizeof(imsi_t), 0);
printf("\r\n");
}
}
}
break;
case MIFI_CMD_LUSER:
{
int i = 0;
macadr_t freeuser = {0};
if (argc == 2) {
devid_t devid;
hex2bin((u8 *)argv[1], (u8 *)&devid, sizeof(devid_t));
i = find_device_by_id(&devid);
if (i < 0) {
printf("cannot find device: %s\r\n", argv[1]);
break;
}
}
pdev = get_device(i);
for (i = 0; i < ARRAY_SIZE(pdev->users); i++)
{
if (memcmp(&pdev->users[i], &freeuser, sizeof(macadr_t)) != 0)
{
dump_data((u8 *)&pdev->users[i], sizeof(macadr_t), 0);
}
}
}
break;
default:
DBG_OUT("func isn't impletement: %d", func);
return ERROR;
}
return 0;
}
/* call as model = mexsvmlearn(data,labels,options) */
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
char **argv;
int argc;
DOC **docs; /* training examples */
long totwords,totdoc,i;
double *target;
double *alpha_in=NULL;
KERNEL_CACHE *kernel_cache;
LEARN_PARM learn_parm;
KERNEL_PARM kernel_parm;
MODEL model;
/* check for valid calling format */
if ((nrhs != 3) || (nlhs != 1))
mexErrMsgTxt(ERR001);
if (mxGetM(prhs[0]) != mxGetM(prhs[1]))
mexErrMsgTxt(ERR002);
if (mxGetN(prhs[1]) != 1)
mexErrMsgTxt(ERR003);
/* reset static variables -- as a .DLL, static things are sticky */
global_init( );
/* convert the parameters (given in prhs[2]) into an argv/argc combination */
argv = make_argv((mxArray *)prhs[2],&argc); /* send the options */
/* this was originally supposed to be argc, argv, re-written for MATLAB ...
its cheesy - but it workss :: convert the options array into an argc,
argv pair and let svm_lite handle it from there. */
read_input_parameters(argc,argv,docfile,modelfile,restartfile,&verbosity,
&learn_parm,&kernel_parm);
extract_user_opts((mxArray *)prhs[2], &kernel_parm);
totdoc = mxGetM(prhs[0]);
totwords = mxGetN(prhs[0]);
/* prhs[0] = samples (mxn) array
prhs[1] = labels (mx1) array */
mexToDOC((mxArray *)prhs[0], (mxArray *)prhs[1], &docs, &target, NULL, NULL);
/* TODO modify to accept this array
if(restartfile[0]) alpha_in=read_alphas(restartfile,totdoc); */
if(kernel_parm.kernel_type == LINEAR) { /* don't need the cache */
kernel_cache=NULL;
}
else {
/* Always get a new kernel cache. It is not possible to use the
same cache for two different training runs */
kernel_cache=kernel_cache_init(totdoc,learn_parm.kernel_cache_size);
}
if(learn_parm.type == CLASSIFICATION) {
svm_learn_classification(docs,target,totdoc,totwords,&learn_parm,
&kernel_parm,kernel_cache,&model,alpha_in);
}
else if(learn_parm.type == REGRESSION) {
svm_learn_regression(docs,target,totdoc,totwords,&learn_parm,
&kernel_parm,&kernel_cache,&model);
}
else if(learn_parm.type == RANKING) {
svm_learn_ranking(docs,target,totdoc,totwords,&learn_parm,
&kernel_parm,&kernel_cache,&model);
}
else if(learn_parm.type == OPTIMIZATION) {
svm_learn_optimization(docs,target,totdoc,totwords,&learn_parm,
&kernel_parm,kernel_cache,&model,alpha_in);
}
else {
mexErrMsgTxt(ERR004);
}
if(kernel_cache) {
/* Free the memory used for the cache. */
kernel_cache_cleanup(kernel_cache);
}
/* **********************************
* After the training/learning portion has finished,
* copy the model back to the output arrays for MATLAB
* ********************************** */
store_model(&model, plhs);
free_kernel();
global_destroy( );
}
int cmd_auto_complete(const char *const prompt, char *buf, int *np, int *colp)
{
int n = *np, col = *colp;
char *argv[CONFIG_SYS_MAXARGS + 1]; /* NULL terminated */
char *cmdv[20];
char *s, *t;
const char *sep;
int i, j, k, len, seplen, argc;
int cnt;
char last_char;
if (strcmp(prompt, CONFIG_SYS_PROMPT) != 0)
return 0; /* not in normal console */
cnt = strlen(buf);
if (cnt >= 1)
last_char = buf[cnt - 1];
else
last_char = '\0';
/* copy to secondary buffer which will be affected */
strcpy(tmp_buf, buf);
/* separate into argv */
argc = make_argv(tmp_buf, sizeof(argv)/sizeof(argv[0]), argv);
/* do the completion and return the possible completions */
i = complete_cmdv(argc, argv, last_char, sizeof(cmdv)/sizeof(cmdv[0]), cmdv);
/* no match; bell and out */
if (i == 0) {
if (argc > 1) /* allow tab for non command */
return 0;
putc('\a');
return 1;
}
s = NULL;
len = 0;
sep = NULL;
seplen = 0;
if (i == 1) { /* one match; perfect */
k = strlen(argv[argc - 1]);
s = cmdv[0] + k;
len = strlen(s);
sep = " ";
seplen = 1;
} else if (i > 1 && (j = find_common_prefix(cmdv)) != 0) { /* more */
k = strlen(argv[argc - 1]);
j -= k;
if (j > 0) {
s = cmdv[0] + k;
len = j;
}
}
if (s != NULL) {
k = len + seplen;
/* make sure it fits */
if (n + k >= CONFIG_SYS_CBSIZE - 2) {
putc('\a');
return 1;
}
t = buf + cnt;
for (i = 0; i < len; i++)
*t++ = *s++;
if (sep != NULL)
for (i = 0; i < seplen; i++)
*t++ = sep[i];
*t = '\0';
n += k;
col += k;
puts(t - k);
if (sep == NULL)
putc('\a');
*np = n;
*colp = col;
} else {
print_argv(NULL, " ", " ", 78, cmdv);
puts(prompt);
puts(buf);
}
return 1;
}
/* Called from main(). */
bool
sys_init(char *program_name)
{
int argc;
char **argv;
repv head, *last;
gtk_set_locale ();
if (!batch_mode_p ())
setpgid (0, 0);
make_argv (Fcons (Fsymbol_value (Qprogram_name, Qt),
Fsymbol_value (Qcommand_line_args, Qt)), &argc, &argv);
/* We need to initialise GTK now. The rep-gtk library will
not reinitialise it.. */
gtk_init (&argc, &argv);
argc--; argv++;
head = Qnil;
last = &head;
while(argc > 0)
{
*last = Fcons(rep_string_copy(*argv), Qnil);
last = &rep_CDR(*last);
argc--;
argv++;
}
Fset (Qcommand_line_args, head);
def_font_str = rep_VAL (&def_font_str_data);
#ifdef HAVE_X11
get_resources (program_name);
#endif
get_options ();
use_options ();
color_map = gdk_colormap_get_system ();
gtk_meta_mod = gtk_find_meta ();
/* Loading the gtk rep library will replace the usual
event loop with one that works with GTK. */
rep_INTERN(gtk_feature);
#if rep_INTERFACE >= 9
Frequire (Qgtk_feature);
#else
Fload (rep_string_copy ("gtk"), Qnil, Qnil, Qnil, Qnil);
#endif
if (!rep_throw_value)
{
/* Find the gtkobj<->lispobj converters */
gtk_jade_wrap_gtkobj = rep_find_dl_symbol (Qgtk_feature, "sgtk_wrap_gtkobj");
gtk_jade_get_gtkobj = rep_find_dl_symbol (Qgtk_feature, "sgtk_get_gtkobj");
gtk_jade_callback_postfix = rep_find_dl_symbol (Qgtk_feature, "sgtk_callback_postfix");
assert (gtk_jade_wrap_gtkobj != 0
&& gtk_jade_get_gtkobj != 0
&& gtk_jade_callback_postfix != 0);
return true;
}
else
return false;
}
int main(int argc, char **argv)
{
const char * rilLibPath = NULL;
char **rilArgv;
void *dlHandle;
const RIL_RadioFunctions *(*rilInit)(const struct RIL_Env *, int, char **);
const RIL_RadioFunctions *funcs;
char libPath[PROPERTY_VALUE_MAX];
unsigned char hasLibArgs = 0;
int i;
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 {
usage(argv[0]);
}
}
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[3];
static char arg_device[32];
int done = 0;
#define REFERENCE_RIL_PATH "/system/lib/libreference-ril.so"
/* first, read /proc/cmdline into memory */
char buffer[1024], *p, *q;
int len;
int fd = open("/proc/cmdline",O_RDONLY);
if (fd < 0) {
LOGD("could not open /proc/cmdline:%s", strerror(errno));
goto OpenLib;
}
do {
len = read(fd,buffer,sizeof(buffer)); }
while (len == -1 && errno == EINTR);
if (len < 0) {
LOGD("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 = 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;
}
LOGD("could not connect to %s socket: %s",
QEMUD_SOCKET_NAME, strerror(errno));
if (--tries == 0)
break;
}
if (!done) {
LOGE("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;
LOGD("overriding with %s %s", arg_overrides[1], arg_overrides[2]);
}
}
OpenLib:
#endif
switchUser();
dlHandle = dlopen(rilLibPath, RTLD_NOW);
if (dlHandle == NULL) {
fprintf(stderr, "dlopen failed: %s\n", dlerror());
exit(-1);
}
RIL_startEventLoop();
rilInit = (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))dlsym(dlHandle, "RIL_Init");
if (rilInit == NULL) {
fprintf(stderr, "RIL_Init not defined or exported in %s\n", rilLibPath);
exit(-1);
}
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);
}
// Make sure there's a reasonable argv[0]
rilArgv[0] = argv[0];
funcs = rilInit(&s_rilEnv, argc, rilArgv);
RIL_register(funcs);
done:
while(1) {
// sleep(UINT32_MAX) seems to return immediately on bionic
sleep(0x00ffffff);
}
}
int main(int argc, char **argv) {
// vendor ril lib path either passed in as -l parameter, or read from rild.libpath property
const char *rilLibPath = NULL;
// ril arguments either passed in as -- parameter, or read from rild.libargs property
char **rilArgv;
// handle for vendor ril lib
void *dlHandle;
// Pointer to ril init function in vendor ril
const RIL_RadioFunctions *(*rilInit)(const struct RIL_Env *, int, char **);
// Pointer to sap init function in vendor ril
const RIL_RadioFunctions *(*rilUimInit)(const struct RIL_Env *, int, char **);
const char *err_str = NULL;
// functions returned by ril init function in vendor ril
const RIL_RadioFunctions *funcs;
// lib path from rild.libpath property (if it's read)
char libPath[PROPERTY_VALUE_MAX];
// flat to indicate if -- parameters are present
unsigned char hasLibArgs = 0;
int i;
// ril/socket id received as -c parameter, otherwise set to 0
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]);
}
}
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)) {
snprintf(ril_service_name, sizeof(ril_service_name), "%s%s", ril_service_name_base,
clientId);
}
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;
}
}
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 =
(const 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);
}
rilArgv[argc++] = "-c";
rilArgv[argc++] = (char*)clientId;
RLOGD("RIL_Init argc = %d clientId = %s", argc, rilArgv[argc-1]);
// Make sure there's a reasonable argv[0]
rilArgv[0] = argv[0];
funcs = rilInit(&s_rilEnv, argc, rilArgv);
RLOGD("RIL_Init rilInit completed");
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");
rilc_thread_pool();
done:
RLOGD("RIL_Init starting sleep loop");
while (true) {
sleep(UINT32_MAX);
}
}
