从HTTP的角度

1 客户端 在http Request  Header上带上 Accept-Encoding:gzip,deflate

2服务器若是支持gzip压缩则在http reponse eader

部分返回Content-Encoding: gzip 或者Content-Type: application/x-gzip

3将body部分用gzip解压缩 则得到网页内容.

传说中ie有bug 在处理js css压缩的时候有bug,我不理解 挺简单的怎么会有bug呢.

从gzip的角度

gzip是一种数据格式 默认且目前仅使用deflate算法压缩data部分

zlib也是一种数据格式,使用defalte算法压缩数据部分.

deflate是一种压缩算法,是huffman编码的一种加强

zlib是一个开源库, 提供deflate压缩和对应的infalte解压缩.

不过zlib默认的deflate infalte默认是处理zlib格式数据.必须使用

deflateInit2(&strm, DEFAULT_COMPRESSION,Z_DEFLATED, DEFAULT_WINDOWSIZE,DEFAULT_MEMLEVEL, Z_DEFAULT_STRATEGY);

初始化才是处理raw deflate data.(这一点在zlib manul没有提,在faq中提到,困扰了我好久,还是同事L帮我调试发现)

至于gzip格式解析 对着RFC写就可以了.

参见RFC 1950 关于zlib http://www.faqs.org/rfcs/rfc1950.html

      RFC 1951 关于deflate http://www.faqs.org/rfcs/rfc1951.html

      RFC 1952 关于gzip http://www.faqs.org/rfcs/rfc1952.html 

nt  CGzip::Ungzip(const std::string & inStr , std::string &outStr){
    static int nFileCount=0;
        nFileCount++;
    string strZipFileName="test";
//    CConvert::StrToFile(inStr,strZipFileName+CConvert::toString<int>(nFileCount)+"H.gzip";
    if(inStr.length()<11){
        return -1;   
    }
    //process gzip header
    unsigned int skipCt = 10;
    unsigned int skipZeroCt = 0;
    unsigned char ID1 = inStr[0];
    unsigned char ID2 = inStr[1];
    unsigned char XFL=inStr[8];
    bool bFEXTRA = false ;
    bool bFNAME = false ;
    bool bFCOMMENT = false ;
    bool bFHCRC = false ;
    unsigned int XLEN = 0;
   
    if( (ID1!=31) && (ID2!=139)){
        return -1;  //非gzip头部
        }
    unsigned char CM = inStr[2];
    if(CM!={
        return -1; //现在都只处理 deflate压缩的
    }
    unsigned char FLG = inStr[3];
    if( (FLG & GZIP_HEAD_FEXTRA) != 0){
        bFEXTRA = true ;
        skipCt += 2;
        XLEN = inStr[10]+ inStr[11]*256 ;//按照小端字节序列处理
        skipCt += XLEN;
    }
    if( (FLG & GZIP_HEAD_FNAME) != 0){
        bFNAME = true;
        skipZeroCt++;
    }
    if( (FLG & GZIP_HEAD_FCOMMENT) != 0){
        bFCOMMENT = true;
        skipZeroCt++;   
    }
   
    size_t passedZeroCt = 0;
   
    size_t iStep = skipCt ;
    for( size_t iStep =  skipCt ; iStep<inStr.length(); iStep++){
            if(passedZeroCt>=skipZeroCt){
                break;   
            }
            if(inStr[iStep]==''{
                passedZeroCt++;   
            }
       
    }
    skipCt = iStep ;
    if( (FLG & GZIP_HEAD_FHCRC) != 0){
        bFHCRC = true;
        skipCt+=2 ;
    }
        string coreStr = inStr.substr(skipCt,inStr.length()-8-skipCt);
           return CGzip::Inflate(coreStr,outStr);
   
   
   
}

int  CGzip:ogzip(const std::string & inStr , std::string &outStr){
    char pAddHead[10];
    unsigned long crc = 0;
    // gzip header
    static const char deflate_magic[2] = {'37', '\213'};
    snprintf(pAddHead, 10,
            "%c%c%c%c%c%c%c%c%c%c", deflate_magic[0],
            deflate_magic[1], Z_DEFLATED, 0 /* flags */,
            0, 0, 0, 0 /* 4 chars for mtime */,
            0 /* xflags */, 0xff);
    string addHead(pAddHead,10);
    //gzip's raw deflate body
    if(CGzip:eflate(inStr,outStr)<0){
        return - 1;   
    }
    //gzip trailer
    crc = crc32(crc, (const Bytef*)inStr.data(), inStr.length());
    char  tailBuf[8];
    memcpy(tailBuf, &crc, 4);
    int isize=inStr.size();
    memcpy(tailBuf,&isize,4);
    string tailStr(tailBuf , 8 );
    outStr = addHead + outStr+tailStr;     //
    return outStr.length(); //

　　以前用Greta，但怎么都觉得不爽，特别是用惯了PHP的我，用着POSIX的正则表达式很不习惯。

　　于是今天琢磨了下Pcre，这个号称最强大的正则表达式库……

　　不过，比起Greta最郁闷的就是编译Pcre了……

　　在网上找了一段实在不怎么有用，居然要用到mv.exe，Windows XP下上哪找去？

　　能用rename为什么要用mv.exe？

　　把那段编译脚本“强改”以后，就成了下面的样子了……

　　当然你还是得有sed.exe

　　如果没有请点此下载 sed.exe

　　然后把sed.exe放到pcre源码目录下，把下面的文字保存为make.bat，用cmd进入pcre目录，运行make即可。

@echo off
echo 正在预处理...
echo ------------------------------------------
copy /y config.h.generic bak.h.generic
sed -e "s/#define HAVE_BCOPY 1/#define HAVE_BCOPY 0/g" config.h.generic > config.h
copy /y pcre.h.generic pcre.h
copy /y pcre_chartables.c.dist pcre_chartables.c
echo ------------------------------------------
echo 正在编译 dftables.exe ...
echo ------------------------------------------
cl -MD -DHAVE_CONFIG_H dftables.c
dftables.exe pcre_chartables.c
echo ------------------------------------------
echo 正在编译源代码为Obj文件...
echo ------------------------------------------
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_chartables.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_compile.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_config.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_dfa_exec.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_exec.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_fullinfo.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_get.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_globals.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_info.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_maketables.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_newline.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_ord2utf8.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_refcount.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_study.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_tables.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_try_flipped.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_ucp_searchfuncs.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_valid_utf8.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_version.c
cl -O1 -MD -DHAVE_CONFIG_H -c pcre_xclass.c
echo ------------------------------------------
echo 正在生成Lib文件...
echo ------------------------------------------
lib -out:pcre.lib pcre_chartables.obj pcre_compile.obj pcre_config.obj pcre_dfa_exec.obj pcre_exec.obj pcre_fullinfo.obj pcre_get.obj pcre_globals.obj pcre_info.obj pcre_maketables.obj pcre_newline.obj pcre_ord2utf8.obj pcre_refcount.obj pcre_study.obj pcre_tables.obj pcre_try_flipped.obj pcre_ucp_searchfuncs.obj pcre_valid_utf8.obj pcre_version.obj pcre_xclass.obj
echo ------------------------------------------
echo 正在还原...
echo ------------------------------------------
copy /y bak.h.generic config.h.generic
echo ------------------------------------------
echo 正在清理...
del *.obj
del dftables.exe
del bak.h.generic
del config.h
del dftables.lib
del dftables.exp
del pcre_chartables.c
echo ------------------------------------------
echo 完成
echo 最终生成列表：
echo -       pcre.lib
echo -       pcre.h
echo ------------------------------------------
pause
@echo on

　　最后生成pcre.lib和pcre.h两个文件。

选择Win32 LIB Release 按F7编绎生成zlib.lib

工程中使用时把

D:\zlib-1.2.3\projects\visualc6\Win32_LIB_Release\zlib.lib

D:\zlib-1.2.3\zlib.h

D:\zlib-1.2.3\zconf.h

拷贝到所在工程目录下

然后

#include "zlib.h"
#pragma comment(lib,"zlib.lib")

void CZlibTestDlg::OnButton1()
{
const unsigned char strSrc[]="hello world!\n\
aaaaa bbbbb ccccc ddddd aaaaa bbbbb ccccc ddddd中文测试 中文测试\
aaaaa bbbbb ccccc ddddd aaaaa bbbbb ccccc ddddd中文测试 中文测试\
aaaaa bbbbb ccccc ddddd aaaaa bbbbb ccccc ddddd中文测试 中文测试\
aaaaa bbbbb ccccc ddddd aaaaa bbbbb ccccc ddddd中文测试 中文测试";

     unsigned char buff[1024]={0},strDst[1024]={0};
     unsigned long srcLen=sizeof(strSrc),bufLen=sizeof(buff),dstLen=sizeof(strDst);
CString strc,strc2,strc3;
     strc.Format("Src string:%s\nLength:%d\n===================\n",strSrc,srcLen);
     //压缩
      compress(buff,&bufLen,strSrc,srcLen);
      strc2.Format("\nAfter Compressed Length:%d\nCompressed String:%s\n==============\n",bufLen,buff);
     //解压缩
      uncompress(strDst,&dstLen,buff,bufLen);
      strc3.Format("\nAfter UnCompressed Length:%d\nUnCompressed String:%s\n",dstLen,strDst);
   AfxMessageBox(strc+strc2+strc3);
}

今天看了一下如何使用PCRE，还没有涉及到PCRE原理和实现的代码。我们可以在http://www.pcre.org/上下载到pcre的代码，下载到的源文件pcre-x.x.tar.bz2在linux下面很容易就可以被编译和安装(x86 系列cpu哦)。

./configure

make

make install

PCRE编译安装之后，以一个lib库的方式提供给用户程序进行使用，PCRE lib 提供了一组API,通过这一组API可以实现类似于Perl语法的正则表达式查找和匹配的功能。（PCREE library is a set of functions that implement regular expression pattern matching using the same syntax and semantics as Perl, with just a few differences.）

要想使用好PCRE，要了解很多正则表达式的内容、同时需要对PCRE进行很多的配置，从而使其支持不同的模式和规格。在这里只是简单的描述一下使用PCRE的方法，不涉及配置和正则表达式语法的内容。

使用PCRE主要是使用下面的四个函数，对这四个函数有了了解，使用PCRE库的时候就会简单很多。

pcre_compile() /pcre_compile2()

pcre_study()

pcre_exec()

1. pcre_compile() /pcre_compile2()， 正则表达式在使用之前要经过编译。

pcre *pcre_compile(const char *pattern, int options, const char **errptr, int *erroffset, const unsigned char *tableptr);

pcre *pcre_compile2(const char *pattern, int options, int *errorcodeptr, const char **errptr, int *erroffset, const unsigned char *tableptr);

编译的目的是将正则表达式的pattern转换成PCRE引擎能够识别的结构（struct real_pcre）。

还没有对编译的过程进行分析.

2. pcre_study（），对编译后的正则表达式结构(struct real_pcre)进行分析和学习,学习的结果是一个数据结构(struct pcre_extra),这个数据结构连同编译后的规则(struct real_pcre)可以一起送给pcre_exec单元进行匹配.

If a compiled pattern is going to be used several times, it is worth spending more time analyzing it in order to speed up the time taken for matching. The function pcre_study() takes a pointer to a compiled pattern as its first argument. If studying the pattern produces additional information that will help speed up matching, pcre_study() returns a pointer to a pcre_extra block, in which the study_data field points to the results of the study.

pcre_study（）的引入主要是为了加速正则表达式匹配的速度.(为什么学习后就能加速呢?)这个还是比较有用的,可以将正则表达式编译,学习后保存到一个文件或内存中,这样进行匹配的时候效率比较搞.snort中就是这样做的.

3. pcre_exec（），根据正则表达式到指定的字符串中进行查找和匹配,并输出匹配的结果.

The function pcre_exec() is called to match a subject string against a compiled pattern, which is passed in the code argument. If the pattern has been studied, the result of the study should be passed in the extra argument. This function is the main matching facility of the library, and it operates in a Perl-like manner.

4. Snort中如何使用PCRE呢?snort中以插件的形式调用PCRE进行正则表达式的匹配。

1）进行正则表达式的初始化。

InitializeDetection--> RegisterRules-->RegisterOneRule-->PCRESetup(Just for OPTION_TYPE_PCRE)->pcre_compile and pcre_study. All will be stored in a structure called PCREInfo in the memory.

2.) 规则的匹配。DetectionCheckRule-->ruleMatch-->ruleMatchInternal-->pcreMatch(OPTION_TYPE_PCRE)->pcre_test-->pcre_exec.

5.编译PCRE on TILERA platform.

1) tar -xjvf pcre-7.9.tar.bz2

2) Modify config.sub to support tile architecture.

We wish to use DE>HOST=tileDE>, but the DE>tileDE> architecture is not yet standard, so may not exist in the DE>config.subDE> file. If necessary, add these lines in the alphabetical list of architectures (typically about 1,100 lines down):

 tile*)
  basic_machine=tile-tilera
  os=-linux-gnu
  ;;

3) Compile PCRE on tile Linux. 

** Start up TILERA card through tile-monitor.

tile-monitor --pci --mount-tile /usr  \
  --mount-tile /bin --mount-tile /sbin --mount-tile /etc --mount-tile /lib \
  --mkdir /mnt/libs --mount /libs-compile /mnt/libs \
  --mkdir /mnt/mde  --mount $TILERA_ROOT /mnt/mde

* ./configure --build=tile  --prefix=/usr  lt_cv_sys_max_cmd_len=262144 --disable-cpp

//编译的时候没有使能c++的支持。

pcre-7.9 configuration summary:

   pcre-7.9 configuration summary:

    Install prefix .................. : /usr
    C preprocessor .................. : gcc -E
    C compiler ...................... : gcc
    C++ preprocessor ................ : g++ -E
    C++ compiler .................... : g++
    Linker .......................... : /usr/bin/ld
    C preprocessor flags ............ :
    C compiler flags ................ : -O2
    C++ compiler flags .............. : -O2
    Linker flags .................... :
    Extra libraries ................. :

    Build C++ library ............... : no
    Enable UTF-8 support ............ : no
    Unicode properties .............. : no
    Newline char/sequence ........... : lf
    \R matches only ANYCRLF ......... : no
    EBCDIC coding ................... : no
    Rebuild char tables ............. : no
    Use stack recursion ............. : yes
    POSIX mem threshold ............. : 10
    Internal link size .............. : 2
    Match limit ..................... : 10000000
    Match limit recursion ........... : MATCH_LIMIT
    Build shared libs ............... : yes
    Build static libs ............... : yes
    Link pcregrep with libz ......... : no
    Link pcregrep with libbz2 ....... : no
    Link pcretest with libreadline .. : no

* make

* make install

4) Compile the PCRE demo code and test PCRE lib on TILERA linux. PCRE 的源文件中提供了两个demo程序，一个是比较简单的pcredemo.c，很容易理解；另外一个是pcretest.c，这个比较全面、完整的介绍了pcre库的使用。这两个demo本身就是非常好的学习材料。

# gcc -o pcredemo pcredemo.c -lpcre
#  ./pcredemo 'cat|dog' 'the cat sat on the mat'

Match succeeded at offset 4
 0: cat
No named substrings
# ./pcredemo -g 'cat|dog' 'the dog sat on the cat'

Match succeeded at offset 4
 0: dog
No named substrings

Match succeeded again at offset 19
 0: cat
No named substrings

//参考资料:

PCRE源码文档:pcre-7.9/doc/html

—— zlib manaul

    deflate算法在rfc1951中有详细的说明。

    zlib同时又是一种数据格式，使用zlib库压缩后的数据会在deflate数据的头和尾添加信息，形成zlib格式的数据。

   gzip也是一种数据压缩格式，可以大体分为头部，数据部和尾部三个部分，其中头部和尾部主要是一些文档属性和校验信息（rfc1952），数据部主要是用deflate方法压缩得到的数据。
   
    zlib库默认的压缩方法并不是gzip的，而是zlib的，因此使用zlib压缩得到gzip格式的数据有两种方法：

1. 使用zlib提供的gz***系列函数可以直接把想要的内容写入一个磁盘gzip文件；

2. 如果想在内存中生成gzip格式的数据，可以在初始化的时候调用inflateInit2函数，并指定为gzip格式，代码如下：

    之后，用deflate压缩出来的数据就是gzip的了。

　　zlib是提供资料压缩之用的函式库，由Jean-loup Gailly与Mark Adler所开发，初版0.9版在1995年5月1日发表。zlib使用DEFLATE算法，最初是为libpng函式库所写的，后来普遍为许多软件所使用。此函式库为自由软件，使用zlib授权。

　　zlib是用于资料压缩的函式库，由Jean-loup Gailly与Mark Adler所开发，是使用抽象化的DEFLATE压缩算法gzip文件压缩程序。初版0.9版在1995年5月1日发表，最初是为libpng函式库所写的，后来普遍为许多软件所使用。此函式库为自由软件，使用zlib授权。

　　截至2007年3月，zlib是包含在Coverity的美国国土安全部赞助者选择继续审查的开源项目。

[编辑本段]

功能

　　* 数据头(header) - zlib能使用一个gzip数据头，zlib数据头或者不使用数据头压缩数据。

　　通常情况下，数据压缩使用zlib数据头，因为这提供错误数据检测。当数据不使用数据头写入时，结果是没有任何错误检测的原始DEFLATE数据，那么解压缩软件的调用者知道压缩数据在什么地方结束。

　　gzip数据头比zlib数据头要大，因为它保存了文件名和其他文件系统信息，事实上这是广泛使用的gzip文件的数据头格式。注意zlib函式库本身不能创建一个gzip文件，但是它相当轻松的通过把压缩数据写入到一个有gzip文件头的文件中。

　　* 算法 - 目前zlib仅支持一个LZ77的变种算法，DEFLATE的算法。

　　这个算法使用很少的系统资源，对各种数据提供很好的压缩效果。这也是在ZIP档案中无一例外的使用这个算法。（尽管zip文件格式也支持几种其他的算法）。

　　看起来zlib格式将不会被扩展使用任何其他算法，尽管数据头可以有这种可能性。

　　* 使用资源 - 函式库提供了对处理器和内存使用控制的能力

　　不同的压缩级别数值可以指示不同的压缩执行速度。

　　还有内存控制管理的功能。这在一些诸如嵌入式系统这样内存有限制的环境中是有用的。

　　* 策略 - 压缩可以针对特定类型的数据进行优化

　　如果你总是使用zlib库压缩压缩特定类型的数据，那么可以使用有针对性的策略可以提高压缩效率和性能。例如，如果你的数据包含很长的重复数据，那么可以用RLE（运行长度编码）策略，可能会有更好的结果。

　　对于一般的数据，默认的策略是首选。

　　* 错误处理 - 错误可以被发现和跳过

　　数据混乱可以被检测（只要数据和zlib或者gzip数据头一起被写入－参见上面）

　　此外，如果全刷新点（full-flush points）被写入到压缩后的数据流中，那么错误数据是可以被跳过的，并且解压缩将重新同步到下个全刷新点。（错误数据的无错恢复被提供）。全刷新点技术对于在不可靠的通道上的大数据流是很有用的，一些过去的数据丢失是不重要的（例如多媒体数据），但是建立太多的全刷新点会极大的影响速度和压缩。

　　* 数据长度 - 对于压缩和解压缩，没有数据长度的限制

　　重复调用库函数允许处理无限的数据块。一些辅助代码（计数变量）可能会溢出，但是不影响实际的压缩和解压缩。

　　当压缩一个长（无限）数据流时，最好写入全刷新点。

[编辑本段]

使用zlib的软件

　　今天，zlib是一种事实上的业界标准，以至于在标准文档中，zlib和DEFLATE常常互换使用。数以千计的应用程序直接或间接依靠zlib压缩函式库，[2]，包括：

　　* Linux核心：使用zlib以实作网络协定的压缩、档案系统的压缩以及开机时解压缩自身的核心。

　　* libpng，用于PNG图形格式的一个实现，对bitmap数据规定了DEFLATE作为流压缩方法。

　　* Apache：使用zlib实作http 1.1。

　　* OpenSSH、OpenSSL：以zlib达到最佳化加密网络传输。

　　* FFmpeg：以zlib读写Matroska等以DEFLATE算法压缩的多媒体串流格式。

　　* rsync：以zlib最佳化远端同步时的传输。

　　* The dpkg and RPM package managers, which use zlib to unpack files from compressed software packages.

　　* Subversion 、Git和 CVS 版本控制系统，使用zlib来压缩和远端仓库的通讯流量。

　　* dpkg和RPM等包管理软件：以zlib解压缩RPM或者其他封包。

　　因为其代码的可移植性，宽松的许可以及较小的内存占用，zlib在许多嵌入式设备中也有应用。

zlib和gzip是一回事，gzip不过外面多了一个文件格式，作者都是同一个人。
据说7zip比zlib有更高的压缩比和解压速度,但没有用过。

BOOL Glob_Fun::LoadFile(const char* file_name, vector<char>& vec_file)
{
    vec_file.clear();
    if ((NULL == file_name))
        return FALSE;
    CFile file;
    char szBuf[1024 * 10] = "", *pTmp = NULL;
    int nRead = 0;
    int file_len = 0;

    if(FALSE == file.Open(file_name,CFile::modeRead))
        return FALSE;

    if(0 >= (file_len=file.GetLength()))
    {
        file.Close();
        return TRUE;
    }
    vec_file.resize(file_len);
    pTmp = &vec_file[0];
    do
    {
        nRead = file.Read(szBuf, sizeof(szBuf));
        memcpy(pTmp, szBuf, nRead);
        pTmp += nRead;
    }while (nRead > 0);
    file.Close();
    return TRUE;
}

char* Glob_Fun::MemFind(const void* src_buf, int src_len, const void* find_buf, int find_len)
{
    if ((NULL == src_buf) || (NULL == find_buf)
        || (src_len <= 0) || (find_len <= 0))
        return NULL;

    char*cp = (char*)src_buf;
    char*src_end = (char*)src_buf +  src_len;
    char*find_end = (char*)find_buf + find_len;
    char*s_src = NULL, *s_find = NULL;
    while (cp < src_end)
    {
        s_src = cp;
        s_find = (char*)find_buf;
        while (s_src < src_end && s_find < find_end && *s_src == *s_find)
            ++s_src, ++s_find;
        if (s_find == find_end)
            return(cp);
        ++cp;
    }
    return(NULL);
}

BOOL Glob_Fun::ParserMem(
                         const void*                    src_buf,
                         int                            src_len,
                         const vector< vector<char> >&    vec_par,
                         vector< vector<char> >&        vec_result)
{
    if ((NULL == src_buf) || (src_len <= 0) || vec_par.size() <= 0)
        return FALSE;
    for (size_t t = 0; t < vec_par.size(); ++t)
    {
        if(0 >= vec_par[t].size())
            return FALSE;
    }

    vec_result.clear();

    vector<char> vec_tmp;
    BOOL bMatched = FALSE;
    int nParCount = vec_par.size();
    int nParTick = 0;
    char*cp = (char*)src_buf;
    char*src_end = (char*)src_buf +  src_len;
    int  nParLen = (int)vec_par[0].size();
    char*find_buf = (char*)&(vec_par[0][0]);
    char*find_end = find_buf + nParLen;
    char*s_src = NULL, *s_find = NULL;

    while (cp < src_end)
    {
        s_src = cp;
        s_find = (char*)find_buf;
        while (s_src < src_end && s_find < find_end && *s_src == *s_find)
            ++s_src,++s_find;
        if (s_find == find_end)
        {   
            bMatched = TRUE;
            cp += nParLen;
            vec_result.push_back(vec_tmp);
            vec_tmp.clear();
            ++nParTick;
            if(nParCount == nParTick)
                nParTick = 0;
            nParLen = (int)(vec_par[nParTick].size());
            find_buf = (char*)&(vec_par[nParTick][0]);
            find_end = find_buf + nParLen;            
        }
        else
        {
            vec_tmp.push_back(*cp);
            ++cp;
        }
    }
    if(TRUE == bMatched)
        vec_result.push_back(vec_tmp);
    return(bMatched);
}

BOOL Glob_Fun::ParserMem(
                         const void*                    src_buf,
                         int                            src_len,
                         const vector<char>&            vec_par,
                         vector< vector<char> >&        vec_result)
{
    if ((NULL == src_buf) || (src_len <= 0) || vec_par.size() <= 0)
        return FALSE;
    vec_result.clear();

    vector<char> vec_tmp;
    BOOL bMatched = FALSE;
    char*cp = (char*)src_buf;
    char*src_end = (char*)src_buf +  src_len;
    int  nParLen = (int)vec_par.size();
    char*find_buf = (char*)&(vec_par[0]);
    char*find_end = find_buf + nParLen;
    char*s_src = NULL, *s_find = NULL;

    while (cp < src_end)
    {
        s_src = cp;
        s_find = (char*)find_buf;
        while (s_src < src_end && s_find < find_end && *s_src == *s_find)
            ++s_src, ++s_find;
        if (s_find == find_end)
        {   
            bMatched = TRUE;
            cp += nParLen;
            vec_result.push_back(vec_tmp);
            vec_tmp.clear();        
        }
        else
        {
            vec_tmp.push_back(*cp);
            ++cp;
        }
    }
    if(TRUE == bMatched)
        vec_result.push_back(vec_tmp);
    return(bMatched);
}

BOOL Glob_Fun::ParserMem(
                         const void*                    src_buf,
                         int                            src_len,
                         const char*                    par_buf,
                         vector< vector<char> >&        vec_result)
{
    if ((NULL == src_buf) || (src_len <= 0) || strlen(par_buf) <= 0)
        return FALSE;
    vec_result.clear();

    vector<char> vec_tmp;
    BOOL bMatched = FALSE;
    char*cp = (char*)src_buf;
    char*src_end = (char*)src_buf +  src_len;
    int  nParLen = strlen(par_buf);
    char*find_buf = (char*)par_buf;
    char*find_end = find_buf + nParLen;
    char*s_src = NULL, *s_find = NULL;

    while (cp < src_end)
    {
        s_src = cp;
        s_find = (char*)find_buf;
        while (s_src < src_end && s_find < find_end && *s_src == *s_find)
            ++s_src, ++s_find;
        if (s_find == find_end)
        {   
            bMatched = TRUE;
            cp += nParLen;
            vec_result.push_back(vec_tmp);
            vec_tmp.clear();        
        }
        else
        {
            vec_tmp.push_back(*cp);
            ++cp;
        }
    }
    if(TRUE == bMatched)
        vec_result.push_back(vec_tmp);
    return(bMatched);
}

BOOL Glob_Fun::ParserMem(
                         const void*                    src_buf,
                         int                            src_len,
                         const char*                    par_buf,
                         vector<string>&                vec_result)
{
    if ((NULL == src_buf) || (src_len <= 0) || strlen(par_buf) <= 0)
        return FALSE;
    vec_result.clear();

    string vec_tmp;
    BOOL bMatched = FALSE;
    char*cp = (char*)src_buf;
    char*src_end = (char*)src_buf +  src_len;
    int  nParLen = strlen(par_buf);
    char*find_buf = (char*)par_buf;
    char*find_end = find_buf + nParLen;
    char*s_src = NULL, *s_find = NULL;

    while (cp < src_end)
    {
        s_src = cp;
        s_find = (char*)find_buf;
        while (s_src < src_end && s_find < find_end && *s_src == *s_find)
            ++s_src, ++s_find;
        if (s_find == find_end)
        {   
            bMatched = TRUE;
            cp += nParLen;
            vec_result.push_back(vec_tmp);
            vec_tmp.clear();        
        }
        else
        {
            vec_tmp.push_back(*cp);
            ++cp;
        }
    }
    if(TRUE == bMatched)
        vec_result.push_back(vec_tmp);
    return(bMatched);
}