mod_proxy_html.c

   1 /********************************************************************
   2          Copyright (c) 2003-8, WebThing Ltd
   3          Author: Nick Kew <nick@webthing.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License  Version 2,
   7 as published by the Free Software Foundation.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You can obtain a copy of the GNU General Poblic License Version 2
  15 from http://www.gnu.org/licenses/old-licenses/gpl-2.0.html or
  16 http://apache.webthing.com/COPYING.txt
  17
  18 *********************************************************************/
  19
  20
  21 /********************************************************************
  22         Note to Users
  23
  24         You are requested to register as a user, at
  25         http://apache.webthing.com/registration.html
  26
  27         This entitles you to support from the developer.
  28         I'm unlikely to reply to help/support requests from
  29         non-registered users, unless you're paying and/or offering
  30         constructive feedback such as bug reports or sensible
  31         suggestions for further development.
  32
  33         It also makes a small contribution to the effort
  34         that's gone into developing this work.
  35 *********************************************************************/
  36
  37 /* End of Notices */
  38
  39
  40
  41
  42 /*      GO_FASTER
  43
  44         You can #define GO_FASTER to disable informational logging.
  45         This disables the ProxyHTMLLogVerbose option altogether.
  46
  47         Default is to leave it undefined, and enable verbose logging
  48         as a configuration option.  Binaries are supplied with verbose
  49         logging enabled.
  50 */
  51
  52 #ifdef GO_FASTER
  53 #define VERBOSE(x)
  54 #define VERBOSEB(x)
  55 #else
  56 #define VERBOSE(x) if (verbose) x
  57 #define VERBOSEB(x) if (verbose) {x}
  58 #endif
  59
  60 #define VERSION_STRING "proxy_html/3.0.1"
  61
  62 #include <ctype.h>
  63
  64 /* libxml2 */
  65 #include <libxml/HTMLparser.h>
  66
  67 /* apache */
  68 #include <http_protocol.h>
  69 #include <http_config.h>
  70 #include <http_log.h>
  71 #include <apr_strings.h>
  72 #include <apr_hash.h>
  73 #include <apr_xlate.h>
  74
  75 /* To support Apache 2.1/2.2, we need the ap_ forms of the
  76  * regexp stuff, and they're now used in the code.
  77  * To support 2.0 in the same compile, * we #define the
  78  * AP_ versions if necessary.
  79  */
  80 #ifndef AP_REG_ICASE
  81 /* it's 2.0, so we #define the ap_ versions */
  82 #define ap_regex_t regex_t
  83 #define ap_regmatch_t regmatch_t
  84 #define AP_REG_EXTENDED REG_EXTENDED
  85 #define AP_REG_ICASE REG_ICASE
  86 #define AP_REG_NOSUB REG_NOSUB
  87 #define AP_REG_NEWLINE REG_NEWLINE
  88 #define APACHE20
  89 #define ap_register_output_filter_protocol(a,b,c,d,e) ap_register_output_filter(a,b,c,d)
  90 #else
  91 #define APACHE22
  92 #endif
  93
  94 module AP_MODULE_DECLARE_DATA proxy_html_module ;
  95
  96 #define M_HTML                  0x01
  97 #define M_EVENTS                0x02
  98 #define M_CDATA                 0x04
  99 #define M_REGEX                 0x08
 100 #define M_ATSTART               0x10
 101 #define M_ATEND                 0x20
 102 #define M_LAST                  0x40
 103 #define M_NOTLAST               0x80
 104 #define M_INTERPOLATE_TO        0x100
 105 #define M_INTERPOLATE_FROM      0x200
 106
 107 typedef struct {
 108   const char* val;
 109 } tattr;
 110 typedef struct {
 111   unsigned int start ;
 112   unsigned int end ;
 113 } meta ;
 114 typedef struct {
 115   const char* env;
 116   const char* val;
 117   int rel;
 118 } rewritecond;
 119 typedef struct urlmap {
 120   struct urlmap* next ;
 121   unsigned int flags ;
 122   unsigned int regflags ;
 123   union {
 124     const char* c ;
 125     ap_regex_t* r ;
 126   } from ;
 127   const char* to ;
 128   rewritecond* cond;
 129 } urlmap ;
 130 typedef struct {
 131   urlmap* map ;
 132   const char* doctype ;
 133   const char* etag ;
 134   unsigned int flags ;
 135   size_t bufsz ;
 136   apr_hash_t* links;
 137   apr_array_header_t* events;
 138   apr_array_header_t* skipto;
 139   xmlCharEncoding default_encoding;
 140   const char* charset_out;
 141   int extfix ;
 142   int metafix ;
 143   int strip_comments ;
 144   int interp;
 145 #ifndef GO_FASTER
 146   int verbose ;
 147 #endif
 148 } proxy_html_conf ;
 149 typedef struct {
 150   apr_xlate_t* convset;
 151   char* buf;
 152   apr_size_t bytes;
 153 } conv_t;
 154 typedef struct {
 155   ap_filter_t* f ;
 156   proxy_html_conf* cfg ;
 157   htmlParserCtxtPtr parser ;
 158   apr_bucket_brigade* bb ;
 159   char* buf ;
 160   size_t offset ;
 161   size_t avail ;
 162   conv_t* conv_in;
 163   conv_t* conv_out;
 164   const char* encoding;
 165   urlmap* map;
 166 } saxctxt ;
 167
 168
 169 #define NORM_LC 0x1
 170 #define NORM_MSSLASH 0x2
 171 #define NORM_RESET 0x4
 172 static htmlSAXHandler sax ;
 173
 174 typedef enum { ATTR_IGNORE, ATTR_URI, ATTR_EVENT } rewrite_t ;
 175
 176 static const char* const fpi_html =
 177         "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\">\n" ;
 178 static const char* const fpi_html_legacy =
 179         "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n" ;
 180 static const char* const fpi_xhtml =
 181         "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n" ;
 182 static const char* const fpi_xhtml_legacy =
 183         "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n" ;
 184 static const char* const html_etag = ">" ;
 185 static const char* const xhtml_etag = " />" ;
 186 /*#define DEFAULT_DOCTYPE fpi_html */
 187 static const char* const DEFAULT_DOCTYPE = "" ;
 188 #define DEFAULT_ETAG html_etag
 189
 190 static void normalise(unsigned int flags, char* str) {
 191   char* p ;
 192   if ( flags & NORM_LC )
 193     for ( p = str ; *p ; ++p )
 194       if ( isupper(*p) )
 195         *p = tolower(*p) ;
 196
 197   if ( flags & NORM_MSSLASH )
 198     for ( p = ap_strchr_c(str, '\\') ; p ; p = ap_strchr_c(p+1, '\\') )
 199       *p = '/' ;
 200
 201 }
 202 static void consume_buffer(saxctxt* ctx, const char* inbuf,
 203                 int bytes, int flag) {
 204   apr_status_t rv;
 205   apr_size_t insz;
 206   char* buf;
 207 #ifndef GO_FASTER
 208   int verbose = ctx->cfg->verbose;
 209 #endif
 210   if (ctx->conv_in == NULL) {
 211     /* just feed it to libxml2 */
 212     htmlParseChunk(ctx->parser, inbuf, bytes, flag) ;
 213     return;
 214   }
 215   if (ctx->conv_in->bytes > 0) {
 216     /* FIXME: make this a reusable buf? */
 217     buf = apr_palloc(ctx->f->r->pool, ctx->conv_in->bytes + bytes);
 218     memcpy(buf, ctx->conv_in->buf, ctx->conv_in->bytes);
 219     memcpy(buf + ctx->conv_in->bytes, inbuf, bytes);
 220     bytes += ctx->conv_in->bytes;
 221     ctx->conv_in->bytes = 0;
 222   } else {
 223     buf = (char*) inbuf;
 224   }
 225   insz = bytes;
 226   while (insz > 0) {
 227     char outbuf[4096];
 228     apr_size_t outsz = 4096;
 229     rv = apr_xlate_conv_buffer(ctx->conv_in->convset,
 230                                 buf + (bytes - insz), &insz,
 231                                 outbuf, &outsz);
 232     htmlParseChunk(ctx->parser, outbuf, 4096-outsz, flag) ;
 233     switch (rv) {
 234       case APR_SUCCESS:
 235         continue;
 236       case APR_EINCOMPLETE:
 237         if (insz < 32) {/* save dangling byte(s) and return */
 238           ctx->conv_in->bytes = insz;
 239           ctx->conv_in->buf = (buf != inbuf) ? buf + (bytes-insz)
 240                 : apr_pmemdup(ctx->f->r->pool, buf + (bytes-insz), insz);
 241           return;
 242         } else { /*OK, maybe 4096 wasn't big enough, and ended mid-char */
 243           continue;
 244         }
 245       case APR_EINVAL:          /* try skipping one bad byte */
 246         VERBOSE( ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, ctx->f->r,
 247                 "Skipping invalid byte in input stream!") ) ;
 248         --insz;
 249         continue;
 250       default:
 251         /* Erk!  What's this? Bail out and eat the buf raw
 252          * if libxml2 will accept it!
 253          */
 254         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, ctx->f->r,
 255                 "Failed to convert input; trying it raw") ;
 256         htmlParseChunk(ctx->parser, buf + (bytes - insz), insz, flag) ;
 257         ctx->conv_in = NULL;    /* don't try converting any more */
 258         return;
 259     }
 260   }
 261 }
 262 static void AP_fwrite(saxctxt* ctx, const char* inbuf, int bytes, int flush) {
 263   /* convert charset if necessary, and output */
 264   char* buf;
 265   apr_status_t rv;
 266   apr_size_t insz ;
 267 #ifndef GO_FASTER
 268   int verbose = ctx->cfg->verbose;
 269 #endif
 270
 271   if (ctx->conv_out == NULL) {
 272     ap_fwrite(ctx->f->next, ctx->bb, inbuf, bytes);
 273     return;
 274   }
 275   if (ctx->conv_out->bytes > 0) {
 276     /* FIXME: make this a reusable buf? */
 277     buf = apr_palloc(ctx->f->r->pool, ctx->conv_out->bytes + bytes);
 278     memcpy(buf, ctx->conv_out->buf, ctx->conv_out->bytes);
 279     memcpy(buf + ctx->conv_out->bytes, inbuf, bytes);
 280     bytes += ctx->conv_out->bytes;
 281     ctx->conv_out->bytes = 0;
 282   } else {
 283     buf = (char*) inbuf;
 284   }
 285   insz = bytes;
 286   while (insz > 0) {
 287     char outbuf[2048];
 288     apr_size_t outsz = 2048;
 289     rv = apr_xlate_conv_buffer(ctx->conv_out->convset,
 290                                 buf + (bytes - insz), &insz,
 291                                 outbuf, &outsz);
 292     ap_fwrite(ctx->f->next, ctx->bb, outbuf, 2048-outsz) ;
 293     switch (rv) {
 294       case APR_SUCCESS:
 295         continue;
 296       case APR_EINCOMPLETE:     /* save dangling byte(s) and return */
 297                                 /* but if we need to flush, just abandon them */
 298         if  ( flush) {          /* if we're flushing, this must be complete */
 299                                 /* so this is an error */
 300           VERBOSE( ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, ctx->f->r,
 301                 "Skipping invalid byte in output stream!") ) ;
 302         } else {
 303           ctx->conv_out->bytes = insz;
 304           ctx->conv_out->buf = (buf != inbuf) ? buf + (bytes-insz)
 305                 : apr_pmemdup(ctx->f->r->pool, buf + (bytes-insz), insz);
 306         }
 307         break;
 308       case APR_EINVAL:          /* try skipping one bad byte */
 309         VERBOSE( ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, ctx->f->r,
 310                 "Skipping invalid byte in output stream!") ) ;
 311         --insz;
 312         continue;
 313       default:
 314         /* Erk!  What's this? Bail out and pass the buf raw
 315          * if libxml2 will accept it!
 316          */
 317         VERBOSE( ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, ctx->f->r,
 318                 "Failed to convert output; sending UTF-8") ) ;
 319         ap_fwrite(ctx->f->next, ctx->bb, buf + (bytes - insz), insz) ;
 320         break;
 321     }
 322   }
 323 }
 324
 325 /* This is always utf-8 on entry.  We can convert charset within FLUSH */
 326 #define FLUSH AP_fwrite(ctx, (chars+begin), (i-begin), 0) ; begin = i+1
 327 static void pcharacters(void* ctxt, const xmlChar *uchars, int length) {
 328   const char* chars = (const char*) uchars;
 329   saxctxt* ctx = (saxctxt*) ctxt ;
 330   int i ;
 331   int begin ;
 332   for ( begin=i=0; i<length; i++ ) {
 333     switch (chars[i]) {
 334       case '&' : FLUSH ; ap_fputs(ctx->f->next, ctx->bb, "&amp;") ; break ;
 335       case '<' : FLUSH ; ap_fputs(ctx->f->next, ctx->bb, "&lt;") ; break ;
 336       case '>' : FLUSH ; ap_fputs(ctx->f->next, ctx->bb, "&gt;") ; break ;
 337       case '"' : FLUSH ; ap_fputs(ctx->f->next, ctx->bb, "&quot;") ; break ;
 338       default : break ;
 339     }
 340   }
 341   FLUSH ;
 342 }
 343 static void preserve(saxctxt* ctx, const size_t len) {
 344   char* newbuf ;
 345   if ( len <= ( ctx->avail - ctx->offset ) )
 346     return ;
 347   else while ( len > ( ctx->avail - ctx->offset ) )
 348     ctx->avail += ctx->cfg->bufsz ;
 349
 350   newbuf = realloc(ctx->buf, ctx->avail) ;
 351   if ( newbuf != ctx->buf ) {
 352     if ( ctx->buf )
 353         apr_pool_cleanup_kill(ctx->f->r->pool, ctx->buf, (void*)free) ;
 354     apr_pool_cleanup_register(ctx->f->r->pool, newbuf,
 355         (void*)free, apr_pool_cleanup_null);
 356     ctx->buf = newbuf ;
 357   }
 358 }
 359 static void pappend(saxctxt* ctx, const char* buf, const size_t len) {
 360   preserve(ctx, len) ;
 361   memcpy(ctx->buf+ctx->offset, buf, len) ;
 362   ctx->offset += len ;
 363 }
 364 static void dump_content(saxctxt* ctx) {
 365   urlmap* m ;
 366   char* found ;
 367   size_t s_from, s_to ;
 368   size_t match ;
 369   char c = 0 ;
 370   int nmatch ;
 371   ap_regmatch_t pmatch[10] ;
 372   char* subs ;
 373   size_t len, offs ;
 374   urlmap* themap = ctx->map;
 375 #ifndef GO_FASTER
 376   int verbose = ctx->cfg->verbose ;
 377 #endif
 378
 379   pappend(ctx, &c, 1) ; /* append null byte */
 380         /* parse the text for URLs */
 381   for ( m = themap ; m ; m = m->next ) {
 382     if ( ! ( m->flags & M_CDATA ) )
 383         continue ;
 384     if ( m->flags & M_REGEX ) {
 385       nmatch = 10 ;
 386       offs = 0 ;
 387       while ( ! ap_regexec(m->from.r, ctx->buf+offs, nmatch, pmatch, 0) ) {
 388         match = pmatch[0].rm_so ;
 389         s_from = pmatch[0].rm_eo - match ;
 390         subs = ap_pregsub(ctx->f->r->pool, m->to, ctx->buf+offs,
 391                 nmatch, pmatch) ;
 392         s_to = strlen(subs) ;
 393         len = strlen(ctx->buf) ;
 394         offs += match ;
 395         VERBOSEB(
 396           const char* f = apr_pstrndup(ctx->f->r->pool,
 397                 ctx->buf + offs , s_from ) ;
 398           ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, ctx->f->r,
 399                 "C/RX: match at %s, substituting %s", f, subs) ;
 400         )
 401         if ( s_to > s_from) {
 402           preserve(ctx, s_to - s_from) ;
 403           memmove(ctx->buf+offs+s_to, ctx->buf+offs+s_from,
 404                 len + 1 - s_from - offs) ;
 405           memcpy(ctx->buf+offs, subs, s_to) ;
 406         } else {
 407           memcpy(ctx->buf + offs, subs, s_to) ;
 408           memmove(ctx->buf+offs+s_to, ctx->buf+offs+s_from,
 409                 len + 1 - s_from - offs) ;
 410         }
 411         offs += s_to ;
 412       }
 413     } else {
 414       s_from = strlen(m->from.c) ;
 415       s_to = strlen(m->to) ;
 416       for ( found = strstr(ctx->buf, m->from.c) ; found ;
 417                 found = strstr(ctx->buf+match+s_to, m->from.c) ) {
 418         match = found - ctx->buf ;
 419         if ( ( m->flags & M_ATSTART ) && ( match != 0) )
 420           break ;
 421         len = strlen(ctx->buf) ;
 422         if ( ( m->flags & M_ATEND ) && ( match < (len - s_from) ) )
 423           continue ;
 424         VERBOSE( ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, ctx->f->r,
 425             "C: matched %s, substituting %s", m->from.c, m->to) ) ;
 426         if ( s_to > s_from ) {
 427           preserve(ctx, s_to - s_from) ;
 428           memmove(ctx->buf+match+s_to, ctx->buf+match+s_from,
 429                 len + 1 - s_from - match) ;
 430           memcpy(ctx->buf+match, m->to, s_to) ;
 431         } else {
 432           memcpy(ctx->buf+match, m->to, s_to) ;
 433           memmove(ctx->buf+match+s_to, ctx->buf+match+s_from,
 434                 len + 1 - s_from - match) ;
 435         }
 436       }
 437     }
 438   }
 439   AP_fwrite(ctx, ctx->buf, strlen(ctx->buf), 1) ;
 440 }
 441 static void pcdata(void* ctxt, const xmlChar *uchars, int length) {
 442   const char* chars = (const char*) uchars;
 443   saxctxt* ctx = (saxctxt*) ctxt ;
 444   if ( ctx->cfg->extfix ) {
 445     pappend(ctx, chars, length) ;
 446   } else {
 447     /* not sure if this should force-flush
 448      * (i.e. can one cdata section come in multiple calls?)
 449      */
 450     AP_fwrite(ctx, chars, length, 0) ;
 451   }
 452 }
 453 static void pcomment(void* ctxt, const xmlChar *uchars) {
 454   const char* chars = (const char*) uchars;
 455   saxctxt* ctx = (saxctxt*) ctxt ;
 456   if ( ctx->cfg->strip_comments )
 457     return ;
 458
 459   if ( ctx->cfg->extfix ) {
 460     pappend(ctx, "<!--", 4) ;
 461     pappend(ctx, chars, strlen(chars) ) ;
 462     pappend(ctx, "-->", 3) ;
 463   } else {
 464     ap_fputs(ctx->f->next, ctx->bb, "<!--") ;
 465     AP_fwrite(ctx, chars, strlen(chars), 1) ;
 466     ap_fputs(ctx->f->next, ctx->bb, "-->") ;
 467   }
 468 }
 469 static void pendElement(void* ctxt, const xmlChar* uname) {
 470   saxctxt* ctx = (saxctxt*) ctxt ;
 471   const char* name = (const char*) uname;
 472   const htmlElemDesc* desc = htmlTagLookup(uname);
 473
 474   if ((ctx->cfg->doctype == fpi_html) || (ctx->cfg->doctype == fpi_xhtml)) {
 475     /* enforce html */
 476     if (!desc || desc->depr)
 477       return;
 478
 479   } else if ((ctx->cfg->doctype == fpi_html)
 480                 || (ctx->cfg->doctype == fpi_xhtml)) {
 481     /* enforce html legacy */
 482     if (!desc)
 483       return;
 484   }
 485   /* TODO - implement HTML "allowed here" using the stack */
 486   /* nah.  Keeping the stack is too much overhead */
 487
 488   if ( ctx->offset > 0 ) {
 489     dump_content(ctx) ;
 490     ctx->offset = 0 ;   /* having dumped it, we can re-use the memory */
 491   }
 492   if ( !desc || ! desc->empty ) {
 493     ap_fprintf(ctx->f->next, ctx->bb, "</%s>", name) ;
 494   }
 495 }
 496 static void pstartElement(void* ctxt, const xmlChar* uname,
 497                 const xmlChar** uattrs ) {
 498
 499   int required_attrs ;
 500   int num_match ;
 501   size_t offs, len ;
 502   char* subs ;
 503   rewrite_t is_uri ;
 504   const char** a ;
 505   urlmap* m ;
 506   size_t s_to, s_from, match ;
 507   char* found ;
 508   saxctxt* ctx = (saxctxt*) ctxt ;
 509   size_t nmatch ;
 510   ap_regmatch_t pmatch[10] ;
 511 #ifndef GO_FASTER
 512   int verbose = ctx->cfg->verbose ;
 513 #endif
 514   apr_array_header_t *linkattrs;
 515   int i;
 516   const char* name = (const char*) uname;
 517   const char** attrs = (const char**) uattrs;
 518   const htmlElemDesc* desc = htmlTagLookup(uname);
 519   urlmap* themap = ctx->map;
 520 #ifdef HAVE_STACK
 521   const void** descp;
 522 #endif
 523   int enforce = 0;
 524   if ((ctx->cfg->doctype == fpi_html) || (ctx->cfg->doctype == fpi_xhtml)) {
 525     /* enforce html */
 526     enforce = 2;
 527     if (!desc || desc->depr)
 528       return;
 529
 530   } else if ((ctx->cfg->doctype == fpi_html)
 531                 || (ctx->cfg->doctype == fpi_xhtml)) {
 532     enforce = 1;
 533     /* enforce html legacy */
 534     if (!desc) {
 535       return;
 536     }
 537   }
 538   if (!desc && enforce) {
 539     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, ctx->f->r,
 540                 "Bogus HTML element %s dropped", name) ;
 541     return;
 542   }
 543   if (desc && desc->depr && (enforce == 2) ) {
 544     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, ctx->f->r,
 545                 "Deprecated HTML element %s dropped", name) ;
 546     return;
 547   }
 548 #ifdef HAVE_STACK
 549   descp = apr_array_push(ctx->stack);
 550   *descp = desc;
 551   /* TODO - implement HTML "allowed here" */
 552 #endif
 553
 554   ap_fputc(ctx->f->next, ctx->bb, '<') ;
 555   ap_fputs(ctx->f->next, ctx->bb, name) ;
 556
 557   required_attrs = 0;
 558   if ((enforce > 0) && (desc != NULL) && (desc->attrs_req != NULL))
 559     for (a = desc->attrs_req; *a; a++)
 560       ++required_attrs;
 561
 562   if ( attrs ) {
 563     linkattrs = apr_hash_get(ctx->cfg->links, name, APR_HASH_KEY_STRING) ;
 564     for ( a = attrs ; *a ; a += 2 ) {
 565       if (desc && enforce > 0) {
 566         switch (htmlAttrAllowed(desc, (xmlChar*)*a, 2-enforce)) {
 567           case HTML_INVALID:
 568             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, ctx->f->r,
 569                 "Bogus HTML attribute %s of %s dropped", *a, name);
 570             continue;
 571           case HTML_DEPRECATED:
 572             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, ctx->f->r,
 573                 "Deprecated HTML attribute %s of %s dropped", *a, name);
 574             continue;
 575           case HTML_REQUIRED:
 576             required_attrs--;   /* cross off the number still needed */
 577             /* fallthrough - required implies valid */
 578           default:
 579             break;
 580         }
 581       }
 582       ctx->offset = 0 ;
 583       if ( a[1] ) {
 584         pappend(ctx, a[1], strlen(a[1])+1) ;
 585         is_uri = ATTR_IGNORE ;
 586         if ( linkattrs ) {
 587           tattr* attrs = (tattr*) linkattrs->elts;
 588           for (i=0; i < linkattrs->nelts; ++i) {
 589             if ( !strcmp(*a, attrs[i].val)) {
 590               is_uri = ATTR_URI ;
 591               break ;
 592             }
 593           }
 594         }
 595         if ( (is_uri == ATTR_IGNORE) && ctx->cfg->extfix
 596                         && (ctx->cfg->events != NULL) ) {
 597           for (i=0; i < ctx->cfg->events->nelts; ++i) {
 598             tattr* attrs = (tattr*) ctx->cfg->events->elts;
 599             if ( !strcmp(*a, attrs[i].val)) {
 600               is_uri = ATTR_EVENT ;
 601               break ;
 602             }
 603           }
 604         }
 605         switch ( is_uri ) {
 606           case ATTR_URI:
 607             num_match = 0 ;
 608             for ( m = themap ; m ; m = m->next ) {
 609               if ( ! ( m->flags & M_HTML ) )
 610                 continue ;
 611               if ( m->flags & M_REGEX ) {
 612                 nmatch = 10 ;
 613                 if ( ! ap_regexec(m->from.r, ctx->buf, nmatch, pmatch, 0) ) {
 614                   ++num_match ;
 615                   offs = match = pmatch[0].rm_so ;
 616                   s_from = pmatch[0].rm_eo - match ;
 617                   subs = ap_pregsub(ctx->f->r->pool, m->to, ctx->buf+offs,
 618                         nmatch, pmatch) ;
 619                   VERBOSE( {
 620                     const char* f = apr_pstrndup(ctx->f->r->pool,
 621                         ctx->buf + offs , s_from ) ;
 622                     ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, ctx->f->r,
 623                         "H/RX: match at %s, substituting %s", f, subs) ;
 624                   } )
 625                   s_to = strlen(subs) ;
 626                   len = strlen(ctx->buf) ;
 627                   if ( s_to > s_from) {
 628                     preserve(ctx, s_to - s_from) ;
 629                     memmove(ctx->buf+offs+s_to, ctx->buf+offs+s_from,
 630                         len + 1 - s_from - offs) ;
 631                     memcpy(ctx->buf+offs, subs, s_to) ;
 632                   } else {
 633                     memcpy(ctx->buf + offs, subs, s_to) ;
 634                     memmove(ctx->buf+offs+s_to, ctx->buf+offs+s_from,
 635                         len + 1 - s_from - offs) ;
 636                   }
 637                 }
 638               } else {
 639                 s_from = strlen(m->from.c) ;
 640                 if ( ! strncasecmp(ctx->buf, m->from.c, s_from ) ) {
 641                   ++num_match ;
 642                   s_to = strlen(m->to) ;
 643                   len = strlen(ctx->buf) ;
 644                   VERBOSE( ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, ctx->f->r,
 645                     "H: matched %s, substituting %s", m->from.c, m->to) ) ;
 646                   if ( s_to > s_from ) {
 647                     preserve(ctx, s_to - s_from) ;
 648                     memmove(ctx->buf+s_to, ctx->buf+s_from,
 649                         len + 1 - s_from ) ;
 650                     memcpy(ctx->buf, m->to, s_to) ;
 651                   } else {      /* it fits in the existing space */
 652                     memcpy(ctx->buf, m->to, s_to) ;
 653                     memmove(ctx->buf+s_to, ctx->buf+s_from,
 654                         len + 1 - s_from) ;
 655                   }
 656                   break ;
 657                 }
 658               }
 659               /* URIs only want one match unless overridden in the config */
 660               if ( (num_match > 0) && !( m->flags & M_NOTLAST ) )
 661                 break ;
 662             }
 663             break ;
 664           case ATTR_EVENT:
 665             for ( m = themap ; m ; m = m->next ) {
 666               num_match = 0 ;   /* reset here since we're working per-rule */
 667               if ( ! ( m->flags & M_EVENTS ) )
 668                 continue ;
 669               if ( m->flags & M_REGEX ) {
 670                 nmatch = 10 ;
 671                 offs = 0 ;
 672                 while ( ! ap_regexec(m->from.r, ctx->buf+offs,
 673                         nmatch, pmatch, 0) ) {
 674                   match = pmatch[0].rm_so ;
 675                   s_from = pmatch[0].rm_eo - match ;
 676                   subs = ap_pregsub(ctx->f->r->pool, m->to, ctx->buf+offs,
 677                         nmatch, pmatch) ;
 678                   VERBOSE( {
 679                     const char* f = apr_pstrndup(ctx->f->r->pool,
 680                         ctx->buf + offs , s_from ) ;
 681                     ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, ctx->f->r,
 682                         "E/RX: match at %s, substituting %s", f, subs) ;
 683                   } )
 684                   s_to = strlen(subs) ;
 685                   offs += match ;
 686                   len = strlen(ctx->buf) ;
 687                   if ( s_to > s_from) {
 688                     preserve(ctx, s_to - s_from) ;
 689                     memmove(ctx->buf+offs+s_to, ctx->buf+offs+s_from,
 690                         len + 1 - s_from - offs) ;
 691                     memcpy(ctx->buf+offs, subs, s_to) ;
 692                   } else {
 693                     memcpy(ctx->buf + offs, subs, s_to) ;
 694                     memmove(ctx->buf+offs+s_to, ctx->buf+offs+s_from,
 695                         len + 1 - s_from - offs) ;
 696                   }
 697                   offs += s_to ;
 698                   ++num_match ;
 699                 }
 700               } else {
 701                 found = strstr(ctx->buf, m->from.c) ;
 702                 if ( (m->flags & M_ATSTART) && ( found != ctx->buf) )
 703                   continue ;
 704                 while ( found ) {
 705                   s_from = strlen(m->from.c) ;
 706                   s_to = strlen(m->to) ;
 707                   match = found - ctx->buf ;
 708                   if ( ( s_from < strlen(found) ) && (m->flags & M_ATEND ) ) {
 709                     found = strstr(ctx->buf+match+s_from, m->from.c) ;
 710                     continue ;
 711                   } else {
 712                     found = strstr(ctx->buf+match+s_to, m->from.c) ;
 713                   }
 714                   VERBOSE( ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, ctx->f->r,
 715                     "E: matched %s, substituting %s", m->from.c, m->to) ) ;
 716                   len = strlen(ctx->buf) ;
 717                   if ( s_to > s_from ) {
 718                     preserve(ctx, s_to - s_from) ;
 719                     memmove(ctx->buf+match+s_to, ctx->buf+match+s_from,
 720                         len + 1 - s_from - match) ;
 721                     memcpy(ctx->buf+match, m->to, s_to) ;
 722                   } else {
 723                     memcpy(ctx->buf+match, m->to, s_to) ;
 724                     memmove(ctx->buf+match+s_to, ctx->buf+match+s_from,
 725                         len + 1 - s_from - match) ;
 726                   }
 727                   ++num_match ;
 728                 }
 729               }
 730               if ( num_match && ( m->flags & M_LAST ) )
 731                 break ;
 732             }
 733             break ;
 734           case ATTR_IGNORE:
 735             break ;
 736         }
 737       }
 738       if ( ! a[1] )
 739         ap_fputstrs(ctx->f->next, ctx->bb, " ", a[0], NULL) ;
 740       else {
 741
 742         if ( ctx->cfg->flags != 0 )
 743           normalise(ctx->cfg->flags, ctx->buf) ;
 744
 745         /* write the attribute, using pcharacters to html-escape
 746            anything that needs it in the value.
 747         */
 748         ap_fputstrs(ctx->f->next, ctx->bb, " ", a[0], "=\"", NULL) ;
 749         pcharacters(ctx, (const xmlChar*)ctx->buf, strlen(ctx->buf)) ;
 750         ap_fputc(ctx->f->next, ctx->bb, '"') ;
 751       }
 752     }
 753   }
 754   ctx->offset = 0 ;
 755   if ( desc && desc->empty )
 756     ap_fputs(ctx->f->next, ctx->bb, ctx->cfg->etag) ;
 757   else
 758     ap_fputc(ctx->f->next, ctx->bb, '>') ;
 759
 760   if ((enforce > 0) && (required_attrs > 0)) {
 761     /* if there are more required attributes than we found then complain */
 762     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, ctx->f->r,
 763         "HTML element %s is missing %d required attributes",
 764         name, required_attrs);
 765   }
 766 }
 767
 768 /* globals set once at startup */
 769 static ap_regex_t* seek_meta_ctype ;
 770 static ap_regex_t* seek_charset ;
 771 static ap_regex_t* seek_meta ;
 772
 773 static xmlCharEncoding sniff_encoding(saxctxt* ctx, const char* cbuf,
 774                 size_t bytes) {
 775 #ifndef GO_FASTER
 776   int verbose = ctx->cfg->verbose;
 777 #endif
 778   request_rec* r = ctx->f->r ;
 779   proxy_html_conf* cfg = ctx->cfg ;
 780   xmlCharEncoding ret ;
 781   char* p ;
 782   ap_regmatch_t match[2] ;
 783   char* buf = (char*)cbuf ;
 784   apr_xlate_t* convset;
 785
 786   VERBOSE( ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r,
 787                 "Content-Type is %s", r->content_type) ) ;
 788
 789 /* If we've got it in the HTTP headers, there's nothing to do */
 790   if ( r->content_type &&
 791         ( p = ap_strcasestr(r->content_type, "charset=") , p > 0 ) ) {
 792     p += 8 ;
 793     if ( ctx->encoding = apr_pstrndup(r->pool, p, strcspn(p, " ;") ) ,
 794         ctx->encoding ) {
 795         VERBOSE( ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r,
 796                 "Got charset %s from HTTP headers", ctx->encoding) ) ;
 797       if ( ret = xmlParseCharEncoding(ctx->encoding),
 798                 ((ret != XML_CHAR_ENCODING_ERROR )
 799                  && (ret != XML_CHAR_ENCODING_NONE))) {
 800         return ret ;
 801       }
 802     }
 803   }
 804
 805 /* to sniff, first we look for BOM */
 806   if (ctx->encoding == NULL) {
 807     if ( ret = xmlDetectCharEncoding((const xmlChar*)buf, bytes),
 808         ret != XML_CHAR_ENCODING_NONE ) {
 809       VERBOSE( ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r,
 810         "Got charset from XML rules.") ) ;
 811       return ret ;
 812     }
 813
 814 /* If none of the above, look for a META-thingey */
 815     if ( ap_regexec(seek_meta_ctype, buf, 1, match, 0) == 0 ) {
 816       p = apr_pstrndup(r->pool, buf + match[0].rm_so,
 817         match[0].rm_eo - match[0].rm_so) ;
 818       if ( ap_regexec(seek_charset, p, 2, match, 0) == 0 )
 819         ctx->encoding = apr_pstrndup(r->pool, p+match[1].rm_so,
 820           match[1].rm_eo - match[1].rm_so) ;
 821     }
 822   }
 823
 824 /* either it's set to something we found or it's still the default */
 825   if ( ctx->encoding ) {
 826     VERBOSE( ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r,
 827         "Got charset %s from HTML META", ctx->encoding) ) ;
 828     if ( ret = xmlParseCharEncoding(ctx->encoding),
 829                 ((ret != XML_CHAR_ENCODING_ERROR )
 830                  && (ret != XML_CHAR_ENCODING_NONE))) {
 831       return ret ;
 832     }
 833 /* Unsupported charset.  Can we get (iconv) support through apr_xlate? */
 834 /* Aaargh!  libxml2 has undocumented <META-crap> support.  So this fails
 835  * if metafix is not active.  Have to make it conditional.
 836  */
 837     if (cfg->metafix) {
 838       VERBOSE( ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 839         "Charset %s not supported by libxml2; trying apr_xlate", ctx->encoding) ) ;
 840       if (apr_xlate_open(&convset, "UTF-8", ctx->encoding, r->pool) == APR_SUCCESS) {
 841         ctx->conv_in = apr_pcalloc(r->pool, sizeof(conv_t));
 842         ctx->conv_in->convset = convset ;
 843         return XML_CHAR_ENCODING_UTF8 ;
 844       } else {
 845         ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 846           "Charset %s not supported.  Consider aliasing it?", ctx->encoding) ;
 847       }
 848     } else {
 849       ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 850           "Charset %s not supported.  Consider aliasing it or use metafix?",
 851           ctx->encoding) ;
 852     }
 853   }
 854
 855
 856 /* Use configuration default as a last resort */
 857   ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,
 858         "No usable charset information; using configuration default") ;
 859   return (cfg->default_encoding == XML_CHAR_ENCODING_NONE)
 860         ? XML_CHAR_ENCODING_8859_1 : cfg->default_encoding ;
 861 }
 862 static meta* metafix(request_rec* r, const char* buf /*, size_t bytes*/
 863 #ifndef GO_FASTER
 864                 , int verbose
 865 #endif
 866         ) {
 867   meta* ret = NULL ;
 868   size_t offs = 0 ;
 869   const char* p ;
 870   const char* q ;
 871   char* header ;
 872   char* content ;
 873   ap_regmatch_t pmatch[2] ;
 874   char delim ;
 875
 876   while ( ! ap_regexec(seek_meta, buf+offs, 2, pmatch, 0) ) {
 877     header = NULL ;
 878     content = NULL ;
 879     p = buf+offs+pmatch[1].rm_eo ;
 880     while ( !isalpha(*++p) ) ;
 881     for ( q = p ; isalnum(*q) || (*q == '-') ; ++q ) ;
 882     header = apr_pstrndup(r->pool, p, q-p) ;
 883     if ( strncasecmp(header, "Content-", 8) ) {
 884 /* find content=... string */
 885       for ( p = ap_strstr((char*)buf+offs+pmatch[0].rm_so, "content") ; *p ; ) {
 886         p += 7 ;
 887         while ( *p && isspace(*p) )
 888           ++p ;
 889         if ( *p != '=' )
 890           continue ;
 891         while ( *p && isspace(*++p) ) ;
 892         if ( ( *p == '\'' ) || ( *p == '"' ) ) {
 893           delim = *p++ ;
 894           for ( q = p ; *q != delim ; ++q ) ;
 895         } else {
 896           for ( q = p ; *q && !isspace(*q) && (*q != '>') ; ++q ) ;
 897         }
 898         content = apr_pstrndup(r->pool, p, q-p) ;
 899         break ;
 900       }
 901     } else if ( !strncasecmp(header, "Content-Type", 12) ) {
 902       ret = apr_palloc(r->pool, sizeof(meta) ) ;
 903       ret->start = pmatch[0].rm_so ;
 904       ret->end = pmatch[0].rm_eo ;
 905     }
 906     if ( header && content ) {
 907       VERBOSE( ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r,
 908         "Adding header [%s: %s] from HTML META", header, content) ) ;
 909       apr_table_setn(r->headers_out, header, content) ;
 910     }
 911     offs += pmatch[0].rm_eo ;
 912   }
 913   return ret ;
 914 }
 915
 916 static const char* interpolate_vars(request_rec* r, const char* str) {
 917   const char* start;
 918   const char* end;
 919   const char* delim;
 920   const char* before;
 921   const char* after;
 922   const char* replacement;
 923   const char* var;
 924   for (;;) {
 925     start = str ;
 926     if (start = ap_strstr_c(start, "${"), start == NULL)
 927       break;
 928
 929     if (end = ap_strchr_c(start+2, '}'), end == NULL)
 930       break;
 931
 932     delim = ap_strchr_c(start, '|');
 933     before = apr_pstrndup(r->pool, str, start-str);
 934     after = end+1;
 935     if (delim) {
 936       var = apr_pstrndup(r->pool, start+2, delim-start-2) ;
 937     } else {
 938       var = apr_pstrndup(r->pool, start+2, end-start-2) ;
 939     }
 940     replacement = apr_table_get(r->subprocess_env, var) ;
 941     if (!replacement)
 942       if (delim)
 943         replacement = apr_pstrndup(r->pool, delim+1, end-delim-1);
 944       else
 945         replacement = "";
 946     str = apr_pstrcat(r->pool, before, replacement, after, NULL);
 947     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 948                         "Interpolating %s  =>  %s", var, replacement) ;
 949   }
 950   return str;
 951 }
 952 static void fixup_rules(saxctxt* ctx) {
 953   const char* thisval;
 954   urlmap* newp;
 955   urlmap* p;
 956   urlmap* prev = NULL;
 957   request_rec* r = ctx->f->r;
 958   int has_cond;
 959
 960   for (p = ctx->cfg->map; p; p = p->next) {
 961     has_cond = -1;
 962     if (p->cond != NULL) {
 963       thisval = apr_table_get(r->subprocess_env, p->cond->env);
 964       if (!p->cond->val) {
 965         /* required to be "anything" */
 966         if (thisval)
 967           has_cond = 1; /* satisfied */
 968         else
 969           has_cond = 0; /* unsatisfied */
 970       } else {
 971         if (thisval && !strcasecmp(p->cond->val, thisval)) {
 972           has_cond = 1; /* satisfied */
 973         } else {
 974           has_cond = 0; /* unsatisfied */
 975         }
 976       }
 977       if (((has_cond == 0) && (p->cond->rel ==1 ))
 978         || ((has_cond == 1) && (p->cond->rel == -1))) {
 979         continue;  /* condition is unsatisfied */
 980       }
 981     }
 982
 983     newp = apr_pmemdup(r->pool, p, sizeof(urlmap));
 984
 985     if (newp->flags & M_INTERPOLATE_FROM) {
 986       newp->from.c = interpolate_vars(r, newp->from.c);
 987       if (!newp->from.c || !*newp->from.c)
 988         continue;       /* don't use empty from-pattern */
 989       if (newp->flags & M_REGEX) {
 990         newp->from.r = ap_pregcomp(r->pool, newp->from.c, newp->regflags) ;
 991       }
 992     }
 993     if (newp->flags & M_INTERPOLATE_TO) {
 994       newp->to = interpolate_vars(r, newp->to);
 995     }
 996     /* evaluate p->cond; continue if unsatisfied */
 997     /* create new urlmap with memcpy and append to map */
 998     /* interpolate from if flagged to do so */
 999     /* interpolate to if flagged to do so */
1000
1001     if (prev != NULL)
1002       prev->next = newp ;
1003     else
1004       ctx->map = newp ;
1005     prev = newp ;
1006   }
1007
1008   if (prev)
1009     prev->next = NULL;
1010 }
1011 static saxctxt* check_filter_init (ap_filter_t* f) {
1012   saxctxt* fctx ;
1013   if ( ! f->ctx) {
1014     proxy_html_conf* cfg
1015         = ap_get_module_config(f->r->per_dir_config, &proxy_html_module);
1016     const char* force = apr_table_get(f->r->subprocess_env, "PROXY_HTML_FORCE");
1017
1018     const char* errmsg = NULL ;
1019     if ( !force ) {
1020       if ( ! f->r->proxyreq ) {
1021         errmsg = "Non-proxy request; not inserting proxy-html filter" ;
1022       } else if ( ! f->r->content_type ) {
1023         errmsg = "No content-type; bailing out of proxy-html filter" ;
1024       } else if ( strncasecmp(f->r->content_type, "text/html", 9) &&
1025             strncasecmp(f->r->content_type, "application/xhtml+xml", 21) ) {
1026         errmsg = "Non-HTML content; not inserting proxy-html filter" ;
1027       }
1028     }
1029     if (!cfg->links) {
1030       errmsg = "No links configured: nothing for proxy-html filter to do";
1031     }
1032
1033     if ( errmsg ) {
1034 #ifndef GO_FASTER
1035       if ( cfg->verbose ) {
1036         ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, f->r, errmsg) ;
1037       }
1038 #endif
1039       ap_remove_output_filter(f) ;
1040       return NULL ;
1041     }
1042
1043     fctx = f->ctx = apr_pcalloc(f->r->pool, sizeof(saxctxt)) ;
1044     fctx->f = f ;
1045     fctx->bb = apr_brigade_create(f->r->pool, f->r->connection->bucket_alloc) ;
1046     fctx->cfg = cfg;
1047     apr_table_unset(f->r->headers_out, "Content-Length") ;
1048
1049     if (cfg->interp)
1050       fixup_rules(fctx);
1051     else
1052       fctx->map = cfg->map;
1053     /* defer dealing with charset_out until after sniffing charset_in
1054      * so we can support setting one to t'other.
1055     */
1056   }
1057   return f->ctx ;
1058 }
1059 static int proxy_html_filter(ap_filter_t* f, apr_bucket_brigade* bb) {
1060   apr_xlate_t* convset;
1061   const char* charset = NULL;
1062   apr_bucket* b ;
1063   meta* m = NULL ;
1064   xmlCharEncoding enc ;
1065   const char* buf = 0 ;
1066   apr_size_t bytes = 0 ;
1067 #ifndef USE_OLD_LIBXML2
1068   int xmlopts = XML_PARSE_RECOVER | XML_PARSE_NONET |
1069         XML_PARSE_NOBLANKS | XML_PARSE_NOERROR | XML_PARSE_NOWARNING ;
1070 #endif
1071
1072   saxctxt* ctxt = check_filter_init(f) ;
1073 #ifndef GO_FASTER
1074   int verbose;
1075 #endif
1076   if ( ! ctxt )
1077     return ap_pass_brigade(f->next, bb) ;
1078 #ifndef GO_FASTER
1079   verbose = ctxt->cfg->verbose;
1080 #endif
1081
1082   for ( b = APR_BRIGADE_FIRST(bb) ;
1083         b != APR_BRIGADE_SENTINEL(bb) ;
1084         b = APR_BUCKET_NEXT(b) ) {
1085     if ( APR_BUCKET_IS_METADATA(b) ) {
1086       if ( APR_BUCKET_IS_EOS(b) ) {
1087         if ( ctxt->parser != NULL ) {
1088           consume_buffer(ctxt, buf, 0, 1);
1089         }
1090         APR_BRIGADE_INSERT_TAIL(ctxt->bb,
1091           apr_bucket_eos_create(ctxt->bb->bucket_alloc) ) ;
1092         ap_pass_brigade(ctxt->f->next, ctxt->bb) ;
1093       } else if ( APR_BUCKET_IS_FLUSH(b) ) {
1094         /* pass on flush, except at start where it would cause
1095          * headers to be sent before doc sniffing
1096          */
1097         if ( ctxt->parser != NULL ) {
1098           ap_fflush(ctxt->f->next, ctxt->bb) ;
1099         }
1100       }
1101     } else if ( apr_bucket_read(b, &buf, &bytes, APR_BLOCK_READ)
1102               == APR_SUCCESS ) {
1103       if ( ctxt->parser == NULL ) {
1104         if ( buf[bytes] != 0 ) {
1105           /* make a string for parse routines to play with */
1106           char* buf1 = apr_palloc(f->r->pool, bytes+1) ;
1107           memcpy(buf1, buf, bytes) ;
1108           buf1[bytes] = 0 ;
1109           buf = buf1 ;
1110         }
1111         /* For publishing systems that insert crap at the head of a
1112          * page that buggers up the parser.  Search to first instance
1113          * of some relatively sane, or at least parseable, element.
1114          */
1115         if (ctxt->cfg->skipto != NULL) {
1116           char* p = ap_strchr_c(buf, '<');
1117           tattr* starts = (tattr*) ctxt->cfg->skipto->elts;
1118           int found = 0;
1119           while (!found && *p) {
1120             int i;
1121             for (i = 0; i < ctxt->cfg->skipto->nelts; ++i) {
1122               if ( !strncasecmp(p+1, starts[i].val, strlen(starts[i].val))) {
1123                 bytes -= (p-buf);
1124                 buf = p ;
1125                 found = 1;
1126                 VERBOSE(
1127                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, f->r,
1128                         "Skipped to first <%s> element", starts[i].val)
1129                 ) ;
1130                 break;
1131               }
1132             }
1133             p = ap_strchr_c(p+1, '<');
1134           }
1135           if (p == NULL) {
1136             ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, f->r,
1137                 "Failed to find start of recognised HTML!") ;
1138           }
1139         }
1140
1141         enc = sniff_encoding(ctxt, buf, bytes) ;
1142         /* now we have input charset, set output charset too */
1143         if (ctxt->cfg->charset_out) {
1144           if (!strcmp(ctxt->cfg->charset_out, "*"))
1145             charset = ctxt->encoding;
1146           else
1147             charset = ctxt->cfg->charset_out;
1148           if (strcasecmp(charset, "utf-8")) {
1149             if (apr_xlate_open(&convset, charset, "UTF-8",
1150                 f->r->pool) == APR_SUCCESS) {
1151               ctxt->conv_out = apr_pcalloc(f->r->pool, sizeof(conv_t));
1152               ctxt->conv_out->convset = convset;
1153             } else {
1154               ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, f->r,
1155                 "Output charset %s not supported.  Falling back to UTF-8",
1156                 charset) ;
1157             }
1158           }
1159         }
1160         if (ctxt->conv_out) {
1161           const char* ctype = apr_psprintf(f->r->pool,
1162                         "text/html;charset=%s", charset);
1163           ap_set_content_type(f->r, ctype) ;
1164         } else {
1165           ap_set_content_type(f->r, "text/html;charset=utf-8") ;
1166         }
1167         ap_fputs(f->next, ctxt->bb, ctxt->cfg->doctype) ;
1168         ctxt->parser = htmlCreatePushParserCtxt(&sax, ctxt, buf, 4, 0, enc) ;
1169         buf += 4;
1170         bytes -= 4;
1171         if (ctxt->parser == NULL) {
1172           apr_status_t rv = ap_pass_brigade(f->next, bb) ;
1173           ap_remove_output_filter(f) ;
1174           return rv;
1175         }
1176         apr_pool_cleanup_register(f->r->pool, ctxt->parser,
1177                 (void*)htmlFreeParserCtxt, apr_pool_cleanup_null) ;
1178 #ifndef USE_OLD_LIBXML2
1179         if ( xmlopts = xmlCtxtUseOptions(ctxt->parser, xmlopts ), xmlopts )
1180           ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, f->r,
1181                 "Unsupported parser opts %x", xmlopts) ;
1182 #endif
1183         if ( ctxt->cfg->metafix )
1184 #ifndef GO_FASTER
1185           m = metafix(f->r, buf, ctxt->cfg->verbose) ;
1186 #else
1187           m = metafix(f->r, buf) ;
1188 #endif
1189         if ( m ) {
1190           consume_buffer(ctxt, buf, m->start, 0) ;
1191           consume_buffer(ctxt, buf+m->end, bytes-m->end, 0) ;
1192         } else {
1193           consume_buffer(ctxt, buf, bytes, 0) ;
1194         }
1195       } else {
1196         consume_buffer(ctxt, buf, bytes, 0) ;
1197       }
1198     } else {
1199       ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, f->r, "Error in bucket read") ;
1200     }
1201   }
1202   /*ap_fflush(ctxt->f->next, ctxt->bb) ;        // uncomment for debug */
1203   apr_brigade_cleanup(bb) ;
1204   return APR_SUCCESS ;
1205 }
1206
1207 static void* proxy_html_config(apr_pool_t* pool, char* x) {
1208   proxy_html_conf* ret = apr_pcalloc(pool, sizeof(proxy_html_conf) ) ;
1209   ret->doctype = DEFAULT_DOCTYPE ;
1210   ret->etag = DEFAULT_ETAG ;
1211   ret->bufsz = 8192 ;
1212   ret->default_encoding = XML_CHAR_ENCODING_NONE ;
1213   /* ret->interp = 1; */
1214   /* don't initialise links and events until they get set/used */
1215   return ret ;
1216 }
1217 static void* proxy_html_merge(apr_pool_t* pool, void* BASE, void* ADD) {
1218   proxy_html_conf* base = (proxy_html_conf*) BASE ;
1219   proxy_html_conf* add = (proxy_html_conf*) ADD ;
1220   proxy_html_conf* conf = apr_palloc(pool, sizeof(proxy_html_conf)) ;
1221
1222   /* don't merge declarations - just use the most specific */
1223   conf->links = (add->links == NULL) ? base->links : add->links;
1224   conf->events = (add->events == NULL) ? base->events : add->events;
1225
1226   conf->default_encoding = (add->default_encoding == XML_CHAR_ENCODING_NONE)
1227         ? base->default_encoding : add->default_encoding ;
1228   conf->charset_out = (add->charset_out == NULL)
1229         ? base->charset_out : add->charset_out ;
1230
1231   if ( add->map && base->map ) {
1232     urlmap* a ;
1233     conf->map = NULL ;
1234     for ( a = base->map ; a ; a = a->next ) {
1235       urlmap* save = conf->map ;
1236       conf->map = apr_pmemdup(pool, a, sizeof(urlmap)) ;
1237       conf->map->next = save ;
1238     }
1239     for ( a = add->map ; a ; a = a->next ) {
1240       urlmap* save = conf->map ;
1241       conf->map = apr_pmemdup(pool, a, sizeof(urlmap)) ;
1242       conf->map->next = save ;
1243     }
1244   } else
1245     conf->map = add->map ? add->map : base->map ;
1246
1247   conf->doctype = ( add->doctype == DEFAULT_DOCTYPE )
1248                 ? base->doctype : add->doctype ;
1249   conf->etag = ( add->etag == DEFAULT_ETAG ) ? base->etag : add->etag ;
1250   conf->bufsz = add->bufsz ;
1251   if ( add->flags & NORM_RESET ) {
1252     conf->flags = add->flags ^ NORM_RESET ;
1253     conf->metafix = add->metafix ;
1254     conf->extfix = add->extfix ;
1255     conf->interp = add->interp ;
1256     conf->strip_comments = add->strip_comments ;
1257     conf->skipto = add->skipto ;
1258 #ifndef GO_FASTER
1259     conf->verbose = add->verbose ;
1260 #endif
1261   } else {
1262     conf->flags = base->flags | add->flags ;
1263     conf->metafix = base->metafix | add->metafix ;
1264     conf->extfix = base->extfix | add->extfix ;
1265     conf->interp = base->interp | add->interp ;
1266     conf->strip_comments = base->strip_comments | add->strip_comments ;
1267     conf->skipto = add->skipto ? add->skipto : base->skipto ;
1268 #ifndef GO_FASTER
1269     conf->verbose = base->verbose | add->verbose ;
1270 #endif
1271   }
1272   return conf ;
1273 }
1274 #define REGFLAG(n,s,c) ( (s&&(ap_strchr_c((s),(c))!=NULL)) ? (n) : 0 )
1275 #define XREGFLAG(n,s,c) ( (!s||(ap_strchr_c((s),(c))==NULL)) ? (n) : 0 )
1276 static void comp_urlmap(apr_pool_t* pool, urlmap* newmap,
1277         const char* from, const char* to, const char* flags, const char* cond) {
1278   char* eq;
1279   newmap->flags
1280         = XREGFLAG(M_HTML,flags,'h')
1281         | XREGFLAG(M_EVENTS,flags,'e')
1282         | XREGFLAG(M_CDATA,flags,'c')
1283         | REGFLAG(M_ATSTART,flags,'^')
1284         | REGFLAG(M_ATEND,flags,'$')
1285         | REGFLAG(M_REGEX,flags,'R')
1286         | REGFLAG(M_LAST,flags,'L')
1287         | REGFLAG(M_NOTLAST,flags,'l')
1288         | REGFLAG(M_INTERPOLATE_TO,flags,'V')
1289         | REGFLAG(M_INTERPOLATE_FROM,flags,'v')
1290   ;
1291   if ( ( newmap->flags & M_INTERPOLATE_FROM)
1292                 || ! (newmap->flags & M_REGEX) ) {
1293     newmap->from.c = from ;
1294     newmap->to = to ;
1295   } else {
1296     newmap->regflags
1297         = REGFLAG(AP_REG_EXTENDED,flags,'x')
1298         | REGFLAG(AP_REG_ICASE,flags,'i')
1299         | REGFLAG(AP_REG_NOSUB,flags,'n')
1300         | REGFLAG(AP_REG_NEWLINE,flags,'s')
1301     ;
1302     newmap->from.r = ap_pregcomp(pool, from, newmap->regflags) ;
1303     newmap->to = to ;
1304   }
1305   if (cond != NULL) {
1306     newmap->cond = apr_pcalloc(pool, sizeof(rewritecond));
1307     if (cond[0] == '!') {
1308       newmap->cond->rel = -1;
1309       newmap->cond->env = cond+1;
1310     } else {
1311       newmap->cond->rel = 1;
1312       newmap->cond->env = cond;
1313     }
1314     eq = ap_strchr_c(++cond, '=');
1315     if (eq && (eq != cond)) {
1316       *eq = 0;
1317       newmap->cond->val = eq+1;
1318     }
1319   } else {
1320     newmap->cond = NULL;
1321   }
1322 }
1323 static const char* set_urlmap(cmd_parms* cmd, void* CFG, const char* args) {
1324   proxy_html_conf* cfg = (proxy_html_conf*)CFG ;
1325   urlmap* map ;
1326   apr_pool_t* pool = cmd->pool;
1327   urlmap* newmap ;
1328   const char* usage =
1329         "Usage: ProxyHTMLURLMap from-pattern to-pattern [flags] [cond]";
1330   const char* from;
1331   const char* to;
1332   const char* flags;
1333   const char* cond = NULL;
1334
1335   if (from = ap_getword_conf(cmd->pool, &args), !from)
1336     return usage;
1337   if (to = ap_getword_conf(cmd->pool, &args), !to)
1338     return usage;
1339   flags = ap_getword_conf(cmd->pool, &args);
1340   if (flags && *flags)
1341     cond = ap_getword_conf(cmd->pool, &args);
1342   if (cond && !*cond)
1343     cond = NULL;
1344
1345   /* the args look OK, so let's use them */
1346   newmap = apr_palloc(pool, sizeof(urlmap) ) ;
1347   newmap->next = NULL;
1348   if ( cfg->map ) {
1349     for ( map = cfg->map ; map->next ; map = map->next ) ;
1350     map->next = newmap ;
1351   } else
1352     cfg->map = newmap ;
1353
1354   comp_urlmap(cmd->pool, newmap, from, to, flags, cond);
1355   return NULL;
1356 }
1357
1358 static const char* set_doctype(cmd_parms* cmd, void* CFG, const char* t,
1359         const char* l) {
1360   proxy_html_conf* cfg = (proxy_html_conf*)CFG ;
1361   if ( !strcasecmp(t, "xhtml") ) {
1362     cfg->etag = xhtml_etag ;
1363     if ( l && !strcasecmp(l, "legacy") )
1364       cfg->doctype = fpi_xhtml_legacy ;
1365     else
1366       cfg->doctype = fpi_xhtml ;
1367   } else if ( !strcasecmp(t, "html") ) {
1368     cfg->etag = html_etag ;
1369     if ( l && !strcasecmp(l, "legacy") )
1370       cfg->doctype = fpi_html_legacy ;
1371     else
1372       cfg->doctype = fpi_html ;
1373   } else {
1374     cfg->doctype = apr_pstrdup(cmd->pool, t) ;
1375     if ( l && ( ( l[0] == 'x' ) || ( l[0] == 'X' ) ) )
1376       cfg->etag = xhtml_etag ;
1377     else
1378       cfg->etag = html_etag ;
1379   }
1380   return NULL ;
1381 }
1382 static const char* set_flags(cmd_parms* cmd, void* CFG, const char* arg) {
1383   proxy_html_conf* cfg = CFG;
1384   if ( arg && *arg ) {
1385     if ( !strcmp(arg, "lowercase") )
1386       cfg->flags |= NORM_LC ;
1387     else if ( !strcmp(arg, "dospath") )
1388       cfg->flags |= NORM_MSSLASH ;
1389     else if ( !strcmp(arg, "reset") )
1390       cfg->flags |= NORM_RESET ;
1391   }
1392   return NULL ;
1393 }
1394 static const char* set_events(cmd_parms* cmd, void* CFG, const char* arg) {
1395   tattr* attr;
1396   proxy_html_conf* cfg = CFG;
1397   if (cfg->events == NULL)
1398     cfg->events = apr_array_make(cmd->pool, 20, sizeof(tattr));
1399   attr = apr_array_push(cfg->events) ;
1400   attr->val = arg;
1401   return NULL ;
1402 }
1403 static const char* set_skipto(cmd_parms* cmd, void* CFG, const char* arg) {
1404   tattr* attr;
1405   proxy_html_conf* cfg = CFG;
1406   if (cfg->skipto == NULL)
1407     cfg->skipto = apr_array_make(cmd->pool, 4, sizeof(tattr));
1408   attr = apr_array_push(cfg->skipto) ;
1409   attr->val = arg;
1410   return NULL ;
1411 }
1412 static const char* set_links(cmd_parms* cmd, void* CFG,
1413         const char* elt, const char* att) {
1414   apr_array_header_t* attrs;
1415   tattr* attr ;
1416   proxy_html_conf* cfg = CFG;
1417
1418   if (cfg->links == NULL)
1419     cfg->links = apr_hash_make(cmd->pool);
1420
1421   attrs = apr_hash_get(cfg->links, elt, APR_HASH_KEY_STRING) ;
1422   if (!attrs) {
1423     attrs = apr_array_make(cmd->pool, 2, sizeof(tattr*)) ;
1424     apr_hash_set(cfg->links, elt, APR_HASH_KEY_STRING, attrs) ;
1425   }
1426   attr = apr_array_push(attrs) ;
1427   attr->val = att ;
1428   return NULL ;
1429 }
1430 static const char* set_charset_alias(cmd_parms* cmd, void* CFG,
1431         const char* charset, const char* alias) {
1432   const char* errmsg = ap_check_cmd_context(cmd, GLOBAL_ONLY);
1433   if (errmsg != NULL)
1434     return errmsg ;
1435   else if (xmlAddEncodingAlias(charset, alias) == 0)
1436     return NULL;
1437   else
1438     return "Error setting charset alias";
1439 }
1440 static const char* set_charset_default(cmd_parms* cmd, void* CFG,
1441         const char* charset) {
1442   proxy_html_conf* cfg = CFG;
1443   cfg->default_encoding = xmlParseCharEncoding(charset);
1444   switch(cfg->default_encoding) {
1445     case XML_CHAR_ENCODING_NONE:
1446       return "Default charset not found";
1447     case XML_CHAR_ENCODING_ERROR:
1448       return "Invalid or unsupported default charset";
1449     default:
1450       return NULL;
1451   }
1452 }
1453 static const command_rec proxy_html_cmds[] = {
1454   AP_INIT_ITERATE("ProxyHTMLStartParse", set_skipto, NULL,
1455         RSRC_CONF|ACCESS_CONF,
1456         "Ignore anything in front of the first of these elements"),
1457   AP_INIT_ITERATE("ProxyHTMLEvents", set_events, NULL,
1458         RSRC_CONF|ACCESS_CONF, "Strings to be treated as scripting events"),
1459   AP_INIT_ITERATE2("ProxyHTMLLinks", set_links, NULL,
1460         RSRC_CONF|ACCESS_CONF, "Declare HTML Attributes"),
1461   AP_INIT_RAW_ARGS("ProxyHTMLURLMap", set_urlmap, NULL,
1462         RSRC_CONF|ACCESS_CONF, "Map URL From To" ) ,
1463   AP_INIT_TAKE12("ProxyHTMLDoctype", set_doctype, NULL,
1464         RSRC_CONF|ACCESS_CONF, "(HTML|XHTML) [Legacy]" ) ,
1465   AP_INIT_ITERATE("ProxyHTMLFixups", set_flags, NULL,
1466         RSRC_CONF|ACCESS_CONF, "Options are lowercase, dospath" ) ,
1467   AP_INIT_FLAG("ProxyHTMLMeta", ap_set_flag_slot,
1468         (void*)APR_OFFSETOF(proxy_html_conf, metafix),
1469         RSRC_CONF|ACCESS_CONF, "Fix META http-equiv elements" ) ,
1470   AP_INIT_FLAG("ProxyHTMLInterp", ap_set_flag_slot,
1471         (void*)APR_OFFSETOF(proxy_html_conf, interp),
1472         RSRC_CONF|ACCESS_CONF,
1473         "Support interpolation and conditions in URLMaps" ) ,
1474   AP_INIT_FLAG("ProxyHTMLExtended", ap_set_flag_slot,
1475         (void*)APR_OFFSETOF(proxy_html_conf, extfix),
1476         RSRC_CONF|ACCESS_CONF, "Map URLs in Javascript and CSS" ) ,
1477   AP_INIT_FLAG("ProxyHTMLStripComments", ap_set_flag_slot,
1478         (void*)APR_OFFSETOF(proxy_html_conf, strip_comments),
1479         RSRC_CONF|ACCESS_CONF, "Strip out comments" ) ,
1480 #ifndef GO_FASTER
1481   AP_INIT_FLAG("ProxyHTMLLogVerbose", ap_set_flag_slot,
1482         (void*)APR_OFFSETOF(proxy_html_conf, verbose),
1483         RSRC_CONF|ACCESS_CONF, "Verbose Logging (use with LogLevel Info)" ) ,
1484 #endif
1485   AP_INIT_TAKE1("ProxyHTMLBufSize", ap_set_int_slot,
1486         (void*)APR_OFFSETOF(proxy_html_conf, bufsz),
1487         RSRC_CONF|ACCESS_CONF, "Buffer size" ) ,
1488   AP_INIT_ITERATE2("ProxyHTMLCharsetAlias", set_charset_alias, NULL,
1489         RSRC_CONF, "ProxyHTMLCharsetAlias charset alias [more aliases]" ) ,
1490   AP_INIT_TAKE1("ProxyHTMLCharsetDefault", set_charset_default, NULL,
1491         RSRC_CONF|ACCESS_CONF, "Usage: ProxyHTMLCharsetDefault charset" ) ,
1492   AP_INIT_TAKE1("ProxyHTMLCharsetOut", ap_set_string_slot,
1493         (void*)APR_OFFSETOF(proxy_html_conf, charset_out),
1494         RSRC_CONF|ACCESS_CONF, "Usage: ProxyHTMLCharsetOut charset" ) ,
1495   { NULL }
1496 } ;
1497 static int mod_proxy_html(apr_pool_t* p, apr_pool_t* p1, apr_pool_t* p2,
1498         server_rec* s) {
1499   ap_add_version_component(p, VERSION_STRING) ;
1500   seek_meta_ctype = ap_pregcomp(p,
1501         "(<meta[^>]*http-equiv[ \t\r\n='\"]*content-type[^>]*>)",
1502         AP_REG_EXTENDED|AP_REG_ICASE) ;
1503   seek_charset = ap_pregcomp(p, "charset=([A-Za-z0-9_-]+)",
1504         AP_REG_EXTENDED|AP_REG_ICASE) ;
1505   seek_meta = ap_pregcomp(p, "<meta[^>]*(http-equiv)[^>]*>",
1506         AP_REG_EXTENDED|AP_REG_ICASE) ;
1507   memset(&sax, 0, sizeof(htmlSAXHandler));
1508   sax.startElement = pstartElement ;
1509   sax.endElement = pendElement ;
1510   sax.characters = pcharacters ;
1511   sax.comment = pcomment ;
1512   sax.cdataBlock = pcdata ;
1513   return OK ;
1514 }
1515 static void proxy_html_hooks(apr_pool_t* p) {
1516   ap_register_output_filter_protocol("proxy-html", proxy_html_filter,
1517         NULL, AP_FTYPE_RESOURCE,
1518         AP_FILTER_PROTO_CHANGE|AP_FILTER_PROTO_CHANGE_LENGTH) ;
1519   ap_hook_post_config(mod_proxy_html, NULL, NULL, APR_HOOK_MIDDLE) ;
1520 }
1521 module AP_MODULE_DECLARE_DATA proxy_html_module = {
1522         STANDARD20_MODULE_STUFF,
1523         proxy_html_config,
1524         proxy_html_merge,
1525         NULL,
1526         NULL,
1527         proxy_html_cmds,
1528         proxy_html_hooks
1529 } ;