granicus.if.org Git - apache/blob - modules/database/mod_dbd.c

   1 /* Copyright 2003-5 The Apache Software Foundation or its licensors, as
   2  * applicable.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /* Overview of what this is and does:
  18  * http://www.apache.org/~niq/dbd.html
  19  * or
  20  * http://apache.webthing.com/database/
  21  */
  22
  23 #include <ctype.h>
  24
  25 #include "http_protocol.h"
  26 #include "http_config.h"
  27 #include "http_log.h"
  28 #include "apr_reslist.h"
  29 #include "apr_strings.h"
  30 #include "apr_dbd.h"
  31 #include "mod_dbd.h"
  32
  33 extern module AP_MODULE_DECLARE_DATA dbd_module;
  34
  35 /************ svr cfg: manage db connection pool ****************/
  36
  37 typedef struct dbd_prepared {
  38     const char *label;
  39     const char *query;
  40     struct dbd_prepared *next;
  41 } dbd_prepared;
  42 typedef struct svr_cfg {
  43     const char *name;
  44     const char *params;
  45     int persist;
  46     dbd_prepared *prepared;
  47 #if APR_HAS_THREADS
  48     apr_reslist_t *dbpool;
  49     int nmin;
  50     int nkeep;
  51     int nmax;
  52     int exptime;
  53 #else
  54     ap_dbd_t *conn;
  55 #endif
  56 } svr_cfg;
  57
  58 typedef enum { cmd_name, cmd_params, cmd_persist,
  59                cmd_min, cmd_keep, cmd_max, cmd_exp
  60 } cmd_parts;
  61
  62
  63 #define ISINT(val) \
  64         for (p = val; *p; ++p)        \
  65                 if (!isdigit(*p))        \
  66                         return "Argument must be numeric!"
  67 static const char *dbd_param(cmd_parms *cmd, void *cfg, const char *val)
  68 {
  69     const char *p;
  70     const apr_dbd_driver_t *driver = NULL;
  71     svr_cfg *svr = (svr_cfg*) ap_get_module_config
  72         (cmd->server->module_config, &dbd_module);
  73
  74     switch ((long) cmd->info) {
  75     case cmd_name:
  76         svr->name = val;
  77         /* loading the driver involves once-only dlloading that is
  78          * best done at server startup.  This also guarantees that
  79          * we won't return an error later.
  80          */
  81         switch (apr_dbd_get_driver(cmd->pool, svr->name, &driver)) {
  82         case APR_ENOTIMPL:
  83             return apr_psprintf(cmd->pool, "DBD: No driver for %s", svr->name);
  84         case APR_EDSOOPEN:
  85             return apr_psprintf(cmd->pool,
  86                                 "DBD: Can't load driver file apr_dbd_%s.so",
  87                                 svr->name);
  88         case APR_ESYMNOTFOUND:
  89             return apr_psprintf(cmd->pool,
  90                                 "DBD: Failed to load driver apr_dbd_%s_driver",
  91                                 svr->name);
  92         }
  93         break;
  94     case cmd_params:
  95         svr->params = val;
  96         break;
  97     case cmd_persist:
  98         ISINT(val);
  99         svr->persist = atoi(val);
 100         break;
 101 #if APR_HAS_THREADS
 102     case cmd_min:
 103         ISINT(val);
 104         svr->nmin = atoi(val);
 105         break;
 106     case cmd_keep:
 107         ISINT(val);
 108         svr->nkeep = atoi(val);
 109         break;
 110     case cmd_max:
 111         ISINT(val);
 112         svr->nmax = atoi(val);
 113         break;
 114     case cmd_exp:
 115         ISINT(val);
 116         svr->exptime = atoi(val);
 117         break;
 118 #endif
 119     }
 120     return NULL;
 121 }
 122 AP_DECLARE(void) ap_dbd_prepare(server_rec *s, const char *query,
 123                                 const char *label)
 124 {
 125     svr_cfg *svr = ap_get_module_config(s->module_config, &dbd_module);
 126     dbd_prepared *prepared = apr_pcalloc(s->process->pool, sizeof(dbd_prepared));
 127     prepared->label = label;
 128     prepared->query = query;
 129     prepared->next = svr->prepared;
 130     svr->prepared = prepared;
 131 }
 132 static const char *dbd_prepare(cmd_parms *cmd, void *cfg, const char *query,
 133                                const char *label)
 134 {
 135     ap_dbd_prepare(cmd->server, query, label);
 136     return NULL;
 137 }
 138 static const command_rec dbd_cmds[] = {
 139     AP_INIT_TAKE1("DBDriver", dbd_param, (void*)cmd_name, RSRC_CONF,
 140                   "SQL Driver"),
 141     AP_INIT_TAKE1("DBDParams", dbd_param, (void*)cmd_params, RSRC_CONF,
 142                   "SQL Driver Params"),
 143     AP_INIT_TAKE1("DBDPersist", dbd_param, (void*)cmd_persist, RSRC_CONF,
 144                   "Use persistent connection/pool"),
 145     AP_INIT_TAKE2("DBDPrepareSQL", dbd_prepare, NULL, RSRC_CONF,
 146                   "Prepared SQL statement, label"),
 147 #if APR_HAS_THREADS
 148     AP_INIT_TAKE1("DBDMin", dbd_param, (void*)cmd_min, RSRC_CONF,
 149                   "Minimum number of connections"),
 150     AP_INIT_TAKE1("DBDKeep", dbd_param, (void*)cmd_keep, RSRC_CONF,
 151                   "Maximum number of sustained connections"),
 152     AP_INIT_TAKE1("DBDMax", dbd_param, (void*)cmd_max, RSRC_CONF,
 153                   "Maximum number of connections"),
 154     AP_INIT_TAKE1("DBDExptime", dbd_param, (void*)cmd_exp, RSRC_CONF,
 155                   "Keepalive time for idle connections"),
 156 #endif
 157     {NULL}
 158 };
 159 #define DEFAULT_NMIN 0
 160 #define DEFAULT_NMAX 5
 161 #define DEFAULT_NKEEP 1
 162 #define DEFAULT_EXPTIME 120
 163 #define COND_PARAM(x,val) \
 164     if (cfg->x == val) {              \
 165         cfg->x = ((svr_cfg*)base)->x; \
 166     }
 167 #define COND_PARAM0(x) COND_PARAM(x,0)
 168 #define COND_PARAM1(x) COND_PARAM(x,-1)
 169 static void *dbd_merge(apr_pool_t *pool, void *base, void *add) {
 170     svr_cfg *cfg = apr_pmemdup(pool, add, sizeof(svr_cfg));
 171     COND_PARAM0(name);
 172     COND_PARAM0(params);
 173     COND_PARAM1(persist);
 174 #if APR_HAS_THREADS
 175     COND_PARAM(nmin, DEFAULT_NMIN);
 176     COND_PARAM(nkeep, DEFAULT_NKEEP);
 177     COND_PARAM(nmax, DEFAULT_NMAX);
 178     COND_PARAM(exptime, DEFAULT_EXPTIME);
 179 #endif
 180     return cfg;
 181 }
 182 #undef COND_PARAM
 183 #undef COND_PARAM0
 184 #undef COND_PARAM1
 185 static void *dbd_cfg(apr_pool_t *p, server_rec *x)
 186 {
 187     svr_cfg *svr = (svr_cfg*) apr_pcalloc(p, sizeof(svr_cfg));
 188     svr->persist = -1;
 189     svr->name = svr->params = ""; /* don't risk segfault on misconfiguration */
 190 #if APR_HAS_THREADS
 191     svr->nmin = DEFAULT_NMIN;
 192     svr->nkeep = DEFAULT_NKEEP;
 193     svr->nmax = DEFAULT_NMAX;
 194     svr->exptime = DEFAULT_EXPTIME;
 195 #endif
 196     return svr;
 197 }
 198 static apr_status_t dbd_prepared_init(apr_pool_t *pool, svr_cfg *svr,
 199                                       ap_dbd_t *dbd)
 200 {
 201     dbd_prepared *p;
 202     apr_status_t ret = APR_SUCCESS;
 203     apr_dbd_prepared_t *stmt;
 204     dbd->prepared = apr_hash_make(pool);
 205
 206     for (p = svr->prepared; p; p = p->next) {
 207         stmt = NULL;
 208         if (apr_dbd_prepare(dbd->driver, pool, dbd->handle, p->query,
 209                             p->label, &stmt) == 0) {
 210             apr_hash_set(dbd->prepared, p->label, APR_HASH_KEY_STRING, stmt);
 211         }
 212         else {
 213             ret = APR_EGENERAL;
 214         }
 215     }
 216     return ret;
 217 }
 218 /************ svr cfg: manage db connection pool ****************/
 219 /* an apr_reslist_constructor for SQL connections
 220  * Also use this for opening in non-reslist modes, since it gives
 221  * us all the error-handling in one place.
 222  */
 223 static apr_status_t dbd_construct(void **db, void *params, apr_pool_t *pool)
 224 {
 225     svr_cfg *svr = (svr_cfg*) params;
 226     ap_dbd_t *rec = apr_pcalloc(pool, sizeof(ap_dbd_t));
 227     apr_status_t rv = apr_dbd_get_driver(pool, svr->name, &rec->driver);
 228
 229 /* Error-checking get_driver isn't necessary now (because it's done at
 230  * config-time).  But in case that changes in future ...
 231  */
 232     switch (rv) {
 233     case APR_ENOTIMPL:
 234         ap_log_perror(APLOG_MARK, APLOG_CRIT, 0, pool,
 235                       "DBD: driver for %s not available", svr->name);
 236         return rv;
 237     case APR_EDSOOPEN:
 238         ap_log_perror(APLOG_MARK, APLOG_CRIT, 0, pool,
 239                       "DBD: can't find driver for %s", svr->name);
 240         return rv;
 241     case APR_ESYMNOTFOUND:
 242         ap_log_perror(APLOG_MARK, APLOG_CRIT, 0, pool,
 243                       "DBD: driver for %s is invalid or corrupted", svr->name);
 244         return rv;
 245     default:
 246         ap_log_perror(APLOG_MARK, APLOG_CRIT, 0, pool,
 247                       "DBD: mod_dbd not compatible with apr in get_driver");
 248         return rv;
 249     case APR_SUCCESS:
 250         break;
 251     }
 252
 253     rv = apr_dbd_open(rec->driver, pool, svr->params, &rec->handle);
 254     switch (rv) {
 255     case APR_EGENERAL:
 256         ap_log_perror(APLOG_MARK, APLOG_CRIT, 0, pool,
 257                       "DBD: Can't connect to %s[%s]", svr->name, svr->params);
 258         return rv;
 259     default:
 260         ap_log_perror(APLOG_MARK, APLOG_CRIT, 0, pool,
 261                       "DBD: mod_dbd not compatible with apr in open");
 262         return rv;
 263     case APR_SUCCESS:
 264         break;
 265     }
 266     *db = rec;
 267     rv = dbd_prepared_init(pool, svr, rec);
 268     return rv;
 269 }
 270 #if APR_HAS_THREADS
 271 static apr_status_t dbd_destruct(void *sql, void *params, apr_pool_t *pool)
 272 {
 273     ap_dbd_t *rec = sql;
 274     return apr_dbd_close(rec->driver, rec->handle);
 275 }
 276
 277 static apr_status_t dbd_setup(apr_pool_t *pool, server_rec *s)
 278 {
 279     svr_cfg *svr = ap_get_module_config(s->module_config, &dbd_module);
 280     apr_status_t rv = apr_reslist_create(&svr->dbpool, svr->nmin, svr->nkeep,
 281                                          svr->nmax, svr->exptime,
 282                                          dbd_construct, dbd_destruct,
 283                                          svr, pool);
 284     if (rv == APR_SUCCESS) {
 285         apr_pool_cleanup_register(pool, svr->dbpool,
 286                                   (void*)apr_reslist_destroy,
 287                                   apr_pool_cleanup_null);
 288     }
 289     else {
 290         ap_log_perror(APLOG_MARK, APLOG_CRIT, 0, pool,
 291                       "DBD Pool: failed to initialise");
 292     }
 293     return rv;
 294 }
 295
 296 #endif
 297
 298
 299 /* Functions we export for modules to use:
 300         - open acquires a connection from the pool (opens one if necessary)
 301         - close releases it back in to the pool
 302 */
 303 AP_DECLARE(void) ap_dbd_close(server_rec *s, ap_dbd_t *sql)
 304 {
 305     svr_cfg *svr = ap_get_module_config(s->module_config, &dbd_module);
 306     if (!svr->persist) {
 307         apr_dbd_close(sql->driver, sql->handle);
 308     }
 309 #if APR_HAS_THREADS
 310     else {
 311         apr_reslist_release(svr->dbpool, sql);
 312     }
 313 #endif
 314 }
 315 static apr_status_t dbd_close(void *CONN)
 316 {
 317     ap_dbd_t *conn = CONN;
 318     return apr_dbd_close(conn->driver, conn->handle);
 319 }
 320 #define arec ((ap_dbd_t*)rec)
 321 #if APR_HAS_THREADS
 322 AP_DECLARE(ap_dbd_t*) ap_dbd_open(apr_pool_t *pool, server_rec *s)
 323 {
 324     void *rec = NULL;
 325     svr_cfg *svr = ap_get_module_config(s->module_config, &dbd_module);
 326     apr_status_t rv = APR_SUCCESS;
 327     const char *errmsg;
 328
 329     if (!svr->persist) {
 330         /* Return a once-only connection */
 331         rv = dbd_construct(&rec, svr, s->process->pool);
 332         return (rv == APR_SUCCESS) ? arec : NULL;
 333     }
 334
 335     if (!svr->dbpool) {
 336         if (dbd_setup(s->process->pool, s) != APR_SUCCESS) {
 337             return NULL;
 338         }
 339     }
 340     if (apr_reslist_acquire(svr->dbpool, &rec) != APR_SUCCESS) {
 341         ap_log_perror(APLOG_MARK, APLOG_ERR, 0, pool,
 342                       "Failed to acquire DBD connection from pool!");
 343         return NULL;
 344     }
 345     rv = apr_dbd_check_conn(arec->driver, pool, arec->handle);
 346     if ((rv != APR_SUCCESS) && (rv != APR_ENOTIMPL)) {
 347         errmsg = apr_dbd_error(arec->driver, arec->handle, rv);
 348         if (!errmsg) {
 349             errmsg = "(unknown)";
 350         }
 351         ap_log_perror(APLOG_MARK, APLOG_ERR, 0, pool,
 352                       "DBD[%s] Error: %s", svr->name, errmsg );
 353         apr_reslist_invalidate(svr->dbpool, rec);
 354         return NULL;
 355     }
 356     return arec;
 357 }
 358 #else
 359 AP_DECLARE(ap_dbd_t*) ap_dbd_open(apr_pool_t *pool, server_rec *s)
 360 {
 361     apr_status_t rv = APR_SUCCESS;
 362     const char *errmsg;
 363     void *rec = NULL;
 364     svr_cfg *svr = ap_get_module_config(s->module_config, &dbd_module);
 365
 366     if (!svr->persist) {
 367         /* Return a once-only connection */
 368         rv = dbd_construct(&rec, svr, s->process->pool);
 369         return (rv == APR_SUCCESS) ? arec : NULL;
 370     }
 371
 372 /* since we're in nothread-land, we can mess with svr->conn with impunity */
 373 /* If we have a persistent connection and it's good, we'll use it */
 374     if (svr->conn) {
 375         rv = apr_dbd_check_conn(svr->conn->driver, pool, svr->conn->handle);
 376         if ((rv != APR_SUCCESS) && (rv != APR_ENOTIMPL)) {
 377             errmsg = apr_dbd_error(arec->driver, arec->handle, rv);
 378             if (!errmsg) {
 379                 errmsg = "(unknown)";
 380             }
 381             ap_log_perror(APLOG_MARK, APLOG_ERR, 0, pool,
 382                           "DBD[%s] Error: %s", svr->name, errmsg);
 383             svr->conn = NULL;
 384         }
 385     }
 386 /* We don't have a connection right now, so we'll open one */
 387     if (!svr->conn) {
 388         if (dbd_construct(&rec, svr, s->process->pool) == APR_SUCCESS) {
 389             svr->conn = arec ;
 390             apr_pool_cleanup_register(s->process->pool, svr->conn,
 391                                       dbd_close, apr_pool_cleanup_null);
 392         }
 393     }
 394     return svr->conn;
 395 }
 396 #endif
 397 #if APR_HAS_THREADS
 398 typedef struct {
 399     ap_dbd_t *conn;
 400     apr_reslist_t *dbpool;
 401 } dbd_pool_rec;
 402 static apr_status_t dbd_release(void *REQ)
 403 {
 404     dbd_pool_rec *req = REQ;
 405     apr_reslist_release(req->dbpool, req->conn);
 406     return APR_SUCCESS;
 407 }
 408 AP_DECLARE(ap_dbd_t *) ap_dbd_acquire(request_rec *r)
 409 {
 410     svr_cfg *svr;
 411     dbd_pool_rec *req = ap_get_module_config(r->request_config, &dbd_module);
 412     if (!req) {
 413         req = apr_palloc(r->pool, sizeof(dbd_pool_rec));
 414         req->conn = ap_dbd_open(r->pool, r->server);
 415         if (req->conn) {
 416             svr = ap_get_module_config(r->server->module_config, &dbd_module);
 417             ap_set_module_config(r->request_config, &dbd_module, req);
 418             if (svr->persist) {
 419                 req->dbpool = svr->dbpool;
 420                 apr_pool_cleanup_register(r->pool, req, dbd_release,
 421                                           apr_pool_cleanup_null);
 422             }
 423             else {
 424                 apr_pool_cleanup_register(r->pool, req->conn, dbd_close,
 425                                           apr_pool_cleanup_null);
 426             }
 427         }
 428     }
 429     return req->conn;
 430 }
 431 AP_DECLARE(ap_dbd_t *) ap_dbd_cacquire(conn_rec *c)
 432 {
 433     svr_cfg *svr;
 434     dbd_pool_rec *req = ap_get_module_config(c->conn_config, &dbd_module);
 435     if (!req) {
 436         req = apr_palloc(c->pool, sizeof(dbd_pool_rec));
 437         req->conn = ap_dbd_open(c->pool, c->base_server);
 438         if (req->conn) {
 439             svr = ap_get_module_config(c->base_server->module_config, &dbd_module);
 440             ap_set_module_config(c->conn_config, &dbd_module, req);
 441             if (svr->persist) {
 442                 req->dbpool = svr->dbpool;
 443                 apr_pool_cleanup_register(c->pool, req, dbd_release,
 444                                           apr_pool_cleanup_null);
 445             }
 446             else {
 447                 apr_pool_cleanup_register(c->pool, req->conn, dbd_close,
 448                                           apr_pool_cleanup_null);
 449             }
 450         }
 451     }
 452     return req->conn;
 453 }
 454 #else
 455 AP_DECLARE(ap_dbd_t *) ap_dbd_acquire(request_rec *r)
 456 {
 457     svr_cfg *svr;
 458     ap_dbd_t *ret = ap_get_module_config(r->request_config, &dbd_module);
 459     if (!ret) {
 460         svr = ap_get_module_config(r->server->module_config, &dbd_module);
 461         ret = ap_dbd_open(r->pool, r->server);
 462         if (ret) {
 463             ap_set_module_config(r->request_config, &dbd_module, ret);
 464             if (!svr->persist) {
 465                 apr_pool_cleanup_register(r->pool, svr->conn, dbd_close,
 466                                           apr_pool_cleanup_null);
 467             }
 468             /* if persist then dbd_open registered cleanup on proc pool */
 469         }
 470     }
 471     return ret;
 472 }
 473 AP_DECLARE(ap_dbd_t *) ap_dbd_cacquire(conn_rec *c)
 474 {
 475     svr_cfg *svr;
 476     ap_dbd_t *ret = ap_get_module_config(c->conn_config, &dbd_module);
 477     if (!ret) {
 478         svr = ap_get_module_config(c->base_server->module_config, &dbd_module);
 479         ret = ap_dbd_open(c->pool, c->base_server);
 480         if (ret) {
 481             ap_set_module_config(c->conn_config, &dbd_module, ret);
 482             if (!svr->persist) {
 483                 apr_pool_cleanup_register(c->pool, svr->conn, dbd_close,
 484                                           apr_pool_cleanup_null);
 485             }
 486             /* if persist then dbd_open registered cleanup on proc pool */
 487         }
 488     }
 489     return ret;
 490 }
 491 #endif
 492
 493 static void dbd_hooks(apr_pool_t *pool)
 494 {
 495 #if APR_HAS_THREADS
 496     ap_hook_child_init((void*)dbd_setup, NULL, NULL, APR_HOOK_MIDDLE);
 497 #endif
 498     APR_REGISTER_OPTIONAL_FN(ap_dbd_open);
 499     APR_REGISTER_OPTIONAL_FN(ap_dbd_close);
 500     APR_REGISTER_OPTIONAL_FN(ap_dbd_acquire);
 501     APR_REGISTER_OPTIONAL_FN(ap_dbd_cacquire);
 502     APR_REGISTER_OPTIONAL_FN(ap_dbd_prepare);
 503     apr_dbd_init(pool);
 504 }
 505
 506 module AP_MODULE_DECLARE_DATA dbd_module = {
 507     STANDARD20_MODULE_STUFF,
 508     NULL,
 509     NULL,
 510     dbd_cfg,
 511     dbd_merge,
 512     dbd_cmds,
 513     dbd_hooks
 514 };