Write protocol dependent lengths when encoding

CreateStringTable and TempEntities both read their payload length as a fixed
width field on protocol 23 and older and as a var int after that, but the
encoders always write the var int. Reencoding an older demo therefore hands
the game a length it can't read: string tables come back as "bogus substring
index", and any packet carrying temp entities is malformed from there on,
taking whatever messages follow it in that packet with it.

The threshold and both widths are taken from the read paths a few lines up in
these same two files rather than worked out separately, so the two sides can't
drift: > 23, with 20 bits for CreateStringTable and 17 for TempEntities. The
engine agrees, for what it's worth - netmessages.cpp reads both of these under
> PROTOCOL_VERSION_23 at NET_MAX_PAYLOAD_BITS_V23 + 3 and
NET_MAX_PAYLOAD_BITS_V23 respectively, and that constant is 17.

serverinfo and prefetch already branch on the protocol on both sides, these
two were the only ones that didn't.

On a protocol 15 demo that was 28909 of 92518 reencoded packets failing to
parse back; on test_data/protocol23.dem, 13220 of 43327. Both are zero now,
so protocol23.dem can join the reencode round trip test. Protocol 24 output
is unchanged, byte for byte.

src/demo/message/stringtable.rs

@@ -164,7 +164,7 @@ impl Encode for CreateStringTableMessage<'_> {
     fn encode(
         &self,
         stream: &mut BitWriteStream<LittleEndian>,
-        _state: &ParserState,
+        state: &ParserState,
     ) -> Result<()> {
         let table = &self.table;
         table.name.write(stream)?;
@@ -172,7 +172,14 @@ impl Encode for CreateStringTableMessage<'_> {
         let encode_bits = log_base2(table.max_entries) as usize;
         (table.entries.len() as u16).write_sized(stream, encode_bits + 1)?;
 
-        stream.reserve_int::<ParseError, _>(40, |stream| {
+        // threshold and both widths are the ones used by the read side above
+        let (length_bits, encode_length): (usize, fn(u32) -> u64) =
+            if state.protocol_version > 23 {
+                (40, encode_var_int_fixed)
+            } else {
+                (20, |length| length as u64)
+            };
+        stream.reserve_int::<ParseError, _>(length_bits, |stream| {
             table.fixed_user_data_size.is_some().write(stream)?;
             if let Some(fixed_size) = table.fixed_user_data_size {
                 fixed_size.write(stream)?;
@@ -188,7 +195,7 @@ impl Encode for CreateStringTableMessage<'_> {
             write_string_table_update(&table.entries, stream, &table_meta)?;
 
             let end = stream.bit_len();
-            Ok(encode_var_int_fixed((end - start) as u32))
+            Ok(encode_length((end - start) as u32))
         })?;
 
         Ok(())

src/demo/message/tempentities.rs

@@ -109,7 +109,14 @@ impl Encode for TempEntitiesMessage {
         };
         count.write(stream)?;
 
-        stream.reserve_int::<ParseError, _>(40, |stream| {
+        // threshold and both widths are the ones used by the read side above
+        let (length_bits, encode_length): (usize, fn(u32) -> u64) =
+            if state.protocol_version > 23 {
+                (40, encode_var_int_fixed)
+            } else {
+                (17, |length| length as u64)
+            };
+        stream.reserve_int::<ParseError, _>(length_bits, |stream| {
             let start = stream.bit_len();
             let mut last_class_id = u16::MAX.into();
 
@@ -138,7 +145,7 @@ impl Encode for TempEntitiesMessage {
                 PacketEntitiesMessage::write_update(&event.props, stream, send_table, 0u32.into())?;
             }
             let end = stream.bit_len();
-            Ok(encode_var_int_fixed((end - start) as u32))
+            Ok(encode_length((end - start) as u32))
         })?;
         Ok(())
     }

tests/reencode.rs

@@ -32,6 +32,7 @@ use tf_demo_parser::{Demo, Parse};
 #[test_case("test_data/decal.dem"; "decal.dem")]
 #[test_case("test_data/saytext2.dem"; "saytext2.dem")]
 #[test_case("test_data/emptysaytext.dem"; "emptysaytext.dem")]
+#[test_case("test_data/protocol23.dem"; "protocol23.dem")]
 fn re_encode_test(input_file: &str) {
     let file = fs::read(input_file).expect("Unable to read file");
     let demo = Demo::new(&file);