#include <config.h>
#include <isc/buffer.h>
#include <isc/httpd.h>
#include <isc/mem.h>
#include <isc/socket.h>
#include <isc/string.h>
#include <isc/task.h>
#include <isc/util.h>
#include <string.h>
#define MSHUTTINGDOWN(cm) ((cm->flags & ISC_HTTPDMGR_FLAGSHUTTINGDOWN) != 0)
#define MSETSHUTTINGDOWN(cm) (cm->flags |= ISC_HTTPDMGR_FLAGSHUTTINGDOWN)
#ifdef DEBUG_HTTPD
#define ENTER(x) do { fprintf(stderr, "ENTER %s\n", (x)); } while (0)
#define EXIT(x) do { fprintf(stderr, "EXIT %s\n", (x)); } while (0)
#define NOTICE(x) do { fprintf(stderr, "NOTICE %s\n", (x)); } while (0)
#else
#define ENTER(x) do { } while(0)
#define EXIT(x) do { } while(0)
#define NOTICE(x) do { } while(0)
#endif
#define HTTP_RECVLEN 1024
#define HTTP_SENDGROW 1024
#define HTTP_SEND_MAXLEN 10240
struct isc_httpdurl {
char *url;
isc_httpdaction_t *action;
void *action_arg;
ISC_LINK(isc_httpdurl_t) link;
};
#define HTTPD_CLOSE 0x0001
#define HTTPD_FOUNDHOST 0x0002
struct isc_httpd {
isc_httpdmgr_t *mgr;
ISC_LINK(isc_httpd_t) link;
unsigned int state;
isc_socket_t *sock;
char recvbuf[HTTP_RECVLEN];
isc_uint32_t recvlen;
unsigned int method;
char *url;
char *querystring;
char *protocol;
int flags;
isc_bufferlist_t bufflist;
char *headerdata;
unsigned int headerlen;
isc_buffer_t headerbuffer;
const char *mimetype;
unsigned int retcode;
const char *retmsg;
isc_buffer_t bodybuffer;
isc_httpdfree_t *freecb;
void *freecb_arg;
};
struct isc_httpdmgr {
isc_mem_t *mctx;
isc_socket_t *sock;
isc_task_t *task;
isc_timermgr_t *timermgr;
isc_httpdclientok_t *client_ok;
isc_httpdondestroy_t *ondestroy;
void *cb_arg;
unsigned int flags;
ISC_LIST(isc_httpd_t) running;
isc_mutex_t lock;
ISC_LIST(isc_httpdurl_t) urls;
isc_httpdaction_t *render_404;
};
#define ISC_HTTPD_METHODUNKNOWN 0
#define ISC_HTTPD_METHODGET 1
#define ISC_HTTPD_METHODPOST 2
#define ISC_HTTPD_STATEIDLE 0
#define ISC_HTTPD_STATERECV 1
#define ISC_HTTPD_STATERECVDONE 2
#define ISC_HTTPD_STATESEND 3
#define ISC_HTTPD_STATESENDDONE 4
#define ISC_HTTPD_ISRECV(c) ((c)->state == ISC_HTTPD_STATERECV)
#define ISC_HTTPD_ISRECVDONE(c) ((c)->state == ISC_HTTPD_STATERECVDONE)
#define ISC_HTTPD_ISSEND(c) ((c)->state == ISC_HTTPD_STATESEND)
#define ISC_HTTPD_ISSENDDONE(c) ((c)->state == ISC_HTTPD_STATESENDDONE)
#define ISC_HTTPD_SETRECV(c) ((c)->state = ISC_HTTPD_STATERECV)
#define ISC_HTTPD_SETRECVDONE(c) ((c)->state = ISC_HTTPD_STATERECVDONE)
#define ISC_HTTPD_SETSEND(c) ((c)->state = ISC_HTTPD_STATESEND)
#define ISC_HTTPD_SETSENDDONE(c) ((c)->state = ISC_HTTPD_STATESENDDONE)
static void isc_httpd_accept(isc_task_t *, isc_event_t *);
static void isc_httpd_recvdone(isc_task_t *, isc_event_t *);
static void isc_httpd_senddone(isc_task_t *, isc_event_t *);
static void destroy_client(isc_httpd_t **);
static isc_result_t process_request(isc_httpd_t *, int);
static void httpdmgr_destroy(isc_httpdmgr_t *);
static isc_result_t grow_headerspace(isc_httpd_t *);
static void reset_client(isc_httpd_t *httpd);
static isc_result_t render_404(const char *, const char *,
void *,
unsigned int *, const char **,
const char **, isc_buffer_t *,
isc_httpdfree_t **, void **);
static void
destroy_client(isc_httpd_t **httpdp)
{
isc_httpd_t *httpd = *httpdp;
isc_httpdmgr_t *httpdmgr = httpd->mgr;
*httpdp = NULL;
LOCK(&httpdmgr->lock);
isc_socket_detach(&httpd->sock);
ISC_LIST_UNLINK(httpdmgr->running, httpd, link);
if (httpd->headerlen > 0)
isc_mem_put(httpdmgr->mctx, httpd->headerdata,
httpd->headerlen);
isc_mem_put(httpdmgr->mctx, httpd, sizeof(isc_httpd_t));
UNLOCK(&httpdmgr->lock);
httpdmgr_destroy(httpdmgr);
}
isc_result_t
isc_httpdmgr_create(isc_mem_t *mctx, isc_socket_t *sock, isc_task_t *task,
isc_httpdclientok_t *client_ok,
isc_httpdondestroy_t *ondestroy, void *cb_arg,
isc_timermgr_t *tmgr, isc_httpdmgr_t **httpdp)
{
isc_result_t result;
isc_httpdmgr_t *httpd;
REQUIRE(mctx != NULL);
REQUIRE(sock != NULL);
REQUIRE(task != NULL);
REQUIRE(tmgr != NULL);
REQUIRE(httpdp != NULL && *httpdp == NULL);
httpd = isc_mem_get(mctx, sizeof(isc_httpdmgr_t));
if (httpd == NULL)
return (ISC_R_NOMEMORY);
result = isc_mutex_init(&httpd->lock);
if (result != ISC_R_SUCCESS) {
isc_mem_put(mctx, httpd, sizeof(isc_httpdmgr_t));
return (result);
}
httpd->mctx = NULL;
isc_mem_attach(mctx, &httpd->mctx);
httpd->sock = NULL;
isc_socket_attach(sock, &httpd->sock);
httpd->task = NULL;
isc_task_attach(task, &httpd->task);
httpd->timermgr = tmgr;
httpd->client_ok = client_ok;
httpd->ondestroy = ondestroy;
httpd->cb_arg = cb_arg;
ISC_LIST_INIT(httpd->running);
ISC_LIST_INIT(httpd->urls);
result = isc_socket_listen(sock, SOMAXCONN);
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR(__FILE__, __LINE__,
"isc_socket_listen() failed: %s",
isc_result_totext(result));
goto cleanup;
}
(void)isc_socket_filter(sock, "httpready");
result = isc_socket_accept(sock, task, isc_httpd_accept, httpd);
if (result != ISC_R_SUCCESS)
goto cleanup;
httpd->render_404 = render_404;
*httpdp = httpd;
return (ISC_R_SUCCESS);
cleanup:
isc_task_detach(&httpd->task);
isc_socket_detach(&httpd->sock);
isc_mem_detach(&httpd->mctx);
isc_mutex_destroy(&httpd->lock);
isc_mem_put(mctx, httpd, sizeof(isc_httpdmgr_t));
return (result);
}
static void
httpdmgr_destroy(isc_httpdmgr_t *httpdmgr)
{
isc_mem_t *mctx;
isc_httpdurl_t *url;
ENTER("httpdmgr_destroy");
LOCK(&httpdmgr->lock);
if (!MSHUTTINGDOWN(httpdmgr)) {
NOTICE("httpdmgr_destroy not shutting down yet");
UNLOCK(&httpdmgr->lock);
return;
}
if (!ISC_LIST_EMPTY(httpdmgr->running)) {
NOTICE("httpdmgr_destroy clients still active");
UNLOCK(&httpdmgr->lock);
return;
}
NOTICE("httpdmgr_destroy detaching socket, task, and timermgr");
isc_socket_detach(&httpdmgr->sock);
isc_task_detach(&httpdmgr->task);
httpdmgr->timermgr = NULL;
url = ISC_LIST_HEAD(httpdmgr->urls);
while (url != NULL) {
isc_mem_free(httpdmgr->mctx, url->url);
ISC_LIST_UNLINK(httpdmgr->urls, url, link);
isc_mem_put(httpdmgr->mctx, url, sizeof(isc_httpdurl_t));
url = ISC_LIST_HEAD(httpdmgr->urls);
}
UNLOCK(&httpdmgr->lock);
isc_mutex_destroy(&httpdmgr->lock);
if (httpdmgr->ondestroy != NULL)
(httpdmgr->ondestroy)(httpdmgr->cb_arg);
mctx = httpdmgr->mctx;
isc_mem_putanddetach(&mctx, httpdmgr, sizeof(isc_httpdmgr_t));
EXIT("httpdmgr_destroy");
}
#define LENGTHOK(s) (httpd->recvbuf - (s) < (int)httpd->recvlen)
#define BUFLENOK(s) (httpd->recvbuf - (s) < HTTP_RECVLEN)
static isc_result_t
process_request(isc_httpd_t *httpd, int length)
{
char *s;
char *p;
int delim;
ENTER("request");
httpd->recvlen += length;
httpd->recvbuf[httpd->recvlen] = 0;
s = strstr(httpd->recvbuf, "\r\n\r\n");
delim = 1;
if (s == NULL) {
s = strstr(httpd->recvbuf, "\n\n");
delim = 2;
}
if (s == NULL)
return (ISC_R_NOTFOUND);
if (strncmp(httpd->recvbuf, "GET ", 4) == 0) {
httpd->method = ISC_HTTPD_METHODGET;
p = httpd->recvbuf + 4;
} else if (strncmp(httpd->recvbuf, "POST ", 5) == 0) {
httpd->method = ISC_HTTPD_METHODPOST;
p = httpd->recvbuf + 5;
} else {
return (ISC_R_RANGE);
}
s = p;
while (LENGTHOK(s) && BUFLENOK(s) &&
(*s != '\n' && *s != '\r' && *s != '\0' && *s != ' '))
s++;
if (!LENGTHOK(s))
return (ISC_R_NOTFOUND);
if (!BUFLENOK(s))
return (ISC_R_NOMEMORY);
*s = 0;
if ((strncmp(p, "http:/", 6) == 0)
|| (strncmp(p, "https:/", 7) == 0)) {
while (*p != '/' && *p != 0)
p++;
if (*p == 0)
return (ISC_R_RANGE);
p++;
while (*p != '/' && *p != 0)
p++;
if (*p == 0)
return (ISC_R_RANGE);
p++;
while (*p != '/' && *p != 0)
p++;
if (*p == 0) {
p--;
*p = '/';
}
}
httpd->url = p;
p = s + delim;
s = p;
httpd->querystring = strchr(httpd->url, '?');
if (httpd->querystring != NULL) {
*(httpd->querystring) = 0;
httpd->querystring++;
}
while (LENGTHOK(s) && BUFLENOK(s) &&
(*s != '\n' && *s != '\r' && *s != '\0'))
s++;
if (!LENGTHOK(s))
return (ISC_R_NOTFOUND);
if (!BUFLENOK(s))
return (ISC_R_NOMEMORY);
*s = 0;
if ((strncmp(p, "HTTP/1.0", 8) != 0)
&& (strncmp(p, "HTTP/1.1", 8) != 0))
return (ISC_R_RANGE);
httpd->protocol = p;
p = s + 1;
s = p;
if (strstr(s, "Connection: close") != NULL)
httpd->flags |= HTTPD_CLOSE;
if (strstr(s, "Host: ") != NULL)
httpd->flags |= HTTPD_FOUNDHOST;
if (strcmp(httpd->protocol, "HTTP/1.1") == 0
&& ((httpd->flags & HTTPD_FOUNDHOST) == 0))
return (ISC_R_RANGE);
EXIT("request");
return (ISC_R_SUCCESS);
}
static void
isc_httpd_accept(isc_task_t *task, isc_event_t *ev)
{
isc_result_t result;
isc_httpdmgr_t *httpdmgr = ev->ev_arg;
isc_httpd_t *httpd;
isc_region_t r;
isc_socket_newconnev_t *nev = (isc_socket_newconnev_t *)ev;
isc_sockaddr_t peeraddr;
ENTER("accept");
LOCK(&httpdmgr->lock);
if (MSHUTTINGDOWN(httpdmgr)) {
NOTICE("accept shutting down, goto out");
goto out;
}
if (nev->result == ISC_R_CANCELED) {
NOTICE("accept canceled, goto out");
goto out;
}
if (nev->result != ISC_R_SUCCESS) {
NOTICE("accept returned failure, goto requeue");
goto requeue;
}
(void)isc_socket_getpeername(nev->newsocket, &peeraddr);
if (httpdmgr->client_ok != NULL &&
!(httpdmgr->client_ok)(&peeraddr, httpdmgr->cb_arg)) {
isc_socket_detach(&nev->newsocket);
goto requeue;
}
httpd = isc_mem_get(httpdmgr->mctx, sizeof(isc_httpd_t));
if (httpd == NULL) {
NOTICE("accept failed to allocate memory, goto requeue");
isc_socket_detach(&nev->newsocket);
goto requeue;
}
httpd->mgr = httpdmgr;
ISC_LINK_INIT(httpd, link);
ISC_LIST_APPEND(httpdmgr->running, httpd, link);
ISC_HTTPD_SETRECV(httpd);
httpd->sock = nev->newsocket;
isc_socket_setname(httpd->sock, "httpd", NULL);
httpd->flags = 0;
httpd->headerdata = isc_mem_get(httpdmgr->mctx, HTTP_SENDGROW);
if (httpd->headerdata == NULL) {
isc_mem_put(httpdmgr->mctx, httpd, sizeof(isc_httpd_t));
isc_socket_detach(&nev->newsocket);
goto requeue;
}
httpd->headerlen = HTTP_SENDGROW;
isc_buffer_init(&httpd->headerbuffer, httpd->headerdata,
httpd->headerlen);
ISC_LIST_INIT(httpd->bufflist);
isc_buffer_initnull(&httpd->bodybuffer);
reset_client(httpd);
r.base = (unsigned char *)httpd->recvbuf;
r.length = HTTP_RECVLEN - 1;
result = isc_socket_recv(httpd->sock, &r, 1, task, isc_httpd_recvdone,
httpd);
NOTICE("accept queued recv on socket");
requeue:
result = isc_socket_accept(httpdmgr->sock, task, isc_httpd_accept,
httpdmgr);
if (result != ISC_R_SUCCESS) {
NOTICE("accept could not reaccept due to failure");
}
out:
UNLOCK(&httpdmgr->lock);
httpdmgr_destroy(httpdmgr);
isc_event_free(&ev);
EXIT("accept");
}
static isc_result_t
render_404(const char *url, const char *querystring,
void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
isc_httpdfree_t **freecb, void **freecb_args)
{
static char msg[] = "No such URL.";
UNUSED(url);
UNUSED(querystring);
UNUSED(arg);
*retcode = 404;
*retmsg = "No such URL";
*mimetype = "text/plain";
isc_buffer_reinit(b, msg, strlen(msg));
isc_buffer_add(b, strlen(msg));
*freecb = NULL;
*freecb_args = NULL;
return (ISC_R_SUCCESS);
}
static void
isc_httpd_recvdone(isc_task_t *task, isc_event_t *ev)
{
isc_region_t r;
isc_result_t result;
isc_httpd_t *httpd = ev->ev_arg;
isc_socketevent_t *sev = (isc_socketevent_t *)ev;
isc_httpdurl_t *url;
isc_time_t now;
char datebuf[32];
ENTER("recv");
INSIST(ISC_HTTPD_ISRECV(httpd));
if (sev->result != ISC_R_SUCCESS) {
NOTICE("recv destroying client");
destroy_client(&httpd);
goto out;
}
result = process_request(httpd, sev->n);
if (result == ISC_R_NOTFOUND) {
if (httpd->recvlen >= HTTP_RECVLEN - 1) {
destroy_client(&httpd);
goto out;
}
r.base = (unsigned char *)httpd->recvbuf + httpd->recvlen;
r.length = HTTP_RECVLEN - httpd->recvlen - 1;
result = isc_socket_recv(httpd->sock, &r, 1, task,
isc_httpd_recvdone, httpd);
goto out;
} else if (result != ISC_R_SUCCESS) {
destroy_client(&httpd);
goto out;
}
ISC_HTTPD_SETSEND(httpd);
isc_buffer_initnull(&httpd->bodybuffer);
isc_time_now(&now);
isc_time_formathttptimestamp(&now, datebuf, sizeof(datebuf));
url = ISC_LIST_HEAD(httpd->mgr->urls);
while (url != NULL) {
if (strcmp(httpd->url, url->url) == 0)
break;
url = ISC_LIST_NEXT(url, link);
}
if (url == NULL)
result = httpd->mgr->render_404(httpd->url, httpd->querystring,
NULL,
&httpd->retcode,
&httpd->retmsg,
&httpd->mimetype,
&httpd->bodybuffer,
&httpd->freecb,
&httpd->freecb_arg);
else
result = url->action(httpd->url, httpd->querystring,
url->action_arg,
&httpd->retcode, &httpd->retmsg,
&httpd->mimetype, &httpd->bodybuffer,
&httpd->freecb, &httpd->freecb_arg);
if (result != ISC_R_SUCCESS) {
destroy_client(&httpd);
goto out;
}
isc_httpd_response(httpd);
isc_httpd_addheader(httpd, "Content-Type", httpd->mimetype);
isc_httpd_addheader(httpd, "Date", datebuf);
isc_httpd_addheader(httpd, "Expires", datebuf);
isc_httpd_addheader(httpd, "Last-Modified", datebuf);
isc_httpd_addheader(httpd, "Pragma: no-cache", NULL);
isc_httpd_addheader(httpd, "Cache-Control: no-cache", NULL);
isc_httpd_addheader(httpd, "Server: libisc", NULL);
isc_httpd_addheaderuint(httpd, "Content-Length",
isc_buffer_usedlength(&httpd->bodybuffer));
isc_httpd_endheaders(httpd);
ISC_LIST_APPEND(httpd->bufflist, &httpd->headerbuffer, link);
if (isc_buffer_length(&httpd->bodybuffer) > 0)
ISC_LIST_APPEND(httpd->bufflist, &httpd->bodybuffer, link);
result = isc_socket_sendv(httpd->sock, &httpd->bufflist, task,
isc_httpd_senddone, httpd);
out:
isc_event_free(&ev);
EXIT("recv");
}
void
isc_httpdmgr_shutdown(isc_httpdmgr_t **httpdmgrp)
{
isc_httpdmgr_t *httpdmgr;
isc_httpd_t *httpd;
httpdmgr = *httpdmgrp;
*httpdmgrp = NULL;
ENTER("isc_httpdmgr_shutdown");
LOCK(&httpdmgr->lock);
MSETSHUTTINGDOWN(httpdmgr);
isc_socket_cancel(httpdmgr->sock, httpdmgr->task, ISC_SOCKCANCEL_ALL);
httpd = ISC_LIST_HEAD(httpdmgr->running);
while (httpd != NULL) {
isc_socket_cancel(httpd->sock, httpdmgr->task,
ISC_SOCKCANCEL_ALL);
httpd = ISC_LIST_NEXT(httpd, link);
}
UNLOCK(&httpdmgr->lock);
EXIT("isc_httpdmgr_shutdown");
}
static isc_result_t
grow_headerspace(isc_httpd_t *httpd)
{
char *newspace;
unsigned int newlen;
isc_region_t r;
newlen = httpd->headerlen + HTTP_SENDGROW;
if (newlen > HTTP_SEND_MAXLEN)
return (ISC_R_NOSPACE);
newspace = isc_mem_get(httpd->mgr->mctx, newlen);
if (newspace == NULL)
return (ISC_R_NOMEMORY);
isc_buffer_region(&httpd->headerbuffer, &r);
isc_buffer_reinit(&httpd->headerbuffer, newspace, newlen);
isc_mem_put(httpd->mgr->mctx, r.base, r.length);
return (ISC_R_SUCCESS);
}
isc_result_t
isc_httpd_response(isc_httpd_t *httpd)
{
isc_result_t result;
unsigned int needlen;
needlen = strlen(httpd->protocol) + 1;
needlen += 3 + 1;
needlen += strlen(httpd->retmsg) + 2;
if (isc_buffer_availablelength(&httpd->headerbuffer) < needlen) {
result = grow_headerspace(httpd);
if (result != ISC_R_SUCCESS)
return (result);
}
sprintf(isc_buffer_used(&httpd->headerbuffer), "%s %03d %s\r\n",
httpd->protocol, httpd->retcode, httpd->retmsg);
isc_buffer_add(&httpd->headerbuffer, needlen);
return (ISC_R_SUCCESS);
}
isc_result_t
isc_httpd_addheader(isc_httpd_t *httpd, const char *name,
const char *val)
{
isc_result_t result;
unsigned int needlen;
needlen = strlen(name);
if (val != NULL)
needlen += 2 + strlen(val);
needlen += 2;
if (isc_buffer_availablelength(&httpd->headerbuffer) < needlen) {
result = grow_headerspace(httpd);
if (result != ISC_R_SUCCESS)
return (result);
}
if (val != NULL)
sprintf(isc_buffer_used(&httpd->headerbuffer),
"%s: %s\r\n", name, val);
else
sprintf(isc_buffer_used(&httpd->headerbuffer),
"%s\r\n", name);
isc_buffer_add(&httpd->headerbuffer, needlen);
return (ISC_R_SUCCESS);
}
isc_result_t
isc_httpd_endheaders(isc_httpd_t *httpd)
{
isc_result_t result;
if (isc_buffer_availablelength(&httpd->headerbuffer) < 2) {
result = grow_headerspace(httpd);
if (result != ISC_R_SUCCESS)
return (result);
}
sprintf(isc_buffer_used(&httpd->headerbuffer), "\r\n");
isc_buffer_add(&httpd->headerbuffer, 2);
return (ISC_R_SUCCESS);
}
isc_result_t
isc_httpd_addheaderuint(isc_httpd_t *httpd, const char *name, int val) {
isc_result_t result;
unsigned int needlen;
char buf[sizeof "18446744073709551616"];
sprintf(buf, "%d", val);
needlen = strlen(name);
needlen += 2 + strlen(buf);
needlen += 2;
if (isc_buffer_availablelength(&httpd->headerbuffer) < needlen) {
result = grow_headerspace(httpd);
if (result != ISC_R_SUCCESS)
return (result);
}
sprintf(isc_buffer_used(&httpd->headerbuffer),
"%s: %s\r\n", name, buf);
isc_buffer_add(&httpd->headerbuffer, needlen);
return (ISC_R_SUCCESS);
}
static void
isc_httpd_senddone(isc_task_t *task, isc_event_t *ev)
{
isc_httpd_t *httpd = ev->ev_arg;
isc_region_t r;
isc_result_t result;
isc_socketevent_t *sev = (isc_socketevent_t *)ev;
ENTER("senddone");
INSIST(ISC_HTTPD_ISSEND(httpd));
NOTICE("senddone unlinked header");
ISC_LIST_UNLINK(sev->bufferlist, &httpd->headerbuffer, link);
if (httpd->freecb != NULL) {
isc_buffer_t *b = NULL;
if (isc_buffer_length(&httpd->bodybuffer) > 0)
b = &httpd->bodybuffer;
httpd->freecb(b, httpd->freecb_arg);
NOTICE("senddone free callback performed");
}
if (ISC_LINK_LINKED(&httpd->bodybuffer, link)) {
ISC_LIST_UNLINK(sev->bufferlist, &httpd->bodybuffer, link);
NOTICE("senddone body buffer unlinked");
}
if (sev->result != ISC_R_SUCCESS) {
destroy_client(&httpd);
goto out;
}
if ((httpd->flags & HTTPD_CLOSE) != 0) {
destroy_client(&httpd);
goto out;
}
ISC_HTTPD_SETRECV(httpd);
NOTICE("senddone restarting recv on socket");
reset_client(httpd);
r.base = (unsigned char *)httpd->recvbuf;
r.length = HTTP_RECVLEN - 1;
result = isc_socket_recv(httpd->sock, &r, 1, task, isc_httpd_recvdone,
httpd);
out:
isc_event_free(&ev);
EXIT("senddone");
}
static void
reset_client(isc_httpd_t *httpd)
{
INSIST(ISC_HTTPD_ISRECV(httpd));
INSIST(!ISC_LINK_LINKED(&httpd->headerbuffer, link));
INSIST(!ISC_LINK_LINKED(&httpd->bodybuffer, link));
httpd->recvbuf[0] = 0;
httpd->recvlen = 0;
httpd->method = ISC_HTTPD_METHODUNKNOWN;
httpd->url = NULL;
httpd->querystring = NULL;
httpd->protocol = NULL;
httpd->flags = 0;
isc_buffer_clear(&httpd->headerbuffer);
isc_buffer_invalidate(&httpd->bodybuffer);
}
isc_result_t
isc_httpdmgr_addurl(isc_httpdmgr_t *httpdmgr, const char *url,
isc_httpdaction_t *func, void *arg)
{
isc_httpdurl_t *item;
if (url == NULL) {
httpdmgr->render_404 = func;
return (ISC_R_SUCCESS);
}
item = isc_mem_get(httpdmgr->mctx, sizeof(isc_httpdurl_t));
if (item == NULL)
return (ISC_R_NOMEMORY);
item->url = isc_mem_strdup(httpdmgr->mctx, url);
if (item->url == NULL) {
isc_mem_put(httpdmgr->mctx, item, sizeof(isc_httpdurl_t));
return (ISC_R_NOMEMORY);
}
item->action = func;
item->action_arg = arg;
ISC_LINK_INIT(item, link);
ISC_LIST_APPEND(httpdmgr->urls, item, link);
return (ISC_R_SUCCESS);
}