diff options
author | Jörg Frings-Fürst <debian@jff-webhosting.net> | 2014-08-02 08:43:31 +0200 |
---|---|---|
committer | Jörg Frings-Fürst <debian@jff-webhosting.net> | 2014-08-02 08:43:31 +0200 |
commit | daf17154bf13139d9375f48525d19d6aaba08155 (patch) | |
tree | e3c08b6c49dc8a8e83f03327591310546675b43d /xbase64/xblock.cpp |
Imported Upstream version 3.1.2upstream/3.1.2
Diffstat (limited to 'xbase64/xblock.cpp')
-rwxr-xr-x | xbase64/xblock.cpp | 580 |
1 files changed, 580 insertions, 0 deletions
diff --git a/xbase64/xblock.cpp b/xbase64/xblock.cpp new file mode 100755 index 0000000..c44cbb9 --- /dev/null +++ b/xbase64/xblock.cpp @@ -0,0 +1,580 @@ +/* xblock.cpp + + Xbase64 project source code + written at 35000 feet on SWA + + This file contains the implementation of the xbLock. + + This file conatains a header file for the xbLock virtual objects which + is used for controlling file and record locking. Record and file + locking has been rewritten in version 3. + + Copyright (C) 1997,2003 Gary A Kunkel + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + + Contact: + + Email: + + xdb-devel@lists.sourceforge.net + xdb-users@lists.sourceforge.net + + + Regular Mail: + + XBase Support + 149C South Main St + Keller Texas, 76248 + USA +*/ + +#ifdef __GNU LesserG__ + #pragma implementation "xblock.h" +#endif + +#ifdef __WIN32__ +#include <xbase64/xbwincfg.h> +#else +#include <xbase64/xbconfig.h> +#endif + +#include <xbase64/xbase64.h> + +#ifdef HAVE_IO_H // windows locking +#include <io.h> +#endif + +#ifdef HAVE_DOS_H // _sleep +#include <dos.h> +#endif + +//#include <stdio.h> +//#include <stdlib.h> + +/*! \file xblock.cpp +*/ +#ifdef XB_LOCKING_ON + +//! Constructor +/*! + \param pdbf +*/ + +/*************************************************************************/ +xbLock::xbLock(xbDbf * pdbf) +{ + dbf = pdbf; + HdrLockCnt = 0; + TableLockCnt = 0; + MemoLockCnt = 0; + IndexLockCnt = 0; + std::cout << "xbLock constructor" << std::cout; +} +/*************************************************************************/ +xbLock::~xbLock() +{ + std::cout << "xbLock destructor" << std::endl; +} +/*************************************************************************/ + +//! File lock routine +/*! + Lowest level lock routine + Locks/unlocks a database,memo or index file. + This function assumes the file position has been correctly set + + \param fn file to lock/unlock + \param LockType lock type, one of: XB_LOCK or XB_UNLOCK + \param lockLen byte count to lock +*/ + +#ifdef __WIN32__ +xbShort xbLock::LockFile( int fn, xbShort LockType, xbOffT lockLen) +{ + int mode; + int rc; + int tries = 0; + + /* convert the xbase locking command into a windows locking command */ + if( LockType == XB_UNLOCK ) + mode = LK_UNLCK; + else if( LockType == XB_LOCK || LockType == XB_LOCK_HOLD ) + mode = LK_NBLCK; + else + return XB_INVALID_LOCK_OPTION; + + do{ + rc = locking( fn, mode, lockLen ); + if( rc ) + _sleep( 1 ); + } while( rc == -1 && tries < dbf->xbase->GetLockRetryCount()); + + if( rc ) + return XB_LOCK_FAILED; + + return 0; +} + +#elif HAVE_FCNTL_H + +xbShort xbLock::LockFile( int fn, xbShort LockType, xbOffT lockLen ) +{ + xbShort cmd, rc; + xbShort tries = 0; + +/* convert cross platform xbase lock type to unix lock type */ + if( LockType == XB_UNLOCK ) + cmd = F_ULOCK; +else if( LockType == XB_LOCK || LockType == XB_LOCK_HOLD ) + cmd = F_TLOCK; + else + return XB_INVALID_LOCK_OPTION; + +/* do the actual lock */ + do{ + #ifdef _LARGEFILE64_SOURCE + rc = lockf64( fn, cmd, lockLen ); + #else + rc = lockf( fn, cmd, lockLen ); + #endif + if( rc == -1 && errno != EINTR ){ + tries++; + sleep(1); + } + } while( rc == -1 && tries < dbf->xbase->GetLockRetryCount()); + + if( rc ) + return XB_LOCK_FAILED; + + return XB_NO_ERROR; +} +#endif // HAVE_FCNTL +/*************************************************************************/ +/*************************************************************************/ +xbaseLock::xbaseLock( xbDbf * pdbf ) : xbLock( pdbf ) +{ + std::cout << "xbaseLock constructor" << std::cout; +} +/*************************************************************************/ +xbShort xbaseLock::LockTableHeader( xbShort LockType ) +{ + if( LockType == XB_UNLOCK ) + return XB_NO_ERROR; + return XB_INVALID_LOCK_OPTION; +} +/*************************************************************************/ +xbShort xbaseLock::LockTable( xbShort LockType ) +{ + if(( LockType == XB_LOCK || LockType == XB_LOCK_HOLD ) && TableLockCnt ){ + TableLockCnt++; + return XB_NO_ERROR; + } + if( LockType == XB_UNLOCK && TableLockCnt > 1 ){ + TableLockCnt--; + return XB_NO_ERROR; + } + +#ifdef _LARGEFILE64_SOURCE + if( lseek64( fileno( lfh ), 1, SEEK_SET ) != 1 ) + return XB_LOCK_FAILED; + + if( LockFile( fileno( lfh ), LockType, 4294967295LL ) != XB_NO_ERROR ) + return XB_LOCK_FAILED; +#else + if( lseek( fileno( lfh ), 1, SEEK_SET ) != 1 ) + return XB_LOCK_FAILED; + + if( LockFile( fileno( lfh ), LockType, 4294967295L ) != XB_NO_ERROR ) + return XB_LOCK_FAILED; +#endif + + if( LockType == XB_UNLOCK ) + TableLockCnt--; + else + TableLockCnt++; + + return XB_NO_ERROR; +} +/*************************************************************************/ +xbShort xbaseLock::LockRecord(xbShort LockType,xbULong RecNo,xbOffT RecCnt) +{ + +#ifdef _LARGEFILE64_SOURCE + if( lseek64( fileno( lfh ), 100L + RecNo, SEEK_SET ) == -1 ){ + return XB_LOCK_FAILED; + } +#else + if( lseek( fileno( lfh ), 100L + RecNo, SEEK_SET ) == -1 ){ + return XB_LOCK_FAILED; + } +#endif + + return LockFile( fileno( lfh ), LockType, (xbOffT) RecCnt ); +} +/*************************************************************************/ +xbShort xbaseLock::LockMemo( xbShort LockType ) +{ + xbShort rc; + + if(( LockType == XB_LOCK || LockType == XB_LOCK_HOLD ) && MemoLockCnt ){ + MemoLockCnt++; + return XB_NO_ERROR; + } + else if ( LockType == XB_UNLOCK && MemoLockCnt > 1 ){ + MemoLockCnt--; + return XB_NO_ERROR; + } + +#ifdef _LARGEFILE64_SOURCE + if( lseek64( fileno( lfh ), 2, SEEK_SET ) != 2 ) + return XB_LOCK_FAILED; +#else + if( lseek( fileno( lfh ), 2, SEEK_SET ) != 2 ) + return XB_LOCK_FAILED; +#endif + rc = LockFile( fileno( lfh ), LockType, 1 ); + + if( rc == XB_NO_ERROR ){ + if( LockType == XB_UNLOCK ) + MemoLockCnt--; + else + MemoLockCnt++; + } + return rc; +} +/*************************************************************************/ +//! Lock Index +/*! + Locks all indices for a table when using lock mode XB_XBASE_LOCK_MODE + + \param LockType is one of XB_LOCK, XB_LOCK_HOLD or XB_UNLOCK +*/ + +xbShort xbaseLock::LockIndex( xbShort LockType ) +{ + xbShort rc; + +// if( !NdxList ) +// printf( "no index\n" ); + + if(( LockType == XB_LOCK || LockType == XB_LOCK_HOLD ) && IndexLockCnt ){ + IndexLockCnt++; + return XB_NO_ERROR; + } + if( LockType == XB_UNLOCK && IndexLockCnt > 1 ){ + IndexLockCnt--; + return XB_NO_ERROR; + } + +#ifdef _LARGEFILE64_SOURCE + if( lseek64( fileno( lfh ), 3, SEEK_SET ) == -1 ){ + printf( "here cp1\n"); + return XB_LOCK_FAILED; + } +#else + if( lseek( fileno( lfh ), 3, SEEK_SET ) == -1 ){ + printf( "here cp2\n" ); + return XB_LOCK_FAILED; + } +#endif + + rc = LockFile( fileno( lfh ), LockType, 1 ); + + if( rc == XB_NO_ERROR ) + if( LockType == XB_UNLOCK ) + IndexLockCnt--; + else + IndexLockCnt++; + + return rc; +} +/*************************************************************************/ +xbShort xbaseLock::UnlockAll() +{ + return XB_INVALID_LOCK_OPTION; +} +/************************************************************************/ +xbShort xbaseLock::LockInit() +{ + xbShort len; + xbString lfn; + + lfn = dbf->GetDbfName(); + lfn.resize( lfn.len() - 3 ); + + lfn += ".lck"; + +#ifdef _LARGEFILE_SOURCE + if(( lfh = fopen64( lfn.getData(), "w+b" )) == NULL ) + return XB_OPEN_ERROR; +#else + if(( lfh = fopen( lfn.getData(), "w+b" )) == NULL ) + return XB_OPEN_ERROR; +#endif + + else + return XB_NO_ERROR; +} + +/*************************************************************************/ +/*************************************************************************/ +dbaseLock::dbaseLock( xbDbf * pdbf ) : xbLock( pdbf ) +{ + std::cout << "dbaseLock constructor" << std::cout; +} +/*************************************************************************/ +xbShort dbaseLock::LockTableHeader( xbShort LockType ) +{ + if( LockType == XB_UNLOCK ) + return XB_NO_ERROR; + return XB_INVALID_LOCK_OPTION; +} +/*************************************************************************/ +xbShort dbaseLock::LockTable( xbShort LockType ) +{ + + if(( LockType == XB_LOCK || LockType == XB_LOCK_HOLD ) && TableLockCnt ){ + TableLockCnt++; + return XB_NO_ERROR; + } + if( LockType == XB_UNLOCK && TableLockCnt > 1 ){ + TableLockCnt--; + return XB_NO_ERROR; + } + +#ifdef _LARGEFILE64_SOURCE + if( lseek64( dbf->GetDbfFileNo(), 4026531838LL, SEEK_SET )) + return XB_LOCK_FAILED; + + if( LockFile( dbf->GetDbfFileNo(), LockType, 1 ) != XB_NO_ERROR ) + return XB_LOCK_FAILED; + + if( LockType == XB_LOCK || LockType == XB_LOCK_HOLD ){ + if( LockRecord( XB_LOCK, 1, 4294967295LL ) != XB_NO_ERROR ) + return LockTable( XB_UNLOCK ); + LockRecord( XB_UNLOCK, 1, 4294967295LL ); + } + + if( LockType == XB_UNLOCK ) + TableLockCnt--; + else + TableLockCnt++; + + return XB_NO_ERROR; +#else + /* I couldn't figure out how Dbase locks a file at offset 4026531838 + for a 32 bit platform - if you know how, please let me know + + Gary - gkunkel@zhsac.com + + */ + + return XB_INVALID_LOCK_OPTION; +#endif + +} + +/*************************************************************************/ +xbShort dbaseLock::LockRecord( xbShort LockType, xbULong RecNo, xbOffT RecCnt ) +{ +#ifdef _LARGEFILE64_SOURCE + + if( lseek64( dbf->GetDbfFileNo(), 4026531838LL - (RecNo+RecCnt-1), SEEK_SET ) == -1 ) + return XB_LOCK_FAILED; + + return LockFile( dbf->GetDbfFileNo(), LockType, RecCnt ); + +#else + + /* I couldn't figure out how dbase locks a file at offset 4026531838 + for a 32 bit platform - if you know how, please let me know + + Gary - gkunkel@zhsac.com + + */ + + return XB_INVALID_LOCK_OPTION; +#endif +} + +/*************************************************************************/ +xbShort dbaseLock::LockMemo( xbShort LockType ) +{ + + xbShort rc; + + if(( LockType == XB_LOCK || LockType == XB_LOCK_HOLD ) && MemoLockCnt ){ + MemoLockCnt++; + return XB_NO_ERROR; + } + else if ( LockType == XB_UNLOCK && MemoLockCnt > 1 ){ + MemoLockCnt--; + return XB_NO_ERROR; + } + +#ifdef _LARGEFILE_SOURCE + if( lseek64( dbf->GetMemoFileNo(), 4026531838LL, SEEK_SET ) == -1 ) + return XB_LOCK_FAILED; + rc = LockFile( dbf->GetMemoFileNo(), LockType, 1 ); +#else + rc = XB_INVALID_OPTION; +#endif + + if( rc == XB_NO_ERROR ){ + if( LockType == XB_UNLOCK ) + MemoLockCnt--; + else + MemoLockCnt++; + } + return rc; +} +/*************************************************************************/ +xbShort dbaseLock::LockIndex( xbShort LockType ) +{ + if( LockType == XB_NO_ERROR ) + return XB_NO_ERROR; + return XB_INVALID_LOCK_OPTION; +} +/*************************************************************************/ +xbShort dbaseLock::UnlockAll() +{ + return XB_INVALID_LOCK_OPTION; +} +/*************************************************************************/ +/*************************************************************************/ +clipperLock::clipperLock( xbDbf * pdbf ) : xbLock( pdbf ) +{ + std::cout << "clipperLock constructor" << std::cout; +} +/*************************************************************************/ +xbShort clipperLock::LockTableHeader( xbShort LockType ) +{ + return XB_INVALID_LOCK_OPTION; +} +/*************************************************************************/ +xbShort clipperLock::LockTable( xbShort LockType ) +{ + if(( LockType == XB_LOCK || LockType == XB_LOCK_HOLD ) && TableLockCnt ){ + TableLockCnt++; + return XB_NO_ERROR; + } + if( LockType == XB_UNLOCK && TableLockCnt > 1 ){ + TableLockCnt--; + return XB_NO_ERROR; + } + + if( LockRecord( LockType, 1L, 1000000000L ) != XB_NO_ERROR ) + return XB_LOCK_FAILED; + + if( LockType == XB_UNLOCK ) + TableLockCnt--; + else + TableLockCnt++; + + return XB_NO_ERROR; +} +/*************************************************************************/ +xbShort clipperLock::LockRecord( + xbShort LockType, xbULong RecNo, xbOffT RecCnt ) +{ + +#ifdef _LARGEFILE64_SOURCE + if( lseek64( dbf->GetDbfFileNo(), 1000000000L + RecNo, SEEK_SET )) + return XB_LOCK_FAILED; +#else + if( lseek( dbf->GetDbfFileNo(), 1000000000L + RecNo, SEEK_SET )) + return XB_LOCK_FAILED; +#endif + + return LockFile( dbf->GetDbfFileNo(), LockType, RecCnt ); +} +/*************************************************************************/ +xbShort clipperLock::LockMemo( xbShort LockType ) +{ + return XB_NO_ERROR; +} +/*************************************************************************/ +xbShort clipperLock::LockIndex( xbShort LockType ) +{ + return XB_INVALID_LOCK_OPTION; +} +/*************************************************************************/ +xbShort clipperLock::UnlockAll() +{ + return XB_INVALID_LOCK_OPTION; +} +/*************************************************************************/ +/*************************************************************************/ +foxproLock::foxproLock( xbDbf * pdbf ) : xbLock( pdbf ) +{ + std::cout << "foxproLock constructor" << std::cout; +} +/*************************************************************************/ +xbShort foxproLock::LockTableHeader( xbShort LockType ) +{ + + return XB_INVALID_LOCK_OPTION; +} +/*************************************************************************/ +xbShort foxproLock::LockTable( xbShort LockType ) +{ + + if(( LockType == XB_LOCK || LockType == XB_LOCK_HOLD ) && TableLockCnt ){ + TableLockCnt++; + return XB_NO_ERROR; + } + if( LockType == XB_UNLOCK && TableLockCnt > 1 ){ + TableLockCnt--; + return XB_NO_ERROR; + } + + +// something goes in here + + + if( LockType == XB_UNLOCK ) + TableLockCnt--; + else + TableLockCnt++; + + return XB_NO_ERROR; + +} +/*************************************************************************/ +xbShort foxproLock::LockRecord( xbShort LockType, xbULong RecNo, xbOffT len ) +{ + return XB_INVALID_LOCK_OPTION; +} +/*************************************************************************/ +xbShort foxproLock::LockMemo( xbShort LockType ) +{ + return XB_INVALID_LOCK_OPTION; +} +/*************************************************************************/ +xbShort foxproLock::LockIndex( xbShort LockType ) +{ + return XB_INVALID_LOCK_OPTION; +} +/*************************************************************************/ +xbShort foxproLock::UnlockAll() +{ + return XB_INVALID_LOCK_OPTION; +} +/*************************************************************************/ + +#endif // XB_LOCKING_ON + |