Subversion Repositories Kolibri OS

#if !defined(SQLITE_TEST) || _KOLIBRI

#include "sqlite3.h"

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

/*

** Size of the write buffer used by journal files in bytes.

*/

#ifndef SQLITE_DEMOVFS_BUFFERSZ

# define SQLITE_DEMOVFS_BUFFERSZ 8192

#endif

/*

** The maximum pathname length supported by this VFS.

*/

#define MAXPATHNAME 512

sqlite3_vfs *sqlite3_kosvfs(void);

/*

** When using this VFS, the sqlite3_file* handles that SQLite uses are

** actually pointers to instances of type KosFile.

*/

typedef struct KosFile KosFile;

struct KosFile {

  sqlite3_file base;              /* Base class. Must be first. */

  int fd;                         /* File descriptor */

  char *aBuffer;                  /* Pointer to malloc'd buffer */

  int nBuffer;                    /* Valid bytes of data in zBuffer */

  sqlite3_int64 iBufferOfst;      /* Offset in file of zBuffer[0] */

};

/*

** Write directly to the file passed as the first argument. Even if the

** file has a write-buffer (KosFile.aBuffer), ignore it.

*/

static int kosDirectWrite(

  KosFile *p,                    /* File handle */

  const void *zBuf,               /* Buffer containing data to write */

  int iAmt,                       /* Size of data to write in bytes */

  sqlite_int64 iOfst              /* File offset to write to */

){

  off_t ofst;                     /* Return value from lseek() */

  size_t nWrite;                  /* Return value from write() */

  ofst = lseek(p->fd, iOfst, SEEK_SET);

  if( ofst!=iOfst ){

    return SQLITE_IOERR_WRITE;

  }

  nWrite = write(p->fd, zBuf, iAmt);

  if( nWrite!=iAmt ){

    return SQLITE_IOERR_WRITE;

  }

  return SQLITE_OK;

}

/*

** Flush the contents of the KosFile.aBuffer buffer to disk. This is a

** no-op if this particular file does not have a buffer (i.e. it is not

** a journal file) or if the buffer is currently empty.

*/

int sqlite3_os_init(){

   return sqlite3_vfs_register(sqlite3_kosvfs(), 0);

}

static int kosFlushBuffer(KosFile *p){

  int rc = SQLITE_OK;

  if( p->nBuffer ){

    rc = kosDirectWrite(p, p->aBuffer, p->nBuffer, p->iBufferOfst);

    p->nBuffer = 0;

  }

  return rc;

}

/*

** Close a file.

*/

static int kosClose(sqlite3_file *pFile){

  int rc;

  KosFile *p = (KosFile*)pFile;

  rc = kosFlushBuffer(p);

  sqlite3_free(p->aBuffer);

  close(p->fd);

  return rc;

}

/*

** Read data from a file.

*/

static int kosRead(

  sqlite3_file *pFile,

  void *zBuf,

  int iAmt,

  sqlite_int64 iOfst

){

  KosFile *p = (KosFile*)pFile;

  off_t ofst;                     /* Return value from lseek() */

  int nRead;                      /* Return value from read() */

  int rc;                         /* Return code from kosFlushBuffer() */

  /* Flush any data in the write buffer to disk in case this operation

  ** is trying to read data the file-region currently cached in the buffer.

  ** It would be possible to detect this case and possibly save an

  ** unnecessary write here, but in practice SQLite will rarely read from

  ** a journal file when there is data cached in the write-buffer.

  */

  rc = kosFlushBuffer(p);

  if( rc!=SQLITE_OK ){

    return rc;

  }

  ofst = lseek(p->fd, iOfst, SEEK_SET);

  if( ofst!=iOfst ){

    return SQLITE_IOERR_READ;

  }

  nRead = read(p->fd, zBuf, iAmt);

  if( nRead==iAmt ){

    return SQLITE_OK;

  }else if( nRead>=0 ){

    if( nRead

      memset(&((char*)zBuf)[nRead], 0, iAmt-nRead);

    }

    return SQLITE_IOERR_SHORT_READ;

  }

  return SQLITE_IOERR_READ;

}

/*

** Write data to a crash-file.

*/

static int kosWrite(

  sqlite3_file *pFile,

  const void *zBuf,

  int iAmt,

  sqlite_int64 iOfst

){

  KosFile *p = (KosFile*)pFile;

  if( p->aBuffer ){

    char *z = (char *)zBuf;       /* Pointer to remaining data to write */

    int n = iAmt;                 /* Number of bytes at z */

    sqlite3_int64 i = iOfst;      /* File offset to write to */

    while( n>0 ){

      int nCopy;                  /* Number of bytes to copy into buffer */

      /* If the buffer is full, or if this data is not being written directly

      ** following the data already buffered, flush the buffer. Flushing

      ** the buffer is a no-op if it is empty.

      */

      if( p->nBuffer==SQLITE_DEMOVFS_BUFFERSZ || p->iBufferOfst+p->nBuffer!=i ){

        int rc = kosFlushBuffer(p);

        if( rc!=SQLITE_OK ){

          return rc;

        }

      }

      assert( p->nBuffer==0 || p->iBufferOfst+p->nBuffer==i );

      p->iBufferOfst = i - p->nBuffer;

      /* Copy as much data as possible into the buffer. */

      nCopy = SQLITE_DEMOVFS_BUFFERSZ - p->nBuffer;

      if( nCopy>n ){

        nCopy = n;

      }

      memcpy(&p->aBuffer[p->nBuffer], z, nCopy);

      p->nBuffer += nCopy;

      n -= nCopy;

      i += nCopy;

      z += nCopy;

    }

  }else{

    return kosDirectWrite(p, zBuf, iAmt, iOfst);

  }

  return SQLITE_OK;

}

/*

** Truncate a file. This is a no-op for this VFS (see header comments at

** the top of the file).

*/

static int kosTruncate(sqlite3_file *pFile, sqlite_int64 size){

#if 0

  if( ftruncate(((KosFile *)pFile)->fd, size) ) return SQLITE_IOERR_TRUNCATE;

#endif

  return SQLITE_OK;

}

/*

** Sync the contents of the file to the persistent media.

*/

static int kosSync(sqlite3_file *pFile, int flags){

  KosFile *p = (KosFile*)pFile;

  int rc;

  rc = kosFlushBuffer(p);

  if( rc!=SQLITE_OK ){

    return rc;

  }

  rc = fsync(p->fd);

  return (rc==0 ? SQLITE_OK : SQLITE_IOERR_FSYNC);

}

/*

** Write the size of the file in bytes to *pSize.

*/

static int kosFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){

  KosFile *p = (KosFile*)pFile;

  int rc;                         /* Return code from fstat() call */

  struct stat sStat;              /* Output of fstat() call */

  /* Flush the contents of the buffer to disk. As with the flush in the

  ** kosRead() method, it would be possible to avoid this and save a write

  ** here and there. But in practice this comes up so infrequently it is

  ** not worth the trouble.

  */

  rc = kosFlushBuffer(p);

  if( rc!=SQLITE_OK ){

    return rc;

  }

  rc = fstat(p->fd, &sStat);

  if( rc!=0 ) return SQLITE_IOERR_FSTAT;

  *pSize = sStat.st_size;

  return SQLITE_OK;

}

/*

** Locking functions. The xLock() and xUnlock() methods are both no-ops.

** The xCheckReservedLock() always indicates that no other process holds

** a reserved lock on the database file. This ensures that if a hot-journal

** file is found in the file-system it is rolled back.

*/

static int kosLock(sqlite3_file *pFile, int eLock){

  return SQLITE_OK;

}

static int kosUnlock(sqlite3_file *pFile, int eLock){

  return SQLITE_OK;

}

static int kosCheckReservedLock(sqlite3_file *pFile, int *pResOut){

  *pResOut = 0;

  return SQLITE_OK;

}

/*

** No xFileControl() verbs are implemented by this VFS.

*/

static int kosFileControl(sqlite3_file *pFile, int op, void *pArg){

  return SQLITE_NOTFOUND;

}

/*

** The xSectorSize() and xDeviceCharacteristics() methods. These two

** may return special values allowing SQLite to optimize file-system

** access to some extent. But it is also safe to simply return 0.

*/

static int kosSectorSize(sqlite3_file *pFile){

  return 0;

}

static int kosDeviceCharacteristics(sqlite3_file *pFile){

  return 0;

}

/*

** Open a file handle.

*/

static int kosOpen(

  sqlite3_vfs *pVfs,              /* VFS */

  const char *zName,              /* File to open, or 0 for a temp file */

  sqlite3_file *pFile,            /* Pointer to KosFile struct to populate */

  int flags,                      /* Input SQLITE_OPEN_XXX flags */

  int *pOutFlags                  /* Output SQLITE_OPEN_XXX flags (or NULL) */

){

  static const sqlite3_io_methods kosio = {

    1,                            /* iVersion */

    kosClose,                    /* xClose */

    kosRead,                     /* xRead */

    kosWrite,                    /* xWrite */

    kosTruncate,                 /* xTruncate */

    kosSync,                     /* xSync */

    kosFileSize,                 /* xFileSize */

    kosLock,                     /* xLock */

    kosUnlock,                   /* xUnlock */

    kosCheckReservedLock,        /* xCheckReservedLock */

    kosFileControl,              /* xFileControl */

    kosSectorSize,               /* xSectorSize */

    kosDeviceCharacteristics     /* xDeviceCharacteristics */

  };

  KosFile *p = (KosFile*)pFile; /* Populate this structure */

  int oflags = 0;                 /* flags to pass to open() call */

  char *aBuf = 0;

  if( zName==0 ){

    return SQLITE_IOERR;

  }

  if( flags&SQLITE_OPEN_MAIN_JOURNAL ){

    aBuf = (char *)sqlite3_malloc(SQLITE_DEMOVFS_BUFFERSZ);

    if( !aBuf ){

      return SQLITE_NOMEM;

    }

  }

  if( flags&SQLITE_OPEN_EXCLUSIVE ) oflags |= O_EXCL;

  if( flags&SQLITE_OPEN_CREATE )    oflags |= O_CREAT;

  if( flags&SQLITE_OPEN_READONLY )  oflags |= O_RDONLY;

  if( flags&SQLITE_OPEN_READWRITE ) oflags |= O_RDWR;

  memset(p, 0, sizeof(KosFile));

  p->fd = open(zName, oflags, 0600);

  if( p->fd<0 ){

    sqlite3_free(aBuf);

    return SQLITE_CANTOPEN;

  }

  p->aBuffer = aBuf;

  if( pOutFlags ){

    *pOutFlags = flags;

  }

  p->base.pMethods = &kosio;

  return SQLITE_OK;

}

/*

** Delete the file identified by argument zPath. If the dirSync parameter

** is non-zero, then ensure the file-system modification to delete the

** file has been synced to disk before returning.

*/

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

  int rc;                         /* Return code */

  rc = unlink(zPath);

  if( rc!=0 && errno==ENOENT ) return SQLITE_OK;

  if( rc==0 && dirSync ){

    int dfd;                      /* File descriptor open on directory */

    int i;                        /* Iterator variable */

    char zDir[MAXPATHNAME+1];     /* Name of directory containing file zPath */

    /* Figure out the directory name from the path of the file deleted. */

    sqlite3_snprintf(MAXPATHNAME, zDir, "%s", zPath);

    zDir[MAXPATHNAME] = '\0';

    for(i=strlen(zDir); i>1 && zDir[i]!='/'; i++);

    zDir[i] = '\0';

    /* Open a file-descriptor on the directory. Sync. Close. */

    dfd = open(zDir, O_RDONLY, 0);

    if( dfd<0 ){

      rc = -1;

    }else{

      rc = fsync(dfd);

      close(dfd);

    }

  }

  return (rc==0 ? SQLITE_OK : SQLITE_IOERR_DELETE);

}

#ifndef F_OK

# define F_OK 0

#endif

#ifndef R_OK

# define R_OK 4

#endif

#ifndef W_OK

# define W_OK 2

#endif

/*

** Query the file-system to see if the named file exists, is readable or

** is both readable and writable.

*/

static int kosAccess(

  sqlite3_vfs *pVfs,

  const char *zPath,

  int flags,

  int *pResOut

){

  int rc;                         /* access() return code */

  int eAccess = F_OK;             /* Second argument to access() */

  assert( flags==SQLITE_ACCESS_EXISTS       /* access(zPath, F_OK) */

       || flags==SQLITE_ACCESS_READ         /* access(zPath, R_OK) */

       || flags==SQLITE_ACCESS_READWRITE    /* access(zPath, R_OK|W_OK) */

  );

  if( flags==SQLITE_ACCESS_READWRITE ) eAccess = R_OK|W_OK;

  if( flags==SQLITE_ACCESS_READ )      eAccess = R_OK;

  rc = access(zPath, eAccess);

  *pResOut = (rc==0);

  return SQLITE_OK;

}

/*

** Argument zPath points to a nul-terminated string containing a file path.

** If zPath is an absolute path, then it is copied as is into the output

** buffer. Otherwise, if it is a relative path, then the equivalent full

** path is written to the output buffer.

**

** This function assumes that paths are UNIX style. Specifically, that:

**

**   1. Path components are separated by a '/'. and

**   2. Full paths begin with a '/' character.

*/

static int kosFullPathname(

  sqlite3_vfs *pVfs,              /* VFS */

  const char *zPath,              /* Input path (possibly a relative path) */

  int nPathOut,                   /* Size of output buffer in bytes */

  char *zPathOut                  /* Pointer to output buffer */

){

  char zDir[MAXPATHNAME+1];

  if( zPath[0]=='/' ){

    zDir[0] = '\0';

  }else{

    if( getcwd(zDir, sizeof(zDir))==0 ) return SQLITE_IOERR;

  }

  zDir[MAXPATHNAME] = '\0';

  sqlite3_snprintf(nPathOut, zPathOut, "%s/%s", zDir, zPath);

  zPathOut[nPathOut-1] = '\0';

  return SQLITE_OK;

}

/*

** The following four VFS methods:

**

**   xDlOpen

**   xDlError

**   xDlSym

**   xDlClose

**

** are supposed to implement the functionality needed by SQLite to load

** extensions compiled as shared objects. This simple VFS does not support

** this functionality, so the following functions are no-ops.

*/

static void *kosDlOpen(sqlite3_vfs *pVfs, const char *zPath){

  return 0;

}

static void kosDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){

  sqlite3_snprintf(nByte, zErrMsg, "Loadable extensions are not supported");

  zErrMsg[nByte-1] = '\0';

}

static void (*kosDlSym(sqlite3_vfs *pVfs, void *pH, const char *z))(void){

  return 0;

}

static void kosDlClose(sqlite3_vfs *pVfs, void *pHandle){

  return;

}

/*

** Parameter zByte points to a buffer nByte bytes in size. Populate this

** buffer with pseudo-random data.

*/

static int kosRandomness(sqlite3_vfs *pVfs, int nByte, char *zByte){

  return SQLITE_OK;

}

/*

** Sleep for at least nMicro microseconds. Return the (approximate) number

** of microseconds slept for.

*/

static int kosSleep(sqlite3_vfs *pVfs, int nMicro){

  sleep(nMicro / 1000000);

  usleep(nMicro % 1000000);

  return nMicro;

}

/*

** Set *pTime to the current UTC time expressed as a Julian day. Return

** SQLITE_OK if successful, or an error code otherwise.

**

**   http://en.wikipedia.org/wiki/Julian_day

**

** This implementation is not very good. The current time is rounded to

** an integer number of seconds. Also, assuming time_t is a signed 32-bit

** value, it will stop working some time in the year 2038 AD (the so-called

** "year 2038" problem that afflicts systems that store time this way).

*/

static int kosCurrentTime(sqlite3_vfs *pVfs, double *pTime){

  time_t t = time(0);

  *pTime = t/86400.0 + 2440587.5;

  return SQLITE_OK;

}

/*

** This function returns a pointer to the VFS implemented in this file.

** To make the VFS available to SQLite:

**

**   sqlite3_vfs_register(sqlite3_kosvfs(), 0);

*/

sqlite3_vfs *sqlite3_kosvfs(void){

  static sqlite3_vfs kosvfs = {

    1,                            /* iVersion */

    sizeof(KosFile),             /* szOsFile */

    MAXPATHNAME,                  /* mxPathname */

    0,                            /* pNext */

    "kos",                       /* zName */

    0,                            /* pAppData */

    kosOpen,                     /* xOpen */

    kosDelete,                   /* xDelete */

    kosAccess,                   /* xAccess */

    kosFullPathname,             /* xFullPathname */

    kosDlOpen,                   /* xDlOpen */

    kosDlError,                  /* xDlError */

    kosDlSym,                    /* xDlSym */

    kosDlClose,                  /* xDlClose */

    kosRandomness,               /* xRandomness */

    kosSleep,                    /* xSleep */

    kosCurrentTime,              /* xCurrentTime */

  };

  return &kosvfs;

}

SQLITE_API int sqlite3_os_end(void){

  return SQLITE_OK;

}

void _ksys_sleep(unsigned time)

{

    __asm__ __volatile__(

    "int $0x40"

    ::"a"(5), "b"(time)

    :"memory");

};

unsigned sleep(unsigned time){

  _ksys_sleep(time*100);

  return 0;

}

int usleep(useconds_t usec){

   _ksys_sleep(usec);

   return 0;

}

int fsync(int fd){

  return 0;

}

#endif /* !defined(SQLITE_TEST) || SQLITE_OS_UNIX */

#ifdef SQLITE_TEST

#if defined(INCLUDE_SQLITE_TCL_H)

#  include "sqlite_tcl.h"

#else

#  include "tcl.h"

#  ifndef SQLITE_TCLAPI

#    define SQLITE_TCLAPI

#  endif

#endif

#if SQLITE_OS_UNIX

static int SQLITE_TCLAPI register_kosvfs(

  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */

  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

  int objc,              /* Number of arguments */

  Tcl_Obj *CONST objv[]  /* Command arguments */

){

  sqlite3_vfs_register(sqlite3_kosvfs(), 1);

  return TCL_OK;

}

static int SQLITE_TCLAPI unregister_kosvfs(

  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */

  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

  int objc,              /* Number of arguments */

  Tcl_Obj *CONST objv[]  /* Command arguments */

){

  sqlite3_vfs_unregister(sqlite3_kosvfs());

  return TCL_OK;

}

/*

** Register commands with the TCL interpreter.

*/

int Sqlitetest_kosvfs_Init(Tcl_Interp *interp){

  Tcl_CreateObjCommand(interp, "register_kosvfs", register_kosvfs, 0, 0);

  Tcl_CreateObjCommand(interp, "unregister_kosvfs", unregister_kosvfs, 0, 0);

  return TCL_OK;

}

#else

int Sqlitetest_kosvfs_Init(Tcl_Interp *interp){ return TCL_OK; }

#endif

#endif /* SQLITE_TEST */