diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 25aafb9..18cb808 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -36,6 +36,10 @@ jobs: # The drop zone's pure logic and its offscreen renders (snapshots are uploaded). - run: "cargo test --locked --features edge edge::" - run: cargo build --release --locked --features webview,edge + env: + # Lets the in-app updater tell which main build this is. + AIRBRIDGE_BUILD: ${{ github.run_number }} + - run: packaging/appimage.sh target/release/airbridge - uses: actions/upload-artifact@v6 with: name: edge-snapshots @@ -43,7 +47,7 @@ jobs: - uses: actions/upload-artifact@v6 with: name: airbridge-linux-x86_64 - path: linux/target/release/airbridge + path: linux/airbridge-x86_64.AppImage android: name: Android app + interop with Linux @@ -104,14 +108,24 @@ jobs: with: name: airbridge-android-apk path: release - - name: Package release assets + - name: Package and sign release assets + env: + UPDATE_SIGNING_KEY: ${{ secrets.UPDATE_SIGNING_KEY }} + TAG: main-${{ github.run_number }} run: | - test -s release/airbridge + test -s release/airbridge-x86_64.AppImage test -s release/app-release.apk + [ -n "$UPDATE_SIGNING_KEY" ] || { echo "UPDATE_SIGNING_KEY secret is missing; refusing to publish an unsigned build"; exit 1; } # Artifact downloads do not preserve the Linux executable bit. - chmod +x release/airbridge - tar -C release -czf airbridge-linux-x86_64.tar.gz airbridge + install -m755 release/airbridge-x86_64.AppImage airbridge-x86_64.AppImage cp release/app-release.apk airbridge-android.apk + # The in-app updater checks this: the AppImage, a newline, then its tag. + umask 077 + printf '%s\n' "$UPDATE_SIGNING_KEY" > "$RUNNER_TEMP/key.pem" + { cat airbridge-x86_64.AppImage; printf '\n%s' "$TAG"; } > "$RUNNER_TEMP/message" + openssl pkeyutl -sign -rawin -inkey "$RUNNER_TEMP/key.pem" -in "$RUNNER_TEMP/message" -out airbridge-x86_64.AppImage.sig + rm -f "$RUNNER_TEMP/key.pem" "$RUNNER_TEMP/message" + test "$(stat -c %s airbridge-x86_64.AppImage.sig)" -eq 64 - uses: softprops/action-gh-release@v3 with: tag_name: main-${{ github.run_number }} @@ -126,9 +140,10 @@ jobs: **Downloads** - `airbridge-android.apk`: Android 10 or newer. - - `airbridge-linux-x86_64.tar.gz`: unpack and run `./airbridge`. + - `airbridge-x86_64.AppImage`: make it executable and run it. It updates itself from the app's Update button. The APK uses a debug signing key; Android may require uninstalling the previous build before installation. files: | - airbridge-linux-x86_64.tar.gz + airbridge-x86_64.AppImage + airbridge-x86_64.AppImage.sig airbridge-android.apk diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 090305f..c07b1c3 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -62,11 +62,11 @@ jobs: working-directory: linux run: | cargo build --release --locked --features webview,edge - tar -C target/release -czf ../airbridge-linux-x86_64.tar.gz airbridge + packaging/appimage.sh target/release/airbridge .. - uses: actions/upload-artifact@v6 with: name: release-linux-x86_64 - path: airbridge-linux-x86_64.tar.gz + path: airbridge-x86_64.AppImage if-no-files-found: error android: @@ -106,7 +106,8 @@ jobs: merge-multiple: true - name: Check release assets run: | - test -s airbridge-linux-x86_64.tar.gz + test -s airbridge-x86_64.AppImage + chmod +x airbridge-x86_64.AppImage test -s airbridge-android.apk - uses: softprops/action-gh-release@v3 with: @@ -116,10 +117,10 @@ jobs: body: | **Downloads** - `airbridge-android.apk`: the Android app (Android 10 or newer). Allow installs from your browser or file manager when asked. - - `airbridge-linux-x86_64.tar.gz`: the Linux app. Unpack it and run `./airbridge`, or install it with `packaging/install.sh` from the source. + - `airbridge-x86_64.AppImage`: the Linux app. Make it executable and run it (needs GTK 3 and WebKitGTK 4.1, present on most desktops). The APK is signed with a debug key made for this build, not a private release key, so a newer release may need the old app uninstalled first. See [SECURITY.md](https://github.com/${{ github.repository }}/blob/${{ env.VERSION }}/docs/SECURITY.md). files: | - airbridge-linux-x86_64.tar.gz + airbridge-x86_64.AppImage airbridge-android.apk generate_release_notes: true diff --git a/README.md b/README.md index 990ba10..e0d9f0f 100644 --- a/README.md +++ b/README.md @@ -127,6 +127,20 @@ Received photos show up as a preview in the notification. ### Linux +Download `airbridge-x86_64.AppImage` from the newest +[release](https://github.com/MDHaarith/Linux-Android-AirDrop/releases), then: + +```bash +chmod +x airbridge-x86_64.AppImage && ./airbridge-x86_64.AppImage +``` + +It uses the system's GTK 3, WebKitGTK 4.1 and gtk-layer-shell, which most desktops already have. +When a newer build of `main` passes CI, an **Update** button appears in the toolbar. It +downloads the new AppImage, checks its Ed25519 signature against the key built into the app, +swaps the file and restarts. Unsigned or older builds are refused. + +#### From source + You need [Rust](https://rustup.rs) 1.89 or newer and the Wayland client headers (`libwayland-dev` / `wayland-devel`, used by the file picker). For a native app window, also install WebKitGTK. Without it, AirBridge opens in a Chromium app window or your default browser. diff --git a/docs/SECURITY.md b/docs/SECURITY.md index e4cedb8..8c69d5d 100644 --- a/docs/SECURITY.md +++ b/docs/SECURITY.md @@ -59,6 +59,16 @@ to your own verified devices. Devices at the phone's own address are refused transfers, received text is marked sensitive on the clipboard, and malformed requests cannot crash the app. +## Updates + +The Linux AppImage updates itself only from `main-N` prereleases on GitHub, over +HTTPS (system CA store, HTTPS-only redirects). CI signs each AppImage with an +Ed25519 key kept in the `UPDATE_SIGNING_KEY` secret. The signature covers the +file and its tag, and the public key is built into the app. A download with a +bad signature, an older or equal build number, or one that is not an ELF file +is rejected before anything is written. The swap is atomic (temp file, fsync, +rename). Only the token-protected local UI can start an update. + ## Known limits - The official LocalSend apps do not present client certificates. They work, diff --git a/linux/packaging/appimage.sh b/linux/packaging/appimage.sh new file mode 100755 index 0000000..df53cfe --- /dev/null +++ b/linux/packaging/appimage.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +# Packs a release binary into airbridge-x86_64.AppImage. +# ./appimage.sh path/to/airbridge [output-dir] +# GTK, WebKitGTK 4.1 and gtk-layer-shell come from the system, as on any desktop. +set -euo pipefail + +bin="$(realpath "$1")" +out="$(realpath "${2:-.}")" +here="$(cd "$(dirname "$0")" && pwd)" +work="$(mktemp -d)" +trap 'rm -rf "$work"' EXIT + +# Pinned tools, checked before use. +fetch() { # url sha256 dest + curl -fsSL --proto '=https' --retry 3 -o "$3" "$1" + echo "$2 $3" | sha256sum -c --quiet +} +fetch https://github.com/AppImage/appimagetool/releases/download/1.9.1/appimagetool-x86_64.AppImage \ + ed4ce84f0d9caff66f50bcca6ff6f35aae54ce8135408b3fa33abfc3cb384eb0 "$work/appimagetool" +fetch https://github.com/AppImage/type2-runtime/releases/download/20251108/runtime-x86_64 \ + 2fca8b443c92510f1483a883f60061ad09b46b978b2631c807cd873a47ec260d "$work/runtime" +chmod +x "$work/appimagetool" + +app="$work/AirBridge.AppDir" +install -Dm755 "$bin" "$app/usr/bin/airbridge" +install -Dm644 "$here/../ui/icon.svg" "$app/airbridge.svg" +install -Dm644 "$here/../ui/icon.svg" "$app/usr/share/icons/hicolor/scalable/apps/airbridge.svg" +install -Dm644 "$here/airbridge.desktop" "$app/airbridge.desktop" +cat > "$app/AppRun" <<'EOF' +#!/bin/sh +exec "$(dirname "$(readlink -f "$0")")/usr/bin/airbridge" "$@" +EOF +chmod +x "$app/AppRun" + +# No FUSE on CI runners. +APPIMAGE_EXTRACT_AND_RUN=1 ARCH=x86_64 "$work/appimagetool" --no-appstream \ + --runtime-file "$work/runtime" "$app" "$out/airbridge-x86_64.AppImage" diff --git a/linux/src/fetch.rs b/linux/src/fetch.rs index f871046..b72a5fb 100644 --- a/linux/src/fetch.rs +++ b/linux/src/fetch.rs @@ -210,6 +210,43 @@ async fn stage(name: &str, data: &[u8]) -> Result { }) } +/// Downloads `url` into memory over HTTPS only (redirects included), up to `max` bytes. +pub async fn download(url: &str, max: u64) -> Result> { + let mut uri: Uri = url.parse().context("not a valid link")?; + for _ in 0..=MAX_REDIRECTS { + if uri.scheme_str() != Some("https") { + bail!("refusing a non-HTTPS download"); + } + let response = get(&uri).await?; + let status = response.status(); + if status.is_redirection() { + let location = response + .headers() + .get(hyper::header::LOCATION) + .and_then(|v| v.to_str().ok()) + .ok_or_else(|| anyhow!("redirect without a location"))?; + uri = resolve(&uri, location)?; + continue; + } + if status != StatusCode::OK { + bail!("the server answered {status}"); + } + let mut stream = response.into_body().into_data_stream(); + let mut data = Vec::new(); + while let Some(chunk) = timeout(IO_TIMEOUT, stream.next()) + .await + .map_err(|_| anyhow!("the download stalled"))? + { + data.extend_from_slice(&chunk?); + if data.len() as u64 > max { + bail!("the download is too large"); + } + } + return Ok(data); + } + bail!("too many redirects") +} + async fn stage_stream(name: &str, body: hyper::body::Incoming) -> Result { let path = staging_path(name); tokio::fs::create_dir_all(path.parent().unwrap()).await?; diff --git a/linux/src/main.rs b/linux/src/main.rs index dd2fafb..c6f8ee4 100644 --- a/linux/src/main.rs +++ b/linux/src/main.rs @@ -27,6 +27,7 @@ mod transfers; #[cfg(feature = "tray")] mod tray; mod ui; +mod update; #[cfg(feature = "webview")] mod window; @@ -157,13 +158,27 @@ fn main() -> ExitCode { }; } let runtime = tokio::runtime::Runtime::new().expect("tokio runtime"); - match runtime.block_on(run(cli)) { + let code = match runtime.block_on(run(cli)) { Ok(code) => code, Err(err) => { eprintln!("airbridge: {err:#}"); ExitCode::FAILURE } + }; + if update::RESTART.load(std::sync::atomic::Ordering::Relaxed) { + // Close every socket first so the new version can take the ports. + runtime.shutdown_timeout(Duration::from_secs(3)); + if let Some(appimage) = update::appimage() { + use std::os::unix::process::CommandExt; + if let Err(err) = std::process::Command::new(appimage) + .process_group(0) + .spawn() + { + eprintln!("airbridge: could not restart after the update: {err}"); + } + } } + code } async fn run(cli: Cli) -> Result { diff --git a/linux/src/ui.rs b/linux/src/ui.rs index f0368cd..131f587 100644 --- a/linux/src/ui.rs +++ b/linux/src/ui.rs @@ -25,6 +25,7 @@ use crate::config; use crate::desktop; use crate::receiver::constant_time_eq; use crate::sender::{expand_paths, SendItem}; +use crate::update; const COOKIE: &str = "airbridge_token"; @@ -64,6 +65,7 @@ pub fn router(app: Arc) -> Router { .route("/open-downloads", post(open_downloads)) .route("/show", post(show)) .route("/quit", post(quit)) + .route("/update", get(check_update).post(apply_update)) .layer(middleware::from_fn_with_state(app.clone(), auth)); Router::new() .route("/", get(index)) @@ -665,3 +667,40 @@ async fn quit(State(app): State>) -> StatusCode { app.shutdown.cancel(); StatusCode::NO_CONTENT } + +async fn check_update() -> Response { + match update::check().await { + Ok(available) => Json(json!({ + "current": update::current_build(), + "available": available, + "canInstall": update::appimage().is_some(), + })) + .into_response(), + Err(err) => bad_request(format!("Could not check for updates: {err:#}")), + } +} + +/// Installs the newest build and restarts; outside the AppImage it opens the release page. +async fn apply_update(State(app): State>) -> Response { + let available = match update::check().await { + Ok(Some(available)) => available, + Ok(None) => return bad_request("AirBridge is up to date."), + Err(err) => return bad_request(format!("Could not check for updates: {err:#}")), + }; + if update::appimage().is_none() { + desktop::open_url(&available.page); + return Json(json!({ "restarting": false })).into_response(); + } + if let Err(err) = update::install(&available).await { + tracing::warn!("Update failed: {err:#}"); + return bad_request(format!("Update failed: {err:#}")); + } + tracing::info!("Updated to {}; restarting", available.tag); + update::RESTART.store(true, Ordering::Relaxed); + // Let this answer reach the window before the server goes away. + tokio::spawn(async move { + tokio::time::sleep(std::time::Duration::from_millis(500)).await; + app.shutdown.cancel(); + }); + Json(json!({ "restarting": true })).into_response() +} diff --git a/linux/src/update.rs b/linux/src/update.rs new file mode 100644 index 0000000..66852aa --- /dev/null +++ b/linux/src/update.rs @@ -0,0 +1,193 @@ +//! In-app updates from the automatic `main-N` prereleases (every merge to main +//! that passed CI). Only the AppImage replaces itself; the download must carry +//! an Ed25519 signature from the release key, bound to its tag so an older +//! build cannot be replayed as a newer one. + +use std::os::unix::fs::PermissionsExt; +use std::path::PathBuf; +use std::sync::atomic::AtomicBool; + +use anyhow::{anyhow, bail, Context, Result}; +use ring::signature::{UnparsedPublicKey, ED25519}; +use serde::{Deserialize, Serialize}; + +use crate::fetch::download; + +const REPO: &str = "MDHaarith/Linux-Android-AirDrop"; +const ASSET: &str = "airbridge-x86_64.AppImage"; +const MAX_SIZE: u64 = 512 * 1024 * 1024; +/// Release signing key; the private half lives only in the repo's `UPDATE_SIGNING_KEY` secret. +const PUBLIC_KEY: [u8; 32] = [ + 0xaa, 0x73, 0xb8, 0xf3, 0x37, 0xfa, 0xca, 0xc6, 0x1a, 0x52, 0x6a, 0x52, 0xd7, 0x19, 0x49, 0x66, + 0x4f, 0x83, 0x99, 0xd8, 0xeb, 0x77, 0x6a, 0xe6, 0x57, 0x4a, 0xe2, 0x78, 0x0a, 0xf0, 0x49, 0x2f, +]; + +/// Set once a new AppImage is in place; `main` relaunches it after shutdown. +pub static RESTART: AtomicBool = AtomicBool::new(false); + +/// CI run number of this build (0 for local builds). +pub fn current_build() -> u64 { + option_env!("AIRBRIDGE_BUILD") + .and_then(|b| b.parse().ok()) + .unwrap_or(0) +} + +/// The AppImage file we are running from, if any. +pub fn appimage() -> Option { + std::env::var_os("APPIMAGE") + .map(PathBuf::from) + .filter(|p| p.is_absolute()) +} + +#[derive(Serialize, Clone)] +pub struct Available { + pub build: u64, + pub tag: String, + pub page: String, + #[serde(skip)] + app_url: String, + #[serde(skip)] + sig_url: String, +} + +#[derive(Deserialize)] +struct Release { + tag_name: String, + html_url: String, + #[serde(default)] + draft: bool, + assets: Vec, +} + +#[derive(Deserialize)] +struct Asset { + name: String, + browser_download_url: String, +} + +fn main_build(tag: &str) -> Option { + tag.strip_prefix("main-")?.parse().ok() +} + +/// The newest main build that is newer than this one and ships a signed AppImage. +pub async fn check() -> Result> { + let url = format!("https://api.github.com/repos/{REPO}/releases?per_page=20"); + let releases: Vec = serde_json::from_slice(&download(&url, 4 * 1024 * 1024).await?) + .context("unexpected answer from GitHub")?; + Ok(newest(releases, current_build())) +} + +fn newest(releases: Vec, current: u64) -> Option { + releases + .into_iter() + .filter(|r| !r.draft) + .filter_map(|r| { + let build = main_build(&r.tag_name).filter(|&b| b > current)?; + let url = |name: &str| { + r.assets + .iter() + .find(|a| a.name == name) + .map(|a| a.browser_download_url.clone()) + }; + Some(Available { + build, + app_url: url(ASSET)?, + sig_url: url(&format!("{ASSET}.sig"))?, + tag: r.tag_name, + page: r.html_url, + }) + }) + .max_by_key(|a| a.build) +} + +/// What the signature covers: the file, then a newline and its tag. +fn verify(data: &[u8], tag: &str, signature: &[u8]) -> Result<()> { + let mut message = Vec::with_capacity(data.len() + tag.len() + 1); + message.extend_from_slice(data); + message.push(b'\n'); + message.extend_from_slice(tag.as_bytes()); + UnparsedPublicKey::new(&ED25519, PUBLIC_KEY) + .verify(&message, signature) + .map_err(|_| anyhow!("the update's signature is not valid")) +} + +/// Downloads, verifies and swaps in the new AppImage. Takes effect on restart. +pub async fn install(update: &Available) -> Result<()> { + let target = appimage().ok_or_else(|| anyhow!("only the AppImage can update itself"))?; + let signature = download(&update.sig_url, 1024).await?; + let data = download(&update.app_url, MAX_SIZE).await?; + verify(&data, &update.tag, &signature)?; + if !data.starts_with(b"\x7fELF") { + bail!("the update is not a Linux program"); + } + let dir = target.parent().context("AppImage has no folder")?; + let temp = dir.join(format!(".{ASSET}.update")); + let written = (|| -> std::io::Result<()> { + use std::io::Write; + let mut file = std::fs::OpenOptions::new() + .write(true) + .create(true) + .truncate(true) + .open(&temp)?; + file.write_all(&data)?; + file.set_permissions(std::fs::Permissions::from_mode(0o755))?; + file.sync_all()?; + // The running copy keeps its open inode, so replacing the file is safe. + std::fs::rename(&temp, &target) + })(); + if let Err(err) = written { + let _ = std::fs::remove_file(&temp); + return Err(err).with_context(|| format!("could not replace {}", target.display())); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + // Made with the release key: `printf airbridge-update-selftest` + "\n" + "main-1". + const SELFTEST_SIG: [u8; 64] = [ + 0xb9, 0x13, 0xb4, 0x7a, 0x81, 0x54, 0xfb, 0xe7, 0x30, 0xf6, 0xc9, 0x51, 0xc0, 0x7b, 0x0d, + 0xc2, 0x16, 0x51, 0xfb, 0x6e, 0xed, 0x92, 0xb2, 0x8a, 0x4f, 0xf2, 0x81, 0x4a, 0x34, 0xb4, + 0x51, 0xc0, 0x0d, 0xf9, 0x06, 0x29, 0xf5, 0xeb, 0xbf, 0x0a, 0x31, 0x1a, 0x5f, 0x59, 0xee, + 0xdc, 0xb5, 0x41, 0x3c, 0x06, 0x3a, 0x61, 0xb9, 0xf8, 0x33, 0xa1, 0x38, 0x50, 0xcf, 0x06, + 0x5b, 0xf0, 0x67, 0x08, + ]; + + #[test] + fn signature_binds_file_and_tag() { + let data = b"airbridge-update-selftest"; + verify(data, "main-1", &SELFTEST_SIG).unwrap(); + assert!(verify(data, "main-2", &SELFTEST_SIG).is_err()); + assert!(verify(b"airbridge-update-selftesT", "main-1", &SELFTEST_SIG).is_err()); + assert!(verify(data, "main-1", &[0; 64]).is_err()); + } + + #[test] + fn picks_the_newest_signed_main_build() { + let release = |tag: &str, names: &[&str]| Release { + tag_name: tag.into(), + html_url: format!("https://example/{tag}"), + draft: false, + assets: names + .iter() + .map(|n| Asset { + name: n.to_string(), + browser_download_url: format!("https://example/{tag}/{n}"), + }) + .collect(), + }; + let signed = [ASSET, "airbridge-x86_64.AppImage.sig"]; + let releases = || { + vec![ + release("main-50", &[ASSET]), // unsigned: skipped + release("main-42", &signed), + release("v0.2.0", &signed), + release("main-40", &signed), + ] + }; + assert_eq!(newest(releases(), 41).unwrap().tag, "main-42"); + assert!(newest(releases(), 42).is_none()); + } +} diff --git a/linux/src/window.rs b/linux/src/window.rs index ef7c4f8..7969f20 100644 --- a/linux/src/window.rs +++ b/linux/src/window.rs @@ -12,11 +12,14 @@ use wry::{DragDropEvent, WebViewBuilder}; enum UserEvent { Drag(DragDropEvent), + /// The page asked to close (the service is restarting after an update). + Close, } pub fn run(url: &str) -> Result<()> { let event_loop = EventLoopBuilder::::with_user_event().build(); let proxy = event_loop.create_proxy(); + let close = event_loop.create_proxy(); let window = WindowBuilder::new() .with_title("AirBridge") .with_inner_size(LogicalSize::new(1120.0, 780.0)) @@ -25,6 +28,11 @@ pub fn run(url: &str) -> Result<()> { let builder = WebViewBuilder::new() .with_url(url) + .with_ipc_handler(move |request| { + if request.body() == "close" { + let _ = close.send_event(UserEvent::Close); + } + }) .with_drag_drop_handler(move |event| { // WebKit also reports dragged browser URLs as paths. Let the DOM // handle those with the original URL instead of sending a file path. @@ -55,7 +63,8 @@ pub fn run(url: &str) -> Result<()> { Event::WindowEvent { event: WindowEvent::CloseRequested, .. - } => *control_flow = ControlFlow::Exit, + } + | Event::UserEvent(UserEvent::Close) => *control_flow = ControlFlow::Exit, Event::UserEvent(UserEvent::Drag(event)) => { let script = match event { DragDropEvent::Drop { diff --git a/linux/ui/app.js b/linux/ui/app.js index 042d108..287fb03 100644 --- a/linux/ui/app.js +++ b/linux/ui/app.js @@ -64,6 +64,35 @@ async function api(path, { method, body } = {}) { return data; } +/* ---------------------------------------------------------------- updates */ +async function checkUpdate() { + try { + const { available, canInstall } = await api("/update"); + const btn = $("btnUpdate"); + btn.hidden = !available; + if (available) btn.title = `Build #${available.build} is ready` + (canInstall ? "" : " (opens the download page)"); + } catch (_) { /* offline: try again later */ } +} + +async function installUpdate() { + const btn = $("btnUpdate"); + btn.disabled = true; + btn.textContent = "Updating…"; + try { + const { restarting } = await api("/update", { body: {} }); + if (restarting) { + toast("Updated. Restarting AirBridge…"); + // The new version opens its own window. + setTimeout(() => window.ipc?.postMessage("close"), 300); + return; + } + } catch (err) { + toast(err.message); + } + btn.disabled = false; + btn.textContent = "Update"; +} + function applyTheme(theme) { if (!theme || theme === "auto") delete document.documentElement.dataset.theme; else document.documentElement.dataset.theme = theme; @@ -1003,6 +1032,9 @@ function init() { $("btnPair").addEventListener("click", openPairing); $("emptyPair").addEventListener("click", openPairing); $("btnSettings").addEventListener("click", openSettings); + $("btnUpdate").addEventListener("click", installUpdate); + checkUpdate(); + setInterval(checkUpdate, 6 * 60 * 60 * 1000); $("btnActivity").addEventListener("click", () => toggleActivity()); $("closeActivity").addEventListener("click", () => toggleActivity(false)); $("clearHistory").addEventListener("click", () => api("/history", { method: "DELETE" })); diff --git a/linux/ui/index.html b/linux/ui/index.html index 0f0a0c6..2d6071f 100644 --- a/linux/ui/index.html +++ b/linux/ui/index.html @@ -12,6 +12,7 @@
AirBridge
+