lib/liblynq-sim/src/lynq_sim.cpp

/*============================================================================= 
#     FileName: lynq_sim.cpp
#     Desc: about SIM API
#     Author: mobiletek 
#     Version: V1.0
#     LastChange: 2021-12-29 
#     History: 
=============================================================================*/
#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 "lynq_sim.h"
#include <sys/socket.h>   
#include <netinet/in.h>   
#include <arpa/inet.h>
#define MAX_BUF 20
#define MAX_NUM 80
#define RIL_REQUEST_GET_SIM_STATUS 1
#define RIL_REQUEST_GET_IMSI 11
#define RIL_REQUEST_QUERY_ICCID 2026
#define RIL_REQUEST_SET_FACILITY_LOCK 43
#define RIL_REQUEST_QUERY_FACILITY_LOCK 42
#define RIL_REQUEST_ENTER_SIM_PIN 2
#define RIL_REQUEST_ENTER_SIM_PUK 3
#define RIL_REQUEST_CHANGE_SIM_PIN 6
#define RIL_REQUEST_OEM_HOOK_RAW 59
#define LYNQ_REQUEST_SET_DEFAULT_SIM_ALL 8008
#define MAX_LEN 1024*8
#define MAX_NUM 10
#define LOG_TAG "LYNQ_SIM"
#define FLAG_TESS 0
using ::android::Parcel;
#define DEST_PORT 8088
#define DSET_IP_ADDRESS  "127.0.0.1"

typedef struct{
    int uToken;
    int request;
    int paramLen;
    char param[MAX_LEN];
}lynq_client_t;

lynq_client_t client_t;
/* socket文件描述符 */ 
int len_addr_serv;
struct sockaddr_in addr_serv;
static int sock_fd = 0;
int Global_uToken = 0; 
int resp_type = -1;
int request = -1;
int slot_id = -1;
int error1 = -1;

int lynq_sim_init(int utoken){
    if(utoken < 0){
        return -1;
    }
    // LYLOGSET(LOG_INFO);
    // LYLOGEINIT(USER_LOG_TAG);
    Global_uToken = utoken;
    sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
	if (-1 == sock_fd)
	{
		return sock_fd;
	}
    /* 设置address */  
    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);  
    len_addr_serv = sizeof(addr_serv);  
    /*test*/
    return 0;
}

int lynq_sim_deinit(void){
    close(sock_fd);
    return 0;
}

static char * lynqStrdupReadString(Parcel &p) {
    size_t stringlen;
    const char16_t *s16;

    s16 = p.readString16Inplace(&stringlen);
    return strndup16to8(s16, stringlen);
}

/*If you need to use any API under lynq_sim, you mustfirst call the init_sim() function to initialize these functions.*/
int lynq_get_sim_status(int *card_status)
{   
    int ret = -1;
    if(card_status == NULL)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    int len = 0;
    lynq_client_t client_t1;
    memset(&client_t1, 0, sizeof(client_t1) );
    client_t1.request = RIL_REQUEST_GET_SIM_STATUS;
    client_t1.paramLen = 0;
    client_t1.uToken = Global_uToken;
    char res_data[MAX_LEN] = {0};
    int len1 = sizeof(client_t1.param);
    memset(client_t1.param, 0, sizeof(char)*MAX_LEN);
    send_num = sendto(sock_fd, &client_t1, sizeof(client_t1), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
    if(send_num < 0)  
    {  
        RLOGD("sendto error:");  
        return send_num;
    }
    //get data msg
    recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN, 0, (struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
    if(recv_num < 0 || recv_num == 0)
    {
        RLOGD("recvfrom step2 fail:");
        return recv_num;
    }
    Parcel p;;
    p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&resp_type);
        p.readInt32(&request);
        p.readInt32(&slot_id);
        p.readInt32(&error1);
        p.readInt32(card_status);
    }
    return error1;
}
/*AT> AT+CIMI     AT< IMSI*/
int lynq_get_imsi(char buf[])
{   
    int ret = -1;
    if(buf == NULL)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    int len = 0;
    lynq_client_t client_t1;
    memset(&client_t1, 0, sizeof(client_t1) );
    client_t1.request = RIL_REQUEST_GET_IMSI;
    client_t1.paramLen = 0;
    client_t1.uToken = Global_uToken;
    char res_data[MAX_LEN] = {0};
    memset(client_t1.param, 0, sizeof(client_t1.param));
    send_num = sendto(sock_fd, &client_t1, sizeof(client_t1), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
    if(send_num < 0)  
    {  
        RLOGD("sendto error:");  
        return send_num;
    }
    //get data msg
    recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
    if(recv_num < 0 || recv_num == 0)
    {
        RLOGD("recvfrom step2 fail:");
        return recv_num;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&resp_type);
        p.readInt32(&request);
        p.readInt32(&slot_id);
        p.readInt32(&error1);
        if(!error1){
            char * test = lynqStrdupReadString(p);
            memcpy(buf, test, strlen(test));
        }
    }
    return error1;
}


/*add by lei*/

int lynq_get_iccid(char buf[]){
    int ret = -1;
    if(buf == NULL)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    int len = 0; 
    client_t.request = RIL_REQUEST_QUERY_ICCID;
    client_t.paramLen = 0;
    client_t.uToken = Global_uToken;
    char res_data[MAX_LEN] = {0};
    memset(client_t.param, 0, sizeof(client_t.param));
    send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
    if(send_num < 0)  
    {  
        RLOGD("sendto error:");  
        return send_num;
    }
    //get data msg
    recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
    if(recv_num < 0 || recv_num == 0)
    {
        RLOGD("recvfrom step2 fail:");
        return recv_num;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&resp_type);
        p.readInt32(&request);
        p.readInt32(&slot_id);
        p.readInt32(&error1);
        if(!error1){
            char * test = lynqStrdupReadString(p);
            memcpy(buf, test, strlen(test));
        }
    }
    return error1;
}

int lynq_enable_pin(char *pin){
    int ret = -1;
    if(pin == NULL)
        return ret;
    if(!strlen(pin))
        return ret;
    int send_num = 0;
    int recv_num = 0;  
    char res_data[MAX_LEN] = {0};
    client_t.request = RIL_REQUEST_SET_FACILITY_LOCK;
    client_t.paramLen = 4;
    client_t.uToken = Global_uToken;
    sprintf(client_t.param, "%s %s %s %s\n", "SC", pin, "11", "1");
    send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
    if(send_num < 0)  
    {  
        RLOGD("sendto error:");  
        return send_num;
    }

    //get data msg
    recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
    if(recv_num < 0 || recv_num == 0)
    {
        RLOGD("recvfrom step2 fail:");
        return recv_num;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&resp_type);
        p.readInt32(&request);
        p.readInt32(&slot_id);
        p.readInt32(&error1);
    }
    return error1;
}

int lynq_disable_pin(char *pin){
    int ret = -1;
    if(pin == NULL)
        return ret;
    int send_num = 0;  
    int recv_num = 0;
    char res_data[MAX_LEN] = {0};
    client_t.request = RIL_REQUEST_SET_FACILITY_LOCK;
    client_t.paramLen = 4;
    client_t.uToken = Global_uToken;
    sprintf(client_t.param, "%s %s %s %s\n", "SC", pin, "11", "0");
    send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
    if(send_num < 0)  
    {  
        RLOGD("sendto error:");  
        return send_num;
    }
    //get data msg
    recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
    if(recv_num < 0 || recv_num == 0)
    {
        RLOGD("recvfrom step2 fail:");
        return recv_num;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&resp_type);
        p.readInt32(&request);
        p.readInt32(&slot_id);
        p.readInt32(&error1);
    }
    return error1;
}

int lynq_query_pin_lock(char *pin,int buf[]){
    int ret = -1;
    if(pin == NULL)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    int len = 0; 
    client_t.request = RIL_REQUEST_QUERY_FACILITY_LOCK;
    client_t.paramLen = 3;
    client_t.uToken = Global_uToken;
    char res_data[MAX_LEN] = {0};
    sprintf(client_t.param, "%s %s %s\n", "SC", pin, "11");
    send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
    if(send_num < 0)  
    {  
        RLOGD("sendto error:");  
        return send_num;
    }
    //get data msg
    recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
    if(recv_num < 0 || recv_num == 0)
    {
        RLOGD("recvfrom step2 fail:");
        return recv_num;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
    p.setDataPosition(0);
    int num = -1;
    if(p.dataAvail() > 0)
    {
        p.readInt32(&resp_type);
        p.readInt32(&request);
        p.readInt32(&slot_id);
        p.readInt32(&error1);
        p.readInt32(&num);
        if(num > 0){
            int *test = (int *)calloc(1, sizeof(int)*num);
            for(int i =0; i <num; i++){
                p.readInt32(&test[i]);
                buf[i] = test[i];
            }
            free(test);
        }
    }
    return error1;
}

int lynq_verify_pin(char *pin){
    int ret = -1;
    if(pin == NULL)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    char res_data[MAX_LEN] = {0};
    int len = 0; 
    client_t.request = RIL_REQUEST_ENTER_SIM_PIN;
    client_t.paramLen = 1;
    client_t.uToken = Global_uToken;
    sprintf(client_t.param, "%s\n", pin);
    send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
    if(send_num < 0)  
    {  
        RLOGD("sendto error:");  
        return send_num;
    }
   //get data msg
    recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
    if(recv_num < 0 || recv_num == 0)
    {
        RLOGD("recvfrom step2 fail:");
        return recv_num;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&resp_type);
        p.readInt32(&request);
        p.readInt32(&slot_id);
        p.readInt32(&error1);
    }
    return error1;
}

int lynq_change_pin(char *old_pin, char *new_pin){
    int ret = -1;
    if(old_pin == NULL || new_pin == NULL)
        return ret;
    if(!strlen(new_pin))
        return ret;
    if(!strlen(old_pin))
        return ret;
    int send_num = 0;
    int recv_num = 0;
    char res_data[MAX_LEN] = {0};
    int len = 0; 
    client_t.request = RIL_REQUEST_CHANGE_SIM_PIN;
    client_t.paramLen = 2;
    client_t.uToken = Global_uToken;
    sprintf(client_t.param, "%s %s\n", old_pin, new_pin);
    send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
    if(send_num < 0)  
    {  
        RLOGD("sendto error:");  
        return send_num;
    }
    //get data msg
    recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
    if(recv_num < 0 || recv_num == 0)
    {
        RLOGD("recvfrom step2 fail:");
        return recv_num;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&resp_type);
        p.readInt32(&request);
        p.readInt32(&slot_id);
        p.readInt32(&error1);
    }
    return error1;
}

int lynq_unlock_pin(char *puk, char *pin){
    int ret = -1;
    if(puk == NULL || pin == NULL)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    char res_data[MAX_LEN] = {0};
    int len = 0; 
    client_t.request = RIL_REQUEST_ENTER_SIM_PUK;
    client_t.paramLen = 2;
    client_t.uToken = Global_uToken;
    sprintf(client_t.param, "%s %s\n", puk, pin);
    send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
    if(send_num < 0)  
    {  
        RLOGD("sendto error:");  
        return send_num;
    }
    //get data msg
    recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
    if(recv_num < 0 || recv_num == 0)
    {
        RLOGD("recvfrom step2 fail:");
        return recv_num;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
    p.setDataPosition(0);
    if(p.dataAvail() > 0)
    {
        p.readInt32(&resp_type);
        p.readInt32(&request);
        p.readInt32(&slot_id);
        p.readInt32(&error1);
    }
    return error1;
}

static void delete_char(char str[],char target){
    if(str == NULL){
        return;
    }
    int i,j;
    for(i=j=0;str[i]!='\0';i++){
        if(str[i]!=target){
            str[j++]=str[i];
        }
    }
    str[j]='\0';
} 

static int parse_param(char *cmd, char **argv, char buf[]){
    if(cmd == NULL || argv == NULL || buf == NULL){
        return 0;
    }
    if(strstr(cmd,"ERROR")){
        //char *test = strchr(cmd, ':')+1;
        int len = strlen(cmd);
        memcpy(buf, cmd, len);
        buf[len] = '\0';
        return 3;
    }
    else{
        int argc = 0;
        char *token;
        token = strtok(cmd, ",");
        if(strstr(token, "CNUM")){
            char *string;
            while (token != NULL)
            {  
                string = token;
                argv[argc++] = string;
                token = strtok(NULL, ",");
            }
            int lengh = strlen(argv[1]);
            memcpy(buf, argv[1], lengh);
            buf[lengh] = '\0';
            delete_char(buf, '"');
        }
    }
    return 0;
}

int lynq_query_phone_number(char buf[]){
    int ret = -1;
    if(buf == NULL)
        return ret;
    int send_num = 0;
    int recv_num = 0;
    int len = 0;
    char res_data[MAX_LEN] = {0};
    client_t.request = RIL_REQUEST_OEM_HOOK_RAW;
    client_t.paramLen = 1;
    client_t.uToken = Global_uToken;
    sprintf(client_t.param, "%s\n", "AT+CNUM");
    send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
    if(send_num < 0)  
    {  
        RLOGD("sendto error:");  
        return ret;
    }
     //get data msg
    recv_num = recvfrom(sock_fd,res_data,sizeof(char)*MAX_LEN,0,(struct sockaddr *)&addr_serv,(socklen_t*)&len_addr_serv);
    if(recv_num < 0 || recv_num == 0)
    {
        RLOGD("recvfrom step2 fail:");
        return recv_num;
    }
    Parcel p;
    p.setData((uint8_t *)res_data,sizeof(char)*recv_num); // p.setData((uint8_t *) buffer, buflen);
    p.setDataPosition(0);
    int num = -1;
    if(p.dataAvail() > 0)
    {   
        char test[30] = {0};
        char *argv[5] = {0};
        p.readInt32(&resp_type);
        p.readInt32(&request);
        p.readInt32(&slot_id);
        p.readInt32(&error1);
        p.readInt32(&num);
        if(num == -1){
        }else{
            p.read(test, num);
            parse_param(test, argv, buf);
        }
    }
    return error1;
}

static int judge(int slot){
    switch(slot){
        case 0:
            return -1;
        case 1:
            return -1;
    }
    return 0;
}


int lynq_switch_card(int slot){
    int ret = -1;
    if(!judge(slot))
        return ret;
    int send_num = 0;
    int recv_num = 0;
    char res_data[MAX_LEN] = {0};
    int len = 0; 
    client_t.request = LYNQ_REQUEST_SET_DEFAULT_SIM_ALL;
    client_t.paramLen = 1;
    client_t.uToken = Global_uToken;
    sprintf(client_t.param, "%d\n", slot);
    send_num = sendto(sock_fd, &client_t, sizeof(client_t), 0, (struct sockaddr *)&addr_serv, len_addr_serv);
    if(send_num < 0)  
    {  
        RLOGD("sendto error:");  
        return send_num;
    }
    return 0;
}
#if FLAG_TESS
int lynq_query_operator(char buf[]){
    int32_t token = -1;
    if(buf == NULL)
        return token;
    char msg_imsi[20] = {0};
    memset(msg_imsi,0,sizeof(msg_imsi));
    token = lynq_get_imsi(msg_imsi);
    if(strlen(msg_imsi) != 0){
        FindOperator *ope_command = NULL;
        ope_command = find_ope_command(msg_imsi, findOperator);
        if(ope_command){
            memcpy(buf, ope_command->buf, strlen(ope_command->buf));
            buf[strlen(ope_command->buf)] = '\0';
        }
        else{
            /*more*/
            char mccmnc[5] = {0};
            memcpy(buf, msg_imsi, 5);
            buf[5] = '\0';
            /*more*/
        }
        return token;
    }
    else{
        //msg->base.e = err;
        const char *test = "please insert sim card";
        memcpy(buf, test, strlen(test));
        return token;
    }
}
FindOperator findOperator[] = {
#include "operator.h"
};

static FindOperator*find_ope_command (char *name,FindOperator *Class){
    if(name == NULL || Class == NULL){
        return ((FindOperator *)NULL);
    }
    register int i;
    for (i = 0; Class[i].MCCMCN; i++)
        if (strncmp (name, Class[i].MCCMCN, 5) == 0)
            return (&Class[i]);
    return ((FindOperator *)NULL);
}

#endif