![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to client.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 client.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: Client.c
8:
9: Abstract:
10:
11: The Client component of Remote. Connects to the remote
12: server using named pipes. It sends its stdin to
13: the server and output everything from server to
14: its stdout.
15:
16: Author:
17:
18: Rajivendra Nath (rajnath) 2-Jan-1992
19:
20: Environment:
21:
22: Console App. User mode.
23:
24: Revision History:
25:
26: --*/
27:
28: #include <windows.h>
29: #include <stdio.h>
30: #include <stdlib.h>
31: #include <io.h>
32: #include <string.h>
33: #include "Remote.h"
34:
35:
36:
37:
38: HANDLE*
39: EstablishSession(
40: char *server,
41: char *pipe
42: );
43:
44: DWORD
45: GetServerOut(
46: PVOID *Noarg
47: );
48:
49: DWORD
50: SendServerInp(
51: PVOID *Noarg
52: );
53:
54: BOOL
55: FilterClientInp(
56: char *buff,
57: int count
58: );
59:
60:
61: BOOL
62: Mych(
63: DWORD ctrlT
64: );
65:
66: VOID
67: SendMyInfo(
68: PHANDLE Pipes
69: );
70:
71:
72:
73: HANDLE iothreads[2];
74: HANDLE MyStdInp;
75: HANDLE MyStdOut;
76: HANDLE ReadPipe;
77: HANDLE WritePipe;
78:
79:
80: CONSOLE_SCREEN_BUFFER_INFO csbi;
81:
82: char MyEchoStr[30];
83: BOOL CmdSent;
84: DWORD LinesToSend=LINESTOSEND;
85:
86: VOID
87: Client(
88: char* Server,
89: char* Pipe
90: )
91: {
92: HANDLE *Connection;
93: DWORD tid;
94:
95:
96: MyStdInp=GetStdHandle(STD_INPUT_HANDLE);
97: MyStdOut=GetStdHandle(STD_OUTPUT_HANDLE);
98:
99: WRITEF((VBuff,"**************************************\n"));
100: WRITEF((VBuff,"*********** REMOTE ************\n"));
101: WRITEF((VBuff,"*********** CLIENT ************\n"));
102: WRITEF((VBuff,"**************************************\n"));
103:
104: if ((Connection=EstablishSession(Server,Pipe))==NULL)
105: return;
106:
107:
108: ReadPipe=Connection[0];
109: WritePipe=Connection[1];
110:
111:
112: SetConsoleCtrlHandler((PHANDLER_ROUTINE)Mych,TRUE);
113:
114: // Start Thread For Server --> Client Flow
115: if ((iothreads[0]=CreateThread((LPSECURITY_ATTRIBUTES)NULL, // No security attributes.
116: (DWORD)0, // Use same stack size.
117: (LPTHREAD_START_ROUTINE)GetServerOut, // Thread procedure.
118: (LPVOID)NULL, // Parameter to pass.
119: (DWORD)0, // Run immediately.
120: (LPDWORD)&tid))==NULL) // Thread identifier.
121: {
122:
123: Errormsg("Could Not Create rwSrv2Cl Thread");
124: return;
125: }
126:
127:
128:
129: //
130: // Start Thread for Client --> Server Flow
131: //
132:
133: if ((iothreads[1]=CreateThread((LPSECURITY_ATTRIBUTES)NULL, // No security attributes.
134: (DWORD)0, // Use same stack size.
135: (LPTHREAD_START_ROUTINE)SendServerInp, // Thread procedure.
136: (LPVOID)NULL, // Parameter to pass.
137: (DWORD)0, // Run immediately.
138: (LPDWORD)&tid))==NULL) // Thread identifier.
139: {
140:
141: Errormsg("Could Not Create rwSrv2Cl Thread");
142: return;
143: }
144:
145: WaitForMultipleObjects(2,iothreads,FALSE,INFINITE);
146:
147: CloseHandle(ReadPipe);
148: CloseHandle(WritePipe);
149: TerminateThread(iothreads[0],1);
150: TerminateThread(iothreads[1],1);
151: WRITEF((VBuff,"*** SESSION OVER ***\n"));
152: }
153:
154:
155: DWORD
156: GetServerOut(
157: PVOID *Noarg
158: )
159:
160: {
161: char buffin[200];
162: DWORD dread=0,tmp;
163:
164: while(ReadFile(ReadPipe,buffin,200,&dread,NULL))
165: {
166: if (dread!=0)
167: {
168: if (!WriteFile(MyStdOut,buffin,dread,&tmp,NULL))
169: break;
170: }
171:
172: }
173: return(1);
174: }
175:
176: DWORD
177: SendServerInp(
178: PVOID *Noarg
179: )
180:
181: {
182: char buff[200];
183: DWORD dread,dwrote;
184: SetLastError(0);
185:
186: while(ReadFile(MyStdInp,buff,200,&dread,NULL))
187: {
188: if (FilterClientInp(buff,dread))
189: continue;
190: if (!WriteFile(WritePipe,buff,dread,&dwrote,NULL))
191: break;
192: }
193: return(0);
194: }
195:
196: BOOL
197: FilterClientInp(
198: char *buff,
199: int count
200: )
201: {
202:
203: if (count==0)
204: return(TRUE);
205:
206: if (buff[0]==2) //Adhoc screening of ^B so that i386kd/mipskd
207: return(TRUE);//do not terminate.
208:
209: if (buff[0]==COMMANDCHAR)
210: {
211: switch (buff[1])
212: {
213: case 'k':
214: case 'K':
215: case 'q':
216: case 'Q':
217: CloseHandle(WritePipe);
218: return(FALSE);
219:
220: case 'h':
221: case 'H':
222: WRITEF((VBuff,"%cM : Send Message\n",COMMANDCHAR));
223: WRITEF((VBuff,"%cP : Show Popup on Server\n",COMMANDCHAR));
224: WRITEF((VBuff,"%cS : Status of Server\n",COMMANDCHAR));
225: WRITEF((VBuff,"%cQ : Quit client\n",COMMANDCHAR));
226: WRITEF((VBuff,"%cH : This Help\n",COMMANDCHAR));
227: return(TRUE);
228:
229: default:
230: return(FALSE);
231: }
232:
233: }
234: return(FALSE);
235: }
236:
237:
238: BOOL
239: Mych(
240: DWORD ctrlT
241: )
242:
243: {
244: char c[2];
245: DWORD tmp;
246: DWORD send=1;
247: c[0]=3;
248: if (ctrlT==CTRL_C_EVENT)
249: {
250: if (!WriteFile(WritePipe,c,send,&tmp,NULL))
251: {
252: Errormsg("Error Sending ^c\n");
253: return(FALSE);
254: }
255:
256: }
257: if ((ctrlT==CTRL_BREAK_EVENT)||
258: (ctrlT==CTRL_CLOSE_EVENT)||
259: (ctrlT==CTRL_LOGOFF_EVENT)||
260: (ctrlT==CTRL_SHUTDOWN_EVENT)
261:
262: )
263: {
264: CloseHandle(ReadPipe); //Will Shutdown naturally
265: }
266: return(TRUE);
267: }
268:
269: HANDLE*
270: EstablishSession(
271: char *server,
272: char *srvpipename
273: )
274: {
275: static HANDLE PipeH[2];
276: char pipenameSrvIn[200];
277: char pipenameSrvOut[200];
278:
279: sprintf(pipenameSrvIn ,SERVER_READ_PIPE ,server,srvpipename);
280: sprintf(pipenameSrvOut,SERVER_WRITE_PIPE,server,srvpipename);
281:
282: PipeH[0]=CreateFile(pipenameSrvOut,GENERIC_READ ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
283: PipeH[1]=CreateFile(pipenameSrvIn ,GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
284:
285: if ((PipeH[0]==INVALID_HANDLE_VALUE)||(PipeH[1]==INVALID_HANDLE_VALUE))
286: {
287: DWORD Err=GetLastError();
288: char msg[128];
289:
290: Errormsg("*** Unable to Connect ***");
291: //
292: // Print a helpfull message
293: //
294: switch(Err)
295: {
296: case 2: sprintf(msg,"Invalid PipeName %s",srvpipename);break;
297: case 5: sprintf(msg,"Access Denied to %s",server);break;
298: case 53:sprintf(msg,"Server %s not found",server);break;
299: case 240:sprintf(msg,"Session Cancelled by %s",server);break;
300: case 1311:sprintf(msg,"No logon servers available");break;
301: default:sprintf(msg,"None");break;
302:
303: }
304: WRITEF((VBuff,"Diagnosis:%s\n",msg));
305:
306: return(NULL);
307: }
308:
309: WRITEF((VBuff,"Connected..\n\n"));
310:
311: SendMyInfo(PipeH);
312:
313: return(PipeH);
314: }
315:
316: VOID
317: SendMyInfo(
318: PHANDLE pipeH
319: )
320: {
321: HANDLE rPipe=pipeH[0];
322: HANDLE wPipe=pipeH[1];
323:
324: DWORD hostlen=HOSTNAMELEN-1;
325: WORD BytesToSend=sizeof(SESSION_STARTUPINFO);
326: DWORD tmp;
327: SESSION_STARTUPINFO ssi;
328: SESSION_STARTREPLY ssr;
329: DWORD BytesToRead;
330: char *buff;
331:
332: ssi.Size=BytesToSend;
333: ssi.Version=VERSION;
334:
335: GetComputerName((char *)ssi.ClientName,&hostlen);
336: ssi.LinesToSend=LinesToSend;
337: ssi.Flag=ClientToServerFlag;
338:
339: {
340: DWORD NewCode=MAGICNUMBER;
341: char Name[15];
342:
343: strcpy(Name,(char *)ssi.ClientName);
344: memcpy(&Name[11],(char *)&NewCode,sizeof(NewCode));
345:
346: WriteFile(wPipe,(char *)Name,HOSTNAMELEN-1,&tmp,NULL);
347: ReadFile(rPipe ,(char *)&ssr.MagicNumber,sizeof(ssr.MagicNumber),&tmp,NULL);
348:
349: if (ssr.MagicNumber!=MAGICNUMBER)
350: {
351: WRITEF((VBuff,"WARNING-YOU ARE CONNECTED TO AN OLD REMOTE SERVER\n"));
352: WriteFile(MyStdOut,(char *)&ssr.MagicNumber,sizeof(ssr.MagicNumber),&tmp,NULL);
353: return;
354: }
355:
356: //Get Rest of the info-its not the old server
357:
358: ReadFixBytes(rPipe,(char *)&ssr.Size,sizeof(ssr.Size),0);
359: ReadFixBytes(rPipe,(char *)&ssr.FileSize,sizeof(ssr)-sizeof(ssr.FileSize)-sizeof(ssr.MagicNumber),0);
360:
361: }
362:
363: if (!WriteFile(wPipe,(char *)&ssi,BytesToSend,&tmp,NULL))
364: {
365: Errormsg("INFO Send Error");
366: return;
367: }
368:
369: BytesToRead=MINIMUM(ssr.FileSize,ssi.LinesToSend*CHARS_PER_LINE);
370: buff=calloc(BytesToRead+1,1);
371: if (buff!=NULL)
372: {
373: DWORD bytesread=0;
374:
375: ReadFile(rPipe,buff,BytesToRead,&bytesread,NULL);
376:
377: WriteFile(MyStdOut,buff,bytesread,&tmp,NULL);
378: free(buff);
379: }
380:
381: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.