//
|
// Copyright 2019 Staysail Systems, Inc. <info@staysail.tech>
|
// Copyright 2018 Capitar IT Group BV <info@capitar.com>
|
//
|
// This software is supplied under the terms of the MIT License, a
|
// copy of which should be located in the distribution where this
|
// file was obtained (LICENSE.txt). A copy of the license may also be
|
// found online at https://opensource.org/licenses/MIT.
|
//
|
|
#include <stdarg.h>
|
#include <stdbool.h>
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
|
#include "core/nng_impl.h"
|
#include "http_api.h"
|
|
// Note that as we parse headers, the rule is that if a header is already
|
// present, then we can append it to the existing header, separated by
|
// a comma. From experience, for example, Firefox uses a Connection:
|
// header with two values, "keepalive", and "upgrade".
|
typedef struct http_header {
|
char * name;
|
char * value;
|
nni_list_node node;
|
} http_header;
|
|
typedef struct nni_http_entity {
|
char * data;
|
size_t size; // allocated/expected size
|
size_t len; // current length
|
bool own; // if true, data is "ours", and should be freed
|
} nni_http_entity;
|
|
struct nng_http_req {
|
nni_list hdrs;
|
nni_http_entity data;
|
char * meth;
|
char * uri;
|
char * vers;
|
char * buf;
|
size_t bufsz;
|
bool parsed;
|
};
|
|
struct nng_http_res {
|
nni_list hdrs;
|
nni_http_entity data;
|
uint16_t code;
|
char * rsn;
|
char * vers;
|
char * buf;
|
size_t bufsz;
|
bool parsed;
|
bool iserr;
|
};
|
|
static int
|
http_set_string(char **strp, const char *val)
|
{
|
char *news;
|
if (val == NULL) {
|
news = NULL;
|
} else if ((news = nni_strdup(val)) == NULL) {
|
return (NNG_ENOMEM);
|
}
|
nni_strfree(*strp);
|
*strp = news;
|
return (0);
|
}
|
|
static void
|
http_headers_reset(nni_list *hdrs)
|
{
|
http_header *h;
|
while ((h = nni_list_first(hdrs)) != NULL) {
|
nni_list_remove(hdrs, h);
|
nni_strfree(h->name);
|
nni_strfree(h->value);
|
NNI_FREE_STRUCT(h);
|
}
|
}
|
|
static void
|
http_entity_reset(nni_http_entity *entity)
|
{
|
if (entity->own && entity->size) {
|
nni_free(entity->data, entity->size);
|
}
|
entity->data = NULL;
|
entity->size = 0;
|
entity->own = false;
|
}
|
|
void
|
nni_http_req_reset(nni_http_req *req)
|
{
|
http_headers_reset(&req->hdrs);
|
http_entity_reset(&req->data);
|
nni_strfree(req->vers);
|
nni_strfree(req->meth);
|
nni_strfree(req->uri);
|
req->vers = req->meth = req->uri = NULL;
|
nni_free(req->buf, req->bufsz);
|
req->bufsz = 0;
|
req->buf = NULL;
|
req->parsed = false;
|
}
|
|
void
|
nni_http_res_reset(nni_http_res *res)
|
{
|
http_headers_reset(&res->hdrs);
|
http_entity_reset(&res->data);
|
nni_strfree(res->rsn);
|
nni_strfree(res->vers);
|
res->vers = NULL;
|
res->rsn = NULL;
|
res->code = NNG_HTTP_STATUS_OK;
|
res->parsed = false;
|
nni_free(res->buf, res->bufsz);
|
res->buf = NULL;
|
res->bufsz = 0;
|
}
|
|
void
|
nni_http_req_free(nni_http_req *req)
|
{
|
if (req != NULL) {
|
nni_http_req_reset(req);
|
NNI_FREE_STRUCT(req);
|
}
|
}
|
|
void
|
nni_http_res_free(nni_http_res *res)
|
{
|
if (res != NULL) {
|
nni_http_res_reset(res);
|
NNI_FREE_STRUCT(res);
|
}
|
}
|
|
static int
|
http_del_header(nni_list *hdrs, const char *key)
|
{
|
http_header *h;
|
NNI_LIST_FOREACH (hdrs, h) {
|
if (nni_strcasecmp(key, h->name) == 0) {
|
nni_list_remove(hdrs, h);
|
nni_strfree(h->name);
|
nni_free(h->value, strlen(h->value) + 1);
|
NNI_FREE_STRUCT(h);
|
return (0);
|
}
|
}
|
return (NNG_ENOENT);
|
}
|
|
int
|
nni_http_req_del_header(nni_http_req *req, const char *key)
|
{
|
return (http_del_header(&req->hdrs, key));
|
}
|
|
int
|
nni_http_res_del_header(nni_http_res *res, const char *key)
|
{
|
return (http_del_header(&res->hdrs, key));
|
}
|
|
static int
|
http_set_header(nni_list *hdrs, const char *key, const char *val)
|
{
|
http_header *h;
|
NNI_LIST_FOREACH (hdrs, h) {
|
if (nni_strcasecmp(key, h->name) == 0) {
|
char *news;
|
if ((news = nni_strdup(val)) == NULL) {
|
return (NNG_ENOMEM);
|
}
|
nni_strfree(h->value);
|
h->value = news;
|
return (0);
|
}
|
}
|
|
if ((h = NNI_ALLOC_STRUCT(h)) == NULL) {
|
return (NNG_ENOMEM);
|
}
|
if ((h->name = nni_strdup(key)) == NULL) {
|
NNI_FREE_STRUCT(h);
|
return (NNG_ENOMEM);
|
}
|
if ((h->value = nni_strdup(val)) == NULL) {
|
nni_strfree(h->name);
|
NNI_FREE_STRUCT(h);
|
return (NNG_ENOMEM);
|
}
|
nni_list_append(hdrs, h);
|
return (0);
|
}
|
|
int
|
nni_http_req_set_header(nni_http_req *req, const char *key, const char *val)
|
{
|
return (http_set_header(&req->hdrs, key, val));
|
}
|
|
int
|
nni_http_res_set_header(nni_http_res *res, const char *key, const char *val)
|
{
|
return (http_set_header(&res->hdrs, key, val));
|
}
|
|
static int
|
http_add_header(nni_list *hdrs, const char *key, const char *val)
|
{
|
http_header *h;
|
NNI_LIST_FOREACH (hdrs, h) {
|
if (nni_strcasecmp(key, h->name) == 0) {
|
char *news;
|
int rv;
|
rv = nni_asprintf(&news, "%s, %s", h->value, val);
|
if (rv != 0) {
|
return (rv);
|
}
|
nni_strfree(h->value);
|
h->value = news;
|
return (0);
|
}
|
}
|
|
if ((h = NNI_ALLOC_STRUCT(h)) == NULL) {
|
return (NNG_ENOMEM);
|
}
|
if ((h->name = nni_strdup(key)) == NULL) {
|
NNI_FREE_STRUCT(h);
|
return (NNG_ENOMEM);
|
}
|
if ((h->value = nni_strdup(val)) == NULL) {
|
nni_strfree(h->name);
|
NNI_FREE_STRUCT(h);
|
return (NNG_ENOMEM);
|
}
|
nni_list_append(hdrs, h);
|
return (0);
|
}
|
|
int
|
nni_http_req_add_header(nni_http_req *req, const char *key, const char *val)
|
{
|
return (http_add_header(&req->hdrs, key, val));
|
}
|
|
int
|
nni_http_res_add_header(nni_http_res *res, const char *key, const char *val)
|
{
|
return (http_add_header(&res->hdrs, key, val));
|
}
|
|
static const char *
|
http_get_header(nni_list *hdrs, const char *key)
|
{
|
http_header *h;
|
NNI_LIST_FOREACH (hdrs, h) {
|
if (nni_strcasecmp(h->name, key) == 0) {
|
return (h->value);
|
}
|
}
|
return (NULL);
|
}
|
|
const char *
|
nni_http_req_get_header(nni_http_req *req, const char *key)
|
{
|
return (http_get_header(&req->hdrs, key));
|
}
|
|
const char *
|
nni_http_res_get_header(nni_http_res *res, const char *key)
|
{
|
return (http_get_header(&res->hdrs, key));
|
}
|
|
// http_entity_set_data sets the entity, but does not update the
|
// content-length header.
|
static void
|
http_entity_set_data(nni_http_entity *entity, const void *data, size_t size)
|
{
|
if (entity->own) {
|
nni_free(entity->data, entity->size);
|
}
|
entity->data = (void *) data;
|
entity->size = size;
|
entity->own = false;
|
}
|
|
static int
|
http_entity_alloc_data(nni_http_entity *entity, size_t size)
|
{
|
void *newdata;
|
if ((newdata = nni_zalloc(size)) == NULL) {
|
return (NNG_ENOMEM);
|
}
|
http_entity_set_data(entity, newdata, size);
|
entity->own = true;
|
return (0);
|
}
|
|
static int
|
http_entity_copy_data(nni_http_entity *entity, const void *data, size_t size)
|
{
|
int rv;
|
if ((rv = http_entity_alloc_data(entity, size)) == 0) {
|
memcpy(entity->data, data, size);
|
}
|
return (rv);
|
}
|
|
static int
|
http_set_content_length(nni_http_entity *entity, nni_list *hdrs)
|
{
|
char buf[16];
|
(void) snprintf(buf, sizeof(buf), "%u", (unsigned) entity->size);
|
return (http_set_header(hdrs, "Content-Length", buf));
|
}
|
|
static void
|
http_entity_get_data(nni_http_entity *entity, void **datap, size_t *sizep)
|
{
|
*datap = entity->data;
|
*sizep = entity->size;
|
}
|
|
void
|
nni_http_req_get_data(nni_http_req *req, void **datap, size_t *sizep)
|
{
|
http_entity_get_data(&req->data, datap, sizep);
|
}
|
|
void
|
nni_http_res_get_data(nni_http_res *res, void **datap, size_t *sizep)
|
{
|
http_entity_get_data(&res->data, datap, sizep);
|
}
|
|
int
|
nni_http_req_set_data(nni_http_req *req, const void *data, size_t size)
|
{
|
int rv;
|
|
http_entity_set_data(&req->data, data, size);
|
if ((rv = http_set_content_length(&req->data, &req->hdrs)) != 0) {
|
http_entity_set_data(&req->data, NULL, 0);
|
}
|
return (rv);
|
}
|
|
int
|
nni_http_res_set_data(nni_http_res *res, const void *data, size_t size)
|
{
|
int rv;
|
|
http_entity_set_data(&res->data, data, size);
|
if ((rv = http_set_content_length(&res->data, &res->hdrs)) != 0) {
|
http_entity_set_data(&res->data, NULL, 0);
|
}
|
res->iserr = false;
|
return (rv);
|
}
|
|
int
|
nni_http_req_copy_data(nni_http_req *req, const void *data, size_t size)
|
{
|
int rv;
|
|
if (((rv = http_entity_copy_data(&req->data, data, size)) != 0) ||
|
((rv = http_set_content_length(&req->data, &req->hdrs)) != 0)) {
|
http_entity_set_data(&req->data, NULL, 0);
|
return (rv);
|
}
|
return (0);
|
}
|
|
int
|
nni_http_req_alloc_data(nni_http_req *req, size_t size)
|
{
|
int rv;
|
|
if ((rv = http_entity_alloc_data(&req->data, size)) != 0) {
|
return (rv);
|
}
|
return (0);
|
}
|
|
int
|
nni_http_res_copy_data(nni_http_res *res, const void *data, size_t size)
|
{
|
int rv;
|
|
if (((rv = http_entity_copy_data(&res->data, data, size)) != 0) ||
|
((rv = http_set_content_length(&res->data, &res->hdrs)) != 0)) {
|
http_entity_set_data(&res->data, NULL, 0);
|
return (rv);
|
}
|
res->iserr = false;
|
return (0);
|
}
|
|
// nni_http_res_alloc_data allocates the data region, but does not update any
|
// headers. The intended use is for client implementations that want to
|
// allocate a buffer to receive the entity into.
|
int
|
nni_http_res_alloc_data(nni_http_res *res, size_t size)
|
{
|
int rv;
|
|
if ((rv = http_entity_alloc_data(&res->data, size)) != 0) {
|
return (rv);
|
}
|
return (0);
|
}
|
|
bool
|
nni_http_res_is_error(nni_http_res *res)
|
{
|
return (res->iserr);
|
}
|
|
static int
|
http_parse_header(nni_list *hdrs, void *line)
|
{
|
char *key = line;
|
char *val;
|
char *end;
|
|
// Find separation between key and value
|
if ((val = strchr(key, ':')) == NULL) {
|
return (NNG_EPROTO);
|
}
|
|
// Trim leading and trailing whitespace from header
|
*val = '\0';
|
val++;
|
while (*val == ' ' || *val == '\t') {
|
val++;
|
}
|
end = val + strlen(val);
|
end--;
|
while ((end > val) && (*end == ' ' || *end == '\t')) {
|
*end = '\0';
|
end--;
|
}
|
|
return (http_add_header(hdrs, key, val));
|
}
|
|
// http_sprintf_headers makes headers for an HTTP request or an HTTP response
|
// object. Each header is dumped from the list. If the buf is NULL,
|
// or the sz is 0, then a dryrun is done, in order to allow the caller to
|
// determine how much space is needed. Returns the size of the space needed,
|
// not including the terminating NULL byte. Truncation occurs if the size
|
// returned is >= the requested size.
|
static size_t
|
http_sprintf_headers(char *buf, size_t sz, nni_list *list)
|
{
|
size_t rv = 0;
|
http_header *h;
|
|
if (buf == NULL) {
|
sz = 0;
|
}
|
|
NNI_LIST_FOREACH (list, h) {
|
size_t l;
|
l = snprintf(buf, sz, "%s: %s\r\n", h->name, h->value);
|
if (buf != NULL) {
|
buf += l;
|
}
|
sz = (sz > l) ? sz - l : 0;
|
rv += l;
|
}
|
return (rv);
|
}
|
|
static int
|
http_asprintf(char **bufp, size_t *szp, nni_list *hdrs, const char *fmt, ...)
|
{
|
va_list ap;
|
size_t len;
|
size_t n;
|
char * buf;
|
|
va_start(ap, fmt);
|
len = vsnprintf(NULL, 0, fmt, ap);
|
va_end(ap);
|
|
len += http_sprintf_headers(NULL, 0, hdrs);
|
len += 3; // \r\n\0
|
|
if (len <= *szp) {
|
buf = *bufp;
|
} else {
|
if ((buf = nni_alloc(len)) == NULL) {
|
return (NNG_ENOMEM);
|
}
|
nni_free(*bufp, *szp);
|
*bufp = buf;
|
*szp = len;
|
}
|
va_start(ap, fmt);
|
n = vsnprintf(buf, len, fmt, ap);
|
va_end(ap);
|
buf += n;
|
len -= n;
|
n = http_sprintf_headers(buf, len, hdrs);
|
buf += n;
|
len -= n;
|
snprintf(buf, len, "\r\n");
|
NNI_ASSERT(len == 3);
|
return (0);
|
}
|
|
static int
|
http_req_prepare(nni_http_req *req)
|
{
|
int rv;
|
if (req->uri == NULL) {
|
return (NNG_EINVAL);
|
}
|
rv = http_asprintf(&req->buf, &req->bufsz, &req->hdrs, "%s %s %s\r\n",
|
req->meth != NULL ? req->meth : "GET", req->uri,
|
req->vers != NULL ? req->vers : "HTTP/1.1");
|
return (rv);
|
}
|
|
static int
|
http_res_prepare(nni_http_res *res)
|
{
|
int rv;
|
rv = http_asprintf(&res->buf, &res->bufsz, &res->hdrs, "%s %d %s\r\n",
|
nni_http_res_get_version(res), nni_http_res_get_status(res),
|
nni_http_res_get_reason(res));
|
return (rv);
|
}
|
|
char *
|
nni_http_req_headers(nni_http_req *req)
|
{
|
char * s;
|
size_t len;
|
|
len = http_sprintf_headers(NULL, 0, &req->hdrs) + 1;
|
if ((s = nni_alloc(len)) != NULL) {
|
http_sprintf_headers(s, len, &req->hdrs);
|
}
|
return (s);
|
}
|
|
char *
|
nni_http_res_headers(nni_http_res *res)
|
{
|
char * s;
|
size_t len;
|
|
len = http_sprintf_headers(NULL, 0, &res->hdrs) + 1;
|
if ((s = nni_alloc(len)) != NULL) {
|
http_sprintf_headers(s, len, &res->hdrs);
|
}
|
return (s);
|
}
|
|
int
|
nni_http_req_get_buf(nni_http_req *req, void **data, size_t *szp)
|
{
|
int rv;
|
|
if ((req->buf == NULL) && (rv = http_req_prepare(req)) != 0) {
|
return (rv);
|
}
|
*data = req->buf;
|
*szp = req->bufsz - 1; // exclude terminating NUL
|
return (0);
|
}
|
|
int
|
nni_http_res_get_buf(nni_http_res *res, void **data, size_t *szp)
|
{
|
int rv;
|
|
if ((res->buf == NULL) && (rv = http_res_prepare(res)) != 0) {
|
return (rv);
|
}
|
*data = res->buf;
|
*szp = res->bufsz - 1; // exclude terminating NUL
|
return (0);
|
}
|
|
int
|
nni_http_req_alloc(nni_http_req **reqp, const nni_url *url)
|
{
|
nni_http_req *req;
|
if ((req = NNI_ALLOC_STRUCT(req)) == NULL) {
|
return (NNG_ENOMEM);
|
}
|
NNI_LIST_INIT(&req->hdrs, http_header, node);
|
req->buf = NULL;
|
req->bufsz = 0;
|
req->data.data = NULL;
|
req->data.size = 0;
|
req->data.own = false;
|
req->vers = NULL;
|
req->meth = NULL;
|
req->uri = NULL;
|
if (url != NULL) {
|
const char *host;
|
int rv;
|
if ((req->uri = nni_strdup(url->u_requri)) == NULL) {
|
NNI_FREE_STRUCT(req);
|
return (NNG_ENOMEM);
|
}
|
|
// Add a Host: header since we know that from the URL. Also,
|
// only include the :port portion if it isn't the default port.
|
if (strcmp(nni_url_default_port(url->u_scheme), url->u_port) ==
|
0) {
|
host = url->u_hostname;
|
} else {
|
host = url->u_host;
|
}
|
if ((rv = nni_http_req_add_header(req, "Host", host)) != 0) {
|
nni_http_req_free(req);
|
return (rv);
|
}
|
}
|
*reqp = req;
|
return (0);
|
}
|
|
int
|
nni_http_res_alloc(nni_http_res **resp)
|
{
|
nni_http_res *res;
|
if ((res = NNI_ALLOC_STRUCT(res)) == NULL) {
|
return (NNG_ENOMEM);
|
}
|
NNI_LIST_INIT(&res->hdrs, http_header, node);
|
res->buf = NULL;
|
res->bufsz = 0;
|
res->data.data = NULL;
|
res->data.size = 0;
|
res->data.own = false;
|
res->vers = NULL;
|
res->rsn = NULL;
|
res->code = NNG_HTTP_STATUS_OK;
|
*resp = res;
|
return (0);
|
}
|
|
const char *
|
nni_http_req_get_method(nni_http_req *req)
|
{
|
return (req->meth != NULL ? req->meth : "GET");
|
}
|
|
const char *
|
nni_http_req_get_uri(nni_http_req *req)
|
{
|
return (req->uri != NULL ? req->uri : "");
|
}
|
|
const char *
|
nni_http_req_get_version(nni_http_req *req)
|
{
|
return (req->vers != NULL ? req->vers : "HTTP/1.1");
|
}
|
|
const char *
|
nni_http_res_get_version(nni_http_res *res)
|
{
|
return (res->vers != NULL ? res->vers : "HTTP/1.1");
|
}
|
|
int
|
nni_http_req_set_version(nni_http_req *req, const char *vers)
|
{
|
if ((vers != NULL) && (strcmp(vers, "HTTP/1.1") == 0)) {
|
vers = NULL;
|
}
|
return (http_set_string(&req->vers, vers));
|
}
|
|
int
|
nni_http_res_set_version(nni_http_res *res, const char *vers)
|
{
|
if ((vers != NULL) && (strcmp(vers, "HTTP/1.1") == 0)) {
|
vers = NULL;
|
}
|
return (http_set_string(&res->vers, vers));
|
}
|
|
int
|
nni_http_req_set_uri(nni_http_req *req, const char *uri)
|
{
|
return (http_set_string(&req->uri, uri));
|
}
|
|
int
|
nni_http_req_set_method(nni_http_req *req, const char *meth)
|
{
|
if ((meth != NULL) && (strcmp(meth, "GET") == 0)) {
|
meth = NULL;
|
}
|
return (http_set_string(&req->meth, meth));
|
}
|
|
int
|
nni_http_res_set_status(nni_http_res *res, uint16_t status)
|
{
|
res->code = status;
|
return (0);
|
}
|
|
uint16_t
|
nni_http_res_get_status(nni_http_res *res)
|
{
|
return (res->code);
|
}
|
|
static int
|
http_scan_line(void *vbuf, size_t n, size_t *lenp)
|
{
|
size_t len;
|
char lc;
|
char * buf = vbuf;
|
|
lc = 0;
|
for (len = 0; len < n; len++) {
|
char c = buf[len];
|
if (c == '\n') {
|
// Technically we should be receiving CRLF, but
|
// debugging is easier with just LF, so we behave
|
// following Postel's Law.
|
if (lc != '\r') {
|
buf[len] = '\0';
|
} else {
|
buf[len - 1] = '\0';
|
}
|
*lenp = len + 1;
|
return (0);
|
}
|
// If we have a control character (other than CR), or a CR
|
// followed by anything other than LF, then its an error.
|
if (((c < ' ') && (c != '\r')) || (lc == '\r')) {
|
return (NNG_EPROTO);
|
}
|
lc = c;
|
}
|
// Scanned the entire content, but did not find a line.
|
return (NNG_EAGAIN);
|
}
|
|
static int
|
http_req_parse_line(nni_http_req *req, void *line)
|
{
|
int rv;
|
char *method;
|
char *uri;
|
char *version;
|
|
method = line;
|
if ((uri = strchr(method, ' ')) == NULL) {
|
return (NNG_EPROTO);
|
}
|
*uri = '\0';
|
uri++;
|
|
if ((version = strchr(uri, ' ')) == NULL) {
|
return (NNG_EPROTO);
|
}
|
*version = '\0';
|
version++;
|
|
if (((rv = nni_http_req_set_method(req, method)) != 0) ||
|
((rv = nni_http_req_set_uri(req, uri)) != 0) ||
|
((rv = nni_http_req_set_version(req, version)) != 0)) {
|
return (rv);
|
}
|
req->parsed = true;
|
return (0);
|
}
|
|
static int
|
http_res_parse_line(nni_http_res *res, uint8_t *line)
|
{
|
int rv;
|
char *reason;
|
char *codestr;
|
char *version;
|
int status;
|
|
version = (char *) line;
|
if ((codestr = strchr(version, ' ')) == NULL) {
|
return (NNG_EPROTO);
|
}
|
*codestr = '\0';
|
codestr++;
|
|
if ((reason = strchr(codestr, ' ')) == NULL) {
|
return (NNG_EPROTO);
|
}
|
*reason = '\0';
|
reason++;
|
|
status = atoi(codestr);
|
if ((status < 100) || (status > 999)) {
|
return (NNG_EPROTO);
|
}
|
|
if (((rv = nni_http_res_set_status(res, (uint16_t) status)) != 0) ||
|
((rv = nni_http_res_set_version(res, version)) != 0) ||
|
((rv = nni_http_res_set_reason(res, reason)) != 0)) {
|
return (rv);
|
}
|
res->parsed = true;
|
return (0);
|
}
|
|
// nni_http_req_parse parses a request (but not any attached entity data).
|
// The amount of data consumed is returned in lenp. Returns zero on
|
// success, NNG_EPROTO on parse failure, NNG_EAGAIN if more data is
|
// required, or NNG_ENOMEM on memory exhaustion. Note that lenp may
|
// be updated even in the face of errors (esp. NNG_EAGAIN, which is
|
// not an error so much as a request for more data.)
|
int
|
nni_http_req_parse(nni_http_req *req, void *buf, size_t n, size_t *lenp)
|
{
|
|
size_t len = 0;
|
size_t cnt;
|
int rv = 0;
|
|
for (;;) {
|
uint8_t *line;
|
if ((rv = http_scan_line(buf, n, &cnt)) != 0) {
|
break;
|
}
|
|
len += cnt;
|
line = buf;
|
buf = line + cnt;
|
n -= cnt;
|
|
if (*line == '\0') {
|
break;
|
}
|
|
if (req->parsed) {
|
rv = http_parse_header(&req->hdrs, line);
|
} else {
|
rv = http_req_parse_line(req, line);
|
}
|
|
if (rv != 0) {
|
break;
|
}
|
}
|
|
*lenp = len;
|
return (rv);
|
}
|
|
int
|
nni_http_res_parse(nni_http_res *res, void *buf, size_t n, size_t *lenp)
|
{
|
|
size_t len = 0;
|
size_t cnt;
|
int rv = 0;
|
for (;;) {
|
uint8_t *line;
|
if ((rv = http_scan_line(buf, n, &cnt)) != 0) {
|
break;
|
}
|
|
len += cnt;
|
line = buf;
|
buf = line + cnt;
|
n -= cnt;
|
|
if (*line == '\0') {
|
break;
|
}
|
|
if (res->parsed) {
|
rv = http_parse_header(&res->hdrs, line);
|
} else {
|
rv = http_res_parse_line(res, line);
|
}
|
|
if (rv != 0) {
|
break;
|
}
|
}
|
|
*lenp = len;
|
return (rv);
|
}
|
|
static struct {
|
uint16_t code;
|
const char *mesg;
|
} http_status[] = {
|
// 200, listed first because most likely
|
{ NNG_HTTP_STATUS_OK, "OK" },
|
|
// 100 series -- informational
|
{ NNG_HTTP_STATUS_CONTINUE, "Continue" },
|
{ NNG_HTTP_STATUS_SWITCHING, "Switching Protocols" },
|
{ NNG_HTTP_STATUS_PROCESSING, "Processing" },
|
|
// 200 series -- successful
|
{ NNG_HTTP_STATUS_CREATED, "Created" },
|
{ NNG_HTTP_STATUS_ACCEPTED, "Accepted" },
|
{ NNG_HTTP_STATUS_NOT_AUTHORITATIVE, "Not Authoritative" },
|
{ NNG_HTTP_STATUS_NO_CONTENT, "No Content" },
|
{ NNG_HTTP_STATUS_RESET_CONTENT, "Reset Content" },
|
{ NNG_HTTP_STATUS_PARTIAL_CONTENT, "Partial Content" },
|
|
// 300 series -- redirection
|
{ NNG_HTTP_STATUS_MULTIPLE_CHOICES, "Multiple Choices" },
|
{ NNG_HTTP_STATUS_STATUS_MOVED_PERMANENTLY, "Moved Permanently" },
|
{ NNG_HTTP_STATUS_FOUND, "Found" },
|
{ NNG_HTTP_STATUS_SEE_OTHER, "See Other" },
|
{ NNG_HTTP_STATUS_NOT_MODIFIED, "Not Modified" },
|
{ NNG_HTTP_STATUS_USE_PROXY, "Use Proxy" },
|
{ NNG_HTTP_STATUS_TEMPORARY_REDIRECT, "Temporary Redirect" },
|
|
// 400 series -- client errors
|
{ NNG_HTTP_STATUS_BAD_REQUEST, "Bad Request" },
|
{ NNG_HTTP_STATUS_UNAUTHORIZED, "Unauthorized" },
|
{ NNG_HTTP_STATUS_PAYMENT_REQUIRED, "Payment Required" },
|
{ NNG_HTTP_STATUS_FORBIDDEN, "Forbidden" },
|
{ NNG_HTTP_STATUS_NOT_FOUND, "Not Found" },
|
{ NNG_HTTP_STATUS_METHOD_NOT_ALLOWED, "Method Not Allowed" },
|
{ NNG_HTTP_STATUS_NOT_ACCEPTABLE, "Not Acceptable" },
|
{ NNG_HTTP_STATUS_PROXY_AUTH_REQUIRED,
|
"Proxy Authentication Required" },
|
{ NNG_HTTP_STATUS_REQUEST_TIMEOUT, "Request Timeout" },
|
{ NNG_HTTP_STATUS_CONFLICT, "Conflict" },
|
{ NNG_HTTP_STATUS_GONE, "Gone" },
|
{ NNG_HTTP_STATUS_LENGTH_REQUIRED, "Length Required" },
|
{ NNG_HTTP_STATUS_PRECONDITION_FAILED, "Precondition Failed" },
|
{ NNG_HTTP_STATUS_ENTITY_TOO_LONG, "Request Entity Too Long" },
|
{ NNG_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE, "Unsupported Media Type" },
|
{ NNG_HTTP_STATUS_RANGE_NOT_SATISFIABLE,
|
"Requested Range Not Satisfiable" },
|
{ NNG_HTTP_STATUS_EXPECTATION_FAILED, "Expectation Failed" },
|
{ NNG_HTTP_STATUS_TEAPOT, "I Am A Teapot" },
|
{ NNG_HTTP_STATUS_LOCKED, "Locked" },
|
{ NNG_HTTP_STATUS_FAILED_DEPENDENCY, "Failed Dependency" },
|
{ NNG_HTTP_STATUS_UPGRADE_REQUIRED, "Upgrade Required" },
|
{ NNG_HTTP_STATUS_PRECONDITION_REQUIRED, "Precondition Required" },
|
{ NNG_HTTP_STATUS_TOO_MANY_REQUESTS, "Too Many Requests" },
|
{ NNG_HTTP_STATUS_HEADERS_TOO_LARGE, "Headers Too Large" },
|
{ NNG_HTTP_STATUS_UNAVAIL_LEGAL_REASONS,
|
"Unavailable For Legal Reasons" },
|
|
// 500 series -- server errors
|
{ NNG_HTTP_STATUS_INTERNAL_SERVER_ERROR, "Internal Server Error" },
|
{ NNG_HTTP_STATUS_NOT_IMPLEMENTED, "Not Implemented" },
|
{ NNG_HTTP_STATUS_BAD_REQUEST, "Bad Gateway" },
|
{ NNG_HTTP_STATUS_SERVICE_UNAVAILABLE, "Service Unavailable" },
|
{ NNG_HTTP_STATUS_GATEWAY_TIMEOUT, "Gateway Timeout" },
|
{ NNG_HTTP_STATUS_HTTP_VERSION_NOT_SUPP,
|
"HTTP Version Not Supported" },
|
{ NNG_HTTP_STATUS_VARIANT_ALSO_NEGOTIATES, "Variant Also Negotiates" },
|
{ NNG_HTTP_STATUS_INSUFFICIENT_STORAGE, "Insufficient Storage" },
|
{ NNG_HTTP_STATUS_LOOP_DETECTED, "Loop Detected" },
|
{ NNG_HTTP_STATUS_NOT_EXTENDED, "Not Extended" },
|
{ NNG_HTTP_STATUS_NETWORK_AUTH_REQUIRED,
|
"Network Authentication Required" },
|
|
// Terminator
|
{ 0, NULL },
|
};
|
|
const char *
|
nni_http_reason(uint16_t code)
|
{
|
for (int i = 0; http_status[i].code != 0; i++) {
|
if (http_status[i].code == code) {
|
return (http_status[i].mesg);
|
}
|
}
|
return ("Unknown HTTP Status");
|
}
|
|
const char *
|
nni_http_res_get_reason(nni_http_res *res)
|
{
|
return (res->rsn ? res->rsn : nni_http_reason(res->code));
|
}
|
|
int
|
nni_http_res_set_reason(nni_http_res *res, const char *reason)
|
{
|
if ((reason != NULL) &&
|
(strcmp(reason, nni_http_reason(res->code)) == 0)) {
|
reason = NULL;
|
}
|
return (http_set_string(&res->rsn, reason));
|
}
|
|
int
|
nni_http_alloc_html_error(char **html, uint16_t code, const char *details)
|
{
|
const char *rsn = nni_http_reason(code);
|
|
return (nni_asprintf(html,
|
"<!DOCTYPE html>\n"
|
"<html><head><title>%d %s</title>\n"
|
"<style>"
|
"body { font-family: Arial, sans serif; text-align: center }\n"
|
"h1 { font-size: 36px; }"
|
"span { background-color: gray; color: white; padding: 7px; "
|
"border-radius: 5px }"
|
"h2 { font-size: 24px; }"
|
"p { font-size: 20px; }"
|
"</style></head>"
|
"<body><p> </p>"
|
"<h1><span>%d</span></h1>"
|
"<h2>%s</h2>"
|
"<p>%s</p>"
|
"</body></html>",
|
code, rsn, code, rsn, details != NULL ? details : ""));
|
}
|
|
int
|
nni_http_res_alloc_error(nni_http_res **resp, uint16_t err)
|
{
|
char * html = NULL;
|
nni_http_res *res = NULL;
|
int rv;
|
|
if (((rv = nni_http_res_alloc(&res)) != 0) ||
|
((rv = nni_http_alloc_html_error(&html, err, NULL)) != 0) ||
|
((rv = nni_http_res_set_header(
|
res, "Content-Type", "text/html; charset=UTF-8")) != 0) ||
|
((rv = nni_http_res_copy_data(res, html, strlen(html))) != 0)) {
|
nni_strfree(html);
|
nni_http_res_free(res);
|
} else {
|
nni_strfree(html);
|
res->code = err;
|
res->iserr = true;
|
*resp = res;
|
}
|
|
return (rv);
|
}
|
