bin/telephony/ril-qmi/src/client.rs - garnet - Git at Google

 // Copyright 2018 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 use {
     bytes::{BufMut, BytesMut},
     crate::errors::QmuxError,
     crate::transport::{ClientId, SvcId},
     crate::transport::{QmiResponse, QmiTransport},
     fidl::endpoints::ServerEnd,
     fidl_fuchsia_telephony_ril::NetworkConnectionMarker,
     fuchsia_syslog::macros::*,
     parking_lot::RwLock,
     qmi_protocol::{Decodable, Encodable, QmiResult},
     std::collections::HashMap,
     std::fmt::Debug,
     std::marker::Unpin,
     std::ops::Deref,
     std::sync::Arc,
 };

 #[derive(Debug)]
 pub struct ClientSvcMap(RwLock<HashMap<SvcId, ClientId>>);

 impl Default for ClientSvcMap {
     fn default() -> Self {
         let mut m = HashMap::new();
         // Requests for IDs occur on the CTL service (ID 0),
         // this default mapping allows the client to request an ID
         // without a unique client just for this functionality
         m.insert(SvcId(0), ClientId(0));
         ClientSvcMap(RwLock::new(m))
     }
 }
 impl Deref for ClientSvcMap {
     type Target = RwLock<HashMap<SvcId, ClientId>>;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }

 #[derive(Debug)]
 pub struct Connection {
     pub conn: ServerEnd<NetworkConnectionMarker>,
     pub pkt_handle: u32,
 }

 #[derive(Debug)]
 pub struct QmiClient {
     inner: Arc<QmiTransport>,
     clients: ClientSvcMap,
     pub data_conn: Option<Connection>,
 }

 impl Unpin for QmiClient {}

 impl QmiClient {
     pub fn new(inner: Arc<QmiTransport>) -> Self {
         QmiClient {
             inner: inner,
             clients: ClientSvcMap::default(),
             data_conn: None,
         }
     }

     /// Send a QMI message and allocate the client IDs for the service
     /// if they have not yet been
     pub async fn send_msg<'a, E: Encodable + 'a, D: Decodable + Debug>(
         &'a self, msg: E,
     ) -> Result<QmiResult<D>, QmuxError> {
         let svc_id = SvcId(msg.svc_id());
         let mut need_id = false;
         {
             let map = self.clients.read();
             // allocate a client id for this service
             if map.get(&svc_id).is_none() {
                 need_id = true;
             }
         }
         if need_id {
             use qmi_protocol::CTL::{GetClientIdReq, GetClientIdResp};
             fx_log_info!("allocating a client ID for service: {}", svc_id.0);
             let resp: QmiResult<GetClientIdResp> =
                 await!(self.send_msg_actual(GetClientIdReq::new(svc_id.0)))?;
             let client_id_resp = resp.unwrap(); // TODO from trait for QmiError to QmuxError
             let mut map = self.clients.write();
             assert_eq!(client_id_resp.svc_type, svc_id.0);
             map.insert(svc_id, ClientId(client_id_resp.client_id));
         }
         Ok(await!(self.send_msg_actual(msg))?)
     }

     fn get_client_id(&self, svc_id: SvcId) -> ClientId {
         let clients = self.clients.read();
         *clients
             .get(&svc_id)
             .expect("Precondition of calling get_client_id is to have verified an ID is allocated")
     }

     /// Send a QMI message without checking if a client ID has been allocated for the service
     async fn send_msg_actual<'a, E: Encodable + 'a, D: Decodable + Debug>(
         &'a self, msg: E,
     ) -> Result<QmiResult<D>, QmuxError> {
         fx_log_info!("Sending a structured QMI message");

         let svc_id = SvcId(msg.svc_id());
         let client_id = self.get_client_id(svc_id);

         let tx_id = self.inner.register_interest(svc_id, client_id);

         let mut msg_buf = BytesMut::new();
         let (payload_bytes, payload_len) = msg.to_bytes();
         // QMI header
         msg_buf.put_u8(0x01); // magic QMI number
                               // 2 bytes total length
         msg_buf.put_u16_le(
             payload_len
                            + 3 /* flags */
                            + 2 /* length byte length */
                            // additional length is bytes not captured in the payload length
                            // They cannot be calculated there because multi-payload SDUs may
                            // exist
                            + 1 /* sdu control flag */
                            + msg.transaction_id_len() as u16,
         );

         // 1 byte control flag
         msg_buf.put_u8(0x00);
         // 1 byte svc flag
         msg_buf.put_u8(svc_id.0);
         // 1 byte client id
         msg_buf.put_u8(client_id.0);

         // SDU
         // 1 byte control flag
         msg_buf.put_u8(0x00);
         // 1 or 2 byte transaction ID
         match msg.transaction_id_len() {
             1 => msg_buf.put_u8(tx_id.0 as u8 + 1), // we know it's one byte
             2 => msg_buf.put_u16_le(tx_id.0 + 1),
             _ => panic!(
                 "Unknown transaction ID length. Please add client support or fix the message \
                  definitions"
             ),
         }
         // add the payload to the buffer
         msg_buf.extend(payload_bytes);

         let bytes = msg_buf.freeze();

         if let Some(ref transport) = self.inner.transport_channel {
             if transport.is_closed() {
                 fx_log_err!("Transport channel to modem is closed");
             }
             transport
                 .write(bytes.as_ref(), &mut Vec::new())
                 .map_err(QmuxError::ClientWrite)?
         }

         let resp = await!(QmiResponse {
             client_id: client_id,
             svc_id: svc_id,
             tx_id: tx_id,
             transport: Some(self.inner.clone())
         })?;

         let buf = std::io::Cursor::new(resp.bytes());
         let decoded = D::from_bytes(buf);
         Ok(decoded)
     }
 }

 #[cfg(test)]
 mod tests {
     use super::*;
     use {
         fuchsia_async::{self as fasync, TimeoutExt},
         fuchsia_zircon::{self as zx, DurationNum},
         futures::{FutureExt, TryFutureExt},
         parking_lot::Mutex,
         pretty_assertions::assert_eq,
         qmi_protocol::QmiError,
         std::io,
     };

     #[test]
     #[should_panic]
     fn no_client() {
         use qmi_protocol::WDA;
         let mut executor = fasync::Executor::new().unwrap();
         let modem = Arc::new(Mutex::new(crate::QmiModem::new()));
         let modem_lock = modem.lock();
         let sender = async {
             let client = await!(modem_lock.create_client()).unwrap();
             // Panic should occur here. No valid channel to send message on!
             let _: Result<WDA::SetDataFormatResp, QmiError> = await!(client
                 .send_msg(WDA::SetDataFormatReq::new(None, Some(0x01)))
                 .map_err(|e| io::Error::new(
                     io::ErrorKind::Other,
                     &*format!("fidl error: {:?}", e)
                 )))
             .unwrap();
         };
         executor.run_singlethreaded(sender);
     }

     #[test]
     fn request_id() {
         use qmi_protocol::CTL;
         const EXPECTED: &[u8] = &[1, 15, 0, 0, 0, 0, 0, 1, 34, 0, 4, 0, 1, 1, 0, 66];

         let mut executor = fasync::Executor::new().unwrap();

         let (client_end, server_end) = zx::Channel::create().unwrap();
         let client_end = fasync::Channel::from_channel(client_end).unwrap();
         let trans = Arc::new(QmiTransport::new(client_end));
         let modem = Arc::new(Mutex::new(crate::QmiModem::new_with_transport(trans)));

         let server = fasync::Channel::from_channel(server_end).unwrap();
         let mut buffer = zx::MessageBuf::new();

         let modem_lock = modem.lock();

         let receiver = async {
             await!(server.recv_msg(&mut buffer)).expect("failed to recv msg");
             assert_eq!(EXPECTED, buffer.bytes());
             let bytes = &[
                 1, 15, 0, 0, 0, 0, 1, 1, 34, 0, 12, 0, 0, 4, 0, 0, 0, 0, 0, 1, 0, 0, 42, 6,
             ];
             let _ = server
                 .write(bytes, &mut vec![])
                 .expect("Server channel write failed");
         };

         let receiver = receiver.on_timeout(1000.millis().after_now(), || {
             panic!("did not receiver message in time!")
         });

         let sender = async {
             let client = await!(modem_lock.create_client()).unwrap();
             let resp: QmiResult<CTL::GetClientIdResp> =
                 await!(client.send_msg_actual(CTL::GetClientIdReq::new(0x42))).unwrap();
             let msg = resp.unwrap();
             assert_eq!(msg.svc_type, 42);
             assert_eq!(msg.client_id, 6);
         };

         let sender = sender.on_timeout(1000.millis().after_now(), || {
             panic!("did not receive response in time!")
         });

         executor.run_singlethreaded(receiver.join(sender));
     }
 }
	// Copyright 2018 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	use {
	bytes::{BufMut, BytesMut},
	crate::errors::QmuxError,
	crate::transport::{ClientId, SvcId},
	crate::transport::{QmiResponse, QmiTransport},
	fidl::endpoints::ServerEnd,
	fidl_fuchsia_telephony_ril::NetworkConnectionMarker,
	fuchsia_syslog::macros::*,
	parking_lot::RwLock,
	qmi_protocol::{Decodable, Encodable, QmiResult},
	std::collections::HashMap,
	std::fmt::Debug,
	std::marker::Unpin,
	std::ops::Deref,
	std::sync::Arc,
	};

	#[derive(Debug)]
	pub struct ClientSvcMap(RwLock<HashMap<SvcId, ClientId>>);

	impl Default for ClientSvcMap {
	fn default() -> Self {
	let mut m = HashMap::new();
	// Requests for IDs occur on the CTL service (ID 0),
	// this default mapping allows the client to request an ID
	// without a unique client just for this functionality
	m.insert(SvcId(0), ClientId(0));
	ClientSvcMap(RwLock::new(m))
	}
	}
	impl Deref for ClientSvcMap {
	type Target = RwLock<HashMap<SvcId, ClientId>>;
	fn deref(&self) -> &Self::Target {
	&self.0
	}
	}

	#[derive(Debug)]
	pub struct Connection {
	pub conn: ServerEnd<NetworkConnectionMarker>,
	pub pkt_handle: u32,
	}

	#[derive(Debug)]
	pub struct QmiClient {
	inner: Arc<QmiTransport>,
	clients: ClientSvcMap,
	pub data_conn: Option<Connection>,
	}

	impl Unpin for QmiClient {}

	impl QmiClient {
	pub fn new(inner: Arc<QmiTransport>) -> Self {
	QmiClient {
	inner: inner,
	clients: ClientSvcMap::default(),
	data_conn: None,
	}
	}

	/// Send a QMI message and allocate the client IDs for the service
	/// if they have not yet been
	pub async fn send_msg<'a, E: Encodable + 'a, D: Decodable + Debug>(
	&'a self, msg: E,
	) -> Result<QmiResult<D>, QmuxError> {
	let svc_id = SvcId(msg.svc_id());
	let mut need_id = false;
	{
	let map = self.clients.read();
	// allocate a client id for this service
	if map.get(&svc_id).is_none() {
	need_id = true;
	}
	}
	if need_id {
	use qmi_protocol::CTL::{GetClientIdReq, GetClientIdResp};
	fx_log_info!("allocating a client ID for service: {}", svc_id.0);
	let resp: QmiResult<GetClientIdResp> =
	await!(self.send_msg_actual(GetClientIdReq::new(svc_id.0)))?;
	let client_id_resp = resp.unwrap(); // TODO from trait for QmiError to QmuxError
	let mut map = self.clients.write();
	assert_eq!(client_id_resp.svc_type, svc_id.0);
	map.insert(svc_id, ClientId(client_id_resp.client_id));
	}
	Ok(await!(self.send_msg_actual(msg))?)
	}

	fn get_client_id(&self, svc_id: SvcId) -> ClientId {
	let clients = self.clients.read();
	*clients
	.get(&svc_id)
	.expect("Precondition of calling get_client_id is to have verified an ID is allocated")
	}

	/// Send a QMI message without checking if a client ID has been allocated for the service
	async fn send_msg_actual<'a, E: Encodable + 'a, D: Decodable + Debug>(
	&'a self, msg: E,
	) -> Result<QmiResult<D>, QmuxError> {
	fx_log_info!("Sending a structured QMI message");

	let svc_id = SvcId(msg.svc_id());
	let client_id = self.get_client_id(svc_id);

	let tx_id = self.inner.register_interest(svc_id, client_id);

	let mut msg_buf = BytesMut::new();
	let (payload_bytes, payload_len) = msg.to_bytes();
	// QMI header
	msg_buf.put_u8(0x01); // magic QMI number
	// 2 bytes total length
	msg_buf.put_u16_le(
	payload_len
	+ 3 /* flags */
	+ 2 /* length byte length */
	// additional length is bytes not captured in the payload length
	// They cannot be calculated there because multi-payload SDUs may
	// exist
	+ 1 /* sdu control flag */
	+ msg.transaction_id_len() as u16,
	);

	// 1 byte control flag
	msg_buf.put_u8(0x00);
	// 1 byte svc flag
	msg_buf.put_u8(svc_id.0);
	// 1 byte client id
	msg_buf.put_u8(client_id.0);

	// SDU
	// 1 byte control flag
	msg_buf.put_u8(0x00);
	// 1 or 2 byte transaction ID
	match msg.transaction_id_len() {
	1 => msg_buf.put_u8(tx_id.0 as u8 + 1), // we know it's one byte
	2 => msg_buf.put_u16_le(tx_id.0 + 1),
	_ => panic!(
	"Unknown transaction ID length. Please add client support or fix the message \
	definitions"
	),
	}
	// add the payload to the buffer
	msg_buf.extend(payload_bytes);

	let bytes = msg_buf.freeze();

	if let Some(ref transport) = self.inner.transport_channel {
	if transport.is_closed() {
	fx_log_err!("Transport channel to modem is closed");
	}
	transport
	.write(bytes.as_ref(), &mut Vec::new())
	.map_err(QmuxError::ClientWrite)?
	}

	let resp = await!(QmiResponse {
	client_id: client_id,
	svc_id: svc_id,
	tx_id: tx_id,
	transport: Some(self.inner.clone())
	})?;

	let buf = std::io::Cursor::new(resp.bytes());
	let decoded = D::from_bytes(buf);
	Ok(decoded)
	}
	}

	#[cfg(test)]
	mod tests {
	use super::*;
	use {
	fuchsia_async::{self as fasync, TimeoutExt},
	fuchsia_zircon::{self as zx, DurationNum},
	futures::{FutureExt, TryFutureExt},
	parking_lot::Mutex,
	pretty_assertions::assert_eq,
	qmi_protocol::QmiError,
	std::io,
	};

	#[test]
	#[should_panic]
	fn no_client() {
	use qmi_protocol::WDA;
	let mut executor = fasync::Executor::new().unwrap();
	let modem = Arc::new(Mutex::new(crate::QmiModem::new()));
	let modem_lock = modem.lock();
	let sender = async {
	let client = await!(modem_lock.create_client()).unwrap();
	// Panic should occur here. No valid channel to send message on!
	let _: Result<WDA::SetDataFormatResp, QmiError> = await!(client
	.send_msg(WDA::SetDataFormatReq::new(None, Some(0x01)))
	.map_err(\|e\| io::Error::new(
	io::ErrorKind::Other,
	&*format!("fidl error: {:?}", e)
	)))
	.unwrap();
	};
	executor.run_singlethreaded(sender);
	}

	#[test]
	fn request_id() {
	use qmi_protocol::CTL;
	const EXPECTED: &[u8] = &[1, 15, 0, 0, 0, 0, 0, 1, 34, 0, 4, 0, 1, 1, 0, 66];

	let mut executor = fasync::Executor::new().unwrap();

	let (client_end, server_end) = zx::Channel::create().unwrap();
	let client_end = fasync::Channel::from_channel(client_end).unwrap();
	let trans = Arc::new(QmiTransport::new(client_end));
	let modem = Arc::new(Mutex::new(crate::QmiModem::new_with_transport(trans)));

	let server = fasync::Channel::from_channel(server_end).unwrap();
	let mut buffer = zx::MessageBuf::new();

	let modem_lock = modem.lock();

	let receiver = async {
	await!(server.recv_msg(&mut buffer)).expect("failed to recv msg");
	assert_eq!(EXPECTED, buffer.bytes());
	let bytes = &[
	1, 15, 0, 0, 0, 0, 1, 1, 34, 0, 12, 0, 0, 4, 0, 0, 0, 0, 0, 1, 0, 0, 42, 6,
	];
	let _ = server
	.write(bytes, &mut vec![])
	.expect("Server channel write failed");
	};

	let receiver = receiver.on_timeout(1000.millis().after_now(), \|\| {
	panic!("did not receiver message in time!")
	});

	let sender = async {
	let client = await!(modem_lock.create_client()).unwrap();
	let resp: QmiResult<CTL::GetClientIdResp> =
	await!(client.send_msg_actual(CTL::GetClientIdReq::new(0x42))).unwrap();
	let msg = resp.unwrap();
	assert_eq!(msg.svc_type, 42);
	assert_eq!(msg.client_id, 6);
	};

	let sender = sender.on_timeout(1000.millis().after_now(), \|\| {
	panic!("did not receive response in time!")
	});

	executor.run_singlethreaded(receiver.join(sender));
	}
	}