/*
** 2010 October 28
**
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
*************************************************************************
**
** This file contains a VFS "shim" - a layer that sits in between the
** pager and the real VFS - that breaks up a very large database file
** into two or more smaller files on disk. This is useful, for example,
** in order to support large, multi-gigabyte databases on older filesystems
** that limit the maximum file size to 2 GiB.
**
** USAGE:
**
** Compile this source file and link it with your application. Then
** at start-time, invoke the following procedure:
**
** int sqlite3_multiplex_initialize(
** const char *zOrigVfsName, // The underlying real VFS
** int makeDefault // True to make multiplex the default VFS
** );
**
** The procedure call above will create and register a new VFS shim named
** "multiplex". The multiplex VFS will use the VFS named by zOrigVfsName to
** do the actual disk I/O. (The zOrigVfsName parameter may be NULL, in
** which case the default VFS at the moment sqlite3_multiplex_initialize()
** is called will be used as the underlying real VFS.)
**
** If the makeDefault parameter is TRUE then multiplex becomes the new
** default VFS. Otherwise, you can use the multiplex VFS by specifying
** "multiplex" as the 4th parameter to sqlite3_open_v2() or by employing
** URI filenames and adding "vfs=multiplex" as a parameter to the filename
** URI.
**
** The multiplex VFS allows databases up to 32 GiB in size. But it splits
** the files up into smaller pieces, so that they will work even on
** filesystems that do not support large files. The default chunk size
** is 2147418112 bytes (which is 64KiB less than 2GiB) but this can be
** changed at compile-time by defining the SQLITE_MULTIPLEX_CHUNK_SIZE
** macro. Use the "chunksize=NNNN" query parameter with a URI filename
** in order to select an alternative chunk size for individual connections
** at run-time.
*/
#include "sqlite3.h"
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include "test_multiplex.h"

#ifndef SQLITE_CORE
 #define SQLITE_CORE 1 /* Disable the API redefinition in sqlite3ext.h */
#endif
#include "sqlite3ext.h"

/*
** These should be defined to be the same as the values in
** sqliteInt.h. They are defined separately here so that
** the multiplex VFS shim can be built as a loadable
** module.
*/
#define UNUSED_PARAMETER(x) (void)(x)
#define MAX_PAGE_SIZE 0x10000
#define DEFAULT_SECTOR_SIZE 0x1000

/* Maximum chunk number */
#define MX_CHUNK_NUMBER 299

/* First chunk for rollback journal files */
#define SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET 400
#define SQLITE_MULTIPLEX_WAL_8_3_OFFSET 700


/************************ Shim Definitions ******************************/

#ifndef SQLITE_MULTIPLEX_VFS_NAME
# define SQLITE_MULTIPLEX_VFS_NAME "multiplex"
#endif

/* This is the limit on the chunk size. It may be changed by calling
** the xFileControl() interface. It will be rounded up to a
** multiple of MAX_PAGE_SIZE. We default it here to 2GiB less 64KiB.
*/
#ifndef SQLITE_MULTIPLEX_CHUNK_SIZE
# define SQLITE_MULTIPLEX_CHUNK_SIZE 2147418112
#endif

/* This used to be the default limit on number of chunks, but
** it is no longer enforced. There is currently no limit to the
** number of chunks.
**
** May be changed by calling the xFileControl() interface.
*/
#ifndef SQLITE_MULTIPLEX_MAX_CHUNKS
# define SQLITE_MULTIPLEX_MAX_CHUNKS 12
#endif

/************************ Object Definitions ******************************/

/* Forward declaration of all object types */
typedef struct multiplexGroup multiplexGroup;
typedef struct multiplexConn multiplexConn;

/*
** A "multiplex group" is a collection of files that collectively
** makeup a single SQLite DB file. This allows the size of the DB
** to exceed the limits imposed by the file system.
**
** There is an instance of the following object for each defined multiplex
** group.
*/
struct multiplexGroup {
 struct multiplexReal { /* For each chunk */
 sqlite3_file *p; /* Handle for the chunk */
 char *z; /* Name of this chunk */
 } *aReal; /* list of all chunks */
 int nReal; /* Number of chunks */
 char *zName; /* Base filename of this group */
 int nName; /* Length of base filename */
 int flags; /* Flags used for original opening */
 unsigned int szChunk; /* Chunk size used for this group */
 unsigned char bEnabled; /* TRUE to use Multiplex VFS for this file */
 unsigned char bTruncate; /* TRUE to enable truncation of databases */
};

/*
** An instance of the following object represents each open connection
** to a file that is multiplex'ed. This object is a
** subclass of sqlite3_file. The sqlite3_file object for the underlying
** VFS is appended to this structure.
*/
struct multiplexConn {
 sqlite3_file base; /* Base class - must be first */
 multiplexGroup *pGroup; /* The underlying group of files */
};

/************************* Global Variables **********************************/
/*
** All global variables used by this file are containing within the following
** gMultiplex structure.
*/
static struct {
 /* The pOrigVfs is the real, original underlying VFS implementation.
 ** Most operations pass-through to the real VFS. This value is read-only
 ** during operation. It is only modified at start-time and thus does not
 ** require a mutex.
 */
 sqlite3_vfs *pOrigVfs;

 /* The sThisVfs is the VFS structure used by this shim. It is initialized
 ** at start-time and thus does not require a mutex
 */
 sqlite3_vfs sThisVfs;

 /* The sIoMethods defines the methods used by sqlite3_file objects
 ** associated with this shim. It is initialized at start-time and does
 ** not require a mutex.
 **
 ** When the underlying VFS is called to open a file, it might return
 ** either a version 1 or a version 2 sqlite3_file object. This shim
 ** has to create a wrapper sqlite3_file of the same version. Hence
 ** there are two I/O method structures, one for version 1 and the other
 ** for version 2.
 */
 sqlite3_io_methods sIoMethodsV1;
 sqlite3_io_methods sIoMethodsV2;

 /* True when this shim has been initialized.
 */
 int isInitialized;
} gMultiplex;

/************************* Utility Routines *********************************/
/*
** Compute a string length that is limited to what can be stored in
** lower 30 bits of a 32-bit signed integer.
**
** The value returned will never be negative. Nor will it ever be greater
** than the actual length of the string. For very long strings (greater
** than 1GiB) the value returned might be less than the true string length.
*/
static int multiplexStrlen30(const char *z){
 const char *z2 = z;
 if( z==0 ) return 0;
 while( *z2 ){ z2++; }
 return 0x3fffffff & (int)(z2 - z);
}

/*
** Generate the file-name for chunk iChunk of the group with base name
** zBase. The file-name is written to buffer zOut before returning. Buffer
** zOut must be allocated by the caller so that it is at least (nBase+5)
** bytes in size, where nBase is the length of zBase, not including the
** nul-terminator.
**
** If iChunk is 0 (or 400 - the number for the first journal file chunk),
** the output is a copy of the input string. Otherwise, if
** SQLITE_ENABLE_8_3_NAMES is not defined or the input buffer does not contain
** a "." character, then the output is a copy of the input string with the
** three-digit zero-padded decimal representation if iChunk appended to it.
** For example:
**
** zBase="test.db", iChunk=4 -> zOut="test.db004"
**
** Or, if SQLITE_ENABLE_8_3_NAMES is defined and the input buffer contains
** a "." character, then everything after the "." is replaced by the
** three-digit representation of iChunk.
**
** zBase="test.db", iChunk=4 -> zOut="test.004"
**
** The output buffer string is terminated by 2 0x00 bytes. This makes it safe
** to pass to sqlite3_uri_parameter() and similar.
*/
static void multiplexFilename(
 const char *zBase, /* Filename for chunk 0 */
 int nBase, /* Size of zBase in bytes (without 0円) */
 int flags, /* Flags used to open file */
 int iChunk, /* Chunk to generate filename for */
 char *zOut /* Buffer to write generated name to */
){
 int n = nBase;
 memcpy(zOut, zBase, n+1);
 if( iChunk!=0 && iChunk<=MX_CHUNK_NUMBER ){
#ifdef SQLITE_ENABLE_8_3_NAMES
 int i;
 for(i=n-1; i>0 && i>=n-4 && zOut[i]!='.'; i--){}
 if( i>=n-4 ) n = i+1;
 if( flags & SQLITE_OPEN_MAIN_JOURNAL ){
 /* The extensions on overflow files for main databases are 001, 002,
 ** 003 and so forth. To avoid name collisions, add 400 to the
 ** extensions of journal files so that they are 401, 402, 403, ....
 */
 iChunk += SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET;
 }else if( flags & SQLITE_OPEN_WAL ){
 /* To avoid name collisions, add 700 to the
 ** extensions of WAL files so that they are 701, 702, 703, ....
 */
 iChunk += SQLITE_MULTIPLEX_WAL_8_3_OFFSET;
 }
#endif
 sqlite3_snprintf(4,&zOut[n],"%03d",iChunk);
 n += 3;
 }

 assert( zOut[n]=='0円' );
 zOut[n+1] = '0円';
}

/* Compute the filename for the iChunk-th chunk
*/
static int multiplexSubFilename(multiplexGroup *pGroup, int iChunk){
 if( iChunk>=pGroup->nReal ){
 struct multiplexReal *p;
 p = sqlite3_realloc64(pGroup->aReal, (iChunk+1)*sizeof(*p));
 if( p==0 ){
 return SQLITE_NOMEM;
 }
 memset(&p[pGroup->nReal], 0, sizeof(p[0])*(iChunk+1-pGroup->nReal));
 pGroup->aReal = p;
 pGroup->nReal = iChunk+1;
 }
 if( pGroup->zName && pGroup->aReal[iChunk].z==0 ){
 char *z;
 int n = pGroup->nName;
 z = sqlite3_malloc64( n+5 );
 if( z==0 ){
 return SQLITE_NOMEM;
 }
 multiplexFilename(pGroup->zName, pGroup->nName, pGroup->flags, iChunk, z);
 pGroup->aReal[iChunk].z = (char*)sqlite3_create_filename(z,"","",0,0);
 sqlite3_free(z);
 if( pGroup->aReal[iChunk].z==0 ) return SQLITE_NOMEM;
 }
 return SQLITE_OK;
}

/* Translate an sqlite3_file* that is really a multiplexGroup* into
** the sqlite3_file* for the underlying original VFS.
**
** For chunk 0, the pGroup->flags determines whether or not a new file
** is created if it does not already exist. For chunks 1 and higher, the
** file is created only if createFlag is 1.
*/
static sqlite3_file *multiplexSubOpen(
 multiplexGroup *pGroup, /* The multiplexor group */
 int iChunk, /* Which chunk to open. 0==original file */
 int *rc, /* Result code in and out */
 int *pOutFlags, /* Output flags */
 int createFlag /* True to create if iChunk>0 */
){
 sqlite3_file *pSubOpen = 0;
 sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */

#ifdef SQLITE_ENABLE_8_3_NAMES
 /* If JOURNAL_8_3_OFFSET is set to (say) 400, then any overflow files are
 ** part of a database journal are named db.401, db.402, and so on. A
 ** database may therefore not grow to larger than 400 chunks. Attempting
 ** to open chunk 401 indicates the database is full. */
 if( iChunk>=SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET ){
 sqlite3_log(SQLITE_FULL, "multiplexed chunk overflow: %s", pGroup->zName);
 *rc = SQLITE_FULL;
 return 0;
 }
#endif

 *rc = multiplexSubFilename(pGroup, iChunk);
 if( (*rc)==SQLITE_OK && (pSubOpen = pGroup->aReal[iChunk].p)==0 ){
 int flags, bExists;
 flags = pGroup->flags;
 if( createFlag ){
 flags |= SQLITE_OPEN_CREATE;
 }else if( iChunk==0 ){
 /* Fall through */
 }else if( pGroup->aReal[iChunk].z==0 ){
 return 0;
 }else{
 *rc = pOrigVfs->xAccess(pOrigVfs, pGroup->aReal[iChunk].z,
 SQLITE_ACCESS_EXISTS, &bExists);
 if( *rc || !bExists ){
 if( *rc ){
 sqlite3_log(*rc, "multiplexor.xAccess failure on %s",
 pGroup->aReal[iChunk].z);
 }
 return 0;
 }
 flags &= ~SQLITE_OPEN_CREATE;
 }
 pSubOpen = sqlite3_malloc64( pOrigVfs->szOsFile );
 if( pSubOpen==0 ){
 *rc = SQLITE_IOERR_NOMEM;
 return 0;
 }
 pGroup->aReal[iChunk].p = pSubOpen;
 *rc = pOrigVfs->xOpen(pOrigVfs, pGroup->aReal[iChunk].z, pSubOpen,
 flags, pOutFlags);
 if( (*rc)!=SQLITE_OK ){
 sqlite3_log(*rc, "multiplexor.xOpen failure on %s",
 pGroup->aReal[iChunk].z);
 sqlite3_free(pSubOpen);
 pGroup->aReal[iChunk].p = 0;
 return 0;
 }
 }
 return pSubOpen;
}

/*
** Return the size, in bytes, of chunk number iChunk. If that chunk
** does not exist, then return 0. This function does not distinguish between
** non-existent files and zero-length files.
*/
static sqlite3_int64 multiplexSubSize(
 multiplexGroup *pGroup, /* The multiplexor group */
 int iChunk, /* Which chunk to open. 0==original file */
 int *rc /* Result code in and out */
){
 sqlite3_file *pSub;
 sqlite3_int64 sz = 0;

 if( *rc ) return 0;
 pSub = multiplexSubOpen(pGroup, iChunk, rc, NULL, 0);
 if( pSub==0 ) return 0;
 *rc = pSub->pMethods->xFileSize(pSub, &sz);
 return sz;
} 

/*
** This is the implementation of the multiplex_control() SQL function.
*/
static void multiplexControlFunc(
 sqlite3_context *context,
 int argc,
 sqlite3_value **argv
){
 int rc = SQLITE_OK;
 sqlite3 *db = sqlite3_context_db_handle(context);
 int op = 0;
 int iVal;

 if( !db || argc!=2 ){
 rc = SQLITE_ERROR;
 }else{
 /* extract params */
 op = sqlite3_value_int(argv[0]);
 iVal = sqlite3_value_int(argv[1]);
 /* map function op to file_control op */
 switch( op ){
 case 1:
 op = MULTIPLEX_CTRL_ENABLE;
 break;
 case 2:
 op = MULTIPLEX_CTRL_SET_CHUNK_SIZE;
 break;
 case 3:
 op = MULTIPLEX_CTRL_SET_MAX_CHUNKS;
 break;
 default:
 rc = SQLITE_NOTFOUND;
 break;
 }
 }
 if( rc==SQLITE_OK ){
 rc = sqlite3_file_control(db, 0, op, &iVal);
 }
 sqlite3_result_error_code(context, rc);
}

/*
** This is the entry point to register the auto-extension for the
** multiplex_control() function.
*/
static int multiplexFuncInit(
 sqlite3 *db,
 char **pzErrMsg,
 const sqlite3_api_routines *pApi
){
 int rc;
 rc = sqlite3_create_function(db, "multiplex_control", 2, SQLITE_ANY,
 0, multiplexControlFunc, 0, 0);
 return rc;
}

/*
** Close a single sub-file in the connection group.
*/
static void multiplexSubClose(
 multiplexGroup *pGroup,
 int iChunk,
 sqlite3_vfs *pOrigVfs
){
 sqlite3_file *pSubOpen = pGroup->aReal[iChunk].p;
 if( pSubOpen ){
 pSubOpen->pMethods->xClose(pSubOpen);
 if( pOrigVfs && pGroup->aReal[iChunk].z ){
 pOrigVfs->xDelete(pOrigVfs, pGroup->aReal[iChunk].z, 0);
 }
 sqlite3_free(pGroup->aReal[iChunk].p);
 }
 sqlite3_free_filename(pGroup->aReal[iChunk].z);
 memset(&pGroup->aReal[iChunk], 0, sizeof(pGroup->aReal[iChunk]));
}

/*
** Deallocate memory held by a multiplexGroup
*/
static void multiplexFreeComponents(multiplexGroup *pGroup){
 int i;
 for(i=0; i<pGroup->nReal; i++){ multiplexSubClose(pGroup, i, 0); }
 sqlite3_free(pGroup->aReal);
 pGroup->aReal = 0;
 pGroup->nReal = 0;
}


/************************* VFS Method Wrappers *****************************/

/*
** This is the xOpen method used for the "multiplex" VFS.
**
** Most of the work is done by the underlying original VFS. This method
** simply links the new file into the appropriate multiplex group if it is a
** file that needs to be tracked.
*/
static int multiplexOpen(
 sqlite3_vfs *pVfs, /* The multiplex VFS */
 const char *zName, /* Name of file to be opened */
 sqlite3_file *pConn, /* Fill in this file descriptor */
 int flags, /* Flags to control the opening */
 int *pOutFlags /* Flags showing results of opening */
){
 int rc = SQLITE_OK; /* Result code */
 multiplexConn *pMultiplexOpen; /* The new multiplex file descriptor */
 multiplexGroup *pGroup = 0; /* Corresponding multiplexGroup object */
 sqlite3_file *pSubOpen = 0; /* Real file descriptor */
 sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
 int nName = 0;
 int sz = 0;
 char *zToFree = 0;

 UNUSED_PARAMETER(pVfs);
 memset(pConn, 0, pVfs->szOsFile);
 assert( zName || (flags & SQLITE_OPEN_DELETEONCLOSE) );

 /* We need to create a group structure and manage
 ** access to this group of files.
 */
 pMultiplexOpen = (multiplexConn*)pConn;

 if( rc==SQLITE_OK ){
 /* allocate space for group */
 nName = zName ? multiplexStrlen30(zName) : 0;
 sz = sizeof(multiplexGroup) /* multiplexGroup */
 + nName + 1; /* zName */
 pGroup = sqlite3_malloc64( sz );
 if( pGroup==0 ){
 rc = SQLITE_NOMEM;
 }
 }

 if( rc==SQLITE_OK ){
 const char *zUri = (flags & SQLITE_OPEN_URI) ? zName : 0;
 /* assign pointers to extra space allocated */
 memset(pGroup, 0, sz);
 pMultiplexOpen->pGroup = pGroup;
 pGroup->bEnabled = (unsigned char)-1;
 pGroup->bTruncate = (unsigned char)sqlite3_uri_boolean(zUri, "truncate",
 (flags & SQLITE_OPEN_MAIN_DB)==0);
 pGroup->szChunk = (int)sqlite3_uri_int64(zUri, "chunksize",
 SQLITE_MULTIPLEX_CHUNK_SIZE);
 pGroup->szChunk = (pGroup->szChunk+0xffff)&~0xffff;
 if( zName ){
 char *p = (char *)&pGroup[1];
 pGroup->zName = p;
 memcpy(pGroup->zName, zName, nName+1);
 pGroup->nName = nName;
 }
 if( pGroup->bEnabled ){
 /* Make sure that the chunksize is such that the pending byte does not
 ** falls at the end of a chunk. A region of up to 64K following
 ** the pending byte is never written, so if the pending byte occurs
 ** near the end of a chunk, that chunk will be too small. */
#ifndef SQLITE_OMIT_WSD
 extern int sqlite3PendingByte;
#else
 int sqlite3PendingByte = 0x40000000;
#endif
 while( (sqlite3PendingByte % pGroup->szChunk)>=(pGroup->szChunk-65536) ){
 pGroup->szChunk += 65536;
 }
 }
 pGroup->flags = (flags & ~SQLITE_OPEN_URI);
 rc = multiplexSubFilename(pGroup, 1);
 if( rc==SQLITE_OK ){
 pSubOpen = multiplexSubOpen(pGroup, 0, &rc, pOutFlags, 0);
 if( pSubOpen==0 && rc==SQLITE_OK ) rc = SQLITE_CANTOPEN;
 }
 if( rc==SQLITE_OK ){
 sqlite3_int64 sz64;

 rc = pSubOpen->pMethods->xFileSize(pSubOpen, &sz64);
 if( rc==SQLITE_OK && zName ){
 int bExists;
 if( flags & SQLITE_OPEN_SUPER_JOURNAL ){
 pGroup->bEnabled = 0;
 }else
 if( sz64==0 ){
 if( flags & SQLITE_OPEN_MAIN_JOURNAL ){
 /* If opening a main journal file and the first chunk is zero
 ** bytes in size, delete any subsequent chunks from the
 ** file-system. */
 int iChunk = 1;
 do {
 rc = pOrigVfs->xAccess(pOrigVfs,
 pGroup->aReal[iChunk].z, SQLITE_ACCESS_EXISTS, &bExists
 );
 if( rc==SQLITE_OK && bExists ){
 rc = pOrigVfs->xDelete(pOrigVfs, pGroup->aReal[iChunk].z, 0);
 if( rc==SQLITE_OK ){
 rc = multiplexSubFilename(pGroup, ++iChunk);
 }
 }
 }while( rc==SQLITE_OK && bExists );
 }
 }else{
 /* If the first overflow file exists and if the size of the main file
 ** is different from the chunk size, that means the chunk size is set
 ** set incorrectly. So fix it.
 **
 ** Or, if the first overflow file does not exist and the main file is
 ** larger than the chunk size, that means the chunk size is too small.
 ** But we have no way of determining the intended chunk size, so
 ** just disable the multiplexor all together.
 */
 rc = pOrigVfs->xAccess(pOrigVfs, pGroup->aReal[1].z,
 SQLITE_ACCESS_EXISTS, &bExists);
 bExists = multiplexSubSize(pGroup, 1, &rc)>0;
 if( rc==SQLITE_OK && bExists && sz64==(sz64&0xffff0000) && sz64>0
 && sz64!=pGroup->szChunk ){
 pGroup->szChunk = (int)sz64;
 }else if( rc==SQLITE_OK && !bExists && sz64>pGroup->szChunk ){
 pGroup->bEnabled = 0;
 }
 }
 }
 }

 if( rc==SQLITE_OK ){
 if( pSubOpen->pMethods->iVersion==1 ){
 pConn->pMethods = &gMultiplex.sIoMethodsV1;
 }else{
 pConn->pMethods = &gMultiplex.sIoMethodsV2;
 }
 }else{
 multiplexFreeComponents(pGroup);
 sqlite3_free(pGroup);
 }
 }
 sqlite3_free(zToFree);
 return rc;
}

/*
** This is the xDelete method used for the "multiplex" VFS.
** It attempts to delete the filename specified.
*/
static int multiplexDelete(
 sqlite3_vfs *pVfs, /* The multiplex VFS */
 const char *zName, /* Name of file to delete */
 int syncDir
){
 int rc;
 sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
 rc = pOrigVfs->xDelete(pOrigVfs, zName, syncDir);
 if( rc==SQLITE_OK ){
 /* If the main chunk was deleted successfully, also delete any subsequent
 ** chunks - starting with the last (highest numbered).
 */
 int nName = (int)strlen(zName);
 char *z;
 z = sqlite3_malloc64(nName + 5);
 if( z==0 ){
 rc = SQLITE_IOERR_NOMEM;
 }else{
 int iChunk = 0;
 int bExists;
 do{
 multiplexFilename(zName, nName, SQLITE_OPEN_MAIN_JOURNAL, ++iChunk, z);
 rc = pOrigVfs->xAccess(pOrigVfs, z, SQLITE_ACCESS_EXISTS, &bExists);
 }while( rc==SQLITE_OK && bExists );
 while( rc==SQLITE_OK && iChunk>1 ){
 multiplexFilename(zName, nName, SQLITE_OPEN_MAIN_JOURNAL, --iChunk, z);
 rc = pOrigVfs->xDelete(pOrigVfs, z, syncDir);
 }
 if( rc==SQLITE_OK ){
 iChunk = 0;
 do{
 multiplexFilename(zName, nName, SQLITE_OPEN_WAL, ++iChunk, z);
 rc = pOrigVfs->xAccess(pOrigVfs, z, SQLITE_ACCESS_EXISTS, &bExists);
 }while( rc==SQLITE_OK && bExists );
 while( rc==SQLITE_OK && iChunk>1 ){
 multiplexFilename(zName, nName, SQLITE_OPEN_WAL, --iChunk, z);
 rc = pOrigVfs->xDelete(pOrigVfs, z, syncDir);
 }
 }
 }
 sqlite3_free(z);
 }
 return rc;
}

static int multiplexAccess(sqlite3_vfs *a, const char *b, int c, int *d){
 return gMultiplex.pOrigVfs->xAccess(gMultiplex.pOrigVfs, b, c, d);
}
static int multiplexFullPathname(sqlite3_vfs *a, const char *b, int c, char *d){
 return gMultiplex.pOrigVfs->xFullPathname(gMultiplex.pOrigVfs, b, c, d);
}
static void *multiplexDlOpen(sqlite3_vfs *a, const char *b){
 return gMultiplex.pOrigVfs->xDlOpen(gMultiplex.pOrigVfs, b);
}
static void multiplexDlError(sqlite3_vfs *a, int b, char *c){
 gMultiplex.pOrigVfs->xDlError(gMultiplex.pOrigVfs, b, c);
}
static void (*multiplexDlSym(sqlite3_vfs *a, void *b, const char *c))(void){
 return gMultiplex.pOrigVfs->xDlSym(gMultiplex.pOrigVfs, b, c);
}
static void multiplexDlClose(sqlite3_vfs *a, void *b){
 gMultiplex.pOrigVfs->xDlClose(gMultiplex.pOrigVfs, b);
}
static int multiplexRandomness(sqlite3_vfs *a, int b, char *c){
 return gMultiplex.pOrigVfs->xRandomness(gMultiplex.pOrigVfs, b, c);
}
static int multiplexSleep(sqlite3_vfs *a, int b){
 return gMultiplex.pOrigVfs->xSleep(gMultiplex.pOrigVfs, b);
}
static int multiplexCurrentTime(sqlite3_vfs *a, double *b){
 return gMultiplex.pOrigVfs->xCurrentTime(gMultiplex.pOrigVfs, b);
}
static int multiplexGetLastError(sqlite3_vfs *a, int b, char *c){
 if( gMultiplex.pOrigVfs->xGetLastError ){
 return gMultiplex.pOrigVfs->xGetLastError(gMultiplex.pOrigVfs, b, c);
 }else{
 return 0;
 }
}
static int multiplexCurrentTimeInt64(sqlite3_vfs *a, sqlite3_int64 *b){
 return gMultiplex.pOrigVfs->xCurrentTimeInt64(gMultiplex.pOrigVfs, b);
}

/************************ I/O Method Wrappers *******************************/

/* xClose requests get passed through to the original VFS.
** We loop over all open chunk handles and close them.
** The group structure for this file is unlinked from
** our list of groups and freed.
*/
static int multiplexClose(sqlite3_file *pConn){
 multiplexConn *p = (multiplexConn*)pConn;
 multiplexGroup *pGroup = p->pGroup;
 int rc = SQLITE_OK;
 multiplexFreeComponents(pGroup);
 sqlite3_free(pGroup);
 return rc;
}

/* Pass xRead requests thru to the original VFS after
** determining the correct chunk to operate on.
** Break up reads across chunk boundaries.
*/
static int multiplexRead(
 sqlite3_file *pConn,
 void *pBuf,
 int iAmt,
 sqlite3_int64 iOfst
){
 multiplexConn *p = (multiplexConn*)pConn;
 multiplexGroup *pGroup = p->pGroup;
 int rc = SQLITE_OK;
 if( !pGroup->bEnabled ){
 sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
 if( pSubOpen==0 ){
 rc = SQLITE_IOERR_READ;
 }else{
 rc = pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, iOfst);
 }
 }else{
 while( iAmt > 0 ){
 int i = (int)(iOfst / pGroup->szChunk);
 sqlite3_file *pSubOpen;
 pSubOpen = multiplexSubOpen(pGroup, i, &rc, NULL, 1);
 if( pSubOpen ){
 int extra = ((int)(iOfst % pGroup->szChunk) + iAmt) - pGroup->szChunk;
 if( extra<0 ) extra = 0;
 iAmt -= extra;
 rc = pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt,
 iOfst % pGroup->szChunk);
 if( rc!=SQLITE_OK ) break;
 pBuf = (char *)pBuf + iAmt;
 iOfst += iAmt;
 iAmt = extra;
 }else{
 rc = SQLITE_IOERR_READ;
 break;
 }
 }
 }

 return rc;
}

/* Pass xWrite requests thru to the original VFS after
** determining the correct chunk to operate on.
** Break up writes across chunk boundaries.
*/
static int multiplexWrite(
 sqlite3_file *pConn,
 const void *pBuf,
 int iAmt,
 sqlite3_int64 iOfst
){
 multiplexConn *p = (multiplexConn*)pConn;
 multiplexGroup *pGroup = p->pGroup;
 int rc = SQLITE_OK;
 if( !pGroup->bEnabled ){
 sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
 if( pSubOpen==0 ){
 rc = SQLITE_IOERR_WRITE;
 }else{
 rc = pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, iOfst);
 }
 }else{
 while( rc==SQLITE_OK && iAmt>0 ){
 int i = (int)(iOfst / pGroup->szChunk);
 sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, i, &rc, NULL, 1);
 if( pSubOpen ){
 int extra = ((int)(iOfst % pGroup->szChunk) + iAmt) -
 pGroup->szChunk;
 if( extra<0 ) extra = 0;
 iAmt -= extra;
 rc = pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt,
 iOfst % pGroup->szChunk);
 pBuf = (char *)pBuf + iAmt;
 iOfst += iAmt;
 iAmt = extra;
 }
 }
 }
 return rc;
}

/* Pass xTruncate requests thru to the original VFS after
** determining the correct chunk to operate on. Delete any
** chunks above the truncate mark.
*/
static int multiplexTruncate(sqlite3_file *pConn, sqlite3_int64 size){
 multiplexConn *p = (multiplexConn*)pConn;
 multiplexGroup *pGroup = p->pGroup;
 int rc = SQLITE_OK;
 if( !pGroup->bEnabled ){
 sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
 if( pSubOpen==0 ){
 rc = SQLITE_IOERR_TRUNCATE;
 }else{
 rc = pSubOpen->pMethods->xTruncate(pSubOpen, size);
 }
 }else{
 int i;
 int iBaseGroup = (int)(size / pGroup->szChunk);
 sqlite3_file *pSubOpen;
 sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
 /* delete the chunks above the truncate limit */
 for(i = pGroup->nReal-1; i>iBaseGroup && rc==SQLITE_OK; i--){
 if( pGroup->bTruncate ){
 multiplexSubClose(pGroup, i, pOrigVfs);
 }else{
 pSubOpen = multiplexSubOpen(pGroup, i, &rc, 0, 0);
 if( pSubOpen ){
 rc = pSubOpen->pMethods->xTruncate(pSubOpen, 0);
 }
 }
 }
 if( rc==SQLITE_OK ){
 pSubOpen = multiplexSubOpen(pGroup, iBaseGroup, &rc, 0, 0);
 if( pSubOpen ){
 rc = pSubOpen->pMethods->xTruncate(pSubOpen, size % pGroup->szChunk);
 }
 }
 if( rc ) rc = SQLITE_IOERR_TRUNCATE;
 }
 return rc;
}

/* Pass xSync requests through to the original VFS without change
*/
static int multiplexSync(sqlite3_file *pConn, int flags){
 multiplexConn *p = (multiplexConn*)pConn;
 multiplexGroup *pGroup = p->pGroup;
 int rc = SQLITE_OK;
 int i;
 for(i=0; i<pGroup->nReal; i++){
 sqlite3_file *pSubOpen = pGroup->aReal[i].p;
 if( pSubOpen ){
 int rc2 = pSubOpen->pMethods->xSync(pSubOpen, flags);
 if( rc2!=SQLITE_OK ) rc = rc2;
 }
 }
 return rc;
}

/* Pass xFileSize requests through to the original VFS.
** Aggregate the size of all the chunks before returning.
*/
static int multiplexFileSize(sqlite3_file *pConn, sqlite3_int64 *pSize){
 multiplexConn *p = (multiplexConn*)pConn;
 multiplexGroup *pGroup = p->pGroup;
 int rc = SQLITE_OK;
 int i;
 if( !pGroup->bEnabled ){
 sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
 if( pSubOpen==0 ){
 rc = SQLITE_IOERR_FSTAT;
 }else{
 rc = pSubOpen->pMethods->xFileSize(pSubOpen, pSize);
 }
 }else{
 *pSize = 0;
 for(i=0; rc==SQLITE_OK; i++){
 sqlite3_int64 sz = multiplexSubSize(pGroup, i, &rc);
 if( sz==0 ) break;
 *pSize = i*(sqlite3_int64)pGroup->szChunk + sz;
 }
 }
 return rc;
}

/* Pass xLock requests through to the original VFS unchanged.
*/
static int multiplexLock(sqlite3_file *pConn, int lock){
 multiplexConn *p = (multiplexConn*)pConn;
 int rc;
 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
 if( pSubOpen ){
 return pSubOpen->pMethods->xLock(pSubOpen, lock);
 }
 return SQLITE_BUSY;
}

/* Pass xUnlock requests through to the original VFS unchanged.
*/
static int multiplexUnlock(sqlite3_file *pConn, int lock){
 multiplexConn *p = (multiplexConn*)pConn;
 int rc;
 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
 if( pSubOpen ){
 return pSubOpen->pMethods->xUnlock(pSubOpen, lock);
 }
 return SQLITE_IOERR_UNLOCK;
}

/* Pass xCheckReservedLock requests through to the original VFS unchanged.
*/
static int multiplexCheckReservedLock(sqlite3_file *pConn, int *pResOut){
 multiplexConn *p = (multiplexConn*)pConn;
 int rc;
 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
 if( pSubOpen ){
 return pSubOpen->pMethods->xCheckReservedLock(pSubOpen, pResOut);
 }
 return SQLITE_IOERR_CHECKRESERVEDLOCK;
}

/* Pass xFileControl requests through to the original VFS unchanged,
** except for any MULTIPLEX_CTRL_* requests here.
*/
static int multiplexFileControl(sqlite3_file *pConn, int op, void *pArg){
 multiplexConn *p = (multiplexConn*)pConn;
 multiplexGroup *pGroup = p->pGroup;
 int rc = SQLITE_ERROR;
 sqlite3_file *pSubOpen;

 if( !gMultiplex.isInitialized ) return SQLITE_MISUSE;
 switch( op ){
 case MULTIPLEX_CTRL_ENABLE:
 if( pArg ) {
 int bEnabled = *(int *)pArg;
 pGroup->bEnabled = (unsigned char)bEnabled;
 rc = SQLITE_OK;
 }
 break;
 case MULTIPLEX_CTRL_SET_CHUNK_SIZE:
 if( pArg ) {
 unsigned int szChunk = *(unsigned*)pArg;
 if( szChunk<1 ){
 rc = SQLITE_MISUSE;
 }else{
 /* Round up to nearest multiple of MAX_PAGE_SIZE. */
 szChunk = (szChunk + (MAX_PAGE_SIZE-1));
 szChunk &= ~(MAX_PAGE_SIZE-1);
 pGroup->szChunk = szChunk;
 rc = SQLITE_OK;
 }
 }
 break;
 case MULTIPLEX_CTRL_SET_MAX_CHUNKS:
 rc = SQLITE_OK;
 break;
 case SQLITE_FCNTL_SIZE_HINT:
 case SQLITE_FCNTL_CHUNK_SIZE:
 /* no-op these */
 rc = SQLITE_OK;
 break;
 case SQLITE_FCNTL_PRAGMA: {
 char **aFcntl = (char**)pArg;
 /*
 ** EVIDENCE-OF: R-29875-31678 The argument to the SQLITE_FCNTL_PRAGMA
 ** file control is an array of pointers to strings (char**) in which the
 ** second element of the array is the name of the pragma and the third
 ** element is the argument to the pragma or NULL if the pragma has no
 ** argument.
 */
 if( aFcntl[1] && sqlite3_strnicmp(aFcntl[1],"multiplex_",10)==0 ){
 sqlite3_int64 sz = 0;
 (void)multiplexFileSize(pConn, &sz);
 /*
 ** PRAGMA multiplex_truncate=BOOLEAN;
 ** PRAGMA multiplex_truncate;
 **
 ** Turn the multiplexor truncate feature on or off. Return either
 ** "on" or "off" to indicate the new setting. If the BOOLEAN argument
 ** is omitted, just return the current value for the truncate setting.
 */
 if( sqlite3_stricmp(aFcntl[1],"multiplex_truncate")==0 ){
 if( aFcntl[2] && aFcntl[2][0] ){
 if( sqlite3_stricmp(aFcntl[2], "on")==0
 || sqlite3_stricmp(aFcntl[2], "1")==0 ){
 pGroup->bTruncate = 1;
 }else
 if( sqlite3_stricmp(aFcntl[2], "off")==0
 || sqlite3_stricmp(aFcntl[2], "0")==0 ){
 pGroup->bTruncate = 0;
 }
 }
 /* EVIDENCE-OF: R-27806-26076 The handler for an SQLITE_FCNTL_PRAGMA
 ** file control can optionally make the first element of the char**
 ** argument point to a string obtained from sqlite3_mprintf() or the
 ** equivalent and that string will become the result of the pragma
 ** or the error message if the pragma fails.
 */
 aFcntl[0] = sqlite3_mprintf(pGroup->bTruncate ? "on" : "off");
 rc = SQLITE_OK;
 break;
 }
 /*
 ** PRAGMA multiplex_enabled;
 **
 ** Return 0 or 1 depending on whether the multiplexor is enabled or
 ** disabled, respectively.
 */
 if( sqlite3_stricmp(aFcntl[1],"multiplex_enabled")==0 ){
 aFcntl[0] = sqlite3_mprintf("%d", pGroup->bEnabled!=0);
 rc = SQLITE_OK;
 break;
 }
 /*
 ** PRAGMA multiplex_chunksize;
 **
 ** Return the chunksize for the multiplexor, or no-op if the
 ** multiplexor is not active.
 */
 if( sqlite3_stricmp(aFcntl[1],"multiplex_chunksize")==0
 && pGroup->bEnabled
 ){
 aFcntl[0] = sqlite3_mprintf("%u", pGroup->szChunk);
 rc = SQLITE_OK;
 break;
 }
 /*
 ** PRAGMA multiplex_filecount;
 **
 ** Return the number of disk files currently in use by the
 ** multiplexor. This should be the total database size size
 ** divided by the chunksize and rounded up.
 */
 if( sqlite3_stricmp(aFcntl[1],"multiplex_filecount")==0 ){
 int n = 0;
 int ii;
 for(ii=0; ii<pGroup->nReal; ii++){
 if( pGroup->aReal[ii].p!=0 ) n++;
 }
 aFcntl[0] = sqlite3_mprintf("%d", n);
 rc = SQLITE_OK;
 break;
 }
 }
 /* If the multiplexor does not handle the pragma, pass it through
 ** into the default case. */
 }
 default:
 pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
 if( pSubOpen ){
 rc = pSubOpen->pMethods->xFileControl(pSubOpen, op, pArg);
 if( op==SQLITE_FCNTL_VFSNAME && rc==SQLITE_OK ){
 *(char**)pArg = sqlite3_mprintf("multiplex/%z", *(char**)pArg);
 }
 }
 break;
 }
 return rc;
}

/* Pass xSectorSize requests through to the original VFS unchanged.
*/
static int multiplexSectorSize(sqlite3_file *pConn){
 multiplexConn *p = (multiplexConn*)pConn;
 int rc;
 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
 if( pSubOpen && pSubOpen->pMethods->xSectorSize ){
 return pSubOpen->pMethods->xSectorSize(pSubOpen);
 }
 return DEFAULT_SECTOR_SIZE;
}

/* Pass xDeviceCharacteristics requests through to the original VFS unchanged.
*/
static int multiplexDeviceCharacteristics(sqlite3_file *pConn){
 multiplexConn *p = (multiplexConn*)pConn;
 int rc;
 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
 if( pSubOpen ){
 return pSubOpen->pMethods->xDeviceCharacteristics(pSubOpen);
 }
 return 0;
}

/* Pass xShmMap requests through to the original VFS unchanged.
*/
static int multiplexShmMap(
 sqlite3_file *pConn, /* Handle open on database file */
 int iRegion, /* Region to retrieve */
 int szRegion, /* Size of regions */
 int bExtend, /* True to extend file if necessary */
 void volatile **pp /* OUT: Mapped memory */
){
 multiplexConn *p = (multiplexConn*)pConn;
 int rc;
 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
 if( pSubOpen ){
 return pSubOpen->pMethods->xShmMap(pSubOpen, iRegion, szRegion, bExtend,pp);
 }
 return SQLITE_IOERR;
}

/* Pass xShmLock requests through to the original VFS unchanged.
*/
static int multiplexShmLock(
 sqlite3_file *pConn, /* Database file holding the shared memory */
 int ofst, /* First lock to acquire or release */
 int n, /* Number of locks to acquire or release */
 int flags /* What to do with the lock */
){
 multiplexConn *p = (multiplexConn*)pConn;
 int rc;
 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
 if( pSubOpen ){
 return pSubOpen->pMethods->xShmLock(pSubOpen, ofst, n, flags);
 }
 return SQLITE_BUSY;
}

/* Pass xShmBarrier requests through to the original VFS unchanged.
*/
static void multiplexShmBarrier(sqlite3_file *pConn){
 multiplexConn *p = (multiplexConn*)pConn;
 int rc;
 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
 if( pSubOpen ){
 pSubOpen->pMethods->xShmBarrier(pSubOpen);
 }
}

/* Pass xShmUnmap requests through to the original VFS unchanged.
*/
static int multiplexShmUnmap(sqlite3_file *pConn, int deleteFlag){
 multiplexConn *p = (multiplexConn*)pConn;
 int rc;
 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
 if( pSubOpen ){
 return pSubOpen->pMethods->xShmUnmap(pSubOpen, deleteFlag);
 }
 return SQLITE_OK;
}

/************************** Public Interfaces *****************************/
/*
** CAPI: Initialize the multiplex VFS shim - sqlite3_multiplex_initialize()
**
** Use the VFS named zOrigVfsName as the VFS that does the actual work.
** Use the default if zOrigVfsName==NULL.
**
** The multiplex VFS shim is named "multiplex". It will become the default
** VFS if makeDefault is non-zero.
**
** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly once
** during start-up.
*/
int sqlite3_multiplex_initialize(const char *zOrigVfsName, int makeDefault){
 sqlite3_vfs *pOrigVfs;
 if( gMultiplex.isInitialized ) return SQLITE_MISUSE;
 pOrigVfs = sqlite3_vfs_find(zOrigVfsName);
 if( pOrigVfs==0 ) return SQLITE_ERROR;
 assert( pOrigVfs!=&gMultiplex.sThisVfs );
 gMultiplex.isInitialized = 1;
 gMultiplex.pOrigVfs = pOrigVfs;
 gMultiplex.sThisVfs = *pOrigVfs;
 gMultiplex.sThisVfs.szOsFile += sizeof(multiplexConn);
 gMultiplex.sThisVfs.zName = SQLITE_MULTIPLEX_VFS_NAME;
 gMultiplex.sThisVfs.xOpen = multiplexOpen;
 gMultiplex.sThisVfs.xDelete = multiplexDelete;
 gMultiplex.sThisVfs.xAccess = multiplexAccess;
 gMultiplex.sThisVfs.xFullPathname = multiplexFullPathname;
 gMultiplex.sThisVfs.xDlOpen = multiplexDlOpen;
 gMultiplex.sThisVfs.xDlError = multiplexDlError;
 gMultiplex.sThisVfs.xDlSym = multiplexDlSym;
 gMultiplex.sThisVfs.xDlClose = multiplexDlClose;
 gMultiplex.sThisVfs.xRandomness = multiplexRandomness;
 gMultiplex.sThisVfs.xSleep = multiplexSleep;
 gMultiplex.sThisVfs.xCurrentTime = multiplexCurrentTime;
 gMultiplex.sThisVfs.xGetLastError = multiplexGetLastError;
 gMultiplex.sThisVfs.xCurrentTimeInt64 = multiplexCurrentTimeInt64;

 gMultiplex.sIoMethodsV1.iVersion = 1;
 gMultiplex.sIoMethodsV1.xClose = multiplexClose;
 gMultiplex.sIoMethodsV1.xRead = multiplexRead;
 gMultiplex.sIoMethodsV1.xWrite = multiplexWrite;
 gMultiplex.sIoMethodsV1.xTruncate = multiplexTruncate;
 gMultiplex.sIoMethodsV1.xSync = multiplexSync;
 gMultiplex.sIoMethodsV1.xFileSize = multiplexFileSize;
 gMultiplex.sIoMethodsV1.xLock = multiplexLock;
 gMultiplex.sIoMethodsV1.xUnlock = multiplexUnlock;
 gMultiplex.sIoMethodsV1.xCheckReservedLock = multiplexCheckReservedLock;
 gMultiplex.sIoMethodsV1.xFileControl = multiplexFileControl;
 gMultiplex.sIoMethodsV1.xSectorSize = multiplexSectorSize;
 gMultiplex.sIoMethodsV1.xDeviceCharacteristics =
 multiplexDeviceCharacteristics;
 gMultiplex.sIoMethodsV2 = gMultiplex.sIoMethodsV1;
 gMultiplex.sIoMethodsV2.iVersion = 2;
 gMultiplex.sIoMethodsV2.xShmMap = multiplexShmMap;
 gMultiplex.sIoMethodsV2.xShmLock = multiplexShmLock;
 gMultiplex.sIoMethodsV2.xShmBarrier = multiplexShmBarrier;
 gMultiplex.sIoMethodsV2.xShmUnmap = multiplexShmUnmap;
 sqlite3_vfs_register(&gMultiplex.sThisVfs, makeDefault);

 sqlite3_auto_extension((void(*)(void))multiplexFuncInit);

 return SQLITE_OK;
}

/*
** CAPI: Shutdown the multiplex system - sqlite3_multiplex_shutdown()
**
** All SQLite database connections must be closed before calling this
** routine.
**
** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly once while
** shutting down in order to free all remaining multiplex groups.
*/
int sqlite3_multiplex_shutdown(int eForce){
 int rc = SQLITE_OK;
 if( gMultiplex.isInitialized==0 ) return SQLITE_MISUSE;
 gMultiplex.isInitialized = 0;
 sqlite3_vfs_unregister(&gMultiplex.sThisVfs);
 memset(&gMultiplex, 0, sizeof(gMultiplex));
 return rc;
}

/***************************** Test Code ***********************************/
#ifdef SQLITE_TEST
#include "tclsqlite.h"
extern const char *sqlite3ErrName(int);


/*
** tclcmd: sqlite3_multiplex_initialize NAME MAKEDEFAULT
*/
static int SQLITE_TCLAPI test_multiplex_initialize(
 void * clientData,
 Tcl_Interp *interp,
 int objc,
 Tcl_Obj *CONST objv[]
){
 const char *zName; /* Name of new multiplex VFS */
 int makeDefault; /* True to make the new VFS the default */
 int rc; /* Value returned by multiplex_initialize() */

 UNUSED_PARAMETER(clientData);

 /* Process arguments */
 if( objc!=3 ){
 Tcl_WrongNumArgs(interp, 1, objv, "NAME MAKEDEFAULT");
 return TCL_ERROR;
 }
 zName = Tcl_GetString(objv[1]);
 if( Tcl_GetBooleanFromObj(interp, objv[2], &makeDefault) ) return TCL_ERROR;
 if( zName[0]=='0円' ) zName = 0;

 /* Call sqlite3_multiplex_initialize() */
 rc = sqlite3_multiplex_initialize(zName, makeDefault);
 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);

 return TCL_OK;
}

/*
** tclcmd: sqlite3_multiplex_shutdown
*/
static int SQLITE_TCLAPI test_multiplex_shutdown(
 void * clientData,
 Tcl_Interp *interp,
 int objc,
 Tcl_Obj *CONST objv[]
){
 int rc; /* Value returned by multiplex_shutdown() */

 UNUSED_PARAMETER(clientData);

 if( objc==2 && strcmp(Tcl_GetString(objv[1]),"-force")!=0 ){
 objc = 3;
 }
 if( (objc!=1 && objc!=2) ){
 Tcl_WrongNumArgs(interp, 1, objv, "?-force?");
 return TCL_ERROR;
 }

 /* Call sqlite3_multiplex_shutdown() */
 rc = sqlite3_multiplex_shutdown(objc==2);
 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);

 return TCL_OK;
}

/*
** Tclcmd: test_multiplex_control HANDLE DBNAME SUB-COMMAND ?INT-VALUE?
*/
static int SQLITE_TCLAPI test_multiplex_control(
 ClientData cd,
 Tcl_Interp *interp,
 int objc,
 Tcl_Obj *CONST objv[]
){
 int rc; /* Return code from file_control() */
 int idx; /* Index in aSub[] */
 Tcl_CmdInfo cmdInfo; /* Command info structure for HANDLE */
 sqlite3 *db; /* Underlying db handle for HANDLE */
 int iValue = 0;
 void *pArg = 0;

 struct SubCommand {
 const char *zName;
 int op;
 int argtype;
 } aSub[] = {
 { "enable", MULTIPLEX_CTRL_ENABLE, 1 },
 { "chunk_size", MULTIPLEX_CTRL_SET_CHUNK_SIZE, 1 },
 { "max_chunks", MULTIPLEX_CTRL_SET_MAX_CHUNKS, 1 },
 { 0, 0, 0 }
 };

 if( objc!=5 ){
 Tcl_WrongNumArgs(interp, 1, objv, "HANDLE DBNAME SUB-COMMAND INT-VALUE");
 return TCL_ERROR;
 }

 if( 0==Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){
 Tcl_AppendResult(interp, "expected database handle, got \"", NULL);
 Tcl_AppendResult(interp, Tcl_GetString(objv[1]), "\"", NULL);
 return TCL_ERROR;
 }else{
 db = *(sqlite3 **)cmdInfo.objClientData;
 }

 rc = Tcl_GetIndexFromObjStruct(
 interp, objv[3], aSub, sizeof(aSub[0]), "sub-command", 0, &idx
 );
 if( rc!=TCL_OK ) return rc;

 switch( aSub[idx].argtype ){
 case 1:
 if( Tcl_GetIntFromObj(interp, objv[4], &iValue) ){
 return TCL_ERROR;
 }
 pArg = (void *)&iValue;
 break;
 default:
 Tcl_WrongNumArgs(interp, 4, objv, "SUB-COMMAND");
 return TCL_ERROR;
 }

 rc = sqlite3_file_control(db, Tcl_GetString(objv[2]), aSub[idx].op, pArg);
 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
 return (rc==SQLITE_OK) ? TCL_OK : TCL_ERROR;
}

/*
** This routine registers the custom TCL commands defined in this
** module. This should be the only procedure visible from outside
** of this module.
*/
int Sqlitemultiplex_Init(Tcl_Interp *interp){
 static struct {
 char *zName;
 Tcl_ObjCmdProc *xProc;
 } aCmd[] = {
 { "sqlite3_multiplex_initialize", test_multiplex_initialize },
 { "sqlite3_multiplex_shutdown", test_multiplex_shutdown },
 { "sqlite3_multiplex_control", test_multiplex_control },
 };
 int i;

 for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
 Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
 }

 return TCL_OK;
}
#endif