Ignore:
Timestamp:
Jun 1, 2000, 1:28:48 PM (25 years ago)
Author:
sandervl
Message:

Rewrote file io apis

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/hmopen32.cpp

    r3593 r3642  
    1 /* $Id: hmopen32.cpp,v 1.23 2000-05-23 18:45:12 sandervl Exp $ */
     1/* $Id: hmopen32.cpp,v 1.24 2000-06-01 11:28:47 sandervl Exp $ */
    22
    33/*
    … …  
    7171}
    7272
     73/*****************************************************************************
     74 * Name      : DWORD HMDeviceOpen32Class::CloseHandle
     75 * Purpose   : close the handle
     76 * Parameters: PHMHANDLEDATA pHMHandleData
     77 * Variables :
     78 * Result    : API returncode
     79 * Remark    :
     80 * Status    :
     81 *
     82 * Author    : Patrick Haller [Wed, 1998/02/11 20:44]
     83 *****************************************************************************/
     84
     85DWORD HMDeviceOpen32Class::CloseHandle(PHMHANDLEDATA pHMHandleData)
     86{
     87  BOOL bRC;
     88
     89  dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle(%08x)\n",
     90           pHMHandleData->hHMHandle));
     91
     92  bRC = O32_CloseHandle(pHMHandleData->hHMHandle);
     93
     94  dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle returned %08xh\n",
     95           bRC));
     96
     97  return (DWORD)bRC;
     98}
    7399
    74100/*****************************************************************************
    … …  
    100126           srcprocess, pHMSrcHandle->hHMHandle, destprocess, desthandle));
    101127
    102 #if 1
    103128  rc = O32_DuplicateHandle(srcprocess, pHMSrcHandle->hHMHandle, destprocess, desthandle, fdwAccess, fInherit, fdwOptions);
    104129
    105130  if(rc == TRUE) {
    106131        pHMHandleData->hHMHandle = *desthandle;
    107         return (NO_ERROR);
     132        return TRUE;
    108133  }
    109   else  return(O32_GetLastError());
    110 #else
    111   rc = OSLibDosDupHandle(pHMSrcHandle->hHMHandle, desthandle);
    112   if(rc == NO_ERROR)
    113   {
    114     pHMHandleData->hHMHandle = *desthandle;
    115     return (NO_ERROR);
    116   }
    117   else
    118   {
    119     dprintfl(("KERNEL32: HandleManager::Open32::DuplicateHandle Error %d\n",rc));
    120     O32_SetLastError(rc);
    121     return(rc);
    122   }
    123 #endif
    124 }
    125 
    126 /*****************************************************************************
    127  * Name      : DWORD HMDeviceOpen32Class::CreateFile
    128  * Purpose   : this is called from the handle manager if a CreateFile() is
    129  *             performed on a handle
    130  * Parameters: LPCSTR        lpFileName            name of the file / device
    131  *             PHMHANDLEDATA pHMHandleData         data of the NEW handle
    132  *             PVOID         lpSecurityAttributes  ignored
    133  *             PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
    134  * Variables :
    135  * Result    :
    136  * Remark    :
    137  * Status    : NO_ERROR - API succeeded
    138  *             other    - what is to be set in SetLastError
    139  *
    140  * Author    : Patrick Haller [Wed, 1998/02/11 20:44]
    141  *****************************************************************************/
    142 
    143 DWORD HMDeviceOpen32Class::CreateFile (LPCSTR        lpFileName,
    144                                        PHMHANDLEDATA pHMHandleData,
    145                                        PVOID         lpSecurityAttributes,
    146                                        PHMHANDLEDATA pHMHandleDataTemplate)
    147 {
    148   HFILE hFile;
    149   HFILE hTemplate;
    150 
    151   dprintfl(("KERNEL32: HandleManager::Open32::CreateFile %s(%s,%08x,%08x,%08x) - stub?\n",
    152            lpHMDeviceName,
    153            lpFileName,
    154            pHMHandleData,
    155            lpSecurityAttributes,
    156            pHMHandleDataTemplate));
    157 
    158   if (strncmp(lpFileName,       // "support" for local unc names
    159               "\\\\.\\",
    160               4) == 0)
    161   {
    162         lpFileName+=4;
    163   }
    164 
    165   // create from template
    166   if (pHMHandleDataTemplate != NULL)
    167      hTemplate = pHMHandleDataTemplate->hHMHandle;
    168   else
    169      hTemplate = 0;
    170 
    171 #if 1
    172   //SvL: Open32 doesn't like this flag
    173   if(pHMHandleData->dwShare & FILE_SHARE_DELETE) {
    174         pHMHandleData->dwShare &= ~FILE_SHARE_DELETE;
    175   }
    176 
    177   hFile = O32_CreateFile(lpFileName,
    178                          pHMHandleData->dwAccess,
    179                          pHMHandleData->dwShare,
    180                          //(LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
    181                          NULL,
    182                          pHMHandleData->dwCreation,
    183                          pHMHandleData->dwFlags,
    184                          hTemplate);
    185   if (hFile != INVALID_HANDLE_ERROR)
    186   {
    187         pHMHandleData->hHMHandle = hFile;
    188         return (NO_ERROR);
    189   }
    190   else {
    191         dprintf(("CreateFile failed; error %x", O32_GetLastError()));
    192         return(O32_GetLastError());
    193   }
    194 #else
    195 
    196   rc = OSLibDosCreate((char *)lpFileName,
    197                        pHMHandleData->dwAccess,
    198                        pHMHandleData->dwShare,
    199                        //(LPSECURITY_ATTRIBUTES)lpSecurityAttributes,
    200                        NULL,
    201                        pHMHandleData->dwCreation,
    202                        pHMHandleData->dwFlags,
    203                        hTemplate, &hFile);
    204   if(rc)
    205   {
    206     dprintfl(("KERNEL32: HandleManager::Open32::CreateFile Error %d\n",rc));
    207     O32_SetLastError(rc);
    208     return(rc);
    209   }
    210   else
    211   {
    212     pHMHandleData->hHMHandle = hFile;
    213     return (NO_ERROR);
    214   }
    215 #endif
    216 }
    217 
    218 
    219 /*****************************************************************************
    220  * Name      : DWORD HMDeviceOpen32Class::CloseHandle
    221  * Purpose   : close the handle
    222  * Parameters: PHMHANDLEDATA pHMHandleData
    223  * Variables :
    224  * Result    : API returncode
    225  * Remark    :
    226  * Status    :
    227  *
    228  * Author    : Patrick Haller [Wed, 1998/02/11 20:44]
    229  *****************************************************************************/
    230 
    231 DWORD HMDeviceOpen32Class::CloseHandle(PHMHANDLEDATA pHMHandleData)
    232 {
    233   BOOL bRC;
    234 
    235   dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle(%08x)\n",
    236            pHMHandleData->hHMHandle));
    237 
    238 #if 1
    239   bRC = O32_CloseHandle(pHMHandleData->hHMHandle);
    240 
    241   dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle returned %08xh\n",
    242            bRC));
    243 
    244   return (DWORD)bRC;
    245 #else
    246   bRC = OSLibDosClose(pHMHandleData->hHMHandle);
    247   if(bRC)
    248   {
    249     dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle Error %d\n",bRC));
    250     O32_SetLastError(bRC);
    251     return TRUE;      // MUTEX Problem
    252     return FALSE;
    253   }
    254   else
    255   {
    256     return TRUE;
    257   }
    258 #endif
    259 }
    260 
    261 
    262 /*****************************************************************************
    263  * Name      : BOOL HMDeviceOpen32Class::ReadFile
    264  * Purpose   : read data from handle / device
    265  * Parameters: PHMHANDLEDATA pHMHandleData,
    266  *             LPCVOID       lpBuffer,
    267  *             DWORD         nNumberOfBytesToRead,
    268  *             LPDWORD       lpNumberOfBytesRead,
    269  *             LPOVERLAPPED  lpOverlapped
    270  * Variables :
    271  * Result    : Boolean
    272  * Remark    :
    273  * Status    :
    274  *
    275  * Author    : Patrick Haller [Wed, 1998/02/11 20:44]
    276  *****************************************************************************/
    277 
    278 BOOL HMDeviceOpen32Class::ReadFile(PHMHANDLEDATA pHMHandleData,
    279                                    LPCVOID       lpBuffer,
    280                                    DWORD         nNumberOfBytesToRead,
    281                                    LPDWORD       lpNumberOfBytesRead,
    282                                    LPOVERLAPPED  lpOverlapped)
    283 {
    284   BOOL bRC;
    285   LPVOID lpRealBuf;
    286 
    287   dprintfl(("KERNEL32: HandleManager::Open32::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
    288            lpHMDeviceName,
    289            pHMHandleData,
    290            lpBuffer,
    291            nNumberOfBytesToRead,
    292            lpNumberOfBytesRead,
    293            lpOverlapped));
    294 
    295 #if 1
    296   Win32MemMap *map;
    297   DWORD offset;
    298 
    299   //SvL: DosRead doesn't like writing to memory addresses returned by
    300   //     DosAliasMem -> search for original memory mapped pointer and use
    301   //     that one
    302   map = Win32MemMapView::findMapByView((ULONG)lpBuffer, &offset, MEMMAP_ACCESS_READ);
    303   if(map) {
    304         lpRealBuf = (LPVOID)((ULONG)map->getMappingAddr() + offset);
    305         DWORD nrpages = nNumberOfBytesToRead/4096;
    306         if(offset & 0xfff)
    307                 nrpages++;
    308         else
    309         if(nNumberOfBytesToRead & 0xfff)
    310                 nrpages++;
    311 
    312         map->commitPage(offset & ~0xfff, TRUE, nrpages);
    313   }
    314   else  lpRealBuf = (LPVOID)lpBuffer;
    315  
    316   bRC = O32_ReadFile(pHMHandleData->hHMHandle,
    317                      (PVOID)lpRealBuf,
    318                      nNumberOfBytesToRead,
    319                      lpNumberOfBytesRead,
    320                      lpOverlapped);
    321 
    322   if(bRC == 0) {
    323         dprintf(("KERNEL32: HandleManager::Open32::ReadFile returned %08xh %x\n",
    324                   bRC, GetLastError()));
    325         dprintf(("%x -> %d", lpBuffer, IsBadWritePtr((LPVOID)lpBuffer, nNumberOfBytesToRead)));
    326   }
    327   else  dprintfl(("KERNEL32: HandleManager::Open32::ReadFile returned %08xh\n",
    328                    bRC));
    329 
    330   return bRC;
    331 #else
    332   rc = OSLibDosRead(pHMHandleData->hHMHandle,
    333                     (PVOID) lpBuffer,
    334                     nNumberOfBytesToRead,
    335                     lpNumberOfBytesRead);
    336   if(rc)
    337   {
    338     dprintfl(("KERNEL32: HandleManager::Open32::ReadFile Error %d\n",rc));
    339     O32_SetLastError(rc);
    340     return FALSE;
    341   }
    342   else
    343   {
    344     return TRUE;
    345   }
    346 #endif
    347 }
    348 
    349 
    350 /*****************************************************************************
    351  * Name      : BOOL HMDeviceOpen32Class::WriteFile
    352  * Purpose   : write data to handle / device
    353  * Parameters: PHMHANDLEDATA pHMHandleData,
    354  *             LPCVOID       lpBuffer,
    355  *             DWORD         nNumberOfBytesToWrite,
    356  *             LPDWORD       lpNumberOfBytesWritten,
    357  *             LPOVERLAPPED  lpOverlapped
    358  * Variables :
    359  * Result    : Boolean
    360  * Remark    :
    361  * Status    :
    362  *
    363  * Author    : Patrick Haller [Wed, 1998/02/11 20:44]
    364  *****************************************************************************/
    365 
    366 BOOL HMDeviceOpen32Class::WriteFile(PHMHANDLEDATA pHMHandleData,
    367                                     LPCVOID       lpBuffer,
    368                                     DWORD         nNumberOfBytesToWrite,
    369                                     LPDWORD       lpNumberOfBytesWritten,
    370                                     LPOVERLAPPED  lpOverlapped)
    371 {
    372   BOOL bRC;
    373 
    374   dprintfl(("KERNEL32: HandleManager::Open32::WriteFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
    375            lpHMDeviceName,
    376            pHMHandleData,
    377            lpBuffer,
    378            nNumberOfBytesToWrite,
    379            lpNumberOfBytesWritten,
    380            lpOverlapped));
    381 
    382 #if 1
    383   bRC = O32_WriteFile(pHMHandleData->hHMHandle,
    384                       lpBuffer,
    385                       nNumberOfBytesToWrite,
    386                       lpNumberOfBytesWritten,
    387                       lpOverlapped);
    388 
    389   dprintfl(("KERNEL32: HandleManager::Open32::WriteFile returned %08xh\n",
    390            bRC));
    391 
    392   return bRC;
    393 #else
    394   rc = OSLibDosWrite(pHMHandleData->hHMHandle,
    395                      (PVOID) lpBuffer,
    396                      nNumberOfBytesToWrite,
    397                      lpNumberOfBytesWritten);
    398   if(rc)
    399   {
    400     dprintfl(("KERNEL32: HandleManager::Open32::WriteFile Error %d\n",rc));
    401     O32_SetLastError(rc);
    402     return FALSE;
    403   }
    404   else
    405   {
    406     return TRUE;
    407   }
    408 #endif
    409 }
    410 
     134  else  return FALSE;
     135}
    411136
    412137/*****************************************************************************
    … …  
    428153           pHMHandleData));
    429154
    430 #if 1
     155  //TODO: return FILE_TYPE_UNKNOWN for standard in/out handles; correct??
    431156  return O32_GetFileType(pHMHandleData->hHMHandle);
    432 #else
    433   // TODO: FILE_TYPE_DISK
    434   return FILE_TYPE_CHAR;
    435 #endif
    436157}
    437158
    … …  
    461182                                        pHFI);
    462183}
    463 
    464 
    465 /*****************************************************************************
    466  * Name      : BOOL HMDeviceOpen32Class::SetEndOfFile
    467  * Purpose   : set end of file marker
    468  * Parameters: PHMHANDLEDATA              pHMHandleData
    469  * Variables :
    470  * Result    : API returncode
    471  * Remark    :
    472  * Status    :
    473  *
    474  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    475  *****************************************************************************/
    476 
    477 BOOL HMDeviceOpen32Class::SetEndOfFile(PHMHANDLEDATA pHMHandleData)
    478 {
    479   dprintfl(("KERNEL32: HandleManager::Open32::SetEndOfFile %s(%08xh)\n",
    480            lpHMDeviceName,
    481            pHMHandleData));
    482 
    483   return O32_SetEndOfFile(pHMHandleData->hHMHandle);
    484 }
    485 
    486 
    487 /*****************************************************************************
    488  * Name      : BOOL HMDeviceOpen32Class::SetFileTime
    489  * Purpose   : set file time
    490  * Parameters: PHMHANDLEDATA pHMHandleData
    491  *             PFILETIME     pFT1
    492  *             PFILETIME     pFT2
    493  *             PFILETIME     pFT3
    494  * Variables :
    495  * Result    : API returncode
    496  * Remark    :
    497  * Status    :
    498  *
    499  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    500  *****************************************************************************/
    501 
    502 BOOL HMDeviceOpen32Class::SetFileTime(PHMHANDLEDATA pHMHandleData,
    503                                       LPFILETIME pFT1,
    504                                       LPFILETIME pFT2,
    505                                       LPFILETIME pFT3)
    506 {
    507   dprintfl(("KERNEL32: HandleManager::Open32::SetFileTime %s(%08xh,%08xh,%08xh,%08xh)\n",
    508            lpHMDeviceName,
    509            pHMHandleData,
    510            pFT1,
    511            pFT2,
    512            pFT3));
    513 
    514   return O32_SetFileTime(pHMHandleData->hHMHandle,
    515                          pFT1,
    516                          pFT2,
    517                          pFT3);
    518 }
    519 
    520 /*****************************************************************************
    521  * Name      : BOOL HMDeviceOpen32Class::GetFileTime
    522  * Purpose   : get file time
    523  * Parameters: PHMHANDLEDATA pHMHandleData
    524  *             PFILETIME     pFT1
    525  *             PFILETIME     pFT2
    526  *             PFILETIME     pFT3
    527  * Variables :
    528  * Result    : API returncode
    529  * Remark    :
    530  * Status    :
    531  *
    532  * Author    : SvL
    533  *****************************************************************************/
    534 
    535 BOOL HMDeviceOpen32Class::GetFileTime(PHMHANDLEDATA pHMHandleData,
    536                                       LPFILETIME pFT1,
    537                                       LPFILETIME pFT2,
    538                                       LPFILETIME pFT3)
    539 {
    540   return O32_GetFileTime(pHMHandleData->hHMHandle,
    541                          pFT1,
    542                          pFT2,
    543                          pFT3);
    544 }
    545 
    546 
    547 /*****************************************************************************
    548  * Name      : DWORD HMDeviceOpen32Class::GetFileSize
    549  * Purpose   : set file time
    550  * Parameters: PHMHANDLEDATA pHMHandleData
    551  *             PDWORD        pSize
    552  * Variables :
    553  * Result    : API returncode
    554  * Remark    :
    555  * Status    :
    556  *
    557  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    558  *****************************************************************************/
    559 
    560 DWORD HMDeviceOpen32Class::GetFileSize(PHMHANDLEDATA pHMHandleData,
    561                                        PDWORD        lpdwFileSizeHigh)
    562 {
    563   dprintfl(("KERNEL32: HandleManager::Open32::GetFileSize %s(%08xh,%08xh)\n",
    564            lpHMDeviceName,
    565            pHMHandleData,
    566            lpdwFileSizeHigh));
    567 
    568 #if 1
    569   if(lpdwFileSizeHigh)
    570     *lpdwFileSizeHigh = 0;
    571 
    572   return O32_GetFileSize(pHMHandleData->hHMHandle,
    573                          lpdwFileSizeHigh);
    574 #else
    575   size = OSLibDosGetFileSize(pHMHandleData->hHMHandle);
    576   if(pSize)
    577     *pSize = 0;
    578   return size;
    579 #endif
    580 }
    581 
    582 
    583 /*****************************************************************************
    584  * Name      : DWORD HMDeviceOpen32Class::SetFilePointer
    585  * Purpose   : set file pointer
    586  * Parameters: PHMHANDLEDATA pHMHandleData
    587  *             LONG          lDistanceToMove
    588  *             PLONG         lpDistanceToMoveHigh
    589  *             DWORD         dwMoveMethod
    590  * Variables :
    591  * Result    : API returncode
    592  * Remark    :
    593  * Status    :
    594  *
    595  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    596  *****************************************************************************/
    597 
    598 DWORD HMDeviceOpen32Class::SetFilePointer(PHMHANDLEDATA pHMHandleData,
    599                                           LONG          lDistanceToMove,
    600                                           PLONG         lpDistanceToMoveHigh,
    601                                           DWORD         dwMoveMethod)
    602 {
    603   dprintfl(("KERNEL32: HandleManager::Open32::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
    604            lpHMDeviceName,
    605            pHMHandleData,
    606            lDistanceToMove,
    607            lpDistanceToMoveHigh,
    608            dwMoveMethod));
    609 
    610 #if 1
    611   DWORD ret;
    612 
    613   if(lpDistanceToMoveHigh)
    614     *lpDistanceToMoveHigh = 0;
    615 
    616   ret = O32_SetFilePointer(pHMHandleData->hHMHandle,
    617                            lDistanceToMove,
    618                            lpDistanceToMoveHigh,
    619                            dwMoveMethod);
    620 
    621 //  if(ret == -1) {
    622 //      dprintf(("current position %x (error = %x)", O32_SetFilePointer(pHMHandleData->hHMHandle,0, 0, 1), GetLastError()));
    623 //  }
    624   return ret;
    625 #else
    626 
    627   if(lpDistanceToMoveHigh)
    628     *lpDistanceToMoveHigh = 0;
    629   pos = OSLibDosSetFilePtr2(pHMHandleData->hHMHandle, lDistanceToMove, dwMoveMethod);
    630   return pos;
    631 #endif
    632 }
    633 
    634 
    635 /*****************************************************************************
    636  * Name      : DWORD HMDeviceOpen32Class::LockFile
    637  * Purpose   : file locking
    638  * Parameters: PHMHANDLEDATA pHMHandleData
    639  *             DWORD arg2
    640  *             DWORD arg3
    641  *             DWORD arg4
    642  *             DWORD arg5
    643  * Variables :
    644  * Result    : API returncode
    645  * Remark    :
    646  * Status    :
    647  *
    648  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    649  *****************************************************************************/
    650 
    651 DWORD HMDeviceOpen32Class::LockFile(PHMHANDLEDATA pHMHandleData,
    652                                     DWORD         arg2,
    653                                     DWORD         arg3,
    654                                     DWORD         arg4,
    655                                     DWORD         arg5)
    656 {
    657   dprintfl(("KERNEL32: HandleManager::Open32::LockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    658            lpHMDeviceName,
    659            pHMHandleData,
    660            arg2,
    661            arg3,
    662            arg4,
    663            arg5));
    664 
    665   return O32_LockFile(pHMHandleData->hHMHandle,
    666                       arg2,
    667                       arg3,
    668                       arg4,
    669                       arg5);
    670 }
    671 
    672 
    673 
    674 /*****************************************************************************
    675  * Name      : DWORD HMDeviceOpen32Class::LockFileEx
    676  * Purpose   : file locking
    677  * Parameters: PHMHANDLEDATA pHMHandleData
    678  *             DWORD dwFlags
    679  *             DWORD dwReserved
    680  *             DWORD nNumberOfBytesToLockLow
    681  *             DWORD nNumberOfBytesToLockHigh
    682  *             LPOVERLAPPED lpOverlapped
    683  * Variables :
    684  * Result    : API returncode
    685  * Remark    :
    686  * Status    :
    687  *
    688  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    689  *****************************************************************************/
    690 
    691 DWORD HMDeviceOpen32Class::LockFileEx(PHMHANDLEDATA pHMHandleData,
    692                                       DWORD         dwFlags,
    693                                       DWORD         dwReserved,
    694                                       DWORD         nNumberOfBytesToLockLow,
    695                                       DWORD         nNumberOfBytesToLockHigh,
    696                                       LPOVERLAPPED  lpOverlapped)
    697 {
    698 
    699   dprintfl(("KERNEL32: HandleManager::Open32::LockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    700            lpHMDeviceName,
    701            pHMHandleData,
    702            dwFlags,
    703            dwReserved,
    704            nNumberOfBytesToLockLow,
    705            nNumberOfBytesToLockHigh,
    706            lpOverlapped));
    707 
    708 
    709   return(O32_LockFile(pHMHandleData->hHMHandle,
    710                       lpOverlapped->Offset,
    711                       lpOverlapped->OffsetHigh,
    712                       nNumberOfBytesToLockLow,
    713                       nNumberOfBytesToLockHigh));
    714 }
    715 
    716 
    717 /*****************************************************************************
    718  * Name      : DWORD HMDeviceOpen32Class::OpenFile
    719  * Purpose   : this is called from the handle manager if a OpenFile() is
    720  *             performed on a handle
    721  * Parameters: LPCSTR        lpFileName            name of the file / device
    722  *             PHMHANDLEDATA pHMHandleData         data of the NEW handle
    723  *             PVOID         lpSecurityAttributes  ignored
    724  *             PHMHANDLEDATA pHMHandleDataTemplate data of the template handle
    725  * Variables :
    726  * Result    :
    727  * Remark    :
    728  * Status    : NO_ERROR - API succeeded
    729  *             other    - what is to be set in SetLastError
    730  *
    731  * Author    : Patrick Haller [Wed, 1998/02/11 20:44]
    732  *****************************************************************************/
    733 
    734 DWORD HMDeviceOpen32Class::OpenFile (LPCSTR        lpFileName,
    735                                      PHMHANDLEDATA pHMHandleData,
    736                                      OFSTRUCT      *pOFStruct,
    737                                      UINT          fuMode)
    738 {
    739   HFILE hFile;
    740   FILETIME filetime;
    741   WORD filedatetime[2];
    742   char filepath[260];
    743 
    744   dprintfl(("KERNEL32: HandleManager::Open32::OpenFile %s(%s,%08x,%08x,%08x) - stub?\n",
    745            lpHMDeviceName,
    746            lpFileName,
    747            pHMHandleData,
    748            pOFStruct,
    749            fuMode));
    750 
    751   if(strcmp(lpFileName,       // "support" for local unc names
    752              "\\\\.\\") == 0)
    753   {
    754     lpFileName+=4;
    755   }
    756   else
    757   if(!strchr(lpFileName, ':') && !strchr(lpFileName, '\\'))
    758   {
    759         //filename only; search for file in following order
    760         //1: dir from which the app loaded
    761         //2: current dir
    762         //3: windows system dir
    763         //4: windows dir
    764         //5: dirs in path path environment variable
    765         //SearchPath does exactly that
    766         LPSTR filenameinpath;
    767 
    768         if(SearchPathA(NULL, lpFileName, NULL, sizeof(filepath), filepath, &filenameinpath) == 0
    769            && !(fuMode & OF_CREATE) ) {
    770                 SetLastError(ERROR_FILE_NOT_FOUND);
    771                 return HFILE_ERROR;
    772         }
    773         lpFileName = filepath;
    774   }
    775   // filling OFSTRUCT
    776   memset(pOFStruct, 0, sizeof(OFSTRUCT));
    777   pOFStruct->cBytes = sizeof(OFSTRUCT);
    778   pOFStruct->nErrCode = 0;
    779   strncpy((char *)pOFStruct->szPathName, lpFileName, OFS_MAXPATHNAME - 1);
    780 
    781   hFile = O32_OpenFile(lpFileName,
    782                        pOFStruct,
    783                        fuMode);
    784   if (hFile != INVALID_HANDLE_ERROR)
    785   {
    786     pHMHandleData->hHMHandle = hFile;
    787 
    788     GetFileTime(pHMHandleData,
    789                 NULL,
    790                 NULL,
    791                 &filetime );
    792     FileTimeToDosDateTime(&filetime,
    793                           &filedatetime[0],
    794                           &filedatetime[1] );
    795     memcpy(pOFStruct->reserved,
    796            filedatetime,
    797            sizeof(pOFStruct->reserved) );
    798 
    799     return (NO_ERROR);
    800   }
    801 
    802   // error branch
    803   pOFStruct->nErrCode = O32_GetLastError();
    804   dprintf(("KERNEL32: HandleManager::Open32::OpenFile Error %08xh\n",
    805             pOFStruct->nErrCode));
    806 
    807   // return != NO_ERROR => error code
    808   return(hFile);
    809 }
    810 
    811 
    812 /*****************************************************************************
    813  * Name      : DWORD HMDeviceOpen32Class::UnlockFile
    814  * Purpose   : file locking
    815  * Parameters: PHMHANDLEDATA pHMHandleData
    816  *             DWORD arg2
    817  *             DWORD arg3
    818  *             DWORD arg4
    819  *             DWORD arg5
    820  * Variables :
    821  * Result    : API returncode
    822  * Remark    :
    823  * Status    :
    824  *
    825  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    826  *****************************************************************************/
    827 
    828 DWORD HMDeviceOpen32Class::UnlockFile(PHMHANDLEDATA pHMHandleData,
    829                                       DWORD         arg2,
    830                                       DWORD         arg3,
    831                                       DWORD         arg4,
    832                                       DWORD         arg5)
    833 {
    834   dprintfl(("KERNEL32: HandleManager::Open32::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    835            lpHMDeviceName,
    836            pHMHandleData,
    837            arg2,
    838            arg3,
    839            arg4,
    840            arg5));
    841 
    842   return O32_UnlockFile(pHMHandleData->hHMHandle,
    843                         arg2,
    844                         arg3,
    845                         arg4,
    846                         arg5);
    847 }
    848 
    849 
    850 
    851 /*****************************************************************************
    852  * Name      : DWORD HMDeviceOpen32Class::UnlockFileEx
    853  * Purpose   : file locking
    854  * Parameters: PHMHANDLEDATA pHMHandleData
    855  *             DWORD dwFlags
    856  *             DWORD dwReserved
    857  *             DWORD nNumberOfBytesToLockLow
    858  *             DWORD nNumberOfBytesToLockHigh
    859  *             LPOVERLAPPED lpOverlapped
    860  * Variables :
    861  * Result    : API returncode
    862  * Remark    :
    863  * Status    :
    864  *
    865  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    866  *****************************************************************************/
    867 
    868 DWORD HMDeviceOpen32Class::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
    869                                         DWORD         dwFlags,
    870                                         DWORD         dwReserved,
    871                                         DWORD         nNumberOfBytesToLockLow,
    872                                         DWORD         nNumberOfBytesToLockHigh,
    873                                         LPOVERLAPPED  lpOverlapped)
    874 {
    875 
    876   dprintfl(("KERNEL32: HandleManager::Open32::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    877            lpHMDeviceName,
    878            pHMHandleData,
    879            dwFlags,
    880            dwReserved,
    881            nNumberOfBytesToLockLow,
    882            nNumberOfBytesToLockHigh,
    883            lpOverlapped));
    884 
    885   return(O32_UnlockFile(pHMHandleData->hHMHandle,
    886                    lpOverlapped->Offset,
    887                    lpOverlapped->OffsetHigh,
    888                    nNumberOfBytesToLockLow,
    889                    nNumberOfBytesToLockHigh));
    890 }
    891 
    892184
    893185/*****************************************************************************
    … …  
    955247}
    956248
    957 
    958 /*****************************************************************************
    959  * Name      : DWORD HMDeviceOpen32Class::FlushFileBuffers
    960  * Purpose   : flush the buffers of a file
    961  * Parameters: PHMHANDLEDATA pHMHandleData
    962  * Variables :
    963  * Result    : API returncode
    964  * Remark    :
    965  * Status    :
    966  *
    967  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    968  *****************************************************************************/
    969 
    970 BOOL HMDeviceOpen32Class::FlushFileBuffers(PHMHANDLEDATA pHMHandleData)
    971 {
    972   dprintfl(("KERNEL32: HandleManager::Open32:FlushFileBuffers(%08xh)\n",
    973             pHMHandleData->hHMHandle));
    974 
    975   return(O32_FlushFileBuffers(pHMHandleData->hHMHandle));
    976 }
    977 
    978 
    979 /*****************************************************************************
    980  * Name      : DWORD HMDeviceOpen32Class::GetOverlappedResult
    981  * Purpose   : asynchronus I/O
    982  * Parameters: PHMHANDLEDATA pHMHandleData
    983  *             LPOVERLAPPED  arg2
    984  *             LPDWORD       arg3
    985  *             BOOL          arg4
    986  * Variables :
    987  * Result    : API returncode
    988  * Remark    :
    989  * Status    :
    990  *
    991  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    992  *****************************************************************************/
    993 
    994 BOOL HMDeviceOpen32Class::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
    995                                               LPOVERLAPPED  arg2,
    996                                               LPDWORD       arg3,
    997                                               BOOL          arg4)
    998 {
    999   dprintfl(("KERNEL32: HandleManager::Open32::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh)\n",
    1000             pHMHandleData->hHMHandle,
    1001             arg2,
    1002             arg3,
    1003             arg4));
    1004 
    1005   return(O32_GetOverlappedResult(pHMHandleData->hHMHandle,
    1006                                  arg2,
    1007                                  arg3,
    1008                                  arg4));
    1009 }
    1010 
Note: See TracChangeset for help on using the changeset viewer.