* Makefile.am (DISTCHECK_CONFIGURE_FLAGS): New.
[gnupg.git] / sm / encrypt.c
index 40e1258..725a81b 100644 (file)
@@ -1,5 +1,5 @@
 /* encrypt.c - Encrypt a message
- *     Copyright (C) 2001 Free Software Foundation, Inc.
+ *     Copyright (C) 2001, 2003 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 #include <time.h>
 #include <assert.h>
 
+#include "gpgsm.h"
 #include <gcrypt.h>
 #include <ksba.h>
 
-#include "gpgsm.h"
 #include "keydb.h"
 #include "i18n.h"
 
@@ -38,7 +38,7 @@
 struct dek_s {
   const char *algoid;
   int algo;
-  GCRY_CIPHER_HD chd;
+  gcry_cipher_hd_t chd;
   char key[32];
   int keylen;
   char iv[32];
@@ -72,54 +72,54 @@ init_dek (DEK dek)
   if (!dek->algo || !mode)
     {
       log_error ("unsupported algorithm `%s'\n", dek->algoid);
-      return GNUPG_Unsupported_Algorithm;
+      return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
     }
 
   dek->keylen = gcry_cipher_get_algo_keylen (dek->algo);
   if (!dek->keylen || dek->keylen > sizeof (dek->key))
-    return GNUPG_Bug;
+    return gpg_error (GPG_ERR_BUG);
 
   dek->ivlen = gcry_cipher_get_algo_blklen (dek->algo);
   if (!dek->ivlen || dek->ivlen > sizeof (dek->iv))
-    return GNUPG_Bug;
+    return gpg_error (GPG_ERR_BUG);
 
   if (dek->keylen < 100/8)
     { /* make sure we don't use weak keys */
       log_error ("key length of `%s' too small\n", dek->algoid);
-      return GNUPG_Unsupported_Algorithm;
+      return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
     }
   
-  dek->chd = gcry_cipher_open (dek->algo, mode, GCRY_CIPHER_SECURE);
-  if (!dek->chd)
+  rc = gcry_cipher_open (&dek->chd, dek->algo, mode, GCRY_CIPHER_SECURE);
+  if (rc)
     {
-      log_error ("failed to create cipher context: %s\n", gcry_strerror (-1));
-      return GNUPG_General_Error;
+      log_error ("failed to create cipher context: %s\n", gpg_strerror (rc));
+      return rc;
     }
   
   for (i=0; i < 8; i++)
     {
       gcry_randomize (dek->key, dek->keylen, GCRY_STRONG_RANDOM );
       rc = gcry_cipher_setkey (dek->chd, dek->key, dek->keylen);
-      if (rc != GCRYERR_WEAK_KEY)
+      if (gpg_err_code (rc) != GPG_ERR_WEAK_KEY)
         break;
       log_info(_("weak key created - retrying\n") );
     }
   if (rc)
     {
-      log_error ("failed to set the key: %s\n", gcry_strerror (rc));
+      log_error ("failed to set the key: %s\n", gpg_strerror (rc));
       gcry_cipher_close (dek->chd);
       dek->chd = NULL;
-      return map_gcry_err (rc);
+      return rc;
     }
 
   gcry_randomize (dek->iv, dek->ivlen, GCRY_STRONG_RANDOM);
   rc = gcry_cipher_setiv (dek->chd, dek->iv, dek->ivlen);
   if (rc)
     {
-      log_error ("failed to set the IV: %s\n", gcry_strerror (rc));
+      log_error ("failed to set the IV: %s\n", gpg_strerror (rc));
       gcry_cipher_close (dek->chd);
       dek->chd = NULL;
-      return map_gcry_err (rc);
+      return rc;
     }
   
   return 0;
@@ -129,14 +129,14 @@ init_dek (DEK dek)
 /* Encode the session key. NBITS is the number of bits which should be
    used for packing the session key.  returns: An mpi with the session
    key (caller must free) */
-static GCRY_MPI
+static gcry_mpi_t
 encode_session_key (DEK dek, unsigned int nbits)
 {
   int nframe = (nbits+7) / 8;
   byte *p;
   byte *frame;
   int i,n;
-  MPI a;
+  gcry_mpi_t a;
 
   if (dek->keylen + 7 > nframe || !nframe)
     log_bug ("can't encode a %d bit key in a %d bits frame\n",
@@ -192,7 +192,7 @@ encode_session_key (DEK dek, unsigned int nbits)
   memcpy (frame+n, dek->key, dek->keylen);
   n += dek->keylen;
   assert (n == nframe);
-  if (gcry_mpi_scan (&a, GCRYMPI_FMT_USG, frame, &nframe) )
+  if (gcry_mpi_scan (&a, GCRYMPI_FMT_USG, frame, n, &nframe) )
     BUG ();
   gcry_free(frame);
 
@@ -206,7 +206,7 @@ encode_session_key (DEK dek, unsigned int nbits)
 static int
 encrypt_dek (const DEK dek, KsbaCert cert, char **encval)
 {
-  GCRY_SEXP s_ciph, s_data, s_pkey;
+  gcry_sexp_t s_ciph, s_data, s_pkey;
   int rc;
   KsbaSexp buf;
   size_t len;
@@ -218,30 +218,30 @@ encrypt_dek (const DEK dek, KsbaCert cert, char **encval)
   if (!buf)
     {
       log_error ("no public key for recipient\n");
-      return GNUPG_No_Public_Key;
+      return gpg_error (GPG_ERR_NO_PUBKEY);
     }
   len = gcry_sexp_canon_len (buf, 0, NULL, NULL);
   if (!len)
     {
       log_error ("libksba did not return a proper S-Exp\n");
-      return GNUPG_Bug;
+      return gpg_error (GPG_ERR_BUG);
     }
   rc = gcry_sexp_sscan (&s_pkey, NULL, buf, len);
   xfree (buf); buf = NULL;
   if (rc)
     {
-      log_error ("gcry_sexp_scan failed: %s\n", gcry_strerror (rc));
-      return map_gcry_err (rc);
+      log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (rc));
+      return rc;
     }
 
   /* put the encoded cleartext into a simple list */
   {
     /* fixme: actually the pkcs-1 encoding should go into libgcrypt */
-    GCRY_MPI data = encode_session_key (dek, gcry_pk_get_nbits (s_pkey));
+    gcry_mpi_t data = encode_session_key (dek, gcry_pk_get_nbits (s_pkey));
     if (!data)
       {
         gcry_mpi_release (data);
-        return GNUPG_General_Error;
+        return gpg_error (GPG_ERR_GENERAL);
       }
     if (gcry_sexp_build (&s_data, NULL, "%m", data))
       BUG ();
@@ -259,8 +259,9 @@ encrypt_dek (const DEK dek, KsbaCert cert, char **encval)
   buf = xtrymalloc (len);
   if (!buf)
     {
+      gpg_error_t tmperr = OUT_OF_CORE (errno);
       gcry_sexp_release (s_ciph);
-      return GNUPG_Out_Of_Core;
+      return tmperr;
     }
   len = gcry_sexp_sprint (s_ciph, GCRYSEXP_FMT_CANON, buf, len);
   assert (len);
@@ -367,7 +368,7 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
     {
       log_error(_("no valid recipients given\n"));
       gpgsm_status (ctrl, STATUS_NO_RECP, "0");
-      rc = GNUPG_No_Public_Key;
+      rc = gpg_error (GPG_ERR_NO_PUBKEY);
       goto leave;
     }
 
@@ -375,15 +376,15 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   if (!kh)
     {
       log_error (_("failed to allocated keyDB handle\n"));
-      rc = GNUPG_General_Error;
+      rc = gpg_error (GPG_ERR_GENERAL);
       goto leave;
     }
 
   data_fp = fdopen ( dup (data_fd), "rb");
   if (!data_fp)
     {
+      rc = gpg_error (gpg_err_code_from_errno (errno));
       log_error ("fdopen() failed: %s\n", strerror (errno));
-      rc = seterr (IO_Error);
       goto leave;
     }
 
@@ -403,14 +404,14 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   rc = gpgsm_create_writer (&b64writer, ctrl, out_fp, &writer);
   if (rc)
     {
-      log_error ("can't create writer: %s\n", gnupg_strerror (rc));
+      log_error ("can't create writer: %s\n", gpg_strerror (rc));
       goto leave;
     }
 
   cms = ksba_cms_new ();
   if (!cms)
     {
-      rc = seterr (Out_Of_Core);
+      rc = gpg_error (GPG_ERR_ENOMEM);
       goto leave;
     }
 
@@ -439,7 +440,7 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   /* create a session key */
   dek = xtrycalloc (1, sizeof *dek); /* hmmm: should we put it into secmem?*/
   if (!dek)
-    rc = GNUPG_Out_Of_Core;
+    rc = OUT_OF_CORE (errno);
   else
   {
     dek->algoid = opt.def_cipher_algoid;
@@ -448,7 +449,7 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   if (rc)
     {
       log_error ("failed to create the session key: %s\n",
-                 gnupg_strerror (rc));
+                 gpg_strerror (rc));
       goto leave;
     }
 
@@ -467,7 +468,7 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   encparm.buffer = xtrymalloc (encparm.bufsize);
   if (!encparm.buffer)
     {
-      rc = seterr (Out_Of_Core);
+      rc = OUT_OF_CORE (errno);
       goto leave;
     }
 
@@ -481,7 +482,7 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
       if (rc)
         {
           log_error ("encryption failed for recipient no. %d: %s\n",
-                     recpno, gnupg_strerror (rc));
+                     recpno, gpg_strerror (rc));
           goto leave;
         }
       
@@ -523,7 +524,7 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   if (encparm.readerror)
     {
       log_error ("error reading input: %s\n", strerror (encparm.readerror));
-      rc = seterr (Read_Error);
+      rc = gpg_error (gpg_err_code_from_errno (encparm.readerror));
       goto leave;
     }
 
@@ -531,7 +532,7 @@ gpgsm_encrypt (CTRL ctrl, CERTLIST recplist, int data_fd, FILE *out_fp)
   rc = gpgsm_finish_writer (b64writer);
   if (rc) 
     {
-      log_error ("write failed: %s\n", gnupg_strerror (rc));
+      log_error ("write failed: %s\n", gpg_strerror (rc));
       goto leave;
     }
   log_info ("encrypted data created\n");