#include <ctype.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "gwlib.h"
#include "gwlib/gw-regex.h"

Data Structures
struct	HTTPEntity

struct	HTTPServer

struct	HTTPClient

struct	port

Macros
#define	DUMP_RESPONSE 1

#define	HTTP_SERVER_TIMEOUT 60

#define	HTTP_SERVER_MAX_ACTIVE_CONNECTIONS 500

#define	HTTP_MAX_FOLLOW 5

#define	MAX_HEADER_LENGTH 256

Enumerations
enum	{ HTTP_PORT = 80, HTTPS_PORT = 443 }

enum	{ limbo, running, terminating }

enum	body_expectation { expect_no_body, expect_body_if_indicated, expect_body }

enum	entity_state { reading_headers, reading_chunked_body_len, reading_chunked_body_data, reading_chunked_body_crlf, reading_chunked_body_trailer, reading_body_until_eof, reading_body_with_length, body_error, entity_done }

Functions
static int	read_some_headers (Connection conn, List headers)

static int	parse_http_version (Octstr *version)

static void	proxy_add_authentication (List *headers)

static void	proxy_init (void)

static void	proxy_shutdown (void)

static int	proxy_used_for_host (Octstr host, Octstr url)

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

void	http_close_proxy (void)

static void	deduce_body_state (HTTPEntity *ent)

static HTTPEntity *	entity_create (enum body_expectation exp)

static void	entity_destroy (HTTPEntity *ent)

static void	read_chunked_body_len (HTTPEntity ent, Connection conn)

static void	read_chunked_body_data (HTTPEntity ent, Connection conn)

static void	read_chunked_body_crlf (HTTPEntity ent, Connection conn)

static void	read_chunked_body_trailer (HTTPEntity ent, Connection conn)

static void	read_body_until_eof (HTTPEntity ent, Connection conn)

static void	read_body_with_length (HTTPEntity ent, Connection conn)

static int	entity_read (HTTPEntity ent, Connection conn)

static int	send_request (HTTPServer *trans)

static Octstr *	build_response (List headers, Octstr body)

static int	header_is_called (Octstr header, char name)

static HTTPServer *	server_create (HTTPCaller caller, int method, Octstr url, List headers, Octstr body, int follow_remaining, Octstr *certkeyfile)

static void	server_destroy (void *p)

static void	conn_pool_item_destroy (void *item)

static void	conn_pool_init (void)

static void	conn_pool_shutdown (void)

static Octstr *	conn_pool_key (Octstr host, int port, int ssl, Octstr certfile, Octstr *our_host)

static Connection *	conn_pool_get (Octstr host, int port, int ssl, Octstr certkeyfile, Octstr *our_host)

HTTPCaller *	http_caller_create (void)

void	http_caller_destroy (HTTPCaller *caller)

void	http_caller_signal_shutdown (HTTPCaller *caller)

static Octstr *	get_redirection_location (HTTPServer *trans)

static void	recover_absolute_uri (HTTPServer trans, Octstr loc)

static int	client_read_status (HTTPServer *trans)

static int	response_expectation (int method, int status)

static void	handle_transaction (Connection conn, void data)

static Octstr *	build_request (char method_name, Octstr path_or_url, Octstr host, long port, int ssl, List headers, Octstr *request_body)

HTTPURLParse *	http_urlparse_create (void)

void	http_urlparse_destroy (HTTPURLParse *p)

void	parse_dump (HTTPURLParse *p)

HTTPURLParse *	parse_url (Octstr *url)

static void	parse2trans (HTTPURLParse p, HTTPServer t)

static Connection *	get_connection (HTTPServer *trans)

static void	write_request_thread (void *arg)

static void	start_client_threads (void)

void	http_set_interface (const Octstr *our_host)

void	http_set_client_timeout (long timeout)

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)

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

static void	client_init (void)

static void	client_shutdown (void)

static HTTPClient *	client_create (int port, Connection conn, Octstr ip)

static void	client_destroy (void *client)

static void	client_reset (HTTPClient *p)

static int	client_is_persistent (List *headers, int use_version_1_0)

static int	port_match (void client, void port)

static void	port_init (void)

static void	port_shutdown (void)

static Octstr *	port_key (int port)

static struct port *	port_add (int port)

static void	port_remove (int port)

static void	port_put_request (HTTPClient *client)

static HTTPClient *	port_get_request (int port)

static void	port_set_timeout (int port, long timeout)

static FDSet *	port_get_fdset (int port)

static int	parse_request_line (int method, Octstr url, int use_version_1_0, Octstr *line)

static void	receive_request (Connection conn, void data)

static void	server_thread (void *dummy)

static void	start_server_thread (void)

void	http_set_server_timeout (int port, long timeout)

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

int	http_open_port (int port, int ssl)

void	http_close_port (int port)

void	http_close_all_ports (void)

void	parse_cgivars (List cgivars, Octstr pairs)

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

static const char *	http_reason_phrase (int status)

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

void	http_close_client (HTTPClient *client)

int	http_method (HTTPClient *client)

Octstr *	http_request_url (HTTPClient *client)

static void	server_init (void)

static void	destroy_struct_server (void *p)

static void	destroy_int_pointer (void *p)

static void	server_shutdown (void)

void	http_destroy_cgiargs (List *args)

Octstr *	http_cgi_variable (List list, char name)

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)

Octstr *	http_header_value (List headers, Octstr name)

List *	http_header_duplicate (List *headers)

void	http_header_pack (List *headers)

void	http_append_headers (List to, List from)

void	http_header_combine (List old_headers, List new_headers)

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)

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)

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

static void	http_header_add_element (List list, Octstr value, long start, long end)

long	http_header_quoted_string_len (Octstr *header, long start)

List *	http_header_split_value (Octstr *value)

List *	http_header_split_auth_value (Octstr *value)

void	http_header_dump (List *headers)

void	http_cgivar_dump (List *cgiargs)

void	http_cgivar_dump_into (List cgiargs, Octstr os)

static int	http_something_accepted (List headers, char header_name, char *what)

int	http_type_accepted (List headers, char type)

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)

void	http_init (void)

void	http_shutdown (void)

int	http_status_class (int code)

int	http_name2method (Octstr *method)

char *	http_method2name (int method)

Variables
static int	http_client_timeout = 30

static enum { ... }	run_status = limbo

static Octstr *	http_interface = NULL

static Mutex *	proxy_mutex = NULL

static Octstr *	proxy_hostname = NULL

static int	proxy_port = 0

static int	proxy_ssl = 0

static Octstr *	proxy_username = NULL

static Octstr *	proxy_password = NULL

static List *	proxy_exceptions = NULL

static regex_t *	proxy_exceptions_regex = NULL

static List *	pending_requests = NULL

static Mutex *	client_thread_lock = NULL

static volatile sig_atomic_t	client_threads_are_running = 0

static FDSet *	client_fdset = NULL

static char *	http_methods []

static Dict *	conn_pool

static Mutex *	conn_pool_lock

static Mutex *	server_thread_lock = NULL

static volatile sig_atomic_t	server_thread_is_running = 0

static long	server_thread_id = -1

static List *	new_server_sockets = NULL

static List *	closed_server_sockets = NULL

static int	keep_servers_open = 0

static List *	active_connections

static Mutex *	port_mutex = NULL

static Dict *	port_collection = NULL

Macro Definition Documentation

◆ DUMP_RESPONSE

#define DUMP_RESPONSE 1

Definition at line 88 of file http.c.

◆ HTTP_MAX_FOLLOW

#define HTTP_MAX_FOLLOW 5

Definition at line 653 of file http.c.

Referenced by http_start_request().

◆ HTTP_SERVER_MAX_ACTIVE_CONNECTIONS

#define HTTP_SERVER_MAX_ACTIVE_CONNECTIONS 500

Definition at line 96 of file http.c.

Referenced by client_destroy(), and server_thread().

◆ HTTP_SERVER_TIMEOUT

#define HTTP_SERVER_TIMEOUT 60

Definition at line 94 of file http.c.

Referenced by port_add().

◆ MAX_HEADER_LENGTH

#define MAX_HEADER_LENGTH 256

Definition at line 2987 of file http.c.

Referenced by http_header_pack().

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
HTTP_PORT
HTTPS_PORT

Definition at line 106 of file http.c.

106 { HTTP_PORT = 80,

107 HTTPS_PORT = 443 };

HTTPS_PORT

Definition: http.c:107

HTTP_PORT

Definition: http.c:106

◆ anonymous enum

anonymous enum

Enumerator
limbo
running
terminating

Definition at line 113 of file http.c.

             { 
     limbo, 
     running, 
     terminating 
 } run_status = limbo;

◆ body_expectation

enum body_expectation

Enumerator
expect_no_body
expect_body_if_indicated
expect_body

Definition at line 331 of file http.c.

                       {
    /*
     * Message must not have a body, even if the headers indicate one.
     * (i.e. response to HEAD method).
     */
    expect_no_body,
    /*
     * Message will have a body if Content-Length or Transfer-Encoding
     * headers are present (i.e. most request methods).
     */
    expect_body_if_indicated,
    /*
     * Message will have a body, possibly zero-length.
     * (i.e. 200 OK responses to a GET method.)
     */
    expect_body
 };

◆ entity_state

enum entity_state

Enumerator
reading_headers
reading_chunked_body_len
reading_chunked_body_data
reading_chunked_body_crlf
reading_chunked_body_trailer
reading_body_until_eof
reading_body_with_length
body_error
entity_done

Definition at line 349 of file http.c.

                   {
     reading_headers,
     reading_chunked_body_len,
     reading_chunked_body_data,
     reading_chunked_body_crlf,
     reading_chunked_body_trailer,
     reading_body_until_eof,
     reading_body_with_length,
     body_error,
     entity_done
 };

Function Documentation

◆ build_request()

static Octstr* build_request	(	char *	method_name,
		Octstr *	path_or_url,
		Octstr *	host,
		long	port,
		int	ssl,
		List *	headers,
		Octstr *	request_body
	)

static

Definition at line 1244 of file http.c.

References gwlist_get(), gwlist_len(), header_is_called(), host, HTTP_PORT, HTTPS_PORT, method_name, octstr_append(), octstr_format(), octstr_format_append(), octstr_imm(), and ssl.

Referenced by send_request().

 {
     /* XXX headers missing */
     Octstr *request;
     int i, host_found = 0;
 
     request = octstr_format("%s %S HTTP/1.1\r\n",
                             method_name, path_or_url);
 
 #ifdef USE_KEEPALIVE 
     octstr_append(request, octstr_imm("Connection: keep-alive\r\n"));
 #endif
 
     for (i = 0; headers != NULL && i < gwlist_len(headers); ++i) {
         /* check if Host already set in the headers */
         if (header_is_called(gwlist_get(headers, i), "Host"))
             host_found = 1;
         octstr_append(request, gwlist_get(headers, i));
         octstr_append(request, octstr_imm("\r\n"));
     }
 
     if (!host_found) {
         octstr_format_append(request, "Host: %S", host);
         /*
          * In accordance with HTT/1.1 [RFC 2616], section 14.23 "Host"
          * we shall ONLY add the port number if it is not one of the
          * officially assigned port numbers. This means we need to obey
          * port 80 for non-SSL connections and port 443 for SSL-enabled.
          */
         if ((port != HTTP_PORT && !ssl) || (port != HTTPS_PORT && ssl))
             octstr_format_append(request, ":%ld", port);
         octstr_append(request, octstr_imm("\r\n"));
     }
 
     octstr_append(request, octstr_imm("\r\n"));
 
     if (request_body != NULL)
         octstr_append(request, request_body);
 
     return request;
 }

◆ build_response()

static Octstr * build_response	(	List *	headers,
		Octstr *	body
	)

static

Definition at line 1293 of file http.c.

References gwlist_get(), gwlist_len(), octstr_append(), octstr_create, octstr_imm(), and response().

Referenced by handle_transaction().

 {
     Octstr *response;
     int i;
 
     response = octstr_create("");
 
     for (i = 0; headers != NULL && i < gwlist_len(headers); ++i) {
         octstr_append(response, gwlist_get(headers, i));
         octstr_append(response, octstr_imm("\r\n"));
     }
     octstr_append(response, octstr_imm("\r\n"));
 
     if (body != NULL)
         octstr_append(response, body);
 
     return response;
 }

◆ client_create()

static HTTPClient* client_create	(	int	port,
		Connection *	conn,
		Octstr *	ip
	)

static

Definition at line 1902 of file http.c.

References active_connections, HTTPClient::conn, HTTPClient::conn_time, debug(), gwlist_produce(), HTTPClient::ip, octstr_get_cstr, HTTPClient::persistent_conn, port, HTTPClient::port, HTTPClient::request, HTTPClient::state, HTTPClient::url, and HTTPClient::use_version_1_0.

Referenced by server_thread().

 {
     HTTPClient *p;
     
 #ifdef HAVE_LIBSSL
     if (conn_get_ssl(conn)) 
         debug("gwlib.http", 0, "HTTP: Creating SSL-enabled HTTPClient for `%s', using cipher '%s'.",
               octstr_get_cstr(ip), SSL_get_cipher_version(conn_get_ssl(conn)));
     else
 #endif    
         debug("gwlib.http", 0, "HTTP: Creating HTTPClient for `%s'.", octstr_get_cstr(ip));
     p = gw_malloc(sizeof(*p));
     p->port = port;
     p->conn = conn;
     p->ip = ip;
     p->state = reading_request_line;
     p->url = NULL;
     p->use_version_1_0 = 0;
     p->persistent_conn = 1;
     p->conn_time = time(NULL);
     p->request = NULL;
     debug("gwlib.http", 0, "HTTP: Created HTTPClient area %p.", p);
     
     /* add this client to active_connections */
     gwlist_produce(active_connections, p);
     
     return p;
 }

◆ client_destroy()

static void client_destroy ( void * client )

static

Definition at line 1932 of file http.c.

References active_connections, client(), HTTPClient::conn, conn_destroy(), debug(), entity_destroy(), gwlist_delete_equal(), gwlist_len(), gwlist_lock(), gwlist_unlock(), gwthread_wakeup(), HTTP_SERVER_MAX_ACTIVE_CONNECTIONS, HTTPClient::ip, octstr_destroy(), octstr_get_cstr, panic, HTTPClient::request, server_thread_id, and HTTPClient::url.

Referenced by http_accept_request(), http_close_client(), http_send_reply(), port_put_request(), port_remove(), port_shutdown(), and receive_request().

 {
     HTTPClient *p;
     long a_len;
     
     if (client == NULL)
         return;
 
     p = client;
     
     /* drop this client from active_connections list */
     gwlist_lock(active_connections);
     if (gwlist_delete_equal(active_connections, p) != 1)
         panic(0, "HTTP: Race condition in client_destroy(%p) detected!", client);
 
     /* signal server thread that client slot is free */
     a_len = gwlist_len(active_connections);
     gwlist_unlock(active_connections);
 
     if (a_len >= HTTP_SERVER_MAX_ACTIVE_CONNECTIONS - 1)
         gwthread_wakeup(server_thread_id);
     
     debug("gwlib.http", 0, "HTTP: Destroying HTTPClient area %p.", p);
     gw_assert_allocated(p, __FILE__, __LINE__, __func__);
     debug("gwlib.http", 0, "HTTP: Destroying HTTPClient for `%s'.",
           octstr_get_cstr(p->ip));
     
     conn_destroy(p->conn);
     octstr_destroy(p->ip);
     octstr_destroy(p->url);
     entity_destroy(p->request);
     gw_free(p);
 }

◆ client_init()

static void client_init ( void )

static

Definition at line 1840 of file http.c.

References client_thread_lock, gwlist_add_producer(), gwlist_create, mutex_create, and pending_requests.

Referenced by http_init().

 {
     pending_requests = gwlist_create();
     gwlist_add_producer(pending_requests);
     client_thread_lock = mutex_create();
 }

◆ client_is_persistent()

static int client_is_persistent	(	List *	headers,
		int	use_version_1_0
	)

static

Definition at line 1982 of file http.c.

References gwlist_destroy(), gwlist_search(), http_header_find_first, octstr_destroy(), octstr_destroy_item(), octstr_imm(), octstr_item_case_match(), and octstr_split().

Referenced by http_accept_request().

 {
     Octstr *h = http_header_find_first(headers, "Connection");
 
     if (h == NULL) {
         /* assumes persistent for HTTP/1.1, not for HTTP/1.0 */
         return !use_version_1_0;
     } else {
         List *values = octstr_split(h, octstr_imm(","));
         int ret;
         octstr_destroy(h);
         if (gwlist_search(values, octstr_imm("keep-alive"), octstr_item_case_match) != NULL) {
             /* Keep-Alive was requested */
             ret = 1;
         } else if (gwlist_search(values, octstr_imm("close"), octstr_item_case_match) != NULL) {
             /* Close was requested */
             ret = 0;
         } else {
             /* Nothing was requested, so based on HTTP version */
             ret = (!use_version_1_0);
         }
         gwlist_destroy(values, octstr_destroy_item);
         return ret;
     }
 
     return 1;
 }

◆ client_read_status()

static int client_read_status ( HTTPServer * trans )

static

Definition at line 982 of file http.c.

References HTTPServer::conn, conn_eof(), conn_error(), conn_read_line(), debug(), error(), octstr_copy, octstr_delete(), octstr_destroy(), octstr_get_cstr, octstr_parse_long(), octstr_search_char(), octstr_truncate(), parse_http_version(), HTTPServer::persistent, and HTTPServer::status.

Referenced by handle_transaction().

 {
     Octstr *line, *version;
     long space;
     int ret;
 
     line = conn_read_line(trans->conn);
     if (line == NULL) {
     if (conn_eof(trans->conn) || conn_error(trans->conn))
         return -1;
         return 1;
     }
 
     debug("gwlib.http", 0, "HTTP: Status line: <%s>", octstr_get_cstr(line));
 
     space = octstr_search_char(line, ' ', 0);
     if (space == -1)
         goto error;
     
     version = octstr_copy(line, 0, space);
     ret = parse_http_version(version);
     octstr_destroy(version);
     if (ret == -1)
         goto error;
     trans->persistent = ret;
 
     octstr_delete(line, 0, space + 1);
     space = octstr_search_char(line, ' ', 0);
     if (space == -1)
         goto error;
     octstr_truncate(line, space);
     
     if (octstr_parse_long(&trans->status, line, 0, 10) == -1)
         goto error;
 
     octstr_destroy(line);
     return 0;
 
 error:
     error(0, "HTTP: Malformed status line from HTTP server: <%s>",
       octstr_get_cstr(line));
     octstr_destroy(line);
     return -1;
 }

◆ client_reset()

static void client_reset ( HTTPClient * p )

static

Definition at line 1967 of file http.c.

References HTTPClient::conn_time, debug(), gw_assert(), HTTPClient::ip, octstr_get_cstr, HTTPClient::request, and HTTPClient::state.

Referenced by http_send_reply(), and receive_request().

 {
     debug("gwlib.http", 0, "HTTP: Resetting HTTPClient for `%s'.",
           octstr_get_cstr(p->ip));
     p->state = reading_request_line;
     p->conn_time = time(NULL);
     gw_assert(p->request == NULL);
 }

◆ client_shutdown()

static void client_shutdown ( void )

static

Definition at line 1848 of file http.c.

References client_fdset, client_thread_lock, client_threads_are_running, fdset_destroy(), gwlist_destroy(), gwlist_remove_producer(), gwthread_join_every(), http_interface, mutex_destroy(), octstr_destroy(), pending_requests, server_destroy(), and write_request_thread().

Referenced by http_shutdown().

 {
     gwlist_remove_producer(pending_requests);
     gwthread_join_every(write_request_thread);
     client_threads_are_running = 0;
     gwlist_destroy(pending_requests, server_destroy);
     mutex_destroy(client_thread_lock);
     fdset_destroy(client_fdset);
     client_fdset = NULL;
     octstr_destroy(http_interface);
     http_interface = NULL;
 }

◆ conn_pool_get()

static Connection* conn_pool_get	(	Octstr *	host,
		int	port,
		int	ssl,
		Octstr *	certkeyfile,
		Octstr *	our_host
	)

static

Definition at line 783 of file http.c.

References conn_destroy(), conn_eof(), conn_error(), conn_get_id(), conn_open_tcp_nb(), conn_pool, conn_pool_key(), conn_pool_lock, conn_unregister(), conn_wait(), debug(), dict_get(), gwlist_extract_first(), host, mutex_lock, mutex_unlock, octstr_destroy(), octstr_get_cstr, our_host, and ssl.

Referenced by get_connection().

 {
     Octstr *key;
     List *list = NULL;
     Connection *conn = NULL;
     int retry;
 
     do {
         retry = 0;
         key = conn_pool_key(host, port, ssl, certkeyfile, our_host);
         mutex_lock(conn_pool_lock);
         list = dict_get(conn_pool, key);
         if (list != NULL)
             conn = gwlist_extract_first(list);
         mutex_unlock(conn_pool_lock);
         /*
          * Note: we don't hold conn_pool_lock when we check/destroy/unregister
          *       connection because otherwise we can deadlock! And it's even better
          *       not to delay other threads while we check connection.
          */
         if (conn != NULL) {
 #ifdef USE_KEEPALIVE
             /* unregister our server disconnect callback */
             conn_unregister(conn);
 #endif 
             /*
              * Check whether the server has closed the connection while
              * it has been in the pool.
              */
             conn_wait(conn, 0);
             if (conn_eof(conn) || conn_error(conn)) {
                 debug("gwlib.http", 0, "HTTP:conn_pool_get: Server closed connection, destroying it <%s><%p><fd:%d>.",
                       octstr_get_cstr(key), conn, conn_get_id(conn));
                 conn_destroy(conn);
                 retry = 1;
                 conn = NULL;
             }
         }
         octstr_destroy(key);
     } while(retry == 1);
     
     if (conn == NULL) {
 #ifdef HAVE_LIBSSL
         if (ssl) 
             conn = conn_open_ssl_nb(host, port, certkeyfile, our_host);
         else
 #endif /* HAVE_LIBSSL */
             conn = conn_open_tcp_nb(host, port, our_host);
         debug("gwlib.http", 0, "HTTP: Opening connection to `%s:%d' (fd=%d).",
               octstr_get_cstr(host), port, conn_get_id(conn));
     } else {
         debug("gwlib.http", 0, "HTTP: Reusing connection to `%s:%d' (fd=%d).",
               octstr_get_cstr(host), port, conn_get_id(conn)); 
     }
     
     return conn;
 }

◆ conn_pool_init()

static void conn_pool_init ( void )

static

Definition at line 762 of file http.c.

References conn_pool, conn_pool_item_destroy(), conn_pool_lock, dict_create(), and mutex_create.

Referenced by http_init().

 {
     conn_pool = dict_create(1024, conn_pool_item_destroy);
     conn_pool_lock = mutex_create();
 }

◆ conn_pool_item_destroy()

static void conn_pool_item_destroy ( void * item )

static

Definition at line 757 of file http.c.

References conn_destroy(), and gwlist_destroy().

Referenced by conn_pool_init().

 {
     gwlist_destroy(item, (void(*)(void*))conn_destroy);
 }

◆ conn_pool_key()

static Octstr* conn_pool_key	(	Octstr *	host,
		int	port,
		int	ssl,
		Octstr *	certfile,
		Octstr *	our_host
	)

inlinestatic

Definition at line 776 of file http.c.

References host, octstr_format(), octstr_imm(), our_host, and ssl.

Referenced by conn_pool_get().

 {
     return octstr_format("%S:%d:%d:%S:%S", host, port, ssl?1:0, certfile?certfile:octstr_imm(""),
                          our_host?our_host:octstr_imm(""));
 }

◆ conn_pool_shutdown()

static void conn_pool_shutdown ( void )

static

Definition at line 769 of file http.c.

References conn_pool, conn_pool_lock, dict_destroy(), and mutex_destroy().

Referenced by http_shutdown().

 {
     dict_destroy(conn_pool);
     mutex_destroy(conn_pool_lock);
 }

◆ deduce_body_state()

static void deduce_body_state ( HTTPEntity * ent )

static

Definition at line 375 of file http.c.

References body_error, entity_done, error(), expect_body, expect_no_body, HTTPEntity::expect_state, HTTPEntity::expected_body_len, HTTPEntity::headers, http_header_find_first, octstr_destroy(), octstr_get_cstr, octstr_parse_long(), octstr_str_compare(), octstr_strip_blanks(), reading_body_until_eof, reading_body_with_length, reading_chunked_body_len, and HTTPEntity::state.

Referenced by entity_read().

 {
     Octstr *h = NULL;
 
     if (ent->expect_state == expect_no_body) {
         ent->state = entity_done;
         return;
     }
 
     ent->state = body_error;  /* safety net */
 
     h = http_header_find_first(ent->headers, "Transfer-Encoding");
     if (h != NULL) {
         octstr_strip_blanks(h);
         if (octstr_str_compare(h, "chunked") != 0) {
             error(0, "HTTP: Unknown Transfer-Encoding <%s>",
                   octstr_get_cstr(h));
             ent->state = body_error;
         } else {
             ent->state = reading_chunked_body_len;
         }
         octstr_destroy(h);
         return;
     }
 
     h = http_header_find_first(ent->headers, "Content-Length");
     if (h != NULL) {
         if (octstr_parse_long(&ent->expected_body_len, h, 0, 10) == -1 ||
             ent->expected_body_len < 0) {
             error(0, "HTTP: Content-Length header wrong: <%s>",
                   octstr_get_cstr(h));
             ent->state = body_error;
         } else if (ent->expected_body_len == 0) {
             ent->state = entity_done;
         } else {
             ent->state = reading_body_with_length;
         }
         octstr_destroy(h);
         return;
     }
 
     if (ent->expect_state == expect_body)
         ent->state = reading_body_until_eof;
     else
         ent->state = entity_done;
 }

◆ destroy_int_pointer()

static void destroy_int_pointer ( void * p )

static

Definition at line 2792 of file http.c.

Referenced by server_shutdown().

 {
     (void) close(*(int *) p);
     gw_free(p);
 }

◆ destroy_struct_server()

static void destroy_struct_server ( void * p )

static

Definition at line 2782 of file http.c.

References port::fd, port::port, and port_remove().

Referenced by server_shutdown().

 {
     struct port *pp;
     
     pp = p;
     (void) close(pp->fd);
     port_remove(pp->port);
 }

◆ entity_create()

static HTTPEntity* entity_create ( enum body_expectation exp )

static

Definition at line 429 of file http.c.

References HTTPEntity::body, HTTPEntity::chunked_body_chunk_len, HTTPEntity::expect_state, HTTPEntity::expected_body_len, HTTPEntity::headers, http_create_empty_headers(), octstr_create, reading_headers, and HTTPEntity::state.

Referenced by handle_transaction(), and receive_request().

 {
     HTTPEntity *ent;
 
     ent = gw_malloc(sizeof(*ent));
     ent->headers = http_create_empty_headers();
     ent->body = octstr_create("");
     ent->chunked_body_chunk_len = -1;
     ent->expected_body_len = -1;
     ent->state = reading_headers;
     ent->expect_state = exp;
 
     return ent;
 }

◆ entity_destroy()

static void entity_destroy ( HTTPEntity * ent )

static

Definition at line 445 of file http.c.

References HTTPEntity::body, HTTPEntity::headers, http_destroy_headers(), and octstr_destroy().

Referenced by client_destroy(), handle_transaction(), http_accept_request(), and server_destroy().

 {
     if (ent == NULL)
         return;
 
     http_destroy_headers(ent->headers);
     octstr_destroy(ent->body);
     gw_free(ent);
 }

◆ entity_read()

static int entity_read	(	HTTPEntity *	ent,
		Connection *	conn
	)

static

Definition at line 560 of file http.c.

References body_error, deduce_body_state(), entity_done, HTTPEntity::headers, panic, read_body_until_eof(), read_body_with_length(), read_chunked_body_crlf(), read_chunked_body_data(), read_chunked_body_len(), read_chunked_body_trailer(), read_some_headers(), reading_body_until_eof, reading_body_with_length, reading_chunked_body_crlf, reading_chunked_body_data, reading_chunked_body_len, reading_chunked_body_trailer, reading_headers, and HTTPEntity::state.

Referenced by handle_transaction(), and receive_request().

 {
     int ret;
     enum entity_state old_state;
 
     /*
      * In this loop, each state will process as much input as it needs
      * and then switch to the next state, unless it's a final state in
      * which case it returns directly, or unless it needs more input.
      * So keep looping as long as the state changes.
      */
     do {
         old_state = ent->state;
         switch (ent->state) {
         case reading_headers:
             ret = read_some_headers(conn, ent->headers);
                 if (ret == 0)
                 deduce_body_state(ent);
             if (ret < 0)
             return -1;
             break;
 
         case reading_chunked_body_len:
             read_chunked_body_len(ent, conn);
             break;
 
         case reading_chunked_body_data:
             read_chunked_body_data(ent, conn);
             break;
 
         case reading_chunked_body_crlf:
             read_chunked_body_crlf(ent, conn);
             break;
 
         case reading_chunked_body_trailer:
             read_chunked_body_trailer(ent, conn);
             break;
 
         case reading_body_until_eof:
             read_body_until_eof(ent, conn);
             break;
 
         case reading_body_with_length:
             read_body_with_length(ent, conn);
             break;
 
         case body_error:
             return -1;
 
         case entity_done:
             return 0;
 
         default:
             panic(0, "Internal error: Invalid HTTPEntity state.");
         }
     } while (ent->state != old_state);
 
     /*
      * If we got here, then the loop ended because a non-final state
      * needed more input.
      */
     return 1;
 }

◆ get_connection()

static Connection* get_connection ( HTTPServer * trans )

static

Definition at line 1567 of file http.c.

References HTTPServer::certkeyfile, conn_destroy(), conn_pool_get(), error(), host, HTTPServer::host, http_interface, http_urlparse_destroy(), octstr_get_cstr, parse2trans(), parse_url(), port, HTTPServer::port, proxy_hostname, proxy_port, proxy_ssl, proxy_used_for_host(), ssl, HTTPServer::ssl, and HTTPServer::url.

Referenced by write_request_thread().

 {
     Connection *conn = NULL;
     Octstr *host;
     HTTPURLParse *p;
     int port, ssl;
     
     /* if the parsing has not yet been done, then do it now */
     if (!trans->host && trans->port == 0 && trans->url != NULL) {
         if ((p = parse_url(trans->url)) != NULL) {
             parse2trans(p, trans);
             http_urlparse_destroy(p);
         } else {
             goto error;
         }
     }
 
     if (proxy_used_for_host(trans->host, trans->url)) {
         host = proxy_hostname;
         port = proxy_port;
         ssl = proxy_ssl;
     } else {
         host = trans->host;
         port = trans->port;
         ssl = trans->ssl;
     }
 
     conn = conn_pool_get(host, port, ssl, trans->certkeyfile,
                          http_interface);
     if (conn == NULL)
         goto error;
 
     return conn;
 
 error:
     conn_destroy(conn);
     error(0, "Couldn't send request to <%s>", octstr_get_cstr(trans->url));
     return NULL;
 }

◆ get_redirection_location()

static Octstr* get_redirection_location ( HTTPServer * trans )

static

Definition at line 919 of file http.c.

References HTTPServer::follow_remaining, HTTPEntity::headers, HTTP_FOUND, http_header_find_first, HTTP_MOVED_PERMANENTLY, HTTP_SEE_OTHER, HTTP_TEMPORARY_REDIRECT, HTTPServer::response, and HTTPServer::status.

Referenced by handle_transaction().

 {
     if (trans->status < 0 || trans->follow_remaining <= 0)
         return NULL;
     /* check for the redirection response codes */
     if (trans->status != HTTP_MOVED_PERMANENTLY &&
         trans->status != HTTP_FOUND && trans->status != HTTP_SEE_OTHER &&
         trans->status != HTTP_TEMPORARY_REDIRECT)
     return NULL;
     if (trans->response == NULL)
         return NULL;
     return http_header_find_first(trans->response->headers, "Location");
 }

◆ handle_transaction()

static void handle_transaction	(	Connection *	conn,
		void *	data
	)

static

Definition at line 1038 of file http.c.

References HTTPEntity::body, build_response(), HTTPServer::caller, HTTPServer::certkeyfile, client_read_status(), HTTPServer::conn, conn_destroy(), conn_get_connect_result(), conn_unregister(), debug(), entity_create(), entity_destroy(), entity_read(), error(), HTTPServer::follow_remaining, get_redirection_location(), gw_assert(), gwlist_insert(), gwlist_produce(), HTTPEntity::headers, HTTPServer::host, http_header_find_first, http_interface, http_status_class(), HTTP_STATUS_PROVISIONAL, HTTPServer::method, octstr_case_compare(), octstr_destroy(), octstr_dump, octstr_get_cstr, octstr_imm(), octstr_strip_blanks(), panic, HTTPServer::password, pending_requests, HTTPServer::persistent, HTTPServer::port, proxy_hostname, proxy_port, proxy_used_for_host(), recover_absolute_uri(), HTTPServer::response, response_expectation(), run_status, running, send_request(), HTTPServer::ssl, HTTPServer::state, HTTPServer::status, HTTPServer::uri, HTTPServer::url, and HTTPServer::username.

Referenced by write_request_thread().

 {
     HTTPServer *trans;
     int ret;
     Octstr *h;
     int rc;
     
     trans = data;
 
     gw_assert(trans->conn == conn);
 
     if (run_status != running) {
         conn_unregister(trans->conn);
         return;
     }
 
     while (trans->state != transaction_done) {
         switch (trans->state) {
         case connecting:
             debug("gwlib.http", 0, "Get info about connecting socket");
             if (conn_get_connect_result(trans->conn) != 0) {
                 debug("gwlib.http", 0, "Socket not connected");
                 goto error;
             }
 
             if ((rc = send_request(trans)) == 0) {
                 trans->state = reading_status;
             } else {
                 debug("gwlib.http", 0, "Failed while sending request");
                 goto error;
             }
             break;
 
         case reading_status:
             ret = client_read_status(trans);
             if (ret < 0) {
                 /*
                  * Couldn't read the status from the socket. This may mean
                  * that the socket had been closed by the server after an
                  * idle timeout.
                  */
                 debug("gwlib.http",0,"Failed while reading status");
                 goto error;
             } else if (ret == 0) {
                 /* Got the status, go read headers and body next. */
                 trans->state = reading_entity;
                 trans->response = entity_create(response_expectation(trans->method, trans->status));
             } else {
                 return;
             }
             break;
 
         case reading_entity:
             ret = entity_read(trans->response, trans->conn);
             if (ret < 0) {
                 debug("gwlib.http",0,"Failed reading entity");
                 goto error;
             } else if (ret == 0 &&
                        http_status_class(trans->status) == HTTP_STATUS_PROVISIONAL) {
                 /* This was a provisional reply; get the real one now. */
                 trans->state = reading_status;
                 entity_destroy(trans->response);
                 trans->response = NULL;
             } else if (ret == 0) {
                 trans->state = transaction_done;
 #ifdef DUMP_RESPONSE
                 /* Dump the response */
                 debug("gwlib.http", 0, "HTTP: Received response:");
                 h = build_response(trans->response->headers, trans->response->body);
                 octstr_dump(h, 0);
                 octstr_destroy(h);
 #endif
             } else {
                 return;
             }
             break;
 
         default:
             panic(0, "Internal error: Invalid HTTPServer state.");
         }
     }
 
     /*
      * Connection may have been destroyed within send_request,
      * so be more carefull here not to panic.
      */
     if (trans->conn)
         conn_unregister(trans->conn);
 
     /* 
      * Take care of persistent connection handling. 
      * At this point we have only obeyed if server responds in HTTP/1.0 or 1.1
      * and have assigned trans->persistent accordingly. This can be keept
      * for default usage, but if we have [Proxy-]Connection: keep-alive, then
      * we're still forcing persistancy of the connection.
      */
     h = http_header_find_first(trans->response->headers, "Connection");
     if (h != NULL && octstr_case_compare(h, octstr_imm("close")) == 0)
         trans->persistent = 0;
     if (h != NULL && octstr_case_compare(h, octstr_imm("keep-alive")) == 0)
         trans->persistent = 1;
     octstr_destroy(h);
     if (proxy_used_for_host(trans->host, trans->url)) {
         h = http_header_find_first(trans->response->headers, "Proxy-Connection");
         if (h != NULL && octstr_case_compare(h, octstr_imm("close")) == 0)
             trans->persistent = 0;
         if (h != NULL && octstr_case_compare(h, octstr_imm("keep-alive")) == 0)
             trans->persistent = 1;
         octstr_destroy(h);
     }
 
 #ifdef USE_KEEPALIVE 
     if (trans->persistent) {
         if (proxy_used_for_host(trans->host, trans->url))
             conn_pool_put(trans->conn, proxy_hostname, proxy_port, trans->ssl, trans->certkeyfile, http_interface);
         else 
             conn_pool_put(trans->conn, trans->host, trans->port, trans->ssl, trans->certkeyfile, http_interface);
     } else
 #endif
         conn_destroy(trans->conn);
 
     trans->conn = NULL;
 
     /* 
      * Check if the HTTP server told us to look somewhere else,
      * hence if we got one of the following response codes:
      *   HTTP_MOVED_PERMANENTLY (301)
      *   HTTP_FOUND (302)
      *   HTTP_SEE_OTHER (303)
      *   HTTP_TEMPORARY_REDIRECT (307)
      */
     if ((h = get_redirection_location(trans)) != NULL) {
 
         /* 
          * This is a redirected response, we have to follow.
          * 
          * According to HTTP/1.1 (RFC 2616), section 14.30 any Location
          * header value should be 'absoluteURI', which is defined in
          * RFC 2616, section 3.2.1 General Syntax, and specifically in
          * RFC 2396, section 3 URI Syntactic Components as
          * 
          *   absoluteURI   = scheme ":" ( hier_part | opaque_part )
          * 
          * Some HTTP servers 'interpret' a leading UDI / as that kind
          * of absoluteURI, which is not correct, following the protocol in
          * detail. But we'll try to recover from that misleaded 
          * interpreation and try to convert the partly absoluteURI to a
          * fully qualified absoluteURI.
          * 
          *   http_URL = "http:" "//" [ userid : password "@"] host 
          *      [ ":" port ] [ abs_path [ "?" query ]] 
          * 
          */
         octstr_strip_blanks(h);
         recover_absolute_uri(trans, h);
         
         /*
          * Clean up all trans stuff for the next request we do.
          */
         octstr_destroy(trans->url);
         octstr_destroy(trans->host);
         trans->port = 0;
         octstr_destroy(trans->uri);
         octstr_destroy(trans->username);
         octstr_destroy(trans->password);
         trans->host = NULL;
         trans->port = 0;
         trans->uri = NULL;
         trans->username = NULL;
         trans->password = NULL;
         trans->ssl = 0;
         trans->url = h; /* apply new absolute URL to next request */
         trans->state = request_not_sent;
         trans->status = -1;
         entity_destroy(trans->response);
         trans->response = NULL;
         --trans->follow_remaining;
         conn_destroy(trans->conn);
         trans->conn = NULL;
 
         /* re-inject request to the front of the queue */
         gwlist_insert(pending_requests, 0, trans);
 
     } else {
         /* handle this response as usual */
         gwlist_produce(trans->caller, trans);
     }
     return;
 
 error:
     if (trans->conn != NULL) {
         conn_unregister(trans->conn);
         conn_destroy(trans->conn);
         trans->conn = NULL;
     }
     error(0, "Couldn't fetch <%s>", octstr_get_cstr(trans->url));
     trans->status = -1;
     gwlist_produce(trans->caller, trans);
 }

◆ header_is_called()

static int header_is_called	(	Octstr *	header,
		char *	name
	)

static

Definition at line 2859 of file http.c.

References colon, name, octstr_get_cstr, and octstr_search_char().

Referenced by build_request(), http_header_find_all(), http_header_find_first_real(), and http_header_remove_all().

 {
     long colon;
 
     colon = octstr_search_char(header, ':', 0);
     if (colon == -1)
         return 0;
     if ((long) strlen(name) != colon)
         return 0;
     return strncasecmp(octstr_get_cstr(header), name, colon) == 0;
 }

◆ 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_add_element()

static void http_header_add_element	(	List *	list,
		Octstr *	value,
		long	start,
		long	end
	)

static

Definition at line 3279 of file http.c.

References gwlist_append(), octstr_copy, octstr_destroy(), octstr_len(), octstr_strip_blanks(), and start.

Referenced by http_header_split_value().

 {
     Octstr *element;
 
     element = octstr_copy(value, start, end - start);
     octstr_strip_blanks(element);
     if (octstr_len(element) == 0)
     octstr_destroy(element);
     else
         gwlist_append(list, element);
 }

◆ 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	start
	)

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 *	name
	)

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_reason_phrase()

static const char* http_reason_phrase ( int status )

static

Definition at line 2645 of file http.c.

References HTTP_ACCEPTED, HTTP_BAD_GATEWAY, HTTP_BAD_METHOD, HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_FORBIDDEN, HTTP_FOUND, HTTP_INTERNAL_SERVER_ERROR, HTTP_MOVED_PERMANENTLY, HTTP_NO_CONTENT, HTTP_NOT_ACCEPTABLE, HTTP_NOT_FOUND, HTTP_NOT_IMPLEMENTED, HTTP_NOT_MODIFIED, HTTP_OK, HTTP_REQUEST_ENTITY_TOO_LARGE, HTTP_RESET_CONTENT, HTTP_SEE_OTHER, HTTP_TEMPORARY_REDIRECT, HTTP_UNAUTHORIZED, and HTTP_UNSUPPORTED_MEDIA_TYPE.

Referenced by http_send_reply().

 {
     switch (status) {
     case HTTP_OK:
         return "OK";                        /* 200 */
     case HTTP_CREATED:                   
         return "Created";                   /* 201 */
     case HTTP_ACCEPTED:
         return "Accepted";                  /* 202 */
     case HTTP_NO_CONTENT:
         return "No Content";                /* 204 */
     case HTTP_RESET_CONTENT: 
         return "Reset Content";             /* 205 */
     case HTTP_MOVED_PERMANENTLY:
         return "Moved Permanently";         /* 301 */
     case HTTP_FOUND:
         return "Found";                     /* 302 */
     case HTTP_SEE_OTHER:
         return "See Other";                 /* 303 */
     case HTTP_NOT_MODIFIED:
         return "Not Modified";              /* 304 */
     case HTTP_TEMPORARY_REDIRECT:
         return "Temporary Redirect";        /* 307 */
     case HTTP_BAD_REQUEST:
         return "Bad Request";               /* 400 */
     case HTTP_UNAUTHORIZED:
         return "Unauthorized";              /* 401 */
     case HTTP_FORBIDDEN:
         return "Forbidden";                 /* 403 */
     case HTTP_NOT_FOUND:            
         return "Not Found";                 /* 404 */
     case HTTP_BAD_METHOD:
         return "Method Not Allowed";        /* 405 */
     case HTTP_NOT_ACCEPTABLE:
         return "Not Acceptable";            /* 406 */
     case HTTP_REQUEST_ENTITY_TOO_LARGE:
         return "Request Entity Too Large";  /* 413 */
     case HTTP_UNSUPPORTED_MEDIA_TYPE:
         return "Unsupported Media Type";    /* 415 */
     case HTTP_INTERNAL_SERVER_ERROR:
         return "Internal Server Error";     /* 500 */
     case HTTP_NOT_IMPLEMENTED:
         return "Not Implemented";           /* 501 */
     case HTTP_BAD_GATEWAY:
         return "Bad Gateway";               /* 502 */
     }
     return "Foo";
 }

◆ 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_something_accepted()

static int http_something_accepted	(	List *	headers,
		char *	header_name,
		char *	what
	)

static

Definition at line 3476 of file http.c.

References found, gw_assert(), gwlib_assert_init(), gwlist_get(), gwlist_len(), http_destroy_headers(), http_header_find_all(), octstr_case_search(), octstr_create, and octstr_destroy().

Referenced by http_charset_accepted(), and http_type_accepted().

 {
     int found;
     long i;
     List *accepts;
     Octstr *needle = octstr_create(what);
 
     gwlib_assert_init();
     gw_assert(headers != NULL);
     gw_assert(what != NULL);
 
     /* return all headers with this name */
     accepts = http_header_find_all(headers, header_name);
 
     found = 0;
     for (i = 0; !found && i < gwlist_len(accepts); ++i) {
         Octstr *header_value = gwlist_get(accepts, i);
         if (octstr_case_search(header_value, needle, 0) != -1)
             found = 1;
     }
     octstr_destroy(needle);
     http_destroy_headers(accepts);
     return found;
 }

◆ 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);
 }

◆ parse2trans()

static void parse2trans	(	HTTPURLParse *	p,
		HTTPServer *	t
	)

static

Definition at line 1543 of file http.c.

References HTTPURLParse::host, HTTPServer::host, octstr_append(), octstr_append_char(), octstr_compare(), octstr_duplicate, octstr_imm(), HTTPURLParse::pass, HTTPServer::password, HTTPURLParse::path, HTTPURLParse::port, HTTPServer::port, HTTPURLParse::query, HTTPURLParse::scheme, HTTPServer::ssl, HTTPServer::uri, HTTPURLParse::user, and HTTPServer::username.

Referenced by get_connection().

 {
     if (p == NULL || t == NULL)
         return;
 
     if (p->user && !t->username)
         t->username = octstr_duplicate(p->user);
     if (p->pass && !t->password)
         t->password = octstr_duplicate(p->pass);
     if (p->host && !t->host) 
         t->host = octstr_duplicate(p->host);
     if (p->port && !t->port)
         t->port = p->port;
     if (p->path && !t->uri) {
         t->uri = octstr_duplicate(p->path);
         if (p->query) { /* add the query too */
             octstr_append_char(t->uri, '?');
             octstr_append(t->uri, p->query);
         }
     }
     t->ssl = (p->scheme && (octstr_compare(p->scheme, octstr_imm("https://")) == 0) 
               && !t->ssl) ? 1 : 0;
 }

◆ 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_http_version()

static int parse_http_version ( Octstr * version )

static

Definition at line 168 of file http.c.

References octstr_get_char(), octstr_imm(), octstr_len(), and octstr_ncompare().

Referenced by client_read_status(), and parse_request_line().

 {
     Octstr *prefix;
     long prefix_len;
     int digit;
     
     prefix = octstr_imm("HTTP/1.");
     prefix_len = octstr_len(prefix);
 
     if (octstr_ncompare(version, prefix, prefix_len) != 0)
         return -1;
     if (octstr_len(version) != prefix_len + 1)
         return -1;
     digit = octstr_get_char(version, prefix_len);
     if (!isdigit(digit))
         return -1;
     if (digit == '0')
         return 0;
     return 1;
 }

◆ parse_request_line()

static int parse_request_line	(	int *	method,
		Octstr **	url,
		int *	use_version_1_0,
		Octstr *	line
	)

static

Definition at line 2210 of file http.c.

References error(), gwlist_destroy(), gwlist_get(), gwlist_len(), http_name2method(), method, octstr_destroy(), octstr_destroy_item(), octstr_split_words(), parse_http_version(), and url.

Referenced by receive_request().

 {
     List *words;
     Octstr *version;
     Octstr *method_str;
     int ret;
 
     words = octstr_split_words(line);
     if (gwlist_len(words) != 3) {
         gwlist_destroy(words, octstr_destroy_item);
         return -1;
     }
 
     method_str = gwlist_get(words, 0);
     *url = gwlist_get(words, 1);
     version = gwlist_get(words, 2);
     gwlist_destroy(words, NULL);
 
     *method = http_name2method(method_str);
     if (*method == -1)
         goto error;
 
     ret = parse_http_version(version);
     if (ret < 0)
         goto error;
     *use_version_1_0 = !ret;
 
     octstr_destroy(method_str);
     octstr_destroy(version);
     return 0;
 
 error:
     octstr_destroy(method_str);
     octstr_destroy(*url);
     octstr_destroy(version);
     *url = NULL;
     return -1;
 }

◆ 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;
 }

◆ port_add()

static struct port* port_add ( int port )

static

Definition at line 2057 of file http.c.

References port::active_consumers, port::clients_with_requests, counter_create(), dict_get(), dict_put(), fdset_create_real(), gwlist_add_producer(), gwlist_create, HTTP_SERVER_TIMEOUT, mutex_lock, mutex_unlock, octstr_destroy(), port_collection, port_key(), port_mutex, port::server_fdset, and warning().

Referenced by http_open_port_if().

 {
     Octstr *key;
     struct port *p;
 
     key = port_key(port);
     mutex_lock(port_mutex);
     if ((p = dict_get(port_collection, key)) == NULL) {
         p = gw_malloc(sizeof(*p));
         p->clients_with_requests = gwlist_create();
         gwlist_add_producer(p->clients_with_requests);
         p->active_consumers = counter_create();
         p->server_fdset = fdset_create_real(HTTP_SERVER_TIMEOUT);
         dict_put(port_collection, key, p);
     } else {
         warning(0, "HTTP: port_add called for existing port (%d)", port);
     }
     mutex_unlock(port_mutex);
     octstr_destroy(key);
 
     return p;
 }

◆ port_get_fdset()

static FDSet* port_get_fdset ( int port )

static

Definition at line 2190 of file http.c.

References dict_get(), mutex_lock, mutex_unlock, octstr_destroy(), port_collection, port_key(), port_mutex, and port::server_fdset.

Referenced by http_send_reply().

 {
     Octstr *key;
     struct port *p;
     FDSet *ret = NULL;
 
     mutex_lock(port_mutex);
     key = port_key(port);
     p = dict_get(port_collection, key);
     octstr_destroy(key);
 
     if (p != NULL)
         ret = p->server_fdset;
 
     mutex_unlock(port_mutex);
 
     return ret;
 }

◆ port_get_request()

static HTTPClient* port_get_request ( int port )

static

Definition at line 2149 of file http.c.

References port::active_consumers, client(), port::clients_with_requests, counter_decrease(), counter_increase(), dict_get(), gwlist_consume(), mutex_lock, mutex_unlock, octstr_destroy(), port_collection, port_key(), and port_mutex.

Referenced by http_accept_request().

 {
     Octstr *key;
     struct port *p;
     HTTPClient *client;
     
     mutex_lock(port_mutex);
     key = port_key(port);
     p = dict_get(port_collection, key);
     octstr_destroy(key);
 
     if (p == NULL) {
        client = NULL;
        mutex_unlock(port_mutex);
     } else {
        counter_increase(p->active_consumers);
        mutex_unlock(port_mutex);   /* Placement of this unlock is tricky. */
        client = gwlist_consume(p->clients_with_requests);
        counter_decrease(p->active_consumers);
     }
     return client;
 }

◆ port_init()

static void port_init ( void )

static

Definition at line 2034 of file http.c.

References active_connections, dict_create(), gwlist_create, mutex_create, port_collection, and port_mutex.

Referenced by http_init().

 {
     port_mutex = mutex_create();
     port_collection = dict_create(1024, NULL);
     /* create list with all active_connections */
     active_connections = gwlist_create();
 }

◆ port_key()

static Octstr* port_key ( int port )

static

Definition at line 2051 of file http.c.

References octstr_format().

Referenced by port_add(), port_get_fdset(), port_get_request(), port_put_request(), port_remove(), and port_set_timeout().

 {
     return octstr_format("%d", port);
 }

◆ port_match()

static int port_match	(	void *	client,
		void *	port
	)

static

Definition at line 2028 of file http.c.

References client().

Referenced by port_remove().

 {
     return ((HTTPClient*)client)->port == *((int*)port);
 }

◆ port_put_request()

static void port_put_request ( HTTPClient * client )

static

Definition at line 2129 of file http.c.

References client(), client_destroy(), port::clients_with_requests, dict_get(), gwlist_produce(), mutex_lock, mutex_unlock, octstr_destroy(), port_collection, port_key(), and port_mutex.

Referenced by receive_request().

 {
     Octstr *key;
     struct port *p;
 
     mutex_lock(port_mutex);
     key = port_key(client->port);
     p = dict_get(port_collection, key);
     octstr_destroy(key);
     if (p == NULL) {
         /* client was too slow and we closed port already */
         mutex_unlock(port_mutex);
         client_destroy(client);
         return;
     }
     gwlist_produce(p->clients_with_requests, client);
     mutex_unlock(port_mutex);
 }

◆ port_remove()

static void port_remove ( int port )

static

Definition at line 2081 of file http.c.

References active_connections, port::active_consumers, client(), client_destroy(), port::clients_with_requests, conn_unregister(), counter_destroy(), counter_value(), dict_remove(), error(), fdset_destroy(), gwlist_destroy(), gwlist_extract_first(), gwlist_lock(), gwlist_remove_producer(), gwlist_search(), gwlist_search_all(), gwlist_unlock(), gwthread_sleep(), mutex_lock, mutex_unlock, octstr_destroy(), port_collection, port_key(), port_match(), port_mutex, and port::server_fdset.

Referenced by destroy_struct_server(), http_open_port_if(), and server_thread().

 {
     Octstr *key;
     struct port *p;
     List *l;
     HTTPClient *client;
 
     key = port_key(port);
     mutex_lock(port_mutex);
     p = dict_remove(port_collection, key);
     mutex_unlock(port_mutex);
     octstr_destroy(key);
     
     if (p == NULL) {
         error(0, "HTTP: Could not find port (%d) in port_collection.", port);
         return;
     }
 
     gwlist_remove_producer(p->clients_with_requests);
     while (counter_value(p->active_consumers) > 0)
        gwthread_sleep(0.1);    /* Reasonable use of busy waiting. */
 
     gwlist_destroy(p->clients_with_requests, client_destroy);
     counter_destroy(p->active_consumers);
 
     /*
      * In order to avoid race conditions with FDSet thread, we
      * destroy Clients for this port in two steps:
      * 1) unregister from fdset with gwlist_lock held, so client_destroy
      *    cannot destroy our client that we currently use
      * 2) without gwlist_lock held destroy every client, we can do this
      *    because we only one thread that can use this client struct
      */
     gwlist_lock(active_connections);
     l = gwlist_search_all(active_connections, &port, port_match);
     while(l != NULL && (client = gwlist_extract_first(l)) != NULL)
         conn_unregister(client->conn);
     gwlist_unlock(active_connections);
     gwlist_destroy(l, NULL);
     while((client = gwlist_search(active_connections, &port, port_match)) != NULL)
         client_destroy(client);
 
     /* now destroy fdset */
     fdset_destroy(p->server_fdset);
     gw_free(p);
 }

◆ port_set_timeout()

static void port_set_timeout	(	int	port,
		long	timeout
	)

static

Definition at line 2173 of file http.c.

References dict_get(), fdset_set_timeout(), mutex_lock, mutex_unlock, octstr_destroy(), port_collection, port_key(), port_mutex, and port::server_fdset.

Referenced by http_set_server_timeout().

 {
     Octstr *key;
     struct port *p;
 
     mutex_lock(port_mutex);
     key = port_key(port);
     p = dict_get(port_collection, key);
     octstr_destroy(key);
 
     if (p != NULL)
         fdset_set_timeout(p->server_fdset, timeout);
 
     mutex_unlock(port_mutex);
 }

◆ port_shutdown()

static void port_shutdown ( void )

static

Definition at line 2042 of file http.c.

References active_connections, client_destroy(), dict_destroy(), gwlist_destroy(), mutex_destroy(), port_collection, and port_mutex.

Referenced by http_shutdown().

 {
     mutex_destroy(port_mutex);
     dict_destroy(port_collection);
     /* destroy active_connections list */
     gwlist_destroy(active_connections, client_destroy);
 }

◆ proxy_add_authentication()

static void proxy_add_authentication ( List * headers )

static

Definition at line 209 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(), proxy_password, and proxy_username.

Referenced by send_request().

 {
     Octstr *os;
     
     if (proxy_username == NULL || proxy_password == NULL)
         return;
 
     os = octstr_format("%S:%S", proxy_username, proxy_password);
     octstr_binary_to_base64(os);
     octstr_strip_blanks(os);
     octstr_insert(os, octstr_imm("Basic "), 0);
     http_header_add(headers, "Proxy-Authorization", octstr_get_cstr(os));
     octstr_destroy(os);
 }

◆ proxy_init()

static void proxy_init ( void )

static

Definition at line 225 of file http.c.

References gwlist_create, mutex_create, proxy_exceptions, and proxy_mutex.

Referenced by http_init().

 {
     proxy_mutex = mutex_create();
     proxy_exceptions = gwlist_create();
 }

◆ proxy_shutdown()

static void proxy_shutdown ( void )

static

Definition at line 232 of file http.c.

References http_close_proxy(), mutex_destroy(), and proxy_mutex.

Referenced by http_shutdown().

 {
     http_close_proxy();
     mutex_destroy(proxy_mutex);
     proxy_mutex = NULL;
 }

◆ proxy_used_for_host()

static int proxy_used_for_host	(	Octstr *	host,
		Octstr *	url
	)

static

Definition at line 240 of file http.c.

References gwlist_get(), gwlist_len(), host, mutex_lock, mutex_unlock, octstr_compare(), proxy_exceptions, proxy_exceptions_regex, proxy_hostname, proxy_mutex, and url.

Referenced by get_connection(), handle_transaction(), and send_request().

 {
     int i;
 
     mutex_lock(proxy_mutex);
 
     if (proxy_hostname == NULL) {
         mutex_unlock(proxy_mutex);
         return 0;
     }
 
     for (i = 0; i < gwlist_len(proxy_exceptions); ++i) {
         if (octstr_compare(host, gwlist_get(proxy_exceptions, i)) == 0) {
             mutex_unlock(proxy_mutex);
             return 0;
         }
     }
 
     if (proxy_exceptions_regex != NULL && gw_regex_match_pre(proxy_exceptions_regex, url)) {
             mutex_unlock(proxy_mutex);
             return 0;
     }
 
     mutex_unlock(proxy_mutex);
     return 1;
 }

◆ read_body_until_eof()

static void read_body_until_eof	(	HTTPEntity *	ent,
		Connection *	conn
	)

static

Definition at line 525 of file http.c.

References HTTPEntity::body, body_error, conn_eof(), conn_error(), conn_read_everything(), entity_done, octstr_append(), octstr_destroy(), and HTTPEntity::state.

Referenced by entity_read().

 {
     Octstr *os;
 
     while ((os = conn_read_everything(conn)) != NULL) {
         octstr_append(ent->body, os);
         octstr_destroy(os);
     }
     if (conn_error(conn))
     ent->state = body_error;
     if (conn_eof(conn))
     ent->state = entity_done;
 }

◆ read_body_with_length()

static void read_body_with_length	(	HTTPEntity *	ent,
		Connection *	conn
	)

static

Definition at line 540 of file http.c.

References HTTPEntity::body, body_error, conn_eof(), conn_error(), conn_read_fixed(), entity_done, HTTPEntity::expected_body_len, octstr_destroy(), and HTTPEntity::state.

Referenced by entity_read().

 {
     Octstr *os;
 
     os = conn_read_fixed(conn, ent->expected_body_len);
     if (os == NULL) {
         if (conn_error(conn) || conn_eof(conn))
             ent->state = body_error;
         return;
     }
     octstr_destroy(ent->body);
     ent->body = os;
     ent->state = entity_done;
 }

◆ read_chunked_body_crlf()

static void read_chunked_body_crlf	(	HTTPEntity *	ent,
		Connection *	conn
	)

static

Definition at line 498 of file http.c.

References body_error, conn_eof(), conn_error(), conn_read_line(), octstr_destroy(), reading_chunked_body_len, and HTTPEntity::state.

Referenced by entity_read().

 {
     Octstr *os;
 
     os = conn_read_line(conn);
     if (os == NULL) {
         if (conn_error(conn) || conn_eof(conn))
         ent->state = body_error;
     } else {
         octstr_destroy(os);
         ent->state = reading_chunked_body_len;
     }
 }

◆ read_chunked_body_data()

static void read_chunked_body_data	(	HTTPEntity *	ent,
		Connection *	conn
	)

static

Definition at line 482 of file http.c.

References HTTPEntity::body, body_error, HTTPEntity::chunked_body_chunk_len, conn_eof(), conn_error(), conn_read_fixed(), octstr_append(), octstr_destroy(), reading_chunked_body_crlf, and HTTPEntity::state.

Referenced by entity_read().

 {
     Octstr *os;
 
     os = conn_read_fixed(conn, ent->chunked_body_chunk_len);
     if (os == NULL) {
         if (conn_error(conn) || conn_eof(conn))
         ent->state = body_error;
     } else {
         octstr_append(ent->body, os);
         octstr_destroy(os);
         ent->state = reading_chunked_body_crlf;
     }
 }

◆ read_chunked_body_len()

static void read_chunked_body_len	(	HTTPEntity *	ent,
		Connection *	conn
	)

static

Definition at line 456 of file http.c.

References body_error, HTTPEntity::chunked_body_chunk_len, conn_eof(), conn_error(), conn_read_line(), octstr_destroy(), octstr_parse_long(), reading_chunked_body_data, reading_chunked_body_trailer, and HTTPEntity::state.

Referenced by entity_read().

 {
     Octstr *os;
     long len;
     
     os = conn_read_line(conn);
     if (os == NULL) {
         if (conn_error(conn) || conn_eof(conn))
         ent->state = body_error;
         return;
     }
     if (octstr_parse_long(&len, os, 0, 16) == -1) {
         octstr_destroy(os);
     ent->state = body_error;
         return;
     }
     octstr_destroy(os);
     if (len == 0)
         ent->state = reading_chunked_body_trailer;
     else {
         ent->state = reading_chunked_body_data;
         ent->chunked_body_chunk_len = len;
     }
 }

◆ read_chunked_body_trailer()

static void read_chunked_body_trailer	(	HTTPEntity *	ent,
		Connection *	conn
	)

static

Definition at line 513 of file http.c.

References body_error, entity_done, HTTPEntity::headers, read_some_headers(), and HTTPEntity::state.

Referenced by entity_read().

 {
     int ret;
 
     ret = read_some_headers(conn, ent->headers);
     if (ret == -1)
     ent->state = body_error;
     if (ret == 0)
         ent->state = entity_done;
 }

◆ read_some_headers()

static int read_some_headers	(	Connection *	conn,
		List *	headers
	)

static

Definition at line 131 of file http.c.

References conn_eof(), conn_error(), conn_read_line(), gwlist_append(), gwlist_get(), gwlist_len(), octstr_append(), octstr_destroy(), octstr_get_char(), and octstr_len().

Referenced by entity_read(), and read_chunked_body_trailer().

 {
     Octstr *line, *prev;
 
     if (gwlist_len(headers) == 0)
         prev = NULL;
     else
         prev = gwlist_get(headers, gwlist_len(headers) - 1);
 
     for (;;) {
     line = conn_read_line(conn);
     if (line == NULL) {
             if (conn_eof(conn) || conn_error(conn))
             return -1;
         return 1;
     }
         if (octstr_len(line) == 0) {
             octstr_destroy(line);
             break;
         }
         if (isspace(octstr_get_char(line, 0)) && prev != NULL) {
             octstr_append(prev, line);
             octstr_destroy(line);
         } else {
             gwlist_append(headers, line);
             prev = line;
         }
     }
 
     return 0;
 }

◆ receive_request()

static void receive_request	(	Connection *	conn,
		void *	data
	)

static

Definition at line 2251 of file http.c.

References client(), client_destroy(), client_reset(), conn_eof(), conn_error(), conn_outbuf_len(), conn_read_line(), conn_unregister(), entity_create(), entity_read(), error(), expect_body_if_indicated, HTTP_BAD_REQUEST, http_send_reply(), octstr_destroy(), panic, parse_request_line(), port_put_request(), run_status, and running.

Referenced by http_send_reply(), and server_thread().

 {
     HTTPClient *client;
     Octstr *line;
     int ret;
 
     if (run_status != running) {
         conn_unregister(conn);
         return;
     }
 
     client = data;
     
     for (;;) {
         switch (client->state) {
             case reading_request_line:
                 line = conn_read_line(conn);
                 if (line == NULL) {
                     if (conn_eof(conn) || conn_error(conn))
                         goto error;
                     return;
                 }
                 ret = parse_request_line(&client->method, &client->url,
                                          &client->use_version_1_0, line);
                 octstr_destroy(line);
                 /* client sent bad request? */
                 if (ret == -1) {
                     /*
                      * mark client as not persistent in order to destroy connection
                      * afterwards
                      */
                     client->persistent_conn = 0;
                     /* unregister connection, http_send_reply handle this */
                     conn_unregister(conn);
                     http_send_reply(client, HTTP_BAD_REQUEST, NULL, NULL);
                     return;
                 }
                 /*
                  * RFC2616 (4.3) says we should read a message body if there
                  * is one, even on GET requests.
                  */
                 client->request = entity_create(expect_body_if_indicated);
                 client->state = reading_request;
                 break;
                 
             case reading_request:
                 ret = entity_read(client->request, conn);
                 if (ret < 0)
                     goto error;
                 if (ret == 0) {
                     client->state = request_is_being_handled;
                     conn_unregister(conn);
                     port_put_request(client);
                 }
                 return;
                 
             case sending_reply:
                 /* Implicit conn_unregister() and _destroy */
                 if (conn_error(conn))
                     goto error;
                 if (conn_outbuf_len(conn) > 0)
                     return;
                 /* Reply has been sent completely */
                 if (!client->persistent_conn) {
                     /*
                      * in order to avoid race conditions while conn will be destroyed but
                      * conn is still in use, we call conn_unregister explicit here because
                      * conn_unregister call uses locks
                      */
                     conn_unregister(conn);
                     client_destroy(client);
                     return;
                 }
                 /* Start reading another request */
                 client_reset(client);
                 break;
                 
             default:
                 panic(0, "Internal error: HTTPClient state is wrong.");
         }
     }
     
 error:
     /*
      * in order to avoid race conditions while conn will be destroyed but
      * conn is still in use, we call conn_unregister explicit here because
      * conn_unregister call uses locks
      */
     conn_unregister(conn);
     client_destroy(client);
 }

◆ recover_absolute_uri()

static void recover_absolute_uri	(	HTTPServer *	trans,
		Octstr *	loc
	)

static

Definition at line 941 of file http.c.

References gw_assert(), HTTPServer::host, octstr_append(), octstr_append_char(), octstr_create, octstr_destroy(), octstr_format_append(), octstr_get_char(), octstr_insert(), HTTPServer::password, HTTPServer::port, HTTPServer::ssl, and HTTPServer::username.

Referenced by handle_transaction().

 {
     Octstr *os;
     
     gw_assert(loc != NULL && trans != NULL);
     
     /* we'll only accept locations with a leading / */
     if (octstr_get_char(loc, 0) == '/') {
         
         /* scheme */
         os = trans->ssl ? octstr_create("https://") : 
             octstr_create("http://");
         
         /* credentials, if any */
         if (trans->username && trans->password) {
             octstr_append(os, trans->username);
             octstr_append_char(os, ':');
             octstr_append(os, trans->password);
             octstr_append_char(os, '@');
         }
         
         /* host */
         octstr_append(os, trans->host);
         
         /* port, only added if literally not default. */
         if (trans->port != 80 || trans->ssl) {
             octstr_format_append(os, ":%ld", trans->port);
         }
         
         /* prepend the created octstr to the loc, and destroy then. */
         octstr_insert(loc, os, 0);
         octstr_destroy(os);
     }
 }

◆ response_expectation()

static int response_expectation	(	int	method,
		int	status
	)

static

Definition at line 1027 of file http.c.

References expect_body, expect_no_body, HTTP_METHOD_DELETE, HTTP_METHOD_HEAD, HTTP_NO_CONTENT, HTTP_NOT_MODIFIED, http_status_class(), HTTP_STATUS_PROVISIONAL, and method.

Referenced by handle_transaction().

 {
     if (status == HTTP_NO_CONTENT ||
         status == HTTP_NOT_MODIFIED ||
         http_status_class(status) == HTTP_STATUS_PROVISIONAL ||
         method == HTTP_METHOD_HEAD || method == HTTP_METHOD_DELETE)
         return expect_no_body;
     else
         return expect_body;
 }

◆ send_request()

static int send_request ( HTTPServer * trans )

static

Definition at line 1611 of file http.c.

References build_request(), HTTPServer::conn, conn_destroy(), conn_write(), debug(), error(), HTTPServer::host, http_add_basic_auth(), http_header_add(), http_header_remove_all(), http_method2name(), HTTP_METHOD_PATCH, HTTP_METHOD_POST, HTTP_METHOD_PUT, HTTPServer::method, octstr_destroy(), octstr_dump, octstr_get_cstr, octstr_len(), HTTPServer::password, HTTPServer::port, proxy_add_authentication(), proxy_used_for_host(), HTTPServer::request_body, HTTPServer::request_headers, HTTPServer::ssl, HTTPServer::uri, HTTPServer::url, HTTPServer::username, and warning().

Referenced by handle_transaction(), and write_request_thread().

 {
     char buf[128];    
     Octstr *request = NULL;
 
     if (trans->method == HTTP_METHOD_POST || trans->method == HTTP_METHOD_PATCH || trans->method == HTTP_METHOD_PUT) {
         /* 
          * Add a Content-Length header.  Override an existing one, if
          * necessary.  We must have an accurate one in order to use the
          * connection for more than a single request.
          */
         http_header_remove_all(trans->request_headers, "Content-Length");
         snprintf(buf, sizeof(buf), "%ld", octstr_len(trans->request_body));
         http_header_add(trans->request_headers, "Content-Length", buf);
     } 
     /* 
      * ok, this has to be an GET or HEAD request method then,
      * if it contains a body, then this is not HTTP conform, so at
      * least warn the user 
      */
     else if (trans->request_body != NULL) {
         warning(0, "HTTP: GET or HEAD method request contains body:");
         octstr_dump(trans->request_body, 0);
     }
 
     /* 
      * we have to assume all values in trans are already set
      * by parse_url() before calling this.
      */
 
     if (trans->username != NULL)
         http_add_basic_auth(trans->request_headers, trans->username,
                             trans->password);
 
     if (proxy_used_for_host(trans->host, trans->url)) {
         proxy_add_authentication(trans->request_headers);
         request = build_request(http_method2name(trans->method), trans->url,
                                 trans->host, trans->port, trans->ssl,
                                 trans->request_headers, 
                                 trans->request_body);
     } else {
         request = build_request(http_method2name(trans->method), trans->uri, 
                                 trans->host, trans->port, trans->ssl,
                                 trans->request_headers,
                                 trans->request_body);
     }
   
     debug("gwlib.http", 0, "HTTP: Sending request:");
     octstr_dump(request, 0);
     if (conn_write(trans->conn, request) == -1)
         goto error;
 
     octstr_destroy(request);
 
     return 0;
 
 error:
     conn_destroy(trans->conn);
     trans->conn = NULL;
     octstr_destroy(request);
     error(0, "Couldn't send request to <%s>", octstr_get_cstr(trans->url));
     return -1;
 }

◆ server_create()

static HTTPServer* server_create	(	HTTPCaller *	caller,
		int	method,
		Octstr *	url,
		List *	headers,
		Octstr *	body,
		int	follow_remaining,
		Octstr *	certkeyfile
	)

static

Definition at line 700 of file http.c.

References caller, HTTPServer::caller, HTTPServer::certkeyfile, HTTPServer::conn, HTTPServer::follow_remaining, HTTPServer::host, http_header_duplicate(), method, HTTPServer::method, octstr_duplicate, HTTPServer::password, HTTPServer::persistent, HTTPServer::port, HTTPServer::request_body, HTTPServer::request_headers, HTTPServer::request_id, HTTPServer::response, HTTPServer::ssl, HTTPServer::state, HTTPServer::status, HTTPServer::uri, url, HTTPServer::url, and HTTPServer::username.

Referenced by http_start_request().

 {
     HTTPServer *trans;
     
     trans = gw_malloc(sizeof(*trans));
     trans->caller = caller;
     trans->request_id = NULL;
     trans->method = method;
     trans->url = octstr_duplicate(url);
     trans->uri = NULL;
     trans->request_headers = http_header_duplicate(headers);
     trans->request_body = octstr_duplicate(body);
     trans->state = request_not_sent;
     trans->status = -1;
     trans->persistent = 0;
     trans->response = NULL;
     trans->conn = NULL;
     trans->host = NULL;
     trans->port = 0;
     trans->username = NULL;
     trans->password = NULL;
     trans->follow_remaining = follow_remaining;
     trans->certkeyfile = octstr_duplicate(certkeyfile);
     trans->ssl = 0;
     return trans;
 }

◆ server_destroy()

static void server_destroy ( void * p )

static

Definition at line 730 of file http.c.

References HTTPServer::certkeyfile, entity_destroy(), HTTPServer::host, http_destroy_headers(), octstr_destroy(), HTTPServer::password, HTTPServer::request_body, HTTPServer::request_headers, HTTPServer::response, HTTPServer::uri, HTTPServer::url, and HTTPServer::username.

Referenced by client_shutdown(), http_caller_destroy(), and http_receive_result_real().

 {
     HTTPServer *trans;
     
     trans = p;
     octstr_destroy(trans->url);
     octstr_destroy(trans->uri);
     http_destroy_headers(trans->request_headers);
     trans->request_headers = NULL;
     octstr_destroy(trans->request_body);
     entity_destroy(trans->response);
     octstr_destroy(trans->host);
     octstr_destroy(trans->certkeyfile);
     octstr_destroy(trans->username);
     octstr_destroy(trans->password);
     gw_free(trans);
 }

◆ server_init()

static void server_init ( void )

static

Definition at line 2773 of file http.c.

References closed_server_sockets, gwlist_add_producer(), gwlist_create, mutex_create, new_server_sockets, and server_thread_lock.

Referenced by http_init().

 {
     new_server_sockets = gwlist_create();
     gwlist_add_producer(new_server_sockets);
     closed_server_sockets = gwlist_create();
     server_thread_lock = mutex_create();
 }

◆ server_shutdown()

static void server_shutdown ( void )

static

Definition at line 2799 of file http.c.

References closed_server_sockets, destroy_int_pointer(), destroy_struct_server(), gwlist_destroy(), gwlist_remove_producer(), gwthread_join_every(), gwthread_wakeup(), mutex_destroy(), new_server_sockets, server_thread(), server_thread_id, server_thread_is_running, and server_thread_lock.

Referenced by http_shutdown().

 {
     gwlist_remove_producer(new_server_sockets);
     if (server_thread_id != -1) {
         gwthread_wakeup(server_thread_id);
         gwthread_join_every(server_thread);
         server_thread_is_running = 0;
     }
     mutex_destroy(server_thread_lock);
     gwlist_destroy(new_server_sockets, destroy_struct_server);
     gwlist_destroy(closed_server_sockets, destroy_int_pointer);
 }

◆ server_thread()

static void server_thread ( void * dummy )

static

Definition at line 2344 of file http.c.

References active_connections, client(), client_create(), closed_server_sockets, conn_register, conn_wrap_fd(), debug(), error(), pollfd::events, pollfd::fd, port::fd, gwlist_consume(), gwlist_extract_first(), gwlist_len(), gwthread_poll(), gwthread_sleep(), host_ip(), HTTP_SERVER_MAX_ACTIVE_CONNECTIONS, keep_servers_open, new_server_sockets, octstr_destroy(), octstr_get_cstr, POLLIN, port::port, port_remove(), receive_request(), run_status, running, port::server_fdset, server_thread_id, ssl, and warning().

Referenced by http_close_all_ports(), server_shutdown(), and start_server_thread().

 {
     struct pollfd *tab = NULL;
     struct port **ports = NULL;
     int tab_size = 0, n, i, fd, ret, max_clients_reached;
     struct sockaddr_in addr;
     socklen_t addrlen;
     HTTPClient *client;
     Connection *conn;
     int *portno;
 
     n = max_clients_reached = 0;
     while (run_status == running && keep_servers_open) {
         while (n == 0 || gwlist_len(new_server_sockets) > 0) {
             struct port *p = gwlist_consume(new_server_sockets);
             if (p == NULL) {
                 debug("gwlib.http", 0, "HTTP: No new servers. Quitting.");
                 break;
             } else {
                 debug ("gwlib.http", 0, "HTTP: Including port %d, fd %d for polling in server thread", p->port, p->fd);
             }
             if (tab_size <= n) {
                 tab_size++;
                 tab = gw_realloc(tab, tab_size * sizeof(*tab));
                 ports = gw_realloc(ports, tab_size * sizeof(*ports));
                 if (tab == NULL || ports == NULL) {
                     tab_size--;
                     port_remove(p->port);
                     continue;
                 }
             }
             tab[n].fd = p->fd;
             tab[n].events = POLLIN;
             ports[n] = p;
             n++;
         }
 
         if (max_clients_reached && gwlist_len(active_connections) >= HTTP_SERVER_MAX_ACTIVE_CONNECTIONS) {
             /* TODO start cleanup of stale connections */
             /* wait for slots to become free */
             gwthread_sleep(1.0);
         } else if (!max_clients_reached && (ret = gwthread_poll(tab, n, -1.0)) == -1) {
             if (errno != EINTR) /* a signal was caught during poll() function */
                 warning(errno, "HTTP: gwthread_poll failed.");
             continue;
         }
 
         for (i = 0; i < n; ++i) {
             if (tab[i].revents & POLLIN) {
                 /* check our limit */
                 if (gwlist_len(active_connections) >= HTTP_SERVER_MAX_ACTIVE_CONNECTIONS) {
                     max_clients_reached = 1;
                     break;
                 } else {
                     max_clients_reached = 0;
                 }
 
                 addrlen = sizeof(addr);
                 fd = accept(tab[i].fd, (struct sockaddr *) &addr, &addrlen);
                 if (fd == -1) {
                     error(errno, "HTTP: Error accepting a client.");
                 } else {
                     Octstr *client_ip = host_ip(addr);
                     /*
                      * Be aware that conn_wrap_fd() will return NULL if SSL 
                      * handshake has failed, so we only client_create() if
                      * there is an conn.
                      */             
                     if ((conn = conn_wrap_fd(fd, ports[i]->ssl))) {
                         client = client_create(ports[i]->port, conn, client_ip);
                         conn_register(conn, ports[i]->server_fdset, receive_request, client);
                     } else {
                         error(0, "HTTP: unsuccessful SSL handshake for client `%s'",
                         octstr_get_cstr(client_ip));
                         octstr_destroy(client_ip);
                     }
                 }
             }
         }
 
         while ((portno = gwlist_extract_first(closed_server_sockets)) != NULL) {
             for (i = 0; i < n; ++i) {
                 if (ports[i]->port == *portno) {
                     (void) close(tab[i].fd);
                     tab[i].fd = -1;
                     tab[i].events = 0;
                     port_remove(ports[i]->port);
                     ports[i] = NULL;
                     n--;
                     
                     /* now put the last entry on this place */
                     tab[i].fd = tab[n].fd;
                     tab[i].events = tab[n].events;
                     tab[n].fd = -1;
                     tab[n].events = 0;
                     ports[i] = ports[n];
                 }
             }
             gw_free(portno);
         }
     }
     
     /* make sure we close all ports */
     for (i = 0; i < n; ++i) {
         (void) close(tab[i].fd);
         port_remove(ports[i]->port);
     }
     gw_free(tab);
     gw_free(ports);
 
     server_thread_id = -1;
 }

◆ start_client_threads()

static void start_client_threads ( void )

static

Definition at line 1723 of file http.c.

References client_fdset, client_thread_lock, client_threads_are_running, error(), fdset_create_real(), fdset_destroy(), gwthread_create, http_client_timeout, mutex_lock, mutex_unlock, and write_request_thread().

Referenced by http_start_request().

 {
     if (!client_threads_are_running) {
     /* 
      * To be really certain, we must repeat the test, but use the
      * lock first. If the test failed, however, we _know_ we've
      * already initialized. This strategy of double testing avoids
      * using the lock more than a few times at startup.
      */
     mutex_lock(client_thread_lock);
     if (!client_threads_are_running) {
         client_fdset = fdset_create_real(http_client_timeout);
         if (gwthread_create(write_request_thread, NULL) == -1) {
                 error(0, "HTTP: Could not start client write_request thread.");
                 fdset_destroy(client_fdset);
                 client_threads_are_running = 0;
             } else
                 client_threads_are_running = 1;
     }
     mutex_unlock(client_thread_lock);
     }
 }

◆ start_server_thread()

static void start_server_thread ( void )

static

Definition at line 2458 of file http.c.

References gwthread_create, mutex_lock, mutex_unlock, server_thread(), server_thread_id, server_thread_is_running, and server_thread_lock.

Referenced by http_open_port_if().

 {
     if (!server_thread_is_running) {
         /* 
          * To be really certain, we must repeat the test, but use the
          * lock first. If the test failed, however, we _know_ we've
          * already initialized. This strategy of double testing avoids
          * using the lock more than a few times at startup.
          */
         mutex_lock(server_thread_lock);
         if (!server_thread_is_running) {
             server_thread_id = gwthread_create(server_thread, NULL);
             server_thread_is_running = 1;
         }
         mutex_unlock(server_thread_lock);
     }
 }

◆ write_request_thread()

static void write_request_thread ( void * arg )

static

Definition at line 1681 of file http.c.

References HTTPServer::caller, client_fdset, HTTPServer::conn, conn_is_connected(), conn_register, debug(), get_connection(), gw_assert(), gwlist_consume(), gwlist_len(), gwlist_produce(), handle_transaction(), pending_requests, run_status, running, send_request(), and HTTPServer::state.

Referenced by client_shutdown(), and start_client_threads().

 {
     HTTPServer *trans;
     int rc;
 
     while (run_status == running) {
         trans = gwlist_consume(pending_requests);
         if (trans == NULL)
             break;
 
         gw_assert(trans->state == request_not_sent);
 
         debug("gwlib.http", 0, "Queue contains %ld pending requests.", gwlist_len(pending_requests));
 
         /* 
          * get the connection to use
          * also calls parse_url() to populate the trans values
          */
         trans->conn = get_connection(trans);
 
         if (trans->conn == NULL)
             gwlist_produce(trans->caller, trans);
         else if (conn_is_connected(trans->conn) == 0) {
             debug("gwlib.http", 0, "Socket connected at once");
 
             if ((rc = send_request(trans)) == 0) {
                 trans->state = reading_status;
                 conn_register(trans->conn, client_fdset, handle_transaction, 
                                 trans);
             } else {
                 gwlist_produce(trans->caller, trans);
             }
 
         } else { /* Socket not connected, wait for connection */
             debug("gwlib.http", 0, "Socket connecting");
             trans->state = connecting;
             conn_register(trans->conn, client_fdset, handle_transaction, trans);
         }
     }
 }

Variable Documentation

◆ active_connections

List* active_connections

static

Definition at line 1899 of file http.c.

Referenced by client_create(), client_destroy(), port_init(), port_remove(), port_shutdown(), and server_thread().

◆ client_fdset

FDSet* client_fdset = NULL

static

Definition at line 647 of file http.c.

Referenced by client_shutdown(), http_set_client_timeout(), start_client_threads(), and write_request_thread().

◆ client_thread_lock

Mutex* client_thread_lock = NULL

static

Definition at line 639 of file http.c.

Referenced by client_init(), client_shutdown(), and start_client_threads().

◆ client_threads_are_running

volatile sig_atomic_t client_threads_are_running = 0

static

Definition at line 640 of file http.c.

Referenced by client_shutdown(), and start_client_threads().

◆ closed_server_sockets

List* closed_server_sockets = NULL

static

Definition at line 1896 of file http.c.

Referenced by http_close_port(), server_init(), server_shutdown(), and server_thread().

◆ conn_pool

Dict* conn_pool

static

Definition at line 753 of file http.c.

Referenced by conn_pool_get(), conn_pool_init(), and conn_pool_shutdown().

◆ conn_pool_lock

Mutex* conn_pool_lock

static

Definition at line 754 of file http.c.

Referenced by conn_pool_get(), conn_pool_init(), and conn_pool_shutdown().

◆ http_client_timeout

int http_client_timeout = 30

static

Definition at line 91 of file http.c.

Referenced by http_set_client_timeout(), and start_client_threads().

◆ http_interface

Octstr* http_interface = NULL

static

Definition at line 123 of file http.c.

Referenced by client_shutdown(), get_connection(), handle_transaction(), and http_set_interface().

◆ http_methods

char* http_methods[]

static

Initial value:

= {
    "GET", "POST", "HEAD", "PUT", "DELETE", "PATCH"
}

Definition at line 660 of file http.c.

Referenced by http_method2name().

◆ keep_servers_open

int keep_servers_open = 0

static

Definition at line 1897 of file http.c.

Referenced by http_close_all_ports(), http_open_port_if(), and server_thread().

◆ new_server_sockets

List* new_server_sockets = NULL

static

Definition at line 1895 of file http.c.

Referenced by http_open_port_if(), server_init(), server_shutdown(), and server_thread().

◆ pending_requests

List* pending_requests = NULL

static

Definition at line 633 of file http.c.

Referenced by client_init(), client_shutdown(), handle_transaction(), http_start_request(), and write_request_thread().

◆ port_collection

Dict* port_collection = NULL

static

Definition at line 2025 of file http.c.

Referenced by port_add(), port_get_fdset(), port_get_request(), port_init(), port_put_request(), port_remove(), port_set_timeout(), and port_shutdown().

◆ port_mutex

Mutex* port_mutex = NULL

static

Definition at line 2024 of file http.c.

Referenced by port_add(), port_get_fdset(), port_get_request(), port_init(), port_put_request(), port_remove(), port_set_timeout(), and port_shutdown().

◆ proxy_exceptions

List* proxy_exceptions = NULL

static

Definition at line 205 of file http.c.

Referenced by http_close_proxy(), http_use_proxy(), proxy_init(), and proxy_used_for_host().

◆ proxy_exceptions_regex

regex_t* proxy_exceptions_regex = NULL

static

Definition at line 206 of file http.c.

Referenced by http_close_proxy(), http_use_proxy(), and proxy_used_for_host().

◆ proxy_hostname

Octstr* proxy_hostname = NULL

static

Definition at line 200 of file http.c.

Referenced by get_connection(), handle_transaction(), http_close_proxy(), http_use_proxy(), and proxy_used_for_host().

◆ proxy_mutex

Mutex* proxy_mutex = NULL

static

Definition at line 199 of file http.c.

Referenced by http_close_proxy(), http_use_proxy(), proxy_init(), proxy_shutdown(), and proxy_used_for_host().

◆ proxy_password

Octstr* proxy_password = NULL

static

Definition at line 204 of file http.c.

Referenced by http_close_proxy(), http_use_proxy(), main(), and proxy_add_authentication().

◆ proxy_port

int proxy_port = 0

static

Definition at line 201 of file http.c.

Referenced by get_connection(), handle_transaction(), http_close_proxy(), http_use_proxy(), and main().

◆ proxy_ssl

int proxy_ssl = 0

static

Definition at line 202 of file http.c.

Referenced by get_connection(), http_use_proxy(), and main().

◆ proxy_username

Octstr* proxy_username = NULL

static

Definition at line 203 of file http.c.

Referenced by http_close_proxy(), http_use_proxy(), main(), and proxy_add_authentication().

◆ run_status

enum { ... } run_status

Referenced by handle_transaction(), http_close_proxy(), http_init(), http_shutdown(), http_use_proxy(), receive_request(), server_thread(), and write_request_thread().

◆ server_thread_id

long server_thread_id = -1

static

Definition at line 1894 of file http.c.

Referenced by client_destroy(), http_close_all_ports(), http_close_port(), http_open_port_if(), server_shutdown(), server_thread(), and start_server_thread().

◆ server_thread_is_running

volatile sig_atomic_t server_thread_is_running = 0

static

Definition at line 1893 of file http.c.

Referenced by http_close_all_ports(), server_shutdown(), and start_server_thread().

◆ server_thread_lock

Mutex* server_thread_lock = NULL

static

Definition at line 1892 of file http.c.

Referenced by server_init(), server_shutdown(), and start_server_thread().

Data Structures

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ DUMP_RESPONSE

◆ HTTP_MAX_FOLLOW

◆ HTTP_SERVER_MAX_ACTIVE_CONNECTIONS

◆ HTTP_SERVER_TIMEOUT

◆ MAX_HEADER_LENGTH

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

◆ body_expectation

◆ entity_state

Function Documentation

◆ build_request()

◆ build_response()

◆ client_create()

◆ client_destroy()

◆ client_init()

◆ client_is_persistent()

◆ client_read_status()

◆ client_reset()

◆ client_shutdown()

◆ conn_pool_get()

◆ conn_pool_init()

◆ conn_pool_item_destroy()

◆ conn_pool_key()

◆ conn_pool_shutdown()

◆ deduce_body_state()

◆ destroy_int_pointer()

◆ destroy_struct_server()

◆ entity_create()

◆ entity_destroy()

◆ entity_read()

◆ get_connection()

◆ get_redirection_location()

◆ handle_transaction()

◆ header_is_called()

◆ http_accept_request()

◆ http_add_basic_auth()

◆ http_append_headers()

◆ http_caller_create()

◆ http_caller_destroy()

◆ http_caller_signal_shutdown()

◆ http_cgi_variable()

◆ http_cgivar_dump()

◆ http_cgivar_dump_into()

◆ http_charset_accepted()

◆ http_close_all_ports()

◆ http_close_client()

◆ http_close_port()

◆ http_close_proxy()

◆ http_create_empty_headers()

◆ http_destroy_cgiargs()

◆ http_destroy_headers()

◆ http_get_header_parameter()

◆ http_get_real()

◆ http_header_add()

◆ http_header_add_element()

◆ http_header_combine()

◆ http_header_dump()

◆ http_header_duplicate()

◆ http_header_find_all()

◆ http_header_find_first_real()

◆ http_header_get()

◆ http_header_get_content_type()

◆ http_header_mark_transformation()

◆ http_header_pack()

◆ http_header_quoted_string_len()

◆ http_header_remove_all()

◆ http_header_split_auth_value()

◆ http_header_split_value()

◆ http_header_value()

◆ http_init()

◆ http_method()

◆ http_method2name()

◆ http_name2method()