@@ -176,7 +176,7 @@ static uint32_t getbits(struct UNP *UNP, uint32_t size) {

 *********************/

-static int ea05(cli_ctx *ctx, uint8_t *base, char *tmpd) {

+static int ea05(cli_ctx *ctx, const uint8_t *base, char *tmpd) {

   uint8_t b[300], comp;

   uint32_t s, m4sum=0;

   int i, ret;

@@ -480,7 +480,7 @@ static void LAME_decrypt (uint8_t *cypher, uint32_t size, uint16_t seed) {

  autoit3 EA06 handler 

 *********************/

-static int ea06(cli_ctx *ctx, uint8_t *base, char *tmpd) {

+static int ea06(cli_ctx *ctx, const uint8_t *base, char *tmpd) {

   uint8_t b[600], comp, script, *buf;

   uint32_t s;

   int i, ret;

@@ -916,7 +916,7 @@ static int ea06(cli_ctx *ctx, uint8_t *base, char *tmpd) {

 *********************/

 int cli_scanautoit(cli_ctx *ctx, off_t offset) {

-  uint8_t *version;

+  const uint8_t *version;

   int r;

   char *tmpd;

   fmap_t *map = *ctx->fmap;

@@ -48,7 +48,8 @@ static const uint8_t hqxtbl[] = {

 int cli_binhex(cli_ctx *ctx) {

     fmap_t *map = *ctx->fmap;

-    uint8_t *encoded, decoded[BUFSIZ], spare_bits, last_byte=0, this_byte, offset=0;

+    const uint8_t *encoded;

+    uint8_t decoded[BUFSIZ], spare_bits, last_byte=0, this_byte, offset=0;

     size_t enc_done=0, enc_todo=map->len;

     unsigned int dec_done=0, chunksz = 0, chunkoff=0;

     uint32_t datalen, reslen;

@@ -534,7 +534,7 @@ int32_t cli_bcapi_extract_new(struct cli_bc_ctx *ctx, int32_t id)

 int32_t cli_bcapi_read_number(struct cli_bc_ctx *ctx, uint32_t radix)

 {

     unsigned i;

-    char *p;

+    const char *p;

     int32_t result;

     if ((radix != 10 && radix != 16) || !ctx->fmap)

@@ -705,7 +705,7 @@ uint32_t cli_bcapi_buffer_pipe_read_avail(struct cli_bc_ctx *ctx , int32_t id)

     return ctx->file_size - b->read_cursor;

 }

-uint8_t* cli_bcapi_buffer_pipe_read_get(struct cli_bc_ctx *ctx , int32_t id, uint32_t size)

+const uint8_t* cli_bcapi_buffer_pipe_read_get(struct cli_bc_ctx *ctx , int32_t id, uint32_t size)

 {

     struct bc_buffer *b = get_buffer(ctx, id);

     if (!b || size > cli_bcapi_buffer_pipe_read_avail(ctx, id) || !size)

@@ -843,7 +843,7 @@ int32_t cli_bcapi_inflate_process(struct cli_bc_ctx *ctx , int32_t id)

     b->stream.avail_in = avail_in_orig =

 	cli_bcapi_buffer_pipe_read_avail(ctx, b->from);

-    b->stream.next_in = cli_bcapi_buffer_pipe_read_get(ctx, b->from,

+    b->stream.next_in = (void*)cli_bcapi_buffer_pipe_read_get(ctx, b->from,

 						       b->stream.avail_in);

     b->stream.avail_out = avail_out_orig =

@@ -959,7 +959,7 @@ static struct bc_jsnorm *get_jsnorm(struct cli_bc_ctx *ctx, int32_t id)

 int32_t cli_bcapi_jsnorm_process(struct cli_bc_ctx *ctx, int32_t id)

 {

     unsigned avail;

-    unsigned char *in;

+    const unsigned char *in;

     cli_ctx *cctx = ctx->ctx;

     struct bc_jsnorm *b = get_jsnorm(ctx, id);

     if (!b || b->from == -1 || !b->state)

@@ -1448,7 +1448,7 @@ uint32_t cli_bcapi_pdf_getobjsize(struct cli_bc_ctx *ctx , int32_t objidx)

     return ctx->pdf_objs[objidx+1].start - ctx->pdf_objs[objidx].start - 4;

 }

-uint8_t* cli_bcapi_pdf_getobj(struct cli_bc_ctx *ctx , int32_t objidx, uint32_t amount)

+const uint8_t* cli_bcapi_pdf_getobj(struct cli_bc_ctx *ctx , int32_t objidx, uint32_t amount)

 {

     uint32_t size = cli_bcapi_pdf_getobjsize(ctx, objidx);

     if (amount > size)

@@ -65,7 +65,7 @@ int32_t cli_bcapi_hashset_empty(struct cli_bc_ctx *ctx , int32_t);

 int32_t cli_bcapi_buffer_pipe_new(struct cli_bc_ctx *ctx , uint32_t);

 int32_t cli_bcapi_buffer_pipe_new_fromfile(struct cli_bc_ctx *ctx , uint32_t);

 uint32_t cli_bcapi_buffer_pipe_read_avail(struct cli_bc_ctx *ctx , int32_t);

-uint8_t* cli_bcapi_buffer_pipe_read_get(struct cli_bc_ctx *ctx , int32_t, uint32_t);

+const uint8_t* cli_bcapi_buffer_pipe_read_get(struct cli_bc_ctx *ctx , int32_t, uint32_t);

 int32_t cli_bcapi_buffer_pipe_read_stopped(struct cli_bc_ctx *ctx , int32_t, uint32_t);

 uint32_t cli_bcapi_buffer_pipe_write_avail(struct cli_bc_ctx *ctx , int32_t);

 uint8_t* cli_bcapi_buffer_pipe_write_get(struct cli_bc_ctx *ctx , int32_t, uint32_t);

@@ -114,7 +114,7 @@ int32_t cli_bcapi_pdf_get_flags(struct cli_bc_ctx *ctx );

 int32_t cli_bcapi_pdf_set_flags(struct cli_bc_ctx *ctx , int32_t);

 int32_t cli_bcapi_pdf_lookupobj(struct cli_bc_ctx *ctx , uint32_t);

 uint32_t cli_bcapi_pdf_getobjsize(struct cli_bc_ctx *ctx , int32_t);

-uint8_t* cli_bcapi_pdf_getobj(struct cli_bc_ctx *ctx , int32_t, uint32_t);

+const uint8_t* cli_bcapi_pdf_getobj(struct cli_bc_ctx *ctx , int32_t, uint32_t);

 int32_t cli_bcapi_pdf_getobjid(struct cli_bc_ctx *ctx , int32_t);

 int32_t cli_bcapi_pdf_getobjflags(struct cli_bc_ctx *ctx , int32_t);

 int32_t cli_bcapi_pdf_setobjflags(struct cli_bc_ctx *ctx , int32_t, int32_t);

@@ -63,7 +63,7 @@ int32_t cli_bcapi_hashset_empty(struct cli_bc_ctx *ctx , int32_t);

 int32_t cli_bcapi_buffer_pipe_new(struct cli_bc_ctx *ctx , uint32_t);

 int32_t cli_bcapi_buffer_pipe_new_fromfile(struct cli_bc_ctx *ctx , uint32_t);

 uint32_t cli_bcapi_buffer_pipe_read_avail(struct cli_bc_ctx *ctx , int32_t);

-uint8_t* cli_bcapi_buffer_pipe_read_get(struct cli_bc_ctx *ctx , int32_t, uint32_t);

+const uint8_t* cli_bcapi_buffer_pipe_read_get(struct cli_bc_ctx *ctx , int32_t, uint32_t);

 int32_t cli_bcapi_buffer_pipe_read_stopped(struct cli_bc_ctx *ctx , int32_t, uint32_t);

 uint32_t cli_bcapi_buffer_pipe_write_avail(struct cli_bc_ctx *ctx , int32_t);

 uint8_t* cli_bcapi_buffer_pipe_write_get(struct cli_bc_ctx *ctx , int32_t, uint32_t);

@@ -112,7 +112,7 @@ int32_t cli_bcapi_pdf_get_flags(struct cli_bc_ctx *ctx );

 int32_t cli_bcapi_pdf_set_flags(struct cli_bc_ctx *ctx , int32_t);

 int32_t cli_bcapi_pdf_lookupobj(struct cli_bc_ctx *ctx , uint32_t);

 uint32_t cli_bcapi_pdf_getobjsize(struct cli_bc_ctx *ctx , int32_t);

-uint8_t* cli_bcapi_pdf_getobj(struct cli_bc_ctx *ctx , int32_t, uint32_t);

+const uint8_t* cli_bcapi_pdf_getobj(struct cli_bc_ctx *ctx , int32_t, uint32_t);

 int32_t cli_bcapi_pdf_getobjid(struct cli_bc_ctx *ctx , int32_t);

 int32_t cli_bcapi_pdf_getobjflags(struct cli_bc_ctx *ctx , int32_t);

 int32_t cli_bcapi_pdf_setobjflags(struct cli_bc_ctx *ctx , int32_t, int32_t);

@@ -95,7 +95,8 @@ struct cab_block_hdr

 static char *cab_readstr(fmap_t *map, off_t *offset, int *ret)

 {

 	int i;

-	char *str, *retstr;

+	const char *str;

+	char *retstr;

     if(!(str = fmap_need_offstr(map, *offset, 256))) {

 	*ret = CL_EFORMAT;

@@ -181,8 +182,8 @@ int cab_open(fmap_t *map, off_t offset, struct cab_archive *cab)

 	unsigned int i, folders = 0;

 	struct cab_file *file, *lfile = NULL;

 	struct cab_folder *folder, *lfolder = NULL;

-	struct cab_hdr *hdr;

-	struct cab_hdr_opt *hdr_opt;

+	const struct cab_hdr *hdr;

+	const struct cab_hdr_opt *hdr_opt;

 	uint16_t fidx;

 	uint32_t coffFiles;

 	char *pt;

@@ -305,7 +306,7 @@ int cab_open(fmap_t *map, off_t offset, struct cab_archive *cab)

     /* folders */

     for(i = 0; i < cab->nfolders; i++) {

-	struct cab_folder_hdr *folder_hdr;

+	const struct cab_folder_hdr *folder_hdr;

 	if(!(folder_hdr = fmap_need_off_once(map, cur_offset, sizeof(*folder_hdr)))) {

 	    cli_dbgmsg("cab_open: Can't read header for folder %u\n", i);

@@ -360,7 +361,7 @@ int cab_open(fmap_t *map, off_t offset, struct cab_archive *cab)

 	cur_offset = coffFiles;

     }

     for(i = 0; i < cab->nfiles; i++) {

-	struct cab_file_hdr *file_hdr;

+	const struct cab_file_hdr *file_hdr;

 	if(!(file_hdr = fmap_need_off_once(map, cur_offset, sizeof(*file_hdr)))) {

 	    cli_dbgmsg("cab_open: Can't read file %u header\n", i);

@@ -449,7 +450,7 @@ int cab_open(fmap_t *map, off_t offset, struct cab_archive *cab)

 static int cab_read_block(struct cab_file *file)

 {

-	struct cab_block_hdr *block_hdr;

+	const struct cab_block_hdr *block_hdr;

 	struct cab_state *state = file->cab->state;

     if(!(block_hdr = fmap_need_off_once(file->cab->map, file->cab->cur_offset, sizeof(*block_hdr)))) {

@@ -703,7 +703,7 @@ int cache_check(unsigned char *hash, cli_ctx *ctx) {

     cli_md5_init(&md5);

     while(todo) {

-	void *buf;

+	const void *buf;

 	size_t readme = todo < FILEBUFF ? todo : FILEBUFF;

 	if(!(buf = fmap_need_off_once(map, at, readme)))

 	    return CL_VIRUS;

@@ -105,7 +105,7 @@ typedef struct lzx_content_tag {

 /* Read in a block of data from either the mmap area or the given fd */

 static int chm_read_data(fmap_t *map, char *dest, off_t offset, off_t len)

 {

-    void *src = fmap_need_off_once(map, offset, len);

+    const void *src = fmap_need_off_once(map, offset, len);

     if(!src) return FALSE;

     memcpy(dest, src, len);

     return TRUE;

@@ -233,10 +233,10 @@ static int itsp_read_header(chm_metadata_t *metadata, off_t offset)

 	return TRUE;

 }

-static uint64_t read_enc_int(char **start, char *end)

+static uint64_t read_enc_int(const char **start, const char *end)

 {

 	uint64_t retval=0;

-	char *current;

+	const char *current;

 	current = *start;

@@ -258,7 +258,7 @@ static uint64_t read_enc_int(char **start, char *end)

 /* Read control entries */

 static int read_control_entries(chm_metadata_t *metadata)

 {

-	char *name;

+	const char *name;

 	uint64_t name_len, section, offset, length;

 	while (metadata->chunk_entries--) {

@@ -108,9 +108,9 @@ typedef struct chm_metadata_tag {

 	int ofd;

 	uint32_t num_chunks;

 	off_t chunk_offset;

-	char *chunk_data;

-	char *chunk_current;

-	char *chunk_end;

+	const char *chunk_data;

+	const char *chunk_current;

+	const char *chunk_end;

 	fmap_t *map;

 	uint16_t chunk_entries;

 } chm_metadata_t;

@@ -155,11 +155,12 @@ cli_file_t cli_filetype(const unsigned char *buf, size_t buflen, const struct cl

     return cli_texttype(buf, buflen);

 }

-int is_tar(unsigned char *buf, unsigned int nbytes);

+int is_tar(const unsigned char *buf, unsigned int nbytes);

 cli_file_t cli_filetype2(fmap_t *map, const struct cl_engine *engine)

 {

-	unsigned char *buff, *decoded;

+	const unsigned char *buff;

+	unsigned char *decoded;

 	int bread = MIN(map->len, MAGIC_BUFFER_SIZE), sret;

 	cli_file_t ret = CL_TYPE_BINARY_DATA;

 	struct cli_matcher *root;

@@ -103,12 +103,12 @@ static inline size_t fmap_ptr2off(const fmap_t *m, const void *ptr)

 	 :(const char*)ptr - (const char*)m - m->hdrsz;

 }

-static inline const void *fmap_need_ptr(fmap_t *m, void *ptr, size_t len)

+static inline const void *fmap_need_ptr(fmap_t *m, const void *ptr, size_t len)

 {

     return m->need(m, fmap_ptr2off(m, ptr), len, 1);

 }

-static inline const void *fmap_need_ptr_once(fmap_t *m, void *ptr, size_t len)

+static inline const void *fmap_need_ptr_once(fmap_t *m, const void *ptr, size_t len)

 {

     return m->need(m, fmap_ptr2off(m, ptr), len, 0);

 }

@@ -118,7 +118,7 @@ static inline void fmap_unneed_off(fmap_t *m, size_t at, size_t len)

     m->unneed_off(m, at, len);

 }

-static inline void fmap_unneed_ptr(fmap_t *m, void *ptr, size_t len)

+static inline void fmap_unneed_ptr(fmap_t *m, const void *ptr, size_t len)

 {

     fmap_unneed_off(m, fmap_ptr2off(m, ptr), len);

 }

@@ -140,7 +140,7 @@ static inline int fmap_readn(fmap_t *m, void *dst, size_t at, size_t len)

     return len;

 }

-static inline const void *fmap_need_str(fmap_t *m, void *ptr, size_t len_hint)

+static inline const void *fmap_need_str(fmap_t *m, const void *ptr, size_t len_hint)

 {

     return m->need_offstr(m, fmap_ptr2off(m, ptr), len_hint);

 }

@@ -46,7 +46,7 @@

 #include "packlibs.h"

 #include "fsg.h"

-int unfsg_200(char *source, char *dest, int ssize, int dsize, uint32_t rva, uint32_t base, uint32_t ep, int file) {

+int unfsg_200(const char *source, char *dest, int ssize, int dsize, uint32_t rva, uint32_t base, uint32_t ep, int file) {

   struct cli_exe_section section; /* Yup, just one ;) */

   if ( cli_unfsg(source, dest, ssize, dsize, NULL, NULL) ) return -1;

@@ -64,8 +64,9 @@ int unfsg_200(char *source, char *dest, int ssize, int dsize, uint32_t rva, uint

 }

-int unfsg_133(char *source, char *dest, int ssize, int dsize, struct cli_exe_section *sections, int sectcount, uint32_t base, uint32_t ep, int file) {

-  char *tsrc=source, *tdst=dest;

+int unfsg_133(const char *source, char *dest, int ssize, int dsize, struct cli_exe_section *sections, int sectcount, uint32_t base, uint32_t ep, int file) {

+  const char *tsrc=source;

+  char *tdst=dest;

   int i, upd=1, offs=0, lastsz=dsize;

   for (i = 0 ; i <= sectcount ; i++) {

@@ -24,8 +24,8 @@

 #include "cltypes.h"

 #include "execs.h"

-int unfsg_200(char *, char *, int, int, uint32_t, uint32_t, uint32_t, int);

-int unfsg_133(char *, char *, int , int, struct cli_exe_section *, int, uint32_t, uint32_t, int);

+int unfsg_200(const char *, char *, int, int, uint32_t, uint32_t, uint32_t, int);

+int unfsg_133(const char *, char *, int , int, struct cli_exe_section *, int, uint32_t, uint32_t, int);

 #endif

@@ -32,7 +32,7 @@ static int from_oct(int digs, char *where);

  *	1 for old UNIX tar file,

  *	2 for Unix Std (POSIX) tar file.

  */

-int is_tar(unsigned char *buf, unsigned int nbytes)

+int is_tar(const unsigned char *buf, unsigned int nbytes)

 {

 	union record *header = (union record *)buf;

 	int	i;

@@ -44,4 +44,4 @@ union record {

 /* The magic field is filled with this if uname and gname are valid. */

 #define	TMAGIC		"ustar  "	/* 7 chars and a null */

-int is_tar(unsigned char *buf, unsigned int nbytes);

+int is_tar(const unsigned char *buf, unsigned int nbytes);

@@ -193,7 +193,7 @@ static const uint8_t skey[] = { 0xec, 0xca, 0x79, 0xf8 }; /* ~0x13, ~0x35, ~0x86

 /* Extracts the content of MSI based IS */

 int cli_scanishield_msi(cli_ctx *ctx, off_t off) {

-    uint8_t *buf;

+    const uint8_t *buf;

     unsigned int fcount, scanned = 0;

     int ret;

     fmap_t *map = *ctx->fmap;

@@ -337,7 +337,8 @@ static int is_extract_cab(cli_ctx *ctx, uint64_t off, uint64_t size, uint64_t cs

 /* Extract the content of older (non-MSI) IS */

 int cli_scanishield(cli_ctx *ctx, off_t off, size_t sz) {

-    char *fname, *path, *version, *strsz, *eostr, *data;

+    const char *fname, *path, *version, *strsz, *data;

+    char *eostr;

     int ret = CL_CLEAN;

     long fsize;

     off_t coff = off;

@@ -436,7 +437,8 @@ int cli_scanishield(cli_ctx *ctx, off_t off, size_t sz) {

 /* Utility func to scan a fd @ a given offset and size */

 static int is_dump_and_scan(cli_ctx *ctx, off_t off, size_t fsize) {

-    char *fname, *buf;

+    char *fname;

+    const char *buf;

     int ofd, ret = CL_CLEAN;

     fmap_t *map = *ctx->fmap;

@@ -486,7 +488,7 @@ static int is_parse_hdr(cli_ctx *ctx, struct IS_CABSTUFF *c) {

     char hash[33], *hdr;

     fmap_t *map = *ctx->fmap;

-    struct IS_HDR *h1;

+    const struct IS_HDR *h1;

     struct IS_OBJECTS *objs;

     /* struct IS_INSTTYPEHDR *typehdr; -- UNUSED */

@@ -675,7 +677,8 @@ static void md5str(uint8_t *sum) {

 #define IS_CABBUFSZ 65536

 static int is_extract_cab(cli_ctx *ctx, uint64_t off, uint64_t size, uint64_t csize) {

-    uint8_t *inbuf, *outbuf;

+    const uint8_t *inbuf;

+    uint8_t *outbuf;

     char *tempfile;

     int ofd, ret = CL_CLEAN;

     z_stream z;

@@ -37,7 +37,7 @@ typedef struct {

 } iso9660_t;

-static void *needblock(const iso9660_t *iso, unsigned int block, int temp) {

+static const void *needblock(const iso9660_t *iso, unsigned int block, int temp) {

     cli_ctx *ctx = iso->ctx;

     size_t loff;

     unsigned int blocks_per_sect = (2048 / iso->blocksz);

@@ -59,7 +59,7 @@ static int iso_scan_file(const iso9660_t *iso, unsigned int block, unsigned int

     cli_dbgmsg("iso_scan_file: dumping to %s\n", tmpf);

     while(len) {

-	void *buf = needblock(iso, block, 1);

+	const void *buf = needblock(iso, block, 1);

 	unsigned int todo = MIN(len, iso->blocksz);

 	if(cli_writen(fd, buf, todo) != todo) {

 	    close(fd);

@@ -88,7 +88,7 @@ static int iso_scan_file(const iso9660_t *iso, unsigned int block, unsigned int

     return ret;

 }

-static char *iso_string(iso9660_t *iso, void *src, unsigned int len) {

+static char *iso_string(iso9660_t *iso, const void *src, unsigned int len) {

     if(iso->joliet) {

 	char *utf8;

 	if(len > sizeof(iso->buf))

@@ -120,7 +120,7 @@ static int iso_parse_dir(iso9660_t *iso, unsigned int block, unsigned int len) {

     }

     for(; len && ret == CL_CLEAN; block++, len -= MIN(len, iso->blocksz)) {

-	uint8_t *dir, *dir_orig;

+	const uint8_t *dir, *dir_orig;

 	unsigned int dirsz;

 	if(iso->dir_blocks.count > 1024) {

@@ -205,7 +205,7 @@ static int iso_parse_dir(iso9660_t *iso, unsigned int block, unsigned int len) {

 }

 int cli_scaniso(cli_ctx *ctx, size_t offset) {

-    uint8_t *privol, *next;

+    const uint8_t *privol, *next;

     iso9660_t iso;

     int i;

@@ -396,7 +396,7 @@ int cli_checkfp(unsigned char *digest, size_t size, cli_ctx *ctx)

         SHA1Context sha1;

         SHA256_CTX sha256;

         fmap_t *map;

-        char *ptr;

+        const char *ptr;

         uint8_t shash1[SHA1_HASH_SIZE*2+1];

         uint8_t shash256[SHA256_HASH_SIZE*2+1];

 	int have_sha1, have_sha256;

@@ -610,7 +610,7 @@ int cli_lsig_eval(cli_ctx *ctx, struct cli_matcher *root, struct cli_ac_data *ac

 int cli_fmap_scandesc(cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly, struct cli_matched_type **ftoffset, unsigned int acmode, struct cli_ac_result **acres, unsigned char *refhash)

 {

- 	unsigned char *buff;

+	const unsigned char *buff;

 	int ret = CL_CLEAN, type = CL_CLEAN, bytes, compute_hash[CLI_HASH_AVAIL_TYPES];

 	unsigned int i = 0, bm_offmode = 0;

 	uint32_t maxpatlen, offset = 0;

@@ -760,7 +760,7 @@ int cli_fmap_scandesc(cli_ctx *ctx, cli_file_t ftype, uint8_t ftonly, struct cli

 	    }

 	    if(hdb) {

-		void *data = buff + maxpatlen * (offset!=0);

+		const void *data = buff + maxpatlen * (offset!=0);

 		uint32_t data_len = bytes - maxpatlen * (offset!=0);

 		if(compute_hash[CLI_HASH_MD5])

@@ -656,7 +656,7 @@ parseEmailFile(fmap_t *map, size_t *at, const table_t *rfc821, const char *first

 				bodyIsEmpty = TRUE;

 			} else {

 				char *ptr;

-				char *lookahead;

+				const char *lookahead;

 				if(fullline == NULL) {

 					char cmd[RFC2821LENGTH + 1], out[RFC2821LENGTH + 1];

@@ -3212,7 +3212,8 @@ usefulHeader(int commandNumber, const char *cmd)

 static char *

 getline_from_mbox(char *buffer, size_t buffer_len, fmap_t *map, size_t *at)

 {

-    char *src, *cursrc, *curbuf;

+    const char *src, *cursrc;

+    char *curbuf;

     size_t i;

     size_t input_len = MIN(map->len - *at, buffer_len + 1);

     src = cursrc = fmap_need_off_once(map, *at, input_len);

@@ -64,7 +64,7 @@

 /* northfox does this shitty way,

  * this should be done with just a bswap

  */

-static char *lzma_bswap_4861dc(struct lzmastate *p, char *old_edx)

+static const char *lzma_bswap_4861dc(struct lzmastate *p, const char *old_edx)

 {

 	/* dumb_dump_start

 	 *

@@ -99,7 +99,7 @@ static char *lzma_bswap_4861dc(struct lzmastate *p, char *old_edx)

 	return p->p0;

 }

-static uint32_t lzma_486248 (struct lzmastate *p, char **old_ecx, char *src, uint32_t size)

+static uint32_t lzma_486248 (struct lzmastate *p,const char **old_ecx, char *src, uint32_t size)

 {

 	uint32_t loc_esi, loc_edi, loc_eax, loc_ecx, ret;

 	if (!CLI_ISCONTAINED(src, size, *old_ecx, 4) || !CLI_ISCONTAINED(src, size, p->p0, 1))

@@ -152,11 +152,11 @@ static uint32_t lzma_486248 (struct lzmastate *p, char **old_ecx, char *src, uin

 }

-static uint32_t lzma_48635C(uint8_t znaczek, char **old_ecx, struct lzmastate *p, uint32_t *retval, char *src, uint32_t size)

+static uint32_t lzma_48635C(uint8_t znaczek, const char **old_ecx, struct lzmastate *p, uint32_t *retval, char *src, uint32_t size)

 {

 	uint32_t loc_esi = (znaczek&0xff) >> 7, /* msb */

 		loc_ebx, ret;

-	char *loc_edi;

+	const char *loc_edi;

 	znaczek <<= 1;

 	ret = loc_esi << 9;

 	loc_edi = *old_ecx;

@@ -196,10 +196,10 @@ static uint32_t lzma_48635C(uint8_t znaczek, char **old_ecx, struct lzmastate *p

 	return 0;

 }

-static uint32_t lzma_4862e0 (struct lzmastate *p, char **old_ecx, uint32_t *old_edx, uint32_t *retval, char *src, uint32_t size)

+static uint32_t lzma_4862e0 (struct lzmastate *p, const char **old_ecx, uint32_t *old_edx, uint32_t *retval, char *src, uint32_t size)

 {

 	uint32_t loc_ebx, loc_esi, stack_ecx, ret;

-	char *loc_edi;

+	const char *loc_edi;

 	loc_ebx = *old_edx;

 	ret = 1;

@@ -229,10 +229,10 @@ static uint32_t lzma_4862e0 (struct lzmastate *p, char **old_ecx, uint32_t *old_

 }

 /* old_edx - write only */

-static uint32_t lzma_4863da (uint32_t var0, struct lzmastate *p, char  **old_ecx, uint32_t *old_edx, uint32_t *retval, char *src, uint32_t size)

+static uint32_t lzma_4863da (uint32_t var0, struct lzmastate *p, const char  **old_ecx, uint32_t *old_edx, uint32_t *retval, char *src, uint32_t size)

 {

 	uint32_t ret;

-	char *loc_esi = *old_ecx;

+	const char *loc_esi = *old_ecx;

 	if ((ret = lzma_486248 (p, old_ecx, src, size)) == 0xffffffff)

 		return -1;

@@ -274,7 +274,7 @@ static uint32_t lzma_4863da (uint32_t var0, struct lzmastate *p, char  **old_ecx

 static uint32_t lzma_486204 (struct lzmastate *p, uint32_t old_edx, uint32_t *retval, char *src, uint32_t size)

 {

 	uint32_t loc_esi, loc_edi, loc_ebx, loc_eax;

-	char *loc_edx;

+	const char *loc_edx;

 	loc_esi = p->p1;

 	loc_edi = p->p2;

 	loc_eax = 0;

@@ -311,11 +311,11 @@ static uint32_t lzma_486204 (struct lzmastate *p, uint32_t old_edx, uint32_t *re

 	return 0;

 }

-static uint32_t lzma_48631a (struct lzmastate *p, char **old_ecx, uint32_t *old_edx, uint32_t *retval, char *src, uint32_t size)

+static uint32_t lzma_48631a (struct lzmastate *p, const char **old_ecx, uint32_t *old_edx, uint32_t *retval, char *src, uint32_t size)

 {

 	uint32_t copy1, copy2;

 	uint32_t loc_esi, loc_edi, ret;

-	char *loc_ebx;

+	const char *loc_ebx;

 	copy1 = *old_edx;

 	loc_edi = 0;

@@ -347,7 +347,7 @@ static uint32_t lzma_48631a (struct lzmastate *p, char **old_ecx, uint32_t *old_

 }

-int mew_lzma(char *orgsource, char *buf, uint32_t size_sum, uint32_t vma, uint32_t special)

+int mew_lzma(char *orgsource, const char *buf, uint32_t size_sum, uint32_t vma, uint32_t special)

 {

 	uint32_t var08, var0C, var10, var14, var20, var24, var28, var34;

 	struct lzmastate var40;

@@ -355,8 +355,12 @@ int mew_lzma(char *orgsource, char *buf, uint32_t size_sum, uint32_t vma, uint32

 	int i, mainloop;

 	char var1, var30;

-	char *source = buf, *dest, *new_ebx, *new_ecx, *var0C_ecxcopy, *var2C;

-	char *pushed_esi = NULL, *pushed_ebx = NULL;

+	const char *source = buf;

+	char *dest, *new_ebx;

+	const char *new_ecx, *var0C_ecxcopy;

+	const char *var2C;

+	char *pushed_esi = NULL;

+	const char *pushed_ebx = NULL;

 	uint32_t pushed_edx=0;

 	uint32_t loc_esi, loc_edi;

@@ -774,8 +778,10 @@ int unmew11(char *src, int off, int ssize, int dsize, uint32_t base, uint32_t va

 {

 	uint32_t entry_point, newedi, loc_ds=dsize, loc_ss=ssize;

 	char *source = src + dsize + off;

-	char *lesi = source + 12, *ledi;

-	char *f1, *f2;

+	const char *lesi = source + 12;

+	char *ledi;

+	const char *f1;

+	char *f2;

 	int i;

 	struct cli_exe_section *section = NULL;

 	uint32_t vma = base + vadd, size_sum = ssize + dsize;

@@ -28,11 +28,11 @@

 #include "cltypes.h"

 struct lzmastate {

-	char *p0;

+	const char *p0;

 	uint32_t p1, p2;

 };

-int mew_lzma(char *, char *, uint32_t, uint32_t, uint32_t);

+int mew_lzma(char *, const char *, uint32_t, uint32_t, uint32_t);

 uint32_t lzma_upack_esi_00(struct lzmastate *, char *, char *, uint32_t);

 uint32_t lzma_upack_esi_50(struct lzmastate *, uint32_t, uint32_t, char **, char *, uint32_t *, char *, uint32_t);

@@ -94,7 +94,7 @@ struct msexp_hdr {

 int cli_msexpand(cli_ctx *ctx, int ofd)

 {

-	struct msexp_hdr *hdr;

+	const struct msexp_hdr *hdr;

 	uint8_t i, mask, bits;

 	unsigned char buff[B_SIZE], wbuff[RW_SIZE];

 	const unsigned char *rbuff;

@@ -70,7 +70,7 @@ struct nsis_st {

   struct CLI_LZMA lz;

 /*   z_stream z; */

   nsis_z_stream z;

-  unsigned char *freeme;

+  const unsigned char *freeme;

   fmap_t *map;

   char ofn[1024];

 };

@@ -183,7 +183,7 @@ static int nsis_decomp(struct nsis_st *n) {

 }

 static int nsis_unpack_next(struct nsis_st *n, cli_ctx *ctx) {

-  unsigned char *ibuf;

+  const unsigned char *ibuf;

   uint32_t size, loops;

   int ret, gotsome=0;

   unsigned char obuf[BUFSIZ];

@@ -258,7 +258,7 @@ static int nsis_unpack_next(struct nsis_st *n, cli_ctx *ctx) {

       }

       n->nsis.avail_in = size;

-      n->nsis.next_in = ibuf;

+      n->nsis.next_in = (void*)ibuf;

       n->nsis.next_out = obuf;

       n->nsis.avail_out = BUFSIZ;

       loops=0;

@@ -325,7 +325,7 @@ static int nsis_unpack_next(struct nsis_st *n, cli_ctx *ctx) {

 	close(n->ofd);

 	return CL_EREAD;

       }

-      n->nsis.next_in = n->freeme;

+      n->nsis.next_in = (void*)n->freeme;

       n->nsis.avail_in = n->asz;

     }

@@ -276,7 +276,7 @@ static void print_ole2_header(ole2_header_t *hdr)

 static int ole2_read_block(ole2_header_t *hdr, void *buff, unsigned int size, int32_t blockno)

 {

 	off_t offset, offend;

-	void *pblock;

+	const void *pblock;

 	if (blockno < 0) {

 		return FALSE;

@@ -872,7 +872,7 @@ int cli_ole2_extract(const char *dirname, cli_ctx *ctx, struct uniq **vba)

 	int hdr_size, ret=CL_CLEAN;

 	unsigned int file_count=0;

 	unsigned long scansize, scansize2;

-	void *phdr;

+	const void *phdr;

 	cli_dbgmsg("in cli_ole2_extract()\n");

@@ -27,7 +27,7 @@

 #include "pe.h"

 #include "packlibs.h"

-static int doubledl(char **scur, uint8_t *mydlptr, char *buffer, uint32_t buffersize)

+static int doubledl(const char **scur, uint8_t *mydlptr, const char *buffer, uint32_t buffersize)

 {

   unsigned char mydl = *mydlptr;

   unsigned char olddl = mydl;

@@ -45,10 +45,11 @@ static int doubledl(char **scur, uint8_t *mydlptr, char *buffer, uint32_t buffer

 }

-int cli_unfsg(char *source, char *dest, int ssize, int dsize, char **endsrc, char **enddst) {

+int cli_unfsg(const char *source, char *dest, int ssize, int dsize, const char **endsrc, char **enddst) {

   uint8_t mydl=0x80;

   uint32_t backbytes, backsize, oldback = 0;

-  char *csrc = source, *cdst = dest;

+  const char *csrc = source;

+  char *cdst = dest;

   int oob, lostbit = 1;

   if (ssize<=0 || dsize<=0) return -1;

@@ -170,10 +171,11 @@ int cli_unfsg(char *source, char *dest, int ssize, int dsize, char **endsrc, cha

   return 0;

 }

-int unmew(char *source, char *dest, int ssize, int dsize, char **endsrc, char **enddst) {

+int unmew(const char *source, char *dest, int ssize, int dsize, const char **endsrc, char **enddst) {

   uint8_t mydl=0x80;

   uint32_t myeax_backbytes, myecx_backsize, oldback = 0;

-  char *csrc = source, *cdst = dest;

+  const char *csrc = source;

+  char *cdst = dest;

   int oob, lostbit = 1;

   *cdst++=*csrc++;

@@ -28,8 +28,8 @@

 #include "cltypes.h"

 #include "rebuildpe.h"

-int cli_unfsg(char *, char *, int, int, char **, char **);

+int cli_unfsg(const char *, char *, int, int, const char **, char **);

-int unmew(char *, char *, int, int, char **, char **);

+int unmew(const char *, char *, int, int, const char **, char **);

 #endif

@@ -325,7 +325,7 @@ static int cli_ddump(int desc, int offset, int size, const char *file) {

 void findres(uint32_t by_type, uint32_t by_name, uint32_t res_rva, fmap_t *map, struct cli_exe_section *exe_sections, uint16_t nsections, uint32_t hdr_size, int (*cb)(void *, uint32_t, uint32_t, uint32_t, uint32_t), void *opaque) {

     unsigned int err = 0;

     uint32_t type, type_offs, name, name_offs, lang, lang_offs;

-    uint8_t *resdir, *type_entry, *name_entry, *lang_entry ;

+    const uint8_t *resdir, *type_entry, *name_entry, *lang_entry ;

     uint16_t type_cnt, name_cnt, lang_cnt;

     if (!(resdir = fmap_need_off_once(map, cli_rawaddr(res_rva, exe_sections, nsections, &err, map->len, hdr_size), 16)) || err)

@@ -389,7 +389,7 @@ void findres(uint32_t by_type, uint32_t by_name, uint32_t res_rva, fmap_t *map,

 }

 static unsigned int cli_md5sect(fmap_t *map, struct cli_exe_section *s, unsigned char *digest) {

-    void *hashme;

+    const void *hashme;

     cli_md5_ctx md5;

     if (s->rsz > CLI_MAX_ALLOCATION) {

@@ -411,8 +411,8 @@ static unsigned int cli_md5sect(fmap_t *map, struct cli_exe_section *s, unsigned

 static void cli_parseres_special(uint32_t base, uint32_t rva, fmap_t *map, struct cli_exe_section *exe_sections, uint16_t nsections, size_t fsize, uint32_t hdr_size, unsigned int level, uint32_t type, unsigned int *maxres, struct swizz_stats *stats) {

     unsigned int err = 0, i;

-    uint8_t *resdir;

-    uint8_t *entry, *oentry;

+    const uint8_t *resdir;

+    const uint8_t *entry, *oentry;

     uint16_t named, unnamed;

     uint32_t rawaddr = cli_rawaddr(rva, exe_sections, nsections, &err, fsize, hdr_size);

     uint32_t entries;

@@ -481,7 +481,7 @@ static void cli_parseres_special(uint32_t base, uint32_t rva, fmap_t *map, struc

 			rawaddr = cli_rawaddr(base + offs, exe_sections, nsections, &err, fsize, hdr_size);

 			if (!err && (resdir = fmap_need_off_once(map, rawaddr, 16))) {

 				uint32_t isz = cli_readint32(resdir+4);

-				uint8_t *str;

+				const uint8_t *str;

 				rawaddr = cli_rawaddr(cli_readint32(resdir), exe_sections, nsections, &err, fsize, hdr_size);

 				if (err || !isz || isz >= fsize || rawaddr+isz >= fsize) {

 					cli_dbgmsg("cli_parseres_special: invalid resource table entry: %lu + %lu\n", 

@@ -519,8 +519,9 @@ int cli_scanpe(cli_ctx *ctx)

 	ssize_t bytes, at;

 	unsigned int i, found, upx_success = 0, min = 0, max = 0, err, overlays = 0;

 	unsigned int ssize = 0, dsize = 0, dll = 0, pe_plus = 0, corrupted_cur;

-	int (*upxfn)(char *, uint32_t, char *, uint32_t *, uint32_t, uint32_t, uint32_t) = NULL;

-	char *src = NULL, *dest = NULL;

+	int (*upxfn)(const char *, uint32_t, char *, uint32_t *, uint32_t, uint32_t, uint32_t) = NULL;

+	const char *src = NULL;

+	char *dest = NULL;

 	int ndesc, ret = CL_CLEAN, upack = 0, native=0;

 	size_t fsize;

 	uint32_t valign, falign, hdr_size, j;

@@ -1247,19 +1248,19 @@ int cli_scanpe(cli_ctx *ctx)

 	if(vsize >= 0x612c && rsize >= 0x612c && ((vsize & 0xff) == 0xec)) {

 		int bw = rsize < 0x7000 ? rsize : 0x7000;

-		char *tbuff;

+		const char *tbuff;

 	    if((tbuff = fmap_need_off_once(map, exe_sections[nsections - 1].raw + rsize - bw, 4096))) {

 		if(cli_memstr(tbuff, 4091, "\xe8\x2c\x61\x00\x00", 5)) {

 		    *ctx->virname = dam ? "Heuristics.W32.Magistr.A.dam" : "Heuristics.W32.Magistr.A";

 		    free(exe_sections);

 		    return CL_VIRUS;

-		} 

+		}

 	    }

 	} else if(rsize >= 0x7000 && vsize >= 0x7000 && ((vsize & 0xff) == 0xed)) {

 		int bw = rsize < 0x8000 ? rsize : 0x8000;

-		char *tbuff;

+		const char *tbuff;

 	    if((tbuff = fmap_need_off_once(map, exe_sections[nsections - 1].raw + rsize - bw, 4096))) {

 		if(cli_memstr(tbuff, 4091, "\xe8\x04\x72\x00\x00", 5)) {

@@ -1274,7 +1275,7 @@ int cli_scanpe(cli_ctx *ctx)

     /* W32.Polipos.A */

     while(polipos && !dll && nsections > 2 && nsections < 13 && e_lfanew <= 0x800 && (EC16(optional_hdr32.Subsystem) == 2 || EC16(optional_hdr32.Subsystem) == 3) && EC16(file_hdr.Machine) == 0x14c && optional_hdr32.SizeOfStackReserve >= 0x80000) {

 	uint32_t jump, jold, *jumps = NULL;

-	uint8_t *code;

+	const uint8_t *code;

 	unsigned int xsjs = 0;

 	if(exe_sections[0].rsz > CLI_MAX_ALLOCATION) break;

@@ -1367,10 +1368,11 @@ int cli_scanpe(cli_ctx *ctx)

     /* MEW support */

     if (found && (DCONF & PE_CONF_MEW) && epsize>=16 && epbuff[0]=='\xe9') {

 	uint32_t fileoffset;

-	char *tbuff;

+	const char *tbuff;

 	fileoffset = (vep + cli_readint32(epbuff + 1) + 5);

 	while (fileoffset == 0x154 || fileoffset == 0x158) {

+	    char *src;

 	    uint32_t offdiff, uselzma;

 	    cli_dbgmsg ("MEW: found MEW characteristics %08X + %08X + 5 = %08X\n", 

@@ -1543,7 +1545,8 @@ int cli_scanpe(cli_ctx *ctx)

     }

-    while(found && (DCONF & PE_CONF_FSG) && epbuff[0] == '\x87' && epbuff[1] == '\x25') {

+    while(found  && (DCONF & PE_CONF_FSG) && epbuff[0] == '\x87' && epbuff[1] == '\x25') {

+	const char *dst;

 	/* FSG v2.0 support - thanks to aCaB ! */

@@ -1572,28 +1575,28 @@ int cli_scanpe(cli_ctx *ctx)

 	    return CL_ESEEK;

 	}

-	dest = src + newedx - exe_sections[i + 1].rva;

-	if(newedx < exe_sections[i + 1].rva || !CLI_ISCONTAINED(src, ssize, dest, 4)) {

+	dst = src + newedx - exe_sections[i + 1].rva;

+	if(newedx < exe_sections[i + 1].rva || !CLI_ISCONTAINED(src, ssize, dst, 4)) {

 	    cli_dbgmsg("FSG: New ESP out of bounds\n");

 	    break;

 	}

-	newedx = cli_readint32(dest) - EC32(optional_hdr32.ImageBase);

+	newedx = cli_readint32(dst) - EC32(optional_hdr32.ImageBase);

 	if(!CLI_ISCONTAINED(exe_sections[i + 1].rva, exe_sections[i + 1].rsz, newedx, 4)) {

 	    cli_dbgmsg("FSG: New ESP (%x) is wrong\n", newedx);

 	    break;

 	}

-	dest = src + newedx - exe_sections[i + 1].rva;

-	if(!CLI_ISCONTAINED(src, ssize, dest, 32)) {

+	dst = src + newedx - exe_sections[i + 1].rva;

+	if(!CLI_ISCONTAINED(src, ssize, dst, 32)) {

 	    cli_dbgmsg("FSG: New stack out of bounds\n");

 	    break;

 	}

-	newedi = cli_readint32(dest) - EC32(optional_hdr32.ImageBase);

-	newesi = cli_readint32(dest + 4) - EC32(optional_hdr32.ImageBase);

-	newebx = cli_readint32(dest + 16) - EC32(optional_hdr32.ImageBase);

-	newedx = cli_readint32(dest + 20);

+	newedi = cli_readint32(dst) - EC32(optional_hdr32.ImageBase);

+	newesi = cli_readint32(dst + 4) - EC32(optional_hdr32.ImageBase);

+	newebx = cli_readint32(dst + 16) - EC32(optional_hdr32.ImageBase);

+	newedx = cli_readint32(dst + 20);

 	if(newedi != exe_sections[i].rva) {

 	    cli_dbgmsg("FSG: Bad destination buffer (edi is %x should be %x)\n", newedi, exe_sections[i].rva);

@@ -1615,7 +1618,6 @@ int cli_scanpe(cli_ctx *ctx)

 	if((dest = (char *) cli_calloc(dsize, sizeof(char))) == NULL) {

 	    free(exe_sections);

-	    free(src);

 	    return CL_EMEM;

 	}

@@ -1630,7 +1632,7 @@ int cli_scanpe(cli_ctx *ctx)

 	/* FSG support - v. 1.33 (thx trog for the many samples) */

 	int sectcnt = 0;

-	char *support;

+	const char *support;

 	uint32_t newesi, newedi, oldep, gp, t;

 	struct cli_exe_section *sections;

@@ -1733,7 +1735,7 @@ int cli_scanpe(cli_ctx *ctx)

 	int sectcnt = 0;

 	uint32_t gp, t = cli_rawaddr(cli_readint32(epbuff+1) - EC32(optional_hdr32.ImageBase), NULL, 0 , &err, fsize, hdr_size);

-	char *support;

+	const char *support;

 	uint32_t newesi = cli_readint32(epbuff+11) - EC32(optional_hdr32.ImageBase);

 	uint32_t newedi = cli_readint32(epbuff+6) - EC32(optional_hdr32.ImageBase);