VOID TimeIt()
{
TIMESTAMP tsStart, tsStop;
ULONG ulRC, ulMsecs, ulNsecs, ulBytes;
printf( "\nHit Ctrl-C to terminate this test program...\n" );
for( ; ; )
{
printf( "\nSleeping for %u milliseconds...", ulTimePeriod );
fflush( stdout );
ulRC = DosRead( hfTimer, &tsStart, sizeof( TIMESTAMP ), &ulBytes );
if( ulRC )
{
printf( "\nDosRead for start got a retcode of %u", ulRC );
return;
}
DosSleep( ulTimePeriod );
ulRC = DosRead( hfTimer, &tsStop, sizeof( TIMESTAMP ), &ulBytes );
if( ulRC )
{
printf( "\nDosRead for stop got a retcode of %u", ulRC );
return;
}
ulMsecs = CalcElapsedTime( &tsStart, &tsStop,
ulOverheadMs, ulOverheadNs, &ulNsecs );
printf( " elapsed time (ms:ns) = %06u:%06u", ulMsecs, ulNsecs );
}
}
BOOL ReadData( HFILE handle )
{
BOOL ret = FALSE;
char * p1;
int dif;
char crc[2];
ULONG bytesread;
ULONG actual;
DosRead( handle, tmpbuf, BUFSIZE, &bytesread );
if ( bytesread )
{
if (p1=memchr( tmpbuf, EOFFLAG, bytesread ) )
{
dif = bytesread - (int)(p1-tmpbuf);
bytesread -= dif;
if (dif < 3)
{
DosRead( handle, crc+dif, 3-dif, &bytesread );
if (dif==1)
crc[0] = *(p1+1);
rc = *(unsigned int *)crc;
}
else
rc = *(unsigned int *)(p1+1);
ret = TRUE;
} /* endif */
DosWrite( 1, tmpbuf, bytesread, &actual );
}
return( ret );
}
int main(void)
{
APIRET apiret;
HPIPE hpipe;
PSZ pipeName = "\\pipe\\testpipe";
PSZ semName = "\\sem32\\pipesem";
HEV hev;
CHAR objname[50];
RESULTCODES rc;
ULONG bytesread;
CHAR buf[50];
printf(__FILE__ " main function invoked\n");
printf("Test named pipe functions\n");
apiret = DosCreateNPipe(pipeName, &hpipe, 0, NP_WAIT, 0, 0, 0);
printf("DosCreateNPipe function returned %d\n", (int)apiret);
apiret = DosCreateEventSem(semName, &hev, DC_SEM_SHARED, FALSE);
printf("DosCreateEventSem function returned %d\n", (int)apiret);
apiret = DosExecPgm(objname, 50, EXEC_ASYNC, NULL, NULL, &rc, "./test11a");
printf("DosExecPgm function returned %d\n", (int)apiret);
apiret = DosWaitEventSem(hev, 5000);
printf("DosWaitEventSem function returned %d\n", (int)apiret);
apiret = DosRead((HFILE)hpipe, buf, sizeof(buf) - 1, &bytesread);
printf("DosRead function returned %d\n", (int)apiret);
buf[bytesread] = '\0';
printf("Message was \"%s\"\n", buf);
apiret = DosWaitEventSem(hev, 5000);
printf("DosWaitEventSem function returned %d\n", (int)apiret);
apiret = DosRead((HFILE)hpipe, buf, sizeof(buf) - 1, &bytesread);
printf("DosRead function returned %d\n", (int)apiret);
buf[bytesread] = '\0';
printf("Message was \"%s\"\n", buf);
apiret = DosWaitEventSem(hev, 5000);
printf("DosWaitEventSem function returned %d\n", (int)apiret);
apiret = DosRead((HFILE)hpipe, buf, sizeof(buf) - 1, &bytesread);
printf("DosRead function returned %d\n", (int)apiret);
buf[bytesread] = '\0';
printf("Message was \"%s\"\n", buf);
/* wait for test11a to catch up with us */
DosSleep(2000);
apiret = DosCloseEventSem(hev);
printf("DosCloseEventSem function returned %d\n", (int)apiret);
apiret = DosClose((HFILE)hpipe);
printf("DosClose function returned %d\n", (int)apiret);
return 0;
}
int SERIAL_getextchar(COMPORT port) {
ULONG dwRead = 0; // Number of chars read
char chRead;
int retval = 0;
// receive a byte; TODO communicate failure
if (DosRead(port->porthandle, &chRead, 1, &dwRead) == NO_ERROR) {
if (dwRead) {
// check for errors; will OS/2 clear the error on reading its data?
// if yes then this is in wrong order
USHORT errors = 0, event = 0;
ULONG ulParmLen = sizeof(errors);
DosDevIOCtl(port->porthandle, IOCTL_ASYNC, ASYNC_GETCOMMEVENT,
0, 0, 0, &event, ulParmLen, &ulParmLen);
if (event & (64 + 128) ) { // Break (Bit 6) or Frame or Parity (Bit 7) error
Bit8u errreg = 0;
if (event & 64) retval |= SERIAL_BREAK_ERR;
if (event & 128) {
DosDevIOCtl(port->porthandle, IOCTL_ASYNC, ASYNC_GETCOMMERROR,
0, 0, 0, &errors, ulParmLen, &ulParmLen);
if (errors & 8) retval |= SERIAL_FRAMING_ERR;
if (errors & 4) retval |= SERIAL_PARITY_ERR;
}
}
retval |= (chRead & 0xff);
retval |= 0x10000;
}
}
return retval;
}
VOID APIENTRY Thread(VOID)
{
APIRET rc;
ULONG ulNumBytes;
TRACE_EVENT te;
printf("Thread() started\n");
rc = DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, 0);
if (rc) {
printf("Thread() DosSetPriority failed with RC = %lu\n", rc);
return;
}
fRunning = TRUE;
while (!fQuit) {
rc = DosRead(hfile, &te, sizeof(TRACE_EVENT), &ulNumBytes);
if (rc) {
printf("Error %d while calling device driver\n", rc);
return;
}
ShowTrace(te);
}
printf("Thread() stopped\n");
fRunning = FALSE;
}
/****************************************************************************
REMARKS:
VDD implementation of the ANSI C fread function. Note that unlike Windows VxDs,
OS/2 VDDs are not limited to 64K reads or writes.
****************************************************************************/
size_t fread(
void *ptr,
size_t size,
size_t n,
FILE *f)
{
char *buf = ptr;
int bytes,readbytes,totalbytes = 0;
/* First copy any data already read into our buffer */
if ((bytes = (f->curp - f->startp)) > 0) {
memcpy(buf,f->curp,bytes);
f->startp = f->curp = f->buf;
buf += bytes;
totalbytes += bytes;
bytes = (size * n) - bytes;
}
else
bytes = size * n;
if (bytes) {
#ifdef __OS2_VDD__
readbytes = VDHRead((HFILE)f->handle, buf, bytes);
#else
DosRead((HFILE)f->handle, buf, bytes, &readbytes);
#endif
totalbytes += readbytes;
f->offset += readbytes;
}
return totalbytes / size;
}
static VOID APIENTRY ServiceRequests( VOID )
{
USHORT len;
pmhelp_packet data;
WinCreateMsgQueue( Hab, 0 );
for( ;; ) {
if( DosRead( InStream, &data, sizeof( data ), &len ) != 0 ) break;
if( len != sizeof( data ) ) break;
switch( data.command ) {
case PMHELP_LOCK:
PidDebugee = data.pid;
TidDebugee = data.tid;
LockIt();
break;
case PMHELP_UNLOCK:
PidDebugee = data.pid;
TidDebugee = data.tid;
UnLockIt();
break;
case PMHELP_EXIT:
WinPostMsg( hwndClient, WM_QUIT, 0, 0 );/* Cause termination*/
break;
}
WinInvalidateRegion( hwndClient, 0L, FALSE );
}
Say( "Read Failed" );
}
void _System Reader(ULONG arg)
{
int data;
ULONG read;
int new_index;
APIRET rc;
OverRun = FALSE;
for( ;; ) {
rc = DosRead( ComPort, &data, 1, &read );
if( rc != NO_ERROR )
break;
if( read == 1 ) {
new_index = ReadBuffAdd + 1;
new_index &= BSIZE-1;
if( new_index == ReadBuffRemove ) {
OverRun = TRUE;
} else {
ReadBuff[ ReadBuffAdd ] = data;
ReadBuffAdd = new_index;
}
DosPostEventSem( ReadSemaphore );
}
}
}
char far *InitAlias( char far * inname )
/**************************************/
{
USHORT hdl,read;
static char b[80];
char *bp;
unsigned long ppos,pos;
USHORT action;
char far *endname;
static char noalias = 0;
endname = inname;
while( *endname == ' ' ) ++endname;
for( ;; ) {
if( *endname == '\0' ) {
break;
}
if( *endname == ' ' ) {
*endname = '\0';
++endname;
break;
}
++endname;
}
bp = b;
while( *bp = *inname ) {
++bp;
++inname;
}
action=action;
if( DosOpen( b, &hdl, &action, 0L, 0, 1, 0x10 ,0L ) == 0 ) {
DosChgFilePtr( hdl, 0L, 2, &ppos );
pos = ppos;
DosChgFilePtr( hdl, 0L, 0, &ppos );
#ifdef DOS
{
static int alias_seg;
DosAllocSeg( pos + 1 + ALIAS_SLACK, &alias_seg, 0 );
*(((int far *)&AliasList)+0) = 0;
*(((int far *)&AliasList)+1) = alias_seg;
AliasSize = pos + ALIAS_SLACK;
}
#else
AliasList = AliasArea;
AliasSize = 2047;
#endif
DosRead( hdl, AliasList, pos, &read );
if( pos > 0 && AliasList[ pos-1 ] != '\n' ) {
AliasList[ pos+0 ] = '\r';
AliasList[ pos+1 ] = '\n';
AliasList[ pos+2 ] = '\0';
} else {
AliasList[ pos ] = '\0';
}
DosClose( hdl );
} else {
AliasList = &noalias;
}
return( endname );
}
/*
** Read data from a file into a buffer. Return SQLITE_OK if all
** bytes were read successfully and SQLITE_IOERR if anything goes
** wrong.
*/
static int os2Read(
sqlite3_file *id, /* File to read from */
void *pBuf, /* Write content into this buffer */
int amt, /* Number of bytes to read */
sqlite3_int64 offset /* Begin reading at this offset */
){
ULONG fileLocation = 0L;
ULONG got;
os2File *pFile = (os2File*)id;
assert( id!=0 );
SimulateIOError( return SQLITE_IOERR_READ );
OSTRACE3( "READ %d lock=%d\n", pFile->h, pFile->locktype );
if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
return SQLITE_IOERR;
}
if( DosRead( pFile->h, pBuf, amt, &got ) != NO_ERROR ){
return SQLITE_IOERR_READ;
}
if( got == (ULONG)amt )
return SQLITE_OK;
else {
/* Unread portions of the input buffer must be zero-filled */
memset(&((char*)pBuf)[got], 0, amt-got);
return SQLITE_IOERR_SHORT_READ;
}
}
size_t read_func(void *ptr, size_t size, size_t nmemb, void *datasource)
{
ULONG ulActual;
DosRead( (HFILE)datasource, ptr, (size*nmemb), &ulActual );
return ulActual / size;
}
static int
TRANS(Os2Read)(XtransConnInfo ciptr, char *buf, int size)
{
int ret;
APIRET rc;
ULONG ulRead;
PRMSG(2,"Os2Read(%d,%x,%d)\n", ciptr->fd, buf, size );
errno = 0;
rc = DosRead(ciptr->fd, buf, size, &ulRead);
if (rc == 0){
ret = ulRead;
}
else if ((rc == 232) || (rc == 231)){
errno = EAGAIN;
ret = -1;
}
else if (rc == 6){
errno = EBADF;
ret = -1;
}
else if ((rc == 109) || (rc == 230) || (rc == 233)){
errno = EPIPE;
ret = -1;
}
else {
PRMSG(2,"Os2Read: Unknown return code from DosRead, fd %d rc=%d\n", ciptr->fd,rc,0 );
errno = EINVAL;
ret = -1;
}
return (ret);
}
/*
* get the address of Dos32Debug, and get the flat selectors, too.
*/
int GetDos32Debug( char __far *err )
{
char buff[256];
RESULTCODES resc;
USHORT dummy;
PSZ start;
PSZ p;
HFILE inh;
HFILE outh;
USHORT rc;
struct {
ULONG dos_debug;
USHORT cs;
USHORT ds;
USHORT ss;
} data;
rc = DosGetModName( ThisDLLModHandle, sizeof( buff ), buff );
if( rc ) {
StrCopy( TRP_OS2_no_dll, err );
return( FALSE );
}
start = buff;
for( p = buff; *p != '\0'; ++p ) {
switch( *p ) {
case ':':
case '\\':
case '/':
start = p + 1;
break;
}
}
p = StrCopy( LOCATOR, start );
if( DosMakePipe( &inh, &outh, sizeof( data ) ) ) {
StrCopy( TRP_OS2_no_pipe, err );
return( FALSE );
}
*++p = outh + '0';
*++p = '\0';
*++p = '\0';
rc = DosExecPgm( NULL, 0, EXEC_ASYNC, buff, NULL, &resc, buff );
DosClose( outh );
if( rc ) {
DosClose( inh );
StrCopy( TRP_OS2_no_help, err );
return( FALSE );
}
rc = DosRead( inh, &data, sizeof( data ), &dummy );
DosClose( inh );
if( rc ) {
StrCopy( TRP_OS2_no_help, err );
return( FALSE );
}
DebugFunc = (void __far *)data.dos_debug;
FlatCS = (USHORT) data.cs;
FlatDS = (USHORT) data.ds;
_retaddr = MakeLocalPtrFlat( (void __far *)DoReturn );
return( TRUE );
}
static void init( void )
{
ULONG rc;
ULONG action;
ULONG bytes;
rc = DosOpen( "WTIMER$", &timerHandle, &action, 0,
FILE_NORMAL, FILE_OPEN, OPEN_SHARE_DENYNONE, NULL );
if( rc == 0 ) {
DosRead( timerHandle, &startTime, sizeof( TIMESTAMP ), &bytes );
DosRead( timerHandle, &stopTime, sizeof( TIMESTAMP ), &bytes );
calc_time( &overHead, &startTime, &stopTime, NULL );
DosRead( timerHandle, &startTime, sizeof( TIMESTAMP ), &bytes );
} else {
printf( "Could not open WTIMER$\n" );
}
}
int myread( int handle, char *buff, int len )
{
APIRET rc;
ULONG bytes_read;
rc = DosRead( handle, buff, len, &bytes_read );
if( rc != 0 ) return( 0 );
return( bytes_read );
}
char __far *InitAlias( char __far * inname )
/******************************************/
{
USHORT hdl,read;
static char b[80];
char *bp;
unsigned long ppos,pos;
USHORT action;
char __far *endname;
static char noalias = 0;
#ifndef DOS
static char AliasArea[2048]; /* The DLL seems to need static memory */
#endif
endname = inname;
while( *endname == ' ' )
++endname;
for( ; *endname != '\0'; endname++ ) {
if( *endname == ' ' ) {
*endname++ = '\0';
break;
}
}
for( bp = b; (*bp = *inname) != '\0'; bp++ ) {
++inname;
}
action=action;
if( DosOpen( b, &hdl, &action, 0L, 0, 1, 0x10 ,0L ) == 0 ) {
DosChgFilePtr( hdl, 0L, 2, &ppos );
pos = ppos;
DosChgFilePtr( hdl, 0L, 0, &ppos );
#ifdef DOS
{
static int alias_seg;
DosAllocSeg( pos + 1 + ALIAS_SLACK, &alias_seg, 0 );
AliasList = (char __far *)MK_FP( alias_seg, 0 );
AliasSize = pos + ALIAS_SLACK;
}
#else
AliasList = AliasArea;
AliasSize = 2047;
#endif
DosRead( hdl, AliasList, pos, &read );
if( pos > 0 && AliasList[pos - 1] != '\n' ) {
AliasList[pos + 0] = '\r';
AliasList[pos + 1] = '\n';
AliasList[pos + 2] = '\0';
} else {
AliasList[pos] = '\0';
}
DosClose( hdl );
} else {
AliasList = &noalias;
}
return( endname );
}
VOID CheckSystemConfig( VOID )
{
// Проверяем настройки в файле "Config.sys".
CHAR File_name[ SIZE_OF_NAME ] = "*:\\Config.sys"; ULONG Boot_drive = 0;
DosQuerySysInfo( QSV_BOOT_DRIVE, QSV_BOOT_DRIVE, (PULONG) &Boot_drive, sizeof( Boot_drive ) );
File_name[ 0 ] = (CHAR) Boot_drive + 64;
ULONG Action = OPEN_ACTION_OPEN_IF_EXISTS;
ULONG Mode = OPEN_FLAGS_FAIL_ON_ERROR | OPEN_SHARE_DENYWRITE | OPEN_ACCESS_READONLY;
HFILE File = NULLHANDLE; ULONG Report = 0;
APIRET RC = DosOpen( File_name, &File, &Report, 0, FILE_NORMAL, Action, Mode, NULL );
// Если файл был открыт:
if( RC == NO_ERROR )
{
// Отводим память для текста.
PCHAR Text = NULL; ULONG Length = 65536;
if( DosAllocMem( (PPVOID) &Text, Length, PAG_ALLOCATE ) != NO_ERROR )
{
DosClose( File );
DosExit( EXIT_PROCESS, 0 );
}
// Читаем настройки.
memset( Text, 0, Length );
DosRead( File, Text, Length, &Length );
// Проверяем, есть ли в настройках путь к каталогу расширителя.
BYTE Path_is_present = 1; if( !stristr( "NICE\\ENHANCER", Text ) ) Path_is_present = 0;
// Освобождаем память.
DosFreeMem( Text ); Text = NULL;
// Закрываем файл.
DosClose( File ); File = NULLHANDLE;
// Если настройки заданы неправильно:
if( !Path_is_present )
{
// Показываем сообщение.
CHAR Title[ SIZE_OF_TITLE ] = ""; GetEnhancerWindowTitle( Title );
if( QuerySystemCodePage() == RUSSIAN )
WinMessageBox( HWND_DESKTOP, HWND_DESKTOP, StrConst_RU_No_path_in_Config_sys, Title, NULLHANDLE, NULLHANDLE );
else
WinMessageBox( HWND_DESKTOP, HWND_DESKTOP, StrConst_EN_No_path_in_Config_sys, Title, NULLHANDLE, NULLHANDLE );
// Выход.
DosExit( EXIT_PROCESS, 0 );
}
}
// Возврат.
return;
}
char *ReadPipe(int iPipe)
{
APIRET rc;
ULONG ulTotal = 0;
ULONG ulBytesRead = 0;
Chunk* pHead = new Chunk;
Chunk* pCurr = pHead;
do
{
ulBytesRead = 0;
rc = DosRead(0, pCurr->data, sizeof(pCurr->data), &ulBytesRead);
pCurr->sz = ulBytesRead;
ulTotal += ulBytesRead;
if(ulBytesRead)
{
pCurr->next = new Chunk;
pCurr = pCurr->next;
}
}
while(!rc && ulBytesRead);
char *str = 0;
if(ulTotal)
{
str = new char[ulTotal+1];
char *ptr = str;
for(pCurr = pHead; pCurr; pCurr = pCurr->next)
{
if(!pCurr->sz)
continue;
memcpy(ptr, pCurr->data, pCurr->sz);
ptr += pCurr->sz;
}
*ptr = 0;
}
//Free memory
for(pCurr = pHead; pCurr; )
{
Chunk* pTmp = pCurr;
pCurr = pCurr->next;
delete pTmp;
}
return str;
}
/* --------------------------------------------------------------------------
Read 'cb' bytes from the file 'hf' into the buffer 'pBuffer'.
Display an error message in case of error.
- Parameters -------------------------------------------------------------
HFILE hf : file handle.
PVOID pBuffer : read buffer.
ULONG cb : count of bytes to be read.
- Return value -----------------------------------------------------------
LONG : count of succesfully read bytes (-1 in case of error).
-------------------------------------------------------------------------- */
LONG fmRead(HFILE hf, PVOID pBuffer, ULONG cb) {
ULONG cbRead;
g.rc = DosRead(hf, pBuffer, cb, &cbRead);
if (g.mode & FSJVERBOSE)
printMsg(IROW_DEBUG, SZ_FREAD, hf, cb, cbRead, g.rc);
if (g.rc)
return handleFileIOError(-1, SZERR_READFILE, "", g.rc);
return cbRead;
}
COUNT csysOpen(void)
{ COUNT fd;
struct nlsCSys_fileHeader header;
if((fd = DosOpen((BYTE FAR*)filename, 0)) < 0) {
printf("Cannot open: \"%s\"\n", filename);
return 1;
}
if(DosRead(fd, &header, sizeof(header)) != sizeof(header);
|| strcmp(header.csys_idstring, CSYS_FD_IDSTRING) != 0
// read bitmap color palette
BOOL GBMReadPalette( HFILE hFile, GBM *gbm, GBMRGB *gbmrgb )
{
BMP_PRIV *bmp_priv = ( BMP_PRIV * )gbm->priv;
ULONG ulActual;
if( gbm->bpp != 24 )
{
int i;
BYTE b[4];
if( bmp_priv->windows ) // OS/2 2.0 and Windows 3.0
{
DosSetFilePtr( hFile, // set to beginning of palette
bmp_priv->base + 14L + bmp_priv->cbFix,
FILE_BEGIN,
&ulActual );
for( i = 0; i < ( int )bmp_priv->cclrUsed; i++ ) // read colors
{
DosRead( hFile, b, 4, &ulActual ); // colors are in file as bgr
( gbmrgb + i )->Blue = *b;
( gbmrgb + i )->Green = *( b + 1 );
( gbmrgb + i )->Red = *( b + 2 );
}
}
else // OS/2 1.1 and 1.2
{
DosSetFilePtr( hFile, bmp_priv->base + 26L, FILE_BEGIN, &ulActual ); // set to palette start
for( i = 0; i < ( 1 << gbm->bpp ); i++ ) // read colors
{
DosRead( hFile, b, 3, &ulActual ); // colors are in file as bgr
( gbmrgb + i )->Blue = *b;
( gbmrgb + i )->Green = *( b + 1 );
( gbmrgb + i )->Red = *( b + 2 );
}
}
}
return( TRUE );
}
int ReadConfigFile(HWND hwnd, char szFileSpec[],char **ppBuffer)
{
ULONG ulStatus;
HFILE hFile;
FILESTATUS3 stFileInfo;
int iCount;
char szMessage[CCHMAXPATH];
APIRET rc;
if ((rc = DosOpen(szFileSpec,&hFile,&ulStatus,0L,0,1,0x0022,(PEAOP2)0L)) != 0)
{
if (hwnd != NULLHANDLE)
{
sprintf(szMessage,"Could not open %s - Error = %u",szFileSpec,rc);
MessageBox(HWND_DESKTOP,szMessage);
}
return(0);
}
DosQueryFileInfo(hFile,1,&stFileInfo,sizeof(FILESTATUS3));
iCount = stFileInfo.cbFile;
if ((rc = DosAllocMem((PVOID)ppBuffer,(iCount + 10),(PAG_COMMIT | PAG_READ | PAG_WRITE))) != NO_ERROR)
{
if (hwnd != NULLHANDLE)
{
sprintf(szMessage,"Unable to Allocate memory to read %s - %u",szFileSpec,rc);
MessageBox(HWND_DESKTOP,szMessage);
}
iCount = 0;
}
if (DosRead(hFile,(PVOID)*ppBuffer,iCount,(ULONG *)&iCount) != 0)
{
DosFreeMem(*ppBuffer);
iCount = 0;
}
else
{
/*
** ignore/remove EOF character, if present
*/
if ((*ppBuffer)[(iCount) - 1] == '\x1a')
iCount--;
/*
** Add LF and CR to end of file, if not already there
*/
if ((*ppBuffer)[iCount - 1] != '\x0a')
{
(*ppBuffer)[(iCount)++] = '\x0d';
(*ppBuffer)[(iCount)++] = '\x0a';
}
}
DosClose(hFile);
return(iCount);
}
static void fini( TIMESTAMP *time )
{
ULONG rc;
ULONG bytes;
DosRead( timerHandle, &stopTime, sizeof( TIMESTAMP ), &bytes );
calc_time( time, &startTime, &stopTime, &overHead );
rc = DosClose( timerHandle );
if( rc != 0 ) {
printf( "Could not close WTIMER$\n" );
}
}
unsigned LocalRead( sys_handle filehndl, void *ptr, unsigned len )
{
USHORT read;
USHORT ret;
ret = DosRead( filehndl, ptr, len, &read );
if( ret != 0 ) {
StashErrCode( ret, OP_LOCAL );
return( ERR_RETURN );
}
return( read );
}
int read(int fd, void *buffer, unsigned int count)
{
APIRET rc;
ULONG actual;
rc= DosRead( fd, (PVOID) buffer, count, &actual);
if (!rc)
return( actual); /* NO_ERROR */
_OS2errno( rc); /* set errno */
return(-1); /* read failed */
}
static VOID pipeClose( HPIPE hpipe )
{
#if 0
USHORT usIndex;
ULONG cbActual;
// wait acknowledgement
DosRead( hpipe, &usIndex, sizeof( USHORT ), &cbActual );
#endif
DosClose( hpipe );
}
unsigned LocalRead(sys_handle filehndl, void *ptr, unsigned len)
{
ULONG read;
APIRET ret;
ret = DosRead(filehndl, ptr, len, &read);
if (ret != 0) {
StashErrCode(ret, OP_LOCAL);
return ERR_RETURN;
}
return read;
}
INT multiRead(CHAR *inFile, INT datS, INT sizeF, INT recNum)
{
struct Samp
{
SHORT indx;
CHAR noteName[NAMESIZE];
}sample;
ULONG oneRecSize, start;
APIRET apiret;
ULONG ulAction, ulBufferSize, ulBytesRead, newP;
HFILE hfile;
ulBufferSize = sizeF;
apiret = DosOpen(inFile,
&hfile,
&ulAction,
ulBufferSize,
FILE_NORMAL,
OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
OPEN_ACCESS_READONLY | OPEN_SHARE_DENYWRITE | OPEN_FLAGS_SEQUENTIAL,
NULL);
oneRecSize = sizeof(sample) + sizeF;
start = sizeof(recIndex);
DosSetFilePtr(hfile, start+(oneRecSize*(recNum)), FILE_BEGIN, &newP);
DosRead (hfile, &sample, sizeof(sample), &ulBytesRead);
if( datS == 1 )
{
DosRead (hfile, &dataRecs.noteText, sizeF, &ulBytesRead);
dataRecs.indx = sample.indx;
strcpy(dataRecs.noteName, sample.noteName);
}
else
{
DosRead (hfile, &dataR.noteText, sizeF, &ulBytesRead);
dataR.indx = sample.indx;
strcpy(dataR.noteName, sample.noteName);
}
DosClose(hfile);
return(1);
}
ULONG FileReadFile( HFILE hFile, char * pBuf, ULONG cbRequest, char * path)
{
ULONG rc;
ULONG ul;
ULONG ulRtn;
do {
ulRtn = 0;
rc = DosRead( hFile, pBuf, cbRequest, &ulRtn);
if (!rc && ulRtn == cbRequest)
break;
printf( "FileReadFile - first attempt - rc= 0x%lx request= 0x%lx read= 0x%lx\n file= %s\n",
rc, cbRequest, ulRtn, path);
DosSleep( 100);
rc = DosSetFilePtr( hFile, -(ulRtn), FILE_CURRENT, &ul);
if (rc) {
printf( "FileReadFile - DosSetFilePtr - rc= 0x%lx\n", rc);
ulRtn = 0;
break;
}
ulRtn = 0;
rc = DosRead( hFile, pBuf, cbRequest, &ulRtn);
if (!rc && ulRtn == cbRequest)
break;
printf( "FileReadFile - second attempt - rc= 0x%lx request= 0x%lx read= 0x%lx\n",
rc, cbRequest, ulRtn);
ulRtn = 0;
} while (0);
return (ulRtn);
}
int __qread( int handle, void *buffer, unsigned len )
{
#if defined( __NT__ )
DWORD amount_read;
#elif defined(__OS2__)
OS_UINT amount_read;
APIRET rc;
#else
unsigned amount_read;
tiny_ret_t rc;
#endif
__handle_check( handle, -1 );
#ifdef DEFAULT_WINDOWING
if( _WindowsStdin != NULL ) {
LPWDATA res;
res = _WindowsIsWindowedHandle( handle );
if( res ) {
int rt;
rt = _WindowsStdin( res, buffer, len );
return( rt );
}
}
#endif
#if defined(__NT__)
if( !ReadFile( __getOSHandle( handle ), buffer, len, &amount_read, NULL ) ) {
DWORD err;
err = GetLastError();
__set_errno_dos( err );
if( err != ERROR_BROKEN_PIPE || amount_read != 0 ) {
return( -1 );
}
}
#elif defined(__OS2__)
rc = DosRead( handle, buffer, len, &amount_read );
if( rc ) {
return( __set_errno_dos( rc ) );
}
#else
#if defined( __WINDOWS_386__ )
rc = __TinyRead( handle, buffer, len );
#else
rc = TinyRead( handle, buffer, len );
#endif
if( TINY_ERROR( rc ) ) {
return( __set_errno_dos( TINY_INFO( rc ) ) );
}
amount_read = TINY_LINFO( rc );
#endif
return( amount_read );
}