sl@0: /*
sl@0: ** 2006 Feb 14
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: ******************************************************************************
sl@0: **
sl@0: ** This file contains code that is specific to OS/2.
sl@0: **
sl@0: ** $Id: os_os2.c,v 1.55 2008/07/29 18:49:29 pweilbacher Exp $
sl@0: */
sl@0: 
sl@0: #include "sqliteInt.h"
sl@0: 
sl@0: #if SQLITE_OS_OS2
sl@0: 
sl@0: /*
sl@0: ** A Note About Memory Allocation:
sl@0: **
sl@0: ** This driver uses malloc()/free() directly rather than going through
sl@0: ** the SQLite-wrappers sqlite3_malloc()/sqlite3_free().  Those wrappers
sl@0: ** are designed for use on embedded systems where memory is scarce and
sl@0: ** malloc failures happen frequently.  OS/2 does not typically run on
sl@0: ** embedded systems, and when it does the developers normally have bigger
sl@0: ** problems to worry about than running out of memory.  So there is not
sl@0: ** a compelling need to use the wrappers.
sl@0: **
sl@0: ** But there is a good reason to not use the wrappers.  If we use the
sl@0: ** wrappers then we will get simulated malloc() failures within this
sl@0: ** driver.  And that causes all kinds of problems for our tests.  We
sl@0: ** could enhance SQLite to deal with simulated malloc failures within
sl@0: ** the OS driver, but the code to deal with those failure would not
sl@0: ** be exercised on Linux (which does not need to malloc() in the driver)
sl@0: ** and so we would have difficulty writing coverage tests for that
sl@0: ** code.  Better to leave the code out, we think.
sl@0: **
sl@0: ** The point of this discussion is as follows:  When creating a new
sl@0: ** OS layer for an embedded system, if you use this file as an example,
sl@0: ** avoid the use of malloc()/free().  Those routines work ok on OS/2
sl@0: ** desktops but not so well in embedded systems.
sl@0: */
sl@0: 
sl@0: /*
sl@0: ** Macros used to determine whether or not to use threads.
sl@0: */
sl@0: #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE
sl@0: # define SQLITE_OS2_THREADS 1
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Include code that is common to all os_*.c files
sl@0: */
sl@0: #include "os_common.h"
sl@0: 
sl@0: /*
sl@0: ** The os2File structure is subclass of sqlite3_file specific for the OS/2
sl@0: ** protability layer.
sl@0: */
sl@0: typedef struct os2File os2File;
sl@0: struct os2File {
sl@0:   const sqlite3_io_methods *pMethod;  /* Always the first entry */
sl@0:   HFILE h;                  /* Handle for accessing the file */
sl@0:   char* pathToDel;          /* Name of file to delete on close, NULL if not */
sl@0:   unsigned char locktype;   /* Type of lock currently held on this file */
sl@0: };
sl@0: 
sl@0: #define LOCK_TIMEOUT 10L /* the default locking timeout */
sl@0: 
sl@0: /*****************************************************************************
sl@0: ** The next group of routines implement the I/O methods specified
sl@0: ** by the sqlite3_io_methods object.
sl@0: ******************************************************************************/
sl@0: 
sl@0: /*
sl@0: ** Close a file.
sl@0: */
sl@0: static int os2Close( sqlite3_file *id ){
sl@0:   APIRET rc = NO_ERROR;
sl@0:   os2File *pFile;
sl@0:   if( id && (pFile = (os2File*)id) != 0 ){
sl@0:     OSTRACE2( "CLOSE %d\n", pFile->h );
sl@0:     rc = DosClose( pFile->h );
sl@0:     pFile->locktype = NO_LOCK;
sl@0:     if( pFile->pathToDel != NULL ){
sl@0:       rc = DosForceDelete( (PSZ)pFile->pathToDel );
sl@0:       free( pFile->pathToDel );
sl@0:       pFile->pathToDel = NULL;
sl@0:     }
sl@0:     id = 0;
sl@0:     OpenCounter( -1 );
sl@0:   }
sl@0: 
sl@0:   return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Read data from a file into a buffer.  Return SQLITE_OK if all
sl@0: ** bytes were read successfully and SQLITE_IOERR if anything goes
sl@0: ** wrong.
sl@0: */
sl@0: static int os2Read(
sl@0:   sqlite3_file *id,               /* File to read from */
sl@0:   void *pBuf,                     /* Write content into this buffer */
sl@0:   int amt,                        /* Number of bytes to read */
sl@0:   sqlite3_int64 offset            /* Begin reading at this offset */
sl@0: ){
sl@0:   ULONG fileLocation = 0L;
sl@0:   ULONG got;
sl@0:   os2File *pFile = (os2File*)id;
sl@0:   assert( id!=0 );
sl@0:   SimulateIOError( return SQLITE_IOERR_READ );
sl@0:   OSTRACE3( "READ %d lock=%d\n", pFile->h, pFile->locktype );
sl@0:   if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
sl@0:     return SQLITE_IOERR;
sl@0:   }
sl@0:   if( DosRead( pFile->h, pBuf, amt, &got ) != NO_ERROR ){
sl@0:     return SQLITE_IOERR_READ;
sl@0:   }
sl@0:   if( got == (ULONG)amt )
sl@0:     return SQLITE_OK;
sl@0:   else {
sl@0:     memset(&((char*)pBuf)[got], 0, amt-got);
sl@0:     return SQLITE_IOERR_SHORT_READ;
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Write data from a buffer into a file.  Return SQLITE_OK on success
sl@0: ** or some other error code on failure.
sl@0: */
sl@0: static int os2Write(
sl@0:   sqlite3_file *id,               /* File to write into */
sl@0:   const void *pBuf,               /* The bytes to be written */
sl@0:   int amt,                        /* Number of bytes to write */
sl@0:   sqlite3_int64 offset            /* Offset into the file to begin writing at */
sl@0: ){
sl@0:   ULONG fileLocation = 0L;
sl@0:   APIRET rc = NO_ERROR;
sl@0:   ULONG wrote;
sl@0:   os2File *pFile = (os2File*)id;
sl@0:   assert( id!=0 );
sl@0:   SimulateIOError( return SQLITE_IOERR_WRITE );
sl@0:   SimulateDiskfullError( return SQLITE_FULL );
sl@0:   OSTRACE3( "WRITE %d lock=%d\n", pFile->h, pFile->locktype );
sl@0:   if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
sl@0:     return SQLITE_IOERR;
sl@0:   }
sl@0:   assert( amt>0 );
sl@0:   while( amt > 0 &&
sl@0:          ( rc = DosWrite( pFile->h, (PVOID)pBuf, amt, &wrote ) ) == NO_ERROR &&
sl@0:          wrote > 0
sl@0:   ){
sl@0:     amt -= wrote;
sl@0:     pBuf = &((char*)pBuf)[wrote];
sl@0:   }
sl@0: 
sl@0:   return ( rc != NO_ERROR || amt > (int)wrote ) ? SQLITE_FULL : SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Truncate an open file to a specified size
sl@0: */
sl@0: static int os2Truncate( sqlite3_file *id, i64 nByte ){
sl@0:   APIRET rc = NO_ERROR;
sl@0:   os2File *pFile = (os2File*)id;
sl@0:   OSTRACE3( "TRUNCATE %d %lld\n", pFile->h, nByte );
sl@0:   SimulateIOError( return SQLITE_IOERR_TRUNCATE );
sl@0:   rc = DosSetFileSize( pFile->h, nByte );
sl@0:   return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
sl@0: }
sl@0: 
sl@0: #ifdef SQLITE_TEST
sl@0: /*
sl@0: ** Count the number of fullsyncs and normal syncs.  This is used to test
sl@0: ** that syncs and fullsyncs are occuring at the right times.
sl@0: */
sl@0: int sqlite3_sync_count = 0;
sl@0: int sqlite3_fullsync_count = 0;
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Make sure all writes to a particular file are committed to disk.
sl@0: */
sl@0: static int os2Sync( sqlite3_file *id, int flags ){
sl@0:   os2File *pFile = (os2File*)id;
sl@0:   OSTRACE3( "SYNC %d lock=%d\n", pFile->h, pFile->locktype );
sl@0: #ifdef SQLITE_TEST
sl@0:   if( flags & SQLITE_SYNC_FULL){
sl@0:     sqlite3_fullsync_count++;
sl@0:   }
sl@0:   sqlite3_sync_count++;
sl@0: #endif
sl@0:   return DosResetBuffer( pFile->h ) == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Determine the current size of a file in bytes
sl@0: */
sl@0: static int os2FileSize( sqlite3_file *id, sqlite3_int64 *pSize ){
sl@0:   APIRET rc = NO_ERROR;
sl@0:   FILESTATUS3 fsts3FileInfo;
sl@0:   memset(&fsts3FileInfo, 0, sizeof(fsts3FileInfo));
sl@0:   assert( id!=0 );
sl@0:   SimulateIOError( return SQLITE_IOERR );
sl@0:   rc = DosQueryFileInfo( ((os2File*)id)->h, FIL_STANDARD, &fsts3FileInfo, sizeof(FILESTATUS3) );
sl@0:   if( rc == NO_ERROR ){
sl@0:     *pSize = fsts3FileInfo.cbFile;
sl@0:     return SQLITE_OK;
sl@0:   }else{
sl@0:     return SQLITE_IOERR;
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Acquire a reader lock.
sl@0: */
sl@0: static int getReadLock( os2File *pFile ){
sl@0:   FILELOCK  LockArea,
sl@0:             UnlockArea;
sl@0:   APIRET res;
sl@0:   memset(&LockArea, 0, sizeof(LockArea));
sl@0:   memset(&UnlockArea, 0, sizeof(UnlockArea));
sl@0:   LockArea.lOffset = SHARED_FIRST;
sl@0:   LockArea.lRange = SHARED_SIZE;
sl@0:   UnlockArea.lOffset = 0L;
sl@0:   UnlockArea.lRange = 0L;
sl@0:   res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 1L );
sl@0:   OSTRACE3( "GETREADLOCK %d res=%d\n", pFile->h, res );
sl@0:   return res;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Undo a readlock
sl@0: */
sl@0: static int unlockReadLock( os2File *id ){
sl@0:   FILELOCK  LockArea,
sl@0:             UnlockArea;
sl@0:   APIRET res;
sl@0:   memset(&LockArea, 0, sizeof(LockArea));
sl@0:   memset(&UnlockArea, 0, sizeof(UnlockArea));
sl@0:   LockArea.lOffset = 0L;
sl@0:   LockArea.lRange = 0L;
sl@0:   UnlockArea.lOffset = SHARED_FIRST;
sl@0:   UnlockArea.lRange = SHARED_SIZE;
sl@0:   res = DosSetFileLocks( id->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 1L );
sl@0:   OSTRACE3( "UNLOCK-READLOCK file handle=%d res=%d?\n", id->h, res );
sl@0:   return res;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Lock the file with the lock specified by parameter locktype - one
sl@0: ** of the following:
sl@0: **
sl@0: **     (1) SHARED_LOCK
sl@0: **     (2) RESERVED_LOCK
sl@0: **     (3) PENDING_LOCK
sl@0: **     (4) EXCLUSIVE_LOCK
sl@0: **
sl@0: ** Sometimes when requesting one lock state, additional lock states
sl@0: ** are inserted in between.  The locking might fail on one of the later
sl@0: ** transitions leaving the lock state different from what it started but
sl@0: ** still short of its goal.  The following chart shows the allowed
sl@0: ** transitions and the inserted intermediate states:
sl@0: **
sl@0: **    UNLOCKED -> SHARED
sl@0: **    SHARED -> RESERVED
sl@0: **    SHARED -> (PENDING) -> EXCLUSIVE
sl@0: **    RESERVED -> (PENDING) -> EXCLUSIVE
sl@0: **    PENDING -> EXCLUSIVE
sl@0: **
sl@0: ** This routine will only increase a lock.  The os2Unlock() routine
sl@0: ** erases all locks at once and returns us immediately to locking level 0.
sl@0: ** It is not possible to lower the locking level one step at a time.  You
sl@0: ** must go straight to locking level 0.
sl@0: */
sl@0: static int os2Lock( sqlite3_file *id, int locktype ){
sl@0:   int rc = SQLITE_OK;       /* Return code from subroutines */
sl@0:   APIRET res = NO_ERROR;    /* Result of an OS/2 lock call */
sl@0:   int newLocktype;       /* Set pFile->locktype to this value before exiting */
sl@0:   int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
sl@0:   FILELOCK  LockArea,
sl@0:             UnlockArea;
sl@0:   os2File *pFile = (os2File*)id;
sl@0:   memset(&LockArea, 0, sizeof(LockArea));
sl@0:   memset(&UnlockArea, 0, sizeof(UnlockArea));
sl@0:   assert( pFile!=0 );
sl@0:   OSTRACE4( "LOCK %d %d was %d\n", pFile->h, locktype, pFile->locktype );
sl@0: 
sl@0:   /* If there is already a lock of this type or more restrictive on the
sl@0:   ** os2File, do nothing. Don't use the end_lock: exit path, as
sl@0:   ** sqlite3_mutex_enter() hasn't been called yet.
sl@0:   */
sl@0:   if( pFile->locktype>=locktype ){
sl@0:     OSTRACE3( "LOCK %d %d ok (already held)\n", pFile->h, locktype );
sl@0:     return SQLITE_OK;
sl@0:   }
sl@0: 
sl@0:   /* Make sure the locking sequence is correct
sl@0:   */
sl@0:   assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
sl@0:   assert( locktype!=PENDING_LOCK );
sl@0:   assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
sl@0: 
sl@0:   /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
sl@0:   ** a SHARED lock.  If we are acquiring a SHARED lock, the acquisition of
sl@0:   ** the PENDING_LOCK byte is temporary.
sl@0:   */
sl@0:   newLocktype = pFile->locktype;
sl@0:   if( pFile->locktype==NO_LOCK
sl@0:       || (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK)
sl@0:   ){
sl@0:     LockArea.lOffset = PENDING_BYTE;
sl@0:     LockArea.lRange = 1L;
sl@0:     UnlockArea.lOffset = 0L;
sl@0:     UnlockArea.lRange = 0L;
sl@0: 
sl@0:     /* wait longer than LOCK_TIMEOUT here not to have to try multiple times */
sl@0:     res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 100L, 0L );
sl@0:     if( res == NO_ERROR ){
sl@0:       gotPendingLock = 1;
sl@0:       OSTRACE3( "LOCK %d pending lock boolean set.  res=%d\n", pFile->h, res );
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   /* Acquire a shared lock
sl@0:   */
sl@0:   if( locktype==SHARED_LOCK && res == NO_ERROR ){
sl@0:     assert( pFile->locktype==NO_LOCK );
sl@0:     res = getReadLock(pFile);
sl@0:     if( res == NO_ERROR ){
sl@0:       newLocktype = SHARED_LOCK;
sl@0:     }
sl@0:     OSTRACE3( "LOCK %d acquire shared lock. res=%d\n", pFile->h, res );
sl@0:   }
sl@0: 
sl@0:   /* Acquire a RESERVED lock
sl@0:   */
sl@0:   if( locktype==RESERVED_LOCK && res == NO_ERROR ){
sl@0:     assert( pFile->locktype==SHARED_LOCK );
sl@0:     LockArea.lOffset = RESERVED_BYTE;
sl@0:     LockArea.lRange = 1L;
sl@0:     UnlockArea.lOffset = 0L;
sl@0:     UnlockArea.lRange = 0L;
sl@0:     res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
sl@0:     if( res == NO_ERROR ){
sl@0:       newLocktype = RESERVED_LOCK;
sl@0:     }
sl@0:     OSTRACE3( "LOCK %d acquire reserved lock. res=%d\n", pFile->h, res );
sl@0:   }
sl@0: 
sl@0:   /* Acquire a PENDING lock
sl@0:   */
sl@0:   if( locktype==EXCLUSIVE_LOCK && res == NO_ERROR ){
sl@0:     newLocktype = PENDING_LOCK;
sl@0:     gotPendingLock = 0;
sl@0:     OSTRACE2( "LOCK %d acquire pending lock. pending lock boolean unset.\n", pFile->h );
sl@0:   }
sl@0: 
sl@0:   /* Acquire an EXCLUSIVE lock
sl@0:   */
sl@0:   if( locktype==EXCLUSIVE_LOCK && res == NO_ERROR ){
sl@0:     assert( pFile->locktype>=SHARED_LOCK );
sl@0:     res = unlockReadLock(pFile);
sl@0:     OSTRACE2( "unreadlock = %d\n", res );
sl@0:     LockArea.lOffset = SHARED_FIRST;
sl@0:     LockArea.lRange = SHARED_SIZE;
sl@0:     UnlockArea.lOffset = 0L;
sl@0:     UnlockArea.lRange = 0L;
sl@0:     res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
sl@0:     if( res == NO_ERROR ){
sl@0:       newLocktype = EXCLUSIVE_LOCK;
sl@0:     }else{
sl@0:       OSTRACE2( "OS/2 error-code = %d\n", res );
sl@0:       getReadLock(pFile);
sl@0:     }
sl@0:     OSTRACE3( "LOCK %d acquire exclusive lock.  res=%d\n", pFile->h, res );
sl@0:   }
sl@0: 
sl@0:   /* If we are holding a PENDING lock that ought to be released, then
sl@0:   ** release it now.
sl@0:   */
sl@0:   if( gotPendingLock && locktype==SHARED_LOCK ){
sl@0:     int r;
sl@0:     LockArea.lOffset = 0L;
sl@0:     LockArea.lRange = 0L;
sl@0:     UnlockArea.lOffset = PENDING_BYTE;
sl@0:     UnlockArea.lRange = 1L;
sl@0:     r = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
sl@0:     OSTRACE3( "LOCK %d unlocking pending/is shared. r=%d\n", pFile->h, r );
sl@0:   }
sl@0: 
sl@0:   /* Update the state of the lock has held in the file descriptor then
sl@0:   ** return the appropriate result code.
sl@0:   */
sl@0:   if( res == NO_ERROR ){
sl@0:     rc = SQLITE_OK;
sl@0:   }else{
sl@0:     OSTRACE4( "LOCK FAILED %d trying for %d but got %d\n", pFile->h,
sl@0:               locktype, newLocktype );
sl@0:     rc = SQLITE_BUSY;
sl@0:   }
sl@0:   pFile->locktype = newLocktype;
sl@0:   OSTRACE3( "LOCK %d now %d\n", pFile->h, pFile->locktype );
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This routine checks if there is a RESERVED lock held on the specified
sl@0: ** file by this or any other process. If such a lock is held, return
sl@0: ** non-zero, otherwise zero.
sl@0: */
sl@0: static int os2CheckReservedLock( sqlite3_file *id, int *pOut ){
sl@0:   int r = 0;
sl@0:   os2File *pFile = (os2File*)id;
sl@0:   assert( pFile!=0 );
sl@0:   if( pFile->locktype>=RESERVED_LOCK ){
sl@0:     r = 1;
sl@0:     OSTRACE3( "TEST WR-LOCK %d %d (local)\n", pFile->h, r );
sl@0:   }else{
sl@0:     FILELOCK  LockArea,
sl@0:               UnlockArea;
sl@0:     APIRET rc = NO_ERROR;
sl@0:     memset(&LockArea, 0, sizeof(LockArea));
sl@0:     memset(&UnlockArea, 0, sizeof(UnlockArea));
sl@0:     LockArea.lOffset = RESERVED_BYTE;
sl@0:     LockArea.lRange = 1L;
sl@0:     UnlockArea.lOffset = 0L;
sl@0:     UnlockArea.lRange = 0L;
sl@0:     rc = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
sl@0:     OSTRACE3( "TEST WR-LOCK %d lock reserved byte rc=%d\n", pFile->h, rc );
sl@0:     if( rc == NO_ERROR ){
sl@0:       APIRET rcu = NO_ERROR; /* return code for unlocking */
sl@0:       LockArea.lOffset = 0L;
sl@0:       LockArea.lRange = 0L;
sl@0:       UnlockArea.lOffset = RESERVED_BYTE;
sl@0:       UnlockArea.lRange = 1L;
sl@0:       rcu = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
sl@0:       OSTRACE3( "TEST WR-LOCK %d unlock reserved byte r=%d\n", pFile->h, rcu );
sl@0:     }
sl@0:     r = !(rc == NO_ERROR);
sl@0:     OSTRACE3( "TEST WR-LOCK %d %d (remote)\n", pFile->h, r );
sl@0:   }
sl@0:   *pOut = r;
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Lower the locking level on file descriptor id to locktype.  locktype
sl@0: ** must be either NO_LOCK or SHARED_LOCK.
sl@0: **
sl@0: ** If the locking level of the file descriptor is already at or below
sl@0: ** the requested locking level, this routine is a no-op.
sl@0: **
sl@0: ** It is not possible for this routine to fail if the second argument
sl@0: ** is NO_LOCK.  If the second argument is SHARED_LOCK then this routine
sl@0: ** might return SQLITE_IOERR;
sl@0: */
sl@0: static int os2Unlock( sqlite3_file *id, int locktype ){
sl@0:   int type;
sl@0:   os2File *pFile = (os2File*)id;
sl@0:   APIRET rc = SQLITE_OK;
sl@0:   APIRET res = NO_ERROR;
sl@0:   FILELOCK  LockArea,
sl@0:             UnlockArea;
sl@0:   memset(&LockArea, 0, sizeof(LockArea));
sl@0:   memset(&UnlockArea, 0, sizeof(UnlockArea));
sl@0:   assert( pFile!=0 );
sl@0:   assert( locktype<=SHARED_LOCK );
sl@0:   OSTRACE4( "UNLOCK %d to %d was %d\n", pFile->h, locktype, pFile->locktype );
sl@0:   type = pFile->locktype;
sl@0:   if( type>=EXCLUSIVE_LOCK ){
sl@0:     LockArea.lOffset = 0L;
sl@0:     LockArea.lRange = 0L;
sl@0:     UnlockArea.lOffset = SHARED_FIRST;
sl@0:     UnlockArea.lRange = SHARED_SIZE;
sl@0:     res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
sl@0:     OSTRACE3( "UNLOCK %d exclusive lock res=%d\n", pFile->h, res );
sl@0:     if( locktype==SHARED_LOCK && getReadLock(pFile) != NO_ERROR ){
sl@0:       /* This should never happen.  We should always be able to
sl@0:       ** reacquire the read lock */
sl@0:       OSTRACE3( "UNLOCK %d to %d getReadLock() failed\n", pFile->h, locktype );
sl@0:       rc = SQLITE_IOERR_UNLOCK;
sl@0:     }
sl@0:   }
sl@0:   if( type>=RESERVED_LOCK ){
sl@0:     LockArea.lOffset = 0L;
sl@0:     LockArea.lRange = 0L;
sl@0:     UnlockArea.lOffset = RESERVED_BYTE;
sl@0:     UnlockArea.lRange = 1L;
sl@0:     res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
sl@0:     OSTRACE3( "UNLOCK %d reserved res=%d\n", pFile->h, res );
sl@0:   }
sl@0:   if( locktype==NO_LOCK && type>=SHARED_LOCK ){
sl@0:     res = unlockReadLock(pFile);
sl@0:     OSTRACE5( "UNLOCK %d is %d want %d res=%d\n", pFile->h, type, locktype, res );
sl@0:   }
sl@0:   if( type>=PENDING_LOCK ){
sl@0:     LockArea.lOffset = 0L;
sl@0:     LockArea.lRange = 0L;
sl@0:     UnlockArea.lOffset = PENDING_BYTE;
sl@0:     UnlockArea.lRange = 1L;
sl@0:     res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
sl@0:     OSTRACE3( "UNLOCK %d pending res=%d\n", pFile->h, res );
sl@0:   }
sl@0:   pFile->locktype = locktype;
sl@0:   OSTRACE3( "UNLOCK %d now %d\n", pFile->h, pFile->locktype );
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Control and query of the open file handle.
sl@0: */
sl@0: static int os2FileControl(sqlite3_file *id, int op, void *pArg){
sl@0:   switch( op ){
sl@0:     case SQLITE_FCNTL_LOCKSTATE: {
sl@0:       *(int*)pArg = ((os2File*)id)->locktype;
sl@0:       OSTRACE3( "FCNTL_LOCKSTATE %d lock=%d\n", ((os2File*)id)->h, ((os2File*)id)->locktype );
sl@0:       return SQLITE_OK;
sl@0:     }
sl@0:   }
sl@0:   return SQLITE_ERROR;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the sector size in bytes of the underlying block device for
sl@0: ** the specified file. This is almost always 512 bytes, but may be
sl@0: ** larger for some devices.
sl@0: **
sl@0: ** SQLite code assumes this function cannot fail. It also assumes that
sl@0: ** if two files are created in the same file-system directory (i.e.
sl@0: ** a database and its journal file) that the sector size will be the
sl@0: ** same for both.
sl@0: */
sl@0: static int os2SectorSize(sqlite3_file *id){
sl@0:   return SQLITE_DEFAULT_SECTOR_SIZE;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return a vector of device characteristics.
sl@0: */
sl@0: static int os2DeviceCharacteristics(sqlite3_file *id){
sl@0:   return 0;
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Character set conversion objects used by conversion routines.
sl@0: */
sl@0: static UconvObject ucUtf8 = NULL; /* convert between UTF-8 and UCS-2 */
sl@0: static UconvObject uclCp = NULL;  /* convert between local codepage and UCS-2 */
sl@0: 
sl@0: /*
sl@0: ** Helper function to initialize the conversion objects from and to UTF-8.
sl@0: */
sl@0: static void initUconvObjects( void ){
sl@0:   if( UniCreateUconvObject( UTF_8, &ucUtf8 ) != ULS_SUCCESS )
sl@0:     ucUtf8 = NULL;
sl@0:   if ( UniCreateUconvObject( (UniChar *)L"@path=yes", &uclCp ) != ULS_SUCCESS )
sl@0:     uclCp = NULL;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Helper function to free the conversion objects from and to UTF-8.
sl@0: */
sl@0: static void freeUconvObjects( void ){
sl@0:   if ( ucUtf8 )
sl@0:     UniFreeUconvObject( ucUtf8 );
sl@0:   if ( uclCp )
sl@0:     UniFreeUconvObject( uclCp );
sl@0:   ucUtf8 = NULL;
sl@0:   uclCp = NULL;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Helper function to convert UTF-8 filenames to local OS/2 codepage.
sl@0: ** The two-step process: first convert the incoming UTF-8 string
sl@0: ** into UCS-2 and then from UCS-2 to the current codepage.
sl@0: ** The returned char pointer has to be freed.
sl@0: */
sl@0: static char *convertUtf8PathToCp( const char *in ){
sl@0:   UniChar tempPath[CCHMAXPATH];
sl@0:   char *out = (char *)calloc( CCHMAXPATH, 1 );
sl@0: 
sl@0:   if( !out )
sl@0:     return NULL;
sl@0: 
sl@0:   if( !ucUtf8 || !uclCp )
sl@0:     initUconvObjects();
sl@0: 
sl@0:   /* determine string for the conversion of UTF-8 which is CP1208 */
sl@0:   if( UniStrToUcs( ucUtf8, tempPath, (char *)in, CCHMAXPATH ) != ULS_SUCCESS )
sl@0:     return out; /* if conversion fails, return the empty string */
sl@0: 
sl@0:   /* conversion for current codepage which can be used for paths */
sl@0:   UniStrFromUcs( uclCp, out, tempPath, CCHMAXPATH );
sl@0: 
sl@0:   return out;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Helper function to convert filenames from local codepage to UTF-8.
sl@0: ** The two-step process: first convert the incoming codepage-specific
sl@0: ** string into UCS-2 and then from UCS-2 to the codepage of UTF-8.
sl@0: ** The returned char pointer has to be freed.
sl@0: **
sl@0: ** This function is non-static to be able to use this in shell.c and
sl@0: ** similar applications that take command line arguments.
sl@0: */
sl@0: char *convertCpPathToUtf8( const char *in ){
sl@0:   UniChar tempPath[CCHMAXPATH];
sl@0:   char *out = (char *)calloc( CCHMAXPATH, 1 );
sl@0: 
sl@0:   if( !out )
sl@0:     return NULL;
sl@0: 
sl@0:   if( !ucUtf8 || !uclCp )
sl@0:     initUconvObjects();
sl@0: 
sl@0:   /* conversion for current codepage which can be used for paths */
sl@0:   if( UniStrToUcs( uclCp, tempPath, (char *)in, CCHMAXPATH ) != ULS_SUCCESS )
sl@0:     return out; /* if conversion fails, return the empty string */
sl@0: 
sl@0:   /* determine string for the conversion of UTF-8 which is CP1208 */
sl@0:   UniStrFromUcs( ucUtf8, out, tempPath, CCHMAXPATH );
sl@0: 
sl@0:   return out;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This vector defines all the methods that can operate on an
sl@0: ** sqlite3_file for os2.
sl@0: */
sl@0: static const sqlite3_io_methods os2IoMethod = {
sl@0:   1,                        /* iVersion */
sl@0:   os2Close,
sl@0:   os2Read,
sl@0:   os2Write,
sl@0:   os2Truncate,
sl@0:   os2Sync,
sl@0:   os2FileSize,
sl@0:   os2Lock,
sl@0:   os2Unlock,
sl@0:   os2CheckReservedLock,
sl@0:   os2FileControl,
sl@0:   os2SectorSize,
sl@0:   os2DeviceCharacteristics
sl@0: };
sl@0: 
sl@0: /***************************************************************************
sl@0: ** Here ends the I/O methods that form the sqlite3_io_methods object.
sl@0: **
sl@0: ** The next block of code implements the VFS methods.
sl@0: ****************************************************************************/
sl@0: 
sl@0: /*
sl@0: ** Create a temporary file name in zBuf.  zBuf must be big enough to
sl@0: ** hold at pVfs->mxPathname characters.
sl@0: */
sl@0: static int getTempname(int nBuf, char *zBuf ){
sl@0:   static const unsigned char zChars[] =
sl@0:     "abcdefghijklmnopqrstuvwxyz"
sl@0:     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
sl@0:     "0123456789";
sl@0:   int i, j;
sl@0:   char zTempPathBuf[3];
sl@0:   PSZ zTempPath = (PSZ)&zTempPathBuf;
sl@0:   if( sqlite3_temp_directory ){
sl@0:     zTempPath = sqlite3_temp_directory;
sl@0:   }else{
sl@0:     if( DosScanEnv( (PSZ)"TEMP", &zTempPath ) ){
sl@0:       if( DosScanEnv( (PSZ)"TMP", &zTempPath ) ){
sl@0:         if( DosScanEnv( (PSZ)"TMPDIR", &zTempPath ) ){
sl@0:            ULONG ulDriveNum = 0, ulDriveMap = 0;
sl@0:            DosQueryCurrentDisk( &ulDriveNum, &ulDriveMap );
sl@0:            sprintf( (char*)zTempPath, "%c:", (char)( 'A' + ulDriveNum - 1 ) );
sl@0:         }
sl@0:       }
sl@0:     }
sl@0:   }
sl@0:   /* Strip off a trailing slashes or backslashes, otherwise we would get *
sl@0:    * multiple (back)slashes which causes DosOpen() to fail.              *
sl@0:    * Trailing spaces are not allowed, either.                            */
sl@0:   j = strlen(zTempPath);
sl@0:   while( j > 0 && ( zTempPath[j-1] == '\\' || zTempPath[j-1] == '/'
sl@0:                     || zTempPath[j-1] == ' ' ) ){
sl@0:     j--;
sl@0:   }
sl@0:   zTempPath[j] = '\0';
sl@0:   if( !sqlite3_temp_directory ){
sl@0:     char *zTempPathUTF = convertCpPathToUtf8( zTempPath );
sl@0:     sqlite3_snprintf( nBuf-30, zBuf,
sl@0:                       "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPathUTF );
sl@0:     free( zTempPathUTF );
sl@0:   }else{
sl@0:     sqlite3_snprintf( nBuf-30, zBuf,
sl@0:                       "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath );
sl@0:   }
sl@0:   j = strlen( zBuf );
sl@0:   sqlite3_randomness( 20, &zBuf[j] );
sl@0:   for( i = 0; i < 20; i++, j++ ){
sl@0:     zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
sl@0:   }
sl@0:   zBuf[j] = 0;
sl@0:   OSTRACE2( "TEMP FILENAME: %s\n", zBuf );
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Turn a relative pathname into a full pathname.  Write the full
sl@0: ** pathname into zFull[].  zFull[] will be at least pVfs->mxPathname
sl@0: ** bytes in size.
sl@0: */
sl@0: static int os2FullPathname(
sl@0:   sqlite3_vfs *pVfs,          /* Pointer to vfs object */
sl@0:   const char *zRelative,      /* Possibly relative input path */
sl@0:   int nFull,                  /* Size of output buffer in bytes */
sl@0:   char *zFull                 /* Output buffer */
sl@0: ){
sl@0:   char *zRelativeCp = convertUtf8PathToCp( zRelative );
sl@0:   char zFullCp[CCHMAXPATH] = "\0";
sl@0:   char *zFullUTF;
sl@0:   APIRET rc = DosQueryPathInfo( zRelativeCp, FIL_QUERYFULLNAME, zFullCp,
sl@0:                                 CCHMAXPATH );
sl@0:   free( zRelativeCp );
sl@0:   zFullUTF = convertCpPathToUtf8( zFullCp );
sl@0:   sqlite3_snprintf( nFull, zFull, zFullUTF );
sl@0:   free( zFullUTF );
sl@0:   return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Open a file.
sl@0: */
sl@0: static int os2Open(
sl@0:   sqlite3_vfs *pVfs,            /* Not used */
sl@0:   const char *zName,            /* Name of the file */
sl@0:   sqlite3_file *id,             /* Write the SQLite file handle here */
sl@0:   int flags,                    /* Open mode flags */
sl@0:   int *pOutFlags                /* Status return flags */
sl@0: ){
sl@0:   HFILE h;
sl@0:   ULONG ulFileAttribute = 0;
sl@0:   ULONG ulOpenFlags = 0;
sl@0:   ULONG ulOpenMode = 0;
sl@0:   os2File *pFile = (os2File*)id;
sl@0:   APIRET rc = NO_ERROR;
sl@0:   ULONG ulAction;
sl@0:   char *zNameCp;
sl@0:   char zTmpname[CCHMAXPATH+1];    /* Buffer to hold name of temp file */
sl@0: 
sl@0:   /* If the second argument to this function is NULL, generate a 
sl@0:   ** temporary file name to use 
sl@0:   */
sl@0:   if( !zName ){
sl@0:     int rc = getTempname(CCHMAXPATH+1, zTmpname);
sl@0:     if( rc!=SQLITE_OK ){
sl@0:       return rc;
sl@0:     }
sl@0:     zName = zTmpname;
sl@0:   }
sl@0: 
sl@0: 
sl@0:   memset( pFile, 0, sizeof(*pFile) );
sl@0: 
sl@0:   OSTRACE2( "OPEN want %d\n", flags );
sl@0: 
sl@0:   /*ulOpenMode = flags & SQLITE_OPEN_READWRITE ? OPEN_ACCESS_READWRITE : OPEN_ACCESS_READONLY;*/
sl@0:   if( flags & SQLITE_OPEN_READWRITE ){
sl@0:     ulOpenMode |= OPEN_ACCESS_READWRITE;
sl@0:     OSTRACE1( "OPEN read/write\n" );
sl@0:   }else{
sl@0:     ulOpenMode |= OPEN_ACCESS_READONLY;
sl@0:     OSTRACE1( "OPEN read only\n" );
sl@0:   }
sl@0: 
sl@0:   /*ulOpenFlags = flags & SQLITE_OPEN_CREATE ? OPEN_ACTION_CREATE_IF_NEW : OPEN_ACTION_FAIL_IF_NEW;*/
sl@0:   if( flags & SQLITE_OPEN_CREATE ){
sl@0:     ulOpenFlags |= OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW;
sl@0:     OSTRACE1( "OPEN open new/create\n" );
sl@0:   }else{
sl@0:     ulOpenFlags |= OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW;
sl@0:     OSTRACE1( "OPEN open existing\n" );
sl@0:   }
sl@0: 
sl@0:   /*ulOpenMode |= flags & SQLITE_OPEN_MAIN_DB ? OPEN_SHARE_DENYNONE : OPEN_SHARE_DENYWRITE;*/
sl@0:   if( flags & SQLITE_OPEN_MAIN_DB ){
sl@0:     ulOpenMode |= OPEN_SHARE_DENYNONE;
sl@0:     OSTRACE1( "OPEN share read/write\n" );
sl@0:   }else{
sl@0:     ulOpenMode |= OPEN_SHARE_DENYWRITE;
sl@0:     OSTRACE1( "OPEN share read only\n" );
sl@0:   }
sl@0: 
sl@0:   if( flags & (SQLITE_OPEN_TEMP_DB | SQLITE_OPEN_TEMP_JOURNAL
sl@0:                | SQLITE_OPEN_SUBJOURNAL) ){
sl@0:     char pathUtf8[CCHMAXPATH];
sl@0: #ifdef NDEBUG /* when debugging we want to make sure it is deleted */
sl@0:     ulFileAttribute = FILE_HIDDEN;
sl@0: #endif
sl@0:     ulFileAttribute = FILE_NORMAL;
sl@0:     os2FullPathname( pVfs, zName, CCHMAXPATH, pathUtf8 );
sl@0:     pFile->pathToDel = convertUtf8PathToCp( pathUtf8 );
sl@0:     OSTRACE1( "OPEN hidden/delete on close file attributes\n" );
sl@0:   }else{
sl@0:     ulFileAttribute = FILE_ARCHIVED | FILE_NORMAL;
sl@0:     pFile->pathToDel = NULL;
sl@0:     OSTRACE1( "OPEN normal file attribute\n" );
sl@0:   }
sl@0: 
sl@0:   /* always open in random access mode for possibly better speed */
sl@0:   ulOpenMode |= OPEN_FLAGS_RANDOM;
sl@0:   ulOpenMode |= OPEN_FLAGS_FAIL_ON_ERROR;
sl@0:   ulOpenMode |= OPEN_FLAGS_NOINHERIT;
sl@0: 
sl@0:   zNameCp = convertUtf8PathToCp( zName );
sl@0:   rc = DosOpen( (PSZ)zNameCp,
sl@0:                 &h,
sl@0:                 &ulAction,
sl@0:                 0L,
sl@0:                 ulFileAttribute,
sl@0:                 ulOpenFlags,
sl@0:                 ulOpenMode,
sl@0:                 (PEAOP2)NULL );
sl@0:   free( zNameCp );
sl@0:   if( rc != NO_ERROR ){
sl@0:     OSTRACE7( "OPEN Invalid handle rc=%d: zName=%s, ulAction=%#lx, ulAttr=%#lx, ulFlags=%#lx, ulMode=%#lx\n",
sl@0:               rc, zName, ulAction, ulFileAttribute, ulOpenFlags, ulOpenMode );
sl@0:     if( pFile->pathToDel )
sl@0:       free( pFile->pathToDel );
sl@0:     pFile->pathToDel = NULL;
sl@0:     if( flags & SQLITE_OPEN_READWRITE ){
sl@0:       OSTRACE2( "OPEN %d Invalid handle\n", ((flags | SQLITE_OPEN_READONLY) & ~SQLITE_OPEN_READWRITE) );
sl@0:       return os2Open( pVfs, zName, id,
sl@0:                       ((flags | SQLITE_OPEN_READONLY) & ~SQLITE_OPEN_READWRITE),
sl@0:                       pOutFlags );
sl@0:     }else{
sl@0:       return SQLITE_CANTOPEN;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   if( pOutFlags ){
sl@0:     *pOutFlags = flags & SQLITE_OPEN_READWRITE ? SQLITE_OPEN_READWRITE : SQLITE_OPEN_READONLY;
sl@0:   }
sl@0: 
sl@0:   pFile->pMethod = &os2IoMethod;
sl@0:   pFile->h = h;
sl@0:   OpenCounter(+1);
sl@0:   OSTRACE3( "OPEN %d pOutFlags=%d\n", pFile->h, pOutFlags );
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Delete the named file.
sl@0: */
sl@0: static int os2Delete(
sl@0:   sqlite3_vfs *pVfs,                     /* Not used on os2 */
sl@0:   const char *zFilename,                 /* Name of file to delete */
sl@0:   int syncDir                            /* Not used on os2 */
sl@0: ){
sl@0:   APIRET rc = NO_ERROR;
sl@0:   char *zFilenameCp = convertUtf8PathToCp( zFilename );
sl@0:   SimulateIOError( return SQLITE_IOERR_DELETE );
sl@0:   rc = DosDelete( (PSZ)zFilenameCp );
sl@0:   free( zFilenameCp );
sl@0:   OSTRACE2( "DELETE \"%s\"\n", zFilename );
sl@0:   return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Check the existance and status of a file.
sl@0: */
sl@0: static int os2Access(
sl@0:   sqlite3_vfs *pVfs,        /* Not used on os2 */
sl@0:   const char *zFilename,    /* Name of file to check */
sl@0:   int flags,                /* Type of test to make on this file */
sl@0:   int *pOut                 /* Write results here */
sl@0: ){
sl@0:   FILESTATUS3 fsts3ConfigInfo;
sl@0:   APIRET rc = NO_ERROR;
sl@0:   char *zFilenameCp = convertUtf8PathToCp( zFilename );
sl@0: 
sl@0:   memset( &fsts3ConfigInfo, 0, sizeof(fsts3ConfigInfo) );
sl@0:   rc = DosQueryPathInfo( (PSZ)zFilenameCp, FIL_STANDARD,
sl@0:                          &fsts3ConfigInfo, sizeof(FILESTATUS3) );
sl@0:   free( zFilenameCp );
sl@0:   OSTRACE4( "ACCESS fsts3ConfigInfo.attrFile=%d flags=%d rc=%d\n",
sl@0:             fsts3ConfigInfo.attrFile, flags, rc );
sl@0:   switch( flags ){
sl@0:     case SQLITE_ACCESS_READ:
sl@0:     case SQLITE_ACCESS_EXISTS:
sl@0:       rc = (rc == NO_ERROR);
sl@0:       OSTRACE3( "ACCESS %s access of read and exists  rc=%d\n", zFilename, rc );
sl@0:       break;
sl@0:     case SQLITE_ACCESS_READWRITE:
sl@0:       rc = (rc == NO_ERROR) && ( (fsts3ConfigInfo.attrFile & FILE_READONLY) == 0 );
sl@0:       OSTRACE3( "ACCESS %s access of read/write  rc=%d\n", zFilename, rc );
sl@0:       break;
sl@0:     default:
sl@0:       assert( !"Invalid flags argument" );
sl@0:   }
sl@0:   *pOut = rc;
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: 
sl@0: #ifndef SQLITE_OMIT_LOAD_EXTENSION
sl@0: /*
sl@0: ** Interfaces for opening a shared library, finding entry points
sl@0: ** within the shared library, and closing the shared library.
sl@0: */
sl@0: /*
sl@0: ** Interfaces for opening a shared library, finding entry points
sl@0: ** within the shared library, and closing the shared library.
sl@0: */
sl@0: static void *os2DlOpen(sqlite3_vfs *pVfs, const char *zFilename){
sl@0:   UCHAR loadErr[256];
sl@0:   HMODULE hmod;
sl@0:   APIRET rc;
sl@0:   char *zFilenameCp = convertUtf8PathToCp(zFilename);
sl@0:   rc = DosLoadModule((PSZ)loadErr, sizeof(loadErr), zFilenameCp, &hmod);
sl@0:   free(zFilenameCp);
sl@0:   return rc != NO_ERROR ? 0 : (void*)hmod;
sl@0: }
sl@0: /*
sl@0: ** A no-op since the error code is returned on the DosLoadModule call.
sl@0: ** os2Dlopen returns zero if DosLoadModule is not successful.
sl@0: */
sl@0: static void os2DlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
sl@0: /* no-op */
sl@0: }
sl@0: static void *os2DlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
sl@0:   PFN pfn;
sl@0:   APIRET rc;
sl@0:   rc = DosQueryProcAddr((HMODULE)pHandle, 0L, zSymbol, &pfn);
sl@0:   if( rc != NO_ERROR ){
sl@0:     /* if the symbol itself was not found, search again for the same
sl@0:      * symbol with an extra underscore, that might be needed depending
sl@0:      * on the calling convention */
sl@0:     char _zSymbol[256] = "_";
sl@0:     strncat(_zSymbol, zSymbol, 255);
sl@0:     rc = DosQueryProcAddr((HMODULE)pHandle, 0L, _zSymbol, &pfn);
sl@0:   }
sl@0:   return rc != NO_ERROR ? 0 : (void*)pfn;
sl@0: }
sl@0: static void os2DlClose(sqlite3_vfs *pVfs, void *pHandle){
sl@0:   DosFreeModule((HMODULE)pHandle);
sl@0: }
sl@0: #else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
sl@0:   #define os2DlOpen 0
sl@0:   #define os2DlError 0
sl@0:   #define os2DlSym 0
sl@0:   #define os2DlClose 0
sl@0: #endif
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Write up to nBuf bytes of randomness into zBuf.
sl@0: */
sl@0: static int os2Randomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf ){
sl@0:   ULONG sizeofULong = sizeof(ULONG);
sl@0:   int n = 0;
sl@0:   if( sizeof(DATETIME) <= nBuf - n ){
sl@0:     DATETIME x;
sl@0:     DosGetDateTime(&x);
sl@0:     memcpy(&zBuf[n], &x, sizeof(x));
sl@0:     n += sizeof(x);
sl@0:   }
sl@0: 
sl@0:   if( sizeofULong <= nBuf - n ){
sl@0:     PPIB ppib;
sl@0:     DosGetInfoBlocks(NULL, &ppib);
sl@0:     memcpy(&zBuf[n], &ppib->pib_ulpid, sizeofULong);
sl@0:     n += sizeofULong;
sl@0:   }
sl@0: 
sl@0:   if( sizeofULong <= nBuf - n ){
sl@0:     PTIB ptib;
sl@0:     DosGetInfoBlocks(&ptib, NULL);
sl@0:     memcpy(&zBuf[n], &ptib->tib_ptib2->tib2_ultid, sizeofULong);
sl@0:     n += sizeofULong;
sl@0:   }
sl@0: 
sl@0:   /* if we still haven't filled the buffer yet the following will */
sl@0:   /* grab everything once instead of making several calls for a single item */
sl@0:   if( sizeofULong <= nBuf - n ){
sl@0:     ULONG ulSysInfo[QSV_MAX];
sl@0:     DosQuerySysInfo(1L, QSV_MAX, ulSysInfo, sizeofULong * QSV_MAX);
sl@0: 
sl@0:     memcpy(&zBuf[n], &ulSysInfo[QSV_MS_COUNT - 1], sizeofULong);
sl@0:     n += sizeofULong;
sl@0: 
sl@0:     if( sizeofULong <= nBuf - n ){
sl@0:       memcpy(&zBuf[n], &ulSysInfo[QSV_TIMER_INTERVAL - 1], sizeofULong);
sl@0:       n += sizeofULong;
sl@0:     }
sl@0:     if( sizeofULong <= nBuf - n ){
sl@0:       memcpy(&zBuf[n], &ulSysInfo[QSV_TIME_LOW - 1], sizeofULong);
sl@0:       n += sizeofULong;
sl@0:     }
sl@0:     if( sizeofULong <= nBuf - n ){
sl@0:       memcpy(&zBuf[n], &ulSysInfo[QSV_TIME_HIGH - 1], sizeofULong);
sl@0:       n += sizeofULong;
sl@0:     }
sl@0:     if( sizeofULong <= nBuf - n ){
sl@0:       memcpy(&zBuf[n], &ulSysInfo[QSV_TOTAVAILMEM - 1], sizeofULong);
sl@0:       n += sizeofULong;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   return n;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Sleep for a little while.  Return the amount of time slept.
sl@0: ** The argument is the number of microseconds we want to sleep.
sl@0: ** The return value is the number of microseconds of sleep actually
sl@0: ** requested from the underlying operating system, a number which
sl@0: ** might be greater than or equal to the argument, but not less
sl@0: ** than the argument.
sl@0: */
sl@0: static int os2Sleep( sqlite3_vfs *pVfs, int microsec ){
sl@0:   DosSleep( (microsec/1000) );
sl@0:   return microsec;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The following variable, if set to a non-zero value, becomes the result
sl@0: ** returned from sqlite3OsCurrentTime().  This is used for testing.
sl@0: */
sl@0: #ifdef SQLITE_TEST
sl@0: int sqlite3_current_time = 0;
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Find the current time (in Universal Coordinated Time).  Write the
sl@0: ** current time and date as a Julian Day number into *prNow and
sl@0: ** return 0.  Return 1 if the time and date cannot be found.
sl@0: */
sl@0: int os2CurrentTime( sqlite3_vfs *pVfs, double *prNow ){
sl@0:   double now;
sl@0:   SHORT minute; /* needs to be able to cope with negative timezone offset */
sl@0:   USHORT second, hour,
sl@0:          day, month, year;
sl@0:   DATETIME dt;
sl@0:   DosGetDateTime( &dt );
sl@0:   second = (USHORT)dt.seconds;
sl@0:   minute = (SHORT)dt.minutes + dt.timezone;
sl@0:   hour = (USHORT)dt.hours;
sl@0:   day = (USHORT)dt.day;
sl@0:   month = (USHORT)dt.month;
sl@0:   year = (USHORT)dt.year;
sl@0: 
sl@0:   /* Calculations from http://www.astro.keele.ac.uk/~rno/Astronomy/hjd.html
sl@0:      http://www.astro.keele.ac.uk/~rno/Astronomy/hjd-0.1.c */
sl@0:   /* Calculate the Julian days */
sl@0:   now = day - 32076 +
sl@0:     1461*(year + 4800 + (month - 14)/12)/4 +
sl@0:     367*(month - 2 - (month - 14)/12*12)/12 -
sl@0:     3*((year + 4900 + (month - 14)/12)/100)/4;
sl@0: 
sl@0:   /* Add the fractional hours, mins and seconds */
sl@0:   now += (hour + 12.0)/24.0;
sl@0:   now += minute/1440.0;
sl@0:   now += second/86400.0;
sl@0:   *prNow = now;
sl@0: #ifdef SQLITE_TEST
sl@0:   if( sqlite3_current_time ){
sl@0:     *prNow = sqlite3_current_time/86400.0 + 2440587.5;
sl@0:   }
sl@0: #endif
sl@0:   return 0;
sl@0: }
sl@0: 
sl@0: static int os2GetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
sl@0:   return 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Initialize and deinitialize the operating system interface.
sl@0: */
sl@0: int sqlite3_os_init(void){
sl@0:   static sqlite3_vfs os2Vfs = {
sl@0:     1,                 /* iVersion */
sl@0:     sizeof(os2File),   /* szOsFile */
sl@0:     CCHMAXPATH,        /* mxPathname */
sl@0:     0,                 /* pNext */
sl@0:     "os2",             /* zName */
sl@0:     0,                 /* pAppData */
sl@0: 
sl@0:     os2Open,           /* xOpen */
sl@0:     os2Delete,         /* xDelete */
sl@0:     os2Access,         /* xAccess */
sl@0:     os2FullPathname,   /* xFullPathname */
sl@0:     os2DlOpen,         /* xDlOpen */
sl@0:     os2DlError,        /* xDlError */
sl@0:     os2DlSym,          /* xDlSym */
sl@0:     os2DlClose,        /* xDlClose */
sl@0:     os2Randomness,     /* xRandomness */
sl@0:     os2Sleep,          /* xSleep */
sl@0:     os2CurrentTime,    /* xCurrentTime */
sl@0:     os2GetLastError    /* xGetLastError */
sl@0:   };
sl@0:   sqlite3_vfs_register(&os2Vfs, 1);
sl@0:   initUconvObjects();
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: int sqlite3_os_end(void){
sl@0:   freeUconvObjects();
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: #endif /* SQLITE_OS_OS2 */