1 /* This file is part of Pazpar2.
2 Copyright (C) 2006-2009 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>
68 #define MAX_HTTP_HEADER 4096
71 #define strncasecmp _strnicmp
72 #define strcasecmp _stricmp
75 static void proxy_io(IOCHAN i, int event);
76 static struct http_channel *http_create(const char *addr,
77 struct conf_server *server);
78 static void http_destroy(IOCHAN i);
80 static struct http_buf *http_buf_freelist = 0; /* thread pr */
81 static struct http_channel *http_channel_freelist = 0; /* thread pr */
83 struct http_channel_observer_s {
86 http_channel_destroy_t destroy;
87 struct http_channel_observer_s *next;
88 struct http_channel *chan;
92 const char *http_lookup_header(struct http_header *header,
95 for (; header; header = header->next)
96 if (!strcasecmp(name, header->name))
101 static struct http_buf *http_buf_create(void)
105 if (http_buf_freelist)
107 r = http_buf_freelist;
108 http_buf_freelist = http_buf_freelist->next;
111 r = xmalloc(sizeof(struct http_buf));
118 static void http_buf_destroy(struct http_buf *b)
120 b->next = http_buf_freelist;
121 http_buf_freelist = b;
124 static void http_buf_destroy_queue(struct http_buf *b)
135 static struct http_buf *http_buf_bybuf(char *b, int len)
137 struct http_buf *res = 0;
138 struct http_buf **p = &res;
143 if (tocopy > HTTP_BUF_SIZE)
144 tocopy = HTTP_BUF_SIZE;
145 *p = http_buf_create();
146 memcpy((*p)->buf, b, tocopy);
155 // Add a (chain of) buffers to the end of an existing queue.
156 static void http_buf_enqueue(struct http_buf **queue, struct http_buf *b)
159 queue = &(*queue)->next;
163 static struct http_buf *http_buf_bywrbuf(WRBUF wrbuf)
165 // Heavens to Betsy (buf)!
166 return http_buf_bybuf(wrbuf_buf(wrbuf), wrbuf_len(wrbuf));
169 // Non-destructively collapse chain of buffers into a string (max *len)
171 static void http_buf_peek(struct http_buf *b, char *buf, int len)
174 while (b && rd < len)
176 int toread = len - rd;
179 memcpy(buf + rd, b->buf + b->offset, toread);
186 static int http_buf_size(struct http_buf *b)
189 for (; b; b = b->next)
194 // Ddestructively munch up to len from head of queue.
195 static int http_buf_read(struct http_buf **b, char *buf, int len)
198 while ((*b) && rd < len)
200 int toread = len - rd;
201 if (toread > (*b)->len)
203 memcpy(buf + rd, (*b)->buf + (*b)->offset, toread);
205 if (toread < (*b)->len)
208 (*b)->offset += toread;
213 struct http_buf *n = (*b)->next;
214 http_buf_destroy(*b);
222 // Buffers may overlap.
223 static void urldecode(char *i, char *o)
232 else if (*i == '%' && i[1] && i[2])
236 sscanf(i, "%2x", &v);
246 // Warning: Buffers may not overlap
247 void urlencode(const char *i, char *o)
251 if (strchr(" /:", *i))
253 sprintf(o, "%%%.2X", (int) *i);
263 void http_addheader(struct http_response *r, const char *name, const char *value)
265 struct http_channel *c = r->channel;
266 struct http_header *h = nmem_malloc(c->nmem, sizeof *h);
267 h->name = nmem_strdup(c->nmem, name);
268 h->value = nmem_strdup(c->nmem, value);
269 h->next = r->headers;
273 const char *http_argbyname(struct http_request *r, const char *name)
275 struct http_argument *p;
278 for (p = r->arguments; p; p = p->next)
279 if (!strcmp(p->name, name))
284 const char *http_headerbyname(struct http_header *h, const char *name)
286 for (; h; h = h->next)
287 if (!strcmp(h->name, name))
292 struct http_response *http_create_response(struct http_channel *c)
294 struct http_response *r = nmem_malloc(c->nmem, sizeof(*r));
295 strcpy(r->code, "200");
300 r->content_type = "text/xml";
305 static const char *next_crlf(const char *cp, size_t *skipped)
307 const char *next_cp = strchr(cp, '\n');
310 if (next_cp > cp && next_cp[-1] == '\r')
311 *skipped = next_cp - cp - 1;
313 *skipped = next_cp - cp;
319 // Check if buf contains a package (minus payload)
320 static int package_check(const char *buf, int sz)
328 const char *b = next_crlf(buf, &skipped);
332 // we did not find CRLF.. See if buffer is too large..
333 if (sz >= MAX_HTTP_HEADER-1)
334 return MAX_HTTP_HEADER-1; // yes. Return that (will fail later)
340 // CRLF CRLF , i.e. end of header
341 if (len + content_len <= sz)
342 return len + content_len;
346 // following first skip of \r\n so that we don't consider Method
347 if (!strncasecmp(buf, "Content-Length:", 15))
349 const char *cp = buf+15;
353 while (*cp && isdigit(*(const unsigned char *)cp))
354 content_len = content_len*10 + (*cp++ - '0');
355 if (content_len < 0) /* prevent negative offsets */
359 return 0; // incomplete request
362 // Check if we have a request. Return 0 or length
363 static int request_check(struct http_buf *queue)
365 char tmp[MAX_HTTP_HEADER];
367 // only peek at the header..
368 http_buf_peek(queue, tmp, MAX_HTTP_HEADER-1);
369 // still we only return non-zero if the complete request is received..
370 return package_check(tmp, http_buf_size(queue));
373 struct http_response *http_parse_response_buf(struct http_channel *c, const char *buf, int len)
375 char tmp[MAX_HTTP_HEADER];
376 struct http_response *r = http_create_response(c);
378 struct http_header **hp = &r->headers;
380 if (len >= MAX_HTTP_HEADER)
382 memcpy(tmp, buf, len);
383 for (p = tmp; *p && *p != ' '; p++) // Skip HTTP version
387 for (p2 = p; *p2 && *p2 != ' ' && p2 - p < 3; p2++)
388 r->code[p2 - p] = *p2;
389 if (!(p = strstr(tmp, "\r\n")))
394 if (!(p2 = strstr(p, "\r\n")))
396 if (p == p2) // End of headers
400 struct http_header *h = *hp = nmem_malloc(c->nmem, sizeof(*h));
401 char *value = strchr(p, ':');
405 h->name = nmem_strdup(c->nmem, p);
406 while (isspace(*(const unsigned char *) value))
408 if (value >= p2) // Empty header;
415 h->value = nmem_strdup(c->nmem, value);
424 static int http_parse_arguments(struct http_request *r, NMEM nmem,
427 const char *p2 = args;
431 struct http_argument *a;
432 const char *equal = strchr(p2, '=');
433 const char *eoa = strchr(p2, '&');
436 yaz_log(YLOG_WARN, "Expected '=' in argument");
440 eoa = equal + strlen(equal); // last argument
441 else if (equal > eoa)
443 yaz_log(YLOG_WARN, "Missing '&' in argument");
446 a = nmem_malloc(nmem, sizeof(struct http_argument));
447 a->name = nmem_strdupn(nmem, p2, equal - p2);
448 a->value = nmem_strdupn(nmem, equal+1, eoa - equal - 1);
449 urldecode(a->name, a->name);
450 urldecode(a->value, a->value);
451 a->next = r->arguments;
460 struct http_request *http_parse_request(struct http_channel *c,
461 struct http_buf **queue,
464 struct http_request *r = nmem_malloc(c->nmem, sizeof(*r));
466 char *start = nmem_malloc(c->nmem, len+1);
469 if (http_buf_read(queue, buf, len) < len)
471 yaz_log(YLOG_WARN, "http_buf_read < len (%d)", len);
481 for (p = buf, p2 = r->method; *p && *p != ' ' && p - buf < 19; p++)
485 yaz_log(YLOG_WARN, "Unexpected HTTP method in request");
490 if (!(buf = strchr(buf, ' ')))
492 yaz_log(YLOG_WARN, "Missing Request-URI in HTTP request");
496 if (!(p = strchr(buf, ' ')))
498 yaz_log(YLOG_WARN, "HTTP Request-URI not terminated (too long?)");
502 if ((p2 = strchr(buf, '?'))) // Do we have arguments?
504 r->path = nmem_strdup(c->nmem, buf);
507 r->search = nmem_strdup(c->nmem, p2);
509 http_parse_arguments(r, c->nmem, p2);
513 if (strncmp(buf, "HTTP/", 5))
514 strcpy(r->http_version, "1.0");
518 buf += 5; // strlen("HTTP/")
520 p = (char*) next_crlf(buf, &skipped);
521 if (!p || skipped < 3 || skipped > 5)
524 memcpy(r->http_version, buf, skipped);
525 r->http_version[skipped] = '\0';
528 strcpy(c->version, r->http_version);
535 p = (char *) next_crlf(buf, &skipped);
540 else if (skipped == 0)
548 char *n_v = nmem_malloc(c->nmem, skipped+1);
549 struct http_header *h = nmem_malloc(c->nmem, sizeof(*h));
551 memcpy(n_v, buf, skipped);
554 if (!(cp = strchr(n_v, ':')))
556 h->name = nmem_strdupn(c->nmem, n_v, cp - n_v);
560 h->value = nmem_strdup(c->nmem, cp);
561 h->next = r->headers;
567 // determine if we do keep alive
568 if (!strcmp(c->version, "1.0"))
570 const char *v = http_lookup_header(r->headers, "Connection");
571 if (v && !strcmp(v, "Keep-Alive"))
578 const char *v = http_lookup_header(r->headers, "Connection");
579 if (v && !strcmp(v, "close"))
584 if (buf < start + len)
586 const char *content_type = http_lookup_header(r->headers,
588 r->content_len = start + len - buf;
589 r->content_buf = buf;
591 if (!yaz_strcmp_del("application/x-www-form-urlencoded",
594 http_parse_arguments(r, c->nmem, r->content_buf);
600 static struct http_buf *http_serialize_response(struct http_channel *c,
601 struct http_response *r)
603 struct http_header *h;
605 wrbuf_rewind(c->wrbuf);
606 wrbuf_printf(c->wrbuf, "HTTP/%s %s %s\r\n", c->version, r->code, r->msg);
607 for (h = r->headers; h; h = h->next)
608 wrbuf_printf(c->wrbuf, "%s: %s\r\n", h->name, h->value);
611 wrbuf_printf(c->wrbuf, "Content-Length: %d\r\n", r->payload ?
612 (int) strlen(r->payload) : 0);
613 wrbuf_printf(c->wrbuf, "Content-Type: %s\r\n", r->content_type);
614 if (!strcmp(r->content_type, "text/xml"))
616 xmlDoc *doc = xmlParseMemory(r->payload, strlen(r->payload));
623 yaz_log(YLOG_WARN, "Sending non-wellformed "
624 "response (bug #1162");
625 yaz_log(YLOG_WARN, "payload: %s", r->payload);
629 wrbuf_puts(c->wrbuf, "\r\n");
632 wrbuf_puts(c->wrbuf, r->payload);
634 return http_buf_bywrbuf(c->wrbuf);
637 // Serialize a HTTP request
638 static struct http_buf *http_serialize_request(struct http_request *r)
640 struct http_channel *c = r->channel;
641 struct http_header *h;
643 wrbuf_rewind(c->wrbuf);
644 wrbuf_printf(c->wrbuf, "%s %s%s%s", r->method, r->path,
645 *r->search ? "?" : "", r->search);
647 wrbuf_printf(c->wrbuf, " HTTP/%s\r\n", r->http_version);
649 for (h = r->headers; h; h = h->next)
650 wrbuf_printf(c->wrbuf, "%s: %s\r\n", h->name, h->value);
652 wrbuf_puts(c->wrbuf, "\r\n");
655 wrbuf_write(c->wrbuf, r->content_buf, r->content_len);
658 yaz_log(YLOG_LOG, "WRITING TO PROXY:\n%s\n----",
659 wrbuf_cstr(c->wrbuf));
661 return http_buf_bywrbuf(c->wrbuf);
665 static int http_weshouldproxy(struct http_request *rq)
667 struct http_channel *c = rq->channel;
668 if (c->server->proxy_addr && !strstr(rq->path, "search.pz2"))
674 struct http_header * http_header_append(struct http_channel *ch,
675 struct http_header * hp,
679 struct http_header *hpnew = 0;
684 while (hp && hp->next)
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);
703 static int is_inprogress(void)
706 if (WSAGetLastError() == WSAEWOULDBLOCK)
709 if (errno == EINPROGRESS)
715 static void enable_nonblock(int sock)
719 flags = (flags & CS_FLAGS_BLOCKING) ? 0 : 1;
720 if (ioctlsocket(sock, FIONBIO, &flags) < 0)
721 yaz_log(YLOG_FATAL|YLOG_ERRNO, "ioctlsocket");
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");
730 static int http_proxy(struct http_request *rq)
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_port[16] = "";
737 struct conf_server *ser = c->server;
739 if (!p) // This is a new connection. Create a proxy channel
745 if (!(pe = getprotobyname("tcp"))) {
748 if ((sock = socket(PF_INET, SOCK_STREAM, pe->p_proto)) < 0)
750 yaz_log(YLOG_WARN|YLOG_ERRNO, "socket");
753 if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)
754 &one, sizeof(one)) < 0)
756 enable_nonblock(sock);
757 if (connect(sock, (struct sockaddr *) c->server->proxy_addr,
758 sizeof(*c->server->proxy_addr)) < 0)
760 if (!is_inprogress())
762 yaz_log(YLOG_WARN|YLOG_ERRNO, "Proxy connect");
766 p = xmalloc(sizeof(struct http_proxy));
769 p->first_response = 1;
771 // We will add EVENT_OUTPUT below
772 p->iochan = iochan_create(sock, proxy_io, EVENT_INPUT);
773 iochan_setdata(p->iochan, p);
774 pazpar2_add_channel(p->iochan);
777 // Do _not_ modify Host: header, just checking it's existence
779 if (!http_lookup_header(rq->headers, "Host"))
781 yaz_log(YLOG_WARN, "Failed to find Host header in proxy");
785 // Add new header about paraz2 version, host, remote client address, etc.
787 char server_via[128];
790 hp = http_header_append(c, hp,
791 "X-Pazpar2-Version", PACKAGE_VERSION);
792 hp = http_header_append(c, hp,
793 "X-Pazpar2-Server-Host", ser->host);
794 sprintf(server_port, "%d", ser->port);
795 hp = http_header_append(c, hp,
796 "X-Pazpar2-Server-Port", server_port);
797 yaz_snprintf(server_via, sizeof(server_via),
799 ser->host ? ser->host : "@",
800 server_port, PACKAGE_NAME, PACKAGE_VERSION);
801 hp = http_header_append(c, hp, "Via" , server_via);
802 hp = http_header_append(c, hp, "X-Forwarded-For", c->addr);
805 requestbuf = http_serialize_request(rq);
807 http_buf_enqueue(&p->oqueue, requestbuf);
808 iochan_setflag(p->iochan, EVENT_OUTPUT);
812 void http_send_response(struct http_channel *ch)
814 struct http_response *rs = ch->response;
818 hb = http_serialize_response(ch, rs);
821 yaz_log(YLOG_WARN, "Failed to serialize HTTP response");
822 http_destroy(ch->iochan);
826 http_buf_enqueue(&ch->oqueue, hb);
827 iochan_setflag(ch->iochan, EVENT_OUTPUT);
828 ch->state = Http_Idle;
832 static void http_error(struct http_channel *hc, int no, const char *msg)
834 struct http_response *rs = http_create_response(hc);
837 hc->keep_alive = 0; // not keeping this HTTP session alive
839 sprintf(rs->code, "%d", no);
841 rs->msg = nmem_strdup(hc->nmem, msg);
842 rs->payload = nmem_malloc(hc->nmem, 100);
843 yaz_snprintf(rs->payload, 99, "<error>HTTP Error %d: %s</error>\n",
845 http_send_response(hc);
848 static void http_io(IOCHAN i, int event)
850 struct http_channel *hc = iochan_getdata(i);
855 struct http_buf *htbuf;
858 htbuf = http_buf_create();
859 res = recv(iochan_getfd(i), htbuf->buf, HTTP_BUF_SIZE -1, 0);
860 if (res == -1 && errno == EAGAIN)
862 http_buf_destroy(htbuf);
867 http_buf_destroy(htbuf);
871 htbuf->buf[res] = '\0';
873 http_buf_enqueue(&hc->iqueue, htbuf);
877 if (hc->state == Http_Busy)
879 reqlen = request_check(hc->iqueue);
882 // we have a complete HTTP request
883 nmem_reset(hc->nmem);
884 if (!(hc->request = http_parse_request(hc, &hc->iqueue, reqlen)))
886 yaz_log(YLOG_WARN, "Failed to parse request");
887 http_error(hc, 400, "Bad Request");
891 yaz_log(YLOG_LOG, "Request: %s %s%s%s", hc->request->method,
893 *hc->request->search ? "?" : "",
894 hc->request->search);
895 if (hc->request->content_buf)
896 yaz_log(YLOG_LOG, "%s", hc->request->content_buf);
897 if (http_weshouldproxy(hc->request))
898 http_proxy(hc->request);
901 // Execute our business logic!
902 hc->state = Http_Busy;
910 struct http_buf *wb = hc->oqueue;
911 res = send(iochan_getfd(hc->iochan), wb->buf + wb->offset, wb->len, 0);
914 yaz_log(YLOG_WARN|YLOG_ERRNO, "write");
920 hc->oqueue = hc->oqueue->next;
921 http_buf_destroy(wb);
936 iochan_clearflag(i, EVENT_OUTPUT);
938 iochan_setevent(hc->iochan, EVENT_INPUT);
943 if (!hc->oqueue && hc->proxy && !hc->proxy->iochan)
944 http_destroy(i); // Server closed; we're done
947 yaz_log(YLOG_WARN, "Unexpected event on connection");
952 // Handles I/O on a client connection to a backend web server (proxy mode)
953 static void proxy_io(IOCHAN pi, int event)
955 struct http_proxy *pc = iochan_getdata(pi);
956 struct http_channel *hc = pc->channel;
961 struct http_buf *htbuf;
964 htbuf = http_buf_create();
965 res = recv(iochan_getfd(pi), htbuf->buf, HTTP_BUF_SIZE -1, 0);
966 if (res == 0 || (res < 0 && !is_inprogress()))
970 yaz_log(YLOG_WARN, "Proxy read came up short");
971 // Close channel and alert client HTTP channel that we're gone
972 http_buf_destroy(htbuf);
974 closesocket(iochan_getfd(pi));
976 close(iochan_getfd(pi));
983 http_destroy(hc->iochan);
989 htbuf->buf[res] = '\0';
992 // Write any remaining payload
993 if (htbuf->len - htbuf->offset > 0)
994 http_buf_enqueue(&hc->oqueue, htbuf);
996 iochan_setflag(hc->iochan, EVENT_OUTPUT);
999 if (!(htbuf = pc->oqueue))
1001 iochan_clearflag(pi, EVENT_OUTPUT);
1004 res = send(iochan_getfd(pi), htbuf->buf + htbuf->offset, htbuf->len, 0);
1007 yaz_log(YLOG_WARN|YLOG_ERRNO, "write");
1008 http_destroy(hc->iochan);
1011 if (res == htbuf->len)
1013 struct http_buf *np = htbuf->next;
1014 http_buf_destroy(htbuf);
1020 htbuf->offset += res;
1024 iochan_setflags(pi, EVENT_INPUT); // Turns off output flag
1028 yaz_log(YLOG_WARN, "Unexpected event on connection");
1029 http_destroy(hc->iochan);
1033 static void http_fire_observers(struct http_channel *c);
1034 static void http_destroy_observers(struct http_channel *c);
1037 static void http_destroy(IOCHAN i)
1039 struct http_channel *s = iochan_getdata(i);
1043 if (s->proxy->iochan)
1046 closesocket(iochan_getfd(s->proxy->iochan));
1048 close(iochan_getfd(s->proxy->iochan));
1050 iochan_destroy(s->proxy->iochan);
1052 http_buf_destroy_queue(s->proxy->oqueue);
1055 http_buf_destroy_queue(s->iqueue);
1056 http_buf_destroy_queue(s->oqueue);
1057 http_fire_observers(s);
1058 http_destroy_observers(s);
1059 s->next = http_channel_freelist;
1060 http_channel_freelist = s;
1062 closesocket(iochan_getfd(i));
1064 close(iochan_getfd(i));
1069 static struct http_channel *http_create(const char *addr,
1070 struct conf_server *server)
1072 struct http_channel *r = http_channel_freelist;
1076 http_channel_freelist = r->next;
1077 nmem_reset(r->nmem);
1078 wrbuf_rewind(r->wrbuf);
1082 r = xmalloc(sizeof(struct http_channel));
1083 r->nmem = nmem_create();
1084 r->wrbuf = wrbuf_alloc();
1089 r->iqueue = r->oqueue = 0;
1090 r->state = Http_Idle;
1096 yaz_log(YLOG_WARN, "Invalid HTTP forward address");
1099 strcpy(r->addr, addr);
1105 /* Accept a new command connection */
1106 static void http_accept(IOCHAN i, int event)
1108 struct sockaddr_in addr;
1109 int fd = iochan_getfd(i);
1113 struct http_channel *ch;
1114 struct conf_server *server = iochan_getdata(i);
1117 if ((s = accept(fd, (struct sockaddr *) &addr, &len)) < 0)
1119 yaz_log(YLOG_WARN|YLOG_ERRNO, "accept");
1124 yaz_log(YLOG_DEBUG, "New command connection");
1125 c = iochan_create(s, http_io, EVENT_INPUT | EVENT_EXCEPT);
1127 ch = http_create(inet_ntoa(addr.sin_addr), server);
1129 iochan_setdata(c, ch);
1131 pazpar2_add_channel(c);
1134 /* Create a http-channel listener, syntax [host:]port */
1135 int http_init(const char *addr, struct conf_server *server)
1140 struct sockaddr_in myaddr;
1145 yaz_log(YLOG_LOG, "HTTP listener %s", addr);
1147 memset(&myaddr, 0, sizeof myaddr);
1148 myaddr.sin_family = AF_INET;
1149 pp = strchr(addr, ':');
1152 WRBUF w = wrbuf_alloc();
1155 wrbuf_write(w, addr, pp - addr);
1158 he = gethostbyname(wrbuf_cstr(w));
1162 yaz_log(YLOG_FATAL, "Unable to resolve '%s'", addr);
1165 memcpy(&myaddr.sin_addr.s_addr, he->h_addr_list[0], he->h_length);
1166 port = atoi(pp + 1);
1171 myaddr.sin_addr.s_addr = INADDR_ANY;
1174 myaddr.sin_port = htons(port);
1176 if (!(p = getprotobyname("tcp"))) {
1179 if ((l = socket(PF_INET, SOCK_STREAM, p->p_proto)) < 0)
1180 yaz_log(YLOG_FATAL|YLOG_ERRNO, "socket");
1181 if (setsockopt(l, SOL_SOCKET, SO_REUSEADDR, (char*)
1182 &one, sizeof(one)) < 0)
1185 if (bind(l, (struct sockaddr *) &myaddr, sizeof myaddr) < 0)
1187 yaz_log(YLOG_FATAL|YLOG_ERRNO, "bind");
1190 if (listen(l, SOMAXCONN) < 0)
1192 yaz_log(YLOG_FATAL|YLOG_ERRNO, "listen");
1196 server->listener_socket = l;
1198 c = iochan_create(l, http_accept, EVENT_INPUT | EVENT_EXCEPT);
1199 iochan_setdata(c, server);
1200 pazpar2_add_channel(c);
1204 void http_close_server(struct conf_server *server)
1206 /* break the event_loop (select) by closing down the HTTP listener sock */
1207 if (server->listener_socket)
1210 closesocket(server->listener_socket);
1212 close(server->listener_socket);
1217 void http_set_proxyaddr(const char *host, struct conf_server *server)
1222 WRBUF w = wrbuf_alloc();
1224 yaz_log(YLOG_LOG, "HTTP backend %s", host);
1226 p = strchr(host, ':');
1230 wrbuf_write(w, host, p - host);
1236 wrbuf_puts(w, host);
1238 if (!(he = gethostbyname(wrbuf_cstr(w))))
1240 fprintf(stderr, "Failed to lookup '%s'\n", wrbuf_cstr(w));
1245 server->proxy_addr = xmalloc(sizeof(struct sockaddr_in));
1246 server->proxy_addr->sin_family = he->h_addrtype;
1247 memcpy(&server->proxy_addr->sin_addr.s_addr, he->h_addr_list[0], he->h_length);
1248 server->proxy_addr->sin_port = htons(port);
1251 static void http_fire_observers(struct http_channel *c)
1253 http_channel_observer_t p = c->observers;
1256 p->destroy(p->data, c, p->data2);
1261 static void http_destroy_observers(struct http_channel *c)
1263 while (c->observers)
1265 http_channel_observer_t obs = c->observers;
1266 c->observers = obs->next;
1271 http_channel_observer_t http_add_observer(struct http_channel *c, void *data,
1272 http_channel_destroy_t des)
1274 http_channel_observer_t obs = xmalloc(sizeof(*obs));
1279 obs->next = c->observers;
1284 void http_remove_observer(http_channel_observer_t obs)
1286 struct http_channel *c = obs->chan;
1287 http_channel_observer_t found, *p = &c->observers;
1296 struct http_channel *http_channel_observer_chan(http_channel_observer_t obs)
1301 void http_observer_set_data2(http_channel_observer_t obs, void *data2)
1310 * c-file-style: "Stroustrup"
1311 * indent-tabs-mode: nil
1313 * vim: shiftwidth=4 tabstop=8 expandtab