mongrel_esi 0.5.1 → 0.5.2

data/ext/esi/esi_parser.c

@@ -92,8 +92,8 @@ esi_parser_default_start_cb( const void *data,
     VALUE attr_hash = rb_hash_new();
     VALUE tag_text = rb_str_new( name_start, name_length );
     while( attr ){
-      VALUE name = rb_str_new( attr->name, strlen( attr->name ) );
-      VALUE value = rb_str_new( attr->value, strlen( attr->value ) );
+      VALUE name = rb_str_new( attr->name, attr->name_length );
+      VALUE value = rb_str_new( attr->value, attr->value_length );
       rb_hash_aset( attr_hash, name, value );
       attr = attr->next;
     }

data/ext/esi/parser.c

@@ -65,6 +65,21 @@ static void esi_parser_echo_char( ESIParser *parser, char ch )
     esi_parser_flush_output( parser );
   }
 }
+static void esi_parser_send_buffer( ESIParser *parser, const char *seq, size_t len )
+{
+  const char *nseq = seq + len;
+  size_t nlen = parser->output_buffer_size + len;
+
+  if( nlen < ESI_OUTPUT_BUFFER_SIZE ) {
+    memcpy( parser->output_buffer + parser->output_buffer_size, seq, len ); 
+    parser->output_buffer_size += len;
+  }
+  else if( nlen > ESI_OUTPUT_BUFFER_SIZE ) {
+    while( seq != nseq ) {
+      esi_parser_echo_char( parser, *seq++ );
+    }
+  }
+}
 /* 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
@@ -100,6 +115,7 @@ static void esi_parser_concat_to_echobuffer( ESIParser *parser, char ch )
     /* double the echobuffer size 
      * we're getting some crazy input if this case ever happens
      */
+    printf( "increase echobuffer: %d, %s\n", parser->echobuffer_allocated, parser->echobuffer );
     parser->echobuffer_allocated *= 2;
     parser->echobuffer = (char*)realloc( parser->echobuffer, parser->echobuffer_allocated );
   }
@@ -139,11 +155,11 @@ static void rtrim_pointer( const char **ptr, const char *bounds, size_t *len )
   }
 }
 
-#line 306 "parser.rl"
+#line 321 "parser.rl"
 
 
 
-#line 147 "parser.c"
+#line 163 "parser.c"
 static const char _esi_eof_actions[] = {
 	0, 0, 0, 0, 0, 0, 0, 0, 
 	0, 0, 0, 0, 0, 0, 0, 0, 
@@ -163,7 +179,7 @@ static const int esi_error = -1;
 
 static const int esi_en_main = 75;
 
-#line 309 "parser.rl"
+#line 324 "parser.rl"
 
 /* dup the string up to len */
 char *esi_strndup( const char *str, size_t len )
@@ -177,8 +193,10 @@ char *esi_strndup( const char *str, size_t len )
 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->name = name;//esi_strndup(name, name_length);
+  attr->value = value;//esi_strndup(value, value_length);
+  attr->name_length = name_length;
+  attr->value_length = value_length;
   attr->next = NULL;
   return attr;
 }
@@ -189,16 +207,16 @@ ESIAttribute *esi_attribute_copy( ESIAttribute *attribute )
   if( !attribute ){ return NULL; }
 
   // copy the first attribute
-  nattr = esi_attribute_new( attribute->name, strlen( attribute->name ),
-                             attribute->value, strlen( attribute->value ) );
+  nattr = esi_attribute_new( attribute->name, attribute->name_length,
+                             attribute->value, attribute->value_length );
   // 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 ) );
+    nattr->next = esi_attribute_new( attribute->name, attribute->name_length,
+                                     attribute->value, attribute->value_length );
     // next attribute
     nattr = nattr->next;
     attribute = attribute->next;
@@ -210,8 +228,8 @@ void esi_attribute_free( ESIAttribute *attribute )
 {
   ESIAttribute *ptr;
   while( attribute ){
-    free( attribute->name );
-    free( attribute->value );
+//    free( attribute->name );
+//    free( attribute->value );
     ptr = attribute->next;
     free( attribute );
     attribute = ptr;
@@ -228,9 +246,11 @@ ESIParser *esi_parser_new()
   parser->attr_value = NULL;
   parser->overflow_data_size = 0;
   parser->overflow_data = NULL;
+  parser->overflow_data_allocated = 0;
+  parser->using_overflow = 0;
 
   /* allocate ESI_OUTPUT_BUFFER_SIZE bytes for the echobuffer */
-  parser->echobuffer_allocated = ESI_OUTPUT_BUFFER_SIZE;
+  parser->echobuffer_allocated = ESI_ECHOBUFFER_SIZE;
   parser->echobuffer_index = -1;
   parser->echobuffer = (char*)malloc(sizeof(char)*parser->echobuffer_allocated);
 
@@ -251,6 +271,7 @@ void esi_parser_free( ESIParser *parser )
   if( parser->overflow_data ){ free( parser->overflow_data ); }
 
   free( parser->echobuffer );
+
   esi_attribute_free( parser->attributes );
 
   free( parser );
@@ -265,11 +286,11 @@ int esi_parser_init( ESIParser *parser )
 {
   int cs;
   
-#line 269 "parser.c"
+#line 290 "parser.c"
 	{
 	cs = esi_start;
 	}
-#line 410 "parser.rl"
+#line 430 "parser.rl"
   parser->prev_state = parser->cs = cs;
   return 0;
 }
@@ -328,6 +349,54 @@ esi_parser_scan_for_start( ESIParser *parser, const char *data, size_t length )
   }
 }
 
+static void 
+esi_parser_append_data_to_overflow_data( ESIParser *parser, const char *data, size_t length )
+{
+  int mark_offset       = 0;
+  int tag_text_offset   = 0;
+  int attr_key_offset   = 0;
+  int attr_value_offset = 0;
+
+  if( parser->using_overflow ) {
+    // recompute mark, tag_text, attr_key, and attr_value as they all exist within overflow_data
+    mark_offset       = compute_offset( parser->mark,       parser->overflow_data );
+    tag_text_offset   = compute_offset( parser->tag_text,   parser->overflow_data );
+    attr_key_offset   = compute_offset( parser->attr_key,   parser->overflow_data );
+    attr_value_offset = compute_offset( parser->attr_value, parser->overflow_data );
+  }
+  else {
+    // recompute mark, tag_text, attr_key, and attr_value as they all exist within data
+    mark_offset       = compute_offset( parser->mark,       data );
+    tag_text_offset   = compute_offset( parser->tag_text,   data );
+    attr_key_offset   = compute_offset( parser->attr_key,   data );
+    attr_value_offset = compute_offset( parser->attr_value, data );
+  }
+
+  if( parser->overflow_data ) {
+    // check if we need to resize or grow the buffer
+    if( (parser->overflow_data_size + length) > parser->overflow_data_allocated ) {
+      parser->overflow_data_allocated += length;
+//      printf( "realloc: %d bytes, using %d\n", (int)parser->overflow_data_allocated, (int)(parser->overflow_data_size+length) );
+      parser->overflow_data = (char*)realloc( parser->overflow_data, sizeof(char)*(parser->overflow_data_allocated) );
+    }
+    memcpy( parser->overflow_data+parser->overflow_data_size, data, length );
+    parser->overflow_data_size += length;
+  }
+  else {
+    parser->overflow_data_allocated = ESI_OUTPUT_BUFFER_SIZE > length ? ESI_OUTPUT_BUFFER_SIZE : length;
+    parser->overflow_data = (char*)malloc( sizeof( char ) * parser->overflow_data_allocated );
+    memcpy( parser->overflow_data, data, length );
+    parser->overflow_data_size = length;
+//    printf( "malloc: %d for %d bytes\n", (int)parser->overflow_data_allocated, (int)length );
+  }
+
+  // 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;
+}
+
 /* 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
@@ -345,51 +414,33 @@ int esi_parser_execute( ESIParser *parser, const char *data, size_t length )
   if( length == 0 ){ return cs; }
 
   /* scan data for any '<esi:' start sequences, /<$/, /<e$/, /<es$/, /<esi$/, /<esi:$/ */
-  if( cs == esi_start ) { 
+  if( cs == esi_start || cs == 0 ) { 
     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;
+    if( pindex == -1 ) { /* this means there are no start sequences in the buffer we recieved */
+      esi_parser_send_buffer( parser, data, length );
+      return cs; /* no esi start sequences send it all out and break out early */
     }
   }
 
-  /* there's an existing overflow buffer data append the new data to the existing data */
-  if( parser->overflow_data && parser->overflow_data_size > 0 ) {
+  /* there's an existing overflow buffer and it's being used, append the new data */
+  //if( parser->overflow_data && parser->overflow_data_size > 0 ) {
+  if( parser->using_overflow ) {
+    int prev_overflow_size = parser->overflow_data_size; // save the current overflow size
+    esi_parser_append_data_to_overflow_data( parser, data, length );
 
-    // 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;
- 
+    /* set parser variables */
+    p = parser->overflow_data + prev_overflow_size;
     data = parser->overflow_data;
-    parser->overflow_data_size = length = length + parser->overflow_data_size;
-//    printf( "grow overflow data: %ld\n", parser->overflow_data_size );
+    length = parser->overflow_data_size;
     pe = data + length;
-
   }
 
   if( !parser->mark ) {
     parser->mark = p;
   }
 
-//  printf( "cs: %d, ", cs );
-
   
-#line 393 "parser.c"
+#line 444 "parser.c"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -1303,7 +1354,7 @@ case 79:
 	tr98: cs = 79; goto f8;
 
 f0:
-#line 280 "parser.rl"
+#line 295 "parser.rl"
 	{
     //printf( "[%c:%d],", *p, cs );
     switch( cs ) {
@@ -1330,7 +1381,7 @@ f0:
   }
 	goto _again;
 f1:
-#line 280 "parser.rl"
+#line 295 "parser.rl"
 	{
     //printf( "[%c:%d],", *p, cs );
     switch( cs ) {
@@ -1355,14 +1406,14 @@ f1:
     */
     parser->prev_state = cs;
   }
-#line 144 "parser.rl"
+#line 160 "parser.rl"
 	{
     parser->mark = p;
     //debug_string( "begin", p, 1 );
   }
 	goto _again;
 f10:
-#line 280 "parser.rl"
+#line 295 "parser.rl"
 	{
     //printf( "[%c:%d],", *p, cs );
     switch( cs ) {
@@ -1387,13 +1438,13 @@ f10:
     */
     parser->prev_state = cs;
   }
-#line 148 "parser.rl"
+#line 164 "parser.rl"
 	{
 //    printf( "finish\n" );
   }
 	goto _again;
 f3:
-#line 280 "parser.rl"
+#line 295 "parser.rl"
 	{
     //printf( "[%c:%d],", *p, cs );
     switch( cs ) {
@@ -1418,7 +1469,7 @@ f3:
     */
     parser->prev_state = cs;
   }
-#line 153 "parser.rl"
+#line 169 "parser.rl"
 	{
     parser->tag_text = parser->mark+1;
     parser->tag_text_length = p - (parser->mark+1);
@@ -1426,7 +1477,7 @@ f3:
   }
 	goto _again;
 f8:
-#line 280 "parser.rl"
+#line 295 "parser.rl"
 	{
     //printf( "[%c:%d],", *p, cs );
     switch( cs ) {
@@ -1451,7 +1502,7 @@ f8:
     */
     parser->prev_state = cs;
   }
-#line 160 "parser.rl"
+#line 176 "parser.rl"
 	{
     /* trim the tag text */
     ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
@@ -1460,9 +1511,8 @@ f8:
     /* 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 );
+    //printf("\t[see inline tag]\n");
 
     /* mark the position */
     parser->tag_text = NULL;
@@ -1474,7 +1524,7 @@ f8:
   }
 	goto _again;
 f5:
-#line 280 "parser.rl"
+#line 295 "parser.rl"
 	{
     //printf( "[%c:%d],", *p, cs );
     switch( cs ) {
@@ -1499,7 +1549,7 @@ f5:
     */
     parser->prev_state = cs;
   }
-#line 182 "parser.rl"
+#line 197 "parser.rl"
 	{
     /* trim tag text */
     ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
@@ -1508,7 +1558,7 @@ f5:
     /* 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 );
+    //printf("\t[see start tag with attributes]\n");
 
     parser->tag_text = NULL;
     parser->tag_text_length = 0;
@@ -1519,7 +1569,7 @@ f5:
   }
 	goto _again;
 f6:
-#line 280 "parser.rl"
+#line 295 "parser.rl"
 	{
     //printf( "[%c:%d],", *p, cs );
     switch( cs ) {
@@ -1544,7 +1594,7 @@ f6:
     */
     parser->prev_state = cs;
   }
-#line 201 "parser.rl"
+#line 216 "parser.rl"
 	{
     /* save the attribute  key start */
     parser->attr_key = parser->mark;
@@ -1559,7 +1609,7 @@ f6:
   }
 	goto _again;
 f7:
-#line 280 "parser.rl"
+#line 295 "parser.rl"
 	{
     //printf( "[%c:%d],", *p, cs );
     switch( cs ) {
@@ -1584,7 +1634,7 @@ f7:
     */
     parser->prev_state = cs;
   }
-#line 215 "parser.rl"
+#line 230 "parser.rl"
 	{
     ESIAttribute *attr;
 
@@ -1614,7 +1664,7 @@ f7:
   }
 	goto _again;
 f4:
-#line 280 "parser.rl"
+#line 295 "parser.rl"
 	{
     //printf( "[%c:%d],", *p, cs );
     switch( cs ) {
@@ -1639,7 +1689,7 @@ f4:
     */
     parser->prev_state = cs;
   }
-#line 244 "parser.rl"
+#line 259 "parser.rl"
 	{
 
     parser->tag_text = parser->mark;
@@ -1652,13 +1702,13 @@ f4:
 
     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 );
+    //printf("\t[see start tag]\n");
 
     esi_parser_echobuffer_clear( parser );
   }
 	goto _again;
 f2:
-#line 280 "parser.rl"
+#line 295 "parser.rl"
 	{
     //printf( "[%c:%d],", *p, cs );
     switch( cs ) {
@@ -1683,7 +1733,7 @@ f2:
     */
     parser->prev_state = cs;
   }
-#line 262 "parser.rl"
+#line 277 "parser.rl"
 	{
     /* offset by 2 to account for the </ characters */
     parser->tag_text = parser->mark+2;
@@ -1696,13 +1746,13 @@ f2:
     
     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 );
+    //printf("\t[see end tag]\n");
 
     esi_parser_echobuffer_clear( parser );
   }
 	goto _again;
 f12:
-#line 280 "parser.rl"
+#line 295 "parser.rl"
 	{
     //printf( "[%c:%d],", *p, cs );
     switch( cs ) {
@@ -1727,18 +1777,18 @@ f12:
     */
     parser->prev_state = cs;
   }
-#line 144 "parser.rl"
+#line 160 "parser.rl"
 	{
     parser->mark = p;
     //debug_string( "begin", p, 1 );
   }
-#line 148 "parser.rl"
+#line 164 "parser.rl"
 	{
 //    printf( "finish\n" );
   }
 	goto _again;
 f11:
-#line 280 "parser.rl"
+#line 295 "parser.rl"
 	{
     //printf( "[%c:%d],", *p, cs );
     switch( cs ) {
@@ -1763,7 +1813,7 @@ f11:
     */
     parser->prev_state = cs;
   }
-#line 215 "parser.rl"
+#line 230 "parser.rl"
 	{
     ESIAttribute *attr;
 
@@ -1791,7 +1841,7 @@ f11:
       parser->last = parser->attributes = attr;
     }
   }
-#line 148 "parser.rl"
+#line 164 "parser.rl"
 	{
 //    printf( "finish\n" );
   }
@@ -1805,54 +1855,30 @@ _again:
 	{
 	switch ( _esi_eof_actions[cs] ) {
 	case 10:
-#line 148 "parser.rl"
+#line 164 "parser.rl"
 	{
 //    printf( "finish\n" );
   }
 	break;
-#line 1814 "parser.c"
+#line 1864 "parser.c"
 	}
 	}
 
 	}
-#line 529 "parser.rl"
+#line 579 "parser.rl"
 
   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" ); }
+    if( !parser->using_overflow ) { 
+      esi_parser_append_data_to_overflow_data( parser, data, length );
+      parser->using_overflow = 1;
     }
 
-  }else if( parser->overflow_data ) {
-    /* dump the overflow buffer execution ended at a final state */
-    free( parser->overflow_data );
-    parser->overflow_data = NULL;
+  } else if ( parser->using_overflow ) { 
+    parser->using_overflow = 0;
     parser->overflow_data_size = 0;
   }