![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rcmd.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 / client|
Return to rcmd.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / rshell / client |
1.1 ! root 1: /****************************** Module Header ******************************\ ! 2: * Module Name: rsh.c ! 3: * ! 4: * Copyright (c) 1991, Microsoft Corporation ! 5: * ! 6: * Remote shell NT client main module ! 7: * ! 8: * History: ! 9: * 05-20-92 Davidc Created. ! 10: \***************************************************************************/ ! 11: ! 12: #define UNICODE ! 13: ! 14: #include <windows.h> ! 15: ! 16: #include <stdio.h> ! 17: #include <stdarg.h> ! 18: #include <assert.h> ! 19: ! 20: #define PIPE_NAME TEXT("%hs\\pipe\\rshell") ! 21: #define BUFFER_SIZE 1000 ! 22: ! 23: ! 24: // #define DEBUG ! 25: ! 26: #ifdef DEBUG ! 27: #define Dbgprintf DbgPrint ! 28: #else ! 29: #define Dbgprintf ! 30: #endif ! 31: ! 32: ! 33: // ! 34: // The pipe handle is global so we can use it from the ! 35: // Ctrl-C handler routine. ! 36: // ! 37: ! 38: static HANDLE PipeHandle = NULL; ! 39: ! 40: ! 41: ! 42: // ! 43: // Private prototypes ! 44: // ! 45: ! 46: DWORD ! 47: ReadThreadProc( ! 48: LPVOID Parameter ! 49: ); ! 50: ! 51: DWORD ! 52: WriteThreadProc( ! 53: LPVOID Parameter ! 54: ); ! 55: ! 56: BOOL ! 57: CtrlHandler( ! 58: DWORD CtrlType ! 59: ); ! 60: ! 61: int Myprintf ( ! 62: const char *format, ! 63: ... ! 64: ); ! 65: ! 66: ! 67: ! 68: ! 69: /***************************************************************************\ ! 70: * FUNCTION: Main ! 71: * ! 72: * PURPOSE: Main entry point. ! 73: * ! 74: * RETURNS: 0 on success, 1 on failure ! 75: * ! 76: * HISTORY: ! 77: * ! 78: * 07-10-92 Davidc Created. ! 79: * ! 80: \***************************************************************************/ ! 81: ! 82: int ! 83: _CRTAPI1 main( ! 84: int argc, ! 85: char **argv ! 86: ) ! 87: { ! 88: SECURITY_ATTRIBUTES SecurityAttributes; ! 89: HANDLE StdInputHandle; ! 90: HANDLE StdOutputHandle; ! 91: HANDLE StdErrorHandle; ! 92: WCHAR PipeName[MAX_PATH]; ! 93: LPSTR ServerName; ! 94: HANDLE ReadThreadHandle; ! 95: HANDLE WriteThreadHandle; ! 96: DWORD ThreadId; ! 97: HANDLE HandleArray[2]; ! 98: ! 99: // ! 100: // Install a handler for Ctrl-C ! 101: // ! 102: ! 103: if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE) &CtrlHandler, TRUE)) { ! 104: Myprintf("Failed to install control-C handler, error = %d\n", GetLastError()); ! 105: return(1); ! 106: } ! 107: ! 108: ! 109: // ! 110: // Check usage ! 111: // ! 112: ! 113: if (argc < 2) { ! 114: Myprintf("Usage: rcmd server_name\n"); ! 115: Myprintf("Note : server name should include leading '\\\\'s\n"); ! 116: return(1); ! 117: } ! 118: ! 119: ! 120: // ! 121: // Calculate the pipe name ! 122: // ! 123: ! 124: if (argc > 1) { ! 125: ServerName = argv[1]; ! 126: } else { ! 127: ServerName = "\\\\."; ! 128: } ! 129: ! 130: wsprintf(PipeName, PIPE_NAME, ServerName); ! 131: ! 132: ! 133: // ! 134: // Store away our normal i/o handles ! 135: // ! 136: ! 137: StdInputHandle = GetStdHandle(STD_INPUT_HANDLE); ! 138: assert(StdInputHandle != (HANDLE)0xffffffff); ! 139: StdOutputHandle = GetStdHandle(STD_OUTPUT_HANDLE); ! 140: assert(StdOutputHandle != (HANDLE)0xffffffff); ! 141: StdErrorHandle = GetStdHandle(STD_ERROR_HANDLE); ! 142: assert(StdErrorHandle != (HANDLE)0xffffffff); ! 143: ! 144: ! 145: // ! 146: // Open the named pipe ! 147: // ! 148: ! 149: SecurityAttributes.nLength = sizeof(SecurityAttributes); ! 150: SecurityAttributes.lpSecurityDescriptor = NULL; // Use default SD ! 151: SecurityAttributes.bInheritHandle = FALSE; ! 152: ! 153: PipeHandle = CreateFile( PipeName, ! 154: GENERIC_READ | GENERIC_WRITE, ! 155: 0, // No sharing ! 156: &SecurityAttributes, ! 157: OPEN_EXISTING, ! 158: FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, ! 159: NULL // Template file ! 160: ); ! 161: ! 162: if (PipeHandle == (HANDLE)0xffffffff ) { ! 163: Dbgprintf("Failed to open named pipe, error = %d\n", GetLastError()); ! 164: Myprintf("Failed to connect to <%s>, error = %d\n", ServerName, GetLastError()); ! 165: return(1); ! 166: } ! 167: ! 168: Myprintf("Connected to %s\n\n", ServerName); ! 169: ! 170: // ! 171: // Exec 2 threads - 1 copies data from stdin to pipe, the other ! 172: // copies data from the pipe to stdout. ! 173: // ! 174: ! 175: ReadThreadHandle = CreateThread( ! 176: NULL, // Default security ! 177: 0, // Default Stack size ! 178: (LPTHREAD_START_ROUTINE) ReadThreadProc, ! 179: (PVOID)PipeHandle, ! 180: 0, ! 181: &ThreadId); ! 182: ! 183: if (ReadThreadHandle == NULL) { ! 184: Myprintf("Failed to create read thread, error = %ld\n", GetLastError()); ! 185: return(1); ! 186: } ! 187: ! 188: ! 189: // ! 190: // Create the write thread ! 191: // ! 192: ! 193: WriteThreadHandle = CreateThread( ! 194: NULL, // Default security ! 195: 0, // Default Stack size ! 196: (LPTHREAD_START_ROUTINE) WriteThreadProc, ! 197: (PVOID)PipeHandle, ! 198: 0, ! 199: &ThreadId); ! 200: ! 201: if (WriteThreadHandle == NULL) { ! 202: Myprintf("Failed to create write thread, error = %ld\n", GetLastError()); ! 203: TerminateThread(ReadThreadHandle, 0); ! 204: CloseHandle(ReadThreadHandle); ! 205: return(1); ! 206: } ! 207: ! 208: ! 209: ! 210: // ! 211: // Wait for either thread to finish ! 212: // ! 213: ! 214: HandleArray[0] = ReadThreadHandle; ! 215: HandleArray[1] = WriteThreadHandle; ! 216: ! 217: WaitForMultipleObjects( ! 218: 2, ! 219: HandleArray, ! 220: FALSE, // Wait for either to finish ! 221: 0xffffffff ! 222: ); // Wait forever ! 223: ! 224: Dbgprintf("Read or write thread terminated\n"); ! 225: ! 226: // ! 227: // Terminate and close both threads ! 228: // ! 229: ! 230: TerminateThread(ReadThreadHandle, 0); ! 231: CloseHandle(ReadThreadHandle); ! 232: TerminateThread(WriteThreadHandle, 0); ! 233: CloseHandle(WriteThreadHandle); ! 234: ! 235: ! 236: // ! 237: // Close our pipe handle ! 238: // ! 239: ! 240: CloseHandle(PipeHandle); ! 241: PipeHandle = NULL; ! 242: ! 243: ! 244: Myprintf("\nDisconnected from %s\n", ServerName); ! 245: ! 246: return(0); ! 247: } ! 248: ! 249: ! 250: /***************************************************************************\ ! 251: * FUNCTION: ReadPipe ! 252: * ! 253: * PURPOSE: Implements an overlapped read such that read and write operations ! 254: * to the same pipe handle don't deadlock. ! 255: * ! 256: * RETURNS: TRUE on success, FALSE on failure (GetLastError() has error) ! 257: * ! 258: * HISTORY: ! 259: * ! 260: * 05-27-92 Davidc Created. ! 261: * ! 262: \***************************************************************************/ ! 263: ! 264: BOOL ! 265: ReadPipe( ! 266: HANDLE PipeHandle, ! 267: LPVOID lpBuffer, ! 268: DWORD nNumberOfBytesToRead, ! 269: LPDWORD lpNumberOfBytesRead ! 270: ) ! 271: { ! 272: DWORD Result; ! 273: OVERLAPPED Overlapped; ! 274: HANDLE EventHandle; ! 275: DWORD Error; ! 276: ! 277: // ! 278: // Create an event for the overlapped operation ! 279: // ! 280: ! 281: EventHandle = CreateEvent( ! 282: NULL, // no security ! 283: TRUE, // Manual reset ! 284: FALSE, // Initial state ! 285: NULL // Name ! 286: ); ! 287: if (EventHandle == NULL) { ! 288: Myprintf("ReadPipe failed to create event, error = %d\n", GetLastError()); ! 289: return(FALSE); ! 290: } ! 291: ! 292: Overlapped.hEvent = EventHandle; ! 293: ! 294: Result = ReadFile( ! 295: PipeHandle, ! 296: lpBuffer, ! 297: nNumberOfBytesToRead, ! 298: lpNumberOfBytesRead, ! 299: &Overlapped ! 300: ); ! 301: if (Result) { ! 302: ! 303: // ! 304: // Success without waiting - it's too easy ! ! 305: // ! 306: ! 307: CloseHandle(EventHandle); ! 308: ! 309: } else { ! 310: ! 311: // ! 312: // Read failed, if it's overlapped io, go wait for it ! 313: // ! 314: ! 315: Error = GetLastError(); ! 316: ! 317: if (Error != ERROR_IO_PENDING) { ! 318: Dbgprintf("ReadPipe: ReadFile failed, error = %d\n", Error); ! 319: CloseHandle(EventHandle); ! 320: return(FALSE); ! 321: } ! 322: ! 323: // ! 324: // Wait for the I/O to complete ! 325: // ! 326: ! 327: Result = WaitForSingleObject(EventHandle, (DWORD)-1); ! 328: if (Result != 0) { ! 329: Dbgprintf("ReadPipe: event wait failed, result = %d, last error = %d\n", Result, GetLastError()); ! 330: CloseHandle(EventHandle); ! 331: return(FALSE); ! 332: } ! 333: ! 334: // ! 335: // Go get the I/O result ! 336: // ! 337: ! 338: Result = GetOverlappedResult( PipeHandle, ! 339: &Overlapped, ! 340: lpNumberOfBytesRead, ! 341: FALSE ! 342: ); ! 343: // ! 344: // We're finished with the event handle ! 345: // ! 346: ! 347: CloseHandle(EventHandle); ! 348: ! 349: // ! 350: // Check result of GetOverlappedResult ! 351: // ! 352: ! 353: if (!Result) { ! 354: Dbgprintf("ReadPipe: GetOverlappedResult failed, error = %d\n", GetLastError()); ! 355: return(FALSE); ! 356: } ! 357: } ! 358: ! 359: return(TRUE); ! 360: } ! 361: ! 362: ! 363: /***************************************************************************\ ! 364: * FUNCTION: WritePipe ! 365: * ! 366: * PURPOSE: Implements an overlapped write such that read and write operations ! 367: * to the same pipe handle don't deadlock. ! 368: * ! 369: * RETURNS: TRUE on success, FALSE on failure (GetLastError() has error) ! 370: * ! 371: * HISTORY: ! 372: * ! 373: * 05-27-92 Davidc Created. ! 374: * ! 375: \***************************************************************************/ ! 376: ! 377: BOOL ! 378: WritePipe( ! 379: HANDLE PipeHandle, ! 380: CONST VOID *lpBuffer, ! 381: DWORD nNumberOfBytesToWrite, ! 382: LPDWORD lpNumberOfBytesWritten ! 383: ) ! 384: { ! 385: DWORD Result; ! 386: OVERLAPPED Overlapped; ! 387: HANDLE EventHandle; ! 388: DWORD Error; ! 389: ! 390: // ! 391: // Create an event for the overlapped operation ! 392: // ! 393: ! 394: EventHandle = CreateEvent( ! 395: NULL, // no security ! 396: TRUE, // Manual reset ! 397: FALSE, // Initial state ! 398: NULL // Name ! 399: ); ! 400: if (EventHandle == NULL) { ! 401: Myprintf("WritePipe failed to create event, error = %d\n", GetLastError()); ! 402: return(FALSE); ! 403: } ! 404: ! 405: Overlapped.hEvent = EventHandle; ! 406: ! 407: Result = WriteFile( ! 408: PipeHandle, ! 409: lpBuffer, ! 410: nNumberOfBytesToWrite, ! 411: lpNumberOfBytesWritten, ! 412: &Overlapped ! 413: ); ! 414: if (Result) { ! 415: ! 416: // ! 417: // Success without waiting - it's too easy ! ! 418: // ! 419: ! 420: CloseHandle(EventHandle); ! 421: ! 422: } else { ! 423: ! 424: // ! 425: // Write failed, if it's overlapped io, go wait for it ! 426: // ! 427: ! 428: Error = GetLastError(); ! 429: ! 430: if (Error != ERROR_IO_PENDING) { ! 431: Dbgprintf("WritePipe: WriteFile failed, error = %d\n", Error); ! 432: CloseHandle(EventHandle); ! 433: return(FALSE); ! 434: } ! 435: ! 436: // ! 437: // Wait for the I/O to complete ! 438: // ! 439: ! 440: Result = WaitForSingleObject(EventHandle, (DWORD)-1); ! 441: if (Result != 0) { ! 442: Dbgprintf("WritePipe: event wait failed, result = %d, last error = %d\n", Result, GetLastError()); ! 443: CloseHandle(EventHandle); ! 444: return(FALSE); ! 445: } ! 446: ! 447: // ! 448: // Go get the I/O result ! 449: // ! 450: ! 451: Result = GetOverlappedResult( PipeHandle, ! 452: &Overlapped, ! 453: lpNumberOfBytesWritten, ! 454: FALSE ! 455: ); ! 456: // ! 457: // We're finished with the event handle ! 458: // ! 459: ! 460: CloseHandle(EventHandle); ! 461: ! 462: // ! 463: // Check result of GetOverlappedResult ! 464: // ! 465: ! 466: if (!Result) { ! 467: Dbgprintf("WritePipe: GetOverlappedResult failed, error = %d\n", GetLastError()); ! 468: return(FALSE); ! 469: } ! 470: } ! 471: ! 472: return(TRUE); ! 473: } ! 474: ! 475: ! 476: /***************************************************************************\ ! 477: * FUNCTION: ReadThreadProc ! 478: * ! 479: * PURPOSE: The read thread procedure. Reads from pipe and writes to STD_OUT ! 480: * ! 481: * RETURNS: Nothing ! 482: * ! 483: * HISTORY: ! 484: * ! 485: * 05-21-92 Davidc Created. ! 486: * ! 487: \***************************************************************************/ ! 488: ! 489: DWORD ! 490: ReadThreadProc( ! 491: LPVOID Parameter ! 492: ) ! 493: { ! 494: HANDLE PipeHandle = Parameter; ! 495: BYTE Buffer[BUFFER_SIZE]; ! 496: DWORD BytesRead; ! 497: DWORD BytesWritten; ! 498: ! 499: while (ReadPipe( ! 500: PipeHandle, ! 501: Buffer, ! 502: sizeof(Buffer), ! 503: &BytesRead ! 504: )) { ! 505: ! 506: if (!WriteFile( ! 507: (HANDLE)STD_OUTPUT_HANDLE, ! 508: Buffer, ! 509: BytesRead, ! 510: &BytesWritten, ! 511: NULL ! 512: )) { ! 513: ! 514: Dbgprintf("ReadThreadProc, writefile failed\n"); ! 515: Myprintf("ReadThreadProc, writefile failed\n"); ! 516: break; ! 517: } ! 518: } ! 519: ! 520: Dbgprintf("ReadThreadProc exitted, error = %ld\n", GetLastError()); ! 521: ! 522: ExitThread((DWORD)0); ! 523: ! 524: assert(FALSE); // Should never get here ! 525: ! 526: return(0); ! 527: } ! 528: ! 529: ! 530: /***************************************************************************\ ! 531: * FUNCTION: WriteThreadProc ! 532: * ! 533: * PURPOSE: The write thread procedure. Reads from STD_INPUT and writes to pipe ! 534: * ! 535: * RETURNS: Nothing ! 536: * ! 537: * HISTORY: ! 538: * ! 539: * 05-21-92 Davidc Created. ! 540: * ! 541: \***************************************************************************/ ! 542: ! 543: DWORD ! 544: WriteThreadProc( ! 545: LPVOID Parameter ! 546: ) ! 547: { ! 548: HANDLE PipeHandle = Parameter; ! 549: BYTE Buffer[BUFFER_SIZE]; ! 550: DWORD BytesRead; ! 551: DWORD BytesWritten; ! 552: ! 553: while (ReadFile( ! 554: (HANDLE)STD_INPUT_HANDLE, ! 555: Buffer, ! 556: sizeof(Buffer), ! 557: &BytesRead, ! 558: NULL ! 559: )) { ! 560: ! 561: if (!WritePipe( ! 562: PipeHandle, ! 563: Buffer, ! 564: BytesRead, ! 565: &BytesWritten ! 566: )) { ! 567: Dbgprintf("WriteThreadProc, writefile failed\n"); ! 568: break; ! 569: } ! 570: } ! 571: ! 572: Dbgprintf("WriteThreadProc exitted, error = %ld\n", GetLastError()); ! 573: ! 574: ExitThread((DWORD)0); ! 575: ! 576: assert(FALSE); // Should never get here ! 577: ! 578: return(0); ! 579: } ! 580: ! 581: ! 582: /***************************************************************************\ ! 583: * FUNCTION: CtrlHandler ! 584: * ! 585: * PURPOSE: Handles console event notifications. ! 586: * ! 587: * RETURNS: TRUE if the event has been handled, otherwise FALSE. ! 588: * ! 589: * HISTORY: ! 590: * ! 591: * 05-21-92 Davidc Created. ! 592: * ! 593: \***************************************************************************/ ! 594: ! 595: BOOL ! 596: CtrlHandler( ! 597: DWORD CtrlType ! 598: ) ! 599: { ! 600: // ! 601: // We'll handle Ctrl-C events ! 602: // ! 603: ! 604: if (CtrlType == CTRL_C_EVENT) { ! 605: ! 606: if (PipeHandle != NULL) { ! 607: ! 608: // ! 609: // Send a Ctrl-C to the server, don't care if it fails ! 610: // ! 611: ! 612: CHAR CtrlC = '\003'; ! 613: DWORD BytesWritten; ! 614: ! 615: WriteFile(PipeHandle, ! 616: &CtrlC, ! 617: sizeof(CtrlC), ! 618: &BytesWritten, ! 619: NULL ! 620: ); ! 621: } ! 622: ! 623: // ! 624: // We handled the event ! 625: // ! 626: ! 627: return(TRUE); ! 628: } ! 629: ! 630: // ! 631: // Deal with all other events as normal ! 632: // ! 633: ! 634: return (FALSE); ! 635: } ! 636: ! 637: ! 638: /***************************************************************************\ ! 639: * FUNCTION: MyPrintf ! 640: * ! 641: * PURPOSE: Printf that uses low-level io. ! 642: * ! 643: * HISTORY: ! 644: * ! 645: * 07-15-92 Davidc Created. ! 646: * ! 647: \***************************************************************************/ ! 648: ! 649: int Myprintf ( ! 650: const char *format, ! 651: ... ! 652: ) ! 653: { ! 654: CHAR Buffer[MAX_PATH]; ! 655: va_list argpointer; ! 656: int Result; ! 657: DWORD BytesWritten; ! 658: ! 659: va_start(argpointer, format); ! 660: ! 661: Result = vsprintf(Buffer, format, argpointer); ! 662: ! 663: if (!WriteFile((HANDLE)STD_OUTPUT_HANDLE, Buffer, Result, &BytesWritten, NULL)) { ! 664: Dbgprintf("Myprintf : Write file to stdout failed, error = %d\n", GetLastError()); ! 665: Result = 0; ! 666: } ! 667: ! 668: va_end(argpointer); ! 669: ! 670: return(Result); ! 671: } ! 672:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.