Remove some lint, found by gcc -W etc.

[chaz/tar] / src / extract.c

diff --git a/src/extract.c b/src/extract.c
index 1f231e38e335c15b103643ee7522952ac5e1f4a1..c3a99e084d3d143f1b8d4612d00d33008a72ef54 100644 (file)
--- a/src/extract.c
+++ b/src/extract.c
@@ -1,13 +1,13 @@
 /* Extract files from a tar archive.
 
    Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,
 /* Extract files from a tar archive.
 
    Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000,

-   2001, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+   2001, 2003, 2004, 2005, 2006, 2007, 2010 Free Software Foundation, Inc.

 
    Written by John Gilmore, on 1985-11-19.
 
    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
 
    Written by John Gilmore, on 1985-11-19.
 
    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, or (at your option) any later
+   Free Software Foundation; either version 3, or (at your option) any later

    version.
 
    This program is distributed in the hope that it will be useful, but
    version.
 
    This program is distributed in the hope that it will be useful, but


@@ -24,6 +24,7 @@
 #include <utimens.h>
 #include <errno.h>
 #include <xgetcwd.h>
 #include <utimens.h>
 #include <errno.h>
 #include <xgetcwd.h>

+#include <priv-set.h>

 
 #include "common.h"
 
 
 #include "common.h"
 


@@ -144,6 +145,7 @@ set_mode (char const *file_name,
          char typeflag)
 {
   mode_t mode;
          char typeflag)
 {
   mode_t mode;

+  bool failed;

 
   if (0 < same_permissions_option
       && permstatus != INTERDIR_PERMSTATUS)
 
   if (0 < same_permissions_option
       && permstatus != INTERDIR_PERMSTATUS)


@@ -186,7 +188,17 @@ set_mode (char const *file_name,
       mode = cur_info->st_mode ^ invert_permissions;
     }
 
       mode = cur_info->st_mode ^ invert_permissions;
     }
 

-  if (chmod (file_name, mode) != 0)
+  failed = chmod (file_name, mode) != 0;
+  if (failed && errno == EPERM)
+    {
+      /* On Solaris, chmod may fail if we don't have PRIV_ALL.  */
+      if (priv_set_restore_linkdir () == 0)
+       {
+         failed = chmod (file_name, mode) != 0;
+         priv_set_remove_linkdir ();
+       }
+    }
+  if (failed)

     chmod_error_details (file_name, mode);
 }
 
     chmod_error_details (file_name, mode);
 }
 


@@ -195,8 +207,9 @@ static void
 check_time (char const *file_name, struct timespec t)
 {
   if (t.tv_sec <= 0)
 check_time (char const *file_name, struct timespec t)
 {
   if (t.tv_sec <= 0)

-    WARN ((0, 0, _("%s: implausibly old time stamp %s"),
-          file_name, tartime (t, true)));
+    WARNOPT (WARN_TIMESTAMP,
+            (0, 0, _("%s: implausibly old time stamp %s"),
+             file_name, tartime (t, true)));

   else if (timespec_cmp (volume_start_time, t) < 0)
     {
       struct timespec now;
   else if (timespec_cmp (volume_start_time, t) < 0)
     {
       struct timespec now;


@@ -212,8 +225,9 @@ check_time (char const *file_name, struct timespec t)
              diff.tv_nsec += BILLION;
              diff.tv_sec--;
            }
              diff.tv_nsec += BILLION;
              diff.tv_sec--;
            }

-         WARN ((0, 0, _("%s: time stamp %s is %s s in the future"),
-                file_name, tartime (t, true), code_timespec (diff, buf)));
+         WARNOPT (WARN_TIMESTAMP,
+                  (0, 0, _("%s: time stamp %s is %s s in the future"),
+                   file_name, tartime (t, true), code_timespec (diff, buf)));

        }
     }
 }
        }
     }
 }


@@ -474,9 +488,13 @@ file_newer_p (const char *file_name, struct tar_stat_info *tar_stat)
 
   if (stat (file_name, &st))
     {
 
   if (stat (file_name, &st))
     {

-      stat_warn (file_name);
-      /* Be on the safe side: if the file does exist assume it is newer */
-      return errno != ENOENT;
+      if (errno != ENOENT)
+       {
+         stat_warn (file_name);
+         /* Be on the safe side: if the file does exist assume it is newer */
+         return true;
+       }
+      return false;

     }
   if (!S_ISDIR (st.st_mode)
       && tar_timespec_cmp (tar_stat->mtime, get_stat_mtime (&st)) <= 0)
     }
   if (!S_ISDIR (st.st_mode)
       && tar_timespec_cmp (tar_stat->mtime, get_stat_mtime (&st)) <= 0)


@@ -486,17 +504,24 @@ file_newer_p (const char *file_name, struct tar_stat_info *tar_stat)
   return false;
 }
 
   return false;
 }
 

+#define RECOVER_NO 0
+#define RECOVER_OK 1
+#define RECOVER_SKIP 2
+

 /* Attempt repairing what went wrong with the extraction.  Delete an
    already existing file or create missing intermediate directories.
 /* Attempt repairing what went wrong with the extraction.  Delete an
    already existing file or create missing intermediate directories.

-   Return nonzero if we somewhat increased our chances at a successful
-   extraction.  errno is properly restored on zero return.  */
+   Return RECOVER_OK if we somewhat increased our chances at a successful
+   extraction, RECOVER_NO if there are no chances, and RECOVER_SKIP if the
+   caller should skip extraction of that member.  The value of errno is
+   properly restored on returning RECOVER_NO.  */
+

 static int
 maybe_recoverable (char *file_name, int *interdir_made)
 {
   int e = errno;
 
   if (*interdir_made)
 static int
 maybe_recoverable (char *file_name, int *interdir_made)
 {
   int e = errno;
 
   if (*interdir_made)

-    return 0;
+    return RECOVER_NO;

 
   switch (errno)
     {
 
   switch (errno)
     {


@@ -506,13 +531,13 @@ maybe_recoverable (char *file_name, int *interdir_made)
       switch (old_files_option)
        {
        case KEEP_OLD_FILES:
       switch (old_files_option)
        {
        case KEEP_OLD_FILES:

-         return 0;
+         return RECOVER_SKIP;

 
        case KEEP_NEWER_FILES:
          if (file_newer_p (file_name, &current_stat_info))
            {
              errno = e;
 
        case KEEP_NEWER_FILES:
          if (file_newer_p (file_name, &current_stat_info))
            {
              errno = e;

-             return 0;
+             return RECOVER_NO;

            }
          /* FALL THROUGH */
 
            }
          /* FALL THROUGH */
 


@@ -522,7 +547,7 @@ maybe_recoverable (char *file_name, int *interdir_made)
          {
            int r = remove_any_file (file_name, ORDINARY_REMOVE_OPTION);
            errno = EEXIST;
          {
            int r = remove_any_file (file_name, ORDINARY_REMOVE_OPTION);
            errno = EEXIST;

-           return r;
+           return r > 0 ? RECOVER_OK : RECOVER_NO;

          }
 
        case UNLINK_FIRST_OLD_FILES:
          }
 
        case UNLINK_FIRST_OLD_FILES:


@@ -534,15 +559,15 @@ maybe_recoverable (char *file_name, int *interdir_made)
       if (! make_directories (file_name))
        {
          errno = ENOENT;
       if (! make_directories (file_name))
        {
          errno = ENOENT;

-         return 0;
+         return RECOVER_NO;

        }
       *interdir_made = 1;
        }
       *interdir_made = 1;

-      return 1;
+      return RECOVER_OK;

 
     default:
       /* Just say we can't do anything about it...  */
 
 
     default:
       /* Just say we can't do anything about it...  */
 

-      return 0;
+      return RECOVER_NO;

     }
 }
 
     }
 }
 


@@ -593,13 +618,13 @@ apply_nonancestor_delayed_set_stat (char const *file_name, bool after_links)
 
       if (! skip_this_one)
        {
 
       if (! skip_this_one)
        {

-         struct tar_stat_info st;
-         st.stat.st_mode = data->mode;
-         st.stat.st_uid = data->uid;
-         st.stat.st_gid = data->gid;
-         st.atime = data->atime;
-         st.mtime = data->mtime;
-         set_stat (data->file_name, &st, cur_info,
+         struct tar_stat_info sb;
+         sb.stat.st_mode = data->mode;
+         sb.stat.st_uid = data->uid;
+         sb.stat.st_gid = data->gid;
+         sb.atime = data->atime;
+         sb.mtime = data->mtime;
+         set_stat (data->file_name, &sb, cur_info,

                    data->invert_permissions, data->permstatus, DIRTYPE);
        }
 
                    data->invert_permissions, data->permstatus, DIRTYPE);
        }
 


@@ -659,6 +684,7 @@ extract_dir (char *file_name, int typeflag)
                }
              if (S_ISDIR (st.st_mode))
                {
                }
              if (S_ISDIR (st.st_mode))
                {

+                 status = 0;

                  mode = st.st_mode;
                  break;
                }
                  mode = st.st_mode;
                  break;
                }


@@ -666,13 +692,21 @@ extract_dir (char *file_name, int typeflag)
          errno = EEXIST;
        }
 
          errno = EEXIST;
        }
 

-      if (maybe_recoverable (file_name, &interdir_made))
-       continue;
-
-      if (errno != EEXIST)
+      switch (maybe_recoverable (file_name, &interdir_made))

        {
        {

-         mkdir_error (file_name);
-         return 1;
+       case RECOVER_OK:
+         continue;
+
+       case RECOVER_SKIP:
+         break;
+
+       case RECOVER_NO:
+         if (errno != EEXIST)
+           {
+             mkdir_error (file_name);
+             return 1;
+           }
+         break;

        }
       break;
     }
        }
       break;
     }


@@ -721,7 +755,8 @@ open_output_file (char *file_name, int typeflag, mode_t mode)
       if (!conttype_diagnosed)
        {
          conttype_diagnosed = 1;
       if (!conttype_diagnosed)
        {
          conttype_diagnosed = 1;

-         WARN ((0, 0, _("Extracting contiguous files as regular files")));
+         WARNOPT (WARN_CONTIGUOUS_CAST,
+                  (0, 0, _("Extracting contiguous files as regular files")));

        }
     }
   fd = open (file_name, openflag, mode);
        }
     }
   fd = open (file_name, openflag, mode);


@@ -760,13 +795,18 @@ extract_file (char *file_name, int typeflag)
     }
   else
     {
     }
   else
     {

+      int recover = RECOVER_NO;

       do
        fd = open_output_file (file_name, typeflag, mode ^ invert_permissions);
       do
        fd = open_output_file (file_name, typeflag, mode ^ invert_permissions);

-      while (fd < 0 && maybe_recoverable (file_name, &interdir_made));
+      while (fd < 0
+            && (recover = maybe_recoverable (file_name, &interdir_made))
+                == RECOVER_OK);

 
       if (fd < 0)
        {
          skip_member ();
 
       if (fd < 0)
        {
          skip_member ();

+         if (recover == RECOVER_SKIP)
+           return 0;

          open_error (file_name);
          return 1;
        }
          open_error (file_name);
          return 1;
        }


@@ -848,12 +888,22 @@ create_placeholder_file (char *file_name, bool is_symlink, int *interdir_made)
   struct stat st;
 
   while ((fd = open (file_name, O_WRONLY | O_CREAT | O_EXCL, 0)) < 0)
   struct stat st;
 
   while ((fd = open (file_name, O_WRONLY | O_CREAT | O_EXCL, 0)) < 0)

-    if (! maybe_recoverable (file_name, interdir_made))
-      break;
+    {
+      switch (maybe_recoverable (file_name, interdir_made))
+       {
+       case RECOVER_OK:
+         continue;
+
+       case RECOVER_SKIP:
+         return 0;
+
+       case RECOVER_NO:
+         open_error (file_name);
+         return -1;
+       }
+      }

 
 

-  if (fd < 0)
-    open_error (file_name);
-  else if (fstat (fd, &st) != 0)
+  if (fstat (fd, &st) != 0)

     {
       stat_error (file_name);
       close (fd);
     {
       stat_error (file_name);
       close (fd);


@@ -916,10 +966,10 @@ extract_link (char *file_name, int typeflag)
 {
   int interdir_made = 0;
   char const *link_name;
 {
   int interdir_made = 0;
   char const *link_name;

+  int rc;

 
 

-  transform_member_name (&current_stat_info.link_name, xform_link);

   link_name = current_stat_info.link_name;
   link_name = current_stat_info.link_name;

-  
+

   if (! absolute_names_option && contains_dot_dot (link_name))
     return create_placeholder_file (file_name, false, &interdir_made);
 
   if (! absolute_names_option && contains_dot_dot (link_name))
     return create_placeholder_file (file_name, false, &interdir_made);
 


@@ -957,8 +1007,10 @@ extract_link (char *file_name, int typeflag)
 
       errno = e;
     }
 
       errno = e;
     }

-  while (maybe_recoverable (file_name, &interdir_made));
+  while ((rc = maybe_recoverable (file_name, &interdir_made)) == RECOVER_OK);

 
 

+  if (rc == RECOVER_SKIP)
+    return 0;

   if (!(incremental_option && errno == EEXIST))
     {
       link_error (link_name, file_name);
   if (!(incremental_option && errno == EEXIST))
     {
       link_error (link_name, file_name);


@@ -971,25 +1023,29 @@ static int
 extract_symlink (char *file_name, int typeflag)
 {
 #ifdef HAVE_SYMLINK
 extract_symlink (char *file_name, int typeflag)
 {
 #ifdef HAVE_SYMLINK

-  int status;

   int interdir_made = 0;
 
   int interdir_made = 0;
 

-  transform_member_name (&current_stat_info.link_name, xform_symlink);
-

   if (! absolute_names_option
       && (IS_ABSOLUTE_FILE_NAME (current_stat_info.link_name)
          || contains_dot_dot (current_stat_info.link_name)))
     return create_placeholder_file (file_name, true, &interdir_made);
 
   if (! absolute_names_option
       && (IS_ABSOLUTE_FILE_NAME (current_stat_info.link_name)
          || contains_dot_dot (current_stat_info.link_name)))
     return create_placeholder_file (file_name, true, &interdir_made);
 

-  while ((status = symlink (current_stat_info.link_name, file_name)))
-    if (!maybe_recoverable (file_name, &interdir_made))
-      break;
+  while (symlink (current_stat_info.link_name, file_name))
+    switch (maybe_recoverable (file_name, &interdir_made))
+      {
+      case RECOVER_OK:
+       continue;

 
 

-  if (status == 0)
-    set_stat (file_name, &current_stat_info, NULL, 0, 0, SYMTYPE);
-  else
-    symlink_error (current_stat_info.link_name, file_name);
-  return status;
+      case RECOVER_SKIP:
+       return 0;
+
+      case RECOVER_NO:
+       symlink_error (current_stat_info.link_name, file_name);
+       return -1;
+      }
+
+  set_stat (file_name, &current_stat_info, NULL, 0, 0, SYMTYPE);
+  return 0;

 
 #else
   static int warned_once;
 
 #else
   static int warned_once;


@@ -997,7 +1053,9 @@ extract_symlink (char *file_name, int typeflag)
   if (!warned_once)
     {
       warned_once = 1;
   if (!warned_once)
     {
       warned_once = 1;

-      WARN ((0, 0, _("Attempting extraction of symbolic links as hard links")));
+      WARNOPT (WARN_SYMBOLIC_CAST,
+              (0, 0,
+               _("Attempting extraction of symbolic links as hard links")));

     }
   return extract_link (file_name, typeflag);
 #endif
     }
   return extract_link (file_name, typeflag);
 #endif


@@ -1007,23 +1065,29 @@ extract_symlink (char *file_name, int typeflag)
 static int
 extract_node (char *file_name, int typeflag)
 {
 static int
 extract_node (char *file_name, int typeflag)
 {

-  int status;

   int interdir_made = 0;
   mode_t mode = current_stat_info.stat.st_mode & ~ current_umask;
   mode_t invert_permissions =
     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;
 
   int interdir_made = 0;
   mode_t mode = current_stat_info.stat.st_mode & ~ current_umask;
   mode_t invert_permissions =
     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;
 

-  do
-    status = mknod (file_name, mode ^ invert_permissions,
-                   current_stat_info.stat.st_rdev);
-  while (status && maybe_recoverable (file_name, &interdir_made));
+  while (mknod (file_name, mode ^ invert_permissions,
+               current_stat_info.stat.st_rdev))
+    switch (maybe_recoverable (file_name, &interdir_made))
+      {
+      case RECOVER_OK:
+       continue;

 
 

-  if (status != 0)
-    mknod_error (file_name);
-  else
-    set_stat (file_name, &current_stat_info, NULL, invert_permissions,
-             ARCHIVED_PERMSTATUS, typeflag);
-  return status;
+      case RECOVER_SKIP:
+       return 0;
+
+      case RECOVER_NO:
+       mknod_error (file_name);
+       return -1;
+      }
+
+  set_stat (file_name, &current_stat_info, NULL, invert_permissions,
+           ARCHIVED_PERMSTATUS, typeflag);
+  return 0;

 }
 #endif
 
 }
 #endif
 


@@ -1038,23 +1102,28 @@ extract_fifo (char *file_name, int typeflag)
     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;
 
   while ((status = mkfifo (file_name, mode)) != 0)
     0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO) : 0;
 
   while ((status = mkfifo (file_name, mode)) != 0)

-    if (!maybe_recoverable (file_name, &interdir_made))
-      break;
+    switch (maybe_recoverable (file_name, &interdir_made))
+      {
+      case RECOVER_OK:
+       continue;

 
 

-  if (status == 0)
-    set_stat (file_name, &current_stat_info, NULL, invert_permissions,
-             ARCHIVED_PERMSTATUS, typeflag);
-  else
-    mkfifo_error (file_name);
-  return status;
+      case RECOVER_SKIP:
+       return 0;
+
+      case RECOVER_NO:
+       mkfifo_error (file_name);
+       return -1;
+      }
+
+  set_stat (file_name, &current_stat_info, NULL, invert_permissions,
+           ARCHIVED_PERMSTATUS, typeflag);
+  return 0;

 }
 #endif
 
 static int
 extract_volhdr (char *file_name, int typeflag)
 {
 }
 #endif
 
 static int
 extract_volhdr (char *file_name, int typeflag)
 {

-  if (verbose_option)
-    fprintf (stdlis, _("Reading %s\n"), quote (current_stat_info.file_name));

   skip_member ();
   return 0;
 }
   skip_member ();
   return 0;
 }


@@ -1155,9 +1224,10 @@ prepare_to_extract (char const *file_name, int typeflag, tar_extractor_t *fun)
       break;
 
     default:
       break;
 
     default:

-      WARN ((0, 0,
-            _("%s: Unknown file type `%c', extracted as normal file"),
-            quotearg_colon (file_name), typeflag));
+      WARNOPT (WARN_UNKNOWN_CAST,
+              (0, 0,
+               _("%s: Unknown file type `%c', extracted as normal file"),
+               quotearg_colon (file_name), typeflag));

       *fun = extract_file;
     }
 
       *fun = extract_file;
     }
 


@@ -1181,8 +1251,9 @@ prepare_to_extract (char const *file_name, int typeflag, tar_extractor_t *fun)
     case KEEP_NEWER_FILES:
       if (file_newer_p (file_name, &current_stat_info))
        {
     case KEEP_NEWER_FILES:
       if (file_newer_p (file_name, &current_stat_info))
        {

-         WARN ((0, 0, _("Current %s is newer or same age"),
-                quote (file_name)));
+         WARNOPT (WARN_IGNORE_NEWER,
+                  (0, 0, _("Current %s is newer or same age"),
+                   quote (file_name)));

          return 0;
        }
       break;
          return 0;
        }
       break;


@@ -1201,6 +1272,11 @@ extract_archive (void)
   char typeflag;
   tar_extractor_t fun;
 
   char typeflag;
   tar_extractor_t fun;
 

+  fatal_exit_hook = extract_finish;
+
+  /* Try to disable the ability to unlink a directory.  */
+  priv_set_remove_linkdir ();
+

   set_next_block_after (current_header);
   decode_header (current_header, &current_stat_info, &current_format, 1);
   if (!current_stat_info.file_name[0]
   set_next_block_after (current_header);
   decode_header (current_header, &current_stat_info, &current_format, 1);
   if (!current_stat_info.file_name[0]


@@ -1213,7 +1289,7 @@ extract_archive (void)
 
   /* Print the block from current_header and current_stat.  */
   if (verbose_option)
 
   /* Print the block from current_header and current_stat.  */
   if (verbose_option)

-    print_header (&current_stat_info, -1);
+    print_header (&current_stat_info, current_header, -1);

 
   /* Restore stats for all non-ancestor directories, unless
      it is an incremental archive.
 
   /* Restore stats for all non-ancestor directories, unless
      it is an incremental archive.


@@ -1362,18 +1438,3 @@ rename_directory (char *src, char *dst)
     }
   return true;
 }
     }
   return true;
 }

-
-void
-fatal_exit (void)
-{
-  extract_finish ();
-  error (TAREXIT_FAILURE, 0, _("Error is not recoverable: exiting now"));
-  abort ();
-}
-
-void
-xalloc_die (void)
-{
-  error (0, 0, "%s", _("memory exhausted"));
-  fatal_exit ();
-}