@@ -361,7 +361,7 @@ int main(int argc, char **argv)

         if(logg_size)

-            logg("#Log file size limited to %u bytes.\n", logg_size);

+            logg("#Log file size limited to %lld bytes.\n", (long long int)logg_size);

         else

             logg("#Log file size limit disabled.\n");

@@ -699,7 +699,7 @@ static int handle_stream(client_conn_t *conn, struct fd_buf *buf, const struct o

 	    logg("!INSTREAM: Can't write to temporary file.\n");

 	    *error = 1;

 	}

-	logg("$Processed %lu bytes of chunkdata, pos %lu\n", cmdlen, pos);

+	logg("$Processed %llu bytes of chunkdata, pos %llu\n", (long long unsigned)cmdlen, (long long unsigned)pos);

 	pos += cmdlen;

 	if (pos == buf->off) {

 	    buf->off = 0;

@@ -133,7 +133,7 @@ struct metachain {

 struct clamscan_cb_data {

     struct metachain * chain;

-    char * filename;

+    const char * filename;

 };

 static cl_error_t pre(int fd, const char *type, void *context)

@@ -277,7 +277,7 @@ static cl_error_t meta(const char* container_type, unsigned long fsize_container

 static void clamscan_virus_found_cb(int fd, const char *virname, void *context)

 {

     struct clamscan_cb_data *data = (struct clamscan_cb_data *)context;

-    char * filename;

+    const char * filename;

     if (data == NULL)

         return;

@@ -389,9 +389,9 @@ static void scanfile(const char *filename, struct cl_engine *engine, const struc

                 char str[128];

                 int toolong = print_chain(&chain, str, sizeof(str));

-                logg("~%s%s!(%u)%s: %s FOUND\n", str, toolong ? "..." : "", chain.lastvir-1, chain.chains[chain.nchains-1], virname);

+                logg("~%s%s!(%llu)%s: %s FOUND\n", str, toolong ? "..." : "", (long long unsigned)(chain.lastvir-1), chain.chains[chain.nchains-1], virname);

             } else if (chain.lastvir) {

-                logg("~%s!(%u): %s FOUND\n", filename, chain.lastvir-1, virname);

+                logg("~%s!(%llu): %s FOUND\n", filename, (long long unsigned)(chain.lastvir-1), virname);

             }

         }

         if (!(options & CL_SCAN_ALLMATCHES))

@@ -2205,8 +2205,8 @@ updatecustomdb (const char *url, int *signo, const struct optstruct *opts,

     if (strlen (url) > sizeof (urlcpy) - 1)

     {

-        logg ("!DatabaseCustomURL: URL must be shorter than %lu\n",

-              sizeof (urlcpy));

+        logg ("!DatabaseCustomURL: URL must be shorter than %llu\n",

+              (long long unsigned)sizeof (urlcpy));

         return FCE_FAILEDUPDATE;

     }

@@ -87,7 +87,8 @@ int adc_decompress(adc_stream *strm)

         return ADC_DATA_ERROR;

     }

-    cli_dbgmsg("adc_decompress: avail_in %lu avail_out %lu state %u\n", strm->avail_in, strm->avail_out, strm->state);

+    cli_dbgmsg("adc_decompress: avail_in %llu avail_out %llu state %u\n",

+               (long long unsigned)strm->avail_in, (long long unsigned)strm->avail_out, strm->state);

     while (strm->avail_out) {

         /* Exit if needs more in bytes and none available */

@@ -1482,7 +1482,7 @@ int asn1_check_mscat(struct cl_engine *engine, fmap_t *map, size_t offset, unsig

     if (engine->dconf->pe & PE_CONF_DISABLECERT)

         return CL_VIRUS;

-    cli_dbgmsg("in asn1_check_mscat (offset: %lu)\n", offset);

+    cli_dbgmsg("in asn1_check_mscat (offset: %llu)\n", (long long unsigned)offset);

     crtmgr_init(&certs);

     if(crtmgr_add_roots(engine, &certs)) {

 	crtmgr_free(&certs);

@@ -330,9 +330,9 @@ static int cli_hashtab_grow(struct cli_hashtable *s)

 	struct cli_element* htable;

 	size_t i,idx, used = 0;

-	cli_dbgmsg("hashtab.c: new capacity: %lu\n",new_capacity);

+	cli_dbgmsg("hashtab.c: new capacity: %llu\n",(long long unsigned)new_capacity);

 	if(new_capacity == s->capacity) {

-		cli_errmsg("hashtab.c: capacity problem growing from: %lu\n",s->capacity);

+		cli_errmsg("hashtab.c: capacity problem growing from: %llu\n",(long long unsigned)s->capacity);

 		return CL_EMEM;

 	}

 	htable = cli_calloc(new_capacity, sizeof(*s->htable));

@@ -373,7 +373,7 @@ static int cli_hashtab_grow(struct cli_hashtable *s)

 	s->used = used;

 	s->capacity = new_capacity;

 	s->maxfill = new_capacity*8/10;

-	cli_dbgmsg("Table %p size after grow:%ld\n",(void*)s,s->capacity);

+	cli_dbgmsg("Table %p size after grow:%llu\n",(void*)s,(long long unsigned)s->capacity);

 	PROFILE_GROW_DONE(s);

 	return CL_SUCCESS;

 }

@@ -387,7 +387,7 @@ static int cli_htu32_grow(struct cli_htu32 *s, mpool_t *mempool)

 	const size_t new_capacity = nearest_power(s->capacity + 1);

 	struct cli_htu32_element* htable = mpool_calloc(mempool, new_capacity, sizeof(*s->htable));

 	size_t i,idx, used = 0;

-	cli_dbgmsg("hashtab.c: new capacity: %lu\n",new_capacity);

+	cli_dbgmsg("hashtab.c: new capacity: %llu\n",(long long unsigned)new_capacity);

 	if(new_capacity == s->capacity || !htable)

 		return CL_EMEM;

@@ -423,7 +423,7 @@ static int cli_htu32_grow(struct cli_htu32 *s, mpool_t *mempool)

 	s->used = used;

 	s->capacity = new_capacity;

 	s->maxfill = new_capacity*8/10;

-	cli_dbgmsg("Table %p size after grow:%ld\n",(void*)s,s->capacity);

+	cli_dbgmsg("Table %p size after grow:%llu\n",(void*)s,(long long unsigned)s->capacity);

 	PROFILE_GROW_DONE(s);

 	return CL_SUCCESS;

 }

@@ -438,7 +438,7 @@ const struct cli_element* cli_hashtab_insert(struct cli_hashtable *s, const char

 	if(!s)

 		return NULL;

 	if(s->used > s->maxfill) {

-		cli_dbgmsg("hashtab.c:Growing hashtable %p, because it has exceeded maxfill, old size:%ld\n",(void*)s,s->capacity);

+		cli_dbgmsg("hashtab.c:Growing hashtable %p, because it has exceeded maxfill, old size:%llu\n",(void*)s,(long long unsigned)s->capacity);

 		cli_hashtab_grow(s);

 	}

 	do {

@@ -487,7 +487,7 @@ const struct cli_element* cli_hashtab_insert(struct cli_hashtable *s, const char

 		} while (tries <= s->capacity);

 		/* no free place found*/

 		PROFILE_HASH_EXHAUSTED(s);

-		cli_dbgmsg("hashtab.c: Growing hashtable %p, because its full, old size:%ld.\n",(void*)s,s->capacity);

+		cli_dbgmsg("hashtab.c: Growing hashtable %p, because its full, old size:%llu.\n",(void*)s,(long long unsigned)s->capacity);

 	} while( cli_hashtab_grow(s) >= 0 );

 	cli_warnmsg("hashtab.c: Unable to grow hashtable\n");

 	return NULL;

@@ -505,7 +505,7 @@ int cli_htu32_insert(struct cli_htu32 *s, const struct cli_htu32_element *item,

 	if(!s)

 		return CL_ENULLARG;

 	if(s->used > s->maxfill) {

-		cli_dbgmsg("hashtab.c:Growing hashtable %p, because it has exceeded maxfill, old size:%ld\n",(void*)s,s->capacity);

+		cli_dbgmsg("hashtab.c:Growing hashtable %p, because it has exceeded maxfill, old size:%llu\n",(void*)s,(long long unsigned)s->capacity);

 		cli_htu32_grow(s, mempool);

 	}

 	do {

@@ -544,7 +544,7 @@ int cli_htu32_insert(struct cli_htu32 *s, const struct cli_htu32_element *item,

 		} while (tries <= s->capacity);

 		/* no free place found*/

 		PROFILE_HASH_EXHAUSTED(s);

-		cli_dbgmsg("hashtab.c: Growing hashtable %p, because its full, old size:%ld.\n",(void*)s,s->capacity);

+		cli_dbgmsg("hashtab.c: Growing hashtable %p, because its full, old size:%llu.\n",(void*)s,(long long unsigned)s->capacity);

 	} while( (ret = cli_htu32_grow(s, mempool)) >= 0 );

 	cli_warnmsg("hashtab.c: Unable to grow hashtable\n");

 	return ret;

@@ -633,11 +633,12 @@ int cli_hashtab_generate_c(const struct cli_hashtable *s,const char* name)

 		else if(e->key == DELETED_KEY)

 			printf("\t{DELETED_KEY,0,0},\n");

 		else

-			printf("\t{\"%s\", %ld, %ld},\n", e->key, e->data, e->len);

+			printf("\t{\"%s\", %ld, %llu},\n", e->key, e->data, (long long unsigned)e->len);

 	}

 	printf("};\n");

 	printf("const struct cli_hashtable %s = {\n",name);

-	printf("\t%s_elements, %ld, %ld, %ld", name, s->capacity, s->used, s->maxfill);

+	printf("\t%s_elements, %llu, %llu, %llu", name, (long long unsigned)s->capacity,

+	       (long long unsigned)s->used, (long long unsigned)s->maxfill);

 	printf("\n};\n");

 	PROFILE_REPORT(s);

@@ -179,7 +179,7 @@ void cli_pcre_perf_print()

     while (elem->run_count) {

         cli_infomsg (NULL, "%-*s %*lu %*lu %*llu %*.2f\n", max_name_len, elem->name,

                      8, elem->run_count, 8, elem->match_count,

-                     12, elem->usecs, 9, (double)elem->usecs/elem->run_count);

+                     12, (long long unsigned)elem->usecs, 9, (double)elem->usecs/elem->run_count);

         elem++;

     }

 }

@@ -192,7 +192,8 @@ static inline int matcher_run(const struct cli_matcher *root,

                 if (rc != CL_SUCCESS)

                     return rc;

                 if (maxfilesize && (map->len > maxfilesize)) {

-                    cli_dbgmsg("matcher_run: pcre max filesize (map) exceeded (limit: %llu, needed: %llu)\n", maxfilesize, (long long unsigned)map->len);

+                    cli_dbgmsg("matcher_run: pcre max filesize (map) exceeded (limit: %llu, needed: %llu)\n",

+                               (long long unsigned)maxfilesize, (long long unsigned)map->len);

                     return CL_EMAXSIZE;

                 }

@@ -212,7 +213,7 @@ static inline int matcher_run(const struct cli_matcher *root,

             if (rc != CL_SUCCESS)

                 return rc;

             if (maxfilesize && (length > maxfilesize)) {

-                cli_dbgmsg("matcher_run: pcre max filesize (buf) exceeded (limit: %llu, needed: %u)\n", maxfilesize, length);

+                cli_dbgmsg("matcher_run: pcre max filesize (buf) exceeded (limit: %llu, needed: %u)\n", (long long unsigned)maxfilesize, length);

                 return CL_EMAXSIZE;

             }

@@ -1205,8 +1206,9 @@ int cli_matchmeta(cli_ctx *ctx, const char *fname, size_t fsizec, size_t fsizer,

 	const struct cli_cdb *cdb;

 	unsigned int viruses_found = 0;

-    cli_dbgmsg("CDBNAME:%s:%lu:%s:%lu:%lu:%d:%u:%u:%p\n",

-	       cli_ftname(ctx->container_type), fsizec, fname, fsizec, fsizer, encrypted, filepos, res1, res2);

+    cli_dbgmsg("CDBNAME:%s:%llu:%s:%llu:%llu:%d:%u:%u:%p\n",

+	       cli_ftname(ctx->container_type), (long long unsigned)fsizec, fname, (long long unsigned)fsizec, (long long unsigned)fsizer,

+	       encrypted, filepos, res1, res2);

     if (ctx->engine && ctx->engine->cb_meta)

 	if (ctx->engine->cb_meta(cli_ftname(ctx->container_type), fsizec, fname, fsizer, encrypted, filepos, ctx->cb_ctx) == CL_VIRUS) {

@@ -2509,7 +2509,7 @@ parseMimeHeader(message *m, const char *cmd, const table_t *rfc821Table, const c

 				buf = cli_malloc(strlen(ptr) + 1);

 				if(buf == NULL) {

-                    cli_errmsg("parseMimeHeader: Unable to allocate memory for buf %lu\n", strlen(ptr) + 1);

+                    cli_errmsg("parseMimeHeader: Unable to allocate memory for buf %llu\n", (long long unsigned)(strlen(ptr) + 1));

 					if(copy)

 						free(copy);

 					return -1;

@@ -2618,7 +2618,7 @@ parseMimeHeader(message *m, const char *cmd, const table_t *rfc821Table, const c

 		case CONTENT_DISPOSITION:

 			buf = cli_malloc(strlen(ptr) + 1);

 			if(buf == NULL) {

-                cli_errmsg("parseMimeHeader: Unable to allocate memory for buf %lu\n", strlen(ptr) + 1);

+                cli_errmsg("parseMimeHeader: Unable to allocate memory for buf %llu\n", (long long unsigned)(strlen(ptr) + 1));

 				if(copy)

 					free(copy);

 				return -1;

@@ -2696,7 +2696,7 @@ rfc822comments(const char *in, char *out)

 	if(out == NULL) {

 		out = cli_malloc(strlen(in) + 1);

 		if(out == NULL) {

-            cli_errmsg("rfc822comments: Unable to allocate memory for out %lu\n", strlen(in) + 1);

+            cli_errmsg("rfc822comments: Unable to allocate memory for out %llu\n", (long long unsigned)(strlen(in) + 1));

 			return NULL;

         }

 	}

@@ -2764,7 +2764,7 @@ rfc2047(const char *in)

 	out = cli_malloc(strlen(in) + 1);

 	if(out == NULL) {

-        cli_errmsg("rfc2047: Unable to allocate memory for out %lu\n", strlen(in) + 1);

+        cli_errmsg("rfc2047: Unable to allocate memory for out %llu\n", (long long unsigned)(strlen(in) + 1));

 		return NULL;

     }

@@ -1467,7 +1467,7 @@ int lzx_decompress(struct lzx_stream *lzx, uint32_t out_bytes) {

     /* check that we've used all of the previous frame first */

     if (lzx->o_ptr != lzx->o_end) {

-      cli_dbgmsg("lzx_decompress: %ld avail bytes, new %d frame\n", lzx->o_end-lzx->o_ptr, frame_size);

+      cli_dbgmsg("lzx_decompress: %d avail bytes, new %d frame\n", lzx->o_end-lzx->o_ptr, frame_size);

       return lzx->error = CL_EFORMAT;

     }

@@ -778,7 +778,8 @@ struct cl_settings *cl_engine_settings_copy(const struct cl_engine *engine)

     settings = (struct cl_settings *) malloc(sizeof(struct cl_settings));

     if(!settings) {

-        cli_errmsg("cl_engine_settings_copy: Unable to allocate memory for settings %u\n", sizeof(struct cl_settings));

+        cli_errmsg("cl_engine_settings_copy: Unable to allocate memory for settings %llu\n",

+                   (long long unsigned)sizeof(struct cl_settings));

         return NULL;

     }

@@ -1216,7 +1217,7 @@ int cli_rmdirs(const char *dirname)

 		    if(strcmp(dent->d_name, ".") && strcmp(dent->d_name, "..")) {

 			path = cli_malloc(strlen(dirname) + strlen(dent->d_name) + 2);

 			if(!path) {

-                cli_errmsg("cli_rmdirs: Unable to allocate memory for path %lu\n", strlen(dirname) + strlen(dent->d_name) + 2);

+                cli_errmsg("cli_rmdirs: Unable to allocate memory for path %llu\n", (long long unsigned)(strlen(dirname) + strlen(dent->d_name) + 2));

 			    closedir(dd);

 			    return -1;

 			}

@@ -1288,7 +1289,7 @@ bitset_t *cli_bitset_init(void)

 	bs = cli_malloc(sizeof(bitset_t));

 	if (!bs) {

-        cli_errmsg("cli_bitset_init: Unable to allocate memory for bs %u\n", sizeof(bitset_t));

+        cli_errmsg("cli_bitset_init: Unable to allocate memory for bs %llu\n", (long long unsigned)sizeof(bitset_t));

 		return NULL;

 	}

 	bs->length = BITSET_DEFAULT_SIZE;

@@ -1052,14 +1052,15 @@ int pdf_extract_obj(struct pdf_struct *pdf, struct pdf_obj *obj, uint32_t flags)

                     cli_dbgmsg("cli_pdf: calculated length %ld\n", length);

                 } else {

                     if (size > (size_t)length+2) {

-                        cli_dbgmsg("cli_pdf: calculated length %ld < %ld\n",

-                               length, size);

+                        cli_dbgmsg("cli_pdf: calculated length %llu < %llu\n",

+                                   (long long unsigned)length, (long long unsigned)size);

                         length = size;

                     }

                 }

                 if (orig_length && size > (size_t)orig_length + 20) {

-                    cli_dbgmsg("cli_pdf: orig length: %ld, length: %ld, size: %ld\n", orig_length, length, size);

+                    cli_dbgmsg("cli_pdf: orig length: %ld, length: %ld, size: %llu\n", orig_length, length,

+                               (long long unsigned)size);

                     pdfobj_flag(pdf, obj, BAD_STREAMLEN);

                 }

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

         }

         if((sections = (struct cli_exe_section *) cli_malloc((sectcnt + 1) * sizeof(struct cli_exe_section))) == NULL) {

-            cli_errmsg("FSG: Unable to allocate memory for sections %lu\n", (sectcnt + 1) * sizeof(struct cli_exe_section));

+            cli_errmsg("FSG: Unable to allocate memory for sections %llu\n", (long long unsigned)((sectcnt + 1) * sizeof(struct cli_exe_section)));

             free(exe_sections);

             return CL_EMEM;

         }

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

             break;

         if((sections = (struct cli_exe_section *) cli_malloc((sectcnt + 1) * sizeof(struct cli_exe_section))) == NULL) {

-            cli_errmsg("FSG: Unable to allocate memory for sections %lu\n", (sectcnt + 1) * sizeof(struct cli_exe_section));

+            cli_errmsg("FSG: Unable to allocate memory for sections %llu\n", (long long unsigned)((sectcnt + 1) * sizeof(struct cli_exe_section)));

             free(exe_sections);

             return CL_EMEM;

         }

@@ -1051,7 +1051,7 @@ static int getmetrics(unsigned int side, unsigned int *imagedata, struct icomtr

 #ifdef USE_FLOATS

     sobel = cli_malloc(side * side * sizeof(double));

     if(!sobel) {

-        cli_errmsg("getmetrics: Unable to allocate memory for edge detection %lu\n", (side * side * sizeof(double)));

+        cli_errmsg("getmetrics: Unable to allocate memory for edge detection %llu\n", (long long unsigned)(side * side * sizeof(double)));

 	free(tmp);

 	return CL_EMEM;

     }

@@ -710,7 +710,7 @@ int cli_parsepng(cli_ctx *ctx)

             } else if (cur_y >= h) {

                 inflateEnd(&zstrm);

 		if(eod - p > 0) {

-		    cli_dbgmsg("PNG:  %li bytes remaining in buffer before inflateEnd()", eod-p);

+		    cli_dbgmsg("PNG:  %d bytes remaining in buffer before inflateEnd()", eod-p);

 		    return CL_EPARSE;

 		}

 		err = Z_STREAM_END;

@@ -85,7 +85,8 @@ static inline size_t get_char_at_pos_with_skip(const struct pre_fixup_info* info

 		return (pos <= strlen(buffer)) ? buffer[pos>0 ? pos-1:0] : '\0';

 	}

 	str = info->pre_displayLink.data;

-	cli_dbgmsg("calc_pos_with_skip: skip:%lu, %lu - %lu \"%s\",\"%s\"\n", pos, info->host_start, info->host_end, str, buffer);

+	cli_dbgmsg("calc_pos_with_skip: skip:%llu, %llu - %llu \"%s\",\"%s\"\n", (long long unsigned)pos, (long long unsigned)info->host_start,

+               (long long unsigned)info->host_end, str, buffer);

 	pos += info->host_start;

 	while(str[realpos] && !isalnum(str[realpos])) realpos++;

 	for(; str[realpos] && (pos>0); pos--) {

@@ -179,7 +179,7 @@ char *export_stats_to_json(struct cl_engine *engine, cli_intel_t *intel)

                 if (!(buf))

                     return NULL;

-                snprintf(buf+curused, bufsz-curused, "\t\t\t\t\t\"size\": %u\n", sample->sections->sections[i].len);

+                snprintf(buf+curused, bufsz-curused, "\t\t\t\t\t\"size\": %llu\n", (long long unsigned)sample->sections->sections[i].len);

                 curused += strlen(buf+curused);

                 buf = ensure_bufsize(buf, &bufsz, curused, 30);

@@ -18,8 +18,8 @@ const char *fp_ident(void)

 "TomsFastMath (%s)\n"

 "\n"

 "Sizeofs\n"

-"\tfp_digit = %lu\n"

-"\tfp_word  = %lu\n"

+"\tfp_digit = %llu\n"

+"\tfp_word  = %llu\n"

 "\n"

 "FP_MAX_SIZE = %u\n"

 "\n"

@@ -70,7 +70,7 @@ const char *fp_ident(void)

 #ifdef TFM_HUGE

 " TFM_HUGE "

 #endif

-"\n", __DATE__, sizeof(fp_digit), sizeof(fp_word), FP_MAX_SIZE);

+            "\n", __DATE__, (long long unsigned)sizeof(fp_digit), (long long unsigned)sizeof(fp_word), FP_MAX_SIZE);

    if (sizeof(fp_digit) == sizeof(fp_word)) {

       strncat(buf, "WARNING: sizeof(fp_digit) == sizeof(fp_word), this build is likely to not work properly.\n", 

@@ -715,7 +715,8 @@ int cli_scanxar(cli_ctx *ctx)

                     if (avail_out == 0)

                         cli_dbgmsg("cli_scanxar: cli_LzmaDecode() produces no output for "

-                                   "avail_in %lu, avail_out %lu.\n", avail_in, avail_out);

+                                   "avail_in %llu, avail_out %llu.\n",

+                                   (long long unsigned)avail_in, (long long unsigned)avail_out);

                     if (a_hash_ctx != NULL)

                         xar_hash_update(a_hash_ctx, next_in, in_consumed, a_hash);                    

@@ -728,8 +729,8 @@ int cli_scanxar(cli_ctx *ctx)

                     /*            avail_out, in_consumed, avail_in); */

                     if (cli_writen(fd, buff, avail_out) < 0) {

-                        cli_dbgmsg("cli_scanxar: cli_writen error writing lzma temp file for %li bytes.\n",

-                                   avail_out);

+                        cli_dbgmsg("cli_scanxar: cli_writen error writing lzma temp file for %llu bytes.\n",

+                                   (long long unsigned)avail_out);

                         __lzma_wrap_free(NULL, buff);

                         cli_LzmaShutdown(&lz);

                         rc = CL_EWRITE;

@@ -37,7 +37,7 @@ void *rar_malloc(size_t size)

     alloc = malloc(size);

     if(!alloc) {

-	fprintf(stderr, "UNRAR: rar_malloc(): Can't allocate memory (%lu bytes).\n", size);

+	fprintf(stderr, "UNRAR: rar_malloc(): Can't allocate memory (%llu bytes).\n", (long long unsigned)size);

 	return NULL;

     } else return alloc;

 }

@@ -55,7 +55,7 @@ void *rar_realloc2(void *ptr, size_t size)

     alloc = realloc(ptr, size);

     if(!alloc) {

-	fprintf(stderr, "UNRAR: rar_realloc2(): Can't allocate memory (%lu bytes).\n", size);

+	fprintf(stderr, "UNRAR: rar_realloc2(): Can't allocate memory (%llu bytes).\n", (long long unsigned)size);

 	if(ptr)

 	    free(ptr);

 	return NULL;

@@ -215,7 +215,7 @@ static int rename_logg(STATBUF *sb)

     if (!logg_rotate) {

         if (logg_fp) {

-            fprintf(logg_fp, "Log size = %zu, max = %zu\n", sb->st_size, logg_size);

+            fprintf(logg_fp, "Log size = %lld, max = %lld\n", (long long int)sb->st_size, (long long int)logg_size);

             fprintf(logg_fp, "WARNING: Log size limit met but log file rotation turned off. Forcing log file rotation anyways.\n");

         }