开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 远程控制编程 > 查看源码
clzhcompress.cpp
资源名称：bo2ksrc.zip　[点击查看]
上传用户：jinandeyu
上传日期：2007-01-05
资源大小：620k
文件大小：18k
源码类别：

远程控制编程

开发平台：

WINDOWS

clzhcompress.cpp：源码内容
  1. /*  Back Orifice 2000 - Remote Administration Suite
  2.     Copyright (C) 1999, Cult Of The Dead Cow
  4.     This program is free software; you can redistribute it and/or modify
  5.     it under the terms of the GNU General Public License as published by
  6.     the Free Software Foundation; either version 2 of the License, or
  7.     (at your option) any later version.
  9.     This program is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.     GNU General Public License for more details.
  14.     You should have received a copy of the GNU General Public License
  15.     along with this program; if not, write to the Free Software
  16.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18. The author of this program may be contacted at dildog@l0pht.com. */
  20. #include<windows.h>
  21. #include<limits.h>
  22. #include<lzhcompress.h>
  25. void CLzhCompress::InitTree(void)  /* initialize trees */
  26. {
  27.     short  i;
  29.     for (i = N + 1; i <= N + 256; i++)
  30.         rson[i] = NIL;        /* root */
  31.     for (i = 0; i < N; i++)
  32.         dad[i] = NIL;         /* node */
  33. }
  35. void CLzhCompress::InsertNode(short r)  /* insert to tree */
  36. {
  37.     short  i, p, cmp;
  38.     unsigned char  *key;
  39.     unsigned c;
  41.     cmp = 1;
  42.     key = &text_buf[r];
  43.     p = N + 1 + key[0];
  44.     rson[r] = lson[r] = NIL;
  45.     match_length = 0;
  46.     for(;;) {
  47.         if (cmp >= 0) {
  48.             if (rson[p] != NIL)
  49.                 p = rson[p];
  50.             else {
  51.                 rson[p] = r;
  52.                 dad[r] = p;
  53.                 return;
  54.             }
  55.         } else {
  56.             if (lson[p] != NIL)
  57.                 p = lson[p];
  58.             else {
  59.                 lson[p] = r;
  60.                 dad[r] = p;
  61.                 return;
  62.             }
  63.         }
  64.         for (i = 1; i < F; i++)
  65.             if ((cmp = key[i] - text_buf[p + i]) != 0)
  66.                 break;
  67. if (i > THRESHOLD) {
  68. if (i > match_length) {
  69. match_position = ((r - p) & (N - 1)) - 1;
  70. if ((match_length = i) >= F)
  71. break;
  72. }
  73. if (i == match_length) {
  74. if ((c = ((r - p) & (N-1)) - 1) < (WORD)match_position) {
  75. match_position = c;
  76. }
  77. }
  78. }
  79.     }
  80.     dad[r] = dad[p];
  81.     lson[r] = lson[p];
  82.     rson[r] = rson[p];
  83.     dad[lson[p]] = r;
  84.     dad[rson[p]] = r;
  85.     if (rson[dad[p]] == p)
  86.         rson[dad[p]] = r;
  87.     else
  88.         lson[dad[p]] = r;
  89.     dad[p] = NIL; /* remove p */
  90. }
  92. void CLzhCompress::DeleteNode(short p)  /* remove from tree */
  93. {
  94.     short  q;
  96.     if (dad[p] == NIL)
  97.         return;         /* not registered */
  98.     if (rson[p] == NIL)
  99.         q = lson[p];
  100.     else {
  101. if (lson[p] == NIL)
  102. q = rson[p];
  103. else {
  104. q = lson[p];
  105. if (rson[q] != NIL) {
  106. do {
  107. q = rson[q];
  108. } while (rson[q] != NIL);
  109. rson[dad[q]] = lson[q];
  110. dad[lson[q]] = dad[q];
  111. lson[q] = lson[p];
  112. dad[lson[p]] = q;
  113. }
  114. rson[q] = rson[p];
  115. dad[rson[p]] = q;
  116. }
  117. }
  118. dad[q] = dad[p];
  119. if (rson[dad[p]] == p)
  120. rson[dad[p]] = q;
  121. else
  122. lson[dad[p]] = q;
  123. dad[p] = NIL;
  124. }
  126. /* Huffman coding */
  127. /* table for encoding and decoding the upper 6 bits of position */
  128. /* for encoding */
  129. BYTE p_len[64] = {
  130.     0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05,
  131. 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06,
  132. 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
  133. 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  134. 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  135. 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  136. 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  137. 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08
  138. };
  140. BYTE p_code[64] = {
  141.     0x00, 0x20, 0x30, 0x40, 0x50, 0x58, 0x60, 0x68,
  142. 0x70, 0x78, 0x80, 0x88, 0x90, 0x94, 0x98, 0x9C,
  143. 0xA0, 0xA4, 0xA8, 0xAC, 0xB0, 0xB4, 0xB8, 0xBC,
  144. 0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE,
  145. 0xD0, 0xD2, 0xD4, 0xD6, 0xD8, 0xDA, 0xDC, 0xDE,
  146. 0xE0, 0xE2, 0xE4, 0xE6, 0xE8, 0xEA, 0xEC, 0xEE,
  147. 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
  148. 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
  149. };
  151. /* for decoding */
  152. BYTE d_code[256] = {
  153.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  154. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  155. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  156. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  157. 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  158. 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  159. 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
  160. 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
  161. 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
  162. 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
  163. 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
  164. 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  165. 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
  166. 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  167. 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  168. 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
  169. 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
  170. 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B,
  171. 0x0C, 0x0C, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D,
  172. 0x0E, 0x0E, 0x0E, 0x0E, 0x0F, 0x0F, 0x0F, 0x0F,
  173. 0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11,
  174. 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13,
  175. 0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15,
  176. 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17,
  177. 0x18, 0x18, 0x19, 0x19, 0x1A, 0x1A, 0x1B, 0x1B,
  178. 0x1C, 0x1C, 0x1D, 0x1D, 0x1E, 0x1E, 0x1F, 0x1F,
  179. 0x20, 0x20, 0x21, 0x21, 0x22, 0x22, 0x23, 0x23,
  180. 0x24, 0x24, 0x25, 0x25, 0x26, 0x26, 0x27, 0x27,
  181. 0x28, 0x28, 0x29, 0x29, 0x2A, 0x2A, 0x2B, 0x2B,
  182. 0x2C, 0x2C, 0x2D, 0x2D, 0x2E, 0x2E, 0x2F, 0x2F,
  183. 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
  184. 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
  185. };
  187. BYTE d_len[256] = {
  188.     0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
  189. 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
  190. 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
  191. 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
  192. 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
  193. 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
  194. 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
  195. 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
  196. 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
  197. 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
  198. 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  199. 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  200. 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  201. 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  202. 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  203. 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  204. 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  205. 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  206. 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
  207. 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
  208. 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
  209. 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
  210. 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
  211. 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
  212. 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  213. 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  214. 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  215. 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  216. 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  217. 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
  218. 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  219. 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
  220. };
  223. WORD CLzhCompress::GetBit(void)    /* get one bit */
  224. {
  225.     WORD i;
  227.     while (getlen <= 8) {
  228.         if ((i = fnc_getc())==0xFFFF) i = 0;
  229.         getbuf |= i << (8 - getlen);
  230.         getlen += 8;
  231.     }
  232.     i = getbuf;
  233.     getbuf <<= 1;
  234.     getlen--;
  235.     return ((i & 0x8000) >> 15);
  236. }
  238. WORD CLzhCompress::GetByte(void)   /* get one byte */
  239. {
  240.     WORD i;
  242.     while (getlen <= 8) {
  243.         if ((i = fnc_getc())==0xFFFF) i = 0;
  244.         getbuf |= i << (8 - getlen);
  245.         getlen += 8;
  246.     }
  247.     i = getbuf;
  248.     getbuf <<= 8;
  249.     getlen -= 8;
  250.     return ((i & 0xff00) >> 8);
  251. }
  253. void CLzhCompress::Putcode(short l, WORD c)     /* output c bits of code */
  254. {
  255.     putbuf |= c >> putlen;
  256.     if ((putlen += l) >= 8) {
  257.         if(fnc_putc(putbuf >> 8)==-1) return;
  258.         
  259.         if((putlen -= 8) >= 8) {
  260.             if(fnc_putc(putbuf)==-1) return;
  261.       
  262.             codesize += 2;
  263.             putlen -= 8;
  264.             putbuf = c << (l - putlen);
  265.         } else {
  266.             putbuf <<= 8;
  267.             codesize++;
  268.         }
  269.     }
  270. }
  273. /* initialization of tree */
  275. void CLzhCompress::StartHuff(void)
  276. {
  277.     short i, j;
  279.     for (i = 0; i < N_CHAR; i++) {
  280.         freq[i] = 1;
  281.         son[i] = i + T;
  282.         prnt[i + T] = i;
  283.     }
  284.     i = 0; j = N_CHAR;
  285.     while (j <= R) {
  286.         freq[j] = freq[i] + freq[i + 1];
  287.         son[j] = i;
  288.         prnt[i] = prnt[i + 1] = j;
  289.         i += 2; j++;
  290.     }
  291.     freq[T] = 0xffff;
  292.     prnt[R] = 0;
  293. }
  296. /* reconstruction of tree */
  298. void CLzhCompress::reconst(void)
  299. {
  300.     short i, j, k;
  301.     WORD f, l;
  303.     /* collect leaf nodes in the first half of the table */
  304.     /* and replace the freq by (freq + 1) / 2. */
  305.     j = 0;
  306.     for (i = 0; i < T; i++) {
  307.         if (son[i] >= T) {
  308.             freq[j] = (freq[i] + 1) / 2;
  309.             son[j] = son[i];
  310.             j++;
  311.         }
  312.     }
  313.     /* begin constructing tree by connecting sons */
  314.     for (i = 0, j = N_CHAR; j < T; i += 2, j++) {
  315.         k = i + 1;
  316.         f = freq[j] = freq[i] + freq[k];
  317.         for (k = j - 1; f < freq[k]; k--);
  318.         k++;
  319.         l = (j - k) * 2;
  320.         memmove(&freq[k + 1], &freq[k], l);
  321.         freq[k] = f;
  322.         memmove(&son[k + 1], &son[k], l);
  323.         son[k] = i;
  324.     }
  325.     /* connect prnt */
  326.     for (i = 0; i < T; i++) {
  327.         if ((k = son[i]) >= T) {
  328.             prnt[k] = i;
  329.         } else {
  330.             prnt[k] = prnt[k + 1] = i;
  331.         }
  332.     }
  333. }
  336. /* increment frequency of given code by one, and update tree */
  338. void CLzhCompress::update(short c)
  339. {
  340.     short i, j, k, l;
  342.     if (freq[R] == MAX_FREQ) {
  343.         reconst();
  344.     }
  345.     c = prnt[c + T];
  346.     do {
  347.         k = ++freq[c];
  349.         /* if the order is disturbed, exchange nodes */
  350.         if ((WORD)k > freq[l = c + 1]) {
  351.             while ((WORD)k > freq[++l]);
  352.             l--;
  353.             freq[c] = freq[l];
  354.             freq[l] = k;
  356.             i = son[c];
  357.             prnt[i] = l;
  358.             if (i < T) prnt[i + 1] = l;
  360.             j = son[l];
  361.             son[l] = i;
  363.             prnt[j] = c;
  364.             if (j < T) prnt[j + 1] = c;
  365.             son[c] = j;
  367.             c = l;
  368.         }
  369.     } while ((c = prnt[c]) != 0); /* repeat up to root */
  370. }
  373. void CLzhCompress::EncodeChar(WORD c)
  374. {
  375.     WORD i;
  376.     short j, k;
  378.     i = 0;
  379.     j = 0;
  380.     k = prnt[c + T];
  382.     /* travel from leaf to root */
  383.     do {
  384.         i >>= 1;
  386.         /* if node's address is odd-numbered, choose bigger brother node */
  387.         if (k & 1) i += 0x8000;
  389.         j++;
  390.     } while ((k = prnt[k]) != R);
  391.     Putcode(j, i);
  392.     code = i;
  393.     len = j;
  394.     update(c);
  395. }
  397. void CLzhCompress::EncodePosition(WORD c)
  398. {
  399.     WORD i;
  401.     /* output upper 6 bits by table lookup */
  402.     i = c >> 6;
  403.     Putcode(p_len[i], (WORD)p_code[i] << 8);
  405.     /* output lower 6 bits verbatim */
  406.     Putcode(6, (c & 0x3f) << 10);
  407. }
  409. void CLzhCompress::EncodeEnd(void)
  410. {
  411.     if (putlen) {
  412.         if (fnc_putc(putbuf >> 8) == -1) {
  413. return;
  414.         }
  415.         codesize++;
  416.     }
  417. }
  419. short CLzhCompress::DecodeChar(void)
  420. {
  421.     WORD c;
  423.     c = son[R];
  425.     /* travel from root to leaf, */
  426.     /* choosing the smaller child node (son[]) if the read bit is 0, */
  427.     /* the bigger (son[]+1} if 1 */
  428.     while (c < T) {
  429.         c += GetBit();
  430.         c = son[c];
  431.     }
  432.     c -= T;
  433.     update(c);
  434.     return (short)c;
  435. }
  437. short CLzhCompress::DecodePosition(void)
  438. {
  439.     WORD i, j, c;
  441.     /* recover upper 6 bits from table */
  442.     i = GetByte();
  443.     c = (WORD)d_code[i] << 6;
  444.     j = d_len[i];
  446.     /* read lower 6 bits verbatim */
  447.     j -= 2;
  448.     while (j--) {
  449.         i = (i << 1) + GetBit();
  450.     }
  451.     return (short)(c | (i & 0x3f));
  452. }
  454. /* compression */
  456. void CLzhCompress::Encode(void)  /* compression */
  457. {
  458.     short  i, c, len, r, s, last_match_length;
  460. codesize=0;
  461.     fnc_putc((BYTE)(textsize & 0xff));
  462.     fnc_putc((BYTE)((textsize & 0xff00) >> 8));
  463.     fnc_putc((BYTE)((textsize & 0xff0000L) >> 16));
  464.     fnc_putc((BYTE)((textsize & 0xff000000L) >> 24));
  465.     
  466. if (textsize == 0)
  467.         return;
  469.     textsize = 0;           /* rewind and re-read */
  470.     StartHuff();
  471.     InitTree();
  472.     s = 0;
  473.     r = N - F;
  474.     for (i = s; i < r; i++)
  475.         text_buf[i] = 0x20;
  476.     for (len = 0; len < F && ((c = fnc_getc()) != -1); len++)
  477.         text_buf[r + len] = (unsigned char)c;
  478.     textsize = len;
  479.     for (i = 1; i <= F; i++)
  480.         InsertNode(r - i);
  481.     InsertNode(r);
  482.     do {
  483.         if (match_length > len)
  484.             match_length = len;
  485.         if (match_length <= THRESHOLD) {
  486.             match_length = 1;
  487.             EncodeChar(text_buf[r]);
  488.         } else {
  489.             EncodeChar(255 - THRESHOLD + match_length);
  490.             EncodePosition(match_position);
  491.         }
  492.         last_match_length = match_length;
  493.         for (i = 0; i < last_match_length &&
  494. ((c = fnc_getc()) != -1); i++) {
  495.             DeleteNode(s);
  496.             text_buf[s] = (unsigned char)c;
  497.             if (s < F - 1)
  498.                 text_buf[s + N] = (unsigned char)c;
  499.             s = (s + 1) & (N - 1);
  500.             r = (r + 1) & (N - 1);
  501.             InsertNode(r);
  502.         }
  503.         while (i++ < last_match_length) {
  504.             DeleteNode(s);
  505.             s = (s + 1) & (N - 1);
  506.             r = (r + 1) & (N - 1);
  507.             if (--len) InsertNode(r);
  508.         }
  509.     } while (len > 0);
  511.     EncodeEnd();
  512. }
  514. void CLzhCompress::Decode(void)  /* recover */
  515. {
  516.     short  i, j, k, r, c;
  517.     unsigned long int  count;
  519.     codesize=0;
  520. textsize = (fnc_getc());
  521.     textsize |= (((unsigned long)fnc_getc()) << 8);
  522.     textsize |= (((unsigned long)fnc_getc()) << 16);
  523.     textsize |= (((unsigned long)fnc_getc()) << 24);
  524.     
  525. if (textsize == 0)
  526.         return;
  527.     StartHuff();
  528.     for (i = 0; i < N - F; i++)
  529.         text_buf[i] = 0x20;
  530.     r = N - F;
  531.     for (count = 0; count < textsize; ) {
  532.         c = DecodeChar();
  533.         if (c < 256) {
  534.             if(fnc_putc(c)==-1) {
  535.                 return;
  536.             }
  537.             text_buf[r++] = (unsigned char)c;
  538.             r &= (N - 1);
  539.             count++;
  540.         } else {
  541.             i = (r - DecodePosition() - 1) & (N - 1);
  542.             j = c - 255 + THRESHOLD;
  543.             for (k = 0; k < j; k++) {
  544.                 c = text_buf[(i + k) & (N - 1)];
  545.                 if(fnc_putc(c)==-1) {
  546.                     return;
  547.                 }
  548.                 text_buf[r++] = (unsigned char)c;
  549.                 r &= (N - 1);
  550.                 count++;
  551.             }
  552.         }
  553.         
  554.     }
  556. }
  558. int CLzhCompress::fnc_read_file(BYTE *pBuffer, int nLen)
  559. {
  560. DWORD dwBytes;
  561. dwBytes=0;
  562. ReadFile(hFileIn,pBuffer,nLen,&dwBytes,NULL);
  563. return dwBytes;
  564. }
  566. int CLzhCompress::fnc_write_file(BYTE *pBuffer, int nLen)
  567. {
  568. DWORD dwBytes;
  569. dwBytes=0;
  570. WriteFile(hFileOut,pBuffer,nLen,&dwBytes,NULL);
  571. return dwBytes;
  572. }
  574. int CLzhCompress::fnc_read_memory(BYTE *pBuffer, int nLen)
  575. {
  576. int nCount;
  577. nCount=nLen;
  578. if((nCount+nMemInOff)>nMemInSize)
  579. nCount=nMemInSize-nMemInOff;
  581. memcpy(pBuffer,pMemIn+nMemInOff,nCount);
  582. nMemInOff+=nCount;
  584. return nCount;
  585. }
  587. int CLzhCompress::fnc_write_memory(BYTE *pBuffer, int nLen)
  588. {
  589. int nCount;
  590. nCount=nLen;
  591. if((nCount+nMemOutOff)>nMemOutSize)
  592. nCount=nMemOutSize-nMemOutOff;
  594. memcpy(pMemOut+nMemOutOff,pBuffer,nCount);
  595. nMemOutOff+=nCount;
  597. return nCount;
  598. }
  600. int CLzhCompress::fnc_write(BYTE *ptr, int len)
  601. {
  602. if(freeze_type==0)
  603. return fnc_write_file(ptr,len);
  604. else if(freeze_type==1)
  605. return fnc_write_memory(ptr,len);
  606. return 0;
  607. }
  609. int CLzhCompress::fnc_read(BYTE *ptr, int len)
  610. {
  611. if(freeze_type==0)
  612. return fnc_read_file(ptr,len);
  613. else if(freeze_type==1)
  614. return fnc_read_memory(ptr,len);
  615. return 0;
  616. }
  618. int CLzhCompress::fnc_getc(void)
  619. {
  620. int val;
  622. val=0;
  623. if(fnc_read((BYTE *)&val,1)!=1) return -1;
  625. return val;
  626. }
  628. int CLzhCompress::fnc_putc(int val)
  629. {
  630. if(fnc_write((BYTE *)&val,1)!=1) return -1;
  632. return (int) 0;
  633. }
  636. int CLzhCompress::lzh_freeze_file(char *szInFile, char *szOutFile)
  637. {
  638. hFileIn=CreateFile(szInFile,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,0,NULL);
  639. if(hFileIn==INVALID_HANDLE_VALUE) return -1;
  640. hFileOut=CreateFile(szOutFile,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
  641. if(hFileOut==INVALID_HANDLE_VALUE) {
  642. CloseHandle(hFileIn);
  643. return -1;
  644. }
  646. getbuf=0;
  647. getlen=0;
  648. putbuf=0;
  649. putlen=0;
  650. textsize=GetFileSize(hFileIn,NULL);
  651.     freeze_type=0;
  653. Encode();
  655. CloseHandle(hFileOut);
  656. CloseHandle(hFileIn);
  657. return 0;
  658. }
  660. int CLzhCompress::lzh_freeze_memory(void *pInBuffer, int nInBufLen, void *pOutBuf, int nOutBufLen)
  661. {
  662. pMemIn=(BYTE *)pInBuffer;
  663. nMemInSize=nInBufLen;
  664. pMemOut=(BYTE *)pOutBuf;
  665. nMemOutSize=nOutBufLen;
  666. nMemInOff=0;
  667. nMemOutOff=0;
  669. getbuf=0;
  670. getlen=0;
  671. putbuf=0;
  672. putlen=0;
  673. textsize=nInBufLen;
  674.     freeze_type=1;
  676. Encode();
  678. return 0;
  679. }
  682. int CLzhCompress::lzh_melt_file(char *szInFile, char *szOutFile)
  683. {
  684. hFileIn=CreateFile(szInFile,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,0,NULL);
  685. if(hFileIn==INVALID_HANDLE_VALUE) return -1;
  686. hFileOut=CreateFile(szOutFile,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
  687. if(hFileOut==INVALID_HANDLE_VALUE) {
  688. CloseHandle(hFileIn);
  689. return -1;
  690. }
  692. getbuf=0;
  693. getlen=0;
  694. putbuf=0;
  695. putlen=0;
  696. freeze_type=0;
  698. Decode();
  700. CloseHandle(hFileOut);
  701. CloseHandle(hFileIn);
  702. return 0;
  703. }
  705. int CLzhCompress::lzh_melt_memory(void *pInBuffer, int nInBufLen, void *pOutBuf, int nOutBufLen)
  706. {
  707. pMemIn=(BYTE *)pInBuffer;
  708. nMemInSize=nInBufLen;
  709. pMemOut=(BYTE *)pOutBuf;
  710. nMemOutSize=nOutBufLen;
  711. nMemInOff=0;
  712. nMemOutOff=0;
  714. getbuf=0;
  715. getlen=0;
  716. putbuf=0;
  717. putlen=0;
  718. freeze_type=1;
  720. Decode();
  722. return 0;
  723. }