Proxy

[sandain]

It might be really handy to setup a proxy on the default port (25565) to listen for connections, and pipe the data to the first running world server (say port 25566). If we use netcat and perl, it wouldn't add any new prerequisites to the script.

With the ability to listen in to connections, we could theoretically catch a user typing and redirect the user input to a new command processor like the script used to have when it parsed the log file. With a user command processor in place, and the script already redirecting traffic to one world server, it might be possible to add a switch world server user command to the script. Something I always wanted this script to be able to do.

[sandain]

Some good links needed to decode the Minecraft Protocol:
http://wiki.vg/Protocol
http://en.wikipedia.org/wiki/LEB128

[zanix]

Is this the protocol between the server and client?

[sandain]

Yes

[phlupp]

mabe we can use something like this:
http://voorloopnul.com/blog/a-python-proxy-in-less-than-100-lines-of-code/

[sandain]

I have a working proxy script, it just doesn't do much besides pipe the communication between the server and client to the terminal. I haven't been inspired to work on this in a while, but maybe I'll put some more time into it this weekend (it has been on my mind).

edit: Here is a new version that is starting to understand the handshake portion of the protocol.

#!/bin/sh

CLIENT_PORT=25565
SERVER_PORT=25566
SERVER_IP=127.0.0.1

BACK_PIPE=pipe.back
CLIENT_PIPE=pipe.client
SERVER_PIPE=pipe.server


serverRunning() {
  printf "1"
}

parseProtocol() {
  perl -ne '
    use warnings;
    my $raw = $_;
    my $type = "'$1'";

    sub unpackShort {
      my ($input) = @_;
      my $length = 2;
      my $result = unpack ("s>", $$input);
      substr ($$input, 0, $length, "");
      return $result;
    }

    sub unpackString {
      my ($input) = @_;
      my $length = unpackVarint ($input);
      my $result = substr ($$input, 0, $length, "");
      return $result;
    }

    sub unpackVarint {
      my ($input) = @_;
      my $length = 0;
      my $result = 0;
      foreach my $byte (unpack ("C*", $$input)) {
        $result |= ($byte & 0x7F) << $length * 7;
        $length ++;
        last if (($byte & 0x80) == 0);
      }
      substr ($$input, 0, $length, "");
      return $result;
    }

    sub unpackPacket {
      my ($input) = @_;
      my $length = unpackVarint ($input);
      my $packet = substr ($$input, 0, $length, "");
      my $id = unpackVarint(\$packet);
      return ($length, $id, $packet);
    }

    sub unpackClientPacket {
      my ($input) = @_;
      my ($length, $id, $packet) = unpackPacket ($input);
      if ($id == 0) {
        # Handshake packet.
        my $protocolVersion = unpackVarint (\$packet);
        my $serverAddress = unpackString (\$packet);
        my $serverPort = unpackShort (\$packet);
        my $nextState = unpackVarint (\$packet);
        print "client - $id\t$protocolVersion\t$serverAddress\t$serverPort\t$nextState\n";
      }
    }

    sub unpackServerPacket {
      my ($input) = @_;
      my ($length, $id, $packet) = unpackPacket ($input);
      if ($id == 0) {
        # Handshake response packet.
        my $json = unpackString (\$packet);
        print "server - $id\t$json\n";
      }
    }



    if ($type =~ /client/i) {
      unpackClientPacket (\$raw);
    }
    elsif ($type =~ /server/i) {
      unpackServerPacket (\$raw);
    }


  ' "$2"
}


# Setup the fifo pipes.
rm -Rf "$BACK_PIPE" "$CLIENT_PIPE" "$SERVER_PIPE"
mkfifo -m 0600 "$BACK_PIPE" "$CLIENT_PIPE" "$SERVER_PIPE"


while [ $(serverRunning "world") -eq 1 ]; do
  # Parse the client and server pipes.
  parseProtocol 'client' "$CLIENT_PIPE" &
  parseProtocol 'server' "$SERVER_PIPE" &
  # Listen for the next connection.
  socat - TCP-LISTEN:$CLIENT_PORT,reuseaddr < "$BACK_PIPE" | tee "$CLIENT_PIPE" | 
  socat - TCP:$SERVER_IP:$SERVER_PORT | tee "$SERVER_PIPE" > "$BACK_PIPE"
done

[sandain]

I'm currently torn between integrating something like this into the minecraft_server script or creating a separate script that would plug into the minecraft_server script. If a plugin script functioned like a world server (the mscs-server-command variable would point to a shell script rather than java and a .jar file), it might greatly simplify configuration.

I guess what I am saying is that the code above is a proof-of-concept. The actual design that I want to go with is still up in the air.

[sandain]

I have decided to abandon the proxy server project. I just gave BungeeCord a try, and besides having to do some local configuration changes, it pretty much just works with the script. The great thing is BungeeCord almost has all of the features that I wanted to accomplish with this proxy idea.

To get it working, I first created a new directory in the worlds folder called lobby, and created a small server.properties file for the script:

mscs-server-jar=BungeeCord.jar
mscs-server-url=http://ci.md-5.net/job/BungeeCord/lastStableBuild/artifact/bootstrap/target/BungeeCord.jar

I then started the BungeeCord server with the script to have it generate the default config.yml file. Then I stopped the server by hand since the script is currently unable to stop the BungeeCord server due to it using a different command (end vs stop). After modifying the config.yml to match my setup, changing online-mode to false on all my worlds, and restarting the BungeeCord server with the script, I was up and running.

I will post a patch sometime in the near future to fix the stop server command for BungeeCord, once I've had some time to figure out the best route.