![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to async.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / rshell / server|
Return to async.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / rshell / server |
1.1 ! root 1: /****************************** Module Header ******************************\ ! 2: * Module Name: async.c ! 3: * ! 4: * Copyright (c) 1991, Microsoft Corporation ! 5: * ! 6: * This module implements asynchronous I/O on file handles in a more ! 7: * useful way than provided for by Win32 apis. ! 8: * ! 9: * This module provides 2 main apis : ReadFileAsync, WriteFileAsync. ! 10: * These apis take a handle to an async object and always return ! 11: * immediately without waiting for the I/O to complete. An event ! 12: * can be queried from the async object and used to wait for completion. ! 13: * When this event is signalled, the I/O result can be queried from ! 14: * the async object. ! 15: * ! 16: * History: ! 17: * 06-29-92 Davidc Created. ! 18: \***************************************************************************/ ! 19: ! 20: #include "rcmdsrv.h" ! 21: ! 22: ! 23: ! 24: // ! 25: // Define MYOVERLAPPED structure ! 26: // ! 27: ! 28: typedef struct { ! 29: ! 30: OVERLAPPED Overlapped; ! 31: ! 32: HANDLE FileHandle; // Non-null when I/O operation in progress. ! 33: ! 34: DWORD CompletionCode; ! 35: DWORD BytesTransferred; ! 36: BOOL CompletedSynchronously; ! 37: ! 38: } MYOVERLAPPED, *PMYOVERLAPPED; ! 39: ! 40: ! 41: ! 42: ! 43: ! 44: ///////////////////////////////////////////////////////////////////////////// ! 45: // ! 46: // CreateAsync ! 47: // ! 48: // Creates an async object. ! 49: // The async event is created with the initial state specified. If this ! 50: // is TRUE the async object created simulates a successfully completed ! 51: // transfer of 0 bytes. ! 52: // ! 53: // Returns handle on success, NULL on failure. GetLastError() for details. ! 54: // ! 55: // The object should be deleted by calling DeleteAsync. ! 56: // ! 57: ///////////////////////////////////////////////////////////////////////////// ! 58: ! 59: HANDLE ! 60: CreateAsync( ! 61: BOOL InitialState ! 62: ) ! 63: { ! 64: SECURITY_ATTRIBUTES SecurityAttributes; ! 65: PMYOVERLAPPED MyOverlapped; ! 66: ! 67: SecurityAttributes.nLength = sizeof(SecurityAttributes); ! 68: SecurityAttributes.lpSecurityDescriptor = NULL; // Use default ACL ! 69: SecurityAttributes.bInheritHandle = FALSE; // No inheritance ! 70: ! 71: // ! 72: // Allocate space for the async structure ! 73: // ! 74: ! 75: ! 76: MyOverlapped = (PMYOVERLAPPED)Alloc(sizeof(MYOVERLAPPED)); ! 77: if (MyOverlapped == NULL) { ! 78: DbgPrint("CreateAsync : Failed to allocate space for async object\n"); ! 79: return(NULL); ! 80: } ! 81: ! 82: // ! 83: // Create the synchronisation event ! 84: // ! 85: ! 86: MyOverlapped->Overlapped.hEvent = CreateEvent( &SecurityAttributes, ! 87: TRUE, // Manual-reset ! 88: InitialState, ! 89: NULL); // Name ! 90: if (MyOverlapped->Overlapped.hEvent == NULL) { ! 91: DbgPrint("CreateAsync failed to create event, error = %d\n", GetLastError()); ! 92: Free(MyOverlapped); ! 93: return(NULL); ! 94: } ! 95: ! 96: // ! 97: // Initialize other fields. ! 98: // (Set FileHandle non-NULL to keep GetAsyncResult happy) ! 99: // ! 100: ! 101: MyOverlapped->FileHandle = InitialState ? (HANDLE)1 : NULL; ! 102: MyOverlapped->BytesTransferred = 0; ! 103: MyOverlapped->CompletionCode = ERROR_SUCCESS; ! 104: MyOverlapped->CompletedSynchronously = TRUE; ! 105: ! 106: ! 107: return((HANDLE)MyOverlapped); ! 108: } ! 109: ! 110: ! 111: ! 112: ! 113: ///////////////////////////////////////////////////////////////////////////// ! 114: // ! 115: // DeleteAsync ! 116: // ! 117: // Deletes resources used by async object ! 118: // ! 119: // Returns nothing ! 120: // ! 121: ///////////////////////////////////////////////////////////////////////////// ! 122: ! 123: VOID ! 124: DeleteAsync( ! 125: HANDLE AsyncHandle ! 126: ) ! 127: { ! 128: PMYOVERLAPPED MyOverlapped = (PMYOVERLAPPED)AsyncHandle; ! 129: ! 130: MyCloseHandle(MyOverlapped->Overlapped.hEvent, "async overlapped event"); ! 131: Free(MyOverlapped); ! 132: ! 133: return; ! 134: } ! 135: ! 136: ! 137: ! 138: ! 139: ///////////////////////////////////////////////////////////////////////////// ! 140: // ! 141: // ReadFileAsync ! 142: // ! 143: // Reads from file asynchronously. ! 144: // ! 145: // Returns TRUE on success, FALSE on failure (GetLastError() for detail) ! 146: // ! 147: // Caller should wait on async event for operation to complete, then call ! 148: // GetAsyncResult to retrieve information on transfer. ! 149: // ! 150: ///////////////////////////////////////////////////////////////////////////// ! 151: ! 152: BOOL ! 153: ReadFileAsync( ! 154: HANDLE hFile, ! 155: LPVOID lpBuffer, ! 156: DWORD nBytesToRead, ! 157: HANDLE AsyncHandle ! 158: ) ! 159: { ! 160: BOOL Result; ! 161: DWORD Error; ! 162: PMYOVERLAPPED MyOverlapped = (PMYOVERLAPPED)AsyncHandle; ! 163: ! 164: // ! 165: // Check an IO operation is not in progress ! 166: // ! 167: ! 168: if (MyOverlapped->FileHandle != NULL) { ! 169: DbgPrint("ReadFileAsync : Operation already in progress!\n"); ! 170: SetLastError(ERROR_IO_PENDING); ! 171: return(FALSE); ! 172: } ! 173: ! 174: // ! 175: // Reset the event ! 176: // ! 177: ! 178: Result = ResetEvent(MyOverlapped->Overlapped.hEvent); ! 179: if (!Result) { ! 180: DbgPrint("ReadFileAsync : Failed to reset async event, error = %d\n", GetLastError()); ! 181: return(FALSE); ! 182: } ! 183: ! 184: ! 185: // ! 186: // Store the file handle in our structure. ! 187: // This also functions as a signal that an operation is in progress. ! 188: // ! 189: ! 190: MyOverlapped->FileHandle = hFile; ! 191: MyOverlapped->CompletedSynchronously = FALSE; ! 192: ! 193: Result = ReadFile(hFile, ! 194: lpBuffer, ! 195: nBytesToRead, ! 196: &MyOverlapped->BytesTransferred, ! 197: &MyOverlapped->Overlapped); ! 198: ! 199: if (!Result) { ! 200: ! 201: Error = GetLastError(); ! 202: ! 203: if (Error == ERROR_IO_PENDING) { ! 204: ! 205: // ! 206: // The I/O has been started synchronously, we're done ! 207: // ! 208: ! 209: return(TRUE); ! 210: } ! 211: ! 212: // ! 213: // The read really did fail, reset our flag and get out ! 214: // ! 215: ! 216: DbgPrint("ReadFileAsync : ReadFile failed, error = %d\n", Error); ! 217: MyOverlapped->FileHandle = NULL; ! 218: return(FALSE); ! 219: } ! 220: ! 221: ! 222: // ! 223: // The operation completed synchronously. Store the paramaters in our ! 224: // structure ready for GetAsyncResult and signal the event ! 225: // ! 226: ! 227: MyOverlapped->CompletionCode = ERROR_SUCCESS; ! 228: MyOverlapped->CompletedSynchronously = TRUE; ! 229: ! 230: // ! 231: // Set the event ! 232: // ! 233: ! 234: Result = SetEvent(MyOverlapped->Overlapped.hEvent); ! 235: if (!Result) { ! 236: DbgPrint("ReadFileAsync : Failed to set async event, error = %d\n", GetLastError()); ! 237: } ! 238: ! 239: return(TRUE); ! 240: } ! 241: ! 242: ! 243: ! 244: ///////////////////////////////////////////////////////////////////////////// ! 245: // ! 246: // WriteFileAsync ! 247: // ! 248: // Writes to file asynchronously. ! 249: // ! 250: // Returns TRUE on success, FALSE on failure (GetLastError() for detail) ! 251: // ! 252: // Caller should wait on async event for operation to complete, then call ! 253: // GetAsyncResult to retrieve information on transfer. ! 254: // ! 255: ///////////////////////////////////////////////////////////////////////////// ! 256: ! 257: BOOL ! 258: WriteFileAsync( ! 259: HANDLE hFile, ! 260: LPVOID lpBuffer, ! 261: DWORD nBytesToWrite, ! 262: HANDLE AsyncHandle ! 263: ) ! 264: { ! 265: BOOL Result; ! 266: DWORD Error; ! 267: PMYOVERLAPPED MyOverlapped = (PMYOVERLAPPED)AsyncHandle; ! 268: ! 269: // ! 270: // Check an IO operation is not in progress ! 271: // ! 272: ! 273: if (MyOverlapped->FileHandle != NULL) { ! 274: DbgPrint("ReadFileAsync : Operation already in progress!\n"); ! 275: SetLastError(ERROR_IO_PENDING); ! 276: return(FALSE); ! 277: } ! 278: ! 279: ! 280: // ! 281: // Reset the event ! 282: // ! 283: ! 284: Result = ResetEvent(MyOverlapped->Overlapped.hEvent); ! 285: if (!Result) { ! 286: DbgPrint("WriteFileAsync : Failed to reset async event, error = %d\n", GetLastError()); ! 287: return(FALSE); ! 288: } ! 289: ! 290: // ! 291: // Store the file handle in our structure. ! 292: // This also functions as a signal that an operation is in progress. ! 293: // ! 294: ! 295: MyOverlapped->FileHandle = hFile; ! 296: MyOverlapped->CompletedSynchronously = FALSE; ! 297: ! 298: Result = WriteFile(hFile, ! 299: lpBuffer, ! 300: nBytesToWrite, ! 301: &MyOverlapped->BytesTransferred, ! 302: &MyOverlapped->Overlapped); ! 303: ! 304: if (!Result) { ! 305: ! 306: Error = GetLastError(); ! 307: ! 308: if (Error == ERROR_IO_PENDING) { ! 309: ! 310: // ! 311: // The I/O has been started synchronously, we're done ! 312: // ! 313: ! 314: return(TRUE); ! 315: } ! 316: ! 317: // ! 318: // The read really did fail, reset our flag and get out ! 319: // ! 320: ! 321: DbgPrint("WriteFileAsync : WriteFile failed, error = %d\n", Error); ! 322: MyOverlapped->FileHandle = NULL; ! 323: return(FALSE); ! 324: } ! 325: ! 326: ! 327: // ! 328: // The operation completed synchronously. Store the paramaters in our ! 329: // structure ready for GetAsyncResult and signal the event ! 330: // ! 331: ! 332: MyOverlapped->CompletionCode = ERROR_SUCCESS; ! 333: MyOverlapped->CompletedSynchronously = TRUE; ! 334: ! 335: // ! 336: // Set the event ! 337: // ! 338: ! 339: Result = SetEvent(MyOverlapped->Overlapped.hEvent); ! 340: if (!Result) { ! 341: DbgPrint("WriteFileAsync : Failed to set async event, error = %d\n", GetLastError()); ! 342: } ! 343: ! 344: return(TRUE); ! 345: } ! 346: ! 347: ! 348: ! 349: ! 350: ///////////////////////////////////////////////////////////////////////////// ! 351: // ! 352: // GetCompletionHandle ! 353: // ! 354: // Returns a handle that can be used to wait for completion of the ! 355: // operation associated with this async object ! 356: // ! 357: // Returns an event handle or NULL on failure ! 358: // ! 359: ///////////////////////////////////////////////////////////////////////////// ! 360: ! 361: HANDLE ! 362: GetAsyncCompletionHandle( ! 363: HANDLE AsyncHandle ! 364: ) ! 365: { ! 366: PMYOVERLAPPED MyOverlapped = (PMYOVERLAPPED)AsyncHandle; ! 367: ! 368: return(MyOverlapped->Overlapped.hEvent); ! 369: } ! 370: ! 371: ! 372: ! 373: ! 374: ///////////////////////////////////////////////////////////////////////////// ! 375: // ! 376: // GetAsyncResult ! 377: // ! 378: // Returns the result of the last completed operation involving the ! 379: // passed async object handle. ! 380: // ! 381: // Returns the completion code of the last operation OR ! 382: // ERROR_IO_INCOMPLETE if the operation has not completed. ! 383: // ERROR_NO_DATA if there is no operation in progress. ! 384: // ! 385: ///////////////////////////////////////////////////////////////////////////// ! 386: ! 387: DWORD ! 388: GetAsyncResult( ! 389: HANDLE AsyncHandle, ! 390: LPDWORD BytesTransferred ! 391: ) ! 392: { ! 393: BOOL Result; ! 394: DWORD WaitResult; ! 395: PMYOVERLAPPED MyOverlapped = (PMYOVERLAPPED)AsyncHandle; ! 396: DWORD AsyncResult; ! 397: ! 398: // ! 399: // Check an IO operation is (was) in progress ! 400: // ! 401: ! 402: if (MyOverlapped->FileHandle == NULL) { ! 403: DbgPrint("GetAsyncResult : No operation in progress !\n"); ! 404: return(ERROR_NO_DATA); ! 405: } ! 406: ! 407: ! 408: // ! 409: // Check the event is set - i.e that an IO operation has completed ! 410: // ! 411: ! 412: WaitResult = WaitForSingleObject(MyOverlapped->Overlapped.hEvent, 0); ! 413: if (WaitResult != 0) { ! 414: DbgPrint("GetAsyncResult : Event was not set, wait result = %d\n", WaitResult); ! 415: return(ERROR_IO_INCOMPLETE); ! 416: } ! 417: ! 418: ! 419: // ! 420: // If the call completed synchronously, copy the data out of ! 421: // our structure ! 422: // ! 423: ! 424: if (MyOverlapped->CompletedSynchronously) { ! 425: ! 426: AsyncResult = MyOverlapped->CompletionCode; ! 427: *BytesTransferred = MyOverlapped->BytesTransferred; ! 428: ! 429: } else { ! 430: ! 431: // ! 432: // Go get the asynchronous result info from the system ! 433: // ! 434: ! 435: AsyncResult = ERROR_SUCCESS; ! 436: ! 437: Result = GetOverlappedResult(MyOverlapped->FileHandle, ! 438: &MyOverlapped->Overlapped, ! 439: BytesTransferred, ! 440: FALSE); ! 441: if (!Result) { ! 442: AsyncResult = GetLastError(); ! 443: DbgPrint("GetAsyncResult : GetOverlappedResult failed, error = %d\n", AsyncResult); ! 444: } ! 445: } ! 446: ! 447: ! 448: // ! 449: // Reset the event so it doesn't trigger the caller again ! 450: // ! 451: ! 452: Result = ResetEvent(MyOverlapped->Overlapped.hEvent); ! 453: if (!Result) { ! 454: DbgPrint("GetAsyncResult : Failed to reset async event\n"); ! 455: } ! 456: ! 457: ! 458: // ! 459: // Result the file handle so we know there is no pending operation ! 460: // ! 461: ! 462: MyOverlapped->FileHandle = NULL; ! 463: ! 464: ! 465: return(AsyncResult); ! 466: } ! 467: ! 468: ! 469:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.