![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to server.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / remote|
Return to server.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / remote |
1.1 root 1: /*++
2:
3: Copyright (c) 1992 Microsoft Corporation
4:
5: Module Name:
6:
7: Server.c
8:
9: Abstract:
10:
11: The server component of Remote. It spawns a child process
12: and redirects the stdin/stdout/stderr of child to itself.
13: Waits for connections from clients - passing the
14: output of child process to client and the input from clients
15: to child process.
16:
17: Author:
18:
19: Rajivendra Nath (rajnath) 2-Jan-1992
20:
21: Environment:
22:
23: Console App. User mode.
24:
25: Revision History:
26:
27: --*/
28:
29: #include <windows.h>
30: #include <stdio.h>
31: #include <stdlib.h>
32: #include <io.h>
33: #include <string.h>
34: #include "Remote.h"
35:
36: #define MAX_SESSION 10
37:
38: #define COMMANDFORMAT "%c%-15s [%-15s %d:%d]\n%c"
39: #define LOCALNAME "Local"
40: #define LOCALCLIENT(x) (strcmp((char *)(x->Name),LOCALNAME)==0)
41: #define RemoteInfo(prt,flg) {if (!(flg&&0x80000000)) prt;}
42:
43: #define CMDSTRING(OutBuff,InpBuff,Client,sTime) \
44: { \
45: /* int xxlen; */ \
46: sprintf \
47: ( \
48: &OutBuff[0],COMMANDFORMAT,\
49: BEGINMARK,InpBuff, \
50: Client->Name,sTime.wHour, \
51: sTime.wMinute,ENDMARK \
52: ); \
53: } \
54:
55: #define BUFFSIZE 256
56:
57: SESSION_TYPE ClientList[MAX_SESSION];
58:
59: HANDLE ChildStdInp; //Server Writes to it
60: HANDLE ChildStdOut; //Server Reads from it
61: HANDLE ChildStdErr; //Server Reads from it
62:
63: HANDLE SaveFile; //File containing all that was
64: //output by child process.
65: //Each connection opens a handle to this file
66: //and is sent through PipeWriteH.
67:
68: char SaveFileName[64]; //Name of above file - all new sessions need
69: HANDLE ChldProc; //Handle to the Child Process
70: HANDLE ListenThreadH; //Handle to the thread listening for connections
71: //from Remote Clients.
72:
73: HANDLE
74: ForkChildProcess( // Creates a new process
75: char *cmd, // Redirects its stdin,stdout
76: PHANDLE in, // and stderr - returns the
77: PHANDLE out, // corresponding pipe ends. Using currently
78: PHANDLE err
79: );
80:
81: HANDLE
82: OldForkChildProcess( //Same as above except different
83: char *cmd, //method for redirection. Not Used.
84: PHANDLE in,
85: PHANDLE out,
86: PHANDLE err
87: );
88:
89: DWORD
90: ListenForSession( //THREAD:Listens for new connections and
91: char* pipe //spawns of new seesions - Updates the
92: ); //Status in Client DataStructure. Seperate Thread.
93:
94: DWORD
95: NewSession( //Manages the session with a client.
96: SESSION_TYPE* Client
97: );
98:
99: DWORD //2 THREAD:Each reads either
100: GetChldOutput( //StdOut or StdErr of child and
101: HANDLE rhandle //writes to SaveFile. Seperate Thread.
102: );
103:
104: DWORD
105: TransferFileToClient( //X THREADS:Reads the save
106: SESSION_TYPE* Client //file and sendsoutput to a client. Seperate Thread
107: );
108:
109:
110: DWORD
111: GetClientInput( //Times X THREADS:Gets input from Child pipe
112: SESSION_TYPE* Client //and sends to childs StdIn. Seperate Thread.
113: );
114:
115:
116: BOOL
117: FilterCommand( //Filters input from client
118: SESSION_TYPE *cl, //for commands intended for REMOTE
119: char *buff,
120: int dread
121: );
122:
123: DWORD // Manages the IO with user
124: LocalSession( // For the remote server. Seperate Thread.
125: PVOID noarg
126: );
127:
128: DWORD // Manages the IO with Remote Client.
129: RemoteSession(
130: SESSION_TYPE* Client
131: );
132:
133: BOOL // Ctrl-C handler
134: SrvCtrlHand(
135: DWORD event
136: );
137:
138: VOID // @s command to remote
139: SendStatus(
140: HANDLE hClientPipe
141: );
142:
143: DWORD // @p command to remote
144: ShowPopup(
145: char *mssg
146: );
147:
148: VOID // Removes the command begin and end markers
149: RemoveInpMark( // from the save file.
150: char* Buff,
151: DWORD Size
152: );
153:
154: VOID // Cleans up the session
155: CloseClient( // once it ends.
156: SESSION_TYPE *Client
157: );
158: // Initialises the Client datastructs
159: VOID
160: InitClientList(
161: );
162:
163:
164: /*************************************************************/
165: /* The main entry point for the Server End of Remote */
166: /*************************************************************/
167: VOID
168: Server(
169: char* ChildCmd,
170: char* PipeName
171: )
172: {
173: DWORD ThreadID ;
174: HANDLE WaitH[3];
175: DWORD WaitObj;
176: char tmpdir[32];
177:
178: WRITEF((VBuff,"**************************************\n"));
179: WRITEF((VBuff,"*********** REMOTE ************\n"));
180: WRITEF((VBuff,"*********** SERVER ************\n"));
181: WRITEF((VBuff,"**************************************\n"));
182: WRITEF((VBuff,"To Connect: Remote /C %s %s\n\n",HostName,PipeName));
183:
184: InitClientList();
185:
186: //
187: //Start the command as a child process
188: //
189:
190: ChldProc=ForkChildProcess(ChildCmd,&ChildStdInp,&ChildStdOut,&ChildStdErr);
191:
192: //
193: //Create a tempfile for storing Child process output.
194: //
195: {
196: DWORD size=sizeof(tmpdir);
197: if (
198: (GetEnvironmentVariable("TMP" ,tmpdir,size)==0)&&
199: (GetEnvironmentVariable("TEMP",tmpdir,size)==0)
200: )
201: {
202: sprintf(tmpdir,"%s",".");
203: }
204: if (!GetTempFileName(tmpdir,"REMOTE",0,SaveFileName))
205: GetTempFileName(".","REMOTE",0,SaveFileName);
206: }
207:
208:
209: if ((SaveFile=CreateFile
210: (
211: (LPCTSTR)SaveFileName, /* address of name of the file */
212: GENERIC_READ|GENERIC_WRITE, /* access (read/write) mode */
213: FILE_SHARE_READ|FILE_SHARE_WRITE,/* share mode */
214: (LPSECURITY_ATTRIBUTES)NULL, /* security descriptor */
215: CREATE_ALWAYS, /* how to create */
216: FILE_ATTRIBUTE_NORMAL, /* File Attribute */
217: (HANDLE)NULL)
218: )==NULL)
219: {
220: TerminateProcess(ChldProc,0);
221: ErrorExit("Could not Create Output File");
222: }
223:
224:
225: //
226: //Start 2 threads to save the output from stdout and stderr of cmd to savefile.
227: //
228:
229: if ((WaitH[0]=CreateThread
230: (
231: (LPSECURITY_ATTRIBUTES)NULL, // No security attributes.
232: (DWORD)0, // Use same stack size.
233: (LPTHREAD_START_ROUTINE)GetChldOutput, // Thread procedure.
234: (LPVOID)ChildStdErr, // Parameter to pass.
235: (DWORD)0, // Run immediately.
236: (LPDWORD)&ThreadID)
237: )==NULL)
238: {
239:
240: TerminateProcess(ChldProc,0);
241: ErrorExit("Failed to Create GetGhldOutput#1 Thread");
242: }
243:
244:
245: if ((WaitH[1]=CreateThread
246: (
247: (LPSECURITY_ATTRIBUTES)NULL, // No security attributes.
248: (DWORD)0, // Use same stack size.
249: (LPTHREAD_START_ROUTINE)GetChldOutput, // Thread procedure.
250: (LPVOID)ChildStdOut, // Parameter to pass.
251: (DWORD)0, // Run immediately.
252: (LPDWORD)&ThreadID)
253: )==NULL)
254: {
255:
256: TerminateProcess(ChldProc,0);
257: ErrorExit("Failed to Create GetGhldOutput#2 Thread");
258: }
259:
260:
261: //
262: //Start Thread to listen for new Connections
263: //
264:
265: if ((ListenThreadH=CreateThread
266: (
267: (LPSECURITY_ATTRIBUTES)NULL, // No security attributes.
268: (DWORD)0, // Use same stack size.
269: (LPTHREAD_START_ROUTINE)ListenForSession, // Thread procedure.
270: (LPVOID)PipeName, // Parameter to pass.
271: (DWORD)0, // Run immediately.
272: (LPDWORD)&ThreadID)
273: )==NULL)
274: {
275:
276: TerminateProcess(ChldProc,0);
277: ErrorExit("Failed To Create ListenForSession Thread");
278:
279: }
280:
281: //
282: //Start Local Thread
283: //
284:
285: if ((ClientList[0].hThread=CreateThread
286: (
287: (LPSECURITY_ATTRIBUTES)NULL, // No security attributes.
288: (DWORD)0, // Use same stack size.
289: (LPTHREAD_START_ROUTINE)LocalSession, // Thread procedure.
290: (LPVOID)NULL, // Parameter to pass.
291: (DWORD)0, // Run immediately.
292: (LPDWORD)&ThreadID)
293: )==NULL)
294: {
295:
296: TerminateProcess(ChldProc,0);
297: ErrorExit("Failed To Create ListenForSession Thread");
298:
299: }
300:
301: SetConsoleCtrlHandler((PHANDLER_ROUTINE)SrvCtrlHand,TRUE);
302:
303: WaitH[2]=ChldProc;
304:
305: //
306: // Wait until the child process terminates
307: // or local IO thread terminates
308: // or IO with child process ends
309: //
310:
311: WaitObj=WaitForMultipleObjects(3,WaitH,FALSE,INFINITE);
312:
313: switch (WaitObj-WAIT_OBJECT_0)
314: {
315: case 0: // Error Writing to savefile
316: case 1:
317: TerminateProcess(ChldProc,0);
318: break;
319: case 2: // Child Proc Terminated
320: break;
321:
322: default: // Out of Some Resource
323: printf("Out of Resource Error %d..Terminating\n",GetLastError());
324: break;
325:
326: }
327:
328: TerminateThread(ListenThreadH,0);
329:
330: CloseHandle(ChildStdInp);
331: CloseHandle(ChildStdOut);
332: CloseHandle(ChildStdErr);
333:
334: WRITEF((VBuff,"\nRemote:Parent exiting. Child(%s) dead..\n",ChildCmd));
335:
336: CloseHandle(SaveFile);
337:
338: {
339: int i;
340: for (i=0;i<MAX_SESSION;i++)
341: CloseClient(&ClientList[i]);
342: }
343:
344: if (!DeleteFile(SaveFileName))
345: WRITEF((VBuff,"Temp File %s not deleted..\n",SaveFileName));
346:
347: return;
348: }
349: /*************************************************************/
350: /* Creates the child process and redirects its std.IO handles*/
351: /*************************************************************/
352: HANDLE
353: ForkChildProcess( // Creates a new process
354: char *cmd, // Redirects its stdin,stdout
355: PHANDLE inH, // and stderr - returns the
356: PHANDLE outH, // corresponding pipe ends.
357: PHANDLE errH
358: )
359: {
360: SECURITY_ATTRIBUTES lsa;
361: STARTUPINFO si;
362: PROCESS_INFORMATION pi;
363:
364: HANDLE ChildIn;
365: HANDLE ChildOut;
366: HANDLE ChildErr;
367:
368: lsa.nLength=sizeof(SECURITY_ATTRIBUTES);
369: lsa.lpSecurityDescriptor=NULL;
370: lsa.bInheritHandle=TRUE;
371:
372: //
373: //Create Parent_Write to ChildStdIn Pipe
374: //
375:
376: if (!CreatePipe(&ChildIn,inH,&lsa,0))
377: ErrorExit("Could Not Create Parent-->Child Pipe");
378:
379: //
380: //Create ChildStdOut to Parent_Read pipe
381: //
382:
383: if (!CreatePipe(outH,&ChildOut,&lsa,0))
384: ErrorExit("Could Not Create Child-->Parent Pipe");
385:
386: //
387: //Create ChildStdOut to Parent_Read pipe
388: //
389:
390: if (!CreatePipe(errH,&ChildErr,&lsa,0))
391: ErrorExit("Could Not Create Child-->Parent Pipe");
392:
393: //
394: // Lets Redirect Console StdHandles - easy enough
395: //
396:
397:
398: si.cb=sizeof(STARTUPINFO);
399: si.lpReserved=NULL;
400: si.lpTitle=NULL;
401: si.lpDesktop=NULL;
402: si.dwX=si.dwY=si.dwYSize=si.dwXSize=0;
403: si.dwFlags=STARTF_USESTDHANDLES;
404: si.hStdInput =ChildIn;
405: si.hStdOutput=ChildOut;
406: si.hStdError =ChildErr;
407: si.wShowWindow=SW_SHOW;
408: si.lpReserved2=NULL;
409: si.cbReserved2=0;
410:
411: //
412: //Create Child Process
413: //
414:
415: if (!CreateProcess
416: (
417: NULL,
418: cmd,
419: NULL,
420: NULL,
421: TRUE,
422: NORMAL_PRIORITY_CLASS,
423: NULL,
424: NULL,
425: &si,
426: &pi)
427: )
428: {
429: if (GetLastError()==2)
430: WRITEF((VBuff,"Executable %s not found\n",cmd));
431: ErrorExit("Could Not Create Child Process");
432: }
433:
434: //
435: //Close unneccesary Handles and Restore the crt handles
436: //
437:
438: CloseHandle(ChildIn);
439: CloseHandle(ChildOut);
440: CloseHandle(ChildErr);
441:
442: return(pi.hProcess);
443: }
444: /*************************************************************/
445: /* Same as above but uses different method of IO redir. */
446: /* Not used now */
447: /*************************************************************/
448: HANDLE
449: OldForkChildProcess(
450: char *cmd,
451: PHANDLE inH,
452: PHANDLE outH,
453: PHANDLE errH
454: )
455: {
456: SECURITY_ATTRIBUTES lsa;
457: STARTUPINFO si;
458: PROCESS_INFORMATION pi;
459:
460: HANDLE OldStdIn =GetStdHandle(STD_INPUT_HANDLE);
461: HANDLE OldStdOut=GetStdHandle(STD_OUTPUT_HANDLE);
462: HANDLE OldStdErr=GetStdHandle(STD_ERROR_HANDLE);
463:
464: HANDLE ChildStdIn;
465: HANDLE ChildStdOut;
466: HANDLE ChildStdErr;
467:
468: lsa.nLength=sizeof(SECURITY_ATTRIBUTES);
469: lsa.lpSecurityDescriptor=NULL;
470: lsa.bInheritHandle=TRUE;
471:
472: //Create Parent_Write to ChildStdIn Pipe
473: if (!CreatePipe(&ChildStdIn,inH,&lsa,0))
474: ErrorExit("Could Not Create Parent-->Child Pipe");
475:
476: //Create ChildStdOut to Parent_Read pipe
477: if (!CreatePipe(outH,&ChildStdOut,&lsa,0))
478: ErrorExit("Could Not Create Child-->Parent Pipe");
479:
480: //Create ChildStdOut to Parent_Read pipe
481: if (!CreatePipe(errH,&ChildStdErr,&lsa,0))
482: ErrorExit("Could Not Create Child-->Parent Pipe");
483:
484: //Make ChildStdIn and Out as standard handles and get it inherited by child
485: if (!SetStdHandle(STD_INPUT_HANDLE,ChildStdIn))
486: ErrorExit("Could not change StdIn");
487:
488: if (!SetStdHandle(STD_OUTPUT_HANDLE,ChildStdOut))
489: ErrorExit("Could Not change StdOut");
490:
491: if (!SetStdHandle(STD_ERROR_HANDLE,ChildStdErr))
492: ErrorExit("Could Not change StdErr");
493:
494: si.cb=sizeof(STARTUPINFO);
495: si.lpReserved=NULL;
496: si.lpTitle=NULL;
497: si.lpDesktop=NULL;
498: si.dwX=si.dwY=si.dwYSize=si.dwXSize=si.dwFlags=0L;
499: si.wShowWindow=SW_SHOW;
500: si.lpReserved2=NULL;
501: si.cbReserved2=0;
502:
503: //Create Child Process
504: if (!CreateProcess
505: (
506: NULL,
507: cmd,
508: NULL,
509: NULL,
510: TRUE,
511: NORMAL_PRIORITY_CLASS,
512: NULL,
513: NULL,
514: &si,
515: &pi)
516: )
517: {
518: ErrorExit("Could Not Create Child Process");
519: }
520:
521: //reset StdIn StdOut
522: if (!SetStdHandle(STD_INPUT_HANDLE,OldStdIn))
523: {
524: TerminateProcess(pi.hProcess,1);
525: ErrorExit("Could not RESET StdIn");
526: }
527:
528: if (!SetStdHandle(STD_OUTPUT_HANDLE,OldStdOut))
529: {
530: TerminateProcess(pi.hProcess,1);
531: ErrorExit("Could not RESET StdIn");
532: }
533:
534: if (!SetStdHandle(STD_ERROR_HANDLE,OldStdErr))
535: {
536: TerminateProcess(pi.hProcess,1);
537: ErrorExit("Could not RESET StdIn");
538: }
539:
540: //Close unneccesary Handles
541: CloseHandle(ChildStdIn);
542: CloseHandle(ChildStdOut);
543: CloseHandle(ChildStdErr);
544:
545: return(pi.hProcess);
546: }
547: /*************************************************************/
548: /* Listens for sessions from Clients and creates a new thread*/
549: /* for each client */
550: /*************************************************************/
551:
552: DWORD
553: ListenForSession(
554: char* pipename
555: )
556: {
557: int i;
558: DWORD ThreadID;
559: HANDLE PipeH[2];
560: SECURITY_DESCRIPTOR SecurityDescriptor;
561: HANDLE TokenHandle;
562: TOKEN_DEFAULT_DACL DefaultDacl;
563: SECURITY_ATTRIBUTES lsa;
564:
565: char fullnameIn[BUFFSIZE];
566: char fullnameOut[BUFFSIZE];
567:
568: sprintf(fullnameIn,SERVER_READ_PIPE ,".",pipename);
569: sprintf(fullnameOut,SERVER_WRITE_PIPE,".",pipename);
570:
571: //
572: // Initialize the security descriptor that we're going to
573: // use.
574: //
575:
576: InitializeSecurityDescriptor
577: (
578: &SecurityDescriptor,
579: SECURITY_DESCRIPTOR_REVISION
580: );
581:
582: (VOID) SetSecurityDescriptorDacl
583: (
584: &SecurityDescriptor,
585: TRUE,
586: NULL,
587: FALSE
588: );
589:
590: DefaultDacl.DefaultDacl = NULL;
591:
592: if (OpenProcessToken
593: (
594: GetCurrentProcess(),
595: TOKEN_ADJUST_DEFAULT,
596: &TokenHandle
597: ))
598: {
599:
600: //
601: // Remove the default DACL on the token
602: //
603:
604: SetTokenInformation
605: (
606: TokenHandle,
607: TokenDefaultDacl,
608: &DefaultDacl,
609: sizeof( TOKEN_DEFAULT_DACL )
610: );
611:
612: }
613:
614: lsa.nLength=sizeof(SECURITY_ATTRIBUTES);
615: lsa.lpSecurityDescriptor=&SecurityDescriptor;
616: lsa.bInheritHandle=TRUE;
617:
618: while(TRUE)
619: {
620: //
621: // Create New pipe instances for each connection
622: //
623:
624: PipeH[0]=CreateNamedPipe
625: (
626: fullnameIn ,
627: PIPE_ACCESS_INBOUND ,
628: PIPE_TYPE_BYTE,
629: PIPE_UNLIMITED_INSTANCES,
630: 0,0,0,&lsa
631: );
632:
633: PipeH[1]=CreateNamedPipe
634: (
635: fullnameOut,
636: PIPE_ACCESS_OUTBOUND,
637: PIPE_TYPE_BYTE,
638: PIPE_UNLIMITED_INSTANCES,
639: 0,0,0,&lsa
640: );
641:
642: if (!ConnectNamedPipe(PipeH[0],NULL))
643: {
644: if (GetLastError()!=ERROR_PIPE_CONNECTED)
645: {
646: CloseHandle(PipeH[0]);
647: CloseHandle(PipeH[1]);
648: continue;
649: }
650:
651: }
652:
653: if (!ConnectNamedPipe(PipeH[1],NULL))
654: {
655: if (GetLastError()!=ERROR_PIPE_CONNECTED)
656: {
657: CloseHandle(PipeH[0]);
658: CloseHandle(PipeH[1]);
659: continue;
660: }
661: }
662:
663: //
664: //Look For a Free Slot & if not- then terminate connection
665: //
666:
667: for (i=1;i<MAX_SESSION;i++)
668: {
669: //
670: // Locate a Free Client block
671: //
672: if (!ClientList[i].Active)
673: break;
674: }
675:
676: if (i<MAX_SESSION)
677: {
678: //
679: // Initialize the Client
680: //
681: ClientList[i].PipeReadH=PipeH[0];
682: ClientList[i].PipeWriteH=PipeH[1];
683: ClientList[i].Active=TRUE;
684: ClientList[i].SendOutput=TRUE;
685: ClientList[i].CommandRcvd=FALSE;
686:
687: }
688: else
689: {
690: WRITEF((VBuff,"Remote:Closing New Session - No more slots\n"));
691: CloseHandle(PipeH[0]);
692: CloseHandle(PipeH[1]);
693: continue;
694: }
695:
696: //
697: //start new thread for this connection
698: //
699:
700: if((ClientList[i].hThread=CreateThread
701: (
702: (LPSECURITY_ATTRIBUTES)NULL, // No security attributes.
703: (DWORD)0, // Use same stack size.
704: (LPTHREAD_START_ROUTINE)RemoteSession, // Thread procedure.
705: (LPVOID)&ClientList[i], // Parameter to pass.
706: (DWORD)0, // Run immediately.
707: (LPDWORD)&ThreadID)
708: )==NULL)
709: {
710: CloseClient(&ClientList[i]);
711: continue;
712: }
713: }
714: return(0);
715: }
716: /*************************************************************/
717: /* Manages the Session with a Client - Creates a thread for */
718: /* Inputs from the client and a thread for sending outputs to*/
719: /* the client. Could have just as easily done with 1 thread */
720: /* using Asyn IO. */
721: /*************************************************************/
722: DWORD
723: RemoteSession(
724: SESSION_TYPE *MyClient
725: )
726: {
727: DWORD ReadCnt;
728: SESSION_STARTUPINFO ssi;
729: char *headerbuff;
730: char msg[BUFFSIZE];
731: DWORD tmp;
732: SESSION_STARTREPLY ssr;
733: SYSTEMTIME st;
734:
735: GetLocalTime(&st);
736: memset((char *)&ssi,0,sizeof(ssi));
737:
738: //
739: // Open a new handle to the save file ...
740: // contains the saved output from the child process
741: // and the commands already given to it.
742: //
743:
744: if ((MyClient->rSaveFile=CreateFile
745: (
746: SaveFileName,
747: GENERIC_READ|GENERIC_WRITE,
748: FILE_SHARE_READ|FILE_SHARE_WRITE,
749: NULL,OPEN_EXISTING,
750: FILE_ATTRIBUTE_NORMAL,NULL)
751: )==NULL)
752:
753: {
754: CloseClient(MyClient);
755: return(1);
756: }
757:
758: //
759: // Exchange Remote Information with Client.
760: //
761:
762: {
763:
764: DWORD reply=0;
765:
766: ReadFixBytes(MyClient->PipeReadH,(char *)MyClient->Name,HOSTNAMELEN-1,0);
767:
768: //
769: //Last four Bytes contains a code
770: //
771:
772: memcpy((char *)&reply,(char *)&(MyClient->Name[11]),4);
773:
774: if (reply!=MAGICNUMBER)
775: {
776: //
777: // Unknown client
778: //
779: CloseClient(MyClient);
780: return(1);
781: }
782:
783: ssr.MagicNumber=MAGICNUMBER;
784: ssr.Size=sizeof(ssr);
785: ssr.FileSize=GetFileSize( MyClient->rSaveFile, &tmp );
786:
787: WriteFile(MyClient->PipeWriteH,(char *)&ssr,sizeof(ssr),&tmp,NULL);
788: }
789:
790: if (ReadFixBytes(MyClient->PipeReadH,(char *)&(ssi.Size),sizeof(ssi.Size),0)!=0)
791: {
792: CloseClient(MyClient);
793: return(1);
794: }
795:
796: if (ssi.Size>1024) //Sanity Check
797: {
798: sprintf(msg,"%s","Server:Unknown Header..Terminating session\n");
799: WriteFile(MyClient->PipeWriteH,msg,strlen(msg),&tmp,NULL);
800: CloseClient(MyClient);
801: return(1);
802: }
803:
804: if ((headerbuff=(char *)calloc(ssi.Size,1))==NULL)
805: {
806: sprintf(msg,"%s","Server:Not Enough Memory..Terminating session\n");
807: WriteFile(MyClient->PipeWriteH,msg,strlen(msg),&tmp,NULL);
808: CloseClient(MyClient);
809: return(1);
810: }
811:
812: ReadCnt=ssi.Size-sizeof(ssi.Size);
813: if (ReadFixBytes(MyClient->PipeReadH,(char *)headerbuff,ReadCnt,0)!=0)
814: {
815: CloseClient(MyClient);
816: return(1);
817: }
818:
819: memcpy((char *)&ssi+sizeof(ssi.Size),headerbuff,sizeof(ssi)-sizeof(ssi.Size));
820: free(headerbuff);
821:
822: /* Version */
823: if (ssi.Version!=VERSION)
824: {
825: sprintf(msg,"Remote Warning:Server Version=%d Client Version=%d\n",VERSION,ssi.Version);
826: WriteFile(MyClient->PipeWriteH,msg,strlen(msg),&tmp,NULL);
827:
828: }
829:
830: /* Name */
831: {
832: memcpy(MyClient->Name,ssi.ClientName,15);
833: MyClient->Name[14]=0;
834:
835: }
836:
837: /* Lines */
838: if (ssi.LinesToSend!=-1)
839: {
840: long PosFromEnd=ssi.LinesToSend*CHARS_PER_LINE;
841: DWORD BytesToSend=MINIMUM((DWORD)PosFromEnd,ssr.FileSize);
842: DWORD BytesRead;
843: char *buff=(char *)calloc(BytesToSend+1,1);
844:
845: if (ssr.FileSize > (DWORD)PosFromEnd)
846: {
847: SetFilePointer(
848: MyClient->rSaveFile,
849: -PosFromEnd,
850: (PLONG)NULL,
851: FILE_END
852: );
853: }
854:
855: if (buff!=NULL)
856: {
857: if (!ReadFile(MyClient->rSaveFile,buff,BytesToSend,&BytesRead,NULL))
858: {
859: CloseClient(MyClient);
860: return(1);
861: }
862:
863: //
864: // Don't want the markers to be part of the output display
865: // at the client end.
866: //
867: RemoveInpMark(buff,BytesRead);
868: if (!WriteFile(MyClient->PipeWriteH,buff,BytesRead,&tmp,NULL))
869: {
870: CloseClient(MyClient);
871: return(1);
872: }
873: }
874: free(buff);
875:
876: }
877:
878: RemoteInfo(printf("\n**Remote:Connected To %s [%02d:%02d]\n",MyClient->Name,st.wHour,st.wMinute),ssi.Flag);
879:
880: //
881: // Start off the new session.
882: //
883: NewSession(MyClient);
884:
885: RemoteInfo(printf("\n**Remote:Disconnected From %s [%02d:%02d]\n",MyClient->Name,st.wHour,st.wMinute),ssi.Flag);
886: CloseClient(MyClient);
887: return(0);
888: }
889: /*************************************************************/
890: DWORD
891: NewSession(
892: SESSION_TYPE* MyClient
893: )
894: {
895: DWORD ThreadId;
896: HANDLE rwThread[3];
897:
898: MyClient->MoreData=CreateEvent
899: (
900: (LPSECURITY_ATTRIBUTES) NULL,/* address of security attributes */
901: FALSE, /* flag for manual-reset event */
902: TRUE, /* flag for initial state */
903: NULL /* address of event-object name */
904: );
905:
906: if ((rwThread[0]=CreateThread
907: (
908: (LPSECURITY_ATTRIBUTES)NULL, // No security attributes.
909: (DWORD)0, // Use same stack size.
910: (LPTHREAD_START_ROUTINE)GetClientInput, // Thread procedure.
911: (LPVOID)MyClient, // Parameter to pass.
912: (DWORD)0, // Run immediately.
913: (LPDWORD)&ThreadId)
914: )==NULL)
915: {
916: return(GetLastError());
917: }
918:
919:
920: if ((rwThread[1]=CreateThread
921: (
922: (LPSECURITY_ATTRIBUTES)NULL, // No security attributes.
923: (DWORD)0, // Use same stack size.
924: (LPTHREAD_START_ROUTINE)TransferFileToClient, // Thread procedure.
925: (LPVOID)MyClient, // Parameter to pass.
926: (DWORD)0, // Run immediately.
927: (LPDWORD)&ThreadId)
928: )==NULL)
929: {
930: CloseHandle(rwThread[0]);
931: return(GetLastError());
932: }
933:
934: rwThread[2]=ChldProc;
935:
936: //
937: // Wait for either the Input or Output thread
938: // to terminate and then close the session.
939: //
940:
941: WaitForMultipleObjects(3, rwThread,FALSE, INFINITE);
942:
943: TerminateThread(rwThread[0],1);
944: TerminateThread(rwThread[1],1);
945:
946: CloseHandle(rwThread[0]);
947: CloseHandle(rwThread[0]);
948:
949: return(0);
950: }
951:
952: /*************************************************************/
953: /* Saves the output from the child process into the savefile */
954: /* All the remote client thread and local client thread */
955: /* open a seperate handle to this and output its content */
956: /* sequentially. */
957: /*************************************************************/
958: DWORD
959: GetChldOutput(
960: HANDLE readH
961: )
962: {
963: char buff[BUFFSIZE];
964: DWORD dread;
965: DWORD tmp;
966:
967:
968: while(ReadFile(readH,buff,BUFFSIZE-1,&dread,NULL))
969: {
970: buff[dread]='\0';
971:
972: if (!WriteFile(SaveFile,buff,dread,&tmp,NULL))
973: {
974: return(1);
975: }
976:
977: //
978: // Signal Reader Thread that more data is available
979: //
980: {
981: int i;
982: for (i=0;i<MAX_SESSION;i++)
983: {
984: if (ClientList[i].Active)
985: {
986: SetEvent(ClientList[i].MoreData);
987: }
988: }
989: }
990: }
991: return(1);
992: }
993: /*************************************************************/
994: /* A thread for each client connection and one for local IO */
995: /* Reads the contents of Save file and sends it to client for*/
996: /* display. */
997: /*************************************************************/
998: DWORD
999: TransferFileToClient(
1000: SESSION_TYPE *MyClient
1001: )
1002: {
1003:
1004: char buffin[BUFFSIZE],buffout[BUFFSIZE],cmdbuff[BUFFSIZE];
1005: DWORD tmp;
1006: DWORD dread=0,dwrite=0;
1007: BOOL incmd=FALSE;
1008: DWORD cmdP=0;
1009: DWORD i;
1010: char MyEchoStr[30];
1011:
1012: sprintf(MyEchoStr,"[%-15s",MyClient->Name);
1013:
1014: while(ReadFile(MyClient->rSaveFile,buffin,BUFFSIZE-1,&dread,NULL))
1015: {
1016: if (dread==0)
1017: {
1018: //
1019: // Event is set by GetChldOutput() func. to signal
1020: // More data is available in save file.
1021: //
1022: WaitForSingleObject(MyClient->MoreData,INFINITE);
1023: continue;
1024: }
1025: dwrite=0;
1026:
1027: //
1028: // This is all to insure that the commands entered
1029: // by clients are not echoed back to them.
1030: // A Beginmark and an Endmark is placed around commands
1031: // sent to the child process from some client.
1032: //
1033:
1034: for(i=0;i<dread;i++)
1035: {
1036: if (incmd)
1037: {
1038: if ((buffin[i]==ENDMARK)||(cmdP==BUFFSIZE-1))
1039: {
1040: incmd=FALSE;
1041: cmdbuff[cmdP]=0;
1042: if ((strstr(cmdbuff,MyEchoStr)==NULL)||
1043: (!MyClient->CommandRcvd))
1044: {
1045: if (!WriteFile(
1046: MyClient->PipeWriteH,
1047: cmdbuff,cmdP,&tmp,NULL))
1048: {
1049: return(1);
1050: }
1051: }
1052: cmdP=0;
1053: }
1054: else
1055: {
1056: cmdbuff[cmdP++]=buffin[i];
1057: }
1058: }
1059: else
1060: {
1061:
1062: if (buffin[i]==BEGINMARK)
1063: {
1064: if (dwrite!=0)
1065: {
1066: if (!WriteFile(
1067: MyClient->PipeWriteH,
1068: buffout,dwrite,&tmp,NULL))
1069: {
1070: return(1);
1071: }
1072: dwrite=0;
1073: }
1074: incmd=TRUE;
1075: continue;
1076: }
1077: else
1078: {
1079: buffout[dwrite++]=buffin[i];
1080: }
1081: }
1082: }
1083:
1084: if (dwrite!=0)
1085: {
1086: if (!WriteFile(
1087: MyClient->PipeWriteH,
1088: buffout,dwrite,&tmp,NULL))
1089: {
1090: return(0);
1091: }
1092: }
1093: }
1094: return(1);
1095: }
1096:
1097: /*************************************************************/
1098: /* Commands from the clients are sent to the child process */
1099: /* and also saved in the SaveFile with Begin and End markers */
1100: /* around them to seperate them from the output from child */
1101: /* process. */
1102: /*************************************************************/
1103: DWORD
1104: GetClientInput(
1105: SESSION_TYPE *MyClient
1106: )
1107: {
1108: char buff[BUFFSIZE];
1109: DWORD tmp,dread;
1110:
1111: while(ReadFile(MyClient->PipeReadH,buff,BUFFSIZE,&dread,NULL))
1112: {
1113: buff[dread]=0;
1114: MyClient->CommandRcvd=TRUE;
1115:
1116: if (FilterCommand(MyClient,buff,dread))
1117: continue;
1118:
1119:
1120: if (!WriteFile(ChildStdInp,buff,dread,&tmp,NULL))
1121: {
1122: ExitThread(0);
1123: }
1124: }
1125: return(1);
1126: }
1127:
1128: /*************************************************************/
1129: /* If a client command is intended for the Remote server - */
1130: /* those beginning with COMMANDCHAR (are not intended */
1131: /* for the child process) - they are executed here */
1132: /* and the output sent to the client. */
1133: /*************************************************************/
1134: BOOL
1135: FilterCommand(
1136: SESSION_TYPE *cl,
1137: char *buff,
1138: int dread
1139: )
1140: {
1141: SYSTEMTIME st;
1142: char inp_buff[4096];
1143: char tmpchar;
1144: char ch[3];
1145: DWORD tmp;
1146: int len;
1147: DWORD ThreadID; //Useless
1148:
1149: if (dread==0)
1150: return(FALSE);
1151:
1152: buff[dread]=0;
1153:
1154: GetLocalTime(&st);
1155:
1156:
1157: if (buff[0]==COMMANDCHAR)
1158: {
1159: switch(buff[1])
1160: {
1161: case 'o':
1162: case 'O':
1163: cl->SendOutput=!cl->SendOutput;
1164: break;
1165:
1166: case 'k':
1167: case 'K':
1168: TerminateProcess(ChldProc,1);
1169: break;
1170:
1171: case 's':
1172: case 'S':
1173: SendStatus(cl->PipeWriteH);
1174: break;
1175:
1176: case 'p':
1177: case 'P':
1178: {
1179: char *mssg=(char *)calloc(4096,1); //Free it in called Proc
1180: char *ack="Remote:Popup Shown..\n";
1181:
1182: if (mssg==NULL)
1183: break;
1184:
1185: sprintf(mssg,"From %s [%d:%d]\n\n%s\n",cl->Name,st.wHour,st.wMinute,&buff[2]);
1186: CreateThread(
1187: (LPSECURITY_ATTRIBUTES)NULL, // No security attributes.
1188: (DWORD)0, // Use same stack size.
1189: (LPTHREAD_START_ROUTINE)ShowPopup, // Thread procedure.
1190: (LPVOID)mssg, // Parameter to pass.
1191: (DWORD)0, // Run immediately.
1192: (LPDWORD)&ThreadID
1193: );
1194: WriteFile(cl->PipeWriteH,ack,strlen(ack),&tmp,NULL);
1195: break;
1196: }
1197:
1198: case 'm':
1199: case 'M':
1200: buff[dread-2]=0;
1201: CMDSTRING(inp_buff,buff,cl,st);
1202: len=strlen(inp_buff);
1203: WriteFile(SaveFile,inp_buff,len,&tmp,NULL);
1204: break;
1205:
1206: case '@':
1207: buff[dread-2]=0;
1208: CMDSTRING(inp_buff,&buff[1],cl,st);
1209: len=strlen(inp_buff);
1210: WriteFile(SaveFile,inp_buff,len,&tmp,NULL);
1211: //
1212: // Remove the first @ sign
1213: //
1214: MoveMemory(buff,&buff[1],dread-1);
1215: buff[dread-1]=' ';
1216: return(FALSE); //Send it it to the chile process
1217: break;
1218:
1219:
1220: default :
1221: sprintf(inp_buff,"%s","** Unknown Command **\n");
1222: WriteFile(cl->PipeWriteH,inp_buff,strlen(inp_buff),&tmp,NULL);
1223:
1224: case 'h':
1225: case 'H':
1226: sprintf(inp_buff,"%cM: To Send Message\n",COMMANDCHAR);
1227: WriteFile(cl->PipeWriteH,inp_buff,strlen(inp_buff),&tmp,NULL);
1228: sprintf(inp_buff,"%cP: To Generate popup\n",COMMANDCHAR);
1229: WriteFile(cl->PipeWriteH,inp_buff,strlen(inp_buff),&tmp,NULL);
1230: sprintf(inp_buff,"%cK: To kill the server\n",COMMANDCHAR);
1231: WriteFile(cl->PipeWriteH,inp_buff,strlen(inp_buff),&tmp,NULL);
1232: sprintf(inp_buff,"%cH: This Help\n",COMMANDCHAR);
1233: WriteFile(cl->PipeWriteH,inp_buff,strlen(inp_buff),&tmp,NULL);
1234: break;
1235: }
1236: return(TRUE);
1237: }
1238:
1239:
1240: if ((buff[0]<26))
1241: {
1242: BOOL ret=FALSE;
1243:
1244: sprintf(ch,"^%c",buff[0]+64);
1245: CMDSTRING(inp_buff,ch,cl,st);
1246: len=strlen(inp_buff);
1247:
1248: if (buff[0]==CTRLC)
1249: {
1250: cl->CommandRcvd=FALSE;
1251: GenerateConsoleCtrlEvent(CTRL_C_EVENT,0);
1252: ret=TRUE; //Already sent to child
1253: }
1254:
1255: WriteFile(SaveFile,inp_buff,len,&tmp,NULL);
1256: return(ret); //FALSE:send it to child StdIn
1257: }
1258:
1259: tmpchar=buff[dread-2]; //must be 13;but just incase
1260: buff[dread-2]=0;
1261: CMDSTRING(inp_buff,buff,cl,st);
1262: buff[dread-2]=tmpchar;
1263: len=strlen(inp_buff);
1264: WriteFile(SaveFile,inp_buff,len,&tmp,NULL);
1265: return(FALSE);
1266: }
1267: /*************************************************************/
1268: VOID
1269: SendStatus(
1270: HANDLE hClientPipe
1271: )
1272: {
1273: char buff[1024];
1274: int i;
1275: DWORD tmp;
1276: char *env=(char *)GetEnvironmentStrings();
1277: DWORD ver=GetVersion();
1278:
1279: sprintf(buff,"Command = %s\n",ChildCmd);
1280: WriteFile(hClientPipe,buff,strlen(buff),&tmp,NULL);
1281:
1282: sprintf(buff,"Server = %s PIPE=%s\n",HostName,PipeName);
1283: WriteFile(hClientPipe,buff,strlen(buff),&tmp,NULL);
1284:
1285: sprintf(buff,"Build = %d \n",((WORD *)&ver)[1]);
1286: WriteFile(hClientPipe,buff,strlen(buff),&tmp,NULL);
1287:
1288: for (i=1;i<MAX_SESSION;i++)
1289: {
1290: if (ClientList[i].Active)
1291: {
1292: sprintf(buff,"ACTIVE SESSION=%s\n",ClientList[i].Name);
1293: WriteFile(hClientPipe,buff,strlen(buff),&tmp,NULL);
1294: }
1295: }
1296:
1297: sprintf(buff,"====================\n",Server,PipeName);
1298: WriteFile(hClientPipe,buff,strlen(buff),&tmp,NULL);
1299:
1300: sprintf(buff,"ENVIRONMENT VARIABLES\n",Server,PipeName);
1301: WriteFile(hClientPipe,buff,strlen(buff),&tmp,NULL);
1302:
1303: sprintf(buff,"====================\n",Server,PipeName);
1304: WriteFile(hClientPipe,buff,strlen(buff),&tmp,NULL);
1305:
1306:
1307: try
1308: {
1309: while (*env!=0)
1310: {
1311: sprintf(buff,"%s\n",env);
1312: WriteFile(hClientPipe,buff,strlen(buff),&tmp,NULL);
1313:
1314: while(*(env++)!=0);
1315: }
1316: }
1317: except(EXCEPTION_EXECUTE_HANDLER)
1318: {
1319: sprintf(buff,"Exception Generated Getting Environment Block\n",env);
1320: WriteFile(hClientPipe,buff,strlen(buff),&tmp,NULL);
1321:
1322: }
1323:
1324: sprintf(buff,"====================\n",Server,PipeName);
1325: WriteFile(hClientPipe,buff,strlen(buff),&tmp,NULL);
1326: return;
1327: }
1328: /*************************************************************/
1329: DWORD
1330: ShowPopup(
1331: char *mssg
1332: )
1333: {
1334: MessageBox(GetActiveWindow(),mssg,"***REMOTE***",MB_OK|MB_SETFOREGROUND);
1335: free(mssg);
1336: return(0);
1337:
1338: }
1339: /*************************************************************/
1340: BOOL SrvCtrlHand(
1341: DWORD event
1342: )
1343: {
1344: if (event==CTRL_BREAK_EVENT)
1345: {
1346: TerminateProcess(ChldProc,1);
1347: }
1348: return(TRUE);
1349: }
1350: /*************************************************************/
1351:
1352: DWORD LocalSession(PVOID noarg)
1353: {
1354: //Local is ClientList[0]
1355: char *name=(char *)ClientList[0].Name;
1356:
1357: strcpy(name,LOCALNAME);
1358: if ((ClientList[0].rSaveFile=CreateFile(SaveFileName,GENERIC_READ|GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL))==NULL)
1359: {
1360: WRITEF((VBuff,"Remote:Cannot open ReadHandle to Savefile:%d\n",GetLastError()));
1361: ClientList[0].Active=FALSE;
1362: return(1);
1363:
1364: }
1365:
1366: ClientList[0].PipeReadH=GetStdHandle(STD_INPUT_HANDLE);
1367: ClientList[0].PipeWriteH=GetStdHandle(STD_OUTPUT_HANDLE);
1368: ClientList[0].SendOutput=TRUE;
1369: ClientList[0].Active=TRUE;
1370: NewSession(&ClientList[0]);
1371: CloseClient(&ClientList[0]);
1372: return(0);
1373: }
1374:
1375: VOID
1376: CloseClient(
1377: SESSION_TYPE *Client
1378: )
1379: {
1380: ZeroMemory(Client->Name,HOSTNAMELEN);
1381:
1382: if (Client->PipeReadH!=INVALID_HANDLE_VALUE)
1383: {
1384: CloseHandle(Client->PipeReadH);
1385: Client->PipeReadH=INVALID_HANDLE_VALUE;
1386: }
1387:
1388: if (Client->PipeWriteH!=INVALID_HANDLE_VALUE)
1389: {
1390: CloseHandle(Client->PipeWriteH);
1391: Client->PipeWriteH=INVALID_HANDLE_VALUE;
1392: }
1393:
1394: if (Client->rSaveFile!=INVALID_HANDLE_VALUE)
1395: {
1396: CloseHandle(Client->rSaveFile);
1397: Client->rSaveFile=INVALID_HANDLE_VALUE;
1398: }
1399: if (Client->MoreData!=NULL)
1400: {
1401: CloseHandle(Client->MoreData);
1402: Client->MoreData=NULL;
1403: }
1404:
1405: Client->Active=FALSE; //Keep it last else synch problem.
1406: return;
1407: }
1408:
1409: VOID
1410: InitClientList(
1411: )
1412: {
1413: int i;
1414: for (i=0;i<MAX_SESSION;i++)
1415: {
1416: ZeroMemory(ClientList[i].Name,HOSTNAMELEN);
1417: ClientList[i].PipeReadH=INVALID_HANDLE_VALUE;
1418: ClientList[i].PipeWriteH=INVALID_HANDLE_VALUE;
1419: ClientList[i].rSaveFile=INVALID_HANDLE_VALUE;
1420: ClientList[i].MoreData=NULL;
1421: ClientList[i].Active=FALSE;
1422: ClientList[i].CommandRcvd=FALSE;
1423: ClientList[i].SendOutput=FALSE;
1424: ClientList[i].hThread=NULL;
1425: }
1426: return;
1427: }
1428:
1429:
1430:
1431: VOID
1432: RemoveInpMark(
1433: char* Buff,
1434: DWORD Size
1435: )
1436:
1437: {
1438: DWORD i;
1439: for (i=0;i<Size;i++)
1440: {
1441: switch (Buff[i])
1442: {
1443: case BEGINMARK:
1444: Buff[i]=' ';
1445: break;
1446:
1447: case ENDMARK:
1448: if (i<2)
1449: {
1450: Buff[i]= ' ';
1451: }
1452: else
1453: {
1454: Buff[i] =Buff[i-1];
1455: Buff[i-1]=Buff[i-2];
1456: Buff[i-2]=' ';
1457: }
1458: break;
1459:
1460: default:
1461: break;
1462: }
1463: }
1464: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.