framework/lynq-sdk-ready/src/timer/lynq_timer.cpp

#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_GET_IMSI 11
#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 fp is null\n", __FUNCTION__);
        return 0;
    }
    if(!strlen(buffer))
    {
        pclose(fp);
        return 0;
    }
    fgets(buffer,sizeof(buffer),fp);
    if(buffer[4] == '4')
    {
        pclose(fp);
        return 1;
    }
    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 fp is null\n", __FUNCTION__);
        return 0;
    }
    while(NULL != fgets(buffer,sizeof(buffer),fp))
    {
        if(strstr(buffer,service))
        {
            pclose(fp);
            printf("check_service 1\n");
            return 1;
        }
    }
    printf("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 res_error = -1;
    lynq_client_t client_t;
    char res_data[MAX_LEN] = {0};
    client_t.request = RIL_REQUEST_GET_IMSI;
    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);
        printf("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);
        printf("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(&request);
            p.readInt32(&slot_id);
            p.readInt32(&res_error);
        }
        /*judge the res_error*/
        if(!res_error)
        {
            system("uci set lynq_uci.sdk_ready='2'");//Md configurations are inconsistent with AP configurations
        }
        else
        {
            system("uci set lynq_uci.sdk_ready='0'");
        }
        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 start_timer_request(void)
{
    pthread_t thid;
    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;
    }
    return;
}