1 /* v/http.c
2 **
3 */
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <fcntl.h>
7 #include <sys/ioctl.h>
8 #include <sys/stat.h>
9 #include <unistd.h>
10 #include <stdint.h>
11 #include <sys/socket.h>
12 #include <netinet/in.h>
13 #include <uv.h>
14 #include <errno.h>
15 #include <openssl/ssl.h>
16 #include <h2o.h>
17 #include "all.h"
18 #include "vere/vere.h"
19
20 static const c3_i TCP_BACKLOG = 16;
21
22 /* _http_vec_to_meth(): convert h2o_iovec_t to meth
23 */
24 static u3_weak
_http_vec_to_meth(h2o_iovec_t vec_u)25 _http_vec_to_meth(h2o_iovec_t vec_u)
26 {
27 return ( 0 == strncmp(vec_u.base, "GET", vec_u.len) ) ? c3__get :
28 ( 0 == strncmp(vec_u.base, "PUT", vec_u.len) ) ? c3__put :
29 ( 0 == strncmp(vec_u.base, "POST", vec_u.len) ) ? c3__post :
30 ( 0 == strncmp(vec_u.base, "HEAD", vec_u.len) ) ? c3__head :
31 ( 0 == strncmp(vec_u.base, "CONNECT", vec_u.len) ) ? c3__conn :
32 ( 0 == strncmp(vec_u.base, "DELETE", vec_u.len) ) ? c3__delt :
33 ( 0 == strncmp(vec_u.base, "OPTIONS", vec_u.len) ) ? c3__opts :
34 ( 0 == strncmp(vec_u.base, "TRACE", vec_u.len) ) ? c3__trac :
35 // TODO ??
36 // ( 0 == strncmp(vec_u.base, "PATCH", vec_u.len) ) ? c3__patc :
37 u3_none;
38 }
39
40 /* _http_vec_to_atom(): convert h2o_iovec_t to atom (cord)
41 */
42 static u3_noun
_http_vec_to_atom(h2o_iovec_t vec_u)43 _http_vec_to_atom(h2o_iovec_t vec_u)
44 {
45 return u3i_bytes(vec_u.len, (const c3_y*)vec_u.base);
46 }
47
48 /* _http_vec_to_octs(): convert h2o_iovec_t to (unit octs)
49 */
50 static u3_noun
_http_vec_to_octs(h2o_iovec_t vec_u)51 _http_vec_to_octs(h2o_iovec_t vec_u)
52 {
53 if ( 0 == vec_u.len ) {
54 return u3_nul;
55 }
56
57 // XX correct size_t -> atom?
58 return u3nt(u3_nul, u3i_chubs(1, (const c3_d*)&vec_u.len),
59 _http_vec_to_atom(vec_u));
60 }
61
62 /* _http_vec_from_octs(): convert (unit octs) to h2o_iovec_t
63 */
64 static h2o_iovec_t
_http_vec_from_octs(u3_noun oct)65 _http_vec_from_octs(u3_noun oct)
66 {
67 if ( u3_nul == oct ) {
68 return h2o_iovec_init(0, 0);
69 }
70
71 // 2GB max
72 if ( c3n == u3a_is_cat(u3h(u3t(oct))) ) {
73 u3m_bail(c3__fail);
74 }
75
76 c3_w len_w = u3h(u3t(oct));
77 c3_y* buf_y = c3_malloc(1 + len_w);
78 buf_y[len_w] = 0;
79
80 u3r_bytes(0, len_w, buf_y, u3t(u3t(oct)));
81
82 u3z(oct);
83 return h2o_iovec_init(buf_y, len_w);
84 }
85
86 /* _http_heds_to_noun(): convert h2o_header_t to (list (pair @t @t))
87 */
88 static u3_noun
_http_heds_to_noun(h2o_header_t * hed_u,c3_d hed_d)89 _http_heds_to_noun(h2o_header_t* hed_u, c3_d hed_d)
90 {
91 u3_noun hed = u3_nul;
92 c3_d dex_d = hed_d;
93
94 h2o_header_t deh_u;
95
96 while ( 0 < dex_d ) {
97 deh_u = hed_u[--dex_d];
98 hed = u3nc(u3nc(_http_vec_to_atom(*deh_u.name),
99 _http_vec_to_atom(deh_u.value)), hed);
100 }
101
102 return hed;
103 }
104
105 /* _http_heds_free(): free header linked list
106 */
107 static void
_http_heds_free(u3_hhed * hed_u)108 _http_heds_free(u3_hhed* hed_u)
109 {
110 while ( hed_u ) {
111 u3_hhed* nex_u = hed_u->nex_u;
112
113 free(hed_u->nam_c);
114 free(hed_u->val_c);
115 free(hed_u);
116 hed_u = nex_u;
117 }
118 }
119
120 /* _http_hed_new(): create u3_hhed from nam/val cords
121 */
122 static u3_hhed*
_http_hed_new(u3_atom nam,u3_atom val)123 _http_hed_new(u3_atom nam, u3_atom val)
124 {
125 c3_w nam_w = u3r_met(3, nam);
126 c3_w val_w = u3r_met(3, val);
127 u3_hhed* hed_u = c3_malloc(sizeof(*hed_u));
128
129 hed_u->nam_c = c3_malloc(1 + nam_w);
130 hed_u->val_c = c3_malloc(1 + val_w);
131 hed_u->nam_c[nam_w] = 0;
132 hed_u->val_c[val_w] = 0;
133 hed_u->nex_u = 0;
134 hed_u->nam_w = nam_w;
135 hed_u->val_w = val_w;
136
137 u3r_bytes(0, nam_w, (c3_y*)hed_u->nam_c, nam);
138 u3r_bytes(0, val_w, (c3_y*)hed_u->val_c, val);
139
140 return hed_u;
141 }
142
143 /* _http_heds_from_noun(): convert (list (pair @t @t)) to u3_hhed
144 */
145 static u3_hhed*
_http_heds_from_noun(u3_noun hed)146 _http_heds_from_noun(u3_noun hed)
147 {
148 u3_noun deh = hed;
149 u3_noun i_hed;
150
151 u3_hhed* hed_u = 0;
152
153 while ( u3_nul != hed ) {
154 i_hed = u3h(hed);
155 u3_hhed* nex_u = _http_hed_new(u3h(i_hed), u3t(i_hed));
156 nex_u->nex_u = hed_u;
157
158 hed_u = nex_u;
159 hed = u3t(hed);
160 }
161
162 u3z(deh);
163 return hed_u;
164 }
165
166 /* _http_req_find(): find http request in connection by sequence.
167 */
168 static u3_hreq*
_http_req_find(u3_hcon * hon_u,c3_w seq_l)169 _http_req_find(u3_hcon* hon_u, c3_w seq_l)
170 {
171 u3_hreq* req_u = hon_u->req_u;
172
173 // XX glories of linear search
174 //
175 while ( req_u ) {
176 if ( seq_l == req_u->seq_l ) {
177 return req_u;
178 }
179 req_u = req_u->nex_u;
180 }
181 return 0;
182 }
183
184 /* _http_req_link(): link http request to connection
185 */
186 static void
_http_req_link(u3_hcon * hon_u,u3_hreq * req_u)187 _http_req_link(u3_hcon* hon_u, u3_hreq* req_u)
188 {
189 req_u->hon_u = hon_u;
190 req_u->seq_l = hon_u->seq_l++;
191 req_u->nex_u = hon_u->req_u;
192 hon_u->req_u = req_u;
193 }
194
195 /* _http_req_unlink(): remove http request from connection
196 */
197 static void
_http_req_unlink(u3_hreq * req_u)198 _http_req_unlink(u3_hreq* req_u)
199 {
200 u3_hcon* hon_u = req_u->hon_u;
201
202 if ( hon_u->req_u == req_u ) {
203 hon_u->req_u = req_u->nex_u;
204 }
205 else {
206 u3_hreq* pre_u = hon_u->req_u;
207
208 // XX glories of linear search
209 //
210 while ( pre_u ) {
211 if ( pre_u->nex_u == req_u ) {
212 pre_u->nex_u = req_u->nex_u;
213 }
214 else pre_u = pre_u->nex_u;
215 }
216 }
217 }
218
219 /* _http_req_free(): free http request.
220 */
221 static void
_http_req_free(u3_hreq * req_u)222 _http_req_free(u3_hreq* req_u)
223 {
224 _http_req_unlink(req_u);
225 free(req_u);
226 }
227
228 /* _http_req_new(): receive http request.
229 */
230 static u3_hreq*
_http_req_new(u3_hcon * hon_u,h2o_req_t * rec_u)231 _http_req_new(u3_hcon* hon_u, h2o_req_t* rec_u)
232 {
233 u3_hreq* req_u = c3_malloc(sizeof(*req_u));
234 req_u->rec_u = rec_u;
235 req_u->sat_e = u3_rsat_init;
236 _http_req_link(hon_u, req_u);
237
238 return req_u;
239 }
240
241 /* _http_req_to_duct(): translate srv/con/req to duct
242 */
243 static u3_noun
_http_req_to_duct(u3_hreq * req_u)244 _http_req_to_duct(u3_hreq* req_u)
245 {
246 return u3nt(u3_blip, c3__http,
247 u3nq(u3dc("scot", c3_s2('u','v'), req_u->hon_u->htp_u->sev_l),
248 u3dc("scot", c3_s2('u','d'), req_u->hon_u->coq_l),
249 u3dc("scot", c3_s2('u','d'), req_u->seq_l),
250 u3_nul));
251 }
252
253 /* _http_req_kill(): kill http request in %eyre.
254 */
255 static void
_http_req_kill(u3_hreq * req_u)256 _http_req_kill(u3_hreq* req_u)
257 {
258 u3_noun pox = _http_req_to_duct(req_u);
259 u3v_plan(pox, u3nc(c3__thud, u3_nul));
260 }
261
262 /* _http_req_dispatch(): dispatch http request to %eyre
263 */
264 static void
_http_req_dispatch(u3_hreq * req_u,u3_noun req)265 _http_req_dispatch(u3_hreq* req_u, u3_noun req)
266 {
267 c3_assert(u3_rsat_init == req_u->sat_e);
268 req_u->sat_e = u3_rsat_plan;
269
270 u3_noun pox = _http_req_to_duct(req_u);
271 u3_noun typ = _(req_u->hon_u->htp_u->lop) ? c3__chis : c3__this;
272
273 u3v_plan(pox, u3nq(typ,
274 req_u->hon_u->htp_u->sec,
275 u3nc(c3y, u3i_words(1, &req_u->hon_u->ipf_w)),
276 req));
277 }
278
279 typedef struct _u3_hgen {
280 h2o_generator_t neg_u;
281 h2o_iovec_t bod_u;
282 u3_hreq* req_u;
283 u3_hhed* hed_u;
284 } u3_hgen;
285
286 /* _http_hgen_dispose(): dispose response generator and buffers
287 */
288 static void
_http_hgen_dispose(void * ptr_v)289 _http_hgen_dispose(void* ptr_v)
290 {
291 u3_hgen* gen_u = (u3_hgen*)ptr_v;
292 _http_req_free(gen_u->req_u);
293 _http_heds_free(gen_u->hed_u);
294 free(gen_u->bod_u.base);
295 }
296
297 /* _http_req_respond(): write httr to h2o_req_t->res and send
298 */
299 static void
_http_req_respond(u3_hreq * req_u,u3_noun sas,u3_noun hed,u3_noun bod)300 _http_req_respond(u3_hreq* req_u, u3_noun sas, u3_noun hed, u3_noun bod)
301 {
302 // XX ideally
303 //c3_assert(u3_rsat_plan == req_u->sat_e);
304
305 if ( u3_rsat_plan != req_u->sat_e ) {
306 //uL(fprintf(uH, "duplicate response\n"));
307 return;
308 }
309
310 req_u->sat_e = u3_rsat_ripe;
311
312 h2o_req_t* rec_u = req_u->rec_u;
313
314 rec_u->res.status = sas;
315 rec_u->res.reason = (sas < 200) ? "weird" :
316 (sas < 300) ? "ok" :
317 (sas < 400) ? "moved" :
318 (sas < 500) ? "missing" :
319 "hosed";
320
321 u3_hhed* hed_u = _http_heds_from_noun(u3k(hed));
322
323 u3_hgen* gen_u = h2o_mem_alloc_shared(&rec_u->pool, sizeof(*gen_u),
324 _http_hgen_dispose);
325 gen_u->neg_u = (h2o_generator_t){0, 0};
326 gen_u->req_u = req_u;
327 gen_u->hed_u = hed_u;
328
329 while ( 0 != hed_u ) {
330 h2o_add_header_by_str(&rec_u->pool, &rec_u->res.headers,
331 hed_u->nam_c, hed_u->nam_w, 0, 0,
332 hed_u->val_c, hed_u->val_w);
333 hed_u = hed_u->nex_u;
334 }
335
336 gen_u->bod_u = _http_vec_from_octs(u3k(bod));
337 rec_u->res.content_length = gen_u->bod_u.len;
338
339 h2o_start_response(rec_u, &gen_u->neg_u);
340 h2o_send(rec_u, &gen_u->bod_u, 1, H2O_SEND_STATE_FINAL);
341
342
343 u3z(sas); u3z(hed); u3z(bod);
344 }
345
346 /* _http_rec_to_httq(): convert h2o_req_t to httq
347 */
348 static u3_weak
_http_rec_to_httq(h2o_req_t * rec_u)349 _http_rec_to_httq(h2o_req_t* rec_u)
350 {
351 u3_noun med = _http_vec_to_meth(rec_u->method);
352
353 if ( u3_none == med ) {
354 return u3_none;
355 }
356
357 u3_noun url = _http_vec_to_atom(rec_u->path);
358 u3_noun hed = _http_heds_to_noun(rec_u->headers.entries,
359 rec_u->headers.size);
360
361 // restore host header
362 hed = u3nc(u3nc(u3i_string("host"),
363 _http_vec_to_atom(rec_u->authority)),
364 hed);
365
366 u3_noun bod = _http_vec_to_octs(rec_u->entity);
367
368 return u3nq(med, url, hed, bod);
369 }
370
371 /* _http_rec_fail(): fail on bad h2o_req_t
372 */
373 static void
_http_rec_fail(h2o_req_t * rec_u,c3_i sas_i,c3_c * sas_c)374 _http_rec_fail(h2o_req_t* rec_u, c3_i sas_i, c3_c* sas_c)
375 {
376 static h2o_generator_t gen_u = {0, 0};
377 rec_u->res.status = sas_i;
378 rec_u->res.reason = sas_c;
379 h2o_start_response(rec_u, &gen_u);
380 h2o_send(rec_u, 0, 0, H2O_SEND_STATE_FINAL);
381 }
382
383 struct h2o_con_wrap { // see private st_h2o_http1_conn_t
384 h2o_conn_t con_u; // connection
385 struct { // see private st_h2o_uv_socket_t
386 h2o_socket_t sok_u; // socket
387 uv_stream_t* han_u; // client stream handler (u3_hcon)
388 } *suv_u;
389 };
390
391 /* _http_rec_accept(); handle incoming http request from h2o.
392 */
393 static c3_i
_http_rec_accept(h2o_handler_t * han_u,h2o_req_t * rec_u)394 _http_rec_accept(h2o_handler_t* han_u, h2o_req_t* rec_u)
395 {
396 u3_weak req = _http_rec_to_httq(rec_u);
397
398 if ( u3_none == req ) {
399 if ( (u3C.wag_w & u3o_verbose) ) {
400 uL(fprintf(uH, "strange %.*s request\n", (int)rec_u->method.len,
401 rec_u->method.base));
402 }
403 _http_rec_fail(rec_u, 400, "bad request");
404 }
405 else {
406 // XX HTTP2 wat do?
407 struct h2o_con_wrap* noc_u = (struct h2o_con_wrap*)rec_u->conn;
408 u3_hcon* hon_u = (u3_hcon*)noc_u->suv_u->han_u;
409
410 // sanity check
411 c3_assert(hon_u->sok_u == &noc_u->suv_u->sok_u);
412
413 u3_hreq* req_u = _http_req_new(hon_u, rec_u);
414 _http_req_dispatch(req_u, req);
415 }
416
417 return 0;
418 }
419
420 /* _http_conn_find(): find http connection in server by sequence.
421 */
422 static u3_hcon*
_http_conn_find(u3_http * htp_u,c3_w coq_l)423 _http_conn_find(u3_http *htp_u, c3_w coq_l)
424 {
425 u3_hcon* hon_u = htp_u->hon_u;
426
427 // XX glories of linear search
428 //
429 while ( hon_u ) {
430 if ( coq_l == hon_u->coq_l ) {
431 return hon_u;
432 }
433 hon_u = hon_u->nex_u;
434 }
435 return 0;
436 }
437
438 /* _http_conn_link(): link http request to connection
439 */
440 static void
_http_conn_link(u3_http * htp_u,u3_hcon * hon_u)441 _http_conn_link(u3_http* htp_u, u3_hcon* hon_u)
442 {
443 hon_u->htp_u = htp_u;
444 hon_u->coq_l = htp_u->coq_l++;
445 hon_u->nex_u = htp_u->hon_u;
446 htp_u->hon_u = hon_u;
447 }
448
449 /* _http_conn_unlink(): remove http request from connection
450 */
451 static void
_http_conn_unlink(u3_hcon * hon_u)452 _http_conn_unlink(u3_hcon* hon_u)
453 {
454 u3_http* htp_u = hon_u->htp_u;
455
456 if ( htp_u->hon_u == hon_u ) {
457 htp_u->hon_u = hon_u->nex_u;
458 }
459 else {
460 u3_hcon *pre_u = htp_u->hon_u;
461
462 // XX glories of linear search
463 //
464 while ( pre_u ) {
465 if ( pre_u->nex_u == hon_u ) {
466 pre_u->nex_u = hon_u->nex_u;
467 }
468 else pre_u = pre_u->nex_u;
469 }
470 }
471 }
472
473 /* _http_conn_free_early(): free http connection on failure.
474 */
475 static void
_http_conn_free_early(uv_handle_t * han_t)476 _http_conn_free_early(uv_handle_t* han_t)
477 {
478 u3_hcon* hon_u = (u3_hcon*)han_t;
479 free(hon_u);
480 }
481
482 /* _http_conn_free(): free http connection on close.
483 */
484 static void
_http_conn_free(uv_handle_t * han_t)485 _http_conn_free(uv_handle_t* han_t)
486 {
487 u3_hcon* hon_u = (u3_hcon*)han_t;
488
489 while ( 0 != hon_u->req_u ) {
490 u3_hreq* req_u = hon_u->req_u;
491 u3_hreq* nex_u = req_u->nex_u;
492
493 _http_req_kill(req_u);
494 _http_req_free(req_u);
495 hon_u->req_u = nex_u;
496 }
497
498 _http_conn_unlink(hon_u);
499 free(hon_u);
500 }
501
502 /* _http_conn_new(): create and accept http connection.
503 */
504 static void
_http_conn_new(u3_http * htp_u)505 _http_conn_new(u3_http* htp_u)
506 {
507 // TODO where?
508 // u3_lo_open();
509
510 u3_hcon* hon_u = c3_malloc(sizeof(*hon_u));
511 hon_u->seq_l = 1;
512 hon_u->req_u = 0;
513
514 uv_tcp_init(u3L, &hon_u->wax_u);
515
516 c3_i sas_i;
517
518 if ( 0 != (sas_i = uv_accept((uv_stream_t*)&htp_u->wax_u,
519 (uv_stream_t*)&hon_u->wax_u)) ) {
520 if ( (u3C.wag_w & u3o_verbose) ) {
521 uL(fprintf(uH, "http: accept: %s\n", uv_strerror(sas_i)));
522 }
523
524 uv_close((uv_handle_t*)&hon_u->wax_u,
525 (uv_close_cb)_http_conn_free_early);
526 return;
527 }
528
529 _http_conn_link(htp_u, hon_u);
530
531 hon_u->sok_u = h2o_uv_socket_create((uv_stream_t*)&hon_u->wax_u,
532 (uv_close_cb)_http_conn_free);
533 h2o_accept(htp_u->cep_u, hon_u->sok_u);
534
535 // capture h2o connection (XX fragile)
536 hon_u->con_u = (h2o_conn_t*)hon_u->sok_u->data;
537
538 struct sockaddr_in adr_u;
539 h2o_socket_getpeername(hon_u->sok_u, (struct sockaddr*)&adr_u);
540 hon_u->ipf_w = ( adr_u.sin_family != AF_INET ) ?
541 0 : ntohl(adr_u.sin_addr.s_addr);
542
543 // TODO where?
544 // u3_lo_shut(c3y);
545 }
546
547 /* _http_serv_find(): find http server by sequence.
548 */
549 static u3_http*
_http_serv_find(c3_l sev_l)550 _http_serv_find(c3_l sev_l)
551 {
552 u3_http* htp_u = u3_Host.htp_u;
553
554 // XX glories of linear search
555 //
556 while ( htp_u ) {
557 if ( sev_l == htp_u->sev_l ) {
558 return htp_u;
559 }
560 htp_u = htp_u->nex_u;
561 }
562 return 0;
563 }
564
565 // XX serv link/unlink/free/new
566
567 /* _http_serv_listen_cb(): uv_connection_cb for uv_listen
568 */
569 static void
_http_serv_listen_cb(uv_stream_t * str_u,c3_i sas_i)570 _http_serv_listen_cb(uv_stream_t* str_u, c3_i sas_i)
571 {
572 u3_http* htp_u = (u3_http*)str_u;
573
574 if ( 0 != sas_i ) {
575 uL(fprintf(uH, "http: listen_cb: %s\n", uv_strerror(sas_i)));
576 }
577 else {
578 _http_conn_new(htp_u);
579 }
580 }
581
582 /* _http_serv_init_h2o(): initialize h2o ctx and handlers for server.
583 */
584 static void
_http_serv_init_h2o(u3_http * htp_u)585 _http_serv_init_h2o(u3_http* htp_u)
586 {
587 htp_u->fig_u = c3_calloc(sizeof(*htp_u->fig_u));
588 h2o_config_init(htp_u->fig_u);
589 htp_u->fig_u->server_name = h2o_iovec_init(
590 H2O_STRLIT("urbit/vere-" URBIT_VERSION));
591
592 // XX use u3_Host.ops_u.nam_c? Or ship.urbit.org? Multiple hosts?
593 // see https://github.com/urbit/urbit/issues/914
594 htp_u->hos_u = h2o_config_register_host(htp_u->fig_u,
595 h2o_iovec_init(H2O_STRLIT("default")),
596 htp_u->por_w);
597
598 htp_u->ctx_u = c3_calloc(sizeof(*htp_u->ctx_u));
599 htp_u->cep_u = c3_calloc(sizeof(*htp_u->cep_u));
600 htp_u->cep_u->ctx = (h2o_context_t*)htp_u->ctx_u;
601 htp_u->cep_u->hosts = htp_u->fig_u->hosts;
602
603 if ( c3y == htp_u->sec ) {
604 htp_u->cep_u->ssl_ctx = u3_Host.tls_u;
605 }
606
607 htp_u->han_u = h2o_create_handler(&htp_u->hos_u->fallback_path,
608 sizeof(*htp_u->han_u));
609 htp_u->han_u->on_req = _http_rec_accept;
610
611 h2o_context_init(htp_u->ctx_u, u3L, htp_u->fig_u);
612 }
613
614 /* _http_serv_start(): start http server.
615 */
616 static void
_http_serv_start(u3_http * htp_u)617 _http_serv_start(u3_http* htp_u)
618 {
619 struct sockaddr_in adr_u;
620 memset(&adr_u, 0, sizeof(adr_u));
621 adr_u.sin_family = AF_INET;
622
623 if ( c3y == htp_u->lop ) {
624 inet_pton(AF_INET, "127.0.0.1", &adr_u.sin_addr);
625 }
626 else {
627 adr_u.sin_addr.s_addr = INADDR_ANY;
628 }
629
630 if ( c3y == htp_u->sec && 0 == u3_Host.tls_u ) {
631 uL(fprintf(uH, "http: secure server not started: .urb/tls/ not found\n"));
632 htp_u->por_w = 0;
633 return;
634 }
635
636 uv_tcp_init(u3L, &htp_u->wax_u);
637
638 /* Try ascending ports.
639 */
640 while ( 1 ) {
641 c3_i sas_i;
642
643 adr_u.sin_port = htons(htp_u->por_w);
644 sas_i = uv_tcp_bind(&htp_u->wax_u, (const struct sockaddr*)&adr_u, 0);
645
646 if ( 0 != sas_i ||
647 0 != (sas_i = uv_listen((uv_stream_t*)&htp_u->wax_u,
648 TCP_BACKLOG, _http_serv_listen_cb)) ) {
649 if ( UV_EADDRINUSE == sas_i ) {
650 htp_u->por_w++;
651 continue;
652 }
653
654 uL(fprintf(uH, "http: listen: %s\n", uv_strerror(sas_i)));
655 htp_u->por_w = 0;
656 return;
657 }
658
659 _http_serv_init_h2o(htp_u);
660
661 uL(fprintf(uH, "http: live (%s, %s) on %d\n",
662 (c3y == htp_u->sec) ? "secure" : "insecure",
663 (c3y == htp_u->lop) ? "loopback" : "public",
664 htp_u->por_w));
665 break;
666 }
667 }
668
669 /* _http_init_tls: initialize OpenSSL context
670 */
671 static SSL_CTX*
_http_init_tls()672 _http_init_tls()
673 {
674 // XX require 1.1.0 and use TLS_server_method()
675 SSL_CTX* tls_u = SSL_CTX_new(SSLv23_server_method());
676 // XX use SSL_CTX_set_max_proto_version() and SSL_CTX_set_min_proto_version()
677 SSL_CTX_set_options(tls_u, SSL_OP_NO_SSLv2 |
678 SSL_OP_NO_SSLv3 |
679 // SSL_OP_NO_TLSv1 | // XX test
680 SSL_OP_NO_COMPRESSION);
681
682 SSL_CTX_set_default_verify_paths(tls_u);
683 SSL_CTX_set_session_cache_mode(tls_u, SSL_SESS_CACHE_OFF);
684 SSL_CTX_set_cipher_list(tls_u,
685 "ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:"
686 "ECDH+AES128:DH+AES:ECDH+3DES:DH+3DES:RSA+AESGCM:"
687 "RSA+AES:RSA+3DES:!aNULL:!MD5:!DSS");
688
689 c3_c pub_c[2048];
690 c3_c pir_c[2048];
691 c3_i ret_i;
692
693 ret_i = snprintf(pub_c, 2048, "%s/.urb/tls/certificate.pem", u3_Host.dir_c);
694 c3_assert(ret_i < 2048);
695 ret_i = snprintf(pir_c, 2048, "%s/.urb/tls/private.pem", u3_Host.dir_c);
696 c3_assert(ret_i < 2048);
697
698 // TODO: SSL_CTX_use_certificate_chain_file ?
699 if (SSL_CTX_use_certificate_file(tls_u, pub_c, SSL_FILETYPE_PEM) <= 0) {
700 uL(fprintf(uH, "https: failed to load certificate\n"));
701 // c3_assert(0);
702 return 0;
703 }
704
705 if (SSL_CTX_use_PrivateKey_file(tls_u, pir_c, SSL_FILETYPE_PEM) <= 0 ) {
706 uL(fprintf(uH, "https: failed to load private key\n"));
707 // c3_assert(0);
708 return 0;
709 }
710
711 return tls_u;
712 }
713
714 /* _http_write_ports_file(): update .http.ports
715 */
716 static void
_http_write_ports_file(c3_c * pax_c)717 _http_write_ports_file(c3_c *pax_c)
718 {
719 c3_i pal_i;
720 c3_c *paf_c;
721 c3_i por_i;
722 u3_http *htp_u;
723
724 pal_i = strlen(pax_c) + 13; /* includes NUL */
725 paf_c = u3a_malloc(pal_i);
726 snprintf(paf_c, pal_i, "%s/%s", pax_c, ".http.ports");
727
728 por_i = open(paf_c, O_WRONLY | O_CREAT | O_TRUNC, 0666);
729 u3a_free(paf_c);
730
731 for ( htp_u = u3_Host.htp_u; htp_u; htp_u = htp_u->nex_u ) {
732 if ( 0 < htp_u->por_w ) {
733 dprintf(por_i, "%u %s %s\n", htp_u->por_w,
734 (c3y == htp_u->sec) ? "secure" : "insecure",
735 (c3y == htp_u->lop) ? "loopback" : "public");
736 }
737 }
738
739 c3_sync(por_i);
740 close(por_i);
741 }
742
743 /* _http_release_ports_file(): remove .http.ports
744 */
745 static void
_http_release_ports_file(c3_c * pax_c)746 _http_release_ports_file(c3_c *pax_c)
747 {
748 c3_i pal_i;
749 c3_c *paf_c;
750
751 pal_i = strlen(pax_c) + 13; /* includes NUL */
752 paf_c = u3a_malloc(pal_i);
753 snprintf(paf_c, pal_i, "%s/%s", pax_c, ".http.ports");
754
755 unlink(paf_c);
756 u3a_free(paf_c);
757 }
758
759 /* u3_http_ef_bake(): notify %eyre that we're live
760 */
761 void
u3_http_ef_bake(void)762 u3_http_ef_bake(void)
763 {
764 u3_noun pax = u3nq(u3_blip, c3__http, u3k(u3A->sen), u3_nul);
765
766 u3v_plan(pax, u3nc(c3__born, u3_nul));
767 }
768
769 /* u3_http_ef_thou(): send %thou from %eyre as http response.
770 */
771 void
u3_http_ef_thou(c3_l sev_l,c3_l coq_l,c3_l seq_l,u3_noun rep)772 u3_http_ef_thou(c3_l sev_l,
773 c3_l coq_l,
774 c3_l seq_l,
775 u3_noun rep)
776 {
777 u3_http* htp_u;
778 u3_hcon* hon_u;
779 u3_hreq* req_u;
780 c3_w bug_w = u3C.wag_w & u3o_verbose;
781
782 if ( !(htp_u = _http_serv_find(sev_l)) ) {
783 if ( bug_w ) {
784 uL(fprintf(uH, "http: server not found: %x\r\n", sev_l));
785 }
786 }
787 else if ( !(hon_u = _http_conn_find(htp_u, coq_l)) ) {
788 if ( bug_w ) {
789 uL(fprintf(uH, "http: connection not found: %x/%d\r\n", sev_l, coq_l));
790 }
791 }
792 else if ( !(req_u = _http_req_find(hon_u, seq_l)) ) {
793 if ( bug_w ) {
794 uL(fprintf(uH, "http: request not found: %x/%d/%d\r\n",
795 sev_l, coq_l, seq_l));
796 }
797 }
798 else {
799 u3_noun p_rep, q_rep, r_rep;
800
801 if ( c3n == u3r_trel(rep, &p_rep, &q_rep, &r_rep) ) {
802 uL(fprintf(uH, "http: strange response\n"));
803 }
804 else {
805 _http_req_respond(req_u, u3k(p_rep), u3k(q_rep), u3k(r_rep));
806 }
807 }
808
809 u3z(rep);
810 }
811
812 /* u3_http_io_init(): initialize http I/O.
813 */
814 void
u3_http_io_init()815 u3_http_io_init()
816 {
817 // Lens port
818 {
819 u3_http *htp_u = c3_malloc(sizeof(*htp_u));
820
821 htp_u->sev_l = u3A->sev_l + 2;
822 htp_u->coq_l = 1;
823 htp_u->por_w = 12321;
824 htp_u->sec = c3n;
825 htp_u->lop = c3y;
826
827 htp_u->cep_u = 0;
828 htp_u->hos_u = 0;
829 htp_u->hon_u = 0;
830 htp_u->nex_u = 0;
831
832 htp_u->nex_u = u3_Host.htp_u;
833 u3_Host.htp_u = htp_u;
834 }
835
836 // Secure port.
837 {
838 u3_http *htp_u = c3_malloc(sizeof(*htp_u));
839
840 htp_u->sev_l = u3A->sev_l + 1;
841 htp_u->coq_l = 1;
842 htp_u->por_w = 8443;
843 htp_u->sec = c3y;
844 htp_u->lop = c3n;
845
846 htp_u->cep_u = 0;
847 htp_u->hos_u = 0;
848 htp_u->hon_u = 0;
849 htp_u->nex_u = 0;
850
851 htp_u->nex_u = u3_Host.htp_u;
852 u3_Host.htp_u = htp_u;
853 }
854
855 // Insecure port.
856 {
857 u3_http* htp_u = c3_malloc(sizeof(*htp_u));
858
859 htp_u->sev_l = u3A->sev_l;
860 htp_u->coq_l = 1;
861 htp_u->por_w = 8080;
862 htp_u->sec = c3n;
863 htp_u->lop = c3n;
864
865 htp_u->cep_u = 0;
866 htp_u->hos_u = 0;
867 htp_u->hon_u = 0;
868 htp_u->nex_u = 0;
869
870 htp_u->nex_u = u3_Host.htp_u;
871 u3_Host.htp_u = htp_u;
872 }
873
874 u3_Host.tls_u = _http_init_tls();
875 }
876
877 /* u3_http_io_talk(): start http I/O.
878 */
879 void
u3_http_io_talk()880 u3_http_io_talk()
881 {
882 u3_http* htp_u;
883
884 for ( htp_u = u3_Host.htp_u; htp_u; htp_u = htp_u->nex_u ) {
885 _http_serv_start(htp_u);
886 }
887
888 _http_write_ports_file(u3_Host.dir_c);
889 }
890
891 /* u3_http_io_poll(): poll kernel for http I/O.
892 */
893 void
u3_http_io_poll(void)894 u3_http_io_poll(void)
895 {
896 }
897
898 /* u3_http_io_exit(): shut down http.
899 */
900 void
u3_http_io_exit(void)901 u3_http_io_exit(void)
902 {
903 // XX shutdown servers cleanly
904 _http_release_ports_file(u3_Host.dir_c);
905 }
906