/*

** 2005 November 29

**

** 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 OS interface code that is common to all

** architectures.

*/

#define _SQLITE_OS_C_ 1

#include "sqliteInt.h"

#undef _SQLITE_OS_C_

/*

** The default SQLite sqlite3_vfs implementations do not allocate

** memory (actually, os_unix.c allocates a small amount of memory

** from within OsOpen()), but some third-party implementations may.

** So we test the effects of a malloc() failing and the sqlite3OsXXX()

** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.

**

** The following functions are instrumented for malloc() failure 

** testing:

**

**     sqlite3OsOpen()

**     sqlite3OsRead()

**     sqlite3OsWrite()

**     sqlite3OsSync()

**     sqlite3OsLock()

**

*/

#ifdef SQLITE_TEST

  #define DO_OS_MALLOC_TEST if (1) {            \

    void *pTstAlloc = sqlite3_malloc(10);       \

    if (!pTstAlloc) return SQLITE_IOERR_NOMEM;  \

    sqlite3_free(pTstAlloc);                    \

  }

#else

  #define DO_OS_MALLOC_TEST

#endif

/*

** The following routines are convenience wrappers around methods

** of the sqlite3_file object.  This is mostly just syntactic sugar. All

** of this would be completely automatic if SQLite were coded using

** C++ instead of plain old C.

*/

int sqlite3OsClose(sqlite3_file *pId){

  int rc = SQLITE_OK;

  if( pId->pMethods ){

    rc = pId->pMethods->xClose(pId);

    pId->pMethods = 0;

  }

  return rc;

}

int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){

  DO_OS_MALLOC_TEST;

  return id->pMethods->xRead(id, pBuf, amt, offset);

}

int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){

  DO_OS_MALLOC_TEST;

  return id->pMethods->xWrite(id, pBuf, amt, offset);

}

int sqlite3OsTruncate(sqlite3_file *id, i64 size){

  return id->pMethods->xTruncate(id, size);

}

int sqlite3OsSync(sqlite3_file *id, int flags){

  DO_OS_MALLOC_TEST;

  return id->pMethods->xSync(id, flags);

}

int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){

  return id->pMethods->xFileSize(id, pSize);

}

int sqlite3OsLock(sqlite3_file *id, int lockType){

  DO_OS_MALLOC_TEST;

  return id->pMethods->xLock(id, lockType);

}

int sqlite3OsUnlock(sqlite3_file *id, int lockType){

  return id->pMethods->xUnlock(id, lockType);

}

int sqlite3OsCheckReservedLock(sqlite3_file *id){

  return id->pMethods->xCheckReservedLock(id);

}

int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){

  return id->pMethods->xFileControl(id,op,pArg);

}

#ifdef SQLITE_TEST

  /* The following two variables are used to override the values returned

  ** by the xSectorSize() and xDeviceCharacteristics() vfs methods for

  ** testing purposes. They are usually set by a test command implemented

  ** in test6.c.

  */

  int sqlite3_test_sector_size = 0;

  int sqlite3_test_device_characteristics = 0;

  int sqlite3OsDeviceCharacteristics(sqlite3_file *id){

    int dc = id->pMethods->xDeviceCharacteristics(id);

    return dc | sqlite3_test_device_characteristics;

  }

  int sqlite3OsSectorSize(sqlite3_file *id){

    if( sqlite3_test_sector_size==0 ){

      int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize;

      return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);

    }

    return sqlite3_test_sector_size;

  }

#else

  int sqlite3OsSectorSize(sqlite3_file *id){

    int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize;

    return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);

  }

  int sqlite3OsDeviceCharacteristics(sqlite3_file *id){

    return id->pMethods->xDeviceCharacteristics(id);

  }

#endif

/*

** The next group of routines are convenience wrappers around the

** VFS methods.

*/

int sqlite3OsOpen(

  sqlite3_vfs *pVfs, 

  const char *zPath, 

  sqlite3_file *pFile, 

  int flags, 

  int *pFlagsOut

){

  DO_OS_MALLOC_TEST;

  return pVfs->xOpen(pVfs, zPath, pFile, flags, pFlagsOut);

}

int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){

  return pVfs->xDelete(pVfs, zPath, dirSync);

}

int sqlite3OsAccess(sqlite3_vfs *pVfs, const char *zPath, int flags){

  return pVfs->xAccess(pVfs, zPath, flags);

}

int sqlite3OsGetTempname(sqlite3_vfs *pVfs, int nBufOut, char *zBufOut){

  return pVfs->xGetTempname(pVfs, nBufOut, zBufOut);

}

int sqlite3OsFullPathname(

  sqlite3_vfs *pVfs, 

  const char *zPath, 

  int nPathOut, 

  char *zPathOut

){

  return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);

}

void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){

  return pVfs->xDlOpen(pVfs, zPath);

}

void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){

  pVfs->xDlError(pVfs, nByte, zBufOut);

}

void *sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){

  return pVfs->xDlSym(pVfs, pHandle, zSymbol);

}

void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){

  pVfs->xDlClose(pVfs, pHandle);

}

int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){

  return pVfs->xRandomness(pVfs, nByte, zBufOut);

}

int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){

  return pVfs->xSleep(pVfs, nMicro);

}

int sqlite3OsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){

  return pVfs->xCurrentTime(pVfs, pTimeOut);

}

int sqlite3OsOpenMalloc(

  sqlite3_vfs *pVfs, 

  const char *zFile, 

  sqlite3_file **ppFile, 

  int flags,

  int *pOutFlags

){

  int rc = SQLITE_NOMEM;

  sqlite3_file *pFile;

  pFile = (sqlite3_file *)sqlite3_malloc(pVfs->szOsFile);

  if( pFile ){

    rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);

    if( rc!=SQLITE_OK ){

      sqlite3_free(pFile);

    }else{

      *ppFile = pFile;

    }

  }

  return rc;

}

int sqlite3OsCloseFree(sqlite3_file *pFile){

  int rc = SQLITE_OK;

  if( pFile ){

    rc = sqlite3OsClose(pFile);

    sqlite3_free(pFile);

  }

  return rc;

}

/*

** The list of all registered VFS implementations.  This list is

** initialized to the single VFS returned by sqlite3OsDefaultVfs()

** upon the first call to sqlite3_vfs_find().

*/

static sqlite3_vfs *vfsList = 0;

/*

** Locate a VFS by name.  If no name is given, simply return the

** first VFS on the list.

*/

sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){

  sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);

  sqlite3_vfs *pVfs;

  static int isInit = 0;

  sqlite3_mutex_enter(mutex);

  if( !isInit ){

    vfsList = sqlite3OsDefaultVfs();

    isInit = 1;

  }

  for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){

    if( zVfs==0 ) break;

    if( strcmp(zVfs, pVfs->zName)==0 ) break;

  }

  sqlite3_mutex_leave(mutex);

  return pVfs;

}

/*

** Unlink a VFS from the linked list

*/

static void vfsUnlink(sqlite3_vfs *pVfs){

  assert( sqlite3_mutex_held(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER)) );

  if( vfsList==pVfs ){

    vfsList = pVfs->pNext;

  }else{

    sqlite3_vfs *p = vfsList;

    while( p->pNext && p->pNext!=pVfs ){

      p = p->pNext;

    }

    if( p->pNext==pVfs ){

      p->pNext = pVfs->pNext;

    }

  }

}

/*

** Register a VFS with the system.  It is harmless to register the same

** VFS multiple times.  The new VFS becomes the default if makeDflt is

** true.

*/

int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){

  sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);

  sqlite3_vfs_find(0);  /* Make sure we are initialized */

  sqlite3_mutex_enter(mutex);

  vfsUnlink(pVfs);

  if( makeDflt || vfsList==0 ){

    pVfs->pNext = vfsList;

    vfsList = pVfs;

  }else{

    pVfs->pNext = vfsList->pNext;

    vfsList->pNext = pVfs;

  }

  assert(vfsList);

  sqlite3_mutex_leave(mutex);

  return SQLITE_OK;

}

/*

** Unregister a VFS so that it is no longer accessible.

*/

int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){

  sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);

  sqlite3_mutex_enter(mutex);

  vfsUnlink(pVfs);

  assert(vfsList);

  sqlite3_mutex_leave(mutex);

  return SQLITE_OK;

}