Mercurial > mplayer.hg
annotate unrarlib.c @ 10252:d275152390ee
I've found some time to implement the encoding support for the new
DivX API. Now it's possible to play and encode movies with the
latest DivX release.
One thing that doesn't work is the new Video Buffer Verifier (VBV)
multipass encoding. The encoder segfaults. Maybe it just isn't
supported with the standard profile of the released binary encoder.
Andreas Hess <jaska@gmx.net>
author | arpi |
---|---|
date | Fri, 06 Jun 2003 19:57:37 +0000 |
parents | 228a767a51fd |
children | 58c6f2998afa |
rev | line source |
---|---|
7446 | 1 /* *************************************************************************** |
2 ** | |
3 ** This file is part of the UniquE RAR File Library. | |
4 ** | |
5 ** Copyright (C) 2000-2002 by Christian Scheurer (www.ChristianScheurer.ch) | |
6 ** UNIX port copyright (c) 2000-2002 by Johannes Winkelmann (jw@tks6.net) | |
7 ** | |
8 ** The contents of this file are subject to the UniquE RAR File Library | |
9 ** License (the "unrarlib-license.txt"). You may not use this file except | |
10 ** in compliance with the License. You may obtain a copy of the License | |
11 ** at http://www.unrarlib.org/license.html. | |
12 ** Software distributed under the License is distributed on an "AS IS" | |
13 ** basis, WITHOUT WARRANTY OF ANY KIND, either express or implied warranty. | |
14 ** | |
15 ** Alternatively, the contents of this file may be used under the terms | |
16 ** of the GNU General Public License Version 2 or later (the "GPL"), in | |
17 ** which case the provisions of the GPL are applicable instead of those | |
18 ** above. If you wish to allow use of your version of this file only | |
19 ** under the terms of the GPL and not to allow others to use your version | |
20 ** of this file under the terms of the UniquE RAR File Library License, | |
21 ** indicate your decision by deleting the provisions above and replace | |
22 ** them with the notice and other provisions required by the GPL. If you | |
23 ** do not delete the provisions above, a recipient may use your version | |
24 ** of this file under the terms of the GPL or the UniquE RAR File Library | |
25 ** License. | |
26 ** | |
27 ************************************************************************** */ | |
28 | |
29 /* *************************************************************************** | |
30 ** | |
31 ** UniquE RAR File Library | |
32 ** The free file lib for the demoscene | |
33 ** multi-OS version (Win32, Linux and SunOS) | |
34 ** | |
35 ***************************************************************************** | |
36 ** | |
37 ** ==> Please configure the program in "unrarlib.h". <== | |
38 ** | |
39 ** RAR decompression code: | |
40 ** (C) Eugene Roshal | |
41 ** Modifications to a FileLib: | |
42 ** (C) 2000-2002 Christian Scheurer aka. UniquE/Vantage (cs@unrarlib.org) | |
43 ** Linux port: | |
44 ** (C) 2000-2002 Johannes Winkelmann (jw@tks6.net) | |
45 ** | |
46 ** The UniquE RAR File Library gives you the ability to access RAR archives | |
47 ** (any compression method supported in RAR v2.0 including Multimedia | |
48 ** Compression and encryption) directly from your program with ease an by | |
49 ** adding only 12kB (6kB UPX-compressed) additional code to your program. | |
50 ** Both solid and normal (recommended for fast random access to the files!) | |
51 ** archives are supported. This FileLib is made for the Demo scene, so it's | |
52 ** designed for easy use within your demos and intros. | |
53 ** Please read "licence.txt" to learn more about how you may use URARFileLib | |
54 ** in your productions. | |
55 ** | |
56 ***************************************************************************** | |
57 ** | |
58 ** ==> see the "CHANGES" file to see what's new | |
59 ** | |
60 ************************************************************************** */ | |
61 | |
62 /* -- include files ------------------------------------------------------- */ | |
63 #include "unrarlib.h" /* include global configuration */ | |
64 /* ------------------------------------------------------------------------ */ | |
65 | |
66 | |
67 | |
68 /* -- global stuff -------------------------------------------------------- */ | |
69 #ifdef _WIN_32 | |
70 | |
71 #include <windows.h> /* WIN32 definitions */ | |
72 #include <stdio.h> | |
73 #include <string.h> | |
74 | |
75 | |
76 #define ENABLE_ACCESS | |
77 | |
78 #define HOST_OS WIN_32 | |
79 | |
80 #define FM_NORMAL 0x00 | |
81 #define FM_RDONLY 0x01 | |
82 #define FM_HIDDEN 0x02 | |
83 #define FM_SYSTEM 0x04 | |
84 #define FM_LABEL 0x08 | |
85 #define FM_DIREC 0x10 | |
86 #define FM_ARCH 0x20 | |
87 | |
88 #define PATHDIVIDER "\\" | |
89 #define CPATHDIVIDER '\\' | |
90 #define MASKALL "*.*" | |
91 | |
92 #define READBINARY "rb" | |
93 #define READTEXT "rt" | |
94 #define UPDATEBINARY "r+b" | |
95 #define CREATEBINARY "w+b" | |
96 #define CREATETEXT "w" | |
97 #define APPENDTEXT "at" | |
98 | |
99 #endif | |
100 | |
101 #ifdef _UNIX | |
102 | |
103 #include <stdio.h> /* LINUX/UNIX definitions */ | |
104 #include <stdlib.h> | |
105 #include <ctype.h> | |
106 #include <string.h> | |
107 | |
108 #define ENABLE_ACCESS | |
109 | |
110 #define HOST_OS UNIX | |
111 | |
112 #define FM_LABEL 0x0000 | |
113 #define FM_DIREC 0x4000 | |
114 | |
115 #define PATHDIVIDER "/" | |
116 #define CPATHDIVIDER '/' | |
117 #define MASKALL "*.*" | |
118 | |
119 #define READBINARY "r" | |
120 #define READTEXT "r" | |
121 #define UPDATEBINARY "r+" | |
122 #define CREATEBINARY "w+" | |
123 #define CREATETEXT "w" | |
124 #define APPENDTEXT "a" | |
125 | |
126 | |
127 /* emulation of the windows API and data types */ | |
128 /* 20-08-2000 Johannes Winkelmann, jw@tks6.net */ | |
129 | |
130 typedef long DWORD; | |
131 typedef short BOOL; | |
132 #define TRUE 1 | |
133 #define FALSE 0 | |
134 | |
135 | |
136 #ifdef _DEBUG_LOG /* define macros for debugging */ | |
137 #include <unistd.h> | |
138 #include <sys/time.h> | |
139 | |
140 DWORD GetTickCount() | |
141 { | |
142 struct timeval tv; | |
143 gettimeofday( &tv, 0 ); | |
144 return (tv.tv_usec / 1000); | |
145 } | |
146 #endif | |
147 | |
148 #endif | |
149 | |
150 | |
151 | |
152 | |
153 | |
154 #ifdef _DEBUG_LOG /* define macros for debugging */ | |
155 | |
156 BOOL debug_log_first_start = TRUE; | |
157 | |
158 #define debug_log(a); debug_log_proc(a, __FILE__, __LINE__); | |
159 #define debug_init(a); debug_init_proc(a); | |
160 | |
161 void debug_log_proc(char *text, char *sourcefile, int sourceline); | |
162 void debug_init_proc(char *file_name); | |
163 | |
164 #else | |
165 #define debug_log(a); /* no debug this time */ | |
166 #define debug_init(a); /* no debug this time */ | |
167 #endif | |
168 | |
169 | |
170 | |
171 | |
172 | |
173 #define MAXWINSIZE 0x100000 | |
174 #define MAXWINMASK (MAXWINSIZE-1) | |
175 #define UNP_MEMORY MAXWINSIZE | |
176 #define Min(x,y) (((x)<(y)) ? (x):(y)) | |
177 #define Max(x,y) (((x)>(y)) ? (x):(y)) | |
178 #define NM 260 | |
179 | |
180 #define SIZEOF_MARKHEAD 7 | |
181 #define SIZEOF_OLDMHD 7 | |
182 #define SIZEOF_NEWMHD 13 | |
183 #define SIZEOF_OLDLHD 21 | |
184 #define SIZEOF_NEWLHD 32 | |
185 #define SIZEOF_SHORTBLOCKHEAD 7 | |
186 #define SIZEOF_LONGBLOCKHEAD 11 | |
187 #define SIZEOF_COMMHEAD 13 | |
188 #define SIZEOF_PROTECTHEAD 26 | |
189 | |
190 | |
191 #define PACK_VER 20 /* version of decompression code*/ | |
192 #define UNP_VER 20 | |
193 #define PROTECT_VER 20 | |
194 | |
195 | |
196 enum { M_DENYREAD,M_DENYWRITE,M_DENYNONE,M_DENYALL }; | |
197 enum { FILE_EMPTY,FILE_ADD,FILE_UPDATE,FILE_COPYOLD,FILE_COPYBLOCK }; | |
198 enum { SUCCESS,WARNING,FATAL_ERROR,CRC_ERROR,LOCK_ERROR,WRITE_ERROR, | |
199 OPEN_ERROR,USER_ERROR,MEMORY_ERROR,USER_BREAK=255,IMM_ABORT=0x8000 }; | |
200 enum { EN_LOCK=1,EN_VOL=2 }; | |
201 enum { SD_MEMORY=1,SD_FILES=2 }; | |
202 enum { NAMES_DONTCHANGE }; | |
203 enum { LOG_ARC=1,LOG_FILE=2 }; | |
204 enum { OLD_DECODE=0,OLD_ENCODE=1,NEW_CRYPT=2 }; | |
205 enum { OLD_UNPACK,NEW_UNPACK }; | |
206 | |
207 | |
208 #define MHD_COMMENT 2 | |
209 #define MHD_LOCK 4 | |
210 #define MHD_PACK_COMMENT 16 | |
211 #define MHD_AV 32 | |
212 #define MHD_PROTECT 64 | |
213 | |
214 #define LHD_SPLIT_BEFORE 1 | |
215 #define LHD_SPLIT_AFTER 2 | |
216 #define LHD_PASSWORD 4 | |
217 #define LHD_COMMENT 8 | |
218 #define LHD_SOLID 16 | |
219 | |
220 #define LHD_WINDOWMASK 0x00e0 | |
221 #define LHD_WINDOW64 0 | |
222 #define LHD_WINDOW128 32 | |
223 #define LHD_WINDOW256 64 | |
224 #define LHD_WINDOW512 96 | |
225 #define LHD_WINDOW1024 128 | |
226 #define LHD_DIRECTORY 0x00e0 | |
227 | |
228 #define LONG_BLOCK 0x8000 | |
229 #define READSUBBLOCK 0x8000 | |
230 | |
231 enum { ALL_HEAD=0,MARK_HEAD=0x72,MAIN_HEAD=0x73,FILE_HEAD=0x74, | |
232 COMM_HEAD=0x75,AV_HEAD=0x76,SUB_HEAD=0x77,PROTECT_HEAD=0x78}; | |
233 enum { EA_HEAD=0x100 }; | |
234 enum { MS_DOS=0,OS2=1,WIN_32=2,UNIX=3 }; | |
235 | |
236 | |
237 struct MarkHeader | |
238 { | |
239 UBYTE Mark[7]; | |
240 }; | |
241 | |
242 | |
243 struct NewMainArchiveHeader | |
244 { | |
245 UWORD HeadCRC; | |
246 UBYTE HeadType; | |
247 UWORD Flags; | |
248 UWORD HeadSize; | |
249 UWORD Reserved; | |
250 UDWORD Reserved1; | |
251 }; | |
252 | |
253 | |
254 struct NewFileHeader | |
255 { | |
256 UWORD HeadCRC; | |
257 UBYTE HeadType; | |
258 UWORD Flags; | |
259 UWORD HeadSize; | |
260 UDWORD PackSize; | |
261 UDWORD UnpSize; | |
262 UBYTE HostOS; | |
263 UDWORD FileCRC; | |
264 UDWORD FileTime; | |
265 UBYTE UnpVer; | |
266 UBYTE Method; | |
267 UWORD NameSize; | |
268 UDWORD FileAttr; | |
269 }; | |
270 | |
271 | |
272 struct BlockHeader | |
273 { | |
274 UWORD HeadCRC; | |
275 UBYTE HeadType; | |
276 UWORD Flags; | |
277 UWORD HeadSize; | |
278 UDWORD DataSize; | |
279 }; | |
280 | |
281 | |
282 struct Decode | |
283 { | |
284 unsigned int MaxNum; | |
285 unsigned int DecodeLen[16]; | |
286 unsigned int DecodePos[16]; | |
287 unsigned int DecodeNum[2]; | |
288 }; | |
289 | |
290 | |
291 struct MarkHeader MarkHead; | |
292 struct NewMainArchiveHeader NewMhd; | |
293 struct NewFileHeader NewLhd; | |
294 struct BlockHeader BlockHead; | |
295 | |
9584 | 296 UBYTE *TempMemory = NULL; /* temporary unpack-buffer */ |
297 char *CommMemory = NULL; | |
298 | |
299 | |
300 UBYTE *UnpMemory = NULL; | |
7446 | 301 char ArgName[NM]; /* current file in rar archive */ |
302 char ArcFileName[NM]; /* file to decompress */ | |
303 | |
304 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION /* mem-to-mem decompression */ | |
305 MemoryFile *MemRARFile; /* pointer to RAR file in memory*/ | |
306 #else | |
307 char ArcName[255]; /* RAR archive name */ | |
308 FILE *ArcPtr; /* input RAR file handler */ | |
309 #endif | |
310 char Password[255]; /* password to decrypt files */ | |
311 | |
312 unsigned char *temp_output_buffer; /* extract files to this pointer*/ | |
313 unsigned long *temp_output_buffer_offset; /* size of temp. extract buffer */ | |
314 | |
315 BOOL FileFound; /* TRUE=use current extracted */ | |
316 /* data FALSE=throw data away, */ | |
317 /* wrong file */ | |
318 int MainHeadSize; | |
319 long CurBlockPos,NextBlockPos; | |
320 | |
321 unsigned long CurUnpRead, CurUnpWrite; | |
322 long UnpPackedSize; | |
323 long DestUnpSize; | |
324 | |
325 UDWORD HeaderCRC; | |
326 int Encryption; | |
327 | |
328 unsigned int UnpWrSize; | |
329 unsigned char *UnpWrAddr; | |
330 unsigned int UnpPtr,WrPtr; | |
331 | |
332 unsigned char PN1,PN2,PN3; | |
333 unsigned short OldKey[4]; | |
334 | |
335 | |
336 | |
337 /* function header definitions */ | |
338 int ReadHeader(int BlockType); | |
339 BOOL ExtrFile(void); | |
340 BOOL ListFile(void); | |
341 int tread(void *stream,void *buf,unsigned len); | |
342 int tseek(void *stream,long offset,int fromwhere); | |
343 BOOL UnstoreFile(void); | |
344 int IsArchive(void); | |
345 int ReadBlock(int BlockType); | |
346 unsigned int UnpRead(unsigned char *Addr,unsigned int Count); | |
347 void UnpInitData(void); | |
348 void Unpack(unsigned char *UnpAddr); | |
349 UBYTE DecodeAudio(int Delta); | |
350 static void DecodeNumber(struct Decode *Dec); | |
351 void UpdKeys(UBYTE *Buf); | |
352 void SetCryptKeys(char *Password); | |
353 void SetOldKeys(char *Password); | |
354 void DecryptBlock(unsigned char *Buf); | |
355 void InitCRC(void); | |
356 UDWORD CalcCRC32(UDWORD StartCRC,UBYTE *Addr,UDWORD Size); | |
357 void UnpReadBuf(int FirstBuf); | |
358 void ReadTables(void); | |
359 static void ReadLastTables(void); | |
360 static void MakeDecodeTables(unsigned char *LenTab, | |
361 struct Decode *Dec, | |
362 int Size); | |
10127
228a767a51fd
avoid symbol clash with never samba versions (btw, unrarlib.c is full of global variables, with common names :( and it's a bit bloated, I think)
alex
parents:
9584
diff
changeset
|
363 static int my_stricomp(char *Str1,char *Str2); |
7446 | 364 /* ------------------------------------------------------------------------ */ |
365 | |
366 | |
367 /* -- global functions ---------------------------------------------------- */ | |
368 | |
369 int urarlib_get(void *output, | |
370 unsigned long *size, | |
371 char *filename, | |
372 void *rarfile, | |
373 char *libpassword) | |
374 /* Get a file from a RAR file to the "output" buffer. The UniquE RAR FileLib | |
375 * does everything from allocating memory, decrypting and unpacking the file | |
376 * from the archive. TRUE is returned if the file could be successfully | |
377 * extracted, else a FALSE indicates a failure. | |
378 */ | |
379 { | |
380 BOOL retcode = FALSE; | |
381 | |
382 #ifdef _DEBUG_LOG | |
383 int str_offs; /* used for debug-strings */ | |
384 char DebugMsg[500]; /* used to compose debug msg */ | |
385 | |
386 if(debug_log_first_start) | |
387 { | |
388 debug_log_first_start=FALSE; /* only create a new log file */ | |
389 debug_init(_DEBUG_LOG_FILE); /* on startup */ | |
390 } | |
391 | |
392 #endif | |
393 | |
394 InitCRC(); /* init some vars */ | |
395 | |
396 strcpy(ArgName, filename); /* set file(s) to extract */ | |
397 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
398 MemRARFile = rarfile; /* set pointer to mem-RAR file */ | |
399 #else | |
400 strcpy(ArcName, rarfile); /* set RAR file name */ | |
401 #endif | |
402 if(libpassword != NULL) | |
403 strcpy(Password, libpassword); /* init password */ | |
404 | |
405 temp_output_buffer = NULL; | |
406 temp_output_buffer_offset=size; /* set size of the temp buffer */ | |
407 | |
408 #ifdef _DEBUG_LOG | |
409 sprintf(DebugMsg, "Extracting >%s< from >%s< (password is >%s<)...", | |
410 filename, (char*)rarfile, libpassword); | |
411 debug_log(DebugMsg); | |
412 #endif | |
413 | |
414 retcode = ExtrFile(); /* unpack file now! */ | |
415 | |
416 memset(Password,0,sizeof(Password)); /* clear password */ | |
417 | |
418 #ifndef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
419 if (ArcPtr!=NULL){ | |
420 fclose(ArcPtr); | |
421 ArcPtr = NULL; | |
422 } | |
423 #endif | |
424 | |
9584 | 425 if(UnpMemory) free(UnpMemory); /* free memory */ |
426 if(TempMemory) free(TempMemory); | |
427 if(CommMemory) free(CommMemory); | |
7446 | 428 UnpMemory=NULL; |
429 TempMemory=NULL; | |
430 CommMemory=NULL; | |
431 | |
432 | |
433 if(retcode == FALSE) | |
434 { | |
9584 | 435 if(temp_output_buffer) /* free memory and return NULL */ |
436 free(temp_output_buffer); | |
7446 | 437 temp_output_buffer=NULL; |
438 *(DWORD*)output=0; /* pointer on errors */ | |
439 *size=0; | |
440 #ifdef _DEBUG_LOG | |
441 | |
442 | |
443 /* sorry for this ugly code, but older SunOS gcc compilers don't support */ | |
444 /* white spaces within strings */ | |
445 str_offs = sprintf(DebugMsg, "Error - couldn't extract "); | |
446 str_offs += sprintf(DebugMsg + str_offs, ">%s<", filename); | |
447 str_offs += sprintf(DebugMsg + str_offs, " and allocated "); | |
448 str_offs += sprintf(DebugMsg + str_offs, "%u Bytes", (unsigned int)*size); | |
449 str_offs += sprintf(DebugMsg + str_offs, " of unused memory!"); | |
450 | |
451 } else | |
452 { | |
453 sprintf(DebugMsg, "Extracted %u Bytes.", (unsigned int)*size); | |
454 } | |
455 debug_log(DebugMsg); | |
456 #else | |
457 } | |
458 #endif | |
459 *(DWORD*)output=(DWORD)temp_output_buffer;/* return pointer for unpacked*/ | |
460 /* data */ | |
461 | |
462 return retcode; | |
463 } | |
464 | |
465 | |
466 int urarlib_list(void *rarfile, ArchiveList_struct *list) | |
467 { | |
468 ArchiveList_struct *tmp_List = NULL; | |
469 int NoOfFilesInArchive = 0; /* number of files in archive */ | |
470 | |
471 #ifdef _DEBUG_LOG | |
472 if(debug_log_first_start) | |
473 { | |
474 debug_log_first_start=FALSE; /* only create a new log file */ | |
475 debug_init(_DEBUG_LOG_FILE); /* on startup */ | |
476 } | |
477 #endif | |
478 | |
479 InitCRC(); /* init some vars */ | |
480 | |
481 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
482 MemRARFile = rarfile; /* assign pointer to RAR file */ | |
483 MemRARFile->offset = 0; | |
484 if (!IsArchive()) | |
485 { | |
486 debug_log("Not a RAR file"); | |
487 return NoOfFilesInArchive; /* error => exit! */ | |
488 } | |
489 #else | |
490 /* open and identify archive */ | |
491 if ((ArcPtr=fopen(rarfile,READBINARY))!=NULL) | |
492 { | |
493 if (!IsArchive()) | |
494 { | |
495 debug_log("Not a RAR file"); | |
496 fclose(ArcPtr); | |
497 ArcPtr = NULL; | |
498 return NoOfFilesInArchive; /* error => exit! */ | |
499 } | |
500 } | |
501 else { | |
502 debug_log("Error opening file."); | |
503 return NoOfFilesInArchive; | |
504 } | |
505 #endif | |
506 | |
507 if ((UnpMemory=malloc(UNP_MEMORY))==NULL) | |
508 { | |
509 debug_log("Can't allocate memory for decompression!"); | |
510 return NoOfFilesInArchive; | |
511 } | |
512 | |
513 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
514 MemRARFile->offset+=NewMhd.HeadSize-MainHeadSize; | |
515 #else | |
516 tseek(ArcPtr,NewMhd.HeadSize-MainHeadSize,SEEK_CUR); | |
517 #endif | |
518 (*(DWORD*)list) = (DWORD)NULL; /* init file list */ | |
519 /* do while file is not extracted and there's no error */ | |
520 while (TRUE) | |
521 { | |
522 if (ReadBlock(FILE_HEAD | READSUBBLOCK) <= 0) /* read name of the next */ | |
523 { /* file within the RAR archive */ | |
524 debug_log("Couldn't read next filename from archive (I/O error)."); | |
525 break; /* error, file not found in */ | |
526 } /* archive or I/O error */ | |
527 if (BlockHead.HeadType==SUB_HEAD) | |
528 { | |
529 debug_log("Sorry, sub-headers not supported."); | |
530 break; /* error => exit */ | |
531 } | |
532 | |
533 if((void*)(*(DWORD*)list) == NULL) /* first entry */ | |
534 { | |
535 tmp_List = malloc(sizeof(ArchiveList_struct)); | |
536 tmp_List->next = NULL; | |
537 | |
538 (*(DWORD*)list) = (DWORD)tmp_List; | |
539 | |
540 } else /* add entry */ | |
541 { | |
542 tmp_List->next = malloc(sizeof(ArchiveList_struct)); | |
543 tmp_List = (ArchiveList_struct*) tmp_List->next; | |
544 tmp_List->next = NULL; | |
545 } | |
546 | |
547 tmp_List->item.Name = malloc(NewLhd.NameSize + 1); | |
548 strcpy(tmp_List->item.Name, ArcFileName); | |
549 tmp_List->item.NameSize = NewLhd.NameSize; | |
550 tmp_List->item.PackSize = NewLhd.PackSize; | |
551 tmp_List->item.UnpSize = NewLhd.UnpSize; | |
552 tmp_List->item.HostOS = NewLhd.HostOS; | |
553 tmp_List->item.FileCRC = NewLhd.FileCRC; | |
554 tmp_List->item.FileTime = NewLhd.FileTime; | |
555 tmp_List->item.UnpVer = NewLhd.UnpVer; | |
556 tmp_List->item.Method = NewLhd.Method; | |
557 tmp_List->item.FileAttr = NewLhd.FileAttr; | |
558 | |
559 NoOfFilesInArchive++; /* count files */ | |
560 | |
561 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
562 MemRARFile->offset = NextBlockPos; | |
563 #else | |
564 if (ArcPtr!=NULL) tseek(ArcPtr,NextBlockPos,SEEK_SET); | |
565 #endif | |
566 | |
567 }; | |
568 | |
569 /* free memory, clear password and close archive */ | |
570 memset(Password,0,sizeof(Password)); /* clear password */ | |
571 #ifndef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
572 if (ArcPtr!=NULL){ | |
573 fclose(ArcPtr); | |
574 ArcPtr = NULL; | |
575 } | |
576 #endif | |
577 | |
578 free(UnpMemory); /* free memory */ | |
579 free(TempMemory); | |
580 free(CommMemory); | |
581 UnpMemory=NULL; | |
582 TempMemory=NULL; | |
583 CommMemory=NULL; | |
584 | |
585 return NoOfFilesInArchive; | |
586 } | |
587 | |
588 | |
589 | |
590 /* urarlib_freelist: | |
591 * (after the suggestion and code of Duy Nguyen, Sean O'Blarney | |
592 * and Johannes Winkelmann who independently wrote a patch) | |
593 * free the memory of a ArchiveList_struct created by urarlib_list. | |
594 * | |
595 * input: *list pointer to an ArchiveList_struct | |
596 * output: - | |
597 */ | |
598 | |
599 void urarlib_freelist(ArchiveList_struct *list) | |
600 { | |
601 ArchiveList_struct* tmp = list; | |
602 | |
603 while ( list ) { | |
604 tmp = list->next; | |
605 free( list->item.Name ); | |
606 free( list ); | |
607 list = tmp; | |
608 } | |
609 } | |
610 | |
611 | |
612 /* ------------------------------------------------------------------------ */ | |
613 | |
614 | |
615 | |
616 | |
617 | |
618 | |
619 | |
620 | |
621 | |
622 | |
623 | |
624 | |
625 | |
626 | |
627 | |
628 | |
629 | |
630 /**************************************************************************** | |
631 **************************************************************************** | |
632 **************************************************************************** | |
633 **************************************************************************** | |
634 ******* ******* | |
635 ******* ******* | |
636 ******* ******* | |
637 ******* B L O C K I / O ******* | |
638 ******* ******* | |
639 ******* ******* | |
640 ******* ******* | |
641 **************************************************************************** | |
642 **************************************************************************** | |
643 **************************************************************************** | |
644 ****************************************************************************/ | |
645 | |
646 | |
647 | |
648 #define GetHeaderByte(N) Header[N] | |
649 | |
650 #define GetHeaderWord(N) (Header[N]+((UWORD)Header[N+1]<<8)) | |
651 | |
652 #define GetHeaderDword(N) (Header[N]+((UWORD)Header[N+1]<<8)+\ | |
653 ((UDWORD)Header[N+2]<<16)+\ | |
654 ((UDWORD)Header[N+3]<<24)) | |
655 | |
656 | |
657 int ReadBlock(int BlockType) | |
658 { | |
659 struct NewFileHeader SaveFileHead; | |
660 int Size=0,ReadSubBlock=0; | |
661 static int LastBlock; | |
662 memcpy(&SaveFileHead,&NewLhd,sizeof(SaveFileHead)); | |
663 if (BlockType & READSUBBLOCK) | |
664 ReadSubBlock=1; | |
665 BlockType &= 0xff; | |
666 { | |
667 while (1) | |
668 { | |
669 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
670 CurBlockPos=MemRARFile->offset; /* get offset of mem-file */ | |
671 #else | |
672 CurBlockPos=ftell(ArcPtr); | |
673 #endif | |
674 Size=ReadHeader(FILE_HEAD); | |
675 if (Size!=0) | |
676 { | |
677 if (NewLhd.HeadSize<SIZEOF_SHORTBLOCKHEAD) | |
678 return(0); | |
679 NextBlockPos=CurBlockPos+NewLhd.HeadSize; | |
680 if (NewLhd.Flags & LONG_BLOCK) | |
681 NextBlockPos+=NewLhd.PackSize; | |
682 if (NextBlockPos<=CurBlockPos) | |
683 return(0); | |
684 } | |
685 | |
686 if (Size > 0 && BlockType!=SUB_HEAD) | |
687 LastBlock=BlockType; | |
688 if (Size==0 || BlockType==ALL_HEAD || NewLhd.HeadType==BlockType || | |
689 (NewLhd.HeadType==SUB_HEAD && ReadSubBlock && LastBlock==BlockType)) | |
690 break; | |
691 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
692 MemRARFile->offset = NextBlockPos; | |
693 #else | |
694 tseek(ArcPtr, NextBlockPos, SEEK_SET); | |
695 #endif | |
696 } | |
697 } | |
698 | |
699 BlockHead.HeadCRC=NewLhd.HeadCRC; | |
700 BlockHead.HeadType=NewLhd.HeadType; | |
701 BlockHead.Flags=NewLhd.Flags; | |
702 BlockHead.HeadSize=NewLhd.HeadSize; | |
703 BlockHead.DataSize=NewLhd.PackSize; | |
704 | |
705 if (BlockType!=NewLhd.HeadType) BlockType=ALL_HEAD; | |
706 | |
707 if((FILE_HEAD == BlockType) && (Size>0)) | |
708 { | |
709 NewLhd.NameSize=Min(NewLhd.NameSize,sizeof(ArcFileName)-1); | |
710 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
711 tread(MemRARFile, ArcFileName, NewLhd.NameSize); | |
712 #else | |
713 tread(ArcPtr,ArcFileName,NewLhd.NameSize); | |
714 #endif | |
715 ArcFileName[NewLhd.NameSize]=0; | |
716 #ifdef _DEBUG_LOG | |
717 if (NewLhd.HeadCRC!=(UWORD)~CalcCRC32(HeaderCRC,(UBYTE*)&ArcFileName[0], | |
718 NewLhd.NameSize)) | |
719 { | |
720 debug_log("file header broken"); | |
721 } | |
722 #endif | |
723 Size+=NewLhd.NameSize; | |
724 } else | |
725 { | |
726 memcpy(&NewLhd,&SaveFileHead,sizeof(NewLhd)); | |
727 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
728 MemRARFile->offset = CurBlockPos; | |
729 #else | |
730 tseek(ArcPtr,CurBlockPos,SEEK_SET); | |
731 #endif | |
732 } | |
733 | |
734 | |
735 return(Size); | |
736 } | |
737 | |
738 | |
739 int ReadHeader(int BlockType) | |
740 { | |
741 int Size = 0; | |
742 unsigned char Header[64]; | |
743 switch(BlockType) | |
744 { | |
745 case MAIN_HEAD: | |
746 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
747 Size=tread(MemRARFile, Header, SIZEOF_NEWMHD); | |
748 #else | |
749 Size=tread(ArcPtr,Header,SIZEOF_NEWMHD); | |
750 #endif | |
751 NewMhd.HeadCRC=(unsigned short)GetHeaderWord(0); | |
752 NewMhd.HeadType=GetHeaderByte(2); | |
753 NewMhd.Flags=(unsigned short)GetHeaderWord(3); | |
754 NewMhd.HeadSize=(unsigned short)GetHeaderWord(5); | |
755 NewMhd.Reserved=(unsigned short)GetHeaderWord(7); | |
756 NewMhd.Reserved1=GetHeaderDword(9); | |
757 HeaderCRC=CalcCRC32(0xFFFFFFFFL,&Header[2],SIZEOF_NEWMHD-2); | |
758 break; | |
759 case FILE_HEAD: | |
760 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
761 Size=tread(MemRARFile, Header, SIZEOF_NEWLHD); | |
762 #else | |
763 Size=tread(ArcPtr,Header,SIZEOF_NEWLHD); | |
764 #endif | |
765 NewLhd.HeadCRC=(unsigned short)GetHeaderWord(0); | |
766 NewLhd.HeadType=GetHeaderByte(2); | |
767 NewLhd.Flags=(unsigned short)GetHeaderWord(3); | |
768 NewLhd.HeadSize=(unsigned short)GetHeaderWord(5); | |
769 NewLhd.PackSize=GetHeaderDword(7); | |
770 NewLhd.UnpSize=GetHeaderDword(11); | |
771 NewLhd.HostOS=GetHeaderByte(15); | |
772 NewLhd.FileCRC=GetHeaderDword(16); | |
773 NewLhd.FileTime=GetHeaderDword(20); | |
774 NewLhd.UnpVer=GetHeaderByte(24); | |
775 NewLhd.Method=GetHeaderByte(25); | |
776 NewLhd.NameSize=(unsigned short)GetHeaderWord(26); | |
777 NewLhd.FileAttr=GetHeaderDword(28); | |
778 HeaderCRC=CalcCRC32(0xFFFFFFFFL,&Header[2],SIZEOF_NEWLHD-2); | |
779 break; | |
780 | |
781 #ifdef _DEBUG_LOG | |
782 case COMM_HEAD: /* log errors in case of debug */ | |
783 debug_log("Comment headers not supported! "\ | |
784 "Please create archives without comments."); | |
785 break; | |
786 case PROTECT_HEAD: | |
787 debug_log("Protected headers not supported!"); | |
788 break; | |
789 case ALL_HEAD: | |
790 debug_log("ShortBlockHeader not supported!"); | |
791 break; | |
792 default: | |
793 debug_log("Unknown//unsupported !"); | |
794 #else | |
795 default: /* else do nothing */ | |
796 break; | |
797 #endif | |
798 } | |
799 return(Size); | |
800 } | |
801 | |
802 /* ************************************************************************** | |
803 **************************************************************************** | |
804 **************************************************************************** | |
805 ************************************************************************** */ | |
806 | |
807 | |
808 | |
809 | |
810 | |
811 | |
812 | |
813 | |
814 | |
815 | |
816 | |
817 | |
818 | |
819 | |
820 | |
821 | |
822 | |
823 /* ************************************************************************** | |
824 **************************************************************************** | |
825 **************************************************************************** | |
826 **************************************************************************** | |
827 ******* ******* | |
828 ******* ******* | |
829 ******* ******* | |
830 ******* E X T R A C T L O O P ******* | |
831 ******* ******* | |
832 ******* ******* | |
833 ******* ******* | |
834 **************************************************************************** | |
835 **************************************************************************** | |
836 **************************************************************************** | |
837 ************************************************************************** */ | |
838 | |
839 | |
840 int IsArchive(void) | |
841 { | |
842 #ifdef _DEBUG_LOG | |
843 int str_offs; /* used for debug-strings */ | |
844 char DebugMsg[500]; /* used to compose debug msg */ | |
845 #endif | |
846 | |
847 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
848 if (tread(MemRARFile, MarkHead.Mark, SIZEOF_MARKHEAD) != SIZEOF_MARKHEAD) | |
849 return(FALSE); | |
850 #else | |
851 if (tread(ArcPtr,MarkHead.Mark,SIZEOF_MARKHEAD)!=SIZEOF_MARKHEAD) | |
852 return(FALSE); | |
853 #endif | |
854 /* Old archive => error */ | |
855 if (MarkHead.Mark[0]==0x52 && MarkHead.Mark[1]==0x45 && | |
856 MarkHead.Mark[2]==0x7e && MarkHead.Mark[3]==0x5e) | |
857 { | |
858 debug_log("Attention: format as OLD detected! Can't handel archive!"); | |
859 } | |
860 else | |
861 /* original RAR v2.0 */ | |
862 if ((MarkHead.Mark[0]==0x52 && MarkHead.Mark[1]==0x61 && /* original */ | |
863 MarkHead.Mark[2]==0x72 && MarkHead.Mark[3]==0x21 && /* RAR header*/ | |
864 MarkHead.Mark[4]==0x1a && MarkHead.Mark[5]==0x07 && | |
865 MarkHead.Mark[6]==0x00) || | |
866 /* "UniquE!" - header */ | |
867 (MarkHead.Mark[0]=='U' && MarkHead.Mark[1]=='n' && /* "UniquE!" */ | |
868 MarkHead.Mark[2]=='i' && MarkHead.Mark[3]=='q' && /* header */ | |
869 MarkHead.Mark[4]=='u' && MarkHead.Mark[5]=='E' && | |
870 MarkHead.Mark[6]=='!')) | |
871 | |
872 { | |
873 if (ReadHeader(MAIN_HEAD)!=SIZEOF_NEWMHD) | |
874 return(FALSE); | |
875 } else | |
876 { | |
877 | |
878 #ifdef _DEBUG_LOG | |
879 /* sorry for this ugly code, but older SunOS gcc compilers don't */ | |
880 /* support white spaces within strings */ | |
881 str_offs = sprintf(DebugMsg, "unknown archive type (only plain RAR "); | |
882 str_offs += sprintf(DebugMsg + str_offs, "supported (normal and solid "); | |
883 str_offs += sprintf(DebugMsg + str_offs, "archives), SFX and Volumes "); | |
884 str_offs += sprintf(DebugMsg + str_offs, "are NOT supported!)"); | |
885 | |
886 debug_log(DebugMsg); | |
887 #endif | |
888 | |
889 } | |
890 | |
891 | |
892 MainHeadSize=SIZEOF_NEWMHD; | |
893 | |
894 return(TRUE); | |
895 } | |
896 | |
897 | |
898 BOOL ExtrFile(void) | |
899 { | |
900 BOOL ReturnCode=TRUE; | |
901 FileFound=FALSE; /* no file found by default */ | |
902 | |
903 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
904 MemRARFile->offset = 0; /* start reading from offset 0 */ | |
905 if (!IsArchive()) | |
906 { | |
907 debug_log("Not a RAR file"); | |
908 return FALSE; /* error => exit! */ | |
909 } | |
910 | |
911 #else | |
912 /* open and identify archive */ | |
913 if ((ArcPtr=fopen(ArcName,READBINARY))!=NULL) | |
914 { | |
915 if (!IsArchive()) | |
916 { | |
917 debug_log("Not a RAR file"); | |
918 fclose(ArcPtr); | |
919 ArcPtr = NULL; | |
920 return FALSE; /* error => exit! */ | |
921 } | |
922 } else | |
923 { | |
924 debug_log("Error opening file."); | |
925 return FALSE; | |
926 } | |
927 #endif | |
928 | |
929 | |
930 if ((UnpMemory=malloc(UNP_MEMORY))==NULL) | |
931 { | |
932 debug_log("Can't allocate memory for decompression!"); | |
933 return FALSE; | |
934 } | |
935 | |
936 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
937 MemRARFile->offset+=NewMhd.HeadSize-MainHeadSize; | |
938 #else | |
939 tseek(ArcPtr,NewMhd.HeadSize-MainHeadSize,SEEK_CUR); | |
940 #endif | |
941 | |
942 /* do while file is not extracted and there's no error */ | |
943 do | |
944 { | |
945 | |
946 if (ReadBlock(FILE_HEAD | READSUBBLOCK) <= 0) /* read name of the next */ | |
947 { /* file within the RAR archive */ | |
948 /* | |
949 * | |
950 * 21.11.2000 UnQ There's a problem with some linux distros when a file | |
951 * can not be found in an archive. | |
952 * | |
953 * debug_log("Couldn't read next filename from archive (I/O error)."); | |
954 * | |
955 */ | |
956 ReturnCode=FALSE; | |
957 break; /* error, file not found in */ | |
958 } /* archive or I/O error */ | |
959 if (BlockHead.HeadType==SUB_HEAD) | |
960 { | |
961 debug_log("Sorry, sub-headers not supported."); | |
962 ReturnCode=FALSE; | |
963 break; /* error => exit */ | |
964 } | |
965 | |
966 | |
10127
228a767a51fd
avoid symbol clash with never samba versions (btw, unrarlib.c is full of global variables, with common names :( and it's a bit bloated, I think)
alex
parents:
9584
diff
changeset
|
967 if(TRUE == (FileFound=(my_stricomp(ArgName, ArcFileName) == 0))) |
7446 | 968 /* *** file found! *** */ |
969 { | |
970 { | |
971 temp_output_buffer=malloc(NewLhd.UnpSize);/* allocate memory for the*/ | |
972 } | |
973 *temp_output_buffer_offset=0; /* file. The default offset */ | |
974 /* within the buffer is 0 */ | |
975 | |
976 if(temp_output_buffer == NULL) | |
977 { | |
978 debug_log("can't allocate memory for the file decompression"); | |
979 ReturnCode=FALSE; | |
980 break; /* error, can't extract file! */ | |
981 } | |
982 | |
983 | |
984 } | |
985 | |
986 /* in case of a solid archive, we need to decompress any single file till | |
987 * we have found the one we are looking for. In case of normal archives | |
988 * (recommended!!), we skip the files until we are sure that it is the | |
989 * one we want. | |
990 */ | |
991 if((NewMhd.Flags & 0x08) || FileFound) | |
992 { | |
993 if (NewLhd.UnpVer<13 || NewLhd.UnpVer>UNP_VER) | |
994 { | |
995 debug_log("unknown compression method"); | |
996 ReturnCode=FALSE; | |
997 break; /* error, can't extract file! */ | |
998 } | |
999 | |
1000 CurUnpRead=CurUnpWrite=0; | |
1001 if ((*Password!=0) && (NewLhd.Flags & LHD_PASSWORD)) | |
1002 Encryption=NewLhd.UnpVer; | |
1003 else | |
1004 Encryption=0; | |
1005 if (Encryption) SetCryptKeys(Password); | |
1006 | |
1007 UnpPackedSize=NewLhd.PackSize; | |
1008 DestUnpSize=NewLhd.UnpSize; | |
1009 | |
1010 if (NewLhd.Method==0x30) | |
1011 { | |
1012 UnstoreFile(); | |
1013 } else | |
1014 { | |
1015 Unpack(UnpMemory); | |
1016 } | |
1017 | |
1018 | |
1019 | |
1020 #ifdef _DO_CRC32_CHECK /* calculate CRC32 */ | |
1021 if((UBYTE*)temp_output_buffer != NULL) | |
1022 { | |
1023 if(NewLhd.FileCRC!=~CalcCRC32(0xFFFFFFFFL, | |
1024 (UBYTE*)temp_output_buffer, | |
1025 NewLhd.UnpSize)) | |
1026 { | |
1027 debug_log("CRC32 error - file couldn't be decompressed correctly!"); | |
1028 ReturnCode=FALSE; | |
1029 break; /* error, can't extract file! */ | |
1030 } | |
1031 } | |
1032 #endif | |
1033 | |
1034 } | |
1035 | |
1036 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
1037 MemRARFile->offset = NextBlockPos; | |
1038 #else | |
1039 if (ArcPtr!=NULL) tseek(ArcPtr,NextBlockPos,SEEK_SET); | |
1040 #endif | |
10127
228a767a51fd
avoid symbol clash with never samba versions (btw, unrarlib.c is full of global variables, with common names :( and it's a bit bloated, I think)
alex
parents:
9584
diff
changeset
|
1041 } while(my_stricomp(ArgName, ArcFileName) != 0);/* exit if file is extracted */ |
7446 | 1042 |
1043 /* free memory, clear password and close archive */ | |
1044 free(UnpMemory); | |
1045 UnpMemory=NULL; | |
1046 #ifndef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
1047 if (ArcPtr!=NULL){ | |
1048 fclose(ArcPtr); | |
1049 ArcPtr = NULL; | |
1050 } | |
1051 #endif | |
1052 | |
1053 return ReturnCode; /* file extracted successful! */ | |
1054 } | |
1055 | |
1056 /* ************************************************************************** | |
1057 **************************************************************************** | |
1058 **************************************************************************** | |
1059 ************************************************************************** */ | |
1060 | |
1061 | |
1062 | |
1063 | |
1064 | |
1065 | |
1066 | |
1067 | |
1068 | |
1069 | |
1070 | |
1071 | |
1072 | |
1073 | |
1074 | |
1075 | |
1076 | |
1077 | |
1078 /* ************************************************************************** | |
1079 **************************************************************************** | |
1080 **************************************************************************** | |
1081 **************************************************************************** | |
1082 ******* ******* | |
1083 ******* ******* | |
1084 ******* ******* | |
1085 ******* G L O B A L F U N C T I O N S ******* | |
1086 ******* ******* | |
1087 ******* ******* | |
1088 ******* ******* | |
1089 **************************************************************************** | |
1090 **************************************************************************** | |
1091 **************************************************************************** | |
1092 ************************************************************************** */ | |
1093 | |
1094 | |
1095 int tread(void *stream,void *buf,unsigned len) | |
1096 { | |
1097 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
1098 | |
1099 if(((MemRARFile->offset + len) > MemRARFile->size) || (len == 0)) | |
1100 return 0; | |
1101 | |
1102 memcpy(buf, | |
1103 (BYTE*)(((MemoryFile*)stream)->data)+((MemoryFile*)stream)->offset, | |
1104 len % ((((MemoryFile*)stream)->size) - 1)); | |
1105 | |
1106 MemRARFile->offset+=len; /* update read pointer */ | |
1107 return len % ((((MemoryFile*)stream)->size) - 1); | |
1108 #else | |
1109 return(fread(buf,1,len,(FILE*)stream)); | |
1110 #endif | |
1111 } | |
1112 | |
1113 | |
1114 #ifndef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
1115 int tseek(void *stream,long offset,int fromwhere) | |
1116 { | |
1117 return(fseek((FILE*)stream,offset,fromwhere)); | |
1118 } | |
1119 #endif | |
1120 | |
1121 | |
10127
228a767a51fd
avoid symbol clash with never samba versions (btw, unrarlib.c is full of global variables, with common names :( and it's a bit bloated, I think)
alex
parents:
9584
diff
changeset
|
1122 static char* my_strupper(char *Str) |
7446 | 1123 { |
1124 char *ChPtr; | |
1125 for (ChPtr=Str;*ChPtr;ChPtr++) | |
1126 *ChPtr=(char)toupper(*ChPtr); | |
1127 return(Str); | |
1128 } | |
1129 | |
10127
228a767a51fd
avoid symbol clash with never samba versions (btw, unrarlib.c is full of global variables, with common names :( and it's a bit bloated, I think)
alex
parents:
9584
diff
changeset
|
1130 |
228a767a51fd
avoid symbol clash with never samba versions (btw, unrarlib.c is full of global variables, with common names :( and it's a bit bloated, I think)
alex
parents:
9584
diff
changeset
|
1131 static int my_stricomp(char *Str1,char *Str2) |
7446 | 1132 /* compare strings without regard of '\' and '/' */ |
1133 { | |
1134 char S1[512],S2[512]; | |
1135 char *chptr; | |
1136 | |
1137 strncpy(S1,Str1,sizeof(S1)); | |
1138 strncpy(S2,Str2,sizeof(S2)); | |
1139 | |
1140 while((chptr = strchr(S1, '\\')) != NULL) /* ignore backslash */ | |
1141 { | |
1142 *chptr = '_'; | |
1143 } | |
1144 | |
1145 while((chptr = strchr(S2, '\\')) != NULL) /* ignore backslash */ | |
1146 { | |
1147 *chptr = '_'; | |
1148 } | |
1149 | |
1150 while((chptr = strchr(S1, '/')) != NULL) /* ignore slash */ | |
1151 { | |
1152 *chptr = '_'; | |
1153 } | |
1154 | |
1155 while((chptr = strchr(S2, '/')) != NULL) /* ignore slash */ | |
1156 { | |
1157 *chptr = '_'; | |
1158 } | |
1159 | |
10127
228a767a51fd
avoid symbol clash with never samba versions (btw, unrarlib.c is full of global variables, with common names :( and it's a bit bloated, I think)
alex
parents:
9584
diff
changeset
|
1160 return(strcmp(my_strupper(S1),my_strupper(S2))); |
7446 | 1161 } |
1162 | |
1163 | |
1164 /* ************************************************************************** | |
1165 **************************************************************************** | |
1166 **************************************************************************** | |
1167 ************************************************************************** */ | |
1168 | |
1169 | |
1170 | |
1171 | |
1172 | |
1173 | |
1174 | |
1175 | |
1176 | |
1177 | |
1178 | |
1179 | |
1180 | |
1181 | |
1182 | |
1183 | |
1184 | |
1185 | |
1186 /* ************************************************************************** | |
1187 **************************************************************************** | |
1188 **************************************************************************** | |
1189 **************************************************************************** | |
1190 ******* ******* | |
1191 ******* ******* | |
1192 ******* ******* | |
1193 ******* U N P A C K C O D E ******* | |
1194 ******* ******* | |
1195 ******* ******* | |
1196 ******* ******* | |
1197 **************************************************************************** | |
1198 **************************************************************************** | |
1199 **************************************************************************** | |
1200 ************************************************************************** */ | |
1201 | |
1202 | |
1203 /* ***************************** | |
1204 * ** unpack stored RAR files ** | |
1205 * *****************************/ | |
1206 | |
1207 BOOL UnstoreFile(void) | |
1208 { | |
1209 if ((long)(*temp_output_buffer_offset=UnpRead(temp_output_buffer, | |
1210 NewLhd.UnpSize))==-1) | |
1211 { | |
1212 debug_log("Read error of stored file!"); | |
1213 return FALSE; | |
1214 } | |
1215 return TRUE; | |
1216 } | |
1217 | |
1218 | |
1219 | |
1220 | |
1221 /* **************************************** | |
1222 * ** RAR decompression code starts here ** | |
1223 * ****************************************/ | |
1224 | |
1225 #define NC 298 /* alphabet = {0,1,2, .,NC - 1} */ | |
1226 #define DC 48 | |
1227 #define RC 28 | |
1228 #define BC 19 | |
1229 #define MC 257 | |
1230 | |
1231 enum {CODE_HUFFMAN=0,CODE_LZ=1,CODE_LZ2=2,CODE_REPEATLZ=3,CODE_CACHELZ=4, | |
1232 CODE_STARTFILE=5,CODE_ENDFILE=6,CODE_STARTMM=8,CODE_ENDMM=7, | |
1233 CODE_MMDELTA=9}; | |
1234 | |
1235 struct AudioVariables | |
1236 { | |
1237 int K1,K2,K3,K4,K5; | |
1238 int D1,D2,D3,D4; | |
1239 int LastDelta; | |
1240 unsigned int Dif[11]; | |
1241 unsigned int ByteCount; | |
1242 int LastChar; | |
1243 }; | |
1244 | |
1245 | |
1246 #define NC 298 /* alphabet = {0, 1, 2, ..., NC - 1} */ | |
1247 #define DC 48 | |
1248 #define RC 28 | |
1249 #define BC 19 | |
1250 #define MC 257 | |
1251 | |
1252 | |
1253 struct AudioVariables AudV[4]; | |
1254 | |
1255 #define GetBits() \ | |
1256 BitField = ( ( ( (UDWORD)InBuf[InAddr] << 16 ) | \ | |
1257 ( (UWORD) InBuf[InAddr+1] << 8 ) | \ | |
1258 ( InBuf[InAddr+2] ) ) \ | |
1259 >> (8-InBit) ) & 0xffff; | |
1260 | |
1261 | |
1262 #define AddBits(Bits) \ | |
1263 InAddr += ( InBit + (Bits) ) >> 3; \ | |
1264 InBit = ( InBit + (Bits) ) & 7; | |
1265 | |
1266 static unsigned char *UnpBuf; | |
1267 static unsigned int BitField; | |
1268 static unsigned int Number; | |
1269 | |
1270 unsigned char InBuf[8192]; /* input read buffer */ | |
1271 | |
1272 unsigned char UnpOldTable[MC*4]; | |
1273 | |
1274 unsigned int InAddr,InBit,ReadTop; | |
1275 | |
1276 unsigned int LastDist,LastLength; | |
1277 static unsigned int Length,Distance; | |
1278 | |
1279 unsigned int OldDist[4],OldDistPtr; | |
1280 | |
1281 | |
1282 struct LitDecode | |
1283 { | |
1284 unsigned int MaxNum; | |
1285 unsigned int DecodeLen[16]; | |
1286 unsigned int DecodePos[16]; | |
1287 unsigned int DecodeNum[NC]; | |
1288 } LD; | |
1289 | |
1290 struct DistDecode | |
1291 { | |
1292 unsigned int MaxNum; | |
1293 unsigned int DecodeLen[16]; | |
1294 unsigned int DecodePos[16]; | |
1295 unsigned int DecodeNum[DC]; | |
1296 } DD; | |
1297 | |
1298 struct RepDecode | |
1299 { | |
1300 unsigned int MaxNum; | |
1301 unsigned int DecodeLen[16]; | |
1302 unsigned int DecodePos[16]; | |
1303 unsigned int DecodeNum[RC]; | |
1304 } RD; | |
1305 | |
1306 struct MultDecode | |
1307 { | |
1308 unsigned int MaxNum; | |
1309 unsigned int DecodeLen[16]; | |
1310 unsigned int DecodePos[16]; | |
1311 unsigned int DecodeNum[MC]; | |
1312 } MD[4]; | |
1313 | |
1314 struct BitDecode | |
1315 { | |
1316 unsigned int MaxNum; | |
1317 unsigned int DecodeLen[16]; | |
1318 unsigned int DecodePos[16]; | |
1319 unsigned int DecodeNum[BC]; | |
1320 } BD; | |
1321 | |
1322 static struct MultDecode *MDPtr[4]={&MD[0],&MD[1],&MD[2],&MD[3]}; | |
1323 | |
1324 int UnpAudioBlock,UnpChannels,CurChannel,ChannelDelta; | |
1325 | |
1326 | |
1327 void Unpack(unsigned char *UnpAddr) | |
1328 /* *** 38.3% of all CPU time is spent within this function!!! */ | |
1329 { | |
1330 static unsigned char LDecode[]={0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32, | |
1331 40,48,56,64,80,96,112,128,160,192,224}; | |
1332 static unsigned char LBits[]= {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3, | |
1333 3,3,3,4,4,4,4,5,5,5,5}; | |
1334 static int DDecode[]={0,1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256,384, | |
1335 512,768,1024,1536,2048,3072,4096,6144,8192,12288, | |
1336 16384,24576,32768U,49152U,65536,98304,131072,196608, | |
1337 262144,327680,393216,458752,524288,589824,655360, | |
1338 720896,786432,851968,917504,983040}; | |
1339 static unsigned char DBits[]= {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9, | |
1340 9,10,10,11,11,12,12,13,13,14,14,15,15,16, | |
1341 16,16,16,16,16,16,16,16,16,16,16,16,16}; | |
1342 static unsigned char SDDecode[]={0,4,8,16,32,64,128,192}; | |
1343 static unsigned char SDBits[]={2,2,3, 4, 5, 6, 6, 6}; | |
1344 unsigned int Bits; | |
1345 | |
1346 | |
1347 UnpBuf=UnpAddr; /* UnpAddr is a pointer to the */ | |
1348 UnpInitData(); /* unpack buffer */ | |
1349 UnpReadBuf(1); | |
1350 if (!(NewLhd.Flags & LHD_SOLID)) | |
1351 ReadTables(); | |
1352 DestUnpSize--; | |
1353 | |
1354 while (DestUnpSize>=0) | |
1355 { | |
1356 UnpPtr&=MAXWINMASK; | |
1357 | |
1358 if (InAddr>sizeof(InBuf)-30) | |
1359 UnpReadBuf(0); | |
1360 if (((WrPtr-UnpPtr) & MAXWINMASK)<270 && WrPtr!=UnpPtr) | |
1361 { | |
1362 | |
1363 | |
1364 if (FileFound) | |
1365 { | |
1366 | |
1367 if (UnpPtr<WrPtr) | |
1368 { | |
1369 if((*temp_output_buffer_offset + UnpPtr) > NewLhd.UnpSize) | |
1370 { | |
1371 debug_log("Fatal! Buffer overrun during decompression!"); | |
1372 DestUnpSize=-1; | |
1373 | |
1374 } else | |
1375 { | |
1376 /* copy extracted data to output buffer */ | |
1377 memcpy(temp_output_buffer + *temp_output_buffer_offset, | |
1378 &UnpBuf[WrPtr], (0-WrPtr) & MAXWINMASK); | |
1379 /* update offset within buffer */ | |
1380 *temp_output_buffer_offset+= (0-WrPtr) & MAXWINMASK; | |
1381 /* copy extracted data to output buffer */ | |
1382 memcpy(temp_output_buffer + *temp_output_buffer_offset, UnpBuf, | |
1383 UnpPtr); | |
1384 /* update offset within buffer */ | |
1385 *temp_output_buffer_offset+=UnpPtr; | |
1386 } | |
1387 } else | |
1388 { | |
1389 if((*temp_output_buffer_offset + (UnpPtr-WrPtr)) > NewLhd.UnpSize) | |
1390 { | |
1391 debug_log("Fatal! Buffer overrun during decompression!"); | |
1392 DestUnpSize=-1; | |
1393 } else | |
1394 { | |
1395 /* copy extracted data to output buffer */ | |
1396 memcpy(temp_output_buffer + *temp_output_buffer_offset, | |
1397 &UnpBuf[WrPtr], UnpPtr-WrPtr); | |
1398 *temp_output_buffer_offset+=UnpPtr-WrPtr; /* update offset within buffer */ | |
1399 } | |
1400 | |
1401 } | |
1402 } | |
1403 | |
1404 WrPtr=UnpPtr; | |
1405 } | |
1406 | |
1407 if (UnpAudioBlock) | |
1408 { | |
1409 DecodeNumber((struct Decode *)MDPtr[CurChannel]); | |
1410 if (Number==256) | |
1411 { | |
1412 ReadTables(); | |
1413 continue; | |
1414 } | |
1415 UnpBuf[UnpPtr++]=DecodeAudio(Number); | |
1416 if (++CurChannel==UnpChannels) | |
1417 CurChannel=0; | |
1418 DestUnpSize--; | |
1419 continue; | |
1420 } | |
1421 | |
1422 DecodeNumber((struct Decode *)&LD); | |
1423 if (Number<256) | |
1424 { | |
1425 UnpBuf[UnpPtr++]=(UBYTE)Number; | |
1426 DestUnpSize--; | |
1427 continue; | |
1428 } | |
1429 if (Number>269) | |
1430 { | |
1431 Length=LDecode[Number-=270]+3; | |
1432 if ((Bits=LBits[Number])>0) | |
1433 { | |
1434 GetBits(); | |
1435 Length+=BitField>>(16-Bits); | |
1436 AddBits(Bits); | |
1437 } | |
1438 | |
1439 DecodeNumber((struct Decode *)&DD); | |
1440 Distance=DDecode[Number]+1; | |
1441 if ((Bits=DBits[Number])>0) | |
1442 { | |
1443 GetBits(); | |
1444 Distance+=BitField>>(16-Bits); | |
1445 AddBits(Bits); | |
1446 } | |
1447 | |
1448 if (Distance>=0x40000L) | |
1449 Length++; | |
1450 | |
1451 if (Distance>=0x2000) | |
1452 Length++; | |
1453 | |
1454 LastDist=OldDist[OldDistPtr++ & 3]=Distance; | |
1455 DestUnpSize-=(LastLength=Length); | |
1456 while (Length--) | |
1457 { | |
1458 UnpBuf[UnpPtr]=UnpBuf[(UnpPtr-Distance) & MAXWINMASK]; | |
1459 UnpPtr=(UnpPtr+1) & MAXWINMASK; | |
1460 } | |
1461 | |
1462 continue; | |
1463 } | |
1464 if (Number==269) | |
1465 { | |
1466 ReadTables(); | |
1467 continue; | |
1468 } | |
1469 if (Number==256) | |
1470 { | |
1471 Length=LastLength; | |
1472 Distance=LastDist; | |
1473 LastDist=OldDist[OldDistPtr++ & 3]=Distance; | |
1474 DestUnpSize-=(LastLength=Length); | |
1475 while (Length--) | |
1476 { | |
1477 UnpBuf[UnpPtr]=UnpBuf[(UnpPtr-Distance) & MAXWINMASK]; | |
1478 UnpPtr=(UnpPtr+1) & MAXWINMASK; | |
1479 } | |
1480 continue; | |
1481 } | |
1482 if (Number<261) | |
1483 { | |
1484 Distance=OldDist[(OldDistPtr-(Number-256)) & 3]; | |
1485 DecodeNumber((struct Decode *)&RD); | |
1486 Length=LDecode[Number]+2; | |
1487 if ((Bits=LBits[Number])>0) | |
1488 { | |
1489 GetBits(); | |
1490 Length+=BitField>>(16-Bits); | |
1491 AddBits(Bits); | |
1492 } | |
1493 if (Distance>=0x40000) | |
1494 Length++; | |
1495 if (Distance>=0x2000) | |
1496 Length++; | |
1497 if (Distance>=0x101) | |
1498 Length++; | |
1499 LastDist=OldDist[OldDistPtr++ & 3]=Distance; | |
1500 DestUnpSize-=(LastLength=Length); | |
1501 while (Length--) | |
1502 { | |
1503 UnpBuf[UnpPtr]=UnpBuf[(UnpPtr-Distance) & MAXWINMASK]; | |
1504 UnpPtr=(UnpPtr+1) & MAXWINMASK; | |
1505 } | |
1506 continue; | |
1507 } | |
1508 if (Number<270) | |
1509 { | |
1510 Distance=SDDecode[Number-=261]+1; | |
1511 if ((Bits=SDBits[Number])>0) | |
1512 { | |
1513 GetBits(); | |
1514 Distance+=BitField>>(16-Bits); | |
1515 AddBits(Bits); | |
1516 } | |
1517 Length=2; | |
1518 LastDist=OldDist[OldDistPtr++ & 3]=Distance; | |
1519 DestUnpSize-=(LastLength=Length); | |
1520 while (Length--) | |
1521 { | |
1522 UnpBuf[UnpPtr]=UnpBuf[(UnpPtr-Distance) & MAXWINMASK]; | |
1523 UnpPtr=(UnpPtr+1) & MAXWINMASK; | |
1524 } | |
1525 continue; | |
1526 } | |
1527 } | |
1528 ReadLastTables(); | |
1529 | |
1530 if (FileFound) /* flush buffer */ | |
1531 { | |
1532 | |
1533 if (UnpPtr<WrPtr) | |
1534 { | |
1535 if((*temp_output_buffer_offset + UnpPtr) > NewLhd.UnpSize) | |
1536 { | |
1537 debug_log("Fatal! Buffer overrun during decompression!"); | |
1538 DestUnpSize=-1; | |
1539 } else | |
1540 { | |
1541 /* copy extracted data to output buffer */ | |
1542 memcpy(temp_output_buffer + *temp_output_buffer_offset, &UnpBuf[WrPtr], | |
1543 (0-WrPtr) & MAXWINMASK); | |
1544 /* update offset within buffer */ | |
1545 *temp_output_buffer_offset+= (0-WrPtr) & MAXWINMASK; | |
1546 /* copy extracted data to output buffer */ | |
1547 memcpy(temp_output_buffer + *temp_output_buffer_offset, UnpBuf, UnpPtr); | |
1548 /* update offset within buffer */ | |
1549 *temp_output_buffer_offset+=UnpPtr; | |
1550 } | |
1551 } else | |
1552 { | |
1553 if((*temp_output_buffer_offset + (UnpPtr-WrPtr)) > NewLhd.UnpSize) | |
1554 { | |
1555 debug_log("Fatal! Buffer overrun during decompression!"); | |
1556 DestUnpSize=-1; | |
1557 } else | |
1558 { | |
1559 /* copy extracted data to output buffer */ | |
1560 memcpy(temp_output_buffer + *temp_output_buffer_offset, &UnpBuf[WrPtr], | |
1561 UnpPtr-WrPtr); | |
1562 /* update offset within buffer */ | |
1563 *temp_output_buffer_offset+=UnpPtr-WrPtr; | |
1564 } | |
1565 } | |
1566 } | |
1567 | |
1568 WrPtr=UnpPtr; | |
1569 } | |
1570 | |
1571 | |
1572 unsigned int UnpRead(unsigned char *Addr,unsigned int Count) | |
1573 { | |
1574 int RetCode=0; | |
1575 unsigned int I,ReadSize,TotalRead=0; | |
1576 unsigned char *ReadAddr; | |
1577 ReadAddr=Addr; | |
1578 while (Count > 0) | |
1579 { | |
1580 ReadSize=(unsigned int)((Count>(unsigned long)UnpPackedSize) ? | |
1581 UnpPackedSize : Count); | |
1582 #ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION | |
1583 if(MemRARFile->data == NULL) | |
1584 return(0); | |
1585 RetCode=tread(MemRARFile, ReadAddr, ReadSize); | |
1586 #else | |
1587 if (ArcPtr==NULL) | |
1588 return(0); | |
1589 RetCode=tread(ArcPtr,ReadAddr,ReadSize); | |
1590 #endif | |
1591 CurUnpRead+=RetCode; | |
1592 ReadAddr+=RetCode; | |
1593 TotalRead+=RetCode; | |
1594 Count-=RetCode; | |
1595 UnpPackedSize-=RetCode; | |
1596 break; | |
1597 } | |
1598 if (RetCode!= -1) | |
1599 { | |
1600 RetCode=TotalRead; | |
1601 if (Encryption) | |
1602 { | |
1603 if (Encryption<20) | |
1604 { | |
1605 debug_log("Old Crypt() not supported!"); | |
1606 } | |
1607 else | |
1608 { | |
1609 for (I=0;I<(unsigned int)RetCode;I+=16) | |
1610 DecryptBlock(&Addr[I]); | |
1611 } | |
1612 } | |
1613 } | |
1614 return(RetCode); | |
1615 } | |
1616 | |
1617 | |
1618 void UnpReadBuf(int FirstBuf) | |
1619 { | |
1620 int RetCode; | |
1621 if (FirstBuf) | |
1622 { | |
1623 ReadTop=UnpRead(InBuf,sizeof(InBuf)); | |
1624 InAddr=0; | |
1625 } | |
1626 else | |
1627 { | |
1628 memcpy(InBuf,&InBuf[sizeof(InBuf)-32],32); | |
1629 InAddr&=0x1f; | |
1630 RetCode=UnpRead(&InBuf[32],sizeof(InBuf)-32); | |
1631 if (RetCode>0) | |
1632 ReadTop=RetCode+32; | |
1633 else | |
1634 ReadTop=InAddr; | |
1635 } | |
1636 } | |
1637 | |
1638 | |
1639 void ReadTables(void) | |
1640 { | |
1641 UBYTE BitLength[BC]; | |
1642 unsigned char Table[MC*4]; | |
1643 int TableSize,N,I; | |
1644 if (InAddr>sizeof(InBuf)-25) | |
1645 UnpReadBuf(0); | |
1646 GetBits(); | |
1647 UnpAudioBlock=(BitField & 0x8000); | |
1648 | |
1649 if (!(BitField & 0x4000)) | |
1650 memset(UnpOldTable,0,sizeof(UnpOldTable)); | |
1651 AddBits(2); | |
1652 | |
1653 | |
1654 if (UnpAudioBlock) | |
1655 { | |
1656 UnpChannels=((BitField>>12) & 3)+1; | |
1657 if (CurChannel>=UnpChannels) | |
1658 CurChannel=0; | |
1659 AddBits(2); | |
1660 TableSize=MC*UnpChannels; | |
1661 } | |
1662 else | |
1663 TableSize=NC+DC+RC; | |
1664 | |
1665 | |
1666 for (I=0;I<BC;I++) | |
1667 { | |
1668 GetBits(); | |
1669 BitLength[I]=(UBYTE)(BitField >> 12); | |
1670 AddBits(4); | |
1671 } | |
1672 MakeDecodeTables(BitLength,(struct Decode *)&BD,BC); | |
1673 I=0; | |
1674 while (I<TableSize) | |
1675 { | |
1676 if (InAddr>sizeof(InBuf)-5) | |
1677 UnpReadBuf(0); | |
1678 DecodeNumber((struct Decode *)&BD); | |
1679 if (Number<16) | |
8451 | 1680 { |
1681 Table[I]=(Number+UnpOldTable[I]) & 0xf; | |
1682 I++; | |
1683 } | |
7446 | 1684 else |
1685 if (Number==16) | |
1686 { | |
1687 GetBits(); | |
1688 N=(BitField >> 14)+3; | |
1689 AddBits(2); | |
1690 while (N-- > 0 && I<TableSize) | |
1691 { | |
1692 Table[I]=Table[I-1]; | |
1693 I++; | |
1694 } | |
1695 } | |
1696 else | |
1697 { | |
1698 if (Number==17) | |
1699 { | |
1700 GetBits(); | |
1701 N=(BitField >> 13)+3; | |
1702 AddBits(3); | |
1703 } | |
1704 else | |
1705 { | |
1706 GetBits(); | |
1707 N=(BitField >> 9)+11; | |
1708 AddBits(7); | |
1709 } | |
1710 while (N-- > 0 && I<TableSize) | |
1711 Table[I++]=0; | |
1712 } | |
1713 } | |
1714 if (UnpAudioBlock) | |
1715 for (I=0;I<UnpChannels;I++) | |
1716 MakeDecodeTables(&Table[I*MC],(struct Decode *)MDPtr[I],MC); | |
1717 else | |
1718 { | |
1719 MakeDecodeTables(&Table[0],(struct Decode *)&LD,NC); | |
1720 MakeDecodeTables(&Table[NC],(struct Decode *)&DD,DC); | |
1721 MakeDecodeTables(&Table[NC+DC],(struct Decode *)&RD,RC); | |
1722 } | |
1723 memcpy(UnpOldTable,Table,sizeof(UnpOldTable)); | |
1724 } | |
1725 | |
1726 | |
1727 static void ReadLastTables(void) | |
1728 { | |
1729 if (ReadTop>=InAddr+5) | |
1730 { | |
1731 if (UnpAudioBlock) | |
1732 { | |
1733 DecodeNumber((struct Decode *)MDPtr[CurChannel]); | |
1734 if (Number==256) | |
1735 ReadTables(); | |
1736 } | |
1737 else | |
1738 { | |
1739 DecodeNumber((struct Decode *)&LD); | |
1740 if (Number==269) | |
1741 ReadTables(); | |
1742 } | |
1743 } | |
1744 } | |
1745 | |
1746 | |
1747 static void MakeDecodeTables(unsigned char *LenTab, | |
1748 struct Decode *Dec, | |
1749 int Size) | |
1750 { | |
1751 int LenCount[16],TmpPos[16],I; | |
1752 long M,N; | |
1753 memset(LenCount,0,sizeof(LenCount)); | |
1754 for (I=0;I<Size;I++) | |
1755 LenCount[LenTab[I] & 0xF]++; | |
1756 | |
1757 LenCount[0]=0; | |
1758 for (TmpPos[0]=Dec->DecodePos[0]=Dec->DecodeLen[0]=0,N=0,I=1;I<16;I++) | |
1759 { | |
1760 N=2*(N+LenCount[I]); | |
1761 M=N<<(15-I); | |
1762 if (M>0xFFFF) | |
1763 M=0xFFFF; | |
1764 Dec->DecodeLen[I]=(unsigned int)M; | |
1765 TmpPos[I]=Dec->DecodePos[I]=Dec->DecodePos[I-1]+LenCount[I-1]; | |
1766 } | |
1767 | |
1768 for (I=0;I<Size;I++) | |
1769 if (LenTab[I]!=0) | |
1770 Dec->DecodeNum[TmpPos[LenTab[I] & 0xF]++]=I; | |
1771 Dec->MaxNum=Size; | |
1772 } | |
1773 | |
1774 | |
1775 static void DecodeNumber(struct Decode *Deco) | |
1776 /* *** 52.6% of all CPU time is spent within this function!!! */ | |
1777 { | |
1778 unsigned int I; | |
1779 register unsigned int N; | |
1780 GetBits(); | |
1781 | |
1782 #ifdef _USE_ASM | |
1783 | |
1784 #ifdef _WIN_32 | |
1785 __asm { | |
1786 | |
1787 xor eax, eax | |
1788 mov eax, BitField // N=BitField & 0xFFFE; | |
1789 and eax, 0xFFFFFFFE | |
1790 mov [N], eax | |
1791 mov edx, [Deco] // EAX=N, EDX=Deco | |
1792 | |
1793 cmp eax, dword ptr[edx + 8*4 + 4]// if (N<Dec->DecodeLen[8]) | |
1794 jae else_G | |
1795 | |
1796 cmp eax, dword ptr[edx + 4*4 + 4]// if (N<Dec->DecodeLen[4]) | |
1797 jae else_F | |
1798 | |
1799 | |
1800 cmp eax, dword ptr[edx + 2*4 + 4]// if (N<Dec->DecodeLen[2]) | |
1801 jae else_C | |
1802 | |
1803 cmp eax, dword ptr[edx + 1*4 + 4]// if (N<Dec->DecodeLen[1]) | |
1804 jae else_1 | |
1805 mov I, 1 // I=1; | |
1806 jmp next_1 | |
1807 else_1: // else | |
1808 mov I, 2 // I=2; | |
1809 next_1: | |
1810 | |
1811 jmp next_C | |
1812 else_C: // else | |
1813 | |
1814 cmp eax, dword ptr[edx + 3*4 + 4]// if (N<Dec->DecodeLen[3]) | |
1815 jae else_2 | |
1816 mov I, 3 // I=3; | |
1817 jmp next_2 | |
1818 else_2: // else | |
1819 mov I, 4 // I=4; | |
1820 next_2: | |
1821 | |
1822 next_C: // else | |
1823 | |
1824 jmp next_F | |
1825 else_F: | |
1826 | |
1827 | |
1828 cmp eax, dword ptr[edx + 6*4 + 4]// if (N<Dec->DecodeLen[6]) | |
1829 jae else_E | |
1830 | |
1831 cmp eax, dword ptr[edx + 5*4 + 4]// if (N<Dec->DecodeLen[5]) | |
1832 jae else_3 | |
1833 mov I, 5 // I=5; | |
1834 jmp next_3 | |
1835 else_3: // else | |
1836 mov I, 6 // I=6; | |
1837 next_3: | |
1838 | |
1839 jmp next_E | |
1840 else_E: // else | |
1841 | |
1842 cmp eax, dword ptr[edx + 7*4 + 4]// if (N<Dec->DecodeLen[7]) | |
1843 jae else_4 | |
1844 mov I, 7 // I=7; | |
1845 jmp next_4 | |
1846 else_4: // else | |
1847 mov I, 8 // I=8; | |
1848 next_4: | |
1849 | |
1850 next_E: | |
1851 | |
1852 next_F: | |
1853 | |
1854 jmp next_G | |
1855 else_G: | |
1856 | |
1857 cmp eax, dword ptr[edx + 12*4 + 4] // if (N<Dec->DecodeLen[12]) | |
1858 jae else_D | |
1859 | |
1860 cmp eax, dword ptr[edx + 10*4 + 4]// if (N<Dec->DecodeLen[10]) | |
1861 jae else_B | |
1862 | |
1863 cmp eax, dword ptr[edx + 9*4 + 4]// if (N<Dec->DecodeLen[9]) | |
1864 jae else_5 | |
1865 mov I, 9 // I=9; | |
1866 jmp next_5 | |
1867 else_5: // else | |
1868 mov I, 10 // I=10; | |
1869 next_5: | |
1870 | |
1871 jmp next_B | |
1872 else_B: // else | |
1873 | |
1874 cmp eax, dword ptr[edx + 11*4 + 4]// if (N<Dec->DecodeLen[11]) | |
1875 jae else_6 | |
1876 mov I, 11 // I=11; | |
1877 jmp next_6 | |
1878 else_6: // else | |
1879 mov I, 12 // I=12; | |
1880 next_6: | |
1881 | |
1882 next_B: | |
1883 | |
1884 | |
1885 jmp next_D | |
1886 else_D: // else | |
1887 | |
1888 cmp eax, dword ptr[edx + 14*4 + 4]// if (N<Dec->DecodeLen[14]) | |
1889 jae else_A | |
1890 | |
1891 cmp eax, dword ptr[edx + 13*4 + 4]// if (N<Dec->DecodeLen[13]) | |
1892 jae else_7 | |
1893 mov I, 13 // I=13; | |
1894 jmp next_7 | |
1895 else_7: // else | |
1896 mov I, 14 // I=14; | |
1897 next_7: | |
1898 | |
1899 jmp next_A | |
1900 else_A: // else | |
1901 mov I, 15 // I=15; | |
1902 next_A: | |
1903 | |
1904 next_D: | |
1905 next_G: | |
1906 } | |
1907 #else | |
1908 __asm__ __volatile__ ( | |
1909 "andl $0xFFFFFFFE, %%eax" | |
1910 " movl %%eax, %1" | |
1911 " cmpl 8*4(%%edx), %%eax /* 5379 */" | |
1912 " jae else_G" | |
1913 "" | |
1914 " cmpl 4*4(%%edx), %%eax" | |
1915 " jae else_F" | |
1916 "" | |
1917 " cmpl 2*4(%%edx), %%eax" | |
1918 " jae else_C" | |
1919 "" | |
1920 " cmpl 1*4(%%edx), %%eax" | |
1921 "" | |
1922 " jae else_1" | |
1923 " movl $1, %0" | |
1924 " jmp next_1" | |
1925 " else_1: " | |
1926 " movl $2, %0" | |
1927 " next_1:" | |
1928 " " | |
1929 " jmp next_C" | |
1930 " else_C: " | |
1931 "" | |
1932 " cmpl 3*4(%%edx), %%eax " | |
1933 " jae else_2" | |
1934 " movl $3, %0" | |
1935 " jmp next_2" | |
1936 " else_2: " | |
1937 " movl $4, %0" | |
1938 " next_2:" | |
1939 "" | |
1940 " next_C: " | |
1941 "" | |
1942 " jmp next_F" | |
1943 " else_F:" | |
1944 "" | |
1945 " cmpl 6*4(%%edx), %%eax" | |
1946 " jae else_E" | |
1947 "" | |
1948 " cmpl 5*4(%%edx), %%eax" | |
1949 " jae else_3" | |
1950 " movl $5, %0 " | |
1951 " jmp next_3" | |
1952 " else_3: " | |
1953 " movl $6, %0 " | |
1954 " next_3:" | |
1955 "" | |
1956 " jmp next_E" | |
1957 " else_E: " | |
1958 "" | |
1959 " cmpl 7*4(%%edx), %%eax" | |
1960 " jae else_4" | |
1961 " movl $7, %0 " | |
1962 " jmp next_4" | |
1963 " else_4: " | |
1964 " movl $8, %0 " | |
1965 " next_4:" | |
1966 "" | |
1967 " next_E:" | |
1968 "" | |
1969 " next_F:" | |
1970 "" | |
1971 " jmp next_G" | |
1972 " else_G:" | |
1973 "" | |
1974 " cmpl 12*4(%%edx), %%eax" | |
1975 " jae else_D" | |
1976 "" | |
1977 " cmpl 10*4(%%edx), %%eax" | |
1978 " jae else_B" | |
1979 "" | |
1980 " cmpl 9*4(%%edx), %%eax" | |
1981 " jae else_5" | |
1982 " movl $9, %0 " | |
1983 " jmp next_5" | |
1984 " else_5: " | |
1985 " movl $10, %0 " | |
1986 " next_5:" | |
1987 "" | |
1988 " jmp next_B" | |
1989 " else_B: " | |
1990 "" | |
1991 " cmpl 11*4(%%edx), %%eax" | |
1992 " " | |
1993 " jae else_6" | |
1994 " movl $11, %0 " | |
1995 " jmp next_6" | |
1996 " else_6: " | |
1997 " movl $12, %0 " | |
1998 " next_6:" | |
1999 "" | |
2000 " next_B:" | |
2001 " " | |
2002 " " | |
2003 " jmp next_D" | |
2004 " else_D: " | |
2005 "" | |
2006 " cmpl 14*4(%%edx), %%eax" | |
2007 " jae else_A" | |
2008 "" | |
2009 " cmpl 13*4(%%edx), %%eax" | |
2010 " jae else_7" | |
2011 " movl $13, %0" | |
2012 " jmp next_7" | |
2013 " else_7: " | |
2014 " movl $14, %0" | |
2015 " next_7:" | |
2016 "" | |
2017 " jmp next_A" | |
2018 " else_A: " | |
2019 " movl $15, %0 " | |
2020 " next_A:" | |
2021 " " | |
2022 " next_D: " | |
2023 " next_G:" | |
2024 : "=g" (I), "=r"(N) | |
2025 : "eax" ((long)BitField), "edx"((long)Deco->DecodeLen) | |
2026 : "memory" | |
2027 ); | |
2028 #endif /* #ifdef _WIN_32 ... #elif defined _X86_ASM_ */ | |
2029 | |
2030 #else | |
2031 N=BitField & 0xFFFE; | |
2032 if (N<Deco->DecodeLen[8]) { | |
2033 if (N<Deco->DecodeLen[4]) { | |
2034 if (N<Deco->DecodeLen[2]) { | |
2035 if (N<Deco->DecodeLen[1]) | |
2036 I=1; | |
2037 else | |
2038 I=2; | |
2039 } else { | |
2040 if (N<Deco->DecodeLen[3]) | |
2041 I=3; | |
2042 else | |
2043 I=4; | |
2044 } | |
2045 } else { | |
2046 if (N<Deco->DecodeLen[6]) { | |
2047 if (N<Deco->DecodeLen[5]) | |
2048 I=5; | |
2049 else | |
2050 I=6; | |
2051 } else { | |
2052 if (N<Deco->DecodeLen[7]) | |
2053 I=7; | |
2054 else | |
2055 I=8; | |
2056 } | |
2057 } | |
2058 } else { | |
2059 if (N<Deco->DecodeLen[12]) { | |
2060 if (N<Deco->DecodeLen[10]) { | |
2061 if (N<Deco->DecodeLen[9]) | |
2062 I=9; | |
2063 else | |
2064 I=10; | |
2065 } else { | |
2066 if (N<Deco->DecodeLen[11]) | |
2067 I=11; | |
2068 else | |
2069 I=12; | |
2070 } | |
2071 } else { | |
2072 if (N<Deco->DecodeLen[14]) { | |
2073 if (N<Deco->DecodeLen[13]) | |
2074 I=13; | |
2075 else | |
2076 I=14; | |
2077 | |
2078 } else { | |
2079 I=15; | |
2080 } | |
2081 } | |
2082 | |
2083 } | |
2084 #endif | |
2085 | |
2086 AddBits(I); | |
2087 if ((N=Deco->DecodePos[I]+((N-Deco->DecodeLen[I-1])>>(16-I)))>=Deco->MaxNum) | |
2088 N=0; | |
2089 Number=Deco->DecodeNum[N]; | |
2090 } | |
2091 | |
2092 | |
2093 void UnpInitData() | |
2094 { | |
2095 InAddr=InBit=0; | |
2096 if (!(NewLhd.Flags & LHD_SOLID)) | |
2097 { | |
2098 ChannelDelta=CurChannel=0; | |
2099 | |
2100 #ifdef _USE_ASM | |
2101 | |
2102 #ifdef _WIN_32 /* Win32 with VisualC */ | |
2103 | |
2104 __asm { | |
2105 push edi | |
2106 push eax | |
2107 push ecx | |
2108 | |
2109 cld /* increment EDI and ESI */ | |
2110 mov al, 0x00 | |
2111 mov ecx, SIZE AudV | |
2112 mov edi, Offset AudV | |
2113 rep stosb /* clear memory */ | |
2114 | |
2115 mov ecx, SIZE OldDist | |
2116 mov edi, Offset OldDist | |
2117 rep stosb /* clear memory */ | |
2118 | |
2119 mov ecx, SIZE UnpOldTable | |
2120 mov edi, Offset UnpOldTable | |
2121 rep stosb /* clear memory */ | |
2122 | |
2123 pop ecx | |
2124 pop eax | |
2125 pop edi | |
2126 | |
2127 | |
2128 mov [OldDistPtr], 0 | |
2129 mov [LastDist], 0 | |
2130 mov [LastLength], 0 | |
2131 mov [UnpPtr], 0 | |
2132 mov [WrPtr], 0 | |
2133 mov [OldDistPtr], 0 | |
2134 mov [LastLength], 0 | |
2135 mov [LastDist], 0 | |
2136 mov [UnpPtr], 0 | |
2137 mov [WrPtr], 0 | |
2138 | |
2139 } | |
2140 memset(UnpBuf,0,MAXWINSIZE); | |
2141 | |
2142 | |
2143 #else /* unix/linux on i386 cpus */ | |
2144 __asm__ __volatile ( | |
2145 " cld /* increment EDI and ESI */" | |
2146 " movb $0x00, %%al" | |
2147 " movl %0, %%ecx" | |
2148 " movl %1, %%edi" | |
2149 " rep " | |
2150 " stosb /* clear memory */" | |
2151 "" | |
2152 " movl %2, %%ecx" | |
2153 " mov %3, %%edi" | |
2154 " rep " | |
2155 " stosb /* clear memory */" | |
2156 "" | |
2157 " movl %4, %%ecx" | |
2158 " movl %5, %%edi" | |
2159 " rep " | |
2160 " stosb /* clear memory */" | |
2161 "" | |
2162 " movl $0, (OldDistPtr)" | |
2163 " movl $0, (LastDist)" | |
2164 " movl $0, (LastLength)" | |
2165 " movl $0, (UnpPtr)" | |
2166 " movl $0, (WrPtr)" | |
2167 " movl $0, (OldDistPtr)" | |
2168 " movl $0, (LastLength)" | |
2169 " movl $0, (LastDist)" | |
2170 " movl $0, (UnpPtr)" | |
2171 " movl $0, (WrPtr)" | |
2172 : | |
2173 : "m" ((long)sizeof(AudV)), | |
2174 "m" ((long)AudV), | |
2175 "m" ((long)sizeof(OldDist)), | |
2176 "m" ((long)OldDist), | |
2177 "m" ((long)sizeof(UnpOldTable)), | |
2178 "m" ((long)UnpOldTable) | |
2179 : "memory", "edi", "eax", "ecx" | |
2180 ); | |
2181 memset(UnpBuf,0,MAXWINSIZE); | |
2182 #endif | |
2183 | |
2184 #else /* unix/linux on non-i386 cpu */ | |
2185 memset(AudV,0,sizeof(AudV)); | |
2186 memset(OldDist,0,sizeof(OldDist)); | |
2187 OldDistPtr=0; | |
2188 LastDist=LastLength=0; | |
2189 memset(UnpBuf,0,MAXWINSIZE); | |
2190 memset(UnpOldTable,0,sizeof(UnpOldTable)); | |
2191 UnpPtr=WrPtr=0; | |
2192 #endif | |
2193 | |
2194 } | |
2195 } | |
2196 | |
2197 | |
2198 UBYTE DecodeAudio(int Delta) | |
2199 { | |
2200 struct AudioVariables *V; | |
2201 unsigned int Ch; | |
2202 unsigned int NumMinDif,MinDif; | |
2203 int PCh,I; | |
2204 | |
2205 V=&AudV[CurChannel]; | |
2206 V->ByteCount++; | |
2207 V->D4=V->D3; | |
2208 V->D3=V->D2; | |
2209 V->D2=V->LastDelta-V->D1; | |
2210 V->D1=V->LastDelta; | |
2211 PCh=8*V->LastChar+V->K1*V->D1+V->K2*V->D2+ | |
2212 V->K3*V->D3+V->K4*V->D4+V->K5*ChannelDelta; | |
2213 PCh=(PCh>>3) & 0xFF; | |
2214 | |
2215 Ch=PCh-Delta; | |
2216 | |
2217 I=((signed char)Delta)<<3; | |
2218 | |
2219 V->Dif[0]+=abs(I); | |
2220 V->Dif[1]+=abs(I-V->D1); | |
2221 V->Dif[2]+=abs(I+V->D1); | |
2222 V->Dif[3]+=abs(I-V->D2); | |
2223 V->Dif[4]+=abs(I+V->D2); | |
2224 V->Dif[5]+=abs(I-V->D3); | |
2225 V->Dif[6]+=abs(I+V->D3); | |
2226 V->Dif[7]+=abs(I-V->D4); | |
2227 V->Dif[8]+=abs(I+V->D4); | |
2228 V->Dif[9]+=abs(I-ChannelDelta); | |
2229 V->Dif[10]+=abs(I+ChannelDelta); | |
2230 | |
2231 ChannelDelta=V->LastDelta=(signed char)(Ch-V->LastChar); | |
2232 V->LastChar=Ch; | |
2233 | |
2234 if ((V->ByteCount & 0x1F)==0) | |
2235 { | |
2236 MinDif=V->Dif[0]; | |
2237 NumMinDif=0; | |
2238 V->Dif[0]=0; | |
2239 for (I=1;(unsigned int)I<sizeof(V->Dif)/sizeof(V->Dif[0]);I++) | |
2240 { | |
2241 if (V->Dif[I]<MinDif) | |
2242 { | |
2243 MinDif=V->Dif[I]; | |
2244 NumMinDif=I; | |
2245 } | |
2246 V->Dif[I]=0; | |
2247 } | |
2248 switch(NumMinDif) | |
2249 { | |
2250 case 1: | |
2251 if (V->K1>=-16) | |
2252 V->K1--; | |
2253 break; | |
2254 case 2: | |
2255 if (V->K1<16) | |
2256 V->K1++; | |
2257 break; | |
2258 case 3: | |
2259 if (V->K2>=-16) | |
2260 V->K2--; | |
2261 break; | |
2262 case 4: | |
2263 if (V->K2<16) | |
2264 V->K2++; | |
2265 break; | |
2266 case 5: | |
2267 if (V->K3>=-16) | |
2268 V->K3--; | |
2269 break; | |
2270 case 6: | |
2271 if (V->K3<16) | |
2272 V->K3++; | |
2273 break; | |
2274 case 7: | |
2275 if (V->K4>=-16) | |
2276 V->K4--; | |
2277 break; | |
2278 case 8: | |
2279 if (V->K4<16) | |
2280 V->K4++; | |
2281 break; | |
2282 case 9: | |
2283 if (V->K5>=-16) | |
2284 V->K5--; | |
2285 break; | |
2286 case 10: | |
2287 if (V->K5<16) | |
2288 V->K5++; | |
2289 break; | |
2290 } | |
2291 } | |
2292 return((UBYTE)Ch); | |
2293 } | |
2294 | |
2295 | |
2296 | |
2297 | |
2298 | |
2299 | |
2300 | |
2301 /* *************************************************** | |
2302 * ** CRCCrypt Code - decryption engine starts here ** | |
2303 * ***************************************************/ | |
2304 | |
2305 | |
2306 #define NROUNDS 32 | |
2307 | |
2308 #define rol(x,n) (((x)<<(n)) | ((x)>>(8*sizeof(x)-(n)))) | |
2309 #define ror(x,n) (((x)>>(n)) | ((x)<<(8*sizeof(x)-(n)))) | |
2310 | |
2311 #define substLong(t) ( (UDWORD)SubstTable[(int)t&255] | \ | |
2312 ((UDWORD)SubstTable[(int)(t>> 8)&255]<< 8) | \ | |
2313 ((UDWORD)SubstTable[(int)(t>>16)&255]<<16) | \ | |
2314 ((UDWORD)SubstTable[(int)(t>>24)&255]<<24) ) | |
2315 | |
2316 | |
2317 UDWORD CRCTab[256]; | |
2318 | |
2319 UBYTE SubstTable[256]; | |
2320 UBYTE InitSubstTable[256]={ | |
2321 215, 19,149, 35, 73,197,192,205,249, 28, 16,119, 48,221, 2, 42, | |
2322 232, 1,177,233, 14, 88,219, 25,223,195,244, 90, 87,239,153,137, | |
2323 255,199,147, 70, 92, 66,246, 13,216, 40, 62, 29,217,230, 86, 6, | |
2324 71, 24,171,196,101,113,218,123, 93, 91,163,178,202, 67, 44,235, | |
2325 107,250, 75,234, 49,167,125,211, 83,114,157,144, 32,193,143, 36, | |
2326 158,124,247,187, 89,214,141, 47,121,228, 61,130,213,194,174,251, | |
2327 97,110, 54,229,115, 57,152, 94,105,243,212, 55,209,245, 63, 11, | |
2328 164,200, 31,156, 81,176,227, 21, 76, 99,139,188,127, 17,248, 51, | |
2329 207,120,189,210, 8,226, 41, 72,183,203,135,165,166, 60, 98, 7, | |
2330 122, 38,155,170, 69,172,252,238, 39,134, 59,128,236, 27,240, 80, | |
2331 131, 3, 85,206,145, 79,154,142,159,220,201,133, 74, 64, 20,129, | |
2332 224,185,138,103,173,182, 43, 34,254, 82,198,151,231,180, 58, 10, | |
2333 118, 26,102, 12, 50,132, 22,191,136,111,162,179, 45, 4,148,108, | |
2334 161, 56, 78,126,242,222, 15,175,146, 23, 33,241,181,190, 77,225, | |
2335 0, 46,169,186, 68, 95,237, 65, 53,208,253,168, 9, 18,100, 52, | |
2336 116,184,160, 96,109, 37, 30,106,140,104,150, 5,204,117,112, 84 | |
2337 }; | |
2338 | |
2339 UDWORD Key[4]; | |
2340 | |
2341 | |
2342 void EncryptBlock(UBYTE *Buf) | |
2343 { | |
2344 int I; | |
2345 | |
2346 UDWORD A,B,C,D,T,TA,TB; | |
2347 #ifdef NON_INTEL_BYTE_ORDER | |
2348 A=((UDWORD)Buf[0]|((UDWORD)Buf[1]<<8)|((UDWORD)Buf[2]<<16)| | |
2349 ((UDWORD)Buf[3]<<24))^Key[0]; | |
2350 B=((UDWORD)Buf[4]|((UDWORD)Buf[5]<<8)|((UDWORD)Buf[6]<<16)| | |
2351 ((UDWORD)Buf[7]<<24))^Key[1]; | |
2352 C=((UDWORD)Buf[8]|((UDWORD)Buf[9]<<8)|((UDWORD)Buf[10]<<16)| | |
2353 ((UDWORD)Buf[11]<<24))^Key[2]; | |
2354 D=((UDWORD)Buf[12]|((UDWORD)Buf[13]<<8)|((UDWORD)Buf[14]<<16)| | |
2355 ((UDWORD)Buf[15]<<24))^Key[3]; | |
2356 #else | |
2357 UDWORD *BufPtr; | |
2358 BufPtr=(UDWORD *)Buf; | |
2359 A=BufPtr[0]^Key[0]; | |
2360 B=BufPtr[1]^Key[1]; | |
2361 C=BufPtr[2]^Key[2]; | |
2362 D=BufPtr[3]^Key[3]; | |
2363 #endif | |
2364 for(I=0;I<NROUNDS;I++) | |
2365 { | |
2366 T=((C+rol(D,11))^Key[I&3]); | |
2367 TA=A^substLong(T); | |
2368 T=((D^rol(C,17))+Key[I&3]); | |
2369 TB=B^substLong(T); | |
2370 A=C; | |
2371 B=D; | |
2372 C=TA; | |
2373 D=TB; | |
2374 } | |
2375 #ifdef NON_INTEL_BYTE_ORDER | |
2376 C^=Key[0]; | |
2377 Buf[0]=(UBYTE)C; | |
2378 Buf[1]=(UBYTE)(C>>8); | |
2379 Buf[2]=(UBYTE)(C>>16); | |
2380 Buf[3]=(UBYTE)(C>>24); | |
2381 D^=Key[1]; | |
2382 Buf[4]=(UBYTE)D; | |
2383 Buf[5]=(UBYTE)(D>>8); | |
2384 Buf[6]=(UBYTE)(D>>16); | |
2385 Buf[7]=(UBYTE)(D>>24); | |
2386 A^=Key[2]; | |
2387 Buf[8]=(UBYTE)A; | |
2388 Buf[9]=(UBYTE)(A>>8); | |
2389 Buf[10]=(UBYTE)(A>>16); | |
2390 Buf[11]=(UBYTE)(A>>24); | |
2391 B^=Key[3]; | |
2392 Buf[12]=(UBYTE)B; | |
2393 Buf[13]=(UBYTE)(B>>8); | |
2394 Buf[14]=(UBYTE)(B>>16); | |
2395 Buf[15]=(UBYTE)(B>>24); | |
2396 #else | |
2397 BufPtr[0]=C^Key[0]; | |
2398 BufPtr[1]=D^Key[1]; | |
2399 BufPtr[2]=A^Key[2]; | |
2400 BufPtr[3]=B^Key[3]; | |
2401 #endif | |
2402 UpdKeys(Buf); | |
2403 } | |
2404 | |
2405 | |
2406 void DecryptBlock(UBYTE *Buf) | |
2407 { | |
2408 int I; | |
2409 UBYTE InBuf[16]; | |
2410 UDWORD A,B,C,D,T,TA,TB; | |
2411 #ifdef NON_INTEL_BYTE_ORDER | |
2412 A=((UDWORD)Buf[0]|((UDWORD)Buf[1]<<8)|((UDWORD)Buf[2]<<16)| | |
2413 ((UDWORD)Buf[3]<<24))^Key[0]; | |
2414 B=((UDWORD)Buf[4]|((UDWORD)Buf[5]<<8)|((UDWORD)Buf[6]<<16)| | |
2415 ((UDWORD)Buf[7]<<24))^Key[1]; | |
2416 C=((UDWORD)Buf[8]|((UDWORD)Buf[9]<<8)|((UDWORD)Buf[10]<<16)| | |
2417 ((UDWORD)Buf[11]<<24))^Key[2]; | |
2418 D=((UDWORD)Buf[12]|((UDWORD)Buf[13]<<8)|((UDWORD)Buf[14]<<16)| | |
2419 ((UDWORD)Buf[15]<<24))^Key[3]; | |
2420 #else | |
2421 UDWORD *BufPtr; | |
2422 BufPtr=(UDWORD *)Buf; | |
2423 A=BufPtr[0]^Key[0]; /* xxx may be this can be */ | |
2424 B=BufPtr[1]^Key[1]; /* optimized in assembler */ | |
2425 C=BufPtr[2]^Key[2]; | |
2426 D=BufPtr[3]^Key[3]; | |
2427 #endif | |
2428 memcpy(InBuf,Buf,sizeof(InBuf)); | |
2429 for(I=NROUNDS-1;I>=0;I--) | |
2430 { | |
2431 T=((C+rol(D,11))^Key[I&3]); | |
2432 TA=A^substLong(T); | |
2433 T=((D^rol(C,17))+Key[I&3]); | |
2434 TB=B^substLong(T); | |
2435 A=C; | |
2436 B=D; | |
2437 C=TA; | |
2438 D=TB; | |
2439 } | |
2440 #ifdef NON_INTEL_BYTE_ORDER | |
2441 C^=Key[0]; | |
2442 Buf[0]=(UBYTE)C; | |
2443 Buf[1]=(UBYTE)(C>>8); | |
2444 Buf[2]=(UBYTE)(C>>16); | |
2445 Buf[3]=(UBYTE)(C>>24); | |
2446 D^=Key[1]; | |
2447 Buf[4]=(UBYTE)D; | |
2448 Buf[5]=(UBYTE)(D>>8); | |
2449 Buf[6]=(UBYTE)(D>>16); | |
2450 Buf[7]=(UBYTE)(D>>24); | |
2451 A^=Key[2]; | |
2452 Buf[8]=(UBYTE)A; | |
2453 Buf[9]=(UBYTE)(A>>8); | |
2454 Buf[10]=(UBYTE)(A>>16); | |
2455 Buf[11]=(UBYTE)(A>>24); | |
2456 B^=Key[3]; | |
2457 Buf[12]=(UBYTE)B; | |
2458 Buf[13]=(UBYTE)(B>>8); | |
2459 Buf[14]=(UBYTE)(B>>16); | |
2460 Buf[15]=(UBYTE)(B>>24); | |
2461 #else | |
2462 BufPtr[0]=C^Key[0]; | |
2463 BufPtr[1]=D^Key[1]; | |
2464 BufPtr[2]=A^Key[2]; | |
2465 BufPtr[3]=B^Key[3]; | |
2466 #endif | |
2467 UpdKeys(InBuf); | |
2468 } | |
2469 | |
2470 | |
2471 void UpdKeys(UBYTE *Buf) | |
2472 { | |
2473 int I; | |
2474 for (I=0;I<16;I+=4) | |
2475 { | |
2476 Key[0]^=CRCTab[Buf[I]]; /* xxx may be I'll rewrite this */ | |
2477 Key[1]^=CRCTab[Buf[I+1]]; /* in asm for speedup */ | |
2478 Key[2]^=CRCTab[Buf[I+2]]; | |
2479 Key[3]^=CRCTab[Buf[I+3]]; | |
2480 } | |
2481 } | |
2482 | |
2483 void SetCryptKeys(char *Password) | |
2484 { | |
2485 unsigned int I,J,K,PswLength; | |
2486 unsigned char N1,N2; | |
2487 unsigned char Psw[256]; | |
2488 | |
2489 #if !defined _USE_ASM | |
2490 UBYTE Ch; | |
2491 #endif | |
2492 | |
2493 SetOldKeys(Password); | |
2494 | |
2495 Key[0]=0xD3A3B879L; | |
2496 Key[1]=0x3F6D12F7L; | |
2497 Key[2]=0x7515A235L; | |
2498 Key[3]=0xA4E7F123L; | |
2499 memset(Psw,0,sizeof(Psw)); | |
2500 strcpy((char *)Psw,Password); | |
2501 PswLength=strlen(Password); | |
2502 memcpy(SubstTable,InitSubstTable,sizeof(SubstTable)); | |
2503 | |
2504 for (J=0;J<256;J++) | |
2505 for (I=0;I<PswLength;I+=2) | |
2506 { | |
2507 N2=(unsigned char)CRCTab[(Psw[I+1]+J)&0xFF]; | |
2508 for (K=1, N1=(unsigned char)CRCTab[(Psw[I]-J)&0xFF]; | |
2509 (N1!=N2) && (N1 < 256); /* I had to add "&& (N1 < 256)", */ | |
2510 N1++, K++) /* because the system crashed with */ | |
2511 { /* encrypted RARs */ | |
2512 #ifdef _USE_ASM | |
2513 | |
2514 #ifdef _WIN_32 | |
2515 __asm { | |
2516 | |
2517 mov ebx, Offset SubstTable | |
2518 mov edx, ebx | |
2519 | |
2520 xor ecx, ecx // read SubstTable[N1]... | |
2521 mov cl, N1 | |
2522 add ebx, ecx | |
2523 mov al, byte ptr[ebx] | |
2524 | |
2525 mov cl, N1 // read SubstTable[(N1+I+K)&0xFF]... | |
2526 add ecx, I | |
2527 add ecx, K | |
2528 and ecx, 0xFF | |
2529 add edx, ecx | |
2530 mov ah, byte ptr[edx] | |
2531 | |
2532 mov byte ptr[ebx], ah // and write back | |
2533 mov byte ptr[edx], al | |
2534 | |
2535 } | |
2536 #else | |
2537 __asm__ __volatile__ ( | |
2538 " xorl %%ecx, %%ecx" | |
2539 " movl %2, %%ecx /* ecx = N1 */" | |
2540 " mov %%ebx, %%edx" | |
2541 " addl %%ecx, %%ebx" | |
2542 "" | |
2543 " addl %0, %%ecx" | |
2544 " addl %1, %%ecx" | |
2545 " andl $0x000000FF, %%ecx" | |
2546 " addl %%ecx, %%edx" | |
2547 " " | |
2548 " movb (%%ebx), %%al" | |
2549 " movb (%%edx), %%ah" | |
2550 "" | |
2551 " movb %%ah, (%%ebx) /* and write back */" | |
2552 " movb %%al, (%%edx)" | |
2553 : : "g" ((long)I), | |
2554 "g" ((long)K), | |
2555 "g" ((long)N1), | |
2556 "ebx"((long)SubstTable) | |
2557 : "ecx", "edx" | |
2558 | |
2559 ); | |
2560 #endif | |
2561 | |
2562 #else | |
2563 /* Swap(&SubstTable[N1],&SubstTable[(N1+I+K)&0xFF]); */ | |
2564 Ch=SubstTable[N1]; | |
2565 SubstTable[N1]=SubstTable[(N1+I+K)&0xFF]; | |
2566 SubstTable[(N1+I+K)&0xFF]=Ch; | |
2567 #endif | |
2568 } | |
2569 } | |
2570 for (I=0;I<PswLength;I+=16) | |
2571 EncryptBlock(&Psw[I]); | |
2572 } | |
2573 | |
2574 | |
2575 void SetOldKeys(char *Password) | |
2576 { | |
2577 UDWORD PswCRC; | |
2578 UBYTE Ch; | |
2579 PswCRC=CalcCRC32(0xFFFFFFFFL,(UBYTE*)Password,strlen(Password)); | |
2580 OldKey[0]=(UWORD)PswCRC; | |
2581 OldKey[1]=(UWORD)(PswCRC>>16); | |
2582 OldKey[2]=OldKey[3]=0; | |
2583 PN1=PN2=PN3=0; | |
2584 while ((Ch=*Password)!=0) | |
2585 { | |
2586 PN1+=Ch; | |
2587 PN2^=Ch; | |
2588 PN3+=Ch; | |
2589 PN3=(UBYTE)rol(PN3,1); | |
2590 OldKey[2]^=((UWORD)(Ch^CRCTab[Ch])); | |
2591 OldKey[3]+=((UWORD)(Ch+(CRCTab[Ch]>>16))); | |
2592 Password++; | |
2593 } | |
2594 } | |
2595 | |
2596 void InitCRC(void) | |
2597 { | |
2598 int I, J; | |
2599 UDWORD C; | |
2600 for (I=0;I<256;I++) | |
2601 { | |
2602 for (C=I,J=0;J<8;J++) | |
2603 C=(C & 1) ? (C>>1)^0xEDB88320L : (C>>1); | |
2604 CRCTab[I]=C; | |
2605 } | |
2606 } | |
2607 | |
2608 | |
2609 UDWORD CalcCRC32(UDWORD StartCRC,UBYTE *Addr,UDWORD Size) | |
2610 { | |
2611 unsigned int I; | |
2612 for (I=0; I<Size; I++) | |
2613 StartCRC = CRCTab[(UBYTE)StartCRC ^ Addr[I]] ^ (StartCRC >> 8); | |
2614 return(StartCRC); | |
2615 } | |
2616 | |
2617 | |
2618 /* ************************************************************************** | |
2619 **************************************************************************** | |
2620 **************************************************************************** | |
2621 ************************************************************************** */ | |
2622 | |
2623 | |
2624 | |
2625 | |
2626 | |
2627 | |
2628 | |
2629 | |
2630 | |
2631 | |
2632 | |
2633 | |
2634 | |
2635 | |
2636 | |
2637 | |
2638 | |
2639 | |
2640 | |
2641 | |
2642 | |
2643 | |
2644 | |
2645 | |
2646 | |
2647 /* ************************************************************************** | |
2648 **************************************************************************** | |
2649 **************************************************************************** | |
2650 **************************************************************************** | |
2651 ******* ******* | |
2652 ******* ******* | |
2653 ******* ******* | |
2654 ******* D E B U G F U N C T I O N S ******* | |
2655 ******* ******* | |
2656 ******* ******* | |
2657 ******* ******* | |
2658 **************************************************************************** | |
2659 **************************************************************************** | |
2660 **************************************************************************** | |
2661 ************************************************************************** */ | |
2662 #ifdef _DEBUG_LOG | |
2663 | |
2664 | |
2665 /* -- global stuff -------------------------------------------------------- */ | |
2666 char log_file_name[256]; /* file name for the log file */ | |
2667 DWORD debug_start_time; /* starttime of debug */ | |
2668 BOOL debug_started = FALSE; /* debug_log writes only if */ | |
2669 /* this is TRUE */ | |
2670 /* ------------------------------------------------------------------------ */ | |
2671 | |
2672 | |
2673 /* -- global functions ---------------------------------------------------- */ | |
2674 void debug_init_proc(char *file_name) | |
2675 /* Create/Rewrite a log file */ | |
2676 { | |
2677 FILE *fp; | |
2678 char date[] = __DATE__; | |
2679 char time[] = __TIME__; | |
2680 | |
2681 debug_start_time = GetTickCount(); /* get start time */ | |
2682 strcpy(log_file_name, file_name); /* save file name */ | |
2683 | |
2684 if((fp = fopen(log_file_name, CREATETEXT)) != NULL) | |
2685 { | |
2686 debug_started = TRUE; /* enable debug */ | |
2687 fprintf(fp, "Debug log of UniquE's RARFileLib\n"\ | |
2688 "~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~\n"); | |
2689 fprintf(fp, "(executable compiled on %s at %s)\n\n", date, time); | |
2690 fclose(fp); | |
2691 } | |
2692 } | |
2693 | |
2694 | |
2695 void debug_log_proc(char *text, char *sourcefile, int sourceline) | |
2696 /* add a line to the log file */ | |
2697 { | |
2698 FILE *fp; | |
2699 | |
2700 if(debug_started == FALSE) return; /* exit if not initialized */ | |
2701 | |
2702 if((fp = fopen(log_file_name, APPENDTEXT)) != NULL) /* append to logfile */ | |
2703 | |
2704 { | |
2705 fprintf(fp, " %8u ms (line %u in %s):\n - %s\n", | |
2706 (unsigned int)(GetTickCount() - debug_start_time), | |
2707 sourceline, sourcefile, text); | |
2708 fclose(fp); | |
2709 } | |
2710 } | |
2711 | |
2712 /* ------------------------------------------------------------------------ */ | |
2713 #endif | |
2714 /* ************************************************************************** | |
2715 **************************************************************************** | |
2716 **************************************************************************** | |
2717 ************************************************************************** */ | |
2718 | |
2719 | |
2720 /* end of file urarlib.c */ |