ssize_t
__pwrite (int fd, const void *buf, size_t nbyte, off_t offset)
{
/* Since we must not change the file pointer preserve the value so that
we can restore it later. */
int save_errno;
ssize_t result;
off_t old_offset = __lseek (fd, 0, SEEK_CUR);
if (old_offset == (off_t) -1)
return -1;
/* Set to wanted position. */
if (__lseek (fd, offset, SEEK_SET) == (off_t) -1)
return -1;
/* Write out the data. */
result = __write (fd, buf, nbyte);
/* Now we have to restore the position. If this fails we have to
return this as an error. But if the writing also failed we
return this error. */
save_errno = errno;
if (__lseek (fd, old_offset, SEEK_SET) == (off_t) -1)
{
if (result == -1)
__set_errno (save_errno);
return -1;
}
__set_errno (save_errno);
return result;
}
_WCRTLINK int chsize( int hid, long size )
{
long curOffset;
long rc;
__file_handle *fh;
__handle_check( hid, -1 );
fh = (__file_handle*) __getOSHandle( hid );
_AccessFileH( hid );
curOffset = __lseek( hid, 0L, SEEK_CUR ); /* get current offset */
rc = set_file_size(fh->name, size);
if(rc !=0 )
{
_ReleaseFileH( hid );
if(rc==8)
__set_errno( ENOSPC );
else
__set_errno( EACCES );
return -1;
};
if( curOffset > size ) curOffset = size;
curOffset = __lseek( hid, curOffset, SEEK_SET );
_ReleaseFileH( hid );
if( curOffset == -1 ) {
__set_errno(ENOSPC);
return( -1 );
}
return( 0 );
}
_WCRTLINK int chsize( int handle, long size )
{
long curOffset, endOffset;
char buf[512];
long diff;
unsigned amount;
int retCode;
__handle_check( handle, -1 );
/*** Prepare to change the size ***/
_AccessFileH( handle );
curOffset = __lseek( handle, 0L, SEEK_CUR ); /* get current offset */
if( curOffset == -1 ) {
_ReleaseFileH( handle );
return( -1 );
}
endOffset = __lseek( handle, 0L, SEEK_END ); /* get file size */
if( endOffset == -1 ) {
_ReleaseFileH( handle );
return( -1 );
}
if( size > endOffset ) {
/*** Increase file size ***/
diff = size - endOffset; /* number of bytes to pad */
memset( buf, 0, 512 ); /* zero buffer */
do {
if( diff >= 512 ) {
amount = 512;
} else {
amount = (unsigned)diff;
}
retCode = write( handle, buf, amount );
if( retCode != amount ) {
__set_errno( ENOSPC );
retCode = -1;
break;
}
diff -= amount;
} while( diff != 0 );
if( retCode != -1 ) retCode = 0;
} else {
/*** Shrink file ***/
retCode = DosNewSize( handle, size );
if( retCode != 0 ) {
__set_errno_dos( retCode );
retCode = -1;
}
if( curOffset > size ) curOffset = size;
}
/*** Clean up and go home ***/
curOffset = __lseek( handle, curOffset, SEEK_SET );
if( curOffset == -1 ) retCode = -1;
_ReleaseFileH( handle );
return( retCode );
}
void rewind(FILE* f)
{
fflush(f);
if (f->flags & _IORWOK)
f->flags &= ~(_IORD | _IOWR); // last operation for read-write files is neither
f->flags &= ~(_IOUNGOT | _IOERR | _IOEOF); // ungetc()'s changes are gone
f->ptr = f->buf;
f->cnt = 0; // force entrance into __fillbuf()/__flushbuf() on the next read/write
// "a+" mode isn't supported now because DOS doesn't support opening files in append mode directly.
// "a" should ignore seek requests since it's always appending data at file's end and never reading anything.
if (f->flags & _IOAPPEND)
return;
#ifdef __SMALLER_C_16__
{
fpos_t pos;
pos.halves[1] = pos.halves[0] = 0;
__lseek(f->fd, &pos, SEEK_SET);
}
#else
lseek(f->fd, 0, SEEK_SET);
#endif
}
int __ftell(FILE* f, fpos_t* pos)
{
if (__lseek(f->fd, pos, SEEK_CUR))
{
// errno = EUNKNOWN;
return -1;
}
if (f->flags & _IORD) // read-only file or last was read
{
// underlying file's current position is after the last byte of data read,
// so, there's f->cnt bytes from C file's position to underlying file's position
// pos -= f->cnt;
fpos_t t;
__lngFromUnsigned(&t, f->cnt);
__lngSub(pos, &t);
}
else if ((f->flags & _IOWR) && f->ptr != f->buf) // write-only file or last was write; there was no flush
{
// underlying file's current position is at the beginning of the buffer with unwritten data,
// so, there's f->ptr - f->buf from underlying file's position to C file's position
// pos += f->ptr - f->buf;
fpos_t t;
__lngFromUnsigned(&t, f->ptr - f->buf);
__lngAdd(pos, &t);
}
return 0;
}
ut64 dbg_lseek(int fildes, ut64 offset, int whence)
{
if (old_lseek == offset && whence == SEEK_SET)
return old_lseek;
if (ps.opened && ps.fd == fildes)
switch(whence) {
case SEEK_SET:
old_lseek = offset;
ps.offset = offset;
return ps.offset;
case SEEK_CUR:
ps.offset = (ut64)((unsigned long long)ps.offset+(unsigned long long)offset);
return ps.offset;
case SEEK_END:
#if __x86_64__
return ps.offset = (ut64)((unsigned long long)(-1));
#else
return ps.offset = 0xffffffff;
#endif
default:
return (ut64)(unsigned long long)-1;
}
return __lseek(fildes, offset, whence);
}
ssize_t
GETDIRENTRIES (int fd, char *buf, size_t nbytes, off_t *basep)
{
off_t base = __lseek (fd, (off_t) 0, SEEK_CUR);
ssize_t result;
result = __GETDENTS (fd, buf, nbytes);
if (result != -1)
*basep = base;
return result;
}
int _lseek ()
{
int fd = -1;
int position = -1;
if (!out[1]) // still need both arguments
{
printf("Missing file descriptor. (Usage: lseek fd position)\n");
return -1;
}
if (!out[2]) // still need position argument
{
printf("Missing second argument. (Usage: lseek fd position)\n");
return -2;
}
if (strcmp(out[1], "0") == 0) // atoi cannot convert string "0" to int 0
{
fd = 0;
}
else
{
fd = atoi(out[1]);
if (fd == 0)
{
printf("\"%s\" : not an integer value. (Valid: 0-%d)\n", out[1], NFD - 1);
return -3;
}
if (fd >= NFD)
{
printf("\"%d\" : Not within specified range. (Valid: 0-%d)", fd, NFD - 1);
return -4;
}
}
if (strcmp(out[2], "0") == 0) // atoi cannot convert string "0" to int 0
{
position = 0;
}
else
{
position = atoi(out[2]);
if (position == 0)
{
printf("\"%s\" : not an integer value.\n", out[2]);
return -5;
}
}
return __lseek(fd, position);
}
/* FIXME: This is not what this function does. It starts reading at the
current position of FD, not at *BASEP. */
ssize_t
GETDIRENTRIES (int fd, char *buf, size_t nbytes, OFF_T *basep)
{
OFF_T base = 0;
ssize_t result;
if (basep)
base = __lseek (fd, (off_t) 0, SEEK_CUR);
result = __syscall_getdents (fd, buf, nbytes);
if (basep && result >= 0)
*basep = base;
return result;
}
_WCRTLINK off_t lseek( int handle, off_t offset, int origin )
{
#if !defined( __LINUX__ )
unsigned iomode_flags;
__handle_check( handle, -1 );
/*** Set the _FILEEXT iomode_flags bit if positive offset ***/
iomode_flags = __GetIOMode( handle );
if( offset > 0 && !(iomode_flags & _APPEND) )
__SetIOMode_nogrow( handle, iomode_flags | _FILEEXT );
#endif
return( __lseek( handle, offset, origin ) );
}
int __doclose( FILE *fp, int close_handle )
{
int ret;
if( (fp->_flag & (_READ | _WRITE)) == 0 ) {
return( -1 ); /* file already closed */
}
ret = 0;
if( fp->_flag & _DIRTY ) {
if( __flush( fp ) ) {
ret = -1;
}
}
_AccessFile( fp );
/*
* 02-nov-92 G.Turcotte Syncronize buffer pointer with the file pointer
* IEEE Std 1003.1-1988 B.8.2.3.2
* 03-nov-03 B.Oldeman Inlined ftell; we already know the buffer isn't
* dirty (because of the flush), so only a "get" applies
*/
if( fp->_cnt != 0 ) { /* if something in buffer */
__lseek( fileno( fp ), -fp->_cnt, SEEK_CUR );
}
if( close_handle ) {
#if defined( __UNIX__ ) || defined( __NETWARE__ ) || defined( __RDOS__ ) || defined( __RDOSDEV__ )
// we don't get to implement the close function on these systems
ret |= close( fileno( fp ) );
#else
ret |= __close( fileno( fp ) );
#endif
}
if( fp->_flag & _BIGBUF ) { /* if we allocated the buffer */
lib_free( _FP_BASE( fp ) );
_FP_BASE( fp ) = NULL;
}
#ifndef __UNIX__
/* this never happens under UNIX */
if( fp->_flag & _TMPFIL ) { /* if this is a temporary file */
__RmTmpFileFn( fp );
}
#endif
fp->_flag &= _DYNAMIC;
_ReleaseFile( fp );
return( ret );
}
int __doclose( FILE *fp, int close_handle )
{
int ret;
if( fp->_flag == 0 ) {
return( -1 ); /* file already closed */
}
ret = 0;
if( fp->_flag & _DIRTY ) {
ret = __flush( fp );
}
_AccessFile( fp );
if( fp->_cnt != 0 ) { /* if something in buffer */
__lseek( fileno( fp ), -fp->_cnt, SEEK_CUR );
}
if( close_handle ) {
#if defined(__UNIX__) || defined(__NETWARE__)
// we don't get to implement the close function on these systems
ret |= close( fileno( fp ) );
#else
ret |= __close( fileno( fp ) );
#endif
}
if( fp->_flag & _BIGBUF ) { /* if we allocated the buffer */
lib_free( _FP_BASE(fp) );
_FP_BASE(fp) = NULL;
}
#ifndef __UNIX__
/* this never happens under UNIX */
if( fp->_flag & _TMPFIL ) { /* if this is a temporary file */
__RmTmpFileFn( fp );
}
#endif
_ReleaseFile( fp );
return( ret );
}
int
gdbm_store (GDBM_FILE dbf, datum key, datum content, int flags)
{
int new_hash_val; /* The new hash value. */
int elem_loc; /* The location in hash bucket. */
off_t file_adr; /* The address of new space in the file. */
off_t file_pos; /* The position after a lseek. */
off_t free_adr; /* For keeping track of a freed section. */
int free_size;
int new_size; /* Used in allocating space. */
char *temp; /* Used in _gdbm_findkey call. */
int rc;
/* First check to make sure this guy is a writer. */
if (dbf->read_write == GDBM_READER)
{
gdbm_errno = GDBM_READER_CANT_STORE;
return -1;
}
/* Check for illegal data values. A NULL dptr field is illegal because
NULL dptr returned by a lookup procedure indicates an error. */
if ((key.dptr == NULL) || (content.dptr == NULL))
{
gdbm_errno = GDBM_ILLEGAL_DATA;
return -1;
}
/* Initialize the gdbm_errno variable. */
gdbm_errno = GDBM_NO_ERROR;
/* Look for the key in the file.
A side effect loads the correct bucket and calculates the hash value. */
elem_loc = _gdbm_findkey (dbf, key, &temp, &new_hash_val);
/* Initialize these. */
file_adr = 0;
new_size = key.dsize + content.dsize;
/* Did we find the item? */
if (elem_loc != -1)
{
if (flags == GDBM_REPLACE)
{
/* Just replace the data. */
free_adr = dbf->bucket->h_table[elem_loc].data_pointer;
free_size = dbf->bucket->h_table[elem_loc].key_size
+ dbf->bucket->h_table[elem_loc].data_size;
if (free_size != new_size)
{
_gdbm_free (dbf, free_adr, free_size);
}
else
{
/* Just reuse the same address! */
file_adr = free_adr;
}
}
else
{
gdbm_errno = GDBM_CANNOT_REPLACE;
return 1;
}
}
/* Get the file address for the new space.
(Current bucket's free space is first place to look.) */
if (file_adr == 0)
file_adr = _gdbm_alloc (dbf, new_size);
/* If this is a new entry in the bucket, we need to do special things. */
if (elem_loc == -1)
{
if (dbf->bucket->count == dbf->header->bucket_elems)
{
/* Split the current bucket. */
_gdbm_split_bucket (dbf, new_hash_val);
}
/* Find space to insert into bucket and set elem_loc to that place. */
elem_loc = new_hash_val % dbf->header->bucket_elems;
while (dbf->bucket->h_table[elem_loc].hash_value != -1)
elem_loc = (elem_loc + 1) % dbf->header->bucket_elems;
/* We now have another element in the bucket. Add the new information.*/
dbf->bucket->count++;
dbf->bucket->h_table[elem_loc].hash_value = new_hash_val;
memcpy (dbf->bucket->h_table[elem_loc].key_start, key.dptr,
(SMALL < key.dsize ? SMALL : key.dsize));
}
/* Update current bucket data pointer and sizes. */
dbf->bucket->h_table[elem_loc].data_pointer = file_adr;
dbf->bucket->h_table[elem_loc].key_size = key.dsize;
dbf->bucket->h_table[elem_loc].data_size = content.dsize;
/* Write the data to the file. */
file_pos = __lseek (dbf, file_adr, SEEK_SET);
if (file_pos != file_adr)
_gdbm_fatal (dbf, _("lseek error"));
rc = _gdbm_full_write (dbf, key.dptr, key.dsize);
if (rc)
_gdbm_fatal (dbf, gdbm_strerror (rc));
rc = _gdbm_full_write (dbf, content.dptr, content.dsize);
if (rc)
_gdbm_fatal (dbf, gdbm_strerror (rc));
/* Current bucket has changed. */
dbf->cache_entry->ca_changed = TRUE;
dbf->bucket_changed = TRUE;
/* Write everything that is needed to the disk. */
_gdbm_end_update (dbf);
return 0;
}
_WCRTLINK int read( int handle, void *buf, unsigned len )
#endif
{
unsigned read_len, total_len;
unsigned reduce_idx, finish_idx;
unsigned iomode_flags;
char *buffer = buf;
#if defined(__NT__)
DWORD amount_read;
BOOL rc;
HANDLE h;
#elif defined(__WARP__)
ULONG amount_read;
#elif defined(__OS2_286__)
USHORT amount_read;
#else
unsigned amount_read;
#endif
#if !defined(__NT__)
tiny_ret_t rc;
#endif
#ifdef DEFAULT_WINDOWING
LPWDATA res;
#endif
__handle_check( handle, -1 );
__ChkTTYIOMode( handle );
iomode_flags = __GetIOMode( handle );
if( iomode_flags == 0 ) {
#if defined( __WINDOWS__ ) || defined( __WINDOWS_386__ )
return( _lread( handle, buffer, len ) );
#else
_RWD_errno = EBADF;
return( -1 );
#endif
}
if( !(iomode_flags & _READ) ) {
_RWD_errno = EACCES; /* changed from EBADF to EACCES 23-feb-89 */
return( -1 );
}
#ifdef __NT__
h = __getOSHandle( handle );
#endif
if( iomode_flags & _BINARY ) { /* if binary mode */
#ifdef DEFAULT_WINDOWING
if( _WindowsStdin != 0 &&
(res = _WindowsIsWindowedHandle( handle )) != 0 ) {
total_len = _WindowsStdin( res, buffer, len );
rc = 0;
} else
#endif
{
#if defined(__NT__)
rc = ReadFile( h, buffer, len, &amount_read, NULL );
total_len = amount_read;
if( !rc ) {
if (GetLastError() == ERROR_BROKEN_PIPE)
return total_len;
return( __set_errno_nt() );
}
#elif defined( __OS2__ )
rc = DosRead( handle, buffer, len, &amount_read );
total_len = amount_read;
#else
rc = TinyRead( handle, buffer, len );
total_len = TINY_LINFO( rc );
#endif
}
#if !defined(__NT__)
if( TINY_ERROR( rc ) ) {
return( __set_errno_dos( TINY_INFO( rc ) ) );
}
#endif
} else {
_AccessFileH( handle );
total_len = 0;
read_len = len;
do {
#ifdef DEFAULT_WINDOWING
if( _WindowsStdin != 0 &&
(res = _WindowsIsWindowedHandle( handle )) != 0L ) {
amount_read = _WindowsStdin( res, buffer, read_len );
rc = 0;
} else
#endif
{
#if defined(__NT__)
rc = ReadFile( h, buffer, read_len, &amount_read, NULL );
if( !rc ) {
_ReleaseFileH( handle );
if( GetLastError() == ERROR_BROKEN_PIPE )
return total_len;
return( __set_errno_nt() );
}
#elif defined( __OS2__ )
rc = DosRead( handle, buffer, read_len, &amount_read );
#else
rc = TinyRead( handle, buffer, read_len );
amount_read = TINY_LINFO( rc );
#endif
}
#if !defined(__NT__)
if( TINY_ERROR( rc ) ) {
_ReleaseFileH( handle );
return( __set_errno_dos( TINY_INFO( rc ) ) );
}
#endif
if( amount_read == 0 ) { /* EOF */
break;
}
reduce_idx = 0;
finish_idx = reduce_idx;
for( ; reduce_idx < amount_read; ++reduce_idx ) {
if( buffer[ reduce_idx ] == 0x1a ) { /* EOF */
__lseek( handle,
((long)reduce_idx - (long)amount_read)+1L,
SEEK_CUR );
total_len += finish_idx;
_ReleaseFileH( handle );
return( total_len );
}
if( buffer[ reduce_idx ] != '\r' ) {
buffer[ finish_idx++ ] = buffer[ reduce_idx ];
}
}
total_len += finish_idx;
buffer += finish_idx;
read_len -= finish_idx;
if( iomode_flags & _ISTTY ) {
break; /* 04-feb-88, FWC */
}
} while( read_len != 0 );
_ReleaseFileH( handle );
}
return( total_len );
}
int
__write(int fd, const void *buffer, unsigned int length)
{
struct UFB *ufb;
int count, totcount;
char *ptr;
/*
* Check for the break signals
*/
__chkabort();
/*
* find the ufb *
*/
if ((ufb = __chkufb(fd)) == NULL) {
errno = EINVAL;
return -1;
}
/*
* Check if write is allowed
*/
if (!(ufb->ufbflg & UFB_WA)) {
_OSERR = ERROR_WRITE_PROTECTED;
errno = EIO;
return -1;
}
/*
* Seek to end of the file if necessary
*/
if (ufb->ufbflg & UFB_APP)
__lseek(fd, 0, 2);
/*
* Check if translation is not needed
*/
if (!(ufb->ufbflg & UFB_XLAT) ||
(ptr = memchr(buffer, 0x0A, length)) == NULL) {
if (ufb->ufbflg & UFB_SOCK) {
if ((count = send(fd, (char *)buffer, length, 0)) < 0)
return -1;
}
else {
if ((count = Write(ufb->ufbfh, (void *)buffer, length)) == -1)
goto osfail;
}
return count;
}
totcount = length;
/*
* Translate, ie., append CR before each LF
*/
do {
count = ptr - (char *)buffer;
if (ufb->ufbflg & UFB_SOCK) {
if (send(fd, (char *)buffer, count, 0) < 0)
return -1;
if (send(fd, "\015"/* CR */, 1, 0) < 0)
return -1;
}
else {
if (Write(ufb->ufbfh, (void *)buffer, count) == -1)
goto osfail;
if (Write(ufb->ufbfh, "\015"/* CR */, 1) == -1)
goto osfail;
}
length -= count;
buffer = ptr;
} while ((ptr = memchr((char *)buffer + 1, 0x0A, length)) != NULL);
if (ufb->ufbflg & UFB_SOCK) {
if ((count = send(fd, (char *)buffer, length, 0)) < 0)
return -1;
}
else {
if (Write(ufb->ufbfh, (void *)buffer, length) == -1)
goto osfail;
}
return totcount;
osfail:
errno = __io2errno(_OSERR = IoErr());
return -1;
}
_WCRTLINK int read( int handle, void *buf, unsigned len )
{
unsigned read_len, total_len;
unsigned reduce_idx, finish_idx;
unsigned iomode_flags;
char *buffer = buf;
BOOL rc;
HANDLE h;
unsigned amount_read;
int err;
__file_handle *fh;
__handle_check( handle, -1 );
__ChkTTYIOMode( handle );
iomode_flags = __GetIOMode( handle );
if( iomode_flags == 0 )
{
__set_errno( EBADF );
return( -1 );
}
if( !(iomode_flags & _READ) )
{
__set_errno( EACCES ); /* changed from EBADF to EACCES 23-feb-89 */
return( -1 );
}
fh = (__file_handle*) __getOSHandle( handle );
if( iomode_flags & _BINARY ) /* if binary mode */
{
err=read_file(fh->name,buffer,fh->offset,len,&amount_read);
fh->offset+=amount_read;
total_len = amount_read;
if(err)
if ( amount_read == 0)
return (-1);
}
else
{
total_len = 0;
read_len = len;
do
{
err=read_file(fh->name,buffer,fh->offset,len,&amount_read);
fh->offset+=amount_read;
if( amount_read == 0 )
break; /* EOF */
reduce_idx = 0;
finish_idx = reduce_idx;
for( ; reduce_idx < amount_read; ++reduce_idx )
{
if( buffer[ reduce_idx ] == 0x1a ) /* EOF */
{
__lseek( handle,
((long)reduce_idx - (long)amount_read)+1L,
SEEK_CUR );
total_len += finish_idx;
return( total_len );
}
if( buffer[ reduce_idx ] != '\r' )
{
buffer[ finish_idx++ ] = buffer[ reduce_idx ];
};
}
total_len += finish_idx;
buffer += finish_idx;
read_len -= finish_idx;
if( iomode_flags & _ISTTY )
{
break; /* 04-feb-88, FWC */
}
} while( read_len != 0 );
}
return( total_len );
}
_WCRTLINK __int64 __lseeki64( int handle, __int64 offset, int origin )
{
#if defined( __NT__ ) || defined( __OS2__ ) || defined( __LINUX__ )
__int64 pos;
__handle_check( handle, -1 );
#if defined( __OS2__ )
{
#if !defined( _M_I86 )
APIRET rc;
if( __os2_DosSetFilePtrL != NULL ) {
rc = __os2_DosSetFilePtrL( handle, offset, origin, &pos );
if( rc != 0 ) {
return( __set_errno_dos( rc ) );
}
} else {
#endif
if( offset > LONG_MAX || offset < LONG_MIN ) {
__set_errno( EINVAL );
return( -1LL );
}
pos = (unsigned long)__lseek( handle, offset, origin );
if( pos == INVALID_SET_FILE_POINTER ) {
pos = -1LL;
}
#if !defined( _M_I86 )
}
#endif
}
#elif defined( __NT__ )
{
DWORD rc;
LONG offset_hi;
int error;
offset_hi = HIDWORD( offset );
rc = SetFilePointer( __getOSHandle( handle ), LODWORD( offset ), &offset_hi, origin );
if( rc == INVALID_SET_FILE_POINTER ) { // this might be OK so
error = GetLastError(); // check for sure JBS 04-nov-99
if( error != NO_ERROR ) {
return( __set_errno_dos( error ) );
}
}
U64Set( (unsigned_64 *)&pos, rc, offset_hi );
}
#elif defined( __LINUX__ )
if( _llseek( handle, LODWORD( offset ), HIDWORD( offset ), &pos, origin ) ) {
pos = -1LL;
}
#endif
return( pos );
#else
long pos;
if( offset > LONG_MAX || offset < LONG_MIN ) {
__set_errno( EINVAL );
return( -1LL );
}
pos = __lseek( handle, offset, origin );
if( pos == INVALID_SET_FILE_POINTER ) {
return( -1LL );
}
return( (unsigned long)pos );
#endif
}
static int zero_pad( int handle ) /* 09-jan-95 */
/*******************************/
{
#if defined(__NT__)
HANDLE h;
DWORD dw_ptr;
DWORD dw_error;
DWORD number_of_bytes_written;
unsigned write_amt;
__i64 cur_ptr;
__i64 end_ptr;
BOOL rc;
char zeroBuf[PAD_SIZE];
h = __getOSHandle( handle );
dw_error = NO_ERROR;
cur_ptr._64 = 0;
dw_ptr = SetFilePointer( h, cur_ptr._32[0], &cur_ptr._32[1], FILE_CURRENT );
if( dw_ptr == INVALID_SET_FILE_POINTER ) { // this might be OK so
dw_error = GetLastError() ;
}
if( dw_error != NO_ERROR )
return( -1 );
cur_ptr._32[0] = dw_ptr;
end_ptr._64 = 0;
dw_ptr = SetFilePointer( h, end_ptr._32[0], &end_ptr._32[1], FILE_END );
if( dw_ptr == INVALID_SET_FILE_POINTER ) { // this might be OK so
dw_error = GetLastError() ;
}
if( dw_error != NO_ERROR )
return( -1 );
end_ptr._32[0] = dw_ptr;
memset( zeroBuf, 0x00, PAD_SIZE );
while( end_ptr._64 < cur_ptr._64 ) {
if( (end_ptr._64 + PAD_SIZE) < cur_ptr._64 ) {
write_amt = PAD_SIZE;
} else {
write_amt = cur_ptr._64 - end_ptr._64;
}
rc = WriteFile( h, zeroBuf, write_amt, &number_of_bytes_written, NULL );
dw_error = GetLastError() ;
if( rc == 0 )
return( -1 );
end_ptr._64 = end_ptr._64 + write_amt;
}
if( cur_ptr._64 != end_ptr._64 ) {
dw_ptr = SetFilePointer( h, cur_ptr._32[0], &cur_ptr._32[1], FILE_BEGIN );
if( dw_ptr == INVALID_SET_FILE_POINTER ) { // this might be OK so
dw_error = GetLastError() ;
}
if( dw_error != NO_ERROR ) {
return( -1 );
}
}
return( 0 );
#else
int rc;
long curPos, eodPos;
long bytesToWrite;
unsigned writeAmt;
char zeroBuf[PAD_SIZE];
// Pad with zeros due to lseek() past EOF (POSIX)
curPos = __lseek( handle, 0L, SEEK_CUR ); /* current offset */
if( curPos == -1 )
return( -1 );
eodPos = __lseek( handle, 0L, SEEK_END ); /* end of data offset */
if( eodPos == -1 )
return( -1 );
if( curPos > eodPos ) {
bytesToWrite = curPos - eodPos; /* amount to pad by */
if( bytesToWrite > 0 ) { /* only write if needed */
memset( zeroBuf, 0x00, PAD_SIZE ); /* zero out a buffer */
do { /* loop until done */
if( bytesToWrite > PAD_SIZE )
writeAmt = 512;
else
writeAmt = (unsigned)bytesToWrite;
rc = write( handle, zeroBuf, writeAmt );
if( rc < 0 )
return( rc );
bytesToWrite -= writeAmt; /* more bytes written */
} while( bytesToWrite != 0 );
}
} else {
curPos = __lseek( handle, curPos, SEEK_SET );
if( curPos == -1 ) {
return( -1 );
}
}
return( 0 ); /* return success code */
#endif
}
long _RTLENTRY _EXPFUNC tell(int handle)
{
return (__lseek (handle, 0L, SEEK_CUR));
}