602 lines
16 KiB
C
602 lines
16 KiB
C
#include "mio-http.h"
|
|
#include "mio-htrd.h"
|
|
#include "mio-prv.h"
|
|
|
|
struct mio_svc_htts_t
|
|
{
|
|
MIO_SVC_HEADER;
|
|
|
|
mio_dev_sck_t* lsck;
|
|
};
|
|
|
|
struct mio_svc_httc_t
|
|
{
|
|
MIO_SVC_HEADER;
|
|
};
|
|
|
|
|
|
struct mio_htts_client_t
|
|
{
|
|
mio_skad_t remote_addr;
|
|
mio_skad_t local_addr;
|
|
mio_skad_t orgdst_addr;
|
|
mio_htrd_t* htrd;
|
|
mio_becs_t* sbuf; /* temporary buffer for status line formatting */
|
|
};
|
|
typedef struct mio_htts_client_t mio_htts_client_t;
|
|
|
|
struct sck_xtn_t
|
|
{
|
|
mio_svc_htts_t* htts;
|
|
|
|
mio_htts_client_t c;
|
|
};
|
|
typedef struct sck_xtn_t sck_xtn_t;
|
|
|
|
struct htrd_xtn_t
|
|
{
|
|
mio_dev_sck_t* sck;
|
|
};
|
|
typedef struct htrd_xtn_t htrd_xtn_t;
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
static int process_request (mio_svc_htts_t* htts, mio_dev_sck_t* csck, mio_htre_t* req, int peek)
|
|
{
|
|
//server_xtn_t* server_xtn = GET_SERVER_XTN(htts, client->server);
|
|
//mio_htts_task_t* task;
|
|
sck_xtn_t* csckxtn = mio_dev_sck_getxtn(csck);
|
|
mio_http_method_t mth;
|
|
//mio_htts_rsrc_t rsrc;
|
|
|
|
/* percent-decode the query path to the original buffer
|
|
* since i'm not going to need it in the original form
|
|
* any more. once it's decoded in the peek mode,
|
|
* the decoded query path is made available in the
|
|
* non-peek mode as well */
|
|
if (peek)
|
|
{
|
|
mio_htre_perdecqpath(req);
|
|
|
|
/* TODO: proper request logging */
|
|
|
|
MIO_DEBUG2 (htts->mio, "%s %s\n", mio_htre_getqmethodname(req), mio_htre_getqpath(req));
|
|
}
|
|
else
|
|
{
|
|
MIO_DEBUG2 (htts->mio, "[NOPEEK] %s %s\n", mio_htre_getqmethodname(req), mio_htre_getqpath(req));
|
|
}
|
|
|
|
#if 0
|
|
mio_printf (MIO_T("================================\n"));
|
|
mio_printf (MIO_T("[%lu] %hs REQUEST ==> [%hs] version[%d.%d %hs] method[%hs]\n"),
|
|
(unsigned long)time(NULL),
|
|
(peek? MIO_MT("PEEK"): MIO_MT("HANDLE")),
|
|
mio_htre_getqpath(req),
|
|
mio_htre_getmajorversion(req),
|
|
mio_htre_getminorversion(req),
|
|
mio_htre_getverstr(req),
|
|
mio_htre_getqmethodname(req)
|
|
);
|
|
if (mio_htre_getqparam(req))
|
|
mio_printf (MIO_T("PARAMS ==> [%hs]\n"), mio_htre_getqparam(req));
|
|
|
|
mio_htb_walk (&req->hdrtab, walk, MIO_NULL);
|
|
if (mio_htre_getcontentlen(req) > 0)
|
|
{
|
|
mio_printf (MIO_T("CONTENT [%.*S]\n"), (int)mio_htre_getcontentlen(req), mio_htre_getcontentptr(req));
|
|
}
|
|
#endif
|
|
|
|
mth = mio_htre_getqmethodtype(req);
|
|
if (peek)
|
|
{
|
|
/* determine what to do once the header fields are all received.
|
|
* i don't want to delay this until the contents are received.
|
|
* if you don't like this behavior, you must implement your own
|
|
* callback function for request handling. */
|
|
|
|
#if 0
|
|
/* TODO support X-HTTP-Method-Override */
|
|
if (data.method == MIO_HTTP_POST)
|
|
{
|
|
tmp = mio_htre_getheaderval(req, MIO_MT("X-HTTP-Method-Override"));
|
|
if (tmp)
|
|
{
|
|
/*while (tmp->next) tmp = tmp->next;*/ /* get the last value */
|
|
data.method = mio_mbstohttpmethod (tmp->ptr);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (mth == MIO_HTTP_CONNECT)
|
|
{
|
|
/* CONNECT method must not have content set.
|
|
* however, arrange to discard it if so.
|
|
*
|
|
* NOTE: CONNECT is implemented to ignore many headers like
|
|
* 'Expect: 100-continue' and 'Connection: keep-alive'. */
|
|
mio_htre_discardcontent (req);
|
|
}
|
|
else
|
|
{
|
|
#if 0
|
|
if (mth == MIO_HTTP_POST &&
|
|
!(req->flags & MIO_HTRE_ATTR_LENGTH) &&
|
|
!(req->flags & MIO_HTRE_ATTR_CHUNKED))
|
|
{
|
|
/* POST without Content-Length nor not chunked */
|
|
req->flags &= ~MIO_HTRE_ATTR_KEEPALIVE;
|
|
mio_htre_discardcontent (req);
|
|
task = mio_htts_entaskerror(htts, client, MIO_NULL, 411, req);
|
|
if (task)
|
|
{
|
|
/* 411 Length Required - can't keep alive. Force disconnect */
|
|
task = mio_htts_entaskdisconnect (htts, client, MIO_NULL);
|
|
}
|
|
|
|
/*
|
|
const qse_http_version_t* version = qse_htre_getversion(req);
|
|
return qse_httpd_entaskformat (
|
|
httpd, client, pred,
|
|
QSE_MT("HTTP/%d.%d 100 Continue\r\n\r\n"),
|
|
version->major, version->minor);
|
|
*/
|
|
mio_dev_sck_write (csck, data, len, XXXX, MIO_NULL);
|
|
}
|
|
else if (server_xtn->makersrc(htts, client, req, &rsrc) <= -1)
|
|
{
|
|
/* failed to make a resource. just send the internal server error.
|
|
* the makersrc handler can return a negative number to return
|
|
* '500 Internal Server Error'. If it wants to return a specific
|
|
* error code, it should return 0 with the MIO_HTTPD_RSRC_ERROR
|
|
* resource. */
|
|
mio_htts_discardcontent (req);
|
|
task = mio_htts_entaskerror(htts, client, MIO_NULL, 500, req);
|
|
}
|
|
else
|
|
{
|
|
|
|
task = MIO_NULL;
|
|
|
|
|
|
if ((rsrc.flags & MIO_HTTPD_RSRC_100_CONTINUE) &&
|
|
(task = mio_htts_entaskcontinue(htts, client, task, req)) == MIO_NULL)
|
|
{
|
|
/* inject '100 continue' first if it is needed */
|
|
goto oops;
|
|
}
|
|
|
|
/* arrange the actual resource to be returned */
|
|
task = mio_htts_entaskrsrc(htts, client, task, &rsrc, req);
|
|
server_xtn->freersrc (htts, client, req, &rsrc);
|
|
|
|
/* if the resource is indicating to return an error,
|
|
* discard the contents since i won't return them */
|
|
if (rsrc.type == MIO_HTTPD_RSRC_ERROR)
|
|
{
|
|
mio_htre_discardcontent (req);
|
|
}
|
|
}
|
|
|
|
if (task == MIO_NULL) goto oops;
|
|
#endif
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* contents are all received */
|
|
mio_svc_htts_sendstatus (htts, csck, 500, mth, mio_htre_getversion(req), (req->flags & MIO_HTRE_ATTR_KEEPALIVE), MIO_NULL);
|
|
return 0;
|
|
|
|
if (mth == MIO_HTTP_CONNECT)
|
|
{
|
|
MIO_DEBUG1 (htts->mio, "Switching HTRD to DUMMY for [%hs]\n", mio_htre_getqpath(req));
|
|
|
|
/* Switch the http read to a dummy mode so that the subsqeuent
|
|
* input(request) is just treated as data to the request just
|
|
* completed */
|
|
mio_htrd_dummify (csckxtn->c.htrd);
|
|
|
|
////////
|
|
#if 0
|
|
if (server_xtn->makersrc(htts, client, req, &rsrc) <= -1)
|
|
{
|
|
MIO_DEBUG1 (htts->mio, "Cannot make resource for [%hs]\n", mio_htre_getqpath(req));
|
|
|
|
/* failed to make a resource. just send the internal server error.
|
|
* the makersrc handler can return a negative number to return
|
|
* '500 Internal Server Error'. If it wants to return a specific
|
|
* error code, it should return 0 with the MIO_HTTPD_RSRC_ERROR
|
|
* resource. */
|
|
task = mio_htts_entaskerror(htts, client, MIO_NULL, 500, req);
|
|
}
|
|
else
|
|
{
|
|
/* arrange the actual resource to be returned */
|
|
task = mio_htts_entaskrsrc (htts, client, MIO_NULL, &rsrc, req);
|
|
server_xtn->freersrc (htts, client, req, &rsrc);
|
|
}
|
|
|
|
if (task == MIO_NULL) goto oops;
|
|
#endif
|
|
////////
|
|
}
|
|
else if (req->flags & MIO_HTRE_ATTR_PROXIED)
|
|
{
|
|
/* the contents should be proxied.
|
|
* do nothing locally */
|
|
}
|
|
else
|
|
{
|
|
/* when the request is handled locally,
|
|
* there's nothing special to do here */
|
|
}
|
|
}
|
|
|
|
if (!(req->flags & MIO_HTRE_ATTR_KEEPALIVE) || mth == MIO_HTTP_CONNECT)
|
|
{
|
|
if (!peek)
|
|
{
|
|
//// task = mio_htts_entaskdisconnect(htts, client, MIO_NULL);
|
|
//// if (MIO_UNLIKELY(!task)) goto oops;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
|
|
oops:
|
|
/*mio_htts_markbadclient (htts, client);*/
|
|
return -1;
|
|
}
|
|
|
|
static int client_htrd_peek_request (mio_htrd_t* htrd, mio_htre_t* req)
|
|
{
|
|
htrd_xtn_t* htrdxtn = (htrd_xtn_t*)mio_htrd_getxtn(htrd);
|
|
sck_xtn_t* sckxtn = (sck_xtn_t*)mio_dev_sck_getxtn(htrdxtn->sck);
|
|
return process_request(sckxtn->htts, htrdxtn->sck, req, 1);
|
|
// return xtn->htts->opt.rcb.peekreq(xtn->htts, xtn->client, req);
|
|
}
|
|
|
|
static int client_htrd_poke_request (mio_htrd_t* htrd, mio_htre_t* req)
|
|
{
|
|
htrd_xtn_t* htrdxtn = (htrd_xtn_t*)mio_htrd_getxtn(htrd);
|
|
sck_xtn_t* sckxtn = (sck_xtn_t*)mio_dev_sck_getxtn(htrdxtn->sck);
|
|
return process_request(sckxtn->htts, htrdxtn->sck, req, 0);
|
|
}
|
|
|
|
static mio_htrd_recbs_t client_htrd_recbs =
|
|
{
|
|
client_htrd_peek_request,
|
|
client_htrd_poke_request
|
|
};
|
|
|
|
static int init_client (mio_t* mio, mio_htts_client_t* c, mio_dev_sck_t* sck)
|
|
{
|
|
htrd_xtn_t* htrdxtn;
|
|
|
|
c->htrd = mio_htrd_open(mio, MIO_SIZEOF(*htrdxtn));
|
|
if (MIO_UNLIKELY(!c->htrd)) goto oops;
|
|
|
|
c->sbuf = mio_becs_open(mio, 0, 2048);
|
|
if (MIO_UNLIKELY(!c->sbuf)) goto oops;
|
|
htrdxtn = mio_htrd_getxtn(c->htrd);
|
|
htrdxtn->sck = sck;
|
|
|
|
mio_htrd_setrecbs (c->htrd, &client_htrd_recbs);
|
|
|
|
return 0;
|
|
|
|
oops:
|
|
if (c->sbuf)
|
|
{
|
|
mio_becs_close(c->sbuf);
|
|
c->sbuf = MIO_NULL;
|
|
}
|
|
if (c->htrd)
|
|
{
|
|
mio_htrd_close (c->htrd);
|
|
c->htrd = MIO_NULL;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static void fini_client (mio_t* mio, mio_htts_client_t* c)
|
|
{
|
|
if (c->sbuf)
|
|
{
|
|
mio_becs_close(c->sbuf);
|
|
c->sbuf = MIO_NULL;
|
|
}
|
|
if (c->htrd)
|
|
{
|
|
mio_htrd_close (c->htrd);
|
|
c->htrd = MIO_NULL;
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
static int client_on_read (mio_dev_sck_t* sck, const void* buf, mio_iolen_t len, const mio_skad_t* srcaddr)
|
|
{
|
|
sck_xtn_t* sckxtn = mio_dev_sck_getxtn(sck);
|
|
printf ("** HTTS - client read %p %d -> htts:%p\n", sck, (int)len, sckxtn->htts);
|
|
if (len <= 0)
|
|
{
|
|
mio_dev_sck_halt (sck);
|
|
}
|
|
else if (mio_htrd_feed(sckxtn->c.htrd, buf, len) <= -1)
|
|
{
|
|
mio_dev_sck_halt (sck);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int client_on_write (mio_dev_sck_t* sck, mio_iolen_t wrlen, void* wrctx, const mio_skad_t* dstaddr)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void client_on_disconnect (mio_dev_sck_t* sck)
|
|
{
|
|
sck_xtn_t* sckxtn = mio_dev_sck_getxtn(sck);
|
|
printf ("** HTTS - client disconnect %p\n", sck);
|
|
fini_client (sck->mio, &sckxtn->c);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
static int listener_on_read (mio_dev_sck_t* sck, const void* buf, mio_iolen_t len, const mio_skad_t* srcaddr)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int listener_on_write (mio_dev_sck_t* sck, mio_iolen_t wrlen, void* wrctx, const mio_skad_t* dstaddr)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void listener_on_connect (mio_dev_sck_t* sck)
|
|
{
|
|
sck_xtn_t* sckxtn = mio_dev_sck_getxtn(sck); /* the contents came from the listening socket */
|
|
|
|
if (sck->state & MIO_DEV_SCK_ACCEPTED)
|
|
{
|
|
/* accepted a new client */
|
|
MIO_DEBUG3 (sck->mio, "** HTTS(%p) - accepted... %p %d \n", sckxtn->htts, sck, sck->sck);
|
|
|
|
/* the accepted socket inherits various event callbacks. switch some of them to avoid sharing */
|
|
sck->on_read = client_on_read;
|
|
sck->on_write = client_on_write;
|
|
sck->on_disconnect = client_on_disconnect;
|
|
|
|
if (init_client(sck->mio, &sckxtn->c, sck) <= -1)
|
|
{
|
|
MIO_INFO2 (sck->mio, "UNABLE TO INITIALIZE NEW CLIENT %p %d\n", sck, (int)sck->sck);
|
|
mio_dev_sck_halt (sck);
|
|
}
|
|
}
|
|
else if (sck->state & MIO_DEV_SCK_CONNECTED)
|
|
{
|
|
/* this will never be triggered as the listing socket never call mio_dev_sck_connect() */
|
|
MIO_DEBUG3 (sck->mio, "** HTTS(%p) - connected... %p %d \n", sckxtn->htts, sck, sck->sck);
|
|
}
|
|
|
|
/* MIO_DEV_SCK_CONNECTED must not be seen here as this is only for the listener socket */
|
|
}
|
|
|
|
static void listener_on_disconnect (mio_dev_sck_t* sck)
|
|
{
|
|
sck_xtn_t* sckxtn = mio_dev_sck_getxtn(sck);
|
|
|
|
switch (MIO_DEV_SCK_GET_PROGRESS(sck))
|
|
{
|
|
case MIO_DEV_SCK_CONNECTING:
|
|
MIO_INFO1 (sck->mio, "OUTGOING SESSION DISCONNECTED - FAILED TO CONNECT (%d) TO REMOTE SERVER\n", (int)sck->sck);
|
|
break;
|
|
|
|
case MIO_DEV_SCK_CONNECTING_SSL:
|
|
MIO_INFO1 (sck->mio, "OUTGOING SESSION DISCONNECTED - FAILED TO SSL-CONNECT (%d) TO REMOTE SERVER\n", (int)sck->sck);
|
|
break;
|
|
|
|
case MIO_DEV_SCK_LISTENING:
|
|
MIO_INFO1 (sck->mio, "SHUTTING DOWN THE SERVER SOCKET(%d)...\n", (int)sck->sck);
|
|
break;
|
|
|
|
case MIO_DEV_SCK_CONNECTED:
|
|
MIO_INFO1 (sck->mio, "OUTGOING CLIENT CONNECTION GOT TORN DOWN(%d).......\n", (int)sck->sck);
|
|
break;
|
|
|
|
case MIO_DEV_SCK_ACCEPTING_SSL:
|
|
MIO_INFO1 (sck->mio, "INCOMING SSL-ACCEPT GOT DISCONNECTED(%d) ....\n", (int)sck->sck);
|
|
break;
|
|
|
|
case MIO_DEV_SCK_ACCEPTED:
|
|
MIO_INFO1 (sck->mio, "INCOMING CLIENT BEING SERVED GOT DISCONNECTED(%d).......\n", (int)sck->sck);
|
|
break;
|
|
|
|
default:
|
|
MIO_INFO1 (sck->mio, "DISCONNECTED AFTER ALL(%d).......\n", (int)sck->sck);
|
|
break;
|
|
}
|
|
|
|
|
|
/* the client sockets are finalized in clinet_on_disconnect().
|
|
* for a listener socket, these fields must be NULL */
|
|
MIO_ASSERT (sck->mio, sckxtn->c.htrd == MIO_NULL);
|
|
MIO_ASSERT (sck->mio, sckxtn->c.sbuf == MIO_NULL);
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
mio_svc_htts_t* mio_svc_htts_start (mio_t* mio, const mio_skad_t* bind_addr)
|
|
{
|
|
mio_svc_htts_t* htts = MIO_NULL;
|
|
union
|
|
{
|
|
mio_dev_sck_make_t m;
|
|
mio_dev_sck_bind_t b;
|
|
mio_dev_sck_listen_t l;
|
|
} info;
|
|
sck_xtn_t* sckxtn;
|
|
|
|
htts = (mio_svc_htts_t*)mio_callocmem(mio, MIO_SIZEOF(*htts));
|
|
if (MIO_UNLIKELY(!htts)) goto oops;
|
|
|
|
htts->mio = mio;
|
|
htts->svc_stop = mio_svc_htts_stop;
|
|
|
|
MIO_MEMSET (&info, 0, MIO_SIZEOF(info));
|
|
switch (mio_skad_family(bind_addr))
|
|
{
|
|
case MIO_AF_INET:
|
|
info.m.type = MIO_DEV_SCK_TCP4;
|
|
break;
|
|
|
|
case MIO_AF_INET6:
|
|
info.m.type = MIO_DEV_SCK_TCP6;
|
|
break;
|
|
|
|
default:
|
|
mio_seterrnum (mio, MIO_EINVAL);
|
|
goto oops;
|
|
}
|
|
|
|
MIO_MEMSET (&info, 0, MIO_SIZEOF(info));
|
|
info.m.on_write = listener_on_write;
|
|
info.m.on_read = listener_on_read;
|
|
info.m.on_connect = listener_on_connect;
|
|
info.m.on_disconnect = listener_on_disconnect;
|
|
htts->lsck = mio_dev_sck_make(mio, MIO_SIZEOF(*sckxtn), &info.m);
|
|
if (!htts->lsck) goto oops;
|
|
|
|
sckxtn = (sck_xtn_t*)mio_dev_sck_getxtn(htts->lsck);
|
|
sckxtn->htts = htts;
|
|
|
|
MIO_MEMSET (&info, 0, MIO_SIZEOF(info));
|
|
info.b.localaddr = *bind_addr;
|
|
info.b.options = MIO_DEV_SCK_BIND_REUSEADDR | MIO_DEV_SCK_BIND_REUSEPORT;
|
|
MIO_INIT_NTIME (&info.b.accept_tmout, 5, 1);
|
|
if (mio_dev_sck_bind(htts->lsck, &info.b) <= -1) goto oops;
|
|
|
|
info.l.backlogs = 255;
|
|
if (mio_dev_sck_listen(htts->lsck, &info.l) <= -1) goto oops;
|
|
|
|
printf ("** HTTS LISTENER SOCKET %p\n", htts->lsck);
|
|
MIO_SVCL_APPEND_SVC (&mio->actsvc, (mio_svc_t*)htts);
|
|
return htts;
|
|
|
|
oops:
|
|
if (htts)
|
|
{
|
|
if (htts->lsck) mio_dev_sck_kill (htts->lsck);
|
|
mio_freemem (mio, htts);
|
|
}
|
|
return MIO_NULL;
|
|
}
|
|
|
|
void mio_svc_htts_stop (mio_svc_htts_t* htts)
|
|
{
|
|
mio_t* mio = htts->mio;
|
|
|
|
if (htts->lsck) mio_dev_sck_kill (htts->lsck);
|
|
/*if (dnc->lsck) mio_dev_sck_kill (dnc->lsck);
|
|
while (dnc->pending_req) release_dns_msg (dnc, dnc->pending_req);*/
|
|
|
|
MIO_SVCL_UNLINK_SVC (htts);
|
|
mio_freemem (mio, htts);
|
|
}
|
|
|
|
|
|
void mio_svc_htts_sendstatus (mio_svc_htts_t* htts, mio_dev_sck_t* csck, int status_code, mio_http_method_t method, const mio_http_version_t* version, int keepalive, void* extra)
|
|
{
|
|
sck_xtn_t* csckxtn = mio_dev_sck_getxtn(csck);
|
|
mio_bch_t text[1024]; /* TODO: make this buffer dynamic or scalable */
|
|
mio_bch_t dtbuf[64];
|
|
|
|
const mio_bch_t* extrapre = "";
|
|
const mio_bch_t* extrapst = "";
|
|
const mio_bch_t* extraval = "";
|
|
|
|
|
|
text[0] = '\0';
|
|
|
|
switch (status_code)
|
|
{
|
|
#if 0
|
|
case 301: /* Moved Permanently */
|
|
case 302: /* Found */
|
|
case 303: /* See Other (since HTTP/1.1) */
|
|
case 307: /* Temporary Redirect (since HTTP/1.1) */
|
|
case 308: /* Permanent Redirect (Experimental RFC; RFC 7238) */
|
|
{
|
|
mio_svc_htts_rsrc_reloc_t* reloc;
|
|
reloc = (mio_htts_rsrc_reloc_t*)extra;
|
|
extrapre = "Location: ";
|
|
extrapst = (reloc->flags & MIO_SVC_HTTS_RSRC_RELOC_APPENDSLASH)? "/\r\n": "\r\n";
|
|
extraval = reloc->target;
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
case 304:
|
|
case 200:
|
|
case 201:
|
|
case 202:
|
|
case 203:
|
|
case 204:
|
|
case 205:
|
|
case 206:
|
|
/* nothing to do */
|
|
break;
|
|
|
|
|
|
default:
|
|
#if 0
|
|
if (method != MIO_HTTP_HEAD &&
|
|
htts->opt.rcb.fmterr(htts, client, code, text, MIO_COUNTOF(text)) <= -1) return QSE_NULL;
|
|
#endif
|
|
|
|
if (status_code == 401)
|
|
{
|
|
extrapre = "WWW-Authenticate: Basic realm=\"";
|
|
extrapst = "\"\r\n";
|
|
extraval = (const mio_bch_t*)extra;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
mio_svc_htts_fmtgmtime(htts, MIO_NULL, dtbuf, MIO_COUNTOF(dtbuf));
|
|
|
|
mio_becs_fmt (csckxtn->c.sbuf, "HTTP/%d.%d %d %s\r\nServer: %s\r\nDate: %s\r\nConnection: %s\r\nContent-Type: text/html\r\nContent-Length: %u\r\n%s%s%s\r\n%s",
|
|
version->major, version->minor, status_code, mio_http_status_to_bcstr(status_code),
|
|
"SERVER-NAME", /* TODO: use actual name mio_svc_htts_getservername(). */
|
|
dtbuf, /* DATE */
|
|
(keepalive? "keep-alive": "close"), /* connection */
|
|
mio_count_bcstr(text), /* content length */
|
|
extrapre, extraval, extraval, text
|
|
);
|
|
|
|
if (mio_dev_sck_write(csck, MIO_BECS_PTR(csckxtn->c.sbuf), MIO_BECS_LEN(csckxtn->c.sbuf), MIO_NULL, MIO_NULL) <= -1)
|
|
{
|
|
mio_dev_sck_halt (csck);
|
|
}
|
|
}
|
|
|
|
|
|
void mio_svc_htts_fmtgmtime (mio_svc_htts_t* htts, const mio_ntime_t* nt, mio_bch_t* buf, mio_oow_t len)
|
|
{
|
|
mio_ntime_t now;
|
|
|
|
if (!nt)
|
|
{
|
|
mio_sys_getrealtime(htts->mio, &now);
|
|
nt = &now;
|
|
}
|
|
|
|
mio_fmt_http_time_to_bcstr(nt, buf, len);
|
|
}
|