sync

testing_api_cmd_block_update.c (5882B)

---

 /*
   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_update.c
  * @brief command to update a block in the sync backend service.
  * @author Iván Ávalos
  */
 #include "testing_api_cmd_block_common.h"
 
 
 /**
  * Process a reference for an update: inherit keys, nonce
  * (if not explicitly set), and old_data_hash from the ref's
  * curr_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
 update_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 curr_hash for update */
   if (GNUNET_is_zero (&bus->old_data_hash))
   {
     const struct GNUNET_HashCode *h;
 
     if (GNUNET_OK ==
         TALER_TESTING_get_trait_curr_hash (ref,
                                            &h))
       bus->old_data_hash = *h;
   }
 
   return GNUNET_OK;
 }
 
 
 /**
  * Start a block update 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 nonce of the succeeding block, or NULL
  * @param old_data_hash hash of the existing block 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 unused for updates (the links do not change)
  * @param cb function to call with the result
  * @param cb_cls closure for @a cb
  * @return handle for the operation
  */
 static struct SYNC_BlockOperation *
 update_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 = next_nonce,
     .old_data_hash = old_data_hash,
     .block_data_size = block_data_size,
     .block_data = block_data,
     .refs_len = refs_len,
     .object_uids = object_uids,
     .object_incs = object_incs,
   };
 
   (void) prev_entry;
   return SYNC_block_update (ctx,
                             sync_url,
                             sync_priv,
                             &args,
                             cb,
                             cb_cls);
 }
 
 
 struct TALER_TESTING_Command
 SYNC_TESTING_cmd_block_update (const char *label,
                                const char *sync_url,
                                const char *upload_reference,
                                const struct SYNC_BlockNonce *nonce,
                                const struct GNUNET_HashCode *old_data_hash,
                                unsigned int http_status,
                                const void *block_data,
                                size_t block_data_size,
                                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;
   if (NULL != old_data_hash)
     bus->old_data_hash = *old_data_hash;
   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 = &update_process_ref;
   bus->start_upload = &update_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;
   }
 }