- Update to 0.90

- Cleanup a little bit

PR:		ports/109185 (Based on)
Submitted by:	Michael Scheidell <scheidell@secnap.net>

10 files changed, 44 insertions, 3342 deletions

diff --git a/security/clamav/Makefile b/security/clamav/Makefile
index 079c78a89a8b..d988232397f0 100644
--- a/security/clamav/Makefile
+++ b/security/clamav/Makefile
@@ -6,8 +6,7 @@
 #
 
 PORTNAME=	clamav
-PORTVERSION=	0.88.7
-PORTREVISION=	1
+PORTVERSION=	0.90
 CATEGORIES=	security
 MASTER_SITES=	SF
 
@@ -18,12 +17,10 @@ LIB_DEPENDS=	gmp.7:${PORTSDIR}/math/libgmp4
 RUN_DEPENDS=	lha:${PORTSDIR}/archivers/lha \
 		arj:${PORTSDIR}/archivers/arj \
 		unzoo:${PORTSDIR}/archivers/unzoo \
-		arc:${PORTSDIR}/archivers/arc \
-		unzip:${PORTSDIR}/archivers/unzip
+		arc:${PORTSDIR}/archivers/arc
 
 OPTIONS=	MILTER "Compile the milter interface" Off \
 		CURL "Support URL downloading" Off \
-		LIBUNRAR "Support for external Unrar library" Off \
 		STDERR "Print logs to stderr instead of stdout" Off
 
 USE_AUTOTOOLS=	libtool:15
@@ -31,7 +28,7 @@ CONFIGURE_TARGET=	--build=${MACHINE_ARCH}-portbld-freebsd${OSREL}
 USE_LDCONFIG=	yes
 USE_RC_SUBR=	clamav-clamd clamav-freshclam
 
-PORTDOCS=	NEWS ChangeLog html
+PORTDOCS=	*
 
 DBDIR=		/var/db/clamav
 LOGDIR=		/var/log/clamav
@@ -55,14 +52,21 @@ LDFLAGS+=	-L${LOCALBASE}/lib \
 
 CONFIGURE_ENV+=	CPPFLAGS="${CPPFLAGS}" \
 		LDFLAGS="${LDFLAGS}"
-MAN1=		clamscan.1 freshclam.1 sigtool.1 clamdscan.1
-MAN5=		clamd.conf.5 freshclam.conf.5
-MAN8=		clamd.8 clamav-milter.8
+MAN1=		clamconf.1 \
+		clamscan.1 \
+		freshclam.1 \
+		sigtool.1 \
+		clamdscan.1
+MAN5=		clamd.conf.5 \
+		freshclam.conf.5
+MAN8=		clamd.8 \
+		clamav-milter.8
 
 CONFLICTS=	clamav-devel-[0-9]*
 
 CLAMAVUSER?=	clamav
 CLAMAVGROUP?=	clamav
+
 CLAMAV_CLAMD_SOCKET?=	${RUNDIR}/clamd
 CLAMAV_MILTER_SOCKET?=	${RUNDIR}/clmilter.sock
 
@@ -83,10 +87,10 @@ SED_CONF=	-E -e 's|^\#?(Example)$$|\#\1|' \
 		-e 's|^\#?(User) .*$$|\1 ${CLAMAVUSER}|' \
 		-e 's|^\#?(AllowSupplementaryGroups)$$|\1|' \
 		-e 's|^\#?(ScanMail)$$|\1|' \
-		-e 's|^\#?(NotifyClamd)$$|\1|' \
 		-e 's|^\#?(DatabaseDirectory) .*$$|\1 ${DBDIR}|' \
 		-e 's|^\#?(DatabaseOwner) .*$$|\1 ${CLAMAVUSER}|' \
-		-e 's|^\#?(FixStaleSocket)$$|\1|'
+		-e 's|^\#?(FixStaleSocket)$$|\1|' \
+		-e 's|^\#?(NotifyClamd) .*$$|\1 ${PREFIX}/etc/clamd.conf|'
 
 PLIST_SUB+=	CLAMAVUSER=${CLAMAVUSER} \
 		CLAMAVGROUP=${CLAMAVGROUP}
@@ -122,16 +126,6 @@ CONFIGURE_ARGS+=	--with-libcurl
 CONFIGURE_ARGS+=	--without-libcurl
 .endif
 
-.if defined(WITH_LIBUNRAR)
-CFLAGS+=		-DUNRAR3
-LDFLAGS+=		-lunrar
-LIB_DEPENDS+=		unrar.3:${PORTSDIR}/archivers/libunrar
-EXTRA_PATCHES=		${FILESDIR}/extra-patch-libunrar
-.else
-RUN_DEPENDS+=		unrar:${PORTSDIR}/archivers/unrar
-EXTRA_PATCHES=		${FILESDIR}/extra-patch-libclamav__unrarlib.h
-.endif
-
 .if defined(WITH_STDERR)
 EXTRA_PATCHES+=		${FILESDIR}/extra-patch-shared_output.c
 .endif
@@ -141,15 +135,6 @@ post-patch:
 		${CONFIGURE_WRKSRC}/${CONFIGURE_SCRIPT}
 	@${REINPLACE_CMD} -e 's,unarj,arj,g' \
 		${WRKSRC}/docs/man/clamscan.1
-
-pre-build:
-	@if ${LDCONFIG} -r | ${GREP} -qw -e -lclamav; then \
-		${ECHO_MSG} "===>  *** WARNING ***"; \
-		${ECHO_MSG} "      Installed version of libclamav found."; \
-		${ECHO_MSG} "      This might cause build problems."; \
-	fi
-
-post-build:
 	@${REINPLACE_CMD} ${SED_CONF} ${BUILD_WRKSRC}/etc/clamd.conf
 	@${REINPLACE_CMD} ${SED_CONF} ${BUILD_WRKSRC}/etc/freshclam.conf
 
@@ -158,20 +143,15 @@ pre-install:
 		${SH} ${PKGINSTALL} ${PKGNAME} PRE-INSTALL
 
 post-install:
-	@${CHOWN} -R ${CLAMAVUSER}:${CLAMAVGROUP} ${DESTDIR}${DBDIR}
 .for c in clamd freshclam
 	@[ -f ${TARGETDIR}/etc/${c}.conf ] || \
 		${CP} ${TARGETDIR}/etc/${c}.conf.default ${TARGETDIR}/etc/${c}.conf
 .endfor
 .if !defined(NOPORTDOCS)
-	@${MKDIR} ${DOCSDIR}
-	@${INSTALL_DATA} ${INSTALL_WRKSRC}/NEWS ${INSTALL_WRKSRC}/ChangeLog \
-		${DOCSDIR}
 	@${MKDIR} ${DOCSDIR}/html
-	@${INSTALL_DATA} ${INSTALL_WRKSRC}/docs/html/*.* \
-		${DOCSDIR}/html
+	@${INSTALL_DATA} ${INSTALL_WRKSRC}/NEWS ${INSTALL_WRKSRC}/ChangeLog ${DOCSDIR}
+	@${INSTALL_DATA} ${INSTALL_WRKSRC}/docs/html/* ${DOCSDIR}/html
 .endif
-	@${SETENV} PKG_PREFIX=${PREFIX} \
-		${SH} ${PKGINSTALL} ${PKGNAME} POST-INSTALL
+	@${SETENV} PKG_PREFIX=${PREFIX} ${SH} ${PKGINSTALL} ${PKGNAME} POST-INSTALL
 
 .include <bsd.port.post.mk>
diff --git a/security/clamav/distinfo b/security/clamav/distinfo
index 741ccd57d377..483a3c6b13e5 100644
--- a/security/clamav/distinfo
+++ b/security/clamav/distinfo
@@ -1,3 +1,3 @@
-MD5 (clamav-0.88.7.tar.gz) = 34a9d58cf5bcb04dbe3eb32b5367a3f8
-SHA256 (clamav-0.88.7.tar.gz) = 702cb5928bff3d0e647a4a6b505d434e3a0f10f2af74bddac5239a200b92d1e2
-SIZE (clamav-0.88.7.tar.gz) = 9510548
+MD5 (clamav-0.90.tar.gz) = f04372e49c3c5ff3bd94bbe1fef2eaca
+SHA256 (clamav-0.90.tar.gz) = c39005318d4a7d27d9710c3d71396b8c500e0bc5a184cb7392051c9ca9dea60d
+SIZE (clamav-0.90.tar.gz) = 11575374
diff --git a/security/clamav/files/extra-patch-libclamav__unrarlib.h b/security/clamav/files/extra-patch-libclamav__unrarlib.h
deleted file mode 100644
index 4d8f466fed78..000000000000
--- a/security/clamav/files/extra-patch-libclamav__unrarlib.h
+++ /dev/null
@@ -1,11 +0,0 @@
---- libclamav/unrarlib.h.orig	Fri May 13 09:07:21 2005
-+++ libclamav/unrarlib.h	Fri May 13 09:07:26 2005
-@@ -198,7 +198,7 @@
- 
- 
- #ifdef __cplusplus
--};
-+}
- #endif
- 
- #endif
diff --git a/security/clamav/files/extra-patch-libunrar b/security/clamav/files/extra-patch-libunrar
deleted file mode 100644
index 3145ad16c458..000000000000
--- a/security/clamav/files/extra-patch-libunrar
+++ /dev/null
@@ -1,3221 +0,0 @@
---- ./libclamav/scanners.c.orig	Thu Sep 15 18:45:30 2005
-+++ ./libclamav/scanners.c	Wed Oct 12 14:40:13 2005
-@@ -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)
-@@ -1216,6 +1219,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, unsigned long int *scanned, const struct cl_node *root, const struct cl_limits *limits, unsigned int options, unsigned int arec, unsigned int mrec)
- {
- 	char *tempname;
-@@ -1403,8 +1443,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:
-@@ -1541,8 +1586,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:
---- ./libclamav/unrarlib.c.orig	Thu Jun 23 17:03:12 2005
-+++ ./libclamav/unrarlib.c	Wed Oct 12 14:40:13 2005
-@@ -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;
--  }
--}
--
--
--void ReadTables(void)
--{
--  UBYTE BitLength[BC];
--  unsigned char Table[MC*4];
--  int TableSize,N,I;
--  if (InAddr>sizeof(InBuf)-25)
--    UnpReadBuf(0);
--  GetBits();
--  UnpAudioBlock=(BitField & 0x8000);
--
--  if (!(BitField & 0x4000))
--    memset(UnpOldTable,0,sizeof(UnpOldTable));
--  AddBits(2);
--
--
--  if (UnpAudioBlock)
--  {
--    UnpChannels=((BitField>>12) & 3)+1;
--    if (CurChannel>=UnpChannels)
--      CurChannel=0;
--    AddBits(2);
--    TableSize=MC*UnpChannels;
--  }
--  else
--    TableSize=NC+DC+RC;
--
--
--  for (I=0;I<BC;I++)
--  {
--    GetBits();
--    BitLength[I]=(UBYTE)(BitField >> 12);
--    AddBits(4);
--  }
--  MakeDecodeTables(BitLength,(struct Decode *)&BD,BC);
--  I=0;
--  while (I<TableSize)
--  {
--    if (InAddr>sizeof(InBuf)-5)
--      UnpReadBuf(0);
--    DecodeNumber((struct Decode *)&BD);
--    if (Number<16) {
--      Table[I]=(Number+UnpOldTable[I]) & 0xf;
--      I++;
--    }
--    else
--      if (Number==16)
--      {
--        GetBits();
--        N=(BitField >> 14)+3;
--        AddBits(2);
--        while (N-- > 0 && I<TableSize)
--        {
--          Table[I]=Table[I-1];
--          I++;
--        }
--      }
--      else
--      {
--        if (Number==17)
--        {
--          GetBits();
--          N=(BitField >> 13)+3;
--          AddBits(3);
--        }
--        else
--        {
--          GetBits();
--          N=(BitField >> 9)+11;
--          AddBits(7);
--        }
--        while (N-- > 0 && I<TableSize)
--          Table[I++]=0;
--      }
--  }
--  if (UnpAudioBlock)
--    for (I=0;I<UnpChannels;I++)
--      MakeDecodeTables(&Table[I*MC],(struct Decode *)MDPtr[I],MC);
--  else
--  {
--    MakeDecodeTables(&Table[0],(struct Decode *)&LD,NC);
--    MakeDecodeTables(&Table[NC],(struct Decode *)&DD,DC);
--    MakeDecodeTables(&Table[NC+DC],(struct Decode *)&RD,RC);
--  }
--  memcpy(UnpOldTable,Table,sizeof(UnpOldTable));
--}
--
--
--static void ReadLastTables(void)
--{
--  if (ReadTop>=InAddr+5)
--  {
--    if (UnpAudioBlock)
--    {
--      DecodeNumber((struct Decode *)MDPtr[CurChannel]);
--      if (Number==256)
--        ReadTables();
--    }
--    else
--    {
--      DecodeNumber((struct Decode *)&LD);
--      if (Number==269)
--        ReadTables();
--    }
--  }
--}
--
--
--static void MakeDecodeTables(unsigned char *LenTab,
--                             struct Decode *Dec,
--                             int Size)
--{
--  int LenCount[16],TmpPos[16],I;
--  long M,N;
--  memset(LenCount,0,sizeof(LenCount));
--  for (I=0;I<Size;I++)
--    LenCount[LenTab[I] & 0xF]++;
--
--  LenCount[0]=0;
--  for (TmpPos[0]=Dec->DecodePos[0]=Dec->DecodeLen[0]=0,N=0,I=1;I<16;I++)
--  {
--    N=2*(N+LenCount[I]);
--    M=N<<(15-I);
--    if (M>0xFFFF)
--      M=0xFFFF;
--    Dec->DecodeLen[I]=(unsigned int)M;
--    TmpPos[I]=Dec->DecodePos[I]=Dec->DecodePos[I-1]+LenCount[I-1];
--  }
--
--  for (I=0;I<Size;I++)
--    if (LenTab[I]!=0)
--      Dec->DecodeNum[TmpPos[LenTab[I] & 0xF]++]=I;
--  Dec->MaxNum=Size;
--}
--
--
--static void DecodeNumber(struct Decode *Deco)
--/* *** 52.6% of all CPU time is spent within this function!!!               */
--{
--  unsigned int I;
--  register unsigned int N;
--  GetBits();
--
--#ifdef _USE_ASM
--
--#ifdef _WIN_32
-- __asm {
--
--    xor eax, eax
--    mov eax, BitField                       /* N=BitField & 0xFFFE; */
--    and eax, 0xFFFFFFFE
--    mov [N], eax
--    mov edx, [Deco]                         /* EAX=N, EDX=Deco */
--
--          cmp  eax, dword ptr[edx + 8*4 + 4] /* if (N<Dec->DecodeLen[8]) */
--          jae  else_G
--
--             cmp  eax, dword ptr[edx + 4*4 + 4] /* if (N<Dec->DecodeLen[4]) */
--             jae  else_F
--
--
--                cmp  eax, dword ptr[edx + 2*4 + 4] /* if (N<Dec->DecodeLen[2]) */
--                jae  else_C
--
--                   cmp  eax, dword ptr[edx + 1*4 + 4] /* if (N<Dec->DecodeLen[1]) */
--                   jae  else_1
--                   mov  I, 1                         /*  I=1; */
--                   jmp  next_1
--                 else_1:                             /* else */
--                   mov  I, 2                         /*  I=2; */
--                 next_1:
--
--                jmp  next_C
--              else_C:                             /* else */
--
--                   cmp  eax, dword ptr[edx + 3*4 + 4] /* if (N<Dec->DecodeLen[3]) */
--                   jae  else_2
--                   mov  I, 3                         /*  I=3; */
--                   jmp  next_2
--                 else_2:                             /* else */
--                   mov  I, 4                         /*  I=4; */
--                 next_2:
--
--              next_C:                             /* else */
--
--             jmp  next_F
--           else_F:
--
--
--             cmp  eax, dword ptr[edx + 6*4 + 4] /* if (N<Dec->DecodeLen[6]) */
--             jae  else_E
--
--                cmp  eax, dword ptr[edx + 5*4 + 4] /* if (N<Dec->DecodeLen[5]) */
--                jae  else_3
--                mov  I, 5                         /*  I=5; */
--                jmp  next_3
--              else_3:                             /* else */
--                mov  I, 6                         /*  I=6; */
--              next_3:
--
--             jmp  next_E
--           else_E:                             /* else */
--
--                cmp  eax, dword ptr[edx + 7*4 + 4] /* if (N<Dec->DecodeLen[7]) */
--                jae  else_4
--                mov  I, 7                         /*  I=7; */
--                jmp  next_4
--              else_4:                             /* else */
--                mov  I, 8                         /*  I=8; */
--              next_4:
--
--           next_E:
--
--           next_F:
--
--          jmp  next_G
--        else_G:
--
--          cmp  eax, dword ptr[edx + 12*4 + 4] /* if (N<Dec->DecodeLen[12]) */
--          jae  else_D
--
--             cmp  eax, dword ptr[edx + 10*4 + 4] /* if (N<Dec->DecodeLen[10]) */
--             jae  else_B
--
--                cmp  eax, dword ptr[edx + 9*4 + 4] /* if (N<Dec->DecodeLen[9]) */
--                jae  else_5
--                mov  I, 9                         /*  I=9; */
--                jmp  next_5
--              else_5:                             /* else */
--                mov  I, 10                         /*  I=10; */
--              next_5:
--
--             jmp  next_B
--           else_B:                             /* else */
--
--                cmp  eax, dword ptr[edx + 11*4 + 4] /* if (N<Dec->DecodeLen[11]) */
--                jae  else_6
--                mov  I, 11                         /*  I=11; */
--                jmp  next_6
--              else_6:                              /* else */
--                mov  I, 12                         /*  I=12; */
--              next_6:
--
--           next_B:
--
--
--          jmp  next_D
--        else_D:                             /* else */
--
--               cmp  eax, dword ptr[edx + 14*4 + 4] /* if (N<Dec->DecodeLen[14]) */
--               jae  else_A
--
--                  cmp  eax, dword ptr[edx + 13*4 + 4] /* if (N<Dec->DecodeLen[13]) */
--                  jae  else_7
--                  mov  I, 13                         /*  I=13; */
--                  jmp  next_7
--                 else_7:                             /* else */
--                  mov  I, 14                         /*  I=14; */
--                 next_7:
--
--               jmp  next_A
--              else_A:                             /* else */
--               mov  I, 15                         /*  I=15; */
--              next_A:
--
--        next_D:
--    next_G:
--}
--#else
-- __asm__ __volatile__ (
--     "andl $0xFFFFFFFE, %%eax"
--"      movl %%eax, %1"
--"          cmpl 8*4(%%edx), %%eax /* 5379 */"
--"          jae  else_G"
--""
--"             cmpl 4*4(%%edx), %%eax"
--"             jae  else_F"
--""
--"                cmpl 2*4(%%edx), %%eax"
--"                jae  else_C"
--""
--"                   cmpl 1*4(%%edx), %%eax"
--""
--"                   jae  else_1"
--"                   movl $1, %0"
--"                   jmp  next_1"
--"                 else_1:       "
--"                   movl  $2, %0"
--"                 next_1:"
--"                "
--"                jmp  next_C"
--"              else_C:          "
--""
--"                   cmpl 3*4(%%edx), %%eax "
--"                   jae  else_2"
--"                   movl  $3, %0"
--"                   jmp  next_2"
--"                 else_2:       "
--"                   movl  $4, %0"
--"                 next_2:"
--""
--"              next_C:          "
--""
--"             jmp  next_F"
--"           else_F:"
--""
--"             cmpl 6*4(%%edx), %%eax"
--"             jae  else_E"
--""
--"                cmpl 5*4(%%edx), %%eax"
--"                jae  else_3"
--"                movl  $5, %0   "
--"                jmp  next_3"
--"              else_3:          "
--"                movl  $6, %0   "
--"              next_3:"
--""
--"             jmp  next_E"
--"           else_E:             "
--""
--"                cmpl 7*4(%%edx), %%eax"
--"                jae  else_4"
--"                movl  $7, %0   "
--"                jmp  next_4"
--"              else_4:          "
--"                movl  $8, %0   "
--"              next_4:"
--""
--"           next_E:"
--""
--"           next_F:"
--""
--"          jmp  next_G"
--"        else_G:"
--""
--"          cmpl 12*4(%%edx), %%eax"
--"          jae  else_D"
--""
--"             cmpl 10*4(%%edx), %%eax"
--"             jae  else_B"
--""
--"                cmpl 9*4(%%edx), %%eax"
--"                jae  else_5"
--"                movl  $9, %0   "
--"                jmp  next_5"
--"              else_5:          "
--"                movl  $10, %0  "
--"              next_5:"
--""
--"             jmp  next_B"
--"           else_B:             "
--""
--"                cmpl 11*4(%%edx), %%eax"
--" "
--"                jae  else_6"
--"                movl  $11, %0  "
--"                jmp  next_6"
--"              else_6:          "
--"                movl  $12, %0  "
--"              next_6:"
--""
--"           next_B:"
--"      "
--"        "
--"          jmp  next_D"
--"        else_D:                "
--""
--"               cmpl 14*4(%%edx), %%eax"
--"               jae  else_A"
--""
--"                  cmpl 13*4(%%edx), %%eax"
--"                  jae  else_7"
--"                  movl  $13, %0"
--"                  jmp  next_7"
--"                 else_7:       "
--"                  movl  $14, %0"
--"                 next_7:"
--""
--"               jmp  next_A"
--"              else_A:          "
--"               movl  $15, %0   "
--"              next_A:"
--"          "
--"        next_D:                             "
--"    next_G:"
--     : "=g" (I), "=r"(N)
--     : "eax" ((long)BitField), "edx"((long)Deco->DecodeLen)
--      : "memory"
--     );
--#endif /* #ifdef _WIN_32 ... #elif defined _X86_ASM_ */
--
--#else
--  N=BitField & 0xFFFE;
--  if (N<Deco->DecodeLen[8])  {
--    if (N<Deco->DecodeLen[4]) {
--      if (N<Deco->DecodeLen[2]) {
--        if (N<Deco->DecodeLen[1])
--          I=1;
--        else
--          I=2;
--      } else {
--        if (N<Deco->DecodeLen[3])
--          I=3;
--        else
--          I=4;
--      }
--    } else {
--      if (N<Deco->DecodeLen[6])  {
--        if (N<Deco->DecodeLen[5])
--          I=5;
--        else
--          I=6;
--      } else {
--        if (N<Deco->DecodeLen[7])
--          I=7;
--        else
--          I=8;
--      }
--   }
--  } else {
--    if (N<Deco->DecodeLen[12]) {
--      if (N<Deco->DecodeLen[10]) {
--        if (N<Deco->DecodeLen[9])
--          I=9;
--        else
--          I=10;
--      } else {
--        if (N<Deco->DecodeLen[11])
--          I=11;
--        else
--          I=12;
--      }
--    } else {
--      if (N<Deco->DecodeLen[14]) {
--        if (N<Deco->DecodeLen[13])
--          I=13;
--        else
--          I=14;
--
--      } else {
--          I=15;
--      }
--    }
--
--  }
--#endif
--
--  AddBits(I);
--  if ((N=Deco->DecodePos[I]+((N-Deco->DecodeLen[I-1])>>(16-I)))>=Deco->MaxNum)
--      N=0;
--  Number=Deco->DecodeNum[N];
--}
--
--
--void UnpInitData()
--{
--  InAddr=InBit=0;
--  if (!(NewLhd.Flags & LHD_SOLID))
--  {
--    ChannelDelta=CurChannel=0;
--
--#ifdef _USE_ASM
--
--#ifdef _WIN_32                              /* Win32 with VisualC           */
--
--    __asm {
--        push edi
--        push eax
--        push ecx
--
--        cld                                 /* increment EDI and ESI        */
--        mov  al, 0x00
--        mov  ecx, SIZE AudV
--        mov  edi, Offset AudV
--        rep  stosb                          /* clear memory                 */
--
--        mov  ecx, SIZE OldDist
--        mov  edi, Offset OldDist
--        rep  stosb                          /* clear memory                 */
--
--        mov  ecx, SIZE UnpOldTable
--        mov  edi, Offset UnpOldTable
--        rep  stosb                          /* clear memory                 */
--
--        pop  ecx
--        pop  eax
--        pop  edi
--
--
--        mov  [OldDistPtr], 0
--        mov  [LastDist], 0
--        mov  [LastLength], 0
--        mov  [UnpPtr], 0
--        mov  [WrPtr], 0
--        mov  [OldDistPtr], 0
--        mov  [LastLength], 0
--        mov  [LastDist], 0
--        mov  [UnpPtr], 0
--        mov  [WrPtr], 0
--
--    }
--    memset(UnpBuf,0,MAXWINSIZE);
--
--
--#else                    /* unix/linux on i386 cpus */
--    __asm__ __volatile (
--"        cld                                 /* increment EDI and ESI        */"
--"        movb $0x00, %%al"
--"        movl %0, %%ecx"
--"        movl %1, %%edi"
--"        rep  "
--"        stosb                              /* clear memory                 */"
--""
--"        movl %2, %%ecx"
--"        mov  %3, %%edi"
--"        rep  "
--"        stosb                              /* clear memory                 */"
--""
--"        movl %4, %%ecx"
--"        movl %5, %%edi"
--"        rep  "
--"        stosb                              /* clear memory                 */"
--""
--"        movl $0, (OldDistPtr)"
--"        movl $0, (LastDist)"
--"        movl $0, (LastLength)"
--"        movl $0, (UnpPtr)"
--"        movl $0, (WrPtr)"
--"        movl $0, (OldDistPtr)"
--"        movl $0, (LastLength)"
--"        movl $0, (LastDist)"
--"        movl $0, (UnpPtr)"
--"        movl $0, (WrPtr)"
--        :
--        : "m" ((long)sizeof(AudV)),
--          "m" ((long)AudV),
--          "m" ((long)sizeof(OldDist)),
--          "m" ((long)OldDist),
--          "m" ((long)sizeof(UnpOldTable)),
--          "m" ((long)UnpOldTable)
--        : "memory", "edi", "eax", "ecx"
--    );
--    memset(UnpBuf,0,MAXWINSIZE);
--#endif
--
--#else                                       /* unix/linux on non-i386 cpu  */
--    memset(AudV,0,sizeof(AudV));
--    memset(OldDist,0,sizeof(OldDist));
--    OldDistPtr=0;
--    LastDist=LastLength=0;
--    memset(UnpBuf,0,MAXWINSIZE);
--    memset(UnpOldTable,0,sizeof(UnpOldTable));
--    UnpPtr=WrPtr=0;
--#endif
--
--  }
--}
--
--
--UBYTE DecodeAudio(int Delta)
--{
--  struct AudioVariables *V;
--  unsigned int Ch;
--  unsigned int NumMinDif,MinDif;
--  int PCh,I;
--
--  V=&AudV[CurChannel];
--  V->ByteCount++;
--  V->D4=V->D3;
--  V->D3=V->D2;
--  V->D2=V->LastDelta-V->D1;
--  V->D1=V->LastDelta;
--  PCh=8*V->LastChar+V->K1*V->D1+V->K2*V->D2+
--           V->K3*V->D3+V->K4*V->D4+V->K5*ChannelDelta;
--  PCh=(PCh>>3) & 0xFF;
--
--  Ch=PCh-Delta;
--
--  I=((signed char)Delta)<<3;
--
--  V->Dif[0]+=abs(I);
--  V->Dif[1]+=abs(I-V->D1);
--  V->Dif[2]+=abs(I+V->D1);
--  V->Dif[3]+=abs(I-V->D2);
--  V->Dif[4]+=abs(I+V->D2);
--  V->Dif[5]+=abs(I-V->D3);
--  V->Dif[6]+=abs(I+V->D3);
--  V->Dif[7]+=abs(I-V->D4);
--  V->Dif[8]+=abs(I+V->D4);
--  V->Dif[9]+=abs(I-ChannelDelta);
--  V->Dif[10]+=abs(I+ChannelDelta);
--
--  ChannelDelta=V->LastDelta=(signed char)(Ch-V->LastChar);
--  V->LastChar=Ch;
--
--  if ((V->ByteCount & 0x1F)==0)
--  {
--    MinDif=V->Dif[0];
--    NumMinDif=0;
--    V->Dif[0]=0;
--    for (I=1;(unsigned int)I<sizeof(V->Dif)/sizeof(V->Dif[0]);I++)
--    {
--      if (V->Dif[I]<MinDif)
--      {
--        MinDif=V->Dif[I];
--        NumMinDif=I;
--      }
--      V->Dif[I]=0;
--    }
--    switch(NumMinDif)
--    {
--      case 1:
--        if (V->K1>=-16)
--          V->K1--;
--        break;
--      case 2:
--        if (V->K1<16)
--          V->K1++;
--        break;
--      case 3:
--        if (V->K2>=-16)
--          V->K2--;
--        break;
--      case 4:
--        if (V->K2<16)
--          V->K2++;
--        break;
--      case 5:
--        if (V->K3>=-16)
--          V->K3--;
--        break;
--      case 6:
--        if (V->K3<16)
--          V->K3++;
--        break;
--      case 7:
--        if (V->K4>=-16)
--          V->K4--;
--        break;
--      case 8:
--        if (V->K4<16)
--          V->K4++;
--        break;
--      case 9:
--        if (V->K5>=-16)
--          V->K5--;
--        break;
--      case 10:
--        if (V->K5<16)
--          V->K5++;
--        break;
--    }
--  }
--  return((UBYTE)Ch);
--}
--
--
--
--
--
--
--
--/* ***************************************************
-- * ** CRCCrypt Code - decryption engine starts here **
-- * ***************************************************/
--
--
--#define NROUNDS 32
--
--#define rol(x,n)  (((x)<<(n)) | ((x)>>(8*sizeof(x)-(n))))
--#define ror(x,n)  (((x)>>(n)) | ((x)<<(8*sizeof(x)-(n))))
--
--#define substLong(t) ( (UDWORD)SubstTable[(int)t&255] | \
--           ((UDWORD)SubstTable[(int)(t>> 8)&255]<< 8) | \
--           ((UDWORD)SubstTable[(int)(t>>16)&255]<<16) | \
--           ((UDWORD)SubstTable[(int)(t>>24)&255]<<24) )
--
--
--static UDWORD CRCTab[256];
--
--static UBYTE SubstTable[256];
--static const UBYTE InitSubstTable[256]={
--  215, 19,149, 35, 73,197,192,205,249, 28, 16,119, 48,221,  2, 42,
--  232,  1,177,233, 14, 88,219, 25,223,195,244, 90, 87,239,153,137,
--  255,199,147, 70, 92, 66,246, 13,216, 40, 62, 29,217,230, 86,  6,
--   71, 24,171,196,101,113,218,123, 93, 91,163,178,202, 67, 44,235,
--  107,250, 75,234, 49,167,125,211, 83,114,157,144, 32,193,143, 36,
--  158,124,247,187, 89,214,141, 47,121,228, 61,130,213,194,174,251,
--   97,110, 54,229,115, 57,152, 94,105,243,212, 55,209,245, 63, 11,
--  164,200, 31,156, 81,176,227, 21, 76, 99,139,188,127, 17,248, 51,
--  207,120,189,210,  8,226, 41, 72,183,203,135,165,166, 60, 98,  7,
--  122, 38,155,170, 69,172,252,238, 39,134, 59,128,236, 27,240, 80,
--  131,  3, 85,206,145, 79,154,142,159,220,201,133, 74, 64, 20,129,
--  224,185,138,103,173,182, 43, 34,254, 82,198,151,231,180, 58, 10,
--  118, 26,102, 12, 50,132, 22,191,136,111,162,179, 45,  4,148,108,
--  161, 56, 78,126,242,222, 15,175,146, 23, 33,241,181,190, 77,225,
--    0, 46,169,186, 68, 95,237, 65, 53,208,253,168,  9, 18,100, 52,
--  116,184,160, 96,109, 37, 30,106,140,104,150,  5,204,117,112, 84
--};
--
--static UDWORD Key[4];
--
--
--static void EncryptBlock(UBYTE *Buf)
--{
--  int I;
--
--  UDWORD A,B,C,D,T,TA,TB;
--#ifdef NON_INTEL_BYTE_ORDER
--  A=((UDWORD)Buf[0]|((UDWORD)Buf[1]<<8)|((UDWORD)Buf[2]<<16)|
--      ((UDWORD)Buf[3]<<24))^Key[0];
--  B=((UDWORD)Buf[4]|((UDWORD)Buf[5]<<8)|((UDWORD)Buf[6]<<16)|
--      ((UDWORD)Buf[7]<<24))^Key[1];
--  C=((UDWORD)Buf[8]|((UDWORD)Buf[9]<<8)|((UDWORD)Buf[10]<<16)|
--      ((UDWORD)Buf[11]<<24))^Key[2];
--  D=((UDWORD)Buf[12]|((UDWORD)Buf[13]<<8)|((UDWORD)Buf[14]<<16)|
--      ((UDWORD)Buf[15]<<24))^Key[3];
--#else
--  UDWORD *BufPtr;
--  BufPtr=(UDWORD *)Buf;
--  A=BufPtr[0]^Key[0];
--  B=BufPtr[1]^Key[1];
--  C=BufPtr[2]^Key[2];
--  D=BufPtr[3]^Key[3];
--#endif
--  for(I=0;I<NROUNDS;I++)
--  {
--    T=((C+rol(D,11))^Key[I&3]);
--    TA=A^substLong(T);
--    T=((D^rol(C,17))+Key[I&3]);
--    TB=B^substLong(T);
--    A=C;
--    B=D;
--    C=TA;
--    D=TB;
--  }
--#ifdef NON_INTEL_BYTE_ORDER
--  C^=Key[0];
--  Buf[0]=(UBYTE)C;
--  Buf[1]=(UBYTE)(C>>8);
--  Buf[2]=(UBYTE)(C>>16);
--  Buf[3]=(UBYTE)(C>>24);
--  D^=Key[1];
--  Buf[4]=(UBYTE)D;
--  Buf[5]=(UBYTE)(D>>8);
--  Buf[6]=(UBYTE)(D>>16);
--  Buf[7]=(UBYTE)(D>>24);
--  A^=Key[2];
--  Buf[8]=(UBYTE)A;
--  Buf[9]=(UBYTE)(A>>8);
--  Buf[10]=(UBYTE)(A>>16);
--  Buf[11]=(UBYTE)(A>>24);
--  B^=Key[3];
--  Buf[12]=(UBYTE)B;
--  Buf[13]=(UBYTE)(B>>8);
--  Buf[14]=(UBYTE)(B>>16);
--  Buf[15]=(UBYTE)(B>>24);
--#else
--  BufPtr[0]=C^Key[0];
--  BufPtr[1]=D^Key[1];
--  BufPtr[2]=A^Key[2];
--  BufPtr[3]=B^Key[3];
--#endif
--  UpdKeys(Buf);
--}
--
--
--void DecryptBlock(UBYTE *Buf)
--{
--  int I;
--  UBYTE InBuf[16];
--  UDWORD A,B,C,D,T,TA,TB;
--#ifdef NON_INTEL_BYTE_ORDER
--  A=((UDWORD)Buf[0]|((UDWORD)Buf[1]<<8)|((UDWORD)Buf[2]<<16)|
--      ((UDWORD)Buf[3]<<24))^Key[0];
--  B=((UDWORD)Buf[4]|((UDWORD)Buf[5]<<8)|((UDWORD)Buf[6]<<16)|
--      ((UDWORD)Buf[7]<<24))^Key[1];
--  C=((UDWORD)Buf[8]|((UDWORD)Buf[9]<<8)|((UDWORD)Buf[10]<<16)|
--      ((UDWORD)Buf[11]<<24))^Key[2];
--  D=((UDWORD)Buf[12]|((UDWORD)Buf[13]<<8)|((UDWORD)Buf[14]<<16)|
--      ((UDWORD)Buf[15]<<24))^Key[3];
--#else
--  UDWORD *BufPtr;
--  BufPtr=(UDWORD *)Buf;
--  A=BufPtr[0]^Key[0];                       /* xxx may be this can be       */
--  B=BufPtr[1]^Key[1];                       /* optimized in assembler       */
--  C=BufPtr[2]^Key[2];
--  D=BufPtr[3]^Key[3];
--#endif
--  memcpy(InBuf,Buf,sizeof(InBuf));
--  for(I=NROUNDS-1;I>=0;I--)
--  {
--    T=((C+rol(D,11))^Key[I&3]);
--    TA=A^substLong(T);
--    T=((D^rol(C,17))+Key[I&3]);
--    TB=B^substLong(T);
--    A=C;
--    B=D;
--    C=TA;
--    D=TB;
--  }
--#ifdef NON_INTEL_BYTE_ORDER
--  C^=Key[0];
--  Buf[0]=(UBYTE)C;
--  Buf[1]=(UBYTE)(C>>8);
--  Buf[2]=(UBYTE)(C>>16);
--  Buf[3]=(UBYTE)(C>>24);
--  D^=Key[1];
--  Buf[4]=(UBYTE)D;
--  Buf[5]=(UBYTE)(D>>8);
--  Buf[6]=(UBYTE)(D>>16);
--  Buf[7]=(UBYTE)(D>>24);
--  A^=Key[2];
--  Buf[8]=(UBYTE)A;
--  Buf[9]=(UBYTE)(A>>8);
--  Buf[10]=(UBYTE)(A>>16);
--  Buf[11]=(UBYTE)(A>>24);
--  B^=Key[3];
--  Buf[12]=(UBYTE)B;
--  Buf[13]=(UBYTE)(B>>8);
--  Buf[14]=(UBYTE)(B>>16);
--  Buf[15]=(UBYTE)(B>>24);
--#else
--  BufPtr[0]=C^Key[0];
--  BufPtr[1]=D^Key[1];
--  BufPtr[2]=A^Key[2];
--  BufPtr[3]=B^Key[3];
--#endif
--  UpdKeys(InBuf);
--}
--
--
--void UpdKeys(UBYTE *Buf)
--{
--  int I;
--  for (I=0;I<16;I+=4)
--  {
--    Key[0]^=CRCTab[Buf[I]];                 /* xxx may be I'll rewrite this */
--    Key[1]^=CRCTab[Buf[I+1]];               /* in asm for speedup           */
--    Key[2]^=CRCTab[Buf[I+2]];
--    Key[3]^=CRCTab[Buf[I+3]];
--  }
--}
--
--static void SetCryptKeys(char *NewPassword)
--{
--  unsigned int I,J,K,PswLength;
--  unsigned char N1,N2;
--  unsigned char Psw[256];
--
--#if !defined _USE_ASM
--  UBYTE Ch;
--#endif
--
--  SetOldKeys(NewPassword);
--
--  Key[0]=0xD3A3B879L;
--  Key[1]=0x3F6D12F7L;
--  Key[2]=0x7515A235L;
--  Key[3]=0xA4E7F123L;
--  memset(Psw,0,sizeof(Psw));
--  strcpy((char *)Psw,NewPassword);
--  PswLength=strlen(NewPassword);
--  memcpy(SubstTable,InitSubstTable,sizeof(SubstTable));
--
--  for (J=0;J<256;J++)
--    for (I=0;I<PswLength;I+=2)
--    {
--      N2=(unsigned char)CRCTab[(Psw[I+1]+J)&0xFF];
--      for (K=1, N1=(unsigned char)CRCTab[(Psw[I]-J)&0xFF];
--           (N1!=N2);
--           N1++, K++)
--          {
--#ifdef _USE_ASM
--
--#ifdef _WIN_32
--          __asm {
--
--                    mov ebx, Offset SubstTable
--                    mov edx, ebx
--
--                    xor ecx, ecx            /* read SubstTable[N1]... */
--                    mov cl, N1
--                    add ebx, ecx
--                    mov al, byte ptr[ebx]
--
--                    mov cl, N1              /* read SubstTable[(N1+I+K)&0xFF]... */
--                    add ecx, I
--                    add ecx, K
--                    and ecx, 0xFF
--                    add edx, ecx
--                    mov ah, byte ptr[edx]
--
--                    mov  byte ptr[ebx], ah  /* and write back */
--                    mov  byte ptr[edx], al
--
--               }
--#else
--                     __asm__ __volatile__ (
--"                    xorl %%ecx, %%ecx"
--"                    movl %2, %%ecx                     /* ecx = N1 */"
--"                    mov %%ebx, %%edx"
--"                    addl %%ecx, %%ebx"
--""
--"                    addl %0, %%ecx"
--"                    addl %1, %%ecx"
--"                    andl $0x000000FF, %%ecx"
--"                    addl %%ecx, %%edx"
--"                    "
--"                    movb (%%ebx), %%al"
--"                    movb (%%edx), %%ah"
--""
--"                    movb  %%ah, (%%ebx)     /* and write back */"
--"                    movb  %%al, (%%edx)"
--                    : : "g" ((long)I),
--                        "g" ((long)K),
--                        "g" ((long)N1),
--                        "ebx"((long)SubstTable)
--                    : "ecx", "edx"
--
--              );
--#endif
--
--#else
--            /* Swap(&SubstTable[N1],&SubstTable[(N1+I+K)&0xFF]);            */
--             Ch=SubstTable[N1];
--             SubstTable[N1]=SubstTable[(N1+I+K)&0xFF];
--             SubstTable[(N1+I+K)&0xFF]=Ch;
--#endif
--          }
--    }
--  for (I=0;I<PswLength;I+=16)
--    EncryptBlock(&Psw[I]);
--}
--
--
--void SetOldKeys(char *NewPassword)
--{
--  UDWORD PswCRC;
--  UBYTE Ch;
--  PswCRC=CalcCRC32(0xFFFFFFFFL,(UBYTE*)NewPassword,strlen(NewPassword));
--  OldKey[0]=(UWORD)PswCRC;
--  OldKey[1]=(UWORD)(PswCRC>>16);
--  OldKey[2]=OldKey[3]=0;
--  PN1=PN2=PN3=0;
--  while ((Ch=*NewPassword)!=0)
--  {
--    PN1+=Ch;
--    PN2^=Ch;
--    PN3+=Ch;
--    PN3=(UBYTE)rol(PN3,1);
--    OldKey[2]^=((UWORD)(Ch^CRCTab[Ch]));
--    OldKey[3]+=((UWORD)(Ch+(CRCTab[Ch]>>16)));
--    NewPassword++;
--  }
--}
--
--static short crcInitialized = 0;
--void InitCRC(void)
--{
--  int I, J;
--  UDWORD C;
--  if (crcInitialized) return;
--
--  cli_dbgmsg("%s:%d:%s Initialize CRC table\n", __FILE__, __LINE__, "InitCRC");
--  for (I=0;I<256;I++)
--  {
--    for (C=I,J=0;J<8;J++)
--      C=(C & 1) ? (C>>1)^0xEDB88320L : (C>>1);
--    CRCTab[I]=C;
--  }
--  crcInitialized = 1;
--}
--
--
--static UDWORD CalcCRC32(UDWORD StartCRC,UBYTE *Addr,UDWORD Size)
--{
--  unsigned int I;
--  for (I=0; I<Size; I++)
--    StartCRC = CRCTab[(UBYTE)StartCRC ^ Addr[I]] ^ (StartCRC >> 8);
--  return(StartCRC);
--}
--
--
--/* **************************************************************************
-- ****************************************************************************
-- ****************************************************************************
-- ************************************************************************** */
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--/* **************************************************************************
-- ****************************************************************************
-- ****************************************************************************
-- ****************************************************************************
-- *******                                                              *******
-- *******                                                              *******
-- *******                                                              *******
-- *******              D E B U G    F U N C T I O N S                  *******
-- *******                                                              *******
-- *******                                                              *******
-- *******                                                              *******
-- ****************************************************************************
-- ****************************************************************************
-- ****************************************************************************
-- ************************************************************************** */
--#ifdef _DEBUG_LOG
--
--
--/* -- global stuff -------------------------------------------------------- */
--char  log_file_name[256];                   /* file name for the log file   */
--DWORD debug_start_time;                     /* starttime of debug           */
--BOOL  debug_started = FALSE;                /* debug_log writes only if     */
--                                            /* this is TRUE                 */
--/* ------------------------------------------------------------------------ */
--
--
--/* -- global functions ---------------------------------------------------- */
--void debug_init_proc(char *file_name)
--/* Create/Rewrite a log file                                                */
--{
--  FILE *fp;
--  char date[] = __DATE__;
--  char time[] = __TIME__;
--
--  debug_start_time = GetTickCount();        /* get start time               */
--  strcpy(log_file_name, file_name);         /* save file name               */
--
--  if((fp = fopen(log_file_name, CREATETEXT)) != NULL)
--  {
--    debug_started = TRUE;                   /* enable debug                 */
--    fprintf(fp, "Debug log of UniquE's RARFileLib\n"\
--                "~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~\n");
--    fprintf(fp, "(executable compiled on %s at %s)\n\n", date, time);
--    fclose(fp);
--  }
--}
--
--
--void debug_log_proc(char *text, char *sourcefile, int sourceline)
--/* add a line to the log file                                               */
--{
--  FILE *fp;
--
--  if(debug_started == FALSE) return;        /* exit if not initialized      */
--
--  if((fp = fopen(log_file_name, APPENDTEXT)) != NULL) /* append to logfile  */
--
--  {
--    fprintf(fp, " %8u ms (line %u in %s):\n              - %s\n",
--            (unsigned int)(GetTickCount() - debug_start_time),
--            sourceline, sourcefile, text);
--    fclose(fp);
--  }
--}
--
--/* ------------------------------------------------------------------------ */
--#endif
--/* **************************************************************************
-- ****************************************************************************
-- ****************************************************************************
-- ************************************************************************** */
--
--
--/* end of file urarlib.c */
---- ./libclamav/unrarlib.h.orig	Thu Jun 23 17:03:12 2005
-+++ ./libclamav/unrarlib.h	Wed Oct 12 14:40:13 2005
-@@ -1,205 +1,22 @@
--/* ***************************************************************************
-- **
-- **  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.
-- **
-- ************************************************************************** */
--
--/* include file for the "UniquE RAR File Library"  */
--/* (C) 2000-2002 by Christian Scheurer aka. UniquE */
--/* multi-OS version (Win32, Linux and SUN)         */
--
--#ifndef __URARLIB_H
--#define __URARLIB_H
--
--#ifdef __cplusplus
--extern "C"
--{
--#endif
--
--
--/* ************************************************************************ */
--/* ************************************************************************ */
--/* **                                                                    ** */
--/* **   CONFIGURATION of the UniquE RAR FileLib                          ** */
--/* **   ==> you may change the setting for the lib HERE!                 ** */
--/* **                                                                    ** */
--/* ************************************************************************ */
--/* ************************************************************************ */
--
--
--/* #define _DEBUG_LOG */                          /* generate debug messages      */
--
--#define _DO_CRC32_CHECK                     /* perform cyclical redundancy  */
--                                            /* check (CRC32) - disable this */
--                                            /* for a little speed-up        */
--/*#define _USE_ASM*/                            /*
--                                             * enable assembly extensions
--                                             * x86 cpus.
--                                             */
--
--/*#define _USE_MEMORY_TO_MEMORY_DECOMPRESSION*/ /* read file from memory or a   */
--                                            /* resource instead of reading  */
--                                            /* from a file. NOTE: you wont't*/
--                                            /*  be able to decompress from  */
--                                            /*  file if you enable this     */
--                                            /*  option!                     */
--
--
--#ifdef WIN32                                /* autodetect Win32 and Linux   */
--#define _WIN_32                             /* Win32 with VisualC           */
--#define _DEBUG_LOG_FILE "C:\\temp\\debug_unrar.txt" /* log file path        */
--#else
--#define _UNIX                               /* Linux or Unix with GCC       */
--#define _DEBUG_LOG_FILE "/tmp/debug_unrar.txt" /* log file path             */
--/*#define NON_INTEL_BYTE_ORDER*/               /* GCC on motorola systems    */
--
--#endif
--
--/* ------------------------------------------------------------------------ */
--
--/* detected by clamav/configure */
--#if 1 - WORDS_BIGENDIAN
--#define NON_INTEL_BYTE_ORDER
--#endif
--
--/* -- global type definitions --------------------------------------------- */
--
--#ifdef NON_INTEL_BYTE_ORDER
--#ifdef _USE_ASM
--#warning Disabling assembly because NON_INTEL_BYTE_ORDER is set
--#undef _USE_ASM
--#endif
--#endif
--
--#ifdef _WIN_32
--typedef unsigned char    UBYTE;             /* WIN32 definitions            */
--typedef unsigned short   UWORD;
--typedef unsigned long    UDWORD;
--#endif
--
--#ifdef _UNIX                                /* LINUX/UNIX definitions       */
--typedef unsigned char    UBYTE;
--typedef unsigned short   UWORD;
--typedef unsigned long    UDWORD;
--#endif
--
--#define RAR_FENTRY_ATTR_DIRECTORY ( 0x10 | 0x4000 )
--
--/* This structure is used for listing archive content                       */
--struct RAR20_archive_entry                  /* These infos about files are  */
--{                                           /* stored in RAR v2.0 archives  */
--  char   *Name;
--  UWORD  NameSize;
--  UDWORD PackSize;
--  UDWORD UnpSize;
--  UBYTE  HostOS;                            /* MSDOS=0,OS2=1,WIN32=2,UNIX=3 */
--  UDWORD FileCRC;
--  UDWORD FileTime;
--  UBYTE  UnpVer;
--  UBYTE  Method;
--  UDWORD FileAttr;
--  UWORD  Flags;
--};
--
--typedef struct  archivelist                 /* used to list archives        */
--{
--  struct RAR20_archive_entry item;
--  struct archivelist         *next;
--} ArchiveList_struct;
--
--
--#ifdef _USE_MEMORY_TO_MEMORY_DECOMPRESSION
--typedef struct  memory_file                 /* used to decompress files in  */
--{                                           /* memory                       */
--  void                       *data;         /* pointer to the file data     */
--  unsigned long              size;          /* total size of the file data  */
--  unsigned long              offset;        /* offset within "memory-file"  */
--} MemoryFile;
--#endif
--
--/* -- global functions ---------------------------------------------------- */
--
--/* urarlib_get:
-- * decompresses and decrypt data from a RAR file to a buffer in system memory.
-+/*
-+ *  Copyright (C) 2004 McMCC <mcmcc@mail.ru>
-  *
-- *   input: *output         pointer to an empty char*. This pointer will show
-- *                          to the extracted data
-- *          *size           shows where to write the size of the decompressed
-- *                          file
-- *                          (**NOTE: URARLib _does_ memory allocation etc.!**)
-- *          *filename       pointer to string containing the file to decompress
-- *          *rarfile        pointer to a string with the full name and path of
-- *                          the RAR file or pointer to a RAR file in memory if
-- *                          memory-to-memory decompression is active.
-- *          *libpassword    pointer to a string with the password used to
-- *                          en-/decrypt the RAR
-- *   output: int            returns TRUE on success or FALSE on error
-- *                          (FALSE=0, TRUE=1)
-- */
--
--extern int urarlib_get(void  *output,
--                       unsigned long *size,
--                       char *filename,
--                       int desc,
--                       char *libpassword);
--
--
--
--/* urarlib_list:
-- * list the content of a RAR archive.
-+ *  Support check archives RAR v.3.x
-  *
-- *   input: *rarfile        pointer to a string with the full name and path of
-- *                          the RAR file or pointer to a RAR file in memory if
-- *                          memory-to-memory decompression is active.
-- *          *list           pointer to an ArchiveList_struct that can be
-- *                          filled with details about the archive
-- *                          to the extracted data
-- *   output: int            number of files/directories within archive
-- */
--
--extern int urarlib_list(int desc, ArchiveList_struct *list);
--
--
--/* 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.
-+ *  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.
-  *
-- *    input: *list          pointer to an ArchiveList_struct
-- *    output: -
-  */
- 
--extern void urarlib_freelist(ArchiveList_struct *list);
--
--/* ------------------------------------------------------------------------ */
--
--
--
--#ifdef __cplusplus
--};
--#endif
--
--#endif
--
-+int cli_unrar3(const char *dir, int desc);
diff --git a/security/clamav/files/patch-configure b/security/clamav/files/patch-configure
index 2ac2e4dfeb61..96f1b1ce1785 100644
--- a/security/clamav/files/patch-configure
+++ b/security/clamav/files/patch-configure
@@ -1,25 +1,5 @@
 --- configure.orig	Thu Jun 23 23:12:00 2005
 +++ configure	Tue Jun 28 20:53:10 2005
-@@ -10914,6 +10914,9 @@
- cat >>conftest.$ac_ext <<_ACEOF
- /* end confdefs.h.  */
- $ac_includes_default
-+#include <sys/types.h>
-+#include <netinet/in.h>
-+#include <arpa/nameser.h>
- #include <resolv.h>
- _ACEOF
- rm -f conftest.$ac_objext
-@@ -10957,6 +10960,9 @@
- cat confdefs.h >>conftest.$ac_ext
- cat >>conftest.$ac_ext <<_ACEOF
- /* end confdefs.h.  */
-+#include <sys/types.h>
-+#include <netinet/in.h>
-+#include <arpa/nameser.h>
- #include <resolv.h>
- _ACEOF
- if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 @@ -11195,19 +11201,25 @@
      sendmailver_c=`echo $sendmailver | awk -F. '{printf $3}'`
  
diff --git a/security/clamav/files/patch-libclamav::zziplib::zzip-conf.h b/security/clamav/files/patch-libclamav::zziplib::zzip-conf.h
deleted file mode 100644
index fe62753a8889..000000000000
--- a/security/clamav/files/patch-libclamav::zziplib::zzip-conf.h
+++ /dev/null
@@ -1,11 +0,0 @@
---- libclamav/zziplib/zzip-conf.h.orig	Mon Nov 24 17:52:56 2003
-+++ libclamav/zziplib/zzip-conf.h	Mon Nov 24 17:53:05 2003
-@@ -11,6 +11,8 @@
- #ifndef _ZZIP_CONF_H
- #define _ZZIP_CONF_H 1
- 
-+#include <sys/types.h>
-+
- #if !defined ZZIP_OMIT_CONFIG_H
- # if defined _MSC_VER || defined __BORLANDC__ || defined __WATCOMC__
- # include <zzip-msvc.h>
diff --git a/security/clamav/files/patch-libclamav_clamav.h b/security/clamav/files/patch-libclamav_clamav.h
deleted file mode 100644
index a67b0cfbf6bd..000000000000
--- a/security/clamav/files/patch-libclamav_clamav.h
+++ /dev/null
@@ -1,11 +0,0 @@
---- libclamav/clamav.h.orig	Fri May 13 09:11:42 2005
-+++ libclamav/clamav.h	Fri May 13 09:11:46 2005
-@@ -221,7 +221,7 @@
- extern const char *cl_perror(int clerror); /* deprecated */
- 
- #ifdef __cplusplus
--};
-+}
- #endif
-  
- #endif
diff --git a/security/clamav/files/pkg-deinstall.in b/security/clamav/files/pkg-deinstall.in
index 0075621d1650..32b25c24a4d1 100644
--- a/security/clamav/files/pkg-deinstall.in
+++ b/security/clamav/files/pkg-deinstall.in
@@ -1,5 +1,5 @@
 #!/bin/sh
-# $FreeBSD: /tmp/pcvs/ports/security/clamav/files/pkg-deinstall.in,v 1.1 2005-05-13 08:16:40 jylefort Exp $
+# $FreeBSD: /tmp/pcvs/ports/security/clamav/files/pkg-deinstall.in,v 1.2 2007-02-16 00:19:32 garga Exp $
 
 if [ "$2" != "POST-DEINSTALL" ]; then
 	exit 0
@@ -7,7 +7,20 @@ fi
 
 CLAMAVUSER=%%CLAMAVUSER%%
 
+echo
+echo "===================================================="
+echo
+echo "If you want remove clamav permanently from you system"
+echo "execute following commands:"
+echo
+echo " # rm -rf %%LOGDIR%%"
+echo " # rm -rf %%RUNDIR%%"
+echo " # rm -rf %%DBDIR%%"
 if pw usershow "${CLAMAVUSER}" 2>/dev/null 1>&2; then
-	echo "To delete ${CLAMAVUSER} user permanently, use 'pw userdel \"${CLAMAVUSER}\"'"
+	echo " # pw userdel ${CLAMAVUSER}"
 fi
+echo
+echo "===================================================="
+echo
+
 exit 0
diff --git a/security/clamav/files/pkg-install.in b/security/clamav/files/pkg-install.in
index 729a0036f07c..bd223b539fa6 100644
--- a/security/clamav/files/pkg-install.in
+++ b/security/clamav/files/pkg-install.in
@@ -1,5 +1,5 @@
 #!/bin/sh
-# $FreeBSD: /tmp/pcvs/ports/security/clamav/files/pkg-install.in,v 1.2 2006-08-08 19:33:04 garga Exp $
+# $FreeBSD: /tmp/pcvs/ports/security/clamav/files/pkg-install.in,v 1.3 2007-02-16 00:19:32 garga Exp $
 
 PREFIX=${PKG_PREFIX:-%%PREFIX%%}
 
@@ -48,32 +48,14 @@ if [ "$2" = "PRE-INSTALL" ]; then
 
 elif [ "$2" = "POST-INSTALL" ]; then
 
-	if [ ! -d "${DESTDIR}${DBDIR}" ]; then
-		${MKDIR} ${DBDIR} || exit 1
-		${CHOWN} ${CLAMAVUSER}:${CLAMAVGROUP} ${DBDIR} || exit 1
-	fi
+	[ ! -d "${DESTDIR}${DBDIR}" ] && (${MKDIR} ${DBDIR} || exit 1)
+	${CHOWN} -R ${CLAMAVUSER}:${CLAMAVGROUP} ${DBDIR} || exit 1
 
-	if [ ! -d "${DESTDIR}${LOGDIR}" ]; then
-		${MKDIR} ${LOGDIR} || exit 1
-		${CHOWN} ${CLAMAVUSER}:${CLAMAVGROUP} ${LOGDIR} || exit 1
-	fi
+	[ ! -d "${DESTDIR}${LOGDIR}" ] && (${MKDIR} ${LOGDIR} || exit 1)
+	${CHOWN} -R ${CLAMAVUSER}:${CLAMAVGROUP} ${LOGDIR} || exit 1
 
-	if [ ! -d "${DESTDIR}${RUNDIR}" ]; then
-		${MKDIR} ${RUNDIR} || exit 1
-		${CHOWN} ${CLAMAVUSER}:${CLAMAVGROUP} ${RUNDIR} || exit 1
-	fi
-
-	if [ -f "${TARGETDIR}/etc/clamav.conf" ]; then
-		echo
-		echo "**************** WARNING ****************"
-		echo "*                                       *"
-		echo "*  The configuration file has changed:  *"
-		echo "* Please edit $PREFIX/etc/clamd.conf *"
-		echo "* and remove $PREFIX/etc/clamav.conf *"
-		echo "*                                       *"
-		echo "**************** WARNING ****************"
-		echo
-	fi
+	[ ! -d "${DESTDIR}${RUNDIR}" ] && (${MKDIR} ${RUNDIR} || exit 1)
+	${CHOWN} -R ${CLAMAVUSER}:${CLAMAVGROUP} ${RUNDIR} || exit 1
 
 fi
 
diff --git a/security/clamav/pkg-plist b/security/clamav/pkg-plist
index 6deae405f325..a071176ce2de 100644
--- a/security/clamav/pkg-plist
+++ b/security/clamav/pkg-plist
@@ -1,5 +1,6 @@
 @comment $FreeBSD$
 bin/clamav-config
+bin/clamconf
 bin/clamscan
 bin/clamdscan
 bin/freshclam