@@ -412,59 +412,81 @@ struct client_serial_data {

 /* FTW callback for scanning in non IDSESSION mode

  * Returns SUCCESS or BREAK on success, CL_EXXX on error */

-static int serial_callback(STATBUF *sb, char *filename, const char *path, enum cli_ftw_reason reason, struct cli_ftw_cbdata *data)

+static cl_error_t serial_callback(STATBUF *sb, char *filename, const char *path, enum cli_ftw_reason reason, struct cli_ftw_cbdata *data)

 {

+    int status = CL_EOPEN;

+

     struct client_serial_data *c = (struct client_serial_data *)data->data;

     int sockd, ret;

-    const char *f = filename;

+    const char *f       = filename;

+    char *real_filename = NULL;

     UNUSEDPARAM(sb);

-    if (chkpath(path))

-        return CL_SUCCESS;

+    if (reason != visit_directory_toplev) {

+        if (CL_SUCCESS != cli_realpath((const char *)path, &real_filename)) {

+            logg("*Failed to determine real filename of %s.\n", path);

+        } else {

+            path = real_filename;

+        }

+    }

+

+    if (chkpath(path)) {

+        status = CL_SUCCESS;

+        goto done;

+    }

     c->files++;

     switch (reason) {

         case error_stat:

             logg("!Can't access file %s\n", path);

             c->errors++;

-            return CL_SUCCESS;

+            status = CL_SUCCESS;

+            goto done;

         case error_mem:

             logg("!Memory allocation failed in ftw\n");

             c->errors++;

-            return CL_EMEM;

+            status = CL_EMEM;

+            goto done;

         case warning_skipped_dir:

             logg("^Directory recursion limit reached\n");

         case warning_skipped_link:

-            return CL_SUCCESS;

+            status = CL_SUCCESS;

+            goto done;

         case warning_skipped_special:

             logg("^%s: Not supported file type\n", path);

             c->errors++;

-            return CL_SUCCESS;

+            status = CL_SUCCESS;

+            goto done;

         case visit_directory_toplev:

-            if (c->scantype >= STREAM)

-                return CL_SUCCESS;

-            f        = path;

-            filename = NULL;

+            if (c->scantype >= STREAM) {

+                status = CL_SUCCESS;

+                goto done;

+            }

+            f = path;

         case visit_file:

             break;

     }

     if ((sockd = dconnect()) < 0) {

-        if (filename) free(filename);

         c->errors++;

-        return CL_EOPEN;

+        goto done;

     }

     ret = dsresult(sockd, c->scantype, f, &c->printok, &c->errors);

-    if (filename) free(filename);

     closesocket(sockd);

     if (ret < 0) {

         c->errors++;

-        return CL_EOPEN;

+        goto done;

     }

     c->infected += ret;

-    if (reason == visit_directory_toplev)

-        return CL_BREAK;

-    return CL_SUCCESS;

+    if (reason == visit_directory_toplev) {

+        status = CL_BREAK;

+        goto done;

+    }

+

+    status = CL_SUCCESS;

+done:

+    free(filename);

+    return status;

 }

 /* Non-IDSESSION handler

@@ -571,43 +593,62 @@ static int dspresult(struct client_parallel_data *c)

 /* FTW callback for scanning in IDSESSION mode

  * Returns SUCCESS on success, CL_EXXX or BREAK on error */

-static int parallel_callback(STATBUF *sb, char *filename, const char *path, enum cli_ftw_reason reason, struct cli_ftw_cbdata *data)

+static cl_error_t parallel_callback(STATBUF *sb, char *filename, const char *path, enum cli_ftw_reason reason, struct cli_ftw_cbdata *data)

 {

+    cl_error_t status = CL_EOPEN;

+

     struct client_parallel_data *c = (struct client_parallel_data *)data->data;

-    struct SCANID *cid;

-    int res = CL_CLEAN;

+    struct SCANID *cid             = NULL;

+    int res                        = CL_CLEAN;

+

+    char *real_filename = NULL;

     UNUSEDPARAM(sb);

+    UNUSEDPARAM(path);

+

+    if (reason != visit_directory_toplev) {

+        if (CL_SUCCESS != cli_realpath((const char *)filename, &real_filename)) {

+            logg("*Failed to determine real filename of %s.\n", filename);

+        } else {

+            free(filename);

+            filename = real_filename;

+        }

+    }

-    if (chkpath(path))

-        return CL_SUCCESS;

+    if (chkpath(filename)) {

+        goto done;

+    }

     c->files++;

     switch (reason) {

         case error_stat:

-            logg("!Can't access file %s\n", path);

+            logg("!Can't access file %s\n", filename);

             c->errors++;

-            return CL_SUCCESS;

+            status = CL_SUCCESS;

+            goto done;

         case error_mem:

             logg("!Memory allocation failed in ftw\n");

             c->errors++;

-            return CL_EMEM;

+            status = CL_EMEM;

+            goto done;

         case warning_skipped_dir:

             logg("^Directory recursion limit reached\n");

-            return CL_SUCCESS;

+            status = CL_SUCCESS;

+            goto done;

         case warning_skipped_special:

-            logg("^%s: Not supported file type\n", path);

+            logg("^%s: Not supported file type\n", filename);

             c->errors++;

         case warning_skipped_link:

         case visit_directory_toplev:

-            return CL_SUCCESS;

+            status = CL_SUCCESS;

+            goto done;

         case visit_file:

             break;

     }

     while (1) {

         /* consume all the available input to let some of the clamd

-	 * threads blocked on send() to be dead.

-	 * by doing so we shouldn't deadlock on the next recv() */

+	     * threads blocked on send() to be dead.

+	     * by doing so we shouldn't deadlock on the next recv() */

         fd_set rfds, wfds;

         FD_ZERO(&rfds);

         FD_SET(c->sockd, &rfds);

@@ -615,31 +656,20 @@ static int parallel_callback(STATBUF *sb, char *filename, const char *path, enum

         FD_SET(c->sockd, &wfds);

         if (select(c->sockd + 1, &rfds, &wfds, NULL, NULL) < 0) {

             if (errno == EINTR) continue;

-            free(filename);

             logg("!select() failed during session: %s\n", strerror(errno));

-            return CL_BREAK;

+            status = CL_BREAK;

+            goto done;

         }

         if (FD_ISSET(c->sockd, &rfds)) {

             if (dspresult(c)) {

-                free(filename);

-                return CL_BREAK;

+                status = CL_BREAK;

+                goto done;

             } else

                 continue;

         }

         if (FD_ISSET(c->sockd, &wfds)) break;

     }

-    cid = (struct SCANID *)malloc(sizeof(struct SCANID));

-    if (!cid) {

-        free(filename);

-        logg("!Failed to allocate scanid entry: %s\n", strerror(errno));

-        return CL_BREAK;

-    }

-    cid->id   = ++c->lastid;

-    cid->file = filename;

-    cid->next = c->ids;

-    c->ids    = cid;

-

     switch (c->scantype) {

 #ifdef HAVE_FD_PASSING

         case FILDES:

@@ -653,13 +683,32 @@ static int parallel_callback(STATBUF *sb, char *filename, const char *path, enum

     if (res <= 0) {

         c->printok = 0;

         c->errors++;

-        c->ids = cid->next;

-        c->lastid--;

-        free(cid);

+        status = res ? CL_BREAK : CL_SUCCESS;

+        goto done;

+    }

+

+    cid = (struct SCANID *)malloc(sizeof(struct SCANID));

+    if (!cid) {

+        logg("!Failed to allocate scanid entry: %s\n", strerror(errno));

+        status = CL_BREAK;

+        goto done;

+    }

+

+    cid->id   = ++c->lastid;

+    cid->file = filename;

+    cid->next = c->ids;

+    c->ids    = cid;

+

+    /* Give up ownership of the filename to the client parralel scan ID list */

+    filename = NULL;

+

+    status = CL_SUCCESS;

+

+done:

+    if (NULL != filename) {

         free(filename);

-        return res ? CL_BREAK : CL_SUCCESS;

     }

-    return CL_SUCCESS;

+    return status;

 }

 /* IDSESSION handler

@@ -929,7 +929,7 @@ struct cli_ftw_cbdata {

  * after an error, we call the callback with reason == error,

  * and if it returns CL_BREAK we break.

  */

-typedef int (*cli_ftw_cb)(STATBUF *stat_buf, char *filename, const char *path, enum cli_ftw_reason reason, struct cli_ftw_cbdata *data);

+typedef cl_error_t (*cli_ftw_cb)(STATBUF *stat_buf, char *filename, const char *path, enum cli_ftw_reason reason, struct cli_ftw_cbdata *data);

 /*

  * returns 1 if the path should be skipped and 0 otherwise

@@ -696,7 +696,9 @@ int actsetup(const struct optstruct *opts)

 {

     int move = optget(opts, "move")->enabled;

     if (move || optget(opts, "copy")->enabled) {

+#ifndef _WIN32

         cl_error_t ret;

+#endif

         actarget = optget(opts, move ? "move" : "copy")->strarg;

 #ifndef _WIN32

         ret = cli_realpath((const char *)actarget, &actarget);

@@ -256,11 +256,9 @@ int filecopy(const char *src, const char *dest)

 #endif

 }

-int close_std_descriptors() {

-#ifdef _WIN32

-    return -1;

-#else

-

+#ifndef _WIN32

+int close_std_descriptors()

+{

     int fds[3], i;

     fds[0] = open("/dev/null", O_RDONLY);

@@ -289,67 +287,51 @@ int close_std_descriptors() {

             close(fds[i]);

     return 0;

-#endif

 }

-

-int daemonize_all_return(void) {

-#ifdef _WIN32

-    fputs("Background mode is not supported on your operating system\n", stderr);

-    return -1;

-#else

+int daemonize_all_return(void)

+{

     pid_t pid;

     pid = fork();

-    if (0 == pid){

+    if (0 == pid) {

         setsid();

     }

     return pid;

-

-#endif

 }

-int daemonize(void) {

-#ifdef _WIN32

-    fputs("Background mode is not supported on your operating system\n", stderr);

-    return -1;

-#else

-

+int daemonize(void)

+{

     int ret = 0;

     ret = close_std_descriptors();

-    if (ret){

+    if (ret) {

         return ret;

     }

-    ret = daemonize_all_return();

-    pid_t pid = (pid_t) ret;

+    ret       = daemonize_all_return();

+    pid_t pid = (pid_t)ret;

     /*parent process.*/

-    if (pid > 0){

+    if (pid > 0) {

         exit(0);

     }

     return pid;

-#endif

 }

-

-static void daemonize_child_initialized_handler(int sig){

+static void daemonize_child_initialized_handler(int sig)

+{

     (void)(sig);

     exit(0);

 }

-int daemonize_parent_wait(){

-#ifdef _WIN32

-    fputs("Background mode is not supported on your operating system\n", stderr);

-    return -1;

-#else

-

+int daemonize_parent_wait()

+{

     int daemonizePid = daemonize_all_return();

     if (daemonizePid == -1) {

         return -1;

-    } else if (daemonizePid){ //parent

+    } else if (daemonizePid) { //parent

         /* The parent will wait until either the child process

          * exits, or signals the parent that it's initialization is

          * complete.  If it exits, it is due to an error condition,

@@ -363,33 +345,27 @@ int daemonize_parent_wait(){

         sigemptyset(&(sig.sa_mask));

         sig.sa_handler = daemonize_child_initialized_handler;

-        if (0 != sigaction(SIGINT, &sig, NULL)){

+        if (0 != sigaction(SIGINT, &sig, NULL)) {

             perror("sigaction");

             return -1;

         }

         int exitStatus;

         wait(&exitStatus);

-        if (WIFEXITED(exitStatus)){ //error

+        if (WIFEXITED(exitStatus)) { //error

             exitStatus = WEXITSTATUS(exitStatus);

             exit(exitStatus);

         }

-

     }

     return 0;

-#endif

 }

-void daemonize_signal_parent(pid_t parentPid){

-#ifdef _WIN32

-    fputs("Background mode is not supported on your operating system\n", stderr);

-    return -1;

-#else

+void daemonize_signal_parent(pid_t parentPid)

+{

     close_std_descriptors();

-    kill(parentPid, SIGINT) ;

-#endif

+    kill(parentPid, SIGINT);

 }

-

+#endif

 int match_regex(const char *filename, const char *pattern)

 {

@@ -63,24 +63,27 @@ int check_flevel(void);

 const char *filelist(const struct optstruct *opts, int *err);

 int filecopy(const char *src, const char *dest);

+#ifndef _WIN32

 /*Returns 0 on success (only the child process returns.*/

 int daemonize(void);

 /*closes stdin, stdout, stderr.  This is called by daemonize, but not

  * daemonize_all_return.  Users of daemonize_all_return should call this

  * when initialization is complete.*/

-int close_std_descriptors() ;

+int close_std_descriptors();

+

 /*Returns the return value of fork.  All processes return */

 int daemonize_all_return(void);

+

 /*Parent waits for a SIGINT or the child process to exit.  If

  * it receives a SIGINT, it exits with exit code 0.  If the child

  * exits (error), it exits with the child process's exit code.*/

 int daemonize_parent_wait();

+

 /*Sends a SIGINT to the parent process.  It also closes stdin, stdout, 

  * and stderr.*/

 void daemonize_signal_parent(pid_t parentPid);

-

-

+#endif

 const char *get_version(void);

 int match_regex(const char *filename, const char *pattern);