---------------------
PatchSet 4716 
Date: 2002/08/19 11:42:57
Author: rbcollins
Branch: esi
Tag: (none) 
Log:
esi:vars support (minus USER_AGENT)

Members: 
	src/ESI.c:1.1.2.16->1.1.2.17 
	src/client_side_reply.c:1.1.2.15->1.1.2.16 

Index: squid/src/ESI.c
===================================================================
RCS file: /cvsroot/squid-sf//squid/src/Attic/ESI.c,v
retrieving revision 1.1.2.16
retrieving revision 1.1.2.17
diff -u -r1.1.2.16 -r1.1.2.17
--- squid/src/ESI.c	19 Aug 2002 00:23:48 -0000	1.1.2.16
+++ squid/src/ESI.c	19 Aug 2002 11:42:57 -0000	1.1.2.17
@@ -1,6 +1,6 @@
 
 /*
- * $Id: ESI.c,v 1.1.2.16 2002/08/19 00:23:48 rbcollins Exp $
+ * $Id: ESI.c,v 1.1.2.17 2002/08/19 11:42:57 rbcollins Exp $
  *
  * DEBUG: section 86    ESI processing
  * AUTHOR: Robert Collins
@@ -48,6 +48,7 @@
 /* TODO: Factor the store memory segment management into a reusable code block 
  * or perhaps use membuffers here?
  */ 
+
 typedef struct _esiSegment {
     char buf[HTTP_REQBUF_SZ];
     size_t len; /* how much data has been pushed into this */
@@ -91,6 +92,25 @@
  * NOT TODO: esi:inline - out of scope.
  */
 
+/* esi variable replacement logic */
+/* Recursive uses are not supported by design */
+struct _query_elem{char *var, *val;};
+typedef struct {
+    esiSegment *output;
+    HttpHeader hdr;
+    struct _query_elem *query;
+    size_t query_sz;
+    size_t query_elements;
+    char *query_string;
+} esiVarState; 
+CBDATA_TYPE (esiVarState);
+FREE esiVarStateFree;
+static esiVarState *esiVarStateNew(HttpHeader const *, const char *uri);
+static void esiVarStateDoIt (esiVarState *);
+static void esiVarStateFeedData (esiVarState *, const char *buf, size_t len);
+static esiSegment *esiVarStateExtractList(esiVarState *);
+static char * esiVarStateExtractChar (esiVarState *);
+
 typedef enum {
     ESI_PROCESS_COMPLETE,
     ESI_PROCESS_PENDING_WONTFAIL,
@@ -111,8 +131,8 @@
 #define RENDER(foo, bar)  foo->vptr->render(foo, bar)
 typedef int esiAddElement (void *, esiElement *); /* add a child to an element */
 #define ADDELEMENT(foo, bar) foo->vptr->add(foo,bar)
-typedef esiProcessResult_t esiProcessSelf (void *); /* process this element */
-#define PROCESS(foo) foo->vptr->process(foo)
+typedef esiProcessResult_t esiProcessSelf (void *, int); /* process this element */
+#define PROCESS(foo, bar) foo->vptr->process(foo, bar)
 struct _esiElementType {
     esiRender *render;
     esiAddElement *add;
@@ -131,6 +151,7 @@
 static esiRender esiCommentRender;
 
 static esiRender esiLiteralRender;
+static esiProcessSelf esiLiteralProcess;
 
 static esiAddElement esiSequenceAdd;
 static esiRender esiSequenceRender;
@@ -155,18 +176,20 @@
     ESI_ELEMENT_REMOVE,
     ESI_ELEMENT_TRY,
     ESI_ELEMENT_ATTEMPT,
-    ESI_ELEMENT_EXCEPT
+    ESI_ELEMENT_EXCEPT,
+    ESI_ELEMENT_VARS
 } esiElementType_t;
 
 static esiElementType _esiComment  = {esiCommentRender,esiAddFail,esiProcessComplete};
-static esiElementType _esiLiteral  = {esiLiteralRender,esiAddFail,esiProcessComplete};
+static esiElementType _esiLiteral  = {esiLiteralRender,esiAddFail,esiLiteralProcess};
 static esiElementType _esiSequence = {esiSequenceRender,esiSequenceAdd,esiSequenceProcess};
 static esiElementType _esiInclude  = {esiIncludeRender, esiAddFail, esiIncludeProcess};
 static esiElementType _esiRemove   = {esiRemoveRender, esiRemoveAdd, esiProcessComplete};
 static esiElementType _esiTry      = {esiTryRender, esiTryAdd, esiTryProcess};
-/* esiAttempt and esiExcept are 'Sequences' */
+/* esiAttempt, esiExcept and esiVar are 'Sequences' */
 static esiElementType _esiAttempt  = {esiSequenceRender,esiSequenceAdd,esiSequenceProcess};
 static esiElementType _esiExcept   = {esiSequenceRender,esiSequenceAdd,esiSequenceProcess};
+static esiElementType _esiVar      = {esiSequenceRender,esiSequenceAdd,esiSequenceProcess};
 
 /* esiComment */
 typedef struct {
@@ -181,10 +204,14 @@
     esiElementType *vptr;
     /* optimise copies away later */
     esiSegment *buffer;
+    struct {
+	int donevars:1;
+    } flags;
+    esiVarState *varState;
 } esiLiteral;
 CBDATA_TYPE (esiLiteral);
 static FREE esiLiteralFree;
-static esiElement * esiLiteralNew(const XML_Char *s, int len);
+static esiElement * esiLiteralNew(esiContext *, const XML_Char *s, int len);
 
 /* esiSequence */
 typedef struct {
@@ -194,6 +221,9 @@
     size_t allocedsize;
     int elementcount;
     int processedcount;
+    struct {
+	int dovars:1;
+    } flags;
 } esiSequence;
 CBDATA_TYPE (esiSequence);
 static FREE esiSequenceFree;
@@ -250,6 +280,10 @@
 static FREE esiTryFree;
 static esiElement *esiTryNew(void);
 
+/* esiVar */
+typedef esiSequence esiVar;
+static esiElement *esiVarNew(void);
+
 /* esiContext */
 struct _esiContext {
     clientStreamNode *this; /* our stream node */
@@ -288,6 +322,7 @@
 	int stackdepth; /* self explanatory */
 	XML_Parser p; /* our parser */
     } parserState; /* todo factor this off somewhere else; */
+    esiVarState *varState;
     esiElement *tree;
 };
 
@@ -314,6 +349,9 @@
 static esiStreamContext *esiStreamContextNew (esiInclude *);
 /* esiSegment */
 static void esiSegmentFreeList (esiSegment **head);
+static void esiSegmentTransferList (esiSegment **from, esiSegment **to);
+static char *esiSegmentListToChar (esiSegment *head);
+static void esiSegmentListAppend (esiSegment **head, char const *, size_t);
 
 /* other */
 static CSCB esiBufferRecipient;
@@ -733,26 +771,12 @@
 	rv->this = this;
 	rv->http = http;
 	rv->flags.clientwantsdata = 1;
+	rv->varState = esiVarStateNew (&http->request->header, http->uri);
 	debug (86,5)("esiContextNew: Client wants data (always created during reply cycle\n");
     }
     return rv;
 }
 
-typedef struct {
-    char *buf; /* not owned by us. */
-    size_t len;
-} inplacetoken;
-
-inplacetoken
-esiFindToken (esiSegment *buffer, off_t startat);
-
-typedef enum { 
-    TOKEN_START, /* looking for < */
-    TOKEN_QUOTED, /* looking for a match to the start quote */
-    TOKEN_UNQUOTED, /* looking for " or ' or > */
-    TOKEN_COMPLETE /* finished */
-} tokenstate;
-
 int
 esiAddLiteral (esiContext *context, const XML_Char *s, int len);
 void start(void *data, const XML_Char *el, const char **attr);
@@ -779,6 +803,8 @@
 	return ESI_ELEMENT_REMOVE;
     if (!strncmp (el + 4, "except", 6))
 	return ESI_ELEMENT_EXCEPT;
+    if (!strncmp (el + 4, "vars", 4))
+	return ESI_ELEMENT_VARS;
     if (!strncmp (el + 4, "try", 3))
 	return ESI_ELEMENT_TRY;
     
@@ -874,6 +900,11 @@
 	element = esiExceptNew ();
 	esiAddStackElement (context, element);
 	break;
+      case ESI_ELEMENT_VARS:
+	/* Put on the stack to allow skipping of 'invalid' markup */
+	element = esiVarNew ();
+	esiAddStackElement (context, element);
+	break;
     }
 
     debug (86,5)("esi stack depth %d\n",context->parserState.stackdepth);
@@ -912,6 +943,7 @@
       case ESI_ELEMENT_TRY:
       case ESI_ELEMENT_ATTEMPT:
       case ESI_ELEMENT_EXCEPT:
+      case ESI_ELEMENT_VARS:
 	/* pop of the stack */
 	--context->parserState.stackdepth;
 	break;
@@ -946,7 +978,8 @@
 	
 	/* wrap the comment in some tags */
 	assert (XML_Parse (p, "<div>", 5,0));
-	if (! XML_Parse(p, s + 3, strlen(s) - 3, 0)) {
+	if (! XML_Parse(p, s + 3, strlen(s) - 3, 0) ||
+	    ! XML_Parse (p, "</div>",6,1)) {
 	    debug (86,0)("esiExpatComment: Parsing fragment '%s' failed.\n", s + 3);
 	    context->errorpage = ERR_UNSUP_REQ;
 	    context->errorstatus = HTTP_INTERNAL_SERVER_ERROR;
@@ -956,7 +989,6 @@
 			 XML_GetCurrentLineNumber(p),
 			 XML_ErrorString(XML_GetErrorCode(p)));
 	}
-	assert (XML_Parse (p, "</div>",6,1));
 	XML_ParserFree (p);
 	debug (86,5)("esiExpatComment: ESI <!-- block parsed\n");
 	return;
@@ -986,7 +1018,7 @@
     debug (86,5)("literal length is %d\n", len);
     /* give a literal to the current element */
     assert (context->parserState.stackdepth <11);
-    element = esiLiteralNew (s, len);
+    element = esiLiteralNew (context, s, len);
     if (ADDELEMENT (context->parserState.stack[context->parserState.stackdepth-1], element)) {
 	debug (86,1)("esiProcess: failed to add esi node, probable error in ESI template\n");
 	cbdataFree (element);
@@ -1059,7 +1091,7 @@
     /* ok, we've done all we can with the data. What can we process now?
      */
     {
-      esiProcessResult_t status = PROCESS(context->tree);
+      esiProcessResult_t status = PROCESS(context->tree, 0);
       switch (status) {
 	case ESI_PROCESS_COMPLETE:
 	    debug (86,5)("esiProcess: tree Processed OK\n");
@@ -1101,6 +1133,7 @@
     return ESI_PROCESS_COMPLETE; /* because we have no callbacks */
 }
 
+/* esiSegment */
 void
 esiSegmentFreeList (esiSegment **head) {
     while (*head) {
@@ -1111,6 +1144,70 @@
 }
 
 void
+esiSegmentTransferList (esiSegment **from, esiSegment **to)
+{
+    if (!*to) {
+	*to = *from;
+    } else {
+	esiSegment *temp = *to;
+	while (temp->next) temp = temp->next;
+	temp->next = *from;
+    }
+    *from = NULL;
+}
+
+char *
+esiSegmentListToChar (esiSegment *head)
+{
+    char *rv;
+    size_t len = 0, pos = 0;
+    esiSegment *temp;
+    assert (head);
+    temp = head;
+    while (temp) {
+	len += temp->len;
+	temp = temp->next;
+    }
+    rv = xmalloc (len + 1);
+    assert (rv);
+    rv [ len] = '\0';
+    temp = head;
+    while (temp) {
+	xmemcpy (&rv[pos], temp->buf, temp->len);
+	pos += temp->len;
+	temp = temp->next;
+    }
+    return rv;
+}
+
+void
+esiSegmentListAppend (esiSegment **head, char const *s, size_t len)
+{
+    esiSegment *output;
+    size_t pos=0;
+    if (!*head)
+	*head = cbdataAlloc (esiSegment);
+    output = *head;
+    while (output->next)
+	output=output->next;
+    /* copy the string to output */
+    while (pos < len) {
+	size_t amount;
+	if (output->len == sizeof (output->buf)) {
+	    assert (output->next == NULL);
+	    output->next = cbdataAlloc (esiSegment);
+	    output = output->next;
+	}
+	amount = len - pos;
+	if (amount > sizeof (output->buf) - output->len)
+	    amount = sizeof (output->buf) - output->len;
+	xmemcpy (&output->buf[output->len], s + pos, amount);
+	output->len += amount;
+	pos += amount;
+    }
+}
+
+void
 esiContextFreeResources (esiContext *context) {
     if (context->rep) {
 	httpReplyDestroy (context->rep);
@@ -1123,6 +1220,7 @@
     }
     esiSegmentFreeList (&context->buffered);
     esiSegmentFreeList (&context->outbound);
+    cbdataFree (context->varState);
     /* don't touch incoming, it's a pointer into buffered anyway */
 }
 
@@ -1346,7 +1444,7 @@
 
 /* always complete processing */
 esiProcessResult_t
-esiProcessComplete (void *data) {
+esiProcessComplete (void *data, int dovars) {
     debug (86,5) ("esiProcessComplete: Processed %p\n",data);
     return ESI_PROCESS_COMPLETE;
 }
@@ -1383,12 +1481,13 @@
     esiLiteral *this = data;
     debug (86, 5) ("esiLiteralFree %p\n", this);
     esiSegmentFreeList (&this->buffer);
+    cbdataReferenceDone (this->varState);
 }
 
 /* precondition: the buffer chain has at least start + length bytes of data
  */
 esiElement *
-esiLiteralNew (const XML_Char *s, int length)
+esiLiteralNew (esiContext *context, const XML_Char *s, int length)
 {
     esiLiteral *rv;
     esiSegment *local;
@@ -1413,6 +1512,7 @@
 	    local=local->next;
 	}
     }
+    rv->varState = cbdataReference (context->varState);
     return (esiElement *)rv;
 }
 
@@ -1427,6 +1527,29 @@
     this->buffer = NULL;
 }
 
+esiProcessResult_t
+esiLiteralProcess (void *data, int dovars)
+{
+    esiLiteral *this = data;
+    if (this->flags.donevars)
+	return ESI_PROCESS_COMPLETE;
+    if (dovars) {
+	esiSegment *temp = this->buffer;
+	/* Ensure variable state is clean */
+	assert (this->varState->output == NULL);
+	while (temp) {
+	    esiVarStateFeedData(this->varState, temp->buf,temp->len);
+	    temp = temp->next;
+	}
+	/* free the pre-processed content */
+	esiSegmentFreeList (&this->buffer);
+	this->buffer = esiVarStateExtractList (this->varState);
+	/* TODO: process variables */
+    }
+    this->flags.donevars = 1;
+    return ESI_PROCESS_COMPLETE;
+}
+
 /* esiSequence */
 void
 esiSequenceFree (void *data)
@@ -1486,6 +1609,16 @@
 	debug (86,0)("esiSequenceAdd: misparented Attempt or Except element (section 3.4)\n");
 	return -1;
     }
+    /* Tie literals together for efficiency */
+    if (this->elementcount && element->vptr == &_esiLiteral &&
+	this->elements[this->elementcount - 1]->vptr == &_esiLiteral) {
+	debug (86,5)("esiSequenceAdd: tying Literals %p and %p together\n", this->elements[this->elementcount - 1], 
+		     element);
+	esiSegmentTransferList (&((esiLiteral *)element)->buffer, 
+				&((esiLiteral *)this->elements[this->elementcount - 1])->buffer);
+	cbdataFree (element);
+	return 0;
+    }
     this->elements = memReallocBuf (this->elements, ++this->elementcount * sizeof (esiElement *),
 				    &this->allocedsize);
     assert (this->elements);
@@ -1496,7 +1629,7 @@
 }
 
 esiProcessResult_t
-esiSequenceProcess (void *data)
+esiSequenceProcess (void *data, int dovars)
 {
     /* process as much of the list as we can, stopping only on
      * faliures
@@ -1504,8 +1637,10 @@
     esiSequence *this = data;
     int i;
     esiProcessResult_t rv = ESI_PROCESS_COMPLETE;
+    if (this->flags.dovars)
+	dovars = 1;
     for (i = this->processedcount; i < this->elementcount; ++i) {
-	switch (PROCESS(this->elements[i])){
+	switch (PROCESS(this->elements[i], dovars)){
 	    case ESI_PROCESS_COMPLETE:
 	        debug (86,5)("esiSequenceProcess: element Processed OK\n");
 		if (i == this->processedcount)
@@ -1546,22 +1681,29 @@
 }
 
 void
-esiIncludeStart (esiStreamContext *, char const *);
+esiIncludeStart (esiStreamContext *, char const *, esiVarState *);
 
 void
-esiIncludeStart (esiStreamContext *stream, char const *url)
+esiIncludeStart (esiStreamContext *stream, char const *url, esiVarState *vars)
 {
     HttpHeader tempheaders;
     if (!stream)
 	return;
     httpHeaderInit (&tempheaders, hoRequest);
+    /* TODO: move this to clientRequestBegin as part of loosely coupled header set */
     httpHeaderPutStr (&tempheaders, HDR_SURROGATE_CAPABILITY, "Surrogate/1.0");
-    /* TODO: evaluate variables */
+
+    /* Ensure variable state is clean */
+    assert (vars->output == NULL);
+    esiVarStateFeedData(vars, url, strlen (url));
+    safe_free (url);
+    /* url is eaten by the request */
+    url = esiVarStateExtractChar (vars);
+    debug (86,1)("esiIncludeStart: Starting subrequest with url '%s'\n", url);
     if (clientBeginRequest(METHOD_GET, url, esiBufferRecipient, stream, &tempheaders, stream->localbuffer.buf, HTTP_REQBUF_SZ)) {
 	debug (86,0) ("starting new ESI subrequest failed\n");
     }
     httpHeaderClean (&tempheaders);
-    
 }
 
 esiElement *
@@ -1582,7 +1724,7 @@
 	    assert (rv->src == NULL);
 	    rv->src = esiStreamContextNew (rv);
 	    assert (rv->src != NULL);
-	    rv->srcurl =xstrdup ( attr[i+1]);
+	    rv->srcurl = xstrdup ( attr[i+1]);
 	} else if (!strcmp(attr[i],"alt")) {
 	    /* Start a secondary request for this url */
 	    /* TODO: make a config parameter to wait on requesting alt's 
@@ -1607,8 +1749,12 @@
       }
     rv->context = cbdataReference(context); 
     if (rv->src) {
-	esiIncludeStart (rv->src, rv->srcurl);
-	esiIncludeStart (rv->alt, rv->alturl);
+	esiIncludeStart (rv->src, rv->srcurl, context->varState);
+	/* eaten by the request */
+	rv->srcurl = NULL;
+	esiIncludeStart (rv->alt, rv->alturl, context->varState);
+	/* eaten by the request */
+	rv->alturl = NULL;
     } else {
 	if (rv->alt)
 	    cbdataFree (rv->alt);
@@ -1642,7 +1788,7 @@
 }
 
 esiProcessResult_t
-esiIncludeProcess (void *data)
+esiIncludeProcess (void *data, int dovars)
 {
     esiInclude *this = data;
     debug (86, 5)("esiIncludeRender: Processing include %p\n", this);
@@ -1826,7 +1972,7 @@
 }
            
 esiProcessResult_t
-esiTryProcess (void *data)
+esiTryProcess (void *data, int dovars)
 {
     esiTry *this = data;
     esiProcessResult_t rv = ESI_PROCESS_PENDING_MAYFAIL;
@@ -1841,7 +1987,7 @@
     }
     if (!this->flags.attemptfailed)
 	/* Try the attempt branch */
-	switch ((rv = PROCESS(this->attempt))){
+	switch ((rv = PROCESS(this->attempt, dovars))){
 	  case ESI_PROCESS_COMPLETE:
 	    debug (86,5)("esiTryProcess: attempt Processed OK\n");
 	    this->flags.attemptok = 1;
@@ -1862,7 +2008,7 @@
     /* query except to see if it has a definite result */
     if (!this->flags.exceptfailed)
 	/* Try the except branch */
-	switch (PROCESS(this->except)){
+	switch (PROCESS(this->except, dovars)){
 	  case ESI_PROCESS_COMPLETE:
 	    debug (86,5)("esiTryProcess: except Processed OK\n");
 	    this->flags.exceptok = 1;
@@ -1907,3 +2053,450 @@
     rv->vptr = &_esiExcept;
     return rv;
 }            
+
+/* esiVar */
+esiElement *
+esiVarNew ()
+{
+    esiSequence *rv = (esiSequence *)esiSequenceNew();
+    rv->vptr = &_esiVar;
+    rv->flags.dovars = 1;
+    return (esiElement *)rv;
+}
+
+/* esiVarState */
+void
+esiVarStateFree (void *data)
+{
+    esiVarState *this = data;
+    esiSegmentFreeList (&this->output);
+    httpHeaderClean (&this->hdr);
+    if (this->query) {
+	int i;
+	for (i = 0; i < this->query_elements; ++i) {
+	    safe_free(this->query[i].var);
+	    safe_free(this->query[i].val);
+	}
+	memFreeBuf (this->query_sz, this->query);
+    }
+    safe_free (this->query_string);
+}
+
+typedef enum {
+    ESI_VAR_LANGUAGE,
+    ESI_VAR_COOKIE,
+    ESI_VAR_HOST,
+    ESI_VAR_REFERER,
+    ESI_VAR_USERAGENT,
+    ESI_QUERY_STRING,
+    ESI_VAR_OTHER
+} esiVar_t;
+
+esiVarState *
+esiVarStateNew (HttpHeader const *hdr, char const *uri)
+{
+    esiVarState *rv;
+    char const *query_pos;
+    char const *query_start;
+    CBDATA_INIT_TYPE_FREECB(esiVarState, esiVarStateFree);
+    rv = cbdataAlloc (esiVarState);
+    /* Fill out variable values */
+    /* TODO: only grab the needed headers */
+    httpHeaderInit (&rv->hdr, hoReply);
+    httpHeaderAppend (&rv->hdr, hdr);
+    debug (86,0)("%s\n",uri);
+
+    /* Count off the query elements */
+    query_start = strchr (uri, '?');
+    if (query_start && query_start[1] != '\0' ) {
+	int n;
+	rv->query_string = xstrdup (query_start + 1);
+	rv->query_elements = 1;
+	query_pos = query_start + 1;
+	while ((query_pos = strchr (query_pos, '&'))) ++rv->query_elements;
+	rv->query = memReallocBuf(rv->query, rv->query_elements * sizeof (struct _query_elem),
+				  &rv->query_sz);
+	query_pos = query_start + 1;
+	n = 0;
+	while (query_pos) {
+	    char *next = strchr (query_pos, '&');
+	    char *div = strchr (query_pos, '=');
+	    assert (n < rv->query_elements);
+	    if (!div)
+		div = next;
+	    if (!(div - query_pos + 1))
+		/* zero length between & and = or & and & */
+		continue;
+	    rv->query[n].var = xstrndup (query_pos, div - query_pos + 1) ;
+	    if (div == next) {
+		rv->query[n].val = xstrdup ("");
+	    } else {
+		rv->query[n].val = xstrndup (div + 1, next - div - 1);
+	    }
+	    
+	    query_pos = next;
+	    ++n;
+	}
+    } else {
+	rv->query_string = xstrdup ("");
+    }
+    if (rv->query) {
+	int n = 0;
+	debug (86,1)("esiVarStateNew: Parsed Query string: '%s'\n",uri);
+	while (n < rv->query_elements) {
+	    debug (86,1)("esiVarStateNew: Parsed Query element %d '%s'='%s'\n",n + 1, rv->query[n].var, rv->query[n].val);
+	    ++n;
+	}
+    }
+    return rv;
+}
+
+void
+esiVarStateFeedData (esiVarState *this, const char *buf, size_t len)
+{
+    /* TODO: if needed - tune to skip segment iteration */
+    debug (86,1)("esiVarStateFeedData: accepting %d bytes\n", len);
+    esiSegmentListAppend (&this->output, buf, len);
+}
+
+esiSegment *
+esiVarStateExtractList(esiVarState *this)
+{
+    esiSegment *rv;
+    esiVarStateDoIt (this);
+    rv = this->output;
+    this->output = NULL;
+    debug (86,1)("esiVarStateExtractList: Extracted list\n");
+    return rv;
+}
+
+char * 
+esiVarStateExtractChar (esiVarState *this)
+{
+    char *rv;
+    if (!this->output)
+	fatal ("Attempt to extract variable state with no data fed in \n");
+    esiVarStateDoIt (this);
+    rv = esiSegmentListToChar(this->output);
+    esiSegmentFreeList (&this->output);
+    debug (86,1)("esiVarStateExtractList: Extracted char\n");
+    return rv;
+}
+ 
+static int 
+esiVarChar (char c);
+
+static esiVar_t 
+esiGetVar(char *s, int len);
+
+static void
+esiVarEval (esiVarState *this, esiVar_t type, char const *, char const *);
+
+int
+httpHeaderHasListMember(const HttpHeader * hdr, http_hdr_type id, const char *member, const char separator);
+
+int
+httpHeaderHasListMember(const HttpHeader * hdr, http_hdr_type id, const char *member, const char separator)
+{
+    int result = 0;
+    String header;
+    const char *pos = NULL;
+    const char *item;
+    int ilen;
+    int mlen = strlen(member);
+    
+    assert(hdr);
+    assert(id >= 0);
+    
+    header = httpHeaderGetStrOrList(hdr, id);
+    
+    while (strListGetItem(&header, separator, &item, &ilen, &pos)) {
+	if (strncmp(item, member, mlen) == 0 
+	    && (item[mlen] == '=' || item[mlen] == separator || item[mlen] == ';')) {
+	    result = 1;
+	    break;
+	}
+    }
+    stringClean(&header);
+    return result;
+
+}
+
+static void 
+esiVarEval (esiVarState *this, esiVar_t type, char const *subref, char const *found_default ) {
+    const char *s = NULL;
+    switch (type) {
+      case ESI_VAR_HOST:
+        if (!subref && httpHeaderHas(&this->hdr,HDR_HOST)) {
+	    s = httpHeaderGetStr (&this->hdr, HDR_HOST);
+	} else s = found_default;
+	esiSegmentListAppend (&this->output, s, strlen (s));
+	break;
+      case ESI_VAR_COOKIE:
+        if (httpHeaderHas(&this->hdr, HDR_COOKIE)) {
+	    if (!subref)
+		s = httpHeaderGetStr (&this->hdr, HDR_COOKIE);
+	    else {
+		String S = httpHeaderGetListMember (&this->hdr, HDR_COOKIE, subref, ';');
+		if (strLen(S))
+		    esiSegmentListAppend (&this->output, strBuf(S), strLen (S));
+		else if (found_default)
+		    esiSegmentListAppend (&this->output, found_default, strlen (found_default));
+		stringClean (&S);
+	    }
+	} else
+	    s = found_default;
+	if (s)
+	    esiSegmentListAppend (&this->output, s, strlen (s));
+	break;
+      case ESI_VAR_REFERER:
+        if (!subref && httpHeaderHas(&this->hdr, HDR_REFERER))
+	    s = httpHeaderGetStr (&this->hdr, HDR_REFERER);
+	else
+	    s = found_default;
+	esiSegmentListAppend (&this->output, s, strlen (s));
+	break;
+      case ESI_QUERY_STRING:
+	if (!subref)
+	    s = this->query_string;
+	else {
+	    int i = 0;
+	    while (i < this->query_elements && !s) {
+		if (!strcmp (subref, this->query[i].var))
+		    s = this->query[i].val;
+		++i;
+	    }
+	    if (!s)
+		s = found_default;
+	}
+	esiSegmentListAppend (&this->output, s, strlen (s));
+	break;
+      case ESI_VAR_USERAGENT:
+        if (httpHeaderHas(&this->hdr, HDR_USER_AGENT)) {
+	    if (!subref)
+		s = httpHeaderGetStr (&this->hdr, HDR_USER_AGENT);
+	    else {
+		s = "TODO";
+	    }
+	} else s = found_default;
+	esiSegmentListAppend (&this->output, s, strlen (s));
+	break;
+      case ESI_VAR_LANGUAGE:
+        if (httpHeaderHas(&this->hdr, HDR_ACCEPT_LANGUAGE)) {
+	    if (!subref) {
+		String S = httpHeaderGetList (&this->hdr, HDR_ACCEPT_LANGUAGE);
+		esiSegmentListAppend (&this->output, strBuf(S), strLen (S));
+		stringClean (&S);
+	    } else {
+		if (httpHeaderHasListMember (&this->hdr, HDR_ACCEPT_LANGUAGE, subref, ',')) {
+		    s = "true";
+		} else {
+		    s = "false";
+		}
+		esiSegmentListAppend (&this->output, s, strlen (s));
+	    }
+	} else {
+	     s = found_default;
+	     esiSegmentListAppend (&this->output, s, strlen (s));
+	}
+	break;
+      case ESI_VAR_OTHER:
+	/* No-op. We swallow it */
+	if (found_default) {
+	    esiSegmentListAppend (&this->output, found_default, strlen (found_default));
+	}
+	break;
+    }
+}
+
+int
+esiVarChar (char c)
+{
+    if (('A' <= c && c <= 'Z') ||
+	('a' <= c && c <= 'z') ||
+	'_' == c || '-' == c)
+	return 1;
+    return 0;
+}
+
+esiVar_t
+esiGetVar(char *s, int len)
+{
+    assert (s);
+    if (len == 9) {
+	if (!strncmp (s, "HTTP_HOST", 9))
+	    return ESI_VAR_HOST;
+	else
+	    return ESI_VAR_OTHER;
+    }
+    if (len == 11) {
+	if (!strncmp (s, "HTTP_COOKIE", 11))
+	    return ESI_VAR_COOKIE;
+	else
+	    return ESI_VAR_OTHER;
+    }
+    if (len == 12) {
+	if (!strncmp (s, "HTTP_REFERER", 12))
+	    return ESI_VAR_REFERER;
+	else if (!strncmp (s, "QUERY_STRING", 12))
+	    return ESI_QUERY_STRING;
+	else
+	    return ESI_VAR_OTHER;
+    }
+    if (len == 15) {
+	if (!strncmp (s, "HTTP_USER_AGENT", 15))
+	    return ESI_VAR_USERAGENT;
+	else
+	    return ESI_VAR_OTHER;
+    }
+    if (len == 20) {
+	if (!strncmp (s, "HTTP_ACCEPT_LANGUAGE", 20))
+	    return ESI_VAR_LANGUAGE;
+	else
+	    return ESI_VAR_OTHER;
+    }
+    return ESI_VAR_OTHER;
+}
+
+/* because we are only used to process:
+ * - include URL's
+ * - non-esi elements
+ * - choose clauses
+ * buffering is ok - we won't delay the start of async activity, or
+ * of output data preparation
+ */
+void
+esiVarStateDoIt (esiVarState *this)
+{
+    int state = 0;
+    char *string = esiSegmentListToChar(this->output);
+    size_t len = strlen (string);
+    size_t pos = 0;
+    size_t var_pos = 0;
+    size_t done_pos = 0;
+    char * found_subref = NULL;
+    char *found_default = NULL;
+    esiVar_t vartype = ESI_VAR_OTHER;
+    esiSegmentFreeList (&this->output);
+    /* TODO: use strcspn? */
+    while (pos < len) {
+	    switch (state) {
+	      case 0: /* skipping pre-variables */
+	        if (string[pos] != '$') {
+		    ++pos;
+		} else {
+		    if (pos - done_pos)
+			/* extract known good text */
+			esiSegmentListAppend (&this->output, string + done_pos, pos - done_pos);
+		    done_pos = pos;
+		    state = 1;
+		    ++pos;
+		}
+		break;
+	      case 1:/* looking for ( */
+		if (string[pos] != '(') {
+		    state = 0;
+		} else {
+		    state = 2; /* extract a variable name */
+		    var_pos = ++pos;
+		}
+		break;
+	      case 2: /* looking for variable name */
+		if (!esiVarChar(string[pos])) {
+		    /* not a variable name char */
+		    if (pos - var_pos)
+			vartype = esiGetVar (string + var_pos, pos - var_pos);
+		    state = 3;
+		} else {
+		    ++pos;
+		}
+		break;
+	      case 3: /* looking for variable subref, end bracket or default indicator */
+		if (string[pos] == ')') {
+		    /* end of string */
+		    esiVarEval (this, vartype, found_subref, found_default);
+		    done_pos = ++pos;
+		    safe_free(found_subref);
+		    safe_free(found_default);
+		    state = 0;
+		} else if (!found_subref && !found_default && string[pos] == '{') {
+		    debug (86,1)("esiVarStateDoIt: Subref of some sort\n");
+		    /* subreference of some sort */
+		    /* look for the entry name */
+		    var_pos = ++pos;
+		    state = 4;
+		} else if (!found_default && string[pos] == '|') {
+		    debug (86,1)("esiVarStateDoIt: Default present\n");
+		    /* extract default value */
+		    state = 5;
+		    var_pos = ++pos;
+		} else {
+		    /* unexpected char, not a variable after all */
+		    debug (86,1)("esiVarStateDoIt: unexpected char after varname\n");
+		    state = 0;
+		    pos = done_pos + 2;
+		}
+		break;
+	      case 4: /* looking for variable subref */
+		if (string[pos] == '}') {
+		    /* end of subref */
+		    found_subref = xstrndup (&string[var_pos], pos - var_pos + 1);
+		    debug (86,1)("esiVarStateDoIt: found end of variable subref '%s'\n", found_subref);
+		    state = 3;
+		    ++pos;
+		} else if (!esiVarChar (string[pos])) {
+		    debug (86,1)("esiVarStateDoIt: found invalid char in variable subref\n");
+		    /* not a valid subref */
+		    safe_free(found_subref);
+		    state = 0;
+		    pos = done_pos + 2;
+		} else {
+		    ++pos;
+		}
+		break;
+	      case 5: /* looking for a default value */
+		if (string[pos] == '\'') {
+		    /* begins with a quote */
+		    debug (86,1)("esiVarStateDoIt: found quoted default\n");
+		    state = 6;
+		    var_pos = ++pos;
+		} else {
+		    /* doesn't */
+		    debug (86,1)("esiVarStateDoIt: found unquoted default\n");
+		    state = 7;
+		    ++pos;
+		}
+		break;
+	      case 6: /* looking for a quote terminate default value */
+		if (string[pos] == '\'') {
+		    /* end of default */
+		    found_default = xstrndup (&string[var_pos], pos - var_pos + 1);
+		    debug (86,1)("esiVarStateDoIt: found end of quoted default '%s'\n", found_default);
+		    state = 3;
+		}
+		++pos;
+		break;
+	      case 7: /* looking for } terminate default value */
+		if (string[pos] == ')') {
+		    /* end of default - end of variable*/
+		    found_default = xstrndup (&string[var_pos], pos - var_pos + 1);
+		    debug (86,1)("esiVarStateDoIt: found end of variable (w/ unquoted default) '%s'\n",found_default);
+		    esiVarEval (this, vartype,found_subref, found_default);
+		    done_pos = ++pos;
+		    safe_free(found_default);
+		    safe_free(found_subref);
+		    state = 0;
+		}
+		++pos;
+		break;
+      default:fatal("esiVarStateDoIt: unexpected state\n");
+	    }
+	}
+	/* pos-done_pos chars are ready to copy */
+	if (pos-done_pos)
+	    esiSegmentListAppend (&this->output, string+done_pos, pos - done_pos);
+    safe_free (found_default);
+    safe_free (found_subref);
+  
+}
+
Index: squid/src/client_side_reply.c
===================================================================
RCS file: /cvsroot/squid-sf//squid/src/Attic/client_side_reply.c,v
retrieving revision 1.1.2.15
retrieving revision 1.1.2.16
diff -u -r1.1.2.15 -r1.1.2.16
--- squid/src/client_side_reply.c	18 Aug 2002 11:09:23 -0000	1.1.2.15
+++ squid/src/client_side_reply.c	19 Aug 2002 11:42:57 -0000	1.1.2.16
@@ -1,6 +1,6 @@
 
 /*
- * $Id: client_side_reply.c,v 1.1.2.15 2002/08/18 11:09:23 rbcollins Exp $
+ * $Id: client_side_reply.c,v 1.1.2.16 2002/08/19 11:42:57 rbcollins Exp $
  *
  * DEBUG: section 88    Client-side Reply Routines
  * AUTHOR: Robert Collins (Originally Duane Wessels in client_side.c)
@@ -1418,7 +1418,7 @@
         }
         /* ESI TODO: replace me with a true ESI header check */
         if (http->flags.accel && rep->sline.status != HTTP_FORBIDDEN &&
-	    !clientAlwaysAllowResponse(rep->sline.status) && !strcmp (http->uri, "http://192.168.0.2:9673/esi_page_1.html")) {
+	    !clientAlwaysAllowResponse(rep->sline.status) && !strcmp (http->uri, "http://192.168.0.2:9673/esi_page_1.html?foobar=foo")) {
             debug(88, 0) ("Enabling ESI processing for %s\n", http->uri);
             clientStreamInsertHead (&http->client_stream, esiStreamRead,
 				 esiProcessStream, esiStreamStatus,NULL);