sync

testing_api_cmd_block_append.c (7733B)

---

 /*
   This file is part of SYNC
   Copyright (C) 2014-2026 Taler Systems SA
 
   SYNC is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 3, or
   (at your option) any later version.
 
   SYNC is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public
   License along with SYNC; see the file COPYING.  If not, see
   <http://www.gnu.org/licenses/>
 */
 /**
  * @file testing/testing_api_cmd_block_append.c
  * @brief command to append a block to the sync backend service.
  * @author Iván Ávalos
  */
 #include "testing_api_cmd_block_common.h"
 #include <stdbool.h>
 
 
 /**
  * Process a reference for a retry upload: inherit keys, nonce
  * (if not explicitly set), and old_data_hash from the ref's
  * prev_hash trait.
  *
  * @param[in,out] bus state to populate
  * @param ref reference command to inherit from
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 static enum GNUNET_GenericReturnValue
 append_retry_process_ref (
   struct BlockUploadState *bus,
   const struct TALER_TESTING_Command *ref)
 {
   if (GNUNET_OK !=
       SYNC_TESTING_inherit_account_keys_ (bus,
                                           ref))
     return GNUNET_SYSERR;
 
   /* Inherit block nonce if not explicitly set */
   if (GNUNET_is_zero (&bus->nonce))
   {
     const struct SYNC_BlockNonce *nonce;
 
     if (GNUNET_OK ==
         TALER_TESTING_get_trait_block_nonce (ref,
                                              &nonce))
       bus->nonce = *nonce;
   }
 
   /* Inherit old_data_hash from prev_hash for retry */
   if (GNUNET_is_zero (&bus->old_data_hash))
   {
     const struct GNUNET_HashCode *h;
 
     if (GNUNET_OK ==
         TALER_TESTING_get_trait_prev_hash (ref,
                                            &h))
       bus->old_data_hash = *h;
   }
 
   return GNUNET_OK;
 }
 
 
 /**
  * Process a reference for an append-after: inherit keys, set
  * prev_nonce from the ref's block_nonce (to chain the new block after
  * the referenced one), and collect the tail's data for its relink
  * signature.
  *
  * @param[in,out] bus state to populate
  * @param ref reference command to inherit from
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 static enum GNUNET_GenericReturnValue
 append_after_process_ref (
   struct BlockUploadState *bus,
   const struct TALER_TESTING_Command *ref)
 {
   const struct SYNC_BlockNonce *nonce;
   const struct SYNC_BlockNonce *pn;
   const struct GNUNET_HashCode *h;
   const struct GNUNET_HashCode *rh;
 
   if (GNUNET_OK !=
       SYNC_TESTING_inherit_account_keys_ (bus,
                                           ref))
     return GNUNET_SYSERR;
   /* Set prev_nonce to chain after the referenced block.  If ref has
      no nonce trait, prev_nonce stays zero (meaning no predecessor —
      allowed by the API) */
   if (GNUNET_OK ==
       TALER_TESTING_get_trait_block_nonce (ref,
                                            &nonce))
     bus->prev_nonce = *nonce;
 
   /* The tail's data for its relink signature */
   if (GNUNET_OK ==
       TALER_TESTING_get_trait_curr_hash (ref,
                                          &h))
   {
     bus->prev_entry.nonce = bus->prev_nonce;
     bus->prev_entry.hash = *h;
     bus->have_relink_target = true;
   }
   if (GNUNET_OK ==
       TALER_TESTING_get_trait_block_refs_hash (ref,
                                                &rh))
     bus->prev_entry.refs_hash = *rh;
   if (GNUNET_OK ==
       TALER_TESTING_get_trait_prev_nonce (ref,
                                           &pn))
   {
     bus->prev_entry.prev_nonce = *pn;
     bus->prev_entry.have_prev_nonce = ! GNUNET_is_zero (pn);
   }
 
   return GNUNET_OK;
 }
 
 
 /**
  * Start a block append operation.
  *
  * @param ctx for HTTP client request processing
  * @param sync_url base URL of the Sync server
  * @param sync_priv private key of the account
  * @param nonce nonce identifying the block
  * @param prev_nonce nonce of the preceding block, or NULL
  * @param next_nonce unused, appends are always at the tail
  * @param old_data_hash unused, appends have no previous data
  * @param block_data_size number of bytes in @a block_data
  * @param block_data the block data
  * @param refs_len number of entries in @a object_uids and @a object_incs
  * @param object_uids array of object UIDs referenced by this block
  * @param object_incs array of reference count adjustments
  * @param prev_entry the tail's entry, for its relink signature, or NULL
  * @param cb function to call with the result
  * @param cb_cls closure for @a cb
  * @return handle for the operation
  */
 static struct SYNC_BlockOperation *
 append_start_upload (
   struct GNUNET_CURL_Context *ctx,
   const char *sync_url,
   const struct SYNC_AccountPrivateKeyP *sync_priv,
   const struct SYNC_BlockNonce *nonce,
   const struct SYNC_BlockNonce *prev_nonce,
   const struct SYNC_BlockNonce *next_nonce,
   const struct GNUNET_HashCode *old_data_hash,
   size_t block_data_size,
   const void *block_data,
   size_t refs_len,
   const struct SYNC_ObjectUID *object_uids,
   const int16_t *object_incs,
   const struct SYNC_BlockListEntry *prev_entry,
   SYNC_BlockOperationCallback cb,
   void *cb_cls)
 {
   struct SYNC_BlockOperationArgs args = {
     .nonce = nonce,
     .prev_nonce = prev_nonce,
     .next_nonce = NULL,
     .old_data_hash = NULL,
     .block_data_size = block_data_size,
     .block_data = block_data,
     .refs_len = refs_len,
     .object_uids = object_uids,
     .object_incs = object_incs,
     .prev_entry = prev_entry,
   };
 
   (void) next_nonce;
   (void) old_data_hash;
   return SYNC_block_append (ctx,
                             sync_url,
                             sync_priv,
                             &args,
                             cb,
                             cb_cls);
 }
 
 
 struct TALER_TESTING_Command
 SYNC_TESTING_cmd_block_append (const char *label,
                                const char *sync_url,
                                const char *upload_reference,
                                const struct SYNC_BlockNonce *nonce,
                                unsigned int http_status,
                                const void *block_data,
                                size_t block_data_size,
                                bool retry_upload,
                                unsigned int refs_len,
                                const struct SYNC_ObjectUID *object_uids,
                                const int16_t *object_incs)
 {
   struct BlockUploadState *bus;
 
   GNUNET_assert (refs_len <= MAX_BLOCK_OBJECT_REFS);
   bus = GNUNET_new (struct BlockUploadState);
   bus->sync_url = sync_url;
   bus->upload_reference = upload_reference;
   if (NULL != nonce)
     bus->nonce = *nonce;
   bus->http_status = http_status;
   bus->block_data = block_data;
   bus->block_data_size = block_data_size;
   bus->refs_len = refs_len;
   if (0 < refs_len)
   {
     GNUNET_memcpy (bus->object_uids,
                    object_uids,
                    refs_len * sizeof (struct SYNC_ObjectUID));
     GNUNET_memcpy (bus->object_incs,
                    object_incs,
                    refs_len * sizeof (int16_t));
   }
   bus->process_ref = retry_upload
     ? &append_retry_process_ref
     : &append_after_process_ref;
   bus->start_upload = &append_start_upload;
   {
     struct TALER_TESTING_Command cmd = {
       .cls = bus,
       .label = label,
       .run = &SYNC_TESTING_block_upload_run_,
       .cleanup = &SYNC_TESTING_block_upload_cleanup_,
       .traits = &SYNC_TESTING_block_upload_traits_
     };
 
     return cmd;
   }
 }