FTB:IE/1.7.10+Forge: UpdateSign_u16 Error("EOF while parsing a value",

[iceiix]

Connecting to an FTB:IE server (modded 1.7.10) panics on parsing a sign packet, as noted in #134:

panic from UpdateSign_u16

about to parse id=33, dir=Clientbound state=Play
thread '' panicked at 'called Result::unwrap() on an Err value: Error("EOF while parsing a value", line: 1, column: 0)', src/libcore/result.rs:997:5

https://wiki.vg/index.php?title=Protocol&oldid=6003#Update_Sign

steven $ hexdump -C last-packet 
00000000  33 ff ff fe c1 00 53 00  00 00 a6 00 0a 41 70 6f  |3.....S......Apo|
00000010  74 68 65 63 61 72 79 00  00                       |thecary..|
00000019

[iceiix]

with RUST_BACKTRACE=full:

// src/protocol/mod.rs
  10: <stevenarella::format::Component as stevenarella::protocol::Serializable>::read_from
             at src/protocol/mod.rs:280
  11: stevenarella::protocol::packet::packet_by_id
             at src/protocol/mod.rs:140
  12: stevenarella::protocol::Conn::read_packet
             at src/protocol/mod.rs:994
  13: stevenarella::server::Server::spawn_reader::{{closure}}
             at src/server/mod.rs:216

crashing deserializing JSON:

// src/format.rs
impl Serializable for format::Component {
    fn read_from<R: io::Read>(buf: &mut R) -> Result<Self, Error> {
        let len = VarInt::read_from(buf)?.0;
        let mut ret = String::new();
        buf.take(len as u64).read_to_string(&mut ret)?;
        let val: serde_json::Value = serde_json::from_str(&ret[..]).unwrap();

presumably because it is a literal string "Apothecary" instead of JSON? But wouldn't this not take care of it:

impl Component {

    pub fn from_string(str: &str) -> Self {
        let mut component;
        match serde_json::from_str::<serde_json::Value>(str) {
            Ok(value) => component = Component::from_value(&value),
            // Sometimes mojang sends a literal string, so we should interpret it literally
            Err(_) => {
                component = Component::Text(TextComponent::new(str));
                convert_legacy(&mut component);
            },
        }
        component
    }

[iceiix]

Debugging:

diff --git a/src/format.rs b/src/format.rs
index 29776bd..f647e68 100644
--- a/src/format.rs
+++ b/src/format.rs
@@ -24,15 +24,24 @@ pub enum Component {
 impl Component {
 
     pub fn from_string(str: &str) -> Self {
+        println!("Component from_string(str={:?})", str);
         let mut component;
         match serde_json::from_str::<serde_json::Value>(str) {
-            Ok(value) => component = Component::from_value(&value),
+            Ok(value) => {
+                println!("Component from_string ok={:?}", value);
+                component = Component::from_value(&value);
+                println!("Component component from_value component={:?}", component);
+            },
             // Sometimes mojang sends a literal string, so we should interpret it literally
             Err(_) => {
+                println!("Component str={:?}", str);
                 component = Component::Text(TextComponent::new(str));
+                println!("Component component={:?}", component);
                 convert_legacy(&mut component);
+                println!("Component convert_legacy={:?}", component);
             },
         }
+        println!("Component from_string({:?}) = {:?}", str, component);
         component
     }
 
diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs
index 97423ca..8372e32 100644
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@@ -277,8 +277,11 @@ impl Serializable for format::Component {
         let len = VarInt::read_from(buf)?.0;
         let mut ret = String::new();
         buf.take(len as u64).read_to_string(&mut ret)?;
-        let val: serde_json::Value = serde_json::from_str(&ret[..]).unwrap();
-        Result::Ok(Self::from_value(&val))
+        println!("Serializable format::Component read_from ret={:?}", ret);
+        Result::Ok(Self::from_string(&ret[..]))
+        //let val: serde_json::Value = serde_json::from_str(&ret[..]).unwrap();
+        //println!("Serializable format::Component val={:?}", val);
+        //Result::Ok(Self::from_value(&val))
     }
     fn write_to<W: io::Write>(&self, buf: &mut W) -> Result<(), Error> {
         let val = serde_json::to_string(&self.to_value()).unwrap();

[iceiix]

Why does read_from() deserialize JSON itself then call from_value() on the serde_json::Value, instead of from_string() which tries to deserialize JSON and falls back to literal text if it doesn't? This actually fixes signs rendering on 1.7.10.