telnet.h

mgcp协议源代码。支持多种编码：g711

      HorizTabDisposition = 12,   // Negotiate about horizontal tab disposition
      FormFeedDisposition = 13,   // Negotiate about formfeed disposition.
      VerticalTabStops    = 14,   // Negotiate about vertical tab stops.
      VertTabDisposition  = 15,   // Negotiate about vertical tab disposition.
      LineFeedDisposition = 16,   // Negotiate about output LF disposition.
      ExtendedASCII       = 17,   // Extended ascic character set.
      ForceLogout         = 18,   // Force logout.
      ByteMacroOption     = 19,   // Byte macro.
      DataEntryTerminal   = 20,   // data entry terminal.
      SupDupProtocol      = 21,   // supdup protocol.
      SupDupOutput        = 22,   // supdup output.
      SendLocation        = 23,   // Send location.
      TerminalType        = 24,   // Provide terminal type information.
      EndOfRecordOption   = 25,   // Record boundary marker.
      TACACSUID           = 26,   // TACACS user identification.
      OutputMark          = 27,   // Output marker or banner text.
      TerminalLocation    = 28,   // Terminals physical location infromation.
      Use3270RegimeOption = 29,   // 3270 regime.
      UseX3PADOption      = 30,   // X.3 PAD
      WindowSize          = 31,   // NAWS - Negotiate About Window Size.
      TerminalSpeed       = 32,   // Provide terminal speed information.
      FlowControl         = 33,   // Remote flow control.
      LineModeOption      = 34,   // Terminal in line mode option.
      XDisplayLocation    = 35,   // X Display location.
      EnvironmentOption   = 36,   // Provide environment information.
      AuthenticateOption  = 37,   // Authenticate option.
      EncriptionOption    = 38,	  // Encryption option.
      ExtendedOptionsList = 255,  // Code for extended options.
      MaxOptions
    };
    // Defined TELNET options.


    /** Send DO request.

       @return
       TRUE if the command was successfully sent.
     */
    virtual BOOL SendDo(
      BYTE option    // Option to DO
    );

    /** Send DONT command.

       @return
       TRUE if the command was successfully sent.
     */
    virtual BOOL SendDont(
      BYTE option    // Option to DONT
    );

    /** Send WILL request.

       @return
       TRUE if the command was successfully sent.
     */
    virtual BOOL SendWill(
      BYTE option    // Option to WILL
    );

    /** Send WONT command.

       @return
       TRUE if the command was successfully sent.
     */
    virtual BOOL SendWont(
      BYTE option    // Option to WONT
    );

    enum SubOptionCodes {
      SubOptionIs       = 0,  // Sub-option is...
      SubOptionSend     = 1,  // Request to send option.
    };
    // Codes for sub option negotiation.

    /** Send a sub-option with the information given.

       @return
       TRUE if the command was successfully sent.
     */
    BOOL SendSubOption(
      BYTE code,          // Suboptions option code.
      const BYTE * info,  // Information to send.
      PINDEX len,         // Length of information.
      int subCode = -1    // Suboptions sub-code, -1 indicates no sub-code.
    );

    /** Set if the option on our side is possible, this does not mean it is set
       it only means that in response to a DO we WILL rather than WONT.
     */
    void SetOurOption(
      BYTE code,          // Option to check.
      BOOL state = TRUE   // New state for for option.
    ) { option[code].weCan = state; }

    /** Set if the option on their side is desired, this does not mean it is set
       it only means that in response to a WILL we DO rather than DONT.
     */
    void SetTheirOption(
      BYTE code,          // Option to check.
      BOOL state = TRUE  // New state for for option.
    ) { option[code].theyShould = state; }

    /** Determine if the option on our side is enabled.

       @return
       TRUE if option is enabled.
     */
    BOOL IsOurOption(
      BYTE code    // Option to check.
    ) const { return option[code].ourState == OptionInfo::IsYes; }

    /** Determine if the option on their side is enabled.

       @return
       TRUE if option is enabled.
     */
    BOOL IsTheirOption(
      BYTE code    // Option to check.
    ) const { return option[code].theirState == OptionInfo::IsYes; }

    void SetTerminalType(
      const PString & newType   // New terminal type description string.
    );
    // Set the terminal type description string for TELNET protocol.

    const PString & GetTerminalType() const { return terminalType; }
    // Get the terminal type description string for TELNET protocol.

    void SetWindowSize(
      WORD width,   // New window width.
      WORD height   // New window height.
    );
    // Set the width and height of the Network Virtual Terminal window.

    void GetWindowSize(
      WORD & width,   // Old window width.
      WORD & height   // Old window height.
    ) const;
    // Get the width and height of the Network Virtual Terminal window.


  protected:
    void Construct();
    // Common construct code for TELNET socket channel.

    /** This callback function is called by the system when it receives a DO
       request from the remote system.
       
       The default action is to send a WILL for options that are understood by
       the standard TELNET class and a WONT for all others.

       @return
       TRUE if option is accepted.
     */
    virtual void OnDo(
      BYTE option   // Option to DO
    );

    /** This callback function is called by the system when it receives a DONT
       request from the remote system.
       
       The default action is to disable options that are understood by the
       standard TELNET class. All others are ignored.
     */
    virtual void OnDont(
      BYTE option   // Option to DONT
    );

    /** This callback function is called by the system when it receives a WILL
       request from the remote system.
       
       The default action is to send a DO for options that are understood by
       the standard TELNET class and a DONT for all others.
     */
    virtual void OnWill(
      BYTE option   // Option to WILL
    );

    /** This callback function is called by the system when it receives a WONT
       request from the remote system.

       The default action is to disable options that are understood by the
       standard TELNET class. All others are ignored.
     */
    virtual void OnWont(
      BYTE option   // Option to WONT
    );

    /** This callback function is called by the system when it receives a
       sub-option command from the remote system.
     */
    virtual void OnSubOption(
      BYTE code,          // Option code for sub-option data.
      const BYTE * info,  // Extra information being sent in the sub-option.
      PINDEX len          // Number of extra bytes.
    );


    /** This callback function is called by the system when it receives an
       telnet command that it does not do anything with.

       The default action displays a message to the <A>PError</A> stream
       (when <CODE>debug</CODE> is TRUE) and returns TRUE;

       @return
       TRUE if next byte is not part of the command.
     */
    virtual BOOL OnCommand(
      BYTE code  // Code received that could not be precessed.
    );


  // Member variables.
    struct OptionInfo {
      enum {
        IsNo, IsYes, WantNo, WantNoQueued, WantYes, WantYesQueued
      };
      unsigned weCan:1;      // We can do the option if they want us to do.
      unsigned ourState:3;
      unsigned theyShould:1; // They should if they will.
      unsigned theirState:3;
    };
    
    OptionInfo option[MaxOptions];
    // Information on protocol options.

    PString terminalType;
    // Type of terminal connected to telnet socket, defaults to "UNKNOWN"

    WORD windowWidth, windowHeight;
    // Size of the "window" used by the NVT.

    BOOL debug;
    // Debug socket, output messages to PError stream.


  private:
    enum State {
      StateNormal,
      StateCarriageReturn,
      StateIAC,
      StateDo,
      StateDont,
      StateWill,
      StateWont,
      StateSubNegotiations,
      StateEndNegotiations
    };
    // Internal states for the TELNET decoder

    State state;
    // Current state of incoming characters.

    PBYTEArray subOption;
    // Storage for sub-negotiated options

    unsigned synchronising;

    BOOL StartSend(const char * which, BYTE code);
};


#endif


// End Of File ///////////////////////////////////////////////////////////////