Split GUI code to separate module (#242)

* Split into modules

* Post merge compile fixes

Co-authored-by: modmuss50 <modmuss50@gmail.com>

27 files changed, 2360 insertions, 0 deletions

diff --git a/enigma-server/build.gradle b/enigma-server/build.gradle
new file mode 100644
index 00000000..bf72b184
--- /dev/null
+++ b/enigma-server/build.gradle
@@ -0,0 +1,6 @@
+dependencies {
+    implementation project(':enigma')
+    implementation 'net.sf.jopt-simple:jopt-simple:6.0-alpha-3'
+}
+
+jar.manifest.attributes 'Main-Class': 'cuchaz.enigma.network.DedicatedEnigmaServer'
diff --git a/enigma-server/docs/protocol.md b/enigma-server/docs/protocol.md
new file mode 100644
index 00000000..c14ecb81
--- /dev/null
+++ b/enigma-server/docs/protocol.md
@@ -0,0 +1,366 @@
+# Enigma protocol
+Enigma uses TCP sockets for communication. Data is sent in each direction as a continuous stream, with packets being
+concatenated one after the other.
+
+In this document, data will be represented in C-like pseudocode. The primitive data types will be the same as those
+defined by Java's [DataOutputStream](https://docs.oracle.com/javase/7/docs/api/java/io/DataOutputStream.html), i.e. in
+big-endian order for multi-byte integers (`short`, `int` and `long`). The one exception is for Strings, which do *not*
+use the same modified UTF format as in `DataOutputStream`, I repeat, the normal `writeUTF` method in `DataOutputStream`
+(and the corresponding method in `DataInputStream`) should *not* be used. Instead, there is a custom `utf` struct for
+Strings, see below.
+
+## Login protocol
+```
+Client     Server
+|               |
+|     Login     |
+| >>>>>>>>>>>>> |
+|               |
+| SyncMappings  |
+| <<<<<<<<<<<<< |
+|               |
+| ConfirmChange |
+| >>>>>>>>>>>>> |
+```
+1. On connect, the client sends a login packet to the server. This allows the server to test the validity of the client,
+   as well as allowing the client to declare metadata about itself, such as the username.
+1. After validating the login packet, the server sends all its mappings to the client, and the client will apply them.
+1. Upon receiving the mappings, the client sends a `ConfirmChange` packet with `sync_id` set to 0, to confirm that it
+   has received the mappings and is in sync with the server. Once the server receives this packet, the client will be
+   allowed to modify mappings.
+
+The server will not accept any other packets from the client until this entire exchange has been completed. 
+
+## Kicking clients
+When the server kicks a client, it may optionally send a `Kick` packet immediately before closing the connection, which
+contains the reason why the client was kicked (so the client can display it to the user). This is not required though -
+the server may simply terminate the connection.
+
+## Changing mappings
+This section uses the example of renaming, but the same pattern applies to all mapping changes.
+```
+Client A   Server    Client B
+|           |               |
+| RenameC2S |               |
+| >>>>>>>>> |               |
+|           |               |
+|           |   RenameS2C   |
+|           | >>>>>>>>>>>>> |
+|           |               |
+|           | ConfirmChange |
+|           | <<<<<<<<<<<<< |
+```
+
+1. Client A validates the name and updates the mapping client-side to give the impression there is no latency >:)
+1. Client A sends a rename packet to the server, notifying it of the rename.
+1. The server assesses the validity of the rename. If it is invalid for whatever reason (e.g. the mapping was locked or
+   the name contains invalid characters), then the server sends an appropriate packet back to client A to revert the
+   change, with `sync_id` set to 0. The server will ignore any `ConfirmChange` packets it receives in response to this.
+1. If the rename was valid, the server will lock all clients except client A from being able to modify this mapping, and
+   then send an appropriate packet to all clients except client A notifying them of this rename. The `sync_id` will be a
+   unique non-zero value identifying this change.
+1. Each client responds to this packet by updating their mappings locally to reflect this change, then sending a
+   `ConfirmChange` packet with the same `sync_id` as the one in the packet they received, to confirm that they have
+   received the change.
+1. When the server receives the `ConfirmChange` packet, and another change to that mapping hasn't occurred since, the
+   server will unlock that mapping for that client and allow them to make changes again.
+
+## Packets
+```c
+struct Packet {
+    unsigned short packet_id;
+    data[]; // depends on packet_id
+}
+```
+The IDs for client-to-server packets are as follows:
+- 0: `Login`
+- 1: `ConfirmChange`
+- 2: `Rename`
+- 3: `RemoveMapping`
+- 4: `ChangeDocs`
+- 5: `MarkDeobfuscated`
+- 6: `Message`
+
+The IDs for server-to-client packets are as follows:
+- 0: `Kick`
+- 1: `SyncMappings`
+- 2: `Rename`
+- 3: `RemoveMapping`
+- 4: `ChangeDocs`
+- 5: `MarkDeobfuscated`
+- 6: `Message`
+- 7: `UserList`
+
+### The utf struct
+```c
+struct utf {
+    unsigned short length;
+    byte data[length];
+}
+```
+- `length`: The number of bytes in the UTF-8 encoding of the string. Note, this may not be the same as the number of
+            Unicode characters in the string.
+- `data`: A standard UTF-8 encoded byte array representing the string. 
+
+### The Entry struct
+```c
+enum EntryType {
+    ENTRY_CLASS = 0, ENTRY_FIELD = 1, ENTRY_METHOD = 2, ENTRY_LOCAL_VAR = 3;
+}
+struct Entry {
+    unsigned byte type;
+    boolean has_parent;
+    if<has_parent> {
+        Entry parent;
+    }
+    utf name;
+    boolean has_javadoc;
+    if<has_javadoc> {
+        utf javadoc;
+    }
+    if<type == ENTRY_FIELD || type == ENTRY_METHOD> {
+        utf descriptor;
+    }
+    if<type == ENTRY_LOCAL_VAR> {
+        unsigned short index;
+        boolean parameter;
+    }
+}
+```
+- `type`: The type of entry this is. One of `ENTRY_CLASS`, `ENTRY_FIELD`, `ENTRY_METHOD` or `ENTRY_LOCAL_VAR`.
+- `parent`: The parent entry. Only class entries may have no parent. fields, methods and inner classes must have their
+            containing class as their parent. Local variables have a method as a parent.
+- `name`: The class/field/method/variable name.
+- `javadoc`: The javadoc of an entry, if present.
+- `descriptor`: The field/method descriptor.
+- `index`: The index of the local variable in the local variable table.
+- `parameter`: Whether the local variable is a parameter.
+
+### The Message struct
+```c
+enum MessageType {
+    MESSAGE_CHAT = 0,
+    MESSAGE_CONNECT = 1,
+    MESSAGE_DISCONNECT = 2,
+    MESSAGE_EDIT_DOCS = 3,
+    MESSAGE_MARK_DEOBF = 4,
+    MESSAGE_REMOVE_MAPPING = 5,
+    MESSAGE_RENAME = 6
+};
+typedef unsigned byte message_type_t;
+
+struct Message {
+    message_type_t type;
+    union { // Note that the size of this varies depending on type, it is not constant size
+        struct {
+            utf user;
+            utf message;
+        } chat;
+        struct {
+            utf user;
+        } connect;
+        struct {
+            utf user;
+        } disconnect;
+        struct {
+            utf user;
+            Entry entry;
+        } edit_docs;
+        struct {
+            utf user;
+            Entry entry;
+        } mark_deobf;
+        struct {
+            utf user;
+            Entry entry;
+        } remove_mapping;
+        struct {
+            utf user;
+            Entry entry;
+            utf new_name;
+        } rename;
+    } data;
+};
+```
+- `type`: The type of message this is. One of `MESSAGE_CHAT`, `MESSAGE_CONNECT`, `MESSAGE_DISCONNECT`,
+    `MESSAGE_EDIT_DOCS`, `MESSAGE_MARK_DEOBF`, `MESSAGE_REMOVE_MAPPING`, `MESSAGE_RENAME`.
+- `chat`: Chat message. Use in case `type` is `MESSAGE_CHAT`
+- `connect`: Sent when a user connects. Use in case `type` is `MESSAGE_CONNECT`
+- `disconnect`: Sent when a user disconnects. Use in case `type` is `MESSAGE_DISCONNECT`
+- `edit_docs`: Sent when a user edits the documentation of an entry. Use in case `type` is `MESSAGE_EDIT_DOCS`
+- `mark_deobf`: Sent when a user marks an entry as deobfuscated. Use in case `type` is `MESSAGE_MARK_DEOBF`
+- `remove_mapping`: Sent when a user removes a mapping. Use in case `type` is `MESSAGE_REMOVE_MAPPING`
+- `rename`: Sent when a user renames an entry. Use in case `type` is `MESSAGE_RENAME`
+- `user`: The user that performed the action.
+- `message`: The message the user sent.
+- `entry`: The entry that was modified.
+- `new_name`: The new name for the entry.
+
+
+### Login (client-to-server)
+```c
+struct LoginC2SPacket {
+    unsigned short protocol_version;
+    byte checksum[20];
+    unsigned byte password_length;
+    char password[password_length];
+    utf username;
+}
+```
+- `protocol_version`: the version of the protocol. If the version does not match on the server, then the client will be
+                      kicked immediately. Currently always equal to 0.
+- `checksum`: the SHA-1 hash of the JAR file the client has open. If this does not match the SHA-1 hash of the JAR file
+              the server has open, the client will be kicked.
+- `password`: the password needed to log into the server. Note that each `char` is 2 bytes, as per the Java data type.
+              If this password is incorrect, the client will be kicked.
+- `username`: the username of the user logging in. If the username is not unique, the client will be kicked.
+
+### ConfirmChange (client-to-server)
+```c
+struct ConfirmChangeC2SPacket {
+    unsigned short sync_id;
+}
+```
+- `sync_id`: the sync ID to confirm.
+
+### Rename (client-to-server)
+```c
+struct RenameC2SPacket {
+    Entry obf_entry;
+    utf new_name;
+    boolean refresh_class_tree;
+}
+```
+- `obf_entry`: the obfuscated name and descriptor of the entry to rename.
+- `new_name`: what to rename the entry to.
+- `refresh_class_tree`: whether the class tree on the sidebar of Enigma needs refreshing as a result of this change.
+
+### RemoveMapping (client-to-server)
+```c
+struct RemoveMappingC2SPacket {
+    Entry obf_entry;
+}
+```
+- `obf_entry`: the obfuscated name and descriptor of the entry to remove the mapping for.
+
+### ChangeDocs (client-to-server)
+```c
+struct ChangeDocsC2SPacket {
+    Entry obf_entry;
+    utf new_docs;
+}
+```
+- `obf_entry`: the obfuscated name and descriptor of the entry to change the documentation for.
+- `new_docs`: the new documentation for this entry, or an empty string to remove the documentation.
+
+### MarkDeobfuscated (client-to-server)
+```c
+struct MarkDeobfuscatedC2SPacket {
+    Entry obf_entry;
+}
+```
+- `obf_entry`: the obfuscated name and descriptor of the entry to mark as deobfuscated.
+
+### Message (client-to-server)
+```c
+struct MessageC2SPacket {
+    utf message;
+}
+```
+- `message`: The text message the user sent.
+
+### Kick (server-to-client)
+```c
+struct KickS2CPacket {
+    utf reason;
+}
+```
+- `reason`: the reason for the kick, may or may not be a translation key for the client to display to the user.
+
+### SyncMappings (server-to-client)
+```c
+struct SyncMappingsS2CPacket {
+    int num_roots;
+    MappingNode roots[num_roots];
+}
+struct MappingNode {
+    NoParentEntry obf_entry;
+    boolean is_named;
+    if<is_named> {
+        utf name;
+        boolean has_javadoc;
+        if<has_javadoc> {
+            utf javadoc;
+        }
+    }
+    unsigned short children_count;
+    MappingNode children[children_count];
+}
+typedef { Entry but without the has_parent or parent fields } NoParentEntry;
+```
+- `roots`: The root mapping nodes, containing all the entries without parents.
+- `obf_entry`: The value of a node, containing the obfuscated name and descriptor of the entry.
+- `name`: The deobfuscated name of the entry, if it has a mapping.
+- `javadoc`: The documentation for the entry, if it is named and has documentation.
+- `children`: The children of this node
+
+### Rename (server-to-client)
+```c
+struct RenameS2CPacket {
+    unsigned short sync_id;
+    Entry obf_entry;
+    utf new_name;
+    boolean refresh_class_tree;
+}
+```
+- `sync_id`: the sync ID of the change for locking purposes.
+- `obf_entry`: the obfuscated name and descriptor of the entry to rename.
+- `new_name`: what to rename the entry to.
+- `refresh_class_tree`: whether the class tree on the sidebar of Enigma needs refreshing as a result of this change.
+
+### RemoveMapping (server-to-client)
+```c
+struct RemoveMappingS2CPacket {
+    unsigned short sync_id;
+    Entry obf_entry;
+}
+```
+- `sync_id`: the sync ID of the change for locking purposes.
+- `obf_entry`: the obfuscated name and descriptor of the entry to remove the mapping for.
+
+### ChangeDocs (server-to-client)
+```c
+struct ChangeDocsS2CPacket {
+    unsigned short sync_id;
+    Entry obf_entry;
+    utf new_docs;
+}
+```
+- `sync_id`: the sync ID of the change for locking purposes.
+- `obf_entry`: the obfuscated name and descriptor of the entry to change the documentation for.
+- `new_docs`: the new documentation for this entry, or an empty string to remove the documentation.
+
+### MarkDeobfuscated (server-to-client)
+```c
+struct MarkDeobfuscatedS2CPacket {
+    unsigned short sync_id;
+    Entry obf_entry;
+}
+```
+- `sync_id`: the sync ID of the change for locking purposes.
+- `obf_entry`: the obfuscated name and descriptor of the entry to mark as deobfuscated.
+
+### Message (server-to-client)
+```c
+struct MessageS2CPacket {
+    Message message;
+}
+```
+
+### UserList (server-to-client)
+```c
+struct UserListS2CPacket {
+    unsigned short len;
+    utf user[len];
+}
+```
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/ClientPacketHandler.java b/enigma-server/src/main/java/cuchaz/enigma/network/ClientPacketHandler.java
new file mode 100644
index 00000000..720744bf
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/ClientPacketHandler.java
@@ -0,0 +1,29 @@
+package cuchaz.enigma.network;
+
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.tree.EntryTree;
+import cuchaz.enigma.network.packet.Packet;
+import cuchaz.enigma.translation.representation.entry.Entry;
+
+import java.util.List;
+
+public interface ClientPacketHandler {
+    void openMappings(EntryTree<EntryMapping> mappings);
+
+    void rename(EntryReference<Entry<?>, Entry<?>> reference, String newName, boolean refreshClassTree, boolean jumpToReference);
+
+    void removeMapping(EntryReference<Entry<?>, Entry<?>> reference, boolean jumpToReference);
+
+    void changeDocs(EntryReference<Entry<?>, Entry<?>> reference, String updatedDocs, boolean jumpToReference);
+
+    void markAsDeobfuscated(EntryReference<Entry<?>, Entry<?>> reference, boolean jumpToReference);
+
+    void disconnectIfConnected(String reason);
+
+    void sendPacket(Packet<ServerPacketHandler> packet);
+
+    void addMessage(Message message);
+
+    void updateUserList(List<String> users);
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/DedicatedEnigmaServer.java b/enigma-server/src/main/java/cuchaz/enigma/network/DedicatedEnigmaServer.java
new file mode 100644
index 00000000..924302f3
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/DedicatedEnigmaServer.java
@@ -0,0 +1,200 @@
+package cuchaz.enigma.network;
+
+import com.google.common.io.MoreFiles;
+import cuchaz.enigma.*;
+import cuchaz.enigma.translation.mapping.serde.MappingParseException;
+import cuchaz.enigma.translation.mapping.EntryRemapper;
+import cuchaz.enigma.translation.mapping.serde.MappingFormat;
+import cuchaz.enigma.utils.Utils;
+import joptsimple.OptionParser;
+import joptsimple.OptionSet;
+import joptsimple.OptionSpec;
+import joptsimple.ValueConverter;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.TimeUnit;
+
+public class DedicatedEnigmaServer extends EnigmaServer {
+
+        private final EnigmaProfile profile;
+        private final MappingFormat mappingFormat;
+        private final Path mappingsFile;
+        private final PrintWriter log;
+        private BlockingQueue<Runnable> tasks = new LinkedBlockingDeque<>();
+
+        public DedicatedEnigmaServer(
+                        byte[] jarChecksum,
+                        char[] password,
+                        EnigmaProfile profile,
+                        MappingFormat mappingFormat,
+                        Path mappingsFile,
+                        PrintWriter log,
+                        EntryRemapper mappings,
+                        int port
+        ) {
+                super(jarChecksum, password, mappings, port);
+                this.profile = profile;
+                this.mappingFormat = mappingFormat;
+                this.mappingsFile = mappingsFile;
+                this.log = log;
+        }
+
+        @Override
+        protected void runOnThread(Runnable task) {
+                tasks.add(task);
+        }
+
+        @Override
+        public void log(String message) {
+                super.log(message);
+                log.println(message);
+        }
+
+        public static void main(String[] args) {
+                OptionParser parser = new OptionParser();
+
+                OptionSpec<Path> jarOpt = parser.accepts("jar", "Jar file to open at startup")
+                                .withRequiredArg()
+                                .required()
+                                .withValuesConvertedBy(PathConverter.INSTANCE);
+
+                OptionSpec<Path> mappingsOpt = parser.accepts("mappings", "Mappings file to open at startup")
+                                .withRequiredArg()
+                                .required()
+                                .withValuesConvertedBy(PathConverter.INSTANCE);
+
+                OptionSpec<Path> profileOpt = parser.accepts("profile", "Profile json to apply at startup")
+                                .withRequiredArg()
+                                .withValuesConvertedBy(PathConverter.INSTANCE);
+
+                OptionSpec<Integer> portOpt = parser.accepts("port", "Port to run the server on")
+                                .withOptionalArg()
+                                .ofType(Integer.class)
+                                .defaultsTo(EnigmaServer.DEFAULT_PORT);
+
+                OptionSpec<String> passwordOpt = parser.accepts("password", "The password to join the server")
+                                .withRequiredArg()
+                                .defaultsTo("");
+
+                OptionSpec<Path> logFileOpt = parser.accepts("log", "The log file to write to")
+                                .withRequiredArg()
+                                .withValuesConvertedBy(PathConverter.INSTANCE)
+                                .defaultsTo(Paths.get("log.txt"));
+
+                OptionSet parsedArgs = parser.parse(args);
+                Path jar = parsedArgs.valueOf(jarOpt);
+                Path mappingsFile = parsedArgs.valueOf(mappingsOpt);
+                Path profileFile = parsedArgs.valueOf(profileOpt);
+                int port = parsedArgs.valueOf(portOpt);
+                char[] password = parsedArgs.valueOf(passwordOpt).toCharArray();
+                if (password.length > EnigmaServer.MAX_PASSWORD_LENGTH) {
+                        System.err.println("Password too long, must be at most " + EnigmaServer.MAX_PASSWORD_LENGTH + " characters");
+                        System.exit(1);
+                }
+                Path logFile = parsedArgs.valueOf(logFileOpt);
+
+                System.out.println("Starting Enigma server");
+                DedicatedEnigmaServer server;
+                try {
+                        byte[] checksum = Utils.zipSha1(parsedArgs.valueOf(jarOpt));
+
+                        EnigmaProfile profile = EnigmaProfile.read(profileFile);
+                        Enigma enigma = Enigma.builder().setProfile(profile).build();
+                        System.out.println("Indexing Jar...");
+                        EnigmaProject project = enigma.openJar(jar, ProgressListener.none());
+
+                        MappingFormat mappingFormat = MappingFormat.ENIGMA_DIRECTORY;
+                        EntryRemapper mappings;
+                        if (!Files.exists(mappingsFile)) {
+                                mappings = EntryRemapper.empty(project.getJarIndex());
+                        } else {
+                                System.out.println("Reading mappings...");
+                                if (Files.isDirectory(mappingsFile)) {
+                                        mappingFormat = MappingFormat.ENIGMA_DIRECTORY;
+                                } else if ("zip".equalsIgnoreCase(MoreFiles.getFileExtension(mappingsFile))) {
+                                        mappingFormat = MappingFormat.ENIGMA_ZIP;
+                                } else {
+                                        mappingFormat = MappingFormat.ENIGMA_FILE;
+                                }
+                                mappings = EntryRemapper.mapped(project.getJarIndex(), mappingFormat.read(mappingsFile, ProgressListener.none(), profile.getMappingSaveParameters()));
+                        }
+
+                        PrintWriter log = new PrintWriter(Files.newBufferedWriter(logFile));
+
+                        server = new DedicatedEnigmaServer(checksum, password, profile, mappingFormat, mappingsFile, log, mappings, port);
+                        server.start();
+                        System.out.println("Server started");
+                } catch (IOException | MappingParseException e) {
+                        System.err.println("Error starting server!");
+                        e.printStackTrace();
+                        System.exit(1);
+                        return;
+                }
+
+                // noinspection RedundantSuppression
+                // noinspection Convert2MethodRef - javac 8 bug
+                Executors.newScheduledThreadPool(1).scheduleAtFixedRate(() -> server.runOnThread(() -> server.saveMappings()), 0, 1, TimeUnit.MINUTES);
+                Runtime.getRuntime().addShutdownHook(new Thread(server::saveMappings));
+
+                while (true) {
+                        try {
+                                server.tasks.take().run();
+                        } catch (InterruptedException e) {
+                                break;
+                        }
+                }
+        }
+
+        @Override
+        public synchronized void stop() {
+                super.stop();
+                System.exit(0);
+        }
+
+        private void saveMappings() {
+                mappingFormat.write(getMappings().getObfToDeobf(), getMappings().takeMappingDelta(), mappingsFile, ProgressListener.none(), profile.getMappingSaveParameters());
+                log.flush();
+        }
+
+        public static class PathConverter implements ValueConverter<Path> {
+                public static final ValueConverter<Path> INSTANCE = new PathConverter();
+
+                PathConverter() {
+                }
+
+                @Override
+                public Path convert(String path) {
+                        // expand ~ to the home dir
+                        if (path.startsWith("~")) {
+                                // get the home dir
+                                Path dirHome = Paths.get(System.getProperty("user.home"));
+
+                                // is the path just ~/ or is it ~user/ ?
+                                if (path.startsWith("~/")) {
+                                        return dirHome.resolve(path.substring(2));
+                                } else {
+                                        return dirHome.getParent().resolve(path.substring(1));
+                                }
+                        }
+
+                        return Paths.get(path);
+                }
+
+                @Override
+                public Class<? extends Path> valueType() {
+                        return Path.class;
+                }
+
+                @Override
+                public String valuePattern() {
+                        return "path";
+                }
+        }
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/EnigmaClient.java b/enigma-server/src/main/java/cuchaz/enigma/network/EnigmaClient.java
new file mode 100644
index 00000000..71bd011c
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/EnigmaClient.java
@@ -0,0 +1,78 @@
+package cuchaz.enigma.network;
+
+import cuchaz.enigma.network.packet.Packet;
+import cuchaz.enigma.network.packet.PacketRegistry;
+
+import javax.swing.*;
+import java.io.*;
+import java.net.Socket;
+import java.net.SocketException;
+
+public class EnigmaClient {
+
+        private final ClientPacketHandler controller;
+
+        private final String ip;
+        private final int port;
+        private Socket socket;
+        private DataOutput output;
+
+        public EnigmaClient(ClientPacketHandler controller, String ip, int port) {
+                this.controller = controller;
+                this.ip = ip;
+                this.port = port;
+        }
+
+        public void connect() throws IOException {
+                socket = new Socket(ip, port);
+                output = new DataOutputStream(socket.getOutputStream());
+                Thread thread = new Thread(() -> {
+                        try {
+                                DataInput input = new DataInputStream(socket.getInputStream());
+                                while (true) {
+                                        int packetId;
+                                        try {
+                                                packetId = input.readUnsignedByte();
+                                        } catch (EOFException | SocketException e) {
+                                                break;
+                                        }
+                                        Packet<ClientPacketHandler> packet = PacketRegistry.createS2CPacket(packetId);
+                                        if (packet == null) {
+                                                throw new IOException("Received invalid packet id " + packetId);
+                                        }
+                                        packet.read(input);
+                                        SwingUtilities.invokeLater(() -> packet.handle(controller));
+                                }
+                        } catch (IOException e) {
+                                controller.disconnectIfConnected(e.toString());
+                                return;
+                        }
+                        controller.disconnectIfConnected("Disconnected");
+                });
+                thread.setName("Client I/O thread");
+                thread.setDaemon(true);
+                thread.start();
+        }
+
+        public synchronized void disconnect() {
+                if (socket != null && !socket.isClosed()) {
+                        try {
+                                socket.close();
+                        } catch (IOException e1) {
+                                System.err.println("Failed to close socket");
+                                e1.printStackTrace();
+                        }
+                }
+        }
+
+
+        public void sendPacket(Packet<ServerPacketHandler> packet) {
+                try {
+                        output.writeByte(PacketRegistry.getC2SId(packet));
+                        packet.write(output);
+                } catch (IOException e) {
+                        controller.disconnectIfConnected(e.toString());
+                }
+        }
+
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/EnigmaServer.java b/enigma-server/src/main/java/cuchaz/enigma/network/EnigmaServer.java
new file mode 100644
index 00000000..6027a6bd
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/EnigmaServer.java
@@ -0,0 +1,290 @@
+package cuchaz.enigma.network;
+
+import cuchaz.enigma.network.packet.KickS2CPacket;
+import cuchaz.enigma.network.packet.MessageS2CPacket;
+import cuchaz.enigma.network.packet.Packet;
+import cuchaz.enigma.network.packet.PacketRegistry;
+import cuchaz.enigma.network.packet.RemoveMappingS2CPacket;
+import cuchaz.enigma.network.packet.RenameS2CPacket;
+import cuchaz.enigma.network.packet.UserListS2CPacket;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.EntryRemapper;
+import cuchaz.enigma.translation.representation.entry.Entry;
+
+import java.io.DataInput;
+import java.io.DataInputStream;
+import java.io.DataOutput;
+import java.io.DataOutputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public abstract class EnigmaServer {
+
+        // https://discordapp.com/channels/507304429255393322/566418023372816394/700292322918793347
+        public static final int DEFAULT_PORT = 34712;
+        public static final int PROTOCOL_VERSION = 0;
+        public static final String OWNER_USERNAME = "Owner";
+        public static final int CHECKSUM_SIZE = 20;
+        public static final int MAX_PASSWORD_LENGTH = 255; // length is written as a byte in the login packet
+
+        private final int port;
+        private ServerSocket socket;
+        private List<Socket> clients = new CopyOnWriteArrayList<>();
+        private Map<Socket, String> usernames = new HashMap<>();
+        private Set<Socket> unapprovedClients = new HashSet<>();
+
+        private final byte[] jarChecksum;
+        private final char[] password;
+
+        public static final int DUMMY_SYNC_ID = 0;
+        private final EntryRemapper mappings;
+        private Map<Entry<?>, Integer> syncIds = new HashMap<>();
+        private Map<Integer, Entry<?>> inverseSyncIds = new HashMap<>();
+        private Map<Integer, Set<Socket>> clientsNeedingConfirmation = new HashMap<>();
+        private int nextSyncId = DUMMY_SYNC_ID + 1;
+
+        private static int nextIoId = 0;
+
+        public EnigmaServer(byte[] jarChecksum, char[] password, EntryRemapper mappings, int port) {
+                this.jarChecksum = jarChecksum;
+                this.password = password;
+                this.mappings = mappings;
+                this.port = port;
+        }
+
+        public void start() throws IOException {
+                socket = new ServerSocket(port);
+                log("Server started on " + socket.getInetAddress() + ":" + port);
+                Thread thread = new Thread(() -> {
+                        try {
+                                while (!socket.isClosed()) {
+                                        acceptClient();
+                                }
+                        } catch (SocketException e) {
+                                System.out.println("Server closed");
+                        } catch (IOException e) {
+                                e.printStackTrace();
+                        }
+                });
+                thread.setName("Server client listener");
+                thread.setDaemon(true);
+                thread.start();
+        }
+
+        private void acceptClient() throws IOException {
+                Socket client = socket.accept();
+                clients.add(client);
+                Thread thread = new Thread(() -> {
+                        try {
+                                DataInput input = new DataInputStream(client.getInputStream());
+                                while (true) {
+                                        int packetId;
+                                        try {
+                                                packetId = input.readUnsignedByte();
+                                        } catch (EOFException | SocketException e) {
+                                                break;
+                                        }
+                                        Packet<ServerPacketHandler> packet = PacketRegistry.createC2SPacket(packetId);
+                                        if (packet == null) {
+                                                throw new IOException("Received invalid packet id " + packetId);
+                                        }
+                                        packet.read(input);
+                                        runOnThread(() -> packet.handle(new ServerPacketHandler(client, this)));
+                                }
+                        } catch (IOException e) {
+                                kick(client, e.toString());
+                                e.printStackTrace();
+                                return;
+                        }
+                        kick(client, "disconnect.disconnected");
+                });
+                thread.setName("Server I/O thread #" + (nextIoId++));
+                thread.setDaemon(true);
+                thread.start();
+        }
+
+        public void stop() {
+                runOnThread(() -> {
+                        if (socket != null && !socket.isClosed()) {
+                                for (Socket client : clients) {
+                                        kick(client, "disconnect.server_closed");
+                                }
+                                try {
+                                        socket.close();
+                                } catch (IOException e) {
+                                        System.err.println("Failed to close server socket");
+                                        e.printStackTrace();
+                                }
+                        }
+                });
+        }
+
+        public void kick(Socket client, String reason) {
+                if (!clients.remove(client)) return;
+
+                sendPacket(client, new KickS2CPacket(reason));
+
+                clientsNeedingConfirmation.values().removeIf(list -> {
+                        list.remove(client);
+                        return list.isEmpty();
+                });
+                String username = usernames.remove(client);
+                try {
+                        client.close();
+                } catch (IOException e) {
+                        System.err.println("Failed to close server client socket");
+                        e.printStackTrace();
+                }
+
+                if (username != null) {
+                        System.out.println("Kicked " + username + " because " + reason);
+                        sendMessage(Message.disconnect(username));
+                }
+                sendUsernamePacket();
+        }
+
+        public boolean isUsernameTaken(String username) {
+                return usernames.containsValue(username);
+        }
+
+        public void setUsername(Socket client, String username) {
+                usernames.put(client, username);
+                sendUsernamePacket();
+        }
+
+        private void sendUsernamePacket() {
+                List<String> usernames = new ArrayList<>(this.usernames.values());
+                Collections.sort(usernames);
+                sendToAll(new UserListS2CPacket(usernames));
+        }
+
+        public String getUsername(Socket client) {
+                return usernames.get(client);
+        }
+
+        public void sendPacket(Socket client, Packet<ClientPacketHandler> packet) {
+                if (!client.isClosed()) {
+                        int packetId = PacketRegistry.getS2CId(packet);
+                        try {
+                                DataOutput output = new DataOutputStream(client.getOutputStream());
+                                output.writeByte(packetId);
+                                packet.write(output);
+                        } catch (IOException e) {
+                                if (!(packet instanceof KickS2CPacket)) {
+                                        kick(client, e.toString());
+                                        e.printStackTrace();
+                                }
+                        }
+                }
+        }
+
+        public void sendToAll(Packet<ClientPacketHandler> packet) {
+                for (Socket client : clients) {
+                        sendPacket(client, packet);
+                }
+        }
+
+        public void sendToAllExcept(Socket excluded, Packet<ClientPacketHandler> packet) {
+                for (Socket client : clients) {
+                        if (client != excluded) {
+                                sendPacket(client, packet);
+                        }
+                }
+        }
+
+        public boolean canModifyEntry(Socket client, Entry<?> entry) {
+                if (unapprovedClients.contains(client)) {
+                        return false;
+                }
+
+                Integer syncId = syncIds.get(entry);
+                if (syncId == null) {
+                        return true;
+                }
+                Set<Socket> clients = clientsNeedingConfirmation.get(syncId);
+                return clients == null || !clients.contains(client);
+        }
+
+        public int lockEntry(Socket exception, Entry<?> entry) {
+                int syncId = nextSyncId;
+                nextSyncId++;
+                // sync id is sent as an unsigned short, can't have more than 65536
+                if (nextSyncId == 65536) {
+                        nextSyncId = DUMMY_SYNC_ID + 1;
+                }
+                Integer oldSyncId = syncIds.get(entry);
+                if (oldSyncId != null) {
+                        clientsNeedingConfirmation.remove(oldSyncId);
+                }
+                syncIds.put(entry, syncId);
+                inverseSyncIds.put(syncId, entry);
+                Set<Socket> clients = new HashSet<>(this.clients);
+                clients.remove(exception);
+                clientsNeedingConfirmation.put(syncId, clients);
+                return syncId;
+        }
+
+        public void confirmChange(Socket client, int syncId) {
+                if (usernames.containsKey(client)) {
+                        unapprovedClients.remove(client);
+                }
+
+                Set<Socket> clients = clientsNeedingConfirmation.get(syncId);
+                if (clients != null) {
+                        clients.remove(client);
+                        if (clients.isEmpty()) {
+                                clientsNeedingConfirmation.remove(syncId);
+                                syncIds.remove(inverseSyncIds.remove(syncId));
+                        }
+                }
+        }
+
+        public void sendCorrectMapping(Socket client, Entry<?> entry, boolean refreshClassTree) {
+                EntryMapping oldMapping = mappings.getDeobfMapping(entry);
+                String oldName = oldMapping == null ? null : oldMapping.getTargetName();
+                if (oldName == null) {
+                        sendPacket(client, new RemoveMappingS2CPacket(DUMMY_SYNC_ID, entry));
+                } else {
+                        sendPacket(client, new RenameS2CPacket(0, entry, oldName, refreshClassTree));
+                }
+        }
+
+        protected abstract void runOnThread(Runnable task);
+
+        public void log(String message) {
+                System.out.println(message);
+        }
+
+        protected boolean isRunning() {
+                return !socket.isClosed();
+        }
+
+        public byte[] getJarChecksum() {
+                return jarChecksum;
+        }
+
+        public char[] getPassword() {
+                return password;
+        }
+
+        public EntryRemapper getMappings() {
+                return mappings;
+        }
+
+        public void sendMessage(Message message) {
+                log(String.format("[MSG] %s", message.translate()));
+                sendToAll(new MessageS2CPacket(message));
+        }
+
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/IntegratedEnigmaServer.java b/enigma-server/src/main/java/cuchaz/enigma/network/IntegratedEnigmaServer.java
new file mode 100644
index 00000000..21c6825b
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/IntegratedEnigmaServer.java
@@ -0,0 +1,16 @@
+package cuchaz.enigma.network;
+
+import cuchaz.enigma.translation.mapping.EntryRemapper;
+
+import javax.swing.*;
+
+public class IntegratedEnigmaServer extends EnigmaServer {
+        public IntegratedEnigmaServer(byte[] jarChecksum, char[] password, EntryRemapper mappings, int port) {
+                super(jarChecksum, password, mappings, port);
+        }
+
+        @Override
+        protected void runOnThread(Runnable task) {
+                SwingUtilities.invokeLater(task);
+        }
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/Message.java b/enigma-server/src/main/java/cuchaz/enigma/network/Message.java
new file mode 100644
index 00000000..c1578387
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/Message.java
@@ -0,0 +1,393 @@
+package cuchaz.enigma.network;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+import java.util.Objects;
+
+import cuchaz.enigma.network.packet.PacketHelper;
+import cuchaz.enigma.translation.representation.entry.Entry;
+import cuchaz.enigma.utils.I18n;
+
+public abstract class Message {
+
+        public final String user;
+        
+        public static Chat chat(String user, String message) {
+                return new Chat(user, message);
+        }
+
+        public static Connect connect(String user) {
+                return new Connect(user);
+        }
+
+        public static Disconnect disconnect(String user) {
+                return new Disconnect(user);
+        }
+
+        public static EditDocs editDocs(String user, Entry<?> entry) {
+                return new EditDocs(user, entry);
+        }
+
+        public static MarkDeobf markDeobf(String user, Entry<?> entry) {
+                return new MarkDeobf(user, entry);
+        }
+
+        public static RemoveMapping removeMapping(String user, Entry<?> entry) {
+                return new RemoveMapping(user, entry);
+        }
+
+        public static Rename rename(String user, Entry<?> entry, String newName) {
+                return new Rename(user, entry, newName);
+        }
+
+        public abstract String translate();
+
+        public abstract Type getType();
+
+        public static Message read(DataInput input) throws IOException {
+                byte typeId = input.readByte();
+                if (typeId < 0 || typeId >= Type.values().length) {
+                        throw new IOException(String.format("Invalid message type ID %d", typeId));
+                }
+                Type type = Type.values()[typeId];
+                String user = input.readUTF();
+                switch (type) {
+                        case CHAT:
+                                String message = input.readUTF();
+                                return chat(user, message);
+                        case CONNECT:
+                                return connect(user);
+                        case DISCONNECT:
+                                return disconnect(user);
+                        case EDIT_DOCS:
+                                Entry<?> entry = PacketHelper.readEntry(input);
+                                return editDocs(user, entry);
+                        case MARK_DEOBF:
+                                entry = PacketHelper.readEntry(input);
+                                return markDeobf(user, entry);
+                        case REMOVE_MAPPING:
+                                entry = PacketHelper.readEntry(input);
+                                return removeMapping(user, entry);
+                        case RENAME:
+                                entry = PacketHelper.readEntry(input);
+                                String newName = input.readUTF();
+                                return rename(user, entry, newName);
+                        default:
+                                throw new IllegalStateException("unreachable");
+                }
+        }
+
+        public void write(DataOutput output) throws IOException {
+                output.writeByte(getType().ordinal());
+                PacketHelper.writeString(output, user);
+        }
+
+        private Message(String user) {
+                this.user = user;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                Message message = (Message) o;
+                return Objects.equals(user, message.user);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(user);
+        }
+
+        public enum Type {
+                CHAT,
+                CONNECT,
+                DISCONNECT,
+                EDIT_DOCS,
+                MARK_DEOBF,
+                REMOVE_MAPPING,
+                RENAME,
+        }
+
+        public static final class Chat extends Message {
+
+                public final String message;
+
+                private Chat(String user, String message) {
+                        super(user);
+                        this.message = message;
+                }
+
+                @Override
+                public void write(DataOutput output) throws IOException {
+                        super.write(output);
+                        PacketHelper.writeString(output, message);
+                }
+
+                @Override
+                public String translate() {
+                        return String.format(I18n.translate("message.chat.text"), user, message);
+                }
+
+                @Override
+                public Type getType() {
+                        return Type.CHAT;
+                }
+
+                @Override
+                public boolean equals(Object o) {
+                        if (this == o) return true;
+                        if (o == null || getClass() != o.getClass()) return false;
+                        if (!super.equals(o)) return false;
+                        Chat chat = (Chat) o;
+                        return Objects.equals(message, chat.message);
+                }
+
+                @Override
+                public int hashCode() {
+                        return Objects.hash(super.hashCode(), message);
+                }
+
+                @Override
+                public String toString() {
+                        return String.format("Message.Chat { user: '%s', message: '%s' }", user, message);
+                }
+
+        }
+
+        public static final class Connect extends Message {
+
+                private Connect(String user) {
+                        super(user);
+                }
+
+                @Override
+                public String translate() {
+                        return String.format(I18n.translate("message.connect.text"), user);
+                }
+
+                @Override
+                public Type getType() {
+                        return Type.CONNECT;
+                }
+
+                @Override
+                public String toString() {
+                        return String.format("Message.Connect { user: '%s' }", user);
+                }
+
+        }
+
+        public static final class Disconnect extends Message {
+
+                private Disconnect(String user) {
+                        super(user);
+                }
+
+                @Override
+                public String translate() {
+                        return String.format(I18n.translate("message.disconnect.text"), user);
+                }
+
+                @Override
+                public Type getType() {
+                        return Type.DISCONNECT;
+                }
+
+                @Override
+                public String toString() {
+                        return String.format("Message.Disconnect { user: '%s' }", user);
+                }
+
+        }
+
+        public static  final class EditDocs extends Message {
+
+                public final Entry<?> entry;
+
+                private EditDocs(String user, Entry<?> entry) {
+                        super(user);
+                        this.entry = entry;
+                }
+
+                @Override
+                public void write(DataOutput output) throws IOException {
+                        super.write(output);
+                        PacketHelper.writeEntry(output, entry);
+                }
+
+                @Override
+                public String translate() {
+                        return String.format(I18n.translate("message.edit_docs.text"), user, entry);
+                }
+
+                @Override
+                public Type getType() {
+                        return Type.EDIT_DOCS;
+                }
+
+                @Override
+                public boolean equals(Object o) {
+                        if (this == o) return true;
+                        if (o == null || getClass() != o.getClass()) return false;
+                        if (!super.equals(o)) return false;
+                        EditDocs editDocs = (EditDocs) o;
+                        return Objects.equals(entry, editDocs.entry);
+                }
+
+                @Override
+                public int hashCode() {
+                        return Objects.hash(super.hashCode(), entry);
+                }
+
+                @Override
+                public String toString() {
+                        return String.format("Message.EditDocs { user: '%s', entry: %s }", user, entry);
+                }
+
+        }
+
+        public static final class MarkDeobf extends Message {
+
+                public final Entry<?> entry;
+
+                private MarkDeobf(String user, Entry<?> entry) {
+                        super(user);
+                        this.entry = entry;
+                }
+
+                @Override
+                public void write(DataOutput output) throws IOException {
+                        super.write(output);
+                        PacketHelper.writeEntry(output, entry);
+                }
+
+                @Override
+                public String translate() {
+                        return String.format(I18n.translate("message.mark_deobf.text"), user, entry);
+                }
+
+                @Override
+                public Type getType() {
+                        return Type.MARK_DEOBF;
+                }
+
+                @Override
+                public boolean equals(Object o) {
+                        if (this == o) return true;
+                        if (o == null || getClass() != o.getClass()) return false;
+                        if (!super.equals(o)) return false;
+                        MarkDeobf markDeobf = (MarkDeobf) o;
+                        return Objects.equals(entry, markDeobf.entry);
+                }
+
+                @Override
+                public int hashCode() {
+                        return Objects.hash(super.hashCode(), entry);
+                }
+
+                @Override
+                public String toString() {
+                        return String.format("Message.MarkDeobf { user: '%s', entry: %s }", user, entry);
+                }
+
+        }
+
+        public static final class RemoveMapping extends Message {
+
+                public final Entry<?> entry;
+
+                private RemoveMapping(String user, Entry<?> entry) {
+                        super(user);
+                        this.entry = entry;
+                }
+
+                @Override
+                public void write(DataOutput output) throws IOException {
+                        super.write(output);
+                        PacketHelper.writeEntry(output, entry);
+                }
+
+                @Override
+                public String translate() {
+                        return String.format(I18n.translate("message.remove_mapping.text"), user, entry);
+                }
+
+                @Override
+                public Type getType() {
+                        return Type.REMOVE_MAPPING;
+                }
+
+                @Override
+                public boolean equals(Object o) {
+                        if (this == o) return true;
+                        if (o == null || getClass() != o.getClass()) return false;
+                        if (!super.equals(o)) return false;
+                        RemoveMapping that = (RemoveMapping) o;
+                        return Objects.equals(entry, that.entry);
+                }
+
+                @Override
+                public int hashCode() {
+                        return Objects.hash(super.hashCode(), entry);
+                }
+
+                @Override
+                public String toString() {
+                        return String.format("Message.RemoveMapping { user: '%s', entry: %s }", user, entry);
+                }
+
+        }
+
+        public static final class Rename extends Message {
+
+                public final Entry<?> entry;
+                public final String newName;
+
+                private Rename(String user, Entry<?> entry, String newName) {
+                        super(user);
+                        this.entry = entry;
+                        this.newName = newName;
+                }
+
+                @Override
+                public void write(DataOutput output) throws IOException {
+                        super.write(output);
+                        PacketHelper.writeEntry(output, entry);
+                        PacketHelper.writeString(output, newName);
+                }
+
+                @Override
+                public String translate() {
+                        return String.format(I18n.translate("message.rename.text"), user, entry, newName);
+                }
+
+                @Override
+                public Type getType() {
+                        return Type.RENAME;
+                }
+
+                @Override
+                public boolean equals(Object o) {
+                        if (this == o) return true;
+                        if (o == null || getClass() != o.getClass()) return false;
+                        if (!super.equals(o)) return false;
+                        Rename rename = (Rename) o;
+                        return Objects.equals(entry, rename.entry) &&
+                                        Objects.equals(newName, rename.newName);
+                }
+
+                @Override
+                public int hashCode() {
+                        return Objects.hash(super.hashCode(), entry, newName);
+                }
+
+                @Override
+                public String toString() {
+                        return String.format("Message.Rename { user: '%s', entry: %s, newName: '%s' }", user, entry, newName);
+                }
+
+        }
+
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/ServerPacketHandler.java b/enigma-server/src/main/java/cuchaz/enigma/network/ServerPacketHandler.java
new file mode 100644
index 00000000..86185536
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/ServerPacketHandler.java
@@ -0,0 +1,22 @@
+package cuchaz.enigma.network;
+
+import java.net.Socket;
+
+public class ServerPacketHandler {
+
+        private final Socket client;
+        private final EnigmaServer server;
+
+        public ServerPacketHandler(Socket client, EnigmaServer server) {
+                this.client = client;
+                this.server = server;
+        }
+
+        public Socket getClient() {
+                return client;
+        }
+
+        public EnigmaServer getServer() {
+                return server;
+        }
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/ChangeDocsC2SPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/ChangeDocsC2SPacket.java
new file mode 100644
index 00000000..1b52cf14
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/ChangeDocsC2SPacket.java
@@ -0,0 +1,59 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.network.EnigmaServer;
+import cuchaz.enigma.network.Message;
+import cuchaz.enigma.network.ServerPacketHandler;
+import cuchaz.enigma.translation.representation.entry.Entry;
+import cuchaz.enigma.utils.Utils;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+public class ChangeDocsC2SPacket implements Packet<ServerPacketHandler> {
+        private Entry<?> entry;
+        private String newDocs;
+
+        ChangeDocsC2SPacket() {
+        }
+
+        public ChangeDocsC2SPacket(Entry<?> entry, String newDocs) {
+                this.entry = entry;
+                this.newDocs = newDocs;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                this.entry = PacketHelper.readEntry(input);
+                this.newDocs = PacketHelper.readString(input);
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                PacketHelper.writeEntry(output, entry);
+                PacketHelper.writeString(output, newDocs);
+        }
+
+        @Override
+        public void handle(ServerPacketHandler handler) {
+                EntryMapping mapping = handler.getServer().getMappings().getDeobfMapping(entry);
+
+                boolean valid = handler.getServer().canModifyEntry(handler.getClient(), entry);
+                if (!valid) {
+                        String oldDocs = mapping == null ? null : mapping.getJavadoc();
+                        handler.getServer().sendPacket(handler.getClient(), new ChangeDocsS2CPacket(EnigmaServer.DUMMY_SYNC_ID, entry, oldDocs == null ? "" : oldDocs));
+                        return;
+                }
+
+                if (mapping == null) {
+                        mapping = new EntryMapping(handler.getServer().getMappings().deobfuscate(entry).getName());
+                }
+                handler.getServer().getMappings().mapFromObf(entry, mapping.withDocs(Utils.isBlank(newDocs) ? null : newDocs));
+
+                int syncId = handler.getServer().lockEntry(handler.getClient(), entry);
+                handler.getServer().sendToAllExcept(handler.getClient(), new ChangeDocsS2CPacket(syncId, entry, newDocs));
+                handler.getServer().sendMessage(Message.editDocs(handler.getServer().getUsername(handler.getClient()), entry));
+        }
+
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/ChangeDocsS2CPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/ChangeDocsS2CPacket.java
new file mode 100644
index 00000000..12a30253
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/ChangeDocsS2CPacket.java
@@ -0,0 +1,44 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.network.ClientPacketHandler;
+import cuchaz.enigma.translation.representation.entry.Entry;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+public class ChangeDocsS2CPacket implements Packet<ClientPacketHandler> {
+        private int syncId;
+        private Entry<?> entry;
+        private String newDocs;
+
+        ChangeDocsS2CPacket() {
+        }
+
+        public ChangeDocsS2CPacket(int syncId, Entry<?> entry, String newDocs) {
+                this.syncId = syncId;
+                this.entry = entry;
+                this.newDocs = newDocs;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                this.syncId = input.readUnsignedShort();
+                this.entry = PacketHelper.readEntry(input);
+                this.newDocs = PacketHelper.readString(input);
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                output.writeShort(syncId);
+                PacketHelper.writeEntry(output, entry);
+                PacketHelper.writeString(output, newDocs);
+        }
+
+        @Override
+        public void handle(ClientPacketHandler controller) {
+                controller.changeDocs(new EntryReference<>(entry, entry.getName()), newDocs, false);
+                controller.sendPacket(new ConfirmChangeC2SPacket(syncId));
+        }
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/ConfirmChangeC2SPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/ConfirmChangeC2SPacket.java
new file mode 100644
index 00000000..78ef9645
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/ConfirmChangeC2SPacket.java
@@ -0,0 +1,33 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.network.ServerPacketHandler;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+public class ConfirmChangeC2SPacket implements Packet<ServerPacketHandler> {
+        private int syncId;
+
+        ConfirmChangeC2SPacket() {
+        }
+
+        public ConfirmChangeC2SPacket(int syncId) {
+                this.syncId = syncId;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                this.syncId = input.readUnsignedShort();
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                output.writeShort(syncId);
+        }
+
+        @Override
+        public void handle(ServerPacketHandler handler) {
+                handler.getServer().confirmChange(handler.getClient(), syncId);
+        }
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/KickS2CPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/KickS2CPacket.java
new file mode 100644
index 00000000..9a112a80
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/KickS2CPacket.java
@@ -0,0 +1,33 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.network.ClientPacketHandler;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+public class KickS2CPacket implements Packet<ClientPacketHandler> {
+        private String reason;
+
+        KickS2CPacket() {
+        }
+
+        public KickS2CPacket(String reason) {
+                this.reason = reason;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                this.reason = PacketHelper.readString(input);
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                PacketHelper.writeString(output, reason);
+        }
+
+        @Override
+        public void handle(ClientPacketHandler controller) {
+                controller.disconnectIfConnected(reason);
+        }
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/LoginC2SPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/LoginC2SPacket.java
new file mode 100644
index 00000000..da0f44a5
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/LoginC2SPacket.java
@@ -0,0 +1,75 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.network.EnigmaServer;
+import cuchaz.enigma.network.ServerPacketHandler;
+import cuchaz.enigma.network.Message;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class LoginC2SPacket implements Packet<ServerPacketHandler> {
+        private byte[] jarChecksum;
+        private char[] password;
+        private String username;
+
+        LoginC2SPacket() {
+        }
+
+        public LoginC2SPacket(byte[] jarChecksum, char[] password, String username) {
+                this.jarChecksum = jarChecksum;
+                this.password = password;
+                this.username = username;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                if (input.readUnsignedShort() != EnigmaServer.PROTOCOL_VERSION) {
+                        throw new IOException("Mismatching protocol");
+                }
+                this.jarChecksum = new byte[EnigmaServer.CHECKSUM_SIZE];
+                input.readFully(jarChecksum);
+                this.password = new char[input.readUnsignedByte()];
+                for (int i = 0; i < password.length; i++) {
+                        password[i] = input.readChar();
+                }
+                this.username = PacketHelper.readString(input);
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                output.writeShort(EnigmaServer.PROTOCOL_VERSION);
+                output.write(jarChecksum);
+                output.writeByte(password.length);
+                for (char c : password) {
+                        output.writeChar(c);
+                }
+                PacketHelper.writeString(output, username);
+        }
+
+        @Override
+        public void handle(ServerPacketHandler handler) {
+                boolean usernameTaken = handler.getServer().isUsernameTaken(username);
+                handler.getServer().setUsername(handler.getClient(), username);
+                handler.getServer().log(username + " logged in with IP " + handler.getClient().getInetAddress().toString() + ":" + handler.getClient().getPort());
+
+                if (!Arrays.equals(password, handler.getServer().getPassword())) {
+                        handler.getServer().kick(handler.getClient(), "disconnect.wrong_password");
+                        return;
+                }
+
+                if (usernameTaken) {
+                        handler.getServer().kick(handler.getClient(), "disconnect.username_taken");
+                        return;
+                }
+
+                if (!Arrays.equals(jarChecksum, handler.getServer().getJarChecksum())) {
+                        handler.getServer().kick(handler.getClient(), "disconnect.wrong_jar");
+                        return;
+                }
+
+                handler.getServer().sendPacket(handler.getClient(), new SyncMappingsS2CPacket(handler.getServer().getMappings().getObfToDeobf()));
+                handler.getServer().sendMessage(Message.connect(username));
+        }
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/MarkDeobfuscatedC2SPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/MarkDeobfuscatedC2SPacket.java
new file mode 100644
index 00000000..a41c620f
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/MarkDeobfuscatedC2SPacket.java
@@ -0,0 +1,48 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.network.ServerPacketHandler;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.representation.entry.Entry;
+import cuchaz.enigma.network.Message;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+public class MarkDeobfuscatedC2SPacket implements Packet<ServerPacketHandler> {
+        private Entry<?> entry;
+
+        MarkDeobfuscatedC2SPacket() {
+        }
+
+        public MarkDeobfuscatedC2SPacket(Entry<?> entry) {
+                this.entry = entry;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                this.entry = PacketHelper.readEntry(input);
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                PacketHelper.writeEntry(output, entry);
+        }
+
+        @Override
+        public void handle(ServerPacketHandler handler) {
+                boolean valid = handler.getServer().canModifyEntry(handler.getClient(), entry);
+                if (!valid) {
+                        handler.getServer().sendCorrectMapping(handler.getClient(), entry, true);
+                        return;
+                }
+
+                handler.getServer().getMappings().mapFromObf(entry, new EntryMapping(handler.getServer().getMappings().deobfuscate(entry).getName()));
+                handler.getServer().log(handler.getServer().getUsername(handler.getClient()) + " marked " + entry + " as deobfuscated");
+
+                int syncId = handler.getServer().lockEntry(handler.getClient(), entry);
+                handler.getServer().sendToAllExcept(handler.getClient(), new MarkDeobfuscatedS2CPacket(syncId, entry));
+                handler.getServer().sendMessage(Message.markDeobf(handler.getServer().getUsername(handler.getClient()), entry));
+
+        }
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/MarkDeobfuscatedS2CPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/MarkDeobfuscatedS2CPacket.java
new file mode 100644
index 00000000..7504430d
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/MarkDeobfuscatedS2CPacket.java
@@ -0,0 +1,40 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.network.ClientPacketHandler;
+import cuchaz.enigma.translation.representation.entry.Entry;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+public class MarkDeobfuscatedS2CPacket implements Packet<ClientPacketHandler> {
+        private int syncId;
+        private Entry<?> entry;
+
+        MarkDeobfuscatedS2CPacket() {
+        }
+
+        public MarkDeobfuscatedS2CPacket(int syncId, Entry<?> entry) {
+                this.syncId = syncId;
+                this.entry = entry;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                this.syncId = input.readUnsignedShort();
+                this.entry = PacketHelper.readEntry(input);
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                output.writeShort(syncId);
+                PacketHelper.writeEntry(output, entry);
+        }
+
+        @Override
+        public void handle(ClientPacketHandler controller) {
+                controller.markAsDeobfuscated(new EntryReference<>(entry, entry.getName()), false);
+                controller.sendPacket(new ConfirmChangeC2SPacket(syncId));
+        }
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/MessageC2SPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/MessageC2SPacket.java
new file mode 100644
index 00000000..3bc09e79
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/MessageC2SPacket.java
@@ -0,0 +1,39 @@
+package cuchaz.enigma.network.packet;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import cuchaz.enigma.network.ServerPacketHandler;
+import cuchaz.enigma.network.Message;
+
+public class MessageC2SPacket implements Packet<ServerPacketHandler> {
+
+        private String message;
+
+        MessageC2SPacket() {
+        }
+
+        public MessageC2SPacket(String message) {
+                this.message = message;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                message = PacketHelper.readString(input);
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                PacketHelper.writeString(output, message);
+        }
+
+        @Override
+        public void handle(ServerPacketHandler handler) {
+                String message = this.message.trim();
+                if (!message.isEmpty()) {
+                        handler.getServer().sendMessage(Message.chat(handler.getServer().getUsername(handler.getClient()), message));
+                }
+        }
+
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/MessageS2CPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/MessageS2CPacket.java
new file mode 100644
index 00000000..2b07968d
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/MessageS2CPacket.java
@@ -0,0 +1,36 @@
+package cuchaz.enigma.network.packet;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import cuchaz.enigma.network.ClientPacketHandler;
+import cuchaz.enigma.network.Message;
+
+public class MessageS2CPacket implements Packet<ClientPacketHandler> {
+
+        private Message message;
+
+        MessageS2CPacket() {
+        }
+
+        public MessageS2CPacket(Message message) {
+                this.message = message;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                message = Message.read(input);
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                message.write(output);
+        }
+
+        @Override
+        public void handle(ClientPacketHandler handler) {
+                handler.addMessage(message);
+        }
+
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/Packet.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/Packet.java
new file mode 100644
index 00000000..2f16dfb9
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/Packet.java
@@ -0,0 +1,15 @@
+package cuchaz.enigma.network.packet;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+public interface Packet<H> {
+
+        void read(DataInput input) throws IOException;
+
+        void write(DataOutput output) throws IOException;
+
+        void handle(H handler);
+
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/PacketHelper.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/PacketHelper.java
new file mode 100644
index 00000000..464606e0
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/PacketHelper.java
@@ -0,0 +1,135 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.translation.representation.MethodDescriptor;
+import cuchaz.enigma.translation.representation.TypeDescriptor;
+import cuchaz.enigma.translation.representation.entry.ClassEntry;
+import cuchaz.enigma.translation.representation.entry.Entry;
+import cuchaz.enigma.translation.representation.entry.FieldEntry;
+import cuchaz.enigma.translation.representation.entry.LocalVariableEntry;
+import cuchaz.enigma.translation.representation.entry.MethodEntry;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+public class PacketHelper {
+
+        private static final int ENTRY_CLASS = 0, ENTRY_FIELD = 1, ENTRY_METHOD = 2, ENTRY_LOCAL_VAR = 3;
+        private static final int MAX_STRING_LENGTH = 65535;
+
+        public static Entry<?> readEntry(DataInput input) throws IOException {
+                return readEntry(input, null, true);
+        }
+
+        public static Entry<?> readEntry(DataInput input, Entry<?> parent, boolean includeParent) throws IOException {
+                int type = input.readUnsignedByte();
+
+                if (includeParent && input.readBoolean()) {
+                        parent = readEntry(input, null, true);
+                }
+
+                String name = readString(input);
+
+                String javadocs = null;
+                if (input.readBoolean()) {
+                        javadocs = readString(input);
+                }
+
+                switch (type) {
+                case ENTRY_CLASS: {
+                        if (parent != null && !(parent instanceof ClassEntry)) {
+                                throw new IOException("Class requires class parent");
+                        }
+                        return new ClassEntry((ClassEntry) parent, name, javadocs);
+                }
+                case ENTRY_FIELD: {
+                        if (!(parent instanceof ClassEntry)) {
+                                throw new IOException("Field requires class parent");
+                        }
+                        TypeDescriptor desc = new TypeDescriptor(readString(input));
+                        return new FieldEntry((ClassEntry) parent, name, desc, javadocs);
+                }
+                case ENTRY_METHOD: {
+                        if (!(parent instanceof ClassEntry)) {
+                                throw new IOException("Method requires class parent");
+                        }
+                        MethodDescriptor desc = new MethodDescriptor(readString(input));
+                        return new MethodEntry((ClassEntry) parent, name, desc, javadocs);
+                }
+                case ENTRY_LOCAL_VAR: {
+                        if (!(parent instanceof MethodEntry)) {
+                                throw new IOException("Local variable requires method parent");
+                        }
+                        int index = input.readUnsignedShort();
+                        boolean parameter = input.readBoolean();
+                        return new LocalVariableEntry((MethodEntry) parent, index, name, parameter, javadocs);
+                }
+                default: throw new IOException("Received unknown entry type " + type);
+                }
+        }
+
+        public static void writeEntry(DataOutput output, Entry<?> entry) throws IOException {
+                writeEntry(output, entry, true);
+        }
+
+        public static void writeEntry(DataOutput output, Entry<?> entry, boolean includeParent) throws IOException {
+                // type
+                if (entry instanceof ClassEntry) {
+                        output.writeByte(ENTRY_CLASS);
+                } else if (entry instanceof FieldEntry) {
+                        output.writeByte(ENTRY_FIELD);
+                } else if (entry instanceof MethodEntry) {
+                        output.writeByte(ENTRY_METHOD);
+                } else if (entry instanceof LocalVariableEntry) {
+                        output.writeByte(ENTRY_LOCAL_VAR);
+                } else {
+                        throw new IOException("Don't know how to serialize entry of type " + entry.getClass().getSimpleName());
+                }
+
+                // parent
+                if (includeParent) {
+                        output.writeBoolean(entry.getParent() != null);
+                        if (entry.getParent() != null) {
+                                writeEntry(output, entry.getParent(), true);
+                        }
+                }
+
+                // name
+                writeString(output, entry.getName());
+
+                // javadocs
+                output.writeBoolean(entry.getJavadocs() != null);
+                if (entry.getJavadocs() != null) {
+                        writeString(output, entry.getJavadocs());
+                }
+
+                // type-specific stuff
+                if (entry instanceof FieldEntry) {
+                        writeString(output, ((FieldEntry) entry).getDesc().toString());
+                } else if (entry instanceof MethodEntry) {
+                        writeString(output, ((MethodEntry) entry).getDesc().toString());
+                } else if (entry instanceof LocalVariableEntry) {
+                        LocalVariableEntry localVar = (LocalVariableEntry) entry;
+                        output.writeShort(localVar.getIndex());
+                        output.writeBoolean(localVar.isArgument());
+                }
+        }
+
+        public static String readString(DataInput input) throws IOException {
+                int length = input.readUnsignedShort();
+                byte[] bytes = new byte[length];
+                input.readFully(bytes);
+                return new String(bytes, StandardCharsets.UTF_8);
+        }
+
+        public static void writeString(DataOutput output, String str) throws IOException {
+                byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
+                if (bytes.length > MAX_STRING_LENGTH) {
+                        throw new IOException("String too long, was " + bytes.length + " bytes, max " + MAX_STRING_LENGTH + " allowed");
+                }
+                output.writeShort(bytes.length);
+                output.write(bytes);
+        }
+
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/PacketRegistry.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/PacketRegistry.java
new file mode 100644
index 00000000..3b8af81c
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/PacketRegistry.java
@@ -0,0 +1,64 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.network.ClientPacketHandler;
+import cuchaz.enigma.network.ServerPacketHandler;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Supplier;
+
+public class PacketRegistry {
+
+        private static final Map<Class<? extends Packet<ServerPacketHandler>>, Integer> c2sPacketIds = new HashMap<>();
+        private static final Map<Integer, Supplier<? extends Packet<ServerPacketHandler>>> c2sPacketCreators = new HashMap<>();
+        private static final Map<Class<? extends Packet<ClientPacketHandler>>, Integer> s2cPacketIds = new HashMap<>();
+        private static final Map<Integer, Supplier<? extends Packet<ClientPacketHandler>>> s2cPacketCreators = new HashMap<>();
+
+        private static <T extends Packet<ServerPacketHandler>> void registerC2S(int id, Class<T> clazz, Supplier<T> creator) {
+                c2sPacketIds.put(clazz, id);
+                c2sPacketCreators.put(id, creator);
+        }
+
+        private static <T extends Packet<ClientPacketHandler>> void registerS2C(int id, Class<T> clazz, Supplier<T> creator) {
+                s2cPacketIds.put(clazz, id);
+                s2cPacketCreators.put(id, creator);
+        }
+
+        static {
+                registerC2S(0, LoginC2SPacket.class, LoginC2SPacket::new);
+                registerC2S(1, ConfirmChangeC2SPacket.class, ConfirmChangeC2SPacket::new);
+                registerC2S(2, RenameC2SPacket.class, RenameC2SPacket::new);
+                registerC2S(3, RemoveMappingC2SPacket.class, RemoveMappingC2SPacket::new);
+                registerC2S(4, ChangeDocsC2SPacket.class, ChangeDocsC2SPacket::new);
+                registerC2S(5, MarkDeobfuscatedC2SPacket.class, MarkDeobfuscatedC2SPacket::new);
+                registerC2S(6, MessageC2SPacket.class, MessageC2SPacket::new);
+
+                registerS2C(0, KickS2CPacket.class, KickS2CPacket::new);
+                registerS2C(1, SyncMappingsS2CPacket.class, SyncMappingsS2CPacket::new);
+                registerS2C(2, RenameS2CPacket.class, RenameS2CPacket::new);
+                registerS2C(3, RemoveMappingS2CPacket.class, RemoveMappingS2CPacket::new);
+                registerS2C(4, ChangeDocsS2CPacket.class, ChangeDocsS2CPacket::new);
+                registerS2C(5, MarkDeobfuscatedS2CPacket.class, MarkDeobfuscatedS2CPacket::new);
+                registerS2C(6, MessageS2CPacket.class, MessageS2CPacket::new);
+                registerS2C(7, UserListS2CPacket.class, UserListS2CPacket::new);
+        }
+
+        public static int getC2SId(Packet<ServerPacketHandler> packet) {
+                return c2sPacketIds.get(packet.getClass());
+        }
+
+        public static Packet<ServerPacketHandler> createC2SPacket(int id) {
+                Supplier<? extends Packet<ServerPacketHandler>> creator = c2sPacketCreators.get(id);
+                return creator == null ? null : creator.get();
+        }
+
+        public static int getS2CId(Packet<ClientPacketHandler> packet) {
+                return s2cPacketIds.get(packet.getClass());
+        }
+
+        public static Packet<ClientPacketHandler> createS2CPacket(int id) {
+                Supplier<? extends Packet<ClientPacketHandler>> creator = s2cPacketCreators.get(id);
+                return creator == null ? null : creator.get();
+        }
+
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/RemoveMappingC2SPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/RemoveMappingC2SPacket.java
new file mode 100644
index 00000000..3f852285
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/RemoveMappingC2SPacket.java
@@ -0,0 +1,55 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.network.ServerPacketHandler;
+import cuchaz.enigma.translation.mapping.IllegalNameException;
+import cuchaz.enigma.translation.representation.entry.Entry;
+import cuchaz.enigma.network.Message;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+public class RemoveMappingC2SPacket implements Packet<ServerPacketHandler> {
+        private Entry<?> entry;
+
+        RemoveMappingC2SPacket() {
+        }
+
+        public RemoveMappingC2SPacket(Entry<?> entry) {
+                this.entry = entry;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                this.entry = PacketHelper.readEntry(input);
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                PacketHelper.writeEntry(output, entry);
+        }
+
+        @Override
+        public void handle(ServerPacketHandler handler) {
+                boolean valid = handler.getServer().canModifyEntry(handler.getClient(), entry);
+
+                if (valid) {
+                        try {
+                                handler.getServer().getMappings().removeByObf(entry);
+                        } catch (IllegalNameException e) {
+                                valid = false;
+                        }
+                }
+
+                if (!valid) {
+                        handler.getServer().sendCorrectMapping(handler.getClient(), entry, true);
+                        return;
+                }
+
+                handler.getServer().log(handler.getServer().getUsername(handler.getClient()) + " removed the mapping for " + entry);
+
+                int syncId = handler.getServer().lockEntry(handler.getClient(), entry);
+                handler.getServer().sendToAllExcept(handler.getClient(), new RemoveMappingS2CPacket(syncId, entry));
+                handler.getServer().sendMessage(Message.removeMapping(handler.getServer().getUsername(handler.getClient()), entry));
+        }
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/RemoveMappingS2CPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/RemoveMappingS2CPacket.java
new file mode 100644
index 00000000..70d803c1
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/RemoveMappingS2CPacket.java
@@ -0,0 +1,40 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.network.ClientPacketHandler;
+import cuchaz.enigma.translation.representation.entry.Entry;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+public class RemoveMappingS2CPacket implements Packet<ClientPacketHandler> {
+        private int syncId;
+        private Entry<?> entry;
+
+        RemoveMappingS2CPacket() {
+        }
+
+        public RemoveMappingS2CPacket(int syncId, Entry<?> entry) {
+                this.syncId = syncId;
+                this.entry = entry;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                this.syncId = input.readUnsignedShort();
+                this.entry = PacketHelper.readEntry(input);
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                output.writeShort(syncId);
+                PacketHelper.writeEntry(output, entry);
+        }
+
+        @Override
+        public void handle(ClientPacketHandler controller) {
+                controller.removeMapping(new EntryReference<>(entry, entry.getName()), false);
+                controller.sendPacket(new ConfirmChangeC2SPacket(syncId));
+        }
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/RenameC2SPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/RenameC2SPacket.java
new file mode 100644
index 00000000..e3e7e379
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/RenameC2SPacket.java
@@ -0,0 +1,64 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.network.ServerPacketHandler;
+import cuchaz.enigma.translation.mapping.IllegalNameException;
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.representation.entry.Entry;
+import cuchaz.enigma.network.Message;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+public class RenameC2SPacket implements Packet<ServerPacketHandler> {
+        private Entry<?> entry;
+        private String newName;
+        private boolean refreshClassTree;
+
+        RenameC2SPacket() {
+        }
+
+        public RenameC2SPacket(Entry<?> entry, String newName, boolean refreshClassTree) {
+                this.entry = entry;
+                this.newName = newName;
+                this.refreshClassTree = refreshClassTree;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                this.entry = PacketHelper.readEntry(input);
+                this.newName = PacketHelper.readString(input);
+                this.refreshClassTree = input.readBoolean();
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                PacketHelper.writeEntry(output, entry);
+                PacketHelper.writeString(output, newName);
+                output.writeBoolean(refreshClassTree);
+        }
+
+        @Override
+        public void handle(ServerPacketHandler handler) {
+                boolean valid = handler.getServer().canModifyEntry(handler.getClient(), entry);
+
+                if (valid) {
+                        try {
+                                handler.getServer().getMappings().mapFromObf(entry, new EntryMapping(newName));
+                        } catch (IllegalNameException e) {
+                                valid = false;
+                        }
+                }
+
+                if (!valid) {
+                        handler.getServer().sendCorrectMapping(handler.getClient(), entry, refreshClassTree);
+                        return;
+                }
+
+                handler.getServer().log(handler.getServer().getUsername(handler.getClient()) + " renamed " + entry + " to " + newName);
+
+                int syncId = handler.getServer().lockEntry(handler.getClient(), entry);
+                handler.getServer().sendToAllExcept(handler.getClient(), new RenameS2CPacket(syncId, entry, newName, refreshClassTree));
+                handler.getServer().sendMessage(Message.rename(handler.getServer().getUsername(handler.getClient()), entry, newName));
+        }
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/RenameS2CPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/RenameS2CPacket.java
new file mode 100644
index 00000000..787e89e6
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/RenameS2CPacket.java
@@ -0,0 +1,48 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.analysis.EntryReference;
+import cuchaz.enigma.network.ClientPacketHandler;
+import cuchaz.enigma.translation.representation.entry.Entry;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+public class RenameS2CPacket implements Packet<ClientPacketHandler> {
+        private int syncId;
+        private Entry<?> entry;
+        private String newName;
+        private boolean refreshClassTree;
+
+        RenameS2CPacket() {
+        }
+
+        public RenameS2CPacket(int syncId, Entry<?> entry, String newName, boolean refreshClassTree) {
+                this.syncId = syncId;
+                this.entry = entry;
+                this.newName = newName;
+                this.refreshClassTree = refreshClassTree;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                this.syncId = input.readUnsignedShort();
+                this.entry = PacketHelper.readEntry(input);
+                this.newName = PacketHelper.readString(input);
+                this.refreshClassTree = input.readBoolean();
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                output.writeShort(syncId);
+                PacketHelper.writeEntry(output, entry);
+                PacketHelper.writeString(output, newName);
+                output.writeBoolean(refreshClassTree);
+        }
+
+        @Override
+        public void handle(ClientPacketHandler controller) {
+                controller.rename(new EntryReference<>(entry, entry.getName()), newName, refreshClassTree, false);
+                controller.sendPacket(new ConfirmChangeC2SPacket(syncId));
+        }
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/SyncMappingsS2CPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/SyncMappingsS2CPacket.java
new file mode 100644
index 00000000..76ecbc7d
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/SyncMappingsS2CPacket.java
@@ -0,0 +1,88 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.translation.mapping.EntryMapping;
+import cuchaz.enigma.translation.mapping.tree.EntryTree;
+import cuchaz.enigma.translation.mapping.tree.EntryTreeNode;
+import cuchaz.enigma.translation.mapping.tree.HashEntryTree;
+import cuchaz.enigma.network.ClientPacketHandler;
+import cuchaz.enigma.network.EnigmaServer;
+import cuchaz.enigma.translation.representation.entry.Entry;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class SyncMappingsS2CPacket implements Packet<ClientPacketHandler> {
+        private EntryTree<EntryMapping> mappings;
+
+        SyncMappingsS2CPacket() {
+        }
+
+        public SyncMappingsS2CPacket(EntryTree<EntryMapping> mappings) {
+                this.mappings = mappings;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                mappings = new HashEntryTree<>();
+                int size = input.readInt();
+                for (int i = 0; i < size; i++) {
+                        readEntryTreeNode(input, null);
+                }
+        }
+
+        private void readEntryTreeNode(DataInput input, Entry<?> parent) throws IOException {
+                Entry<?> entry = PacketHelper.readEntry(input, parent, false);
+                EntryMapping mapping = null;
+                if (input.readBoolean()) {
+                        String name = input.readUTF();
+                        if (input.readBoolean()) {
+                                String javadoc = input.readUTF();
+                                mapping = new EntryMapping(name, javadoc);
+                        } else {
+                                mapping = new EntryMapping(name);
+                        }
+                }
+                mappings.insert(entry, mapping);
+                int size = input.readUnsignedShort();
+                for (int i = 0; i < size; i++) {
+                        readEntryTreeNode(input, entry);
+                }
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                List<EntryTreeNode<EntryMapping>> roots = mappings.getRootNodes().collect(Collectors.toList());
+                output.writeInt(roots.size());
+                for (EntryTreeNode<EntryMapping> node : roots) {
+                        writeEntryTreeNode(output, node);
+                }
+        }
+
+        private static void writeEntryTreeNode(DataOutput output, EntryTreeNode<EntryMapping> node) throws IOException {
+                PacketHelper.writeEntry(output, node.getEntry(), false);
+                EntryMapping value = node.getValue();
+                output.writeBoolean(value != null);
+                if (value != null) {
+                        PacketHelper.writeString(output, value.getTargetName());
+                        output.writeBoolean(value.getJavadoc() != null);
+                        if (value.getJavadoc() != null) {
+                                PacketHelper.writeString(output, value.getJavadoc());
+                        }
+                }
+                Collection<? extends EntryTreeNode<EntryMapping>> children = node.getChildNodes();
+                output.writeShort(children.size());
+                for (EntryTreeNode<EntryMapping> child : children) {
+                        writeEntryTreeNode(output, child);
+                }
+        }
+
+        @Override
+        public void handle(ClientPacketHandler controller) {
+                controller.openMappings(mappings);
+                controller.sendPacket(new ConfirmChangeC2SPacket(EnigmaServer.DUMMY_SYNC_ID));
+        }
+}
diff --git a/enigma-server/src/main/java/cuchaz/enigma/network/packet/UserListS2CPacket.java b/enigma-server/src/main/java/cuchaz/enigma/network/packet/UserListS2CPacket.java
new file mode 100644
index 00000000..b4a277a4
--- /dev/null
+++ b/enigma-server/src/main/java/cuchaz/enigma/network/packet/UserListS2CPacket.java
@@ -0,0 +1,44 @@
+package cuchaz.enigma.network.packet;
+
+import cuchaz.enigma.network.ClientPacketHandler;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class UserListS2CPacket implements Packet<ClientPacketHandler> {
+
+        private List<String> users;
+
+        UserListS2CPacket() {
+        }
+
+        public UserListS2CPacket(List<String> users) {
+                this.users = users;
+        }
+
+        @Override
+        public void read(DataInput input) throws IOException {
+                int len = input.readUnsignedShort();
+                users = new ArrayList<>(len);
+                for (int i = 0; i < len; i++) {
+                        users.add(input.readUTF());
+                }
+        }
+
+        @Override
+        public void write(DataOutput output) throws IOException {
+                output.writeShort(users.size());
+                for (String user : users) {
+                        PacketHelper.writeString(output, user);
+                }
+        }
+
+        @Override
+        public void handle(ClientPacketHandler handler) {
+                handler.updateUserList(users);
+        }
+
+}