X-Git-Url: http://jsfdemo.indexdata.com/?a=blobdiff_plain;f=src%2Fhttp.c;h=c8533df092e66a546d91e491edf9cb5166b25af2;hb=0ff1a97b2a69905755b9adb24a474d30f1c52150;hp=291f0d9920d3bf4698aeaf5c6cddce572f92ca0b;hpb=a567f55ee47da94c337b232a3848d1c8bab254b2;p=pazpar2-moved-to-github.git

diff --git a/src/http.c b/src/http.c
index 291f0d9..c8533df 100644
--- a/src/http.c
+++ b/src/http.c
@@ -1,5 +1,22 @@
-/*
- * $Id: http.c,v 1.10 2007-02-05 16:15:41 quinn Exp $
+/* $Id: http.c,v 1.36 2007-07-03 10:10:14 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,17 +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;
@@ -168,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)
     {
@@ -190,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;
@@ -312,8 +357,9 @@ struct http_response *http_parse_response_buf(struct http_channel *c, const char
     return r;
 }
 
-struct http_request *http_parse_request(struct http_channel *c, struct http_buf **queue,
-        int len)
+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;
@@ -321,10 +367,15 @@ struct http_request *http_parse_request(struct http_channel *c, struct http_buf
     char *buf = tmp;
 
     if (len > 4096)
+    {
+        yaz_log(YLOG_WARN, "http_parse_request len > 4096 (%d)", len);
         return 0;
+    }
     if (http_buf_read(queue, buf, len) < len)
+    {
+        yaz_log(YLOG_WARN, "http_buf_read < len 4096 (%d)", len);
         return 0;
-
+    }
     r->search = "";
     r->channel = c;
     r->arguments = 0;
@@ -375,6 +426,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;
@@ -390,7 +442,10 @@ struct http_request *http_parse_request(struct http_channel *c, struct http_buf
     {
         buf += 5;
         if (!(p = strstr(buf, "\r\n")))
+        {
+            yaz_log(YLOG_WARN, "Did not see \\r\\n (1)");
             return 0;
+        }
         *(p++) = '\0';
         p++;
         strcpy(r->http_version, buf);
@@ -402,7 +457,10 @@ struct http_request *http_parse_request(struct http_channel *c, struct http_buf
     while (*buf)
     {
         if (!(p = strstr(buf, "\r\n")))
+        {
+            yaz_log(YLOG_WARN, "Did not see \\r\\n (2)");
             return 0;
+        }
         if (p == buf)
             break;
         else
@@ -444,6 +502,20 @@ static struct http_buf *http_serialize_response(struct http_channel *c,
         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");
 
@@ -491,12 +563,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
     {
@@ -520,7 +626,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");
@@ -535,11 +642,10 @@ static int http_proxy(struct http_request *rq)
         // 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;
@@ -548,7 +654,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);
@@ -598,12 +720,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;
@@ -683,6 +802,7 @@ 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)
 {
@@ -699,6 +819,7 @@ static char *sub_hostname(struct http_channel *c, char *buf)
     }
     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)
@@ -734,8 +855,9 @@ static void proxy_io(IOCHAN pi, int event)
             else
             {
                 htbuf->buf[res] = '\0';
+                htbuf->offset = 0;
                 htbuf->len = res;
-                int offset = 0;
+#ifdef GAGA
                 if (pc->first_response) // Check if this is a redirect
                 {
                     int len;
@@ -752,24 +874,19 @@ static void proxy_io(IOCHAN pi, int event)
                                     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);
-                                    offset = len;
+                                    htbuf->offset = len;
                                     break;
                                 }
                         }
                     }
                     pc->first_response = 0;
                 }
+#endif
                 // Write any remaining payload
-                if (htbuf->len - offset > 0)
-                {
-                    if (offset > 0)
-                    {
-                        memmove(htbuf->buf, htbuf->buf + offset, htbuf->len - offset);
-                        htbuf->len -= offset;
-                    }
-                    http_buf_enqueue(&hc->oqueue, htbuf + offset);
-                }
+                if (htbuf->len - htbuf->offset > 0)
+                    http_buf_enqueue(&hc->oqueue, htbuf);
             }
             iochan_setflag(hc->iochan, EVENT_OUTPUT);
             break;
@@ -808,6 +925,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)
 {
@@ -823,13 +943,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;
 
@@ -851,6 +975,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;
 }
 
@@ -879,13 +1010,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 */
@@ -899,7 +1029,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;
@@ -912,19 +1042,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"))) {
@@ -937,13 +1073,18 @@ 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, char *base_url)
@@ -956,6 +1097,7 @@ void http_set_proxyaddr(char *host, char *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';
@@ -973,6 +1115,55 @@ void http_set_proxyaddr(char *host, char *base_url)
     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