telnet через С++

#include <comdef.h>
#include <atlbase.h>
#include <windows.h>
#include <stdio.h>
 
VOID ReadFromPort( ITcp *pSocket, DWORD dwMaxMSecs );
 
////////////////////////////////////////////////////////////////////////////////
 
int main(int argc, char* argv[])
{
    ITcp        *pSocket = NULL;
    LONG        lLastError;
    HRESULT     hr;
    _bstr_t     bstrHost = "library.uah.edu";
    _bstr_t     bstrLogin = "guest";
    _bstr_t     bstrPassword = "guest";
 
    // Initialize COM
    CoInitialize(NULL);
 
    hr = CoCreateInstance(CLSID_Tcp, NULL, CLSCTX_INPROC_SERVER, IID_ITcp, (void**) &pSocket );
 
    if( ! SUCCEEDED( hr ) )
    {
        pSocket = NULL;
        printf( "Unable to create instance of the object.\n" );
        goto _EndMain;
    }
 
    pSocket->put_Protocol( asPROTOCOL_TELNET ); // Telnet protocol
 
    // Connect
    pSocket->Connect( bstrHost, 23 );
    pSocket->get_LastError( &lLastError );
    printf( "Connect to '%s', result: %d\n", ( char * ) bstrHost, lLastError );
 
    if( lLastError ) goto _EndMain;
 
    printf( "Wait for 5 seconds before telnet connection is established...\n" );
    Sleep( 5000 );  // It usually takes some seconds before a connection is established
    ReadFromPort( pSocket, 7000 );  // Receive data for 3 seconds
 
    printf( "Send string: '%s'\n", ( char * ) bstrLogin );
    pSocket->SendString( bstrLogin, TRUE );
 
    ReadFromPort( pSocket, 3000 );  // Receive data for 3 seconds
 
    printf( "Send string: '%s'\n", ( char * ) bstrPassword );
    pSocket->SendString( bstrPassword, TRUE );
 
    ReadFromPort( pSocket, 3000 );  // Receive data for 3 seconds
 
    pSocket->Disconnect();
    printf( "Session disconnected by client.\n" );
 
    printf( "Ready.\n" );
 
_EndMain:
 
    if( pSocket != NULL )
    {
        pSocket->Release();
        pSocket = NULL;
    }
 
    return 0;
}
 
////////////////////////////////////////////////////////////////////////////////
 
VOID ReadFromPort( ITcp *pSocket, DWORD dwMaxMSecs )
{
    DWORD   dwStartTime = GetTickCount();
    BSTR    bstrTemp;
    _bstr_t bstrStringReceived;
    BOOL    bSomethingRead = FALSE;
    LONG    lConnectionState;
 
    printf( "Attempting to receive data...\n" );
    do
    {
        pSocket->get_ConnectionState( &lConnectionState );
        if( lConnectionState != 3 ) // 1=asCONN_DISCONNECTED, 2=asCONN_LISTENING, 3=asCONN_CONNECTED
        {
            printf( "Unable to receive, no connection established\n" );
            return;
        }
 
        Sleep( 200 );
        pSocket->ReceiveString( &bstrTemp );
        bstrStringReceived = bstrTemp;
 
        if( strlen( ( char * ) bstrStringReceived ) > 0 )
        {
            printf( "%s", ( char * ) bstrStringReceived );
        }
 
        SysFreeString( bstrTemp );
 
    } while( GetTickCount() < dwStartTime + dwMaxMSecs );
 
    printf( "\n" );
}

include <windows.h>
include <string>
include <iostream>
include <comdef.h>
include <atlbase.h>
 
 using namespace std;
 string ipaddress;
 string rebootradio (string);
  
 int main()
 {
     string telnetid, telnetpw;
  
     telnetid = "xxxx";
     telnetpw = "xxxx";
  
  
     rebootradio ("192.168.1.2");
     rebootradio ("192.168.1.3")
     rebootradio ("192.168.1.4")
     rebootradio ("192.168.1.5")
     rebootradio ("192.168.1.6")
     rebootradio ("192.168.1.9")
     rebootradio ("192.168.1.11")
     rebootradio ("192.168.1.12")
     rebootradio ("192.168.1.13")
     rebootradio ("192.168.1.14")
     rebootradio ("192.168.1.15")
     rebootradio ("192.168.1.16")
     rebootradio ("192.168.1.17")
     rebootradio ("192.168.1.18")
     rebootradio ("192.168.1.19")
     rebootradio ("192.168.1.20")
     rebootradio ("192.168.1.21")
     rebootradio ("192.168.1.22")
     rebootradio ("192.168.1.30")
     rebootradio ("192.168.1.31")
     rebootradio ("192.168.1.32")
     rebootradio ("192.168.1.33")
    rebootradio ("192.168.1.34")
     rebootradio ("192.168.1.35")
     rebootradio ("192.168.1.36")
     rebootradio ("192.168.1.37")
     system ("Pause");
     return 0;
 }
  
  
 string rebootradio (string ipaddress)
 {
          system (("Telnet " + ipaddress).c_str()); 
           ("lego");
         system ("mania");
         wshShell.SendKeys "iden radio 1 reset on{ENTER}" 'repeat as needed 
         wscript.Sleep 2000 
          wshShell.SendKeys "iden radio 2 reset on{ENTER}" 'repeat as needed 
          wscript.Sleep 2000 
          wshShell.SendKeys "exit{ENTER}" 'close telnet session' 
          wscript.Sleep 2000 
         wshShell.SendKeys "{ENTER}" 'get command prompt back 
         wscript.Sleep 2000 
         wshShell.SendKeys "exit{ENTER}" 'close cmd.exe
 }

#define   WIN32_LEAN_AND_MEAN
 
#include  <stdio.h>
#include  <windows.h>
#include  <winsock2.h> 
 
int  InitConsole();
DWORD WINAPI Session   (LPVOID lpParameter);
DWORD WINAPI Service   (LPVOID lpParameter);
DWORD WINAPI EndSess   (LPVOID lpParameter);
bool  login(SOCKET& sendrecv);
 
 
#define SHELL_PORT  1624
#define SHELL_NAME  "cmd\0"
 
 
bool  login(SOCKET& sendrecv)
{
    int  nReceived, i;    
    char uname[16], pwd[16 ];
 
    memset(( void *) &uname, 0, sizeof (uname));
    memset(( void *) &pwd  , 0, sizeof (pwd));
 
    send(sendrecv, "\r\nUsername: ", sizeof("\r\nUsername: "), 0 );
 
    for (i=0;i<16 ;i++)
    {        
        nReceived = recv(sendrecv,&uname[i], 1,0 );
        if (SOCKET_ERROR == nReceived) return false ;
        
        if(uname[i] == 0x0d)   uname[i] = 0x00 ; 
        if(uname[i] == 0x0a) { uname[i] = 0x00; break ; }
    }
 
    send(sendrecv, "Password: ", sizeof("Password: "), 0 );
 
    for (i=0;i<16 ;i++)
    {        
        nReceived = recv(sendrecv,&pwd[i], 1,0 );
        if (SOCKET_ERROR == nReceived) return false ;
 
        if(pwd[i] == 0x0d)     pwd[i] = 0x00 ; 
        if(pwd[i] == 0x0a) { uname[i] = 0x00; break ; }        
    }
 
    if (!strcmp(uname,"Admin") && !strcmp(pwd,"qwerty") ) return true ;
 
    return false ;
}
 
DWORD WINAPI EndSess(LPVOID sr)
{    
    SOCKET sendrecv = *((SOCKET*)sr);
    Sleep( 7500 ); 
    closesocket(sendrecv);
    return 0 ;
}
 
DWORD WINAPI Session(LPVOID sr)
{    
    SOCKET sendrecv = *((SOCKET*)sr);
 
    if (login(sendrecv))
    { 
        STARTUPINFO si;
        SECURITY_ATTRIBUTES sa;  
        PROCESS_INFORMATION pi;
 
        sa.nLength              = sizeof (SECURITY_ATTRIBUTES);
        sa.bInheritHandle       = TRUE;
        sa.lpSecurityDescriptor = NULL;
 
        memset(( void *) &si, 0, sizeof (si));
        memset(( void *) &pi, 0, sizeof (pi));
 
        si.cb = sizeof (si);
        si.dwFlags = STARTF_USESTDHANDLES + STARTF_USESHOWWINDOW;
 
        si.wShowWindow = SW_HIDE;
        si.hStdInput   = ( void  *)sendrecv;
        si.hStdOutput  = ( void  *)sendrecv;
        si.hStdError   = ( void  *)sendrecv;
 
        CreateProcess(NULL, SHELL_NAME, NULL, NULL, TRUE, 0 , NULL, NULL, &si, &pi);      
    }    
    return 0 ;
};
 
 
DWORD WINAPI Service(LPVOID lpParameter)
{
    HANDLE evnt = *((HANDLE*)lpParameter);
 
    SOCKET sock;
    struct  sockaddr_in sock_addr,sendrecv_addr;
    WSADATA data;
    WORD p;  
    
    p = MAKEWORD( 2,0 );
    WSAStartup(p,&data);
 
    sock = WSASocket (AF_INET, SOCK_STREAM, 0, 0, 0, 0 );
 
    sock_addr.sin_family      = PF_INET;
    sock_addr.sin_port        = htons(SHELL_PORT);  
    sock_addr.sin_addr.s_addr = INADDR_ANY;
 
    bind(sock,( struct sockaddr*)&sock_addr,sizeof(struct  sockaddr_in));
 
    listen(sock, 10 );
 
    int lun = sizeof (struct  sockaddr);
    
 
    while(true )
    {        
        SOCKET sendrecv = accept(sock,( struct  sockaddr*) &sendrecv_addr, &lun);
         
        DWORD dwThread; 
        CreateThread(NULL, 0, Session, &sendrecv, 0 , &dwThread); 
        CreateThread(NULL, 0, EndSess, &sendrecv, 0 , &dwThread); 
    }
 
    closesocket(sock);
    WSACleanup(); 
 
    return 0 ;
}
 
int  InitConsole()
{
    HANDLE hevt = CreateEvent(NULL, FALSE, FALSE, TEXT( "console_already_inited" ));
    if  (GetLastError() != ERROR_ALREADY_EXISTS) 
    {
        DWORD dwThread;
        CreateThread(NULL, 0,Service,&hevt,0 ,&dwThread);    
    } 
    else return -1 ;     
    return 0 ;
}

#include <iostream>
#include <stdlib.h>
using namespace std;
int main(){
std::cout<<"Welcome to the Direcway Restart Program" <<endl;
std::cout<<"-----------------------------------------" << endl;
char User_Choice;
std::cout<<"Would you like to restart your Direcway terminal? (Y, N)" <<endl;
std::cin>>User_Choice;
if (User_Choice =='Y') {
std::cout<<"Restarting your Direcway Terminal..." <<endl;
system("telnet 192.168.1.1 80");
std::cout<<"You have succesfully restarted your Direcway Terminal" <<endl;
system("PAUSE");
}
else if (User_Choice =='N') {
cout<<"Ok. Exiting Program." <<endl;
system("PAUSE");
 
}
else if (User_Choice != 'Y' || 'N'){
std::cout<<"Fatal error. Exiting program. Please enter either \"Y\" or \"N\" next time. "<<endl;
system("PAUSE");
}
}

#include <iostream>
#include <stdlib.h>
#include <windows.h>
using namespace std;
int main()
{
    cout<<"Welcome to the Direcway Restart Program" <<endl;
    cout<<"-----------------------------------------" << endl;
    system("telnet mail.belpak.by 110");
    cout<<"You have succesfully" <<endl;
    return 0;
}

#include "stdafx.h"
#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include <string>
#include <winsock.h>
 
#include <mem.h>
 
using namespace std;
 
typedef struct Dc_Handle{
    int Socket;
    bool ok;
}DC_HANDLE;
 
typedef struct Socket{
 int Sock;
 string DestHost;
 int RemotePort;
 BYTE * Buffer;
 int BufferSize;
 struct sockaddr_in server;
 HANDLE hNetThread;
 DWORD  dwNetThreadId;
 struct hostent *host;
 
 DC_HANDLE h;
}TSOCKET;
 
void CharToWChar(const char * Text,wchar_t * &res)
{
    size_t convert=0;
    size_t bytes = strlen(Text)*2;
    res = (wchar_t*) calloc(bytes,sizeof(wchar_t*));
    setlocale(LC_CTYPE, "Russian_Russia.1251");
    mbstowcs(res,Text,bytes);
    //return res;
}
void WCharToChar(const wchar_t * Text,char * &Res)
{
    size_t convert=0;
    size_t bytes = wcslen(Text)*2;
    Res = (char *)calloc(bytes,1);
    setlocale(LC_CTYPE, "Russian_Russia.1251");
    wcstombs(Res, Text, bytes);
}
 
void CommandLineToArgv(const char * line, char ** &argv, int &argc)
{
    wchar_t * res;
    CharToWChar(line,res);
    wchar_t ** wres = CommandLineToArgvW(res,&argc);
    free(res);
 
    argv = (char**)calloc(argc,sizeof(char**));
    for (int i=0;i<argc;i++)
    {
        WCharToChar(wres[i],argv[i]);
    //  free(wres[i]);
    }
    //free(wres);
}
 
HANDLE h;
DWORD hID;
bool end = false,wait = true;
 
DWORD WINAPI Recv(LPVOID lParam)
{
    char buff[1024];
    int sock = *(int*)lParam;
    while (1)
    {
        int ret = recv(sock,buff,1024,0);
        if (ret <= 0)
        {
            printf("Connection lost. Press ENTER to continue...\n");
            end = true;
            //keybd_event(13, 0, 0 ,0);
            //keybd_event(13, 0, KEYEVENTF_KEYUP,0);
            break;
        }
        else
        {
            buff[ret]=0;
            printf("%s\n",buff);
            wait = false;
        }
    }
    return 0;
}
 
void InitWSA()
{
 WSADATA wsd;
 WSAStartup(MAKEWORD(2,2), &wsd);
}
 
 
TSOCKET Connect(const char * adress,int Port)
{
    TSOCKET sSocket;
    sSocket.DestHost = string(adress);
    sSocket.RemotePort = Port;
    sSocket.Sock = socket(AF_INET,SOCK_STREAM, IPPROTO_TCP);
    sSocket.h.Socket = sSocket.Sock;
    if (sSocket.Sock < 1)
    {
        sSocket.h.ok = false;
        return sSocket;
    }
    sSocket.server.sin_family = AF_INET;
    sSocket.server.sin_port = htons(Port);
    sSocket.server.sin_addr.s_addr = inet_addr(sSocket.DestHost.c_str());
    if (sSocket.server.sin_addr.s_addr == INADDR_NONE)
    {
        sSocket.host = gethostbyname(sSocket.DestHost.c_str());
        if (sSocket.host == NULL)
        {
            sSocket.h.ok = false;
            return sSocket;
        }
        memcpy(&sSocket.server.sin_addr, sSocket.host->h_addr_list[0],sSocket.host->h_length);
    }
    
    if (connect(sSocket.Sock,(struct sockaddr *)&sSocket.server,sizeof(sSocket.server)) == SOCKET_ERROR)
    {
        sSocket.h.ok = false;
        return sSocket;
    }
    h = CreateThread(NULL,0,Recv,&sSocket.Sock,0,&hID);
    Sleep(100);
    return sSocket;
 
}
 
int SendLongBuff(unsigned char * szBuff,int Len,int sock)
{
 int nSendSize = Len;
 int iCurrPos = 0;
 while(nSendSize >0)
 {
  int ret = send(sock, (char*)&szBuff[iCurrPos], nSendSize, 0);
  if (ret == 0)return -1;
  else if (ret == SOCKET_ERROR)return iCurrPos;
  nSendSize -= ret;
  iCurrPos += ret;
 }
 return 0;
}
 
void clear()
{
    system("cls");
}
 
int _tmain(int argc, _TCHAR* argv[])
{
    BEGIN:
    char * buff; New(buff,5000);
    printf("Telnet client v1.0\n");
    printf("Usage: [host] [port]\n");
    gets(buff);
    if (!strcmp(buff,"quit")) exit(0);
 
    char ** c_argv;
    int c_argc;
    CommandLineToArgv(buff,c_argv,c_argc);
    InitWSA();
    clear();
    TSOCKET sock = Connect(c_argv[0],atoi(c_argv[1]));
    if (sock.h.ok)
    {
        Free(buff);
        while (!end)
        {
            wait = true;
            New(buff,5000);
            gets(buff);
            SendLongBuff((BYTE*)buff,strlen(buff),sock.Sock);
        }
        end = false;
        goto BEGIN;
    }
    else
    {
        Free(buff);
        clear();
        goto BEGIN;
    }
    return 0;
}

WinExec("telnet x.x.x.x port", SW_SHOW);