exchange

exchange_api_get-kyc-proof-PROVIDER_NAME.c (7756B)

---

 /*
   This file is part of TALER
   Copyright (C) 2021, 2022, 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/exchange_api_get-kyc-proof-PROVIDER_NAME.c
  * @brief Implementation of the /kyc-proof request
  * @author Christian Grothoff
  */
 #include "taler/platform.h"
 #include <microhttpd.h> /* just for HTTP proof codes */
 #include <gnunet/gnunet_util_lib.h>
 #include <gnunet/gnunet_curl_lib.h>
 #include "taler/taler_exchange_service.h"
 #include "taler/taler_json_lib.h"
 #include "exchange_api_handle.h"
 #include "taler/taler_signatures.h"
 #include "exchange_api_curl_defaults.h"
 #include "taler/taler-exchange/get-kyc-proof-PROVIDER_NAME.h"
 
 
 /**
  * @brief A handle for GET /kyc-proof/$PROVIDER_NAME
  */
 struct TALER_EXCHANGE_GetKycProofHandle
 {
 
   /**
    * The base URL of the exchange.
    */
   char *base_url;
 
   /**
    * The full URL for this request.
    */
   char *url;
 
   /**
    * Handle to our CURL request.
    */
   CURL *eh;
 
   /**
    * Handle for the request.
    */
   struct GNUNET_CURL_Job *job;
 
   /**
    * Function to call with the result.
    */
   TALER_EXCHANGE_GetKycProofCallback cb;
 
   /**
    * Closure for @e cb.
    */
   TALER_EXCHANGE_GET_KYC_PROOF_RESULT_CLOSURE *cb_cls;
 
   /**
    * CURL context to use.
    */
   struct GNUNET_CURL_Context *ctx;
 
   /**
    * Hash of the payto URI identifying the target account.
    */
   struct TALER_NormalizedPaytoHashP h_payto;
 
   /**
    * Name of the KYC logic / provider. Heap-allocated copy.
    */
   char *logic;
 
   /**
    * Additional query string arguments to append to the URL.
    * Borrowed pointer (not owned), must start with '&'.
    * NULL if not set.
    */
   const char *args;
 
 };
 
 
 /**
  * Function called when we're done processing the
  * HTTP GET /kyc-proof request.
  *
  * @param cls the `struct TALER_EXCHANGE_GetKycProofHandle`
  * @param response_code HTTP response code, 0 on error
  * @param body response body
  * @param body_size number of bytes in @a body
  */
 static void
 handle_get_kyc_proof_finished (void *cls,
                                long response_code,
                                const void *body,
                                size_t body_size)
 {
   struct TALER_EXCHANGE_GetKycProofHandle *gkph = cls;
   struct TALER_EXCHANGE_GetKycProofResponse gkpr = {
     .hr.http_status = (unsigned int) response_code
   };
 
   (void) body;
   (void) body_size;
   gkph->job = NULL;
   switch (response_code)
   {
   case 0:
     break;
   case MHD_HTTP_SEE_OTHER:
     {
       char *redirect_url;
 
       GNUNET_assert (CURLE_OK ==
                      curl_easy_getinfo (gkph->eh,
                                         CURLINFO_REDIRECT_URL,
                                         &redirect_url));
       gkpr.details.found.redirect_url = redirect_url;
       break;
     }
   case MHD_HTTP_BAD_REQUEST:
     /* This should never happen, either us or the exchange is buggy
        (or API version conflict); just pass JSON reply to the application */
     break;
   case MHD_HTTP_UNAUTHORIZED:
     break;
   case MHD_HTTP_FORBIDDEN:
     break;
   case MHD_HTTP_NOT_FOUND:
     break;
   case MHD_HTTP_BAD_GATEWAY:
     /* Server had an internal issue; we should retry, but this API
        leaves this to the application */
     break;
   case MHD_HTTP_GATEWAY_TIMEOUT:
     /* Server had an internal issue; we should retry, but this API
        leaves this to the application */
     break;
   default:
     /* unexpected response code */
     GNUNET_break_op (0);
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Unexpected response code %u for exchange get_kyc_proof\n",
                 (unsigned int) response_code);
     break;
   }
   gkph->cb (gkph->cb_cls,
             &gkpr);
   TALER_EXCHANGE_get_kyc_proof_cancel (gkph);
 }
 
 
 struct TALER_EXCHANGE_GetKycProofHandle *
 TALER_EXCHANGE_get_kyc_proof_create (
   struct GNUNET_CURL_Context *ctx,
   const char *url,
   const struct TALER_NormalizedPaytoHashP *h_payto,
   const char *logic)
 {
   struct TALER_EXCHANGE_GetKycProofHandle *gkph;
 
   gkph = GNUNET_new (struct TALER_EXCHANGE_GetKycProofHandle);
   gkph->ctx = ctx;
   gkph->base_url = GNUNET_strdup (url);
   gkph->h_payto = *h_payto;
   gkph->logic = GNUNET_strdup (logic);
   return gkph;
 }
 
 
 enum GNUNET_GenericReturnValue
 TALER_EXCHANGE_get_kyc_proof_set_options_ (
   struct TALER_EXCHANGE_GetKycProofHandle *gkph,
   unsigned int num_options,
   const struct TALER_EXCHANGE_GetKycProofOptionValue *options)
 {
   for (unsigned int i = 0; i < num_options; i++)
   {
     const struct TALER_EXCHANGE_GetKycProofOptionValue *opt = &options[i];
 
     switch (opt->option)
     {
     case TALER_EXCHANGE_GET_KYC_PROOF_OPTION_END:
       return GNUNET_OK;
     case TALER_EXCHANGE_GET_KYC_PROOF_OPTION_ARGS:
       GNUNET_assert (opt->details.args[0] == '&');
       gkph->args = opt->details.args;
       break;
     }
   }
   return GNUNET_OK;
 }
 
 
 enum TALER_ErrorCode
 TALER_EXCHANGE_get_kyc_proof_start (
   struct TALER_EXCHANGE_GetKycProofHandle *gkph,
   TALER_EXCHANGE_GetKycProofCallback cb,
   TALER_EXCHANGE_GET_KYC_PROOF_RESULT_CLOSURE *cb_cls)
 {
   char *arg_str;
 
   if (NULL != gkph->job)
   {
     GNUNET_break (0);
     return TALER_EC_GENERIC_INTERNAL_INVARIANT_FAILURE;
   }
   gkph->cb = cb;
   gkph->cb_cls = cb_cls;
   {
     char hstr[sizeof (gkph->h_payto) * 2];
     char *end;
 
     end = GNUNET_STRINGS_data_to_string (&gkph->h_payto,
                                          sizeof (gkph->h_payto),
                                          hstr,
                                          sizeof (hstr));
     *end = '\0';
     GNUNET_asprintf (&arg_str,
                      "kyc-proof/%s?state=%s%s",
                      gkph->logic,
                      hstr,
                      (NULL != gkph->args) ? gkph->args : "");
   }
   gkph->url = TALER_url_join (gkph->base_url,
                               arg_str,
                               NULL);
   GNUNET_free (arg_str);
   if (NULL == gkph->url)
     return TALER_EC_GENERIC_CONFIGURATION_INVALID;
   gkph->eh = TALER_EXCHANGE_curl_easy_get_ (gkph->url);
   if (NULL == gkph->eh)
   {
     GNUNET_break (0);
     GNUNET_free (gkph->url);
     gkph->url = NULL;
     return TALER_EC_GENERIC_CONFIGURATION_INVALID;
   }
   /* disable location following, we want to learn the
      result of a 303 redirect! */
   curl_easy_setopt (gkph->eh,
                     CURLOPT_FOLLOWLOCATION,
                     0L);
   gkph->job = GNUNET_CURL_job_add_raw (gkph->ctx,
                                        gkph->eh,
                                        NULL,
                                        &handle_get_kyc_proof_finished,
                                        gkph);
   if (NULL == gkph->job)
   {
     curl_easy_cleanup (gkph->eh);
     gkph->eh = NULL;
     GNUNET_free (gkph->url);
     gkph->url = NULL;
     return TALER_EC_GENERIC_INTERNAL_INVARIANT_FAILURE;
   }
   return TALER_EC_NONE;
 }
 
 
 void
 TALER_EXCHANGE_get_kyc_proof_cancel (
   struct TALER_EXCHANGE_GetKycProofHandle *gkph)
 {
   if (NULL != gkph->job)
   {
     GNUNET_CURL_job_cancel (gkph->job);
     gkph->job = NULL;
   }
   GNUNET_free (gkph->url);
   GNUNET_free (gkph->logic);
   GNUNET_free (gkph->base_url);
   GNUNET_free (gkph);
 }
 
 
 /* end of exchange_api_get-kyc-proof-PROVIDER_NAME.c */