1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
#![doc(html_root_url = "https://azasypkin.github.io/rust-cast/")]
#![feature(custom_derive, plugin)]
#![plugin(serde_macros)]
extern crate byteorder;
#[macro_use]
extern crate log;
extern crate openssl;
extern crate protobuf;
extern crate serde;
extern crate serde_json;
pub mod cast;
pub mod errors;
mod utils;
mod message_manager;
pub mod channels;
use std::borrow::Cow;
use std::cell::RefCell;
use std::net::TcpStream;
use std::rc::Rc;
use openssl::ssl::{SslContext, SslStream, SslMethod};
use channels::heartbeat::{HeartbeatChannel, HeartbeatResponse};
use channels::connection::{ConnectionChannel, ConnectionResponse};
use channels::receiver::{ReceiverChannel, ReceiverResponse};
use channels::media::{MediaChannel, MediaResponse};
use errors::Error;
use message_manager::MessageManager;
const DEFAULT_SENDER_ID: &'static str = "sender-0";
const DEFAULT_RECEIVER_ID: &'static str = "receiver-0";
pub enum ChannelMessage<'a> {
Connection(ConnectionResponse),
Hearbeat(HeartbeatResponse),
Media(MediaResponse<'a>),
Receiver(ReceiverResponse),
}
pub struct CastDevice<'a> {
stream: Rc<RefCell<SslStream<TcpStream>>>,
pub connection: ConnectionChannel<'a, SslStream<TcpStream>>,
pub heartbeat: HeartbeatChannel<'a, SslStream<TcpStream>>,
pub media: MediaChannel<'a, SslStream<TcpStream>>,
pub receiver: ReceiverChannel<'a, SslStream<TcpStream>>,
}
impl<'a> CastDevice<'a> {
pub fn connect<S>(host: S, port: u16)
-> Result<CastDevice<'a>, Error> where S: Into<Cow<'a, str>> {
let host = host.into();
debug!("Establishing connection with cast device at {}:{}...", host, port);
let ssl_context = try!(SslContext::new(SslMethod::Sslv23));
let tcp_stream = try!(TcpStream::connect((host.as_ref(), port)));
let ssl_stream = try!(SslStream::connect(&ssl_context, tcp_stream));
debug!("Connection with {}:{} successfully established.", host, port);
let ssl_stream_rc = Rc::new(RefCell::new(ssl_stream));
let heartbeat = HeartbeatChannel::new(DEFAULT_SENDER_ID, DEFAULT_RECEIVER_ID,
ssl_stream_rc.clone());
let connection = ConnectionChannel::new(DEFAULT_SENDER_ID, ssl_stream_rc.clone());
let receiver = ReceiverChannel::new(DEFAULT_SENDER_ID, DEFAULT_RECEIVER_ID,
ssl_stream_rc.clone());
let media = MediaChannel::new(DEFAULT_SENDER_ID, ssl_stream_rc.clone());
Ok(CastDevice {
stream: ssl_stream_rc,
heartbeat: heartbeat,
connection: connection,
receiver: receiver,
media: media,
})
}
pub fn receive(&self) -> Result<ChannelMessage, Error> {
let cast_message = try!(MessageManager::receive(&mut *self.stream.borrow_mut()));
if self.connection.can_handle(&cast_message) {
return Ok(ChannelMessage::Connection(try!(self.connection.parse(&cast_message))));
}
if self.heartbeat.can_handle(&cast_message) {
return Ok(ChannelMessage::Hearbeat(try!(self.heartbeat.parse(&cast_message))));
}
if self.media.can_handle(&cast_message) {
return Ok(ChannelMessage::Media(try!(self.media.parse(&cast_message))));
}
if self.receiver.can_handle(&cast_message) {
return Ok(ChannelMessage::Receiver(try!(self.receiver.parse(&cast_message))));
}
Err(Error::Internal(
format!("Unsupported message namespace: {}", cast_message.get_namespace())))
}
}