Add basic support for server-side

src/client.rs

@@ -77,7 +77,7 @@ impl Event {
                 },
                 protocol::S2C::FramebufferUpdate { count } => {
                     for _ in 0..count {
-                        let rectangle = try!(protocol::Rectangle::read_from(&mut stream));
+                        let rectangle = try!(protocol::RectangleHeader::read_from(&mut stream));
                         debug!("<- {:?}", rectangle);
 
                         let dst = Rect {

src/lib.rs

@@ -8,16 +8,21 @@ extern crate octavo;
 #[cfg(feature = "apple-auth")]
 extern crate crypto;
 
+use std::io::Write;
+use byteorder::{BigEndian, WriteBytesExt};
+
 mod protocol;
 mod zrle;
 mod security;
 
 pub mod client;
 pub mod proxy;
+pub mod server;
 
 pub use protocol::{PixelFormat, Colour, Encoding};
 pub use client::Client;
 pub use proxy::Proxy;
+pub use server::Server;
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Rect {
@@ -27,6 +32,37 @@ pub struct Rect {
     pub height: u16
 }
 
+impl Rect {
+    /// Constructs new `Rect`.
+    pub fn new(left: u16, top: u16, width: u16, height: u16) -> Self {
+        Rect {
+            left: left,
+            top: top,
+            width: width,
+            height: height,
+        }
+    }
+
+    /// Constructs new zero-sized `Rect` placed at (0, 0).
+    pub fn new_empty() -> Self {
+        Rect {
+            left: 0,
+            top: 0,
+            width: 0,
+            height: 0,
+        }
+    }
+
+    /// Writes `Rect` to given stream.
+    fn write_to<W: Write>(&self, writer: &mut W) -> Result<()> {
+        try!(writer.write_u16::<BigEndian>(self.left));
+        try!(writer.write_u16::<BigEndian>(self.top));
+        try!(writer.write_u16::<BigEndian>(self.width));
+        try!(writer.write_u16::<BigEndian>(self.height));
+        Ok(())
+    }
+}
+
 #[derive(Debug)]
 pub enum Error {
     Io(std::io::Error),

src/protocol.rs

@@ -237,6 +237,40 @@ pub struct PixelFormat {
     pub blue_shift:     u8,
 }
 
+impl PixelFormat {
+    /// Creates RGB pixel format with 4 bytes per pixel and 3 bytes of depth.
+    pub fn new_rgb8888() -> Self {
+        PixelFormat {
+            bits_per_pixel: 32,
+            depth: 24,
+            big_endian: true,
+            true_colour: true,
+            red_max: 255,
+            green_max: 255,
+            blue_max: 255,
+            red_shift: 0,
+            green_shift: 8,
+            blue_shift: 16,
+        }
+    }
+
+    /// Creates BGR pixel format with 4 bytes per pixel and 3 bytes of depth.
+    pub fn new_bgr8888() -> Self {
+        PixelFormat {
+            bits_per_pixel: 32,
+            depth: 24,
+            big_endian: true,
+            true_colour: true,
+            red_max: 255,
+            green_max: 255,
+            blue_max: 255,
+            red_shift: 16,
+            green_shift: 8,
+            blue_shift: 0,
+        }
+    }
+}
+
 impl Message for PixelFormat {
     fn read_from<R: Read>(reader: &mut R) -> Result<PixelFormat> {
         let pixel_format = PixelFormat {
@@ -330,7 +364,9 @@ pub enum Encoding {
     Zrle,
     Cursor,
     DesktopSize,
+
     // extensions
+    ExtendedKeyEvent,
 }
 
 impl Message for Encoding {
@@ -344,6 +380,7 @@ impl Message for Encoding {
             16   => Ok(Encoding::Zrle),
             -239 => Ok(Encoding::Cursor),
             -223 => Ok(Encoding::DesktopSize),
+            -258 => Ok(Encoding::ExtendedKeyEvent),
             n    => Ok(Encoding::Unknown(n))
         }
     }
@@ -357,6 +394,7 @@ impl Message for Encoding {
             &Encoding::Zrle => 16,
             &Encoding::Cursor => -239,
             &Encoding::DesktopSize => -223,
+            &Encoding::ExtendedKeyEvent => -258,
             &Encoding::Unknown(n) => n
         };
         try!(writer.write_i32::<BigEndian>(encoding));
@@ -386,7 +424,13 @@ pub enum C2S {
         y_position:  u16
     },
     CutText(String),
+
     // extensions
+    ExtendedKeyEvent {
+        down:        bool,
+        keysym:      u32,
+        keycode:     u32,
+    },
 }
 
 impl Message for C2S {
@@ -437,6 +481,18 @@ impl Message for C2S {
                 try!(reader.read_exact(&mut [0u8; 3]));
                 Ok(C2S::CutText(try!(String::read_from(reader))))
             },
+            255 => {
+                let submessage_type = try!(reader.read_u8());
+                match submessage_type {
+                    0 => {
+                        let down = try!(reader.read_u16::<BigEndian>()) != 0;
+                        let keysym = try!(reader.read_u32::<BigEndian>());
+                        let keycode = try!(reader.read_u32::<BigEndian>());
+                        Ok(C2S::ExtendedKeyEvent { down: down, keysym: keysym, keycode: keycode })
+                    }
+                    _ => Err(Error::Unexpected("server to client QEMU submessage type"))
+                }
+            }
             _ => Err(Error::Unexpected("client to server message type"))
         }
     }
@@ -478,23 +534,30 @@ impl Message for C2S {
             &C2S::CutText(ref text) => {
                 try!(String::write_to(text, writer));
             }
+            &C2S::ExtendedKeyEvent { down, keysym, keycode } => {
+                try!(writer.write_u8(255));
+                try!(writer.write_u8(0));
+                try!(writer.write_u16::<BigEndian>(if down { 1 } else { 0 }));
+                try!(writer.write_u32::<BigEndian>(keysym));
+                try!(writer.write_u32::<BigEndian>(keycode));
+            }
         }
         Ok(())
     }
 }
 
 #[derive(Debug)]
-pub struct Rectangle {
+pub struct RectangleHeader {
     pub x_position: u16,
     pub y_position: u16,
     pub width:      u16,
     pub height:     u16,
     pub encoding:   Encoding,
 }
 
-impl Message for Rectangle {
-    fn read_from<R: Read>(reader: &mut R) -> Result<Rectangle> {
-        Ok(Rectangle {
+impl Message for RectangleHeader {
+    fn read_from<R: Read>(reader: &mut R) -> Result<RectangleHeader> {
+        Ok(RectangleHeader {
             x_position: try!(reader.read_u16::<BigEndian>()),
             y_position: try!(reader.read_u16::<BigEndian>()),
             width:      try!(reader.read_u16::<BigEndian>()),
@@ -542,7 +605,7 @@ pub enum S2C {
     // core spec
     FramebufferUpdate {
         count:        u16,
-        /* Vec<Rectangle> has to be read out manually */
+        // Vec<RectangleHeader> has to be read out manually
     },
     SetColourMapEntries {
         first_colour: u16,

src/proxy.rs

@@ -177,9 +177,9 @@ impl Proxy {
                 match message {
                     protocol::S2C::FramebufferUpdate { count } => {
                         for _ in 0..count {
-                            let rectangle = try!(protocol::Rectangle::read_from(server_stream));
+                            let rectangle = try!(protocol::RectangleHeader::read_from(server_stream));
                             debug!("c<-s {:?}", rectangle);
-                            try!(protocol::Rectangle::write_to(&rectangle, &mut buffer_stream));
+                            try!(protocol::RectangleHeader::write_to(&rectangle, &mut buffer_stream));
 
                             match rectangle.encoding {
                                 protocol::Encoding::Raw => {