diff --git a/Cargo.toml b/Cargo.toml index d1c90f4..e6ae96c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -15,7 +15,8 @@ windows = { version = "0.58", features = [ "Win32_UI_Shell", "Win32_System_LibraryLoader", "Win32_System_Threading", - "Win32_Media" + "Win32_Media", + "Win32_Networking_WinHttp" ] } tiny-skia = "0.11" rand = "0.8" diff --git a/README.md b/README.md index 0e04501..e30bbb1 100644 --- a/README.md +++ b/README.md @@ -53,7 +53,7 @@ Settings are saved automatically to `%APPDATA%\Snowfall\settings.txt` and restor ## Privacy -Snowfall makes no network connections and collects no data. It only reads window positions and titles locally to find where snow can land. +Snowfall collects no data and makes no network connections on its own. It only reads window positions and titles locally to find where snow can land. The one exception is the **Check for updates** button in the settings window: when you press it, Snowfall sends a single request to the GitHub API (api.github.com) to read the version number of the latest release. Nothing else is sent. ## License diff --git a/src/main.rs b/src/main.rs index d3db4c3..9ae2c93 100644 --- a/src/main.rs +++ b/src/main.rs @@ -9,6 +9,7 @@ mod settings_ui; mod snow; mod tracker; mod tray; +mod update; use overlay::Overlay; use snow::{bgra, Snow}; diff --git a/src/settings_ui.rs b/src/settings_ui.rs index ae00795..46e49ef 100644 --- a/src/settings_ui.rs +++ b/src/settings_ui.rs @@ -49,8 +49,9 @@ const SWITCH_HEIGHT: i32 = 22; const FPS_TOP: i32 = 410; const BUTTON_TOP: i32 = 465; +const UPDATE_TOP: i32 = 515; const CLIENT_WIDTH: i32 = 340; -const CLIENT_HEIGHT: i32 = 520; +const CLIENT_HEIGHT: i32 = 570; #[derive(Clone, Copy, PartialEq)] enum SliderKind { @@ -338,6 +339,15 @@ fn clear_btn_rect() -> RECT { } } +fn update_btn_rect() -> RECT { + RECT { + left: 180, + top: UPDATE_TOP, + right: 320, + bottom: UPDATE_TOP + 34, + } +} + fn hit_test_slider(x: i32, y: i32) -> Option { if (MARGIN_X..=MARGIN_X + TRACK_WIDTH).contains(&x) { if (SLIDER1_TOP..SLIDER1_TOP + ROW_HEIGHT).contains(&y) { @@ -884,12 +894,98 @@ unsafe fn draw_content(hdc: windows::Win32::Graphics::Gdi::HDC, state: &AppState DT_CENTER | DT_VCENTER | DT_SINGLELINE, ); + // Update row + let hfont_small = CreateFontW( + 12, + 0, + 0, + 0, + FW_NORMAL.0 as i32, + 0, + 0, + 0, + DEFAULT_CHARSET.0 as u32, + OUT_DEFAULT_PRECIS.0 as u32, + CLIP_DEFAULT_PRECIS.0 as u32, + DEFAULT_QUALITY.0 as u32, + DEFAULT_PITCH.0 as u32, + windows::core::w!("Segoe UI"), + ); + + let mut ver_rc = RECT { + left: MARGIN_X, + top: UPDATE_TOP, + right: 170, + bottom: UPDATE_TOP + 17, + }; + let _ = SetTextColor(hdc, COLORREF(0x008A8482)); + SelectObject(hdc, hfont_normal); + let ver_str = format!("Snowfall v{}", env!("CARGO_PKG_VERSION")); + draw_text_str( + hdc, + &ver_str, + &mut ver_rc, + DT_LEFT | DT_VCENTER | DT_SINGLELINE, + ); + + let mut status_rc = RECT { + left: MARGIN_X, + top: UPDATE_TOP + 18, + right: 170, + bottom: UPDATE_TOP + 34, + }; + let update_state_val = state.update_state.load(Ordering::Relaxed); + let status_str = match update_state_val { + 1 => "Checking...".to_string(), + 2 => "You have the latest version".to_string(), + 3 => { + let tag = state + .update_tag + .lock() + .map(|l| l.clone()) + .unwrap_or_default(); + format!("Update available: {}", tag) + } + 4 => "Check failed".to_string(), + _ => "".to_string(), + }; + if !status_str.is_empty() { + SelectObject(hdc, hfont_small); + draw_text_str( + hdc, + &status_str, + &mut status_rc, + DT_LEFT | DT_VCENTER | DT_SINGLELINE, + ); + } + + let update_r = update_btn_rect(); + let u_brush = CreateSolidBrush(COLORREF(0x003A3D41)); + let mut u_sys = update_r; + FillRect(hdc, &u_sys, u_brush); + let _ = DeleteObject(HGDIOBJ(u_brush.0)); + let _ = SetTextColor(hdc, COLORREF(0x00FFFFFF)); + let update_btn_str = if update_state_val == 3 { + "Download update" + } else { + "Check for updates" + }; + SelectObject(hdc, hfont_normal); + draw_text_str( + hdc, + update_btn_str, + &mut u_sys, + DT_CENTER | DT_VCENTER | DT_SINGLELINE, + ); + + let _ = DeleteObject(HGDIOBJ(hfont_small.0)); + SelectObject(hdc, old_font); let _ = DeleteObject(HGDIOBJ(hfont_normal.0)); let _ = DeleteObject(HGDIOBJ(hfont_bold.0)); } -fn handle_click(state: &AppState, x: i32, y: i32) -> bool { +fn handle_click(state: &Arc, x: i32, y: i32) -> bool { // Check accumulate tiles let t0_l = MARGIN_X; let t0_r = t0_l + TILE_WIDTH; @@ -954,5 +1050,56 @@ fn handle_click(state: &AppState, x: i32, y: i32) -> bool { return true; } + // Check update button + let ur = update_btn_rect(); + if x >= ur.left && x <= ur.right && y >= ur.top && y <= ur.bottom { + let update_state = state.update_state.load(Ordering::Relaxed); + if update_state == 3 { + unsafe { + let _ = windows::Win32::UI::Shell::ShellExecuteW( + HWND(std::ptr::null_mut()), + windows::core::w!("open"), + windows::core::w!("https://github.com/Tomjerri1/Snowfall/releases/latest"), + windows::core::PCWSTR::null(), + windows::core::PCWSTR::null(), + windows::Win32::UI::WindowsAndMessaging::SW_SHOW, + ); + } + } else if update_state != 1 { + state.update_state.store(1, Ordering::Release); + let state_clone = state.clone(); + std::thread::spawn(move || { + match crate::update::fetch_latest_tag() { + Ok(tag) => { + if crate::update::parse_version(&tag).is_none() { + state_clone.update_state.store(4, Ordering::Release); + } else { + let newer = crate::update::is_newer(env!("CARGO_PKG_VERSION"), &tag); + if newer { + if let Ok(mut lock) = state_clone.update_tag.lock() { + *lock = tag; + } + state_clone.update_state.store(3, Ordering::Release); + } else { + state_clone.update_state.store(2, Ordering::Release); + } + } + } + Err(_) => { + state_clone.update_state.store(4, Ordering::Release); + } + } + let hwnd_val = state_clone.settings_hwnd.load(Ordering::Acquire); + if hwnd_val != 0 { + let hwnd = HWND(hwnd_val as *mut std::ffi::c_void); + unsafe { + let _ = InvalidateRect(hwnd, None, false); + } + } + }); + } + return true; + } + false } diff --git a/src/tray.rs b/src/tray.rs index 459bb14..7b155bd 100644 --- a/src/tray.rs +++ b/src/tray.rs @@ -40,6 +40,8 @@ pub struct AppState { pub acc_dock: AtomicBool, pub acc_ground: AtomicBool, pub mouse_flakes: AtomicBool, + pub update_state: AtomicUsize, + pub update_tag: std::sync::Mutex, } impl AppState { @@ -59,6 +61,8 @@ impl AppState { acc_dock: AtomicBool::new(true), acc_ground: AtomicBool::new(false), mouse_flakes: AtomicBool::new(true), + update_state: AtomicUsize::new(0), + update_tag: std::sync::Mutex::new(String::new()), } } } diff --git a/src/update.rs b/src/update.rs new file mode 100644 index 0000000..c18ef3e --- /dev/null +++ b/src/update.rs @@ -0,0 +1,271 @@ +use windows::core::PCWSTR; +use windows::Win32::Networking::WinHttp::{ + WinHttpAddRequestHeaders, WinHttpCloseHandle, WinHttpConnect, WinHttpOpen, WinHttpOpenRequest, + WinHttpQueryHeaders, WinHttpReadData, WinHttpReceiveResponse, WinHttpSendRequest, + WinHttpSetTimeouts, WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY, WINHTTP_ADDREQ_FLAG_ADD, + WINHTTP_ADDREQ_FLAG_REPLACE, WINHTTP_FLAG_SECURE, WINHTTP_QUERY_FLAG_NUMBER, + WINHTTP_QUERY_STATUS_CODE, +}; + +pub fn parse_version(s: &str) -> Option<(u64, u64, u64, bool)> { + let s = s.trim(); + let s = if let Some(stripped) = s.strip_prefix('v').or_else(|| s.strip_prefix('V')) { + stripped + } else { + s + }; + let s = s.split('+').next().unwrap_or(s); + + let (version_part, is_prerelease) = if let Some(idx) = s.find('-') { + let v = &s[..idx]; + let suf = &s[idx + 1..]; + if suf.is_empty() { + return None; + } + (v, true) + } else { + (s, false) + }; + + if version_part.contains(' ') { + return None; + } + + let parts: Vec<&str> = version_part.split('.').collect(); + if parts.len() != 3 { + return None; + } + + for part in &parts { + if part.is_empty() { + return None; + } + if part.starts_with('0') && part.len() > 1 { + return None; + } + if !part.chars().all(|c| c.is_ascii_digit()) { + return None; + } + } + + let major = parts[0].parse::().ok()?; + let minor = parts[1].parse::().ok()?; + let patch = parts[2].parse::().ok()?; + + Some((major, minor, patch, is_prerelease)) +} + +pub fn is_newer(current: &str, latest: &str) -> bool { + let (curr_maj, curr_min, curr_pat, curr_pre) = match parse_version(current) { + Some(v) => v, + None => return false, + }; + let (latest_maj, latest_min, latest_pat, latest_pre) = match parse_version(latest) { + Some(v) => v, + None => return false, + }; + + if latest_maj != curr_maj { + return latest_maj > curr_maj; + } + if latest_min != curr_min { + return latest_min > curr_min; + } + if latest_pat != curr_pat { + return latest_pat > curr_pat; + } + + curr_pre && !latest_pre +} + +pub fn extract_tag_name(json: &str) -> Option { + let key = "\"tag_name\""; + let mut search_idx = 0; + while let Some(pos) = json[search_idx..].find(key) { + let mut idx = search_idx + pos + key.len(); + while idx < json.len() && json.as_bytes()[idx].is_ascii_whitespace() { + idx += 1; + } + if idx < json.len() && json.as_bytes()[idx] == b':' { + idx += 1; + while idx < json.len() && json.as_bytes()[idx].is_ascii_whitespace() { + idx += 1; + } + if idx < json.len() && json.as_bytes()[idx] == b'"' { + idx += 1; + let mut escaped = false; + let mut val = String::new(); + while idx < json.len() { + let b = json.as_bytes()[idx]; + if escaped { + val.push(b as char); + escaped = false; + } else if b == b'\\' { + escaped = true; + } else if b == b'"' { + return Some(val); + } else { + val.push(b as char); + } + idx += 1; + } + } + } + search_idx += pos + key.len(); + } + None +} + +pub fn fetch_latest_tag() -> Result { + unsafe { fetch_latest_tag_impl() } +} + +unsafe fn fetch_latest_tag_impl() -> Result { + let h_session = WinHttpOpen( + windows::core::w!("Snowfall-update-check"), + WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY, + PCWSTR::null(), + PCWSTR::null(), + 0, + ); + if h_session.is_null() { + return Err("WinHttpOpen failed".to_string()); + } + + let mut h_connect = std::ptr::null_mut(); + let mut h_request = std::ptr::null_mut(); + + let body_res = (|| -> Result { + h_connect = WinHttpConnect(h_session, windows::core::w!("api.github.com"), 443, 0); + if h_connect.is_null() { + return Err("WinHttpConnect failed".to_string()); + } + + h_request = WinHttpOpenRequest( + h_connect, + windows::core::w!("GET"), + windows::core::w!("/repos/Tomjerri1/Snowfall/releases/latest"), + PCWSTR::null(), + PCWSTR::null(), + std::ptr::null(), + WINHTTP_FLAG_SECURE, + ); + if h_request.is_null() { + return Err("WinHttpOpenRequest failed".to_string()); + } + + let headers = + encode_wide("Accept: application/vnd.github+json\r\nUser-Agent: Snowfall-update-check"); + WinHttpAddRequestHeaders( + h_request, + &headers, + WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE, + ) + .map_err(|e| format!("WinHttpAddRequestHeaders failed: {}", e))?; + + let _ = WinHttpSetTimeouts(h_session, 5000, 5000, 5000, 5000); + + WinHttpSendRequest(h_request, None, None, 0, 0, 0) + .map_err(|e| format!("WinHttpSendRequest failed: {}", e))?; + + WinHttpReceiveResponse(h_request, std::ptr::null_mut()) + .map_err(|e| format!("WinHttpReceiveResponse failed: {}", e))?; + + let mut status_code: u32 = 0; + let mut status_size = std::mem::size_of::() as u32; + let mut index = 0; + WinHttpQueryHeaders( + h_request, + WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, + windows::core::PCWSTR::null(), + Some(&mut status_code as *mut u32 as *mut std::ffi::c_void), + &mut status_size, + &mut index, + ) + .map_err(|e| format!("WinHttpQueryHeaders failed: {}", e))?; + + if status_code != 200 { + return Err(format!("HTTP status: {}", status_code)); + } + + let mut body_bytes = Vec::new(); + let mut buffer = [0u8; 65536]; + loop { + let mut bytes_read = 0u32; + WinHttpReadData( + h_request, + buffer.as_mut_ptr() as *mut std::ffi::c_void, + buffer.len() as u32, + &mut bytes_read, + ) + .map_err(|e| format!("WinHttpReadData failed: {}", e))?; + + if bytes_read == 0 { + break; + } + body_bytes.extend_from_slice(&buffer[..bytes_read as usize]); + } + + let body = String::from_utf8_lossy(&body_bytes).to_string(); + extract_tag_name(&body).ok_or_else(|| "tag not found".to_string()) + })(); + + if !h_request.is_null() { + let _ = WinHttpCloseHandle(h_request); + } + if !h_connect.is_null() { + let _ = WinHttpCloseHandle(h_connect); + } + if !h_session.is_null() { + let _ = WinHttpCloseHandle(h_session); + } + + body_res +} + +fn encode_wide(s: &str) -> Vec { + s.encode_utf16().chain(std::iter::once(0)).collect() +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_parse_version() { + let v1 = parse_version("v0.1.2"); + assert!(v1 == Some((0, 1, 2, false))); + + let v2 = parse_version("0.1.2-beta.1"); + assert!(v2 == Some((0, 1, 2, true))); + + let v3 = parse_version("abc"); + assert!(v3.is_none()); + } + + #[test] + fn test_is_newer() { + assert!(is_newer("0.1.1", "v0.1.2")); + assert!(!is_newer("0.1.2", "0.1.2")); + assert!(is_newer("0.1.2-beta.1", "0.1.2")); + assert!(!is_newer("0.1.3", "0.1.2")); + assert!(is_newer("0.1.9", "0.1.10")); + } + + #[test] + fn test_extract_tag_name() { + let json1 = r#"{"url":"x","tag_name": "v0.1.2","name":"n"}"#; + assert!(extract_tag_name(json1) == Some("v0.1.2".to_string())); + + let json2 = "{}"; + assert!(extract_tag_name(json2).is_none()); + } + + #[test] + fn test_build_metadata_and_bad_tags() { + assert!(parse_version("v0.1.2+build.1") == Some((0, 1, 2, false))); + assert!(parse_version("0.1.2-pr.1+build-5") == Some((0, 1, 2, true))); + assert!(parse_version("release-0.1.2").is_none()); + assert!(is_newer("0.1.1", "v0.1.2+build.1")); + } +}