os.c

sqlite源码wince移植版

	s_tm.tm_min  = ls.wMinute;
	s_tm.tm_hour = ls.wHour;
	s_tm.tm_mday = ls.wDay;
	s_tm.tm_mon  = ls.wMonth -1;
	s_tm.tm_year = ls.wYear - 1900;
	s_tm.tm_wday = ls.wDayOfWeek;
	// Return pointer to static data
	return &s_tm;
}

/* --------------------------------------------------------------------- */
/*
** WinCE File Locking routines.
**
** These are just helpers for the sqliteOsFileLock family of functions.
** The idea is to have a named counter, made with a named mutex and a named
** semaphore. The name of this resources is generated from the file path, so
** that they are unique for each database opened.
**
** I'm sure there are many other ways to acomplish the same thing, and maybe
** some are better. If you know any better way, just say so, and I will be
** happy to use it.
*/
#if defined(_WIN32_WCE) && ! defined(SQLITE_WCE_OMIT_FILELOCK)

// I think this is more than enough for Windows CE
#define MAX_FILE_READERS 64

static BOOL wceport_OpenFileLock( OsFile * id )
{
	WCHAR aux[256];
	WCHAR muxName[256] = L"SqliteMux";
	WCHAR semName[256] = L"SqliteSem";
	int i = 0, j = 0;
	for ( ; id->filePath[i]; ++i )
		switch ( id->filePath[i] )
		{
		case '\\':
		case '/':		break;
		default:		aux[j] = id->filePath[i];
						++j;
		}
	aux[j] = '\0';
	wcscat( muxName, aux );
	id->hMux = CreateMutexW( NULL, FALSE, muxName );
	if ( id->hMux == NULL )
		return FALSE;
	wcscat( semName, aux );
	id->hSem = CreateSemaphoreW( NULL, MAX_FILE_READERS,
								MAX_FILE_READERS, semName );
	if ( id->hSem == 0 )
	{
		CloseHandle( id->hMux );
		return FALSE;
	}
	id->locked = 0;
	return TRUE;
}
static void wceport_CloseFileLock( OsFile * id )
{
	if ( id->hMux )
		CloseHandle( id->hMux );
	if ( id->hSem )
		CloseHandle( id->hSem );
}
// Lock access to file by all processes.
// Returns TRUE on success, FALSE on failure.
static BOOL wceport_LockFileMutex( HANDLE hMux )
{
	DWORD res = WaitForSingleObject( hMux, 250 );
	// I don't know very well what I have to do in this case.
	// The MSDN says that this case is when a thread terminates without
	// releasing the mutex. So I have to release it and try again
	if ( res == WAIT_ABANDONED )
	{
		ReleaseMutex( hMux );
		res = WaitForSingleObject( hMux, 250 );
	}
	// success ?
	if ( res != WAIT_OBJECT_0 )
	{
		return FALSE;	// someone is taking a long time
	}
	return TRUE;
}
static int wceport_IncrementSemaphoreN( HANDLE hSem, unsigned count )
{
	DWORD prevCount;
	BOOL res = ReleaseSemaphore( hSem, count, &prevCount );
	// this can only fail on a program bug or operating sistem error
	// what should we do if that happens ?
	assert( res != FALSE );
	return prevCount;
}
static BOOL wceport_DecrementSemaphore( HANDLE hSem )
{
	DWORD res = WaitForSingleObject( hSem, 250 );
	// I don't know very well what I have to do in this case.
	// Does this apply to semaphores ??!!...
//	if ( res == WAIT_ABANDONED )
//		....
	// success ?
	if ( res != WAIT_OBJECT_0 )
	{
		return FALSE;	// someone is taking a long time
	}
	return TRUE;
}
// Decrement semaphore by a specified amount.
// If failure, restore the original semaphore count.
static BOOL wceport_DecrementSemaphoreN( HANDLE hSem, unsigned count )
{
	unsigned i;
	for ( i = 0; i < count; ++i )
	{
		if ( ! wceport_DecrementSemaphore(hSem) )
		{	// Restore original count
			if ( i > 0 )
				wceport_IncrementSemaphoreN( hSem, i );
			return FALSE;
		}
	}
	return TRUE;
}

#endif // UNDER_CE && ! SQLITE_WCE_OMIT_FILELOCK
/* --------------------------------------------------------------------- */


/*
** Delete the named file
*/
int sqliteOsDelete(const char *zFilename){
#if OS_UNIX
  unlink(zFilename);
#endif
#if OS_WIN
# ifndef _WIN32_WCE
  DeleteFile(zFilename);
# else
  wchar_t * aux = wStrDup( zFilename );
  DeleteFileW( aux );
  free( aux );
# endif
#endif
#if OS_MAC
  unlink(zFilename);
#endif
  return SQLITE_OK;
}

/*
** Return TRUE if the named file exists.
*/
int sqliteOsFileExists(const char *zFilename){
#if OS_UNIX
  return access(zFilename, 0)==0;
#endif
#if OS_WIN
# ifndef _WIN32_WCE
  return GetFileAttributes(zFilename) != 0xffffffff;
# else
  wchar_t * aux = wStrDup( zFilename );
  int ret = GetFileAttributesW( aux ) != 0xFFFFFFFF;
  free( aux );
  return ret;
# endif
#endif
#if OS_MAC
  return access(zFilename, 0)==0;
#endif
}


#if 0 /* NOT USED */
/*
** Change the name of an existing file.
*/
int sqliteOsFileRename(const char *zOldName, const char *zNewName){
#if OS_UNIX
  if( link(zOldName, zNewName) ){
    return SQLITE_ERROR;
  }
  unlink(zOldName);
  return SQLITE_OK;
#endif
#if OS_WIN
  if( !MoveFile(zOldName, zNewName) ){
    return SQLITE_ERROR;
  }
  return SQLITE_OK;
#endif
#if OS_MAC
  /**** FIX ME ***/
  return SQLITE_ERROR;
#endif
}
#endif /* NOT USED */

/*
** Attempt to open a file for both reading and writing.  If that
** fails, try opening it read-only.  If the file does not exist,
** try to create it.
**
** On success, a handle for the open file is written to *id
** and *pReadonly is set to 0 if the file was opened for reading and
** writing or 1 if the file was opened read-only.  The function returns
** SQLITE_OK.
**
** On failure, the function returns SQLITE_CANTOPEN and leaves
** *id and *pReadonly unchanged.
*/
int sqliteOsOpenReadWrite(
  const char *zFilename,
  OsFile *id,
  int *pReadonly
){
#if OS_UNIX
  int rc;
  id->dirfd = -1;
  id->fd = open(zFilename, O_RDWR|O_CREAT|O_LARGEFILE|O_BINARY, 0644);
  if( id->fd<0 ){
#ifdef EISDIR
    if( errno==EISDIR ){
      return SQLITE_CANTOPEN;
    }
#endif
    id->fd = open(zFilename, O_RDONLY|O_LARGEFILE|O_BINARY);
    if( id->fd<0 ){
      return SQLITE_CANTOPEN; 
    }
    *pReadonly = 1;
  }else{
    *pReadonly = 0;
  }
  sqliteOsEnterMutex();
  rc = findLockInfo(id->fd, &id->pLock, &id->pOpen);
  sqliteOsLeaveMutex();
  if( rc ){
    close(id->fd);
    return SQLITE_NOMEM;
  }
  id->locked = 0;
  TRACE3("OPEN    %-3d %s\n", id->fd, zFilename);
  OpenCounter(+1);
  return SQLITE_OK;
#endif
#if OS_WIN
# ifndef _WIN32_WCE
  HANDLE h = CreateFile(zFilename,
     GENERIC_READ | GENERIC_WRITE,
     FILE_SHARE_READ | FILE_SHARE_WRITE,
     NULL,
     OPEN_ALWAYS,
     FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
     NULL
  );
  if( h==INVALID_HANDLE_VALUE ){
    h = CreateFile(zFilename,
       GENERIC_READ,
       FILE_SHARE_READ,
       NULL,
       OPEN_ALWAYS,
       FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
       NULL
    );
    if( h==INVALID_HANDLE_VALUE ){
      return SQLITE_CANTOPEN;
    }
    *pReadonly = 1;
  }else{
    *pReadonly = 0;
  }
  id->h = h;
  id->locked = 0;
# else
  WCHAR * wFilename = wStrDup( zFilename );
  // Try to open for read/write
  HANDLE h = CreateFileW( wFilename, GENERIC_READ | GENERIC_WRITE,
      FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS,
      FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL );
  // If it fails, try to open read-only
  if ( h==INVALID_HANDLE_VALUE )
  {
    h = CreateFileW( wFilename, GENERIC_READ, FILE_SHARE_READ, NULL,
          OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
          NULL );
    if ( h==INVALID_HANDLE_VALUE )
	{
      free( wFilename );
      return SQLITE_CANTOPEN;
	}
    *pReadonly = 1;
  }
  else
  {
    *pReadonly = 0;
  }
  id->h = h;
  id->delOnClose = 0;
  id->filePath = wFilename;
#  ifndef SQLITE_WCE_OMIT_FILELOCK
  // Prepare file lock mechanism
  if ( ! wceport_OpenFileLock( id ) )
  {
     // Failled to initialize file lock mechanism
     CloseHandle( id->h );
     /* NOTE: the spec says that *id and *pReadOnly should be left
              unchanged on failure, but I don't see any problem on
              ignoring this here. Should this be fixed ? */
     return SQLITE_CANTOPEN;
  }
#  else // SQLITE_OMIT_FILELOCK
  id->hMux   = 0;
  id->hSem   = 0;
  id->locked = 0;
#  endif // SQLITE_OMIT_FILELOCK
# endif
  OpenCounter(+1);
  return SQLITE_OK;
#endif
#if OS_MAC
  FSSpec fsSpec;
# ifdef _LARGE_FILE
  HFSUniStr255 dfName;
  FSRef fsRef;
  if( __path2fss(zFilename, &fsSpec) != noErr ){
    if( HCreate(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, 'SQLI', cDocumentFile) != noErr )
      return SQLITE_CANTOPEN;
  }
  if( FSpMakeFSRef(&fsSpec, &fsRef) != noErr )
    return SQLITE_CANTOPEN;
  FSGetDataForkName(&dfName);
  if( FSOpenFork(&fsRef, dfName.length, dfName.unicode,
                 fsRdWrShPerm, &(id->refNum)) != noErr ){
    if( FSOpenFork(&fsRef, dfName.length, dfName.unicode,
                   fsRdWrPerm, &(id->refNum)) != noErr ){
      if (FSOpenFork(&fsRef, dfName.length, dfName.unicode,
                   fsRdPerm, &(id->refNum)) != noErr )
        return SQLITE_CANTOPEN;
      else
        *pReadonly = 1;
    } else
      *pReadonly = 0;
  } else
    *pReadonly = 0;
# else
  __path2fss(zFilename, &fsSpec);
  if( !sqliteOsFileExists(zFilename) ){
    if( HCreate(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, 'SQLI', cDocumentFile) != noErr )
      return SQLITE_CANTOPEN;
  }
  if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrShPerm, &(id->refNum)) != noErr ){
    if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrPerm, &(id->refNum)) != noErr ){
      if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdPerm, &(id->refNum)) != noErr )
        return SQLITE_CANTOPEN;
      else
        *pReadonly = 1;
    } else
      *pReadonly = 0;
  } else
    *pReadonly = 0;
# endif
  if( HOpenRF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrShPerm, &(id->refNumRF)) != noErr){
    id->refNumRF = -1;
  }
  id->locked = 0;
  id->delOnClose = 0;
  OpenCounter(+1);
  return SQLITE_OK;
#endif
}


/*
** Attempt to open a new file for exclusive access by this process.
** The file will be opened for both reading and writing.  To avoid
** a potential security problem, we do not allow the file to have
** previously existed.  Nor do we allow the file to be a symbolic
** link.
**
** If delFlag is true, then make arrangements to automatically delete
** the file when it is closed.
**
** On success, write the file handle into *id and return SQLITE_OK.
**
** On failure, return SQLITE_CANTOPEN.
*/
int sqliteOsOpenExclusive(const char *zFilename, OsFile *id, int delFlag){
#if OS_UNIX
  int rc;
  if( access(zFilename, 0)==0 ){
    return SQLITE_CANTOPEN;
  }
  id->dirfd = -1;
  id->fd = open(zFilename,
                O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW|O_LARGEFILE|O_BINARY, 0600);
  if( id->fd<0 ){
    return SQLITE_CANTOPEN;
  }
  sqliteOsEnterMutex();
  rc = findLockInfo(id->fd, &id->pLock, &id->pOpen);
  sqliteOsLeaveMutex();
  if( rc ){
    close(id->fd);
    unlink(zFilename);
    return SQLITE_NOMEM;
  }
  id->locked = 0;
  if( delFlag ){
    unlink(zFilename);
  }
  TRACE3("OPEN-EX %-3d %s\n", id->fd, zFilename);
  OpenCounter(+1);
  return SQLITE_OK;
#endif
#if OS_WIN
# ifndef _WIN32_WCE
  HANDLE h;
  int fileflags;
  if( delFlag ){
    fileflags = FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_RANDOM_ACCESS 
                     | FILE_FLAG_DELETE_ON_CLOSE;
  }else{
    fileflags = FILE_FLAG_RANDOM_ACCESS;
  }
  h = CreateFile(zFilename,
     GENERIC_READ | GENERIC_WRITE,
     0,
     NULL,
     CREATE_ALWAYS,
     fileflags,
     NULL
  );
  if( h==INVALID_HANDLE_VALUE ){
    return SQLITE_CANTOPEN;
  }
  id->h = h;
  id->locked = 0;
# else
  WCHAR * wFilename = wStrDup( zFilename );
  HANDLE h = CreateFileW( wFilename, GENERIC_READ | GENERIC_WRITE, 0,
                NULL, CREATE_ALWAYS, FILE_FLAG_RANDOM_ACCESS, NULL );
  if ( h == INVALID_HANDLE_VALUE )
  {
    free( wFilename );
    return SQLITE_CANTOPEN;
  }
  id->h = h;
  id->delOnClose = delFlag;
  id->filePath = wFilename;
  id->hMux   = 0;	// Not shared, so no need to lock file
  id->hSem   = 0;
  id->locked = 0;
# endif
  OpenCounter(+1);
  return SQLITE_OK;