Gammon Forum

#include <string.h>
#include <stdio.h>
#include <anachronism/nvt.h>


typedef struct gmcp_data
{
  telnet_channel* channel;
} gmcp_data;

// This is called when the option is negotiated on (DO/WILL) or off (DONT/WONT).
void on_gmcp_toggle(telnet_channel* channel,
                    telnet_channel_mode on,
                    telnet_channel_provider who)
{
  // Get the gmcp_data object back from the channel.
  if (on)
  {
    if (who == TELNET_CHANNEL_LOCAL)
    {
      const telnet_byte* data = "Foo.Bar [4, 5, 6]";
      telnet_channel_send(channel, data, strlen(data));
    }
  }
}

// This is called for IAC SB <option>, IAC SE, and any data between the two.
void on_gmcp_data(telnet_channel* channel,
                  telnet_channel_event type,
                  const telnet_byte* data,
                  size_t length)
{
  // Get the gmcp_data object back from the channel.
  gmcp_data* gmcp = NULL;
  telnet_channel_get_userdata(channel, (void**)&gmcp);
  
  switch (type)
  {
    case TELNET_CHANNEL_EV_BEGIN:
      printf("<GMCP>\n");
      break;
    case TELNET_CHANNEL_EV_END:
      printf("</GMCP>\n");
      break;
    case TELNET_CHANNEL_EV_DATA:
      printf("[GMCP] %.*s\n", length, data);
      break;
  }
}

gmcp_data* gmcp_new(telnet_channel** out)
{
  gmcp_data* gmcp = malloc(sizeof(gmcp_data));
  if (gmcp)
  {
    // Create a new channel, hooking it up to our two GMCP event handlers.
    // We store the gmcp_data object with it so we have a context
    // in the event handlers.
    telnet_channel* channel = telnet_channel_new(&on_gmcp_toggle,
                                                 &on_gmcp_data,
                                                 (void*)gmcp);
    if (channel)
    {
      gmcp->channel = channel;
      *out = channel;
    }
    else
    {
      free(gmcp);
      gmcp = NULL;
    }
  }
  
  return gmcp;
}


void on_event(telnet_nvt* nvt, telnet_event* event)
{
  switch (event->type)
  {
    // Command, warning, and send events aren't routed to channels.
    // The others can be processed here as well, but it's not very useful
    // except for logging.
    case TELNET_EV_COMMAND:
      break;
    case TELNET_EV_WARNING:
      break;
    
    // A send event is emitted when the NVT has data to send to the remote host.
    case TELNET_EV_SEND:
    {
      telnet_send_event* ev = (telnet_send_event*)event;
      printf("[OUT] %.*s\n", ev->length, ev->data);
      break;
    }
    
    default:
      // everything else is handled by channels, so we ignore it
      break;
  }
}

int main()
{
  // Create an NVT, routing events to the on_event method.
  // We're not storing any extra data with this NVT.
  telnet_nvt* nvt = telnet_nvt_new(&on_event, NULL);
  
  // Create a Telnet channel for GMCP.
  telnet_channel* channel = NULL;
  gmcp_data* gmcp = gmcp_new(&channel);
  
  // Bind the GMCP channel to option 201.
  // The two final parameters are comparable to WILL/WONT and DO/DONT.
  // In this case, we WILL offer GMCP, but we DONT want the client to offer it.
  //
  // TELNET_CHANNEL_LAZY is also available. In this mode, we only accept
  // if the remote host asks first. This is useful for clients, as
  // some MUDs don't understand Telnet very well. It's best to wait until
  // the server offers a channel before accepting it.
  telnet_channel_register(channel, nvt, 201, TELNET_CHANNEL_ON, TELNET_CHANNEL_OFF);
  
  // Process some "incoming" data.
  const char* data = "\xFF\xFD\xC9"      // IAC DO GMCP
                     "\xFF\xFA\xC9"      // IAC SB GMCP
                     "Foo.Bar [1, 2, 3]" // data
                     "\xFF\xF0";         // IAC SE
  size_t bytes_used;
  telnet_recv(nvt, (const telnet_byte*)data, strlen(data), &bytes_used);
  
  return 0;
}

require "anachronism"
require "eventmachine"
require "zlib"

class MccpChannel < Anachronism::Channel
  # Called when the channel is negotiated open.
  def on_open (where)
    case where
    when :local
      @out = Zlib::Deflate.new
      send ''
    end
  end
  
  # Called when the channel is closed.
  def on_close (where)
    case where
    when :remote
      @in = nil
    when :local
      @out = nil
    end
  end
  
  # Called on IAC SB <option>.
  def on_focus
  end
  
  # Called on IAC SE.
  def on_blur
    @in = Zlib::Inflate.new
    nvt.interrupt(option, 0)
  end
  
  # Called with data from the subnegotiation as it's received.
  def on_data (data)
  end
  
  def inflate (data)
    return data unless @in
    data = @in.inflate(data)
    
    if @in.finished?
      # There may be some uncompressed data after the compressed stream ends,
      # so get that out too.
      data << @in.flush_next_out
      @in = nil
    end
    
    data
  end
  
  def deflate (data)
    return data unless @out
    @out.deflate(data, Zlib::SYNC_FLUSH)
  end
end

class MainChannel < Anachronism::Channel
  def on_data (data)
    print(data)
  end
end

class MudNVT < Anachronism::NVT
  def initialize (sock)
    super()
    @sock = sock
    @mccp = MccpChannel.new
    
    main = MainChannel.new
    main.register(self, :main)
    @mccp.register(self, 86, :local => :false, :remote => :lazy)
  end
  
  def receive (data)
    data = @mccp.inflate(data)
    while true
      bytes_used = super(data)
      break unless bytes_used < data.length
      data = data[bytes_used..-1]
      
      if last_interrupt_code == [86, 0]
        data = @mccp.inflate(data)
      end
    end
  end
  
  def on_send (data)
    @sock.send_data(data)
  end
end

module MyAdapter
  def post_init
    @nvt = MudNVT.new(self)
  end
  
  def receive_data (data)
    @nvt.receive(data)
  end
  
  def << (data)
    @nvt.send_data (data)
  end
end

module InputAdapter
  attr_accessor :out
  
  def receive_data (data)
    data.gsub! "\n", "\r\n"
    out << data
    puts data
  end
end

EventMachine.run do
  sock = EM.connect "localhost", 5445, MyAdapter
  
  adapter = EM.attach $stdin, InputAdapter
  adapter.out = sock
end

#line 74 "src/parser.c"
{
parser->cs = telnet_parser_start;
}

#line 142 "src/parser.rl"
    parser->callback = callback;
    parser->userdata = userdata;
  }
  return parser;
}

    if (parser->callback && parser->buf)
    {
      telnet_option_event ev;
      EV_OPTION(ev, parser->option_mark, (*( parser->p)));
      parser->callback(parser, (telnet_event*)&ev);
    }
  }
goto st8;
st8:
if ( ++( parser->p) == ( parser->pe) )
goto _test_eof8;