Annotation of embedaddon/sqlite3/src/test_quota.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2010 September 31
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 7: ** May you do good and not evil.
! 8: ** May you find forgiveness for yourself and forgive others.
! 9: ** May you share freely, never taking more than you give.
! 10: **
! 11: *************************************************************************
! 12: **
! 13: ** This file contains a VFS "shim" - a layer that sits in between the
! 14: ** pager and the real VFS.
! 15: **
! 16: ** This particular shim enforces a quota system on files. One or more
! 17: ** database files are in a "quota group" that is defined by a GLOB
! 18: ** pattern. A quota is set for the combined size of all files in the
! 19: ** the group. A quota of zero means "no limit". If the total size
! 20: ** of all files in the quota group is greater than the limit, then
! 21: ** write requests that attempt to enlarge a file fail with SQLITE_FULL.
! 22: **
! 23: ** However, before returning SQLITE_FULL, the write requests invoke
! 24: ** a callback function that is configurable for each quota group.
! 25: ** This callback has the opportunity to enlarge the quota. If the
! 26: ** callback does enlarge the quota such that the total size of all
! 27: ** files within the group is less than the new quota, then the write
! 28: ** continues as if nothing had happened.
! 29: */
! 30: #include "test_quota.h"
! 31: #include <string.h>
! 32: #include <assert.h>
! 33:
! 34: /*
! 35: ** For an build without mutexes, no-op the mutex calls.
! 36: */
! 37: #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE==0
! 38: #define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8)
! 39: #define sqlite3_mutex_free(X)
! 40: #define sqlite3_mutex_enter(X)
! 41: #define sqlite3_mutex_try(X) SQLITE_OK
! 42: #define sqlite3_mutex_leave(X)
! 43: #define sqlite3_mutex_held(X) ((void)(X),1)
! 44: #define sqlite3_mutex_notheld(X) ((void)(X),1)
! 45: #endif /* SQLITE_THREADSAFE==0 */
! 46:
! 47:
! 48: /************************ Object Definitions ******************************/
! 49:
! 50: /* Forward declaration of all object types */
! 51: typedef struct quotaGroup quotaGroup;
! 52: typedef struct quotaConn quotaConn;
! 53: typedef struct quotaFile quotaFile;
! 54:
! 55: /*
! 56: ** A "quota group" is a collection of files whose collective size we want
! 57: ** to limit. Each quota group is defined by a GLOB pattern.
! 58: **
! 59: ** There is an instance of the following object for each defined quota
! 60: ** group. This object records the GLOB pattern that defines which files
! 61: ** belong to the quota group. The object also remembers the size limit
! 62: ** for the group (the quota) and the callback to be invoked when the
! 63: ** sum of the sizes of the files within the group goes over the limit.
! 64: **
! 65: ** A quota group must be established (using sqlite3_quota_set(...))
! 66: ** prior to opening any of the database connections that access files
! 67: ** within the quota group.
! 68: */
! 69: struct quotaGroup {
! 70: const char *zPattern; /* Filename pattern to be quotaed */
! 71: sqlite3_int64 iLimit; /* Upper bound on total file size */
! 72: sqlite3_int64 iSize; /* Current size of all files */
! 73: void (*xCallback)( /* Callback invoked when going over quota */
! 74: const char *zFilename, /* Name of file whose size increases */
! 75: sqlite3_int64 *piLimit, /* IN/OUT: The current limit */
! 76: sqlite3_int64 iSize, /* Total size of all files in the group */
! 77: void *pArg /* Client data */
! 78: );
! 79: void *pArg; /* Third argument to the xCallback() */
! 80: void (*xDestroy)(void*); /* Optional destructor for pArg */
! 81: quotaGroup *pNext, **ppPrev; /* Doubly linked list of all quota objects */
! 82: quotaFile *pFiles; /* Files within this group */
! 83: };
! 84:
! 85: /*
! 86: ** An instance of this structure represents a single file that is part
! 87: ** of a quota group. A single file can be opened multiple times. In
! 88: ** order keep multiple openings of the same file from causing the size
! 89: ** of the file to count against the quota multiple times, each file
! 90: ** has a unique instance of this object and multiple open connections
! 91: ** to the same file each point to a single instance of this object.
! 92: */
! 93: struct quotaFile {
! 94: char *zFilename; /* Name of this file */
! 95: quotaGroup *pGroup; /* Quota group to which this file belongs */
! 96: sqlite3_int64 iSize; /* Current size of this file */
! 97: int nRef; /* Number of times this file is open */
! 98: int deleteOnClose; /* True to delete this file when it closes */
! 99: quotaFile *pNext, **ppPrev; /* Linked list of files in the same group */
! 100: };
! 101:
! 102: /*
! 103: ** An instance of the following object represents each open connection
! 104: ** to a file that participates in quota tracking. This object is a
! 105: ** subclass of sqlite3_file. The sqlite3_file object for the underlying
! 106: ** VFS is appended to this structure.
! 107: */
! 108: struct quotaConn {
! 109: sqlite3_file base; /* Base class - must be first */
! 110: quotaFile *pFile; /* The underlying file */
! 111: /* The underlying VFS sqlite3_file is appended to this object */
! 112: };
! 113:
! 114: /*
! 115: ** An instance of the following object records the state of an
! 116: ** open file. This object is opaque to all users - the internal
! 117: ** structure is only visible to the functions below.
! 118: */
! 119: struct quota_FILE {
! 120: FILE *f; /* Open stdio file pointer */
! 121: sqlite3_int64 iOfst; /* Current offset into the file */
! 122: quotaFile *pFile; /* The file record in the quota system */
! 123: };
! 124:
! 125:
! 126: /************************* Global Variables **********************************/
! 127: /*
! 128: ** All global variables used by this file are containing within the following
! 129: ** gQuota structure.
! 130: */
! 131: static struct {
! 132: /* The pOrigVfs is the real, original underlying VFS implementation.
! 133: ** Most operations pass-through to the real VFS. This value is read-only
! 134: ** during operation. It is only modified at start-time and thus does not
! 135: ** require a mutex.
! 136: */
! 137: sqlite3_vfs *pOrigVfs;
! 138:
! 139: /* The sThisVfs is the VFS structure used by this shim. It is initialized
! 140: ** at start-time and thus does not require a mutex
! 141: */
! 142: sqlite3_vfs sThisVfs;
! 143:
! 144: /* The sIoMethods defines the methods used by sqlite3_file objects
! 145: ** associated with this shim. It is initialized at start-time and does
! 146: ** not require a mutex.
! 147: **
! 148: ** When the underlying VFS is called to open a file, it might return
! 149: ** either a version 1 or a version 2 sqlite3_file object. This shim
! 150: ** has to create a wrapper sqlite3_file of the same version. Hence
! 151: ** there are two I/O method structures, one for version 1 and the other
! 152: ** for version 2.
! 153: */
! 154: sqlite3_io_methods sIoMethodsV1;
! 155: sqlite3_io_methods sIoMethodsV2;
! 156:
! 157: /* True when this shim as been initialized.
! 158: */
! 159: int isInitialized;
! 160:
! 161: /* For run-time access any of the other global data structures in this
! 162: ** shim, the following mutex must be held.
! 163: */
! 164: sqlite3_mutex *pMutex;
! 165:
! 166: /* List of quotaGroup objects.
! 167: */
! 168: quotaGroup *pGroup;
! 169:
! 170: } gQuota;
! 171:
! 172: /************************* Utility Routines *********************************/
! 173: /*
! 174: ** Acquire and release the mutex used to serialize access to the
! 175: ** list of quotaGroups.
! 176: */
! 177: static void quotaEnter(void){ sqlite3_mutex_enter(gQuota.pMutex); }
! 178: static void quotaLeave(void){ sqlite3_mutex_leave(gQuota.pMutex); }
! 179:
! 180: /* Count the number of open files in a quotaGroup
! 181: */
! 182: static int quotaGroupOpenFileCount(quotaGroup *pGroup){
! 183: int N = 0;
! 184: quotaFile *pFile = pGroup->pFiles;
! 185: while( pFile ){
! 186: if( pFile->nRef ) N++;
! 187: pFile = pFile->pNext;
! 188: }
! 189: return N;
! 190: }
! 191:
! 192: /* Remove a file from a quota group.
! 193: */
! 194: static void quotaRemoveFile(quotaFile *pFile){
! 195: quotaGroup *pGroup = pFile->pGroup;
! 196: pGroup->iSize -= pFile->iSize;
! 197: *pFile->ppPrev = pFile->pNext;
! 198: if( pFile->pNext ) pFile->pNext->ppPrev = pFile->ppPrev;
! 199: sqlite3_free(pFile);
! 200: }
! 201:
! 202: /* Remove all files from a quota group. It is always the case that
! 203: ** all files will be closed when this routine is called.
! 204: */
! 205: static void quotaRemoveAllFiles(quotaGroup *pGroup){
! 206: while( pGroup->pFiles ){
! 207: assert( pGroup->pFiles->nRef==0 );
! 208: quotaRemoveFile(pGroup->pFiles);
! 209: }
! 210: }
! 211:
! 212:
! 213: /* If the reference count and threshold for a quotaGroup are both
! 214: ** zero, then destroy the quotaGroup.
! 215: */
! 216: static void quotaGroupDeref(quotaGroup *pGroup){
! 217: if( pGroup->iLimit==0 && quotaGroupOpenFileCount(pGroup)==0 ){
! 218: quotaRemoveAllFiles(pGroup);
! 219: *pGroup->ppPrev = pGroup->pNext;
! 220: if( pGroup->pNext ) pGroup->pNext->ppPrev = pGroup->ppPrev;
! 221: if( pGroup->xDestroy ) pGroup->xDestroy(pGroup->pArg);
! 222: sqlite3_free(pGroup);
! 223: }
! 224: }
! 225:
! 226: /*
! 227: ** Return TRUE if string z matches glob pattern zGlob.
! 228: **
! 229: ** Globbing rules:
! 230: **
! 231: ** '*' Matches any sequence of zero or more characters.
! 232: **
! 233: ** '?' Matches exactly one character.
! 234: **
! 235: ** [...] Matches one character from the enclosed list of
! 236: ** characters.
! 237: **
! 238: ** [^...] Matches one character not in the enclosed list.
! 239: **
! 240: ** / Matches "/" or "\\"
! 241: **
! 242: */
! 243: static int quotaStrglob(const char *zGlob, const char *z){
! 244: int c, c2, cx;
! 245: int invert;
! 246: int seen;
! 247:
! 248: while( (c = (*(zGlob++)))!=0 ){
! 249: if( c=='*' ){
! 250: while( (c=(*(zGlob++))) == '*' || c=='?' ){
! 251: if( c=='?' && (*(z++))==0 ) return 0;
! 252: }
! 253: if( c==0 ){
! 254: return 1;
! 255: }else if( c=='[' ){
! 256: while( *z && quotaStrglob(zGlob-1,z)==0 ){
! 257: z++;
! 258: }
! 259: return (*z)!=0;
! 260: }
! 261: cx = (c=='/') ? '\\' : c;
! 262: while( (c2 = (*(z++)))!=0 ){
! 263: while( c2!=c && c2!=cx ){
! 264: c2 = *(z++);
! 265: if( c2==0 ) return 0;
! 266: }
! 267: if( quotaStrglob(zGlob,z) ) return 1;
! 268: }
! 269: return 0;
! 270: }else if( c=='?' ){
! 271: if( (*(z++))==0 ) return 0;
! 272: }else if( c=='[' ){
! 273: int prior_c = 0;
! 274: seen = 0;
! 275: invert = 0;
! 276: c = *(z++);
! 277: if( c==0 ) return 0;
! 278: c2 = *(zGlob++);
! 279: if( c2=='^' ){
! 280: invert = 1;
! 281: c2 = *(zGlob++);
! 282: }
! 283: if( c2==']' ){
! 284: if( c==']' ) seen = 1;
! 285: c2 = *(zGlob++);
! 286: }
! 287: while( c2 && c2!=']' ){
! 288: if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){
! 289: c2 = *(zGlob++);
! 290: if( c>=prior_c && c<=c2 ) seen = 1;
! 291: prior_c = 0;
! 292: }else{
! 293: if( c==c2 ){
! 294: seen = 1;
! 295: }
! 296: prior_c = c2;
! 297: }
! 298: c2 = *(zGlob++);
! 299: }
! 300: if( c2==0 || (seen ^ invert)==0 ) return 0;
! 301: }else if( c=='/' ){
! 302: if( z[0]!='/' && z[0]!='\\' ) return 0;
! 303: z++;
! 304: }else{
! 305: if( c!=(*(z++)) ) return 0;
! 306: }
! 307: }
! 308: return *z==0;
! 309: }
! 310:
! 311:
! 312: /* Find a quotaGroup given the filename.
! 313: **
! 314: ** Return a pointer to the quotaGroup object. Return NULL if not found.
! 315: */
! 316: static quotaGroup *quotaGroupFind(const char *zFilename){
! 317: quotaGroup *p;
! 318: for(p=gQuota.pGroup; p && quotaStrglob(p->zPattern, zFilename)==0;
! 319: p=p->pNext){}
! 320: return p;
! 321: }
! 322:
! 323: /* Translate an sqlite3_file* that is really a quotaConn* into
! 324: ** the sqlite3_file* for the underlying original VFS.
! 325: */
! 326: static sqlite3_file *quotaSubOpen(sqlite3_file *pConn){
! 327: quotaConn *p = (quotaConn*)pConn;
! 328: return (sqlite3_file*)&p[1];
! 329: }
! 330:
! 331: /* Find a file in a quota group and return a pointer to that file.
! 332: ** Return NULL if the file is not in the group.
! 333: */
! 334: static quotaFile *quotaFindFile(
! 335: quotaGroup *pGroup, /* Group in which to look for the file */
! 336: const char *zName, /* Full pathname of the file */
! 337: int createFlag /* Try to create the file if not found */
! 338: ){
! 339: quotaFile *pFile = pGroup->pFiles;
! 340: while( pFile && strcmp(pFile->zFilename, zName)!=0 ){
! 341: pFile = pFile->pNext;
! 342: }
! 343: if( pFile==0 && createFlag ){
! 344: int nName = strlen(zName);
! 345: pFile = (quotaFile *)sqlite3_malloc( sizeof(*pFile) + nName + 1 );
! 346: if( pFile ){
! 347: memset(pFile, 0, sizeof(*pFile));
! 348: pFile->zFilename = (char*)&pFile[1];
! 349: memcpy(pFile->zFilename, zName, nName+1);
! 350: pFile->pNext = pGroup->pFiles;
! 351: if( pGroup->pFiles ) pGroup->pFiles->ppPrev = &pFile->pNext;
! 352: pFile->ppPrev = &pGroup->pFiles;
! 353: pGroup->pFiles = pFile;
! 354: pFile->pGroup = pGroup;
! 355: }
! 356: }
! 357: return pFile;
! 358: }
! 359:
! 360: /*
! 361: ** Figure out if we are dealing with Unix, Windows, or some other
! 362: ** operating system. After the following block of preprocess macros,
! 363: ** all of SQLITE_OS_UNIX, SQLITE_OS_WIN, SQLITE_OS_OS2, and SQLITE_OS_OTHER
! 364: ** will defined to either 1 or 0. One of the four will be 1. The other
! 365: ** three will be 0.
! 366: */
! 367: #if defined(SQLITE_OS_OTHER)
! 368: # if SQLITE_OS_OTHER==1
! 369: # undef SQLITE_OS_UNIX
! 370: # define SQLITE_OS_UNIX 0
! 371: # undef SQLITE_OS_WIN
! 372: # define SQLITE_OS_WIN 0
! 373: # undef SQLITE_OS_OS2
! 374: # define SQLITE_OS_OS2 0
! 375: # else
! 376: # undef SQLITE_OS_OTHER
! 377: # endif
! 378: #endif
! 379: #if !defined(SQLITE_OS_UNIX) && !defined(SQLITE_OS_OTHER)
! 380: # define SQLITE_OS_OTHER 0
! 381: # ifndef SQLITE_OS_WIN
! 382: # if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) \
! 383: || defined(__MINGW32__) || defined(__BORLANDC__)
! 384: # define SQLITE_OS_WIN 1
! 385: # define SQLITE_OS_UNIX 0
! 386: # define SQLITE_OS_OS2 0
! 387: # elif defined(__EMX__) || defined(_OS2) || defined(OS2) \
! 388: || defined(_OS2_) || defined(__OS2__)
! 389: # define SQLITE_OS_WIN 0
! 390: # define SQLITE_OS_UNIX 0
! 391: # define SQLITE_OS_OS2 1
! 392: # else
! 393: # define SQLITE_OS_WIN 0
! 394: # define SQLITE_OS_UNIX 1
! 395: # define SQLITE_OS_OS2 0
! 396: # endif
! 397: # else
! 398: # define SQLITE_OS_UNIX 0
! 399: # define SQLITE_OS_OS2 0
! 400: # endif
! 401: #else
! 402: # ifndef SQLITE_OS_WIN
! 403: # define SQLITE_OS_WIN 0
! 404: # endif
! 405: #endif
! 406:
! 407: #if SQLITE_OS_UNIX
! 408: # include <unistd.h>
! 409: #endif
! 410: #if SQLITE_OS_WIN
! 411: # include <windows.h>
! 412: # include <io.h>
! 413: #endif
! 414:
! 415: /*
! 416: ** Translate UTF8 to MBCS for use in fopen() calls. Return a pointer to the
! 417: ** translated text.. Call quota_mbcs_free() to deallocate any memory
! 418: ** used to store the returned pointer when done.
! 419: */
! 420: static char *quota_utf8_to_mbcs(const char *zUtf8){
! 421: #if SQLITE_OS_WIN
! 422: int n; /* Bytes in zUtf8 */
! 423: int nWide; /* number of UTF-16 characters */
! 424: int nMbcs; /* Bytes of MBCS */
! 425: LPWSTR zTmpWide; /* The UTF16 text */
! 426: char *zMbcs; /* The MBCS text */
! 427: int codepage; /* Code page used by fopen() */
! 428:
! 429: n = strlen(zUtf8);
! 430: nWide = MultiByteToWideChar(CP_UTF8, 0, zUtf8, -1, NULL, 0);
! 431: if( nWide==0 ) return 0;
! 432: zTmpWide = (LPWSTR)sqlite3_malloc( (nWide+1)*sizeof(zTmpWide[0]) );
! 433: if( zTmpWide==0 ) return 0;
! 434: MultiByteToWideChar(CP_UTF8, 0, zUtf8, -1, zTmpWide, nWide);
! 435: codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
! 436: nMbcs = WideCharToMultiByte(codepage, 0, zTmpWide, nWide, 0, 0, 0, 0);
! 437: zMbcs = nMbcs ? (char*)sqlite3_malloc( nMbcs+1 ) : 0;
! 438: if( zMbcs ){
! 439: WideCharToMultiByte(codepage, 0, zTmpWide, nWide, zMbcs, nMbcs, 0, 0);
! 440: }
! 441: sqlite3_free(zTmpWide);
! 442: return zMbcs;
! 443: #else
! 444: return (char*)zUtf8; /* No-op on unix */
! 445: #endif
! 446: }
! 447:
! 448: /*
! 449: ** Deallocate any memory allocated by quota_utf8_to_mbcs().
! 450: */
! 451: static void quota_mbcs_free(char *zOld){
! 452: #if SQLITE_OS_WIN
! 453: sqlite3_free(zOld);
! 454: #else
! 455: /* No-op on unix */
! 456: #endif
! 457: }
! 458:
! 459: /************************* VFS Method Wrappers *****************************/
! 460: /*
! 461: ** This is the xOpen method used for the "quota" VFS.
! 462: **
! 463: ** Most of the work is done by the underlying original VFS. This method
! 464: ** simply links the new file into the appropriate quota group if it is a
! 465: ** file that needs to be tracked.
! 466: */
! 467: static int quotaOpen(
! 468: sqlite3_vfs *pVfs, /* The quota VFS */
! 469: const char *zName, /* Name of file to be opened */
! 470: sqlite3_file *pConn, /* Fill in this file descriptor */
! 471: int flags, /* Flags to control the opening */
! 472: int *pOutFlags /* Flags showing results of opening */
! 473: ){
! 474: int rc; /* Result code */
! 475: quotaConn *pQuotaOpen; /* The new quota file descriptor */
! 476: quotaFile *pFile; /* Corresponding quotaFile obj */
! 477: quotaGroup *pGroup; /* The group file belongs to */
! 478: sqlite3_file *pSubOpen; /* Real file descriptor */
! 479: sqlite3_vfs *pOrigVfs = gQuota.pOrigVfs; /* Real VFS */
! 480:
! 481: /* If the file is not a main database file or a WAL, then use the
! 482: ** normal xOpen method.
! 483: */
! 484: if( (flags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_WAL))==0 ){
! 485: return pOrigVfs->xOpen(pOrigVfs, zName, pConn, flags, pOutFlags);
! 486: }
! 487:
! 488: /* If the name of the file does not match any quota group, then
! 489: ** use the normal xOpen method.
! 490: */
! 491: quotaEnter();
! 492: pGroup = quotaGroupFind(zName);
! 493: if( pGroup==0 ){
! 494: rc = pOrigVfs->xOpen(pOrigVfs, zName, pConn, flags, pOutFlags);
! 495: }else{
! 496: /* If we get to this point, it means the file needs to be quota tracked.
! 497: */
! 498: pQuotaOpen = (quotaConn*)pConn;
! 499: pSubOpen = quotaSubOpen(pConn);
! 500: rc = pOrigVfs->xOpen(pOrigVfs, zName, pSubOpen, flags, pOutFlags);
! 501: if( rc==SQLITE_OK ){
! 502: pFile = quotaFindFile(pGroup, zName, 1);
! 503: if( pFile==0 ){
! 504: quotaLeave();
! 505: pSubOpen->pMethods->xClose(pSubOpen);
! 506: return SQLITE_NOMEM;
! 507: }
! 508: pFile->deleteOnClose = (flags & SQLITE_OPEN_DELETEONCLOSE)!=0;
! 509: pFile->nRef++;
! 510: pQuotaOpen->pFile = pFile;
! 511: if( pSubOpen->pMethods->iVersion==1 ){
! 512: pQuotaOpen->base.pMethods = &gQuota.sIoMethodsV1;
! 513: }else{
! 514: pQuotaOpen->base.pMethods = &gQuota.sIoMethodsV2;
! 515: }
! 516: }
! 517: }
! 518: quotaLeave();
! 519: return rc;
! 520: }
! 521:
! 522: /*
! 523: ** This is the xDelete method used for the "quota" VFS.
! 524: **
! 525: ** If the file being deleted is part of the quota group, then reduce
! 526: ** the size of the quota group accordingly. And remove the file from
! 527: ** the set of files in the quota group.
! 528: */
! 529: static int quotaDelete(
! 530: sqlite3_vfs *pVfs, /* The quota VFS */
! 531: const char *zName, /* Name of file to be deleted */
! 532: int syncDir /* Do a directory sync after deleting */
! 533: ){
! 534: int rc; /* Result code */
! 535: quotaFile *pFile; /* Files in the quota */
! 536: quotaGroup *pGroup; /* The group file belongs to */
! 537: sqlite3_vfs *pOrigVfs = gQuota.pOrigVfs; /* Real VFS */
! 538:
! 539: /* Do the actual file delete */
! 540: rc = pOrigVfs->xDelete(pOrigVfs, zName, syncDir);
! 541:
! 542: /* If the file just deleted is a member of a quota group, then remove
! 543: ** it from that quota group.
! 544: */
! 545: if( rc==SQLITE_OK ){
! 546: quotaEnter();
! 547: pGroup = quotaGroupFind(zName);
! 548: if( pGroup ){
! 549: pFile = quotaFindFile(pGroup, zName, 0);
! 550: if( pFile ){
! 551: if( pFile->nRef ){
! 552: pFile->deleteOnClose = 1;
! 553: }else{
! 554: quotaRemoveFile(pFile);
! 555: quotaGroupDeref(pGroup);
! 556: }
! 557: }
! 558: }
! 559: quotaLeave();
! 560: }
! 561: return rc;
! 562: }
! 563:
! 564:
! 565: /************************ I/O Method Wrappers *******************************/
! 566:
! 567: /* xClose requests get passed through to the original VFS. But we
! 568: ** also have to unlink the quotaConn from the quotaFile and quotaGroup.
! 569: ** The quotaFile and/or quotaGroup are freed if they are no longer in use.
! 570: */
! 571: static int quotaClose(sqlite3_file *pConn){
! 572: quotaConn *p = (quotaConn*)pConn;
! 573: quotaFile *pFile = p->pFile;
! 574: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 575: int rc;
! 576: rc = pSubOpen->pMethods->xClose(pSubOpen);
! 577: quotaEnter();
! 578: pFile->nRef--;
! 579: if( pFile->nRef==0 ){
! 580: quotaGroup *pGroup = pFile->pGroup;
! 581: if( pFile->deleteOnClose ){
! 582: gQuota.pOrigVfs->xDelete(gQuota.pOrigVfs, pFile->zFilename, 0);
! 583: quotaRemoveFile(pFile);
! 584: }
! 585: quotaGroupDeref(pGroup);
! 586: }
! 587: quotaLeave();
! 588: return rc;
! 589: }
! 590:
! 591: /* Pass xRead requests directory thru to the original VFS without
! 592: ** further processing.
! 593: */
! 594: static int quotaRead(
! 595: sqlite3_file *pConn,
! 596: void *pBuf,
! 597: int iAmt,
! 598: sqlite3_int64 iOfst
! 599: ){
! 600: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 601: return pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, iOfst);
! 602: }
! 603:
! 604: /* Check xWrite requests to see if they expand the file. If they do,
! 605: ** the perform a quota check before passing them through to the
! 606: ** original VFS.
! 607: */
! 608: static int quotaWrite(
! 609: sqlite3_file *pConn,
! 610: const void *pBuf,
! 611: int iAmt,
! 612: sqlite3_int64 iOfst
! 613: ){
! 614: quotaConn *p = (quotaConn*)pConn;
! 615: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 616: sqlite3_int64 iEnd = iOfst+iAmt;
! 617: quotaGroup *pGroup;
! 618: quotaFile *pFile = p->pFile;
! 619: sqlite3_int64 szNew;
! 620:
! 621: if( pFile->iSize<iEnd ){
! 622: pGroup = pFile->pGroup;
! 623: quotaEnter();
! 624: szNew = pGroup->iSize - pFile->iSize + iEnd;
! 625: if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){
! 626: if( pGroup->xCallback ){
! 627: pGroup->xCallback(pFile->zFilename, &pGroup->iLimit, szNew,
! 628: pGroup->pArg);
! 629: }
! 630: if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){
! 631: quotaLeave();
! 632: return SQLITE_FULL;
! 633: }
! 634: }
! 635: pGroup->iSize = szNew;
! 636: pFile->iSize = iEnd;
! 637: quotaLeave();
! 638: }
! 639: return pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, iOfst);
! 640: }
! 641:
! 642: /* Pass xTruncate requests thru to the original VFS. If the
! 643: ** success, update the file size.
! 644: */
! 645: static int quotaTruncate(sqlite3_file *pConn, sqlite3_int64 size){
! 646: quotaConn *p = (quotaConn*)pConn;
! 647: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 648: int rc = pSubOpen->pMethods->xTruncate(pSubOpen, size);
! 649: quotaFile *pFile = p->pFile;
! 650: quotaGroup *pGroup;
! 651: if( rc==SQLITE_OK ){
! 652: quotaEnter();
! 653: pGroup = pFile->pGroup;
! 654: pGroup->iSize -= pFile->iSize;
! 655: pFile->iSize = size;
! 656: pGroup->iSize += size;
! 657: quotaLeave();
! 658: }
! 659: return rc;
! 660: }
! 661:
! 662: /* Pass xSync requests through to the original VFS without change
! 663: */
! 664: static int quotaSync(sqlite3_file *pConn, int flags){
! 665: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 666: return pSubOpen->pMethods->xSync(pSubOpen, flags);
! 667: }
! 668:
! 669: /* Pass xFileSize requests through to the original VFS but then
! 670: ** update the quotaGroup with the new size before returning.
! 671: */
! 672: static int quotaFileSize(sqlite3_file *pConn, sqlite3_int64 *pSize){
! 673: quotaConn *p = (quotaConn*)pConn;
! 674: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 675: quotaFile *pFile = p->pFile;
! 676: quotaGroup *pGroup;
! 677: sqlite3_int64 sz;
! 678: int rc;
! 679:
! 680: rc = pSubOpen->pMethods->xFileSize(pSubOpen, &sz);
! 681: if( rc==SQLITE_OK ){
! 682: quotaEnter();
! 683: pGroup = pFile->pGroup;
! 684: pGroup->iSize -= pFile->iSize;
! 685: pFile->iSize = sz;
! 686: pGroup->iSize += sz;
! 687: quotaLeave();
! 688: *pSize = sz;
! 689: }
! 690: return rc;
! 691: }
! 692:
! 693: /* Pass xLock requests through to the original VFS unchanged.
! 694: */
! 695: static int quotaLock(sqlite3_file *pConn, int lock){
! 696: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 697: return pSubOpen->pMethods->xLock(pSubOpen, lock);
! 698: }
! 699:
! 700: /* Pass xUnlock requests through to the original VFS unchanged.
! 701: */
! 702: static int quotaUnlock(sqlite3_file *pConn, int lock){
! 703: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 704: return pSubOpen->pMethods->xUnlock(pSubOpen, lock);
! 705: }
! 706:
! 707: /* Pass xCheckReservedLock requests through to the original VFS unchanged.
! 708: */
! 709: static int quotaCheckReservedLock(sqlite3_file *pConn, int *pResOut){
! 710: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 711: return pSubOpen->pMethods->xCheckReservedLock(pSubOpen, pResOut);
! 712: }
! 713:
! 714: /* Pass xFileControl requests through to the original VFS unchanged.
! 715: */
! 716: static int quotaFileControl(sqlite3_file *pConn, int op, void *pArg){
! 717: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 718: int rc = pSubOpen->pMethods->xFileControl(pSubOpen, op, pArg);
! 719: #if defined(SQLITE_FCNTL_VFSNAME)
! 720: if( op==SQLITE_FCNTL_VFSNAME && rc==SQLITE_OK ){
! 721: *(char**)pArg = sqlite3_mprintf("quota/%z", *(char**)pArg);
! 722: }
! 723: #endif
! 724: return rc;
! 725: }
! 726:
! 727: /* Pass xSectorSize requests through to the original VFS unchanged.
! 728: */
! 729: static int quotaSectorSize(sqlite3_file *pConn){
! 730: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 731: return pSubOpen->pMethods->xSectorSize(pSubOpen);
! 732: }
! 733:
! 734: /* Pass xDeviceCharacteristics requests through to the original VFS unchanged.
! 735: */
! 736: static int quotaDeviceCharacteristics(sqlite3_file *pConn){
! 737: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 738: return pSubOpen->pMethods->xDeviceCharacteristics(pSubOpen);
! 739: }
! 740:
! 741: /* Pass xShmMap requests through to the original VFS unchanged.
! 742: */
! 743: static int quotaShmMap(
! 744: sqlite3_file *pConn, /* Handle open on database file */
! 745: int iRegion, /* Region to retrieve */
! 746: int szRegion, /* Size of regions */
! 747: int bExtend, /* True to extend file if necessary */
! 748: void volatile **pp /* OUT: Mapped memory */
! 749: ){
! 750: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 751: return pSubOpen->pMethods->xShmMap(pSubOpen, iRegion, szRegion, bExtend, pp);
! 752: }
! 753:
! 754: /* Pass xShmLock requests through to the original VFS unchanged.
! 755: */
! 756: static int quotaShmLock(
! 757: sqlite3_file *pConn, /* Database file holding the shared memory */
! 758: int ofst, /* First lock to acquire or release */
! 759: int n, /* Number of locks to acquire or release */
! 760: int flags /* What to do with the lock */
! 761: ){
! 762: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 763: return pSubOpen->pMethods->xShmLock(pSubOpen, ofst, n, flags);
! 764: }
! 765:
! 766: /* Pass xShmBarrier requests through to the original VFS unchanged.
! 767: */
! 768: static void quotaShmBarrier(sqlite3_file *pConn){
! 769: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 770: pSubOpen->pMethods->xShmBarrier(pSubOpen);
! 771: }
! 772:
! 773: /* Pass xShmUnmap requests through to the original VFS unchanged.
! 774: */
! 775: static int quotaShmUnmap(sqlite3_file *pConn, int deleteFlag){
! 776: sqlite3_file *pSubOpen = quotaSubOpen(pConn);
! 777: return pSubOpen->pMethods->xShmUnmap(pSubOpen, deleteFlag);
! 778: }
! 779:
! 780: /************************** Public Interfaces *****************************/
! 781: /*
! 782: ** Initialize the quota VFS shim. Use the VFS named zOrigVfsName
! 783: ** as the VFS that does the actual work. Use the default if
! 784: ** zOrigVfsName==NULL.
! 785: **
! 786: ** The quota VFS shim is named "quota". It will become the default
! 787: ** VFS if makeDefault is non-zero.
! 788: **
! 789: ** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly once
! 790: ** during start-up.
! 791: */
! 792: int sqlite3_quota_initialize(const char *zOrigVfsName, int makeDefault){
! 793: sqlite3_vfs *pOrigVfs;
! 794: if( gQuota.isInitialized ) return SQLITE_MISUSE;
! 795: pOrigVfs = sqlite3_vfs_find(zOrigVfsName);
! 796: if( pOrigVfs==0 ) return SQLITE_ERROR;
! 797: assert( pOrigVfs!=&gQuota.sThisVfs );
! 798: gQuota.pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
! 799: if( !gQuota.pMutex ){
! 800: return SQLITE_NOMEM;
! 801: }
! 802: gQuota.isInitialized = 1;
! 803: gQuota.pOrigVfs = pOrigVfs;
! 804: gQuota.sThisVfs = *pOrigVfs;
! 805: gQuota.sThisVfs.xOpen = quotaOpen;
! 806: gQuota.sThisVfs.xDelete = quotaDelete;
! 807: gQuota.sThisVfs.szOsFile += sizeof(quotaConn);
! 808: gQuota.sThisVfs.zName = "quota";
! 809: gQuota.sIoMethodsV1.iVersion = 1;
! 810: gQuota.sIoMethodsV1.xClose = quotaClose;
! 811: gQuota.sIoMethodsV1.xRead = quotaRead;
! 812: gQuota.sIoMethodsV1.xWrite = quotaWrite;
! 813: gQuota.sIoMethodsV1.xTruncate = quotaTruncate;
! 814: gQuota.sIoMethodsV1.xSync = quotaSync;
! 815: gQuota.sIoMethodsV1.xFileSize = quotaFileSize;
! 816: gQuota.sIoMethodsV1.xLock = quotaLock;
! 817: gQuota.sIoMethodsV1.xUnlock = quotaUnlock;
! 818: gQuota.sIoMethodsV1.xCheckReservedLock = quotaCheckReservedLock;
! 819: gQuota.sIoMethodsV1.xFileControl = quotaFileControl;
! 820: gQuota.sIoMethodsV1.xSectorSize = quotaSectorSize;
! 821: gQuota.sIoMethodsV1.xDeviceCharacteristics = quotaDeviceCharacteristics;
! 822: gQuota.sIoMethodsV2 = gQuota.sIoMethodsV1;
! 823: gQuota.sIoMethodsV2.iVersion = 2;
! 824: gQuota.sIoMethodsV2.xShmMap = quotaShmMap;
! 825: gQuota.sIoMethodsV2.xShmLock = quotaShmLock;
! 826: gQuota.sIoMethodsV2.xShmBarrier = quotaShmBarrier;
! 827: gQuota.sIoMethodsV2.xShmUnmap = quotaShmUnmap;
! 828: sqlite3_vfs_register(&gQuota.sThisVfs, makeDefault);
! 829: return SQLITE_OK;
! 830: }
! 831:
! 832: /*
! 833: ** Shutdown the quota system.
! 834: **
! 835: ** All SQLite database connections must be closed before calling this
! 836: ** routine.
! 837: **
! 838: ** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly once while
! 839: ** shutting down in order to free all remaining quota groups.
! 840: */
! 841: int sqlite3_quota_shutdown(void){
! 842: quotaGroup *pGroup;
! 843: if( gQuota.isInitialized==0 ) return SQLITE_MISUSE;
! 844: for(pGroup=gQuota.pGroup; pGroup; pGroup=pGroup->pNext){
! 845: if( quotaGroupOpenFileCount(pGroup)>0 ) return SQLITE_MISUSE;
! 846: }
! 847: while( gQuota.pGroup ){
! 848: pGroup = gQuota.pGroup;
! 849: gQuota.pGroup = pGroup->pNext;
! 850: pGroup->iLimit = 0;
! 851: assert( quotaGroupOpenFileCount(pGroup)==0 );
! 852: quotaGroupDeref(pGroup);
! 853: }
! 854: gQuota.isInitialized = 0;
! 855: sqlite3_mutex_free(gQuota.pMutex);
! 856: sqlite3_vfs_unregister(&gQuota.sThisVfs);
! 857: memset(&gQuota, 0, sizeof(gQuota));
! 858: return SQLITE_OK;
! 859: }
! 860:
! 861: /*
! 862: ** Create or destroy a quota group.
! 863: **
! 864: ** The quota group is defined by the zPattern. When calling this routine
! 865: ** with a zPattern for a quota group that already exists, this routine
! 866: ** merely updates the iLimit, xCallback, and pArg values for that quota
! 867: ** group. If zPattern is new, then a new quota group is created.
! 868: **
! 869: ** If the iLimit for a quota group is set to zero, then the quota group
! 870: ** is disabled and will be deleted when the last database connection using
! 871: ** the quota group is closed.
! 872: **
! 873: ** Calling this routine on a zPattern that does not exist and with a
! 874: ** zero iLimit is a no-op.
! 875: **
! 876: ** A quota group must exist with a non-zero iLimit prior to opening
! 877: ** database connections if those connections are to participate in the
! 878: ** quota group. Creating a quota group does not affect database connections
! 879: ** that are already open.
! 880: */
! 881: int sqlite3_quota_set(
! 882: const char *zPattern, /* The filename pattern */
! 883: sqlite3_int64 iLimit, /* New quota to set for this quota group */
! 884: void (*xCallback)( /* Callback invoked when going over quota */
! 885: const char *zFilename, /* Name of file whose size increases */
! 886: sqlite3_int64 *piLimit, /* IN/OUT: The current limit */
! 887: sqlite3_int64 iSize, /* Total size of all files in the group */
! 888: void *pArg /* Client data */
! 889: ),
! 890: void *pArg, /* client data passed thru to callback */
! 891: void (*xDestroy)(void*) /* Optional destructor for pArg */
! 892: ){
! 893: quotaGroup *pGroup;
! 894: quotaEnter();
! 895: pGroup = gQuota.pGroup;
! 896: while( pGroup && strcmp(pGroup->zPattern, zPattern)!=0 ){
! 897: pGroup = pGroup->pNext;
! 898: }
! 899: if( pGroup==0 ){
! 900: int nPattern = strlen(zPattern);
! 901: if( iLimit<=0 ){
! 902: quotaLeave();
! 903: return SQLITE_OK;
! 904: }
! 905: pGroup = (quotaGroup *)sqlite3_malloc( sizeof(*pGroup) + nPattern + 1 );
! 906: if( pGroup==0 ){
! 907: quotaLeave();
! 908: return SQLITE_NOMEM;
! 909: }
! 910: memset(pGroup, 0, sizeof(*pGroup));
! 911: pGroup->zPattern = (char*)&pGroup[1];
! 912: memcpy((char *)pGroup->zPattern, zPattern, nPattern+1);
! 913: if( gQuota.pGroup ) gQuota.pGroup->ppPrev = &pGroup->pNext;
! 914: pGroup->pNext = gQuota.pGroup;
! 915: pGroup->ppPrev = &gQuota.pGroup;
! 916: gQuota.pGroup = pGroup;
! 917: }
! 918: pGroup->iLimit = iLimit;
! 919: pGroup->xCallback = xCallback;
! 920: if( pGroup->xDestroy && pGroup->pArg!=pArg ){
! 921: pGroup->xDestroy(pGroup->pArg);
! 922: }
! 923: pGroup->pArg = pArg;
! 924: pGroup->xDestroy = xDestroy;
! 925: quotaGroupDeref(pGroup);
! 926: quotaLeave();
! 927: return SQLITE_OK;
! 928: }
! 929:
! 930: /*
! 931: ** Bring the named file under quota management. Or if it is already under
! 932: ** management, update its size.
! 933: */
! 934: int sqlite3_quota_file(const char *zFilename){
! 935: char *zFull;
! 936: sqlite3_file *fd;
! 937: int rc;
! 938: int outFlags = 0;
! 939: sqlite3_int64 iSize;
! 940: int nAlloc = gQuota.sThisVfs.szOsFile + gQuota.sThisVfs.mxPathname+2;
! 941:
! 942: /* Allocate space for a file-handle and the full path for file zFilename */
! 943: fd = (sqlite3_file *)sqlite3_malloc(nAlloc);
! 944: if( fd==0 ){
! 945: rc = SQLITE_NOMEM;
! 946: }else{
! 947: zFull = &((char *)fd)[gQuota.sThisVfs.szOsFile];
! 948: rc = gQuota.pOrigVfs->xFullPathname(gQuota.pOrigVfs, zFilename,
! 949: gQuota.sThisVfs.mxPathname+1, zFull);
! 950: }
! 951:
! 952: if( rc==SQLITE_OK ){
! 953: zFull[strlen(zFull)+1] = '\0';
! 954: rc = quotaOpen(&gQuota.sThisVfs, zFull, fd,
! 955: SQLITE_OPEN_READONLY | SQLITE_OPEN_MAIN_DB, &outFlags);
! 956: if( rc==SQLITE_OK ){
! 957: fd->pMethods->xFileSize(fd, &iSize);
! 958: fd->pMethods->xClose(fd);
! 959: }else if( rc==SQLITE_CANTOPEN ){
! 960: quotaGroup *pGroup;
! 961: quotaFile *pFile;
! 962: quotaEnter();
! 963: pGroup = quotaGroupFind(zFull);
! 964: if( pGroup ){
! 965: pFile = quotaFindFile(pGroup, zFull, 0);
! 966: if( pFile ) quotaRemoveFile(pFile);
! 967: }
! 968: quotaLeave();
! 969: }
! 970: }
! 971:
! 972: sqlite3_free(fd);
! 973: return rc;
! 974: }
! 975:
! 976: /*
! 977: ** Open a potentially quotaed file for I/O.
! 978: */
! 979: quota_FILE *sqlite3_quota_fopen(const char *zFilename, const char *zMode){
! 980: quota_FILE *p = 0;
! 981: char *zFull = 0;
! 982: char *zFullTranslated;
! 983: int rc;
! 984: quotaGroup *pGroup;
! 985: quotaFile *pFile;
! 986:
! 987: zFull = (char*)sqlite3_malloc(gQuota.sThisVfs.mxPathname + 1);
! 988: if( zFull==0 ) return 0;
! 989: rc = gQuota.pOrigVfs->xFullPathname(gQuota.pOrigVfs, zFilename,
! 990: gQuota.sThisVfs.mxPathname+1, zFull);
! 991: if( rc ) goto quota_fopen_error;
! 992: p = (quota_FILE*)sqlite3_malloc(sizeof(*p));
! 993: if( p==0 ) goto quota_fopen_error;
! 994: memset(p, 0, sizeof(*p));
! 995: zFullTranslated = quota_utf8_to_mbcs(zFull);
! 996: if( zFullTranslated==0 ) goto quota_fopen_error;
! 997: p->f = fopen(zFullTranslated, zMode);
! 998: quota_mbcs_free(zFullTranslated);
! 999: if( p->f==0 ) goto quota_fopen_error;
! 1000: quotaEnter();
! 1001: pGroup = quotaGroupFind(zFull);
! 1002: if( pGroup ){
! 1003: pFile = quotaFindFile(pGroup, zFull, 1);
! 1004: if( pFile==0 ){
! 1005: quotaLeave();
! 1006: goto quota_fopen_error;
! 1007: }
! 1008: pFile->nRef++;
! 1009: p->pFile = pFile;
! 1010: }
! 1011: quotaLeave();
! 1012: sqlite3_free(zFull);
! 1013: return p;
! 1014:
! 1015: quota_fopen_error:
! 1016: sqlite3_free(zFull);
! 1017: if( p && p->f ) fclose(p->f);
! 1018: sqlite3_free(p);
! 1019: return 0;
! 1020: }
! 1021:
! 1022: /*
! 1023: ** Read content from a quota_FILE
! 1024: */
! 1025: size_t sqlite3_quota_fread(
! 1026: void *pBuf, /* Store the content here */
! 1027: size_t size, /* Size of each element */
! 1028: size_t nmemb, /* Number of elements to read */
! 1029: quota_FILE *p /* Read from this quota_FILE object */
! 1030: ){
! 1031: return fread(pBuf, size, nmemb, p->f);
! 1032: }
! 1033:
! 1034: /*
! 1035: ** Write content into a quota_FILE. Invoke the quota callback and block
! 1036: ** the write if we exceed quota.
! 1037: */
! 1038: size_t sqlite3_quota_fwrite(
! 1039: void *pBuf, /* Take content to write from here */
! 1040: size_t size, /* Size of each element */
! 1041: size_t nmemb, /* Number of elements */
! 1042: quota_FILE *p /* Write to this quota_FILE objecct */
! 1043: ){
! 1044: sqlite3_int64 iOfst;
! 1045: sqlite3_int64 iEnd;
! 1046: sqlite3_int64 szNew;
! 1047: quotaFile *pFile;
! 1048:
! 1049: iOfst = ftell(p->f);
! 1050: iEnd = iOfst + size*nmemb;
! 1051: pFile = p->pFile;
! 1052: if( pFile && pFile->iSize<iEnd ){
! 1053: quotaGroup *pGroup = pFile->pGroup;
! 1054: quotaEnter();
! 1055: szNew = pGroup->iSize - pFile->iSize + iEnd;
! 1056: if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){
! 1057: if( pGroup->xCallback ){
! 1058: pGroup->xCallback(pFile->zFilename, &pGroup->iLimit, szNew,
! 1059: pGroup->pArg);
! 1060: }
! 1061: if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){
! 1062: iEnd = pGroup->iLimit - pGroup->iSize + pFile->iSize;
! 1063: nmemb = (iEnd - iOfst)/size;
! 1064: iEnd = iOfst + size*nmemb;
! 1065: szNew = pGroup->iSize - pFile->iSize + iEnd;
! 1066: }
! 1067: }
! 1068: pGroup->iSize = szNew;
! 1069: pFile->iSize = iEnd;
! 1070: quotaLeave();
! 1071: }
! 1072: return fwrite(pBuf, size, nmemb, p->f);
! 1073: }
! 1074:
! 1075: /*
! 1076: ** Close an open quota_FILE stream.
! 1077: */
! 1078: int sqlite3_quota_fclose(quota_FILE *p){
! 1079: int rc;
! 1080: quotaFile *pFile;
! 1081: rc = fclose(p->f);
! 1082: pFile = p->pFile;
! 1083: if( pFile ){
! 1084: quotaEnter();
! 1085: pFile->nRef--;
! 1086: if( pFile->nRef==0 ){
! 1087: quotaGroup *pGroup = pFile->pGroup;
! 1088: if( pFile->deleteOnClose ){
! 1089: gQuota.pOrigVfs->xDelete(gQuota.pOrigVfs, pFile->zFilename, 0);
! 1090: quotaRemoveFile(pFile);
! 1091: }
! 1092: quotaGroupDeref(pGroup);
! 1093: }
! 1094: quotaLeave();
! 1095: }
! 1096: sqlite3_free(p);
! 1097: return rc;
! 1098: }
! 1099:
! 1100: /*
! 1101: ** Flush memory buffers for a quota_FILE to disk.
! 1102: */
! 1103: int sqlite3_quota_fflush(quota_FILE *p, int doFsync){
! 1104: int rc;
! 1105: rc = fflush(p->f);
! 1106: if( rc==0 && doFsync ){
! 1107: #if SQLITE_OS_UNIX
! 1108: rc = fsync(fileno(p->f));
! 1109: #endif
! 1110: #if SQLITE_OS_WIN
! 1111: rc = _commit(_fileno(p->f));
! 1112: #endif
! 1113: }
! 1114: return rc!=0;
! 1115: }
! 1116:
! 1117: /*
! 1118: ** Seek on a quota_FILE stream.
! 1119: */
! 1120: int sqlite3_quota_fseek(quota_FILE *p, long offset, int whence){
! 1121: return fseek(p->f, offset, whence);
! 1122: }
! 1123:
! 1124: /*
! 1125: ** rewind a quota_FILE stream.
! 1126: */
! 1127: void sqlite3_quota_rewind(quota_FILE *p){
! 1128: rewind(p->f);
! 1129: }
! 1130:
! 1131: /*
! 1132: ** Tell the current location of a quota_FILE stream.
! 1133: */
! 1134: long sqlite3_quota_ftell(quota_FILE *p){
! 1135: return ftell(p->f);
! 1136: }
! 1137:
! 1138: /*
! 1139: ** Remove a managed file. Update quotas accordingly.
! 1140: */
! 1141: int sqlite3_quota_remove(const char *zFilename){
! 1142: char *zFull; /* Full pathname for zFilename */
! 1143: int nFull; /* Number of bytes in zFilename */
! 1144: int rc; /* Result code */
! 1145: quotaGroup *pGroup; /* Group containing zFilename */
! 1146: quotaFile *pFile; /* A file in the group */
! 1147: quotaFile *pNextFile; /* next file in the group */
! 1148: int diff; /* Difference between filenames */
! 1149: char c; /* First character past end of pattern */
! 1150:
! 1151: zFull = (char*)sqlite3_malloc(gQuota.sThisVfs.mxPathname + 1);
! 1152: if( zFull==0 ) return SQLITE_NOMEM;
! 1153: rc = gQuota.pOrigVfs->xFullPathname(gQuota.pOrigVfs, zFilename,
! 1154: gQuota.sThisVfs.mxPathname+1, zFull);
! 1155: if( rc ){
! 1156: sqlite3_free(zFull);
! 1157: return rc;
! 1158: }
! 1159:
! 1160: /* Figure out the length of the full pathname. If the name ends with
! 1161: ** / (or \ on windows) then remove the trailing /.
! 1162: */
! 1163: nFull = strlen(zFull);
! 1164: if( nFull>0 && (zFull[nFull-1]=='/' || zFull[nFull-1]=='\\') ){
! 1165: nFull--;
! 1166: zFull[nFull] = 0;
! 1167: }
! 1168:
! 1169: quotaEnter();
! 1170: pGroup = quotaGroupFind(zFull);
! 1171: if( pGroup ){
! 1172: for(pFile=pGroup->pFiles; pFile && rc==SQLITE_OK; pFile=pNextFile){
! 1173: pNextFile = pFile->pNext;
! 1174: diff = memcmp(zFull, pFile->zFilename, nFull);
! 1175: if( diff==0 && ((c = pFile->zFilename[nFull])==0 || c=='/' || c=='\\') ){
! 1176: if( pFile->nRef ){
! 1177: pFile->deleteOnClose = 1;
! 1178: }else{
! 1179: rc = gQuota.pOrigVfs->xDelete(gQuota.pOrigVfs, pFile->zFilename, 0);
! 1180: quotaRemoveFile(pFile);
! 1181: quotaGroupDeref(pGroup);
! 1182: }
! 1183: }
! 1184: }
! 1185: }
! 1186: quotaLeave();
! 1187: sqlite3_free(zFull);
! 1188: return rc;
! 1189: }
! 1190:
! 1191: /***************************** Test Code ***********************************/
! 1192: #ifdef SQLITE_TEST
! 1193: #include <tcl.h>
! 1194:
! 1195: /*
! 1196: ** Argument passed to a TCL quota-over-limit callback.
! 1197: */
! 1198: typedef struct TclQuotaCallback TclQuotaCallback;
! 1199: struct TclQuotaCallback {
! 1200: Tcl_Interp *interp; /* Interpreter in which to run the script */
! 1201: Tcl_Obj *pScript; /* Script to be run */
! 1202: };
! 1203:
! 1204: extern const char *sqlite3TestErrorName(int);
! 1205:
! 1206:
! 1207: /*
! 1208: ** This is the callback from a quota-over-limit.
! 1209: */
! 1210: static void tclQuotaCallback(
! 1211: const char *zFilename, /* Name of file whose size increases */
! 1212: sqlite3_int64 *piLimit, /* IN/OUT: The current limit */
! 1213: sqlite3_int64 iSize, /* Total size of all files in the group */
! 1214: void *pArg /* Client data */
! 1215: ){
! 1216: TclQuotaCallback *p; /* Callback script object */
! 1217: Tcl_Obj *pEval; /* Script to evaluate */
! 1218: Tcl_Obj *pVarname; /* Name of variable to pass as 2nd arg */
! 1219: unsigned int rnd; /* Random part of pVarname */
! 1220: int rc; /* Tcl error code */
! 1221:
! 1222: p = (TclQuotaCallback *)pArg;
! 1223: if( p==0 ) return;
! 1224:
! 1225: pVarname = Tcl_NewStringObj("::piLimit_", -1);
! 1226: Tcl_IncrRefCount(pVarname);
! 1227: sqlite3_randomness(sizeof(rnd), (void *)&rnd);
! 1228: Tcl_AppendObjToObj(pVarname, Tcl_NewIntObj((int)(rnd&0x7FFFFFFF)));
! 1229: Tcl_ObjSetVar2(p->interp, pVarname, 0, Tcl_NewWideIntObj(*piLimit), 0);
! 1230:
! 1231: pEval = Tcl_DuplicateObj(p->pScript);
! 1232: Tcl_IncrRefCount(pEval);
! 1233: Tcl_ListObjAppendElement(0, pEval, Tcl_NewStringObj(zFilename, -1));
! 1234: Tcl_ListObjAppendElement(0, pEval, pVarname);
! 1235: Tcl_ListObjAppendElement(0, pEval, Tcl_NewWideIntObj(iSize));
! 1236: rc = Tcl_EvalObjEx(p->interp, pEval, TCL_EVAL_GLOBAL);
! 1237:
! 1238: if( rc==TCL_OK ){
! 1239: Tcl_Obj *pLimit = Tcl_ObjGetVar2(p->interp, pVarname, 0, 0);
! 1240: rc = Tcl_GetWideIntFromObj(p->interp, pLimit, piLimit);
! 1241: Tcl_UnsetVar(p->interp, Tcl_GetString(pVarname), 0);
! 1242: }
! 1243:
! 1244: Tcl_DecrRefCount(pEval);
! 1245: Tcl_DecrRefCount(pVarname);
! 1246: if( rc!=TCL_OK ) Tcl_BackgroundError(p->interp);
! 1247: }
! 1248:
! 1249: /*
! 1250: ** Destructor for a TCL quota-over-limit callback.
! 1251: */
! 1252: static void tclCallbackDestructor(void *pObj){
! 1253: TclQuotaCallback *p = (TclQuotaCallback*)pObj;
! 1254: if( p ){
! 1255: Tcl_DecrRefCount(p->pScript);
! 1256: sqlite3_free((char *)p);
! 1257: }
! 1258: }
! 1259:
! 1260: /*
! 1261: ** tclcmd: sqlite3_quota_initialize NAME MAKEDEFAULT
! 1262: */
! 1263: static int test_quota_initialize(
! 1264: void * clientData,
! 1265: Tcl_Interp *interp,
! 1266: int objc,
! 1267: Tcl_Obj *CONST objv[]
! 1268: ){
! 1269: const char *zName; /* Name of new quota VFS */
! 1270: int makeDefault; /* True to make the new VFS the default */
! 1271: int rc; /* Value returned by quota_initialize() */
! 1272:
! 1273: /* Process arguments */
! 1274: if( objc!=3 ){
! 1275: Tcl_WrongNumArgs(interp, 1, objv, "NAME MAKEDEFAULT");
! 1276: return TCL_ERROR;
! 1277: }
! 1278: zName = Tcl_GetString(objv[1]);
! 1279: if( Tcl_GetBooleanFromObj(interp, objv[2], &makeDefault) ) return TCL_ERROR;
! 1280: if( zName[0]=='\0' ) zName = 0;
! 1281:
! 1282: /* Call sqlite3_quota_initialize() */
! 1283: rc = sqlite3_quota_initialize(zName, makeDefault);
! 1284: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
! 1285:
! 1286: return TCL_OK;
! 1287: }
! 1288:
! 1289: /*
! 1290: ** tclcmd: sqlite3_quota_shutdown
! 1291: */
! 1292: static int test_quota_shutdown(
! 1293: void * clientData,
! 1294: Tcl_Interp *interp,
! 1295: int objc,
! 1296: Tcl_Obj *CONST objv[]
! 1297: ){
! 1298: int rc; /* Value returned by quota_shutdown() */
! 1299:
! 1300: if( objc!=1 ){
! 1301: Tcl_WrongNumArgs(interp, 1, objv, "");
! 1302: return TCL_ERROR;
! 1303: }
! 1304:
! 1305: /* Call sqlite3_quota_shutdown() */
! 1306: rc = sqlite3_quota_shutdown();
! 1307: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
! 1308:
! 1309: return TCL_OK;
! 1310: }
! 1311:
! 1312: /*
! 1313: ** tclcmd: sqlite3_quota_set PATTERN LIMIT SCRIPT
! 1314: */
! 1315: static int test_quota_set(
! 1316: void * clientData,
! 1317: Tcl_Interp *interp,
! 1318: int objc,
! 1319: Tcl_Obj *CONST objv[]
! 1320: ){
! 1321: const char *zPattern; /* File pattern to configure */
! 1322: sqlite3_int64 iLimit; /* Initial quota in bytes */
! 1323: Tcl_Obj *pScript; /* Tcl script to invoke to increase quota */
! 1324: int rc; /* Value returned by quota_set() */
! 1325: TclQuotaCallback *p; /* Callback object */
! 1326: int nScript; /* Length of callback script */
! 1327: void (*xDestroy)(void*); /* Optional destructor for pArg */
! 1328: void (*xCallback)(const char *, sqlite3_int64 *, sqlite3_int64, void *);
! 1329:
! 1330: /* Process arguments */
! 1331: if( objc!=4 ){
! 1332: Tcl_WrongNumArgs(interp, 1, objv, "PATTERN LIMIT SCRIPT");
! 1333: return TCL_ERROR;
! 1334: }
! 1335: zPattern = Tcl_GetString(objv[1]);
! 1336: if( Tcl_GetWideIntFromObj(interp, objv[2], &iLimit) ) return TCL_ERROR;
! 1337: pScript = objv[3];
! 1338: Tcl_GetStringFromObj(pScript, &nScript);
! 1339:
! 1340: if( nScript>0 ){
! 1341: /* Allocate a TclQuotaCallback object */
! 1342: p = (TclQuotaCallback *)sqlite3_malloc(sizeof(TclQuotaCallback));
! 1343: if( !p ){
! 1344: Tcl_SetResult(interp, (char *)"SQLITE_NOMEM", TCL_STATIC);
! 1345: return TCL_OK;
! 1346: }
! 1347: memset(p, 0, sizeof(TclQuotaCallback));
! 1348: p->interp = interp;
! 1349: Tcl_IncrRefCount(pScript);
! 1350: p->pScript = pScript;
! 1351: xDestroy = tclCallbackDestructor;
! 1352: xCallback = tclQuotaCallback;
! 1353: }else{
! 1354: p = 0;
! 1355: xDestroy = 0;
! 1356: xCallback = 0;
! 1357: }
! 1358:
! 1359: /* Invoke sqlite3_quota_set() */
! 1360: rc = sqlite3_quota_set(zPattern, iLimit, xCallback, (void*)p, xDestroy);
! 1361:
! 1362: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
! 1363: return TCL_OK;
! 1364: }
! 1365:
! 1366: /*
! 1367: ** tclcmd: sqlite3_quota_file FILENAME
! 1368: */
! 1369: static int test_quota_file(
! 1370: void * clientData,
! 1371: Tcl_Interp *interp,
! 1372: int objc,
! 1373: Tcl_Obj *CONST objv[]
! 1374: ){
! 1375: const char *zFilename; /* File pattern to configure */
! 1376: int rc; /* Value returned by quota_file() */
! 1377:
! 1378: /* Process arguments */
! 1379: if( objc!=2 ){
! 1380: Tcl_WrongNumArgs(interp, 1, objv, "FILENAME");
! 1381: return TCL_ERROR;
! 1382: }
! 1383: zFilename = Tcl_GetString(objv[1]);
! 1384:
! 1385: /* Invoke sqlite3_quota_file() */
! 1386: rc = sqlite3_quota_file(zFilename);
! 1387:
! 1388: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
! 1389: return TCL_OK;
! 1390: }
! 1391:
! 1392: /*
! 1393: ** tclcmd: sqlite3_quota_dump
! 1394: */
! 1395: static int test_quota_dump(
! 1396: void * clientData,
! 1397: Tcl_Interp *interp,
! 1398: int objc,
! 1399: Tcl_Obj *CONST objv[]
! 1400: ){
! 1401: Tcl_Obj *pResult;
! 1402: Tcl_Obj *pGroupTerm;
! 1403: Tcl_Obj *pFileTerm;
! 1404: quotaGroup *pGroup;
! 1405: quotaFile *pFile;
! 1406:
! 1407: pResult = Tcl_NewObj();
! 1408: quotaEnter();
! 1409: for(pGroup=gQuota.pGroup; pGroup; pGroup=pGroup->pNext){
! 1410: pGroupTerm = Tcl_NewObj();
! 1411: Tcl_ListObjAppendElement(interp, pGroupTerm,
! 1412: Tcl_NewStringObj(pGroup->zPattern, -1));
! 1413: Tcl_ListObjAppendElement(interp, pGroupTerm,
! 1414: Tcl_NewWideIntObj(pGroup->iLimit));
! 1415: Tcl_ListObjAppendElement(interp, pGroupTerm,
! 1416: Tcl_NewWideIntObj(pGroup->iSize));
! 1417: for(pFile=pGroup->pFiles; pFile; pFile=pFile->pNext){
! 1418: int i;
! 1419: char zTemp[1000];
! 1420: pFileTerm = Tcl_NewObj();
! 1421: sqlite3_snprintf(sizeof(zTemp), zTemp, "%s", pFile->zFilename);
! 1422: for(i=0; zTemp[i]; i++){ if( zTemp[i]=='\\' ) zTemp[i] = '/'; }
! 1423: Tcl_ListObjAppendElement(interp, pFileTerm,
! 1424: Tcl_NewStringObj(zTemp, -1));
! 1425: Tcl_ListObjAppendElement(interp, pFileTerm,
! 1426: Tcl_NewWideIntObj(pFile->iSize));
! 1427: Tcl_ListObjAppendElement(interp, pFileTerm,
! 1428: Tcl_NewWideIntObj(pFile->nRef));
! 1429: Tcl_ListObjAppendElement(interp, pFileTerm,
! 1430: Tcl_NewWideIntObj(pFile->deleteOnClose));
! 1431: Tcl_ListObjAppendElement(interp, pGroupTerm, pFileTerm);
! 1432: }
! 1433: Tcl_ListObjAppendElement(interp, pResult, pGroupTerm);
! 1434: }
! 1435: quotaLeave();
! 1436: Tcl_SetObjResult(interp, pResult);
! 1437: return TCL_OK;
! 1438: }
! 1439:
! 1440: /*
! 1441: ** tclcmd: sqlite3_quota_fopen FILENAME MODE
! 1442: */
! 1443: static int test_quota_fopen(
! 1444: void * clientData,
! 1445: Tcl_Interp *interp,
! 1446: int objc,
! 1447: Tcl_Obj *CONST objv[]
! 1448: ){
! 1449: const char *zFilename; /* File pattern to configure */
! 1450: const char *zMode; /* Mode string */
! 1451: quota_FILE *p; /* Open string object */
! 1452: char zReturn[50]; /* Name of pointer to return */
! 1453:
! 1454: /* Process arguments */
! 1455: if( objc!=3 ){
! 1456: Tcl_WrongNumArgs(interp, 1, objv, "FILENAME MODE");
! 1457: return TCL_ERROR;
! 1458: }
! 1459: zFilename = Tcl_GetString(objv[1]);
! 1460: zMode = Tcl_GetString(objv[2]);
! 1461: p = sqlite3_quota_fopen(zFilename, zMode);
! 1462: sqlite3_snprintf(sizeof(zReturn), zReturn, "%p", p);
! 1463: Tcl_SetResult(interp, zReturn, TCL_VOLATILE);
! 1464: return TCL_OK;
! 1465: }
! 1466:
! 1467: /* Defined in test1.c */
! 1468: extern void *sqlite3TestTextToPtr(const char*);
! 1469:
! 1470: /*
! 1471: ** tclcmd: sqlite3_quota_fread HANDLE SIZE NELEM
! 1472: */
! 1473: static int test_quota_fread(
! 1474: void * clientData,
! 1475: Tcl_Interp *interp,
! 1476: int objc,
! 1477: Tcl_Obj *CONST objv[]
! 1478: ){
! 1479: quota_FILE *p;
! 1480: char *zBuf;
! 1481: int sz;
! 1482: int nElem;
! 1483: int got;
! 1484:
! 1485: if( objc!=4 ){
! 1486: Tcl_WrongNumArgs(interp, 1, objv, "HANDLE SIZE NELEM");
! 1487: return TCL_ERROR;
! 1488: }
! 1489: p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
! 1490: if( Tcl_GetIntFromObj(interp, objv[2], &sz) ) return TCL_ERROR;
! 1491: if( Tcl_GetIntFromObj(interp, objv[3], &nElem) ) return TCL_ERROR;
! 1492: zBuf = (char*)sqlite3_malloc( sz*nElem + 1 );
! 1493: if( zBuf==0 ){
! 1494: Tcl_SetResult(interp, "out of memory", TCL_STATIC);
! 1495: return TCL_ERROR;
! 1496: }
! 1497: got = sqlite3_quota_fread(zBuf, sz, nElem, p);
! 1498: if( got<0 ) got = 0;
! 1499: zBuf[got*sz] = 0;
! 1500: Tcl_SetResult(interp, zBuf, TCL_VOLATILE);
! 1501: sqlite3_free(zBuf);
! 1502: return TCL_OK;
! 1503: }
! 1504:
! 1505: /*
! 1506: ** tclcmd: sqlite3_quota_fwrite HANDLE SIZE NELEM CONTENT
! 1507: */
! 1508: static int test_quota_fwrite(
! 1509: void * clientData,
! 1510: Tcl_Interp *interp,
! 1511: int objc,
! 1512: Tcl_Obj *CONST objv[]
! 1513: ){
! 1514: quota_FILE *p;
! 1515: char *zBuf;
! 1516: int sz;
! 1517: int nElem;
! 1518: int got;
! 1519:
! 1520: if( objc!=5 ){
! 1521: Tcl_WrongNumArgs(interp, 1, objv, "HANDLE SIZE NELEM CONTENT");
! 1522: return TCL_ERROR;
! 1523: }
! 1524: p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
! 1525: if( Tcl_GetIntFromObj(interp, objv[2], &sz) ) return TCL_ERROR;
! 1526: if( Tcl_GetIntFromObj(interp, objv[3], &nElem) ) return TCL_ERROR;
! 1527: zBuf = Tcl_GetString(objv[4]);
! 1528: got = sqlite3_quota_fwrite(zBuf, sz, nElem, p);
! 1529: Tcl_SetObjResult(interp, Tcl_NewIntObj(got));
! 1530: return TCL_OK;
! 1531: }
! 1532:
! 1533: /*
! 1534: ** tclcmd: sqlite3_quota_fclose HANDLE
! 1535: */
! 1536: static int test_quota_fclose(
! 1537: void * clientData,
! 1538: Tcl_Interp *interp,
! 1539: int objc,
! 1540: Tcl_Obj *CONST objv[]
! 1541: ){
! 1542: quota_FILE *p;
! 1543: int rc;
! 1544:
! 1545: if( objc!=2 ){
! 1546: Tcl_WrongNumArgs(interp, 1, objv, "HANDLE");
! 1547: return TCL_ERROR;
! 1548: }
! 1549: p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
! 1550: rc = sqlite3_quota_fclose(p);
! 1551: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
! 1552: return TCL_OK;
! 1553: }
! 1554:
! 1555: /*
! 1556: ** tclcmd: sqlite3_quota_fflush HANDLE ?HARDSYNC?
! 1557: */
! 1558: static int test_quota_fflush(
! 1559: void * clientData,
! 1560: Tcl_Interp *interp,
! 1561: int objc,
! 1562: Tcl_Obj *CONST objv[]
! 1563: ){
! 1564: quota_FILE *p;
! 1565: int rc;
! 1566: int doSync = 0;
! 1567:
! 1568: if( objc!=2 && objc!=3 ){
! 1569: Tcl_WrongNumArgs(interp, 1, objv, "HANDLE ?HARDSYNC?");
! 1570: return TCL_ERROR;
! 1571: }
! 1572: p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
! 1573: if( objc==3 ){
! 1574: if( Tcl_GetBooleanFromObj(interp, objv[2], &doSync) ) return TCL_ERROR;
! 1575: }
! 1576: rc = sqlite3_quota_fflush(p, doSync);
! 1577: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
! 1578: return TCL_OK;
! 1579: }
! 1580:
! 1581: /*
! 1582: ** tclcmd: sqlite3_quota_fseek HANDLE OFFSET WHENCE
! 1583: */
! 1584: static int test_quota_fseek(
! 1585: void * clientData,
! 1586: Tcl_Interp *interp,
! 1587: int objc,
! 1588: Tcl_Obj *CONST objv[]
! 1589: ){
! 1590: quota_FILE *p;
! 1591: int ofst;
! 1592: const char *zWhence;
! 1593: int whence;
! 1594: int rc;
! 1595:
! 1596: if( objc!=4 ){
! 1597: Tcl_WrongNumArgs(interp, 1, objv, "HANDLE OFFSET WHENCE");
! 1598: return TCL_ERROR;
! 1599: }
! 1600: p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
! 1601: if( Tcl_GetIntFromObj(interp, objv[2], &ofst) ) return TCL_ERROR;
! 1602: zWhence = Tcl_GetString(objv[3]);
! 1603: if( strcmp(zWhence, "SEEK_SET")==0 ){
! 1604: whence = SEEK_SET;
! 1605: }else if( strcmp(zWhence, "SEEK_CUR")==0 ){
! 1606: whence = SEEK_CUR;
! 1607: }else if( strcmp(zWhence, "SEEK_END")==0 ){
! 1608: whence = SEEK_END;
! 1609: }else{
! 1610: Tcl_AppendResult(interp,
! 1611: "WHENCE should be SEEK_SET, SEEK_CUR, or SEEK_END", (char*)0);
! 1612: return TCL_ERROR;
! 1613: }
! 1614: rc = sqlite3_quota_fseek(p, ofst, whence);
! 1615: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
! 1616: return TCL_OK;
! 1617: }
! 1618:
! 1619: /*
! 1620: ** tclcmd: sqlite3_quota_rewind HANDLE
! 1621: */
! 1622: static int test_quota_rewind(
! 1623: void * clientData,
! 1624: Tcl_Interp *interp,
! 1625: int objc,
! 1626: Tcl_Obj *CONST objv[]
! 1627: ){
! 1628: quota_FILE *p;
! 1629: if( objc!=2 ){
! 1630: Tcl_WrongNumArgs(interp, 1, objv, "HANDLE");
! 1631: return TCL_ERROR;
! 1632: }
! 1633: p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
! 1634: sqlite3_quota_rewind(p);
! 1635: return TCL_OK;
! 1636: }
! 1637:
! 1638: /*
! 1639: ** tclcmd: sqlite3_quota_ftell HANDLE
! 1640: */
! 1641: static int test_quota_ftell(
! 1642: void * clientData,
! 1643: Tcl_Interp *interp,
! 1644: int objc,
! 1645: Tcl_Obj *CONST objv[]
! 1646: ){
! 1647: quota_FILE *p;
! 1648: sqlite3_int64 x;
! 1649: if( objc!=2 ){
! 1650: Tcl_WrongNumArgs(interp, 1, objv, "HANDLE");
! 1651: return TCL_ERROR;
! 1652: }
! 1653: p = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
! 1654: x = sqlite3_quota_ftell(p);
! 1655: Tcl_SetObjResult(interp, Tcl_NewWideIntObj(x));
! 1656: return TCL_OK;
! 1657: }
! 1658:
! 1659: /*
! 1660: ** tclcmd: sqlite3_quota_remove FILENAME
! 1661: */
! 1662: static int test_quota_remove(
! 1663: void * clientData,
! 1664: Tcl_Interp *interp,
! 1665: int objc,
! 1666: Tcl_Obj *CONST objv[]
! 1667: ){
! 1668: const char *zFilename; /* File pattern to configure */
! 1669: int rc;
! 1670: if( objc!=2 ){
! 1671: Tcl_WrongNumArgs(interp, 1, objv, "FILENAME");
! 1672: return TCL_ERROR;
! 1673: }
! 1674: zFilename = Tcl_GetString(objv[1]);
! 1675: rc = sqlite3_quota_remove(zFilename);
! 1676: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
! 1677: return TCL_OK;
! 1678: }
! 1679:
! 1680: /*
! 1681: ** tclcmd: sqlite3_quota_glob PATTERN TEXT
! 1682: **
! 1683: ** Test the glob pattern matching. Return 1 if TEXT matches PATTERN
! 1684: ** and return 0 if it does not.
! 1685: */
! 1686: static int test_quota_glob(
! 1687: void * clientData,
! 1688: Tcl_Interp *interp,
! 1689: int objc,
! 1690: Tcl_Obj *CONST objv[]
! 1691: ){
! 1692: const char *zPattern; /* The glob pattern */
! 1693: const char *zText; /* Text to compare agains the pattern */
! 1694: int rc;
! 1695: if( objc!=3 ){
! 1696: Tcl_WrongNumArgs(interp, 1, objv, "PATTERN TEXT");
! 1697: return TCL_ERROR;
! 1698: }
! 1699: zPattern = Tcl_GetString(objv[1]);
! 1700: zText = Tcl_GetString(objv[2]);
! 1701: rc = quotaStrglob(zPattern, zText);
! 1702: Tcl_SetObjResult(interp, Tcl_NewIntObj(rc));
! 1703: return TCL_OK;
! 1704: }
! 1705:
! 1706: /*
! 1707: ** This routine registers the custom TCL commands defined in this
! 1708: ** module. This should be the only procedure visible from outside
! 1709: ** of this module.
! 1710: */
! 1711: int Sqlitequota_Init(Tcl_Interp *interp){
! 1712: static struct {
! 1713: char *zName;
! 1714: Tcl_ObjCmdProc *xProc;
! 1715: } aCmd[] = {
! 1716: { "sqlite3_quota_initialize", test_quota_initialize },
! 1717: { "sqlite3_quota_shutdown", test_quota_shutdown },
! 1718: { "sqlite3_quota_set", test_quota_set },
! 1719: { "sqlite3_quota_file", test_quota_file },
! 1720: { "sqlite3_quota_dump", test_quota_dump },
! 1721: { "sqlite3_quota_fopen", test_quota_fopen },
! 1722: { "sqlite3_quota_fread", test_quota_fread },
! 1723: { "sqlite3_quota_fwrite", test_quota_fwrite },
! 1724: { "sqlite3_quota_fclose", test_quota_fclose },
! 1725: { "sqlite3_quota_fflush", test_quota_fflush },
! 1726: { "sqlite3_quota_fseek", test_quota_fseek },
! 1727: { "sqlite3_quota_rewind", test_quota_rewind },
! 1728: { "sqlite3_quota_ftell", test_quota_ftell },
! 1729: { "sqlite3_quota_remove", test_quota_remove },
! 1730: { "sqlite3_quota_glob", test_quota_glob },
! 1731: };
! 1732: int i;
! 1733:
! 1734: for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
! 1735: Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
! 1736: }
! 1737:
! 1738: return TCL_OK;
! 1739: }
! 1740: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_quota.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src