1 //! Starts the facade services that allow us to test the Bluetooth stack
2
3 use bt_topshim::btif;
4
5 use clap::{value_parser, Arg, Command};
6 use futures::channel::mpsc;
7 use futures::executor::block_on;
8 use futures::stream::StreamExt;
9 use grpcio::*;
10 use lazy_static::lazy_static;
11 use log::debug;
12 use nix::sys::signal;
13 use std::sync::{Arc, Mutex};
14 use tokio::runtime::Runtime;
15
16 mod adapter_service;
17 mod gatt_service;
18 mod hf_client_service;
19 mod hfp_service;
20 mod media_service;
21 mod security_service;
22 mod utils;
23
24 // This is needed for linking, libbt_shim_bridge needs symbols defined by
25 // bt_shim, however bt_shim depends on rust crates (future, tokio) that
26 // we use too, if we build and link them separately we ends with duplicate
27 // symbols. To solve that we build bt_shim with bt_topshim_facade so the rust
28 // compiler share the transitive dependencies.
29 //
30 // The `::*` is here to circuvent the single_component_path_imports from
31 // clippy that is denied on the rust command line so we can't just allow it.
32 // This is fine for now since bt_shim doesn't export anything
33 #[allow(unused)]
34 use bluetooth_core_rs_for_facade::*;
35 #[allow(unused)]
36 use bt_shim::*;
37
main()38 fn main() {
39 let sigint = install_sigint();
40 bt_common::init_logging();
41 let rt = Arc::new(Runtime::new().unwrap());
42 rt.block_on(async_main(Arc::clone(&rt), sigint));
43 }
44
clap_command() -> Command45 fn clap_command() -> Command {
46 Command::new("bluetooth_topshim_facade")
47 .about("The bluetooth topshim stack, with testing facades enabled and exposed via gRPC.")
48 .arg(
49 Arg::new("grpc-port")
50 .long("grpc-port")
51 .value_parser(value_parser!(u16))
52 .default_value("8899"),
53 )
54 .arg(
55 Arg::new("root-server-port")
56 .long("root-server-port")
57 .value_parser(value_parser!(u16))
58 .default_value("8897"),
59 )
60 .arg(
61 Arg::new("signal-port")
62 .long("signal-port")
63 .value_parser(value_parser!(u16))
64 .default_value("8895"),
65 )
66 .arg(Arg::new("rootcanal-port").long("rootcanal-port").value_parser(value_parser!(u16)))
67 .arg(Arg::new("btsnoop").long("btsnoop"))
68 .arg(Arg::new("btsnooz").long("btsnooz"))
69 .arg(Arg::new("btconfig").long("btconfig"))
70 .arg(
71 Arg::new("start-stack-now")
72 .long("start-stack-now")
73 .value_parser(value_parser!(bool))
74 .default_value("true"),
75 )
76 }
77
async_main(rt: Arc<Runtime>, mut sigint: mpsc::UnboundedReceiver<()>)78 async fn async_main(rt: Arc<Runtime>, mut sigint: mpsc::UnboundedReceiver<()>) {
79 let matches = clap_command().get_matches();
80
81 let grpc_port = *matches.get_one::<u16>("grpc-port").unwrap();
82 let _rootcanal_port = matches.get_one::<u16>("rootcanal-port").cloned();
83 let env = Arc::new(Environment::new(2));
84
85 let btif_intf = Arc::new(Mutex::new(btif::get_btinterface().unwrap()));
86
87 // AdapterServiceImpl::create initializes the stack; not the best practice because the side effect is hidden
88 let adapter_service_impl =
89 adapter_service::AdapterServiceImpl::create(rt.clone(), btif_intf.clone());
90
91 let security_service_impl =
92 security_service::SecurityServiceImpl::create(rt.clone(), btif_intf.clone());
93
94 let gatt_service_impl = gatt_service::GattServiceImpl::create(rt.clone(), btif_intf.clone());
95
96 let hf_client_service_impl =
97 hf_client_service::HfClientServiceImpl::create(rt.clone(), btif_intf.clone());
98
99 let hfp_service_impl = hfp_service::HfpServiceImpl::create(rt.clone(), btif_intf.clone());
100
101 let media_service_impl = media_service::MediaServiceImpl::create(rt.clone(), btif_intf.clone());
102
103 let start_stack_now = *matches.get_one::<bool>("start-stack-now").unwrap();
104
105 if start_stack_now {
106 btif_intf.clone().lock().unwrap().enable();
107 }
108
109 let mut server = ServerBuilder::new(env)
110 .register_service(adapter_service_impl)
111 .register_service(security_service_impl)
112 .register_service(gatt_service_impl)
113 .register_service(hf_client_service_impl)
114 .register_service(hfp_service_impl)
115 .register_service(media_service_impl)
116 .bind("0.0.0.0", grpc_port)
117 .build()
118 .unwrap();
119 server.start();
120
121 sigint.next().await;
122 block_on(server.shutdown()).unwrap();
123 }
124
125 // TODO: remove as this is a temporary nix-based hack to catch SIGINT
install_sigint() -> mpsc::UnboundedReceiver<()>126 fn install_sigint() -> mpsc::UnboundedReceiver<()> {
127 let (tx, rx) = mpsc::unbounded();
128 *SIGINT_TX.lock().unwrap() = Some(tx);
129
130 let sig_action = signal::SigAction::new(
131 signal::SigHandler::Handler(handle_sigint),
132 signal::SaFlags::empty(),
133 signal::SigSet::empty(),
134 );
135 unsafe {
136 signal::sigaction(signal::SIGINT, &sig_action).unwrap();
137 }
138
139 rx
140 }
141
142 lazy_static! {
143 static ref SIGINT_TX: Mutex<Option<mpsc::UnboundedSender<()>>> = Mutex::new(None);
144 }
145
handle_sigint(_: i32)146 extern "C" fn handle_sigint(_: i32) {
147 let mut sigint_tx = SIGINT_TX.lock().unwrap();
148 if let Some(tx) = &*sigint_tx {
149 debug!("Stopping gRPC root server due to SIGINT");
150 tx.unbounded_send(()).unwrap();
151 }
152 *sigint_tx = None;
153 }
154
155 #[cfg(test)]
156 mod tests {
157 use super::*;
158
159 #[test]
verify_comand()160 fn verify_comand() {
161 clap_command().debug_assert();
162 }
163 }
164