2001-09-09 22:24:39 -04:00
|
|
|
/* Httpp.c
|
|
|
|
**
|
|
|
|
** http parsing engine
|
2014-12-05 04:31:08 -05:00
|
|
|
**
|
|
|
|
** Copyright (C) 2014 Michael Smith <msmith@icecast.org>,
|
|
|
|
** Ralph Giles <giles@xiph.org>,
|
|
|
|
** Ed "oddsock" Zaleski <oddsock@xiph.org>,
|
|
|
|
** Karl Heyes <karl@xiph.org>,
|
|
|
|
** Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>
|
|
|
|
**
|
|
|
|
** This library is free software; you can redistribute it and/or
|
|
|
|
** modify it under the terms of the GNU Library General Public
|
|
|
|
** License as published by the Free Software Foundation; either
|
|
|
|
** version 2 of the License, or (at your option) any later version.
|
|
|
|
**
|
|
|
|
** This library is distributed in the hope that it will be useful,
|
|
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
** Library General Public License for more details.
|
|
|
|
**
|
|
|
|
** You should have received a copy of the GNU Library General Public
|
|
|
|
** License along with this library; if not, write to the
|
|
|
|
** Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
|
|
** Boston, MA 02110-1301, USA.
|
|
|
|
**
|
2001-09-09 22:24:39 -04:00
|
|
|
*/
|
|
|
|
|
2003-03-08 11:05:38 -05:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include <config.h>
|
|
|
|
#endif
|
|
|
|
|
2002-04-05 04:28:26 -05:00
|
|
|
#include <stdio.h>
|
|
|
|
|
2001-09-09 22:24:39 -04:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <ctype.h>
|
2003-06-05 13:09:12 -04:00
|
|
|
#ifdef HAVE_STRINGS_H
|
|
|
|
#include <strings.h>
|
|
|
|
#endif
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2003-03-09 17:56:46 -05:00
|
|
|
#include <avl/avl.h>
|
2001-09-09 22:24:39 -04:00
|
|
|
#include "httpp.h"
|
|
|
|
|
2002-04-05 04:28:26 -05:00
|
|
|
#define MAX_HEADERS 32
|
|
|
|
|
2001-09-09 22:24:39 -04:00
|
|
|
/* internal functions */
|
|
|
|
|
|
|
|
/* misc */
|
2003-06-18 07:13:11 -04:00
|
|
|
static char *_lowercase(char *str);
|
2001-09-09 22:24:39 -04:00
|
|
|
|
|
|
|
/* for avl trees */
|
2003-07-06 21:49:27 -04:00
|
|
|
static int _compare_vars(void *compare_arg, void *a, void *b);
|
|
|
|
static int _free_vars(void *key);
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2018-06-18 10:39:03 -04:00
|
|
|
/* For avl tree manipulation */
|
|
|
|
static void parse_query(avl_tree *tree, const char *query, size_t len);
|
|
|
|
static const char *_httpp_get_param(avl_tree *tree, const char *name);
|
2018-07-26 08:55:10 -04:00
|
|
|
static void _httpp_set_param_nocopy(avl_tree *tree, char *name, char *value, int replace);
|
2018-06-18 10:39:03 -04:00
|
|
|
static void _httpp_set_param(avl_tree *tree, const char *name, const char *value);
|
2018-07-26 08:55:10 -04:00
|
|
|
static http_var_t *_httpp_get_param_var(avl_tree *tree, const char *name);
|
2018-06-18 10:39:03 -04:00
|
|
|
|
2018-08-02 05:00:32 -04:00
|
|
|
httpp_request_info_t httpp_request_info(httpp_request_type_e req)
|
|
|
|
{
|
|
|
|
#if 0
|
|
|
|
#define HTTPP_REQUEST_IS_SAFE ((httpp_request_info_t)0x0001U)
|
|
|
|
#define HTTPP_REQUEST_IS_IDEMPOTENT ((httpp_request_info_t)0x0002U)
|
|
|
|
#define HTTPP_REQUEST_IS_CACHEABLE ((httpp_request_info_t)0x0004U)
|
|
|
|
#define HTTPP_REQUEST_HAS_RESPONSE_BODY ((httpp_request_info_t)0x0010U)
|
|
|
|
#define HTTPP_REQUEST_HAS_REQUEST_BODY ((httpp_request_info_t)0x0100U)
|
|
|
|
#define HTTPP_REQUEST_HAS_OPTIONAL_REQUEST_BODY ((httpp_request_info_t)0x0200U)
|
|
|
|
#endif
|
|
|
|
switch (req) {
|
|
|
|
/* offical methods */
|
|
|
|
case httpp_req_get:
|
|
|
|
return HTTPP_REQUEST_IS_SAFE|HTTPP_REQUEST_IS_IDEMPOTENT|HTTPP_REQUEST_IS_CACHEABLE|HTTPP_REQUEST_HAS_RESPONSE_BODY|HTTPP_REQUEST_HAS_OPTIONAL_REQUEST_BODY;
|
|
|
|
break;
|
|
|
|
case httpp_req_post:
|
|
|
|
return HTTPP_REQUEST_IS_CACHEABLE|HTTPP_REQUEST_HAS_RESPONSE_BODY|HTTPP_REQUEST_HAS_REQUEST_BODY;
|
|
|
|
break;
|
|
|
|
case httpp_req_put:
|
|
|
|
return HTTPP_REQUEST_IS_IDEMPOTENT|HTTPP_REQUEST_HAS_RESPONSE_BODY|HTTPP_REQUEST_HAS_REQUEST_BODY;
|
|
|
|
break;
|
|
|
|
case httpp_req_head:
|
|
|
|
return HTTPP_REQUEST_IS_SAFE|HTTPP_REQUEST_IS_IDEMPOTENT|HTTPP_REQUEST_IS_CACHEABLE;
|
|
|
|
break;
|
|
|
|
case httpp_req_options:
|
|
|
|
return HTTPP_REQUEST_IS_SAFE|HTTPP_REQUEST_IS_IDEMPOTENT|HTTPP_REQUEST_HAS_RESPONSE_BODY|HTTPP_REQUEST_HAS_OPTIONAL_REQUEST_BODY;
|
|
|
|
break;
|
|
|
|
case httpp_req_delete:
|
|
|
|
return HTTPP_REQUEST_IS_IDEMPOTENT|HTTPP_REQUEST_HAS_RESPONSE_BODY;
|
|
|
|
break;
|
|
|
|
case httpp_req_trace:
|
|
|
|
return HTTPP_REQUEST_IS_SAFE|HTTPP_REQUEST_IS_IDEMPOTENT|HTTPP_REQUEST_HAS_RESPONSE_BODY;
|
|
|
|
break;
|
|
|
|
case httpp_req_connect:
|
|
|
|
return HTTPP_REQUEST_HAS_RESPONSE_BODY|HTTPP_REQUEST_HAS_REQUEST_BODY;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Icecast specific methods */
|
|
|
|
case httpp_req_source:
|
|
|
|
return HTTPP_REQUEST_HAS_RESPONSE_BODY|HTTPP_REQUEST_HAS_REQUEST_BODY;
|
|
|
|
break;
|
|
|
|
case httpp_req_play:
|
|
|
|
return HTTPP_REQUEST_IS_SAFE|HTTPP_REQUEST_HAS_RESPONSE_BODY|HTTPP_REQUEST_HAS_OPTIONAL_REQUEST_BODY;
|
|
|
|
break;
|
|
|
|
case httpp_req_stats:
|
|
|
|
return HTTPP_REQUEST_IS_SAFE|HTTPP_REQUEST_HAS_RESPONSE_BODY|HTTPP_REQUEST_HAS_OPTIONAL_REQUEST_BODY;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Virtual and other methods */
|
|
|
|
case httpp_req_none:
|
|
|
|
case httpp_req_unknown:
|
|
|
|
default:
|
|
|
|
return HTTPP_REQUEST_HAS_RESPONSE_BODY|HTTPP_REQUEST_HAS_OPTIONAL_REQUEST_BODY;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-09-09 22:24:39 -04:00
|
|
|
http_parser_t *httpp_create_parser(void)
|
|
|
|
{
|
2018-08-09 05:25:26 -04:00
|
|
|
http_parser_t *parser = calloc(1, sizeof(http_parser_t));
|
2003-03-14 21:10:19 -05:00
|
|
|
|
2018-08-09 05:25:26 -04:00
|
|
|
parser->refc = 1;
|
2003-03-14 21:10:19 -05:00
|
|
|
parser->req_type = httpp_req_none;
|
|
|
|
parser->uri = NULL;
|
|
|
|
parser->vars = avl_tree_new(_compare_vars, NULL);
|
|
|
|
parser->queryvars = avl_tree_new(_compare_vars, NULL);
|
2018-06-18 10:39:03 -04:00
|
|
|
parser->postvars = avl_tree_new(_compare_vars, NULL);
|
2003-03-14 21:10:19 -05:00
|
|
|
|
2018-08-09 05:25:26 -04:00
|
|
|
return parser;
|
|
|
|
}
|
|
|
|
|
|
|
|
void httpp_initialize(http_parser_t *parser, http_varlist_t *defaults)
|
|
|
|
{
|
|
|
|
http_varlist_t *list;
|
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
/* now insert the default variables */
|
|
|
|
list = defaults;
|
|
|
|
while (list != NULL) {
|
2018-07-26 08:55:10 -04:00
|
|
|
size_t i;
|
|
|
|
|
|
|
|
for (i = 0; i < list->var.values; i++) {
|
|
|
|
httpp_setvar(parser, list->var.name, list->var.value[i]);
|
|
|
|
}
|
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
list = list->next;
|
|
|
|
}
|
2001-09-09 22:24:39 -04:00
|
|
|
}
|
|
|
|
|
2002-08-05 10:48:04 -04:00
|
|
|
static int split_headers(char *data, unsigned long len, char **line)
|
2001-09-09 22:24:39 -04:00
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
/* first we count how many lines there are
|
|
|
|
** and set up the line[] array
|
|
|
|
*/
|
|
|
|
int lines = 0;
|
2003-01-17 04:01:04 -05:00
|
|
|
unsigned long i;
|
2003-03-14 21:10:19 -05:00
|
|
|
line[lines] = data;
|
|
|
|
for (i = 0; i < len && lines < MAX_HEADERS; i++) {
|
|
|
|
if (data[i] == '\r')
|
|
|
|
data[i] = '\0';
|
|
|
|
if (data[i] == '\n') {
|
|
|
|
lines++;
|
|
|
|
data[i] = '\0';
|
2004-08-09 20:03:14 -04:00
|
|
|
if (lines >= MAX_HEADERS)
|
|
|
|
return MAX_HEADERS;
|
2003-03-14 21:10:19 -05:00
|
|
|
if (i + 1 < len) {
|
|
|
|
if (data[i + 1] == '\n' || data[i + 1] == '\r')
|
|
|
|
break;
|
|
|
|
line[lines] = &data[i + 1];
|
2002-02-11 04:11:18 -05:00
|
|
|
}
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
|
|
|
}
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
i++;
|
2004-08-09 20:03:14 -04:00
|
|
|
while (i < len && data[i] == '\n') i++;
|
2002-08-05 10:48:04 -04:00
|
|
|
|
|
|
|
return lines;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void parse_headers(http_parser_t *parser, char **line, int lines)
|
|
|
|
{
|
2014-11-07 18:14:00 -05:00
|
|
|
int i, l;
|
|
|
|
int whitespace, slen;
|
2003-03-14 21:10:19 -05:00
|
|
|
char *name = NULL;
|
|
|
|
char *value = NULL;
|
|
|
|
|
|
|
|
/* parse the name: value lines. */
|
|
|
|
for (l = 1; l < lines; l++) {
|
|
|
|
whitespace = 0;
|
|
|
|
name = line[l];
|
|
|
|
value = NULL;
|
|
|
|
slen = strlen(line[l]);
|
|
|
|
for (i = 0; i < slen; i++) {
|
|
|
|
if (line[l][i] == ':') {
|
|
|
|
whitespace = 1;
|
|
|
|
line[l][i] = '\0';
|
|
|
|
} else {
|
|
|
|
if (whitespace) {
|
|
|
|
whitespace = 0;
|
|
|
|
while (i < slen && line[l][i] == ' ')
|
|
|
|
i++;
|
|
|
|
|
|
|
|
if (i < slen)
|
|
|
|
value = &line[l][i];
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (name != NULL && value != NULL) {
|
|
|
|
httpp_setvar(parser, _lowercase(name), value);
|
|
|
|
name = NULL;
|
|
|
|
value = NULL;
|
|
|
|
}
|
|
|
|
}
|
2002-08-05 10:48:04 -04:00
|
|
|
}
|
|
|
|
|
2007-08-16 18:52:24 -04:00
|
|
|
int httpp_parse_response(http_parser_t *parser, const char *http_data, unsigned long len, const char *uri)
|
2002-08-05 10:48:04 -04:00
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
char *data;
|
|
|
|
char *line[MAX_HEADERS];
|
|
|
|
int lines, slen,i, whitespace=0, where=0,code;
|
|
|
|
char *version=NULL, *resp_code=NULL, *message=NULL;
|
2002-08-05 10:48:04 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
if(http_data == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* make a local copy of the data, including 0 terminator */
|
|
|
|
data = (char *)malloc(len+1);
|
|
|
|
if (data == NULL) return 0;
|
|
|
|
memcpy(data, http_data, len);
|
|
|
|
data[len] = 0;
|
|
|
|
|
|
|
|
lines = split_headers(data, len, line);
|
|
|
|
|
|
|
|
/* In this case, the first line contains:
|
|
|
|
* VERSION RESPONSE_CODE MESSAGE, such as HTTP/1.0 200 OK
|
|
|
|
*/
|
|
|
|
slen = strlen(line[0]);
|
|
|
|
version = line[0];
|
|
|
|
for(i=0; i < slen; i++) {
|
|
|
|
if(line[0][i] == ' ') {
|
|
|
|
line[0][i] = 0;
|
|
|
|
whitespace = 1;
|
|
|
|
} else if(whitespace) {
|
|
|
|
whitespace = 0;
|
|
|
|
where++;
|
|
|
|
if(where == 1)
|
|
|
|
resp_code = &line[0][i];
|
|
|
|
else {
|
|
|
|
message = &line[0][i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(version == NULL || resp_code == NULL || message == NULL) {
|
|
|
|
free(data);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_ERROR_CODE, resp_code);
|
|
|
|
code = atoi(resp_code);
|
|
|
|
if(code < 200 || code >= 300) {
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_ERROR_MESSAGE, message);
|
|
|
|
}
|
|
|
|
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_URI, uri);
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "NONE");
|
|
|
|
|
|
|
|
parse_headers(parser, line, lines);
|
|
|
|
|
|
|
|
free(data);
|
|
|
|
|
|
|
|
return 1;
|
2002-08-05 10:48:04 -04:00
|
|
|
}
|
|
|
|
|
2018-06-18 10:39:03 -04:00
|
|
|
int httpp_parse_postdata(http_parser_t *parser, const char *body_data, size_t len)
|
|
|
|
{
|
|
|
|
const char *header = httpp_getvar(parser, "content-type");
|
|
|
|
|
|
|
|
if (strcasecmp(header, "application/x-www-form-urlencoded") != 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
parse_query(parser->postvars, body_data, len);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-12-31 01:28:39 -05:00
|
|
|
static int hex(char c)
|
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
if(c >= '0' && c <= '9')
|
|
|
|
return c - '0';
|
|
|
|
else if(c >= 'A' && c <= 'F')
|
|
|
|
return c - 'A' + 10;
|
|
|
|
else if(c >= 'a' && c <= 'f')
|
|
|
|
return c - 'a' + 10;
|
|
|
|
else
|
|
|
|
return -1;
|
2002-12-31 01:28:39 -05:00
|
|
|
}
|
|
|
|
|
2018-06-18 10:39:03 -04:00
|
|
|
static char *url_unescape(const char *src, size_t len)
|
2002-12-31 01:28:39 -05:00
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
unsigned char *decoded;
|
2018-06-18 10:39:03 -04:00
|
|
|
size_t i;
|
2003-03-14 21:10:19 -05:00
|
|
|
char *dst;
|
|
|
|
int done = 0;
|
|
|
|
|
|
|
|
decoded = calloc(1, len + 1);
|
|
|
|
|
2007-08-16 18:52:24 -04:00
|
|
|
dst = (char *)decoded;
|
2003-03-14 21:10:19 -05:00
|
|
|
|
|
|
|
for(i=0; i < len; i++) {
|
|
|
|
switch(src[i]) {
|
|
|
|
case '%':
|
|
|
|
if(i+2 >= len) {
|
|
|
|
free(decoded);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if(hex(src[i+1]) == -1 || hex(src[i+2]) == -1 ) {
|
|
|
|
free(decoded);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
*dst++ = hex(src[i+1]) * 16 + hex(src[i+2]);
|
|
|
|
i+= 2;
|
|
|
|
break;
|
2004-12-07 17:42:50 -05:00
|
|
|
case '+':
|
|
|
|
*dst++ = ' ';
|
|
|
|
break;
|
2003-03-14 21:10:19 -05:00
|
|
|
case '#':
|
|
|
|
done = 1;
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
free(decoded);
|
|
|
|
return NULL;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
*dst++ = src[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if(done)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
*dst = 0; /* null terminator */
|
|
|
|
|
2007-08-16 18:52:24 -04:00
|
|
|
return (char *)decoded;
|
2002-12-31 01:28:39 -05:00
|
|
|
}
|
|
|
|
|
2018-06-18 10:39:03 -04:00
|
|
|
static void parse_query_element(avl_tree *tree, const char *start, const char *mid, const char *end)
|
2002-12-31 01:28:39 -05:00
|
|
|
{
|
2018-06-18 10:39:03 -04:00
|
|
|
size_t keylen;
|
|
|
|
char *key;
|
|
|
|
size_t valuelen;
|
|
|
|
char *value;
|
|
|
|
|
|
|
|
if (start >= end)
|
|
|
|
return;
|
2003-03-14 21:10:19 -05:00
|
|
|
|
2018-06-18 10:39:03 -04:00
|
|
|
if (!mid)
|
2003-03-14 21:10:19 -05:00
|
|
|
return;
|
|
|
|
|
2018-06-18 10:39:03 -04:00
|
|
|
keylen = mid - start;
|
|
|
|
valuelen = end - mid - 1;
|
2003-03-14 21:10:19 -05:00
|
|
|
|
2018-06-18 10:39:03 -04:00
|
|
|
/* REVIEW: We ignore keys with empty values. */
|
|
|
|
if (!keylen || !valuelen)
|
|
|
|
return;
|
|
|
|
|
|
|
|
key = malloc(keylen + 1);
|
|
|
|
memcpy(key, start, keylen);
|
|
|
|
key[keylen] = 0;
|
|
|
|
|
|
|
|
value = url_unescape(mid + 1, valuelen);
|
|
|
|
|
2018-07-26 08:55:10 -04:00
|
|
|
_httpp_set_param_nocopy(tree, key, value, 0);
|
2018-06-18 10:39:03 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void parse_query(avl_tree *tree, const char *query, size_t len)
|
|
|
|
{
|
|
|
|
const char *start = query;
|
|
|
|
const char *mid = NULL;
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
if (!query || !*query)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
switch (query[i]) {
|
|
|
|
case '&':
|
|
|
|
parse_query_element(tree, start, mid, &(query[i]));
|
|
|
|
start = &(query[i + 1]);
|
|
|
|
mid = NULL;
|
2003-03-14 21:10:19 -05:00
|
|
|
break;
|
2018-06-18 10:39:03 -04:00
|
|
|
case '=':
|
|
|
|
mid = &(query[i]);
|
2003-03-14 21:10:19 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-18 10:39:03 -04:00
|
|
|
parse_query_element(tree, start, mid, &(query[i]));
|
2002-12-31 01:28:39 -05:00
|
|
|
}
|
|
|
|
|
2007-08-16 18:52:24 -04:00
|
|
|
int httpp_parse(http_parser_t *parser, const char *http_data, unsigned long len)
|
2002-08-05 10:48:04 -04:00
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
char *data, *tmp;
|
|
|
|
char *line[MAX_HEADERS]; /* limited to 32 lines, should be more than enough */
|
|
|
|
int i;
|
|
|
|
int lines;
|
|
|
|
char *req_type = NULL;
|
|
|
|
char *uri = NULL;
|
|
|
|
char *version = NULL;
|
|
|
|
int whitespace, where, slen;
|
|
|
|
|
|
|
|
if (http_data == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* make a local copy of the data, including 0 terminator */
|
|
|
|
data = (char *)malloc(len+1);
|
|
|
|
if (data == NULL) return 0;
|
|
|
|
memcpy(data, http_data, len);
|
|
|
|
data[len] = 0;
|
|
|
|
|
|
|
|
lines = split_headers(data, len, line);
|
|
|
|
|
|
|
|
/* parse the first line special
|
|
|
|
** the format is:
|
|
|
|
** REQ_TYPE URI VERSION
|
|
|
|
** eg:
|
|
|
|
** GET /index.html HTTP/1.0
|
|
|
|
*/
|
|
|
|
where = 0;
|
|
|
|
whitespace = 0;
|
|
|
|
slen = strlen(line[0]);
|
|
|
|
req_type = line[0];
|
|
|
|
for (i = 0; i < slen; i++) {
|
|
|
|
if (line[0][i] == ' ') {
|
|
|
|
whitespace = 1;
|
|
|
|
line[0][i] = '\0';
|
|
|
|
} else {
|
|
|
|
/* we're just past the whitespace boundry */
|
|
|
|
if (whitespace) {
|
|
|
|
whitespace = 0;
|
|
|
|
where++;
|
|
|
|
switch (where) {
|
2018-09-12 05:22:46 -04:00
|
|
|
case 1:
|
|
|
|
uri = &line[0][i];
|
2003-03-14 21:10:19 -05:00
|
|
|
break;
|
2018-09-12 05:22:46 -04:00
|
|
|
case 2:
|
|
|
|
version = &line[0][i];
|
2003-03-14 21:10:19 -05:00
|
|
|
break;
|
2018-09-12 05:26:59 -04:00
|
|
|
case 3:
|
|
|
|
/* There is an extra element in the request line. This is not HTTP. */
|
|
|
|
free(data);
|
|
|
|
return 0;
|
|
|
|
break;
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-21 23:44:47 -05:00
|
|
|
parser->req_type = httpp_str_to_method(req_type);
|
2003-03-14 21:10:19 -05:00
|
|
|
|
|
|
|
if (uri != NULL && strlen(uri) > 0) {
|
|
|
|
char *query;
|
|
|
|
if((query = strchr(uri, '?')) != NULL) {
|
2005-06-14 22:32:26 -04:00
|
|
|
httpp_setvar(parser, HTTPP_VAR_RAWURI, uri);
|
2009-07-07 12:37:31 -04:00
|
|
|
httpp_setvar(parser, HTTPP_VAR_QUERYARGS, query);
|
2003-03-14 21:10:19 -05:00
|
|
|
*query = 0;
|
|
|
|
query++;
|
2018-06-18 10:39:03 -04:00
|
|
|
parse_query(parser->queryvars, query, strlen(query));
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
parser->uri = strdup(uri);
|
|
|
|
} else {
|
2003-03-07 23:57:02 -05:00
|
|
|
free(data);
|
|
|
|
return 0;
|
|
|
|
}
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
if ((version != NULL) && ((tmp = strchr(version, '/')) != NULL)) {
|
|
|
|
tmp[0] = '\0';
|
|
|
|
if ((strlen(version) > 0) && (strlen(&tmp[1]) > 0)) {
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_PROTOCOL, version);
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_VERSION, &tmp[1]);
|
|
|
|
} else {
|
|
|
|
free(data);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
free(data);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parser->req_type != httpp_req_none && parser->req_type != httpp_req_unknown) {
|
|
|
|
switch (parser->req_type) {
|
|
|
|
case httpp_req_get:
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "GET");
|
|
|
|
break;
|
|
|
|
case httpp_req_post:
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "POST");
|
|
|
|
break;
|
2012-07-16 12:05:21 -04:00
|
|
|
case httpp_req_put:
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "PUT");
|
|
|
|
break;
|
2003-03-14 21:10:19 -05:00
|
|
|
case httpp_req_head:
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "HEAD");
|
|
|
|
break;
|
2015-02-10 03:33:30 -05:00
|
|
|
case httpp_req_options:
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "OPTIONS");
|
|
|
|
break;
|
|
|
|
case httpp_req_delete:
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "DELETE");
|
|
|
|
break;
|
|
|
|
case httpp_req_trace:
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "TRACE");
|
|
|
|
break;
|
|
|
|
case httpp_req_connect:
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "CONNECT");
|
|
|
|
break;
|
2003-03-14 21:10:19 -05:00
|
|
|
case httpp_req_source:
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "SOURCE");
|
|
|
|
break;
|
|
|
|
case httpp_req_play:
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "PLAY");
|
|
|
|
break;
|
|
|
|
case httpp_req_stats:
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_REQ_TYPE, "STATS");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
free(data);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parser->uri != NULL) {
|
|
|
|
httpp_setvar(parser, HTTPP_VAR_URI, parser->uri);
|
|
|
|
} else {
|
|
|
|
free(data);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
parse_headers(parser, line, lines);
|
|
|
|
|
|
|
|
free(data);
|
|
|
|
|
|
|
|
return 1;
|
2001-09-09 22:24:39 -04:00
|
|
|
}
|
|
|
|
|
2009-07-07 12:37:31 -04:00
|
|
|
void httpp_deletevar(http_parser_t *parser, const char *name)
|
|
|
|
{
|
|
|
|
http_var_t var;
|
|
|
|
|
|
|
|
if (parser == NULL || name == NULL)
|
|
|
|
return;
|
2018-07-26 07:57:44 -04:00
|
|
|
memset(&var, 0, sizeof(var));
|
|
|
|
|
2009-07-07 12:37:31 -04:00
|
|
|
var.name = (char*)name;
|
2018-07-26 07:57:44 -04:00
|
|
|
|
2009-07-07 12:37:31 -04:00
|
|
|
avl_delete(parser->vars, (void *)&var, _free_vars);
|
|
|
|
}
|
|
|
|
|
2005-06-14 22:32:26 -04:00
|
|
|
void httpp_setvar(http_parser_t *parser, const char *name, const char *value)
|
2001-09-09 22:24:39 -04:00
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
http_var_t *var;
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
if (name == NULL || value == NULL)
|
|
|
|
return;
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2018-07-26 07:57:44 -04:00
|
|
|
var = (http_var_t *)calloc(1, sizeof(http_var_t));
|
2003-03-14 21:10:19 -05:00
|
|
|
if (var == NULL) return;
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2018-07-26 08:55:10 -04:00
|
|
|
var->value = calloc(1, sizeof(*var->value));
|
|
|
|
if (!var->value) {
|
|
|
|
free(var);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
var->name = strdup(name);
|
2018-07-26 08:55:10 -04:00
|
|
|
var->values = 1;
|
|
|
|
var->value[0] = strdup(value);
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
if (httpp_getvar(parser, name) == NULL) {
|
|
|
|
avl_insert(parser->vars, (void *)var);
|
|
|
|
} else {
|
|
|
|
avl_delete(parser->vars, (void *)var, _free_vars);
|
|
|
|
avl_insert(parser->vars, (void *)var);
|
|
|
|
}
|
2001-09-09 22:24:39 -04:00
|
|
|
}
|
|
|
|
|
2007-08-16 18:52:24 -04:00
|
|
|
const char *httpp_getvar(http_parser_t *parser, const char *name)
|
2001-09-09 22:24:39 -04:00
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
http_var_t var;
|
|
|
|
http_var_t *found;
|
2003-06-09 18:30:09 -04:00
|
|
|
void *fp;
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2005-04-07 23:48:08 -04:00
|
|
|
if (parser == NULL || name == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2003-06-09 18:30:09 -04:00
|
|
|
fp = &found;
|
2018-07-26 07:57:44 -04:00
|
|
|
memset(&var, 0, sizeof(var));
|
2005-06-14 22:32:26 -04:00
|
|
|
var.name = (char*)name;
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2018-07-26 08:55:10 -04:00
|
|
|
if (avl_get_by_key(parser->vars, &var, fp) == 0) {
|
|
|
|
if (!found->values)
|
|
|
|
return NULL;
|
|
|
|
return found->value[0];
|
|
|
|
} else {
|
2003-03-14 21:10:19 -05:00
|
|
|
return NULL;
|
2018-07-26 08:55:10 -04:00
|
|
|
}
|
2001-09-09 22:24:39 -04:00
|
|
|
}
|
|
|
|
|
2018-07-26 08:55:10 -04:00
|
|
|
static void _httpp_set_param_nocopy(avl_tree *tree, char *name, char *value, int replace)
|
2002-12-31 01:28:39 -05:00
|
|
|
{
|
2018-07-26 08:55:10 -04:00
|
|
|
http_var_t *var, *found;
|
|
|
|
char **n;
|
2002-12-31 01:28:39 -05:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
if (name == NULL || value == NULL)
|
|
|
|
return;
|
2002-12-31 01:28:39 -05:00
|
|
|
|
2018-07-26 08:55:10 -04:00
|
|
|
found = _httpp_get_param_var(tree, name);
|
2002-12-31 01:28:39 -05:00
|
|
|
|
2018-07-26 08:55:10 -04:00
|
|
|
if (replace || !found) {
|
|
|
|
var = (http_var_t *)calloc(1, sizeof(http_var_t));
|
|
|
|
if (var == NULL) {
|
|
|
|
free(name);
|
|
|
|
free(value);
|
|
|
|
return;
|
|
|
|
}
|
2002-12-31 01:28:39 -05:00
|
|
|
|
2018-07-26 08:55:10 -04:00
|
|
|
var->name = name;
|
2003-03-14 21:10:19 -05:00
|
|
|
} else {
|
2018-07-26 08:55:10 -04:00
|
|
|
free(name);
|
|
|
|
var = found;
|
|
|
|
}
|
|
|
|
|
|
|
|
n = realloc(var->value, sizeof(*n)*(var->values + 1));
|
|
|
|
if (!n) {
|
|
|
|
if (replace || !found) {
|
|
|
|
free(name);
|
|
|
|
free(var);
|
|
|
|
}
|
|
|
|
free(value);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
var->value = n;
|
|
|
|
var->value[var->values++] = value;
|
|
|
|
|
|
|
|
if (replace && found) {
|
|
|
|
avl_delete(tree, (void *)found, _free_vars);
|
2018-06-18 10:39:03 -04:00
|
|
|
avl_insert(tree, (void *)var);
|
2018-07-26 09:08:25 -04:00
|
|
|
} else if (!found) {
|
|
|
|
avl_insert(tree, (void *)var);
|
2003-03-14 21:10:19 -05:00
|
|
|
}
|
2002-12-31 01:28:39 -05:00
|
|
|
}
|
|
|
|
|
2018-06-18 10:39:03 -04:00
|
|
|
static void _httpp_set_param(avl_tree *tree, const char *name, const char *value)
|
|
|
|
{
|
|
|
|
if (name == NULL || value == NULL)
|
|
|
|
return;
|
|
|
|
|
2018-07-26 08:55:10 -04:00
|
|
|
_httpp_set_param_nocopy(tree, strdup(name), url_unescape(value, strlen(value)), 1);
|
2018-06-18 10:39:03 -04:00
|
|
|
}
|
|
|
|
|
2018-07-26 08:55:10 -04:00
|
|
|
static http_var_t *_httpp_get_param_var(avl_tree *tree, const char *name)
|
2002-12-31 01:28:39 -05:00
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
http_var_t var;
|
|
|
|
http_var_t *found;
|
2003-06-09 18:30:09 -04:00
|
|
|
void *fp;
|
2002-12-31 01:28:39 -05:00
|
|
|
|
2003-06-09 18:30:09 -04:00
|
|
|
fp = &found;
|
2018-07-26 07:57:44 -04:00
|
|
|
memset(&var, 0, sizeof(var));
|
2007-08-16 18:52:24 -04:00
|
|
|
var.name = (char *)name;
|
2002-12-31 01:28:39 -05:00
|
|
|
|
2018-06-18 10:39:03 -04:00
|
|
|
if (avl_get_by_key(tree, (void *)&var, fp) == 0)
|
2018-07-26 08:55:10 -04:00
|
|
|
return found;
|
2003-03-14 21:10:19 -05:00
|
|
|
else
|
|
|
|
return NULL;
|
2002-12-31 01:28:39 -05:00
|
|
|
}
|
2018-07-26 08:55:10 -04:00
|
|
|
static const char *_httpp_get_param(avl_tree *tree, const char *name)
|
|
|
|
{
|
|
|
|
http_var_t *res = _httpp_get_param_var(tree, name);
|
|
|
|
|
|
|
|
if (!res)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!res->values)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return res->value[0];
|
|
|
|
}
|
2002-12-31 01:28:39 -05:00
|
|
|
|
2018-06-18 10:39:03 -04:00
|
|
|
void httpp_set_query_param(http_parser_t *parser, const char *name, const char *value)
|
|
|
|
{
|
|
|
|
return _httpp_set_param(parser->queryvars, name, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *httpp_get_query_param(http_parser_t *parser, const char *name)
|
|
|
|
{
|
|
|
|
return _httpp_get_param(parser->queryvars, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
void httpp_set_post_param(http_parser_t *parser, const char *name, const char *value)
|
|
|
|
{
|
|
|
|
return _httpp_set_param(parser->postvars, name, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *httpp_get_post_param(http_parser_t *parser, const char *name)
|
|
|
|
{
|
|
|
|
return _httpp_get_param(parser->postvars, name);
|
|
|
|
}
|
|
|
|
|
2018-07-26 08:59:23 -04:00
|
|
|
const http_var_t *httpp_get_param_var(http_parser_t *parser, const char *name)
|
|
|
|
{
|
|
|
|
http_var_t *ret = _httpp_get_param_var(parser->postvars, name);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return _httpp_get_param_var(parser->queryvars, name);
|
|
|
|
}
|
|
|
|
|
2018-08-09 07:17:38 -04:00
|
|
|
const http_var_t *httpp_get_any_var(http_parser_t *parser, httpp_ns_t ns, const char *name)
|
|
|
|
{
|
|
|
|
avl_tree *tree = NULL;
|
|
|
|
|
|
|
|
if (!parser || !name)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
switch (ns) {
|
|
|
|
case HTTPP_NS_VAR:
|
|
|
|
if (name[0] != '_' || name[1] != '_')
|
|
|
|
return NULL;
|
|
|
|
tree = parser->vars;
|
|
|
|
break;
|
|
|
|
case HTTPP_NS_HEADER:
|
|
|
|
if (name[0] == '_' && name[1] == '_')
|
|
|
|
return NULL;
|
|
|
|
tree = parser->vars;
|
|
|
|
break;
|
|
|
|
case HTTPP_NS_QUERY_STRING:
|
|
|
|
tree = parser->queryvars;
|
|
|
|
break;
|
|
|
|
case HTTPP_NS_POST_BODY:
|
|
|
|
tree = parser->postvars;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!tree)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return _httpp_get_param_var(tree, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
char ** httpp_get_any_key(http_parser_t *parser, httpp_ns_t ns)
|
|
|
|
{
|
|
|
|
avl_tree *tree = NULL;
|
|
|
|
avl_node *avlnode;
|
|
|
|
char **ret;
|
|
|
|
size_t len;
|
|
|
|
size_t pos = 0;
|
|
|
|
|
|
|
|
if (!parser)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
switch (ns) {
|
|
|
|
case HTTPP_NS_VAR:
|
|
|
|
case HTTPP_NS_HEADER:
|
|
|
|
tree = parser->vars;
|
|
|
|
break;
|
|
|
|
case HTTPP_NS_QUERY_STRING:
|
|
|
|
tree = parser->queryvars;
|
|
|
|
break;
|
|
|
|
case HTTPP_NS_POST_BODY:
|
|
|
|
tree = parser->postvars;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!tree)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
ret = calloc(8, sizeof(*ret));
|
|
|
|
if (!ret)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
len = 8;
|
|
|
|
|
|
|
|
for (avlnode = avl_get_first(tree); avlnode; avlnode = avl_get_next(avlnode)) {
|
|
|
|
http_var_t *var = avlnode->key;
|
|
|
|
|
|
|
|
if (ns == HTTPP_NS_VAR) {
|
|
|
|
if (var->name[0] != '_' || var->name[1] != '_') {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else if (ns == HTTPP_NS_HEADER) {
|
|
|
|
if (var->name[0] == '_' && var->name[1] == '_') {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pos == (len-1)) {
|
|
|
|
char **n = realloc(ret, sizeof(*ret)*(len + 8));
|
|
|
|
if (!n) {
|
|
|
|
httpp_free_any_key(ret);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
memset(n + len, 0, sizeof(*n)*8);
|
|
|
|
ret = n;
|
|
|
|
len += 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret[pos] = strdup(var->name);
|
|
|
|
if (!ret[pos]) {
|
|
|
|
httpp_free_any_key(ret);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
pos++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void httpp_free_any_key(char **keys)
|
|
|
|
{
|
|
|
|
char **p;
|
|
|
|
|
|
|
|
if (!keys)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (p = keys; *p; p++) {
|
|
|
|
free(*p);
|
|
|
|
}
|
|
|
|
free(keys);
|
|
|
|
}
|
|
|
|
|
2018-06-18 17:36:19 -04:00
|
|
|
const char *httpp_get_param(http_parser_t *parser, const char *name)
|
|
|
|
{
|
|
|
|
const char *ret = _httpp_get_param(parser->postvars, name);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return _httpp_get_param(parser->queryvars, name);
|
|
|
|
}
|
|
|
|
|
2018-08-09 05:25:26 -04:00
|
|
|
static void httpp_clear(http_parser_t *parser)
|
2001-09-09 22:24:39 -04:00
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
parser->req_type = httpp_req_none;
|
|
|
|
if (parser->uri)
|
|
|
|
free(parser->uri);
|
|
|
|
parser->uri = NULL;
|
|
|
|
avl_tree_free(parser->vars, _free_vars);
|
|
|
|
avl_tree_free(parser->queryvars, _free_vars);
|
2018-06-18 10:39:03 -04:00
|
|
|
avl_tree_free(parser->postvars, _free_vars);
|
2003-03-14 21:10:19 -05:00
|
|
|
parser->vars = NULL;
|
2001-09-09 22:24:39 -04:00
|
|
|
}
|
|
|
|
|
2018-08-09 05:25:26 -04:00
|
|
|
int httpp_addref(http_parser_t *parser)
|
|
|
|
{
|
|
|
|
if (!parser)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
parser->refc++;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int httpp_release(http_parser_t *parser)
|
2002-05-03 11:04:56 -04:00
|
|
|
{
|
2018-08-09 05:25:26 -04:00
|
|
|
if (!parser)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
parser->refc--;
|
|
|
|
if (parser->refc)
|
|
|
|
return 0;
|
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
httpp_clear(parser);
|
|
|
|
free(parser);
|
2018-08-09 05:25:26 -04:00
|
|
|
|
|
|
|
return 0;
|
2002-05-03 11:04:56 -04:00
|
|
|
}
|
|
|
|
|
2003-06-18 07:13:11 -04:00
|
|
|
static char *_lowercase(char *str)
|
2001-09-09 22:24:39 -04:00
|
|
|
{
|
2003-06-18 07:13:11 -04:00
|
|
|
char *p = str;
|
2003-06-18 11:52:25 -04:00
|
|
|
for (; *p != '\0'; p++)
|
2003-06-18 07:13:11 -04:00
|
|
|
*p = tolower(*p);
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
return str;
|
2001-09-09 22:24:39 -04:00
|
|
|
}
|
|
|
|
|
2003-07-06 21:49:27 -04:00
|
|
|
static int _compare_vars(void *compare_arg, void *a, void *b)
|
2001-09-09 22:24:39 -04:00
|
|
|
{
|
2003-03-14 21:10:19 -05:00
|
|
|
http_var_t *vara, *varb;
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
vara = (http_var_t *)a;
|
|
|
|
varb = (http_var_t *)b;
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
return strcmp(vara->name, varb->name);
|
2001-09-09 22:24:39 -04:00
|
|
|
}
|
|
|
|
|
2003-07-06 21:49:27 -04:00
|
|
|
static int _free_vars(void *key)
|
2001-09-09 22:24:39 -04:00
|
|
|
{
|
2018-07-26 08:55:10 -04:00
|
|
|
http_var_t *var = (http_var_t *)key;
|
|
|
|
size_t i;
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2018-07-26 08:55:10 -04:00
|
|
|
free(var->name);
|
2018-07-26 07:57:44 -04:00
|
|
|
|
2018-07-26 08:55:10 -04:00
|
|
|
for (i = 0; i < var->values; i++) {
|
|
|
|
free(var->value[i]);
|
2018-07-26 07:57:44 -04:00
|
|
|
}
|
2018-07-26 08:55:10 -04:00
|
|
|
free(var->value);
|
|
|
|
free(var);
|
2001-09-09 22:24:39 -04:00
|
|
|
|
2003-03-14 21:10:19 -05:00
|
|
|
return 1;
|
2001-09-09 22:24:39 -04:00
|
|
|
}
|
|
|
|
|
2014-11-21 23:44:47 -05:00
|
|
|
httpp_request_type_e httpp_str_to_method(const char * method) {
|
|
|
|
if (strcasecmp("GET", method) == 0) {
|
|
|
|
return httpp_req_get;
|
|
|
|
} else if (strcasecmp("POST", method) == 0) {
|
|
|
|
return httpp_req_post;
|
|
|
|
} else if (strcasecmp("PUT", method) == 0) {
|
|
|
|
return httpp_req_put;
|
|
|
|
} else if (strcasecmp("HEAD", method) == 0) {
|
|
|
|
return httpp_req_head;
|
2015-02-10 03:33:30 -05:00
|
|
|
} else if (strcasecmp("OPTIONS", method) == 0) {
|
|
|
|
return httpp_req_options;
|
|
|
|
} else if (strcasecmp("DELETE", method) == 0) {
|
|
|
|
return httpp_req_delete;
|
|
|
|
} else if (strcasecmp("TRACE", method) == 0) {
|
|
|
|
return httpp_req_trace;
|
|
|
|
} else if (strcasecmp("CONNECT", method) == 0) {
|
|
|
|
return httpp_req_connect;
|
2014-11-21 23:44:47 -05:00
|
|
|
} else if (strcasecmp("SOURCE", method) == 0) {
|
|
|
|
return httpp_req_source;
|
|
|
|
} else if (strcasecmp("PLAY", method) == 0) {
|
|
|
|
return httpp_req_play;
|
|
|
|
} else if (strcasecmp("STATS", method) == 0) {
|
|
|
|
return httpp_req_stats;
|
|
|
|
} else {
|
|
|
|
return httpp_req_unknown;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|