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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
telnet.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：22k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

telnet.cxx：源码内容
  1. /*
  2.  * telnet.cxx
  3.  *
  4.  * TELNET socket I/O channel class.
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: telnet.cxx,v $
  30.  * Revision 1.7  1998/11/30 04:52:11  robertj
  31.  * New directory structure
  32.  *
  33.  * Revision 1.6  1998/09/23 06:22:47  robertj
  34.  * Added open source copyright license.
  35.  *
  36.  * Revision 1.5  1998/01/26 02:49:23  robertj
  37.  * GNU support.
  38.  *
  39.  * Revision 1.4  1997/07/14 11:47:18  robertj
  40.  * Added "const" to numerous variables.
  41.  *
  42.  * Revision 1.3  1996/08/08 10:08:48  robertj
  43.  * Directory structure changes for common files.
  44.  *
  45.  * Revision 1.2  1996/05/26 03:47:08  robertj
  46.  * Compatibility to GNU 2.7.x
  47.  *
  48.  * Revision 1.1  1996/03/04 12:12:51  robertj
  49.  * Initial revision
  50.  *
  51.  */
  53. #ifdef __GNUC__
  54. #pragma implementation "telnet.h"
  55. #endif
  57. #include <ptlib.h>
  58. #include <ptlib/sockets.h>
  59. #include <ptclib/telnet.h>
  62. //////////////////////////////////////////////////////////////////////////////
  63. // PTelnetSocket
  65. PTelnetSocket::PTelnetSocket()
  66.   : PTCPSocket("telnet")
  67. {
  68.   Construct();
  69. }
  72. PTelnetSocket::PTelnetSocket(const PString & address)
  73.   : PTCPSocket("telnet")
  74. {
  75.   Construct();
  76.   Connect(address);
  77. }
  80. void PTelnetSocket::Construct()
  81. {
  82.   synchronising = 0;
  83.   terminalType = "UNKNOWN";
  84.   windowWidth = windowHeight = 0;
  85.   state = StateNormal;
  87.   memset(option, 0, sizeof(option));
  88.   SetOurOption(TransmitBinary);
  89.   SetOurOption(SuppressGoAhead);
  90.   SetOurOption(StatusOption);
  91.   SetOurOption(TimingMark);
  92.   SetOurOption(TerminalSpeed);
  93.   SetOurOption(TerminalType);
  94.   SetTheirOption(TransmitBinary);
  95.   SetTheirOption(SuppressGoAhead);
  96.   SetTheirOption(StatusOption);
  97.   SetTheirOption(TimingMark);
  98.   SetTheirOption(EchoOption);
  100. #ifdef _DEBUG
  101.   debug = TRUE;
  102. #endif
  103. }
  106. #define PTelnetError if (debug) PError << "PTelnetSocket: "
  107. #define PDebugError if (debug) PError
  109. BOOL PTelnetSocket::Connect(const PString & host)
  110. {
  111.   PTelnetError << "Connect" << endl;
  113.   if (!PTCPSocket::Connect(host))
  114.     return FALSE;
  116.   SendDo(SuppressGoAhead);
  117.   SendDo(StatusOption);
  118.   SendWill(TerminalSpeed);
  119.   return TRUE;
  120. }
  123. BOOL PTelnetSocket::Accept(PSocket & sock)
  124. {
  125.   if (!PTCPSocket::Accept(sock))
  126.     return FALSE;
  128.   SendDo(SuppressGoAhead);
  129.   SendWill(StatusOption);
  130.   return TRUE;
  131. }
  134. BOOL PTelnetSocket::Write(void const * buffer, PINDEX length)
  135. {
  136.   const BYTE * base = (const BYTE *)buffer;
  137.   const BYTE * next = base;
  138.   int count = 0;
  140.   while (length > 0) {
  141.     if (*next == 'r' &&
  142.             !(length > 1 && next[1] == 'n') && !IsOurOption(TransmitBinary)) {
  143.       // send the characters
  144.       if (!PTCPSocket::Write(base, (next - base) + 1))
  145.         return FALSE;
  146.       count += lastWriteCount;
  148.       char null = '';
  149.       if (!PTCPSocket::Write(&null, 1))
  150.         return FALSE;
  151.       count += lastWriteCount;
  153.       base = next+1;
  154.     }
  156.     if (*next == IAC) {
  157.       // send the characters
  158.       if (!PTCPSocket::Write(base, (next - base) + 1))
  159.         return FALSE;
  160.       count += lastWriteCount;
  161.       base = next;
  162.     }
  164.     next++;
  165.     length--;
  166.   }
  168.   if (next > base) {
  169.     if (!PTCPSocket::Write(base, next - base))
  170.       return FALSE;
  171.     count += lastWriteCount;
  172.   }
  174.   lastWriteCount = count;
  175.   return TRUE;
  176. }
  179. BOOL PTelnetSocket::SendCommand(Command cmd, int opt)
  180. {
  181.   BYTE buffer[3];
  182.   buffer[0] = IAC;
  183.   buffer[1] = (BYTE)cmd;
  185.   switch (cmd) {
  186.     case DO :
  187.     case DONT :
  188.     case WILL :
  189.     case WONT :
  190.       buffer[2] = (BYTE)opt;
  191.       return PTCPSocket::Write(buffer, 3);
  193.     case InterruptProcess :
  194.     case Break :
  195.     case AbortProcess :
  196.     case SuspendProcess :
  197.     case AbortOutput :
  198.       if (opt) {
  199.         // Send the command
  200.         if (!PTCPSocket::Write(buffer, 2))
  201.           return FALSE;
  202.         // Send a TimingMark for output flush.
  203.         buffer[1] = TimingMark;
  204.         if (!PTCPSocket::Write(buffer, 2))
  205.           return FALSE;
  206.         // Send a DataMark for synchronisation.
  207.         if (cmd != AbortOutput) {
  208.           buffer[1] = DataMark;
  209.           if (!PTCPSocket::Write(buffer, 2))
  210.             return FALSE;
  211.           // Send the datamark character as the only out of band data byte.
  212.           if (!WriteOutOfBand(&buffer[1], 1))
  213.             return FALSE;
  214.         }
  215.         // Then flush any waiting input data.
  216.         PTimeInterval oldTimeout = readTimeout;
  217.         readTimeout = 0;
  218.         while (PTCPSocket::Read(buffer, sizeof(buffer)))
  219.           ;
  220.         readTimeout = oldTimeout;
  221.       }
  222.       break;
  224.     default :
  225.       return PTCPSocket::Write(buffer, 2);
  226.   }
  228.   return TRUE;
  229. }
  232. static PString GetTELNETOptionName(PINDEX code)
  233. {
  234.   static const char * const name[] = {
  235.     "TransmitBinary",
  236.     "EchoOption",
  237.     "ReconnectOption",
  238.     "SuppressGoAhead",
  239.     "MessageSizeOption",
  240.     "StatusOption",
  241.     "TimingMark",
  242.     "RCTEOption",
  243.     "OutputLineWidth",
  244.     "OutputPageSize",
  245.     "CRDisposition",
  246.     "HorizontalTabsStops",
  247.     "HorizTabDisposition",
  248.     "FormFeedDisposition",
  249.     "VerticalTabStops",
  250.     "VertTabDisposition",
  251.     "LineFeedDisposition",
  252.     "ExtendedASCII",
  253.     "ForceLogout",
  254.     "ByteMacroOption",
  255.     "DataEntryTerminal",
  256.     "SupDupProtocol",
  257.     "SupDupOutput",
  258.     "SendLocation",
  259.     "TerminalType",
  260.     "EndOfRecordOption",
  261.     "TACACSUID",
  262.     "OutputMark",
  263.     "TerminalLocation",
  264.     "Use3270RegimeOption",
  265.     "UseX3PADOption",
  266.     "WindowSize",
  267.     "TerminalSpeed",
  268.     "FlowControl",
  269.     "LineMode",
  270.     "XDisplayLocation",
  271.     "EnvironmentOption",
  272.     "AuthenticateOption",
  273.     "EncriptionOption"
  274.   };
  276.   if (code < PARRAYSIZE(name))
  277.     return name[code];
  278.   if (code == PTelnetSocket::ExtendedOptionsList)
  279.     return "ExtendedOptionsList";
  280.   return PString(PString::Printf, "Option #%u", code);
  281. }
  284. BOOL PTelnetSocket::StartSend(const char * which, BYTE code)
  285. {
  286.   PTelnetError << which << ' ' << GetTELNETOptionName(code) << ' ';
  287.   if (IsOpen())
  288.     return TRUE;
  290.   PDebugError << "not open yet." << endl;
  291.   osError = EBADF;
  292.   lastError = NotOpen;
  293.   return FALSE;
  294. }
  297. BOOL PTelnetSocket::SendDo(BYTE code)
  298. {
  299.   if (!StartSend("SendDo", code))
  300.     return FALSE;
  302.   OptionInfo & opt = option[code];
  304.   switch (opt.theirState) {
  305.     case OptionInfo::IsNo :
  306.       PDebugError << "initiated.";
  307.       SendCommand(DO, code);
  308.       opt.theirState = OptionInfo::WantYes;
  309.       break;
  311.     case OptionInfo::IsYes :
  312.       PDebugError << "already enabled." << endl;
  313.       return FALSE;
  315.     case OptionInfo::WantNo :
  316.       PDebugError << "queued.";
  317.       opt.theirState = OptionInfo::WantNoQueued;
  318.       break;
  320.     case OptionInfo::WantNoQueued :
  321.       PDebugError << "already queued." << endl;
  322.       opt.theirState = OptionInfo::IsNo;
  323.       return FALSE;
  325.     case OptionInfo::WantYes :
  326.       PDebugError << "already negotiating." << endl;
  327.       opt.theirState = OptionInfo::IsNo;
  328.       return FALSE;
  330.     case OptionInfo::WantYesQueued :
  331.       PDebugError << "dequeued.";
  332.       opt.theirState = OptionInfo::WantYes;
  333.       break;
  334.   }
  336.   PDebugError << endl;
  337.   return TRUE;
  338. }
  341. BOOL PTelnetSocket::SendDont(BYTE code)
  342. {
  343.   if (!StartSend("SendDont", code))
  344.     return FALSE;
  346.   OptionInfo & opt = option[code];
  348.   switch (opt.theirState) {
  349.     case OptionInfo::IsNo :
  350.       PDebugError << "already disabled." << endl;
  351.       return FALSE;
  353.     case OptionInfo::IsYes :
  354.       PDebugError << "initiated.";
  355.       SendCommand(DONT, code);
  356.       opt.theirState = OptionInfo::WantNo;
  357.       break;
  359.     case OptionInfo::WantNo :
  360.       PDebugError << "already negotiating." << endl;
  361.       opt.theirState = OptionInfo::IsNo;
  362.       return FALSE;
  364.     case OptionInfo::WantNoQueued :
  365.       PDebugError << "dequeued.";
  366.       opt.theirState = OptionInfo::WantNo;
  367.       break;
  369.     case OptionInfo::WantYes :
  370.       PDebugError << "queued.";
  371.       opt.theirState = OptionInfo::WantYesQueued;
  372.       break;
  374.     case OptionInfo::WantYesQueued :
  375.       PDebugError << "already queued." << endl;
  376.       opt.theirState = OptionInfo::IsYes;
  377.       return FALSE;
  378.   }
  380.   PDebugError << endl;
  381.   return TRUE;
  382. }
  385. BOOL PTelnetSocket::SendWill(BYTE code)
  386. {
  387.   if (!StartSend("SendWill", code))
  388.     return FALSE;
  390.   if (!IsOpen())
  391.     return FALSE;
  393.   OptionInfo & opt = option[code];
  395.   switch (opt.ourState) {
  396.     case OptionInfo::IsNo :
  397.       PDebugError << "initiated.";
  398.       SendCommand(WILL, code);
  399.       opt.ourState = OptionInfo::WantYes;
  400.       break;
  402.     case OptionInfo::IsYes :
  403.       PDebugError << "already enabled." << endl;
  404.       return FALSE;
  406.     case OptionInfo::WantNo :
  407.       PDebugError << "queued.";
  408.       opt.ourState = OptionInfo::WantNoQueued;
  409.       break;
  411.     case OptionInfo::WantNoQueued :
  412.       PDebugError << "already queued." << endl;
  413.       opt.ourState = OptionInfo::IsNo;
  414.       return FALSE;
  416.     case OptionInfo::WantYes :
  417.       PDebugError << "already negotiating." << endl;
  418.       opt.ourState = OptionInfo::IsNo;
  419.       return FALSE;
  421.     case OptionInfo::WantYesQueued :
  422.       PDebugError << "dequeued.";
  423.       opt.ourState = OptionInfo::WantYes;
  424.       break;
  425.   }
  427.   PDebugError << endl;
  428.   return TRUE;
  429. }
  432. BOOL PTelnetSocket::SendWont(BYTE code)
  433. {
  434.   if (!StartSend("SendWont", code))
  435.     return FALSE;
  437.   OptionInfo & opt = option[code];
  439.   switch (opt.ourState) {
  440.     case OptionInfo::IsNo :
  441.       PDebugError << "already disabled." << endl;
  442.       return FALSE;
  444.     case OptionInfo::IsYes :
  445.       PDebugError << "initiated.";
  446.       SendCommand(WONT, code);
  447.       opt.ourState = OptionInfo::WantNo;
  448.       break;
  450.     case OptionInfo::WantNo :
  451.       PDebugError << "already negotiating." << endl;
  452.       opt.ourState = OptionInfo::IsNo;
  453.       return FALSE;
  455.     case OptionInfo::WantNoQueued :
  456.       PDebugError << "dequeued.";
  457.       opt.ourState = OptionInfo::WantNo;
  458.       break;
  460.     case OptionInfo::WantYes :
  461.       PDebugError << "queued.";
  462.       opt.ourState = OptionInfo::WantYesQueued;
  463.       break;
  465.     case OptionInfo::WantYesQueued :
  466.       PDebugError << "already queued." << endl;
  467.       opt.ourState = OptionInfo::IsYes;
  468.       return FALSE;
  469.   }
  471.   PDebugError << endl;
  472.   return TRUE;
  473. }
  476. BOOL PTelnetSocket::SendSubOption(BYTE code,
  477.                                     const BYTE * info, PINDEX len, int subCode)
  478. {
  479.   if (!StartSend("SendSubOption", code))
  480.     return FALSE;
  482.   PDebugError << "with " << len << " bytes." << endl;
  484.   PBYTEArray buffer(len + 6);
  485.   buffer[0] = IAC;
  486.   buffer[1] = SB;
  487.   buffer[2] = code;
  488.   PINDEX i = 3;
  489.   if (subCode >= 0)
  490.     buffer[i++] = (BYTE)subCode;
  491.   while (len-- > 0) {
  492.     if (*info == IAC)
  493.       buffer[i++] = IAC;
  494.     buffer[i++] = *info++;
  495.   }
  496.   buffer[i++] = IAC;
  497.   buffer[i++] = SE;
  499.   return PTCPSocket::Write((const BYTE *)buffer, i);
  500. }
  503. void PTelnetSocket::SetTerminalType(const PString & newType)
  504. {
  505.   terminalType = newType;
  506. }
  509. void PTelnetSocket::SetWindowSize(WORD width, WORD height)
  510. {
  511.   windowWidth = width;
  512.   windowHeight = height;
  513.   if (IsOurOption(WindowSize)) {
  514.     BYTE buffer[4];
  515.     buffer[0] = (BYTE)(width >> 8);
  516.     buffer[1] = (BYTE)width;
  517.     buffer[2] = (BYTE)(height >> 8);
  518.     buffer[3] = (BYTE)height;
  519.     SendSubOption(WindowSize, buffer, 4);
  520.   }
  521.   else {
  522.     SetOurOption(WindowSize);
  523.     SendWill(WindowSize);
  524.   }
  525. }
  528. void PTelnetSocket::GetWindowSize(WORD & width, WORD & height) const
  529. {
  530.   width = windowWidth;
  531.   height = windowHeight;
  532. }
  535. BOOL PTelnetSocket::Read(void * data, PINDEX bytesToRead)
  536. {
  537.   PBYTEArray buffer(bytesToRead);
  538.   PINDEX charsLeft = bytesToRead;
  539.   BYTE * dst = (BYTE *)data;
  541.   while (charsLeft > 0) {
  542.     BYTE * src = buffer.GetPointer(charsLeft);
  543.     if (!PTCPSocket::Read(src, charsLeft)) {
  544.       lastReadCount = bytesToRead - charsLeft;
  545.       return lastReadCount > 0;
  546.     }
  548.     while (lastReadCount > 0) {
  549.       BYTE currentByte = *src++;
  550.       lastReadCount--;
  551.       switch (state) {
  552.         case StateCarriageReturn :
  553.           state = StateNormal;
  554.           if (currentByte == '')
  555.             break; // Ignore  after CR
  556.           // Else, fall through for normal processing
  558.         case StateNormal :
  559.           if (currentByte == IAC)
  560.             state = StateIAC;
  561.           else {
  562.             if (currentByte == 'r' && !IsTheirOption(TransmitBinary))
  563.               state = StateCarriageReturn;
  564.             *dst++ = currentByte;
  565.             charsLeft--;
  566.           }
  567.           break;
  569.         case StateIAC :
  570.           switch (currentByte) {
  571.             case IAC :
  572.               state = StateNormal;
  573.               *dst++ = IAC;
  574.               charsLeft--;
  575.               break;
  577.             case DO :
  578.               state = StateDo;
  579.               break;
  581.             case DONT :
  582.               state = StateDont;
  583.               break;
  585.             case WILL :
  586.               state = StateWill;
  587.               break;
  589.             case WONT :
  590.               state = StateWont;
  591.               break;
  593.             case DataMark :    // data stream portion of a Synch
  594.               /* We may have missed an urgent notification, so make sure we
  595.                  flush whatever is in the buffer currently.
  596.                */
  597.               PTelnetError << "received DataMark" << endl;
  598.               if (synchronising > 0)
  599.                 synchronising--;
  600.               break;
  602.             case SB :          // subnegotiation start
  603.               state = StateSubNegotiations;
  604.               subOption.SetSize(0);
  605.               break;
  607.             default:
  608.               if (OnCommand(currentByte))
  609.                 state = StateNormal;
  610.               break;
  611.           }
  612.           break;
  614.         case StateDo :
  615.           OnDo(currentByte);
  616.           state = StateNormal;
  617.           break;
  619.         case StateDont :
  620.           OnDont(currentByte);
  621.           state = StateNormal;
  622.           break;
  624.         case StateWill :
  625.           OnWill(currentByte);
  626.           state = StateNormal;
  627.           break;
  629.         case StateWont :
  630.           OnWont(currentByte);
  631.           state = StateNormal;
  632.           break;
  634.         case StateSubNegotiations :
  635.           if (currentByte == IAC)
  636.             state = StateEndNegotiations;
  637.           else
  638.             subOption[subOption.GetSize()] = currentByte;
  639.           break;
  641.         case StateEndNegotiations :
  642.           if (currentByte == SE)
  643.             state = StateNormal;
  644.           else if (currentByte != IAC) {
  645.             /* This is an error.  We only expect to get "IAC IAC" or "IAC SE".
  646.                Several things may have happend.  An IAC was not doubled, the
  647.                IAC SE was left off, or another option got inserted into the
  648.                suboption are all possibilities. If we assume that the IAC was
  649.                not doubled, and really the IAC SE was left off, we could get
  650.                into an infinate loop here.  So, instead, we terminate the
  651.                suboption, and process the partial suboption if we can.
  652.              */
  653.             state = StateIAC;
  654.             src--;  // Go back to character for IAC ccommand
  655.           }
  656.           else {
  657.             subOption[subOption.GetSize()] = currentByte;
  658.             state = StateSubNegotiations;
  659.             break;  // Was IAC IAC, subnegotiation not over yet.
  660.           }
  661.           if (subOption.GetSize() > 1 && IsOurOption(subOption[0]))
  662.             OnSubOption(subOption[0],
  663.                             ((const BYTE*)subOption)+1, subOption.GetSize()-1);
  664.           break;
  666.         default :
  667.           PTelnetError << "illegal state: " << (int)state << endl;
  668.           state = StateNormal;
  669.       }
  670.       if (synchronising > 0) {
  671.         charsLeft = bytesToRead;    // Flush data being received.
  672.         dst = (BYTE *)data;
  673.       }
  674.     }
  675.   }
  676.   lastReadCount = bytesToRead;
  677.   return TRUE;
  678. }
  681. void PTelnetSocket::OnDo(BYTE code)
  682. {
  683.   PTelnetError << "OnDo " << GetTELNETOptionName(code) << ' ';
  685.   OptionInfo & opt = option[code];
  687.   switch (opt.ourState) {
  688.     case OptionInfo::IsNo :
  689.       if (opt.weCan) {
  690.         PDebugError << "WILL.";
  691.         SendCommand(WILL, code);
  692.         opt.ourState = OptionInfo::IsYes;
  693.       }
  694.       else {
  695.         PDebugError << "WONT.";
  696.         SendCommand(WONT, code);
  697.       }
  698.       break;
  700.     case OptionInfo::IsYes :
  701.       PDebugError << "ignored.";
  702.       break;
  704.     case OptionInfo::WantNo :
  705.       PDebugError << "is answer to WONT.";
  706.       opt.ourState = OptionInfo::IsNo;
  707.       break;
  709.     case OptionInfo::WantNoQueued :
  710.       PDebugError << "impossible answer.";
  711.       opt.ourState = OptionInfo::IsYes;
  712.       break;
  714.     case OptionInfo::WantYes :
  715.       PDebugError << "accepted.";
  716.       opt.ourState = OptionInfo::IsYes;
  717.       break;
  719.     case OptionInfo::WantYesQueued :
  720.       PDebugError << "refused.";
  721.       opt.ourState = OptionInfo::WantNo;
  722.       SendCommand(WONT, code);
  723.       break;
  724.   }
  726.   PDebugError << endl;
  728.   if (IsOurOption(code)) {
  729.     switch (code) {
  730.       case TerminalSpeed : {
  731.           static BYTE defSpeed[] = "38400,38400";
  732.           SendSubOption(TerminalSpeed,defSpeed,sizeof(defSpeed)-1,SubOptionIs);
  733.         }
  734.         break;
  736.       case TerminalType :
  737.         SendSubOption(TerminalType,
  738.                           terminalType, terminalType.GetLength(), SubOptionIs);
  739.         break;
  741.       case WindowSize :
  742.         SetWindowSize(windowWidth, windowHeight);
  743.         break;
  744.     }
  745.   }
  746. }
  749. void PTelnetSocket::OnDont(BYTE code)
  750. {
  751.   PTelnetError << "OnDont " << GetTELNETOptionName(code) << ' ';
  753.   OptionInfo & opt = option[code];
  755.   switch (opt.ourState) {
  756.     case OptionInfo::IsNo :
  757.       PDebugError << "ignored.";
  758.       break;
  760.     case OptionInfo::IsYes :
  761.       PDebugError << "WONT.";
  762.       opt.ourState = OptionInfo::IsNo;
  763.       SendCommand(WONT, code);
  764.       break;
  766.     case OptionInfo::WantNo :
  767.       PDebugError << "disabled.";
  768.       opt.ourState = OptionInfo::IsNo;
  769.       break;
  771.     case OptionInfo::WantNoQueued :
  772.       PDebugError << "accepting.";
  773.       opt.ourState = OptionInfo::WantYes;
  774.       SendCommand(DO, code);
  775.       break;
  777.     case OptionInfo::WantYes :
  778.       PDebugError << "queued disable.";
  779.       opt.ourState = OptionInfo::IsNo;
  780.       break;
  782.     case OptionInfo::WantYesQueued :
  783.       PDebugError << "refused.";
  784.       opt.ourState = OptionInfo::IsNo;
  785.       break;
  786.   }
  788.   PDebugError << endl;
  789. }
  792. void PTelnetSocket::OnWill(BYTE code)
  793. {
  794.   PTelnetError << "OnWill " << GetTELNETOptionName(code) << ' ';
  796.   OptionInfo & opt = option[code];
  798.   switch (opt.theirState) {
  799.     case OptionInfo::IsNo :
  800.       if (opt.theyShould) {
  801.         PDebugError << "DO.";
  802.         SendCommand(DO, code);
  803.         opt.theirState = OptionInfo::IsYes;
  804.       }
  805.       else {
  806.         PDebugError << "DONT.";
  807.         SendCommand(DONT, code);
  808.       }
  809.       break;
  811.     case OptionInfo::IsYes :
  812.       PDebugError << "ignored.";
  813.       break;
  815.     case OptionInfo::WantNo :
  816.       PDebugError << "is answer to DONT.";
  817.       opt.theirState = OptionInfo::IsNo;
  818.       break;
  820.     case OptionInfo::WantNoQueued :
  821.       PDebugError << "impossible answer.";
  822.       opt.theirState = OptionInfo::IsYes;
  823.       break;
  825.     case OptionInfo::WantYes :
  826.       PDebugError << "accepted.";
  827.       opt.theirState = OptionInfo::IsYes;
  828.       break;
  830.     case OptionInfo::WantYesQueued :
  831.       PDebugError << "refused.";
  832.       opt.theirState = OptionInfo::WantNo;
  833.       SendCommand(DONT, code);
  834.       break;
  835.   }
  837.   PDebugError << endl;
  838. }
  841. void PTelnetSocket::OnWont(BYTE code)
  842. {
  843.   PTelnetError << "OnWont " << GetTELNETOptionName(code) << ' ';
  845.   OptionInfo & opt = option[code];
  847.   switch (opt.theirState) {
  848.     case OptionInfo::IsNo :
  849.       PDebugError << "ignored.";
  850.       break;
  852.     case OptionInfo::IsYes :
  853.       PDebugError << "DONT.";
  854.       opt.theirState = OptionInfo::IsNo;
  855.       SendCommand(DONT, code);
  856.       break;
  858.     case OptionInfo::WantNo :
  859.       PDebugError << "disabled.";
  860.       opt.theirState = OptionInfo::IsNo;
  861.       break;
  863.     case OptionInfo::WantNoQueued :
  864.       PDebugError << "accepting.";
  865.       opt.theirState = OptionInfo::WantYes;
  866.       SendCommand(DO, code);
  867.       break;
  869.     case OptionInfo::WantYes :
  870.       PDebugError << "refused.";
  871.       opt.theirState = OptionInfo::IsNo;
  872.       break;
  874.     case OptionInfo::WantYesQueued :
  875.       PDebugError << "queued refusal.";
  876.       opt.theirState = OptionInfo::IsNo;
  877.       break;
  878.   }
  880.   PDebugError << endl;
  881. }
  884. void PTelnetSocket::OnSubOption(BYTE code, const BYTE * info, PINDEX len)
  885. {
  886.   PTelnetError << "OnSubOption " << GetTELNETOptionName(code)
  887.                << " of " << len << " bytes." << endl;
  888.   switch (code) {
  889.     case TerminalType :
  890.       if (*info == SubOptionSend)
  891.         SendSubOption(TerminalType,
  892.                           terminalType, terminalType.GetLength(), SubOptionIs);
  893.       break;
  895.     case TerminalSpeed :
  896.       if (*info == SubOptionSend) {
  897.         static BYTE defSpeed[] = "38400,38400";
  898.         SendSubOption(TerminalSpeed,defSpeed,sizeof(defSpeed)-1,SubOptionIs);
  899.       }
  900.       break;
  901.   }
  902. }
  905. BOOL PTelnetSocket::OnCommand(BYTE code)
  906. {
  907.   PTelnetError << "unknown command " << (int)code << endl;
  908.   return TRUE;
  909. }
  911. void PTelnetSocket::OnOutOfBand(const void *, PINDEX length)
  912. {
  913.   PTelnetError << "out of band data received of length " << length << endl;
  914.   synchronising++;
  915. }
  918. // End Of File ///////////////////////////////////////////////////////////////