![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to session.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 session.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / rshell / server |
1.1 ! root 1: /****************************** Module Header ******************************\ ! 2: * Module Name: session.c ! 3: * ! 4: * Copyright (c) 1991, Microsoft Corporation ! 5: * ! 6: * Remote shell session module ! 7: * ! 8: * History: ! 9: * 06-28-92 Davidc Created. ! 10: \***************************************************************************/ ! 11: ! 12: #include "rcmdsrv.h" ! 13: ! 14: #include <io.h> ! 15: ! 16: // ! 17: // Global pointer to generate console ctrl event fn ! 18: // Dynamically link to this api so exe will run ! 19: // on pre build-304 systems. ! 20: // ! 21: ! 22: typedef BOOL (APIENTRY * GENERATE_CONSOLE_CTRL_EVENT_FN)(DWORD dwCtrlEvent, ! 23: DWORD dwProcessGroupId); ! 24: ! 25: static GENERATE_CONSOLE_CTRL_EVENT_FN GenerateConsoleCtrlEventfn = NULL; ! 26: ! 27: #define GENERATE_CONSOLE_CTRL_EVENT_MODULE TEXT("kernel32.dll") ! 28: #define GENERATE_CONSOLE_CTRL_EVENT_NAME "GenerateConsoleCtrlEvent" ! 29: ! 30: // ! 31: // Define standard handles ! 32: // ! 33: ! 34: #define STDIN 0 ! 35: #define STDOUT 1 ! 36: #define STDERROR 2 ! 37: ! 38: // ! 39: // Define shell command line ! 40: // ! 41: ! 42: #define SHELL_COMMAND_LINE TEXT("cmd /q") ! 43: ! 44: // ! 45: // Define buffer size for reads/writes to/from shell ! 46: // ! 47: ! 48: #define SHELL_BUFFER_SIZE 1000 ! 49: ! 50: ! 51: // ! 52: // Define the structure used to describe each session ! 53: // ! 54: ! 55: typedef struct { ! 56: ! 57: // ! 58: // These fields are filled in at session creation time ! 59: // ! 60: ! 61: HANDLE ShellReadPipeHandle; // Handle to shell stdout pipe ! 62: HANDLE ShellWritePipeHandle; // Handle to shell stdin pipe ! 63: HANDLE ShellProcessHandle; // Handle to shell process ! 64: ! 65: // ! 66: // These fields maintain the state of asynchronouse reads/writes ! 67: // to the shell process across client disconnections. They ! 68: // are initialized at session creation. ! 69: // ! 70: ! 71: BYTE ShellReadBuffer[SHELL_BUFFER_SIZE]; // Data for shell reads goes here ! 72: HANDLE ShellReadAsyncHandle; // Object used for async reads from shell ! 73: BOOL ShellReadPending; ! 74: ! 75: BYTE ShellWriteBuffer[SHELL_BUFFER_SIZE]; // Data for shell writes goes here ! 76: HANDLE ShellWriteAsyncHandle; // Object used for async writes to shell ! 77: BOOL ShellWritePending; ! 78: ! 79: // ! 80: // These fields are filled in at session connect time and are only ! 81: // valid when the session is connected ! 82: // ! 83: ! 84: HANDLE ClientPipeHandle; // Handle to client pipe ! 85: HANDLE SessionThreadHandle; // Handle to session thread ! 86: HANDLE SessionThreadSignalEventHandle; // Handle to event used to signal thread ! 87: ! 88: ! 89: } SESSION_DATA, *PSESSION_DATA; ! 90: ! 91: ! 92: ! 93: ! 94: // ! 95: // Private prototypes ! 96: // ! 97: ! 98: HANDLE ! 99: StartShell( ! 100: int StdinCrtHandle, ! 101: int StdoutCrtHandle ! 102: ); ! 103: ! 104: DWORD ! 105: SessionThreadFn( ! 106: LPVOID Parameter ! 107: ); ! 108: ! 109: ! 110: // ! 111: // Useful macros ! 112: // ! 113: ! 114: #define SESSION_CONNECTED(Session) ((Session)->ClientPipeHandle != NULL) ! 115: ! 116: ! 117: ! 118: ! 119: ///////////////////////////////////////////////////////////////////////////// ! 120: // ! 121: // CreateSession ! 122: // ! 123: // Creates a new session. Involves creating the shell process and establishing ! 124: // pipes for communication with it. ! 125: // ! 126: // Returns a handle to the session or NULL on failure. ! 127: // ! 128: ///////////////////////////////////////////////////////////////////////////// ! 129: ! 130: HANDLE ! 131: CreateSession( ! 132: VOID ! 133: ) ! 134: { ! 135: PSESSION_DATA Session = NULL; ! 136: BOOL Result; ! 137: SECURITY_ATTRIBUTES SecurityAttributes; ! 138: HANDLE ShellStdinPipe = NULL; ! 139: HANDLE ShellStdoutPipe = NULL; ! 140: int ShellStdinCrtHandle; ! 141: int ShellStdoutCrtHandle; ! 142: ! 143: // ! 144: // Allocate space for the session data ! 145: // ! 146: ! 147: Session = (PSESSION_DATA)Alloc(sizeof(SESSION_DATA)); ! 148: if (Session == NULL) { ! 149: return(NULL); ! 150: } ! 151: ! 152: // ! 153: // Reset fields in preparation for failure ! 154: // ! 155: ! 156: Session->ShellReadPipeHandle = NULL; ! 157: Session->ShellWritePipeHandle = NULL; ! 158: Session->ShellReadAsyncHandle = NULL; ! 159: Session->ShellWriteAsyncHandle = NULL; ! 160: ! 161: ! 162: // ! 163: // Create the I/O pipes for the shell ! 164: // ! 165: ! 166: SecurityAttributes.nLength = sizeof(SecurityAttributes); ! 167: SecurityAttributes.lpSecurityDescriptor = NULL; // Use default ACL ! 168: SecurityAttributes.bInheritHandle = TRUE; // Shell will inherit handles ! 169: ! 170: Result = MyCreatePipe(&Session->ShellReadPipeHandle, ! 171: &ShellStdoutPipe, ! 172: &SecurityAttributes, ! 173: 0, // Default pipe size ! 174: 0, // Default timeout ! 175: FILE_FLAG_OVERLAPPED, // shell read flags ! 176: 0 // shell stdout flags ! 177: ); ! 178: if (!Result) { ! 179: DbgPrint("Failed to create shell stdout pipe, error = %d\n", GetLastError()); ! 180: goto Failure; ! 181: } ! 182: ! 183: Result = MyCreatePipe(&ShellStdinPipe, ! 184: &Session->ShellWritePipeHandle, ! 185: &SecurityAttributes, ! 186: 0, // Default pipe size ! 187: 0, // Default timeout ! 188: 0, // shell stdin flags ! 189: FILE_FLAG_OVERLAPPED // shell write flags ! 190: ); ! 191: if (!Result) { ! 192: DbgPrint("Failed to create shell stdin pipe, error = %d\n", GetLastError()); ! 193: goto Failure; ! 194: } ! 195: ! 196: ! 197: // ! 198: // Initialize async objects ! 199: // ! 200: ! 201: Session->ShellReadAsyncHandle = CreateAsync(FALSE); ! 202: if (Session->ShellReadAsyncHandle == NULL) { ! 203: DbgPrint("Failed to create shell read async object, error = %d\n", GetLastError()); ! 204: goto Failure; ! 205: } ! 206: ! 207: Session->ShellWriteAsyncHandle = CreateAsync(FALSE); ! 208: if (Session->ShellWriteAsyncHandle == NULL) { ! 209: DbgPrint("Failed to create shell write async object, error = %d\n", GetLastError()); ! 210: goto Failure; ! 211: } ! 212: ! 213: Session->ShellReadPending = FALSE; ! 214: Session->ShellWritePending = FALSE; ! 215: ! 216: ! 217: // ! 218: // Create a runtime handle for shell pipes ! 219: // ! 220: ! 221: ShellStdinCrtHandle = _open_osfhandle((long)ShellStdinPipe, 0); ! 222: assert(ShellStdinCrtHandle != -1); ! 223: ShellStdoutCrtHandle = _open_osfhandle((long)ShellStdoutPipe, 0); ! 224: assert(ShellStdoutCrtHandle != -1); ! 225: ! 226: ! 227: // ! 228: // Start the shell ! 229: // ! 230: ! 231: Session->ShellProcessHandle = StartShell(ShellStdinCrtHandle, ShellStdoutCrtHandle); ! 232: ! 233: // ! 234: // We're finished with our copy of the shell pipe handles ! 235: // Closing the runtime handles will close the pipe handles for us. ! 236: // ! 237: ! 238: close(ShellStdinCrtHandle); ! 239: ShellStdinPipe = NULL; ! 240: close(ShellStdoutCrtHandle); ! 241: ShellStdoutPipe = NULL; ! 242: ! 243: // ! 244: // Check result of shell start ! 245: // ! 246: ! 247: if (Session->ShellProcessHandle == NULL) { ! 248: DbgPrint("Failed to execute shell\n"); ! 249: goto Failure; ! 250: } ! 251: ! 252: ! 253: // ! 254: // Get the address of the GenerateConsoleCtrlEvent function ! 255: // if it's available ! 256: // ! 257: ! 258: if (GenerateConsoleCtrlEventfn == NULL) { ! 259: ! 260: HANDLE hMod = LoadLibrary(GENERATE_CONSOLE_CTRL_EVENT_MODULE); ! 261: ! 262: if (hMod != NULL) { ! 263: ! 264: GenerateConsoleCtrlEventfn = (GENERATE_CONSOLE_CTRL_EVENT_FN) ! 265: GetProcAddress(hMod, GENERATE_CONSOLE_CTRL_EVENT_NAME); ! 266: ! 267: if (GenerateConsoleCtrlEventfn == NULL) { ! 268: DbgPrint("Failed to get address of %s function\n", GENERATE_CONSOLE_CTRL_EVENT_NAME); ! 269: } ! 270: ! 271: FreeLibrary(hMod); ! 272: ! 273: } else { ! 274: DbgPrint("Load library failed on kernel32.dll!, error = %d\n", GetLastError()); ! 275: } ! 276: } ! 277: ! 278: ! 279: // ! 280: // If any code is added here, remember to cleanup process handle ! 281: // in failure code ! 282: // ! 283: ! 284: ! 285: // ! 286: // The session is not connected, initialize variables to indicate that ! 287: // ! 288: ! 289: Session->ClientPipeHandle = NULL; ! 290: ! 291: ! 292: // ! 293: // Success, return the session pointer as a handle ! 294: // ! 295: ! 296: return((HANDLE)Session); ! 297: ! 298: ! 299: ! 300: Failure: ! 301: ! 302: // ! 303: // We get here for any failure case. ! 304: // Free up any resources and exit ! 305: // ! 306: ! 307: ! 308: // ! 309: // Cleanup shell pipe handles ! 310: // ! 311: ! 312: if (ShellStdinPipe != NULL) { ! 313: MyCloseHandle(ShellStdinPipe, "shell stdin pipe (shell side)"); ! 314: } ! 315: ! 316: if (ShellStdoutPipe != NULL) { ! 317: MyCloseHandle(ShellStdoutPipe, "shell stdout pipe (shell side)"); ! 318: } ! 319: ! 320: if (Session->ShellReadPipeHandle != NULL) { ! 321: MyCloseHandle(Session->ShellReadPipeHandle, "shell read pipe (session side)"); ! 322: } ! 323: ! 324: if (Session->ShellWritePipeHandle != NULL) { ! 325: MyCloseHandle(Session->ShellWritePipeHandle, "shell write pipe (session side)"); ! 326: } ! 327: ! 328: ! 329: // ! 330: // Cleanup async data ! 331: // ! 332: ! 333: if (Session->ShellReadAsyncHandle != NULL) { ! 334: DeleteAsync(Session->ShellReadAsyncHandle); ! 335: } ! 336: ! 337: if (Session->ShellWriteAsyncHandle != NULL) { ! 338: DeleteAsync(Session->ShellWriteAsyncHandle); ! 339: } ! 340: ! 341: ! 342: // ! 343: // Free up our session data ! 344: // ! 345: ! 346: Free(Session); ! 347: ! 348: return(NULL); ! 349: } ! 350: ! 351: ! 352: ! 353: ! 354: ///////////////////////////////////////////////////////////////////////////// ! 355: // ! 356: // DeleteSession ! 357: // ! 358: // Deletes the session specified by SessionHandle. ! 359: // ! 360: // Returns nothing ! 361: // ! 362: ///////////////////////////////////////////////////////////////////////////// ! 363: ! 364: VOID ! 365: DeleteSession( ! 366: HANDLE SessionHandle ! 367: ) ! 368: { ! 369: PSESSION_DATA Session = (PSESSION_DATA)SessionHandle; ! 370: BOOL Result; ! 371: ! 372: // ! 373: // Disconnect session first ! 374: // ! 375: ! 376: if (SESSION_CONNECTED(Session)) { ! 377: DisconnectSession(SessionHandle); ! 378: } ! 379: ! 380: ! 381: // ! 382: // Kill off the shell process ! 383: // ! 384: ! 385: Result = TerminateProcess(Session->ShellProcessHandle, 1); ! 386: if (!Result) { ! 387: DbgPrint("Failed to terminate shell, error = %d\n", GetLastError()); ! 388: } ! 389: ! 390: MyCloseHandle(Session->ShellProcessHandle, "shell process"); ! 391: ! 392: ! 393: // ! 394: // Close the shell pipe handles ! 395: // ! 396: ! 397: MyCloseHandle(Session->ShellReadPipeHandle, "shell read pipe (session side)"); ! 398: MyCloseHandle(Session->ShellWritePipeHandle, "shell write pipe (session side)"); ! 399: ! 400: ! 401: // ! 402: // Cleanup async data ! 403: // ! 404: ! 405: DeleteAsync(Session->ShellReadAsyncHandle); ! 406: DeleteAsync(Session->ShellWriteAsyncHandle); ! 407: ! 408: ! 409: // ! 410: // Free up the session structure ! 411: // ! 412: ! 413: Free(Session); ! 414: ! 415: // ! 416: // We're done ! 417: // ! 418: ! 419: return; ! 420: } ! 421: ! 422: ! 423: ! 424: ! 425: ///////////////////////////////////////////////////////////////////////////// ! 426: // ! 427: // ConnectSession ! 428: // ! 429: // Connects the session specified by SessionHandle to a client ! 430: // on the other end of the pipe specified by PipeHandle ! 431: // ! 432: // Returns a session disconnect notification handle or NULL on failure. ! 433: // The returned handle will be signalled if the client disconnects or the ! 434: // shell terminates. ! 435: // Calling DisconnectSession will return the disconnect notification code. ! 436: // ! 437: ///////////////////////////////////////////////////////////////////////////// ! 438: ! 439: HANDLE ! 440: ConnectSession( ! 441: HANDLE SessionHandle, ! 442: HANDLE ClientPipeHandle ! 443: ) ! 444: { ! 445: PSESSION_DATA Session = (PSESSION_DATA)SessionHandle; ! 446: SECURITY_ATTRIBUTES SecurityAttributes; ! 447: DWORD ThreadId; ! 448: ! 449: assert(ClientPipeHandle != NULL); ! 450: ! 451: // ! 452: // Fail if the session is already connected ! 453: // ! 454: ! 455: if (SESSION_CONNECTED(Session)) { ! 456: DbgPrint("Attempted to connect session already connected\n"); ! 457: return(NULL); ! 458: } ! 459: ! 460: // ! 461: // Create the thread signal event. We'll use this to tell the ! 462: // thread to exit during disconnection. ! 463: // ! 464: ! 465: SecurityAttributes.nLength = sizeof(SecurityAttributes); ! 466: SecurityAttributes.lpSecurityDescriptor = NULL; // Use default ACL ! 467: SecurityAttributes.bInheritHandle = FALSE; // No inheritance ! 468: ! 469: Session->SessionThreadSignalEventHandle = CreateEvent(&SecurityAttributes, ! 470: TRUE, // Manual reset ! 471: FALSE, // Initially clear ! 472: NULL); // No name ! 473: if (Session->SessionThreadSignalEventHandle == NULL) { ! 474: DbgPrint("Failed to create thread signal event, error = %d\n", GetLastError()); ! 475: return(NULL); ! 476: } ! 477: ! 478: ! 479: // ! 480: // Store the client pipe handle in the session structure so the thread ! 481: // can get at it. This also signals that the session is connected. ! 482: // ! 483: ! 484: Session->ClientPipeHandle = ClientPipeHandle; ! 485: ! 486: ! 487: // ! 488: // Create the session thread ! 489: // ! 490: ! 491: Session->SessionThreadHandle = CreateThread( ! 492: &SecurityAttributes, ! 493: 0, // Default stack size ! 494: (LPTHREAD_START_ROUTINE)SessionThreadFn, // Start address ! 495: (LPVOID)Session, // Parameter ! 496: 0, // Creation flags ! 497: &ThreadId // Thread id ! 498: ); ! 499: if (Session->SessionThreadHandle == NULL) { ! 500: ! 501: DbgPrint("Failed to create session thread, error = %d\n", GetLastError()); ! 502: ! 503: // ! 504: // Close the thread signal event ! 505: // ! 506: ! 507: MyCloseHandle(Session->SessionThreadSignalEventHandle, "thread signal event"); ! 508: ! 509: // ! 510: // Reset the client pipe handle to indicate this session is disconnected ! 511: // ! 512: ! 513: Session->ClientPipeHandle = NULL; ! 514: } ! 515: ! 516: ! 517: return(Session->SessionThreadHandle); ! 518: } ! 519: ! 520: ! 521: ! 522: ! 523: ///////////////////////////////////////////////////////////////////////////// ! 524: // ! 525: // DisconnectSession ! 526: // ! 527: // Disconnects the session specified by SessionHandle for its client. ! 528: // ! 529: // Returns a disconnect notification code (DisconnectError on failure) ! 530: // ! 531: ///////////////////////////////////////////////////////////////////////////// ! 532: ! 533: SESSION_DISCONNECT_CODE ! 534: DisconnectSession( ! 535: HANDLE SessionHandle ! 536: ) ! 537: { ! 538: PSESSION_DATA Session = (PSESSION_DATA)SessionHandle; ! 539: DWORD TerminationCode; ! 540: SESSION_DISCONNECT_CODE DisconnectCode; ! 541: BOOL Result; ! 542: DWORD WaitResult; ! 543: ! 544: // ! 545: // Signal the thread to terminate (if it hasn't already) ! 546: // ! 547: ! 548: Result = SetEvent(Session->SessionThreadSignalEventHandle); ! 549: if (!Result) { ! 550: DbgPrint("Failed to set thread signal event, error = %d\n", GetLastError()); ! 551: } ! 552: ! 553: // ! 554: // Wait for the thread to terminate ! 555: // ! 556: ! 557: DbgPrint("Waiting for session thread to terminate..."); ! 558: ! 559: WaitResult = WaitForSingleObject(Session->SessionThreadHandle, INFINITE); ! 560: if (WaitResult != 0) { ! 561: DbgPrint("Unexpected result from infinite wait on thread handle, result = %d\n", WaitResult); ! 562: } ! 563: ! 564: DbgPrint("done\n"); ! 565: ! 566: ! 567: // ! 568: // Get the thread termination code ! 569: // ! 570: ! 571: Result = GetExitCodeThread(Session->SessionThreadHandle, &TerminationCode); ! 572: if (!Result) { ! 573: DbgPrint("Failed to get termination code for thread, error = %d\n", GetLastError()); ! 574: TerminationCode = (DWORD)DisconnectError; ! 575: } else { ! 576: if (TerminationCode == STILL_ACTIVE) { ! 577: DbgPrint("Got termination code for thread, it's still active!\n"); ! 578: TerminationCode = (DWORD)DisconnectError; ! 579: } ! 580: } ! 581: ! 582: DisconnectCode = (SESSION_DISCONNECT_CODE)TerminationCode; ! 583: ! 584: ! 585: ! 586: // ! 587: // Close the thread handle and thread signal event handle ! 588: // ! 589: ! 590: MyCloseHandle(Session->SessionThreadHandle, "session thread"); ! 591: MyCloseHandle(Session->SessionThreadSignalEventHandle, "thread signal event"); ! 592: ! 593: ! 594: // ! 595: // Reset the client pipe handle to signal that this session is disconnected ! 596: // The pipe handle will have been closed by the session thread on exit ! 597: // ! 598: ! 599: Session->ClientPipeHandle = NULL; ! 600: ! 601: ! 602: // ! 603: // We're done ! 604: // ! 605: ! 606: return(DisconnectCode); ! 607: } ! 608: ! 609: ! 610: ! 611: ! 612: ! 613: ! 614: ! 615: ! 616: ///////////////////////////////////////////////////////////////////////////// ! 617: // ! 618: // StartShell ! 619: // ! 620: // Execs the shell with the specified handle as stdin, stdout/err ! 621: // ! 622: // Returns process handle or NULL on failure ! 623: // ! 624: ///////////////////////////////////////////////////////////////////////////// ! 625: ! 626: HANDLE ! 627: StartShell( ! 628: int ShellStdinCrtHandle, ! 629: int ShellStdoutCrtHandle ! 630: ) ! 631: { ! 632: int StdInputHandle; ! 633: int StdOutputHandle; ! 634: int StdErrorHandle; ! 635: int crtResult; ! 636: PROCESS_INFORMATION ProcessInformation; ! 637: STARTUPINFO si; ! 638: HANDLE ProcessHandle = NULL; ! 639: ! 640: ! 641: // ! 642: // Replace std handles with appropriate pipe handles and exec the ! 643: // shell process. It will inherit our std handles and we can then ! 644: // reset them to normal ! 645: // ! 646: ! 647: ! 648: // ! 649: // Store away our normal i/o handles ! 650: // ! 651: ! 652: StdInputHandle = dup(STDIN); ! 653: assert(StdInputHandle != -1); ! 654: StdOutputHandle = dup(STDOUT); ! 655: assert(StdOutputHandle != -1); ! 656: StdErrorHandle = dup(STDERROR); ! 657: assert(StdErrorHandle != -1); ! 658: ! 659: // ! 660: // Replace std handles with pipe handle. ! 661: // ! 662: ! 663: crtResult = dup2(ShellStdinCrtHandle, STDIN); ! 664: assert(crtResult == 0); ! 665: crtResult = dup2(ShellStdoutCrtHandle, STDOUT); ! 666: assert(crtResult == 0); ! 667: crtResult = dup2(ShellStdoutCrtHandle, STDERROR); ! 668: assert(crtResult == 0); ! 669: ! 670: // ! 671: // Initialize process startup info ! 672: // ! 673: ! 674: si.cb = sizeof(STARTUPINFO); ! 675: si.lpReserved = NULL; ! 676: si.lpTitle = NULL; ! 677: si.lpDesktop = NULL; ! 678: si.dwX = si.dwY = si.dwXSize = si.dwYSize = si.dwFlags = 0L; ! 679: si.wShowWindow = SW_SHOW; ! 680: si.lpReserved2 = NULL; ! 681: si.cbReserved2 = 0; ! 682: ! 683: if (CreateProcess(NULL, ! 684: SHELL_COMMAND_LINE, ! 685: NULL, ! 686: NULL, ! 687: TRUE, // Inherit handles ! 688: 0, ! 689: NULL, ! 690: NULL, ! 691: &si, ! 692: &ProcessInformation)) { ! 693: ! 694: ProcessHandle = ProcessInformation.hProcess; ! 695: MyCloseHandle(ProcessInformation.hThread, "process thread"); ! 696: ! 697: } else { ! 698: DbgPrint("Failed to execute shell, error = %d\n", GetLastError()); ! 699: } ! 700: ! 701: ! 702: ! 703: // ! 704: // Restore std handles to normal ! 705: // ! 706: ! 707: crtResult = dup2(StdInputHandle, STDIN); ! 708: assert(crtResult == 0); ! 709: crtResult = dup2(StdOutputHandle, STDOUT); ! 710: assert(crtResult == 0); ! 711: crtResult = dup2(StdErrorHandle, STDERROR); ! 712: assert(crtResult == 0); ! 713: ! 714: // ! 715: // Close any handles we created ! 716: // ! 717: ! 718: crtResult = close(StdInputHandle); ! 719: assert(crtResult == 0); ! 720: crtResult = close(StdOutputHandle); ! 721: assert(crtResult == 0); ! 722: crtResult = close(StdErrorHandle); ! 723: assert(crtResult == 0); ! 724: ! 725: ! 726: return(ProcessHandle); ! 727: } ! 728: ! 729: ! 730: ! 731: ! 732: ! 733: ! 734: ! 735: ! 736: ///////////////////////////////////////////////////////////////////////////// ! 737: // ! 738: // SessionThreadFn ! 739: // ! 740: // This is the code executed by the session thread ! 741: // ! 742: // Waits for read or write from/to shell or client pipe and termination ! 743: // event. Handles reads or writes by passing data to either client or ! 744: // shell as appropriate. Any error or termination event being signalled ! 745: // causes the thread to exit with an appropriate exit code. ! 746: // ! 747: ///////////////////////////////////////////////////////////////////////////// ! 748: ! 749: DWORD ! 750: SessionThreadFn( ! 751: LPVOID Parameter ! 752: ) ! 753: { ! 754: PSESSION_DATA Session = (PSESSION_DATA)Parameter; ! 755: HANDLE ClientReadAsyncHandle; ! 756: HANDLE ClientWriteAsyncHandle; ! 757: DWORD BytesTransferred; ! 758: DWORD CompletionCode; ! 759: BOOL Result; ! 760: DWORD WaitResult; ! 761: DWORD ExitCode; ! 762: HANDLE WaitHandles[5]; ! 763: BOOL Done; ! 764: DWORD i; ! 765: ! 766: if (Session->ShellWritePending) { ! 767: printf("SessionThread started - SHELL-WRITE-PENDING\n"); ! 768: } ! 769: if (Session->ShellReadPending) { ! 770: printf("SessionThread started - SHELL-READ-PENDING\n"); ! 771: } ! 772: ! 773: // ! 774: // Initialize the client async structures ! 775: // ! 776: ! 777: ClientReadAsyncHandle = CreateAsync(!Session->ShellWritePending); ! 778: if (ClientReadAsyncHandle == NULL) { ! 779: DbgPrint("Failed to create client read async object, error = %d\n", GetLastError()); ! 780: return((DWORD)ConnectError); ! 781: } ! 782: ! 783: ClientWriteAsyncHandle = CreateAsync(!Session->ShellReadPending); ! 784: if (ClientWriteAsyncHandle == NULL) { ! 785: DbgPrint("Failed to create client write async object, error = %d\n", GetLastError()); ! 786: DeleteAsync(ClientReadAsyncHandle); ! 787: return((DWORD)ConnectError); ! 788: } ! 789: ! 790: ! 791: ! 792: // ! 793: // Initialize the handle array we'll wait on ! 794: // ! 795: ! 796: WaitHandles[0] = Session->SessionThreadSignalEventHandle; ! 797: WaitHandles[1] = GetAsyncCompletionHandle(Session->ShellReadAsyncHandle); ! 798: WaitHandles[2] = GetAsyncCompletionHandle(Session->ShellWriteAsyncHandle); ! 799: WaitHandles[3] = GetAsyncCompletionHandle(ClientReadAsyncHandle); ! 800: WaitHandles[4] = GetAsyncCompletionHandle(ClientWriteAsyncHandle); ! 801: ! 802: // ! 803: // Wait on our handle array in a loop until an error occurs or ! 804: // we're signalled to exit. ! 805: // ! 806: ! 807: Done = FALSE; ! 808: ! 809: while (!Done) { ! 810: ! 811: // ! 812: // Wait for one of our objects to be signalled. ! 813: // ! 814: ! 815: WaitResult = WaitForMultipleObjects(5, WaitHandles, FALSE, INFINITE); ! 816: ! 817: if (WaitResult == 0xffffffff) { ! 818: DbgPrint("Session thread wait failed, error = %d\n", GetLastError()); ! 819: ExitCode = (DWORD)ConnectError; ! 820: break; // out of while ! 821: } ! 822: ! 823: ! 824: switch (WaitResult) { ! 825: case 0: ! 826: ! 827: // ! 828: // Our thread was signalled ! 829: // ! 830: ExitCode = (DWORD)ClientDisconnected; ! 831: Done = TRUE; ! 832: break; // out of switch ! 833: ! 834: case 1: ! 835: ! 836: // ! 837: // Shell read completed ! 838: // ! 839: ! 840: Session->ShellReadPending = FALSE; ! 841: ! 842: CompletionCode = GetAsyncResult(Session->ShellReadAsyncHandle, ! 843: &BytesTransferred); ! 844: ! 845: if (CompletionCode != ERROR_SUCCESS) { ! 846: DbgPrint("Async read from shell returned error, completion code = %d\n", CompletionCode); ! 847: ExitCode = (DWORD)ShellEnded; ! 848: Done = TRUE; ! 849: break; // out of switch ! 850: } ! 851: ! 852: // ! 853: // Start an async write to client pipe ! 854: // ! 855: ! 856: Result = WriteFileAsync(Session->ClientPipeHandle, ! 857: Session->ShellReadBuffer, ! 858: BytesTransferred, ! 859: ClientWriteAsyncHandle); ! 860: if (!Result) { ! 861: DbgPrint("Async write to client pipe failed, error = %d\n", GetLastError()); ! 862: ExitCode = (DWORD)ClientDisconnected; ! 863: Done = TRUE; ! 864: } ! 865: ! 866: break; // out of switch ! 867: ! 868: ! 869: case 4: ! 870: ! 871: // ! 872: // Client write completed ! 873: // ! 874: ! 875: CompletionCode = GetAsyncResult(ClientWriteAsyncHandle, ! 876: &BytesTransferred); ! 877: ! 878: if (CompletionCode != ERROR_SUCCESS) { ! 879: DbgPrint("Async write to client returned error, completion code = %d\n", CompletionCode); ! 880: ExitCode = (DWORD)ClientDisconnected; ! 881: Done = TRUE; ! 882: break; // out of switch ! 883: } ! 884: ! 885: // ! 886: // Start an async read from shell ! 887: // ! 888: ! 889: Result = ReadFileAsync(Session->ShellReadPipeHandle, ! 890: Session->ShellReadBuffer, ! 891: sizeof(Session->ShellReadBuffer), ! 892: Session->ShellReadAsyncHandle); ! 893: if (!Result) { ! 894: DbgPrint("Async read from shell failed, error = %d\n", GetLastError()); ! 895: ExitCode = (DWORD)ShellEnded; ! 896: Done = TRUE; ! 897: } else { ! 898: Session->ShellReadPending = TRUE; ! 899: } ! 900: ! 901: break; // out of switch ! 902: ! 903: ! 904: case 3: ! 905: ! 906: // ! 907: // Client read completed ! 908: // ! 909: ! 910: CompletionCode = GetAsyncResult(ClientReadAsyncHandle, ! 911: &BytesTransferred); ! 912: ! 913: if (CompletionCode != ERROR_SUCCESS) { ! 914: DbgPrint("Async read from client returned error, completion code = %d\n", CompletionCode); ! 915: ExitCode = (DWORD)ClientDisconnected; ! 916: Done = TRUE; ! 917: break; // out of switch ! 918: } ! 919: ! 920: // ! 921: // Check for Ctrl-C from the client ! 922: // ! 923: ! 924: for (i=0; i < BytesTransferred; i++) { ! 925: if (Session->ShellWriteBuffer[i] == '\003') { ! 926: ! 927: // ! 928: // Generate a Ctrl-C if we have the technology ! 929: // ! 930: ! 931: if (GenerateConsoleCtrlEventfn != NULL) { ! 932: (*GenerateConsoleCtrlEventfn)(CTRL_C_EVENT, 0); ! 933: } ! 934: ! 935: // ! 936: // Remove the Ctrl-C from the buffer ! 937: // ! 938: ! 939: BytesTransferred --; ! 940: ! 941: for (; i < BytesTransferred; i++) { ! 942: Session->ShellWriteBuffer[i] = Session->ShellWriteBuffer[i+1]; ! 943: } ! 944: } ! 945: } ! 946: ! 947: // ! 948: // Start an async write to shell ! 949: // ! 950: ! 951: Result = WriteFileAsync(Session->ShellWritePipeHandle, ! 952: Session->ShellWriteBuffer, ! 953: BytesTransferred, ! 954: Session->ShellWriteAsyncHandle); ! 955: if (!Result) { ! 956: DbgPrint("Async write to shell failed, error = %d\n", GetLastError()); ! 957: ExitCode = (DWORD)ShellEnded; ! 958: Done = TRUE; ! 959: } else { ! 960: Session->ShellWritePending = TRUE; ! 961: } ! 962: ! 963: break; // out of switch ! 964: ! 965: ! 966: ! 967: case 2: ! 968: ! 969: // ! 970: // Shell write completed ! 971: // ! 972: ! 973: Session->ShellWritePending = FALSE; ! 974: ! 975: CompletionCode = GetAsyncResult(Session->ShellWriteAsyncHandle, ! 976: &BytesTransferred); ! 977: ! 978: if (CompletionCode != ERROR_SUCCESS) { ! 979: DbgPrint("Async write to shell returned error, completion code = %d\n", CompletionCode); ! 980: ExitCode = (DWORD)ShellEnded; ! 981: Done = TRUE; ! 982: break; // out of switch ! 983: } ! 984: ! 985: // ! 986: // Start an async read from client ! 987: // ! 988: ! 989: Result = ReadFileAsync(Session->ClientPipeHandle, ! 990: Session->ShellWriteBuffer, ! 991: sizeof(Session->ShellWriteBuffer), ! 992: ClientReadAsyncHandle); ! 993: if (!Result) { ! 994: DbgPrint("Async read from client failed, error = %d\n", GetLastError()); ! 995: ExitCode = (DWORD)ClientDisconnected; ! 996: Done = TRUE; ! 997: } ! 998: ! 999: break; // out of switch ! 1000: ! 1001: ! 1002: default: ! 1003: ! 1004: DbgPrint("Session thread, unexpected result from wait, result = %d\n", WaitResult); ! 1005: ExitCode = (DWORD)ConnectError; ! 1006: Done = TRUE; ! 1007: break; ! 1008: ! 1009: } ! 1010: } ! 1011: ! 1012: ! 1013: ! 1014: // ! 1015: // Cleanup and exit ! 1016: // ! 1017: ! 1018: // ! 1019: // Closing the client pipe should interrupt any pending I/O so ! 1020: // we should then be safe to close the event handles in the client ! 1021: // overlapped structs ! 1022: // ! 1023: ! 1024: Result = DisconnectNamedPipe(Session->ClientPipeHandle); ! 1025: if (!Result) { ! 1026: DbgPrint("Session thread: disconnect client named pipe failed, error = %d\n", GetLastError()); ! 1027: } ! 1028: ! 1029: MyCloseHandle(Session->ClientPipeHandle, "client pipe"); ! 1030: Session->ClientPipeHandle = NULL; ! 1031: ! 1032: ! 1033: DeleteAsync(ClientReadAsyncHandle); ! 1034: DeleteAsync(ClientWriteAsyncHandle); ! 1035: ! 1036: ! 1037: // ! 1038: // Return the appropriate exit code ! 1039: // ! 1040: ! 1041: ExitThread(ExitCode); ! 1042: ! 1043: assert(FALSE); ! 1044: return(ExitCode); // keep compiler happy ! 1045: } ! 1046:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.