Return to client.c CVS log

Up to [WindowsNT SDKs] / mstools / samples / sdktools / remote

Annotation of mstools/samples/sdktools/remote/client.c, revision 1.1

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.