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