.if defined(WITH_LIBUNRAR)

WANT_AUTOMAKE_VER=      19

USE_AUTOCONF_VER=       259

LIB_DEPENDS+=		unrar.3:${PORTSDIR}/archivers/libunrar

pre-configure:

	cd ${WRKSRC} && \

	${ACLOCAL} && \

	${AUTOHEADER} && \

	${AUTOCONF} && \

	${AUTOMAKE}

.endif

.if defined(WITH_LIBUNRAR)

	${PATCH} -d  ${WRKSRC}/libclamav < ${PORTSDIR}/security/clamav/files/clamav-0.87-libunrar3.patch

.endif

diff -ruN clamav-0.84.orig/libclamav/Makefile.am clamav-0.84/libclamav/Makefile.am

--- clamav-0.84.orig/libclamav/Makefile.am	2005-04-20 03:33:17.000000000 +0400

+++ clamav-0.84/libclamav/Makefile.am	2005-05-04 02:12:02.540693464 +0400

@@ -17,6 +17,8 @@

 INCLUDES = -I$(top_srcdir) -I@srcdir@/zziplib -I@srcdir@/mspack

+CFLAGS = @CFLAGS@ -DUNRAR3

+LDFLAGS = @LDFLAGS@ -lunrar

 libclamav_la_LIBADD = @LIBCLAMAV_LIBS@

diff -ruN clamav-0.84.orig/libclamav/scanners.c clamav-0.84/libclamav/scanners.c

--- clamav-0.84.orig/libclamav/scanners.c	2005-04-29 05:31:10.000000000 +0400

+++ clamav-0.84/libclamav/scanners.c	2005-05-04 02:12:02.543693008 +0400

@@ -42,12 +42,13 @@

 #include <mspack.h>

+#ifndef UNRAR3

 #ifdef CL_THREAD_SAFE

 #  include <pthread.h>

 pthread_mutex_t cli_scanrar_mutex = PTHREAD_MUTEX_INITIALIZER;

 #endif

 int cli_scanrar_inuse = 0;

-

+#endif

 extern short cli_leavetemps_flag;

 extern int cli_mbox(const char *dir, int desc, unsigned int options); /* FIXME */

@@ -111,6 +112,7 @@

 static int cli_scanfile(const char *filename, const char **virname, unsigned long int *scanned, const struct cl_node *root, const struct cl_limits *limits, unsigned int options, unsigned int arec, unsigned int mrec);

+#ifndef UNRAR3

 #ifdef CL_THREAD_SAFE

 static void cli_unlock_mutex(void *mtx)

 {

@@ -330,6 +332,7 @@

     return ret;

 }

+#endif

 #ifdef HAVE_ZLIB_H

 static int cli_scanzip(int desc, const char **virname, long int *scanned, const struct cl_node *root, const struct cl_limits *limits, unsigned int options, unsigned int arec, unsigned int mrec)

@@ -1213,6 +1216,43 @@

     return ret;

 }

+#ifdef UNRAR3

+static int cli_scanrar3(int desc, const char **virname, long int *scanned, const struct cl_node *root, const struct cl_limits *limits, unsigned int options, unsigned int arec, unsigned int mrec)

+{

+	const char *tmpdir;

+	char *dir;

+	int ret = CL_CLEAN;

+

+

+	cli_dbgmsg("in cli_scanrar3()\n");

+

+	if((tmpdir = getenv("TMPDIR")) == NULL)

+#ifdef P_tmpdir

+    	    tmpdir = P_tmpdir;

+#else

+    	    tmpdir = "/tmp";

+#endif

+

+     /* generate temporary directory */

+        dir = cli_gentemp(tmpdir);

+        if(mkdir(dir, 0700)) {

+    	    cli_errmsg("Rar3: Can't create temporary directory %s\n", dir);

+    	    return CL_ETMPDIR;

+        }

+

+        if((ret = cli_unrar3(dir, desc)))

+    	    cli_dbgmsg("Rar3: %s\n", cl_strerror(ret));

+        else

+    	    ret = cli_scandir(dir, virname, scanned, root, limits, options, arec, mrec);

+

+        if(!cli_leavetemps_flag)

+    	    cli_rmdirs(dir);

+

+        free(dir);

+        return ret;

+}

+#endif

+

 static int cli_scanmschm(int desc, const char **virname, long int *scanned, const struct cl_node *root, const struct cl_limits *limits, unsigned int options, unsigned int arec, unsigned int mrec)

 {

 	char *tempname;

@@ -1400,8 +1440,13 @@

     switch(type) {

 	case CL_TYPE_RAR:

+#ifdef UNRAR3

+	    if(!DISABLE_RAR && SCAN_ARCHIVE)

+		ret = cli_scanrar3(desc, virname, scanned, root, limits, options, arec, mrec);

+#else

 	    if(!DISABLE_RAR && SCAN_ARCHIVE && !cli_scanrar_inuse)

 		ret = cli_scanrar(desc, virname, scanned, root, limits, options, arec, mrec);

+#endif

 	    break;

 	case CL_TYPE_ZIP:

@@ -1538,8 +1583,17 @@

 	 * in raw mode. Now we will try to unpack them

 	 */

 	case CL_TYPE_MSEXE:

+#ifdef UNRAR3

+	    if(!DISABLE_RAR && SCAN_ARCHIVE)

+		ret = cli_scanrar3(desc, virname, scanned, root, limits, options, arec, mrec);

+	    if(SCAN_PE && ret != CL_VIRUS)

+#else

 	    if(SCAN_PE)

+#endif

+	    {

+		lseek(desc, 0, SEEK_SET);

 		ret = cli_scanpe(desc, virname, scanned, root, limits, options, arec, mrec);

+	    }

 	    break;

 	default:

diff -ruN clamav-0.84.orig/libclamav/unrarlib.c clamav-0.84/libclamav/unrarlib.c

--- clamav-0.84.orig/libclamav/unrarlib.c	2005-04-20 03:33:17.000000000 +0400

+++ clamav-0.84/libclamav/unrarlib.c	2005-05-04 02:12:27.131955024 +0400

@@ -1,2774 +1,119 @@

-/* It contains some changes needed for libclamav and isn't compatible with

- * the original version, --tk

+/*

+ *  Copyright (C) 2004 McMCC <mcmcc@mail.ru>

+ *

+ *  Support check archives RAR v.3.x

+ *

+ *  This program is free software; you can redistribute it and/or modify

+ *  it under the terms of the GNU General Public License as published by

+ *  the Free Software Foundation; either version 2 of the License, or

+ *  (at your option) any later version.

+ *

+ *  This program is distributed in the hope that it will be useful,

+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of

+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ *  GNU General Public License for more details.

+ *

+ *  You should have received a copy of the GNU General Public License

+ *  along with this program; if not, write to the Free Software

+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

+ *

  */

-/* ***************************************************************************

- **

- **  This file is part of the UniquE RAR File Library.

- **

- **  Copyright (C) 2000-2002 by Christian Scheurer (www.ChristianScheurer.ch)

- **  UNIX port copyright (c) 2000-2002 by Johannes Winkelmann (jw@tks6.net)

- **

- **  The contents of this file are subject to the UniquE RAR File Library

- **  License (the "unrarlib-license.txt"). You may not use this file except

- **  in compliance with the License. You may obtain a copy of the License

- **  at http://www.unrarlib.org/license.html.

- **  Software distributed under the License is distributed on an "AS IS"

- **  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied warranty.

- **

- **  Alternatively, the contents of this file may be used under the terms

- **  of the GNU General Public License Version 2 or later (the "GPL"), in

- **  which case the provisions of the GPL are applicable instead of those

- **  above. If you wish to allow use of your version of this file only

- **  under the terms of the GPL and not to allow others to use your version

- **  of this file under the terms of the UniquE RAR File Library License,

- **  indicate your decision by deleting the provisions above and replace

- **  them with the notice and other provisions required by the GPL. If you

- **  do not delete the provisions above, a recipient may use your version

- **  of this file under the terms of the GPL or the UniquE RAR File Library

- **  License.

- **

- ************************************************************************** */

-

-/* ***************************************************************************

- **

- **                           UniquE RAR File Library

- **                     The free file lib for the demoscene

- **                   multi-OS version (Win32, Linux and SunOS)

- **

- *****************************************************************************

- **

- **   ==> Please configure the program in "unrarlib.h". <==

- **

- **   RAR decompression code:

- **    (C) Eugene Roshal

- **   Modifications to a FileLib:

- **    (C) 2000-2002 Christian Scheurer aka. UniquE/Vantage (cs@unrarlib.org)

- **   Linux port:

- **    (C) 2000-2002 Johannes Winkelmann (jw@tks6.net)

- **

- **  The UniquE RAR File Library gives you the ability to access RAR archives

- **  (any compression method supported in RAR v2.0 including Multimedia

- **  Compression and encryption) directly from your program with ease an by

- **  adding only 12kB (6kB UPX-compressed) additional code to your program.

- **  Both solid and normal (recommended for fast random access to the files!)

- **  archives are supported. This FileLib is made for the Demo scene, so it's

- **  designed for easy use within your demos and intros.

- **  Please read "licence.txt" to learn more about how you may use URARFileLib

- **  in your productions.

- **

- *****************************************************************************

- **

- **  ==> see the "CHANGES" file to see what's new

- **

- ************************************************************************** */

-

-/* -- include files ------------------------------------------------------- */

-#if HAVE_CONFIG_H

-#include "clamav-config.h"

-#endif

-

-#include "unrarlib.h"                       /* include global configuration */

-#include "others.h"

-/* ------------------------------------------------------------------------ */

-

+static char const rcsid[] = "$Id: unrarlib.c,v 1.0 2004/10/20 18:18:46 mcmcc Exp $";

-

-/* -- global stuff -------------------------------------------------------- */

-#ifdef _WIN_32

-

-#include <windows.h>                        /* WIN32 definitions            */

 #include <stdio.h>

-#include <string.h>

-

-

-#define ENABLE_ACCESS

-

-#define HOST_OS     WIN_32

-

-#define FM_NORMAL   0x00

-#define FM_RDONLY   0x01

-#define FM_HIDDEN   0x02

-#define FM_SYSTEM   0x04

-#define FM_LABEL    0x08

-#define FM_DIREC    0x10

-#define FM_ARCH     0x20

-

-#define PATHDIVIDER  "\\"

-#define CPATHDIVIDER '\\'

-#define MASKALL      "*.*"

-

-#define READBINARY   "rb"

-#define READTEXT     "rt"

-#define UPDATEBINARY "r+b"

-#define CREATEBINARY "w+b"

-#define CREATETEXT   "w"

-#define APPENDTEXT   "at"

-

-#endif

-

-#ifdef _UNIX

-

-#include <stdio.h>                          /* LINUX/UNIX definitions       */

 #include <stdlib.h>

-#include <unistd.h>

-#include <ctype.h>

-#include <string.h>

 #include <errno.h>

-

-#define ENABLE_ACCESS

-

-#define HOST_OS     UNIX

-

-#define FM_LABEL    0x0000

-#define FM_DIREC    0x4000

-

-#define PATHDIVIDER  "/"

-#define CPATHDIVIDER '/'

-#define MASKALL      "*.*"

-

-#define READBINARY   "r"

-#define READTEXT     "r"

-#define UPDATEBINARY "r+"

-#define CREATEBINARY "w+"

-#define CREATETEXT   "w"

-#define APPENDTEXT   "a"

-

-

-/* emulation of the windows API and data types                              */

-/* 20-08-2000 Johannes Winkelmann, jw@tks6.net                              */

-

-typedef long    DWORD;

-typedef short   BOOL;

-#define TRUE    1

-#define FALSE   0

-

-

-#ifdef _DEBUG_LOG                           /* define macros for debugging  */

+#include <string.h>

 #include <unistd.h>

-#include <sys/time.h>

-

-DWORD GetTickCount()

-{

-    struct timeval tv;

-    gettimeofday( &tv, 0 );

-    return (tv.tv_usec / 1000);

-}

-#endif

-

-#endif

-

-

-

-

-

-#ifdef _DEBUG_LOG                           /* define macros for debugging  */

-

-BOOL debug_log_first_start = TRUE;

-

-#define debug_log(a); debug_log_proc(a, __FILE__, __LINE__);

-#define debug_init(a); debug_init_proc(a);

-

-void debug_log_proc(char *text, char *sourcefile, int sourceline);

-void debug_init_proc(char *file_name);

-

-#else

-#define debug_log(a);	cli_dbgmsg("%s:%d %s\n", __FILE__, __LINE__, a);

-#define debug_init(a);  /* no debug this time */

-#endif

-

-

-

-

-

-#define MAXWINSIZE      0x100000

-#define MAXWINMASK      (MAXWINSIZE-1)

-#define UNP_MEMORY      MAXWINSIZE

-#define Min(x,y) (((x)<(y)) ? (x):(y))

-#define Max(x,y) (((x)>(y)) ? (x):(y))

-#define NM  260

-

-#define SIZEOF_MARKHEAD         7

-#define SIZEOF_OLDMHD           7

-#define SIZEOF_NEWMHD          13

-#define SIZEOF_OLDLHD          21

-#define SIZEOF_NEWLHD          32

-#define SIZEOF_SHORTBLOCKHEAD   7

-#define SIZEOF_LONGBLOCKHEAD   11

-#define SIZEOF_COMMHEAD        13

-#define SIZEOF_PROTECTHEAD     26

-

-

-#define PACK_VER       20                   /* version of decompression code*/

-#define UNP_VER        20

-#define PROTECT_VER    20

-

-

-enum { M_DENYREAD,M_DENYWRITE,M_DENYNONE,M_DENYALL };

-enum { FILE_EMPTY,FILE_ADD,FILE_UPDATE,FILE_COPYOLD,FILE_COPYBLOCK };

-enum { SUCCESS,WARNING,FATAL_ERROR,CRC_ERROR,LOCK_ERROR,WRITE_ERROR,

-       OPEN_ERROR,USER_ERROR,MEMORY_ERROR,USER_BREAK=255,IMM_ABORT=0x8000 };

-enum { EN_LOCK=1,EN_VOL=2 };

-enum { SD_MEMORY=1,SD_FILES=2 };

-enum { NAMES_DONTCHANGE };

-enum { LOG_ARC=1,LOG_FILE=2 };

-enum { OLD_DECODE=0,OLD_ENCODE=1,NEW_CRYPT=2 };

-enum { OLD_UNPACK,NEW_UNPACK };

-

-

-#define MHD_COMMENT        2

-#define MHD_LOCK           4

-#define MHD_PACK_COMMENT   16

-#define MHD_AV             32

-#define MHD_PROTECT        64

-

-#define LHD_SPLIT_BEFORE   1

-#define LHD_SPLIT_AFTER    2

-#define LHD_PASSWORD       4

-#define LHD_COMMENT        8

-#define LHD_SOLID          16

-

-#define LHD_WINDOWMASK     0x00e0

-#define LHD_WINDOW64       0

-#define LHD_WINDOW128      32

-#define LHD_WINDOW256      64

-#define LHD_WINDOW512      96

-#define LHD_WINDOW1024     128

-#define LHD_DIRECTORY      0x00e0

-

-#define LONG_BLOCK         0x8000

-#define READSUBBLOCK       0x8000

-

-enum { ALL_HEAD=0,MARK_HEAD=0x72,MAIN_HEAD=0x73,FILE_HEAD=0x74,

-       COMM_HEAD=0x75,AV_HEAD=0x76,SUB_HEAD=0x77,PROTECT_HEAD=0x78};

-enum { EA_HEAD=0x100 };

-enum { MS_DOS=0,OS2=1,WIN_32=2,UNIX=3 };

-

-

-struct MarkHeader

-{

-  UBYTE Mark[7];

-};

-

-

-struct NewMainArchiveHeader

-{

-  UWORD HeadCRC;

-  UBYTE HeadType;

-  UWORD Flags;

-  UWORD HeadSize;

-  UWORD Reserved;

-  UDWORD Reserved1;

-};

-

-

-struct NewFileHeader

-{

-  UWORD HeadCRC;

-  UBYTE HeadType;

-  UWORD Flags;

-  UWORD HeadSize;

-  UDWORD PackSize;

-  UDWORD UnpSize;

-  UBYTE HostOS;

-  UDWORD FileCRC;

-  UDWORD FileTime;

-  UBYTE UnpVer;

-  UBYTE Method;

-  UWORD NameSize;

-  UDWORD FileAttr;

-};

-

-

-struct BlockHeader

-{

-  UWORD HeadCRC;

-  UBYTE HeadType;

-  UWORD Flags;

-  UWORD HeadSize;

-  UDWORD DataSize;

-};

-

-

-struct Decode

-{

-  unsigned int MaxNum;

-  unsigned int DecodeLen[16];

-  unsigned int DecodePos[16];

-  unsigned int DecodeNum[2];

-};

-

-

-static struct MarkHeader MarkHead;

-static struct NewMainArchiveHeader NewMhd;

-static struct NewFileHeader NewLhd;

-static struct BlockHeader BlockHead;

-

-static UBYTE *TempMemory = NULL;                          /* temporary unpack-buffer      */

-static char *CommMemory = NULL;

-

-

-static UBYTE *UnpMemory = NULL;

-static char ArgName[NM];                           /* current file in rar archive  */

-static char ArcFileName[NM];                       /* file to decompress           */

-

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION  /* mem-to-mem decompression     */

-static  MemoryFile *MemRARFile;                   /* pointer to RAR file in memory*/

-#else

-static  FILE *ArcPtr;                             /* input RAR file handler       */

-#endif

-static char Password[255];                         /* password to decrypt files    */

-

-static unsigned char *temp_output_buffer;          /* extract files to this pointer*/

-static unsigned long *temp_output_buffer_offset;   /* size of temp. extract buffer */

-

-static int MainHeadSize;

-

-static long CurBlockPos,NextBlockPos;

-

-static unsigned long CurUnpRead;

-static long UnpPackedSize;

-static long DestUnpSize;

-

-static UDWORD HeaderCRC;

-static int Encryption;

-

-static unsigned int UnpPtr,WrPtr;

-

-static unsigned char PN1,PN2,PN3;

-static unsigned short OldKey[4];

-

-

-

-/* function header definitions                                              */

-static int ReadHeader(int BlockType);

-static BOOL ExtrFile(int desc);

-static int tread(void *stream,void *buf,unsigned len);

-static int tseek(void *stream,long offset,int fromwhere);

-/* static BOOL UnstoreFile(void); */

-static int IsArchive(void);

-static int ReadBlock(int BlockType);

-static unsigned int UnpRead(unsigned char *Addr,unsigned int Count);

-static void UnpInitData(void);

-static void Unpack(unsigned char *UnpAddr, BOOL FileFound);

-static UBYTE DecodeAudio(int Delta);

-static void DecodeNumber(struct Decode *Dec);

-static void UpdKeys(UBYTE *Buf);

-static void SetCryptKeys(char* NewPassword);

-static void SetOldKeys(char *NewPassword);

-static void DecryptBlock(unsigned char *Buf);

-static void InitCRC(void);

-static UDWORD CalcCRC32(UDWORD StartCRC,UBYTE *Addr,UDWORD Size);

-static void UnpReadBuf(int FirstBuf);

-static void ReadTables(void);

-static void ReadLastTables(void);

-static void MakeDecodeTables(unsigned char *LenTab,

-                             struct Decode *Dec,

-                             int Size);

-static int stricomp(char *Str1,char *Str2);

-/* ------------------------------------------------------------------------ */

-

-

-/* -- global functions ---------------------------------------------------- */

-

-int urarlib_get(void *output,

-                unsigned long *size,

-                char *filename,

-                int desc,

-                char *libpassword)

-/* Get a file from a RAR file to the "output" buffer. The UniquE RAR FileLib

- * does everything from allocating memory, decrypting and unpacking the file

- * from the archive. TRUE is returned if the file could be successfully

- * extracted, else a FALSE indicates a failure.

- */

-{

-  BOOL  retcode = FALSE;

-

-#ifdef _DEBUG_LOG

-  int  str_offs;                            /* used for debug-strings       */

-  char DebugMsg[500];                       /* used to compose debug msg    */

-

-  if(debug_log_first_start)

-  {

-    debug_log_first_start=FALSE;            /* only create a new log file   */

-    debug_init(_DEBUG_LOG_FILE);            /* on startup                   */

-  }

-

-#endif

-

-  InitCRC();                                /* init some vars               */

-

-  strcpy(ArgName, filename);                /* set file(s) to extract       */

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-  MemRARFile = rarfile;                     /* set pointer to mem-RAR file  */

-#endif

-  if(libpassword != NULL)

-    strcpy(Password, libpassword);          /* init password                */

-

-  temp_output_buffer = NULL;

-  temp_output_buffer_offset=size;           /* set size of the temp buffer  */

-

-  retcode = ExtrFile(desc);                     /* unpack file now! */

-

-

-  memset(Password,0,sizeof(Password));      /* clear password               */

-

-#ifndef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-  if (ArcPtr!=NULL){

-      /* FIXME: possible FILE* leak */

-      cli_dbgmsg("%s:%d NOT Close ArcPtr from fd %d\n", __FILE__, __LINE__, desc);

-      /*

-      fclose(ArcPtr);

-      lseek(desc, 0, SEEK_SET);

-      ArcPtr = NULL;

-      */

-  }

-#endif

-

-  if(UnpMemory)

-    free(UnpMemory);

-

-  if(TempMemory)

-    free(TempMemory);

-

-  if(CommMemory)

-    free(CommMemory);

-

-  UnpMemory=NULL;

-  TempMemory=NULL;

-  CommMemory=NULL;

-

-

-  if(retcode == FALSE)

-  {

-    if(temp_output_buffer)

-	free(temp_output_buffer);               /* free memory and return NULL  */

-    temp_output_buffer=NULL;

-    *(DWORD*)output=0;                      /* pointer on errors            */

-    *size=0;

-#ifdef _DEBUG_LOG

-

-

-   /* sorry for this ugly code, but older SunOS gcc compilers don't support */

-   /* white spaces within strings                                           */

-   str_offs  = sprintf(DebugMsg, "Error - couldn't extract ");

-   str_offs += sprintf(DebugMsg + str_offs, ">%s<", filename);

-   str_offs += sprintf(DebugMsg + str_offs, " and allocated ");

-   str_offs += sprintf(DebugMsg + str_offs, "%u Bytes", (unsigned int)*size);

-   str_offs += sprintf(DebugMsg + str_offs, " of unused memory!");

-

-  } else

-  {

-    sprintf(DebugMsg, "Extracted %u Bytes.", (unsigned int)*size);

-  }

-  debug_log(DebugMsg);

-#else

-  }

-#endif

-  *(DWORD*)output=(DWORD)temp_output_buffer;/* return pointer for unpacked*/

-                                            /* data                       */

-

-  return retcode;

-}

-

-

-int urarlib_list(int desc, ArchiveList_struct *list)

-{

-  ArchiveList_struct *tmp_List = NULL;

-  int NoOfFilesInArchive       = 0;         /* number of files in archive   */

-  int newdesc;

-

-#ifdef _DEBUG_LOG

-  if(debug_log_first_start)

-  {

-    debug_log_first_start=FALSE;            /* only create a new log file   */

-    debug_init(_DEBUG_LOG_FILE);            /* on startup                   */

-  }

-#endif

-

-  InitCRC();                                /* init some vars               */

-

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-  MemRARFile         = rarfile;             /* assign pointer to RAR file   */

-  MemRARFile->offset = 0;

-  if (!IsArchive())

-  {

-    debug_log("Not a RAR file");

-    return NoOfFilesInArchive;              /* error => exit!               */

-  }

-#else

-  /* open and identify archive                                              */

-  newdesc = dup(desc);

-  cli_dbgmsg("ExtrFile(): dup(%d) = %d\n", desc, newdesc);

-  if ((ArcPtr=fdopen(newdesc,READBINARY))!=NULL)

-  {

-    if (!IsArchive())

-    {

-      cli_dbgmsg("urarlib_list(): Not a valid archive.");

-      debug_log("Not a RAR file");

-      fclose(ArcPtr);

-      lseek(desc, 0, SEEK_SET);

-      ArcPtr = NULL;

-      return NoOfFilesInArchive;            /* error => exit!               */

-    }

-  }

-  else {

-    cli_dbgmsg("urarlib_list(): Error opening file: %s", strerror(errno));

-    debug_log("Error opening file.");

-    cli_dbgmsg("%s:%d Close fd %d\n", __FILE__, __LINE__, newdesc);

-    close(newdesc);

-    return NoOfFilesInArchive;

-  }

-#endif

-

-  if ((UnpMemory=malloc(UNP_MEMORY))==NULL)

-  {

-    cli_dbgmsg("urarlib_list(): out of memory.");

-    debug_log("Can't allocate memory for decompression!");

-    fclose(ArcPtr);

-    return NoOfFilesInArchive;

-  }

-

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-  MemRARFile->offset+=NewMhd.HeadSize-MainHeadSize;

-#else

-  tseek(ArcPtr,NewMhd.HeadSize-MainHeadSize,SEEK_CUR);

-#endif

-  (*(DWORD*)list) = (DWORD)NULL;            /* init file list               */

-  /* do while file is not extracted and there's no error                    */

-  for(;;)

-  {

-    int ReadBlockResult;

-    if ((ReadBlockResult = ReadBlock(FILE_HEAD | READSUBBLOCK)) <= 0) /* read name of the next  */

-    {                                       /* file within the RAR archive  */

-      cli_dbgmsg("Couldn't read next filename from archive (I/O error): %d\n", ReadBlockResult);

-      break;                                /* error, file not found in     */

-    }                                       /* archive or I/O error         */

-    if (BlockHead.HeadType==SUB_HEAD)

-    {

-      debug_log("Sorry, sub-headers not supported.");

-      NoOfFilesInArchive = 0;

-      break;                                /* error => exit                */

-    }

-

-    if((void*)(*(DWORD*)list) == NULL)      /* first entry                  */

-    {

-      tmp_List = malloc(sizeof(ArchiveList_struct));

-      tmp_List->next = NULL;

-

-      (*(DWORD*)list) = (DWORD)tmp_List;

-

-    } else                                  /* add entry                    */

-    {

-      tmp_List->next = malloc(sizeof(ArchiveList_struct));

-      tmp_List = (ArchiveList_struct*) tmp_List->next;

-      tmp_List->next = NULL;

-    }

-

-    tmp_List->item.Name = malloc(NewLhd.NameSize + 1);

-    strcpy(tmp_List->item.Name, ArcFileName);

-    tmp_List->item.NameSize = NewLhd.NameSize;

-    tmp_List->item.PackSize = NewLhd.PackSize;

-    tmp_List->item.UnpSize = NewLhd.UnpSize;

-    tmp_List->item.HostOS = NewLhd.HostOS;

-    tmp_List->item.FileCRC = NewLhd.FileCRC;

-    tmp_List->item.FileTime = NewLhd.FileTime;

-    tmp_List->item.UnpVer = NewLhd.UnpVer;

-    tmp_List->item.Method = NewLhd.Method;

-    tmp_List->item.FileAttr = NewLhd.FileAttr;

-    tmp_List->item.Flags = NewLhd.Flags;

-

-    NoOfFilesInArchive++;                   /* count files                  */

-

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-    MemRARFile->offset = NextBlockPos;

-#else

-    if (ArcPtr!=NULL) tseek(ArcPtr,NextBlockPos,SEEK_SET);

-#endif

-

-  };

-

-  /* free memory, clear password and close archive                          */

-  memset(Password,0,sizeof(Password));      /* clear password               */

-#ifndef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-  if (ArcPtr!=NULL){

-      fclose(ArcPtr);

-      ArcPtr = NULL;

-      lseek(desc, 0, SEEK_SET);

-  }

-#endif

-

-  if(UnpMemory)

-    free(UnpMemory);

-

-  if(TempMemory)

-    free(TempMemory);

-

-  if(CommMemory)

-    free(CommMemory);

-

-  UnpMemory=NULL;

-  TempMemory=NULL;

-  CommMemory=NULL;

-

-  return NoOfFilesInArchive;

-}

-

-

-

-/* urarlib_freelist:

- * (after the suggestion and code of Duy Nguyen, Sean O'Blarney

- * and Johannes Winkelmann who independently wrote a patch)

- * free the memory of a ArchiveList_struct created by urarlib_list.

- *

- *    input: *list          pointer to an ArchiveList_struct

- *    output: -

- */

-

-void urarlib_freelist(ArchiveList_struct *list)

-{

-    ArchiveList_struct* tmp = list;

-

-    while ( list ) {

-        tmp = list->next;

-        free( list->item.Name );

-        free( list );

-        list = tmp;

-    }

-}

-

-

-/* ------------------------------------------------------------------------ */

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-/****************************************************************************

- ****************************************************************************

- ****************************************************************************

- ****************************************************************************

- *******                                                              *******

- *******                                                              *******

- *******                                                              *******

- *******                    B L O C K   I / O                         *******

- *******                                                              *******

- *******                                                              *******

- *******                                                              *******

- ****************************************************************************

- ****************************************************************************

- ****************************************************************************

- ****************************************************************************/

-

-

-

-#define GetHeaderByte(N) Header[N]

-

-#define GetHeaderWord(N) (Header[N]+((UWORD)Header[N+1]<<8))

-

-#define GetHeaderDword(N) (Header[N]+((UWORD)Header[N+1]<<8)+\

-                          ((UDWORD)Header[N+2]<<16)+\

-                          ((UDWORD)Header[N+3]<<24))

-

-

-int ReadBlock(int BlockType)

-{

-  struct NewFileHeader SaveFileHead;

-  int Size=0,ReadSubBlock=0;

-  static int LastBlock;

-  memcpy(&SaveFileHead,&NewLhd,sizeof(SaveFileHead));

-  if (BlockType & READSUBBLOCK) {

-    ReadSubBlock=1;

-    BlockType &= 0xff;

-  }

-  {

-    while (1)

-    {

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-      CurBlockPos=MemRARFile->offset;       /* get offset of mem-file       */

-#else

-      CurBlockPos=ftell(ArcPtr);

-#endif

-      Size=ReadHeader(FILE_HEAD);

-      if (Size!=0)

-      {

-        if (NewLhd.HeadSize<SIZEOF_SHORTBLOCKHEAD)

-          return(0);

-        NextBlockPos=CurBlockPos+NewLhd.HeadSize;

-        if (NewLhd.Flags & LONG_BLOCK)

-          NextBlockPos+=NewLhd.PackSize;

-        if (NextBlockPos<=CurBlockPos)

-          return(0);

-      }

-

-      if (Size > 0 && BlockType!=SUB_HEAD)

-        LastBlock=BlockType;

-      if (Size==0 || BlockType==ALL_HEAD || NewLhd.HeadType==BlockType ||

-          (NewLhd.HeadType==SUB_HEAD && ReadSubBlock && LastBlock==BlockType))

-        break;

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-      MemRARFile->offset = NextBlockPos;

-#else

-      tseek(ArcPtr, NextBlockPos, SEEK_SET);

-#endif

+#include <sys/stat.h>

+#include <fcntl.h>

+#include <sys/param.h>

+#include <libunrar3/dll.hpp>

+#include "clamav.h"

+#include "others.h"

+#include "unrarlib.h"

+#include "mbox.h"

+#include "blob.h"

+

+int cli_unrar3(const char *dir, int desc)

+{

+

+    struct RAROpenArchiveDataEx OpenArchiveData;

+    struct RARHeaderData HeaderData;

+    int iReadHeaderCode, iProcessFileCode, fd, s_buff;

+    char buff[4096], uname[48];

+    const char *tmpdir;

+    HANDLE hArcData;

+    FILE *out;

+

+    if((tmpdir = getenv("TMPDIR")) == NULL)

+#ifdef P_tmpdir

+        tmpdir = P_tmpdir;

+#else

+        tmpdir = "/tmp";

+#endif

+

+    sprintf(uname, "%s/rarXXXXXX", tmpdir);

+

+    if((fd = mkstemp(uname)) < 0 || (out = fdopen(fd, "w+")) == NULL)

+    {

+	

+	cli_dbgmsg("cli_unrar3: can't generate temporary file %s or open descriptor %d.\n", 

+		    uname, fd);

+	if(fd >= 0)

+	    close(fd);

+	unlink(uname);

+	return CL_ETMPFILE;

+    }	

+

+    while((s_buff=read(desc, buff, sizeof(buff))) > 0) 

+    {    

+    	if(fwrite(buff, 1, s_buff, out) != s_buff)

+	{

+	    cli_dbgmsg("cli_unrar3: can't write to file %s.\n", uname); 

+	    fclose(out);

+	    close(fd);

+	    unlink(uname);

+	    return CL_EOPEN;

+	}

     }

-  }

-

-  BlockHead.HeadCRC=NewLhd.HeadCRC;

-  BlockHead.HeadType=NewLhd.HeadType;

-  BlockHead.Flags=NewLhd.Flags;

-  BlockHead.HeadSize=NewLhd.HeadSize;

-  BlockHead.DataSize=NewLhd.PackSize;

-

-  if (BlockType!=NewLhd.HeadType) BlockType=ALL_HEAD;

-

-  if((FILE_HEAD == BlockType) && (Size>0))

-  {

-    NewLhd.NameSize=Min(NewLhd.NameSize,sizeof(ArcFileName)-1);

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-    tread(MemRARFile, ArcFileName, NewLhd.NameSize);

-#else

-    tread(ArcPtr,ArcFileName,NewLhd.NameSize);

-#endif

-    ArcFileName[NewLhd.NameSize]=0;

-#ifdef _DEBUG_LOG

-    if (NewLhd.HeadCRC!=(UWORD)~CalcCRC32(HeaderCRC,(UBYTE*)&ArcFileName[0],

-                                          NewLhd.NameSize))

-    {

-      debug_log("file header broken");

+    fclose(out);

+    close(fd);

+    

+    memset(&OpenArchiveData, 0, sizeof(OpenArchiveData));

+	

+    OpenArchiveData.ArcName         = uname; /* name arch */

+    OpenArchiveData.CmtBuf          = NULL;

+    OpenArchiveData.OpenMode        = RAR_OM_EXTRACT;

+		    

+    hArcData = RAROpenArchiveEx(&OpenArchiveData);

+			

+    if (OpenArchiveData.OpenResult != 0)

+    {

+        cli_dbgmsg("cli_unrar3: error archive open (%d)\n", OpenArchiveData.OpenResult);

+	unlink(uname);

+        return CL_EOPEN;

+    }

+						    

+    HeaderData.CmtBuf = NULL;

+									

+    while ((iReadHeaderCode = RARReadHeader(hArcData, &HeaderData)) == 0)

+    {

+        iProcessFileCode = RARProcessFile(hArcData, RAR_EXTRACT, (char *)dir, NULL);

+        if (iProcessFileCode != 0)

+	{

+            cli_dbgmsg("cli_unrar3: error archive extract (%d)\n", iProcessFileCode);

+            break;

+	}

+		    

     }

-#endif

-    Size+=NewLhd.NameSize;

-  } else

-  {

-    memcpy(&NewLhd,&SaveFileHead,sizeof(NewLhd));

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-    MemRARFile->offset = CurBlockPos;

-#else

-    tseek(ArcPtr,CurBlockPos,SEEK_SET);

-#endif

-  }

-

-

-  return(Size);

-}

-

-

-int ReadHeader(int BlockType)

-{

-  int Size = 0;

-  unsigned char Header[64];

-  memset(Header, 0, sizeof(Header));

-  switch(BlockType)

-  {

-    case MAIN_HEAD:

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-        Size=tread(MemRARFile, Header, SIZEOF_NEWMHD);

-#else

-        Size=tread(ArcPtr,Header,SIZEOF_NEWMHD);

-#endif

-        NewMhd.HeadCRC=(unsigned short)GetHeaderWord(0);

-        NewMhd.HeadType=GetHeaderByte(2);

-        NewMhd.Flags=(unsigned short)GetHeaderWord(3);

-        NewMhd.HeadSize=(unsigned short)GetHeaderWord(5);

-        NewMhd.Reserved=(unsigned short)GetHeaderWord(7);

-        NewMhd.Reserved1=GetHeaderDword(9);

-        HeaderCRC=CalcCRC32(0xFFFFFFFFL,&Header[2],SIZEOF_NEWMHD-2);

-      break;

-    case FILE_HEAD:

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-        Size=tread(MemRARFile, Header, SIZEOF_NEWLHD);

-#else

-        Size=tread(ArcPtr,Header,SIZEOF_NEWLHD);

-#endif

-        NewLhd.HeadCRC=(unsigned short)GetHeaderWord(0);

-        NewLhd.HeadType=GetHeaderByte(2);

-        NewLhd.Flags=(unsigned short)GetHeaderWord(3);

-        NewLhd.HeadSize=(unsigned short)GetHeaderWord(5);

-        NewLhd.PackSize=GetHeaderDword(7);

-        NewLhd.UnpSize=GetHeaderDword(11);

-        NewLhd.HostOS=GetHeaderByte(15);

-        NewLhd.FileCRC=GetHeaderDword(16);

-        NewLhd.FileTime=GetHeaderDword(20);

-        NewLhd.UnpVer=GetHeaderByte(24);

-        NewLhd.Method=GetHeaderByte(25);

-        NewLhd.NameSize=(unsigned short)GetHeaderWord(26);

-        NewLhd.FileAttr=GetHeaderDword(28);

-        HeaderCRC=CalcCRC32(0xFFFFFFFFL,Header+2,SIZEOF_NEWLHD-2);

-      break;

-

-#ifdef _DEBUG_LOG

-  case COMM_HEAD:                           /* log errors in case of debug  */

-        debug_log("Comment headers not supported! "\

-                  "Please create archives without comments.");

-      break;

-  case PROTECT_HEAD:

-        debug_log("Protected headers not supported!");

-      break;

-  case ALL_HEAD:

-        debug_log("ShortBlockHeader not supported!");

-      break;

-  default:

-        debug_log("Unknown//unsupported !");

-#else

-  default:                                  /* else do nothing              */

-        break;

-#endif

-  }

-  return(Size);

+					    

+    RARCloseArchive(hArcData);

+    unlink(uname);

+    

+    /*

+    if (iProcessFileCode == ERAR_BAD_DATA)

+	return CL_ERAR;

+    */

+    return CL_CLEAN;

 }

-

-/* **************************************************************************

- ****************************************************************************

- ****************************************************************************

- ************************************************************************** */

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-/* **************************************************************************

- ****************************************************************************

- ****************************************************************************

- ****************************************************************************

- *******                                                              *******

- *******                                                              *******

- *******                                                              *******

- *******                  E X T R A C T   L O O P                     *******

- *******                                                              *******

- *******                                                              *******

- *******                                                              *******

- ****************************************************************************

- ****************************************************************************

- ****************************************************************************

- ************************************************************************** */

-

-

-int IsArchive(void)

-{

-#ifdef _DEBUG_LOG

-  int  str_offs;                            /* used for debug-strings       */

-  char DebugMsg[500];                       /* used to compose debug msg    */

-#endif

-

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-  if (tread(MemRARFile, MarkHead.Mark, SIZEOF_MARKHEAD) != SIZEOF_MARKHEAD) {

-    debug_log("IsArchive(): short read: FALSE");

-    return(FALSE);

-  }

-#else

-  if (tread(ArcPtr,MarkHead.Mark,SIZEOF_MARKHEAD)!=SIZEOF_MARKHEAD) {

-    debug_log("IsArchive(): short read: FALSE");

-    return(FALSE);

-  }

-#endif

-  /* Old archive => error                                                   */

-  if (MarkHead.Mark[0]==0x52 && MarkHead.Mark[1]==0x45 &&

-      MarkHead.Mark[2]==0x7e && MarkHead.Mark[3]==0x5e)

-  {

-    debug_log("Attention: format as OLD detected! Can't handle archive!");

-  }

-  else

-      /* original RAR v2.0                                                  */

-      if ((MarkHead.Mark[0]==0x52 && MarkHead.Mark[1]==0x61 && /* original  */

-           MarkHead.Mark[2]==0x72 && MarkHead.Mark[3]==0x21 && /* RAR header*/

-           MarkHead.Mark[4]==0x1a && MarkHead.Mark[5]==0x07 &&

-           MarkHead.Mark[6]==0x00) ||

-     /* "UniquE!" - header                                                  */

-          (MarkHead.Mark[0]=='U' && MarkHead.Mark[1]=='n' &&   /* "UniquE!" */

-           MarkHead.Mark[2]=='i' && MarkHead.Mark[3]=='q' &&   /* header    */

-           MarkHead.Mark[4]=='u' && MarkHead.Mark[5]=='E' &&

-           MarkHead.Mark[6]=='!'))

-

-    {

-      if (ReadHeader(MAIN_HEAD)!=SIZEOF_NEWMHD) {

-        debug_log("IsArchive(): ReadHeader() failed");

-        return(FALSE);

-      }

-    } else

-    {

-

-#ifdef _DEBUG_LOG

-     /* sorry for this ugly code, but older SunOS gcc compilers don't       */

-     /* support white spaces within strings                                 */

-     str_offs  = sprintf(DebugMsg, "unknown archive type (only plain RAR ");

-     str_offs += sprintf(DebugMsg + str_offs, "supported (normal and solid ");

-     str_offs += sprintf(DebugMsg + str_offs, "archives), SFX and Volumes ");

-     str_offs += sprintf(DebugMsg + str_offs, "are NOT supported!)");

-

-     debug_log(DebugMsg);

-#endif

-

-    }

-

-

-  MainHeadSize=SIZEOF_NEWMHD;

-

-  return(TRUE);

-}

-

-

-BOOL ExtrFile(int desc)

-{

-  BOOL ReturnCode=TRUE;

-  BOOL FileFound=FALSE;                     /* TRUE=use current extracted   */

-                                            /* data FALSE=throw data away,  */

-                                            /* wrong file                   */

-  int newdesc;

-

-#ifdef  _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-  MemRARFile->offset = 0;                   /* start reading from offset 0  */

-  if (!IsArchive())

-  {

-    debug_log("Not a RAR file");

-    return FALSE;                           /* error => exit!               */

-  }

-

-#else

-  /* open and identify archive                                              */

-  newdesc = dup(desc);

-  cli_dbgmsg("ExtrFile(): dup(%d) = %d\n", desc, newdesc);

-  if ((ArcPtr=fdopen(newdesc,READBINARY))!=NULL)

-  {

-    if (!IsArchive())

-    {

-      debug_log("Not a RAR file");

-      fclose(ArcPtr);

-      ArcPtr = NULL;

-      return FALSE;                         /* error => exit!               */

-    }

-  } else

-  {

-    debug_log("Error opening file.");

-    return FALSE;

-  }

-#endif

-

-

-  if ((UnpMemory=malloc(UNP_MEMORY))==NULL)

-  {

-    cli_dbgmsg("unrarlib: Can't allocate memory for decompression!");

-    return FALSE;

-  } else cli_dbgmsg("unrarlib: Allocated %d bytes.\n", UNP_MEMORY);

-

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-  MemRARFile->offset+=NewMhd.HeadSize-MainHeadSize;

-#else

-  tseek(ArcPtr,NewMhd.HeadSize-MainHeadSize,SEEK_CUR);

-#endif

-

-  /* do while file is not extracted and there's no error                    */

-  do

-  {

-

-    if (ReadBlock(FILE_HEAD | READSUBBLOCK) <= 0) /* read name of the next  */

-    {                                       /* file within the RAR archive  */

-/*

- *

- * 21.11.2000  UnQ  There's a problem with some linux distros when a file

- *                  can not be found in an archive.

- * 07.09.2004  ThL  Seems more like a logical bug in this lib, since it

- *		    appears to occur once for every archive.

- */

-

-      /*

-      debug_log("Couldn't read next filename from archive (I/O error).");

-      */

-      ReturnCode=FALSE;

-      break;                                /* error, file not found in     */

-    }                                       /* archive or I/O error         */

-    if (BlockHead.HeadType==SUB_HEAD)

-    {

-      debug_log("Sorry, sub-headers not supported.");

-      ReturnCode=FALSE;

-      break;                                /* error => exit                */

-    }

-

-

-    if(TRUE == (FileFound=(stricomp(ArgName, ArcFileName) == 0)))

-    /* *** file found! ***                                                  */

-    {

-      {

-	cli_dbgmsg("unrarlib: Allocating %d bytes\n", NewLhd.UnpSize);

-        if((temp_output_buffer=malloc(NewLhd.UnpSize)) == NULL) { ;/* allocate memory for the*/

-	    cli_errmsg("unrarlib: Can't malloc %d bytes\n", NewLhd.UnpSize);

-	    ReturnCode = FALSE;

-	    break;

-	}

-      }

-      *temp_output_buffer_offset=0;         /* file. The default offset     */

-                                            /* within the buffer is 0       */

-    }

-

-    /* in case of a solid archive, we need to decompress any single file till

-     * we have found the one we are looking for. In case of normal archives

-     * (recommended!!), we skip the files until we are sure that it is the

-     * one we want.

-     */

-    if((NewMhd.Flags & 0x08) || FileFound)

-    {

-      if (NewLhd.UnpVer<13 || NewLhd.UnpVer>UNP_VER)

-      {

-        cli_dbgmsg("unknown compression method: %d  (min=13 max=%d)\n", NewLhd.UnpVer, UNP_VER);

-        ReturnCode=FALSE;

-        break;                              /* error, can't extract file!   */

-      }

-

-      CurUnpRead=0;

-      if ((*Password!=0) && (NewLhd.Flags & LHD_PASSWORD))

-        Encryption=NewLhd.UnpVer;

-      else

-        Encryption=0;

-      if (Encryption) SetCryptKeys(Password);

-

-      UnpPackedSize=NewLhd.PackSize;

-      DestUnpSize=NewLhd.UnpSize;

-

-      if (NewLhd.Method==0x30)

-      {

-	cli_dbgmsg("unrarlib: Unstore method temporarily not supported\n");

-        /* UnstoreFile(); */

-        ReturnCode=FALSE;

-        break;                              /* error, can't extract file! */

-      } else

-      {

-	cli_dbgmsg("unrarlib: Unpack()\n");

-        Unpack(UnpMemory, FileFound);

-      }

-

-

-#ifdef _DO_CRC32_CHECK                      /* calculate CRC32              */

-      if((UBYTE*)temp_output_buffer != NULL)

-      {

-        if(NewLhd.FileCRC!=~CalcCRC32(0xFFFFFFFFL,

-                                      (UBYTE*)temp_output_buffer,

-                                      NewLhd.UnpSize))

-        {

-          debug_log("CRC32 error - file couldn't be decompressed correctly!");

-          ReturnCode=FALSE;

-          break;                              /* error, can't extract file! */

-        }

-      }

-#endif

-

-    }

-

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-    MemRARFile->offset = NextBlockPos;

-#else

-    if (ArcPtr!=NULL) tseek(ArcPtr,NextBlockPos,SEEK_SET);

-#endif

-  } while(stricomp(ArgName, ArcFileName) != 0);/* exit if file is extracted */

-

-  /* free memory, clear password and close archive                          */

-  if(UnpMemory)

-    free(UnpMemory);

-

-  UnpMemory=NULL;

-#ifndef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-  if (ArcPtr!=NULL){

-      fclose(ArcPtr);

-      lseek(desc, 0, SEEK_SET);

-      ArcPtr = NULL;

-  }

-#endif

-

-  return ReturnCode;

-}

-

-/* **************************************************************************

- ****************************************************************************

- ****************************************************************************

- ************************************************************************** */

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-/* **************************************************************************

- ****************************************************************************

- ****************************************************************************

- ****************************************************************************

- *******                                                              *******

- *******                                                              *******

- *******                                                              *******

- *******             G L O B A L   F U N C T I O N S                  *******

- *******                                                              *******

- *******                                                              *******

- *******                                                              *******

- ****************************************************************************

- ****************************************************************************

- ****************************************************************************

- ************************************************************************** */

-

-

-int tread(void *stream,void *buf,unsigned len)

-{

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-

-  if(((MemRARFile->offset + len) > MemRARFile->size) || (len == 0))

-     return 0;

-

-  memcpy(buf,

-         (BYTE*)(((MemoryFile*)stream)->data)+((MemoryFile*)stream)->offset,

-         len % ((((MemoryFile*)stream)->size) - 1));

-

-  MemRARFile->offset+=len;                  /* update read pointer          */

-  return len % ((((MemoryFile*)stream)->size) - 1);

-#else

-  return(fread(buf,1,len,(FILE*)stream));

-#endif

-}

-

-

-#ifndef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-int tseek(void *stream,long offset,int fromwhere)

-{

-  return(fseek((FILE*)stream,offset,fromwhere));

-}

-#endif

-

-

-static char* strupper(char *Str)

-{

-  char *ChPtr;

-  for (ChPtr=Str;*ChPtr;ChPtr++)

-    *ChPtr=(char)toupper(*ChPtr);

-  return(Str);

-}

-

-

-int stricomp(char *Str1,char *Str2)

-/* compare strings without regard of '\' and '/'                            */

-{

-  char S1[512],S2[512];

-  char *chptr;

-

-  strncpy(S1,Str1,sizeof(S1));

-  strncpy(S2,Str2,sizeof(S2));

-

-  while((chptr = strchr(S1, '\\')) != NULL) /* ignore backslash             */

-  {

-    *chptr = '_';

-  }

-

-  while((chptr = strchr(S2, '\\')) != NULL) /* ignore backslash             */

-  {

-    *chptr = '_';

-  }

-

-  while((chptr = strchr(S1, '/')) != NULL)  /* ignore slash                 */

-  {

-    *chptr = '_';

-  }

-

-  while((chptr = strchr(S2, '/')) != NULL)  /* ignore slash                 */

-  {

-    *chptr = '_';

-  }

-

-  return(strcmp(strupper(S1),strupper(S2)));

-}

-

-

-/* **************************************************************************

- ****************************************************************************

- ****************************************************************************

- ************************************************************************** */

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-/* **************************************************************************

- ****************************************************************************

- ****************************************************************************

- ****************************************************************************

- *******                                                              *******

- *******                                                              *******

- *******                                                              *******

- *******                   U N P A C K   C O D E                      *******

- *******                                                              *******

- *******                                                              *******

- *******                                                              *******

- ****************************************************************************

- ****************************************************************************

- ****************************************************************************

- ************************************************************************** */

-

-

-/* *****************************

- * ** unpack stored RAR files **

- * *****************************/

-

-/*

-BOOL UnstoreFile(void)

-{

-  if ((long)(*temp_output_buffer_offset=UnpRead(temp_output_buffer,

-                                                NewLhd.UnpSize))==-1)

-  {

-    cli_dbgmsg("unrarlib: Read error of stored file!");

-    return FALSE;

-  }

-  return TRUE;

-}

-*/

-

-

-/* ****************************************

- * ** RAR decompression code starts here **

- * ****************************************/

-

-#define NC 298                              /* alphabet = {0,1,2, .,NC - 1} */

-#define DC 48

-#define RC 28

-#define BC 19

-#define MC 257

-

-enum {CODE_HUFFMAN=0,CODE_LZ=1,CODE_LZ2=2,CODE_REPEATLZ=3,CODE_CACHELZ=4,

-      CODE_STARTFILE=5,CODE_ENDFILE=6,CODE_STARTMM=8,CODE_ENDMM=7,

-      CODE_MMDELTA=9};

-

-struct AudioVariables

-{

-  int K1,K2,K3,K4,K5;

-  int D1,D2,D3,D4;

-  int LastDelta;

-  unsigned int Dif[11];

-  unsigned int ByteCount;

-  int LastChar;

-};

-

-

-#define NC 298  /* alphabet = {0, 1, 2, ..., NC - 1} */

-#define DC 48

-#define RC 28

-#define BC 19

-#define MC 257

-

-

-static struct AudioVariables AudV[4];

-

-#define GetBits()                                                 \

-        BitField = ( ( ( (UDWORD)InBuf[InAddr]   << 16 ) |        \

-                       ( (UWORD) InBuf[InAddr+1] <<  8 ) |        \

-                       (         InBuf[InAddr+2]       ) )        \

-                       >> (8-InBit) ) & 0xffff;

-

-

-#define AddBits(Bits)                          \

-        InAddr += ( InBit + (Bits) ) >> 3;     \

-        InBit  =  ( InBit + (Bits) ) &  7;

-

-static unsigned char *UnpBuf;

-static unsigned int BitField;

-static unsigned int Number;

-

-static unsigned char InBuf[8192];                  /* input read buffer            */

-

-static unsigned char UnpOldTable[MC*4];

-

-static unsigned int InAddr,InBit,ReadTop;

-

-static unsigned int LastDist,LastLength;

-static unsigned int Length,Distance;

-

-static unsigned int OldDist[4],OldDistPtr;

-

-

-static struct LitDecode

-{

-  unsigned int MaxNum;

-  unsigned int DecodeLen[16];

-  unsigned int DecodePos[16];

-  unsigned int DecodeNum[NC];

-} LD;

-

-static struct DistDecode

-{

-  unsigned int MaxNum;

-  unsigned int DecodeLen[16];

-  unsigned int DecodePos[16];

-  unsigned int DecodeNum[DC];

-} DD;

-

-static struct RepDecode

-{

-  unsigned int MaxNum;

-  unsigned int DecodeLen[16];

-  unsigned int DecodePos[16];

-  unsigned int DecodeNum[RC];

-} RD;

-

-static struct MultDecode

-{

-  unsigned int MaxNum;

-  unsigned int DecodeLen[16];

-  unsigned int DecodePos[16];

-  unsigned int DecodeNum[MC];

-} MD[4];

-

-static struct BitDecode

-{

-  unsigned int MaxNum;

-  unsigned int DecodeLen[16];

-  unsigned int DecodePos[16];

-  unsigned int DecodeNum[BC];

-} BD;

-

-static struct MultDecode *MDPtr[4]={&MD[0],&MD[1],&MD[2],&MD[3]};

-

-static int UnpAudioBlock,UnpChannels,CurChannel,ChannelDelta;

-

-

-void Unpack(unsigned char *UnpAddr, BOOL FileFound)

-/* *** 38.3% of all CPU time is spent within this function!!!               */

-{

-  static unsigned char LDecode[]={0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,

-                                  40,48,56,64,80,96,112,128,160,192,224};

-  static unsigned char LBits[]=  {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,

-                                  3,3,3,4,4,4,4,5,5,5,5};

-  static int DDecode[]={0,1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256,384,

-                        512,768,1024,1536,2048,3072,4096,6144,8192,12288,

-                        16384,24576,32768U,49152U,65536,98304,131072,196608,

-                        262144,327680,393216,458752,524288,589824,655360,

-                        720896,786432,851968,917504,983040};

-  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,

-                                  9,10,10,11,11,12,12,13,13,14,14,15,15,16,

-                                  16,16,16,16,16,16,16,16,16,16,16,16,16};

-  static unsigned char SDDecode[]={0,4,8,16,32,64,128,192};

-  static unsigned char SDBits[]={2,2,3, 4, 5, 6,  6,  6};

-  unsigned int Bits;

-

-

-  UnpBuf=UnpAddr;                           /* UnpAddr is a pointer to the  */

-  UnpInitData();                            /* unpack buffer                */

-  UnpReadBuf(1);

-  if (!(NewLhd.Flags & LHD_SOLID))

-     ReadTables();

-   DestUnpSize--;

-

-  while (DestUnpSize>=0)

-  {

-    UnpPtr&=MAXWINMASK;

-

-    if (InAddr>sizeof(InBuf)-30)

-      UnpReadBuf(0);

-    if (((WrPtr-UnpPtr) & MAXWINMASK)<270 && WrPtr!=UnpPtr)

-    {

-

-

-      if (FileFound)

-      {

-

-        if (UnpPtr<WrPtr)

-        {

-                        if((*temp_output_buffer_offset + ((0-WrPtr) & MAXWINMASK) + UnpPtr) > NewLhd.UnpSize)

-                        {

-                           debug_log("Fatal! Buffer overrun during decompression!");

-                          DestUnpSize=-1;

-

-                    } else

-                        {

-              /* copy extracted data to output buffer                         */

-              memcpy(temp_output_buffer + *temp_output_buffer_offset,

-                     &UnpBuf[WrPtr], (0-WrPtr) & MAXWINMASK);

-              /* update offset within buffer                                  */

-              *temp_output_buffer_offset+= (0-WrPtr) & MAXWINMASK;

-              /* copy extracted data to output buffer                         */

-              memcpy(temp_output_buffer + *temp_output_buffer_offset, UnpBuf,

-                     UnpPtr);

-              /* update offset within buffer                                  */

-              *temp_output_buffer_offset+=UnpPtr;

-                        }

-        } else

-        {

-                        if((*temp_output_buffer_offset + (UnpPtr-WrPtr)) > NewLhd.UnpSize)

-                        {

-                           debug_log("Fatal! Buffer overrun during decompression!");

-                          DestUnpSize=-1;

-                    } else

-                        {

-                  /* copy extracted data to output buffer                       */

-              memcpy(temp_output_buffer + *temp_output_buffer_offset,

-                     &UnpBuf[WrPtr], UnpPtr-WrPtr);

-              *temp_output_buffer_offset+=UnpPtr-WrPtr;                                                /* update offset within buffer */

-                    }

-

-            }

-      }

-

-      WrPtr=UnpPtr;

-    }

-

-    if (UnpAudioBlock)

-    {

-      DecodeNumber((struct Decode *)MDPtr[CurChannel]);

-      if (Number==256)

-      {

-        ReadTables();

-        continue;

-      }

-      UnpBuf[UnpPtr++]=DecodeAudio(Number);

-      if (++CurChannel==UnpChannels)

-        CurChannel=0;

-      DestUnpSize--;

-      continue;

-    }

-

-    DecodeNumber((struct Decode *)&LD);

-    if (Number<256)

-    {

-      UnpBuf[UnpPtr++]=(UBYTE)Number;

-      DestUnpSize--;

-      continue;

-    }

-    if (Number>269)

-    {

-      Length=LDecode[Number-=270]+3;

-      if ((Bits=LBits[Number])>0)

-      {

-        GetBits();

-        Length+=BitField>>(16-Bits);

-        AddBits(Bits);

-      }

-

-      DecodeNumber((struct Decode *)&DD);

-      Distance=DDecode[Number]+1;

-      if ((Bits=DBits[Number])>0)

-      {

-        GetBits();

-        Distance+=BitField>>(16-Bits);

-        AddBits(Bits);

-      }

-

-      if (Distance>=0x40000L)

-        Length++;

-

-      if (Distance>=0x2000)

-        Length++;

-

-       LastDist=OldDist[OldDistPtr++ & 3]=Distance;

-       DestUnpSize-=(LastLength=Length);

-       while (Length--)

-       {

-         UnpBuf[UnpPtr]=UnpBuf[(UnpPtr-Distance) & MAXWINMASK];

-         UnpPtr=(UnpPtr+1) & MAXWINMASK;

-       }

-

-      continue;

-    }

-    if (Number==269)

-    {

-      ReadTables();

-      continue;

-    }

-    if (Number==256)

-    {

-      Length=LastLength;

-      Distance=LastDist;

-       LastDist=OldDist[OldDistPtr++ & 3]=Distance;

-       DestUnpSize-=(LastLength=Length);

-       while (Length--)

-       {

-         UnpBuf[UnpPtr]=UnpBuf[(UnpPtr-Distance) & MAXWINMASK];

-         UnpPtr=(UnpPtr+1) & MAXWINMASK;

-       }

-      continue;

-    }

-    if (Number<261)

-    {

-      Distance=OldDist[(OldDistPtr-(Number-256)) & 3];

-      DecodeNumber((struct Decode *)&RD);

-      Length=LDecode[Number]+2;

-      if ((Bits=LBits[Number])>0)

-      {

-        GetBits();

-        Length+=BitField>>(16-Bits);

-        AddBits(Bits);

-      }

-      if (Distance>=0x40000)

-        Length++;

-      if (Distance>=0x2000)

-        Length++;

-      if (Distance>=0x101)

-        Length++;

-       LastDist=OldDist[OldDistPtr++ & 3]=Distance;

-       DestUnpSize-=(LastLength=Length);

-       while (Length--)

-       {

-         UnpBuf[UnpPtr]=UnpBuf[(UnpPtr-Distance) & MAXWINMASK];

-         UnpPtr=(UnpPtr+1) & MAXWINMASK;

-       }

-      continue;

-    }

-    if (Number<270)

-    {

-      Distance=SDDecode[Number-=261]+1;

-      if ((Bits=SDBits[Number])>0)

-      {

-        GetBits();

-        Distance+=BitField>>(16-Bits);

-        AddBits(Bits);

-      }

-      Length=2;

-       LastDist=OldDist[OldDistPtr++ & 3]=Distance;

-       DestUnpSize-=(LastLength=Length);

-       while (Length--)

-       {

-         UnpBuf[UnpPtr]=UnpBuf[(UnpPtr-Distance) & MAXWINMASK];

-         UnpPtr=(UnpPtr+1) & MAXWINMASK;

-       }

-      continue;

-   }

-  }

-  ReadLastTables();

-

-  if (FileFound)                            /* flush buffer                 */

-  {

-

-    if (UnpPtr<WrPtr)

-    {

-          if((*temp_output_buffer_offset + ((0-WrPtr) & MAXWINMASK) + UnpPtr) > NewLhd.UnpSize)

-          {

-            debug_log("Fatal! Buffer overrun during decompression!");

-                DestUnpSize=-1;

-          } else

-          {

-        /* copy extracted data to output buffer                             */

-        memcpy(temp_output_buffer + *temp_output_buffer_offset, &UnpBuf[WrPtr],

-               (0-WrPtr) & MAXWINMASK);

-        /* update offset within buffer                                      */

-        *temp_output_buffer_offset+= (0-WrPtr) & MAXWINMASK;

-        /* copy extracted data to output buffer                             */

-        memcpy(temp_output_buffer + *temp_output_buffer_offset, UnpBuf, UnpPtr);

-        /* update offset within buffer                                      */

-        *temp_output_buffer_offset+=UnpPtr;

-          }

-    } else

-    {

-          if((*temp_output_buffer_offset + (UnpPtr-WrPtr)) > NewLhd.UnpSize)

-          {

-                 debug_log("Fatal! Buffer overrun during decompression!");

-                DestUnpSize=-1;

-          } else

-          {

-        /* copy extracted data to output buffer                             */

-        memcpy(temp_output_buffer + *temp_output_buffer_offset, &UnpBuf[WrPtr],

-               UnpPtr-WrPtr);

-        /* update offset within buffer                                      */

-        *temp_output_buffer_offset+=UnpPtr-WrPtr;

-          }

-    }

-  }

-

-  WrPtr=UnpPtr;

-}

-

-

-unsigned int UnpRead(unsigned char *Addr,unsigned int Count)

-{

-  int RetCode=0;

-  unsigned int I,ReadSize,TotalRead=0;

-  unsigned char *ReadAddr;

-  ReadAddr=Addr;

-  while (Count > 0)

-  {

-    ReadSize=(unsigned int)((Count>(unsigned long)UnpPackedSize) ?

-                                                  UnpPackedSize : Count);

-#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION

-    cli_dbgmsg("unrarlib: UnpREAD: Using memory->memory decompression\n");

-    if(MemRARFile->data == NULL)

-      return(0);

-    RetCode=tread(MemRARFile, ReadAddr, ReadSize);

-#else

-    if (ArcPtr==NULL)

-      return(0);

-    RetCode=tread(ArcPtr,ReadAddr,ReadSize);

-#endif

-    CurUnpRead+=RetCode;

-    ReadAddr+=RetCode;

-    TotalRead+=RetCode;

-    Count-=RetCode;

-    UnpPackedSize-=RetCode;

-      break;

-  }

-

-  cli_dbgmsg("CurUnpRead == %d, TotalRead == %d, Count == %d, UnpPackedSize == %d\n", CurUnpRead, TotalRead, Count, UnpPackedSize);

-

-  if (RetCode!= -1)

-  {

-    RetCode=TotalRead;

-    if (Encryption)

-    {

-      if (Encryption<20)

-          {

-            cli_dbgmsg("unrarlib: Old Crypt() not supported!");

-          }

-      else

-      {

-        for (I=0;I<(unsigned int)RetCode;I+=16)

-          DecryptBlock(&Addr[I]);

-      }

-    }

-  }

-  return(RetCode);

-}

-

-

-void UnpReadBuf(int FirstBuf)

-{

-  int RetCode;

-  if (FirstBuf)

-  {

-    ReadTop=UnpRead(InBuf,sizeof(InBuf));

-    InAddr=0;

-  }

-  else

-  {

-    memcpy(InBuf,&InBuf[sizeof(InBuf)-32],32);

-    InAddr&=0x1f;

-    RetCode=UnpRead(&InBuf[32],sizeof(InBuf)-32);

-    if (RetCode>0)

-      ReadTop=RetCode+32;

-    else

-      ReadTop=InAddr;

-  }

-}

-

-