Windows编程

开发平台：
Visual C++

SERVER.H：源码内容
							
/******************************************************************************
*       This is a part of the Microsoft Source Code Samples. 
*       Copyright 1995 - 1997 Microsoft Corporation.
*       All rights reserved. 
*       This source code is only intended as a supplement to 
*       Microsoft Development Tools and/or WinHelp documentation.
*       See these sources for detailed information regarding the 
*       Microsoft samples programs.
******************************************************************************/
/*++
Copyright (c) 1997  Microsoft Corporation
Module Name:
    Server.h
Abstract:
    The server component of Remote, rewritten using
    ReadFileEx/WriteFileEx completion routines.
Author:
    Dave Hart  30 May 1997
Environment:
    Console App. User mode.
Revision History:
--*/
#include <lm.h>                // needed for NET_API_STATUS below
#if !defined(SERVER_H_NOEXTERN)
#define SRVEXTERN extern
#else
#define SRVEXTERN
#endif
#if DBG
  DWORD Trace;         // bits set in here trigger trace printfs
  #define TR_SESSION            (0x01)
  #define TR_CHILD              (0x02)
  #define TR_SHAKE              (0x04)
  #define TR_CONNECT            (0x08)
  #define TR_QUERY              (0x10)
  #define TR_COPYPIPE           (0x20)
#endif
#if DBG
  #define TRACE(tracebit, printfargs)                        
              ((Trace & (TR_##tracebit)                      
                   ? (printf printfargs, fflush(stdout), 0)  
                   : 0))
#else
  #define TRACE(tracebit, printfargs)    (0)
#endif
#if defined(ASSERT)
#undef ASSERT
#endif
#if DBG
  #define ASSERT(exp)  ((exp) || (ErrorExit("Assertion failed in " __FILE__ ": " #exp ),0))
#else
  #define ASSERT(exp)  (0)
#endif
//
// Size of transfer buffers
//
#define BUFFSIZE      (4 * 1024)
//
// ServerFlags bit values in REMOTE_CLIENT below
//
#define SFLG_CLOSING               0x01
#define SFLG_HANDSHAKING           0x02
#define SFLG_READINGCOMMAND        0x04
#define SFLG_LOCAL                 0x08
#define SFLG_VALID                 
            (SFLG_CLOSING        | 
             SFLG_HANDSHAKING    | 
             SFLG_READINGCOMMAND | 
             SFLG_LOCAL)
//
// Per-client state
//
typedef struct tagREMOTE_CLIENT {
    LIST_ENTRY Links;
    DWORD   dwID;           // 1, 2, ...
    DWORD   ServerFlags;
    DWORD   Flag;           //from Client's ClientToServerFlag
    DWORD   cbWrite;        //zero if no read temp/write client ops pending
    HANDLE  PipeReadH;      //Client sends its StdIn  through this
    HANDLE  PipeWriteH;     //Client gets  its StdOut through this
    DWORD   dwFilePos;      //offset of temp file where next read begins
    OVERLAPPED ReadOverlapped;
    OVERLAPPED WriteOverlapped;
    HANDLE  rSaveFile;      //Sessions read handle to SaveFile
    DWORD   cbReadTempBuffer;
    DWORD   cbWriteBuffer;
    DWORD   cbCommandBuffer;
    char    HexAsciiId[8];         // dwID as 8 hex chars -- no terminator
    char    Name[HOSTNAMELEN];     //Name of client Machine;
    char    UserName[16];          //Name of user on client machine.
    BYTE    ReadBuffer[BUFFSIZE];
    BYTE    ReadTempBuffer[BUFFSIZE];
    BYTE    WriteBuffer[BUFFSIZE];
    BYTE    CommandBuffer[BUFFSIZE];
} REMOTE_CLIENT, *PREMOTE_CLIENT;
//
// Client lists, see srvlist.c
//
SRVEXTERN LIST_ENTRY       HandshakingListHead;
SRVEXTERN CRITICAL_SECTION csHandshakingList;
SRVEXTERN LIST_ENTRY       ClientListHead;
SRVEXTERN CRITICAL_SECTION csClientList;
SRVEXTERN LIST_ENTRY       ClosingClientListHead;
SRVEXTERN CRITICAL_SECTION csClosingClientList;
SRVEXTERN DWORD   dwNextClientID;
SRVEXTERN LPSTR   pszPipeName;
SRVEXTERN HANDLE  ChldProc;
SRVEXTERN DWORD   pidChild;
SRVEXTERN HANDLE  hWriteChildStdIn;
SRVEXTERN BOOL    bShuttingDownServer;
SRVEXTERN HANDLE  hHeap;
SRVEXTERN volatile DWORD cPendingCtrlCEvents;
SRVEXTERN OSVERSIONINFO OsVersionInfo;
// File containing all that was output by child process.
// Each connection opens a handle to this file
// and sends its contents through PipeWriteH.
SRVEXTERN HANDLE  hWriteTempFile;
SRVEXTERN char    SaveFileName[64]; //Name of above file - all new sessions need
//
// Generic "wide-open" security descriptor as well
// as the possibly-restricted pipe SD.
//
SRVEXTERN SECURITY_DESCRIPTOR sdPublic;
SRVEXTERN SECURITY_ATTRIBUTES saPublic;
SRVEXTERN SECURITY_ATTRIBUTES saPipe;
//
// To minimize client "all pipe instances are busy" errors,
// we wait on connection to several instances of the IN pipe,
// the sole pipe used by single-pipe clients.  Because of the
// requirement to support two-pipe clients (old software as
// well as new software on Win95), we cannot easily create
// and wait for connection on several instances of the OUT pipe.
// This is because two-pipe clients connect to both pipes before
// handshaking commences, and they connect to OUT first.  If we
// had several OUT pipe instances waiting, when an IN pipe was
// connected by the two-pipe client, we wouldn't know which of
// the possibly several connected OUT pipe instances to pair
// it with.  With only one OUT pipe, at IN connect time we need
// to distinguish two-pipe from one-pipe clients so a one-pipe
// client doesn't sneak in between the OUT and IN connects of
// a two-pipe client and wrongly be paired with the OUT pipe.
// To do so we look at the first byte of the initial write
// from the client (of the computername and magic value), if
// it's a question mark we know we have a new client and won't
// accidentally link it to a connected OUT instance.
//
#define CONNECT_COUNT  3
SRVEXTERN DWORD      cConnectIns;
SRVEXTERN OVERLAPPED rgolConnectIn[CONNECT_COUNT];
SRVEXTERN HANDLE     rghPipeIn[CONNECT_COUNT];
SRVEXTERN OVERLAPPED olConnectOut;
SRVEXTERN BOOL       bOutPipeConnected;
SRVEXTERN HANDLE     hPipeOut;
SRVEXTERN HANDLE     hConnectOutTimer;
//
// Indexes into rghWait array for multiple-wait
//
#define WAITIDX_CHILD_PROCESS           0
#define WAITIDX_READ_STDIN_DONE         1
#define WAITIDX_QUERYSRV_WAIT           2
#define WAITIDX_PER_PIPE_EVENT          3
#define WAITIDX_CONNECT_OUT             4
#define WAITIDX_CONNECT_IN_BASE         5
#define MAX_WAIT_HANDLES                (WAITIDX_CONNECT_IN_BASE + CONNECT_COUNT)
SRVEXTERN HANDLE rghWait[MAX_WAIT_HANDLES];
SRVEXTERN OVERLAPPED ReadChildOverlapped;
SRVEXTERN HANDLE     hReadChildOutput;
SRVEXTERN BYTE       ReadChildBuffer[BUFFSIZE];
SRVEXTERN PREMOTE_CLIENT pLocalClient;
typedef struct tagCOPYPIPE {
    HANDLE     hRead;
    HANDLE     hWrite;
} COPYPIPE, *PCOPYPIPE;
SRVEXTERN COPYPIPE rgCopyPipe[2];
SRVEXTERN volatile DWORD dwWriteFilePointer;   // used by SrvCtrlHand (thread)
SRVEXTERN OVERLAPPED QueryOverlapped;
SRVEXTERN HANDLE hQPipe;
SRVEXTERN OVERLAPPED olMainThread;
BOOL
APIENTRY
MyCreatePipeEx(
    OUT LPHANDLE lpReadPipe,
    OUT LPHANDLE lpWritePipe,
    IN LPSECURITY_ATTRIBUTES lpPipeAttributes,
    IN DWORD nSize,
    DWORD dwReadMode,
    DWORD dwWriteMode
    );
DWORD
WINAPI
CopyPipeToPipe(
    LPVOID   lpCopyPipeData
    );
DWORD
WINAPI
CopyStdInToPipe(
    LPVOID   lpCopyPipeData
    );
VOID
FASTCALL
StartSession(
    PREMOTE_CLIENT pClient
    );
VOID
FASTCALL
StartLocalSession(
    VOID
    );
VOID
FASTCALL
StartReadClientInput(
    PREMOTE_CLIENT pClient
    );
VOID
WINAPI
ReadClientInputCompleted(
    DWORD dwError,
    DWORD cbRead,
    LPOVERLAPPED lpO
    );
VOID
WINAPI
WriteChildStdInCompleted(
    DWORD dwError,
    DWORD cbWritten,
    LPOVERLAPPED lpO
    );
#define OUT_PIPE -1
VOID
FASTCALL
CreatePipeAndIssueConnect(
    int  nIndex   // IN pipe index or OUT_PIPE
    );
VOID
FASTCALL
HandleOutPipeConnected(
    VOID
    );
VOID
APIENTRY
ConnectOutTimerFired(
    LPVOID pArg,
    DWORD  dwTimerLo,
    DWORD  dwTimerHi
    );
VOID
FASTCALL
HandleInPipeConnected(
    int nIndex
    );
VOID
FASTCALL
HandshakeWithRemoteClient(
    PREMOTE_CLIENT pClient
    );
VOID
FASTCALL
StartChildOutPipeRead(
    VOID
    );
VOID
WINAPI
ReadChildOutputCompleted(
    DWORD dwError,
    DWORD cbRead,
    LPOVERLAPPED lpO
    );
VOID
WINAPI
WriteTempFileCompleted(
    DWORD dwError,
    DWORD cbWritten,
    LPOVERLAPPED lpO
    );
VOID
FASTCALL
StartServerToClientFlow(
    VOID
    );
VOID
FASTCALL
StartReadTempFile(
    PREMOTE_CLIENT pClient
    );
VOID
WINAPI
ReadTempFileCompleted(
    DWORD dwError,
    DWORD cbRead,
    LPOVERLAPPED lpO
    );
VOID
FASTCALL
StartWriteSessionOutput(
    PREMOTE_CLIENT pClient
    );
BOOL
FASTCALL
WriteSessionOutputCompletedCommon(
    PREMOTE_CLIENT pClient,
    DWORD dwError,
    DWORD cbWritten,
    LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
    );
VOID
WINAPI
WriteSessionOutputCompletedWriteNext(
    DWORD dwError,
    DWORD cbWritten,
    LPOVERLAPPED lpO
    );
VOID
WINAPI
WriteSessionOutputCompletedReadNext(
    DWORD dwError,
    DWORD cbWritten,
    LPOVERLAPPED lpO
    );
VOID
FASTCALL
HandshakeWithRemoteClient(
    PREMOTE_CLIENT pClient
    );
VOID
WINAPI
ReadClientNameCompleted(
    DWORD dwError,
    DWORD cbRead,
    LPOVERLAPPED lpO
    );
VOID
WINAPI
WriteServerReplyCompleted(
    DWORD dwError,
    DWORD cbWritten,
    LPOVERLAPPED lpO
    );
VOID
WINAPI
ReadClientStartupInfoSizeCompleted(
    DWORD dwError,
    DWORD cbRead,
    LPOVERLAPPED lpO
    );
VOID
WINAPI
ReadClientStartupInfoCompleted(
    DWORD dwError,
    DWORD cbRead,
    LPOVERLAPPED lpO
    );
PCHAR
GetFormattedTime(
    BOOL bDate
    );
HANDLE
ForkChildProcess(          // Creates a new process
    char *cmd,             // Redirects its stdin,stdout
    PHANDLE in,            // and stderr - returns the
    PHANDLE out            // corresponding pipe ends.
    );
BOOL
FilterCommand(             //Filters input from client
    REMOTE_CLIENT *cl,      //for commands intended for REMOTE
    char *buff,
    int dread
    );
BOOL
WINAPI
SrvCtrlHand(
    DWORD event
    );
DWORD
WINAPI
SendStatus(
    LPVOID   lpSendStatusParm
    );
DWORD
WINAPI
ShowPopup(
    void *vpArg
    );
VOID
RemoveInpMark(
    char* Buff,
    DWORD Size
    );
VOID
CloseClient(
    REMOTE_CLIENT *Client
    );
PSECURITY_DESCRIPTOR
FormatSecurityDescriptor(
    CHAR * * DenyNames,
    DWORD    DenyCount,
    CHAR * * Names,
    DWORD    Count
    );
BOOL
FASTCALL
HandleSessionError(
    PREMOTE_CLIENT pClient,
    DWORD         dwError
    );
VOID
FASTCALL
CleanupTempFiles(
    PSZ pszTempDir
    );
VOID
FASTCALL
SetupSecurityDescriptors(
    VOID
    );
VOID
FASTCALL
RuntimeLinkAPIs(
    VOID
    );
VOID
FASTCALL
InitializeClientLists(
    VOID
    );
VOID
FASTCALL
AddClientToHandshakingList(
    PREMOTE_CLIENT pClient
    );
VOID
FASTCALL
MoveClientToNormalList(
    PREMOTE_CLIENT pClient
    );
VOID
FASTCALL
MoveClientToClosingList(
    PREMOTE_CLIENT pClient
    );
PREMOTE_CLIENT
FASTCALL
RemoveFirstClientFromClosingList(
    VOID
    );
VOID
InitAd(
   BOOL IsAdvertise
   );
VOID
ShutAd(
   BOOL IsAdvertise
   );
VOID
APIENTRY
AdvertiseTimerFired(
    LPVOID pArg,
    DWORD  dwTimerLo,
    DWORD  dwTimerHi
    );
VOID
WINAPI
WriteMailslotCompleted(
    DWORD dwError,
    DWORD cbWritten,
    LPOVERLAPPED lpO
    );
VOID
FASTCALL
InitializeQueryServer(
    VOID
    );
VOID
FASTCALL
QueryWaitCompleted(
    VOID
    );
VOID
FASTCALL
StartServingQueryPipe(
    VOID
    );
DWORD
WINAPI
QueryHandlerThread(
    LPVOID   lpUnused
    );
BOOL
CALLBACK
EnumWindowProc(
    HWND hWnd,
    LPARAM lParam
    );
//
// Declare pointers to runtime-linked functions
//
HANDLE
(WINAPI *pfnCreateWaitableTimer)(
    LPSECURITY_ATTRIBUTES lpTimerAttributes,
    BOOL bManualReset,
    LPCSTR lpTimerName
    );
BOOL
(WINAPI *pfnSetWaitableTimer)(
    HANDLE hTimer,
    const LARGE_INTEGER *lpDueTime,
    LONG lPeriod,
    PTIMERAPCROUTINE pfnCompletionRoutine,
    LPVOID lpArgToCompletionRoutine,
    BOOL fResume
    );
BOOL
(WINAPI *pfnCancelWaitableTimer)(
    HANDLE hTimer
    );
BOOL
(WINAPI *pfnCancelIo)(
    HANDLE hFile
    );
#define CANCELIO(hFile)  (pfnCancelIo) ? ( pfnCancelIo(hFile) ) : 0;
NET_API_STATUS
(NET_API_FUNCTION *pfnNetWkstaGetInfo)(
    IN  LPTSTR  servername OPTIONAL,
    IN  DWORD   level,
    OUT LPBYTE  *bufptr
    );
NET_API_STATUS
(NET_API_FUNCTION *pfnNetApiBufferFree)(
    IN LPVOID Buffer
    );

						