fix #4483

4 files changed, 54 insertions, 122 deletions

diff --git a/src/exchangedb/perf_taler_exchangedb_init.c b/src/exchangedb/perf_taler_exchangedb_init.c
index 988014a1..5e98c4f5 100644
--- a/src/exchangedb/perf_taler_exchangedb_init.c
+++ b/src/exchangedb/perf_taler_exchangedb_init.c
@@ -573,24 +573,13 @@ struct TALER_EXCHANGEDB_RefreshCommitCoin *
 PERF_TALER_EXCHANGEDB_refresh_commit_coin_init ()
 {
   struct TALER_EXCHANGEDB_RefreshCommitCoin *commit_coin;
-  struct TALER_RefreshLinkEncrypted refresh_link;
 
   commit_coin = GNUNET_new (struct TALER_EXCHANGEDB_RefreshCommitCoin);
-  GNUNET_assert (NULL != commit_coin);
-  {/* refresh_link */
-    refresh_link = (struct TALER_RefreshLinkEncrypted)
-    {
-      .blinding_key_enc = "blinding_key",
-      .blinding_key_enc_size = 13
-    };
-    GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
-                                &refresh_link.coin_priv_enc,
-                                sizeof(struct TALER_CoinSpendPrivateKeyP));
-  }
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
+			      &commit_coin->refresh_link,
+			      sizeof(struct TALER_RefreshLinkEncryptedP));
   commit_coin->coin_ev = "coin_ev";
   commit_coin->coin_ev_size = 8;
-  commit_coin->refresh_link = GNUNET_new (struct TALER_RefreshLinkEncrypted);
-  *commit_coin->refresh_link = refresh_link;
   return commit_coin;
 }
 
@@ -607,8 +596,7 @@ PERF_TALER_EXCHANGEDB_refresh_commit_coin_copy (struct TALER_EXCHANGEDB_RefreshC
   struct TALER_EXCHANGEDB_RefreshCommitCoin *copy;
 
   copy = GNUNET_new (struct TALER_EXCHANGEDB_RefreshCommitCoin);
-  copy->refresh_link = GNUNET_new (struct TALER_RefreshLinkEncrypted);
-  *copy->refresh_link = *commit_coin->refresh_link;
+  *copy = *commit_coin;
   return copy;
 }
 
@@ -621,6 +609,5 @@ PERF_TALER_EXCHANGEDB_refresh_commit_coin_copy (struct TALER_EXCHANGEDB_RefreshC
 void
 PERF_TALER_EXCHANGEDB_refresh_commit_coin_free (struct TALER_EXCHANGEDB_RefreshCommitCoin *commit_coin)
 {
-  GNUNET_free (commit_coin->refresh_link);
   GNUNET_free (commit_coin);
 }
diff --git a/src/exchangedb/plugin_exchangedb_common.c b/src/exchangedb/plugin_exchangedb_common.c
index 9b62d688..16396f0f 100644
--- a/src/exchangedb/plugin_exchangedb_common.c
+++ b/src/exchangedb/plugin_exchangedb_common.c
@@ -73,7 +73,6 @@ common_free_link_data_list (void *cls,
   while (NULL != ldl)
   {
     next = ldl->next;
-    GNUNET_free (ldl->link_data_enc);
     GNUNET_free (ldl);
     ldl = next;
   }
@@ -147,7 +146,6 @@ common_free_melt_commitment (void *cls,
       {
         /* NOTE: 'non_null' because this API is used also
            internally to clean up the struct on failures! */
-        GNUNET_free_non_null (mc->commit_coins[k][i].refresh_link);
         GNUNET_free_non_null (mc->commit_coins[k][i].coin_ev);
       }
       GNUNET_free (mc->commit_coins[k]);
diff --git a/src/exchangedb/plugin_exchangedb_postgres.c b/src/exchangedb/plugin_exchangedb_postgres.c
index e2b158c9..694ab01d 100644
--- a/src/exchangedb/plugin_exchangedb_postgres.c
+++ b/src/exchangedb/plugin_exchangedb_postgres.c
@@ -3064,29 +3064,19 @@ postgres_insert_refresh_commit_coins (void *cls,
                                       uint16_t num_newcoins,
                                       const struct TALER_EXCHANGEDB_RefreshCommitCoin *commit_coins)
 {
-  char *rle;
-  size_t rle_size;
   PGresult *result;
   unsigned int i;
   uint16_t coin_off;
 
   for (i=0;i<(unsigned int) num_newcoins;i++)
   {
-    rle = TALER_refresh_link_encrypted_encode (commit_coins[i].refresh_link,
-                                               &rle_size);
-    if (NULL == rle)
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
     coin_off = (uint16_t) i;
     {
       struct GNUNET_PQ_QueryParam params[] = {
         GNUNET_PQ_query_param_auto_from_type (session_hash),
         GNUNET_PQ_query_param_uint16 (&cnc_index),
         GNUNET_PQ_query_param_uint16 (&coin_off),
-        GNUNET_PQ_query_param_fixed_size (rle,
-                                         rle_size),
+        GNUNET_PQ_query_param_auto_from_type (&commit_coins[i].refresh_link),
         GNUNET_PQ_query_param_fixed_size (commit_coins[i].coin_ev,
                                          commit_coins[i].coin_ev_size),
         GNUNET_PQ_query_param_end
@@ -3095,7 +3085,6 @@ postgres_insert_refresh_commit_coins (void *cls,
                                        "insert_refresh_commit_coin",
                                        params);
     }
-    GNUNET_free (rle);
     if (PGRES_COMMAND_OK != PQresultStatus (result))
     {
       BREAK_DB_ERR (result);
@@ -3131,8 +3120,6 @@ postgres_free_refresh_commit_coins (void *cls,
 
   for (i=0;i<commit_coins_len;i++)
   {
-    GNUNET_free (commit_coins[i].refresh_link);
-    commit_coins[i].refresh_link = NULL;
     GNUNET_free (commit_coins[i].coin_ev);
     commit_coins[i].coin_ev = NULL;
     commit_coins[i].coin_ev_size = 0;
@@ -3175,9 +3162,6 @@ postgres_get_refresh_commit_coins (void *cls,
     };
     void *c_buf;
     size_t c_buf_size;
-    void *rl_buf;
-    size_t rl_buf_size;
-    struct TALER_RefreshLinkEncrypted *rl;
     PGresult *result;
 
     result = GNUNET_PQ_exec_prepared (session->conn,
@@ -3198,12 +3182,11 @@ postgres_get_refresh_commit_coins (void *cls,
     }
     {
       struct GNUNET_PQ_ResultSpec rs[] = {
-        GNUNET_PQ_result_spec_variable_size ("link_vector_enc",
-                                            &rl_buf,
-                                            &rl_buf_size),
+        GNUNET_PQ_result_spec_auto_from_type ("link_vector_enc",
+					      &commit_coins[i].refresh_link),
         GNUNET_PQ_result_spec_variable_size ("coin_ev",
-                                            &c_buf,
-                                            &c_buf_size),
+					     &c_buf,
+					     &c_buf_size),
         GNUNET_PQ_result_spec_end
       };
 
@@ -3216,17 +3199,6 @@ postgres_get_refresh_commit_coins (void *cls,
       }
     }
     PQclear (result);
-    if (rl_buf_size < sizeof (struct TALER_CoinSpendPrivateKeyP))
-    {
-      GNUNET_free (c_buf);
-      GNUNET_free (rl_buf);
-      postgres_free_refresh_commit_coins (cls, i, commit_coins);
-      return GNUNET_SYSERR;
-    }
-    rl = TALER_refresh_link_encrypted_decode (rl_buf,
-                                              rl_buf_size);
-    GNUNET_free (rl_buf);
-    commit_coins[i].refresh_link = rl;
     commit_coins[i].coin_ev = c_buf;
     commit_coins[i].coin_ev_size = c_buf_size;
   }
@@ -3475,7 +3447,6 @@ postgres_get_link_data_list (void *cls,
                              const struct GNUNET_HashCode *session_hash)
 {
   struct TALER_EXCHANGEDB_LinkDataList *ldl;
-  struct TALER_EXCHANGEDB_LinkDataList *pos;
   int i;
   int nrows;
   struct GNUNET_PQ_QueryParam params[] = {
@@ -3503,45 +3474,34 @@ postgres_get_link_data_list (void *cls,
 
   for (i = 0; i < nrows; i++)
   {
-    struct TALER_RefreshLinkEncrypted *link_enc;
     struct GNUNET_CRYPTO_RsaPublicKey *denom_pub;
     struct GNUNET_CRYPTO_RsaSignature *sig;
-    void *ld_buf;
-    size_t ld_buf_size;
-    struct GNUNET_PQ_ResultSpec rs[] = {
-      GNUNET_PQ_result_spec_variable_size ("link_vector_enc",
-                                           &ld_buf,
-                                           &ld_buf_size),
-      GNUNET_PQ_result_spec_rsa_signature ("ev_sig",
-                                           &sig),
-      GNUNET_PQ_result_spec_rsa_public_key ("denom_pub",
-                                            &denom_pub),
-      GNUNET_PQ_result_spec_end
-    };
+    struct TALER_EXCHANGEDB_LinkDataList *pos;
 
-    if (GNUNET_OK !=
-        GNUNET_PQ_extract_result (result, rs, i))
-    {
-      PQclear (result);
-      GNUNET_break (0);
-      common_free_link_data_list (cls,
-                                  ldl);
-      return NULL;
-    }
-    if (ld_buf_size < sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey))
+    pos = GNUNET_new (struct TALER_EXCHANGEDB_LinkDataList);
     {
-      PQclear (result);
-      GNUNET_free (ld_buf);
-      common_free_link_data_list (cls,
-                                  ldl);
-      return NULL;
+      struct GNUNET_PQ_ResultSpec rs[] = {
+	GNUNET_PQ_result_spec_auto_from_type ("link_vector_enc",
+					      &pos->link_data_enc),
+	GNUNET_PQ_result_spec_rsa_signature ("ev_sig",
+					     &sig),
+	GNUNET_PQ_result_spec_rsa_public_key ("denom_pub",
+					      &denom_pub),
+	GNUNET_PQ_result_spec_end
+      };
+      
+      if (GNUNET_OK !=
+	  GNUNET_PQ_extract_result (result, rs, i))
+      {
+	PQclear (result);
+	GNUNET_break (0);
+	common_free_link_data_list (cls,
+				    ldl);
+	GNUNET_free (pos);
+	return NULL;
+      }
     }
-    link_enc = TALER_refresh_link_encrypted_decode (ld_buf,
-                                                    ld_buf_size);
-    GNUNET_free (ld_buf);
-    pos = GNUNET_new (struct TALER_EXCHANGEDB_LinkDataList);
     pos->next = ldl;
-    pos->link_data_enc = link_enc;
     pos->denom_pub.rsa_public_key = denom_pub;
     pos->ev_sig.rsa_signature = sig;
     ldl = pos;
diff --git a/src/exchangedb/test_exchangedb.c b/src/exchangedb/test_exchangedb.c
index a5530e3c..d9c04b8c 100644
--- a/src/exchangedb/test_exchangedb.c
+++ b/src/exchangedb/test_exchangedb.c
@@ -301,18 +301,13 @@ static struct TALER_Amount amount_with_fee;
  * @return 0 if they are equal
  */
 static int
-refresh_link_encrypted_cmp (struct TALER_RefreshLinkEncrypted *rl1,
-                            struct TALER_RefreshLinkEncrypted *rl2)
+refresh_link_encrypted_cmp (struct TALER_RefreshLinkEncryptedP *rl1,
+                            struct TALER_RefreshLinkEncryptedP *rl2)
 {
-  if ( (rl1->blinding_key_enc_size == rl2->blinding_key_enc_size) &&
-       (0 ==
-        memcmp (rl1->coin_priv_enc,
-                rl2->coin_priv_enc,
-                sizeof (struct TALER_CoinSpendPrivateKeyP))) &&
-       (0 ==
-        memcmp (rl1->blinding_key_enc,
-                rl2->blinding_key_enc,
-                rl1->blinding_key_enc_size)) )
+  if (0 ==
+      memcmp (rl1,
+	      rl2,
+	      sizeof (struct TALER_RefreshLinkEncryptedP)))
     return 0;
   return 1;
 }
@@ -334,8 +329,8 @@ commit_coin_cmp (struct TALER_EXCHANGEDB_RefreshCommitCoin *rc1,
                        rc2->coin_ev,
                        rc2->coin_ev_size));
   FAILIF (0 !=
-          refresh_link_encrypted_cmp (rc1->refresh_link,
-                                      rc2->refresh_link));
+          refresh_link_encrypted_cmp (&rc1->refresh_link,
+                                      &rc2->refresh_link));
   return 0;
  drop:
   return 1;
@@ -370,10 +365,9 @@ test_refresh_commit_coins (struct TALER_EXCHANGEDB_Session *session,
 {
   struct TALER_EXCHANGEDB_RefreshCommitCoin *ret_commit_coins;
   struct TALER_EXCHANGEDB_RefreshCommitCoin *a_ccoin;
-  struct TALER_RefreshLinkEncrypted *a_rlink;
+  struct TALER_RefreshLinkEncryptedP a_rlink;
   struct TALER_EXCHANGEDB_RefreshCommitCoin *b_ccoin;
-  struct TALER_RefreshLinkEncrypted *b_rlink;
-  size_t size;
+  struct TALER_RefreshLinkEncryptedP b_rlink;
   unsigned int cnt;
   uint16_t cnc_index;
   int ret;
@@ -389,12 +383,12 @@ test_refresh_commit_coins (struct TALER_EXCHANGEDB_Session *session,
     for (cnt=0; cnt < MELT_NEW_COINS; cnt++)
     {
       struct TALER_EXCHANGEDB_RefreshCommitCoin *ccoin;
-      struct TALER_RefreshLinkEncrypted *rlink;
+      struct TALER_RefreshLinkEncryptedP rlink;
 
       ccoin = &commit_coins[cnc_index][cnt];
-      size = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                       COIN_ENC_MAX_SIZE);
-      rlink = GNUNET_malloc (sizeof (struct TALER_RefreshLinkEncrypted) + size);
+      GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
+                                  &rlink,
+                                  sizeof (rlink));
       ccoin->refresh_link = rlink;
       ccoin->coin_ev_size = GNUNET_CRYPTO_random_u64
         (GNUNET_CRYPTO_QUALITY_WEAK, COIN_ENC_MAX_SIZE);
@@ -402,12 +396,6 @@ test_refresh_commit_coins (struct TALER_EXCHANGEDB_Session *session,
       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,
@@ -436,13 +424,12 @@ test_refresh_commit_coins (struct TALER_EXCHANGEDB_Session *session,
                            a_ccoin->coin_ev_size));
       a_rlink = a_ccoin->refresh_link;
       b_rlink = b_ccoin->refresh_link;
-      FAILIF (a_rlink->blinding_key_enc_size != b_rlink->blinding_key_enc_size);
-      FAILIF (0 != memcmp (a_rlink->blinding_key_enc,
-                           b_rlink->blinding_key_enc,
-                           a_rlink->blinding_key_enc_size));
-      FAILIF (0 != memcmp (a_rlink->coin_priv_enc,
-                           b_rlink->coin_priv_enc,
-                           sizeof (a_rlink->coin_priv_enc)));
+      FAILIF (0 != memcmp (a_rlink.blinding_key_enc,
+                           b_rlink.blinding_key_enc,
+                           sizeof (a_rlink.blinding_key_enc)));
+      FAILIF (0 != memcmp (a_rlink.coin_priv_enc,
+                           b_rlink.coin_priv_enc,
+                           sizeof (a_rlink.coin_priv_enc)));
     }
   }
   ret = GNUNET_OK;
@@ -745,8 +732,8 @@ test_melting (struct TALER_EXCHANGEDB_Session *session)
   FAILIF (NULL == ldl);
   for (ldlp = ldl; NULL != ldlp; ldlp = ldlp->next)
   {
-    struct TALER_RefreshLinkEncrypted *r1;
-    struct TALER_RefreshLinkEncrypted *r2;
+    struct TALER_RefreshLinkEncryptedP r1;
+    struct TALER_RefreshLinkEncryptedP r2;
     int found;
 
     found = GNUNET_NO;
@@ -762,7 +749,7 @@ test_melting (struct TALER_EXCHANGEDB_Session *session)
             GNUNET_CRYPTO_rsa_signature_cmp (ldlp->ev_sig.rsa_signature,
                                              ev_sigs[cnt].rsa_signature)) &&
            (0 ==
-            refresh_link_encrypted_cmp (r1, r2)) )
+            refresh_link_encrypted_cmp (&r1, &r2)) )
       {
         found = GNUNET_YES;
         break;