windows-nt/Source/XPSP1/NT/base/remoteboot/rcc/net/client/rccclnt.c

/****************************************************************************

   Copyright (c) Microsoft Corporation 1997
   All rights reserved
 
 ***************************************************************************/

#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
#include <winsock2.h>
#include <rccxport.h>


//
// Main entry routine
//
DWORD
RCCClntInitDll(
    HINSTANCE hInst,
    DWORD Reason,
    PVOID Context
    )

/*++

Routine Description:

    This routine simply returns TRUE.  Normally it would initialize all global information, but we have none.

Arguments:

    hInst - Instance that is calling us.

    Reason - Why we are being invoked.

    Context - Context passed for this init.

Return Value:

    TRUE if successful, else FALSE

--*/

{
    return(TRUE);
}




DWORD
RCCClntCreateInstance(
    OUT HANDLE *phHandle
    )

/*++

Routine Description:

    This routine creates a RCC_CLIENT instance, and returns a handle (pointer) to it.

Arguments:

    phHandle - A pointer to storage for storing a pointer to internal representation of a remote
        command port client.

Return Value:

    ERROR_SUCCESS if successful, else an appropriate error code.

--*/

{
    WORD Version;
    DWORD Error;
    WSADATA WSAData;
    PRCC_CLIENT Client;

    //
    // See if we can start up WinSock
    //
    Version = WINSOCK_VERSION;

    Error = WSAStartup(Version, &WSAData);

    if (Error != 0) {
        return WSAGetLastError();
    }

    if ((HIBYTE(WSAData.wVersion) != 2) || 
        (LOBYTE(WSAData.wVersion) != 2)) {
        WSACleanup();
        return ERROR_RMODE_APP;
    }

    //
    // Now get space for our internal data
    //
    Client =  LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, sizeof(RCC_CLIENT));

    if (Client == NULL) {
        WSACleanup();
        return ERROR_OUTOFMEMORY;
    } 

    //
    // Init the data structure
    //
    Client->CommandSequenceNumber = 0;
    Client->MySocket = INVALID_SOCKET;
    Client->RemoteSocket = INVALID_SOCKET;

    *phHandle = (HANDLE)Client;

    return ERROR_SUCCESS;
}


VOID
RCCClntDestroyInstance(
    OUT HANDLE *phHandle
    )

/*++

Routine Description:

    This routine destroys a RCC_CLIENT instance, and NULLs the handle.

Arguments:

    phHandle - A pointer to previously created remote command port instance.

Return Value:

    None.

--*/

{
    PRCC_CLIENT Client = *((PRCC_CLIENT *)phHandle);


    if (Client == NULL) {
        return;
    }

    if (Client->MySocket != INVALID_SOCKET) {
        shutdown(Client->MySocket, SD_BOTH);
        closesocket(Client->MySocket);
    }
    
    if (Client->RemoteSocket != INVALID_SOCKET) {
        shutdown(Client->RemoteSocket, SD_BOTH);
        closesocket(Client->RemoteSocket);
    }

    LocalFree(Client);

    *phHandle = NULL;
}


DWORD
RCCClntConnectToRCCPort(
    IN HANDLE hHandle,
    IN PSTR MachineName
    )

/*++

Routine Description:

    This routine takes a previously created instance, and attempts to make a connection from it to 
    a remote command port on the given machine name.

Arguments:

    hHandle - A handle to a previously created instance.
    
    MachineName - An ASCII string of the machine to attempt to connect to.

Return Value:

    ERROR_SUCCESS if successful, else an appropriate error code.

--*/

{
    char InAddr[4];
    DWORD Error;
    struct sockaddr_in SockAddrIn;
    struct  hostent *HostAddr;
    PRCC_CLIENT Client = (PRCC_CLIENT)hHandle;

    //
    // Check handle
    //
    if (Client == NULL) {
        return ERROR_INVALID_HANDLE;
    }

    HostAddr = gethostbyname(MachineName);

    if (HostAddr == NULL) {
        return WSAGetLastError();
    }

    if (HostAddr->h_addrtype != AF_INET) {
        return WSAGetLastError();
    }

    if (Client->RemoteSocket != INVALID_SOCKET) {
        shutdown(Client->RemoteSocket, SD_BOTH);
        closesocket(Client->RemoteSocket);
        Client->RemoteSocket = INVALID_SOCKET;
    }

    //
    // Make a socket descriptor
    //
    Client->MySocket = socket(PF_INET, SOCK_STREAM, 0);

    if (Client->MySocket == INVALID_SOCKET) {
        return WSAGetLastError();
    }

    //
    // Build the sockaddr_in structure
    //
    memset(&(SockAddrIn), 0, sizeof(SockAddrIn));
    SockAddrIn.sin_family = AF_INET;    

    //
    // Fill in the socket structure
    //
    Error = bind(Client->MySocket, (struct sockaddr *)(&SockAddrIn), sizeof(struct sockaddr_in));

    if (Error != 0) {
        closesocket(Client->MySocket);
        return WSAGetLastError();
    }
    
    //
    // Make a socket descriptor for connecting to client
    //
    Client->RemoteSocket = socket(PF_INET, SOCK_STREAM, 0);

    if (Client->RemoteSocket == INVALID_SOCKET) {
        closesocket(Client->MySocket);
        return WSAGetLastError();
    }

    //
    // Build the sockaddr_in structure for the remote site.
    //
    memset(&(SockAddrIn), 0, sizeof(SockAddrIn));
    memcpy(&(SockAddrIn.sin_addr), HostAddr->h_addr_list[0], HostAddr->h_length);
    SockAddrIn.sin_family = AF_INET;    
    SockAddrIn.sin_port = htons(385);

    //
    // Connect to the remote site
    //
    Error = connect(Client->RemoteSocket, (struct sockaddr *)(&SockAddrIn), sizeof(struct sockaddr_in));

    if (Error != 0) {
        closesocket(Client->MySocket);
        closesocket(Client->RemoteSocket);
        Client->RemoteSocket = INVALID_SOCKET;
        return WSAGetLastError();
    }

    return ERROR_SUCCESS;
}


DWORD
GetResponse(
    IN PRCC_CLIENT Client,
    IN ULONG CommandCode,
    IN PUCHAR Buffer,
    IN ULONG BufferSize
    )

/*++

Routine Description:

    This routine reads from a socket until either (a) a full response is received for the command given,
    (b) a timeout occurs, or (c) too much data arrives (it is tossed out).

Arguments:

    Client - A remote command port client instance.
    
    CommandCode - The command code response to wait for.
    
    Buffer - Storage for the response.
    
    BufferSize - Size of Buffer in bytes.

Return Value:

    ERROR_SUCCESS if successful, else an appropriate error code.

--*/

{ 
    fd_set FdSet;
    struct timeval Timeout;
    int Count;
    DWORD Bytes;
    DWORD Error;
    ULONG TotalBytes;
    PRCC_RESPONSE Response;
    BOOLEAN BufferTooSmall = FALSE;
    char *DataBuffer;
    
    FD_ZERO(&FdSet);
    FD_SET(Client->RemoteSocket, &FdSet);

    while (1) {
        
        Timeout.tv_usec = 0;
        Timeout.tv_sec = 30;

        Count = select(0, &FdSet, NULL, NULL, &Timeout);

        if (Count == 0) {
            return WAIT_TIMEOUT;
        }

        Bytes = recv(Client->RemoteSocket, (char *)Buffer, BufferSize, 0);

        if (Bytes == SOCKET_ERROR) {
            return GetLastError();
        }

        Response = (PRCC_RESPONSE)Buffer;

        TotalBytes = Bytes;

        if ((Response->DataLength + sizeof(RCC_RESPONSE) - 1) > BufferSize) {
            BufferTooSmall = TRUE;
        }

        //
        // Receive the entire response.
        //
        while (TotalBytes < (Response->DataLength + sizeof(RCC_RESPONSE) - 1)) {

            if (BufferTooSmall) {
                DataBuffer = (char *)(Buffer + sizeof(RCC_RESPONSE)); // preserve the response data structure for getting the needed size later.
            } else {
                DataBuffer = (char *)(Buffer + TotalBytes);
            }
            
            Count = select(0, &FdSet, NULL, NULL, &Timeout);

            if (Count == 0) {
                return WAIT_TIMEOUT;
            }

            Bytes = recv(Client->RemoteSocket, 
                         DataBuffer, 
                         (BufferTooSmall ? (BufferSize - sizeof(RCC_RESPONSE)) : (BufferSize - TotalBytes)), 
                         0
                        );

            if (Bytes == SOCKET_ERROR) {
                return GetLastError();
            }

            TotalBytes += Bytes;

        }

        if (TotalBytes > (Response->DataLength + sizeof(RCC_RESPONSE) - 1)) {

            //
            // Something is weird here - we got more data than we expected, skip this message.
            //
            ASSERT(0);
            continue;

        }

        //
        // Check that this is the response we were looking for
        //
        if ((Response->CommandSequenceNumber == Client->CommandSequenceNumber) &&
            (Response->CommandCode == CommandCode)) {
                break;
        }

    }

    if (BufferTooSmall) {
        return SEC_E_BUFFER_TOO_SMALL;
    }

    return ERROR_SUCCESS;
}


DWORD
RCCClntGetTList(
    IN HANDLE hHandle,
    IN ULONG BufferSize,
    OUT PRCC_RSP_TLIST Buffer,
    OUT PULONG ResponseSize
    )

/*++

Routine Description:

    This routine submits a "TLIST" command to a remote machine via the remote command port, and then waits
    for a response.

Arguments:

    hHandle - A previously created instance.
    
    BufferSize - Size of Buffer in bytes.
    
    Buffer - The buffer for holding the response.
    
    ResponseSize - The number of bytes in buffer that were filled.  If BufferSize is too small, then this
       will contain the number of bytes needed.

Return Value:

    ERROR_SUCCESS if successful, else an appropriate error code.

--*/

{
    DWORD Error;
    PRCC_CLIENT Client = (PRCC_CLIENT)hHandle;
    PRCC_REQUEST Request;
    PRCC_RESPONSE Response;

    //
    // Check handle
    //
    if (Client == NULL) {
        return ERROR_INVALID_HANDLE;
    }

    //
    // Build the request
    //
    Request = LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, sizeof(RCC_REQUEST));
    if (Request == NULL) {
        return ERROR_OUTOFMEMORY;
    }

    Request->CommandSequenceNumber = ++(Client->CommandSequenceNumber);
    Request->CommandCode = RCC_CMD_TLIST;
    Request->OptionLength = 0;
    Request->Options[0] = '\0';

    //
    // Send the request.
    //
    Error = send(Client->RemoteSocket, (char *)Request, sizeof(RCC_REQUEST) - 1 + Request->OptionLength, 0);

    if (Error == SOCKET_ERROR) {
        LocalFree(Request);
        return GetLastError();
    }

    //
    // Get the response.
    //
    Error = GetResponse(Client, RCC_CMD_TLIST, (PUCHAR)Buffer, BufferSize);
    
    Response = (PRCC_RESPONSE)Buffer;

    if (Error != ERROR_SUCCESS) {

        if (ERROR == SEC_E_BUFFER_TOO_SMALL) {
            *ResponseSize = Response->DataLength;
        }
        LocalFree(Request);
        return Error;
    }

    //
    // Extract the data
    //
    Error = Response->Error;
    *ResponseSize = Response->DataLength;
    RtlCopyMemory(Buffer, &(Response->Data[0]), Response->DataLength);

    LocalFree(Request);

    //
    // Return the status.
    //
    return Error;
}


DWORD
RCCClntKillProcess(
    IN HANDLE hHandle,
    IN DWORD ProcessId
    )

/*++

Routine Description:

    This routine submits a "KILL" command to a remote machine via the remote command port, and then waits
    for a response.

Arguments:

    hHandle - A previously created instance.
    
    ProcessId - The process id on the remote machine to kill.
    
Return Value:

    ERROR_SUCCESS if successful, else an appropriate error code.

--*/

{
    DWORD Error;
    PRCC_CLIENT Client = (PRCC_CLIENT)hHandle;
    PRCC_REQUEST Request;
    RCC_RESPONSE Response;

    //
    // Check handle
    //
    if (Client == NULL) {
        return ERROR_INVALID_HANDLE;
    }

    //
    // Build the request
    //
    Request = LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, sizeof(RCC_REQUEST));
    if (Request == NULL) {
        return ERROR_OUTOFMEMORY;
    }

    Request->CommandSequenceNumber = ++(Client->CommandSequenceNumber);
    Request->CommandCode = RCC_CMD_KILL;
    Request->OptionLength = sizeof(DWORD);
    RtlCopyMemory(&(Request->Options[0]), &ProcessId, sizeof(DWORD));

    //
    // Send the request.
    //
    Error = send(Client->RemoteSocket, (char *)Request, sizeof(RCC_REQUEST) - 1 + Request->OptionLength, 0);

    if (Error == SOCKET_ERROR) {
        LocalFree(Request);
        return GetLastError();
    }

    //
    // Get the response.
    //
    Error = GetResponse(Client, RCC_CMD_KILL, (PUCHAR)&Response, sizeof(Response));
    
    if (Error != ERROR_SUCCESS) {
        LocalFree(Request);
        return Error;
    }

    //
    // Extract the result
    //
    Error = Response.Error;
    LocalFree(Request);

    //
    // Return the status.
    //
    return Error;
}


DWORD
RCCClntReboot(
    IN HANDLE hHandle
    )

/*++

Routine Description:

    This routine submits a "REBOOT" command to a remote machine via the remote command port, and then waits
    for a response.

Arguments:

    hHandle - A previously created instance.
    
    ProcessId - The process id on the remote machine to kill.
    
Return Value:

    ERROR_SUCCESS if successful, else an appropriate error code.

--*/

{
    DWORD Error;
    PRCC_CLIENT Client = (PRCC_CLIENT)hHandle;
    PRCC_REQUEST Request;
    RCC_RESPONSE Response;

    //
    // Check handle
    //
    if (Client == NULL) {
        return ERROR_INVALID_HANDLE;
    }

    //
    // Build the request
    //
    Request = LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, sizeof(RCC_REQUEST));
    if (Request == NULL) {
        return ERROR_OUTOFMEMORY;
    }

    Request->CommandSequenceNumber = ++(Client->CommandSequenceNumber);
    Request->CommandCode = RCC_CMD_REBOOT;
    Request->OptionLength = 0;

    //
    // Send the request.
    //
    Error = send(Client->RemoteSocket, (char *)Request, sizeof(RCC_REQUEST) - 1 + Request->OptionLength, 0);

    if (Error == SOCKET_ERROR) {
        LocalFree(Request);
        return GetLastError();
    }

    //
    // Get the response.
    //
    Error = GetResponse(Client, RCC_CMD_REBOOT, (PUCHAR)&Response, sizeof(Response));
    
    if (Error != ERROR_SUCCESS) {
        LocalFree(Request);
        return Error;
    }

    //
    // Extract the result
    //
    Error = Response.Error;
    LocalFree(Request);

    //
    // Close the connection if there was no error
    //
    if (Error == ERROR_SUCCESS) {
        shutdown(Client->RemoteSocket, SD_BOTH);
        closesocket(Client->RemoteSocket);
        Client->RemoteSocket = INVALID_SOCKET;
    }

    //
    // Return the status.
    //
    return Error;
}


DWORD
RCCClntLowerProcessPriority(
    IN HANDLE hHandle,
    IN DWORD ProcessId
    )

/*++

Routine Description:

    This routine submits a "LOWER" command to a remote machine via the remote command port, and then waits
    for a response.

Arguments:

    hHandle - A previously created instance.
    
    ProcessId - The process id on the remote machine to reduce the priority of.
    
Return Value:

    ERROR_SUCCESS if successful, else an appropriate error code.

--*/

{
    DWORD Error;
    PRCC_CLIENT Client = (PRCC_CLIENT)hHandle;
    PRCC_REQUEST Request;
    RCC_RESPONSE Response;

    //
    // Check handle
    //
    if (Client == NULL) {
        return ERROR_INVALID_HANDLE;
    }

    //
    // Build the request
    //
    Request = LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, sizeof(RCC_REQUEST));
    if (Request == NULL) {
        return ERROR_OUTOFMEMORY;
    }

    Request->CommandSequenceNumber = ++(Client->CommandSequenceNumber);
    Request->CommandCode = RCC_CMD_LOWER;
    Request->OptionLength = sizeof(DWORD);
    RtlCopyMemory(&(Request->Options[0]), &ProcessId, sizeof(DWORD));

    //
    // Send the request.
    //
    Error = send(Client->RemoteSocket, (char *)Request, sizeof(RCC_REQUEST) - 1 + Request->OptionLength, 0);

    if (Error == SOCKET_ERROR) {
        LocalFree(Request);
        return GetLastError();
    }

    //
    // Get the response.
    //
    Error = GetResponse(Client, RCC_CMD_LOWER, (PUCHAR)&Response, sizeof(Response));
    
    if (Error != ERROR_SUCCESS) {
        LocalFree(Request);
        return Error;
    }

    //
    // Extract the result
    //
    Error = Response.Error;
    LocalFree(Request);

    //
    // Return the status.
    //
    return Error;
}


DWORD
RCCClntLimitProcessMemory(
    IN HANDLE hHandle,
    IN DWORD ProcessId,
    IN DWORD MemoryLimit
    )

/*++

Routine Description:

    This routine submits a "LIMIT" command to a remote machine via the remote command port, and then waits
    for a response.

Arguments:

    hHandle - A previously created instance.
    
    ProcessId - The process id on the remote machine to limit the memory of.
    
    MemoryLimit - Number of MB to set the limit to.
    
Return Value:

    ERROR_SUCCESS if successful, else an appropriate error code.

--*/

{
    DWORD Error;
    PRCC_CLIENT Client = (PRCC_CLIENT)hHandle;
    PRCC_REQUEST Request;
    RCC_RESPONSE Response;

    //
    // Check handle
    //
    if (Client == NULL) {
        return ERROR_INVALID_HANDLE;
    }

    //
    // Build the request
    //
    Request = LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, sizeof(RCC_REQUEST) + sizeof(DWORD));
    if (Request == NULL) {
        return ERROR_OUTOFMEMORY;
    }

    Request->CommandSequenceNumber = ++(Client->CommandSequenceNumber);
    Request->CommandCode = RCC_CMD_LIMIT;
    Request->OptionLength = 2 * sizeof(DWORD);
    RtlCopyMemory(&(Request->Options[0]), &ProcessId, sizeof(DWORD));
    RtlCopyMemory(&(Request->Options[sizeof(DWORD)]), &MemoryLimit, sizeof(DWORD));

    //
    // Send the request.
    //
    Error = send(Client->RemoteSocket, (char *)Request, sizeof(RCC_REQUEST) - 1 + Request->OptionLength, 0);

    if (Error == SOCKET_ERROR) {
        LocalFree(Request);
        return GetLastError();
    }

    //
    // Get the response.
    //
    Error = GetResponse(Client, RCC_CMD_LIMIT, (PUCHAR)&Response, sizeof(Response));
    
    if (Error != ERROR_SUCCESS) {
        LocalFree(Request);
        return Error;
    }

    //
    // Extract the result
    //
    Error = Response.Error;
    LocalFree(Request);

    //
    // Return the status.
    //
    return Error;
}


DWORD
RCCClntCrashDump(
    IN HANDLE hHandle
    )

/*++

Routine Description:

    This routine submits a "CRASHDUMP" command to a remote machine via the remote command port,
    and then waits for a response.

Arguments:

    hHandle - A previously created instance.
    
Return Value:

    ERROR_SUCCESS if successful, else an appropriate error code.

--*/

{
    DWORD Error;
    PRCC_CLIENT Client = (PRCC_CLIENT)hHandle;
    PRCC_REQUEST Request;
    RCC_RESPONSE Response;

    //
    // Check handle
    //
    if (Client == NULL) {
        return ERROR_INVALID_HANDLE;
    }

    //
    // Build the request
    //
    Request = LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, sizeof(RCC_REQUEST) + sizeof(DWORD));
    if (Request == NULL) {
        return ERROR_OUTOFMEMORY;
    }

    Request->CommandSequenceNumber = ++(Client->CommandSequenceNumber);
    Request->CommandCode = RCC_CMD_CRASHDUMP;
    Request->OptionLength = 0;

    //
    // Send the request.
    //
    Error = send(Client->RemoteSocket, (char *)Request, sizeof(RCC_REQUEST) - 1 + Request->OptionLength, 0);

    if (Error == SOCKET_ERROR) {
        LocalFree(Request);
        return GetLastError();
    }

    //
    // Get the response.
    //
    Error = GetResponse(Client, RCC_CMD_LIMIT, (PUCHAR)&Response, sizeof(Response));
    
    if (Error != ERROR_SUCCESS) {
        LocalFree(Request);
        return Error;
    }

    //
    // Extract the result
    //
    Error = Response.Error;
    LocalFree(Request);

    //
    // Return the status.
    //
    return Error;
}