Update plibc header

[oweals/gnunet.git] / src / util / test_crypto_ecc.c

diff --git a/src/util/test_crypto_ecc.c b/src/util/test_crypto_ecc.c
index dca14963262127547765fe0666177d82d8561bb6..c89568bb9e66a60c3fe450975984298e82021636 100644 (file)
--- a/src/util/test_crypto_ecc.c
+++ b/src/util/test_crypto_ecc.c
@@ -43,13 +43,13 @@ testSignVerify ()
 {
   struct GNUNET_CRYPTO_EccSignature sig;
   struct GNUNET_CRYPTO_EccSignaturePurpose purp;
-  struct GNUNET_CRYPTO_EccPublicKey pkey;
+  struct GNUNET_CRYPTO_EccPublicSignKey pkey;
   int i;
   struct GNUNET_TIME_Absolute start;
   int ok = GNUNET_OK;
 
   FPRINTF (stderr, "%s",  "W");
-  GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &pkey);
   start = GNUNET_TIME_absolute_get ();
   purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
   purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
@@ -92,37 +92,37 @@ testDeriveSignVerify ()
   struct GNUNET_CRYPTO_EccSignature sig;
   struct GNUNET_CRYPTO_EccSignaturePurpose purp;
   struct GNUNET_CRYPTO_EccPrivateKey *dpriv;
-  struct GNUNET_CRYPTO_EccPublicKey pkey;
-  struct GNUNET_CRYPTO_EccPublicKey dpub;
+  struct GNUNET_CRYPTO_EccPublicSignKey pkey;
+  struct GNUNET_CRYPTO_EccPublicSignKey dpub;
 
-  dpriv = GNUNET_CRYPTO_ecc_key_derive (key, "test-derive");
-  GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
-  GNUNET_CRYPTO_ecc_public_key_derive (&pkey, "test-derive", &dpub);
+  dpriv = GNUNET_CRYPTO_ecc_key_derive (key, "test-derive", "test-CTX");
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &pkey);
+  GNUNET_CRYPTO_ecc_public_key_derive (&pkey, "test-derive", "test-CTX", &dpub);
   purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
   purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
 
   if (GNUNET_SYSERR == GNUNET_CRYPTO_ecc_sign (dpriv, &purp, &sig))
   {
     FPRINTF (stderr, "%s",  "GNUNET_CRYPTO_ecc_sign returned SYSERR\n");
-    GNUNET_CRYPTO_ecc_key_free (dpriv);
+    GNUNET_free (dpriv);
     return GNUNET_SYSERR;
   }
   if (GNUNET_SYSERR ==
-      GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_TEST, 
+      GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
                                &purp, &sig,
                                &dpub))
   {
     printf ("GNUNET_CRYPTO_ecc_verify failed!\n");
-    GNUNET_CRYPTO_ecc_key_free (dpriv);
+    GNUNET_free (dpriv);
     return GNUNET_SYSERR;
   }
   if (GNUNET_SYSERR !=
-      GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_TEST, 
+      GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
                                &purp, &sig,
                                &pkey))
   {
     printf ("GNUNET_CRYPTO_ecc_verify failed to fail!\n");
-    GNUNET_CRYPTO_ecc_key_free (dpriv);
+    GNUNET_free (dpriv);
     return GNUNET_SYSERR;
   }
   if (GNUNET_SYSERR !=
@@ -130,10 +130,10 @@ testDeriveSignVerify ()
                                &purp, &sig, &dpub))
   {
     printf ("GNUNET_CRYPTO_ecc_verify failed to fail!\n");
-    GNUNET_CRYPTO_ecc_key_free (dpriv);
+    GNUNET_free (dpriv);
     return GNUNET_SYSERR;
   }
-  GNUNET_CRYPTO_ecc_key_free (dpriv);
+  GNUNET_free (dpriv);
   return GNUNET_OK;
 }
 
@@ -146,7 +146,7 @@ testSignPerformance ()
 {
   struct GNUNET_CRYPTO_EccSignaturePurpose purp;
   struct GNUNET_CRYPTO_EccSignature sig;
-  struct GNUNET_CRYPTO_EccPublicKey pkey;
+  struct GNUNET_CRYPTO_EccPublicSignKey pkey;
   int i;
   struct GNUNET_TIME_Absolute start;
   int ok = GNUNET_OK;
@@ -154,7 +154,7 @@ testSignPerformance ()
   purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
   purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
   FPRINTF (stderr, "%s",  "W");
-  GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &pkey);
   start = GNUNET_TIME_absolute_get ();
   for (i = 0; i < ITER; i++)
   {
@@ -166,9 +166,9 @@ testSignPerformance ()
       continue;
     }
   }
-  printf ("%d ECC sign operations %llu ms\n", ITER,
-          (unsigned long long)
-          GNUNET_TIME_absolute_get_duration (start).rel_value);
+  printf ("%d ECC sign operations %s\n", ITER,
+          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
+                                                 GNUNET_YES));
   return ok;
 }
 #endif
@@ -177,24 +177,24 @@ testSignPerformance ()
 static int
 testCreateFromFile ()
 {
-  struct GNUNET_CRYPTO_EccPublicKey p1;
-  struct GNUNET_CRYPTO_EccPublicKey p2;
+  struct GNUNET_CRYPTO_EccPublicSignKey p1;
+  struct GNUNET_CRYPTO_EccPublicSignKey p2;
 
   key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE);
   GNUNET_assert (NULL != key);
-  GNUNET_CRYPTO_ecc_key_get_public (key, &p1);
-  GNUNET_CRYPTO_ecc_key_free (key);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &p1);
+  GNUNET_free (key);
   key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE);
   GNUNET_assert (NULL != key);
-  GNUNET_CRYPTO_ecc_key_get_public (key, &p2);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &p2);
   GNUNET_assert (0 == memcmp (&p1, &p2, sizeof (p1)));
-  GNUNET_CRYPTO_ecc_key_free (key);
+  GNUNET_free (key);
   GNUNET_assert (0 == UNLINK (KEYFILE));
   key = GNUNET_CRYPTO_ecc_key_create_from_file (KEYFILE);
   GNUNET_assert (NULL != key);
-  GNUNET_CRYPTO_ecc_key_get_public (key, &p2);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &p2);
   GNUNET_assert (0 != memcmp (&p1, &p2, sizeof (p1)));
-  GNUNET_CRYPTO_ecc_key_free (key);
+  GNUNET_free (key);
   return GNUNET_OK;
 }
 
@@ -204,21 +204,21 @@ test_ecdh ()
 {
   struct GNUNET_CRYPTO_EccPrivateKey *priv1;
   struct GNUNET_CRYPTO_EccPrivateKey *priv2;
-  struct GNUNET_CRYPTO_EccPublicKey pub1;
-  struct GNUNET_CRYPTO_EccPublicKey pub2;
+  struct GNUNET_CRYPTO_EccPublicEncryptKey pub1;
+  struct GNUNET_CRYPTO_EccPublicEncryptKey pub2;
   struct GNUNET_HashCode ecdh1;
   struct GNUNET_HashCode ecdh2;
 
   priv1 = GNUNET_CRYPTO_ecc_key_create ();
   priv2 = GNUNET_CRYPTO_ecc_key_create ();
-  GNUNET_CRYPTO_ecc_key_get_public (priv1, &pub1);
-  GNUNET_CRYPTO_ecc_key_get_public (priv2, &pub2);
+  GNUNET_CRYPTO_ecc_key_get_public_for_encryption (priv1, &pub1);
+  GNUNET_CRYPTO_ecc_key_get_public_for_encryption (priv2, &pub2);
   GNUNET_CRYPTO_ecc_ecdh (priv1, &pub2, &ecdh1);
   GNUNET_CRYPTO_ecc_ecdh (priv2, &pub1, &ecdh2);
   GNUNET_assert (0 == memcmp (&ecdh1, &ecdh2,
                              sizeof (struct GNUNET_HashCode)));
-  GNUNET_CRYPTO_ecc_key_free (priv1);
-  GNUNET_CRYPTO_ecc_key_free (priv2);
+  GNUNET_free (priv1);
+  GNUNET_free (priv2);
 }
 
 
@@ -234,7 +234,7 @@ perf_keygen ()
   {
     fprintf (stderr, ".");
     pk = GNUNET_CRYPTO_ecc_key_create ();
-    GNUNET_CRYPTO_ecc_key_free (pk);
+    GNUNET_free (pk);
   }
   fprintf (stderr, "\n");
   printf ("Creating 10 ECC keys took %s\n",
@@ -255,7 +255,7 @@ main (int argc, char *argv[])
              "1.5.0");
     return 0;
   }
-  GNUNET_log_setup ("test-crypto-ecc", "ERROR", NULL);
+  GNUNET_log_setup ("test-crypto-ecc", "WARNING", NULL);
   key = GNUNET_CRYPTO_ecc_key_create ();
   if (GNUNET_OK != testDeriveSignVerify ())
   {
@@ -270,7 +270,7 @@ main (int argc, char *argv[])
 #endif
   if (GNUNET_OK != testSignVerify ())
     failure_count++;
-  GNUNET_CRYPTO_ecc_key_free (key);
+  GNUNET_free (key);
   if (GNUNET_OK != testCreateFromFile ())
     failure_count++;
   GNUNET_assert (0 == UNLINK (KEYFILE));
@@ -280,7 +280,7 @@ main (int argc, char *argv[])
   if (0 != failure_count)
   {
     fprintf (stderr,
-            "\n\n%d TESTS FAILED!\n\n", 
+            "\n\n%d TESTS FAILED!\n\n",
             failure_count);
     return -1;
   }