2901 lines
74 KiB
C
Executable File
2901 lines
74 KiB
C
Executable File
/* c4trans.c (c)Copyright Sequiter Software Inc., 1988-1996. All rights reserved. */
|
|
|
|
#include "d4all.h"
|
|
|
|
#ifndef UNIX
|
|
#ifdef __TURBOC__
|
|
#pragma hdrstop
|
|
#endif
|
|
#endif
|
|
|
|
/* TRANSACTION FILE FORMAT
|
|
-----------------------
|
|
|
|
Every entry in the transaction file has the following format:
|
|
|
|
[unisgned short int] - transaction entry length (including this length entry)
|
|
[transaction data]
|
|
[transaction header]
|
|
|
|
The transaction file can be read either forwards or backwards in this
|
|
fashion. It is usually read backwards when performing rollbacks, but
|
|
it is useful to read forwards for database history review purposes or
|
|
in case the transaction file itself is corrupt at some point.
|
|
*/
|
|
|
|
#ifndef S4OFF_TRAN
|
|
#ifndef S4OFF_WRITE
|
|
|
|
static void tran4lowCloseDelayed( TRAN4 *trans )
|
|
{
|
|
DATA4 *data ;
|
|
|
|
for ( ;; )
|
|
{
|
|
data = (DATA4 *)l4pop( &trans->closedDataFiles ) ;
|
|
if ( data == 0 )
|
|
break ;
|
|
l4add( tran4dataList( data->trans ), data ) ;
|
|
d4close( data ) ;
|
|
}
|
|
}
|
|
|
|
#ifndef S4CLIENT
|
|
static DATA4 *tran4dataFull( TRAN4 *, const long, const long ) ;
|
|
#endif
|
|
|
|
#ifdef E4ANALYZE
|
|
static int code4transVerify( CODE4TRANS *, int ) ;
|
|
#endif /* E4ANALYZE */
|
|
|
|
#ifndef S4SERVER
|
|
static void code4invalidate( CODE4 * ) ;
|
|
#endif
|
|
#ifndef S4CLIENT
|
|
#ifdef E4ANALYZE
|
|
static int tran4fileVerify( TRAN4FILE *t4, int subs )
|
|
{
|
|
int rc ;
|
|
|
|
if ( t4 == 0 )
|
|
return error4( 0, e4parm_null, E93801 ) ;
|
|
|
|
if ( t4->c4trans == 0 )
|
|
return error4( 0, e4parm, E93801 ) ;
|
|
|
|
if ( subs == 1 )
|
|
if ( ( rc = code4transVerify( t4->c4trans, 1 ) ) < 0 )
|
|
return rc ;
|
|
|
|
return 0 ;
|
|
}
|
|
#endif /* E4ANALYZE */
|
|
|
|
static int tran4fileInit( TRAN4FILE *t4, CODE4TRANS *c4trans )
|
|
{
|
|
t4->c4trans = c4trans ;
|
|
memset( &t4->file, 0, sizeof( FILE4 ) ) ;
|
|
t4->file.hand = -1 ;
|
|
t4->transId = -1 ;
|
|
|
|
#ifdef E4ANALYZE
|
|
return tran4fileVerify( t4, 0 ) ;
|
|
#else
|
|
return 0 ;
|
|
#endif
|
|
}
|
|
|
|
int S4FUNCTION tran4fileAppend( TRAN4FILE *t4, LOG4HEADER *header, void *dta )
|
|
{
|
|
long filePos ;
|
|
int rc ;
|
|
TRAN4ENTRY_LEN len ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( header == 0 )
|
|
return error4( t4->c4trans->c4, e4parm_null, E93801 ) ;
|
|
#endif
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4fileVerify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
|
|
if ( t4->file.hand < 0 )
|
|
return error4( t4->c4trans->c4, e4struct, E93801 ) ;
|
|
#endif
|
|
|
|
filePos = file4len( &t4->file ) ;
|
|
if ( filePos < 0 )
|
|
return (int)filePos ;
|
|
|
|
len = tran4entryLen( header ) ;
|
|
rc = file4write( &t4->file, filePos, &len, sizeof( TRAN4ENTRY_LEN ) ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
filePos += sizeof( len ) ;
|
|
|
|
if ( header->dataLen != 0 )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( dta == 0 )
|
|
return error4( t4->c4trans->c4, e4parm_null, E93801 ) ;
|
|
#endif
|
|
rc = file4write( &t4->file, filePos, dta, (unsigned int)header->dataLen ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
filePos += header->dataLen ;
|
|
}
|
|
|
|
rc = file4write( &t4->file, filePos, header, sizeof( LOG4HEADER ) ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
|
|
return file4flush( &t4->file ) ;
|
|
}
|
|
|
|
int S4FUNCTION tran4lowAppend( TRAN4 *t4, void *dta )
|
|
{
|
|
int rc ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4verify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
if ( t4->dataPos != 0 )
|
|
{
|
|
dta = t4->c4trans->c4->tranData ;
|
|
t4->dataPos = 0 ;
|
|
}
|
|
|
|
t4->pos = -1 ;
|
|
rc = tran4fileAppend( t4->c4trans->transFile, &t4->header, dta ) ;
|
|
|
|
memset( &t4->header, 0, sizeof( LOG4HEADER ) ) ;
|
|
return rc ;
|
|
}
|
|
|
|
static int tran4fileClose( TRAN4FILE *t4 )
|
|
{
|
|
int rc, saveRc, saveErr ;
|
|
#ifdef S4SERVER
|
|
SERVER4CLIENT *client ;
|
|
#endif
|
|
|
|
/* must close files no matter what */
|
|
/* #ifdef E4ANALYZE*/
|
|
/* if ( ( rc = tran4fileVerify( t4, 1 ) ) < 0 )*/
|
|
/* return rc ;*/
|
|
/* #endif*/
|
|
|
|
if ( t4->file.hand < 0 )
|
|
return 0 ;
|
|
|
|
saveRc = 0 ;
|
|
|
|
#ifdef S4SERVER
|
|
/* ensure there are no active transactions */
|
|
client = (SERVER4CLIENT *)l4first( &t4->c4trans->c4->server->clients ) ;
|
|
for ( ;; )
|
|
{
|
|
if ( client == 0 )
|
|
break ;
|
|
if ( client->trans.currentTranStatus == r4active )
|
|
{
|
|
if ( error4code( t4->c4trans->c4 ) == 0 )
|
|
saveRc = error4( t4->c4trans->c4, e4trans, E93801 ) ;
|
|
t4->validState = 0 ;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
saveErr = error4code( t4->c4trans->c4 ) ;
|
|
error4set( t4->c4trans->c4, 0 ) ;
|
|
|
|
rc = file4close( &t4->file ) ;
|
|
if ( rc < 0 && saveRc == 0 )
|
|
saveRc = rc ;
|
|
|
|
t4->c4trans->c4->errorCode = saveErr ;
|
|
|
|
return saveRc ;
|
|
}
|
|
|
|
int tran4fileCreate( TRAN4FILE *t4, const char *name )
|
|
{
|
|
char buf[258] ;
|
|
int rc ;
|
|
LOG4HEADER header ;
|
|
CODE4 *c4 ;
|
|
#ifndef S4OFF_MULTI
|
|
int oldExcl ;
|
|
#endif
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4fileVerify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
c4 = t4->c4trans->c4 ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( name == 0 )
|
|
return error4( c4, e4parm_null, E93801 ) ;
|
|
#endif
|
|
|
|
memcpy( buf, name, strlen( name ) + 1 ) ;
|
|
u4nameExt( buf, sizeof( buf ), "log", 0 ) ;
|
|
#ifndef S4OFF_MULTI
|
|
oldExcl = c4->accessMode ;
|
|
c4->accessMode = OPEN4DENY_NONE ;
|
|
#endif
|
|
rc = file4create( &t4->file, c4, buf, 1 ) ;
|
|
#ifndef S4OFF_MULTI
|
|
c4->accessMode = oldExcl ;
|
|
#endif
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
t4->validState = 1;
|
|
memset( &header, 0, sizeof( header ) ) ;
|
|
header.type = TRAN4SHUTDOWN ;
|
|
header.serverDataId = TRAN4VERSION_NUM ;
|
|
rc = tran4fileAppend( t4, &header, "\0" ) ;
|
|
if (rc < 0)
|
|
return(rc);
|
|
#ifdef E4ANALYZE
|
|
return tran4fileVerify( t4, 1 ) ;
|
|
#else
|
|
return 0 ;
|
|
#endif
|
|
}
|
|
|
|
#ifndef S4UTILS
|
|
static int tran4fileStatusFile( TRAN4FILE *t4 )
|
|
{
|
|
CODE4 *c4 ;
|
|
long filePos ;
|
|
int rc ;
|
|
LOG4HEADER header ;
|
|
TRAN4ENTRY_LEN entryLen;
|
|
#ifdef S4STAND_ALONE
|
|
#ifndef S4OFF_MULTI
|
|
long loop ;
|
|
int oldNumAttempts ;
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4fileVerify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
if ( t4->file.hand < 0 )
|
|
return error4( t4->c4trans->c4, e4struct, E93801 ) ;
|
|
#endif
|
|
|
|
c4 = t4->c4trans->c4 ;
|
|
|
|
#ifdef S4STAND_ALONE
|
|
/* first see if the only user, in which case can verify */
|
|
#ifndef S4OFF_MULTI
|
|
oldNumAttempts = c4->lockAttempts ;
|
|
/* can't do overlay locking due to Novell inconsistencies... */
|
|
/* reserve a byte so only one attempt to set up at a time */
|
|
c4->lockAttempts = -1 ;
|
|
rc = file4lock( &t4->file, TRAN4LOCK_USERS + TRAN4MAX_USERS + 1, 1 ) ;
|
|
c4->lockAttempts = 1 ;
|
|
for ( loop = 0 ; loop <= TRAN4MAX_USERS ; loop++ )
|
|
{
|
|
rc = file4lock( &t4->file, TRAN4LOCK_USERS+loop, 1 ) ;
|
|
if ( rc < 0 || rc == r4locked )
|
|
break ;
|
|
file4unlock( &t4->file, TRAN4LOCK_USERS+loop, 1 ) ;
|
|
}
|
|
c4->lockAttempts = oldNumAttempts ;
|
|
if ( rc != 0 )
|
|
{
|
|
file4unlock( &t4->file, TRAN4LOCK_USERS + TRAN4MAX_USERS + 1, 1 ) ;
|
|
if ( rc == r4locked )
|
|
return 0 ;
|
|
return rc ;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
for( ;; )
|
|
{
|
|
filePos = file4len( &t4->file ) - sizeof( LOG4HEADER ) - sizeof(TRAN4ENTRY_LEN);
|
|
if ( filePos < 0 )
|
|
{
|
|
rc = error4( c4, e4trans, E83801 ) ;
|
|
break ;
|
|
}
|
|
|
|
rc = file4readAll( &t4->file, 0L, &entryLen, sizeof( TRAN4ENTRY_LEN ) ) ;
|
|
if ( rc < 0 )
|
|
break ;
|
|
|
|
if (entryLen != sizeof(LOG4HEADER) + sizeof(TRAN4ENTRY_LEN))
|
|
{
|
|
rc = error4( c4, e4read, E93801 ) ;
|
|
break ;
|
|
}
|
|
|
|
rc = file4readAll( &t4->file, (long)sizeof(TRAN4ENTRY_LEN), &header, sizeof( LOG4HEADER ) ) ;
|
|
if ( rc < 0 )
|
|
break ;
|
|
|
|
if ( header.type == TRAN4BACKEDUP )
|
|
{
|
|
rc = error4( c4, e4trans, E83815 ) ;
|
|
break ;
|
|
}
|
|
|
|
rc = file4readAll( &t4->file, filePos, &entryLen, sizeof( TRAN4ENTRY_LEN ) ) ;
|
|
if ( rc < 0 )
|
|
break ;
|
|
|
|
if (entryLen != sizeof(LOG4HEADER) + sizeof(TRAN4ENTRY_LEN))
|
|
{
|
|
rc = error4( c4, e4trans, E83801 ) ;
|
|
break ;
|
|
}
|
|
|
|
rc = file4readAll( &t4->file, filePos + sizeof(TRAN4ENTRY_LEN), &header, sizeof( LOG4HEADER ) ) ;
|
|
if ( rc < 0 )
|
|
break ;
|
|
|
|
break ;
|
|
}
|
|
|
|
#ifdef S4STAND_ALONE
|
|
file4unlock( &t4->file, TRAN4LOCK_USERS + TRAN4MAX_USERS + 1, 1 ) ;
|
|
#endif
|
|
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
|
|
if ( header.type == TRAN4SHUTDOWN )
|
|
return 0 ;
|
|
|
|
return error4( c4, e4trans, E83801 ) ;
|
|
}
|
|
#endif /* S4UTILS */
|
|
|
|
static int tran4fileOpen( TRAN4FILE *t4, char *name )
|
|
{
|
|
int rc, oldOpenError, oldReadOnly ;
|
|
char buf[258] ;
|
|
CODE4 *c4 ;
|
|
#ifndef S4OFF_MULTI
|
|
int oldExcl ;
|
|
#endif
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( name == 0 )
|
|
return error4( t4->c4trans->c4, e4parm_null, E93801 ) ;
|
|
#endif
|
|
|
|
c4 = t4->c4trans->c4 ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4fileVerify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
if ( t4->file.hand != -1 ) /* already open */
|
|
return error4( c4, e4struct, E93801 ) ;
|
|
#endif
|
|
|
|
memcpy( buf, name, strlen( name ) + 1 ) ;
|
|
u4nameExt( buf, sizeof( buf ), "log", 0 ) ;
|
|
|
|
#ifndef S4OFF_MULTI
|
|
oldExcl = c4->accessMode ;
|
|
#ifdef S4UTILS
|
|
c4->accessMode = OPEN4DENY_RW ;
|
|
#else
|
|
c4->accessMode = OPEN4DENY_NONE ;
|
|
#endif
|
|
#endif
|
|
oldReadOnly = c4->readOnly ;
|
|
c4->readOnly = 0 ;
|
|
oldOpenError = c4->errOpen ;
|
|
c4->errOpen = 0 ;
|
|
|
|
rc = file4open( &t4->file, c4, buf, 1 ) ;
|
|
|
|
c4->errOpen = oldOpenError ;
|
|
c4->readOnly = oldReadOnly ;
|
|
#ifndef S4OFF_MULTI
|
|
c4->accessMode = oldExcl ;
|
|
#endif
|
|
#ifndef S4UTILS
|
|
if ( rc != r4noOpen && rc >= 0 )
|
|
{
|
|
if ( tran4fileStatusFile( t4 ) != 0 )
|
|
{
|
|
t4->validState = 0 ;
|
|
return -1 ;
|
|
}
|
|
else
|
|
t4->validState = 1 ;
|
|
}
|
|
#endif /* S4UTILS */
|
|
|
|
if ( rc != 0 )
|
|
return rc ;
|
|
|
|
#ifdef E4ANALYZE
|
|
return tran4fileVerify( t4, 1 ) ;
|
|
#else
|
|
return 0 ;
|
|
#endif
|
|
}
|
|
|
|
/* server just increments and checks trans file for last entry */
|
|
/* stand-alone uses the userIdNo as an offset to avoid requiring
|
|
continual reads to get next id no. */
|
|
static long tran4fileGetNextTransId( TRAN4FILE *t4, TRAN4 *trans )
|
|
{
|
|
#ifdef E4ANALYZE
|
|
int rc ;
|
|
|
|
if ( ( rc = tran4fileVerify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
#ifdef S4SERVER
|
|
if ( t4->transId > 0 )
|
|
{
|
|
if ( t4->transId == LONG_MAX )
|
|
t4->transId = 0 ;
|
|
++t4->transId ;
|
|
}
|
|
else
|
|
{
|
|
if ( tran4bottom( trans ) < 0 ) /* no entries */
|
|
return 0 ;
|
|
|
|
while ( trans->header.transId == 0 )
|
|
if ( tran4skip( trans, TRAN4BACKWARDS ) != 0 )
|
|
break ;
|
|
|
|
if ( trans->header.transId < 0 )
|
|
return e4trans ;
|
|
|
|
if ( trans->header.transId == LONG_MAX )
|
|
t4->transId = 0 ;
|
|
else
|
|
t4->transId = trans->header.transId + 1 ;
|
|
}
|
|
#endif
|
|
|
|
#ifdef S4STAND_ALONE
|
|
if ( t4->transId > 0 )
|
|
{
|
|
if ( t4->transId == LONG_MAX )
|
|
t4->transId = t4->c4trans->trans.userIdNo ;
|
|
t4->transId += TRAN4MAX_USERS ;
|
|
}
|
|
else
|
|
{
|
|
if ( tran4bottom( trans ) < 0 ) /* no entries */
|
|
return 0 ;
|
|
|
|
for ( ;; )
|
|
{
|
|
if ( trans->header.transId % TRAN4MAX_USERS == trans->userIdNo )
|
|
break ;
|
|
if ( tran4skip( trans, TRAN4BACKWARDS ) != 0 )
|
|
break ;
|
|
}
|
|
|
|
if ( trans->header.transId < 0 )
|
|
return e4trans ;
|
|
|
|
if ( trans->header.transId == LONG_MAX || ( trans->header.transId % TRAN4MAX_USERS != t4->c4trans->trans.userIdNo ) )
|
|
t4->transId = t4->c4trans->trans.userIdNo ;
|
|
else
|
|
t4->transId = trans->header.transId + TRAN4MAX_USERS ;
|
|
}
|
|
#endif
|
|
return t4->transId ;
|
|
}
|
|
|
|
static long tran4getTransId( TRAN4 *t4 )
|
|
{
|
|
#ifdef E4ANALYZE
|
|
int rc ;
|
|
|
|
if ( ( rc = tran4verify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
if ( t4->transId > 0 )
|
|
return t4->transId ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( t4->c4trans->transFile == 0 )
|
|
return error4( t4->c4trans->c4, e4struct, E93801 ) ;
|
|
#endif
|
|
|
|
t4->transId = tran4fileGetNextTransId( t4->c4trans->transFile, t4 ) ;
|
|
return t4->transId ;
|
|
}
|
|
|
|
/*
|
|
int S4FUNCTION tran4fileStatus( TRAN4FILE *t4, long transactionId )
|
|
{
|
|
long filePos ;
|
|
int rc ;
|
|
LOG4HEADER header ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4fileVerify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
if ( t4->file.hand < 0 )
|
|
return error4( t4->c4trans->c4, e4struct, E93801 ) ;
|
|
#endif
|
|
|
|
rc = -1 ;
|
|
filePos = file4len( &t4->file ) - sizeof( LOG4HEADER ) ;
|
|
|
|
for( ; filePos > 0 ; )
|
|
{
|
|
rc = file4readAll( &t4->file, filePos, &header, sizeof( LOG4HEADER ) ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
|
|
if ( header.transId == transactionId )
|
|
return header.type ;
|
|
|
|
filePos -= ( header.dataLen + sizeof( LOG4HEADER ) ) ;
|
|
}
|
|
|
|
return rc ;
|
|
}
|
|
*/
|
|
|
|
static int tran4fileRead( TRAN4FILE *t4, long pos, LOG4HEADER *header, char **data, unsigned int *dataLen )
|
|
{
|
|
int rc ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4fileVerify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
if ( t4->file.hand < 0 )
|
|
return error4( t4->c4trans->c4, e4struct, E93801 ) ;
|
|
#endif
|
|
|
|
rc = file4readAll( &t4->file, pos, header, sizeof( LOG4HEADER ) ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
if ( *dataLen < header->dataLen + 1 )
|
|
if ( u4allocAgain( t4->c4trans->c4, data, dataLen, (unsigned int)header->dataLen + 1 ) != 0 )
|
|
return e4memory ;
|
|
if ( header->dataLen > 0L )
|
|
{
|
|
rc = file4readAll( &t4->file, pos - header->dataLen, *data, (unsigned int)header->dataLen ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
}
|
|
else
|
|
(*data)[0] = '\0' ;
|
|
return 0 ;
|
|
}
|
|
|
|
static int tran4read( TRAN4 *t4 )
|
|
{
|
|
#ifdef E4ANALYZE
|
|
int rc ;
|
|
|
|
if ( ( rc = tran4verify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
if ( t4->pos < 0 )
|
|
return error4( t4->c4trans->c4, e4info, E83802 ) ;
|
|
if ( t4->c4trans->transFile == 0 )
|
|
return error4( t4->c4trans->c4, e4info, E93801 ) ;
|
|
#endif
|
|
return tran4fileRead( t4->c4trans->transFile, t4->pos, &t4->header, &t4->c4trans->c4->tranData, &t4->c4trans->c4->tranDataLen ) ;
|
|
}
|
|
|
|
int S4FUNCTION tran4fileTop( TRAN4FILE *t4, TRAN4 *trans )
|
|
{
|
|
int rc ;
|
|
unsigned lenRead ;
|
|
TRAN4ENTRY_LEN len ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4fileVerify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
lenRead = file4read( &t4->file, 0L, &len, sizeof( len ) ) ;
|
|
if ( lenRead != sizeof( len ) )
|
|
return r4bof ;
|
|
|
|
trans->pos = len - sizeof( LOG4HEADER ) ;
|
|
|
|
rc = tran4read( trans ) ;
|
|
if ( rc < 0 )
|
|
{
|
|
trans->pos = -1 ;
|
|
return rc ;
|
|
}
|
|
return 0 ;
|
|
}
|
|
|
|
int S4FUNCTION tran4fileBottom( TRAN4FILE *t4, TRAN4 *trans )
|
|
{
|
|
int rc ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4fileVerify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
trans->pos = file4len( &t4->file ) - sizeof( LOG4HEADER ) ;
|
|
if ( trans->pos < 0 )
|
|
return r4eof ;
|
|
rc = tran4read( trans ) ;
|
|
if ( rc < 0 )
|
|
{
|
|
trans->pos = -1 ;
|
|
return rc ;
|
|
}
|
|
return 0 ;
|
|
}
|
|
|
|
int S4FUNCTION tran4fileSkip( TRAN4FILE *t4, TRAN4 *trans, const int direction )
|
|
{
|
|
int rc ;
|
|
TRAN4ENTRY_LEN len ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( t4 == 0 || trans == 0 || ( direction != TRAN4FORWARDS && direction != TRAN4BACKWARDS ) )
|
|
return error4( 0, e4parm, E93801 ) ;
|
|
#endif
|
|
|
|
if ( trans->pos < 0L ) /* empty file ... */
|
|
{
|
|
if ( direction == TRAN4BACKWARDS )
|
|
return r4eof ;
|
|
else
|
|
return r4bof ;
|
|
}
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4fileVerify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
if ( direction == TRAN4BACKWARDS )
|
|
{
|
|
trans->pos -= tran4entryLen( &trans->header ) ;
|
|
if ( trans->pos < 0L )
|
|
return r4bof ;
|
|
rc = tran4read( trans ) ;
|
|
if ( rc< 0 )
|
|
{
|
|
trans->pos = -1 ;
|
|
return rc ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
trans->pos += sizeof( LOG4HEADER ) ;
|
|
if ( (long)trans->pos + (long)sizeof( TRAN4ENTRY_LEN ) >= file4len( &t4->file ) )
|
|
return r4eof ;
|
|
rc = file4readAll( &t4->file, trans->pos, &len, sizeof( TRAN4ENTRY_LEN ) ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
|
|
trans->pos += len - sizeof( LOG4HEADER ) ;
|
|
|
|
if ( trans->pos >= file4len( &t4->file ) )
|
|
return r4eof ;
|
|
|
|
rc = tran4read( trans ) ;
|
|
if ( rc< 0 )
|
|
{
|
|
trans->pos = -1 ;
|
|
return rc ;
|
|
}
|
|
}
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
/*
|
|
int S4FUNCTION tran4fileSeek( TRAN4FILE *t4, TRAN4 *trans, long transIdno )
|
|
{
|
|
int rc ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4fileVerify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
for ( trans->pos = file4len( &t4->file ) - sizeof( LOG4HEADER ) ; trans->pos > 0L ; trans->pos -= tran4entryLen( &trans->header ) )
|
|
{
|
|
rc = file4readAll( &t4->file, trans->pos, &trans->header, sizeof( LOG4HEADER ) ) ;
|
|
if ( rc < 0 )
|
|
{
|
|
trans->pos = -1L ;
|
|
return rc ;
|
|
}
|
|
if ( trans->header.transId == transIdno )
|
|
return tran4read( trans ) ;
|
|
}
|
|
|
|
trans->pos = -1L ;
|
|
return error4( t4->c4trans->c4, e4trans, E83803 ) ;
|
|
}
|
|
*/
|
|
|
|
#ifndef S4INLINE
|
|
long S4FUNCTION tran4id( TRAN4 *t4 )
|
|
{
|
|
#ifdef E4ANALYZE
|
|
int rc ;
|
|
|
|
if ( ( rc = tran4verify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
return t4->header.transId ;
|
|
}
|
|
|
|
long S4FUNCTION tran4clientId( TRAN4 *t4 )
|
|
{
|
|
int rc ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4verify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
return t4->header.clientId ;
|
|
}
|
|
|
|
unsigned long S4FUNCTION tran4clientDataId( TRAN4 *t4 )
|
|
{
|
|
int rc ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4verify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
return t4->header.clientDataId ;
|
|
}
|
|
|
|
unsigned long S4FUNCTION tran4serverDataId( TRAN4 *t4 )
|
|
{
|
|
int rc ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4verify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
return t4->header.serverDataId ;
|
|
}
|
|
|
|
int S4FUNCTION tran4type( TRAN4 *t4 )
|
|
{
|
|
int rc ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4verify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
return t4->header.type ;
|
|
}
|
|
|
|
unsigned S4FUNCTION tran4len( TRAN4 *t4 )
|
|
{
|
|
int rc ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4verify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
return t4->header.dataLen ;
|
|
}
|
|
#endif /* S4INLINE */
|
|
|
|
/* data may be larger than can be contained in memory... new coding reqd */
|
|
void *S4FUNCTION tran4getData( TRAN4 *t4, const long pos )
|
|
{
|
|
CODE4 *c4 ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( tran4verify( t4, 1 ) < 0 )
|
|
return 0 ;
|
|
if ( t4->c4trans->transFile == 0 )
|
|
{
|
|
error4( t4->c4trans->c4, e4struct, E93801 ) ;
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
|
|
c4 = t4->c4trans->c4 ;
|
|
|
|
if ( c4->tranData != 0 )
|
|
{
|
|
if ( c4->tranDataLen < t4->header.dataLen + 1 )
|
|
{
|
|
error4( c4, e4trans, E93801 ) ;
|
|
return 0 ;
|
|
}
|
|
c4->tranData[ t4->header.dataLen ] = 0 ;
|
|
}
|
|
return c4->tranData + pos ;
|
|
}
|
|
|
|
int S4FUNCTION tran4set( TRAN4 *t4, const int status, const long id1, const long id2, const int typ,
|
|
const unsigned int dLen, const long clientId, const long serverId )
|
|
{
|
|
#ifdef E4ANALYZE
|
|
int rc ;
|
|
|
|
if ( ( rc = tran4verify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
if ( status == r4active || typ == TRAN4START || typ == TRAN4ROLLBACK )
|
|
{
|
|
if ( id1 == -1 )
|
|
t4->header.transId = tran4getTransId( t4 ) ;
|
|
else
|
|
t4->header.transId = id1 ;
|
|
}
|
|
else
|
|
t4->header.transId = 0 ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( t4->c4trans->transFile == 0 )
|
|
return error4( t4->c4trans->c4, e4struct, E93801 ) ;
|
|
#endif
|
|
|
|
if ( t4->header.transId < 0 )
|
|
return error4( t4->c4trans->c4, e4trans, E93801 ) ;
|
|
|
|
t4->header.clientId = id2 ;
|
|
t4->header.type = typ ;
|
|
t4->header.dataLen = dLen ;
|
|
t4->header.clientDataId = clientId ;
|
|
t4->header.serverDataId = serverId ;
|
|
time( &t4->header.time ) ;
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
int S4FUNCTION tran4putData( TRAN4 *t4, void *dta, unsigned dLen )
|
|
{
|
|
CODE4 *c4 ;
|
|
|
|
#ifdef E4ANALYZE
|
|
int rc ;
|
|
|
|
if ( ( rc = tran4verify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
if ( t4->c4trans->transFile == 0 || dLen <= 0 )
|
|
return error4( t4->c4trans->c4, e4info, E93801 ) ;
|
|
#endif
|
|
|
|
c4 = t4->c4trans->c4 ;
|
|
|
|
if ( t4->dataPos + dLen + 1 > c4->tranDataLen )
|
|
if ( u4allocAgain( c4, &c4->tranData, &c4->tranDataLen, dLen + t4->dataPos + 1 ) != 0 )
|
|
return e4memory ;
|
|
|
|
memcpy( c4->tranData + t4->dataPos, dta, dLen ) ;
|
|
t4->dataPos += dLen ;
|
|
return 0 ;
|
|
}
|
|
|
|
#ifndef S4INLINE
|
|
int S4FUNCTION tran4bottom( TRAN4 *t4 )
|
|
{
|
|
#ifdef E4ANALYZE
|
|
int rc ;
|
|
|
|
if ( ( rc = tran4verify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
if ( t4->c4trans->transFile == 0 )
|
|
return error4( t4->c4trans->c4, e4struct, E93801 ) ;
|
|
#endif
|
|
return tran4fileBottom( t4->c4trans->transFile, t4 ) ;
|
|
}
|
|
|
|
int S4FUNCTION tran4top( TRAN4 *t4 )
|
|
{
|
|
#ifdef E4ANALYZE
|
|
int rc ;
|
|
|
|
if ( ( rc = tran4verify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
if ( t4->c4trans->transFile == 0 )
|
|
return error4( t4->c4trans->c4, e4info, E93801 ) ;
|
|
#endif
|
|
return tran4fileTop( t4->c4trans->transFile, t4 ) ;
|
|
}
|
|
|
|
int S4FUNCTION tran4skip( TRAN4 *t4, int direction )
|
|
{
|
|
#ifdef E4ANALYZE
|
|
int rc ;
|
|
#endif
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( direction != TRAN4FORWARDS && direction != TRAN4BACKWARDS )
|
|
return error4( 0, e4parm, E93801 ) ;
|
|
#endif
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4verify( t4, 1 ) ) < 0 )
|
|
return rc ;
|
|
if ( t4->c4trans->transFile == 0 )
|
|
return error4( t4->c4trans->c4, e4struct, E93801 ) ;
|
|
#endif
|
|
return tran4fileSkip( t4->c4trans->transFile, t4, direction ) ;
|
|
}
|
|
#endif /* S4INLINE */
|
|
|
|
int tran4lowUnappend( TRAN4 *trans )
|
|
{
|
|
DATA4 *data ;
|
|
int rc ;
|
|
long recNo ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( trans == 0 )
|
|
return error4( 0, e4parm_null, E93801 ) ;
|
|
#endif
|
|
|
|
recNo = *((long *)(tran4getData( trans, 0L ) ) ) ;
|
|
|
|
data = tran4dataFull( trans, tran4serverDataId( trans ), tran4clientDataId( trans ) ) ;
|
|
if ( data == 0 )
|
|
return error4( trans->c4trans->c4, e4name, E93801 ) ;
|
|
|
|
#ifndef S4OFF_MULTI
|
|
if ( dfile4lockTestAppend( data->dataFile, tran4clientDataId( trans ), tran4serverDataId( trans ) ) == 0 )
|
|
return error4( trans->c4trans->c4, e4lock, E83804 ) ;
|
|
#endif
|
|
if ( d4recCount( data ) != recNo )
|
|
{
|
|
if ( d4recCount( data ) == recNo - 1 ) /* already unappended */
|
|
return 0 ;
|
|
else
|
|
return error4( trans->c4trans->c4, e4rollback, E83805 ) ;
|
|
}
|
|
|
|
memcpy( data->record, tran4getData( trans, sizeof( long ) ), dfile4recWidth( data->dataFile ) ) ;
|
|
rc = d4unappend( data ) ;
|
|
memset( data->record, 0, dfile4recWidth( data->dataFile ) ) ;
|
|
if ( rc < 0 )
|
|
return error4stack( trans->c4trans->c4, rc, E93801 ) ;
|
|
|
|
return d4update( data ) ;
|
|
}
|
|
|
|
int tran4lowUnwrite( TRAN4 *trans )
|
|
{
|
|
DATA4 *data ;
|
|
int rc, doSpecial ;
|
|
long recNo ;
|
|
char *rec, *saveRec = 0;
|
|
CODE4 *c4 ;
|
|
#ifndef S4MEMO_OFF
|
|
int i ;
|
|
unsigned long ptrLen, pos ;
|
|
#endif
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( trans == 0 )
|
|
return error4( 0, e4parm_null, E93801 ) ;
|
|
#endif
|
|
|
|
c4 = trans->c4trans->c4 ;
|
|
recNo = *((long *)(tran4getData( trans, 0L ) ) ) ;
|
|
rec = (char *)tran4getData( trans, (long)sizeof( long ) ) ;
|
|
|
|
data = tran4dataFull( trans, tran4serverDataId( trans ), tran4clientDataId( trans ) ) ;
|
|
if ( data == 0 )
|
|
return error4( c4, e4name, E93801 ) ;
|
|
|
|
doSpecial = 0 ;
|
|
if ( data->recordChanged == 1 ) /* override flush */
|
|
{
|
|
if ( d4recNo( data ) == recNo )
|
|
{
|
|
/* special, case (automatic rollback) -- save record for user */
|
|
doSpecial = 1 ;
|
|
saveRec = data->record ;
|
|
data->record =(char*) u4allocFree( c4, dfile4recWidth( data->dataFile ) + 1 ) ;
|
|
if ( data->record == 0 )
|
|
{
|
|
/* user will lose changes, due to low memory, but can at least rollback */
|
|
data->record = saveRec ;
|
|
doSpecial = 0 ;
|
|
}
|
|
else
|
|
memcpy( data->record, saveRec, dfile4recWidth( data->dataFile ) ) ;
|
|
}
|
|
data->recordChanged = 0 ;
|
|
}
|
|
rc = 0 ;
|
|
if ( doSpecial == 0 )
|
|
rc = d4go( data, recNo ) ;
|
|
|
|
if ( rc == 0 )
|
|
#ifndef S4OFF_MULTI
|
|
if ( dfile4lockTest( data->dataFile, tran4clientDataId( trans ), tran4serverDataId( trans ), recNo ) == 0 )
|
|
rc = error4( c4, e4lock, E83804 ) ;
|
|
#endif
|
|
|
|
if ( rc == 0 )
|
|
{
|
|
memcpy( d4record( data ), rec, (size_t)dfile4recWidth( data->dataFile ) ) ;
|
|
#ifndef S4MEMO_OFF
|
|
pos = (long)sizeof( long ) + 2L * dfile4recWidth( data->dataFile ) ;
|
|
for ( i = 0; i < data->dataFile->nFieldsMemo; i++ )
|
|
{
|
|
ptrLen = *( (unsigned int *)tran4getData( trans, pos ) ) ;
|
|
pos += sizeof( ptrLen ) ;
|
|
if ( ptrLen != 0 )
|
|
f4memoAssignN( data->fieldsMemo[i].field, (char *)tran4getData( trans, pos ), (unsigned int)ptrLen ) ;
|
|
pos += ptrLen ;
|
|
#ifdef S4DATA_ALIGN
|
|
memcpy(&ptrLen, tran4getData(trans, pos), sizeof(ptrLen));
|
|
#else
|
|
ptrLen = *( (unsigned long *)tran4getData( trans, pos ) ) ;
|
|
#endif
|
|
pos += sizeof( ptrLen ) + ptrLen ;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if ( rc == 0 )
|
|
rc = d4writeLow( data, recNo, 0 ) ;
|
|
|
|
if ( rc == 0 )
|
|
rc = d4update( data ) ;
|
|
|
|
if ( doSpecial )
|
|
{
|
|
u4free( data->record ) ;
|
|
data->record = saveRec ;
|
|
data->recordChanged = 1 ;
|
|
}
|
|
|
|
return rc ;
|
|
}
|
|
|
|
#ifdef P4ARGS_USED
|
|
#pragma argsused
|
|
#endif
|
|
/* clientId is a unique id for the transactee. In the single user case, there is only one */
|
|
int S4FUNCTION tran4lowStart( TRAN4 *trans, long clientId, int doUnlock )
|
|
{
|
|
int rc ;
|
|
#ifdef S4STAND_ALONE_TRANS
|
|
int oldLockAttempts ;
|
|
#endif
|
|
CODE4 *c4 ;
|
|
|
|
#ifdef E4PARM_HIGH
|
|
if ( trans == 0 )
|
|
return error4( 0, e4parm_null, E93801 ) ;
|
|
#endif
|
|
|
|
c4 = trans->c4trans->c4 ;
|
|
|
|
if ( trans->c4trans->enabled == 0 )
|
|
{
|
|
#ifdef S4STAND_ALONE
|
|
if ( c4->logOpen == 0 )
|
|
return error4( c4, e4trans, E83814 ) ;
|
|
#endif
|
|
#ifdef S4STAND_ALONE
|
|
rc = code4logOpen( c4, 0, 0 ) ;
|
|
#else
|
|
rc = code4transFileEnable( trans->c4trans, 0, 0 ) ;
|
|
#endif
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
}
|
|
|
|
if ( trans->c4trans->enabled != 1 )
|
|
return error4( c4, e4trans, E83807 ) ;
|
|
|
|
#ifdef S4STAND_ALONE
|
|
if ( trans->currentTranStatus == r4active ) /* already in a transactional state */
|
|
return error4( c4, e4trans, E93801 ) ;
|
|
#endif
|
|
|
|
if ( trans->c4trans->transFile->status != 0 )
|
|
return error4( c4, e4trans, E83801 ) ;
|
|
|
|
#ifndef S4OFF_MULTI
|
|
if ( doUnlock == 1 )
|
|
{
|
|
rc = code4unlock( c4 ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
}
|
|
#endif
|
|
|
|
#ifdef S4STAND_ALONE_TRANS
|
|
oldLockAttempts = c4->lockAttempts ;
|
|
c4->lockAttempts = WAIT4EVER ;
|
|
rc = code4tranLockTransactions( c4->c4trans, TRAN4LOCK_MULTIPLE ) ;
|
|
c4->lockAttempts = oldLockAttempts ;
|
|
if ( rc < 0 )
|
|
rc = error4( c4, rc, E93801 ) ;
|
|
tran4bottom( trans ) ;
|
|
switch( tran4type( trans ) )
|
|
{
|
|
case TRAN4COMPLETE:
|
|
case TRAN4ROLLBACK:
|
|
case TRAN4OPEN:
|
|
case TRAN4CLOSE:
|
|
}
|
|
#endif
|
|
|
|
rc = tran4set( trans, trans->currentTranStatus, -1L, clientId, TRAN4START, 0, 0L, 0L ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
if ( tran4lowAppend( trans, "\0" ) != 0 )
|
|
return e4transAppend ;
|
|
|
|
trans->currentTranStatus = r4active ;
|
|
|
|
#ifndef S4OFF_MULTI
|
|
trans->savedUnlockAuto = trans->unlockAuto ;
|
|
trans->unlockAuto = 0 ;
|
|
#endif
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
/*int S4FUNCTION tran4lowRollback( TRAN4 *trans, long id, int doUnlock )*/
|
|
int S4FUNCTION tran4lowRollback( TRAN4 *trans, long id, const int doInvalidate )
|
|
{
|
|
int done, saveErr, rc ;
|
|
long transId ;
|
|
CODE4 *c4 ;
|
|
|
|
#ifdef E4PARM_HIGH
|
|
if ( trans == 0 )
|
|
return error4( 0, e4parm, E93801 ) ;
|
|
#endif
|
|
|
|
c4 = trans->c4trans->c4 ;
|
|
saveErr = error4set( c4, 0 ) ;
|
|
transId = tran4getTransId( trans ) ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( transId <= 0 )
|
|
return error4( 0, e4info, E93801 ) ;
|
|
#endif
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( trans->c4trans->enabled != 1 )
|
|
return error4( c4, e4rollback, E83807 ) ;
|
|
#endif
|
|
|
|
if ( trans->currentTranStatus != r4active )
|
|
return error4( c4, e4trans, E83808 ) ;
|
|
|
|
if ( trans->c4trans->transFile->status != 0 )
|
|
return error4( c4, e4trans, E83801 ) ;
|
|
trans->c4trans->transFile->status = 1 ;
|
|
|
|
trans->currentTranStatus = r4rollback ;
|
|
|
|
/* first rollback all the transactions, then mark a rollback as having occurred */
|
|
rc = tran4bottom( trans ) ;
|
|
if ( rc != 0 )
|
|
return error4stack( c4, rc, E93801 ) ;
|
|
|
|
for( done = 0, rc = 0; !done && !rc ; )
|
|
{
|
|
if ( tran4id( trans ) == transId )
|
|
{
|
|
switch( tran4type( trans ) )
|
|
{
|
|
case TRAN4START:
|
|
done = 1 ;
|
|
break ;
|
|
case TRAN4WRITE:
|
|
rc = tran4lowUnwrite( trans ) ;
|
|
break ;
|
|
case TRAN4APPEND:
|
|
rc = tran4lowUnappend( trans ) ;
|
|
break ;
|
|
case TRAN4VOID: /* transaction connectioning to next was voided, so skip... */
|
|
case TRAN4OPEN:
|
|
case TRAN4OPEN_TEMP:
|
|
case TRAN4CLOSE:
|
|
break ;
|
|
default:
|
|
rc = error4( c4, e4rollback, E83809 ) ;
|
|
}
|
|
}
|
|
if ( !done && !rc )
|
|
rc = tran4skip( trans, TRAN4BACKWARDS ) ;
|
|
}
|
|
if ( rc > 0 )
|
|
rc = 0 ;
|
|
|
|
if ( rc == 0 )
|
|
{
|
|
tran4set( trans, trans->currentTranStatus, transId, id, TRAN4ROLLBACK, 0, 0L, 0L ) ;
|
|
if ( tran4lowAppend( trans, "\0" ) != 0 )
|
|
return e4transAppend ;
|
|
}
|
|
|
|
trans->currentTranStatus = r4inactive ;
|
|
trans->transId = 0;
|
|
|
|
#ifndef S4OFF_MULTI
|
|
trans->unlockAuto = trans->savedUnlockAuto ;
|
|
#endif
|
|
|
|
#ifdef S4STAND_ALONE_TRANS
|
|
#ifndef S4UTILS
|
|
rc = code4tranUnlockTransactions( c4->c4trans, TRAN4LOCK_MULTIPLE ) ;
|
|
#endif
|
|
#endif
|
|
|
|
if ( saveErr != 0 )
|
|
error4set( c4, saveErr ) ;
|
|
|
|
if ( rc == 0 )
|
|
trans->c4trans->transFile->status = 0 ;
|
|
tran4lowCloseDelayed( trans ) ;
|
|
#ifndef S4SERVER
|
|
if ( doInvalidate )
|
|
code4invalidate( c4 ) ;
|
|
#endif
|
|
return rc ;
|
|
}
|
|
|
|
static int tran4lowRemoveKeys( TRAN4 *trans )
|
|
{
|
|
DATA4 *data ;
|
|
#ifndef S4OFF_INDEX
|
|
int rc, saveRc ;
|
|
TAG4 *tag ;
|
|
TAG4KEY_REMOVED *removed ;
|
|
|
|
saveRc = 0 ;
|
|
#endif
|
|
|
|
for ( data = 0 ;; ) /* first do open files */
|
|
{
|
|
data =(DATA4 *) l4next( tran4dataList( trans ), data ) ;
|
|
if ( data == 0 )
|
|
break ;
|
|
#ifndef S4OFF_INDEX
|
|
for ( tag = 0 ;; )
|
|
{
|
|
tag = d4tagNext( data, tag ) ;
|
|
if ( tag == 0 )
|
|
break ;
|
|
for ( removed = 0 ;; )
|
|
{
|
|
removed = (TAG4KEY_REMOVED *)l4first( &tag->removedKeys ) ;
|
|
if ( removed == 0 )
|
|
break ;
|
|
rc = tfile4remove( tag->tagFile, removed->key, removed->recno ) ;
|
|
if ( rc < 0 )
|
|
saveRc = rc ;
|
|
l4remove( &tag->removedKeys, removed ) ;
|
|
u4free( removed ) ;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
for ( data = 0 ;; ) /* now do closed files */
|
|
{
|
|
data =(DATA4 *) l4next( &trans->closedDataFiles, data ) ;
|
|
if ( data == 0 )
|
|
break ;
|
|
#ifndef S4OFF_INDEX
|
|
for ( tag = 0 ;; )
|
|
{
|
|
tag = d4tagNext( data, tag ) ;
|
|
if ( tag == 0 )
|
|
break ;
|
|
for ( removed = 0 ;; )
|
|
{
|
|
removed = (TAG4KEY_REMOVED *)l4first( &tag->removedKeys ) ;
|
|
if ( removed == 0 )
|
|
break ;
|
|
rc = tfile4remove( tag->tagFile, removed->key, removed->recno ) ;
|
|
if ( rc < 0 )
|
|
saveRc = rc ;
|
|
l4remove( &tag->removedKeys, removed ) ;
|
|
u4free( removed ) ;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
#ifndef S4OFF_INDEX
|
|
return saveRc ;
|
|
#else
|
|
return 0 ;
|
|
#endif
|
|
}
|
|
|
|
static int tran4updateData( TRAN4 *trans )
|
|
{
|
|
DATA4 *data ;
|
|
int rc, saveRc, oldTransStatus ;
|
|
|
|
/* changes trans status to force an update */
|
|
oldTransStatus = trans->currentTranStatus ;
|
|
trans->currentTranStatus = r4off ;
|
|
for ( data = 0, saveRc = 0 ;; )
|
|
{
|
|
data = (DATA4 *)l4next( trans->dataList, data ) ;
|
|
if ( data == 0 )
|
|
break ;
|
|
if ( data->dataFile->fileChanged == 1 )
|
|
{
|
|
#ifndef S4OFF_MULTI
|
|
if ( d4lockTestAppend( data ) == 1 )
|
|
#endif
|
|
{
|
|
rc = dfile4updateHeader( data->dataFile, 1, 1 ) ;
|
|
if ( rc < 0 )
|
|
saveRc = rc ;
|
|
}
|
|
}
|
|
}
|
|
|
|
trans->currentTranStatus = oldTransStatus ;
|
|
return saveRc ;
|
|
}
|
|
|
|
static int tran4lowFlush( TRAN4 *trans )
|
|
{
|
|
DATA4 *dataOn ;
|
|
int rc ;
|
|
|
|
for ( dataOn = 0 ;; )
|
|
{
|
|
dataOn = (DATA4 *)l4next( tran4dataList( trans ), dataOn ) ;
|
|
if ( dataOn == 0 )
|
|
break ;
|
|
#ifndef S4OFF_MULTI
|
|
if ( d4lockTestAppend( dataOn ) )
|
|
#endif
|
|
dfile4updateHeader( dataOn->dataFile, 1, 1 ) ;
|
|
rc = d4flush( dataOn ) ;
|
|
if ( rc != 0 )
|
|
return rc ;
|
|
}
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
#ifdef P4ARGS_USED
|
|
#pragma argsused
|
|
#endif
|
|
int S4FUNCTION tran4lowCommit( TRAN4 *trans, long id, unsigned short int numServers, int doUnlock )
|
|
{
|
|
int rc ;
|
|
CODE4 *c4 ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( trans == 0 )
|
|
return error4( 0, e4parm_null, E93801 ) ;
|
|
#endif
|
|
|
|
c4 = trans->c4trans->c4 ;
|
|
|
|
if ( trans->c4trans->enabled != 1 )
|
|
return error4( c4, e4parm, E83807 ) ;
|
|
|
|
if ( trans->currentTranStatus == r4inactive )
|
|
return 0 ;
|
|
|
|
#ifdef S4DISTRIBUTED
|
|
if ( trans->currentTranStatus == S4PARTIAL )
|
|
return error4( c4, e4commit, E93801 ) ;
|
|
#endif
|
|
|
|
if ( trans->c4trans->transFile->status != 0 )
|
|
return error4( c4, e4trans, E83801 ) ;
|
|
|
|
rc = tran4lowFlush( trans ) ;
|
|
if ( rc != 0 )
|
|
return rc ;
|
|
|
|
trans->c4trans->transFile->status = 1 ;
|
|
|
|
rc = tran4set( trans, trans->currentTranStatus, -1L, id, TRAN4COMPLETE, 0, 0L, 0L ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
#ifdef S4DISTRIBUTED
|
|
rc = tran4putData( trans, &numServers, sizeof( numServers ) ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
#endif
|
|
if ( tran4lowAppend( trans, "\0" ) != 0 )
|
|
return e4transAppend ;
|
|
|
|
#ifdef S4DISTRIBUTED
|
|
trans->currentTranStatus = r4partial ;
|
|
if ( numServers == 1 ) /* simple commit, perform completion as well */
|
|
rc = tran4complete( trans, id ) ;
|
|
else
|
|
rc = 0 ;
|
|
#else
|
|
rc = tran4lowRemoveKeys( trans ) ;
|
|
if ( rc < 0 )
|
|
return error4stack( c4, rc, E93801 ) ;
|
|
trans->currentTranStatus = r4inactive ;
|
|
trans->transId = 0;
|
|
#ifdef S4STAND_ALONE_TRANS
|
|
#ifndef S4UTILS
|
|
rc = code4tranUnlockTransactions( c4->c4trans, TRAN4LOCK_MULTIPLE ) ;
|
|
if ( rc == 0 )
|
|
{
|
|
#endif
|
|
#endif
|
|
#ifdef S4OFF_MULTI
|
|
rc = 0 ;
|
|
#else
|
|
trans->unlockAuto = trans->savedUnlockAuto ;
|
|
rc = tran4updateData( trans ) ;
|
|
if ( rc == 0 && doUnlock )
|
|
{
|
|
if ( code4unlockAuto( c4 ) == 1 )
|
|
rc = code4unlock( c4 ) ;
|
|
}
|
|
#endif
|
|
#ifdef S4STAND_ALONE_TRANS
|
|
#ifndef S4UTILS
|
|
}
|
|
#endif
|
|
#endif
|
|
#endif
|
|
if ( rc == 0 )
|
|
trans->c4trans->transFile->status = 0 ;
|
|
|
|
tran4lowCloseDelayed( trans ) ;
|
|
return rc ;
|
|
}
|
|
|
|
#ifdef S4DISTRIBUTED
|
|
int tran4lowComplete( TRAN4 *trans, long id )
|
|
{
|
|
int rc ;
|
|
#ifdef E4PARM_LOW
|
|
if ( trans == 0 )
|
|
return error4( 0, e4parm_null, E93801 ) ;
|
|
#endif
|
|
|
|
if ( trans->currentTranStatus != S4PARTIAL )
|
|
return error4( trans->c4trans->c4, e4commit, E83811 ) ;
|
|
|
|
rc = tran4set( trans, trans->currentTranStatus, -1, id, TRAN4COMMIT, 0, 0L, 0L ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
if ( tran4lowAppend( trans, "\0" ) != 0 )
|
|
return e4transAppend ;
|
|
|
|
trans->currentTranStatus = TRAN4INACTIVE ;
|
|
trans->unlockAuto = trans->savedUnlockAuto ;
|
|
|
|
return 0 ;
|
|
}
|
|
#endif /* S4DISTRIBUTED */
|
|
#endif /* not S4CLIENT */
|
|
|
|
#ifdef S4SERVER
|
|
#ifndef S4INLINE
|
|
int S4FUNCTION code4tranStart( CODE4 *c4 )
|
|
{
|
|
return tran4lowStart( &c4->currentClient->trans, connection4id( c4->currentClient->connection ), 0 ) ;
|
|
}
|
|
|
|
int S4FUNCTION code4tranStartSingle( CODE4 *c4 )
|
|
{
|
|
return tran4lowStart( &c4->currentClient->trans, connection4id( c4->currentClient->connection ), 0 ) ;
|
|
}
|
|
|
|
int S4FUNCTION code4tranCommit( CODE4 *c4 )
|
|
{
|
|
int rc ;
|
|
|
|
rc = code4flush( c4 ) ;
|
|
if ( rc != 0 )
|
|
return rc ;
|
|
|
|
return tran4lowCommit( &c4->currentClient->trans, connection4id( c4->currentClient->connection ), 1 ) ;
|
|
}
|
|
|
|
int S4FUNCTION code4tranRollback( CODE4 *c4 )
|
|
{
|
|
return tran4lowRollback( &c4->currentClient->trans, connection4id( c4->currentClient->connection ), 1 ) ;
|
|
}
|
|
#endif /* S4INLINE */
|
|
#endif /* S4SERVER */
|
|
|
|
|
|
#ifndef S4SERVER
|
|
|
|
/* places all DATA4's into an invalid state */
|
|
static void code4invalidate( CODE4 *c4 )
|
|
{
|
|
DATA4 *dataOn ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( c4 == 0 )
|
|
{
|
|
error4( 0, e4parm_null, E93827 ) ;
|
|
return ;
|
|
}
|
|
#endif
|
|
|
|
for ( dataOn = 0 ;; )
|
|
{
|
|
dataOn = (DATA4 *)l4next( c4->c4trans.trans.dataList, dataOn ) ;
|
|
if ( dataOn == 0 )
|
|
break ;
|
|
/* 04/24/96 --> d4blank() replacing memset due to S4FOX binary
|
|
fields having non-blank contents to represent blank */
|
|
/* memset( dataOn->record, ' ', dfile4recWidth( dataOn->dataFile ) ) ; */
|
|
dataOn->recNum = dataOn->recNumOld = -1 ; /* ensure that d4blank works with lock-enforce on, plus reset record # */
|
|
d4blank( dataOn ) ;
|
|
d4changed( dataOn, 0 ) ;
|
|
}
|
|
}
|
|
|
|
#ifndef S4CLIENT
|
|
S4EXPORT int S4FUNCTION code4tranCommit( CODE4 *c4 )
|
|
{
|
|
int saveErr, rc ;
|
|
|
|
#ifdef E4PARM_HIGH
|
|
if ( c4 == 0 )
|
|
return error4( 0, e4parm_null, E93828 ) ;
|
|
#endif
|
|
|
|
if ( code4transEnabled( c4 ) != 1 )
|
|
return error4( c4, e4trans, E83807 ) ;
|
|
|
|
rc = code4flush( c4 ) ;
|
|
if ( rc != 0 )
|
|
return rc ;
|
|
|
|
saveErr = error4code( c4 ) ;
|
|
if ( saveErr < 0 )
|
|
error4set( c4, 0 ) ;
|
|
|
|
rc = tran4lowCommit( &c4->c4trans.trans, 0, 1, 1 ) ;
|
|
|
|
#ifndef S4OFF_MULTI
|
|
if ( code4unlockAuto( c4 ) == 1 )
|
|
if ( code4unlock( c4 ) != 0 )
|
|
return error4( c4, e4unlock, E93828 ) ;
|
|
#endif
|
|
|
|
if ( saveErr == 0 )
|
|
saveErr = rc ;
|
|
if ( saveErr != 0 )
|
|
error4set( c4, saveErr ) ;
|
|
|
|
return rc ;
|
|
}
|
|
|
|
S4EXPORT int S4FUNCTION code4tranStart( CODE4 *c4 )
|
|
{
|
|
#ifdef E4PARM_HIGH
|
|
if ( c4 == 0 )
|
|
return error4( 0, e4parm_null, E93829 ) ;
|
|
#endif
|
|
|
|
return tran4lowStart( &c4->c4trans.trans, 0, 0 ) ;
|
|
}
|
|
|
|
int S4FUNCTION code4tranStartSingle( CODE4 *c4 )
|
|
{
|
|
#ifdef E4PARM_HIGH
|
|
if ( c4 == 0 )
|
|
return error4( 0, e4parm_null, E93829 ) ;
|
|
#endif
|
|
|
|
return tran4lowStart( &c4->c4trans.trans, 0, 0 ) ;
|
|
}
|
|
|
|
int S4FUNCTION code4tranRollback( CODE4 *c4 )
|
|
{
|
|
int rc ;
|
|
|
|
#ifdef E4PARM_HIGH
|
|
if ( c4 == 0 )
|
|
return error4( 0, e4parm_null, E93830 ) ;
|
|
#endif
|
|
|
|
if ( code4transEnabled( c4 ) != 1 )
|
|
return error4( c4, e4trans, E83807 ) ;
|
|
|
|
rc = tran4lowRollback( &c4->c4trans.trans, 0, 1 ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
|
|
/* rc = code4invalidate( c4 ) ; --> moved to low rollback.*/
|
|
/* if ( rc < 0 )*/
|
|
/* return rc ;*/
|
|
|
|
#ifdef S4OFF_MULTI
|
|
return 0 ;
|
|
#else
|
|
return code4unlock( c4 ) ;
|
|
#endif
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef S4CLIENT
|
|
int S4FUNCTION code4tranCommit( CODE4 *c4 )
|
|
{
|
|
int saveRc, saveErr ;
|
|
SOCKET4 *socket4 ;
|
|
CONNECTION4 *connection ;
|
|
CONNECTION4COMMIT_INFO_IN info ;
|
|
#ifdef S4DISTRIBUTED
|
|
unsigned int dataLen ;
|
|
char *data ;
|
|
int numServers, rc ;
|
|
#endif
|
|
|
|
#ifdef E4ANALYZE
|
|
socket4 = 0 ;
|
|
connection = 0 ;
|
|
memset( &info, 0, sizeof( CONNECTION4COMMIT_INFO_IN ) ) ;
|
|
#endif
|
|
|
|
#ifdef E4PARM_HIGH
|
|
if ( c4 == 0 )
|
|
return error4( 0, e4parm_null, E93828 ) ;
|
|
#endif
|
|
|
|
if ( code4transEnabled( c4 ) != 1 )
|
|
return error4( c4, e4trans, E83807 ) ;
|
|
|
|
if ( c4->c4trans.trans.currentTranStatus == r4inactive )
|
|
return error4( c4, e4trans, E83812 ) ;
|
|
|
|
saveRc = code4flush( c4 ) ;
|
|
if ( saveRc != 0 )
|
|
return saveRc ;
|
|
|
|
#ifdef S4DISTRIBUTED
|
|
if ( c4->servers.nLink == 0 )
|
|
#else
|
|
if ( c4->defaultServer == 0 )
|
|
#endif
|
|
if ( c4->defaultServer == 0 )
|
|
return error4( c4, e4connection, E80304 ) ;
|
|
|
|
if ( error4code( c4 ) < 0 )
|
|
{
|
|
saveErr = error4code( c4 ) ;
|
|
error4set( c4, 0 ) ;
|
|
}
|
|
else
|
|
saveErr = 0 ;
|
|
|
|
saveRc = 0 ;
|
|
|
|
#ifdef S4DISTRIBUTED
|
|
if ( c4->servers.nLink == 1 ) /* simple commit only required */
|
|
{
|
|
#endif
|
|
info.numServers = 1 ;
|
|
#ifdef S4DISTRIBUTED
|
|
socket4 = (SOCKET4 *)l4first( &c4->servers ) ;
|
|
#else
|
|
socket4 = c4->defaultServer ;
|
|
#endif
|
|
connection = socket4->connect ;
|
|
connection4assign( connection, CON4COMMIT, 0, 0 ) ;
|
|
connection4addData( connection, &info, sizeof( CONNECTION4COMMIT_INFO_IN ), 0 ) ;
|
|
connection4send( connection ) ;
|
|
saveRc = connection4receive( connection ) ;
|
|
if ( saveRc >= 0 )
|
|
saveRc = connection4status( connection ) ;
|
|
#ifdef S4DISTRIBUTED
|
|
}
|
|
else
|
|
{
|
|
info.numServers = c4->servers.nLink ;
|
|
|
|
dataLen = sizeof( CONNECTION4COMMIT_INFO_IN ) + info.numServers * S4STAND_ALONE_ALIAS_LEN ;
|
|
data = (char *)u4allocFree( c4, dataLen ) ;
|
|
if ( data == 0 )
|
|
return error4stack( c4, e4memory, E93828 ) ;
|
|
|
|
memcpy( data, &info, sizeof( CONNECTION4COMMIT_INFO_IN ) ) ;
|
|
|
|
rc = 0 ;
|
|
socket4 = 0 ;
|
|
for( numServers = 0 ;; numServers++ ) /* prepare the info packets */
|
|
{
|
|
socket4 = (SOCKET4 *)l4next( &c4->servers, socket4 ) ;
|
|
if ( socket4 == 0 )
|
|
break ;
|
|
connection = socket4->connect ;
|
|
if ( connection == 0 )
|
|
return error4( c4, e4info, E93828 ) ;
|
|
memcpy( data + sizeof( CONNECTION4COMMIT_INFO_IN ) + numServers * S4STAND_ALONE_ALIAS_LEN, socket4->serverName, NEED A LOCAL FOR SERVER NAME, SET TO SIZE AND S4MAX_SERVER_NAME_SI
|
|
}
|
|
|
|
rc = 0 ;
|
|
socket4 = 0 ;
|
|
for( ;; ) /* set commit message to all connected servers */
|
|
{
|
|
socket4 = (SOCKET4 *)l4next( &c4->servers, socket4 ) ;
|
|
if ( socket4 == 0 )
|
|
break ;
|
|
connection = socket4->connect ;
|
|
connection4assign( connection, CON4COMMIT, 0, 0 ) ;
|
|
connection4addData( connection, data, dataLen, 0 ) ;
|
|
connection4send( connection ) ;
|
|
rc = connection4receive( connection ) ;
|
|
if ( rc < 0 )
|
|
break ;
|
|
rc = connection4status( connection ) ;
|
|
if ( rc != 0 )
|
|
break ;
|
|
}
|
|
|
|
if ( rc != 0 ) /* rollback everybody */
|
|
{
|
|
for( ;; )
|
|
{
|
|
socket4 = (SOCKET4 *)l4prev( &c4->servers, socket4 ) ;
|
|
if ( socket4 == 0 )
|
|
break ;
|
|
connection = socket4->connect ;
|
|
connection4assign( connection, S4CANCEL_TRANSACTION, 0, 0 ) ;
|
|
connection4send( connection ) ;
|
|
connection4receive( connection, rc ) ;
|
|
}
|
|
|
|
return rc ;
|
|
}
|
|
|
|
socket4 = 0 ;
|
|
for( ;; ) /* complete the commits */
|
|
{
|
|
socket4 = (SOCKET4 *)l4next( &c4->servers, socket4 ) ;
|
|
if ( socket4 == 0 )
|
|
break ;
|
|
connection = socket4->connect ;
|
|
connection4assign( connection, S4COMPLETE, 0, 0 ) ;
|
|
connection4send( connection ) ;
|
|
rc = connection4receive( connection ) ;
|
|
if ( rc < 0 )
|
|
{
|
|
saveRc = rc ;
|
|
error4set( c4, 0 ) ;
|
|
continue ;
|
|
}
|
|
rc = connection4status( connection ) ;
|
|
if ( rc < 0 )
|
|
{
|
|
saveRc = rc ;
|
|
error4set( c4, 0 ) ;
|
|
continue ;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if ( saveErr == 0 )
|
|
saveErr = saveRc ;
|
|
if ( saveErr != 0 )
|
|
error4set( c4, saveErr ) ;
|
|
|
|
c4->c4trans.trans.currentTranStatus = r4inactive ;
|
|
tran4lowCloseDelayed( &c4->c4trans.trans ) ;
|
|
return 0 ;
|
|
}
|
|
|
|
int S4FUNCTION code4tranStart( CODE4 *c4 )
|
|
{
|
|
CONNECTION4 *connection ;
|
|
int rc ;
|
|
#ifdef S4DISTRIBUTED
|
|
SOCKET4 *socket4 ;
|
|
#endif
|
|
|
|
#ifdef E4PARM_HIGH
|
|
if ( c4 == 0 )
|
|
return error4( 0, e4parm_null, E93829 ) ;
|
|
#endif
|
|
|
|
if ( code4transEnabled( c4 ) != 1 )
|
|
return error4( c4, e4trans, E83807 ) ;
|
|
|
|
if ( c4->c4trans.trans.currentTranStatus == r4active )
|
|
return error4( c4, e4trans, E93829 ) ;
|
|
|
|
rc = 0 ;
|
|
#ifdef S4DISTRIBUTED
|
|
socket4 = 0 ;
|
|
for( ;; ) /* set start message to all connected servers */
|
|
{
|
|
socket4 = (SOCKET4 *)l4next( &c4->servers, socket4 ) ;
|
|
if ( socket4 == 0 )
|
|
break ;
|
|
connection = socket4->connect ;
|
|
connection4assign( connection, CON4START, 0, 0 ) ;
|
|
connection4send( connection ) ;
|
|
rc = connection4receive( connection ) ;
|
|
if ( rc < 0 )
|
|
break ;
|
|
rc = connection4status( connection ) ;
|
|
if ( rc != 0 )
|
|
{
|
|
if ( rc < 0 )
|
|
connection4error( connection, c4, rc, E93829 ) ;
|
|
break ;
|
|
}
|
|
}
|
|
#else
|
|
if ( c4->defaultServer == 0 )
|
|
return error4( c4, e4connection, E80304 ) ;
|
|
|
|
if ( c4->defaultServer != 0 )
|
|
{
|
|
connection = c4->defaultServer->connect ;
|
|
connection4assign( connection, CON4START, 0, 0 ) ;
|
|
connection4send( connection ) ;
|
|
rc = connection4receive( connection ) ;
|
|
if ( rc >= 0 )
|
|
rc = connection4status( connection ) ;
|
|
}
|
|
|
|
if ( rc < 0 )
|
|
return error4stack( c4, rc, E93829 ) ;
|
|
#endif
|
|
|
|
c4->c4trans.trans.currentTranStatus = r4active ;
|
|
|
|
return rc ;
|
|
|
|
/* code4save()*/
|
|
}
|
|
|
|
int S4FUNCTION code4tranRollback( CODE4 *c4 )
|
|
{
|
|
CONNECTION4 *connection ;
|
|
int rc ;
|
|
#ifdef S4DISTRIBUTED
|
|
SOCKET4 *socket4 ;
|
|
#endif
|
|
|
|
#ifdef E4PARM_HIGH
|
|
if ( c4 == 0 )
|
|
return error4( 0, e4parm_null, E93830 ) ;
|
|
#endif
|
|
|
|
if ( code4transEnabled( c4 ) != 1 )
|
|
return error4( c4, e4trans, E83807 ) ;
|
|
|
|
if ( c4->c4trans.trans.currentTranStatus == r4inactive )
|
|
return error4( c4, e4trans, E83808 ) ;
|
|
|
|
#ifdef S4DISTRIBUTED
|
|
socket4 = 0 ;
|
|
for( ;; ) /* set start message to all connected servers */
|
|
{
|
|
socket4 = (SOCKET4 *)l4next( &c4->servers, socket4 ) ;
|
|
if ( socket4 == 0 )
|
|
break ;
|
|
connection = socket4->connect ;
|
|
connection4assign( connection, TRAN4ROLLBACK, 0, 0 ) ;
|
|
connection4send( connection ) ;
|
|
rc = connection4receive( connection ) ;
|
|
if ( rc < 0 )
|
|
return error4( c4, rc, E93830 ) ;
|
|
rc = connection4status( connection ) ;
|
|
if ( rc < 0 )
|
|
return connection4error( connection, c4, rc, E93830 ) ;
|
|
}
|
|
#else
|
|
if ( c4->defaultServer == 0 )
|
|
return error4( c4, e4connection, E80304 ) ;
|
|
|
|
if ( c4->defaultServer != 0 )
|
|
{
|
|
connection = c4->defaultServer->connect ;
|
|
connection4assign( connection, CON4ROLLBACK, 0, 0 ) ;
|
|
connection4send( connection ) ;
|
|
rc = connection4receive( connection ) ;
|
|
if ( rc >= 0 )
|
|
rc = connection4status( connection ) ;
|
|
if ( rc != 0 )
|
|
return error4stack( c4, rc, E93830 ) ;
|
|
}
|
|
#endif
|
|
|
|
c4->c4trans.trans.currentTranStatus = r4inactive ;
|
|
|
|
/* 04/24/96 AS --> moved code4invalidate before unlock call, so that any
|
|
changes left to records won't be flushed as a result of the unlock
|
|
call */
|
|
code4invalidate( c4 ) ;
|
|
|
|
rc = code4unlock( c4 ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
tran4lowCloseDelayed( &c4->c4trans.trans ) ;
|
|
|
|
return 0 ;
|
|
/* code4restore( c4 ) ;*/
|
|
}
|
|
#endif
|
|
|
|
#ifdef S4STAND_ALONE
|
|
int S4FUNCTION code4transFileEnable( CODE4TRANS *c4trans, const char *logName, const int doCreate )
|
|
#else
|
|
int code4transFileEnable( CODE4TRANS *c4trans, const char *logName, const int doCreate )
|
|
#endif
|
|
{
|
|
#ifdef E4ANALYZE
|
|
int rc ;
|
|
#else
|
|
#ifndef S4CLIENT
|
|
int rc ;
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef S4CLIENT
|
|
CODE4 *c4 ;
|
|
#endif
|
|
|
|
if ( c4trans->enabled == 1 )
|
|
return 0 ;
|
|
|
|
#ifdef S4STAND_ALONE
|
|
rc = code4tranInitLow( &c4trans->trans, c4trans ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = code4transVerify( c4trans, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
#ifndef S4CLIENT
|
|
rc = 0 ;
|
|
|
|
c4 = c4trans->c4 ;
|
|
|
|
if ( c4trans->enabled == 0 )
|
|
{
|
|
if ( logName != 0 )
|
|
{
|
|
if ( c4->transFileName != 0 )
|
|
u4free( c4->transFileName ) ;
|
|
c4->transFileName = (char *)u4allocFree( c4, (long)strlen( logName ) + 1L ) ;
|
|
if ( c4->transFileName == 0 )
|
|
rc = e4memory ;
|
|
else
|
|
strcpy( c4->transFileName, logName ) ;
|
|
}
|
|
|
|
if( c4->transFileName != 0 )
|
|
{
|
|
#ifdef S4SERVER
|
|
rc = tran4fileInit( &c4->server->transFile, c4trans ) ;
|
|
#else
|
|
rc = tran4fileInit( &c4->transFile, c4trans ) ;
|
|
#endif
|
|
if ( rc == 0 )
|
|
{
|
|
if ( doCreate == 0 )
|
|
{
|
|
#ifdef S4SERVER
|
|
rc = tran4fileOpen( &c4->server->transFile, c4->transFileName ) ;
|
|
#else
|
|
rc = tran4fileOpen( &c4->transFile, c4->transFileName ) ;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
#ifdef S4SERVER
|
|
rc = tran4fileCreate( &c4->server->transFile, c4->transFileName ) ;
|
|
#else
|
|
rc = tran4fileCreate( &c4->transFile, c4->transFileName ) ;
|
|
#endif
|
|
}
|
|
if ( rc == 0 )
|
|
{
|
|
c4trans->enabled = 1 ;
|
|
#ifdef S4SERVER
|
|
c4trans->transFile = &c4->server->transFile ;
|
|
#else
|
|
c4trans->transFile = &c4->transFile ;
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ( rc != 0 )
|
|
{
|
|
u4free( c4->transFileName ) ;
|
|
c4->transFileName = 0 ;
|
|
}
|
|
return rc ;
|
|
#else
|
|
return 0 ;
|
|
#endif
|
|
}
|
|
|
|
#ifndef S4CLIENT
|
|
int tran4addUser( TRAN4 *trans, const long clientId, const char *charId, const unsigned short int lenIn )
|
|
{
|
|
int rc ;
|
|
short int netIdLen ;
|
|
unsigned short int len ;
|
|
char *netId ;
|
|
CODE4 *c4 ;
|
|
#ifdef S4STAND_ALONE
|
|
#ifndef S4OFF_MULTI
|
|
int i, oldNumAttempts ;
|
|
#endif
|
|
#endif
|
|
|
|
len = lenIn ;
|
|
c4 = trans->c4trans->c4 ;
|
|
|
|
if ( trans->c4trans->enabled == 1 && code4tranStatus( c4 ) != r4off )
|
|
{
|
|
#ifdef S4STAND_ALONE
|
|
#ifdef S4OFF_MULTI
|
|
trans->userIdNo = 1 ; /* only one user */
|
|
#else
|
|
if ( clientId == 0L ) /* need to manually get the id */
|
|
{
|
|
for ( i = 0 ;; i++ )
|
|
{
|
|
if ( i >= TRAN4MAX_USERS )
|
|
return error4( c4, e4max, E83816 ) ;
|
|
oldNumAttempts = c4->lockAttempts ;
|
|
c4->lockAttempts = 1 ;
|
|
rc = file4lock( &trans->c4trans->transFile->file, TRAN4LOCK_USERS+i+1, 1 ) ;
|
|
c4->lockAttempts = oldNumAttempts ;
|
|
if ( rc == 0 )
|
|
{
|
|
trans->userIdNo = i + 1 ;
|
|
break ;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
if ( len > sizeof( trans->userId ) )
|
|
len = sizeof( trans->userId ) - 1 ;
|
|
memcpy( trans->userId, charId, len ) ;
|
|
trans->userId[len] = 0 ;
|
|
#ifdef S4SERVER
|
|
netId = connection4netUserId( c4->currentClient->connection->net ) ;
|
|
if ( netId == 0 )
|
|
netIdLen = 0 ;
|
|
else
|
|
netIdLen = strlen( netId ) ;
|
|
#else
|
|
netId = (char *)0 ;
|
|
netIdLen = 0 ;
|
|
#endif
|
|
rc = tran4set( trans, trans->currentTranStatus, -1L, clientId, TRAN4INIT, len + netIdLen + sizeof( len ) + sizeof( netIdLen), 0L, 0L ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
if ( tran4putData( trans, (void *)&netIdLen, sizeof( netIdLen ) ) == e4memory )
|
|
return e4memory ;
|
|
if ( netIdLen != 0 )
|
|
if ( tran4putData( trans, (void *)netId, (unsigned int)netIdLen ) == e4memory )
|
|
return e4memory ;
|
|
if ( tran4putData( trans, (void *)&len, sizeof( len ) ) == e4memory )
|
|
return e4memory ;
|
|
if ( tran4putData( trans, (void *)charId, len ) == e4memory )
|
|
return e4memory ;
|
|
if ( tran4lowAppend( trans, 0 ) != 0 )
|
|
return e4transAppend ;
|
|
}
|
|
else
|
|
return e4trans ; /* must return error to client so it is known that code4tranInit failed */
|
|
|
|
return 0 ;
|
|
}
|
|
#endif /* S4CLIENT */
|
|
|
|
#endif /* S4OFF_WRITE */
|
|
#endif /* S4OFF_TRAN */
|
|
|
|
#ifndef S4SERVER
|
|
#ifdef P4ARGS_USED
|
|
#pragma argsused
|
|
#endif
|
|
int S4FUNCTION code4lock( CODE4 *c4 )
|
|
{
|
|
#ifdef S4OFF_MULTI
|
|
return 0 ;
|
|
#else
|
|
LOCK4 *lock ;
|
|
#ifdef S4CLIENT
|
|
int numLocks, unlockData ;
|
|
int outRc = 0 ;
|
|
CONNECTION4 *connection ;
|
|
CONNECTION4LOCK_GROUP_INFO_IN info ;
|
|
#else
|
|
LOCK4 *lockNext ;
|
|
LIST4 locked ;
|
|
int saveErr, count, saveUnlockAuto ;
|
|
#endif
|
|
int rc = 0 ;
|
|
CODE4TRANS *c4trans ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = code4verify( c4, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
c4trans = &c4->c4trans ;
|
|
|
|
#ifdef S4CLIENT
|
|
numLocks = c4trans->trans.locks.nLink ;
|
|
if ( numLocks > 0 )
|
|
{
|
|
lock = (LOCK4 *)l4first( &c4trans->trans.locks ) ; /* for next line */
|
|
connection = lock->data->dataFile->connection ;
|
|
info.numLocks = numLocks ;
|
|
|
|
connection4assign( connection, CON4LOCK_GROUP, 0L, 0L ) ;
|
|
connection4addData( connection, &info, sizeof( info ), 0 ) ;
|
|
lock = (LOCK4 *)l4first( &c4trans->trans.locks ) ; /* reset */
|
|
unlockData = ( code4unlockAuto( c4 ) == LOCK4DATA ) ; /* must perform and register data unlock */
|
|
for( numLocks = info.numLocks ; numLocks > 0 ; numLocks-- )
|
|
{
|
|
#ifdef E4ANALYZE
|
|
if ( lock == 0 )
|
|
return error4stack( c4, e4struct, E91008 ) ;
|
|
#endif
|
|
if ( unlockData )
|
|
d4unlockClientData( lock->data ) ;
|
|
connection4addData( connection, &lock->id, sizeof( LOCK4ID ), 0 ) ;
|
|
lock = (LOCK4 *)l4next( &c4trans->trans.locks, lock ) ;
|
|
}
|
|
outRc = connection4repeat( connection, -2, -1, -1, 0 ) ;
|
|
if ( outRc < 0 )
|
|
return connection4error( connection, c4, outRc, E91008 ) ;
|
|
|
|
if ( outRc == r4locked )
|
|
return outRc ;
|
|
|
|
for( ;; ) /* now free lock memory, and record locks if required */
|
|
{
|
|
lock = (LOCK4 *)l4first( &c4trans->trans.locks ) ;
|
|
if ( lock == 0 )
|
|
break ;
|
|
if ( outRc == 0 ) /* record lock */
|
|
{
|
|
switch( lock->id.type )
|
|
{
|
|
case LOCK4APPEND:
|
|
lock->data->dataFile->appendLock = lock->data ;
|
|
break ;
|
|
case LOCK4FILE:
|
|
lock->data->dataFile->fileLock = lock->data ;
|
|
break ;
|
|
case LOCK4ALL:
|
|
lock->data->dataFile->fileLock = lock->data ;
|
|
break ;
|
|
case LOCK4RECORD:
|
|
d4localLockSet( lock->data, lock->id.recNum ) ;
|
|
break ;
|
|
#ifdef E4ANALYZE
|
|
default:
|
|
return error4( c4, e4lock, E81505 ) ;
|
|
#endif
|
|
}
|
|
}
|
|
l4remove( &c4trans->trans.locks, lock ) ;
|
|
mem4free( c4->lockMemory, lock ) ;
|
|
}
|
|
}
|
|
return outRc ;
|
|
#else
|
|
saveUnlockAuto = code4unlockAuto( c4 ) ;
|
|
|
|
if ( saveUnlockAuto == 1 )
|
|
{
|
|
rc = code4unlockDo( tran4dataList( &c4->c4trans.trans ) ) ;
|
|
if ( rc < 0 )
|
|
return error4stack( c4, rc, E91008 ) ;
|
|
}
|
|
|
|
code4unlockAutoSet( c4, 0 ) ;
|
|
|
|
memset( &locked, 0, sizeof( locked ) ) ;
|
|
for ( lock = 0, count = -1 ;; )
|
|
{
|
|
if ( lock == 0 )
|
|
{
|
|
lock = (LOCK4 *)l4first( &c4trans->trans.locks ) ;
|
|
count++ ;
|
|
|
|
if ( c4->lockAttemptsSingle != WAIT4EVER )
|
|
if ( count >= c4->lockAttemptsSingle ) /* timed out */
|
|
for ( ;; )
|
|
{
|
|
lock = (LOCK4 *)l4first( &locked ) ;
|
|
if ( lock == 0 )
|
|
{
|
|
code4unlockAutoSet( c4, saveUnlockAuto ) ;
|
|
return r4locked ;
|
|
}
|
|
lockNext = (LOCK4 *)l4next( &locked, lock ) ;
|
|
l4remove( &locked, lock ) ;
|
|
l4add( &c4trans->trans.locks, lock ) ;
|
|
lock = lockNext ;
|
|
}
|
|
}
|
|
|
|
if ( lock == 0 )
|
|
{
|
|
code4unlockAutoSet( c4, saveUnlockAuto ) ;
|
|
return 0 ;
|
|
}
|
|
|
|
switch( lock4lock( lock ) )
|
|
{
|
|
case r4success:
|
|
lockNext = (LOCK4 *)l4next( &c4trans->trans.locks, lock ) ;
|
|
l4remove( &c4trans->trans.locks, lock ) ;
|
|
l4add( &locked, lock ) ;
|
|
lock = lockNext ;
|
|
if ( lock == 0 )
|
|
{
|
|
for ( ;; )
|
|
{
|
|
lock = (LOCK4 *)l4first( &locked ) ;
|
|
if ( lock == 0 )
|
|
break ;
|
|
l4remove( &locked, lock ) ;
|
|
mem4free( c4->lockMemory, lock ) ;
|
|
}
|
|
code4unlockAutoSet( c4, saveUnlockAuto ) ;
|
|
return 0 ;
|
|
}
|
|
break ;
|
|
case r4locked:
|
|
lock = (LOCK4 *)l4next( &c4trans->trans.locks, lock ) ;
|
|
break ;
|
|
default:
|
|
saveErr = error4set( c4trans->c4, 0 ) ;
|
|
for ( ;; )
|
|
{
|
|
lock = (LOCK4 *)l4first( &locked ) ;
|
|
if ( lock == 0 )
|
|
{
|
|
error4set( c4trans->c4, saveErr ) ;
|
|
code4unlockAutoSet( c4, saveUnlockAuto ) ;
|
|
return -1 ;
|
|
}
|
|
|
|
l4remove( &locked, lock ) ;
|
|
l4add( &c4trans->trans.locks, lock ) ;
|
|
lock4unlock( lock ) ;
|
|
}
|
|
}
|
|
}
|
|
#endif /* S4CLIENT */
|
|
#endif /* S4OFF_MULTI */
|
|
}
|
|
#endif /* not S4SERVER */
|
|
|
|
#ifdef S4SERVER
|
|
int tran4closeAll( TRAN4 *trans )
|
|
{
|
|
DATA4 *dataOn, *dataNext ;
|
|
int rc ;
|
|
LIST4 *list ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( trans == 0 )
|
|
return error4( 0, e4parm_null, E93801 ) ;
|
|
#endif
|
|
|
|
rc = 0 ;
|
|
list = tran4dataList( trans ) ;
|
|
#ifdef E4ANALYZE
|
|
if ( list == 0 )
|
|
return error4( trans->c4trans->c4, e4struct, E93801 ) ;
|
|
#endif
|
|
for ( dataNext = (DATA4 *)l4first( list ) ;; )
|
|
{
|
|
dataOn = dataNext ;
|
|
if ( !dataOn )
|
|
break ;
|
|
dataNext = (DATA4 *)l4next( list, dataNext ) ;
|
|
|
|
if ( d4close( dataOn ) < 0 )
|
|
rc = -1 ;
|
|
}
|
|
|
|
if ( error4code( trans->c4trans->c4 ) < 0 )
|
|
return -1 ;
|
|
|
|
return rc ;
|
|
}
|
|
#endif /* S4SERVER */
|
|
|
|
#ifdef E4ANALYZE
|
|
static int code4transVerify( CODE4TRANS *c4trans, int subs )
|
|
{
|
|
int rc ;
|
|
|
|
if ( c4trans == 0 )
|
|
return error4( 0, e4parm_null, E93832 ) ;
|
|
|
|
if ( subs == 1 )
|
|
{
|
|
if ( ( rc = code4verify( c4trans->c4, 1 ) ) < 0 )
|
|
return rc ;
|
|
}
|
|
else
|
|
if ( c4trans->c4 == 0 )
|
|
return error4( 0, e4struct, E93832 ) ;
|
|
|
|
#ifndef S4OFF_TRAN
|
|
#ifndef S4OFF_WRITE
|
|
#ifndef S4CLIENT
|
|
if ( c4trans->enabled == 1 )
|
|
if ( c4trans->transFile == 0 )
|
|
return error4( c4trans->c4, e4struct, E93832 ) ;
|
|
#endif
|
|
#endif
|
|
#endif
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
int tran4verify( TRAN4 *t4, int subs )
|
|
{
|
|
int rc ;
|
|
#ifndef S4OFF_TRAN
|
|
CODE4 *c4 ;
|
|
#endif
|
|
|
|
if ( t4 == 0 )
|
|
return error4( 0, e4parm_null, E93801 ) ;
|
|
|
|
if ( t4->c4trans == 0 )
|
|
return error4( 0, e4struct, E93801 ) ;
|
|
|
|
#ifndef S4OFF_TRAN
|
|
c4 = t4->c4trans->c4 ;
|
|
|
|
if ( ( c4->tranDataLen != 0 && c4->tranData == 0 ) || ( c4->tranDataLen == 0 && c4->tranData != 0 ) )
|
|
return error4( c4, e4struct, E93801 ) ;
|
|
|
|
if ( ( t4->dataPos != 0 && c4->tranDataLen == 0 ) )
|
|
return error4( c4, e4struct, E93801 ) ;
|
|
#endif
|
|
|
|
if ( subs == 1 )
|
|
if ( ( rc = code4transVerify( t4->c4trans, 1 ) ) < 0 )
|
|
return rc ;
|
|
|
|
return 0 ;
|
|
}
|
|
#endif /* E4ANALYZE */
|
|
|
|
int code4tranInitLow( TRAN4 *t4, CODE4TRANS *c4trans )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( t4 == 0 || c4trans == 0 )
|
|
return error4( 0, e4parm_null, E93834 ) ;
|
|
#endif
|
|
|
|
t4->c4trans = c4trans ;
|
|
|
|
#ifndef S4OFF_WRITE
|
|
t4->transId = -1 ;
|
|
t4->dataPos = 0 ;
|
|
t4->pos = -1 ;
|
|
#endif
|
|
|
|
#ifdef S4CLIENT
|
|
t4->dataIdCount = 1 ;
|
|
#endif
|
|
#ifdef S4SERVER
|
|
t4->unlockAuto = 1 ;
|
|
#endif
|
|
|
|
#ifndef S4OFF_WRITE
|
|
t4->currentTranStatus = r4inactive ;
|
|
#endif
|
|
|
|
tran4dataListSet( t4, &(t4->localDataList) ) ;
|
|
|
|
#ifdef E4ANALYZE
|
|
return tran4verify( t4, 0 ) ;
|
|
#else
|
|
return 0 ;
|
|
#endif
|
|
}
|
|
|
|
#ifdef P4ARGS_USED
|
|
#pragma argsused
|
|
#endif
|
|
int S4FUNCTION code4transInitUndo( CODE4TRANS *c4trans )
|
|
{
|
|
#ifndef S4OFF_WRITE
|
|
#ifndef S4CLIENT
|
|
CODE4 *c4 ;
|
|
#ifndef S4OFF_TRAN
|
|
int rc, oldError ;
|
|
LOG4HEADER header ;
|
|
short int i ;
|
|
#ifdef S4STAND_ALONE
|
|
#ifndef S4OFF_MULTI
|
|
int oldNumAttempts ;
|
|
#endif
|
|
#endif
|
|
#endif
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( c4trans == 0 )
|
|
return error4( 0, e4parm_null, E93835 ) ;
|
|
#endif
|
|
|
|
#ifdef S4OFF_WRITE
|
|
return 0 ;
|
|
#else
|
|
#ifdef S4CLIENT
|
|
return 0 ;
|
|
#else
|
|
c4 = c4trans->c4 ;
|
|
if ( c4 != 0 )
|
|
if ( c4->transFileName != 0 )
|
|
{
|
|
u4free( c4->transFileName ) ;
|
|
c4->transFileName = 0 ;
|
|
}
|
|
|
|
#ifndef S4OFF_TRAN
|
|
oldError = error4set( c4trans->c4, 0 ) ;
|
|
rc = 0 ;
|
|
if ( c4trans->transFile != 0 )
|
|
{
|
|
#ifdef S4STAND_ALONE
|
|
#ifndef S4UTILS
|
|
code4tranInitUndoLow( &c4trans->trans, 0L ) ;
|
|
if (c4trans->trans.currentTranStatus == r4inactive)
|
|
{
|
|
#ifndef S4OFF_MULTI
|
|
file4unlock( &c4trans->transFile->file, TRAN4LOCK_USERS + c4trans->trans.userIdNo, 1 ) ;
|
|
oldNumAttempts = c4->lockAttempts ;
|
|
c4->lockAttempts = 1 ;
|
|
if ( file4lock( &c4trans->transFile->file, TRAN4LOCK_USERS, TRAN4MAX_USERS ) != r4locked ) /* last user, so shutdown */
|
|
#endif
|
|
{
|
|
#endif /* S4UTILS */
|
|
#endif /* S4STAND_ALONE */
|
|
#ifndef S4UTILS
|
|
if ( c4trans->transFile->status == 0 )
|
|
{
|
|
memset( &header, 0, sizeof( header ) ) ;
|
|
header.type = TRAN4SHUTDOWN ;
|
|
header.serverDataId = TRAN4VERSION_NUM ;
|
|
tran4fileAppend( c4trans->transFile, &header, "\0" ) ;
|
|
}
|
|
#endif
|
|
#ifdef S4STAND_ALONE
|
|
#ifndef S4UTILS
|
|
#ifndef S4OFF_MULTI
|
|
file4unlock( &c4trans->transFile->file, TRAN4LOCK_USERS, TRAN4MAX_USERS ) ;
|
|
#endif
|
|
}
|
|
#ifndef S4OFF_MULTI
|
|
c4->lockAttempts = oldNumAttempts ;
|
|
#endif
|
|
}
|
|
#endif /* S4UTILS */
|
|
#endif /* S4STAND_ALONE */
|
|
i = -1;
|
|
#ifndef S4OFF_MULTI
|
|
#ifndef S4UTILS
|
|
while ( (1UL << ++i ) <= c4trans->transFile->fileLocks )
|
|
if ( c4trans->transFile->fileLocks & ( 1UL << i ) )
|
|
code4tranUnlockTransactions( c4trans, TRAN4LOCK_BASE + i ) ;
|
|
#endif
|
|
#endif
|
|
rc = tran4fileClose( c4trans->transFile ) ;
|
|
c4trans->transFile = 0 ;
|
|
}
|
|
c4trans->enabled = 0 ;
|
|
error4set( c4trans->c4, oldError ) ;
|
|
return rc ;
|
|
#else
|
|
return 0 ;
|
|
#endif /* S4OFF_TRAN */
|
|
#endif /* S4CLIENT */
|
|
#endif
|
|
}
|
|
|
|
#ifdef S4SERVER
|
|
int code4transInit( CODE4TRANS *c4trans, CODE4 *c4 )
|
|
{
|
|
#ifndef S4SERVER
|
|
int rc ;
|
|
#endif
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( c4trans == 0 || c4 == 0 )
|
|
return error4( 0, e4parm_null, E93836 ) ;
|
|
#endif
|
|
|
|
#ifndef S4OFF_TRAN
|
|
#ifndef S4CLIENT
|
|
#ifdef E4ANALYZE
|
|
if ( c4trans->enabled != 0 )
|
|
return error4( 0, e4struct, E93836 ) ;
|
|
#endif
|
|
#endif
|
|
#endif
|
|
|
|
memset( c4trans, 0, sizeof( c4trans ) ) ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( c4->debugInt != E4DEBUG_INT ) /* not initialized */
|
|
return error4( 0, e4struct, E81301 ) ;
|
|
#endif
|
|
c4trans->c4 = c4 ;
|
|
|
|
#ifndef S4SERVER
|
|
rc = code4tranInitLow( &c4trans->trans, c4trans ) ;
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
#ifdef E4ANALYZE
|
|
return code4transVerify( c4trans, 0 ) ;
|
|
#else
|
|
return 0 ;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
#ifndef S4CLIENT
|
|
#ifdef S4SERVER
|
|
/*
|
|
int d4tagUniqueSync( DATA4 *data )
|
|
{
|
|
TAG4 *tag ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( data == 0 )
|
|
return error4( 0, e4parm_null, E96501 ) ;
|
|
#endif
|
|
|
|
for ( tag = 0 ;; )
|
|
{
|
|
tag = d4tagNext( data, tag ) ;
|
|
if ( tag == 0 )
|
|
break ;
|
|
tag->tagFile->uniqueError = tag->uniqueError ;
|
|
}
|
|
|
|
return 0 ;
|
|
}
|
|
*/
|
|
#endif /* S4SERVER */
|
|
|
|
#ifndef S4OFF_MULTI
|
|
#ifndef S4OFF_TRAN
|
|
/* ensure only one process is accessing the transaction file */
|
|
int S4FUNCTION code4tranLockTransactions( CODE4TRANS *c4trans, long lockByte )
|
|
{
|
|
int rc, oldAttempts ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( code4transVerify( c4trans, 1 ) < 0 )
|
|
return 0 ;
|
|
#endif
|
|
|
|
if ( lockByte < TRAN4LOCK_BASE )
|
|
return e4parm ;
|
|
if ( c4trans->transFile->fileLocks & ( 1UL << ( lockByte - TRAN4LOCK_BASE ) ) )
|
|
return 0 ;
|
|
oldAttempts = c4trans->c4->lockAttempts ;
|
|
c4trans->c4->lockAttempts = 1 ;
|
|
rc = file4lock( &c4trans->transFile->file, lockByte, 1L ) ;
|
|
c4trans->c4->lockAttempts = oldAttempts ;
|
|
if ( rc == 0 )
|
|
c4trans->transFile->fileLocks |= ( 1UL << ( lockByte - TRAN4LOCK_BASE ) ) ;
|
|
return rc ;
|
|
}
|
|
|
|
#ifndef S4UTILS
|
|
int S4FUNCTION code4tranUnlockTransactions( CODE4TRANS *c4trans, long lockByte )
|
|
{
|
|
#ifdef E4ANALYZE
|
|
if ( code4transVerify( c4trans, 1 ) < 0 )
|
|
return 0 ;
|
|
#endif
|
|
if ( lockByte < TRAN4LOCK_BASE )
|
|
return e4parm ;
|
|
if ( !(c4trans->transFile->fileLocks & ( 1UL << ( lockByte - TRAN4LOCK_BASE ) ) ) )
|
|
return e4unlock ;
|
|
return file4unlock( &c4trans->transFile->file, lockByte, 1L ) ;
|
|
}
|
|
#endif /* S4UTILS */
|
|
#endif /* S4OFF_TRAN */
|
|
|
|
int tran4lock( TRAN4 *trans )
|
|
{
|
|
LOCK4 *lock, *lockNext ;
|
|
LIST4 locked ;
|
|
int saveErr, rc, saveUnlockAuto ;
|
|
CODE4 *c4 ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( ( rc = tran4verify( trans, 1 ) ) < 0 )
|
|
return rc ;
|
|
#endif
|
|
|
|
c4 = trans->c4trans->c4 ;
|
|
|
|
saveUnlockAuto = code4unlockAuto( c4 ) ;
|
|
|
|
if ( saveUnlockAuto == 1 )
|
|
{
|
|
rc = code4unlockDo( tran4dataList( trans ) ) ;
|
|
if ( rc < 0 )
|
|
return error4stack( c4, rc, 0L ) ;
|
|
}
|
|
|
|
code4unlockAutoSet( c4, 0 ) ;
|
|
|
|
#ifndef S4CLIENT
|
|
memset( &locked, 0, sizeof( locked ) ) ;
|
|
#endif
|
|
|
|
lock = (LOCK4 *)l4first( &trans->locks ) ;
|
|
for ( ;; )
|
|
{
|
|
if ( lock == 0 )
|
|
{
|
|
for ( ;; )
|
|
{
|
|
lock = (LOCK4 *)l4first( &locked ) ;
|
|
if ( lock == 0 )
|
|
{
|
|
code4unlockAutoSet( c4, saveUnlockAuto ) ;
|
|
|
|
#ifdef S4CLIENT
|
|
return saveRc ;
|
|
#else
|
|
return 0 ;
|
|
#endif
|
|
}
|
|
lockNext = (LOCK4 *)l4next( &locked, lock ) ;
|
|
l4remove( &locked, lock ) ;
|
|
mem4free( c4->lockMemory, lock ) ;
|
|
lock = lockNext ;
|
|
}
|
|
}
|
|
|
|
switch( lock4lock( lock ) )
|
|
{
|
|
case r4success:
|
|
lockNext = (LOCK4 *)l4next( &trans->locks, lock ) ;
|
|
l4remove( &trans->locks, lock ) ;
|
|
l4add( &locked, lock ) ;
|
|
lock = lockNext ;
|
|
break ;
|
|
case r4locked:
|
|
lock = (LOCK4 *)l4next( &trans->locks, lock ) ;
|
|
#ifdef S4SERVER
|
|
for ( ;; )
|
|
{
|
|
lock = (LOCK4 *)l4first( &locked ) ;
|
|
if ( lock == 0 )
|
|
return r4locked ;
|
|
l4remove( &locked, lock ) ;
|
|
l4add( &trans->locks, lock ) ;
|
|
lock4unlock( lock ) ;
|
|
}
|
|
#else
|
|
break ;
|
|
#endif
|
|
default:
|
|
saveErr = error4set( trans->c4trans->c4, 0 ) ;
|
|
|
|
for ( ;; )
|
|
{
|
|
lock = (LOCK4 *)l4first( &locked ) ;
|
|
if ( lock == 0 )
|
|
{
|
|
code4unlockAutoSet( c4, saveUnlockAuto ) ;
|
|
error4set( trans->c4trans->c4, saveErr ) ;
|
|
return -1 ;
|
|
}
|
|
|
|
l4remove( &locked, lock ) ;
|
|
l4add( &trans->locks, lock ) ;
|
|
lock4unlock( lock ) ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif /* S4OFF_MULTI */
|
|
#endif /* S4SERVER */
|
|
|
|
#ifndef S4CLIENT
|
|
static DATA4 *tran4dataFull( TRAN4 *trans, const long serverId, const long clientId )
|
|
{
|
|
DATA4 *data ;
|
|
LIST4 *oldList ;
|
|
|
|
data = tran4data( trans, serverId, clientId ) ;
|
|
if ( data != 0 )
|
|
return data ;
|
|
|
|
oldList = tran4dataList( trans ) ;
|
|
tran4dataListSet( trans, &trans->closedDataFiles ) ;
|
|
data = tran4data( trans, serverId, clientId ) ;
|
|
tran4dataListSet( trans, oldList ) ;
|
|
|
|
return data ;
|
|
}
|
|
#endif
|
|
|
|
#ifdef S4SERVER
|
|
/* to get a DATA4 based on id instead of TRAN4 */
|
|
DATA4 *code4idData( CODE4 *c4, const long serverId, const long clientId )
|
|
{
|
|
SERVER4CLIENT *client ;
|
|
DATA4 *data ;
|
|
|
|
for( client = 0 ;; )
|
|
{
|
|
client = (SERVER4CLIENT *)l4next( &c4->server->clients, client ) ;
|
|
if ( client == 0 )
|
|
break ;
|
|
data = tran4data( &client->trans, serverId, clientId ) ;
|
|
if ( data != 0 )
|
|
return data ;
|
|
}
|
|
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
|
|
#ifndef S4CLIENT
|
|
#ifdef P4ARGS_USED
|
|
#pragma argsused
|
|
#endif
|
|
/* are there any active transactions which conflict with the data4? */
|
|
int tran4active( CODE4 *c4, DATA4 *data )
|
|
{
|
|
#ifndef S4OFF_TRAN
|
|
#ifndef S4STAND_ALONE
|
|
SERVER4CLIENT *client ;
|
|
DATA4 *dataLoop ;
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef S4OFF_TRAN
|
|
if ( code4transEnabled( c4 ) )
|
|
if ( code4trans( c4 )->currentTranStatus == r4active )
|
|
return e4transViolation ;
|
|
|
|
#ifdef S4STAND_ALONE
|
|
if ( data->logVal == LOG4TRANS ) /* not logging this datafile, and not a transaction in progress... */
|
|
return 0 ;
|
|
#endif
|
|
|
|
#ifdef S4SERVER
|
|
if ( data->accessMode != OPEN4DENY_NONE ) /* if denying others write access, then can proceed */
|
|
return 0 ;
|
|
#endif
|
|
#ifdef S4OFF_MULTI
|
|
return 0 ;
|
|
#else
|
|
#ifdef S4STAND_ALONE
|
|
if ( d4lockTestFile( data ) == 1 )
|
|
return 0 ;
|
|
if ( data->dataFile->file.lowAccessMode != OPEN4DENY_NONE )
|
|
return 0 ;
|
|
/* in stand-alone, can't check active transactions, so just deny */
|
|
return error4( c4, e4transViolation, E81504 ) ;
|
|
#else
|
|
if ( dfile4lockTestFile( data->dataFile, data4clientId( data ), data4serverId( data ) ) == 1 )
|
|
return 0 ;
|
|
/* if file not ultimately opened exclusively, may be problems */
|
|
if ( data->dataFile->file.lowAccessMode == OPEN4DENY_NONE )
|
|
return error4( c4, e4transViolation, E81504 ) ;
|
|
for ( client = 0 ;; )
|
|
{
|
|
client = (SERVER4CLIENT *)l4next( &c4->server->clients, client ) ;
|
|
if ( client == 0 )
|
|
break ;
|
|
if ( client->trans.c4trans->enabled )
|
|
if ( client->trans.currentTranStatus == r4active )
|
|
{
|
|
/* check if that user has a data4 using the same datafile */
|
|
for( dataLoop = 0 ;; )
|
|
{
|
|
dataLoop = (DATA4 *)l4next( client->trans.dataList, dataLoop ) ;
|
|
if ( dataLoop == 0 )
|
|
break ;
|
|
if ( dataLoop->readOnly == 0 )
|
|
if ( dataLoop->dataFile == data->dataFile )
|
|
return error4( c4, e4transViolation, E81504 ) ;
|
|
}
|
|
}
|
|
}
|
|
return 0 ;
|
|
#endif
|
|
#endif
|
|
#else
|
|
return 0 ;
|
|
#endif /* S4OFF_TRAN */
|
|
}
|
|
#endif
|
|
|
|
#ifdef P4ARGS_USED
|
|
#pragma argsused
|
|
#endif
|
|
void S4FUNCTION code4lockClear( CODE4 *c4 )
|
|
{
|
|
#ifndef S4OFF_MULTI
|
|
LOCK4 *lock ;
|
|
TRAN4 *trans ;
|
|
|
|
#ifdef E4PARM_HIGH
|
|
if ( c4 == 0 )
|
|
{
|
|
error4( 0, e4parm_null, E91018 ) ;
|
|
return ;
|
|
}
|
|
#endif
|
|
|
|
#ifdef S4SERVER
|
|
trans = &c4->currentClient->trans ;
|
|
#else
|
|
trans = &c4->c4trans.trans ;
|
|
#endif
|
|
|
|
for ( ;; )
|
|
{
|
|
lock = (LOCK4 *)l4first( &trans->locks ) ;
|
|
if ( lock == 0 )
|
|
break ;
|
|
l4remove( &trans->locks, lock ) ;
|
|
mem4free( c4->lockMemory, lock ) ;
|
|
}
|
|
#endif /* S4OFF_MULTI */
|
|
return ;
|
|
}
|