http.h File Reference

#include "gwlib/list.h"
#include "gwlib/octstr.h"

Go to the source code of this file.

Data Structures
struct	HTTPCGIVar
struct	HTTPURLParse

Macros
#define	http_receive_result(caller, status, final_url, headers, body)   http_receive_result_real(caller, status, final_url, headers, body, 1)
#define	http_header_find_first(headers, name)   gw_claim_area(http_header_find_first_real((headers), (name), __FILE__, __LINE__, __func__))

Typedefs
typedef List	HTTPCaller
typedef struct HTTPClient	HTTPClient

Enumerations
enum	{   HTTP_CONTINUE = 100, HTTP_SWITCHING_PROTOCOLS = 101, HTTP_OK = 200, HTTP_CREATED = 201,   HTTP_ACCEPTED = 202, HTTP_NON_AUTHORATIVE_INFORMATION = 203, HTTP_NO_CONTENT = 204, HTTP_RESET_CONTENT = 205,   HTTP_PARTIAL_CONTENT = 206, HTTP_MULTIPLE_CHOICES = 300, HTTP_MOVED_PERMANENTLY = 301, HTTP_FOUND = 302,   HTTP_SEE_OTHER = 303, HTTP_NOT_MODIFIED = 304, HTTP_USE_PROXY = 305, HTTP_TEMPORARY_REDIRECT = 307,   HTTP_BAD_REQUEST = 400, HTTP_UNAUTHORIZED = 401, HTTP_PAYMENT_REQUIRED = 402, HTTP_FORBIDDEN = 403,   HTTP_NOT_FOUND = 404, HTTP_BAD_METHOD = 405, HTTP_NOT_ACCEPTABLE = 406, HTTP_PROXY_AUTHENTICATION_REQUIRED = 407,   HTTP_REQUEST_TIMEOUT = 408, HTTP_CONFLICT = 409, HTTP_GONE = 410, HTTP_LENGTH_REQUIRED = 411,   HTTP_PRECONDITION_FAILED = 412, HTTP_REQUEST_ENTITY_TOO_LARGE = 413, HTTP_REQUEST_URI_TOO_LARGE = 414, HTTP_UNSUPPORTED_MEDIA_TYPE = 415,   HTTP_REQUESTED_RANGE_NOT_SATISFIABLE = 416, HTTP_EXPECTATION_FAILED = 417, HTTP_INTERNAL_SERVER_ERROR = 500, HTTP_NOT_IMPLEMENTED = 501,   HTTP_BAD_GATEWAY = 502, HTTP_SERVICE_UNAVAILABLE = 503, HTTP_GATEWAY_TIMEOUT = 504, HTTP_HTTP_VERSION_NOT_SUPPORTED = 505 }
enum	{   HTTP_STATUS_PROVISIONAL = 100, HTTP_STATUS_SUCCESSFUL = 200, HTTP_STATUS_REDIRECTION = 300, HTTP_STATUS_CLIENT_ERROR = 400,   HTTP_STATUS_SERVER_ERROR = 500, HTTP_STATUS_UNKNOWN = 0 }
enum	{   HTTP_METHOD_GET = 1, HTTP_METHOD_POST = 2, HTTP_METHOD_HEAD = 3, HTTP_METHOD_PUT = 4,   HTTP_METHOD_DELETE = 5, HTTP_METHOD_PATCH = 6 }

Functions
void	http_init (void)
void	http_shutdown (void)
HTTPURLParse *	http_urlparse_create (void)
void	http_urlparse_destroy (HTTPURLParse *p)
HTTPURLParse *	parse_url (Octstr *url)
void	parse_dump (HTTPURLParse *p)
void	parse_cgivars (List *cgivars, Octstr *pairs)
void	http_use_proxy (Octstr *hostname, int port, int ssl, List *exceptions, Octstr *username, Octstr *password, Octstr *exceptions_regex)
void	http_close_proxy (void)
void	http_set_interface (const Octstr *our_host)
void	http_set_client_timeout (long timeout)
int	http_get_real (int method, Octstr *url, List *request_headers, Octstr **final_url, List **reply_headers, Octstr **reply_body)
HTTPCaller *	http_caller_create (void)
void	http_caller_destroy (HTTPCaller *caller)
void	http_caller_signal_shutdown (HTTPCaller *caller)
void	http_start_request (HTTPCaller *caller, int method, Octstr *url, List *headers, Octstr *body, int follow, void *id, Octstr *certkeyfile)
void *	http_receive_result_real (HTTPCaller *caller, int *status, Octstr **final_url, List **headers, Octstr **body, int blocking)
void	http_set_server_timeout (int port, long timeout)
int	http_open_port (int port, int ssl)
int	http_open_port_if (int port, int ssl, Octstr *interface)
HTTPClient *	http_accept_request (int port, Octstr **client_ip, Octstr **url, List **headers, Octstr **body, List **cgivars)
void	http_send_reply (HTTPClient *client, int status, List *headers, Octstr *body)
void	http_close_client (HTTPClient *client)
void	http_close_port (int port)
void	http_close_all_ports (void)
void	http_destroy_cgiargs (List *args)
Octstr *	http_cgi_variable (List *list, char *name)
int	http_method (HTTPClient *client)
Octstr *	http_request_url (HTTPClient *client)
List *	http_create_empty_headers (void)
void	http_destroy_headers (List *headers)
void	http_header_add (List *headers, char *name, char *contents)
void	http_header_get (List *headers, long i, Octstr **name, Octstr **value)
List *	http_header_duplicate (List *headers)
void	http_header_pack (List *headers)
void	http_append_headers (List *to, List *from)
Octstr *	http_header_value (List *headers, Octstr *header)
void	http_header_combine (List *old_headers, List *new_headers)
long	http_header_quoted_string_len (Octstr *header, long pos)
List *	http_header_split_value (Octstr *value)
List *	http_header_split_auth_value (Octstr *value)
long	http_header_remove_all (List *headers, char *name)
void	http_remove_hop_headers (List *headers)
void	http_header_mark_transformation (List *headers, Octstr *new_body, Octstr *new_type)
Octstr *	http_header_find_first_real (List *headers, char *name, const char *file, long line, const char *func)
List *	http_header_find_all (List *headers, char *name)
void	http_header_get_content_type (List *headers, Octstr **type, Octstr **charset)
int	http_type_accepted (List *headers, char *type)
void	http_header_dump (List *headers)
void	http_cgivar_dump (List *cgiargs)
void	http_cgivar_dump_into (List *cgiargs, Octstr *os)
int	http_charset_accepted (List *headers, char *charset)
void	http_add_basic_auth (List *headers, Octstr *username, Octstr *password)
Octstr *	http_get_header_parameter (Octstr *value, Octstr *parameter)
int	http_status_class (int code)
int	http_name2method (Octstr *method)
char *	http_method2name (int method)

Macro Definition Documentation

http_header_find_first

#define http_header_find_first	(		headers,
			name
	)		gw_claim_area(http_header_find_first_real((headers), (name), __FILE__, __LINE__, __func__))

Definition at line 603 of file http.h.

Referenced by check_x_wap_application_id_header(), client_is_persistent(), deduce_body_state(), get_redirection_location(), handle_transaction(), headers_acceptable(), http_header_get_content_type(), response(), transform_message(), and wsp_pack_separate_content_type().

http_receive_result

#define http_receive_result	(		caller,
			status,
			final_url,
			headers,
			body
	)		http_receive_result_real(caller, status, final_url, headers, body, 1)

Definition at line 394 of file http.h.

Referenced by http_get_real(), httpsmsc_send_cb(), receive_push_reply(), receive_reply(), return_replies_thread(), soap_read_response(), and url_result_thread().

Typedef Documentation

HTTPCaller

typedef List HTTPCaller

Definition at line 338 of file http.h.

HTTPClient

typedef struct HTTPClient HTTPClient

Definition at line 406 of file http.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
HTTP_CONTINUE
HTTP_SWITCHING_PROTOCOLS
HTTP_OK
HTTP_CREATED
HTTP_ACCEPTED
HTTP_NON_AUTHORATIVE_INFORMATION
HTTP_NO_CONTENT
HTTP_RESET_CONTENT
HTTP_PARTIAL_CONTENT
HTTP_MULTIPLE_CHOICES
HTTP_MOVED_PERMANENTLY
HTTP_FOUND
HTTP_SEE_OTHER
HTTP_NOT_MODIFIED
HTTP_USE_PROXY
HTTP_TEMPORARY_REDIRECT
HTTP_BAD_REQUEST
HTTP_UNAUTHORIZED
HTTP_PAYMENT_REQUIRED
HTTP_FORBIDDEN
HTTP_NOT_FOUND
HTTP_BAD_METHOD
HTTP_NOT_ACCEPTABLE
HTTP_PROXY_AUTHENTICATION_REQUIRED
HTTP_REQUEST_TIMEOUT
HTTP_CONFLICT
HTTP_GONE
HTTP_LENGTH_REQUIRED
HTTP_PRECONDITION_FAILED
HTTP_REQUEST_ENTITY_TOO_LARGE
HTTP_REQUEST_URI_TOO_LARGE
HTTP_UNSUPPORTED_MEDIA_TYPE
HTTP_REQUESTED_RANGE_NOT_SATISFIABLE
HTTP_EXPECTATION_FAILED
HTTP_INTERNAL_SERVER_ERROR
HTTP_NOT_IMPLEMENTED
HTTP_BAD_GATEWAY
HTTP_SERVICE_UNAVAILABLE
HTTP_GATEWAY_TIMEOUT
HTTP_HTTP_VERSION_NOT_SUPPORTED

Definition at line 139 of file http.h.

     {
    HTTP_CONTINUE                           = 100,
    HTTP_SWITCHING_PROTOCOLS                = 101,
    HTTP_OK                                 = 200,
    HTTP_CREATED                            = 201,
    HTTP_ACCEPTED                           = 202,
    HTTP_NON_AUTHORATIVE_INFORMATION        = 203,
    HTTP_NO_CONTENT                         = 204,
    HTTP_RESET_CONTENT                      = 205,
    HTTP_PARTIAL_CONTENT                    = 206,
    HTTP_MULTIPLE_CHOICES                   = 300,
    HTTP_MOVED_PERMANENTLY                  = 301,
    HTTP_FOUND                              = 302,
    HTTP_SEE_OTHER                          = 303,
    HTTP_NOT_MODIFIED                       = 304,
    HTTP_USE_PROXY                          = 305,
    /* HTTP 306 is not used and reserved */
    HTTP_TEMPORARY_REDIRECT                 = 307,
    HTTP_BAD_REQUEST                        = 400,
    HTTP_UNAUTHORIZED                       = 401,
    HTTP_PAYMENT_REQUIRED                   = 402,
    HTTP_FORBIDDEN                          = 403,
    HTTP_NOT_FOUND                          = 404,
    HTTP_BAD_METHOD                         = 405,
    HTTP_NOT_ACCEPTABLE                     = 406,
    HTTP_PROXY_AUTHENTICATION_REQUIRED      = 407,
    HTTP_REQUEST_TIMEOUT                    = 408,
    HTTP_CONFLICT                           = 409,
    HTTP_GONE                               = 410,
    HTTP_LENGTH_REQUIRED                    = 411,
    HTTP_PRECONDITION_FAILED                = 412,
    HTTP_REQUEST_ENTITY_TOO_LARGE           = 413,
    HTTP_REQUEST_URI_TOO_LARGE              = 414,
    HTTP_UNSUPPORTED_MEDIA_TYPE             = 415,
    HTTP_REQUESTED_RANGE_NOT_SATISFIABLE    = 416,
    HTTP_EXPECTATION_FAILED                 = 417,
    HTTP_INTERNAL_SERVER_ERROR              = 500,
    HTTP_NOT_IMPLEMENTED                    = 501,
    HTTP_BAD_GATEWAY                        = 502,
    HTTP_SERVICE_UNAVAILABLE                = 503,
    HTTP_GATEWAY_TIMEOUT                    = 504,
    HTTP_HTTP_VERSION_NOT_SUPPORTED         = 505
};

anonymous enum

anonymous enum

Enumerator
HTTP_STATUS_PROVISIONAL
HTTP_STATUS_SUCCESSFUL
HTTP_STATUS_REDIRECTION
HTTP_STATUS_CLIENT_ERROR
HTTP_STATUS_SERVER_ERROR
HTTP_STATUS_UNKNOWN

Definition at line 188 of file http.h.

     {
    HTTP_STATUS_PROVISIONAL = 100,
    HTTP_STATUS_SUCCESSFUL = 200,
    HTTP_STATUS_REDIRECTION = 300,
    HTTP_STATUS_CLIENT_ERROR = 400,
    HTTP_STATUS_SERVER_ERROR = 500,
    HTTP_STATUS_UNKNOWN = 0
};

anonymous enum

anonymous enum

Enumerator
HTTP_METHOD_GET
HTTP_METHOD_POST
HTTP_METHOD_HEAD
HTTP_METHOD_PUT
HTTP_METHOD_DELETE
HTTP_METHOD_PATCH

Definition at line 202 of file http.h.

     {
    HTTP_METHOD_GET  = 1,
    HTTP_METHOD_POST = 2,
    HTTP_METHOD_HEAD = 3,
    HTTP_METHOD_PUT  = 4,
    HTTP_METHOD_DELETE = 5,
    HTTP_METHOD_PATCH  = 6,
};

Function Documentation

http_accept_request()

HTTPClient* http_accept_request	(	int	port,
		Octstr **	client_ip,
		Octstr **	url,
		List **	headers,
		Octstr **	body,
		List **	cgivars
	)

Definition at line 2571 of file http.c.

References charset, client(), client_destroy(), client_is_persistent(), conn_eof(), conn_error(), conn_wait(), content_type, debug(), entity_destroy(), gwlist_create, http_header_get_content_type(), http_method2name(), HTTP_METHOD_POST, HTTP_METHOD_PUT, octstr_copy, octstr_destroy(), octstr_duplicate, octstr_get_cstr, octstr_len(), octstr_search_char(), octstr_str_compare(), octstr_truncate(), parse_cgivars(), port_get_request(), and url.

Referenced by client_thread(), http_read_thread(), http_thread(), httpadmin_run(), httpd_emu(), httpsmsc_receiver(), sendsms_thread(), and soap_server().

{
    HTTPClient *client;
    Octstr *query, *content_type, *charset;
    int question_mark;

    do {
        client = port_get_request(port);
        if (client == NULL) {
            debug("gwlib.http", 0, "HTTP: No clients with requests, quitting.");
            return NULL;
        }
        /* check whether client connection still ok */
        conn_wait(client->conn, 0);
        if (conn_error(client->conn) || conn_eof(client->conn)) {
            client_destroy(client);
            client = NULL;
        }
    } while(client == NULL);

    debug("gwlib.http", 0, "HTTP: Got %s request with url='%s' and body='%s'",
          http_method2name(client->method), octstr_get_cstr(client->url), octstr_get_cstr(client->request->body));

    *client_ip = octstr_duplicate(client->ip);
    *url = client->url;
    *headers = client->request->headers;
    *body = client->request->body;
    *cgivars = gwlist_create();

    /* is there a query string in the url? */
    question_mark = octstr_search_char(*url, '?', 0);
    if (question_mark >= 0) {
        /* parse the query string */
        query = octstr_copy(*url, question_mark + 1, octstr_len(*url));
        parse_cgivars(*cgivars, query);
        octstr_destroy(query);

        /* remove query string from url */
        octstr_truncate(*url, question_mark);
    }

    if (client->method == HTTP_METHOD_POST || client->method == HTTP_METHOD_PUT) {
        if (octstr_len(*body) > 0) {
            http_header_get_content_type(*headers, &content_type, &charset);
            if (octstr_str_compare(content_type, "application/x-www-form-urlencoded") == 0) {
                /* parse the body */
                parse_cgivars(*cgivars, *body);
            }
            octstr_destroy(content_type);
            octstr_destroy(charset);
        }
    } else {
        octstr_destroy(*body);
        *body = NULL;
    }

    client->persistent_conn = client_is_persistent(client->request->headers,
                                                   client->use_version_1_0);

    client->url = NULL;
    client->request->headers = NULL;
    client->request->body = NULL;
    entity_destroy(client->request);
    client->request = NULL;

    return client;
}

http_add_basic_auth()

void http_add_basic_auth	(	List *	headers,
		Octstr *	username,
		Octstr *	password
	)

Definition at line 3515 of file http.c.

References http_header_add(), octstr_binary_to_base64(), octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_insert(), octstr_strip_blanks(), password, and username.

Referenced by client_thread(), push_headers_create(), receive_push_reply(), and send_request().

{
    Octstr *os;
    
    if (password != NULL)
      os = octstr_format("%S:%S", username, password);
    else
      os = octstr_format("%S", username);
    octstr_binary_to_base64(os);
    octstr_strip_blanks(os);
    octstr_insert(os, octstr_imm("Basic "), 0);
    http_header_add(headers, "Authorization", octstr_get_cstr(os));
    octstr_destroy(os);
}

http_append_headers()

void http_append_headers	(	List *	to,
		List *	from
	)

Definition at line 3052 of file http.c.

References from, gw_assert(), gwlib_assert_init(), gwlist_append(), gwlist_get(), gwlist_len(), and octstr_duplicate.

Referenced by http_header_combine(), and pap_request_thread().

{
    Octstr *header;
    long i;

    gwlib_assert_init();
    gw_assert(to != NULL);
    gw_assert(from != NULL);

    for (i = 0; i < gwlist_len(from); ++i) {
        header = gwlist_get(from, i);
        gwlist_append(to, octstr_duplicate(header));
    }
}

http_caller_create()

HTTPCaller* http_caller_create

(

void

)

Definition at line 897 of file http.c.

References caller, gwlist_add_producer(), and gwlist_create.

Referenced by http_get_real(), main(), smsc_http_create(), soap_create_client_data(), and wap_appl_init().

{
    HTTPCaller *caller;
    
    caller = gwlist_create();
    gwlist_add_producer(caller);
    return caller;
}

http_caller_destroy()

void http_caller_destroy

(

HTTPCaller *

caller

)

Definition at line 907 of file http.c.

References caller, gwlist_destroy(), and server_destroy().

Referenced by client_thread(), conndata_destroy(), http_get_real(), main(), push_thread(), soap_destroy_client_data(), and wap_appl_shutdown().

{
    gwlist_destroy(caller, server_destroy);
}

http_caller_signal_shutdown()

void http_caller_signal_shutdown

(

HTTPCaller *

caller

)

Definition at line 913 of file http.c.

References caller, and gwlist_remove_producer().

Referenced by httpsmsc_receiver(), httpsmsc_sender(), main(), soap_destroy_client_data(), and wap_appl_shutdown().

{
    gwlist_remove_producer(caller);
}

http_cgi_variable()

Octstr* http_cgi_variable	(	List *	list,
		char *	name
	)

Definition at line 2836 of file http.c.

References gw_assert(), gwlib_assert_init(), gwlist_get(), gwlist_len(), name, HTTPCGIVar::name, octstr_str_compare(), and HTTPCGIVar::value.

Referenced by brunet_receive_sms(), clickatell_receive_sms(), client_thread(), default_authorise_user(), generic_receive_sms(), httpd_add_smsc(), httpd_check_authorization(), httpd_emu(), httpd_loglevel(), httpd_remove_message(), httpd_remove_smsc(), httpd_restart_smsc(), httpd_stop_smsc(), kannel_receive_sms(), parse_cgivars_for_password(), parse_cgivars_for_username(), smsbox_req_sendota(), smsbox_req_sendsms(), and xidris_receive_sms().

{
    int i;
    HTTPCGIVar *v;

    gwlib_assert_init();
    gw_assert(list != NULL);
    gw_assert(name != NULL);

    for (i = 0; i < gwlist_len(list); ++i) {
        v = gwlist_get(list, i);
        if (octstr_str_compare(v->name, name) == 0)
            return v->value;
    }
    return NULL;
}

http_cgivar_dump()

void http_cgivar_dump

(

List *

cgiargs

)

Definition at line 3440 of file http.c.

References debug(), gwlib_assert_init(), gwlist_get(), gwlist_len(), HTTPCGIVar::name, octstr_dump, and HTTPCGIVar::value.

{
    HTTPCGIVar *v;
    long i, len;

    gwlib_assert_init();

    len = gwlist_len(cgiargs);

    debug("gwlib.http", 0, "Dumping %ld cgi variables:", len);
    for (i = 0; i < len; i++) {
        v = gwlist_get(cgiargs, i);
        octstr_dump(v->name, 0);
        octstr_dump(v->value, 0);
    }
    debug("gwlib.http", 0, "End of dump.");
}

http_cgivar_dump_into()

void http_cgivar_dump_into	(	List *	cgiargs,
		Octstr *	os
	)

Definition at line 3459 of file http.c.

References gwlib_assert_init(), gwlist_get(), gwlist_len(), HTTPCGIVar::name, octstr_format_append(), and HTTPCGIVar::value.

Referenced by httpsmsc_receiver().

{
    HTTPCGIVar *v;
    long i;

    if (os == NULL)
        return;

    gwlib_assert_init();

    for (i = 0; i < gwlist_len(cgiargs); i++) {
        v = gwlist_get(cgiargs, i);
        octstr_format_append(os, "&%E=%E", v->name, v->value);
    }
}

http_charset_accepted()

int http_charset_accepted	(	List *	headers,
		char *	charset
	)

Definition at line 3509 of file http.c.

References charset, and http_something_accepted().

Referenced by add_charset_headers(), and normalize_charset().

{
    return http_something_accepted(headers, "Accept-Charset", charset);
}

http_close_all_ports()

void http_close_all_ports

(

void

)

Definition at line 2526 of file http.c.

References gwthread_join_every(), gwthread_wakeup(), keep_servers_open, server_thread(), server_thread_id, and server_thread_is_running.

Referenced by client_thread(), httpadmin_stop(), httpd_emu_destroy(), main(), and wap_push_ppg_shutdown().

{
    if (server_thread_id != -1) {
        keep_servers_open = 0;
        gwthread_wakeup(server_thread_id);
        gwthread_join_every(server_thread);
        server_thread_is_running = 0;
    }
}

http_close_client()

void http_close_client

(

HTTPClient *

client

)

Definition at line 2758 of file http.c.

References client(), and client_destroy().

Referenced by httpadmin_run(), httpsmsc_receiver(), and pap_request_thread().

{
    client_destroy(client);
}

http_close_port()

void http_close_port

(

int

port

)

Definition at line 2515 of file http.c.

References closed_server_sockets, gwlist_produce(), gwthread_wakeup(), port, and server_thread_id.

Referenced by httpsmsc_receiver(), httpsmsc_shutdown(), soap_server_start(), and soap_server_stop().

{
    int *p;
    
    p = gw_malloc(sizeof(*p));
    *p = port;
    gwlist_produce(closed_server_sockets, p);
    gwthread_wakeup(server_thread_id);
}

http_close_proxy()

void http_close_proxy

(

void

)

Definition at line 304 of file http.c.

References gw_assert(), gwlist_destroy(), mutex_lock, mutex_unlock, octstr_destroy(), octstr_destroy_item(), proxy_exceptions, proxy_exceptions_regex, proxy_hostname, proxy_mutex, proxy_password, proxy_port, proxy_username, run_status, running, and terminating.

Referenced by http_use_proxy(), and proxy_shutdown().

{
    gw_assert(run_status == running || run_status == terminating);

    mutex_lock(proxy_mutex);
    proxy_port = 0;
    octstr_destroy(proxy_hostname);
    octstr_destroy(proxy_username);
    octstr_destroy(proxy_password);
    proxy_hostname = NULL;
    proxy_username = NULL;
    proxy_password = NULL;
    gwlist_destroy(proxy_exceptions, octstr_destroy_item);
    gw_regex_destroy(proxy_exceptions_regex);
    proxy_exceptions = NULL;
    proxy_exceptions_regex = NULL;
    mutex_unlock(proxy_mutex);
}

http_create_empty_headers()

List* http_create_empty_headers

(

void

)

Definition at line 2872 of file http.c.

References gwlib_assert_init(), and gwlist_create.

Referenced by brunet_send_sms(), challenge(), clickatell_send_sms(), entity_create(), http_header_duplicate(), httpd_emu_init(), indicate_push_connection(), indicate_push_resume(), kill_kannel(), main(), make_confirmedpush_pdu(), make_push_pdu(), make_reply_headers(), make_resume_reply_pdu(), mime_entity_create(), numhash_create(), obey_request(), pass_data_headers(), push_headers_create(), reply(), return_reply(), send_to_pi(), soap_send(), soap_server(), start_fetch(), test_header_combine(), unpack_new_headers(), and wsp_headers_unpack().

{
    gwlib_assert_init();
    return gwlist_create();
}

http_destroy_cgiargs()

void http_destroy_cgiargs

(

List *

args

)

Definition at line 2818 of file http.c.

References gwlib_assert_init(), gwlist_destroy(), gwlist_extract_first(), HTTPCGIVar::name, octstr_destroy(), and HTTPCGIVar::value.

Referenced by client_thread(), http_thread(), httpd_emu(), httpd_serve(), httpsmsc_receiver(), pap_request_thread(), and sendsms_thread().

{
    HTTPCGIVar *v;

    gwlib_assert_init();

    if (args == NULL)
        return ;

    while ((v = gwlist_extract_first(args)) != NULL) {
        octstr_destroy(v->name);
        octstr_destroy(v->value);
        gw_free(v);
    }
    gwlist_destroy(args, NULL);
}

http_destroy_headers()

void http_destroy_headers

(

List *

headers

)

Definition at line 2879 of file http.c.

References gwlib_assert_init(), gwlist_destroy(), and octstr_destroy_item().

Referenced by brunet_receive_sms(), brunet_send_sms(), challenge(), check_application_headers(), clickatell_receive_sms(), clickatell_send_sms(), client_thread(), content_transformable(), decode_bearer_indication(), entity_destroy(), generic_receive_sms(), generic_send_sms(), http_queue_thread(), http_something_accepted(), http_thread(), httpd_emu(), httpd_emu_shutdown(), httpd_serve(), httpsmsc_receiver(), httpsmsc_send_cb(), indicate_push_connection(), indicate_push_resume(), kannel_receive_sms(), kannel_send_sms(), kill_kannel(), main(), make_confirmedpush_pdu(), make_connectreply_pdu(), make_push_pdu(), make_resume_reply_pdu(), mime_entity_to_octstr(), mime_replace_headers(), mime_something_to_entity(), numhash_create(), obey_request(), pack_sia(), pap_request_thread(), receive_push_reply(), receive_reply(), reply(), return_replies_thread(), return_reply(), send_to_pi(), sendsms_thread(), server_destroy(), soap_read_response(), soap_send(), soap_server(), start_fetch(), start_push(), test_header_combine(), url_result_thread(), xidris_receive_sms(), and xidris_send_sms().

{
    gwlib_assert_init();
    gwlist_destroy(headers, octstr_destroy_item);
}

http_get_header_parameter()

Octstr* http_get_header_parameter	(	Octstr *	value,
		Octstr *	parameter
	)

Definition at line 3531 of file http.c.

References found, http_header_quoted_string_len(), octstr_case_compare(), octstr_copy, octstr_destroy(), octstr_duplicate, octstr_get_char(), octstr_len(), octstr_search_char(), and octstr_strip_blanks().

Referenced by fix_boundary_element(), get_start_param(), and mime_something_to_entity().

{
    long pos, len, end;
    int c, found = 0;
    Octstr *result = NULL;

    len = octstr_len(value);
    /* Find the start of the first parameter. */
    for (pos = 0; pos < len; pos++) {
        c = octstr_get_char(value, pos);
        if (c == ';')
            break;
        else if (c == '"')
            pos += http_header_quoted_string_len(value, pos) - 1;
    }

    if (pos >= len)
        return NULL;   /* no parameters */

    for (pos++; pos > 0 && pos < len && found == 0; pos++) {
        Octstr *key = NULL;
        Octstr *val = NULL;

        end = octstr_search_char(value, '=', pos);
        if (end < 0)
            end = octstr_search_char(value, ';', pos);
        if (end < 0)
            end = octstr_len(value);
        key = octstr_copy(value, pos, end - pos);
        octstr_strip_blanks(key);
        pos = end;

        if (octstr_get_char(value, pos) == '=') {
            pos++;
            while (isspace(octstr_get_char(value, pos)))
                pos++;
            if (octstr_get_char(value, pos) == '"')
                end = pos + http_header_quoted_string_len(value, pos);
            else
                end = octstr_search_char(value, ';', pos);
            if (end < 0)
                end = octstr_len(value);
            val = octstr_copy(value, pos, end - pos);
            octstr_strip_blanks(val);
            pos = end;
            pos = octstr_search_char(value, ';', pos);
        }

        /* is this the pair we look for? bail out then*/
        if (octstr_case_compare(key, parameter) == 0) {
            found++;        
            result = octstr_duplicate(val);
        }

        octstr_destroy(key);
        octstr_destroy(val);
    }

    return result;
}

http_get_real()

int http_get_real	(	int	method,
		Octstr *	url,
		List *	request_headers,
		Octstr **	final_url,
		List **	reply_headers,
		Octstr **	reply_body
	)

Definition at line 1821 of file http.c.

References caller, http_caller_create(), http_caller_destroy(), http_get_real(), http_receive_result, http_start_request(), method, and url.

Referenced by http_get_real(), kill_kannel(), and numhash_create().

{
    HTTPCaller *caller;
    int status;
    void *ret;
    
    caller = http_caller_create();
    http_start_request(caller, method, url, request_headers, 
                       NULL, 1, http_get_real, NULL);
    ret = http_receive_result(caller, &status, final_url, 
                              reply_headers, reply_body);
    http_caller_destroy(caller);
    if (ret == NULL)
        return -1;
    return status;
}

http_header_add()

void http_header_add	(	List *	headers,
		char *	name,
		char *	contents
	)

Definition at line 2886 of file http.c.

References gw_assert(), gwlib_assert_init(), gwlist_append(), name, and octstr_format().

Referenced by add_accept_headers(), add_charset_headers(), add_client_sdu_size(), add_connection_header(), add_dlr_mask(), add_dlr_url(), add_kannel_version(), add_msisdn(), add_network_info(), add_push_flag(), add_session_id(), add_via(), add_x_wap_tod(), brunet_receive_sms(), challenge(), change_header_value(), check_application_headers(), check_session_request_headers(), check_x_wap_application_id_header(), clickatell_receive_sms(), client_thread(), decode_bearer_indication(), fix_boundary_element(), generic_receive_sms(), generic_send_sms(), http_add_basic_auth(), http_header_mark_transformation(), httpd_emu_init(), httpd_serve(), kannel_receive_sms(), kill_kannel(), main(), make_reply_headers(), obey_request(), pack_into_push_datagram(), pack_into_result_datagram(), pass_extension_headers(), pass_optional_header(), proxy_add_authentication(), push_headers_create(), send_request(), send_to_pi(), soap_send(), soap_server(), start_fetch(), test_header_combine(), wsp_unpack_app_header(), wsp_unpack_well_known_field(), and xmlrpc_doc_send().

{
    gwlib_assert_init();
    gw_assert(headers != NULL);
    gw_assert(name != NULL);
    gw_assert(contents != NULL);

    gwlist_append(headers, octstr_format("%s: %s", name, contents));
}

http_header_combine()

void http_header_combine	(	List *	old_headers,
		List *	new_headers
	)

Definition at line 3068 of file http.c.

References gwlist_len(), http_append_headers(), http_header_get(), http_header_remove_all(), name, octstr_destroy(), and octstr_get_cstr.

Referenced by client_thread(), return_reply(), start_fetch(), start_request(), test_header_combine(), and unpack_new_headers().

{
    long i;
    Octstr *name;
    Octstr *value;

    /*
     * Avoid doing this scan if old_headers is empty anyway.
     */
    if (gwlist_len(old_headers) > 0) {
        for (i = 0; i < gwlist_len(new_headers); i++) {
        http_header_get(new_headers, i, &name, &value);
        http_header_remove_all(old_headers, octstr_get_cstr(name));
            octstr_destroy(name);
            octstr_destroy(value);
        }
    }

    http_append_headers(old_headers, new_headers);
}

http_header_dump()

void http_header_dump

(

List *

headers

)

Definition at line 3427 of file http.c.

References debug(), gwlib_assert_init(), gwlist_get(), gwlist_len(), and octstr_dump.

Referenced by check_application_headers(), client_thread(), decode_bearer_indication(), main(), and start_push().

{
    long i;

    gwlib_assert_init();

    debug("gwlib.http", 0, "Dumping HTTP headers:");
    for (i = 0; headers != NULL && i < gwlist_len(headers); ++i)
        octstr_dump(gwlist_get(headers, i), 1);
    debug("gwlib.http", 0, "End of dump.");
}

http_header_duplicate()

List* http_header_duplicate

(

List *

headers

)

Definition at line 2969 of file http.c.

References gwlib_assert_init(), gwlist_append(), gwlist_get(), gwlist_len(), http_create_empty_headers(), and octstr_duplicate.

Referenced by add_push_flag(), create_session(), indicate_confirmedpush(), indicate_push_connection(), indicate_push_resume(), indicate_resume(), make_session_request(), mime_entity_headers(), mime_entity_to_octstr(), mime_replace_headers(), mime_something_to_entity(), pap_request_thread(), push_machine_create(), remember_receiver(), request_confirmed_push(), request_push(), request_unit_push(), and server_create().

{
    List *new;
    long i, len;

    gwlib_assert_init();

    if (headers == NULL)
        return NULL;

    new = http_create_empty_headers();
    len = gwlist_len(headers);
    for (i = 0; i < len; ++i)
        gwlist_append(new, octstr_duplicate(gwlist_get(headers, i)));
    return new;
}

http_header_find_all()

List* http_header_find_all	(	List *	headers,
		char *	name
	)

Definition at line 3115 of file http.c.

References gw_assert(), gwlib_assert_init(), gwlist_append(), gwlist_create, gwlist_get(), gwlist_len(), header_is_called(), name, and octstr_duplicate.

Referenced by content_transformable(), http_remove_hop_headers(), http_something_accepted(), make_session_request(), and split_header_list().

{
    List *list;
    long i;
    Octstr *h;

    gwlib_assert_init();
    gw_assert(headers != NULL);
    gw_assert(name != NULL);

    list = gwlist_create();
    for (i = 0; i < gwlist_len(headers); ++i) {
        h = gwlist_get(headers, i);
        if (header_is_called(h, name))
            gwlist_append(list, octstr_duplicate(h));
    }
    return list;
}

http_header_find_first_real()

Octstr* http_header_find_first_real	(	List *	headers,
		char *	name,
		const char *	file,
		long	line,
		const char *	func
	)

Definition at line 3090 of file http.c.

References file, gw_assert(), gwlib_assert_init(), gwlist_get(), gwlist_len(), header_is_called(), name, name_len, octstr_copy_real(), octstr_len(), and octstr_strip_blanks().

{
    long i, name_len;
    Octstr *h, *value;

    gwlib_assert_init();
    gw_assert(headers != NULL);
    gw_assert(name != NULL);

    name_len = strlen(name);

    for (i = 0; i < gwlist_len(headers); ++i) {
        h = gwlist_get(headers, i);
        if (header_is_called(h, name)) {
            value = octstr_copy_real(h, name_len + 1, octstr_len(h),
                                     file, line, func);
        octstr_strip_blanks(value);
        return value;
    }
    }
    return NULL;
}

http_header_get()

void http_header_get	(	List *	headers,
		long	i,
		Octstr **	name,
		Octstr **	value
	)

Definition at line 2902 of file http.c.

References colon, error(), gw_assert(), gwlib_assert_init(), gwlist_get(), name, octstr_copy, octstr_create, octstr_duplicate, octstr_len(), octstr_search_char(), and octstr_strip_blanks().

Referenced by check_application_headers(), content_transformable(), decode_bearer_indication(), get_x_kannel_from_headers(), http_header_combine(), http_header_pack(), pack_appid_list(), smsbox_sendota_post(), and wsp_headers_pack().

{
    Octstr *os;
    long colon;

    gwlib_assert_init();
    gw_assert(i >= 0);
    gw_assert(name != NULL);
    gw_assert(value != NULL);

    os = gwlist_get(headers, i);
    if (os == NULL)
        colon = -1;
    else
        colon = octstr_search_char(os, ':', 0);
    if (colon == -1) {
        error(0, "HTTP: Header does not contain a colon. BAD.");
        *name = octstr_create("X-Unknown");
        *value = octstr_duplicate(os);
    } else {
        *name = octstr_copy(os, 0, colon);
        *value = octstr_copy(os, colon + 1, octstr_len(os) - colon - 1);
        octstr_strip_blanks(*value);
    }
}

http_header_get_content_type()

void http_header_get_content_type	(	List *	headers,
		Octstr **	type,
		Octstr **	charset
	)

Definition at line 3225 of file http.c.

References charset, gw_assert(), gwlib_assert_init(), http_header_find_first, octstr_append_cstr(), octstr_create, octstr_delete(), octstr_duplicate, octstr_get_char(), octstr_imm(), octstr_len(), octstr_ncompare(), octstr_search_char(), octstr_strip_blanks(), octstr_truncate(), and type.

Referenced by generic_receive_sms(), http_accept_request(), mime_entity_dump_real(), numhash_create(), receive_reply(), return_reply(), smsbox_sendota_post(), smsbox_sendsms_post(), smsbox_xmlrpc_post(), start_fetch(), transform_message(), and url_result_thread().

{
    Octstr *h;
    long semicolon, equals, len;

    gwlib_assert_init();
    gw_assert(headers != NULL);
    gw_assert(type != NULL);
    gw_assert(charset != NULL);

    h = http_header_find_first(headers, "Content-Type");
    if (h == NULL) {
        *type = octstr_create("application/octet-stream");
        *charset = octstr_create("");
    } else {
        octstr_strip_blanks(h);
        semicolon = octstr_search_char(h, ';', 0);
        if (semicolon == -1) {
            *type = h;
            *charset = octstr_create("");
        } else {
            *charset = octstr_duplicate(h);
            octstr_delete(*charset, 0, semicolon + 1);
            octstr_strip_blanks(*charset);
            equals = octstr_search_char(*charset, '=', 0);
            if (equals == -1)
                octstr_truncate(*charset, 0);
            else {
                octstr_delete(*charset, 0, equals + 1);
                if (octstr_get_char(*charset, 0) == '"')
                    octstr_delete(*charset, 0, 1);
                len = octstr_len(*charset);
                if (octstr_get_char(*charset, len - 1) == '"')
                    octstr_truncate(*charset, len - 1);
            }

            octstr_truncate(h, semicolon);
            octstr_strip_blanks(h);
            *type = h;
        }

        /* 
         * According to HTTP/1.1 (RFC 2616, section 3.7.1) we have to ensure
         * to return charset 'iso-8859-1' in case of no given encoding and
         * content-type is a 'text' subtype. 
         */
        if (octstr_len(*charset) == 0 && 
            octstr_ncompare(*type, octstr_imm("text"), 4) == 0)
            octstr_append_cstr(*charset, "ISO-8859-1");
    }
}

http_header_mark_transformation()

void http_header_mark_transformation	(	List *	headers,
		Octstr *	new_body,
		Octstr *	new_type
	)

Definition at line 3203 of file http.c.

References http_header_add(), http_header_remove_all(), octstr_destroy(), octstr_format(), octstr_get_cstr, and octstr_len().

Referenced by handle_push_message(), return_reply(), and start_fetch().

{
    Octstr *new_length = NULL;

    /* Remove all headers that no longer apply to the new body. */
    http_header_remove_all(headers, "Content-Length");
    http_header_remove_all(headers, "Content-MD5");
    http_header_remove_all(headers, "Content-Type");

    /* Add headers that we need to describe the new body. */
    new_length = octstr_format("%ld", octstr_len(new_body));
    http_header_add(headers, "Content-Length", octstr_get_cstr(new_length));
    if(octstr_len(new_type))
    http_header_add(headers, "Content-Type", octstr_get_cstr(new_type));

    /* Perhaps we should add Warning: 214 "Transformation applied" too? */

    octstr_destroy(new_length);
}

http_header_pack()

void http_header_pack

(

List *

headers

)

Definition at line 2992 of file http.c.

References gw_assert(), gwlib_assert_init(), gwlist_delete(), gwlist_get(), gwlist_insert(), gwlist_len(), http_header_get(), MAX_HEADER_LENGTH, name, octstr_append(), octstr_case_compare(), octstr_create, octstr_destroy(), octstr_imm(), and octstr_len().

Referenced by start_fetch().

{
    Octstr *name, *value;
    Octstr *name2, *value2;
    long i, j;

    gwlib_assert_init();
    gw_assert(headers != NULL);

    /*
     * For each header, search forward headers for similar ones and if possible, 
     * add it to current header and delete it
     */
    for(i = 0; i < gwlist_len(headers); i++) {
        http_header_get(headers, i, &name, &value);
    /* debug("http_header_pack", 0, "HTTP_HEADER_PACK: Processing header %d. [%s: %s]", 
           i, octstr_get_cstr(name), octstr_get_cstr(value)); */

        for(j=i+1; j < gwlist_len(headers); j++) {
            http_header_get(headers, j, &name2, &value2);

            if(octstr_case_compare(name, name2) == 0) {
                if(octstr_len(value) + 2 + octstr_len(value2) > MAX_HEADER_LENGTH) {
            octstr_destroy(name2);
            octstr_destroy(value2);
                    break;
                } else {
            Octstr *header;

            /* Delete old header */
            header = gwlist_get(headers, i);
            octstr_destroy(header);
                    gwlist_delete(headers, i, 1);

            /* Adds comma and new value to old header value */
                    octstr_append(value, octstr_imm(", "));
                    octstr_append(value, value2);
            /* Creates a new header */
            header = octstr_create("");
                    octstr_append(header, name);
                    octstr_append(header, octstr_imm(": "));
                    octstr_append(header, value);
                    gwlist_insert(headers, i, header);

            /* Delete this header */
            header = gwlist_get(headers, j);
            octstr_destroy(header);
                    gwlist_delete(headers, j, 1);
                    j--;
                }
            }
        octstr_destroy(name2);
        octstr_destroy(value2);
        }
    octstr_destroy(name);
    octstr_destroy(value);
    }
}

http_header_quoted_string_len()

long http_header_quoted_string_len	(	Octstr *	header,
		long	pos
	)

Definition at line 3293 of file http.c.

References octstr_get_char(), octstr_get_cstr, octstr_len(), start, and warning().

Referenced by http_get_header_parameter(), http_header_split_value(), pack_warning(), and wsp_strip_parameters().

{
    long len;
    long pos;
    int c;

    if (octstr_get_char(header, start) != '"')
    return -1;

    len = octstr_len(header);
    for (pos = start + 1; pos < len; pos++) {
    c = octstr_get_char(header, pos);
    if (c == '\\')    /* quoted-pair */
        pos++;
    else if (c == '"')
        return pos - start + 1;
    }

    warning(0, "Header contains unterminated quoted-string:");
    warning(0, "%s", octstr_get_cstr(header));
    return len - start;
}

http_header_remove_all()

long http_header_remove_all	(	List *	headers,
		char *	name
	)

Definition at line 3135 of file http.c.

References gw_assert(), gwlib_assert_init(), gwlist_delete(), gwlist_get(), gwlist_len(), header_is_called(), name, and octstr_destroy().

Referenced by add_msisdn(), change_header_value(), check_x_wap_application_id_header(), fix_boundary_element(), handle_push_message(), http_header_combine(), http_header_mark_transformation(), http_remove_hop_headers(), pap_request_thread(), remove_link_headers(), remove_mime_headers(), remove_x_kannel_headers(), response(), return_reply(), send_request(), set_addr_tuple(), split_header_list(), start_fetch(), and xmlrpc_doc_send().

{
    long i;
    Octstr *h;
    long count;

    gwlib_assert_init();
    gw_assert(headers != NULL);
    gw_assert(name != NULL);

    i = 0;
    count = 0;
    while (i < gwlist_len(headers)) {
    h = gwlist_get(headers, i);
    if (header_is_called(h, name)) {
        gwlist_delete(headers, i, 1);
        octstr_destroy(h);
        count++;
    } else
        i++;
    }

    return count;
}

http_header_split_auth_value()

List* http_header_split_auth_value

(

Octstr *

value

)

Definition at line 3351 of file http.c.

References gwlist_delete(), gwlist_get(), gwlist_len(), http_header_split_value(), octstr_append(), octstr_append_char(), octstr_destroy(), octstr_get_char(), octstr_insert_data(), and octstr_len().

Referenced by pack_known_header().

{
    List *result;
    Octstr *auth_scheme;
    Octstr *element;
    long i;

    /*
     * According to RFC2617, both "challenge" and "credentials"
     * consist of an auth-scheme followed by a list of auth-param.
     * Since we have to parse a list of challenges or credentials,
     * we have to look for auth-scheme to signal the start of
     * a new element.  (We can't just split on commas because
     * they are also used to separate the auth-params.)
     *
     * An auth-scheme is a single token, while an auth-param is
     * always a key=value pair.  So we can recognize an auth-scheme
     * as a token that is not followed by a '=' sign.
     *
     * Simple approach: First split at all commas, then recombine
     * the elements that belong to the same challenge or credential.
     * This is somewhat expensive but saves programmer thinking time.
     *
     * Richard Braakman
     */
 
    result = http_header_split_value(value);
    if (gwlist_len(result) == 0)
        return result;

    auth_scheme = gwlist_get(result, 0);
    i = 1;
    while (i < gwlist_len(result)) {
        int c;
        long pos;

        element = gwlist_get(result, i);

        /*
         * If the element starts with: token '='
         * then it's just an auth_param; append it to the current
         * auth_scheme.  If it starts with: token token '='
         * then it's the start of a new auth scheme.
         *
         * To make the scan easier, we consider anything other
         * than whitespace or '=' to be part of a token.
         */

        /* Skip first token */
        for (pos = 0; pos < octstr_len(element); pos++) {
            c = octstr_get_char(element, pos);
            if (isspace(c) || c == '=')
                break;
        }

        /* Skip whitespace, if any */
        while (isspace(octstr_get_char(element, pos)))
            pos++;

        if (octstr_get_char(element, pos) == '=') {
            octstr_append_char(auth_scheme, ';');
            octstr_append(auth_scheme, element);
            gwlist_delete(result, i, 1);
            octstr_destroy(element);
        } else {
            char semicolon = ';';
            octstr_insert_data(element, pos, &semicolon, 1);
            auth_scheme = element;
            i++;
        }
    }

    return result;
}

http_header_split_value()

List* http_header_split_value

(

Octstr *

value

)

Definition at line 3317 of file http.c.

References gwlist_create, http_header_add_element(), http_header_quoted_string_len(), octstr_get_char(), octstr_len(), and start.

Referenced by http_header_split_auth_value(), http_remove_hop_headers(), pack_cache_control(), and pack_known_header().

{
    long start;  /* start of current element */
    long pos;
    long len;
    List *result;
    int c;

    /*
     * According to RFC2616 section 4.2, a field-value is either *TEXT
     * (the caller is responsible for not feeding us one of those) or
     * combinations of token, separators, and quoted-string.  We're
     * looking for commas which are separators, and have to skip
     * commas in quoted-strings.
     */
 
    result = gwlist_create();
    len = octstr_len(value);
    start = 0;
    for (pos = 0; pos < len; pos++) {
    c = octstr_get_char(value, pos);
    if (c == ',') {
        http_header_add_element(result, value, start, pos);
        start = pos + 1;
    } else if (c == '"') {
            pos += http_header_quoted_string_len(value, pos);
        pos--; /* compensate for the loop's pos++ */
        }
    }
    http_header_add_element(result, value, start, len);
    return result;
}

http_header_value()

Octstr* http_header_value	(	List *	headers,
		Octstr *	header
	)

Definition at line 2932 of file http.c.

References colon, gw_assert(), gwlib_assert_init(), gwlist_get(), gwlist_len(), name, octstr_case_compare(), octstr_copy, octstr_destroy(), octstr_len(), octstr_search_char(), and octstr_strip_blanks().

Referenced by add_msisdn(), add_via(), cid_matches(), client_thread(), fix_boundary_element(), mime_entity_dump_real(), mime_multipart_start_elem(), mime_something_to_entity(), return_reply(), set_addr_tuple(), set_dlr_mask(), set_dlr_url(), set_smsbox_id(), and set_smsc_id().

{
    Octstr *value;
    long i;
    Octstr *os;
    long colon;
    Octstr *current_name;
    
    gwlib_assert_init();
    gw_assert(name);
    
    value = NULL;
    i = 0;
    while (i < gwlist_len(headers)) {
        os = gwlist_get(headers, i);
        if (os == NULL)
            colon = -1;
        else
            colon = octstr_search_char(os, ':', 0);
        if (colon == -1) {
            return NULL;      
        } else {
            current_name = octstr_copy(os, 0, colon);
        }
        if (octstr_case_compare(current_name, name) == 0) {
            value = octstr_copy(os, colon + 1, octstr_len(os) - colon - 1);
            octstr_strip_blanks(value);
            octstr_destroy(current_name);
            return value;
        }
        octstr_destroy(current_name);
        ++i;
    }
    
    return NULL;
}

http_init()

void http_init

(

void

)

Definition at line 3598 of file http.c.

References client_init(), conn_pool_init(), gw_assert(), limbo, port_init(), proxy_init(), run_status, running, and server_init().

Referenced by gwlib_init().

{
    gw_assert(run_status == limbo);

#ifdef HAVE_LIBSSL
    conn_init_ssl();
#endif /* HAVE_LIBSSL */
    proxy_init();
    client_init();
    conn_pool_init();
    port_init();
    server_init();
#ifdef HAVE_LIBSSL
    server_ssl_init();
#endif /* HAVE_LIBSSL */
    
    run_status = running;
}

http_method()

int http_method

(

HTTPClient *

client

)

Definition at line 2763 of file http.c.

References client().

{
    return client->method;
}

http_method2name()

char* http_method2name

(

int

method

)

Definition at line 3681 of file http.c.

References gw_assert(), HTTP_METHOD_GET, HTTP_METHOD_PATCH, http_methods, and method.

Referenced by http_accept_request(), and send_request().

{
    gw_assert(method >= HTTP_METHOD_GET && method <= HTTP_METHOD_PATCH);

    return http_methods[method-1];
}

http_name2method()

int http_name2method

(

Octstr *

method

)

Definition at line 3654 of file http.c.

References gw_assert(), HTTP_METHOD_DELETE, HTTP_METHOD_GET, HTTP_METHOD_HEAD, HTTP_METHOD_PATCH, HTTP_METHOD_POST, HTTP_METHOD_PUT, method, and octstr_str_compare().

Referenced by main(), parse_request_line(), and start_fetch().

{
    gw_assert(method != NULL);

    if (octstr_str_compare(method, "GET") == 0) {
        return HTTP_METHOD_GET;
    } 
    else if (octstr_str_compare(method, "POST") == 0) {
        return HTTP_METHOD_POST;
    } 
    else if (octstr_str_compare(method, "HEAD") == 0) {
        return HTTP_METHOD_HEAD;
    } 
    else if (octstr_str_compare(method, "PUT") == 0) {
        return HTTP_METHOD_PUT;
    }
    else if (octstr_str_compare(method, "DELETE") == 0) {
        return HTTP_METHOD_DELETE;
    }
    else if (octstr_str_compare(method, "PATCH") == 0) {
        return HTTP_METHOD_PATCH;
    }

    return -1;
}

http_open_port()

int http_open_port	(	int	port,
		int	ssl
	)

Definition at line 2509 of file http.c.

References http_open_port_if(), and ssl.

Referenced by httpd_emu_create(), main(), smsc_http_create(), soap_server_start(), start_http_thread(), and wap_push_ppg_init().

{
    return http_open_port_if(port, ssl, NULL);
}

http_open_port_if()

int http_open_port_if	(	int	port,
		int	ssl,
		Octstr *	interface
	)

Definition at line 2483 of file http.c.

References port::fd, gwlist_produce(), gwthread_wakeup(), info(), keep_servers_open, make_server_socket(), new_server_sockets, octstr_get_cstr, port, port::port, port_add(), port_remove(), server_thread_id, ssl, port::ssl, and start_server_thread().

Referenced by http_open_port(), httpadmin_start(), and init_smsbox().

{
    struct port *p;

    if (ssl) 
        info(0, "HTTP: Opening SSL server at port %d.", port);
    else 
        info(0, "HTTP: Opening server at port %d.", port);
    p = port_add(port);
    p->port = port;
    p->ssl = ssl;
    p->fd = make_server_socket(port, (interface ? octstr_get_cstr(interface) : NULL));
    if (p->fd == -1) {
        port_remove(port);
        return -1;
    }
    
    gwlist_produce(new_server_sockets, p);
    keep_servers_open = 1;
    start_server_thread();
    gwthread_wakeup(server_thread_id);
    
    return 0;
}

http_receive_result_real()

void* http_receive_result_real	(	HTTPCaller *	caller,
		int *	status,
		Octstr **	final_url,
		List **	headers,
		Octstr **	body,
		int	blocking
	)

Definition at line 1786 of file http.c.

References HTTPEntity::body, caller, gwlist_consume(), gwlist_extract_first(), HTTPEntity::headers, HTTPServer::request_id, HTTPServer::response, server_destroy(), HTTPServer::status, and HTTPServer::url.

{
    HTTPServer *trans;
    void *request_id;

    if (blocking == 0)
        trans = gwlist_extract_first(caller);
    else
        trans = gwlist_consume(caller);
    if (trans == NULL)
        return NULL;

    request_id = trans->request_id;
    *status = trans->status;
    
    if (trans->status >= 0) {
        *final_url = trans->url;
        *headers = trans->response->headers;
        *body = trans->response->body;

        trans->url = NULL;
        trans->response->headers = NULL;
        trans->response->body = NULL;
    } else {
       *final_url = NULL;
       *headers = NULL;
       *body = NULL;
    }

    server_destroy(trans);
    return request_id;
}

http_remove_hop_headers()

void http_remove_hop_headers

(

List *

headers

)

Definition at line 3161 of file http.c.

References gw_assert(), gwlib_assert_init(), gwlist_consume(), gwlist_destroy(), http_header_find_all(), http_header_remove_all(), http_header_split_value(), octstr_delete(), octstr_destroy(), and octstr_get_cstr.

Referenced by pap_request_thread(), return_reply(), and start_fetch().

{
    Octstr *h;
    List *connection_headers;

    gwlib_assert_init();
    gw_assert(headers != NULL);

    /*
     * The hop-by-hop headers are a standard list, plus those named
     * in the Connection header(s).
     */

    connection_headers = http_header_find_all(headers, "Connection");
    while ((h = gwlist_consume(connection_headers))) {
    List *hop_headers;
    Octstr *e;

    octstr_delete(h, 0, strlen("Connection:"));
    hop_headers = http_header_split_value(h);
    octstr_destroy(h);

    while ((e = gwlist_consume(hop_headers))) {
        http_header_remove_all(headers, octstr_get_cstr(e));
        octstr_destroy(e);
    }

    gwlist_destroy(hop_headers, NULL);
    }
    gwlist_destroy(connection_headers, NULL);
   
    http_header_remove_all(headers, "Connection");
    http_header_remove_all(headers, "Keep-Alive");
    http_header_remove_all(headers, "Proxy-Authenticate");
    http_header_remove_all(headers, "Proxy-Authorization");
    http_header_remove_all(headers, "TE");
    http_header_remove_all(headers, "Trailers");
    http_header_remove_all(headers, "Transfer-Encoding");
    http_header_remove_all(headers, "Upgrade");
}

http_request_url()

Octstr* http_request_url

(

HTTPClient *

client

)

Definition at line 2768 of file http.c.

References client().

{
    return client->url;
}

http_send_reply()

void http_send_reply	(	HTTPClient *	client,
		int	status,
		List *	headers,
		Octstr *	body
	)

Definition at line 2695 of file http.c.

References client(), client_destroy(), client_reset(), conn_register, conn_write(), date(), date_format_http(), gwlist_get(), gwlist_len(), HTTP_METHOD_DELETE, HTTP_METHOD_HEAD, http_reason_phrase(), octstr_append(), octstr_destroy(), octstr_format(), octstr_format_append(), octstr_get_cstr, octstr_len(), port_get_fdset(), receive_request(), and response().

Referenced by brunet_receive_sms(), challenge(), clickatell_receive_sms(), client_thread(), delayed_http_reply(), generic_receive_sms(), http_thread(), httpd_emu_reply(), httpd_serve(), kannel_receive_sms(), pap_request_thread(), receive_request(), reply(), send_to_pi(), sendsms_thread(), soap_server(), and xidris_receive_sms().

{
    Octstr *response;
    Octstr *date;
    long i;
    int ret;

    if (client->use_version_1_0)
        response = octstr_format("HTTP/1.0 %d %s\r\n", status, http_reason_phrase(status));
    else
        response = octstr_format("HTTP/1.1 %d %s\r\n", status, http_reason_phrase(status));

    /* identify ourselfs */
    octstr_format_append(response, "Server: " GW_NAME "/%s\r\n", GW_VERSION);
    
    /* let's inform the client of our time */
    date = date_format_http(time(NULL));
    octstr_format_append(response, "Date: %s\r\n", octstr_get_cstr(date));
    octstr_destroy(date);
    
    octstr_format_append(response, "Content-Length: %ld\r\n", octstr_len(body));

    /* Indicate if we're keeping the connection or closing. */
    if (client->persistent_conn)
        octstr_format_append(response, "Connection: Keep-Alive\r\n");
    else
        octstr_format_append(response, "Connection: Close\r\n");

    for (i = 0; i < gwlist_len(headers); ++i)
        octstr_format_append(response, "%S\r\n", gwlist_get(headers, i));
    octstr_format_append(response, "\r\n");
    
    if (body != NULL && client->method != HTTP_METHOD_HEAD && client->method != HTTP_METHOD_DELETE)
        octstr_append(response, body);
    
    ret = conn_write(client->conn, response);
    octstr_destroy(response);

    /* obey return code of conn_write() */
    /* sending response was successful */
    if (ret == 0) { 
        /* HTTP/1.0 or 1.1, hence keep-alive or keep-alive */
        if (!client->persistent_conn) {
            client_destroy(client);     
        } else {
            /* XXX mark this HTTPClient in the keep-alive cleaner thread */
            client_reset(client);
            conn_register(client->conn, port_get_fdset(client->port), receive_request, client);
        }
    }
    /* queued for sending, we don't want to block */
    else if (ret == 1) {    
        client->state = sending_reply;
        conn_register(client->conn, port_get_fdset(client->port), receive_request, client);
    }
    /* error while sending response */
    else {     
        client_destroy(client);
    }
}

http_set_client_timeout()

void http_set_client_timeout

(

long

timeout

)

Define timeout in seconds for which HTTP client will wait for response. Set -1 to disable timeouts.

Definition at line 1751 of file http.c.

References client_fdset, fdset_set_timeout(), and http_client_timeout.

Referenced by init_bearerbox(), init_smsbox(), and init_wapbox().

{
    http_client_timeout = timeout;
    if (client_fdset != NULL) {
        /* we are already initialized set timeout in fdset */
        fdset_set_timeout(client_fdset, http_client_timeout);
    }
}

http_set_interface()

void http_set_interface

(

const Octstr *

our_host

)

Definition at line 1746 of file http.c.

References http_interface, octstr_duplicate, and our_host.

Referenced by config_reload().

{
    http_interface = octstr_duplicate(our_host);
}

http_set_server_timeout()

void http_set_server_timeout	(	int	port,
		long	timeout
	)

Define timeout in seconds for which HTTP server will wait for request. Set -1 to disable timeouts.

Definition at line 2477 of file http.c.

References port_set_timeout().

{
    port_set_timeout(port, timeout);
}

http_shutdown()

void http_shutdown

(

void

)

Definition at line 3618 of file http.c.

References client_shutdown(), conn_pool_shutdown(), gw_assert(), gwlib_assert_init(), limbo, port_shutdown(), proxy_shutdown(), run_status, running, server_shutdown(), and terminating.

Referenced by gwlib_shutdown().

{
    gwlib_assert_init();
    gw_assert(run_status == running);

    run_status = terminating;

    conn_pool_shutdown();
    client_shutdown();
    server_shutdown();
    port_shutdown();
    proxy_shutdown();
#ifdef HAVE_LIBSSL
    conn_shutdown_ssl();
    server_shutdown_ssl();
#endif /* HAVE_LIBSSL */
    run_status = limbo;
}

http_start_request()

void http_start_request	(	HTTPCaller *	caller,
		int	method,
		Octstr *	url,
		List *	headers,
		Octstr *	body,
		int	follow,
		void *	id,
		Octstr *	certkeyfile
	)

Definition at line 1760 of file http.c.

References caller, gwlist_produce(), HTTP_MAX_FOLLOW, http_start_request(), method, pending_requests, HTTPServer::request_id, server_create(), start_client_threads(), and url.

Referenced by brunet_send_sms(), clickatell_send_sms(), generic_send_sms(), http_get_real(), http_queue_thread(), http_start_request(), kannel_send_sms(), obey_request(), receive_push_reply(), soap_client_init_query(), start_fetch(), start_push(), start_request(), xidris_send_sms(), and xmlrpc_doc_send().

{
    HTTPServer *trans;
    int follow_remaining;
    
    if (follow)
        follow_remaining = HTTP_MAX_FOLLOW;
    else
        follow_remaining = 0;

    trans = server_create(caller, method, url, headers, body, follow_remaining, 
              certkeyfile);

    if (id == NULL)
        /* We don't leave this NULL so http_receive_result can use NULL
         * to signal no more requests */
        trans->request_id = http_start_request;
    else
        trans->request_id = id;
        
    gwlist_produce(pending_requests, trans);
    start_client_threads();
}

http_status_class()

int http_status_class

(

int

code

)

Definition at line 3642 of file http.c.

References code, and HTTP_STATUS_UNKNOWN.

Referenced by handle_transaction(), response_expectation(), and return_reply().

{
    int sclass;

    if (code < 100 || code >= 600)
        sclass = HTTP_STATUS_UNKNOWN;
    else
        sclass = code - (code % 100);
    return sclass;
}

http_type_accepted()

int http_type_accepted	(	List *	headers,
		char *	type
	)

Definition at line 3503 of file http.c.

References http_something_accepted(), and type.

Referenced by add_accept_headers(), check_session_request_headers(), convert_content(), httpd_serve(), and return_reply().

{
    return http_something_accepted(headers, "Accept", type);
}

http_urlparse_create()

HTTPURLParse* http_urlparse_create

(

void

)

Definition at line 1313 of file http.c.

References HTTPURLParse::fragment, HTTPURLParse::host, HTTPURLParse::pass, HTTPURLParse::path, HTTPURLParse::port, HTTPURLParse::query, HTTPURLParse::scheme, HTTPURLParse::url, and HTTPURLParse::user.

Referenced by parse_url().

{
    HTTPURLParse *p;

    p = gw_malloc(sizeof(HTTPURLParse));
    p->url = NULL;
    p->scheme = NULL;
    p->host = NULL;
    p->port = 0;
    p->user = NULL;
    p->pass = NULL;
    p->path = NULL;
    p->query = NULL;
    p->fragment = NULL;
    
    return p;
}

http_urlparse_destroy()

void http_urlparse_destroy

(

HTTPURLParse *

p

)

Definition at line 1332 of file http.c.

References HTTPURLParse::fragment, gw_assert(), HTTPURLParse::host, octstr_destroy(), HTTPURLParse::pass, HTTPURLParse::path, HTTPURLParse::query, HTTPURLParse::scheme, HTTPURLParse::url, and HTTPURLParse::user.

Referenced by generic_send_sms(), get_connection(), and parse_url().

{
    gw_assert(p != NULL);

    octstr_destroy(p->url);
    octstr_destroy(p->scheme);
    octstr_destroy(p->host);
    octstr_destroy(p->user);
    octstr_destroy(p->pass);
    octstr_destroy(p->path);
    octstr_destroy(p->query);
    octstr_destroy(p->fragment);
    gw_free(p);
}

http_use_proxy()

void http_use_proxy	(	Octstr *	hostname,
		int	port,
		int	ssl,
		List *	exceptions,
		Octstr *	username,
		Octstr *	password,
		Octstr *	exceptions_regex
	)

Definition at line 268 of file http.c.

References debug(), gw_assert(), gwlist_append(), gwlist_create, gwlist_get(), gwlist_len(), hostname, http_close_proxy(), mutex_lock, mutex_unlock, octstr_duplicate, octstr_get_cstr, octstr_len(), panic, password, port, proxy_exceptions, proxy_exceptions_regex, proxy_hostname, proxy_mutex, proxy_password, proxy_port, proxy_ssl, proxy_username, run_status, running, ssl, and username.

Referenced by config_reload(), init_bearerbox(), init_smsbox(), and main().

{
    Octstr *e;
    int i;

    gw_assert(run_status == running);
    gw_assert(hostname != NULL);
    gw_assert(octstr_len(hostname) > 0);
    gw_assert(port > 0);

    http_close_proxy();
    mutex_lock(proxy_mutex);

    proxy_hostname = octstr_duplicate(hostname);
    proxy_port = port;
    proxy_ssl = ssl;
    proxy_exceptions = gwlist_create();
    for (i = 0; i < gwlist_len(exceptions); ++i) {
        e = gwlist_get(exceptions, i);
        debug("gwlib.http", 0, "HTTP: Proxy exception `%s'.", octstr_get_cstr(e));
        gwlist_append(proxy_exceptions, octstr_duplicate(e));
    }
    if (exceptions_regex != NULL &&
        (proxy_exceptions_regex = gw_regex_comp(exceptions_regex, REG_EXTENDED)) == NULL)
            panic(0, "Could not compile pattern '%s'", octstr_get_cstr(exceptions_regex));
    proxy_username = octstr_duplicate(username);
    proxy_password = octstr_duplicate(password);
    debug("gwlib.http", 0, "Using proxy <%s:%d> with %s scheme", 
          octstr_get_cstr(proxy_hostname), proxy_port,
          (proxy_ssl ? "HTTPS" : "HTTP"));

    mutex_unlock(proxy_mutex);
}

parse_cgivars()

void parse_cgivars	(	List *	cgivars,
		Octstr *	pairs
	)

Definition at line 2542 of file http.c.

References gwlist_append(), HTTPCGIVar::name, octstr_copy, octstr_destroy(), octstr_len(), octstr_search_char(), octstr_url_decode(), start, and HTTPCGIVar::value.

Referenced by generic_receive_sms(), and http_accept_request().

{
    HTTPCGIVar *v;
    Octstr *pair;
    long ampersand, equal, start;
    long pairs_len = octstr_len(pairs);

    for (start = 0; start < pairs_len; start = ampersand + 1) {
        ampersand = octstr_search_char(pairs, '&', start);
        if (ampersand == -1)
            ampersand = pairs_len;
        pair = octstr_copy(pairs, start, ampersand - start);

        equal = octstr_search_char(pair, '=', 0);
        if (equal == -1)
            equal = octstr_len(pair);

        v = gw_malloc(sizeof(HTTPCGIVar));
        v->name = octstr_copy(pair, 0, equal);
        v->value = octstr_copy(pair, equal + 1, octstr_len(pair));
        octstr_url_decode(v->name);
        octstr_url_decode(v->value);
        gwlist_append(cgivars, v);

        octstr_destroy(pair);
    }
}

parse_dump()

void parse_dump

(

HTTPURLParse *

p

)

Definition at line 1348 of file http.c.

References debug(), HTTPURLParse::fragment, HTTPURLParse::host, octstr_get_cstr, HTTPURLParse::pass, HTTPURLParse::path, HTTPURLParse::port, HTTPURLParse::query, HTTPURLParse::scheme, HTTPURLParse::url, and HTTPURLParse::user.

Referenced by parse_url().

{
    if (p == NULL)
        return;
    debug("http.parse_url",0,"Parsing URL `%s':", octstr_get_cstr(p->url));
    debug("http.parse_url",0,"  Scheme: %s", octstr_get_cstr(p->scheme));  
    debug("http.parse_url",0,"  Host: %s", octstr_get_cstr(p->host));  
    debug("http.parse_url",0,"  Port: %ld", p->port);  
    debug("http.parse_url",0,"  Username: %s", octstr_get_cstr(p->user));  
    debug("http.parse_url",0,"  Password: %s", octstr_get_cstr(p->pass));  
    debug("http.parse_url",0,"  Path: %s", octstr_get_cstr(p->path));  
    debug("http.parse_url",0,"  Query: %s", octstr_get_cstr(p->query));  
    debug("http.parse_url",0,"  Fragment: %s", octstr_get_cstr(p->fragment));  
}

parse_url()

HTTPURLParse* parse_url

(

Octstr *

url

)

Definition at line 1377 of file http.c.

References colon, debug(), error(), HTTPURLParse::host, HTTP_PORT, http_urlparse_create(), http_urlparse_destroy(), HTTPS_PORT, octstr_case_search(), octstr_compare(), octstr_copy, octstr_create, octstr_duplicate, octstr_get_cstr, octstr_imm(), octstr_len(), octstr_parse_long(), octstr_search_char(), octstr_set_char(), octstr_url_decode(), parse_dump(), HTTPURLParse::pass, HTTPURLParse::path, HTTPURLParse::port, HTTPURLParse::query, HTTPURLParse::scheme, url, HTTPURLParse::url, and HTTPURLParse::user.

Referenced by generic_send_sms(), and get_connection().

{
    HTTPURLParse *p;
    Octstr *prefix, *prefix_https;
    long prefix_len;
    int host_len, colon, slash, at, auth_sep, query;
    host_len = colon = slash = at = auth_sep = query = 0;

    prefix = octstr_imm("http://");
    prefix_https = octstr_imm("https://");
    prefix_len = octstr_len(prefix);

    if (octstr_case_search(url, prefix, 0) != 0) {
        if (octstr_case_search(url, prefix_https, 0) == 0) {
#ifdef HAVE_LIBSSL
            debug("gwlib.http", 0, "HTTPS URL; Using SSL for the connection");
            prefix = prefix_https;
            prefix_len = octstr_len(prefix_https);  
#else
            error(0, "Attempt to use HTTPS <%s> but SSL not compiled in", 
                  octstr_get_cstr(url));
            return NULL;
#endif
        } else {
            error(0, "URL <%s> doesn't start with `%s' nor `%s'",
            octstr_get_cstr(url), octstr_get_cstr(prefix),
            octstr_get_cstr(prefix_https));
            return NULL;
        }
    }

    /* an URL should be more (at least one charset) then the scheme itself */
    if (octstr_len(url) == prefix_len) {
        error(0, "URL <%s> is malformed.", octstr_get_cstr(url));
        return NULL;
    }

    /* check if colon and slashes are within scheme */
    colon = octstr_search_char(url, ':', prefix_len);
    slash = octstr_search_char(url, '/', prefix_len);
    if (colon == prefix_len || slash == prefix_len) {
        error(0, "URL <%s> is malformed.", octstr_get_cstr(url));
        return NULL;
    }

    /* create struct and add values succesively while parsing */
    p = http_urlparse_create();
    p->url = octstr_duplicate(url);
    p->scheme = octstr_duplicate(prefix);

    /* try to parse authentication separator */
    at = octstr_search_char(url, '@', prefix_len);
    if (at != -1) {
        if ((slash == -1 || ( slash != -1 && at < slash))) {
            auth_sep = octstr_search_char(url, ':', prefix_len);
            if (auth_sep != -1 && (auth_sep < at)) {
                octstr_set_char(url, auth_sep, '@');
                colon = octstr_search_char(url, ':', prefix_len);
            }
        } else {
            at = -1;
        }
    }

    /*
     * We have to watch out here for 4 cases:
     *  a) hostname, no port or path
     *  b) hostname, port, no path
     *  c) hostname, path, no port
     *  d) hostname, port and path
     */
    
    /* we only have the hostname, no port or path. */
    if (slash == -1 && colon == -1) {
        host_len = octstr_len(url) - prefix_len;
#ifdef HAVE_LIBSSL
        p->port = (octstr_compare(p->scheme, octstr_imm("https://")) == 0) ? 
            HTTPS_PORT : HTTP_PORT;
#else
        p->port = HTTP_PORT;
#endif /* HAVE_LIBSSL */
    } 
    /* we have a port, but no path. */
    else if (slash == -1) {
        host_len = colon - prefix_len;
        if (octstr_parse_long((long*) &(p->port), url, colon + 1, 10) == -1) {
            error(0, "URL <%s> has malformed port number.",
                  octstr_get_cstr(url));
            http_urlparse_destroy(p);
            return NULL;
        }
    } 
    /* we have a path, but no port. */
    else if (colon == -1 || colon > slash) {
        host_len = slash - prefix_len;
#ifdef HAVE_LIBSSL
        p->port = (octstr_compare(p->scheme, octstr_imm("https://")) == 0) ? 
            HTTPS_PORT : HTTP_PORT;
#else
        p->port = HTTP_PORT;
#endif /* HAVE_LIBSSL */
    } 
    /* we have both, path and port. */
    else if (colon < slash) {
        host_len = colon - prefix_len;
        if (octstr_parse_long((long*) &(p->port), url, colon + 1, 10) == -1) {
            error(0, "URL <%s> has malformed port number.",
                  octstr_get_cstr(url));
            http_urlparse_destroy(p);
            return NULL;
        }
    /* none of the above, so there is something wrong here */
    } else {
        error(0, "Internal error in URL parsing logic.");
        http_urlparse_destroy(p);
        return NULL;
    }

    /* there was an authenticator separator, so try to parse 
     * the username and password credentials */
    if (at != -1) {
        int at2;

        at2 = octstr_search_char(url, '@', prefix_len);
        p->user = octstr_copy(url, prefix_len, at2 - prefix_len);
        p->pass = (at2 != at) ? octstr_copy(url, at2 + 1, at - at2 - 1) : NULL;

        /* url-decode user & pass */
        if (p->user != NULL)
            octstr_url_decode(p->user);
        if (p->pass != NULL)
            octstr_url_decode(p->pass);

        if (auth_sep != -1)
            octstr_set_char(url, auth_sep, ':');
  
        host_len = host_len - at + prefix_len - 1;
        prefix_len = at + 1;
    }

    /* query (CGI vars) */
    query = octstr_search_char(url, '?', (slash == -1) ? prefix_len : slash);
    if (query != -1) {
        p->query = octstr_copy(url, query + 1, octstr_len(url));
        if (colon == -1)
            host_len = slash != -1 ? slash - prefix_len : query - prefix_len;
    }

    /* path */
    p->path = (slash == -1) ? 
        octstr_create("/") : ((query != -1) && (query > slash) ? 
            octstr_copy(url, slash, query - slash) :
            octstr_copy(url, slash, octstr_len(url) - slash)); 

    /* hostname */
    p->host = octstr_copy(url, prefix_len, host_len); 

    /* XXX add fragment too */
   
    /* dump components */
    parse_dump(p);

    return p;
}