| /* |
| ** 2010 September 31 |
| ** |
| ** 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. |
| ** |
| ** This particular shim enforces a quota system on files. One or more |
| ** database files are in a "quota group" that is defined by a GLOB |
| ** pattern. A quota is set for the combined size of all files in the |
| ** the group. A quota of zero means "no limit". If the total size |
| ** of all files in the quota group is greater than the limit, then |
| ** write requests that attempt to enlarge a file fail with SQLITE_FULL. |
| ** |
| ** However, before returning SQLITE_FULL, the write requests invoke |
| ** a callback function that is configurable for each quota group. |
| ** This callback has the opportunity to enlarge the quota. If the |
| ** callback does enlarge the quota such that the total size of all |
| ** files within the group is less than the new quota, then the write |
| ** continues as if nothing had happened. |
| */ |
| #include "test_quota.h" |
| #include <string.h> |
| #include <assert.h> |
| |
| /* |
| ** For an build without mutexes, no-op the mutex calls. |
| */ |
| #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE==0 |
| #define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8) |
| #define sqlite3_mutex_free(X) |
| #define sqlite3_mutex_enter(X) |
| #define sqlite3_mutex_try(X) SQLITE_OK |
| #define sqlite3_mutex_leave(X) |
| #define sqlite3_mutex_held(X) ((void)(X),1) |
| #define sqlite3_mutex_notheld(X) ((void)(X),1) |
| #endif /* SQLITE_THREADSAFE==0 */ |
| |
| #include "os_setup.h" |
| |
| #if SQLITE_OS_UNIX |
| # include <unistd.h> |
| #endif |
| #if SQLITE_OS_WIN |
| # include "os_win.h" |
| # include <io.h> |
| #endif |
| |
| |
| /************************ Object Definitions ******************************/ |
| |
| /* Forward declaration of all object types */ |
| typedef struct quotaGroup quotaGroup; |
| typedef struct quotaConn quotaConn; |
| typedef struct quotaFile quotaFile; |
| |
| /* |
| ** A "quota group" is a collection of files whose collective size we want |
| ** to limit. Each quota group is defined by a GLOB pattern. |
| ** |
| ** There is an instance of the following object for each defined quota |
| ** group. This object records the GLOB pattern that defines which files |
| ** belong to the quota group. The object also remembers the size limit |
| ** for the group (the quota) and the callback to be invoked when the |
| ** sum of the sizes of the files within the group goes over the limit. |
| ** |
| ** A quota group must be established (using sqlite3_quota_set(...)) |
| ** prior to opening any of the database connections that access files |
| ** within the quota group. |
| */ |
| struct quotaGroup { |
| const char *zPattern; /* Filename pattern to be quotaed */ |
| sqlite3_int64 iLimit; /* Upper bound on total file size */ |
| sqlite3_int64 iSize; /* Current size of all files */ |
| void (*xCallback)( /* Callback invoked when going over quota */ |
| const char *zFilename, /* Name of file whose size increases */ |
| sqlite3_int64 *piLimit, /* IN/OUT: The current limit */ |
| sqlite3_int64 iSize, /* Total size of all files in the group */ |
| void *pArg /* Client data */ |
| ); |
| void *pArg; /* Third argument to the xCallback() */ |
| void (*xDestroy)(void*); /* Optional destructor for pArg */ |
| quotaGroup *pNext, **ppPrev; /* Doubly linked list of all quota objects */ |
| quotaFile *pFiles; /* Files within this group */ |
| }; |
| |
| /* |
| ** An instance of this structure represents a single file that is part |
| ** of a quota group. A single file can be opened multiple times. In |
| ** order keep multiple openings of the same file from causing the size |
| ** of the file to count against the quota multiple times, each file |
| ** has a unique instance of this object and multiple open connections |
| ** to the same file each point to a single instance of this object. |
| */ |
| struct quotaFile { |
| char *zFilename; /* Name of this file */ |
| quotaGroup *pGroup; /* Quota group to which this file belongs */ |
| sqlite3_int64 iSize; /* Current size of this file */ |
| int nRef; /* Number of times this file is open */ |
| int deleteOnClose; /* True to delete this file when it closes */ |
| quotaFile *pNext, **ppPrev; /* Linked list of files in the same group */ |
| }; |
| |
| /* |
| ** An instance of the following object represents each open connection |
| ** to a file that participates in quota tracking. This object is a |
| ** subclass of sqlite3_file. The sqlite3_file object for the underlying |
| ** VFS is appended to this structure. |
| */ |
| struct quotaConn { |
| sqlite3_file base; /* Base class - must be first */ |
| quotaFile *pFile; /* The underlying file */ |
| /* The underlying VFS sqlite3_file is appended to this object */ |
| }; |
| |
| /* |
| ** An instance of the following object records the state of an |
| ** open file. This object is opaque to all users - the internal |
| ** structure is only visible to the functions below. |
| */ |
| struct quota_FILE { |
| FILE *f; /* Open stdio file pointer */ |
| sqlite3_int64 iOfst; /* Current offset into the file */ |
| quotaFile *pFile; /* The file record in the quota system */ |
| #if SQLITE_OS_WIN |
| char *zMbcsName; /* Full MBCS pathname of the file */ |
| #endif |
| }; |
| |
| |
| /************************* Global Variables **********************************/ |
| /* |
| ** All global variables used by this file are containing within the following |
| ** gQuota 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 as been initialized. |
| */ |
| int isInitialized; |
| |
| /* For run-time access any of the other global data structures in this |
| ** shim, the following mutex must be held. |
| */ |
| sqlite3_mutex *pMutex; |
| |
| /* List of quotaGroup objects. |
| */ |
| quotaGroup *pGroup; |
| |
| } gQuota; |
| |
| /************************* Utility Routines *********************************/ |
| /* |
| ** Acquire and release the mutex used to serialize access to the |
| ** list of quotaGroups. |
| */ |
| static void quotaEnter(void){ sqlite3_mutex_enter(gQuota.pMutex); } |
| static void quotaLeave(void){ sqlite3_mutex_leave(gQuota.pMutex); } |
| |
| /* Count the number of open files in a quotaGroup |
| */ |
| static int quotaGroupOpenFileCount(quotaGroup *pGroup){ |
| int N = 0; |
| quotaFile *pFile = pGroup->pFiles; |
| while( pFile ){ |
| if( pFile->nRef ) N++; |
| pFile = pFile->pNext; |
| } |
| return N; |
| } |
| |
| /* Remove a file from a quota group. |
| */ |
| static void quotaRemoveFile(quotaFile *pFile){ |
| quotaGroup *pGroup = pFile->pGroup; |
| pGroup->iSize -= pFile->iSize; |
| *pFile->ppPrev = pFile->pNext; |
| if( pFile->pNext ) pFile->pNext->ppPrev = pFile->ppPrev; |
| sqlite3_free(pFile); |
| } |
| |
| /* Remove all files from a quota group. It is always the case that |
| ** all files will be closed when this routine is called. |
| */ |
| static void quotaRemoveAllFiles(quotaGroup *pGroup){ |
| while( pGroup->pFiles ){ |
| assert( pGroup->pFiles->nRef==0 ); |
| quotaRemoveFile(pGroup->pFiles); |
| } |
| } |
| |
| |
| /* If the reference count and threshold for a quotaGroup are both |
| ** zero, then destroy the quotaGroup. |
| */ |
| static void quotaGroupDeref(quotaGroup *pGroup){ |
| if( pGroup->iLimit==0 && quotaGroupOpenFileCount(pGroup)==0 ){ |
| quotaRemoveAllFiles(pGroup); |
| *pGroup->ppPrev = pGroup->pNext; |
| if( pGroup->pNext ) pGroup->pNext->ppPrev = pGroup->ppPrev; |
| if( pGroup->xDestroy ) pGroup->xDestroy(pGroup->pArg); |
| sqlite3_free(pGroup); |
| } |
| } |
| |
| /* |
| ** Return TRUE if string z matches glob pattern zGlob. |
| ** |
| ** Globbing rules: |
| ** |
| ** '*' Matches any sequence of zero or more characters. |
| ** |
| ** '?' Matches exactly one character. |
| ** |
| ** [...] Matches one character from the enclosed list of |
| ** characters. |
| ** |
| ** [^...] Matches one character not in the enclosed list. |
| ** |
| ** / Matches "/" or "\\" |
| ** |
| */ |
| static int quotaStrglob(const char *zGlob, const char *z){ |
| int c, c2, cx; |
| int invert; |
| int seen; |
| |
| while( (c = (*(zGlob++)))!=0 ){ |
| if( c=='*' ){ |
| while( (c=(*(zGlob++))) == '*' || c=='?' ){ |
| if( c=='?' && (*(z++))==0 ) return 0; |
| } |
| if( c==0 ){ |
| return 1; |
| }else if( c=='[' ){ |
| while( *z && quotaStrglob(zGlob-1,z)==0 ){ |
| z++; |
| } |
| return (*z)!=0; |
| } |
| cx = (c=='/') ? '\\' : c; |
| while( (c2 = (*(z++)))!=0 ){ |
| while( c2!=c && c2!=cx ){ |
| c2 = *(z++); |
| if( c2==0 ) return 0; |
| } |
| if( quotaStrglob(zGlob,z) ) return 1; |
| } |
| return 0; |
| }else if( c=='?' ){ |
| if( (*(z++))==0 ) return 0; |
| }else if( c=='[' ){ |
| int prior_c = 0; |
| seen = 0; |
| invert = 0; |
| c = *(z++); |
| if( c==0 ) return 0; |
| c2 = *(zGlob++); |
| if( c2=='^' ){ |
| invert = 1; |
| c2 = *(zGlob++); |
| } |
| if( c2==']' ){ |
| if( c==']' ) seen = 1; |
| c2 = *(zGlob++); |
| } |
| while( c2 && c2!=']' ){ |
| if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){ |
| c2 = *(zGlob++); |
| if( c>=prior_c && c<=c2 ) seen = 1; |
| prior_c = 0; |
| }else{ |
| if( c==c2 ){ |
| seen = 1; |
| } |
| prior_c = c2; |
| } |
| c2 = *(zGlob++); |
| } |
| if( c2==0 || (seen ^ invert)==0 ) return 0; |
| }else if( c=='/' ){ |
| if( z[0]!='/' && z[0]!='\\' ) return 0; |
| z++; |
| }else{ |
| if( c!=(*(z++)) ) return 0; |
| } |
| } |
| return *z==0; |
| } |
| |
| |
| /* Find a quotaGroup given the filename. |
| ** |
| ** Return a pointer to the quotaGroup object. Return NULL if not found. |
| */ |
| static quotaGroup *quotaGroupFind(const char *zFilename){ |
| quotaGroup *p; |
| for(p=gQuota.pGroup; p && quotaStrglob(p->zPattern, zFilename)==0; |
| p=p->pNext){} |
| return p; |
| } |
| |
| /* Translate an sqlite3_file* that is really a quotaConn* into |
| ** the sqlite3_file* for the underlying original VFS. |
| */ |
| static sqlite3_file *quotaSubOpen(sqlite3_file *pConn){ |
| quotaConn *p = (quotaConn*)pConn; |
| return (sqlite3_file*)&p[1]; |
| } |
| |
| /* Find a file in a quota group and return a pointer to that file. |
| ** Return NULL if the file is not in the group. |
| */ |
| static quotaFile *quotaFindFile( |
| quotaGroup *pGroup, /* Group in which to look for the file */ |
| const char *zName, /* Full pathname of the file */ |
| int createFlag /* Try to create the file if not found */ |
| ){ |
| quotaFile *pFile = pGroup->pFiles; |
| while( pFile && strcmp(pFile->zFilename, zName)!=0 ){ |
| pFile = pFile->pNext; |
| } |
| if( pFile==0 && createFlag ){ |
| int nName = (int)(strlen(zName) & 0x3fffffff); |
| pFile = (quotaFile *)sqlite3_malloc( sizeof(*pFile) + nName + 1 ); |
| if( pFile ){ |
| memset(pFile, 0, sizeof(*pFile)); |
| pFile->zFilename = (char*)&pFile[1]; |
| memcpy(pFile->zFilename, zName, nName+1); |
| pFile->pNext = pGroup->pFiles; |
| if( pGroup->pFiles ) pGroup->pFiles->ppPrev = &pFile->pNext; |
| pFile->ppPrev = &pGroup->pFiles; |
| pGroup->pFiles = pFile; |
| pFile->pGroup = pGroup; |
| } |
| } |
| return pFile; |
| } |
| /* |
| ** Translate UTF8 to MBCS for use in fopen() calls. Return a pointer to the |
| ** translated text.. Call quota_mbcs_free() to deallocate any memory |
| ** used to store the returned pointer when done. |
| */ |
| static char *quota_utf8_to_mbcs(const char *zUtf8){ |
| #if SQLITE_OS_WIN |
| size_t n; /* Bytes in zUtf8 */ |
| int nWide; /* number of UTF-16 characters */ |
| int nMbcs; /* Bytes of MBCS */ |
| LPWSTR zTmpWide; /* The UTF16 text */ |
| char *zMbcs; /* The MBCS text */ |
| int codepage; /* Code page used by fopen() */ |
| |
| n = strlen(zUtf8); |
| nWide = MultiByteToWideChar(CP_UTF8, 0, zUtf8, -1, NULL, 0); |
| if( nWide==0 ) return 0; |
| zTmpWide = (LPWSTR)sqlite3_malloc( (nWide+1)*sizeof(zTmpWide[0]) ); |
| if( zTmpWide==0 ) return 0; |
| MultiByteToWideChar(CP_UTF8, 0, zUtf8, -1, zTmpWide, nWide); |
| codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP; |
| nMbcs = WideCharToMultiByte(codepage, 0, zTmpWide, nWide, 0, 0, 0, 0); |
| zMbcs = nMbcs ? (char*)sqlite3_malloc( nMbcs+1 ) : 0; |
| if( zMbcs ){ |
| WideCharToMultiByte(codepage, 0, zTmpWide, nWide, zMbcs, nMbcs, 0, 0); |
| } |
| sqlite3_free(zTmpWide); |
| return zMbcs; |
| #else |
| return (char*)zUtf8; /* No-op on unix */ |
| #endif |
| } |
| |
| /* |
| ** Deallocate any memory allocated by quota_utf8_to_mbcs(). |
| */ |
| static void quota_mbcs_free(char *zOld){ |
| #if SQLITE_OS_WIN |
| sqlite3_free(zOld); |
| #else |
| /* No-op on unix */ |
| #endif |
| } |
| |
| /************************* VFS Method Wrappers *****************************/ |
| /* |
| ** This is the xOpen method used for the "quota" VFS. |
| ** |
| ** Most of the work is done by the underlying original VFS. This method |
| ** simply links the new file into the appropriate quota group if it is a |
| ** file that needs to be tracked. |
| */ |
| static int quotaOpen( |
| sqlite3_vfs *pVfs, /* The quota 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; /* Result code */ |
| quotaConn *pQuotaOpen; /* The new quota file descriptor */ |
| quotaFile *pFile; /* Corresponding quotaFile obj */ |
| quotaGroup *pGroup; /* The group file belongs to */ |
| sqlite3_file *pSubOpen; /* Real file descriptor */ |
| sqlite3_vfs *pOrigVfs = gQuota.pOrigVfs; /* Real VFS */ |
| |
| /* If the file is not a main database file or a WAL, then use the |
| ** normal xOpen method. |
| */ |
| if( (flags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_WAL))==0 ){ |
| return pOrigVfs->xOpen(pOrigVfs, zName, pConn, flags, pOutFlags); |
| } |
| |
| /* If the name of the file does not match any quota group, then |
| ** use the normal xOpen method. |
| */ |
| quotaEnter(); |
| pGroup = quotaGroupFind(zName); |
| if( pGroup==0 ){ |
| rc = pOrigVfs->xOpen(pOrigVfs, zName, pConn, flags, pOutFlags); |
| }else{ |
| /* If we get to this point, it means the file needs to be quota tracked. |
| */ |
| pQuotaOpen = (quotaConn*)pConn; |
| pSubOpen = quotaSubOpen(pConn); |
| rc = pOrigVfs->xOpen(pOrigVfs, zName, pSubOpen, flags, pOutFlags); |
| if( rc==SQLITE_OK ){ |
| pFile = quotaFindFile(pGroup, zName, 1); |
| if( pFile==0 ){ |
| quotaLeave(); |
| pSubOpen->pMethods->xClose(pSubOpen); |
| return SQLITE_NOMEM; |
| } |
| pFile->deleteOnClose = (flags & SQLITE_OPEN_DELETEONCLOSE)!=0; |
| pFile->nRef++; |
| pQuotaOpen->pFile = pFile; |
| if( pSubOpen->pMethods->iVersion==1 ){ |
| pQuotaOpen->base.pMethods = &gQuota.sIoMethodsV1; |
| }else{ |
| pQuotaOpen->base.pMethods = &gQuota.sIoMethodsV2; |
| } |
| } |
| } |
| quotaLeave(); |
| return rc; |
| } |
| |
| /* |
| ** This is the xDelete method used for the "quota" VFS. |
| ** |
| ** If the file being deleted is part of the quota group, then reduce |
| ** the size of the quota group accordingly. And remove the file from |
| ** the set of files in the quota group. |
| */ |
| static int quotaDelete( |
| sqlite3_vfs *pVfs, /* The quota VFS */ |
| const char *zName, /* Name of file to be deleted */ |
| int syncDir /* Do a directory sync after deleting */ |
| ){ |
| int rc; /* Result code */ |
| quotaFile *pFile; /* Files in the quota */ |
| quotaGroup *pGroup; /* The group file belongs to */ |
| sqlite3_vfs *pOrigVfs = gQuota.pOrigVfs; /* Real VFS */ |
| |
| /* Do the actual file delete */ |
| rc = pOrigVfs->xDelete(pOrigVfs, zName, syncDir); |
| |
| /* If the file just deleted is a member of a quota group, then remove |
| ** it from that quota group. |
| */ |
| if( rc==SQLITE_OK ){ |
| quotaEnter(); |
| pGroup = quotaGroupFind(zName); |
| if( pGroup ){ |
| pFile = quotaFindFile(pGroup, zName, 0); |
| if( pFile ){ |
| if( pFile->nRef ){ |
| pFile->deleteOnClose = 1; |
| }else{ |
| quotaRemoveFile(pFile); |
| quotaGroupDeref(pGroup); |
| } |
| } |
| } |
| quotaLeave(); |
| } |
| return rc; |
| } |
| |
| |
| /************************ I/O Method Wrappers *******************************/ |
| |
| /* xClose requests get passed through to the original VFS. But we |
| ** also have to unlink the quotaConn from the quotaFile and quotaGroup. |
| ** The quotaFile and/or quotaGroup are freed if they are no longer in use. |
| */ |
| static int quotaClose(sqlite3_file *pConn){ |
| quotaConn *p = (quotaConn*)pConn; |
| quotaFile *pFile = p->pFile; |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| int rc; |
| rc = pSubOpen->pMethods->xClose(pSubOpen); |
| quotaEnter(); |
| pFile->nRef--; |
| if( pFile->nRef==0 ){ |
| quotaGroup *pGroup = pFile->pGroup; |
| if( pFile->deleteOnClose ){ |
| gQuota.pOrigVfs->xDelete(gQuota.pOrigVfs, pFile->zFilename, 0); |
| quotaRemoveFile(pFile); |
| } |
| quotaGroupDeref(pGroup); |
| } |
| quotaLeave(); |
| return rc; |
| } |
| |
| /* Pass xRead requests directory thru to the original VFS without |
| ** further processing. |
| */ |
| static int quotaRead( |
| sqlite3_file *pConn, |
| void *pBuf, |
| int iAmt, |
| sqlite3_int64 iOfst |
| ){ |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| return pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, iOfst); |
| } |
| |
| /* Check xWrite requests to see if they expand the file. If they do, |
| ** the perform a quota check before passing them through to the |
| ** original VFS. |
| */ |
| static int quotaWrite( |
| sqlite3_file *pConn, |
| const void *pBuf, |
| int iAmt, |
| sqlite3_int64 iOfst |
| ){ |
| quotaConn *p = (quotaConn*)pConn; |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| sqlite3_int64 iEnd = iOfst+iAmt; |
| quotaGroup *pGroup; |
| quotaFile *pFile = p->pFile; |
| sqlite3_int64 szNew; |
| |
| if( pFile->iSize<iEnd ){ |
| pGroup = pFile->pGroup; |
| quotaEnter(); |
| szNew = pGroup->iSize - pFile->iSize + iEnd; |
| if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){ |
| if( pGroup->xCallback ){ |
| pGroup->xCallback(pFile->zFilename, &pGroup->iLimit, szNew, |
| pGroup->pArg); |
| } |
| if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){ |
| quotaLeave(); |
| return SQLITE_FULL; |
| } |
| } |
| pGroup->iSize = szNew; |
| pFile->iSize = iEnd; |
| quotaLeave(); |
| } |
| return pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, iOfst); |
| } |
| |
| /* Pass xTruncate requests thru to the original VFS. If the |
| ** success, update the file size. |
| */ |
| static int quotaTruncate(sqlite3_file *pConn, sqlite3_int64 size){ |
| quotaConn *p = (quotaConn*)pConn; |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| int rc = pSubOpen->pMethods->xTruncate(pSubOpen, size); |
| quotaFile *pFile = p->pFile; |
| quotaGroup *pGroup; |
| if( rc==SQLITE_OK ){ |
| quotaEnter(); |
| pGroup = pFile->pGroup; |
| pGroup->iSize -= pFile->iSize; |
| pFile->iSize = size; |
| pGroup->iSize += size; |
| quotaLeave(); |
| } |
| return rc; |
| } |
| |
| /* Pass xSync requests through to the original VFS without change |
| */ |
| static int quotaSync(sqlite3_file *pConn, int flags){ |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| return pSubOpen->pMethods->xSync(pSubOpen, flags); |
| } |
| |
| /* Pass xFileSize requests through to the original VFS but then |
| ** update the quotaGroup with the new size before returning. |
| */ |
| static int quotaFileSize(sqlite3_file *pConn, sqlite3_int64 *pSize){ |
| quotaConn *p = (quotaConn*)pConn; |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| quotaFile *pFile = p->pFile; |
| quotaGroup *pGroup; |
| sqlite3_int64 sz; |
| int rc; |
| |
| rc = pSubOpen->pMethods->xFileSize(pSubOpen, &sz); |
| if( rc==SQLITE_OK ){ |
| quotaEnter(); |
| pGroup = pFile->pGroup; |
| pGroup->iSize -= pFile->iSize; |
| pFile->iSize = sz; |
| pGroup->iSize += sz; |
| quotaLeave(); |
| *pSize = sz; |
| } |
| return rc; |
| } |
| |
| /* Pass xLock requests through to the original VFS unchanged. |
| */ |
| static int quotaLock(sqlite3_file *pConn, int lock){ |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| return pSubOpen->pMethods->xLock(pSubOpen, lock); |
| } |
| |
| /* Pass xUnlock requests through to the original VFS unchanged. |
| */ |
| static int quotaUnlock(sqlite3_file *pConn, int lock){ |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| return pSubOpen->pMethods->xUnlock(pSubOpen, lock); |
| } |
| |
| /* Pass xCheckReservedLock requests through to the original VFS unchanged. |
| */ |
| static int quotaCheckReservedLock(sqlite3_file *pConn, int *pResOut){ |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| return pSubOpen->pMethods->xCheckReservedLock(pSubOpen, pResOut); |
| } |
| |
| /* Pass xFileControl requests through to the original VFS unchanged. |
| */ |
| static int quotaFileControl(sqlite3_file *pConn, int op, void *pArg){ |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| int rc = pSubOpen->pMethods->xFileControl(pSubOpen, op, pArg); |
| #if defined(SQLITE_FCNTL_VFSNAME) |
| if( op==SQLITE_FCNTL_VFSNAME && rc==SQLITE_OK ){ |
| *(char**)pArg = sqlite3_mprintf("quota/%z", *(char**)pArg); |
| } |
| #endif |
| return rc; |
| } |
| |
| /* Pass xSectorSize requests through to the original VFS unchanged. |
| */ |
| static int quotaSectorSize(sqlite3_file *pConn){ |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| return pSubOpen->pMethods->xSectorSize(pSubOpen); |
| } |
| |
| /* Pass xDeviceCharacteristics requests through to the original VFS unchanged. |
| */ |
| static int quotaDeviceCharacteristics(sqlite3_file *pConn){ |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| return pSubOpen->pMethods->xDeviceCharacteristics(pSubOpen); |
| } |
| |
| /* Pass xShmMap requests through to the original VFS unchanged. |
| */ |
| static int quotaShmMap( |
| 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 */ |
| ){ |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| return pSubOpen->pMethods->xShmMap(pSubOpen, iRegion, szRegion, bExtend, pp); |
| } |
| |
| /* Pass xShmLock requests through to the original VFS unchanged. |
| */ |
| static int quotaShmLock( |
| 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 */ |
| ){ |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| return pSubOpen->pMethods->xShmLock(pSubOpen, ofst, n, flags); |
| } |
| |
| /* Pass xShmBarrier requests through to the original VFS unchanged. |
| */ |
| static void quotaShmBarrier(sqlite3_file *pConn){ |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| pSubOpen->pMethods->xShmBarrier(pSubOpen); |
| } |
| |
| /* Pass xShmUnmap requests through to the original VFS unchanged. |
| */ |
| static int quotaShmUnmap(sqlite3_file *pConn, int deleteFlag){ |
| sqlite3_file *pSubOpen = quotaSubOpen(pConn); |
| return pSubOpen->pMethods->xShmUnmap(pSubOpen, deleteFlag); |
| } |
| |
| /************************** Public Interfaces *****************************/ |
| /* |
| ** Initialize the quota VFS shim. Use the VFS named zOrigVfsName |
| ** as the VFS that does the actual work. Use the default if |
| ** zOrigVfsName==NULL. |
| ** |
| ** The quota VFS shim is named "quota". 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_quota_initialize(const char *zOrigVfsName, int makeDefault){ |
| sqlite3_vfs *pOrigVfs; |
| if( gQuota.isInitialized ) return SQLITE_MISUSE; |
| pOrigVfs = sqlite3_vfs_find(zOrigVfsName); |
| if( pOrigVfs==0 ) return SQLITE_ERROR; |
| assert( pOrigVfs!=&gQuota.sThisVfs ); |
| gQuota.pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); |
| if( !gQuota.pMutex ){ |
| return SQLITE_NOMEM; |
| } |
| gQuota.isInitialized = 1; |
| gQuota.pOrigVfs = pOrigVfs; |
| gQuota.sThisVfs = *pOrigVfs; |
| gQuota.sThisVfs.xOpen = quotaOpen; |
| gQuota.sThisVfs.xDelete = quotaDelete; |
| gQuota.sThisVfs.szOsFile += sizeof(quotaConn); |
| gQuota.sThisVfs.zName = "quota"; |
| gQuota.sIoMethodsV1.iVersion = 1; |
| gQuota.sIoMethodsV1.xClose = quotaClose; |
| gQuota.sIoMethodsV1.xRead = quotaRead; |
| gQuota.sIoMethodsV1.xWrite = quotaWrite; |
| gQuota.sIoMethodsV1.xTruncate = quotaTruncate; |
| gQuota.sIoMethodsV1.xSync = quotaSync; |
| gQuota.sIoMethodsV1.xFileSize = quotaFileSize; |
| gQuota.sIoMethodsV1.xLock = quotaLock; |
| gQuota.sIoMethodsV1.xUnlock = quotaUnlock; |
| gQuota.sIoMethodsV1.xCheckReservedLock = quotaCheckReservedLock; |
| gQuota.sIoMethodsV1.xFileControl = quotaFileControl; |
| gQuota.sIoMethodsV1.xSectorSize = quotaSectorSize; |
| gQuota.sIoMethodsV1.xDeviceCharacteristics = quotaDeviceCharacteristics; |
| gQuota.sIoMethodsV2 = gQuota.sIoMethodsV1; |
| gQuota.sIoMethodsV2.iVersion = 2; |
| gQuota.sIoMethodsV2.xShmMap = quotaShmMap; |
| gQuota.sIoMethodsV2.xShmLock = quotaShmLock; |
| gQuota.sIoMethodsV2.xShmBarrier = quotaShmBarrier; |
| gQuota.sIoMethodsV2.xShmUnmap = quotaShmUnmap; |
| sqlite3_vfs_register(&gQuota.sThisVfs, makeDefault); |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Shutdown the quota system. |
| ** |
| ** 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 quota groups. |
| */ |
| int sqlite3_quota_shutdown(void){ |
| quotaGroup *pGroup; |
| if( gQuota.isInitialized==0 ) return SQLITE_MISUSE; |
| for(pGroup=gQuota.pGroup; pGroup; pGroup=pGroup->pNext){ |
| if( quotaGroupOpenFileCount(pGroup)>0 ) return SQLITE_MISUSE; |
| } |
| while( gQuota.pGroup ){ |
| pGroup = gQuota.pGroup; |
| gQuota.pGroup = pGroup->pNext; |
| pGroup->iLimit = 0; |
| assert( quotaGroupOpenFileCount(pGroup)==0 ); |
| quotaGroupDeref(pGroup); |
| } |
| gQuota.isInitialized = 0; |
| sqlite3_mutex_free(gQuota.pMutex); |
| sqlite3_vfs_unregister(&gQuota.sThisVfs); |
| memset(&gQuota, 0, sizeof(gQuota)); |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Create or destroy a quota group. |
| ** |
| ** The quota group is defined by the zPattern. When calling this routine |
| ** with a zPattern for a quota group that already exists, this routine |
| ** merely updates the iLimit, xCallback, and pArg values for that quota |
| ** group. If zPattern is new, then a new quota group is created. |
| ** |
| ** If the iLimit for a quota group is set to zero, then the quota group |
| ** is disabled and will be deleted when the last database connection using |
| ** the quota group is closed. |
| ** |
| ** Calling this routine on a zPattern that does not exist and with a |
| ** zero iLimit is a no-op. |
| ** |
| ** A quota group must exist with a non-zero iLimit prior to opening |
| ** database connections if those connections are to participate in the |
| ** quota group. Creating a quota group does not affect database connections |
| ** that are already open. |
| */ |
| int sqlite3_quota_set( |
| const char *zPattern, /* The filename pattern */ |
| sqlite3_int64 iLimit, /* New quota to set for this quota group */ |
| void (*xCallback)( /* Callback invoked when going over quota */ |
| const char *zFilename, /* Name of file whose size increases */ |
| sqlite3_int64 *piLimit, /* IN/OUT: The current limit */ |
| sqlite3_int64 iSize, /* Total size of all files in the group */ |
| void *pArg /* Client data */ |
| ), |
| void *pArg, /* client data passed thru to callback */ |
| void (*xDestroy)(void*) /* Optional destructor for pArg */ |
| ){ |
| quotaGroup *pGroup; |
| quotaEnter(); |
| pGroup = gQuota.pGroup; |
| while( pGroup && strcmp(pGroup->zPattern, zPattern)!=0 ){ |
| pGroup = pGroup->pNext; |
| } |
| if( pGroup==0 ){ |
| int nPattern = (int)(strlen(zPattern) & 0x3fffffff); |
| if( iLimit<=0 ){ |
| quotaLeave(); |
| return SQLITE_OK; |
| } |
| pGroup = (quotaGroup *)sqlite3_malloc( sizeof(*pGroup) + nPattern + 1 ); |
| if( pGroup==0 ){ |
| quotaLeave(); |
| return SQLITE_NOMEM; |
| } |
| memset(pGroup, 0, sizeof(*pGroup)); |
| pGroup->zPattern = (char*)&pGroup[1]; |
| memcpy((char *)pGroup->zPattern, zPattern, nPattern+1); |
| if( gQuota.pGroup ) gQuota.pGroup->ppPrev = &pGroup->pNext; |
| pGroup->pNext = gQuota.pGroup; |
| pGroup->ppPrev = &gQuota.pGroup; |
| gQuota.pGroup = pGroup; |
| } |
| pGroup->iLimit = iLimit; |
| pGroup->xCallback = xCallback; |
| if( pGroup->xDestroy && pGroup->pArg!=pArg ){ |
| pGroup->xDestroy(pGroup->pArg); |
| } |
| pGroup->pArg = pArg; |
| pGroup->xDestroy = xDestroy; |
| quotaGroupDeref(pGroup); |
| quotaLeave(); |
| return SQLITE_OK; |
| } |
| |
| /* |
| ** Bring the named file under quota management. Or if it is already under |
| ** management, update its size. |
| */ |
| int sqlite3_quota_file(const char *zFilename){ |
| char *zFull = 0; |
| sqlite3_file *fd; |
| int rc; |
| int outFlags = 0; |
| sqlite3_int64 iSize; |
| int nAlloc = gQuota.sThisVfs.szOsFile + gQuota.sThisVfs.mxPathname+2; |
| |
| /* Allocate space for a file-handle and the full path for file zFilename */ |
| fd = (sqlite3_file *)sqlite3_malloc(nAlloc); |
| if( fd==0 ){ |
| rc = SQLITE_NOMEM; |
| }else{ |
| zFull = &((char *)fd)[gQuota.sThisVfs.szOsFile]; |
| rc = gQuota.pOrigVfs->xFullPathname(gQuota.pOrigVfs, zFilename, |
| gQuota.sThisVfs.mxPathname+1, zFull); |
| } |
| |
| if( rc==SQLITE_OK ){ |
| zFull[strlen(zFull)+1] = '\0'; |
| rc = quotaOpen(&gQuota.sThisVfs, zFull, fd, |
| SQLITE_OPEN_READONLY | SQLITE_OPEN_MAIN_DB, &outFlags); |
| if( rc==SQLITE_OK ){ |
| fd->pMethods->xFileSize(fd, &iSize); |
| fd->pMethods->xClose(fd); |
| }else if( rc==SQLITE_CANTOPEN ){ |
| quotaGroup *pGroup; |
| quotaFile *pFile; |
| quotaEnter(); |
| pGroup = quotaGroupFind(zFull); |
| if( pGroup ){ |
| pFile = quotaFindFile(pGroup, zFull, 0); |
| if( pFile ) quotaRemoveFile(pFile); |
| } |
| quotaLeave(); |
| } |
| } |
| |
| sqlite3_free(fd); |
| return rc; |
| } |
| |
| /* |
| ** Open a potentially quotaed file for I/O. |
| */ |
| quota_FILE *sqlite3_quota_fopen(const char *zFilename, const char *zMode){ |
| quota_FILE *p = 0; |
| char *zFull = 0; |
| char *zFullTranslated = 0; |
| int rc; |
| quotaGroup *pGroup; |
| quotaFile *pFile; |
| |
| zFull = (char*)sqlite3_malloc(gQuota.sThisVfs.mxPathname + 1); |
| if( zFull==0 ) return 0; |
| rc = gQuota.pOrigVfs->xFullPathname(gQuota.pOrigVfs, zFilename, |
| gQuota.sThisVfs.mxPathname+1, zFull); |
| if( rc ) goto quota_fopen_error; |
| p = (quota_FILE*)sqlite3_malloc(sizeof(*p)); |
| if( p==0 ) goto quota_fopen_error; |
| memset(p, 0, sizeof(*p)); |
| zFullTranslated = quota_utf8_to_mbcs(zFull); |
| if( zFullTranslated==0 ) goto quota_fopen_error; |
| p->f = fopen(zFullTranslated, zMode); |
| if( p->f==0 ) goto quota_fopen_error; |
| quotaEnter(); |
| pGroup = quotaGroupFind(zFull); |
| if( pGroup ){ |
| pFile = quotaFindFile(pGroup, zFull, 1); |
| if( pFile==0 ){ |
| quotaLeave(); |
| goto quota_fopen_error; |
| } |
| pFile->nRef++; |
| p->pFile = pFile; |
| } |
| quotaLeave(); |
| sqlite3_free(zFull); |
| #if SQLITE_OS_WIN |
| p->zMbcsName = zFullTranslated; |
| #endif |
| return p; |
| |
| quota_fopen_error: |
| quota_mbcs_free(zFullTranslated); |
| sqlite3_free(zFull); |
| if( p && p->f ) fclose(p->f); |
| sqlite3_free(p); |
| return 0; |
| } |
| |
| /* |
| ** Read content from a quota_FILE |
| */ |
| size_t sqlite3_quota_fread( |
| void *pBuf, /* Store the content here */ |
| size_t size, /* Size of each element */ |
| size_t nmemb, /* Number of elements to read */ |
| quota_FILE *p /* Read from this quota_FILE object */ |
| ){ |
| return fread(pBuf, size, nmemb, p->f); |
| } |
| |
| /* |
| ** Write content into a quota_FILE. Invoke the quota callback and block |
| ** the write if we exceed quota. |
| */ |
| size_t sqlite3_quota_fwrite( |
| const void *pBuf, /* Take content to write from here */ |
| size_t size, /* Size of each element */ |
| size_t nmemb, /* Number of elements */ |
| quota_FILE *p /* Write to this quota_FILE objecct */ |
| ){ |
| sqlite3_int64 iOfst; |
| sqlite3_int64 iEnd; |
| sqlite3_int64 szNew; |
| quotaFile *pFile; |
| size_t rc; |
| |
| iOfst = ftell(p->f); |
| iEnd = iOfst + size*nmemb; |
| pFile = p->pFile; |
| if( pFile && pFile->iSize<iEnd ){ |
| quotaGroup *pGroup = pFile->pGroup; |
| quotaEnter(); |
| szNew = pGroup->iSize - pFile->iSize + iEnd; |
| if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){ |
| if( pGroup->xCallback ){ |
| pGroup->xCallback(pFile->zFilename, &pGroup->iLimit, szNew, |
| pGroup->pArg); |
| } |
| if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){ |
| iEnd = pGroup->iLimit - pGroup->iSize + pFile->iSize; |
| nmemb = (size_t)((iEnd - iOfst)/size); |
| iEnd = iOfst + size*nmemb; |
| szNew = pGroup->iSize - pFile->iSize + iEnd; |
| } |
| } |
| pGroup->iSize = szNew; |
| pFile->iSize = iEnd; |
| quotaLeave(); |
| }else{ |
| pFile = 0; |
| } |
| rc = fwrite(pBuf, size, nmemb, p->f); |
| |
| /* If the write was incomplete, adjust the file size and group size |
| ** downward */ |
| if( rc<nmemb && pFile ){ |
| size_t nWritten = rc; |
| sqlite3_int64 iNewEnd = iOfst + size*nWritten; |
| if( iNewEnd<iEnd ) iNewEnd = iEnd; |
| quotaEnter(); |
| pFile->pGroup->iSize += iNewEnd - pFile->iSize; |
| pFile->iSize = iNewEnd; |
| quotaLeave(); |
| } |
| return rc; |
| } |
| |
| /* |
| ** Close an open quota_FILE stream. |
| */ |
| int sqlite3_quota_fclose(quota_FILE *p){ |
| int rc; |
| quotaFile *pFile; |
| rc = fclose(p->f); |
| pFile = p->pFile; |
| if( pFile ){ |
| quotaEnter(); |
| pFile->nRef--; |
| if( pFile->nRef==0 ){ |
| quotaGroup *pGroup = pFile->pGroup; |
| if( pFile->deleteOnClose ){ |
| gQuota.pOrigVfs->xDelete(gQuota.pOrigVfs, pFile->zFilename, 0); |
| quotaRemoveFile(pFile); |
| } |
| quotaGroupDeref(pGroup); |
| } |
| quotaLeave(); |
| } |
| #if SQLITE_OS_WIN |
| quota_mbcs_free(p->zMbcsName); |
| #endif |
| sqlite3_free(p); |
| return rc; |
| } |
| |
| /* |
| ** Flush memory buffers for a quota_FILE to disk. |
| */ |
| int sqlite3_quota_fflush(quota_FILE *p, int doFsync){ |
| int rc; |
| rc = fflush(p->f); |
| if( rc==0 && doFsync ){ |
| #if SQLITE_OS_UNIX |
| rc = fsync(fileno(p->f)); |
| #endif |
| #if SQLITE_OS_WIN |
| rc = _commit(_fileno(p->f)); |
| #endif |
| } |
| return rc!=0; |
| } |
| |
| /* |
| ** Seek on a quota_FILE stream. |
| */ |
| int sqlite3_quota_fseek(quota_FILE *p, long offset, int whence){ |
| return fseek(p->f, offset, whence); |
| } |
| |
| /* |
| ** rewind a quota_FILE stream. |
| */ |
| void sqlite3_quota_rewind(quota_FILE *p){ |
| rewind(p->f); |
| } |
| |
| /* |
| ** Tell the current location of a quota_FILE stream. |
| */ |
| long sqlite3_quota_ftell(quota_FILE *p){ |
| return ftell(p->f); |
| } |
| |
| /* |
| ** Test the error indicator for the given file. |
| */ |
| int sqlite3_quota_ferror(quota_FILE *p){ |
| return ferror(p->f); |
| } |
| |
| /* |
| ** Truncate a file to szNew bytes. |
| */ |
| int sqlite3_quota_ftruncate(quota_FILE *p, sqlite3_int64 szNew){ |
| quotaFile *pFile = p->pFile; |
| int rc; |
| if( (pFile = p->pFile)!=0 && pFile->iSize<szNew ){ |
| quotaGroup *pGroup; |
| if( pFile->iSize<szNew ){ |
| /* This routine cannot be used to extend a file that is under |
| ** quota management. Only true truncation is allowed. */ |
| return -1; |
| } |
| pGroup = pFile->pGroup; |
| quotaEnter(); |
| pGroup->iSize += szNew - pFile->iSize; |
| quotaLeave(); |
| } |
| #if SQLITE_OS_UNIX |
| rc = ftruncate(fileno(p->f), szNew); |
| #endif |
| #if SQLITE_OS_WIN |
| # if defined(__MINGW32__) && defined(SQLITE_TEST) |
| /* _chsize_s() is missing from MingW (as of 2012-11-06). Use |
| ** _chsize() as a work-around for testing purposes. */ |
| rc = _chsize(_fileno(p->f), (long)szNew); |
| # else |
| rc = _chsize_s(_fileno(p->f), szNew); |
| # endif |
| #endif |
| if( pFile && rc==0 ){ |
| quotaGroup *pGroup = pFile->pGroup; |
| quotaEnter(); |
| pGroup->iSize += szNew - pFile->iSize; |
| pFile->iSize = szNew; |
| quotaLeave(); |
| } |
| return rc; |
| } |
| |
| /* |
| ** Determine the time that the given file was last modified, in |
| ** seconds size 1970. Write the result into *pTime. Return 0 on |
| ** success and non-zero on any kind of error. |
| */ |
| int sqlite3_quota_file_mtime(quota_FILE *p, time_t *pTime){ |
| int rc; |
| #if SQLITE_OS_UNIX |
| struct stat buf; |
| rc = fstat(fileno(p->f), &buf); |
| #endif |
| #if SQLITE_OS_WIN |
| struct _stati64 buf; |
| rc = _stati64(p->zMbcsName, &buf); |
| #endif |
| if( rc==0 ) *pTime = buf.st_mtime; |
| return rc; |
| } |
| |
| /* |
| ** Return the true size of the file, as reported by the operating |
| ** system. |
| */ |
| sqlite3_int64 sqlite3_quota_file_truesize(quota_FILE *p){ |
| int rc; |
| #if SQLITE_OS_UNIX |
| struct stat buf; |
| rc = fstat(fileno(p->f), &buf); |
| #endif |
| #if SQLITE_OS_WIN |
| struct _stati64 buf; |
| rc = _stati64(p->zMbcsName, &buf); |
| #endif |
| return rc==0 ? buf.st_size : -1; |
| } |
| |
| /* |
| ** Return the size of the file, as it is known to the quota subsystem. |
| */ |
| sqlite3_int64 sqlite3_quota_file_size(quota_FILE *p){ |
| return p->pFile ? p->pFile->iSize : -1; |
| } |
| |
| /* |
| ** Determine the amount of data in bytes available for reading |
| ** in the given file. |
| */ |
| long sqlite3_quota_file_available(quota_FILE *p){ |
| FILE* f = p->f; |
| long pos1, pos2; |
| int rc; |
| pos1 = ftell(f); |
| if ( pos1 < 0 ) return -1; |
| rc = fseek(f, 0, SEEK_END); |
| if ( rc != 0 ) return -1; |
| pos2 = ftell(f); |
| if ( pos2 < 0 ) return -1; |
| rc = fseek(f, pos1, SEEK_SET); |
| if ( rc != 0 ) return -1; |
| return pos2 - pos1; |
| } |
| |
| /* |
| ** Remove a managed file. Update quotas accordingly. |
| */ |
| int sqlite3_quota_remove(const char *zFilename){ |
| char *zFull; /* Full pathname for zFilename */ |
| size_t nFull; /* Number of bytes in zFilename */ |
| int rc; /* Result code */ |
| quotaGroup *pGroup; /* Group containing zFilename */ |
| quotaFile *pFile; /* A file in the group */ |
| quotaFile *pNextFile; /* next file in the group */ |
| int diff; /* Difference between filenames */ |
| char c; /* First character past end of pattern */ |
| |
| zFull = (char*)sqlite3_malloc(gQuota.sThisVfs.mxPathname + 1); |
| if( zFull==0 ) return SQLITE_NOMEM; |
| rc = gQuota.pOrigVfs->xFullPathname(gQuota.pOrigVfs, zFilename, |
| gQuota.sThisVfs.mxPathname+1, zFull); |
| if( rc ){ |
| sqlite3_free(zFull); |
| return rc; |
| } |
| |
| /* Figure out the length of the full pathname. If the name ends with |
| ** / (or \ on windows) then remove the trailing /. |
| */ |
| nFull = strlen(zFull); |
| if( nFull>0 && (zFull[nFull-1]=='/' || zFull[nFull-1]=='\\') ){ |
| nFull--; |
| zFull[nFull] = 0; |
| } |
| |
| quotaEnter(); |
| pGroup = quotaGroupFind(zFull); |
| if( pGroup ){ |
| for(pFile=pGroup->pFiles; pFile && rc==SQLITE_OK; pFile=pNextFile){ |
| pNextFile = pFile->pNext; |
| diff = strncmp(zFull, pFile->zFilename, nFull); |
| if( diff==0 && ((c = pFile->zFilename[nFull])==0 || c=='/' || c=='\\') ){ |
| if( pFile->nRef ){ |
| pFile->deleteOnClose = 1; |
| }else{ |
| rc = gQuota.pOrigVfs->xDelete(gQuota.pOrigVfs, pFile->zFilename, 0); |
| quotaRemoveFile(pFile); |
| quotaGroupDeref(pGroup); |
| } |
| } |
| } |
| } |
| quotaLeave(); |
| sqlite3_free(zFull); |
| return rc; |
| } |
| |
| /***************************** Test Code ***********************************/ |
| #ifdef SQLITE_TEST |
| #if defined(INCLUDE_SQLITE_TCL_H) |
| # include "sqlite_tcl.h" |
| #else |
| # include "tcl.h" |
| # ifndef SQLITE_TCLAPI |
| # define SQLITE_TCLAPI |
| # endif |
| #endif |
| |
| /* |
| ** Argument passed to a TCL quota-over-limit callback. |
| */ |
| typedef struct TclQuotaCallback TclQuotaCallback; |
| struct TclQuotaCallback { |
| Tcl_Interp *interp; /* Interpreter in which to run the script */ |
| Tcl_Obj *pScript; /* Script to be run */ |
| }; |
| |
| extern const char *sqlite3ErrName(int); |
| |
| |
| /* |
| ** This is the callback from a quota-over-limit. |
| */ |
| static void tclQuotaCallback( |
| const char *zFilename, /* Name of file whose size increases */ |
| sqlite3_int64 *piLimit, /* IN/OUT: The current limit */ |
| sqlite3_int64 iSize, /* Total size of all files in the group */ |
| void *pArg /* Client data */ |
| ){ |
| TclQuotaCallback *p; /* Callback script object */ |
| Tcl_Obj *pEval; /* Script to evaluate */ |
| Tcl_Obj *pVarname; /* Name of variable to pass as 2nd arg */ |
| unsigned int rnd; /* Random part of pVarname */ |
| int rc; /* Tcl error code */ |
| |
| p = (TclQuotaCallback *)pArg; |
| if( p==0 ) return; |
| |
| pVarname = Tcl_NewStringObj("::piLimit_", -1); |
| Tcl_IncrRefCount(pVarname); |
| sqlite3_randomness(sizeof(rnd), (void *)&rnd); |
| Tcl_AppendObjToObj(pVarname, Tcl_NewIntObj((int)(rnd&0x7FFFFFFF))); |
| Tcl_ObjSetVar2(p->interp, pVarname, 0, Tcl_NewWideIntObj(*piLimit), 0); |
| |
| pEval = Tcl_DuplicateObj(p->pScript); |
| Tcl_IncrRefCount(pEval); |
| Tcl_ListObjAppendElement(0, pEval, Tcl_NewStringObj(zFilename, -1)); |
| Tcl_ListObjAppendElement(0, pEval, pVarname); |
| Tcl_ListObjAppendElement(0, pEval, Tcl_NewWideIntObj(iSize)); |
| rc = Tcl_EvalObjEx(p->interp, pEval, TCL_EVAL_GLOBAL); |
| |
| if( rc==TCL_OK ){ |
| Tcl_WideInt x; |
| Tcl_Obj *pLimit = Tcl_ObjGetVar2(p->interp, pVarname, 0, 0); |
| rc = Tcl_GetWideIntFromObj(p->interp, pLimit, &x); |
| *piLimit = x; |
| Tcl_UnsetVar(p->interp, Tcl_GetString(pVarname), 0); |
| } |
| |
| Tcl_DecrRefCount(pEval); |
| Tcl_DecrRefCount(pVarname); |
| if( rc!=TCL_OK ) Tcl_BackgroundError(p->interp); |
| } |
| |
| /* |
| ** Destructor for a TCL quota-over-limit callback. |
| */ |
| static void tclCallbackDestructor(void *pObj){ |
| TclQuotaCallback *p = (TclQuotaCallback*)pObj; |
| if( p ){ |
| Tcl_DecrRefCount(p->pScript); |
| sqlite3_free((char *)p); |
| } |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_initialize NAME MAKEDEFAULT |
| */ |
| static int SQLITE_TCLAPI test_quota_initialize( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| const char *zName; /* Name of new quota VFS */ |
| int makeDefault; /* True to make the new VFS the default */ |
| int rc; /* Value returned by quota_initialize() */ |
| |
| /* 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_quota_initialize() */ |
| rc = sqlite3_quota_initialize(zName, makeDefault); |
| Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); |
| |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_shutdown |
| */ |
| static int SQLITE_TCLAPI test_quota_shutdown( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| int rc; /* Value returned by quota_shutdown() */ |
| |
| if( objc!=1 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, ""); |
| return TCL_ERROR; |
| } |
| |
| /* Call sqlite3_quota_shutdown() */ |
| rc = sqlite3_quota_shutdown(); |
| Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); |
| |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_set PATTERN LIMIT SCRIPT |
| */ |
| static int SQLITE_TCLAPI test_quota_set( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| const char *zPattern; /* File pattern to configure */ |
| Tcl_WideInt iLimit; /* Initial quota in bytes */ |
| Tcl_Obj *pScript; /* Tcl script to invoke to increase quota */ |
| int rc; /* Value returned by quota_set() */ |
| TclQuotaCallback *p; /* Callback object */ |
| int nScript; /* Length of callback script */ |
| void (*xDestroy)(void*); /* Optional destructor for pArg */ |
| void (*xCallback)(const char *, sqlite3_int64 *, sqlite3_int64, void *); |
| |
| /* Process arguments */ |
| if( objc!=4 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "PATTERN LIMIT SCRIPT"); |
| return TCL_ERROR; |
| } |
| zPattern = Tcl_GetString(objv[1]); |
| if( Tcl_GetWideIntFromObj(interp, objv[2], &iLimit) ) return TCL_ERROR; |
| pScript = objv[3]; |
| Tcl_GetStringFromObj(pScript, &nScript); |
| |
| if( nScript>0 ){ |
| /* Allocate a TclQuotaCallback object */ |
| p = (TclQuotaCallback *)sqlite3_malloc(sizeof(TclQuotaCallback)); |
| if( !p ){ |
| Tcl_SetResult(interp, (char *)"SQLITE_NOMEM", TCL_STATIC); |
| return TCL_OK; |
| } |
| memset(p, 0, sizeof(TclQuotaCallback)); |
| p->interp = interp; |
| Tcl_IncrRefCount(pScript); |
| p->pScript = pScript; |
| xDestroy = tclCallbackDestructor; |
| xCallback = tclQuotaCallback; |
| }else{ |
| p = 0; |
| xDestroy = 0; |
| xCallback = 0; |
| } |
| |
| /* Invoke sqlite3_quota_set() */ |
| rc = sqlite3_quota_set(zPattern, iLimit, xCallback, (void*)p, xDestroy); |
| |
| Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_file FILENAME |
| */ |
| static int SQLITE_TCLAPI test_quota_file( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| const char *zFilename; /* File pattern to configure */ |
| int rc; /* Value returned by quota_file() */ |
| |
| /* Process arguments */ |
| if( objc!=2 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "FILENAME"); |
| return TCL_ERROR; |
| } |
| zFilename = Tcl_GetString(objv[1]); |
| |
| /* Invoke sqlite3_quota_file() */ |
| rc = sqlite3_quota_file(zFilename); |
| |
| Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_dump |
| */ |
| static int SQLITE_TCLAPI test_quota_dump( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| Tcl_Obj *pResult; |
| Tcl_Obj *pGroupTerm; |
| Tcl_Obj *pFileTerm; |
| quotaGroup *pGroup; |
| quotaFile *pFile; |
| |
| pResult = Tcl_NewObj(); |
| quotaEnter(); |
| for(pGroup=gQuota.pGroup; pGroup; pGroup=pGroup->pNext){ |
| pGroupTerm = Tcl_NewObj(); |
| Tcl_ListObjAppendElement(interp, pGroupTerm, |
| Tcl_NewStringObj(pGroup->zPattern, -1)); |
| Tcl_ListObjAppendElement(interp, pGroupTerm, |
| Tcl_NewWideIntObj(pGroup->iLimit)); |
| Tcl_ListObjAppendElement(interp, pGroupTerm, |
| Tcl_NewWideIntObj(pGroup->iSize)); |
| for(pFile=pGroup->pFiles; pFile; pFile=pFile->pNext){ |
| int i; |
| char zTemp[1000]; |
| pFileTerm = Tcl_NewObj(); |
| sqlite3_snprintf(sizeof(zTemp), zTemp, "%s", pFile->zFilename); |
| for(i=0; zTemp[i]; i++){ if( zTemp[i]=='\\' ) zTemp[i] = '/'; } |
| Tcl_ListObjAppendElement(interp, pFileTerm, |
| Tcl_NewStringObj(zTemp, -1)); |
| Tcl_ListObjAppendElement(interp, pFileTerm, |
| Tcl_NewWideIntObj(pFile->iSize)); |
| Tcl_ListObjAppendElement(interp, pFileTerm, |
| Tcl_NewWideIntObj(pFile->nRef)); |
| Tcl_ListObjAppendElement(interp, pFileTerm, |
| Tcl_NewWideIntObj(pFile->deleteOnClose)); |
| Tcl_ListObjAppendElement(interp, pGroupTerm, pFileTerm); |
| } |
| Tcl_ListObjAppendElement(interp, pResult, pGroupTerm); |
| } |
| quotaLeave(); |
| Tcl_SetObjResult(interp, pResult); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_fopen FILENAME MODE |
| */ |
| static int SQLITE_TCLAPI test_quota_fopen( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| const char *zFilename; /* File pattern to configure */ |
| const char *zMode; /* Mode string */ |
| quota_FILE *p; /* Open string object */ |
| char zReturn[50]; /* Name of pointer to return */ |
| |
| /* Process arguments */ |
| if( objc!=3 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "FILENAME MODE"); |
| return TCL_ERROR; |
| } |
| zFilename = Tcl_GetString(objv[1]); |
| zMode = Tcl_GetString(objv[2]); |
| p = sqlite3_quota_fopen(zFilename, zMode); |
| sqlite3_snprintf(sizeof(zReturn), zReturn, "%p", p); |
| Tcl_SetResult(interp, zReturn, TCL_VOLATILE); |
| return TCL_OK; |
| } |
| |
| /* Defined in test1.c */ |
| extern void *sqlite3TestTextToPtr(const char*); |
| |
| /* |
| ** tclcmd: sqlite3_quota_fread HANDLE SIZE NELEM |
| */ |
| static int SQLITE_TCLAPI test_quota_fread( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| quota_FILE *p; |
| char *zBuf; |
| int sz; |
| int nElem; |
| size_t got; |
| |
| if( objc!=4 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "HANDLE SIZE NELEM"); |
| return TCL_ERROR; |
| } |
| p = sqlite3TestTextToPtr(Tcl_GetString(objv[1])); |
| if( Tcl_GetIntFromObj(interp, objv[2], &sz) ) return TCL_ERROR; |
| if( Tcl_GetIntFromObj(interp, objv[3], &nElem) ) return TCL_ERROR; |
| zBuf = (char*)sqlite3_malloc( sz*nElem + 1 ); |
| if( zBuf==0 ){ |
| Tcl_SetResult(interp, "out of memory", TCL_STATIC); |
| return TCL_ERROR; |
| } |
| got = sqlite3_quota_fread(zBuf, sz, nElem, p); |
| zBuf[got*sz] = 0; |
| Tcl_SetResult(interp, zBuf, TCL_VOLATILE); |
| sqlite3_free(zBuf); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_fwrite HANDLE SIZE NELEM CONTENT |
| */ |
| static int SQLITE_TCLAPI test_quota_fwrite( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| quota_FILE *p; |
| char *zBuf; |
| int sz; |
| int nElem; |
| size_t got; |
| |
| if( objc!=5 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "HANDLE SIZE NELEM CONTENT"); |
| return TCL_ERROR; |
| } |
| p = sqlite3TestTextToPtr(Tcl_GetString(objv[1])); |
| if( Tcl_GetIntFromObj(interp, objv[2], &sz) ) return TCL_ERROR; |
| if( Tcl_GetIntFromObj(interp, objv[3], &nElem) ) return TCL_ERROR; |
| zBuf = Tcl_GetString(objv[4]); |
| got = sqlite3_quota_fwrite(zBuf, sz, nElem, p); |
| Tcl_SetObjResult(interp, Tcl_NewWideIntObj(got)); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_fclose HANDLE |
| */ |
| static int SQLITE_TCLAPI test_quota_fclose( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| quota_FILE *p; |
| int rc; |
| |
| if( objc!=2 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "HANDLE"); |
| return TCL_ERROR; |
| } |
| p = sqlite3TestTextToPtr(Tcl_GetString(objv[1])); |
| rc = sqlite3_quota_fclose(p); |
| Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_fflush HANDLE ?HARDSYNC? |
| */ |
| static int SQLITE_TCLAPI test_quota_fflush( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| quota_FILE *p; |
| int rc; |
| int doSync = 0; |
| |
| if( objc!=2 && objc!=3 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "HANDLE ?HARDSYNC?"); |
| return TCL_ERROR; |
| } |
| p = sqlite3TestTextToPtr(Tcl_GetString(objv[1])); |
| if( objc==3 ){ |
| if( Tcl_GetBooleanFromObj(interp, objv[2], &doSync) ) return TCL_ERROR; |
| } |
| rc = sqlite3_quota_fflush(p, doSync); |
| Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_fseek HANDLE OFFSET WHENCE |
| */ |
| static int SQLITE_TCLAPI test_quota_fseek( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| quota_FILE *p; |
| int ofst; |
| const char *zWhence; |
| int whence; |
| int rc; |
| |
| if( objc!=4 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "HANDLE OFFSET WHENCE"); |
| return TCL_ERROR; |
| } |
| p = sqlite3TestTextToPtr(Tcl_GetString(objv[1])); |
| if( Tcl_GetIntFromObj(interp, objv[2], &ofst) ) return TCL_ERROR; |
| zWhence = Tcl_GetString(objv[3]); |
| if( strcmp(zWhence, "SEEK_SET")==0 ){ |
| whence = SEEK_SET; |
| }else if( strcmp(zWhence, "SEEK_CUR")==0 ){ |
| whence = SEEK_CUR; |
| }else if( strcmp(zWhence, "SEEK_END")==0 ){ |
| whence = SEEK_END; |
| }else{ |
| Tcl_AppendResult(interp, |
| "WHENCE should be SEEK_SET, SEEK_CUR, or SEEK_END", (char*)0); |
| return TCL_ERROR; |
| } |
| rc = sqlite3_quota_fseek(p, ofst, whence); |
| Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_rewind HANDLE |
| */ |
| static int SQLITE_TCLAPI test_quota_rewind( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| quota_FILE *p; |
| if( objc!=2 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "HANDLE"); |
| return TCL_ERROR; |
| } |
| p = sqlite3TestTextToPtr(Tcl_GetString(objv[1])); |
| sqlite3_quota_rewind(p); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_ftell HANDLE |
| */ |
| static int SQLITE_TCLAPI test_quota_ftell( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| quota_FILE *p; |
| sqlite3_int64 x; |
| if( objc!=2 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "HANDLE"); |
| return TCL_ERROR; |
| } |
| p = sqlite3TestTextToPtr(Tcl_GetString(objv[1])); |
| x = sqlite3_quota_ftell(p); |
| Tcl_SetObjResult(interp, Tcl_NewWideIntObj(x)); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_ftruncate HANDLE SIZE |
| */ |
| static int SQLITE_TCLAPI test_quota_ftruncate( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| quota_FILE *p; |
| sqlite3_int64 x; |
| Tcl_WideInt w; |
| int rc; |
| if( objc!=3 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "HANDLE SIZE"); |
| return TCL_ERROR; |
| } |
| p = sqlite3TestTextToPtr(Tcl_GetString(objv[1])); |
| if( Tcl_GetWideIntFromObj(interp, objv[2], &w) ) return TCL_ERROR; |
| x = (sqlite3_int64)w; |
| rc = sqlite3_quota_ftruncate(p, x); |
| Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_file_size HANDLE |
| */ |
| static int SQLITE_TCLAPI test_quota_file_size( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| quota_FILE *p; |
| sqlite3_int64 x; |
| if( objc!=2 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "HANDLE"); |
| return TCL_ERROR; |
| } |
| p = sqlite3TestTextToPtr(Tcl_GetString(objv[1])); |
| x = sqlite3_quota_file_size(p); |
| Tcl_SetObjResult(interp, Tcl_NewWideIntObj(x)); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_file_truesize HANDLE |
| */ |
| static int SQLITE_TCLAPI test_quota_file_truesize( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| quota_FILE *p; |
| sqlite3_int64 x; |
| if( objc!=2 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "HANDLE"); |
| return TCL_ERROR; |
| } |
| p = sqlite3TestTextToPtr(Tcl_GetString(objv[1])); |
| x = sqlite3_quota_file_truesize(p); |
| Tcl_SetObjResult(interp, Tcl_NewWideIntObj(x)); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_file_mtime HANDLE |
| */ |
| static int SQLITE_TCLAPI test_quota_file_mtime( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| quota_FILE *p; |
| time_t t; |
| if( objc!=2 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "HANDLE"); |
| return TCL_ERROR; |
| } |
| p = sqlite3TestTextToPtr(Tcl_GetString(objv[1])); |
| t = 0; |
| sqlite3_quota_file_mtime(p, &t); |
| Tcl_SetObjResult(interp, Tcl_NewWideIntObj(t)); |
| return TCL_OK; |
| } |
| |
| |
| /* |
| ** tclcmd: sqlite3_quota_remove FILENAME |
| */ |
| static int SQLITE_TCLAPI test_quota_remove( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| const char *zFilename; /* File pattern to configure */ |
| int rc; |
| if( objc!=2 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "FILENAME"); |
| return TCL_ERROR; |
| } |
| zFilename = Tcl_GetString(objv[1]); |
| rc = sqlite3_quota_remove(zFilename); |
| Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_glob PATTERN TEXT |
| ** |
| ** Test the glob pattern matching. Return 1 if TEXT matches PATTERN |
| ** and return 0 if it does not. |
| */ |
| static int SQLITE_TCLAPI test_quota_glob( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| const char *zPattern; /* The glob pattern */ |
| const char *zText; /* Text to compare agains the pattern */ |
| int rc; |
| if( objc!=3 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "PATTERN TEXT"); |
| return TCL_ERROR; |
| } |
| zPattern = Tcl_GetString(objv[1]); |
| zText = Tcl_GetString(objv[2]); |
| rc = quotaStrglob(zPattern, zText); |
| Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_file_available HANDLE |
| ** |
| ** Return the number of bytes from the current file point to the end of |
| ** the file. |
| */ |
| static int SQLITE_TCLAPI test_quota_file_available( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| quota_FILE *p; |
| sqlite3_int64 x; |
| if( objc!=2 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "HANDLE"); |
| return TCL_ERROR; |
| } |
| p = sqlite3TestTextToPtr(Tcl_GetString(objv[1])); |
| x = sqlite3_quota_file_available(p); |
| Tcl_SetObjResult(interp, Tcl_NewWideIntObj(x)); |
| return TCL_OK; |
| } |
| |
| /* |
| ** tclcmd: sqlite3_quota_ferror HANDLE |
| ** |
| ** Return true if the file handle is in the error state. |
| */ |
| static int SQLITE_TCLAPI test_quota_ferror( |
| void * clientData, |
| Tcl_Interp *interp, |
| int objc, |
| Tcl_Obj *CONST objv[] |
| ){ |
| quota_FILE *p; |
| int x; |
| if( objc!=2 ){ |
| Tcl_WrongNumArgs(interp, 1, objv, "HANDLE"); |
| return TCL_ERROR; |
| } |
| p = sqlite3TestTextToPtr(Tcl_GetString(objv[1])); |
| x = sqlite3_quota_ferror(p); |
| Tcl_SetObjResult(interp, Tcl_NewIntObj(x)); |
| return TCL_OK; |
| } |
| |
| /* |
| ** This routine registers the custom TCL commands defined in this |
| ** module. This should be the only procedure visible from outside |
| ** of this module. |
| */ |
| int Sqlitequota_Init(Tcl_Interp *interp){ |
| static struct { |
| char *zName; |
| Tcl_ObjCmdProc *xProc; |
| } aCmd[] = { |
| { "sqlite3_quota_initialize", test_quota_initialize }, |
| { "sqlite3_quota_shutdown", test_quota_shutdown }, |
| { "sqlite3_quota_set", test_quota_set }, |
| { "sqlite3_quota_file", test_quota_file }, |
| { "sqlite3_quota_dump", test_quota_dump }, |
| { "sqlite3_quota_fopen", test_quota_fopen }, |
| { "sqlite3_quota_fread", test_quota_fread }, |
| { "sqlite3_quota_fwrite", test_quota_fwrite }, |
| { "sqlite3_quota_fclose", test_quota_fclose }, |
| { "sqlite3_quota_fflush", test_quota_fflush }, |
| { "sqlite3_quota_fseek", test_quota_fseek }, |
| { "sqlite3_quota_rewind", test_quota_rewind }, |
| { "sqlite3_quota_ftell", test_quota_ftell }, |
| { "sqlite3_quota_ftruncate", test_quota_ftruncate }, |
| { "sqlite3_quota_file_size", test_quota_file_size }, |
| { "sqlite3_quota_file_truesize", test_quota_file_truesize }, |
| { "sqlite3_quota_file_mtime", test_quota_file_mtime }, |
| { "sqlite3_quota_remove", test_quota_remove }, |
| { "sqlite3_quota_glob", test_quota_glob }, |
| { "sqlite3_quota_file_available",test_quota_file_available }, |
| { "sqlite3_quota_ferror", test_quota_ferror }, |
| }; |
| 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 |