[T106][ZXW-22]7520V3SCV2.01.01.02P42U09_VEC_V0.8_AP_VEC origin source commit
Change-Id: Ic6e05d89ecd62fc34f82b23dcf306c93764aec4b
diff --git a/ap/app/zte_dm/zxic_dm.c b/ap/app/zte_dm/zxic_dm.c
new file mode 100644
index 0000000..7386557
--- /dev/null
+++ b/ap/app/zte_dm/zxic_dm.c
@@ -0,0 +1,3014 @@
+/**
+* @File: sanichips_dm.c
+* @Brief: Implementation of Device Manager in Sanechips
+*
+* Copyright (C) 2017 Sanechips Technology Co., Ltd.
+* @Author: chen tianming <chen.tianming@sanechips.com.cn>
+*
+* This program is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+* */
+
+/*******************************************************************************
+ * Í·Îļþ *
+ ******************************************************************************/
+
+#include <pthread.h>
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/msg.h>
+#include <sys/prctl.h>
+#include "rtc_timer.h"
+#include <stdio.h>
+#include <error.h>
+#include <unistd.h>
+
+#include "cfg_nv_def.h"
+
+#include "softap_api.h"
+#include "unicom_dm.h"
+#include "mobile_dm.h"
+#include "telecom_dm.h"
+/*******************************************************************************
+ * ºê¶¨Òå *
+ ******************************************************************************/
+#define DM_NV_ITEM_SIZE 64
+#define DM_INFO_MAX_SIZE 64
+#define DM_INTERNAL_MSG_SIZE 128
+#define DM_MSG_CMD_REGISTER_REQUEST 0x1000
+#define DM_ROUND_TOTAL 10
+#define DM_MSG_CMD_REGISTER_THREAD_RELEASE 0x1001
+#define DM_MSG_CMD_MAIN_THREAD_EXIT 0x1002
+#define DM_TELECOM_RETRY_TIMES 10
+#define DM_TELECOM_RETRYTIMES_BEFORE_ACTIVED 30
+/*NV name*/
+#define DM_REGISTERED_ROUND "registeredRound"
+#define DM_SECS_EVERY_ROUND "secsEveryRound"
+#define DM_SECS_EVERY_TIME "secsEveryTime"
+#define DM_SEC_TIMER "secsTime"
+#define DM_REGISTER_FLAG "registerFlag"
+#define DM_REGISTER_TYPE "registerDmType"
+
+#define DM_APP_KEY_MOBILE "appKeyMobile"
+#define DM_HOST_NAME "hostName"
+#define DM_PORT_NUM "portNum"
+
+#define DM_MANUF "Manuf"
+#define DM_MODEL "Model"
+#define DM_HW_VERSION "hw_version"
+#define DM_SW_VERSION "wa_version"
+#define DM_OS "OS"
+#define DM_OS_VERSION "OSVersion"
+#define DM_IN_TYPE "Intype"
+#define DM_BRAND "Brand"
+
+#define DM_WCDMA_ONLY "wcdmaModel"
+#define DM_URL_MOBILE "urlMobile"
+
+#define DM_IMEI_PREVIOUS "imeiPrevious"
+#define DM_ICCID_PREVIOUS "iccidPrevious"
+#define DM_VERSION_PREVIOU "versionPrevious"
+#define DM_SIM_CARD_STATUS "creg_stat"
+#define DM_CEREG_STATUS "cereg_stat"
+
+#define DM_REGVER "regver"
+#define DM_MEID "meid"
+#define DM_UETYPE "uetype"
+
+#define DM_SYSTEM_LOCK_FILE_PATH "/sys/power/wake_lock"
+#define DM_SYSTEM_UNLOCK_FILE_PATH "/sys/power/wake_unlock"
+
+
+#define log(...) do { printf(__VA_ARGS__); fflush(stdout); } while(0)
+#define log_err(...) do { log("DM-ERR NOW: FILE(%s) ,LINE(%d) >>>>: ", __FILE__, __LINE__ ); printf(__VA_ARGS__); fflush(stdout);} while(0)
+#ifndef __DM_NO_EBUG__
+#define log_debug(...) do { log("dm-debug now: file(%s) ,line(%d) >>>>: ", __FILE__, __LINE__); printf(__VA_ARGS__); fflush(stdout);} while(0)
+#else
+#define log_debug(...)
+#endif
+
+#define CALL(X) do { int t_ret = (X); if (t_ret != DM_ERR_SUCCESS) { log_err("Get t_ret(%d)\n", t_ret); return t_ret;} } while(0)
+#define CHECK_PARAM(X) do { if(!(X)) {log_err("the param is null\n"); return DM_ERR_PARAM_NULL;} } while(0)
+
+// tap_log(LOG_ERR,MMI_PRINT,"Function rpc_AddObject: %s", ERROR1);
+/*******************************************************************************
+ * Êý¾ÝÀàÐͶ¨Òå *
+ ******************************************************************************/
+
+enum
+{
+ DM_ERR_SUCCESS,
+ DM_ERR_PARAM_NULL,
+ DM_ERR_CREATE_THERAD_ERROR,
+ DM_ERR_CREATE_MSG_QUEUE_ERROR,
+ DM_ERR_DEVICE_TYPE_IS_NONE,
+ DM_ERR_CREATE_TIMER_ERROR,
+ DM_ERR_DEVICE_REGISTERED,
+ DM_ERR_ADD_TIMER_ERROR,
+ DM_ERR_SET_DOMAIN_ERR,
+ DM_ERR_WAITING_NET_STATUS_CHANAGE,
+ DM_ERR_QUEUE_SEND_ERROR,
+ DM_ERR_CHECK_ROUTE_ERROR,
+ DM_ERR_IPC_SEND_MESSAGE_ERROR,
+ DM_ERR_CREATE_JSON_INFO_ERROR,
+ DM_ERR_URL_INFO_CREATE_ERROR,
+ DM_ERR_MOBILE_OVER_RETRY_TMIES_ERROR,
+ DM_ERR_SERVER_ERROR,
+ DM_ERR_SET_TIME_ROUND_ERROR,
+ DM_ERR_NET_ERROR,
+ DM_ERR_RETRY_ERROR,
+ DM_ERR_NO_MOBILE_CARD_ERROR,
+ DM_ERR_ROMAING_STATUS_ERROR,
+};
+
+/* DM ¶¨Ê±Æ÷ID£¬*/
+enum
+{
+ DM_TIMER_ID_UNICOM_START,
+ DM_TIMER_ID_MOBILE_START,
+ DM_TIMER_ID_UNICOM_EVERY_TIMES,
+ DM_TIMER_ID_UNICOM_EVERY_ROUND,
+ DM_TIMER_ID_MOBILE_EVERY_TIMES,
+ DM_TIMER_ID_MAX,
+};
+
+/*DM ×¢²á±ê¼Ç */
+enum
+{
+ DM_REGISTERED_NO,
+ DM_REGISTERED_YES,
+};
+
+/* µ±Ç°ÖÕ¶ËÖÆʽ */
+enum DM_TYPE
+{
+ DM_NO_ONE,
+ DM_MOBILE,
+ DM_UNICOM,
+ DM_TELECOM,
+};
+
+/* ÁªÍ¨ÐÅÏ¢½á¹¹ÌåË÷Òý */
+enum DM_UNICOM_INFO_INDEX
+{
+ DM_INFO_MANUF = 0,
+ DM_INFO_MODEL,
+ DM_INFO_HWVISION,
+ DM_INFO_SWVERSION,
+ DM_INFO_OS,
+ DM_INFO_OSVISION,
+ DM_INFO_IMEI1,
+ DM_INFO_ICCID1,
+ DM_INFO_IMSI1,
+ DM_INFO_MSISDN1,
+ DM_INFO_MNC1,
+ DM_INFO_NCLS1,
+ DM_INFO_CELLID1,
+ DM_INFO_LAC1,
+ DM_INFO_ACCTYPE,
+ DM_INFO_TIME,
+ DM_INFO_TAG,
+ DM_INFO_UNICOM_MAX,
+};
+
+/*struct DM_UNICOM - Áªµ÷×¢²áµÄÐÅÏ¢½á¹¹ÃèÊö */
+struct DM_UNICOM_REGISTER_INFO
+{
+ char value[DM_INFO_UNICOM_MAX][DM_INFO_MAX_SIZE];
+};
+
+/* Òƶ¯DMÐÅÏ¢½á¹¹Ë÷Òý */
+typedef enum
+{
+ DM_INFO_MOBILE_SDKVERSION = 0,
+ DM_INFO_MOBILE_IMEI1,
+ DM_INFO_MOBILE_IMEI2,
+ DM_INFO_MOBILE_MEID,
+ DM_INFO_MOBILE_DEVICE_ID,
+ DM_INFO_MOBILE_BRAND,
+ DM_INFO_MOBILE_MODEL,
+ DM_INFO_MOBILE_FIRMWARE_VERSION,
+ DM_INFO_MOBILE_SYSTEM_VERSION,
+ DM_INFO_MOBILE_CPU,
+ DM_INFO_MOBILE_ROM,
+ DM_INFO_MOBILE_RAM,
+ DM_INFO_MOBILE_TYPE,
+ DM_INFO_MOBILE_ICCID1,
+ DM_INFO_MOBILE_ICCID2,
+ DM_INFO_MOBILE_IMSI1,
+ DM_INFO_MOBILE_IMSI2,
+ DM_INFO_MOBILE_MAC,
+ DM_INFO_MOBILE_CELLID,
+ DM_INFO_MOBILE_LAC,
+ DM_INFO_MOBILE_CHNL,
+ DM_INFO_MOBILE_DATA_CARD,
+ DM_INFO_MOBILE_MASTER_STATUS,
+ DM_INFO_MOBILE_SEND_TIME,
+ DM_INFO_MOBILE_SLOT_QUANTITY,
+ DM_INFO_MOBILE_DATA_CARD2,
+ DM_INFO_MOBILE_SLOT_SERVICE1,
+ DM_INFO_MOBILE_SLOT_SERVICE2,
+ DM_INFO_MOBILE_SLOT_NETWORK1,
+ DM_INFO_MOBILE_SLOT_NETWORK2,
+ DM_INFO_MOBILE_LAC2,
+ DM_INFO_MOBILE_CELLID2,
+ DM_INFO_MOBILE_TERMINAL_INTTYPE,
+ DM_INFO_MOBILE_MAX
+} DM_INFO_MOBILE_INDEX;
+
+/*struct DM_MOBILE_INFO Òƶ¯×¢²áµÄÐÅÏ¢½á¹¹ÃèÊö */
+struct DM_MOBILE_REGISTER_INFO
+{
+ char value[DM_INFO_MOBILE_MAX][DM_INFO_MAX_SIZE];
+};
+
+/* µçÐÅÐÅÏ¢½á¹¹ÌåË÷Òý */
+enum DM_TELECOM_INFO_INDEX
+{
+ DM_INFO_REGVER = 0,
+ DM_INFO_MEID,
+ DM_INFO_MODELSMS,
+ DM_INFO_SWVER,
+ DM_INFO_SIM1CDMAIMSI,
+ DM_INFO_UETYPE,
+ DM_INFO_SIM1ICCID,
+ DM_INFO_SIM1LTEIMSI,
+ DM_INFO_IMEI,
+ DM_INFO_BASEID1,
+ DM_INFO_SIM1TYPE,
+ DM_INFO_SID,
+ DM_INFO_NID,
+ DM_INFO_TELECOM_MAX,
+};
+
+/*struct DM_TELECOM - µçÐÅ×¢²áµÄÐÅÏ¢½á¹¹ÃèÊö */
+struct DM_TELECOM_REGISTER_INFO
+{
+ char value[DM_INFO_TELECOM_MAX][DM_INFO_MAX_SIZE];
+};
+
+/**
+ * @brief struct DM_CONTROl_INFO DMÄ£¿éÄÚ²¿ÐÅÏ¢ÃèÊö
+ * @param DM_TYPE:dm ÀàÐÍ moblie unicom telecom
+ * @param registErThreadFlag:×¢²áÏ̱߳ê¼Ç£¬×¢²áÍê³ÉÍ˳öÏß³Ì
+ * @param mainThreadFlag:Ö÷Ï̱߳ê¼Ç£¬×¢²áÍê³ÉÍ˳öÏß³Ì
+ * @param secTimer: dm¿ª»ú¶¨Ê±Ê±¼ä
+ * @param pid:·þÎñÏ̵߳ÄID
+ * @param serverPid:Ö÷Ïß³ÌID
+ * @param msgQueueId:Ö÷ÏûÏ¢¶ÓÁеÄID
+ * @param msgQueueIdReg:×¢²áÏß³ÌÏûÏ¢¶ÓÁÐID
+ * @param registerFlag:×¢²á±êÖ¾£¬±ê¼ÇÊÇ·ñÒѾע²á
+ * @param secsEveryRound:ÿÂÖ¼ä¸ôµÄʱ¼ä
+ * @param secsEveryTime:ÿ´Î¼ä¸ôµÄʱ¼ä
+ * @param registerTimesEveryRound:ÿÂÖ³¢ÊԵĴÎÊý
+ * @param registerRoundsCurrent:µ±Ç°¿ª»ú³¢ÊÔµÄÂÖÊý
+ * @param registeredRounds:ÒѾ³¢ÊÔµÄÂÖÊý
+ * @param currentRouds:µ±Ç°³¢ÊÔ×¢²áµÄÂÛÊý
+ * @param currentTimes:µ±Ç°³¢ÊÔ×¢²áµÄ´ÎÊý
+ * @param netStatus:±ê¼Çµ±Ç°µÄÍøÂç״̬
+ * @param imeiPrevious:ÉÏÒ»´Î±£´æµÄimei
+ * @param iccidprevious:ÉÏÒ»´Î±£´æµÄiccid
+ * @param hostName:·þÎñÆ÷ÓòÃû
+ * @param ipAddr:·þÎñÆ÷µØÖ·
+ * @param portNum:·þÎñÆ÷¶Ë¿Ú
+ * @note
+ * @warning
+ */
+struct DM_CONTROl_INFO
+{
+ enum DM_TYPE dmType;
+ int registErThreadFlag;
+ int mainThreadFlag;
+ int secTimer;
+ pthread_t pid;
+ pthread_t serverId;
+ int msgQueueId;
+ int msgQueueIdReg;
+ int registerFlag;
+ int secsEveryRound;
+ int secsEveryTime;
+ int registeredRounds;
+ int currentRounds;
+ int currentTimes;
+ int netStatus;
+ int globalRomaing;
+ int cardType;
+ int needRegForNetStatusChange;
+ char hostName[DM_INFO_MAX_SIZE];
+ char imeiPrevious[DM_INFO_MAX_SIZE];
+ char iccidPrevious[DM_INFO_MAX_SIZE];
+ char ipAddr[32];
+ unsigned long portNum;
+};
+
+/*******************************************************************************
+ * ¾²Ì¬±äÁ¿¶¨Òå *
+ ******************************************************************************/
+static int g_retrytimes_before_netactived = 0;
+
+/*******************************************************************************
+ * ¾²Ì¬º¯Êý¶¨Òå *
+ ******************************************************************************/
+static int dm_control_info_init(struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_register_thread_init(struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_timer_create(struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_server_init(struct DM_CONTROl_INFO *dmControlInfo);
+
+static void* dm_server_thread_entry(void* args);
+static void dm_register_queue_msg_proc(MSG_BUF *pstMsg, struct DM_CONTROl_INFO *dmControlInfo);
+
+static int dm_get_device_type(struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_unicom_control_info_init(struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_mobile_control_info_init(struct DM_CONTROl_INFO *dmControlInfo);
+
+static void dm_wake_lock(const char *lockName);
+static void dm_wake_unlock(const char *unLockName);
+static void dm_write_lockfile(const char *filepath, const char *setbuf);
+
+static int dm_timer_add(unsigned long sec, RTC_ID rtcId);
+
+static void dm_register_flag_clean(struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_server_domain_config_set(MSG_BUF *pstMsg, struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_net_status_change_proc(struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_register_request_handle(struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_mobile_register_request_handle(struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_unicom_register_request_handle(struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_net_global_romaing_proc(struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_unicom_register_start(struct DM_CONTROl_INFO *dmControlInfo);
+
+static int dm_register_msg_send(struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_unicom_url_info_create(struct DM_CONTROl_INFO *dmControlInfo, struct DM_UNICOM_REGISTER_INFO *dmUnicomRegInfo, DM_UNICOM_HTTP_URL_INFO *dmUnicomUrlInfo);
+static int dm_mobile_url_info_create(struct DM_CONTROl_INFO *dmControlInfo, struct DM_MOBILE_REGISTER_INFO *dmMobileRegInfo, DM_MOBILE_HTTPS_URL_INIO *dmMobileUrlInfo);
+
+static int dm_unicom_json_info_create(struct DM_UNICOM_REGISTER_INFO *dmUnicomRegInfo, DM_UNICOM_HTTP_DATA_INFO * httpsDataInfo) ;
+static int dm_mobile_json_info_create(struct DM_MOBILE_REGISTER_INFO *dmMobileRegInfo, DM_MOBILE_HTTPS_DATA_INFO * httpsDataInfo);
+static int dm_unicom_register_info_create(struct DM_CONTROl_INFO *dmControlInfo, struct DM_UNICOM_REGISTER_INFO *dmUnicomRegInfo);
+static int dm_mobile_register_info_create(struct DM_CONTROl_INFO *dmControlInfo, struct DM_MOBILE_REGISTER_INFO *dmMobileRegInfo);
+static void dm_resource_clean(struct DM_CONTROl_INFO *dmControlInfo, void *dataInfo);
+static int dm_register_time_set(struct DM_CONTROl_INFO *dmControlInfo, void *dataInfo);
+static void dm_register_tag_set(struct DM_CONTROl_INFO *dmControlInfo, struct DM_UNICOM_REGISTER_INFO *dmUnicomRegInfo);
+static int dm_mobile_register_start(struct DM_CONTROl_INFO *dmControlInfo);
+
+static int dm_config_info_msg_prc(MSG_BUF *pstMsg, struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_time_every_round_set(MSG_BUF *pstMsg, struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_server_port_num_set(MSG_BUF *pstMsg, struct DM_CONTROl_INFO *dmControlInfo);
+static void dm_data_channel_set(struct DM_MOBILE_REGISTER_INFO *dmMobileRegInfo);
+static int dm_register_thread_release(struct DM_CONTROl_INFO *dmControlInfo);
+static int dm_main_thread_release(struct DM_CONTROl_INFO *dmControlInfo);
+static void dm_rtc_timer_del();
+static int dm_telecom_register_request_handle(struct DM_CONTROl_INFO *dmControlInfo);
+BOOL dm_telecom_need_reg_check(struct DM_CONTROl_INFO *dmControlInfo);
+
+/**
+ * º¯ÊýÃû³Æ£º dm_get_device_type
+ * ¹¦ÄÜÃèÊö£º »ñÈ¡µ±Ç°µÄÉ豸ÀàÐÍ£ºÁªµ÷DM / Òƶ¯DM
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º ³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_get_device_type(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ char dmType[4] = {0};
+ char registerFlag[4] = {0};
+
+ CALL(sc_cfg_get(DM_REGISTER_TYPE, dmType, sizeof(dmType)));
+ CALL(sc_cfg_get(DM_REGISTER_FLAG, registerFlag, sizeof(registerFlag)));
+
+ dmControlInfo->dmType = atoi(dmType);
+ dmControlInfo->registerFlag = atoi(registerFlag);
+
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£º dm_write_lockfile
+ * ¹¦ÄÜÃèÊö£º ÎļþдÈë×Ö·û²Ù×÷
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ */
+static void dm_write_lockfile(const char *filepath, const char *setbuf)
+{
+ int fd = -1;
+ int len = 0;
+ if (!filepath || !setbuf)
+ {
+ log_err("parm is null \n");
+ return;
+ }
+
+ fd = open(filepath, O_RDWR);
+ if (-1 == fd)
+ {
+ log_err("open lockfile fail\n");
+ return;
+ }
+
+ len = strlen(setbuf);
+ if (write(fd, setbuf, len) != len)
+ {
+ log_err("write lockfile fail\n");
+ }
+
+ close(fd);
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_wake_lock
+ * ¹¦ÄÜÃèÊö£ºDMÄ£¿éϵͳ˯ÃßÉÏËø
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ */
+static void dm_wake_lock(const char *lockName)
+{
+ dm_write_lockfile(DM_SYSTEM_LOCK_FILE_PATH, lockName);
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_wake_lock
+ * ¹¦ÄÜÃèÊö£ºDMÄ£¿éϵͳ˯Ãß½âËø
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£ºÎÞ
+ * ÆäËü˵Ã÷£º
+ */
+static void dm_wake_unlock(const char *unLockName)
+{
+ dm_write_lockfile(DM_SYSTEM_UNLOCK_FILE_PATH, unLockName);
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_timer_add
+ * ¹¦ÄÜÃèÊö£ºÌí¼ÓRTC¶¨Ê±Æ÷
+ * ²ÎÊý˵Ã÷£ºsec: ·ÖÖÓ
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ */
+static int dm_timer_add(unsigned long sec, RTC_ID rtcId)
+{
+ int ret = 0;
+ if (0 != (ret = rtc_timer_add(sec, rtcId, MODULE_ID_DMREG)))
+ {
+ log_err("dm add timer error... ret-value(%d)\n", ret);
+ return DM_ERR_ADD_TIMER_ERROR;
+ }
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_create_timer
+ * ¹¦ÄÜÃèÊö£ºDMÄ£¿é´´½¨rtc¶¨Ê±Æ÷
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_timer_create(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(dmControlInfo);
+
+ if (DM_UNICOM == dmControlInfo->dmType && DM_REGISTERED_NO == dmControlInfo->registerFlag)
+ {
+
+ CALL(dm_timer_add(dmControlInfo->secTimer * 60, DM_TIMER_ID_UNICOM_START));
+ log_debug("dm timer create success: dmType(%d), secTimer(%d)\n", dmControlInfo->dmType, dmControlInfo->secTimer);
+ }
+ else if (DM_MOBILE == dmControlInfo->dmType)
+ {
+
+ CALL(dm_timer_add(10, DM_TIMER_ID_MOBILE_START));
+ log_debug("dm timer create success: dmType(%d), secTimer(%d)\n", dmControlInfo->dmType, dmControlInfo->secTimer);
+ }
+ else if(DM_TELECOM == dmControlInfo->dmType)
+ {
+ CALL(dm_timer_add(10, DM_TIMER_ID_MOBILE_START));
+ log_debug("dm timer create success: dmType(%d), secTimer(%d)\n", dmControlInfo->dmType, dmControlInfo->secTimer);
+ }
+ else
+ {
+
+ log_debug("dm do not need to create timer, because dm have registered or registerRound more than 10...\n");
+ }
+
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_net_status_change_proc
+ * ¹¦ÄÜÃèÊö£ºPDPÏûÏ¢Éϱ¨´¦Àíº¯Êý£¬¼àÌýÍøÂç״̬±ä»¯
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_net_status_change_proc(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(dmControlInfo);
+ char netStatus[4] = {0};
+ char romaingStatus[DM_NV_ITEM_SIZE] = {0};
+
+ CALL(sc_cfg_get(NV_PDP_STATUS, netStatus, 4));
+ CALL(sc_cfg_get(NV_SIMCARD_ROAM, romaingStatus, sizeof(romaingStatus)));
+
+ dmControlInfo->netStatus = atoi(netStatus);
+
+ if (0 == strcmp(romaingStatus, "Internal"))
+ {
+ dmControlInfo->globalRomaing = 1;
+ }
+ else if (0 == strcmp(romaingStatus, "Home"))
+ {
+ dmControlInfo->globalRomaing = 0;
+ }
+ else
+ {
+ log_err("dm global romaing some error, romaingStatus(%s) \n ", romaingStatus);
+ return DM_ERR_WAITING_NET_STATUS_CHANAGE;
+ }
+
+ /* ÍøÂçÊý¾Ý¿ª¹Ø´ò¿ª£¬ Çҷǹú¼ÊÂþÓÎ */
+ if (dmControlInfo->netStatus && !dmControlInfo->globalRomaing)
+ {
+
+ /* ÏÂÃæ±ê¼ÇµÄ¹¦ÄÜÊÇ: ¶¨Ê±Æ÷³¬Ê±£¬¶øÓÉÓÚÍøÂç¹Ø±Õ£¬±ØÐëµÈ´ýÍøÂ翪¹Ø´ò¿ª½øÐÐ×¢²á
+ * Ðë±£Ö¤´Î±êÖ¾Ö»ÄÜÔÚ×¢²áÏß³ÌÖнøÐÐÐ޸ģ¬(Ô¤·À±äÁ¿¶àÏ߳̽»²æÐÞ¸Ä)
+ */
+ if (dmControlInfo->needRegForNetStatusChange == 1)
+ {
+ /* ÏûÏ¢·¢ËÍ£¬¿ªÊ¼×¢²áÁ÷³Ì */
+ CALL(dm_register_msg_send(dmControlInfo));
+ }
+ }
+
+ log_debug("dm net change now netstatus(%d), romaing(%d), netStatus(%s), romaingStatus(%s),needRegForNetStatusChange(%d) \n", dmControlInfo->netStatus, dmControlInfo->globalRomaing, netStatus, romaingStatus, dmControlInfo->needRegForNetStatusChange);
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_server_port_num_set
+ * ¹¦ÄÜÃèÊö£º×¢²áµÄ·þÎñÆ÷¶Ë¿ÚºÅÅäÖÃ(ÓÉCP²à¹¤³ÌÃüÁî´¥·¢)
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_server_port_num_set(MSG_BUF *pstMsg, struct DM_CONTROl_INFO *dmControlInfo)
+{
+ char *msgData = (char *) pstMsg->aucDataBuf;
+ char *portNum = NULL;
+ char port[12] = {0};
+
+ if (!(portNum = strstr(msgData, "AT+DM_REGISTER_PORT_NUM=")))
+ {
+ log_err("dm set portNum erro , can not find server portNum \n");
+ return DM_ERR_SET_DOMAIN_ERR;
+ }
+
+ portNum = portNum + strlen("AT+DM_REGISTER_PORT_NUM=");
+ sscanf(portNum, "%10[^,]", port);
+
+ /*È·È϶˿ںÅÊÇ·ñºÏ·¨*/
+ if (!strcmp(port, "6001") || !strcmp(port, "6002"))
+ {
+ dmControlInfo->portNum = atol(port);
+ sc_cfg_set(DM_PORT_NUM, port);
+ }
+ else /* ²»ºÏ·¨£¬¹¹Ôì´íÎóµÄport£¬ 0 < port < 65535*/
+ {
+ dmControlInfo->portNum = 65539;
+ sc_cfg_set(DM_PORT_NUM, "65539");
+ }
+
+ log_debug("dm set server portNum config now: server-portNum(%d)\n", dmControlInfo->portNum);
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_set_server_domain_config
+ * ¹¦ÄÜÃèÊö£º×¢²áµÄ·þÎñÆ÷µØÖ·ÓòÃûÅäÖÃ(ÓÉcp²à¹¤³ÌÃüÁî´¥·¢)
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_server_domain_config_set(MSG_BUF *pstMsg, struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(pstMsg);
+ CHECK_PARAM(dmControlInfo);
+
+ char *msgData = (char *) pstMsg->aucDataBuf;
+ char *server = NULL;
+
+ if (!(server = strstr(msgData, "AT+DM_REGISTER_SERVER=")))
+ {
+ log_err("dm server domain set error\n");
+ return DM_ERR_SET_DOMAIN_ERR;
+ }
+
+ memset(dmControlInfo->hostName, 0, DM_INFO_MAX_SIZE);
+ server = server + strlen("AT+DM_REGISTER_SERVER=");
+ sscanf(server, "%32[^,]", dmControlInfo->hostName);
+
+ sc_cfg_set(DM_HOST_NAME, dmControlInfo->hostName);
+
+ log_debug("dm set server domain config now: server-domain(%s)\n", dmControlInfo->hostName);
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_clean_register_flag
+ * ¹¦ÄÜÃèÊö£ºÉèÖÃ×¢²áÿÂÖµÄʱ¼ä ¼ä¸ô£¬(ÓÉcp²àµÄ¹¤³ÌÃüÁî´¥·¢)
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º ³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_time_every_round_set(MSG_BUF *pstMsg, struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(pstMsg);
+ CHECK_PARAM(dmControlInfo);
+
+ char *msgData = (char *) pstMsg->aucDataBuf;
+ char *time = NULL;
+ char timeValue[12] = {0};
+
+ if (!(time = strstr(msgData, "AT+DM_REGISTER_SECS_ROUND=")))
+ {
+ log_err("dm set time evry round error\n");
+ return DM_ERR_SET_TIME_ROUND_ERROR;
+ }
+
+ time = time + strlen("AT+DM_REGISTER_SECS_ROUND=");
+
+ sscanf(time, "%10[^,]", timeValue);
+ dmControlInfo->secsEveryRound = atoi(timeValue);
+ sc_cfg_set(DM_SECS_EVERY_ROUND, timeValue);
+
+ log_debug("dm every round set now, timeValue(%s)", timeValue);
+ return DM_ERR_SUCCESS;
+}
+
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_rtc_timer_del
+ * ¹¦ÄÜÃèÊö£ºÉ¾³ýËùÓеĶ¨Ê±Æ÷
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£ºÎÞ
+ * ÆäËü˵Ã÷£º
+ */
+static void dm_rtc_timer_del(void)
+{
+ int index = 0;
+ int ret = 0;
+ for (index = DM_TIMER_ID_UNICOM_START; index < DM_TIMER_ID_MAX; index++)
+ {
+ ret = rtc_timer_del(index, MODULE_ID_DMREG);
+ log_debug("del rtc id(%d), ret(%d)\n", index, ret);
+ }
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_clean_register_flag
+ * ¹¦ÄÜÃèÊö£ºÇå³ý×¢²áµÄ״̬±ê¼Ç£¬±íÃ÷É豸ûÓÐ×¢²á(CP ²à¹¤³ÌÃüÁî´¥·¢)
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º ÎÞ
+ * ÆäËü˵Ã÷£º
+ */
+static void dm_register_flag_clean(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ sc_cfg_set(DM_REGISTER_FLAG, "0");
+ sc_cfg_set(DM_REGISTERED_ROUND, "0");
+ dmControlInfo->currentRounds = 0;
+ dmControlInfo->currentTimes = 0;
+ dmControlInfo->registeredRounds = 0;
+ dmControlInfo->registerFlag = 0;
+
+ if (DM_MOBILE == dmControlInfo->dmType)
+ {
+ sc_cfg_set(DM_IMEI_PREVIOUS, "0");
+ sc_cfg_set(DM_ICCID_PREVIOUS, "0");
+ sc_cfg_set(DM_VERSION_PREVIOU, "");
+ }
+
+ /*ɾ³ýËùÓеĶ¨Ê±Æ÷*/
+ dm_rtc_timer_del();
+
+ dm_register_thread_release(dmControlInfo);
+ log_debug("dm register flag clean now: \n");
+}
+
+#if 0 /*±£ÁôΪºóÐøÀ©Õ¹*/
+/**
+ * º¯ÊýÃû³Æ£ºdm_msg_request_info_send
+ * ¹¦ÄÜÃèÊö£ºÇëÇóbl²ã¸üÐÂNVÐÅÏ¢£¬
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ */
+static long dm_msg_request_info_send(unsigned short targetId, unsigned short msgCmd, unsigned short dataLen, unsigned char *data, int flag)
+{
+ /* ctm MODULE_ID_AT_CTL */
+ long ret = 0;
+ if (0 != (ret = ipc_send_message(MODULE_ID_DMREG, targetId, msgCmd, dataLen, data, flag)))
+ return DM_ERR_IPC_SEND_MESSAGE_ERROR;
+ log_debug("dm msg request send now: targetId(0x%04x), msgCmd(0x%08x), dataLen(%d)\n", targetId, msgCmd, dataLen);
+ return DM_ERR_SUCCESS;
+}
+#endif
+
+/**
+* º¯ÊýÃû³Æ£ºdm_register_msg_send
+* ¹¦ÄÜÃèÊö£º·¢ËÍ×¢²áÏûÏ¢µ½×¢²áÏß³Ì,·¢Æð×¢²áÁ÷³Ì
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+* ÆäËü˵Ã÷£º
+*/
+static int dm_register_msg_send(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(dmControlInfo);
+ int ret = 0;
+ long size = 0;
+ MSG_BUF msgBuf = {0};
+
+ msgBuf.usMsgCmd = DM_MSG_CMD_REGISTER_REQUEST;
+ size = sizeof(MSG_BUF) - sizeof(long);
+
+ msgBuf.ulMagic = MSG_MAGIC_WORD;
+ msgBuf.lMsgType = MSG_TYPE_DEFAULT;
+
+ /* ·¢ËÍÏûÏ¢µ½ ×¢²áÏß³Ì ·¢Æð×¢²áÁ÷³Ì */
+ ret = msgsnd(dmControlInfo->msgQueueIdReg, (void*) & (msgBuf), size, 0);
+ if (ret < 0)
+ {
+ log_err("unicom startup proc send msg errro \n");
+ return DM_ERR_QUEUE_SEND_ERROR;
+ }
+
+ return DM_ERR_SUCCESS;
+}
+
+/**
+* º¯ÊýÃû³Æ£º dm_mobile_register_start
+* ¹¦ÄÜÃèÊö£º Òƶ¯DM×¢²áÁ÷³Ì¿ªÊ¼
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º ³É¹¦ 0: ʧ°Ü ´íÎóÂë
+* ÆäËü˵Ã÷£º
+*/
+static int dm_mobile_register_start(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ char *dataBuf = NULL;
+ int dataSize = 0;
+ int ret = 0;
+ char imei[DM_NV_ITEM_SIZE] = {0};
+ char iccid[DM_NV_ITEM_SIZE] = {0};
+ char version[DM_NV_ITEM_SIZE] = {0};
+ DM_MOBILE_HTTPS_URL_INIO dmMobileUrlInfo = {{0}, {0}, {0}, 0, 0};
+ DM_MOBILE_HTTPS_DATA_INFO dmMobileHttpsDataInfo = {0};
+ struct DM_MOBILE_REGISTER_INFO dmMobileRegInfo ;
+
+ dataSize = (DM_NV_ITEM_SIZE + DM_NV_ITEM_SIZE / 4 + 5) * DM_INFO_MOBILE_MAX;
+
+ if (!(dataBuf = (char *) malloc(dataSize)))
+ {
+ log_err("dm unicom start reg malloc mem error\n");
+ return DM_ERR_PARAM_NULL;
+ }
+ memset(dataBuf, 0, dataSize);
+ dmMobileHttpsDataInfo.dataBuffer = dataBuf;
+ dmMobileHttpsDataInfo.dataLen = dataSize;
+
+ ret = dm_mobile_register_info_create(dmControlInfo, &dmMobileRegInfo);
+ if(DM_ERR_SUCCESS != ret)
+ {
+ goto ErrRet;
+ }
+ ret = dm_mobile_json_info_create(&dmMobileRegInfo, &dmMobileHttpsDataInfo);
+ if(DM_ERR_SUCCESS != ret)
+ {
+ goto ErrRet;
+ }
+ ret = dm_mobile_url_info_create(dmControlInfo, &dmMobileRegInfo, &dmMobileUrlInfo);
+ if(DM_ERR_SUCCESS != ret)
+ {
+ goto ErrRet;
+ } //klockworks issue.
+
+ ret = dm_mobile_https_request(&dmMobileUrlInfo, &dmMobileHttpsDataInfo);
+
+ if (0 == ret)
+ {
+ /*×¢²á³É¹¦£¬±£´æNV */
+ char buf[4] = {0};
+ dmControlInfo->registerFlag = DM_REGISTERED_YES;
+ snprintf(buf, 3, "%d", dmControlInfo->registerFlag);
+ sc_cfg_set("registerFlag", buf); //ctm
+
+ /*дÈëIMEI ICCID ºÅ*/
+ sc_cfg_get(NV_IMEI, imei, sizeof(imei));
+ sc_cfg_get(NV_ZICCID, iccid, sizeof(iccid));
+ sc_cfg_get(DM_SW_VERSION, version, sizeof(version));
+
+ sc_cfg_set(DM_IMEI_PREVIOUS, imei);
+ sc_cfg_set(DM_ICCID_PREVIOUS, iccid);
+
+ /*дÈë°æ±¾ºÅ£¬ÎªfotaÉý¼¶ºó DM ×¢²áµÄÒÀ¾Ý*/
+ sc_cfg_set(DM_VERSION_PREVIOU, version);
+
+ dm_resource_clean(dmControlInfo, (void *) &dmMobileHttpsDataInfo);
+ return DM_ERR_SUCCESS;
+ }
+
+ dm_resource_clean(dmControlInfo, &dmMobileHttpsDataInfo);
+ log_debug("dm start register start: debug info as following ************\n");
+ log_debug("dm currentTimes(%d)\n", dmControlInfo->currentTimes);
+ log_debug("dm register secTimer(%d), , secsEveryTime(%d), netStatus(%d), globalRomaing(%d)\n",
+ dmControlInfo->secTimer,
+ dmControlInfo->secsEveryTime,
+ dmControlInfo->netStatus,
+ dmControlInfo->globalRomaing);
+
+ return DM_ERR_RETRY_ERROR;
+
+ErrRet:
+ free(dataBuf);
+ return ret;
+}
+
+/**
+* º¯ÊýÃû³Æ£ºdm_register_request_handle
+* ¹¦ÄÜÃèÊö£ºÒƶ¯dm ×¢²áÇëÇó´¦Àí
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+* ÆäËü˵Ã÷£º
+*/
+static int dm_mobile_register_request_handle(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(dmControlInfo);
+
+ int ret = 0;
+ int checkTimes = 10;
+ char romaingStatus[DM_NV_ITEM_SIZE] = {0};
+ char netStatus[DM_NV_ITEM_SIZE] = {0};
+
+ /*»ñÈ¡ ״ֵ̬*/
+ CALL(sc_cfg_get(NV_PDP_STATUS, netStatus, sizeof(netStatus)));
+ CALL(sc_cfg_get(NV_SIMCARD_ROAM, romaingStatus, sizeof(romaingStatus)));
+ dmControlInfo->netStatus = atoi(netStatus);
+
+ if (0 == strcmp(romaingStatus, "Internal"))
+ {
+ dmControlInfo->globalRomaing = 1;
+ }
+ else if (0 == strcmp(romaingStatus, "Home"))
+ {
+ dmControlInfo->globalRomaing = 0;
+ }
+ else
+ {
+ log_err("dm global romaing some error, romaingStatus(%s) \n ", romaingStatus);
+ return DM_ERR_WAITING_NET_STATUS_CHANAGE;
+ }
+
+ if (dmControlInfo->currentTimes >= 10)
+ {
+ log_debug("dm mobile register 10 times now...");
+ return DM_ERR_MOBILE_OVER_RETRY_TMIES_ERROR;
+ }
+
+ /* 1¡¢Êý¾ÝÁ´Â·¹Ø±Õ£¬»ò
+ * 2¡¢Êý¾ÝÁ´Â·´ò¿ª£¬ÇÒÔÚ¹ú¼ÊÂþÓÎ
+ */
+ if (dmControlInfo->netStatus == 0 || (dmControlInfo->netStatus == 1 && dmControlInfo->globalRomaing == 1))
+ {
+ /*Òƶ¯µÄ¹æ·¶ÖÐ˵Ã÷£¬´Ë´ÎÒ²¼ÆÈë³¢ÊÔ´ÎÊýÖÐ */
+ dmControlInfo->currentTimes++;
+
+ if (dmControlInfo->currentTimes < 10)
+ {
+ /*1¡¢Óû§Í¨¹ý¹¤³ÌÃüÁîÉèÖà ·½±ã²âÊÔÈËÔ±½øÐвâÊÔ£¬´ËÖµ´úÌæÐÒé¹æ¶¨µÄÕæʵµÄ´Î¼ä¸ôʱ¼ä£¬Ëõ¶Ì²âÊÔʱ¼ä
+ *2¡¢Ä¬ÈÏÖµ0,±íʾʹÓÃÕæʵµÄ´Î¼ä¸ôʱ¼ä£¬·Ç0 ±íʾʹÓôËÉèÖõÄÖµ´úÌæ*/
+ if (0 != dmControlInfo->secsEveryRound)
+ {
+ dmControlInfo->secsEveryTime = dmControlInfo->secsEveryRound;
+ }
+ else
+ {
+ dmControlInfo->secsEveryTime = dmControlInfo->currentTimes * 10;
+ }
+
+ dm_timer_add(dmControlInfo->secsEveryTime * 60, DM_TIMER_ID_MOBILE_EVERY_TIMES);
+ }
+
+ log_debug(" startup_proc now, net status(%d), globalRomaing(%d), currentTimes(%d)\n", dmControlInfo->netStatus, dmControlInfo->globalRomaing, dmControlInfo->currentTimes);
+ return DM_ERR_WAITING_NET_STATUS_CHANAGE;
+ }
+
+ while (checkTimes-- > 0)
+ {
+ if (1 == default_route_check())
+ break;
+ usleep(1000 * 500);
+ log_debug("mobile startup check rout times(%d)\n", checkTimes);
+ if (checkTimes == 0)
+ {
+ log_err("dm net some error occur\n");
+ return DM_ERR_CHECK_ROUTE_ERROR;
+ }
+ }
+
+ dmControlInfo->currentTimes++; /*´ÎÊý½øÐмÆÊý */
+ /*·¢Æðhttp´«Êä¼ÓÃܵÈÁ÷³Ì */
+ if (DM_ERR_SUCCESS != (ret = dm_mobile_register_start(dmControlInfo)))
+ {
+ /* ³¢ÊÔ×¢²áµÄ´ÎÊýСÓÚ 10 ´Îʱ£¬¼ÌÐø³¢ÊÔ */
+ if (dmControlInfo->currentTimes < 10)
+ {
+ /*1¡¢dmControlInfo->secsEveryRound Óû§Í¨¹ý¹¤³ÌÃüÁîÉèÖÃ,Ä¿µÄÊÇ·½±ã²âÊÔÈËÔ±½øÐвâÊÔ£¬
+ * ´ËÖµ´úÌæÐÒé¹æ¶¨µÄÕæʵµÄ´Î¼ä¸ôʱ¼ä£¬Ëõ¶Ì²âÊÔʱ¼ä£»
+ *2¡¢Ä¬ÈÏÖµ0,±íʾʹÓÃÕæʵµÄ´Î¼ä¸ôʱ¼ä£¬·Ç0 ±íʾʹÓôËÉèÖõÄÖµ´úÌæ²âÊÔ */
+ if (0 != dmControlInfo->secsEveryRound)
+ {
+ dmControlInfo->secsEveryTime = dmControlInfo->secsEveryRound;
+ }
+ else
+ {
+ dmControlInfo->secsEveryTime = dmControlInfo->currentTimes * 10;
+ }
+ /* ʧ°ÜÆô¶¯Ã¿´Î³¢ÊÔ¶¨Ê±Æ÷ */
+ dm_timer_add(dmControlInfo->secsEveryTime * 60, DM_TIMER_ID_MOBILE_EVERY_TIMES);
+ }
+
+ log_debug("dm mobile register error, ret(%d), currentTimes(%d), next-rtc-time(%d)\n", ret, dmControlInfo->currentTimes, dmControlInfo->secsEveryTime);
+ return ret;
+ }
+
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£º dm_mobile_url_info_create
+ * ¹¦ÄÜÃèÊö£º ¹¹ÔìÒƶ¯DMµÄ·þÎñÆ÷ urlÐÅÏ¢£¬°üÀ¨ ·þÎñÆ÷µØÖ·£¬¶Ë¿ÚµÈÐÅÏ¢£¬
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º ³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_mobile_url_info_create(struct DM_CONTROl_INFO *dmControlInfo, struct DM_MOBILE_REGISTER_INFO *dmMobileRegInfo, DM_MOBILE_HTTPS_URL_INIO *dmMobileUrlInfo)
+{
+ char mobileAppkey[DM_NV_ITEM_SIZE] = {0};
+ CHECK_PARAM(dmControlInfo);
+ CHECK_PARAM(dmMobileRegInfo);
+ CHECK_PARAM(dmMobileUrlInfo);
+ CHECK_PARAM(dmMobileUrlInfo->urlBuffer);
+
+ sc_cfg_get("appKeyMobile", mobileAppkey, DM_NV_ITEM_SIZE);
+
+ memset(dmMobileUrlInfo, 0, sizeof(DM_MOBILE_HTTPS_URL_INIO));
+ snprintf(dmMobileUrlInfo->urlBuffer, DM_HTTPS_HEAD_DATA_LENGTH - 1, "/accept/featureService?func=tsdk:postotherreg&appkey=%s", mobileAppkey);
+
+ snprintf(dmMobileUrlInfo->hostName, DM_NV_ITEM_SIZE - 1, "%s", dmControlInfo->hostName);
+
+ snprintf(dmMobileUrlInfo->ipAddr, 31, "%s", dmControlInfo->ipAddr);
+
+ dmMobileUrlInfo->portNum = dmControlInfo->portNum;
+
+ log_debug("dm unicom url-info debug: ulr(%s), portNum(%ld), hostName(%s)\n ", dmMobileUrlInfo->urlBuffer, dmMobileUrlInfo->portNum, dmMobileUrlInfo->hostName);
+
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_unicom_json_info_create
+ * ¹¦ÄÜÃèÊö£º¹¹ÔìÁªÍ¨ÐÒé¹æ·¶json¸ñʽÊý¾Ý
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_unicom_json_info_create(struct DM_UNICOM_REGISTER_INFO *dmUnicomRegInfo, DM_UNICOM_HTTP_DATA_INFO *httpsDataInfo)
+{
+ CHECK_PARAM(dmUnicomRegInfo);
+ CHECK_PARAM(httpsDataInfo);
+
+ int i = 0;
+ char *pTmep = NULL;
+ int jsonSize = 0;
+ char *unicomItemName[] = {"Manuf", "Model", "HWVersion", "SWVersion",
+ "OS", "OSVersion", "IMEI1", "ICCID1",
+ "IMSI1", "MSISDN1", "MNC1", "NCLS1",
+ "CellID1", "LAC1", "AccType", "Time", "Tag"
+ };
+ /*json fromat as following
+ * {"key1":"key1Value","key2":"key2Value", xxxxx}*/
+ log_debug("dm unicom json infof ***********\n");
+
+ pTmep = httpsDataInfo->dataBuffer;
+ memset(pTmep, 0, httpsDataInfo->dataLen);
+ for (i = 0; i < DM_INFO_UNICOM_MAX; i++)
+ {
+ if (i == 0)
+ sprintf(pTmep, "{\"%s\":\"%s\"", unicomItemName[i], dmUnicomRegInfo->value[i]);
+ else if (i == DM_INFO_UNICOM_MAX - 1)
+ sprintf(pTmep, ",\"%s\":\"%s\"}", unicomItemName[i], dmUnicomRegInfo->value[i]);
+ else
+ sprintf(pTmep, ",\"%s\":\"%s\"", unicomItemName[i], dmUnicomRegInfo->value[i]);
+
+ log_debug("json-value(%s)\n", pTmep);
+ jsonSize = jsonSize + strlen(pTmep);
+ pTmep = pTmep + strlen(pTmep);
+
+ if (jsonSize > httpsDataInfo->dataLen)
+ log_err("json buffer memory overwrite now! please check memory size, jsonSize(%d), httpsDatainfo-size(%d) !!!\n", jsonSize, httpsDataInfo->dataLen);
+ }
+
+ httpsDataInfo->dataLen = jsonSize;
+ log_debug("create json info, json-szie(%d)\n", jsonSize);
+
+ return DM_ERR_SUCCESS;
+}
+
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_mobile_json_info_create
+ * ¹¦ÄÜÃèÊö£º¹¹ÔìÒƶ¯ÐÒé¹æ·¶json¸ñʽÊý¾Ý
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_mobile_json_info_create(struct DM_MOBILE_REGISTER_INFO *dmMobileRegInfo, DM_MOBILE_HTTPS_DATA_INFO *httpsDataInfo)
+{
+ CHECK_PARAM(dmMobileRegInfo);
+ CHECK_PARAM(httpsDataInfo);
+ CHECK_PARAM(httpsDataInfo->dataBuffer);
+ int i = 0;
+ char *pTmep = NULL;
+ int jsonSize = 0;
+
+ /*Áªµ÷¹æ·¶Êý¾Ý£¬¶¨Öµ */
+ char *mobileItemName[] = {"sdkVersion", "imei1", "imei2", "meid", "deviceId", "brand",
+ "model", "firmwareVer", "systemVer", "cpu", "rom", "ram", "type", "iccid1", "iccid2", "imsi1", "imsi2",
+ "mac", "cellId", "lac", "channel", "dataCard", "masterStatus", "sendTime", "soltQuantity",
+ "dataCard2", "soltService1", "soltService2", "soltNetwork1", "soltNetwork2", "lac2", "cellId2", "Intype"
+ };
+
+ log_debug("dm mobile json infof ***********\n");
+ pTmep = httpsDataInfo->dataBuffer;
+ memset(pTmep, 0, httpsDataInfo->dataLen);
+ for (i = 0; i < DM_INFO_MOBILE_MAX; i++)
+ {
+ if (i == 0)
+ sprintf(pTmep, "{\"%s\":\"%s\"", mobileItemName[i], dmMobileRegInfo->value[i]);
+ else if (i == DM_INFO_MOBILE_MAX - 1)
+ sprintf(pTmep, ",\"%s\":\"%s\"}", mobileItemName[i], dmMobileRegInfo->value[i]);
+ else
+ sprintf(pTmep, ",\"%s\":\"%s\"", mobileItemName[i], dmMobileRegInfo->value[i]);
+
+ log_debug("json-value[%d](%s)\n", i, pTmep);
+ jsonSize = jsonSize + strlen(pTmep);
+ pTmep = pTmep + strlen(pTmep);
+
+ if (jsonSize > httpsDataInfo->dataLen)
+ {
+ log_err("json buffer memory overwrite now! please check memory size, jsonSize(%d), httpsDatainfo-size(%d) !!!\n", jsonSize, httpsDataInfo->dataLen);
+ return DM_ERR_CREATE_JSON_INFO_ERROR;
+ }
+ }
+
+ httpsDataInfo->dataLen = jsonSize;
+ log_debug("json-szie(%d)\n", jsonSize);
+
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_set_register_tag
+ * ¹¦ÄÜÃèÊö£ºÁªÍ¨DMµÄÐÒéTagÖµÉèÖÃ
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static void dm_register_tag_set(struct DM_CONTROl_INFO *dmControlInfo, struct DM_UNICOM_REGISTER_INFO *dmUnicomRegInfo)
+{
+ snprintf(dmUnicomRegInfo->value[DM_INFO_TAG], 63, "%d,%d,%d", dmControlInfo->registeredRounds, dmControlInfo->currentRounds, dmControlInfo->currentTimes);
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_register_time_set
+ * ¹¦ÄÜÃèÊö£ºDMÐÒé¸ñʽ¹æ¶¨µÄʱ¼ä¸ñʽÉèÖÃ
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_register_time_set(struct DM_CONTROl_INFO *dmControlInfo, void *dataInfo)
+{
+ CHECK_PARAM(dataInfo);
+ char timeBuf[DM_NV_ITEM_SIZE] = {0};
+ struct DM_MOBILE_REGISTER_INFO *dmMobileRegInfo = NULL;
+ struct DM_UNICOM_REGISTER_INFO *dmUnicomRegInfo = NULL;
+ time_t t = {0};
+ struct tm *area = NULL;
+
+ t = time(NULL);
+ area = (struct tm *) localtime(&t);
+
+ if (!area)
+ {
+ log_err("dm set register time error\n");
+ return DM_ERR_PARAM_NULL;
+ }
+ strftime(timeBuf, 63, "%Y-%m-%d %H:%M:%S", area);
+
+ if (DM_UNICOM == dmControlInfo->dmType)
+ {
+ dmUnicomRegInfo = (struct DM_UNICOM_REGISTER_INFO *) dataInfo;
+ snprintf(dmUnicomRegInfo->value[DM_INFO_TIME], DM_NV_ITEM_SIZE - 1, "%s", timeBuf);
+ }
+
+ if (DM_MOBILE == dmControlInfo->dmType)
+ {
+ dmMobileRegInfo = (struct DM_MOBILE_REGISTER_INFO *) dataInfo;
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SEND_TIME], DM_NV_ITEM_SIZE - 1, "%s", timeBuf);
+ }
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_unicom_register_info_create
+ * ¹¦ÄÜÃèÊö: ¹¹ÔìÁªÍ¨DMÐÒé¹æ·¶Ö¸¶¨µÄ×¢²áÐÅÏ¢
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_unicom_register_info_create(struct DM_CONTROl_INFO *dmControlInfo, struct DM_UNICOM_REGISTER_INFO *dmUnicomRegInfo)
+{
+ CHECK_PARAM(dmUnicomRegInfo);
+ char mmc[DM_NV_ITEM_SIZE] = {0};
+ char dmUnicomNvInfo[DM_NV_ITEM_SIZE] = {0};
+ int index = 0;
+
+ memset(dmUnicomRegInfo, 0, sizeof(struct DM_UNICOM_REGISTER_INFO));
+
+#ifndef DM_TEST_DEBUG
+ /*³§ÉÌÐͺÅ*/
+ CALL(sc_cfg_get(DM_MANUF, dmUnicomNvInfo, DM_NV_ITEM_SIZE));
+ snprintf(dmUnicomRegInfo->value[DM_INFO_MANUF], DM_NV_ITEM_SIZE - 1, "%s", dmUnicomNvInfo);
+
+ /*³§ÉÌ´úÂë*/
+ memset(dmUnicomNvInfo, 0, DM_NV_ITEM_SIZE);
+ CALL(sc_cfg_get(DM_MODEL, dmUnicomNvInfo, DM_NV_ITEM_SIZE));
+ snprintf(dmUnicomRegInfo->value[DM_INFO_MODEL], DM_NV_ITEM_SIZE - 1, "%s", dmUnicomNvInfo);
+
+ /*Ó²¼þ°æ±¾ºÅ*/
+ memset(dmUnicomNvInfo, 0, DM_NV_ITEM_SIZE);
+ CALL(sc_cfg_get(NV_HW_VERSION, dmUnicomNvInfo, DM_NV_ITEM_SIZE));
+ snprintf(dmUnicomRegInfo->value[DM_INFO_HWVISION], DM_NV_ITEM_SIZE - 1, "%s", dmUnicomNvInfo);
+
+ /*Èí¼þ°æ±¾ºÅ*/
+ memset(dmUnicomNvInfo, 0, DM_NV_ITEM_SIZE);
+ CALL(sc_cfg_get(NV_WA_VERSION, dmUnicomNvInfo, DM_NV_ITEM_SIZE));
+ snprintf(dmUnicomRegInfo->value[DM_INFO_SWVERSION], DM_NV_ITEM_SIZE - 1, "%s", dmUnicomNvInfo);
+
+ snprintf(dmUnicomRegInfo->value[DM_INFO_OS], DM_NV_ITEM_SIZE - 1, "%s", "TOS");
+
+ snprintf(dmUnicomRegInfo->value[DM_INFO_OSVISION], DM_NV_ITEM_SIZE - 1, "%s", "1.0");
+
+ memset(dmUnicomNvInfo, 0, DM_NV_ITEM_SIZE);
+ CALL(sc_cfg_get(NV_IMEI, dmUnicomNvInfo, DM_NV_ITEM_SIZE));
+ snprintf(dmUnicomRegInfo->value[DM_INFO_IMEI1], DM_NV_ITEM_SIZE - 1, "%s", dmUnicomNvInfo);
+
+ memset(dmUnicomNvInfo, 0, DM_NV_ITEM_SIZE);
+ CALL(sc_cfg_get(NV_MCC, dmUnicomNvInfo, DM_NV_ITEM_SIZE));
+ CALL(sc_cfg_get(NV_MNC, mmc, DM_NV_ITEM_SIZE));
+ snprintf(dmUnicomRegInfo->value[DM_INFO_MNC1], DM_NV_ITEM_SIZE - 1, "%s%s", dmUnicomNvInfo, mmc);
+
+ /*ÍøÂçÀàÐÍ LTE, WCDMA, GSM, TD-CDMA, ÁªÍ¨ÐèÒª´óÖÆʽ */
+ memset(dmUnicomNvInfo, 0, DM_NV_ITEM_SIZE);
+ CALL(sc_cfg_get(NV_NETWORK_TYPE, dmUnicomNvInfo, DM_NV_ITEM_SIZE));
+ if (!strcmp(dmUnicomNvInfo, "GPRS")) /* ÐÒé¹æ·¶ GPRS->GSM */
+ {
+ snprintf(dmUnicomRegInfo->value[DM_INFO_NCLS1], DM_NV_ITEM_SIZE - 1, "%s", "GSM");
+ }
+ else
+ {
+ snprintf(dmUnicomRegInfo->value[DM_INFO_NCLS1], DM_NV_ITEM_SIZE - 1, "%s", dmUnicomNvInfo);
+ }
+
+ if (1 == dmControlInfo->cardType) /* Òƶ¯¿¨ ,ÐÒé¹æ·¶Ö¸¶¨ Ϊ 1*/
+ {
+ snprintf(dmUnicomRegInfo->value[DM_INFO_ICCID1], DM_NV_ITEM_SIZE - 1, "%s", "11111111111111111111");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_IMSI1], DM_NV_ITEM_SIZE - 1, "%s", "111111111111111");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_MSISDN1], DM_NV_ITEM_SIZE - 1, "%s", "11111111111");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_CELLID1], DM_NV_ITEM_SIZE - 1, "%s", "1111");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_LAC1], DM_NV_ITEM_SIZE - 1, "%s", "1111");
+
+ }
+ else if (3 == dmControlInfo->cardType) /*µçÐÅ¿¨£¬ÐÒé¹æ·¶Ö¸¶¨Îª 3*/
+ {
+ snprintf(dmUnicomRegInfo->value[DM_INFO_ICCID1], DM_NV_ITEM_SIZE - 1, "%s", "33333333333333333333");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_IMSI1], DM_NV_ITEM_SIZE - 1, "%s", "333333333333333");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_MSISDN1], DM_NV_ITEM_SIZE - 1, "%s", "33333333333");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_CELLID1], DM_NV_ITEM_SIZE - 1, "%s", "3333");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_LAC1], DM_NV_ITEM_SIZE - 1, "%s", "3333");
+
+ }
+ else if (2 == dmControlInfo->cardType)
+ {
+ memset(dmUnicomNvInfo, 0, DM_NV_ITEM_SIZE);
+ CALL(sc_cfg_get(NV_ZICCID, dmUnicomNvInfo, DM_NV_ITEM_SIZE));
+ snprintf(dmUnicomRegInfo->value[DM_INFO_ICCID1], DM_NV_ITEM_SIZE - 1, "%s", dmUnicomNvInfo);
+
+ memset(dmUnicomNvInfo, 0, DM_NV_ITEM_SIZE);
+ CALL(sc_cfg_get(NV_MSISDN, dmUnicomNvInfo, DM_NV_ITEM_SIZE));
+ snprintf(dmUnicomRegInfo->value[DM_INFO_MSISDN1], DM_NV_ITEM_SIZE - 1, "%s", dmUnicomNvInfo);
+
+ memset(dmUnicomNvInfo, 0, DM_NV_ITEM_SIZE);
+ CALL(sc_cfg_get(NV_SIM_IMSI, dmUnicomNvInfo, DM_NV_ITEM_SIZE));
+ snprintf(dmUnicomRegInfo->value[DM_INFO_IMSI1], DM_NV_ITEM_SIZE - 1, "%s", dmUnicomNvInfo);
+
+ /*СÇøλÖÃÐÅÏ¢1 */
+ memset(dmUnicomNvInfo, 0, DM_NV_ITEM_SIZE);
+ CALL(sc_cfg_get(NV_CELL_ID, dmUnicomNvInfo, DM_NV_ITEM_SIZE));
+ snprintf(dmUnicomRegInfo->value[DM_INFO_CELLID1], DM_NV_ITEM_SIZE - 1, "%s", dmUnicomNvInfo);
+
+ /*СÇøλÖÃÐÅÏ¢2 */
+ memset(dmUnicomNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_NETWORK_TYPE, dmUnicomNvInfo, DM_NV_ITEM_SIZE);
+ if (!strcmp(dmUnicomNvInfo, "LTE")) /* 4GÍøÂç */
+ {
+ memset(dmUnicomNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_TAC_CODE, dmUnicomNvInfo, DM_NV_ITEM_SIZE);
+ snprintf(dmUnicomRegInfo->value[DM_INFO_LAC1], DM_NV_ITEM_SIZE - 1, "%s", dmUnicomNvInfo);
+ }
+ else /* ·Ç4GÍøÂç */
+ {
+ memset(dmUnicomNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_LAC_CODE, dmUnicomNvInfo, DM_NV_ITEM_SIZE);
+ snprintf(dmUnicomRegInfo->value[DM_INFO_LAC1], DM_NV_ITEM_SIZE - 1, "%s", dmUnicomNvInfo);
+ }
+ }
+ else
+ {
+ log_err("dm there is unknow card type\n");
+ return DM_ERR_PARAM_NULL;
+ }
+#else // for test debug
+ snprintf(dmUnicomRegInfo->value[DM_INFO_MANUF], DM_NV_ITEM_SIZE - 1, "%s", "BestSonny");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_MODEL], DM_NV_ITEM_SIZE - 1, "%s", "Best sonny LT589");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_HWVISION], DM_NV_ITEM_SIZE - 1, "%s", "K312-MB-V0.2A");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_SWVERSION], DM_NV_ITEM_SIZE - 1, "%s", "K312-HUASEN-BEST-SONNY-LT589-QVGA-SC-B10P02_170609_1700");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_OS], DM_NV_ITEM_SIZE - 1, "%s", "TOS");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_OSVISION], DM_NV_ITEM_SIZE - 1, "%s", "1.0");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_IMEI1], DM_NV_ITEM_SIZE - 1, "%s", "865062030001015");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_MNC1], DM_NV_ITEM_SIZE - 1, "%s", "46001");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_NCLS1], DM_NV_ITEM_SIZE - 1, "%s", "LTE");
+
+ if (1 == dmControlInfo->cardType) /*Òƶ¯¿¨*/
+ {
+ snprintf(dmUnicomRegInfo->value[DM_INFO_ICCID1], DM_NV_ITEM_SIZE - 1, "%s", "11111111111111111111");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_IMSI1], DM_NV_ITEM_SIZE - 1, "%s", "111111111111111");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_MSISDN1], DM_NV_ITEM_SIZE - 1, "%s", "11111111111");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_CELLID1], DM_NV_ITEM_SIZE - 1, "%s", "1111");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_LAC1], DM_NV_ITEM_SIZE - 1, "%s", "1111");
+
+ }
+ else if (3 == dmControlInfo->cardType) /*µçÐÅ¿¨*/
+ {
+ snprintf(dmUnicomRegInfo->value[DM_INFO_ICCID1], DM_NV_ITEM_SIZE - 1, "%s", "33333333333333333333");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_IMSI1], DM_NV_ITEM_SIZE - 1, "%s", "333333333333333");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_MSISDN1], DM_NV_ITEM_SIZE - 1, "%s", "33333333333");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_CELLID1], DM_NV_ITEM_SIZE - 1, "%s", "3333");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_LAC1], DM_NV_ITEM_SIZE - 1, "%s", "3333");
+
+ }
+ else
+ {
+
+ snprintf(dmUnicomRegInfo->value[DM_INFO_ICCID1], DM_NV_ITEM_SIZE - 1, "%s", "89860114834067295358");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_IMSI1], DM_NV_ITEM_SIZE - 1, "%s", "460011675515843");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_MSISDN1], DM_NV_ITEM_SIZE - 1, "%s", "18551770057");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_CELLID1], DM_NV_ITEM_SIZE - 1, "%s", "101387885");
+ snprintf(dmUnicomRegInfo->value[DM_INFO_LAC1], DM_NV_ITEM_SIZE - 1, "%s", "53515");
+ }
+#endif
+
+ snprintf(dmUnicomRegInfo->value[DM_INFO_ACCTYPE], 10, "%s", "Mobile");
+ CALL(dm_register_time_set(dmControlInfo, dmUnicomRegInfo));
+ dm_register_tag_set(dmControlInfo, dmUnicomRegInfo);
+
+ log_debug("dm unicom get register from NV now ...\n");
+ for (index = 0; index < DM_INFO_UNICOM_MAX; index++)
+ {
+ log_debug("Unicom info VALUE[%d] = %s\n", index, (dmUnicomRegInfo->value) [index]);
+
+ }
+
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_data_channel_set
+ * ¹¦ÄÜÃèÊö£ºÒÀ¾ÝDMÐÒé¹æ·¶£¬ÉèÖÃÊý¾ÝͨµÀÏî±ê¼Ç
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static void dm_data_channel_set(struct DM_MOBILE_REGISTER_INFO *dmMobileRegInfo)
+{
+ char dmMobileNvInfo[DM_NV_ITEM_SIZE] = {0};
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_SUB_NETWORK_TYPE, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+
+ if (strstr(dmMobileNvInfo, "GPRS"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 1);
+ }
+ else if (strstr(dmMobileNvInfo, "EDGE"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 2);
+ }
+ else if (strstr(dmMobileNvInfo, "UMTS"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 3);
+ }
+ else if (strstr(dmMobileNvInfo, "CDMA"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 4);
+ }
+ else if (strstr(dmMobileNvInfo, "EVDO_0"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 5);
+ }
+ else if (strstr(dmMobileNvInfo, "EVDO_A"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 6);
+ }
+ else if (strstr(dmMobileNvInfo, "HSDPA"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 8);
+ }
+ else if (strstr(dmMobileNvInfo, "HSUPA"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 9);
+ }
+ else if (strstr(dmMobileNvInfo, "HSPA"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 10);
+ }
+ else if (strstr(dmMobileNvInfo, "IDEN"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 11);
+ }
+ else if (strstr(dmMobileNvInfo, "EVDO_B"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 12);
+ }
+ else if (strstr(dmMobileNvInfo, "LTE"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 13);
+ }
+ else if (strstr(dmMobileNvInfo, "EHRPD"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 14);
+ }
+ else if (strstr(dmMobileNvInfo, "HSPAP"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 15);
+ }
+ else if (strstr(dmMobileNvInfo, "GSM"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 16);
+ }
+ else if (strstr(dmMobileNvInfo, "TD-SCDMA"))
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 17);
+ }
+ else
+ {
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL], DM_NV_ITEM_SIZE - 1, "%d", 0);
+ log_debug("dm data channel set , unknow the network_type(%s)\n", dmMobileNvInfo);
+ }
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_mobile_register_info_create
+ * ¹¦ÄÜÃèÊö£º¹¹ÔìÒƶ¯ÐÒé¹æ·¶Ö¸¶¨µÄ×¢²áÐÅÏ¢
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_mobile_register_info_create(struct DM_CONTROl_INFO *dmControlInfo, struct DM_MOBILE_REGISTER_INFO *dmMobileRegInfo)
+{
+ CHECK_PARAM(dmMobileRegInfo);
+ char dmMobileNvInfo[DM_NV_ITEM_SIZE] = {0};
+ int index = 0;
+
+ memset(dmMobileRegInfo, 0, sizeof(struct DM_MOBILE_REGISTER_INFO));
+
+#ifndef DM_TEST_DEBUG
+ /*SDK °æ±¾*/
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SDKVERSION], DM_NV_ITEM_SIZE - 1, "%s", "1.0.1");
+
+ /*imei ºÅ*/
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_IMEI, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_IMEI1], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_IMEI2], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_MEID], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ /* ¹¦ÄÜ»úÎÞid ,ÓÃiemiºÅ´úÌæ */
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_DEVICE_ID], DM_NV_ITEM_SIZE - 1, "%s", dmMobileRegInfo->value[DM_INFO_MOBILE_IMEI1]);
+
+ /*ÖÕ¶ËÆ·ÅÆ*/
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(DM_BRAND, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_BRAND], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+
+ /*ÖÕ¶ËÐͺÅ*/
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(DM_MODEL, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_MODEL], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+
+ /*Èí¼þ°æ±¾*/
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(DM_SW_VERSION, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_FIRMWARE_VERSION], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+
+ /*Èí¼þ°æ±¾ºÅ*/
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SYSTEM_VERSION], DM_NV_ITEM_SIZE - 1, "%s", "1.0");
+
+ /*ƽ̨CPUÐͺŠ*/
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CPU], DM_NV_ITEM_SIZE - 1, "%s", "ZX297520V3");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_ROM], DM_NV_ITEM_SIZE - 1, "%s", "128MB");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_RAM], DM_NV_ITEM_SIZE - 1, "%s", "128MB");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_TYPE], DM_NV_ITEM_SIZE - 1, "%s", "1");
+
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_ZICCID, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_ICCID1], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_ICCID2], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_SIM_IMSI, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_IMSI1], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_IMSI2], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_MAC], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_CELL_ID, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CELLID], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_NETWORK_TYPE, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ if (!strcmp(dmMobileNvInfo, "LTE")) /* 4GÍøÂç */
+ {
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_TAC_CODE, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_LAC], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+ }
+ else /* ·Ç4GÍøÂç */
+ {
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_LAC_CODE, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_LAC], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+ }
+
+ /*ÍøÂçÊý¾ÝÀàÐÍ 4g 3G 2G*/
+ dm_data_channel_set(dmMobileRegInfo);
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_DATA_CARD], DM_NV_ITEM_SIZE - 1, "%s", "2");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_MASTER_STATUS], DM_NV_ITEM_SIZE - 1, "%s", "0");
+
+ /*ÉèÖÃÊý¾ÝͨµÀ*/
+ CALL(dm_register_time_set(dmControlInfo, (void *) dmMobileRegInfo));
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SLOT_QUANTITY], DM_NV_ITEM_SIZE - 1, "%s", "1");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_DATA_CARD2], DM_NV_ITEM_SIZE - 1, "%s", "-1");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SLOT_SERVICE1], DM_NV_ITEM_SIZE - 1, "%s", "5");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SLOT_SERVICE2], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ /* slot-network µÄÖµºÍÊý¾ÝͨµÀÖµÏàͬ(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL])*/
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SLOT_NETWORK1], DM_NV_ITEM_SIZE - 1, "%s", dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL]);
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SLOT_NETWORK2], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_LAC2], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CELLID2], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(DM_IN_TYPE, dmMobileNvInfo, DM_NV_ITEM_SIZE); /*ÈëÍøÐͺÅ*/
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_TERMINAL_INTTYPE], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+
+ log_debug("dm mobile get register from NV now ...\n");
+
+ for (index = 0; index < DM_INFO_MOBILE_MAX; index++)
+ {
+ log_debug("Mobile info VALUE[%d] = %s\n", index, (dmMobileRegInfo->value) [index]);
+ }
+
+#else
+
+ /*SDK °æ±¾*/
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SDKVERSION], DM_NV_ITEM_SIZE - 1, "%s", "1.0.1");
+
+ /*imei ºÅ*/
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_IMEI, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ //snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_IMEI1], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_IMEI1], DM_NV_ITEM_SIZE - 1, "%s", "864023030000167");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_IMEI2], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_MEID], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ /* ¹¦ÄÜ»úÎÞid ,ÓÃiemiºÅ´úÌæ */
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_DEVICE_ID], DM_NV_ITEM_SIZE - 1, "%s", dmMobileRegInfo->value[DM_INFO_MOBILE_IMEI1]);
+
+ //memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ //sc_cfg_get(DM_BRAND, dmMobileNvInfo, DM_NV_ITEM_SIZE); // ÖÕ¶ËÆ·ÅÆ
+ //snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_BRAND], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_BRAND], DM_NV_ITEM_SIZE - 1, "%s", "CFZZ");
+
+ //memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ //sc_cfg_get(DM_MODEL, dmMobileNvInfo, DM_NV_ITEM_SIZE); //ÖÕ¶ËÐͺÅ
+ //snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_MODEL], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_MODEL], DM_NV_ITEM_SIZE - 1, "%s", "OK-W6");
+
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(DM_HW_VERSION, dmMobileNvInfo, DM_NV_ITEM_SIZE); // Ó²¼þ°æ±¾ºÅ
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_FIRMWARE_VERSION], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+
+ /*Èí¼þ°æ±¾ºÅ*/
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SYSTEM_VERSION], DM_NV_ITEM_SIZE - 1, "%s", "1.0");
+
+ /*ƽ̨CPUÐͺŠ*/
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CPU], DM_NV_ITEM_SIZE - 1, "%s", "ZX297520V3");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_ROM], DM_NV_ITEM_SIZE - 1, "%s", "128MB");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_RAM], DM_NV_ITEM_SIZE - 1, "%s", "128MB");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_TYPE], DM_NV_ITEM_SIZE - 1, "%s", "1");
+
+ //memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ //sc_cfg_get(NV_ZICCID, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ //snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_ICCID1], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_ICCID1], DM_NV_ITEM_SIZE - 1, "%s", "89860065101750003921");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_ICCID2], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_SIM_IMSI, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_IMSI1], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_IMSI2], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_MAC], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_CELL_ID, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CELLID], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+
+ memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_LAC_CODE, dmMobileNvInfo, DM_NV_ITEM_SIZE);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_LAC], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+
+ /*ÍøÂçÊý¾ÝÀàÐÍ 4g 3G 2G*/
+ dm_data_channel_set(dmMobileRegInfo);
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_DATA_CARD], DM_NV_ITEM_SIZE - 1, "%s", "2");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_MASTER_STATUS], DM_NV_ITEM_SIZE - 1, "%s", "0");
+
+ CALL(dm_register_time_set(dmControlInfo, (void *) dmMobileRegInfo));
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SLOT_QUANTITY], DM_NV_ITEM_SIZE - 1, "%s", "1");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_DATA_CARD2], DM_NV_ITEM_SIZE - 1, "%s", "-1");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SLOT_SERVICE1], DM_NV_ITEM_SIZE - 1, "%s", "5");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SLOT_SERVICE2], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ /* slot-network µÄÖµºÍÊý¾ÝͨµÀÖµÏàͬ(dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL])*/
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SLOT_NETWORK1], DM_NV_ITEM_SIZE - 1, "%s", dmMobileRegInfo->value[DM_INFO_MOBILE_CHNL]);
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_SLOT_NETWORK2], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_LAC2], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_CELLID2], DM_NV_ITEM_SIZE - 1, "%s", "unknow");
+
+ //memset(dmMobileNvInfo, 0, DM_NV_ITEM_SIZE);
+ //sc_cfg_get(DM_IN_TYPE, dmMobileNvInfo, DM_NV_ITEM_SIZE); /*ÈëÍøÐͺÅ*/
+ //snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_TERMINAL_INTTYPE], DM_NV_ITEM_SIZE - 1, "%s", dmMobileNvInfo);
+ snprintf(dmMobileRegInfo->value[DM_INFO_MOBILE_TERMINAL_INTTYPE], DM_NV_ITEM_SIZE - 1, "%s", "OK-W6");
+
+ log_debug("dm mobile get register from NV now ...\n");
+
+ for (index = 0; index < DM_INFO_MOBILE_MAX; index++)
+ {
+ log_debug("Mobile info VALUE[%d] = %s\n", index, (dmMobileRegInfo->value) [index]);
+ }
+#endif
+ return DM_ERR_SUCCESS;
+}
+
+/**
+* º¯ÊýÃû³Æ£ºdm_unicom_url_info_create
+* ¹¦ÄÜÃèÊö£º¹¹ÔìÁªÍ¨dm ulrÐÅÏ¢,°üÀ¨·þÎñÆ÷µØÖ·£¬¶Ë¿ÚºÅµÈ
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+* ÆäËü˵Ã÷£º
+*/
+static int dm_unicom_url_info_create(struct DM_CONTROl_INFO *dmControlInfo, struct DM_UNICOM_REGISTER_INFO *dmUnicomRegInfo, DM_UNICOM_HTTP_URL_INFO *dmUnicomUrlInfo)
+{
+ int ret = 0;
+ CHECK_PARAM(dmControlInfo);
+ CHECK_PARAM(dmUnicomRegInfo);
+ CHECK_PARAM(dmUnicomUrlInfo);
+ CHECK_PARAM(dmUnicomUrlInfo->urlBuffer);
+
+ memset(dmUnicomUrlInfo, 0, sizeof(DM_UNICOM_HTTP_URL_INFO));
+ ret = snprintf(dmUnicomUrlInfo->urlBuffer, URL_INFO_LINE_SIZE - 1, "http://%s:%ld/register?ver=1.1&model=%s&manuf=%s&sign=", dmControlInfo->hostName, dmControlInfo->portNum, & ((dmUnicomRegInfo->value) [DM_INFO_MODEL][0]), & ((dmUnicomRegInfo->value) [DM_INFO_MANUF][0]));
+ if (ret <= 0)
+ return DM_ERR_URL_INFO_CREATE_ERROR;
+
+ ret = snprintf(dmUnicomUrlInfo->hostName, DM_NV_ITEM_SIZE - 1, "%s", dmControlInfo->hostName);
+ if (ret < 0)
+ return DM_ERR_URL_INFO_CREATE_ERROR;
+
+ ret = snprintf(dmUnicomUrlInfo->ipAddr, 31, "%s", dmControlInfo->ipAddr);
+ if (ret < 0)
+ return DM_ERR_URL_INFO_CREATE_ERROR;
+
+ dmUnicomUrlInfo->portNum = dmControlInfo->portNum;
+
+ log_debug("dm unicom url-info debug: ulr(%s), portNum(%ld), hostName(%s)\n ", dmUnicomUrlInfo->urlBuffer, dmUnicomUrlInfo->portNum, dmUnicomUrlInfo->hostName);
+ return DM_ERR_SUCCESS;
+}
+
+
+/**
+* º¯ÊýÃû³Æ£ºdm_register_thread_release
+* ¹¦ÄÜÃèÊö£ºÍ¨Öª×¢²áỊ̈߳¬Í˳öÏß³Ì
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+* ÆäËü˵Ã÷£º²»ÄÜʹÓÃpthread_xxxÏà¹Øº¯ÊýÍ˳ö(ϵͳ˯ÃßËø´æÔÚ£¬Ðë±£Ö¤Åä¶ÔÖ´ÐÐÍê)
+*/
+static int dm_register_thread_release(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(dmControlInfo);
+ int ret = 0;
+ long size = 0;
+ MSG_BUF msgBuf = {0};
+ msgBuf.usMsgCmd = DM_MSG_CMD_REGISTER_THREAD_RELEASE;
+ size = sizeof(MSG_BUF) - sizeof(long);
+ msgBuf.lMsgType = 1;
+
+ /* ·¢ËÍÏûÏ¢µ½ ×¢²áÏß³Ì ·¢Æð×¢²áÁ÷³Ì */
+ ret = msgsnd(dmControlInfo->msgQueueIdReg, (void*) & (msgBuf), size, 0);
+ if (ret < 0)
+ {
+ log_err("unicom thread release msg errro ret(%d) \n", ret);
+ return DM_ERR_QUEUE_SEND_ERROR;
+ }
+
+ return DM_ERR_SUCCESS;
+}
+
+/**
+* º¯ÊýÃû³Æ£ºdm_resource_clean
+* ¹¦ÄÜÃèÊö£º×¢²áÍê³É£¬»ò³ö´í£¬ÄÚ´æµÄÊÍ·Å, ֪ͨÏß³ÌÍ˳ö
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£º
+*/
+static void dm_resource_clean(struct DM_CONTROl_INFO *dmControlInfo, void *dataInfo)
+{
+ DM_UNICOM_HTTP_DATA_INFO *dmUnicomHttpDataInfo = NULL;
+ DM_MOBILE_HTTPS_DATA_INFO *dmMobileHttpsDataInfo = NULL;
+
+ if (DM_UNICOM == dmControlInfo->dmType)
+ {
+ dmUnicomHttpDataInfo = (DM_UNICOM_HTTP_DATA_INFO *) dataInfo;
+ if (dmUnicomHttpDataInfo)
+ {
+ if (dmUnicomHttpDataInfo->dataBuffer)
+ {
+ free(dmUnicomHttpDataInfo->dataBuffer);
+ dmUnicomHttpDataInfo->dataBuffer = NULL;
+ dmUnicomHttpDataInfo->dataLen = 0;
+ }
+ }
+ }
+
+ if (DM_MOBILE == dmControlInfo->dmType)
+ {
+ dmMobileHttpsDataInfo = (DM_MOBILE_HTTPS_DATA_INFO *) dataInfo;
+ if (dmMobileHttpsDataInfo)
+ {
+ if (dmMobileHttpsDataInfo->dataBuffer)
+ {
+ free(dmMobileHttpsDataInfo->dataBuffer);
+ dmMobileHttpsDataInfo->dataBuffer = NULL;
+ dmMobileHttpsDataInfo->dataLen = 0;
+ }
+ }
+ }
+
+ /*±£´æNV±ê¼Ç */
+ if (DM_REGISTERED_YES == dmControlInfo->registerFlag)
+ {
+ char registerRounds[4] = {0};
+ snprintf(registerRounds, 3, "%d", 0);
+ sc_cfg_set(DM_REGISTERED_ROUND, registerRounds);
+
+ dm_rtc_timer_del();
+ log_debug("dm register success now...\n");
+ }
+
+ if ((DM_UNICOM == dmControlInfo->dmType) && (10 < dmControlInfo->registeredRounds || 3 < dmControlInfo->currentRounds))
+ {
+ dm_rtc_timer_del();
+ log_debug("dm unicom have registered total registerRounds(%d) or rounds(%d) on starting up\n", dmControlInfo->registeredRounds, dmControlInfo->currentRounds);
+ }
+
+ if ((DM_MOBILE == dmControlInfo->dmType) && (10 < dmControlInfo->currentTimes))
+ {
+ dm_rtc_timer_del();
+ log_debug("dm unicom have registered total times(%d) on starting up\n", dmControlInfo->currentTimes);
+ }
+}
+
+/**
+* º¯ÊýÃû³Æ£ºdm_unicom_register_start
+* ¹¦ÄÜÃèÊö£ºÁªÍ¨DM×¢²áÁ÷³Ì¿ªÊ¼
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+* ÆäËü˵Ã÷£ºÁªÍ¨DM×¢²áÌá½»¿ªÊ¼£¬·ÖÎö´úÂëÇë×¢ÒâÒÔÏÂϸ½Ú:
+* ÁªÍ¨ÐÒé¹æ·¶Ö¸¶¨£¬Èç¹û×¢²á²»³É¹¦£¬ÐèÒª½øÐжà´Î³¢ÊÔ×¢²á
+* 1¡¢¿ª»ú°ëСʱºó·¢Æð×¢²áÁ÷³Ì
+* 2¡¢Ã¿´Î¿ª»ú³¢ÊÔ3ÂÖ£¬Ã¿ÂÖ¼ä¸ôÊÇ6¸öСʱ£¬Ã¿ÂÖÀïÃæÓÖ°üº¬Èý´Î£¬Ã¿´ÎµÄ¼ä¸ôÊÇ6·ÖÖÓ£¬¹ÊÒ»´Î¿ª»ú×î¶à³¢ÊÔ9´Î
+* 3¡¢Ã¿Ò»ÂÖµÄÊýÄ¿£¬Ã¿Ò»´ÎÊýÄ¿£¬¶¼Òª±£´æ£¬×÷Ϊע²áÐÅÏ¢Ò»²¿·Ö£¬Ìá½»¸øÁªÍ¨·þÎñÆ÷¡£
+* 4¡¢¶à´Î¿ª»úºó£¬µ±×¢²áµÄ×ܵÄÂÖÊý£¬´ïµ½10,²»³¬¹ý11ÂÖ£¬»¹Ã»ÓÐ×¢²á³É¹¦£¬±¾Öն˽«ÓÀÔ¶²»ÔÚ×¢²á¡£
+*/
+static int dm_unicom_register_start(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ char *dataBuf = NULL;
+ int dataSize = 0;
+ int ret = 0;
+ static int currentRounds = 1;
+ static int currentTimes = 1;
+ DM_UNICOM_HTTP_URL_INFO dmUnicomUrlInfo ;
+ DM_UNICOM_HTTP_DATA_INFO dmUnicomHttpDataInfo ;
+ struct DM_UNICOM_REGISTER_INFO dmUnicomRegInfo ;
+
+ dataSize = (DM_NV_ITEM_SIZE + DM_NV_ITEM_SIZE / 4 + 5) * DM_INFO_UNICOM_MAX;
+
+ if (!(dataBuf = (char *) malloc(dataSize)))
+ {
+ log_err("dm unicom start reg malloc mem error\n");
+ return DM_ERR_PARAM_NULL;
+ }
+ memset(&dmUnicomHttpDataInfo, 0, sizeof(DM_UNICOM_HTTP_DATA_INFO));
+ memset(dataBuf, 0, dataSize);
+ dmUnicomHttpDataInfo.dataBuffer = dataBuf;
+ dmUnicomHttpDataInfo.dataLen = dataSize;
+
+ /* Öն˳¢ÊÔ×ܵÄÂÖÊýСÓÚ 10ÂÖ £¬µ±Ç°¿ª»ú³¢ÊÔµÄÂÖÊý²»³¬¹ý3ÂÖ£¬ÇÒÿÂÖ²»³¬¹ý3´Î */
+ if ((dmControlInfo->registeredRounds <= DM_ROUND_TOTAL) && (currentRounds <= 3))
+ {
+ /* ×¢²áµÄtag¸³Öµ²Ù×÷£¬(tag, ÁªÍ¨ÓÃÓں˶Ե±Ç°Öն˳¢ÊÔ×¢²áµÄ´ÎÊýºÍÂÖÊý) */
+ dmControlInfo->currentTimes = currentTimes;
+ dmControlInfo->currentRounds = currentRounds;
+
+ /*±£´æ×ܵÄÂÖÊý£¬×¢²áÇ°½øÐб£´æ£¬ÐÒé¹æ·¶Ö¸¶¨¡£Ô¤·ÀÔÚijһÂÖÖУ¬Óû§¹Ø»úÁË£¬±¾ÂÖÐèÒª¼ÆÊý*/
+ char registerRound[5] = {0};
+ snprintf(registerRound, 4, "%d", dmControlInfo->registeredRounds);
+ sc_cfg_set(DM_REGISTERED_ROUND, registerRound);
+
+ ret = dm_unicom_register_info_create(dmControlInfo, &dmUnicomRegInfo);
+ if(DM_ERR_SUCCESS != ret)
+ goto ErrRet;
+
+ ret = dm_unicom_json_info_create(&dmUnicomRegInfo, &dmUnicomHttpDataInfo);
+
+ ret = dm_unicom_url_info_create(dmControlInfo, &dmUnicomRegInfo, &dmUnicomUrlInfo);
+ if(DM_ERR_SUCCESS != ret)
+ goto ErrRet; //klockworks issue.
+
+ ret = dm_unicom_http_request(&dmUnicomUrlInfo, &dmUnicomHttpDataInfo);
+ log_debug("dm register total rounds(%d), currentRounds(%d), currentTimes(%d), http-ret(%d)\n", dmControlInfo->registeredRounds, currentRounds, currentTimes, ret);
+
+ if (0 == ret)
+ {
+ char registerFlag[4] = {0};
+ char registerRounds[4] = {0};
+
+ dmControlInfo->registerFlag = DM_REGISTERED_YES;
+ snprintf(registerFlag, 3, "%d", dmControlInfo->registerFlag);
+ sc_cfg_set("registerFlag", registerFlag);
+
+ snprintf(registerRounds, 3, "%d", 0);
+ sc_cfg_set("registerRounds", registerRounds);
+
+ dm_resource_clean(dmControlInfo, (void *) &dmUnicomHttpDataInfo);
+ return DM_ERR_SUCCESS;
+ }
+
+ /* ·Ç·þÎñÆ÷·µ»Ø´íÎó£¬ÐèÒªÖØÊÔ£¬µ«´Ë´Î²»¼ÆÈë³¢ÊÔ´ÎÊý */
+ if (ret == ERR_SOCKET_NO_IP)
+ {
+ /*·Ç·þÎñÆ÷´íÎ󣬵±Ç°±¾´Î ´ÎÊý²»ÄܼÆÈëͳ¼Æ */
+ log_debug("dm start register£¬ some net's error occur \n");
+ dm_resource_clean(dmControlInfo, &dmUnicomHttpDataInfo);
+
+ /*
+ *´Î´íÎóÊÇÓÉÍøÂç´íÎ󣬽øÐйæ±Ü¡£ÒòΪÒѾcheck·ÓÉÊÇOk,¶ø·¢ÏÖ²»ÁËIPµØÖ·
+ */
+ dm_timer_add(3, 0);
+ return DM_ERR_NET_ERROR;
+ }
+
+ /* ÿÂÖÀïÃæ³¢ÊÔ3´Î£¬´¦Àíÿ´Î */
+ if (currentTimes < 3)
+ {
+ currentTimes++;
+ dmControlInfo->currentTimes = currentTimes;
+ /* Æô¶¯Ã¿´Î³¢ÊÔ¶¨Ê±Æ÷ */
+ dm_timer_add(dmControlInfo->secsEveryTime * 60, DM_TIMER_ID_UNICOM_EVERY_TIMES);
+ }
+ else /* ´¦ÀíÿÂÖ */
+ {
+ currentTimes = 1; /* ÿÂÖÖУ¬´ÎÊýÖØдÓÁ㿪ʼ¼ÆÊý */
+ dmControlInfo->currentTimes = currentTimes;
+
+ currentRounds++;
+ dmControlInfo->currentRounds = currentRounds;
+
+ /*ÒÀ¾ÝÐÒé¹æ·¶£¬Ò»´Î¿ª»ú×î¶à³¢ÊÔ3ÂÖ*/
+ if (dmControlInfo->currentRounds > 3)
+ {
+ dm_resource_clean(dmControlInfo, &dmUnicomHttpDataInfo);
+ log_debug("dm unicom currentRound(%d)\n", dmControlInfo->currentRounds);
+ return DM_ERR_SERVER_ERROR;
+ }
+
+ dmControlInfo->registeredRounds++;
+ if (10 < dmControlInfo->registeredRounds)
+ {
+ log_debug("dm unicom registeredRound(%d)\n", dmControlInfo->registeredRounds);
+ dm_resource_clean(dmControlInfo, &dmUnicomHttpDataInfo);
+ return DM_ERR_SERVER_ERROR;
+ }
+ /* Æô¶¯Ã¿ÂÖ³¢ÊÔ¶¨Ê±Æ÷ */
+ dm_timer_add(dmControlInfo->secsEveryRound * 60, DM_TIMER_ID_UNICOM_EVERY_ROUND);
+ }
+
+ log_debug("dm start register start: debug info as following ************\n");
+ log_debug("dm total rounds-next(%d), currentRounds-next(%d), currentTimes-next(%d)\n", dmControlInfo->registeredRounds, currentRounds, currentTimes);
+ log_debug("dm register secTimer(%d), secsEveryRound(%d) , secsEveryTime(%d), netStatus(%d), globalRomaing(%d)\n",
+ dmControlInfo->secTimer,
+ dmControlInfo->secsEveryRound,
+ dmControlInfo->secsEveryTime,
+ dmControlInfo->netStatus,
+ dmControlInfo->globalRomaing);
+
+ dm_resource_clean(dmControlInfo, &dmUnicomHttpDataInfo);
+ return DM_ERR_SERVER_ERROR;
+ }
+
+ dm_resource_clean(dmControlInfo, &dmUnicomHttpDataInfo);
+ return DM_ERR_RETRY_ERROR;
+
+ErrRet:
+ free(dataBuf);
+ return ret; //klockworks issue.
+}
+
+/**
+* º¯ÊýÃû³Æ£ºdm_unicom_register_request_handle
+* ¹¦ÄÜÃèÊö£ºÁªÍ¨DM×¢²áÇëÇó´¦Àí
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+* ÆäËü˵Ã÷£º
+*/
+static int dm_unicom_register_request_handle(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(dmControlInfo);
+
+ int checkTimes = 10;
+ char romaingStatus[DM_NV_ITEM_SIZE] = {0};
+ char netStatus[DM_NV_ITEM_SIZE] = {0};
+ char cardType[4] = {0};
+
+ /*cmt »ñÈ¡ ״ֵ̬*/
+ CALL(sc_cfg_get(NV_PDP_STATUS, netStatus, sizeof(netStatus)));
+ CALL(sc_cfg_get(NV_SIMCARD_ROAM, romaingStatus, sizeof(romaingStatus)));
+ CALL(sc_cfg_get(NV_SIMCARD_TYPE, cardType, sizeof(cardType)));
+
+ dmControlInfo->netStatus = atoi(netStatus);
+ dmControlInfo->cardType = atoi(cardType);
+
+ if (0 == strcmp(romaingStatus, "Internal"))
+ {
+ dmControlInfo->globalRomaing = 1;
+ }
+ else if (0 == strcmp(romaingStatus, "Home"))
+ {
+ dmControlInfo->globalRomaing = 0;
+ }
+ else
+ {
+ log_err("dm global romaing some error, romaingStatus(%s) \n ", romaingStatus);
+ return DM_ERR_WAITING_NET_STATUS_CHANAGE;
+ }
+
+ /* 1¡¢Êý¾ÝÁ´Â·¹Ø±Õ£¬»ò
+ * 2¡¢Êý¾ÝÁ´Â·´ò¿ª£¬ÇÒÔÚ¹ú¼ÊÂþÓÎ
+ * ²»½øÐÐ×¢²á¡£
+ */
+ if ((dmControlInfo->netStatus == 0) || ((dmControlInfo->netStatus == 1) && (dmControlInfo->globalRomaing == 1)))
+ {
+ /*±ê¼Ç¶¨Ê±Æ÷µ½Ê±£¬Êý¾ÝÁ´Â·Ã»Óдò¿ª£¬µÈ´ýÊý¾ÝÁ´Â·´ò¿ªÏûÏ¢, ´¥·¢×¢²áÁ÷³Ì */
+ dmControlInfo->needRegForNetStatusChange = 1;
+ log_debug(" startup_proc now, net status(%d), romaing status(%d), needRegForNetStatusChange(%d)\n", dmControlInfo->netStatus, dmControlInfo->globalRomaing, dmControlInfo->needRegForNetStatusChange);
+ return DM_ERR_WAITING_NET_STATUS_CHANAGE;
+ }
+ dmControlInfo->needRegForNetStatusChange = 0;
+
+ /*ÓÉÓÚPDPÏûÏ¢Éϱ¨£¬Íø¿¨²»ÄÜÁ¢¼´Ê¹Óà £¬½øÐзÓɼì²é */
+ while (checkTimes-- >= 0)
+ {
+ if (1 == default_route_check())
+ break;
+ usleep(1000 * 500);
+ if (0 == checkTimes)
+ {
+ log_debug("unicom startup check rout times(%d)\n", checkTimes);
+ return DM_ERR_CHECK_ROUTE_ERROR;
+ }
+ }
+
+ /*ctm ·¢Æð×¢²áÁ÷³Ì */
+ CALL(dm_unicom_register_start(dmControlInfo));
+
+ return DM_ERR_SUCCESS;
+}
+
+/**
+* º¯ÊýÃû³Æ£ºdm_register_request_handle
+* ¹¦ÄÜÃèÊö£ºDM×¢²áÇëÇó´¦Àí
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+* ÆäËü˵Ã÷£º
+*/
+static int dm_register_request_handle(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(dmControlInfo);
+
+ if (DM_MOBILE == dmControlInfo->dmType)
+ {
+ char imei[DM_NV_ITEM_SIZE] = {0};
+ char iccid[DM_NV_ITEM_SIZE] = {0};
+ char imeiPrevious[DM_NV_ITEM_SIZE] = {0};
+ char iccidPrevious[DM_NV_ITEM_SIZE] = {0};
+ char cardType[4] = {0};
+ char versionPrevious[DM_NV_ITEM_SIZE] = {0};
+ char version[DM_NV_ITEM_SIZE] = {0};
+
+ CALL(sc_cfg_get(NV_IMEI, imei, sizeof(imei)));
+ CALL(sc_cfg_get(NV_ZICCID, iccid, sizeof(iccid)));
+
+ CALL(sc_cfg_get(DM_IMEI_PREVIOUS, imeiPrevious, sizeof(imeiPrevious)));
+ CALL(sc_cfg_get(DM_ICCID_PREVIOUS, iccidPrevious, sizeof(iccidPrevious)));
+ CALL(sc_cfg_get(NV_SIMCARD_TYPE, cardType, sizeof(cardType)));
+
+ CALL(sc_cfg_get(DM_VERSION_PREVIOU, versionPrevious, sizeof(versionPrevious)));
+ CALL(sc_cfg_get(DM_SW_VERSION, version, sizeof(version)));
+
+ snprintf(dmControlInfo->imeiPrevious, sizeof(dmControlInfo->imeiPrevious)-1, "%s", imeiPrevious);
+ snprintf(dmControlInfo->iccidPrevious, sizeof(dmControlInfo->iccidPrevious)-1, "%s", iccidPrevious); //klockworks issue.
+
+ dmControlInfo->cardType = atoi(cardType);
+
+ /*
+ * 1¡¢Òƶ¯DM ÒѾע²á¹ý£¬µ«ÊǸü»»ÁË sim ¿¨£¬ÐÒé¹æ¶¨ÐèÒªÖØÐÂ×¢²á
+ * 2¡¢Òƶ¯DM fotaÉý¼¶ÐèÒªÖØз¢Æð×¢²á,ÒÀ¾ÝÇ°ºóµÄ°æ±¾ºÅ½øÐÐÅжÏ
+ * eg: B11 -> B12 -> B11 ÎÞÐè×¢²á
+ */
+ if ((DM_REGISTERED_YES == dmControlInfo->registerFlag)
+ && (!strcmp(dmControlInfo->imeiPrevious, imei)
+ && (!strcmp(dmControlInfo->iccidPrevious, iccid)))
+ && (!strcmp(versionPrevious, version)))
+ {
+ log_debug("dm mobile imei and iccid have no change, system have no updated now (fota), versionPrevious(%s), vesion(%s)\n", versionPrevious, version);
+ return DM_ERR_DEVICE_REGISTERED;
+ }
+
+ /*Òƶ¯DM ²åÈë·ÇÒƶ¯¿¨ ²»×¢²á */
+ if (1 != dmControlInfo->cardType)
+ {
+ log_debug("dm mobile register, no-mobile-card cardType(%s) \n", cardType);
+ return DM_ERR_NO_MOBILE_CARD_ERROR;
+ }
+
+ CALL(dm_mobile_register_request_handle(dmControlInfo));
+ }
+ else if (DM_UNICOM == dmControlInfo->dmType)
+ {
+ CALL(dm_unicom_register_request_handle(dmControlInfo));
+ }
+ else if (DM_TELECOM == dmControlInfo->dmType)
+ {
+ CALL(dm_telecom_register_request_handle(dmControlInfo));
+ }
+ else
+ {
+ log_err("dm don't not know the register type(%d) now ...\n", dmControlInfo->dmType);
+ }
+ return DM_ERR_SUCCESS;
+}
+
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_main_thread_release
+ * ¹¦ÄÜÃèÊö£ºÍ¨ÖªdmÄ£¿éÖ÷Ị̈߳¬Í˳öÏß³Ì
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_main_thread_release(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(dmControlInfo);
+ int ret = 0;
+ long size = 0;
+ MSG_BUF msgBuf = {0};
+ msgBuf.usMsgCmd = DM_MSG_CMD_MAIN_THREAD_EXIT;
+ size = sizeof(MSG_BUF) - sizeof(long);
+ msgBuf.lMsgType = 1;
+
+ dmControlInfo->registErThreadFlag = 0; /*×ÓÏß³ÌÍ˳ö±ê¼Ç£¬ ͬʱ·¢ËÍÏûÏ¢µ½Ö÷Ị̈߳¬ÈÃÖ÷Ïß³ÌÍ˳ö*/
+
+ ret = msgsnd(dmControlInfo->msgQueueId, (void*) & (msgBuf), size, 0);
+ if (ret < 0)
+ {
+ log_err("main thread release msg errro \n");
+ return DM_ERR_QUEUE_SEND_ERROR;
+ }
+
+ return DM_ERR_SUCCESS;
+}
+
+/**
+* º¯ÊýÃû³Æ£ºdm_register_queue_msg_proc
+* ¹¦ÄÜÃèÊö£ºDM×¢²áÏß³ÌÏûÏ¢´¦Àíº¯Êý
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£ºÎÞ
+* ÆäËü˵Ã÷£º×¢²áỊ̈߳¬ÓÃÓÚ½ÓÊÕÖ÷Ï̷߳¢Ë͵Ä×¢²áÇëÇóÏûÏ¢,ºÍÏß³ÌÍ˳öÏûÏ¢
+* (×¢Òâ×¢²á¿ØÖÆÏà¹ØµÄ±äÁ¿µÄÉèÖ㬶¼ÔÚ´ÎÏß³ÌÖÐ
+* ½øÐÐÉèÖã¬Ö÷Ïß³ÌÖв»ÄܶÔÉæ¼°µ½¶Ôͬ²½±äÁ¿µÄ¸³Öµ£¬Ö»ÄܶÁÈ¡)
+*/
+static void dm_register_queue_msg_proc(MSG_BUF *pstMsg, struct DM_CONTROl_INFO *dmControlInfo)
+{
+ switch (pstMsg->usMsgCmd)
+ {
+ case DM_MSG_CMD_REGISTER_REQUEST:
+ {
+ dm_register_request_handle(dmControlInfo);
+ break;
+ }
+
+ case DM_MSG_CMD_REGISTER_THREAD_RELEASE:
+ {
+ dm_main_thread_release(dmControlInfo);
+ log_debug("dm register thread readly to exit...\n");
+ break;
+ }
+
+ default:
+ log_debug("dm queue msg proc\n");
+ }
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_server_thread_entry
+ * ¹¦ÄÜÃèÊö£ºdm×¢²áÏß³ÌÈë¿Úº¯Êý
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static void* dm_server_thread_entry(void* args)
+{
+ int ret = 0;
+ MSG_BUF dmMsg = {0};
+ long msgSize = 0;
+ pthread_attr_t threadAttr;
+
+ if (!args)
+ {
+ log_err("dm register thread param error \n");
+ return NULL;
+ }
+
+ struct DM_CONTROl_INFO *dmControlInfo = (struct DM_CONTROl_INFO *) args;
+
+ pthread_attr_init(&threadAttr);
+ pthread_attr_setstacksize(&threadAttr, 16 * 1024);
+ prctl(PR_SET_NAME, "dm_register_server", 0, 0, 0);
+
+ log_debug("dm register thread start now...\n");
+ dmControlInfo->registErThreadFlag = 1;
+ while (dmControlInfo->registErThreadFlag)
+ {
+ memset((void*)(&dmMsg), 0, sizeof(dmMsg));
+ msgSize = sizeof(MSG_BUF) - sizeof(long);
+ if (0 < (ret = msgrcv(dmControlInfo->msgQueueIdReg, &dmMsg, msgSize, 0, MSG_NOERROR)))
+ {
+ log_debug("dm register thread recv msg now: ret(%d), dmMsg.src_id(%ld), dmMsg.usMsgCmd(0x%08x), dmMsg.usDatalen(%d), dmMsg.auDataBuffer(%s)\n",
+ ret, dmMsg.src_id, dmMsg.usMsgCmd, dmMsg.usDataLen, dmMsg.aucDataBuf);
+ dm_wake_lock("dm_lock_dm");
+ dm_register_queue_msg_proc(&dmMsg, dmControlInfo);
+ dm_wake_unlock("dm_lock_dm");
+ }
+ else
+ {
+ log_err(" dm server thread rec data error ,err-code\n");
+ }
+ }
+
+ pthread_attr_destroy(&threadAttr); //klockworks issue.
+ log_debug("dm reg server exit now... \n");
+ return NULL;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_register_thread_init
+ * ¹¦ÄÜÃèÊö£ºDM×¢²áÏ̳߳õʼ»¯
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_register_thread_init(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(dmControlInfo);
+
+ if (-1 == ((dmControlInfo->msgQueueIdReg) = msgget(IPC_PRIVATE, IPC_CREAT | 0600)))
+ {
+ log_err("Create MSG_ID_DMREG queue faild! (*msgId)(%d)\n", dmControlInfo->msgQueueIdReg);
+ return DM_ERR_CREATE_MSG_QUEUE_ERROR;
+ }
+
+ if (0 != pthread_create(& (dmControlInfo->pid), NULL, dm_server_thread_entry, dmControlInfo))
+ {
+ log_err("dm servers pthread_create error\n");
+ return DM_ERR_CREATE_THERAD_ERROR;
+ }
+
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_init_unicom_control_info
+ * ¹¦ÄÜÃèÊö£º³õʼ»¯Áªµ÷DM¿ØÖÆÐÅÏ¢
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_unicom_control_info_init(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ char secsEveryRound[DM_NV_ITEM_SIZE] = {0};
+ char secsEveryTime[DM_NV_ITEM_SIZE] = {0};
+ char registeredRounds[DM_NV_ITEM_SIZE] = {0};
+ char secTimer[DM_NV_ITEM_SIZE] = {0};
+ char hostName[DM_NV_ITEM_SIZE] = {0};
+ char portNum[12] = {0};
+ char netStatus[4] = {0};
+
+ CHECK_PARAM(dmControlInfo);
+
+ CALL(sc_cfg_get(DM_SECS_EVERY_ROUND, secsEveryRound, DM_NV_ITEM_SIZE));
+ CALL(sc_cfg_get(DM_SECS_EVERY_TIME, secsEveryTime, DM_NV_ITEM_SIZE));
+ CALL(sc_cfg_get(DM_REGISTERED_ROUND, registeredRounds, DM_NV_ITEM_SIZE));
+ CALL(sc_cfg_get(DM_SEC_TIMER, secTimer, DM_NV_ITEM_SIZE));
+ CALL(sc_cfg_get(DM_HOST_NAME, hostName, DM_NV_ITEM_SIZE));
+ CALL(sc_cfg_get(DM_PORT_NUM, portNum, sizeof(portNum))); //klockworks issue.
+ CALL(sc_cfg_get(NV_PDP_STATUS, netStatus, 4));
+
+ dmControlInfo->secsEveryRound = atoi(secsEveryRound);
+ dmControlInfo->secsEveryTime = atoi(secsEveryTime);
+ dmControlInfo->registeredRounds = atoi(registeredRounds);
+ /*klocwork 3 SV.TAINTED.BINOP, add if condition*/
+ if((dmControlInfo->registeredRounds >= 0) && (dmControlInfo->registeredRounds < 100))
+ {
+ dmControlInfo->registeredRounds = dmControlInfo->registeredRounds + 1;
+ }
+
+ dmControlInfo->secTimer = atoi(secTimer);
+ dmControlInfo->netStatus = atoi(netStatus);
+
+ dmControlInfo->portNum = atol(portNum);
+ snprintf(dmControlInfo->hostName, DM_NV_ITEM_SIZE - 1, "%s", hostName);
+
+ log_debug("dm unicom init control info: secsEveryTime(%d), secsEveryRound(%d), registeredRounds(%d), secTimer(%d), hostName(%s), portNum(%ld), netStatus(%d) \n",
+ dmControlInfo->secsEveryTime,
+ dmControlInfo->secsEveryRound,
+ dmControlInfo->registeredRounds,
+ dmControlInfo->secTimer,
+ dmControlInfo->hostName,
+ dmControlInfo->portNum,
+ dmControlInfo->netStatus);
+
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_init_mobile_control_info
+ * ¹¦ÄÜÃèÊö£º³õʼ»¯Òƶ¯DM¿ØÖÆÐÅÏ¢
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_mobile_control_info_init(struct DM_CONTROl_INFO * dmControlInfo)
+{
+ char secTimer[DM_NV_ITEM_SIZE] = {0};
+ char hostName[DM_NV_ITEM_SIZE] = {0};
+ char portNum[DM_NV_ITEM_SIZE] = {0};
+ char imeiPrevious[DM_NV_ITEM_SIZE] = {0};
+ char iccidPrevious[DM_NV_ITEM_SIZE] = {0};
+ char cardType[4] = {0};
+ char secsEveryRound[DM_NV_ITEM_SIZE] = {0};
+
+ CHECK_PARAM(dmControlInfo);
+ CHECK_PARAM(dmControlInfo);
+
+ CALL(sc_cfg_get(DM_SEC_TIMER, secTimer, sizeof(secTimer)));
+ CALL(sc_cfg_get(DM_HOST_NAME, hostName, sizeof(hostName)));
+ CALL(sc_cfg_get(DM_PORT_NUM, portNum, sizeof(portNum)));
+ CALL(sc_cfg_get(NV_SIMCARD_TYPE, cardType, sizeof(cardType)));
+ CALL(sc_cfg_get(DM_IMEI_PREVIOUS, imeiPrevious, sizeof(imeiPrevious)));
+ CALL(sc_cfg_get(DM_ICCID_PREVIOUS, iccidPrevious, sizeof(iccidPrevious)));
+ CALL(sc_cfg_get(DM_SECS_EVERY_ROUND, secsEveryRound, sizeof(secsEveryRound)));
+
+ dmControlInfo->secTimer = atoi(secTimer);
+ dmControlInfo->portNum = atoi(portNum);
+ snprintf(dmControlInfo->hostName, 31, "%s", hostName);
+ dmControlInfo->cardType = atoi(cardType);
+ dmControlInfo->secsEveryRound = atoi(secsEveryRound);
+
+ snprintf(dmControlInfo->imeiPrevious, 31, "%s", imeiPrevious);
+ snprintf(dmControlInfo->iccidPrevious, 31, "%s", iccidPrevious);
+
+ log_debug("dm init mobile control info: secsEveryRound(%d),secTimer(%d), cardType(%d), portNum(%d), hostName(%s), iccidPrevious(%s), imeiPrevious(%s)\n",
+ dmControlInfo->secsEveryRound,
+ dmControlInfo->secTimer,
+ dmControlInfo->cardType,
+ dmControlInfo->portNum,
+ dmControlInfo->hostName,
+ dmControlInfo->iccidPrevious,
+ dmControlInfo->imeiPrevious);
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_telecom_control_info_init
+ * ¹¦ÄÜÃèÊö£º³õʼ»¯µçÐÅDM¿ØÖÆÐÅÏ¢
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_telecom_control_info_init(struct DM_CONTROl_INFO * dmControlInfo)
+{
+ char hostName[DM_NV_ITEM_SIZE] = {0};
+ char portNum[DM_NV_ITEM_SIZE] = {0};
+
+ char imeiPrevious[DM_NV_ITEM_SIZE] = {0};
+ char iccidPrevious[DM_NV_ITEM_SIZE] = {0};
+ char cardType[4] = {0};
+ char secsEveryRound[DM_NV_ITEM_SIZE] = {0};
+ char secsEveryTime[DM_NV_ITEM_SIZE] = {0};
+
+ CHECK_PARAM(dmControlInfo);
+
+ CALL(sc_cfg_get(DM_HOST_NAME, hostName, sizeof(hostName)));
+ CALL(sc_cfg_get(DM_PORT_NUM, portNum, sizeof(portNum)));
+ //CALL(sc_cfg_get(NV_SIMCARD_TYPE, cardType, sizeof(cardType)));
+ CALL(sc_cfg_get(DM_IMEI_PREVIOUS, imeiPrevious, sizeof(imeiPrevious)));
+ CALL(sc_cfg_get(DM_ICCID_PREVIOUS, iccidPrevious, sizeof(iccidPrevious)));
+ CALL(sc_cfg_get(DM_SECS_EVERY_ROUND, secsEveryRound, sizeof(secsEveryRound)));
+ CALL(sc_cfg_get(DM_SECS_EVERY_TIME, secsEveryTime, sizeof(secsEveryTime)));
+
+ dmControlInfo->portNum = atoi(portNum);
+ snprintf(dmControlInfo->hostName, 31, "%s", hostName);
+ dmControlInfo->cardType = atoi(cardType);
+ dmControlInfo->secsEveryRound = atoi(secsEveryRound);
+ dmControlInfo->secsEveryTime = atoi(secsEveryTime);
+
+ snprintf(dmControlInfo->imeiPrevious, 31, "%s", imeiPrevious);
+ snprintf(dmControlInfo->iccidPrevious, 31, "%s", iccidPrevious);
+
+ log_debug("dm init mobile control info: secsEveryRound(%d),secTimer(%d), cardType(%d), portNum(%d), hostName(%s), iccidPrevious(%s), imeiPrevious(%s)\n",
+ dmControlInfo->secsEveryRound,
+ dmControlInfo->secTimer,
+ dmControlInfo->cardType,
+ dmControlInfo->portNum,
+ dmControlInfo->hostName,
+ dmControlInfo->iccidPrevious,
+ dmControlInfo->imeiPrevious);
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_control_info_init
+ * ¹¦ÄÜÃèÊö£º³õʼ»¯DM¿ØÖÆÐÅÏ¢
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_control_info_init(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(dmControlInfo);
+ memset((void*) dmControlInfo, 0, sizeof(struct DM_CONTROl_INFO));
+
+ CALL(dm_get_device_type(dmControlInfo));
+
+ if (DM_MOBILE == dmControlInfo->dmType)
+ {
+ CALL(dm_mobile_control_info_init(dmControlInfo));
+ }
+ else if (DM_UNICOM == dmControlInfo->dmType)
+ {
+ CALL(dm_unicom_control_info_init(dmControlInfo));
+ }
+ else if (DM_TELECOM == dmControlInfo->dmType)
+ {
+ CALL(dm_telecom_control_info_init(dmControlInfo));
+ }
+ else
+ {
+ log_err("the device type is none \n");
+ return DM_ERR_DEVICE_TYPE_IS_NONE;
+ }
+
+ log_debug("dm control info init success, device dmType(%d),registeredRounds(%d), secsEveryTime(%d), secsEveryRound(%d) ,cardType(%d), hostNameUnicom(%s), portNum(%u), imeiPrevious(%s), iccidPrevious(%s)\n",
+ dmControlInfo->dmType,
+ dmControlInfo->registeredRounds,
+ dmControlInfo->secsEveryTime,
+ dmControlInfo->secsEveryRound,
+ dmControlInfo->cardType,
+ dmControlInfo->hostName,
+ dmControlInfo->portNum,
+ dmControlInfo->imeiPrevious,
+ dmControlInfo->iccidPrevious);
+ return DM_ERR_SUCCESS;
+}
+
+BOOL dm_telecom_check_iccid_registed(void)
+{
+ char iccid[DM_NV_ITEM_SIZE] = {0};
+ char iccidPrevious[DM_NV_ITEM_SIZE] = {0};
+ char versionPrevious[DM_NV_ITEM_SIZE] = {0};
+ char version[DM_NV_ITEM_SIZE] = {0};
+
+ CALL(sc_cfg_get(NV_ZICCID, iccid, sizeof(iccid)));
+ CALL(sc_cfg_get(DM_ICCID_PREVIOUS, iccidPrevious, sizeof(iccidPrevious)));
+ CALL(sc_cfg_get(DM_VERSION_PREVIOU, versionPrevious, sizeof(versionPrevious)));
+ CALL(sc_cfg_get(DM_SW_VERSION, version, sizeof(version)));
+
+ if (0 != strcmp("", versionPrevious) &&
+ 0 != strcmp(versionPrevious, version))
+ {
+ log_debug("[dm_telecom] software version update!\n");
+ sc_cfg_set(DM_ICCID_PREVIOUS, "0");
+ return FALSE;
+ }
+
+ if (0 != strcmp("", iccidPrevious) &&
+ 0 == strcmp(iccid, iccidPrevious))
+ {
+ log_debug("[dm_telecom] check_ueiccid same!\n");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+BOOL dm_check_is_chinatelecom(void)
+{
+ char num_oper[DM_NV_ITEM_SIZE] = {0};
+ sc_cfg_get(NV_OPER_NUM, num_oper, sizeof(num_oper));
+ if (strcmp(num_oper, "46003") == 0 ||
+ strcmp(num_oper, "46005") == 0 ||
+ strcmp(num_oper, "46011") == 0)
+ {
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_unicom_register_info_create
+ * ¹¦ÄÜÃèÊö: ¹¹ÔìÁªÍ¨DMÐÒé¹æ·¶Ö¸¶¨µÄ×¢²áÐÅÏ¢
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_telecom_register_info_create(struct DM_CONTROl_INFO *dmControlInfo, struct DM_TELECOM_REGISTER_INFO *dmTelecomRegInfo)
+{
+ CHECK_PARAM(dmTelecomRegInfo);
+ (void)dmControlInfo;
+
+ sc_cfg_get(DM_REGVER, dmTelecomRegInfo->value[DM_INFO_REGVER], DM_NV_ITEM_SIZE);
+ sc_cfg_get(DM_MEID, dmTelecomRegInfo->value[DM_INFO_MEID], DM_NV_ITEM_SIZE);
+ sc_cfg_get(DM_MODEL, dmTelecomRegInfo->value[DM_INFO_MODELSMS], DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_CR_VERSION, dmTelecomRegInfo->value[DM_INFO_SWVER], DM_NV_ITEM_SIZE);
+ //sc_cfg_get(NV_SIM_IMSI, dmTelecomRegInfo->value[DM_INFO_SIM1CDMAIMSI], DM_NV_ITEM_SIZE);
+ sc_cfg_get(DM_UETYPE, dmTelecomRegInfo->value[DM_INFO_UETYPE], DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_ZICCID, dmTelecomRegInfo->value[DM_INFO_SIM1ICCID], DM_NV_ITEM_SIZE);
+ sc_cfg_get(NV_SIM_IMSI, dmTelecomRegInfo->value[DM_INFO_SIM1LTEIMSI], DM_NV_ITEM_SIZE);
+
+ sc_cfg_get(NV_IMEI, dmTelecomRegInfo->value[DM_INFO_IMEI], DM_NV_ITEM_SIZE);
+ strcpy(dmTelecomRegInfo->value[DM_INFO_SIM1TYPE], "2"); //TODO
+
+ return DM_ERR_SUCCESS;
+}
+
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_unicom_json_info_create
+ * ¹¦ÄÜÃèÊö£º¹¹ÔìÁªÍ¨ÐÒé¹æ·¶json¸ñʽÊý¾Ý
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_telecom_json_info_create(struct DM_TELECOM_REGISTER_INFO *dmTelecomRegInfo, DM_TELECOM_HTTP_DATA_INFO *httpsDataInfo)
+{
+ CHECK_PARAM(dmTelecomRegInfo);
+ CHECK_PARAM(httpsDataInfo);
+
+ int i = 0;
+ char *pTmep = NULL;
+ int jsonSize = 0;
+ char *telecomItemName[] = {"REGVER", "MEID", "MODELSMS", "SWVER",
+ "SIM1CDMAIMSI", "UETYPE", "SIM1ICCID", "SIM1LTEIMSI",
+ "IMEI1", "BASEID", "SIM1TYPE", "SID",
+ "NID"
+ };
+ /*json fromat as following
+ * {"key1":"key1Value","key2":"key2Value", xxxxx}*/
+ log_debug("dm unicom json infof ***********\n");
+
+ pTmep = httpsDataInfo->dataBuffer;
+ memset(pTmep, 0, httpsDataInfo->dataLen);
+ for (i = 0; i < DM_INFO_TELECOM_MAX; i++)
+ {
+ if (i == 0)
+ sprintf(pTmep, "{\"%s\":\"%s\"", telecomItemName[i], dmTelecomRegInfo->value[i]);
+ else if (i == DM_INFO_TELECOM_MAX - 1)
+ sprintf(pTmep, ",\"%s\":\"%s\"}", telecomItemName[i], dmTelecomRegInfo->value[i]);
+ else
+ sprintf(pTmep, ",\"%s\":\"%s\"", telecomItemName[i], dmTelecomRegInfo->value[i]);
+
+ log_debug("json-value(%s)\n", pTmep);
+ jsonSize = jsonSize + strlen(pTmep);
+ pTmep = pTmep + strlen(pTmep);
+
+ if (jsonSize > httpsDataInfo->dataLen)
+ log_err("json buffer memory overwrite now! please check memory size, jsonSize(%d), httpsDatainfo-size(%d) !!!\n", jsonSize, httpsDataInfo->dataLen);
+ }
+
+ httpsDataInfo->dataLen = jsonSize;
+ log_debug("create json info, json-szie(%d)\n", jsonSize);
+
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£º dm_telecom_url_info_create
+ * ¹¦ÄÜÃèÊö£º ¹¹ÔìÒƶ¯DMµÄ·þÎñÆ÷ urlÐÅÏ¢£¬°üÀ¨ ·þÎñÆ÷µØÖ·£¬¶Ë¿ÚµÈÐÅÏ¢£¬
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º ³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_telecom_url_info_create(struct DM_CONTROl_INFO *dmControlInfo, struct DM_TELECOM_REGISTER_INFO *dmMobileRegInfo, DM_TELECOM_HTTP_URL_INFO *dmMobileUrlInfo)
+{
+ CHECK_PARAM(dmControlInfo);
+ CHECK_PARAM(dmMobileRegInfo);
+ CHECK_PARAM(dmMobileUrlInfo);
+ CHECK_PARAM(dmMobileUrlInfo->urlBuffer);
+
+ memset(dmMobileUrlInfo, 0, sizeof(DM_TELECOM_HTTP_URL_INFO));
+
+ snprintf(dmMobileUrlInfo->hostName, DM_NV_ITEM_SIZE - 1, "%s", dmControlInfo->hostName);
+
+ snprintf(dmMobileUrlInfo->ipAddr, 31, "%s", dmControlInfo->ipAddr);
+
+ dmMobileUrlInfo->portNum = dmControlInfo->portNum;
+
+ log_debug("dm unicom url-info debug: ulr(%s), portNum(%ld), hostName(%s)\n ", dmMobileUrlInfo->urlBuffer, dmMobileUrlInfo->portNum, dmMobileUrlInfo->hostName);
+
+ return DM_ERR_SUCCESS;
+}
+
+BOOL dm_telecom_need_reg_check(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ char sim_imsi[DM_NV_ITEM_SIZE] = {0};
+ char cardType[4] = {0};
+
+ /*¼ì²âÊÇ·ñΪµçÐÅ¿¨*/
+ if (FALSE == dm_check_is_chinatelecom())
+ {
+ log_debug("[dm_telecom] zte_selfreg_check, not telecom sim or network, return!!\n");
+ return FALSE;
+ }
+
+ CALL(sc_cfg_get(NV_SIMCARD_TYPE, cardType, sizeof(cardType)));
+ dmControlInfo->cardType = atoi(cardType);
+ /*µçÐÅDM ²åÈë·ÇµçÐÅ¿¨ ²»×¢²á */
+ if (3 != dmControlInfo->cardType)
+ {
+ log_debug("[dm_telecom] zte_selfreg_check, no-telecom-card cardType(%s) \n", cardType);
+ return FALSE;
+ }
+ /*ÒѾ³É¹¦×¢²á*/
+ if (TRUE == dm_telecom_check_iccid_registed())
+ {
+ log_debug("[dm_telecom] zte_selfreg_check, selfreg success, return!!\n");
+ return FALSE;
+ }
+ /*ÖØÊÔ´ÎÊý´óÓÚ10*/
+ if (dmControlInfo->currentTimes >= DM_TELECOM_RETRY_TIMES)
+ {
+ log_debug("[dm_telecom] zte_selfreg_check, selfreg retry over, return!!\n");
+ return FALSE;
+ }
+
+ sc_cfg_get(NV_SIM_IMSI, sim_imsi, sizeof(sim_imsi) - 1);
+ if (0 == strcmp(sim_imsi, ""))
+ {
+ log_debug("[dm_telecom] zte_selfreg_check, sim_imsi is null, return!!\n");
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/**
+* º¯ÊýÃû³Æ£º dm_telecom_register_start
+* ¹¦ÄÜÃèÊö£º µçÐÅDM×¢²áÁ÷³Ì¿ªÊ¼
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º ³É¹¦ 0: ʧ°Ü ´íÎóÂë
+* ÆäËü˵Ã÷£º
+*/
+static int dm_telecom_register_start(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ char *dataBuf = NULL;
+ int dataSize = 0;
+ int ret = 0;
+ char imei[DM_NV_ITEM_SIZE] = {0};
+ char iccid[DM_NV_ITEM_SIZE] = {0};
+ char version[DM_NV_ITEM_SIZE] = {0};
+ DM_TELECOM_HTTP_URL_INFO dmTelecomUrlInfo = {{0}, {0}, {0}, 0};
+ DM_TELECOM_HTTP_DATA_INFO dmTelecomHttpsDataInfo = {0};
+ struct DM_TELECOM_REGISTER_INFO dmTelecomRegInfo ;
+ printf("dm_telecom_register_start enter!\n");
+ dataSize = (DM_NV_ITEM_SIZE + DM_NV_ITEM_SIZE / 4 + 5) * DM_INFO_TELECOM_MAX;
+
+ if (!(dataBuf = (char *) malloc(dataSize)))
+ {
+ log_err("dm unicom start reg malloc mem error\n");
+ return DM_ERR_PARAM_NULL;
+ }
+ memset(dataBuf, 0, dataSize);
+ dmTelecomHttpsDataInfo.dataBuffer = dataBuf;
+ dmTelecomHttpsDataInfo.dataLen = dataSize;
+
+ ret = dm_telecom_register_info_create(dmControlInfo, &dmTelecomRegInfo);
+
+ ret = dm_telecom_json_info_create(&dmTelecomRegInfo, &dmTelecomHttpsDataInfo);
+
+ ret = dm_telecom_url_info_create(dmControlInfo, &dmTelecomRegInfo, &dmTelecomUrlInfo);
+ if(DM_ERR_SUCCESS != ret)
+ {
+ free(dataBuf);
+ return ret;
+ } //klockworks issue.
+
+ printf("dm_telecom_register_start enter: telecom_https_request!\n");
+ ret = telecom_https_request(&dmTelecomUrlInfo, &dmTelecomHttpsDataInfo);
+
+ if (0 == ret)
+ {
+ /*×¢²á³É¹¦£¬±£´æNV */
+ char buf[4] = {0};
+ dmControlInfo->registerFlag = DM_REGISTERED_YES;
+ snprintf(buf, 3, "%d", dmControlInfo->registerFlag);
+ sc_cfg_set("registerFlag", buf); //ctm
+
+ /*дÈëIMEI ICCID ºÅ*/
+ sc_cfg_get(NV_IMEI, imei, sizeof(imei));
+ sc_cfg_get(NV_ZICCID, iccid, sizeof(iccid));
+ sc_cfg_get(DM_SW_VERSION, version, sizeof(version));
+
+ sc_cfg_set(DM_IMEI_PREVIOUS, imei);
+ sc_cfg_set(DM_ICCID_PREVIOUS, iccid);
+
+ /*дÈë°æ±¾ºÅ£¬ÎªfotaÉý¼¶ºó DM ×¢²áµÄÒÀ¾Ý*/
+ sc_cfg_set(DM_VERSION_PREVIOU, version);
+
+ dm_resource_clean(dmControlInfo, (void *) &dmTelecomHttpsDataInfo);
+ return DM_ERR_SUCCESS;
+ }
+
+ dm_resource_clean(dmControlInfo, &dmTelecomHttpsDataInfo);
+ log_debug("dm start register start: debug info as following ************\n");
+ log_debug("dm currentTimes(%d)\n", dmControlInfo->currentTimes);
+ log_debug("dm register secTimer(%d), , secsEveryTime(%d), netStatus(%d), globalRomaing(%d)\n",
+ dmControlInfo->secTimer,
+ dmControlInfo->secsEveryTime,
+ dmControlInfo->netStatus,
+ dmControlInfo->globalRomaing);
+
+ return DM_ERR_RETRY_ERROR;
+}
+
+/**
+* º¯ÊýÃû³Æ£ºdm_telecom_register_request_handle
+* ¹¦ÄÜÃèÊö£ºµçÐÅDM×¢²áÇëÇó´¦Àí
+* ²ÎÊý˵Ã÷£º
+* ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+* ÆäËü˵Ã÷£º
+*/
+static int dm_telecom_register_request_handle(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ int ret = 0;
+ int checkTimes = 100;
+ char romaingStatus[DM_NV_ITEM_SIZE] = {0};
+ char netStatus[DM_NV_ITEM_SIZE] = {0};
+
+ printf("dm_telecom_register_request_handle enter!\n");
+ CHECK_PARAM(dmControlInfo);
+
+ if(FALSE == dm_telecom_need_reg_check(dmControlInfo)) //²»Âú×ã×¢²áÌõ¼þ
+ {
+ log_debug("dm_telecom_register_request_handle: reg condition check fail! \n");
+ return DM_ERR_RETRY_ERROR;
+ }
+ /*»ñÈ¡ ״ֵ̬*/
+ CALL(sc_cfg_get(NV_PDP_STATUS, netStatus, sizeof(netStatus)));
+ CALL(sc_cfg_get(NV_SIMCARD_ROAM, romaingStatus, sizeof(romaingStatus)));
+
+ dmControlInfo->netStatus = atoi(netStatus);
+
+ printf("dm_telecom_register_request_handle netStatus = %d!\n", dmControlInfo->netStatus);
+ if (0 == strcmp(romaingStatus, "Internal"))
+ {
+ dmControlInfo->globalRomaing = 1;
+ }
+ else if (0 == strcmp(romaingStatus, "Home"))
+ {
+ dmControlInfo->globalRomaing = 0;
+ }
+ else
+ {
+ log_err("dm global romaing some error, romaingStatus(%s) \n ", romaingStatus);
+ return DM_ERR_WAITING_NET_STATUS_CHANAGE;
+ }
+ /* ×î¶àÖØÊÔ10´Î*/
+ log_debug("dm_telecom_register_request_handle default_route_check = %d\n", default_route_check());
+ if(0 == default_route_check()) //PDPδ¼¤»î
+ {
+ if((0 == dmControlInfo->currentTimes) && (g_retrytimes_before_netactived < DM_TELECOM_RETRYTIMES_BEFORE_ACTIVED)) //´ÓÀ´Ã»Ó줻î¹ý
+ {
+ g_retrytimes_before_netactived++;
+ CALL(dm_timer_add(10, DM_TIMER_ID_MOBILE_START));//10SºóÖØÊÔ
+ log_debug("dm_telecom_register_request_handle addtimer: g_retrytimes_before_netactived = %d, dmType(%d), secTimer(%d)\n", g_retrytimes_before_netactived, dmControlInfo->dmType, 10);
+ }
+ else
+ {
+ dmControlInfo->currentTimes++; /*´ÎÊý½øÐмÆÊý */
+ /* ʧ°ÜÆô¶¯Ã¿´Î³¢ÊÔ¶¨Ê±Æ÷ */
+ dm_timer_add(dmControlInfo->secsEveryTime * 60, DM_TIMER_ID_MOBILE_EVERY_TIMES);
+ }
+ return DM_ERR_NET_ERROR;
+ }
+
+ while (checkTimes-- > 0)
+ {
+ if (1 == default_route_check())
+ break;
+ usleep(1000 * 400);
+ log_debug("mobile startup check rout times(%d)\n", checkTimes);
+ if (checkTimes == 0)
+ {
+ log_err("dm net some error occur\n");
+ return DM_ERR_CHECK_ROUTE_ERROR;
+ }
+ }
+ dmControlInfo->currentTimes++; /*´ÎÊý½øÐмÆÊý */
+ /*·¢Æðhttp´«ÊäÁ÷³Ì */
+ if (DM_ERR_SUCCESS != dm_telecom_register_start(dmControlInfo))
+ {
+
+ /* ³¢ÊÔ×¢²áµÄ´ÎÊýСÓÚ 10 ´Îʱ£¬¼ÌÐø³¢ÊÔ */
+ if (dmControlInfo->currentTimes < DM_TELECOM_RETRY_TIMES)
+ {
+ /*1¡¢dmControlInfo->secsEveryRound Óû§Í¨¹ý¹¤³ÌÃüÁîÉèÖÃ,Ä¿µÄÊÇ·½±ã²âÊÔÈËÔ±½øÐвâÊÔ£¬
+ * ´ËÖµ´úÌæÐÒé¹æ¶¨µÄÕæʵµÄ´Î¼ä¸ôʱ¼ä£¬Ëõ¶Ì²âÊÔʱ¼ä£»
+ *2¡¢Ä¬ÈÏÖµ0,±íʾʹÓÃÕæʵµÄ´Î¼ä¸ôʱ¼ä£¬·Ç0 ±íʾʹÓôËÉèÖõÄÖµ´úÌæ²âÊÔ */
+ if (0 != dmControlInfo->secsEveryRound)
+ {
+ dmControlInfo->secsEveryTime = dmControlInfo->secsEveryRound;
+
+ }
+ /* ʧ°ÜÆô¶¯Ã¿´Î³¢ÊÔ¶¨Ê±Æ÷ */
+ dm_timer_add(dmControlInfo->secsEveryTime * 60, DM_TIMER_ID_MOBILE_EVERY_TIMES);
+ }
+
+ log_debug("dm mobile register error, ret(%d), currentTimes(%d), next-rtc-time(%d)\n", ret, dmControlInfo->currentTimes, dmControlInfo->secsEveryTime);
+ return ret;
+ }
+
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_net_global_romaing_proc
+ * ¹¦ÄÜÃèÊö£ºÂþÓÎÏûÏ¢´¦Àíº¯Êý , ÓÉbl²ãÉϱ¨
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_net_global_romaing_proc(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(dmControlInfo);
+ char romaingStatus[DM_NV_ITEM_SIZE] = {0};
+ char netStatus[4] = {0};
+
+ CALL(sc_cfg_get(NV_PDP_STATUS, netStatus, sizeof(netStatus)));
+ CALL(sc_cfg_get(NV_SIMCARD_ROAM, romaingStatus, sizeof(romaingStatus)));
+
+ dmControlInfo->netStatus = atoi(netStatus);
+
+ if (0 == strcmp(romaingStatus, "Internal"))
+ {
+ dmControlInfo->globalRomaing = 1;
+ }
+ else if (0 == strcmp(romaingStatus, "Home"))
+ {
+ dmControlInfo->globalRomaing = 0;
+ }
+ else
+ {
+ log_err("dm global romaing some error, romaingStatus(%s) \n ", romaingStatus);
+ return DM_ERR_ROMAING_STATUS_ERROR;
+ }
+
+ /* ÍøÂçÊý¾Ý¿ª¹Ø´ò¿ª£¬ Çҷǹú¼ÊÂþÓÎ */
+ if (dmControlInfo->netStatus && !dmControlInfo->globalRomaing)
+ {
+ /* ÏÂÃæ±ê¼ÇµÄ¹¦ÄÜÊÇ: ¶¨Ê±Æ÷³¬Ê±£¬¶øÓÉÓÚÍøÂç¹Ø±Õ£¬±ØÐëµÈ´ýÍøÂ翪¹Ø´ò¿ª½øÐÐ×¢²á
+ * Ðë±£Ö¤´Î±êÖ¾Ö»ÄÜÔÚ×¢²áÏß³ÌÖнøÐÐÐ޸ģ¬(Ô¤·À±äÁ¿¶àÏ߳̽»²æÐÞ¸Ä)
+ */
+ if (dmControlInfo->needRegForNetStatusChange == 1)
+ {
+ /* ÏûÏ¢·¢ËÍ£¬¿ªÊ¼×¢²áÁ÷³Ì */
+ CALL(dm_register_msg_send(dmControlInfo));
+ }
+ }
+
+ log_debug("dm global-roaming change now, romaingStatus(%s)\n", romaingStatus);
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_config_info_msg_prc
+ * ¹¦ÄÜÃèÊö£ºCp²àµÄ¹¤³ÌÃüÁîÏûÏ¢´¦Àíº¯Êý
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_config_info_msg_prc(MSG_BUF *pstMsg, struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(pstMsg);
+ CHECK_PARAM(dmControlInfo);
+ CHECK_PARAM(pstMsg->aucDataBuf);
+
+ unsigned short dataSize = 0;
+ char *buf = NULL;
+
+ dataSize = pstMsg->usDataLen;
+ if (pstMsg->usDataLen <= 0)
+ {
+ log_err("dm msg some err now, data-len(%d)\n", dataSize);
+ return DM_ERR_PARAM_NULL;
+ }
+
+ if (strstr((char *) pstMsg->aucDataBuf, "AT+DM_REGISTER_SERVER=")) /*CP ²àµÄ¹¤³ÌÃüÁîÏûÏ¢£¬ÉèÖÃÁªÍ¨·þÎñÆ÷µØÖ·¡¢¶Ë¿ÚÏûÏ¢ */
+ {
+ CALL(dm_server_domain_config_set(pstMsg, dmControlInfo));
+
+ if (strstr((char *) pstMsg->aucDataBuf, "AT+DM_REGISTER_PORT_NUM="))
+ {
+ CALL(dm_server_port_num_set(pstMsg, dmControlInfo));
+ }
+ }
+ else if (strstr((char *) pstMsg->aucDataBuf, "AT+DM_REGISTER_FLAG="))/*CP ²àµÄ¹¤³ÌÃüÁîÏûÏ¢£¬Çå³ý×¢²á±ê¼Ç */
+ {
+ dm_register_flag_clean(dmControlInfo);
+ }
+ else if (strstr((char *) pstMsg->aucDataBuf, "AT+DM_REGISTER_SECS_ROUND=")) /*CP ²àµÄ¹¤³ÌÃüÁî, ÉèÖÃÿÂÖµÄʱ¼ä¼ä¸ô */
+ {
+ CALL(dm_time_every_round_set(pstMsg, dmControlInfo));
+ }
+ else if ((buf = strstr((char *) pstMsg->aucDataBuf, "AT+DM_REGISTER_W_ONLY="))) /*CP ²àµÄ¹¤³ÌÃüÁ ±£´æÖÆʽ*/
+ {
+ /*Ô¤·ÀbufÄÚÈݹý´ó£¬µ¼ÖÂдNVʧ°Ü */
+ char bufData[4] = {0};
+ buf = buf + strlen("AT+DM_REGISTER_W_ONLY=");
+ sscanf(buf, "%3[^,]", bufData);
+ sc_cfg_set("wcdmaModel", bufData);
+ }
+
+ log_debug("dm config info set now: info(%s), info-size(%d)\n", pstMsg->aucDataBuf, pstMsg->usDataLen);
+ return DM_ERR_SUCCESS;
+}
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_queue_msg_proc
+ * ¹¦ÄÜÃèÊö£ºDMÄ£¿éÖ÷Ïß³ÌÏûÏ¢´¦Àíº¯Êý£¬ Ïß³ÌÓÃÓÚ½ÓÊն෽ÏûÏ¢(°üÀ¨£¬CP²à¸÷ÖÖ¹¤³ÌÃüÁîµÄÏûÏ¢£¬×ÓÏ̵߳ÄÏûÏ¢£¬¶¨Ê±Æ÷ÏûÏ¢)
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£ºÎÞ
+ * ÆäËü˵Ã÷£º
+ */
+static void dm_queue_msg_proc(MSG_BUF *pstMsg, struct DM_CONTROl_INFO *dmControlInfo)
+{
+ switch (pstMsg->usMsgCmd)
+ {
+ case RTC_MSG_ALARM_ELAPSED:
+ {
+ /* rtc¶¨Ê±Æ÷³¬Ê±ÏûÏ¢ */
+ char simCardStatus[DM_NV_ITEM_SIZE] = {0};
+ char cardType[DM_NV_ITEM_SIZE] = {0};
+ char ceregStatus[DM_NV_ITEM_SIZE] = {0};
+ sc_cfg_get(DM_SIM_CARD_STATUS, simCardStatus, sizeof(simCardStatus));
+ sc_cfg_get(NV_SIMCARD_TYPE, cardType, sizeof(cardType));
+ sc_cfg_get(DM_CEREG_STATUS, ceregStatus, sizeof(ceregStatus));
+ log_debug("dm_queue_msg_proc: time out now, simCardStatus(%s), cardType(%s)\n", simCardStatus, cardType);
+ /*
+ * simCardStatus nv Öµ 1 »òÕß 5, ±íÃ÷×¢Íø³É¹¦£¬carType¿Õ£¬ÍøÂç¿Ï¶¨Ã»ÓÐ×¼±¸ºÃ
+ */
+ if ((!strcmp(simCardStatus, "1") || !strcmp(simCardStatus, "5")) && (strcmp(cardType, "")))
+ {
+ dm_register_msg_send(dmControlInfo);
+ }
+ else if((!strcmp(ceregStatus, "1") || !strcmp(ceregStatus, "5")) && (strcmp(cardType, "")) )
+ {
+ dm_register_msg_send(dmControlInfo);
+ }
+ else
+ {
+ /*
+ *µÈ´ý10s, ÖØг¢ÊÔ£¬ Ö±µ½nvÐÅÏ¢×¼±¸ºÃ; pin Â뿪»ú×ß·ÖÖ§
+ */
+ dm_timer_add(10, 0);
+ log_debug("dm queue msg proc have add 10s timer now \n");
+ }
+ break;
+ }
+
+ case MSG_CMD_DM_CONFIG_REQ: /*CP ²àµÄ¹¤³ÌÃüÁîÏûÏ¢£¬ÉèÖÃdm²¿·Ö¿ØÖÆÐÅÏ¢ */
+ {
+ dm_config_info_msg_prc(pstMsg, dmControlInfo);
+ break;
+ }
+
+ case MSG_CMD_ROAM_STATUS_IND: /*Êý¾ÝÂþÓÎÏûÏ¢ */
+ {
+ dm_net_global_romaing_proc(dmControlInfo);
+ break;
+ }
+
+ case MSG_CMD_PDP_STATUS_IND: /*pdpÁ´Â·ÏûÏ¢, Òƶ¯²»ÎÞÐè¹Ø×¢*/
+ {
+ printf("dm_queue_msg_proc: MSG_CMD_PDP_STATUS_IND \n");
+ dm_net_status_change_proc(dmControlInfo);
+ break;
+ }
+
+ case DM_MSG_CMD_MAIN_THREAD_EXIT:
+ {
+ dmControlInfo->mainThreadFlag = 0;
+ log_debug("dm main thread ready to exit now \n");
+ break;
+ }
+
+ default:
+ log_debug("dm queue msg default proc£¬\n");
+ }
+
+}
+
+
+/**
+ * º¯ÊýÃû³Æ£ºdm_server_init
+ * ¹¦ÄÜÃèÊö£ºDMÄ£¿éÖ÷Ï̷߳þÎñ³õʼ»¯
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º³É¹¦ 0: ʧ°Ü ´íÎóÂë
+ * ÆäËü˵Ã÷£º
+ */
+static int dm_server_init(struct DM_CONTROl_INFO *dmControlInfo)
+{
+ CHECK_PARAM(dmControlInfo);
+ int ret = 0;
+ MSG_BUF dmMsg = {0};
+ long msgSize = 0;
+
+ dmControlInfo->serverId = pthread_self();
+ if (-1 == ((dmControlInfo->msgQueueId) = msgget(MODULE_ID_DMREG, IPC_CREAT | 0600)))
+ {
+ log_err("Create MSG_ID_DMREG queue faild! (*msgId)(%d)\n", dmControlInfo->msgQueueIdReg);
+ return DM_ERR_CREATE_MSG_QUEUE_ERROR;
+ }
+
+ /*´´½¨¶¨Ê±Æ÷*/
+ if (DM_ERR_SUCCESS != (ret = dm_timer_create(dmControlInfo)))
+ {
+ log_err("dm timer create error...\n");
+ return DM_ERR_CREATE_MSG_QUEUE_ERROR;
+ }
+
+ log_debug("dm main thread start now...\n");
+ dmControlInfo->mainThreadFlag = 1;
+ while (dmControlInfo->mainThreadFlag)
+ {
+ memset((void*)(&dmMsg), 0, sizeof(MSG_BUF));
+ msgSize = sizeof(MSG_BUF) - sizeof(long);
+ if (0 < (ret = msgrcv(dmControlInfo->msgQueueId, &dmMsg, msgSize, 0, MSG_NOERROR)))
+ {
+ log_debug("dm main queue recv msg now: ret(%d), dmMsg.src_id(0x%08x), dmMsg.usMsgCmd(0x%08x), dmMsg.usDatalen(%d), dmMsg.auDataBuffer(%s)\n",
+ ret, dmMsg.src_id, dmMsg.usMsgCmd, dmMsg.usDataLen, dmMsg.aucDataBuf);
+ dm_queue_msg_proc(&dmMsg, dmControlInfo);
+ }
+ }
+
+ if (msgctl(dmControlInfo->msgQueueId, IPC_RMID, NULL) < 0)
+ log_err("dm remove msg now error \n");
+
+ log_debug("dm main thread exit...\n");
+ return DM_ERR_SUCCESS;
+}
+
+/*******************************************************************************
+ * È«¾Öº¯Êý¶¨Òå *
+ ******************************************************************************/
+/**
+ * º¯ÊýÃû³Æ£ºmain
+ * ¹¦ÄÜÃèÊö£ºDMÄ£¿éÈë¿Úº¯Êý
+ * ²ÎÊý˵Ã÷£º
+ * ·µ »Ø Öµ£º
+ * ÆäËü˵Ã÷£º
+ */
+int main(void)
+{
+ int ret = DM_ERR_SUCCESS;
+ struct DM_CONTROl_INFO dmControlInfo = {0};
+
+ //¸ù¾ÝNV³õʼ»¯´òÓ¡¼¶±ð£¬²¢×¢²á¶¯Ì¬µ÷Õû´òÓ¡¼¶±ðÐźÅÁ¿
+ loglevel_init();
+
+ /* ³õʼ»¯DM¿ØÖÆÏà¹ØÐÅÏ¢ */
+ ret = dm_control_info_init(&dmControlInfo);
+ if (DM_ERR_SUCCESS != ret)
+ {
+ log_err("dm init control info error...\n");
+ exit(EXIT_FAILURE);
+ }
+
+ /* ´´½¨×¢²áỊ̈߳¬ ÓÃÓÚÏòÔËÓªÉÌ·þÎñÆ÷½øÐÐÌá½»×¢²á (Ö»½ÓÊÜÖ÷Ï̷߳¢Ë͵ÄÏûÏ¢£¬
+ * ÓÉÓÚ×¢²áºÄʱ£¬Ðë¶ÀÁ¢Ï̴߳¦Àí£©*/
+ if (DM_ERR_SUCCESS != (ret = dm_register_thread_init(&dmControlInfo)))
+ {
+ log_err("dm register thread start error...\n");
+ exit(EXIT_FAILURE);
+ }
+
+ /* DM·þÎñÖ÷Ị̈߳¬ÓÃÓÚ½ÓÊÕ¸÷ÖÖÏûÏ¢(°üÀ¨CP£¬¶¨Ê±Æ÷ÏûÏ¢£¬APµÄÏûÏ¢) */
+ if (DM_ERR_SUCCESS != (ret = dm_server_init(&dmControlInfo)))
+ {
+ log_err("dm server start error ...\n");
+ exit(EXIT_FAILURE);
+ }
+
+ pthread_join(dmControlInfo.pid, NULL);
+ return 0;
+}
+