| #include <stdbool.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stdint.h> |
| #include <dlfcn.h> |
| #include <time.h> |
| #include "gsw_nw_interface.h" |
| #include "gsw_log_interface.h" |
| typedef unsigned short uint16_t; |
| typedef unsigned int uint32_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short uint16; |
| typedef uint32_t sms_client_handle_type; |
| typedef int kal_int32; |
| |
| |
| //qser include |
| |
| |
| |
| //mbtk include |
| typedef void (*mbtk_info_callback_func)(const void* data, int data_len); |
| typedef unsigned char uint8; |
| |
| typedef struct |
| { |
| int client_fd; |
| pthread_t read_thread_id; |
| int exit_fd[2]; |
| bool is_waitting; |
| pthread_cond_t cond; |
| pthread_mutex_t mutex; |
| |
| pthread_mutex_t send_mutex; |
| |
| // Temp response data. |
| uint16 info_err; |
| uint16 data_len; |
| void *data; |
| |
| //mbtk wyq for server_ready_status add start |
| char server_ready_status; |
| //mbtk wyq for server_ready_status add end |
| |
| mbtk_info_callback_func net_state_cb; |
| mbtk_info_callback_func call_state_cb; |
| mbtk_info_callback_func sms_state_cb; |
| mbtk_info_callback_func radio_state_cb; |
| mbtk_info_callback_func sim_state_cb; |
| mbtk_info_callback_func pdp_state_cb; |
| //add signal by xr |
| mbtk_info_callback_func signal_state_cb; |
| } mbtk_info_handle_t; |
| |
| // PDU include |
| enum EnumDCS { |
| BIT7 = 0, // GSM 字符集 |
| BIT8 = 1, // ASCII字符集 |
| UCS2 = 2 // Unicode 字符集 |
| }; |
| |
| struct SMS_Struct { |
| char *SCA; // 服务中心地址 |
| char *OA; // 发送方地址 |
| char *SCTS; // 服务中心时间戳 |
| struct UDHS *UDH; // 用户数据头 |
| char *UD; // 用户数据 |
| |
| bool RP; // 应答路径 |
| bool UDHI; // 用户数据头标识 |
| bool SRI; // 状态报告指示 |
| bool MMS; // 更多信息发送 |
| int MTI; // 信息类型指示 |
| |
| char PID; // PID 协议标识 |
| |
| enum EnumDCS DCS; // 数据编码方案 |
| bool TC; // 文本压缩指示 0： 未压缩 1：压缩 |
| int MC; // 消息类型 -1： 无 1：移动设备特定类型 2：SIM特定类型 3：终端设备特定类型 |
| |
| }; |
| |
| struct PDUS { |
| unsigned int count; |
| char **PDU; |
| }; |
| |
| enum MDAPI_RET_e { |
| MDAPI_RET_SUCCESS = 0, |
| MDAPI_RET_ERROR = 1, |
| MDAPI_RET_TIMEOUT = 2, |
| MDAPI_RET_NOT_SUPPORT = 3, |
| }; |
| |
| #define MDAPI_TIME_STR_SIZE 22 |
| #define MDAPI_PHONE_NUMBER_SIZE 32 |
| #define MDAPI_MAX_PDU_SIZE 512 |
| #define MSM_NUMBER_MAX 2048+1 |
| #define RES_NUM_MIN 128 |
| #define MIN_MSM_PARAM_NUM 4 |
| #define MIN_IMS_MSM_PARAM_NUM 6 |
| #define MIN_WRITMSM_PARAM_NUM 5 |
| #define MSG_MAX_LEN 1024 |
| #define TELEPHONNUM_LEN 64 |
| #define STORAGSMS_MAX_SIZE 128 |
| #define SMSC_MAX_LEN 100 |
| #define SMS_NUM_MAX 255 |
| #define MAX_OUT_SIZE 512 |
| #define MAX_PDU_SIZE 512 |
| #define MAX_DATE_SIZE 32 |
| |
| GSW_SMS_Callback_fun gsw_sms_callback = NULL; |
| |
| #define lib_mbtk_path "/lib/libmbtk_lib.so" |
| #define lib_qser_sms_path "/lib/liblynq-qser-sms.so" |
| |
| // 短信分片管理器结构体 |
| typedef struct { |
| char msg_id[64]; // 短信唯一标识（号码+日期） |
| int total_segments; // 总分片数 |
| int received_count; // 已接收分片数 |
| char** segments; // 分片内容数组 |
| time_t last_received; // 最后接收时间 |
| } SmsReassembler; |
| |
| #define MAX_SMS_REASSEMBLERS 10 // 最大同时处理的短信数量 |
| #define MAX_SEGMENTS 255 // 最大分片数 |
| #define SMS_TIMEOUT 300 // 5分钟超时(秒) |
| static SmsReassembler g_sms_reassemblers[MAX_SMS_REASSEMBLERS] = {0}; |
| |
| static mbtk_info_handle_t* (*mbtk_info_handle_get)(void); |
| int (*mbtk_sms_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb); |
| static int (*mbtk_info_handle_free)(mbtk_info_handle_t** handle); |
| struct SMS_Struct (*PDUDecoding)(const char *data); |
| char *(*SCADecoding)(const char *data, int *EndIndex); |
| char *(*SCAEncoding)(char *SCA); |
| struct PDUS *(*PDUEncoding)(char *SCA, char *DA, char *UDC, struct UDHS *udhs); |
| int (*mbtk_sms_cmgf_set)(mbtk_info_handle_t* handle, int mode); |
| int (*mbtk_sms_cmgs_set)(mbtk_info_handle_t* handle, char * cmgs, char *resp); |
| int (*mbtk_sms_csca_set)(mbtk_info_handle_t* handle, char * csca); |
| int (*mbtk_sms_csca_get)(mbtk_info_handle_t* handle, char *buf); |
| int (*mbtk_sms_cnmi_set)(mbtk_info_handle_t* handle); |
| // static void (*mbtk_log)(int level, const char *format, ...); |
| // static void (*mbtk_log_init)(char *path, char *tag); |
| int (*smsPduEncode)(const char *smsc, const char *da_num, const char *msg, int charset, char *smsc_pdu, char **pdu); |
| int (*smsPduDecode)(const char *pdu_str, int pdu_len, char *da_num, char *smsc, char *msg, int *charset, int *curr_pack, int *total_pack, char *date); |
| kal_int32 (*_mdapi_sms_get_msg_num)(const char *msg, int charset, kal_int32 *msg_num, kal_int32 *msg_len); |
| |
| #define GSW_SMS "[HAL][GSW_SMS]" |
| |
| static mbtk_info_handle_t* sms_info_handle = NULL; |
| static sms_client_handle_type handle; |
| static char sms_center_address[SMSC_MAX_LEN] = {0}; |
| static void *dlHandle_mbtk; |
| static int init_flag = 0; |
| |
| static int mbtk_sms_import() |
| { |
| dlHandle_mbtk = dlopen(lib_mbtk_path, RTLD_NOW); |
| if (dlHandle_mbtk == NULL) |
| { |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| // mbtk_log_init = (void (*)(char *path, char *tag))dlsym(dlHandle_mbtk, "mbtk_log_init"); |
| // if (mbtk_log_init == NULL) |
| // { |
| // return GSW_HAL_NORMAL_FAIL; |
| // } |
| |
| // mbtk_log = (void (*)(int level, const char *format, ...))dlsym(dlHandle_mbtk, "mbtk_log"); |
| // if (mbtk_log == NULL) |
| // { |
| // return GSW_HAL_NORMAL_FAIL; |
| // } |
| |
| mbtk_info_handle_get = (mbtk_info_handle_t* (*)(void))dlsym(dlHandle_mbtk, "mbtk_info_handle_get"); |
| if (mbtk_info_handle_get == NULL) |
| { |
| LOGE(GSW_SMS,"mbtk_info_handle_get dlsym fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| mbtk_sms_state_change_cb_reg = (int (*)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb))dlsym(dlHandle_mbtk, "mbtk_sms_state_change_cb_reg"); |
| if (mbtk_sms_state_change_cb_reg == NULL) |
| { |
| LOGE(GSW_SMS,"mbtk_sms_state_change_cb_reg dlsym fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| mbtk_info_handle_free = (int (*)(mbtk_info_handle_t** handle))dlsym(dlHandle_mbtk, "mbtk_info_handle_free"); |
| if (mbtk_info_handle_free == NULL) |
| { |
| LOGE(GSW_SMS,"mbtk_info_handle_free dlsym fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| PDUDecoding = (struct SMS_Struct (*)(const char *data))dlsym(dlHandle_mbtk, "PDUDecoding"); |
| if (PDUDecoding == NULL) |
| { |
| LOGE(GSW_SMS,"PDUDecoding dlsym fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| SCADecoding = (char *(*)(const char *data, int *EndIndex))dlsym(dlHandle_mbtk, "SCADecoding"); |
| if (SCADecoding == NULL) |
| { |
| LOGE(GSW_SMS,"SCADecoding dlsym fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| SCAEncoding = (char *(*)(char *SCA))dlsym(dlHandle_mbtk, "SCAEncoding"); |
| if (SCAEncoding == NULL) |
| { |
| LOGE(GSW_SMS,"SCAEncoding dlsym fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| PDUEncoding = (struct PDUS *(*)(char *SCA, char *DA, char *UDC, struct UDHS *udhs))dlsym(dlHandle_mbtk, "PDUEncoding"); |
| if (PDUEncoding == NULL) |
| { |
| LOGE(GSW_SMS,"PDUEncoding dlsym fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| mbtk_sms_cmgf_set = (int (*)(mbtk_info_handle_t* handle, int mode))dlsym(dlHandle_mbtk, "mbtk_sms_cmgf_set"); |
| if (mbtk_sms_cmgf_set == NULL) |
| { |
| LOGE(GSW_SMS,"mbtk_sms_cmgf_set dlsym fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| mbtk_sms_cmgs_set = (int (*)(mbtk_info_handle_t* handle, char * cmgs, char *resp))dlsym(dlHandle_mbtk, "mbtk_sms_cmgs_set"); |
| if (mbtk_sms_cmgs_set == NULL) |
| { |
| LOGE(GSW_SMS,"mbtk_sms_cmgs_set dlsym fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| mbtk_sms_csca_set = (int (*)(mbtk_info_handle_t* handle, char * csca))dlsym(dlHandle_mbtk, "mbtk_sms_csca_set"); |
| if (mbtk_sms_csca_set == NULL) |
| { |
| LOGE(GSW_SMS,"mbtk_sms_csca_set dlsym fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| mbtk_sms_csca_get = (int (*)(mbtk_info_handle_t* handle, char *buf))dlsym(dlHandle_mbtk, "mbtk_sms_csca_get"); |
| if (mbtk_sms_csca_get == NULL) |
| { |
| LOGE(GSW_SMS,"mbtk_sms_csca_get dlsym fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| mbtk_sms_cnmi_set = (int (*)(mbtk_info_handle_t* handle))dlsym(dlHandle_mbtk, "mbtk_sms_cnmi_set"); |
| if (mbtk_sms_cnmi_set == NULL) |
| { |
| LOGE(GSW_SMS,"mbtk_sms_cnmi_set dlsym fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| smsPduEncode = (int (*)(const char *smsc, const char *da_num, const char *msg, int charset, char *smsc_pdu, char **pdu))dlsym(dlHandle_mbtk, "smsPduEncode"); |
| if (smsPduEncode == NULL) |
| { |
| LOGE(GSW_SMS,"smsPduEncode dlsym fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| |
| smsPduDecode = (int (*)(const char *pdu_str, int pdu_len, char *da_num, char *smsc, char *msg, int *charset, int *curr_pack, int *total_pack, char *date))dlsym(dlHandle_mbtk,"smsPduDecode"); |
| if (smsPduDecode == NULL) |
| { |
| LOGE(GSW_SMS,"smsPduDecode dlsym fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| _mdapi_sms_get_msg_num = (kal_int32 (*)(const char *msg, int charset, kal_int32 *msg_num, kal_int32 *msg_len))dlsym(dlHandle_mbtk,"_mdapi_sms_get_msg_num"); |
| if (_mdapi_sms_get_msg_num == NULL) |
| { |
| LOGE(GSW_SMS,"_mdapi_sms_get_msg_num dlsym fail"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| return GSW_HAL_SUCCESS; |
| |
| } |
| |
| static void generate_sms_id(char* dest, const char* num, const char* date) { |
| snprintf(dest, 64, "%.30s_%.30s", num, date); |
| } |
| |
| // 查找或创建短信重组器 |
| static SmsReassembler* get_sms_reassembler(const char* num, const char* date, int total_segments) |
| { |
| char msg_id[64]; |
| generate_sms_id(msg_id, num, date); |
| |
| time_t current_time = time(NULL); |
| |
| for (int i = 0; i < MAX_SMS_REASSEMBLERS; i++) |
| { |
| if (g_sms_reassemblers[i].msg_id[0] != '\0') |
| { |
| // 检查超时 |
| if (current_time - g_sms_reassemblers[i].last_received > SMS_TIMEOUT) |
| { |
| // 清理超时重组器 |
| LOGE(GSW_SMS,"start clean reassembler\n"); |
| for (int j = 0; j < g_sms_reassemblers[i].total_segments; j++) |
| { |
| if (g_sms_reassemblers[i].segments[j]) |
| { |
| free(g_sms_reassemblers[i].segments[j]); |
| } |
| } |
| free(g_sms_reassemblers[i].segments); |
| memset(&g_sms_reassemblers[i], 0, sizeof(SmsReassembler)); |
| } |
| else if (strcmp(g_sms_reassemblers[i].msg_id, msg_id) == 0) |
| { |
| LOGE(GSW_SMS,"start clean reassembler2\n"); |
| g_sms_reassemblers[i].last_received = current_time; |
| return &g_sms_reassemblers[i]; |
| } |
| } |
| } |
| |
| // 创建新的重组器 |
| for (int i = 0; i < MAX_SMS_REASSEMBLERS; i++) |
| { |
| if (g_sms_reassemblers[i].msg_id[0] == '\0') |
| { |
| strncpy(g_sms_reassemblers[i].msg_id, msg_id, sizeof(g_sms_reassemblers[i].msg_id) - 1); |
| g_sms_reassemblers[i].total_segments = total_segments; |
| g_sms_reassemblers[i].received_count = 0; |
| g_sms_reassemblers[i].last_received = current_time; |
| LOGE(GSW_SMS,"start create reassembler\n"); |
| // 分配分片数组内存 |
| g_sms_reassemblers[i].segments = calloc(total_segments, sizeof(char*)); |
| if (!g_sms_reassemblers[i].segments) |
| { |
| LOGE(GSW_SMS, "Memory allocation failed for segments array"); |
| memset(&g_sms_reassemblers[i], 0, sizeof(SmsReassembler)); |
| return NULL; |
| } |
| |
| return &g_sms_reassemblers[i]; |
| } |
| } |
| |
| LOGE(GSW_SMS, "No free slots for new SMS reassembler"); |
| return NULL; |
| } |
| |
| // 重组短信 |
| static char* reassemble_sms(SmsReassembler* reassembler) |
| { |
| LOGE(GSW_SMS, "start real reassemble_sms\n"); |
| size_t total_len = 0; |
| for (int i = 0; i < reassembler->total_segments; i++) |
| { |
| if (reassembler->segments[i]) |
| { |
| total_len += strlen(reassembler->segments[i]); |
| } |
| } |
| |
| char* full_msg = malloc(total_len + 1); |
| if (!full_msg) |
| { |
| LOGE(GSW_SMS, "Memory allocation failed for full message"); |
| return NULL; |
| } |
| |
| full_msg[0] = '\0'; |
| for (int i = 0; i < reassembler->total_segments; i++) |
| { |
| if (reassembler->segments[i]) |
| { |
| strcat(full_msg, reassembler->segments[i]); |
| } |
| } |
| |
| return full_msg; |
| } |
| |
| void ArrayToStr(unsigned char *Buff, unsigned int BuffLen, char *OutputStr) |
| { |
| int i = 0; |
| char TempBuff[MSG_MAX_LEN * 2 +1] = {0}; |
| char strBuff[MSG_MAX_LEN * 2 +1] = {0}; |
| |
| for(i = 0; i<BuffLen;i++) |
| { |
| sprintf(TempBuff,"%02x",(unsigned char)Buff[i]); |
| strncat(strBuff,TempBuff,2); |
| } |
| strncpy(OutputStr, strBuff, BuffLen*2); |
| return; |
| } |
| |
| void gsw_sms_state_change_cb(const void* data, int data_len) |
| { |
| LOGD(GSW_SMS,"gsw_sms_state_change_cb -------start\n"); |
| |
| uint8 *ptr = (uint8*)data; |
| |
| if (!strncmp("+CMT:", (const char *)ptr, 5))//丢弃无用消息 |
| return ; |
| |
| gsw_sms_msg_type_t gsw_sms_msg; |
| gsw_sms_date_t gsw_sms_date; |
| |
| memset(&gsw_sms_msg, 0, sizeof(gsw_sms_msg_type_t)); |
| memset(&gsw_sms_date, 0, sizeof(gsw_sms_date_t)); |
| |
| char smsc[MDAPI_MAX_PDU_SIZE] = {0}; |
| char received_pdu[MDAPI_MAX_PDU_SIZE] = {0}; |
| char msg[MDAPI_MAX_PDU_SIZE] = {0}; |
| char num[MDAPI_MAX_PDU_SIZE] = {0}; |
| char date[MAX_DATE_SIZE] = {0}; |
| int charset = 0; |
| int ret = -1; |
| int curr_pack = 1; |
| int total_pack = 1; |
| if(ptr == NULL) |
| { |
| LOGE(GSW_SMS,"ptr is null"); |
| } |
| LOGE(GSW_SMS,"ptr: %s\n,data_len = %d\n", (char *)ptr, data_len); |
| if(data_len > MDAPI_MAX_PDU_SIZE) |
| { |
| strncpy(received_pdu, (const char *)ptr, MDAPI_MAX_PDU_SIZE-1); |
| } |
| else |
| { |
| strncpy(received_pdu, (const char *)ptr, data_len); |
| } |
| ret = smsPduDecode((const char *)received_pdu, data_len, num, smsc, msg, &charset, &curr_pack, &total_pack,date); |
| if(ret != 0) |
| { |
| LOGE(GSW_SMS,"smsPduDecode fail\n"); |
| return ; |
| } |
| LOGE(GSW_SMS,"smsPduDecode ret: %d\n", ret); |
| LOGE(GSW_SMS,"SMS :%s, %s, %d\n", __FILE__, __FUNCTION__, __LINE__); |
| LOGE(GSW_SMS,"[EVENT][MT_SMS]PDU decode:smsc: %s\n, phone number: %s\ncharset: %d\n msg_len: %d\n message content: %s\n curr_pack: %d\n total_pack: %d\n date: %s", smsc, num, charset, strlen(msg), msg, curr_pack, total_pack, date); |
| |
| gsw_sms_msg.content_encode = charset; |
| memcpy(gsw_sms_msg.src_num, num, strlen(num)); |
| gsw_sms_msg.content_len = strlen(msg); |
| memcpy(gsw_sms_msg.content, msg, strlen(msg)); |
| |
| if(sscanf(date, "%4[^-]-%2[^-]-%2[^ ] %2[^:]:%2[^:]:%2s", (char*)gsw_sms_date.year, (char*)gsw_sms_date.month, (char*)gsw_sms_date.day, (char*)gsw_sms_date.hour, (char*)gsw_sms_date.minutes, (char*)gsw_sms_date.seconds)<=0) |
| { |
| LOGE(GSW_SMS,"sscanf failed\n"); |
| } |
| |
| snprintf((char *)gsw_sms_date.timezone, sizeof(gsw_sms_date.timezone), "%s","+8"); |
| |
| LOGE(GSW_SMS,"Year: %s\n", (char*)gsw_sms_date.year); |
| LOGE(GSW_SMS,"Month: %s\n", (char*)gsw_sms_date.month); |
| LOGE(GSW_SMS,"Day: %s\n", (char*)gsw_sms_date.day); |
| LOGE(GSW_SMS,"Hour: %s\n", (char*)gsw_sms_date.hour); |
| LOGE(GSW_SMS,"Minute: %s\n", (char*)gsw_sms_date.minutes); |
| LOGE(GSW_SMS,"Second: %s\n", (char*)gsw_sms_date.seconds); |
| |
| gsw_sms_msg.date = gsw_sms_date; |
| |
| |
| if(gsw_sms_callback) |
| { |
| if(total_pack > 1) |
| { |
| SmsReassembler* reassembler = get_sms_reassembler(num, date, total_pack); |
| if (!reassembler) |
| { |
| LOGE(GSW_SMS, "Failed to get SMS reassembler"); |
| return; |
| } |
| int seg_index = curr_pack - 1; |
| |
| // 如果该分片尚未接收 |
| if (!reassembler->segments[seg_index]) |
| { |
| reassembler->segments[seg_index] = strdup(msg); |
| if (!reassembler->segments[seg_index]) |
| { |
| LOGE(GSW_SMS, "Memory allocation failed for segment content"); |
| return; |
| } |
| reassembler->received_count++; |
| } |
| |
| // 检查是否所有分片都已接收 |
| if (reassembler->received_count == reassembler->total_segments) |
| { |
| char* full_msg = reassemble_sms(reassembler); |
| if (full_msg) |
| { |
| |
| gsw_sms_msg.content_encode = charset; |
| strncpy(gsw_sms_msg.src_num, num, sizeof(gsw_sms_msg.src_num) - 1); |
| gsw_sms_msg.content_len = strlen(full_msg); |
| |
| size_t copy_size = (gsw_sms_msg.content_len < sizeof(gsw_sms_msg.content)) ? |
| gsw_sms_msg.content_len : sizeof(gsw_sms_msg.content) - 1; |
| strncpy(gsw_sms_msg.content, full_msg, copy_size); |
| gsw_sms_msg.content[copy_size] = '\0'; |
| |
| snprintf((char *)gsw_sms_date.timezone, sizeof(gsw_sms_date.timezone), "%s", "+8"); |
| |
| if (gsw_sms_callback) |
| gsw_sms_callback(GSW_SMS_RECEIVED_FLG, &gsw_sms_msg); |
| |
| free(full_msg); |
| } |
| |
| for (int i = 0; i < reassembler->total_segments; i++) |
| { |
| if (reassembler->segments[i]) |
| { |
| free(reassembler->segments[i]); |
| reassembler->segments[i] = NULL; |
| } |
| } |
| free(reassembler->segments); |
| reassembler->segments = NULL; |
| reassembler->received_count = 0; |
| reassembler->total_segments = 0; |
| memset(reassembler->msg_id, 0, sizeof(reassembler->msg_id)); |
| } |
| } |
| else |
| gsw_sms_callback(GSW_SMS_RECEIVED_FLG, &gsw_sms_msg); |
| } |
| } |
| |
| |
| /** |
| * @brief SDK interface to call back sms messages |
| * @param [in] handle_ptr |
| * @retval 0: success |
| * @retval other: fail |
| */ |
| int gsw_sms_reg_callback(GSW_SMS_Callback_fun handle_ptr) |
| { |
| if(init_flag == 0) |
| { |
| return -1; |
| } |
| |
| if(handle_ptr == NULL) |
| { |
| LOGE(GSW_SMS,"gsw_sms_reg_callback fail,handle_ptr is null\n"); |
| return -1; |
| } |
| else |
| { |
| gsw_sms_callback = handle_ptr; |
| } |
| return GSW_HAL_SUCCESS; |
| } |
| |
| /** |
| * @brief sms sdk init |
| * @param [in] token |
| * @retval 0: success |
| * @retval other: fail |
| */ |
| int gsw_sms_sdk_init(int32_t token) |
| { |
| handle = token; |
| int ret = -1; |
| |
| if(init_flag == 1) |
| { |
| LOGE(GSW_SMS,"has init sms sdk,return\n"); |
| return GSW_HAL_SUCCESS; |
| } |
| |
| ret = mbtk_sms_import(); |
| if(ret != 0) |
| { |
| // if(mbtk_log != NULL) |
| // { |
| // LOGE(GSW_SMS,"[gsw_sms_sdk_init]mbtk_sms_import fail\n"); |
| // } |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| //mbtk_log_init("syslog", "MBTK_RIL"); |
| |
| sms_info_handle = mbtk_info_handle_get(); |
| if(sms_info_handle == NULL) |
| { |
| LOGE(GSW_SMS,"[gsw_sms_sdk_init] mbtk handle init fail\n"); |
| dlclose(dlHandle_mbtk); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| ret = mbtk_sms_cnmi_set(sms_info_handle); |
| if(ret != 0) |
| { |
| LOGE(GSW_SMS,"mbtk_sms_cnmi_set fail.[%d]\n", ret); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| ret = mbtk_sms_state_change_cb_reg(sms_info_handle, gsw_sms_state_change_cb); |
| if(ret != 0) |
| { |
| LOGE(GSW_SMS,"mbtk_sms_state_change_cb_reg fail.[%d]\n", ret); |
| if(sms_info_handle) |
| { |
| mbtk_info_handle_free(&sms_info_handle); |
| sms_info_handle = NULL; |
| } |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| LOGD(GSW_SMS,"[gsw_sms_sdk_init]gsw_sms_sdk_init success\n"); |
| init_flag = 1; |
| return GSW_HAL_SUCCESS; |
| } |
| |
| /** |
| * @brief sms sdk deinit |
| * @param |
| * @retval 0: success |
| * @retval other: fail |
| */ |
| int gsw_sms_sdk_deinit(void) |
| { |
| int ret = -1; |
| |
| if(init_flag == 0) |
| { |
| return -1; |
| } |
| |
| LOGD(GSW_SMS,"callback clear\n"); |
| gsw_sms_callback = NULL; |
| |
| LOGD(GSW_SMS,"handle_free\n"); |
| if(sms_info_handle != NULL) |
| { |
| ret = mbtk_info_handle_free(&sms_info_handle); |
| if(ret != 0) |
| { |
| LOGE(GSW_SMS,"[gsw_sms_sdk_deinit]mbtk_info_handle_free fail\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| sms_info_handle = NULL; |
| } |
| |
| LOGD(GSW_SMS,"dlclose start\n"); |
| if(dlHandle_mbtk == NULL) |
| { |
| LOGE(GSW_SMS,"[gsw_sms_sdk_deinit]dlHandle_sms is null\n"); |
| } |
| else |
| { |
| dlclose(dlHandle_mbtk); |
| } |
| LOGD(GSW_SMS,"dlclose end\n"); |
| init_flag = 0; |
| return GSW_HAL_SUCCESS; |
| } |
| |
| /** |
| * @brief send sms fuction * |
| * @param [in] phone_num dest phone num send sms |
| * @param [in] char_set encode format for sms 0 7bit 1 binary 2 usc2 |
| * @param [in] msg sms content |
| * @param [in] msg_len send sms length,max is 1024 |
| * @retval 0: success |
| * @retval other: fail |
| */ |
| int gsw_send_sms(char *phone_num, int char_set, char *msg, int msg_len) |
| { |
| |
| if(init_flag == 0) |
| { |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| if(phone_num == NULL || msg == NULL) |
| { |
| return GSW_HAL_ARG_INVALID; |
| } |
| |
| if(strlen((char *)msg) == 0 || strlen((char *)phone_num) == 0) |
| { |
| LOGE(GSW_SMS,"strlen(telephony_num):%d", strlen((char *)phone_num)); |
| LOGE(GSW_SMS,"strlen(msg):%d", strlen((char *)msg)); |
| return GSW_HAL_ARG_INVALID; |
| } |
| if(strlen((char *)msg) > MSG_MAX_LEN || msg_len > MSG_MAX_LEN || strlen((char *)msg) != msg_len) |
| { |
| LOGE(GSW_SMS,"stelen is %d\n",strlen((char *)msg)); |
| LOGE(GSW_SMS,"the lenth is error\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| int err = -1; |
| |
| char smscPDU[30] = {0}; |
| char **pdu = NULL; |
| char smsc[4] = {0}; |
| char cmgs[MSM_NUMBER_MAX] = {0}; |
| char resp[RES_NUM_MIN] = {0}; |
| char msg_e_b[GSW_SMS_RECV_CONT_MAX+1] = {0};// +1 for end of string.*2:A char array contains two elements of a string for each value |
| |
| kal_int32 msg_num = 0; |
| kal_int32 pdu_msg_len = 0; |
| kal_int32 status = MDAPI_RET_ERROR; |
| kal_int32 index = 0; |
| |
| if(char_set == 1) //8bit |
| { |
| ArrayToStr((unsigned char *)msg, (unsigned int)msg_len, msg_e_b); |
| status = _mdapi_sms_get_msg_num(msg_e_b, char_set, &msg_num, &pdu_msg_len); |
| } |
| |
| else //7bit usc2 |
| { |
| status = _mdapi_sms_get_msg_num((char *)msg, char_set, &msg_num, &pdu_msg_len); |
| } |
| |
| LOGE(GSW_SMS,"%s, %s, %d, msg_len = [%d] ,msg_num=[%d]\n", __FILE__, __FUNCTION__, __LINE__, msg_len, msg_num); |
| if(status == MDAPI_RET_ERROR) |
| { |
| LOGE(GSW_SMS,"get message number failed\n"); |
| //return GSW_HAL_NORMAL_FAIL; |
| } |
| else |
| { |
| //allocate memery for **pdu |
| pdu = (char **)malloc(sizeof(char *) * msg_num); |
| if(pdu == NULL) |
| { |
| LOGE(GSW_SMS,"%s, %s, %d, allocate memory for pdu failed\n", __FILE__, __FUNCTION__, __LINE__); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| else |
| { |
| for(index = 0; index < msg_num; index++) |
| { |
| pdu[index] = (char *)malloc(sizeof(char)*MAX_PDU_SIZE); |
| if(pdu[index] == NULL) |
| { |
| for(int i = 0; i < index; i++) |
| { |
| free(pdu[i]); |
| pdu[i] = NULL; |
| } |
| free(pdu); |
| pdu = NULL; |
| LOGE(GSW_SMS,"%s, %s, %d, allocate memory for pdu[%d] failed\n", __FILE__, __FUNCTION__, __LINE__,index); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| else |
| { |
| memset(pdu[index], 0, MAX_PDU_SIZE); |
| LOGE(GSW_SMS,"%s, %s, %d, pdu[%d} init value is: %s \n", __FILE__, __FUNCTION__, __LINE__, index, pdu[index]); |
| } |
| } |
| } |
| } |
| |
| //allocate memory for **pdu success |
| if(index == msg_num) |
| { |
| if(char_set == 1)//8bit |
| { |
| smsPduEncode(smsc, (char *)phone_num, msg_e_b, char_set, smscPDU, pdu); |
| } |
| else |
| { |
| smsPduEncode(smsc, (char *)phone_num, (char *)msg, char_set, smscPDU, pdu); |
| } |
| for(index = 0; index < msg_num; index++) |
| { |
| char pdu_data[MAX_PDU_SIZE] = {0}; |
| char *p = pdu_data; |
| |
| LOGE(GSW_SMS,"index:%d\n",index); |
| LOGE(GSW_SMS,"%s, %s, %d, smscPDU: %s, pdu: %s",__FILE__, __FUNCTION__, __LINE__, smscPDU, pdu[index]); |
| sprintf(p, "%s",smscPDU); |
| LOGE(GSW_SMS,"pdu_data:%s\n", pdu_data); |
| int sc = strlen(pdu_data); |
| sprintf(p+strlen(p), "%s", pdu[index]); |
| LOGE(GSW_SMS,"pdu_data:%s\n", pdu_data); |
| |
| int t = strlen(pdu_data); |
| sprintf(cmgs, "%d,%s", (t-sc)/2, pdu_data); |
| LOGE(GSW_SMS,"cmgs:%s\n", cmgs); |
| memset(resp, 0, sizeof(resp)); |
| |
| err = mbtk_sms_cmgf_set(sms_info_handle, 0); |
| if(err) |
| { |
| LOGE(GSW_SMS,"cmgf set error : %d\n", err); |
| for(index = 0; index < msg_num; index++){ |
| free(pdu[index]); |
| pdu[index] = NULL; |
| } |
| free(pdu); |
| pdu = NULL; |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| else |
| { |
| LOGD(GSW_SMS,"cmgf set success\n"); |
| } |
| |
| err = mbtk_sms_cmgs_set(sms_info_handle, cmgs, resp); |
| if(err) |
| { |
| LOGE(GSW_SMS,"cmgs send fail\n"); |
| for(index = 0; index < msg_num; index++){ |
| free(pdu[index]); |
| pdu[index] = NULL; |
| } |
| free(pdu); |
| pdu = NULL; |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| else |
| { |
| LOGD(GSW_SMS,"cmgs send success, resp:%s\n", resp); |
| } |
| |
| } |
| } |
| |
| for(index = 0; index < msg_num; index++){ |
| free(pdu[index]); |
| pdu[index] = NULL; |
| } |
| free(pdu); |
| pdu = NULL; |
| |
| return GSW_HAL_SUCCESS; |
| } |
| |
| |
| /** |
| * @brief get smsc fuction * |
| * @param [in] len input buf len for smsc,max is 32 |
| * @param [out] smsc address for smsc get from this func * |
| * @retval 0: success |
| * @retval other: fail |
| */ |
| int gsw_get_smsc_address(int len, char *smsc) |
| { |
| int ret = -1; |
| int len_t = 0; |
| char smsc_temp[SMSC_MAX_LEN] = {0}; |
| char *p1, *p2 ,*substr; |
| |
| if(init_flag == 0) |
| { |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| if(smsc == NULL || len <= 0) |
| { |
| LOGE(GSW_SMS,"smsc is null or len = %d\n",len); |
| return GSW_HAL_ARG_INVALID; |
| } |
| |
| ret = mbtk_sms_csca_get(sms_info_handle, smsc_temp); |
| if(smsc_temp[0] == '\0') |
| { |
| LOGE(GSW_SMS,"gsw_get_smsc_address Error : %d\n", ret); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| else |
| { |
| p1 = strchr(smsc_temp, '\"'); |
| p2 = strrchr(smsc_temp, '\"'); |
| if (p1 && p2 && p2 > p1) |
| { |
| len_t = p2 - p1 - 1; |
| substr = malloc(len_t + 1); |
| if (NULL == substr) |
| { |
| LOGE(GSW_SMS,"substr = NULL, malloc faill!!!\n"); |
| return GSW_HAL_NO_MEMORY; |
| } |
| strncpy(substr, p1 + 1, len_t); |
| substr[len_t] = '\0'; |
| strncpy(smsc, substr, len); |
| strncpy(sms_center_address, substr, len); |
| |
| LOGE(GSW_SMS,"qser_sms_getsmscenteraddress success, smsc = %s\n", sms_center_address); |
| free(substr); |
| substr = NULL; |
| } |
| else |
| { |
| LOGE(GSW_SMS,"String inside double quotes not found\n"); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| } |
| |
| |
| return GSW_HAL_SUCCESS; |
| } |
| |
| /** |
| * @brief set smsc fuction |
| * @param [out] smsc string value for smsc,max length is 32 * |
| * @retval 0: success |
| * @retval other: fail |
| */ |
| int gsw_set_smsc_address(const char *smsc) |
| { |
| int ret = -1; |
| |
| if(init_flag == 0) |
| { |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| if(smsc == NULL || strlen((char *)smsc) == 0) |
| { |
| LOGE(GSW_SMS,"smsc is null or empty\n"); |
| return GSW_HAL_ARG_INVALID; |
| } |
| |
| ret = mbtk_sms_csca_set(sms_info_handle, (char *)smsc); |
| |
| if(ret == 0) |
| { |
| LOGE(GSW_SMS,"set smsc success,smsc = %s\n",smsc); |
| } |
| else |
| { |
| LOGE(GSW_SMS,"set smsc fail,ret = %d\n", ret); |
| return GSW_HAL_NORMAL_FAIL; |
| } |
| |
| return GSW_HAL_SUCCESS; |
| } |