JSON在android中应用

Android里面权限控制的比较严，一般的应用当需要使用系统或者root权限是，比较麻烦，所以编写一个root service用来处理root权限请求，通过socket通信

[cpp] view plaincopyprint?

/* 标准头文件放在前面，否则有些函数定义会被覆盖掉 */

#include <stdio.h>

#include <assert.h>

#include <stdlib.h>

#include <string.h>

#include <pthread.h>

#define LOG_TAG "ROOT_SERVER"

#include <stdio.h>

#include <errno.h>

#include <stdlib.h>

#include <sys/socket.h>

#include <sys/select.h>

#include <sys/time.h>

#include <sys/types.h>

#include <sys/un.h>

#include <sys/wait.h>

#include "mjson.h"

#include <cutils/log.h>

#include <cutils/sockets.h>

#define SERVER_NAME "@server_root_permission_socket"

#define MAX_PARAM_NUM 10

typedef enum e_root_call_type

{

ROOT_SYSTEM_CALL,

ROOT_SYSTEM_EXE,

};

static inline long long current_time_millis(){

struct timeval tv[1];

gettimeofday(tv, NULL);

return((long long)tv->tv_sec) * 1000 + tv->tv_usec/1000;

}

/* 检测状态,timeout单位ms, timeout=-1表示无限等待 */

int main(int argc, char **argv)

{

int server_sockfd ;

int client_sockfd ;

socklen_t server_len, client_len;

struct sockaddr_un client_addr;

int nread;

int i = 0;

json_t*root = NULL, *q = NULL;

char* json = NULL;

int recv_len;

int param_len = 0;

char buffer[1024];

int ret = -1;

fd_set read_fds;

int max = 0;

e_root_call_type type = ROOT_SYSTEM_CALL;

//delete the old server socket

unlink(SERVER_NAME);

//create socket

server_sockfd = socket(AF_UNIX, SOCK_STREAM, 0);

LOGI("server_sockfd = %d", server_sockfd);

if( -1 == server_sockfd )

{

LOGE("[%s] [%s] [%d] server_sockefd creat error",__FUNCTION__, __FILE__, __LINE__);

return -1;

}

//set server addr_param

struct sockaddr_un server_addr;

server_addr.sun_family = AF_UNIX;

strncpy(server_addr.sun_path, SERVER_NAME, sizeof(server_addr.sun_path) - 1);

ret = bind(server_sockfd,(struct sockaddr*)&server_addr,sizeof(server_addr));

if (ret == -1) {

LOGI("cannot bind server socket");

return -1;

}

//listen the server

listen(server_sockfd, 5);

client_sockfd = -1;

memset(&client_addr,0,sizeof(struct sockaddr_un));

client_len = sizeof(client_addr);

sleep(1);

FD_SET(server_sockfd, &read_fds);

max = server_sockfd;

mjson_init();

while(1)

{

LOGI("before select");

usleep(100*1000);

memset(buffer, 0x0, sizeof(buffer));

if ((ret = select(max + 1, &read_fds, NULL, NULL, NULL)) < 0) {

LOGI("select failed (%s)", strerror(errno));

sleep(1);

continue;

} else if (!ret)

continue;

LOGI("ret select-------------");

if ((client_sockfd = accept(server_sockfd,(struct sockaddr*)&client_addr, &client_len)) < 0)

{

LOGI("accept failed (%s)", strerror(errno));

sleep(1);

continue;

}

LOGI("client_sockfd = %d", client_sockfd);

//read data from client socket

nread = read( client_sockfd, ¶m_len, 4);

if (nread != 0) {//client disconnected

LOGI("client %d receive nothing\n", client_sockfd);

}

LOGI("param_len = %d", param_len);

nread = read( client_sockfd, buffer, param_len);

if (nread != 0) {//client disconnected

LOGI("client %d receive nothing\n", client_sockfd);

}

LOGI("nread = %d", nread);

LOGI("buffer = %s", buffer);

json = buffer;

if (mjson_parse(&root, (char*) json) != 0)

{

LOGE("json parse failed11!\n");

ret = -1;

goto BAIL;

}

if (mjson_try_begin() < 0)

{

LOGE("invalid !!!\n");

ret = -1;

goto BAIL;

}

q = root;

type =(e_root_call_type) mjson_locate_number(q, "call_type");

LOGI("call_type = %d", type);

if(ROOT_SYSTEM_CALL == type)

{

char *fuction_name = NULL;

fuction_name = mjson_locate_string(q, "fuction_name");

LOGI("fuction_name = %s", fuction_name);

LOGI("strlen(fuction_name) = %d", strlen(fuction_name));

if(strstr(fuction_name, "settimeofday") != NULL)

{

struct timeval tms;

tms.tv_sec = mjson_locate_number(q, "tms.tv_sec");

tms.tv_usec = mjson_locate_number(q, "tms.tv_usec");

LOGI("tms.tv_sec = %d", tms.tv_sec);

LOGI("tms.tv_usec = %d", tms.tv_usec);

ret = settimeofday(&tms, NULL);

LOGI("ret = %d", ret);

}

}

else if(ROOT_SYSTEM_EXE == type)

{

int pid = 0;

int param_num = 0;

int wait_flag = 0, status = 0;

char *exe_name = NULL;

char *param_array[MAX_PARAM_NUM];

char param_name[64];

exe_name = mjson_locate_string(q, "exe_name");

param_num = mjson_locate_number(q, "param_num");

wait_flag = mjson_locate_number(q, "wait_flag");

LOGI( "exe_name= %s, param_num = %d, wait_flag = %d", exe_name, param_num, wait_flag);

/*vfork 创建进程*/

pid = vfork();

if (pid < 0)

{

LOGI( "(out)vfork error");

goto BAIL;

}

if (0 == pid)

{

for(i = 0; i < param_num; i++)

{

sprintf(param_name, "param%d", i);

param_array[i] = mjson_locate_string(q, param_name);

LOGI( "param_name= %s, param_array[%d] = %s", param_name, i, param_array[i]);

}

switch(param_num)

{

case 0:

ret = execl(exe_name, exe_name, (char*)0);

break;

case 1:

ret = execl(exe_name, exe_name, param_array[0], (char*)0);

break;

case 2:

ret = execl(exe_name, exe_name, param_array[0], param_array[1], (char*)0);

break;

case 3:

ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], (char*)0);

break;

case 4:

ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], param_array[3], (char*)0);

break;

case 5:

ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], param_array[3], param_array[4], (char*)0);

break;

case 6:

ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], param_array[3], param_array[4], param_array[5], (char*)0);

break;

case 7:

ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], param_array[3], param_array[4], param_array[5],

param_array[6], (char*)0);

break;

case 8:

ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], param_array[3], param_array[4], param_array[5],

param_array[6], param_array[7], (char*)0);

case 9:

ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], param_array[3], param_array[4], param_array[5],

param_array[6], param_array[7],param_array[8],(char*)0);

break;

case 10:

ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], param_array[3], param_array[4], param_array[5],

param_array[6], param_array[7], param_array[8], param_array[9], (char*)0);

break;

}

if(ret < 0)

{

LOGI( "(out)Err on execl");

_exit(0);

}

}

else

{

if(wait_flag)

{

/*等待进程结束*/

LOGI( "waitpid pid:%d", pid);

while(waitpid(pid, &status, 0) < 0)

{

LOGI( "waitpid error pid:%d", pid);

goto BAIL;

}

LOGI( "waitpid out pid:%d", pid);

}

}

}

ret = write(client_sockfd, &ret, 4);

LOGI("ret = %d", ret);

BAIL:

close(client_sockfd);

mjson_try_end();

}

return 0;

}

以json方式传递数据，server解析

client 一个例子：

[cpp] view plaincopyprint?

define SERVER_NAME "@server_root_permission_socket"

static inline long long current_time_millis(){

struct timeval tv[1];

gettimeofday(tv, NULL);

return((long long)tv->tv_sec) * 1000 + tv->tv_usec/1000;

}

int do_root_call(char *json)

{

int sockfd;

int len = -1;

int ret = -1;

int result;

sockfd = socket(AF_UNIX, SOCK_STREAM, 0);

if( -1 == sockfd ){

porting_error(PORT_MODULE_BASE,"[%s] [%d] sockfd creat error",__FUNCTION__, __LINE__);

return -1;

}

struct sockaddr_un address;

address.sun_family = AF_UNIX;

strcpy(address.sun_path, SERVER_NAME);

ret = connect(sockfd, (struct sockaddr *)&address, sizeof(address));

if (ret == -1) {

porting_error(PORT_MODULE_BASE,"[%s] [%d] client connect error",__FUNCTION__, __LINE__);

return -1;

}

porting_info(PORT_MODULE_BASE,"sockfd = %d", sockfd);

porting_info(PORT_MODULE_BASE,"result = %d", ret);

len = strlen(json);

ret = write(sockfd, &len, 4);

porting_info(PORT_MODULE_BASE,"ret2 = %d", ret);

porting_info(PORT_MODULE_BASE,"json = %s", json);

ret = write(sockfd, json, strlen(json));

porting_info(PORT_MODULE_BASE,"ret3 = %d", ret);

read( sockfd, &ret, 4);

porting_info(PORT_MODULE_BASE,"ret4 = %d", ret);

close(sockfd);

sockfd = -1;

porting_info(PORT_MODULE_BASE," client ok");

return 0;

}