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