X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Futil%2Fcrypto_rsa.c;h=99e4bc1c1cd07ac4af70b50ce8e07e4bd01f7655;hb=76c024311489ede1bca79cf647e568dde70d8a48;hp=f686c0359218f4bc39b326f66576e613dd67e1b9;hpb=e9e07433aaf3093e5900080b4ec896b0bdb1901b;p=oweals%2Fgnunet.git

diff --git a/src/util/crypto_rsa.c b/src/util/crypto_rsa.c
index f686c0359..99e4bc1c1 100644
--- a/src/util/crypto_rsa.c
+++ b/src/util/crypto_rsa.c
@@ -559,24 +559,22 @@ rsa_decode_key (const struct RsaPrivateKeyBinaryEncoded *encoding)
 struct GNUNET_CRYPTO_RsaPrivateKey *
 GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
 {
-#ifndef MINGW
-  // FIXME NILS
-  struct flock fl;
-#endif
   struct GNUNET_CRYPTO_RsaPrivateKey *ret;
   struct RsaPrivateKeyBinaryEncoded *enc;
-  struct stat sbuf;
   uint16_t len;
-  int fd;
+  struct GNUNET_DISK_FileHandle *fd;
   unsigned int cnt;
   int ec;
+  uint64_t fs;
 
   if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename))
     return NULL;
-  while (0 != STAT (filename, &sbuf))
+  while (GNUNET_YES != GNUNET_DISK_file_test (filename))
     {
-      fd = open (filename, O_WRONLY | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
-      if (-1 == fd)
+      fd = GNUNET_DISK_file_open (filename, 
+				  GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_FAILIFEXISTS,
+				  GNUNET_DISK_PERM_USER_READ| GNUNET_DISK_PERM_USER_WRITE | GNUNET_DISK_PERM_GROUP_READ);
+      if (NULL == fd)
         {
           if (errno == EEXIST)
             continue;
@@ -584,59 +582,41 @@ GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
                                     "open", filename);
           return NULL;
         }
-#ifndef MINGW
-      memset (&fl, 0, sizeof (struct flock));
-      fl.l_type = F_WRLCK;
-      fl.l_whence = SEEK_SET;
-      fl.l_len = sizeof (struct RsaPrivateKeyBinaryEncoded);
       cnt = 0;
 
-      while (0 != fcntl (fd, F_SETLK, &fl))
+      while (GNUNET_YES != GNUNET_DISK_file_lock (fd, 0, sizeof (struct RsaPrivateKeyBinaryEncoded), GNUNET_YES))
         {
           sleep (1);
           if (0 == ++cnt % 10)
             {
               ec = errno;
-              fl.l_type = F_GETLK;
-              fcntl (fd, F_GETLK, &fl);
               GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                           _
-                          ("Could not aquire lock on file `%s' due to process %u: %s...\n"),
-                          filename, fl.l_pid, STRERROR (errno));
+                          ("Could not aquire lock on file `%s': %s...\n"),
+                          filename, STRERROR (ec));
             }
-          memset (&fl, 0, sizeof (struct flock));
-          fl.l_type = F_WRLCK;
-          fl.l_whence = SEEK_SET;
-          fl.l_len = sizeof (struct RsaPrivateKeyBinaryEncoded);
         }
-#endif
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   _("Creating a new private key.  This may take a while.\n"));
       ret = GNUNET_CRYPTO_rsa_key_create ();
       GNUNET_assert (ret != NULL);
       enc = rsa_encode_key (ret);
       GNUNET_assert (enc != NULL);
-      GNUNET_assert (ntohs (enc->len) == WRITE (fd, enc, ntohs (enc->len)));
+      GNUNET_assert (ntohs (enc->len) == GNUNET_DISK_file_write (fd, enc, ntohs (enc->len)));
       GNUNET_free (enc);
-#ifndef MINGW
-      fdatasync (fd);
-      memset (&fl, 0, sizeof (struct flock));
-      fl.l_type = F_UNLCK;
-      fl.l_whence = SEEK_SET;
-      fl.l_len = sizeof (struct RsaPrivateKeyBinaryEncoded);
-      cnt = 0;
-      if (0 != fcntl (fd, F_SETLK, &fl))
+
+      GNUNET_DISK_file_sync (fd);
+      if (GNUNET_YES != GNUNET_DISK_file_unlock (fd, 0, sizeof (struct RsaPrivateKeyBinaryEncoded)))
         GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                                   "fcntl", filename);
-#endif
-      GNUNET_assert (0 == CLOSE (fd));
+      GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   _("Stored new private key in `%s'.\n"), filename);
       return ret;
     }
   /* hostkey file exists already, read it! */
-  fd = open (filename, O_RDONLY);
-  if (-1 == fd)
+  fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ);
+  if (NULL == fd)
     {
       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", filename);
       return NULL;
@@ -644,22 +624,14 @@ GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
   cnt = 0;
   while (1)
     {
-#ifndef MINGW
-      memset (&fl, 0, sizeof (struct flock));
-      fl.l_type = F_RDLCK;
-      fl.l_whence = SEEK_SET;
-      fl.l_len = sizeof (struct RsaPrivateKeyBinaryEncoded);
-      if (0 != fcntl (fd, F_SETLK, &fl))
+      if (GNUNET_YES != GNUNET_DISK_file_lock (fd, 0, sizeof (struct RsaPrivateKeyBinaryEncoded), GNUNET_NO))
         {
           if (0 == ++cnt % 10)
             {
               ec = errno;
-              fl.l_type = F_GETLK;
-              fcntl (fd, F_GETLK, &fl);
               GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                          _
-                          ("Could not aquire lock on file `%s' due to process %u: %s...\n"),
-                          filename, fl.l_pid, STRERROR (errno));
+                          _("Could not aquire lock on file `%s': %s...\n"),
+                          filename, STRERROR (ec));
               GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                           _
                           ("This may be ok if someone is currently generating a hostkey.\n"));
@@ -667,34 +639,25 @@ GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
           sleep (1);
           continue;
         }
-#endif
-      if (0 != STAT (filename, &sbuf))
+      if (GNUNET_YES != GNUNET_DISK_file_test (filename))
         {
           /* eh, what!? File we opened is now gone!? */
           GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                                     "stat", filename);
-#ifndef MINGW
-          memset (&fl, 0, sizeof (struct flock));
-          fl.l_type = F_UNLCK;
-          fl.l_whence = SEEK_SET;
-          fl.l_len = sizeof (struct RsaPrivateKeyBinaryEncoded);
-          if (0 != fcntl (fd, F_SETLK, &fl))
+          if (GNUNET_YES != GNUNET_DISK_file_unlock (fd, 0, sizeof (struct RsaPrivateKeyBinaryEncoded)))
             GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                                       "fcntl", filename);
-          GNUNET_assert (0 == CLOSE (fd));
-#endif
+          GNUNET_assert (0 == GNUNET_DISK_file_close (fd));
+
           return NULL;
         }
-      if (sbuf.st_size < sizeof (struct RsaPrivateKeyBinaryEncoded))
+      if (GNUNET_YES != GNUNET_DISK_file_size (filename, &fs, GNUNET_YES))
+        fs = 0;
+      if (fs < sizeof (struct RsaPrivateKeyBinaryEncoded))
         {
-#ifndef MINGW
           /* maybe we got the read lock before the hostkey generating
              process had a chance to get the write lock; give it up! */
-          memset (&fl, 0, sizeof (struct flock));
-          fl.l_type = F_UNLCK;
-          fl.l_whence = SEEK_SET;
-          fl.l_len = sizeof (struct RsaPrivateKeyBinaryEncoded);
-          if (0 != fcntl (fd, F_SETLK, &fl))
+          if (GNUNET_YES != GNUNET_DISK_file_unlock (fd, 0, sizeof (struct RsaPrivateKeyBinaryEncoded)))
             GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                                       "fcntl", filename);
           if (0 == ++cnt % 10)
@@ -702,7 +665,7 @@ GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
               GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                           _
                           ("When trying to read hostkey file `%s' I found %u bytes but I need at least %u.\n"),
-                          filename, (unsigned int) sbuf.st_size,
+                          filename, (unsigned int) fs,
                           (unsigned int) sizeof (struct
                                                  RsaPrivateKeyBinaryEncoded));
               GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -711,15 +674,14 @@ GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
             }
           sleep (2);            /* wait a bit longer! */
           continue;
-#endif
         }
       break;
     }
-  enc = GNUNET_malloc (sbuf.st_size);
-  GNUNET_assert (sbuf.st_size == READ (fd, enc, sbuf.st_size));
+  enc = GNUNET_malloc (fs);
+  GNUNET_assert (fs == GNUNET_DISK_file_read (fd, enc, fs));
   len = ntohs (enc->len);
   ret = NULL;
-  if ((len != sbuf.st_size) || (NULL == (ret = rsa_decode_key (enc))))
+  if ((len != fs) || (NULL == (ret = rsa_decode_key (enc))))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _
@@ -727,15 +689,9 @@ GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
                   filename);
     }
   GNUNET_free (enc);
-#ifndef MINGW
-  memset (&fl, 0, sizeof (struct flock));
-  fl.l_type = F_UNLCK;
-  fl.l_whence = SEEK_SET;
-  fl.l_len = sizeof (struct RsaPrivateKeyBinaryEncoded);
-  if (0 != fcntl (fd, F_SETLK, &fl))
+  if (GNUNET_YES != GNUNET_DISK_file_unlock (fd, 0, sizeof (struct RsaPrivateKeyBinaryEncoded)))
     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-#endif
-  GNUNET_assert (0 == CLOSE (fd));
+  GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
   return ret;
 }
 
@@ -752,7 +708,7 @@ GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
  */
 int
 GNUNET_CRYPTO_rsa_encrypt (const void *block,
-                           uint16_t size,
+                           size_t size,
                            const struct
                            GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey,
                            struct GNUNET_CRYPTO_RsaEncryptedData *target)
@@ -800,10 +756,11 @@ GNUNET_CRYPTO_rsa_encrypt (const void *block,
  *        the decrypted block is bigger, an error is returned
  * @returns the size of the decrypted block, -1 on error
  */
-int
+ssize_t
 GNUNET_CRYPTO_rsa_decrypt (const struct GNUNET_CRYPTO_RsaPrivateKey *hostkey,
                            const struct GNUNET_CRYPTO_RsaEncryptedData *block,
-                           void *result, uint16_t max)
+                           void *result, 
+			   size_t max)
 {
   gcry_sexp_t resultsexp;
   gcry_sexp_t data;
@@ -849,7 +806,7 @@ GNUNET_CRYPTO_rsa_decrypt (const struct GNUNET_CRYPTO_RsaPrivateKey *hostkey,
  *
  * @param hostkey private key to use for the signing
  * @param purpose what to sign (size, purpose)
- * @param result where to write the signature
+ * @param sig where to write the signature
  * @return GNUNET_SYSERR on error, GNUNET_OK on success
  */
 int