Changeset 7549 for trunk/src/kernel32


Ignore:
Timestamp:
Dec 5, 2001, 3:16:38 PM (24 years ago)
Author:
sandervl
Message:

preliminary changes for new overlapped io framework

Location:
trunk/src/kernel32
Files:
2 added
33 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/Fileio.cpp

    r7518 r7549  
    1 /* $Id: Fileio.cpp,v 1.57 2001-12-01 19:26:40 sandervl Exp $ */
     1/* $Id: Fileio.cpp,v 1.58 2001-12-05 14:15:55 sandervl Exp $ */
    22
    33/*
    … …  
    663663                     dwLength,
    664664                     lpNumberOfBytesRead,
    665                      lpOverlapped));
     665                     lpOverlapped, NULL));
    666666}
    667667//******************************************************************************
    … …  
    679679      return TRUE;
    680680  }
    681   return (HMReadFileEx(hFile,
    682                        lpBuffer,
    683                        nNumberOfBytesToRead,
    684                        lpOverlapped, lpCompletionRoutine));
     681  return (HMReadFile(hFile,
     682                     lpBuffer,
     683                     nNumberOfBytesToRead, NULL,
     684                     lpOverlapped, lpCompletionRoutine));
    685685}
    686686//******************************************************************************
    … …  
    704704                      nrbytes,
    705705                      nrbyteswritten,
    706                       lpOverlapped));
     706                      lpOverlapped, NULL));
    707707}
    708708/*****************************************************************************
    … …  
    740740  }
    741741
    742   return (HMWriteFileEx(hFile,
    743                         (LPVOID)lpBuffer,
    744                         nNumberOfBytesToWrite,
    745                         lpOverlapped, lpCompletionRoutine));
     742  return (HMWriteFile(hFile,
     743                      (LPVOID)lpBuffer,
     744                      nNumberOfBytesToWrite, NULL,
     745                      lpOverlapped, lpCompletionRoutine));
    746746}
    747747//******************************************************************************

  • trunk/src/kernel32/HandleManager.cpp

    r7532 r7549  
    1 /* $Id: HandleManager.cpp,v 1.82 2001-12-03 12:13:06 sandervl Exp $ */
     1/* $Id: HandleManager.cpp,v 1.83 2001-12-05 14:15:56 sandervl Exp $ */
    22
    33/*
    … …  
    268268        TabWin32Handles[ulLoop].hmHandleData.dwUserData     = 0;
    269269        TabWin32Handles[ulLoop].hmHandleData.dwInternalType = HMTYPE_UNKNOWN;
     270        TabWin32Handles[ulLoop].hmHandleData.hWin32Handle   = (HANDLE)ulLoop;
    270271        TabWin32Handles[ulLoop].hmHandleData.lpDeviceData   = NULL;
    271272        handleMutex.leave();
    … …  
    845846  /* initialize the complete HMHANDLEDATA structure */
    846847  pHMHandleData = &TabWin32Handles[hHandle].hmHandleData;
    847   pHMHandleData->dwType     = FILE_TYPE_CHAR;
    848848  pHMHandleData->dwAccess   = 0;
    849849  pHMHandleData->dwShare    = 0;
    … …  
    916916  /* initialize the complete HMHANDLEDATA structure */
    917917  pHMHandleData                = &TabWin32Handles[iIndexNew].hmHandleData;
    918   pHMHandleData->dwType        = TabWin32Handles[srchandle].hmHandleData.dwType;
    919918  if (fdwOptions & DUPLICATE_SAME_ACCESS)
    920     pHMHandleData->dwAccess    = TabWin32Handles[srchandle].hmHandleData.dwAccess;
     919      pHMHandleData->dwAccess    = TabWin32Handles[srchandle].hmHandleData.dwAccess;
    921920  else
    922     pHMHandleData->dwAccess    = fdwAccess;
     921      pHMHandleData->dwAccess    = fdwAccess;
    923922
    924923  if((fdwOdinOptions & DUPLICATE_ACCESS_READWRITE) == DUPLICATE_ACCESS_READWRITE) {
    925   pHMHandleData->dwAccess = GENERIC_READ | GENERIC_WRITE;
     924      pHMHandleData->dwAccess = GENERIC_READ | GENERIC_WRITE;
    926925  }
    927926  else
    928927  if(fdwOdinOptions & DUPLICATE_ACCESS_READ) {
    929   pHMHandleData->dwAccess = GENERIC_READ;
     928      pHMHandleData->dwAccess = GENERIC_READ;
    930929  }
    931930
    932931  if(fdwOdinOptions & DUPLICATE_SHARE_READ) {
    933   pHMHandleData->dwShare = FILE_SHARE_READ;
     932      pHMHandleData->dwShare = FILE_SHARE_READ;
    934933  }
    935934  else
    936935  if(fdwOdinOptions & DUPLICATE_SHARE_DENYNONE) {
    937   pHMHandleData->dwShare = FILE_SHARE_READ | FILE_SHARE_WRITE;
     936      pHMHandleData->dwShare = FILE_SHARE_READ | FILE_SHARE_WRITE;
    938937  }
    939938  else  pHMHandleData->dwShare = TabWin32Handles[srchandle].hmHandleData.dwShare;
    … …  
    10691068  else
    10701069  {
    1071     HMHandleTemp.dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
    10721070    HMHandleTemp.dwAccess   = dwDesiredAccess;
    10731071    HMHandleTemp.dwShare    = dwShareMode;
    … …  
    10891087         sizeof(HMHANDLEDATA));
    10901088
    1091   rc = pDeviceHandler->CreateFile((HANDLE)iIndexNew, lpFileName,     /* call the device handler */
     1089  rc = pDeviceHandler->CreateFile(lpFileName,     /* call the device handler */
    10921090                                  &HMHandleTemp,
    10931091                                  lpSecurityAttributes,
    … …  
    12151213  }
    12161214
    1217 
    1218                            /* initialize the complete HMHANDLEDATA structure */
     1215  /* initialize the complete HMHANDLEDATA structure */
    12191216  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    1220   pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
    12211217
    12221218  FILE_ConvertOFMode(fuMode,                                 /* map OF_flags */
    … …  
    12311227  pHMHandleData->lpDeviceData  = pDevData;
    12321228
    1233       /* we've got to mark the handle as occupied here, since another device */
    1234                    /* could be created within the device handler -> deadlock */
    1235 
    1236           /* write appropriate entry into the handle table if open succeeded */
     1229  /* we've got to mark the handle as occupied here, since another device */
     1230  /* could be created within the device handler -> deadlock */
     1231
     1232  /* write appropriate entry into the handle table if open succeeded */
    12371233  TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
    12381234  TabWin32Handles[iIndexNew].pDeviceHandler         = pDeviceHandler;
    12391235
    1240   rc = pDeviceHandler->OpenFile  ((HANDLE)iIndexNew,  lpFileName,     /* call the device handler */
    1241                                   &TabWin32Handles[iIndexNew].hmHandleData,
    1242                                   pOFStruct,
    1243                                   fuMode);
     1236  rc = pDeviceHandler->OpenFile(lpFileName,     /* call the device handler */
     1237                                &TabWin32Handles[iIndexNew].hmHandleData,
     1238                                pOFStruct,
     1239                                fuMode);
    12441240
    12451241#ifdef DEBUG_LOCAL
    … …  
    13561352                DWORD        nNumberOfBytesToRead,
    13571353                LPDWORD      lpNumberOfBytesRead,
    1358                 LPOVERLAPPED lpOverlapped)
     1354                LPOVERLAPPED lpOverlapped,
     1355                LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    13591356{
    13601357  int       iIndex;                           /* index into the handle table */
    … …  
    13751372                                                nNumberOfBytesToRead,
    13761373                                                lpNumberOfBytesRead,
    1377                                                 lpOverlapped);
    1378 
    1379   return (fResult);                                   /* deliver return code */
    1380 }
    1381 /*****************************************************************************
    1382  * Name      : HANDLE  HMReadFileEx
    1383  * Purpose   : Wrapper for the ReadFileEx() API
    1384  * Parameters:
    1385  * Variables :
    1386  * Result    :
    1387  * Remark    :
    1388  * Status    :
    1389  *
    1390  * Author    : SvL
    1391  *****************************************************************************/
    1392 BOOL HMReadFileEx(HANDLE                     hFile,
    1393                   LPVOID                     lpBuffer,
    1394                   DWORD                      nNumberOfBytesToRead,
    1395                   LPOVERLAPPED               lpOverlapped,
    1396                   LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    1397 {
    1398   int       iIndex;                           /* index into the handle table */
    1399   BOOL      fResult;       /* result from the device handler's CloseHandle() */
    1400   PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
    1401 
    1402                                                           /* validate handle */
    1403   iIndex = _HMHandleQuery(hFile);                           /* get the index */
    1404   if (-1 == iIndex)                                               /* error ? */
    1405   {
    1406     SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
    1407     return (FALSE);                                        /* signal failure */
    1408   }
    1409 
    1410   pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
    1411   fResult = pHMHandle->pDeviceHandler->ReadFileEx(&pHMHandle->hmHandleData,
    1412                                                   lpBuffer,
    1413                                                   nNumberOfBytesToRead,
    1414                                                   lpOverlapped,
    1415                                                   lpCompletionRoutine);
     1374                                                lpOverlapped, lpCompletionRoutine);
    14161375
    14171376  return (fResult);                                   /* deliver return code */
    … …  
    14341393                 DWORD        nNumberOfBytesToWrite,
    14351394                 LPDWORD      lpNumberOfBytesWritten,
    1436                  LPOVERLAPPED lpOverlapped)
     1395                 LPOVERLAPPED lpOverlapped,
     1396                 LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    14371397{
    14381398  int       iIndex;                           /* index into the handle table */
    … …  
    14531413                                                 nNumberOfBytesToWrite,
    14541414                                                 lpNumberOfBytesWritten,
    1455                                                  lpOverlapped);
    1456 
    1457   return (fResult);                                   /* deliver return code */
    1458 }
    1459 
    1460 /*****************************************************************************
    1461  * Name      : HANDLE  HMWriteFileEx
    1462  * Purpose   : Wrapper for the WriteFileEx() API
    1463  * Parameters:
    1464  * Variables :
    1465  * Result    :
    1466  * Remark    :
    1467  * Status    :
    1468  *
    1469  * Author    : SvL
    1470  *****************************************************************************/
    1471 BOOL HMWriteFileEx(HANDLE                     hFile,
    1472                    LPVOID                     lpBuffer,
    1473                    DWORD                      nNumberOfBytesToWrite,
    1474                    LPOVERLAPPED               lpOverlapped,
    1475                    LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    1476 {
    1477   int       iIndex;                           /* index into the handle table */
    1478   BOOL      fResult;       /* result from the device handler's CloseHandle() */
    1479   PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
    1480 
    1481                                                           /* validate handle */
    1482   iIndex = _HMHandleQuery(hFile);                           /* get the index */
    1483   if (-1 == iIndex)                                               /* error ? */
    1484   {
    1485     SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
    1486     return (FALSE);                                        /* signal failure */
    1487   }
    1488 
    1489   pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
    1490   fResult = pHMHandle->pDeviceHandler->WriteFileEx(&pHMHandle->hmHandleData,
    1491                                                    lpBuffer,
    1492                                                    nNumberOfBytesToWrite,
    1493                                                    lpOverlapped,
    1494                                                    lpCompletionRoutine);
     1415                                                 lpOverlapped, lpCompletionRoutine);
    14951416
    14961417  return (fResult);                                   /* deliver return code */
    … …  
    23462267  /* Initialize the complete HMHANDLEDATA structure */
    23472268  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    2348   pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
    23492269  pHMHandleData->dwAccess   = 0;
    23502270  pHMHandleData->dwShare    = 0;
    … …  
    24242344                           /* initialize the complete HMHANDLEDATA structure */
    24252345  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    2426   pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
    24272346  pHMHandleData->dwAccess   = 0;
    24282347  pHMHandleData->dwShare    = 0;
    … …  
    24922411                           /* initialize the complete HMHANDLEDATA structure */
    24932412  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    2494   pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
    24952413  pHMHandleData->dwAccess   = fdwAccess;
    24962414  pHMHandleData->dwShare    = 0;
    … …  
    25592477                           /* initialize the complete HMHANDLEDATA structure */
    25602478  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    2561   pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
    25622479  pHMHandleData->dwAccess   = fdwAccess;
    25632480  pHMHandleData->dwShare    = 0;
    … …  
    26362553                           /* initialize the complete HMHANDLEDATA structure */
    26372554  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    2638   pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
    26392555  pHMHandleData->dwAccess   = 0;
    26402556  pHMHandleData->dwShare    = 0;
    … …  
    27052621                           /* initialize the complete HMHANDLEDATA structure */
    27062622  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    2707   pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
    27082623  pHMHandleData->dwAccess   = fdwAccess;
    27092624  pHMHandleData->dwShare    = 0;
    … …  
    28122727                           /* initialize the complete HMHANDLEDATA structure */
    28132728  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    2814   pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
    28152729  pHMHandleData->dwAccess   = 0;
    28162730  pHMHandleData->dwShare    = 0;
    … …  
    28902804  /* initialize the complete HMHANDLEDATA structure */
    28912805  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    2892   pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
    28932806  pHMHandleData->dwAccess   = fdwAccess;
    28942807  pHMHandleData->dwShare    = 0;
    … …  
    38783791  /* initialize the complete HMHANDLEDATA structure */
    38793792  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    3880   pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
    38813793  pHMHandleData->dwAccess   = DesiredAccess;
    38823794  pHMHandleData->dwShare    = 0;
    … …  
    39463858  /* initialize the complete HMHANDLEDATA structure */
    39473859  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    3948   pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
    39493860  pHMHandleData->dwAccess   = DesiredAccess;
    39503861  pHMHandleData->dwShare    = 0;
    … …  
    40183929  /* initialize the complete HMHANDLEDATA structure */
    40193930  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    4020   pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;      /* unknown handle type */
    40213931  pHMHandleData->dwAccess   = 0;
    40223932  pHMHandleData->dwShare    = 0;
    … …  
    44114321  /* initialize the complete HMHANDLEDATA structure */
    44124322  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    4413   pHMHandleData->dwType     = FILE_TYPE_PIPE;
    44144323  pHMHandleData->dwAccess   = 0;
    44154324  pHMHandleData->dwShare    = 0;
    … …  
    47214630  /* initialize the complete HMHANDLEDATA structure */
    47224631  pHMHandleData = &TabWin32Handles[iIndexNewRead].hmHandleData;
    4723   pHMHandleData->dwType     = FILE_TYPE_PIPE;
    47244632  pHMHandleData->dwAccess   = 0;
    47254633  pHMHandleData->dwShare    = 0;
    … …  
    47374645  /* initialize the complete HMHANDLEDATA structure */
    47384646  pHMHandleData = &TabWin32Handles[iIndexNewWrite].hmHandleData;
    4739   pHMHandleData->dwType     = FILE_TYPE_PIPE;
    47404647  pHMHandleData->dwAccess   = 0;
    47414648  pHMHandleData->dwShare    = 0;
    … …  
    48044711  /* initialize the complete HMHANDLEDATA structure */
    48054712  pHMHandleData = &TabWin32Handles[iIndexNew].hmHandleData;
    4806   pHMHandleData->dwType     = FILE_TYPE_UNKNOWN;
    48074713  pHMHandleData->dwAccess   = 0;
    48084714  pHMHandleData->dwShare    = 0;

  • trunk/src/kernel32/async.cpp

    r5308 r7549  
    1 /* $Id: async.cpp,v 1.10 2001-03-13 18:45:32 sandervl Exp $ */
     1/* $Id: async.cpp,v 1.11 2001-12-05 14:15:56 sandervl Exp $ */
    22
    33/*
    … …  
    1616 * Remark                                                                    *
    1717 *****************************************************************************
    18 
    19   ReadFileEx
    2018
    2119 */

  • trunk/src/kernel32/conbuffer.cpp

    r7457 r7549  
    1 /* $Id: conbuffer.cpp,v 1.15 2001-11-26 14:53:58 sandervl Exp $ */
     1/* $Id: conbuffer.cpp,v 1.16 2001-12-05 14:15:56 sandervl Exp $ */
    22
    33/*
    … …  
    9898 *****************************************************************************/
    9999
    100 DWORD HMDeviceConsoleBufferClass::CreateFile (HANDLE        hHandle,
    101                                               LPCSTR        lpFileName,
     100DWORD HMDeviceConsoleBufferClass::CreateFile (LPCSTR        lpFileName,
    102101                                              PHMHANDLEDATA pHMHandleData,
    103102                                              PVOID         lpSecurityAttributes,
    … …  
    115114#endif
    116115
    117   pHMHandleData->dwType = FILE_TYPE_CHAR;        /* we're a character device */
    118 
    119116  pHMHandleData->lpHandlerData = malloc ( sizeof(CONSOLEBUFFER) );
    120117
    … …  
    153150
    154151/*****************************************************************************
     152 * Name      : DWORD HMDeviceConsoleBufferClass::GetFileType
     153 * Purpose   : determine the handle type
     154 * Parameters: PHMHANDLEDATA pHMHandleData
     155 * Variables :
     156 * Result    : API returncode
     157 * Remark    :
     158 * Status    :
     159 *
     160 * Author    : Patrick Haller [Wed, 1998/02/11 20:44]
     161 *****************************************************************************/
     162
     163DWORD HMDeviceConsoleBufferClass::GetFileType(PHMHANDLEDATA pHMHandleData)
     164{
     165  dprintf(("KERNEL32: HMDeviceConsoleBufferClass::GetFileType %s(%08x)\n",
     166           lpHMDeviceName,
     167           pHMHandleData));
     168
     169  return FILE_TYPE_CHAR;
     170}
     171
     172/*****************************************************************************
    155173 * Name      :
    156174 * Purpose   :
    … …  
    205223                                           DWORD         nNumberOfBytesToRead,
    206224                                           LPDWORD       lpNumberOfBytesRead,
    207                                            LPOVERLAPPED  lpOverlapped)
     225                                           LPOVERLAPPED lpOverlapped,
     226                                           LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    208227{
    209228
    … …  
    239258                                            DWORD         nNumberOfBytesToWrite,
    240259                                            LPDWORD       lpNumberOfBytesWritten,
    241                                             LPOVERLAPPED  lpOverlapped)
     260                                            LPOVERLAPPED lpOverlapped,
     261                                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    242262{
    243263  PCONSOLEBUFFER pConsoleBuffer = (PCONSOLEBUFFER)pHMHandleData->lpHandlerData;
    … …  
    24992519                                                cchToWrite,
    25002520                                                lpcchWritten,
    2501                                                 NULL));
     2521                                                NULL, NULL));
    25022522}
    25032523
    … …  
    25502570                                             cchToWrite,
    25512571                                             lpcchWritten,
    2552                                              NULL);
     2572                                             NULL, NULL);
     2573
    25532574  // free memory again
    25542575  HEAP_free(pszAscii);

  • trunk/src/kernel32/conbuffer.h

    r7457 r7549  
    1 /* $Id: conbuffer.h,v 1.4 2001-11-26 14:53:58 sandervl Exp $ */
     1/* $Id: conbuffer.h,v 1.5 2001-12-05 14:15:57 sandervl Exp $ */
    22
    33/*
    … …  
    5555
    5656                       /* this is a handler method for calls to CreateFile() */
    57   virtual DWORD  CreateFile (HANDLE        hHandle,
    58                              LPCSTR        lpFileName,
     57  virtual DWORD  CreateFile (LPCSTR        lpFileName,
    5958                             PHMHANDLEDATA pHMHandleData,
    6059                             PVOID         lpSecurityAttributes,
    … …  
    6665                             DWORD         nNumberOfBytesToRead,
    6766                             LPDWORD       lpNumberOfBytesRead,
    68                              LPOVERLAPPED  lpOverlapped);
     67                             LPOVERLAPPED lpOverlapped,
     68                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    6969
    7070                        /* this is a handler method for calls to WriteFile() */
    … …  
    7373                             DWORD         nNumberOfBytesToWrite,
    7474                             LPDWORD       lpNumberOfBytesWritten,
    75                              LPOVERLAPPED  lpOverlapped);
     75                             LPOVERLAPPED lpOverlapped,
     76                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
     77
     78  /* this is a handler method for calls to GetFileType() */
     79  virtual DWORD GetFileType (PHMHANDLEDATA pHMHandleData);
    7680
    7781  virtual DWORD  CloseHandle(PHMHANDLEDATA pHMHandleData);

  • trunk/src/kernel32/conbuffervio.cpp

    r6920 r7549  
    1 /* $Id: conbuffervio.cpp,v 1.4 2001-10-01 01:45:18 bird Exp $ */
     1/* $Id: conbuffervio.cpp,v 1.5 2001-12-05 14:15:57 sandervl Exp $ */
    22
    33/*
    … …  
    9797                                              DWORD         nNumberOfBytesToWrite,
    9898                                              LPDWORD       lpNumberOfBytesWritten,
    99                                               LPOVERLAPPED  lpOverlapped)
     99                                              LPOVERLAPPED lpOverlapped,
     100                                              LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    100101{
    101102  PCONSOLEBUFFER pConsoleBuffer = (PCONSOLEBUFFER)pHMHandleData->lpHandlerData;
    … …  
    136137        retcode = WriteFile(pHMHandleData, lpBuffer,
    137138                            min(nNumberOfBytesToWrite, 512), lpNumberOfBytesWritten,
    138                             lpOverlapped);
     139                            lpOverlapped, lpCompletionRoutine);
    139140        if(retcode != TRUE)     break;
    140141

  • trunk/src/kernel32/conbuffervio.h

    r4502 r7549  
    1 /* $Id: conbuffervio.h,v 1.1 2000-10-20 11:46:45 sandervl Exp $ */
     1/* $Id: conbuffervio.h,v 1.2 2001-12-05 14:15:57 sandervl Exp $ */
    22
    33/*
    … …  
    5454                             DWORD         nNumberOfBytesToWrite,
    5555                             LPDWORD       lpNumberOfBytesWritten,
    56                              LPOVERLAPPED  lpOverlapped);
     56                             LPOVERLAPPED  lpOverlapped,
     57                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    5758
    5859};

  • trunk/src/kernel32/conin.cpp

    r7457 r7549  
    1 /* $Id: conin.cpp,v 1.15 2001-11-26 14:53:58 sandervl Exp $ */
     1/* $Id: conin.cpp,v 1.16 2001-12-05 14:15:58 sandervl Exp $ */
    22
    33/*
    … …  
    6868 *****************************************************************************/
    6969
    70 DWORD HMDeviceConsoleInClass::CreateFile (HANDLE        hHandle,
    71                                           LPCSTR        lpFileName,
     70DWORD HMDeviceConsoleInClass::CreateFile (LPCSTR        lpFileName,
    7271                                          PHMHANDLEDATA pHMHandleData,
    7372                                          PVOID         lpSecurityAttributes,
    … …  
    8382#endif
    8483
    85   pHMHandleData->dwType = FILE_TYPE_CHAR;        /* we're a character device */
    86 
    8784  return(NO_ERROR);
    8885}
    8986
     87/*****************************************************************************
     88 * Name      : DWORD HMDeviceConsoleInClass::GetFileType
     89 * Purpose   : determine the handle type
     90 * Parameters: PHMHANDLEDATA pHMHandleData
     91 * Variables :
     92 * Result    : API returncode
     93 * Remark    :
     94 * Status    :
     95 *
     96 * Author    : Patrick Haller [Wed, 1998/02/11 20:44]
     97 *****************************************************************************/
     98
     99DWORD HMDeviceConsoleInClass::GetFileType(PHMHANDLEDATA pHMHandleData)
     100{
     101  dprintf(("KERNEL32: HMDeviceConsoleInClass::GetFileType %s(%08x)\n",
     102           lpHMDeviceName,
     103           pHMHandleData));
     104
     105  return FILE_TYPE_CHAR;
     106}
    90107
    91108/*****************************************************************************
    … …  
    102119
    103120BOOL HMDeviceConsoleInClass::ReadFile(PHMHANDLEDATA pHMHandleData,
    104                                        LPCVOID       lpBuffer,
    105                                        DWORD         nNumberOfBytesToRead,
    106                                        LPDWORD       lpNumberOfBytesRead,
    107                                        LPOVERLAPPED  lpOverlapped)
     121                                      LPCVOID       lpBuffer,
     122                                      DWORD         nNumberOfBytesToRead,
     123                                      LPDWORD       lpNumberOfBytesRead,
     124                                      LPOVERLAPPED  lpOverlapped,
     125                                      LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
    108126{
    109127  ULONG  ulCounter;                  /* character counter for the queue loop */
    … …  
    190208                        2,
    191209                        &ulPostCounter,                      /* dummy result */
    192                         NULL);
     210                        NULL, NULL);
    193211
    194212                }
    … …  
    208226                        1,
    209227                        &ulPostCounter,                      /* dummy result */
    210                         NULL);
     228                        NULL, NULL);
    211229                }
    212230                break;
    … …  
    227245                        1,
    228246                        &ulPostCounter,                      /* dummy result */
    229                         NULL);
    230 
    231 
     247                        NULL, NULL);
    232248            }
    233249          }
    … …  
    248264                        1,
    249265                        &ulPostCounter,                      /* dummy result */
    250                         NULL);
     266                        NULL, NULL);
    251267          }
    252268
    … …  
    283299                                        DWORD         nNumberOfBytesToWrite,
    284300                                        LPDWORD       lpNumberOfBytesWritten,
    285                                         LPOVERLAPPED  lpOverlapped)
     301                                        LPOVERLAPPED  lpOverlapped,
     302                                        LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    286303{
    287304
    … …  
    695712                                           cchToRead,
    696713                                           lpcchRead,
    697                                            NULL));
    698 }
    699 
     714                                           NULL, NULL));
     715}
    700716
    701717/*****************************************************************************
    … …  
    744760                                              cchToRead,
    745761                                              lpcchRead,
    746                                               NULL);
     762                                              NULL, NULL);
     763
    747764  /* Ascii -> unicode translation */
    748765  if (dwResult == TRUE)
    … …  
    979996
    980997
    981 DWORD HMDeviceConsoleInClass::GetFileType (PHMHANDLEDATA pHMHandleData)
    982 {
    983    return FILE_TYPE_CHAR;
    984 }

  • trunk/src/kernel32/conin.h

    r7457 r7549  
    1 /* $Id: conin.h,v 1.4 2001-11-26 14:53:59 sandervl Exp $ */
     1/* $Id: conin.h,v 1.5 2001-12-05 14:15:58 sandervl Exp $ */
    22
    33/*
    … …  
    5656
    5757                       /* this is a handler method for calls to CreateFile() */
    58   virtual DWORD  CreateFile (HANDLE        hHandle,
    59                              LPCSTR        lpFileName,
     58  virtual DWORD  CreateFile (LPCSTR        lpFileName,
    6059                             PHMHANDLEDATA pHMHandleData,
    6160                             PVOID         lpSecurityAttributes,
    … …  
    6766                             DWORD         nNumberOfBytesToRead,
    6867                             LPDWORD       lpNumberOfBytesRead,
    69                              LPOVERLAPPED  lpOverlapped);
     68                             LPOVERLAPPED  lpOverlapped,
     69                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    7070
    7171                        /* this is a handler method for calls to WriteFile() */
    … …  
    7474                             DWORD         nNumberOfBytesToWrite,
    7575                             LPDWORD       lpNumberOfBytesWritten,
    76                              LPOVERLAPPED  lpOverlapped);
     76                             LPOVERLAPPED  lpOverlapped,
     77                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
     78
     79  /* this is a handler method for calls to GetFileType() */
     80  virtual DWORD GetFileType (PHMHANDLEDATA pHMHandleData);
    7781
    7882  virtual DWORD  _DeviceRequest (PHMHANDLEDATA pHMHandleData,
    … …  
    140144                                    LPDWORD       lpcWritten);
    141145
    142                       /* this is a handler method for calls to GetFileType() */
    143   virtual DWORD GetFileType (PHMHANDLEDATA pHMHandleData);
    144 
    145146};
    146147

  • trunk/src/kernel32/conout.cpp

    r7476 r7549  
    1 /* $Id: conout.cpp,v 1.12 2001-11-29 00:20:46 phaller Exp $ */
     1/* $Id: conout.cpp,v 1.13 2001-12-05 14:15:58 sandervl Exp $ */
    22
    33/*
    … …  
    9494 *****************************************************************************/
    9595
    96 DWORD HMDeviceConsoleOutClass::CreateFile (HANDLE        hHandle,
    97                                            LPCSTR        lpFileName,
     96DWORD HMDeviceConsoleOutClass::CreateFile (LPCSTR        lpFileName,
    9897                                           PHMHANDLEDATA pHMHandleData,
    9998                                           PVOID         lpSecurityAttributes,
    … …  
    103102  HANDLE hConsole;
    104103
    105 #ifdef DEBUG_LOCAL2
    106   WriteLog("KERNEL32/CONSOLE:HMDeviceConsoleOutClass %s(%s,%08x,%08x,%08x)\n",
     104  dprintf(("KERNEL32/CONSOLE:HMDeviceConsoleOutClass %s(%s,%08x,%08x,%08x)\n",
    107105           lpHMDeviceName,
    108106           lpFileName,
    109107           pHMHandleData->hHMHandle,
    110108           lpSecurityAttributes,
    111            pHMHandleDataTemplate);
    112 #endif
    113 
    114   pHMHandleData->dwType = FILE_TYPE_CHAR;        /* we're a character device */
    115 
    116 
    117                  /* if no default buffer is available, then do default setup */
     109           pHMHandleDataTemplate));
     110
     111
     112  /* if no default buffer is available, then do default setup */
    118113  if (pConsoleGlobals->hConsoleBuffer == INVALID_HANDLE_VALUE)
    119114  {
    … …  
    126121    if (hConsole == INVALID_HANDLE_VALUE)
    127122    {
    128 #ifdef DEBUG_LOCAL
    129       WriteLog("KERNEL32/CONSOLE:OS2CreateConsoleScreenBuffer = %u.\n",
    130                GetLastError());
    131 #endif
     123      dprintf(("KERNEL32/CONSOLE:OS2CreateConsoleScreenBuffer = %u.\n",
     124               GetLastError()));
    132125      return INVALID_HANDLE_VALUE;   /* abort further processing immediately */
    133126    }
    … …  
    145138    if (fResult == FALSE)
    146139    {
    147 #ifdef DEBUG_LOCAL
    148       WriteLog("KERNEL32/CONSOLE:OS2SetConsoleScreenBufferSize=%u.\n",
    149                GetLastError());
    150 #endif
     140      dprintf(("KERNEL32/CONSOLE:OS2SetConsoleScreenBufferSize=%u.\n",
     141               GetLastError()));
    151142      HMCloseHandle(hConsole);                          /* free handle again */
    152143      return (INVALID_HANDLE_VALUE);            /* abort further processing */
    … …  
    156147    if (fResult == FALSE)
    157148    {
    158 #ifdef DEBUG_LOCAL
    159       WriteLog("KERNEL32/CONSOLE:OS2SetConsoleActiveScreenBuffer=%u.\n",
    160                GetLastError());
    161 #endif
     149      dprintf(("KERNEL32/CONSOLE:OS2SetConsoleActiveScreenBuffer=%u.\n",
     150               GetLastError()));
    162151      HMCloseHandle(hConsole);                          /* free handle again */
    163152      return (INVALID_HANDLE_VALUE);            /* abort further processing */
    … …  
    173162}
    174163
     164/*****************************************************************************
     165 * Name      : DWORD HMDeviceConsoleOutClass::GetFileType
     166 * Purpose   : determine the handle type
     167 * Parameters: PHMHANDLEDATA pHMHandleData
     168 * Variables :
     169 * Result    : API returncode
     170 * Remark    :
     171 * Status    :
     172 *
     173 * Author    : Patrick Haller [Wed, 1998/02/11 20:44]
     174 *****************************************************************************/
     175
     176DWORD HMDeviceConsoleOutClass::GetFileType(PHMHANDLEDATA pHMHandleData)
     177{
     178  dprintf(("KERNEL32: HMDeviceConsoleOutClass::GetFileType %s(%08x)\n",
     179           lpHMDeviceName,
     180           pHMHandleData));
     181
     182  return FILE_TYPE_CHAR;
     183}
    175184
    176185/*****************************************************************************
    … …  
    190199                                       DWORD         nNumberOfBytesToRead,
    191200                                       LPDWORD       lpNumberOfBytesRead,
    192                                        LPOVERLAPPED  lpOverlapped)
     201                                       LPOVERLAPPED  lpOverlapped,
     202                                       LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    193203{
    194204
    … …  
    224234                                         DWORD         nNumberOfBytesToWrite,
    225235                                         LPDWORD       lpNumberOfBytesWritten,
    226                                          LPOVERLAPPED  lpOverlapped)
     236                                         LPOVERLAPPED  lpOverlapped,
     237                                         LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    227238{
    228239  BOOL dwResult;                        /* result from subsequent WriteFile */
    … …  
    246257                           nNumberOfBytesToWrite,
    247258                           lpNumberOfBytesWritten,
    248                            lpOverlapped);
     259                           lpOverlapped, lpCompletionRoutine);
    249260
    250261    return (dwResult);                                 /* return result code */
    … …  
    300311
    301312
    302 DWORD HMDeviceConsoleOutClass::GetFileType (PHMHANDLEDATA pHMHandleData)
    303 {
    304    return FILE_TYPE_CHAR;
    305 }

  • trunk/src/kernel32/conout.h

    r7457 r7549  
    1 /* $Id: conout.h,v 1.3 2001-11-26 14:53:59 sandervl Exp $ */
     1/* $Id: conout.h,v 1.4 2001-12-05 14:15:58 sandervl Exp $ */
    22
    33/*
    … …  
    5454
    5555                       /* this is a handler method for calls to CreateFile() */
    56   virtual DWORD  CreateFile (HANDLE        hHandle,
    57                              LPCSTR        lpFileName,
     56  virtual DWORD  CreateFile (LPCSTR        lpFileName,
    5857                             PHMHANDLEDATA pHMHandleData,
    5958                             PVOID         lpSecurityAttributes,
    6059                             PHMHANDLEDATA pHMHandleDataTemplate);
     60
     61  /* this is a handler method for calls to GetFileType() */
     62  virtual DWORD GetFileType (PHMHANDLEDATA pHMHandleData);
    6163
    6264                           /* this is a handler method for calls to ReadFile() */
    … …  
    6567                             DWORD         nNumberOfBytesToRead,
    6668                             LPDWORD       lpNumberOfBytesRead,
    67                              LPOVERLAPPED  lpOverlapped);
     69                             LPOVERLAPPED  lpOverlapped,
     70                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    6871
    6972                        /* this is a handler method for calls to WriteFile() */
    … …  
    7275                             DWORD         nNumberOfBytesToWrite,
    7376                             LPDWORD       lpNumberOfBytesWritten,
    74                              LPOVERLAPPED  lpOverlapped);
     77                             LPOVERLAPPED  lpOverlapped,
     78                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    7579
    7680
    … …  
    8387                                ULONG         arg4);
    8488
    85                       /* this is a handler method for calls to GetFileType() */
    86   virtual DWORD GetFileType (PHMHANDLEDATA pHMHandleData);
    87 
    8889};
    8990

  • trunk/src/kernel32/dbglocal.cpp

    r7476 r7549  
    1 /* $Id: dbglocal.cpp,v 1.18 2001-11-29 00:20:47 phaller Exp $ */
     1/* $Id: dbglocal.cpp,v 1.19 2001-12-05 14:15:58 sandervl Exp $ */
    22
    33/*
    … …  
    126126"hmmailslot",
    127127"hmparport",
    128 "hmnul"
     128"hmnul",
     129"overlappedio"
    129130};
    130131//******************************************************************************

  • trunk/src/kernel32/dbglocal.h

    r7476 r7549  
    124124#define DBG_hmparport      104
    125125#define DBG_hmnul          105
    126 #define DBG_MAXFILES       106
     126#define DBG_overlappedio   106
     127#define DBG_MAXFILES       107
    127128
    128129extern USHORT DbgEnabledKERNEL32[DBG_MAXFILES];

  • trunk/src/kernel32/hmcomm.cpp

    r7543 r7549  
    1 /* $Id: hmcomm.cpp,v 1.25 2001-12-04 16:11:25 sandervl Exp $ */
     1/* $Id: hmcomm.cpp,v 1.26 2001-12-05 14:15:59 sandervl Exp $ */
    22
    33/*
    … …  
    6161#define BaudTableSize (sizeof(BaudTable)/sizeof(BAUDTABLEENTRY))
    6262
    63 DWORD CALLBACK SerialCommThread(LPVOID lpThreadParam);
    64 
    6563//******************************************************************************
    6664//******************************************************************************
    … …  
    157155//******************************************************************************
    158156//******************************************************************************
    159 DWORD HMDeviceCommClass::CreateFile(HANDLE hComm,
    160                                     LPCSTR lpFileName,
     157DWORD HMDeviceCommClass::CreateFile(LPCSTR lpFileName,
    161158                                    PHMHANDLEDATA pHMHandleData,
    162159                                    PVOID lpSecurityAttributes,
    163160                                    PHMHANDLEDATA pHMHandleDataTemplate)
    164161{
    165  char comname[6];
     162 char  comname[6];
     163 DWORD ret = ERROR_SUCCESS;
    166164
    167165  dprintf(("HMComm: Serial communication port %s open request\n", lpFileName));
    … …  
    237235        DWORD         dwThreadId;
    238236
    239         pDevData->hEventSem = ::CreateEventA(NULL, TRUE, FALSE, NULL);
    240         pDevData->hThread   = ::CreateThread(NULL, 32*1024, SerialCommThread, (LPVOID)hComm, 0, &dwThreadId);
    241 
    242         if(!pDevData->hEventSem || !pDevData->hThread)
    243         {
    244             DebugInt3();
    245             if(pDevData->hEventSem) ::CloseHandle(pDevData->hEventSem);
    246             delete pHMHandleData->lpHandlerData;
    247             OSLibDosClose(pHMHandleData->hHMHandle);
    248             return ERROR_NOT_ENOUGH_MEMORY;
    249         }
    250237    }
    251238    return ERROR_SUCCESS;
    … …  
    253240  else
    254241    return ERROR_ACCESS_DENIED;
     242
     243
     244fail:
     245
     246  delete pHMHandleData->lpHandlerData;
     247  OSLibDosClose(pHMHandleData->hHMHandle);
     248  return ret;
     249}
     250/*****************************************************************************
     251 * Name      : DWORD HMDeviceCommClass::GetFileType
     252 * Purpose   : determine the handle type
     253 * Parameters: PHMHANDLEDATA pHMHandleData
     254 * Variables :
     255 * Result    : API returncode
     256 * Remark    :
     257 * Status    :
     258 *
     259 * Author    : SvL
     260 *****************************************************************************/
     261
     262DWORD HMDeviceCommClass::GetFileType(PHMHANDLEDATA pHMHandleData)
     263{
     264  dprintf(("KERNEL32: HMDeviceCommClass::GetFileType %s(%08x)\n",
     265           lpHMDeviceName,
     266           pHMHandleData));
     267
     268  return FILE_TYPE_CHAR;
    255269}
    256270//******************************************************************************
    … …  
    263277  if(pDevData && pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)
    264278  {
    265       pDevData->fClosing = TRUE;
    266       dprintf(("signalling serial thread"));
    267       ::SetEvent(pDevData->hEventSem);
    268       ::ResetEvent(pDevData->hEventSem);
    269 
    270       //Wait for thread to clean up
    271       dprintf(("waiting for serial thread"));
    272       DWORD ret = ::WaitForSingleObject(pDevData->hEventSem, 200);
    273       dprintf(("waiting for serial thread done -> %x", ret));
    274       ::CloseHandle(pDevData->hEventSem);
     279      DebugInt3();
    275280  }
    276281  delete pHMHandleData->lpHandlerData;
    … …  
    296301                                  DWORD         nNumberOfBytesToWrite,
    297302                                  LPDWORD       lpNumberOfBytesWritten,
    298                                   LPOVERLAPPED  lpOverlapped)
     303                                  LPOVERLAPPED  lpOverlapped,
     304                                  LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    299305{
    300306  dprintf(("KERNEL32:HMDeviceCommClass::WriteFile %s(%08x,%08x,%08x,%08x,%08x)",
    … …  
    318324  }
    319325//testestestest
    320   dprintf(("Bytes to write:"));
     326  dprintf2(("Bytes to write:"));
    321327  for(int i=0;i<nNumberOfBytesToWrite;i++) {
    322           dprintf(("%x %c", ((char *)lpBuffer)[i], ((char *)lpBuffer)[i]));
     328          dprintf2(("%x %c", ((char *)lpBuffer)[i], ((char *)lpBuffer)[i]));
    323329  }
    324330//testestestset
    … …  
    336342
    337343  return ret;
    338 }
    339 /*****************************************************************************
    340  * Name      : BOOL WriteFileEx
    341  * Purpose   : The WriteFileEx function writes data to a file. It is designed
    342  *             solely for asynchronous operation, unlike WriteFile, which is
    343  *             designed for both synchronous and asynchronous operation.
    344  *             WriteFileEx reports its completion status asynchronously,
    345  *             calling a specified completion routine when writing is completed
    346  *             and the calling thread is in an alertable wait state.
    347  * Parameters: HANDLE       hFile                handle of file to write
    348  *             LPVOID       lpBuffer             address of buffer
    349  *             DWORD        nNumberOfBytesToRead number of bytes to write
    350  *             LPOVERLAPPED lpOverlapped         address of offset
    351  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    352  * Variables :
    353  * Result    : TRUE / FALSE
    354  * Remark    :
    355  * Status    : UNTESTED STUB
    356  *
    357  * Author    : SvL
    358  *****************************************************************************/
    359 
    360 BOOL HMDeviceCommClass::WriteFileEx(PHMHANDLEDATA pHMHandleData,
    361                            LPVOID       lpBuffer,
    362                            DWORD        nNumberOfBytesToWrite,
    363                            LPOVERLAPPED lpOverlapped,
    364                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    365 {
    366   dprintf(("!ERROR!: WriteFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    367            lpHMDeviceName,
    368            pHMHandleData->hHMHandle,
    369            lpBuffer,
    370            nNumberOfBytesToWrite,
    371            lpOverlapped,
    372            lpCompletionRoutine));
    373 
    374   if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)) {
    375       dprintf(("!WARNING!: Handle not created with FILE_FLAG_OVERLAPPED!"));
    376       ::SetLastError(ERROR_ACCESS_DENIED); //todo: right error?
    377       return FALSE;
    378   }
    379 
    380   ::SetLastError(ERROR_INVALID_FUNCTION);
    381   return FALSE;
    382344}
    383345/*****************************************************************************
    … …  
    401363                                 DWORD         nNumberOfBytesToRead,
    402364                                 LPDWORD       lpNumberOfBytesRead,
    403                                  LPOVERLAPPED  lpOverlapped)
     365                                 LPOVERLAPPED  lpOverlapped,
     366                                 LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    404367{
    405368  dprintf(("KERNEL32:HMDeviceCommClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x)",
    … …  
    444407  else {
    445408//testestestest
    446       dprintf(("Bytes read:"));
     409      dprintf2(("%d Bytes read:", ulBytesRead));
    447410      for(int i=0;i<ulBytesRead;i++) {
    448           dprintf(("%x %c", ((char *)lpBuffer)[i], ((char *)lpBuffer)[i]));
     411          dprintf2(("%x %c", ((char *)lpBuffer)[i], ((char *)lpBuffer)[i]));
    449412      }
    450413//testestestset
    … …  
    453416}
    454417
    455 /*****************************************************************************
    456  * Name      : BOOL ReadFileEx
    457  * Purpose   : The ReadFileEx function reads data from a file asynchronously.
    458  *             It is designed solely for asynchronous operation, unlike the
    459  *             ReadFile function, which is designed for both synchronous and
    460  *             asynchronous operation. ReadFileEx lets an application perform
    461  *             other processing during a file read operation.
    462  *             The ReadFileEx function reports its completion status asynchronously,
    463  *             calling a specified completion routine when reading is completed
    464  *             and the calling thread is in an alertable wait state.
    465  * Parameters: HANDLE       hFile                handle of file to read
    466  *             LPVOID       lpBuffer             address of buffer
    467  *             DWORD        nNumberOfBytesToRead number of bytes to read
    468  *             LPOVERLAPPED lpOverlapped         address of offset
    469  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    470  * Variables :
    471  * Result    : TRUE / FALSE
    472  * Remark    :
    473  * Status    : UNTESTED STUB
    474  *
    475  * Author    : SvL
    476  *****************************************************************************/
    477 BOOL HMDeviceCommClass::ReadFileEx(PHMHANDLEDATA pHMHandleData,
    478                                    LPVOID       lpBuffer,
    479                                    DWORD        nNumberOfBytesToRead,
    480                                    LPOVERLAPPED lpOverlapped,
    481                                    LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    482 {
    483   dprintf(("!ERROR!: ReadFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    484            lpHMDeviceName,
    485            pHMHandleData->hHMHandle,
    486            lpBuffer,
    487            nNumberOfBytesToRead,
    488            lpOverlapped,
    489            lpCompletionRoutine));
    490 
    491   if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)) {
    492       dprintf(("!WARNING!: Handle not created with FILE_FLAG_OVERLAPPED!"));
    493       ::SetLastError(ERROR_ACCESS_DENIED); //todo: right error?
    494       return FALSE;
    495   }
    496 
    497   ::SetLastError(ERROR_INVALID_FUNCTION);
    498   return FALSE;
    499 }
    500418/*****************************************************************************
    501419 * Name      : DWORD HMDeviceHandler::SetupComm
    … …  
    526444}
    527445//******************************************************************************
    528 #define TIMEOUT_COMM  50
    529 //******************************************************************************
    530 DWORD CALLBACK SerialCommThread(LPVOID lpThreadParam)
    531 {
    532   HANDLE        hComm = (HANDLE)lpThreadParam;
    533   PHMHANDLEDATA pHMHandleData;
    534   PHMDEVCOMDATA pDevData;
    535   DWORD         ret;
    536   APIRET        rc;
    537   ULONG         ulLen;
    538   USHORT        COMEvt;
    539   DWORD         dwEvent,dwMask;
    540 
    541   pHMHandleData = HMQueryHandleData(hComm);
    542   if(!pHMHandleData) {
    543       dprintf(("!ERROR!: Invalid handle -> aborting"));
    544       return 0;
    545   }
    546 
    547   pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
    548   if(!pDevData) {
    549       dprintf(("!ERROR! SerialCommThread !pDevData"));
    550       DebugInt3();
    551       return 0;
    552   }
    553   HANDLE hEvent   = pDevData->hEventSem;
    554   HANDLE hCommOS2 = pHMHandleData->hHMHandle;
    555   if(!hCommOS2 || !hEvent) {
    556       dprintf(("!ERROR! SerialCommThread !hCommOS2 || !hEvent"));
    557       DebugInt3();
    558       return 0;
    559   }
    560   dprintf(("SerialCommThread %x entered", hComm));
    561 
    562   SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
    563   while(TRUE)
    564   {
    565       //validate handle
    566       pHMHandleData = HMQueryHandleData(hComm);
    567       if(!pHMHandleData) {
    568           dprintf(("!ERROR!: Invalid handle -> aborting"));
    569           return 0;
    570       }
    571       if(pDevData->fClosing) {
    572           dprintf(("Cleaning up async comm thread"));
    573           SetEvent(hEvent); //signal to CloseHandle that we're done
    574           return 0;
    575       }
    576 
    577       //Wait for the app to call WaitCommEvent
    578       dprintf(("SerialCommThread: wait for WaitCommEvent"));
    579       ret = WaitForSingleObject(hEvent, INFINITE);
    580       ResetEvent(hEvent);
    581       dprintf(("SerialCommThread: wait for WaitCommEvent done %x", ret));
    582 
    583       //validate handle first
    584       pHMHandleData = HMQueryHandleData(hComm);
    585       if(!pHMHandleData) {
    586           dprintf(("!ERROR!: Invalid handle -> aborting"));
    587           return 0;
    588       }
    589 
    590       if(pDevData->fClosing) {
    591           dprintf(("Cleaning up async comm thread"));
    592           SetEvent(hEvent); //signal to CloseHandle that we're done
    593           return 0;
    594       }
    595 
    596       HANDLE hOverlappedEvent = pDevData->overlapped.hEvent;
    597       if(!hOverlappedEvent) {
    598           DebugInt3();
    599           return 0;
    600       }
    601 
    602       ulLen   = sizeof(CHAR);
    603       dwEvent = 0;
    604       rc      = 0;
    605       ulLen   = sizeof(COMEvt);
    606       dwMask  = pDevData->dwEventMask;
    607 
    608       while( (0==rc) &&
    609             !(dwEvent & dwMask) &&
    610             (dwMask == pDevData->dwEventMask) &&
    611             !(pDevData->fCancelIo) && !(pDevData->fClosing) ) // Exit if the Mask gets changed
    612       {
    613           rc = OSLibDosDevIOCtl(hCommOS2,
    614                                 IOCTL_ASYNC,
    615                                 ASYNC_GETCOMMEVENT,
    616                                 0,0,0,
    617                                 &COMEvt,ulLen,&ulLen);
    618           if(!rc)
    619           {
    620               dwEvent |= (COMEvt&0x0001)? EV_RXCHAR:0;
    621               //dwEvent |= (COMEvt&0x0002)? 0:0;
    622               dwEvent |= (COMEvt&0x0004)? EV_TXEMPTY:0;
    623               dwEvent |= (COMEvt&0x0008)? EV_CTS:0;
    624               dwEvent |= (COMEvt&0x0010)? EV_DSR:0;
    625               //dwEvent |= (COMEvt&0x0020)? 0:0; DCS = RLSD?
    626               dwEvent |= (COMEvt&0x0040)? EV_BREAK:0;
    627               dwEvent |= (COMEvt&0x0080)? EV_ERR:0;
    628               dwEvent |= (COMEvt&0x0100)? EV_RING:0;
    629               if((dwEvent & dwMask)) break;
    630           }
    631           else break;
    632 
    633           //validate handle first
    634           pHMHandleData = HMQueryHandleData(hComm);
    635           if(!pHMHandleData) {
    636               dprintf(("!ERROR!: Invalid handle -> aborting"));
    637               return 0;
    638           }
    639 
    640           if(pDevData->fClosing) {
    641               dprintf(("Cleaning up async comm thread"));
    642               SetEvent(hEvent); //signal to CloseHandle that we're done
    643               return 0;
    644           }
    645 
    646           DosSleep(TIMEOUT_COMM);
    647       }
    648       if(pDevData->fClosing) {
    649           dprintf(("Cleaning up async comm thread"));
    650           SetEvent(hEvent); //signal to CloseHandle that we're done
    651           return 0;
    652       }
    653       else
    654       if(pDevData->fCancelIo) {
    655           pDevData->overlapped.Internal = 0;
    656           pDevData->dwLastError = ERROR_OPERATION_ABORTED;
    657           if(pDevData->lpfdwEvtMask) *pDevData->lpfdwEvtMask = 0;
    658           dprintf(("Overlapped: WaitCommEvent ERROR_OPERATION_ABORTED"));
    659 
    660           //signal to app that a comm event has occurred
    661           SetEvent(hOverlappedEvent);
    662       }
    663       else
    664       if((dwEvent & dwMask) && (dwMask == pDevData->dwEventMask)) {
    665           pDevData->overlapped.Internal |= (rc==0) ? (dwEvent & dwMask) : 0;
    666           pDevData->dwLastError = rc;
    667 
    668           //We're also supposed to write the result to the address supplied
    669           //by the call to WaitCommEvent
    670           if(pDevData->lpfdwEvtMask) *pDevData->lpfdwEvtMask = (rc==0) ? (dwEvent & dwMask) : 0;
    671           dprintf(("Overlapped: WaitCommEvent returned %x", pDevData->overlapped.Internal));
    672 
    673           //signal to app that a comm event has occurred
    674           SetEvent(hOverlappedEvent);
    675       }
    676   }
    677   return 0;
    678 }
    679 //******************************************************************************
     446#define TIMEOUT_COMM 50
    680447//******************************************************************************
    681448BOOL HMDeviceCommClass::WaitCommEvent( PHMHANDLEDATA pHMHandleData,
    … …  
    741508        ::ResetEvent(lpo->hEvent);
    742509
    743         //signal async comm thread to start polling comm status
    744         ::SetEvent(pDevData->hEventSem);
    745510        ::SetLastError(ERROR_IO_PENDING);
    746511        return FALSE;
    … …  
    779544    //signal serial thread to cancel pending IO operation
    780545    pDevData->fCancelIo = TRUE;
    781     ::SetEvent(pDevData->hEventSem);
     546//    ::SetEvent(pDevData->hEventSem);
    782547
    783548    ::SetLastError(ERROR_SUCCESS);
    … …  
    1187952  memcpy(&os2dcb,&pDevData->dcbOS2,sizeof(DCBINFO));
    1188953
    1189   fbTimeOut = 0x02;
     954  fbTimeOut = 0x02; //normal processing (wait until timout or buffer full)
    1190955  if(MAXDWORD==pDevData->CommTOuts.ReadIntervalTimeout)
    1191956  {
    1192957    if( (0==pDevData->CommTOuts.ReadTotalTimeoutMultiplier) &&
    1193958        (0==pDevData->CommTOuts.ReadTotalTimeoutConstant))
    1194       fbTimeOut = 0x05;
     959      fbTimeOut = 0x05; //no wait
    1195960    else
    1196       fbTimeOut = 0x04;
     961      fbTimeOut = 0x04; //wait for something
    1197962  }
    1198963  else
    … …  
    1200965    DWORD dwTimeout;
    1201966    dwTimeout = pDevData->CommTOuts.ReadIntervalTimeout/10;
    1202 #if 0
    1203967    if(dwTimeout)
    1204968      dwTimeout--; // 0=10 ms unit is 10ms or .01s
    1205 #endif
     969
    1206970    os2dcb.usWriteTimeout = 0x0000FFFF & dwTimeout;
    1207971    os2dcb.usReadTimeout  = 0x0000FFFF & dwTimeout;
    1208972  }
    1209   os2dcb.fbTimeOut = (os2dcb.fbTimeOut & 0xF9) | fbTimeOut;
     973  if( (0==pDevData->CommTOuts.WriteTotalTimeoutMultiplier) &&
     974      (0==pDevData->CommTOuts.WriteTotalTimeoutConstant))
     975  {//no timeout used for writing
     976    os2dcb.fbTimeOut |= 1; //write infinite timeout
     977  }
     978
     979  os2dcb.fbTimeOut = (os2dcb.fbTimeOut & 0xF8) | fbTimeOut;
    1210980
    1211981  dprintf((" New DCB:\n"

  • trunk/src/kernel32/hmcomm.h

    r7499 r7549  
    1 /* $Id: hmcomm.h,v 1.11 2001-11-30 13:52:32 sandervl Exp $ */
     1/* $Id: hmcomm.h,v 1.12 2001-12-05 14:15:59 sandervl Exp $ */
    22
    33/*
    … …  
    9090  DWORD dwInBuffer, dwOutBuffer;
    9191  DWORD dwEventMask;
    92   //overlapped IO info
    93   HANDLE     hThread;
    94   HANDLE     hEventSem;
    9592  OVERLAPPED overlapped;
    96   DWORD      dwLastError;
    97   DWORD     *lpfdwEvtMask;
    98   BOOL       fClosing;
    99   BOOL       fCancelIo;
     93  DWORD *lpfdwEvtMask;
     94  BOOL fCancelIo;
     95  DWORD dwLastError;
    10096  //OS/2 Device Control Block
    10197  DCBINFO dcbOS2;
    … …  
    130126
    131127  /* this is the handler method for calls to CreateFile() */
    132   virtual DWORD  CreateFile (HANDLE        hHandle,
    133                              LPCSTR        lpFileName,
     128  virtual DWORD  CreateFile (LPCSTR        lpFileName,
    134129                             PHMHANDLEDATA pHMHandleData,
    135130                             PVOID         lpSecurityAttributes,
    136131                             PHMHANDLEDATA pHMHandleDataTemplate);
     132
     133  /* this is a handler method for calls to GetFileType() */
     134  virtual DWORD GetFileType (PHMHANDLEDATA pHMHandleData);
    137135
    138136  /* this is the handler method for calls to CloseHandle() */
    … …  
    187185                                     LPDWORD lpdwSize);
    188186
    189                            /* this is a handler method for calls to ReadFile() */
     187  /* this is a handler method for calls to ReadFile/Ex */
    190188  virtual BOOL   ReadFile   (PHMHANDLEDATA pHMHandleData,
    191189                             LPCVOID       lpBuffer,
    192190                             DWORD         nNumberOfBytesToRead,
    193191                             LPDWORD       lpNumberOfBytesRead,
    194                              LPOVERLAPPED  lpOverlapped);
    195 
    196                         /* this is a handler method for calls to ReadFileEx() */
    197   virtual BOOL  ReadFileEx(PHMHANDLEDATA pHMHandleData,
    198                            LPVOID       lpBuffer,
    199                            DWORD        nNumberOfBytesToRead,
    200                            LPOVERLAPPED lpOverlapped,
    201                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    202 
    203                         /* this is a handler method for calls to WriteFile() */
     192                             LPOVERLAPPED  lpOverlapped,
     193                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
     194
     195  /* this is a handler method for calls to WriteFile/Ex */
    204196  virtual BOOL   WriteFile  (PHMHANDLEDATA pHMHandleData,
    205197                             LPCVOID       lpBuffer,
    206198                             DWORD         nNumberOfBytesToWrite,
    207199                             LPDWORD       lpNumberOfBytesWritten,
    208                              LPOVERLAPPED  lpOverlapped);
    209 
    210                         /* this is a handler method for calls to WriteFileEx() */
    211   virtual BOOL  WriteFileEx(PHMHANDLEDATA pHMHandleData,
    212                             LPVOID       lpBuffer,
    213                             DWORD        nNumberOfBytesToWrite,
    214                             LPOVERLAPPED lpOverlapped,
    215                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
     200                             LPOVERLAPPED  lpOverlapped,
     201                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    216202
    217203  virtual BOOL   CancelIo           (PHMHANDLEDATA pHMHandleData);

  • trunk/src/kernel32/hmdevice.cpp

    r7532 r7549  
    1 /* $Id: hmdevice.cpp,v 1.30 2001-12-03 12:13:08 sandervl Exp $ */
     1/* $Id: hmdevice.cpp,v 1.31 2001-12-05 14:15:59 sandervl Exp $ */
    22
    33/*
    … …  
    169169 *****************************************************************************/
    170170
    171 DWORD HMDeviceHandler::CreateFile (HANDLE        hHandle,
    172                                    LPCSTR        lpFileName,
     171DWORD HMDeviceHandler::CreateFile (LPCSTR        lpFileName,
    173172                                   PHMHANDLEDATA pHMHandleData,
    174173                                   PVOID         lpSecurityAttributes,
    … …  
    217216 *             LPDWORD       lpNumberOfBytesRead,
    218217 *             LPOVERLAPPED  lpOverlapped
     218 *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    219219 * Variables :
    220220 * Result    : Boolean
    … …  
    229229                               DWORD         nNumberOfBytesToRead,
    230230                               LPDWORD       lpNumberOfBytesRead,
    231                                LPOVERLAPPED  lpOverlapped)
    232 {
    233   dprintf(("KERNEL32:HandleManager::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
     231                               LPOVERLAPPED  lpOverlapped,
     232                               LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
     233{
     234  dprintf(("KERNEL32:HandleManager::ReadFile %s(%08x,%08x,%08x,%08x,%08x %08x) - stub?\n",
    234235           lpHMDeviceName,
    235236           pHMHandleData->hHMHandle,
    … …  
    237238           nNumberOfBytesToRead,
    238239           lpNumberOfBytesRead,
    239            lpOverlapped));
     240           lpOverlapped, lpCompletionRoutine));
    240241
    241242  SetLastError(ERROR_INVALID_FUNCTION);
    … …  
    243244}
    244245
    245 /*****************************************************************************
    246  * Name      : BOOL ReadFileEx
    247  * Purpose   : The ReadFileEx function reads data from a file asynchronously.
    248  *             It is designed solely for asynchronous operation, unlike the
    249  *             ReadFile function, which is designed for both synchronous and
    250  *             asynchronous operation. ReadFileEx lets an application perform
    251  *             other processing during a file read operation.
    252  *             The ReadFileEx function reports its completion status asynchronously,
    253  *             calling a specified completion routine when reading is completed
    254  *             and the calling thread is in an alertable wait state.
    255  * Parameters: HANDLE       hFile                handle of file to read
    256  *             LPVOID       lpBuffer             address of buffer
    257  *             DWORD        nNumberOfBytesToRead number of bytes to read
    258  *             LPOVERLAPPED lpOverlapped         address of offset
    259  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    260  * Variables :
    261  * Result    : TRUE / FALSE
    262  * Remark    :
    263  * Status    : UNTESTED STUB
    264  *
    265  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    266  *****************************************************************************/
    267 BOOL HMDeviceHandler::ReadFileEx(PHMHANDLEDATA pHMHandleData,
    268                            LPVOID       lpBuffer,
    269                            DWORD        nNumberOfBytesToRead,
    270                            LPOVERLAPPED lpOverlapped,
    271                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    272 {
    273   dprintf(("ERROR: ReadFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    274            lpHMDeviceName,
    275            pHMHandleData->hHMHandle,
    276            lpBuffer,
    277            nNumberOfBytesToRead,
    278            lpOverlapped,
    279            lpCompletionRoutine));
    280 
    281   SetLastError(ERROR_INVALID_FUNCTION);
    282   return FALSE;
    283 }
    284246
    285247/*****************************************************************************
    … …  
    291253 *             LPDWORD       lpNumberOfBytesWritten,
    292254 *             LPOVERLAPPED  lpOverlapped
     255 *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    293256 * Variables :
    294257 * Result    : Boolean
    … …  
    303266                                DWORD         nNumberOfBytesToWrite,
    304267                                LPDWORD       lpNumberOfBytesWritten,
    305                                 LPOVERLAPPED  lpOverlapped)
    306 {
    307   dprintf(("KERNEL32:HandleManager::WriteFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
     268                                LPOVERLAPPED  lpOverlapped,
     269                                LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
     270{
     271  dprintf(("KERNEL32:HandleManager::WriteFile %s(%08x,%08x,%08x,%08x,%08x,%08x) - stub?\n",
    308272           lpHMDeviceName,
    309273           pHMHandleData->hHMHandle,
    … …  
    311275           nNumberOfBytesToWrite,
    312276           lpNumberOfBytesWritten,
    313            lpOverlapped));
    314 
    315   SetLastError(ERROR_INVALID_FUNCTION);
    316   return FALSE;
    317 }
    318 
    319 
    320 /*****************************************************************************
    321  * Name      : BOOL WriteFileEx
    322  * Purpose   : The WriteFileEx function writes data to a file. It is designed
    323  *             solely for asynchronous operation, unlike WriteFile, which is
    324  *             designed for both synchronous and asynchronous operation.
    325  *             WriteFileEx reports its completion status asynchronously,
    326  *             calling a specified completion routine when writing is completed
    327  *             and the calling thread is in an alertable wait state.
    328  * Parameters: HANDLE       hFile                handle of file to write
    329  *             LPVOID       lpBuffer             address of buffer
    330  *             DWORD        nNumberOfBytesToRead number of bytes to write
    331  *             LPOVERLAPPED lpOverlapped         address of offset
    332  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    333  * Variables :
    334  * Result    : TRUE / FALSE
    335  * Remark    :
    336  * Status    : UNTESTED STUB
    337  *
    338  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    339  *****************************************************************************/
    340 
    341 BOOL HMDeviceHandler::WriteFileEx(PHMHANDLEDATA pHMHandleData,
    342                            LPVOID       lpBuffer,
    343                            DWORD        nNumberOfBytesToWrite,
    344                            LPOVERLAPPED lpOverlapped,
    345                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    346 {
    347   dprintf(("ERROR: WriteFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    348            lpHMDeviceName,
    349            pHMHandleData->hHMHandle,
    350            lpBuffer,
    351            nNumberOfBytesToWrite,
    352            lpOverlapped,
    353            lpCompletionRoutine));
     277           lpOverlapped, lpCompletionRoutine));
    354278
    355279  SetLastError(ERROR_INVALID_FUNCTION);
    … …  
    375299           pHMHandleData));
    376300
    377   return pHMHandleData->dwType;
     301  return FILE_TYPE_UNKNOWN;
    378302}
    379303
    … …  
    627551 *****************************************************************************/
    628552
    629 DWORD HMDeviceHandler::OpenFile (HANDLE        hHandle,
    630                                  LPCSTR        lpFileName,
     553DWORD HMDeviceHandler::OpenFile (LPCSTR        lpFileName,
    631554                                 PHMHANDLEDATA pHMHandleData,
    632555                                 OFSTRUCT      *pOFStruct,

  • trunk/src/kernel32/hmdevice.h

    r7532 r7549  
    1 /* $Id: hmdevice.h,v 1.31 2001-12-03 12:13:08 sandervl Exp $ */
     1/* $Id: hmdevice.h,v 1.32 2001-12-05 14:16:00 sandervl Exp $ */
    22
    33/*
    … …  
    3535#define HMTYPE_MUTEXSEM         8
    3636#define HMTYPE_SEMAPHORE        9
     37#define HMTYPE_COMPORT          10
     38#define HMTYPE_PARPORT          11
    3739//.....
    3840
    … …  
    4446{
    4547  HANDLE          hHMHandle;             /* a copy of the OS/2 system handle */
    46 
    47   DWORD           dwType;                          /* handle type identifier */
     48  HANDLE          hWin32Handle;          // win32 handle
    4849
    4950  DWORD           dwAccess;                     /* access mode of the handle */
    … …  
    99100                               DWORD   fdwOdinOptions);
    100101
    101                        /* this is a handler method for calls to CreateFile() */
    102   virtual DWORD  CreateFile (HANDLE        hHandle,
    103                              LPCSTR        lpFileName,
     102  /* this is a handler method for calls to CreateFile() */
     103  virtual DWORD  CreateFile (LPCSTR        lpFileName,
    104104                             PHMHANDLEDATA pHMHandleData,
    105105                             PVOID         lpSecurityAttributes,
    106106                             PHMHANDLEDATA pHMHandleDataTemplate);
    107107
    108                        /* this is a handler method for calls to   OpenFile() */
    109   virtual DWORD  OpenFile   (HANDLE        hHandle,
    110                              LPCSTR        lpFileName,
     108  /* this is a handler method for calls to   OpenFile() */
     109  virtual DWORD  OpenFile   (LPCSTR        lpFileName,
    111110                             PHMHANDLEDATA pHMHandleData,
    112111                             OFSTRUCT*     pOFStruct,
    113112                             UINT          fuMode);
    114113
    115                       /* this is a handler method for calls to CloseHandle() */
     114  /* this is a handler method for calls to CloseHandle() */
    116115  virtual BOOL   CloseHandle(PHMHANDLEDATA pHMHandleData);
    117116
    118                            /* this is a handler method for calls to ReadFile() */
     117  /* this is a handler method for calls to ReadFile/Ex */
    119118  virtual BOOL   ReadFile   (PHMHANDLEDATA pHMHandleData,
    120119                             LPCVOID       lpBuffer,
    121120                             DWORD         nNumberOfBytesToRead,
    122121                             LPDWORD       lpNumberOfBytesRead,
    123                              LPOVERLAPPED  lpOverlapped);
    124 
    125                         /* this is a handler method for calls to ReadFileEx() */
    126   virtual BOOL  ReadFileEx(PHMHANDLEDATA pHMHandleData,
    127                            LPVOID       lpBuffer,
    128                            DWORD        nNumberOfBytesToRead,
    129                            LPOVERLAPPED lpOverlapped,
    130                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    131 
    132                         /* this is a handler method for calls to WriteFile() */
     122                             LPOVERLAPPED  lpOverlapped,
     123                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
     124
     125  /* this is a handler method for calls to WriteFile/Ex */
    133126  virtual BOOL   WriteFile  (PHMHANDLEDATA pHMHandleData,
    134127                             LPCVOID       lpBuffer,
    135128                             DWORD         nNumberOfBytesToWrite,
    136129                             LPDWORD       lpNumberOfBytesWritten,
    137                              LPOVERLAPPED  lpOverlapped);
    138 
    139                         /* this is a handler method for calls to WriteFileEx() */
    140   virtual BOOL  WriteFileEx(PHMHANDLEDATA pHMHandleData,
    141                             LPVOID       lpBuffer,
    142                             DWORD        nNumberOfBytesToWrite,
    143                             LPOVERLAPPED lpOverlapped,
    144                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    145 
    146                       /* this is a handler method for calls to GetFileType() */
     130                             LPOVERLAPPED  lpOverlapped,
     131                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
     132
     133  /* this is a handler method for calls to GetFileType() */
    147134  virtual DWORD GetFileType (PHMHANDLEDATA pHMHandleData);
    148135
    … …  
    241228   ***************************************************************************/
    242229
    243                      /* this is a handler method for calls to CreateEvent() */
     230  /* this is a handler method for calls to CreateEvent() */
    244231  virtual DWORD CreateEvent (PHMHANDLEDATA         pHMHandleData,
    245232                             LPSECURITY_ATTRIBUTES lpsa,
    … …  
    248235                             LPCSTR                lpszEventName);
    249236
    250                        /* this is a handler method for calls to OpenEvent() */
     237  /* this is a handler method for calls to OpenEvent() */
    251238  virtual DWORD OpenEvent   (PHMHANDLEDATA         pHMHandleData,
    252239                             BOOL                  fInheritHandle,
    253240                             LPCSTR                lpszEventName);
    254241
    255                        /* this is a handle method for calls to ResetEvent() */
     242  /* this is a handle method for calls to ResetEvent() */
    256243  virtual BOOL  ResetEvent  (PHMHANDLEDATA         pHMHandleData);
    257244
    258                          /* this is a handle method for calls to SetEvent() */
     245  /* this is a handle method for calls to SetEvent() */
    259246  virtual BOOL  SetEvent    (PHMHANDLEDATA         pHMHandleData);
    260247
    261                        /* this is a handle method for calls to PulseEvent() */
     248  /* this is a handle method for calls to PulseEvent() */
    262249  virtual BOOL  PulseEvent  (PHMHANDLEDATA         pHMHandleData);
    263250
    … …  
    267254   ***************************************************************************/
    268255
    269                      /* this is a handler method for calls to CreateMutex() */
     256  /* this is a handler method for calls to CreateMutex() */
    270257  virtual DWORD CreateMutex (PHMHANDLEDATA         pHMHandleData,
    271258                             LPSECURITY_ATTRIBUTES lpsa,
    … …  
    273260                             LPCSTR                lpszMutexName);
    274261
    275                        /* this is a handler method for calls to OpenMutex() */
     262  /* this is a handler method for calls to OpenMutex() */
    276263  virtual DWORD OpenMutex   (PHMHANDLEDATA         pHMHandleData,
    277264                             BOOL                  fInheritHandle,
    278265                             LPCSTR                lpszMutexName);
    279266
    280                      /* this is a handle method for calls to ReleaseMutex() */
     267  /* this is a handle method for calls to ReleaseMutex() */
    281268  virtual BOOL  ReleaseMutex(PHMHANDLEDATA         pHMHandleData);
    282269
    … …  
    286273   ***************************************************************************/
    287274
    288                      /* this is a handler method for calls to CreateSemaphore() */
     275  /* this is a handler method for calls to CreateSemaphore() */
    289276  virtual DWORD CreateSemaphore (PHMHANDLEDATA         pHMHandleData,
    290277                                 LPSECURITY_ATTRIBUTES lpsa,
    … …  
    293280                                 LPCSTR                lpszSemaphoreName);
    294281
    295                        /* this is a handler method for calls to OpenSemaphore() */
     282  /* this is a handler method for calls to OpenSemaphore() */
    296283  virtual DWORD OpenSemaphore   (PHMHANDLEDATA         pHMHandleData,
    297284                                 BOOL                  fInheritHandle,
    298285                                 LPCSTR                lpszSemaphoreName);
    299286
    300                      /* this is a handle method for calls to ReleaseSemaphore() */
     287  /* this is a handle method for calls to ReleaseSemaphore() */
    301288  virtual BOOL  ReleaseSemaphore(PHMHANDLEDATA pHMHandleData,
    302289                                 LONG          cReleaseCount,
    303290                                 LPLONG        lpPreviousCount);
    304291
    305                 /* this is a handler method for calls to CreateFileMapping() */
     292  /* this is a handler method for calls to CreateFileMapping() */
    306293  virtual DWORD CreateFileMapping   (PHMHANDLEDATA              pHMHandleData,
    307294                                     HANDLE                     hFile,
    … …  
    312299                                     LPCSTR                     lpName);
    313300
    314                   /* this is a handler method for calls to OpenFileMapping() */
     301  /* this is a handler method for calls to OpenFileMapping() */
    315302  virtual DWORD OpenFileMapping     (PHMHANDLEDATA              pHMHandleData,
    316303                         DWORD access,   /* [in] Access mode */
    … …  
    318305                                     LPCSTR                     lpName);
    319306
    320                     /* this is a handler method for calls to MapViewOfFileEx() */
     307  /* this is a handler method for calls to MapViewOfFileEx() */
    321308  virtual LPVOID MapViewOfFileEx    (PHMHANDLEDATA              pHMHandleData,
    322309                                     DWORD                      dwDesiredAccess,
    … …  
    324311                                     DWORD                      dwFileOffsetLow,
    325312                                     DWORD                      dwNumberOfBytesToMap,
    326                    LPVOID                     lpBaseAddress);
    327 
    328                     /* this is a handler method for calls to DeviceIoControl() */
     313                                     LPVOID                     lpBaseAddress);
     314
     315  /* this is a handler method for calls to DeviceIoControl() */
    329316  virtual BOOL   DeviceIoControl    (PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,
    330317                                     LPVOID lpInBuffer, DWORD nInBufferSize,

  • trunk/src/kernel32/hmdevio.cpp

    r7474 r7549  
    1 /* $Id: hmdevio.cpp,v 1.18 2001-11-28 23:33:35 phaller Exp $ */
     1/* $Id: hmdevio.cpp,v 1.19 2001-12-05 14:16:00 sandervl Exp $ */
    22
    33/*
    … …  
    172172//******************************************************************************
    173173//******************************************************************************
    174 DWORD HMDeviceDriver::CreateFile (HANDLE        hHandle,
    175                                   LPCSTR lpFileName,
     174DWORD HMDeviceDriver::CreateFile (LPCSTR lpFileName,
    176175                                  PHMHANDLEDATA pHMHandleData,
    177176                                  PVOID         lpSecurityAttributes,
    … …  
    492491//******************************************************************************
    493492//******************************************************************************
    494 DWORD HMCustomDriver::CreateFile (HANDLE        hHandle,
    495                                   LPCSTR lpFileName,
     493DWORD HMCustomDriver::CreateFile (LPCSTR lpFileName,
    496494                                  PHMHANDLEDATA pHMHandleData,
    497495                                  PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/hmdevio.h

    r7458 r7549  
    1 /* $Id: hmdevio.h,v 1.6 2001-11-26 17:16:24 sandervl Exp $ */
     1/* $Id: hmdevio.h,v 1.7 2001-12-05 14:16:00 sandervl Exp $ */
    22
    33#ifndef __DEVIO_H__
    … …  
    123123
    124124                       /* this is a handler method for calls to CreateFile() */
    125   virtual DWORD  CreateFile (HANDLE        hHandle,
    126                              LPCSTR        lpFileName,
     125  virtual DWORD  CreateFile (LPCSTR        lpFileName,
    127126                             PHMHANDLEDATA pHMHandleData,
    128127                             PVOID         lpSecurityAttributes,
    … …  
    153152
    154153                       /* this is a handler method for calls to CreateFile() */
    155   virtual DWORD  CreateFile (HANDLE        hHandle,
    156                              LPCSTR        lpFileName,
     154  virtual DWORD  CreateFile (LPCSTR        lpFileName,
    157155                             PHMHANDLEDATA pHMHandleData,
    158156                             PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/hmdisk.cpp

    r7494 r7549  
    1 /* $Id: hmdisk.cpp,v 1.33 2001-11-29 19:58:09 sandervl Exp $ */
     1/* $Id: hmdisk.cpp,v 1.34 2001-12-05 14:16:00 sandervl Exp $ */
    22
    33/*
    … …  
    101101//TODO: PHYSICALDRIVEn!!
    102102//******************************************************************************
    103 DWORD HMDeviceDiskClass::CreateFile (HANDLE        hHandle,
    104                                      LPCSTR        lpFileName,
     103DWORD HMDeviceDiskClass::CreateFile (LPCSTR        lpFileName,
    105104                                     PHMHANDLEDATA pHMHandleData,
    106105                                     PVOID         lpSecurityAttributes,
    … …  
    11841183                                 DWORD         nNumberOfBytesToRead,
    11851184                                 LPDWORD       lpNumberOfBytesRead,
    1186                                  LPOVERLAPPED  lpOverlapped)
     1185                                 LPOVERLAPPED  lpOverlapped,
     1186                                 LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    11871187{
    11881188  LPVOID       lpRealBuf;
    … …  
    13091309  return ret;
    13101310}
    1311 /*****************************************************************************
    1312  * Name      : BOOL ReadFileEx
    1313  * Purpose   : The ReadFileEx function reads data from a file asynchronously.
    1314  *             It is designed solely for asynchronous operation, unlike the
    1315  *             ReadFile function, which is designed for both synchronous and
    1316  *             asynchronous operation. ReadFileEx lets an application perform
    1317  *             other processing during a file read operation.
    1318  *             The ReadFileEx function reports its completion status asynchronously,
    1319  *             calling a specified completion routine when reading is completed
    1320  *             and the calling thread is in an alertable wait state.
    1321  * Parameters: HANDLE       hFile                handle of file to read
    1322  *             LPVOID       lpBuffer             address of buffer
    1323  *             DWORD        nNumberOfBytesToRead number of bytes to read
    1324  *             LPOVERLAPPED lpOverlapped         address of offset
    1325  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    1326  * Variables :
    1327  * Result    : TRUE / FALSE
    1328  * Remark    :
    1329  * Status    : UNTESTED STUB
    1330  *
    1331  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    1332  *****************************************************************************/
    1333 BOOL HMDeviceDiskClass::ReadFileEx(PHMHANDLEDATA pHMHandleData,
    1334                            LPVOID       lpBuffer,
    1335                            DWORD        nNumberOfBytesToRead,
    1336                            LPOVERLAPPED lpOverlapped,
    1337                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    1338 {
    1339   dprintf(("ERROR: ReadFileEx(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    1340            pHMHandleData->hHMHandle,
    1341            lpBuffer,
    1342            nNumberOfBytesToRead,
    1343            lpOverlapped,
    1344            lpCompletionRoutine));
    1345   return FALSE;
    1346 }
    1347 
    13481311
    13491312/*****************************************************************************
    … …  
    13671330                                    DWORD         nNumberOfBytesToWrite,
    13681331                                    LPDWORD       lpNumberOfBytesWritten,
    1369                                     LPOVERLAPPED  lpOverlapped)
     1332                                    LPOVERLAPPED  lpOverlapped,
     1333                                    LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    13701334{
    13711335  LPVOID       lpRealBuf;
    … …  
    14561420}
    14571421
    1458 /*****************************************************************************
    1459  * Name      : BOOL WriteFileEx
    1460  * Purpose   : The WriteFileEx function writes data to a file. It is designed
    1461  *             solely for asynchronous operation, unlike WriteFile, which is
    1462  *             designed for both synchronous and asynchronous operation.
    1463  *             WriteFileEx reports its completion status asynchronously,
    1464  *             calling a specified completion routine when writing is completed
    1465  *             and the calling thread is in an alertable wait state.
    1466  * Parameters: HANDLE       hFile                handle of file to write
    1467  *             LPVOID       lpBuffer             address of buffer
    1468  *             DWORD        nNumberOfBytesToRead number of bytes to write
    1469  *             LPOVERLAPPED lpOverlapped         address of offset
    1470  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    1471  * Variables :
    1472  * Result    : TRUE / FALSE
    1473  * Remark    :
    1474  * Status    : UNTESTED STUB
    1475  *
    1476  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    1477  *****************************************************************************/
    1478 
    1479 BOOL HMDeviceDiskClass::WriteFileEx(PHMHANDLEDATA pHMHandleData,
    1480                            LPVOID       lpBuffer,
    1481                            DWORD        nNumberOfBytesToWrite,
    1482                            LPOVERLAPPED lpOverlapped,
    1483                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    1484 {
    1485   dprintf(("ERROR: WriteFileEx(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    1486            pHMHandleData->hHMHandle,
    1487            lpBuffer,
    1488            nNumberOfBytesToWrite,
    1489            lpOverlapped,
    1490            lpCompletionRoutine));
    1491   return FALSE;
    1492 }
    14931422
    14941423/*****************************************************************************

  • trunk/src/kernel32/hmdisk.h

    r7457 r7549  
    1 /* $Id: hmdisk.h,v 1.7 2001-11-26 14:54:01 sandervl Exp $ */
     1/* $Id: hmdisk.h,v 1.8 2001-12-05 14:16:01 sandervl Exp $ */
    22
    33#ifndef __HMDISK_H__
    … …  
    2525
    2626  /* this is a handler method for calls to CreateFile() */
    27   virtual DWORD  CreateFile (HANDLE        hHandle,
    28                              LPCSTR        lpFileName,
     27  virtual DWORD  CreateFile (LPCSTR        lpFileName,
    2928                             PHMHANDLEDATA pHMHandleData,
    3029                             PVOID         lpSecurityAttributes,
    … …  
    3332  virtual BOOL   CloseHandle(PHMHANDLEDATA pHMHandleData);
    3433
    35   /* this is a handler method for calls to ReadFile() */
     34  /* this is a handler method for calls to ReadFile/Ex */
    3635  virtual BOOL   ReadFile   (PHMHANDLEDATA pHMHandleData,
    3736                             LPCVOID       lpBuffer,
    3837                             DWORD         nNumberOfBytesToRead,
    3938                             LPDWORD       lpNumberOfBytesRead,
    40                              LPOVERLAPPED  lpOverlapped);
     39                             LPOVERLAPPED  lpOverlapped,
     40                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
     41
     42  /* this is a handler method for calls to WriteFile/Ex */
     43  virtual BOOL   WriteFile  (PHMHANDLEDATA pHMHandleData,
     44                             LPCVOID       lpBuffer,
     45                             DWORD         nNumberOfBytesToWrite,
     46                             LPDWORD       lpNumberOfBytesWritten,
     47                             LPOVERLAPPED  lpOverlapped,
     48                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    4149
    4250  /* this is a handler method for calls to SetFilePointer() */
    … …  
    5260                                     LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
    5361
    54                         /* this is a handler method for calls to ReadFileEx() */
    55   virtual BOOL  ReadFileEx(PHMHANDLEDATA pHMHandleData,
    56                            LPVOID       lpBuffer,
    57                            DWORD        nNumberOfBytesToRead,
    58                            LPOVERLAPPED lpOverlapped,
    59                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    60 
    61                         /* this is a handler method for calls to WriteFile() */
    62   virtual BOOL   WriteFile  (PHMHANDLEDATA pHMHandleData,
    63                              LPCVOID       lpBuffer,
    64                              DWORD         nNumberOfBytesToWrite,
    65                              LPDWORD       lpNumberOfBytesWritten,
    66                              LPOVERLAPPED  lpOverlapped);
    67 
    68                         /* this is a handler method for calls to WriteFileEx() */
    69   virtual BOOL  WriteFileEx(PHMHANDLEDATA pHMHandleData,
    70                             LPVOID       lpBuffer,
    71                             DWORD        nNumberOfBytesToWrite,
    72                             LPOVERLAPPED lpOverlapped,
    73                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    74 
    75                       /* this is a handler method for calls to GetFileType() */
     62  /* this is a handler method for calls to GetFileType() */
    7663  virtual DWORD GetFileType (PHMHANDLEDATA pHMHandleData);
    7764

  • trunk/src/kernel32/hmfile.cpp

    r7474 r7549  
    1 /* $Id: hmfile.cpp,v 1.31 2001-11-28 23:33:36 phaller Exp $ */
     1/* $Id: hmfile.cpp,v 1.32 2001-12-05 14:16:01 sandervl Exp $ */
    22
    33/*
    … …  
    5656 *****************************************************************************/
    5757
    58 DWORD HMDeviceFileClass::CreateFile (HANDLE        hHandle,
    59                                      LPCSTR        lpFileName,
     58DWORD HMDeviceFileClass::CreateFile (LPCSTR        lpFileName,
    6059                                     PHMHANDLEDATA pHMHandleData,
    6160                                     PVOID         lpSecurityAttributes,
    … …  
    143142 *****************************************************************************/
    144143
    145 DWORD HMDeviceFileClass::OpenFile (HANDLE        hHandle,
    146                                    LPCSTR        lpszFileName,
     144DWORD HMDeviceFileClass::OpenFile (LPCSTR        lpszFileName,
    147145                                   PHMHANDLEDATA pHMHandleData,
    148146                                   OFSTRUCT      *pOFStruct,
    … …  
    337335        duphdata.dwCreation = OPEN_EXISTING;
    338336
    339         if(CreateFile(0, srcfileinfo->lpszFileName, &duphdata,
     337        if(CreateFile(srcfileinfo->lpszFileName, &duphdata,
    340338                      srcfileinfo->lpSecurityAttributes, NULL) == NO_ERROR)
    341339        {
    … …  
    436434                                 DWORD         nNumberOfBytesToRead,
    437435                                 LPDWORD       lpNumberOfBytesRead,
    438                                  LPOVERLAPPED  lpOverlapped)
     436                                 LPOVERLAPPED  lpOverlapped,
     437                                 LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    439438{
    440439  LPVOID       lpRealBuf;
    … …  
    501500}
    502501
    503 /*****************************************************************************
    504  * Name      : BOOL ReadFileEx
    505  * Purpose   : The ReadFileEx function reads data from a file asynchronously.
    506  *             It is designed solely for asynchronous operation, unlike the
    507  *             ReadFile function, which is designed for both synchronous and
    508  *             asynchronous operation. ReadFileEx lets an application perform
    509  *             other processing during a file read operation.
    510  *             The ReadFileEx function reports its completion status asynchronously,
    511  *             calling a specified completion routine when reading is completed
    512  *             and the calling thread is in an alertable wait state.
    513  * Parameters: HANDLE       hFile                handle of file to read
    514  *             LPVOID       lpBuffer             address of buffer
    515  *             DWORD        nNumberOfBytesToRead number of bytes to read
    516  *             LPOVERLAPPED lpOverlapped         address of offset
    517  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    518  * Variables :
    519  * Result    : TRUE / FALSE
    520  * Remark    :
    521  * Status    : UNTESTED STUB
    522  *
    523  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    524  *****************************************************************************/
    525 BOOL HMDeviceFileClass::ReadFileEx(PHMHANDLEDATA pHMHandleData,
    526                            LPVOID       lpBuffer,
    527                            DWORD        nNumberOfBytesToRead,
    528                            LPOVERLAPPED lpOverlapped,
    529                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    530 {
    531   dprintf(("ERROR: ReadFileEx(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    532            pHMHandleData->hHMHandle,
    533            lpBuffer,
    534            nNumberOfBytesToRead,
    535            lpOverlapped,
    536            lpCompletionRoutine));
    537   return FALSE;
    538 }
    539 
    540502
    541503/*****************************************************************************
    … …  
    559521                                    DWORD         nNumberOfBytesToWrite,
    560522                                    LPDWORD       lpNumberOfBytesWritten,
    561                                     LPOVERLAPPED  lpOverlapped)
     523                                    LPOVERLAPPED  lpOverlapped,
     524                                    LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    562525{
    563526  LPVOID       lpRealBuf;
    … …  
    621584}
    622585
    623 /*****************************************************************************
    624  * Name      : BOOL WriteFileEx
    625  * Purpose   : The WriteFileEx function writes data to a file. It is designed
    626  *             solely for asynchronous operation, unlike WriteFile, which is
    627  *             designed for both synchronous and asynchronous operation.
    628  *             WriteFileEx reports its completion status asynchronously,
    629  *             calling a specified completion routine when writing is completed
    630  *             and the calling thread is in an alertable wait state.
    631  * Parameters: HANDLE       hFile                handle of file to write
    632  *             LPVOID       lpBuffer             address of buffer
    633  *             DWORD        nNumberOfBytesToRead number of bytes to write
    634  *             LPOVERLAPPED lpOverlapped         address of offset
    635  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    636  * Variables :
    637  * Result    : TRUE / FALSE
    638  * Remark    :
    639  * Status    : UNTESTED STUB
    640  *
    641  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    642  *****************************************************************************/
    643 
    644 BOOL HMDeviceFileClass::WriteFileEx(PHMHANDLEDATA pHMHandleData,
    645                            LPVOID       lpBuffer,
    646                            DWORD        nNumberOfBytesToWrite,
    647                            LPOVERLAPPED lpOverlapped,
    648                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    649 {
    650   dprintf(("ERROR: WriteFileEx(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    651            pHMHandleData->hHMHandle,
    652            lpBuffer,
    653            nNumberOfBytesToWrite,
    654            lpOverlapped,
    655            lpCompletionRoutine));
    656   return FALSE;
    657 }
    658586
    659587/*****************************************************************************

  • trunk/src/kernel32/hmfile.h

    r7457 r7549  
    1 /* $Id: hmfile.h,v 1.6 2001-11-26 14:54:02 sandervl Exp $ */
     1/* $Id: hmfile.h,v 1.7 2001-12-05 14:16:01 sandervl Exp $ */
    22
    33/*
    … …  
    4545
    4646                       /* this is a handler method for calls to CreateFile() */
    47   virtual DWORD  CreateFile (HANDLE        hHandle,
    48                              LPCSTR        lpFileName,
     47  virtual DWORD  CreateFile (LPCSTR        lpFileName,
    4948                             PHMHANDLEDATA pHMHandleData,
    5049                             PVOID         lpSecurityAttributes,
    … …  
    5251
    5352                       /* this is a handler method for calls to   OpenFile() */
    54   virtual DWORD  OpenFile   (HANDLE        hHandle,
    55                              LPCSTR        lpFileName,
     53  virtual DWORD  OpenFile   (LPCSTR        lpFileName,
    5654                             PHMHANDLEDATA pHMHandleData,
    5755                             OFSTRUCT*     pOFStruct,
    … …  
    7068  virtual BOOL   CloseHandle(PHMHANDLEDATA pHMHandleData);
    7169
    72                            /* this is a handler method for calls to ReadFile() */
     70  /* this is a handler method for calls to ReadFile/Ex */
    7371  virtual BOOL   ReadFile   (PHMHANDLEDATA pHMHandleData,
    7472                             LPCVOID       lpBuffer,
    7573                             DWORD         nNumberOfBytesToRead,
    7674                             LPDWORD       lpNumberOfBytesRead,
    77                              LPOVERLAPPED  lpOverlapped);
     75                             LPOVERLAPPED  lpOverlapped,
     76                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    7877
    79                         /* this is a handler method for calls to ReadFileEx() */
    80   virtual BOOL  ReadFileEx(PHMHANDLEDATA pHMHandleData,
    81                            LPVOID       lpBuffer,
    82                            DWORD        nNumberOfBytesToRead,
    83                            LPOVERLAPPED lpOverlapped,
    84                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    85 
    86                         /* this is a handler method for calls to WriteFile() */
     78  /* this is a handler method for calls to WriteFile/Ex */
    8779  virtual BOOL   WriteFile  (PHMHANDLEDATA pHMHandleData,
    8880                             LPCVOID       lpBuffer,
    8981                             DWORD         nNumberOfBytesToWrite,
    9082                             LPDWORD       lpNumberOfBytesWritten,
    91                              LPOVERLAPPED  lpOverlapped);
     83                             LPOVERLAPPED  lpOverlapped,
     84                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    9285
    93                         /* this is a handler method for calls to WriteFileEx() */
    94   virtual BOOL  WriteFileEx(PHMHANDLEDATA pHMHandleData,
    95                             LPVOID       lpBuffer,
    96                             DWORD        nNumberOfBytesToWrite,
    97                             LPOVERLAPPED lpOverlapped,
    98                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    99 
    100                       /* this is a handler method for calls to GetFileType() */
     86  /* this is a handler method for calls to GetFileType() */
    10187  virtual DWORD GetFileType (PHMHANDLEDATA pHMHandleData);
    10288

  • trunk/src/kernel32/hmmailslot.cpp

    r7489 r7549  
    1 /* $Id: hmmailslot.cpp,v 1.5 2001-11-29 13:38:51 sandervl Exp $
     1/* $Id: hmmailslot.cpp,v 1.6 2001-12-05 14:16:01 sandervl Exp $
    22 *
    33 * Win32 mailslot APIs
    … …  
    176176 *****************************************************************************/
    177177
    178 DWORD HMMailslotClass::CreateFile (HANDLE        hHandle,
    179                                    LPCSTR        lpFileName,
     178DWORD HMMailslotClass::CreateFile (LPCSTR        lpFileName,
    180179                                   PHMHANDLEDATA pHMHandleData,
    181180                                   PVOID         lpSecurityAttributes,
    … …  
    361360                               DWORD         nNumberOfBytesToRead,
    362361                               LPDWORD       lpNumberOfBytesRead,
    363                                LPOVERLAPPED  lpOverlapped)
     362                               LPOVERLAPPED  lpOverlapped,
     363                               LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    364364{
    365365    HMMailSlotInfo *mailslot = (HMMailSlotInfo *)pHMHandleData->dwUserData;
    … …  
    380380        return FALSE;
    381381    }
    382     return ::ReadFile(mailslot->hPipe, (LPVOID)lpBuffer, nNumberOfBytesToRead,
    383                       lpNumberOfBytesRead, lpOverlapped);
    384 }
    385 
    386 /*****************************************************************************
    387  * Name      : BOOL ReadFileEx
    388  * Purpose   : The ReadFileEx function reads data from a file asynchronously.
    389  *             It is designed solely for asynchronous operation, unlike the
    390  *             ReadFile function, which is designed for both synchronous and
    391  *             asynchronous operation. ReadFileEx lets an application perform
    392  *             other processing during a file read operation.
    393  *             The ReadFileEx function reports its completion status asynchronously,
    394  *             calling a specified completion routine when reading is completed
    395  *             and the calling thread is in an alertable wait state.
    396  * Parameters: HANDLE       hFile                handle of file to read
    397  *             LPVOID       lpBuffer             address of buffer
    398  *             DWORD        nNumberOfBytesToRead number of bytes to read
    399  *             LPOVERLAPPED lpOverlapped         address of offset
    400  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    401  * Variables :
    402  * Result    : TRUE / FALSE
    403  * Remark    :
    404  * Status    : UNTESTED STUB
    405  *
    406  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    407  *****************************************************************************/
    408 BOOL HMMailslotClass::ReadFileEx(PHMHANDLEDATA pHMHandleData,
    409                            LPVOID       lpBuffer,
    410                            DWORD        nNumberOfBytesToRead,
    411                            LPOVERLAPPED lpOverlapped,
    412                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    413 {
    414     HMMailSlotInfo *mailslot = (HMMailSlotInfo *)pHMHandleData->dwUserData;
    415 
    416     dprintf(("HMMailslotClass::ReadFileEx(%08xh,%08xh,%08xh,%08xh,%08xh)",  pHMHandleData->hHMHandle,
    417              lpBuffer, nNumberOfBytesToRead, lpOverlapped, lpCompletionRoutine));
    418 
    419     if(mailslot == NULL) {
    420         DebugInt3();
    421         return FALSE;
    422     }
    423     if(mailslot->fServer == FALSE) {
    424         dprintf(("ReadFile not allowed with client handle"));
    425         SetLastError(ERROR_INVALID_FUNCTION); //TODO: right error?
    426         return FALSE;
    427     }
    428     return ::ReadFileEx(mailslot->hPipe, lpBuffer, nNumberOfBytesToRead, lpOverlapped, lpCompletionRoutine);
    429 }
    430 
     382    if(lpCompletionRoutine) {
     383          return ::ReadFileEx(mailslot->hPipe, (LPVOID)lpBuffer, nNumberOfBytesToRead,
     384                              lpOverlapped, lpCompletionRoutine);
     385    }
     386    else  return ::ReadFile(mailslot->hPipe, (LPVOID)lpBuffer, nNumberOfBytesToRead,
     387                            lpNumberOfBytesRead, lpOverlapped);
     388}
    431389
    432390/*****************************************************************************
    … …  
    447405
    448406BOOL HMMailslotClass::WriteFile(PHMHANDLEDATA pHMHandleData,
    449                                     LPCVOID       lpBuffer,
    450                                     DWORD         nNumberOfBytesToWrite,
    451                                     LPDWORD       lpNumberOfBytesWritten,
    452                                     LPOVERLAPPED  lpOverlapped)
     407                                LPCVOID       lpBuffer,
     408                                DWORD         nNumberOfBytesToWrite,
     409                                LPDWORD       lpNumberOfBytesWritten,
     410                                LPOVERLAPPED  lpOverlapped,
     411                                LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    453412{
    454413    HMMailSlotInfo *mailslot = (HMMailSlotInfo *)pHMHandleData->dwUserData;
    … …  
    471430    }
    472431
    473     return ::WriteFile(mailslot->hPipe, lpBuffer, nNumberOfBytesToWrite,
    474                        lpNumberOfBytesWritten, lpOverlapped);
    475 }
    476 
    477 /*****************************************************************************
    478  * Name      : BOOL WriteFileEx
    479  * Purpose   : The WriteFileEx function writes data to a file. It is designed
    480  *             solely for asynchronous operation, unlike WriteFile, which is
    481  *             designed for both synchronous and asynchronous operation.
    482  *             WriteFileEx reports its completion status asynchronously,
    483  *             calling a specified completion routine when writing is completed
    484  *             and the calling thread is in an alertable wait state.
    485  * Parameters: HANDLE       hFile                handle of file to write
    486  *             LPVOID       lpBuffer             address of buffer
    487  *             DWORD        nNumberOfBytesToRead number of bytes to write
    488  *             LPOVERLAPPED lpOverlapped         address of offset
    489  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    490  * Variables :
    491  * Result    : TRUE / FALSE
    492  * Remark    :
    493  * Status    : UNTESTED STUB
    494  *
    495  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    496  *****************************************************************************/
    497 
    498 BOOL HMMailslotClass::WriteFileEx(PHMHANDLEDATA pHMHandleData,
    499                            LPVOID       lpBuffer,
    500                            DWORD        nNumberOfBytesToWrite,
    501                            LPOVERLAPPED lpOverlapped,
    502                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    503 {
    504     HMMailSlotInfo *mailslot = (HMMailSlotInfo *)pHMHandleData->dwUserData;
    505 
    506     dprintf(("HMMailslotClass::WriteFileEx(%08xh,%08xh,%08xh,%08xh,%08xh)",
    507              pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToWrite,
    508              lpOverlapped,lpCompletionRoutine));
    509 
    510     if(mailslot == NULL) {
    511         DebugInt3();
    512         return FALSE;
    513     }
    514     if(mailslot->fServer == TRUE) {
    515         dprintf(("ReadFile not allowed with server handle"));
    516         SetLastError(ERROR_INVALID_FUNCTION); //TODO: right error?
    517         return FALSE;
    518     }
    519     return ::WriteFileEx(mailslot->hPipe, lpBuffer, nNumberOfBytesToWrite,lpOverlapped,lpCompletionRoutine);
    520 }
     432    if(lpCompletionRoutine) {
     433          return ::WriteFileEx(mailslot->hPipe, lpBuffer, nNumberOfBytesToWrite,
     434                               lpOverlapped, lpCompletionRoutine);
     435    }
     436    else  return ::WriteFile(mailslot->hPipe, lpBuffer, nNumberOfBytesToWrite,
     437                             lpNumberOfBytesWritten, lpOverlapped);
     438}
     439

  • trunk/src/kernel32/hmmailslot.h

    r7457 r7549  
    6969
    7070  /* this is a handler method for calls to CreateFile() */
    71   virtual DWORD  CreateFile (HANDLE        hHandle,
    72                              LPCSTR        lpFileName,
     71  virtual DWORD  CreateFile (LPCSTR        lpFileName,
    7372                             PHMHANDLEDATA pHMHandleData,
    7473                             PVOID         lpSecurityAttributes,
    … …  
    7978
    8079
    81                            /* this is a handler method for calls to ReadFile() */
     80  /* this is a handler method for calls to ReadFile/Ex */
    8281  virtual BOOL   ReadFile   (PHMHANDLEDATA pHMHandleData,
    8382                             LPCVOID       lpBuffer,
    8483                             DWORD         nNumberOfBytesToRead,
    8584                             LPDWORD       lpNumberOfBytesRead,
    86                              LPOVERLAPPED  lpOverlapped);
     85                             LPOVERLAPPED  lpOverlapped,
     86                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    8787
    88                         /* this is a handler method for calls to ReadFileEx() */
    89   virtual BOOL  ReadFileEx(PHMHANDLEDATA pHMHandleData,
    90                            LPVOID       lpBuffer,
    91                            DWORD        nNumberOfBytesToRead,
    92                            LPOVERLAPPED lpOverlapped,
    93                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    94 
    95                         /* this is a handler method for calls to WriteFile() */
     88  /* this is a handler method for calls to WriteFile/Ex */
    9689  virtual BOOL   WriteFile  (PHMHANDLEDATA pHMHandleData,
    9790                             LPCVOID       lpBuffer,
    9891                             DWORD         nNumberOfBytesToWrite,
    9992                             LPDWORD       lpNumberOfBytesWritten,
    100                              LPOVERLAPPED  lpOverlapped);
    101 
    102                         /* this is a handler method for calls to WriteFileEx() */
    103   virtual BOOL  WriteFileEx(PHMHANDLEDATA pHMHandleData,
    104                             LPVOID       lpBuffer,
    105                             DWORD        nNumberOfBytesToWrite,
    106                             LPOVERLAPPED lpOverlapped,
    107                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
     93                             LPOVERLAPPED  lpOverlapped,
     94                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    10895
    10996private:

  • trunk/src/kernel32/hmnpipe.cpp

    r7489 r7549  
    1 /* $Id: hmnpipe.cpp,v 1.6 2001-11-29 13:38:51 sandervl Exp $ */
     1/* $Id: hmnpipe.cpp,v 1.7 2001-12-05 14:16:02 sandervl Exp $ */
    22/*
    33 * Project Odin Software License can be found in LICENSE.TXT
    … …  
    128128 *****************************************************************************/
    129129
    130 DWORD HMDeviceNamedPipeClass::CreateFile (HANDLE        hHandle,
    131                                           LPCSTR        lpFileName,
     130DWORD HMDeviceNamedPipeClass::CreateFile (LPCSTR        lpFileName,
    132131                                          PHMHANDLEDATA pHMHandleData,
    133132                                          PVOID         lpSecurityAttributes,
    … …  
    147146
    148147/*****************************************************************************
     148 * Name      : DWORD HMDeviceFileClass::GetFileType
     149 * Purpose   : determine the handle type
     150 * Parameters: PHMHANDLEDATA pHMHandleData
     151 * Variables :
     152 * Result    : API returncode
     153 * Remark    :
     154 * Status    :
     155 *
     156 * Author    : SvL
     157 *****************************************************************************/
     158
     159DWORD HMDeviceNamedPipeClass::GetFileType(PHMHANDLEDATA pHMHandleData)
     160{
     161  dprintfl(("KERNEL32: HMDeviceNamedPipeClass::GetFileType %s(%08x)\n",
     162           lpHMDeviceName,
     163           pHMHandleData));
     164
     165  return FILE_TYPE_PIPE;
     166}
     167
     168/*****************************************************************************
    149169 * Name      : DWORD HMDeviceNamedPipeClass::CloseHandle
    150170 * Purpose   : close the handle

  • trunk/src/kernel32/hmnpipe.h

    r7457 r7549  
    1 /* $Id: hmnpipe.h,v 1.4 2001-11-26 14:54:03 sandervl Exp $ */
     1/* $Id: hmnpipe.h,v 1.5 2001-12-05 14:16:02 sandervl Exp $ */
    22/*
    33 * Project Odin Software License can be found in LICENSE.TXT
    … …  
    3232
    3333  /* this is a handler method for calls to CreateFile() */
    34   virtual DWORD  CreateFile (HANDLE        hHandle,
    35                              LPCSTR        lpFileName,
     34  virtual DWORD  CreateFile (LPCSTR        lpFileName,
    3635                             PHMHANDLEDATA pHMHandleData,
    3736                             PVOID         lpSecurityAttributes,
    3837                             PHMHANDLEDATA pHMHandleDataTemplate);
     38
     39  /* this is a handler method for calls to GetFileType() */
     40  virtual DWORD GetFileType (PHMHANDLEDATA pHMHandleData);
    3941
    4042  /* this is a handler method for calls to CloseHandle() */

  • trunk/src/kernel32/hmnul.cpp

    r7476 r7549  
    1 /* $Id: hmnul.cpp,v 1.1 2001-11-29 00:20:48 phaller Exp $ */
     1/* $Id: hmnul.cpp,v 1.2 2001-12-05 14:16:02 sandervl Exp $ */
    22
    33/*
    … …  
    6060}
    6161
    62 DWORD HMDeviceNulClass::CreateFile(HANDLE        hHandle,
    63                                        LPCSTR lpFileName,
    64                                        PHMHANDLEDATA pHMHandleData,
    65                                        PVOID lpSecurityAttributes,
    66                                        PHMHANDLEDATA pHMHandleDataTemplate)
     62DWORD HMDeviceNulClass::CreateFile(LPCSTR lpFileName,
     63                                   PHMHANDLEDATA pHMHandleData,
     64                                   PVOID lpSecurityAttributes,
     65                                   PHMHANDLEDATA pHMHandleDataTemplate)
    6766{
    6867  dprintf(("HMDeviceNulClass::CreateFile(%s,%08xh,%08xh,%08xh)\n",
    … …  
    107106
    108107BOOL HMDeviceNulClass::WriteFile(PHMHANDLEDATA pHMHandleData,
    109                                      LPCVOID       lpBuffer,
    110                                      DWORD         nNumberOfBytesToWrite,
    111                                      LPDWORD       lpNumberOfBytesWritten,
    112                                      LPOVERLAPPED  lpOverlapped)
     108                                 LPCVOID       lpBuffer,
     109                                 DWORD         nNumberOfBytesToWrite,
     110                                 LPDWORD       lpNumberOfBytesWritten,
     111                                 LPOVERLAPPED  lpOverlapped,
     112                                 LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    113113{
    114114  dprintf(("KERNEL32:HMDeviceNulClass::WriteFile %s(%08x,%08x,%08x,%08x,%08x)",
    … …  
    146146}
    147147
    148 /*****************************************************************************
    149  * Name      : BOOL WriteFileEx
    150  * Purpose   : The WriteFileEx function writes data to a file. It is designed
    151  *             solely for asynchronous operation, unlike WriteFile, which is
    152  *             designed for both synchronous and asynchronous operation.
    153  *             WriteFileEx reports its completion status asynchronously,
    154  *             calling a specified completion routine when writing is completed
    155  *             and the calling thread is in an alertable wait state.
    156  * Parameters: HANDLE       hFile                handle of file to write
    157  *             LPVOID       lpBuffer             address of buffer
    158  *             DWORD        nNumberOfBytesToRead number of bytes to write
    159  *             LPOVERLAPPED lpOverlapped         address of offset
    160  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    161  * Variables :
    162  * Result    : TRUE / FALSE
    163  * Remark    :
    164  * Status    : UNTESTED STUB
    165  *
    166  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    167  *****************************************************************************/
    168 
    169 BOOL HMDeviceNulClass::WriteFileEx(PHMHANDLEDATA pHMHandleData,
    170                                        LPVOID       lpBuffer,
    171                                        DWORD        nNumberOfBytesToWrite,
    172                                        LPOVERLAPPED lpOverlapped,
    173                                        LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    174 {
    175   dprintf(("ERROR: WriteFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    176            lpHMDeviceName,
    177            pHMHandleData->hHMHandle,
    178            lpBuffer,
    179            nNumberOfBytesToWrite,
    180            lpOverlapped,
    181            lpCompletionRoutine));
    182 
    183   SetLastError(ERROR_INVALID_FUNCTION);
    184   return FALSE;
    185 }
    186148
    187149/*****************************************************************************
    … …  
    202164
    203165BOOL HMDeviceNulClass::ReadFile(PHMHANDLEDATA pHMHandleData,
    204                                     LPCVOID       lpBuffer,
    205                                     DWORD         nNumberOfBytesToRead,
    206                                     LPDWORD       lpNumberOfBytesRead,
    207                                     LPOVERLAPPED  lpOverlapped)
     166                                LPCVOID       lpBuffer,
     167                                DWORD         nNumberOfBytesToRead,
     168                                LPDWORD       lpNumberOfBytesRead,
     169                                LPOVERLAPPED  lpOverlapped,
     170                                LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    208171{
    209172  dprintf(("KERNEL32:HMDeviceNulClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x)",
    … …  
    238201  }
    239202  return ret;
    240 }
    241 
    242 /*****************************************************************************
    243  * Name      : BOOL ReadFileEx
    244  * Purpose   : The ReadFileEx function reads data from a file asynchronously.
    245  *             It is designed solely for asynchronous operation, unlike the
    246  *             ReadFile function, which is designed for both synchronous and
    247  *             asynchronous operation. ReadFileEx lets an application perform
    248  *             other processing during a file read operation.
    249  *             The ReadFileEx function reports its completion status asynchronously,
    250  *             calling a specified completion routine when reading is completed
    251  *             and the calling thread is in an alertable wait state.
    252  * Parameters: HANDLE       hFile                handle of file to read
    253  *             LPVOID       lpBuffer             address of buffer
    254  *             DWORD        nNumberOfBytesToRead number of bytes to read
    255  *             LPOVERLAPPED lpOverlapped         address of offset
    256  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    257  * Variables :
    258  * Result    : TRUE / FALSE
    259  * Remark    :
    260  * Status    : UNTESTED STUB
    261  *
    262  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    263  *****************************************************************************/
    264 BOOL HMDeviceNulClass::ReadFileEx(PHMHANDLEDATA pHMHandleData,
    265                            LPVOID       lpBuffer,
    266                            DWORD        nNumberOfBytesToRead,
    267                            LPOVERLAPPED lpOverlapped,
    268                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    269 {
    270   dprintf(("ERROR: ReadFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    271            lpHMDeviceName,
    272            pHMHandleData->hHMHandle,
    273            lpBuffer,
    274            nNumberOfBytesToRead,
    275            lpOverlapped,
    276            lpCompletionRoutine));
    277 
    278   SetLastError(ERROR_INVALID_FUNCTION);
    279   return FALSE;
    280203}
    281204

  • trunk/src/kernel32/hmnul.h

    r7476 r7549  
    1 /* $Id: hmnul.h,v 1.1 2001-11-29 00:20:48 phaller Exp $ */
     1/* $Id: hmnul.h,v 1.2 2001-12-05 14:16:03 sandervl Exp $ */
    22
    33/*
    … …  
    2323
    2424  /* this is the handler method for calls to CreateFile() */
    25   virtual DWORD  CreateFile (HANDLE        hHandle,
    26                              LPCSTR        lpFileName,
     25  virtual DWORD  CreateFile (LPCSTR        lpFileName,
    2726                             PHMHANDLEDATA pHMHandleData,
    2827                             PVOID         lpSecurityAttributes,
    … …  
    3938 
    4039 
    41                            /* this is a handler method for calls to ReadFile() */
     40  /* this is a handler method for calls to ReadFile/Ex */
    4241  virtual BOOL   ReadFile   (PHMHANDLEDATA pHMHandleData,
    4342                             LPCVOID       lpBuffer,
    4443                             DWORD         nNumberOfBytesToRead,
    4544                             LPDWORD       lpNumberOfBytesRead,
    46                              LPOVERLAPPED  lpOverlapped);
     45                             LPOVERLAPPED  lpOverlapped,
     46                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    4747
    48                         /* this is a handler method for calls to ReadFileEx() */
    49   virtual BOOL  ReadFileEx(PHMHANDLEDATA pHMHandleData,
    50                            LPVOID       lpBuffer,
    51                            DWORD        nNumberOfBytesToRead,
    52                            LPOVERLAPPED lpOverlapped,
    53                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    54 
    55                         /* this is a handler method for calls to WriteFile() */
     48  /* this is a handler method for calls to WriteFile/Ex */
    5649  virtual BOOL   WriteFile  (PHMHANDLEDATA pHMHandleData,
    5750                             LPCVOID       lpBuffer,
    5851                             DWORD         nNumberOfBytesToWrite,
    5952                             LPDWORD       lpNumberOfBytesWritten,
    60                              LPOVERLAPPED  lpOverlapped);
    61 
    62                         /* this is a handler method for calls to WriteFileEx() */
    63   virtual BOOL  WriteFileEx(PHMHANDLEDATA pHMHandleData,
    64                             LPVOID       lpBuffer,
    65                             DWORD        nNumberOfBytesToWrite,
    66                             LPOVERLAPPED lpOverlapped,
    67                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
     53                             LPOVERLAPPED  lpOverlapped,
     54                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    6855
    6956  private:

  • trunk/src/kernel32/hmparport.cpp

    r7542 r7549  
    1 /* $Id: hmparport.cpp,v 1.15 2001-12-04 12:56:52 phaller Exp $ */
     1/* $Id: hmparport.cpp,v 1.16 2001-12-05 14:16:04 sandervl Exp $ */
    22
    33/*
    … …  
    232232}
    233233
    234 DWORD HMDeviceParPortClass::CreateFile(HANDLE        hHandle,
    235                                        LPCSTR lpFileName,
     234DWORD HMDeviceParPortClass::CreateFile(LPCSTR lpFileName,
    236235                                       PHMHANDLEDATA pHMHandleData,
    237236                                       PVOID lpSecurityAttributes,
    … …  
    331330                                     DWORD         nNumberOfBytesToWrite,
    332331                                     LPDWORD       lpNumberOfBytesWritten,
    333                                      LPOVERLAPPED  lpOverlapped)
     332                                     LPOVERLAPPED  lpOverlapped,
     333                                     LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    334334{
    335335  dprintf(("KERNEL32:HMDeviceParPortClass::WriteFile %s(%08x,%08x,%08x,%08x,%08x)",
    … …  
    364364
    365365  return ret;
    366 }
    367 
    368 /*****************************************************************************
    369  * Name      : BOOL WriteFileEx
    370  * Purpose   : The WriteFileEx function writes data to a file. It is designed
    371  *             solely for asynchronous operation, unlike WriteFile, which is
    372  *             designed for both synchronous and asynchronous operation.
    373  *             WriteFileEx reports its completion status asynchronously,
    374  *             calling a specified completion routine when writing is completed
    375  *             and the calling thread is in an alertable wait state.
    376  * Parameters: HANDLE       hFile                handle of file to write
    377  *             LPVOID       lpBuffer             address of buffer
    378  *             DWORD        nNumberOfBytesToRead number of bytes to write
    379  *             LPOVERLAPPED lpOverlapped         address of offset
    380  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    381  * Variables :
    382  * Result    : TRUE / FALSE
    383  * Remark    :
    384  * Status    : UNTESTED STUB
    385  *
    386  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    387  *****************************************************************************/
    388 
    389 BOOL HMDeviceParPortClass::WriteFileEx(PHMHANDLEDATA pHMHandleData,
    390                                        LPVOID       lpBuffer,
    391                                        DWORD        nNumberOfBytesToWrite,
    392                                        LPOVERLAPPED lpOverlapped,
    393                                        LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    394 {
    395   dprintf(("ERROR: WriteFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    396            lpHMDeviceName,
    397            pHMHandleData->hHMHandle,
    398            lpBuffer,
    399            nNumberOfBytesToWrite,
    400            lpOverlapped,
    401            lpCompletionRoutine));
    402 
    403   SetLastError(ERROR_INVALID_FUNCTION);
    404   return FALSE;
    405366}
    406367
    … …  
    425386                                    DWORD         nNumberOfBytesToRead,
    426387                                    LPDWORD       lpNumberOfBytesRead,
    427                                     LPOVERLAPPED  lpOverlapped)
     388                                    LPOVERLAPPED  lpOverlapped,
     389                                    LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    428390{
    429391  dprintf(("KERNEL32:HMDeviceParPortClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x)",
    … …  
    457419  }
    458420  return ret;
    459 }
    460 
    461 /*****************************************************************************
    462  * Name      : BOOL ReadFileEx
    463  * Purpose   : The ReadFileEx function reads data from a file asynchronously.
    464  *             It is designed solely for asynchronous operation, unlike the
    465  *             ReadFile function, which is designed for both synchronous and
    466  *             asynchronous operation. ReadFileEx lets an application perform
    467  *             other processing during a file read operation.
    468  *             The ReadFileEx function reports its completion status asynchronously,
    469  *             calling a specified completion routine when reading is completed
    470  *             and the calling thread is in an alertable wait state.
    471  * Parameters: HANDLE       hFile                handle of file to read
    472  *             LPVOID       lpBuffer             address of buffer
    473  *             DWORD        nNumberOfBytesToRead number of bytes to read
    474  *             LPOVERLAPPED lpOverlapped         address of offset
    475  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    476  * Variables :
    477  * Result    : TRUE / FALSE
    478  * Remark    :
    479  * Status    : UNTESTED STUB
    480  *
    481  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    482  *****************************************************************************/
    483 BOOL HMDeviceParPortClass::ReadFileEx(PHMHANDLEDATA pHMHandleData,
    484                            LPVOID       lpBuffer,
    485                            DWORD        nNumberOfBytesToRead,
    486                            LPOVERLAPPED lpOverlapped,
    487                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    488 {
    489   dprintf(("ERROR: ReadFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    490            lpHMDeviceName,
    491            pHMHandleData->hHMHandle,
    492            lpBuffer,
    493            nNumberOfBytesToRead,
    494            lpOverlapped,
    495            lpCompletionRoutine));
    496 
    497   SetLastError(ERROR_INVALID_FUNCTION);
    498   return FALSE;
    499421}
    500422

  • trunk/src/kernel32/hmparport.h

    r7546 r7549  
    1 /* $Id: hmparport.h,v 1.5 2001-12-05 09:09:52 phaller Exp $ */
     1/* $Id: hmparport.h,v 1.6 2001-12-05 14:16:05 sandervl Exp $ */
    22
    33/*
    … …  
    2323
    2424  /* this is the handler method for calls to CreateFile() */
    25   virtual DWORD  CreateFile (HANDLE        hHandle,
    26                              LPCSTR        lpFileName,
     25  virtual DWORD  CreateFile (LPCSTR        lpFileName,
    2726                             PHMHANDLEDATA pHMHandleData,
    2827                             PVOID         lpSecurityAttributes,
    … …  
    6261 
    6362 
    64                            /* this is a handler method for calls to ReadFile() */
     63  /* this is a handler method for calls to ReadFile/Ex */
    6564  virtual BOOL   ReadFile   (PHMHANDLEDATA pHMHandleData,
    6665                             LPCVOID       lpBuffer,
    6766                             DWORD         nNumberOfBytesToRead,
    6867                             LPDWORD       lpNumberOfBytesRead,
    69                              LPOVERLAPPED  lpOverlapped);
     68                             LPOVERLAPPED  lpOverlapped,
     69                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    7070
    71                         /* this is a handler method for calls to ReadFileEx() */
    72   virtual BOOL  ReadFileEx(PHMHANDLEDATA pHMHandleData,
    73                            LPVOID       lpBuffer,
    74                            DWORD        nNumberOfBytesToRead,
    75                            LPOVERLAPPED lpOverlapped,
    76                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    77 
    78                         /* this is a handler method for calls to WriteFile() */
     71  /* this is a handler method for calls to WriteFile/Ex */
    7972  virtual BOOL   WriteFile  (PHMHANDLEDATA pHMHandleData,
    8073                             LPCVOID       lpBuffer,
    8174                             DWORD         nNumberOfBytesToWrite,
    8275                             LPDWORD       lpNumberOfBytesWritten,
    83                              LPOVERLAPPED  lpOverlapped);
    84 
    85                         /* this is a handler method for calls to WriteFileEx() */
    86   virtual BOOL  WriteFileEx(PHMHANDLEDATA pHMHandleData,
    87                             LPVOID       lpBuffer,
    88                             DWORD        nNumberOfBytesToWrite,
    89                             LPOVERLAPPED lpOverlapped,
    90                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
     76                             LPOVERLAPPED  lpOverlapped,
     77                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    9178
    9279  private:

  • trunk/src/kernel32/hmstd.cpp

    r6511 r7549  
    1 /* $Id: hmstd.cpp,v 1.5 2001-08-10 19:32:28 sandervl Exp $ */
     1/* $Id: hmstd.cpp,v 1.6 2001-12-05 14:16:05 sandervl Exp $ */
    22
    33/*
    … …  
    6868                                 DWORD         nNumberOfBytesToRead,
    6969                                 LPDWORD       lpNumberOfBytesRead,
    70                                  LPOVERLAPPED  lpOverlapped)
     70                                 LPOVERLAPPED  lpOverlapped,
     71                                 LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    7172{
    7273  BOOL         bRC;
    … …  
    9293}
    9394
    94 /*****************************************************************************
    95  * Name      : BOOL ReadFileEx
    96  * Purpose   : The ReadFileEx function reads data from a file asynchronously.
    97  *             It is designed solely for asynchronous operation, unlike the
    98  *             ReadFile function, which is designed for both synchronous and
    99  *             asynchronous operation. ReadFileEx lets an application perform
    100  *             other processing during a file read operation.
    101  *             The ReadFileEx function reports its completion status asynchronously,
    102  *             calling a specified completion routine when reading is completed
    103  *             and the calling thread is in an alertable wait state.
    104  * Parameters: HANDLE       hFile                handle of file to read
    105  *             LPVOID       lpBuffer             address of buffer
    106  *             DWORD        nNumberOfBytesToRead number of bytes to read
    107  *             LPOVERLAPPED lpOverlapped         address of offset
    108  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    109  * Variables :
    110  * Result    : TRUE / FALSE
    111  * Remark    :
    112  * Status    : UNTESTED STUB
    113  *
    114  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    115  *****************************************************************************/
    116 BOOL HMDeviceStandardClass::ReadFileEx(PHMHANDLEDATA pHMHandleData,
    117                            LPVOID       lpBuffer,
    118                            DWORD        nNumberOfBytesToRead,
    119                            LPOVERLAPPED lpOverlapped,
    120                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    121 {
    122   dprintf(("ERROR: ReadFileEx(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    123            pHMHandleData->hHMHandle,
    124            lpBuffer,
    125            nNumberOfBytesToRead,
    126            lpOverlapped,
    127            lpCompletionRoutine));
    128 
    129   return FALSE;
    130 }
    131 
    13295
    13396/*****************************************************************************
    … …  
    151114                                      DWORD         nNumberOfBytesToWrite,
    152115                                      LPDWORD       lpNumberOfBytesWritten,
    153                                       LPOVERLAPPED  lpOverlapped)
     116                                      LPOVERLAPPED  lpOverlapped,
     117                                      LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    154118{
    155119 DWORD  byteswritten;
    … …  
    188152}
    189153
    190 /*****************************************************************************
    191  * Name      : BOOL WriteFileEx
    192  * Purpose   : The WriteFileEx function writes data to a file. It is designed
    193  *             solely for asynchronous operation, unlike WriteFile, which is
    194  *             designed for both synchronous and asynchronous operation.
    195  *             WriteFileEx reports its completion status asynchronously,
    196  *             calling a specified completion routine when writing is completed
    197  *             and the calling thread is in an alertable wait state.
    198  * Parameters: HANDLE       hFile                handle of file to write
    199  *             LPVOID       lpBuffer             address of buffer
    200  *             DWORD        nNumberOfBytesToRead number of bytes to write
    201  *             LPOVERLAPPED lpOverlapped         address of offset
    202  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    203  * Variables :
    204  * Result    : TRUE / FALSE
    205  * Remark    :
    206  * Status    : UNTESTED STUB
    207  *
    208  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    209  *****************************************************************************/
    210 
    211 BOOL HMDeviceStandardClass::WriteFileEx(PHMHANDLEDATA pHMHandleData,
    212                            LPVOID       lpBuffer,
    213                            DWORD        nNumberOfBytesToWrite,
    214                            LPOVERLAPPED lpOverlapped,
    215                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    216 {
    217   dprintf(("ERROR: WriteFileEx(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    218            pHMHandleData->hHMHandle,
    219            lpBuffer,
    220            nNumberOfBytesToWrite,
    221            lpOverlapped,
    222            lpCompletionRoutine));
    223   return FALSE;
    224 }
    225154
    226155/*****************************************************************************

  • trunk/src/kernel32/hmstd.h

    r5019 r7549  
    1 /* $Id: hmstd.h,v 1.1 2001-01-23 18:31:26 sandervl Exp $ */
     1/* $Id: hmstd.h,v 1.2 2001-12-05 14:16:05 sandervl Exp $ */
    22
    33/*
    … …  
    3434  HMDeviceStandardClass(LPCSTR lpDeviceName) : HMDeviceOpen32Class(lpDeviceName) {}
    3535
    36                            /* this is a handler method for calls to ReadFile() */
     36  /* this is a handler method for calls to ReadFile/Ex */
    3737  virtual BOOL   ReadFile   (PHMHANDLEDATA pHMHandleData,
    3838                             LPCVOID       lpBuffer,
    3939                             DWORD         nNumberOfBytesToRead,
    4040                             LPDWORD       lpNumberOfBytesRead,
    41                              LPOVERLAPPED  lpOverlapped);
     41                             LPOVERLAPPED  lpOverlapped,
     42                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    4243
    43                         /* this is a handler method for calls to ReadFileEx() */
    44   virtual BOOL  ReadFileEx(PHMHANDLEDATA pHMHandleData,
    45                            LPVOID       lpBuffer,
    46                            DWORD        nNumberOfBytesToRead,
    47                            LPOVERLAPPED lpOverlapped,
    48                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    49 
    50                         /* this is a handler method for calls to WriteFile() */
     44  /* this is a handler method for calls to WriteFile/Ex */
    5145  virtual BOOL   WriteFile  (PHMHANDLEDATA pHMHandleData,
    5246                             LPCVOID       lpBuffer,
    5347                             DWORD         nNumberOfBytesToWrite,
    5448                             LPDWORD       lpNumberOfBytesWritten,
    55                              LPOVERLAPPED  lpOverlapped);
     49                             LPOVERLAPPED  lpOverlapped,
     50                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    5651
    57                         /* this is a handler method for calls to WriteFileEx() */
    58   virtual BOOL  WriteFileEx(PHMHANDLEDATA pHMHandleData,
    59                             LPVOID       lpBuffer,
    60                             DWORD        nNumberOfBytesToWrite,
    61                             LPOVERLAPPED lpOverlapped,
    62                             LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    63 
    64                       /* this is a handler method for calls to GetFileType() */
     52  /* this is a handler method for calls to GetFileType() */
    6553  virtual DWORD GetFileType (PHMHANDLEDATA pHMHandleData);
    6654};
Note: See TracChangeset for help on using the changeset viewer.