joes        2003/04/15 02:36:12

  Modified:    .        acinclude.m4
               env      Makefile.am mod_apreq.c
               src      Makefile.am apreq.c apreq.h apreq_params.c
                        apreq_params.h apreq_parsers.c apreq_parsers.h
  Log:
  Changed configure option:
      dropped:                        --with-apache-includes
      temporarily replaced with:      --with-apache2  (server-root, assuming
                                                       typical Apache layout).
  
  Lots of bugfixes focusing on urlencoded data parsers (GET & POST).
  The mod_apreq filter is now functional; to bang on it, just do this
  
          % ./buildconf
          % ./configure --with-apache2=/path/to/apache2
          % make
          % cp src/.libs/libapreq.* /path/to/apache2/libs
          % cp env/.libs/mod_apreq.so /path/to/apache2/modules
  
  Now edit httpd.conf by adding
  
          LoadModule apreq_module modules/mod_apreq.so
          ...
          SetInputFilter APREQ
  
  in some appropriate place.  Hopefully the server will start up :-).
  Lowering the loglevel to DEBUG should produce some debugging messages in
  the error log.
  
  Revision  Changes    Path
  1.2       +8 -6      httpd-apreq-2/acinclude.m4
  
  Index: acinclude.m4
  ===================================================================
  RCS file: /home/cvs/httpd-apreq-2/acinclude.m4,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- acinclude.m4      17 Jan 2003 06:39:43 -0000      1.1
  +++ acinclude.m4      15 Apr 2003 09:36:11 -0000      1.2
  @@ -1,10 +1,12 @@
   AC_DEFUN(AC_APREQ, [
  -     AC_ARG_WITH(apache-includes,
  -             [  --with-apache-includes  where the apache header files live],
  -             [APACHE_INCLUDES=$withval],
  -             [APACHE_INCLUDES="/usr/local/apache/include"])
  -     APREQ_INCLUDES="-I$APACHE_INCLUDES"
  -     AC_SUBST(APREQ_INCLUDES)
  +     AC_ARG_WITH(apache2,
  +             [  --with-apache2  the apache-2 server_root directory],
  +             [APACHE2=$withval],
  +             [APACHE2="/usr/local/apache2"])
  +     APACHE2_INCLUDES="$APACHE2/include"
  +        APACHE2_MODULES="$APACHE2/modules"
  +        APACHE2_LIBS="$APACHE2/lib"
  +     AC_SUBST(APACHE2_INCLUDES) AC_SUBST(APACHE2_MODULES) 
AC_SUBST(APACHE2_LIBS)
   ])
   
   AC_DEFUN(APR_ADDTO,[
  
  
  
  1.2       +5 -4      httpd-apreq-2/env/Makefile.am
  
  Index: Makefile.am
  ===================================================================
  RCS file: /home/cvs/httpd-apreq-2/env/Makefile.am,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- Makefile.am       12 Apr 2003 04:52:15 -0000      1.1
  +++ Makefile.am       15 Apr 2003 09:36:11 -0000      1.2
  @@ -1,4 +1,5 @@
  -lib_LTLIBRARIES = lib_mod_apreq.la
  -lib_mod_apreq_la_SOURCES = mod_apreq.c
  -lib_mod_apreq_la_LDFLAGS = -version-info 2:0
  -INCLUDES = @APREQ_INCLUDES@ -I../src
  +lib_LTLIBRARIES = mod_apreq.la
  +INCLUDES = [EMAIL PROTECTED]@ -I../src
  +mod_apreq_la_SOURCES = mod_apreq.c
  +mod_apreq_la_LDFLAGS = -rpath @APACHE2_LIBS@ -dynamic -module
  +mod_apreq_la_LIBADD = ../src/libapreq.la
  
  
  
  1.3       +33 -7     httpd-apreq-2/env/mod_apreq.c
  
  Index: mod_apreq.c
  ===================================================================
  RCS file: /home/cvs/httpd-apreq-2/env/mod_apreq.c,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- mod_apreq.c       12 Apr 2003 15:42:11 -0000      1.2
  +++ mod_apreq.c       15 Apr 2003 09:36:11 -0000      1.3
  @@ -70,14 +70,15 @@
   /* the "warehouse" */
   
   struct env_ctx {
  -    apreq_request_t *req;
  -    apreq_jar_t *jar;
  +    apreq_request_t    *req;
  +    apreq_jar_t        *jar;
       apr_bucket_brigade *bb_in;
       apr_bucket_brigade *bb_parse;
   };
   
   static const char env_name[] = "APACHE2";
   static const char filter_name[] = "APREQ";
  +module AP_MODULE_DECLARE_DATA apreq_module;
   
   static apr_pool_t *env_pool(void *ctx)
   {
  @@ -94,7 +95,7 @@
   static apr_status_t env_out(void *ctx, const char *name, char *value)
   {
       dR;
  -    apr_table_add(r->headers_out, name, value);
  +    apr_table_addn(r->headers_out, name, value);
       return APR_SUCCESS;
   }
   
  @@ -151,6 +152,16 @@
       return NULL;
   }
   
  +
  +static int dump_table(void *ctx, const char *key, const char *value)
  +{
  +    request_rec *r = ctx;
  +    dAPREQ_LOG;
  +    apreq_log(APREQ_DEBUG 0, r, "%s => %s", key, value);
  +    return 1;
  +}
  +
  +
   static apr_status_t apreq_filter(ap_filter_t *f,
                                    apr_bucket_brigade *bb,
                                    ap_input_mode_t mode,
  @@ -159,8 +170,8 @@
   {
       request_rec *r = f->r;
       struct env_ctx *ctx;
  -
       apr_status_t rv;
  +    dAPREQ_LOG;
   
       /* just get out of the way of things we don't want. */
       if (mode != AP_MODE_READBYTES) {
  @@ -174,7 +185,16 @@
               ctx->bb_in = apr_brigade_create(r->pool, f->c->bucket_alloc);
           if (ctx->bb_parse == NULL)
               ctx->bb_parse = apr_brigade_create(r->pool, f->c->bucket_alloc);
  -
  +        if (ctx->req == NULL) {
  +            apreq_parser_t *parser;
  +            ctx->req = apreq_request(r);
  +            parser = apreq_make_parser(r->pool, APREQ_URL_ENCTYPE,
  +                                       apreq_parse_urlencoded, NULL, 
ctx->req);
  +            apreq_register_parser(ctx->req, parser);
  +            parser = apreq_make_parser(r->pool, APREQ_MFD_ENCTYPE,
  +                                       apreq_parse_multipart, NULL, 
ctx->req);
  +            apreq_register_parser(ctx->req, parser);
  +        }
       }
       else
           ctx = (struct env_ctx *)f->ctx;
  @@ -184,12 +204,15 @@
       rv = ap_get_brigade(f->next, ctx->bb_in, AP_MODE_READBYTES,
                           block, readbytes);
   
  +    apreq_log(APREQ_DEBUG rv, r, "dump args:");
  +    apreq_table_do(dump_table, r, ctx->req->args, NULL);
  +
   
       if (ctx->req->v.status == APR_INCOMPLETE) {
           int saw_eos = 0;
   
           while (! APR_BRIGADE_EMPTY(ctx->bb_in)) {
  -            apr_bucket *e, *f = APR_BRIGADE_FIRST(bb);
  +            apr_bucket *e, *f = APR_BRIGADE_FIRST(ctx->bb_in);
               apr_bucket_copy(f, &e);
               apr_bucket_setaside(e, r->pool);
   
  @@ -206,12 +229,15 @@
           rv = apreq_parse(ctx->req, ctx->bb_parse);
   
           if (rv == APR_INCOMPLETE && saw_eos == 1)
  -            return APR_EGENERAL;        /* parser choked on EOS */
  +            return APR_EGENERAL;        /* parser choked on EOS bucket */
       }
   
       else {
           APR_BRIGADE_CONCAT(bb, ctx->bb_in);
       }
  +
  +    apreq_log(APREQ_DEBUG rv, r, "dump body:");
  +    apreq_table_do(dump_table, r, ctx->req->body, NULL);
   
       return rv;
   }
  
  
  
  1.5       +3 -2      httpd-apreq-2/src/Makefile.am
  
  Index: Makefile.am
  ===================================================================
  RCS file: /home/cvs/httpd-apreq-2/src/Makefile.am,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- Makefile.am       11 Apr 2003 04:24:01 -0000      1.4
  +++ Makefile.am       15 Apr 2003 09:36:11 -0000      1.5
  @@ -3,5 +3,6 @@
                        apreq_tables.h apreq_env.h apreq_parsers.h
   libapreq_la_SOURCES = apreq.c apreq_tables.c apreq_cookie.c \
                         apreq_params.c apreq_parsers.c
  -libapreq_la_LDFLAGS = -version-info 2:0
  -INCLUDES = @APREQ_INCLUDES@
  +libapreq_la_LDFLAGS = -lapr-0 -laprutil-0 -version-info 2:0 -rpath 
@APACHE2_LIBS@
  +INCLUDES = [EMAIL PROTECTED]@
  +LIBS = [EMAIL PROTECTED]@
  
  
  
  1.10      +3 -1      httpd-apreq-2/src/apreq.c
  
  Index: apreq.c
  ===================================================================
  RCS file: /home/cvs/httpd-apreq-2/src/apreq.c,v
  retrieving revision 1.9
  retrieving revision 1.10
  diff -u -r1.9 -r1.10
  --- apreq.c   12 Apr 2003 01:45:30 -0000      1.9
  +++ apreq.c   15 Apr 2003 09:36:11 -0000      1.10
  @@ -505,7 +505,7 @@
           break;
   
   
  -    default:
  +    case AS_IS:
           memcpy(d,a[0]->data,a[0]->size);
           d += a[0]->size;
   
  @@ -517,6 +517,8 @@
           }
           break;
   
  +    default:
  +        break;
       }
   
       *d = 0;
  
  
  
  1.10      +0 -3      httpd-apreq-2/src/apreq.h
  
  Index: apreq.h
  ===================================================================
  RCS file: /home/cvs/httpd-apreq-2/src/apreq.h,v
  retrieving revision 1.9
  retrieving revision 1.10
  diff -u -r1.9 -r1.10
  --- apreq.h   12 Apr 2003 01:45:30 -0000      1.9
  +++ apreq.h   15 Apr 2003 09:36:11 -0000      1.10
  @@ -12,11 +12,8 @@
   #define APREQ_DECLARE(d)                d
   
   #define APREQ_URL_ENCTYPE               "application/x-www-form-urlencoded"
  -#define APREQ_URL_LENGTH                33
   #define APREQ_MFD_ENCTYPE               "multipart/form-data"
  -#define APREQ_MFD_ENCTYPE_LENGTH        19
   #define APREQ_XML_ENCTYPE               "application/xml"
  -#define APREQ_XML_ENCTYPE_LENGTH        15
   
   #define APREQ_NELTS                     8
   
  
  
  
  1.9       +23 -38    httpd-apreq-2/src/apreq_params.c
  
  Index: apreq_params.c
  ===================================================================
  RCS file: /home/cvs/httpd-apreq-2/src/apreq_params.c,v
  retrieving revision 1.8
  retrieving revision 1.9
  diff -u -r1.8 -r1.9
  --- apreq_params.c    12 Apr 2003 04:52:15 -0000      1.8
  +++ apreq_params.c    15 Apr 2003 09:36:11 -0000      1.9
  @@ -95,7 +95,7 @@
       apreq_request_t *req, *old_req = apreq_env_request(ctx, NULL);
       const char *query_string, *ct;
       apr_pool_t *p;
  -
  +    apr_status_t s;
       dAPREQ_LOG;
   
       if (old_req != NULL)
  @@ -103,8 +103,8 @@
   
       p = apreq_env_pool(ctx);
       req = apr_palloc(p, sizeof(apreq_table_t *) + sizeof *req);
  -
  -    *(apreq_table_t **)&req->v.data = apreq_make_table(p, APREQ_NELTS);
  +    req->pool = p;
  +    *(apreq_table_t **)req->v.data = apreq_make_table(p, APREQ_NELTS);
       req->v.size   = sizeof(apreq_table_t *);
       req->v.status = APR_EINIT;
       req->env      = ctx;
  @@ -116,11 +116,11 @@
       if (ct == NULL)
           req->v.name = NULL;
       else {
  -        char *enctype = apr_pstrdup(req->pool, ct);
  +        char *enctype = apr_pstrdup(p, ct);
           char *semicolon = strchr(enctype, ';');
           if (semicolon)
               *semicolon = 0;
  -
  +        apreq_log(APREQ_DEBUG 0, ctx, "enctype: %s", enctype);
           req->v.name = enctype;
       }
   
  @@ -135,37 +135,29 @@
           return old_req;
       }
   
  -    apreq_log(APREQ_DEBUG req->v.status, ctx, "making new request");
  -
       /* XXX need to install copy/merge callbacks for apreq_param_t */
       req->pool = p;
       query_string = apreq_env_args(ctx);
  -    req->v.status = (query_string == NULL) ? APR_SUCCESS :
  -        apreq_split_params(p, req->args, query_string, strlen(query_string));
  - 
  -    return req;
  -}
   
  +    s = (query_string == NULL) ? APR_SUCCESS : 
  +        apreq_split_params(p, req->args, query_string);
   
  -APREQ_DECLARE(const apreq_param_t *)apreq_param(const apreq_request_t *req, 
  -                                                const char *name)
  -{
  -    const apreq_param_t *param = UPGRADE(apreq_table_get(req->args, name));
  -    return param ? param : UPGRADE(apreq_table_get(req->body, name));
  -}
  -
  +    if (s == APR_SUCCESS)
  +        req->v.status = ct ? APR_INCOMPLETE : APR_SUCCESS;
   
  -APREQ_DECLARE(const apreq_table_t *) (apreq_args)(const apreq_request_t *req)
  -{
  -    return apreq_args(req);
  +    return req;
   }
   
   
  -APREQ_DECLARE(const apreq_table_t *) (apreq_body)(const apreq_request_t *req)
  +APREQ_DECLARE(const char *)apreq_param(const apreq_request_t *req, 
  +                                       const char *name)
   {
  -    return apreq_body(req);
  +    const char *param = apreq_table_get(req->args, name);
  +    return  param ? param : 
  +        req->body ? apreq_table_get(req->body, name) : NULL;
   }
   
  +
   APREQ_DECLARE(apr_array_header_t *) apreq_params(apr_pool_t *pool,
                                                    const apreq_request_t *req, 
                                                    const char *name)
  @@ -178,14 +170,13 @@
   
   APREQ_DECLARE(apr_status_t) apreq_split_params(apr_pool_t *pool,
                                                  apreq_table_t *t,
  -                                               const char *data, 
  -                                               apr_size_t dlen)
  +                                               const char *data)
   {
  -    const char *start = data, *end = data + dlen;
  +    const char *start = data;
       apr_size_t nlen = 0;
       apr_status_t status = APR_SUCCESS;
   
  -    for (; data < end; ++data) {
  +    for (;;++data) {
           switch (*data) {
   
           case '=':
  @@ -199,23 +190,19 @@
           case '&':
           case ';': 
           case 0:
  -            if (nlen == 0) {
  -                return APR_BADARG;
  -            }
  -            else {
  +            if (nlen > 0) {
                   const apr_size_t vlen = data - start - nlen - 1;
                   status = apreq_table_add(t, p2v(
                                   apreq_decode_param( pool, start,
                                                       nlen, vlen )));
   
  -                if (status != APR_SUCCESS)
  +                if (*data == 0 || status != APR_SUCCESS)
                       return status;
               }
   
               nlen = 0;
               start = data + 1;
  -            if (start < end)
  -                status = APR_INCOMPLETE;
  +            status = APR_INCOMPLETE;
           }
       }
       return status;
  @@ -230,7 +217,7 @@
       apreq_param_t *param;
       apr_ssize_t size;
   
  -    if (nlen == 0 || vlen == 0 || word[nlen] != '=')
  +    if (nlen == 0 || word[nlen] != '=')
           return NULL;
   
       param = apr_palloc(pool, nlen + vlen + 1 + sizeof *param);
  @@ -280,5 +267,3 @@
   
       return v->data;
   }
  -
  -
  
  
  
  1.8       +2 -12     httpd-apreq-2/src/apreq_params.h
  
  Index: apreq_params.h
  ===================================================================
  RCS file: /home/cvs/httpd-apreq-2/src/apreq_params.h,v
  retrieving revision 1.7
  retrieving revision 1.8
  diff -u -r1.7 -r1.8
  --- apreq_params.h    12 Apr 2003 04:52:15 -0000      1.7
  +++ apreq_params.h    15 Apr 2003 09:36:11 -0000      1.8
  @@ -121,22 +121,13 @@
    * @remark Also parses the request as necessary.
    */
   
  -APREQ_DECLARE(const apreq_param_t *) apreq_param(const apreq_request_t *req, 
  +APREQ_DECLARE(const char *) apreq_param(const apreq_request_t *req, 
                                           const char *name); 
   
   APREQ_DECLARE(const char *) apreq_arg(const apreq_request_t *req, 
                                         const char *name);
   #define apreq_arg(req,k) apreq_table_get((req)->args, k)
   
  -
  -APREQ_DECLARE(const apreq_table_t *) apreq_args(const apreq_request_t *req);
  -#define apreq_args(req) (const apreq_table_t *)((req)->args)
  -
  -APREQ_DECLARE(const apreq_table_t *) apreq_body(const apreq_request_t *req);
  -/* Danger Will Robinson!  */
  -#define apreq_body(req) (const apreq_table_t *)((req)->body)
  -
  -
   /**
    * Returns all parameters for the requested key,
    * NULL if none found. The key is case-insensitive.
  @@ -171,8 +162,7 @@
   
   APREQ_DECLARE(apr_status_t)  apreq_split_params(apr_pool_t *pool,
                                                   apreq_table_t *t, 
  -                                                const char *data, 
  -                                                const apr_size_t dlen);
  +                                                const char *data);
   
   APREQ_DECLARE(apreq_param_t *) apreq_decode_param(apr_pool_t *pool, 
                                                     const char *word,
  
  
  
  1.10      +37 -29    httpd-apreq-2/src/apreq_parsers.c
  
  Index: apreq_parsers.c
  ===================================================================
  RCS file: /home/cvs/httpd-apreq-2/src/apreq_parsers.c,v
  retrieving revision 1.9
  retrieving revision 1.10
  diff -u -r1.9 -r1.10
  --- apreq_parsers.c   13 Apr 2003 17:53:10 -0000      1.9
  +++ apreq_parsers.c   15 Apr 2003 09:36:11 -0000      1.10
  @@ -93,15 +93,10 @@
   
   
   APREQ_DECLARE(apr_status_t) apreq_register_parser(apreq_request_t *req,
  -                                                  const char *enctype,
  -                                                  APREQ_PARSER(*parser),
  -                                                  APREQ_HOOK(*hook),
  -                                                  void *out)
  +                                                  apreq_parser_t *parser)
   {
  -    apreq_parser_t *p = apreq_make_parser(req->pool, enctype, 
  -                                          parser, hook, out);
       if (req->body == NULL)
  -        return apreq_table_add((apreq_table_t *)req->v.data, &p->v);
  +        return apreq_table_add(*(apreq_table_t **)req->v.data, &parser->v);
       else
           return APR_EGENERAL;
   }
  @@ -110,18 +105,28 @@
   APREQ_DECLARE(apr_status_t) apreq_parse(apreq_request_t *req, 
                                           apr_bucket_brigade *bb)
   {
  +    dAPREQ_LOG;
   
  -    if (req->v.name == NULL)
  -        return req->v.status;
  +    if (req->v.name == NULL) {
  +        if (req->v.status == APR_SUCCESS)
  +            return APR_SUCCESS;
  +        else
  +            return req->v.status = APR_EINIT;
  +    }
   
  -    if (req->body == NULL && req->v.status == APR_SUCCESS) {
  -        const char *q = apreq_table_get((apreq_table_t *)req->v.data,
  -                                                         req->v.name);
  -        if (q == NULL)
  +    if (req->body == NULL) {
  +        const char *q = apreq_table_get(*(apreq_table_t **)req->v.data,
  +                                        req->v.name);
  +        if (q == NULL) {
  +            apreq_log(APREQ_DEBUG APR_NOTFOUND, req->env, 
  +                      "can't find %s parser", req->v.name);
               return req->v.status = APR_NOTFOUND;
  -
  +        }
           req->body = apreq_table_make(req->pool, APREQ_NELTS);
   
  +        apreq_log(APREQ_DEBUG APR_SUCCESS, req->env, 
  +                  "found %s parser", req->v.name);
  +
           *(apreq_parser_t **)req->v.data = 
               apreq_value_to_parser(apreq_strtoval(q));
   
  @@ -129,9 +134,10 @@
           req->v.status = APR_INCOMPLETE;
       }
   
  -    if (req->v.status == APR_INCOMPLETE && req->body != NULL) {
  -        apreq_parser_t *p = (apreq_parser_t *)req->v.data;
  +    if (req->v.status == APR_INCOMPLETE) {
  +        apreq_parser_t *p = *(apreq_parser_t **)req->v.data;
           req->v.status = p->parser(req->pool, bb, p);
  +        apreq_log(APREQ_DEBUG req->v.status, req->env, "parsing request.");
       }
   
       return req->v.status;
  @@ -156,7 +162,7 @@
       param->charset = UTF_8;
       param->language = NULL;
   
  -    v->name = v->data + vlen;
  +    v->name = v->data + vlen + 1;
   
       off = 0;
       total = 0;
  @@ -165,7 +171,7 @@
           const char *data;
           apr_bucket *f = APR_BRIGADE_FIRST(bb);
           apr_status_t s = apr_bucket_read(f, &data, &dlen, APR_BLOCK_READ);
  -        apr_ssize_t rv;
  +        apr_ssize_t decoded_len;
   
           if ( s != APR_SUCCESS )
               return s;
  @@ -175,14 +181,14 @@
               dlen = nlen - total;
           }
   
  -        rv = apreq_decode((char *)v->name + off, data, dlen);
  +        decoded_len = apreq_decode((char *)v->name + off, data, dlen);
   
  -        if (rv < 0) {
  +        if (decoded_len < 0) {
               return APR_BADARG;
           }
   
           total += dlen;
  -        off += rv;
  +        off += decoded_len;
           apr_bucket_delete(f);
       }
   
  @@ -217,7 +223,7 @@
           const char *data;
           apr_bucket *f = APR_BRIGADE_FIRST(bb);
           apr_status_t s = apr_bucket_read(f, &data, &dlen, APR_BLOCK_READ);
  -        apr_ssize_t rv;
  +        apr_ssize_t decoded_len;
   
           if ( s != APR_SUCCESS )
               return s;
  @@ -227,14 +233,14 @@
               dlen = vlen - total;
           }
   
  -        rv = apreq_decode(v->data + off, data, dlen);
  +        decoded_len = apreq_decode(v->data + off, data, dlen);
   
  -        if (rv < 0) {
  +        if (decoded_len < 0) {
               return APR_BADCH;
           }
   
           total += dlen;
  -        off += rv;
  +        off += decoded_len;
           apr_bucket_delete(f);
       }
   
  @@ -252,7 +258,7 @@
   {
       apreq_request_t *req = (apreq_request_t *)parser->out;
       apreq_table_t *t = req->body;
  -
  +    dAPREQ_LOG;
       apr_ssize_t nlen, vlen;
       apr_bucket *e;
   
  @@ -273,10 +279,12 @@
           const char *data;
           apr_status_t s = apr_bucket_read(e, &data, &dlen, APR_BLOCK_READ);
   
  -        if (APR_BUCKET_IS_EOS(e))
  -            return nlen == 0 ? APR_SUCCESS : 
  +        if (APR_BUCKET_IS_EOS(e)) {
  +            apreq_log(APREQ_DEBUG s, req->env,
  +                      "got eos bucket: %d, %d", nlen, vlen);
  +            return vlen == 0 ? APR_SUCCESS : 
                   split_urlword(pool, t, bb, nlen, vlen);
  -
  +        }
           if ( s != APR_SUCCESS )
               return s;
   
  
  
  
  1.7       +1 -4      httpd-apreq-2/src/apreq_parsers.h
  
  Index: apreq_parsers.h
  ===================================================================
  RCS file: /home/cvs/httpd-apreq-2/src/apreq_parsers.h,v
  retrieving revision 1.6
  retrieving revision 1.7
  diff -u -r1.6 -r1.7
  --- apreq_parsers.h   12 Apr 2003 15:42:11 -0000      1.6
  +++ apreq_parsers.h   15 Apr 2003 09:36:11 -0000      1.7
  @@ -59,10 +59,7 @@
                                                     void *out);
   
   APREQ_DECLARE(apr_status_t) apreq_register_parser(apreq_request_t *req,
  -                                                  const char *enctype,
  -                                                  APREQ_PARSER(*parser),
  -                                                  APREQ_HOOK(*hook),
  -                                                  void *out);
  +                                                  apreq_parser_t *parser);
   
   APREQ_DECLARE(apr_status_t) apreq_copy_parser(apr_pool_t *p, 
                                                 const apreq_value_t *v);
  
  
  

Reply via email to