mongrel_esi 0.5.1 → 0.5.2

data/ext/esi/test/parser.h

@@ -1,120 +0,0 @@
-/**
- * Copyright (c) 2007 Todd A. Fisher
- * You can redistribute it and/or modify it under the same terms as Mozilla Public License 1.1.
- */
-#ifndef ESI_PARSER_H
-#define ESI_PARSER_H
-#include <sys/types.h>
-
-/* how much output to hold in memory before sending out */
-#define ESI_OUTPUT_BUFFER_SIZE 1024
-
-char *esi_strndup( const char *str, size_t len );
-
-/* 
- * ESI Attribute is a single attribute with name and value
- *
- * e.g. for an esi include tag:
- *
- *  <esi:include src='/foo/bar/' timeout='10'/>
- *
- * 2 attributes would be allocated
- *
- * attrs[0]->name => 'src'
- * attrs[0]->value => '/foo/bar/'
- *
- * attrs[1]->name => 'timeout'
- * attrs[1]->value => '10'
- *
- * */
-typedef struct _ESIAttr {
-  char *name;
-  char *value;
-  struct _ESIAttr *next;
-}ESIAttribute;
-
-ESIAttribute *esi_attribute_new( const char *name, size_t name_length, const char *value, size_t value_length );
-ESIAttribute *esi_attribute_copy( ESIAttribute *attribute );
-void esi_attribute_free( ESIAttribute *attribute );
-
-typedef void (*start_tag_cb)(const void *data,
-                             const char *name_start,
-                             size_t name_length,
-                             ESIAttribute *attributes,
-                             void *user_data);
-
-typedef void (*end_tag_cb)(const void *data,
-                           const char *name_start,
-                           size_t name_length,
-                           void *user_data);
-
-typedef void (*output_cb)(const void *data,
-                          size_t length,
-                          void *user_data);
-
-typedef struct _ESIParser {
-  int cs;
-  int prev_state;
-
-  void *user_data;
-
-  const char *mark;
-  size_t overflow_data_size; /* current size of the overflow data buffer */
-  char *overflow_data; /* overflow buffer if execute finishes and we are not in a final state store the parse data */
-
-  size_t echobuffer_allocated; /* amount of memory allocated for the echobuffer */
-  size_t echobuffer_index; /* current write position of the last echo'ed character */
-  char *echobuffer; /* echo buffer if the parse state is not 0 we store the characters here */
-
-  const char *tag_text;  /* start pointer in data */
-  size_t tag_text_length; /* length from tag_text within data */
-
-  const char *attr_key; /* start pointer in data */
-  size_t attr_key_length;
-
-  const char *attr_value; /* start pointer in data */
-  size_t attr_value_length;
-
-  ESIAttribute *attributes, *last;
-
-  /* this memory will be pass to the output_cb when either it's full
-   * or eof is encountered */
-  char output_buffer[ESI_OUTPUT_BUFFER_SIZE+1];
-  size_t output_buffer_size;
-
-  start_tag_cb start_tag_handler;
-  end_tag_cb end_tag_handler;
-  output_cb output_handler;
-
-} ESIParser;
-
-/* create a new Edge Side Include Parser */
-ESIParser *esi_parser_new();
-void esi_parser_free( ESIParser *parser );
-
-/* initialize the parser */
-int esi_parser_init( ESIParser *parser );
-
-/* 
- * send a chunk of data to the parser, the internal parser state is returned
- */
-int esi_parser_execute( ESIParser *parser, const char *data, size_t length );
-/*
- * let the parser no that it has reached the end and it should flush any remaining data to the desired output device
- */
-int esi_parser_finish( ESIParser *parser );
-
-/* 
- * setup a callback to execute when a new esi: start tag is encountered
- * this is will fire for all block tags e.g. <esi:try>, <esi:attempt> and also
- * inline tags <esi:inline src='cache-key'/> <esi:include src='dest'/>
- */
-void esi_parser_start_tag_handler( ESIParser *parser, start_tag_cb callback );
-
-void esi_parser_end_tag_handler( ESIParser *parser, end_tag_cb callback );
-
-/* setup a callback to recieve data ready for output */
-void esi_parser_output_handler( ESIParser *parser, output_cb output_handler );
-
-
-#endif

data/ext/esi/test/parser.rl

@@ -1,585 +0,0 @@
-/** 
- * Copyright (c) 2008 Todd A. Fisher
- * see LICENSE
- */
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include "parser.h"
-
-#ifdef DEBUG
-static void debug_string( const char *msg, const char *str, size_t len )
-{
-  char *pstr = esi_strndup( str, len );
-  printf( "%s :'%s'\n", msg, pstr );
-  free( pstr );
-}
-#else
-#define debug_string(m,s,l)
-#endif
-
-/* define default callbacks */
-static void 
-esi_parser_default_start_cb( const void *data,
-                             const char *name_start,
-                             size_t name_length,
-                             ESIAttribute *attributes,
-                             void *user_data )
-{
-}
-static void 
-esi_parser_default_end_cb( const void *data,
-                           const char *name_start,
-                           size_t name_length,
-                           void *user_data )
-{
-}
-static void 
-esi_parser_default_output_cp(const void *data,
-                             size_t length,
-                             void *user_data)
-{
-}
-
-/* 
- * flush output buffer
- */
-static void esi_parser_flush_output( ESIParser *parser )
-{
-  if( parser->output_buffer_size > 0 ) {
-    //debug_string( "esi_parser_flush_output:", parser->output_buffer, parser->output_buffer_size );
-    parser->output_handler( (void*)parser->output_buffer, parser->output_buffer_size, parser->user_data );
-    parser->output_buffer_size = 0;
-  }
-}
-/* send the character to the output handler marking it 
- * as ready for consumption, e.g. not an esi tag
- */
-static void esi_parser_echo_char( ESIParser *parser, char ch )
-{
-  parser->output_buffer[parser->output_buffer_size++] = ch;
-  if( parser->output_buffer_size == ESI_OUTPUT_BUFFER_SIZE ) {
-    // flush the buffer to the consumer
-    esi_parser_flush_output( parser );
-  }
-}
-/* send any buffered characters to the output handler. 
- * This happens when we enter a case such as <em>  where the
- * first two characters < and e  match the <esi:  expression
- */
-static void esi_parser_echo_buffer( ESIParser *parser )
-{
-  size_t i = 0, len = parser->echobuffer_index + 1;;
-  //debug_string( "echobuffer", parser->echobuffer, parser->echobuffer_index+1 );
-  //parser->output_handler( parser->echobuffer, parser->echobuffer_index+1, parser->user_data );
-  for( ; i < len; ++i ) {
-    esi_parser_echo_char( parser, parser->echobuffer[i] );
-  }
-}
-/*
- * clear the buffer, no buffered characters should be emitted .
- * e.g. we matched an esi tag completely and all buffered characters can be tossed out
- */
-static void esi_parser_echobuffer_clear( ESIParser *parser )
-{
-  parser->echobuffer_index = -1;
-}
-
-/*
- * add a character to the echobuffer. 
- * this happens when we can't determine if the character is allowed to be sent to the client device
- * e.g. matching <e  it's not yet determined if these characters are safe to send or not
- */
-static void esi_parser_concat_to_echobuffer( ESIParser *parser, char ch )
-{
-  parser->echobuffer_index++;
-
-  if( parser->echobuffer_allocated <= parser->echobuffer_index ) {
-    /* double the echobuffer size 
-     * we're getting some crazy input if this case ever happens
-     */
-    parser->echobuffer_allocated *= 2;
-    parser->echobuffer = (char*)realloc( parser->echobuffer, parser->echobuffer_allocated );
-  }
-  parser->echobuffer[parser->echobuffer_index] = ch;
-//  debug_string( "echo buffer", parser->echobuffer, parser->echobuffer_index+1 );
-}
-/*
- * the mark boundary is not always going to be exactly on the attribute or tag name boundary
- * this trims characters from the left to right, advancing *ptr and reducing *len
- */
-static void ltrim_pointer( const char **ptr, const char *bounds, size_t *len )
-{
-  // remove any spaces or = at the before the value
-  while( (isspace( **ptr ) ||
-         **ptr == '=' ||
-         **ptr == '"' ||
-         **ptr == '<' ||
-         **ptr == '\'' ) && (*len > 0) && (*ptr != bounds) ) {
-    (*ptr)++;
-    (*len)--;
-  }
-}
-/*
- * similar to ltrim_pointer, this walks from bounds to *ptr, reducing *len 
- */
-static void rtrim_pointer( const char **ptr, const char *bounds, size_t *len )
-{
-  bounds = (*ptr+(*len-1));
-  // remove any spaces or = at the before the value
-  while( (isspace( *bounds ) ||
-         *bounds == '=' ||
-         *bounds == '"' ||
-         *bounds == '>' ||
-         *bounds == '\'') && (*len > 0) && (*ptr != bounds) ){
-    bounds--;
-    (*len)--;
-  }
-}
-
-%%{
-  machine esi;
-
-  action begin {
-    parser->mark = p;
-    //debug_string( "begin", p, 1 );
-  }
-  action finish {
-//    printf( "finish\n" );
-  }
-
-  # record the position of the start tag
-  action see_start_tag {
-    parser->tag_text = parser->mark+1;
-    parser->tag_text_length = p - (parser->mark+1);
-    parser->mark = p;
-  }
-
-  # detected an inline tag end, sends the start tag and end tag callback
-  action see_end_tag {
-    /* trim the tag text */
-    ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
-    rtrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
-
-    /* send the start tag and end tag message */
-    esi_parser_flush_output( parser );
-    parser->start_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->attributes, parser->user_data );
-    esi_parser_flush_output( parser );
-    parser->end_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->user_data );
-    esi_parser_flush_output( parser );
-
-    /* mark the position */
-    parser->tag_text = NULL;
-    parser->tag_text_length = 0;
-    parser->mark = p;
-
-    /* clear out the echo buffer */
-    esi_parser_echobuffer_clear( parser );
-  }
-
-  # block tag start, with attributes
-  action see_block_start_with_attributes {
-    /* trim tag text */
-    ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
-    rtrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
-    
-    /* send the start and end tag message */
-    esi_parser_flush_output( parser );
-    parser->start_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->attributes, parser->user_data );
-    esi_parser_flush_output( parser );
-
-    parser->tag_text = NULL;
-    parser->tag_text_length = 0;
-    parser->mark = p;
-    
-    /* clear out the echo buffer */
-    esi_parser_echobuffer_clear( parser );
-  }
-  
-  # see an attribute key, /foo\s*=/
-  action see_attribute_key {
-    /* save the attribute  key start */
-    parser->attr_key = parser->mark;
-    /* compute the length of the key */
-    parser->attr_key_length = p - parser->mark;
-    /* save the position following the key */
-    parser->mark = p;
-
-    /* trim the attribute key */
-    ltrim_pointer( &(parser->attr_key), p, &(parser->attr_key_length) );
-    rtrim_pointer( &(parser->attr_key), p, &(parser->attr_key_length) );
-  }
-
-  # see an attribute value, aprox ~= /['"].*['"]/
-  action see_attribute_value {
-    ESIAttribute *attr;
-
-    /* save the attribute value start */
-    parser->attr_value = parser->mark;
-    /* compute the length of the value */
-    parser->attr_value_length = p - parser->mark;
-    /* svae the position following the value */
-    parser->mark = p;
-    
-    /* trim the attribute value */
-    ltrim_pointer( &(parser->attr_value), p, &(parser->attr_value_length) );
-    rtrim_pointer( &(parser->attr_value), p, &(parser->attr_value_length) );
-
-    /* using the attr_key and attr_value, allocate a new attribute object */
-    attr = esi_attribute_new( parser->attr_key, parser->attr_key_length, 
-                              parser->attr_value, parser->attr_value_length );
-
-    /* add the new attribute to the list of attributes */
-    if( parser->attributes ) {
-      parser->last->next = attr;
-      parser->last = attr;
-    }
-    else {
-      parser->last = parser->attributes = attr;
-    }
-  }
-
-  # simple block start tag detected, e.g. <esi:try> no attributes
-  action block_start_tag {
-
-    parser->tag_text = parser->mark;
-    parser->tag_text_length = p - parser->mark;
-
-    parser->mark = p;
-
-    ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
-    rtrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
-
-    esi_parser_flush_output( parser );
-    parser->start_tag_handler( data, parser->tag_text, parser->tag_text_length, NULL, parser->user_data );
-    esi_parser_flush_output( parser );
-
-    esi_parser_echobuffer_clear( parser );
-  }
-
-  # block end tag detected, e.g. </esi:try>
-  action block_end_tag {
-    /* offset by 2 to account for the </ characters */
-    parser->tag_text = parser->mark+2;
-    parser->tag_text_length = p - (parser->mark+2);
-
-    parser->mark = p;
-    
-    ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
-    rtrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
-    
-    esi_parser_flush_output( parser );
-    parser->end_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->user_data );
-    esi_parser_flush_output( parser );
-
-    esi_parser_echobuffer_clear( parser );
-  }
-
-  # process each character in the input stream for output
-  action echo {
-    //printf( "[%c:%d],", *p, cs );
-    switch( cs ) {
-    case 0: /* non matching state */
-      if( parser->prev_state != 12 && parser->prev_state != 7 ){ /* states following a possible end state for a tag */
-        if( parser->echobuffer && parser->echobuffer_index != -1 ){
-          /* send the echo buffer */
-          esi_parser_echo_buffer( parser );
-        }
-        /* send the current character */
-        esi_parser_echo_char( parser, *p );
-      }
-      /* clear the echo buffer */
-      esi_parser_echobuffer_clear( parser );
-      break;
-    default:
-      /* append to the echo buffer */
-      esi_parser_concat_to_echobuffer( parser, *p );
-    }
-    /* save the previous state, necessary for end case detection such as />  and </esi:try>  the trailing > character
-      is state 12 and 7
-    */
-    parser->prev_state = cs;
-  }
-
-  include esi_common_parser "common.rl";
-}%%
-
-%%write data;
-
-/* dup the string up to len */
-char *esi_strndup( const char *str, size_t len )
-{
-  char *s = (char*)malloc(sizeof(char)*(len+1));
-  memcpy( s, str, len );
-  s[len] = '\0';
-  return s;
-}
-
-ESIAttribute *esi_attribute_new( const char *name, size_t name_length, const char *value, size_t value_length )
-{
-  ESIAttribute *attr = (ESIAttribute*)malloc(sizeof(ESIAttribute));
-  attr->name = esi_strndup(name, name_length);
-  attr->value = esi_strndup(value, value_length);
-  attr->next = NULL;
-  return attr;
-}
-
-ESIAttribute *esi_attribute_copy( ESIAttribute *attribute )
-{
-  ESIAttribute *head, *nattr;
-  if( !attribute ){ return NULL; }
-
-  // copy the first attribute
-  nattr = esi_attribute_new( attribute->name, strlen( attribute->name ),
-                             attribute->value, strlen( attribute->value ) );
-  // save a pointer for return
-  head = nattr;
-  // copy next attributes
-  attribute = attribute->next;
-  while( attribute ) {
-    // set the next attribute
-    nattr->next = esi_attribute_new( attribute->name, strlen( attribute->name ),
-                                     attribute->value, strlen( attribute->value ) );
-    // next attribute
-    nattr = nattr->next;
-    attribute = attribute->next;
-  }
-  return head;
-}
-
-void esi_attribute_free( ESIAttribute *attribute )
-{
-  ESIAttribute *ptr;
-  while( attribute ){
-    free( attribute->name );
-    free( attribute->value );
-    ptr = attribute->next;
-    free( attribute );
-    attribute = ptr;
-  }
-}
-
-ESIParser *esi_parser_new()
-{
-  ESIParser *parser = (ESIParser*)malloc(sizeof(ESIParser));
-  parser->cs = esi_start;
-  parser->mark = NULL;
-  parser->tag_text = NULL;
-  parser->attr_key = NULL;
-  parser->attr_value = NULL;
-  parser->overflow_data_size = 0;
-  parser->overflow_data = NULL;
-
-  /* allocate ESI_OUTPUT_BUFFER_SIZE bytes for the echobuffer */
-  parser->echobuffer_allocated = ESI_OUTPUT_BUFFER_SIZE;
-  parser->echobuffer_index = -1;
-  parser->echobuffer = (char*)malloc(sizeof(char)*parser->echobuffer_allocated);
-
-  parser->attributes = NULL;
-  parser->last = NULL;
-
-  parser->start_tag_handler = esi_parser_default_start_cb;
-  parser->end_tag_handler = esi_parser_default_end_cb;
-  parser->output_handler = esi_parser_default_output_cp;
-
-  parser->output_buffer_size = 0;
-  memset( parser->output_buffer, 0, ESI_OUTPUT_BUFFER_SIZE );
-
-  return parser;
-}
-void esi_parser_free( ESIParser *parser )
-{
-  if( parser->overflow_data ){ free( parser->overflow_data ); }
-
-  free( parser->echobuffer );
-  esi_attribute_free( parser->attributes );
-
-  free( parser );
-}
-
-void esi_parser_output_handler( ESIParser *parser, output_cb output_handler )
-{
-  parser->output_handler = output_handler;
-}
-
-int esi_parser_init( ESIParser *parser )
-{
-  int cs;
-  %% write init;
-  parser->prev_state = parser->cs = cs;
-  return 0;
-}
-
-static int compute_offset( const char *mark, const char *data )
-{
-  if( mark ) {
-    return mark - data;
-  }
-  return -1;
-}
-
-/*
- * scans the data buffer for a start sequence /<$/, /<e$/, /<es$/, /<esi$/, /<esi:$/
- * returns index of if start sequence found else returns -1
- */
-static int
-esi_parser_scan_for_start( ESIParser *parser, const char *data, size_t length )
-{
-  size_t i, f = -2, s = -2;
-  char ch;
-
-  for( i = 0; i < length; ++i ) {
-    ch = data[i];
-    switch( ch ) {
-    case '<':
-      f = s = i;
-      break;
-    case '/':
-      if( s == (i-1) && f != -2 ) { s = i; }
-      break;
-    case 'e':
-      if( s == (i-1) && f != -2 ) { s = i; }
-      break;
-    case 's':
-      if( s == (i-1) && f != -2 ) { s = i; }
-      break;
-    case 'i':
-      if( s == (i-1) && f != -2 ) { s = i; }
-      break;
-    case ':':
-      if( s == (i-1) && f != -2 ) { s = i; return f; }
-      break;
-    default:
-      f = s = -2;
-      break;
-    }
-  }
-
-  // if s and f are still valid at end of input return f
-  if( f != -2 && s != -2 ) {
-    return f;
-  }
-  else {
-    return -1;
-  }
-}
-
-/* accept an arbitrary length string buffer
- * when this methods exits it determines if an end state was reached
- * if no end state was reached it saves the full input into an internal buffer
- * when invoked next, it reuses that internable buffer copying all pointers into the 
- * newly allocated buffer. if it exits in a terminal state, e.g. 0 then it will dump these buffers
- */
-int esi_parser_execute( ESIParser *parser, const char *data, size_t length )
-{
-  int cs = parser->cs;
-  const char *p = data;
-  const char *eof = NULL; // ragel 6.x compat
-  const char *pe = data + length;
-  int pindex;
-
-  if( length == 0 ){ return cs; }
-
-  /* scan data for any '<esi:' start sequences, /<$/, /<e$/, /<es$/, /<esi$/, /<esi:$/ */
-  if( cs == esi_start ) { 
-    pindex = esi_parser_scan_for_start( parser, data, length );
-    if( pindex == -1 ) {
-      for( pindex = 0; pindex < length; ++pindex ) {
-        esi_parser_echo_char( parser, data[pindex] );
-      }
-      return cs;
-    }
-  }
-
-  /* there's an existing overflow buffer data append the new data to the existing data */
-  if( parser->overflow_data && parser->overflow_data_size > 0 ) {
-
-    // recompute mark, tag_text, attr_key, and attr_value since they all exist within overflow_data
-    int mark_offset = compute_offset( parser->mark, parser->overflow_data );
-    int tag_text_offset = compute_offset( parser->tag_text, parser->overflow_data );
-    int attr_key_offset = compute_offset( parser->attr_key, parser->overflow_data );
-    int attr_value_offset = compute_offset( parser->attr_value, parser->overflow_data );
-
-    parser->overflow_data = (char*)realloc( parser->overflow_data, sizeof(char)*(parser->overflow_data_size+length) );
-    memcpy( parser->overflow_data+parser->overflow_data_size, data, length );
-
-    p = parser->overflow_data + parser->overflow_data_size;
- 
-    // in our new memory space mark will now be
-    parser->mark = ( mark_offset >= 0 ) ? parser->overflow_data + mark_offset : NULL;
-    parser->tag_text = ( tag_text_offset >= 0 ) ? parser->overflow_data + tag_text_offset : NULL;
-    parser->attr_key = ( attr_key_offset >= 0 ) ? parser->overflow_data + attr_key_offset : NULL;
-    parser->attr_value = ( attr_value_offset >= 0 ) ? parser->overflow_data + attr_value_offset : NULL;
- 
-    data = parser->overflow_data;
-    parser->overflow_data_size = length = length + parser->overflow_data_size;
-//    printf( "grow overflow data: %ld\n", parser->overflow_data_size );
-    pe = data + length;
-
-  }
-
-  if( !parser->mark ) {
-    parser->mark = p;
-  }
-
-//  printf( "cs: %d, ", cs );
-
-  %% write exec;
-
-  parser->cs = cs;
-
-  if( cs != esi_start && cs != 0 ) {
-
-    /* reached the end and we're not at a termination point save the buffer as overflow */
-    if( !parser->overflow_data ){
-      // recompute mark, tag_text, attr_key, and attr_value since they all exist within overflow_data
-      int mark_offset = compute_offset( parser->mark, data );
-      int tag_text_offset = compute_offset( parser->tag_text, data );
-      int attr_key_offset = compute_offset( parser->attr_key, data );
-      int attr_value_offset = compute_offset( parser->attr_value, data );
-      //debug_string( "mark before move", parser->mark, 1 );
-
-      if( ESI_OUTPUT_BUFFER_SIZE > length ) {
-        parser->echobuffer_allocated = ESI_OUTPUT_BUFFER_SIZE;
-      }
-      else {
-        parser->echobuffer_allocated = length;
-      }
-      parser->overflow_data = (char*)malloc( sizeof( char ) * parser->echobuffer_allocated );
-      memcpy( parser->overflow_data, data, length );
-      parser->overflow_data_size = length;
-      //printf( "allocate overflow data: %ld\n", parser->echobuffer_allocated );
-
-      // in our new memory space mark will now be
-      parser->mark = ( mark_offset >= 0 ) ? parser->overflow_data + mark_offset : NULL;
-      parser->tag_text = ( tag_text_offset >= 0 ) ? parser->overflow_data + tag_text_offset : NULL;
-      parser->attr_key = ( attr_key_offset >= 0 ) ? parser->overflow_data + attr_key_offset : NULL;
-      parser->attr_value = ( attr_value_offset >= 0 ) ? parser->overflow_data + attr_value_offset : NULL;
-      //if( parser->mark ){ debug_string( "mark after  move", parser->mark, 1 ); } else { printf( "mark is now empty\n" ); }
-    }
-
-  }else if( parser->overflow_data ) {
-    /* dump the overflow buffer execution ended at a final state */
-    free( parser->overflow_data );
-    parser->overflow_data = NULL;
-    parser->overflow_data_size = 0;
-  }
-
-  return cs;
-}
-int esi_parser_finish( ESIParser *parser )
-{
-  esi_parser_flush_output( parser );
-  return 0;
-}
-
-void esi_parser_start_tag_handler( ESIParser *parser, start_tag_cb callback )
-{
-  parser->start_tag_handler = callback;
-}
-
-void esi_parser_end_tag_handler( ESIParser *parser, end_tag_cb callback )
-{
-  parser->end_tag_handler = callback;
-}