Squashed 'LYNQ_PUBLIC/' content from commit 79d8f932f
git-subtree-dir: LYNQ_PUBLIC
git-subtree-split: 79d8f932fb4ebc4b5aec6c5ace97634912394272
Change-Id: If2527ba937f56fe989487bf71e996f7cfd9fbe61
diff --git a/common_src/lib/liblynq-data/LICENSE b/common_src/lib/liblynq-data/LICENSE
new file mode 100755
index 0000000..77f59ed
--- /dev/null
+++ b/common_src/lib/liblynq-data/LICENSE
@@ -0,0 +1,31 @@
+Copyright Statement:
+
+This software/firmware and related documentation ("MediaTek Software") are
+protected under relevant copyright laws. The information contained herein is
+confidential and proprietary to MediaTek Inc. and/or its licensors. Without
+the prior written permission of MediaTek inc. and/or its licensors, any
+reproduction, modification, use or disclosure of MediaTek Software, and
+information contained herein, in whole or in part, shall be strictly
+prohibited.
+
+MediaTek Inc. (C) 2015. All rights reserved.
+
+BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
+THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
+RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
+ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
+WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
+NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
+RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
+INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
+TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
+RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
+OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
+SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
+RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
+STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S
+ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
+RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE
+MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
+CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
diff --git a/common_src/lib/liblynq-data/include/libdata/lynq_data.h b/common_src/lib/liblynq-data/include/libdata/lynq_data.h
new file mode 100755
index 0000000..3f065f0
--- /dev/null
+++ b/common_src/lib/liblynq-data/include/libdata/lynq_data.h
@@ -0,0 +1,74 @@
+#ifndef LYNQ_DATA_H
+#define LYNQ_DATA_H 1
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define LYNQ_APN_CHANNEL_MAX 10
+#define LYNQ_PDP_TYPE_MAX_LEN 16
+#define LYNQ_IFACE_NAME_MAX_LEN 50
+#define LYNQ_APN_MAX_LEN 50
+#define LYNQ_APN_TYPE_MAX_LEN 50
+#define LYNQ_PDP_ADDR_MAX_LEN 64
+#define LYNQ_DNS_ADDR_MAX_LEN 256
+#define LYNQ_GETWAYS_ADDR_MAX_LEN 64
+#define LYNQ_POXY_ADDR_MAX_LEN 64
+
+typedef struct {
+ int status; /* A RIL_DataCallFailCause, 0 which is PDP_FAIL_NONE if no error */
+ int suggestedRetryTime; /* If status != 0, this fields indicates the suggested retry
+ back-off timer value RIL wants to override the one
+ pre-configured in FW.
+ The unit is miliseconds.
+ The value < 0 means no value is suggested.
+ The value 0 means retry should be done ASAP.
+ The value of INT_MAX(0x7fffffff) means no retry. */
+ int cid; /* Context ID, uniquely identifies this call */
+ int active; /* 0=inactive, 1=active/physical link down, 2=active/physical link up */
+ char type[LYNQ_PDP_TYPE_MAX_LEN]; /* One of the PDP_type values in TS 27.007 section 10.1.1.
+ For example, "IP", "IPV6", "IPV4V6", or "PPP". If status is
+ PDP_FAIL_ONLY_SINGLE_BEARER_ALLOWED this is the type supported
+ such as "IP" or "IPV6" */
+ char ifname[LYNQ_IFACE_NAME_MAX_LEN]; /* The network interface name */
+ char addresses[LYNQ_PDP_ADDR_MAX_LEN]; /* A space-delimited list of addresses with optional "/" prefix length,
+ e.g., "192.0.1.3" or "192.0.1.11/16 2001:db8::1/64".
+ May not be empty, typically 1 IPv4 or 1 IPv6 or
+ one of each. If the prefix length is absent the addresses
+ are assumed to be point to point with IPv4 having a prefix
+ length of 32 and IPv6 128. */
+ char dnses[LYNQ_DNS_ADDR_MAX_LEN]; /* A space-delimited list of DNS server addresses,
+ e.g., "192.0.1.3" or "192.0.1.11 2001:db8::1".
+ May be empty. */
+ char gateways[LYNQ_GETWAYS_ADDR_MAX_LEN]; /* A space-delimited list of default gateway addresses,
+ e.g., "192.0.1.3" or "192.0.1.11 2001:db8::1".
+ May be empty in which case the addresses represent point
+ to point connections. */
+ char pcscf[LYNQ_POXY_ADDR_MAX_LEN]; /* the Proxy Call State Control Function address
+ via PCO(Protocol Configuration Option) for IMS client. */
+ int mtu; /* MTU received from network
+ Value <= 0 means network has either not sent a value or
+ sent an invalid value */
+} lynq_data_call_response_v11_t;
+typedef struct
+{
+ int handle;
+ char apn[LYNQ_APN_MAX_LEN];
+ char apnType[LYNQ_APN_TYPE_MAX_LEN];
+}lynq_apn_msg_t;
+
+int lynq_init_data(int uToken);
+int lynq_deinit_data();
+int lynq_setup_data_call(int *handle);
+int lynq_deactive_data_call(int *handle);
+int lynq_setup_data_call_sp(int *handle,char *apn,char *apnType,char *user,char *password,char *authType,char *normalProtocol,char *roamingProtocol);
+//int lynq_deactive_data_call_sp(int *handle,char *apnType);
+int lynq_get_data_call_list(int *handle,lynq_data_call_response_v11_t *dataCallList);
+int lynq_wait_data_call_state_change(int *handle);
+int lynq_modify_apn_db(const int cmd,char *id,char *mcc,char *mnc,char *apn,char *apntype,char *user,char *password,char *normalprotocol,char *roamingprotocol,char *carrier,char *out);
+int lynq_reset_apn(char *result);
+int lynq_get_apn_msg(int handle,lynq_apn_msg_t *apn_msg);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/common_src/lib/liblynq-data/lynq_data.cpp b/common_src/lib/liblynq-data/lynq_data.cpp
new file mode 100755
index 0000000..b8865ef
--- /dev/null
+++ b/common_src/lib/liblynq-data/lynq_data.cpp
@@ -0,0 +1,2064 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <binder/Parcel.h>
+#include <log/log.h>
+#include "lynq_data.h"
+#include <cutils/jstring.h>
+#include <pthread.h>
+#include "liblog/lynq_deflog.h"
+#include <sys/time.h>
+#include <include/lynq_uci.h>
+#include <errno.h>
+#include <vector>
+#include "lynq_data_urc.h"
+
+#define LYNQ_SERVICE_PORT 8088
+#define LYNQ_RIL_FWK_IP "127.0.0.1"
+
+#define LYNQ_REC_BUF 8192
+#define LYNQ_REQUEST_PARAM_BUF 8192
+#define LYQN_SEDN_BUF 1024*8+sizeof(int)*3
+#define USER_LOG_TAG "LYNQ_DATA"
+
+#define LYNQ_DATA_UCI_BUF 258
+#define LYNQ_DATA_TIME_OUT 1000*120
+#define TELEPHONY_RESTART 10
+
+
+using ::android::Parcel;
+typedef struct{
+ int uToken;
+ int request;
+ int paramLen;
+ char param[LYNQ_REQUEST_PARAM_BUF];
+}lynq_client_t;
+typedef enum{
+ LYNQ_E_CARDSTATE_ERROR=8000,
+ /* The voice service state is out of service*/
+ LYNQ_E_STATE_OUT_OF_SERVICE=8001,
+ /* The voice service state is EMERGENCY_ONLY*/
+ LYNQ_E_STATE_EMERGENCY_ONLY=8002,
+ /* The radio power is power off*/
+ LYNQ_E_STATE_POWER_OFF=8003,
+ LYNQ_E_TIME_OUT=8004,
+ /*create or open sms DB fail */
+ LYNQ_E_SMS_DB_FAIL=8005,
+ /*Failed to execute sql statement*/
+ LYNQ_E_SMS_SQL_FAIL = 8006,
+ LYNQ_E_SMS_NOT_FIND = 8007,
+ LYNQ_E_GET_RESP_FAIL = 8008,
+ LYNQ_E_NOT_THIS_APN = 8087,
+ LYNQ_E_NOT_ANY_APN = 8088,
+ LYNQ_E_MD_NOT_READY = 8089,
+ /* The logic conflict*/
+ LYNQ_E_CONFLICT=9000,
+ /*Null anomaly*/
+ LYNQ_E_NULL_ANONALY=9001
+}LYNQ_E;
+
+typedef enum {
+ PDN_IDLE,
+ PDN_CONNECTING,
+ PDN_CONNECTED,
+ PDN_DISCONNECTING,
+ PDN_DISCONNECTED,
+ PDN_RETRYING,
+ PDN_FAILED,
+ PDN_SCANNING,
+ PDN_TIMEOUT_CANCEL,
+} RIL_Data_Call_PdnState;
+
+int lynq_client_sockfd = 0;
+int Global_uToken = 0;
+struct sockaddr_in lynq_data_socket_server_addr;
+int lynq_data_socket_server_addr_len;
+
+int lynq_data_call_change_id = -1;
+int lynq_telephony_restart_g = 0;
+pthread_t lynq_data_tid =-1;
+static pthread_mutex_t s_data_call_state_change_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_data_call_state_change_cond = PTHREAD_COND_INITIALIZER;
+
+static pthread_mutex_t s_data_call_deactived_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_data_call_deactived_cond = PTHREAD_COND_INITIALIZER;
+
+
+static pthread_mutex_t s_lynq_apn_change_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_lynq_apn_change_cond = PTHREAD_COND_INITIALIZER;
+static pthread_mutex_t s_lynq_urc_vector_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_lynq_urc_vector_cond = PTHREAD_COND_INITIALIZER;
+/**g_lynq_data_sendto_mutex
+* @brief mark data send request mutex
+*/
+static pthread_mutex_t g_lynq_data_sendto_mutex;
+/*This value data the state of the wait*/
+static int data_waiting_status = 0;
+/*The value indicates that 8085 error occurs in data*/
+static int data_invaild_error = 0;
+/*This value ensure the data call timing is correct*/
+static int data_timelimit = 0;
+
+/**g_lynq_data_init_flag
+* @brief mark data initialization state
+* 0:deinit status
+* 1:init state
+*/
+static int g_lynq_data_init_flag = 0;
+/**g_lynq_apn_result
+* @brief temp of apn result info
+*/
+char g_lynq_apn_result[1024] = {};
+int g_data_call_timeout_value = LYNQ_DATA_TIME_OUT;
+
+static std::vector<int> s_data_urc_wait_list;
+
+typedef struct
+{
+ char apn[LYNQ_APN_MAX_LEN];
+ char apnType[LYNQ_APN_TYPE_MAX_LEN];
+ char ifaceName[LYNQ_IFACE_NAME_MAX_LEN];
+ int hasUsed;
+ int hasTimeout;
+ int status;
+ char statusApnType[LYNQ_APN_TYPE_MAX_LEN];
+}lynq_apn_t;
+lynq_apn_t lynq_apn_table[LYNQ_APN_CHANNEL_MAX] = {};
+lynq_data_call_response_v11_t lynq_data_call_lists[LYNQ_APN_CHANNEL_MAX] = {};
+int lynq_data_call = 0;
+
+int radio_switch(int status);
+
+int getLynqApnID(char apnType[])
+{
+ int ret = 0;
+ int len = 0;
+ for(ret;ret<LYNQ_APN_CHANNEL_MAX;ret++)
+ {
+ len = strlen(apnType);
+ LYINFLOG("apn_table[%d].apnType:%s,input apntype:%s,len:%d",ret,lynq_apn_table[ret].apnType,apnType,len);
+ if(strncmp(lynq_apn_table[ret].apnType,apnType,len)==0)
+ {
+ return ret;
+ }
+ }
+ return -1;
+}
+
+int getDeactApnID(char apnType[])
+{
+ int ret = 0;
+ int len = 0;
+ for(ret;ret<LYNQ_APN_CHANNEL_MAX;ret++)
+ {
+ len = strlen(apnType);
+ LYINFLOG("apn_table[%d].apnType:%s,input apntype:%s,len:%d",ret,lynq_apn_table[ret].apnType,apnType,len);
+ if(strncmp(lynq_apn_table[ret].statusApnType,apnType,len)==0)
+ {
+ return ret;
+ }
+ }
+ return -1;
+}
+
+void updateApnTable(lynq_apn_t *apn_table,char apn[],char apntype[],char ifaceName[])
+{
+ LYDBGLOG("[updateApnTable] apn:%s,apntype:%s,ifaceName:%s",apn,apntype,ifaceName);
+ if(apn_table==NULL)
+ {
+ LYERRLOG("apn_table is null");
+ return;
+ }
+ memcpy(apn_table->apn,apn,strlen(apn)+1);
+ memcpy(apn_table->apnType,apntype,strlen(apntype)+1);
+ memcpy(apn_table->ifaceName,ifaceName,strlen(ifaceName)+1);
+ apn_table->hasTimeout = 0;
+ apn_table->hasUsed = 1;
+ return;
+}
+
+void cleanOnceApnTable(int apnId)
+{
+ LYDBGLOG("%s:apn id:%d",__FUNCTION__,apnId);
+ if((apnId < 0) || (apnId > LYNQ_APN_CHANNEL_MAX-1))
+ {
+ LYERRLOG("apn id is invalid!!!");
+ return;
+ }
+ lynq_apn_table[apnId].hasTimeout = 0;
+ lynq_apn_table[apnId].hasUsed = 0;
+ memcpy(lynq_apn_table[apnId].statusApnType,lynq_apn_table[apnId].apnType,strlen(lynq_apn_table[apnId].apnType));
+ bzero(lynq_apn_table[apnId].apn,LYNQ_APN_MAX_LEN);
+ bzero(lynq_apn_table[apnId].apnType,LYNQ_APN_TYPE_MAX_LEN);
+ bzero(lynq_apn_table[apnId].ifaceName,LYNQ_IFACE_NAME_MAX_LEN);
+ lynq_apn_table[apnId].status = 32;
+ return;
+}
+void cleanDeactApn(int apnId)
+{
+ LYDBGLOG("%s:apn id:%d",__FUNCTION__,apnId);
+ if((apnId < 0) || (apnId > LYNQ_APN_CHANNEL_MAX-1))
+ {
+ LYERRLOG("apn id is invalid!!!");
+ return;
+ }
+ lynq_apn_table[apnId].status = 0;
+ bzero(lynq_apn_table[apnId].statusApnType,LYNQ_APN_TYPE_MAX_LEN);
+}
+
+void updateDeactApn(int apnId,int pdnState)
+{
+ LYDBGLOG("%s:apn id:%d",__FUNCTION__,apnId);
+ if((apnId < 0) || (apnId > LYNQ_APN_CHANNEL_MAX-1))
+ {
+ LYERRLOG("apn id is invalid!!!");
+ return;
+ }
+ lynq_apn_table[apnId].status = pdnState;
+}
+
+
+int getUnusedElement()
+{
+ if (lynq_apn_table == NULL)
+ {
+ LYERRLOG("get UnusedElemnt apn_table is null");
+ return -1;
+ }
+ for(int i=0;i < LYNQ_APN_CHANNEL_MAX; i++)
+ {
+ if(lynq_apn_table[i].hasUsed!=1)
+ {
+ return i;
+ }
+ }
+ LYERRLOG("None of get unused Element");
+ return -1;
+}
+int updateApn(char apnType[])
+{
+ int ret = 0;
+ ret = getUnusedElement();
+ if(ret >= 0)
+ {
+ memcpy(lynq_apn_table[ret].apnType,apnType,strlen(apnType)+1);
+ lynq_apn_table[ret].hasUsed = 1;
+ }
+ return ret;
+}
+//@return
+//other:this apn has been used in apn table
+//-1:this apn not has been used in apn table
+int check_used_apn(char apnType[])
+{
+ LYINFLOG("check_used_apn.apnType:%s",apnType);
+ int ret = 0;
+ int len = 0;
+ for(ret;ret<LYNQ_APN_CHANNEL_MAX;ret++)
+ {
+ len = strlen(apnType);
+ if(strncmp(lynq_apn_table[ret].apnType,apnType,len)==0)
+ {
+ LYINFLOG("check_used_apn.apnType:%s in apn table",apnType);
+ return ret;
+ }
+ }
+ return -1;
+}
+int get_handle(char apnType[])
+{
+ int call_id = 0;
+ call_id = check_used_apn(apnType);
+ if(call_id == -1)
+ {
+ call_id = updateApn(apnType);
+ }
+ LYINFLOG("handle:%d",call_id);
+ return call_id;
+}
+
+int handleCheck(int handle)
+{
+ if ((handle >= 0) && (handle <= 6))
+ {
+ if (lynq_apn_table[handle].hasUsed == 1)
+ {
+ return 0;
+ }
+ return -1;
+ }
+ return -1;
+}
+int waitApnResult()
+{
+ int ret = 0;
+ LYINFLOG("start wait apn result!!!");
+ int sec = 0;
+ int usec = 0;
+ struct timeval now;
+ struct timespec timeout;
+ gettimeofday(&now, NULL);
+ sec = 20000 / 1000;
+ usec = 20000 % 1000;
+ timeout.tv_sec = now.tv_sec + sec;
+ timeout.tv_nsec = now.tv_usec * 1000 + usec * 1000000;
+ pthread_mutex_lock(&s_lynq_apn_change_mutex);
+ ret = pthread_cond_timedwait(&s_lynq_apn_change_cond, &s_lynq_apn_change_mutex, &timeout);
+ pthread_mutex_unlock(&s_lynq_apn_change_mutex);
+ return ret;
+}
+
+void sendSignalApnChange()
+{
+ LYINFLOG("start send Signal Apn Change");
+ pthread_mutex_lock(&s_lynq_apn_change_mutex);
+ pthread_cond_signal(&s_lynq_apn_change_cond);
+ pthread_mutex_unlock(&s_lynq_apn_change_mutex);
+ return;
+}
+
+int waitPdnChange()
+{
+ int ret = 0;
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ ret = pthread_cond_wait(&s_lynq_urc_vector_cond,&s_lynq_urc_vector_mutex);
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+ return ret;
+}
+int waitDataCallstateChange(int mtime)
+{
+ int ret = 0;
+ int sec = 0;
+ int usec = 0;
+ struct timeval now;
+ struct timespec timeout;
+ gettimeofday(&now,NULL);
+ sec = mtime/1000;
+ usec = mtime%1000;
+ timeout.tv_sec = now.tv_sec+sec;
+ timeout.tv_nsec = now.tv_usec*1000+usec*1000000;
+ pthread_mutex_lock(&s_data_call_state_change_mutex);
+ ret = pthread_cond_timedwait(&s_data_call_state_change_cond,&s_data_call_state_change_mutex,&timeout);
+ pthread_mutex_unlock(&s_data_call_state_change_mutex);
+ return ret;
+}
+void sendSignalDataCallStateChange()
+{
+ pthread_mutex_lock(&s_data_call_state_change_mutex);
+ pthread_cond_signal(&s_data_call_state_change_cond);
+ pthread_mutex_unlock(&s_data_call_state_change_mutex);
+ return;
+}
+int waitDeactived(int mtime)
+{
+ int ret = 0;
+ int sec = 0;
+ int usec = 0;
+ struct timeval now;
+ struct timespec timeout;
+ gettimeofday(&now,NULL);
+ sec = mtime/1000;
+ usec = mtime%1000;
+ timeout.tv_sec = now.tv_sec+sec;
+ timeout.tv_nsec = now.tv_usec*1000+usec*1000000;
+ pthread_mutex_lock(&s_data_call_deactived_mutex);
+ ret = pthread_cond_timedwait(&s_data_call_deactived_cond,&s_data_call_deactived_mutex,&timeout);
+ pthread_mutex_unlock(&s_data_call_deactived_mutex);
+ return ret;
+}
+void sendSignalDeactvied()
+{
+ pthread_mutex_lock(&s_data_call_deactived_mutex);
+ pthread_cond_signal(&s_data_call_deactived_cond);
+ pthread_mutex_unlock(&s_data_call_deactived_mutex);
+ return;
+}
+
+void sendSignalPdnChange()
+{
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ pthread_cond_signal(&s_lynq_urc_vector_cond);
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+ return;
+}
+
+int get_response(int sockfd,Parcel &p)
+{
+ int len = 0;
+ char recvline[LYNQ_REC_BUF];
+ bzero(recvline,LYNQ_REC_BUF);
+ /* receive data from server */
+ len = recvfrom(sockfd,recvline,LYNQ_REC_BUF,0,(struct sockaddr *)&lynq_data_socket_server_addr,(socklen_t *)&lynq_data_socket_server_addr_len);
+ //len = read(sockfd, recvline, LYNQ_REC_BUF);
+ if(len == -1)
+ {
+ LYERRLOG("get_response fail,errno:%d",errno);
+ return -1;
+ }
+ if (recvline != NULL) {
+ p.setData((uint8_t *)recvline,len); // p.setData((uint8_t *) buffer, buflen);
+ p.setDataPosition(0);
+ }
+ return 0;
+}
+/**@brief get utoken in range 0 to 10000
+* @return utoken
+*/
+int get_utoken()
+{
+ return (Global_uToken++)%10000;/*0-10000*/
+}
+/**@brief wait response with expected token and write msg to parcel in some time
+* @param fd [IN]: socket fd
+* @param p [OUT]: quote the parcel,if return success need delete p.
+* @param token [IN]: the expected token for the response msg
+* @return
+* 0:success
+* other:failure
+*/
+int wait_response(int sockfd,Parcel *& p,int utoken)
+{
+ int len = 0;
+ int flag = 1;
+ int count = 0;
+ int in_utoken = -1;
+ int resp_type = -1;
+ Parcel *temp = NULL;
+ char recvline[LYNQ_REC_BUF];
+ //Sometimes the socket is abnormal, causing the socket buffer to store the response of the last request.
+ //Here it does not return until the response corresponding to the request is read.
+ while(flag && (count < 20))//why?
+ {
+ bzero(recvline,LYNQ_REC_BUF);
+ count++;
+ LYINFLOG("wait_response,count:%d",count);
+ len = recvfrom(sockfd,recvline,LYNQ_REC_BUF,0,(struct sockaddr *)&lynq_data_socket_server_addr,(socklen_t *)&lynq_data_socket_server_addr_len);
+ if(len == -1)
+ {
+ LYERRLOG("wait_response fail,errno:%d",errno);
+ return LYNQ_E_GET_RESP_FAIL;
+ }
+ if (len != 0)
+ {
+ temp = new Parcel;
+ int i = 0;
+ while((NULL == temp) && (i < 100))
+ {
+ usleep(1000);
+ temp = new Parcel;
+ i++;
+ }
+ if((i >= 100) || (NULL == temp))
+ {
+ LYERRLOG("wait_response i:%d",i);
+ return LYNQ_E_GET_RESP_FAIL;
+ }
+ temp->setData((uint8_t *)recvline,len); // p.setData((uint8_t *) buffer, buflen);
+ temp->setDataPosition(0);
+ temp->readInt32(&resp_type);
+ temp->readInt32(&in_utoken);
+ LYINFLOG("[%s]in_utoken:%d,utoken:%d",__FUNCTION__,in_utoken,utoken);
+ if (in_utoken != utoken)
+ {
+ delete temp;
+ temp = NULL;
+ in_utoken = 0;
+ continue;
+ }
+ temp->setDataPosition(0);
+ p = temp;
+ flag = 0;
+ return 0;
+ }
+ else
+ {
+ LYERRLOG("recvline is null,errno:%d",errno);
+ return LYNQ_E_GET_RESP_FAIL;
+ }
+ }
+ return LYNQ_E_GET_RESP_FAIL;
+}
+
+int JumpHeader(Parcel *p,int *resp_type,int *utoken,int *request,int *slot_id,int *error)
+{
+ if(NULL == p)
+ {
+ LYERRLOG("JumpHeader is null");
+ return -1;
+ }
+ if(p->dataAvail() > 0)
+ {
+ p->readInt32(resp_type);
+ p->readInt32(utoken);
+ p->readInt32(request);
+ p->readInt32(slot_id);
+ p->readInt32(error);
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+void free_parcel(Parcel *p)
+{
+ if(p)
+ {
+ delete p;
+ p = NULL;
+ }
+}
+int send_request(int sockfd,lynq_client_t *client_tmp)
+{
+ int ret=0;
+ ret = sendto(sockfd,client_tmp,LYQN_SEDN_BUF,0,(struct sockaddr *)&lynq_data_socket_server_addr,lynq_data_socket_server_addr_len);
+ if(ret==-1)
+ {
+ LYERRLOG("%s:errno code:%d",__FUNCTION__,errno);
+ return -1;
+ }
+ return 0;
+}
+static char *strdupReadString(Parcel &p) {
+ size_t stringlen;
+ const char16_t *s16;
+ s16 = p.readString16Inplace(&stringlen);
+ return strndup16to8(s16, stringlen);
+}
+static char *strdupReadString_p(Parcel *p) {
+ size_t stringlen;
+ const char16_t *s16;
+ s16 = p->readString16Inplace(&stringlen);
+ return strndup16to8(s16, stringlen);
+}
+
+/*Warren add for T800 platform 2021/11/19 start*/
+int lynq_socket_client_start()
+{
+ int ret;
+ struct timeval timeOut;
+ struct sockaddr_in liblynq_data_socket;
+
+ ret = 0;
+ timeOut.tv_sec = 30;
+ timeOut.tv_usec = 0;
+ bzero(&liblynq_data_socket, sizeof(liblynq_data_socket));
+ bzero(&lynq_data_socket_server_addr, sizeof(lynq_data_socket_server_addr));
+
+ //set this lib socket config
+ liblynq_data_socket.sin_family = AF_INET;
+ liblynq_data_socket.sin_addr.s_addr = inet_addr(LYNQ_RIL_FWK_IP);
+
+ //set ril service socket config
+ lynq_data_socket_server_addr.sin_family = AF_INET;
+ lynq_data_socket_server_addr.sin_port = htons(LYNQ_SERVICE_PORT);
+ lynq_data_socket_server_addr.sin_addr.s_addr = inet_addr(LYNQ_RIL_FWK_IP);
+ lynq_data_socket_server_addr_len = sizeof(lynq_data_socket_server_addr);
+
+ lynq_client_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+ ret = bind(lynq_client_sockfd, (struct sockaddr *)&liblynq_data_socket, sizeof(liblynq_data_socket));
+ if (-1 == ret)
+ {
+ LYERRLOG("liblynq_data_socket bind fail,errno:%d",errno);
+ return -1;
+ }
+ if (setsockopt(lynq_client_sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeOut, sizeof(timeOut)) < 0)
+ {
+ LYERRLOG("time out setting failed,errno:%d",errno);
+ return -1;
+ }
+ return 0;
+}
+
+bool is_support_urc(int urc_id)
+{
+ switch(urc_id)
+ {
+ case LYNQ_URC_DATA_CALL_STATUS_IND:
+
+ case LYNQ_URC_MODIFY_APNDB:
+ case LYNQ_URC_RESET_APNDB:
+ case LYNQ_TELEPHONY_RESTART:
+ return true;
+ default:
+ return false;
+ }
+}
+
+int printf_apn_table()
+{
+ int ret = 0;
+ if (lynq_apn_table == NULL)
+ {
+ LYERRLOG("apn table is null");
+ return -1;
+ }
+ for(ret;ret<LYNQ_APN_CHANNEL_MAX;ret++)
+ {
+ LYINFLOG("[%s][%d] apn=%s ;apntype=%s ;ifname=%s ;hasTimeout = %d ; hasUsed = %d,status = %d,statusDeactApn = %s",__FUNCTION__,ret, \
+ lynq_apn_table[ret].apn,lynq_apn_table[ret].apnType,lynq_apn_table[ret].ifaceName, \
+ lynq_apn_table[ret].hasTimeout,lynq_apn_table[ret].hasUsed,lynq_apn_table[ret].status,lynq_apn_table[ret].statusApnType);
+ }
+ return 0;
+}
+
+void printf_apn_table_debug(const char *fun,int line)
+{
+ LYINFLOG("[%s][%d]apn_table msg",fun,line);
+ printf_apn_table();
+}
+
+void urc_msg_process(Parcel *p)
+{
+ int len;
+ int resp_type;
+ int urcid;
+ int slot_id;
+ int check_count = 0;
+ static int apnId=-1;
+
+ int pdnState = 0;
+ char apn[LYNQ_APN_MAX_LEN];
+ char apnType[LYNQ_APN_TYPE_MAX_LEN];
+ char ifaceName[LYNQ_IFACE_NAME_MAX_LEN];
+ char *urc_msg = NULL;
+
+ int size = p->dataSize();
+ p->readInt32(&resp_type);
+ p->readInt32(&urcid);
+ p->readInt32(&slot_id);
+ LYINFLOG("data lib recv urc:resp_type=%d,urcid=%d,slot_id=%d,size=%d\n",resp_type,urcid,slot_id,size);
+ switch(urcid)
+ {
+ case LYNQ_URC_DATA_CALL_STATUS_IND:
+ p->readInt32(&pdnState);
+ bzero(apn,LYNQ_APN_MAX_LEN);
+ bzero(apnType,LYNQ_APN_TYPE_MAX_LEN);
+ bzero(ifaceName,LYNQ_IFACE_NAME_MAX_LEN);
+ if(pdnState != RIL_Data_Call_PdnState::PDN_DISCONNECTED)//PDN_DISCONNECTED
+ {
+ urc_msg = strdupReadString_p(p);
+ int len = strlen(urc_msg);
+ if((len < LYNQ_APN_MAX_LEN-1) && (len > 0))
+ {
+ memcpy(apn,urc_msg,len+1);
+ }
+ free(urc_msg);
+ urc_msg = strdupReadString_p(p);
+ len = strlen(urc_msg);
+ if((len < LYNQ_APN_TYPE_MAX_LEN-1) && (len > 0))
+ {
+ memcpy(apnType,urc_msg,len+1);
+ }
+ free(urc_msg);
+ urc_msg = strdupReadString_p(p);
+ len = strlen(urc_msg);
+ if((len < LYNQ_IFACE_NAME_MAX_LEN-1) && (len > 0))
+ {
+ memcpy(ifaceName,urc_msg,strlen(urc_msg)+1);
+ }
+ free(urc_msg);
+ //sendSignalDataCallStateChange();
+ apnId = getLynqApnID(apnType);
+ if(apnId >= 0)
+ {
+ LYINFLOG("URC apnType:%s,ifaceName:%s,apn:%s pdnState:%d,handle:%d",apnType,ifaceName,apn,pdnState,apnId);
+ if(lynq_apn_table[apnId].hasTimeout==1)
+ {
+ /*whether timeout?,real or not,*/
+ printf_apn_table();
+ LYERRLOG("apn:%s has time out,deacive this apn",lynq_apn_table[apnId].apn);
+ if (NULL != lynq_apn_table[apnId].apn && NULL != lynq_apn_table[apnId].apnType && strlen(lynq_apn_table[apnId].apn)>0)
+ {
+ LYERRLOG("deactive this time out APN");
+ lynq_deactive_data_call(&apnId);
+ }
+ else
+ {
+ /*if apn lose,update apn and deactive all apn*/
+ LYERRLOG("this table is invalid update APN table");
+ }
+ break;
+ }
+ updateApnTable(&lynq_apn_table[apnId],apn,apnType,ifaceName);
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ }
+ /*To be completed*/
+ else
+ {
+ data_invaild_error = 1;
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ apnId = getDeactApnID(apnType);
+ if(apnId < 0)
+ {
+ LYERRLOG("[%d]invalid apnId:%d",__LINE__,apnId);
+ break;
+ }
+ LYINFLOG("URC apnType:%s,ifaceName:%s,apn:%s pdnState:%d,handle:%d",apnType,ifaceName,apn,pdnState,apnId);
+ updateDeactApn(apnId,pdnState);
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ }
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ s_data_urc_wait_list.push_back(apnId);
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+ lynq_data_call_change_id = apnId;
+ sendSignalPdnChange();
+ LYDBGLOG("data call state:%d",lynq_data_call);
+ if(lynq_data_call==1)
+ {
+ while (data_timelimit == 0)
+ {
+ LYINFLOG("client not ready to wait");
+ for (check_count = 0;check_count < 500;check_count++)
+ {
+ /*wait 10ms*/
+ usleep(10*1000);
+ }
+ LYERRLOG("client still without res");
+ break;
+ }
+ if(pdnState == RIL_Data_Call_PdnState::PDN_TIMEOUT_CANCEL)
+ {
+ lynq_data_call = LYNQ_E_TIME_OUT;
+ }
+ else
+ {
+ lynq_data_call = 0;
+ }
+ sendSignalDataCallStateChange();
+ data_timelimit = 0;
+ }
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ }
+ else
+ {
+ urc_msg = strdupReadString_p(p);
+ free(urc_msg);
+ urc_msg = strdupReadString_p(p);
+ len = strlen(urc_msg);
+ if(len < LYNQ_APN_TYPE_MAX_LEN-1)
+ {
+ memcpy(apnType,urc_msg,len+1);
+ }
+ free(urc_msg);
+ LYDBGLOG("[data thread_urc_recv] apntype:%s",apnType);
+ apnId = getLynqApnID(apnType);
+ if(apnId >= 0)
+ {
+ LYINFLOG("[%d]URC apnType:%s,ifaceName:%s,apn:%s pdnState:%d,handle:%d",__LINE__,apnType,ifaceName,apn,pdnState,apnId);
+ lynq_data_call_change_id = apnId;
+ //bzero(lynq_apn_table[apnId].apnType,LYNQ_APN_TYPE_MAX_LEN);//async clean
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ s_data_urc_wait_list.push_back(apnId);
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+ sendSignalPdnChange();
+ }
+ else
+ {
+ apnId = getDeactApnID(apnType);
+ if(apnId < 0)
+ {
+ LYERRLOG("[%d]invalid apnId:%d",__LINE__,apnId);
+ break;
+ }
+ LYINFLOG("[%d]URC apnType:%s,ifaceName:%s,apn:%s pdnState:%d,handle:%d",__LINE__,apnType,ifaceName,apn,pdnState,apnId);
+ cleanDeactApn(apnId);
+ lynq_data_call_change_id = apnId;
+ bzero(lynq_apn_table[apnId].apnType,LYNQ_APN_TYPE_MAX_LEN);//async clean
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ s_data_urc_wait_list.push_back(apnId);
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+ sendSignalDeactvied();
+ sendSignalPdnChange();
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ }
+ LYDBGLOG("data call state:%d",lynq_data_call);
+ if(lynq_data_call==1)
+ {
+ while (data_timelimit == 0)
+ {
+ LYINFLOG("client not ready to wait");
+ for (check_count = 0;check_count < 500;check_count++)
+ {
+ /*wait 10ms*/
+ usleep(10*1000);
+ }
+ LYERRLOG("client still without res");
+ break;
+ }
+ sendSignalDataCallStateChange();
+ lynq_data_call = 0;
+ data_timelimit = 0;
+ }
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ }
+ break;
+ case LYNQ_URC_MODIFY_APNDB:
+ urc_msg = strdupReadString_p(p);
+ if (NULL == urc_msg)
+ {
+ LYERRLOG("error apn msg");
+ }
+ else
+ {
+ bzero(g_lynq_apn_result, 1024);
+ strcpy(g_lynq_apn_result, urc_msg);
+ sendSignalApnChange();
+ }
+ free(urc_msg);
+ break;
+ case LYNQ_URC_RESET_APNDB:
+ {
+ urc_msg = strdupReadString_p(p);
+ if (NULL == urc_msg)
+ {
+ LYERRLOG("error apn msg");
+ }
+ else
+ {
+ bzero(g_lynq_apn_result, 1024);
+ strcpy(g_lynq_apn_result, urc_msg);
+ sendSignalApnChange();
+ }
+ free(urc_msg);
+ break;
+ }
+ case LYNQ_TELEPHONY_RESTART:
+ {
+ if(slot_id == 0)
+ {
+ RLOGI("data has received telephony has restart");
+ RLOGI("handle set to 10");
+ lynq_telephony_restart_g = 1;
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ s_data_urc_wait_list.push_back(TELEPHONY_RESTART);
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+ sendSignalPdnChange();
+ }
+ break;
+ }
+ default:
+ break;
+ }
+
+}
+
+int create_urc_vector_signal_thread()
+{
+ int ret;
+ pthread_mutex_init(&s_lynq_urc_vector_mutex,NULL);
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ s_data_urc_wait_list.clear();
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+ return 0;
+}
+int get_imsi();
+int check_apn_status();
+
+int get_timeout_value();
+int lynq_init_data(int uToken)
+{
+ LYLOGSET(LOG_INFO);
+ LYLOGEINIT(USER_LOG_TAG);
+ LYERRLOG("%s start, parameter is %d", __func__,uToken);
+
+ if (g_lynq_data_init_flag == 1)
+ {
+ LYERRLOG("init twice is not allowed");
+ return -1;
+ }
+ g_lynq_data_init_flag = 1;
+ int result = 0;
+ Global_uToken = uToken;
+
+ int ret = get_timeout_value();
+ if(ret >= 30000)
+ {
+ g_data_call_timeout_value = ret;
+ }
+ else
+ {
+ LYERRLOG("timeout must greater or equal to 30s!!!");
+ }
+ result = lynq_socket_client_start();
+ pthread_mutex_init(&g_lynq_data_sendto_mutex, NULL);
+ if(result!=0)
+ {
+ LYERRLOG("init socket client fail!!!");
+ return -1;
+ }
+ result = lynq_init_data_urc_thread();
+ if(result!=0)
+ {
+ LYERRLOG("init socket urc fail!!!");
+ return -1;
+ }
+
+ result = create_urc_vector_signal_thread();
+ if(result!=0)
+ {
+ LYERRLOG("init socket urc fail!!!");
+ return -1;
+ }
+ memset(lynq_apn_table,0,sizeof(lynq_apn_table));
+ LYINFLOG("[%s] radio on/off solution 20230724",__FUNCTION__);
+ int count = 0;
+ while(count < 2)//try recover the network within 10s.
+ {
+ result = check_apn_status();
+ if(result==0)
+ {
+ break;
+ }
+ radio_switch(0);
+ sleep(1);
+ radio_switch(1);
+ sleep(3);
+ count++;
+ }
+ LYINFLOG("[%s] count is %d",__FUNCTION__,count);
+ if(result!=0)
+ {
+ LYDBGLOG("lynq init call fail!!!");
+ return LYNQ_E_MD_NOT_READY;//
+ }
+ /* old
+ while(count < 10)
+ {
+ result = get_imsi();
+ if(result==0)
+ {
+ break;
+ }
+ sleep(1);
+ count++;
+ }
+ LYINFLOG("[%s] count is %d",__FUNCTION__,count);
+ if(result!=0)
+ {
+ LYDBGLOG("lynq init call fail!!!");
+ return LYNQ_E_MD_NOT_READY;//
+ }
+ */
+ LYERRLOG("%s end suc", __func__);
+ return 0;
+
+}
+int lynq_deinit_data()
+{
+ LYERRLOG("%s start", __func__);
+
+ int ret = -1;
+ if (g_lynq_data_init_flag == 0)
+ {
+ LYERRLOG("deinit twice is not allowed");
+ return ret;
+ }
+ g_lynq_data_init_flag = 0;
+ for(int i =0;i<LYNQ_APN_CHANNEL_MAX;i++)
+ {
+ if(strlen(lynq_apn_table[i].apnType)!=0)
+ {
+ lynq_deactive_data_call(&i);
+ }
+ }
+ if(lynq_client_sockfd>0)
+ {
+ close(lynq_client_sockfd);
+ }
+ ret = lynq_deinit_data_urc_thread();
+ if (ret != 0)
+ {
+ LYERRLOG("lynq_deinit_data_urc_thread fail");
+ return ret;
+ }
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ s_data_urc_wait_list.clear();
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+ LYERRLOG("%s end suc", __func__);
+ return 0;
+}
+int lynq_setup_data_call(int *handle)
+{
+ int error = -1;
+ if (g_lynq_data_init_flag == 0)
+ {
+ LYERRLOG("[%s][%d]Invalid operation",__FUNCTION__,__LINE__);
+ return error;
+ }
+ #ifdef GSW_RIL_CFG //becuase gsw not have connman,data can not be triggered by connman.
+ LYINFLOG("[%s][%d]",__FUNCTION__,__LINE__);
+ error = lynq_setup_data_call_sp(handle,NULL,"default",NULL,NULL,NULL,NULL,NULL);
+ #else
+ Parcel *p = NULL;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int lynq_data_call_id = 0;
+ if(handle==NULL)
+ {
+ LYERRLOG("handle is null!!!");
+ return LYNQ_E_NULL_ANONALY;
+ }
+ client.uToken = get_utoken();
+ client.request = 27;//RIL_REQUEST_SETUP_DATA_CALL
+ client.paramLen = 0;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ lynq_data_call_id = get_handle("default");
+ if (lynq_data_call_id < 0)
+ {
+ LYERRLOG("update apn table fail error id = %d",lynq_data_call_id);
+ return LYNQ_E_NULL_ANONALY+1;
+ }
+ *handle = lynq_data_call_id;//T8TSK-211 (2023/5/16) why? If it times out, the client application will also try to reconnect.
+ //Reconnection needs to be deactivated first, and deactivation needs to know which apn to activate.
+ lynq_data_call = 1;
+ pthread_mutex_lock(&g_lynq_data_sendto_mutex);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_DATA] send request fail:");
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ return LYNQ_E_NULL_ANONALY+2;
+ }
+ //get_response(lynq_client_sockfd,p);
+ error = wait_response(lynq_client_sockfd,p,client.uToken);
+ if(error!=0)
+ {
+ LYERRLOG("wait_response fail,ret:%d",error);
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ return error;
+ }
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ JumpHeader(p,&resp_type,&client.uToken,&request,&slot_id,&error);
+ free_parcel(p);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ if(error==0)
+ {
+ data_timelimit = 1;
+ if (waitDataCallstateChange(g_data_call_timeout_value) == ETIMEDOUT)
+ {
+ error = LYNQ_E_TIME_OUT;
+ LYERRLOG("timeout:wait data Call state fail!!!");
+ lynq_apn_table[lynq_data_call_id].hasTimeout = 1;
+ if (data_invaild_error == 1)
+ {
+ data_invaild_error = 0;
+ LYERRLOG("urc apn info error!!!");
+ return 8085;
+ }
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ return error;
+ }
+ if(lynq_data_call == LYNQ_E_TIME_OUT)
+ {
+ error = LYNQ_E_TIME_OUT;
+ LYERRLOG("PDN_TIMEOUT_CANCLE:wait data Call state fail!!!");
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ return error;
+ }
+ }
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ #endif //GSW_RIL_CFG
+ return error;
+}
+
+int lynq_deactive_data_call(int *handle)
+{
+ Parcel *p = NULL;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ int lynq_data_call_id = -1;
+ int ret = 0;
+ if (g_lynq_data_init_flag == 0)
+ {
+ LYERRLOG("[%s][%d]Invalid operation",__FUNCTION__,__LINE__);
+ return error;
+ }
+ if(handle==NULL)
+ {
+ LYERRLOG("handle is null!!!");
+ return -1;
+ }
+ ret = handleCheck(*handle);
+ if (ret != 0)
+ {
+ LYERRLOG("incomming handle is invalid");
+ return -1;
+ }
+ lynq_data_call_id = *handle;
+ client.uToken = get_utoken();
+ client.request = 41;//RIL_REQUEST_DEACTIVATE_DATA_CALL
+ client.paramLen = 0;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ #ifdef GSW_RIL_CFG
+ client.paramLen = 1;
+ sprintf(client.param,"%s",lynq_apn_table[lynq_data_call_id].apnType);
+ #else
+ if(strcmp(lynq_apn_table[lynq_data_call_id].apnType,"default")!=0)
+ {
+ client.paramLen = 1;
+ sprintf(client.param,"%s",lynq_apn_table[lynq_data_call_id].apnType);
+ }
+ #endif //GSW_RIL_CFG
+ LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ pthread_mutex_lock(&g_lynq_data_sendto_mutex);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_DATA] send request fail:");
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ return -1;
+ }
+ //get_response(lynq_client_sockfd,p);
+ error = wait_response(lynq_client_sockfd,p,client.uToken);
+ if(error!=0)
+ {
+ LYERRLOG("wait_response fail,ret:%d",error);
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ return error;
+ }
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ JumpHeader(p,&resp_type,&client.uToken,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,uToken=%d,request=%d,slot_id=%d,error_code=%d",resp_type,client.uToken,request,slot_id,error);
+ cleanOnceApnTable(lynq_data_call_id);
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ if(error==0)
+ {
+ if(waitDeactived(20000)==ETIMEDOUT)
+ {
+ error = LYNQ_E_TIME_OUT;
+ LYERRLOG("[lynq_deactive_data_call] timeout:wait data Call state fail!!!");
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ }
+ }
+ free_parcel(p);
+ return error;
+}
+int lynq_setup_data_call_sp(int *handle,char *apn,char *apnType,char *user,char *password,char *authType,char *normalProtocol,char *roamingProtocol)
+{
+ Parcel *p = NULL;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ int lynq_data_call_id = -1;
+ char *argv[10] = {};
+ if (g_lynq_data_init_flag == 0)
+ {
+ LYERRLOG("[%s][%d]Invalid operation",__FUNCTION__,__LINE__);
+ return error;
+ }
+ #ifdef GSW_RIL_CFG
+ LYINFLOG("[%s][%d]",__FUNCTION__,__LINE__);
+ if(handle==NULL||apnType==NULL)
+ {
+ LYERRLOG("handle or apntype is null!!!");
+ return -1;
+ }
+ #else
+ if(handle==NULL||apn==NULL||apnType==NULL)
+ {
+ LYERRLOG("handle ,apn or apntype is null!!!");
+ return LYNQ_E_NULL_ANONALY;
+ }
+ #endif //GSW_RIL_CFG
+ if(user==NULL)
+ {
+ argv[1] = "null";
+ }
+ else
+ {
+ argv[1] = user;
+ }
+ if(password==NULL)
+ {
+ argv[2] = "null";
+ }
+ else
+ {
+ argv[2] = password;
+ }
+ if(authType==NULL)
+ {
+ argv[3] = "null";
+ }
+ else
+ {
+ argv[3] = authType;
+ }
+ if(normalProtocol==NULL)
+ {
+ argv[4] = "null";
+ }
+ else
+ {
+ argv[4] = normalProtocol;
+ }
+ if(roamingProtocol==NULL)
+ {
+ argv[5] = "null";
+ }
+ else
+ {
+ argv[5] = roamingProtocol;
+ }
+ client.uToken = get_utoken();
+ client.request = 27;//RIL_REQUEST_SETUP_DATA_CALL
+ client.paramLen = 7;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ #ifdef GSW_RIL_CFG
+ if(NULL == apn)
+ {
+ sprintf(client.param,"null %s %s %s %s %s %s",apnType,argv[1],argv[2],argv[3],argv[4],argv[5]);
+ }
+ else
+ {
+ sprintf(client.param,"%s %s %s %s %s %s %s",apn,apnType,argv[1],argv[2],argv[3],argv[4],argv[5]);
+ }
+ #else
+ sprintf(client.param,"%s %s %s %s %s %s %s",apn,apnType,argv[1],argv[2],argv[3],argv[4],argv[5]);
+ #endif //GSW_RIL_CFG
+ LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ lynq_data_call_id = get_handle(apnType);
+ if (lynq_data_call_id < 0)
+ {
+ LYERRLOG("update apn table fail error id = %d",lynq_data_call_id);
+ return LYNQ_E_NULL_ANONALY+1;
+ }
+ *handle = lynq_data_call_id;//T8TSK-211 (2023/5/16)
+ lynq_data_call = 1;
+ pthread_mutex_lock(&g_lynq_data_sendto_mutex);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_DATA] send request fail:");
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ return LYNQ_E_NULL_ANONALY+2;
+ }
+ //get_response(lynq_client_sockfd,p);
+ error = wait_response(lynq_client_sockfd,p,client.uToken);
+ if(error!=0)
+ {
+ LYERRLOG("wait_response fail,ret:%d",error);
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ return error;
+ }
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ JumpHeader(p,&resp_type,&client.uToken,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,uToken=%d,request=%d,slot_id=%d,error_code=%d",resp_type,client.uToken,request,slot_id,error);
+ free_parcel(p);
+ if(error==0)
+ {
+ data_timelimit = 1;
+ if(waitDataCallstateChange(g_data_call_timeout_value)==ETIMEDOUT)
+ {
+ error = LYNQ_E_TIME_OUT;
+ LYERRLOG("timeout:wait data Call state fail!!!");
+ lynq_apn_table[lynq_data_call_id].hasTimeout = 1;
+ if (data_invaild_error == 1)
+ {
+ data_invaild_error = 0;
+ LYERRLOG("urc apn info error!!!");
+ return 8085;
+ }
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ return error;
+ }
+ if(lynq_data_call == LYNQ_E_TIME_OUT)
+ {
+ error = LYNQ_E_TIME_OUT;
+ LYERRLOG("PDN_TIMEOUT_CANCLE:wait data Call state fail!!!");
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ return error;
+ }
+ }
+ printf_apn_table_debug(__FUNCTION__,__LINE__);
+ return error;
+}
+/*
+int lynq_deactive_data_call_sp(int *handle,char *apnType)
+{
+ Parcel p;
+ lynq_client_t client;
+ int resp_type = -1;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ if(handle==NULL||apnType==NULL)
+ {
+ LYERRLOG("handle is null!!!");
+ return -1;
+ }
+ client.uToken = Global_uToken;
+ client.request = 41;//RIL_REQUEST_DEACTIVATE_DATA_CALL
+ client.paramLen = 1;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ sprintf(client.param,"%s",apnType);
+ LYERRLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_DATA] send request fail:");
+ return -1;
+ }
+ get_response(lynq_client_sockfd,p);
+ JumpHeader(p,&resp_type,&request,&slot_id,&error);
+ LYINFLOG("resp_type=%d,request=%d,slot_id=%d,error_code=%d",resp_type,request,slot_id,error);
+ return error;
+}
+*/
+int getDataCallLists(lynq_data_call_response_v11_t dataCallList[LYNQ_APN_CHANNEL_MAX],int *realNum)
+{
+ Parcel *p = NULL;
+ lynq_client_t client;
+ int resp_type = -1;
+ int token;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ int version =0;
+ int num = 0;
+ char *temp_char = NULL;
+ if(dataCallList==NULL)
+ {
+ LYERRLOG("dataCallList is null!!!");
+ return -1;
+ }
+ client.uToken = get_utoken();;
+ client.request = 57;//RIL_REQUEST_DATA_CALL_LIST
+ client.paramLen = 0;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ pthread_mutex_lock(&g_lynq_data_sendto_mutex);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_DATA] send request fail:");
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ return -1;
+ }
+ //get_response(lynq_client_sockfd,p);
+ error = wait_response(lynq_client_sockfd,p,client.uToken);
+ if(error!=0)
+ {
+ LYERRLOG("wait_response fail,ret:%d",error);
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ return error;
+ }
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ if(JumpHeader(p,&resp_type,&client.uToken,&request,&slot_id,&error)!=0)
+ {
+ LYERRLOG("JumpHeader fail");
+ return -1;
+ }
+ LYINFLOG("resp_type=%d,uToken=%d,request=%d,slot_id=%d,error_code=%d",resp_type,client.uToken,request,slot_id,error);
+ p->readInt32(&version);
+ if(version==11)
+ {
+ p->readInt32(&num);
+ *realNum = num;
+ for (int i = 0; i < num; i++)
+ {
+ p->readInt32(&dataCallList[i].status);
+ p->readInt32(&dataCallList[i].suggestedRetryTime);
+ p->readInt32(&dataCallList[i].cid);
+ p->readInt32(&dataCallList[i].active);
+ temp_char = strdupReadString_p(p);
+ LYINFLOG("[%s][%d]%s",__FUNCTION__,__LINE__,temp_char);
+ if(temp_char)
+ {
+ memcpy(dataCallList[i].type,temp_char,strlen(temp_char)+1);
+ free(temp_char);
+ }
+ temp_char = strdupReadString_p(p);
+ LYINFLOG("[%s][%d]%s",__FUNCTION__,__LINE__,temp_char);
+ if(temp_char)
+ {
+ memcpy(dataCallList[i].ifname,temp_char,strlen(temp_char)+1);
+ free(temp_char);
+ }
+ temp_char = strdupReadString_p(p);
+ LYINFLOG("[%s][%d]%s",__FUNCTION__,__LINE__,temp_char);
+ if(temp_char)
+ {
+ memcpy(dataCallList[i].addresses,temp_char,strlen(temp_char)+1);
+ free(temp_char);
+ }
+ temp_char = strdupReadString_p(p);
+ LYINFLOG("[%s][%d]%s",__FUNCTION__,__LINE__,temp_char);
+ if(temp_char)
+ {
+ memcpy(dataCallList[i].dnses,temp_char,strlen(temp_char)+1);
+ free(temp_char);
+ }
+ temp_char = strdupReadString_p(p);
+ LYINFLOG("[%s][%d]%s",__FUNCTION__,__LINE__,temp_char);
+ if(temp_char)
+ {
+ memcpy(dataCallList[i].gateways,temp_char,strlen(temp_char)+1);
+ free(temp_char);
+ }
+ temp_char = strdupReadString_p(p);
+ LYINFLOG("[%s][%d]%s",__FUNCTION__,__LINE__,temp_char);
+ if(temp_char)
+ {
+ memcpy(dataCallList[i].pcscf,temp_char,strlen(temp_char)+1);
+ free(temp_char);
+ }
+ p->readInt32(&dataCallList[i].mtu);
+ }
+ }
+ free_parcel(p);
+ return error;
+}
+
+int lynq_get_apn_msg(int handle,lynq_apn_msg_t *apn_msg)
+{
+ LYINFLOG("[lynq_get_apn_msg] enter,handle:%d",handle);
+ if((handle < 0) || (handle > 6) || (NULL == apn_msg))
+ {
+ LYERRLOG("handle value error,or apn_msg is null");
+ return LYNQ_E_NULL_ANONALY;
+ }
+ apn_msg->handle = handle;
+ if(apn_msg->apn!=NULL)
+ {
+ memcpy(apn_msg->apn,lynq_apn_table[handle].apn,LYNQ_APN_MAX_LEN);
+ }
+ if(apn_msg->apnType!=NULL)
+ {
+ memcpy(apn_msg->apnType,lynq_apn_table[handle].apnType,LYNQ_APN_TYPE_MAX_LEN);
+ }
+ return 0;
+}
+
+int lynq_get_data_call_list(int *handle,lynq_data_call_response_v11_t *dataCallList)
+{
+ lynq_data_call_response_v11_t interDataCallList[LYNQ_APN_CHANNEL_MAX]={};
+ int number = 0;
+ int lynq_data_call_id = 0;
+ int error = 0;
+ if (g_lynq_data_init_flag == 0)
+ {
+ LYERRLOG("[%s][%d]Invalid operation",__FUNCTION__,__LINE__);
+ return -1;
+ }
+ lynq_data_call_id = *handle;
+ if((handle==NULL) || (dataCallList==NULL))
+ {
+ LYERRLOG("[lynq_get_data_call_list] handle or datacalllist is NULL");
+ return LYNQ_E_NULL_ANONALY;
+ }
+ if ((*handle < 0) || (*handle > 6))
+ {
+ LYERRLOG("[lynq_get_data_call_list] handle value error");
+ return LYNQ_E_NULL_ANONALY;
+ }
+ LYINFLOG("[lynq_get_data_call_list] incoming handle value: %d",*handle);
+ memset(interDataCallList,0,sizeof(interDataCallList));
+ error = getDataCallLists(interDataCallList,&number);
+ if(error == 0)
+ {
+ for(int i = 0;i < number;i++)
+ {
+ if(strcmp(interDataCallList[i].ifname,lynq_apn_table[lynq_data_call_id].ifaceName)==0)
+ {
+ dataCallList->active = interDataCallList[i].active;
+ dataCallList->suggestedRetryTime = interDataCallList[i].suggestedRetryTime;
+ dataCallList->cid = interDataCallList[i].cid;
+ dataCallList->status = interDataCallList[i].status;
+ dataCallList->mtu = interDataCallList[i].mtu;
+ memcpy(dataCallList->addresses,interDataCallList[i].addresses,sizeof(interDataCallList[i].addresses));
+ memcpy(dataCallList->ifname,interDataCallList[i].ifname,sizeof(interDataCallList[i].ifname));
+ memcpy(dataCallList->dnses,interDataCallList[i].dnses,sizeof(interDataCallList[i].dnses));
+ memcpy(dataCallList->type,interDataCallList[i].type,sizeof(interDataCallList[i].type));
+ memcpy(dataCallList->gateways,interDataCallList[i].gateways,sizeof(interDataCallList[i].gateways));
+ memcpy(dataCallList->pcscf,interDataCallList[i].pcscf,sizeof(interDataCallList[i].pcscf));
+ LYDBGLOG("ifname:%s,addr:%s",dataCallList->ifname,dataCallList->addresses);
+ }
+ }
+ }
+ return error;
+}
+int lynq_wait_data_call_state_change(int *handle)
+{
+ if (data_waiting_status == 1)
+ {
+ LYDBGLOG("some thread is waiting");
+ return -3;
+ }
+ LYDBGLOG("is empty :%d",s_data_urc_wait_list.empty());
+ if (s_data_urc_wait_list.empty())
+ {
+ LYDBGLOG("start wait");
+ data_waiting_status = 1;
+ waitPdnChange();
+ }
+ data_waiting_status = 0;
+ std::vector<int>::iterator iter;
+
+ pthread_mutex_lock(&s_lynq_urc_vector_mutex);
+ iter = s_data_urc_wait_list.begin();
+ if (iter != s_data_urc_wait_list.end())
+ {
+ *handle = *iter;
+ }
+ s_data_urc_wait_list.erase(iter);
+ pthread_mutex_unlock(&s_lynq_urc_vector_mutex);
+
+ LYINFLOG("lynq_wait_data_call_state_change handle:%d",*handle);
+ return 0;
+}
+/*Warren add for T800 platform 2021/11/19 end*/
+
+/*Typethree add for T800 platform 2022/04/21 start*/
+
+int insert_apn_char(char *agc, char *id,char *mcc, char *mnc, char *apn, char *apntype, char *user, char *password, char *normalprotocol, char *roamingprotocol, char *carrier)
+{
+ char strtmp[10][32];
+ if (id == NULL)
+ {
+ sprintf(strtmp[0], "id=;");
+ }
+ else
+ {
+ sprintf(strtmp[0], "id=%s;", id);
+ }
+ if (mcc == NULL)
+ {
+ sprintf(strtmp[1], "mcc=;");
+ }
+ else
+ {
+ sprintf(strtmp[1], "mcc=%s;", mcc);
+ }
+ if (mnc == NULL)
+ {
+ sprintf(strtmp[2], "mnc=;");
+ }
+ else
+ {
+ sprintf(strtmp[2], "mnc=%s;", mnc);
+ }
+ if (apn == NULL)
+ {
+ sprintf(strtmp[3], "apn=;");
+ }
+ else
+ {
+ sprintf(strtmp[3], "apn=%s;", apn);
+ }
+ if (apntype == NULL)
+ {
+ sprintf(strtmp[4], "apntype=;");
+ }
+ else
+ {
+ sprintf(strtmp[4], "apntype=%s;", apntype);
+ }
+ if (user == NULL)
+ {
+ sprintf(strtmp[5], "user=;");
+ }
+ else
+ {
+ sprintf(strtmp[5], "user=%s;", user);
+ }
+ if (password == NULL)
+ {
+ sprintf(strtmp[6], "password=;");
+ }
+ else
+ {
+ sprintf(strtmp[6], "password=%s;", password);
+ }
+ if (normalprotocol == NULL)
+ {
+ sprintf(strtmp[7], "normalprotocol=;");
+ }
+ else
+ {
+ sprintf(strtmp[7], "normalprotocol=%s;", normalprotocol);
+ }
+ if (roamingprotocol == NULL)
+ {
+ sprintf(strtmp[8], "roamingprotocol=;");
+ }
+ else
+ {
+ sprintf(strtmp[8], "roamingprotocol=%s;", roamingprotocol);
+ }
+ if (carrier == NULL)
+ {
+ sprintf(strtmp[9], "carrier=;");
+ }
+ else
+ {
+ sprintf(strtmp[9], "carrier=%s;", carrier);
+ }
+ sprintf(agc, "%s%s%s%s%s%s%s%s%s%s",strtmp[0], strtmp[1], strtmp[2], strtmp[3], strtmp[4], strtmp[5], strtmp[6], strtmp[7], strtmp[8], strtmp[9]);
+
+ return 0;
+}
+
+int modify_apn_char(char *agc, char *id, char *mcc, char *mnc, char *apn, char *apntype, char *user, char *password, char *normalprotocol, char *roamingprotocol, char *carrier)
+{
+ char strtmp[10][32];
+ if (id == NULL)
+ {
+ sprintf(strtmp[0], "id=;");
+ }
+ else
+ {
+ sprintf(strtmp[0], "id=%s;", id);
+ }
+ if (mcc == NULL)
+ {
+ sprintf(strtmp[1], "mcc=;");
+ }
+ else
+ {
+ sprintf(strtmp[1], "mcc=%s;", mcc);
+ }
+ if (mnc == NULL)
+ {
+ sprintf(strtmp[2], "mnc=;");
+ }
+ else
+ {
+ sprintf(strtmp[2], "mnc=%s;", mnc);
+ }
+ if (apn == NULL)
+ {
+ sprintf(strtmp[3], "apn=;");
+ }
+ else
+ {
+ sprintf(strtmp[3], "apn=%s;", apn);
+ }
+ if (apntype == NULL)
+ {
+ sprintf(strtmp[4], "apntype=;");
+ }
+ else
+ {
+ sprintf(strtmp[4], "apntype=%s;", apntype);
+ }
+ if (user == NULL)
+ {
+ sprintf(strtmp[5], "user=;");
+ }
+ else
+ {
+ sprintf(strtmp[5], "user=%s;", user);
+ }
+ if (password == NULL)
+ {
+ sprintf(strtmp[6], "password=;");
+ }
+ else
+ {
+ sprintf(strtmp[6], "password=%s;", password);
+ }
+ if (normalprotocol == NULL)
+ {
+ sprintf(strtmp[7], "normalprotocol=;");
+ }
+ else
+ {
+ sprintf(strtmp[7], "normalprotocol=%s;", normalprotocol);
+ }
+ if (roamingprotocol == NULL)
+ {
+ sprintf(strtmp[8], "roamingprotocol=;");
+ }
+ else
+ {
+ sprintf(strtmp[8], "roamingprotocol=%s;", roamingprotocol);
+ }
+ if (carrier == NULL)
+ {
+ sprintf(strtmp[9], "carrier=;");
+ }
+ else
+ {
+ sprintf(strtmp[9], "carrier=%s;", carrier);
+ }
+ sprintf(agc, "%s%s%s%s%s%s%s%s%s%s", strtmp[0], strtmp[1], strtmp[2], strtmp[3], strtmp[4], strtmp[5], strtmp[6], strtmp[7], strtmp[8], strtmp[9]);
+ return 0;
+}
+
+
+int query_apn_char(char *agc, char *id, char *mcc, char *mnc, char *apn, char *apntype, char *user, char *password, char *normalprotocol, char *roamingprotocol, char *carrier)
+{
+ char strtmp[10][32];
+ if (id == NULL)
+ {
+ sprintf(strtmp[0], "");
+ }
+ else
+ {
+ sprintf(strtmp[0], "id=%s;", id);
+ }
+ if (mcc == NULL)
+ {
+ sprintf(strtmp[1], "");
+ }
+ else
+ {
+ sprintf(strtmp[1], "mcc=%s;", mcc);
+ }
+ if (mnc == NULL)
+ {
+ sprintf(strtmp[2], "");
+ }
+ else
+ {
+ sprintf(strtmp[2], "mnc=%s;", mnc);
+ }
+ if (apn == NULL)
+ {
+ sprintf(strtmp[3], "");
+ }
+ else
+ {
+ sprintf(strtmp[3], "apn=%s;", apn);
+ }
+ if (apntype == NULL)
+ {
+ sprintf(strtmp[4], "");
+ }
+ else
+ {
+ sprintf(strtmp[4], "apntype=%s;", apntype);
+ }
+ if (user == NULL)
+ {
+ sprintf(strtmp[5], "");
+ }
+ else
+ {
+ sprintf(strtmp[5], "user=%s;", user);
+ }
+ if (password == NULL)
+ {
+ sprintf(strtmp[6], "");
+ }
+ else
+ {
+ sprintf(strtmp[6], "password=%s;", password);
+ }
+ if (normalprotocol == NULL)
+ {
+ sprintf(strtmp[7], "");
+ }
+ else
+ {
+ sprintf(strtmp[7], "normalprotocol=%s;", normalprotocol);
+ }
+ if (roamingprotocol == NULL)
+ {
+ sprintf(strtmp[8], "");
+ }
+ else
+ {
+ sprintf(strtmp[8], "roamingprotocol=%s;", roamingprotocol);
+ }
+ if (carrier == NULL)
+ {
+ sprintf(strtmp[9], "");
+ }
+ else
+ {
+ sprintf(strtmp[9], "carrier=%s;", carrier);
+ }
+ sprintf(agc, "%s%s%s%s%s%s%s%s%s%s", strtmp[0], strtmp[1], strtmp[2], strtmp[3], strtmp[4], strtmp[5], strtmp[6], strtmp[7], strtmp[8], strtmp[9]);
+ return 0;
+}
+
+static char *lynqStrdupReadString(Parcel &p)
+{
+ size_t stringlen;
+ const char16_t *s16;
+
+ s16 = p.readString16Inplace(&stringlen);
+ return strndup16to8(s16, stringlen);
+}
+int get_imsi()
+{
+ Parcel *p =NULL;
+ lynq_client_t client;
+ int resp_type = -1;
+ int token;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ int version =0;
+ int num = 0;
+ char *temp_char = NULL;
+ char mccmnc[32] = {0};
+ char mccmnckey[64] = {0};
+ client.uToken = get_utoken();
+ client.request = 11;//RIL_REQUEST_GET_IMSI 11
+ client.paramLen = 0;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ pthread_mutex_lock(&g_lynq_data_sendto_mutex);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_DATA] send request fail:");
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ return -1;
+ }
+ //get_response(lynq_client_sockfd,p);
+ error = wait_response(lynq_client_sockfd,p,client.uToken);
+ if(error!=0)
+ {
+ LYERRLOG("wait_response fail,ret:%d",error);
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ return error;
+ }
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ if(JumpHeader(p,&resp_type,&client.uToken,&request,&slot_id,&error)!=0)
+ {
+ LYERRLOG("JumpHeader fail");
+ return -1;
+ }
+ LYINFLOG("resp_type=%d,uToken=%d,request=%d,slot_id=%d,error_code=%d",resp_type,client.uToken,request,slot_id,error);
+ if(error == 0)
+ {
+ char * test = strdupReadString_p(p);
+ memcpy(mccmnc, test,5);
+ mccmnc[5]='\0';
+ free(test);
+ sprintf(mccmnckey,"uci set radio_property.property.vendor_ril_data_gsm_mcc_mnc0=%s",mccmnc);
+ system(mccmnckey);
+ system("uci commit");
+ }
+ free_parcel(p);
+ return error;
+}
+int lynq_modify_apn_db(const int cmd, char *id, char *mcc, char *mnc, char *apn, char *apntype, char *user, char *password, char *normalprotocol, char *roamingprotocol, char *carrier, char *out)
+{
+ if (NULL == id && NULL == mcc && NULL == mnc && NULL == apn && NULL == apntype && NULL == user && NULL == password && NULL == normalprotocol && NULL == roamingprotocol && NULL == carrier)
+ {
+ LYERRLOG("There are no valid parameters");
+ return -1;
+ }
+ lynq_client_t client;
+ char argc[512];
+ int res = -1;
+ if (cmd == 0) // insert apn db
+ {
+ res = insert_apn_char(argc, id, mcc, mnc, apn, apntype, user, password, normalprotocol, roamingprotocol, carrier);
+ client.uToken = get_utoken();
+ client.request = 2000 + 193; // RIL_REQUEST_MODIFY_APN
+ client.paramLen = 2;
+ bzero(client.param, LYNQ_REQUEST_PARAM_BUF);
+ sprintf(client.param, "%d %s", cmd, argc);
+ }
+ else if (cmd == 1) //delete apn db
+ {
+ if (NULL == id)
+ {
+ LYERRLOG("id is NULL!!!please input id: ");
+ }
+ sprintf(argc, "id=%s", id);
+ client.uToken = get_utoken();
+ client.request = 2000 + 193; // RIL_REQUEST_MODIFY_APN
+ client.paramLen = 2;
+ bzero(client.param, LYNQ_REQUEST_PARAM_BUF);
+ sprintf(client.param, "%d %s", cmd, argc);
+ }
+ else if (cmd == 2) //query apn db
+ {
+ query_apn_char(argc, id, mcc, mnc, apn, apntype, user, password, normalprotocol, roamingprotocol, carrier);
+ client.uToken = get_utoken();
+ client.request = 2000 + 193; // RIL_REQUEST_MODIFY_APN
+ client.paramLen = 2;
+ bzero(client.param, LYNQ_REQUEST_PARAM_BUF);
+ sprintf(client.param, "%d %s", cmd, argc);
+ }
+ else if (cmd == 3) //modify apn db
+ {
+ modify_apn_char(argc, id, mcc, mnc, apn, apntype, user, password, normalprotocol, roamingprotocol, carrier);
+ client.uToken = get_utoken();
+ client.request = 2000 + 193; // RIL_REQUEST_MODIFY_APN
+ client.paramLen = 2;
+ bzero(client.param, LYNQ_REQUEST_PARAM_BUF);
+ sprintf(client.param, "%d %s", cmd, argc);
+ }
+ else
+ {
+ LYERRLOG("incoming command is invalid");
+ return -1;
+ }
+ LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ pthread_mutex_lock(&g_lynq_data_sendto_mutex);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ return -1;
+ }
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ waitApnResult();
+ strcpy(out, g_lynq_apn_result);
+ LYINFLOG(">>>>>output info:%s",out);
+ return 0;
+}
+
+int lynq_reset_apn(char *result)
+{
+ lynq_client_t client;
+ if (NULL == result)
+ {
+ LYERRLOG("incoming paramters error");
+ }
+ client.uToken = get_utoken();
+ client.request = 2000 + 194;
+ client.paramLen = 0;
+ bzero(client.param, LYNQ_REQUEST_PARAM_BUF);
+ LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s", client.uToken, client.request, client.paramLen, client.param);
+ pthread_mutex_lock(&g_lynq_data_sendto_mutex);
+ if (send_request(lynq_client_sockfd, &client) == -1)
+ {
+ LYERRLOG("send request fail");
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ return -1;
+ }
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ waitApnResult();
+ strcpy(result, g_lynq_apn_result);
+ LYINFLOG(">>>>>result:%s",result);
+ return 0;
+}
+
+/*Typethree add for T800 platform 2022/04/21 end*/
+static int exec_cmd(const char *str_cmd, char * str_cmd_ret, size_t max_len) {
+ FILE *fp;
+ //printf("to exec cmd:%s\n", str_cmd);
+ if((fp=popen(str_cmd,"r"))==NULL)
+ {
+ perror("popen error!");
+ return -1;
+ }
+ if((fread(str_cmd_ret,max_len,1,fp))<0)
+ {
+ perror("fread fail!");
+ fclose(fp);
+ return -1;
+ }
+ fclose(fp);
+ return 0;
+}
+int check_apn_status()
+{
+ LYINFLOG("check_apn_status enter");
+ int ret = -1;
+ char cmd_ret[8] ={0};//get mccmnc
+ const char *cmd = "uci get radio_property.property.vendor_ril_data_gsm_mcc_mnc0";
+ const char *empty_str = ":empty";
+ ret = exec_cmd(cmd,cmd_ret,8);
+ if(ret==0)
+ {
+ if(strlen(cmd_ret)==0)
+ {
+ LYERRLOG("not have mccmnc config in uci ram");
+ return 1;
+ }
+ if(strncmp(cmd_ret,empty_str,strlen(empty_str))==0)
+ {
+ LYERRLOG("mccmnc is empty");
+ return 2;
+ }
+ LYINFLOG("mccmnc is %s",cmd_ret);
+ return 0;
+ }
+ else
+ {
+ LYERRLOG("exec cmd fail");
+ return -1;
+ }
+ return 0;
+}
+int get_timeout_value()
+{
+ LYINFLOG("get_timeout_value enter");
+ int ret = -1;
+ char timeout_value[8] ={0};//get get_timeout_value
+ ret = lynq_get_value("lynq_uci","data_call","timeout",timeout_value);
+ if(ret == 0)
+ {
+ LYINFLOG("data_call.timeout is %s",timeout_value);
+ return atoi(timeout_value);
+ }
+ else
+ {
+ LYERRLOG("get_timeout_value");
+ return -1;
+ }
+}
+
+int radio_switch(int status)
+{
+ Parcel *p =NULL;
+ lynq_client_t client;
+ int resp_type = -1;
+ int token;
+ int request = -1;
+ int slot_id = -1;
+ int error = -1;
+ int version =0;
+ int num = 0;
+ char *temp_char = NULL;
+ char mccmnc[32] = {0};
+ char mccmnckey[64] = {0};
+ client.uToken = get_utoken();
+ client.request = 59;//RIL_REQUEST_OEM_HOOK_RAW 59
+ client.paramLen = 1;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ sprintf(client.param,"AT+CFUN=%d",status);
+ LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ pthread_mutex_lock(&g_lynq_data_sendto_mutex);
+ if(send_request(lynq_client_sockfd,&client)==-1)
+ {
+ LYERRLOG("send request fail");
+ perror("[LYNQ_DATA] send request fail:");
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ return -1;
+ }
+ //get_response(lynq_client_sockfd,p);
+ error = wait_response(lynq_client_sockfd,p,client.uToken);
+ if(error!=0)
+ {
+ LYERRLOG("wait_response fail,ret:%d",error);
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ return error;
+ }
+ pthread_mutex_unlock(&g_lynq_data_sendto_mutex);
+ if(JumpHeader(p,&resp_type,&client.uToken,&request,&slot_id,&error)!=0)
+ {
+ LYERRLOG("JumpHeader fail");
+ return -1;
+ }
+ LYINFLOG("resp_type=%d,uToken=%d,request=%d,slot_id=%d,error_code=%d",resp_type,client.uToken,request,slot_id,error);
+ free_parcel(p);
+ return error;
+}
diff --git a/common_src/lib/liblynq-data/lynq_data_urc.cpp b/common_src/lib/liblynq-data/lynq_data_urc.cpp
new file mode 100755
index 0000000..c3d95c6
--- /dev/null
+++ b/common_src/lib/liblynq-data/lynq_data_urc.cpp
@@ -0,0 +1,331 @@
+#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 <list>
+#include "lynq_data.h"
+#include "lynq_data_urc.h"
+#include "liblog/lynq_deflog.h"
+#include "lynq_shm.h"
+
+#define LYNQ_REC_BUF 8192
+
+static std::list<Parcel*> s_urc_recv_parcel_list;
+
+int lynq_len_urc_addr_serv;
+struct sockaddr_in urc_local_addr;
+static int lynq_urc_sockfd = -1;
+bool data_urc_recive_status = 1;
+static pthread_mutex_t s_lynq_urc_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_lynq_urc_cond = PTHREAD_COND_INITIALIZER;
+
+/*recv*/
+pthread_t data_urc_recv_tid = -1;
+static pthread_mutex_t s_lynq_urc_recv_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_lynq_urc_recv_cond = PTHREAD_COND_INITIALIZER;
+
+/*process*/
+pthread_t data_urc_process_tid = -1;
+bool data_urc_process_status = 1;
+static pthread_mutex_t s_lynq_urc_process_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_lynq_urc_process_cond = PTHREAD_COND_INITIALIZER;
+
+#define SHM_BUFFER_INDEX_OFFSET 1
+#define SHM_BUFFER_SIZE_OFFSET 16
+#define SHM_BUFFER_INDEX_MASK 0x0000007F
+#define SHM_BUFFER_SIZE_MASK 0x0000FFFF
+
+bool urc_data_is_in_shm_data(int responseType,int& level, int& index, int& size)
+{
+ int shm_index=((responseType>>SHM_BUFFER_INDEX_OFFSET)&SHM_BUFFER_INDEX_MASK);
+ if (shm_index>0)
+ {
+ index=shm_index-1;
+ size=((responseType>>SHM_BUFFER_SIZE_OFFSET)&SHM_BUFFER_SIZE_MASK);
+ if(size>=sizeof(int32_t)*3 && get_shem_buffer_level(size,&level))
+ {
+ LYINFLOG("urc_data_is_in_shm_data level is %d, index is %d size is %d",level,index,size);
+ return true;
+ }
+ }
+ LYINFLOG("urc_data_is_in_shm_data return false, responseType is %d",responseType);
+ return false;
+}
+
+void cleanup_urc_process_mutex(void *arg)
+{
+ pthread_mutex_unlock(&s_lynq_urc_process_mutex);
+}
+
+void *thread_urc_recv()
+{
+ Parcel *urc_p =NULL;
+ char urc_data[LYNQ_REC_BUF];
+ int res = 0;
+ lynq_head_t* phead;
+ int level,index,size;
+ uint8_t * shm_buffer;
+
+ LYINFLOG("urc recv thread is running");
+ while(data_urc_recive_status)
+ {
+ bzero(urc_data,LYNQ_REC_BUF);
+ res = recvfrom(lynq_urc_sockfd,urc_data,sizeof(urc_data),0,(struct sockaddr *)&urc_local_addr,(socklen_t*)&lynq_len_urc_addr_serv);
+ if(res<sizeof(int32_t)*2)
+ {
+ LYERRLOG("thread_urc_recv step2 fail: res is %d",res);
+ continue;
+ }
+
+ phead=(lynq_head_t*) urc_data;
+ if(is_support_urc(phead->urcid)==false)
+ {
+ continue;
+ }
+ urc_p = new Parcel();
+ if(urc_p == NULL)
+ {
+ LYERRLOG("new parcel failure!!!");
+ continue;
+ }
+ if(urc_data_is_in_shm_data(phead->resp_type,level,index,size))
+ {
+ shm_buffer = (uint8_t *)get_shem_buffer(level,index); // p.setData((uint8_t *) buffer, buflen);
+ LYINFLOG("shm pointer is %p", shm_buffer);
+ urc_p->setData(shm_buffer,size);
+ }
+ else if(res>=sizeof(int32_t)*3)
+ {
+ urc_p->setData((uint8_t *)urc_data,res); // p.setData((uint8_t *) buffer, buflen);
+ }
+ else
+ {
+ LYERRLOG("res %d error!!!", res);
+ delete urc_p;
+ urc_p = NULL;
+ continue;
+ }
+ urc_p->setDataPosition(0);
+ if(urc_p->dataAvail()>0)
+ {
+ pthread_mutex_lock(&s_lynq_urc_process_mutex);
+ s_urc_recv_parcel_list.push_back(urc_p);
+ pthread_cond_broadcast(&s_lynq_urc_process_cond);
+ pthread_mutex_unlock(&s_lynq_urc_process_mutex);
+ }
+ else
+ {
+ delete urc_p;
+ urc_p = NULL;
+ }
+ }
+ LYINFLOG("urc recv thread ended");
+ return NULL;
+}
+
+void *thread_urc_process()
+{
+ Parcel *urc_p =NULL;
+ std::list<Parcel*>::iterator iter;
+
+ LYINFLOG("urc process thread is running");
+ pthread_cleanup_push(cleanup_urc_process_mutex, NULL); // thread cleanup handler
+ while (data_urc_process_status)
+ {
+ pthread_mutex_lock(&s_lynq_urc_process_mutex);
+ while(s_urc_recv_parcel_list.empty())
+ {
+ pthread_cond_wait(&s_lynq_urc_process_cond,&s_lynq_urc_process_mutex);
+ }
+ iter=s_urc_recv_parcel_list.begin();
+ urc_p = (*iter);
+ s_urc_recv_parcel_list.erase(iter);
+ pthread_mutex_unlock(&s_lynq_urc_process_mutex);
+ urc_p->setDataPosition(0);
+ if(urc_p->dataAvail()>0)
+ {
+ pthread_mutex_lock(&s_lynq_urc_mutex);
+ urc_msg_process(urc_p);
+ pthread_mutex_unlock(&s_lynq_urc_mutex);
+ }
+ delete urc_p;
+ urc_p = NULL;
+ }
+ pthread_cleanup_pop(0);
+ LYINFLOG("urc process thread ended");
+ return NULL;
+}
+
+int lynq_socket_recv_start()
+{
+ int rt=0;
+ int on=1;
+ struct sockaddr_in urc_local_addr;
+ pthread_attr_t attr;
+ lynq_urc_sockfd = socket(AF_INET,SOCK_DGRAM,0);
+ lynq_len_urc_addr_serv = sizeof(urc_local_addr);
+ if(lynq_urc_sockfd < 0)
+ {
+ LYERRLOG("create socket for udp fail");
+ return -1;
+ }
+ urc_local_addr.sin_family = AF_INET;
+ urc_local_addr.sin_port = htons(LYNQ_URC_SERVICE_PORT);
+ urc_local_addr.sin_addr.s_addr = htons(INADDR_ANY);
+ /* Set socket to allow reuse of address and port, SO_REUSEADDR value is 2*/
+ rt = setsockopt(lynq_urc_sockfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof on);
+ if(rt<0)
+ {
+ LYERRLOG("SO_REUSEADDR fail");
+ close(lynq_urc_sockfd);
+ lynq_urc_sockfd = -1;
+ return -1;
+ }
+ rt = bind(lynq_urc_sockfd ,(struct sockaddr*)&urc_local_addr, sizeof(urc_local_addr));
+ if (rt == -1)
+ {
+ LYERRLOG("bind failed");
+ close(lynq_urc_sockfd);
+ lynq_urc_sockfd = -1;
+ return -1;
+ }
+ return 0;
+}
+
+int lynq_socket_recv_stop()
+{
+ if (lynq_urc_sockfd >=0)
+ {
+ close(lynq_urc_sockfd);
+ lynq_urc_sockfd = -1;
+ }
+ return 0;
+}
+
+void lynq_urc_recv_thread_stop()
+{
+ int ret;
+
+ pthread_mutex_lock(&s_lynq_urc_process_mutex);
+ data_urc_recive_status = 0;
+ if (data_urc_recv_tid != -1)
+ {
+ ret = pthread_cancel(data_urc_recv_tid);
+ LYDBGLOG("pthread cancel ret = %d",ret);
+ }
+ pthread_mutex_unlock(&s_lynq_urc_process_mutex);
+
+ if (data_urc_recv_tid != -1)
+ {
+ ret = pthread_join(data_urc_recv_tid,NULL);
+ LYDBGLOG("pthread join ret = %d",ret);
+ data_urc_recv_tid = -1;
+ }
+}
+
+void lynq_urc_process_thread_stop()
+{
+ int ret;
+
+ pthread_mutex_lock(&s_lynq_urc_process_mutex);
+ pthread_mutex_lock(&s_lynq_urc_mutex);
+
+ data_urc_process_status = 0;
+ if (data_urc_process_tid != -1)
+ {
+ ret = pthread_cancel(data_urc_process_tid);
+ LYDBGLOG("pthread cancel ret = %d",ret);
+ }
+ pthread_mutex_unlock(&s_lynq_urc_mutex);
+ pthread_mutex_unlock(&s_lynq_urc_process_mutex);
+
+ if (data_urc_process_tid != -1)
+ {
+ ret = pthread_join(data_urc_process_tid,NULL);
+ LYDBGLOG("pthread join ret = %d",ret);
+ data_urc_process_tid = -1;
+ }
+}
+
+
+int lynq_init_data_urc_thread()
+{
+ int ret = 0;
+ if(ril_init_mem()!=0)
+ {
+ LYERRLOG("ril_init_mem fail");
+ return -1;
+ }
+
+ ret = lynq_socket_recv_start();
+ if (ret != 0)
+ {
+ LYERRLOG("lynq_socket_recv_start fail");
+ ril_deinit_mem();
+ return -1;
+ }
+
+ pthread_mutex_init(&s_lynq_urc_process_mutex,NULL);
+ pthread_mutex_init(&s_lynq_urc_recv_mutex,NULL);
+
+ pthread_mutex_lock(&s_lynq_urc_process_mutex);
+ std::list<Parcel*>::iterator iter;
+ for (iter=s_urc_recv_parcel_list.begin();iter!=s_urc_recv_parcel_list.end();++iter)
+ {
+ delete(*iter);
+ }
+ s_urc_recv_parcel_list.clear();
+ pthread_mutex_unlock(&s_lynq_urc_process_mutex);
+
+ pthread_mutex_init(&s_lynq_urc_mutex,NULL);
+ data_urc_recive_status = 1;
+
+ ret = pthread_create(&data_urc_recv_tid,NULL,thread_urc_recv,NULL);
+ if (ret < 0)
+ {
+ LYERRLOG("urc recv pthread create error");
+ data_urc_recive_status = 0;
+ lynq_socket_recv_stop();
+ ril_deinit_mem();
+ return -1;
+ }
+
+ data_urc_process_status = 1;
+ ret = pthread_create(&data_urc_process_tid,NULL,thread_urc_process,NULL);
+ if (ret < 0)
+ {
+ LYERRLOG("urc recv pthread create error");
+
+ data_urc_process_status = 0;
+ lynq_socket_recv_stop();
+ lynq_urc_recv_thread_stop();
+
+ return -1;
+ }
+ return 0;
+}
+
+int lynq_deinit_data_urc_thread()
+{
+ lynq_socket_recv_stop();
+ lynq_urc_recv_thread_stop();
+ lynq_urc_process_thread_stop();
+
+ pthread_mutex_lock(&s_lynq_urc_process_mutex);
+ std::list<Parcel*>::iterator iter;
+ for (iter=s_urc_recv_parcel_list.begin();iter!=s_urc_recv_parcel_list.end();++iter)
+ {
+ delete(*iter);
+ }
+ s_urc_recv_parcel_list.clear();
+ pthread_mutex_unlock(&s_lynq_urc_process_mutex);
+
+ ril_deinit_mem();
+ return 0;
+}
diff --git a/common_src/lib/liblynq-data/lynq_data_urc.h b/common_src/lib/liblynq-data/lynq_data_urc.h
new file mode 100755
index 0000000..59f9f9d
--- /dev/null
+++ b/common_src/lib/liblynq-data/lynq_data_urc.h
@@ -0,0 +1,31 @@
+#ifndef LYNQ_DATA_URC_H
+#define LYNQ_DATA_URC_H
+
+using ::android::Parcel;
+
+#define LYNQ_URC_SERVICE_PORT 8086
+
+/*the same with lynq_interface.h begin*/
+#define LYNQ_REQUEST_VENDOR_BASE 8000
+#define LYNQ_URC_VENDOR_BASE 9000
+#define LYNQ_AT_SNED (LYNQ_REQUEST_VENDOR_BASE +1)
+#define LYNQ_URC_CALL_STATUS_IND (LYNQ_URC_VENDOR_BASE+1)
+#define LYNQ_URC_DATA_STATUS_IND (LYNQ_URC_VENDOR_BASE+2)
+#define LYNQ_URC_DATA_CALL_STATUS_IND (LYNQ_URC_VENDOR_BASE+3)
+#define LYNQ_AUTO_ANSWER_CALL (LYNQ_REQUEST_VENDOR_BASE +2)
+#define LYNQ_REQUEST_SET_DTMF_VOLUME (LYNQ_REQUEST_VENDOR_BASE +3)
+#define LYNQ_URC_MODIFY_APNDB (LYNQ_URC_VENDOR_BASE+4)
+#define LYNQ_URC_RESET_APNDB (LYNQ_URC_VENDOR_BASE+5)
+#define LYNQ_TELEPHONY_RESTART 3113
+
+typedef struct{
+ int resp_type;
+ int urcid;
+}lynq_head_t;
+
+int lynq_init_data_urc_thread();
+int lynq_deinit_data_urc_thread();
+bool is_support_urc(int urc_id);
+void urc_msg_process(Parcel *p);
+
+#endif
\ No newline at end of file
diff --git a/common_src/lib/liblynq-data/makefile b/common_src/lib/liblynq-data/makefile
new file mode 100755
index 0000000..e2d17d0
--- /dev/null
+++ b/common_src/lib/liblynq-data/makefile
@@ -0,0 +1,73 @@
+SHELL = /bin/sh
+RM = rm -f
+
+LOCAL_CFLAGS := -Wall \
+ -std=gnu++14 \
+ -g -Os \
+ -flto \
+ -fPIC \
+ -fpermissive \
+
+
+
+$(warning ################# lynq data demo ROOT: $(ROOT),includedir:$(includedir))
+LOCAL_PATH = .
+
+LOCAL_C_INCLUDES = \
+ -I. \
+ -I$(LOCAL_PATH)/include/libdata \
+ -I$(ROOT)$(includedir)/lynq_shm \
+ -I$(ROOT)$(includedir)/logger \
+ -I$(ROOT)$(includedir)/liblog \
+
+
+LOCAL_LIBS := \
+ -L. \
+ -ldl \
+ -lstdc++ \
+ -llog \
+ -lcutils \
+ -lutils \
+ -lbinder \
+ -lpthread \
+ -llynq-log \
+ -llynq-uci \
+ -llynq-shm \
+
+ifeq ($(strip $(MOBILETEK_RIL_CFG)), GSW)
+ LOCAL_CFLAGS += -DGSW_RIL_CFG
+
+endif
+
+SOURCES = $(wildcard *.cpp)
+
+EXECUTABLE = liblynq-data.so
+
+OBJECTS=$(SOURCES:.cpp=.o)
+
+
+.PHONY: build clean install pack_rootfs
+all: build
+$(EXECUTABLE): $(OBJECTS)
+ $(CXX) -shared -Wl,--no-undefined $(OBJECTS) $(LOCAL_LIBS) $(LOCAL_CFLAGS) $(LOCAL_C_INCLUDES) -o $@
+
+%.o : %.cpp
+ $(CXX) $(LOCAL_C_INCLUDES) $(LOCAL_CFLAGS) $(LOCAL_LIBS) -o $@ -c $<
+
+build: $(EXECUTABLE)
+ $(warning ########## build $(EXECUTABLE) ##########)
+install:
+ mkdir -p $(ROOT)$(base_libdir)/
+ install $(EXECUTABLE) $(ROOT)$(base_libdir)/
+ mkdir -p $(ROOT)$(includedir)/$(NAME)/sdk
+pack_rootfs:
+ mkdir -p $(PACK_INITRAMFS_TO)$(base_libdir)/
+ cp -af $(EXECUTABLE) $(PACK_INITRAMFS_TO)$(base_libdir)/
+ $(CROSS)strip $(PACK_INITRAMFS_TO)$(base_libdir)/$(EXECUTABLE)
+ mkdir -p $(PACK_TO)$(base_libdir)/
+ cp -af $(EXECUTABLE) $(PACK_TO)$(base_libdir)/
+ $(CROSS)strip $(PACK_TO)$(base_libdir)/$(EXECUTABLE)
+.PHONY: clean
+clean:
+ $(RM) $(OBJECTS) $(EXECUTABLE)
+ -find . -name "*.o" -delete