291f0d9920d3bf4698aeaf5c6cddce572f92ca0b
[pazpar2-moved-to-github.git] / src / http.c
1 /*
2  * $Id: http.c,v 1.10 2007-02-05 16:15:41 quinn Exp $
3  */
4
5 #include <stdio.h>
6 #include <sys/socket.h>
7 #include <sys/types.h>
8 #include <sys/uio.h>
9 #include <unistd.h>
10 #include <stdlib.h>
11 #include <strings.h>
12 #include <ctype.h>
13 #include <fcntl.h>
14 #include <netdb.h>
15 #include <errno.h>
16 #include <assert.h>
17
18 #if HAVE_CONFIG_H
19 #include <cconfig.h>
20 #endif
21
22 #include <netinet/in.h>
23
24 #include <yaz/yaz-util.h>
25 #include <yaz/comstack.h>
26 #include <netdb.h>
27
28 #include "util.h"
29 #include "eventl.h"
30 #include "pazpar2.h"
31 #include "http.h"
32 #include "http_command.h"
33
34 static void proxy_io(IOCHAN i, int event);
35 static struct http_channel *http_create(void);
36 static void http_destroy(IOCHAN i);
37
38 extern IOCHAN channel_list;
39
40 static struct sockaddr_in *proxy_addr = 0; // If this is set, we proxy normal HTTP requests
41 static char proxy_url[256] = "";
42 static char myurl[256] = "";
43 static struct http_buf *http_buf_freelist = 0;
44 static struct http_channel *http_channel_freelist = 0;
45
46 static struct http_buf *http_buf_create()
47 {
48     struct http_buf *r;
49
50     if (http_buf_freelist)
51     {
52         r = http_buf_freelist;
53         http_buf_freelist = http_buf_freelist->next;
54     }
55     else
56         r = xmalloc(sizeof(struct http_buf));
57     r->offset = 0;
58     r->len = 0;
59     r->next = 0;
60     return r;
61 }
62
63 static void http_buf_destroy(struct http_buf *b)
64 {
65     b->next = http_buf_freelist;
66     http_buf_freelist = b;
67 }
68
69 static void http_buf_destroy_queue(struct http_buf *b)
70 {
71     struct http_buf *p;
72     while (b)
73     {
74         p = b->next;
75         http_buf_destroy(b);
76         b = p;
77     }
78 }
79
80 #ifdef GAGA
81 // Calculate length of chain
82 static int http_buf_len(struct http_buf *b)
83 {
84     int sum = 0;
85     for (; b; b = b->next)
86         sum += b->len;
87     return sum;
88 }
89 #endif
90
91 static struct http_buf *http_buf_bybuf(char *b, int len)
92 {
93     struct http_buf *res = 0;
94     struct http_buf **p = &res;
95
96     while (len)
97     {
98         int tocopy = len;
99         if (tocopy > HTTP_BUF_SIZE)
100             tocopy = HTTP_BUF_SIZE;
101         *p = http_buf_create();
102         memcpy((*p)->buf, b, tocopy);
103         (*p)->len = tocopy;
104         len -= tocopy;
105         b += tocopy;
106         p = &(*p)->next;
107     }
108     return res;
109 }
110
111 // Add a (chain of) buffers to the end of an existing queue.
112 static void http_buf_enqueue(struct http_buf **queue, struct http_buf *b)
113 {
114     while (*queue)
115         queue = &(*queue)->next;
116     *queue = b;
117 }
118
119 static struct http_buf *http_buf_bywrbuf(WRBUF wrbuf)
120 {
121     // Heavens to Betsy (buf)!
122     return http_buf_bybuf(wrbuf_buf(wrbuf), wrbuf_len(wrbuf));
123 }
124
125 // Non-destructively collapse chain of buffers into a string (max *len)
126 // Return
127 static int http_buf_peek(struct http_buf *b, char *buf, int len)
128 {
129     int rd = 0;
130     while (b && rd < len)
131     {
132         int toread = len - rd;
133         if (toread > b->len)
134             toread = b->len;
135         memcpy(buf + rd, b->buf + b->offset, toread);
136         rd += toread;
137         b = b->next;
138     }
139     buf[rd] = '\0';
140     return rd;
141 }
142
143 // Ddestructively munch up to len  from head of queue.
144 static int http_buf_read(struct http_buf **b, char *buf, int len)
145 {
146     int rd = 0;
147     while ((*b) && rd < len)
148     {
149         int toread = len - rd;
150         if (toread > (*b)->len)
151             toread = (*b)->len;
152         memcpy(buf + rd, (*b)->buf + (*b)->offset, toread);
153         rd += toread;
154         if (toread < (*b)->len)
155         {
156             (*b)->len -= toread;
157             (*b)->offset += toread;
158             break;
159         }
160         else
161         {
162             struct http_buf *n = (*b)->next;
163             http_buf_destroy(*b);
164             *b = n;
165         }
166     }
167     buf[rd] = '\0';
168     return rd;
169 }
170
171 void static urldecode(char *i, char *o)
172 {
173     while (*i)
174     {
175         if (*i == '+')
176         {
177             *(o++) = ' ';
178             i++;
179         }
180         else if (*i == '%')
181         {
182             i++;
183             sscanf(i, "%2hhx", o);
184             i += 2;
185             o++;
186         }
187         else
188             *(o++) = *(i++);
189     }
190     *o = '\0';
191 }
192
193 void http_addheader(struct http_response *r, const char *name, const char *value)
194 {
195     struct http_channel *c = r->channel;
196     struct http_header *h = nmem_malloc(c->nmem, sizeof *h);
197     h->name = nmem_strdup(c->nmem, name);
198     h->value = nmem_strdup(c->nmem, value);
199     h->next = r->headers;
200     r->headers = h;
201 }
202
203 char *http_argbyname(struct http_request *r, char *name)
204 {
205     struct http_argument *p;
206     if (!name)
207         return 0;
208     for (p = r->arguments; p; p = p->next)
209         if (!strcmp(p->name, name))
210             return p->value;
211     return 0;
212 }
213
214 char *http_headerbyname(struct http_header *h, char *name)
215 {
216     for (; h; h = h->next)
217         if (!strcmp(h->name, name))
218             return h->value;
219     return 0;
220 }
221
222 struct http_response *http_create_response(struct http_channel *c)
223 {
224     struct http_response *r = nmem_malloc(c->nmem, sizeof(*r));
225     strcpy(r->code, "200");
226     r->msg = "OK";
227     r->channel = c;
228     r->headers = 0;
229     r->payload = 0;
230     return r;
231 }
232
233 // Check if buf contains a package (minus payload)
234 static int package_check(const char *buf)
235 {
236     int len = 0;
237     while (*buf) // Check if we have a sequence of lines terminated by an empty line
238     {
239         char *b = strstr(buf, "\r\n");
240
241         if (!b)
242             return 0;
243
244         len += (b - buf) + 2;
245         if (b == buf)
246             return len;
247         buf = b + 2;
248     }
249     return 0;
250 }
251
252 // Check if we have a request. Return 0 or length
253 // (including trailing CRNL) FIXME: Does not deal gracefully with requests
254 // carrying payload but this is kind of OK since we will reject anything
255 // other than an empty GET
256 static int request_check(struct http_buf *queue)
257 {
258     char tmp[4096];
259
260     http_buf_peek(queue, tmp, 4096);
261     return package_check(tmp);
262 }
263
264 struct http_response *http_parse_response_buf(struct http_channel *c, const char *buf, int len)
265 {
266     char tmp[4096];
267     struct http_response *r = http_create_response(c);
268     char *p, *p2;
269     struct http_header **hp = &r->headers;
270
271     if (len >= 4096)
272         return 0;
273     memcpy(tmp, buf, len);
274     for (p = tmp; *p && *p != ' '; p++) // Skip HTTP version
275         ;
276     p++;
277     // Response code
278     for (p2 = p; *p2 && *p2 != ' ' && p2 - p < 3; p2++)
279         r->code[p2 - p] = *p2;
280     if (!(p = strstr(tmp, "\r\n")))
281         return 0;
282     p += 2;
283     while (*p)
284     {
285         if (!(p2 = strstr(p, "\r\n")))
286             return 0;
287         if (p == p2) // End of headers
288             break;
289         else
290         {
291             struct http_header *h = *hp = nmem_malloc(c->nmem, sizeof(*h));
292             char *value = strchr(p, ':');
293             if (!value)
294                 return 0;
295             *(value++) = '\0';
296             h->name = nmem_strdup(c->nmem, p);
297             while (isspace(*value))
298                 value++;
299             if (value >= p2)  // Empty header;
300             {
301                 h->value = "";
302                 p = p2 + 2;
303                 continue;
304             }
305             *p2 = '\0';
306             h->value = nmem_strdup(c->nmem, value);
307             h->next = 0;
308             hp = &h->next;
309             p = p2 + 2;
310         }
311     }
312     return r;
313 }
314
315 struct http_request *http_parse_request(struct http_channel *c, struct http_buf **queue,
316         int len)
317 {
318     struct http_request *r = nmem_malloc(c->nmem, sizeof(*r));
319     char *p, *p2;
320     char tmp[4096];
321     char *buf = tmp;
322
323     if (len > 4096)
324         return 0;
325     if (http_buf_read(queue, buf, len) < len)
326         return 0;
327
328     r->search = "";
329     r->channel = c;
330     r->arguments = 0;
331     r->headers = 0;
332     // Parse first line
333     for (p = buf, p2 = r->method; *p && *p != ' ' && p - buf < 19; p++)
334         *(p2++) = *p;
335     if (*p != ' ')
336     {
337         yaz_log(YLOG_WARN, "Unexpected HTTP method in request");
338         return 0;
339     }
340     *p2 = '\0';
341
342     if (!(buf = strchr(buf, ' ')))
343     {
344         yaz_log(YLOG_WARN, "Syntax error in request (1)");
345         return 0;
346     }
347     buf++;
348     if (!(p = strchr(buf, ' ')))
349     {
350         yaz_log(YLOG_WARN, "Syntax error in request (2)");
351         return 0;
352     }
353     *(p++) = '\0';
354     if ((p2 = strchr(buf, '?'))) // Do we have arguments?
355         *(p2++) = '\0';
356     r->path = nmem_strdup(c->nmem, buf);
357     if (p2)
358     {
359         r->search = nmem_strdup(c->nmem, p2);
360         // Parse Arguments
361         while (*p2)
362         {
363             struct http_argument *a;
364             char *equal = strchr(p2, '=');
365             char *eoa = strchr(p2, '&');
366             if (!equal)
367             {
368                 yaz_log(YLOG_WARN, "Expected '=' in argument");
369                 return 0;
370             }
371             if (!eoa)
372                 eoa = equal + strlen(equal); // last argument
373             else
374                 *(eoa++) = '\0';
375             a = nmem_malloc(c->nmem, sizeof(struct http_argument));
376             *(equal++) = '\0';
377             a->name = nmem_strdup(c->nmem, p2);
378             urldecode(equal, equal);
379             a->value = nmem_strdup(c->nmem, equal);
380             a->next = r->arguments;
381             r->arguments = a;
382             p2 = eoa;
383         }
384     }
385     buf = p;
386
387     if (strncmp(buf, "HTTP/", 5))
388         strcpy(r->http_version, "1.0");
389     else
390     {
391         buf += 5;
392         if (!(p = strstr(buf, "\r\n")))
393             return 0;
394         *(p++) = '\0';
395         p++;
396         strcpy(r->http_version, buf);
397         buf = p;
398     }
399     strcpy(c->version, r->http_version);
400
401     r->headers = 0;
402     while (*buf)
403     {
404         if (!(p = strstr(buf, "\r\n")))
405             return 0;
406         if (p == buf)
407             break;
408         else
409         {
410             struct http_header *h = nmem_malloc(c->nmem, sizeof(*h));
411             if (!(p2 = strchr(buf, ':')))
412                 return 0;
413             *(p2++) = '\0';
414             h->name = nmem_strdup(c->nmem, buf);
415             while (isspace(*p2))
416                 p2++;
417             if (p2 >= p) // Empty header?
418             {
419                 buf = p + 2;
420                 continue;
421             }
422             *p = '\0';
423             h->value = nmem_strdup(c->nmem, p2);
424             h->next = r->headers;
425             r->headers = h;
426             buf = p + 2;
427         }
428     }
429
430     return r;
431 }
432
433 static struct http_buf *http_serialize_response(struct http_channel *c,
434         struct http_response *r)
435 {
436     struct http_header *h;
437
438     wrbuf_rewind(c->wrbuf);
439     wrbuf_printf(c->wrbuf, "HTTP/1.1 %s %s\r\n", r->code, r->msg);
440     for (h = r->headers; h; h = h->next)
441         wrbuf_printf(c->wrbuf, "%s: %s\r\n", h->name, h->value);
442     if (r->payload)
443     {
444         wrbuf_printf(c->wrbuf, "Content-length: %d\r\n", r->payload ?
445                 (int) strlen(r->payload) : 0);
446         wrbuf_printf(c->wrbuf, "Content-type: text/xml\r\n");
447     }
448     wrbuf_puts(c->wrbuf, "\r\n");
449
450     if (r->payload)
451         wrbuf_puts(c->wrbuf, r->payload);
452
453     return http_buf_bywrbuf(c->wrbuf);
454 }
455
456 // Serialize a HTTP request
457 static struct http_buf *http_serialize_request(struct http_request *r)
458 {
459     struct http_channel *c = r->channel;
460     struct http_header *h;
461     struct http_argument *a;
462
463     wrbuf_rewind(c->wrbuf);
464     wrbuf_printf(c->wrbuf, "%s %s", r->method, r->path);
465
466     if (r->arguments)
467     {
468         wrbuf_putc(c->wrbuf, '?');
469         for (a = r->arguments; a; a = a->next) {
470             if (a != r->arguments)
471                 wrbuf_putc(c->wrbuf, '&');
472             wrbuf_printf(c->wrbuf, "%s=%s", a->name, a->value);
473         }
474     }
475
476     wrbuf_printf(c->wrbuf, " HTTP/%s\r\n", r->http_version);
477
478     for (h = r->headers; h; h = h->next)
479         wrbuf_printf(c->wrbuf, "%s: %s\r\n", h->name, h->value);
480
481     wrbuf_puts(c->wrbuf, "\r\n");
482     
483     return http_buf_bywrbuf(c->wrbuf);
484 }
485
486
487 static int http_weshouldproxy(struct http_request *rq)
488 {
489     if (proxy_addr && !strstr(rq->path, "search.pz2"))
490         return 1;
491     return 0;
492 }
493
494 static int http_proxy(struct http_request *rq)
495 {
496     struct http_channel *c = rq->channel;
497     struct http_proxy *p = c->proxy;
498     struct http_header *hp;
499     struct http_buf *requestbuf;
500
501     if (!p) // This is a new connection. Create a proxy channel
502     {
503         int sock;
504         struct protoent *pe;
505         int one = 1;
506         int flags;
507
508         if (!(pe = getprotobyname("tcp"))) {
509             abort();
510         }
511         if ((sock = socket(PF_INET, SOCK_STREAM, pe->p_proto)) < 0)
512         {
513             yaz_log(YLOG_WARN|YLOG_ERRNO, "socket");
514             return -1;
515         }
516         if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)
517                         &one, sizeof(one)) < 0)
518             abort();
519         if ((flags = fcntl(sock, F_GETFL, 0)) < 0) 
520             yaz_log(YLOG_FATAL|YLOG_ERRNO, "fcntl");
521         if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0)
522             yaz_log(YLOG_FATAL|YLOG_ERRNO, "fcntl2");
523         if (connect(sock, (struct sockaddr *) proxy_addr, sizeof(*proxy_addr)) < 0)
524             if (errno != EINPROGRESS)
525             {
526                 yaz_log(YLOG_WARN|YLOG_ERRNO, "Proxy connect");
527                 return -1;
528             }
529
530         p = xmalloc(sizeof(struct http_proxy));
531         p->oqueue = 0;
532         p->channel = c;
533         p->first_response = 1;
534         c->proxy = p;
535         // We will add EVENT_OUTPUT below
536         p->iochan = iochan_create(sock, proxy_io, EVENT_INPUT);
537         iochan_setdata(p->iochan, p);
538         p->iochan->next = channel_list;
539         channel_list = p->iochan;
540     }
541
542     // Modify Host: header
543     for (hp = rq->headers; hp; hp = hp->next)
544         if (!strcmp(hp->name, "Host"))
545             break;
546     if (!hp)
547     {
548         yaz_log(YLOG_WARN, "Failed to find Host header in proxy");
549         return -1;
550     }
551     hp->value = nmem_strdup(c->nmem, proxy_url);
552     requestbuf = http_serialize_request(rq);
553     http_buf_enqueue(&p->oqueue, requestbuf);
554     iochan_setflag(p->iochan, EVENT_OUTPUT);
555     return 0;
556 }
557
558 void http_send_response(struct http_channel *ch)
559 {
560     struct http_response *rs = ch->response;
561     struct http_buf *hb;
562
563     assert(rs);
564     hb = http_serialize_response(ch, rs);
565     if (!hb)
566     {
567         yaz_log(YLOG_WARN, "Failed to serialize HTTP response");
568         http_destroy(ch->iochan);
569     }
570     else
571     {
572         http_buf_enqueue(&ch->oqueue, hb);
573         iochan_setflag(ch->iochan, EVENT_OUTPUT);
574         ch->state = Http_Idle;
575     }
576 }
577
578 static void http_io(IOCHAN i, int event)
579 {
580     struct http_channel *hc = iochan_getdata(i);
581
582     switch (event)
583     {
584         int res, reqlen;
585         struct http_buf *htbuf;
586
587         case EVENT_INPUT:
588             htbuf = http_buf_create();
589             res = read(iochan_getfd(i), htbuf->buf, HTTP_BUF_SIZE -1);
590             if (res == -1 && errno == EAGAIN)
591             {
592                 http_buf_destroy(htbuf);
593                 return;
594             }
595             if (res <= 0)
596             {
597                 http_buf_destroy(htbuf);
598                 http_destroy(i);
599                 return;
600             }
601             if (res > 0)
602             {
603                 htbuf->buf[res] = '\0';
604                 htbuf->len = res;
605                 http_buf_enqueue(&hc->iqueue, htbuf);
606             }
607
608             if (hc->state == Http_Busy)
609                 return;
610             if ((reqlen = request_check(hc->iqueue)) <= 2)
611                 return;
612
613             nmem_reset(hc->nmem);
614             if (!(hc->request = http_parse_request(hc, &hc->iqueue, reqlen)))
615             {
616                 yaz_log(YLOG_WARN, "Failed to parse request");
617                 http_destroy(i);
618                 return;
619             }
620             hc->response = 0;
621             yaz_log(YLOG_LOG, "Request: %s %s%s%s", hc->request->method,
622                     hc->request->path,
623                     *hc->request->search ? "?" : "",
624                     hc->request->search);
625             if (http_weshouldproxy(hc->request))
626                 http_proxy(hc->request);
627             else
628             {
629                 // Execute our business logic!
630                 hc->state = Http_Busy;
631                 http_command(hc);
632             }
633             if (hc->iqueue)
634             {
635                 yaz_log(YLOG_DEBUG, "We think we have more input to read. Forcing event");
636                 iochan_setevent(i, EVENT_INPUT);
637             }
638
639             break;
640
641         case EVENT_OUTPUT:
642             if (hc->oqueue)
643             {
644                 struct http_buf *wb = hc->oqueue;
645                 res = write(iochan_getfd(hc->iochan), wb->buf + wb->offset, wb->len);
646                 if (res <= 0)
647                 {
648                     yaz_log(YLOG_WARN|YLOG_ERRNO, "write");
649                     http_destroy(i);
650                     return;
651                 }
652                 if (res == wb->len)
653                 {
654                     hc->oqueue = hc->oqueue->next;
655                     http_buf_destroy(wb);
656                 }
657                 else
658                 {
659                     wb->len -= res;
660                     wb->offset += res;
661                 }
662                 if (!hc->oqueue) {
663                     if (!strcmp(hc->version, "1.0"))
664                     {
665                         http_destroy(i);
666                         return;
667                     }
668                     else
669                     {
670                         iochan_clearflag(i, EVENT_OUTPUT);
671                         if (hc->iqueue)
672                             iochan_setevent(hc->iochan, EVENT_INPUT);
673                     }
674                 }
675             }
676
677             if (!hc->oqueue && hc->proxy && !hc->proxy->iochan) 
678                 http_destroy(i); // Server closed; we're done
679             break;
680         default:
681             yaz_log(YLOG_WARN, "Unexpected event on connection");
682             http_destroy(i);
683     }
684 }
685
686 // If this hostname contains our proxy host as a prefix, replace with myurl
687 static char *sub_hostname(struct http_channel *c, char *buf)
688 {
689     char tmp[1024];
690     if (strlen(buf) > 1023)
691         return buf;
692     if (strncmp(buf, "http://", 7))
693         return buf;
694     if (!strncmp(buf + 7, proxy_url, strlen(proxy_url)))
695     {
696         strcpy(tmp, myurl);
697         strcat(tmp, buf + strlen(proxy_url) + 7);
698         return nmem_strdup(c->nmem, tmp);
699     }
700     return buf;
701 }
702
703 // Handles I/O on a client connection to a backend web server (proxy mode)
704 static void proxy_io(IOCHAN pi, int event)
705 {
706     struct http_proxy *pc = iochan_getdata(pi);
707     struct http_channel *hc = pc->channel;
708
709     switch (event)
710     {
711         int res;
712         struct http_buf *htbuf;
713
714         case EVENT_INPUT:
715             htbuf = http_buf_create();
716             res = read(iochan_getfd(pi), htbuf->buf, HTTP_BUF_SIZE -1);
717             if (res == 0 || (res < 0 && errno != EINPROGRESS))
718             {
719                 if (hc->oqueue)
720                 {
721                     yaz_log(YLOG_WARN, "Proxy read came up short");
722                     // Close channel and alert client HTTP channel that we're gone
723                     http_buf_destroy(htbuf);
724                     close(iochan_getfd(pi));
725                     iochan_destroy(pi);
726                     pc->iochan = 0;
727                 }
728                 else
729                 {
730                     http_destroy(hc->iochan);
731                     return;
732                 }
733             }
734             else
735             {
736                 htbuf->buf[res] = '\0';
737                 htbuf->len = res;
738                 int offset = 0;
739                 if (pc->first_response) // Check if this is a redirect
740                 {
741                     int len;
742                     if ((len = package_check(htbuf->buf)))
743                     {
744                         struct http_response *res = http_parse_response_buf(hc, htbuf->buf, len);
745                         if (res)
746                         {
747                             struct http_header *h;
748                             for (h = res->headers; h; h = h->next)
749                                 if (!strcmp(h->name, "Location"))
750                                 {
751                                     // We found a location header. Rewrite it.
752                                     struct http_buf *buf;
753                                     h->value = sub_hostname(hc, h->value);
754                                     buf = http_serialize_response(hc, res);
755                                     http_buf_enqueue(&hc->oqueue, buf);
756                                     offset = len;
757                                     break;
758                                 }
759                         }
760                     }
761                     pc->first_response = 0;
762                 }
763                 // Write any remaining payload
764                 if (htbuf->len - offset > 0)
765                 {
766                     if (offset > 0)
767                     {
768                         memmove(htbuf->buf, htbuf->buf + offset, htbuf->len - offset);
769                         htbuf->len -= offset;
770                     }
771                     http_buf_enqueue(&hc->oqueue, htbuf + offset);
772                 }
773             }
774             iochan_setflag(hc->iochan, EVENT_OUTPUT);
775             break;
776         case EVENT_OUTPUT:
777             if (!(htbuf = pc->oqueue))
778             {
779                 iochan_clearflag(pi, EVENT_OUTPUT);
780                 return;
781             }
782             res = write(iochan_getfd(pi), htbuf->buf + htbuf->offset, htbuf->len);
783             if (res <= 0)
784             {
785                 yaz_log(YLOG_WARN|YLOG_ERRNO, "write");
786                 http_destroy(hc->iochan);
787                 return;
788             }
789             if (res == htbuf->len)
790             {
791                 struct http_buf *np = htbuf->next;
792                 http_buf_destroy(htbuf);
793                 pc->oqueue = np;
794             }
795             else
796             {
797                 htbuf->len -= res;
798                 htbuf->offset += res;
799             }
800
801             if (!pc->oqueue) {
802                 iochan_setflags(pi, EVENT_INPUT); // Turns off output flag
803             }
804             break;
805         default:
806             yaz_log(YLOG_WARN, "Unexpected event on connection");
807             http_destroy(hc->iochan);
808     }
809 }
810
811 // Cleanup channel
812 static void http_destroy(IOCHAN i)
813 {
814     struct http_channel *s = iochan_getdata(i);
815
816     if (s->proxy)
817     {
818         if (s->proxy->iochan)
819         {
820             close(iochan_getfd(s->proxy->iochan));
821             iochan_destroy(s->proxy->iochan);
822         }
823         http_buf_destroy_queue(s->proxy->oqueue);
824         xfree(s->proxy);
825     }
826     s->next = http_channel_freelist;
827     http_channel_freelist = s;
828     close(iochan_getfd(i));
829     iochan_destroy(i);
830 }
831
832 static struct http_channel *http_create(void)
833 {
834     struct http_channel *r = http_channel_freelist;
835
836     if (r)
837     {
838         http_channel_freelist = r->next;
839         nmem_reset(r->nmem);
840         wrbuf_rewind(r->wrbuf);
841     }
842     else
843     {
844         r = xmalloc(sizeof(struct http_channel));
845         r->nmem = nmem_create();
846         r->wrbuf = wrbuf_alloc();
847     }
848     r->proxy = 0;
849     r->iochan = 0;
850     r->iqueue = r->oqueue = 0;
851     r->state = Http_Idle;
852     r->request = 0;
853     r->response = 0;
854     return r;
855 }
856
857
858 /* Accept a new command connection */
859 static void http_accept(IOCHAN i, int event)
860 {
861     struct sockaddr_in addr;
862     int fd = iochan_getfd(i);
863     socklen_t len;
864     int s;
865     IOCHAN c;
866     int flags;
867     struct http_channel *ch;
868
869     len = sizeof addr;
870     if ((s = accept(fd, (struct sockaddr *) &addr, &len)) < 0)
871     {
872         yaz_log(YLOG_WARN|YLOG_ERRNO, "accept");
873         return;
874     }
875     if ((flags = fcntl(s, F_GETFL, 0)) < 0) 
876         yaz_log(YLOG_FATAL|YLOG_ERRNO, "fcntl");
877     if (fcntl(s, F_SETFL, flags | O_NONBLOCK) < 0)
878         yaz_log(YLOG_FATAL|YLOG_ERRNO, "fcntl2");
879
880     yaz_log(YLOG_DEBUG, "New command connection");
881     c = iochan_create(s, http_io, EVENT_INPUT | EVENT_EXCEPT);
882
883     ch = http_create();
884     ch->iochan = c;
885     iochan_setdata(c, ch);
886
887     c->next = channel_list;
888     channel_list = c;
889 }
890
891 /* Create a http-channel listener, syntax [host:]port */
892 void http_init(const char *addr)
893 {
894     IOCHAN c;
895     int l;
896     struct protoent *p;
897     struct sockaddr_in myaddr;
898     int one = 1;
899     const char *pp;
900     int port;
901
902     yaz_log(YLOG_LOG, "HTTP listener is %s", addr);
903
904     memset(&myaddr, 0, sizeof myaddr);
905     myaddr.sin_family = AF_INET;
906     pp = strchr(addr, ':');
907     if (pp)
908     {
909         int len = pp - addr;
910         char hostname[128];
911         struct hostent *he;
912
913         strncpy(hostname, addr, len);
914         hostname[len] = '\0';
915         if (!(he = gethostbyname(hostname)))
916         {
917             yaz_log(YLOG_FATAL, "Unable to resolve '%s'", hostname);
918             exit(1);
919         }
920         memcpy(&myaddr.sin_addr.s_addr, he->h_addr_list[0], he->h_length);
921         port = atoi(pp + 1);
922     }
923     else
924     {
925         port = atoi(addr);
926         myaddr.sin_addr.s_addr = INADDR_ANY;
927     }
928     myaddr.sin_port = htons(port);
929
930     if (!(p = getprotobyname("tcp"))) {
931         abort();
932     }
933     if ((l = socket(PF_INET, SOCK_STREAM, p->p_proto)) < 0)
934         yaz_log(YLOG_FATAL|YLOG_ERRNO, "socket");
935     if (setsockopt(l, SOL_SOCKET, SO_REUSEADDR, (char*)
936                     &one, sizeof(one)) < 0)
937         abort();
938
939     if (bind(l, (struct sockaddr *) &myaddr, sizeof myaddr) < 0) 
940         yaz_log(YLOG_FATAL|YLOG_ERRNO, "bind");
941     if (listen(l, SOMAXCONN) < 0) 
942         yaz_log(YLOG_FATAL|YLOG_ERRNO, "listen");
943
944     c = iochan_create(l, http_accept, EVENT_INPUT | EVENT_EXCEPT);
945     c->next = channel_list;
946     channel_list = c;
947 }
948
949 void http_set_proxyaddr(char *host, char *base_url)
950 {
951     char *p;
952     int port;
953     struct hostent *he;
954
955     strcpy(myurl, base_url);
956     strcpy(proxy_url, host);
957     p = strchr(host, ':');
958     yaz_log(YLOG_DEBUG, "Proxying for %s", host);
959     if (p) {
960         port = atoi(p + 1);
961         *p = '\0';
962     }
963     else
964         port = 80;
965     if (!(he = gethostbyname(host))) 
966     {
967         fprintf(stderr, "Failed to lookup '%s'\n", host);
968         exit(1);
969     }
970     proxy_addr = xmalloc(sizeof(struct sockaddr_in));
971     proxy_addr->sin_family = he->h_addrtype;
972     memcpy(&proxy_addr->sin_addr.s_addr, he->h_addr_list[0], he->h_length);
973     proxy_addr->sin_port = htons(port);
974 }
975
976 /*
977  * Local variables:
978  * c-basic-offset: 4
979  * indent-tabs-mode: nil
980  * End:
981  * vim: shiftwidth=4 tabstop=8 expandtab
982  */