wkd: New command --print-wkd-hash for gpg-wks-client.
[gnupg.git] / tools / gpgtar-extract.c
index 028ac0d..3da100c 100644 (file)
@@ -14,7 +14,7 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ * along with this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
  */
 
 #include <config.h>
 #include <unistd.h>
 #include <assert.h>
 
 #include <unistd.h>
 #include <assert.h>
 
-#include "i18n.h"
+#include "../common/i18n.h"
+#include "../common/exectool.h"
 #include "../common/sysutils.h"
 #include "../common/sysutils.h"
+#include "../common/ccparray.h"
 #include "gpgtar.h"
 
 
 static gpg_error_t
 extract_regular (estream_t stream, const char *dirname,
 #include "gpgtar.h"
 
 
 static gpg_error_t
 extract_regular (estream_t stream, const char *dirname,
-                 tar_header_t hdr)
+                 tarinfo_t info, tar_header_t hdr)
 {
   gpg_error_t err;
   char record[RECORDSIZE];
 {
   gpg_error_t err;
   char record[RECORDSIZE];
@@ -51,12 +53,15 @@ extract_regular (estream_t stream, const char *dirname,
     }
   else
     err = 0;
     }
   else
     err = 0;
-  
-  outfp = es_fopen (fname, "wb");
+
+  if (opt.dry_run)
+    outfp = es_fopenmem (0, "wb");
+  else
+    outfp = es_fopen (fname, "wb");
   if (!outfp)
     {
       err = gpg_error_from_syserror ();
   if (!outfp)
     {
       err = gpg_error_from_syserror ();
-      log_error ("error creating `%s': %s\n", fname, gpg_strerror (err));
+      log_error ("error creating '%s': %s\n", fname, gpg_strerror (err));
       goto leave;
     }
 
       goto leave;
     }
 
@@ -65,13 +70,18 @@ extract_regular (estream_t stream, const char *dirname,
       err = read_record (stream, record);
       if (err)
         goto leave;
       err = read_record (stream, record);
       if (err)
         goto leave;
+      info->nblocks++;
       n++;
       n++;
-      nbytes = (n < hdr->nrecords)? RECORDSIZE : (hdr->size % RECORDSIZE);
+      if (n < hdr->nrecords || (hdr->size && !(hdr->size % RECORDSIZE)))
+        nbytes = RECORDSIZE;
+      else
+        nbytes = (hdr->size % RECORDSIZE);
+
       nwritten = es_fwrite (record, 1, nbytes, outfp);
       if (nwritten != nbytes)
         {
           err = gpg_error_from_syserror ();
       nwritten = es_fwrite (record, 1, nbytes, outfp);
       if (nwritten != nbytes)
         {
           err = gpg_error_from_syserror ();
-          log_error ("error writing `%s': %s\n", fname, gpg_strerror (err));
+          log_error ("error writing '%s': %s\n", fname, gpg_strerror (err));
           goto leave;
         }
     }
           goto leave;
         }
     }
@@ -79,12 +89,12 @@ extract_regular (estream_t stream, const char *dirname,
 
  leave:
   if (!err && opt.verbose)
 
  leave:
   if (!err && opt.verbose)
-    log_info ("extracted `%s/'\n", fname);
+    log_info ("extracted '%s'\n", fname);
   es_fclose (outfp);
   if (err && fname && outfp)
     {
       if (gnupg_remove (fname))
   es_fclose (outfp);
   if (err && fname && outfp)
     {
       if (gnupg_remove (fname))
-        log_error ("error removing incomplete file `%s': %s\n",
+        log_error ("error removing incomplete file '%s': %s\n",
                    fname, gpg_strerror (gpg_error_from_syserror ()));
     }
   xfree (fname);
                    fname, gpg_strerror (gpg_error_from_syserror ()));
     }
   xfree (fname);
@@ -98,7 +108,7 @@ extract_directory (const char *dirname, tar_header_t hdr)
   gpg_error_t err;
   char *fname;
   size_t prefixlen;
   gpg_error_t err;
   char *fname;
   size_t prefixlen;
-  
+
   prefixlen = strlen (dirname) + 1;
   fname = strconcat (dirname, "/", hdr->name, NULL);
   if (!fname)
   prefixlen = strlen (dirname) + 1;
   fname = strconcat (dirname, "/", hdr->name, NULL);
   if (!fname)
@@ -113,18 +123,22 @@ extract_directory (const char *dirname, tar_header_t hdr)
   if (fname[strlen (fname)-1] == '/')
     fname[strlen (fname)-1] = 0;
 
   if (fname[strlen (fname)-1] == '/')
     fname[strlen (fname)-1] = 0;
 
- /* Note that we don't need to care about EEXIST because we always
-     extract into a new hierarchy.  */
-  if (gnupg_mkdir (fname, "-rwx------"))
+  if (! opt.dry_run && gnupg_mkdir (fname, "-rwx------"))
     {
       err = gpg_error_from_syserror ();
     {
       err = gpg_error_from_syserror ();
+      if (gpg_err_code (err) == GPG_ERR_EEXIST)
+        {
+          /* Ignore existing directories while extracting.  */
+          err = 0;
+        }
+
       if (gpg_err_code (err) == GPG_ERR_ENOENT)
         {
           /* Try to create the directory with parents but keep the
              original error code in case of a failure.  */
           char *p;
           int rc = 0;
       if (gpg_err_code (err) == GPG_ERR_ENOENT)
         {
           /* Try to create the directory with parents but keep the
              original error code in case of a failure.  */
           char *p;
           int rc = 0;
-          
+
           for (p = fname+prefixlen; (p = strchr (p, '/')); p++)
             {
               *p = 0;
           for (p = fname+prefixlen; (p = strchr (p, '/')); p++)
             {
               *p = 0;
@@ -137,20 +151,21 @@ extract_directory (const char *dirname, tar_header_t hdr)
             err = 0;
         }
       if (err)
             err = 0;
         }
       if (err)
-        log_error ("error creating directory `%s': %s\n",
+        log_error ("error creating directory '%s': %s\n",
                    fname, gpg_strerror (err));
     }
 
  leave:
   if (!err && opt.verbose)
                    fname, gpg_strerror (err));
     }
 
  leave:
   if (!err && opt.verbose)
-    log_info ("created   `%s/'\n", fname);
+    log_info ("created   '%s/'\n", fname);
   xfree (fname);
   return err;
 }
 
 
 static gpg_error_t
   xfree (fname);
   return err;
 }
 
 
 static gpg_error_t
-extract (estream_t stream, const char *dirname, tar_header_t hdr)
+extract (estream_t stream, const char *dirname, tarinfo_t info,
+         tar_header_t hdr)
 {
   gpg_error_t err;
   size_t n;
 {
   gpg_error_t err;
   size_t n;
@@ -159,35 +174,39 @@ extract (estream_t stream, const char *dirname, tar_header_t hdr)
 #ifdef HAVE_DOSISH_SYSTEM
   if (strchr (hdr->name, '\\'))
     {
 #ifdef HAVE_DOSISH_SYSTEM
   if (strchr (hdr->name, '\\'))
     {
-      log_error ("filename `%s' contains a backslash - "
+      log_error ("filename '%s' contains a backslash - "
                  "can't extract on this system\n", hdr->name);
       return gpg_error (GPG_ERR_INV_NAME);
     }
 #endif /*HAVE_DOSISH_SYSTEM*/
 
   if (!n
                  "can't extract on this system\n", hdr->name);
       return gpg_error (GPG_ERR_INV_NAME);
     }
 #endif /*HAVE_DOSISH_SYSTEM*/
 
   if (!n
-      || strstr (hdr->name, "//") 
-      || strstr (hdr->name, "/../") 
+      || strstr (hdr->name, "//")
+      || strstr (hdr->name, "/../")
       || !strncmp (hdr->name, "../", 3)
       || (n >= 3 && !strcmp (hdr->name+n-3, "/.." )))
     {
       || !strncmp (hdr->name, "../", 3)
       || (n >= 3 && !strcmp (hdr->name+n-3, "/.." )))
     {
-      log_error ("filename `%s' as suspicious parts - not extracting\n",
+      log_error ("filename '%s' as suspicious parts - not extracting\n",
                  hdr->name);
       return gpg_error (GPG_ERR_INV_NAME);
     }
 
   if (hdr->typeflag == TF_REGULAR || hdr->typeflag == TF_UNKNOWN)
                  hdr->name);
       return gpg_error (GPG_ERR_INV_NAME);
     }
 
   if (hdr->typeflag == TF_REGULAR || hdr->typeflag == TF_UNKNOWN)
-    err = extract_regular (stream, dirname, hdr);
+    err = extract_regular (stream, dirname, info, hdr);
   else if (hdr->typeflag == TF_DIRECTORY)
     err = extract_directory (dirname, hdr);
   else
     {
       char record[RECORDSIZE];
 
   else if (hdr->typeflag == TF_DIRECTORY)
     err = extract_directory (dirname, hdr);
   else
     {
       char record[RECORDSIZE];
 
-      log_info ("unsupported file type %d for `%s' - skipped\n",
+      log_info ("unsupported file type %d for '%s' - skipped\n",
                 (int)hdr->typeflag, hdr->name);
       for (err = 0, n=0; !err && n < hdr->nrecords; n++)
                 (int)hdr->typeflag, hdr->name);
       for (err = 0, n=0; !err && n < hdr->nrecords; n++)
-        err = read_record (stream, record);
+        {
+          err = read_record (stream, record);
+          if (!err)
+            info->nblocks++;
+        }
     }
   return err;
 }
     }
   return err;
 }
@@ -208,10 +227,11 @@ create_directory (const char *dirprefix)
 
   /* Remove common suffixes.  */
   n = strlen (dirprefix);
 
   /* Remove common suffixes.  */
   n = strlen (dirprefix);
-  if (n > 4 && (!compare_filenames    (dirprefix + n - 4, EXTSEP_S "gpg")
+  if (n > 4 && (!compare_filenames    (dirprefix + n - 4, EXTSEP_S GPGEXT_GPG)
                 || !compare_filenames (dirprefix + n - 4, EXTSEP_S "pgp")
                 || !compare_filenames (dirprefix + n - 4, EXTSEP_S "asc")
                 || !compare_filenames (dirprefix + n - 4, EXTSEP_S "pem")
                 || !compare_filenames (dirprefix + n - 4, EXTSEP_S "pgp")
                 || !compare_filenames (dirprefix + n - 4, EXTSEP_S "asc")
                 || !compare_filenames (dirprefix + n - 4, EXTSEP_S "pem")
+                || !compare_filenames (dirprefix + n - 4, EXTSEP_S "p7m")
                 || !compare_filenames (dirprefix + n - 4, EXTSEP_S "p7e")))
     {
       prefix_buffer = xtrystrdup (dirprefix);
                 || !compare_filenames (dirprefix + n - 4, EXTSEP_S "p7e")))
     {
       prefix_buffer = xtrystrdup (dirprefix);
@@ -259,62 +279,121 @@ create_directory (const char *dirprefix)
 
 
 \f
 
 
 \f
-void
-gpgtar_extract (const char *filename)
+gpg_error_t
+gpgtar_extract (const char *filename, int decrypt)
 {
   gpg_error_t err;
   estream_t stream;
 {
   gpg_error_t err;
   estream_t stream;
+  estream_t cipher_stream = NULL;
   tar_header_t header = NULL;
   const char *dirprefix = NULL;
   char *dirname = NULL;
   tar_header_t header = NULL;
   const char *dirprefix = NULL;
   char *dirname = NULL;
+  struct tarinfo_s tarinfo_buffer;
+  tarinfo_t tarinfo = &tarinfo_buffer;
+
+  memset (&tarinfo_buffer, 0, sizeof tarinfo_buffer);
 
   if (filename)
     {
 
   if (filename)
     {
-      stream = es_fopen (filename, "rb");
+      if (!strcmp (filename, "-"))
+        stream = es_stdin;
+      else
+        stream = es_fopen (filename, "rb");
       if (!stream)
         {
           err = gpg_error_from_syserror ();
       if (!stream)
         {
           err = gpg_error_from_syserror ();
-          log_error ("error opening `%s': %s\n", filename, gpg_strerror (err));
-          return;
+          log_error ("error opening '%s': %s\n", filename, gpg_strerror (err));
+          return err;
         }
     }
   else
         }
     }
   else
-    stream = es_stdin;  /* FIXME:  How can we enforce binary mode?  */
+    stream = es_stdin;
 
 
+  if (stream == es_stdin)
+    es_set_binary (es_stdin);
 
 
-  if (filename)
+  if (decrypt)
     {
     {
-      dirprefix = strrchr (filename, '/');
-      if (dirprefix)
-        dirprefix++;
+      strlist_t arg;
+      ccparray_t ccp;
+      const char **argv;
+
+      cipher_stream = stream;
+      stream = es_fopenmem (0, "rwb");
+      if (! stream)
+        {
+          err = gpg_error_from_syserror ();
+          goto leave;
+        }
+
+      ccparray_init (&ccp, 0);
+
+      ccparray_put (&ccp, "--decrypt");
+      for (arg = opt.gpg_arguments; arg; arg = arg->next)
+        ccparray_put (&ccp, arg->d);
+
+      ccparray_put (&ccp, NULL);
+      argv = ccparray_get (&ccp, NULL);
+      if (!argv)
+        {
+          err = gpg_error_from_syserror ();
+          goto leave;
+        }
+
+      err = gnupg_exec_tool_stream (opt.gpg_program, argv,
+                                    cipher_stream, NULL, stream, NULL, NULL);
+      xfree (argv);
+      if (err)
+        goto leave;
+
+      err = es_fseek (stream, 0, SEEK_SET);
+      if (err)
+        goto leave;
     }
     }
-  else if (opt.filename)
+
+  if (opt.directory)
+    dirname = xtrystrdup (opt.directory);
+  else
     {
     {
-      dirprefix = strrchr (opt.filename, '/');
-      if (dirprefix)
-        dirprefix++;
-    }
+      if (opt.filename)
+        {
+          dirprefix = strrchr (opt.filename, '/');
+          if (dirprefix)
+            dirprefix++;
+          else
+            dirprefix = opt.filename;
+        }
+      else if (filename)
+        {
+          dirprefix = strrchr (filename, '/');
+          if (dirprefix)
+            dirprefix++;
+          else
+            dirprefix = filename;
+        }
 
 
-  if (!dirprefix || !*dirprefix)
-    dirprefix = "GPGARCH";
+      if (!dirprefix || !*dirprefix)
+        dirprefix = "GPGARCH";
 
 
-  dirname = create_directory (dirprefix);
-  if (!dirname)
-    {
-      err = gpg_error (GPG_ERR_GENERAL);
-      goto leave;
+      dirname = create_directory (dirprefix);
+      if (!dirname)
+        {
+          err = gpg_error (GPG_ERR_GENERAL);
+          goto leave;
+        }
     }
 
   if (opt.verbose)
     }
 
   if (opt.verbose)
-    log_info ("extracting to `%s/'\n", dirname);
+    log_info ("extracting to '%s/'\n", dirname);
 
   for (;;)
     {
 
   for (;;)
     {
-      header = gpgtar_read_header (stream);
-      if (!header)
+      err = gpgtar_read_header (stream, tarinfo, &header);
+      if (err || header == NULL)
         goto leave;
         goto leave;
-     
-      if (extract (stream, dirname, header))
+
+      err = extract (stream, dirname, tarinfo, header);
+      if (err)
         goto leave;
       xfree (header);
       header = NULL;
         goto leave;
       xfree (header);
       header = NULL;
@@ -326,5 +405,7 @@ gpgtar_extract (const char *filename)
   xfree (dirname);
   if (stream != es_stdin)
     es_fclose (stream);
   xfree (dirname);
   if (stream != es_stdin)
     es_fclose (stream);
-  return;
+  if (stream != cipher_stream)
+    es_fclose (cipher_stream);
+  return err;
 }
 }