| /**
|
| *
|
| * @file log_agent_tool.c
|
| * @brief
|
| * This file is part of ZCAT.
|
| * zcatÓ¦Óòãlog_agent´¦ÀíÊý¾ÝÔ´µÄ°ïÖúº¯Êý
|
| *
|
| * @details
|
| * @author Tools Team.
|
| * @email
|
| * @copyright Copyright (C) 2013 Sanechips Technology Co., Ltd.
|
| * @warning
|
| * @date 2019/02/02
|
| * @version 1.2
|
| * @pre
|
| * @post
|
| *
|
| * @par
|
| * Change History :
|
| * ---------------------------------------------------------------------------
|
| * date version author description
|
| * ---------------------------------------------------------------------------
|
| * 2017/07/17 1.0 hou.bing Create file
|
| * 2019/01/24 1.1 jiang.fenglin 1.Ìí¼Óusblog¶ÁдËø
|
| * 2.Ìí¼ÓÏß³ÌÃû³Æ
|
| * 2019/02/02 1.2 jiang.fenglin ÐÞ¸Ä×¢ÊÍ·½Ê½Îªdoxygen
|
| * 2019/07/08 1.3 jiang.fenglin Ôö¼ÓAPFS/CPFSģʽ
|
| * ---------------------------------------------------------------------------
|
| *
|
| *
|
| */
|
|
|
|
|
| /**
|
| * Í·Îļþ°üº¬
|
| */
|
| #include <string.h>
|
| #include <signal.h>
|
| #include <time.h>
|
| #include <pthread.h>
|
| #include <sys/time.h>
|
| #include <sys/ioctl.h>
|
| #include "log_agent.h"
|
|
|
| #define MAX_PACKET_LEN (0x10000)
|
| #define MAX_ENCODE_PACKET_LEN (MAX_PACKET_LEN * 2)
|
| #define COMM_MDLNO_ZCAT_FLAG 115
|
| #define COMM_MDLNO_RAMDUMP_FLAG 119
|
| #define MAX_AP_LOG_BUFF_LEN 2048
|
|
|
| extern E_ZCAT_MODE g_log_dir;
|
| extern E_ZCAT_STATE g_log_state;
|
|
|
| extern int send_message_to_client(unsigned char* buf, int len);
|
| extern int send_message_to_usblog(unsigned char* buf, int len);
|
| extern int send_message_to_sdcard(unsigned char* buf, int len);
|
| extern int init_sdcard_log_dir(E_FLASH_MODE mode);
|
| extern int init_fs_log_dir();
|
| extern int zCat_MountSd();
|
| extern BOOL hdlc_encode(T_HDLC_BUFFER_TYPE *dest, const T_HDLC_BUFFER_TYPE *src);
|
| extern BOOL hdlc_decode(T_HDLC_BUFFER_TYPE *dest, T_HDLC_BUFFER_TYPE *src);
|
|
|
|
|
| int deal_with_encoded_data(unsigned char* buffer, int buf_len);
|
|
|
| int hb_flag = 0;
|
| int bFirst = 1;
|
| /*É豸¾ä±ú*/
|
| extern int ramdump_fd;
|
| extern int kernellog_fd;
|
| extern int applog_fd;
|
| extern int cplog_fd;
|
|
|
| /*Ï̻߳¥³âËø*/
|
| static pthread_mutex_t mutex_AP;
|
| static pthread_mutex_t mutex_SD;
|
|
|
| static T_HDLC_BUFFER_TYPE g_recvBuf = {0};
|
|
|
| static unsigned int gCommEncodeBuffer[MAX_ENCODE_PACKET_LEN / 4] = {0};
|
| static unsigned int gCommDecodeBuffer[MAX_ENCODE_PACKET_LEN / 4] = {0};
|
| static unsigned int gCommRecvBuffer[MAX_ENCODE_PACKET_LEN / 4] = {0};
|
|
|
| BOOL bSDSet = FALSE;
|
|
|
| void init_log_agent_tools()
|
| {
|
| g_recvBuf.buf = (unsigned char *)gCommRecvBuffer;
|
| g_recvBuf.bufIndex = 0;
|
| g_recvBuf.bufSize = 0;
|
| pthread_mutex_init(&mutex_AP, NULL);
|
| pthread_mutex_init(&mutex_SD, NULL);
|
| }
|
|
|
| int g_cp_log_count = 0;
|
| int g_ap_log_count = 0;
|
|
|
| /**
|
| * @brief ´òӡʱ¼äµÄ°ïÖúº¯Êý
|
| * @param[in] void
|
| * @return void
|
| * @note
|
| * @see
|
| */
|
| char* zte_time()
|
| {
|
| time_t timep;
|
| struct tm *p;
|
| static char buf[22];
|
| memset(buf, 0, 22);
|
| time(&timep);
|
| p =localtime(&timep);
|
| if(p != NULL)
|
| snprintf(buf,21,"%4d/%02d/%02d %02d:%02d:%02d ",1900 + p->tm_year,1 + p->tm_mon,p->tm_mday,p->tm_hour,p->tm_min,p->tm_sec);
|
| return buf;
|
| }
|
|
|
| /**
|
| * @brief ½«¹æÔòÎļþ¡¢ÐÄÌø°üµÄÏÂÐÐÊý¾Ý·¢Ë͵½cp
|
| * @param[in] buf ´ý·¢Ë͵ÄÊý¾ÝÖ¸Õë
|
| * @param[in] len ´ý·¢Ë͵ÄÊý¾Ý³¤¶È
|
| * @return ʵ¼Ê·¢Ë͵ÄÊý¾Ý³¤¶È
|
| * @note
|
| * @see
|
| */
|
| int send_log_to_cp(unsigned char *buf, int len)
|
| {
|
| int write_len = 0;
|
| if(buf == NULL || cplog_fd == -1)
|
| {
|
| printf("[zcat] send_log_to_cp fail\n");
|
| return 0;
|
| }
|
| write_len = write(cplog_fd, buf, len);
|
|
|
| return write_len;
|
| }
|
|
|
| /**
|
| * @brief ¸ù¾Ýzcat_mode£¬·¢ËÍlogµ½²»Í¬µÄÍâÉ裺usb¡¢Íø¿¨¡¢sd¿¨
|
| * @param[in] buf ´ý·¢Ë͵ÄÊý¾ÝÖ¸Õë
|
| * @param[in] len ´ý·¢Ë͵ÄÊý¾Ý³¤¶È
|
| * @return void
|
| * @note
|
| * @see
|
| */
|
| void send_log_out(unsigned char* buf, int len)
|
| {
|
| if(g_log_state != ZCAT_STATE_RUNNING)
|
| {
|
| printf("[zcat] send_log_out fail, state = %d.\n", g_log_state);
|
| return;
|
| }
|
|
|
| if(g_log_dir == ZCAT_MODE_AP_NET)
|
| {
|
| send_message_to_client(buf, len);
|
| }
|
| else if(g_log_dir == ZCAT_MODE_AP_USB)
|
| {
|
| int i;
|
| int cnt = len / MAX_AP_LOG_BUFF_LEN;
|
|
|
| for(i = 0; i < cnt; i++)
|
| {
|
| g_cp_log_count++;
|
| send_message_to_usblog(buf + i * MAX_AP_LOG_BUFF_LEN, MAX_AP_LOG_BUFF_LEN);
|
| }
|
|
|
| cnt = len % MAX_AP_LOG_BUFF_LEN;
|
| if(cnt > 0)
|
| {
|
| g_cp_log_count++;
|
| send_message_to_usblog(buf + i * MAX_AP_LOG_BUFF_LEN, cnt);
|
| }
|
| }
|
| else if(g_log_dir == ZCAT_MODE_AP_TF)
|
| {
|
| if(bSDSet == FALSE )
|
| {
|
| if(zCat_MountSd())
|
| return;
|
|
|
| bSDSet = TRUE;
|
| if(init_sdcard_log_dir(FLASH_MODE_NOMAL) < 0) //³õʼ»¯cpÊä³öÎļþ¼Ð¼°²ÎÊý
|
| {
|
| bSDSet = FALSE;
|
| return;
|
| }
|
| hb_flag = 1;
|
| return;
|
| }
|
| if(bSDSet == TRUE)
|
| {
|
| pthread_mutex_lock(&mutex_SD);
|
| send_message_to_sdcard(buf, len);
|
| pthread_mutex_unlock(&mutex_SD);
|
| }
|
| }
|
| else if(g_log_dir == ZCAT_MODE_AP_FS)
|
| {
|
| if(bSDSet == FALSE )
|
| {
|
| bSDSet = TRUE;
|
| if(init_fs_log_dir() < 0) //³õʼ»¯cpÊä³öÎļþ¼Ð¼°²ÎÊý
|
| {
|
| bSDSet = FALSE;
|
| return;
|
| }
|
| hb_flag = 1;
|
| return;
|
| }
|
| if(bSDSet == TRUE)
|
| {
|
| pthread_mutex_lock(&mutex_SD);
|
| send_message_to_sdcard(buf, len);
|
| pthread_mutex_unlock(&mutex_SD);
|
| }
|
| }
|
| else
|
| {
|
| deal_with_encoded_data(buf, len);
|
| }
|
| }
|
|
|
| /**
|
| * @brief ½«ap²àprintf¡¢printk²úÉúµÄlogÊý¾Ý·¢ËͳöÈ¥
|
| * @param[in] commHeader ´ý·¢Ë͵ÄÊý¾Ý
|
| * @return void
|
| * @note
|
| * @see
|
| */
|
| static void send_ap_log_out(T_COMM_TYPE *commHeader)
|
| {
|
| T_HDLC_BUFFER_TYPE srcBuf = {0};
|
| //T_ZCAT_HEADER *zcatHeader = (T_ZCAT_HEADER *)(((unsigned char*)commHeader) + sizeof(T_COMM_TYPE));
|
| T_HDLC_BUFFER_TYPE destBuf = {(unsigned char *)gCommEncodeBuffer, 0, MAX_ENCODE_PACKET_LEN};
|
| //int cmd_code = zcatHeader->cmd_code;
|
|
|
| //UINT16 times = 0;
|
| //UINT16 ipLast = 0;
|
|
|
| srcBuf.buf = (unsigned char *)(commHeader);
|
| srcBuf.bufIndex = 0;
|
| srcBuf.bufSize = sizeof(T_COMM_TYPE) + commHeader->buf_len;
|
| destBuf.bufIndex = 0;
|
| if(g_log_state != ZCAT_STATE_RUNNING)
|
| {
|
| free((void*)commHeader);
|
| return;
|
| }
|
| pthread_mutex_lock(&mutex_AP); // ¼Ó»¥³âËø£¬·Àֹͬʱ²Ù×÷gCommEncodeBuffer
|
| if (hdlc_encode(&destBuf, &srcBuf)) // ±àÂë
|
| {
|
| if(g_log_dir == ZCAT_MODE_CP_USB || g_log_dir == ZCAT_MODE_CP_TF || g_log_dir == ZCAT_MODE_CP_FS)
|
| {
|
| send_log_to_cp(destBuf.buf, destBuf.bufIndex);
|
| }
|
| else
|
| {
|
| send_log_out(destBuf.buf, destBuf.bufIndex);
|
| }
|
| }
|
| pthread_mutex_unlock(&mutex_AP); // ½â³ý»¥³âËø
|
| free((void*)commHeader);
|
| }
|
|
|
| /**
|
| * @brief ·¢ËÍÊý¾Ýµ½"ͳһ»º´æ"ÖÐ
|
| * @param[in] buf ·¢ËÍÊý¾Ý(±ØÐëÊÇÓÉComm_MallocÉêÇëµÄÄÚ´æ!!!)
|
| * @param[in] buf_len ·¢ËÍÊý¾ÝµÄ³¤¶È
|
| * @param[in] tgt_mdl_no Ä¿±êÄ£¿éºÅ£¬ÊÖ»ú»òPCµÈ
|
| * @param[in] tgt_submdl_no Ä¿±ê×ÓÄ£¿éºÅ
|
| * @param[in] src_submdl_no Ô´×ÓÄ£¿éºÅ
|
| * @return ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
|
| * @note
|
| * @see
|
| */
|
| unsigned int zTools_SendData(unsigned char *buf, unsigned int buf_len,
|
| unsigned char tgt_mdl_no, unsigned char tgt_submdl_no, unsigned char src_submdl_no)
|
| {
|
| T_COMM_TYPE *commHeader = NULL;
|
|
|
| /* Èë²ÎÅÐ¶Ï */
|
| if (buf == NULL || buf_len == 0 || tgt_mdl_no == 0 || tgt_submdl_no == 0 || src_submdl_no == 0)
|
| {
|
| return -1;
|
| }
|
|
|
| commHeader = (T_COMM_TYPE *)(buf - sizeof(T_COMM_TYPE));
|
|
|
| commHeader->msg_type = 1;
|
| commHeader->pad = 0xAA;
|
| commHeader->reserved = 0xAAAA;
|
| commHeader->tgt_mdl_no = tgt_mdl_no; // Ä¿±êÄ£¿é
|
| commHeader->tgt_submdl_no = tgt_submdl_no; // Ä¿±ê×ÓÄ£¿é
|
| commHeader->src_mdl_no = MDL_PHONE; // Ô´Ä£¿é
|
| commHeader->src_submdl_no = src_submdl_no; // Ô´×ÓÄ£¿é
|
| commHeader->buf_len = buf_len; // Êý¾ÝÇø³¤¶È
|
|
|
| send_ap_log_out(commHeader);
|
| return 0;
|
| }
|
|
|
| /**
|
| * @brief ZCATÏûϢͷ³õʼ»¯
|
| * @param[out] zcatHeader ÏûϢͷָÕë
|
| * @param[in] cmd_code ÏûÏ¢Âë
|
| * @param[in] len ÏûÏ¢³¤¶È
|
| * @return N/A
|
| * @note
|
| * @see
|
| */
|
| VOID zCatAgt_HeaderInit(T_ZCAT_HEADER *zcatHeader, unsigned char cmd_code, unsigned int len)
|
| {
|
| struct timeval tmpTimeVal = {0};
|
|
|
| zcatHeader->cmd_code = cmd_code;
|
| zcatHeader->reserved = 0xBBBB;
|
| zcatHeader->timeStamp[1] = 0;
|
| zcatHeader->length = len;
|
| zcatHeader->timeStamp[0] = 0;//corem»ñȡʱ¼ä
|
| gettimeofday(&tmpTimeVal, NULL);
|
| zcatHeader->timeStamp[1] = tmpTimeVal.tv_sec;
|
| }
|
|
|
| /**
|
| * @brief ·¢ËÍZCATÏûÏ¢µ½"ÍâÉè"
|
| * @param[in] cmd_code ÏûÏ¢Âë
|
| * @param[in] buf ÏûÏ¢Êý¾ÝÖ¸Õë
|
| * @param[in] len ÏûÏ¢Êý¾Ý³¤¶È
|
| * @return ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
|
| * @note
|
| * @see
|
| */
|
| unsigned int zCatAgt_SendMsg(unsigned char cmd_code, unsigned char *buf, unsigned int len)
|
| {
|
| T_ZCAT_HEADER *zcatHeader = (T_ZCAT_HEADER *)(buf - sizeof(T_ZCAT_HEADER));
|
|
|
| zCatAgt_HeaderInit(zcatHeader, cmd_code, len);
|
|
|
| return zTools_SendData((unsigned char *)zcatHeader, sizeof(T_ZCAT_HEADER) + len, MDL_ZCAT, 1, SUBMDL_ZCATAGT);
|
| }
|
|
|
| /**
|
| * @brief »ñÈ¡Ä£¿éºÍµÈ¼¶
|
| * @param[in] buf ÏûÏ¢Êý¾ÝÖ¸Õë
|
| * @param[in] bufLen ÏûÏ¢Êý¾Ý³¤¶È
|
| * @param[in] priority ÏûÏ¢µÈ¼¶
|
| * @param[in] mod Ä£¿é±àºÅ
|
| * @return void
|
| * @note
|
| * @see
|
| */
|
| VOID zCatAgt_Ap_GetModAndPri(unsigned char **buf, unsigned short *bufLen, unsigned char *pPriority, unsigned char *pMod)
|
| {
|
| unsigned char *p = *buf;
|
| unsigned short len = *bufLen;
|
|
|
| if (len > 3 && p[0] == '<' && p[1] >= '0' && p[1] <= '7' && p[2] == '>')
|
| {
|
| *pPriority = p[1] - '0';
|
| p += 3;
|
| len -= 3;
|
|
|
| if (len > 3 && p[0] == '<' && p[1] > '0' && p[1] <= '9')
|
| {
|
| if (p[2] == '>')
|
| {
|
| *pMod = p[1] - '0';
|
| p += 3;
|
| len -= 3;
|
| }
|
| else if (len > 4 && p[2] >= '0' && p[2] <= '9')
|
| {
|
| if (p[3] == '>')
|
| {
|
| *pMod = (p[1] - '0') * 10 + (p[2] - '0');
|
| p += 4;
|
| len -= 4;
|
| }
|
| else if (len > 5 && p[3] >= '0' && p[3] <= '9' && p[4] == '>')
|
| {
|
| *pMod = (p[1] - '0') * 100 + (p[2] - '0') * 10 + (p[3] - '0');
|
| p += 5;
|
| len -= 5;
|
| }
|
| }
|
| }
|
| }
|
|
|
| *buf = p;
|
| *bufLen = len;
|
| }
|
|
|
| /**
|
| * @brief ·¢ËÍAP LOGµ½"ͳһ»º´æ"ÖÐ
|
| * @param[in] cmd_code ÏûÏ¢Âë
|
| * @param[in] priority ÏûÏ¢µÈ¼¶
|
| * @param[in] mod Ä£¿é±àºÅ
|
| * @param[in] buf ÏûÏ¢Êý¾ÝÖ¸Õë
|
| * @param[in] len ÏûÏ¢Êý¾Ý³¤¶È
|
| * @return ³É¹¦·µ»ØZOSS_SUCCESS, ·ñÔò·µ»ØZOSS_ERROR
|
| * @note
|
| * @see
|
| */
|
| unsigned int zCatAgt_Ap_SendMsg(unsigned char cmd_code, unsigned char priority, unsigned char mod, unsigned char *buf, unsigned int len)
|
| {
|
| T_ZCAT_APLOG_HEADER *apHeader = NULL;
|
| unsigned char *newBuffer = malloc(sizeof(T_ZCAT_APLOG_HEADER) + sizeof(T_ZCAT_HEADER) + sizeof(T_COMM_TYPE) + len);
|
|
|
| if(newBuffer == NULL)
|
| {
|
| printf("[zcat] malloc buffer failed!\n");
|
| return -1;
|
| }
|
| apHeader = (T_ZCAT_APLOG_HEADER *)(newBuffer + sizeof(T_ZCAT_HEADER) + sizeof(T_COMM_TYPE));
|
| #if 0
|
| if (apHeader == NULL)
|
| {
|
| printf("[zcat] apHeader is null.\n");
|
| return -1;
|
| }
|
| else
|
| #endif
|
| {
|
| apHeader->priority = priority;
|
| apHeader->mod = mod;
|
| apHeader->len = len;
|
| memcpy(apHeader + 1, buf, len);
|
| return zCatAgt_SendMsg(cmd_code, (unsigned char *)apHeader, sizeof(T_ZCAT_APLOG_HEADER) + len);
|
| }
|
|
|
| }
|
|
|
| /**
|
| * @brief ·ÖÎöAP LOG£¬°´»»ÐÐÖØзָî
|
| * @param[in] src Ô´
|
| * @param[in] dst Ä¿µÄ
|
| * @return Èç¹û³É¹¦·µ»ØTRUE, ·ñÔò·µ»ØFALSE
|
| * @note
|
| * @see
|
| */
|
| BOOL zCatAgt_Ap_ReadBuffer(T_AP_SRC_BUFFER_TYPE *src, T_AP_DEST_BUFFER_TYPE *dest)
|
| {
|
| if (src != NULL && src->buf != NULL && src->bufSize > src->beginIndex && dest != NULL )
|
| {
|
| unsigned char *src_buf = src->buf + src->beginIndex;
|
| unsigned int src_length = src->bufSize - src->beginIndex;
|
| unsigned int buf_length = src_length > AP_LOG_MAX_LENGTH ? AP_LOG_MAX_LENGTH : src_length;
|
| unsigned int i = 0;
|
|
|
| for (; i < buf_length; i++)
|
| {
|
| if (src_buf[i] == '\n')
|
| {
|
| i++;
|
| dest->newLine = 1;
|
| break;
|
| }
|
| }
|
|
|
| dest->buf = src->buf + src->beginIndex;
|
| dest->len = i;
|
| src->beginIndex += i;
|
|
|
| return TRUE;
|
| }
|
|
|
| return FALSE;
|
| }
|
|
|
| void timer(int sig)
|
| {
|
| hb_flag = 0;
|
|
|
| return;
|
| }
|
|
|
| /**
|
| * @brief ´¦Àíδ±àÂëµÄÊý¾Ý£¬¸ù¾ÝÀàÐÍ·Ö±ð½øÐÐÏàÓ¦´¦Àí
|
| * @param[in] buffer »º´æÖ¸Õë
|
| * @param[in] buf_len »º´æ³¤¶È
|
| * @return ³É¹¦·µ»Ø0£»Ê§°Ü·µ»Ø-1
|
| * @note
|
| * @see
|
| */
|
| void deal_with_rawdata(unsigned char* buf, unsigned short buf_len)
|
| {
|
| T_COMM_TYPE commHeader = {0};
|
|
|
| if(buf_len > sizeof(T_COMM_TYPE))
|
| {
|
| memcpy(&commHeader, buf, sizeof(T_COMM_TYPE));
|
| if(commHeader.src_mdl_no == COMM_MDLNO_ZCAT_FLAG) //aplogÏûÏ¢£¬È¥³ýcomÍ·zcatÍ·diagÍ·
|
| {
|
| T_ZCAT_HEADER *zcatHeader = (T_ZCAT_HEADER*)(buf+sizeof(T_COMM_TYPE));
|
| if(zcatHeader->cmd_code >= ZCAT_CMDCODE_MAX)
|
| {
|
| printf("[zcat] zcatHeader->cmd_code:%d > ZCAT_CMDCODE_MAX\n", zcatHeader->cmd_code);
|
| return;
|
| }
|
| else if(zcatHeader->cmd_code == ZCAT_DIAG_REPORT)
|
| {
|
| hb_flag = 1;
|
| if(bFirst)
|
| {
|
| signal(SIGALRM, timer);
|
| bFirst = 0;
|
| }
|
| alarm(5);
|
|
|
| T_ZCAT_DIAG_HEADER *zdiagHeader = (T_ZCAT_DIAG_HEADER*)(buf + sizeof(T_COMM_TYPE)+sizeof(T_ZCAT_HEADER));
|
| if (zdiagHeader->diag_id == DIAG_FILTER_CONFIG)
|
| {
|
| T_ZCAT_DIAG_CONFIG_REQ *diag_config = (T_ZCAT_DIAG_CONFIG_REQ *)(zdiagHeader + 1);
|
| int headerLen = sizeof(T_COMM_TYPE)+sizeof(T_ZCAT_HEADER)+sizeof(T_ZCAT_DIAG_HEADER);
|
| if(diag_config->type == ZCAT_AP_APP_TYPE)
|
| {
|
| ioctl(applog_fd, 5, buf + headerLen);
|
| }
|
| else if(diag_config->type == ZCAT_AP_KERNEL_TYPE)
|
| {
|
| ioctl(kernellog_fd, 5, buf + headerLen);
|
| }
|
| }
|
| }
|
| }
|
| }
|
| }
|
|
|
| /**
|
| * @brief ´¦Àí±àÂëºóµÄÊý¾Ý£¬¸ù¾ÝÀàÐÍ·Ö±ð½øÐÐÏàÓ¦´¦Àí
|
| * @param[in] buffer »º´æÖ¸Õë
|
| * @param[in] buf_len »º´æ³¤¶È
|
| * @return ³É¹¦·µ»Ø0£»Ê§°Ü·µ»Ø-1
|
| * @note
|
| * @see
|
| */
|
| int deal_with_encoded_data(unsigned char* buffer, int buf_len)
|
| {
|
| static T_HDLC_BUFFER_TYPE dest = {(unsigned char *)gCommDecodeBuffer, 0, MAX_ENCODE_PACKET_LEN};
|
| T_HDLC_BUFFER_TYPE *src = &g_recvBuf;
|
| unsigned int remainLen = 0;
|
| BOOL ret_decode = FALSE;
|
|
|
| if(buffer == NULL)
|
| {
|
| printf("[zcat] deal_with_encoded_data input error!\n");
|
| return -1;
|
| }
|
|
|
| src->bufIndex=0;
|
|
|
| // ½«ÐÂÏûÏ¢Êý¾Ý¿½È뻺³åÇø
|
| if (src->bufSize + buf_len <= MAX_ENCODE_PACKET_LEN)
|
| {
|
| memcpy(src->buf + src->bufSize, buffer, buf_len);
|
| src->bufSize += buf_len;
|
| }
|
| else if (buf_len <= MAX_ENCODE_PACKET_LEN)
|
| {
|
| memcpy(src->buf, buffer, buf_len);
|
| src->bufSize = buf_len;
|
| }
|
| else
|
| {
|
| src->bufSize = 0;
|
| }
|
|
|
| remainLen = src->bufSize - src->bufIndex;
|
|
|
| while (remainLen > 0)
|
| {
|
| ret_decode = hdlc_decode(&dest, src);
|
| if(!ret_decode)
|
| {
|
| if (dest.bufIndex != 0 || src->bufSize - src->bufIndex == remainLen)
|
| {
|
| break;
|
| }
|
| }
|
| else
|
| {
|
| deal_with_rawdata(dest.buf, dest.bufIndex);
|
| dest.bufIndex = 0;
|
| }
|
| remainLen = src->bufSize - src->bufIndex;
|
| }//end while
|
| if (dest.bufSize <= dest.bufIndex)
|
| {
|
| dest.bufIndex = 0;
|
| }
|
| if (src->bufSize > src->bufIndex)
|
| {
|
| src->bufSize -= src->bufIndex;
|
| memmove(src->buf, src->buf + src->bufIndex, src->bufSize);
|
| }
|
| else
|
| {
|
| src->bufSize = 0;
|
| }
|
| src->bufIndex = 0;
|
| return 0;
|
| }
|