1 /* 2 ** 2007 September 14 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 ** OVERVIEW: 14 ** 15 ** This file contains some example code demonstrating how the SQLite 16 ** vfs feature can be used to have SQLite operate directly on an 17 ** embedded media, without using an intermediate file system. 18 ** 19 ** Because this is only a demo designed to run on a workstation, the 20 ** underlying media is simulated using a regular file-system file. The 21 ** size of the file is fixed when it is first created (default size 10 MB). 22 ** From SQLite's point of view, this space is used to store a single 23 ** database file and the journal file. 24 ** 25 ** Any statement journal created is stored in volatile memory obtained 26 ** from sqlite3_malloc(). Any attempt to create a temporary database file 27 ** will fail (SQLITE_IOERR). To prevent SQLite from attempting this, 28 ** it should be configured to store all temporary database files in 29 ** main memory (see pragma "temp_store" or the SQLITE_TEMP_STORE compile 30 ** time option). 31 ** 32 ** ASSUMPTIONS: 33 ** 34 ** After it has been created, the blob file is accessed using the 35 ** following three functions only: 36 ** 37 ** mediaRead(); - Read a 512 byte block from the file. 38 ** mediaWrite(); - Write a 512 byte block to the file. 39 ** mediaSync(); - Tell the media hardware to sync. 40 ** 41 ** It is assumed that these can be easily implemented by any "real" 42 ** media vfs driver adapting this code. 43 ** 44 ** FILE FORMAT: 45 ** 46 ** The basic principle is that the "database file" is stored at the 47 ** beginning of the 10 MB blob and grows in a forward direction. The 48 ** "journal file" is stored at the end of the 10MB blob and grows 49 ** in the reverse direction. If, during a transaction, insufficient 50 ** space is available to expand either the journal or database file, 51 ** an SQLITE_FULL error is returned. The database file is never allowed 52 ** to consume more than 90% of the blob space. If SQLite tries to 53 ** create a file larger than this, SQLITE_FULL is returned. 54 ** 55 ** No allowance is made for "wear-leveling", as is required by. 56 ** embedded devices in the absence of equivalent hardware features. 57 ** 58 ** The first 512 block byte of the file is reserved for storing the 59 ** size of the "database file". It is updated as part of the sync() 60 ** operation. On startup, it can only be trusted if no journal file 61 ** exists. If a journal-file does exist, then it stores the real size 62 ** of the database region. The second and subsequent blocks store the 63 ** actual database content. 64 ** 65 ** The size of the "journal file" is not stored persistently in the 66 ** file. When the system is running, the size of the journal file is 67 ** stored in volatile memory. When recovering from a crash, this vfs 68 ** reports a very large size for the journal file. The normal journal 69 ** header and checksum mechanisms serve to prevent SQLite from 70 ** processing any data that lies past the logical end of the journal. 71 ** 72 ** When SQLite calls OsDelete() to delete the journal file, the final 73 ** 512 bytes of the blob (the area containing the first journal header) 74 ** are zeroed. 75 ** 76 ** LOCKING: 77 ** 78 ** File locking is a no-op. Only one connection may be open at any one 79 ** time using this demo vfs. 80 */ 81 82 #include "sqlite3.h" 83 #include <assert.h> 84 #include <string.h> 85 86 /* 87 ** Maximum pathname length supported by the fs backend. 88 */ 89 #define BLOCKSIZE 512 90 #define BLOBSIZE 10485760 91 92 /* 93 ** Name used to identify this VFS. 94 */ 95 #define FS_VFS_NAME "fs" 96 97 typedef struct fs_real_file fs_real_file; 98 struct fs_real_file { 99 sqlite3_file *pFile; 100 const char *zName; 101 int nDatabase; /* Current size of database region */ 102 int nJournal; /* Current size of journal region */ 103 int nBlob; /* Total size of allocated blob */ 104 int nRef; /* Number of pointers to this structure */ 105 fs_real_file *pNext; 106 fs_real_file **ppThis; 107 }; 108 109 typedef struct fs_file fs_file; 110 struct fs_file { 111 sqlite3_file base; 112 int eType; 113 fs_real_file *pReal; 114 }; 115 116 typedef struct tmp_file tmp_file; 117 struct tmp_file { 118 sqlite3_file base; 119 int nSize; 120 int nAlloc; 121 char *zAlloc; 122 }; 123 124 /* Values for fs_file.eType. */ 125 #define DATABASE_FILE 1 126 #define JOURNAL_FILE 2 127 128 /* 129 ** Method declarations for fs_file. 130 */ 131 static int fsClose(sqlite3_file*); 132 static int fsRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); 133 static int fsWrite(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); 134 static int fsTruncate(sqlite3_file*, sqlite3_int64 size); 135 static int fsSync(sqlite3_file*, int flags); 136 static int fsFileSize(sqlite3_file*, sqlite3_int64 *pSize); 137 static int fsLock(sqlite3_file*, int); 138 static int fsUnlock(sqlite3_file*, int); 139 static int fsCheckReservedLock(sqlite3_file*, int *pResOut); 140 static int fsFileControl(sqlite3_file*, int op, void *pArg); 141 static int fsSectorSize(sqlite3_file*); 142 static int fsDeviceCharacteristics(sqlite3_file*); 143 144 /* 145 ** Method declarations for tmp_file. 146 */ 147 static int tmpClose(sqlite3_file*); 148 static int tmpRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); 149 static int tmpWrite(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); 150 static int tmpTruncate(sqlite3_file*, sqlite3_int64 size); 151 static int tmpSync(sqlite3_file*, int flags); 152 static int tmpFileSize(sqlite3_file*, sqlite3_int64 *pSize); 153 static int tmpLock(sqlite3_file*, int); 154 static int tmpUnlock(sqlite3_file*, int); 155 static int tmpCheckReservedLock(sqlite3_file*, int *pResOut); 156 static int tmpFileControl(sqlite3_file*, int op, void *pArg); 157 static int tmpSectorSize(sqlite3_file*); 158 static int tmpDeviceCharacteristics(sqlite3_file*); 159 160 /* 161 ** Method declarations for fs_vfs. 162 */ 163 static int fsOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *); 164 static int fsDelete(sqlite3_vfs*, const char *zName, int syncDir); 165 static int fsAccess(sqlite3_vfs*, const char *zName, int flags, int *); 166 static int fsFullPathname(sqlite3_vfs*, const char *zName, int nOut,char *zOut); 167 static void *fsDlOpen(sqlite3_vfs*, const char *zFilename); 168 static void fsDlError(sqlite3_vfs*, int nByte, char *zErrMsg); 169 static void (*fsDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void); 170 static void fsDlClose(sqlite3_vfs*, void*); 171 static int fsRandomness(sqlite3_vfs*, int nByte, char *zOut); 172 static int fsSleep(sqlite3_vfs*, int microseconds); 173 static int fsCurrentTime(sqlite3_vfs*, double*); 174 175 176 typedef struct fs_vfs_t fs_vfs_t; 177 struct fs_vfs_t { 178 sqlite3_vfs base; 179 fs_real_file *pFileList; 180 sqlite3_vfs *pParent; 181 }; 182 183 static fs_vfs_t fs_vfs = { 184 { 185 1, /* iVersion */ 186 0, /* szOsFile */ 187 0, /* mxPathname */ 188 0, /* pNext */ 189 FS_VFS_NAME, /* zName */ 190 0, /* pAppData */ 191 fsOpen, /* xOpen */ 192 fsDelete, /* xDelete */ 193 fsAccess, /* xAccess */ 194 fsFullPathname, /* xFullPathname */ 195 fsDlOpen, /* xDlOpen */ 196 fsDlError, /* xDlError */ 197 fsDlSym, /* xDlSym */ 198 fsDlClose, /* xDlClose */ 199 fsRandomness, /* xRandomness */ 200 fsSleep, /* xSleep */ 201 fsCurrentTime, /* xCurrentTime */ 202 0 /* xCurrentTimeInt64 */ 203 }, 204 0, /* pFileList */ 205 0 /* pParent */ 206 }; 207 208 static sqlite3_io_methods fs_io_methods = { 209 1, /* iVersion */ 210 fsClose, /* xClose */ 211 fsRead, /* xRead */ 212 fsWrite, /* xWrite */ 213 fsTruncate, /* xTruncate */ 214 fsSync, /* xSync */ 215 fsFileSize, /* xFileSize */ 216 fsLock, /* xLock */ 217 fsUnlock, /* xUnlock */ 218 fsCheckReservedLock, /* xCheckReservedLock */ 219 fsFileControl, /* xFileControl */ 220 fsSectorSize, /* xSectorSize */ 221 fsDeviceCharacteristics, /* xDeviceCharacteristics */ 222 0, /* xShmMap */ 223 0, /* xShmLock */ 224 0, /* xShmBarrier */ 225 0 /* xShmUnmap */ 226 }; 227 228 229 static sqlite3_io_methods tmp_io_methods = { 230 1, /* iVersion */ 231 tmpClose, /* xClose */ 232 tmpRead, /* xRead */ 233 tmpWrite, /* xWrite */ 234 tmpTruncate, /* xTruncate */ 235 tmpSync, /* xSync */ 236 tmpFileSize, /* xFileSize */ 237 tmpLock, /* xLock */ 238 tmpUnlock, /* xUnlock */ 239 tmpCheckReservedLock, /* xCheckReservedLock */ 240 tmpFileControl, /* xFileControl */ 241 tmpSectorSize, /* xSectorSize */ 242 tmpDeviceCharacteristics, /* xDeviceCharacteristics */ 243 0, /* xShmMap */ 244 0, /* xShmLock */ 245 0, /* xShmBarrier */ 246 0 /* xShmUnmap */ 247 }; 248 249 /* Useful macros used in several places */ 250 #define MIN(x,y) ((x)<(y)?(x):(y)) 251 #define MAX(x,y) ((x)>(y)?(x):(y)) 252 253 254 /* 255 ** Close a tmp-file. 256 */ 257 static int tmpClose(sqlite3_file *pFile){ 258 tmp_file *pTmp = (tmp_file *)pFile; 259 sqlite3_free(pTmp->zAlloc); 260 return SQLITE_OK; 261 } 262 263 /* 264 ** Read data from a tmp-file. 265 */ 266 static int tmpRead( 267 sqlite3_file *pFile, 268 void *zBuf, 269 int iAmt, 270 sqlite_int64 iOfst 271 ){ 272 tmp_file *pTmp = (tmp_file *)pFile; 273 if( (iAmt+iOfst)>pTmp->nSize ){ 274 return SQLITE_IOERR_SHORT_READ; 275 } 276 memcpy(zBuf, &pTmp->zAlloc[iOfst], iAmt); 277 return SQLITE_OK; 278 } 279 280 /* 281 ** Write data to a tmp-file. 282 */ 283 static int tmpWrite( 284 sqlite3_file *pFile, 285 const void *zBuf, 286 int iAmt, 287 sqlite_int64 iOfst 288 ){ 289 tmp_file *pTmp = (tmp_file *)pFile; 290 if( (iAmt+iOfst)>pTmp->nAlloc ){ 291 int nNew = 2*(iAmt+iOfst+pTmp->nAlloc); 292 char *zNew = sqlite3_realloc(pTmp->zAlloc, nNew); 293 if( !zNew ){ 294 return SQLITE_NOMEM; 295 } 296 pTmp->zAlloc = zNew; 297 pTmp->nAlloc = nNew; 298 } 299 memcpy(&pTmp->zAlloc[iOfst], zBuf, iAmt); 300 pTmp->nSize = MAX(pTmp->nSize, iOfst+iAmt); 301 return SQLITE_OK; 302 } 303 304 /* 305 ** Truncate a tmp-file. 306 */ 307 static int tmpTruncate(sqlite3_file *pFile, sqlite_int64 size){ 308 tmp_file *pTmp = (tmp_file *)pFile; 309 pTmp->nSize = MIN(pTmp->nSize, size); 310 return SQLITE_OK; 311 } 312 313 /* 314 ** Sync a tmp-file. 315 */ 316 static int tmpSync(sqlite3_file *pFile, int flags){ 317 return SQLITE_OK; 318 } 319 320 /* 321 ** Return the current file-size of a tmp-file. 322 */ 323 static int tmpFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ 324 tmp_file *pTmp = (tmp_file *)pFile; 325 *pSize = pTmp->nSize; 326 return SQLITE_OK; 327 } 328 329 /* 330 ** Lock a tmp-file. 331 */ 332 static int tmpLock(sqlite3_file *pFile, int eLock){ 333 return SQLITE_OK; 334 } 335 336 /* 337 ** Unlock a tmp-file. 338 */ 339 static int tmpUnlock(sqlite3_file *pFile, int eLock){ 340 return SQLITE_OK; 341 } 342 343 /* 344 ** Check if another file-handle holds a RESERVED lock on a tmp-file. 345 */ 346 static int tmpCheckReservedLock(sqlite3_file *pFile, int *pResOut){ 347 *pResOut = 0; 348 return SQLITE_OK; 349 } 350 351 /* 352 ** File control method. For custom operations on a tmp-file. 353 */ 354 static int tmpFileControl(sqlite3_file *pFile, int op, void *pArg){ 355 return SQLITE_OK; 356 } 357 358 /* 359 ** Return the sector-size in bytes for a tmp-file. 360 */ 361 static int tmpSectorSize(sqlite3_file *pFile){ 362 return 0; 363 } 364 365 /* 366 ** Return the device characteristic flags supported by a tmp-file. 367 */ 368 static int tmpDeviceCharacteristics(sqlite3_file *pFile){ 369 return 0; 370 } 371 372 /* 373 ** Close an fs-file. 374 */ 375 static int fsClose(sqlite3_file *pFile){ 376 int rc = SQLITE_OK; 377 fs_file *p = (fs_file *)pFile; 378 fs_real_file *pReal = p->pReal; 379 380 /* Decrement the real_file ref-count. */ 381 pReal->nRef--; 382 assert(pReal->nRef>=0); 383 384 /* When the ref-count reaches 0, destroy the structure */ 385 if( pReal->nRef==0 ){ 386 *pReal->ppThis = pReal->pNext; 387 if( pReal->pNext ){ 388 pReal->pNext->ppThis = pReal->ppThis; 389 } 390 rc = pReal->pFile->pMethods->xClose(pReal->pFile); 391 sqlite3_free(pReal); 392 } 393 394 return rc; 395 } 396 397 /* 398 ** Read data from an fs-file. 399 */ 400 static int fsRead( 401 sqlite3_file *pFile, 402 void *zBuf, 403 int iAmt, 404 sqlite_int64 iOfst 405 ){ 406 int rc = SQLITE_OK; 407 fs_file *p = (fs_file *)pFile; 408 fs_real_file *pReal = p->pReal; 409 sqlite3_file *pF = pReal->pFile; 410 411 if( (p->eType==DATABASE_FILE && (iAmt+iOfst)>pReal->nDatabase) 412 || (p->eType==JOURNAL_FILE && (iAmt+iOfst)>pReal->nJournal) 413 ){ 414 rc = SQLITE_IOERR_SHORT_READ; 415 }else if( p->eType==DATABASE_FILE ){ 416 rc = pF->pMethods->xRead(pF, zBuf, iAmt, iOfst+BLOCKSIZE); 417 }else{ 418 /* Journal file. */ 419 int iRem = iAmt; 420 int iBuf = 0; 421 int ii = iOfst; 422 while( iRem>0 && rc==SQLITE_OK ){ 423 int iRealOff = pReal->nBlob - BLOCKSIZE*((ii/BLOCKSIZE)+1) + ii%BLOCKSIZE; 424 int iRealAmt = MIN(iRem, BLOCKSIZE - (iRealOff%BLOCKSIZE)); 425 426 rc = pF->pMethods->xRead(pF, &((char *)zBuf)[iBuf], iRealAmt, iRealOff); 427 ii += iRealAmt; 428 iBuf += iRealAmt; 429 iRem -= iRealAmt; 430 } 431 } 432 433 return rc; 434 } 435 436 /* 437 ** Write data to an fs-file. 438 */ 439 static int fsWrite( 440 sqlite3_file *pFile, 441 const void *zBuf, 442 int iAmt, 443 sqlite_int64 iOfst 444 ){ 445 int rc = SQLITE_OK; 446 fs_file *p = (fs_file *)pFile; 447 fs_real_file *pReal = p->pReal; 448 sqlite3_file *pF = pReal->pFile; 449 450 if( p->eType==DATABASE_FILE ){ 451 if( (iAmt+iOfst+BLOCKSIZE)>(pReal->nBlob-pReal->nJournal) ){ 452 rc = SQLITE_FULL; 453 }else{ 454 rc = pF->pMethods->xWrite(pF, zBuf, iAmt, iOfst+BLOCKSIZE); 455 if( rc==SQLITE_OK ){ 456 pReal->nDatabase = MAX(pReal->nDatabase, iAmt+iOfst); 457 } 458 } 459 }else{ 460 /* Journal file. */ 461 int iRem = iAmt; 462 int iBuf = 0; 463 int ii = iOfst; 464 while( iRem>0 && rc==SQLITE_OK ){ 465 int iRealOff = pReal->nBlob - BLOCKSIZE*((ii/BLOCKSIZE)+1) + ii%BLOCKSIZE; 466 int iRealAmt = MIN(iRem, BLOCKSIZE - (iRealOff%BLOCKSIZE)); 467 468 if( iRealOff<(pReal->nDatabase+BLOCKSIZE) ){ 469 rc = SQLITE_FULL; 470 }else{ 471 rc = pF->pMethods->xWrite(pF, &((char *)zBuf)[iBuf], iRealAmt,iRealOff); 472 ii += iRealAmt; 473 iBuf += iRealAmt; 474 iRem -= iRealAmt; 475 } 476 } 477 if( rc==SQLITE_OK ){ 478 pReal->nJournal = MAX(pReal->nJournal, iAmt+iOfst); 479 } 480 } 481 482 return rc; 483 } 484 485 /* 486 ** Truncate an fs-file. 487 */ 488 static int fsTruncate(sqlite3_file *pFile, sqlite_int64 size){ 489 fs_file *p = (fs_file *)pFile; 490 fs_real_file *pReal = p->pReal; 491 if( p->eType==DATABASE_FILE ){ 492 pReal->nDatabase = MIN(pReal->nDatabase, size); 493 }else{ 494 pReal->nJournal = MIN(pReal->nJournal, size); 495 } 496 return SQLITE_OK; 497 } 498 499 /* 500 ** Sync an fs-file. 501 */ 502 static int fsSync(sqlite3_file *pFile, int flags){ 503 fs_file *p = (fs_file *)pFile; 504 fs_real_file *pReal = p->pReal; 505 sqlite3_file *pRealFile = pReal->pFile; 506 int rc = SQLITE_OK; 507 508 if( p->eType==DATABASE_FILE ){ 509 unsigned char zSize[4]; 510 zSize[0] = (pReal->nDatabase&0xFF000000)>>24; 511 zSize[1] = (pReal->nDatabase&0x00FF0000)>>16; 512 zSize[2] = (pReal->nDatabase&0x0000FF00)>>8; 513 zSize[3] = (pReal->nDatabase&0x000000FF); 514 rc = pRealFile->pMethods->xWrite(pRealFile, zSize, 4, 0); 515 } 516 if( rc==SQLITE_OK ){ 517 rc = pRealFile->pMethods->xSync(pRealFile, flags&(~SQLITE_SYNC_DATAONLY)); 518 } 519 520 return rc; 521 } 522 523 /* 524 ** Return the current file-size of an fs-file. 525 */ 526 static int fsFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ 527 fs_file *p = (fs_file *)pFile; 528 fs_real_file *pReal = p->pReal; 529 if( p->eType==DATABASE_FILE ){ 530 *pSize = pReal->nDatabase; 531 }else{ 532 *pSize = pReal->nJournal; 533 } 534 return SQLITE_OK; 535 } 536 537 /* 538 ** Lock an fs-file. 539 */ 540 static int fsLock(sqlite3_file *pFile, int eLock){ 541 return SQLITE_OK; 542 } 543 544 /* 545 ** Unlock an fs-file. 546 */ 547 static int fsUnlock(sqlite3_file *pFile, int eLock){ 548 return SQLITE_OK; 549 } 550 551 /* 552 ** Check if another file-handle holds a RESERVED lock on an fs-file. 553 */ 554 static int fsCheckReservedLock(sqlite3_file *pFile, int *pResOut){ 555 *pResOut = 0; 556 return SQLITE_OK; 557 } 558 559 /* 560 ** File control method. For custom operations on an fs-file. 561 */ 562 static int fsFileControl(sqlite3_file *pFile, int op, void *pArg){ 563 return SQLITE_OK; 564 } 565 566 /* 567 ** Return the sector-size in bytes for an fs-file. 568 */ 569 static int fsSectorSize(sqlite3_file *pFile){ 570 return BLOCKSIZE; 571 } 572 573 /* 574 ** Return the device characteristic flags supported by an fs-file. 575 */ 576 static int fsDeviceCharacteristics(sqlite3_file *pFile){ 577 return 0; 578 } 579 580 /* 581 ** Open an fs file handle. 582 */ 583 static int fsOpen( 584 sqlite3_vfs *pVfs, 585 const char *zName, 586 sqlite3_file *pFile, 587 int flags, 588 int *pOutFlags 589 ){ 590 fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs; 591 fs_file *p = (fs_file *)pFile; 592 fs_real_file *pReal = 0; 593 int eType; 594 int nName; 595 int rc = SQLITE_OK; 596 597 if( 0==(flags&(SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_MAIN_JOURNAL)) ){ 598 tmp_file *p = (tmp_file *)pFile; 599 memset(p, 0, sizeof(*p)); 600 p->base.pMethods = &tmp_io_methods; 601 return SQLITE_OK; 602 } 603 604 eType = ((flags&(SQLITE_OPEN_MAIN_DB))?DATABASE_FILE:JOURNAL_FILE); 605 p->base.pMethods = &fs_io_methods; 606 p->eType = eType; 607 608 assert(strlen("-journal")==8); 609 nName = strlen(zName)-((eType==JOURNAL_FILE)?8:0); 610 pReal=pFsVfs->pFileList; 611 for(; pReal && strncmp(pReal->zName, zName, nName); pReal=pReal->pNext); 612 613 if( !pReal ){ 614 int real_flags = (flags&~(SQLITE_OPEN_MAIN_DB))|SQLITE_OPEN_TEMP_DB; 615 sqlite3_int64 size; 616 sqlite3_file *pRealFile; 617 sqlite3_vfs *pParent = pFsVfs->pParent; 618 assert(eType==DATABASE_FILE); 619 620 pReal = (fs_real_file *)sqlite3_malloc(sizeof(*pReal)+pParent->szOsFile); 621 if( !pReal ){ 622 rc = SQLITE_NOMEM; 623 goto open_out; 624 } 625 memset(pReal, 0, sizeof(*pReal)+pParent->szOsFile); 626 pReal->zName = zName; 627 pReal->pFile = (sqlite3_file *)(&pReal[1]); 628 629 rc = pParent->xOpen(pParent, zName, pReal->pFile, real_flags, pOutFlags); 630 if( rc!=SQLITE_OK ){ 631 goto open_out; 632 } 633 pRealFile = pReal->pFile; 634 635 rc = pRealFile->pMethods->xFileSize(pRealFile, &size); 636 if( rc!=SQLITE_OK ){ 637 goto open_out; 638 } 639 if( size==0 ){ 640 rc = pRealFile->pMethods->xWrite(pRealFile, "\0", 1, BLOBSIZE-1); 641 pReal->nBlob = BLOBSIZE; 642 }else{ 643 unsigned char zS[4]; 644 pReal->nBlob = size; 645 rc = pRealFile->pMethods->xRead(pRealFile, zS, 4, 0); 646 pReal->nDatabase = (zS[0]<<24)+(zS[1]<<16)+(zS[2]<<8)+zS[3]; 647 if( rc==SQLITE_OK ){ 648 rc = pRealFile->pMethods->xRead(pRealFile, zS, 4, pReal->nBlob-4); 649 if( zS[0] || zS[1] || zS[2] || zS[3] ){ 650 pReal->nJournal = pReal->nBlob; 651 } 652 } 653 } 654 655 if( rc==SQLITE_OK ){ 656 pReal->pNext = pFsVfs->pFileList; 657 if( pReal->pNext ){ 658 pReal->pNext->ppThis = &pReal->pNext; 659 } 660 pReal->ppThis = &pFsVfs->pFileList; 661 pFsVfs->pFileList = pReal; 662 } 663 } 664 665 open_out: 666 if( pReal ){ 667 if( rc==SQLITE_OK ){ 668 p->pReal = pReal; 669 pReal->nRef++; 670 }else{ 671 if( pReal->pFile->pMethods ){ 672 pReal->pFile->pMethods->xClose(pReal->pFile); 673 } 674 sqlite3_free(pReal); 675 } 676 } 677 return rc; 678 } 679 680 /* 681 ** Delete the file located at zPath. If the dirSync argument is true, 682 ** ensure the file-system modifications are synced to disk before 683 ** returning. 684 */ 685 static int fsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ 686 int rc = SQLITE_OK; 687 fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs; 688 fs_real_file *pReal; 689 sqlite3_file *pF; 690 int nName = strlen(zPath) - 8; 691 692 assert(strlen("-journal")==8); 693 assert(strcmp("-journal", &zPath[nName])==0); 694 695 pReal = pFsVfs->pFileList; 696 for(; pReal && strncmp(pReal->zName, zPath, nName); pReal=pReal->pNext); 697 if( pReal ){ 698 pF = pReal->pFile; 699 rc = pF->pMethods->xWrite(pF, "\0\0\0\0", 4, pReal->nBlob-BLOCKSIZE); 700 if( rc==SQLITE_OK ){ 701 pReal->nJournal = 0; 702 } 703 } 704 return rc; 705 } 706 707 /* 708 ** Test for access permissions. Return true if the requested permission 709 ** is available, or false otherwise. 710 */ 711 static int fsAccess( 712 sqlite3_vfs *pVfs, 713 const char *zPath, 714 int flags, 715 int *pResOut 716 ){ 717 fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs; 718 fs_real_file *pReal; 719 int isJournal = 0; 720 int nName = strlen(zPath); 721 722 if( flags!=SQLITE_ACCESS_EXISTS ){ 723 sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent; 724 return pParent->xAccess(pParent, zPath, flags, pResOut); 725 } 726 727 assert(strlen("-journal")==8); 728 if( nName>8 && strcmp("-journal", &zPath[nName-8])==0 ){ 729 nName -= 8; 730 isJournal = 1; 731 } 732 733 pReal = pFsVfs->pFileList; 734 for(; pReal && strncmp(pReal->zName, zPath, nName); pReal=pReal->pNext); 735 736 *pResOut = (pReal && (!isJournal || pReal->nJournal>0)); 737 return SQLITE_OK; 738 } 739 740 /* 741 ** Populate buffer zOut with the full canonical pathname corresponding 742 ** to the pathname in zPath. zOut is guaranteed to point to a buffer 743 ** of at least (FS_MAX_PATHNAME+1) bytes. 744 */ 745 static int fsFullPathname( 746 sqlite3_vfs *pVfs, /* Pointer to vfs object */ 747 const char *zPath, /* Possibly relative input path */ 748 int nOut, /* Size of output buffer in bytes */ 749 char *zOut /* Output buffer */ 750 ){ 751 sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent; 752 return pParent->xFullPathname(pParent, zPath, nOut, zOut); 753 } 754 755 /* 756 ** Open the dynamic library located at zPath and return a handle. 757 */ 758 static void *fsDlOpen(sqlite3_vfs *pVfs, const char *zPath){ 759 sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent; 760 return pParent->xDlOpen(pParent, zPath); 761 } 762 763 /* 764 ** Populate the buffer zErrMsg (size nByte bytes) with a human readable 765 ** utf-8 string describing the most recent error encountered associated 766 ** with dynamic libraries. 767 */ 768 static void fsDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){ 769 sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent; 770 pParent->xDlError(pParent, nByte, zErrMsg); 771 } 772 773 /* 774 ** Return a pointer to the symbol zSymbol in the dynamic library pHandle. 775 */ 776 static void (*fsDlSym(sqlite3_vfs *pVfs, void *pH, const char *zSym))(void){ 777 sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent; 778 return pParent->xDlSym(pParent, pH, zSym); 779 } 780 781 /* 782 ** Close the dynamic library handle pHandle. 783 */ 784 static void fsDlClose(sqlite3_vfs *pVfs, void *pHandle){ 785 sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent; 786 pParent->xDlClose(pParent, pHandle); 787 } 788 789 /* 790 ** Populate the buffer pointed to by zBufOut with nByte bytes of 791 ** random data. 792 */ 793 static int fsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ 794 sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent; 795 return pParent->xRandomness(pParent, nByte, zBufOut); 796 } 797 798 /* 799 ** Sleep for nMicro microseconds. Return the number of microseconds 800 ** actually slept. 801 */ 802 static int fsSleep(sqlite3_vfs *pVfs, int nMicro){ 803 sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent; 804 return pParent->xSleep(pParent, nMicro); 805 } 806 807 /* 808 ** Return the current time as a Julian Day number in *pTimeOut. 809 */ 810 static int fsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ 811 sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent; 812 return pParent->xCurrentTime(pParent, pTimeOut); 813 } 814 815 /* 816 ** This procedure registers the fs vfs with SQLite. If the argument is 817 ** true, the fs vfs becomes the new default vfs. It is the only publicly 818 ** available function in this file. 819 */ 820 int fs_register(void){ 821 if( fs_vfs.pParent ) return SQLITE_OK; 822 fs_vfs.pParent = sqlite3_vfs_find(0); 823 fs_vfs.base.mxPathname = fs_vfs.pParent->mxPathname; 824 fs_vfs.base.szOsFile = MAX(sizeof(tmp_file), sizeof(fs_file)); 825 return sqlite3_vfs_register(&fs_vfs.base, 0); 826 } 827 828 #ifdef SQLITE_TEST 829 int SqlitetestOnefile_Init() {return fs_register();} 830 #endif 831
