1 /* This file is part of Pazpar2.
2 Copyright (C) 2006-2011 Index Data
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
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
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
27 typedef int socklen_t;
31 #include <sys/socket.h>
34 #include <sys/types.h>
36 #include <yaz/snprintf.h>
54 #include <netinet/in.h>
58 #include <arpa/inet.h>
61 #include <yaz/yaz-util.h>
62 #include <yaz/comstack.h>
64 #include <yaz/mutex.h>
70 #define MAX_HTTP_HEADER 4096
73 #define strncasecmp _strnicmp
74 #define strcasecmp _stricmp
79 #define HTTP_BUF_SIZE 4096
83 struct http_buf *next;
87 static void proxy_io(IOCHAN i, int event);
88 static struct http_channel *http_channel_create(http_server_t http_server,
90 struct conf_server *server);
91 static void http_channel_destroy(IOCHAN i);
92 static http_server_t http_server_create(void);
93 static void http_server_incref(http_server_t hs);
97 struct http_buf *http_buf_freelist;
98 int http_buf_freelist_count;
99 int http_buf_freelist_max;
101 struct http_channel *http_channel_freelist;
102 int http_channel_freelist_count;
103 int http_channel_freelist_max;
107 http_sessions_t http_sessions;
108 struct sockaddr_in *proxy_addr;
111 struct http_channel_observer_s {
114 http_channel_destroy_t destroy;
115 struct http_channel_observer_s *next;
116 struct http_channel *chan;
120 const char *http_lookup_header(struct http_header *header,
123 for (; header; header = header->next)
124 if (!strcasecmp(name, header->name))
125 return header->value;
129 static struct http_buf *http_buf_create(http_server_t hs)
131 struct http_buf *r = 0;
133 yaz_mutex_enter(hs->mutex);
134 if (hs->http_buf_freelist)
136 r = hs->http_buf_freelist;
137 hs->http_buf_freelist = hs->http_buf_freelist->next;
138 hs->http_buf_freelist_count--;
140 yaz_mutex_leave(hs->mutex);
142 r = xmalloc(sizeof(struct http_buf));
149 static void http_buf_destroy(http_server_t hs, struct http_buf *b)
151 yaz_mutex_enter(hs->mutex);
152 if (hs->http_buf_freelist_max > 0 && hs->http_buf_freelist_count > hs->http_buf_freelist_max) {
154 while (b = hs->http_buf_freelist) {
156 hs->http_buf_freelist = hs->http_buf_freelist->next;
160 b->next = hs->http_buf_freelist;
161 hs->http_buf_freelist = b;
162 hs->http_buf_freelist_count++;
164 yaz_mutex_leave(hs->mutex);
167 static void http_buf_destroy_queue(http_server_t hs, struct http_buf *b)
173 http_buf_destroy(hs, b);
178 static struct http_buf *http_buf_bybuf(http_server_t hs, char *b, int len)
180 struct http_buf *res = 0;
181 struct http_buf **p = &res;
186 if (tocopy > HTTP_BUF_SIZE)
187 tocopy = HTTP_BUF_SIZE;
188 *p = http_buf_create(hs);
189 memcpy((*p)->buf, b, tocopy);
198 // Add a (chain of) buffers to the end of an existing queue.
199 static void http_buf_enqueue(struct http_buf **queue, struct http_buf *b)
202 queue = &(*queue)->next;
206 static struct http_buf *http_buf_bywrbuf(http_server_t hs, WRBUF wrbuf)
208 // Heavens to Betsy (buf)!
209 return http_buf_bybuf(hs, wrbuf_buf(wrbuf), wrbuf_len(wrbuf));
212 // Non-destructively collapse chain of buffers into a string (max *len)
214 static void http_buf_peek(struct http_buf *b, char *buf, int len)
217 while (b && rd < len)
219 int toread = len - rd;
222 memcpy(buf + rd, b->buf + b->offset, toread);
229 static int http_buf_size(struct http_buf *b)
232 for (; b; b = b->next)
237 // Ddestructively munch up to len from head of queue.
238 static int http_buf_read(http_server_t hs,
239 struct http_buf **b, char *buf, int len)
242 while ((*b) && rd < len)
244 int toread = len - rd;
245 if (toread > (*b)->len)
247 memcpy(buf + rd, (*b)->buf + (*b)->offset, toread);
249 if (toread < (*b)->len)
252 (*b)->offset += toread;
257 struct http_buf *n = (*b)->next;
258 http_buf_destroy(hs, *b);
266 // Buffers may overlap.
267 static void urldecode(char *i, char *o)
276 else if (*i == '%' && i[1] && i[2])
280 sscanf(i, "%2x", &v);
290 // Warning: Buffers may not overlap
291 void urlencode(const char *i, char *o)
295 if (strchr(" /:", *i))
297 sprintf(o, "%%%.2X", (int) *i);
307 void http_addheader(struct http_response *r, const char *name, const char *value)
309 struct http_channel *c = r->channel;
310 struct http_header *h = nmem_malloc(c->nmem, sizeof *h);
311 h->name = nmem_strdup(c->nmem, name);
312 h->value = nmem_strdup(c->nmem, value);
313 h->next = r->headers;
317 const char *http_argbyname(struct http_request *r, const char *name)
319 struct http_argument *p;
322 for (p = r->arguments; p; p = p->next)
323 if (!strcmp(p->name, name))
328 const char *http_headerbyname(struct http_header *h, const char *name)
330 for (; h; h = h->next)
331 if (!strcmp(h->name, name))
336 struct http_response *http_create_response(struct http_channel *c)
338 struct http_response *r = nmem_malloc(c->nmem, sizeof(*r));
339 strcpy(r->code, "200");
344 r->content_type = "text/xml";
349 static const char *next_crlf(const char *cp, size_t *skipped)
351 const char *next_cp = strchr(cp, '\n');
354 if (next_cp > cp && next_cp[-1] == '\r')
355 *skipped = next_cp - cp - 1;
357 *skipped = next_cp - cp;
363 // Check if buf contains a package (minus payload)
364 static int package_check(const char *buf, int sz)
372 const char *b = next_crlf(buf, &skipped);
376 // we did not find CRLF.. See if buffer is too large..
377 if (sz >= MAX_HTTP_HEADER-1)
378 return MAX_HTTP_HEADER-1; // yes. Return that (will fail later)
384 // CRLF CRLF , i.e. end of header
385 if (len + content_len <= sz)
386 return len + content_len;
390 // following first skip of \r\n so that we don't consider Method
391 if (!strncasecmp(buf, "Content-Length:", 15))
393 const char *cp = buf+15;
397 while (*cp && isdigit(*(const unsigned char *)cp))
398 content_len = content_len*10 + (*cp++ - '0');
399 if (content_len < 0) /* prevent negative offsets */
403 return 0; // incomplete request
406 // Check if we have a request. Return 0 or length
407 static int request_check(struct http_buf *queue)
409 char tmp[MAX_HTTP_HEADER];
411 // only peek at the header..
412 http_buf_peek(queue, tmp, MAX_HTTP_HEADER-1);
413 // still we only return non-zero if the complete request is received..
414 return package_check(tmp, http_buf_size(queue));
417 struct http_response *http_parse_response_buf(struct http_channel *c, const char *buf, int len)
419 char tmp[MAX_HTTP_HEADER];
420 struct http_response *r = http_create_response(c);
422 struct http_header **hp = &r->headers;
424 if (len >= MAX_HTTP_HEADER)
426 memcpy(tmp, buf, len);
427 for (p = tmp; *p && *p != ' '; p++) // Skip HTTP version
431 for (p2 = p; *p2 && *p2 != ' ' && p2 - p < 3; p2++)
432 r->code[p2 - p] = *p2;
433 if (!(p = strstr(tmp, "\r\n")))
438 if (!(p2 = strstr(p, "\r\n")))
440 if (p == p2) // End of headers
444 struct http_header *h = *hp = nmem_malloc(c->nmem, sizeof(*h));
445 char *value = strchr(p, ':');
449 h->name = nmem_strdup(c->nmem, p);
450 while (isspace(*(const unsigned char *) value))
452 if (value >= p2) // Empty header;
459 h->value = nmem_strdup(c->nmem, value);
468 static int http_parse_arguments(struct http_request *r, NMEM nmem,
471 const char *p2 = args;
475 struct http_argument *a;
476 const char *equal = strchr(p2, '=');
477 const char *eoa = strchr(p2, '&');
480 yaz_log(YLOG_WARN, "Expected '=' in argument");
484 eoa = equal + strlen(equal); // last argument
485 else if (equal > eoa)
487 yaz_log(YLOG_WARN, "Missing '&' in argument");
490 a = nmem_malloc(nmem, sizeof(struct http_argument));
491 a->name = nmem_strdupn(nmem, p2, equal - p2);
492 a->value = nmem_strdupn(nmem, equal+1, eoa - equal - 1);
493 urldecode(a->name, a->name);
494 urldecode(a->value, a->value);
495 a->next = r->arguments;
504 struct http_request *http_parse_request(struct http_channel *c,
505 struct http_buf **queue,
508 struct http_request *r = nmem_malloc(c->nmem, sizeof(*r));
510 char *start = nmem_malloc(c->nmem, len+1);
513 if (http_buf_read(c->http_server, queue, buf, len) < len)
515 yaz_log(YLOG_WARN, "http_buf_read < len (%d)", len);
525 for (p = buf, p2 = r->method; *p && *p != ' ' && p - buf < 19; p++)
529 yaz_log(YLOG_WARN, "Unexpected HTTP method in request");
534 if (!(buf = strchr(buf, ' ')))
536 yaz_log(YLOG_WARN, "Missing Request-URI in HTTP request");
540 if (!(p = strchr(buf, ' ')))
542 yaz_log(YLOG_WARN, "HTTP Request-URI not terminated (too long?)");
546 if ((p2 = strchr(buf, '?'))) // Do we have arguments?
548 r->path = nmem_strdup(c->nmem, buf);
551 r->search = nmem_strdup(c->nmem, p2);
553 http_parse_arguments(r, c->nmem, p2);
557 if (strncmp(buf, "HTTP/", 5))
558 strcpy(r->http_version, "1.0");
562 buf += 5; // strlen("HTTP/")
564 p = (char*) next_crlf(buf, &skipped);
565 if (!p || skipped < 3 || skipped > 5)
568 memcpy(r->http_version, buf, skipped);
569 r->http_version[skipped] = '\0';
572 strcpy(c->version, r->http_version);
579 p = (char *) next_crlf(buf, &skipped);
584 else if (skipped == 0)
592 char *n_v = nmem_malloc(c->nmem, skipped+1);
593 struct http_header *h = nmem_malloc(c->nmem, sizeof(*h));
595 memcpy(n_v, buf, skipped);
598 if (!(cp = strchr(n_v, ':')))
600 h->name = nmem_strdupn(c->nmem, n_v, cp - n_v);
604 h->value = nmem_strdup(c->nmem, cp);
605 h->next = r->headers;
611 // determine if we do keep alive
612 if (!strcmp(c->version, "1.0"))
614 const char *v = http_lookup_header(r->headers, "Connection");
615 if (v && !strcmp(v, "Keep-Alive"))
622 const char *v = http_lookup_header(r->headers, "Connection");
623 if (v && !strcmp(v, "close"))
628 if (buf < start + len)
630 const char *content_type = http_lookup_header(r->headers,
632 r->content_len = start + len - buf;
633 r->content_buf = buf;
635 if (!yaz_strcmp_del("application/x-www-form-urlencoded",
638 http_parse_arguments(r, c->nmem, r->content_buf);
644 static struct http_buf *http_serialize_response(struct http_channel *c,
645 struct http_response *r)
647 struct http_header *h;
649 wrbuf_rewind(c->wrbuf);
650 wrbuf_printf(c->wrbuf, "HTTP/%s %s %s\r\n", c->version, r->code, r->msg);
651 for (h = r->headers; h; h = h->next)
652 wrbuf_printf(c->wrbuf, "%s: %s\r\n", h->name, h->value);
655 wrbuf_printf(c->wrbuf, "Content-Length: %d\r\n", r->payload ?
656 (int) strlen(r->payload) : 0);
657 wrbuf_printf(c->wrbuf, "Content-Type: %s\r\n", r->content_type);
658 if (!strcmp(r->content_type, "text/xml"))
660 xmlDoc *doc = xmlParseMemory(r->payload, strlen(r->payload));
667 yaz_log(YLOG_WARN, "Sending non-wellformed "
668 "response (bug #1162");
669 yaz_log(YLOG_WARN, "payload: %s", r->payload);
673 wrbuf_puts(c->wrbuf, "\r\n");
676 wrbuf_puts(c->wrbuf, r->payload);
678 return http_buf_bywrbuf(c->http_server, c->wrbuf);
681 // Serialize a HTTP request
682 static struct http_buf *http_serialize_request(struct http_request *r)
684 struct http_channel *c = r->channel;
685 struct http_header *h;
687 wrbuf_rewind(c->wrbuf);
688 wrbuf_printf(c->wrbuf, "%s %s%s%s", r->method, r->path,
689 *r->search ? "?" : "", r->search);
691 wrbuf_printf(c->wrbuf, " HTTP/%s\r\n", r->http_version);
693 for (h = r->headers; h; h = h->next)
694 wrbuf_printf(c->wrbuf, "%s: %s\r\n", h->name, h->value);
696 wrbuf_puts(c->wrbuf, "\r\n");
699 wrbuf_write(c->wrbuf, r->content_buf, r->content_len);
702 yaz_log(YLOG_LOG, "WRITING TO PROXY:\n%s\n----",
703 wrbuf_cstr(c->wrbuf));
705 return http_buf_bywrbuf(c->http_server, c->wrbuf);
709 static int http_weshouldproxy(struct http_request *rq)
711 struct http_channel *c = rq->channel;
712 if (c->server->http_server->proxy_addr && !strstr(rq->path, "search.pz2"))
718 struct http_header * http_header_append(struct http_channel *ch,
719 struct http_header * hp,
723 struct http_header *hpnew = 0;
728 while (hp && hp->next)
731 if(name && strlen(name)&& value && strlen(value)){
732 hpnew = nmem_malloc(ch->nmem, sizeof *hpnew);
733 hpnew->name = nmem_strdup(ch->nmem, name);
734 hpnew->value = nmem_strdup(ch->nmem, value);
747 static int is_inprogress(void)
750 if (WSAGetLastError() == WSAEWOULDBLOCK)
753 if (errno == EINPROGRESS)
759 static void enable_nonblock(int sock)
763 flags = (flags & CS_FLAGS_BLOCKING) ? 0 : 1;
764 if (ioctlsocket(sock, FIONBIO, &flags) < 0)
765 yaz_log(YLOG_FATAL|YLOG_ERRNO, "ioctlsocket");
767 if ((flags = fcntl(sock, F_GETFL, 0)) < 0)
768 yaz_log(YLOG_FATAL|YLOG_ERRNO, "fcntl");
769 if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0)
770 yaz_log(YLOG_FATAL|YLOG_ERRNO, "fcntl2");
774 static int http_proxy(struct http_request *rq)
776 struct http_channel *c = rq->channel;
777 struct http_proxy *p = c->proxy;
778 struct http_header *hp;
779 struct http_buf *requestbuf;
780 char server_port[16] = "";
781 struct conf_server *ser = c->server;
783 if (!p) // This is a new connection. Create a proxy channel
789 if (!(pe = getprotobyname("tcp"))) {
792 if ((sock = socket(PF_INET, SOCK_STREAM, pe->p_proto)) < 0)
794 yaz_log(YLOG_WARN|YLOG_ERRNO, "socket");
797 if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)
798 &one, sizeof(one)) < 0)
800 enable_nonblock(sock);
801 if (connect(sock, (struct sockaddr *)
802 c->server->http_server->proxy_addr,
803 sizeof(*c->server->http_server->proxy_addr)) < 0)
805 if (!is_inprogress())
807 yaz_log(YLOG_WARN|YLOG_ERRNO, "Proxy connect");
811 p = xmalloc(sizeof(struct http_proxy));
814 p->first_response = 1;
816 // We will add EVENT_OUTPUT below
817 p->iochan = iochan_create(sock, proxy_io, EVENT_INPUT, "http_proxy");
818 iochan_setdata(p->iochan, p);
820 iochan_add(ser->iochan_man, p->iochan);
823 // Do _not_ modify Host: header, just checking it's existence
825 if (!http_lookup_header(rq->headers, "Host"))
827 yaz_log(YLOG_WARN, "Failed to find Host header in proxy");
831 // Add new header about paraz2 version, host, remote client address, etc.
833 char server_via[128];
836 hp = http_header_append(c, hp,
837 "X-Pazpar2-Version", PACKAGE_VERSION);
838 hp = http_header_append(c, hp,
839 "X-Pazpar2-Server-Host", ser->host);
840 sprintf(server_port, "%d", ser->port);
841 hp = http_header_append(c, hp,
842 "X-Pazpar2-Server-Port", server_port);
843 yaz_snprintf(server_via, sizeof(server_via),
845 ser->host ? ser->host : "@",
846 server_port, PACKAGE_NAME, PACKAGE_VERSION);
847 hp = http_header_append(c, hp, "Via" , server_via);
848 hp = http_header_append(c, hp, "X-Forwarded-For", c->addr);
851 requestbuf = http_serialize_request(rq);
853 http_buf_enqueue(&p->oqueue, requestbuf);
854 iochan_setflag(p->iochan, EVENT_OUTPUT);
858 void http_send_response(struct http_channel *ch)
860 struct http_response *rs = ch->response;
864 hb = http_serialize_response(ch, rs);
867 yaz_log(YLOG_WARN, "Failed to serialize HTTP response");
868 http_channel_destroy(ch->iochan);
872 http_buf_enqueue(&ch->oqueue, hb);
873 iochan_setflag(ch->iochan, EVENT_OUTPUT);
874 ch->state = Http_Idle;
878 static void http_error(struct http_channel *hc, int no, const char *msg)
880 struct http_response *rs = http_create_response(hc);
883 hc->keep_alive = 0; // not keeping this HTTP session alive
885 sprintf(rs->code, "%d", no);
887 rs->msg = nmem_strdup(hc->nmem, msg);
888 rs->payload = nmem_malloc(hc->nmem, 100);
889 yaz_snprintf(rs->payload, 99, "<error>HTTP Error %d: %s</error>\n",
891 http_send_response(hc);
894 static void http_io(IOCHAN i, int event)
896 struct http_channel *hc = iochan_getdata(i);
899 if (event == EVENT_INPUT)
902 struct http_buf *htbuf;
904 htbuf = http_buf_create(hc->http_server);
905 res = recv(iochan_getfd(i), htbuf->buf, HTTP_BUF_SIZE -1, 0);
906 if (res == -1 && errno == EAGAIN)
908 http_buf_destroy(hc->http_server, htbuf);
913 http_buf_destroy(hc->http_server, htbuf);
914 http_channel_destroy(i);
917 htbuf->buf[res] = '\0';
919 http_buf_enqueue(&hc->iqueue, htbuf);
923 if (hc->state == Http_Busy)
925 reqlen = request_check(hc->iqueue);
928 // we have a complete HTTP request
929 nmem_reset(hc->nmem);
930 if (!(hc->request = http_parse_request(hc, &hc->iqueue, reqlen)))
932 yaz_log(YLOG_WARN, "Failed to parse request");
933 http_error(hc, 400, "Bad Request");
937 yaz_log(YLOG_LOG, "Request: %s %s%s%s", hc->request->method,
939 *hc->request->search ? "?" : "",
940 hc->request->search);
941 if (hc->request->content_buf)
942 yaz_log(YLOG_LOG, "%s", hc->request->content_buf);
943 if (http_weshouldproxy(hc->request))
944 http_proxy(hc->request);
947 // Execute our business logic!
948 hc->state = Http_Busy;
953 else if (event == EVENT_OUTPUT)
958 struct http_buf *wb = hc->oqueue;
960 res = send(iochan_getfd(hc->iochan),
961 wb->buf + wb->offset, wb->len, 0);
964 yaz_log(YLOG_WARN|YLOG_ERRNO, "write");
965 http_channel_destroy(i);
970 hc->oqueue = hc->oqueue->next;
971 http_buf_destroy(hc->http_server, wb);
982 http_channel_destroy(i);
987 iochan_clearflag(i, EVENT_OUTPUT);
993 if (!hc->oqueue && hc->proxy && !hc->proxy->iochan)
994 http_channel_destroy(i); // Server closed; we're done
998 yaz_log(YLOG_WARN, "Unexpected event on connection");
999 http_channel_destroy(i);
1005 // Handles I/O on a client connection to a backend web server (proxy mode)
1006 static void proxy_io(IOCHAN pi, int event)
1008 struct http_proxy *pc = iochan_getdata(pi);
1009 struct http_channel *hc = pc->channel;
1014 struct http_buf *htbuf;
1017 htbuf = http_buf_create(hc->http_server);
1018 res = recv(iochan_getfd(pi), htbuf->buf, HTTP_BUF_SIZE -1, 0);
1019 if (res == 0 || (res < 0 && !is_inprogress()))
1023 yaz_log(YLOG_WARN, "Proxy read came up short");
1024 // Close channel and alert client HTTP channel that we're gone
1025 http_buf_destroy(hc->http_server, htbuf);
1027 closesocket(iochan_getfd(pi));
1029 close(iochan_getfd(pi));
1036 http_channel_destroy(hc->iochan);
1042 htbuf->buf[res] = '\0';
1045 // Write any remaining payload
1046 if (htbuf->len - htbuf->offset > 0)
1047 http_buf_enqueue(&hc->oqueue, htbuf);
1049 iochan_setflag(hc->iochan, EVENT_OUTPUT);
1052 if (!(htbuf = pc->oqueue))
1054 iochan_clearflag(pi, EVENT_OUTPUT);
1057 res = send(iochan_getfd(pi), htbuf->buf + htbuf->offset, htbuf->len, 0);
1060 yaz_log(YLOG_WARN|YLOG_ERRNO, "write");
1061 http_channel_destroy(hc->iochan);
1064 if (res == htbuf->len)
1066 struct http_buf *np = htbuf->next;
1067 http_buf_destroy(hc->http_server, htbuf);
1073 htbuf->offset += res;
1077 iochan_setflags(pi, EVENT_INPUT); // Turns off output flag
1081 yaz_log(YLOG_WARN, "Unexpected event on connection");
1082 http_channel_destroy(hc->iochan);
1086 static void http_fire_observers(struct http_channel *c);
1087 static void http_destroy_observers(struct http_channel *c);
1090 static void http_channel_destroy(IOCHAN i)
1092 struct http_channel *s = iochan_getdata(i);
1093 http_server_t http_server;
1097 if (s->proxy->iochan)
1100 closesocket(iochan_getfd(s->proxy->iochan));
1102 close(iochan_getfd(s->proxy->iochan));
1104 iochan_destroy(s->proxy->iochan);
1106 http_buf_destroy_queue(s->http_server, s->proxy->oqueue);
1109 http_buf_destroy_queue(s->http_server, s->iqueue);
1110 http_buf_destroy_queue(s->http_server, s->oqueue);
1111 http_fire_observers(s);
1112 http_destroy_observers(s);
1114 http_server = s->http_server; /* save it for destroy (decref) */
1116 yaz_mutex_enter(s->http_server->mutex);
1117 if (s->http_server->http_channel_freelist_max > 0 && s->http_server->http_channel_freelist_count > s->http_server->http_channel_freelist_max) {
1118 while ((s->next = s->http_server->http_channel_freelist)) {
1119 nmem_destroy(s->next->nmem);
1120 wrbuf_destroy(s->next->wrbuf);
1122 s->http_server->http_channel_freelist = s->http_server->http_channel_freelist->next;
1126 s->next = s->http_server->http_channel_freelist;
1127 s->http_server->http_channel_freelist = s;
1128 s->http_server->http_channel_freelist_count++;
1130 yaz_mutex_leave(s->http_server->mutex);
1132 http_server_destroy(http_server);
1135 closesocket(iochan_getfd(i));
1137 close(iochan_getfd(i));
1142 static struct http_channel *http_channel_create(http_server_t hs,
1144 struct conf_server *server)
1146 struct http_channel *r;
1148 yaz_mutex_enter(hs->mutex);
1149 r = hs->http_channel_freelist;
1151 hs->http_channel_freelist = r->next;
1152 hs->http_channel_freelist_count--;
1154 yaz_mutex_leave(hs->mutex);
1158 nmem_reset(r->nmem);
1159 wrbuf_rewind(r->wrbuf);
1163 r = xmalloc(sizeof(struct http_channel));
1164 r->nmem = nmem_create();
1165 r->wrbuf = wrbuf_alloc();
1167 http_server_incref(hs);
1168 r->http_server = hs;
1169 r->http_sessions = hs->http_sessions;
1170 assert(r->http_sessions);
1174 r->iqueue = r->oqueue = 0;
1175 r->state = Http_Idle;
1181 yaz_log(YLOG_WARN, "Invalid HTTP forward address");
1184 strcpy(r->addr, addr);
1190 /* Accept a new command connection */
1191 static void http_accept(IOCHAN i, int event)
1193 struct sockaddr_in addr;
1194 int fd = iochan_getfd(i);
1198 struct http_channel *ch;
1199 struct conf_server *server = iochan_getdata(i);
1202 if ((s = accept(fd, (struct sockaddr *) &addr, &len)) < 0)
1204 yaz_log(YLOG_WARN|YLOG_ERRNO, "accept");
1209 yaz_log(YLOG_DEBUG, "New command connection");
1210 c = iochan_create(s, http_io, EVENT_INPUT | EVENT_EXCEPT, "http_session_socket");
1212 ch = http_channel_create(server->http_server, inet_ntoa(addr.sin_addr),
1215 iochan_setdata(c, ch);
1216 iochan_add(server->iochan_man, c);
1219 /* Create a http-channel listener, syntax [host:]port */
1220 int http_init(const char *addr, struct conf_server *server)
1225 struct sockaddr_in myaddr;
1230 yaz_log(YLOG_LOG, "HTTP listener %s", addr);
1232 memset(&myaddr, 0, sizeof myaddr);
1233 myaddr.sin_family = AF_INET;
1234 pp = strchr(addr, ':');
1237 WRBUF w = wrbuf_alloc();
1240 wrbuf_write(w, addr, pp - addr);
1243 he = gethostbyname(wrbuf_cstr(w));
1247 yaz_log(YLOG_FATAL, "Unable to resolve '%s'", addr);
1250 memcpy(&myaddr.sin_addr.s_addr, he->h_addr_list[0], he->h_length);
1251 port = atoi(pp + 1);
1256 myaddr.sin_addr.s_addr = INADDR_ANY;
1259 myaddr.sin_port = htons(port);
1261 if (!(p = getprotobyname("tcp"))) {
1264 if ((l = socket(PF_INET, SOCK_STREAM, p->p_proto)) < 0)
1265 yaz_log(YLOG_FATAL|YLOG_ERRNO, "socket");
1266 if (setsockopt(l, SOL_SOCKET, SO_REUSEADDR, (char*)
1267 &one, sizeof(one)) < 0)
1270 if (bind(l, (struct sockaddr *) &myaddr, sizeof myaddr) < 0)
1272 yaz_log(YLOG_FATAL|YLOG_ERRNO, "bind");
1275 if (listen(l, SOMAXCONN) < 0)
1277 yaz_log(YLOG_FATAL|YLOG_ERRNO, "listen");
1281 server->http_server = http_server_create();
1283 server->http_server->listener_socket = l;
1285 c = iochan_create(l, http_accept, EVENT_INPUT | EVENT_EXCEPT, "http_server");
1286 iochan_setdata(c, server);
1288 iochan_add(server->iochan_man, c);
1292 void http_close_server(struct conf_server *server)
1294 /* break the event_loop (select) by closing down the HTTP listener sock */
1295 if (server->http_server->listener_socket)
1298 closesocket(server->http_server->listener_socket);
1300 close(server->http_server->listener_socket);
1305 void http_set_proxyaddr(const char *host, struct conf_server *server)
1310 WRBUF w = wrbuf_alloc();
1312 yaz_log(YLOG_LOG, "HTTP backend %s", host);
1314 p = strchr(host, ':');
1318 wrbuf_write(w, host, p - host);
1324 wrbuf_puts(w, host);
1326 if (!(he = gethostbyname(wrbuf_cstr(w))))
1328 fprintf(stderr, "Failed to lookup '%s'\n", wrbuf_cstr(w));
1333 server->http_server->proxy_addr = xmalloc(sizeof(struct sockaddr_in));
1334 server->http_server->proxy_addr->sin_family = he->h_addrtype;
1335 memcpy(&server->http_server->proxy_addr->sin_addr.s_addr,
1336 he->h_addr_list[0], he->h_length);
1337 server->http_server->proxy_addr->sin_port = htons(port);
1340 static void http_fire_observers(struct http_channel *c)
1342 http_channel_observer_t p = c->observers;
1345 p->destroy(p->data, c, p->data2);
1350 static void http_destroy_observers(struct http_channel *c)
1352 while (c->observers)
1354 http_channel_observer_t obs = c->observers;
1355 c->observers = obs->next;
1360 http_channel_observer_t http_add_observer(struct http_channel *c, void *data,
1361 http_channel_destroy_t des)
1363 http_channel_observer_t obs = xmalloc(sizeof(*obs));
1368 obs->next = c->observers;
1373 void http_remove_observer(http_channel_observer_t obs)
1375 struct http_channel *c = obs->chan;
1376 http_channel_observer_t found, *p = &c->observers;
1385 struct http_channel *http_channel_observer_chan(http_channel_observer_t obs)
1390 void http_observer_set_data2(http_channel_observer_t obs, void *data2)
1395 http_server_t http_server_create(void)
1397 http_server_t hs = xmalloc(sizeof(*hs));
1401 hs->http_sessions = 0;
1403 hs->http_channel_freelist = 0;
1404 hs->http_channel_freelist_count = 0;
1405 hs->http_channel_freelist_max = 10;
1407 hs->http_buf_freelist = 0;
1408 hs->http_buf_freelist_count = 0;
1409 hs->http_buf_freelist_max = 10;
1413 void http_server_destroy(http_server_t hs)
1419 yaz_mutex_enter(hs->mutex); /* OK: hs->mutex may be NULL */
1420 r = --(hs->ref_count);
1421 yaz_mutex_leave(hs->mutex);
1425 struct http_buf *b = hs->http_buf_freelist;
1426 struct http_channel *c = hs->http_channel_freelist;
1429 struct http_buf *b_next = b->next;
1435 struct http_channel *c_next = c->next;
1436 nmem_destroy(c->nmem);
1437 wrbuf_destroy(c->wrbuf);
1441 http_sessions_destroy(hs->http_sessions);
1442 xfree(hs->proxy_addr);
1443 yaz_mutex_destroy(&hs->mutex);
1449 void http_server_incref(http_server_t hs)
1452 yaz_mutex_enter(hs->mutex);
1454 yaz_mutex_leave(hs->mutex);
1457 void http_mutex_init(struct conf_server *server)
1461 assert(server->http_server->mutex == 0);
1462 pazpar2_mutex_create(&server->http_server->mutex, "http_server");
1463 server->http_server->http_sessions = http_sessions_create();
1469 * c-file-style: "Stroustrup"
1470 * indent-tabs-mode: nil
1472 * vim: shiftwidth=4 tabstop=8 expandtab