protocol: send FML2 on fmlNetworkVersion: 2

protocol/src/protocol/mod.rs

@@ -1224,6 +1224,7 @@ impl Conn {
 
         // For modded servers, get the list of Forge mods installed
         let mut forge_mods: std::vec::Vec<crate::protocol::forge::ForgeMod> = vec![];
+        let mut fml_network_version: Option<i64> = None;
         if let Some(modinfo) = val.get("modinfo") {
             if let Some(modinfo_type) = modinfo.get("type") {
                 if modinfo_type == "FML" {
@@ -1240,6 +1241,7 @@ impl Conn {
                                         .push(crate::protocol::forge::ForgeMod { modid, version });
                                 }
                             }
+                            fml_network_version = Some(1);
                         }
                     }
                 } else {
@@ -1267,6 +1269,7 @@ impl Conn {
                     }
                 }
             }
+            fml_network_version = Some(forge_data.get("fmlNetworkVersion").unwrap().as_i64().unwrap());
         }
 
         Ok((
@@ -1301,6 +1304,7 @@ impl Conn {
                     .and_then(Value::as_str)
                     .map(|v| v.to_owned()),
                 forge_mods,
+                fml_network_version,
             },
             ping,
         ))
@@ -1352,6 +1356,7 @@ pub struct Status {
     pub description: format::Component,
     pub favicon: Option<String>,
     pub forge_mods: Vec<crate::protocol::forge::ForgeMod>,
+    pub fml_network_version: Option<i64>,
 }
 
 #[derive(Debug)]

src/main.rs

@@ -91,7 +91,7 @@ pub struct Game {
 
 impl Game {
     pub fn connect_to(&mut self, address: &str) {
-        let (protocol_version, forge_mods) =
+        let (protocol_version, forge_mods, fml_network_version) =
             match protocol::Conn::new(&address, self.default_protocol_version)
                 .and_then(|conn| conn.do_status())
             {
@@ -100,14 +100,14 @@ impl Game {
                         "Detected server protocol version {}",
                         res.0.version.protocol
                     );
-                    (res.0.version.protocol, res.0.forge_mods)
+                    (res.0.version.protocol, res.0.forge_mods, res.0.fml_network_version)
                 }
                 Err(err) => {
                     warn!(
                         "Error pinging server {} to get protocol version: {:?}, defaulting to {}",
                         address, err, self.default_protocol_version
                     );
-                    (self.default_protocol_version, vec![])
+                    (self.default_protocol_version, vec![], None)
                 }
             };
 
@@ -127,6 +127,7 @@ impl Game {
                 &address,
                 protocol_version,
                 forge_mods,
+                fml_network_version,
             ))
             .unwrap();
         });

src/server/mod.rs

@@ -110,14 +110,17 @@ impl Server {
         address: &str,
         protocol_version: i32,
         forge_mods: Vec<forge::ForgeMod>,
+        fml_network_version: Option<i64>,
     ) -> Result<Server, protocol::Error> {
         let mut conn = protocol::Conn::new(address, protocol_version)?;
 
-        let tag = if !forge_mods.is_empty() {
-            "\0FML\0"
-        } else {
-            ""
+        let tag = match fml_network_version {
+            Some(1) => "\0FML\0",
+            Some(2) => "\0FML2\0",
+            None => "",
+            _ => panic!("unsupported FML network version: {:?}", fml_network_version),
         };
+
         let host = conn.host.clone() + tag;
         let port = conn.port;
         conn.write_packet(protocol::packet::handshake::serverbound::Handshake {