1.C++中如何调用zlib.dll进行解压和压缩
2.ubuntu如何安装tar.gz文件？
3.eval(urldecode(gzuncompress(base64_decode
4.请问有没有LZW压缩算法的源码源代码？
5.MySQL源码阅读4-do_command函数/功能类命令

C++中如何调用zlib.dll进行解压和压缩

       1 准备工作。

       ä¸‹è½½zlib.dll。以及相关头文件。将dll文件及头文件加入工程。

       2 压缩：

       è°ƒç”¨å‡½æ•°compress.

       å½¢å¼ä¸º

       int compress（Byte * dest, uLong* destLen, const Byte *source, ULONG sourceLen）;

       åŠŸèƒ½æ˜¯å°†source指向的空间，长度为sourceLen的数据进行压缩，压缩数据储存在dest中，长度由参数destLen返回。

       å¦‚果压缩出错，返回对应错误号，否则返回0.

       3解压缩:

       è°ƒç”¨å‡½æ•°uncompress.

       å½¢å¼ä¸º

       int uncompress（Byte * dest, uLong* destLen, const Byte *source, ULONG sourceLen）;

       åŠŸèƒ½æ˜¯å°†source指向的空间，长度为sourceLen的数据进行解压缩，解压缩后的数据储存在dest中，长度由参数destLen返回。

       å¦‚果解压缩出错，返回对应错误号，否则返回0.

ubuntu如何安装tar.gz文件？

       tar.gz文件的安装，是源码属于自己编译源代码的方法。

       多说一句，源码tar是源码把文件打成一个包，并不压缩；

       .gz是源码用gzip把打成包的.tar文件压缩，所以成了一个.tar.gz的源码全景 php 源码文件。

       安装的源码话，先解包，源码tar -zxvf xxx.tar.gz，源码这样会生成一个以文件名命名的源码文件夹。

       里面会有一些README、源码INSTALL、源码DOC等等一些文档，源码仔细读读，源码datatables editor 源码可以知道这个软件安装需要什么特殊的源码设置什么的。

       这个没有办法细说了吧：）

       一般软件包里会有一个叫configure的脚本文件，完成配置的任务。可以加很多参数，具体的可以运行./configure --help得到帮助的，比如./configure --prefix=xxx是设定软件安装到哪里。

       设置好参数，运行./configure，会生成makefile文件，这是你后面编译的基础。

       接下来就要编译了，很简单，因为有makefile文件的gee引擎源码存在，只要运行make就可以完成编译的。

       make是将读入所有由configure脚本程序建立的制作文件。

       这些制作文件会告诉make哪些文件需要被编译以及按照怎样的顺序对它们进行编译，因为可能会有上百个源程序文件。

       当make工作的时候，会在屏幕上显示出正在执行的每一个命令，以及与这个命令相关的全部参数。

       这些输出通常都是编译器的调用声明和所有传递给编译器的参数。如果编译器顺利地完成了工作，就不会出现什么错误信息。

       大多数编译器的错误信息十分清楚和明确，因此不用担心可能会漏掉一个错误。如果确实看到有一错误，bitbucket 项目源码也不用慌张。

       大多数错误信息并不反映出程序本身出现了一个问题，通常都是系统这里或者那里的问题。

       典型情况下，这些信息大多是因为文件访问权限不正确而产生的或者是因为文件没有找到。完成编译，之后就是安装软件了。

       这就更简单了，make install就好了，这个命令将启动安装脚本程序。

       因为make命令会在执行每一个命令的时候把它显示出来，所以将会看到许许多多的文字掠过眼前。如果没有看到什么错误信息，firefox 修改源码就说明这个软件包安装好了。

       反安装就是make uninstall了。

       介绍tar，gzip的使用方法。

       1.压缩一组文件为tar.gz后缀。

       # tar cvf backup.tar /etc

       # gzip -q backup.tar 或 # tar cvfz backup.tar.gz /etc/

       2.释放一个后缀为tar.gz的文件。

       # gunzip backup.tar.gz

       #tar xvf backup.tar 或 # tar xvfz backup.tar.gz

       3.用一个命令完成压缩

       #tar cvf - /etc/ | gzip -qc > backup.tar.gz

       4.用一个命令完成释放

       #gunzip -c backup.tar.gz | tar xvf -

       5.如何解开tar.Z的文件？

       # tar xvfz backup.tar.Z 或 # uncompress backup.tar.Z

       #tar xvf backup.tar

       6.如何解开.tgz文件？

       #gunzip backup.tgz

       7.如何压缩和解压缩.bz2的包？

       #bzip2 /etc/smb.conf

       这将压缩文件smb.conf成smb.conf.bz2

       #bunzip2 /etc/smb.conf.bz2

       这将在当前目录下还原smb.conf.bz2为smb.conf

       注:.bz2压缩格式不是很常用，你可以man bzip2

eval(urldecode(gzuncompress(base_decode

       æˆ‘并没有写成解密文档，这类所谓的解密其实一点也不复杂，就是把eval换成echo,然后在浏览器中访问，查看源代码，会发现又会输出类似的eval,继续替换eval为echo,再次在浏览器中访问。

       å¤šåšå‡ æ¬¡å°±èƒ½å¾—到最终的代码。

       æœ‰äº›åŠ å¯†çš„代码中有一些前置解密函数不能丢掉，仍要放在代码的最前端。才能正确解密。

请问有没有LZW压缩算法的源代码？

       #include<stdio.h>

       #include<string.h>

       #include<stdlib.h>

       #define PATHSIZE

       #define BITS

       #define HashShift BITS-8

       #define MAX_VALUE ((1<<BITS)-1)

       #define MAX_CODE (MAX_VALUE-1)

       #define HashTableLen

       #define process

       /*压缩结构*/

       typedef struct

       {

        int *code;

        unsigned int *prenum;

        unsigned char *baknum;

       }LZW_DATA;

       unsigned char decode_stack[HashTableLen];

       LZW_DATA lzwt,*lzw;

       void dataout(FILE *output,unsigned int code);/*输出压缩后的流*/

       unsigned int hashfind(unsigned int hash_prenum,unsigned int hash_character);/*压缩算法*/

       char *decode(unsigned char *buffer,unsigned int code);

       unsigned int incode(FILE *input);

       void compress(FILE *input,FILE *output);

       void decompress(FILE *input,FILE *output);

       int main()

       {

        FILE *fp1,*fp2;

        char path[PATHSIZE];

        S1:puts("Input function.(h:hoop,u:uncompress)...");

        fflush(stdin);

        gets(path);

        if(!strcmp(path,"h")||!strcmp(path,"hoop"))

        {

        printf("Input source file path:");

        fflush(stdin);

        gets(path);

        if((fp1=fopen(path,"rb"))==NULL)

        {

        puts("Can not open source file!");

        return 1;

        }

        printf("Input objective file path:");

        fflush(stdin);

        gets(path);

        if((fp2=fopen(path,"wb"))==NULL)

        {

        puts("Can not open objective file!");

        return 1;

        }

        compress(fp1,fp2);

        }

        else if(!strcmp(path,"u")||!strcmp(path,"uncompress"))

        {

        printf("Input source file path:");

        fflush(stdin);

        gets(path);

        if((fp1=fopen(path,"rb"))==NULL)

        {

        puts("Can not open source file!");

        return 1;

        }

        printf("Input objective file path:");

        fflush(stdin);

        gets(path);

        if((fp2=fopen(path,"wb"))==NULL)

        {

        puts("Can not open objective file!");

        return 1;

        }

        decompress(fp1,fp2);

        }

        else

        {

        puts("Input error,please input again!");

        goto S1;

        }

        fclose(fp1);

        fclose(fp2);

        S2:puts("If continue or not(y:yes/n:no)?");

        fflush(stdin);

        gets(path);

        if(!strcmp(path,"y")||!strcmp(path,"yes"))

        {

        goto S1;

        }

        else if(!strcmp(path,"n")||!strcmp(path,"no"))

        {

        goto S3;

        }

        else

        {

        puts("Input error,please input again!");

        goto S2;

        }

        S3:return 0;

       }

       void compress(FILE *input,FILE *output)

       {

        int i,index,len1,len2;

        int curr_code;

        int baknum;

        int prenum;

        len1=HashTableLen*sizeof(unsigned int);

        len2=HashTableLen*sizeof(unsigned char);

        if(!(lzwt.code=(int*)malloc(len1)))

        {

        puts("Internal memory distribution error!");

        exit(0);

        }

        if(!(lzwt.prenum=(unsigned int*)malloc(len1)))

        {

        puts("Internal memory distribution error!");

        exit(0);

        }

        if(!(lzwt.baknum=(unsigned char*)malloc(len2)))

        {

        puts("Internal memory distribution error!");

        exit(0);

        }

        lzw=&lzwt;

        curr_code=;

        for(i=0;i<HashTableLen;i++)

        {

        lzw->code[i]=-1;

        }

        i=0;

        puts("Hoop begin.");

        prenum=getc(input);

        while((baknum=getc(input))!=EOF)

        {

        index=hashfind(prenum,baknum);

        if(lzw->code[index]!=-1)

        {

        prenum=lzw->code[index];

        }

        else

        {

        if(curr_code<=(MAX_CODE))

        {

        lzw->code[index]=curr_code++;

        lzw->prenum[index]=prenum;

        lzw->baknum[index]=baknum;

        }

        dataout(output,prenum);

        prenum=baknum;

        }

        if(i==prenum)

        {

        i=0;

        putchar('.');

        }

        else

        {

        i++;

        }

        }

        dataout(output,prenum);

        dataout(output,MAX_VALUE);

        dataout(output,0);

        free(lzw->code);

        free(lzw->prenum);

        free(lzw->baknum);

       }

       unsigned int hashfind(unsigned int prenum,unsigned int baknum)

       {

        int index;

        int offset;

        index=(baknum<<HashShift)^prenum;

        if(index==0)

        {

        offset=1;

        }

        else

        {

        offset=HashTableLen-index;

        }

        while(1)

        {

        if(lzw->code[index]==-1)

        {

        return index;

        }

        if(lzw->prenum[index]==prenum&&lzw->baknum[index]==baknum)

        {

        return index;

        }

        index-=offset;

        if(index<0)

        {

        index+=HashTableLen;

        }

        }

       }

       void dataout(FILE *output,unsigned int code)

       {

        static int outbinary=0;

        static unsigned long nob=0L;

        nob|=(unsigned long)code<<(-BITS-outbinary);

        outbinary+=BITS;

        while(outbinary>=8)

        {

        putc(nob>>,output);

        nob<<=8;

        outbinary=outbinary-8;

        }

       }

       void decompress(FILE *input,FILE *output)

       {

        unsigned int curr_code;

        unsigned int baknum;

        unsigned int prenum;

        int i,ch,len1,len2;

        char *ps;

        len1=HashTableLen*sizeof(unsigned int);

        len2=HashTableLen*sizeof(unsigned char);

        if(!(lzwt.code=(int*)malloc(len1)))

        {

        puts("Internal memory distribution error!");

        exit(0);

        }

        if(!(lzwt.prenum=(unsigned int*)malloc(len1)))

        {

        puts("Internal memory distribution error!");

        exit(0);

        }

        if(!(lzwt.baknum=(unsigned char*)malloc(len2)))

        {

        puts("Internal memory distribution error!");

        exit(0);

        }

        lzw=&lzwt;

        curr_code=;

        i=0;

        puts("Uncompress begin.");

        ch=prenum=incode(input);

        putc(prenum,output);

        while((baknum=incode(input))!=MAX_VALUE)

        {

        if(baknum>=curr_code)

        {

        *decode_stack=ch;

        ps=decode(decode_stack+1,prenum);

        }

        else

        {

        ps=decode(decode_stack,prenum);

        }

        ch=*ps;

        while(ps>=decode_stack)

        {

        putc(*(ps--),output);

        }

        if(curr_code<=MAX_CODE)

        {

        lzw->prenum[curr_code]=prenum;

        lzw->baknum[curr_code]=ch;

        curr_code++;

        }

        prenum=baknum;

        if(i==process)

        {

        i=0;

        putchar('.');

        }

        else

        {

        i++;

        }

        }

        free(lzw->code);

        free(lzw->prenum);

        free(lzw->baknum);

       }

       char *decode(unsigned char *buffer,unsigned int code)

       {

        int len=0;

        while(code>)

        {

        *buffer++=lzw->baknum[code];

        code=lzw->prenum[code];

        len++;

        if(len>=HashTableLen)

        {

        puts("Internal memory run over!");

        exit(1);

        }

        }

        *buffer=code;

        return buffer;

       }

       unsigned int incode(FILE *input)

       {

        unsigned int ret;

        static int inputbinary=0;

        static unsigned long nib=0L;

        while(inputbinary<=)

        {

        nib|=(unsigned long)getc(input)<<(-inputbinary);

        inputbinary=inputbinary+8;

        }

        ret=nib>>(-BITS);

        nib<<=BITS;

        inputbinary=inputbinary-BITS;

        return ret;

       }

       这是我以前写的LZW算法，压缩和解压缩文本文件都没问题，就是解压后可能字符的顺序有点问题，呵呵用作学习的

       我在这个地址回答过了，这样的复杂算法一般不会有个人去写的，我写了就觉得晕，如果提问的是同一个人，加我QQ我抽空教你原理。

       /question/.html?fr=im

MySQL源码阅读4-do_command函数/功能类命令

       do_command函数在MySQL的线程循环中执行，分为读取命令和分发执行命令两个主要步骤。

       在读取命令阶段，首先设置读取超时（my_net_set_read_timeout），通过vio（Virtual I/O）接口从连接中读取数据。读取时，先解析包头，然后根据包头大小读取数据，同时检查是否超过最大包限制。若数据被压缩，使用zstd_uncompress或zlib_uncompress解压。解析数据并校验，将结果存储到thd对象中。

       执行命令阶段，依据获取到的命令执行逻辑，分配内存给String对象。通过dispatch_command函数，进入switch...case...结构，执行不同命令的特定逻辑。功能类命令包括初始化数据库（COM_INIT_DB）、注册从节点（COM_REGISTER_SLAVE）、重置连接（COM_RESET_CONNECTION）、克隆插件（COM_CLONE）、修改用户（COM_CHANGE_USER）等。其他类如数据操作、未实现命令则在后续阅读。

       以功能类命令为例，COM_INIT_DB用于改变当前连接的默认数据库。COM_REGISTER_SLAVE则在master节点上注册从节点，启动从节点与master节点的同步。COM_RESET_CONNECTION重置连接，但不创建新连接或更新授权。COM_CLONE命令用于克隆远程插件到本地，并确保一致性。COM_CHANGE_USER允许修改当前连接的用户，并重置连接。

       具体操作包括解析请求包、验证、更新thd信息、保存用户连接信息、证书验证、检查密码有效期、限制最大连接数、更新schema属性等。COM_QUIT命令用于清除数据并退出循环。COM_BINLOG_DUMP_GTID和COM_BINLOG_DUMP用于请求发送binlog数据流，而COM_REFRESH命令用于刷新缓存、权限、日志、表、连接主机信息等数据。

       在COM_PROCESS_INFO命令中获取进程处理信息，COM_SET_OPTION设置连接属性，COM_DEBUG触发打印调试信息，而COM_PROCESS_KILL用于终止连接。最后，检查是否具有RELOAD_ACL权限并加载数据。

       本文总结了do_command函数的命令读取和执行流程，详细介绍了功能类命令的执行情况，为理解MySQL核心工作原理提供了深入洞察。