Header Callback

Collaboration diagram for Header Callback:

Data Structures
struct	curl_header_data
	Context structure passed to ast_curl_header_default_cb. More...

Functions
size_t	curl_header_cb (char *data, size_t size, size_t nitems, void *client_data)
	A default implementation of a header callback. More...
void	curl_header_data_free (void *obj)

Detailed Description

If you need to access the headers returned on the response, you can define a callback that curl will call for every header it receives.

Your callback must follow the specification defined for CURLOPT_HEADERFUNCTION and implement the curl_write_callback prototype.

The following ast_curl_headers objects compose a default implementation that will accumulate the headers in an ast_variable list.

Function Documentation

curl_header_cb()

size_t curl_header_cb	(	char *	data,
		size_t	size,
		size_t	nitems,
		void *	client_data
	)

A default implementation of a header callback.

This is an implementation of #CURLOPT_HEADERFUNCTION that performs basic sanity checks and saves headers in the ast_curl_header_data.headers ast_variable list.

The curl prototype for this function is curl_write_callback

Warning

If you decide to write your own callback, curl doesn't guarantee a terminating NULL in data passed to the callbacks!

Parameters

data	Will contain a header line that may not be NULL terminated.
size	Always 1.
nitems	The number of bytes in data.
client_data	A pointer to whatever structure you passed to ast_curler in the curl_header_data parameter.

Returns

Number of bytes handled. Must be (size * nitems) or an error is signalled.

Definition at line 39 of file curl_utils.c.

{
    struct curl_header_data *cb_data = client_data;
    size_t realsize = size * nitems;
    size_t adjusted_size = realsize;
    char *debug_info = S_OR(cb_data->debug_info, "");
    char *start = data;
    char *colon = NULL;
    struct ast_variable *h;
    char *header;
    char *value;
    SCOPE_ENTER(5, "'%s': Header received with %zu bytes\n",
        debug_info, realsize);
 
    if (cb_data->max_header_len == 0) {
        cb_data->max_header_len = AST_CURL_DEFAULT_MAX_HEADER_LEN;
    }
 
    if (realsize > cb_data->max_header_len) {
        /*
         * Silently ignore any header over the length limit.
         */
        SCOPE_EXIT_RTN_VALUE(realsize, "oversize header: %zu > %zu\n",
            realsize, cb_data->max_header_len);
    }
 
    /* Per CURL: buffer may not be NULL terminated. */
 
    /* Skip blanks */
    while (*start && ((unsigned char) *start) < 33 && start < data + realsize) {
        start++;
        adjusted_size--;
    }
 
    if (adjusted_size < strlen("HTTP/") + 1) {
        /* this is probably the \r\n\r\n sequence that ends the headers */
        cb_data->_capture = 0;
        SCOPE_EXIT_RTN_VALUE(realsize, "undersized header.  probably end-of-headers marker: %zu\n",
            adjusted_size);
    }
 
    /*
     * We only want headers from a 2XX response
     * so don't start capturing until we see
     * the 2XX.
     */
    if (ast_begins_with(start, "HTTP/")) {
        int code;
        /*
         * HTTP/1.1 200 OK
         * We want there to be a version after the HTTP/
         * and reason text after the code but we don't care
         * what they are.
         */
        int rc = sscanf(start, "HTTP/%*s %d %*s", &code);
        if (rc == 1) {
            if (code / 100 == 2) {
                cb_data->_capture = 1;
            }
        }
        SCOPE_EXIT_RTN_VALUE(realsize, "HTTP response code: %d\n",
            code);
    }
 
    if (!cb_data->_capture) {
        SCOPE_EXIT_RTN_VALUE(realsize, "not capturing\n");
    }
 
    header = ast_alloca(adjusted_size + 1);
    ast_copy_string(header, start, adjusted_size + 1);
 
    /* We have a NULL terminated string now */
 
    colon = strchr(header, ':');
    if (!colon) {
        SCOPE_EXIT_RTN_VALUE(realsize, "No colon in the header.  Weird\n");
    }
 
    *colon++ = '\0';
    value = colon;
    value = ast_skip_blanks(ast_trim_blanks(value));
 
    h = ast_variable_new(header, value, __FILE__);
    if (!h) {
        SCOPE_EXIT_LOG_RTN_VALUE(CURL_WRITEFUNC_ERROR, LOG_WARNING,
            "'%s': Unable to allocate memory for header '%s'\n",
            debug_info, header);
    }
    ast_variable_list_append(&cb_data->headers, h);
 
    SCOPE_EXIT_RTN_VALUE(realsize, "header: <%s>  value: <%s>",
        header, value);
}

References curl_header_data::_capture, ast_alloca, ast_begins_with(), ast_copy_string(), AST_CURL_DEFAULT_MAX_HEADER_LEN, ast_skip_blanks(), ast_trim_blanks(), ast_variable_list_append, ast_variable_new, CURL_WRITEFUNC_ERROR, curl_header_data::debug_info, curl_header_data::headers, LOG_WARNING, curl_header_data::max_header_len, NULL, S_OR, SCOPE_ENTER, SCOPE_EXIT_LOG_RTN_VALUE, SCOPE_EXIT_RTN_VALUE, and value.

Referenced by curler().

curl_header_data_free()

void curl_header_data_free

(

void *

obj

)

Definition at line 26 of file curl_utils.c.

{
    struct curl_header_data *cb_data = obj;
    if (!cb_data) {
        return;
    }
    ast_variables_destroy(cb_data->headers);
    if (cb_data->debug_info) {
        ast_free(cb_data->debug_info);
    }
    ast_free(cb_data);
}

References ast_free, ast_variables_destroy(), curl_header_data::debug_info, and curl_header_data::headers.

Referenced by retrieve_cert_from_url().