tools,build: Build WKS tools against libintl.
[gnupg.git] / g13 / create.c
index bde6757..573039d 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
- * 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 "keyblob.h"
 #include "backend.h"
-#include "utils.h"
-#include "call-gpg.h"
-#include "estream.h"
+#include "g13tuple.h"
+#include "../common/call-gpg.h"
 
 /* Create a new blob with all the session keys and other meta
    information which are to be stored encrypted in the crypto
    container header.  On success the malloced blob is stored at R_BLOB
    and its length at R_BLOBLEN.  On error an error code is returned
-   and (R_BLOB,R_BLOBLEN) are set to (NULL,0). 
+   and (R_BLOB,R_BLOBLEN) are set to (NULL,0).
 
    The format of this blob is a sequence of tag-length-value tuples.
    All tuples have this format:
@@ -104,15 +103,16 @@ create_new_keyblob (ctrl_t ctrl, int is_detached,
    CTRL the result is a single OpenPGP binary message, a single
    special OpenPGP packet encapsulating a CMS message or a
    concatenation of both with the CMS packet being the last.  */
-static gpg_error_t
-encrypt_keyblob (ctrl_t ctrl, void *keyblob, size_t keybloblen,
-                 strlist_t keys,
-                 void **r_encblob, size_t *r_encbloblen)
+gpg_error_t
+g13_encrypt_keyblob (ctrl_t ctrl, void *keyblob, size_t keybloblen,
+                     void **r_encblob, size_t *r_encbloblen)
 {
   gpg_error_t err;
 
   /* FIXME:  For now we only implement OpenPGP.  */
-  err = gpg_encrypt_blob (ctrl, keyblob, keybloblen, keys,
+  err = gpg_encrypt_blob (ctrl, opt.gpg_program, opt.gpg_arguments,
+                          keyblob, keybloblen,
+                          ctrl->recipients,
                           r_encblob, r_encbloblen);
 
   return err;
@@ -120,10 +120,10 @@ encrypt_keyblob (ctrl_t ctrl, void *keyblob, size_t keybloblen,
 
 
 /* Write a new file under the name FILENAME with the keyblob and an
-   appropriate header.  This fucntion is called with a lock file in
+   appropriate header.  This function is called with a lock file in
    place and after checking that the filename does not exists.  */
 static gpg_error_t
-write_keyblob (const char *filename, 
+write_keyblob (const char *filename,
                const void *keyblob, size_t keybloblen)
 {
   gpg_error_t err;
@@ -135,7 +135,7 @@ write_keyblob (const char *filename,
   if (!fp)
     {
       err = gpg_error_from_syserror ();
-      log_error ("error creating new container `%s': %s\n", 
+      log_error ("error creating new container '%s': %s\n",
                  filename, gpg_strerror (err));
       return err;
     }
@@ -197,18 +197,18 @@ write_keyblob (const char *filename,
   if (es_fclose (fp))
     {
       err = gpg_error_from_syserror ();
-      log_error ("error closing `%s': %s\n", 
+      log_error ("error closing '%s': %s\n",
                  filename, gpg_strerror (err));
       remove (filename);
       return err;
     }
 
   return 0;
-  
+
 
  writeerr:
   err = gpg_error_from_syserror ();
-  log_error ("error writing header to `%s': %s\n", 
+  log_error ("error writing header to '%s': %s\n",
              filename, gpg_strerror (err));
   es_fclose (fp);
   remove (filename);
@@ -218,11 +218,10 @@ write_keyblob (const char *filename,
 
 
 /* Create a new container under the name FILENAME and intialize it
-   using the current settings.  KEYS is a list of public keys to which
-   the container will be encrypted.  If the file already exists an
-   error is returned.  */
+   using the current settings.  If the file already exists an error is
+   returned.  */
 gpg_error_t
-g13_create_container (ctrl_t ctrl, const char *filename, strlist_t keys)
+g13_create_container (ctrl_t ctrl, const char *filename)
 {
   gpg_error_t err;
   dotlock_t lock;
@@ -235,38 +234,13 @@ g13_create_container (ctrl_t ctrl, const char *filename, strlist_t keys)
   tupledesc_t tuples = NULL;
   unsigned int dummy_rid;
 
-  if (!keys)
+  if (!ctrl->recipients)
     return gpg_error (GPG_ERR_NO_PUBKEY);
 
-  /* A quick check to see that no container with that name already
-     exists.  */
-  if (!access (filename, F_OK))
-    return gpg_error (GPG_ERR_EEXIST);
-
-  /* Take a lock and proceed with the creation.  If there is a lock we
-     immediately return an error because for creation it does not make
-     sense to wait.  */
-  lock = create_dotlock (filename);
-  if (!lock)
-    return gpg_error_from_syserror ();
-  if (make_dotlock (lock, 0))
-    {
-      err = gpg_error_from_syserror ();
-      goto leave;
-    }
-  else
-    err = 0;
-
-  /* Check again that the file does not exist.  */
-  {
-      struct stat sb;
+  err = be_take_lock_for_create (ctrl, filename, &lock);
+  if (err)
+    goto leave;
 
-      if (!stat (filename, &sb))
-        {
-          err = gpg_error (GPG_ERR_EEXIST);
-          goto leave;
-        }
-  }
   /* And a possible detached file or directory may not exist either.  */
   err = be_get_detached_name (ctrl->conttype, filename,
                               &detachedname, &detachedisdir);
@@ -283,29 +257,32 @@ g13_create_container (ctrl_t ctrl, const char *filename, strlist_t keys)
         }
     }
 
-  /* Create a new keyblob.  */
-  err = create_new_keyblob (ctrl, !!detachedname, &keyblob, &keybloblen);
-  if (err)
-    goto leave;
-
-  /* Encrypt that keyblob.  */
-  err = encrypt_keyblob (ctrl, keyblob, keybloblen, keys,
-                         &enckeyblob, &enckeybloblen);
-  if (err)
-    goto leave;
-
-  /* Put a copy of the keyblob into a tuple structure.  */
-  err = create_tupledesc (&tuples, keyblob, keybloblen);
-  if (err)
-    goto leave;
-  keyblob = NULL;
-  /* if (opt.verbose) */
-  /*   dump_keyblob (tuples); */
-  
-  /* Write out the header, the encrypted keyblob and some padding. */
-  err = write_keyblob (filename, enckeyblob, enckeybloblen);
-  if (err)
-    goto leave;
+  if (ctrl->conttype != CONTTYPE_DM_CRYPT)
+    {
+      /* Create a new keyblob.  */
+      err = create_new_keyblob (ctrl, !!detachedname, &keyblob, &keybloblen);
+      if (err)
+        goto leave;
+
+      /* Encrypt that keyblob.  */
+      err = g13_encrypt_keyblob (ctrl, keyblob, keybloblen,
+                                 &enckeyblob, &enckeybloblen);
+      if (err)
+        goto leave;
+
+      /* Put a copy of the keyblob into a tuple structure.  */
+      err = create_tupledesc (&tuples, keyblob, keybloblen);
+      if (err)
+        goto leave;
+      keyblob = NULL;
+      /* if (opt.verbose) */
+      /*   dump_keyblob (tuples); */
+
+      /* Write out the header, the encrypted keyblob and some padding. */
+      err = write_keyblob (filename, enckeyblob, enckeybloblen);
+      if (err)
+        goto leave;
+    }
 
   /* Create and append the container.  FIXME: We should pass the
      estream object in addition to the filename, so that the backend
@@ -319,7 +296,7 @@ g13_create_container (ctrl_t ctrl, const char *filename, strlist_t keys)
   xfree (detachedname);
   xfree (enckeyblob);
   xfree (keyblob);
-  destroy_dotlock (lock);
+  dotlock_destroy (lock);
 
   return err;
 }