Replace unsafe endianness code with byteorder functions

src/protocol/frame/frame.rs

@@ -1,10 +1,10 @@
 use std::fmt;
 use std::mem::transmute;
-use std::io::{Cursor, Read, Write};
+use std::io::{Cursor, Read, Write, ErrorKind};
 use std::default::Default;
 use std::string::{String, FromUtf8Error};
 use std::result::Result as StdResult;
-use byteorder::{ByteOrder, NetworkEndian};
+use byteorder::{ByteOrder, ReadBytesExt, NetworkEndian};
 use bytes::BufMut;
 
 use rand;
@@ -319,29 +319,24 @@ impl Frame {
 
         let mut length = (second & 0x7F) as u64;
 
-        if length == 126 {
+        if let Some(length_nbytes) = match length {
-            let mut length_bytes = [0u8; 2];
+            126 => Some(2),
-            if try!(cursor.read(&mut length_bytes)) != 2 {
+            127 => Some(8),
-                cursor.set_position(initial);
+            _ => None,
-                return Ok(None)
+        } {
-            }
+            match cursor.read_uint::<NetworkEndian>(length_nbytes) {
-
+                Err(ref err) if err.kind() == ErrorKind::UnexpectedEof => {
-            length = unsafe {
+                    cursor.set_position(initial);
-                let mut wide: u16 = transmute(length_bytes);
+                    return Ok(None);
-                wide = u16::from_be(wide);
+                }
-                wide
+                Err(err) => {
-            } as u64;
+                    return Err(Error::from(err));
-            header_length += 2;
+                }
-        } else if length == 127 {
+                Ok(read) => {
-            let mut length_bytes = [0u8; 8];
+                    length = read;
-            if try!(cursor.read(&mut length_bytes)) != 8 {
+                }
-                cursor.set_position(initial);
+            };
-                return Ok(None)
+            header_length += length_nbytes as u64;
-            }
-
-            unsafe { length = transmute(length_bytes); }
-            length = u64::from_be(length);
-            header_length += 8;
         }
         trace!("Payload length: {}", length);
 
@@ -425,18 +420,14 @@ impl Frame {
             try!(w.write(&headers));
         } else if self.payload.len() <= 65535 {
             two |= 126;
-            let length_bytes: [u8; 2] = unsafe {
+            let mut length_bytes = [0u8; 2];
-                let short = self.payload.len() as u16;
+            NetworkEndian::write_u16(&mut length_bytes, self.payload.len() as u16);
-                transmute(short.to_be())
-            };
             let headers = [one, two, length_bytes[0], length_bytes[1]];
             try!(w.write(&headers));
         } else {
             two |= 127;
-            let length_bytes: [u8; 8] = unsafe {
+            let mut length_bytes = [0u8; 8];
-                let long = self.payload.len() as u64;
+            NetworkEndian::write_u64(&mut length_bytes, self.payload.len() as u64);
-                transmute(long.to_be())
-            };
             let headers = [
                 one,
                 two,