apreq_module.h

Go to the documentation of this file.

/*
**  Licensed to the Apache Software Foundation (ASF) under one or more
** contributor license agreements.  See the NOTICE file distributed with
** this work for additional information regarding copyright ownership.
** The ASF licenses this file to You under the Apache License, Version 2.0
** (the "License"); you may not use this file except in compliance with
** the License.  You may obtain a copy of the License at
**
**      http://www.apache.org/licenses/LICENSE-2.0
**
**  Unless required by applicable law or agreed to in writing, software
**  distributed under the License is distributed on an "AS IS" BASIS,
**  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
**  See the License for the specific language governing permissions and
**  limitations under the License.
*/
 
#ifndef APREQ_MODULE_H
#define APREQ_MODULE_H
 
#include "apreq_cookie.h"
#include "apreq_parser.h"
#include "apreq_error.h"
 
#ifdef  __cplusplus
 extern "C" {
#endif
 
typedef struct apreq_handle_t {
    const struct apreq_module_t *module;
    apr_pool_t *pool;
    apr_bucket_alloc_t *bucket_alloc;
 
} apreq_handle_t;
 
typedef struct apreq_module_t {
    const char *name;
    apr_uint32_t magic_number;
 
    apr_status_t (*jar)(apreq_handle_t *, const apr_table_t **);
    apr_status_t (*args)(apreq_handle_t *, const apr_table_t **);
    apr_status_t (*body)(apreq_handle_t *, const apr_table_t **);
 
    apreq_cookie_t *(*jar_get)(apreq_handle_t *, const char *);
    apreq_param_t *(*args_get)(apreq_handle_t *, const char *);
    apreq_param_t *(*body_get)(apreq_handle_t *, const char *);
 
    apr_status_t (*parser_get)(apreq_handle_t *, const apreq_parser_t **);
    apr_status_t (*parser_set)(apreq_handle_t *, apreq_parser_t *);
    apr_status_t (*hook_add)(apreq_handle_t *, apreq_hook_t *);
 
    apr_status_t (*brigade_limit_get)(apreq_handle_t *, apr_size_t *);
    apr_status_t (*brigade_limit_set)(apreq_handle_t *, apr_size_t);
 
    apr_status_t (*read_limit_get)(apreq_handle_t *, apr_uint64_t *);
    apr_status_t (*read_limit_set)(apreq_handle_t *, apr_uint64_t);
 
    apr_status_t (*temp_dir_get)(apreq_handle_t *, const char **);
    apr_status_t (*temp_dir_set)(apreq_handle_t *, const char *);
 
} apreq_module_t;
 
 
static APR_INLINE
unsigned apreq_module_status_is_error(apr_status_t s) {
    switch (s) {
    case APR_SUCCESS:
    case APR_INCOMPLETE:
    case APR_EINIT:
    case APREQ_ERROR_NODATA:
    case APREQ_ERROR_NOPARSER:
    case APREQ_ERROR_NOHEADER:
        return 0;
    default:
        return 1;
    }
}
 
 
static APR_INLINE
apr_status_t apreq_jar(apreq_handle_t *req, const apr_table_t **t)
{
    return req->module->jar(req,t);
}
 
static APR_INLINE
apr_status_t apreq_args(apreq_handle_t *req, const apr_table_t **t)
{
    return req->module->args(req,t);
}
 
static APR_INLINE
apr_status_t apreq_body(apreq_handle_t *req, const apr_table_t **t)
{
    return req->module->body(req, t);
}
 
 
static APR_INLINE
apreq_cookie_t *apreq_jar_get(apreq_handle_t *req, const char *name)
{
    return req->module->jar_get(req, name);
}
 
static APR_INLINE
apreq_param_t *apreq_args_get(apreq_handle_t *req, const char *name)
{
    return req->module->args_get(req, name);
}
 
static APR_INLINE
apreq_param_t *apreq_body_get(apreq_handle_t *req, const char *name)
{
    return req->module->body_get(req, name);
}
 
static APR_INLINE
apr_status_t apreq_parser_get(apreq_handle_t *req,
                              const apreq_parser_t **parser)
{
    return req->module->parser_get(req, parser);
}
 
 
static APR_INLINE
apr_status_t apreq_parser_set(apreq_handle_t *req,
                              apreq_parser_t *parser)
{
    return req->module->parser_set(req, parser);
}
 
static APR_INLINE
apr_status_t apreq_hook_add(apreq_handle_t *req, apreq_hook_t *hook)
{
    return req->module->hook_add(req, hook);
}
 
 
static APR_INLINE
apr_status_t apreq_brigade_limit_set(apreq_handle_t *req,
                                     apr_size_t bytes)
{
    return req->module->brigade_limit_set(req, bytes);
}
 
static APR_INLINE
apr_status_t apreq_brigade_limit_get(apreq_handle_t *req,
                                     apr_size_t *bytes)
{
    return req->module->brigade_limit_get(req, bytes);
}
 
static APR_INLINE
apr_status_t apreq_read_limit_set(apreq_handle_t *req,
                                  apr_uint64_t bytes)
{
    return req->module->read_limit_set(req, bytes);
}
 
static APR_INLINE
apr_status_t apreq_read_limit_get(apreq_handle_t *req,
                                  apr_uint64_t *bytes)
{
    return req->module->read_limit_get(req, bytes);
}
 
static APR_INLINE
apr_status_t apreq_temp_dir_set(apreq_handle_t *req, const char *path)
{
    return req->module->temp_dir_set(req, path);
}
 
static APR_INLINE
apr_status_t apreq_temp_dir_get(apreq_handle_t *req, const char **path)
{
    return req->module->temp_dir_get(req, path);
}
 
 
 
#define APREQ_MODULE(pre, mmn) const apreq_module_t     \
  pre##_module = { #pre, mmn,                           \
  pre##_jar,        pre##_args,       pre##_body,       \
  pre##_jar_get,    pre##_args_get,   pre##_body_get,   \
  pre##_parser_get, pre##_parser_set, pre##_hook_add,   \
  pre##_brigade_limit_get, pre##_brigade_limit_set,     \
  pre##_read_limit_get,    pre##_read_limit_set,        \
  pre##_temp_dir_get,      pre##_temp_dir_set,          \
  }
 
 
APREQ_DECLARE(apreq_handle_t*) apreq_handle_cgi(apr_pool_t *pool);
 
APREQ_DECLARE(apreq_handle_t*) apreq_handle_custom(apr_pool_t *pool,
                                                   const char *query_string,
                                                   const char *cookie,
                                                   apreq_parser_t *parser,
                                                   apr_uint64_t read_limit,
                                                   apr_bucket_brigade *in);
 
APREQ_DECLARE(apreq_param_t *)apreq_param(apreq_handle_t *req, const char *key);
 
#define apreq_cookie(req, name) apreq_jar_get(req, name)
 
APREQ_DECLARE(apr_table_t *) apreq_params(apreq_handle_t *req, apr_pool_t *p);
 
 
APREQ_DECLARE(apr_table_t *)apreq_cookies(apreq_handle_t *req, apr_pool_t *p);
 
#ifdef __cplusplus
 }
#endif
 
#endif /* APREQ_MODULE_H */