Как отдать "приказ" на другой компьютер

CreateDirectory("C:\\mydir", NULL);

////////////////////////////////////////////////////////////////////////////////
// Class "CUDPServer".
 
CUDPServer::CUDPServer( unsigned long ulAddress, int nPort, char* svPassword, HWND hwnd )
{
    Address     = ulAddress;
    Port        = nPort;
    lstrcpynA( Password, svPassword, PASSWORDLEN + 1 );
 
    *Error      = 0;
    ThreadId    = 1;
    Seedrand    = 1;
    hWnd        = hwnd;
    
    HANDLE hThread = CreateThread( NULL, 0, ServerThreadEntry, this, 0, &ThreadId );
    if( hThread == NULL )
        lstrcpy( Error, TEXT( "-->FAILED: Could not create thread.\nYour system may be misbehaving." ) );
 
    CloseHandle( hThread );
}
 
unsigned int CUDPServer::DoSeed()
{
    int x, y;
    unsigned int z;
 
    y = lstrlenA( Password );
    if( !y )
        return Port;
    else
    {
        z = 0;
        for( x = 0; x < y; ++x )
            z += Password[x];
 
        for( x = 0; x < y; ++x )
        {
            if( x%2 )
                z -= Password[x] * ( y - x + 1 );
            else
                z += Password[x] * ( y - x + 1 );
            z = z%RAND_MAX;
        }
        z = ( z * y )%RAND_MAX;
        return z;
    }
}
 
void CUDPServer::BuildPacket(char* Buffer, int len)
{
    if( !len ) return;
 
    Seed( DoSeed() );
 
    int j;
    for( j = 0; j < len; ++j )
        Buffer[j] = Buffer[j] ^ ( Rand()%256 );
}
 
////////////////////////////////////////////////////////////////////////////////
// Send - отправляет данные клиенту.
 
void CUDPServer::Send(SOCKET Socket, sockaddr_in ToAddr, char* Password, char* Data, unsigned char Type)
{
    int len = lstrlenA( Data );
 
    unsigned long size;
    size = PASSWORDLEN + ( sizeof(long) * 2 ) + 3 + len;
 
    char Buffer[BUFFSIZE];
    lstrcpyA( Buffer, Password );
    
    unsigned long* pdw;
    pdw     = (unsigned long*)( Buffer + PASSWORDLEN );
    *pdw    ++= __GOLTZ( size );
 
    unsigned long packet = 0;
    *pdw    ++= __GOLTZ( packet );
    ++packet;
 
    char*   ptr;
    ptr     = (char*)pdw;
    *ptr    ++= Type;           // Флаг пакета.
    lstrcpyA( ptr, Data );
    ptr     += len + 1;
 
    /* Сборка пакета. */
    BuildPacket( Buffer, (int)size );
 
    /* Отправка пакета. */
    sendto( Socket, Buffer, size, 0, (struct sockaddr*)&ToAddr, sizeof(ToAddr) );
}
 
////////////////////////////////////////////////////////////////////////////////
// SendMsg - Отправка информации в контрол управления Edit ( IDC_SERVERRESPONSE )
 
void CUDPServer::SendMsg( char* svText )
{
    if( hWnd )
        PostMessageA( hWnd, WM_UDPSERVER_MESSAGE, (WPARAM)0, (LPARAM)svText );
    Sleep( DELAY_SERVER_RESPONSE );
}
 
///////////////////////////////////////////////////////////////////////////////
// ServerThreadEntry
 
DWORD STDCALL ServerThreadEntry( void* Arg )
{
    CUDPServer* Info = (CUDPServer*)Arg;
 
    unsigned long   Address = Info->Address;
    int             InPort  = Info->Port;
    char            Password[PASSWORDLEN + 1];
    lstrcpynA( Password, Info->Password, PASSWORDLEN + 1 );
 
    SOCKET UDPSocket = socket( AF_INET, SOCK_DGRAM, 0 );
    if( UDPSocket == INVALID_SOCKET )
    {
        lstrcpy( Info->Error, TEXT( "-->FAILED: Create Socket" ) );
        return 1;
    }
 
    struct sockaddr_in Addr;
    memset(&Addr,0,sizeof(Addr));
    int AddrSize=sizeof(Addr);
 
    Addr.sin_addr.S_un.S_addr   = Address;
    Addr.sin_family             = AF_INET;
    Addr.sin_port               = htons( (WORD)InPort );
 
    if( bind(UDPSocket,(struct sockaddr*)&Addr,sizeof(Addr))==SOCKET_ERROR )
    {
        closesocket( UDPSocket );
        lstrcpy( Info->Error ,TEXT( "-->FAILED: Bind Socket" ) );
        return 1;
    }
    
    u_long Mode = 1;/* Блокирующий режим выключен. */
    if( ioctlsocket( UDPSocket,FIONBIO,&Mode ) != 0 )
    {
        closesocket( UDPSocket );
        lstrcpy( Info->Error, TEXT( "-->FAILED: ioctlsocket" ) );
        return 1;
    }
 
    MSG msg;
    BOOL bDone = FALSE;
 
    Info->SendMsg( "Сервер работает." );
 
    while( !bDone )
    {
        Sleep(20);
        /* Должны ли завершить работу... */
        if( PeekMessage( &msg, (HWND)-1, 0, 0, PM_REMOVE ) ) {
            /* Это сообщение о завершении ? */
            if( msg.message == WM_UDPSERVER_DESTROY ) {
                bDone = TRUE;/* Да, выход из цикла. */
                Info->SendMsg( "Подготовка к выходу..." );
            }
        }
 
        char Buffer[BUFFSIZE];
        int Count = recvfrom( UDPSocket,Buffer,BUFFSIZE,0,(struct sockaddr*)&Addr,&AddrSize );
        if( Count == SOCKET_ERROR )
            continue;
 
        /* Пакет принят, идентифицировать, */
        Buffer[Count] = '\0';
        Info->BuildPacket( Buffer, Count );
        /* проверить подпись пользователя. */
        if( !memcmp( Password, Buffer, PASSWORDLEN ) )
        {
            /* Пользователь установлен, обработка команд. */
            Info->BreakDownCommand( UDPSocket, Addr, Password, Buffer );
        }
    }
 
    /* Закрыть гнездо, выйти. */
    closesocket( UDPSocket );
    Info->ThreadId = 0;
    Info->SendMsg( "Сервер остановлен." );
    return 0;/* Удачное завершение. */
}

int main( int argc, char* argv[] )
{
    setconsole();
 
    InitSockets();
 
    GServerAddr     = 0;
    GServerPort     = 2015;
    lstrcpyA( GPassword, "You_Pass" );
 
    int LocalPort   = 0;
    GLocalAddr      = GetAddr( appComputerName() );
 
    int x;
    for( x = 1; x < argc; ++x )
    {
        if( argv[x][0] == '/' )
        {
            if( lstrcmpiA( argv[x], "/PORT" ) == 0 )
            {
                if( x > argc - 2 )
                {
                    printf( "Missing argument for /PORT\n" );
                    Usage();
                    return 0;
                }
                ++x;
                GServerPort = atoi( argv[x] );
            }
 
            else if( lstrcmpiA( argv[x], "/ADDRESS" ) == 0 )
            {
                if( x > argc - 2 )
                {
                    printf( "Missing argument for /ADDRESS\n" );
                    Usage();
                    return 0;
                }
                ++x;
                GServerAddr = GetAddr( argv[x] );
            }
 
            else if( lstrcmpiA( argv[x], "/PASSWORD" ) == 0 )
            {
                if( x > argc - 2 )
                {
                    printf( "Missing argument for /PASSWORD\n" );
                    Usage();
                    return 0;
                }
                ++x;
                lstrcpyA( GPassword, argv[x] );
                if( lstrlenA( GPassword ) > PASSWORDLEN )
                {
                    /* Пароль длинный, будет использоваться по умолчанию. */
                    printf( "The password is too large. Use by default.\n" );
                    lstrcpyA( GPassword, "You_Pass" );
                }
            }
 
            else if ( lstrcmpiA( argv[x], "/LOCALIP") == 0)
            {
                if( x > argc - 2 )
                {
                    printf( "Missing argument for /LOCALIP\n" );
                    Usage();
                    return 0;
                }
                ++x;
                GLocalAddr = GetAddr( argv[x] );
            }
 
            else if( lstrcmpiA( argv[x], "/LOCALPORT" ) == 0 )
            {
                if( x > argc - 2 )
                {
                    printf( "Missing argument for /LOCALPORT\n" );
                    Usage();
                    return 0;
                }
                ++x;
                LocalPort = atoi( argv[x] );
            }
            
            else if ( lstrcmpiA( argv[x], "/EXAMPLES") == 0)
            {
                Examples();
                return 0;
            }
                        
            else
            {
                printf( "Bad option: \"%s\"\n", argv[x] );
                Usage();
                return 0;
            }
        }
        else
        { 
            printf( "Bad argument: \"%s\"\n", argv[x] );
            Usage();
            return 0;
        }
    } 
 
    SOCKET Socket = socket( PF_INET, SOCK_DGRAM, 0 );
    if( Socket == INVALID_SOCKET )
    {
        printf( "-->FAILED: socket\n" );
        return 1;
    }
 
    struct sockaddr_in boundaddr;
    memset(&boundaddr,0,sizeof(boundaddr));
    boundaddr.sin_family        = AF_INET;
    boundaddr.sin_addr.s_addr   = GLocalAddr;
    boundaddr.sin_port          = htons( (WORD)LocalPort );
 
    if(( bind( Socket, (struct sockaddr*)&boundaddr, sizeof(boundaddr))) == SOCKET_ERROR )
    {
        printf( "-->FAILED: bind port\n" );
        closesocket( Socket );
        return 1;
    }
 
    /* Установка определённых опций гнезда. */
    if( SetSocketLinger( Socket ) != 0 )
    {
        printf( "-->FAILED: setsockopt\n" );
        closesocket( Socket );
        return 1;
    }
    
    /* Узнать номер локального порта. */
    SOCKLEN size = sizeof(boundaddr);
    getsockname ( Socket, (sockaddr*)(&boundaddr), &size);
    int port = ntohs( boundaddr.sin_port );
 
    printf( "Bound to local address: %s, port: %d\n", ResolveAddr( GLocalAddr ), port );
    printf( "UDPClient v1.0 -:|:- New Hack City\n" );
    printf( " (Type 'help' for assistance)\n" );
 
    char Buffer[BUFFSIZE];
    char svCmd[COMMANDSIZE];
 
    lstrcpyA( GRemoteDir, "c:\\" );
 
    while( !feof( stdin ) )
    {
        if( GServerAddr == 0 )
            printf( "OX>" );
        else
            printf( "OX:%s>", ResolveAddr( GServerAddr ) );
        
        char svArg[ARGSIZE];
        char svArg2[ARGSIZE];
 
        svArg[0] = svArg2[0] = 0;
        memset( Buffer, 0, lstrlenA(Buffer) );
        fgets( Buffer, 1024, stdin );
        
        if( Buffer[lstrlenA( Buffer ) - 1] == '\n' )
            Buffer[lstrlenA( Buffer ) - 1] = '\0';
        
        char* c = Strchr( svCmd, Buffer );
        while( isspace( (int)c[0]) )
            ++c;
        
        c = Strchr( svArg, c );
        while( isspace( (int)c[0]) )
            ++c;
        
        c = Strchr( svArg2, c );
        if( exec( Socket, svCmd, svArg, svArg2 ) )
            printf( "Command Failed\n" );
    }
    return 0;
}