Quelle md_http.c Sprache: C

/* 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.
*/

#include <assert.h>

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

#include "md_http.h"
#include "md_log.h"
#include "md_util.h"

struct md_http_t {
    apr_pool_t *pool;
    apr_bucket_alloc_t *bucket_alloc;
    int next_id;
    apr_off_t resp_limit;
    md_http_impl_t *impl;
    void *impl_data;         /* to be used by the implementation */
    const char *user_agent;
    const char *proxy_url;
    const char *unix_socket_path;
    md_http_timeouts_t timeout;
    const char *ca_file;
};

static md_http_impl_t *cur_impl;
static int cur_init_done;

void md_http_use_implementation(md_http_impl_t *impl)
{
    if (cur_impl != impl) {
        cur_impl = impl;
        cur_init_done = 0;
    }
}

static apr_status_t http_cleanup(void *data)
{
    md_http_t *http = data;
    if (http && http->impl && http->impl->cleanup) {
        http->impl->cleanup(http, http->pool);
    }
    return APR_SUCCESS;
}

apr_status_t md_http_create(md_http_t **phttp, apr_pool_t *p, const char *user_agent,
                            const char *proxy_url)
{
    md_http_t *http;
    apr_status_t rv = APR_SUCCESS;

    if (!cur_impl) {
        *phttp = NULL;
        return APR_ENOTIMPL;
    }

    if (!cur_init_done) {
        if (APR_SUCCESS == (rv = cur_impl->init())) {
            cur_init_done = 1;
        }
        else {
            return rv;
        }
    }

    http = apr_pcalloc(p, sizeof(*http));
    http->pool = p;
    http->impl = cur_impl;
    http->user_agent = apr_pstrdup(p, user_agent);
    http->proxy_url = proxy_url? apr_pstrdup(p, proxy_url) : NULL;
    http->bucket_alloc = apr_bucket_alloc_create(p);
    if (!http->bucket_alloc) {
        return APR_EGENERAL;
    }
    apr_pool_cleanup_register(p, http, http_cleanup, apr_pool_cleanup_null);
    *phttp = http;
    return APR_SUCCESS;
}

apr_status_t md_http_clone(md_http_t **phttp,
                           apr_pool_t *p, md_http_t *source_http)
{
    apr_status_t rv;

    rv = md_http_create(phttp, p, source_http->user_agent, source_http->proxy_url);
    if (APR_SUCCESS == rv) {
        (*phttp)->resp_limit = source_http->resp_limit;
        (*phttp)->timeout = source_http->timeout;
        if (source_http->unix_socket_path) {
            (*phttp)->unix_socket_path = apr_pstrdup(p, source_http->unix_socket_path);
        }
        if (source_http->ca_file) {
            (*phttp)->ca_file = apr_pstrdup(p, source_http->ca_file);
        }
    }
    return rv;
}

void md_http_set_impl_data(md_http_t *http, void *data)
{
    http->impl_data = data;
}

void *md_http_get_impl_data(md_http_t *http)
{
    return http->impl_data;
}

void md_http_set_response_limit(md_http_t *http, apr_off_t resp_limit)
{
    http->resp_limit = resp_limit;
}

void md_http_set_timeout_default(md_http_t *http, apr_time_t timeout)
{
    http->timeout.overall = timeout;
}

void md_http_set_timeout(md_http_request_t *req, apr_time_t timeout)
{
    req->timeout.overall = timeout;
}

void md_http_set_connect_timeout_default(md_http_t *http, apr_time_t timeout)
{
    http->timeout.connect = timeout;
}

void md_http_set_connect_timeout(md_http_request_t *req, apr_time_t timeout)
{
    req->timeout.connect = timeout;
}

void md_http_set_stalling_default(md_http_t *http, long bytes_per_sec, apr_time_t timeout)
{
    http->timeout.stall_bytes_per_sec = bytes_per_sec;
    http->timeout.stalled = timeout;
}

void md_http_set_stalling(md_http_request_t *req, long bytes_per_sec, apr_time_t timeout)
{
    req->timeout.stall_bytes_per_sec = bytes_per_sec;
    req->timeout.stalled = timeout;
}

void md_http_set_ca_file(md_http_t *http, const char *ca_file)
{
    http->ca_file = ca_file;
}

void md_http_set_unix_socket_path(md_http_t *http, const char *path)
{
    http->unix_socket_path = path;
}

static apr_status_t req_set_body(md_http_request_t *req, const char *content_type,
                                 apr_bucket_brigade *body, apr_off_t body_len,
                                 int detect_len)
{
    apr_status_t rv = APR_SUCCESS;

    if (body && detect_len) {
        rv = apr_brigade_length(body, 1, &body_len);
        if (rv != APR_SUCCESS) {
            return rv;
        }
    }

    req->body = body;
    req->body_len = body? body_len : 0;
    if (content_type) {
        apr_table_set(req->headers, "Content-Type", content_type);
    }
    else {
        apr_table_unset(req->headers, "Content-Type");
    }
    return rv;
}

static apr_status_t req_set_body_data(md_http_request_t *req, const char *content_type,
                                      const md_data_t *body)
{
    apr_bucket_brigade *bbody = NULL;
    apr_status_t rv;

    if (body && body->len > 0) {
        bbody = apr_brigade_create(req->pool, req->http->bucket_alloc);
        rv = apr_brigade_write(bbody, NULL, NULL, body->data, body->len);
        if (rv != APR_SUCCESS) {
            return rv;
        }
    }
    return req_set_body(req, content_type, bbody, body? (apr_off_t)body->len : 0, 0);
}

static apr_status_t req_create(md_http_request_t **preq, md_http_t *http,
                               const char *method, const char *url,
                               struct apr_table_t *headers)
{
    md_http_request_t *req;
    apr_pool_t *pool;
    apr_status_t rv;

    rv = apr_pool_create(&pool, http->pool);
    if (rv != APR_SUCCESS) {
        return rv;
    }
    apr_pool_tag(pool, "md_http_req");

    req = apr_pcalloc(pool, sizeof(*req));
    req->pool = pool;
    req->id = http->next_id++;
    req->bucket_alloc = http->bucket_alloc;
    req->http = http;
    req->method = method;
    req->url = url;
    req->headers = headers? apr_table_copy(req->pool, headers) : apr_table_make(req->pool, 5);
    req->resp_limit = http->resp_limit;
    req->user_agent = http->user_agent;
    req->proxy_url = http->proxy_url;
    req->timeout = http->timeout;
    req->ca_file = http->ca_file;
    req->unix_socket_path = http->unix_socket_path;
    *preq = req;
    return rv;
}

void md_http_req_destroy(md_http_request_t *req)
{
    if (req->internals) {
        req->http->impl->req_cleanup(req);
        req->internals = NULL;
    }
    apr_pool_destroy(req->pool);
}

void md_http_set_on_status_cb(md_http_request_t *req, md_http_status_cb *cb, void *baton)
{
    req->cb.on_status = cb;
    req->cb.on_status_data = baton;
}

void md_http_set_on_response_cb(md_http_request_t *req, md_http_response_cb *cb, void *baton)
{
    req->cb.on_response = cb;
    req->cb.on_response_data = baton;
}

apr_status_t md_http_perform(md_http_request_t *req)
{
    return req->http->impl->perform(req);
}

typedef struct {
    md_http_next_req *nextreq;
    void *baton;
} nextreq_proxy_t;

static apr_status_t proxy_nextreq(md_http_request_t **preq, void *baton,
                                      md_http_t *http, int in_flight)
{
    nextreq_proxy_t *proxy = baton;

    return proxy->nextreq(preq, proxy->baton, http, in_flight);
}

apr_status_t md_http_multi_perform(md_http_t *http, md_http_next_req *nextreq, void *baton)
{
    nextreq_proxy_t proxy;

    proxy.nextreq = nextreq;
    proxy.baton = baton;
    return http->impl->multi_perform(http, http->pool, proxy_nextreq, &proxy);
}

apr_status_t md_http_GET_create(md_http_request_t **preq, md_http_t *http, const char *url,
                                struct apr_table_t *headers)
{
    md_http_request_t *req;
    apr_status_t rv;

    rv = req_create(&req, http, "GET", url, headers);
    *preq = (APR_SUCCESS == rv)? req : NULL;
    return rv;
}

apr_status_t md_http_HEAD_create(md_http_request_t **preq, md_http_t *http, const char *url,
                                 struct apr_table_t *headers)
{
    md_http_request_t *req;
    apr_status_t rv;

    rv = req_create(&req, http, "HEAD", url, headers);
    *preq = (APR_SUCCESS == rv)? req : NULL;
    return rv;
}

apr_status_t md_http_POST_create(md_http_request_t **preq, md_http_t *http, const char *url,
                                 struct apr_table_t *headers, const char *content_type,
                                 struct apr_bucket_brigade *body, int detect_len)
{
    md_http_request_t *req;
    apr_status_t rv;

    rv = req_create(&req, http, "POST", url, headers);
    if (APR_SUCCESS == rv) {
        rv = req_set_body(req, content_type, body, -1, detect_len);
    }
    *preq = (APR_SUCCESS == rv)? req : NULL;
    return rv;
}

apr_status_t md_http_POSTd_create(md_http_request_t **preq, md_http_t *http, const char *url,
                                  struct apr_table_t *headers, const char *content_type,
                                  const struct md_data_t *body)
{
    md_http_request_t *req;
    apr_status_t rv;

    rv = req_create(&req, http, "POST", url, headers);
    if (APR_SUCCESS != rv) goto cleanup;
    rv = req_set_body_data(req, content_type, body);
cleanup:
    if (APR_SUCCESS == rv) {
        *preq = req;
    }
    else {
        *preq = NULL;
        if (req) md_http_req_destroy(req);
    }
    return rv;
}

apr_status_t md_http_GET_perform(struct md_http_t *http,
                                 const char *url, struct apr_table_t *headers,
                                 md_http_response_cb *cb, void *baton)
{
    md_http_request_t *req;
    apr_status_t rv;

    rv = md_http_GET_create(&req, http, url, headers);
    if (APR_SUCCESS == rv) md_http_set_on_response_cb(req, cb, baton);
    return (APR_SUCCESS == rv)? md_http_perform(req) : rv;
}

apr_status_t md_http_HEAD_perform(struct md_http_t *http,
                                  const char *url, struct apr_table_t *headers,
                                  md_http_response_cb *cb, void *baton)
{
    md_http_request_t *req;
    apr_status_t rv;

    rv = md_http_HEAD_create(&req, http, url, headers);
    if (APR_SUCCESS == rv) md_http_set_on_response_cb(req, cb, baton);
    return (APR_SUCCESS == rv)? md_http_perform(req) : rv;
}

apr_status_t md_http_POST_perform(struct md_http_t *http, const char *url,
                                  struct apr_table_t *headers, const char *content_type,
                                  apr_bucket_brigade *body, int detect_len,
                                  md_http_response_cb *cb, void *baton)
{
    md_http_request_t *req;
    apr_status_t rv;

    rv = md_http_POST_create(&req, http, url, headers, content_type, body, detect_len);
    if (APR_SUCCESS == rv) md_http_set_on_response_cb(req, cb, baton);
    return (APR_SUCCESS == rv)? md_http_perform(req) : rv;
}

apr_status_t md_http_POSTd_perform(md_http_t *http, const char *url,
                                   struct apr_table_t *headers, const char *content_type,
                                   const md_data_t *body,
                                   md_http_response_cb *cb, void *baton)
{
    md_http_request_t *req;
    apr_status_t rv;

    rv = md_http_POSTd_create(&req, http, url, headers, content_type, body);
    if (APR_SUCCESS == rv) md_http_set_on_response_cb(req, cb, baton);
    return (APR_SUCCESS == rv)? md_http_perform(req) : rv;
}

quality93%

¤ Dauer der Verarbeitung: 0.16 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.