Merge branch 'master' of ssh://taler.net:/var/git/mint

1 files changed, 97 insertions, 1 deletions

diff --git a/src/mintdb/test_mintdb.c b/src/mintdb/test_mintdb.c
index 69147b0b7..f2a4d8d35 100644
--- a/src/mintdb/test_mintdb.c
+++ b/src/mintdb/test_mintdb.c
@@ -185,9 +185,11 @@ test_melting (struct TALER_MINTDB_Session *session)
   struct TALER_MINTDB_RefreshSession ret_refresh_session;
   struct GNUNET_HashCode session_hash;
   struct DenomKeyPair *dkp;
-  struct DenomKeyPair *new_dkp;
+  struct DenomKeyPair **new_dkp;
   /* struct TALER_CoinPublicInfo *coins; */
   struct TALER_MINTDB_RefreshMelt *melts;
+  struct TALER_DenominationPublicKey *new_denom_pubs;
+  struct TALER_DenominationPublicKey *ret_denom_pubs;
   unsigned int cnt;
   int ret;
 
@@ -195,6 +197,8 @@ test_melting (struct TALER_MINTDB_Session *session)
   RND_BLK (&refresh_session);
   RND_BLK (&session_hash);
   melts = NULL;
+  new_dkp = NULL;
+  new_denom_pubs = NULL;
   /* create and test a refresh session */
   refresh_session.num_oldcoins = MELT_OLD_COINS;
   refresh_session.num_newcoins = 1;
@@ -266,16 +270,108 @@ test_melting (struct TALER_MINTDB_Session *session)
     GNUNET_CRYPTO_rsa_signature_free (ret_melt.coin.denom_sig.rsa_signature);
     GNUNET_CRYPTO_rsa_public_key_free (ret_melt.coin.denom_pub.rsa_public_key);
   }
+  new_dkp = GNUNET_new_array (MELT_NEW_COINS, struct DenomKeyPair *);
+  new_denom_pubs = GNUNET_new_array (MELT_NEW_COINS,
+                                     struct TALER_DenominationPublicKey);
+  for (cnt=0; cnt < MELT_NEW_COINS; cnt++)
+  {
+    new_dkp[cnt] = create_denom_key_pair (128, session,
+                                          &value,
+                                          &fee_withdraw,
+                                          &fee_deposit,
+                                          &fee_refresh);
+    new_denom_pubs[cnt]=new_dkp[cnt]->pub;
+  }
+  FAILIF (GNUNET_OK != plugin->insert_refresh_order (plugin->cls,
+                                                       session,
+                                                       &session_hash,
+                                                       MELT_NEW_COINS,
+                                                       new_denom_pubs));
+  ret_denom_pubs = GNUNET_new_array (MELT_NEW_COINS,
+                                     struct TALER_DenominationPublicKey);
+  FAILIF (GNUNET_OK != plugin->get_refresh_order (plugin->cls,
+                                                  session,
+                                                  &session_hash,
+                                                  MELT_NEW_COINS,
+                                                  ret_denom_pubs));
+  for (cnt=0; cnt < MELT_NEW_COINS; cnt++)
+  {
+    FAILIF (0 != GNUNET_CRYPTO_rsa_public_key_cmp
+            (ret_denom_pubs[cnt].rsa_public_key,
+             new_denom_pubs[cnt].rsa_public_key));
+  }
+  struct TALER_MINTDB_RefreshCommitCoin *commit_coins;
+  struct TALER_MINTDB_RefreshCommitCoin *ccoin;
+  struct TALER_RefreshLinkEncrypted *rlink;
+  size_t size;
+  uint16_t cnc_index;
+
+#define COIN_ENC_MAX_SIZE 512
+  commit_coins = GNUNET_new_array (MELT_NEW_COINS,
+                                   struct TALER_MINTDB_RefreshCommitCoin);
+  cnc_index = (uint16_t) GNUNET_CRYPTO_random_u32
+      (GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_MIN (MELT_NEW_COINS, UINT16_MAX));
+  for (cnt=0; cnt < MELT_NEW_COINS; cnt++)
+  {
+    ccoin = &commit_coins[cnt];
+    size = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                  COIN_ENC_MAX_SIZE);
+    rlink = GNUNET_malloc (sizeof (struct TALER_RefreshLinkEncrypted) + size);
+    ccoin->refresh_link = rlink;
+    ccoin->coin_ev_size = GNUNET_CRYPTO_random_u64
+        (GNUNET_CRYPTO_QUALITY_WEAK, COIN_ENC_MAX_SIZE);
+    ccoin->coin_ev = GNUNET_malloc (ccoin->coin_ev_size);
+    GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
+                                ccoin->coin_ev,
+                                ccoin->coin_ev_size);
+    rlink->blinding_key_enc_size = size;
+    RND_BLK (&rlink->coin_priv_enc);
+    rlink->blinding_key_enc = (const char *) &rlink[1];
+    GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
+                                (void *)rlink->blinding_key_enc,
+                                rlink->blinding_key_enc_size);
+  }
+  FAILIF (GNUNET_OK !=
+          plugin->insert_refresh_commit_coins (plugin->cls,
+                                               session,
+                                               &session_hash,
+                                               cnc_index,
+                                               MELT_NEW_COINS,
+                                               commit_coins));
+
   ret = GNUNET_OK;
 
  drop:
   destroy_denom_key_pair (dkp);
+  if (NULL != commit_coins)
+  {
+    for (cnt = 0; cnt < MELT_NEW_COINS; cnt++)
+    {
+      ccoin = &commit_coins[cnt];
+      GNUNET_free_non_null (ccoin->coin_ev);
+      rlink = (struct TALER_RefreshLinkEncrypted *) ccoin->refresh_link;
+      GNUNET_free_non_null (rlink);
+    }
+    GNUNET_free (commit_coins);
+  }
   if (NULL != melts)
   {
     for (cnt = 0; cnt < MELT_OLD_COINS; cnt++)
       GNUNET_CRYPTO_rsa_signature_free (melts[cnt].coin.denom_sig.rsa_signature);
     GNUNET_free (melts);
   }
+  for (cnt = 0;
+       (NULL != ret_denom_pubs) && (cnt < MELT_NEW_COINS)
+           && (NULL != ret_denom_pubs[cnt].rsa_public_key);
+       cnt++)
+    GNUNET_CRYPTO_rsa_public_key_free (ret_denom_pubs[cnt].rsa_public_key);
+  GNUNET_free_non_null (ret_denom_pubs);
+  GNUNET_free_non_null (new_denom_pubs);
+  for (cnt = 0;
+       (NULL != new_dkp) && (cnt < MELT_NEW_COINS) && (NULL != new_dkp[cnt]);
+       cnt++)
+    destroy_denom_key_pair (new_dkp[cnt]);
+  GNUNET_free_non_null (new_dkp);
   return ret;
 }