aolserver/nsdb/dbinit.c

/*
 * The contents of this file are subject to the AOLserver Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://aolserver.com/.
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is AOLserver Code and related documentation
 * distributed by AOL.
 * 
 * The Initial Developer of the Original Code is America Online,
 * Inc. Portions created by AOL are Copyright (C) 1999 America Online,
 * Inc. All Rights Reserved.
 *
 * Alternatively, the contents of this file may be used under the terms
 * of the GNU General Public License (the "GPL"), in which case the
 * provisions of GPL are applicable instead of those above.  If you wish
 * to allow use of your version of this file only under the terms of the
 * GPL and not to allow others to use your version of this file under the
 * License, indicate your decision by deleting the provisions above and
 * replace them with the notice and other provisions required by the GPL.
 * If you do not delete the provisions above, a recipient may use your
 * version of this file under either the License or the GPL.
 */


/* 
 * dbinit.c --
 *
 *      This file contains routines for creating and accessing
 *      pools of database handles.
 */

static const char *RCSID = "@(#) $Header: /cvsroot-fuse/aolserver/aolserver/nsdb/dbinit.c,v 1.5 2004/02/05 17:50:53 dossy Exp $, compiled: " __DATE__ " " __TIME__;

#include "db.h"

/*
 * The following structure defines a database pool.
 */

struct Handle;

typedef struct Pool {
    char           *name;
    char           *desc;
    char           *source;
    char           *user;
    char           *pass;
    int             type;
    Ns_Mutex        lock;
    Ns_Cond         waitCond;
    Ns_Cond         getCond;
    char           *driver;
    struct DbDriver  *driverPtr;
    int             waiting;
    int             nhandles;
    struct Handle  *firstPtr;
    struct Handle  *lastPtr;
    int             fVerbose;
    int             fVerboseError;
    time_t          maxidle;
    time_t          maxopen;
    int             stale_on_close;
}               Pool;

/*
 * The following structure defines the internal
 * state of a database handle.
 */

typedef struct Handle {
    char           *driver;
    char           *datasource;
    char           *user;
    char           *password;
    void           *connection;
    char           *poolname;
    int             connected;
    int             verbose;
    Ns_Set         *row;
    char            cExceptionCode[6];
    Ns_DString      dsExceptionMsg;
    void           *context;
    void           *statement;
    int             fetchingRows;
    /* Members above must match Ns_DbHandle */
    struct Handle  *nextPtr;
    struct Pool    *poolPtr;
    time_t          otime;
    time_t          atime;
    int             stale;
    int             stale_on_close;
}               Handle;

/*
 * The following structure maintains per-server data.
 */

typedef struct ServData {
    char *defpool;
    char *allowed;
} ServData;

/*
 * Local functions defined in this file
 */

static Pool    *<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_GetPool">GetPool</a>(char *pool);
static void     <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_ReturnHandle">ReturnHandle</a>(Handle * handle);
static int      <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_IsStale">IsStale</a>(Handle *, time_t now);
static int      <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Connect">Connect</a>(Handle *);
static Pool    *<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CreatePool">CreatePool</a>(char *pool, char *path, char *driver);
static int      <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_IncrCount">IncrCount</a>(Pool *poolPtr, int incr);
static ServData *<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_GetServer">GetServer</a>(char *server);
static Ns_TlsCleanup <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_FreeTable">FreeTable</a>;
static Ns_Callback <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CheckPool">CheckPool</a>;
static Ns_ArgProc <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CheckArgProc">CheckArgProc</a>;

/*
 * Static variables defined in this file
 */

static Tcl_HashTable poolsTable;
static Tcl_HashTable serversTable;
static Ns_Tls tls;


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolDescription">Ns_DbPoolDescription</a> --
 *
 *      Return the pool's description string.
 *
 * Results:
 *      Configured description string or NULL.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

char *
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolDescription">Ns_DbPoolDescription</a>(char *pool)
{
    Pool         *poolPtr;

    poolPtr = <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_GetPool">GetPool</a>(pool);
    if (poolPtr == NULL) {
        return NULL;
    }
    return poolPtr->desc;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolDefault">Ns_DbPoolDefault</a> --
 *
 *      Return the default pool.
 *
 * Results:
 *      String name of default pool or NULL if no default is defined.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

char *
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolDefault">Ns_DbPoolDefault</a>(char *server)
{
    ServData *sdataPtr = <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_GetServer">GetServer</a>(server);

    return (sdataPtr ? sdataPtr->defpool : NULL);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolList">Ns_DbPoolList</a> --
 *
 *      Return the list of all pools.
 *
 * Results:
 *      Double-null terminated list of pool names.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

char *
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolList">Ns_DbPoolList</a>(char *server)
{
    ServData *sdataPtr = <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_GetServer">GetServer</a>(server);

    return (sdataPtr ? sdataPtr->allowed : NULL);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolAllowable">Ns_DbPoolAllowable</a> --
 *
 *      Check that access is allowed to a pool.
 *
 * Results:
 *      NS_TRUE if allowed, NS_FALSE otherwise.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

int
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolAllowable">Ns_DbPoolAllowable</a>(char *server, char *pool)
{
    register char *p;

    p = <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolList">Ns_DbPoolList</a>(server);
    if (p != NULL) {
        while (*p != '\0') {
            if (STREQ(pool, p)) {
                return NS_TRUE;
            }
            p = p + strlen(p) + 1;
        }
    }
    return NS_FALSE;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolPutHandle">Ns_DbPoolPutHandle</a> --
 *
 *      Cleanup and then return a handle to its pool.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Handle is flushed, reset, and possibly closed as required.
 *
 *----------------------------------------------------------------------
 */

void
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolPutHandle">Ns_DbPoolPutHandle</a>(Ns_DbHandle *handle)
{
    Handle      *handlePtr;
    Pool        *poolPtr;
    time_t       now;

    handlePtr = (Handle *) handle;
    poolPtr = handlePtr->poolPtr;

    /*
     * Cleanup the handle.
     */

    <a href="/cvs/aolserver/aolserver/nsdb/dbdrv.c#A_Ns_DbFlush">Ns_DbFlush</a>(handle);
    <a href="/cvs/aolserver/aolserver/nsdb/dbdrv.c#A_Ns_DbResetHandle">Ns_DbResetHandle</a>(handle);

    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringFree">Ns_DStringFree</a>(&handle->dsExceptionMsg);
    handle->cExceptionCode[0] = '\0';

    /*
     * Close the handle if it's stale, otherwise update
     * the last access time.
     */

    time(&now);
    if (<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_IsStale">IsStale</a>(handlePtr, now)) {
        <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_NsDbDisconnect">NsDbDisconnect</a>(handle);
    } else {
        handlePtr->atime = now;
    }
    <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_IncrCount">IncrCount</a>(poolPtr, -1);
    Ns_MutexLock(&poolPtr->lock);
    <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_ReturnHandle">ReturnHandle</a>(handlePtr);
    if (poolPtr->waiting) {
        Ns_CondSignal(&poolPtr->getCond);
    }
    Ns_MutexUnlock(&poolPtr->lock);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolTimedGetHandle">Ns_DbPoolTimedGetHandle</a> --
 *
 *      Return a single handle from a pool within the given number of
 *      seconds.
 *
 * Results:
 *      Pointer to Ns_DbHandle or NULL on error or timeout.
 *
 * Side effects:
 *      Database may be opened if needed.
 *
 *----------------------------------------------------------------------
 */

Ns_DbHandle *
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolTimedGetHandle">Ns_DbPoolTimedGetHandle</a>(char *pool, int wait)
{
    Ns_DbHandle       *handle;

    if (<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolTimedGetMultipleHandles">Ns_DbPoolTimedGetMultipleHandles</a>(&handle, pool, 1, wait) != NS_OK) {
        return NULL;
    }
    return handle;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolGetHandle">Ns_DbPoolGetHandle</a> --
 *
 *      Return a single handle from a pool.
 *
 * Results:
 *      Pointer to Ns_DbHandle or NULL on error.
 *
 * Side effects:
 *      Database may be opened if needed.
 *
 *----------------------------------------------------------------------
 */

Ns_DbHandle *
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolGetHandle">Ns_DbPoolGetHandle</a>(char *pool)
{
    return <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolTimedGetHandle">Ns_DbPoolTimedGetHandle</a>(pool, 0);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolGetMultipleHandles">Ns_DbPoolGetMultipleHandles</a> --
 *
 *      Return 1 or more handles from a pool.
 *
 * Results:
 *      NS_OK if handles were allocated, NS_ERROR otherwise.
 *
 * Side effects:
 *      Given array of handles is updated with pointers to allocated
 *      handles.  Also, database may be opened if needed.
 *
 *----------------------------------------------------------------------
 */

int
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolGetMultipleHandles">Ns_DbPoolGetMultipleHandles</a>(Ns_DbHandle **handles, char *pool, int nwant)
{
    return <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolTimedGetMultipleHandles">Ns_DbPoolTimedGetMultipleHandles</a>(handles, pool, nwant, 0);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolTimedGetMultipleHandles">Ns_DbPoolTimedGetMultipleHandles</a> --
 *
 *      Return 1 or more handles from a pool within the given number
 *      of seconds.
 *
 * Results:
 *      NS_OK if the handlers where allocated, NS_TIMEOUT if the
 *      thread could not wait long enough for the handles, NS_ERROR
 *      otherwise.
 *
 * Side effects:
 *      Given array of handles is updated with pointers to allocated
 *      handles.  Also, database may be opened if needed.
 *
 *----------------------------------------------------------------------
 */

int
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbPoolTimedGetMultipleHandles">Ns_DbPoolTimedGetMultipleHandles</a>(Ns_DbHandle **handles, char *pool, 
                                 int nwant, int wait)
{
    Handle    *handlePtr;
    Handle   **handlesPtrPtr = (Handle **) handles;
    Pool      *poolPtr;
    Ns_Time    timeout, *timePtr;
    int        i, ngot, status;

    /*
     * Verify the pool, the number of available handles in the pool,
     * and that the calling thread does not already own handles from
     * this pool.
     */
     
    poolPtr = <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_GetPool">GetPool</a>(pool);
    if (poolPtr == NULL) {
        <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "dbinit: no such pool '%s'", pool);
        return NS_ERROR;
    }
    if (poolPtr->nhandles < nwant) {
        <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "dbinit: "
               "failed to get %d handles from a db pool of only %d handles: '%s'",
               nwant, poolPtr->nhandles, pool);
        return NS_ERROR;
    }
    ngot = <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_IncrCount">IncrCount</a>(poolPtr, nwant);
    if (ngot > 0) {
        <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "dbinit: db handle limit exceeded: "
               "thread already owns %d handle%s from pool '%s'",
               ngot, ngot == 1 ? "" : "s", pool);
        <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_IncrCount">IncrCount</a>(poolPtr, -nwant);
        return NS_ERROR;
    }
    
    /*
     * Wait until this thread can be the exclusive thread aquireing
     * handles and then wait until all requested handles are available,
     * watching for timeout in either of these waits.
     */
     
    if (wait < 0) {
        timePtr = NULL;
    } else {
        Ns_GetTime(&timeout);
        Ns_IncrTime(&timeout, wait, 0);
        timePtr = &timeout;
    }
    status = NS_OK;
    Ns_MutexLock(&poolPtr->lock);
    while (status == NS_OK && poolPtr->waiting) {
        status = Ns_CondTimedWait(&poolPtr->waitCond, &poolPtr->lock, timePtr);
    }
    if (status == NS_OK) {
        poolPtr->waiting = 1;
        while (status == NS_OK && ngot < nwant) {
            while (status == NS_OK && poolPtr->firstPtr == NULL) {
                status = Ns_CondTimedWait(&poolPtr->getCond, &poolPtr->lock,
                                          timePtr);
            }
            if (poolPtr->firstPtr != NULL) {
                handlePtr = poolPtr->firstPtr;
                poolPtr->firstPtr = handlePtr->nextPtr;
                handlePtr->nextPtr = NULL;
                if (poolPtr->lastPtr == handlePtr) {
                    poolPtr->lastPtr = NULL;
                }
                handlesPtrPtr[ngot++] = handlePtr;
            }
        }
        poolPtr->waiting = 0;
        Ns_CondSignal(&poolPtr->waitCond);
    }
    Ns_MutexUnlock(&poolPtr->lock);

    /*
     * Handle special race condition where the final requested handle
     * arrived just as the condition wait was timing out.
     */

    if (status == NS_TIMEOUT && ngot == nwant) {
        status = NS_OK;
    }

    /*
     * If status is still ok, connect any handles not already connected,
     * otherwise return any allocated handles back to the pool, then
     * update the final number of handles owned by this thread.
     */

    for (i = 0; status == NS_OK && i < ngot; ++i) {
        handlePtr = handlesPtrPtr[i];
        if (handlePtr->connected == NS_FALSE) {
            status = <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Connect">Connect</a>(handlePtr);
        }
    }
    if (status != NS_OK) {
        Ns_MutexLock(&poolPtr->lock);
        while (ngot > 0) {
            <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_ReturnHandle">ReturnHandle</a>(handlesPtrPtr[--ngot]);
        }
        if (poolPtr->waiting) {
            Ns_CondSignal(&poolPtr->getCond);
        }
        Ns_MutexUnlock(&poolPtr->lock);
        <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_IncrCount">IncrCount</a>(poolPtr, -nwant);
    }
    return status;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbBouncePool">Ns_DbBouncePool</a> --
 *
 *      Close all handles in the pool.
 *
 * Results:
 *      NS_OK if pool was bounce, NS_ERROR otherwise.
 *
 * Side effects:
 *      Handles are all marked stale and then closed by <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CheckPool">CheckPool</a>.
 *
 *----------------------------------------------------------------------
 */

int
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Ns_DbBouncePool">Ns_DbBouncePool</a>(char *pool)
{
    Pool        *poolPtr;
    Handle      *handlePtr;
    
    poolPtr = <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_GetPool">GetPool</a>(pool);
    if (poolPtr == NULL) {
        return NS_ERROR;
    }
    Ns_MutexLock(&poolPtr->lock);
    poolPtr->stale_on_close++;
    handlePtr = poolPtr->firstPtr;
    while (handlePtr != NULL) {
        if (handlePtr->connected) {
            handlePtr->stale = 1;
        }
        handlePtr->stale_on_close = poolPtr->stale_on_close;
        handlePtr = handlePtr->nextPtr;
    }
    Ns_MutexUnlock(&poolPtr->lock);
    <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CheckPool">CheckPool</a>(poolPtr);

    return NS_OK;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_NsDbInitPools">NsDbInitPools</a> --
 *
 *      Initialize the database pools at startup.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Pools may be created as configured.
 *
 *----------------------------------------------------------------------
 */

void
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_NsDbInitPools">NsDbInitPools</a>(void)
{
    Tcl_HashEntry  *hPtr;
    Pool           *poolPtr;
    Ns_Set         *pools;
    char           *path, *pool, *driver;
    int             new, i;

    Ns_TlsAlloc(&tls, <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_FreeTable">FreeTable</a>);

    /*
     * Attempt to create each database pool.
     */

    Tcl_InitHashTable(&serversTable, TCL_STRING_KEYS);
    Tcl_InitHashTable(&poolsTable, TCL_STRING_KEYS);
    pools = <a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetSection">Ns_ConfigGetSection</a>("ns/db/pools");
    for (i = 0; pools != NULL && i < Ns_SetSize(pools); ++i) {
        pool = Ns_SetKey(pools, i);
        hPtr = Tcl_CreateHashEntry(&poolsTable, pool, &new);
        if (!new) {
            <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "dbinit: duplicate pool: %s", pool);
            continue;   
        }
        path = <a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetPath">Ns_ConfigGetPath</a>(NULL, NULL, "db", "pool", pool, NULL);
        driver = <a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetValue">Ns_ConfigGetValue</a>(path, "driver");
        poolPtr = <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CreatePool">CreatePool</a>(pool, path, driver);
        if (poolPtr == NULL) {
            Tcl_DeleteHashEntry(hPtr);
        } else {
            Tcl_SetHashValue(hPtr, poolPtr);
        }
    }
    <a href="/cvs/aolserver/aolserver/nsd/proc.c#A_Ns_RegisterProcInfo">Ns_RegisterProcInfo</a>(<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CheckPool">CheckPool</a>, "nsdb:check", <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CheckArgProc">CheckArgProc</a>);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_NsDbInitServer">NsDbInitServer</a> --
 *
 *      Initialize a virtual server allowed and default options.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

void
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_NsDbInitServer">NsDbInitServer</a>(char *server)
{
    Pool           *poolPtr;
    ServData       *sdataPtr;
    Tcl_HashEntry  *hPtr;
    Tcl_HashSearch  search;
    char           *path, *pool, *p;
    Ns_DString      ds;
    int             new;

    path = <a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetPath">Ns_ConfigGetPath</a>(server, NULL, "db", NULL);

    /*
     * Verify the default pool exists, if any.
     */

    sdataPtr = ns_malloc(sizeof(ServData));
    hPtr = Tcl_CreateHashEntry(&serversTable, server, &new);
    Tcl_SetHashValue(hPtr, sdataPtr);
    sdataPtr->defpool = <a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetValue">Ns_ConfigGetValue</a>(path, "defaultpool");
    if (sdataPtr->defpool != NULL &&
        (Tcl_FindHashEntry(&poolsTable, sdataPtr->defpool) == NULL)) {
        <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "dbinit: no such default pool '%s'", sdataPtr->defpool);
        sdataPtr->defpool = NULL;
    }

    /*
     * Construct the allowed list and call the server-specific init.
     */

    sdataPtr->allowed = "";
    pool = <a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetValue">Ns_ConfigGetValue</a>(path, "pools");
    if (pool != NULL && poolsTable.numEntries > 0) {
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringInit">Ns_DStringInit</a>(&ds);
        if (STREQ(pool, "*")) {
            hPtr = Tcl_FirstHashEntry(&poolsTable, &search);
            while (hPtr != NULL) {
                poolPtr = Tcl_GetHashValue(hPtr);
                <a href="/cvs/aolserver/aolserver/nsdb/dbdrv.c#A_NsDbDriverInit">NsDbDriverInit</a>(server, poolPtr->driverPtr);
                <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppendArg">Ns_DStringAppendArg</a>(&ds, poolPtr->name);
                hPtr = Tcl_NextHashEntry(&search);
            }
        } else {
            p = pool;
            while (p != NULL && *p != '\0') {
                p = strchr(pool, ',');
                if (p != NULL) {
                    *p = '\0';
                }
                hPtr = Tcl_FindHashEntry(&poolsTable, pool);
                if (hPtr != NULL) {
                    poolPtr = Tcl_GetHashValue(hPtr);
                    <a href="/cvs/aolserver/aolserver/nsdb/dbdrv.c#A_NsDbDriverInit">NsDbDriverInit</a>(server, poolPtr->driverPtr);
                    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppendArg">Ns_DStringAppendArg</a>(&ds, poolPtr->name);
                }
                if (p != NULL) {
                    *p++ = ',';
                }
                pool = p;
            }
        }
        sdataPtr->allowed = ns_malloc((size_t)(ds.length + 1));
        memcpy(sdataPtr->allowed, ds.string, (size_t)(ds.length + 1));
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringFree">Ns_DStringFree</a>(&ds);
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_NsDbDisconnect">NsDbDisconnect</a> --
 *
 *      Disconnect a handle by closing the database if needed.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

void
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_NsDbDisconnect">NsDbDisconnect</a>(Ns_DbHandle *handle)
{
    Handle *handlePtr = (Handle *) handle;

    <a href="/cvs/aolserver/aolserver/nsdb/dbdrv.c#A_NsDbClose">NsDbClose</a>(handle);
    handlePtr->connected = NS_FALSE;
    handlePtr->atime = handlePtr->otime = 0;
    handlePtr->stale = NS_FALSE;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_NsDbLogSql">NsDbLogSql</a> --
 *
 *      <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> a SQL statement depending on the verbose state of the
 *      handle.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

void
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_NsDbLogSql">NsDbLogSql</a>(Ns_DbHandle *handle, char *sql)
{
    Handle *handlePtr = (Handle *) handle;

    if (handle->dsExceptionMsg.length > 0) {
        if (handlePtr->poolPtr->fVerboseError || handle->verbose) {
            
            <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "dbinit: error(%s,%s): '%s'",
                   handle->datasource, handle->dsExceptionMsg.string, sql);
        }
    } else if (handle->verbose) {
        <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Notice, "dbinit: sql(%s): '%s'", handle->datasource, sql);
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_NsDbGetDriver">NsDbGetDriver</a> --
 *
 *      Return a pointer to the driver structure for a handle.
 *
 * Results:
 *      Pointer to driver or NULL on error.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

struct DbDriver *
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_NsDbGetDriver">NsDbGetDriver</a>(Ns_DbHandle *handle)
{
    Handle *handlePtr = (Handle *) handle;

    if (handlePtr != NULL && handlePtr->poolPtr != NULL) {
        return handlePtr->poolPtr->driverPtr;
    }

    return NULL;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_GetPool">GetPool</a> --
 *
 *      Return the Pool structure for the given pool name.
 *
 * Results:
 *      Pointer to Pool structure or NULL if pool does not exist.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static Pool *
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_GetPool">GetPool</a>(char *pool)
{
    Tcl_HashEntry   *hPtr;

    hPtr = Tcl_FindHashEntry(&poolsTable, pool);
    if (hPtr == NULL) {
        return NULL;
    }

    return (Pool *) Tcl_GetHashValue(hPtr);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_ReturnHandle">ReturnHandle</a> --
 *
 *      Return a handle to its pool.  Connected handles are pushed on
 *      the front of the list, disconnected handles are appened to
 *      the end.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Handle is returned to the pool.  Note:  The pool lock must be
 *      held by the caller and this function does not signal a thread
 *      waiting for handles.
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_ReturnHandle">ReturnHandle</a>(Handle *handlePtr)
{
    Pool         *poolPtr;

    poolPtr = handlePtr->poolPtr;
    if (poolPtr->firstPtr == NULL) {
        poolPtr->firstPtr = poolPtr->lastPtr = handlePtr;
        handlePtr->nextPtr = NULL;
    } else if (handlePtr->connected) {
        handlePtr->nextPtr = poolPtr->firstPtr;
        poolPtr->firstPtr = handlePtr;
    } else {
        poolPtr->lastPtr->nextPtr = handlePtr;
        poolPtr->lastPtr = handlePtr;
        handlePtr->nextPtr = NULL;
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_IsStale">IsStale</a> --
 *
 *      Check to see if a handle is stale.
 *
 * Results:
 *      NS_TRUE if handle stale, NS_FALSE otherwise.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_IsStale">IsStale</a>(Handle *handlePtr, time_t now)
{
    time_t    minAccess, minOpen;
    
    if (handlePtr->connected) {
        minAccess = now - handlePtr->poolPtr->maxidle;
        minOpen = now - handlePtr->poolPtr->maxopen;
        if ((handlePtr->poolPtr->maxidle && handlePtr->atime < minAccess) || 
            (handlePtr->poolPtr->maxopen && (handlePtr->otime < minOpen)) ||
            (handlePtr->stale == NS_TRUE) ||
            (handlePtr->poolPtr->stale_on_close > handlePtr->stale_on_close)) {

            if (handlePtr->poolPtr->fVerbose) {
                <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Notice, "dbinit: closing %s handle in pool '%s'",
                       handlePtr->atime < minAccess ? "idle" : "old",
                       handlePtr->poolname);
            }
            return NS_TRUE;
        }
    }

    return NS_FALSE;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CheckArgProc">CheckArgProc</a> --
 *
 *      Ns_ArgProc callback for the pool checker.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Copies name of pool to given dstring.
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CheckArgProc">CheckArgProc</a>(Tcl_DString *dsPtr, void *arg)
{
    Pool *poolPtr = arg;

    Tcl_DStringAppendElement(dsPtr, poolPtr->name);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CheckPool">CheckPool</a> --
 *
 *      Verify all handles in a pool are not stale.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Stale handles, if any, are closed.
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CheckPool">CheckPool</a>(void *arg)
{
    Pool         *poolPtr = arg;
    Handle       *handlePtr, *nextPtr;
    Handle       *checkedPtr;
    time_t        now;

    time(&now);
    checkedPtr = NULL;

    /*
     * Grab the entire list of handles from the pool.
     */

    Ns_MutexLock(&poolPtr->lock);
    handlePtr = poolPtr->firstPtr;
    poolPtr->firstPtr = poolPtr->lastPtr = NULL;
    Ns_MutexUnlock(&poolPtr->lock);

    /*
     * Run through the list of handles, closing any
     * which have gone stale, and then return them
     * all to the pool.
     */

    if (handlePtr != NULL) {
        while (handlePtr != NULL) {
            nextPtr = handlePtr->nextPtr;
            if (<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_IsStale">IsStale</a>(handlePtr, now)) {
                <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_NsDbDisconnect">NsDbDisconnect</a>((Ns_DbHandle *) handlePtr);
            }
            handlePtr->nextPtr = checkedPtr;
            checkedPtr = handlePtr;
            handlePtr = nextPtr;
        }

        Ns_MutexLock(&poolPtr->lock);
        handlePtr = checkedPtr;
        while (handlePtr != NULL) {
            nextPtr = handlePtr->nextPtr;
            <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_ReturnHandle">ReturnHandle</a>(handlePtr);
            handlePtr = nextPtr;
        }
        if (poolPtr->waiting) {
            Ns_CondSignal(&poolPtr->getCond);
        }
        Ns_MutexUnlock(&poolPtr->lock);
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CreatePool">CreatePool</a> --
 *
 *      Create a new pool using the given driver.
 *
 * Results:
 *      Pointer to newly allocated Pool structure.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static Pool  *
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CreatePool">CreatePool</a>(char *pool, char *path, char *driver)
{
    Pool            *poolPtr;
    Handle          *handlePtr;
    struct DbDriver *driverPtr;
    int              i;
    char            *source;

    if (driver == NULL) {
        <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "dbinit: no driver for pool '%s'", pool);
        return NULL;
    }
    driverPtr = <a href="/cvs/aolserver/aolserver/nsdb/dbdrv.c#A_NsDbLoadDriver">NsDbLoadDriver</a>(driver);
    if (driverPtr == NULL) {
        return NULL;
    }
    source = <a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetValue">Ns_ConfigGetValue</a>(path, "datasource");
    if (source == NULL) {
        <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "dbinit: missing datasource for pool '%s'", pool);
        return NULL;
    }
    poolPtr = ns_malloc(sizeof(Pool));
    poolPtr->driver = driver;
    poolPtr->driverPtr = driverPtr;
    Ns_MutexInit(&poolPtr->lock);
    Ns_MutexSetName2(&poolPtr->lock, "nsdb", pool);
    Ns_CondInit(&poolPtr->waitCond);
    Ns_CondInit(&poolPtr->getCond);
    poolPtr->source = source;
    poolPtr->name = pool;
    poolPtr->waiting = 0;
    poolPtr->user = <a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetValue">Ns_ConfigGetValue</a>(path, "user");
    poolPtr->pass = <a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetValue">Ns_ConfigGetValue</a>(path, "password");
    poolPtr->desc = <a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetValue">Ns_ConfigGetValue</a>("ns/db/pools", pool);
    poolPtr->stale_on_close = 0;
    if (!<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetBool">Ns_ConfigGetBool</a>(path, "verbose", &poolPtr->fVerbose)) {
        poolPtr->fVerbose = 0;
    } 
    if (!<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetBool">Ns_ConfigGetBool</a>(path, "logsqlerrors", &poolPtr->fVerboseError)) {
        poolPtr->fVerboseError = 0;
    }
    if (!<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetInt">Ns_ConfigGetInt</a>(path, "connections", &poolPtr->nhandles)
        || poolPtr->nhandles <= 0) {
        poolPtr->nhandles = 2;
    }
    if (<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetInt">Ns_ConfigGetInt</a>(path, "MaxIdle", &i) == NS_FALSE || i < 0) {
        i = 600;                    /* 10 minutes */
    }
    poolPtr->maxidle = i;
    if (<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetInt">Ns_ConfigGetInt</a>(path, "MaxOpen", &i) == NS_FALSE || i < 0) {
        i = 3600;                   /* 1 hour */
    }
    poolPtr->maxopen = i;
    poolPtr->firstPtr = poolPtr->lastPtr = NULL;
    for (i = 0; i < poolPtr->nhandles; ++i) {
        handlePtr = ns_malloc(sizeof(Handle));
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringInit">Ns_DStringInit</a>(&handlePtr->dsExceptionMsg);
        handlePtr->poolPtr = poolPtr;
        handlePtr->connection = NULL;
        handlePtr->connected = NS_FALSE;
        handlePtr->fetchingRows = 0;
        handlePtr->row = <a href="/cvs/aolserver/aolserver/nsd/set.c#A_Ns_SetCreate">Ns_SetCreate</a>(NULL);
        handlePtr->cExceptionCode[0] = '\0';
        handlePtr->otime = handlePtr->atime = 0;
        handlePtr->stale = NS_FALSE;
        handlePtr->stale_on_close = 0;

        /*
         * The following elements of the Handle structure could
         * be obtained by dereferencing the poolPtr.  They're
         * only needed to maintain the original Ns_DbHandle
         * structure definition which was designed to allow
         * handles outside of pools, a feature no longer supported.
         */

        handlePtr->driver = driver;
        handlePtr->datasource = poolPtr->source;
        handlePtr->user = poolPtr->user;
        handlePtr->password = poolPtr->pass;
        handlePtr->verbose = poolPtr->fVerbose;
        handlePtr->poolname = pool;
        <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_ReturnHandle">ReturnHandle</a>(handlePtr);
    }
    if (!<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetInt">Ns_ConfigGetInt</a>(path, "checkinterval", &i) || i < 0) {
        i = 600;        /* 10 minutes. */
    }
    <a href="/cvs/aolserver/aolserver/nsd/sched.c#A_Ns_ScheduleProc">Ns_ScheduleProc</a>(<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_CheckPool">CheckPool</a>, poolPtr, 0, i);
    return poolPtr;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Connect">Connect</a> --
 *
 *      <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Connect">Connect</a> a handle by opening the database.
 *
 * Results:
 *      NS_OK if connect ok, NS_ERROR otherwise.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_Connect">Connect</a>(Handle *handlePtr)
{
    int status;

    status = <a href="/cvs/aolserver/aolserver/nsdb/dbdrv.c#A_NsDbOpen">NsDbOpen</a>((Ns_DbHandle *) handlePtr);
    if (status != NS_OK) {
        handlePtr->connected = NS_FALSE;
        handlePtr->atime = handlePtr->otime = 0;
        handlePtr->stale = NS_FALSE;
    } else {
        handlePtr->connected = NS_TRUE;
        handlePtr->atime = handlePtr->otime = time(NULL);
    }

    return status;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_IncrCount">IncrCount</a> --
 *
 *      Update per-thread count of allocated handles.
 *
 * Results:
 *      Previous count of allocated handles.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_IncrCount">IncrCount</a>(Pool *poolPtr, int incr)
{
    Tcl_HashTable *tablePtr;
    Tcl_HashEntry *hPtr;
    int prev, count, new;

    tablePtr = Ns_TlsGet(&tls);
    if (tablePtr == NULL) {
        tablePtr = ns_malloc(sizeof(Tcl_HashTable));
        Tcl_InitHashTable(tablePtr, TCL_ONE_WORD_KEYS);
        Ns_TlsSet(&tls, tablePtr);
    }
    hPtr = Tcl_CreateHashEntry(tablePtr, (char *) poolPtr, &new);
    if (new) {
        prev = 0;
    } else {
        prev = (int) Tcl_GetHashValue(hPtr);
    }
    count = prev + incr;
    if (count == 0) {
        Tcl_DeleteHashEntry(hPtr);
    } else {
        Tcl_SetHashValue(hPtr, (ClientData) count);
    }
    return prev;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_GetServer">GetServer</a> --
 *
 *      Get per-server data.
 *
 * Results:
 *      Pointer to per-server data.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static ServData *
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_GetServer">GetServer</a>(char *server)
{
    Tcl_HashEntry *hPtr;

    hPtr = Tcl_FindHashEntry(&serversTable, server);
    if (hPtr != NULL) {
        return Tcl_GetHashValue(hPtr);
    }
    return NULL;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_FreeTable">FreeTable</a> --
 *
 *      Free the per-thread count of allocated handles table.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nsdb/dbinit.c#A_FreeTable">FreeTable</a>(void *arg)
{
    Tcl_HashTable  *tablePtr = arg;

    Tcl_DeleteHashTable(tablePtr);
    ns_free(tablePtr);
}