src/rxv_spin.h

Go to the documentation of this file.

/*
 * rxv_spin.h
 *
 * Copyright (C) 2003 - 2008 Bojan Smojver
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 2.1 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef __RXV_SPIN_H__
#define __RXV_SPIN_H__

#define RXV_SPIN_STDC_HEADERS        1
#define RXV_SPIN_HAVE_UNISTD_H       1
#define RXV_SPIN_HAVE_SYS_TYPES_H    1
#define RXV_SPIN_HAVE_APR_STRINGS_H  1
#define RXV_SPIN_HAVE_APR_POOLS_H    1
#define RXV_SPIN_HAVE_APR_HASH_H     1
#define RXV_SPIN_HAVE_APR_TIME_H     1
#define RXV_SPIN_HAVE_APR_DSO_H      1
#define RXV_SPIN_HAVE_APR_BUCKETS_H  1
#define RXV_SPIN_HAVE_APR_DBD_H      1
#define RXV_SPIN_HAVE_APREQ_PARAM_H  1
#define RXV_SPIN_HAVE_APREQ_COOKIE_H 1
#define RXV_SPIN_HAVE_APREQ_MODULE_H 1
#define RXV_SPIN_HAVE_HTTPD_H        1
#define RXV_SPIN_HAVE_HTTP_REQUEST_H 1
#define RXV_SPIN_HAVE_AP_REGEX_H     1

#include <stdio.h>
#if RXV_SPIN_STDC_HEADERS
#include <stdlib.h>
#include <stddef.h>
#include <stdarg.h>
#include <string.h>
#endif
#if RXV_SPIN_HAVE_UNISTD_H
#include <unistd.h>
#endif
#if RXV_SPIN_HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif

#if RXV_SPIN_HAVE_APR_STRINGS_H
#include <apr_strings.h>
#endif
#if RXV_SPIN_HAVE_APR_POOLS_H
#include <apr_pools.h>
#endif
#if RXV_SPIN_HAVE_APR_HASH_H
#include <apr_hash.h>
#endif
#if RXV_SPIN_HAVE_APR_TIME_H
#include <apr_time.h>
#endif
#if RXV_SPIN_HAVE_APR_DSO_H
#include <apr_dso.h>
#endif
#if RXV_SPIN_HAVE_APR_BUCKETS_H
#include <apr_buckets.h>
#endif
#if RXV_SPIN_HAVE_APR_DBD_H
#include <apr_dbd.h>
#endif

#if RXV_SPIN_HAVE_APREQ_PARAM_H
#include <apreq_param.h>
#endif
#if RXV_SPIN_HAVE_APREQ_COOKIE_H
#include <apreq_cookie.h>
#endif
#if RXV_SPIN_HAVE_APREQ_MODULE_H
#include <apreq_module.h>
#endif

/* remove some macros, Apache defines them as well */
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#undef  PACKAGE_BUGREPORT
#undef  PACKAGE_NAME
#undef  PACKAGE_STRING
#undef  PACKAGE_TARNAME
#undef  PACKAGE_VERSION
#endif

#if RXV_SPIN_HAVE_HTTPD_H
#include <httpd.h>
#endif

/* remove Apache macros, restore good definitions */
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#undef  PACKAGE_BUGREPORT
#undef  PACKAGE_NAME
#undef  PACKAGE_STRING
#undef  PACKAGE_TARNAME
#undef  PACKAGE_VERSION
#define PACKAGE_BUGREPORT RXV_SPIN_PACKAGE_BUGREPORT
#define PACKAGE_NAME      RXV_SPIN_PACKAGE_NAME
#define PACKAGE_STRING    RXV_SPIN_PACKAGE_STRING
#define PACKAGE_TARNAME   RXV_SPIN_PACKAGE_TARNAME
#define PACKAGE_VERSION   RXV_SPIN_PACKAGE_VERSION
#endif

#if RXV_SPIN_HAVE_HTTP_REQUEST_H
#include <http_request.h>
#endif
#if RXV_SPIN_HAVE_AP_REGEX_H
#include <ap_regex.h>
#endif

typedef enum{
  RXV_SPIN_TRIM_LEFT=1, 
  RXV_SPIN_TRIM_RIGHT   
} rxv_spin_trim_e;

typedef struct rxv_spin_data rxv_spin_data_t; 
typedef struct rxv_spin_curs rxv_spin_curs_t; 
typedef struct rxv_spin_ctx rxv_spin_ctx_t; 
/* Data creation and manipulation functions */

rxv_spin_data_t *rxv_spin_datum(apr_pool_t *pool,const char *str,
                                rxv_spin_data_t *data);

rxv_spin_data_t *rxv_spin_mdatum(apr_pool_t *pool,const char *str,
                                 apr_size_t size,rxv_spin_data_t *data);

char *rxv_spin_string(rxv_spin_data_t *single);

apr_hash_t *rxv_spin_guts(rxv_spin_data_t *rows);

apr_size_t rxv_spin_size(rxv_spin_data_t *data);

#define rxv_spin_multi(d) (!rxv_spin_string(d) && rxv_spin_size(d)>0)

#define rxv_spin_single(d) (!rxv_spin_multi(d))

rxv_spin_data_t *rxv_spin_column(apr_pool_t *pool,const char *name,
                                 rxv_spin_data_t *data,...)
#if defined(__GNUC__) && __GNUC__ >= 4
  __attribute__((sentinel))
#endif
;

rxv_spin_data_t *rxv_spin_parse(apr_pool_t *pool,const char *name,
                                char *str,const char *sep,
                                rxv_spin_data_t *data);

rxv_spin_data_t *rxv_spin_array(apr_pool_t *pool,const char *name,
                                apr_array_header_t *arr,rxv_spin_data_t *data);

rxv_spin_data_t *rxv_spin_brigade(apr_pool_t *pool,const char *name,
                                  apr_bucket_brigade *bb,
                                  rxv_spin_data_t *data);

rxv_spin_data_t *rxv_spin_null(apr_pool_t *pool,const char *name,
                               apr_size_t size,rxv_spin_data_t *data);

rxv_spin_data_t *rxv_spin_rows(apr_pool_t *pool,rxv_spin_data_t *data,...)
#if defined(__GNUC__) && __GNUC__ >= 4
  __attribute__((sentinel))
#endif
;

apr_size_t rxv_spin_first(apr_pool_t *pool,rxv_spin_data_t *rows,...)
#if defined(__GNUC__) && __GNUC__ >= 4
  __attribute__((sentinel))
#endif
;

apr_size_t rxv_spin_next(rxv_spin_curs_t *curs);

rxv_spin_data_t *rxv_spin_this(rxv_spin_curs_t *curs);

rxv_spin_data_t *rxv_spin_entry(rxv_spin_data_t *rows,const char *name,
                                apr_size_t index);

rxv_spin_data_t *rxv_spin_resize(rxv_spin_data_t *data,apr_size_t size);

rxv_spin_data_t *rxv_spin_copy(apr_pool_t *pool,rxv_spin_data_t *src,
                               rxv_spin_data_t *data);

char *rxv_spin_slower(const char *str);

char *rxv_spin_supper(const char *str);

char *rxv_spin_strim(const char *str,rxv_spin_trim_e what);
#define rxv_spin_strim2(s) \
        rxv_spin_strim((s),(RXV_SPIN_TRIM_LEFT|RXV_SPIN_TRIM_RIGHT))

#define rxv_spin_striml(s) \
        rxv_spin_strim((s),(RXV_SPIN_TRIM_LEFT))

#define rxv_spin_strimr(s) \
        rxv_spin_strim((s),(RXV_SPIN_TRIM_RIGHT))

#define rxv_spin_lower(s)                                                   \
        ((s)?(rxv_spin_single(s)                                            \
              ?rxv_spin_datum(NULL,rxv_spin_slower(rxv_spin_string(s)),(s)) \
              :NULL)                                                        \
            :NULL)

#define rxv_spin_upper(s)                                                   \
        ((s)?(rxv_spin_single(s)                                            \
              ?rxv_spin_datum(NULL,rxv_spin_supper(rxv_spin_string(s)),(s)) \
              :NULL)                                                        \
            :NULL)

#define rxv_spin_trim(s,w)                                                     \
        ((s)?(rxv_spin_single(s)                                               \
              ?rxv_spin_datum(NULL,rxv_spin_strim(rxv_spin_string(s),(w)),(s)) \
              :NULL)                                                           \
            :NULL)

#define rxv_spin_trim2(s) \
        rxv_spin_trim((s),(RXV_SPIN_TRIM_LEFT|RXV_SPIN_TRIM_RIGHT))

#define rxv_spin_triml(s) \
        rxv_spin_trim((s),(RXV_SPIN_TRIM_LEFT))

#define rxv_spin_trimr(s) \
        rxv_spin_trim((s),(RXV_SPIN_TRIM_RIGHT))

/* Context functions and macros */

apr_pool_t *rxv_spin_pool(rxv_spin_ctx_t *ctx);

apr_pool_t *rxv_spin_ppool(rxv_spin_ctx_t *ctx);

rxv_spin_data_t *rxv_spin_data(rxv_spin_ctx_t *ctx);

request_rec *rxv_spin_r(rxv_spin_ctx_t *ctx);

apreq_handle_t *rxv_spin_req(rxv_spin_ctx_t *ctx);

void *rxv_spin_xget(rxv_spin_ctx_t *ctx);

void *rxv_spin_xset(rxv_spin_ctx_t *ctx,void *extra);

rxv_spin_data_t *rxv_spin_get(rxv_spin_ctx_t *ctx,const char *key);
#define rxv_spin_sget(ctx,key) \
        rxv_spin_string(rxv_spin_get((ctx),(key)))

rxv_spin_data_t *rxv_spin_set(rxv_spin_ctx_t *ctx,
                              const char *key,rxv_spin_data_t *value);
#define rxv_spin_sset(ctx,key,val) \
  rxv_spin_set((ctx),(key),rxv_spin_datum(rxv_spin_pool(ctx),(val),NULL))

#define rxv_spin_del(ctx,key) rxv_spin_set((ctx),(key),NULL)

/* Application/session functions */

rxv_spin_data_t *rxv_spin_app_get(rxv_spin_ctx_t *ctx,const char *key);
#define rxv_spin_app_sget(ctx,key) \
        rxv_spin_string(rxv_spin_app_get((ctx),(key)))

rxv_spin_data_t *rxv_spin_app_set(rxv_spin_ctx_t *ctx,
                                  const char *key,rxv_spin_data_t *val);
#define rxv_spin_app_sset(ctx,key,val) \
  rxv_spin_app_set((ctx),(key),rxv_spin_datum(rxv_spin_pool(ctx),(val),NULL))

apr_status_t rxv_spin_app_del(rxv_spin_ctx_t *ctx,const char *key);

rxv_spin_data_t *rxv_spin_ses_get(rxv_spin_ctx_t *ctx,const char *key);
#define rxv_spin_ses_sget(ctx,key) \
        rxv_spin_string(rxv_spin_ses_get((ctx),(key)))

rxv_spin_data_t *rxv_spin_ses_set(rxv_spin_ctx_t *ctx,
                                  const char *key,rxv_spin_data_t *val);
#define rxv_spin_ses_sset(ctx,key,val) \
  rxv_spin_ses_set((ctx),(key),rxv_spin_datum(rxv_spin_pool(ctx),(val),NULL))

apr_status_t rxv_spin_ses_del(rxv_spin_ctx_t *ctx,const char *key);

void rxv_spin_ses_kill(rxv_spin_ctx_t *ctx);

char *rxv_spin_ses_id(rxv_spin_ctx_t *ctx);

int rxv_spin_ses_valid(rxv_spin_ctx_t *ctx);

apr_time_t rxv_spin_ses_atime(rxv_spin_ctx_t *ctx);

typedef struct rxv_spin_db     rxv_spin_db_t;     
typedef struct rxv_spin_db_txn rxv_spin_db_txn_t; 
apr_pool_t *rxv_spin_db_pool(rxv_spin_db_t *db);

char *rxv_spin_db_cinfo(rxv_spin_db_t *db);

const apr_dbd_driver_t *rxv_spin_db_driver(rxv_spin_db_t *db);

apr_dbd_t *rxv_spin_db_handle(rxv_spin_db_t *db);

apr_dbd_transaction_t *rxv_spin_db_txn(rxv_spin_db_txn_t *txn);

rxv_spin_db_t *rxv_spin_db_open(rxv_spin_ctx_t *ctx,const char *conninfo);

apr_status_t rxv_spin_db_close(rxv_spin_ctx_t *ctx,rxv_spin_db_t *db);

apr_status_t rxv_spin_db_status(rxv_spin_ctx_t *ctx,rxv_spin_db_t *db);

rxv_spin_data_t *rxv_spin_db_data(apr_pool_t *pool,rxv_spin_db_t *db,
                                  apr_dbd_results_t *dbdres);

rxv_spin_data_t *rxv_spin_db_select(apr_pool_t *pool,rxv_spin_db_t *db,
                                    const char *query);

int rxv_spin_db_query(apr_pool_t *pool,rxv_spin_db_t *db,const char *query);

rxv_spin_data_t *rxv_spin_db_pselect(apr_pool_t *pool,rxv_spin_db_t *db,
                                     const char *query,...)
#if defined(__GNUC__) && __GNUC__ >= 4
  __attribute__((sentinel))
#endif
;

int rxv_spin_db_pquery(apr_pool_t *pool,rxv_spin_db_t *db,
                       const char *query,...)
#if defined(__GNUC__) && __GNUC__ >= 4
  __attribute__((sentinel))
#endif
;

rxv_spin_db_txn_t *rxv_spin_db_start(apr_pool_t *pool,rxv_spin_db_t *db);

apr_status_t rxv_spin_db_end(rxv_spin_db_txn_t *txn);

void *rxv_spin_conn_get(rxv_spin_ctx_t *ctx,const char *conninfo);

void *rxv_spin_conn_set(rxv_spin_ctx_t *ctx,
                        const char *conninfo,void *conn,
                        apr_status_t (*cleanup)(void *data));

typedef void (*rxv_spin_init_t)(rxv_spin_ctx_t *ctx);
typedef int (*rxv_spin_prepare_t)(rxv_spin_ctx_t *ctx);
typedef int (*rxv_spin_service_t)(rxv_spin_ctx_t *ctx);
/* DSO loading functions */

apr_status_t rxv_spin_dso_load(rxv_spin_ctx_t *ctx,const char *path,
                               apr_dso_handle_t **handle);

char *rxv_spin_hash(apr_pool_t *pool,const char *uniq);

char *rxv_spin_hmac(apr_pool_t *pool,const char *uniq,const char *salt);

#endif /* __RXV_SPIN_H__ */

---