pub mod backend;
pub mod bundle;
pub mod cache;
pub mod check;
pub mod conn;
pub mod hub;
pub mod picker;
pub mod remote;
pub mod resolution;
pub mod scan;
pub mod server;
pub mod shortlink;
pub mod smoke;
pub mod source;
pub mod surface;
pub mod tool;
pub mod web;
pub mod window;
use std::net::{IpAddr, SocketAddr};
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
use crate::ctx::Ctx;
use crate::error::{Error, Result};
use crate::events::{Events, Progress, Step};
use crate::net::httpd;
use crate::net::tunnel::Provider;
use crate::util::stop::Stop;
pub use bundle::Bundle;
pub use hub::Hub;
pub use window::WindowMode;
pub const LAN_PORT: u16 = 7420;
pub const ORPHAN_AFTER: Duration = Duration::from_secs(30);
const TICK: Duration = Duration::from_millis(200);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum TunnelChoice {
#[default]
Auto,
Provider(Provider),
Off,
}
#[derive(Debug, Clone, Default)]
pub struct Options {
pub game: String,
pub fetch: remote::FetchOptions,
pub yes: bool,
pub tunnel: TunnelChoice,
pub lan: Option<Option<IpAddr>>,
pub window: WindowMode,
pub browser: Option<PathBuf>,
pub port: u16,
pub resolution: resolution::Resolution,
pub no_short_link: bool,
}
pub(crate) struct Running {
pub hub: Arc<Hub>,
servers: Servers,
tunnel: TunnelThread,
}
impl Running {
pub(crate) fn start(
bundle: Bundle,
backend: Box<dyn backend::Backend>,
opts: &Options,
stop: Stop,
) -> Result<Running> {
Running::start_with(bundle, backend, opts, stop, Events::none())
}
pub(crate) fn start_with(
bundle: Bundle,
backend: Box<dyn backend::Backend>,
opts: &Options,
stop: Stop,
events: Events,
) -> Result<Running> {
let token = crate::util::hex::encode(&crate::crypto::ring::random_array::<16>()?);
let hub = Hub::new(bundle, token, backend, stop.clone());
hub.set_resolution(opts.resolution);
let _ = hub.events.set(events);
let _ = hub.shortlinks.set(shortlink::ShortLinks::from_env(
opts.no_short_link,
stop.clone(),
));
let servers = Servers::start(&hub, opts.port, opts.lan)?;
let tunnel = start_tunnel(&hub, opts.tunnel);
Ok(Running {
hub,
servers,
tunnel,
})
}
pub(crate) fn start_url(&self) -> String {
format!(
"http://127.0.0.1:{}/_tvpipe/start?t={}",
self.hub.ports.get().map(|p| p.local).unwrap_or(0),
self.hub.token
)
}
pub(crate) fn end(self) {
self.hub.shutdown();
if let Some(l) = self.hub.shortlinks.get() {
l.release();
}
drop(self.tunnel);
drop(self.servers);
}
}
pub type Ask<'a> = &'a dyn Fn(&str, &dyn Fn() -> bool) -> Option<bool>;
pub fn open_game(opts: &Options, ctx: &Ctx, ask: Ask<'_>) -> Result<Bundle> {
let src = source::Source::parse(&opts.game)?;
if let source::Source::Local(p) = &src {
return Bundle::open(p);
}
let fetcher =
remote::Fetcher::from_env(opts.fetch, ctx.events.clone(), Some(ctx.stop.clone()))?;
let f = fetcher.fetch(&src)?;
if f.pinned || f.trusted || opts.yes {
return Ok(f.bundle);
}
let stop = ctx.stop.clone();
match ask(&f.question(), &|| stop.requested()) {
Some(true) => {
fetcher.trust(&f)?;
Ok(f.bundle)
}
Some(false) => Err(Error::usage(format!(
"not playing {}: you said no",
f.bundle.manifest.name
))),
None if stop.requested() => Err(Error::closed("stopped")),
None => Err(Error::usage(format!(
"{} is a game from the internet, and there is no terminal to ask whether to run it: \
pass --yes, or pin it: tvpipe game play '{}'",
f.shown, f.pin_hint
))),
}
}
pub fn run(opts: &Options, ctx: &Ctx, ask: Ask<'_>) -> Result<()> {
if opts.game.trim().is_empty() {
return run_picked(opts, ctx);
}
let bundle = open_game(opts, ctx, ask)?;
let running = start_game(bundle, opts, ctx)?;
let url = running.start_url();
let window = match open_window(opts, &url, &ctx.events) {
Ok(w) => w,
Err(e) => {
running.end();
return Err(e);
}
};
serve(running, window, &ctx.stop, &ctx.events);
Ok(())
}
fn run_picked(opts: &Options, ctx: &Ctx) -> Result<()> {
let stop = ctx.stop.clone();
let picker = picker::Picker::start(opts.fetch, opts.yes, opts.port, stop.clone())?;
let mut window = open_window(opts, &picker.start_url(), &ctx.events)?;
info!("playshare: pick a game in the window");
let bundle = loop {
if stop.wait(TICK) {
window.close();
return Ok(());
}
if window.owned() {
window.pass_out_new_pages();
if window.closed() {
info!("playshare: the window was closed");
window.close();
return Ok(());
}
}
if let Some(b) = picker.take() {
break b;
}
};
let source = bundle.origin.display().to_string();
let game_opts = Options {
port: 0,
..opts.clone()
};
let running = match start_game(bundle, &game_opts, ctx) {
Ok(r) => r,
Err(e) => {
picker.failed(&source, &e);
stop.wait(Duration::from_secs(3));
window.close();
return Err(e);
}
};
picker.started(running.start_url());
serve(running, window, &stop, &ctx.events);
drop(picker);
Ok(())
}
fn start_game(bundle: Bundle, opts: &Options, ctx: &Ctx) -> Result<Running> {
let events = ctx.events.clone();
info!(
"playshare: {} from {}",
bundle.manifest.title,
bundle.origin.display()
);
let title = bundle.manifest.title.clone();
let backend = backend::Real {
storage: ctx.storage.clone(),
browser: opts.browser.clone(),
};
let running = Running::start_with(
bundle,
Box::new(backend),
opts,
ctx.stop.clone(),
events.clone(),
)?;
let p = *running
.hub
.ports
.get()
.ok_or_else(|| Error::closed("no ports"))?;
let local = format!("http://127.0.0.1:{}/", p.public);
let lan = p.lan.map(|lan| format!("http://{lan}/"));
info!(
"playshare: phones on this computer: {local}{}",
lan.as_ref()
.map(|l| format!(", on the Wi-Fi: {l}"))
.unwrap_or_default()
);
events.progress(Progress::Game { title, local, lan });
Ok(running)
}
fn open_window(opts: &Options, url: &str, events: &Events) -> Result<window::Window> {
if opts.window != WindowMode::None {
events.progress(Progress::Begin(Step::Window));
}
let (window, mode) = match window::Window::open(opts.window, url, opts.browser.as_ref()) {
Ok(w) => w,
Err(e) => {
events.progress(Progress::Failed(Step::Window, e.to_string()));
return Err(e);
}
};
if opts.window != WindowMode::None {
events.progress(Progress::Done(Step::Window, None));
}
if mode == WindowMode::None {
println!("{url}");
}
Ok(window)
}
fn serve(running: Running, mut window: window::Window, stop: &Stop, events: &Events) {
let hub = running.hub.clone();
let mut phones = 0;
let why = loop {
if stop.wait(TICK) {
break "stopped";
}
hub.tick();
let n = hub.client_count();
if n != phones {
phones = n;
events.progress(Progress::Phones(n));
}
if window.owned() {
window.pass_out_new_pages();
if window.closed() {
break "the window was closed";
}
} else if hub.apis_gone_for().is_some_and(|d| d > ORPHAN_AFTER) {
break "no page has been connected for 30 s";
}
};
info!("playshare: ending ({why})");
running.end();
window.close();
}
struct Servers {
list: Vec<httpd::Server>,
}
impl Servers {
fn start(hub: &Arc<Hub>, port: u16, lan: Option<Option<IpAddr>>) -> Result<Servers> {
let config = httpd::Config {
max_connections: hub.max_clients() + 64,
max_body: 64 * 1024,
lan: false,
};
let local = httpd::Server::bind_with(
SocketAddr::from(([127, 0, 0, 1], port)),
server::handler(hub.clone(), server::Listener::Local),
config,
)?;
let public = httpd::Server::bind_with(
SocketAddr::from(([127, 0, 0, 1], 0)),
server::handler(hub.clone(), server::Listener::Public),
config,
)?;
let mut list = vec![];
let mut lan_addr = None;
if let Some(ip) = lan {
let ip = match ip {
Some(ip) => ip,
None => IpAddr::V4(crate::net::iface::default_ipv4()?),
};
let cfg = httpd::Config {
lan: true,
..config
};
let mut bound = None;
let mut last = None;
for port in (LAN_PORT..LAN_PORT + 20).chain([0]) {
match httpd::Server::bind_with(
SocketAddr::new(ip, port),
server::handler(hub.clone(), server::Listener::Lan),
cfg,
) {
Ok(s) => {
bound = Some(s);
break;
}
Err(e) => last = Some(e),
}
}
let s = match bound {
Some(s) => s,
None => {
return Err(last.unwrap_or_else(|| Error::closed("no LAN port")));
}
};
lan_addr = Some(s.local_addr());
list.push(s);
}
let _ = hub.ports.set(hub::Ports {
local: local.local_addr().port(),
public: public.local_addr().port(),
lan: lan_addr,
});
list.push(local);
list.push(public);
Ok(Servers { list })
}
}
impl Drop for Servers {
fn drop(&mut self) {
for s in &mut self.list {
s.shutdown();
}
}
}
struct TunnelThread {
slot: Arc<std::sync::Mutex<Option<Box<dyn crate::net::tunnel::Tunnel>>>>,
}
impl Drop for TunnelThread {
fn drop(&mut self) {
let t = self.slot.lock().unwrap_or_else(|e| e.into_inner()).take();
drop(t);
}
}
fn start_tunnel(hub: &Arc<Hub>, choice: TunnelChoice) -> TunnelThread {
let slot: Arc<std::sync::Mutex<Option<Box<dyn crate::net::tunnel::Tunnel>>>> = Arc::default();
let order: Vec<Provider> = match choice {
TunnelChoice::Off => return TunnelThread { slot },
TunnelChoice::Auto => vec![Provider::OpenTunnel, Provider::Cloudflare],
TunnelChoice::Provider(p) => vec![p],
};
let port = hub.ports.get().map(|p| p.public).unwrap_or(0);
{
let mut t = hub.tunnel.write().unwrap_or_else(|e| e.into_inner());
t.state = "starting";
}
hub.progress(Progress::Begin(Step::Tunnel));
let (hub, s) = (hub.clone(), slot.clone());
let _ = std::thread::Builder::new()
.name("playshare-tunnel".into())
.spawn(move || {
let stop = hub.stop.clone();
let mut last_err = None;
for p in order {
if stop.requested() {
return;
}
let started = match p {
Provider::Cloudflare => crate::storage::cli_dir()
.map(|d| d.join("cloudflare-quick-tunnel.json"))
.and_then(|f| {
crate::net::cftunnel::Tunnel::start_reusing(port, &f, &|| {
stop.requested()
})
})
.map(|t| Box::new(t) as Box<dyn crate::net::tunnel::Tunnel>),
_ => crate::net::tunnel::start(port, p, &|| stop.requested()),
};
match started {
Ok(t) => {
info!(
"playshare: phones join at https://{}/ ({})",
t.host(),
t.name()
);
{
let mut info = hub.tunnel.write().unwrap_or_else(|e| e.into_inner());
info.state = "up";
info.provider = Some(p.name().to_owned());
info.host = Some(t.host().to_owned());
info.error = None;
}
hub.progress(Progress::GameLink {
url: format!("https://{}/", t.host()),
provider: p.name().to_owned(),
short: hub.shortlinks.get().is_some_and(|l| l.enabled()),
});
*hub.peers.write().unwrap_or_else(|e| e.into_inner()) = t.peer_lookup();
*s.lock().unwrap_or_else(|e| e.into_inner()) = Some(t);
if stop.requested() {
s.lock().unwrap_or_else(|e| e.into_inner()).take();
return;
}
hub.tunnel_changed();
return;
}
Err(e) => {
warn!("playshare: {} tunnel: {e}", p.name());
last_err = Some(e.to_string());
}
}
}
hub.progress(Progress::Failed(
Step::Tunnel,
last_err.clone().unwrap_or_else(|| "no tunnel".into()),
));
{
let mut info = hub.tunnel.write().unwrap_or_else(|e| e.into_inner());
info.state = "failed";
info.error = last_err;
}
hub.tunnel_changed();
});
TunnelThread { slot }
}
#[cfg(test)]
mod tests;