Merge branch '1897_libc_respect_return_values'

* 1897_libc_respect_return_values:
  Final Indentation of all touched files
  Changes into src/consaver directory:
  Changes into src/editor directory:
  Changes into src directory:
  Ticket #1897: Build breaks on ignored return values

lib/util.c

@@ -1241,6 +1241,7 @@ mc_util_write_backup_content (const char *from_file_name, const char *to_file_na
     FILE *backup_fd;
     char *contents;
     gsize length;
+    gboolean ret1 = TRUE;
 
     if (!g_file_get_contents (from_file_name, &contents, &length, NULL))
         return FALSE;
@@ -1252,12 +1253,15 @@ mc_util_write_backup_content (const char *from_file_name, const char *to_file_na
         return FALSE;
     }
 
-    fwrite ((const void *) contents, length, 1, backup_fd);
-
-    fflush (backup_fd);
-    fclose (backup_fd);
+    if (fwrite ((const void *) contents, length, 1, backup_fd) != length)
+        ret1 = FALSE;
+    {
+        int ret2;
+        ret2 = fflush (backup_fd);
+        ret2 = fclose (backup_fd);
+    }
     g_free (contents);
-    return TRUE;
+    return ret1;
 }
 
 /* Finds out a relative path from first to second, i.e. goes as many ..

lib/utilunix.c

@@ -12,7 +12,7 @@
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
@@ -50,153 +50,169 @@
 
 #include "lib/global.h"
 #include "src/execute.h"
-#include "src/wtools.h"		/* message() */
+#include "src/wtools.h"         /* message() */
 
 struct sigaction startup_handler;
 
 #define UID_CACHE_SIZE 200
 #define GID_CACHE_SIZE 30
 
-typedef struct {
-    int  index;
+typedef struct
+{
+    int index;
     char *string;
 } int_cache;
 
-static int_cache uid_cache [UID_CACHE_SIZE];
-static int_cache gid_cache [GID_CACHE_SIZE];
+static int_cache uid_cache[UID_CACHE_SIZE];
+static int_cache gid_cache[GID_CACHE_SIZE];
 
-static char *i_cache_match (int id, int_cache *cache, int size)
+static char *
+i_cache_match (int id, int_cache * cache, int size)
 {
     int i;
 
     for (i = 0; i < size; i++)
-	if (cache [i].index == id)
-	    return cache [i].string;
+        if (cache[i].index == id)
+            return cache[i].string;
     return 0;
 }
 
-static void i_cache_add (int id, int_cache *cache, int size, char *text,
-			 int *last)
+static void
+i_cache_add (int id, int_cache * cache, int size, char *text, int *last)
 {
-    g_free (cache [*last].string);
-    cache [*last].string = g_strdup (text);
-    cache [*last].index = id;
-    *last = ((*last)+1) % size;
+    g_free (cache[*last].string);
+    cache[*last].string = g_strdup (text);
+    cache[*last].index = id;
+    *last = ((*last) + 1) % size;
 }
 
-char *get_owner (int uid)
+char *
+get_owner (int uid)
 {
     struct passwd *pwd;
-    static char ibuf [10];
-    char   *name;
+    static char ibuf[10];
+    char *name;
     static int uid_last;
-    
+
     if ((name = i_cache_match (uid, uid_cache, UID_CACHE_SIZE)) != NULL)
-	return name;
-    
+        return name;
+
     pwd = getpwuid (uid);
-    if (pwd){
-	i_cache_add (uid, uid_cache, UID_CACHE_SIZE, pwd->pw_name, &uid_last);
-	return pwd->pw_name;
+    if (pwd)
+    {
+        i_cache_add (uid, uid_cache, UID_CACHE_SIZE, pwd->pw_name, &uid_last);
+        return pwd->pw_name;
     }
-    else {
-	g_snprintf (ibuf, sizeof (ibuf), "%d", uid);
-	return ibuf;
+    else
+    {
+        g_snprintf (ibuf, sizeof (ibuf), "%d", uid);
+        return ibuf;
     }
 }
 
-char *get_group (int gid)
+char *
+get_group (int gid)
 {
     struct group *grp;
-    static char gbuf [10];
+    static char gbuf[10];
     char *name;
-    static int  gid_last;
-    
+    static int gid_last;
+
     if ((name = i_cache_match (gid, gid_cache, GID_CACHE_SIZE)) != NULL)
-	return name;
-    
+        return name;
+
     grp = getgrgid (gid);
-    if (grp){
-	i_cache_add (gid, gid_cache, GID_CACHE_SIZE, grp->gr_name, &gid_last);
-	return grp->gr_name;
-    } else {
-	g_snprintf (gbuf, sizeof (gbuf), "%d", gid);
-	return gbuf;
+    if (grp)
+    {
+        i_cache_add (gid, gid_cache, GID_CACHE_SIZE, grp->gr_name, &gid_last);
+        return grp->gr_name;
+    }
+    else
+    {
+        g_snprintf (gbuf, sizeof (gbuf), "%d", gid);
+        return gbuf;
     }
 }
 
 /* Since ncurses uses a handler that automatically refreshes the */
 /* screen after a SIGCONT, and we don't want this behavior when */
 /* spawning a child, we save the original handler here */
-void save_stop_handler (void)
+void
+save_stop_handler (void)
 {
     sigaction (SIGTSTP, NULL, &startup_handler);
 }
 
-int my_system (int flags, const char *shell, const char *command)
+int
+my_system (int flags, const char *shell, const char *command)
 {
     struct sigaction ignore, save_intr, save_quit, save_stop;
     pid_t pid;
     int status = 0;
-    
+
     ignore.sa_handler = SIG_IGN;
     sigemptyset (&ignore.sa_mask);
     ignore.sa_flags = 0;
-    
-    sigaction (SIGINT, &ignore, &save_intr);    
+
+    sigaction (SIGINT, &ignore, &save_intr);
     sigaction (SIGQUIT, &ignore, &save_quit);
 
     /* Restore the original SIGTSTP handler, we don't want ncurses' */
     /* handler messing the screen after the SIGCONT */
     sigaction (SIGTSTP, &startup_handler, &save_stop);
 
-    if ((pid = fork ()) < 0){
-	fprintf (stderr, "\n\nfork () = -1\n");
-	return -1;
+    if ((pid = fork ()) < 0)
+    {
+        fprintf (stderr, "\n\nfork () = -1\n");
+        return -1;
+    }
+    if (pid == 0)
+    {
+        signal (SIGINT, SIG_DFL);
+        signal (SIGQUIT, SIG_DFL);
+        signal (SIGTSTP, SIG_DFL);
+        signal (SIGCHLD, SIG_DFL);
+
+        if (flags & EXECUTE_AS_SHELL)
+            execl (shell, shell, "-c", command, (char *) NULL);
+        else
+        {
+            gchar **shell_tokens;
+            const gchar *only_cmd;
+            shell_tokens = g_strsplit (shell, " ", 2);
+
+            if (shell_tokens == NULL)
+                only_cmd = shell;
+            else
+                only_cmd = (*shell_tokens) ? *shell_tokens : shell;
+
+            execlp (only_cmd, shell, command, (char *) NULL);
+
+            /*
+               execlp will replace current process,
+               therefore no sence in call of g_strfreev().
+               But this keeped for estetic reason :)
+             */
+            g_strfreev (shell_tokens);
+
+        }
+
+        _exit (127);            /* Exec error */
     }
-    if (pid == 0){
-	signal (SIGINT, SIG_DFL);
-	signal (SIGQUIT, SIG_DFL);
-	signal (SIGTSTP, SIG_DFL);
-	signal (SIGCHLD, SIG_DFL);
-
-	if (flags & EXECUTE_AS_SHELL)
-	    execl (shell, shell, "-c", command, (char *) NULL);
-	else
-	{
-	    gchar **shell_tokens;
-	    const gchar *only_cmd;
-	    shell_tokens = g_strsplit(shell," ", 2);
-
-	    if (shell_tokens == NULL)
-	        only_cmd = shell;
-	    else
-	        only_cmd = (*shell_tokens) ? *shell_tokens: shell;
-
-	    execlp (only_cmd, shell, command, (char *) NULL);
-
-	    /*
-	      execlp will replace current process,
-	      therefore no sence in call of g_strfreev().
-	      But this keeped for estetic reason :)
-	    */
-	    g_strfreev(shell_tokens);
-
-	}
-
-	_exit (127);		/* Exec error */
-    } else {
-	while (waitpid (pid, &status, 0) < 0)
-	    if (errno != EINTR){
-		status = -1;
-		break;
-	    }
+    else
+    {
+        while (waitpid (pid, &status, 0) < 0)
+            if (errno != EINTR)
+            {
+                status = -1;
+                break;
+            }
     }
-    sigaction (SIGINT,  &save_intr, NULL);
+    sigaction (SIGINT, &save_intr, NULL);
     sigaction (SIGQUIT, &save_quit, NULL);
     sigaction (SIGTSTP, &save_stop, NULL);
 
-    return WEXITSTATUS(status);
+    return WEXITSTATUS (status);
 }
 
 
@@ -212,29 +228,35 @@ tilde_expand (const char *directory)
     char *name;
 
     if (*directory != '~')
-	return g_strdup (directory);
+        return g_strdup (directory);
 
     p = directory + 1;
 
     /* d = "~" or d = "~/" */
-    if (!(*p) || (*p == PATH_SEP)) {
-	passwd = getpwuid (geteuid ());
-	q = (*p == PATH_SEP) ? p + 1 : "";
-    } else {
-	q = strchr (p, PATH_SEP);
-	if (!q) {
-	    passwd = getpwnam (p);
-	} else {
-	    name = g_strndup (p, q - p);
-	    passwd = getpwnam (name);
-	    q++;
-	    g_free (name);
-	}
+    if (!(*p) || (*p == PATH_SEP))
+    {
+        passwd = getpwuid (geteuid ());
+        q = (*p == PATH_SEP) ? p + 1 : "";
+    }
+    else
+    {
+        q = strchr (p, PATH_SEP);
+        if (!q)
+        {
+            passwd = getpwnam (p);
+        }
+        else
+        {
+            name = g_strndup (p, q - p);
+            passwd = getpwnam (name);
+            q++;
+            g_free (name);
+        }
     }
 
     /* If we can't figure the user name, leave tilde unexpanded */
     if (!passwd)
-	return g_strdup (directory);
+        return g_strdup (directory);
 
     return g_strconcat (passwd->pw_dir, PATH_SEP_STR, q, (char *) NULL);
 }
@@ -258,84 +280,91 @@ mc_tmpdir (void)
 
     /* Check if already correctly initialized */
     if (tmpdir && lstat (tmpdir, &st) == 0 && S_ISDIR (st.st_mode) &&
-	st.st_uid == getuid () && (st.st_mode & 0777) == 0700)
-	return tmpdir;
+        st.st_uid == getuid () && (st.st_mode & 0777) == 0700)
+        return tmpdir;
 
     sys_tmp = getenv ("TMPDIR");
-    if (!sys_tmp || sys_tmp[0] != '/') {
-	sys_tmp = TMPDIR_DEFAULT;
+    if (!sys_tmp || sys_tmp[0] != '/')
+    {
+        sys_tmp = TMPDIR_DEFAULT;
     }
 
     pwd = getpwuid (getuid ());
 
     if (pwd)
-	g_snprintf (buffer, sizeof (buffer), "%s/mc-%s", sys_tmp,
-		pwd->pw_name);
+        g_snprintf (buffer, sizeof (buffer), "%s/mc-%s", sys_tmp, pwd->pw_name);
     else
-	g_snprintf (buffer, sizeof (buffer), "%s/mc-%lu", sys_tmp,
-		(unsigned long) getuid ());
+        g_snprintf (buffer, sizeof (buffer), "%s/mc-%lu", sys_tmp, (unsigned long) getuid ());
 
     canonicalize_pathname (buffer);
 
-    if (lstat (buffer, &st) == 0) {
-	/* Sanity check for existing directory */
-	if (!S_ISDIR (st.st_mode))
-	    error = _("%s is not a directory\n");
-	else if (st.st_uid != getuid ())
-	    error = _("Directory %s is not owned by you\n");
-	else if (((st.st_mode & 0777) != 0700)
-		 && (chmod (buffer, 0700) != 0))
-	    error = _("Cannot set correct permissions for directory %s\n");
-    } else {
-	/* Need to create directory */
-	if (mkdir (buffer, S_IRWXU) != 0) {
-	    fprintf (stderr,
-		     _("Cannot create temporary directory %s: %s\n"),
-		     buffer, unix_error_string (errno));
-	    error = "";
-	}
+    if (lstat (buffer, &st) == 0)
+    {
+        /* Sanity check for existing directory */
+        if (!S_ISDIR (st.st_mode))
+            error = _("%s is not a directory\n");
+        else if (st.st_uid != getuid ())
+            error = _("Directory %s is not owned by you\n");
+        else if (((st.st_mode & 0777) != 0700) && (chmod (buffer, 0700) != 0))
+            error = _("Cannot set correct permissions for directory %s\n");
+    }
+    else
+    {
+        /* Need to create directory */
+        if (mkdir (buffer, S_IRWXU) != 0)
+        {
+            fprintf (stderr,
+                     _("Cannot create temporary directory %s: %s\n"),
+                     buffer, unix_error_string (errno));
+            error = "";
+        }
     }
 
-    if (error != NULL) {
-	int test_fd;
-	char *test_fn, *fallback_prefix;
-	int fallback_ok = 0;
-
-	if (*error)
-	    fprintf (stderr, error, buffer);
-
-	/* Test if sys_tmp is suitable for temporary files */
-	fallback_prefix = g_strdup_printf ("%s/mctest", sys_tmp);
-	test_fd = mc_mkstemps (&test_fn, fallback_prefix, NULL);
-	g_free (fallback_prefix);
-	if (test_fd != -1) {
-	    close (test_fd);
-	    test_fd = open (test_fn, O_RDONLY);
-	    if (test_fd != -1) {
-		close (test_fd);
-		unlink (test_fn);
-		fallback_ok = 1;
-	    }
-	}
-
-	if (fallback_ok) {
-	    fprintf (stderr, _("Temporary files will be created in %s\n"),
-		     sys_tmp);
-	    g_snprintf (buffer, sizeof (buffer), "%s", sys_tmp);
-	    error = NULL;
-	} else {
-	    fprintf (stderr, _("Temporary files will not be created\n"));
-	    g_snprintf (buffer, sizeof (buffer), "%s", "/dev/null/");
-	}
-
-	fprintf (stderr, "%s\n", _("Press any key to continue..."));
-	getc (stdin);
+    if (error != NULL)
+    {
+        int test_fd;
+        char *test_fn, *fallback_prefix;
+        int fallback_ok = 0;
+
+        if (*error)
+            fprintf (stderr, error, buffer);
+
+        /* Test if sys_tmp is suitable for temporary files */
+        fallback_prefix = g_strdup_printf ("%s/mctest", sys_tmp);
+        test_fd = mc_mkstemps (&test_fn, fallback_prefix, NULL);
+        g_free (fallback_prefix);
+        if (test_fd != -1)
+        {
+            close (test_fd);
+            test_fd = open (test_fn, O_RDONLY);
+            if (test_fd != -1)
+            {
+                close (test_fd);
+                unlink (test_fn);
+                fallback_ok = 1;
+            }
+        }
+
+        if (fallback_ok)
+        {
+            fprintf (stderr, _("Temporary files will be created in %s\n"), sys_tmp);
+            g_snprintf (buffer, sizeof (buffer), "%s", sys_tmp);
+            error = NULL;
+        }
+        else
+        {
+            fprintf (stderr, _("Temporary files will not be created\n"));
+            g_snprintf (buffer, sizeof (buffer), "%s", "/dev/null/");
+        }
+
+        fprintf (stderr, "%s\n", _("Press any key to continue..."));
+        getc (stdin);
     }
 
     tmpdir = buffer;
 
     if (!error)
-	g_setenv ("MC_TMPDIR", tmpdir, TRUE);
+        g_setenv ("MC_TMPDIR", tmpdir, TRUE);
 
     return tmpdir;
 }
@@ -345,23 +374,26 @@ mc_tmpdir (void)
 /* More than that would be unportable */
 #define MAX_PIPE_SIZE 4096
 
-static int error_pipe[2];	/* File descriptors of error pipe */
-static int old_error;		/* File descriptor of old standard error */
+static int error_pipe[2];       /* File descriptors of error pipe */
+static int old_error;           /* File descriptor of old standard error */
 
 /* Creates a pipe to hold standard error for a later analysis. */
 /* The pipe can hold 4096 bytes. Make sure no more is written */
 /* or a deadlock might occur. */
-void open_error_pipe (void)
+void
+open_error_pipe (void)
 {
-    if (pipe (error_pipe) < 0){
-	message (D_NORMAL, _("Warning"), _(" Pipe failed "));
+    if (pipe (error_pipe) < 0)
+    {
+        message (D_NORMAL, _("Warning"), _(" Pipe failed "));
     }
     old_error = dup (2);
-    if(old_error < 0 || close(2) || dup (error_pipe[1]) != 2){
-	message (D_NORMAL, _("Warning"), _(" Dup failed "));
+    if (old_error < 0 || close (2) || dup (error_pipe[1]) != 2)
+    {
+        message (D_NORMAL, _("Warning"), _(" Dup failed "));
 
-	close (error_pipe[0]);
-	error_pipe[0] = -1;
+        close (error_pipe[0]);
+        error_pipe[0] = -1;
     }
     else
     {
@@ -378,7 +410,7 @@ void open_error_pipe (void)
         if (fd_flags != -1)
         {
             fd_flags |= O_NONBLOCK;
-            if (fcntl(error_pipe[0], F_SETFL, fd_flags) == -1)
+            if (fcntl (error_pipe[0], F_SETFL, fd_flags) == -1)
             {
                 /* TODO: handle it somehow */
             }
@@ -403,34 +435,41 @@ close_error_pipe (int error, const char *text)
 
     /* already closed */
     if (error_pipe[0] == -1)
-	return 0;
+        return 0;
 
     if (error)
-	title = MSG_ERROR;
+        title = MSG_ERROR;
     else
-	title = _("Warning");
-    if (old_error >= 0){
-	close (2);
-	dup (old_error);
-	close (old_error);
-	len = read (error_pipe[0], msg, MAX_PIPE_SIZE - 1);
-
-	if (len >= 0)
-	    msg[len] = 0;
-	close (error_pipe[0]);
-	error_pipe[0] = -1;
+        title = _("Warning");
+    if (old_error >= 0)
+    {
+        if (dup2 (old_error, 2))
+        {
+            message (error, MSG_ERROR, "%s", _("Error dup'ing old error pipe"));
+            return 1;
+        }
+        close (old_error);
+        len = read (error_pipe[0], msg, MAX_PIPE_SIZE - 1);
+
+        if (len >= 0)
+            msg[len] = 0;
+        close (error_pipe[0]);
+        error_pipe[0] = -1;
     }
     if (error < 0)
-	return 0;	/* Just ignore error message */
-    if (text == NULL){
-	if (len <= 0)
-	    return 0;	/* Nothing to show */
-
-	/* Show message from pipe */
-	message (error, title, "%s", msg);
-    } else {
-	/* Show given text and possible message from pipe */
-	message (error, title, " %s \n %s ", text, msg);
+        return 0;               /* Just ignore error message */
+    if (text == NULL)
+    {
+        if (len <= 0)
+            return 0;           /* Nothing to show */
+
+        /* Show message from pipe */
+        message (error, title, "%s", msg);
+    }
+    else
+    {
+        /* Show given text and possible message from pipe */
+        message (error, title, " %s \n %s ", text, msg);
     }
     return 1;
 }
@@ -438,11 +477,11 @@ close_error_pipe (int error, const char *text)
 /*
  * Canonicalize path, and return a new path.  Do everything in place.
  * The new path differs from path in:
- *	Multiple `/'s are collapsed to a single `/'.
- *	Leading `./'s and trailing `/.'s are removed.
- *	Trailing `/'s are removed.
- *	Non-leading `../'s and trailing `..'s are handled by removing
- *	portions of the path.
+ *      Multiple `/'s are collapsed to a single `/'.
+ *      Leading `./'s and trailing `/.'s are removed.
+ *      Trailing `/'s are removed.
+ *      Non-leading `../'s and trailing `..'s are handled by removing
+ *      portions of the path.
  * Well formed UNC paths are modified only in the local part.
  */
 void
@@ -450,131 +489,160 @@ custom_canonicalize_pathname (char *path, CANON_PATH_FLAGS flags)
 {
     char *p, *s;
     int len;
-    char *lpath = path;	/* path without leading UNC part */
+    char *lpath = path;         /* path without leading UNC part */
 
     /* Detect and preserve UNC paths: //server/... */
-    if ( ( flags & CANON_PATH_GUARDUNC ) && path[0] == PATH_SEP && path[1] == PATH_SEP) {
-	p = path + 2;
-	while (p[0] && p[0] != '/')
-	    p++;
-	if (p[0] == '/' && p > path + 2)
-	    lpath = p;
+    if ((flags & CANON_PATH_GUARDUNC) && path[0] == PATH_SEP && path[1] == PATH_SEP)
+    {
+        p = path + 2;
+        while (p[0] && p[0] != '/')
+            p++;
+        if (p[0] == '/' && p > path + 2)
+            lpath = p;
     }
 
     if (!lpath[0] || !lpath[1])
-	return;
-
-    if ( flags & CANON_PATH_JOINSLASHES ) {
-	/* Collapse multiple slashes */
-	p = lpath;
-	while (*p) {
-	    if (p[0] == PATH_SEP && p[1] == PATH_SEP) {
-		s = p + 1;
-		while (*(++s) == PATH_SEP);
-		str_move (p + 1, s);
-	    }
-	    p++;
-	}
+        return;
+
+    if (flags & CANON_PATH_JOINSLASHES)
+    {
+        /* Collapse multiple slashes */
+        p = lpath;
+        while (*p)
+        {
+            if (p[0] == PATH_SEP && p[1] == PATH_SEP)
+            {
+                s = p + 1;
+                while (*(++s) == PATH_SEP);
+                str_move (p + 1, s);
+            }
+            p++;
+        }
     }
 
-    if ( flags & CANON_PATH_JOINSLASHES ) {
-	/* Collapse "/./" -> "/" */
-	p = lpath;
-	while (*p) {
-	    if (p[0] == PATH_SEP && p[1] == '.' && p[2] == PATH_SEP)
-		str_move (p, p + 2);
-	    else
-		p++;
-	}
+    if (flags & CANON_PATH_JOINSLASHES)
+    {
+        /* Collapse "/./" -> "/" */
+        p = lpath;
+        while (*p)
+        {
+            if (p[0] == PATH_SEP && p[1] == '.' && p[2] == PATH_SEP)
+                str_move (p, p + 2);
+            else
+                p++;
+        }
     }
 
-    if ( flags & CANON_PATH_REMSLASHDOTS ) {
-	/* Remove trailing slashes */
-	p = lpath + strlen (lpath) - 1;
-	while (p > lpath && *p == PATH_SEP)
-	    *p-- = 0;
-
-	/* Remove leading "./" */
-	if (lpath[0] == '.' && lpath[1] == PATH_SEP) {
-	    if (lpath[2] == 0) {
-		lpath[1] = 0;
-		return;
-	    } else {
-		str_move (lpath, lpath + 2);
-	    }
-	}
-
-	/* Remove trailing "/" or "/." */
-	len = strlen (lpath);
-	if (len < 2)
-	    return;
-	if (lpath[len - 1] == PATH_SEP) {
-	    lpath[len - 1] = 0;
-	} else {
-	    if (lpath[len - 1] == '.' && lpath[len - 2] == PATH_SEP) {
-		if (len == 2) {
-		    lpath[1] = 0;
-		    return;
-		} else {
-		    lpath[len - 2] = 0;
-		}
-	    }
-	}
+    if (flags & CANON_PATH_REMSLASHDOTS)
+    {
+        /* Remove trailing slashes */
+        p = lpath + strlen (lpath) - 1;
+        while (p > lpath && *p == PATH_SEP)
+            *p-- = 0;
+
+        /* Remove leading "./" */
+        if (lpath[0] == '.' && lpath[1] == PATH_SEP)
+        {
+            if (lpath[2] == 0)
+            {
+                lpath[1] = 0;
+                return;
+            }
+            else
+            {
+                str_move (lpath, lpath + 2);
+            }
+        }
+
+        /* Remove trailing "/" or "/." */
+        len = strlen (lpath);
+        if (len < 2)
+            return;
+        if (lpath[len - 1] == PATH_SEP)
+        {
+            lpath[len - 1] = 0;
+        }
+        else
+        {
+            if (lpath[len - 1] == '.' && lpath[len - 2] == PATH_SEP)
+            {
+                if (len == 2)
+                {
+                    lpath[1] = 0;
+                    return;
+                }
+                else
+                {
+                    lpath[len - 2] = 0;
+                }
+            }
+        }
     }
 
-    if ( flags & CANON_PATH_REMDOUBLEDOTS ) {
-	/* Collapse "/.." with the previous part of path */
-	p = lpath;
-	while (p[0] && p[1] && p[2]) {
-	    if ((p[0] != PATH_SEP || p[1] != '.' || p[2] != '.')
-		|| (p[3] != PATH_SEP && p[3] != 0)) {
-		p++;
-		continue;
-	    }
-
-	    /* search for the previous token */
-	    s = p - 1;
-	    while (s >= lpath && *s != PATH_SEP)
-		s--;
-
-	    s++;
-
-	    /* If the previous token is "..", we cannot collapse it */
-	    if (s[0] == '.' && s[1] == '.' && s + 2 == p) {
-		p += 3;
-		continue;
-	    }
-
-	    if (p[3] != 0) {
-		if (s == lpath && *s == PATH_SEP) {
-		    /* "/../foo" -> "/foo" */
-		    str_move (s + 1, p + 4);
-		} else {
-		    /* "token/../foo" -> "foo" */
-		    str_move (s, p + 4);
-		}
-		p = (s > lpath) ? s - 1 : s;
-		continue;
-	    }
-
-	    /* trailing ".." */
-	    if (s == lpath) {
-		/* "token/.." -> "." */
-		if (lpath[0] != PATH_SEP) {
-		    lpath[0] = '.';
-		}
-		lpath[1] = 0;
-	    } else {
-		/* "foo/token/.." -> "foo" */
-		if (s == lpath + 1)
-		    s[0] = 0;
-		else
-		    s[-1] = 0;
-		break;
-	    }
-
-	    break;
-	}
+    if (flags & CANON_PATH_REMDOUBLEDOTS)
+    {
+        /* Collapse "/.." with the previous part of path */
+        p = lpath;
+        while (p[0] && p[1] && p[2])
+        {
+            if ((p[0] != PATH_SEP || p[1] != '.' || p[2] != '.') || (p[3] != PATH_SEP && p[3] != 0))
+            {
+                p++;
+                continue;
+            }
+
+            /* search for the previous token */
+            s = p - 1;
+            while (s >= lpath && *s != PATH_SEP)
+                s--;
+
+            s++;
+
+            /* If the previous token is "..", we cannot collapse it */
+            if (s[0] == '.' && s[1] == '.' && s + 2 == p)
+            {
+                p += 3;
+                continue;
+            }
+
+            if (p[3] != 0)
+            {
+                if (s == lpath && *s == PATH_SEP)
+                {
+                    /* "/../foo" -> "/foo" */
+                    str_move (s + 1, p + 4);
+                }
+                else
+                {
+                    /* "token/../foo" -> "foo" */
+                    str_move (s, p + 4);
+                }
+                p = (s > lpath) ? s - 1 : s;
+                continue;
+            }
+
+            /* trailing ".." */
+            if (s == lpath)
+            {
+                /* "token/.." -> "." */
+                if (lpath[0] != PATH_SEP)
+                {
+                    lpath[0] = '.';
+                }
+                lpath[1] = 0;
+            }
+            else
+            {
+                /* "foo/token/.." -> "foo" */
+                if (s == lpath + 1)
+                    s[0] = 0;
+                else
+                    s[-1] = 0;
+                break;
+            }
+
+            break;
+        }
     }
 }
 
@@ -587,9 +655,10 @@ canonicalize_pathname (char *path)
 #ifdef HAVE_GET_PROCESS_STATS
 #    include <sys/procstats.h>
 
-int gettimeofday (struct timeval *tp, void *tzp)
+int
+gettimeofday (struct timeval *tp, void *tzp)
 {
-  return get_process_stats(tp, PS_SELF, 0, 0);
+    return get_process_stats (tp, PS_SELF, 0, 0);
 }
 #endif /* HAVE_GET_PROCESS_STATS */
 
@@ -608,149 +677,178 @@ mc_realpath (const char *path, char resolved_path[])
     int n;
 
     /* Make a copy of the source path since we may need to modify it. */
-    if (strlen (path) >= PATH_MAX - 2) {
-	errno = ENAMETOOLONG;
-	return NULL;
+    if (strlen (path) >= PATH_MAX - 2)
+    {
+        errno = ENAMETOOLONG;
+        return NULL;
     }
     strcpy (copy_path, path);
     path = copy_path;
     max_path = copy_path + PATH_MAX - 2;
     /* If it's a relative pathname use getwd for starters. */
-    if (*path != '/') {
-	/* Ohoo... */
-#ifdef HAVE_GETCWD
-	getcwd (new_path, PATH_MAX - 1);
-#else
-	getwd (new_path);
-#endif
-	new_path += strlen (new_path);
-	if (new_path[-1] != '/')
-	    *new_path++ = '/';
-    } else {
-	*new_path++ = '/';
-	path++;
+    if (*path != '/')
+    {
+
+        new_path = g_get_current_dir ();
+        if (new_path == NULL)
+        {
+            strcpy (got_path, "");
+        }
+        else
+        {
+            g_snprintf (got_path, PATH_MAX, "%s", new_path);
+            g_free (new_path);
+            new_path = got_path;
+        }
+
+        new_path += strlen (got_path);
+        if (new_path[-1] != '/')
+            *new_path++ = '/';
+    }
+    else
+    {
+        *new_path++ = '/';
+        path++;
     }
     /* Expand each slash-separated pathname component. */
-    while (*path != '\0') {
-	/* Ignore stray "/". */
-	if (*path == '/') {
-	    path++;
-	    continue;
-	}
-	if (*path == '.') {
-	    /* Ignore ".". */
-	    if (path[1] == '\0' || path[1] == '/') {
-		path++;
-		continue;
-	    }
-	    if (path[1] == '.') {
-		if (path[2] == '\0' || path[2] == '/') {
-		    path += 2;
-		    /* Ignore ".." at root. */
-		    if (new_path == got_path + 1)
-			continue;
-		    /* Handle ".." by backing up. */
-		    while ((--new_path)[-1] != '/');
-		    continue;
-		}
-	    }
-	}
-	/* Safely copy the next pathname component. */
-	while (*path != '\0' && *path != '/') {
-	    if (path > max_path) {
-		errno = ENAMETOOLONG;
-		return NULL;
-	    }
-	    *new_path++ = *path++;
-	}
+    while (*path != '\0')
+    {
+        /* Ignore stray "/". */
+        if (*path == '/')
+        {
+            path++;
+            continue;
+        }
+        if (*path == '.')
+        {
+            /* Ignore ".". */
+            if (path[1] == '\0' || path[1] == '/')
+            {
+                path++;
+                continue;
+            }
+            if (path[1] == '.')
+            {
+                if (path[2] == '\0' || path[2] == '/')
+                {
+                    path += 2;
+                    /* Ignore ".." at root. */
+                    if (new_path == got_path + 1)
+                        continue;
+                    /* Handle ".." by backing up. */
+                    while ((--new_path)[-1] != '/');
+                    continue;
+                }
+            }
+        }
+        /* Safely copy the next pathname component. */
+        while (*path != '\0' && *path != '/')
+        {
+            if (path > max_path)
+            {
+                errno = ENAMETOOLONG;
+                return NULL;
+            }
+            *new_path++ = *path++;
+        }
 #ifdef S_IFLNK
-	/* Protect against infinite loops. */
-	if (readlinks++ > MAXSYMLINKS) {
-	    errno = ELOOP;
-	    return NULL;
-	}
-	/* See if latest pathname component is a symlink. */
-	*new_path = '\0';
-	n = readlink (got_path, link_path, PATH_MAX - 1);
-	if (n < 0) {
-	    /* EINVAL means the file exists but isn't a symlink. */
-	    if (errno != EINVAL) {
-		/* Make sure it's null terminated. */
-		*new_path = '\0';
-		strcpy (resolved_path, got_path);
-		return NULL;
-	    }
-	} else {
-	    /* Note: readlink doesn't add the null byte. */
-	    link_path[n] = '\0';
-	    if (*link_path == '/')
-		/* Start over for an absolute symlink. */
-		new_path = got_path;
-	    else
-		/* Otherwise back up over this component. */
-		while (*(--new_path) != '/');
-	    /* Safe sex check. */
-	    if (strlen (path) + n >= PATH_MAX - 2) {
-		errno = ENAMETOOLONG;
-		return NULL;
-	    }
-	    /* Insert symlink contents into path. */
-	    strcat (link_path, path);
-	    strcpy (copy_path, link_path);
-	    path = copy_path;
-	}
-#endif				/* S_IFLNK */
-	*new_path++ = '/';
+        /* Protect against infinite loops. */
+        if (readlinks++ > MAXSYMLINKS)
+        {
+            errno = ELOOP;
+            return NULL;
+        }
+        /* See if latest pathname component is a symlink. */
+        *new_path = '\0';
+        n = readlink (got_path, link_path, PATH_MAX - 1);
+        if (n < 0)
+        {
+            /* EINVAL means the file exists but isn't a symlink. */
+            if (errno != EINVAL)
+            {
+                /* Make sure it's null terminated. */
+                *new_path = '\0';
+                strcpy (resolved_path, got_path);
+                return NULL;
+            }
+        }
+        else
+        {
+            /* Note: readlink doesn't add the null byte. */
+            link_path[n] = '\0';
+            if (*link_path == '/')
+                /* Start over for an absolute symlink. */
+                new_path = got_path;
+            else
+                /* Otherwise back up over this component. */
+                while (*(--new_path) != '/');
+            /* Safe sex check. */
+            if (strlen (path) + n >= PATH_MAX - 2)
+            {
+                errno = ENAMETOOLONG;
+                return NULL;
+            }
+            /* Insert symlink contents into path. */
+            strcat (link_path, path);
+            strcpy (copy_path, link_path);
+            path = copy_path;
+        }
+#endif /* S_IFLNK */
+        *new_path++ = '/';
     }
     /* Delete trailing slash but don't whomp a lone slash. */
     if (new_path != got_path + 1 && new_path[-1] == '/')
-	new_path--;
+        new_path--;
     /* Make sure it's null terminated. */
     *new_path = '\0';
     strcpy (resolved_path, got_path);
     return resolved_path;
-#endif	/* USE_SYSTEM_REALPATH */
+#endif /* USE_SYSTEM_REALPATH */
 }
 
 /* Return the index of the permissions triplet */
 int
-get_user_permissions (struct stat *st) {
+get_user_permissions (struct stat *st)
+{
     static gboolean initialized = FALSE;
     static gid_t *groups;
     static int ngroups;
     static uid_t uid;
     int i;
 
-    if (!initialized) {
-	uid = geteuid ();
+    if (!initialized)
+    {
+        uid = geteuid ();
 
-	ngroups = getgroups (0, NULL);
-	if (ngroups == -1)
-	    ngroups = 0;	/* ignore errors */
+        ngroups = getgroups (0, NULL);
+        if (ngroups == -1)
+            ngroups = 0;        /* ignore errors */
 
-	/* allocate space for one element in addition to what
-	 * will be filled by getgroups(). */
-	groups = g_new (gid_t, ngroups + 1);
+        /* allocate space for one element in addition to what
+         * will be filled by getgroups(). */
+        groups = g_new (gid_t, ngroups + 1);
 
-	if (ngroups != 0) {
-	    ngroups = getgroups (ngroups, groups);
-	    if (ngroups == -1)
-		ngroups = 0;	/* ignore errors */
-	}
+        if (ngroups != 0)
+        {
+            ngroups = getgroups (ngroups, groups);
+            if (ngroups == -1)
+                ngroups = 0;    /* ignore errors */
+        }
 
-	/* getgroups() may or may not return the effective group ID,
-	 * so we always include it at the end of the list. */
-	groups[ngroups++] = getegid ();
+        /* getgroups() may or may not return the effective group ID,
+         * so we always include it at the end of the list. */
+        groups[ngroups++] = getegid ();
 
-	initialized = TRUE;
+        initialized = TRUE;
     }
 
     if (st->st_uid == uid || uid == 0)
-       return 0;
+        return 0;
 
-    for (i = 0; i < ngroups; i++) {
-	if (st->st_gid == groups[i])
-	    return 1;
+    for (i = 0; i < ngroups; i++)
+    {
+        if (st->st_gid == groups[i])
+            return 1;
     }
 
     return 2;

lib/vfs/mc-vfs/direntry.c

@@ -1261,8 +1261,10 @@ vfs_s_get_line (struct vfs_class *me, int sock, char *buf, int buf_len, char ter
             return 0;
         if (logfile)
         {
-            fwrite (buf, 1, 1, logfile);
-            fflush (logfile);
+            size_t ret1;
+            int ret2;
+            ret1 = fwrite (buf, 1, 1, logfile);
+            ret2 = fflush (logfile);
         }
         if (*buf == term)
         {
@@ -1277,8 +1279,10 @@ vfs_s_get_line (struct vfs_class *me, int sock, char *buf, int buf_len, char ter
     {
         if (logfile)
         {
-            fwrite (&c, 1, 1, logfile);
-            fflush (logfile);
+            size_t ret1;
+            int ret2;
+            ret1 = fwrite (&c, 1, 1, logfile);
+            ret2 = fflush (logfile);
         }
         if (c == '\n')
             return 1;

lib/vfs/mc-vfs/extfs.c

@@ -597,8 +597,7 @@ extfs_which (struct vfs_class *me, const char *path)
         info = &g_array_index (extfs_plugins, extfs_plugin_info_t, i);
 
         if ((strncmp (path, info->prefix, path_len) == 0)
-                && ((info->prefix[path_len] == '\0')
-                    || (info->prefix[path_len] == '+')))
+            && ((info->prefix[path_len] == '\0') || (info->prefix[path_len] == '+')))
             return i;
     }
     return -1;
@@ -706,7 +705,7 @@ extfs_resolve_symlinks_int (struct entry *entry, GSList * list)
 
         looping = g_slist_prepend (list, entry);
         pent = extfs_find_entry_int (entry->dir, entry->inode->linkname, looping, FALSE, FALSE);
-        g_slist_delete_link (looping, looping);
+        looping = g_slist_delete_link (looping, looping);
 
         if (pent == NULL)
             my_errno = ENOENT;

lib/vfs/mc-vfs/fish.c

@@ -159,8 +159,9 @@ fish_command (struct vfs_class *me, struct vfs_s_super *super, int wait_reply, c
 
     if (logfile)
     {
-        fwrite (str, strlen (str), 1, logfile);
-        fflush (logfile);
+        size_t ret;
+        ret = fwrite (str, strlen (str), 1, logfile);
+        ret = fflush (logfile);
     }
 
     tty_enable_interrupt_key ();
@@ -217,15 +218,13 @@ fish_pipeopen (struct vfs_s_super *super, const char *path, const char *argv[])
     }
     else
     {
-        close (0);
-        dup (fileset1[0]);
+        res = dup2 (fileset1[0], 0);
         close (fileset1[0]);
         close (fileset1[1]);
-        close (1);
+        res = dup2 (fileset2[1], 1);
         close (2);
-        dup (fileset2[1]);
         /* stderr to /dev/null */
-        open ("/dev/null", O_WRONLY);
+        res = open ("/dev/null", O_WRONLY);
         close (fileset2[0]);
         close (fileset2[1]);
         execvp (path, const_cast (char **, argv));
@@ -294,7 +293,6 @@ fish_open_archive_int (struct vfs_class *me, struct vfs_s_super *super)
         print_vfs_message ("%s", answer);
         if (strstr (answer, "assword"))
         {
-
             /* Currently, this does not work. ssh reads passwords from
                /dev/tty, not from stdin :-(. */
 
@@ -312,8 +310,16 @@ fish_open_archive_int (struct vfs_class *me, struct vfs_s_super *super)
                 SUP.password = op;
             }
             print_vfs_message (_("fish: Sending password..."));
-            write (SUP.sockw, SUP.password, strlen (SUP.password));
-            write (SUP.sockw, "\n", 1);
+
+            {
+                size_t str_len;
+                str_len = strlen (SUP.password);
+                if ((write (SUP.sockw, SUP.password, str_len) != (ssize_t) str_len)
+                    || (write (SUP.sockw, "\n", 1) != 1))
+                {
+                    ERRNOR (EIO, -1);
+                }
+            }
         }
     }
 
@@ -757,6 +763,7 @@ fish_file_store (struct vfs_class *me, struct vfs_s_fh *fh, char *name, char *lo
 
     /* FIXME: File size is limited to ULONG_MAX */
     if (!fh->u.fish.append)
+    {
         /* *INDENT-OFF* */
         n = fish_command (me, super, WAIT_REPLY,
                 "#STOR %lu /%s\n"
@@ -781,7 +788,9 @@ fish_file_store (struct vfs_class *me, struct vfs_s_fh *fh, char *name, char *lo
                 (unsigned long) s.st_size, quoted_name,
                 quoted_name, (unsigned long) s.st_size, (unsigned long) s.st_size);
         /* *INDENT-ON* */
+    }
     else
+    {
         /* *INDENT-OFF* */
         n = fish_command (me, super, WAIT_REPLY,
                 "#STOR %lu /%s\n"
@@ -799,7 +808,7 @@ fish_file_store (struct vfs_class *me, struct vfs_s_fh *fh, char *name, char *lo
                 (unsigned long) s.st_size, quoted_name,
                 quoted_name, (unsigned long) s.st_size);
         /* *INDENT-ON* */
-
+    }
     if (n != PRELIM)
     {
         close (h);
@@ -1024,8 +1033,8 @@ fish_send_command (struct vfs_class *me, struct vfs_s_super *super, const char *
 static int
 fish_chmod (struct vfs_class *me, const char *path, int mode)
 {
-    PREFIX
     /* *INDENT-OFF* */
+    PREFIX
     g_snprintf (buf, sizeof (buf),
                 "#CHMOD %4.4o /%s\n"
                 "if chmod %4.4o /%s 2>/dev/null; then\n"
@@ -1034,10 +1043,11 @@ fish_chmod (struct vfs_class *me, const char *path, int mode)
                     "echo '### 500'\n"
                 "fi\n",
                 mode & 07777, rpath, mode & 07777, rpath);
-    /* *INDENT-ON* */
     POSTFIX (OPT_FLUSH);
+    /* *INDENT-ON* */
 }
 
+/* *INDENT-OFF* */
 #define FISH_OP(name, string) \
 static int fish_##name (struct vfs_class *me, const char *path1, const char *path2) \
 { \
@@ -1066,7 +1076,6 @@ static int fish_##name (struct vfs_class *me, const char *path1, const char *pat
     return fish_send_command(me, super2, buf, OPT_FLUSH); \
 }
 
-/* *INDENT-OFF* */
 FISH_OP (rename,
         "#RENAME /%s /%s\n"
         "if mv /%s /%s 2>/dev/null; then\n"
@@ -1119,8 +1128,8 @@ fish_chown (struct vfs_class *me, const char *path, int owner, int group)
     sowner = pw->pw_name;
     sgroup = gr->gr_name;
     {
-        PREFIX
         /* *INDENT-OFF* */
+        PREFIX
         g_snprintf (buf, sizeof (buf),
                     "#CHOWN %s:%s /%s\n"
                     "if chown %s:%s /%s 2>/dev/null; then\n"
@@ -1139,9 +1148,9 @@ fish_chown (struct vfs_class *me, const char *path, int owner, int group)
 static int
 fish_unlink (struct vfs_class *me, const char *path)
 {
+    /* *INDENT-OFF* */
     PREFIX
 
-    /* *INDENT-OFF* */
     g_snprintf (buf, sizeof (buf),
                 "#DELE /%s\n"
                 "if rm -f /%s 2>/dev/null; then\n"
@@ -1158,9 +1167,9 @@ fish_unlink (struct vfs_class *me, const char *path)
 static int
 fish_exists (struct vfs_class *me, const char *path)
 {
+    /* *INDENT-OFF* */
     PREFIX
 
-    /* *INDENT-OFF* */
     g_snprintf (buf, sizeof (buf),
                 "#ISEXISTS /%s\n"
                 "ls -l /%s >/dev/null 2>/dev/null\n"
@@ -1182,9 +1191,9 @@ fish_mkdir (struct vfs_class *me, const char *path, mode_t mode)
 {
     int ret_code;
 
+    /* *INDENT-OFF* */
     PREFIX (void) mode;
 
-    /* *INDENT-OFF* */
     g_snprintf (buf, sizeof (buf),
                 "#MKD /%s\n"
                 "if mkdir /%s 2>/dev/null; then\n"
@@ -1211,8 +1220,8 @@ fish_mkdir (struct vfs_class *me, const char *path, mode_t mode)
 static int
 fish_rmdir (struct vfs_class *me, const char *path)
 {
-    PREFIX
     /* *INDENT-OFF* */
+    PREFIX
     g_snprintf (buf, sizeof (buf),
                 "#RMD /%s\n"
                 "if rmdir /%s 2>/dev/null; then\n"

lib/vfs/mc-vfs/mcfsutil.c

@@ -1,12 +1,12 @@
 /* Low-level protocol for MCFS.
-   
+
    Copyright (C) 1995, 1996 Miguel de Icaza
-   
+
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public License
    as published by the Free Software Foundation; either version 2 of
    the License, or (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
@@ -51,12 +51,12 @@
 #include <errno.h>
 
 #include "lib/global.h"
-#include "src/wtools.h"	/* message() */
-#include "src/main.h"	/* print_vfs_message */
+#include "src/wtools.h"         /* message() */
+#include "src/main.h"           /* print_vfs_message */
 #include "utilvfs.h"
 #include "mcfsutil.h"
 #include "netutil.h"
-#include "mcfs.h"	/* tcp_invalidate_socket() */
+#include "mcfs.h"               /* tcp_invalidate_socket() */
 
 #define CHECK_SIG_PIPE(sock) if (got_sigpipe) \
      { tcp_invalidate_socket (sock); return got_sigpipe = 0; }
@@ -68,13 +68,15 @@ socket_read_block (int sock, char *dest, int len)
 {
     int nread, n;
 
-    for (nread = 0; nread < len;) {
-	n = read (sock, dest + nread, len - nread);
-	if (n <= 0) {
-	    tcp_invalidate_socket (sock);
-	    return 0;
-	}
-	nread += n;
+    for (nread = 0; nread < len;)
+    {
+        n = read (sock, dest + nread, len - nread);
+        if (n <= 0)
+        {
+            tcp_invalidate_socket (sock);
+            return 0;
+        }
+        nread += n;
     }
     return 1;
 }
@@ -84,13 +86,14 @@ socket_write_block (int sock, const char *buffer, int len)
 {
     int left, status;
 
-    for (left = len; left > 0;) {
-	status = write (sock, buffer, left);
-	CHECK_SIG_PIPE (sock);
-	if (status < 0)
-	    return 0;
-	left -= status;
-	buffer += status;
+    for (left = len; left > 0;)
+    {
+        status = write (sock, buffer, left);
+        CHECK_SIG_PIPE (sock);
+        if (status < 0)
+            return 0;
+        left -= status;
+        buffer += status;
     }
     return 1;
 }
@@ -104,40 +107,58 @@ rpc_send (int sock, ...)
 
     va_start (ap, sock);
 
-    for (;;) {
-	cmd = va_arg (ap, int);
-	switch (cmd) {
-	case RPC_END:
-	    va_end (ap);
-	    return 1;
-
-	case RPC_INT:
-	    tmp = htonl (va_arg (ap, int));
-	    write (sock, &tmp, sizeof (tmp));
-	    CHECK_SIG_PIPE (sock);
-	    break;
-
-	case RPC_STRING:
-	    text = va_arg (ap, char *);
-	    len = strlen (text);
-	    tmp = htonl (len);
-	    write (sock, &tmp, sizeof (tmp));
-	    CHECK_SIG_PIPE (sock);
-	    write (sock, text, len);
-	    CHECK_SIG_PIPE (sock);
-	    break;
-
-	case RPC_BLOCK:
-	    len = va_arg (ap, int);
-	    text = va_arg (ap, char *);
-	    tmp = htonl (len);
-	    write (sock, text, len);
-	    CHECK_SIG_PIPE (sock);
-	    break;
-
-	default:
-	    vfs_die ("Unknown rpc message\n");
-	}
+    for (;;)
+    {
+        cmd = va_arg (ap, int);
+        switch (cmd)
+        {
+        case RPC_END:
+            va_end (ap);
+            return 1;
+
+        case RPC_INT:
+            tmp = htonl (va_arg (ap, int));
+            if (write (sock, &tmp, sizeof (tmp)) != sizeof (tmp))
+            {
+                vfs_die ("RPC: write failed (RPC_INT)");
+                break;
+            }
+            CHECK_SIG_PIPE (sock);
+            break;
+
+        case RPC_STRING:
+            text = va_arg (ap, char *);
+            len = strlen (text);
+            tmp = htonl (len);
+            if (write (sock, &tmp, sizeof (tmp)) != sizeof (tmp))
+            {
+                vfs_die ("RPC: write failed (RPC_STRING)");
+                break;
+            }
+            CHECK_SIG_PIPE (sock);
+            if (write (sock, text, len) != len)
+            {
+                vfs_die ("RPC: write failed (RPC_STRING)");
+                break;
+            }
+            CHECK_SIG_PIPE (sock);
+            break;
+
+        case RPC_BLOCK:
+            len = va_arg (ap, int);
+            text = va_arg (ap, char *);
+            tmp = htonl (len);
+            if (write (sock, text, len) != len)
+            {
+                vfs_die ("RPC: write failed (RPC_BLOCK)");
+                break;
+            }
+            CHECK_SIG_PIPE (sock);
+            break;
+
+        default:
+            vfs_die ("Unknown rpc message\n");
+        }
     }
 }
 
@@ -151,63 +172,70 @@ rpc_get (int sock, ...)
 
     va_start (ap, sock);
 
-    for (;;) {
-	cmd = va_arg (ap, int);
-	switch (cmd) {
-	case RPC_END:
-	    va_end (ap);
-	    return 1;
-
-	case RPC_INT:
-	    if (socket_read_block (sock, (char *) &tmp, sizeof (tmp)) == 0) {
-		va_end (ap);
-		return 0;
-	    }
-	    dest = va_arg (ap, int *);
-	    *dest = ntohl (tmp);
-	    break;
-
-	    /* returns an allocated string */
-	case RPC_LIMITED_STRING:
-	case RPC_STRING:
-	    if (socket_read_block (sock, (char *) &tmp, sizeof (tmp)) == 0) {
-		va_end (ap);
-		return 0;
-	    }
-	    len = ntohl (tmp);
-	    if (cmd == RPC_LIMITED_STRING)
-		if (len > 16 * 1024) {
-		    /* silently die */
-		    abort ();
-		}
-	    if (len > 128 * 1024)
-		abort ();
-
-	    /* Don't use glib functions here - this code is used by mcserv */
-	    text = malloc (len + 1);
-	    if (socket_read_block (sock, text, len) == 0) {
-		free (text);
-		va_end (ap);
-		return 0;
-	    }
-	    text[len] = '\0';
-
-	    str_dest = va_arg (ap, char **);
-	    *str_dest = text;
-	    break;
-
-	case RPC_BLOCK:
-	    len = va_arg (ap, int);
-	    text = va_arg (ap, char *);
-	    if (socket_read_block (sock, text, len) == 0) {
-		va_end (ap);
-		return 0;
-	    }
-	    break;
-
-	default:
-	    vfs_die ("Unknown rpc message\n");
-	}
+    for (;;)
+    {
+        cmd = va_arg (ap, int);
+        switch (cmd)
+        {
+        case RPC_END:
+            va_end (ap);
+            return 1;
+
+        case RPC_INT:
+            if (socket_read_block (sock, (char *) &tmp, sizeof (tmp)) == 0)
+            {
+                va_end (ap);
+                return 0;
+            }
+            dest = va_arg (ap, int *);
+            *dest = ntohl (tmp);
+            break;
+
+            /* returns an allocated string */
+        case RPC_LIMITED_STRING:
+        case RPC_STRING:
+            if (socket_read_block (sock, (char *) &tmp, sizeof (tmp)) == 0)
+            {
+                va_end (ap);
+                return 0;
+            }
+            len = ntohl (tmp);
+            if (cmd == RPC_LIMITED_STRING)
+                if (len > 16 * 1024)
+                {
+                    /* silently die */
+                    abort ();
+                }
+            if (len > 128 * 1024)
+                abort ();
+
+            /* Don't use glib functions here - this code is used by mcserv */
+            text = malloc (len + 1);
+            if (socket_read_block (sock, text, len) == 0)
+            {
+                free (text);
+                va_end (ap);
+                return 0;
+            }
+            text[len] = '\0';
+
+            str_dest = va_arg (ap, char **);
+            *str_dest = text;
+            break;
+
+        case RPC_BLOCK:
+            len = va_arg (ap, int);
+            text = va_arg (ap, char *);
+            if (socket_read_block (sock, text, len) == 0)
+            {
+                va_end (ap);
+                return 0;
+            }
+            break;
+
+        default:
+            vfs_die ("Unknown rpc message\n");
+        }
     }
 }
-#endif				/* ENABLE_VFS_MCFS || ENABLE_MCSERVER */
+#endif /* ENABLE_VFS_MCFS || ENABLE_MCSERVER */

src/background.c

@@ -3,14 +3,14 @@
 /* Background support.
    Copyright (C) 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
    Free Software Foundation, Inc.
-   
+
    Written by: 1996 Miguel de Icaza
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
@@ -39,18 +39,19 @@
 
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <sys/wait.h>	/* waitpid() */
+#include <sys/wait.h>           /* waitpid() */
 #include <unistd.h>
 #include <fcntl.h>
 
 #include "lib/global.h"
 #include "background.h"
 #include "wtools.h"
-#include "layout.h"	/* repaint_screen() */
-#include "fileopctx.h"	/* FileOpContext */
-#include "lib/tty/key.h"	/* add_select_channel(), delete_select_channel() */
+#include "layout.h"             /* repaint_screen() */
+#include "fileopctx.h"          /* FileOpContext */
+#include "lib/tty/key.h"        /* add_select_channel(), delete_select_channel() */
 
-enum ReturnType {
+enum ReturnType
+{
     Return_String,
     Return_Integer
 };
@@ -64,26 +65,25 @@ static int parent_fd;
 /* File descriptor for messages from our parent */
 static int from_parent_fd;
 
-#define MAXCALLARGS 4		/* Number of arguments supported */
+#define MAXCALLARGS 4           /* Number of arguments supported */
 
 struct TaskList *task_list = NULL;
 
 static int background_attention (int fd, void *closure);
-    
+
 static void
-register_task_running (FileOpContext *ctx, pid_t pid, int fd, int to_child,
-					   char *info)
+register_task_running (FileOpContext * ctx, pid_t pid, int fd, int to_child, char *info)
 {
     TaskList *new;
 
     new = g_new (TaskList, 1);
-    new->pid   = pid;
-    new->info  = info;
+    new->pid = pid;
+    new->info = info;
     new->state = Task_Running;
-    new->next  = task_list;
-    new->fd    = fd;
+    new->next = task_list;
+    new->fd = fd;
     new->to_child_fd = to_child;
-    task_list  = new;
+    task_list = new;
 
     add_select_channel (fd, background_attention, ctx);
 }
@@ -94,18 +94,20 @@ destroy_task_and_return_fd (pid_t pid)
     TaskList *p = task_list;
     TaskList *prev = 0;
 
-    while (p){
-	if (p->pid == pid){
-	    if (prev)
-		prev->next = p->next;
-	    else
-		task_list = p->next;
-	    g_free (p->info);
-	    g_free (p);
-	    return p->fd;
-	}
-	prev = p;
-	p = p->next;
+    while (p)
+    {
+        if (p->pid == pid)
+        {
+            if (prev)
+                prev->next = p->next;
+            else
+                task_list = p->next;
+            g_free (p->info);
+            g_free (p);
+            return p->fd;
+        }
+        prev = p;
+        p = p->next;
     }
 
     /* pid not found */
@@ -115,16 +117,16 @@ destroy_task_and_return_fd (pid_t pid)
 void
 unregister_task_running (pid_t pid, int fd)
 {
-    destroy_task_and_return_fd(pid);
+    destroy_task_and_return_fd (pid);
     delete_select_channel (fd);
 }
 
 void
 unregister_task_with_pid (pid_t pid)
 {
-    int fd = destroy_task_and_return_fd(pid);
+    int fd = destroy_task_and_return_fd (pid);
     if (fd != -1)
-	delete_select_channel (fd);
+        delete_select_channel (fd);
 }
 
 /*
@@ -138,51 +140,56 @@ unregister_task_with_pid (pid_t pid)
 int
 do_background (struct FileOpContext *ctx, char *info)
 {
-    int comm[2];		/* control connection stream */
-    int back_comm[2];	/* back connection */
+    int comm[2];                /* control connection stream */
+    int back_comm[2];           /* back connection */
     pid_t pid;
 
     if (pipe (comm) == -1)
-	return -1;
+        return -1;
 
     if (pipe (back_comm) == -1)
-	return -1;
-
-    if ((pid = fork ()) == -1) {
-	int saved_errno = errno;
-	(void) close (comm[0]);
-	(void) close (comm[1]);
-	(void) close (back_comm[0]);
-	(void) close (back_comm[1]);
-	errno = saved_errno;
-	return -1;
+        return -1;
+
+    if ((pid = fork ()) == -1)
+    {
+        int saved_errno = errno;
+        (void) close (comm[0]);
+        (void) close (comm[1]);
+        (void) close (back_comm[0]);
+        (void) close (back_comm[1]);
+        errno = saved_errno;
+        return -1;
     }
 
-    if (pid == 0) {
-	int nullfd;
+    if (pid == 0)
+    {
+        int nullfd;
 
-	parent_fd = comm[1];
-	from_parent_fd = back_comm[0];
+        parent_fd = comm[1];
+        from_parent_fd = back_comm[0];
 
-	we_are_background = 1;
-	current_dlg = NULL;
+        we_are_background = 1;
+        current_dlg = NULL;
 
-	/* Make stdin/stdout/stderr point somewhere */
-	close (0);
-	close (1);
-	close (2);
+        /* Make stdin/stdout/stderr point somewhere */
+        close (0);
+        close (1);
+        close (2);
 
-	if ((nullfd = open ("/dev/null", O_RDWR)) != -1) {
-	    while (dup2 (nullfd, 0) == -1 && errno == EINTR);
-	    while (dup2 (nullfd, 1) == -1 && errno == EINTR);
-	    while (dup2 (nullfd, 2) == -1 && errno == EINTR);
-	}
+        if ((nullfd = open ("/dev/null", O_RDWR)) != -1)
+        {
+            while (dup2 (nullfd, 0) == -1 && errno == EINTR);
+            while (dup2 (nullfd, 1) == -1 && errno == EINTR);
+            while (dup2 (nullfd, 2) == -1 && errno == EINTR);
+        }
 
-	return 0;
-    } else {
-	ctx->pid = pid;
-	register_task_running (ctx, pid, comm[0], back_comm[1], info);
-	return 1;
+        return 0;
+    }
+    else
+    {
+        ctx->pid = pid;
+        register_task_running (ctx, pid, comm[0], back_comm[1], info);
+        return 1;
     }
 }
 
@@ -231,174 +238,211 @@ background_attention (int fd, void *closure)
 {
     FileOpContext *ctx;
     int have_ctx;
-    union 
+    union
     {
-      int (*have_ctx0)(int);
-      int (*have_ctx1)(int, char *);
-      int (*have_ctx2)(int, char *, char *);
-      int (*have_ctx3)(int, char *, char *, char *);
-      int (*have_ctx4)(int, char *, char *, char *, char *);
-
-      int (*non_have_ctx0)(FileOpContext *, int);
-      int (*non_have_ctx1)(FileOpContext *, int, char *);
-      int (*non_have_ctx2)(FileOpContext *, int, char *, char *);
-      int (*non_have_ctx3)(FileOpContext *, int, char *, char *, char *);
-      int (*non_have_ctx4)(FileOpContext *, int, char *, char *, char *, char *);
-
-      char * (*ret_str0)();
-      char * (*ret_str1)(char *);
-      char * (*ret_str2)(char *, char *);
-      char * (*ret_str3)(char *, char *, char *);
-      char * (*ret_str4)(char *, char *, char *, char *);
-
-      void *pointer;
+        int (*have_ctx0) (int);
+        int (*have_ctx1) (int, char *);
+        int (*have_ctx2) (int, char *, char *);
+        int (*have_ctx3) (int, char *, char *, char *);
+        int (*have_ctx4) (int, char *, char *, char *, char *);
+
+        int (*non_have_ctx0) (FileOpContext *, int);
+        int (*non_have_ctx1) (FileOpContext *, int, char *);
+        int (*non_have_ctx2) (FileOpContext *, int, char *, char *);
+        int (*non_have_ctx3) (FileOpContext *, int, char *, char *, char *);
+        int (*non_have_ctx4) (FileOpContext *, int, char *, char *, char *, char *);
+
+        char *(*ret_str0) ();
+        char *(*ret_str1) (char *);
+        char *(*ret_str2) (char *, char *);
+        char *(*ret_str3) (char *, char *, char *);
+        char *(*ret_str4) (char *, char *, char *, char *);
+
+        void *pointer;
     } routine;
-/*    void *routine;*/
-    int  argc, i, result, status;
-    char *data [MAXCALLARGS];
-    ssize_t bytes;
-	struct TaskList *p;
-	int to_child_fd = -1;
+    /*    void *routine; */
+    int argc, i, result, status;
+    char *data[MAXCALLARGS];
+    ssize_t bytes, ret;
+    struct TaskList *p;
+    int to_child_fd = -1;
     enum ReturnType type;
 
     ctx = closure;
 
     bytes = read (fd, &routine.pointer, sizeof (routine));
-    if (bytes == -1 || (size_t) bytes < (sizeof (routine))) {
-	const char *background_process_error = _(" Background process error ");
+    if (bytes == -1 || (size_t) bytes < (sizeof (routine)))
+    {
+        const char *background_process_error = _(" Background process error ");
 
-	unregister_task_running (ctx->pid, fd);
-	if (!waitpid (ctx->pid, &status, WNOHANG)) {
-	    /* the process is still running, but it misbehaves - kill it */
-	    kill (ctx->pid, SIGTERM);
-	    message (D_ERROR, background_process_error, _(" Unknown error in child "));
-	    return 0;
-	}
+        unregister_task_running (ctx->pid, fd);
+        if (!waitpid (ctx->pid, &status, WNOHANG))
+        {
+            /* the process is still running, but it misbehaves - kill it */
+            kill (ctx->pid, SIGTERM);
+            message (D_ERROR, background_process_error, _(" Unknown error in child "));
+            return 0;
+        }
 
-	/* 0 means happy end */
-	if (WIFEXITED (status) && (WEXITSTATUS (status) == 0))
-	    return 0;
+        /* 0 means happy end */
+        if (WIFEXITED (status) && (WEXITSTATUS (status) == 0))
+            return 0;
 
-	message (D_ERROR, background_process_error, _(" Child died unexpectedly "));
+        message (D_ERROR, background_process_error, _(" Child died unexpectedly "));
 
-	return 0;
+        return 0;
     }
 
-    read (fd, &argc, sizeof (argc));
-    if (argc > MAXCALLARGS){
-	message (D_ERROR, _(" Background protocol error "),
-		 _(" Background process sent us a request for more arguments \n"
-		 " than we can handle. \n"));
+    if ((read (fd, &argc, sizeof (argc)) != sizeof (argc)) ||
+        (read (fd, &type, sizeof (type)) != sizeof (type)) ||
+        (read (fd, &have_ctx, sizeof (have_ctx)) != sizeof (have_ctx)))
+    {
+        message (D_ERROR, _(" Background protocol error "), _("Reading failed"));
+        return 0;
     }
-    read (fd, &type, sizeof (type));
-    read (fd, &have_ctx, sizeof (have_ctx));
-    if (have_ctx)
-	    read (fd, ctx, sizeof (FileOpContext));
 
-    for (i = 0; i < argc; i++){
-	int size;
+    if (argc > MAXCALLARGS)
+    {
+        message (D_ERROR, _(" Background protocol error "),
+                 _(" Background process sent us a request for more arguments \n"
+                   " than we can handle. \n"));
+    }
 
-	read (fd, &size, sizeof (size));
-	data [i] = g_malloc (size+1);
-	read (fd, data [i], size);
+    if (have_ctx)
+    {
+        if (read (fd, ctx, sizeof (FileOpContext)) != sizeof (FileOpContext))
+        {
+            message (D_ERROR, _(" Background protocol error "), _("Reading failed"));
+            return 0;
+        }
+    }
 
-	data [i][size] = 0;	/* NULL terminate the blocks (they could be strings) */
+    for (i = 0; i < argc; i++)
+    {
+        int size;
+
+        if (read (fd, &size, sizeof (size)) != sizeof (size))
+        {
+            message (D_ERROR, _(" Background protocol error "), _("Reading failed"));
+            return 0;
+        }
+        data[i] = g_malloc (size + 1);
+        if (read (fd, data[i], size) != size)
+        {
+            message (D_ERROR, _(" Background protocol error "), _("Reading failed"));
+            return 0;
+        }
+        data[i][size] = 0;      /* NULL terminate the blocks (they could be strings) */
     }
 
-	/* Find child task info by descriptor */
-	/* Find before call, because process can destroy self after */
-	for (p = task_list; p; p = p->next) {
-		if (p->fd == fd)
-			break;
-	}
+    /* Find child task info by descriptor */
+    /* Find before call, because process can destroy self after */
+    for (p = task_list; p; p = p->next)
+    {
+        if (p->fd == fd)
+            break;
+    }
 
-	if (p) to_child_fd = p->to_child_fd;
+    if (p)
+        to_child_fd = p->to_child_fd;
 
     if (to_child_fd == -1)
-	message (D_ERROR, _(" Background process error "), _(" Unknown error in child "));
+        message (D_ERROR, _(" Background process error "), _(" Unknown error in child "));
 
     /* Handle the call */
-    if (type == Return_Integer){
-	if (!have_ctx)
-	    switch (argc){
-	    case 0:
-		result = routine.have_ctx0 (Background);
-		break;
-	    case 1:
-		result = routine.have_ctx1 (Background, data [0]);
-		break;
-	    case 2:
-		result = routine.have_ctx2 (Background, data [0], data [1]);
-		break;
-	    case 3:
-		result = routine.have_ctx3 (Background, data [0], data [1], data [2]);
-		break;
-	    case 4:
-		result = routine.have_ctx4 (Background, data [0], data [1], data [2], data [3]);
-		break;
-	    }
-	else
-	    switch (argc){
-	    case 0:
-		result = routine.non_have_ctx0 (ctx, Background);
-		break;
-	    case 1:
-		result = routine.non_have_ctx1 (ctx, Background, data [0]);
-		break;
-	    case 2:
-		result = routine.non_have_ctx2 (ctx, Background, data [0], data [1]);
-		break;
-	    case 3:
-		result = routine.non_have_ctx3 (ctx, Background, data [0], data [1], data [2]);
-		break;
-	    case 4:
-		result = routine.non_have_ctx4 (ctx, Background, data [0], data [1], data [2], data [3]);
-		break;
-	    }
-
-	/* Send the result code and the value for shared variables */
-	write (to_child_fd, &result, sizeof (int));
-	if (have_ctx && to_child_fd != -1)
-	    write (to_child_fd, ctx, sizeof (FileOpContext));
-    } else if (type == Return_String) {
-	int len;
-	char *resstr = NULL;
-
-	/* FIXME: string routines should also use the Foreground/Background
-	 * parameter.  Currently, this is not used here
-	 */
-	switch (argc){
-	case 0:
-	    resstr = routine.ret_str0 ();
-	    break;
-	case 1:
-	    resstr = routine.ret_str1 (data [0]);
-	    break;
-	case 2:
-	    resstr = routine.ret_str2 (data [0], data [1]);
-	    break;
-	case 3:
-	    resstr = routine.ret_str3 (data [0], data [1], data [2]);
-	    break;
-	case 4:
-	    resstr = routine.ret_str4 (data [0], data [1], data [2], data [3]);
-	    break;
-	default: g_assert_not_reached();
-	}
-	if (resstr){
-	    len = strlen (resstr);
-	    write (to_child_fd, &len, sizeof (len));
-	    if (len){
-		write (to_child_fd, resstr, len);
-		g_free (resstr);
-	    }
-	} else {
-	    len = 0;
-	    write (to_child_fd, &len, sizeof (len));
-	}
+    if (type == Return_Integer)
+    {
+        if (!have_ctx)
+            switch (argc)
+            {
+            case 0:
+                result = routine.have_ctx0 (Background);
+                break;
+            case 1:
+                result = routine.have_ctx1 (Background, data[0]);
+                break;
+            case 2:
+                result = routine.have_ctx2 (Background, data[0], data[1]);
+                break;
+            case 3:
+                result = routine.have_ctx3 (Background, data[0], data[1], data[2]);
+                break;
+            case 4:
+                result = routine.have_ctx4 (Background, data[0], data[1], data[2], data[3]);
+                break;
+            }
+        else
+            switch (argc)
+            {
+            case 0:
+                result = routine.non_have_ctx0 (ctx, Background);
+                break;
+            case 1:
+                result = routine.non_have_ctx1 (ctx, Background, data[0]);
+                break;
+            case 2:
+                result = routine.non_have_ctx2 (ctx, Background, data[0], data[1]);
+                break;
+            case 3:
+                result = routine.non_have_ctx3 (ctx, Background, data[0], data[1], data[2]);
+                break;
+            case 4:
+                result =
+                    routine.non_have_ctx4 (ctx, Background, data[0], data[1], data[2], data[3]);
+                break;
+            }
+
+        /* Send the result code and the value for shared variables */
+        ret = write (to_child_fd, &result, sizeof (int));
+        if (have_ctx && to_child_fd != -1)
+            ret = write (to_child_fd, ctx, sizeof (FileOpContext));
+    }
+    else if (type == Return_String)
+    {
+        int len;
+        char *resstr = NULL;
+
+        /* FIXME: string routines should also use the Foreground/Background
+         * parameter.  Currently, this is not used here
+         */
+        switch (argc)
+        {
+        case 0:
+            resstr = routine.ret_str0 ();
+            break;
+        case 1:
+            resstr = routine.ret_str1 (data[0]);
+            break;
+        case 2:
+            resstr = routine.ret_str2 (data[0], data[1]);
+            break;
+        case 3:
+            resstr = routine.ret_str3 (data[0], data[1], data[2]);
+            break;
+        case 4:
+            resstr = routine.ret_str4 (data[0], data[1], data[2], data[3]);
+            break;
+        default:
+            g_assert_not_reached ();
+        }
+        if (resstr)
+        {
+            len = strlen (resstr);
+            ret = write (to_child_fd, &len, sizeof (len));
+            if (len)
+            {
+                write (to_child_fd, resstr, len);
+            }
+            g_free (resstr);
+        }
+        else
+        {
+            len = 0;
+            ret = write (to_child_fd, &len, sizeof (len));
+        }
     }
     for (i = 0; i < argc; i++)
-	g_free (data [i]);
+        g_free (data[i]);
 
     repaint_screen ();
     return 0;
@@ -414,19 +458,20 @@ background_attention (int fd, void *closure)
  * the call be a file operation context.
  */
 static void
-parent_call_header (void *routine, int argc, enum ReturnType type, FileOpContext *ctx)
+parent_call_header (void *routine, int argc, enum ReturnType type, FileOpContext * ctx)
 {
     int have_ctx;
+    ssize_t ret;
 
     have_ctx = (ctx != NULL);
 
-    write (parent_fd, &routine, sizeof (routine));
-    write (parent_fd, &argc, sizeof (int));
-    write (parent_fd, &type, sizeof (type));
-    write (parent_fd, &have_ctx, sizeof (have_ctx));
+    ret = write (parent_fd, &routine, sizeof (routine));
+    ret = write (parent_fd, &argc, sizeof (int));
+    ret = write (parent_fd, &type, sizeof (type));
+    ret = write (parent_fd, &have_ctx, sizeof (have_ctx));
 
     if (have_ctx)
-	write (parent_fd, ctx, sizeof (FileOpContext));
+        ret = write (parent_fd, ctx, sizeof (FileOpContext));
 }
 
 int
@@ -434,22 +479,24 @@ parent_call (void *routine, struct FileOpContext *ctx, int argc, ...)
 {
     va_list ap;
     int i;
+    ssize_t ret;
 
     va_start (ap, argc);
     parent_call_header (routine, argc, Return_Integer, ctx);
-    for (i = 0; i < argc; i++) {
-	int  len;
-	void *value;
-
-	len   = va_arg (ap, int);
-	value = va_arg (ap, void *);
-	write (parent_fd, &len, sizeof (int));
-	write (parent_fd, value, len);
+    for (i = 0; i < argc; i++)
+    {
+        int len;
+        void *value;
+
+        len = va_arg (ap, int);
+        value = va_arg (ap, void *);
+        ret = write (parent_fd, &len, sizeof (int));
+        ret = write (parent_fd, value, len);
     }
 
-    read (from_parent_fd, &i, sizeof (int));
+    ret = read (from_parent_fd, &i, sizeof (int));
     if (ctx)
-	read (from_parent_fd, ctx, sizeof (FileOpContext));
+        ret = read (from_parent_fd, ctx, sizeof (FileOpContext));
 
     return i;
 }
@@ -460,25 +507,32 @@ parent_call_string (void *routine, int argc, ...)
     va_list ap;
     char *str;
     int i;
-    
+
     va_start (ap, argc);
     parent_call_header (routine, argc, Return_String, NULL);
-    for (i = 0; i < argc; i++){
-	int  len;
-	void *value;
-
-	len   = va_arg (ap, int);
-	value = va_arg (ap, void *);
-	write (parent_fd, &len, sizeof (int));
-	write (parent_fd, value, len);
+    for (i = 0; i < argc; i++)
+    {
+        int len;
+        void *value;
+
+        len = va_arg (ap, int);
+        value = va_arg (ap, void *);
+        if ((write (parent_fd, &len, sizeof (int)) != sizeof (int)) ||
+            (write (parent_fd, value, len) != len))
+            return NULL;
     }
-    read (from_parent_fd, &i, sizeof (int));
+    if (read (from_parent_fd, &i, sizeof (int)) != sizeof (int))
+        return NULL;
     if (!i)
-	return NULL;
+        return NULL;
     str = g_malloc (i + 1);
-    read (from_parent_fd, str, i);
-    str [i] = 0;
+    if (read (from_parent_fd, str, i) != i)
+    {
+        g_free (str);
+        return NULL;
+    }
+    str[i] = 0;
     return str;
 }
 
-#endif				/* WITH_BACKGROUND */
+#endif /* WITH_BACKGROUND */

src/cons.handler.c

@@ -1,12 +1,12 @@
 /* Client interface for General purpose Linux console save/restore server
    Copyright (C) 1994, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
    2006, 2007 Free Software Foundation, Inc. 
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
@@ -37,7 +37,7 @@
 #include "lib/global.h"
 
 #include "lib/tty/tty.h"
-#include "lib/skin.h"		/* tty_set_normal_attrs */
+#include "lib/skin.h"           /* tty_set_normal_attrs */
 #include "lib/tty/win.h"
 
 #include "consaver/cons.saver.h"
@@ -54,47 +54,49 @@ static int pipefd1[2] = { -1, -1 };
 static int pipefd2[2] = { -1, -1 };
 
 static void
-show_console_contents_linux (int starty, unsigned char begin_line,
-			     unsigned char end_line)
+show_console_contents_linux (int starty, unsigned char begin_line, unsigned char end_line)
 {
     unsigned char message = 0;
     unsigned short bytes = 0;
     int i;
+    ssize_t ret;
 
     /* Is tty console? */
     if (!console_flag)
-	return;
+        return;
     /* Paranoid: Is the cons.saver still running? */
-    if (cons_saver_pid < 1 || kill (cons_saver_pid, SIGCONT)) {
-	cons_saver_pid = 0;
-	console_flag = 0;
-	return;
+    if (cons_saver_pid < 1 || kill (cons_saver_pid, SIGCONT))
+    {
+        cons_saver_pid = 0;
+        console_flag = 0;
+        return;
     }
 
     /* Send command to the console handler */
     message = CONSOLE_CONTENTS;
-    write (pipefd1[1], &message, 1);
+    ret = write (pipefd1[1], &message, 1);
     /* Check for outdated cons.saver */
-    read (pipefd2[0], &message, 1);
+    ret = read (pipefd2[0], &message, 1);
     if (message != CONSOLE_CONTENTS)
-	return;
+        return;
 
     /* Send the range of lines that we want */
-    write (pipefd1[1], &begin_line, 1);
-    write (pipefd1[1], &end_line, 1);
+    ret = write (pipefd1[1], &begin_line, 1);
+    ret = write (pipefd1[1], &end_line, 1);
     /* Read the corresponding number of bytes */
-    read (pipefd2[0], &bytes, 2);
+    ret = read (pipefd2[0], &bytes, 2);
 
     /* Read the bytes and output them */
-    for (i = 0; i < bytes; i++) {
-	if ((i % COLS) == 0)
-	    tty_gotoyx (starty + (i / COLS), 0);
-	read (pipefd2[0], &message, 1);
-	tty_print_char (message);
+    for (i = 0; i < bytes; i++)
+    {
+        if ((i % COLS) == 0)
+            tty_gotoyx (starty + (i / COLS), 0);
+        ret = read (pipefd2[0], &message, 1);
+        tty_print_char (message);
     }
 
     /* Read the value of the console_flag */
-    read (pipefd2[0], &message, 1);
+    ret = read (pipefd2[0], &message, 1);
 }
 
 static void
@@ -104,91 +106,114 @@ handle_console_linux (unsigned char action)
     char *mc_conssaver;
     int status;
 
-    switch (action) {
+    switch (action)
+    {
     case CONSOLE_INIT:
-	/* Close old pipe ends in case it is the 2nd time we run cons.saver */
-	close (pipefd1[1]);
-	close (pipefd2[0]);
-	/* Create two pipes for communication */
-	pipe (pipefd1);
-	pipe (pipefd2);
-	/* Get the console saver running */
-	cons_saver_pid = fork ();
-	if (cons_saver_pid < 0) {
-	    /* Cannot fork */
-	    /* Delete pipes */
-	    close (pipefd1[1]);
-	    close (pipefd1[0]);
-	    close (pipefd2[1]);
-	    close (pipefd2[0]);
-	    console_flag = 0;
-	} else if (cons_saver_pid > 0) {
-	    /* Parent */
-	    /* Close the extra pipe ends */
-	    close (pipefd1[0]);
-	    close (pipefd2[1]);
-	    /* Was the child successful? */
-	    read (pipefd2[0], &console_flag, 1);
-	    if (!console_flag) {
-		close (pipefd1[1]);
-		close (pipefd2[0]);
-		waitpid (cons_saver_pid, &status, 0);
-	    }
-	} else {
-	    /* Child */
-	    /* Close the extra pipe ends */
-	    close (pipefd1[1]);
-	    close (pipefd2[0]);
-	    tty_name = ttyname (0);
-	    /* Bind the pipe 0 to the standard input */
-	    close (0);
-	    dup (pipefd1[0]);
-	    close (pipefd1[0]);
-	    /* Bind the pipe 1 to the standard output */
-	    close (1);
-	    dup (pipefd2[1]);
-	    close (pipefd2[1]);
-	    /* Bind standard error to /dev/null */
-	    close (2);
-	    open ("/dev/null", O_WRONLY);
-	    if (tty_name) {
-		/* Exec the console save/restore handler */
-		mc_conssaver = concat_dir_and_file (SAVERDIR, "cons.saver");
-		execl (mc_conssaver, "cons.saver", tty_name, (char *) NULL);
-	    }
-	    /* Console is not a tty or execl() failed */
-	    console_flag = 0;
-	    write (1, &console_flag, 1);
-	    _exit (3);
-	}			/* if (cons_saver_pid ...) */
-	break;
+        /* Close old pipe ends in case it is the 2nd time we run cons.saver */
+        status = close (pipefd1[1]);
+        status = close (pipefd2[0]);
+        /* Create two pipes for communication */
+        if (!((pipe (pipefd1) == 0) && ((pipe (pipefd2)) == 0)))
+        {
+            console_flag = 0;
+            break;
+        }
+        /* Get the console saver running */
+        cons_saver_pid = fork ();
+        if (cons_saver_pid < 0)
+        {
+            /* Cannot fork */
+            /* Delete pipes */
+            status = close (pipefd1[1]);
+            status = close (pipefd1[0]);
+            status = close (pipefd2[1]);
+            status = close (pipefd2[0]);
+            console_flag = 0;
+        }
+        else if (cons_saver_pid > 0)
+        {
+            /* Parent */
+            /* Close the extra pipe ends */
+            status = close (pipefd1[0]);
+            status = close (pipefd2[1]);
+            /* Was the child successful? */
+            status = read (pipefd2[0], &console_flag, 1);
+            if (!console_flag)
+            {
+                pid_t ret;
+                status = close (pipefd1[1]);
+                status = close (pipefd2[0]);
+                ret = waitpid (cons_saver_pid, &status, 0);
+            }
+        }
+        else
+        {
+            /* Child */
+            /* Close the extra pipe ends */
+            status = close (pipefd1[1]);
+            status = close (pipefd2[0]);
+            tty_name = ttyname (0);
+            /* Bind the pipe 0 to the standard input */
+            do
+            {
+                if (dup2 (pipefd1[0], 0) == -1)
+                    break;
+                status = close (pipefd1[0]);
+                /* Bind the pipe 1 to the standard output */
+                if (dup2 (pipefd2[1], 1) == -1)
+                    break;
+
+                status = close (pipefd2[1]);
+                /* Bind standard error to /dev/null */
+                status = open ("/dev/null", O_WRONLY);
+                if (dup2 (status, 2) == -1)
+                    break;
+                status = close (status);
+                if (tty_name)
+                {
+                    /* Exec the console save/restore handler */
+                    mc_conssaver = concat_dir_and_file (SAVERDIR, "cons.saver");
+                    execl (mc_conssaver, "cons.saver", tty_name, (char *) NULL);
+                }
+                /* Console is not a tty or execl() failed */
+            }
+            while (0);
+            console_flag = 0;
+            status = write (1, &console_flag, 1);
+            _exit (3);
+        }                       /* if (cons_saver_pid ...) */
+        break;
 
     case CONSOLE_DONE:
     case CONSOLE_SAVE:
     case CONSOLE_RESTORE:
-	/* Is tty console? */
-	if (!console_flag)
-	    return;
-	/* Paranoid: Is the cons.saver still running? */
-	if (cons_saver_pid < 1 || kill (cons_saver_pid, SIGCONT)) {
-	    cons_saver_pid = 0;
-	    console_flag = 0;
-	    return;
-	}
-	/* Send command to the console handler */
-	write (pipefd1[1], &action, 1);
-	if (action != CONSOLE_DONE) {
-	    /* Wait the console handler to do its job */
-	    read (pipefd2[0], &console_flag, 1);
-	}
-	if (action == CONSOLE_DONE || !console_flag) {
-	    /* We are done -> Let's clean up */
-	    close (pipefd1[1]);
-	    close (pipefd2[0]);
-	    waitpid (cons_saver_pid, &status, 0);
-	    console_flag = 0;
-	}
-	break;
+        /* Is tty console? */
+        if (!console_flag)
+            return;
+        /* Paranoid: Is the cons.saver still running? */
+        if (cons_saver_pid < 1 || kill (cons_saver_pid, SIGCONT))
+        {
+            cons_saver_pid = 0;
+            console_flag = 0;
+            return;
+        }
+        /* Send command to the console handler */
+        status = write (pipefd1[1], &action, 1);
+        if (action != CONSOLE_DONE)
+        {
+            /* Wait the console handler to do its job */
+            status = read (pipefd2[0], &console_flag, 1);
+        }
+        if (action == CONSOLE_DONE || !console_flag)
+        {
+            /* We are done -> Let's clean up */
+            pid_t ret;
+            close (pipefd1[1]);
+            close (pipefd2[0]);
+            ret = waitpid (cons_saver_pid, &status, 0);
+            console_flag = 0;
+        }
+        break;
     }
 }
 
@@ -208,18 +233,18 @@ static void
 console_init (void)
 {
     if (console_flag)
-	return;
+        return;
 
     screen_info.size = sizeof (screen_info);
     if (ioctl (FD_OUT, CONS_GETINFO, &screen_info) == -1)
-	return;
+        return;
 
     memset (&screen_shot, 0, sizeof (screen_shot));
     screen_shot.xsize = screen_info.mv_csz;
     screen_shot.ysize = screen_info.mv_rsz;
     screen_shot.buf = g_try_malloc (screen_info.mv_csz * screen_info.mv_rsz * 2);
     if (screen_shot.buf != NULL)
-	console_flag = 1;
+        console_flag = 1;
 }
 
 static void
@@ -236,7 +261,7 @@ set_attr (unsigned attr)
     bc = (attr >> 4) & 0xF;
 
     printf ("\x1B[%d;%d;3%d;4%dm", (bc & 8) ? 5 : 25, (tc & 8) ? 1 : 22,
-	    color_map[tc & 7], color_map[bc & 7]);
+            color_map[tc & 7], color_map[bc & 7]);
 }
 
 #define cursor_to(x, y) do {				\
@@ -250,15 +275,16 @@ console_restore (void)
     int i, last;
 
     if (!console_flag)
-	return;
+        return;
 
     cursor_to (0, 0);
 
     /* restoring all content up to cursor position */
     last = screen_info.mv_row * screen_info.mv_csz + screen_info.mv_col;
-    for (i = 0; i < last; ++i) {
-	set_attr ((screen_shot.buf[i] >> 8) & 0xFF);
-	putc (screen_shot.buf[i] & 0xFF, stdout);
+    for (i = 0; i < last; ++i)
+    {
+        set_attr ((screen_shot.buf[i] >> 8) & 0xFF);
+        putc (screen_shot.buf[i] & 0xFF, stdout);
     }
 
     /* restoring cursor color */
@@ -271,7 +297,7 @@ static void
 console_shutdown (void)
 {
     if (!console_flag)
-	return;
+        return;
 
     g_free (screen_shot.buf);
 
@@ -286,94 +312,101 @@ console_save (void)
     scrmap_t revmap;
 
     if (!console_flag)
-	return;
+        return;
 
     /* screen_info.size is already set in console_init() */
-    if (ioctl (FD_OUT, CONS_GETINFO, &screen_info) == -1) {
-	console_shutdown ();
-	return;
+    if (ioctl (FD_OUT, CONS_GETINFO, &screen_info) == -1)
+    {
+        console_shutdown ();
+        return;
     }
 
     /* handle console resize */
-    if (screen_info.mv_csz != screen_shot.xsize
-	|| screen_info.mv_rsz != screen_shot.ysize) {
-	console_shutdown ();
-	console_init ();
+    if (screen_info.mv_csz != screen_shot.xsize || screen_info.mv_rsz != screen_shot.ysize)
+    {
+        console_shutdown ();
+        console_init ();
     }
 
-    if (ioctl (FD_OUT, CONS_SCRSHOT, &screen_shot) == -1) {
-	console_shutdown ();
-	return;
+    if (ioctl (FD_OUT, CONS_SCRSHOT, &screen_shot) == -1)
+    {
+        console_shutdown ();
+        return;
     }
 
-    if (ioctl (FD_OUT, GIO_SCRNMAP, &map) == -1) {
-	console_shutdown ();
-	return;
+    if (ioctl (FD_OUT, GIO_SCRNMAP, &map) == -1)
+    {
+        console_shutdown ();
+        return;
     }
 
-    for (i = 0; i < 256; i++) {
-	char *p = memchr (map.scrmap, i, 256);
-	revmap.scrmap[i] = p ? p - map.scrmap : i;
+    for (i = 0; i < 256; i++)
+    {
+        char *p = memchr (map.scrmap, i, 256);
+        revmap.scrmap[i] = p ? p - map.scrmap : i;
     }
 
-    for (i = 0; i < screen_shot.xsize * screen_shot.ysize; i++) {
-	screen_shot.buf[i] =
-	    (screen_shot.buf[i] & 0xff00) | (unsigned char) revmap.
-	    scrmap[screen_shot.buf[i] & 0xff];
+    for (i = 0; i < screen_shot.xsize * screen_shot.ysize; i++)
+    {
+        screen_shot.buf[i] =
+            (screen_shot.buf[i] & 0xff00) | (unsigned char) revmap.
+            scrmap[screen_shot.buf[i] & 0xff];
     }
 }
 
 static void
-show_console_contents_freebsd (int starty, unsigned char begin_line,
-			       unsigned char end_line)
+show_console_contents_freebsd (int starty, unsigned char begin_line, unsigned char end_line)
 {
     int col, line;
     char c;
 
     if (!console_flag)
-	return;
-
-    for (line = begin_line; line <= end_line; line++) {
-	tty_gotoyx (starty + line - begin_line, 0);
-        for (col = 0; col < min (COLS, screen_info.mv_csz); col++) {
-	    c = screen_shot.buf[line * screen_info.mv_csz + col] & 0xFF;
-	    tty_print_char (c);
-	}
+        return;
+
+    for (line = begin_line; line <= end_line; line++)
+    {
+        tty_gotoyx (starty + line - begin_line, 0);
+        for (col = 0; col < min (COLS, screen_info.mv_csz); col++)
+        {
+            c = screen_shot.buf[line * screen_info.mv_csz + col] & 0xFF;
+            tty_print_char (c);
+        }
     }
 }
 
 static void
 handle_console_freebsd (unsigned char action)
 {
-    switch (action) {
+    switch (action)
+    {
     case CONSOLE_INIT:
-	console_init ();
-	break;
+        console_init ();
+        break;
 
     case CONSOLE_DONE:
-	console_shutdown ();
-	break;
+        console_shutdown ();
+        break;
 
     case CONSOLE_SAVE:
-	console_save ();
-	break;
+        console_save ();
+        break;
 
     case CONSOLE_RESTORE:
-	console_restore ();
-	break;
+        console_restore ();
+        break;
     }
 }
-#endif				/* __FreeBSD__ */
+#endif /* __FreeBSD__ */
 
 void
-show_console_contents (int starty, unsigned char begin_line,
-		       unsigned char end_line)
+show_console_contents (int starty, unsigned char begin_line, unsigned char end_line)
 {
     tty_set_normal_attrs ();
 
-    if (look_for_rxvt_extensions ()) {
-	show_rxvt_contents (starty, begin_line, end_line);
-	return;
+    if (look_for_rxvt_extensions ())
+    {
+        show_rxvt_contents (starty, begin_line, end_line);
+        return;
     }
 #ifdef __linux__
     show_console_contents_linux (starty, begin_line, end_line);
@@ -390,7 +423,7 @@ handle_console (unsigned char action)
     (void) action;
 
     if (look_for_rxvt_extensions ())
-	return;
+        return;
 
 #ifdef __linux__
     handle_console_linux (action);