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