| /**************************************************************************** |
| * |
| * SciTech OS Portability Manager Library |
| * |
| * ======================================================================== |
| * |
| * The contents of this file are subject to the SciTech MGL Public |
| * License Version 1.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at http://www.scitechsoft.com/mgl-license.txt |
| * |
| * Software distributed under the License is distributed on an |
| * "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * rights and limitations under the License. |
| * |
| * The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc. |
| * |
| * The Initial Developer of the Original Code is SciTech Software, Inc. |
| * All Rights Reserved. |
| * |
| * ======================================================================== |
| * |
| * Language: ANSI C |
| * Environment: 32-bit Windows VxD |
| * |
| * Description: C library compatible I/O functions for use within a VxD. |
| * |
| ****************************************************************************/ |
| |
| #include "pmapi.h" |
| #include "vxdfile.h" |
| |
| /*------------------------ Main Code Implementation -----------------------*/ |
| |
| #define EOF -1 |
| |
| /**************************************************************************** |
| REMARKS: |
| VxD implementation of the ANSI C fopen function. |
| ****************************************************************************/ |
| FILE * fopen( |
| const char *filename, |
| const char *mode) |
| { |
| FILE *f = PM_malloc(sizeof(FILE)); |
| long oldpos; |
| |
| if (f) { |
| f->offset = 0; |
| f->text = (mode[1] == 't' || mode[2] == 't'); |
| f->writemode = (mode[0] == 'w') || (mode[0] == 'a'); |
| if (initComplete) { |
| WORD omode,error; |
| BYTE action; |
| |
| if (mode[0] == 'r') { |
| omode = OPEN_ACCESS_READONLY | OPEN_SHARE_COMPATIBLE; |
| action = ACTION_IFEXISTS_OPEN | ACTION_IFNOTEXISTS_FAIL; |
| } |
| else if (mode[0] == 'w') { |
| omode = OPEN_ACCESS_WRITEONLY | OPEN_SHARE_COMPATIBLE; |
| action = ACTION_IFEXISTS_TRUNCATE | ACTION_IFNOTEXISTS_CREATE; |
| } |
| else { |
| omode = OPEN_ACCESS_READWRITE | OPEN_SHARE_COMPATIBLE; |
| action = ACTION_IFEXISTS_OPEN | ACTION_IFNOTEXISTS_CREATE; |
| } |
| f->handle = (int)R0_OpenCreateFile(false,(char*)filename,omode,ATTR_NORMAL,action,0,&error,&action); |
| if (f->handle == 0) { |
| PM_free(f); |
| return NULL; |
| } |
| f->filesize = R0_GetFileSize((HANDLE)f->handle,&error); |
| if (mode[0] == 'a') |
| fseek(f,0,2); |
| } |
| else { |
| int oflag,pmode; |
| |
| if (mode[0] == 'r') { |
| pmode = _S_IREAD; |
| oflag = _O_RDONLY; |
| } |
| else if (mode[0] == 'w') { |
| pmode = _S_IWRITE; |
| oflag = _O_WRONLY | _O_CREAT | _O_TRUNC; |
| } |
| else { |
| pmode = _S_IWRITE; |
| oflag = _O_RDWR | _O_CREAT | _O_APPEND; |
| } |
| if (f->text) |
| oflag |= _O_TEXT; |
| else |
| oflag |= _O_BINARY; |
| if ((f->handle = i_open(filename,oflag,pmode)) == -1) { |
| PM_free(f); |
| return NULL; |
| } |
| oldpos = i_lseek(f->handle,0,1); |
| f->filesize = i_lseek(f->handle,0,2); |
| i_lseek(f->handle,oldpos,0); |
| } |
| } |
| return f; |
| } |
| |
| /**************************************************************************** |
| REMARKS: |
| VxD implementation of the ANSI C fread function. Note that the VxD file I/O |
| functions are layered on DOS, so can only read up to 64K at a time. Since |
| we are expected to handle much larger chunks than this, we handle larger |
| blocks automatically in here. |
| ****************************************************************************/ |
| size_t fread( |
| void *ptr, |
| size_t size, |
| size_t n, |
| FILE *f) |
| { |
| char *buf = ptr; |
| WORD error; |
| int bytes = size * n; |
| int readbytes,totalbytes = 0; |
| |
| while (bytes > 0x10000) { |
| if (initComplete) { |
| readbytes = R0_ReadFile(false,(HANDLE)f->handle,buf,0x8000,f->offset,&error); |
| readbytes += R0_ReadFile(false,(HANDLE)f->handle,buf+0x8000,0x8000,f->offset+0x8000,&error); |
| } |
| else { |
| readbytes = i_read(f->handle,buf,0x8000); |
| readbytes += i_read(f->handle,buf+0x8000,0x8000); |
| } |
| totalbytes += readbytes; |
| f->offset += readbytes; |
| buf += 0x10000; |
| bytes -= 0x10000; |
| } |
| if (bytes) { |
| if (initComplete) |
| readbytes = R0_ReadFile(false,(HANDLE)f->handle,buf,bytes,f->offset,&error); |
| else |
| readbytes = i_read(f->handle,buf,bytes); |
| totalbytes += readbytes; |
| f->offset += readbytes; |
| } |
| return totalbytes / size; |
| } |
| |
| /**************************************************************************** |
| REMARKS: |
| VxD implementation of the ANSI C fwrite function. Note that the VxD file I/O |
| functions are layered on DOS, so can only read up to 64K at a time. Since |
| we are expected to handle much larger chunks than this, we handle larger |
| blocks automatically in here. |
| ****************************************************************************/ |
| size_t fwrite( |
| const void *ptr, |
| size_t size, |
| size_t n, |
| FILE *f) |
| { |
| const char *buf = ptr; |
| WORD error; |
| int bytes = size * n; |
| int writtenbytes,totalbytes = 0; |
| |
| if (!f->writemode) |
| return 0; |
| while (bytes > 0x10000) { |
| if (initComplete) { |
| writtenbytes = R0_WriteFile(false,(HANDLE)f->handle,buf,0x8000,f->offset,&error); |
| writtenbytes += R0_WriteFile(false,(HANDLE)f->handle,buf+0x8000,0x8000,f->offset+0x8000,&error); |
| } |
| else { |
| writtenbytes = i_write(f->handle,buf,0x8000); |
| writtenbytes += i_write(f->handle,buf+0x8000,0x8000); |
| } |
| totalbytes += writtenbytes; |
| f->offset += writtenbytes; |
| buf += 0x10000; |
| bytes -= 0x10000; |
| } |
| if (initComplete) |
| writtenbytes = R0_WriteFile(false,(HANDLE)f->handle,buf,bytes,f->offset,&error); |
| else |
| writtenbytes = i_write(f->handle,buf,bytes); |
| totalbytes += writtenbytes; |
| f->offset += writtenbytes; |
| if (f->offset > f->filesize) |
| f->filesize = f->offset; |
| return totalbytes / size; |
| } |
| |
| /**************************************************************************** |
| REMARKS: |
| VxD implementation of the ANSI C fflush function. |
| ****************************************************************************/ |
| int fflush( |
| FILE *f) |
| { |
| // Nothing to do since we are not doing buffered file I/O |
| (void)f; |
| return 0; |
| } |
| |
| /**************************************************************************** |
| REMARKS: |
| VxD implementation of the ANSI C fseek function. |
| ****************************************************************************/ |
| int fseek( |
| FILE *f, |
| long int offset, |
| int whence) |
| { |
| if (whence == 0) |
| f->offset = offset; |
| else if (whence == 1) |
| f->offset += offset; |
| else if (whence == 2) |
| f->offset = f->filesize + offset; |
| if (!initComplete) |
| i_lseek(f->handle,f->offset,0); |
| return 0; |
| } |
| |
| /**************************************************************************** |
| REMARKS: |
| VxD implementation of the ANSI C ftell function. |
| ****************************************************************************/ |
| long ftell( |
| FILE *f) |
| { |
| return f->offset; |
| } |
| |
| /**************************************************************************** |
| REMARKS: |
| VxD implementation of the ANSI C feof function. |
| ****************************************************************************/ |
| int feof( |
| FILE *f) |
| { |
| return (f->offset == f->filesize); |
| } |
| |
| /**************************************************************************** |
| REMARKS: |
| NT driver implementation of the ANSI C fgets function. |
| ****************************************************************************/ |
| char *fgets( |
| char *s, |
| int n, |
| FILE *f) |
| { |
| int len; |
| char *cs; |
| |
| // Read the entire buffer into memory (our functions are unbuffered!) |
| if ((len = fread(s,1,n,f)) == 0) |
| return NULL; |
| |
| // Search for '\n' or end of string |
| if (n > len) |
| n = len; |
| cs = s; |
| while (--n > 0) { |
| if (*cs == '\n') |
| break; |
| cs++; |
| } |
| *cs = '\0'; |
| return s; |
| } |
| |
| /**************************************************************************** |
| REMARKS: |
| NT driver implementation of the ANSI C fputs function. |
| ****************************************************************************/ |
| int fputs( |
| const char *s, |
| FILE *f) |
| { |
| return fwrite(s,1,strlen(s),f); |
| } |
| |
| /**************************************************************************** |
| REMARKS: |
| VxD implementation of the ANSI C fclose function. |
| ****************************************************************************/ |
| int fclose( |
| FILE *f) |
| { |
| WORD error; |
| |
| if (initComplete) |
| R0_CloseFile((HANDLE)f->handle,&error); |
| else |
| i_close(f->handle); |
| PM_free(f); |
| return 0; |
| } |
| |
