--- /dev/null
+Index: include/vsb.h
+===================================================================
+--- include/vsb.h (.../tags/varnish-2.0.4/varnish-cache)
++++ include/vsb.h (.../branches/2.0/varnish-cache)
+@@ -77,7 +77,8 @@
+ int vsb_len(struct vsb *);
+ int vsb_done(const struct vsb *);
+ void vsb_delete(struct vsb *);
+-void vsb_quote(struct vsb *s, const char *p, int how);
++void vsb_quote(struct vsb *s, const char *p, int len, int how);
++const char *vsb_unquote(struct vsb *s, const char *p, int len, int how);
+ #ifdef __cplusplus
+ };
+ #endif
+Index: include/compat/execinfo.h
+===================================================================
+--- include/compat/execinfo.h (.../tags/varnish-2.0.4/varnish-cache)
++++ include/compat/execinfo.h (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,44 @@
++/*
++ * Copyright (c) 2003 Maxim Sobolev <sobomax@FreeBSD.org>
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ * notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ * notice, this list of conditions and the following disclaimer in the
++ * documentation and/or other materials provided with the distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ *
++ * $Id$
++ */
++
++#ifndef COMPAT_EXECINFO_H_INCLUDED
++#define COMPAT_EXECINFO_H_INCLUDED
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++int backtrace(void **, int);
++char ** backtrace_symbols(void *const *, int);
++void backtrace_symbols_fd(void *const *, int, int);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* COMPAT_EXECINFO_H_INCLUDED */
+Index: include/libvarnish.h
+===================================================================
+--- include/libvarnish.h (.../tags/varnish-2.0.4/varnish-cache)
++++ include/libvarnish.h (.../branches/2.0/varnish-cache)
+@@ -42,6 +42,8 @@
+ /* from libvarnish/argv.c */
+ void FreeArgv(char **argv);
+ char **ParseArgv(const char *s, int flag);
++char *BackSlashDecode(const char *s, const char *e);
++int BackSlash(const char *s, char *res);
+ #define ARGV_COMMENT (1 << 0)
+ #define ARGV_COMMA (1 << 1)
+
+@@ -65,6 +67,7 @@
+ int TCP_filter_http(int sock);
+ void TCP_blocking(int sock);
+ void TCP_nonblocking(int sock);
++void TCP_linger(int sock, int linger);
+ #ifdef SOL_SOCKET
+ void TCP_name(const struct sockaddr *addr, unsigned l, char *abuf,
+ unsigned alen, char *pbuf, unsigned plen);
+Index: include/vrt_obj.h
+===================================================================
+--- include/vrt_obj.h (.../tags/varnish-2.0.4/varnish-cache)
++++ include/vrt_obj.h (.../branches/2.0/varnish-cache)
+@@ -24,6 +24,8 @@
+ double VRT_r_req_grace(struct sess *);
+ void VRT_l_req_grace(struct sess *, double);
+ const char * VRT_r_req_xid(struct sess *);
++unsigned VRT_r_req_esi(struct sess *);
++void VRT_l_req_esi(struct sess *, unsigned);
+ const char * VRT_r_bereq_request(const struct sess *);
+ void VRT_l_bereq_request(const struct sess *, const char *, ...);
+ const char * VRT_r_bereq_url(const struct sess *);
+Index: include/shmlog_tags.h
+===================================================================
+--- include/shmlog_tags.h (.../tags/varnish-2.0.4/varnish-cache)
++++ include/shmlog_tags.h (.../branches/2.0/varnish-cache)
+@@ -101,3 +101,5 @@
+ SLTM(Hash)
+
+ SLTM(Backend_health)
++
++SLTM(FetchError)
+Index: include/vrt.h
+===================================================================
+--- include/vrt.h (.../tags/varnish-2.0.4/varnish-cache)
++++ include/vrt.h (.../branches/2.0/varnish-cache)
+@@ -54,6 +54,7 @@
+ double interval;
+ unsigned window;
+ unsigned threshold;
++ unsigned initial;
+ };
+
+ /*
+Index: include/stat_field.h
+===================================================================
+--- include/stat_field.h (.../tags/varnish-2.0.4/varnish-cache)
++++ include/stat_field.h (.../branches/2.0/varnish-cache)
+@@ -30,21 +30,33 @@
+ */
+
+ MAC_STAT(client_conn, uint64_t, 'a', "Client connections accepted")
++MAC_STAT(client_drop, uint64_t, 'a', "Connection dropped, no sess")
+ MAC_STAT(client_req, uint64_t, 'a', "Client requests received")
+
+ MAC_STAT(cache_hit, uint64_t, 'a', "Cache hits")
+ MAC_STAT(cache_hitpass, uint64_t, 'a', "Cache hits for pass")
+ MAC_STAT(cache_miss, uint64_t, 'a', "Cache misses")
+
+-MAC_STAT(backend_conn, uint64_t, 'a', "Backend connections success")
+-MAC_STAT(backend_unhealthy, uint64_t, 'a',
+- "Backend connections not attempted")
+-MAC_STAT(backend_busy, uint64_t, 'a', "Backend connections too many")
+-MAC_STAT(backend_fail, uint64_t, 'a', "Backend connections failures")
+-MAC_STAT(backend_reuse, uint64_t, 'a', "Backend connections reuses")
+-MAC_STAT(backend_recycle, uint64_t, 'a', "Backend connections recycles")
+-MAC_STAT(backend_unused, uint64_t, 'a', "Backend connections unused")
++MAC_STAT(backend_conn, uint64_t, 'a', "Backend conn. success")
++MAC_STAT(backend_unhealthy, uint64_t, 'a', "Backend conn. not attempted")
++MAC_STAT(backend_busy, uint64_t, 'a', "Backend conn. too many")
++MAC_STAT(backend_fail, uint64_t, 'a', "Backend conn. failures")
++MAC_STAT(backend_reuse, uint64_t, 'a', "Backend conn. reuses")
++MAC_STAT(backend_toolate, uint64_t, 'a', "Backend conn. was closed")
++MAC_STAT(backend_recycle, uint64_t, 'a', "Backend conn. recycles")
++MAC_STAT(backend_unused, uint64_t, 'a', "Backend conn. unused")
+
++
++MAC_STAT(fetch_head, uint64_t, 'a', "Fetch head")
++MAC_STAT(fetch_length, uint64_t, 'a', "Fetch with Length")
++MAC_STAT(fetch_chunked, uint64_t, 'a', "Fetch chunked")
++MAC_STAT(fetch_eof, uint64_t, 'a', "Fetch EOF")
++MAC_STAT(fetch_bad, uint64_t, 'a', "Fetch had bad headers")
++MAC_STAT(fetch_close, uint64_t, 'a', "Fetch wanted close")
++MAC_STAT(fetch_oldhttp, uint64_t, 'a', "Fetch pre HTTP/1.1 closed")
++MAC_STAT(fetch_zero, uint64_t, 'a', "Fetch zero len")
++MAC_STAT(fetch_failed, uint64_t, 'a', "Fetch failed")
++
+ MAC_STAT(n_srcaddr, uint64_t, 'i', "N struct srcaddr")
+ MAC_STAT(n_srcaddr_act, uint64_t, 'i', "N active struct srcaddr")
+ MAC_STAT(n_sess_mem, uint64_t, 'i', "N struct sess_mem")
+Index: include/Makefile.am
+===================================================================
+--- include/Makefile.am (.../tags/varnish-2.0.4/varnish-cache)
++++ include/Makefile.am (.../branches/2.0/varnish-cache)
+@@ -14,6 +14,7 @@
+ cli_priv.h \
+ compat/asprintf.h \
+ compat/daemon.h \
++ compat/execinfo.h \
+ compat/setproctitle.h \
+ compat/srandomdev.h \
+ compat/strlcat.h \
+Index: configure.ac
+===================================================================
+--- configure.ac (.../tags/varnish-2.0.4/varnish-cache)
++++ configure.ac (.../branches/2.0/varnish-cache)
+@@ -81,6 +81,7 @@
+ AC_CHECK_HEADERS([sys/statvfs.h])
+ AC_CHECK_HEADERS([sys/vfs.h])
+ AC_CHECK_HEADERS([endian.h])
++AC_CHECK_HEADERS([execinfo.h])
+ AC_CHECK_HEADERS([netinet/in.h])
+ AC_CHECK_HEADERS([pthread_np.h])
+ AC_CHECK_HEADERS([stddef.h])
+@@ -102,6 +103,7 @@
+ AC_FUNC_VPRINTF
+ AC_CHECK_FUNCS([strerror])
+ AC_FUNC_STRERROR_R
++AC_CHECK_FUNCS([dladdr])
+ AC_CHECK_FUNCS([socket])
+ AC_CHECK_FUNCS([strptime])
+ AC_CHECK_FUNCS([fmtcheck])
+@@ -360,6 +362,15 @@
+ fi
+ AC_DEFINE_UNQUOTED([VCC_CC],"$VCC_CC",[C compiler command line for VCL code])
+
++# Define HTTP_HDR_MAX_VAL
++AC_ARG_WITH(max-header-fields,
++ AS_HELP_STRING([--with-max-header-fields=NUM],
++ [How many header fields to support (default=32)]),
++ [],
++ [with_max_header_fields=32])
++
++AC_DEFINE_UNQUOTED(HTTP_HDR_MAX_VAL, $with_max_header_fields, [Define maximum number of header fields supported by varnish ])
++
+ # Use jemalloc on Linux
+ JEMALLOC_SUBDIR=
+ JEMALLOC_LDADD=
+Index: lib/libvarnish/argv.c
+===================================================================
+--- lib/libvarnish/argv.c (.../tags/varnish-2.0.4/varnish-cache)
++++ lib/libvarnish/argv.c (.../branches/2.0/varnish-cache)
+@@ -43,11 +43,12 @@
+ #include <ctype.h>
+ #include <stdlib.h>
+ #include <stdio.h>
++#include <string.h>
+ #include <stdint.h>
+
+ #include "libvarnish.h"
+
+-static int
++int
+ BackSlash(const char *s, char *res)
+ {
+ int r;
+@@ -103,13 +104,16 @@
+ return (r);
+ }
+
+-static char *
++char *
+ BackSlashDecode(const char *s, const char *e)
+ {
+ const char *q;
+ char *p, *r;
+ int i;
+
++ if (e == NULL)
++ e = strchr(s, '\0');
++ assert(e != NULL);
+ p = calloc((e - s) + 1, 1);
+ if (p == NULL)
+ return (p);
+Index: lib/libvarnish/cli_common.c
+===================================================================
+--- lib/libvarnish/cli_common.c (.../tags/varnish-2.0.4/varnish-cache)
++++ lib/libvarnish/cli_common.c (.../branches/2.0/varnish-cache)
+@@ -73,7 +73,7 @@
+ cli_quote(struct cli *cli, const char *s)
+ {
+
+- vsb_quote(cli->sb, s, 0);
++ vsb_quote(cli->sb, s, -1, 0);
+ }
+
+ void
+Index: lib/libvarnish/tcp.c
+===================================================================
+--- lib/libvarnish/tcp.c (.../tags/varnish-2.0.4/varnish-cache)
++++ lib/libvarnish/tcp.c (.../branches/2.0/varnish-cache)
+@@ -36,6 +36,10 @@
+
+ #include <netinet/in.h>
+
++#ifdef __linux
++#include <netinet/tcp.h>
++#endif
++
+ #include <errno.h>
+ #include <sys/ioctl.h>
+ #ifdef HAVE_SYS_FILIO_H
+@@ -113,6 +117,10 @@
+ printf("Acceptfilter(%d, httpready): %d %s\n",
+ sock, i, strerror(errno));
+ return (i);
++#elif defined(__linux)
++ int defer = 1;
++ setsockopt(sock, SOL_TCP,TCP_DEFER_ACCEPT,(char *) &defer, sizeof(int));
++ return (0);
+ #else
+ (void)sock;
+ return (0);
+@@ -222,3 +230,17 @@
+ AZ(setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof timeout));
+ #endif
+ }
++
++/*--------------------------------------------------------------------
++ * Set or reset SO_LINGER flag
++ */
++
++void
++TCP_linger(int sock, int linger)
++{
++ struct linger lin;
++
++ memset(&lin, 0, sizeof lin);
++ lin.l_onoff = linger;
++ AZ(setsockopt(sock, SOL_SOCKET, SO_LINGER, &lin, sizeof lin));
++}
+Index: lib/libvarnish/vsb.c
+===================================================================
+--- lib/libvarnish/vsb.c (.../tags/varnish-2.0.4/varnish-cache)
++++ lib/libvarnish/vsb.c (.../branches/2.0/varnish-cache)
+@@ -481,25 +481,27 @@
+ * Quote a string
+ */
+ void
+-vsb_quote(struct vsb *s, const char *p, int how)
++vsb_quote(struct vsb *s, const char *p, int len, int how)
+ {
+ const char *q;
+ int quote = 0;
+
+ (void)how; /* For future enhancements */
++ if (len == -1)
++ len = strlen(p);
+
+- for (q = p; *q != '\0'; q++) {
++ for (q = p; q < p + len; q++) {
+ if (!isgraph(*q) || *q == '"') {
+ quote++;
+ break;
+ }
+ }
+ if (!quote) {
+- (void)vsb_cat(s, p);
++ (void)vsb_bcat(s, p, len);
+ return;
+ }
+ (void)vsb_putc(s, '"');
+- for (q = p; *q != '\0'; q++) {
++ for (q = p; q < p + len; q++) {
+ switch (*q) {
+ case ' ':
+ (void)vsb_putc(s, *q);
+@@ -522,9 +524,66 @@
+ if (isgraph(*q))
+ (void)vsb_putc(s, *q);
+ else
+- (void)vsb_printf(s, "\\%o", *q);
++ (void)vsb_printf(s, "\\%o", *q & 0xff);
+ break;
+ }
+ }
+ (void)vsb_putc(s, '"');
+ }
++
++/*
++ * Unquote a string
++ */
++const char *
++vsb_unquote(struct vsb *s, const char *p, int len, int how)
++{
++ const char *q;
++ char *r;
++ unsigned long u;
++ char c;
++
++ (void)how; /* For future enhancements */
++
++ if (len == -1)
++ len = strlen(p);
++
++ for (q = p; q < p + len; q++) {
++ if (*q != '\\') {
++ (void)vsb_bcat(s, q, 1);
++ continue;
++ }
++ if (++q >= p + len)
++ return ("Incomplete '\\'-sequence at end of string");
++
++ switch(*q) {
++ case 'n':
++ (void)vsb_bcat(s, "\n", 1);
++ continue;
++ case 'r':
++ (void)vsb_bcat(s, "\r", 1);
++ continue;
++ case 't':
++ (void)vsb_bcat(s, "\t", 1);
++ continue;
++ case '0':
++ case '1':
++ case '2':
++ case '3':
++ case '4':
++ case '5':
++ case '6':
++ case '7':
++ errno = 0;
++ u = strtoul(q, &r, 8);
++ if (errno != 0 || (u & ~0xff))
++ return ("\\ooo sequence out of range");
++ c = (char)u;
++ (void)vsb_bcat(s, &c, 1);
++ q = r - 1;
++ continue;
++ default:
++ (void)vsb_bcat(s, q, 1);
++ }
++ }
++ return (NULL);
++}
+Index: lib/libvarnishcompat/execinfo.c
+===================================================================
+--- lib/libvarnishcompat/execinfo.c (.../tags/varnish-2.0.4/varnish-cache)
++++ lib/libvarnishcompat/execinfo.c (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,451 @@
++/*
++ * Copyright (c) 2003 Maxim Sobolev <sobomax@FreeBSD.org>
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ * notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ * notice, this list of conditions and the following disclaimer in the
++ * documentation and/or other materials provided with the distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ *
++ * $Id$
++ */
++
++#include "config.h"
++
++#include <sys/types.h>
++#include <sys/uio.h>
++#include <dlfcn.h>
++#include <math.h>
++#include <stddef.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#include <unistd.h>
++
++#include "execinfo.h"
++
++void *getreturnaddr(int);
++void *getframeaddr(int);
++
++#define D10(x) ceil(log10(((x) == 0) ? 2 : ((x) + 1)))
++
++inline static void *
++realloc_safe(void *ptr, size_t size)
++{
++ void *nptr;
++
++ nptr = realloc(ptr, size);
++ if (nptr == NULL)
++ free(ptr);
++ return nptr;
++}
++
++int
++backtrace(void **buffer, int size)
++{
++ int i;
++
++ for (i = 1; getframeaddr(i + 1) != NULL && i != size + 1; i++) {
++ buffer[i - 1] = getreturnaddr(i);
++ if (buffer[i - 1] == NULL)
++ break;
++ }
++
++ return i - 1;
++}
++
++char **
++backtrace_symbols(void *const *buffer, int size)
++{
++ size_t clen, alen;
++ int i;
++ char **rval;
++
++ clen = size * sizeof(char *);
++ rval = malloc(clen);
++ if (rval == NULL)
++ return NULL;
++ for (i = 0; i < size; i++) {
++
++#ifdef HAVE_DLADDR
++ {
++ Dl_info info;
++ int offset;
++
++ if (dladdr(buffer[i], &info) != 0) {
++ if (info.dli_sname == NULL)
++ info.dli_sname = "???";
++ if (info.dli_saddr == NULL)
++ info.dli_saddr = buffer[i];
++ offset = (const char*)buffer[i] - (const char*)info.dli_saddr;
++ /* "0x01234567 <function+offset> at filename" */
++ alen = 2 + /* "0x" */
++ (sizeof(void *) * 2) + /* "01234567" */
++ 2 + /* " <" */
++ strlen(info.dli_sname) + /* "function" */
++ 1 + /* "+" */
++ 10 + /* "offset */
++ 5 + /* "> at " */
++ strlen(info.dli_fname) + /* "filename" */
++ 1; /* "\0" */
++ rval = realloc_safe(rval, clen + alen);
++ if (rval == NULL)
++ return NULL;
++ snprintf((char *) rval + clen, alen, "%p <%s+%d> at %s",
++ buffer[i], info.dli_sname, offset, info.dli_fname);
++ rval[i] = (char *) clen;
++ clen += alen;
++ continue;
++ }
++ }
++#endif
++ alen = 2 + /* "0x" */
++ (sizeof(void *) * 2) + /* "01234567" */
++ 1; /* "\0" */
++ rval = realloc_safe(rval, clen + alen);
++ if (rval == NULL)
++ return NULL;
++ snprintf((char *) rval + clen, alen, "%p", buffer[i]);
++ rval[i] = (char *) clen;
++ clen += alen;
++ }
++
++ for (i = 0; i < size; i++)
++ rval[i] += (long) rval;
++
++ return rval;
++}
++
++#if 0
++void
++backtrace_symbols_fd(void *const *buffer, int size, int fd)
++{
++ int i, len, offset;
++ char *buf;
++ Dl_info info;
++
++ for (i = 0; i < size; i++) {
++ if (dladdr(buffer[i], &info) != 0) {
++ if (info.dli_sname == NULL)
++ info.dli_sname = "???";
++ if (info.dli_saddr == NULL)
++ info.dli_saddr = buffer[i];
++ offset = (const char *)buffer[i] - (const char *)info.dli_saddr;
++ /* "0x01234567 <function+offset> at filename" */
++ len = 2 + /* "0x" */
++ (sizeof(void *) * 2) + /* "01234567" */
++ 2 + /* " <" */
++ strlen(info.dli_sname) + /* "function" */
++ 1 + /* "+" */
++ D10(offset) + /* "offset */
++ 5 + /* "> at " */
++ strlen(info.dli_fname) + /* "filename" */
++ 2; /* "\n\0" */
++ buf = alloca(len);
++ if (buf == NULL)
++ return;
++ snprintf(buf, len, "%p <%s+%d> at %s\n",
++ buffer[i], info.dli_sname, offset, info.dli_fname);
++ } else {
++ len = 2 + /* "0x" */
++ (sizeof(void *) * 2) + /* "01234567" */
++ 2; /* "\n\0" */
++ buf = alloca(len);
++ if (buf == NULL)
++ return;
++ snprintf(buf, len, "%p\n", buffer[i]);
++ }
++ write(fd, buf, len - 1);
++ }
++}
++#endif
++
++void *
++getreturnaddr(int level)
++{
++
++ switch(level) {
++ case 0: return __builtin_return_address(1);
++ case 1: return __builtin_return_address(2);
++ case 2: return __builtin_return_address(3);
++ case 3: return __builtin_return_address(4);
++ case 4: return __builtin_return_address(5);
++ case 5: return __builtin_return_address(6);
++ case 6: return __builtin_return_address(7);
++ case 7: return __builtin_return_address(8);
++ case 8: return __builtin_return_address(9);
++ case 9: return __builtin_return_address(10);
++ case 10: return __builtin_return_address(11);
++ case 11: return __builtin_return_address(12);
++ case 12: return __builtin_return_address(13);
++ case 13: return __builtin_return_address(14);
++ case 14: return __builtin_return_address(15);
++ case 15: return __builtin_return_address(16);
++ case 16: return __builtin_return_address(17);
++ case 17: return __builtin_return_address(18);
++ case 18: return __builtin_return_address(19);
++ case 19: return __builtin_return_address(20);
++ case 20: return __builtin_return_address(21);
++ case 21: return __builtin_return_address(22);
++ case 22: return __builtin_return_address(23);
++ case 23: return __builtin_return_address(24);
++ case 24: return __builtin_return_address(25);
++ case 25: return __builtin_return_address(26);
++ case 26: return __builtin_return_address(27);
++ case 27: return __builtin_return_address(28);
++ case 28: return __builtin_return_address(29);
++ case 29: return __builtin_return_address(30);
++ case 30: return __builtin_return_address(31);
++ case 31: return __builtin_return_address(32);
++ case 32: return __builtin_return_address(33);
++ case 33: return __builtin_return_address(34);
++ case 34: return __builtin_return_address(35);
++ case 35: return __builtin_return_address(36);
++ case 36: return __builtin_return_address(37);
++ case 37: return __builtin_return_address(38);
++ case 38: return __builtin_return_address(39);
++ case 39: return __builtin_return_address(40);
++ case 40: return __builtin_return_address(41);
++ case 41: return __builtin_return_address(42);
++ case 42: return __builtin_return_address(43);
++ case 43: return __builtin_return_address(44);
++ case 44: return __builtin_return_address(45);
++ case 45: return __builtin_return_address(46);
++ case 46: return __builtin_return_address(47);
++ case 47: return __builtin_return_address(48);
++ case 48: return __builtin_return_address(49);
++ case 49: return __builtin_return_address(50);
++ case 50: return __builtin_return_address(51);
++ case 51: return __builtin_return_address(52);
++ case 52: return __builtin_return_address(53);
++ case 53: return __builtin_return_address(54);
++ case 54: return __builtin_return_address(55);
++ case 55: return __builtin_return_address(56);
++ case 56: return __builtin_return_address(57);
++ case 57: return __builtin_return_address(58);
++ case 58: return __builtin_return_address(59);
++ case 59: return __builtin_return_address(60);
++ case 60: return __builtin_return_address(61);
++ case 61: return __builtin_return_address(62);
++ case 62: return __builtin_return_address(63);
++ case 63: return __builtin_return_address(64);
++ case 64: return __builtin_return_address(65);
++ case 65: return __builtin_return_address(66);
++ case 66: return __builtin_return_address(67);
++ case 67: return __builtin_return_address(68);
++ case 68: return __builtin_return_address(69);
++ case 69: return __builtin_return_address(70);
++ case 70: return __builtin_return_address(71);
++ case 71: return __builtin_return_address(72);
++ case 72: return __builtin_return_address(73);
++ case 73: return __builtin_return_address(74);
++ case 74: return __builtin_return_address(75);
++ case 75: return __builtin_return_address(76);
++ case 76: return __builtin_return_address(77);
++ case 77: return __builtin_return_address(78);
++ case 78: return __builtin_return_address(79);
++ case 79: return __builtin_return_address(80);
++ case 80: return __builtin_return_address(81);
++ case 81: return __builtin_return_address(82);
++ case 82: return __builtin_return_address(83);
++ case 83: return __builtin_return_address(84);
++ case 84: return __builtin_return_address(85);
++ case 85: return __builtin_return_address(86);
++ case 86: return __builtin_return_address(87);
++ case 87: return __builtin_return_address(88);
++ case 88: return __builtin_return_address(89);
++ case 89: return __builtin_return_address(90);
++ case 90: return __builtin_return_address(91);
++ case 91: return __builtin_return_address(92);
++ case 92: return __builtin_return_address(93);
++ case 93: return __builtin_return_address(94);
++ case 94: return __builtin_return_address(95);
++ case 95: return __builtin_return_address(96);
++ case 96: return __builtin_return_address(97);
++ case 97: return __builtin_return_address(98);
++ case 98: return __builtin_return_address(99);
++ case 99: return __builtin_return_address(100);
++ case 100: return __builtin_return_address(101);
++ case 101: return __builtin_return_address(102);
++ case 102: return __builtin_return_address(103);
++ case 103: return __builtin_return_address(104);
++ case 104: return __builtin_return_address(105);
++ case 105: return __builtin_return_address(106);
++ case 106: return __builtin_return_address(107);
++ case 107: return __builtin_return_address(108);
++ case 108: return __builtin_return_address(109);
++ case 109: return __builtin_return_address(110);
++ case 110: return __builtin_return_address(111);
++ case 111: return __builtin_return_address(112);
++ case 112: return __builtin_return_address(113);
++ case 113: return __builtin_return_address(114);
++ case 114: return __builtin_return_address(115);
++ case 115: return __builtin_return_address(116);
++ case 116: return __builtin_return_address(117);
++ case 117: return __builtin_return_address(118);
++ case 118: return __builtin_return_address(119);
++ case 119: return __builtin_return_address(120);
++ case 120: return __builtin_return_address(121);
++ case 121: return __builtin_return_address(122);
++ case 122: return __builtin_return_address(123);
++ case 123: return __builtin_return_address(124);
++ case 124: return __builtin_return_address(125);
++ case 125: return __builtin_return_address(126);
++ case 126: return __builtin_return_address(127);
++ case 127: return __builtin_return_address(128);
++ default: return NULL;
++ }
++}
++
++void *
++getframeaddr(int level)
++{
++
++ switch(level) {
++ case 0: return __builtin_frame_address(1);
++ case 1: return __builtin_frame_address(2);
++ case 2: return __builtin_frame_address(3);
++ case 3: return __builtin_frame_address(4);
++ case 4: return __builtin_frame_address(5);
++ case 5: return __builtin_frame_address(6);
++ case 6: return __builtin_frame_address(7);
++ case 7: return __builtin_frame_address(8);
++ case 8: return __builtin_frame_address(9);
++ case 9: return __builtin_frame_address(10);
++ case 10: return __builtin_frame_address(11);
++ case 11: return __builtin_frame_address(12);
++ case 12: return __builtin_frame_address(13);
++ case 13: return __builtin_frame_address(14);
++ case 14: return __builtin_frame_address(15);
++ case 15: return __builtin_frame_address(16);
++ case 16: return __builtin_frame_address(17);
++ case 17: return __builtin_frame_address(18);
++ case 18: return __builtin_frame_address(19);
++ case 19: return __builtin_frame_address(20);
++ case 20: return __builtin_frame_address(21);
++ case 21: return __builtin_frame_address(22);
++ case 22: return __builtin_frame_address(23);
++ case 23: return __builtin_frame_address(24);
++ case 24: return __builtin_frame_address(25);
++ case 25: return __builtin_frame_address(26);
++ case 26: return __builtin_frame_address(27);
++ case 27: return __builtin_frame_address(28);
++ case 28: return __builtin_frame_address(29);
++ case 29: return __builtin_frame_address(30);
++ case 30: return __builtin_frame_address(31);
++ case 31: return __builtin_frame_address(32);
++ case 32: return __builtin_frame_address(33);
++ case 33: return __builtin_frame_address(34);
++ case 34: return __builtin_frame_address(35);
++ case 35: return __builtin_frame_address(36);
++ case 36: return __builtin_frame_address(37);
++ case 37: return __builtin_frame_address(38);
++ case 38: return __builtin_frame_address(39);
++ case 39: return __builtin_frame_address(40);
++ case 40: return __builtin_frame_address(41);
++ case 41: return __builtin_frame_address(42);
++ case 42: return __builtin_frame_address(43);
++ case 43: return __builtin_frame_address(44);
++ case 44: return __builtin_frame_address(45);
++ case 45: return __builtin_frame_address(46);
++ case 46: return __builtin_frame_address(47);
++ case 47: return __builtin_frame_address(48);
++ case 48: return __builtin_frame_address(49);
++ case 49: return __builtin_frame_address(50);
++ case 50: return __builtin_frame_address(51);
++ case 51: return __builtin_frame_address(52);
++ case 52: return __builtin_frame_address(53);
++ case 53: return __builtin_frame_address(54);
++ case 54: return __builtin_frame_address(55);
++ case 55: return __builtin_frame_address(56);
++ case 56: return __builtin_frame_address(57);
++ case 57: return __builtin_frame_address(58);
++ case 58: return __builtin_frame_address(59);
++ case 59: return __builtin_frame_address(60);
++ case 60: return __builtin_frame_address(61);
++ case 61: return __builtin_frame_address(62);
++ case 62: return __builtin_frame_address(63);
++ case 63: return __builtin_frame_address(64);
++ case 64: return __builtin_frame_address(65);
++ case 65: return __builtin_frame_address(66);
++ case 66: return __builtin_frame_address(67);
++ case 67: return __builtin_frame_address(68);
++ case 68: return __builtin_frame_address(69);
++ case 69: return __builtin_frame_address(70);
++ case 70: return __builtin_frame_address(71);
++ case 71: return __builtin_frame_address(72);
++ case 72: return __builtin_frame_address(73);
++ case 73: return __builtin_frame_address(74);
++ case 74: return __builtin_frame_address(75);
++ case 75: return __builtin_frame_address(76);
++ case 76: return __builtin_frame_address(77);
++ case 77: return __builtin_frame_address(78);
++ case 78: return __builtin_frame_address(79);
++ case 79: return __builtin_frame_address(80);
++ case 80: return __builtin_frame_address(81);
++ case 81: return __builtin_frame_address(82);
++ case 82: return __builtin_frame_address(83);
++ case 83: return __builtin_frame_address(84);
++ case 84: return __builtin_frame_address(85);
++ case 85: return __builtin_frame_address(86);
++ case 86: return __builtin_frame_address(87);
++ case 87: return __builtin_frame_address(88);
++ case 88: return __builtin_frame_address(89);
++ case 89: return __builtin_frame_address(90);
++ case 90: return __builtin_frame_address(91);
++ case 91: return __builtin_frame_address(92);
++ case 92: return __builtin_frame_address(93);
++ case 93: return __builtin_frame_address(94);
++ case 94: return __builtin_frame_address(95);
++ case 95: return __builtin_frame_address(96);
++ case 96: return __builtin_frame_address(97);
++ case 97: return __builtin_frame_address(98);
++ case 98: return __builtin_frame_address(99);
++ case 99: return __builtin_frame_address(100);
++ case 100: return __builtin_frame_address(101);
++ case 101: return __builtin_frame_address(102);
++ case 102: return __builtin_frame_address(103);
++ case 103: return __builtin_frame_address(104);
++ case 104: return __builtin_frame_address(105);
++ case 105: return __builtin_frame_address(106);
++ case 106: return __builtin_frame_address(107);
++ case 107: return __builtin_frame_address(108);
++ case 108: return __builtin_frame_address(109);
++ case 109: return __builtin_frame_address(110);
++ case 110: return __builtin_frame_address(111);
++ case 111: return __builtin_frame_address(112);
++ case 112: return __builtin_frame_address(113);
++ case 113: return __builtin_frame_address(114);
++ case 114: return __builtin_frame_address(115);
++ case 115: return __builtin_frame_address(116);
++ case 116: return __builtin_frame_address(117);
++ case 117: return __builtin_frame_address(118);
++ case 118: return __builtin_frame_address(119);
++ case 119: return __builtin_frame_address(120);
++ case 120: return __builtin_frame_address(121);
++ case 121: return __builtin_frame_address(122);
++ case 122: return __builtin_frame_address(123);
++ case 123: return __builtin_frame_address(124);
++ case 124: return __builtin_frame_address(125);
++ case 125: return __builtin_frame_address(126);
++ case 126: return __builtin_frame_address(127);
++ case 127: return __builtin_frame_address(128);
++ default: return NULL;
++ }
++}
+Index: lib/libvarnishcompat/Makefile.am
+===================================================================
+--- lib/libvarnishcompat/Makefile.am (.../tags/varnish-2.0.4/varnish-cache)
++++ lib/libvarnishcompat/Makefile.am (.../branches/2.0/varnish-cache)
+@@ -9,6 +9,7 @@
+ libvarnishcompat_la_SOURCES = \
+ asprintf.c \
+ daemon.c \
++ execinfo.c \
+ vasprintf.c \
+ setproctitle.c \
+ srandomdev.c \
+Index: lib/libvcl/vcc_gen_obj.tcl
+===================================================================
+--- lib/libvcl/vcc_gen_obj.tcl (.../tags/varnish-2.0.4/varnish-cache)
++++ lib/libvcl/vcc_gen_obj.tcl (.../branches/2.0/varnish-cache)
+@@ -116,6 +116,12 @@
+ "struct sess *"
+ }
+
++ { req.esi
++ RW BOOL
++ {recv fetch deliver error}
++ "struct sess *"
++ }
++
+ # Request sent to backend
+ { bereq.request
+ RW STRING
+Index: lib/libvcl/vcc_parse.c
+===================================================================
+--- lib/libvcl/vcc_parse.c (.../tags/varnish-2.0.4/varnish-cache)
++++ lib/libvcl/vcc_parse.c (.../branches/2.0/varnish-cache)
+@@ -263,10 +263,11 @@
+ Fb(tl, 1, "%sVRT_strcmp(%s, ",
+ tl->t->tok == T_EQ ? "!" : "", vp->rname);
+ vcc_NextToken(tl);
+- ExpectErr(tl, CSTR);
+- EncToken(tl->fb, tl->t);
++ if (!vcc_StringVal(tl)) {
++ vcc_ExpectedStringval(tl);
++ break;
++ }
+ Fb(tl, 0, ")\n");
+- vcc_NextToken(tl);
+ break;
+ default:
+ Fb(tl, 1, "%s != (void*)0\n", vp->rname);
+Index: lib/libvcl/vcc_obj.c
+===================================================================
+--- lib/libvcl/vcc_obj.c (.../tags/varnish-2.0.4/varnish-cache)
++++ lib/libvcl/vcc_obj.c (.../branches/2.0/varnish-cache)
+@@ -102,6 +102,11 @@
+ | VCL_MET_MISS | VCL_MET_HIT | VCL_MET_FETCH | VCL_MET_DELIVER
+ | VCL_MET_ERROR
+ },
++ { "req.esi", BOOL, 7,
++ "VRT_r_req_esi(sp)", "VRT_l_req_esi(sp, ",
++ V_RW, 0,
++ VCL_MET_RECV | VCL_MET_FETCH | VCL_MET_DELIVER | VCL_MET_ERROR
++ },
+ { "bereq.request", STRING, 13,
+ "VRT_r_bereq_request(sp)", "VRT_l_bereq_request(sp, ",
+ V_RW, 0,
+Index: lib/libvcl/vcc_backend.c
+===================================================================
+--- lib/libvcl/vcc_backend.c (.../tags/varnish-2.0.4/varnish-cache)
++++ lib/libvcl/vcc_backend.c (.../branches/2.0/varnish-cache)
+@@ -340,7 +340,8 @@
+ struct fld_spec *fs;
+ struct token *t_field;
+ struct token *t_did = NULL, *t_window = NULL, *t_threshold = NULL;
+- unsigned window, threshold;
++ struct token *t_initial = NULL;
++ unsigned window, threshold, initial;
+
+ fs = vcc_FldSpec(tl,
+ "?url",
+@@ -349,6 +350,7 @@
+ "?interval",
+ "?window",
+ "?threshold",
++ "?initial",
+ NULL);
+
+ ExpectErr(tl, '{');
+@@ -356,6 +358,7 @@
+
+ window = 0;
+ threshold = 0;
++ initial = 0;
+ Fb(tl, 0, "\t.probe = {\n");
+ while (tl->t->tok != '}') {
+
+@@ -396,6 +399,11 @@
+ window = vcc_UintVal(tl);
+ vcc_NextToken(tl);
+ ERRCHK(tl);
++ } else if (vcc_IdIs(t_field, "initial")) {
++ t_initial = tl->t;
++ initial = vcc_UintVal(tl);
++ vcc_NextToken(tl);
++ ERRCHK(tl);
+ } else if (vcc_IdIs(t_field, "threshold")) {
+ t_threshold = tl->t;
+ threshold = vcc_UintVal(tl);
+@@ -441,8 +449,12 @@
+ vcc_ErrWhere(tl, t_window);
+ }
+ Fb(tl, 0, "\t\t.window = %u,\n", window);
+- Fb(tl, 0, "\t\t.threshold = %u\n", threshold);
++ Fb(tl, 0, "\t\t.threshold = %u,\n", threshold);
+ }
++ if (t_initial != NULL)
++ Fb(tl, 0, "\t\t.initial = %u,\n", initial);
++ else
++ Fb(tl, 0, "\t\t.initial = ~0U,\n", initial);
+ Fb(tl, 0, "\t},\n");
+ ExpectErr(tl, '}');
+ vcc_NextToken(tl);
+Index: lib/libvcl/vcc_fixed_token.c
+===================================================================
+--- lib/libvcl/vcc_fixed_token.c (.../tags/varnish-2.0.4/varnish-cache)
++++ lib/libvcl/vcc_fixed_token.c (.../branches/2.0/varnish-cache)
+@@ -235,8 +235,8 @@
+ vsb_cat(sb, " * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWI");
+ vsb_cat(sb, "SE) ARISING IN ANY WAY\n * OUT OF THE USE OF THIS SOFT");
+ vsb_cat(sb, "WARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n");
+- vsb_cat(sb, " * SUCH DAMAGE.\n *\n * $Id: vrt.h 3724 2009-02-10 14:");
+- vsb_cat(sb, "58:17Z tfheen $\n *\n * Runtime support for compiled V");
++ vsb_cat(sb, " * SUCH DAMAGE.\n *\n * $Id: vrt.h 4303 2009-10-08 13:");
++ vsb_cat(sb, "58:25Z tfheen $\n *\n * Runtime support for compiled V");
+ vsb_cat(sb, "CL programs.\n *\n * XXX: When this file is changed, l");
+ vsb_cat(sb, "ib/libvcl/vcc_gen_fixed_token.tcl\n");
+ vsb_cat(sb, " * XXX: *MUST* be rerun.\n */\n");
+@@ -247,12 +247,12 @@
+ vsb_cat(sb, "\nstruct vrt_backend_probe {\n\tconst char\t*url;\n");
+ vsb_cat(sb, "\tconst char\t*request;\n\tdouble\t\ttimeout;\n");
+ vsb_cat(sb, "\tdouble\t\tinterval;\n\tunsigned\twindow;\n");
+- vsb_cat(sb, "\tunsigned\tthreshold;\n};\n\n/*\n");
+- vsb_cat(sb, " * A backend is a host+port somewhere on the network\n");
+- vsb_cat(sb, " */\nstruct vrt_backend {\n\tconst char\t\t\t*vcl_name");
+- vsb_cat(sb, ";\n\tconst char\t\t\t*ident;\n\n");
+- vsb_cat(sb, "\tconst char\t\t\t*hosthdr;\n\n");
+- vsb_cat(sb, "\tconst unsigned char\t\t*ipv4_sockaddr;\n");
++ vsb_cat(sb, "\tunsigned\tthreshold;\n\tunsigned\tinitial;\n");
++ vsb_cat(sb, "};\n\n/*\n * A backend is a host+port somewhere on the");
++ vsb_cat(sb, " network\n */\nstruct vrt_backend {\n");
++ vsb_cat(sb, "\tconst char\t\t\t*vcl_name;\n\tconst char\t\t\t*ident");
++ vsb_cat(sb, ";\n\n\tconst char\t\t\t*hosthdr;\n");
++ vsb_cat(sb, "\n\tconst unsigned char\t\t*ipv4_sockaddr;\n");
+ vsb_cat(sb, "\tconst unsigned char\t\t*ipv6_sockaddr;\n");
+ vsb_cat(sb, "\n\tdouble\t\t\t\tconnect_timeout;\n");
+ vsb_cat(sb, "\tdouble\t\t\t\tfirst_byte_timeout;\n");
+@@ -324,9 +324,9 @@
+
+ /* ../../include/vrt_obj.h */
+
+- vsb_cat(sb, "/*\n * $Id: vrt_obj.h 3990 2009-03-23 12:37:42Z tfheen");
+- vsb_cat(sb, " $\n *\n * NB: This file is machine generated, DO NOT");
+- vsb_cat(sb, " EDIT!\n *\n * Edit vcc_gen_obj.tcl instead\n");
++ vsb_cat(sb, "/*\n * $Id: vcc_gen_obj.tcl 4082 2009-05-19 07:14:00Z ");
++ vsb_cat(sb, "sky $\n *\n * NB: This file is machine generated, DO ");
++ vsb_cat(sb, "NOT EDIT!\n *\n * Edit vcc_gen_obj.tcl instead\n");
+ vsb_cat(sb, " */\n\nstruct sockaddr * VRT_r_client_ip(const struct ");
+ vsb_cat(sb, "sess *);\nstruct sockaddr * VRT_r_server_ip(struct ses");
+ vsb_cat(sb, "s *);\nconst char * VRT_r_server_hostname(struct sess ");
+@@ -345,6 +345,8 @@
+ vsb_cat(sb, "uct sess *);\ndouble VRT_r_req_grace(struct sess *);\n");
+ vsb_cat(sb, "void VRT_l_req_grace(struct sess *, double);\n");
+ vsb_cat(sb, "const char * VRT_r_req_xid(struct sess *);\n");
++ vsb_cat(sb, "unsigned VRT_r_req_esi(struct sess *);\n");
++ vsb_cat(sb, "void VRT_l_req_esi(struct sess *, unsigned);\n");
+ vsb_cat(sb, "const char * VRT_r_bereq_request(const struct sess *);");
+ vsb_cat(sb, "\nvoid VRT_l_bereq_request(const struct sess *, const ");
+ vsb_cat(sb, "char *, ...);\nconst char * VRT_r_bereq_url(const stru");
+Index: lib/libvcl/vcc_acl.c
+===================================================================
+--- lib/libvcl/vcc_acl.c (.../tags/varnish-2.0.4/varnish-cache)
++++ lib/libvcl/vcc_acl.c (.../branches/2.0/varnish-cache)
+@@ -250,14 +250,18 @@
+ {
+ unsigned char b[4];
+ int i, j, k;
++ unsigned u;
+ const char *p;
+
+ memset(b, 0, sizeof b);
+ p = ae->t_addr->dec;
+ for (i = 0; i < 4; i++) {
+- j = sscanf(p, "%hhu%n", &b[i], &k);
++ j = sscanf(p, "%u%n", &u, &k);
+ if (j != 1)
+ return (0);
++ if (u & ~0xff)
++ return (0);
++ b[i] = (unsigned char)u;
+ if (p[k] == '\0')
+ break;
+ if (p[k] != '.')
+Index: bin/varnishreplay/varnishreplay.c
+===================================================================
+--- bin/varnishreplay/varnishreplay.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishreplay/varnishreplay.c (.../branches/2.0/varnish-cache)
+@@ -190,7 +190,7 @@
+ pthread_mutex_unlock(&log_mutex);
+ }
+
+-struct thread {
++struct replay_thread {
+ pthread_t thread_id;
+ struct mailbox mbox;
+
+@@ -212,14 +212,14 @@
+ char temp[2048];
+ };
+
+-static struct thread **threads;
++static struct replay_thread **threads;
+ static size_t nthreads;
+
+ /*
+ * Clear thread state
+ */
+ static void
+-thread_clear(struct thread *thr)
++thread_clear(struct replay_thread *thr)
+ {
+
+ thr->method = thr->proto = thr->url = NULL;
+@@ -236,17 +236,17 @@
+ thr->sock = -1;
+ }
+
+-#define THREAD_FAIL ((struct thread *)-1)
++#define THREAD_FAIL ((struct replay_thread *)-1)
+
+ static pthread_attr_t thread_attr;
+
+-static struct thread *
++static struct replay_thread *
+ thread_get(int fd, void *(*thread_main)(void *))
+ {
+
+ assert(fd != 0);
+ if (fd >= nthreads) {
+- struct thread **newthreads = threads;
++ struct replay_thread **newthreads = threads;
+ size_t newnthreads = nthreads;
+
+ while (fd >= newnthreads)
+@@ -309,7 +309,7 @@
+ * Allocate from thread arena
+ */
+ static void *
+-thread_alloc(struct thread *thr, size_t len)
++thread_alloc(struct replay_thread *thr, size_t len)
+ {
+ void *ptr;
+
+@@ -325,7 +325,7 @@
+ * trimmed.
+ */
+ static char *
+-trimline(struct thread *thr, const char *str)
++trimline(struct replay_thread *thr, const char *str)
+ {
+ size_t len;
+ char *p;
+@@ -355,7 +355,7 @@
+ * A line is terminated by \r\n
+ */
+ static int
+-read_line(struct thread *thr)
++read_line(struct replay_thread *thr)
+ {
+ int i, len;
+
+@@ -389,7 +389,7 @@
+ * the number of bytes read.
+ */
+ static int
+-read_block(struct thread *thr, int len)
++read_block(struct replay_thread *thr, int len)
+ {
+ int n, r, tot;
+
+@@ -412,7 +412,7 @@
+ /* Receive the response after sending a request.
+ */
+ static int
+-receive_response(struct thread *thr)
++receive_response(struct replay_thread *thr)
+ {
+ const char *next;
+ int line_len;
+@@ -496,7 +496,7 @@
+ {
+ struct iovec iov[6];
+ char space[1] = " ", crlf[2] = "\r\n";
+- struct thread *thr = arg;
++ struct replay_thread *thr = arg;
+ struct message *msg;
+ enum shmlogtag tag;
+ size_t len;
+@@ -642,7 +642,7 @@
+ gen_traffic(void *priv, enum shmlogtag tag, unsigned fd,
+ unsigned len, unsigned spec, const char *ptr)
+ {
+- struct thread *thr;
++ struct replay_thread *thr;
+ const char *end;
+ struct message *msg;
+
+Index: bin/varnishtest/tests/r00354.vtc
+===================================================================
+--- bin/varnishtest/tests/r00354.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/r00354.vtc (.../branches/2.0/varnish-cache)
+@@ -1,16 +0,0 @@
+-# $Id$
+-
+-test "#354 Segfault in strcmp in http_DissectRequest()"
+-
+-server s1 {
+- rxreq
+- txresp
+-}
+-
+-varnish v1 -vcl+backend {} -start
+-
+-client c1 {
+- send "FOO\r\n\r\n"
+- rxresp
+- expect resp.status == 400
+-} -run
+Index: bin/varnishtest/tests/r00494.vtc
+===================================================================
+--- bin/varnishtest/tests/r00494.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/r00494.vtc (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,27 @@
++# $Id$
++
++test "HTTP continuation lines"
++
++#NB: careful about spaces and tabs in this test.
++
++server s1 {
++ rxreq
++ txresp -hdr {Foo: bar,
++ barf: fail} -body "xxx"
++} -start
++
++varnish v1 -vcl+backend {
++ sub vcl_fetch {
++ set obj.http.bar = obj.http.foo;
++ remove obj.http.foo;
++ }
++} -start
++
++client c1 {
++ txreq
++ rxresp
++ expect resp.http.bar == "bar, barf: fail"
++ expect resp.http.barf == resp.http.barf
++ expect resp.http.foo == resp.http.foo
++} -run
++
+Index: bin/varnishtest/tests/r00498.vtc
+===================================================================
+--- bin/varnishtest/tests/r00498.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/r00498.vtc (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,18 @@
++# $Id$
++
++test "very very very long return header"
++
++server s1 {
++ rxreq
++ expect req.url == "/"
++ txresp -hdr "Location: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" -body {foo}
++} -start
++
++varnish v1 -vcl+backend {
++} -start
++
++client c1 {
++ txreq
++ rxresp
++ expect resp.bodylen == 3
++} -run
+Index: bin/varnishtest/tests/b00029.vtc
+===================================================================
+--- bin/varnishtest/tests/b00029.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/b00029.vtc (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,18 @@
++# $Id$
++
++test "Test orderly connection closure"
++
++
++server s1 {
++ rxreq
++ txresp -bodylen 130000
++} -start
++
++varnish v1 -vcl+backend { } -start
++
++client c1 {
++ txreq -hdr "Connection: close"
++ delay 3
++ rxresp
++ expect resp.bodylen == 130000
++} -run
+Index: bin/varnishtest/tests/r00502.vtc
+===================================================================
+--- bin/varnishtest/tests/r00502.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/r00502.vtc (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,30 @@
++# $Id$
++
++test "multi element purge"
++
++server s1 {
++ rxreq
++ txresp -hdr "foo: bar1" -body "1"
++ rxreq
++ txresp -hdr "foo: bar2" -body "22"
++} -start
++
++varnish v1 -vcl+backend {
++ sub vcl_recv {
++ purge("req.url == / && obj.http.foo ~ bar1");
++ }
++} -start
++
++client c1 {
++ txreq
++ rxresp
++ expect resp.http.foo == "bar1"
++ txreq
++ rxresp
++ expect resp.http.foo == "bar2"
++ txreq
++ rxresp
++ expect resp.http.foo == "bar2"
++} -run
++
++varnish v1 -cliok purge.list
+Index: bin/varnishtest/tests/v00024.vtc
+===================================================================
+--- bin/varnishtest/tests/v00024.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/v00024.vtc (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,27 @@
++# $Id$
++
++test "Test that headers can be compared"
++
++server s1 {
++ rxreq
++ expect req.url == "/foo"
++ txresp -status 200 -body "1"
++} -start
++
++varnish v1 -vcl+backend {
++ sub vcl_recv {
++ if (req.http.etag == req.http.if-none-match) {
++ error 400 "FOO";
++ }
++ }
++} -start
++
++client c1 {
++ txreq -url "/foo"
++ rxresp
++ expect resp.status == 200
++ expect resp.bodylen == 1
++ txreq -url "/foo" -hdr "etag: foo" -hdr "if-none-match: foo"
++ rxresp
++ expect resp.status == 400
++} -run
+Index: bin/varnishtest/tests/r00506.vtc
+===================================================================
+--- bin/varnishtest/tests/r00506.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/r00506.vtc (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,18 @@
++# $Id$
++
++test "Illegal HTTP status from backend"
++
++server s1 {
++ rxreq
++ send "HTTP/1.1 1000\n\nFoo"
++} -start
++
++varnish v1 -vcl+backend {
++ sub vcl_recv {
++ }
++} -start
++
++client c1 {
++ txreq
++ rxresp
++} -run
+Index: bin/varnishtest/tests/r00549.vtc
+===================================================================
+--- bin/varnishtest/tests/r00549.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/r00549.vtc (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,15 @@
++# $Id$
++
++# Regression test for bad backend reply with ctrl char.
++
++server s1 {
++ rxreq
++ send "HTTP/1.1 200 OK\013\r\n\r\nTest"
++} -start
++
++varnish v1 -vcl+backend {} -start
++
++client c1 {
++ txreq
++ rxresp
++} -run
+Index: bin/varnishtest/tests/c00025.vtc
+===================================================================
+--- bin/varnishtest/tests/c00025.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/c00025.vtc (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,33 @@
++# $Id$
++
++test "Test If-None-Match"
++
++server s1 {
++ rxreq
++ expect req.url == "/foo"
++ txresp -hdr "ETag: 123456789" \
++ -body "11111\n"
++} -start
++
++varnish v1 -vcl+backend { } -start
++
++client c1 {
++ txreq -url "/foo"
++ rxresp
++ expect resp.status == 200
++ expect resp.http.content-length == 6
++
++ txreq -url "/foo" \
++ -hdr "If-None-Match: 12345678"
++ rxresp
++ expect resp.status == 200
++
++ txreq -url "/foo" \
++ -hdr "If-None-Match: 123456789"
++ rxresp
++ expect resp.status == 304
++}
++
++client c1 -run
++
++client c1 -run
+Index: bin/varnishtest/tests/r00558.vtc
+===================================================================
+--- bin/varnishtest/tests/r00558.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/r00558.vtc (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,19 @@
++# $Id$
++
++test "error from vcl_recv{} has no numeric code"
++
++
++server s1 {
++}
++
++varnish v1 -vcl+backend {
++ sub vcl_recv {
++ return (error);
++ }
++} -start
++
++client c1 {
++ txreq
++ rxresp
++ expect resp.status == 501
++} -run
+Index: bin/varnishtest/tests/e00016.vtc
+===================================================================
+--- bin/varnishtest/tests/e00016.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/e00016.vtc (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,49 @@
++# $Id$
++
++test "ESI request can't be turned off midstream"
++
++server s1 {
++ rxreq
++ txresp -body {
++ <html>
++ Before include
++ <esi:include src="/body"/>
++ <esi:include src="/body3"/>
++ After include
++ }
++ rxreq
++ expect req.url == "/body"
++ txresp -body {
++ <esi:include src="/body2"/>
++ }
++ rxreq
++ expect req.url == "/body2"
++ txresp -body {
++ included
++ }
++ rxreq
++ expect req.url == "/body3"
++ txresp -body {
++ included body3
++ }
++} -start
++
++varnish v1 -vcl+backend {
++ sub vcl_fetch {
++ set req.esi = true;
++ if(req.url == "/body") {
++ set req.esi = false;
++ }
++ esi;
++ }
++} -start
++
++client c1 {
++ txreq
++ rxresp
++ expect resp.bodylen == 105
++ expect resp.status == 200
++}
++
++client c1 -run
++varnish v1 -expect esi_errors == 0
+Index: bin/varnishtest/tests/r00561.vtc
+===================================================================
+--- bin/varnishtest/tests/r00561.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/r00561.vtc (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,25 @@
++# $Id$
++
++test "Junk request should not go to vcl_error"
++
++server s1 {
++ rxreq
++ txresp
++} -start
++
++varnish v1 -vcl+backend {
++ sub vcl_error {
++ return (restart);
++ }
++} -start
++
++client c1 {
++ send "sljdslf\r\n\r\n"
++ delay .1
++} -run
++
++client c1 {
++ txreq
++ rxresp
++} -run
++
+Index: bin/varnishtest/tests/c00008.vtc
+===================================================================
+--- bin/varnishtest/tests/c00008.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/c00008.vtc (.../branches/2.0/varnish-cache)
+@@ -6,6 +6,7 @@
+ rxreq
+ expect req.url == "/foo"
+ txresp -hdr "Last-Modified: Thu, 26 Jun 2008 12:00:01 GMT" \
++ -hdr "ETag: foo" \
+ -body "11111\n"
+ } -start
+
+@@ -15,22 +16,26 @@
+ txreq -url "/foo"
+ rxresp
+ expect resp.status == 200
++ expect resp.http.etag == "foo"
+ expect resp.http.content-length == 6
+
+ txreq -url "/foo" \
+ -hdr "If-Modified-Since: Thu, 26 Jun 2008 12:00:00 GMT"
+ rxresp
+ expect resp.status == 200
++ expect resp.http.etag == "foo"
+
+ txreq -url "/foo" \
+ -hdr "If-Modified-Since: Thu, 26 Jun 2008 12:00:01 GMT"
+ rxresp
+ expect resp.status == 304
++ expect resp.http.etag == "foo"
+
+ txreq -url "/foo" \
+ -hdr "If-Modified-Since: Thu, 26 Jun 2008 12:00:02 GMT"
+ rxresp
+ expect resp.status == 304
++ expect resp.http.etag == "foo"
+ }
+
+ client c1 -run
+Index: bin/varnishtest/tests/s00002.vtc
+===================================================================
+--- bin/varnishtest/tests/s00002.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/s00002.vtc (.../branches/2.0/varnish-cache)
+@@ -18,6 +18,7 @@
+ .interval = 1s;
+ .window = 2;
+ .threshold = 1;
++ .initial = 0;
+ }
+ }
+ sub vcl_fetch {
+Index: bin/varnishtest/tests/v00014.vtc
+===================================================================
+--- bin/varnishtest/tests/v00014.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/v00014.vtc (.../branches/2.0/varnish-cache)
+@@ -20,6 +20,7 @@
+ .interval = 1s;
+ .window = 3;
+ .threshold = 2;
++ .initial = 0;
+ }
+ }
+
+Index: bin/varnishtest/tests/r00306.vtc
+===================================================================
+--- bin/varnishtest/tests/r00306.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/r00306.vtc (.../branches/2.0/varnish-cache)
+@@ -27,6 +27,7 @@
+ .host = "127.0.0.1"; .port = "9180";
+ .probe = {
+ .url = "/";
++ .initial = 0;
+ }
+ }
+ director foo random {
+Index: bin/varnishtest/tests/c00026.vtc
+===================================================================
+--- bin/varnishtest/tests/c00026.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/c00026.vtc (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,53 @@
++# $Id$
++
++test "Test Combination of If-None-Match and If-Modified-Since"
++
++server s1 {
++ rxreq
++ expect req.url == "/foo"
++ txresp -hdr "ETag: 123456789" \
++ -hdr "Last-Modified: Thu, 26 Jun 2008 12:00:01 GMT" \
++ -body "11111\n"
++} -start
++
++varnish v1 -vcl+backend { } -start
++
++client c1 {
++ txreq -url "/foo"
++ rxresp
++ expect resp.status == 200
++ expect resp.http.content-length == 6
++
++ txreq -url "/foo" \
++ -hdr "If-None-Match: 123456789"
++ rxresp
++ expect resp.status == 304
++
++ txreq -url "/foo" \
++ -hdr "If-Modified-Since: Thu, 26 Jun 2008 12:00:01 GMT"
++ rxresp
++ expect resp.status == 304
++
++ txreq -url "/foo" \
++ -hdr "If-Modified-Since: Thu, 26 Jun 2008 12:00:00 GMT" \
++ -hdr "If-None-Match: 123456789"
++ rxresp
++ expect resp.status == 200
++
++ txreq -url "/foo" \
++ -hdr "If-Modified-Since: Thu, 26 Jun 2008 12:00:01 GMT" \
++ -hdr "If-None-Match: 12345678"
++ rxresp
++ expect resp.status == 200
++
++ txreq -url "/foo" \
++ -hdr "If-Modified-Since: Thu, 26 Jun 2008 12:00:01 GMT" \
++ -hdr "If-None-Match: 123456789"
++ rxresp
++ expect resp.status == 304
++
++}
++
++client c1 -run
++
++client c1 -run
+Index: bin/varnishtest/tests/c00028.vtc
+===================================================================
+--- bin/varnishtest/tests/c00028.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/c00028.vtc (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,24 @@
++# $Id$
++
++test "Test that we can't recurse restarts forever"
++
++varnish v1 -vcl {
++ backend bad {
++ .host = "127.0.0.1";
++ .port = "9090";
++ }
++
++ sub vcl_recv {
++ set req.backend = bad;
++ }
++ sub vcl_error {
++ restart;
++ }
++ } -start
++
++client c1 {
++ txreq -url "/"
++ rxresp
++ expect resp.status == 503
++} -run
++
+Index: bin/varnishtest/tests/e00013.vtc
+===================================================================
+--- bin/varnishtest/tests/e00013.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/e00013.vtc (.../branches/2.0/varnish-cache)
+@@ -6,7 +6,7 @@
+ rxreq
+ expect req.url == "/foo"
+ txresp -hdr "Connection: close"
+- send { }
++ send {<x> }
+ } -start
+
+ varnish v1 -vcl+backend {
+Index: bin/varnishtest/tests/e00015.vtc
+===================================================================
+--- bin/varnishtest/tests/e00015.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/e00015.vtc (.../branches/2.0/varnish-cache)
+@@ -0,0 +1,48 @@
++# $Id$
++
++test "ESI requests turned off"
++
++server s1 {
++ rxreq
++ txresp -body {
++ <html>
++ Before include
++ <esi:include src="/body"/>
++ After include
++ }
++ rxreq
++ txresp -body {
++ <html>
++ Before include
++ <esi:include src="/body"/>
++ After include
++ }
++ rxreq
++ expect req.url == "/body"
++ txresp -body {
++ Included file
++ }
++} -start
++
++varnish v1 -vcl+backend {
++ sub vcl_fetch {
++ if(req.url == "/") {
++ set req.esi = false;
++ }
++ esi;
++ }
++} -start
++
++client c1 {
++ txreq
++ rxresp
++ expect resp.bodylen == 73
++ expect resp.status == 200
++ txreq -url "/esi"
++ rxresp
++ expect resp.bodylen == 65
++ expect resp.status == 200
++}
++
++client c1 -run
++varnish v1 -expect esi_errors == 0
+
+Property changes on: bin/varnishtest/tests/e00015.vtc
+___________________________________________________________________
+Added: svn:keywords
+ + Id
+
+Index: bin/varnishtest/tests/c00001.vtc
+===================================================================
+--- bin/varnishtest/tests/c00001.vtc (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/tests/c00001.vtc (.../branches/2.0/varnish-cache)
+@@ -36,7 +36,7 @@
+ expect resp.http.snafu2 == "_frap_"
+ expect resp.http.snafu3 == "_f\\rap_"
+ expect resp.http.snafu4 == "_f&rap_"
+- expect resp.http.snafu5 == "_barffra\p_"
+- # NB: have to escape the \\ in the next line
++ # NB: have to escape the \\ in the next two lines
++ expect resp.http.snafu5 == "_barffra\\p_"
+ expect resp.http.snafu6 == "_f&rap\\_"
+ } -run
+Index: bin/varnishtest/vtc_varnish.c
+===================================================================
+--- bin/varnishtest/vtc_varnish.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/vtc_varnish.c (.../branches/2.0/varnish-cache)
+@@ -326,9 +326,14 @@
+ vtc_log(v->vl, 2, "R %d Status: %04x", r, status);
+ if (WIFEXITED(status) && WEXITSTATUS(status) == 2)
+ return;
++#ifdef WCOREDUMP
+ vtc_log(v->vl, 0, "Bad exit code: %04x sig %x exit %x core %x",
+ status, WTERMSIG(status), WEXITSTATUS(status),
+ WCOREDUMP(status));
++#else
++ vtc_log(v->vl, 0, "Bad exit code: %04x sig %x exit %x",
++ status, WTERMSIG(status), WEXITSTATUS(status));
++#endif
+ }
+
+ /**********************************************************************
+Index: bin/varnishtest/vtc_http.c
+===================================================================
+--- bin/varnishtest/vtc_http.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/vtc_http.c (.../branches/2.0/varnish-cache)
+@@ -322,11 +322,13 @@
+ pfd[0].revents = 0;
+ i = poll(pfd, 1, hp->timeout);
+ assert(i > 0);
+- assert(hp->prxbuf < hp->nrxbuf);
++ assert(hp->prxbuf + n < hp->nrxbuf);
+ i = read(hp->fd, hp->rxbuf + hp->prxbuf, n);
+ if (i == 0)
+ return (i);
+- assert(i > 0);
++ if (i <= 0)
++ vtc_log(hp->vl, 0, "HTTP rx failed (%s)",
++ strerror(errno));
+ hp->prxbuf += i;
+ hp->rxbuf[hp->prxbuf] = '\0';
+ n -= i;
+@@ -781,7 +783,7 @@
+ hp->vl = vl;
+ hp->client = client;
+ hp->timeout = 3000;
+- hp->nrxbuf = 8192;
++ hp->nrxbuf = 640*1024;
+ hp->vsb = vsb_newauto();
+ hp->rxbuf = malloc(hp->nrxbuf); /* XXX */
+ AN(hp->rxbuf);
+Index: bin/varnishtest/vtc.c
+===================================================================
+--- bin/varnishtest/vtc.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtest/vtc.c (.../branches/2.0/varnish-cache)
+@@ -130,19 +130,9 @@
+ for (; *p != '\0'; p++) {
+ if (*p == '"')
+ break;
+-
+- if (*p == '\\' && p[1] == 'n') {
+- *q++ = '\n';
+- p++;
+- } else if (*p == '\\' && p[1] == 'r') {
+- *q++ = '\r';
+- p++;
+- } else if (*p == '\\' && p[1] == '\\') {
+- *q++ = '\\';
+- p++;
+- } else if (*p == '\\' && p[1] == '"') {
+- *q++ = '"';
+- p++;
++ if (*p == '\\') {
++ p += BackSlash(p, q) - 1;
++ q++;
+ } else {
+ if (*p == '\n')
+ fprintf(stderr,
+Index: bin/varnishtop/varnishtop.c
+===================================================================
+--- bin/varnishtop/varnishtop.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishtop/varnishtop.c (.../branches/2.0/varnish-cache)
+@@ -54,7 +54,8 @@
+ #include "varnishapi.h"
+
+ struct top {
+- unsigned char rec[4 + 255];
++ unsigned char rec[4];
++ unsigned char *rec_data;
+ unsigned clen;
+ unsigned hash;
+ VTAILQ_ENTRY(top) list;
+@@ -99,7 +100,7 @@
+ continue;
+ if (tp->clen != q - p)
+ continue;
+- if (memcmp(p + SHMLOG_DATA, tp->rec + SHMLOG_DATA,
++ if (memcmp(p + SHMLOG_DATA, tp->rec_data,
+ q - (p + SHMLOG_DATA)))
+ continue;
+ tp->count += 1.0;
+@@ -109,12 +110,15 @@
+ ntop++;
+ tp = calloc(sizeof *tp, 1);
+ assert(tp != NULL);
++ tp->rec_data = calloc(l, 1);
++ assert(tp->rec_data != NULL);
+ tp->hash = u;
+ tp->count = 1.0;
+ tp->clen = q - p;
+ VTAILQ_INSERT_TAIL(&top_head, tp, list);
+ }
+- memcpy(tp->rec, p, SHMLOG_DATA + l);
++ memcpy(tp->rec, p, SHMLOG_DATA - 1);
++ memcpy(tp->rec_data, p + SHMLOG_DATA, l);
+ while (1) {
+ tp2 = VTAILQ_PREV(tp, tophead, list);
+ if (tp2 == NULL || tp2->count >= tp->count)
+@@ -157,12 +161,13 @@
+ mvprintw(l, 0, "%9.2f %-*.*s %*.*s\n",
+ tp->count, maxfieldlen, maxfieldlen,
+ VSL_tags[tp->rec[SHMLOG_TAG]],
+- len, len, tp->rec + SHMLOG_DATA);
++ len, len, tp->rec_data);
+ t = tp->count;
+ }
+ tp->count *= .999;
+ if (tp->count * 10 < t || l > LINES * 10) {
+ VTAILQ_REMOVE(&top_head, tp, list);
++ free(tp->rec_data);
+ free(tp);
+ ntop--;
+ }
+@@ -267,8 +272,8 @@
+ VTAILQ_FOREACH_SAFE(tp, &top_head, list, tp2) {
+ if (tp->count <= 1.0)
+ break;
+- len = tp->rec[1];
+- printf("%9.2f %*.*s\n", tp->count, len, len, tp->rec + 4);
++ len = SHMLOG_LEN(tp->rec);
++ printf("%9.2f %s %*.*s\n", tp->count, VSL_tags[tp->rec[SHMLOG_TAG]], len, len, tp->rec + SHMLOG_DATA);
+ }
+ }
+
+Index: bin/varnishd/cache_acceptor_kqueue.c
+===================================================================
+--- bin/varnishd/cache_acceptor_kqueue.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_acceptor_kqueue.c (.../branches/2.0/varnish-cache)
+@@ -197,6 +197,7 @@
+ if (sp->t_open > deadline)
+ break;
+ VTAILQ_REMOVE(&sesshead, sp, list);
++ TCP_linger(sp->fd, 0);
+ vca_close_session(sp, "timeout");
+ SES_Delete(sp);
+ }
+Index: bin/varnishd/storage_file.c
+===================================================================
+--- bin/varnishd/storage_file.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/storage_file.c (.../branches/2.0/varnish-cache)
+@@ -577,6 +577,7 @@
+ p = mmap(NULL, sz, PROT_READ|PROT_WRITE,
+ MAP_NOCORE | MAP_NOSYNC | MAP_SHARED, sc->fd, off);
+ if (p != MAP_FAILED) {
++ (void) madvise(p, sz, MADV_RANDOM);
+ (*sum) += sz;
+ new_smf(sc, p, off, sz);
+ return;
+Index: bin/varnishd/steps.h
+===================================================================
+--- bin/varnishd/steps.h (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/steps.h (.../branches/2.0/varnish-cache)
+@@ -29,7 +29,7 @@
+ * $Id$
+ */
+
+-STEP(again, AGAIN)
++STEP(wait, WAIT)
+ STEP(first, FIRST)
+ STEP(recv, RECV)
+ STEP(start, START)
+Index: bin/varnishd/mgt_param.c
+===================================================================
+--- bin/varnishd/mgt_param.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/mgt_param.c (.../branches/2.0/varnish-cache)
+@@ -692,6 +692,15 @@
+ "have both IPv4 and IPv6 addresses.",
+ 0,
+ "off", "bool" },
++ { "session_max", tweak_uint,
++ &master.max_sess, 1000, UINT_MAX,
++ "Maximum number of sessions we will allocate "
++ "before just dropping connections.\n"
++ "This is mostly an anti-DoS measure, and setting it plenty "
++ "high should not hurt, as long as you have the memory for "
++ "it.\n",
++ 0,
++ "100000", "sessions" },
+ { "session_linger", tweak_uint,
+ &master.session_linger,0, UINT_MAX,
+ "How long time the workerthread lingers on the session "
+@@ -703,7 +712,7 @@
+ "anything for their keep, setting it too low just means that "
+ "more sessions take a detour around the acceptor.",
+ EXPERIMENTAL,
+- "0", "ms" },
++ "50", "ms" },
+ { "cli_buffer", tweak_uint, &master.cli_buffer, 4096, UINT_MAX,
+ "Size of buffer for CLI input."
+ "\nYou may need to increase this if you have big VCL files "
+@@ -756,7 +765,7 @@
+ { "purge_dups", tweak_bool, &master.purge_dups, 0, 0,
+ "Detect and eliminate duplicate purges.\n",
+ 0,
+- "off", "bool" },
++ "on", "bool" },
+ { NULL, NULL, NULL }
+ };
+
+Index: bin/varnishd/cache_vcl.c
+===================================================================
+--- bin/varnishd/cache_vcl.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_vcl.c (.../branches/2.0/varnish-cache)
+@@ -83,7 +83,13 @@
+ void
+ VCL_Get(struct VCL_conf **vcc)
+ {
++ static int once;
+
++ while (!once && vcl_active == NULL) {
++ sleep(1);
++ }
++ once = 1;
++
+ Lck_Lock(&vcl_mtx);
+ AN(vcl_active);
+ *vcc = vcl_active->conf;
+Index: bin/varnishd/cache_ws.c
+===================================================================
+--- bin/varnishd/cache_ws.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_ws.c (.../branches/2.0/varnish-cache)
+@@ -82,6 +82,10 @@
+ WS_Assert(ws);
+ }
+
++/*
++ * Reset a WS to start or a given pointer, likely from WS_Snapshot
++ */
++
+ void
+ WS_Reset(struct ws *ws, char *p)
+ {
+Index: bin/varnishd/cache_httpconn.c
+===================================================================
+--- bin/varnishd/cache_httpconn.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_httpconn.c (.../branches/2.0/varnish-cache)
+@@ -92,6 +92,7 @@
+ (void)WS_Reserve(htc->ws, (htc->ws->e - htc->ws->s) / 2);
+ htc->rxbuf.b = ws->f;
+ htc->rxbuf.e = ws->f;
++ *htc->rxbuf.e = '\0';
+ htc->pipeline.b = NULL;
+ htc->pipeline.e = NULL;
+ }
+Index: bin/varnishd/cache_response.c
+===================================================================
+--- bin/varnishd/cache_response.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_response.c (.../branches/2.0/varnish-cache)
+@@ -46,6 +46,7 @@
+ res_do_304(struct sess *sp)
+ {
+ char lm[64];
++ char *p;
+
+ WSP(sp, SLT_Length, "%u", 0);
+
+@@ -56,8 +57,23 @@
+ http_PrintfHeader(sp->wrk, sp->fd, sp->http, "Date: %s", lm);
+ http_SetHeader(sp->wrk, sp->fd, sp->http, "Via: 1.1 varnish");
+ http_PrintfHeader(sp->wrk, sp->fd, sp->http, "X-Varnish: %u", sp->xid);
+- TIM_format(sp->obj->last_modified, lm);
+- http_PrintfHeader(sp->wrk, sp->fd, sp->http, "Last-Modified: %s", lm);
++ if (sp->obj->last_modified) {
++ TIM_format(sp->obj->last_modified, lm);
++ http_PrintfHeader(sp->wrk, sp->fd, sp->http, "Last-Modified: %s", lm);
++ }
++
++ /* http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5 */
++ if (http_GetHdr(sp->obj->http, H_Cache_Control, &p))
++ http_PrintfHeader(sp->wrk, sp->fd, sp->http, "Cache-Control: %s", p);
++ if (http_GetHdr(sp->obj->http, H_Content_Location, &p))
++ http_PrintfHeader(sp->wrk, sp->fd, sp->http, "Content-Location: %s", p);
++ if (http_GetHdr(sp->obj->http, H_ETag, &p))
++ http_PrintfHeader(sp->wrk, sp->fd, sp->http, "ETag: %s", p);
++ if (http_GetHdr(sp->obj->http, H_Expires, &p))
++ http_PrintfHeader(sp->wrk, sp->fd, sp->http, "Expires: %s", p);
++ if (http_GetHdr(sp->obj->http, H_Vary, &p))
++ http_PrintfHeader(sp->wrk, sp->fd, sp->http, "Vary: %s", p);
++
+ http_PrintfHeader(sp->wrk, sp->fd, sp->http, "Connection: %s",
+ sp->doclose ? "close" : "keep-alive");
+ sp->wantbody = 0;
+@@ -68,17 +84,33 @@
+ static int
+ res_do_conds(struct sess *sp)
+ {
+- char *p;
++ char *p, *e;
+ double ims;
++ int do_cond = 0;
+
+- if (sp->obj->last_modified > 0 &&
+- http_GetHdr(sp->http, H_If_Modified_Since, &p)) {
++ /* RFC 2616 13.3.4 states we need to match both ETag
++ and If-Modified-Since if present*/
++
++ if (http_GetHdr(sp->http, H_If_Modified_Since, &p) ) {
++ if (!sp->obj->last_modified)
++ return (0);
+ ims = TIM_parse(p);
+ if (ims > sp->t_req) /* [RFC2616 14.25] */
+ return (0);
+ if (sp->obj->last_modified > ims) {
+ return (0);
+ }
++ do_cond = 1;
++ }
++
++ if (http_GetHdr(sp->http, H_If_None_Match, &p) &&
++ http_GetHdr(sp->obj->http, H_ETag, &e)) {
++ if (strcmp(p,e) != 0)
++ return (0);
++ do_cond = 1;
++ }
++
++ if (do_cond == 1) {
+ res_do_304(sp);
+ return (1);
+ }
+@@ -106,9 +138,12 @@
+ HTTPH_A_DELIVER);
+
+ /* Only HTTP 1.1 can do Chunked encoding */
+- if (sp->http->protover < 1.1 && !VTAILQ_EMPTY(&sp->obj->esibits))
+- http_Unset(sp->http, H_Transfer_Encoding);
+-
++ if (!sp->disable_esi && !VTAILQ_EMPTY(&sp->obj->esibits)) {
++ http_Unset(sp->http, H_Content_Length);
++ if(sp->http->protover >= 1.1)
++ http_PrintfHeader(sp->wrk, sp->fd, sp->http, "Transfer-Encoding: chunked");
++ }
++
+ TIM_format(TIM_real(), time_str);
+ http_PrintfHeader(sp->wrk, sp->fd, sp->http, "Date: %s", time_str);
+
+@@ -139,10 +174,10 @@
+
+ WRW_Reserve(sp->wrk, &sp->fd);
+
+- if (sp->esis == 0)
++ if (sp->disable_esi || sp->esis == 0)
+ sp->acct_req.hdrbytes += http_Write(sp->wrk, sp->http, 1);
+
+- if (sp->wantbody && !VTAILQ_EMPTY(&sp->obj->esibits)) {
++ if (!sp->disable_esi && sp->wantbody && !VTAILQ_EMPTY(&sp->obj->esibits)) {
+ if (WRW_FlushRelease(sp->wrk)) {
+ vca_close_session(sp, "remote closed");
+ return;
+@@ -152,7 +187,8 @@
+ }
+
+ if (sp->wantbody) {
+- if (sp->esis > 0 &&
++ if (!sp->disable_esi &&
++ sp->esis > 0 &&
+ sp->http->protover >= 1.1 &&
+ sp->obj->len > 0) {
+ sprintf(lenbuf, "%x\r\n", sp->obj->len);
+@@ -183,7 +219,8 @@
+ (void)WRW_Write(sp->wrk, st->ptr, st->len);
+ }
+ assert(u == sp->obj->len);
+- if (sp->esis > 0 &&
++ if (!sp->disable_esi &&
++ sp->esis > 0 &&
+ sp->http->protover >= 1.1 &&
+ sp->obj->len > 0)
+ (void)WRW_Write(sp->wrk, "\r\n", -1);
+Index: bin/varnishd/cache_cli.c
+===================================================================
+--- bin/varnishd/cache_cli.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_cli.c (.../branches/2.0/varnish-cache)
+@@ -158,8 +158,7 @@
+ continue;
+ assert(i == 1);
+ if (pfd[0].revents & POLLHUP) {
+- fprintf(stderr,
+- "EOF on CLI connection, exiting\n");
++ VSL(SLT_CLI, 0, "EOF on CLI connection, worker stops");
+ exit(0);
+ }
+ i = VLU_Fd(heritage.cli_in, vlu);
+Index: bin/varnishd/varnishd.1
+===================================================================
+--- bin/varnishd/varnishd.1 (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/varnishd.1 (.../branches/2.0/varnish-cache)
+@@ -326,8 +326,12 @@
+ address and port.
+ The following commands are available:
+ .Bl -tag -width 4n
+-.It Cm help
++.It Cm help Op Ar command
+ Display a list of available commands.
++.Pp
++If the
++.Ar command
++is specified, display help for this command.
+ .It Cm param.set Ar param Ar value
+ Set the parameter specified by
+ .Ar param
+@@ -336,35 +340,78 @@
+ See
+ .Sx Run-Time Parameters
+ for a list of parameters.
+-.It Cm param.show Ar param
+-Display the value of the parameter specified by
+-.Ar param .
+-See
+-.Sx Run-Time Parameters
+-for a list of parameters.
+-.It Cm param.show Op Fl l
+-Display a list of run-time parameters and their values.
++.It Xo
++.Cm param.show
++.Op Fl l
++.Op Ar param
++.Xc
++Display a list if run-time parameters and their values.
++.Pp
+ If the
+ .Fl l
+ option is specified, the list includes a brief explanation of each
+ parameter.
++.Pp
++If a
++.Ar param
++is specified, display only the value and explanation for this
++parameter.
+ .It Cm ping Op Ns Ar timestamp
+-Ping the child process.
++Ping the Varnish cache process, keeping the connection alive.
++.It Cm purge Ar field Ar operator Ar argument Op && Ar field Ar operator Ar argument Op ...
++Immediately invalidate all documents matching the purge expression.
++See
++.Va Purge expressions
++for more documentation and examples.
++.It Cm purge.hash Ar regex
++Immediately invalidate all documents where
++.Va obj.hash
++matches the
++.Va regex .
++The default object hash contains the values from
++.Va req.url
++and either
++.Va req.http.host
++or
++.Va server.ip
++depending on the presence of a Host: header in the request sent by the
++client.
++The object hash may be modified further by
++.Va VCL.
++.It Cm purge.list
++Display the purge list.
++.Pp
++All requests for objects from the cache are matched against items on
++the purge list.
++If an object in the cache is older than a matching purge list item, it
++is considered
++.Qq purged ,
++and will be fetched from the backend instead.
++.Pp
++When a purge expression is older than all the objects in the cache, it
++is removed from the list.
++.It Cm purge.url Ar regexp
++Immediately invalidate all documents whose URL matches the specified
++regular expression.
++.It Cm quit
++Close the connection to the varnish admin port.
+ .It Cm start
+-Start the child process if it is not already running.
++Start the Varnish cache process if it is not already running.
+ .It Cm stats
+-Display server statistics.
++Show summary statistics.
++.Pp
+ All the numbers presented are totals since server startup; for a
+ better idea of the current situation, use the
+ .Xr varnishstat 1
+ utility.
+ .It Cm status
+-Check the status of the child process.
++Check the status of the Varnish cache process.
+ .It Cm stop
+-Stop the child process.
++Stop the Varnish cache process.
+ .It Cm url.purge Ar regexp
+-Immediately invalidate all documents whos URL matches the specified
+-regular expression.
++Deprecated, see
++.Cm purge.url
++instead.
+ .It Cm vcl.discard Ar configname
+ Discard the configuration specified by
+ .Ar configname .
+@@ -583,6 +630,65 @@
+ The default is
+ .Dv off .
+ .El
++.Ss Purge expressions
++A purge expression consists of one or more conditions.
++A condition consists of a field, an operator, and an argument.
++Conditions can be ANDed together with
++.Qq && .
++.Pp
++A field can be any of the variables from VCL, for instance
++.Va req.url ,
++.Va req.http.host
++or
++.Va obj.set-cookie .
++.Pp
++Operators are
++.Qq ==
++for direct comparision,
++.Qq ~
++for a regular expression match, and
++.Qq >
++or
++.Qq <
++for size comparisons.
++Prepending an operator with
++.Qq \&!
++negates the expression.
++.Pp
++The argument could be a quoted string, a regexp, or an integer.
++Integers can have
++.Qq KB ,
++.Qq MB ,
++.Qq GB
++or
++.Qq TB
++appended for size related fields.
++.Pp
++Simple example: All requests where
++.Va req.url
++exactly matches the string
++.Va /news
++are purged from the cache.
++.Bd -literal -offset 4n
++req.url == "/news"
++.Ed
++.Pp
++Example: Purge all documents where the name does not end with
++.Qq .ogg ,
++and where the size of the object is greater than 10 megabytes.
++.Bd -literal -offset 4n
++req.url !~ "\\.ogg$" && obj.size > 10MB
++.Ed
++.Pp
++Example: Purge all documents where the serving host is
++.Qq example.com
++or
++.Qq www.example.com ,
++and where the Set-Cookie header received from the backend contains
++.Qq USERID=1663 .
++.Bd -literal -offset 4n
++req.http.host ~ "^(www\\.)example.com$" && obj.set-cookie ~ "USERID=1663"
++.Ed
+ .Sh SEE ALSO
+ .Xr varnishlog 1 ,
+ .Xr varnishhist 1 ,
+@@ -609,4 +715,6 @@
+ .An Poul-Henning Kamp Aq phk@phk.freebsd.dk
+ in cooperation with Verdens Gang AS and Linpro AS.
+ This manual page was written by
+-.An Dag-Erling Sm\(/orgrav Aq des@des.no .
++.An Dag-Erling Sm\(/orgrav Aq des@des.no
++with updates by
++.An Stig Sandbeck Mathisen Aq ssm@debian.org
+Index: bin/varnishd/cache_vrt_esi.c
+===================================================================
+--- bin/varnishd/cache_vrt_esi.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_vrt_esi.c (.../branches/2.0/varnish-cache)
+@@ -304,8 +304,7 @@
+ in->b++;
+
+ if (isspace(*in->b)) {
+- val->e = val->b = in->b;;
+- *val->e = '\0';
++ val->e = val->b = in->b;
+ in->b++;
+ return (1);
+ }
+@@ -340,7 +339,6 @@
+ val->e = in->b;
+ in->b++;
+ }
+- *val->e = '\0';
+ return (1);
+ }
+
+@@ -352,11 +350,11 @@
+ esi_handle_include(struct esi_work *ew)
+ {
+ struct esi_bit *eb;
+- char *p, *q;
++ char *p, *q, *c;
+ txt t = ew->tag;
+ txt tag;
+ txt val;
+- unsigned u, v;
++ unsigned u, v, s;
+ struct ws *ws;
+
+ if (ew->eb == NULL || ew->eb->include.b != NULL)
+@@ -371,10 +369,24 @@
+ continue;
+ if (Tlen(val) == 0) {
+ esi_error(ew, tag.b, Tlen(tag),
+- "ESI esi:include src attribute withou value");
++ "ESI esi:include src attribute without value");
+ continue;
+ }
+
++ /* Wee are saving the original string */
++ ws = ew->sp->obj->ws_o;
++ WS_Assert(ws);
++ s = 0;
++
++ if ( val.b != val.e ) {
++ s = Tlen(val) + 1;
++ c = WS_Alloc(ws, s);
++ memcpy(c, val.b, Tlen(val));
++ val.b = c;
++ val.e = val.b + s;
++ *val.e = '\0';
++ }
++
+ if (Tlen(val) > 7 && !memcmp(val.b, "http://", 7)) {
+ /* Rewrite to Host: header inplace */
+ eb->host.b = val.b;
+@@ -406,8 +418,6 @@
+
+ /* Use the objects WS to store the result */
+ CHECK_OBJ_NOTNULL(ew->sp->obj, OBJECT_MAGIC);
+- ws = ew->sp->obj->ws_o;
+- WS_Assert(ws);
+
+ /* Look for the last '/' before a '?' */
+ q = NULL;
+@@ -747,13 +757,6 @@
+ if (ew->incmt)
+ esi_error(ew, ew->t.e, -1,
+ "ESI 1.0 unterminated <!--esi comment");
+-
+- /*
+- * Our ESI implementation needs chunked encoding
+- */
+- http_Unset(sp->obj->http, H_Content_Length);
+- http_PrintfHeader(sp->wrk, sp->fd, sp->obj->http,
+- "Transfer-Encoding: chunked");
+ }
+
+ /*--------------------------------------------------------------------*/
+@@ -763,8 +766,11 @@
+ {
+ struct esi_bit *eb;
+ struct object *obj;
++ char *ws_wm;
++ struct http http_save;
+
+ WRW_Reserve(sp->wrk, &sp->fd);
++ http_save.magic = 0;
+ VTAILQ_FOREACH(eb, &sp->obj->esibits, list) {
+ if (Tlen(eb->verbatim)) {
+ if (sp->http->protover >= 1.1)
+@@ -786,8 +792,17 @@
+ sp->esis++;
+ obj = sp->obj;
+ sp->obj = NULL;
++
++ /* Save the master objects HTTP state, we may need it later */
++ if (http_save.magic == 0)
++ http_save = *sp->http;
++
++ /* Reset request to status before we started messing with it */
+ *sp->http = *sp->http0;
+- /* XXX: reset sp->ws */
++
++ /* Take a workspace snapshot */
++ ws_wm = WS_Snapshot(sp->ws);
++
+ http_SetH(sp->http, HTTP_HDR_URL, eb->include.b);
+ if (eb->host.b != NULL) {
+ http_Unset(sp->http, H_Host);
+@@ -822,10 +837,17 @@
+ assert(sp->step == STP_DONE);
+ sp->esis--;
+ sp->obj = obj;
++
++ /* Reset the workspace */
++ WS_Reset(sp->ws, ws_wm);
++
+ WRW_Reserve(sp->wrk, &sp->fd);
+ if (sp->fd < 0)
+ break;
+ }
++ /* Restore master objects HTTP state */
++ if (http_save.magic)
++ *sp->http = http_save;
+ if (sp->esis == 0 && sp->http->protover >= 1.1)
+ (void)WRW_Write(sp->wrk, "0\r\n\r\n", -1);
+ if (WRW_FlushRelease(sp->wrk))
+Index: bin/varnishd/cache_backend.c
+===================================================================
+--- bin/varnishd/cache_backend.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_backend.c (.../branches/2.0/varnish-cache)
+@@ -314,11 +314,11 @@
+ if (VBE_CheckFd(vc->fd)) {
+ /* XXX locking of stats */
+ VSL_stats->backend_reuse += 1;
+- VSL_stats->backend_conn++;
+ WSP(sp, SLT_Backend, "%d %s %s",
+ vc->fd, sp->director->vcl_name, bp->vcl_name);
+ return (vc);
+ }
++ VSL_stats->backend_toolate++;
+ sp->vbe = vc;
+ VBE_ClosedFd(sp);
+ }
+Index: bin/varnishd/hash_slinger.h
+===================================================================
+--- bin/varnishd/hash_slinger.h (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/hash_slinger.h (.../branches/2.0/varnish-cache)
+@@ -49,7 +49,7 @@
+ };
+
+ /* cache_hash.c */
+-void HSH_Prealloc(struct sess *sp);
++void HSH_Prealloc(struct sess *sp, int transient);
+ void HSH_Freestore(struct object *o);
+ void HSH_Copy(const struct sess *sp, struct objhead *o);
+ struct object *HSH_Lookup(struct sess *sp);
+Index: bin/varnishd/cache_fetch.c
+===================================================================
+--- bin/varnishd/cache_fetch.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_fetch.c (.../branches/2.0/varnish-cache)
+@@ -70,8 +70,11 @@
+
+ while (cl > 0) {
+ i = HTC_Read(htc, p, cl);
+- if (i <= 0)
++ if (i <= 0) {
++ WSP(sp, SLT_FetchError,
++ "straight read_error: %d", errno);
+ return (-1);
++ }
+ p += i;
+ cl -= i;
+ }
+@@ -110,8 +113,11 @@
+
+ /* If we didn't succeed, add to buffer, try again */
+ if (q == NULL || q == buf || *q != '\n') {
+- if (bp >= be)
++ if (bp >= be) {
++ WSP(sp, SLT_FetchError,
++ "chunked hex-line too long");
+ return (-1);
++ }
+ /*
+ * The semantics we need here is "read until you have
+ * received at least one character, but feel free to
+@@ -128,8 +134,11 @@
+ * at a time.
+ */
+ i = HTC_Read(htc, bp, 1);
+- if (i <= 0)
++ if (i <= 0) {
++ WSP(sp, SLT_FetchError,
++ "chunked read_error: %d", errno);
+ return (-1);
++ }
+ bp += i;
+ continue;
+ }
+@@ -241,8 +250,11 @@
+ AN(p);
+ AN(st);
+ i = HTC_Read(htc, p, v);
+- if (i < 0)
++ if (i < 0) {
++ WSP(sp, SLT_FetchError,
++ "eof read_error: %d", errno);
+ return (-1);
++ }
+ if (i == 0)
+ break;
+ p += i;
+@@ -338,8 +350,10 @@
+ /* Set up obj's workspace */
+ WS_Assert(sp->obj->ws_o);
+ VBE_GetFd(sp);
+- if (sp->vbe == NULL)
++ if (sp->vbe == NULL) {
++ WSP(sp, SLT_FetchError, "no backend connection");
+ return (__LINE__);
++ }
+ vc = sp->vbe;
+ /* Inherit the backend timeouts from the selected backend */
+ SES_InheritBackendTimeouts(sp);
+@@ -359,6 +373,7 @@
+ /* Deal with any message-body the request might have */
+ i = FetchReqBody(sp);
+ if (WRW_FlushRelease(w) || i > 0) {
++ WSP(sp, SLT_FetchError, "backend write error: %d", errno);
+ VBE_ClosedFd(sp);
+ /* XXX: other cleanup ? */
+ return (__LINE__);
+@@ -374,17 +389,19 @@
+ TCP_set_read_timeout(vc->fd, sp->first_byte_timeout);
+ do {
+ i = HTC_Rx(htc);
++ if (i < 0) {
++ WSP(sp, SLT_FetchError,
++ "http read error: %d", errno);
++ VBE_ClosedFd(sp);
++ /* XXX: other cleanup ? */
++ return (__LINE__);
++ }
+ TCP_set_read_timeout(vc->fd, sp->between_bytes_timeout);
+ }
+ while (i == 0);
+
+- if (i < 0) {
+- VBE_ClosedFd(sp);
+- /* XXX: other cleanup ? */
+- return (__LINE__);
+- }
+-
+ if (http_DissectResponse(sp->wrk, htc, hp)) {
++ WSP(sp, SLT_FetchError, "http format error");
+ VBE_ClosedFd(sp);
+ /* XXX: other cleanup ? */
+ return (__LINE__);
+@@ -407,14 +424,17 @@
+ cls = 0;
+ mklen = 0;
+ if (is_head) {
+- /* nothing */
++ VSL_stats->fetch_head++;
+ } else if (http_GetHdr(hp, H_Content_Length, &b)) {
++ VSL_stats->fetch_length++;
+ cls = fetch_straight(sp, htc, b);
+ mklen = 1;
+ } else if (http_HdrIs(hp, H_Transfer_Encoding, "chunked")) {
++ VSL_stats->fetch_chunked++;
+ cls = fetch_chunked(sp, htc);
+ mklen = 1;
+ } else if (http_GetHdr(hp, H_Transfer_Encoding, &b)) {
++ VSL_stats->fetch_bad++;
+ /* XXX: AUGH! */
+ WSL(sp->wrk, SLT_Debug, vc->fd, "Invalid Transfer-Encoding");
+ VBE_ClosedFd(sp);
+@@ -427,6 +447,7 @@
+ */
+ mklen = 1;
+ } else if (http_HdrIs(hp, H_Connection, "close")) {
++ VSL_stats->fetch_close++;
+ /*
+ * If we have connection closed, it is safe to read what
+ * comes in any case.
+@@ -434,19 +455,23 @@
+ cls = fetch_eof(sp, htc);
+ mklen = 1;
+ } else if (hp->protover < 1.1) {
++ VSL_stats->fetch_oldhttp++;
+ /*
+ * With no Connection header, assume EOF
+ */
+ cls = fetch_eof(sp, htc);
+ mklen = 1;
+ } else {
++ VSL_stats->fetch_zero++;
+ /*
+ * Assume zero length
++ * XXX: ???
+ */
+ mklen = 1;
+ }
+
+ if (cls < 0) {
++ VSL_stats->fetch_failed++;
+ /* XXX: Wouldn't this store automatically be released ? */
+ while (!VTAILQ_EMPTY(&sp->obj->store)) {
+ st = VTAILQ_FIRST(&sp->obj->store);
+@@ -511,5 +536,3 @@
+
+ CLI_AddFuncs(DEBUG_CLI, debug_cmds);
+ }
+-
+-
+Index: bin/varnishd/cache_panic.c
+===================================================================
+--- bin/varnishd/cache_panic.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_panic.c (.../branches/2.0/varnish-cache)
+@@ -37,6 +37,11 @@
+ #include <stdlib.h>
+ #include <unistd.h>
+
++#ifndef HAVE_EXECINFO_H
++#include "compat/execinfo.h"
++#else
++#include <execinfo.h>
++#endif
+ #include "cache.h"
+ #include "cache_backend.h"
+ #include "vcl.h"
+@@ -63,7 +68,7 @@
+ vsb_printf(vsp, "%*sws = %p { %s\n", indent, "",
+ ws, ws->overflow ? "overflow" : "");
+ vsb_printf(vsp, "%*sid = \"%s\",\n", indent + 2, "", ws->id);
+- vsb_printf(vsp, "%*s{s,f,r,e} = {%p,", indent + 2, "", ws->s);
++ vsb_printf(vsp, "%*s{s,f,r,e} = {%p", indent + 2, "", ws->s);
+ if (ws->f > ws->s)
+ vsb_printf(vsp, ",+%d", ws->f - ws->s);
+ else
+@@ -131,21 +136,21 @@
+ /*--------------------------------------------------------------------*/
+
+ static void
+-pan_http(const struct http *h)
++pan_http(const char *id, const struct http *h, int indent)
+ {
+ int i;
+
+- vsb_printf(vsp, " http = {\n");
+- pan_ws(h->ws, 6);
+- if (h->nhd > HTTP_HDR_FIRST) {
+- vsb_printf(vsp, " hd = {\n");
+- for (i = HTTP_HDR_FIRST; i < h->nhd; ++i)
+- vsb_printf(vsp, " \"%.*s\",\n",
+- (int)(h->hd[i].e - h->hd[i].b),
+- h->hd[i].b);
+- vsb_printf(vsp, " },\n");
++ vsb_printf(vsp, "%*shttp[%s] = {\n", indent, "", id);
++ vsb_printf(vsp, "%*sws = %p[%s]\n", indent + 2, "",
++ h->ws, h->ws ? h->ws->id : "");
++ for (i = 0; i < h->nhd; ++i) {
++ if (h->hd[i].b == NULL && h->hd[i].e == NULL)
++ continue;
++ vsb_printf(vsp, "%*s\"%.*s\",\n", indent + 4, "",
++ (int)(h->hd[i].e - h->hd[i].b),
++ h->hd[i].b);
+ }
+- vsb_printf(vsp, " },\n");
++ vsb_printf(vsp, "%*s},\n", indent, "");
+ }
+
+
+@@ -159,7 +164,7 @@
+ vsb_printf(vsp, " obj = %p {\n", o);
+ vsb_printf(vsp, " refcnt = %u, xid = %u,\n", o->refcnt, o->xid);
+ pan_ws(o->ws_o, 4);
+- pan_http(o->http);
++ pan_http("obj", o->http, 4);
+ vsb_printf(vsp, " len = %u,\n", o->len);
+ vsb_printf(vsp, " store = {\n");
+ VTAILQ_FOREACH(st, &o->store, list)
+@@ -190,8 +195,7 @@
+ pan_wrk(const struct worker *wrk)
+ {
+
+- vsb_printf(vsp, " worker = %p {\n", wrk);
+- vsb_printf(vsp, " },\n");
++ vsb_printf(vsp, " worker = %p\n", wrk);
+ }
+
+ /*--------------------------------------------------------------------*/
+@@ -229,7 +233,11 @@
+ " err_code = %d, err_reason = %s,\n", sp->err_code,
+ sp->err_reason ? sp->err_reason : "(null)");
+
++ vsb_printf(vsp, " restarts = %d, esis = %d\n",
++ sp->restarts, sp->esis);
++
+ pan_ws(sp->ws, 2);
++ pan_http("req", sp->http, 2);
+
+ if (sp->wrk != NULL)
+ pan_wrk(sp->wrk);
+@@ -249,6 +257,28 @@
+ /*--------------------------------------------------------------------*/
+
+ static void
++pan_backtrace(void)
++{
++ void *array[10];
++ size_t size;
++ size_t i;
++
++ size = backtrace (array, 10);
++ vsb_printf(vsp, "Backtrace:\n");
++ for (i = 0; i < size; i++) {
++ vsb_printf (vsp, " ");
++ if (Symbol_Lookup(vsp, array[i]) < 0) {
++ char **strings;
++ strings = backtrace_symbols(&array[i], 1);
++ vsb_printf(vsp, "%p: %s", array[i], strings[0]);
++ }
++ vsb_printf (vsp, "\n");
++ }
++}
++
++/*--------------------------------------------------------------------*/
++
++static void
+ pan_ic(const char *func, const char *file, int line, const char *cond,
+ int err, int xxx)
+ {
+@@ -264,7 +294,7 @@
+ break;
+ case 2:
+ vsb_printf(vsp,
+- "Panic from VCL:\n%s\n", cond);
++ "Panic from VCL:\n %s\n", cond);
+ break;
+ case 1:
+ vsb_printf(vsp,
+@@ -276,16 +306,19 @@
+ case 0:
+ vsb_printf(vsp,
+ "Assert error in %s(), %s line %d:\n"
+- " Condition(%s) not true.",
++ " Condition(%s) not true.\n",
+ func, file, line, cond);
+ break;
+ }
+ if (err)
+- vsb_printf(vsp, " errno = %d (%s)", err, strerror(err));
++ vsb_printf(vsp, "errno = %d (%s)\n", err, strerror(err));
+
+ q = THR_GetName();
+ if (q != NULL)
+- vsb_printf(vsp, " thread = (%s)", q);
++ vsb_printf(vsp, "thread = (%s)\n", q);
++
++ pan_backtrace();
++
+ if (!(params->diag_bitmap & 0x2000)) {
+ sp = THR_GetSession();
+ if (sp != NULL)
+Index: bin/varnishd/cache_expire.c
+===================================================================
+--- bin/varnishd/cache_expire.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_expire.c (.../branches/2.0/varnish-cache)
+@@ -275,26 +275,13 @@
+ */
+
+ static void *
+-exp_timer(void *arg)
++exp_timer(struct sess *sp, void *priv)
+ {
+- struct worker ww;
+ struct objexp *oe;
+ struct object *o;
+ double t;
+- struct sess *sp;
+- unsigned char logbuf[1024]; /* XXX size ? */
+
+- THR_SetName("cache-timeout");
+- (void)arg;
+-
+- sp = SES_New(NULL, 0);
+- XXXAN(sp);
+- sp->wrk = &ww;
+- ww.magic = WORKER_MAGIC;
+- ww.wlp = ww.wlb = logbuf;
+- ww.wle = logbuf + sizeof logbuf;
+-
+- AZ(sleep(10)); /* XXX: Takes time for VCL to arrive */
++ (void)priv;
+ VCL_Get(&sp->vcl);
+ t = TIM_real();
+ while (1) {
+@@ -303,7 +290,7 @@
+ CHECK_OBJ_ORNULL(oe, OBJEXP_MAGIC);
+ if (oe == NULL || oe->timer_when > t) { /* XXX: > or >= ? */
+ Lck_Unlock(&exp_mtx);
+- WSL_Flush(&ww, 0);
++ WSL_Flush(sp->wrk, 0);
+ AZ(sleep(1));
+ VCL_Refresh(&sp->vcl);
+ t = TIM_real();
+@@ -327,7 +314,7 @@
+ assert(oe->on_lru);
+ Lck_Unlock(&exp_mtx);
+
+- WSL(&ww, SLT_ExpPick, 0, "%u %s", o->xid, oe->timer_what);
++ WSL(sp->wrk, SLT_ExpPick, 0, "%u %s", o->xid, oe->timer_what);
+
+ if (oe->timer_what == tmr_prefetch) {
+ o->prefetch = 0.0;
+@@ -335,7 +322,7 @@
+ VCL_prefetch_method(sp);
+ sp->obj = NULL;
+ if (sp->handling == VCL_RET_FETCH) {
+- WSL(&ww, SLT_Debug, 0, "Attempt Prefetch %u",
++ WSL(sp->wrk, SLT_Debug, 0, "Attempt Prefetch %u",
+ o->xid);
+ }
+ Lck_Lock(&exp_mtx);
+@@ -351,7 +338,7 @@
+ sp->obj = NULL;
+
+ assert(sp->handling == VCL_RET_DISCARD);
+- WSL(&ww, SLT_ExpKill, 0,
++ WSL(sp->wrk, SLT_ExpKill, 0,
+ "%u %d", o->xid, (int)(o->ttl - t));
+ Lck_Lock(&exp_mtx);
+ assert(oe->timer_idx == BINHEAP_NOIDX);
+@@ -481,5 +468,5 @@
+ Lck_New(&exp_mtx);
+ exp_heap = binheap_new(NULL, object_cmp, object_update);
+ XXXAN(exp_heap);
+- AZ(pthread_create(&exp_thread, NULL, exp_timer, NULL));
++ WRK_BgThread(&exp_thread, "cache-timeout", exp_timer, NULL);
+ }
+Index: bin/varnishd/cache_ban.c
+===================================================================
+--- bin/varnishd/cache_ban.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_ban.c (.../branches/2.0/varnish-cache)
+@@ -86,6 +86,7 @@
+ int flags;
+ #define BAN_F_GONE (1 << 0)
+ VTAILQ_HEAD(,ban_test) tests;
++ VTAILQ_HEAD(,object) obj;
+ };
+
+ static VTAILQ_HEAD(banhead,ban) ban_head = VTAILQ_HEAD_INITIALIZER(ban_head);
+@@ -103,6 +104,7 @@
+ if (b == NULL)
+ return (b);
+ VTAILQ_INIT(&b->tests);
++ VTAILQ_INIT(&b->obj);
+ return (b);
+ }
+
+@@ -146,6 +148,9 @@
+ struct ban_test *bt;
+
+ CHECK_OBJ_NOTNULL(b, BAN_MAGIC);
++ AZ(b->refcount);
++ assert(VTAILQ_EMPTY(&b->obj));
++
+ while (!VTAILQ_EMPTY(&b->tests)) {
+ bt = VTAILQ_FIRST(&b->tests);
+ VTAILQ_REMOVE(&b->tests, bt, list);
+@@ -366,7 +371,7 @@
+ sb = vsb_newauto();
+ XXXAN(sb);
+ vsb_printf(sb, "%s %s ", a1, a2);
+- vsb_quote(sb, a3, 0);
++ vsb_quote(sb, a3, -1, 0);
+ vsb_finish(sb);
+ AZ(vsb_overflowed(sb));
+ bt->test = strdup(vsb_data(sb));
+@@ -439,6 +444,7 @@
+ Lck_Lock(&ban_mtx);
+ o->ban = ban_start;
+ ban_start->refcount++;
++ VTAILQ_INSERT_TAIL(&ban_start->obj, o, ban_list);
+ Lck_Unlock(&ban_mtx);
+ }
+
+@@ -470,6 +476,7 @@
+ CHECK_OBJ_NOTNULL(o->ban, BAN_MAGIC);
+ Lck_Lock(&ban_mtx);
+ o->ban->refcount--;
++ VTAILQ_REMOVE(&o->ban->obj, o, ban_list);
+ o->ban = NULL;
+
+ /* Attempt to purge last ban entry */
+@@ -518,8 +525,11 @@
+
+ Lck_Lock(&ban_mtx);
+ o->ban->refcount--;
+- if (b == o->ban) /* not banned */
++ VTAILQ_REMOVE(&o->ban->obj, o, ban_list);
++ if (b == o->ban) { /* not banned */
++ VTAILQ_INSERT_TAIL(&b0->obj, o, ban_list);
+ b0->refcount++;
++ }
+ VSL_stats->n_purge_obj_test++;
+ VSL_stats->n_purge_re_test += tests;
+ Lck_Unlock(&ban_mtx);
+@@ -529,6 +539,7 @@
+ return (0);
+ } else {
+ o->ttl = 0;
++ o->cacheable = 0;
+ WSP(sp, SLT_ExpBan, "%u was banned", o->xid);
+ EXP_Rearm(o);
+ o->ban = NULL;
+Index: bin/varnishd/default.vcl
+===================================================================
+--- bin/varnishd/default.vcl (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/default.vcl (.../branches/2.0/varnish-cache)
+@@ -141,8 +141,9 @@
+ <p>"} obj.response {"</p>
+ <h3>Guru Meditation:</h3>
+ <p>XID: "} req.xid {"</p>
++ <hr>
+ <address>
+- <a href="http://www.varnish-cache.org/">Varnish</a>
++ <a href="http://www.varnish-cache.org/">Varnish cache server</a>
+ </address>
+ </body>
+ </html>
+Index: bin/varnishd/cache_lck.c
+===================================================================
+--- bin/varnishd/cache_lck.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_lck.c (.../branches/2.0/varnish-cache)
+@@ -78,7 +78,7 @@
+ return;
+ }
+ r = pthread_mutex_trylock(&ilck->mtx);
+- assert(r == 0 || errno == EBUSY);
++ assert(r == 0 || r == EBUSY);
+ if (r) {
+ VSL(SLT_Debug, 0, "MTX_CONTEST(%s,%s,%d,%s)", p, f, l, ilck->w);
+ AZ(pthread_mutex_lock(&ilck->mtx));
+@@ -111,8 +111,8 @@
+ int r;
+
+ CAST_OBJ_NOTNULL(ilck, lck->priv, ILCK_MAGIC);
+- r = pthread_mutex_lock(&ilck->mtx);
+- assert(r == 0 || errno == EBUSY);
++ r = pthread_mutex_trylock(&ilck->mtx);
++ assert(r == 0 || r == EBUSY);
+ if (params->diag_bitmap & 0x8)
+ VSL(SLT_Debug, 0,
+ "MTX_TRYLOCK(%s,%s,%d,%s) = %d", p, f, l, ilck->w);
+Index: bin/varnishd/cache_vrt.c
+===================================================================
+--- bin/varnishd/cache_vrt.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_vrt.c (.../branches/2.0/varnish-cache)
+@@ -130,7 +130,9 @@
+ return (p);
+ }
+
+-/*--------------------------------------------------------------------*/
++/*--------------------------------------------------------------------
++ * XXX: Optimize the single element case ?
++ */
+
+ /*lint -e{818} ap,hp could be const */
+ static char *
+@@ -496,6 +498,25 @@
+
+ /*--------------------------------------------------------------------*/
+
++void
++VRT_l_req_esi(struct sess *sp, unsigned process_esi)
++{
++ CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
++ /* only allow you to turn of esi in the main request
++ else everything gets confused */
++ if(sp->esis == 0)
++ sp->disable_esi = !process_esi;
++}
++
++unsigned
++VRT_r_req_esi(struct sess *sp)
++{
++ CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
++ return (!sp->disable_esi);
++}
++
++/*--------------------------------------------------------------------*/
++
+ int
+ VRT_r_req_restarts(const struct sess *sp)
+ {
+@@ -846,20 +867,25 @@
+ }
+ b = BAN_New();
+ good = 0;
+- for (i = 1; ; i += 3) {
+- a1 = av[i];
++ for (i = 1; ;) {
++ a1 = av[i++];
+ if (a1 == NULL)
+ break;
+ good = 0;
+- a2 = av[i + 1];
++ a2 = av[i++];
+ if (a2 == NULL)
+ break;
+- a3 = av[i + 2];
++ a3 = av[i++];
+ if (a3 == NULL)
+ break;
+ if (BAN_AddTest(NULL, b, a1, a2, a3))
+ break;
+ good = 1;
++ if (av[i] == NULL)
++ break;
++ good = 0;
++ if (strcmp(av[i++], "&&"))
++ break;
+ }
+ if (!good)
+ /* XXX: report error how ? */
+Index: bin/varnishd/cache_http.c
+===================================================================
+--- bin/varnishd/cache_http.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_http.c (.../branches/2.0/varnish-cache)
+@@ -152,6 +152,11 @@
+ unsigned u;
+
+ for (u = HTTP_HDR_FIRST; u < hp->nhd; u++) {
++ /* XXX We have to check for empty header entries
++ because a header could have been lost in
++ http_copyHome */
++ if (hp->hd[u].b == NULL)
++ continue;
+ Tcheck(hp->hd[u]);
+ if (hp->hd[u].e < hp->hd[u].b + l + 1)
+ continue;
+@@ -327,12 +332,29 @@
+ hp->conds = 0;
+ r = NULL; /* For FlexeLint */
+ for (; p < t.e; p = r) {
+- /* XXX: handle continuation lines */
+- q = strchr(p, '\n');
+- assert(q != NULL);
+- r = q + 1;
+- if (q > p && q[-1] == '\r')
+- q--;
++
++ /* Find end of next header */
++ q = r = p;
++ while (r < t.e) {
++ if (!vct_iscrlf(*r)) {
++ r++;
++ continue;
++ }
++ q = r;
++ assert(r < t.e);
++ r += vct_skipcrlf(r);
++ if (r >= t.e)
++ break;
++ /* If line does not continue: got it. */
++ if (!vct_issp(*r))
++ break;
++
++ /* Clear line continuation LWS to spaces */
++ while (vct_islws(*q))
++ *q++ = ' ';
++ }
++
++ /* Empty header = end of headers */
+ if (p == q)
+ break;
+
+@@ -368,7 +390,7 @@
+ http_splitline(struct worker *w, int fd, struct http *hp,
+ const struct http_conn *htc, int h1, int h2, int h3)
+ {
+- char *p;
++ char *p, *q;
+
+ CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
+ CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
+@@ -381,40 +403,47 @@
+ continue;
+
+ /* First field cannot contain SP, CRLF or CTL */
+- hp->hd[h1].b = p;
+- for (; !vct_issp(*p); p++)
++ q = p;
++ for (; !vct_issp(*p); p++) {
+ if (vct_isctl(*p))
+- return (400);
++ return (-1);
++ }
++ hp->hd[h1].b = q;
+ hp->hd[h1].e = p;
+
+ /* Skip SP */
+- for (; vct_issp(*p); p++)
+- ;
++ for (; vct_issp(*p); p++) {
++ if (vct_isctl(*p))
++ return (-1);
++ }
+
+- /* Second field cannot contain LWS */
+- hp->hd[h2].b = p;
+- for (; !vct_islws(*p); p++)
+- ;
++ /* Second field cannot contain LWS or CTL */
++ q = p;
++ for (; !vct_islws(*p); p++) {
++ if (vct_isctl(*p))
++ return (-1);
++ }
++ hp->hd[h2].b = q;
+ hp->hd[h2].e = p;
+
+ if (!Tlen(hp->hd[h2]))
+ return (400);
+
+ /* Skip SP */
+- for (; vct_issp(*p); p++)
+- ;
++ for (; vct_issp(*p); p++) {
++ if (vct_isctl(*p))
++ return (-1);
++ }
+
+ /* Third field is optional and cannot contain CTL */
++ q = p;
+ if (!vct_iscrlf(*p)) {
+- hp->hd[h3].b = p;
+ for (; !vct_iscrlf(*p); p++)
+ if (vct_isctl(*p))
+- return (400);
+- hp->hd[h3].e = p;
+- } else {
+- hp->hd[h3].b = p;
+- hp->hd[h3].e = p;
++ return (-1);
+ }
++ hp->hd[h3].b = q;
++ hp->hd[h3].e = p;
+
+ /* Skip CRLF */
+ p += vct_skipcrlf(p);
+@@ -481,25 +510,35 @@
+ http_DissectResponse(struct worker *w, const struct http_conn *htc,
+ struct http *hp)
+ {
+- int i;
++ int i = 0;
+
+ CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
+ CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
+ hp->logtag = HTTP_Rx;
+
+- i = http_splitline(w, htc->fd, hp, htc,
+- HTTP_HDR_PROTO, HTTP_HDR_STATUS, HTTP_HDR_RESPONSE);
++ if (http_splitline(w, htc->fd, hp, htc,
++ HTTP_HDR_PROTO, HTTP_HDR_STATUS, HTTP_HDR_RESPONSE))
++ i = 503;
+
+- if (i != 0 || memcmp(hp->hd[HTTP_HDR_PROTO].b, "HTTP/1.", 7))
++ if (i == 0 && memcmp(hp->hd[HTTP_HDR_PROTO].b, "HTTP/1.", 7))
++ i = 503;
++
++ if (i == 0 && Tlen(hp->hd[HTTP_HDR_STATUS]) != 3)
++ i = 503;
++
++ if (i == 0) {
++ hp->status = strtoul(hp->hd[HTTP_HDR_STATUS].b, NULL, 10);
++ if (hp->status < 100 || hp->status > 999)
++ i = 503;
++ }
++
++ if (i != 0) {
+ WSLR(w, SLT_HttpGarbage, htc->fd, htc->rxbuf);
+- if (i != 0) {
+- if (hp->status == 0)
+- hp->status = i;
++ hp->status = i;
+ } else {
+- hp->status =
+- strtoul(hp->hd[HTTP_HDR_STATUS].b, NULL /* XXX */, 10);
++ http_ProtoVer(hp);
+ }
+- http_ProtoVer(hp);
++
+ if (hp->hd[HTTP_HDR_RESPONSE].b == NULL ||
+ !Tlen(hp->hd[HTTP_HDR_RESPONSE])) {
+ /* Backend didn't send a response string, use the standard */
+@@ -615,6 +654,8 @@
+ to->nhd = HTTP_HDR_FIRST;
+ to->status = fm->status;
+ for (u = HTTP_HDR_FIRST; u < fm->nhd; u++) {
++ if (fm->hd[u].b == NULL)
++ continue;
+ if (fm->hdf[u] & HDF_FILTER)
+ continue;
+ #define HTTPH(a, b, c, d, e, f, g) \
+@@ -675,6 +716,8 @@
+ hp->hd[u].b = p;
+ hp->hd[u].e = p + l;
+ } else {
++ /* XXX This leaves a slot empty */
++ VSL_stats->losthdr++;
+ WSLR(w, SLT_LostHeader, fd, hp->hd[u]);
+ hp->hd[u].b = NULL;
+ hp->hd[u].e = NULL;
+@@ -793,6 +836,8 @@
+ unsigned u, v;
+
+ for (v = u = HTTP_HDR_FIRST; u < hp->nhd; u++) {
++ if (hp->hd[u].b == NULL)
++ continue;
+ if (http_IsHdr(&hp->hd[u], hdr))
+ continue;
+ if (v != u) {
+@@ -829,6 +874,8 @@
+ WSLH(w, *w->wfd, hp, HTTP_HDR_PROTO);
+ }
+ for (u = HTTP_HDR_FIRST; u < hp->nhd; u++) {
++ if (hp->hd[u].b == NULL)
++ continue;
+ AN(hp->hd[u].b);
+ AN(hp->hd[u].e);
+ l += WRW_WriteH(w, &hp->hd[u], "\r\n");
+Index: bin/varnishd/cache_center.c
+===================================================================
+--- bin/varnishd/cache_center.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_center.c (.../branches/2.0/varnish-cache)
+@@ -80,17 +80,15 @@
+ static unsigned xids;
+
+ /*--------------------------------------------------------------------
+- * AGAIN
+- * We come here when we just completed a request and already have
+- * received (part of) the next one. Instead taking the detour
+- * around the acceptor and then back to a worker, just stay in this
+- * worker and do what it takes.
++ * WAIT
++ * Wait until we have a full request in our htc.
+ */
+
+ static int
+-cnt_again(struct sess *sp)
++cnt_wait(struct sess *sp)
+ {
+ int i;
++ struct pollfd pfd[1];
+
+ CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+ AZ(sp->vcl);
+@@ -98,12 +96,32 @@
+ assert(sp->xid == 0);
+
+ i = HTC_Complete(sp->htc);
+- while (i == 0)
++ while (i == 0) {
++ if (params->session_linger > 0) {
++ pfd[0].fd = sp->fd;
++ pfd[0].events = POLLIN;
++ pfd[0].revents = 0;
++ i = poll(pfd, 1, params->session_linger);
++ if (i == 0) {
++ WSL(sp->wrk, SLT_Debug, sp->fd, "herding");
++ VSL_stats->sess_herd++;
++ sp->wrk = NULL;
++ vca_return_session(sp);
++ return (1);
++ }
++ }
+ i = HTC_Rx(sp->htc);
++ }
+ if (i == 1) {
+ sp->step = STP_START;
+ } else {
+- vca_close_session(sp, "overflow");
++ if (i == -2)
++ vca_close_session(sp, "overflow");
++ else if (i == -1 && Tlen(sp->htc->rxbuf) == 0 &&
++ (errno == 0 || errno == ECONNRESET))
++ vca_close_session(sp, "EOF");
++ else
++ vca_close_session(sp, "error");
+ sp->step = STP_DONE;
+ }
+ return (0);
+@@ -198,7 +216,6 @@
+ cnt_done(struct sess *sp)
+ {
+ double dh, dp, da;
+- struct pollfd pfd[1];
+ int i;
+
+ CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+@@ -240,8 +257,14 @@
+
+ sp->t_req = NAN;
+
+- if (sp->fd >= 0 && sp->doclose != NULL)
++ if (sp->fd >= 0 && sp->doclose != NULL) {
++ /*
++ * This is an orderly close of the connection; ditch linger
++ * before we close, to get queued data transmitted.
++ */
++ TCP_linger(sp->fd, 0);
+ vca_close_session(sp, sp->doclose);
++ }
+ if (sp->fd < 0) {
+ SES_Charge(sp);
+ VSL_stats->sess_closed++;
+@@ -261,19 +284,13 @@
+ }
+ if (Tlen(sp->htc->rxbuf)) {
+ VSL_stats->sess_readahead++;
+- sp->step = STP_AGAIN;
++ sp->step = STP_WAIT;
+ return (0);
+ }
+ if (params->session_linger > 0) {
+- pfd[0].fd = sp->fd;
+- pfd[0].events = POLLIN;
+- pfd[0].revents = 0;
+- i = poll(pfd, 1, params->session_linger);
+- if (i > 0) {
+- VSL_stats->sess_linger++;
+- sp->step = STP_AGAIN;
+- return (0);
+- }
++ VSL_stats->sess_linger++;
++ sp->step = STP_WAIT;
++ return (0);
+ }
+ VSL_stats->sess_herd++;
+ SES_Charge(sp);
+@@ -307,7 +324,7 @@
+
+ w = sp->wrk;
+ if (sp->obj == NULL) {
+- HSH_Prealloc(sp);
++ HSH_Prealloc(sp, 1);
+ sp->obj = sp->wrk->nobj;
+ sp->obj->xid = sp->xid;
+ sp->obj->entered = sp->t_req;
+@@ -318,6 +335,9 @@
+ CHECK_OBJ_NOTNULL(sp->obj, OBJECT_MAGIC);
+ h = sp->obj->http;
+
++ if (sp->err_code < 100 || sp->err_code > 999)
++ sp->err_code = 501;
++
+ http_PutProtocol(w, sp->fd, h, "HTTP/1.1");
+ http_PutStatus(w, sp->fd, h, sp->err_code);
+ TIM_format(TIM_real(), date);
+@@ -332,13 +352,15 @@
+ http_StatusMessage(sp->err_code));
+ VCL_error_method(sp);
+
+- if (sp->handling == VCL_RET_RESTART) {
++ if (sp->handling == VCL_RET_RESTART && sp->restarts < params->max_restarts) {
+ HSH_Drop(sp);
+ sp->director = NULL;
+ sp->restarts++;
+ sp->step = STP_RECV;
+ return (0);
+- }
++ } else if (sp->handling == VCL_RET_RESTART)
++ sp->handling = VCL_RET_DELIVER;
++
+
+ /* We always close when we take this path */
+ sp->doclose = "error";
+@@ -439,6 +461,7 @@
+ if (sp->obj->objhead != NULL) {
+ VRY_Create(sp);
+ EXP_Insert(sp->obj);
++ AN(sp->obj->ban);
+ HSH_Unbusy(sp);
+ }
+ sp->acct_req.fetch++;
+@@ -452,7 +475,6 @@
+ static int
+ cnt_first(struct sess *sp)
+ {
+- int i;
+
+ /*
+ * XXX: If we don't have acceptfilters we are somewhat subject
+@@ -473,25 +495,8 @@
+ sp->wrk->lastused = sp->t_open;
+ sp->acct_req.sess++;
+ SES_RefSrcAddr(sp);
+- do
+- i = HTC_Rx(sp->htc);
+- while (i == 0);
+
+- switch (i) {
+- case 1:
+- sp->step = STP_START;
+- break;
+- case -1:
+- vca_close_session(sp, "error");
+- sp->step = STP_DONE;
+- break;
+- case -2:
+- vca_close_session(sp, "blast");
+- sp->step = STP_DONE;
+- break;
+- default:
+- WRONG("Illegal return from HTC_Rx");
+- }
++ sp->step = STP_WAIT;
+ return (0);
+ }
+
+@@ -734,7 +739,7 @@
+ }
+ assert(sp->handling == VCL_RET_PASS);
+ sp->acct_req.pass++;
+- HSH_Prealloc(sp);
++ HSH_Prealloc(sp, 0);
+ sp->obj = sp->wrk->nobj;
+ sp->wrk->nobj = NULL;
+ sp->obj->busy = 1;
+@@ -824,6 +829,8 @@
+ sp->director = sp->vcl->director[0];
+ AN(sp->director);
+
++ sp->disable_esi = 0;
++
+ VCL_recv_method(sp);
+ if (sp->restarts >= params->max_restarts) {
+ if (sp->err_code == 0)
+@@ -898,6 +905,13 @@
+ http_Setup(sp->http, sp->ws);
+ done = http_DissectRequest(sp);
+
++ /* If we could not even parse the request, just close */
++ if (done < 0) {
++ sp->step = STP_DONE;
++ vca_close_session(sp, "junk");
++ return (0);
++ }
++
+ /* Catch request snapshot */
+ sp->ws_req = WS_Snapshot(sp->ws);
+
+@@ -926,6 +940,10 @@
+
+ /* XXX: Don't bother with write failures for now */
+ (void)write(sp->fd, r, strlen(r));
++ /* XXX: When we do ESI includes, this is not removed
++ * XXX: because we use http0 as our basis. Believed
++ * XXX: safe, but potentially confusing.
++ */
+ http_Unset(sp->http, H_Expect);
+ }
+
+Index: bin/varnishd/cache_session.c
+===================================================================
+--- bin/varnishd/cache_session.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_session.c (.../branches/2.0/varnish-cache)
+@@ -249,35 +249,16 @@
+
+ /*--------------------------------------------------------------------*/
+
+-struct sess *
+-SES_New(const struct sockaddr *addr, unsigned len)
++static struct sess *
++ses_setup(struct sessmem *sm, const struct sockaddr *addr, unsigned len)
+ {
+- struct sessmem *sm;
+ struct sess *sp;
+ volatile unsigned u;
+
+- /*
+- * One of the two queues is unlocked because only one
+- * thread ever gets here to empty it.
+- */
+- assert(ses_qp <= 1);
+- sm = VTAILQ_FIRST(&ses_free_mem[ses_qp]);
+ if (sm == NULL) {
++ if (VSL_stats->n_sess_mem >= params->max_sess)
++ return (NULL);
+ /*
+- * If that queue is empty, flip queues holding the lock
+- * and try the new unlocked queue.
+- */
+- Lck_Lock(&ses_mem_mtx);
+- ses_qp = 1 - ses_qp;
+- Lck_Unlock(&ses_mem_mtx);
+- sm = VTAILQ_FIRST(&ses_free_mem[ses_qp]);
+- }
+- if (sm != NULL) {
+- VTAILQ_REMOVE(&ses_free_mem[ses_qp], sm, list);
+- } else {
+- /*
+- * If that fails, alloc new one.
+- *
+ * It is not necessary to lock mem_workspace, but we
+ * need to cache it locally, to make sure we get a
+ * consistent view of it.
+@@ -286,6 +267,8 @@
+ sm = malloc(sizeof *sm + u);
+ if (sm == NULL)
+ return (NULL);
++ /* Don't waste time zeroing the workspace */
++ memset(sm, 0, sizeof *sm);
+ sm->magic = SESSMEM_MAGIC;
+ sm->workspace = u;
+ VSL_stats->n_sess_mem++;
+@@ -293,7 +276,6 @@
+ CHECK_OBJ_NOTNULL(sm, SESSMEM_MAGIC);
+ VSL_stats->n_sess++;
+ sp = &sm->sess;
+- memset(sp, 0, sizeof *sp);
+ sp->magic = SESS_MAGIC;
+ sp->mem = sm;
+ sp->sockaddr = (void*)(&sm->sockaddr[0]);
+@@ -306,7 +288,8 @@
+ sp->t_resp = NAN;
+ sp->t_end = NAN;
+ sp->grace = NAN;
+-
++ sp->disable_esi = 0;
++
+ assert(len <= sp->sockaddrlen);
+ if (addr != NULL) {
+ memcpy(sp->sockaddr, addr, len);
+@@ -322,11 +305,49 @@
+ return (sp);
+ }
+
++/*--------------------------------------------------------------------
++ * Try to recycle an existing session.
++ */
++
++struct sess *
++SES_New(const struct sockaddr *addr, unsigned len)
++{
++ struct sessmem *sm;
++
++ assert(pthread_self() == VCA_thread);
++ assert(ses_qp <= 1);
++ sm = VTAILQ_FIRST(&ses_free_mem[ses_qp]);
++ if (sm == NULL) {
++ /*
++ * If that queue is empty, flip queues holding the lock
++ * and try the new unlocked queue.
++ */
++ Lck_Lock(&ses_mem_mtx);
++ ses_qp = 1 - ses_qp;
++ Lck_Unlock(&ses_mem_mtx);
++ sm = VTAILQ_FIRST(&ses_free_mem[ses_qp]);
++ }
++ if (sm != NULL)
++ VTAILQ_REMOVE(&ses_free_mem[ses_qp], sm, list);
++ return (ses_setup(sm, addr, len));
++}
++
++/*--------------------------------------------------------------------*/
++
++struct sess *
++SES_Alloc(const struct sockaddr *addr, unsigned len)
++{
++ return (ses_setup(NULL, addr, len));
++}
++
++/*--------------------------------------------------------------------*/
++
+ void
+ SES_Delete(struct sess *sp)
+ {
+ struct acct *b = &sp->acct;
+ struct sessmem *sm;
++ unsigned workspace;
+
+ CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+ sm = sp->mem;
+@@ -346,6 +367,12 @@
+ VSL_stats->n_sess_mem--;
+ free(sm);
+ } else {
++ /* Clean and prepare for reuse */
++ workspace = sm->workspace;
++ memset(sm, 0, sizeof *sm);
++ sm->magic = SESSMEM_MAGIC;
++ sm->workspace = workspace;
++
+ Lck_Lock(&ses_mem_mtx);
+ VTAILQ_INSERT_HEAD(&ses_free_mem[1 - ses_qp], sm, list);
+ Lck_Unlock(&ses_mem_mtx);
+Index: bin/varnishd/cache_hash.c
+===================================================================
+--- bin/varnishd/cache_hash.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_hash.c (.../branches/2.0/varnish-cache)
+@@ -82,13 +82,14 @@
+
+ /* Precreate an objhead and object for later use */
+ void
+-HSH_Prealloc(struct sess *sp)
++HSH_Prealloc(struct sess *sp, int transient)
+ {
+ struct worker *w;
+ struct objhead *oh;
+ struct object *o;
+ struct storage *st;
+-
++ void *p;
++
+ CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+ CHECK_OBJ_NOTNULL(sp->wrk, WORKER_MAGIC);
+ w = sp->wrk;
+@@ -106,16 +107,26 @@
+ CHECK_OBJ_NOTNULL(w->nobjhead, OBJHEAD_MAGIC);
+
+ if (w->nobj == NULL) {
+- st = STV_alloc(sp, params->obj_workspace);
+- XXXAN(st);
+- assert(st->space > sizeof *w->nobj);
+- o = (void *)st->ptr; /* XXX: align ? */
+- st->len = sizeof *o;
+- memset(o, 0, sizeof *o);
+- o->objstore = st;
+- WS_Init(o->ws_o, "obj",
+- st->ptr + st->len, st->space - st->len);
+- st->len = st->space;
++ if (transient) {
++ p = malloc(sizeof *o + params->obj_workspace);
++ XXXAN(p);
++ o = p;
++ p = o + 1;
++ memset(o, 0, sizeof *o);
++ o->magic = OBJECT_MAGIC;
++ WS_Init(o->ws_o, "obj", p, params->obj_workspace);
++ } else {
++ st = STV_alloc(sp, params->obj_workspace);
++ XXXAN(st);
++ assert(st->space > sizeof *w->nobj);
++ o = (void *)st->ptr; /* XXX: align ? */
++ st->len = sizeof *o;
++ memset(o, 0, sizeof *o);
++ o->objstore = st;
++ WS_Init(o->ws_o, "obj",
++ st->ptr + st->len, st->space - st->len);
++ st->len = st->space;
++ }
+ WS_Assert(o->ws_o);
+ http_Setup(o->http, o->ws_o);
+ o->magic = OBJECT_MAGIC;
+@@ -239,7 +250,7 @@
+ AN(hash);
+ w = sp->wrk;
+
+- HSH_Prealloc(sp);
++ HSH_Prealloc(sp, 0);
+ SHA256_Final(sp->wrk->nobjhead->digest, sp->wrk->sha256ctx);
+
+ if (sp->objhead != NULL) {
+@@ -449,7 +460,8 @@
+ if (r != 0)
+ return;
+
+- BAN_DestroyObj(o);
++ if (oh != NULL)
++ BAN_DestroyObj(o);
+ DSL(0x40, SLT_Debug, 0, "Object %u workspace min free %u",
+ o->xid, WS_Free(o->ws_o));
+
+@@ -458,7 +470,11 @@
+
+ ESI_Destroy(o);
+ HSH_Freestore(o);
+- STV_free(o->objstore);
++ if (o->objstore != NULL)
++ STV_free(o->objstore);
++ else
++ FREE_OBJ(o);
++
+ VSL_stats->n_object--;
+
+ if (oh == NULL)
+Index: bin/varnishd/cache_acceptor_poll.c
+===================================================================
+--- bin/varnishd/cache_acceptor_poll.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_acceptor_poll.c (.../branches/2.0/varnish-cache)
+@@ -146,6 +146,7 @@
+ continue;
+ VTAILQ_REMOVE(&sesshead, sp, list);
+ vca_unpoll(fd);
++ TCP_linger(sp->fd, 0);
+ vca_close_session(sp, "timeout");
+ SES_Delete(sp);
+ }
+Index: bin/varnishd/cache_acceptor_ports.c
+===================================================================
+--- bin/varnishd/cache_acceptor_ports.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_acceptor_ports.c (.../branches/2.0/varnish-cache)
+@@ -138,6 +138,7 @@
+ VTAILQ_REMOVE(&sesshead, sp, list);
+ if(sp->fd != -1)
+ vca_del(sp->fd);
++ TCP_linger(sp->fd, 0);
+ vca_close_session(sp, "timeout");
+ SES_Delete(sp);
+ }
+Index: bin/varnishd/cache_acceptor_epoll.c
+===================================================================
+--- bin/varnishd/cache_acceptor_epoll.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_acceptor_epoll.c (.../branches/2.0/varnish-cache)
+@@ -1,8 +1,10 @@
+ /*-
+ * Copyright (c) 2006 Verdens Gang AS
+- * Copyright (c) 2006-2008 Linpro AS
++ * Copyright (c) 2006-2009 Linpro AS
+ * All rights reserved.
+ *
++ * Author: Rogerio Carvalho Schneider <stockrt@gmail.com>
++ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+@@ -36,8 +38,9 @@
+ #if defined(HAVE_EPOLL_CTL)
+
+ #include <stdio.h>
++#include <string.h>
+ #include <errno.h>
+-#include <string.h>
++#include <fcntl.h>
+ #include <stdlib.h>
+ #include <unistd.h>
+
+@@ -47,77 +50,148 @@
+ #include "cache.h"
+ #include "cache_acceptor.h"
+
++#define NEEV 100
++
+ static pthread_t vca_epoll_thread;
++static pthread_t vca_epoll_sess_timeout_ticker_thread;
+ static int epfd = -1;
+
+ static VTAILQ_HEAD(,sess) sesshead = VTAILQ_HEAD_INITIALIZER(sesshead);
++int dotimer_pipe[2];
+
+ static void
+-vca_add(int fd, void *data)
++vca_modadd(int fd, void *data, short arm)
+ {
+- struct epoll_event ev = { EPOLLIN | EPOLLPRI, { data } };
+- AZ(epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev));
++
++ assert(fd >= 0);
++ if (data == vca_pipes || data == dotimer_pipe) {
++ struct epoll_event ev = { EPOLLIN | EPOLLPRI | EPOLLET, { data } };
++ AZ(epoll_ctl(epfd, arm, fd, &ev));
++ } else {
++ struct sess *sp = (struct sess *)data;
++ CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
++ sp->ev.data.ptr = data;
++#if defined(EPOLLRDHUP)
++ sp->ev.events = EPOLLIN | EPOLLPRI | EPOLLONESHOT | EPOLLRDHUP;
++#else
++ sp->ev.events = EPOLLIN | EPOLLPRI | EPOLLONESHOT;
++#endif
++ AZ(epoll_ctl(epfd, arm, fd, &sp->ev));
++ }
+ }
+
+ static void
+-vca_del(int fd)
++vca_cond_modadd(int fd, void *data)
+ {
+- struct epoll_event ev = { 0, { 0 } };
+- AZ(epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &ev));
++ struct sess *sp = (struct sess *)data;
++
++ assert(fd >= 0);
++ CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
++ if (sp->ev.data.ptr)
++ AZ(epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &sp->ev));
++ else {
++ sp->ev.data.ptr = data;
++#if defined(EPOLLRDHUP)
++ sp->ev.events = EPOLLIN | EPOLLPRI | EPOLLONESHOT | EPOLLRDHUP;
++#else
++ sp->ev.events = EPOLLIN | EPOLLPRI | EPOLLONESHOT;
++#endif
++ AZ(epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &sp->ev));
++ }
+ }
+
++static void
++vca_eev(const struct epoll_event *ep)
++{
++ struct sess *ss[NEEV], *sp;
++ int i, j;
++
++ AN(ep->data.ptr);
++ if (ep->data.ptr == vca_pipes) {
++ if (ep->events & EPOLLIN || ep->events & EPOLLPRI) {
++ j = 0;
++ i = read(vca_pipes[0], ss, sizeof ss);
++ if (i == -1 && errno == EAGAIN)
++ return;
++ while (i >= sizeof ss[0]) {
++ CHECK_OBJ_NOTNULL(ss[j], SESS_MAGIC);
++ assert(ss[j]->fd >= 0);
++ AZ(ss[j]->obj);
++ VTAILQ_INSERT_TAIL(&sesshead, ss[j], list);
++ vca_cond_modadd(ss[j]->fd, ss[j]);
++ j++;
++ i -= sizeof ss[0];
++ }
++ assert(i == 0);
++ }
++ } else {
++ CAST_OBJ_NOTNULL(sp, ep->data.ptr, SESS_MAGIC);
++ if (ep->events & EPOLLIN || ep->events & EPOLLPRI) {
++ i = HTC_Rx(sp->htc);
++ if (i == 0) {
++ vca_modadd(sp->fd, sp, EPOLL_CTL_MOD);
++ return; /* more needed */
++ }
++ VTAILQ_REMOVE(&sesshead, sp, list);
++ vca_handover(sp, i);
++ } else if (ep->events & EPOLLERR) {
++ VTAILQ_REMOVE(&sesshead, sp, list);
++ vca_close_session(sp, "ERR");
++ SES_Delete(sp);
++ } else if (ep->events & EPOLLHUP) {
++ VTAILQ_REMOVE(&sesshead, sp, list);
++ vca_close_session(sp, "HUP");
++ SES_Delete(sp);
++#if defined(EPOLLRDHUP)
++ } else if (ep->events & EPOLLRDHUP) {
++ VTAILQ_REMOVE(&sesshead, sp, list);
++ vca_close_session(sp, "RHUP");
++ SES_Delete(sp);
++#endif
++ }
++ }
++}
++
++/*--------------------------------------------------------------------*/
++
+ static void *
+ vca_main(void *arg)
+ {
+- struct epoll_event ev;
++ struct epoll_event ev[NEEV], *ep;
++ struct sess *sp;
+ double deadline;
+- int dotimer = 0;
+- double last_timeout = 0, tmp_timeout;
+- struct sess *sp, *sp2;
+- int i;
++ int dotimer, i, n;
+
+ THR_SetName("cache-epoll");
+ (void)arg;
+
+- epfd = epoll_create(16);
++ epfd = epoll_create(1);
+ assert(epfd >= 0);
+
+- vca_add(vca_pipes[0], vca_pipes);
++ vca_modadd(vca_pipes[0], vca_pipes, EPOLL_CTL_ADD);
++ vca_modadd(dotimer_pipe[0], dotimer_pipe, EPOLL_CTL_ADD);
+
+ while (1) {
+- if ((dotimer = epoll_wait(epfd, &ev, 1, 100)) > 0) {
+- if (ev.data.ptr == vca_pipes) {
+- i = read(vca_pipes[0], &sp, sizeof sp);
+- assert(i == sizeof sp);
+- CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+- VTAILQ_INSERT_TAIL(&sesshead, sp, list);
+- vca_add(sp->fd, sp);
+- } else {
+- CAST_OBJ_NOTNULL(sp, ev.data.ptr, SESS_MAGIC);
+- i = HTC_Rx(sp->htc);
+- if (i != 0) {
+- VTAILQ_REMOVE(&sesshead, sp, list);
+- vca_del(sp->fd);
+- vca_handover(sp, i);
+- }
+- }
++ dotimer = 0;
++ n = epoll_wait(epfd, ev, NEEV, -1);
++ for (ep = ev, i = 0; i < n; i++, ep++) {
++ if (ep->data.ptr == dotimer_pipe && (ep->events == EPOLLIN || ep->events == EPOLLPRI))
++ dotimer = 1;
++ else
++ vca_eev(ep);
+ }
+- tmp_timeout = TIM_mono();
+- if ((tmp_timeout - last_timeout) > 60) {
+- last_timeout = tmp_timeout;
+- } else {
+- if (dotimer > 0)
+- continue;
+- }
++ if (!dotimer)
++ continue;
+
+ /* check for timeouts */
+ deadline = TIM_real() - params->sess_timeout;
+- VTAILQ_FOREACH_SAFE(sp, &sesshead, list, sp2) {
+- CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
++ for (;;) {
++ sp = VTAILQ_FIRST(&sesshead);
++ if (sp == NULL)
++ break;
+ if (sp->t_open > deadline)
+- continue;
++ break;
+ VTAILQ_REMOVE(&sesshead, sp, list);
+- vca_del(sp->fd);
+ vca_close_session(sp, "timeout");
+ SES_Delete(sp);
+ }
+@@ -126,10 +200,44 @@
+
+ /*--------------------------------------------------------------------*/
+
++static void *
++vca_sess_timeout_ticker(void *arg)
++{
++ char ticker = 'R';
++ char junk;
++
++ THR_SetName("cache-epoll-sess_timeout_ticker");
++ (void)arg;
++
++ while (1) {
++ /* ticking */
++ assert(write(dotimer_pipe[1], &ticker, 1));
++ TIM_sleep(100 * 1e-3);
++ assert(read(dotimer_pipe[0], &junk, 1));
++ }
++}
++
++/*--------------------------------------------------------------------*/
++
+ static void
+ vca_epoll_init(void)
+ {
++ int i;
+
++ i = fcntl(vca_pipes[0], F_GETFL);
++ assert(i != -1);
++ i |= O_NONBLOCK;
++ i = fcntl(vca_pipes[0], F_SETFL, i);
++ assert(i != -1);
++
++ AZ(pipe(dotimer_pipe));
++ i = fcntl(dotimer_pipe[0], F_GETFL);
++ assert(i != -1);
++ i |= O_NONBLOCK;
++ i = fcntl(dotimer_pipe[0], F_SETFL, i);
++ assert(i != -1);
++
++ AZ(pthread_create(&vca_epoll_sess_timeout_ticker_thread, NULL, vca_sess_timeout_ticker, NULL));
+ AZ(pthread_create(&vca_epoll_thread, NULL, vca_main, NULL));
+ }
+
+Index: bin/varnishd/varnishd.c
+===================================================================
+--- bin/varnishd/varnishd.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/varnishd.c (.../branches/2.0/varnish-cache)
+@@ -339,7 +339,8 @@
+ pipes[1][1] = 1;
+
+ /* close the rest */
+- for (i = 5; i < getdtablesize(); i++)
++ j = getdtablesize();
++ for (i = 5; i < j; i++)
+ (void)close(i);
+
+ pfd[0].fd = pipes[0][0];
+@@ -414,6 +415,92 @@
+ exit (2);
+ }
+
++/*--------------------------------------------------------------------
++ * All praise POSIX! Thanks to our glorious standards there are no
++ * standard way to get a back-trace of the stack, and even if we hack
++ * that together from spit and pieces of string, there is no way no
++ * standard way to translate a pointer to a symbol, which returns anything
++ * usable. (See for instance FreeBSD PR-134391).
++ *
++ * Attempt to run nm(1) on our binary during startup, hoping it will
++ * give us a usable list of symbols.
++ */
++
++struct symbols {
++ uintptr_t a;
++ char *n;
++ VTAILQ_ENTRY(symbols) list;
++};
++
++static VTAILQ_HEAD(,symbols) symbols = VTAILQ_HEAD_INITIALIZER(symbols);
++
++int
++Symbol_Lookup(struct vsb *vsb, void *ptr)
++{
++ struct symbols *s, *s0;
++ uintptr_t pp;
++
++ pp = (uintptr_t)ptr;
++ s0 = NULL;
++ VTAILQ_FOREACH(s, &symbols, list) {
++ if (s->a > pp)
++ continue;
++ if (s0 == NULL || s->a > s0->a)
++ s0 = s;
++ }
++ if (s0 == NULL)
++ return (-1);
++ vsb_printf(vsb, "%p: %s+%jx", ptr, s0->n, (uintmax_t)pp - s0->a);
++ return (0);
++}
++
++static void
++Symbol_hack(const char *a0)
++{
++ char buf[BUFSIZ], *p, *e;
++ FILE *fi;
++ uintptr_t a;
++ struct symbols *s;
++
++ p = NULL;
++ asprintf(&p, "nm -an %s", a0);
++ if (p == NULL)
++ return;
++ fi = popen(p, "r");
++ free(p);
++ if (fi == NULL)
++ return;
++ while (fgets(buf, sizeof buf, fi)) {
++ if (buf[0] == ' ')
++ continue;
++ p = NULL;
++ a = strtoul(buf, &p, 16);
++ if (p == NULL)
++ continue;
++ if (a == 0)
++ continue;
++ if (*p++ != ' ')
++ continue;
++ p++;
++ if (*p++ != ' ')
++ continue;
++ if (*p <= ' ')
++ continue;
++ e = strchr(p, '\0');
++ AN(e);
++ while (e > p && isspace(e[-1]))
++ e--;
++ *e = '\0';
++ s = malloc(sizeof *s + strlen(p) + 1);
++ AN(s);
++ s->a = a;
++ s->n = (void*)(s + 1);
++ strcpy(s->n, p);
++ VTAILQ_INSERT_TAIL(&symbols, s, list);
++ }
++ (void)pclose(fi);
++}
++
+ /*--------------------------------------------------------------------*/
+
+ int
+@@ -443,6 +530,11 @@
+ setbuf(stdout, NULL);
+ setbuf(stderr, NULL);
+
++ Symbol_hack(argv[0]);
++
++ /* for ASSERT_MGT() */
++ mgt_pid = getpid();
++
+ /*
+ * Run in UTC timezone, on the off-chance that this operating
+ * system does not have a timegm() function, and translates
+Index: bin/varnishd/cache_pool.c
+===================================================================
+--- bin/varnishd/cache_pool.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_pool.c (.../branches/2.0/varnish-cache)
+@@ -618,6 +618,58 @@
+ }
+ }
+
++/*--------------------------------------------------------------------
++ * Create and starte a back-ground thread which as its own worker and
++ * session data structures;
++ */
++
++struct bgthread {
++ unsigned magic;
++#define BGTHREAD_MAGIC 0x23b5152b
++ const char *name;
++ bgthread_t *func;
++ void *priv;
++};
++
++static void *
++wrk_bgthread(void *arg)
++{
++ struct bgthread *bt;
++ struct worker ww;
++ struct sess *sp;
++ unsigned char logbuf[1024]; /* XXX: size ? */
++
++ CAST_OBJ_NOTNULL(bt, arg, BGTHREAD_MAGIC);
++ THR_SetName(bt->name);
++ sp = SES_Alloc(NULL, 0);
++ XXXAN(sp);
++ memset(&ww, 0, sizeof ww);
++ sp->wrk = &ww;
++ ww.magic = WORKER_MAGIC;
++ ww.wlp = ww.wlb = logbuf;
++ ww.wle = logbuf + sizeof logbuf;
++
++ (void)bt->func(sp, bt->priv);
++
++ WRONG("BgThread terminated");
++
++ return (NULL);
++}
++
++void
++WRK_BgThread(pthread_t *thr, const char *name, bgthread_t *func, void *priv)
++{
++ struct bgthread *bt;
++
++ ALLOC_OBJ(bt, BGTHREAD_MAGIC);
++ AN(bt);
++
++ bt->name = name;
++ bt->func = func;
++ bt->priv = priv;
++ AZ(pthread_create(thr, NULL, wrk_bgthread, bt));
++}
++
+ /*--------------------------------------------------------------------*/
+
+ void
+Index: bin/varnishd/cache_backend_poll.c
+===================================================================
+--- bin/varnishd/cache_backend_poll.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_backend_poll.c (.../branches/2.0/varnish-cache)
+@@ -241,18 +241,82 @@
+ }
+
+ /*--------------------------------------------------------------------
+- * One thread per backend to be poked.
++ * Record pokings...
+ */
+
+-static void *
+-vbp_wrk_poll_backend(void *priv)
++static void
++vbp_start_poke(struct vbp_target *vt)
+ {
+- struct vbp_target *vt;
++ CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
++
++#define BITMAP(n, c, t, b) vt->n <<= 1;
++#include "cache_backend_poll.h"
++#undef BITMAP
++
++ vt->last = 0;
++ vt->resp_buf[0] = '\0';
++}
++
++static void
++vbp_has_poked(struct vbp_target *vt)
++{
+ unsigned i, j;
+ uint64_t u;
+ const char *logmsg;
+ char bits[10];
+
++ CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
++
++ /* Calculate exponential average */
++ if (vt->happy & 1) {
++ if (vt->rate < AVG_RATE)
++ vt->rate += 1.0;
++ vt->avg += (vt->last - vt->avg) / vt->rate;
++ }
++
++ i = 0;
++#define BITMAP(n, c, t, b) bits[i++] = (vt->n & 1) ? c : '-';
++#include "cache_backend_poll.h"
++#undef BITMAP
++ bits[i] = '\0';
++
++ u = vt->happy;
++ for (i = j = 0; i < vt->probe.window; i++) {
++ if (u & 1)
++ j++;
++ u >>= 1;
++ }
++ vt->good = j;
++
++ if (vt->good >= vt->probe.threshold) {
++ if (vt->backend->healthy)
++ logmsg = "Still healthy";
++ else
++ logmsg = "Back healthy";
++ vt->backend->healthy = 1;
++ } else {
++ if (vt->backend->healthy)
++ logmsg = "Went sick";
++ else
++ logmsg = "Still sick";
++ vt->backend->healthy = 0;
++ }
++ VSL(SLT_Backend_health, 0, "%s %s %s %u %u %u %.6f %.6f %s",
++ vt->backend->vcl_name, logmsg, bits,
++ vt->good, vt->probe.threshold, vt->probe.window,
++ vt->last, vt->avg, vt->resp_buf);
++}
++
++/*--------------------------------------------------------------------
++ * One thread per backend to be poked.
++ */
++
++static void *
++vbp_wrk_poll_backend(void *priv)
++{
++ struct vbp_target *vt;
++ unsigned u;
++
+ THR_SetName("backend poll");
+
+ CAST_OBJ_NOTNULL(vt, priv, VBP_TARGET_MAGIC);
+@@ -272,59 +336,25 @@
+ if (vt->probe.threshold == 0)
+ vt->probe.threshold = 3;
+
++ if (vt->probe.threshold == ~0U)
++ vt->probe.initial = vt->probe.threshold - 1;
++
++ if (vt->probe.initial > vt->probe.threshold)
++ vt->probe.initial = vt->probe.threshold;
++
+ printf("Probe(\"%s\", %g, %g)\n",
+- vt->req,
+- vt->probe.timeout,
+- vt->probe.interval);
++ vt->req, vt->probe.timeout, vt->probe.interval);
+
+- /*lint -e{525} indent */
++ for (u = 0; u < vt->probe.initial; u++) {
++ vbp_start_poke(vt);
++ vt->happy |= 1;
++ vbp_has_poked(vt);
++ }
++
+ while (!vt->stop) {
+-#define BITMAP(n, c, t, b) vt->n <<= 1;
+-#include "cache_backend_poll.h"
+-#undef BITMAP
+- vt->last = 0;
+- vt->resp_buf[0] = '\0';
++ vbp_start_poke(vt);
+ vbp_poke(vt);
+-
+- /* Calculate exponential average */
+- if (vt->happy & 1) {
+- if (vt->rate < AVG_RATE)
+- vt->rate += 1.0;
+- vt->avg += (vt->last - vt->avg) / vt->rate;
+- }
+-
+- i = 0;
+-#define BITMAP(n, c, t, b) bits[i++] = (vt->n & 1) ? c : '-';
+-#include "cache_backend_poll.h"
+-#undef BITMAP
+- bits[i] = '\0';
+-
+- u = vt->happy;
+- for (i = j = 0; i < vt->probe.window; i++) {
+- if (u & 1)
+- j++;
+- u >>= 1;
+- }
+- vt->good = j;
+-
+- if (vt->good >= vt->probe.threshold) {
+- if (vt->backend->healthy)
+- logmsg = "Still healthy";
+- else
+- logmsg = "Back healthy";
+- vt->backend->healthy = 1;
+- } else {
+- if (vt->backend->healthy)
+- logmsg = "Went sick";
+- else
+- logmsg = "Still sick";
+- vt->backend->healthy = 0;
+- }
+- VSL(SLT_Backend_health, 0, "%s %s %s %u %u %u %.6f %.6f %s",
+- vt->backend->vcl_name, logmsg, bits,
+- vt->good, vt->probe.threshold, vt->probe.window,
+- vt->last, vt->avg, vt->resp_buf);
+-
++ vbp_has_poked(vt);
+ if (!vt->stop)
+ TIM_sleep(vt->probe.interval);
+ }
+Index: bin/varnishd/cache.h
+===================================================================
+--- bin/varnishd/cache.h (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache.h (.../branches/2.0/varnish-cache)
+@@ -48,6 +48,10 @@
+ #include <limits.h>
+ #include <unistd.h>
+
++#if defined(HAVE_EPOLL_CTL)
++#include <sys/epoll.h>
++#endif
++
+ #include "vqueue.h"
+
+ #include "vsb.h"
+@@ -58,8 +62,6 @@
+ #include "heritage.h"
+ #include "miniobj.h"
+
+-#define HTTP_HDR_MAX_VAL 32
+-
+ enum {
+ /* Fields from the first line of HTTP proto */
+ HTTP_HDR_REQ,
+@@ -283,6 +285,7 @@
+
+ struct http http[1];
+ VTAILQ_ENTRY(object) list;
++ VTAILQ_ENTRY(object) ban_list;
+
+ VTAILQ_HEAD(, storage) store;
+
+@@ -308,6 +311,7 @@
+
+ int restarts;
+ int esis;
++ int disable_esi;
+
+ struct worker *wrk;
+
+@@ -376,6 +380,10 @@
+ unsigned ihashptr;
+ unsigned lhashptr;
+ const char **hashptr;
++
++#if defined(HAVE_EPOLL_CTL)
++ struct epoll_event ev;
++#endif
+ };
+
+
+@@ -398,6 +406,7 @@
+ void vca_close_session(struct sess *sp, const char *why);
+ void VCA_Prep(struct sess *sp);
+ void VCA_Init(void);
++extern pthread_t VCA_thread;
+
+ /* cache_backend.c */
+
+@@ -544,9 +553,13 @@
+ void WRW_Sendfile(struct worker *w, int fd, off_t off, unsigned len);
+ #endif /* SENDFILE_WORKS */
+
++typedef void *bgthread_t(struct sess *, void *priv);
++void WRK_BgThread(pthread_t *thr, const char *name, bgthread_t *func, void *priv);
++
+ /* cache_session.c [SES] */
+ void SES_Init(void);
+ struct sess *SES_New(const struct sockaddr *addr, unsigned len);
++struct sess *SES_Alloc(const struct sockaddr *addr, unsigned len);
+ void SES_Delete(struct sess *sp);
+ void SES_RefSrcAddr(struct sess *sp);
+ void SES_Charge(struct sess *sp);
+Index: bin/varnishd/cache_pipe.c
+===================================================================
+--- bin/varnishd/cache_pipe.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_pipe.c (.../branches/2.0/varnish-cache)
+@@ -102,8 +102,12 @@
+ sp->t_resp = TIM_real();
+
+ memset(fds, 0, sizeof fds);
++
++ TCP_linger(vc->fd, 0);
+ fds[0].fd = vc->fd;
+ fds[0].events = POLLIN | POLLERR;
++
++ TCP_linger(sp->fd, 0);
+ fds[1].fd = sp->fd;
+ fds[1].events = POLLIN | POLLERR;
+
+Index: bin/varnishd/cache_acceptor.c
+===================================================================
+--- bin/varnishd/cache_acceptor.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/cache_acceptor.c (.../branches/2.0/varnish-cache)
+@@ -65,11 +65,20 @@
+
+ static struct acceptor const *vca_act;
+
+-static pthread_t vca_thread_acct;
++pthread_t VCA_thread;
+ static struct timeval tv_sndtimeo;
+ static struct timeval tv_rcvtimeo;
+-static struct linger linger;
+
++/*
++ * We want to get out of any kind of touble-hit TCP connections as fast
++ * as absolutely possible, so we set them LINGER enabled with zero timeout,
++ * so that even if there are outstanding write data on the socket, a close(2)
++ * will return immediately.
++ */
++static const struct linger linger = {
++ .l_onoff = 1,
++};
++
+ static unsigned char need_sndtimeo, need_rcvtimeo, need_linger, need_test;
+
+ int vca_pipes[2];
+@@ -106,13 +115,17 @@
+ need_test = 0;
+ }
+
++/*--------------------------------------------------------------------
++ * Called once the workerthread gets hold of the session, to do setup
++ * setup overhead, we don't want to bother the acceptor thread with.
++ */
++
+ void
+ VCA_Prep(struct sess *sp)
+ {
+ char addr[TCP_ADDRBUFSIZE];
+ char port[TCP_PORTBUFSIZE];
+
+-
+ TCP_name(sp->sockaddr, sp->sockaddrlen,
+ addr, sizeof addr, port, sizeof port);
+ sp->addr = WS_Dup(sp->ws, addr);
+@@ -239,11 +252,15 @@
+ continue;
+ }
+ sp = SES_New(addr, l);
+- XXXAN(sp);
+-
++ if (sp == NULL) {
++ AZ(close(i));
++ VSL_stats->client_drop++;
++ continue;
++ }
+ sp->fd = i;
+ sp->id = i;
+ sp->t_open = now;
++ sp->t_end = now;
+ sp->mylsock = ls;
+
+ sp->step = STP_FIRST;
+@@ -330,7 +347,7 @@
+ if (vca_act->pass == NULL)
+ AZ(pipe(vca_pipes));
+ vca_act->init();
+- AZ(pthread_create(&vca_thread_acct, NULL, vca_acct, NULL));
++ AZ(pthread_create(&VCA_thread, NULL, vca_acct, NULL));
+ VSL(SLT_Debug, 0, "Acceptor is %s", vca_act->name);
+ }
+
+Index: bin/varnishd/shmlog.c
+===================================================================
+--- bin/varnishd/shmlog.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/shmlog.c (.../branches/2.0/varnish-cache)
+@@ -71,16 +71,19 @@
+ vsl_wrap(void)
+ {
+
++ assert(loghead->magic == SHMLOGHEAD_MAGIC);
+ *logstart = SLT_ENDMARKER;
+ logstart[loghead->ptr] = SLT_WRAPMARKER;
+ loghead->ptr = 0;
+ VSL_stats->shm_cycles++;
++ assert(loghead->magic == SHMLOGHEAD_MAGIC);
+ }
+
+ static void
+ vsl_hdr(enum shmlogtag tag, unsigned char *p, unsigned len, unsigned id)
+ {
+
++ assert(loghead->magic == SHMLOGHEAD_MAGIC);
+ assert(len < 0x10000);
+ assert(id < 0x10000);
+ p[__SHMLOG_LEN_HIGH] = (len >> 8) & 0xff;
+@@ -280,13 +283,18 @@
+ void
+ VSL_Panic(int *len, char **ptr)
+ {
++ static char a[1] = { '\0' };
+
+ AN(len);
+ AN(ptr);
+- assert(loghead->magic == SHMLOGHEAD_MAGIC);
+- assert(loghead->hdrsize == sizeof *loghead);
+- *len = sizeof(loghead->panicstr);
+- *ptr = loghead->panicstr;
++ if (loghead->magic == SHMLOGHEAD_MAGIC) {
++ assert(loghead->hdrsize == sizeof *loghead);
++ *len = sizeof(loghead->panicstr);
++ *ptr = loghead->panicstr;
++ } else {
++ *len = 0;
++ *ptr = a;
++ }
+ }
+
+ /*--------------------------------------------------------------------*/
+Index: bin/varnishd/mgt_child.c
+===================================================================
+--- bin/varnishd/mgt_child.c (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/mgt_child.c (.../branches/2.0/varnish-cache)
+@@ -236,7 +236,7 @@
+ unsigned u;
+ char *p;
+ struct vev *e;
+- int i, cp[2];
++ int i, j, cp[2];
+
+ if (child_state != CH_STOPPED && child_state != CH_DIED)
+ return;
+@@ -304,7 +304,8 @@
+ /* Close anything we shouldn't know about */
+ closelog();
+ printf("Closed fds:");
+- for (i = STDERR_FILENO + 1; i < getdtablesize(); i++) {
++ j = getdtablesize();
++ for (i = STDERR_FILENO + 1; i < j; i++) {
+ if (vbit_test(fd_map, i))
+ continue;
+ if (close(i) == 0)
+@@ -345,7 +346,6 @@
+ e->callback = child_listener;
+ AZ(vev_add(mgt_evb, e));
+ ev_listen = e;
+-
+ AZ(ev_poker);
+ if (params->ping_interval > 0) {
+ e = vev_new();
+@@ -362,11 +362,10 @@
+ if (mgt_push_vcls_and_start(&u, &p)) {
+ REPORT(LOG_ERR, "Pushing vcls failed: %s", p);
+ free(p);
+- /* Pick up any stuff lingering on stdout/stderr */
+- (void)child_listener(NULL, EV_RD);
+- exit(2);
+- }
+- child_state = CH_RUNNING;
++ child_state = CH_RUNNING;
++ mgt_stop_child();
++ } else
++ child_state = CH_RUNNING;
+ }
+
+ /*--------------------------------------------------------------------*/
+Index: bin/varnishd/heritage.h
+===================================================================
+--- bin/varnishd/heritage.h (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/heritage.h (.../branches/2.0/varnish-cache)
+@@ -82,6 +82,9 @@
+ /* TTL used for synthesized error pages */
+ unsigned err_ttl;
+
++ /* Maximum concurrent sessions */
++ unsigned max_sess;
++
+ /* Worker threads and pool */
+ unsigned wthread_min;
+ unsigned wthread_max;
+Index: bin/varnishd/common.h
+===================================================================
+--- bin/varnishd/common.h (.../tags/varnish-2.0.4/varnish-cache)
++++ bin/varnishd/common.h (.../branches/2.0/varnish-cache)
+@@ -42,6 +42,10 @@
+ void VSL_MgtInit(const char *fn, unsigned size);
+ extern struct varnish_stats *VSL_stats;
+
++/* varnishd.c */
++struct vsb;
++int Symbol_Lookup(struct vsb *vsb, void *ptr);
++
+ #define TRUST_ME(ptr) ((void*)(uintptr_t)(ptr))
+
+ /* Really belongs in mgt.h, but storage_file chokes on both */
+Index: man/vcl.7so
+===================================================================
+--- man/vcl.7so (.../tags/varnish-2.0.4/varnish-cache)
++++ man/vcl.7so (.../branches/2.0/varnish-cache)
+@@ -93,6 +93,11 @@
+ }
+ .Ed
+ .Pp
++To avoid overloading backend servers,
++.Fa .max_connections
++can be set to limit the maximum number of concurrent backend connections.
++.Ed
++.Pp
+ The timeout parameters can be overridden in the backend declaration.
+ The timeout parameters are
+ .Fa .connect_timeout
+@@ -570,6 +575,9 @@
+ .It Va obj.lastuse
+ The approximate time elapsed since the object was last requests, in
+ seconds.
++.It Va obj.hits
++The approximate number of times the object has been delivered. A value of 0
++indicates a cache miss.
+ .El
+ .Pp
+ The following variables are available while determining the hash key
projects / packages / varnish.git / commitdiff