@@ -116,6 +116,7 @@ CLAMAV_PRIVATE {

     cli_memstr;

     cli_strdup;

     cli_strndup;

+    cli_strnstr;

     cli_realloc;

     cli_ctime;

     tableCreate;

@@ -257,6 +258,7 @@ CLAMAV_PRIVATE {

     cl_get_pkey_file;

     cl_base64_decode;

     cl_base64_encode;

+    cli_sanitize_filepath;

   local:

     *;

 };

@@ -751,6 +751,15 @@ int cli_writen(int fd, const void *buff, unsigned int count);

 const char *cli_gettmpdir(void);

 /**

+ * @brief Sanitize a relative path, so it cannot have a negative depth.

+ *

+ * Caller is responsible for freeing the filename.

+ *

+ * @return char* filename or NULL.

+ */

+char *cli_sanitize_filepath(const char *filepath, size_t filepath_len);

+

+/**

  * @brief Generate tempfile filename (no path) with a random MD5 hash.

  *

  * Caller is responsible for freeing the filename.

@@ -29,49 +29,50 @@

 #include <string.h>

 #include <stdlib.h>

 #include <ctype.h>

-#ifdef	HAVE_UNISTD_H

+#ifdef HAVE_UNISTD_H

 #include <unistd.h>

 #endif

 #include <sys/types.h>

 #include <sys/stat.h>

 #include <dirent.h>

-#ifndef	_WIN32

+#ifndef _WIN32

 #include <sys/wait.h>

 #include <sys/time.h>

 #endif

 #include <time.h>

 #include <fcntl.h>

-#ifdef	HAVE_PWD_H

+#ifdef HAVE_PWD_H

 #include <pwd.h>

 #endif

 #include <errno.h>

 #include "target.h"

-#ifdef	HAVE_SYS_PARAM_H

+#ifdef HAVE_SYS_PARAM_H

 #include <sys/param.h>

 #endif

-#ifdef	HAVE_MALLOC_H

+#ifdef HAVE_MALLOC_H

 #include <malloc.h>

 #endif

 #include "clamav.h"

 #include "others.h"

+#include "platform.h"

 #include "regex/regex.h"

 #include "ltdl.h"

 #include "matcher-ac.h"

-static unsigned char name_salt[16] = { 16, 38, 97, 12, 8, 4, 72, 196, 217, 144, 33, 124, 18, 11, 17, 253 };

+static unsigned char name_salt[16] = {16, 38, 97, 12, 8, 4, 72, 196, 217, 144, 33, 124, 18, 11, 17, 253};

 #ifdef CL_NOTHREADS

 #undef CL_THREAD_SAFE

 #endif

 #ifdef CL_THREAD_SAFE

-#  include <pthread.h>

+#include <pthread.h>

 static pthread_mutex_t cli_gentemp_mutex = PTHREAD_MUTEX_INITIALIZER;

-# ifndef HAVE_CTIME_R

+#ifndef HAVE_CTIME_R

 static pthread_mutex_t cli_ctime_mutex = PTHREAD_MUTEX_INITIALIZER;

-# endif

+#endif

 static pthread_mutex_t cli_strerror_mutex = PTHREAD_MUTEX_INITIALIZER;

 static pthread_key_t cli_ctx_tls_key;

 static pthread_once_t cli_ctx_tls_key_once = PTHREAD_ONCE_INIT;

@@ -81,7 +82,7 @@ static void cli_ctx_tls_key_alloc(void)

     pthread_key_create(&cli_ctx_tls_key, NULL);

 }

-void cli_logg_setup(const cli_ctx *ctx)

+void cli_logg_setup(const cli_ctx* ctx)

 {

     pthread_once(&cli_ctx_tls_key_once, cli_ctx_tls_key_alloc);

     pthread_setspecific(cli_ctx_tls_key, ctx);

@@ -92,22 +93,22 @@ void cli_logg_unsetup(void)

     pthread_setspecific(cli_ctx_tls_key, NULL);

 }

-static inline void *cli_getctx(void)

+static inline void* cli_getctx(void)

 {

-    cli_ctx *ctx;

+    cli_ctx* ctx;

     pthread_once(&cli_ctx_tls_key_once, cli_ctx_tls_key_alloc);

     ctx = pthread_getspecific(cli_ctx_tls_key);

     return ctx ? ctx->cb_ctx : NULL;

 }

 #else

-static const cli_ctx *current_ctx = NULL;

-void cli_logg_setup(const cli_ctx *ctx)

+static const cli_ctx* current_ctx = NULL;

+void cli_logg_setup(const cli_ctx* ctx)

 {

     current_ctx = ctx;

 }

-static inline void *cli_getctx(void)

+static inline void* cli_getctx(void)

 {

     return current_ctx ? current_ctx->cb_ctx : NULL;

 }

@@ -117,10 +118,10 @@ void cli_logg_unsetup(void)

 }

 #endif

-uint8_t cli_debug_flag = 0;

+uint8_t cli_debug_flag              = 0;

 uint8_t cli_always_gen_section_hash = 0;

-static void fputs_callback(enum cl_msg severity, const char *fullmsg, const char *msg, void *context)

+static void fputs_callback(enum cl_msg severity, const char* fullmsg, const char* msg, void* context)

 {

     UNUSEDPARAM(severity);

     UNUSEDPARAM(msg);

@@ -135,138 +136,136 @@ void cl_set_clcb_msg(clcb_msg callback)

     msg_callback = callback;

 }

-#define MSGCODE(buff, len, x)				    \

-	va_list args;					    \

-	size_t len = sizeof(x) - 1;			    \

-	char buff[BUFSIZ];				    \

-    strncpy(buff, x, len);				    \

-    va_start(args, str);				    \

-    vsnprintf(buff + len, sizeof(buff) - len, str, args);   \

-    buff[sizeof(buff) - 1] = '\0';			    \

+#define MSGCODE(buff, len, x)                             \

+    va_list args;                                         \

+    size_t len = sizeof(x) - 1;                           \

+    char buff[BUFSIZ];                                    \

+    strncpy(buff, x, len);                                \

+    va_start(args, str);                                  \

+    vsnprintf(buff + len, sizeof(buff) - len, str, args); \

+    buff[sizeof(buff) - 1] = '\0';                        \

     va_end(args)

-void cli_warnmsg(const char *str, ...)

+void cli_warnmsg(const char* str, ...)

 {

     MSGCODE(buff, len, "LibClamAV Warning: ");

-    msg_callback(CL_MSG_WARN, buff, buff+len, cli_getctx());

+    msg_callback(CL_MSG_WARN, buff, buff + len, cli_getctx());

 }

-void cli_errmsg(const char *str, ...)

+void cli_errmsg(const char* str, ...)

 {

     MSGCODE(buff, len, "LibClamAV Error: ");

-    msg_callback(CL_MSG_ERROR, buff, buff+len, cli_getctx());

+    msg_callback(CL_MSG_ERROR, buff, buff + len, cli_getctx());

 }

-void cli_infomsg(const cli_ctx* ctx, const char *str, ...)

+void cli_infomsg(const cli_ctx* ctx, const char* str, ...)

 {

     MSGCODE(buff, len, "LibClamAV info: ");

-    msg_callback(CL_MSG_INFO_VERBOSE, buff, buff+len, ctx ? ctx->cb_ctx : NULL);

+    msg_callback(CL_MSG_INFO_VERBOSE, buff, buff + len, ctx ? ctx->cb_ctx : NULL);

 }

-void cli_dbgmsg_internal(const char *str, ...)

+void cli_dbgmsg_internal(const char* str, ...)

 {

     MSGCODE(buff, len, "LibClamAV debug: ");

     fputs(buff, stderr);

 }

-int cli_matchregex(const char *str, const char *regex)

+int cli_matchregex(const char* str, const char* regex)

 {

-	regex_t reg;

-	int match, flags = REG_EXTENDED | REG_NOSUB;

+    regex_t reg;

+    int match, flags = REG_EXTENDED | REG_NOSUB;

 #ifdef _WIN32

     flags |= REG_ICASE;

 #endif

     if(cli_regcomp(&reg, regex, flags) == 0) {

-	match = (cli_regexec(&reg, str, 0, NULL, 0) == REG_NOMATCH) ? 0 : 1;

-	cli_regfree(&reg);

-	return match;

+        match = (cli_regexec(&reg, str, 0, NULL, 0) == REG_NOMATCH) ? 0 : 1;

+        cli_regfree(&reg);

+        return match;

     }

     return 0;

 }

-void *cli_malloc(size_t size)

+void* cli_malloc(size_t size)

 {

-	void *alloc;

-

+    void* alloc;

     if(!size || size > CLI_MAX_ALLOCATION) {

-	cli_errmsg("cli_malloc(): Attempt to allocate %lu bytes. Please report to https://bugzilla.clamav.net\n", (unsigned long int) size);

-	return NULL;

+        cli_errmsg("cli_malloc(): Attempt to allocate %lu bytes. Please report to https://bugzilla.clamav.net\n", (unsigned long int)size);

+        return NULL;

     }

     alloc = malloc(size);

     if(!alloc) {

-	perror("malloc_problem");

-	cli_errmsg("cli_malloc(): Can't allocate memory (%lu bytes).\n", (unsigned long int) size);

-	return NULL;

-    } else return alloc;

+        perror("malloc_problem");

+        cli_errmsg("cli_malloc(): Can't allocate memory (%lu bytes).\n", (unsigned long int)size);

+        return NULL;

+    } else

+        return alloc;

 }

-void *cli_calloc(size_t nmemb, size_t size)

+void* cli_calloc(size_t nmemb, size_t size)

 {

-	void *alloc;

-

+    void* alloc;

-    if(!nmemb || !size || size > CLI_MAX_ALLOCATION || nmemb > CLI_MAX_ALLOCATION

-        || (nmemb*size > CLI_MAX_ALLOCATION)) {

-	cli_errmsg("cli_calloc(): Attempt to allocate %lu bytes. Please report to https://bugzilla.clamav.net\n", (unsigned long int) nmemb*size);

-	return NULL;

+    if(!nmemb || !size || size > CLI_MAX_ALLOCATION || nmemb > CLI_MAX_ALLOCATION || (nmemb * size > CLI_MAX_ALLOCATION)) {

+        cli_errmsg("cli_calloc(): Attempt to allocate %lu bytes. Please report to https://bugzilla.clamav.net\n", (unsigned long int)nmemb * size);

+        return NULL;

     }

     alloc = calloc(nmemb, size);

     if(!alloc) {

-	perror("calloc_problem");

-	cli_errmsg("cli_calloc(): Can't allocate memory (%lu bytes).\n", (unsigned long int) (nmemb * size));

-	return NULL;

-    } else return alloc;

+        perror("calloc_problem");

+        cli_errmsg("cli_calloc(): Can't allocate memory (%lu bytes).\n", (unsigned long int)(nmemb * size));

+        return NULL;

+    } else

+        return alloc;

 }

-void *cli_realloc(void *ptr, size_t size)

+void* cli_realloc(void* ptr, size_t size)

 {

-	void *alloc;

-

+    void* alloc;

     if(!size || size > CLI_MAX_ALLOCATION) {

-	cli_errmsg("cli_realloc(): Attempt to allocate %lu bytes. Please report to https://bugzilla.clamav.net\n", (unsigned long int) size);

-	return NULL;

+        cli_errmsg("cli_realloc(): Attempt to allocate %lu bytes. Please report to https://bugzilla.clamav.net\n", (unsigned long int)size);

+        return NULL;

     }

     alloc = realloc(ptr, size);

     if(!alloc) {

-	perror("realloc_problem");

-	cli_errmsg("cli_realloc(): Can't re-allocate memory to %lu bytes.\n", (unsigned long int) size);

-	return NULL;

-    } else return alloc;

+        perror("realloc_problem");

+        cli_errmsg("cli_realloc(): Can't re-allocate memory to %lu bytes.\n", (unsigned long int)size);

+        return NULL;

+    } else

+        return alloc;

 }

-void *cli_realloc2(void *ptr, size_t size)

+void* cli_realloc2(void* ptr, size_t size)

 {

-	void *alloc;

-

+    void* alloc;

     if(!size || size > CLI_MAX_ALLOCATION) {

-	cli_errmsg("cli_realloc2(): Attempt to allocate %lu bytes. Please report to https://bugzilla.clamav.net\n", (unsigned long int) size);

-	return NULL;

+        cli_errmsg("cli_realloc2(): Attempt to allocate %lu bytes. Please report to https://bugzilla.clamav.net\n", (unsigned long int)size);

+        return NULL;

     }

     alloc = realloc(ptr, size);

     if(!alloc) {

-	perror("realloc_problem");

-	cli_errmsg("cli_realloc2(): Can't re-allocate memory to %lu bytes.\n", (unsigned long int) size);

-	if(ptr)

-	    free(ptr);

-	return NULL;

-    } else return alloc;

+        perror("realloc_problem");

+        cli_errmsg("cli_realloc2(): Can't re-allocate memory to %lu bytes.\n", (unsigned long int)size);

+        if(ptr)

+            free(ptr);

+        return NULL;

+    } else

+        return alloc;

 }

-char *cli_strdup(const char *s)

+char* cli_strdup(const char* s)

 {

-        char *alloc;

-

+    char* alloc;

     if(s == NULL) {

         cli_errmsg("cli_strdup(): s == NULL. Please report to https://bugzilla.clamav.net\n");

@@ -277,7 +276,7 @@ char *cli_strdup(const char *s)

     if(!alloc) {

         perror("strdup_problem");

-        cli_errmsg("cli_strdup(): Can't allocate memory (%u bytes).\n", (unsigned int) strlen(s));

+        cli_errmsg("cli_strdup(): Can't allocate memory (%u bytes).\n", (unsigned int)strlen(s));

         return NULL;

     }

@@ -285,142 +284,137 @@ char *cli_strdup(const char *s)

 }

 /* returns converted timestamp, in case of error the returned string contains at least one character */

-const char* cli_ctime(const time_t *timep, char *buf, const size_t bufsize)

+const char* cli_ctime(const time_t* timep, char* buf, const size_t bufsize)

 {

-	const char *ret;

-	if(bufsize < 26) {

-		/* standard says we must have at least 26 bytes buffer */

-		cli_warnmsg("buffer too small for ctime\n");

-		return " ";

-	}

-	if((uint32_t)(*timep) > 0x7fffffff) {

-		/* some systems can consider these timestamps invalid */

-		strncpy(buf, "invalid timestamp", bufsize-1);

-		buf[bufsize-1] = '\0';

-		return buf;

-	}

-

-#ifdef HAVE_CTIME_R	

-# ifdef HAVE_CTIME_R_2

-	ret = ctime_r(timep, buf);

-# else

-	ret = ctime_r(timep, buf, bufsize);

-# endif

+    const char* ret;

+    if(bufsize < 26) {

+        /* standard says we must have at least 26 bytes buffer */

+        cli_warnmsg("buffer too small for ctime\n");

+        return " ";

+    }

+    if((uint32_t)(*timep) > 0x7fffffff) {

+        /* some systems can consider these timestamps invalid */

+        strncpy(buf, "invalid timestamp", bufsize - 1);

+        buf[bufsize - 1] = '\0';

+        return buf;

+    }

+

+#ifdef HAVE_CTIME_R

+#ifdef HAVE_CTIME_R_2

+    ret = ctime_r(timep, buf);

+#else

+    ret = ctime_r(timep, buf, bufsize);

+#endif

 #else /* no ctime_r */

-# ifdef CL_THREAD_SAFE

-	pthread_mutex_lock(&cli_ctime_mutex);

-# endif

-	ret = ctime(timep);

-	if(ret) {

-		strncpy(buf, ret, bufsize-1);

-		buf[bufsize-1] = '\0';

-		ret = buf;

-	}

-# ifdef CL_THREAD_SAFE

-	pthread_mutex_unlock(&cli_ctime_mutex);

-# endif

+#ifdef CL_THREAD_SAFE

+    pthread_mutex_lock(&cli_ctime_mutex);

+#endif

+    ret = ctime(timep);

+    if(ret) {

+        strncpy(buf, ret, bufsize - 1);

+        buf[bufsize - 1] = '\0';

+        ret              = buf;

+    }

+#ifdef CL_THREAD_SAFE

+    pthread_mutex_unlock(&cli_ctime_mutex);

 #endif

-	/* common */

-	if(!ret) {

-		buf[0] = ' ';

-		buf[1] = '\0';

-		return buf;

-	}

-	return ret;

+#endif

+    /* common */

+    if(!ret) {

+        buf[0] = ' ';

+        buf[1] = '\0';

+        return buf;

+    }

+    return ret;

 }

 /* Function: readn

         Try hard to read the requested number of bytes

 */

-int cli_readn(int fd, void *buff, unsigned int count)

+int cli_readn(int fd, void* buff, unsigned int count)

 {

-        int retval;

-        unsigned int todo;

-        unsigned char *current;

-

+    int retval;

+    unsigned int todo;

+    unsigned char* current;

-        todo = count;

-        current = (unsigned char *) buff;

-

-        do {

-                retval = read(fd, current, todo);

-                if (retval == 0) {

-                        return (count - todo);

-                }

-                if (retval < 0) {

-			char err[128];

-			if (errno == EINTR) {

-				continue;

-			}

-			cli_errmsg("cli_readn: read error: %s\n", cli_strerror(errno, err, sizeof(err)));

-                        return -1;

-                }

-                todo -= retval;

-                current += retval;

-        } while (todo > 0);

+    todo    = count;

+    current = (unsigned char*)buff;

+    do {

+        retval = read(fd, current, todo);

+        if(retval == 0) {

+            return (count - todo);

+        }

+        if(retval < 0) {

+            char err[128];

+            if(errno == EINTR) {

+                continue;

+            }

+            cli_errmsg("cli_readn: read error: %s\n", cli_strerror(errno, err, sizeof(err)));

+            return -1;

+        }

+        todo -= retval;

+        current += retval;

+    } while(todo > 0);

-        return count;

+    return count;

 }

 /* Function: writen

         Try hard to write the specified number of bytes

 */

-int cli_writen(int fd, const void *buff, unsigned int count)

+int cli_writen(int fd, const void* buff, unsigned int count)

 {

-        int retval;

-        unsigned int todo;

-        const unsigned char *current;

-

-

-        todo = count;

-        current = (const unsigned char *) buff;

-

-        do {

-                retval = write(fd, current, todo);

-                if (retval < 0) {

-			char err[128];

-			if (errno == EINTR) {

-				continue;

-			}

-			cli_errmsg("cli_writen: write error: %s\n", cli_strerror(errno, err, sizeof(err)));

-                        return -1;

-                }

-                todo -= retval;

-                current += retval;

-        } while (todo > 0);

-

+    int retval;

+    unsigned int todo;

+    const unsigned char* current;

+

+    todo    = count;

+    current = (const unsigned char*)buff;

+

+    do {

+        retval = write(fd, current, todo);

+        if(retval < 0) {

+            char err[128];

+            if(errno == EINTR) {

+                continue;

+            }

+            cli_errmsg("cli_writen: write error: %s\n", cli_strerror(errno, err, sizeof(err)));

+            return -1;

+        }

+        todo -= retval;

+        current += retval;

+    } while(todo > 0);

-        return count;

+    return count;

 }

-int cli_filecopy(const char *src, const char *dest)

+int cli_filecopy(const char* src, const char* dest)

 {

 #ifdef _WIN32

     return CopyFileA(src, dest, 0) ? 0 : -1;

 #else

-	char *buffer;

-	int s, d, bytes;

+    char* buffer;

+    int s, d, bytes;

+    if((s = open(src, O_RDONLY | O_BINARY)) == -1)

+        return -1;

-    if((s = open(src, O_RDONLY|O_BINARY)) == -1)

-	return -1;

-

-    if((d = open(dest, O_CREAT|O_WRONLY|O_TRUNC|O_BINARY, S_IRWXU)) == -1) {

-	close(s);

-	return -1;

+    if((d = open(dest, O_CREAT | O_WRONLY | O_TRUNC | O_BINARY, S_IRWXU)) == -1) {

+        close(s);

+        return -1;

     }

     if(!(buffer = cli_malloc(FILEBUFF))) {

-	close(s);

-	close(d);

-	return -1;

+        close(s);

+        close(d);

+        return -1;

     }

     while((bytes = cli_readn(s, buffer, FILEBUFF)) > 0)

-	cli_writen(d, buffer, bytes);

+        cli_writen(d, buffer, bytes);

     free(buffer);

     close(s);

@@ -437,39 +431,40 @@ int cli_filecopy(const char *src, const char *dest)

 #endif /* _WIN32 */

 #endif /* P_tmpdir */

-const char *cli_gettmpdir(void) {

-	const char *tmpdir;

+const char* cli_gettmpdir(void)

+{

+    const char* tmpdir;

     unsigned int i;

 #ifdef _WIN32

-    char *envs[] = { "TEMP", "TMP", NULL };

+    char* envs[] = {"TEMP", "TMP", NULL};

 #else

-    char *envs[] = { "TMPDIR", NULL };

+    char* envs[] = {"TMPDIR", NULL};

 #endif

-    for (i=0; envs[i] != NULL; i++)

-        if ((tmpdir = getenv(envs[i])))

+    for(i = 0; envs[i] != NULL; i++)

+        if((tmpdir = getenv(envs[i])))

             return tmpdir;

     return P_tmpdir;

 }

 struct dirent_data {

-    char *filename;

-    const char *dirname;

-    STATBUF *statbuf;

-    long  ino; /* -1: inode not available */

-    int   is_dir;/* 0 - no, 1 - yes */

+    char* filename;

+    const char* dirname;

+    STATBUF* statbuf;

+    long ino;   /* -1: inode not available */

+    int is_dir; /* 0 - no, 1 - yes */

 };

 /* sort files before directories, and lower inodes before higher inodes */

-static int ftw_compare(const void *a, const void *b)

+static int ftw_compare(const void* a, const void* b)

 {

-    const struct dirent_data *da = a;

-    const struct dirent_data *db = b;

-    long diff = da->is_dir - db->is_dir;

-    if (!diff) {

-	diff = da->ino - db->ino;

+    const struct dirent_data* da = a;

+    const struct dirent_data* db = b;

+    long diff                    = da->is_dir - db->is_dir;

+    if(!diff) {

+        diff = da->ino - db->ino;

     }

     return diff;

 }

@@ -489,100 +484,98 @@ static inline int ft_skipped(enum filetype ft)

 }

 #define FOLLOW_SYMLINK_MASK (CLI_FTW_FOLLOW_FILE_SYMLINK | CLI_FTW_FOLLOW_DIR_SYMLINK)

-static int get_filetype(const char *fname, int flags, int need_stat,

-			 STATBUF *statbuf, enum filetype *ft)

+static int get_filetype(const char* fname, int flags, int need_stat,

+                        STATBUF* statbuf, enum filetype* ft)

 {

     int stated = 0;

-    if (*ft == ft_unknown || *ft == ft_link) {

-	need_stat = 1;

+    if(*ft == ft_unknown || *ft == ft_link) {

+        need_stat = 1;

-	if ((flags & FOLLOW_SYMLINK_MASK) != FOLLOW_SYMLINK_MASK) {

-	    /* Following only one of directory/file symlinks, or none, may

+        if((flags & FOLLOW_SYMLINK_MASK) != FOLLOW_SYMLINK_MASK) {

+            /* Following only one of directory/file symlinks, or none, may

 	     * need to lstat.

 	     * If we're following both file and directory symlinks, we don't need

 	     * to lstat(), we can just stat() directly.*/

-	    if (*ft != ft_link) {

-		/* need to lstat to determine if it is a symlink */

-		if (LSTAT(fname, statbuf) == -1)

-		    return -1;

-		if (S_ISLNK(statbuf->st_mode)) {

-		    *ft = ft_link;

-		} else {

-		    /* It was not a symlink, stat() not needed */

-		    need_stat = 0;

-		    stated = 1;

-		}

-	    }

-	    if (*ft == ft_link && !(flags & FOLLOW_SYMLINK_MASK)) {

-		/* This is a symlink, but we don't follow any symlinks */

-		*ft = ft_skipped_link;

-		return 0;

-	    }

-	}

+            if(*ft != ft_link) {

+                /* need to lstat to determine if it is a symlink */

+                if(LSTAT(fname, statbuf) == -1)

+                    return -1;

+                if(S_ISLNK(statbuf->st_mode)) {

+                    *ft = ft_link;

+                } else {

+                    /* It was not a symlink, stat() not needed */

+                    need_stat = 0;

+                    stated    = 1;

+                }

+            }

+            if(*ft == ft_link && !(flags & FOLLOW_SYMLINK_MASK)) {

+                /* This is a symlink, but we don't follow any symlinks */

+                *ft = ft_skipped_link;

+                return 0;

+            }

+        }

     }

-    if (need_stat) {

-	if (CLAMSTAT(fname, statbuf) == -1)

-	    return -1;

-	stated = 1;

+    if(need_stat) {

+        if(CLAMSTAT(fname, statbuf) == -1)

+            return -1;

+        stated = 1;

     }

-    if (*ft == ft_unknown || *ft == ft_link) {

-	if (S_ISDIR(statbuf->st_mode) &&

-	    (*ft != ft_link || (flags & CLI_FTW_FOLLOW_DIR_SYMLINK))) {

-	    /* A directory, or (a symlink to a directory and we're following dir

+    if(*ft == ft_unknown || *ft == ft_link) {

+        if(S_ISDIR(statbuf->st_mode) &&

+           (*ft != ft_link || (flags & CLI_FTW_FOLLOW_DIR_SYMLINK))) {

+            /* A directory, or (a symlink to a directory and we're following dir

 	     * symlinks) */

-	    *ft = ft_directory;

-	} else if (S_ISREG(statbuf->st_mode) &&

-		   (*ft != ft_link || (flags & CLI_FTW_FOLLOW_FILE_SYMLINK))) {

-	    /* A file, or (a symlink to a file and we're following file symlinks) */

-	    *ft = ft_regular;

-	} else {

-	    /* default: skipped */

-	    *ft = S_ISLNK(statbuf->st_mode) ?

-		ft_skipped_link : ft_skipped_special;

-	}

+            *ft = ft_directory;

+        } else if(S_ISREG(statbuf->st_mode) &&

+                  (*ft != ft_link || (flags & CLI_FTW_FOLLOW_FILE_SYMLINK))) {

+            /* A file, or (a symlink to a file and we're following file symlinks) */

+            *ft = ft_regular;

+        } else {

+            /* default: skipped */

+            *ft = S_ISLNK(statbuf->st_mode) ? ft_skipped_link : ft_skipped_special;

+        }

     }

     return stated;

 }

-static int handle_filetype(const char *fname, int flags,

-			   STATBUF *statbuf, int *stated, enum filetype *ft,

-			   cli_ftw_cb callback, struct cli_ftw_cbdata *data)

+static int handle_filetype(const char* fname, int flags,

+                           STATBUF* statbuf, int* stated, enum filetype* ft,

+                           cli_ftw_cb callback, struct cli_ftw_cbdata* data)

 {

     int ret;

-    *stated = get_filetype(fname, flags, flags & CLI_FTW_NEED_STAT , statbuf, ft);

-

-    if (*stated == -1) {

-	/*  we failed a stat() or lstat() */

-	ret = callback(NULL, NULL, fname, error_stat, data);

-	if (ret != CL_SUCCESS)

-	    return ret;

-	*ft = ft_unknown;

-    } else if (*ft == ft_skipped_link || *ft == ft_skipped_special) {

-	/* skipped filetype */

-	ret = callback(stated ? statbuf : NULL, NULL, fname,

-		       *ft == ft_skipped_link ?

-		       warning_skipped_link : warning_skipped_special, data);

-	if (ret != CL_SUCCESS)

-	    return ret;

+    *stated = get_filetype(fname, flags, flags & CLI_FTW_NEED_STAT, statbuf, ft);

+

+    if(*stated == -1) {

+        /*  we failed a stat() or lstat() */

+        ret = callback(NULL, NULL, fname, error_stat, data);

+        if(ret != CL_SUCCESS)

+            return ret;

+        *ft = ft_unknown;

+    } else if(*ft == ft_skipped_link || *ft == ft_skipped_special) {

+        /* skipped filetype */

+        ret = callback(stated ? statbuf : NULL, NULL, fname,

+                       *ft == ft_skipped_link ? warning_skipped_link : warning_skipped_special, data);

+        if(ret != CL_SUCCESS)

+            return ret;

     }

     return CL_SUCCESS;

 }

-static int cli_ftw_dir(const char *dirname, int flags, int maxdepth, cli_ftw_cb callback, struct cli_ftw_cbdata *data, cli_ftw_pathchk pathchk);

-static int handle_entry(struct dirent_data *entry, int flags, int maxdepth, cli_ftw_cb callback, struct cli_ftw_cbdata *data, cli_ftw_pathchk pathchk)

+static int cli_ftw_dir(const char* dirname, int flags, int maxdepth, cli_ftw_cb callback, struct cli_ftw_cbdata* data, cli_ftw_pathchk pathchk);

+static int handle_entry(struct dirent_data* entry, int flags, int maxdepth, cli_ftw_cb callback, struct cli_ftw_cbdata* data, cli_ftw_pathchk pathchk)

 {

-    if (!entry->is_dir) {

-	return callback(entry->statbuf, entry->filename, entry->filename, visit_file, data);

+    if(!entry->is_dir) {

+        return callback(entry->statbuf, entry->filename, entry->filename, visit_file, data);

     } else {

-	return cli_ftw_dir(entry->dirname, flags, maxdepth, callback, data, pathchk);

+        return cli_ftw_dir(entry->dirname, flags, maxdepth, callback, data, pathchk);

     }

 }

-int cli_ftw(char *path, int flags, int maxdepth, cli_ftw_cb callback, struct cli_ftw_cbdata *data, cli_ftw_pathchk pathchk)

+int cli_ftw(char* path, int flags, int maxdepth, cli_ftw_cb callback, struct cli_ftw_cbdata* data, cli_ftw_pathchk pathchk)

 {

     STATBUF statbuf;

     enum filetype ft = ft_unknown;

@@ -590,215 +583,215 @@ int cli_ftw(char *path, int flags, int maxdepth, cli_ftw_cb callback, struct cli

     int stated = 0;

     int ret;

-    if (((flags & CLI_FTW_TRIM_SLASHES) || pathchk) && path[0] && path[1]) {

-	char *pathend;

-	/* trim slashes so that dir and dir/ behave the same when

+    if(((flags & CLI_FTW_TRIM_SLASHES) || pathchk) && path[0] && path[1]) {

+        char* pathend;

+        /* trim slashes so that dir and dir/ behave the same when

 	 * they are symlinks, and we are not following symlinks */

 #ifndef _WIN32

-	while (path[0] == *PATHSEP && path[1] == *PATHSEP) path++;

+        while(path[0] == *PATHSEP && path[1] == *PATHSEP) path++;

 #endif

-	pathend = path + strlen(path);

-	while (pathend > path && pathend[-1] == *PATHSEP) --pathend;

-	*pathend = '\0';

+        pathend = path + strlen(path);

+        while(pathend > path && pathend[-1] == *PATHSEP) --pathend;

+        *pathend = '\0';

     }

     if(pathchk && pathchk(path, data) == 1)

-	return CL_SUCCESS;

+        return CL_SUCCESS;

     ret = handle_filetype(path, flags, &statbuf, &stated, &ft, callback, data);

-    if (ret != CL_SUCCESS)

-	return ret;

-    if (ft_skipped(ft))

-	return CL_SUCCESS;

-    entry.statbuf = stated ? &statbuf : NULL;

-    entry.is_dir = ft == ft_directory;

+    if(ret != CL_SUCCESS)

+        return ret;

+    if(ft_skipped(ft))

+        return CL_SUCCESS;

+    entry.statbuf  = stated ? &statbuf : NULL;

+    entry.is_dir   = ft == ft_directory;

     entry.filename = entry.is_dir ? NULL : strdup(path);

-    entry.dirname = entry.is_dir ? path : NULL;

-    if (entry.is_dir) {

-	ret = callback(entry.statbuf, NULL, path, visit_directory_toplev, data);

-	if (ret != CL_SUCCESS)

-	    return ret;

+    entry.dirname  = entry.is_dir ? path : NULL;

+    if(entry.is_dir) {

+        ret = callback(entry.statbuf, NULL, path, visit_directory_toplev, data);

+        if(ret != CL_SUCCESS)

+            return ret;

     }

     return handle_entry(&entry, flags, maxdepth, callback, data, pathchk);

 }

-static int cli_ftw_dir(const char *dirname, int flags, int maxdepth, cli_ftw_cb callback, struct cli_ftw_cbdata *data, cli_ftw_pathchk pathchk)

+static int cli_ftw_dir(const char* dirname, int flags, int maxdepth, cli_ftw_cb callback, struct cli_ftw_cbdata* data, cli_ftw_pathchk pathchk)

 {

-    DIR *dd;

+    DIR* dd;

 #if defined(HAVE_READDIR_R_3) || defined(HAVE_READDIR_R_2)

     union {

-	struct dirent d;

-	char b[offsetof(struct dirent, d_name) + NAME_MAX + 1];

+        struct dirent d;

+        char b[offsetof(struct dirent, d_name) + NAME_MAX + 1];

     } result;

 #endif

-    struct dirent_data *entries = NULL;

+    struct dirent_data* entries = NULL;