diff --git a/examples/srtpsrv.rs b/examples/srtpsrv.rs index ade38da..11182b2 100644 --- a/examples/srtpsrv.rs +++ b/examples/srtpsrv.rs @@ -6,37 +6,48 @@ extern crate trackable; extern crate rtp; use clap::{App, Arg}; -use fibers::{Spawn, Executor, InPlaceExecutor}; -use fibers::net::UdpSocket; use fibers::net::futures::RecvFrom; -use futures::{Future, Poll, Async}; -use trackable::error::ErrorKindExt; -use rtp::{Error, ErrorKind}; -use rtp::traits::ReadPacket; +use fibers::net::UdpSocket; +use fibers::{Executor, InPlaceExecutor, Spawn}; +use futures::{Async, Future, Poll}; use rtp::rfc3550::RtpPacketReader; -use rtp::rfc3711::{SrtpPacketReader, SrtpContext}; +use rtp::rfc3711::{SrtpContext, SrtpPacketReader}; +use rtp::traits::ReadPacket; +use rtp::{Error, ErrorKind}; +use trackable::error::ErrorKindExt; fn main() { let matches = App::new("srtpsrv") - .arg(Arg::with_name("PORT").short("p").takes_value(true).default_value("6000")) - .arg(Arg::with_name("MASTER_KEY").short("k").takes_value(true) - .default_value("d34d74f37d74e75f3bdb4f76f1bdf477")) - .arg(Arg::with_name("MASTER_SALT").short("s").takes_value(true) - .default_value("7f1fe35d78f77e75e79f7beb5f7a")) - .get_matches(); + .arg( + Arg::with_name("PORT") + .short("p") + .takes_value(true) + .default_value("6000"), + ).arg( + Arg::with_name("MASTER_KEY") + .short("k") + .takes_value(true) + .default_value("d34d74f37d74e75f3bdb4f76f1bdf477"), + ).arg( + Arg::with_name("MASTER_SALT") + .short("s") + .takes_value(true) + .default_value("7f1fe35d78f77e75e79f7beb5f7a"), + ).get_matches(); let port = matches.value_of("PORT").unwrap(); let addr = format!("0.0.0.0:{}", port).parse().unwrap(); let master_key = hex_str_to_bytes(matches.value_of("MASTER_KEY").unwrap()); let master_salt = hex_str_to_bytes(matches.value_of("MASTER_SALT").unwrap()); let context = SrtpContext::new(&master_key, &master_salt); - let future = track_err!(UdpSocket::bind(addr)).and_then(move |socket| { - SrtpRecvLoop::new(socket, context) - }); + let future = track_err!(UdpSocket::bind(addr)) + .and_then(move |socket| SrtpRecvLoop::new(socket, context)); let mut executor = InPlaceExecutor::new().unwrap(); let monitor = executor.spawn_monitor(future); - let result = executor.run_fiber(monitor).unwrap() + let result = executor + .run_fiber(monitor) + .unwrap() .map_err(|e| e.unwrap_or_else(|| ErrorKind::Other.cause("disconnected"))); track_try_unwrap!(result); } diff --git a/src/error.rs b/src/error.rs index 8749333..6ae89b9 100644 --- a/src/error.rs +++ b/src/error.rs @@ -1,6 +1,6 @@ use std::io; -use trackable::error::{TrackableError, IntoTrackableError}; use trackable::error::{ErrorKind as TrackableErrorKind, ErrorKindExt}; +use trackable::error::{IntoTrackableError, TrackableError}; pub type Error = TrackableError; diff --git a/src/lib.rs b/src/lib.rs index 7950da9..4940d85 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,18 +1,18 @@ #[macro_use] extern crate trackable; -extern crate handy_async; extern crate crypto; +extern crate handy_async; extern crate num; extern crate splay_tree; pub use error::{Error, ErrorKind}; pub mod io; -pub mod traits; pub mod rfc3550; pub mod rfc3711; pub mod rfc4585; pub mod rfc5761; +pub mod traits; mod error; diff --git a/src/rfc3550/mod.rs b/src/rfc3550/mod.rs index 331242f..2cd1e0e 100644 --- a/src/rfc3550/mod.rs +++ b/src/rfc3550/mod.rs @@ -1,14 +1,14 @@ -pub use self::rtp::{RtpPacket, RtpFixedHeader, RtpHeaderExtension, RtpPacketReader}; +pub use self::rtp::{RtpFixedHeader, RtpHeaderExtension, RtpPacket, RtpPacketReader}; -pub use self::rtcp::{RtcpPacket, RtcpSenderReport, RtcpReceiverReport, RtcpPacketReader}; -pub use self::rtcp::{RtcpSourceDescription, RtcpGoodbye, RtcpApplicationDefined}; -pub use self::rtcp::{RtcpCompoundPacket, ReceptionReport, SdesChunk, SdesItem}; +pub use self::rtcp::{ReceptionReport, RtcpCompoundPacket, SdesChunk, SdesItem}; +pub use self::rtcp::{RtcpApplicationDefined, RtcpGoodbye, RtcpSourceDescription}; +pub use self::rtcp::{RtcpPacket, RtcpPacketReader, RtcpReceiverReport, RtcpSenderReport}; -pub use self::rtcp::{RTCP_PACKET_TYPE_SR, RTCP_PACKET_TYPE_RR, RTCP_PACKET_TYPE_SDES}; -pub use self::rtcp::{RTCP_PACKET_TYPE_BYE, RTCP_PACKET_TYPE_APP}; -pub use self::rtcp::{SDES_ITEM_TYPE_END, SDES_ITEM_TYPE_CNAME, SDES_ITEM_TYPE_NAME}; -pub use self::rtcp::{SDES_ITEM_TYPE_EMAIL, SDES_ITEM_TYPE_PHONE, SDES_ITEM_TYPE_LOC}; -pub use self::rtcp::{SDES_ITEM_TYPE_TOOL, SDES_ITEM_TYPE_NOTE, SDES_ITEM_TYPE_PRIV}; +pub use self::rtcp::{RTCP_PACKET_TYPE_APP, RTCP_PACKET_TYPE_BYE}; +pub use self::rtcp::{RTCP_PACKET_TYPE_RR, RTCP_PACKET_TYPE_SDES, RTCP_PACKET_TYPE_SR}; +pub use self::rtcp::{SDES_ITEM_TYPE_CNAME, SDES_ITEM_TYPE_END, SDES_ITEM_TYPE_NAME}; +pub use self::rtcp::{SDES_ITEM_TYPE_EMAIL, SDES_ITEM_TYPE_LOC, SDES_ITEM_TYPE_PHONE}; +pub use self::rtcp::{SDES_ITEM_TYPE_NOTE, SDES_ITEM_TYPE_PRIV, SDES_ITEM_TYPE_TOOL}; -mod rtp; mod rtcp; +mod rtp; diff --git a/src/rfc3550/rtcp.rs b/src/rfc3550/rtcp.rs index 29cb632..dfd7d7e 100644 --- a/src/rfc3550/rtcp.rs +++ b/src/rfc3550/rtcp.rs @@ -1,11 +1,11 @@ -use std::io::{Read, Write}; use handy_async::sync_io::{ReadExt, WriteExt}; +use std::io::{Read, Write}; -use {Result, ErrorKind}; +use constants::RTP_VERSION; use io::{ReadFrom, WriteTo}; use traits::{self, Packet}; -use types::{U5, U24, RtpTimestamp, NtpTimestamp, NtpMiddleTimetamp, Ssrc, SsrcOrCsrc}; -use constants::RTP_VERSION; +use types::{NtpMiddleTimetamp, NtpTimestamp, RtpTimestamp, Ssrc, SsrcOrCsrc, U24, U5}; +use {ErrorKind, Result}; pub const RTCP_PACKET_TYPE_SR: u8 = 200; pub const RTCP_PACKET_TYPE_RR: u8 = 201; @@ -40,11 +40,11 @@ impl traits::ReadPacket for RtcpPacketReader { } fn supports_type(&self, ty: u8) -> bool { match ty { - RTCP_PACKET_TYPE_SR | - RTCP_PACKET_TYPE_RR | - RTCP_PACKET_TYPE_SDES | - RTCP_PACKET_TYPE_BYE | - RTCP_PACKET_TYPE_APP => true, + RTCP_PACKET_TYPE_SR + | RTCP_PACKET_TYPE_RR + | RTCP_PACKET_TYPE_SDES + | RTCP_PACKET_TYPE_BYE + | RTCP_PACKET_TYPE_APP => true, _ => false, } } @@ -103,11 +103,11 @@ impl ReadFrom for RtcpPacket { RTCP_PACKET_TYPE_APP => { track_err!(RtcpApplicationDefined::read_from(reader).map(From::from)) } - _ => { - track_panic!(ErrorKind::Unsupported, - "Unknown packet type: {}", - packet_type) - } + _ => track_panic!( + ErrorKind::Unsupported, + "Unknown packet type: {}", + packet_type + ), } } } @@ -150,21 +150,25 @@ impl From for RtcpPacket { fn read_sctp(reader: &mut R, expected_type: u8) -> Result<(U5, Vec)> { let b = track_try!(reader.read_u8()); - track_assert_eq!(b >> 6, - RTP_VERSION, - ErrorKind::Unsupported, - "Unsupported RTP version: {}", - b >> 6); + track_assert_eq!( + b >> 6, + RTP_VERSION, + ErrorKind::Unsupported, + "Unsupported RTP version: {}", + b >> 6 + ); let padding = (b & 0b0010_0000) != 0; let packet_specific = b & 0b0001_1111; let packet_type = track_try!(reader.read_u8()); - track_assert_eq!(packet_type, - expected_type, - ErrorKind::Invalid, - "Unexpected SCTP packet type: actual={}, expected={}", - packet_type, - expected_type); + track_assert_eq!( + packet_type, + expected_type, + ErrorKind::Invalid, + "Unexpected SCTP packet type: actual={}, expected={}", + packet_type, + expected_type + ); let word_count = track_try!(reader.read_u16be()) as usize; let mut payload = track_try!(reader.read_bytes(word_count * 4)); @@ -183,11 +187,12 @@ fn read_sctp(reader: &mut R, expected_type: u8) -> Result<(U5, Vec) Ok((packet_specific, payload)) } -fn write_sctp(writer: &mut W, - packet_type: u8, - packet_specific: U5, - payload: &[u8]) - -> Result<()> { +fn write_sctp( + writer: &mut W, + packet_type: u8, + packet_specific: U5, + payload: &[u8], +) -> Result<()> { track_assert_eq!(payload.len() % 4, 0, ErrorKind::Invalid); track_try!(writer.write_u8(RTP_VERSION << 6 | packet_specific)); @@ -247,14 +252,14 @@ impl ReadFrom for RtcpSenderReport { let extensions = track_try!(reader.read_all_bytes()); Ok(RtcpSenderReport { - ssrc: ssrc, - ntp_timestamp: ntp_timestamp, - rtp_timestamp: rtp_timestamp, - sent_packets: sent_packets, - sent_octets: sent_octets, - reception_reports: reception_reports, - extensions: extensions, - }) + ssrc: ssrc, + ntp_timestamp: ntp_timestamp, + rtp_timestamp: rtp_timestamp, + sent_packets: sent_packets, + sent_octets: sent_octets, + reception_reports: reception_reports, + extensions: extensions, + }) } } impl WriteTo for RtcpSenderReport { @@ -270,12 +275,16 @@ impl WriteTo for RtcpSenderReport { } payload.extend(&self.extensions); - track_assert!(self.reception_reports.len() <= 0x0001_1111, - ErrorKind::Invalid); - track_try!(write_sctp(writer, - RTCP_PACKET_TYPE_SR, - self.reception_reports.len() as u8, - &payload)); + track_assert!( + self.reception_reports.len() <= 0x0001_1111, + ErrorKind::Invalid + ); + track_try!(write_sctp( + writer, + RTCP_PACKET_TYPE_SR, + self.reception_reports.len() as u8, + &payload + )); Ok(()) } } @@ -314,14 +323,14 @@ impl ReadFrom for ReceptionReport { let delay_since_last_sr = track_try!(reader.read_u32be()); Ok(ReceptionReport { - ssrc: ssrc, - fraction_lost: fraction_lost, - packets_lost: packets_lost, - seq_num_ext: seq_num_ext, - jitter: jitter, - last_sr_timestamp: last_sr_timestamp, - delay_since_last_sr: delay_since_last_sr, - }) + ssrc: ssrc, + fraction_lost: fraction_lost, + packets_lost: packets_lost, + seq_num_ext: seq_num_ext, + jitter: jitter, + last_sr_timestamp: last_sr_timestamp, + delay_since_last_sr: delay_since_last_sr, + }) } } impl WriteTo for ReceptionReport { @@ -372,10 +381,10 @@ impl ReadFrom for RtcpReceiverReport { let extensions = track_try!(reader.read_all_bytes()); Ok(RtcpReceiverReport { - ssrc: ssrc, - reception_reports: reception_reports, - extensions: extensions, - }) + ssrc: ssrc, + reception_reports: reception_reports, + extensions: extensions, + }) } } impl WriteTo for RtcpReceiverReport { @@ -387,12 +396,16 @@ impl WriteTo for RtcpReceiverReport { } payload.extend(&self.extensions); - track_assert!(self.reception_reports.len() <= 0b0001_1111, - ErrorKind::Invalid); - track_try!(write_sctp(writer, - RTCP_PACKET_TYPE_RR, - self.reception_reports.len() as u8, - &payload)); + track_assert!( + self.reception_reports.len() <= 0b0001_1111, + ErrorKind::Invalid + ); + track_try!(write_sctp( + writer, + RTCP_PACKET_TYPE_RR, + self.reception_reports.len() as u8, + &payload + )); Ok(()) } } @@ -413,7 +426,11 @@ impl ReadFrom for RtcpSourceDescription { let (source_count, payload) = track_try!(read_sctp(reader, RTCP_PACKET_TYPE_SDES)); let reader = &mut &payload[..]; - let chunks = track_try!((0..source_count).map(|_| SdesChunk::read_from(reader)).collect()); + let chunks = track_try!( + (0..source_count) + .map(|_| SdesChunk::read_from(reader)) + .collect() + ); Ok(RtcpSourceDescription { chunks: chunks }) } } @@ -425,10 +442,12 @@ impl WriteTo for RtcpSourceDescription { } track_assert!(self.chunks.len() <= 0b0001_1111, ErrorKind::Invalid); - track_try!(write_sctp(writer, - RTCP_PACKET_TYPE_SDES, - self.chunks.len() as u8, - &payload)); + track_try!(write_sctp( + writer, + RTCP_PACKET_TYPE_SDES, + self.chunks.len() as u8, + &payload + )); Ok(()) } } @@ -474,9 +493,9 @@ impl ReadFrom for SdesChunk { track_try!(reader.read_bytes(padding_len as usize)); // discard Ok(SdesChunk { - ssrc_or_csrc: ssrc_or_csrc, - items: items, - }) + ssrc_or_csrc: ssrc_or_csrc, + items: items, + }) } } impl WriteTo for SdesChunk { @@ -571,9 +590,9 @@ impl ReadFrom for RtcpGoodbye { reason = Some(track_try!(reader.read_string(len as usize))); } Ok(RtcpGoodbye { - ssrc_csrc_list: list, - reason: reason, - }) + ssrc_csrc_list: list, + reason: reason, + }) } } impl WriteTo for RtcpGoodbye { @@ -594,10 +613,12 @@ impl WriteTo for RtcpGoodbye { } track_assert!(self.ssrc_csrc_list.len() <= 0b0001_1111, ErrorKind::Invalid); - track_try!(write_sctp(writer, - RTCP_PACKET_TYPE_BYE, - self.ssrc_csrc_list.len() as u8, - &payload)); + track_try!(write_sctp( + writer, + RTCP_PACKET_TYPE_BYE, + self.ssrc_csrc_list.len() as u8, + &payload + )); Ok(()) } } @@ -621,11 +642,11 @@ impl ReadFrom for RtcpApplicationDefined { track_try!(reader.read_exact(&mut name)); let data = track_try!(reader.read_all_bytes()); Ok(RtcpApplicationDefined { - subtype: subtype, - ssrc_or_csrc: ssrc_or_csrc, - name: name, - data: data, - }) + subtype: subtype, + ssrc_or_csrc: ssrc_or_csrc, + name: name, + data: data, + }) } } impl WriteTo for RtcpApplicationDefined { @@ -636,7 +657,12 @@ impl WriteTo for RtcpApplicationDefined { payload.extend(&self.data); track_assert!(self.subtype <= 0b0001_1111, ErrorKind::Invalid); - track_try!(write_sctp(writer, RTCP_PACKET_TYPE_APP, self.subtype, &payload)); + track_try!(write_sctp( + writer, + RTCP_PACKET_TYPE_APP, + self.subtype, + &payload + )); Ok(()) } } diff --git a/src/rfc3550/rtp.rs b/src/rfc3550/rtp.rs index 8336e4a..2759dcc 100644 --- a/src/rfc3550/rtp.rs +++ b/src/rfc3550/rtp.rs @@ -1,11 +1,11 @@ -use std::io::{Read, Write}; use handy_async::sync_io::{ReadExt, WriteExt}; +use std::io::{Read, Write}; -use {Result, ErrorKind}; +use constants::RTP_VERSION; use io::{ReadFrom, WriteTo}; use traits::{self, Packet}; -use types::{U7, RtpTimestamp, Ssrc, Csrc}; -use constants::RTP_VERSION; +use types::{Csrc, RtpTimestamp, Ssrc, U7}; +use {ErrorKind, Result}; #[derive(Debug, Clone, PartialEq, Eq)] pub struct RtpPacketReader; @@ -51,10 +51,10 @@ impl ReadFrom for RtpPacket { padding = payload.drain(payload_len - padding_len..).collect(); } Ok(RtpPacket { - header: header, - payload: payload, - padding: padding, - }) + header: header, + payload: payload, + padding: padding, + }) } } impl WriteTo for RtpPacket { @@ -62,13 +62,17 @@ impl WriteTo for RtpPacket { track_try!(self.header.write_to(writer)); track_try!(writer.write_all(&self.payload)); - track_assert_ne!(self.header.padding, - self.padding.is_empty(), - ErrorKind::Invalid); + track_assert_ne!( + self.header.padding, + self.padding.is_empty(), + ErrorKind::Invalid + ); if !self.padding.is_empty() { - track_assert_eq!(*self.padding.last().unwrap() as usize, - self.padding.len(), - ErrorKind::Invalid); + track_assert_eq!( + *self.padding.last().unwrap() as usize, + self.padding.len(), + ErrorKind::Invalid + ); track_try!(writer.write_all(&self.padding)); } Ok(()) @@ -89,11 +93,13 @@ pub struct RtpFixedHeader { impl ReadFrom for RtpFixedHeader { fn read_from(reader: &mut R) -> Result { let b = track_try!(reader.read_u8()); - track_assert_eq!(b >> 6, - RTP_VERSION, - ErrorKind::Unsupported, - "Unsupported RTP version: {}", - b >> 6); + track_assert_eq!( + b >> 6, + RTP_VERSION, + ErrorKind::Unsupported, + "Unsupported RTP version: {}", + b >> 6 + ); let padding = (b & 0b0010_0000) != 0; let extension = (b & 0b0001_0000) != 0; let csrc_count = b & 0b0000_1111; @@ -113,15 +119,15 @@ impl ReadFrom for RtpFixedHeader { None }; Ok(RtpFixedHeader { - padding: padding, - extension: extension, - marker: marker, - payload_type: payload_type, - seq_num: seq_num, - timestamp: timestamp, - ssrc: ssrc, - csrc_list: csrc_list, - }) + padding: padding, + extension: extension, + marker: marker, + payload_type: payload_type, + seq_num: seq_num, + timestamp: timestamp, + ssrc: ssrc, + csrc_list: csrc_list, + }) } } impl WriteTo for RtpFixedHeader { @@ -168,9 +174,9 @@ impl ReadFrom for RtpHeaderExtension { let word_count = track_try!(reader.read_u16be()); let extension = track_try!(reader.read_bytes(word_count as usize * 4)); Ok(RtpHeaderExtension { - profile_specific: profile_specific, - extension: extension, - }) + profile_specific: profile_specific, + extension: extension, + }) } } impl WriteTo for RtpHeaderExtension { diff --git a/src/rfc3711.rs b/src/rfc3711.rs index b27abd4..1051643 100644 --- a/src/rfc3711.rs +++ b/src/rfc3711.rs @@ -1,14 +1,14 @@ -use std::io::Read; use crypto; +use handy_async::sync_io::{ReadExt, WriteExt}; use num::BigUint; use splay_tree::SplaySet; -use handy_async::sync_io::{ReadExt, WriteExt}; +use std::io::Read; -use {Result, ErrorKind}; use io::{ReadFrom, WriteTo}; -use types::U48; -use traits::{ReadPacket, RtpPacket, RtcpPacket}; use rfc3550; +use traits::{ReadPacket, RtcpPacket, RtpPacket}; +use types::U48; +use {ErrorKind, Result}; pub type PacketIndex = U48; @@ -64,15 +64,21 @@ impl SrtpContext { let salt_key_id = BigUint::from_bytes_be(&[2, 0, 0, 0, 0, 0, 0]) + index.clone(); let master_salt = BigUint::from_bytes_be(&self.master_salt); - self.session_encr_key = prf_n(&self.master_key, - enc_key_id ^ master_salt.clone(), - self.session_encr_key.len()); - self.session_auth_key = prf_n(&self.master_key, - auth_key_id ^ master_salt.clone(), - self.session_auth_key.len()); - self.session_salt_key = prf_n(&self.master_key, - salt_key_id ^ master_salt.clone(), - self.session_salt_key.len()); + self.session_encr_key = prf_n( + &self.master_key, + enc_key_id ^ master_salt.clone(), + self.session_encr_key.len(), + ); + self.session_auth_key = prf_n( + &self.master_key, + auth_key_id ^ master_salt.clone(), + self.session_auth_key.len(), + ); + self.session_salt_key = prf_n( + &self.master_key, + salt_key_id ^ master_salt.clone(), + self.session_salt_key.len(), + ); } pub fn authenticate(&self, packet: &[u8]) -> Result<()> { let auth_portion = &packet[..packet.len() - self.auth_tag_len]; @@ -151,15 +157,21 @@ impl SrtcpContext { let salt_key_id = BigUint::from_bytes_be(&[5, 0, 0, 0, 0, 0, 0]) + index.clone(); let master_salt = BigUint::from_bytes_be(&self.master_salt); - self.session_encr_key = prf_n(&self.master_key, - enc_key_id ^ master_salt.clone(), - self.session_encr_key.len()); - self.session_auth_key = prf_n(&self.master_key, - auth_key_id ^ master_salt.clone(), - self.session_auth_key.len()); - self.session_salt_key = prf_n(&self.master_key, - salt_key_id ^ master_salt.clone(), - self.session_salt_key.len()); + self.session_encr_key = prf_n( + &self.master_key, + enc_key_id ^ master_salt.clone(), + self.session_encr_key.len(), + ); + self.session_auth_key = prf_n( + &self.master_key, + auth_key_id ^ master_salt.clone(), + self.session_auth_key.len(), + ); + self.session_salt_key = prf_n( + &self.master_key, + salt_key_id ^ master_salt.clone(), + self.session_salt_key.len(), + ); } pub fn authenticate(&self, packet: &[u8]) -> Result<()> { let auth_portion = &packet[..packet.len() - self.auth_tag_len]; @@ -209,8 +221,9 @@ pub struct SrtpPacketReader { inner: T, } impl SrtpPacketReader - where T: ReadPacket, - T::Packet: RtpPacket +where + T: ReadPacket, + T::Packet: RtpPacket, { pub fn new(mut context: SrtpContext, inner: T) -> Self { context.update_session_keys(); @@ -221,8 +234,9 @@ impl SrtpPacketReader } } impl ReadPacket for SrtpPacketReader - where T: ReadPacket, - T::Packet: RtpPacket +where + T: ReadPacket, + T::Packet: RtpPacket, { type Packet = T::Packet; fn read_packet(&mut self, reader: &mut R) -> Result { @@ -243,8 +257,9 @@ pub struct SrtcpPacketReader { inner: T, } impl SrtcpPacketReader - where T: ReadPacket, - T::Packet: RtcpPacket +where + T: ReadPacket, + T::Packet: RtcpPacket, { pub fn new(mut context: SrtcpContext, inner: T) -> Self { context.update_session_keys(); @@ -255,8 +270,9 @@ impl SrtcpPacketReader } } impl ReadPacket for SrtcpPacketReader - where T: ReadPacket, - T::Packet: RtcpPacket +where + T: ReadPacket, + T::Packet: RtcpPacket, { type Packet = T::Packet; fn read_packet(&mut self, reader: &mut R) -> Result { @@ -281,9 +297,11 @@ fn hmac_hash_sha1(key: &[u8], data: &[u8]) -> Vec { fn prf_n(master_key: &[u8], x: BigUint, n: usize) -> Vec { // https://tools.ietf.org/html/rfc3711#section-4.1.1 let mut output = Vec::new(); - let mut ctr = crypto::aes::ctr(crypto::aes::KeySize::KeySize128, - master_key, - &(x << 16).to_bytes_be()); + let mut ctr = crypto::aes::ctr( + crypto::aes::KeySize::KeySize128, + master_key, + &(x << 16).to_bytes_be(), + ); for i in 0.. { let old_len = output.len(); let new_len = output.len() + 16; @@ -302,50 +320,64 @@ fn prf_n(master_key: &[u8], x: BigUint, n: usize) -> Vec { #[cfg(test)] mod test { + use super::*; use rfc3550; use rfc4585; - use super::*; #[test] fn rtp_decryption_works() { - let master_key = [211, 77, 116, 243, 125, 116, 231, 95, 59, 219, 79, 118, 241, 189, 244, - 119]; - let master_salt = [127, 31, 227, 93, 120, 247, 126, 117, 231, 159, 123, 235, 95, 122]; + let master_key = [ + 211, 77, 116, 243, 125, 116, 231, 95, 59, 219, 79, 118, 241, 189, 244, 119, + ]; + let master_salt = [ + 127, 31, 227, 93, 120, 247, 126, 117, 231, 159, 123, 235, 95, 122, + ]; - let packet = [128, 0, 3, 92, 222, 161, 6, 76, 26, 163, 115, 130, 222, 0, 143, 87, 0, 227, - 123, 91, 200, 238, 141, 220, 9, 191, 52, 111, 100, 62, 220, 158, 211, 79, - 184, 199, 79, 182, 9, 248, 170, 82, 125, 152, 143, 206, 8, 152, 80, 207, 27, - 183, 141, 77, 33, 60, 101, 180, 210, 146, 139, 170, 149, 13, 99, 75, 223, - 156, 79, 71, 84, 119, 68, 236, 244, 163, 198, 175, 219, 160, 255, 9, 82, - 169, 64, 112, 106, 4, 0, 246, 39, 29, 88, 15, 62, 174, 21, 253, 171, 198, - 128, 61, 23, 43, 143, 255, 176, 125, 223, 23, 188, 90, 103, 139, 223, 56, - 162, 35, 27, 225, 117, 243, 138, 163, 35, 79, 221, 201, 149, 154, 203, 255, - 2, 23, 184, 184, 169, 32, 1, 138, 172, 60, 70, 240, 53, 11, 54, 81, 172, - 214, 34, 136, 39, 152, 17, 247, 126, 199, 200, 184, 70, 7, 52, 191, 129, - 239, 86, 78, 172, 229, 178, 112, 22, 125, 191, 164, 17, 193, 24, 152, 197, - 146, 94, 74, 156, 171, 245, 239, 220, 205, 145, 206]; + let packet = [ + 128, 0, 3, 92, 222, 161, 6, 76, 26, 163, 115, 130, 222, 0, 143, 87, 0, 227, 123, 91, + 200, 238, 141, 220, 9, 191, 52, 111, 100, 62, 220, 158, 211, 79, 184, 199, 79, 182, 9, + 248, 170, 82, 125, 152, 143, 206, 8, 152, 80, 207, 27, 183, 141, 77, 33, 60, 101, 180, + 210, 146, 139, 170, 149, 13, 99, 75, 223, 156, 79, 71, 84, 119, 68, 236, 244, 163, 198, + 175, 219, 160, 255, 9, 82, 169, 64, 112, 106, 4, 0, 246, 39, 29, 88, 15, 62, 174, 21, + 253, 171, 198, 128, 61, 23, 43, 143, 255, 176, 125, 223, 23, 188, 90, 103, 139, 223, + 56, 162, 35, 27, 225, 117, 243, 138, 163, 35, 79, 221, 201, 149, 154, 203, 255, 2, 23, + 184, 184, 169, 32, 1, 138, 172, 60, 70, 240, 53, 11, 54, 81, 172, 214, 34, 136, 39, + 152, 17, 247, 126, 199, 200, 184, 70, 7, 52, 191, 129, 239, 86, 78, 172, 229, 178, 112, + 22, 125, 191, 164, 17, 193, 24, 152, 197, 146, 94, 74, 156, 171, 245, 239, 220, 205, + 145, 206, + ]; let context = SrtpContext::new(&master_key, &master_salt); let mut rtp_reader = SrtpPacketReader::new(context, rfc3550::RtpPacketReader); let packet = rtp_reader.read_packet(&mut &packet[..]).unwrap(); - let expected_prefix = [0xbe, 0x9c, 0x8c, 0x86, 0x81, 0x80, 0x81, 0x86, 0x8d, 0x9c, 0xfd, - 0x1b, 0x0d, 0x05, 0x01, 0x00, 0x01, 0x05, 0x0d, 0x1b, 0xff, 0x9b, - 0x8d, 0x85, 0x81, 0x80, 0x81, 0x85, 0x8d, 0x9b, 0xff, 0x1b]; + let expected_prefix = [ + 0xbe, 0x9c, 0x8c, 0x86, 0x81, 0x80, 0x81, 0x86, 0x8d, 0x9c, 0xfd, 0x1b, 0x0d, 0x05, + 0x01, 0x00, 0x01, 0x05, 0x0d, 0x1b, 0xff, 0x9b, 0x8d, 0x85, 0x81, 0x80, 0x81, 0x85, + 0x8d, 0x9b, 0xff, 0x1b, + ]; - assert_eq!(&packet.payload[..expected_prefix.len()], - &expected_prefix[..]); + assert_eq!( + &packet.payload[..expected_prefix.len()], + &expected_prefix[..] + ); } #[test] fn rtcp_decryption_works() { - let master_key = [254, 123, 44, 240, 174, 252, 53, 54, 2, 213, 123, 106, 85, 165, 5, 13]; - let master_salt = [77, 202, 202, 112, 81, 101, 219, 232, 143, 131, 160, 89, 15, 141]; - let packet = [128, 201, 0, 1, 194, 242, 138, 93, 67, 38, 193, 233, 60, 78, 188, 195, 230, - 90, 19, 196, 152, 235, 136, 164, 15, 177, 174, 217, 207, 115, 148, 223, 109, - 112, 71, 245, 16, 214, 216, 232, 87, 153, 5, 238, 72, 201, 223, 43, 69, 99, - 54, 211, 118, 28, 227, 100, 161, 216, 90, 203, 99, 167, 215, 130, 151, 16, - 128, 138, 128, 0, 0, 1, 126, 39, 201, 236, 161, 194, 6, 232, 194, 230]; + let master_key = [ + 254, 123, 44, 240, 174, 252, 53, 54, 2, 213, 123, 106, 85, 165, 5, 13, + ]; + let master_salt = [ + 77, 202, 202, 112, 81, 101, 219, 232, 143, 131, 160, 89, 15, 141, + ]; + let packet = [ + 128, 201, 0, 1, 194, 242, 138, 93, 67, 38, 193, 233, 60, 78, 188, 195, 230, 90, 19, + 196, 152, 235, 136, 164, 15, 177, 174, 217, 207, 115, 148, 223, 109, 112, 71, 245, 16, + 214, 216, 232, 87, 153, 5, 238, 72, 201, 223, 43, 69, 99, 54, 211, 118, 28, 227, 100, + 161, 216, 90, 203, 99, 167, 215, 130, 151, 16, 128, 138, 128, 0, 0, 1, 126, 39, 201, + 236, 161, 194, 6, 232, 194, 230, + ]; let context = SrtcpContext::new(&master_key, &master_salt); let mut rtcp_reader = SrtcpPacketReader::new(context, rfc4585::RtcpPacketReader); diff --git a/src/rfc4585.rs b/src/rfc4585.rs index 8709ded..6e3795d 100644 --- a/src/rfc4585.rs +++ b/src/rfc4585.rs @@ -1,12 +1,12 @@ -use std::io::{Read, Write}; use handy_async::sync_io::{ReadExt, WriteExt}; +use std::io::{Read, Write}; -use {Result, ErrorKind}; -use io::{ReadFrom, WriteTo}; -use traits::{self, Packet}; -use types::{U5, U6, U7, U13, Ssrc}; use constants::RTP_VERSION; +use io::{ReadFrom, WriteTo}; use rfc3550; +use traits::{self, Packet}; +use types::{Ssrc, U13, U5, U6, U7}; +use {ErrorKind, Result}; pub const RTCP_PACKET_TYPE_RTPFB: u8 = 205; pub const RTCP_PACKET_TYPE_PSFB: u8 = 206; @@ -35,13 +35,13 @@ impl traits::ReadPacket for RtcpPacketReader { } fn supports_type(&self, ty: u8) -> bool { match ty { - rfc3550::RTCP_PACKET_TYPE_SR | - rfc3550::RTCP_PACKET_TYPE_RR | - rfc3550::RTCP_PACKET_TYPE_SDES | - rfc3550::RTCP_PACKET_TYPE_BYE | - rfc3550::RTCP_PACKET_TYPE_APP | - RTCP_PACKET_TYPE_RTPFB | - RTCP_PACKET_TYPE_PSFB => true, + rfc3550::RTCP_PACKET_TYPE_SR + | rfc3550::RTCP_PACKET_TYPE_RR + | rfc3550::RTCP_PACKET_TYPE_SDES + | rfc3550::RTCP_PACKET_TYPE_BYE + | rfc3550::RTCP_PACKET_TYPE_APP + | RTCP_PACKET_TYPE_RTPFB + | RTCP_PACKET_TYPE_PSFB => true, _ => false, } } @@ -102,9 +102,11 @@ impl ReadFrom for RtcpPacket { } _ => { track_assert_eq!(buf[0] >> 6, RTP_VERSION, ErrorKind::Invalid); - track_panic!(ErrorKind::Unsupported, - "Unknown packet type: {}", - packet_type) + track_panic!( + ErrorKind::Unsupported, + "Unknown packet type: {}", + packet_type + ) } } } @@ -171,11 +173,11 @@ impl ReadFrom for RtcpTransportLayerFeedback { RTPFB_MESSAGE_TYPE_NACK => { track_err!(GenericNack::read_from(&mut &rest[..])).map(From::from) } - _ => { - track_panic!(ErrorKind::Unsupported, - "Unknown feedback type: {}", - fb_message_type) - } + _ => track_panic!( + ErrorKind::Unsupported, + "Unknown feedback type: {}", + fb_message_type + ), } } } @@ -184,10 +186,12 @@ impl WriteTo for RtcpTransportLayerFeedback { match *self { RtcpTransportLayerFeedback::Nack(ref f) => { let payload = track_try!(f.to_bytes()); - track_err!(write_common(writer, - RTCP_PACKET_TYPE_RTPFB, - RTPFB_MESSAGE_TYPE_NACK, - &payload)) + track_err!(write_common( + writer, + RTCP_PACKET_TYPE_RTPFB, + RTPFB_MESSAGE_TYPE_NACK, + &payload + )) } } } @@ -224,11 +228,11 @@ impl ReadFrom for RtcpPayloadSpecificFeedback { PSFB_MESSAGE_TYPE_AFB => { track_err!(ApplicationLayerFeedback::read_from(reader).map(From::from)) } - _ => { - track_panic!(ErrorKind::Unsupported, - "Unknown feedback type: {}", - fb_message_type) - } + _ => track_panic!( + ErrorKind::Unsupported, + "Unknown feedback type: {}", + fb_message_type + ), } } } @@ -237,31 +241,39 @@ impl WriteTo for RtcpPayloadSpecificFeedback { match *self { RtcpPayloadSpecificFeedback::Pli(ref f) => { let payload = track_try!(f.to_bytes()); - track_err!(write_common(writer, - RTCP_PACKET_TYPE_PSFB, - PSFB_MESSAGE_TYPE_PLI, - &payload)) + track_err!(write_common( + writer, + RTCP_PACKET_TYPE_PSFB, + PSFB_MESSAGE_TYPE_PLI, + &payload + )) } RtcpPayloadSpecificFeedback::Sli(ref f) => { let payload = track_try!(f.to_bytes()); - track_err!(write_common(writer, - RTCP_PACKET_TYPE_PSFB, - PSFB_MESSAGE_TYPE_SLI, - &payload)) + track_err!(write_common( + writer, + RTCP_PACKET_TYPE_PSFB, + PSFB_MESSAGE_TYPE_SLI, + &payload + )) } RtcpPayloadSpecificFeedback::Rpsi(ref f) => { let payload = track_try!(f.to_bytes()); - track_err!(write_common(writer, - RTCP_PACKET_TYPE_PSFB, - PSFB_MESSAGE_TYPE_RPSI, - &payload)) + track_err!(write_common( + writer, + RTCP_PACKET_TYPE_PSFB, + PSFB_MESSAGE_TYPE_RPSI, + &payload + )) } RtcpPayloadSpecificFeedback::Afb(ref f) => { let payload = track_try!(f.to_bytes()); - track_err!(write_common(writer, - RTCP_PACKET_TYPE_PSFB, - PSFB_MESSAGE_TYPE_AFB, - &payload)) + track_err!(write_common( + writer, + RTCP_PACKET_TYPE_PSFB, + PSFB_MESSAGE_TYPE_AFB, + &payload + )) } } } @@ -287,11 +299,12 @@ impl From for RtcpPayloadSpecificFeedback { } } -fn write_common(writer: &mut W, - packet_type: u8, - fb_message_type: U5, - payload: &[u8]) - -> Result<()> { +fn write_common( + writer: &mut W, + packet_type: u8, + fb_message_type: U5, + payload: &[u8], +) -> Result<()> { track_assert_eq!(payload.len() % 4, 0, ErrorKind::Invalid); track_try!(writer.write_u8(RTP_VERSION << 6 | fb_message_type)); @@ -308,21 +321,25 @@ fn write_common(writer: &mut W, fn read_common(reader: &mut R, expected_type: u8) -> Result<(U5, Vec)> { let b = track_try!(reader.read_u8()); - track_assert_eq!(b >> 6, - RTP_VERSION, - ErrorKind::Unsupported, - "Unsupported RTP version: {}", - b >> 6); + track_assert_eq!( + b >> 6, + RTP_VERSION, + ErrorKind::Unsupported, + "Unsupported RTP version: {}", + b >> 6 + ); let padding = (b & 0b0010_0000) != 0; let fb_message_type = b & 0b0001_1111; let packet_type = track_try!(reader.read_u8()); - track_assert_eq!(packet_type, - expected_type, - ErrorKind::Invalid, - "Unexpected SCTP packet type: actual={}, expected={}", - packet_type, - expected_type); + track_assert_eq!( + packet_type, + expected_type, + ErrorKind::Invalid, + "Unexpected SCTP packet type: actual={}, expected={}", + packet_type, + expected_type + ); let word_count = track_try!(reader.read_u16be()) as usize; let mut payload = track_try!(reader.read_bytes(word_count * 4)); @@ -354,11 +371,11 @@ impl ReadFrom for GenericNack { let packet_id = track_try!(reader.read_u16be()); let lost_packets_bitmask = track_try!(reader.read_u16be()); Ok(GenericNack { - sender_ssrc: sender_ssrc, - media_ssrc: media_ssrc, - packet_id: packet_id, - lost_packets_bitmask: lost_packets_bitmask, - }) + sender_ssrc: sender_ssrc, + media_ssrc: media_ssrc, + packet_id: packet_id, + lost_packets_bitmask: lost_packets_bitmask, + }) } } impl WriteTo for GenericNack { @@ -381,9 +398,9 @@ impl ReadFrom for PictureLossIndication { let sender_ssrc = track_try!(reader.read_u32be()); let media_ssrc = track_try!(reader.read_u32be()); Ok(PictureLossIndication { - sender_ssrc: sender_ssrc, - media_ssrc: media_ssrc, - }) + sender_ssrc: sender_ssrc, + media_ssrc: media_ssrc, + }) } } impl WriteTo for PictureLossIndication { @@ -411,12 +428,12 @@ impl ReadFrom for SliceLossIndication { let number = num_and_pic >> 6; let picture_id = (num_and_pic as u8) & 0b0011_1111; Ok(SliceLossIndication { - sender_ssrc: sender_ssrc, - media_ssrc: media_ssrc, - first: first, - number: number, - picture_id: picture_id, - }) + sender_ssrc: sender_ssrc, + media_ssrc: media_ssrc, + first: first, + number: number, + picture_id: picture_id, + }) } } impl WriteTo for SliceLossIndication { @@ -447,11 +464,11 @@ impl ReadFrom for ReferencePictureSelectionIndication { let info = track_try!(reader.read_bytes(info_len as usize)); let _ = track_try!(reader.read_bytes(padding as usize)); Ok(ReferencePictureSelectionIndication { - sender_ssrc: sender_ssrc, - media_ssrc: media_ssrc, - rtp_payload_type: rtp_payload_type, - information: info, - }) + sender_ssrc: sender_ssrc, + media_ssrc: media_ssrc, + rtp_payload_type: rtp_payload_type, + information: info, + }) } } impl WriteTo for ReferencePictureSelectionIndication { @@ -489,10 +506,10 @@ impl ReadFrom for ApplicationLayerFeedback { let media_ssrc = track_try!(reader.read_u32be()); let data = track_try!(reader.read_all_bytes()); Ok(ApplicationLayerFeedback { - sender_ssrc: sender_ssrc, - media_ssrc: media_ssrc, - data: data, - }) + sender_ssrc: sender_ssrc, + media_ssrc: media_ssrc, + data: data, + }) } } impl WriteTo for ApplicationLayerFeedback { diff --git a/src/rfc5761.rs b/src/rfc5761.rs index d08a90d..6950725 100644 --- a/src/rfc5761.rs +++ b/src/rfc5761.rs @@ -1,7 +1,7 @@ use std::io::{Read, Write}; +use traits::{Packet, ReadPacket, RtcpPacket, RtpPacket, WritePacket}; use Result; -use traits::{ReadPacket, WritePacket, RtpPacket, RtcpPacket, Packet}; #[derive(Debug, Clone, PartialEq, Eq)] pub struct MuxPacketReader { @@ -9,10 +9,11 @@ pub struct MuxPacketReader { rtcp_reader: U, } impl MuxPacketReader - where T: ReadPacket, - T::Packet: RtpPacket, - U: ReadPacket, - U::Packet: RtcpPacket +where + T: ReadPacket, + T::Packet: RtpPacket, + U: ReadPacket, + U::Packet: RtcpPacket, { pub fn new(rtp_reader: T, rtcp_reader: U) -> Self { MuxPacketReader { @@ -22,10 +23,11 @@ impl MuxPacketReader } } impl ReadPacket for MuxPacketReader - where T: ReadPacket, - T::Packet: RtpPacket, - U: ReadPacket, - U::Packet: RtcpPacket +where + T: ReadPacket, + T::Packet: RtpPacket, + U: ReadPacket, + U::Packet: RtcpPacket, { type Packet = MuxedPacket; fn read_packet(&mut self, reader: &mut R) -> Result { @@ -52,10 +54,11 @@ pub struct MuxPacketWriter { rtcp_writer: U, } impl MuxPacketWriter - where T: WritePacket, - T::Packet: RtpPacket, - U: WritePacket, - U::Packet: RtcpPacket +where + T: WritePacket, + T::Packet: RtpPacket, + U: WritePacket, + U::Packet: RtcpPacket, { pub fn new(rtp_writer: T, rtcp_writer: U) -> Self { MuxPacketWriter { @@ -65,10 +68,11 @@ impl MuxPacketWriter } } impl WritePacket for MuxPacketWriter - where T: WritePacket, - T::Packet: RtpPacket, - U: WritePacket, - U::Packet: RtcpPacket +where + T: WritePacket, + T::Packet: RtpPacket, + U: WritePacket, + U::Packet: RtcpPacket, { type Packet = MuxedPacket; fn write_packet(&mut self, writer: &mut W, packet: &Self::Packet) -> Result<()> { @@ -85,7 +89,8 @@ pub enum MuxedPacket { Rtcp(U), } impl Packet for MuxedPacket - where T: RtpPacket, - U: RtcpPacket +where + T: RtpPacket, + U: RtcpPacket, { }