XML使用XPATH

编译命令

cc -I /home/eas/src/libxml/libxml2-2.6.30/include/ -I /home/eas/src/libiconv/libiconv-1.13.1/include/ -L/home/eas/src/libxml/libxml2-2.6.30/.libs -L/home/eas/src/libiconv/libiconv-1.13.1/lib/.libs/ -lxml2 -liconv -lz -lpthread -lm -o xpath xpath.c

#include    <stdio.h>
#include    <stdlib.h>
#include    <string.h>
#include    <math.h>
#include    <ctype.h>
#include    <sys/stat.h>
#include    <unistd.h>
#include    <stdbool.h>
#include    <sys/timeb.h>
#include    <time.h>

#include    <libxml/parser.h>                /* LIBXML2 Header File */
#include    <libxml/tree.h>                    /* LIBXML2 Header File */
#include     <libxml/xmlmemory.h>            /* LIBXML2 Header File */
#include    <libxml/xpath.h>                /* LIBXML2 Header File */
#include    <iconv.h>                        /* LIBXML2 Header File */

#define FMLFLD_NOTARRAY 0 /* 非数组（用于下标参数） */
#define FMLFLD_OPTIONAL 0 /* 可选域 */
#define FMLFLD_REQUIRED 1 /* 必需域 */
#define    SYM_FML_FS    0x40    /* 域分隔符0x1E*/
#define    SYM_FML_NV    ':'     /* 名值分隔符*/
#define    SYM_FML_AN    '#'     /* 数组下标起始符*/
#define RC_SUCC 0
#define RC_NFND -1
#define RC_NSPC -2

#define SZ_DATA_BUS (32*1024)            /* 数据总线宽度 */
typedef char    T_DATABUS[SZ_DATA_BUS];    /* 数据总线 */

void FmlDataClear(char *    cFmlData);
char *FmlFieldSeek(const char *cFmlData, const char *cFieldName,int    iIndex);
int    FmlFieldPut(char *cFmlData,int iBufSize,char *cFieldName,int iIndex,char *cFieldValue);
int FmlFieldGet(const char *cFmlData,const char *cFieldName,int    iIndex,    char *cFieldValue,int iValueSize);
int    FmlFieldNum(const char *cFmlData, const char *cFieldName, int *iNum);

int CodeConvert(char* from_charset, char* to_charset, char* inbuf,size_t inlen, char* outbuf, size_t outlen);
char* u2g(char *inbuf);
char* g2u(char *inbuf);
char * StrTrim(char * pstr);
int    GetDateTime(char * cDate, char * cTime);
int JugeFileExist(char *lFileName);

int XmlSetPropByXpath(const xmlDocPtr doc, const xmlChar *xpath, const int number, const xmlChar *name, const xmlChar *value, const char * encoding);
int XmlNodeSetContentByXpath(const xmlDocPtr doc, const xmlChar *xpath, const int number, const xmlChar *content, const char * encoding);
xmlNodePtr GetNodeByXpath(const xmlDocPtr doc, const xmlChar *xpath, const int number);

int main(int argc, char **argv)
{
    if(argc < 2)
    {
        printf("参数个数不对，应为2个！\n");
        return -1;
    }

    char filename[1024];
    memset(filename, 0x00, sizeof(filename));
    strcpy(filename, argv[1]);
    StrTrim(filename);

    char sParsefile[1024];
    memset(sParsefile, 0x00, sizeof(sParsefile));
    sprintf(sParsefile, "%s%s%s", getenv("HOME"), "/src/xml_fun/", filename);
    StrTrim(sParsefile);

    printf("*************************************************************\n");
    int iRet = JugeFileExist(sParsefile);
    if(iRet != RC_SUCC)
    {
        printf("文件[%s]不存在\n", sParsefile);
        return -1;
    }
    FILE *    fp = NULL;
    if((fp = fopen(sParsefile, "r")) == NULL)
    {
        printf("打开dmz文件[%s]失败\n", sParsefile);
        return -1;
    }
    char sXmlBuf[1024*1000*8];    /*从报文文件中读取的内容*/
    char sChildBuf[10240];        /*存放一次读取的文件内容*/
    memset(sXmlBuf, 0x00, sizeof(sXmlBuf));
    memset(sChildBuf, 0x00, sizeof(sChildBuf));
    while(NULL != fgets(sChildBuf, sizeof(sChildBuf), fp))
    {
        strcat(sXmlBuf, sChildBuf);
        memset(sChildBuf, 0, sizeof(sChildBuf));
    }
    int iXmlByteNum = strlen(sXmlBuf);
    printf("读取文件[%s]，文件长度=[%d]\n", sParsefile, iXmlByteNum);
    printf("文件数据如下:\n[%s]", sXmlBuf);
    printf("*************************************************************\n");


    xmlDocPtr doc = xmlReadFile(sParsefile,"GBK",XML_PARSE_NOBLANKS);
    if (NULL == doc)
    {
        printf("未指定文件名\n");
        return -1;
    }

    xmlNodePtr root_node = xmlDocGetRootElement(doc);
    /*检查确认当前文档中包含内容*/
    if (NULL == root_node)
    {
        printf("empty document\n");
        xmlFreeDoc(doc);
        return -1;
    }


    #ifdef __DEBUG__

    printf("*************************************************************\n");
    char xPath[128];
    memset(xPath, 0, sizeof(xPath));
    strcpy(xPath,"/ap/head/tr_code");
    xmlNodePtr cur_node1;
    cur_node1 = GetNodeByXpath(doc,BAD_CAST xPath,0);
    char * nodename1;
    char * nodevalue1;
    nodename1 = u2g((char*)cur_node1->name);
    xmlChar * szAttr1 = xmlNodeGetContent(cur_node1);
    nodevalue1 = u2g((char*)szAttr1);
    printf("nodename1 = [%s]\n", nodename1);
    printf("nodevalue1 = [%s]\n", nodevalue1);

    printf("1**************************\n");
    memset(xPath, 0, sizeof(xPath));
    strcpy(xPath,"/ap/head/tr_code");
    char content[128];
    memset(content, 0, sizeof(content));
    strcpy(content, "不知道是什么交易码");
    XmlNodeSetContentByXpath(doc, xPath, 0, content, "GBK");
    cur_node1 = GetNodeByXpath(doc, BAD_CAST xPath, 0);
    nodename1 = u2g((char*)cur_node1->name);
    szAttr1 = xmlNodeGetContent(cur_node1);
    nodevalue1 = u2g((char*)szAttr1);
    printf("nodename1 = [%s]\n", nodename1);
    printf("nodevalue1 = [%s]\n", nodevalue1);

    printf("1**************************\n");
    memset(xPath, 0, sizeof(xPath));
    strcpy(xPath,"/ap/head/sign");
    XmlSetPropByXpath(doc, BAD_CAST xPath, 0, "size","size是测试用的属性", "gb2312");

        printf("******************************************\n");
    //存储xml文件
    char    date[32];
    char    time[32];
    char    filename1[128];
    memset(date,0,sizeof(date));
    memset(time,0,sizeof(time));
    memset(filename1,0,sizeof(filename1));
    printf("111******************************************\n");
    GetDateTime(date,time);
    StrTrim(date);
    StrTrim(time);
    printf("222******************************************\n");
    sprintf(filename1, "Created_%s_%s.xml", date, time);
    printf("333******************************************\n");
    /*iRet = xmlSaveFormatFileEnc(filename, doc, "GBK", 1);*/
    /*iRet = xmlSaveFile(filename,doc);*/
    /*iRet = xmlSaveFormatFile(filename, doc, 1);*/
    /*xmlOutputBufferPtr buf;
    iRet = xmlSaveFileTo(buf, doc, "GBK"); */
    /*iRet = xmlSaveFileEnc(filename, doc, "GBK"); */
    iRet = xmlSaveFormatFileEnc(filename1, doc, "GB2312", 1);
    if (iRet != -1)
    {
       printf("CreatedXml.xml文件已创建成功\n");
    }

    /*
    cur_node1 = GetNodeByXpath(doc,BAD_CAST xPath,0);
    nodename1 = u2g((char*)cur_node1->name);
    szAttr1 = xmlNodeGetContent(cur_node1);
    nodevalue1 = u2g((char*)szAttr1);
    printf("nodename1 = [%s]\n", nodename1);
    printf("nodevalue1 = [%s]\n", nodevalue1);
    */
    printf("1**************************\n");

    #endif

    printf("*************************************************************\n");
    /*xmlXPathContextPtr:XPATH上下文指针*/
    /*xmlXPathNewContext函数功能：创建一个XPath上下文指针
    函数原型：xmlXPathContextPtr xmlXPathNewContext(xmlDocPtr doc);*/
    xmlXPathContextPtr context = xmlXPathNewContext(doc);
    if (context == NULL)
    {
       printf("context is NULL\n");
       return -1;
    }
    /*xmlXPathContextPtr里面的节点指针成员是什么？*/

    /*xmlXPathObjectPtr:XPATH对象指针，用来存储查询结果
    xmlXPathEvalPredicate函数功能*/
    /*xmlXPathEvalExpression函数功能：查询XPath表达式，得到一个查询结果
    函数原型: xmlXPathObjectPtr xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt);
              xmlXPathObjectPtr xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx);
             int xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res);*/
    char xPath2[1024];
    memset(xPath2, 0, sizeof(xPath2));
    strcpy(xPath2,"/request/balance_query/row");
    xmlXPathObjectPtr resultObject = xmlXPathEvalExpression(BAD_CAST xPath2, context);
    if (resultObject == NULL)
    {
       printf("xmlXPathEvalExpression return NULL\n");
       return -1;
    }

    xmlXPathObjectPtr resultObject2 = xmlXPathObjectCopy(resultObject);

    /*xmlXPathFreeContext函数功能：释放上下文指针*/
    xmlXPathFreeContext(context);

    /*result->nodesetval:得到节点集合指针，其中包含了所有符合Xpath查询结果的节点*/
    if (xmlXPathNodeSetIsEmpty(resultObject2->nodesetval) != 0) //检查查询结果是否为空
    {
       xmlXPathFreeObject(resultObject2);
       printf("节点集合是空的！\n");
       return -1;
    }
    /*获取节点集合指针*/
    int boolVal = resultObject2->boolval;
    printf("boolVal = [%d]\n", boolVal);
    double floatVal = resultObject2->floatval;
    printf("floatVal = [%f]\n", floatVal);
    /*
    char stringVal[1024];
    memset(stringVal, 0, sizeof(stringVal));
    strcpy(stringVal, (char*)resultObject->stringval);
    printf("stringVal = [%s]\n", stringVal);
    */
    int indexVal = resultObject2->index;
    printf("indexVal = [%d]\n", indexVal);
    xmlNodeSetPtr node_set = resultObject2->nodesetval;
    int maxvalue = node_set->nodeMax; /*集合最大容量*/
    printf("maxvalue=[%d]\n", maxvalue);
    int nodeNr = node_set->nodeNr; /*查询结果的数量*/
    printf("nodeNr=[%d]\n", nodeNr);

    xmlNodePtr new_node1 = xmlNewNode(NULL, BAD_CAST "row");
    xmlNodePtr new_node2 = xmlNewNode(NULL, BAD_CAST "row");
    int cmpFlag = -100;
    cmpFlag = xmlXPathCmpNodes(new_node1, new_node2); /*还没有加入任何doc文档，所以是-2*/
    printf("111***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(new_node1, new_node1); /*完全同名的节点*/
    printf("222***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(new_node1, node_set->nodeTab[0]);
    printf("333***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(node_set->nodeTab[0], node_set->nodeTab[0]);
    printf("444***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(node_set->nodeTab[0], node_set->nodeTab[1]);
    printf("4.1***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(node_set->nodeTab[1], node_set->nodeTab[0]);
    printf("4.5***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(node_set->nodeTab[1], root_node->children->children);
    printf("555***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(node_set->nodeTab[0], root_node->children->children);
    printf("5.5***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(node_set->nodeTab[0], node_set->nodeTab[2]);
    printf("666***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(node_set->nodeTab[2], node_set->nodeTab[0]);
    printf("6.5***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(node_set->nodeTab[0], node_set->nodeTab[4]);
    printf("777***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(node_set->nodeTab[0], node_set->nodeTab[9]);
    printf("888***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(node_set->nodeTab[0], node_set->nodeTab[90]);
    printf("999***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(node_set->nodeTab[90], node_set->nodeTab[0]);
    printf("9.5***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(node_set->nodeTab[0], root_node->children->next);
    printf("10***********cmpFlag = [%d]***********\n", cmpFlag);
    cmpFlag = xmlXPathCmpNodes(root_node->children->next, node_set->nodeTab[0]);
    printf("10.5***********cmpFlag = [%d]***********\n", cmpFlag);

    /*获取节点集合中一个节点的指针*/
    T_DATABUS tDataBus;
    FmlDataClear(tDataBus);
    xmlNodePtr cur_node;
    char * nodename;

    xmlChar * szAttr;
    char * eleName;
    char * eleValue;
    xmlAttrPtr attrPtr;
    int i = -1;
    for(i=0; i<nodeNr; i++)
    {
        cur_node = node_set->nodeTab[i];
        nodename = u2g((char*)cur_node->name);
        /*printf("nodename = [%s]\n", nodename);*/

     if( xmlStrcmp(cur_node->name,BAD_CAST "row") == 0 )
        {
            for( attrPtr =cur_node->properties ; attrPtr != NULL ; attrPtr = attrPtr->next )
            {
                szAttr = xmlGetProp(cur_node,attrPtr->name);
                eleName = u2g((char*)attrPtr->name);
                eleValue = u2g((char*)szAttr);
                if(eleValue != NULL)
                    FmlFieldPut(tDataBus, SZ_DATA_BUS, eleName, i, eleValue);
                else
                    FmlFieldPut(tDataBus, SZ_DATA_BUS, eleName, i, "");
                xmlFree(szAttr);
                if( eleName != NULL )
                {
                    free(eleName);
                    eleName = NULL;
                }
                if( eleValue != NULL )
                {
                    free(eleValue);
                    eleValue = NULL;
                }
            }
        }
        else
        {
            printf("root node != row\n");
        }
    }
    /*
    typedef void (*xmlXPathEvalFunc)(xmlXPathParserContextPtr ctxt, int nargs);
    typedef struct _xmlXPathFunct xmlXPathFunct;
    typedef xmlXPathFunct *xmlXPathFuncPtr;
    struct _xmlXPathFunct {
        const xmlChar *name; the function name
        xmlXPathEvalFunc func; the evaluation function
    };
    xmlXPathObjectPtr xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx);
    */


    /*xmlXPathFreeObject函数功能：释放Xpath对象指针*/
    xmlXPathFreeObject(resultObject);
    xmlFreeDoc(doc);
    printf("总线=[%s]\n", tDataBus);

    printf("*************************************************************\n");
    return 0;
}


/*
void xmlXPathFreeNodeSet(xmlNodeSetPtr obj);
xmlXPathObjectPtr xmlXPathObjectCopy(xmlXPathObjectPtr val);
void xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj);

xmlNodeSetPtr xmlXPathNodeSetCreate(xmlNodePtr val);
int xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2);*/


/*************************************************************
 * 函 数 名：XmlSetPropByXpath()
 * 功能描述：将val_str设置到XML文档的xpath节点中
 * 输入参数：doc - XML文档指针
 *           encode - 0:utf8 1:gbk
 *           xpath - XML文档路径，如"/root/abc"
 *           val_str - UTF-8编码的值
 *           number - 如果该XML文档中有多个xpath,给第几个xpath设置,0表示第一个节点
 * 输出参数：无
 * 返    回：0 - 成功 ；-1 - 失败
 * 说    明：如果encode为0不需要转码,如果encode为1,说明是中文GBK编码,需要转换成UTF8
 ************************************************************/
int XmlSetPropByXpath(const xmlDocPtr doc, const xmlChar *xpath, const int number, const xmlChar *name, const xmlChar *value, const char * encoding)
{
    int encodingflag = 1;
    if((strncasecmp(encoding, "GBK", strlen("GBK")) == 0)||(strncasecmp(encoding, "GB2312", strlen("GB2312")) == 0)) /*需要转换为utf-8*/
    {
        encodingflag = 1;
    }
    else
    {
        encodingflag = 0;
    }

    xmlXPathContextPtr context = NULL;
    xmlXPathObjectPtr resultObject = NULL;

    context = xmlXPathNewContext(doc);
    resultObject = xmlXPathEval(xpath, context);
    /*number介于0~cur->nodesetval->nodeNr-1之间*/
    int resultNum = resultObject->nodesetval->nodeNr;
    if(resultNum<1 || number>=resultNum || number < 0)
    {
        xmlXPathFreeObject(resultObject);
        xmlXPathFreeContext(context);
        printf("指定xpath的节点不存在！\n");
        return -1;
    }
    xmlNodePtr node = NULL;
    node = resultObject->nodesetval->nodeTab[number];
    if(node == NULL)
    {
        xmlXPathFreeObject(resultObject);
        xmlXPathFreeContext(context);
        printf("指定xpath的节点不存在！\n");
        return -1;
    }
    xmlChar *AttrName = NULL;
    xmlChar *AttrValue = NULL;
    if((name != NULL)&&(value != NULL)) /*均非空*/
    {
        if(encodingflag == 1) /*需要转换为国标码*/
        {
            AttrName = (xmlChar *)g2u((char *)name);
            AttrValue = (xmlChar *)g2u((char *)value);
            if(AttrValue != NULL)
                xmlSetProp(node,AttrName,AttrValue);
        }
        else /*其他编码*/
        {
            xmlSetProp(node,name,value);
        }
    }
    else if((name != NULL)&&(value == NULL)) /*值为空*/
    {
        if(encodingflag == 1) /*需要转换为国标码*/
        {
            AttrName = (xmlChar *)g2u((char *)name);
            xmlSetProp(node, AttrName, "");
        }
        else /*其他编码*/
        {
            xmlSetProp(node, name, "");
        }
    }

    xmlXPathFreeObject(resultObject);
    xmlXPathFreeContext(context);
    if(AttrName != NULL)
    {
        xmlFree(AttrName);
        AttrName = NULL;
    }
    if(AttrValue != NULL)
    {
        xmlFree(AttrValue);
        AttrValue = NULL;
    }
    return 0;
}


/*************************************************************
 * 函 数 名：XmlNodeSetContentByXpath()
 * 功能描述：将content设置到XML文档的xpath节点中
 * 输入参数：doc - XML文档指针
 *           encode - val_str所采用的编码方式
 *           xpath - XML文档路径，如"/root/abc"
 *           val_str - UTF-8编码的值
 *           number - 如果该XML文档中有多个xpath,给第几个xpath设置,0表示第一个节点
 * 输出参数：无
 * 返    回：0 - 成功 ；-1 - 失败
 * 说    明：如果encode为0不需要转码,如果encode为1,说明是中文GBK编码,需要转换成UTF8
 ************************************************************/
int XmlNodeSetContentByXpath(const xmlDocPtr doc, const xmlChar *xpath, const int number, const xmlChar *content, const char * encoding)
{
    int encodingflag = -1;
    if((strncasecmp(encoding, "GBK", strlen("GBK")) == 0)||(strncasecmp(encoding, "GB2312", strlen("GB2312")) == 0)) /*国标码需要转换为utf-8*/
    {
        encodingflag = 1;
    }
    else
    {
        encodingflag = 0;
    }

    xmlXPathContextPtr context = NULL;
    xmlXPathObjectPtr resultObject = NULL;

    context = xmlXPathNewContext(doc);
    resultObject = xmlXPathEval(xpath, context);
    xmlNodeSetPtr nodesetVal = resultObject->nodesetval; /*节点集合指针*/
    /*number介于0~cur->nodesetval->nodeNr-1之间*/
    int resultNum = nodesetVal->nodeNr;
    if(resultNum<1 || number>=resultNum || number < 0)
    {
        xmlXPathFreeObject(resultObject);
        xmlXPathFreeContext(context);
        printf("指定xpath的节点不存在！\n");
        return -1;
    }
    xmlNodePtr node = NULL;
    /*node = (nodesetVal->nodeTab)[number];*/
    node = *((nodesetVal->nodeTab)+number);
    if(node == NULL)
    {
        xmlXPathFreeObject(resultObject);
        xmlXPathFreeContext(context);
        printf("指定xpath的节点不存在！\n");
        return -1;
    }
    xmlChar *out = NULL;
    if(content != NULL) /*空值*/
    {
        if(encodingflag == 1) /*需要转换为utf-8*/
        {
            out = (xmlChar *)g2u((char *)content);
            if(out != NULL)
                xmlNodeSetContent(node,out);
        }
        else /*其他编码*/
        {
            xmlNodeSetContent(node,content);
        }
    }
    else
    {
        xmlNodeSetContent(node,"");
    }

    xmlXPathFreeObject(resultObject);
    xmlXPathFreeContext(context);
    if(out != NULL)
    {
        xmlFree(out);
        out = NULL;
    }
    return 0;
}


/*************************************************************
 * 函 数 名：GetNodeByXpath()
 * 功能描述: 根据xpath查询指定节点
 * 输入参数：doc        - 文档
 *              xpath        - 节点路径"/request/balance/row"
 *              number    - 序号"/request/balance/row...row...row"
 * 输出参数：
 * 返    回：xmlNode - 成功 ；NULL - 失败
 * 说    明：按序号查找节点
 ************************************************************/
xmlNodePtr GetNodeByXpath(const xmlDocPtr doc, const xmlChar *xpath, const int number)
{
    xmlXPathContextPtr context = NULL;
    xmlXPathObjectPtr resultObject = NULL;

    context = xmlXPathNewContext(doc);
    resultObject = xmlXPathEval(xpath,context);
    /*number介于0~cur->nodesetval->nodeNr-1之间*/
    int resultNum = resultObject->nodesetval->nodeNr;
    if(resultNum<1 || number>=resultNum || number < 0)
    {
        xmlXPathFreeObject(resultObject);
        xmlXPathFreeContext(context);
        printf("指定xpath的节点不存在！\n");
        return (NULL);
    }
    xmlNodePtr node;
    node = resultObject->nodesetval->nodeTab[number];

    xmlXPathFreeObject(resultObject);
    xmlXPathFreeContext(context);

    return (node);
}


/***********************************************************
* 函 数 名：GetDateTime()
* 功能描述: 分别获取系统日期时间
* 输入参数：
*            cDate-日期接收缓冲区；
*            cTime-日期接收缓冲区；
* 输出参数：cDate
* 返    回：0 成功
* 流程描述：
* 说明：    返回日期格式：YYYYMMDD
* 修改记录:
* [修改人] [日期] - [描述]
***********************************************************/
int    GetDateTime(char * cDate, char * cTime)
{
    struct tm *    cur;
    time_t    timep;

    struct timeb time_msec;
    unsigned short msec;

    time(&timep);
    cur = localtime(&timep);

    ftime(&time_msec);
    msec=time_msec.millitm;

    sprintf(cDate,"%04d%02d%02d",cur->tm_year+1900,cur->tm_mon+1,cur->tm_mday);
    cDate[8]=0;
    sprintf(cTime,"%02d%02d%02d%03d",cur->tm_hour,cur->tm_min,cur->tm_sec,msec);
    cTime[9]=0;

    return 0;
}


int CodeConvert(char* from_charset, char* to_charset, char* inbuf,size_t inlen, char* outbuf, size_t outlen)
{
    iconv_t cd;
    char** pin = &inbuf;
    char** pout = &outbuf;
    cd = iconv_open(to_charset,from_charset);
    if(cd == (iconv_t)-1)
        return -1;
    memset(outbuf,0,outlen);
    if(iconv(cd,(char**)pin,(size_t *)&inlen,(char**)pout,(size_t*)&outlen) == -1)
        return -1;
    iconv_close(cd);
    return 0;
}

/*************************************************************
 * 函 数 名：u2g()
 * 功能描述: UTF-8码转成GBK码
 * 输入参数：inbuf    - 转入字符
 * 输出参数：
 * 返    回：szOut - 成功; NULL - 失败
 * 说    明：成功则返回一个动态分配的char*变量，需要在使用
 *              完毕后手动free，失败返回NULL，使用有风险，调用需谨慎
 ************************************************************/
char* u2g(char *inbuf)
{
    size_t nOutLen = 0;
    char* szOut = NULL;
    if(!strlen(inbuf))
        return NULL;
    nOutLen = 2 * strlen(inbuf) - 1;
    szOut = (char*)malloc(nOutLen);
    if (-1 == CodeConvert("UTF-8","GBK",inbuf,strlen(inbuf),szOut,nOutLen))
    {
        free(szOut);
        szOut = NULL;
    }
    return szOut;
}

/*************************************************************
 * 函 数 名：g2u()
 * 功能描述: GBK码转成UTF-8码
 * 输入参数：inbuf    - 转入字符
 * 输出参数：
 * 返    回：szOut - 成功; NULL - 失败
 * 说    明：成功则返回一个动态分配的char*变量，需要在使用
 *              完毕后手动free，失败返回NULL，使用有风险，调用需谨慎
 ************************************************************/
char* g2u(char *inbuf)
{
    size_t nOutLen = 0;
    char* szOut = NULL;
    if(!strlen(inbuf))
        return NULL;
    nOutLen = 2 * strlen(inbuf) - 1;
    szOut = (char*)malloc(nOutLen);
    if (-1 == CodeConvert("GBK","UTF-8",inbuf,strlen(inbuf),szOut,nOutLen))
    {
        free(szOut);
        szOut = NULL;
    }
    return szOut;
}

/*FmlDataClear 函数功能：清空数据总线函数*/
void FmlDataClear(char *    cFmlData)
{
    cFmlData[0] = 0;
}

/*FmlFieldErase函数：擦除总线数据中的指定域，没有这个域就不擦除*/
void    FmlFieldErase(char *cFmlData, const char *cFieldName,int iIndex)
{
    char    *p, *q;
    if ( ( p = FmlFieldSeek( cFmlData, cFieldName, iIndex ) ) == NULL )
        return; /*p指向指定的域名的起始地址*/
    if ( ( q = strchr( p, SYM_FML_FS ) ) == NULL ) /*SYM_FML_FS:域分割符^^*/
        q = p + strlen( p );
    else
        q ++; /*q指向域尾*/
    strcpy( p, q ); /*p到q之间的被跳过*/
}

/*FmlFieldSeek函数功能：检索总线中指定域函数，返回指定域的起始地址*/
char *FmlFieldSeek(const char *cFmlData, const char *cFieldName,int    iIndex)
{
    char    *p = (char *) cFmlData;
    char    *n, *q, *v;
    int    r;

    while ( ( n = strchr( p, SYM_FML_FS ) ) != NULL )/*SYM_FML_FS:域分割符^^*/
    {
        *n = 0; /*n指向下一个域分割符^^，并截断*/
        q = strchr( p, SYM_FML_NV ); /*SYM_FML_NV:名值分割符：*/
        *n = SYM_FML_FS; /*恢复域分割符，重新连上总线*/
        if ( q != NULL )
        {
            *q = 0; /*q指向名值分割符：，并截断*/
            if ( ( v = strchr( p, SYM_FML_AN ) ) != NULL ) /*0下标时，v=NULL*/
                *v = 0; /*v指向数组下标起始符#，并截断*/
            if ( ( r = strcmp( p, cFieldName ) ) == 0 ) /*比较p指向的是不是待检索的域名*/
            {
                if ( v == NULL && iIndex != FMLFLD_NOTARRAY || v != NULL && atoi( v + 1 ) != iIndex )
                    r = -1; /*对下标值的检查，出错时r=-1*/
            }
            if ( v != NULL )
                *v = SYM_FML_AN; /*重新连上总线*/
            *q = SYM_FML_NV; /*重新连上总线*/
            if ( r == 0 ) /*域名匹配，下标也正确时，查找完毕*/
                return p; /*返回域名起始地址*/
        }
        p = n + 1; /*p指向下一个域名起始地址，继续循环查找*/
    }
    return NULL;
}

/*FmlFieldPut() 功能描述: 为总线中指定域赋值函数*/
int    FmlFieldPut(char *cFmlData,int iBufSize,char *cFieldName,int iIndex,char *cFieldValue)
{
    int    s, l;
    char    a[12];

    FmlFieldErase( cFmlData, cFieldName, iIndex ); /*擦除指定域名域值*/

    if ( iIndex == FMLFLD_NOTARRAY ) /*FMLFLD_NOTARRAY=0,判断是否是0下标*/
        s = 0; /*0下标时，没有数组下标起始符#，也没有小标值0的显示*/
    else
        s = snprintf( a, sizeof( a ), "%d", iIndex ) + 1; /*下标的长度+#号码长度*/
    if ( ( l = strlen( cFmlData ) ) + strlen( cFieldName ) + s + strlen( cFieldValue ) + 2 > iBufSize )
        return RC_NSPC; /*判断是否溢出，其中2=域分隔符+'\0'*/
    if ( l > 0 && cFmlData[l-1] != SYM_FML_FS ) /*SYM_FML_FS域分割符^^，原串没有域分割符时*/
    {
        cFmlData[l] = SYM_FML_FS; /*原串尾加上域分隔符*/
        l ++; /*原串长+1*/
    }

    if ( s != 0 ) /*非0下标时*/
        /*a中保存的是下标值*/
        sprintf( cFmlData + l, "%s%c%s%c%s%c", cFieldName, SYM_FML_AN, a, SYM_FML_NV, cFieldValue, SYM_FML_FS );
    else /*0下标时*/
        sprintf( cFmlData + l, "%s%c%s%c", cFieldName, SYM_FML_NV,
        cFieldValue, SYM_FML_FS );

    return RC_SUCC;
}

/*FmlFieldGet() 功能描述: 从总线中取指定域值函数*/
int FmlFieldGet(const char *cFmlData,const char *cFieldName,int    iIndex,    char *cFieldValue,int iValueSize)
{
    char    *p, *q, *v;
    int    l;

    if ( ( p = FmlFieldSeek( cFmlData, cFieldName, iIndex ) ) == NULL )
        return RC_NFND; /*p指向指定域名的起始地址*/
    q = strchr( p, SYM_FML_NV ) + 1; /*SYM_FML_NV名值分隔符：,q指向域值的起始地址*/
    if ( ( v = strchr( q, SYM_FML_FS ) ) == NULL ) /*SYM_FML_FS域分隔符^^,v指向域值的尾部地址*/
        l = strlen( q ); /*没有串尾符^^的长度*/
    else
        l = v - q; /*l=域值的长度*/
    if ( l >= iValueSize ) /*要放域值的空间不能小于域值的长度*/
        return RC_NSPC;
    memcpy( cFieldValue, q, l );
    cFieldValue[l] = 0; /*域值的地址加字符串的结束符*/
    return RC_SUCC;
}

/*FmlFieldNum() 功能描述: 统计总线中重复域的个数函数*/
int    FmlFieldNum(const char *cFmlData, const char *cFieldName, int *iNum)
{
    char    *p = (char *) cFmlData;
    char    *n, *q, *v;
    int    r;
    int    num,flag;

    num=0;
    flag=0;

    while ( ( n = strchr( p, SYM_FML_FS ) ) != NULL )
    {
        *n = 0;
        q = strchr( p, SYM_FML_NV );
        *n = SYM_FML_FS;
        if ( q != NULL )
        {
            *q = 0;
            if ( ( v = strchr( p, SYM_FML_AN ) ) != NULL )
                *v = 0;
            else
            {
                *iNum=0;
                if( v != NULL)
                    *v=SYM_FML_AN;
                *q=SYM_FML_NV;
                p = n + 1;
                continue;
            }
            if ( ( r = strcmp( p, cFieldName ) ) == 0 )
            {
                num++;
                flag=1;
            }
                *v=SYM_FML_AN;
                *q=SYM_FML_NV;
        }
        p = n + 1;
    }
    *iNum=num;
    if(flag == 1)
        return RC_SUCC;
    else
        return RC_NFND;
}

char * StrTrim(char * pstr)
{
    if(NULL == pstr)
    {
        return NULL;
    }
    char * phead = pstr;
    char * ptail = pstr + strlen(pstr) - 1;
    while((*phead == ' ')&&(phead < ptail)) phead++;
    while((*ptail == ' ')&&(ptail > phead)) ptail--;
    *(ptail + 1) = '\0';
    memcpy(pstr, phead, sizeof(char)*(ptail - phead + 2));
    return pstr;
}

/***********************************************************
 * 函    数: JugeFileExist()
 * 功能描述: 判断文件是否存在
 * 输入参数：lFilename    -    长文件名
 * 返    回：0-文件存在;1-文件不存在
 * 流程描述：
 *    说    明：
 * 修改记录:
 * [修改人] [日期] – [描述]
***********************************************************/
int JugeFileExist(char *lFileName)
{
    struct stat statbuf;
    memset(&statbuf,0,sizeof(statbuf));
    stat(lFileName,&statbuf);
    if(statbuf.st_mode & S_IFREG)
        return 0;
    else
        return 1;
}