[feature]:add sms feature add bb
Change-Id: I5d7c9f3287b59065907a49ebd610cdf780fd954d
diff --git a/src/lynq/lib/liblynq-sms/LICENSE b/src/lynq/lib/liblynq-sms/LICENSE
new file mode 100755
index 0000000..77f59ed
--- /dev/null
+++ b/src/lynq/lib/liblynq-sms/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/src/lynq/lib/liblynq-sms/include/libsms/lynq_sms.h b/src/lynq/lib/liblynq-sms/include/libsms/lynq_sms.h
new file mode 100755
index 0000000..fe4b6f9
--- /dev/null
+++ b/src/lynq/lib/liblynq-sms/include/libsms/lynq_sms.h
@@ -0,0 +1,30 @@
+#ifndef YLNQ_SMS_H
+#define YLNQ_SMS_H 1
+#include <sys/types.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define MIN_MSM_PARAM_NUM 4
+#define MIN_IMS_MSM_PARAM_NUM 6
+#define MIN_WRITE_MSM_PARAM_NUM 5
+#define MSG_MAX_LEN 1024
+#define TELEPHONE_NUM_LEN 64
+#define STORAGE_SMS_MAX_SIZE 128
+#define SMSC_MAX_LEN 22
+#define SMS_NUM_MAX 255
+int lynq_sms_init(int uToken);
+int lynq_sms_deinit(void);
+int lynq_send_sms(char telephony_num[TELEPHONE_NUM_LEN], int charset, char *msg);
+int lynq_read_sms(int index,int *status,int *charset,char smsc[SMSC_MAX_LEN],int *smscLen,int *smslen,char message[MSG_MAX_LEN],char teleNum[TELEPHONE_NUM_LEN],int *numLen);
+int lynq_get_smsc_address(char service_num[SMSC_MAX_LEN]);
+int lynq_set_smsc_address(const char* service_num);
+int lynq_list_sms(char index_list[SMS_NUM_MAX]);
+int lynq_delete_sms(int index);
+int lynq_wait_receive_new_sms(int *handle);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/src/lynq/lib/liblynq-sms/makefile b/src/lynq/lib/liblynq-sms/makefile
new file mode 100755
index 0000000..9daf449
--- /dev/null
+++ b/src/lynq/lib/liblynq-sms/makefile
@@ -0,0 +1,91 @@
+SHELL = /bin/sh
+RM = rm -f
+
+LOCAL_CFLAGS := -Wall \
+ -std=gnu++14 \
+ -g -Os \
+ -flto \
+ -fPIC \
+ -fpermissive \
+
+$(warning ################# C2K support: $(RAT_CONFIG_C2K_SUPPORT))
+ifeq ($(strip $(RAT_CONFIG_C2K_SUPPORT)), yes)
+ LOCAL_CFLAGS += -DC2K_SUPPORT
+
+endif
+
+ifeq ($(strip $(MTK_MULTI_SIM_SUPPORT)), dsds)
+ LOCAL_CFLAGS += -DANDROID_SIM_COUNT_2 \
+ -DANDROID_MULTI_SIM \
+ -DMODE_DSDS
+endif
+
+ifeq ($(strip $(MTK_MULTI_SIM_SUPPORT)), dsss)
+ LOCAL_CFLAGS += -DMODE_DSSS
+endif
+
+$(warning ################# TARGET_PLATFORM: $(TARGET_PLATFORM))
+ifeq ($(strip $(TARGET_PLATFORM)), mt2731)
+#$(warning #################add for debug $(ROOT), $(includedir))
+$(warning ################# TARGET_PLATFORM_MT2731)
+ LOCAL_CFLAGS += -DTARGET_PLATFORM_MT2731 \
+ -DMD_93_SUPPORT
+else ifeq ($(strip $(TARGET_PLATFORM)), mt2635)
+$(warning ################# TARGET_PLATFORM_MT2635)
+ LOCAL_CFLAGS += -DTARGET_PLATFORM_MT2635 \
+ -DMD_90_SUPPORT
+endif
+
+$(warning ################# RITA ROOT: $(ROOT),includedir:$(includedir))
+LOCAL_PATH = .
+
+LOCAL_C_INCLUDES = \
+ -I. \
+ -I$(LOCAL_PATH)/include/libsms \
+ -I$(ROOT)$(includedir)/vendor-ril \
+ -I$(ROOT)$(includedir)/liblog \
+
+
+LOCAL_LIBS := \
+ -L. \
+ -ldl \
+ -lpthread \
+ -lbinder \
+ -lutils \
+ -lcutils \
+ -llynq-log \
+
+SOURCES = $(wildcard *.c wildcard *.h src/*.cpp)
+
+EXECUTABLE = liblynq-sms.so
+
+OBJECTS=$(SOURCES:.c=.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 : %.c
+ $(CC) $(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)/
+
+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)
diff --git a/src/lynq/lib/liblynq-sms/src/lynq_sms.cpp b/src/lynq/lib/liblynq-sms/src/lynq_sms.cpp
new file mode 100755
index 0000000..15deb5f
--- /dev/null
+++ b/src/lynq/lib/liblynq-sms/src/lynq_sms.cpp
@@ -0,0 +1,427 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <binder/Parcel.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <string.h>
+#include <errno.h>
+#include <cutils/jstring.h>
+#include "lynq_sms.h"
+#include <vendor-ril/telephony/ril.h>
+#include <liblog/lynq_deflog.h>
+#include <sys/types.h>
+#define LYNQ_REQUEST_VENDOR_BASE 8000
+#define LYNQ_URC_VENDOR_BASE 9000
+#define LYNQ_AT_SNED (LYNQ_REQUEST_VENDOR_BASE +1)
+#define LYNQ_REQUEST_WRITE_SMS_TO_MEMORY (LYNQ_REQUEST_VENDOR_BASE +4)
+#define LYNQ_REQUEST_READ_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 5)
+#define LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 6)
+#define LYNQ_REQUEST_LIST_SMS_FROM_MEMORY (LYNQ_REQUEST_VENDOR_BASE + 7)
+using ::android::Parcel;
+
+#define SERVER_PORT 8088
+#define SERVER_URC_PORT 8086
+#define SERVER_IP "127.0.0.1"
+#define USER_LOG_TAG "LYNQ_SMS"
+typedef struct{
+ int uToken;
+ int request;
+ int paramLen;
+ char param[1024*8];
+}lynq_client_t;
+
+typedef struct {
+ int sock_fd;
+ struct sockaddr_in addrto;
+ struct sockaddr_in addrfrom;
+}sms_instance_t;
+
+
+enum{
+ SMS_OK = 0,
+ SMS_FAIL,
+ SMS_PARAM_ERR
+};
+
+typedef struct
+{
+ int index; /*the index of sms in memory,0-255 */
+ int status; /* 0:read, 1:unread */
+ int charset; /* 0:7bit, 1:8bit, 2:16bit(chinese) */
+ char smsc[SMSC_MAX_LEN]; /* smsc address */
+ int smscLen; /* smsc string length */
+ int smslen; /* the length of sms,the maximum length shall not exceed the length specified in 3GGP protocol(160/70) */
+ char message[MSG_MAX_LEN]; /* sms content */
+ char teleNum[TELEPHONE_NUM_LEN]; /* telephony number */
+ int numLen; /* telephony number strings length */
+}lynq_sms_msg_info_t;
+
+typedef struct{
+ int index; /*the index of sms in memory,0-255 */
+ int status; /* 0:read, 1:unread */
+ uint64_t timestamp; /* reciced message timestamp */
+ char telephone_num[TELEPHONE_NUM_LEN]; /* sender telephone number */
+}lynq_sms_info_t;
+
+typedef struct{
+ int num_msg; /* numbers of messsage */
+ lynq_sms_info_t lynq_sms_info[STORAGE_SMS_MAX_SIZE]; /* message information */
+}lynq_sms_list_info_t;
+
+static sms_instance_t sms_instance;
+int urc_recive_status = 1;
+static pthread_mutex_t s_receive_sms_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t s_receive_sms_cond = PTHREAD_COND_INITIALIZER;
+
+int GuToken = 0;
+int sms_storage_index = 0;
+static char *strdupReadString(Parcel &p) {
+ size_t stringlen;
+ const char16_t *s16;
+
+ s16 = p.readString16Inplace(&stringlen);
+
+ return strndup16to8(s16, stringlen);
+}
+
+static int sms_server_init(void)
+{
+ int ret = SMS_OK;
+
+ bzero(&sms_instance, sizeof(sms_instance));
+ if ((sms_instance.sock_fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1){
+ LYERRLOG("socket error:%s\n", strerror(errno));
+ ret = SMS_FAIL;
+ }
+ sms_instance.addrto.sin_family=AF_INET;
+ sms_instance.addrto.sin_addr.s_addr = inet_addr(SERVER_IP);
+ sms_instance.addrto.sin_port=htons(SERVER_PORT);
+ sms_instance.addrfrom.sin_family=AF_INET;
+ sms_instance.addrfrom.sin_addr.s_addr = inet_addr(SERVER_IP);
+ sms_instance.addrfrom.sin_port=htons(SERVER_PORT);
+
+ return ret;
+}
+
+int send_buff_to_service(char *buff, int length)
+{
+ int addr_len = sizeof(sms_instance.addrto);
+ int ret = 0;
+ ret = sendto(sms_instance.sock_fd, buff, length, 0, (struct sockaddr *)&sms_instance.addrto, addr_len);
+
+ return ret;
+}
+int waitReceiveNewSms()
+{
+ int ret = 0;
+ pthread_mutex_lock(&s_receive_sms_mutex);
+ ret = pthread_cond_wait(&s_receive_sms_cond,&s_receive_sms_mutex);
+ pthread_mutex_unlock(&s_receive_sms_mutex);
+ return ret;
+}
+void sendSignalNewSms()
+{
+ pthread_mutex_lock(&s_receive_sms_mutex);
+ pthread_cond_signal(&s_receive_sms_cond);
+ pthread_mutex_unlock(&s_receive_sms_mutex);
+ return;
+}
+int lynq_wait_receive_new_sms(int *handle)
+{
+ if(handle==NULL)
+ {
+ LYERRLOG("handle is null!!!");
+ return -1;
+ }
+ waitReceiveNewSms();
+ *handle = sms_storage_index;
+ return 0;
+}
+int recvfrom_server(void *resp)
+{
+ char recv_buf[4096] = {0};
+ int recv_len = 0;
+ int len = sizeof(struct sockaddr_in);
+ Parcel resp_parcel; // = new Parcel();
+ int32_t resp_type = 0;
+ int32_t request = 0;
+ int32_t slot_id = 0;
+ int32_t error = 0;
+ recv_len = recvfrom(sms_instance.sock_fd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr*)&sms_instance.addrfrom, (socklen_t*)&len);
+ LYDBGLOG("##################recv length:%d\n", recv_len);
+ if(recv_len <= 0){
+ LYERRLOG("recvform error: %s\n", strerror(errno));
+ return SMS_FAIL;
+ }
+ resp_parcel.setData((uint8_t *)recv_buf,recv_len);
+ resp_parcel.setDataPosition(0);
+ if(resp_parcel.dataAvail() > 0)
+ {
+ resp_parcel.readInt32(&resp_type);
+ resp_parcel.readInt32(&request);
+ resp_parcel.readInt32(&slot_id);
+ resp_parcel.readInt32(&error);
+ }
+ LYDBGLOG("resp data: %d,%d, %d,%d\n", resp_type, request, slot_id, error);
+ switch(request)
+ {
+ case RIL_REQUEST_SEND_SMS:
+ case RIL_REQUEST_SET_SMSC_ADDRESS:
+ if(0 != error)
+ {
+ LYDBGLOG("request:%d failure,Error code:%d",request,error);
+ }
+ break;
+
+ case RIL_REQUEST_GET_SMSC_ADDRESS:
+ if(0 != error)
+ {
+ LYDBGLOG("request:%d failure,Error code:%d",request,error);
+ }
+ else
+ {
+ char *temp = strdupReadString(resp_parcel);
+ memcpy(resp, temp, strlen(temp));
+ }
+ break;
+ case LYNQ_REQUEST_READ_SMS_FROM_MEMORY:
+ if(0 != error)
+ {
+ LYDBGLOG("request:%d failure,Error code:%d",request,error);
+ }
+ else
+ {
+ int index = 0;
+ int status = 0;
+ char *phone_num = NULL;
+ char *smsc = NULL;
+ char *msg = NULL;
+ int charset = 0;
+ lynq_sms_msg_info_t * sms_info = (lynq_sms_msg_info_t *)resp;
+ resp_parcel.readInt32(&sms_info->index);
+ resp_parcel.readInt32(&sms_info->status);
+ resp_parcel.readInt32(&sms_info->charset);
+ phone_num = strdupReadString(resp_parcel);
+ smsc = strdupReadString(resp_parcel);
+ msg = strdupReadString(resp_parcel);
+ memcpy(sms_info->smsc, smsc, strlen(smsc));
+ memcpy(sms_info->message, msg, strlen(msg));
+ memcpy(sms_info->teleNum, phone_num, strlen(phone_num));
+ sms_info->smscLen = strlen(smsc);
+ sms_info->smslen = strlen(msg);
+ sms_info->numLen = strlen(phone_num);
+ }
+ break;
+
+ case LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY:
+ if(0 != error)
+ {
+ LYDBGLOG("request:%d failure,Error code:%d",request,error);
+ }
+ break;
+
+ case LYNQ_REQUEST_LIST_SMS_FROM_MEMORY:
+ if(0 != error)
+ {
+ LYDBGLOG("request:%d failure,Error code:%d",request,error);
+ }else{
+ int temp = 0;
+ char *chartemp = NULL;
+ chartemp = strdupReadString(resp_parcel);
+ temp = strlen(chartemp);
+ if((temp > 0) && (temp <= SMS_NUM_MAX))
+ {
+ memcpy((char*)resp,chartemp,temp);
+ }
+ }
+ break;
+
+ default:
+ LYERRLOG("not support id: %d\n", request);
+ break;
+ }
+
+ return error;
+}
+
+void * handle_urc(void *p)
+{
+ int ret = SMS_OK;
+ int sock_fd = -1;
+ char recv_buf[8192] = {0};
+ Parcel resp;
+ int len = sizeof(struct sockaddr_in);
+ if ((sock_fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1){
+ LYERRLOG("socket error:%s\n", strerror(errno));
+ ret = SMS_FAIL;
+ }
+ int opt = 1;
+ ret = setsockopt(sock_fd,SOL_SOCKET,SO_BROADCAST,&opt,sizeof(opt));
+ ret = setsockopt(sock_fd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
+
+ struct sockaddr_in server;
+ server.sin_family=AF_INET;
+ server.sin_addr.s_addr = htonl(INADDR_ANY);
+ server.sin_port=htons(SERVER_URC_PORT);
+ ret = bind(sock_fd ,(struct sockaddr*)&server, sizeof(server));
+ while(urc_recive_status)
+ {
+ int slot_id = 0;
+ char *phone_num = NULL;
+ char *smsc = NULL;
+ char *msg = NULL;
+ int charset = 0;
+ int resp_type = 0;
+ int unsol = 0;
+ int index = 0;
+ ret = recvfrom(sock_fd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr*)&server, (socklen_t*)&len);
+ LYDBGLOG("urc recv length: %d\n", ret);
+ if(ret <= 0)
+ {
+ LYERRLOG("recvform error: %s\n", strerror(errno));
+ continue;
+ }
+ resp.setData((uint8_t *)recv_buf,ret);
+ resp.setDataPosition(0);
+ if(resp.dataAvail() > 0) {
+ resp.readInt32(&resp_type);
+ resp.readInt32(&unsol);
+ resp.readInt32(&slot_id);
+ }
+ LYERRLOG("resp_type%d,unsol=%d,slot_id=%d",resp_type,unsol,slot_id);
+ if(RIL_UNSOL_RESPONSE_NEW_SMS == unsol)
+ {
+ msg = strdupReadString(resp);
+ resp.readInt32(&index);
+ sms_storage_index = index;
+ //sms_urc_callback(slot_id, phone_num, smsc, msg, charset);
+ sendSignalNewSms();
+ }
+ }
+}
+
+int lynq_sms_init(int uToken)
+{
+ int ret = sms_server_init();
+ pthread_t pid = 0;
+ GuToken = uToken;
+ LYLOGSET(LOG_INFO);
+ LYLOGEINIT(USER_LOG_TAG);
+ pthread_create(&pid, NULL, handle_urc, NULL);
+ LYDBGLOG("lynq_sms_init ret: %d\n", ret);
+ return ret;
+}
+
+int lynq_sms_deinit(void)
+{
+ close(sms_instance.sock_fd);
+ urc_recive_status = 0;
+ return 0;
+}
+
+int lynq_send_sms(char telephony_num[TELEPHONE_NUM_LEN], int charset, char *msg)
+{
+ lynq_client_t client;
+ int ret = SMS_OK;
+
+ client.request = RIL_REQUEST_SEND_SMS;
+ client.uToken = GuToken;
+ client.paramLen = 3;
+
+ sprintf(client.param, "%s %d %s\n", telephony_num, charset, msg);
+ ret = send_buff_to_service((char *)&client, sizeof(client));
+ ret = recvfrom_server(NULL);
+
+ return ret;
+}
+
+int lynq_read_sms(int index,int *status,int *charset,char smsc[SMSC_MAX_LEN],int *smscLen,int *smslen,char message[MSG_MAX_LEN],char teleNum[TELEPHONE_NUM_LEN],int *numLen)
+{
+ lynq_client_t client;
+ lynq_sms_msg_info_t sms_msg_info;
+ int lenTemp = -1;
+ int ret = SMS_OK;
+ client.request = LYNQ_REQUEST_READ_SMS_FROM_MEMORY;
+ client.uToken = GuToken;
+ client.paramLen = 1;
+ sprintf(client.param, "%d", index);
+ ret = send_buff_to_service((char *)&client, sizeof(client));
+ ret = recvfrom_server((void *)&sms_msg_info);
+ if(ret == 0)
+ {
+ *charset = sms_msg_info.charset;
+ *status = sms_msg_info.status;
+ *smslen = sms_msg_info.smslen;
+ *smscLen = sms_msg_info.smscLen;
+ *numLen = sms_msg_info.numLen;
+ if((*smscLen > 0) && (*smscLen < SMSC_MAX_LEN))
+ {
+ memcpy(smsc,sms_msg_info.smsc,*smscLen);
+ }
+ if((*smslen > 0) && (*smslen < MSG_MAX_LEN))
+ {
+ memcpy(message,sms_msg_info.message,*smslen);
+ }
+ if((*numLen > 0) && (*numLen < TELEPHONE_NUM_LEN))
+ {
+ memcpy(teleNum,sms_msg_info.teleNum,*numLen);
+ }
+ }
+ return ret;
+}
+
+int lynq_get_smsc_address(char service_num[SMSC_MAX_LEN])
+{
+ int ret = SMS_OK;
+ lynq_client_t client;
+
+ client.request = RIL_REQUEST_GET_SMSC_ADDRESS;
+ client.uToken = GuToken;
+ client.paramLen = 0;
+ ret = send_buff_to_service((char *)&client, sizeof(client));
+ ret = recvfrom_server(service_num);
+
+ return ret;
+}
+
+int lynq_set_smsc_address(const char* service_num)
+{
+ lynq_client_t client;
+ int ret = SMS_OK;
+
+ client.request = RIL_REQUEST_SET_SMSC_ADDRESS;
+ client.uToken = GuToken;
+ client.paramLen = 1;
+ sprintf(client.param, "%s", service_num);
+ send_buff_to_service((char *)&client, sizeof(client));
+ ret = recvfrom_server(NULL);
+
+ return ret;
+}
+
+int lynq_list_sms(char index_list[SMS_NUM_MAX])
+{
+ lynq_client_t client;
+ int ret = SMS_OK;
+ client.request = LYNQ_REQUEST_LIST_SMS_FROM_MEMORY;
+ client.uToken = GuToken;
+ client.paramLen = 0;
+ ret = send_buff_to_service((char *)&client, sizeof(client));
+ ret = recvfrom_server((void *)index_list);
+ return ret;
+}
+
+int lynq_delete_sms(int index)
+{
+ lynq_client_t client;
+ int ret = SMS_OK;
+ client.request = LYNQ_REQUEST_DELETE_SMS_FROM_MEMORY;
+ client.uToken = GuToken;
+ client.paramLen = 1;
+ sprintf(client.param, "%d", index);
+ ret = send_buff_to_service((char *)&client, sizeof(client));
+ ret = recvfrom_server(NULL);
+ return ret;
+}
\ No newline at end of file