shrub/vere/http.c

/* v/http.c
**
*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdint.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <uv.h>
#include <errno.h>

#include "all.h"
#include "vere/vere.h"

#include "h2o.h"

static const c3_i TCP_BACKLOG = 16;

// XX put this on u3_host ?
static h2o_globalconf_t fig_u;

// XX rename and move to vere.h
typedef struct _h2htp {
  uv_tcp_t          wax_u;            //  server stream handler
  h2o_context_t*    ctx_u;            //  h2o ctx
  h2o_accept_ctx_t* cep_u;            //  h2o accept ctx (wat for?)
  h2o_hostconf_t*   hos_u;            //  h2o host config
  c3_w              sev_l;            //  server number
  c3_w              coq_l;            //  next connection number
  c3_w              por_w;            //  running port
  c3_o              sec;              //  logically secure
  c3_o              lop;              //  loopback-only
  struct _h2con*    hon_u;            //  connection list
  struct _h2htp*    nex_u;            //  next in list
} h2htp;

typedef struct _h2con {
  uv_tcp_t         wax_u;             //  client stream handler
  h2o_conn_t*      con_u;             //  h2o connection
  h2o_socket_t*    sok_u;             //  h2o connection socket
  c3_w             ipf_w;             //  client ipv4
  c3_w             coq_l;             //  connection number
  c3_w             seq_l;             //  next request number
  struct _h2htp*   htp_u;             //  server backlink
  struct _h2req*   req_u;             //  request list
  struct _h2con*   nex_u;             //  next in server's list
} h2con;

typedef struct _h2req {
  h2o_req_t*       rec_u;             //  h2o request
  c3_w             seq_l;             //  sequence within connection
  struct _h2con*   hon_u;             //  connection backlink
  struct _h2req*   nex_u;             //  next in connection's list
} h2req;

// XX u3_Host.htp_u
static h2htp* sev_u = 0;  // global server list

static u3_noun _http_pox_to_noun(c3_w sev_l, c3_w coq_l, c3_w seq_l);
static void _http_request(h2req* req_u, u3_noun recq);
static void _http_request_kill(h2req* req_u);
static void _http_req_link(h2con* hon_u, h2req* req_u);
static void _http_req_unlink(h2req* req_u);
static void _http_conn_link(h2htp* htp_u, h2con* hon_u);
static void _http_conn_unlink(h2con* hon_u);

// XX keep here (or in new http.h?)
typedef struct _h2o_ctx_wrap {
  h2o_context_t     cxt_u;            //  h2o ctx
  struct _h2htp*    htp_u;            //  server backlink
} h2o_ctx_wrap;

typedef struct _h2hed {
  struct _h2hed* nex_u;
  c3_w           nam_w;
  c3_c*          nam_c;
  c3_w           val_w;
  c3_c*          val_c;
} h2hed;

/* _http_vec_to_meth(): convert h2o_iovec_t to meth
*/
static u3_weak
_http_vec_to_meth(h2o_iovec_t vec_u)
{
  return ( 0 == strncmp(vec_u.base, "GET",     vec_u.len) ) ? c3__get  :
         ( 0 == strncmp(vec_u.base, "PUT",     vec_u.len) ) ? c3__put  :
         ( 0 == strncmp(vec_u.base, "POST",    vec_u.len) ) ? c3__post :
         ( 0 == strncmp(vec_u.base, "HEAD",    vec_u.len) ) ? c3__head :
         ( 0 == strncmp(vec_u.base, "CONNECT", vec_u.len) ) ? c3__conn :
         ( 0 == strncmp(vec_u.base, "DELETE",  vec_u.len) ) ? c3__delt :
         ( 0 == strncmp(vec_u.base, "OPTIONS", vec_u.len) ) ? c3__opts :
         ( 0 == strncmp(vec_u.base, "TRACE",   vec_u.len) ) ? c3__trac :
         // TODO ??
         // ( 0 == strncmp(vec_u.base, "PATCH",   vec_u.len) ) ? c3__patc :
         u3_none;
}

/* _http_vec_to_atom(): convert h2o_iovec_t to atom (cord)
*/
static u3_noun
_http_vec_to_atom(h2o_iovec_t vec_u)
{
  // XX portable?
  return u3i_bytes(vec_u.len, (const c3_y*)vec_u.base);
}

/* _http_vec_to_octs(): convert h2o_iovec_t to (unit octs)
*/
static u3_noun
_http_vec_to_octs(h2o_iovec_t vec_u)
{
  if ( 0 == vec_u.len ) {
    return u3_nul;
  }

  // XX correct size_t -> atom?
  return u3nt(u3_nul, u3i_chubs(1, (const c3_d*)&vec_u.len),
                      _http_vec_to_atom(vec_u));
}

/* _http_vec_from_octs(): convert (unit octs) to h2o_iovec_t
*/
static h2o_iovec_t*
_http_vec_from_octs(u3_noun oct)
{
  h2o_iovec_t* vec_u = c3_malloc(sizeof(*vec_u));

  if ( u3_nul == oct ) {
    vec_u->base = 0;
    vec_u->len = 0;
  }
  else {
    // XX bails
    // if ( !_(u3a_is_cat(u3t(oct))) ) {
    //   //  2GB max
    //   u3m_bail(c3__fail); return 0;
    // }

    vec_u->len = u3h(u3t(oct));
    vec_u->base = c3_malloc(vec_u->len);
    u3r_bytes(0, vec_u->len, (c3_y*)vec_u->base, u3t(u3t(oct)));
  }

  u3z(oct);
  return vec_u;
}

/* _http_heds_to_noun(): convert h2o_headers_t to (list (pair @t @t))
*/
static u3_noun
_http_heds_to_noun(h2o_headers_t* hed_u)
{
  u3_noun hed = u3_nul;
  size_t dex = hed_u->size;

  h2o_header_t deh;

  while ( 0 < dex ) {
    deh = hed_u->entries[--dex];
    hed = u3nc(u3nc(_http_vec_to_atom(*deh.name),
                    _http_vec_to_atom(deh.value)), hed);
  }

  return hed;
}

/* _http_heds_from_noun(): convert (list (pair @t @t)) to h2hed
*/
static h2hed*
_http_heds_from_noun(u3_noun hed)
{
  u3_noun deh = hed;
  h2hed* hed_u = 0;

  while ( u3_nul != hed ) {
    u3_noun nam = u3h(u3h(hed));
    u3_noun val = u3t(u3h(hed));

    h2hed* nex_u = c3_malloc(sizeof(*nex_u));
    nex_u->nam_w = u3r_met(3, nam);
    nex_u->val_w = u3r_met(3, val);
    nex_u->nam_c = c3_malloc(nex_u->nam_w);
    nex_u->val_c = c3_malloc(nex_u->val_w);

    u3r_bytes(0, nex_u->nam_w, (c3_y*)nex_u->nam_c, nam);
    u3r_bytes(0, nex_u->val_w, (c3_y*)nex_u->val_c, val);

    nex_u->nex_u = hed_u;
    hed_u = nex_u;
    hed = u3t(hed);
  }

  u3z(deh);
  return hed_u;
}

/* _http_req_to_httq(): convert h2o_req_t to httq
*/
static u3_weak
_http_req_to_httq(h2o_req_t* rec_u)
{
  u3_noun med = _http_vec_to_meth(rec_u->method);

  if ( u3_none == med ) {
    return u3_none;
  }

  u3_noun url = _http_vec_to_atom(rec_u->path_normalized);
  u3_noun hed = _http_heds_to_noun(&rec_u->headers);
  u3_noun bod = _http_vec_to_octs(rec_u->entity);

  return u3nq(med, url, hed, bod);
}

/* _http_req_free(): free http request.
*/
static void
_http_req_free(h2req* req_u)
{
  _http_req_unlink(req_u);
  free(req_u);
}

/* _http_req_new(): receive http request.
*/
static h2req*
_http_req_new(h2con* hon_u, h2o_req_t* rec_u)
{
  // unnecessary, just an example
  h2o_ctx_wrap* ctx_u = (h2o_ctx_wrap*)rec_u->conn->ctx;
  h2htp* htp_u = ctx_u->htp_u;

  h2req* req_u = c3_malloc(sizeof(*req_u));
  req_u->rec_u = rec_u;
  _http_req_link(hon_u, req_u);

  return req_u;
}

/* _http_send_response(): write httr to h2o_req_t->res and send
*/
static void
_http_send_response(h2req* req_u, u3_noun sas, u3_noun hed, u3_noun bod)
{
  h2o_req_t* rec_u = req_u->rec_u;

  rec_u->res.status = sas;
  rec_u->res.reason = (sas < 200) ? "Weird" :
                      (sas < 300) ? "OK" :
                      (sas < 400) ? "Moved" :
                      (sas < 500) ? "Missing" :
                      "Hosed";

  h2hed* hed_u = _http_heds_from_noun(u3k(hed));
  h2hed* deh_u = hed_u;

  while ( 0 != hed_u ) {
    h2o_add_header_by_str(&rec_u->pool, &rec_u->res.headers,
                          hed_u->nam_c, hed_u->nam_w, 0, 0,
                          hed_u->val_c, hed_u->val_w);
    hed_u = hed_u->nex_u;
  }

  // XX free req_u on disponse (rec_u should be free'd by h2o)
  static h2o_generator_t gen_u = {NULL, NULL};
  h2o_start_response(rec_u, &gen_u);

  // TODO: put this in the generator so it runs on next turn?
  h2o_iovec_t* bod_u = _http_vec_from_octs(u3k(bod));
  h2o_send(rec_u, bod_u, 1, 1);

  _http_req_free(req_u);

  // XX allocate on &req_u->pool and skip these?
  free(bod_u->base);
  free(bod_u);
  while ( 0 != deh_u ) {
    h2hed* duh_u = deh_u;
    deh_u = deh_u->nex_u;
    free(duh_u->nam_c);
    free(duh_u->val_c);
    free(duh_u);
  }

  u3z(sas); u3z(hed); u3z(bod);
}

// for casting and retrieving h2o_socket_t; see st_h2o_http1_conn_t
typedef struct _h2o_con_http1 {
  h2o_conn_t       con_u;             //  h2o connection
  h2o_socket_t*    sok_u;             //  h2o connection socket
} h2o_con_http1;

// for casting and retrieving h2con; see st_h2o_uv_socket_t
typedef struct _h2o_sok_uv {
  h2o_socket_t     sok_u;             //  h2o connection socket
  struct {
    uv_stream_t *stream;              //  client stream handler (h2con)
    uv_close_cb close_cb;
  } uv;
} h2o_sok_uv;

/* _http_conn_from_req(); retrieve connection from h2o http1 request.
*/
static h2con*
_http_conn_from_req(h2o_req_t* rec_u)
{
  // XX HTTP2 wat do?
  h2o_con_http1* noc_u = (h2o_con_http1*)rec_u->conn;
  h2o_sok_uv* kos_u = (h2o_sok_uv*)noc_u->sok_u;
  return (h2con*)kos_u->uv.stream;
};

/* _http_handle_new_req(); handle incoming http request from h2o.
*/
static c3_i
_http_handle_new_req(h2o_handler_t* han_u, h2o_req_t* rec_u)
{
  u3_weak recq = _http_req_to_httq(rec_u);

  if ( u3_none == recq ) {
    // XX debug only
    uL(fprintf(uH, "strange request\n"));

    static h2o_generator_t gen_u = {NULL, NULL};
    rec_u->res.status = 400;
    rec_u->res.reason = "Bad Request";
    h2o_start_response(rec_u, &gen_u);
    h2o_send(rec_u, 0, 0, 1);
  }
  else {
    h2con* hon_u = _http_conn_from_req(rec_u);
    h2req* req_u = _http_req_new(hon_u, rec_u);
    _http_request(req_u, recq);
  }

  return 0;
}

/* _http_conn_free_early(): free http connection on failure.
*/
static void
_http_conn_free_early(uv_handle_t* han_t)
{
  h2con* hon_u = (h2con*)han_t;
  free(hon_u);
}

/* _http_conn_free(): free http connection on close.
*/
static void
_http_conn_free(uv_handle_t* han_t)
{
  h2con* hon_u = (h2con*)han_t;

  while ( 0 != hon_u->req_u ) {
    h2req* req_u = hon_u->req_u;
    h2req* nex_u = req_u->nex_u;

    _http_request_kill(req_u);
    _http_req_free(req_u);
    hon_u->req_u = nex_u;
  }

  _http_conn_unlink(hon_u);
  free(hon_u);
}

/* _http_conn_new(): create and accept http connection.
*/
static void
_http_conn_new(h2htp* htp_u)
{
  // TODO where?
  // u3_lo_open();

  h2con* hon_u = c3_malloc(sizeof(*hon_u));
  hon_u->seq_l = 1;
  hon_u->req_u = 0;

  uv_tcp_init(u3L, &hon_u->wax_u);

  if ( 0 != uv_accept((uv_stream_t*)&htp_u->wax_u,
                      (uv_stream_t*)&hon_u->wax_u) ) {
    uv_close((uv_handle_t*)&hon_u->wax_u,
             (uv_close_cb)_http_conn_free_early);
    return;
  }

  _http_conn_link(htp_u, hon_u);

  hon_u->sok_u = h2o_uv_socket_create((uv_stream_t*)&hon_u->wax_u,
                                      (uv_close_cb)_http_conn_free);
  h2o_accept(htp_u->cep_u, hon_u->sok_u);

  // capture h2o connection (XX fragile)
  hon_u->con_u = (h2o_conn_t*)hon_u->sok_u->data;

  struct sockaddr_in adr_u;
  h2o_socket_getpeername(hon_u->sok_u, (struct sockaddr*)&adr_u);
  hon_u->ipf_w = ( adr_u.sin_family != AF_INET ) ?
                 0 : ntohl(adr_u.sin_addr.s_addr);

  // TODO where?
  // u3_lo_shut(c3y);
}

/* _http_listen_cb(): uv_connection_cb for uv_listen
*/
static void
_http_listen_cb(uv_stream_t* str_u, c3_i sas_i)
{
  h2htp* htp_u = (h2htp*)str_u;

  if ( 0 != sas_i ) {
    // XX retrieve and print error?
    uL(fprintf(uH, "http: listen_cb: ERROR\n"));
  }
  else {
    _http_conn_new(htp_u);
  }
}

/* _http_req_find(): find http request in connection by sequence.
*/
static h2req*
_http_req_find(h2con* hon_u, c3_w seq_l)
{
  h2req* req_u = hon_u->req_u;

  //  XX glories of linear search
  //
  while ( req_u ) {
    if ( seq_l == req_u->seq_l ) {
      return req_u;
    }
    req_u = req_u->nex_u;
  }
  return 0;
}

/* _http_req_link(): link http request to connection
*/
static void
_http_req_link(h2con* hon_u, h2req* req_u)
{
  req_u->hon_u = hon_u;
  req_u->seq_l = hon_u->seq_l++;
  req_u->nex_u = hon_u->req_u;
  hon_u->req_u = req_u;
}

/* _http_req_unlink(): remove http request from connection
*/
static void
_http_req_unlink(h2req* req_u)
{
  h2con* hon_u = req_u->hon_u;

  if ( hon_u->req_u == req_u ) {
    hon_u->req_u = req_u->nex_u;
  }
  else {
    h2req* pre_u = hon_u->req_u;

    //  XX glories of linear search
    //
    while ( pre_u ) {
      if ( pre_u->nex_u == req_u ) {
        pre_u->nex_u = req_u->nex_u;
      }
      else pre_u = pre_u->nex_u;
    }
  }
}

/* _http_conn_find(): find http connection in server by sequence.
*/
static h2con*
_http_conn_find(h2htp *htp_u, c3_w coq_l)
{
  h2con* hon_u = htp_u->hon_u;

  //  XX glories of linear search
  //
  while ( hon_u ) {
    if ( coq_l == hon_u->coq_l ) {
      return hon_u;
    }
    hon_u = hon_u->nex_u;
  }
  return 0;
}

/* _http_conn_link(): link http request to connection
*/
static void
_http_conn_link(h2htp* htp_u, h2con* hon_u)
{
  hon_u->htp_u = htp_u;
  hon_u->coq_l = htp_u->coq_l++;
  hon_u->nex_u = htp_u->hon_u;
  htp_u->hon_u = hon_u;
}

/* _http_conn_unlink(): remove http request from connection
*/
static void
_http_conn_unlink(h2con* hon_u)
{
  h2htp* htp_u = hon_u->htp_u;

  if ( htp_u->hon_u == hon_u ) {
    htp_u->hon_u = hon_u->nex_u;
  }
  else {
    h2con *pre_u = htp_u->hon_u;

    //  XX glories of linear search
    //
    while ( pre_u ) {
      if ( pre_u->nex_u == hon_u ) {
        pre_u->nex_u = hon_u->nex_u;
      }
      else pre_u = pre_u->nex_u;
    }
  }
}

/* _http_serv_find(): find http server by sequence.
*/
static h2htp*
_http_serv_find(c3_l sev_l)
{
  h2htp* htp_u = sev_u; // u3_Host.htp_u;

  //  XX glories of linear search
  //
  while ( htp_u ) {
    if ( sev_l == htp_u->sev_l ) {
      return htp_u;
    }
    htp_u = htp_u->nex_u;
  }
  return 0;
}

// XX serv_link and serv_unlink

// XX rename
/* _http_pox_to_noun(): translate srv/con/req to path noun (pox).
*/
static u3_noun
_http_pox_to_noun(c3_w sev_l, c3_w coq_l, c3_w seq_l)
{
  return u3nt(u3_blip, c3__http,
              u3nq(u3dc("scot", c3_s2('u','v'), sev_l),
                   u3dc("scot", c3_s2('u','d'), coq_l),
                   u3dc("scot", c3_s2('u','d'), seq_l),
                   u3_nul));
}

/* _http_request(): dispatch http request to %eyre
*/
static void
_http_request(h2req* req_u, u3_noun recq)
{
#if 1
  uL(fprintf(uH, "new request:\n"));
  u3_noun span = u3v_wish("-:!>(*{@t @t (list {p/@t q/@t}) (unit {p/@ q/@})})");
  u3m_tape(u3dc("text", span, u3k(recq)));
  uL(fprintf(uH, "\n"));
#endif

  u3_noun pox = _http_pox_to_noun(req_u->hon_u->htp_u->sev_l,
                                  req_u->hon_u->coq_l,
                                  req_u->seq_l);

  u3_noun typ = _(req_u->hon_u->htp_u->lop) ? c3__chis : c3__this;

  u3v_plan(pox, u3nq(typ,
                     req_u->hon_u->htp_u->sec,
                     u3nc(c3y, u3i_words(1, &req_u->hon_u->ipf_w)),
                     recq));
}

/* _http_request_kill(): kill http request in %eyre.
*/
static void
_http_request_kill(h2req* req_u)
{
  u3_noun pox = _http_pox_to_noun(req_u->hon_u->htp_u->sev_l,
                                  req_u->hon_u->coq_l,
                                  req_u->seq_l);

  u3v_plan(pox, u3nc(c3__thud, u3_nul));
}

/* _http_respond(): attach %eyre response to open request.
*/
static void
_http_respond(c3_l sev_l, c3_l coq_l, c3_l seq_l, u3_noun rep)
{
  h2htp* htp_u;
  h2con* hon_u;
  h2req* req_u;

  if ( !(htp_u = _http_serv_find(sev_l)) ) {
    if ( (u3C.wag_w & u3o_verbose) ) {
      uL(fprintf(uH, "http: server not found: %x\r\n", sev_l));
    }
    u3z(rep);
    return;
  }
  if ( !(hon_u = _http_conn_find(htp_u, coq_l)) ) {
    if ( (u3C.wag_w & u3o_verbose) ) {
      uL(fprintf(uH, "http: connection not found: %x/%d\r\n", sev_l, coq_l));
    }
    u3z(rep);
    return;
  }
  if ( !(req_u = _http_req_find(hon_u, seq_l)) ) {
    if ( (u3C.wag_w & u3o_verbose) ) {
      uL(fprintf(uH, "http: request not found: %x/%d/%d\r\n", sev_l, coq_l, seq_l));
    }
    u3z(rep);
    return;
  }

  {
    u3_noun p_rep, q_rep, r_rep;

    if ( c3n == u3r_trel(rep, &p_rep, &q_rep, &r_rep) ) {
      uL(fprintf(uH, "http: strange response\n"));
    }
    else {
      _http_send_response(req_u, u3k(p_rep), u3k(q_rep), u3k(r_rep));
    }
  }

  u3z(rep);
}

/* _http_init_h2o(): initialize h2o ctx and handlers for server.
*/
static void
_http_init_h2o(h2htp* htp_u)
{
  // wrapped for server backlink (wrapper unnecessary, just an example)
  htp_u->ctx_u = c3_malloc(sizeof(h2o_ctx_wrap));
  memset(htp_u->ctx_u, 0, sizeof(h2o_ctx_wrap));
  h2o_ctx_wrap* ctx_u = (h2o_ctx_wrap*)htp_u->ctx_u;
  ctx_u->htp_u = htp_u;

  //// FAILED ATTEMPTS:
  //   can't wrap handler and link server, see pointer math in request.c call_handlers
  //   can't use htp_u->ctx_u->_module_configs (don't know why)

  htp_u->cep_u = c3_malloc(sizeof(*htp_u->cep_u));
  memset(htp_u->cep_u, 0, sizeof(*htp_u->cep_u));

  htp_u->cep_u->ctx = (h2o_context_t*)htp_u->ctx_u;
  htp_u->cep_u->hosts = fig_u.hosts;

  // XX read name from server?
  htp_u->hos_u = h2o_config_register_host(&fig_u,
                                          h2o_iovec_init(H2O_STRLIT("default")),
                                          htp_u->por_w);

  // XX attach to server?
  h2o_handler_t* han_u = h2o_create_handler(&htp_u->hos_u->fallback_path, sizeof(*han_u));
  han_u->on_req = _http_handle_new_req;

  // XX handler lifecycle
  // han_u->on_context_init
  // han_u->on_context_dispose
  // han_u->dispose

  h2o_context_init((h2o_context_t*)htp_u->ctx_u, u3L, &fig_u);
}

/* _http_start(): start http server.
*/
static void
_http_start(h2htp* htp_u)
{
  struct sockaddr_in adr_u;
  memset(&adr_u, 0, sizeof(adr_u));
  adr_u.sin_family = AF_INET;

  if ( c3y == htp_u->lop ) {
    inet_pton(AF_INET, "127.0.0.1", &adr_u.sin_addr);
  }
  else {
    adr_u.sin_addr.s_addr = INADDR_ANY;
  }

  uv_tcp_init(u3L, &htp_u->wax_u);

  /*  Try ascending ports.
  */
  while ( 1 ) {
    c3_i ret;

    adr_u.sin_port = htons(htp_u->por_w);

    // XX maybe don't check uv_tcp_bind ret
    if ( 0 != (ret = uv_tcp_bind(&htp_u->wax_u, (const struct sockaddr*)&adr_u, 0)) ||
         0 != (ret = uv_listen((uv_stream_t*)&htp_u->wax_u,
                               TCP_BACKLOG, _http_listen_cb)) ) {
      if ( UV_EADDRINUSE == ret ) {
        htp_u->por_w++;
        continue;
      }
      else {
        uL(fprintf(uH, "http: listen: %s\n", uv_strerror(ret)));
      }
    }

    uL(fprintf(uH, "http: live (%s, %s) on %d\n",
                   (c3y == htp_u->sec) ? "\"secure\"" : "insecure",
                   (c3y == htp_u->lop) ? "loopback" : "public",
                   htp_u->por_w));

    _http_init_h2o(htp_u);
    break;
  }
}

/* _http_write_ports_file(): update .http.ports
*/
void
_http_write_ports_file(c3_c *pax_c)
{
#if 0
  c3_i    pal_i;
  c3_c    *paf_c;
  c3_i    por_i;
  u3_http *htp_u;

  pal_i = strlen(pax_c) + 13; /* includes NUL */
  paf_c = u3a_malloc(pal_i);
  snprintf(paf_c, pal_i, "%s/%s", pax_c, ".http.ports");

  por_i = open(paf_c, O_WRONLY | O_CREAT | O_TRUNC, 0666);
  u3a_free(paf_c);

  for ( htp_u = u3_Host.htp_u; htp_u; htp_u = htp_u->nex_u ) {
    dprintf(por_i, "%u %s %s\n", htp_u->por_w,
                   (c3y == htp_u->sec) ? "assumed-secure" : "insecure",
                   (c3y == htp_u->lop) ? "loopback" : "public");
  }

  c3_sync(por_i);
  close(por_i);
#endif
}

/* _http_release_ports_file(): remove .http.ports
*/
void
_http_release_ports_file(c3_c *pax_c)
{
#if 0
  c3_i pal_i;
  c3_c *paf_c;

  pal_i = strlen(pax_c) + 13; /* includes NUL */
  paf_c = u3a_malloc(pal_i);
  snprintf(paf_c, pal_i, "%s/%s", pax_c, ".http.ports");

  unlink(paf_c);
  u3a_free(paf_c);
#endif
}

// XX rename (is a card an effect?)
/* u3_http_ef_bake(): notify %eyre that we're live
*/
void
u3_http_ef_bake(void)
{
  u3_noun pax = u3nq(u3_blip, c3__http, u3k(u3A->sen), u3_nul);

  u3v_plan(pax, u3nc(c3__born, u3_nul));
}

/* u3_http_ef_thou(): send %thou from %eyre as http response.
*/
void
u3_http_ef_thou(c3_l     sev_l,
                c3_l     coq_l,
                c3_l     seq_l,
                u3_noun  rep)
{
  _http_respond(sev_l, coq_l, seq_l, u3k(rep));
  u3z(rep);
}

/* u3_http_io_init(): initialize http I/O.
*/
void
u3_http_io_init()
{
#if 0
  //  Lens port
  {
    u3_http *htp_u = c3_malloc(sizeof(*htp_u));

    htp_u->sev_l = u3A->sev_l + 2;
    htp_u->coq_l = 1;
    htp_u->por_w = 12321;
    htp_u->sec = c3n;
    htp_u->lop = c3y;

    htp_u->hon_u = 0;
    htp_u->nex_u = 0;

    htp_u->nex_u = u3_Host.htp_u;
    u3_Host.htp_u = htp_u;
  }

  //  Logically secure port.
  {
    u3_http *htp_u = c3_malloc(sizeof(*htp_u));

    htp_u->sev_l = u3A->sev_l + 1;
    htp_u->coq_l = 1;
    htp_u->por_w = 8443;
    htp_u->sec = c3y;
    htp_u->lop = c3n;

    htp_u->hon_u = 0;
    htp_u->nex_u = 0;

    htp_u->nex_u = u3_Host.htp_u;
    u3_Host.htp_u = htp_u;
  }
#endif
   // Insecure port.
  {
    h2htp* htp_u = c3_malloc(sizeof(*htp_u));

    htp_u->sev_l = u3A->sev_l;
    htp_u->coq_l = 1;
    htp_u->por_w = 8080;
    htp_u->sec = c3n;
    htp_u->lop = c3n;

    htp_u->cep_u = 0;
    htp_u->hos_u = 0;
    htp_u->hon_u = 0;
    htp_u->nex_u = 0;

    // XX u3_Host.htp_u
    htp_u->nex_u = sev_u;
    sev_u = htp_u;
  }

  // XX why is this here?
  u3_Host.ctp_u.coc_u = 0;
}

/* u3_http_io_talk(): start http I/O.
*/
void
u3_http_io_talk()
{
  h2htp* htp_u;

  // XX "global" per server?
  h2o_config_init(&fig_u);

  // XX u3_Host.htp_u
  for ( htp_u = sev_u; htp_u; htp_u = htp_u->nex_u ) {
    _http_start(htp_u);
  }

  _http_write_ports_file(u3_Host.dir_c);
}

/* u3_http_io_poll(): poll kernel for http I/O.
*/
void
u3_http_io_poll(void)
{
}

/* u3_http_io_exit(): shut down http.
*/
void
u3_http_io_exit(void)
{
  // XX shutdown servers cleanly
  _http_release_ports_file(u3_Host.dir_c);
}