2.4.x-mod_md/modules/md/md_curl.c - httpd - Git at Google

 /* Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 /* Copyright 2017 greenbytes GmbH (https://www.greenbytes.de)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0

  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <assert.h>

 #include <curl/curl.h>

 #include <apr_lib.h>
 #include <apr_strings.h>
 #include <apr_buckets.h>

 #include "md_http.h"
 #include "md_log.h"
 #include "md_curl.h"

 /**************************************************************************************************/
 /* md_http curl implementation */


 static apr_status_t curl_status(int curl_code)
 {
     switch (curl_code) {
         case CURLE_OK:                   return APR_SUCCESS;
         case CURLE_UNSUPPORTED_PROTOCOL: return APR_ENOTIMPL;
         case CURLE_NOT_BUILT_IN:         return APR_ENOTIMPL;
         case CURLE_URL_MALFORMAT:        return APR_EINVAL;
         case CURLE_COULDNT_RESOLVE_PROXY:return APR_ECONNREFUSED;
         case CURLE_COULDNT_RESOLVE_HOST: return APR_ECONNREFUSED;
         case CURLE_COULDNT_CONNECT:      return APR_ECONNREFUSED;
         case CURLE_REMOTE_ACCESS_DENIED: return APR_EACCES;
         case CURLE_OUT_OF_MEMORY:        return APR_ENOMEM;
         case CURLE_OPERATION_TIMEDOUT:   return APR_TIMEUP;
         case CURLE_SSL_CONNECT_ERROR:    return APR_ECONNABORTED;
         case CURLE_AGAIN:                return APR_EAGAIN;
         default:                         return APR_EGENERAL;
     }
 }

 static size_t req_data_cb(void *data, size_t len, size_t nmemb, void *baton)
 {
     apr_bucket_brigade *body = baton;
     size_t blen, read_len = 0, max_len = len * nmemb;
     const char *bdata;
     apr_bucket *b;
     apr_status_t rv;

     while (body && !APR_BRIGADE_EMPTY(body) && max_len > 0) {
         b = APR_BRIGADE_FIRST(body);
         if (APR_BUCKET_IS_METADATA(b)) {
             if (APR_BUCKET_IS_EOS(b)) {
                 body = NULL;
             }
         }
         else {
             rv = apr_bucket_read(b, &bdata, &blen, APR_BLOCK_READ);
             if (rv == APR_SUCCESS) {
                 if (blen > max_len) {
                     apr_bucket_split(b, max_len);
                     blen = max_len;
                 }
                 memcpy(data, bdata, blen);
                 read_len += blen;
                 max_len -= blen;
             }
             else {
                 body = NULL;
                 if (!APR_STATUS_IS_EOF(rv)) {
                     /* everything beside EOF is an error */
                     read_len = CURL_READFUNC_ABORT;
                 }
             }

         }
         apr_bucket_delete(b);
     }

     return read_len;
 }

 static size_t resp_data_cb(void *data, size_t len, size_t nmemb, void *baton)
 {
     md_http_response_t *res = baton;
     size_t blen = len * nmemb;
     apr_status_t rv;

     if (res->body) {
         if (res->req->resp_limit) {
             apr_off_t body_len = 0;
             apr_brigade_length(res->body, 0, &body_len);
             if (body_len + (apr_off_t)len > res->req->resp_limit) {
                 return 0; /* signal curl failure */
             }
         }
         rv = apr_brigade_write(res->body, NULL, NULL, (const char *)data, blen);
         if (rv != APR_SUCCESS) {
             /* returning anything != blen will make CURL fail this */
             return 0;
         }
     }
     return blen;
 }

 static size_t header_cb(void *buffer, size_t elen, size_t nmemb, void *baton)
 {
     md_http_response_t *res = baton;
     size_t len, clen = elen * nmemb;
     const char *name = NULL, *value = "", *b = buffer;
     apr_size_t i;

     len = (clen && b[clen-1] == '\n')? clen-1 : clen;
     len = (len && b[len-1] == '\r')? len-1 : len;
     for (i = 0; i < len; ++i) {
         if (b[i] == ':') {
             name = apr_pstrndup(res->req->pool, b, i);
             ++i;
             while (i < len && b[i] == ' ') {
                 ++i;
             }
             if (i < len) {
                 value = apr_pstrndup(res->req->pool, b+i, len - i);
             }
             break;
         }
     }

     if (name != NULL) {
         apr_table_add(res->headers, name, value);
     }
     return clen;
 }

 static apr_status_t curl_init(md_http_request_t *req)
 {
     CURL *curl = curl_easy_init();
     if (!curl) {
         return APR_EGENERAL;
     }

     curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, header_cb);
     curl_easy_setopt(curl, CURLOPT_HEADERDATA, NULL);
     curl_easy_setopt(curl, CURLOPT_READFUNCTION, req_data_cb);
     curl_easy_setopt(curl, CURLOPT_READDATA, NULL);
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, resp_data_cb);
     curl_easy_setopt(curl, CURLOPT_WRITEDATA, NULL);

     req->internals = curl;
     return APR_SUCCESS;
 }

 typedef struct {
     md_http_request_t *req;
     struct curl_slist *hdrs;
     apr_status_t rv;
 } curlify_hdrs_ctx;

 static int curlify_headers(void *baton, const char *key, const char *value)
 {
     curlify_hdrs_ctx *ctx = baton;
     const char *s;

     if (strchr(key, '\r') || strchr(key, '\n')
         || strchr(value, '\r') || strchr(value, '\n')) {
         ctx->rv = APR_EINVAL;
         return 0;
     }
     s = apr_psprintf(ctx->req->pool, "%s: %s", key, value);
     ctx->hdrs = curl_slist_append(ctx->hdrs, s);
     return 1;
 }

 static apr_status_t curl_perform(md_http_request_t *req)
 {
     apr_status_t rv = APR_SUCCESS;
     CURLcode curle;
     md_http_response_t *res;
     CURL *curl;
     struct curl_slist *req_hdrs = NULL;

     rv = curl_init(req);
     curl = req->internals;

     res = apr_pcalloc(req->pool, sizeof(*res));

     res->req = req;
     res->rv = APR_SUCCESS;
     res->status = 400;
     res->headers = apr_table_make(req->pool, 5);
     res->body = apr_brigade_create(req->pool, req->bucket_alloc);

     curl_easy_setopt(curl, CURLOPT_URL, req->url);
     if (!apr_strnatcasecmp("GET", req->method)) {
         /* nop */
     }
     else if (!apr_strnatcasecmp("HEAD", req->method)) {
         curl_easy_setopt(curl, CURLOPT_NOBODY, 1L);
     }
     else if (!apr_strnatcasecmp("POST", req->method)) {
         curl_easy_setopt(curl, CURLOPT_POST, 1L);
     }
     else {
         curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, req->method);
     }
     curl_easy_setopt(curl, CURLOPT_HEADERDATA, res);
     curl_easy_setopt(curl, CURLOPT_READDATA, req->body);
     curl_easy_setopt(curl, CURLOPT_WRITEDATA, res);

     if (req->user_agent) {
         curl_easy_setopt(curl, CURLOPT_USERAGENT, req->user_agent);
     }
     if (req->proxy_url) {
         curl_easy_setopt(curl, CURLOPT_PROXY, req->proxy_url);
     }
     if (!apr_is_empty_table(req->headers)) {
         curlify_hdrs_ctx ctx;

         ctx.req = req;
         ctx.hdrs = NULL;
         ctx.rv = APR_SUCCESS;
         apr_table_do(curlify_headers, &ctx, req->headers, NULL);
         req_hdrs = ctx.hdrs;
         if (ctx.rv == APR_SUCCESS) {
             curl_easy_setopt(curl, CURLOPT_HTTPHEADER, req_hdrs);
         }
     }

     md_log_perror(MD_LOG_MARK, MD_LOG_TRACE1, 0, req->pool,
                   "request %ld --> %s %s", req->id, req->method, req->url);

     if (md_log_is_level(req->pool, MD_LOG_TRACE3)) {
         curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
     }

     curle = curl_easy_perform(curl);
     res->rv = curl_status(curle);

     if (APR_SUCCESS == res->rv) {
         long l;
         res->rv = curl_status(curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &l));
         if (APR_SUCCESS == res->rv) {
             res->status = (int)l;
         }
         md_log_perror(MD_LOG_MARK, MD_LOG_TRACE1, res->rv, req->pool,
                       "request %ld <-- %d", req->id, res->status);
     }
     else {
         md_log_perror(MD_LOG_MARK, MD_LOG_DEBUG, res->rv, req->pool,
                       "request %ld failed(%d): %s", req->id, curle,
                       curl_easy_strerror(curle));
     }

     if (req->cb) {
         res->rv = req->cb(res);
     }

     rv = res->rv;
     md_http_req_destroy(req);
     if (req_hdrs) {
         curl_slist_free_all(req_hdrs);
     }

     return rv;
 }

 static int initialized;

 static apr_status_t md_curl_init(void) {
     if (!initialized) {
         initialized = 1;
         curl_global_init(CURL_GLOBAL_DEFAULT);
     }
     return APR_SUCCESS;
 }

 static void curl_req_cleanup(md_http_request_t *req)
 {
     if (req->internals) {
         curl_easy_cleanup(req->internals);
         req->internals = NULL;
     }
 }

 static md_http_impl_t impl = {
     md_curl_init,
     curl_req_cleanup,
     curl_perform
 };

 md_http_impl_t * md_curl_get_impl(apr_pool_t *p)
 {
     /* trigger early global curl init, before we are down a rabbit hole */
     (void)p;
     md_curl_init();
     return &impl;
 }
	/* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/* Copyright 2017 greenbytes GmbH (https://www.greenbytes.de)
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0

	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <assert.h>

	#include <curl/curl.h>

	#include <apr_lib.h>
	#include <apr_strings.h>
	#include <apr_buckets.h>

	#include "md_http.h"
	#include "md_log.h"
	#include "md_curl.h"

	/**************************************************************************************************/
	/* md_http curl implementation */


	static apr_status_t curl_status(int curl_code)
	{
	switch (curl_code) {
	case CURLE_OK: return APR_SUCCESS;
	case CURLE_UNSUPPORTED_PROTOCOL: return APR_ENOTIMPL;
	case CURLE_NOT_BUILT_IN: return APR_ENOTIMPL;
	case CURLE_URL_MALFORMAT: return APR_EINVAL;
	case CURLE_COULDNT_RESOLVE_PROXY:return APR_ECONNREFUSED;
	case CURLE_COULDNT_RESOLVE_HOST: return APR_ECONNREFUSED;
	case CURLE_COULDNT_CONNECT: return APR_ECONNREFUSED;
	case CURLE_REMOTE_ACCESS_DENIED: return APR_EACCES;
	case CURLE_OUT_OF_MEMORY: return APR_ENOMEM;
	case CURLE_OPERATION_TIMEDOUT: return APR_TIMEUP;
	case CURLE_SSL_CONNECT_ERROR: return APR_ECONNABORTED;
	case CURLE_AGAIN: return APR_EAGAIN;
	default: return APR_EGENERAL;
	}
	}

	static size_t req_data_cb(void data, size_t len, size_t nmemb, void baton)
	{
	apr_bucket_brigade *body = baton;
	size_t blen, read_len = 0, max_len = len * nmemb;
	const char *bdata;
	apr_bucket *b;
	apr_status_t rv;

	while (body && !APR_BRIGADE_EMPTY(body) && max_len > 0) {
	b = APR_BRIGADE_FIRST(body);
	if (APR_BUCKET_IS_METADATA(b)) {
	if (APR_BUCKET_IS_EOS(b)) {
	body = NULL;
	}
	}
	else {
	rv = apr_bucket_read(b, &bdata, &blen, APR_BLOCK_READ);
	if (rv == APR_SUCCESS) {
	if (blen > max_len) {
	apr_bucket_split(b, max_len);
	blen = max_len;
	}
	memcpy(data, bdata, blen);
	read_len += blen;
	max_len -= blen;
	}
	else {
	body = NULL;
	if (!APR_STATUS_IS_EOF(rv)) {
	/* everything beside EOF is an error */
	read_len = CURL_READFUNC_ABORT;
	}
	}

	}
	apr_bucket_delete(b);
	}

	return read_len;
	}

	static size_t resp_data_cb(void data, size_t len, size_t nmemb, void baton)
	{
	md_http_response_t *res = baton;
	size_t blen = len * nmemb;
	apr_status_t rv;

	if (res->body) {
	if (res->req->resp_limit) {
	apr_off_t body_len = 0;
	apr_brigade_length(res->body, 0, &body_len);
	if (body_len + (apr_off_t)len > res->req->resp_limit) {
	return 0; /* signal curl failure */
	}
	}
	rv = apr_brigade_write(res->body, NULL, NULL, (const char *)data, blen);
	if (rv != APR_SUCCESS) {
	/* returning anything != blen will make CURL fail this */
	return 0;
	}
	}
	return blen;
	}

	static size_t header_cb(void buffer, size_t elen, size_t nmemb, void baton)
	{
	md_http_response_t *res = baton;
	size_t len, clen = elen * nmemb;
	const char name = NULL, value = "", *b = buffer;
	apr_size_t i;

	len = (clen && b[clen-1] == '\n')? clen-1 : clen;
	len = (len && b[len-1] == '\r')? len-1 : len;
	for (i = 0; i < len; ++i) {
	if (b[i] == ':') {
	name = apr_pstrndup(res->req->pool, b, i);
	++i;
	while (i < len && b[i] == ' ') {
	++i;
	}
	if (i < len) {
	value = apr_pstrndup(res->req->pool, b+i, len - i);
	}
	break;
	}
	}

	if (name != NULL) {
	apr_table_add(res->headers, name, value);
	}
	return clen;
	}

	static apr_status_t curl_init(md_http_request_t *req)
	{
	CURL *curl = curl_easy_init();
	if (!curl) {
	return APR_EGENERAL;
	}

	curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, header_cb);
	curl_easy_setopt(curl, CURLOPT_HEADERDATA, NULL);
	curl_easy_setopt(curl, CURLOPT_READFUNCTION, req_data_cb);
	curl_easy_setopt(curl, CURLOPT_READDATA, NULL);
	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, resp_data_cb);
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, NULL);

	req->internals = curl;
	return APR_SUCCESS;
	}

	typedef struct {
	md_http_request_t *req;
	struct curl_slist *hdrs;
	apr_status_t rv;
	} curlify_hdrs_ctx;

	static int curlify_headers(void baton, const char key, const char *value)
	{
	curlify_hdrs_ctx *ctx = baton;
	const char *s;

	if (strchr(key, '\r') \|\| strchr(key, '\n')
	\|\| strchr(value, '\r') \|\| strchr(value, '\n')) {
	ctx->rv = APR_EINVAL;
	return 0;
	}
	s = apr_psprintf(ctx->req->pool, "%s: %s", key, value);
	ctx->hdrs = curl_slist_append(ctx->hdrs, s);
	return 1;
	}

	static apr_status_t curl_perform(md_http_request_t *req)
	{
	apr_status_t rv = APR_SUCCESS;
	CURLcode curle;
	md_http_response_t *res;
	CURL *curl;
	struct curl_slist *req_hdrs = NULL;

	rv = curl_init(req);
	curl = req->internals;

	res = apr_pcalloc(req->pool, sizeof(*res));

	res->req = req;
	res->rv = APR_SUCCESS;
	res->status = 400;
	res->headers = apr_table_make(req->pool, 5);
	res->body = apr_brigade_create(req->pool, req->bucket_alloc);

	curl_easy_setopt(curl, CURLOPT_URL, req->url);
	if (!apr_strnatcasecmp("GET", req->method)) {
	/* nop */
	}
	else if (!apr_strnatcasecmp("HEAD", req->method)) {
	curl_easy_setopt(curl, CURLOPT_NOBODY, 1L);
	}
	else if (!apr_strnatcasecmp("POST", req->method)) {
	curl_easy_setopt(curl, CURLOPT_POST, 1L);
	}
	else {
	curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, req->method);
	}
	curl_easy_setopt(curl, CURLOPT_HEADERDATA, res);
	curl_easy_setopt(curl, CURLOPT_READDATA, req->body);
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, res);

	if (req->user_agent) {
	curl_easy_setopt(curl, CURLOPT_USERAGENT, req->user_agent);
	}
	if (req->proxy_url) {
	curl_easy_setopt(curl, CURLOPT_PROXY, req->proxy_url);
	}
	if (!apr_is_empty_table(req->headers)) {
	curlify_hdrs_ctx ctx;

	ctx.req = req;
	ctx.hdrs = NULL;
	ctx.rv = APR_SUCCESS;
	apr_table_do(curlify_headers, &ctx, req->headers, NULL);
	req_hdrs = ctx.hdrs;
	if (ctx.rv == APR_SUCCESS) {
	curl_easy_setopt(curl, CURLOPT_HTTPHEADER, req_hdrs);
	}
	}

	md_log_perror(MD_LOG_MARK, MD_LOG_TRACE1, 0, req->pool,
	"request %ld --> %s %s", req->id, req->method, req->url);

	if (md_log_is_level(req->pool, MD_LOG_TRACE3)) {
	curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
	}

	curle = curl_easy_perform(curl);
	res->rv = curl_status(curle);

	if (APR_SUCCESS == res->rv) {
	long l;
	res->rv = curl_status(curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &l));
	if (APR_SUCCESS == res->rv) {
	res->status = (int)l;
	}
	md_log_perror(MD_LOG_MARK, MD_LOG_TRACE1, res->rv, req->pool,
	"request %ld <-- %d", req->id, res->status);
	}
	else {
	md_log_perror(MD_LOG_MARK, MD_LOG_DEBUG, res->rv, req->pool,
	"request %ld failed(%d): %s", req->id, curle,
	curl_easy_strerror(curle));
	}

	if (req->cb) {
	res->rv = req->cb(res);
	}

	rv = res->rv;
	md_http_req_destroy(req);
	if (req_hdrs) {
	curl_slist_free_all(req_hdrs);
	}

	return rv;
	}

	static int initialized;

	static apr_status_t md_curl_init(void) {
	if (!initialized) {
	initialized = 1;
	curl_global_init(CURL_GLOBAL_DEFAULT);
	}
	return APR_SUCCESS;
	}

	static void curl_req_cleanup(md_http_request_t *req)
	{
	if (req->internals) {
	curl_easy_cleanup(req->internals);
	req->internals = NULL;
	}
	}

	static md_http_impl_t impl = {
	md_curl_init,
	curl_req_cleanup,
	curl_perform
	};

	md_http_impl_t * md_curl_get_impl(apr_pool_t *p)
	{
	/* trigger early global curl init, before we are down a rabbit hole */
	(void)p;
	md_curl_init();
	return &impl;
	}