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