| #include <stdio.h>
|
| #include <sys/types.h>
|
| #include <sys/socket.h>
|
| #include <arpa/inet.h>
|
| #include <string.h>
|
| #include <unistd.h>
|
| #include <binder/Parcel.h>
|
| #include <log/log.h>
|
| #include <cutils/jstring.h>
|
| #include <pthread.h>
|
| #include <sys/socket.h>
|
| #include <netinet/in.h>
|
| #include <arpa/inet.h>
|
| #include <errno.h>
|
| #include "lynq_timer.h"
|
|
|
| #define DEST_PORT 8088
|
| #define DSET_IP_ADDRESS "127.0.0.1"
|
| #define RIL_REQUEST_DEVICE_IDENTITY 98
|
| #define MAX_LEN 1024
|
| #define TIMER 30
|
|
|
| using ::android::Parcel;
|
|
|
| static pthread_mutex_t g_lynq_sim_sendto_mutex;
|
|
|
| typedef struct{
|
| int uToken;
|
| int request;
|
| int paramLen;
|
| char param[MAX_LEN];
|
| }lynq_client_t;
|
|
|
| static int get_md_sta(void)
|
| {
|
| FILE *fp;
|
| char buffer[64]={};
|
| fp = popen("cat /sys/kernel/ccci/boot","r");
|
| if(fp == NULL)
|
| {
|
| RLOGD("function %s fp is null\n", __FUNCTION__);
|
| return 0;
|
| }
|
| fgets(buffer,sizeof(buffer),fp);
|
| if(!strlen(buffer))
|
| {
|
| RLOGD("function %s line %d\n", __FUNCTION__, __LINE__);
|
| pclose(fp);
|
| return 0;
|
| }
|
| if(buffer[4] == '4')
|
| {
|
| pclose(fp);
|
| return 1;
|
| }
|
| RLOGD("function %s line %d\n", __FUNCTION__, __LINE__);
|
| pclose(fp);
|
| return 0;
|
| }
|
|
|
| static int check_service(const char *service)
|
| {
|
| FILE *fp;
|
| char buffer[1024]={};
|
| if(!strcmp(service, "/usr/sbin/mtkfusionrild"))
|
| {
|
| fp = popen("ps -ef|grep rild","r");
|
| }
|
| else if(!strcmp(service, "lynq-ril-service"))
|
| {
|
| fp = popen("ps -ef|grep ril-service","r");
|
| }
|
| if(fp == NULL)
|
| {
|
| RLOGD("function %s fp is null\n", __FUNCTION__);
|
| return 0;
|
| }
|
| while(NULL != fgets(buffer,sizeof(buffer),fp))
|
| {
|
| if(strstr(buffer,service))
|
| {
|
| pclose(fp);
|
| RLOGD("check_service 1\n");
|
| return 1;
|
| }
|
| }
|
| RLOGD("check_service 0\n");
|
| pclose(fp);
|
| return 0;
|
| }
|
|
|
| /**
|
| * @brief 30s request imei
|
| *
|
| * @param arg
|
| * @return void*
|
| */
|
| void * timer_request_imei(void * arg)
|
| {
|
| int sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
|
| if (-1 == sock_fd)
|
| {
|
| RLOGD("__FUNCTION__ %s create sock_fd failed %s\n", __FUNCTION__, strerror(errno));
|
| /*set uci*/
|
| /*socket abnormal*/
|
| system("uci set lynq_uci.sdk_ready='3'");
|
| /*set uci*/
|
| return NULL;
|
| }
|
| struct timeval timeOut;
|
| timeOut.tv_sec = 3;//timeout time 3s
|
| timeOut.tv_usec = 0;
|
| if (setsockopt(sock_fd, SOL_SOCKET, SO_RCVTIMEO, &timeOut, sizeof(timeOut)) < 0)
|
| {
|
| RLOGD("__FUNCTION__ %s time out setting failed %s\n", __FUNCTION__, strerror(errno));
|
| /*set uci*/
|
| /*socket abnormal*/
|
| system("uci set lynq_uci.sdk_ready='3'");
|
| /*set uci*/
|
| return NULL;
|
| }
|
| struct sockaddr_in addr_serv;
|
| memset(&addr_serv, 0, sizeof(addr_serv));
|
| addr_serv.sin_family = AF_INET;
|
| addr_serv.sin_addr.s_addr = inet_addr(DSET_IP_ADDRESS);
|
| addr_serv.sin_port = htons(DEST_PORT);
|
| int len_addr_serv = sizeof(addr_serv);
|
| int send_num = -1;
|
| int recv_num = -1;
|
| int resp_type = -1;
|
| int request = -1;
|
| int slot_id = -1;
|
| int token = -1;
|
| int res_error = -1;
|
| lynq_client_t client_t;
|
| char res_data[MAX_LEN] = {0};
|
| client_t.request = RIL_REQUEST_DEVICE_IDENTITY;
|
| client_t.paramLen = 0;
|
| client_t.uToken = 999;
|
| memset(client_t.param, 0, sizeof(client_t.param));
|
| while (1)
|
| {
|
| bzero(res_data, MAX_LEN);
|
| pthread_mutex_lock(&g_lynq_sim_sendto_mutex);
|
| send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
|
| RLOGD("send_num %d\n", send_num);
|
| if(send_num == 0)
|
| {
|
| RLOGD("__FUNCTION__ %s Close to end %s\n", __FUNCTION__, strerror(errno));
|
| //unknow
|
| system("uci set lynq_uci.sdk_ready='4'");
|
| pthread_mutex_unlock(&g_lynq_sim_sendto_mutex);
|
| continue;
|
| }
|
| if(send_num < 0)
|
| {
|
| RLOGD("__FUNCTION__ %s sendto error %s\n", __FUNCTION__, strerror(errno));
|
| //unknow
|
| system("uci set lynq_uci.sdk_ready='4'");
|
| pthread_mutex_unlock(&g_lynq_sim_sendto_mutex);
|
| continue;
|
| }
|
| //get data msg
|
| recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
|
| RLOGD("recv_num %d\n", recv_num);
|
| if(recv_num == 0)
|
| {
|
| RLOGD("__FUNCTION__ %s Close to end\n", __FUNCTION__);
|
| //unknow
|
| system("uci set lynq_uci.sdk_ready='4'");
|
| pthread_mutex_unlock(&g_lynq_sim_sendto_mutex);
|
| continue;;
|
| }
|
| if(recv_num == -1 && errno == EAGAIN)
|
| {
|
| RLOGD("__FUNCTION__ %srecvfrom fail because timeout\n", __FUNCTION__);
|
| /*set uci*/
|
| if(!get_md_sta())
|
| {
|
| system("uci set lynq_uci.sdk_ready='1'");
|
| }
|
| else
|
| {
|
| if(check_service("/usr/sbin/mtkfusionrild"))//rild work
|
| {
|
| if(!check_service("lynq-ril-service"))//not find,must be socket error
|
| {
|
| system("uci set lynq_uci.sdk_ready='3'");
|
| }
|
| else
|
| {
|
| //unknow error
|
| system("uci set lynq_uci.sdk_ready='4'");
|
| }
|
|
|
| }
|
| else//rild no work
|
| {
|
| //unknow
|
| system("uci set lynq_uci.sdk_ready='4'");
|
| }
|
| }
|
| pthread_mutex_unlock(&g_lynq_sim_sendto_mutex);
|
| continue;;
|
| }
|
| if(recv_num < 0)
|
| {
|
| RLOGD("__FUNCTION__ %srecvfrom fail %s\n", __FUNCTION__, strerror(errno));
|
| //unknow
|
| system("uci set lynq_uci.sdk_ready='4'");
|
| pthread_mutex_unlock(&g_lynq_sim_sendto_mutex);
|
| continue;;
|
| }
|
| Parcel p;
|
| p.setData((uint8_t *)res_data,sizeof(char)*recv_num);
|
| p.setDataPosition(0);
|
| if(p.dataAvail() > 0)
|
| {
|
| p.readInt32(&resp_type);
|
| p.readInt32(&token);
|
| p.readInt32(&request);
|
| p.readInt32(&slot_id);
|
| p.readInt32(&res_error);
|
| }
|
| /*judge the res_error*/
|
| if(!res_error)
|
| {
|
| system("uci set lynq_uci.sdk_ready='0'");
|
| }
|
| else
|
| {
|
| system("uci set lynq_uci.sdk_ready='2'"); //Md configurations are inconsistent with AP configurations
|
| }
|
| RLOGD("__FUNCTION__ %s res_error %d\n", __FUNCTION__, res_error);
|
| /*judge the res_error*/
|
| pthread_mutex_unlock(&g_lynq_sim_sendto_mutex);
|
| sleep(TIMER);
|
| }
|
| return NULL;
|
| }
|
|
|
|
|
| void delete_enter(char data[]) |
| { |
| char *find = strchr(data, '\n'); |
| if(find) |
| *find = '\0'; |
| return ; |
| }
|
|
|
|
|
| void *check(void * arg)
|
| {
|
|
|
| char pid[200][8];
|
| char ffd[200][4]; |
| char buf[64];
|
| char check_time[4];
|
| char timebuf[32];
|
| int num=0;
|
| int i=0; |
| int j;
|
| FILE *fp,*fp_1;
|
| int ret;
|
|
|
| RLOGD("check cpu/pid/interrupts/fd!!!\n");
|
| system("touch /media/check_time");
|
| fp_1 = popen("cat /media/check_time","r");
|
| if(fgets(check_time, 4, fp_1) != NULL)
|
| {
|
| num = atoi(check_time);
|
| }
|
| pclose(fp_1);
|
| while(1)
|
| {
|
| i = 0;
|
| system("date >>/media/check_file/cpu_moniter.txt");
|
| ret = system("top -b |head -n 25 >>/media/check_file/cpu_moniter.txt");
|
| RLOGD("cpu ret %d", ret);
|
| system("date >>/media/check_file/inter_moniter.txt");
|
| ret = system("cat /proc/interrupts >>/media/check_file/inter_moniter.txt");
|
| RLOGD("interrupts ret %d", ret);
|
| system("date >>/media/check_file/pid_moniter.txt");
|
| ret = system("ps -eo \"%p %a\" | grep -v \"\\[\" >>/media/check_file/pid_moniter.txt");
|
| RLOGD("pid ret %d", ret);
|
| system("date >>/media/check_file/fd_moniter.txt");
|
|
|
| fp = popen("ps -eo \"%p %a\" | grep -v \"\\[\"|awk '{print $1}'","r");
|
| while(fgets(pid[i], 8, fp) != NULL)
|
| {
|
| delete_enter(pid[i]);
|
| i++;
|
| }
|
| pclose(fp);
|
|
|
| for(j=1;j<i;j++)
|
| {
|
| sprintf(buf, "ls /proc/%s/fd | wc -l", pid[j]);
|
| fp = popen(buf, "r");
|
| fgets(ffd[j], 4, fp);
|
| sprintf(buf,"echo \"pid: %s, fd_num: %s\" >>/media/check_file/fd_moniter.txt",pid[j], ffd[j]);
|
| system(buf);
|
| pclose(fp);
|
| }
|
| num++;
|
| sprintf(timebuf, "echo \"%d\" >/media/check_time", num);
|
| ret = system(timebuf);
|
| if(num > 120)
|
| {
|
| system("rm -rf /media/check_file");
|
| }
|
| sleep(300);
|
|
|
| }
|
|
|
|
|
|
|
| }
|
|
|
| void start_timer_request(void)
|
| {
|
| pthread_t thid,thid_1;
|
| pthread_attr_t a;
|
| pthread_attr_init(&a);
|
| pthread_attr_setdetachstate(&a, PTHREAD_CREATE_DETACHED);
|
|
|
| int ret = pthread_create(&thid, &a, timer_request_imei, NULL);
|
| if(ret != 0){
|
| RLOGD("pthread_create error!!!");
|
| return;
|
| }
|
| sleep(20);
|
| ret = pthread_create(&thid_1, NULL, check, NULL);
|
| if(ret != 0){
|
| RLOGD("pthread_create error!!!");
|
| return;
|
| }
|
| return;
|
| }
|
|
|