iec104/src/HTPublic.cpp

/****************************************************************************
** File name    :  HTPublic.cpp
** Description  :  common member function 
** Create date  :  2018.09.01
** Auther by    :  Liuyx
** Version info :  V1.0.01
** Copyrigth By:  xi'an huatek, Inc Co., Ltd
** Update record:  
** DATE         AUTHER   DESC 
** -------------------------------------------------------------------------               
** 2018.09.01   Liuyx    first build
****************************************************************************/
//#include "StdAfx.h"
#include "HTPublic.h"
#include "HTType.h"
#include "HTGlobal.h"

void vSetPid()
{
    FILE *fp = fopen(DEF_PID_FILE, "w");
    fprintf(fp, "%d", GETPID());
    fflush(fp);
    fclose(fp);
}

int  iGetPid()
{
    char szPid[20] = { 0 };
    FILE *fp = fopen(DEF_PID_FILE, "r");
    fgets(szPid, sizeof(szPid), fp);
    fclose(fp);
    return atoi(szPid);
}

/****************************************************************
** Description : 检查文件/目录是否存在
** param in    : pszName         -- 要检查的文件/目录,FileName / PathName
**             : 
** param out   : None
** return code : 0               -- exist
**             : <0              -- not exist
****************************************************************/
int iDirOrFileExist(const char *pszName)
{
#ifdef _WIN32
    return _access(pszName, 0) ;
#else
    return access(pszName, 0) ;
#endif
}
/****************************************************************
** Description : 创建目录
** param in    : pNmae           -- 要创建的目录名称
**             : 
** param out   : None
** return code : <0              -- failed
****************************************************************/
int iBuildDirent(const char *pName)
{
    int iRet = -1;
    char szCmd[256];
    memset(szCmd, 0x00, sizeof(szCmd));
#ifdef _WIN32
    Unix2WindowPath((char*)pName);
    sprintf(szCmd,"mkdir %s", pName);
    //iRet = _mkdir(pName);
#else
    sprintf(szCmd,"mkdir -p %s", pName);    
#endif
    iRet = system(szCmd);
    return iRet;
}

/****************************************************************
** Description : 获取文件大小
** param in    : pNmae           -- 文件名称
**             : 
** param out   : None
** return code : <0              -- failed
****************************************************************/
int get_file_size(const char *path)  
{  
    unsigned long filesize = -1;      
    struct stat statbuff;  
    if(stat(path, &statbuff) < 0){  
        return filesize;  
    }else{  
        filesize = statbuff.st_size;  
    }  
    return filesize;  
}
/****************************************************************
** Description : 获取文件创建时间
** param in    : pNmae           -- 文件名称
**             :
** param out   : pCreateTime     -- YYYY-MM-DD HH24:MI:SS
** return code : <=0             -- failed
**             : >0              -- file size(byte) 
****************************************************************/
int getFileCreateTime(const char *path, char *pCreateTime)
{
    unsigned long filesize = -1;
    char *p = (char*)path, *s = (char*)path;
    struct stat statbuff;
    if (stat(path, &statbuff) < 0){
        vGetHostTime(pCreateTime);
        return 0;
    }
    //vTranHostTimeFmt(statbuff.st_ctime, pCreateTime);
    while (*p != '_') {
        p++; s++;
    }
    while (*s != '.') s++;
    strncpy(pCreateTime, p + 1, s - p - 1);
    return (int)statbuff.st_size ;
}
/****************************************************************
** Description : 从文件全路径中截取文件父目录、文件名及文件扩展名称
** param in    : pFullPath       -- 路径名称
**             :
** param out   : pFilename       -- 文件名
**             ：pExt            -- 扩展名
** return code : <0              -- failed
****************************************************************/
bool bSplitFilenameByFullPath(char *pFullPath, char *pPrantPath, char *pFilename, char *pExt)
{
    char *p, *s;
    // 文件名格式：sersorID_time.jpg 或 ../img/sersorid_time.jpg
    if (pFullPath && strlen(pFullPath) > 1) {
        p = pFullPath + strlen((const char*)pFullPath);

        while (*p != '\\' && *p != '/'  && p != pFullPath) p--;
        strncpy(pPrantPath, pFullPath, p - pFullPath + 1);  // 父目录名称
        s = p + 1;
        while (*s != '.') s++;
        if (*s != '.') strcpy(pFilename, p + 1);
        else {
            strncpy(pFilename, p + 1, s - p - 1);
            strcpy(pExt, s + 1);
        }
        return true;
    }
    return false;
}

/***********************************************************************
** Description  : 获取主机时间
** param  in    : None
** param out    : pszTime         -- string time(yyyymmddhhmmss)
** return code  : None
***********************************************************************/
void vGetHostTimeOnMillsecond(char *pszTime)
{
#ifdef _WIN32
    SYSTEMTIME  t;
    ::GetLocalTime(&t);
    sprintf(pszTime, "%04d%02d%02d%02d%02d%02d+%04d",
        t.wYear, t.wMonth, t.wDay,
        t.wHour, t.wMinute, t.wSecond, t.wMilliseconds);
#else
    struct timeval tv;
    gettimeofday(&tv, NULL);

    struct tm tms;
    memcpy(&tms, localtime((const time_t *)&tv.tv_sec), sizeof(struct tm));

    sprintf(pszTime, "%04d%02d%02d%02d%02d%02d+%04ld",
        tms.tm_year + 1900, tms.tm_mon + 1, tms.tm_mday,
        tms.tm_hour, tms.tm_min, tms.tm_sec, tv.tv_usec / 1000);
#endif
    return;
}
/***********************************************************************
** Description  : 获取主机时间
** param  in    : None
** param out    : pszTime         -- string time(yyyy-mm-dd hh:mm:ss+xxxx)
** return code  : None
***********************************************************************/
time_t vGetHostTimeFmtOnMillsecond(char *pszTime)
{
#ifdef _WIN32
    SYSTEMTIME  t;
    ::GetLocalTime(&t);
    sprintf(pszTime, "%04d-%02d-%02d %02d:%02d:%02d+%04d",
        t.wYear, t.wMonth, t.wDay,
        t.wHour, t.wMinute, t.wSecond, t.wMilliseconds);
#else
    struct timeval tv;
    gettimeofday(&tv, NULL);

    struct tm tms;
    memcpy(&tms, localtime((const time_t *)&tv.tv_sec), sizeof(struct tm));

    sprintf(pszTime, "%04d-%02d-%02d %02d:%02d:%02d+%04ld",
        tms.tm_year + 1900, tms.tm_mon + 1, tms.tm_mday,
        tms.tm_hour, tms.tm_min, tms.tm_sec, tv.tv_usec / 1000);
#endif

    return time(NULL);
}

/***********************************************************************
** Description  : 获取主机时间
** param  in    : None
** param out    : pszTime         -- string time(yyyymmddhhmmss)
** return code  : None
***********************************************************************/
void vGetHostTime (char *pszTime) 
{
   time_t t;
   struct tm tm;

   t= time( NULL );
   memcpy(&tm, localtime(&t), sizeof(struct tm));
   sprintf(pszTime, "%04d%02d%02d%02d%02d%02d",
       tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
       tm.tm_hour, tm.tm_min, tm.tm_sec);
   return ;
}
/***********************************************************************
** Description  : 将int时间转为已经消失的时间格式串
** param  in    : c               -- 时间差(s)
** param out    : pszTime         -- string time(DD(day) hh:mm:ss)
** return code  : None
***********************************************************************/
void diffTimes(unsigned int c, char *pszTime)
{
    int day =0,hour =0 , min = 0, sec = 0;
    day = c / 86400;
    hour = (c%86400) / 3600;
    min = (c%86400%3600) / 60 ;
    sec = (c%86400%3600) % 60;
    sprintf(pszTime, "%02d(day) %02d:%02d:%02d",day, hour, min, sec);
}
/***********************************************************************
** Description  : 计算与当前时间之差
** param  in    : bcd_t           -- BCD编码(YYMMDDHHMISS)
** param out    : none
** return code  : 差值
***********************************************************************/
int getCurrTimeDiff(unsigned char *bcd_t) 
{
    unsigned char szTime[16] = {0} ;
    memcpy(szTime,"20", 2) ;
    bcd_to_asc(bcd_t, 6, szTime+2);
    
    return int(time(NULL)- strTime2int((char*)szTime));
}
/***********************************************************************
** Description  : 获取主机时间
** param  in    : None
** param out    : pszTime         -- string time(yyyy-mm-dd hh:mm:ss)
** return code  : None
***********************************************************************/
time_t vGetHostTimeFmt (char *pszTime) 
{
   time_t t;
   struct tm tm;

   t= time( NULL );
   memcpy(&tm, localtime((const time_t *)&t), sizeof(struct tm));
   sprintf(pszTime, "%04d-%02d-%02d %02d:%02d:%02d",
       tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
       tm.tm_hour, tm.tm_min, tm.tm_sec);
   return t;
}
/***********************************************************************
** Description  : 获取主机时间
** param  in    : None
** param out    : pszTime         -- string time(yyyy-mm-dd hh:mm:ss)
** return code  : None
***********************************************************************/
time_t vGetHostTimeFmtBeforBay(char *pszTime, int beforbay)
{
    time_t t;
    struct tm tm;

    t = time(NULL) - (beforbay * 24 * 60 * 60);
    memcpy(&tm, localtime((const time_t *)&t), sizeof(struct tm));
    sprintf(pszTime, "%04d-%02d-%02d %02d:%02d:%02d",
        tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
        tm.tm_hour, tm.tm_min, tm.tm_sec);
    return t;
}

/***********************************************************************
** Description  : 获取当天的起始和结束时间
** param  in    : None
** param out    : pszTime         -- string time(yyyy-mm-dd hh:mm:ss)
** return code  : None
***********************************************************************/
time_t vGeOneDayTimeFmt(char *pSTime, char *pETime)
{
    time_t t;
    struct tm tm;

    t = time(NULL);
    memcpy(&tm, localtime((const time_t *)&t), sizeof(struct tm));
    sprintf(pSTime, "%04d-%02d-%02d 00:00:00",
        tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
    sprintf(pETime, "%04d-%02d-%02d 23:59:59",
        tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
    return t;
}

/***********************************************************************
** Description  : 获取主机时间
** param  in    : None
** param out    : pszTime         -- string time(yyyy-mm-dd hh:mm:ss)
** return code  : None
***********************************************************************/
unsigned int uiTime (void) 
{
    time_t t;
    t= time( NULL );
    return (unsigned int)(t & 0xFFFFFFFF);
}

/***********************************************************************
** Description  : 转换time_t的时间
** param  in    : t
** param out    : pszTime         -- string time(yyyy-mm-dd hh:mm:ss)
** return code  : None
***********************************************************************/
void vTranHostTimeFmt (time_t t, char *pszTime) 
{
   struct tm tms;
   memcpy(&tms, localtime((const time_t *)&t), sizeof(struct tm));
   sprintf(pszTime, "%04d-%02d-%02d %02d:%02d:%02d",
       tms.tm_year+1900, tms.tm_mon+1, tms.tm_mday,
       tms.tm_hour, tms.tm_min, tms.tm_sec);
}
/*****************************************************************
** Description: 时间串转整数
** param  in  : pszTime      -- 时间串(yyyy-mm-dd 24hh:mm:ss)
** param out  : None
** return code: uintTime
*****************************************************************/
time_t strTimeFmt2int(char *pszTime)
{
    struct tm stTm;
    time_t t1 = 0;
    char szTmp[20 + 1];

    memset(szTmp, 0x00, sizeof(szTmp));
    memcpy(szTmp, pszTime, 20);
    
    stTm.tm_sec = atoi((char *)(szTmp + 17));
    szTmp[16] = '\0';
    stTm.tm_min = atoi((char *)(szTmp + 14));
    szTmp[13] = '\0';
    stTm.tm_hour = atoi((char *)(szTmp + 11));   /*hour since midnight[0, 23]*/
    szTmp[10] = '\0';
    stTm.tm_mday = atoi((char *)(szTmp + 8));   /* day of the month [1, 31] */
    szTmp[7] = '\0';
    stTm.tm_mon = atoi((char *)(szTmp + 5)) - 1;/*months since January[0,11]*/
    szTmp[4] = '\0';
    stTm.tm_year = atoi((char *)(szTmp)) - 1900; /* years since 1900 */
    t1 = mktime(&stTm);
    return t1;
}
/***********************************************************************
** Description  : 日期时间格式转换
** param  in    : t
** param out    : pInTime         -- string time(yyyymmddhh24mmss)
** param out    : pOutTime        -- string time(yyyy-mm-dd hh24:mm:ss)
** return code  : None
***********************************************************************/
void vFormatTimes(char *pszInTimeStr, char *pszOutFormatTime)
{
    sprintf(pszOutFormatTime, "%.4s-%.02s-%.02s %.02s:%.02s:%.02s",
        pszInTimeStr, pszInTimeStr + 4, pszInTimeStr + 4 + 2,
        pszInTimeStr + 4 + 2 + 2, pszInTimeStr + 4 + 2 + 2 + 2, pszInTimeStr + 4 + 2 + 2 + 2 + 2);
}
/***********************************************************************
** Description  : 获取当前时间点到之前360小时的时间段
** param  in    : t
** param out    : pSTime         -- string time(yyyymmddhh24mmss)
** param out    : pETime         -- string time(yyyymmddhh24mmss)
** return code  : None
***********************************************************************/
void getCurrentBefor360Hour(char *pstime, char *petime)
{
    struct tm tm;

    if(pstime == NULL || petime == NULL) return ;
    time_t  curTime = time(NULL);

    memcpy(&tm, localtime((const time_t *)&curTime), sizeof(struct tm));
    sprintf(petime, "%04d%02d%02d%02d%02d%02d",
        tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
        tm.tm_hour, tm.tm_min, tm.tm_sec);

    curTime = curTime - (360 * 60 * 60);  // 360小时之前的时间
    memcpy(&tm, localtime((const time_t *)&curTime), sizeof(struct tm));
    sprintf(pstime, "%04d%02d%02d%02d%02d%02d",
        tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
        tm.tm_hour, tm.tm_min, tm.tm_sec);
}
/*****************************************************************
** Description: 时间串转整数
** param  in  : pszTime      -- 时间串(yyyymmddhhmmss)
** param out  : None
** return code: uintTime
*****************************************************************/
time_t strTime2int(char *pszTime)
{
    struct tm stTm ;
    time_t t1 = 0;
    char szTmp[14+1];
    
    memset(szTmp, 0x00, sizeof(szTmp)) ;
    memcpy(szTmp, pszTime, 14) ;

    stTm.tm_sec = atoi((char *)(szTmp + 12));
    szTmp[12]='\0';
    stTm.tm_min = atoi((char *)(szTmp + 10));
    szTmp[10]='\0';
    stTm.tm_hour = atoi((char *)(szTmp + 8));   /*hour since midnight[0, 23]*/
    szTmp[8]='\0';
    stTm.tm_mday = atoi((char *)(szTmp + 6));   /* day of the month [1, 31] */
    szTmp[6]='\0';
    stTm.tm_mon  = atoi((char *)(szTmp + 4)) -1;/*months since January[0,11]*/
    szTmp[4]='\0';
    stTm.tm_year = atoi((char *)(szTmp)) - 1900; /* years since 1900 */
    t1 = mktime(&stTm);
    return t1 ;
}
#if 0
// 日月年(dmyy), 年的表示是先将年转换为2位十六进制数
void setPostionDate(unsigned char *pDate, unsigned char *pTime)
{
    unsigned char szDate[5]={0};
    unsigned short usNo = 0;

    // 20130109
    memcpy(szDate, pDate+6, 2);          // 日
    memcpy(szDate+2, pDate+4, 2);        // 月
    asc_to_bcd(szDate, 4, pTime);

    memcpy(szDate, pDate, 4);    
    usNo = htons(atoi((char*)szDate));
    memcpy(pTime+2, &usNo, sizeof(short));  // 年
}
// pDate = HH24MMSS
void setPostionTime(unsigned char *pDate, unsigned char *pTime)
{
    unsigned char szTmp[4] = {0};
    asc_to_bcd(pDate, 6, szTmp);
    memcpy(pTime, szTmp, 3);
}
#else
// 日月年(dmyy), 年的表示是先将年转换为2位十六进制数
void setPostionDate(unsigned char *pDate, unsigned char *pTime)
{
    char szDate[5]={0};
    unsigned short usNo = 0;

    // 20130109
    memcpy(szDate, pDate+6, 2);          // 日
    pTime[0] = (char)atoi(szDate);

    memcpy(szDate, pDate+4, 2);          // 月
    pTime[1] = (char)atoi(szDate);

    memcpy(szDate, pDate, 4);    
    usNo = htons(atoi((char*)szDate));
    memcpy(pTime+2, &usNo, sizeof(short));  // 年
}

// pDate = HH24MMSS
void setPostionTime(unsigned char *pDate, unsigned char *pTime)
{
    char szTmp[4] = {0};
    
    memcpy(szTmp, pDate, 2);          // 时
    pTime[0] = (char)atoi(szTmp);
    
    memcpy(szTmp, pDate+2, 2);        // 分
    pTime[1] = (char)atoi(szTmp);
    
    memcpy(szTmp, pDate+4, 2);        // 秒
    pTime[2] = (char)atoi(szTmp);
}
#endif

void getGnssData(unsigned char * p_date)
{
    time_t t;
    struct tm tm;
    char day,month,year[2];
    short years;

    t= time( NULL );
    memcpy(&tm, localtime(&t), sizeof(struct tm));
    day = (char)tm.tm_mday;
    month = (char)tm.tm_mon+1;
    years = (short)tm.tm_year+1900;
    memcpy(&year,(char*)&years,2);

    memcpy(p_date,&day,1);
	memcpy(p_date+1,&month,1);
	memcpy(p_date+2,year,2); 

	return;
}

void getGnssTime(unsigned char *p_time)
{
    time_t t;
    struct tm tm;
    char hour,minute,second;

    t = time(NULL);
    memcpy(&tm, localtime(&t), sizeof(struct tm));
    hour = (char)tm.tm_hour;
    minute = (char)tm.tm_min;
    second = (char)tm.tm_sec;

    memcpy(p_time,&hour,1);
    memcpy(p_time+1,&minute,1);
    memcpy(p_time+2,&second,1);

    return;
}

/***********************************************************************
** Description  : 获取主机UTC时间
** param  in    : None
** param out    : pszTime         -- string time(yyyy-mm-dd hh:mm:ss)
** return code  : None
***********************************************************************/
void getUTCFmtTime (char *pszTime) 
{
   time_t t;
   struct tm tm;

   t= time( NULL );
   memcpy(&tm, gmtime(&t), sizeof(struct tm));
   sprintf(pszTime, "%04d-%02d-%02d %02d:%02d:%02d",
       tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
       tm.tm_hour, tm.tm_min, tm.tm_sec);
   return ;
}
/***********************************************************************
** Description  : 获取主机UTC时间
** param  in    : None
** param out    : pszTime         -- string time(yyyy-mm-dd hh:mm:ss)
** return code  : None
***********************************************************************/
time_t getUTCLongTime (void) 
{
   time_t t,t1=0;
   struct tm tm={0};

   t= time( NULL );
   memcpy(&tm, gmtime(&t), sizeof(struct tm));
   t1 = mktime(&tm);
   return t1 ;
}
/***********************************************************************
** Description  : 将UTC时间转为格式串
** param  in    : None
** param out    : pszTime         -- string time(yyyy-mm-dd hh:mm:ss)
** return code  : None
***********************************************************************/
void UTC2FmtTime (time_t utc, char *pszTime) 
{
    time_t lutc= utc+(8*60*60);
    struct tm tm={0};

    memcpy(&tm, gmtime(&lutc), sizeof(struct tm));
    sprintf(pszTime, "%04d-%02d-%02d %02d:%02d:%02d",
        tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
        tm.tm_hour, tm.tm_min, tm.tm_sec);
    return ;
}
/***********************************************************************
** Description  : UTC时间转为本地时间
** param  in    : None
** param out    : pszTime         -- string time(yyyy-mm-dd hh:mm:ss)
** return code  : None
***********************************************************************/
void UTC2LocalTime (time_t utc, char *pszTime) 
{
    time_t lutc= utc+(8*60*60);
    struct tm tm = {0};
    memcpy(&tm, localtime(&lutc), sizeof(struct tm));
    sprintf(pszTime, "%04d-%02d-%02d %02d:%02d:%02d",
        tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
        tm.tm_hour, tm.tm_min, tm.tm_sec);
    return ;
}
// 本地时间转UTC时间, pTime: YYMMDDHH24MISS
time_t local2Utc(unsigned char *pTime, int iLen)
{
    unsigned char szTime[20] = {0};
    time_t utc = 0 ,t1 = 0 ;
    struct tm tm = {0};

    bcd_to_asc(pTime, iLen, szTime+2);
    memcpy(szTime, "20", 2);
    utc = strTime2int((char*)szTime);
    t1 = utc ;
    memcpy(&tm, gmtime((const time_t*)&t1), sizeof(struct tm));
    t1 = mktime(&tm) ;
    return  t1 ;
}

// 本地时间转UTC整型时间
time_t local2UtcTime(time_t localTime)
{
    struct tm tm = {0};
    time_t t = localTime ;
    memcpy(&tm, gmtime((const time_t*)&t), sizeof(struct tm));
    t = mktime(&tm);
    return t;
}

// 根据BCD编码时间转报警ID
// param_in: pTime  -- YYMMDDHHMISS,  \x13\x10\12\x09\x14\x11
unsigned int getWarnID(unsigned char *pTime, int iLen, unsigned int id)
{
    unsigned char szTime[20] = {0}, szSub[20] = {0}, szTmp[8]={0};
    time_t utc = 0 ;
    if(pTime == NULL || iLen <= 0) return (unsigned int)utc;
    bcd_to_asc(pTime, iLen, szTime+2);  // xx131012091411
    memcpy(szTime, "20", 2);            // 20131012091411
    memcpy(szTmp, szTime, 4);           // 2013
    sprintf((char*)szSub, "%4d0101000000", atoi((char*)szTmp)-1);
    utc = strTime2int((char*)szTime) - strTime2int((char*)szSub);  // 20131012091411-20121012091411
    utc = (id << 26 )| utc;
    return (utc & 0xFFFFFFFF);
}
/***********************************************************************
** Description  : 获取源串中的第no个域,数字串,eg: 1923.122.3.4
** param  in    : pstr            -- source string end=0x00
**              : node            -- split char
**              : no              -- index filed
** param out    : None
** return code  : index on filed val
***********************************************************************/
int   iSplitNumberFiled(char *pstr, char node, int no)
{
    // 192.168.3.13
    int i=0,j=0;
    char *p = NULL, *s = pstr;
    char szTmp[128];
    for(i =0, j=0; i<(int)strlen((const char*)pstr) && j < no; i++) {
        if(pstr[i] == node) {
            s = pstr+i+1;
            j++;
            continue;
        }
    }
    if(s==NULL) return 0;
    if(j == no ) {
        while(pstr[i] != node && i<(int)strlen((const char*)pstr)) i++;
        p = pstr+i;
        strncpy(szTmp, s, p-s);
        szTmp[p-s] = 0x00;
        return atoi((const char*)szTmp);
    }
    return 0;
}
// 去除版本号首部字符,保留数字版本号
// eg: Ver1.2.34  ==> 1.2.34
int  iTrimVersionHeadChar(char *strver)
{
    int i = 0 ;
    if(strver == NULL) return 0 ;
    if((int)strlen(strver) <= 0) return 0 ;
    while(strver[i] != '.' && i < (int)strlen(strver)) {
        if(!(strver[i] >= 0x30 && strver[i] <= 0x39)) 
            i++;
        else break;
    }
    if(i >= (int)strlen(strver)) return 0 ;
    strcpy(strver, strver+i);
    return strlen(strver);
}
/***********************************************************************
** Description  : 获取源串中的第no个域, 字符串
** param  in    : pstr            -- source string end=0x00
**              : node            -- split char
**              : no              -- index filed
** param out    : pFiled          -- index filed string
** return code  : index on filed val length
** call eg: len = iSplitStringFiled("qwwa1.ddee.fwe.3.4.322.fffgsd", '.', 0, retval);
***********************************************************************/
int   iSplitStringFiled(char *pstr, char node, char no, char *pFiled)
{
    char *p = NULL, *s = pstr;
    int i=0,j=0;
    for(i =0, j=0; i<(int)strlen((const char*)pstr) && j < no; i++) {
        if(pstr[i] == node) {
            s = pstr+i+1;
            j++;
            continue;
        }
    }
    if(s==NULL) return 0;
    if(j == no ) {
        while(pstr[i] != node && i<(int)strlen((const char*)pstr)) i++;
        p = pstr+i;
        strncpy(pFiled, s, p-s);
        pFiled[p-s] = 0x00;
        return p-s;
    }
    return 0;
}

/***********************************************************************
** Description  : getDateFromTime 从时间字符串获取Date信息
** param  in    : p_time           -- 时间字符串
***********************************************************************/
void getDateFromTime(char* p_time,char* p_date)
{
    short m_year;
    char m_month,m_day;
    char year[5]  = {0};
	char month[3] = {0};
	char day[3]   = {0};
	
	memcpy(year,p_time,4);
    m_year = atoi(year);
	m_year = htons(m_year);

	memcpy(month,p_time+5,2);
	m_month = atoi(month);
	memcpy(day,p_time+8,2);
	m_day = atoi(day);

	memcpy(p_date,&m_day,1);
	memcpy(p_date+1,&m_month,1);
	memcpy(p_date+2,&m_year,2);
}

/**************************************************************
** Description: trim string rigth space
** param in   :
**            : *str        -- sources string
** param out  :
**            : *str        -- trim string
** return code:
**            : trim string current length
**************************************************************/
int RigthTrim(unsigned char *str)
{
    if ( strlen((char *)str) == 0 ) return 0;
    char *p = (char*)str + strlen((char*)str) - 1;
    while ( p >= (char*)str && *p == ' ' ) p--;
    *( ++p ) = '\0';
    return strlen( (char*)str );
}

 /**************************************************************
** Description: trim string left space
** param in   :
**            : *str         -- sources string(source)
** param out  :
**            : *str         -- trim string(dest)
** return code:
**            :trim string current length
**************************************************************/
int LeftTrim(unsigned char *str)
{
    char *p = (char*)str;
    while ( *p == ' ' ) p++;
    strcpy( (char*)str, p );
    return strlen( (char*)str );
}

/**************************************************************
** Description: trim char string left and rigth space
** param in   :
**            : *str             -- sources string
** param out  :
**            : *str             -- dest string
** return code: None
**************************************************************/
void LRTrim(unsigned char *str)
{
    LeftTrim(str) ;
    RigthTrim(str) ;
}
/**************************************************************
** Description: trim char string middle space,仅保留一个空格
** param in   :
**            : *str             -- sources string
** param out  :
**            : *str             -- dest string
** return code: None
**************************************************************/
void MiddleTrim(unsigned char *str)
{
    char *front = (char*)str;
    char *last = (char*)str;
    if(str == NULL) return;
    while((*front) == ' ') {++front;} 
    while((*front) != '\0') {
        if((*front) == ' ' ) {
            *last = ' ';
            while((*front) == ' ') ++front;
        }
        else {
            *last = *front; 
            ++front;
        }
        ++last;
    }
    *last = '\0';
}
/**************************************************************
** Description: trim char string middle space,仅保留一个空格
** param in   :
**            : *str             -- sources string
** param out  :
**            : *str             -- dest string
** return code: None
**************************************************************/
void strMiddleTrim(unsigned char *str)
{
    char *front = (char*)str;
    char *last = (char*)str;
    if (str == NULL) return;
    while ((*front) == '-') { ++front; }
    while ((*front) != '\0') {
        if ((*front) == '-') {
            ++front;
            continue;
        }
        else {
            *last = *front;
            ++front;
        }
        ++last;
    }
    *last = '\0';
}
/**************************************************************
** Description: check string all char is digit(number '0'--'9')
** param in   : 是否为纯数字的字符串
**            : *str        -- sources string
** param out  :
**            : *str        -- trim string
** return code:
**            : true        all char is digit
**            : false       not digit 
**************************************************************/
bool isStringDigit(char *pstr)
{
    int i = 0;
    while (i < (int)strlen(pstr)) {
        if(!((pstr[i] & 0xff) >= 0x30 && (pstr[i] & 0xff) <= 0x39)) return false;
        else i++;
    }
    return true;
}

void getTimeFromTime(char* p_time,char* p_times)
{
    char m_hour,m_minute,m_second;
    char hour[3]   = {0};
	char minute[3] = {0};
	char second[3] = {0};

    memcpy(hour,p_time+11,2);
    m_hour = atoi(hour);

    memcpy(minute,p_time+14,2);
    m_minute = atoi(minute);

    memcpy(second,p_time+17,2);
    m_second = atoi(second);

    memcpy(p_times,&m_hour,1);
    memcpy(p_times+1,&m_minute,1);
    memcpy(p_times+2,&m_second,1);
}

/*************************************************************************
Function     : two bytes change to one bytes
Param in     :
   pusFrom   : source strings
   uiFromLen : bytes of source strings
Param out    :
   pusTo     : object strings.
Return Code  : none
*************************************************************************/
void asc_to_bcd(unsigned char *pusFrom, unsigned int uiFromLen, unsigned char *pusTo)
{
    unsigned char ucTmp;
    unsigned int i;

    for(i=0; i<uiFromLen; i+=2) {
        ucTmp= pusFrom[i];
        if (ucTmp==0x00)   ucTmp= 0x00;
        else if (ucTmp<'A') ucTmp= ucTmp - '0';
        else ucTmp= tolower(ucTmp) - 'a' + 0x0a;

        ucTmp<<= 4;
        pusTo[i/2]= ucTmp;

        ucTmp= pusFrom[i+1];
        if(ucTmp == 0x00)   ucTmp= 0x00;
        else if (ucTmp<'A') ucTmp= ucTmp - '0';
        else  ucTmp= tolower((int)ucTmp) - 'a' + 0x0a;

        pusTo[i/2]= pusTo[i/2] + ucTmp;
    }
    pusTo[i/2] = 0x00;
}

/*************************************************************************
Function     : one byte change to two bytes
Param in     :
   pusFrom   : source strings
   uiFromLen : bytes of source strings
Param out    :
   pusTo     : object strings.
Return Code  : none
*************************************************************************/
void bcd_to_asc(unsigned char *pusFrom, unsigned int uiFromLen,unsigned char *pusTo)
{
   static unsigned char usHexToChar[16+1]= "0123456789ABCDEF";
   unsigned int i;

   for(i=0; i<uiFromLen; i++) {
      pusTo[2*i]= usHexToChar[(pusFrom[i] >> 4)];
      pusTo[2*i+1]= usHexToChar[(pusFrom[i] & 0x0F)];
   }
   pusTo[2*uiFromLen] = 0x00;
   return;
}
/*************************************************************************
Function     : by host byte order int change to network byte order,size(int)=4
Param in     :
   pusFrom   : source host unsigend int
Param out    : none
Return Code  : network byte order
*************************************************************************/
unsigned int htoni(unsigned int us)
{
    unsigned int i;
    i=((us&0xffff)<<24)|(((us&0xffff)<<8)&0x00ff0000)|
        ((us>>8)&0x0000ff00)|((us>>24)&0xffff);
    return i;
}
/*************************************************************************
Function     : by network byte order int change to host byte order,size(int)=4
Param in     :
   pusFrom   : source network unsigend int
Param out    : none
Return Code  : host byte order
*************************************************************************/
unsigned int ntohi(unsigned int us)
{
    unsigned int i;
    i=((us&0xffff)<<24)|(((us&0xffff)<<8)&0x00ff0000)|
        ((us>>8)&0x0000ff00)|((us>>24)&0xffff);
    return i;
}
/*************************************************************************
Function     : by host byte order int64 change to network byte order,size(int64)=8
Param in     :
   pusFrom   : source host unsigend int64
Param out    : none
Return Code  : network byte order
*************************************************************************/
#ifdef htonll
utint64 htonll(utint64  u64)
{
    unsigned int hi = (unsigned int)( u64 >> 32);
    unsigned int lo = (unsigned int)(u64  & 0xFFFFFFFF);
    utint64 fhi = htoni(hi);
    utint64 flo = htoni(lo);
    flo <<= 32;
    return (utint64)(flo | fhi);
}
#endif
/*************************************************************************
Function     : by network byte order int64 change to host byte order,size(int64)=8
Param in     :
   pusFrom   : source network unsigend int64
Param out    : none
Return Code  : host byte order
*************************************************************************/
#ifdef ntohll
utint64 ntohll(utint64  u64)
{
    unsigned int hi = (unsigned int)( u64 >> 32);
    unsigned int lo = (unsigned int)(u64  & 0xFFFFFFFF);
    utint64 fhi = ntohi(hi);
    utint64 flo = ntohi(lo);
    flo <<= 32;
    return (utint64)(flo | fhi);
}
#endif
/*************************************************************************
Function     : one byte change to two bytes
Param in     :
   pusFrom   : source strings
   uiFromLen : bytes of source strings
Param out    :
   pusTo     : object strings.
Return Code  : none
Note :        本函数入参为网络字节序列
*************************************************************************/
unsigned int int64To32(utint64  u64)
{
    unsigned int hi = (unsigned int)(( u64 >> 32) & 0xFFFFFFFF