X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=src%2Fhttp.c;h=9b9d4380f8144392dab8058d9ed79359bfed2d5c;hb=9864b5ebf2fda284dd208c64192a652b5e799cd9;hp=340808997dee3d73570d718573dbd7ddcd89566b;hpb=00114b899c187399eafbaa3cd4bbf16bd0bf467a;p=pazpar2-moved-to-github.git

diff --git a/src/http.c b/src/http.c
index 3408089..9b9d438 100644
--- a/src/http.c
+++ b/src/http.c
@@ -1,5 +1,22 @@
-/*
- * $Id: http.c,v 1.9 2007-01-10 11:56:10 adam Exp $
+/* $Id: http.c,v 1.35 2007-06-26 13:01:07 adam Exp $
+   Copyright (c) 2006-2007, Index Data.
+
+This file is part of Pazpar2.
+
+Pazpar2 is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+Pazpar2 is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with Pazpar2; see the file LICENSE.  If not, write to the
+Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA.
  */
 
 #include <stdio.h>
@@ -14,17 +31,21 @@
 #include <netdb.h>
 #include <errno.h>
 #include <assert.h>
+#include <string.h>
 
 #if HAVE_CONFIG_H
 #include <cconfig.h>
 #endif
 
 #include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
 
 #include <yaz/yaz-util.h>
 #include <yaz/comstack.h>
-#include <netdb.h>
+#include <yaz/nmem.h>
 
+#include "cconfig.h"
 #include "util.h"
 #include "eventl.h"
 #include "pazpar2.h"
@@ -32,16 +53,23 @@
 #include "http_command.h"
 
 static void proxy_io(IOCHAN i, int event);
-static struct http_channel *http_create(void);
+static struct http_channel *http_create(const char *addr);
 static void http_destroy(IOCHAN i);
 
-extern IOCHAN channel_list;
-
-static struct sockaddr_in *proxy_addr = 0; // If this is set, we proxy normal HTTP requests
+// If this is set, we proxy normal HTTP requests
+static struct sockaddr_in *proxy_addr = 0; 
 static char proxy_url[256] = "";
+static char myurl[256] = "";
 static struct http_buf *http_buf_freelist = 0;
 static struct http_channel *http_channel_freelist = 0;
 
+struct http_channel_observer_s {
+    void *data;
+    void (*destroy)(void *data, struct http_channel *chan);
+    struct http_channel_observer_s *next;
+    struct http_channel *chan;
+};
+
 static struct http_buf *http_buf_create()
 {
     struct http_buf *r;
@@ -167,7 +195,8 @@ static int http_buf_read(struct http_buf **b, char *buf, int len)
     return rd;
 }
 
-void static urldecode(char *i, char *o)
+// Buffers may overlap.
+static void urldecode(char *i, char *o)
 {
     while (*i)
     {
@@ -189,6 +218,23 @@ void static urldecode(char *i, char *o)
     *o = '\0';
 }
 
+// Warning: Buffers may not overlap
+void urlencode(const char *i, char *o)
+{
+    while (*i)
+    {
+        if (strchr(" /:", *i))
+        {
+            sprintf(o, "%%%.2X", (int) *i);
+            o += 3;
+        }
+        else
+            *(o++) = *i;
+        i++;
+    }
+    *o = '\0';
+}
+
 void http_addheader(struct http_response *r, const char *name, const char *value)
 {
     struct http_channel *c = r->channel;
@@ -210,12 +256,11 @@ char *http_argbyname(struct http_request *r, char *name)
     return 0;
 }
 
-char *http_headerbyname(struct http_request *r, char *name)
+char *http_headerbyname(struct http_header *h, char *name)
 {
-    struct http_header *p;
-    for (p = r->headers; p; p = p->next)
-        if (!strcmp(p->name, name))
-            return p->value;
+    for (; h; h = h->next)
+        if (!strcmp(h->name, name))
+            return h->value;
     return 0;
 }
 
@@ -230,16 +275,10 @@ struct http_response *http_create_response(struct http_channel *c)
     return r;
 }
 
-// Check if we have a complete request. Return 0 or length (including trailing newline)
-// FIXME: Does not deal gracefully with requests carrying payload
-// but this is kind of OK since we will reject anything other than an empty GET
-static int request_check(struct http_buf *queue)
+// Check if buf contains a package (minus payload)
+static int package_check(const char *buf)
 {
-    char tmp[4096];
     int len = 0;
-    char *buf = tmp;
-
-    http_buf_peek(queue, tmp, 4096);
     while (*buf) // Check if we have a sequence of lines terminated by an empty line
     {
         char *b = strstr(buf, "\r\n");
@@ -255,8 +294,72 @@ static int request_check(struct http_buf *queue)
     return 0;
 }
 
-struct http_request *http_parse_request(struct http_channel *c, struct http_buf **queue,
-        int len)
+// Check if we have a request. Return 0 or length
+// (including trailing CRNL) FIXME: Does not deal gracefully with requests
+// carrying payload but this is kind of OK since we will reject anything
+// other than an empty GET
+static int request_check(struct http_buf *queue)
+{
+    char tmp[4096];
+
+    http_buf_peek(queue, tmp, 4096);
+    return package_check(tmp);
+}
+
+struct http_response *http_parse_response_buf(struct http_channel *c, const char *buf, int len)
+{
+    char tmp[4096];
+    struct http_response *r = http_create_response(c);
+    char *p, *p2;
+    struct http_header **hp = &r->headers;
+
+    if (len >= 4096)
+        return 0;
+    memcpy(tmp, buf, len);
+    for (p = tmp; *p && *p != ' '; p++) // Skip HTTP version
+        ;
+    p++;
+    // Response code
+    for (p2 = p; *p2 && *p2 != ' ' && p2 - p < 3; p2++)
+        r->code[p2 - p] = *p2;
+    if (!(p = strstr(tmp, "\r\n")))
+        return 0;
+    p += 2;
+    while (*p)
+    {
+        if (!(p2 = strstr(p, "\r\n")))
+            return 0;
+        if (p == p2) // End of headers
+            break;
+        else
+        {
+            struct http_header *h = *hp = nmem_malloc(c->nmem, sizeof(*h));
+            char *value = strchr(p, ':');
+            if (!value)
+                return 0;
+            *(value++) = '\0';
+            h->name = nmem_strdup(c->nmem, p);
+            while (isspace(*value))
+                value++;
+            if (value >= p2)  // Empty header;
+            {
+                h->value = "";
+                p = p2 + 2;
+                continue;
+            }
+            *p2 = '\0';
+            h->value = nmem_strdup(c->nmem, value);
+            h->next = 0;
+            hp = &h->next;
+            p = p2 + 2;
+        }
+    }
+    return r;
+}
+
+struct http_request *http_parse_request(struct http_channel *c,
+                                        struct http_buf **queue,
+                                        int len)
 {
     struct http_request *r = nmem_malloc(c->nmem, sizeof(*r));
     char *p, *p2;
@@ -318,6 +421,7 @@ struct http_request *http_parse_request(struct http_channel *c, struct http_buf
             a = nmem_malloc(c->nmem, sizeof(struct http_argument));
             *(equal++) = '\0';
             a->name = nmem_strdup(c->nmem, p2);
+            urldecode(a->name, a->name);
             urldecode(equal, equal);
             a->value = nmem_strdup(c->nmem, equal);
             a->next = r->arguments;
@@ -373,7 +477,6 @@ struct http_request *http_parse_request(struct http_channel *c, struct http_buf
     return r;
 }
 
-
 static struct http_buf *http_serialize_response(struct http_channel *c,
         struct http_response *r)
 {
@@ -383,8 +486,26 @@ static struct http_buf *http_serialize_response(struct http_channel *c,
     wrbuf_printf(c->wrbuf, "HTTP/1.1 %s %s\r\n", r->code, r->msg);
     for (h = r->headers; h; h = h->next)
         wrbuf_printf(c->wrbuf, "%s: %s\r\n", h->name, h->value);
-    wrbuf_printf(c->wrbuf, "Content-length: %d\r\n", r->payload ? (int) strlen(r->payload) : 0);
-    wrbuf_printf(c->wrbuf, "Content-type: text/xml\r\n");
+    if (r->payload)
+    {
+        wrbuf_printf(c->wrbuf, "Content-length: %d\r\n", r->payload ?
+                (int) strlen(r->payload) : 0);
+        wrbuf_printf(c->wrbuf, "Content-type: text/xml\r\n");
+        if (1)
+        {
+            xmlDoc *doc = xmlParseMemory(r->payload, strlen(r->payload));
+            if (doc)
+            {
+                xmlFreeDoc(doc);
+            }
+            else
+            {
+                yaz_log(YLOG_WARN, "Sending non-wellformed "
+                        "response (bug #1162");
+                yaz_log(YLOG_WARN, "payload: %s", r->payload);
+            }
+        }
+    }
     wrbuf_puts(c->wrbuf, "\r\n");
 
     if (r->payload)
@@ -431,12 +552,46 @@ static int http_weshouldproxy(struct http_request *rq)
     return 0;
 }
 
+
+struct http_header * http_header_append(struct http_channel *ch, 
+                                        struct http_header * hp, 
+                                        const char *name, 
+                                        const char *value)
+{
+    struct http_header *hpnew = 0; 
+
+    if (!hp | !ch)
+        return 0;
+
+    while (hp && hp->next)
+        hp = hp->next;
+
+    if(name && strlen(name)&& value && strlen(value)){
+        hpnew = nmem_malloc(ch->nmem, sizeof *hpnew);
+        hpnew->name = nmem_strdup(ch->nmem, name);
+        hpnew->value = nmem_strdup(ch->nmem, value);
+        
+        hpnew->next = 0;
+        hp->next = hpnew;
+        hp = hp->next;
+        
+        return hpnew;
+    }
+
+    return hp;
+}
+
+    
+
 static int http_proxy(struct http_request *rq)
 {
     struct http_channel *c = rq->channel;
     struct http_proxy *p = c->proxy;
     struct http_header *hp;
     struct http_buf *requestbuf;
+    char server_via[128] = "";
+    char server_port[16] = "";
+    struct conf_server *ser = global_parameters.server;
 
     if (!p) // This is a new connection. Create a proxy channel
     {
@@ -460,7 +615,8 @@ static int http_proxy(struct http_request *rq)
             yaz_log(YLOG_FATAL|YLOG_ERRNO, "fcntl");
         if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0)
             yaz_log(YLOG_FATAL|YLOG_ERRNO, "fcntl2");
-        if (connect(sock, (struct sockaddr *) proxy_addr, sizeof(*proxy_addr)) < 0)
+        if (connect(sock, (struct sockaddr *) proxy_addr, 
+                    sizeof(*proxy_addr)) < 0)
             if (errno != EINPROGRESS)
             {
                 yaz_log(YLOG_WARN|YLOG_ERRNO, "Proxy connect");
@@ -470,15 +626,15 @@ static int http_proxy(struct http_request *rq)
         p = xmalloc(sizeof(struct http_proxy));
         p->oqueue = 0;
         p->channel = c;
+        p->first_response = 1;
         c->proxy = p;
         // We will add EVENT_OUTPUT below
         p->iochan = iochan_create(sock, proxy_io, EVENT_INPUT);
         iochan_setdata(p->iochan, p);
-        p->iochan->next = channel_list;
-        channel_list = p->iochan;
+        pazpar2_add_channel(p->iochan);
     }
 
-    // Modify Host: header
+    // Do _not_ modify Host: header, just checking it's existence
     for (hp = rq->headers; hp; hp = hp->next)
         if (!strcmp(hp->name, "Host"))
             break;
@@ -487,7 +643,23 @@ static int http_proxy(struct http_request *rq)
         yaz_log(YLOG_WARN, "Failed to find Host header in proxy");
         return -1;
     }
-    hp->value = nmem_strdup(c->nmem, proxy_url);
+    
+    // Add new header about paraz2 version, host, remote client address, etc.
+    {
+        hp = rq->headers;
+        hp = http_header_append(c, hp, 
+                                "X-Pazpar2-Version", PACKAGE_VERSION);
+        hp = http_header_append(c, hp, 
+                                "X-Pazpar2-Server-Host", ser->host);
+        sprintf(server_port, "%d",  ser->port);
+        hp = http_header_append(c, hp, 
+                                "X-Pazpar2-Server-Port", server_port);
+        sprintf(server_via,  "1.1 %s:%s (%s/%s)",  
+                ser->host, server_port, PACKAGE_NAME, PACKAGE_VERSION);
+        hp = http_header_append(c, hp, "Via" , server_via);
+        hp = http_header_append(c, hp, "X-Forwarded-For", c->addr);
+    }
+    
     requestbuf = http_serialize_request(rq);
     http_buf_enqueue(&p->oqueue, requestbuf);
     iochan_setflag(p->iochan, EVENT_OUTPUT);
@@ -537,12 +709,9 @@ static void http_io(IOCHAN i, int event)
                 http_destroy(i);
                 return;
             }
-            if (res > 0)
-            {
-                htbuf->buf[res] = '\0';
-                htbuf->len = res;
-                http_buf_enqueue(&hc->iqueue, htbuf);
-            }
+            htbuf->buf[res] = '\0';
+            htbuf->len = res;
+            http_buf_enqueue(&hc->iqueue, htbuf);
 
             if (hc->state == Http_Busy)
                 return;
@@ -622,6 +791,25 @@ static void http_io(IOCHAN i, int event)
     }
 }
 
+#ifdef GAGA
+// If this hostname contains our proxy host as a prefix, replace with myurl
+static char *sub_hostname(struct http_channel *c, char *buf)
+{
+    char tmp[1024];
+    if (strlen(buf) > 1023)
+        return buf;
+    if (strncmp(buf, "http://", 7))
+        return buf;
+    if (!strncmp(buf + 7, proxy_url, strlen(proxy_url)))
+    {
+        strcpy(tmp, myurl);
+        strcat(tmp, buf + strlen(proxy_url) + 7);
+        return nmem_strdup(c->nmem, tmp);
+    }
+    return buf;
+}
+#endif
+
 // Handles I/O on a client connection to a backend web server (proxy mode)
 static void proxy_io(IOCHAN pi, int event)
 {
@@ -656,8 +844,38 @@ static void proxy_io(IOCHAN pi, int event)
             else
             {
                 htbuf->buf[res] = '\0';
+                htbuf->offset = 0;
                 htbuf->len = res;
-                http_buf_enqueue(&hc->oqueue, htbuf);
+#ifdef GAGA
+                if (pc->first_response) // Check if this is a redirect
+                {
+                    int len;
+                    if ((len = package_check(htbuf->buf)))
+                    {
+                        struct http_response *res = http_parse_response_buf(hc, htbuf->buf, len);
+                        if (res)
+                        {
+                            struct http_header *h;
+                            for (h = res->headers; h; h = h->next)
+                                if (!strcmp(h->name, "Location"))
+                                {
+                                    // We found a location header. Rewrite it.
+                                    struct http_buf *buf;
+                                    h->value = sub_hostname(hc, h->value);
+                                    buf = http_serialize_response(hc, res);
+                                    yaz_log(YLOG_LOG, "Proxy rewrite");
+                                    http_buf_enqueue(&hc->oqueue, buf);
+                                    htbuf->offset = len;
+                                    break;
+                                }
+                        }
+                    }
+                    pc->first_response = 0;
+                }
+#endif
+                // Write any remaining payload
+                if (htbuf->len - htbuf->offset > 0)
+                    http_buf_enqueue(&hc->oqueue, htbuf);
             }
             iochan_setflag(hc->iochan, EVENT_OUTPUT);
             break;
@@ -696,6 +914,9 @@ static void proxy_io(IOCHAN pi, int event)
     }
 }
 
+static void http_fire_observers(struct http_channel *c);
+static void http_destroy_observers(struct http_channel *c);
+
 // Cleanup channel
 static void http_destroy(IOCHAN i)
 {
@@ -711,13 +932,17 @@ static void http_destroy(IOCHAN i)
         http_buf_destroy_queue(s->proxy->oqueue);
         xfree(s->proxy);
     }
+    http_buf_destroy_queue(s->iqueue);
+    http_buf_destroy_queue(s->oqueue);
+    http_fire_observers(s);
+    http_destroy_observers(s);
     s->next = http_channel_freelist;
     http_channel_freelist = s;
     close(iochan_getfd(i));
     iochan_destroy(i);
 }
 
-static struct http_channel *http_create(void)
+static struct http_channel *http_create(const char *addr)
 {
     struct http_channel *r = http_channel_freelist;
 
@@ -739,6 +964,13 @@ static struct http_channel *http_create(void)
     r->state = Http_Idle;
     r->request = 0;
     r->response = 0;
+    if (!addr)
+    {
+        yaz_log(YLOG_WARN, "Invalid HTTP forward address");
+        exit(1);
+    }
+    strcpy(r->addr, addr);
+    r->observers = 0;
     return r;
 }
 
@@ -767,13 +999,12 @@ static void http_accept(IOCHAN i, int event)
 
     yaz_log(YLOG_DEBUG, "New command connection");
     c = iochan_create(s, http_io, EVENT_INPUT | EVENT_EXCEPT);
-
-    ch = http_create();
+    
+    ch = http_create(inet_ntoa(addr.sin_addr));
     ch->iochan = c;
     iochan_setdata(c, ch);
 
-    c->next = channel_list;
-    channel_list = c;
+    pazpar2_add_channel(c);
 }
 
 /* Create a http-channel listener, syntax [host:]port */
@@ -787,7 +1018,7 @@ void http_init(const char *addr)
     const char *pp;
     int port;
 
-    yaz_log(YLOG_LOG, "HTTP listener is %s", addr);
+    yaz_log(YLOG_LOG, "HTTP listener %s", addr);
 
     memset(&myaddr, 0, sizeof myaddr);
     myaddr.sin_family = AF_INET;
@@ -800,19 +1031,25 @@ void http_init(const char *addr)
 
         strncpy(hostname, addr, len);
         hostname[len] = '\0';
-        if (!(he = gethostbyname(hostname)))
-        {
+        if (!(he = gethostbyname(hostname))){
             yaz_log(YLOG_FATAL, "Unable to resolve '%s'", hostname);
             exit(1);
         }
+        
         memcpy(&myaddr.sin_addr.s_addr, he->h_addr_list[0], he->h_length);
         port = atoi(pp + 1);
+
+        yaz_log(YLOG_LOG, "HTTP address  %s:%d", 
+                "" == he->h_addr_list[0] ? he->h_addr_list[0] : "127.0.0.1" , 
+                    port);
+
     }
     else
     {
         port = atoi(addr);
         myaddr.sin_addr.s_addr = INADDR_ANY;
     }
+
     myaddr.sin_port = htons(port);
 
     if (!(p = getprotobyname("tcp"))) {
@@ -825,24 +1062,31 @@ void http_init(const char *addr)
         abort();
 
     if (bind(l, (struct sockaddr *) &myaddr, sizeof myaddr) < 0) 
+    {
         yaz_log(YLOG_FATAL|YLOG_ERRNO, "bind");
+        exit(1);
+    }
     if (listen(l, SOMAXCONN) < 0) 
+    {
         yaz_log(YLOG_FATAL|YLOG_ERRNO, "listen");
+        exit(1);
+    }
 
     c = iochan_create(l, http_accept, EVENT_INPUT | EVENT_EXCEPT);
-    c->next = channel_list;
-    channel_list = c;
+    pazpar2_add_channel(c);
 }
 
-void http_set_proxyaddr(char *host)
+void http_set_proxyaddr(char *host, char *base_url)
 {
     char *p;
     int port;
     struct hostent *he;
 
+    strcpy(myurl, base_url);
     strcpy(proxy_url, host);
     p = strchr(host, ':');
     yaz_log(YLOG_DEBUG, "Proxying for %s", host);
+    yaz_log(YLOG_LOG, "HTTP backend  %s", proxy_url);
     if (p) {
         port = atoi(p + 1);
         *p = '\0';
@@ -860,6 +1104,55 @@ void http_set_proxyaddr(char *host)
     proxy_addr->sin_port = htons(port);
 }
 
+static void http_fire_observers(struct http_channel *c)
+{
+    http_channel_observer_t p = c->observers;
+    while (p)
+    {
+        p->destroy(p->data, c);
+        p = p->next;
+    }
+}
+
+static void http_destroy_observers(struct http_channel *c)
+{
+    while (c->observers)
+    {
+        http_channel_observer_t obs = c->observers;
+        c->observers = obs->next;
+        xfree(obs);
+    }
+}
+
+http_channel_observer_t http_add_observer(struct http_channel *c, void *data,
+                                          http_channel_destroy_t des)
+{
+    http_channel_observer_t obs = xmalloc(sizeof(*obs));
+    obs->chan = c;
+    obs->data = data;
+    obs->destroy= des;
+    obs->next = c->observers;
+    c->observers = obs;
+    return obs;
+}
+
+void http_remove_observer(http_channel_observer_t obs)
+{
+    struct http_channel *c = obs->chan;
+    http_channel_observer_t found, *p = &c->observers;
+    while (*p != obs)
+        p = &(*p)->next;
+    found = *p;
+    assert(found);
+    *p = (*p)->next;
+    xfree(found);
+}
+
+struct http_channel *http_channel_observer_chan(http_channel_observer_t obs)
+{
+    return obs->chan;
+}
+
 /*
  * Local variables:
  * c-basic-offset: 4