test_known_coins.c (31007B)
1 /* 2 This file is part of TALER 3 Copyright (C) 2026 Taler Systems SA 4 5 TALER is free software; you can redistribute it and/or modify it under the 6 terms of the GNU General Public License as published by the Free Software 7 Foundation; either version 3, or (at your option) any later version. 8 9 TALER is distributed in the hope that it will be useful, but WITHOUT ANY 10 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR 11 A PARTICULAR PURPOSE. See the GNU General Public License for more details. 12 13 You should have received a copy of the GNU General Public License along with 14 TALER; see the file COPYING. If not, see <http://www.gnu.org/licenses/> 15 */ 16 /** 17 * @file exchangedb/test_known_coins.c 18 * @brief tests for the exchangedb functions whose primary table is 19 * `known_coins` 20 * @author Christian Grothoff 21 * 22 * Covers #TALER_EXCHANGEDB_do_insert_known_coins(), 23 * #TALER_EXCHANGEDB_get_known_coin(), 24 * #TALER_EXCHANGEDB_get_coin_denomination(), 25 * #TALER_EXCHANGEDB_get_signature_for_known_coin(), 26 * #TALER_EXCHANGEDB_get_denomination_proof_for_known_coin() and 27 * #TALER_EXCHANGEDB_get_count_known_coins(). 28 * 29 * `known_coins` references `denominations`, so a denomination is created 30 * first with TDB_denom(). do_insert_known_coins() is the interesting one: 31 * it is idempotent, but only for a coin that comes back with the *same* 32 * denomination and age commitment -- the conflicting cases are what its 33 * negative per-coin status codes are for. It takes a whole batch of 34 * coins in one round trip, so the last check mixes all cases in one call 35 * and verifies that every coin is reported at its own position. 36 */ 37 #include "test_common.h" 38 #include "exchange-database/do_insert_known_coins.h" 39 #include "exchange-database/get_known_coin.h" 40 #include "exchange-database/get_coin_denomination.h" 41 #include "exchange-database/get_signature_for_known_coin.h" 42 #include "exchange-database/get_denomination_proof_for_known_coin.h" 43 #include "exchange-database/get_count_known_coins.h" 44 #include "exchange-database/start.h" 45 #include "exchange-database/rollback.h" 46 47 48 /** 49 * Make a single @a coin known via the batch function. 50 * 51 * @param pg the database context 52 * @param coin the coin to make known 53 * @param[out] res outcome for the coin 54 * @return database status, #GNUNET_DB_STATUS_SUCCESS_ONE_RESULT on success 55 */ 56 static enum GNUNET_DB_QueryStatus 57 insert_one (struct TALER_EXCHANGEDB_PostgresContext *pg, 58 const struct TALER_CoinPublicInfo *coin, 59 struct TALER_EXCHANGEDB_CoinKnownResult *res) 60 { 61 const struct TALER_CoinPublicInfo *coins[1] = { coin }; 62 63 return TALER_EXCHANGEDB_do_insert_known_coins (pg, 64 1, 65 coins, 66 res); 67 } 68 69 70 /** 71 * Nothing is known about a coin that was never inserted. 72 * 73 * @param pg the database context 74 * @return 0 on success 75 */ 76 static int 77 check_empty (struct TALER_EXCHANGEDB_PostgresContext *pg) 78 { 79 struct TALER_CoinSpendPublicKeyP coin_pub; 80 struct TALER_CoinPublicInfo info; 81 struct TALER_DenominationHashP h_denom_pub; 82 struct TALER_DenominationPublicKey denom_pub = { 0 }; 83 struct TALER_DenominationSignature denom_sig = { 0 }; 84 struct TALER_AgeCommitmentHashP h_age_commitment; 85 bool no_age_commitment; 86 uint64_t known_coin_id; 87 88 TDB_FILL (coin_pub, 89 1); 90 TDB_FILL (h_denom_pub, 91 1); 92 FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS != 93 TALER_EXCHANGEDB_get_known_coin (pg, 94 &coin_pub, 95 &info)); 96 FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS != 97 TALER_EXCHANGEDB_get_coin_denomination (pg, 98 &coin_pub, 99 &known_coin_id, 100 &h_denom_pub)); 101 FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS != 102 TALER_EXCHANGEDB_get_signature_for_known_coin (pg, 103 &coin_pub, 104 &denom_pub, 105 &denom_sig)); 106 FAILIF (NULL != denom_pub.bsign_pub_key); 107 FAILIF (NULL != denom_sig.unblinded_sig); 108 FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS != 109 TALER_EXCHANGEDB_get_denomination_proof_for_known_coin ( 110 pg, 111 &coin_pub, 112 &denom_pub, 113 &denom_sig, 114 &h_age_commitment, 115 &no_age_commitment)); 116 FAILIF (NULL != denom_pub.bsign_pub_key); 117 FAILIF (NULL != denom_sig.unblinded_sig); 118 /* a denomination that does not exist has no coins */ 119 FAILIF (0 != TALER_EXCHANGEDB_get_count_known_coins (pg, 120 &h_denom_pub)); 121 return 0; 122 } 123 124 125 /** 126 * A coin of an unknown denomination cannot be made known. 127 * 128 * @param pg the database context 129 * @return 0 on success 130 */ 131 static int 132 check_unknown_denomination (struct TALER_EXCHANGEDB_PostgresContext *pg) 133 { 134 struct TALER_CoinPublicInfo coin; 135 struct TALER_EXCHANGEDB_CoinKnownResult res; 136 137 memset (&coin, 138 0, 139 sizeof (coin)); 140 TDB_FILL (coin.coin_pub, 141 2); 142 TDB_FILL (coin.denom_pub_hash, 143 2); 144 coin.no_age_commitment = true; 145 TDB_denom_sig (2, 146 &coin.denom_sig); 147 /* no denomination row, so nothing is inserted and no coin is found 148 either: the row for the coin has no known_coin_id, a hard error */ 149 FAILIF_C (GNUNET_DB_STATUS_HARD_ERROR != 150 insert_one (pg, 151 &coin, 152 &res), 153 TALER_denom_sig_free (&coin.denom_sig)); 154 TALER_denom_sig_free (&coin.denom_sig); 155 FAILIF (0 != TDB_count (pg, 156 "FROM known_coins")); 157 return 0; 158 } 159 160 161 /** 162 * Making a coin known stores it, and every lookup finds it. 163 * 164 * @param pg the database context 165 * @return 0 on success 166 */ 167 static int 168 check_insert_and_lookup (struct TALER_EXCHANGEDB_PostgresContext *pg) 169 { 170 struct TDB_Denom denom; 171 struct TALER_CoinPublicInfo coin; 172 struct TALER_CoinPublicInfo got; 173 struct TALER_DenominationHashP h_denom_pub; 174 struct TALER_DenominationPublicKey denom_pub = { 0 }; 175 struct TALER_DenominationSignature denom_sig = { 0 }; 176 struct TALER_AgeCommitmentHashP h_age_commitment; 177 bool no_age_commitment = false; 178 uint64_t known_coin_id = 0; 179 uint64_t id2 = 0; 180 181 TDB_denom (pg, 182 10, 183 "5", 184 "0.1", 185 &denom); 186 TDB_coin (pg, 187 &denom, 188 20, 189 &coin, 190 &known_coin_id); 191 FAILIF_C (0 == known_coin_id, 192 TDB_coin_free (&coin); TDB_denom_free (&denom)); 193 194 memset (&got, 195 0, 196 sizeof (got)); 197 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 198 TALER_EXCHANGEDB_get_known_coin (pg, 199 &coin.coin_pub, 200 &got), 201 TDB_coin_free (&coin); TDB_denom_free (&denom)); 202 FAILIF_C (0 != GNUNET_memcmp (&got.denom_pub_hash, 203 &denom.h_denom_pub), 204 TALER_denom_sig_free (&got.denom_sig); 205 TDB_coin_free (&coin); TDB_denom_free (&denom)); 206 FAILIF_C (! got.no_age_commitment, 207 TALER_denom_sig_free (&got.denom_sig); 208 TDB_coin_free (&coin); TDB_denom_free (&denom)); 209 FAILIF_C (0 != TALER_denom_sig_cmp (&got.denom_sig, 210 &coin.denom_sig), 211 TALER_denom_sig_free (&got.denom_sig); 212 TDB_coin_free (&coin); TDB_denom_free (&denom)); 213 TALER_denom_sig_free (&got.denom_sig); 214 215 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 216 TALER_EXCHANGEDB_get_coin_denomination (pg, 217 &coin.coin_pub, 218 &id2, 219 &h_denom_pub), 220 TDB_coin_free (&coin); TDB_denom_free (&denom)); 221 FAILIF_C (id2 != known_coin_id, 222 TDB_coin_free (&coin); TDB_denom_free (&denom)); 223 FAILIF_C (0 != GNUNET_memcmp (&h_denom_pub, 224 &denom.h_denom_pub), 225 TDB_coin_free (&coin); TDB_denom_free (&denom)); 226 227 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 228 TALER_EXCHANGEDB_get_signature_for_known_coin (pg, 229 &coin.coin_pub, 230 &denom_pub, 231 &denom_sig), 232 TDB_coin_free (&coin); TDB_denom_free (&denom)); 233 FAILIF_C (0 != TALER_denom_pub_cmp (&denom_pub, 234 &denom.pub), 235 TALER_denom_pub_free (&denom_pub); 236 TALER_denom_sig_free (&denom_sig); 237 TDB_coin_free (&coin); TDB_denom_free (&denom)); 238 FAILIF_C (0 != TALER_denom_sig_cmp (&denom_sig, 239 &coin.denom_sig), 240 TALER_denom_pub_free (&denom_pub); 241 TALER_denom_sig_free (&denom_sig); 242 TDB_coin_free (&coin); TDB_denom_free (&denom)); 243 TALER_denom_pub_free (&denom_pub); 244 TALER_denom_sig_free (&denom_sig); 245 246 /* the same in one lookup, together with the (absent) age commitment */ 247 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 248 TALER_EXCHANGEDB_get_denomination_proof_for_known_coin ( 249 pg, 250 &coin.coin_pub, 251 &denom_pub, 252 &denom_sig, 253 &h_age_commitment, 254 &no_age_commitment), 255 TDB_coin_free (&coin); TDB_denom_free (&denom)); 256 FAILIF_C ( (0 != TALER_denom_pub_cmp (&denom_pub, 257 &denom.pub)) || 258 (0 != TALER_denom_sig_cmp (&denom_sig, 259 &coin.denom_sig)) || 260 (! no_age_commitment), 261 TALER_denom_pub_free (&denom_pub); 262 TALER_denom_sig_free (&denom_sig); 263 TDB_coin_free (&coin); TDB_denom_free (&denom)); 264 TALER_denom_pub_free (&denom_pub); 265 TALER_denom_sig_free (&denom_sig); 266 267 FAILIF_C (1 != TALER_EXCHANGEDB_get_count_known_coins (pg, 268 &denom.h_denom_pub), 269 TDB_coin_free (&coin); TDB_denom_free (&denom)); 270 TDB_coin_free (&coin); 271 TDB_denom_free (&denom); 272 return 0; 273 } 274 275 276 /** 277 * Re-inserting the same coin is a no-op; re-inserting it under a different 278 * denomination or with an age commitment is a conflict. 279 * 280 * @param pg the database context 281 * @return 0 on success 282 */ 283 static int 284 check_conflicts (struct TALER_EXCHANGEDB_PostgresContext *pg) 285 { 286 struct TDB_Denom denom; 287 struct TDB_Denom other; 288 struct TALER_CoinPublicInfo coin; 289 struct TALER_EXCHANGEDB_CoinKnownResult res; 290 291 TDB_denom (pg, 292 10, 293 "5", 294 "0.1", 295 &denom); 296 TDB_denom (pg, 297 11, 298 "5", 299 "0.1", 300 &other); 301 memset (&coin, 302 0, 303 sizeof (coin)); 304 TDB_FILL (coin.coin_pub, 305 20); 306 coin.denom_pub_hash = denom.h_denom_pub; 307 coin.no_age_commitment = true; 308 TDB_denom_sig (20, 309 &coin.denom_sig); 310 311 /* the coin from the previous check: already present, no conflict */ 312 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 313 insert_one (pg, 314 &coin, 315 &res), 316 TALER_denom_sig_free (&coin.denom_sig); 317 TDB_denom_free (&denom); TDB_denom_free (&other)); 318 FAILIF_C (TALER_EXCHANGEDB_CKS_PRESENT != res.status, 319 TALER_denom_sig_free (&coin.denom_sig); 320 TDB_denom_free (&denom); TDB_denom_free (&other)); 321 FAILIF_C (0 == res.known_coin_id, 322 TALER_denom_sig_free (&coin.denom_sig); 323 TDB_denom_free (&denom); TDB_denom_free (&other)); 324 FAILIF_C (! res.no_age_commitment, 325 TALER_denom_sig_free (&coin.denom_sig); 326 TDB_denom_free (&denom); TDB_denom_free (&other)); 327 328 /* same coin key, different denomination: conflict, and the stored 329 denomination is handed back so the caller can report it */ 330 coin.denom_pub_hash = other.h_denom_pub; 331 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 332 insert_one (pg, 333 &coin, 334 &res), 335 TALER_denom_sig_free (&coin.denom_sig); 336 TDB_denom_free (&denom); TDB_denom_free (&other)); 337 FAILIF_C (TALER_EXCHANGEDB_CKS_DENOM_CONFLICT != res.status, 338 TALER_denom_sig_free (&coin.denom_sig); 339 TDB_denom_free (&denom); TDB_denom_free (&other)); 340 FAILIF_C (0 != GNUNET_memcmp (&res.h_denom_pub, 341 &denom.h_denom_pub), 342 TALER_denom_sig_free (&coin.denom_sig); 343 TDB_denom_free (&denom); TDB_denom_free (&other)); 344 345 /* same coin key and denomination, but now with an age commitment where 346 the stored row has none: the caller should have passed none */ 347 coin.denom_pub_hash = denom.h_denom_pub; 348 coin.no_age_commitment = false; 349 TDB_FILL (coin.h_age_commitment, 350 21); 351 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 352 insert_one (pg, 353 &coin, 354 &res), 355 TALER_denom_sig_free (&coin.denom_sig); 356 TDB_denom_free (&denom); TDB_denom_free (&other)); 357 FAILIF_C (TALER_EXCHANGEDB_CKS_AGE_CONFLICT_EXPECTED_NULL != res.status, 358 TALER_denom_sig_free (&coin.denom_sig); 359 TDB_denom_free (&denom); TDB_denom_free (&other)); 360 TALER_denom_sig_free (&coin.denom_sig); 361 362 /* the conflicting attempts did not add anything */ 363 FAILIF_C (1 != TALER_EXCHANGEDB_get_count_known_coins (pg, 364 &denom.h_denom_pub), 365 TDB_denom_free (&denom); TDB_denom_free (&other)); 366 FAILIF_C (0 != TALER_EXCHANGEDB_get_count_known_coins (pg, 367 &other.h_denom_pub), 368 TDB_denom_free (&denom); TDB_denom_free (&other)); 369 TDB_denom_free (&denom); 370 TDB_denom_free (&other); 371 return 0; 372 } 373 374 375 /** 376 * A coin with an age commitment round-trips, and the mirror-image 377 * conflict is reported. 378 * 379 * @param pg the database context 380 * @return 0 on success 381 */ 382 static int 383 check_age_commitment (struct TALER_EXCHANGEDB_PostgresContext *pg) 384 { 385 struct TDB_Denom denom; 386 struct TALER_CoinPublicInfo coin; 387 struct TALER_CoinPublicInfo got; 388 struct TALER_EXCHANGEDB_CoinKnownResult res; 389 struct TALER_DenominationPublicKey denom_pub = { 0 }; 390 struct TALER_DenominationSignature denom_sig = { 0 }; 391 struct TALER_AgeCommitmentHashP h_age_commitment; 392 bool no_age_commitment = true; 393 394 TDB_denom (pg, 395 10, 396 "5", 397 "0.1", 398 &denom); 399 memset (&coin, 400 0, 401 sizeof (coin)); 402 TDB_FILL (coin.coin_pub, 403 30); 404 coin.denom_pub_hash = denom.h_denom_pub; 405 coin.no_age_commitment = false; 406 TDB_FILL (coin.h_age_commitment, 407 31); 408 TDB_denom_sig (30, 409 &coin.denom_sig); 410 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 411 insert_one (pg, 412 &coin, 413 &res), 414 TALER_denom_sig_free (&coin.denom_sig); 415 TDB_denom_free (&denom)); 416 FAILIF_C (TALER_EXCHANGEDB_CKS_ADDED != res.status, 417 TALER_denom_sig_free (&coin.denom_sig); 418 TDB_denom_free (&denom)); 419 FAILIF_C (0 == res.known_coin_id, 420 TALER_denom_sig_free (&coin.denom_sig); 421 TDB_denom_free (&denom)); 422 memset (&got, 423 0, 424 sizeof (got)); 425 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 426 TALER_EXCHANGEDB_get_known_coin (pg, 427 &coin.coin_pub, 428 &got), 429 TALER_denom_sig_free (&coin.denom_sig); 430 TDB_denom_free (&denom)); 431 FAILIF_C (got.no_age_commitment, 432 TALER_denom_sig_free (&got.denom_sig); 433 TALER_denom_sig_free (&coin.denom_sig); 434 TDB_denom_free (&denom)); 435 FAILIF_C (0 != GNUNET_memcmp (&got.h_age_commitment, 436 &coin.h_age_commitment), 437 TALER_denom_sig_free (&got.denom_sig); 438 TALER_denom_sig_free (&coin.denom_sig); 439 TDB_denom_free (&denom)); 440 TALER_denom_sig_free (&got.denom_sig); 441 /* the age commitment hash is part of the proof of the denomination */ 442 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 443 TALER_EXCHANGEDB_get_denomination_proof_for_known_coin ( 444 pg, 445 &coin.coin_pub, 446 &denom_pub, 447 &denom_sig, 448 &h_age_commitment, 449 &no_age_commitment), 450 TALER_denom_sig_free (&coin.denom_sig); 451 TDB_denom_free (&denom)); 452 TALER_denom_pub_free (&denom_pub); 453 TALER_denom_sig_free (&denom_sig); 454 FAILIF_C ( (no_age_commitment) || 455 (0 != GNUNET_memcmp (&h_age_commitment, 456 &coin.h_age_commitment)), 457 TALER_denom_sig_free (&coin.denom_sig); 458 TDB_denom_free (&denom)); 459 460 /* a different age commitment for the same coin is a conflict... */ 461 TDB_FILL (coin.h_age_commitment, 462 32); 463 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 464 insert_one (pg, 465 &coin, 466 &res), 467 TALER_denom_sig_free (&coin.denom_sig); 468 TDB_denom_free (&denom)); 469 FAILIF_C (TALER_EXCHANGEDB_CKS_AGE_CONFLICT_VALUE_DIFFERS != res.status, 470 TALER_denom_sig_free (&coin.denom_sig); 471 TDB_denom_free (&denom)); 472 /* the stored age commitment is handed back for the error report */ 473 FAILIF_C (res.no_age_commitment, 474 TALER_denom_sig_free (&coin.denom_sig); 475 TDB_denom_free (&denom)); 476 FAILIF_C (0 != GNUNET_memcmp (&res.h_age_commitment, 477 &got.h_age_commitment), 478 TALER_denom_sig_free (&coin.denom_sig); 479 TDB_denom_free (&denom)); 480 /* ...and so is no age commitment at all, where one is on file */ 481 coin.no_age_commitment = true; 482 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 483 insert_one (pg, 484 &coin, 485 &res), 486 TALER_denom_sig_free (&coin.denom_sig); 487 TDB_denom_free (&denom)); 488 FAILIF_C (TALER_EXCHANGEDB_CKS_AGE_CONFLICT_EXPECTED_NON_NULL != res.status, 489 TALER_denom_sig_free (&coin.denom_sig); 490 TDB_denom_free (&denom)); 491 TALER_denom_sig_free (&coin.denom_sig); 492 493 /* two coins of this denomination by now */ 494 FAILIF_C (2 != TALER_EXCHANGEDB_get_count_known_coins (pg, 495 &denom.h_denom_pub), 496 TDB_denom_free (&denom)); 497 TDB_denom_free (&denom); 498 return 0; 499 } 500 501 502 /** 503 * One call with a mixed batch: two new coins (one with an age 504 * commitment), one already known, one with a conflicting denomination 505 * and one with a conflicting age commitment. Every coin must be 506 * reported at its own position, the new ones must be inserted, and a 507 * batch with a repeated coin or an unknown denomination is refused 508 * without inserting anything. 509 * 510 * @param pg the database context 511 * @return 0 on success 512 */ 513 static int 514 check_batch (struct TALER_EXCHANGEDB_PostgresContext *pg) 515 { 516 struct TDB_Denom denom; 517 struct TDB_Denom other; 518 struct TALER_CoinPublicInfo coins[5]; 519 const struct TALER_CoinPublicInfo *pcoins[5]; 520 struct TALER_EXCHANGEDB_CoinKnownResult res[5]; 521 struct TALER_DenominationHashP dh; 522 uint64_t id; 523 uint64_t count_before; 524 int ret = 1; 525 526 TDB_denom (pg, 527 10, 528 "5", 529 "0.1", 530 &denom); 531 TDB_denom (pg, 532 11, 533 "5", 534 "0.1", 535 &other); 536 memset (coins, 537 0, 538 sizeof (coins)); 539 for (unsigned int i = 0; i < 5; i++) 540 { 541 coins[i].no_age_commitment = true; 542 coins[i].denom_pub_hash = denom.h_denom_pub; 543 pcoins[i] = &coins[i]; 544 } 545 /* [0]: new, no age commitment */ 546 TDB_FILL (coins[0].coin_pub, 547 40); 548 TDB_denom_sig (40, 549 &coins[0].denom_sig); 550 /* [1]: new, with age commitment */ 551 TDB_FILL (coins[1].coin_pub, 552 41); 553 coins[1].no_age_commitment = false; 554 TDB_FILL (coins[1].h_age_commitment, 555 410); 556 TDB_denom_sig (41, 557 &coins[1].denom_sig); 558 /* [2]: known from check_insert_and_lookup (seed 20), same data */ 559 TDB_FILL (coins[2].coin_pub, 560 20); 561 TDB_denom_sig (20, 562 &coins[2].denom_sig); 563 /* [3]: known (seed 20 again, different key below), other denomination */ 564 TDB_FILL (coins[3].coin_pub, 565 20); 566 coins[3].denom_pub_hash = other.h_denom_pub; 567 TDB_denom_sig (20, 568 &coins[3].denom_sig); 569 /* [4]: known from check_age_commitment (seed 30), wrong age commitment */ 570 TDB_FILL (coins[4].coin_pub, 571 30); 572 coins[4].no_age_commitment = false; 573 TDB_FILL (coins[4].h_age_commitment, 574 33); 575 TDB_denom_sig (30, 576 &coins[4].denom_sig); 577 578 count_before = TDB_count (pg, 579 "FROM known_coins"); 580 581 /* [2] and [3] share a key: refused, nothing inserted */ 582 FAILIF_C (GNUNET_DB_STATUS_HARD_ERROR != 583 TALER_EXCHANGEDB_do_insert_known_coins (pg, 584 5, 585 pcoins, 586 res), 587 goto cleanup); 588 FAILIF_C (count_before != TDB_count (pg, 589 "FROM known_coins"), 590 goto cleanup); 591 592 /* give [3] its own key: a coin known under the other denomination */ 593 { 594 struct TALER_EXCHANGEDB_CoinKnownResult r1; 595 struct TALER_CoinPublicInfo tmp = coins[3]; 596 597 TDB_FILL (tmp.coin_pub, 598 43); 599 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 600 insert_one (pg, 601 &tmp, 602 &r1), 603 goto cleanup); 604 FAILIF_C (TALER_EXCHANGEDB_CKS_ADDED != r1.status, 605 goto cleanup); 606 count_before++; 607 TDB_FILL (coins[3].coin_pub, 608 43); 609 coins[3].denom_pub_hash = denom.h_denom_pub; 610 } 611 612 /* a new coin of an unknown denomination anywhere in the batch: the 613 batch is refused. The INSERT itself is one statement, so this is 614 done inside a transaction as the callers do it, and the rollback 615 removes the other new coin again. */ 616 TDB_FILL (coins[0].denom_pub_hash, 617 44); 618 FAILIF_C (GNUNET_OK != 619 TALER_EXCHANGEDB_start (pg, 620 "test unknown denomination"), 621 goto cleanup); 622 FAILIF_C (GNUNET_DB_STATUS_HARD_ERROR != 623 TALER_EXCHANGEDB_do_insert_known_coins (pg, 624 5, 625 pcoins, 626 res), 627 TALER_EXCHANGEDB_rollback (pg); goto cleanup); 628 TALER_EXCHANGEDB_rollback (pg); 629 FAILIF_C (count_before != TDB_count (pg, 630 "FROM known_coins"), 631 goto cleanup); 632 coins[0].denom_pub_hash = denom.h_denom_pub; 633 634 /* now the mixed batch goes through, with one row per coin */ 635 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 636 TALER_EXCHANGEDB_do_insert_known_coins (pg, 637 5, 638 pcoins, 639 res), 640 goto cleanup); 641 FAILIF_C (TALER_EXCHANGEDB_CKS_ADDED != res[0].status, 642 goto cleanup); 643 FAILIF_C (0 == res[0].known_coin_id, 644 goto cleanup); 645 FAILIF_C (TALER_EXCHANGEDB_CKS_ADDED != res[1].status, 646 goto cleanup); 647 FAILIF_C (0 == res[1].known_coin_id, 648 goto cleanup); 649 /* for added coins, the result reflects what was stored */ 650 FAILIF_C (! res[0].no_age_commitment, 651 goto cleanup); 652 FAILIF_C (0 != GNUNET_memcmp (&res[0].h_denom_pub, 653 &denom.h_denom_pub), 654 goto cleanup); 655 FAILIF_C (res[1].no_age_commitment, 656 goto cleanup); 657 FAILIF_C (0 != GNUNET_memcmp (&res[1].h_age_commitment, 658 &coins[1].h_age_commitment), 659 goto cleanup); 660 FAILIF_C (res[0].known_coin_id == res[1].known_coin_id, 661 goto cleanup); 662 FAILIF_C (TALER_EXCHANGEDB_CKS_PRESENT != res[2].status, 663 goto cleanup); 664 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 665 TALER_EXCHANGEDB_get_coin_denomination (pg, 666 &coins[2].coin_pub, 667 &id, 668 &dh), 669 goto cleanup); 670 FAILIF_C (id != res[2].known_coin_id, 671 goto cleanup); 672 FAILIF_C (TALER_EXCHANGEDB_CKS_DENOM_CONFLICT != res[3].status, 673 goto cleanup); 674 FAILIF_C (0 != GNUNET_memcmp (&res[3].h_denom_pub, 675 &other.h_denom_pub), 676 goto cleanup); 677 FAILIF_C (TALER_EXCHANGEDB_CKS_AGE_CONFLICT_VALUE_DIFFERS != res[4].status, 678 goto cleanup); 679 FAILIF_C (res[4].no_age_commitment, 680 goto cleanup); 681 FAILIF_C (0 == GNUNET_memcmp (&res[4].h_age_commitment, 682 &coins[4].h_age_commitment), 683 goto cleanup); 684 /* exactly the two new coins were added */ 685 FAILIF_C (count_before + 2 != TDB_count (pg, 686 "FROM known_coins"), 687 goto cleanup); 688 { 689 struct TALER_CoinPublicInfo got; 690 691 memset (&got, 692 0, 693 sizeof (got)); 694 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 695 TALER_EXCHANGEDB_get_known_coin (pg, 696 &coins[1].coin_pub, 697 &got), 698 goto cleanup); 699 FAILIF_C (got.no_age_commitment, 700 TALER_denom_sig_free (&got.denom_sig); goto cleanup); 701 FAILIF_C (0 != GNUNET_memcmp (&got.h_age_commitment, 702 &coins[1].h_age_commitment), 703 TALER_denom_sig_free (&got.denom_sig); goto cleanup); 704 FAILIF_C (0 != TALER_denom_sig_cmp (&got.denom_sig, 705 &coins[1].denom_sig), 706 TALER_denom_sig_free (&got.denom_sig); goto cleanup); 707 TALER_denom_sig_free (&got.denom_sig); 708 } 709 710 /* running the same batch again changes nothing: the new coins are 711 now merely present, the conflicts are reported as before */ 712 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 713 TALER_EXCHANGEDB_do_insert_known_coins (pg, 714 5, 715 pcoins, 716 res), 717 goto cleanup); 718 FAILIF_C (TALER_EXCHANGEDB_CKS_PRESENT != res[0].status, 719 goto cleanup); 720 FAILIF_C (TALER_EXCHANGEDB_CKS_PRESENT != res[1].status, 721 goto cleanup); 722 FAILIF_C (TALER_EXCHANGEDB_CKS_PRESENT != res[2].status, 723 goto cleanup); 724 FAILIF_C (TALER_EXCHANGEDB_CKS_DENOM_CONFLICT != res[3].status, 725 goto cleanup); 726 FAILIF_C (TALER_EXCHANGEDB_CKS_AGE_CONFLICT_VALUE_DIFFERS != res[4].status, 727 goto cleanup); 728 FAILIF_C (count_before + 2 != TDB_count (pg, 729 "FROM known_coins"), 730 goto cleanup); 731 ret = 0; 732 cleanup: 733 for (unsigned int i = 0; i < 5; i++) 734 TALER_denom_sig_free (&coins[i].denom_sig); 735 TDB_denom_free (&denom); 736 TDB_denom_free (&other); 737 return ret; 738 } 739 740 741 /** 742 * Both ways out of do_insert_known_coins() release the closures its 743 * query parameters allocate. Nothing to assert here: the leak shows up 744 * when the test runs under valgrind (meson test --setup=valgrind). 745 * 746 * @param pg the database context 747 * @return 0 on success 748 */ 749 static int 750 check_no_leak (struct TALER_EXCHANGEDB_PostgresContext *pg) 751 { 752 struct TDB_Denom denom; 753 struct TALER_CoinPublicInfo coins[2]; 754 const struct TALER_CoinPublicInfo *pcoins[2]; 755 const struct TALER_CoinPublicInfo *dups[2]; 756 struct TALER_EXCHANGEDB_CoinKnownResult res[2]; 757 int ret = 1; 758 759 TDB_denom (pg, 760 10, 761 "5", 762 "0.1", 763 &denom); 764 memset (coins, 765 0, 766 sizeof (coins)); 767 for (unsigned int i = 0; i < 2; i++) 768 { 769 coins[i].no_age_commitment = true; 770 coins[i].denom_pub_hash = denom.h_denom_pub; 771 TDB_FILL (coins[i].coin_pub, 772 50 + i); 773 TDB_denom_sig (50 + i, 774 &coins[i].denom_sig); 775 pcoins[i] = &coins[i]; 776 dups[i] = &coins[0]; 777 } 778 /* the batch goes through: first inserted, then found */ 779 for (unsigned int i = 0; i < 2; i++) 780 { 781 FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != 782 TALER_EXCHANGEDB_do_insert_known_coins (pg, 783 2, 784 pcoins, 785 res), 786 goto cleanup); 787 FAILIF_C ( (i == 0) 788 ? (TALER_EXCHANGEDB_CKS_ADDED != res[1].status) 789 : (TALER_EXCHANGEDB_CKS_PRESENT != res[1].status), 790 goto cleanup); 791 } 792 /* the batch is refused before the query for repeating a coin */ 793 FAILIF_C (GNUNET_DB_STATUS_HARD_ERROR != 794 TALER_EXCHANGEDB_do_insert_known_coins (pg, 795 2, 796 dups, 797 res), 798 goto cleanup); 799 ret = 0; 800 cleanup: 801 for (unsigned int i = 0; i < 2; i++) 802 TALER_denom_sig_free (&coins[i].denom_sig); 803 TDB_denom_free (&denom); 804 return ret; 805 } 806 807 808 /** 809 * The checks to run, in order. 810 */ 811 static const struct TDB_Test tests[] = { 812 { "known-coins-empty", 813 &check_empty }, 814 { "known-coins-unknown-denomination", 815 &check_unknown_denomination }, 816 { "known-coins-insert-and-lookup", 817 &check_insert_and_lookup }, 818 { "known-coins-conflicts", 819 &check_conflicts }, 820 { "known-coins-age-commitment", 821 &check_age_commitment }, 822 { "known-coins-batch", 823 &check_batch }, 824 { "known-coins-no-leak", 825 &check_no_leak }, 826 { NULL, NULL } 827 }; 828 829 830 int 831 main (int argc, 832 char *const *argv) 833 { 834 return TDB_main (argc, 835 argv, 836 "test-known-coins", 837 "Tests for the exchangedb `known_coins' table", 838 tests); 839 } 840 841 842 /* end of test_known_coins.c */