woe/telnet/telnet.go

package telnet

// import "bytes"
import "io"
import "strings"
import "fmt"
import "compress/zlib"
import "github.com/beoran/woe/monolog"


// This Telnet module implements a subset of the Telnet protocol.

// Telnet states
type TelnetState int

const (
    data_state TelnetState  = iota
    iac_state               = iota
    will_state              = iota
    wont_state              = iota
    do_state                = iota
    dont_state              = iota
    sb_state                = iota
    sb_data_state           = iota
    sb_data_iac_state       = iota
)

// Telnet event type constants
type EventType int

const (
    TELNET_DATA_EVENT           EventType =  iota
    TELNET_NAWS_EVENT           EventType =  iota
    TELNET_TTYPE_EVENT          EventType =  iota
    TELNET_SUBNEGOTIATE_EVENT   EventType =  iota
    TELNET_IAC_EVENT            EventType =  iota
    TELNET_COMPRESS_EVENT       EventType =  iota
    TELNET_ENVIRONMENT_EVENT    EventType =  iota
    TELNET_MSSP_EVENT           EventType =  iota
    TELNET_ZMP_EVENT            EventType =  iota
    TELNET_WILL_EVENT           EventType =  iota
    TELNET_WONT_EVENT           EventType =  iota
    TELNET_DO_EVENT             EventType =  iota
    TELNET_DONT_EVENT           EventType =  iota
    TELNET_ERROR_EVENT          EventType =  iota
    TELNET_UNKNOWN_EVENT        EventType =  iota
)

// Telnet event types

type Event interface {
    Type() EventType
}

type DataEvent struct {
    Data [] byte
}

func (me DataEvent) Type() EventType { return TELNET_DATA_EVENT; }

type NAWSEvent struct {
    W   int
    H   int
}

func (me NAWSEvent) Type() EventType { return TELNET_NAWS_EVENT; }


type TTypeEvent struct {
    Telopt  byte
    Name    string
}

func (me TTypeEvent) Type() EventType { return TELNET_TTYPE_EVENT; }


type SubnegotiateEvent struct {
    Telopt    byte
    Buffer [] byte
}

func (me SubnegotiateEvent) Type() EventType { return TELNET_SUBNEGOTIATE_EVENT; }


type IACEvent struct {
    Telopt    byte
}

func (me IACEvent) Type() EventType { return TELNET_IAC_EVENT; }


type CompressEvent struct {
    Compress  bool
}

func (me CompressEvent) Type() EventType { return TELNET_COMPRESS_EVENT; }


// Storage for environment values
type Environment struct {
    Type byte
    Value string
}


type EnvironmentEvent struct {
    Telopt    byte
    Vars      [] Environment
}

func (me EnvironmentEvent) Type() EventType { return TELNET_ENVIRONMENT_EVENT; }


type MSSPEvent struct {
    Telopt    byte
    Vars      map[string] string
}

func (me MSSPEvent) Type() EventType { return TELNET_MSSP_EVENT; }


type ZMPEvent struct {
    Vars      []string
}

func (me ZMPEvent) Type() EventType { return TELNET_ZMP_EVENT; }

type WillEvent struct {
    Telopt byte
}

func (me WillEvent) Type() EventType { return TELNET_WILL_EVENT; }

type WontEvent struct {
    Telopt byte
}

func (me WontEvent) Type() EventType { return TELNET_WONT_EVENT; }


type DoEvent struct {
    Telopt byte
}

func (me DoEvent) Type() EventType { return TELNET_DO_EVENT; }

type DontEvent struct {
    Telopt byte
}

func (me DontEvent) Type() EventType { return TELNET_DONT_EVENT; }


// For protocol errors.
type ErrorEvent struct {
    error string
}

func (me ErrorEvent) Type() EventType { return TELNET_ERROR_EVENT; }


// Returns the numerical event type of an event. Useful for direct comparison.
func EventTypeOf(event Event) EventType {
    return event.Type()
}

// Returns true if the event is of the given type, or false if not
func IsEventType(event Event, typ EventType) bool {
    return EventTypeOf(event) == typ;
}

type EventChannel chan(Event)


type Telopt struct {
    telopt byte
    us     byte
    him    byte
}
    
type Telnet struct { 
  Events            EventChannel
  ToClient          chan([]byte)
  telopts map[byte] Telopt
  state             TelnetState
  compress          bool
  zwriter           zlib.Writer
  zreader           io.ReadCloser
  buffer          []byte
  sb_telopt         byte
}

func New() (telnet * Telnet) {
    events     := make(EventChannel, 64)
    toclient   := make(chan([]byte), 64)
    telopts    := make (map[byte] Telopt)
    state      := data_state
    compress   := false
    var zwriter zlib.Writer
    var zreader io.ReadCloser
    var buffer []byte = nil
    sb_telopt  := byte(0)
    telnet      = &Telnet { events, toclient, telopts, state, compress, zwriter, zreader, buffer, sb_telopt }
    return telnet
}

// Starts compresssion
func (me * Telnet) StartCompression() {
    // XXX implement compression.
    // var zwbuf  bytes.Buffer
    // me.zwriter = zlib.NewWriter(&zwbuf);
}
  
// Closes the telnet connection, send last compressed data if needed.
func (me * Telnet) Close() { 
    if me.compress  {
        me.zwriter.Close()
        me.zreader.Close()    
    }
}

// Filters raw text, only compressing it if needed. 
func (me * Telnet) SendRaw(in []byte) {
    // XXX Handle compression here later
    me.ToClient <- in
} 

// Filters text, escaping IAC bytes. 
func (me * Telnet) SendEscaped(in []byte) {
    buffer := make([]byte, len(in) * 2, len(in) * 2) 
    outdex := 0
    /* Double IAC characters to escape them. */
    for index := 0; index < len(in) ; index++ {
        now := in[index]
        if now == TELNET_IAC {
            buffer[outdex] = TELNET_IAC; 
            outdex++;    
        }
        buffer[outdex] = now;
        outdex++;
    }
    me.SendRaw(buffer)
} 

// Send negotiation bytes
func (me * Telnet) SendNegotiate(cmd byte, telopt byte) {
    buffer      := make([]byte, 3)
    buffer[0]    = TELNET_IAC
    buffer[1]    = cmd
    buffer[2]    = telopt
    me.SendRaw(buffer)
}

func (me * Telnet) SendEvent(event Event) {
    me.Events <- event
}
   
// Parse a subnegotiation buffer for a naws event
func (me * Telnet) SubnegotiateNAWS(buffer []byte) {
    // Some clients, like Gnome-Mud can't even get this right. Grrr!
    if buffer == nil || len(buffer) != 4 {
      monolog.Warning("Bad NAWS negotiation: #{buffer}")
      return
    }
    var w int   = (int(buffer[0]) << 8) + int(buffer[1])
    var h int   = (int(buffer[2]) << 8) + int(buffer[3])
    me.SendEvent(&NAWSEvent{w, h})
}

// process an ENVIRON/NEW-ENVIRON subnegotiation buffer
func (me * Telnet) SubnegotiateEnviron(buffer []byte) {
    var vars []Environment
    var cmd []byte
    fb   := buffer[0]  
    // First byte must be a valid command 
    if fb != TELNET_ENVIRON_SEND && fb != TELNET_ENVIRON_IS && fb != TELNET_ENVIRON_INFO {
      monolog.Warning("telopt environment subneg command not valid")
    }
    
    cmd = append(cmd, fb)   
    
    if len(buffer) == 1 { 
      me.SendEvent(&EnvironmentEvent{fb, vars})
      return
    }
        
    // Second byte must be VAR or USERVAR, if present
    sb := buffer[1]
    if sb != TELNET_ENVIRON_VAR && fb != TELNET_ENVIRON_USERVAR {
      monolog.Warning("telopt environment subneg missing variable type")
      return
    }
    
    // ensure last byte is not an escape byte (makes parsing later easier) 
    lb := buffer[len(buffer) - 1]
    if lb == TELNET_ENVIRON_ESC {
      monolog.Warning("telopt environment subneg ends with ESC")
      return
    }

/* XXX : not implemented yet
    var variable * Environment = nil
    index           := 1
    escape          := false
    
    for index := 1 ; index < len(buffer) ; index++ {
      c := buffer[index]  
      switch c {
        case TELNET_ENVIRON_VAR: 
            fallthrough
        case TELNET_ENVIRON_VALUE:
            fallthrough
        case TELNET_ENVIRON_USERVAR:
            if escape {
                escape = false
                variable.Value  = append(variable.Value, c)
            } else if (variable != nil) {
                vars            = append(vars, variable)
                variable        = new(Environment)
                variable.Type   = c
            } else {
                variable        = new(Environment)
                variable.Type   = c
            }
      case TELNET_ENVIRON_ESC:
        escape = true
      default:
        variable.Value = append(variable.Value, c)
      }
    }
    // Finally send event
    me.SendEvent(&EnvironmentEvent{fb, vars})
*/
}


const (
    MSTATE_NONE = 0
    MSTATE_VAR  = 1
    MSTATE_VAL  = 2
)

// process an MSSP subnegotiation buffer
func (me * Telnet) SubnegotiateMSSP(buffer []byte) {
    if len(buffer) < 1 {
        return
    }
  
    fb    := buffer[0]  
    // first byte must be a valid command
    if fb != TELNET_MSSP_VAR {
        monolog.Warning("telopt MSSP subneg data not valid")
        return
    }
  
    variables := make(map[string] string)
    var variable []byte
    var value []byte
    mstate := MSTATE_NONE
    
    for index := 0 ; index <  len(buffer) ; index ++ {
        c     := buffer[index]
        
        switch c {
            case TELNET_MSSP_VAR:
            mstate = MSTATE_VAR
            if mstate == MSTATE_VAR {
                variables[string(variable)] = string(value)
                variable = nil
                value    = nil
            }
            case TELNET_MSSP_VAL:
                mstate = MSTATE_VAL
            default:
                if mstate == MSTATE_VAL {
                    variable = append(variable, c)
                } else {
                    value = append(value, c)
                }  
        }
    }
    me.SendEvent(&MSSPEvent{fb, variables})
}


// Parse ZMP command subnegotiation buffers 
func (me * Telnet) SubnegotiateZMP(buffer []byte) {
  var vars []string
  var variable []byte
  var b byte
  for index := 0 ; index < len(buffer) ; index++ {
      b = buffer[index]
      if b == 0 {
        vars     = append(vars, string(variable))
        variable = nil
      } else {
        variable = append(variable, b)
      }  
  }
  me.SendEvent(&ZMPEvent{vars})
}

// parse TERMINAL-TYPE command subnegotiation buffers
func (me * Telnet) SubnegotiateTType(buffer []byte) {
  // make sure request is not empty
  if len(buffer) == 0 {
    monolog.Warning("Incomplete TERMINAL-TYPE request");
    return 
  }
  
  fb    := buffer[0]
  if fb != TELNET_TTYPE_IS && fb != TELNET_TTYPE_SEND {
    monolog.Warning("TERMINAL-TYPE request has invalid type %d (%v)", fb, buffer)
    return
  }
  
  term := string(buffer[1:])
  me.SendEvent(&TTypeEvent{fb, term})
}


// process a subnegotiation buffer; returns true if the current buffer
// must be aborted and reprocessed due to COMPRESS2 being activated
func (me * Telnet) DoSubnegotiate(buffer []byte) bool {
    switch me.sb_telopt {
        case TELNET_TELOPT_COMPRESS2:
        // received COMPRESS2 begin marker, setup our zlib box and
        // start handling the compressed stream if it's not already.
        me.compress = true
        me.SendEvent(&CompressEvent{me.compress})
        return true
        // specially handled subnegotiation telopt types
        case TELNET_TELOPT_TTYPE:
            me.SubnegotiateTType(buffer)
        case TELNET_TELOPT_ENVIRON:
            me.SubnegotiateEnviron(buffer)
        case TELNET_TELOPT_NEW_ENVIRON:
            me.SubnegotiateEnviron(buffer)
        case TELNET_TELOPT_MSSP:
            me.SubnegotiateMSSP(buffer)
        case TELNET_TELOPT_NAWS:
            me.SubnegotiateNAWS(buffer)
        case TELNET_TELOPT_ZMP:
            me.SubnegotiateZMP(buffer)
        default:    
            // Send catch all subnegotiation event
            me.SendEvent(&SubnegotiateEvent{me.sb_telopt, buffer})
    }
    return false
}

func (me * Telnet) DoNegotiate(state TelnetState, telopt byte) bool {
    switch me.state {
        case will_state:
            me.SendEvent(&WillEvent{telopt})
        case wont_state:
            me.SendEvent(&WontEvent{telopt})
        case do_state:
            me.SendEvent(&DoEvent{telopt})
        case dont_state:
            me.SendEvent(&DontEvent{telopt})
        default:
            monolog.Warning("State not vvalid in  telnet negotiation.")
    }
    me.state = data_state
    return false
}

// Send the current buffer as a DataEvent if it's not empty
// Also empties the buffer if it wasn't emmpty
func (me * Telnet) maybeSendDataEventAndEmptyBuffer() {
    if (me.buffer != nil) && (len(me.buffer) > 0) {
        me.SendEvent(&DataEvent{me.buffer})
        me.buffer = nil
    }
}

// Append a byte to the data buffer
func (me * Telnet) appendByte(bin byte) {
    monolog.Log("TELNET", "Appending to telnet buffer: %d %d", len(me.buffer), cap(me.buffer))
    me.buffer = append(me.buffer, bin)
}

// Process a byte in the data state 
func (me * Telnet) dataStateProcessByte(bin byte) bool {
    if bin == TELNET_IAC {
        // receive buffered bytes as data and go to IAC state if it's notempty
        me.maybeSendDataEventAndEmptyBuffer()
        me.state = iac_state
    } else {
        me.appendByte(bin)
    }
    return false
}

// Process a byte in the IAC state 
func (me * Telnet) iacStateProcessByte(bin byte) bool {
    switch bin {
      // subnegotiation
      case TELNET_SB:
        me.state = sb_state
      // negotiation commands
      case TELNET_WILL:
        me.state = will_state
      case TELNET_WONT:
        me.state = wont_state
      case TELNET_DO:
        me.state = do_state
      case TELNET_DONT:
        me.state = dont_state
      // IAC escaping
      case TELNET_IAC:
        me.appendByte(TELNET_IAC)
        me.maybeSendDataEventAndEmptyBuffer()
        me.state = data_state
      // some other command
      default:
        me.SendEvent(IACEvent { bin })
        me.state = data_state
    }
    return false      
}


// Process a byte in the subnegotiation data state 
func (me * Telnet) sbdataStateProcessByte(bin byte) bool {
    // IAC command in subnegotiation -- either IAC SE or IAC IAC
    if (bin == TELNET_IAC)  {
        me.state = sb_data_iac_state
    } else if me.sb_telopt == TELNET_TELOPT_COMPRESS &&  bin == TELNET_WILL {
        // MCCPv1 defined an invalid subnegotiation sequence (IAC SB 85 WILL SE) 
        // to start compression. Catch and discard this case, only support 
        // MMCPv2.
        me.state = data_state
    } else {
        me.appendByte(bin)
    }
    return false
}

// Process a byte in the IAC received when processing subnegotiation data state 
func (me * Telnet) sbdataiacStateProcessByte(bin byte) bool {
    switch bin { 
        //end subnegotiation
        case TELNET_SE:
        me.state = data_state
        // process subnegotiation
        compress := me.DoSubnegotiate(me.buffer)
        // if compression was negotiated, the rest of the stream is compressed
        // and processing it requires decompressing it. Return true to signal 
        // this.
        me.buffer = nil
        if compress {
            return true 
        }
            
        // escaped IAC byte
        case TELNET_IAC:
        // push IAC into buffer
        me.appendByte(bin)
        me.state = sb_data_state
        // something else -- protocol error.  attempt to process
        // content in subnegotiation buffer, then evaluate the
        // given command as an IAC code.
        default:
        monolog.Warning("Unexpected byte after IAC inside SB: %d", bin)
        me.state = iac_state
        // subnegotiate with the buffer anyway, even though it's an error
        compress := me.DoSubnegotiate(me.buffer)
        // if compression was negotiated, the rest of the stream is compressed
        // and processing it requires decompressing it. Return true to signal 
        // this.
        me.buffer = nil
        if compress {
            return true 
        }
    }
    return false    
}


// Process a single byte received from the client 
func (me * Telnet) ProcessByte(bin byte) bool {
    monolog.Log("TELNET", "ProcessByte %d %d", bin, me.state)
    switch me.state {
    // regular data
        case data_state:
        return me.dataStateProcessByte(bin)
    // IAC received before
        case iac_state:
        return me.iacStateProcessByte(bin)
        case will_state, wont_state, do_state, dont_state:
        return me.DoNegotiate(me.state, bin)
        // subnegotiation started, determine option to subnegotiate
        case sb_state:
        me.sb_telopt = bin      
        me.state     = sb_data_state
        // subnegotiation data, buffer bytes until the end request 
        case sb_data_state:
        return me.sbdataStateProcessByte(bin)
        // IAC received inside a subnegotiation
        case sb_data_iac_state:
        return me.sbdataiacStateProcessByte(bin)
        default:
            //  programing error, shouldn't happen
            panic("Error in telnet state machine!")        
    }
    // return false to signal compression needn't start
    return false
}
 
// Process multiple bytes received from the client
func (me * Telnet) ProcessBytes(bytes []byte) {
    for index := 0 ; index < len(bytes) ; {
        bin := bytes[index]
        compress := me.ProcessByte(bin)
        if compress {
            // paper over this for a while... 
            // new_bytes = Zlib.inflate(arr.pack('c*')) rescue nil
            // if new_bytes
            //arr = new_bytes.bytes.to_a
        }
        index ++
    }
    me.maybeSendDataEventAndEmptyBuffer()
}

  
// Call this when the server receives data from the client
func (me * Telnet) TelnetReceive(data []byte) {
// the COMPRESS2 protocol seems to be half-duplex in that only 
// the server's data stream is compressed (unless maybe if the client
// is asked to also compress with a DO command ?)
    me.ProcessBytes(data)
}

// Send a bytes array (raw) to the client
func (me * Telnet) TelnetSendBytes(bytes ...byte) {
    me.SendRaw(bytes)
}

// Send an iac command 
func (me * Telnet) TelnetSendIac(cmd byte) {
    me.TelnetSendBytes(TELNET_IAC, cmd)
}

// Send negotiation. Currently rfc1143 is not implemented, so beware of 
// server client loops. The simplest way to avoid those is to never answer any 
// client requests, only send server requests.
func (me * Telnet) TelnetSendNegotiate(cmd byte, telopt byte) {
    me.TelnetSendBytes(TELNET_IAC, cmd, telopt)
}
        
// Send non-command data (escapes IAC bytes)
func (me * Telnet) TelnetSend(buffer []byte) {
    me.SendEscaped(buffer)
}
  
// send subnegotiation header
func (me * Telnet) TelnetBeginSubnegotiation(telopt byte) {
    me.TelnetSendBytes(TELNET_IAC, TELNET_SB, telopt)
}


// send subnegotiation ending
func (me * Telnet) TelnetEndSubnegotiation() {
    me.TelnetSendBytes(TELNET_IAC, TELNET_SE)
}

// Send complete subnegotiation
func (me * Telnet) TelnetSubnegotiation(telopt byte, buffer []byte) {
    me.TelnetBeginSubnegotiation(telopt)
    if buffer != nil {
        me.TelnetSend(buffer) 
    }
    me.TelnetEndSubnegotiation()
}
  
// Ask client to start accepting compress2 compression
func (me * Telnet) TelnetBeginCompress2() {
    me.TelnetSendBytes(TELNET_IAC, TELNET_SB, TELNET_TELOPT_COMPRESS2, TELNET_IAC, TELNET_SE);
    me.compress = true
}

// Send formatted data to the client
func (me * Telnet) TelnetRawPrintf(format string, args ...interface{}) {
    buf  := fmt.Sprintf(format, args...)
    me.TelnetSend([]byte(buf))
}

const CRLF  = "\r\n"
const CRNUL = "\r\000"
  
// send formatted data with \r and \n translation in addition to IAC IAC 
// escaping
func (me * Telnet) TelnetPrintf(format string, args ...interface{}) {
    buf  := fmt.Sprintf(format, args...)
    buf   = strings.Replace(buf, "\r", CRNUL, -1)
    buf   = strings.Replace(buf, "\n", CRLF , -1)
    me.TelnetSend([]byte(buf))
}

// NEW-ENVIRON subnegotation
func (me * Telnet) TelnetNewenviron(cmd []byte) {
    me.TelnetSubnegotiation(TELNET_TELOPT_NEW_ENVIRON, cmd)
}

// send TERMINAL-TYPE SEND command
func (me * Telnet)  TelnetTTypeSend() {
    me.TelnetSendBytes(TELNET_IAC, TELNET_SB, TELNET_TELOPT_TTYPE, TELNET_TTYPE_SEND, TELNET_IAC, TELNET_SE)
}

// send TERMINAL-TYPE IS command 
func (me * Telnet)  TelnetTTypeIS(ttype string) {
    me.TelnetSendBytes(TELNET_IAC, TELNET_SB, TELNET_TELOPT_TTYPE, TELNET_TTYPE_IS)
    me.TelnetSend([]byte(ttype))
}

// send MSSP data
func (me * Telnet) TelnetSendMSSP(mssp map[string] string) {
    var buf []byte 
    for key, val := range mssp { 
      buf = append(buf, TELNET_MSSP_VAR)
      buf = append(buf, key...)
      buf = append(buf, TELNET_MSSP_VAL)
      buf = append(buf, val...)
    }
    me.TelnetSubnegotiation(TELNET_TELOPT_MSSP, buf)
}