wsp_headers.h File Reference

#include "gwlib/gwlib.h"

Go to the source code of this file.

Data Structures
struct	parameter
struct	headerinfo

Macros
#define	WSP_FIELD_VALUE_NUL_STRING   1
#define	WSP_FIELD_VALUE_ENCODED   2
#define	WSP_FIELD_VALUE_DATA   3
#define	WSP_FIELD_VALUE_NONE   4 /* secondary_field_value only */
#define	WSP_QUOTE   127
#define	MAX_SHORT_INTEGER   127
#define	BASIC_AUTHENTICATION   128
#define	ABSOLUTE_TIME   128
#define	RELATIVE_TIME   129
#define	BYTE_RANGE   128
#define	SUFFIX_BYTE_RANGE   129
#define	LONG_AGO_VALUE   100000
#define	LIST   1
#define	BROKEN_LIST   2
#define	TABLE_SIZE(table)   ((long)(sizeof(table) / sizeof(table[0])))

Typedefs
typedef struct parameter	Parameter
typedef int	header_pack_func_t(Octstr *packed, Octstr *value)

Functions
int	wsp_field_value (ParseContext *context, int *well_known_value)
void	wsp_skip_field_value (ParseContext *context)
int	wsp_secondary_field_value (ParseContext *context, long *result)
void	parm_destroy_item (void *parm)
List *	wsp_strip_parameters (Octstr *value)
Octstr *	wsp_unpack_integer_value (ParseContext *context)
Octstr *	wsp_unpack_version_value (long value)
void	wsp_unpack_all_parameters (ParseContext *context, Octstr *decoded)
Octstr *	wsp_unpack_date_value (ParseContext *context)
void	wsp_unpack_well_known_field (List *unpacked, int field_type, ParseContext *context)
void	wsp_unpack_app_header (List *unpacked, ParseContext *context)
void	wsp_pack_integer_value (Octstr *packed, unsigned long integer)
int	wsp_pack_date (Octstr *packet, Octstr *value)
int	wsp_pack_retry_after (Octstr *packet, Octstr *value)
int	wsp_pack_text (Octstr *packet, Octstr *value)
int	wsp_pack_quoted_text (Octstr *packed, Octstr *text)
int	wsp_pack_integer_string (Octstr *packet, Octstr *value)
int	wsp_pack_version_value (Octstr *packet, Octstr *value)
int	wsp_pack_constrained_value (Octstr *packed, Octstr *text, long value)
void	wsp_pack_value (Octstr *packed, Octstr *encoded)
void	wsp_pack_parameters (Octstr *packed, List *parms)
int	wsp_pack_list (Octstr *packed, long fieldnum, List *elements, int i)
void	wsp_pack_short_integer (Octstr *packed, unsigned long integer)
void	wsp_pack_separate_content_type (Octstr *packed, List *headers)
Octstr *	wsp_unpack_accept_general_form (ParseContext *context)
Octstr *	wsp_unpack_accept_charset_general_form (ParseContext *context)
int	wsp_pack_content_type (Octstr *packet, Octstr *value)
int	wsp_pack_application_header (Octstr *packed, Octstr *fieldname, Octstr *value)
void	wsp_pack_long_integer (Octstr *packed, unsigned long integer)
List *	wsp_headers_unpack (Octstr *headers, int content_type)
Octstr *	wsp_headers_pack (List *headers, int separate_content_type, int wsp_version)

Macro Definition Documentation

ABSOLUTE_TIME

#define ABSOLUTE_TIME   128

Definition at line 81 of file wsp_headers.h.

Referenced by unpack_retry_after(), and wsp_pack_retry_after().

BASIC_AUTHENTICATION

#define BASIC_AUTHENTICATION   128

Definition at line 80 of file wsp_headers.h.

Referenced by pack_challenge(), pack_credentials(), proxy_unpack_credentials(), unpack_challenge(), and unpack_credentials().

BROKEN_LIST

#define BROKEN_LIST   2

Definition at line 100 of file wsp_headers.h.

Referenced by pack_known_header().

BYTE_RANGE

#define BYTE_RANGE   128

Definition at line 83 of file wsp_headers.h.

Referenced by pack_range_value(), and unpack_range_value().

LIST

#define LIST   1

Definition at line 94 of file wsp_headers.h.

Referenced by pack_known_header().

LONG_AGO_VALUE

#define LONG_AGO_VALUE   100000

Definition at line 90 of file wsp_headers.h.

Referenced by pack_expires().

MAX_SHORT_INTEGER

#define MAX_SHORT_INTEGER   127

Definition at line 77 of file wsp_headers.h.

Referenced by pack_accept(), pack_accept_charset(), pack_accept_language(), pack_parameter(), pack_warning(), wsp_pack_integer_value(), and wsp_pack_short_integer().

RELATIVE_TIME

#define RELATIVE_TIME   129

Definition at line 82 of file wsp_headers.h.

Referenced by unpack_retry_after(), and wsp_pack_retry_after().

SUFFIX_BYTE_RANGE

#define SUFFIX_BYTE_RANGE   129

Definition at line 84 of file wsp_headers.h.

Referenced by pack_range_value(), and unpack_range_value().

TABLE_SIZE

#define TABLE_SIZE

(

table

)

((long)(sizeof(table) / sizeof(table[0])))

Definition at line 102 of file wsp_headers.h.

Referenced by pack_known_header().

WSP_FIELD_VALUE_DATA

#define WSP_FIELD_VALUE_DATA   3

Definition at line 70 of file wsp_headers.h.

Referenced by unpack_cache_directive(), unpack_field_name(), wsp_field_value(), wsp_skip_field_value(), and wsp_unpack_well_known_field().

WSP_FIELD_VALUE_ENCODED

#define WSP_FIELD_VALUE_ENCODED   2

Definition at line 69 of file wsp_headers.h.

Referenced by unpack_accept_language_general_form(), unpack_cache_directive(), unpack_field_name(), unpack_parameter(), wsp_field_value(), wsp_secondary_field_value(), wsp_unpack_accept_charset_general_form(), wsp_unpack_accept_general_form(), and wsp_unpack_well_known_field().

WSP_FIELD_VALUE_NONE

#define WSP_FIELD_VALUE_NONE   4 /* secondary_field_value only */

Definition at line 71 of file wsp_headers.h.

Referenced by unpack_accept_language_general_form(), unpack_parameter(), wsp_secondary_field_value(), wsp_unpack_accept_charset_general_form(), and wsp_unpack_accept_general_form().

WSP_FIELD_VALUE_NUL_STRING

#define WSP_FIELD_VALUE_NUL_STRING   1

Definition at line 68 of file wsp_headers.h.

Referenced by unpack_accept_language_general_form(), unpack_cache_directive(), unpack_field_name(), unpack_parameter(), wsp_field_value(), wsp_secondary_field_value(), wsp_unpack_accept_charset_general_form(), wsp_unpack_accept_general_form(), and wsp_unpack_well_known_field().

WSP_QUOTE

#define WSP_QUOTE   127

Definition at line 74 of file wsp_headers.h.

Referenced by unpack_warning_value(), wsp_field_value(), wsp_pack_text(), and wsp_secondary_field_value().

Typedef Documentation

header_pack_func_t

typedef int header_pack_func_t(Octstr *packed, Octstr *value)

Definition at line 111 of file wsp_headers.h.

Parameter

typedef struct parameter Parameter

Definition at line 109 of file wsp_headers.h.

Function Documentation

parm_destroy_item()

void parm_destroy_item

(

void *

parm

)

Definition at line 1515 of file wsp_headers.c.

References parm_destroy().

Referenced by pack_accept(), pack_accept_charset(), pack_accept_encoding(), pack_accept_language(), pack_challenge(), pack_content_disposition(), and pack_credentials().

{
    parm_destroy(parm);
}

wsp_field_value()

int wsp_field_value	(	ParseContext *	context,
		int *	well_known_value
	)

Definition at line 107 of file wsp_headers.c.

References parse_get_char(), parse_get_uintvar(), parse_limit(), parse_skip(), WSP_FIELD_VALUE_DATA, WSP_FIELD_VALUE_ENCODED, WSP_FIELD_VALUE_NUL_STRING, and WSP_QUOTE.

Referenced by unpack_cache_directive(), unpack_field_name(), wsp_skip_field_value(), and wsp_unpack_well_known_field().

{
    int val;
    unsigned long len;

    val = parse_get_char(context);
    if (val > 0 && val < 31) {
        *well_known_value = -1;
        parse_limit(context, val);
        return WSP_FIELD_VALUE_DATA;
    } else if (val == 31) {
        *well_known_value = -1;
        len = parse_get_uintvar(context);
        parse_limit(context, len);
        return WSP_FIELD_VALUE_DATA;
    } else if (val > 127) {
        *well_known_value = val - 128;
        return WSP_FIELD_VALUE_ENCODED;
    } else if (val == WSP_QUOTE || val == '"') {  /* 127 */
        *well_known_value = -1;
        /* We already consumed the Quote */
        return WSP_FIELD_VALUE_NUL_STRING;
    } else {    /* implicite val == 0 */ 
        *well_known_value = -1;
        /* Un-parse the character we just read */
        parse_skip(context, -1);
        return WSP_FIELD_VALUE_NUL_STRING;
    }
}

wsp_headers_pack()

Octstr* wsp_headers_pack	(	List *	headers,
		int	separate_content_type,
		int	wsp_version
	)

Definition at line 2963 of file wsp_headers.c.

References debug(), gwlist_len(), http_header_get(), octstr_create, octstr_destroy(), octstr_get_cstr, pack_known_header(), warning(), wsp_pack_application_header(), and wsp_pack_separate_content_type().

Referenced by main(), make_confirmedpush_pdu(), make_connectreply_pdu(), make_push_pdu(), make_resume_reply_pdu(), pack_into_push_datagram(), and pack_into_result_datagram().

{
    Octstr *packed;
    long i, len;
    int errors;

    packed = octstr_create("");
    if (separate_content_type)
        wsp_pack_separate_content_type(packed, headers);

    len = gwlist_len(headers);
    for (i = 0; i < len; i++) {
        Octstr *fieldname;
        Octstr *value;
        long fieldnum;

        http_header_get(headers, i, &fieldname, &value);
        /* XXX we need to obey which WSP encoding-version to use */
        /* fieldnum = wsp_string_to_header(fieldname); */
        fieldnum = wsp_string_to_versioned_header(fieldname, wsp_version);

        errors = 0;

        if (separate_content_type && fieldnum == WSP_HEADER_CONTENT_TYPE) {
            /* already handled */
            debug("wsp",0,"WSP: content type already handled.");
        } else if (fieldnum < 0) {
            if (wsp_pack_application_header(packed, fieldname, value) < 0)
                errors = 1;
        } else {
            if (pack_known_header(packed, fieldnum, value) < 0)
                errors = 1;
        }

        if (errors)
            warning(0, "Skipping header: %s: %s",
                    octstr_get_cstr(fieldname),
                    octstr_get_cstr(value));

        octstr_destroy(fieldname);
        octstr_destroy(value);
    }

    /*
    http_header_dump(headers);
    octstr_dump(packed, 0);
    */

    return packed;
}

wsp_headers_unpack()

List* wsp_headers_unpack	(	Octstr *	headers,
		int	content_type
	)

Definition at line 1331 of file wsp_headers.c.

References debug(), gwlist_get(), gwlist_len(), http_create_empty_headers(), info(), octstr_dump, octstr_get_cstr, octstr_len(), parse_context_create(), parse_context_destroy(), parse_error(), parse_get_char(), parse_octets_left(), parse_skip(), warning(), wsp_skip_field_value(), wsp_unpack_app_header(), and wsp_unpack_well_known_field().

Referenced by main(), mime_decompile(), unpack_datagram(), and unpack_new_headers().

{
    ParseContext *context;
    int byte;
    List *unpacked;
    int code_page;

    unpacked = http_create_empty_headers();
    context = parse_context_create(headers);

    if (octstr_len(headers) > 0) {
        debug("wsp", 0, "WSP: decoding headers:");
        octstr_dump(headers, 0);
    }

    if (content_type_present)
        wsp_unpack_well_known_field(unpacked,
                                    WSP_HEADER_CONTENT_TYPE, context);

    code_page = 1;   /* default */

    while (parse_octets_left(context) > 0 && !parse_error(context)) {
        byte = parse_get_char(context);

        if (byte == 127 || (byte >= 1 && byte <= 31)) {
            if (byte == 127)
                code_page = parse_get_char(context);
            else
                code_page = byte;
            if (code_page == 1)
                info(0, "Returning to code page 1 (default).");
            else {
                warning(0, "Shift to unknown code page %d.",
                        code_page);
                warning(0, "Will try to skip headers until "
                        "next known code page.");
            }
        } else if (byte >= 128) {  /* well-known-header */
            if (code_page == 1)
                wsp_unpack_well_known_field(unpacked, byte - 128, context);
            else {
                debug("wsp", 0, "Skipping field 0x%02x.", byte);
                wsp_skip_field_value(context);
            }
        } else if (byte > 31 && byte < 127) {
            /* Un-parse the character we just read */
            parse_skip(context, -1);
            wsp_unpack_app_header(unpacked, context);
        } else {
            warning(0, "Unsupported token or header (start 0x%x)", byte);
            break;
        }
    }

    if (gwlist_len(unpacked) > 0) {
        long i;

        debug("wsp", 0, "WSP: decoded headers:");
        for (i = 0; i < gwlist_len(unpacked); i++) {
            Octstr *header = gwlist_get(unpacked, i);
            debug("wsp", 0, "%s", octstr_get_cstr(header));
        }
        debug("wsp", 0, "WSP: End of decoded headers.");
    }

    parse_context_destroy(context);
    return unpacked;
}

wsp_pack_application_header()

int wsp_pack_application_header	(	Octstr *	packed,
		Octstr *	fieldname,
		Octstr *	value
	)

Definition at line 2938 of file wsp_headers.c.

References is_token(), octstr_get_cstr, octstr_str_compare(), warning(), wsp_pack_date(), and wsp_pack_text().

Referenced by wsp_headers_pack().

{
    if (!is_token(fieldname)) {
        warning(0, "WSP headers: `%s' is not a valid HTTP token.",
                octstr_get_cstr(fieldname));
        return -1;
    }

    /* We have to deal specially with the X-WAP.TOD header, because it
     * is the only case of a text-format header defined with a non-text
     * field value. */
    /* Normally this should be a case-insensitive comparison, but this
     * header will only be present if we generated it ourselves in the
     * application layer. */
    if (octstr_str_compare(fieldname, "X-WAP.TOD") == 0) {
        wsp_pack_text(packed, fieldname);
        return wsp_pack_date(packed, value);
    }

    wsp_pack_text(packed, fieldname);
    wsp_pack_text(packed, value);
    return 0;
}

wsp_pack_constrained_value()

int wsp_pack_constrained_value	(	Octstr *	packed,
		Octstr *	text,
		long	value
	)

Definition at line 1879 of file wsp_headers.c.

References text, wsp_pack_short_integer(), and wsp_pack_text().

Referenced by pack_accept(), pack_accept_charset(), pack_accept_language(), pack_cache_control(), pack_connection(), pack_encoding(), pack_field_name(), pack_method(), pack_range_unit(), and pack_transfer_encoding().

{
    if (value >= 0)
        wsp_pack_short_integer(packed, value);
    else
        wsp_pack_text(packed, text);
    return 0;
}

wsp_pack_content_type()

int wsp_pack_content_type	(	Octstr *	packet,
		Octstr *	value
	)

Definition at line 2626 of file wsp_headers.c.

References pack_accept().

Referenced by wsp_pack_separate_content_type().

{
    /* The expansion of Content-type-value works out to be
     * equivalent to Accept-value. */ 
    return pack_accept(packed, value);
}

wsp_pack_date()

int wsp_pack_date	(	Octstr *	packet,
		Octstr *	value
	)

Definition at line 2186 of file wsp_headers.c.

References date_parse_http(), octstr_get_cstr, warning(), and wsp_pack_long_integer().

Referenced by pack_expires(), pack_if_range(), wsp_pack_application_header(), and wsp_pack_retry_after().

{
    long timeval;

    /* If we get a negative timeval here, this means either
     * we're beyond the time_t 32 bit int positive border for the 
     * timestamp or we're really handling time before epoch. */
    timeval = date_parse_http(value);
    if (timeval == -1) {
        warning(0, "WSP headers: cannot decode date '%s'",
                octstr_get_cstr(value));
        return -1;
    }

    /* We'll assume that we don't package time before epoch. */
    wsp_pack_long_integer(packed, (unsigned long) timeval);
    return 0;
}

wsp_pack_integer_string()

int wsp_pack_integer_string	(	Octstr *	packet,
		Octstr *	value
	)

Definition at line 1815 of file wsp_headers.c.

References debug(), octstr_get_char(), octstr_get_cstr, octstr_len(), warning(), and wsp_pack_integer_value().

Referenced by pack_cache_control(), pack_parameter(), and wsp_pack_retry_after().

{
    unsigned long integer;
    long pos;
    int c;
    int digit;

    integer = 0;
    for (pos = 0; pos < octstr_len(value); pos++) {
        c = octstr_get_char(value, pos);
        if (!isdigit(c))
            break;
        digit = c - '0';
        if (integer > ULONG_MAX / 10)
            goto overflow;
        integer *= 10;
        if (integer > ULONG_MAX - digit)
            goto overflow;
        integer += digit;
    }

    debug("wsp",0,"WSP: %s: value `%s', integer 0x%04lx", __func__,
          octstr_get_cstr(value), integer);
    wsp_pack_integer_value(packed, integer);
    return 0;

overflow:
    warning(0, "WSP: Number too large to handle: '%s'.",
            octstr_get_cstr(value));
    return -1;
}

wsp_pack_integer_value()

void wsp_pack_integer_value	(	Octstr *	packed,
		unsigned long	integer
	)

Definition at line 1807 of file wsp_headers.c.

References MAX_SHORT_INTEGER, wsp_pack_long_integer(), and wsp_pack_short_integer().

Referenced by pack_accept(), pack_accept_charset(), pack_accept_language(), pack_language(), pack_parameter(), and wsp_pack_integer_string().

{
    if (integer <= MAX_SHORT_INTEGER)
        wsp_pack_short_integer(packed, integer);
    else
        wsp_pack_long_integer(packed, integer);
}

wsp_pack_list()

int wsp_pack_list	(	Octstr *	packed,
		long	fieldnum,
		List *	elements,
		int	i
	)

Definition at line 2869 of file wsp_headers.c.

References gwlist_consume(), octstr_delete(), octstr_destroy(), octstr_len(), and wsp_pack_short_integer().

Referenced by pack_known_header().

{
    long startpos;
    Octstr *element;

    while ((element = gwlist_consume(elements))) {
        startpos = octstr_len(packed);

        wsp_pack_short_integer(packed, fieldnum);
        if (headerinfo[i].func(packed, element) < 0) {
            /* Remove whatever we added */
            octstr_delete(packed, startpos,
                          octstr_len(packed) - startpos);
            /* But continue processing elements */
        }
        octstr_destroy(element);
    }
    return 0;
}

wsp_pack_long_integer()

void wsp_pack_long_integer	(	Octstr *	packed,
		unsigned long	integer
	)

Definition at line 1776 of file wsp_headers.c.

References octstr_append_char(), octstr_insert_data(), and octstr_len().

Referenced by pack_expires(), wsp_pack_date(), and wsp_pack_integer_value().

{
    long oldlen = octstr_len(packed);
    unsigned char octet;
    long len;

    if (integer == 0) {
    /* The Multi-octet-integer has to be at least 1 octet long. */
    octstr_append_char(packed, 1); /* length */
    octstr_append_char(packed, 0); /* value */
    return;
    }

    /* Encode it back-to-front, by repeatedly inserting
     * at the same position, because that's easier. */
    for (len = 0; integer != 0; integer >>= 8, len++) {
        octet = integer & 0xff;
        octstr_insert_data(packed, oldlen, (char *)&octet, 1);
    }

    octet = len;
    octstr_insert_data(packed, oldlen, (char *)&octet, 1);
}

wsp_pack_parameters()

void wsp_pack_parameters	(	Octstr *	packed,
		List *	parms
	)

Definition at line 1973 of file wsp_headers.c.

References gwlist_get(), gwlist_len(), and pack_parameter().

Referenced by pack_accept(), pack_challenge(), pack_content_disposition(), and pack_credentials().

{
    long i;
    Parameter *parm;

    for (i = 0; i < gwlist_len(parms); i++) {
        parm = gwlist_get(parms, i);
        pack_parameter(packed, parm);
    }
}

wsp_pack_quoted_text()

int wsp_pack_quoted_text	(	Octstr *	packed,
		Octstr *	text
	)

Definition at line 1627 of file wsp_headers.c.

References octstr_append(), octstr_append_char(), and text.

Referenced by pack_if_range().

{
     octstr_append_char(packed, '"');
     octstr_append(packed,text);
     octstr_append_char(packed,0);
     return 0;
}

wsp_pack_retry_after()

int wsp_pack_retry_after	(	Octstr *	packet,
		Octstr *	value
	)

Definition at line 2727 of file wsp_headers.c.

References ABSOLUTE_TIME, error(), octstr_append_char(), octstr_create, octstr_destroy(), octstr_get_char(), RELATIVE_TIME, wsp_pack_date(), wsp_pack_integer_string(), and wsp_pack_value().

{
    Octstr *encoded = NULL;

    encoded = octstr_create("");
    if (isdigit(octstr_get_char(value, 0))) {
        octstr_append_char(encoded, RELATIVE_TIME);
        if (wsp_pack_integer_string(encoded, value) < 0)
            goto error;
    } else {
        octstr_append_char(encoded, ABSOLUTE_TIME);
        if (wsp_pack_date(encoded, value) < 0)
            goto error;
    }
    wsp_pack_value(packed, encoded);

    octstr_destroy(encoded);
    return 0;

error:
    octstr_destroy(encoded);
    return -1;
}

wsp_pack_separate_content_type()

void wsp_pack_separate_content_type	(	Octstr *	packed,
		List *	headers
	)

Definition at line 2851 of file wsp_headers.c.

References content_type, http_header_find_first, octstr_create, octstr_destroy(), octstr_strip_blanks(), warning(), and wsp_pack_content_type().

Referenced by wsp_headers_pack().

{
    Octstr *content_type;

    /* Can't use http_header_get_content_type because it
     * does not parse all possible parameters. */
    content_type = http_header_find_first(headers, "Content-Type");

    if (content_type == NULL) {
        warning(0, "WSP: Missing Content-Type header in "
                "response, guessing application/octet-stream");
        content_type = octstr_create("application/octet-stream");
    }
    octstr_strip_blanks(content_type);
    wsp_pack_content_type(packed, content_type);
    octstr_destroy(content_type);
}

wsp_pack_short_integer()

void wsp_pack_short_integer	(	Octstr *	packed,
		unsigned long	integer
	)

Definition at line 1800 of file wsp_headers.c.

References gw_assert(), MAX_SHORT_INTEGER, and octstr_append_char().

Referenced by ota_pack_push_headers(), pack_cache_control(), pack_content_disposition(), pack_known_header(), pack_parameter(), pack_pragma(), pack_range(), pack_warning(), wsp_pack_constrained_value(), wsp_pack_integer_value(), wsp_pack_list(), and wsp_pack_version_value().

{
    gw_assert(integer <= MAX_SHORT_INTEGER);

    octstr_append_char(packed, integer + 0x80);
}

wsp_pack_text()

int wsp_pack_text	(	Octstr *	packet,
		Octstr *	value
	)

Definition at line 1615 of file wsp_headers.c.

References octstr_append(), octstr_append_char(), octstr_get_char(), text, and WSP_QUOTE.

Referenced by pack_accept(), pack_accept_charset(), pack_accept_language(), pack_cache_control(), pack_challenge(), pack_credentials(), pack_language(), pack_parameter(), pack_uri(), pack_warning(), wsp_pack_application_header(), wsp_pack_constrained_value(), and wsp_pack_version_value().

{
    /* This check catches 0-length strings as well, because
     * octstr_get_char will return -1. */
    if (octstr_get_char(text, 0) >= 128 || octstr_get_char(text, 0) < 32)
        octstr_append_char(packed, WSP_QUOTE);
    octstr_append(packed, text);
    octstr_append_char(packed, 0);
    return 0;
}

wsp_pack_value()

void wsp_pack_value	(	Octstr *	packed,
		Octstr *	encoded
	)

Definition at line 1761 of file wsp_headers.c.

References octstr_append(), octstr_append_char(), octstr_append_uintvar(), and octstr_len().

Referenced by pack_accept(), pack_accept_charset(), pack_accept_language(), pack_cache_control(), pack_challenge(), pack_content_disposition(), pack_content_range(), pack_credentials(), pack_pragma(), pack_range_value(), pack_warning(), and wsp_pack_retry_after().

{
    long len;

    len = octstr_len(encoded);
    if (len <= 30)
        octstr_append_char(packed, len);
    else {
        octstr_append_char(packed, 31);
        octstr_append_uintvar(packed, len);
    }

    octstr_append(packed, encoded);
}

wsp_pack_version_value()

int wsp_pack_version_value	(	Octstr *	packet,
		Octstr *	value
	)

Definition at line 1848 of file wsp_headers.c.

References debug(), octstr_get_char(), octstr_get_cstr, octstr_len(), octstr_parse_long(), wsp_pack_short_integer(), and wsp_pack_text().

Referenced by pack_parameter().

{
    unsigned long integer;
    long major, minor;
    long pos;

    pos = octstr_parse_long(&major, version, 0, 10);
    if (pos < 0 || major < 1 || major > 7)
        goto usetext;

    if (pos == octstr_len(version))
        minor = 15;
    else {
        if (octstr_get_char(version, pos) != '.')
            goto usetext;
        pos = octstr_parse_long(&minor, version, pos + 1, 10);
        if (pos != octstr_len(version) || minor < 0 || minor > 14)
            goto usetext;
    }

    integer = major << 4 | minor;
    debug("wsp",0,"WSP: %s: value `%s', integer 0x%04lx", __func__,
          octstr_get_cstr(version), integer);
    wsp_pack_short_integer(packed, integer);
    return 0;

usetext:
    wsp_pack_text(packed, version);
    return 0;
}

wsp_secondary_field_value()

int wsp_secondary_field_value	(	ParseContext *	context,
		long *	result
	)

Definition at line 183 of file wsp_headers.c.

References parse_get_char(), parse_get_uintvar(), parse_skip(), unpack_multi_octet_integer(), WSP_FIELD_VALUE_ENCODED, WSP_FIELD_VALUE_NONE, WSP_FIELD_VALUE_NUL_STRING, and WSP_QUOTE.

Referenced by unpack_accept_language_general_form(), unpack_parameter(), wsp_unpack_accept_charset_general_form(), and wsp_unpack_accept_general_form().

{
    int val;
    long length;

    val = parse_get_char(context);
    if (val == 0) {
        *result = 0;
        return WSP_FIELD_VALUE_NONE;
    } else if (val > 0 && val < 31) {
        *result = unpack_multi_octet_integer(context, val);
        return WSP_FIELD_VALUE_ENCODED;
    } else if (val == 31) {
        length = parse_get_uintvar(context);
        *result = unpack_multi_octet_integer(context, length);
        return WSP_FIELD_VALUE_ENCODED;
    } else if (val > 127) {
        *result = val - 128;
        return WSP_FIELD_VALUE_ENCODED;
    } else if (val == WSP_QUOTE) {  /* 127 */
        *result = -1;
        return WSP_FIELD_VALUE_NUL_STRING;
    } else {
        *result = -1;
        /* Un-parse the character we just read */
        parse_skip(context, -1);
        return WSP_FIELD_VALUE_NUL_STRING;
    }
}

wsp_skip_field_value()

void wsp_skip_field_value

(

ParseContext *

context

)

Definition at line 138 of file wsp_headers.c.

References parse_pop_limit(), parse_skip_to_limit(), wsp_field_value(), and WSP_FIELD_VALUE_DATA.

Referenced by wsp_headers_unpack().

{
    int val;
    int ret;

    ret = wsp_field_value(context, &val);
    if (ret == WSP_FIELD_VALUE_DATA) {
        parse_skip_to_limit(context);
        parse_pop_limit(context);
    }
}

wsp_strip_parameters()

List* wsp_strip_parameters

(

Octstr *

value

)

Definition at line 1553 of file wsp_headers.c.

References gwlist_append(), gwlist_create, http_header_quoted_string_len(), octstr_copy, octstr_delete(), octstr_get_char(), octstr_len(), octstr_search_char(), octstr_strip_blanks(), and parm_create().

Referenced by pack_accept(), pack_accept_charset(), pack_accept_encoding(), pack_accept_language(), pack_challenge(), pack_content_disposition(), and pack_credentials().

{
    long pos;
    long len;
    int c;
    long end;
    List *parms;
    long firstparm;

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

    parms = gwlist_create();
    firstparm = pos;

    for (pos++; pos > 0 && pos < len; 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);
        }

        gwlist_append(parms, parm_create(key, val));
    }

    octstr_delete(value, firstparm, octstr_len(value) - firstparm);
    octstr_strip_blanks(value);
    return parms;
}

wsp_unpack_accept_charset_general_form()

Octstr* wsp_unpack_accept_charset_general_form

(

ParseContext *

context

)

Definition at line 557 of file wsp_headers.c.

References panic, parse_error(), parse_get_nul_string(), unpack_optional_q_value(), warning(), WSP_FIELD_VALUE_ENCODED, WSP_FIELD_VALUE_NONE, WSP_FIELD_VALUE_NUL_STRING, and wsp_secondary_field_value().

Referenced by wsp_unpack_well_known_field().

{
    Octstr *decoded = NULL;
    int ret;
    long val;

    ret = wsp_secondary_field_value(context, &val);
    if (parse_error(context) || ret == WSP_FIELD_VALUE_NONE) {
        warning(0, "Bad accept-charset-general-form");
        return NULL;
    }

    if (ret == WSP_FIELD_VALUE_ENCODED) {
        decoded = wsp_charset_to_string(val);
        if (!decoded) {
            warning(0, "Unknown character set %04lx.", val);
            return NULL;
        }
    } else if (ret == WSP_FIELD_VALUE_NUL_STRING) {
        decoded = parse_get_nul_string(context);
        if (!decoded) {
            warning(0, "Format error in accept-charset");
            return NULL;
        }
    } else {
        panic(0, "Unknown secondary field value type %d.", ret);
    }

    unpack_optional_q_value(context, decoded);
    return decoded;
}

wsp_unpack_accept_general_form()

Octstr* wsp_unpack_accept_general_form

(

ParseContext *

context

)

Definition at line 513 of file wsp_headers.c.

References panic, parse_error(), parse_get_nul_string(), warning(), WSP_FIELD_VALUE_ENCODED, WSP_FIELD_VALUE_NONE, WSP_FIELD_VALUE_NUL_STRING, wsp_secondary_field_value(), and wsp_unpack_all_parameters().

Referenced by wsp_unpack_well_known_field().

{
    Octstr *decoded = NULL;
    int ret;
    long val;

    /* The definition for Accept-general-form looks quite complicated,
     * but the "Q-token Q-value" part fits the normal expansion of
     * Parameter, so it simplifies to:
     *  Value-length Media-range *(Parameter)
     * and we've already parsed Value-length.
     */

    /* We use this function to parse content-general-form too,
     * because its definition of Media-type is identical to Media-range.
     */

    ret = wsp_secondary_field_value(context, &val);
    if (parse_error(context) || ret == WSP_FIELD_VALUE_NONE) {
        warning(0, "bad media-range or media-type");
        return NULL;
    }

    if (ret == WSP_FIELD_VALUE_ENCODED) {
        decoded = wsp_content_type_to_string(val);
        if (!decoded) {
            warning(0, "Unknown content type 0x%02lx.", val);
            return NULL;
        }
    } else if (ret == WSP_FIELD_VALUE_NUL_STRING) {
        decoded = parse_get_nul_string(context);
        if (!decoded) {
            warning(0, "Format error in content type");
            return NULL;
        }
    } else {
        panic(0, "Unknown secondary field value type %d.", ret);
    }

    wsp_unpack_all_parameters(context, decoded);
    return decoded;
}

wsp_unpack_all_parameters()

void wsp_unpack_all_parameters	(	ParseContext *	context,
		Octstr *	decoded
	)

Definition at line 443 of file wsp_headers.c.

References parse_error(), parse_octets_left(), and unpack_parameter().

Referenced by unpack_disposition(), and wsp_unpack_accept_general_form().

{
    int ret = 0;

    while (ret >= 0 && !parse_error(context) &&
           parse_octets_left(context) > 0) {
        ret = unpack_parameter(context, decoded);
    }
}

wsp_unpack_app_header()

void wsp_unpack_app_header	(	List *	unpacked,
		ParseContext *	context
	)

Definition at line 1311 of file wsp_headers.c.

References http_header_add(), octstr_destroy(), octstr_get_cstr, parse_error(), parse_get_nul_string(), and warning().

Referenced by wsp_headers_unpack().

{
    Octstr *header = NULL;
    Octstr *value = NULL;

    header = parse_get_nul_string(context);
    value = parse_get_nul_string(context);

    if (header && value) {
        http_header_add(unpacked, octstr_get_cstr(header),
                        octstr_get_cstr(value));
    }

    if (parse_error(context))
        warning(0, "Error parsing application-header.");

    octstr_destroy(header);
    octstr_destroy(value);
}

wsp_unpack_date_value()

Octstr* wsp_unpack_date_value

(

ParseContext *

context

)

Definition at line 492 of file wsp_headers.c.

References date_format_http(), parse_get_char(), unpack_multi_octet_integer(), and warning().

Referenced by unpack_retry_after(), and wsp_unpack_well_known_field().

{
    unsigned long timeval;
    int length;

    length = parse_get_char(context);
    if (length > 30) {
        warning(0, "WSP headers: bad date-value.");
        return NULL;
    }

    timeval = unpack_multi_octet_integer(context, length);
    if (timeval < 0) {
        warning(0, "WSP headers: cannot unpack date-value.");
        return NULL;
    }

    return date_format_http(timeval);
}

wsp_unpack_integer_value()

Octstr* wsp_unpack_integer_value

(

ParseContext *

context

)

Definition at line 214 of file wsp_headers.c.

References octstr_append_decimal(), octstr_create, parse_get_char(), unpack_multi_octet_integer(), and warning().

Referenced by unpack_cache_directive(), unpack_retry_after(), and unpack_warning_value().

{
    Octstr *decoded;
    unsigned long value;
    int val;

    val = parse_get_char(context);
    if (val < 31) {
        value = unpack_multi_octet_integer(context, val);
    } else if (val > 127) {
        value = val - 128;
    } else {
        warning(0, "WSP headers: bad integer-value.");
        return NULL;
    }

    decoded = octstr_create("");
    octstr_append_decimal(decoded, value);
    return decoded;
}

wsp_unpack_version_value()

Octstr* wsp_unpack_version_value

(

long

value

)

Definition at line 291 of file wsp_headers.c.

References octstr_append_char(), octstr_append_decimal(), and octstr_create.

Referenced by unpack_encoding_version(), and unpack_parameter().

{
    Octstr *result;
    int major, minor;

    major = ((value >> 4) & 0x7);
    minor = (value & 0xf);

    result = octstr_create("");
    octstr_append_char(result, major + '0');
    if (minor != 15) {
        octstr_append_char(result, '.');
        octstr_append_decimal(result, minor);
    }

    return result;
}

wsp_unpack_well_known_field()

void wsp_unpack_well_known_field	(	List *	unpacked,
		int	field_type,
		ParseContext *	context
	)

Definition at line 1030 of file wsp_headers.c.

References http_header_add(), octstr_append_decimal(), octstr_binary_to_base64(), octstr_create, octstr_delete(), octstr_destroy(), octstr_get_cstr, octstr_len(), panic, parse_error(), parse_get_nul_string(), parse_get_octets(), parse_octets_left(), parse_pop_limit(), parse_skip(), parse_skip_to_limit(), proxy_unpack_credentials(), unpack_accept_language_general_form(), unpack_cache_directive(), unpack_challenge(), unpack_content_range(), unpack_credentials(), unpack_disposition(), unpack_encoding_version(), unpack_multi_octet_integer(), unpack_parameter(), unpack_range_value(), unpack_retry_after(), unpack_warning_value(), warning(), wsp_field_value(), WSP_FIELD_VALUE_DATA, WSP_FIELD_VALUE_ENCODED, WSP_FIELD_VALUE_NUL_STRING, wsp_unpack_accept_charset_general_form(), wsp_unpack_accept_general_form(), and wsp_unpack_date_value().

Referenced by wsp_headers_unpack().

{
    int val, ret;
    unsigned char *headername = NULL;
    unsigned char *ch = NULL;
    Octstr *decoded = NULL;

    ret = wsp_field_value(context, &val);
    if (parse_error(context)) {
        warning(0, "Faulty header, skipping remaining headers.");
        parse_skip_to_limit(context);
        return;
    }

    headername = wsp_header_to_cstr(field_type);
    /* headername can still be NULL.  This is checked after parsing
     * the field value.  We want to parse the value before exiting,
     * so that we are ready for the next header. */

    /* The following code must set "ch" or "decoded" to a non-NULL
     * value if the header is valid. */

    if (ret == WSP_FIELD_VALUE_NUL_STRING) {
        /* We allow any header to have a text value, even if that
         * is not defined in the grammar.  Be generous in what
         * you accept, etc. */
        /* This covers Text-string, Token-Text, and Uri-value rules */
        decoded = parse_get_nul_string(context);
    } else if (ret == WSP_FIELD_VALUE_ENCODED) {
        switch (field_type) {
        case WSP_HEADER_ACCEPT:
        case WSP_HEADER_CONTENT_TYPE:
            ch = wsp_content_type_to_cstr(val);
            if (!ch)
                warning(0, "Unknown content type 0x%02x.", val);
            break;

        case WSP_HEADER_ACCEPT_CHARSET:
            ch = wsp_charset_to_cstr(val);
            if (!ch)
                warning(0, "Unknown charset 0x%02x.", val);
            break;

        case WSP_HEADER_ACCEPT_ENCODING:
        case WSP_HEADER_CONTENT_ENCODING:
            ch = wsp_encoding_to_cstr(val);
            if (!ch)
                warning(0, "Unknown encoding 0x%02x.", val);
            break;

        case WSP_HEADER_ACCEPT_LANGUAGE:
        case WSP_HEADER_CONTENT_LANGUAGE:
            ch = wsp_language_to_cstr(val);
            if (!ch)
                warning(0, "Unknown language 0x%02x.", val);
            break;

        case WSP_HEADER_ACCEPT_RANGES:
            ch = wsp_ranges_to_cstr(val);
            if (!ch)
                warning(0, "Unknown ranges value 0x%02x.", val);
            break;

        case WSP_HEADER_AGE:
        case WSP_HEADER_CONTENT_LENGTH:
        case WSP_HEADER_MAX_FORWARDS:
            /* Short-integer version of Integer-value */
            decoded = octstr_create("");
            octstr_append_decimal(decoded, val);
            break;

        case WSP_HEADER_ALLOW:
        case WSP_HEADER_PUBLIC:
            ch = wsp_method_to_cstr(val);
            if (!ch) {
                /* FIXME Support extended methods */
                warning(0, "Unknown method 0x%02x.", val);
            }
            break;

        case WSP_HEADER_CACHE_CONTROL:
        case WSP_HEADER_CACHE_CONTROL_V13:
        case WSP_HEADER_CACHE_CONTROL_V14:
            ch = wsp_cache_control_to_cstr(val);
            if (!ch)
                warning(0, "Unknown cache-control value 0x%02x.", val);
            break;

        case WSP_HEADER_CONNECTION:
            ch = wsp_connection_to_cstr(val);
            if (!ch)
                warning(0, "Unknown connection value 0x%02x.", val);
            break;


        case WSP_HEADER_PRAGMA:
            if (val == 0)
                ch = (unsigned char *)"no-cache";
            else
                warning(0, "Unknown pragma value 0x%02x.", val);
            break;

        case WSP_HEADER_TRANSFER_ENCODING:
            ch = wsp_transfer_encoding_to_cstr(val);
            if (!ch)
                warning(0, "Unknown transfer encoding value 0x%02x.", val);
            break;

        case WSP_HEADER_VARY:
            ch = wsp_header_to_cstr(val);
            if (!ch)
                warning(0, "Unknown Vary field name 0x%02x.", val);
            break;

        case WSP_HEADER_WARNING:
            decoded = octstr_create("");
            octstr_append_decimal(decoded, val);
            break;

        case WSP_HEADER_BEARER_INDICATION:
             ch = wsp_bearer_indication_to_cstr(val);
             if (!ch)
                 warning(0, "Unknown Bearer-Indication field name 0x%02x.", val);
             break;

        case WSP_HEADER_ACCEPT_APPLICATION:
             ch = wsp_application_id_to_cstr(val);
             if (!ch)
                 warning(0, "Unknown Accept-Application field name 0x%02x.", val);
             break;

        default:
            if (headername) {
                warning(0, "Did not expect short-integer with "
                        "'%s' header, skipping.", headername);
            }
            break;
        }
    } else if (ret == WSP_FIELD_VALUE_DATA) {
        switch (field_type) {
        case WSP_HEADER_ACCEPT:
        case WSP_HEADER_CONTENT_TYPE:
            /* Content-general-form and Accept-general-form
             * are defined separately in WSP, but their
             * definitions are equivalent. */
            decoded = wsp_unpack_accept_general_form(context);
            break;

        case WSP_HEADER_ACCEPT_CHARSET:
            decoded = wsp_unpack_accept_charset_general_form(context);
            break;

        case WSP_HEADER_ACCEPT_LANGUAGE:
            decoded = unpack_accept_language_general_form(context);
            break;

        case WSP_HEADER_AGE:
        case WSP_HEADER_CONTENT_LENGTH:
        case WSP_HEADER_MAX_FORWARDS:
        case WSP_HEADER_BEARER_INDICATION:
        case WSP_HEADER_ACCEPT_APPLICATION:
            /* Long-integer version of Integer-value */
            {
                long l = unpack_multi_octet_integer(context,
                                                    parse_octets_left(context));
                decoded = octstr_create("");
                octstr_append_decimal(decoded, l);
            }
            break;

        case WSP_HEADER_AUTHORIZATION:
            decoded = unpack_credentials(context);
            break;

        case WSP_HEADER_PROXY_AUTHORIZATION:
            decoded = proxy_unpack_credentials(context);
            break;

        case WSP_HEADER_CACHE_CONTROL:
            decoded = unpack_cache_directive(context);
            break;

        case WSP_HEADER_CONTENT_MD5:
            decoded = parse_get_octets(context,
                                       parse_octets_left(context));
            octstr_binary_to_base64(decoded);
            /* Zap the CR LF sequence at the end */
            octstr_delete(decoded, octstr_len(decoded) - 2, 2);
            break;

        case WSP_HEADER_CONTENT_RANGE:
            decoded = unpack_content_range(context);
            break;

        case WSP_HEADER_DATE:
        case WSP_HEADER_EXPIRES:
        case WSP_HEADER_IF_MODIFIED_SINCE:
        case WSP_HEADER_IF_RANGE:
        case WSP_HEADER_IF_UNMODIFIED_SINCE:
        case WSP_HEADER_LAST_MODIFIED:
            /* Back up to get the length byte again */
            parse_skip(context, -1);
            decoded = wsp_unpack_date_value(context);
            break;

        case WSP_HEADER_PRAGMA:
            /* The value is a bare Parameter, without a preceding
             * header body.  unpack_parameter wasn't really
             * designed for this.  We work around it here. */
            decoded = octstr_create("");
            if (unpack_parameter(context, decoded) < 0) {
                octstr_destroy(decoded);
                decoded = NULL;
            } else {
                /* Remove the leading "; " */
                octstr_delete(decoded, 0, 2);
            }
            break;

        case WSP_HEADER_PROXY_AUTHENTICATE:
        case WSP_HEADER_WWW_AUTHENTICATE:
            decoded = unpack_challenge(context);
            break;

        case WSP_HEADER_RANGE:
            decoded = unpack_range_value(context);
            break;

        case WSP_HEADER_RETRY_AFTER:
            decoded = unpack_retry_after(context);
            break;

        case WSP_HEADER_WARNING:
            decoded = unpack_warning_value(context);
            break;

        case WSP_HEADER_CONTENT_DISPOSITION:
            decoded = unpack_disposition(context);
            break;

        case WSP_HEADER_ENCODING_VERSION:
            decoded = unpack_encoding_version(context);
            break;

        default:
            if (headername) {
                warning(0, "Did not expect value-length with "
                        "'%s' header, skipping.", headername);
            }
            break;
        }
        if (headername && parse_octets_left(context) > 0) {
            warning(0, "WSP: %s: skipping %ld trailing octets.",
                    headername, parse_octets_left(context));
        }
        parse_skip_to_limit(context);
        parse_pop_limit(context);
    } else {
        panic(0, "Unknown field-value type %d.", ret);
    }

    if (ch == NULL && decoded != NULL)
        ch = (unsigned char *)octstr_get_cstr(decoded);
    if (ch == NULL)
        goto value_error;

    if (!headername) {
        warning(0, "Unknown header number 0x%02x.", field_type);
        goto value_error;
    }

    http_header_add(unpacked, (char *)headername,(char *) ch);
    octstr_destroy(decoded);
    return;

value_error:
    warning(0, "Skipping faulty header.");
    octstr_destroy(decoded);
}