开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet客户端 > 查看源码
ProtocolRx.cpp
资源名称：Telnet.rar　[点击查看]
上传用户：net1718
上传日期：2016-03-27
资源大小：36k
文件大小：13k
源码类别：

Telnet客户端

开发平台：

Visual C++

ProtocolRx.cpp：源码内容
  1. // ProtocolRx.cpp: implementation of the CProtocolRx class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "Telnet.h"
  7. #include "ProtocolRx.h"
  9. #ifdef _DEBUG
  10. #undef THIS_FILE
  11. static char THIS_FILE[]=__FILE__;
  12. #define new DEBUG_NEW
  13. #endif
  15. //////////////////////////////////////////////////////////////////////
  16. // Construction/Destruction
  17. //////////////////////////////////////////////////////////////////////
  18. extern HANDLE stdin1;
  19. extern HANDLE stdout1;
  20. extern HANDLE stderr1;
  22. void nvt(SOCKET server,unsigned char data);
  23. enum _ansi_state
  24. {
  25.   as_normal,
  26.   as_esc,
  27.   as_esc1
  28. };
  29. static sa = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
  30. char codebuf[256];
  31. unsigned char codeptr;
  32. #define NUM_CODEC 6
  33. typedef void (*LPCODEPROC)(char*);
  34. void ansi_set_screen_attribute(char* buffer);
  35. void ansi_set_position(char* buffer);
  36. void ansi_erase_screen(char* buffer);
  37. void ansi_move_up(char* buffer);
  38. void ansi(SOCKET server,unsigned char data);
  39. void ansi_erase_line(char* buffer);
  40. void ddww_error(SOCKET server,_verb verb,_option option);
  41. void ddww_echo(SOCKET server,_verb verb, _option option);
  42. void ddww_supp(SOCKET server,_verb verb,_option option); //Suppress GA
  43. void ddww_term(SOCKET server,_verb verb,_option option); //Subnegotiate terminal type
  44. void sbproc_term(SOCKET server,unsigned char data);
  47. struct 
  48. {
  49.   unsigned char cmd;
  50.   LPCODEPROC proc;
  51. } codec[NUM_CODEC] = {
  52.   {'m',ansi_set_screen_attribute},
  53.   {'H',ansi_set_position},
  54.   {'K',ansi_erase_line},
  55.   {'J',ansi_erase_screen},
  56.   {'A',ansi_move_up},
  57.   {0,0}
  58. };
  60. CProtocolRx::CProtocolRx()
  61. {
  63. }
  65. CProtocolRx::~CProtocolRx()
  66. {
  68. }
  69. #define NUL     0
  70. #define BEL     7
  71. #define BS      8
  72. #define HT      9
  73. #define LF     10
  74. #define VT     11
  75. #define FF     12
  76. #define CR     13
  77. #define SE    240
  78. #define NOP   241
  79. #define DM    242
  80. #define BRK   243
  81. #define IP    244
  82. #define AO    245
  83. #define AYT   246
  84. #define EC    247
  85. #define EL    248
  86. #define GA    249
  87. #define SB    250
  88. #define WILL  251
  89. #define WONT  252
  90. #define DO    253
  91. #define DONT  254
  92. #define IAC   255
  95. int option_error(_verb,_option,int,SOCKET);
  97. typedef void(*LPOPTIONPROC)(SOCKET,_verb,_option);
  98. typedef void(*LPDATAPROC)(SOCKET,unsigned char data);
  101. inline void yesreply(SOCKET server, _verb verb,_option option)
  102. {
  103.   unsigned char buf[3];
  104.   buf[0] = IAC;
  105.   buf[1] = (verb==verb_do)?WILL:(verb==verb_dont)?WONT:(verb==verb_will)?DO:DONT;
  106.   buf[2] = (unsigned char)option;
  107.   send(server,(char*)buf,3,0);
  108. }
  110. inline void noreply(SOCKET server, _verb verb,_option option)
  111. {
  112.   unsigned char buf[3];
  113.   buf[0] = IAC;
  114.   buf[1] = (verb==verb_do)?WONT:(verb==verb_dont)?WILL:(verb==verb_will)?DONT:DO;
  115.   buf[2] = (unsigned char)option;
  116.   send(server,(char*)buf,3,0);
  117. }
  119. inline void askfor(SOCKET server, _verb verb,_option option)
  120. {
  121.   unsigned char buf[3];
  122.   buf[0] = IAC;
  123.   buf[1] = (unsigned char)verb;
  124.   buf[2] = (unsigned char)option;
  125.   send(server,(char*)buf,3,0);
  126. }
  129. void ddww_error(SOCKET server,_verb verb,_option option)
  130. {
  131. #ifdef _DEBUG
  132.   char tmp[256];
  133.   wsprintf(tmp,"Unknown Option Code: %s, %in",(verb==verb_do)?"DO":(verb==verb_dont)?"DON'T":(verb==verb_will)?"WILL":"WONT",(int)option);
  134.   OutputDebugString(tmp);
  135. #endif
  137.   switch(verb)
  138.   {
  139.   case verb_will: 
  140.     noreply(server,verb,option);
  141.     break;
  142.   case verb_wont:
  143.     return;
  144.   case verb_do:
  145.     noreply(server,verb,option);
  146.     break;
  147.   case verb_dont:
  148.     return;
  149.   }
  150. }
  151. void ddww_echo(SOCKET server,_verb verb, _option option)
  152. {
  153.   DWORD mode;
  154.   GetConsoleMode(stdin1,&mode); // ENABLE_ECHO_INPUT
  155.   
  156.   int set = !(mode & ENABLE_ECHO_INPUT);
  158.   switch(verb)
  159.   {
  160.   case verb_will: // server wants to echo stuff
  161.     if(set) return; //don't confirm - already set.
  162.     SetConsoleMode(stdin1,mode & (~ENABLE_ECHO_INPUT));
  163.     break;
  164.   case verb_wont: // server don't want to echo
  165.     if(!set) return; //don't confirm - already unset.
  166.     SetConsoleMode(stdin1,mode | ENABLE_ECHO_INPUT);
  167.     break;
  168.   case verb_do:   // server wants me to loopback
  169.     noreply(server,verb,option);
  170.     return;
  171.   case verb_dont: // server doesn't want me to echo
  172.     break;        // don't bother to reply - I don't
  173.   }
  174.   yesreply(server,verb,option);
  175. }
  178. void ddww_supp(SOCKET server,_verb verb,_option option) //Suppress GA
  179. {
  180.   DWORD mode;
  181.   GetConsoleMode(stdin1,&mode); // ENABLE_LINE_INPUT
  182.   
  183.   int set = !(mode & ENABLE_LINE_INPUT);
  185.   switch(verb)
  186.   {
  187.   case verb_will: // server wants to suppress GA's
  188.     if(set) break; //don't confirm - already set.
  189.     SetConsoleMode(stdin1,mode & (~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT)));
  190.     askfor(server,verb_do,TOPT_SUPP);
  191.     askfor(server,verb_will,TOPT_SUPP);
  192.     askfor(server,verb_do,TOPT_ECHO);
  193.     break;
  194.   case verb_wont: // server wants to send GA's 
  195.     if(!set) break; //don't confirm - already unset.
  196.     SetConsoleMode(stdin1,mode | ENABLE_LINE_INPUT);
  197.     askfor(server,verb_dont,TOPT_SUPP);
  198.     askfor(server,verb_wont,TOPT_SUPP);
  199.     break;
  200.   case verb_do:   // server wants me to suppress GA's
  201.     if(set) break;
  202.     askfor(server,verb_do,TOPT_SUPP);
  203.     break;
  204.   case verb_dont: // server wants me to send GA's
  205.     if(!set) break;
  206.     askfor(server,verb_dont,TOPT_SUPP);
  207.     break;
  208.   }
  209. }
  211. ///////////////////////////////////////////////////////////////////////////////
  212. // Option TERMINAL-TYPE
  214. void ddww_term(SOCKET server,_verb verb,_option option) //Subnegotiate terminal type
  215. {
  216.   switch(verb)
  217.   {
  218.   case verb_will:
  219.     noreply(server,verb,option); // I don't want terminal info
  220.     break;
  221.   case verb_wont:
  222.     //dat be cool - its not going to send. no need to confirm
  223.     break;
  224.   case verb_do:
  225.     yesreply(server,verb,option); //I'll send it when asked
  226.     break;
  227.   case verb_dont://Ok - I won't
  228.     break;
  229.   }
  230. }
  232. // TERMINAL TYPE subnegotation
  233. enum
  234. {
  235.   SB_TERM_IS = 0,
  236.   SB_TERM_SEND = 1
  237. };
  239. #define NUM_TERMINALS 2
  241. struct
  242. {
  243.   char* name;
  244.   LPDATAPROC termproc;
  245.   //pre requsites.
  246. } terminal[NUM_TERMINALS] = {
  247.   { "NVT", nvt }, 
  248.   { "ANSI", ansi }
  249. };
  251. int term_index = 0;
  253. void sbproc_term(SOCKET server,unsigned char data)
  254. {
  256.   if(data == SB_TERM_SEND)
  257.   {
  258.     if(term_index == NUM_TERMINALS)
  259.       term_index = 0;
  260.     else
  261.       term_index++;
  262.     char buf[16]; //pls limit 
  263.     buf[0] = IAC;
  264.     buf[1] = SB;
  265.     buf[2] = TOPT_TERM;
  266.     buf[3] = SB_TERM_IS;
  267.     lstrcpy(&buf[4],terminal[(term_index==NUM_TERMINALS)?(NUM_TERMINALS-1):term_index].name);
  268.     int nlen = lstrlen(&buf[4]);
  269.     buf[4+nlen] = IAC;
  270.     buf[5+nlen] = SE;
  271.     send(server,buf,4+nlen+2,0);
  272.   }
  273. }
  275. ///////////////////////////////////////////////////////////////////////////////
  277. struct
  278. {
  279.   _option option;
  280.   LPOPTIONPROC OptionProc;
  281.   LPDATAPROC DataProc;
  282. }  ol[] = {
  283.   {TOPT_ECHO,   ddww_echo,  NULL},
  284.   {TOPT_SUPP,   ddww_supp,  NULL},
  285.   {TOPT_TERM,   ddww_term,  sbproc_term},
  286.   {TOPT_ERROR,  ddww_error, NULL}
  287. };
  290. void CProtocolRx::TelentProtcol(SOCKET server,unsigned char code)
  291. {
  292. //These vars are the finite state
  293.   static int state = state_data;
  294.   static _verb verb = verb_sb;
  295.   static LPDATAPROC DataProc = terminal[(term_index==NUM_TERMINALS)?(NUM_TERMINALS-1):term_index].termproc;
  297. //Decide what to do (state based)
  298.   switch(state)
  299.   {
  300.   case state_data:
  301.     switch(code)
  302.     {
  303.     case IAC: state = state_code; break;
  304.     default: DataProc(server,code);
  305.     }
  306.     break;
  307.   case state_code:
  308.     state = state_data;
  309.     switch(code)
  310.     {
  311.     // State transition back to data
  312.     case IAC: 
  313.       DataProc(server,code);
  314.       break;
  315.     // Code state transitions back to data
  316.     case SE:
  317.       DataProc = terminal[(term_index==NUM_TERMINALS)?(NUM_TERMINALS-1):term_index].termproc;
  318.       break;
  319.     case NOP:
  320.       break;
  321.     case DM:
  322.       break;
  323.     case BRK:
  324.       break;
  325.     case IP:
  326.       break;
  327.     case AO:
  328.       break;
  329.     case AYT:
  330.       break;
  331.     case EC:
  332.       break;
  333.     case EL:
  334.       break;
  335.     case GA:
  336.       break;
  337.     // Transitions to option state
  338.     case SB:
  339.       verb = verb_sb;
  340.       state = state_option;
  341.       break;
  342.     case WILL:
  343.       verb = verb_will;
  344.       state = state_option;
  345.       break;
  346.     case WONT:
  347.       verb = verb_wont;
  348.       state = state_option;
  349.       break;
  350.     case DO:
  351.       verb = verb_do;
  352.       state = state_option;
  353.       break;
  354.     case DONT:
  355.       verb = verb_dont;
  356.       state = state_option;
  357.       break;
  358.     }
  359.     break;
  360.   case state_option:
  361.     state = state_data;
  363.     //Find the option entry
  364.     for(
  365.       int i = 0;
  366.       ol[i].option != TOPT_ERROR && ol[i].option != code;
  367.       i++);
  369.     //Do some verb specific stuff
  370.     if(verb == verb_sb)
  371.       DataProc = ol[i].DataProc;
  372.     else
  373.       ol[i].OptionProc(server,verb,(_option)code);
  374.     break;
  375.   }
  376. }
  377. void nvt(SOCKET server,unsigned char data)
  378. {
  379.   DWORD z;
  380.   switch(data)
  381.   {
  382.   case 0:  //eat null codes.
  383.     break;
  384.   default: //Send all else to the console.
  385.     WriteConsole(stdout1,&data,1,&z,NULL);
  386.     break;
  387.   }
  388. }
  389. void ansi_set_screen_attribute(char* buffer)
  390. {
  391.   while(*buffer)
  392.   {
  393.     switch(*buffer++)
  394.     {
  395.     case '0': //Normal
  396.       sa = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
  397.       break;
  398.     case '1': //Hign Intensity
  399.       sa |= FOREGROUND_INTENSITY;
  400.       break;
  401.     case '4': //Underscore
  402.       break;
  403.     case '5': //Blink.
  404.       sa |= BACKGROUND_INTENSITY;
  405.       break;
  406.     case '7':
  407.       sa = BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE;
  408.       break;
  409.     case '8':
  410.       sa = 0;
  411.       break;
  412.     case '3':
  413.       sa = sa & (BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_INTENSITY) |
  414.         (*buffer & 1)?FOREGROUND_RED:0 |
  415.         (*buffer & 2)?FOREGROUND_GREEN:0 |
  416.         (*buffer & 4)?FOREGROUND_BLUE:0;
  417.       if(*buffer)
  418.         buffer++;
  419.       break;
  420.     case '6':
  421.       sa = sa & (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY) |
  422.         (*buffer & 1)?BACKGROUND_RED:0 |
  423.         (*buffer & 2)?BACKGROUND_GREEN:0 |
  424.         (*buffer & 4)?BACKGROUND_BLUE:0;
  425.       if(*buffer)
  426.         buffer++;
  427.       break;
  428.     }
  429.     if(*buffer && *buffer == ';')
  430.       buffer++;
  431.   }
  432.   SetConsoleTextAttribute(stdout1,sa);
  433. }
  434. void ansi_erase_line(char* buffer)
  435. {
  436.   int act = 0;
  437.   while(*buffer)
  438.   {
  439.     act = (*buffer++) - '0';
  440.   }
  442.   CONSOLE_SCREEN_BUFFER_INFO csbi;
  443.   GetConsoleScreenBufferInfo(stdout1,&csbi);
  445.   COORD pos;
  446.   DWORD n;
  448.   switch(act)
  449.   {
  450.   case 0: //erase to end of line
  451.     pos.X = csbi.dwCursorPosition.X;
  452.     pos.Y = csbi.dwCursorPosition.Y;
  453.     n = csbi.dwSize.X - csbi.dwCursorPosition.X;
  454.     break;
  455.   case 1: //erase from beginning
  456.     pos.X = 0;
  457.     pos.Y = csbi.dwCursorPosition.Y;
  458.     n = csbi.dwCursorPosition.X;
  459.     break;
  460.   case 2: // erase whole line
  461.     pos.X = 0;
  462.     pos.Y = csbi.dwCursorPosition.Y;
  463.     n = csbi.dwSize.X;
  464.     break;
  465.   }
  467.   DWORD w;
  468.   FillConsoleOutputCharacter(stdout1,' ',n,pos,&w);
  469. }
  470. void ansi_set_position(char* buffer)
  471. {
  472.   COORD pos = {0,0};
  474.   // Grab line
  475.   while(*buffer && *buffer != ';')
  476.     pos.Y = pos.Y*10 + *buffer++ - '0';
  478.   if(*buffer)
  479.     buffer++;
  481.   // Grab y
  482.   while(*buffer && *buffer != ';')
  483.     pos.X = pos.X*10 + *buffer++ - '0';
  485.   (pos.X)?pos.X--:0;
  486.   (pos.Y)?pos.Y--:0;
  488.   SetConsoleCursorPosition(stdout1,pos);
  489.  
  490. }
  491. void ansi_erase_screen(char* buffer)
  492. {
  493.   int act = 0;
  494.   while(*buffer)
  495.   {
  496.     act = (*buffer++) - '0';
  497.   }
  499.   CONSOLE_SCREEN_BUFFER_INFO csbi;
  500.   GetConsoleScreenBufferInfo(stdout1,&csbi);
  502.   COORD pos;
  503.   DWORD n;
  505.   switch(act)
  506.   {
  507.   case 0:
  508.     pos.X = csbi.dwCursorPosition.X;
  509.     pos.Y = csbi.dwCursorPosition.Y;
  510.     n = csbi.dwSize.X*csbi.dwSize.Y;
  511.     break;
  512.   case 2:
  513.     pos.X = 0;
  514.     pos.Y = 0;
  515.     n = csbi.dwSize.X*csbi.dwSize.Y;
  516.     break;
  517.   }
  519.   DWORD w;
  520.   FillConsoleOutputCharacter(stdout1,' ',n,pos,&w);
  521.   SetConsoleCursorPosition(stdout1,pos);
  522. }
  523. void ansi_move_up(char* buffer)
  524. {
  525.   int cnt = *buffer?0:1;
  526.   while(*buffer)
  527.   {
  528.     cnt = cnt*10 + (*buffer++) - '0';
  529.   }
  531.   COORD pos;
  533.   CONSOLE_SCREEN_BUFFER_INFO csbi;
  534.   GetConsoleScreenBufferInfo(stdout1,&csbi);
  536.   pos.X = csbi.dwCursorPosition.X;
  537.   pos.Y = ((csbi.dwCursorPosition.Y-cnt)>=0)?(csbi.dwCursorPosition.Y-cnt):0;
  539.   SetConsoleCursorPosition(stdout1,pos);
  540. }
  541. void ansi(SOCKET server,unsigned char data)
  542. {
  543.   static _ansi_state state = as_normal;
  544.   DWORD z;
  545.   switch( state)
  546.   {
  547.   case as_normal:
  548.     switch(data)
  549.     {
  550.     case 0:  //eat null codes.
  551.       break;
  552.     case 27: //ANSI esc.
  553.       state = as_esc;
  554.       break;
  555.     default: //Send all else to the console.
  556.       WriteConsole(stdout1,&data,1,&z,NULL);
  557.       break;
  558.     }
  559.     break;
  560.   case as_esc:
  561.     state = as_esc1;
  562.     codeptr=0;
  563.     codebuf[codeptr] = 0;
  564.     break;
  565.   case as_esc1:
  566.     if(data > 64)
  567.     {
  568.       codebuf[codeptr] = 0;
  569.       for(int i=0; codec[i].cmd && codec[i].cmd != data; i++);
  570.       if(codec[i].proc)
  571.         codec[i].proc(codebuf);
  572. #ifdef _DEBUG
  573.       else
  574.       {
  575.         char buf[256];
  576.         wsprintf(buf,"Unknown Ansi code:'%c' (%s)n",data,codebuf);
  577.         OutputDebugString(buf);
  578.       }
  579. #endif
  580.       state = as_normal;
  581.     }
  582.     else
  583.       codebuf[codeptr++] = data;
  584.     break;
  585.   }
  586. }