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