[Bugfix][API-616][network] lynq_set_state_buffer_valid_period_of_network set exception value, no error return
Change-Id: Id05a3493e98ecfd375b4dcf0e96e2e2c3936f97c
diff --git a/lib/liblynq-network/include/lynq_network/lynq_network.h b/lib/liblynq-network/include/lynq_network/lynq_network.h
index 5b2ce3c..fbd121e 100755
--- a/lib/liblynq-network/include/lynq_network/lynq_network.h
+++ b/lib/liblynq-network/include/lynq_network/lynq_network.h
@@ -72,7 +72,6 @@
int lynq_set_ims(const int ims_mode);
int lynq_wait_signalchanges(int *handle);
int lynq_get_urc_info(const int handle,signalStrength_t *solSigStren,int *slot_id);
-
typedef enum {
NETWORK_STATE_BUFFER_TYPE_VOICE_REG,
NETWORK_STATE_BUFFER_TYPE_DATA_REG,
diff --git a/lib/liblynq-network/lynq_network.cpp b/lib/liblynq-network/lynq_network.cpp
index cca772f..7d33b31 100755
--- a/lib/liblynq-network/lynq_network.cpp
+++ b/lib/liblynq-network/lynq_network.cpp
@@ -51,7 +51,303 @@
LYLOGSET(LOG_INFO);
LYLOGEINIT(USER_LOG_TAG);
- int ret;
+ client.uToken = network_Global_uToken;
+ network_Global_uToken=(network_Global_uToken+1)%10000;/*0-10000*/
+ client.request = request_id;
+ client.paramLen = argc;
+ bzero(client.param,LYNQ_REQUEST_PARAM_BUF);
+ if(argc!=0)
+ {
+ va_list args;
+ va_start(args, format);
+ vsnprintf(client.param, LYNQ_REQUEST_PARAM_BUF, format, args);
+ va_end(args);
+ }
+ LYINFLOG("uToken=%d,request=%d,paralen=%d,param=%s",client.uToken,client.request,client.paramLen,client.param);
+ pthread_mutex_lock(&g_lynq_network_sendto_mutex);
+ if(g_inner_test==0)
+ {
+ send_num = sendto(network_sock_fd,&client,sizeof(client),0,(struct sockaddr *)&network_addr_serv,network_len_addr_serv);
+ }
+ else
+ {
+ send_num = 1;
+ g_inner_test = 0;
+ }
+ pthread_mutex_unlock(&g_lynq_network_sendto_mutex);
+
+ if(send_num <= 0)
+ {
+ LYERRLOG("send request fail, send num is %d", send_num);
+ return -1;
+ }
+ ret = waitResponse(p, client.uToken,time_out);
+
+ return ret;
+}
+
+
+int wait_signal_changes()
+{
+ int ret = 0;
+ pthread_mutex_lock(&signal_state_change_mutex);
+ ret = pthread_cond_wait(&signal_state_change_cond,&signal_state_change_mutex);
+ pthread_mutex_unlock(&signal_state_change_mutex);
+ return 0;
+}
+
+void send_signal_changes()
+{
+ pthread_mutex_lock(&signal_state_change_mutex);
+ pthread_cond_signal(&signal_state_change_cond);
+ pthread_mutex_unlock(&signal_state_change_mutex);
+ return;
+}
+
+/**@ a thread just for recv\buffer solicited msg's response and notice waiting thread
+* @param p [IN]: no meaning
+* @return
+* always null
+*/
+void *thread_rc_recv(void *p)
+{
+ Parcel* rc_p;
+ std::list<Parcel*>::iterator iter;
+ int resp_type = -1;
+ char rc_data[LYNQ_REC_BUF];
+ int rc_len;
+ int null_cnt=0;
+ int wakeup_token;
+
+ LYINFLOG("rc thread is running");
+ while(network_rc_status)
+ {
+ bzero(rc_data,LYNQ_REC_BUF);
+ while(true)
+ {
+ rc_len = recvfrom(network_sock_fd,rc_data,sizeof(rc_data),0,(struct sockaddr *)&network_addr_serv,(socklen_t *)&network_len_addr_serv);
+ if(rc_len<sizeof(int32_t)*2)
+ {
+ LYERRLOG("%s recv len %d less %d",__func__, rc_len,sizeof(int)*2);
+ continue;
+ }
+ rc_p= new Parcel;
+ if(rc_p==NULL)
+ {
+ null_cnt++;
+ LYERRLOG("%s rc_p is NULL, cnt is %d",__func__, null_cnt);
+ if(null_cnt>20)
+ {
+ goto rc_recv_end;
+ }
+ continue;
+ }
+ else
+ {
+ null_cnt=0;
+ }
+
+ rc_p->setData((uint8_t *)rc_data,rc_len); // p.setData((uint8_t *) buffer, buflen);
+ rc_p->setDataPosition(0);
+ if(rc_p->dataAvail()>0)
+ {
+ rc_p->readInt32(&resp_type);
+ rc_p->readInt32(&wakeup_token);
+ BLOCK_RC_MSG_LOCK();
+ g_recv_parcel_list.push_back(rc_p);
+ LYINFLOG("%s wakeup token is %d, list size is %d!",__func__,wakeup_token,g_recv_parcel_list.size());
+ if(g_recv_parcel_list.size()>20) //max 20
+ {
+ iter=g_recv_parcel_list.begin();
+ (*iter)->setDataPosition(0);
+ (*iter)->readInt32(&resp_type);
+ (*iter)->readInt32(&wakeup_token);
+ delete (*(g_recv_parcel_list.begin()));
+ LYERRLOG("%s wakeup token %d is deleted!",__func__,wakeup_token);
+ g_recv_parcel_list.erase(iter);
+ }
+ BLOCK_WAKEUP_RECV_MSG();
+ BLOCK_RC_MSG_UNLOCK();
+ break;
+ }
+ else
+ {
+ LYERRLOG("%s rc_p data Avail %d not greater than 0",__func__, rc_p->dataAvail());
+ delete rc_p;
+ }
+ }
+ }
+
+rc_recv_end:
+ return NULL;
+}
+
+void *thread_urc_recv(void *p)
+{
+ Parcel *urc_p =NULL;
+ char urc_data[LYNQ_REC_BUF];
+ int resp_type = -1;
+ int urc_id = -1;
+ int res = 0;
+ int none = 0;
+ int NR_sum = 0;
+ int urc_LTE_signalstrength = 0;
+ int urc_WCDMA_signalstrength = 0;
+ LYINFLOG("urc thread is running");
+ while(network_urc_status)
+ {
+ bzero(urc_data,LYNQ_REC_BUF);
+ res = recvfrom(network_urc_sock_fd,urc_data,sizeof(urc_data),0,(struct sockaddr *)&network_urc_addr_serv,(socklen_t*)&network_len_urc_addr_serv);
+ if(res<=0)
+ {
+ LYERRLOG("thread_urc_recv step2 fail:");
+ break;
+ }
+ urc_p = new Parcel();
+ if(urc_p == NULL)
+ {
+ LYERRLOG("new parcel failure!!!");
+ break;
+ }
+ urc_p->setData((uint8_t *)urc_data,res); // p.setData((uint8_t *) buffer, buflen);
+ urc_p->setDataPosition(0);
+ if(urc_p->dataAvail()>0)
+ {
+ urc_p->readInt32(&resp_type);
+ urc_p->readInt32(&urc_id);
+ urc_p->readInt32(&network_urc_slot_id);
+ switch(urc_id)
+ {
+ case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED:
+ {
+ set_state_buffer_valid(NETWORK_STATE_BUFFER_TYPE_VOICE_REG,false);
+ network_wait_urc_id = urc_id;
+ LYINFLOG("slot_id = %d",network_urc_slot_id);
+ send_signal_changes();
+ break;
+ }
+ case RIL_UNSOL_RESPONSE_PS_NETWORK_STATE_CHANGED:
+ {
+ set_state_buffer_valid(NETWORK_STATE_BUFFER_TYPE_DATA_REG,false);
+ network_wait_urc_id = urc_id;
+ LYINFLOG("slot_id = %d",network_urc_slot_id);
+ send_signal_changes();
+ break;
+ }
+ case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED:
+ {
+ set_state_buffer_valid(NETWORK_STATE_BUFFER_TYPE_IMS_REG,false);
+ network_wait_urc_id = urc_id;
+ LYINFLOG("slot_id = %d",network_urc_slot_id);
+ send_signal_changes();
+ break;
+ }
+ case RIL_UNSOL_SIGNAL_STRENGTH:
+ {
+ urc_p->readInt32(&network_urc_solSigStren.rssi);
+ if((network_urc_solSigStren.rssi!=99)&&(network_urc_solSigStren.rssi!=0))
+ {
+ network_urc_solSigStren.gw_sig_valid = 1;
+ }else{
+ network_urc_solSigStren.gw_sig_valid = 0;
+ }
+ if(network_urc_solSigStren.gw_sig_valid == 1)
+ {
+ LYINFLOG("urc_GSM_signalstrength:%d",network_urc_solSigStren.rssi);
+ }
+ urc_p->readInt32(&none);
+ urc_p->readInt32(&none);
+ urc_p->readInt32(&none);
+ urc_p->readInt32(&none);
+ urc_p->readInt32(&none);
+ urc_p->readInt32(&none);
+ urc_p->readInt32(&none);
+ urc_p->readInt32(&urc_LTE_signalstrength);
+ // p.readInt32(&solSigStren->signalStrength.LTE_SignalStrength.signalStrength);
+ urc_p->readInt32(&network_urc_solSigStren.rsrp);
+ urc_p->readInt32(&network_urc_solSigStren.rsrq);
+ urc_p->readInt32(&network_urc_solSigStren.rssnr);
+ if((urc_LTE_signalstrength!=99)&&(urc_LTE_signalstrength!=0))
+ {
+ network_urc_solSigStren.lte_sig_valid = 1;
+ }else{
+ network_urc_solSigStren.lte_sig_valid = 0;
+ }
+ if(network_urc_solSigStren.lte_sig_valid == 1)
+ {
+ LYINFLOG("urc_LTE_signalstrength:%d",urc_LTE_signalstrength);
+ }
+ urc_p->readInt32(&none);
+ urc_p->readInt32(&none);
+ urc_p->readInt32(&none);
+ urc_p->readInt32(&none);
+ urc_p->readInt32(&none);
+ urc_p->readInt32(&urc_WCDMA_signalstrength);
+ urc_p->readInt32(&none);
+ urc_p->readInt32(&network_urc_solSigStren.rscp);
+ urc_p->readInt32(&network_urc_solSigStren.ecno);
+ if((urc_WCDMA_signalstrength!=99)&&(urc_WCDMA_signalstrength!=0))
+ {
+ network_urc_solSigStren.wcdma_sig_valid = 1;
+ }else{
+ network_urc_solSigStren.wcdma_sig_valid = 0;
+ }
+ if(network_urc_solSigStren.wcdma_sig_valid == 1)
+ {
+ LYINFLOG("urc_WCDMA_signalstrength:%d",urc_WCDMA_signalstrength);
+ }
+ urc_p->readInt32(&network_urc_solSigStren.ssRsrp);
+ urc_p->readInt32(&network_urc_solSigStren.ssRsrq);
+ urc_p->readInt32(&network_urc_solSigStren.ssSinr);
+ urc_p->readInt32(&network_urc_solSigStren.csiRsrp);
+ urc_p->readInt32(&network_urc_solSigStren.csiRsrq);
+ urc_p->readInt32(&network_urc_solSigStren.csiSinr);
+ NR_sum = (network_urc_solSigStren.ssRsrp) + (network_urc_solSigStren.ssRsrq) + (network_urc_solSigStren.ssSinr) + (network_urc_solSigStren.csiRsrp)+\
+ (network_urc_solSigStren.csiRsrq) + (network_urc_solSigStren.csiSinr);
+ if(NR_sum != 0)
+ {
+ network_urc_solSigStren.nr_sig_valid = 1;
+ }else{
+ network_urc_solSigStren.nr_sig_valid = 0;
+ }
+ if(network_urc_solSigStren.nr_sig_valid == 1)
+ {
+ LYINFLOG("[NR signal]ssRsrp is %d , ssRsrq is %d , ssSinr is %d , csiRsrp is %d , csiRsrq is %d , csiSinr is %d",\
+ network_urc_solSigStren.ssRsrp,network_urc_solSigStren.ssRsrq,network_urc_solSigStren.ssSinr, \
+ network_urc_solSigStren.csiRsrp,network_urc_solSigStren.csiRsrq,network_urc_solSigStren.csiSinr);
+ }
+ network_wait_urc_id = urc_id;
+ send_signal_changes();
+ break;
+ }
+ }
+ }
+ delete urc_p;
+ urc_p = NULL;
+ }
+ return NULL;
+}
+
+int lynq_server_socket_start()
+{
+// struct timeval timeOut;
+ network_sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if(-1 == network_sock_fd)
+ {
+ LYERRLOG("socket open error");
+ return -1;
+ }
+# if 0
+ timeOut.tv_sec = 5;
+ timeOut.tv_usec = 0;
+ if (setsockopt(network_sock_fd, SOL_SOCKET, SO_RCVTIMEO, &timeOut, sizeof(timeOut)) < 0)
+ {
+ LYERRLOG("time out setting failed\n");
+ return -1;
+ }
+#endif
+
+ LYINFLOG("network_sock_fd = %d",network_sock_fd);
init_network_timer_all();
@@ -507,14 +803,46 @@
p->readInt32(&num);
if(num == 15)
{
- for(i=0;i<15;i++)
+ p->readInt32(&num);
+ if(num == 15)
+ {
+ *regState = atoi(lynqStrdupReadString(p));
+ lynqStrdupReadString(p);
+ lynqStrdupReadString(p);
+ *netType = atoi(lynqStrdupReadString(p));
+ lynqStrdupReadString(p);
+ lynqStrdupReadString(p);
+ lynqStrdupReadString(p);
+ lynqStrdupReadString(p);
+ lynqStrdupReadString(p);
+ lynqStrdupReadString(p);
+ lynqStrdupReadString(p);
+ lynqStrdupReadString(p);
+ lynqStrdupReadString(p);
+ lynqStrdupReadString(p);
+ *netRejected = atoi(lynqStrdupReadString(p));
+ set_state_to_buf(NETWORK_STATE_BUFFER_TYPE_VOICE_REG,3,*regState,*netType,*netRejected,0);
+ }
+ else
{
resp[i]=lynqStrdupReadString(p);
}
- *regState = atoi(resp[0]);
- *netType = atoi(resp[3]);
- *netRejected = atoi(resp[14]);
- for(i=0;i<15;i++)
+ }
+ else if(!strcmp(str,"DATA")){
+ p->readInt32(&num);
+ if(num == 11)
+ {
+ char *resp[LYNQ_RESP_BUF];
+ *regState = atoi(lynqStrdupReadString(p));
+ resp[0] = lynqStrdupReadString(p);
+ strcpy(LAC,resp[0]);
+
+ resp[1] = lynqStrdupReadString(p);
+ strcpy(CID,resp[1]);
+ *netType = atoi(lynqStrdupReadString(p));
+ set_state_to_buf(NETWORK_STATE_BUFFER_TYPE_DATA_REG,2,*regState,*netType,2,LAC,CID);
+ }
+ else
{
if(resp[i]!=NULL)
{
@@ -536,13 +864,11 @@
{
for(i=0;i<4;i++)
{
- resp[i]=lynqStrdupReadString(p);
- }
- *regState = atoi(resp[0]);
- strcpy(LAC,resp[1]);
- strcpy(CID,resp[2]);
- *netType = atoi(resp[3]);
- for(i=0;i<4;i++)
+ p->readInt32(imsRegState);
+ p->readInt32(radioTechFam);
+ set_state_to_buf(NETWORK_STATE_BUFFER_TYPE_IMS_REG,2,*imsRegState,*radioTechFam,0);
+ }
+ else
{
if(resp[i]!=NULL)
{
diff --git a/lib/liblynq-network/lynq_network_state_buffer.cpp b/lib/liblynq-network/lynq_network_state_buffer.cpp
new file mode 100755
index 0000000..7b41533
--- /dev/null
+++ b/lib/liblynq-network/lynq_network_state_buffer.cpp
@@ -0,0 +1,386 @@
+#include <stdio.h>
+#include <stdint.h> /*just for uint64_t in lynq_query_cell_info 20220819 hq*/
+#include <sys/types.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <signal.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <climits>
+#include "liblog/lynq_deflog.h"
+#include "lynq_network.h"
+#include "lynq_network_state_buffer.h"
+
+#define USER_LOG_TAG "LYNQ_NETWORK"
+
+static timer_t s_state_buffer_timer[NETWORK_STATE_BUFFER_TYPE_MAX];
+
+static int s_state_buffer_sig_value[NETWORK_STATE_BUFFER_TYPE_MAX]={2,3,4};
+
+static int s_state_buffer_valid[NETWORK_STATE_BUFFER_TYPE_MAX]={false,false,false};
+
+static char* s_state_buffer_file[NETWORK_STATE_BUFFER_TYPE_MAX]={
+ "/data/ril/network/.network_register_voice_buffer",
+ "/data/ril/network/.network_register_data_buffer",
+ "/data/ril/network/.network_register_ims_buffer"
+};
+
+#define STATE_BUFFER_CONFIG_FILE "/data/ril/network/.state_buffer_cfg"
+typedef struct{
+ int valid_period[NETWORK_STATE_BUFFER_TYPE_MAX];
+}network_state_buffer_cfg;
+static network_state_buffer_cfg s_state_buffer_cfg;
+static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
+
+void get_state_buffer_timer_length_from_file()
+{
+ int fd_backup;
+ int ret;
+ memset(&s_state_buffer_cfg,0,sizeof (s_state_buffer_cfg));
+ fd_backup = open(STATE_BUFFER_CONFIG_FILE,O_RDONLY | O_CREAT,0777);
+ if (fd_backup < 0) {
+ LYERRLOG("%s open file faile, error is %s\n",__func__,strerror(errno));
+ return;
+ }
+
+ ret = read(fd_backup,&s_state_buffer_cfg,sizeof (s_state_buffer_cfg));
+ if(ret<=0)
+ {
+ LYERRLOG("%s read fail, ret is %d",__func__,ret);
+ memset(&s_state_buffer_cfg,0,sizeof (s_state_buffer_cfg));
+ }
+ else
+ {
+ LYINFLOG("%s suc",__func__);
+ }
+ close(fd_backup);
+
+ return;
+}
+
+int set_state_buffer_timer_length_to_file()
+{
+ int fd_backup;
+ int ret;
+ fd_backup = open(STATE_BUFFER_CONFIG_FILE,O_WRONLY | O_CREAT,0777);
+ if (fd_backup < 0) {
+ LYERRLOG("%s open file fail, error is %s\n",__func__,strerror(errno));
+ return -1;
+ }
+
+ ret = write(fd_backup,&s_state_buffer_cfg,sizeof (s_state_buffer_cfg));
+ if(ret<=0)
+ {
+ LYERRLOG("%s write fail, ret is %d",__func__,ret);
+ }
+ else
+ {
+ LYINFLOG("%s suc",__func__);
+ }
+ close(fd_backup);
+
+ return ret>0? 0:-2;
+}
+
+void start_network_timer(timer_t timer, int signal_value, int milliseconds) {
+ LYINFLOG("start_network_timer(), timer_id=%ld, signal_value=%d, time=%d",(long)timer, signal_value, milliseconds);
+
+ struct itimerspec expire;
+ expire.it_interval.tv_sec = 0;
+ expire.it_interval.tv_nsec = 0;
+ expire.it_value.tv_sec = milliseconds/1000;
+ expire.it_value.tv_nsec = (milliseconds%1000)*1000000;
+ if (timer_settime(timer, 0, &expire, NULL) == -1) {
+ LYERRLOG("timer_settime failed reason=[%s]", strerror(errno));
+ }
+}
+
+void stop_network_timer(timer_t timer, int signal_value) {
+ LYINFLOG("stop_network_timer(), timer_id=%ld, signal_value=%d", (long)timer, signal_value);
+ struct itimerspec timespec;
+ if(timer_gettime(timer, ×pec) == -1) {
+ LYERRLOG("stop_network_timer(), get time fail(%s)", strerror(errno));
+ return;
+ }
+ LYINFLOG("stop_network_timer(), tv_sec=%ld, tv_nsec=%ld",timespec.it_value.tv_sec, timespec.it_value.tv_nsec);
+ if((timespec.it_value.tv_sec == 0) && (timespec.it_value.tv_nsec == 0) ) {
+ LYINFLOG("stop_network_timer(), timer_id(%ld) had stopped, just return", (long)timer);
+ return;
+ } else {
+ start_network_timer(timer, signal_value, 0);
+ }
+}
+
+void network_timer_handler(sigval_t sig) {
+ LYINFLOG("network_timer_handler, sig_value: %d", sig.sival_int);
+ int s;
+ s = pthread_mutex_lock(&mtx);
+ if(s != 0) {
+ LYERRLOG("network_timer_handler, pthead_mutex_lock fail");
+ }
+ for(int i=0;i<NETWORK_STATE_BUFFER_TYPE_MAX;i++)
+ {
+ if(sig.sival_int == s_state_buffer_sig_value[i])
+ {
+ s_state_buffer_valid[i]=false;
+ break;
+ }
+ }
+ s = pthread_mutex_unlock(&mtx);
+ if(s != 0) {
+ LYERRLOG("network_timer_handler, pthread_mutex_unlock fail");
+ }
+}
+
+void init_network_timer(timer_t* timer, int signal_value)
+{
+ struct sigevent sevp;
+ memset(&sevp, 0, sizeof(sevp));
+ sevp.sigev_value.sival_int = signal_value;
+ sevp.sigev_notify = SIGEV_THREAD;
+ sevp.sigev_notify_function = network_timer_handler;
+
+ if(timer_create(CLOCK_MONOTONIC, &sevp, timer) == -1) {
+ LYERRLOG("init_network_timer() failed reason=[%s]", strerror(errno));
+ }
+ LYINFLOG("init_network_timer(), timer_Id = %ld, signal_value=%d", (long)(*timer), signal_value);
+}
+
+void init_network_timer_all() {
+
+ for(int i=0;i<NETWORK_STATE_BUFFER_TYPE_MAX;i++){
+ init_network_timer(&s_state_buffer_timer[i],s_state_buffer_sig_value[i]);
+ s_state_buffer_valid[i] = false;
+ }
+ get_state_buffer_timer_length_from_file();
+}
+
+void deinit_network_timer_all()
+{
+ for(int i=0;i<NETWORK_STATE_BUFFER_TYPE_MAX;i++){
+ stop_network_timer(&s_state_buffer_timer[i],s_state_buffer_sig_value[i]);
+ s_state_buffer_valid[i] = false;
+ }
+}
+
+int is_period_equal_not_valid(int period)
+{
+ return period<=0 || (period > INT_MAX/1000);
+}
+
+void set_state_buffer_valid(lynq_network_state_buffer_type type,int valid)
+{
+ if(is_period_equal_not_valid(s_state_buffer_cfg.valid_period[type]))
+ {
+ valid=false;
+ }
+ s_state_buffer_valid[type] = valid;
+ if(s_state_buffer_valid[type]==false)
+ {
+ stop_network_timer(s_state_buffer_timer[type], s_state_buffer_sig_value[type]);
+ }
+ else
+ {
+ start_network_timer(s_state_buffer_timer[type], s_state_buffer_sig_value[type],s_state_buffer_cfg.valid_period[type]*1000);
+ }
+ LYINFLOG("%s type %d valid is %d",__func__,type,valid);
+}
+
+int get_state_buffer_valid(lynq_network_state_buffer_type type)
+{
+ return s_state_buffer_valid[type];
+}
+
+void set_state_to_buf(lynq_network_state_buffer_type type,...)
+{
+ int ret;
+ int fd_backup;
+
+ if(is_period_equal_not_valid(s_state_buffer_cfg.valid_period[type]))
+ {
+ LYINFLOG("%s type %d timer length %d is equal not valid",__func__,type,s_state_buffer_cfg.valid_period[type]);
+ return;
+ }
+
+ fd_backup = open(s_state_buffer_file[type],O_WRONLY | O_CREAT,0777);
+
+ if (fd_backup < 0) {
+ LYERRLOG("%s Error opening registrate buffer file: %s\n",__func__,strerror(errno));
+ return ;
+ }
+
+ va_list pArgs;
+ va_start(pArgs, type);
+
+ int int_num;
+ int i,int_value;
+
+ int_num = va_arg(pArgs, int);
+ LYINFLOG("%s int_num is %d",__func__,int_num);
+ for(i=0;i<int_num;i++)
+ {
+ int_value=va_arg(pArgs, int);
+ LYINFLOG("%s int_value is %d",__func__,int_value);
+ ret = write(fd_backup,&int_value,sizeof (int));
+ if(ret<=0)
+ {
+ LYERRLOG("%s write int %d value %d fail, ret is %d",__func__,i,int_value,ret);
+ goto set_state_error_done;
+ }
+
+ }
+
+ int stringNum;
+ char * p_value;
+ int stringLen;
+
+ stringNum = va_arg(pArgs, int);
+ LYINFLOG("%s stringNum is %d",__func__,stringNum);
+ for(i=0;i<stringNum;i++)
+ {
+ p_value=va_arg(pArgs, char*);
+ stringLen=strlen(p_value)+1;
+ LYINFLOG("%s p_value is %s,stringlen is %d",__func__,p_value,stringLen);
+ ret = write(fd_backup,&stringLen,sizeof(int));
+ if(ret<=0)
+ {
+ LYERRLOG("%s write %i stringlen %d fail, ret is %d",__func__,i,stringLen,ret);
+ goto set_state_error_done;
+ }
+ ret = write(fd_backup,p_value,stringLen);
+ if(ret<=0)
+ {
+ LYERRLOG("%s write string %d stringlen %d fail, ret is %d",__func__,i, stringLen,ret);
+ goto set_state_error_done;
+ }
+ }
+
+ va_end(pArgs);
+
+ sync();
+ close(fd_backup);
+ set_state_buffer_valid(type,true);
+ LYINFLOG("%s type %d suc",__func__,type);
+ return;
+
+set_state_error_done:
+ set_state_buffer_valid(type,false);
+ close(fd_backup);
+ return;
+}
+
+int get_state_from_buf(lynq_network_state_buffer_type type,...)
+{
+ int ret;
+ int fd_backup;
+
+ if(!get_state_buffer_valid(type))
+ {
+ LYINFLOG("%s type %d buffer not valid",__func__,type);
+ return 1;
+ }
+
+ fd_backup = open(s_state_buffer_file[type], O_RDONLY);
+
+ if (fd_backup < 0) {
+ LYERRLOG("%s Error opening type %d buffer file: %s\n",__func__,type,strerror(errno));
+ set_state_buffer_valid(type,false);
+ return -1;
+ }
+
+ va_list pArgs;
+ va_start(pArgs, type);
+ int int_p_num;
+ int i;
+ int* int_p_value;
+
+ int_p_num= va_arg(pArgs, int);
+ LYINFLOG("%s int_num is %d",__func__,int_p_num);
+ for(i=0;i<int_p_num;i++)
+ {
+ int_p_value=va_arg(pArgs, int*);
+ ret = read(fd_backup,int_p_value,sizeof (int));
+ LYINFLOG("%s int_p_value is %d",__func__,(*int_p_value));
+ if(ret<=0)
+ {
+ LYERRLOG("%s read int %d fail, ret is %d",__func__,i,ret);
+ goto get_state_error_done;
+ }
+
+ }
+
+ int stringNum;
+ char * p_value;
+ int stringLen;
+
+ stringNum = va_arg(pArgs, int);
+ LYINFLOG("%s stringNum is %d",__func__,stringNum);
+ for(i=0;i<stringNum;i++)
+ {
+ ret = read(fd_backup,&stringLen,sizeof (int));
+ if(ret<=0)
+ {
+ LYERRLOG("%s get %d string len fail, ret is %d",__func__,i,ret);
+ goto get_state_error_done;
+ }
+ LYINFLOG("%s stringlen is %d",__func__,stringLen);
+ p_value=va_arg(pArgs, char*);
+ ret = read(fd_backup,p_value,stringLen);
+ if(ret<=0)
+ {
+ LYERRLOG("%s get %d string fail, stringlen is %d, ret is %d",__func__, stringLen,ret);
+ goto get_state_error_done;
+ }
+ LYINFLOG("%s p_value is %s",__func__,p_value);
+ }
+ va_end(pArgs);
+
+ close(fd_backup);
+ LYINFLOG("%s type %d suc",__func__,type);
+ return 0;
+
+get_state_error_done:
+ set_state_buffer_valid(type,false);
+ close(fd_backup);
+ return -1;
+}
+
+int lynq_set_state_buffer_valid_period_of_network(lynq_network_state_buffer_type type,int valid_period)
+{
+ if(type>NETWORK_STATE_BUFFER_TYPE_MAX || type <0)
+ {
+ LYERRLOG("%s type %d error",__func__,type);
+ return -1;
+ }
+ if(valid_period>INT_MAX/1000 || valid_period <0)
+ {
+ LYERRLOG("%s type %d error",__func__,valid_period);
+ return -2;
+ }
+
+ network_state_buffer_cfg cfg_back=s_state_buffer_cfg;
+ s_state_buffer_cfg.valid_period[type]=valid_period;
+ int ret=set_state_buffer_timer_length_to_file();
+ if(ret!=0)
+ {
+ s_state_buffer_cfg=cfg_back;
+ }
+ else
+ {
+ set_state_buffer_valid(type,false);
+ }
+ LYINFLOG("%s type %d period %d ret is %d",__func__,type,valid_period,ret);
+ return ret;
+}
+
+int lynq_get_state_buffer_valid_period_of_network(lynq_network_state_buffer_type type)
+{
+ if(type>NETWORK_STATE_BUFFER_TYPE_MAX || type <0)
+ {
+ LYERRLOG("%s type %d error",__func__,type);
+ return 0;
+ }
+ return s_state_buffer_cfg.valid_period[type];
+}
diff --git a/lib/liblynq-network/lynq_network_state_buffer.h b/lib/liblynq-network/lynq_network_state_buffer.h
new file mode 100755
index 0000000..b451c65
--- /dev/null
+++ b/lib/liblynq-network/lynq_network_state_buffer.h
@@ -0,0 +1,15 @@
+#ifndef LYNQ_NETWORK_STATE_BUFFER_H
+#define LYNQ_NETWORK_STATE_BUFFER_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+void set_state_buffer_valid(lynq_network_state_buffer_type type,int valid);
+void set_state_to_buf(lynq_network_state_buffer_type type,...);
+int get_state_from_buf(lynq_network_state_buffer_type type,...);
+void init_network_timer_all();
+void deinit_network_timer_all();
+#ifdef __cplusplus
+}
+#endif
+
+#endif