Refractored bc connection to treat binary as a generic payload
This commit is contained in:
1 parent
3acd0b4a3c
commit
4ff53b73af
9 files changed
+155
-98
No files matched your search
@@ -1 +0,0 @@
|
||||
enum-variant-size-threshold = 700
|
||||
+36
-51
@@ -1,5 +1,5 @@
|
||||
use super::model::*;
|
||||
use super::xml::{AllTopXmls, Extension};
|
||||
use super::xml::{BcPayloads, BcXml, BcXmls};
|
||||
use super::xml_crypto;
|
||||
use err_derive::Error;
|
||||
use log::*;
|
||||
@@ -116,74 +116,59 @@ fn bc_modern_msg<'a, 'b>(
|
||||
Err,
|
||||
};
|
||||
|
||||
let mut in_bin_mode = context.in_bin_mode.contains(&header.msg_id);
|
||||
|
||||
// We'd like to know where the XML stops, but we haven't parsed the XML yet to see if the
|
||||
// binaryData offset in the header is valid
|
||||
let end_of_xml = if in_bin_mode {
|
||||
0
|
||||
} else {
|
||||
match header.bin_offset {
|
||||
Some(off) if off > 0 => off,
|
||||
_ => header.body_len,
|
||||
}
|
||||
let xml_len = match header.bin_offset {
|
||||
Some(off) => off,
|
||||
_ => header.body_len,
|
||||
};
|
||||
|
||||
let (mut buf, body_buf) = take(end_of_xml)(buf)?;
|
||||
let (buf, xml_buf) = take(xml_len)(buf)?;
|
||||
let payload_len = header.body_len - xml_len;
|
||||
let (buf, payload_buf) = take(payload_len)(buf)?;
|
||||
|
||||
let decrypted;
|
||||
let processed_body_buf = if !header.is_encrypted() {
|
||||
buf
|
||||
let processed_xml_buf = if !header.is_encrypted() {
|
||||
xml_buf
|
||||
} else {
|
||||
decrypted = xml_crypto::crypt(header.enc_offset, body_buf);
|
||||
decrypted = xml_crypto::crypt(header.enc_offset, xml_buf);
|
||||
&decrypted
|
||||
};
|
||||
|
||||
// Now we'll take the buffer that Nom gave a ref to and parse it.
|
||||
let mut xml = None;
|
||||
let mut binary = None;
|
||||
if end_of_xml > 0 {
|
||||
let xml;
|
||||
if xml_len > 0 {
|
||||
// Apply the XML parse function, but throw away the reference to decrypted in the Ok and
|
||||
// Err case. This error-error-error thing is the same idiom Nom uses internally.
|
||||
let parsed = AllTopXmls::try_parse(processed_body_buf)
|
||||
let parsed = BcXmls::try_parse(processed_xml_buf)
|
||||
.map_err(|_| Err::Error(make_error(buf, ErrorKind::MapRes)))?;
|
||||
|
||||
// If this is the first message containing binary, the Extension message puts the message
|
||||
// ID into binary mode, then the first binary is sent after the XML. All remaining
|
||||
// messages for that ID are pure binary.
|
||||
match parsed {
|
||||
AllTopXmls::BcXml(x) => {
|
||||
xml = Some(x);
|
||||
}
|
||||
AllTopXmls::Extension(Extension { binary_data: _ }) => {
|
||||
in_bin_mode = true;
|
||||
}
|
||||
}
|
||||
xml = Some(parsed);
|
||||
} else {
|
||||
xml = None;
|
||||
}
|
||||
|
||||
// If we are in binary mode, extract it
|
||||
if in_bin_mode {
|
||||
if let Some(bin_offset) = header.bin_offset {
|
||||
// Extract remainder of message as binary, if it exists
|
||||
let (buf_after, payload) =
|
||||
map(take(header.body_len - bin_offset), |x: &[u8]| x.to_vec())(buf)?;
|
||||
|
||||
// Since the parser operates in streaming mode, must wait until after we successfully
|
||||
// receive enough bytes before modifying the context (otherwise we'll alter the
|
||||
// behavior of future passes of this function even if we didn't yet consume the
|
||||
// message).
|
||||
context.in_bin_mode.insert(header.msg_id);
|
||||
|
||||
binary = Some(payload);
|
||||
buf = buf_after;
|
||||
// Now to handle the payload block
|
||||
// This block can either be xml or binary depending on what the message expects.
|
||||
// For our purposes we use try_parse and if all xml based parsers fail we treat
|
||||
// As binary
|
||||
let payload;
|
||||
if payload_len > 0 {
|
||||
// Extract remainder of message as binary, if it exists
|
||||
let decrypted;
|
||||
let processed_payload_buf = if !header.is_encrypted() {
|
||||
xml_buf
|
||||
} else {
|
||||
// Seriously, Nom, what even is this
|
||||
error!("Expected header to contain a binary offset, but there was none");
|
||||
return Err(Err::Error(make_error(buf, ErrorKind::Verify)));
|
||||
decrypted = xml_crypto::crypt(header.enc_offset, payload_buf);
|
||||
&decrypted
|
||||
};
|
||||
if let Ok(xml) = BcXml::try_parse(processed_payload_buf) {
|
||||
payload = Some(BcPayloads::BcXml(xml));
|
||||
} else {
|
||||
payload = Some(BcPayloads::Binary(payload_buf.to_vec()));
|
||||
}
|
||||
} else {
|
||||
payload = None;
|
||||
}
|
||||
|
||||
Ok((buf, ModernMsg { xml, binary }))
|
||||
Ok((buf, ModernMsg { xml, payload }))
|
||||
}
|
||||
|
||||
fn bc_header(buf: &[u8]) -> IResult<&[u8], BcHeader> {
|
||||
|
||||
+18
-7
@@ -1,4 +1,4 @@
|
||||
use super::xml::{BcXml, Extension, TopBcXmls};
|
||||
pub use super::xml::{BcXml, Extension, BcXmls, BcPayloads};
|
||||
use std::collections::HashSet;
|
||||
|
||||
pub(super) const MAGIC_HEADER: u32 = 0xabcdef0;
|
||||
@@ -19,6 +19,7 @@ pub struct Bc {
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
#[allow(clippy::large_enum_variant)]
|
||||
pub enum BcBody {
|
||||
LegacyMsg(LegacyMsg),
|
||||
ModernMsg(ModernMsg),
|
||||
@@ -26,8 +27,8 @@ pub enum BcBody {
|
||||
|
||||
#[derive(Debug, Default, PartialEq, Eq)]
|
||||
pub struct ModernMsg {
|
||||
pub xml: Option<BcXml>,
|
||||
pub binary: Option<Vec<u8>>,
|
||||
pub xml: Option<BcXmls>,
|
||||
pub payload: Option<BcPayloads>,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
@@ -76,8 +77,8 @@ impl Bc {
|
||||
Bc {
|
||||
meta,
|
||||
body: BcBody::ModernMsg(ModernMsg {
|
||||
xml: Some(xml),
|
||||
binary: None,
|
||||
xml: Some(BcXmls::BcXml(xml)),
|
||||
payload: None,
|
||||
}),
|
||||
}
|
||||
}
|
||||
@@ -86,8 +87,18 @@ impl Bc {
|
||||
Bc {
|
||||
meta,
|
||||
body: BcBody::ModernMsg(ModernMsg {
|
||||
xml: Some(TopBcXmls::Extension(xml)),
|
||||
binary: None,
|
||||
xml: Some(BcXmls::Extension(xml)),
|
||||
payload: None,
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new_from_meta(meta: BcMeta) -> Bc {
|
||||
Bc {
|
||||
meta,
|
||||
body: BcBody::ModernMsg(ModernMsg {
|
||||
xml: None,
|
||||
payload: None,
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
+21
-7
@@ -1,5 +1,5 @@
|
||||
use super::model::*;
|
||||
use super::xml::BcXml;
|
||||
use super::xml::{BcXmls, BcPayloads};
|
||||
use super::xml_crypto;
|
||||
use cookie_factory::bytes::*;
|
||||
use cookie_factory::sequence::tuple;
|
||||
@@ -24,7 +24,7 @@ impl Bc {
|
||||
body_buf = buf;
|
||||
bin_offset = if has_bin_offset(self.meta.class) {
|
||||
// If we're required to put binary length, put 0 if we have no binary
|
||||
Some(if modern.binary.is_some() {
|
||||
Some(if modern.payload.is_some() {
|
||||
xml_len as u32
|
||||
} else {
|
||||
0
|
||||
@@ -47,24 +47,38 @@ impl Bc {
|
||||
|
||||
// Put the binary part of the body, TODO this is poorly written
|
||||
if let BcBody::ModernMsg(ModernMsg {
|
||||
binary: Some(ref binary),
|
||||
payload: Some(ref payload),
|
||||
..
|
||||
}) = self.body
|
||||
{
|
||||
let (buf2, _) = gen(slice(binary), buf)?;
|
||||
buf = buf2
|
||||
let (buf2, _) = gen(bc_payload(header.enc_offset, payload), buf)?;
|
||||
buf = buf2;
|
||||
}
|
||||
|
||||
Ok(buf)
|
||||
}
|
||||
}
|
||||
|
||||
fn bc_xml<W: Write>(enc_offset: u32, xml: &BcXml) -> impl SerializeFn<W> {
|
||||
let xml_bytes = xml.serialize(vec![]).unwrap();
|
||||
fn bc_xml<W: Write>(enc_offset: u32, xml: &BcXmls) -> impl SerializeFn<W> {
|
||||
let xml_bytes = match xml {
|
||||
BcXmls::BcXml(x) => x.serialize(vec![]).unwrap(),
|
||||
BcXmls::Extension(x) => x.serialize(vec![]).unwrap(),
|
||||
};
|
||||
let enc_bytes = xml_crypto::crypt(enc_offset, &xml_bytes);
|
||||
slice(enc_bytes)
|
||||
}
|
||||
|
||||
fn bc_payload<W: Write>(enc_offset: u32, payload: &BcPayloads) -> impl SerializeFn<W> {
|
||||
let payload_bytes = match payload {
|
||||
BcPayloads::BcXml(x) => {
|
||||
let xml_bytes = x.serialize(vec![]).unwrap();
|
||||
xml_crypto::crypt(enc_offset, &xml_bytes)
|
||||
},
|
||||
BcPayloads::Binary(x) => x.to_owned(),
|
||||
};
|
||||
slice(payload_bytes)
|
||||
}
|
||||
|
||||
fn bc_header<W: Write>(header: &BcHeader) -> impl SerializeFn<W> {
|
||||
// TODO this is actually a u16 "response code" in modern messages
|
||||
let (signaled_encryption, spare) = if header.class == 0x0000 {
|
||||
|
||||
+24
-8
@@ -11,16 +11,32 @@ use indoc::indoc;
|
||||
|
||||
#[derive(PartialEq, Eq, Debug, YaDeserialize)]
|
||||
#[yaserde(flatten)]
|
||||
pub(super) enum AllTopXmls {
|
||||
pub enum BcXmls {
|
||||
#[yaserde(rename = "body")]
|
||||
BcXml(BcXml),
|
||||
Extension(Extension),
|
||||
}
|
||||
|
||||
// Required for YaDeserialize
|
||||
impl Default for AllTopXmls {
|
||||
impl Default for BcXmls {
|
||||
fn default() -> Self {
|
||||
AllTopXmls::BcXml(Default::default())
|
||||
BcXmls::BcXml(Default::default())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Eq, Debug, YaDeserialize)]
|
||||
#[yaserde(flatten)]
|
||||
pub enum BcPayloads {
|
||||
#[yaserde(rename = "body")]
|
||||
BcXml(BcXml),
|
||||
#[yaserde(flatten)]
|
||||
Binary(Vec<u8>),
|
||||
}
|
||||
|
||||
// Required for YaDeserialize
|
||||
impl Default for BcPayloads {
|
||||
fn default() -> Self {
|
||||
BcPayloads::Binary(Default::default())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -43,7 +59,7 @@ pub struct BcXml {
|
||||
pub norm: Option<Norm>,
|
||||
}
|
||||
|
||||
impl AllTopXmls {
|
||||
impl BcXmls {
|
||||
pub fn try_parse(s: impl Read) -> Result<Self, String> {
|
||||
yaserde::de::from_reader(s)
|
||||
}
|
||||
@@ -185,9 +201,9 @@ fn test_encryption_deser() {
|
||||
assert_eq!(enc.nonce, "9E6D1FCB9E69846D");
|
||||
assert_eq!(enc.type_, "md5");
|
||||
|
||||
let t = AllTopXmls::try_parse(sample.as_bytes()).unwrap();
|
||||
let t = BcXmls::try_parse(sample.as_bytes()).unwrap();
|
||||
match t {
|
||||
AllTopXmls::BcXml(top_b) if top_b == b => assert!(true),
|
||||
BcXmls::BcXml(top_b) if top_b == b => assert!(true),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
@@ -322,9 +338,9 @@ fn test_binary_deser() {
|
||||
</Extension>
|
||||
"#
|
||||
);
|
||||
let b = AllTopXmls::try_parse(sample.as_bytes()).unwrap();
|
||||
let b = BcXmls::try_parse(sample.as_bytes()).unwrap();
|
||||
match b {
|
||||
AllTopXmls::Extension(Extension { binary_data: 1 }) => assert!(true),
|
||||
BcXmls::Extension(Extension { binary_data: 1 }) => assert!(true),
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
+33
-11
@@ -24,9 +24,10 @@ use crate::Never;
|
||||
|
||||
type Result<T> = std::result::Result<T, Error>;
|
||||
|
||||
const RX_TIMEOUT: Duration = Duration::from_secs(5);
|
||||
const RX_TIMEOUT: Duration = Duration::from_secs(500);
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
#[allow(clippy::large_enum_variant)]
|
||||
pub enum Error {
|
||||
#[error(display = "Communication error")]
|
||||
CommunicationError(#[error(source)] std::io::Error),
|
||||
@@ -49,8 +50,13 @@ pub enum Error {
|
||||
#[error(display = "Timeout")]
|
||||
Timeout(#[error(source)] std::sync::mpsc::RecvTimeoutError),
|
||||
|
||||
#[error(display = "Media")]
|
||||
MediaPacket(#[error(source)] self::media_packet::Error),
|
||||
// We map std::sync::mpsc::RecvTimeoutError onto one of these based on
|
||||
// the errors enum
|
||||
#[error(display = "Dropped connection")]
|
||||
TimeoutDropped,
|
||||
|
||||
#[error(display = "Timeout")]
|
||||
TimeoutTimeout,
|
||||
|
||||
#[error(display = "Credential error")]
|
||||
AuthFailed,
|
||||
@@ -127,12 +133,18 @@ impl BcCamera {
|
||||
|
||||
sub_login.send(legacy_login)?;
|
||||
|
||||
let legacy_reply = sub_login.rx.recv_timeout(RX_TIMEOUT)?;
|
||||
let legacy_reply = sub_login.rx.recv_timeout(RX_TIMEOUT).map_err(|e| {
|
||||
match e {
|
||||
std::sync::mpsc::RecvTimeoutError::Timeout => {Error::TimeoutTimeout}
|
||||
std::sync::mpsc::RecvTimeoutError::Disconnected => {Error::TimeoutDropped}
|
||||
}
|
||||
})?;
|
||||
|
||||
let nonce;
|
||||
match legacy_reply.body {
|
||||
BcBody::ModernMsg(ModernMsg {
|
||||
xml:
|
||||
Some(BcXml {
|
||||
Some(BcXmls::BcXml(BcXml {
|
||||
encryption: Some(encryption),
|
||||
..
|
||||
}),
|
||||
@@ -181,13 +193,18 @@ impl BcCamera {
|
||||
);
|
||||
|
||||
sub_login.send(modern_login)?;
|
||||
let modern_reply = sub_login.rx.recv_timeout(RX_TIMEOUT)?;
|
||||
let modern_reply = sub_login.rx.recv_timeout(RX_TIMEOUT).map_err(|e| {
|
||||
match e {
|
||||
std::sync::mpsc::RecvTimeoutError::Timeout => {Error::TimeoutTimeout}
|
||||
std::sync::mpsc::RecvTimeoutError::Disconnected => {Error::TimeoutDropped}
|
||||
}
|
||||
})?;
|
||||
|
||||
let device_info;
|
||||
match modern_reply.body {
|
||||
BcBody::ModernMsg(ModernMsg {
|
||||
xml:
|
||||
Some(BcXml {
|
||||
payload:
|
||||
Some(BcPayloads::BcXml(BcXml {
|
||||
device_info: Some(info),
|
||||
..
|
||||
}),
|
||||
@@ -199,7 +216,7 @@ impl BcCamera {
|
||||
}
|
||||
BcBody::ModernMsg(ModernMsg {
|
||||
xml: None,
|
||||
binary: None,
|
||||
payload: None,
|
||||
}) => return Err(Error::AuthFailed),
|
||||
_ => {
|
||||
return Err(Error::UnintelligibleReply {
|
||||
@@ -214,7 +231,7 @@ impl BcCamera {
|
||||
|
||||
pub fn logout(&mut self) -> Result<()> {
|
||||
if self.logged_in {
|
||||
// TODO
|
||||
// TODO: Send message ID 2
|
||||
}
|
||||
self.logged_in = false;
|
||||
Ok(())
|
||||
@@ -238,7 +255,12 @@ impl BcCamera {
|
||||
|
||||
sub_ping.send(ping)?;
|
||||
|
||||
sub_ping.rx.recv_timeout(RX_TIMEOUT)?;
|
||||
sub_ping.rx.recv_timeout(RX_TIMEOUT).map_err(|e| {
|
||||
match e {
|
||||
std::sync::mpsc::RecvTimeoutError::Timeout => {Error::TimeoutTimeout}
|
||||
std::sync::mpsc::RecvTimeoutError::Disconnected => {Error::TimeoutDropped}
|
||||
}
|
||||
})?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use crate::bc::model::*;
|
||||
use crate::bc_protocol::connection::BcSubscription;
|
||||
use err_derive::Error;
|
||||
use super::Error;
|
||||
use log::trace;
|
||||
use log::*;
|
||||
use std::collections::VecDeque;
|
||||
@@ -17,12 +17,6 @@ const PAD_SIZE: usize = 8;
|
||||
|
||||
type Result<T> = std::result::Result<T, Error>;
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum Error {
|
||||
#[error(display = "Timeout")]
|
||||
Timeout(#[error(source)] std::sync::mpsc::RecvTimeoutError),
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]
|
||||
pub enum MediaDataKind {
|
||||
VideoDataIframe,
|
||||
@@ -156,9 +150,14 @@ impl<'a> MediaDataSubscriber<'a> {
|
||||
fn fill_binary_buffer(&mut self, rx_timeout: Duration) -> Result<()> {
|
||||
// Loop messages until we get binary add that data and return
|
||||
loop {
|
||||
let msg = self.bc_sub.rx.recv_timeout(rx_timeout)?;
|
||||
let msg = self.bc_sub.rx.recv_timeout(rx_timeout).map_err(|e| {
|
||||
match e {
|
||||
std::sync::mpsc::RecvTimeoutError::Timeout => {Error::TimeoutTimeout}
|
||||
std::sync::mpsc::RecvTimeoutError::Disconnected => {Error::TimeoutDropped}
|
||||
}
|
||||
})?;
|
||||
if let BcBody::ModernMsg(ModernMsg {
|
||||
binary: Some(binary),
|
||||
payload: Some(BcPayloads::Binary(binary)),
|
||||
..
|
||||
}) = msg.body
|
||||
{
|
||||
|
||||
+14
-4
@@ -20,11 +20,16 @@ impl BcCamera {
|
||||
};
|
||||
|
||||
sub_get_general.send(get)?;
|
||||
let msg = sub_get_general.rx.recv_timeout(RX_TIMEOUT)?;
|
||||
let msg = sub_get_general.rx.recv_timeout(RX_TIMEOUT).map_err(|e| {
|
||||
match e {
|
||||
std::sync::mpsc::RecvTimeoutError::Timeout => {Error::TimeoutTimeout}
|
||||
std::sync::mpsc::RecvTimeoutError::Disconnected => {Error::TimeoutDropped}
|
||||
}
|
||||
})?;
|
||||
|
||||
if let BcBody::ModernMsg(ModernMsg {
|
||||
xml:
|
||||
Some(BcXml {
|
||||
payload:
|
||||
Some(BcPayloads::BcXml(BcXml {
|
||||
system_general:
|
||||
Some(SystemGeneral {
|
||||
time_zone: Some(time_zone),
|
||||
@@ -106,7 +111,12 @@ impl BcCamera {
|
||||
);
|
||||
|
||||
sub_set_general.send(set)?;
|
||||
let msg = sub_set_general.rx.recv_timeout(RX_TIMEOUT)?;
|
||||
let msg = sub_set_general.rx.recv_timeout(RX_TIMEOUT).map_err(|e| {
|
||||
match e {
|
||||
std::sync::mpsc::RecvTimeoutError::Timeout => {Error::TimeoutTimeout}
|
||||
std::sync::mpsc::RecvTimeoutError::Disconnected => {Error::TimeoutDropped}
|
||||
}
|
||||
})?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -20,6 +20,7 @@ use cmdline::Opt;
|
||||
use config::{CameraConfig, Config, UserConfig};
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
#[allow(clippy::large_enum_variant)]
|
||||
pub enum Error {
|
||||
#[error(display = "Configuration parsing error")]
|
||||
ConfigError(#[error(source)] toml::de::Error),
|
||||
|
||||
Reference in new issue
Block a user