// ProtocolRx.h: interface for the CProtocolRx class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_PROTOCOLRX_H__DFEE9DEE_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_)
#define AFX_PROTOCOLRX_H__DFEE9DEE_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

enum _verb
{
  verb_sb   = 250,
  verb_will = 251,
  verb_wont = 252,
  verb_do   = 253,
  verb_dont = 254
};

enum _state
{
  state_data,   //we expect a data byte
  state_code,   //we expect a code
  state_option  //we expect an option
};
enum _option
{
  TOPT_BIN = 0,   // Binary Transmission
  TOPT_ECHO = 1,  // Echo
  TOPT_RECN = 2,  // Reconnection
  TOPT_SUPP = 3,  // Suppress Go Ahead
  TOPT_APRX = 4,  // Approx Message Size Negotiation
  TOPT_STAT = 5,  // Status
  TOPT_TIM = 6,   // Timing Mark
  TOPT_REM = 7,   // Remote Controlled Trans and Echo
  TOPT_OLW = 8,   // Output Line Width
  TOPT_OPS = 9,   // Output Page Size
  TOPT_OCRD = 10, // Output Carriage-Return Disposition
  TOPT_OHT = 11,  // Output Horizontal Tabstops
  TOPT_OHTD = 12, // Output Horizontal Tab Disposition
  TOPT_OFD = 13,  // Output Formfeed Disposition
  TOPT_OVT = 14,  // Output Vertical Tabstops
  TOPT_OVTD = 15, // Output Vertical Tab Disposition
  TOPT_OLD = 16,  // Output Linefeed Disposition
  TOPT_EXT = 17,  // Extended ASCII
  TOPT_LOGO = 18, // Logout
  TOPT_BYTE = 19, // Byte Macro
  TOPT_DATA = 20, // Data Entry Terminal
  TOPT_SUP = 21,  // SUPDUP
  TOPT_SUPO = 22, // SUPDUP Output
  TOPT_SNDL = 23, // Send Location
  TOPT_TERM = 24, // Terminal Type
  TOPT_EOR = 25,  // End of Record
  TOPT_TACACS = 26, // TACACS User Identification
  TOPT_OM = 27,   // Output Marking
  TOPT_TLN = 28,  // Terminal Location Number
  TOPT_3270 = 29, // Telnet 3270 Regime
  TOPT_X3 = 30,  // X.3 PAD
  TOPT_NAWS = 31, // Negotiate About Window Size
  TOPT_TS = 32,   // Terminal Speed
  TOPT_RFC = 33,  // Remote Flow Control
  TOPT_LINE = 34, // Linemode
  TOPT_XDL = 35,  // X Display Location
  TOPT_ENVIR = 36,// Telnet Environment Option
  TOPT_AUTH = 37, // Telnet Authentication Option
  TOPT_NENVIR = 39,// Telnet Environment Option
  TOPT_EXTOP = 255, // Extended-Options-List
  TOPT_ERROR = 256  // Magic number
};


class CProtocolRx
{
public:
        CProtocolRx();
        virtual ~CProtocolRx();
        inline void yesreply(SOCKET server, _verb verb,_option option);
        inline void noreply(SOCKET server, _verb verb,_option option);
        inline void askfor(SOCKET server, _verb verb,_option option);
        void TelentProtcol(SOCKET server,unsigned char code);
        void nvt(SOCKET server,unsigned char data);
};

#endif // !defined(AFX_PROTOCOLRX_H__DFEE9DEE_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_)

[ 本帖最后由 changch84 于 2007-10-18 01:38 编辑 ]

//resource.h
//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by Telnet.rc
//
#define IDS_HELLO                       1

// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        101
#define _APS_NEXT_COMMAND_VALUE         40001
#define _APS_NEXT_CONTROL_VALUE         1000
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif

[ 本帖最后由 changch84 于 2007-10-18 01:31 编辑 ]

// SocketDx.h: interface for the CSocketDx class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_SOCKETDX_H__DFEE9DED_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_)
#define AFX_SOCKETDX_H__DFEE9DED_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CSocketDx  
{
public:
        CSocketDx(char *,int);
        ~CSocketDx();
        int Create();
        int Connect();
        SOCKET TelnetConnect();
        sockaddr_in m_sockaddr_in;
        SOCKET m_hSocket;
};

#endif // !defined(AFX_SOCKETDX_H__DFEE9DED_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_)

// SocketRx.h: interface for the CSocketRx class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_SOCKETRX_H__DFEE9DEC_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_)
#define AFX_SOCKETRX_H__DFEE9DEC_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "ProtocolRx.h"
class CProtocolRx;
class CSocketRx  
{
public:
        CSocketRx();
        CSocketRx(SOCKET,HANDLE&);
        virtual ~CSocketRx();
        static DWORD RdTh(CSocketRx *);

        SOCKET m_hSocket;
        HANDLE m_hThread;
        int m_nExit;
        CProtocolRx m_Protocol;
};

#endif // !defined(AFX_SOCKETRX_H__DFEE9DEC_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_)

// SocketTx.h: interface for the CSocketTx class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_SOCKETTX_H__DFEE9DEA_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_)
#define AFX_SOCKETTX_H__DFEE9DEA_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CSocketTx  
{
public:
        CSocketTx(SOCKET,HANDLE&);
        virtual ~CSocketTx();
        static DWORD SendTh(CSocketTx*);

        SOCKET m_hSocket;
        HANDLE m_hThread;
        int m_nExit;
};

#endif // !defined(AFX_SOCKETTX_H__DFEE9DEA_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_)

// stdafx.h : include file for standard system include files,
//  or project specific include files that are used frequently, but
//      are changed infrequently
//

#if !defined(AFX_STDAFX_H__DFEE9DE2_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_)
#define AFX_STDAFX_H__DFEE9DE2_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#define VC_EXTRALEAN                // Exclude rarely-used stuff from Windows headers

#include <afx.h>
#include <afxwin.h>         // MFC core and standard components
#include <afxext.h>         // MFC extensions
#include <afxdtctl.h>                // MFC support for Internet Explorer 4 Common Controls
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include <afxcmn.h>                        // MFC support for Windows Common Controls
#endif // _AFX_NO_AFXCMN_SUPPORT
#include <winsock.h>
#include <iostream>

// TODO: reference additional headers your program requires here

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_STDAFX_H__DFEE9DE2_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_)

// Telnet.h
#if !defined(AFX_TELNET_H__DFEE9DE8_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_)
#define AFX_TELNET_H__DFEE9DE8_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "resource.h"


#endif // !defined(AFX_TELNET_H__DFEE9DE8_9AF1_11D2_A6CE_204C4F4F5020__INCLUDED_)

// ProtocolRx.cpp: implementation of the CProtocolRx class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Telnet.h"
#include "rotocolRx.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
extern HANDLE stdin1;
extern HANDLE stdout1;
extern HANDLE stderr1;

void nvt(SOCKET server,unsigned char data);
enum _ansi_state
{
  as_normal,
  as_esc,
  as_esc1
};
static int sa = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
char codebuf[256];
unsigned char codeptr;
#define NUM_CODEC 6
typedef void (*LPCODEPROC)(char*);
void ansi_set_screen_attribute(char* buffer);
void ansi_set_position(char* buffer);
void ansi_erase_screen(char* buffer);
void ansi_move_up(char* buffer);
void ansi(SOCKET server,unsigned char data);
void ansi_erase_line(char* buffer);
void ddww_error(SOCKET server,_verb verb,_option option);
void ddww_echo(SOCKET server,_verb verb, _option option);
void ddww_supp(SOCKET server,_verb verb,_option option); //Suppress GA
void ddww_term(SOCKET server,_verb verb,_option option); //Subnegotiate terminal type
void sbproc_term(SOCKET server,unsigned char data);
       

struct
{
  unsigned char cmd;
  LPCODEPROC proc;
} codec[NUM_CODEC] = {
  {'m',ansi_set_screen_attribute},
  {'H',ansi_set_position},
  {'K',ansi_erase_line},
  {'J',ansi_erase_screen},
  {'A',ansi_move_up},
  {0,0}
};

CProtocolRx::CProtocolRx()
{

}

CProtocolRx::~CProtocolRx()
{

}
#define NUL     0
#define BEL     7
#define BS      8
#define HT      9
#define LF     10
#define VT     11
#define FF     12
#define CR     13
#define SE    240
#define NOP   241
#define DM    242
#define BRK   243
#define IP    244
#define AO    245
#define AYT   246
#define EC    247
#define EL    248
#define GA    249
#define SB    250
#define WILL  251
#define WONT  252
#define DO    253
#define DONT  254
#define IAC   255


int option_error(_verb,_option,int,SOCKET);

typedef void(*LPOPTIONPROC)(SOCKET,_verb,_option);
typedef void(*LPDATAPROC)(SOCKET,unsigned char data);


inline void yesreply(SOCKET server, _verb verb,_option option)
{
  unsigned char buf[3];
  buf[0] = IAC;
  buf[1] = (verb==verb_do)?WILLverb==verb_dont)?WONTverb==verb_will)?DOONT;
  buf[2] = (unsigned char)option;
  send(server,(char*)buf,3,0);
}

inline void noreply(SOCKET server, _verb verb,_option option)
{
  unsigned char buf[3];
  buf[0] = IAC;
  buf[1] = (verb==verb_do)?WONTverb==verb_dont)?WILLverb==verb_will)?DONTO;
  buf[2] = (unsigned char)option;
  send(server,(char*)buf,3,0);
}

inline void askfor(SOCKET server, _verb verb,_option option)
{
  unsigned char buf[3];
  buf[0] = IAC;
  buf[1] = (unsigned char)verb;
  buf[2] = (unsigned char)option;
  send(server,(char*)buf,3,0);
}


void ddww_error(SOCKET server,_verb verb,_option option)
{
#ifdef _DEBUG
  char tmp[256];
  wsprintf(tmp,"Unknown Option Code: %s, %i\n",(verb==verb_do)?"DO"verb==verb_dont)?"DON'T"verb==verb_will)?"WILL":"WONT",(int)option);
  OutputDebugString(tmp);
#endif

  switch(verb)
  {
  case verb_will:
    noreply(server,verb,option);
    break;
  case verb_wont:
    return;
  case verb_do:
    noreply(server,verb,option);
    break;
  case verb_dont:
    return;
  }
}
void ddww_echo(SOCKET server,_verb verb, _option option)
{
  DWORD mode;
  GetConsoleMode(stdin1,&mode); // ENABLE_ECHO_INPUT
  
  int set = !(mode & ENABLE_ECHO_INPUT);

  switch(verb)
  {
  case verb_will: // server wants to echo stuff
    if(set) return; //don't confirm - already set.
    SetConsoleMode(stdin1,mode & (~ENABLE_ECHO_INPUT));
    break;
  case verb_wont: // server don't want to echo
    if(!set) return; //don't confirm - already unset.
    SetConsoleMode(stdin1,mode | ENABLE_ECHO_INPUT);
    break;
  case verb_do:   // server wants me to loopback
    noreply(server,verb,option);
    return;
  case verb_dont: // server doesn't want me to echo
    break;        // don't bother to reply - I don't
  }
  yesreply(server,verb,option);
}


void ddww_supp(SOCKET server,_verb verb,_option option) //Suppress GA
{
  DWORD mode;
  GetConsoleMode(stdin1,&mode); // ENABLE_LINE_INPUT
  
  int set = !(mode & ENABLE_LINE_INPUT);

  switch(verb)
  {
  case verb_will: // server wants to suppress GA's
    if(set) break; //don't confirm - already set.
    SetConsoleMode(stdin1,mode & (~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT)));
    askfor(server,verb_do,TOPT_SUPP);
    askfor(server,verb_will,TOPT_SUPP);
    askfor(server,verb_do,TOPT_ECHO);
    break;
  case verb_wont: // server wants to send GA's
    if(!set) break; //don't confirm - already unset.
    SetConsoleMode(stdin1,mode | ENABLE_LINE_INPUT);
    askfor(server,verb_dont,TOPT_SUPP);
    askfor(server,verb_wont,TOPT_SUPP);
    break;
  case verb_do:   // server wants me to suppress GA's
    if(set) break;
    askfor(server,verb_do,TOPT_SUPP);
    break;
  case verb_dont: // server wants me to send GA's
    if(!set) break;
    askfor(server,verb_dont,TOPT_SUPP);
    break;
  }
}

///////////////////////////////////////////////////////////////////////////////
// Option TERMINAL-TYPE

void ddww_term(SOCKET server,_verb verb,_option option) //Subnegotiate terminal type
{
  switch(verb)
  {
  case verb_will:
    noreply(server,verb,option); // I don't want terminal info
    break;
  case verb_wont:
    //dat be cool - its not going to send. no need to confirm
    break;
  case verb_do:
    yesreply(server,verb,option); //I'll send it when asked
    break;
  case verb_dont://Ok - I won't
    break;
  }
}

// TERMINAL TYPE subnegotation
enum
{
  SB_TERM_IS = 0,
  SB_TERM_SEND = 1
};

#define NUM_TERMINALS 2

struct
{
  char* name;
  LPDATAPROC termproc;
  //pre requsites.
} terminal[NUM_TERMINALS] = {
  { "NVT", nvt },
  { "ANSI", ansi }
};

int term_index = 0;

void sbproc_term(SOCKET server,unsigned char data)
{

  if(data == SB_TERM_SEND)
  {
    if(term_index == NUM_TERMINALS)
      term_index = 0;
    else
      term_index++;
    char buf[16]; //pls limit
    buf[0] = IAC;
    buf[1] = SB;
    buf[2] = TOPT_TERM;
    buf[3] = SB_TERM_IS;
    lstrcpy(&buf[4],terminal[(term_index==NUM_TERMINALS)?(NUM_TERMINALS-1):term_index].name);
    int nlen = lstrlen(&buf[4]);
    buf[4+nlen] = IAC;
    buf[5+nlen] = SE;
    send(server,buf,4+nlen+2,0);
  }
}

///////////////////////////////////////////////////////////////////////////////

struct
{
  _option option;
  LPOPTIONPROC OptionProc;
  LPDATAPROC DataProc;
}  ol[] = {
  {TOPT_ECHO,   ddww_echo,  NULL},
  {TOPT_SUPP,   ddww_supp,  NULL},
  {TOPT_TERM,   ddww_term,  sbproc_term},
  {TOPT_ERROR,  ddww_error, NULL}
};

void CProtocolRx::TelentProtcol(SOCKET server,unsigned char code)
{
//These vars are the finite state
  static int state = state_data;
  static _verb verb = verb_sb;
  static LPDATAPROC DataProc = terminal[(term_index==NUM_TERMINALS)?(NUM_TERMINALS-1):term_index].termproc;

//Decide what to do (state based)
  switch(state)
  {
  case state_data:
    switch(code)
    {
    case IAC: state = state_code; break;
    default: DataProc(server,code);
    }
    break;
  case state_code:
    state = state_data;
    switch(code)
    {
    // State transition back to data
    case IAC:
      DataProc(server,code);
      break;
    // Code state transitions back to data
    case SE:
      DataProc = terminal[(term_index==NUM_TERMINALS)?(NUM_TERMINALS-1):term_index].termproc;
      break;
    case NOP:
      break;
    case DM:
      break;
    case BRK:
      break;
    case IP:
      break;
    case AO:
      break;
    case AYT:
      break;
    case EC:
      break;
    case EL:
      break;
    case GA:
      break;
    // Transitions to option state
    case SB:
      verb = verb_sb;
      state = state_option;
      break;
    case WILL:
      verb = verb_will;
      state = state_option;
      break;
    case WONT:
      verb = verb_wont;
      state = state_option;
      break;
    case DO:
      verb = verb_do;
      state = state_option;
      break;
    case DONT:
      verb = verb_dont;
      state = state_option;
      break;
    }
    break;
  case state_option:
    state = state_data;

    //Find the option entry
        int i = 0;
    for(;
      
      ol.option != TOPT_ERROR && ol.option != code;
      i++);

    //Do some verb specific stuff
    if(verb == verb_sb)
      DataProc = ol.DataProc;
    else
      ol.OptionProc(server,verb,(_option)code);
    break;
  }
}
void nvt(SOCKET server,unsigned char data)
{
  DWORD z;
  switch(data)
  {
  case 0:  //eat null codes.
    break;
  default: //Send all else to the console.
    WriteConsole(stdout1,&data,1,&z,NULL);
    break;
  }
}
void ansi_set_screen_attribute(char* buffer)
{
  while(*buffer)
  {
    switch(*buffer++)
    {
    case '0': //Normal
      sa = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
      break;
    case '1': //Hign Intensity
      sa |= FOREGROUND_INTENSITY;
      break;
    case '4': //Underscore
      break;
    case '5': //Blink.
      sa |= BACKGROUND_INTENSITY;
      break;
    case '7':
      sa = BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE;
      break;
    case '8':
      sa = 0;
      break;
    case '3':
      sa = sa & (BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_INTENSITY) |
        (*buffer & 1)?FOREGROUND_RED:0 |
        (*buffer & 2)?FOREGROUND_GREEN:0 |
        (*buffer & 4)?FOREGROUND_BLUE:0;
      if(*buffer)
        buffer++;
      break;
    case '6':
      sa = sa & (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY) |
        (*buffer & 1)?BACKGROUND_RED:0 |
        (*buffer & 2)?BACKGROUND_GREEN:0 |
        (*buffer & 4)?BACKGROUND_BLUE:0;
      if(*buffer)
        buffer++;
      break;
    }
    if(*buffer && *buffer == ';')
      buffer++;
  }
  SetConsoleTextAttribute(stdout1,sa);
}
void ansi_erase_line(char* buffer)
{
  int act = 0;
  while(*buffer)
  {
    act = (*buffer++) - '0';
  }

  CONSOLE_SCREEN_BUFFER_INFO csbi;
  GetConsoleScreenBufferInfo(stdout1,&csbi);

  COORD pos;
  DWORD n;

  switch(act)
  {
  case 0: //erase to end of line
    pos.X = csbi.dwCursorPosition.X;
    pos.Y = csbi.dwCursorPosition.Y;
    n = csbi.dwSize.X - csbi.dwCursorPosition.X;
    break;
  case 1: //erase from beginning
    pos.X = 0;
    pos.Y = csbi.dwCursorPosition.Y;
    n = csbi.dwCursorPosition.X;
    break;
  case 2: // erase whole line
    pos.X = 0;
    pos.Y = csbi.dwCursorPosition.Y;
    n = csbi.dwSize.X;
    break;
  }

  DWORD w;
  FillConsoleOutputCharacter(stdout1,' ',n,pos,&w);
}
void ansi_set_position(char* buffer)
{
  COORD pos = {0,0};

  // Grab line
  while(*buffer && *buffer != ';')
    pos.Y = pos.Y*10 + *buffer++ - '0';

  if(*buffer)
    buffer++;

  // Grab y
  while(*buffer && *buffer != ';')
    pos.X = pos.X*10 + *buffer++ - '0';

  (pos.X)?pos.X--:0;
  (pos.Y)?pos.Y--:0;

  SetConsoleCursorPosition(stdout1,pos);

}
void ansi_erase_screen(char* buffer)
{
  int act = 0;
  while(*buffer)
  {
    act = (*buffer++) - '0';
  }

  CONSOLE_SCREEN_BUFFER_INFO csbi;
  GetConsoleScreenBufferInfo(stdout1,&csbi);

  COORD pos;
  DWORD n;

  switch(act)
  {
  case 0:
    pos.X = csbi.dwCursorPosition.X;
    pos.Y = csbi.dwCursorPosition.Y;
    n = csbi.dwSize.X*csbi.dwSize.Y;
    break;
  case 2:
    pos.X = 0;
    pos.Y = 0;
    n = csbi.dwSize.X*csbi.dwSize.Y;
    break;
  }

  DWORD w;
  FillConsoleOutputCharacter(stdout1,' ',n,pos,&w);
  SetConsoleCursorPosition(stdout1,pos);
}
void ansi_move_up(char* buffer)
{
  int cnt = *buffer?0:1;
  while(*buffer)
  {
    cnt = cnt*10 + (*buffer++) - '0';
  }

  COORD pos;

  CONSOLE_SCREEN_BUFFER_INFO csbi;
  GetConsoleScreenBufferInfo(stdout1,&csbi);

  pos.X = csbi.dwCursorPosition.X;
  pos.Y = ((csbi.dwCursorPosition.Y-cnt)>=0)?(csbi.dwCursorPosition.Y-cnt):0;

  SetConsoleCursorPosition(stdout1,pos);
}
void ansi(SOCKET server,unsigned char data)
{
  static _ansi_state state = as_normal;
  DWORD z;
  switch( state)
  {
  case as_normal:
    switch(data)
    {
    case 0:  //eat null codes.
      break;
    case 27: //ANSI esc.
      state = as_esc;
      break;
    default: //Send all else to the console.
      WriteConsole(stdout1,&data,1,&z,NULL);
      break;
    }
    break;
  case as_esc:
    state = as_esc1;
    codeptr=0;
    codebuf[codeptr] = 0;
    break;
  case as_esc1:
    if(data > 64)
    {
      codebuf[codeptr] = 0;
          int i=0;
      for(; codec.cmd && codec.cmd != data; i++);
      if(codec.proc)
        codec.proc(codebuf);
#ifdef _DEBUG
      else
      {
        char buf[256];
        wsprintf(buf,"Unknown Ansi code:'%c' (%s)\n",data,codebuf);
        OutputDebugString(buf);
      }
#endif
      state = as_normal;
    }
    else
      codebuf[codeptr++] = data;
    break;
  }
}

// SocketDx.cpp: implementation of the CSocketDx class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Telnet.h"
#include "Telnet.h"
#include "SocketDx.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CSocketDx::CSocketDx(char *strIP,int nPort)
{
unsigned long ip;

  if((*strIP <= '9') && (*strIP >= '0'))
  {
     if((ip = inet_addr(strIP)) == INADDR_NONE)
       printf("invalid host ip given");
  }
  else
  {
    hostent* ent = gethostbyname(strIP);
    if(!ent) printf("\nError\n");
    ip = *(unsigned long*)(ent->h_addr);
  }

        m_sockaddr_in.sin_family = AF_INET;
        m_sockaddr_in.sin_port = htons(nPort);
        m_sockaddr_in.sin_addr = *(in_addr*)&ip;
}
CSocketDx::~CSocketDx()
{

}
int CSocketDx::Create()
{
  m_hSocket = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP);
  if ( m_hSocket == INVALID_SOCKET) return -1;
  return 0;
}
int CSocketDx::Connect()
{
int nRet;

  nRet = connect(m_hSocket,(sockaddr*)&m_sockaddr_in,sizeof(sockaddr));
  if ( nRet == SOCKET_ERROR ) return -1;
  return 0;
}
SOCKET CSocketDx::TelnetConnect()
{
int nRet;
       
        nRet = Create();
        if ( nRet < 0 ) return NULL;

        nRet = Connect();
        if ( nRet < 0 ) return NULL;

        return m_hSocket;
}