程序博客网 > sql server 恢复挂起

JSON在android中应用

来源：互联网 发布：sql server 恢复挂起 编辑：程序博客网 时间：2024/05/21 11:20

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

[cpp] view plaincopyprint?
  1. /* 标准头文件放在前面，否则有些函数定义会被覆盖掉 */  
  2. #include <stdio.h>  
  3. #include <assert.h>  
  4. #include <stdlib.h>  
  5. #include <string.h>  
  6. #include <pthread.h>  
  7.   
  8. #define LOG_TAG "ROOT_SERVER"  
  9. #include <stdio.h>  
  10. #include <errno.h>  
  11. #include <stdlib.h>  
  12. #include <sys/socket.h>  
  13. #include <sys/select.h>  
  14. #include <sys/time.h>  
  15. #include <sys/types.h>  
  16. #include <sys/un.h>  
  17.   
  18. #include <sys/wait.h>  
  19.   
  20. #include "mjson.h"  
  21.   
  22. #include <cutils/log.h>  
  23. #include <cutils/sockets.h>  
  24.   
  25. #define SERVER_NAME "@server_root_permission_socket"  
  26.   
  27.   
  28. #define MAX_PARAM_NUM  10  
  29.   
  30. typedef enum e_root_call_type  
  31. {  
  32.     ROOT_SYSTEM_CALL,  
  33.     ROOT_SYSTEM_EXE,  
  34. };  
  35.   
  36.   
  37. static inline long long current_time_millis(){  
  38.     struct timeval tv[1];  
  39.     gettimeofday(tv, NULL);  
  40.     return((long long)tv->tv_sec) * 1000 + tv->tv_usec/1000;  
  41. }  
  42.   
  43.   
  44. /* 检测状态,timeout单位ms, timeout=-1表示无限等待 */  
  45. int main(int argc, char **argv)  
  46. {  
  47.   
  48.     int server_sockfd ;  
  49.     int client_sockfd ;  
  50.     socklen_t server_len, client_len;  
  51.     struct sockaddr_un client_addr;  
  52.     int nread;  
  53.     int i = 0;  
  54.     json_t*root = NULL, *q = NULL;  
  55.     char* json = NULL;  
  56.     int  recv_len;  
  57.     int param_len = 0;  
  58.     char buffer[1024];  
  59.     int ret = -1;  
  60.     fd_set read_fds;  
  61.     int max = 0;  
  62.     e_root_call_type type = ROOT_SYSTEM_CALL;  
  63.   
  64.     //delete the old server socket  
  65.     unlink(SERVER_NAME);  
  66.     //create socket  
  67.     server_sockfd = socket(AF_UNIX, SOCK_STREAM, 0);  
  68.     LOGI("server_sockfd = %d", server_sockfd);  
  69.     if( -1 == server_sockfd )  
  70.     {  
  71.         LOGE("[%s] [%s] [%d] server_sockefd creat error",__FUNCTION__, __FILE__, __LINE__);  
  72.         return -1;  
  73.     }  
  74.     //set server addr_param  
  75.     struct sockaddr_un server_addr;    
  76.     server_addr.sun_family = AF_UNIX;    
  77.     strncpy(server_addr.sun_path, SERVER_NAME, sizeof(server_addr.sun_path) - 1);  
  78.       
  79.     ret = bind(server_sockfd,(struct sockaddr*)&server_addr,sizeof(server_addr));  
  80.     if (ret == -1) {  
  81.         LOGI("cannot bind server socket");  
  82.         return -1;  
  83.     }  
  84.   
  85.     //listen the server  
  86.     listen(server_sockfd, 5);  
  87.     client_sockfd = -1;  
  88.     memset(&client_addr,0,sizeof(struct sockaddr_un));  
  89.     client_len = sizeof(client_addr);  
  90.     sleep(1);  
  91.       
  92.     FD_SET(server_sockfd, &read_fds);  
  93.     max = server_sockfd;  
  94.     mjson_init();  
  95.     while(1)  
  96.     {  
  97.         LOGI("before select");  
  98.         usleep(100*1000);  
  99.         memset(buffer, 0x0, sizeof(buffer));  
  100.         if ((ret = select(max + 1, &read_fds, NULL, NULL, NULL)) < 0) {  
  101.             LOGI("select failed (%s)", strerror(errno));  
  102.             sleep(1);  
  103.             continue;  
  104.         } else if (!ret)  
  105.             continue;   
  106.         LOGI("ret select-------------");  
  107.   
  108.         if ((client_sockfd = accept(server_sockfd,(struct sockaddr*)&client_addr, &client_len)) < 0)   
  109.         {  
  110.             LOGI("accept failed (%s)", strerror(errno));  
  111.             sleep(1);  
  112.             continue;  
  113.         }  
  114.         LOGI("client_sockfd = %d", client_sockfd);  
  115.         //read  data from client socket  
  116.         nread = read( client_sockfd, ¶m_len, 4);  
  117.         if (nread != 0) {//client disconnected  
  118.             LOGI("client %d receive nothing\n", client_sockfd);  
  119.         }    
  120.         LOGI("param_len = %d", param_len);  
  121.         nread = read( client_sockfd, buffer, param_len);  
  122.         if (nread != 0) {//client disconnected  
  123.             LOGI("client %d receive nothing\n", client_sockfd);  
  124.         }   
  125.         LOGI("nread = %d", nread);  
  126.         LOGI("buffer = %s", buffer);  
  127.         json = buffer;  
  128.   
  129.         if (mjson_parse(&root, (char*) json) != 0)   
  130.         {  
  131.             LOGE("json parse failed11!\n");  
  132.             ret = -1;  
  133.             goto BAIL;  
  134.         }  
  135.   
  136.         if (mjson_try_begin() < 0)   
  137.         {  
  138.             LOGE("invalid !!!\n");  
  139.             ret = -1;  
  140.             goto BAIL;  
  141.         }  
  142.           
  143.         q = root;  
  144.   
  145.         type =(e_root_call_type) mjson_locate_number(q, "call_type");  
  146.         LOGI("call_type = %d", type);  
  147.         if(ROOT_SYSTEM_CALL == type)  
  148.         {  
  149.             char *fuction_name = NULL;  
  150.             fuction_name = mjson_locate_string(q, "fuction_name");  
  151.             LOGI("fuction_name = %s", fuction_name);  
  152.             LOGI("strlen(fuction_name) = %d", strlen(fuction_name));  
  153.             if(strstr(fuction_name, "settimeofday") != NULL)   
  154.             {  
  155.                 struct timeval tms;  
  156.                 tms.tv_sec = mjson_locate_number(q, "tms.tv_sec");  
  157.                 tms.tv_usec = mjson_locate_number(q, "tms.tv_usec");  
  158.   
  159.                 LOGI("tms.tv_sec = %d", tms.tv_sec);  
  160.                 LOGI("tms.tv_usec = %d", tms.tv_usec);  
  161.                 ret = settimeofday(&tms, NULL);  
  162.                 LOGI("ret = %d", ret);  
  163.                   
  164.             }  
  165.         }  
  166.         else if(ROOT_SYSTEM_EXE == type)  
  167.         {  
  168.             int pid    = 0;  
  169.             int param_num = 0;  
  170.             int wait_flag = 0, status = 0;  
  171.             char *exe_name = NULL;  
  172.             char *param_array[MAX_PARAM_NUM];  
  173.             char param_name[64];  
  174.             exe_name = mjson_locate_string(q, "exe_name");  
  175.             param_num = mjson_locate_number(q, "param_num");  
  176.             wait_flag = mjson_locate_number(q, "wait_flag");  
  177.             LOGI( "exe_name= %s, param_num = %d, wait_flag = %d", exe_name, param_num, wait_flag);  
  178.             /*vfork 创建进程*/  
  179.             pid = vfork();  
  180.             if (pid < 0)  
  181.             {  
  182.                 LOGI( "(out)vfork error");  
  183.                 goto BAIL;  
  184.             }  
  185.             if (0 == pid)  
  186.             {  
  187.                 for(i = 0; i < param_num; i++)  
  188.                 {  
  189.                     sprintf(param_name, "param%d", i);  
  190.                     param_array[i] = mjson_locate_string(q, param_name);  
  191.                     LOGI( "param_name= %s, param_array[%d] = %s", param_name, i, param_array[i]);  
  192.                 }  
  193.                 switch(param_num)  
  194.                 {  
  195.                     case 0:  
  196.                         ret = execl(exe_name, exe_name, (char*)0);  
  197.                         break;  
  198.   
  199.                     case 1:  
  200.                         ret = execl(exe_name, exe_name, param_array[0], (char*)0);  
  201.                         break;  
  202.   
  203.                     case 2:  
  204.                         ret = execl(exe_name, exe_name, param_array[0], param_array[1], (char*)0);  
  205.                         break;  
  206.   
  207.                     case 3:  
  208.                         ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], (char*)0);  
  209.                         break;  
  210.   
  211.                     case 4:  
  212.                         ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], param_array[3], (char*)0);  
  213.                         break;  
  214.   
  215.                     case 5:  
  216.                         ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], param_array[3], param_array[4], (char*)0);  
  217.                         break;  
  218.   
  219.                     case 6:  
  220.                         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);  
  221.                         break;  
  222.   
  223.                     case 7:  
  224.                         ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], param_array[3], param_array[4], param_array[5],   
  225.                              param_array[6], (char*)0);  
  226.                         break;  
  227.   
  228.                     case 8:  
  229.                         ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], param_array[3], param_array[4], param_array[5],   
  230.                              param_array[6], param_array[7], (char*)0);  
  231.   
  232.                     case 9:  
  233.                         ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], param_array[3], param_array[4], param_array[5],   
  234.                              param_array[6], param_array[7],param_array[8],(char*)0);  
  235.                         break;  
  236.   
  237.                     case 10:  
  238.                         ret = execl(exe_name, exe_name, param_array[0], param_array[1], param_array[2], param_array[3], param_array[4], param_array[5],   
  239.                              param_array[6], param_array[7], param_array[8], param_array[9], (char*)0);  
  240.                         break;  
  241.                 }  
  242.   
  243.                 if(ret < 0)  
  244.                 {  
  245.                     LOGI( "(out)Err on execl");  
  246.                     _exit(0);  
  247.                 }  
  248.             }  
  249.             else  
  250.             {  
  251.                 if(wait_flag)  
  252.                 {  
  253.                     /*等待进程结束*/  
  254.                     LOGI(  "waitpid pid:%d", pid);  
  255.                     while(waitpid(pid, &status, 0) < 0)  
  256.                     {  
  257.                         LOGI(  "waitpid error pid:%d", pid);  
  258.                         goto BAIL;  
  259.                     }  
  260.                     LOGI( "waitpid out pid:%d", pid);  
  261.   
  262.                 }  
  263.             }         
  264.     }  
  265.     ret = write(client_sockfd, &ret, 4);  
  266.     LOGI("ret = %d", ret);    
  267.       
  268.     BAIL:  
  269.         close(client_sockfd);  
  270.         mjson_try_end();  
  271.           
  272.     }  
  273.     return 0;  
  274.   
  275.   
  276. }  

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

client 一个例子：

[cpp] view plaincopyprint?
  1. define SERVER_NAME "@server_root_permission_socket"  
  2.   
  3. static inline long long current_time_millis(){  
  4.     struct timeval tv[1];  
  5.     gettimeofday(tv, NULL);  
  6.     return((long long)tv->tv_sec) * 1000 + tv->tv_usec/1000;  
  7. }  
  8.   
  9. int do_root_call(char *json)  
  10. {  
  11.     int sockfd;  
  12.     int len = -1;  
  13.     int ret = -1;  
  14.     int result;  
  15.     sockfd = socket(AF_UNIX, SOCK_STREAM, 0);  
  16.     if( -1 == sockfd ){  
  17.         porting_error(PORT_MODULE_BASE,"[%s] [%d] sockfd creat error",__FUNCTION__, __LINE__);  
  18.         return -1;  
  19.     }  
  20.   
  21.     struct sockaddr_un address;    
  22.     address.sun_family = AF_UNIX;    
  23.     strcpy(address.sun_path, SERVER_NAME);   
  24.     ret = connect(sockfd, (struct sockaddr *)&address, sizeof(address));   
  25.     if (ret == -1) {  
  26.         porting_error(PORT_MODULE_BASE,"[%s] [%d] client connect error",__FUNCTION__, __LINE__);  
  27.         return -1;  
  28.     }  
  29.     porting_info(PORT_MODULE_BASE,"sockfd = %d", sockfd);  
  30.     porting_info(PORT_MODULE_BASE,"result = %d", ret);  
  31.     len = strlen(json);  
  32.     ret = write(sockfd, &len, 4);  
  33.     porting_info(PORT_MODULE_BASE,"ret2 = %d", ret);  
  34.     porting_info(PORT_MODULE_BASE,"json = %s", json);  
  35.     ret = write(sockfd, json, strlen(json));  
  36.     porting_info(PORT_MODULE_BASE,"ret3 = %d", ret);  
  37.     read( sockfd, &ret, 4);  
  38.     porting_info(PORT_MODULE_BASE,"ret4 = %d", ret);  
  39.     close(sockfd);  
  40.     sockfd = -1;  
  41.     porting_info(PORT_MODULE_BASE," client ok");  
  42.     return 0;  
  43. }  
sql server 恢复挂起 sql server 恢复挂起
原创粉丝点击
热门IT博客
mac如何添加照片mac如何添加照片
4g网络突然变成2g了4g网络突然变成2g了
python不用科学计数法
java se可以开发web吗
淘宝美工的工资
折装导轮的工具的数据
erwin数据建模 pdf
数据挖掘pdf
淘宝 400
冯提莫 知乎
七天网络怎样查分
php二维数组键值互换
java打印空心三角形
零基础写java知乎爬虫
苹果ios软件开发
淘宝上买论文靠谱吗
动态增加的div 调用js
淘宝企业店铺多少钱
简书稿费一篇多少 知乎
java web有什么框架
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 老兵袁永福遗体告别 告发的意思 告发 篠田夕 中夕 ,夕 告子 孟子 告子 江湖告急 脱单告急 婚情告急 恋情告急 新婚告急 海洋告急 婚姻告急 告急 江湖告急国语 脱单告急在线播放 脱单告急在线 脱单告急高清免费观看 江湖告急结局 江湖告急粤语 婚情告急总裁离婚请签字 江湖告急 国语免费观看 大婚告急片尾曲 大婚告急 插曲 总裁婚情告急商臻 天庭告急 言不二 娘子告急 可望云耶 天价交易总裁婚情告急 1001次拒婚大牌男神的峦爱告急 恶人先告状 告状 恶人告状 哑女告状 司马貌告状 孩子爱告状 鬼告状 气死莫告状 女子告状外卖小哥索赔3万 晋剧哑女告状全集

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里