From 2ca9a394063baac075e05b14fcc6c027027ab8f9 Mon Sep 17 00:00:00 2001

From: =?UTF-8?q?Pavel=20B=C5=99ezina?= <pbrezina@redhat.com>

Date: Fri, 24 Feb 2017 10:40:43 +0100

Subject: [PATCH 74/90] tcurl: add support for ssl and raw output

At first, this patch separates curl_easy handle from the multi-handle

processing and makes it encapsulated in custom tcurl_request structure.

This allows us to separate protocol initialization from its asynchonous

logic which gives us the ability to set different options for each

request without over-extending the parameter list.

In this patch we implement options for peer verification for TLS-enabled

protocols and to return response with body and headers together.

Reviewed-by: Simo Sorce <simo@redhat.com>

Reviewed-by: Jakub Hrozek <jhrozek@redhat.com>

(cherry picked from commit 300b9e9217ee1ed8d845ed2370c5ccf5c87afb36)

---

 src/tests/tcurl_test_tool.c |  41 +-

 src/util/tev_curl.c         | 992 +++++++++++++++++++++++++-------------------

 src/util/tev_curl.h         | 172 +++++++-

 src/util/util_errors.c      |   4 +

 src/util/util_errors.h      |   4 +

 5 files changed, 755 insertions(+), 458 deletions(-)

diff --git a/src/tests/tcurl_test_tool.c b/src/tests/tcurl_test_tool.c

index 2af950ebb76a22bdf4a6dfd58442b10486e64293..9a6266f89131ffd3a561e857af85df9854c44949 100644

--- a/src/tests/tcurl_test_tool.c

+++ b/src/tests/tcurl_test_tool.c

@@ -42,9 +42,7 @@ static void request_done(struct tevent_req *req)

     struct tool_ctx *tool_ctx = tevent_req_callback_data(req,

                                                          struct tool_ctx);

-    tool_ctx->error = tcurl_http_recv(tool_ctx, req,

-                                      &http_code,

-                                      &outbuf);

+    tool_ctx->error = tcurl_request_recv(tool_ctx, req, &outbuf, &http_code);

     talloc_zfree(req);

     if (tool_ctx->error != EOK) {

@@ -87,16 +85,17 @@ int main(int argc, const char *argv[])

           "The path to the HTTP server socket", NULL },

         { "get", 'g', POPT_ARG_NONE, NULL, 'g', "Perform a HTTP GET (default)", NULL },

         { "put", 'p', POPT_ARG_NONE, NULL, 'p', "Perform a HTTP PUT", NULL },

-        { "del", 'd', POPT_ARG_NONE, NULL, 'd', "Perform a HTTP DELETE", NULL },

         { "post", 'o', POPT_ARG_NONE, NULL, 'o', "Perform a HTTP POST", NULL },

+        { "del", 'd', POPT_ARG_NONE, NULL, 'd', "Perform a HTTP DELETE", NULL },

         { "verbose", 'v', POPT_ARG_NONE, NULL, 'v', "Print response code and body", NULL },

         POPT_TABLEEND

     };

     struct tevent_req *req;

     struct tevent_context *ev;

-    enum tcurl_http_request req_type = TCURL_HTTP_GET;

+    enum tcurl_http_method method = TCURL_HTTP_GET;

     struct tcurl_ctx *ctx;

+    struct tcurl_request *tcurl_req;

     struct tool_ctx *tool_ctx;

     const char *urls[MAXREQ] = { 0 };

@@ -111,16 +110,16 @@ int main(int argc, const char *argv[])

     while ((opt = poptGetNextOpt(pc)) > 0) {

         switch (opt) {

         case 'g':

-            req_type = TCURL_HTTP_GET;

+            method = TCURL_HTTP_GET;

             break;

         case 'p':

-            req_type = TCURL_HTTP_PUT;

-            break;

-        case 'd':

-            req_type = TCURL_HTTP_DELETE;

+            method = TCURL_HTTP_PUT;

             break;

         case 'o':

-            req_type = TCURL_HTTP_POST;

+            method = TCURL_HTTP_POST;

+            break;

+        case 'd':

+            method = TCURL_HTTP_DELETE;

             break;

         case 'v':

             pc_verbose = 1;

@@ -146,7 +145,7 @@ int main(int argc, const char *argv[])

     }

     while ((extra_arg_ptr = poptGetArg(pc)) != NULL) {

-        switch (req_type) {

+        switch(method) {

         case TCURL_HTTP_GET:

         case TCURL_HTTP_DELETE:

         case TCURL_HTTP_POST:

@@ -203,14 +202,16 @@ int main(int argc, const char *argv[])

     }

     for (size_t i = 0; i < n_reqs; i++) {

-        req = tcurl_http_send(tool_ctx, ev, ctx,

-                              req_type,

-                              socket_path,

-                              urls[i],

-                              headers,

-                              inbufs[i],

-                              5);

-        if (req == NULL) {

+        tcurl_req = tcurl_http(tool_ctx, method, socket_path,

+                               urls[i], headers, inbufs[i]);

+        if (tcurl_req == NULL) {

+            DEBUG(SSSDBG_FATAL_FAILURE, "Unable to create TCURL request\n");

+            talloc_zfree(tool_ctx);

+            return 1;

+        }

+

+        req = tcurl_request_send(tool_ctx, ev, ctx, tcurl_req, 10);

+        if (ctx == NULL) {

             DEBUG(SSSDBG_FATAL_FAILURE, "Could not create request\n");

             talloc_zfree(tool_ctx);

             return 1;

diff --git a/src/util/tev_curl.c b/src/util/tev_curl.c

index 645d1182d10f825f209f48e0ba7e6804dde1971c..c155f4c038d4215933ee30d41c694ad4a14ae132 100644

--- a/src/util/tev_curl.c

+++ b/src/util/tev_curl.c

@@ -34,8 +34,8 @@

 #include "util/util.h"

 #include "util/tev_curl.h"

-#define IOBUF_CHUNK   1024

-#define IOBUF_MAX     4096

+#define TCURL_IOBUF_CHUNK   1024

+#define TCURL_IOBUF_MAX     4096

 static bool global_is_curl_initialized;

@@ -71,39 +71,12 @@ struct tcurl_sock {

     struct tevent_fd *fde;      /* tevent tracker of the fd events */

 };

-/**

- * @brief A state of one curl transfer

- *

- * Intentionally breaking the tevent coding style here and making the struct available

- * in the whole module so that the structure is available to curl callbacks that

- * need to access the state of the transfer.

- *

- * @see handle_curlmsg_done()

- */

-struct tcurl_http_state {

-    /* Input parameters */

-    struct tcurl_ctx *tctx;

-    const char *socket_path;

-    const char *url;

-    int timeout;

-    struct sss_iobuf *inbuf;

-

-    /* Internal state */

-    CURL *http_handle;

-    struct curl_slist *curl_headers;

-

-    /* Output data */

-    struct sss_iobuf *outbuf;

-    long http_code;

-};

+static void tcurl_request_done(struct tevent_req *req,

+                               errno_t process_error,

+                               int response_code);

 static errno_t curl_code2errno(CURLcode crv)

 {

-    if (crv != CURLE_OK) {

-        DEBUG(SSSDBG_OP_FAILURE,

-              "curl error %d: %s\n", crv, curl_easy_strerror(crv));

-    }

-

     switch (crv) {

     /* HTTP error does not fail the whole request, just returns the error

      * separately

@@ -121,6 +94,47 @@ static errno_t curl_code2errno(CURLcode crv)

         return ENOMEM;

     case CURLE_OPERATION_TIMEDOUT:

         return ETIMEDOUT;

+    case CURLE_SSL_ISSUER_ERROR:

+    case CURLE_SSL_CACERT_BADFILE:

+    case CURLE_SSL_CACERT:

+    case CURLE_SSL_CERTPROBLEM:

+        return ERR_INVALID_CERT;

+

+    case CURLE_SSL_CRL_BADFILE:

+    case CURLE_SSL_SHUTDOWN_FAILED:

+    case CURLE_SSL_ENGINE_INITFAILED:

+    case CURLE_USE_SSL_FAILED:

+    case CURLE_SSL_CIPHER:

+    case CURLE_SSL_ENGINE_SETFAILED:

+    case CURLE_SSL_ENGINE_NOTFOUND:

+    case CURLE_SSL_CONNECT_ERROR:

+        return ERR_SSL_FAILURE;

+    case CURLE_PEER_FAILED_VERIFICATION:

+        return ERR_UNABLE_TO_VERIFY_PEER;

+    case CURLE_COULDNT_RESOLVE_HOST:

+        return ERR_UNABLE_TO_RESOLVE_HOST;

+    default:

+        break;

+    }

+

+    return EIO;

+}

+

+static errno_t curlm_code2errno(CURLcode crv)

+{

+    switch (crv) {

+    case CURLM_OK:

+        return EOK;

+    case CURLM_BAD_SOCKET:

+        return EPIPE;

+    case CURLM_OUT_OF_MEMORY:

+        return ENOMEM;

+    case CURLM_BAD_HANDLE:

+    case CURLM_BAD_EASY_HANDLE:

+    case CURLM_UNKNOWN_OPTION:

+        return EINVAL;

+    case CURLM_INTERNAL_ERROR:

+        return ERR_INTERNAL;

     default:

         break;

     }

@@ -145,22 +159,6 @@ static errno_t tcurl_global_init(void)

     return EOK;

 }

-static const char *http_req2str(enum tcurl_http_request req)

-{

-    switch (req) {

-    case TCURL_HTTP_GET:

-        return "GET";

-    case TCURL_HTTP_PUT:

-        return "PUT";

-    case TCURL_HTTP_DELETE:

-        return "DELETE";

-    case TCURL_HTTP_POST:

-        return "POST";

-    }

-

-    return "Uknown request type";

-}

-

 static int curl2tev_flags(int curlflags)

 {

     int flags = 0;

@@ -185,9 +183,9 @@ static void handle_curlmsg_done(CURLMsg *message)

     CURL *easy_handle;

     CURLcode crv;

     struct tevent_req *req;

+    long response_code = 0;

     char *done_url;

     errno_t ret;

-    struct tcurl_http_state *state;

     easy_handle = message->easy_handle;

     if (easy_handle == NULL) {

@@ -198,9 +196,8 @@ static void handle_curlmsg_done(CURLMsg *message)

     if (DEBUG_IS_SET(SSSDBG_TRACE_FUNC)) {

         crv = curl_easy_getinfo(easy_handle, CURLINFO_EFFECTIVE_URL, &done_url);

         if (crv != CURLE_OK) {

-            DEBUG(SSSDBG_MINOR_FAILURE,

-                  "Cannot get CURLINFO_EFFECTIVE_URL [%d]: %s\n",

-                  crv, curl_easy_strerror(crv));

+            DEBUG(SSSDBG_MINOR_FAILURE, "Cannot get CURLINFO_EFFECTIVE_URL "

+                  "[%d]: %s\n", crv, curl_easy_strerror(crv));

             /* not fatal since we need this only for debugging */

         } else {

             DEBUG(SSSDBG_TRACE_FUNC, "Handled %s\n", done_url);

@@ -209,38 +206,32 @@ static void handle_curlmsg_done(CURLMsg *message)

     crv = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (void *) &req;;

     if (crv != CURLE_OK) {

-        DEBUG(SSSDBG_CRIT_FAILURE,

-              "Cannot get CURLINFO_PRIVATE [%d]: %s\n",

+        DEBUG(SSSDBG_CRIT_FAILURE, "Cannot get CURLINFO_PRIVATE [%d]: %s\n",

               crv, curl_easy_strerror(crv));

-        return;

-    }

-

-    state = tevent_req_data(req, struct tcurl_http_state);

-    if (state == NULL) {

-        DEBUG(SSSDBG_CRIT_FAILURE, "BUG: request has no state\n");

-        tevent_req_error(req, EFAULT);

-        return;

+        ret = curl_code2errno(crv);

+        goto done;

     }

     ret = curl_code2errno(message->data.result);

     if (ret != EOK) {

-        DEBUG(SSSDBG_OP_FAILURE,

-              "curl operation failed [%d]: %s\n", ret, sss_strerror(ret));

-        tevent_req_error(req, ret);

-        return;

+        DEBUG(SSSDBG_OP_FAILURE, "CURL operation failed [%d]: %s\n",

+              ret, sss_strerror(ret));

+        goto done;

     }

-    /* If there was no fatal error, let's read the HTTP error code and mark

-     * the request as done

-     */

-    crv = curl_easy_getinfo(easy_handle, CURLINFO_RESPONSE_CODE, &state->http_code);

+    /* If there was no fatal error, let's read the response code

+     * and mark the request as done */

+    crv = curl_easy_getinfo(easy_handle, CURLINFO_RESPONSE_CODE, &response_code);

     if (crv != CURLE_OK) {

-        DEBUG(SSSDBG_OP_FAILURE, "Cannot get HTTP status code\n");

-        tevent_req_error(req, EFAULT);

-        return;

+        DEBUG(SSSDBG_OP_FAILURE, "Cannot get response code\n");

+        ret = curl_code2errno(crv);

+        goto done;

     }

-    tevent_req_done(req);

+    ret = EOK;

+

+done:

+    tcurl_request_done(req, ret, response_code);

 }

 static void process_curl_activity(struct tcurl_ctx *tctx)

@@ -551,346 +542,42 @@ fail:

     return NULL;

 }

-static errno_t tcurl_add_headers(struct tcurl_http_state *state,

-                                 const char *headers[]);

-

-static errno_t tcurl_set_options(struct tcurl_http_state *state,

-                                 struct tevent_req *req,

-                                 enum tcurl_http_request req_type);

-

-static int tcurl_http_cleanup_handle(TALLOC_CTX *ptr);

-

-static size_t tcurl_http_write_data(char *ptr,

-                                    size_t size,

-                                    size_t nmemb,

-                                    void *userdata);

-

-static size_t tcurl_http_read_data(void *ptr,

-                                   size_t size,

-                                   size_t nmemb,

-                                   void *userdata);

-

-struct tevent_req *tcurl_http_send(TALLOC_CTX *mem_ctx,

-                                   struct tevent_context *ev,

-                                   struct tcurl_ctx *tctx,

-                                   enum tcurl_http_request req_type,

-                                   const char *socket_path,

-                                   const char *url,

-                                   const char *headers[],

-                                   struct sss_iobuf *req_data,

-                                   int timeout)

-{

-    errno_t ret;

-    struct tevent_req *req;

-    struct tcurl_http_state *state;

-

-    req = tevent_req_create(mem_ctx, &state, struct tcurl_http_state);

-    if (req == NULL) {

-        return NULL;

-    }

-

-    state->tctx = tctx;

-    state->socket_path = socket_path;

-    state->url = url;

-    state->inbuf = req_data;

-    state->timeout = timeout;

-

-    state->outbuf = sss_iobuf_init_empty(state, IOBUF_CHUNK, IOBUF_MAX);

-    if (state->outbuf == NULL) {

-        ret = ENOMEM;

-        goto fail;

-    }

-

-    DEBUG(SSSDBG_TRACE_FUNC,

-          "HTTP request %s for URL %s\n", http_req2str(req_type), url);

-    talloc_set_destructor((TALLOC_CTX *) state, tcurl_http_cleanup_handle);

-

-    /* All transfer share the same multi handle, but each trasfer has its own

-     * easy handle we can use to set per-transfer options

-     */

-    state->http_handle = curl_easy_init();

-    if (state->http_handle == NULL) {

-        DEBUG(SSSDBG_CRIT_FAILURE, "curl_easy_init failed\n");

-        ret = EIO;

-        goto fail;

-    }

-

-    ret = tcurl_add_headers(state, headers);

-    if (ret != EOK) {

-        DEBUG(SSSDBG_CRIT_FAILURE,

-              "Failed to set CURL headers [%d]: %s\n", ret, sss_strerror(ret));

-        goto fail;

-    }

-

-    ret = tcurl_set_options(state, req, req_type);

-    if (ret != EOK) {

-        DEBUG(SSSDBG_CRIT_FAILURE,

-              "Failed to set CURL options [%d]: %s\n", ret, sss_strerror(ret));

-        goto fail;

-    }

-

-    /* Pass control to the curl handling which will mark the request as

-     * done

-     */

-    curl_multi_add_handle(tctx->multi_handle, state->http_handle);

-

-    return req;

-

-fail:

-    tevent_req_error(req, ret);

-    tevent_req_post(req, ev);

-    return req;

-}

-

-static int tcurl_http_cleanup_handle(TALLOC_CTX *ptr)

-{

-    struct tcurl_http_state *state = talloc_get_type(ptr, struct tcurl_http_state);

-

-    if (state == NULL) {

-        return 0;

-    }

-

-    /* it is safe to pass NULL here */

-    curl_multi_remove_handle(state->tctx->multi_handle, state->http_handle);

-    curl_slist_free_all(state->curl_headers);

-    curl_easy_cleanup(state->http_handle);

-    return 0;

-}

-

-static errno_t tcurl_add_headers(struct tcurl_http_state *state,

-                                 const char *headers[])

-{

-    if (headers == NULL) {

-        return EOK;

-    }

-

-    /* The headers will be freed later in tcurl_http_cleanup_handle */

-    for (int i = 0; headers[i] != NULL; i++) {

-        state->curl_headers = curl_slist_append(state->curl_headers, headers[i]);

-        if (state->curl_headers == NULL) {

-            DEBUG(SSSDBG_CRIT_FAILURE, "Cannot add header %s\n", headers[i]);

-            return ENOMEM;

-        }

-    }

-

-    /* Add a dummy header to suppress libcurl adding Expect 100-continue which

-     * was causing libcurl to always wait for the internal timeout when sending

-     * a PUT/PATCH request

-     */

-    state->curl_headers = curl_slist_append(state->curl_headers, "Expect:");

-    if (state->curl_headers == NULL) {

-        DEBUG(SSSDBG_CRIT_FAILURE, "Cannot add the dummy expect header\n");

-        return ENOMEM;

-    }

-

-    return EOK;

-}

-

-static errno_t tcurl_set_common_options(struct tcurl_http_state *state,

-                                        struct tevent_req *req)

-{

-    CURLcode crv;

-

-    crv = curl_easy_setopt(state->http_handle,

-                           CURLOPT_HTTPHEADER,

-                           state->curl_headers);

-    if (crv != CURLE_OK) {

-        DEBUG(SSSDBG_OP_FAILURE,

-              "Failed to set HTTP headers [%d]: %s\n",

-              crv, curl_easy_strerror(crv));

-        return EIO;

-    }

-

-    crv = curl_easy_setopt(state->http_handle,

-                           CURLOPT_UNIX_SOCKET_PATH,

-                           state->socket_path);

-    if (crv != CURLE_OK) {

-        DEBUG(SSSDBG_OP_FAILURE,

-              "Failed to set UNIX socket path %s [%d]: %s\n",

-              state->socket_path, crv, curl_easy_strerror(crv));

-        return EIO;

-    }

-

-    crv = curl_easy_setopt(state->http_handle, CURLOPT_URL, state->url);

-    if (crv != CURLE_OK) {

-        DEBUG(SSSDBG_OP_FAILURE,

-              "Failed to set URL %s [%d]: %s\n",

-              state->url, crv, curl_easy_strerror(crv));

-        return EIO;

-    }

-

-    crv = curl_easy_setopt(state->http_handle, CURLOPT_PRIVATE, req);

-    if (crv != CURLE_OK) {

-        DEBUG(SSSDBG_OP_FAILURE,

-              "Failed to set private data [%d]: %s\n",

-              crv, curl_easy_strerror(crv));

-        return EIO;

-    }

-

-    if (state->timeout > 0) {

-        crv = curl_easy_setopt(state->http_handle,

-                               CURLOPT_TIMEOUT,

-                               state->timeout);

-        if (crv != CURLE_OK) {

-            DEBUG(SSSDBG_OP_FAILURE,

-                  "Failed to set timeout [%d]: %s\n",

-                  crv, curl_easy_strerror(crv));

-            return EIO;

-        }

-    }

-

-    return EOK;

-}

-

-static errno_t tcurl_set_write_options(struct tcurl_http_state *state)

-{

-    CURLcode crv;

-

-    crv = curl_easy_setopt(state->http_handle,

-                           CURLOPT_WRITEFUNCTION,

-                           tcurl_http_write_data);

-    if (crv != CURLE_OK) {

-        DEBUG(SSSDBG_OP_FAILURE,

-              "Failed to set write function [%d]: %s\n",

-              crv, curl_easy_strerror(crv));

-        return EIO;

-    }

-

-    crv = curl_easy_setopt(state->http_handle,

-                           CURLOPT_WRITEDATA,

-                           state->outbuf);

-    if (crv != CURLE_OK) {

-        DEBUG(SSSDBG_OP_FAILURE,

-              "Failed to set write data [%d]: %s\n",

-              crv, curl_easy_strerror(crv));

-        return EIO;

-    }

-

-    return EOK;

-}

-

-static errno_t tcurl_set_read_options(struct tcurl_http_state *state)

-{

-    CURLcode crv;

-

-    crv = curl_easy_setopt(state->http_handle,

-                           CURLOPT_READFUNCTION,

-                           tcurl_http_read_data);

-    if (crv != CURLE_OK) {

-        DEBUG(SSSDBG_OP_FAILURE,

-              "Failed to set read function [%d]: %s\n",

-              crv, curl_easy_strerror(crv));

-        return EIO;

-    }

-

-    crv = curl_easy_setopt(state->http_handle,

-                           CURLOPT_READDATA,

-                           state->inbuf);

-    if (crv != CURLE_OK) {

-        DEBUG(SSSDBG_OP_FAILURE,

-              "Failed to set read data [%d]: %s\n",

-              crv, curl_easy_strerror(crv));

-        return EIO;

-    }

-

-    return EOK;

-}

-

-static errno_t tcurl_set_options(struct tcurl_http_state *state,

-                                 struct tevent_req *req,

-                                 enum tcurl_http_request req_type)

-{

-    CURLcode crv;

-    errno_t ret;

-

-    ret = tcurl_set_common_options(state, req);

-    if (ret != EOK) {

-        return ret;

-    }

-

-    ret = tcurl_set_write_options(state);

-    if (ret != EOK) {

-        DEBUG(SSSDBG_CRIT_FAILURE,

-              "Failed to set write callbacks [%d]: %s\n",

-              ret, sss_strerror(ret));

-        return ret;

-    }

-

-    switch (req_type) {

-    case TCURL_HTTP_POST:

-        crv = curl_easy_setopt(state->http_handle,

-                               CURLOPT_CUSTOMREQUEST,

-                               "POST");

-        break;

-    case TCURL_HTTP_PUT:

-        /* CURLOPT_UPLOAD enables HTTP_PUT */

-        crv = curl_easy_setopt(state->http_handle,

-                               CURLOPT_UPLOAD,

-                               1L);

-        if (crv != CURLE_OK) {

-            DEBUG(SSSDBG_OP_FAILURE,

-                  "Failed to set the uplodad option [%d]: %s\n",

-                  crv, curl_easy_strerror(crv));

-            return EIO;

-        }

-

-        /* Causes libcurl to add a sane Content-Length header */

-        crv = curl_easy_setopt(state->http_handle,

-                               CURLOPT_INFILESIZE_LARGE,

-                               (curl_off_t) sss_iobuf_get_size(state->inbuf));

-        if (crv != CURLE_OK) {

-            DEBUG(SSSDBG_OP_FAILURE,

-                  "Failed to set CURLOPT_INFILESIZE_LARGE [%d]: %s\n",

-                  crv, curl_easy_strerror(crv));

-            return EIO;

-        }

-

-        ret = tcurl_set_read_options(state);

-        if (ret != EOK) {

-            DEBUG(SSSDBG_CRIT_FAILURE,

-                  "Failed to set write callbacks [%d]: %s\n",

-                  ret, sss_strerror(ret));

-            return ret;

-        }

-        break;

-    case TCURL_HTTP_GET:

-        /* GET just needs the write callbacks, nothing to do here.. */

-        break;

-    case TCURL_HTTP_DELETE:

-        crv = curl_easy_setopt(state->http_handle,

-                               CURLOPT_CUSTOMREQUEST,

-                               "DELETE");

-        if (crv != CURLE_OK) {

-            DEBUG(SSSDBG_OP_FAILURE,

-                  "Failed to set the uplodad option [%d]: %s\n",

-                  crv, curl_easy_strerror(crv));

-            return EIO;

-        }

-        break;

-    default:

-        return EFAULT;

-    }

-

-    return EOK;

-}

-

-static size_t tcurl_http_write_data(char *ptr,

-                                    size_t size,

-                                    size_t nmemb,

-                                    void *userdata)

+#define tcurl_set_option(tcurl_req, option, value)                          \

+({                                                                          \

+    CURLcode __curl_code;                                                   \

+    errno_t __ret;                                                          \

+                                                                            \

+    __curl_code = curl_easy_setopt((tcurl_req)->curl_easy_handle,           \

+                                   (option), (value));                      \

+    if (__curl_code == CURLE_OK) {                                          \

+        __ret = EOK;                                                        \

+    } else {                                                                \

+        DEBUG(SSSDBG_OP_FAILURE, "Failed to set CURL option %s [%d]: %s\n", \

+              #option, __curl_code, curl_easy_strerror(__curl_code));       \

+        __ret = curl_code2errno(__curl_code);                               \

+    }                                                                       \

+    __ret;                                                                  \

+})

+

+static size_t tcurl_write_data(char *ptr,

+                               size_t size,

+                               size_t nmemb,

+                               void *userdata)

 {

     errno_t ret;

     size_t realsize = size * nmemb;

-    struct sss_iobuf *outbuf = talloc_get_type(userdata, struct sss_iobuf);

+    struct sss_iobuf *outbuf;

+

+    outbuf = talloc_get_type(userdata, struct sss_iobuf);

     DEBUG(SSSDBG_TRACE_INTERNAL, "---> begin libcurl data\n");

     DEBUG(SSSDBG_TRACE_INTERNAL, "%s\n", ptr);

     DEBUG(SSSDBG_TRACE_INTERNAL, "<--- end libcurl data\n");

-    ret = sss_iobuf_write_len(outbuf, (uint8_t *) ptr, realsize);

+    ret = sss_iobuf_write_len(outbuf, (uint8_t *)ptr, realsize);

     if (ret != EOK) {

-        DEBUG(SSSDBG_CRIT_FAILURE,

-              "Failed to write data to buffer [%d]: %s\n", ret, sss_strerror(ret));

+        DEBUG(SSSDBG_CRIT_FAILURE, "Failed to write data to buffer [%d]: %s\n",

+              ret, sss_strerror(ret));

         /* zero signifies an EOF */

         return 0;

     }

@@ -898,14 +585,16 @@ static size_t tcurl_http_write_data(char *ptr,

     return realsize;

 }

-static size_t tcurl_http_read_data(void *ptr,

-                                   size_t size,

-                                   size_t nmemb,

-                                   void *userdata)

+static size_t tcurl_read_data(void *ptr,

+                              size_t size,

+                              size_t nmemb,

+                              void *userdata)

 {

     errno_t ret;

     size_t readbytes;

-    struct sss_iobuf *inbuf = (struct sss_iobuf *) userdata;

+    struct sss_iobuf *inbuf;

+

+    inbuf = talloc_get_type(userdata, struct sss_iobuf);

     if (inbuf == NULL) {