sync

sync_api_object_fetch.c (5375B)

---

 /*
   This file is part of TALER
   Copyright (C) 2026 Taler Systems SA
 
   TALER 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.
 
   TALER 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 TALER; see the file COPYING.  If not, see
   <http://www.gnu.org/licenses/>
 */
 /**
  * @file lib/sync_api_object_fetch.c
  * @brief Implementation of the object fetch (GET) operation
  * @author Iván Ávalos
  */
 #include "platform.h"
 #include <curl/curl.h>
 #include <jansson.h>
 #include <microhttpd.h>
 #include <gnunet/gnunet_util_lib.h>
 #include <gnunet/gnunet_curl_lib.h>
 #include <gnunet/gnunet_json_lib.h>
 #include <taler/taler_json_lib.h>
 #include <taler/taler_curl_lib.h>
 #include <sync/sync_service.h>
 #include <sync/sync_util.h>
 #include "sync_api_curl_defaults.h"
 
 
 /**
  * Handle for an object fetch operation.
  */
 struct SYNC_ObjectFetchOperation
 {
 
   /**
    * The url for this request.
    */
   char *url;
 
   /**
    * Handle for the request.
    */
   struct GNUNET_CURL_Job *job;
 
   /**
    * Reference to the execution context.
    */
   struct GNUNET_CURL_Context *ctx;
 
   /**
    * Function to call with the result.
    */
   SYNC_ObjectFetchCallback cb;
 
   /**
    * Closure for @e cb.
    */
   void *cb_cls;
 
 };
 
 
 /**
  * Function called when we're done processing the
  * GET /backups/$KEY/objects/$UID request.
  *
  * @param cls the `struct SYNC_ObjectFetchOperation *`
  * @param response_code HTTP response code, 0 on error
  * @param response response body as parsed JSON, or NULL
  */
 static void
 handle_object_fetch_finished (void *cls,
                               long response_code,
                               const void *response)
 {
   struct SYNC_ObjectFetchOperation *op = cls;
   const json_t *json = response;
   unsigned int http_status = (unsigned int) response_code;
   enum TALER_ErrorCode ec = TALER_EC_INVALID;
   struct SYNC_ObjectEntry entry = { 0 };
 
   op->job = NULL;
   switch (response_code)
   {
   case 0:
     break;
   case MHD_HTTP_OK:
     if (NULL != json)
     {
       if (GNUNET_OK !=
           SYNC_object_entry_parse ((json_t *) json,
                                    &entry))
       {
         GNUNET_break_op (0);
         ec = TALER_EC_GENERIC_PARAMETER_MALFORMED;
         break;
       }
       ec = TALER_EC_NONE;
     }
     else
     {
       ec = TALER_EC_GENERIC_INVALID_RESPONSE;
     }
     break;
   case MHD_HTTP_BAD_REQUEST:
   case MHD_HTTP_NOT_FOUND:
   case MHD_HTTP_INTERNAL_SERVER_ERROR:
   default:
     if ( (response_code >= 400) &&
          (response_code < 500) )
       ec = (NULL != json)
            ? TALER_JSON_get_error_code (json)
            : TALER_EC_GENERIC_PARAMETER_MALFORMED;
     else if (response_code >= 500)
       ec = (NULL != json)
            ? TALER_JSON_get_error_code (json)
            : TALER_EC_GENERIC_INVALID_RESPONSE;
     break;
   }
   if (NULL != op->cb)
   {
     op->cb (op->cb_cls,
             http_status,
             ec,
             (TALER_EC_NONE == ec) ? &entry.uid : NULL,
             (TALER_EC_NONE == ec) ? entry.data_size : 0,
             (TALER_EC_NONE == ec) ? entry.data : NULL);
     op->cb = NULL;
   }
   if (TALER_EC_NONE == ec)
     SYNC_object_entry_clear (&entry);
   SYNC_object_fetch_cancel (op);
 }
 
 
 struct SYNC_ObjectFetchOperation *
 SYNC_object_fetch (struct GNUNET_CURL_Context *ctx,
                    const char *base_url,
                    const struct SYNC_AccountPublicKeyP *pub,
                    const struct SYNC_ObjectUID *uid,
                    SYNC_ObjectFetchCallback cb,
                    void *cb_cls)
 {
   struct SYNC_ObjectFetchOperation *op;
   CURL *eh;
   char *pub_s;
   char *uid_s;
   char *path;
   char *url;
 
   pub_s = GNUNET_STRINGS_data_to_string_alloc (pub,
                                                sizeof (*pub));
   uid_s = GNUNET_STRINGS_data_to_string_alloc (uid,
                                                sizeof (*uid));
   GNUNET_asprintf (&path,
                    "backups/%s/objects/%s",
                    pub_s,
                    uid_s);
   GNUNET_free (pub_s);
   GNUNET_free (uid_s);
   url = TALER_url_join (base_url,
                         path,
                         NULL);
   GNUNET_free (path);
   if (NULL == url)
   {
     GNUNET_break (0);
     return NULL;
   }
 
   op = GNUNET_new (struct SYNC_ObjectFetchOperation);
   op->ctx = ctx;
   op->cb = cb;
   op->cb_cls = cb_cls;
   op->url = url;
 
   eh = SYNC_curl_easy_get_ (op->url);
   if (NULL == eh)
   {
     GNUNET_break (0);
     GNUNET_free (op->url);
     GNUNET_free (op);
     return NULL;
   }
 
   op->job = GNUNET_CURL_job_add2 (ctx,
                                   eh,
                                   NULL,
                                   &handle_object_fetch_finished,
                                   op);
   return op;
 }
 
 
 void
 SYNC_object_fetch_cancel (struct SYNC_ObjectFetchOperation *op)
 {
   if (NULL != op->job)
   {
     GNUNET_CURL_job_cancel (op->job);
     op->job = NULL;
   }
   GNUNET_free (op->url);
   GNUNET_free (op);
 }
 
 
 /* end of sync_api_object_fetch.c */