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