0.12.0

This reverts commit 890ae36590.

.github/workflows/release-on-tag.yml

@@ -1,31 +0,0 @@
-name: Create release for pushed tag
-
-on:
-  push:
-    tags:
-      - "*"
-
-jobs:
-  release-on-tag:
-    runs-on: windows-latest
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@stable
-      - name: Create release
-        shell: bash
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAG: ${{ github.ref_name }}
-        run: |
-          if gh release view "$TAG" >/dev/null 2>&1; then
-            echo "A release already exists for $TAG, skipping"
-          else
-            cargo build --release
-            prev_tag=$(gh release list --limit 100 --json tagName --jq '.[0].tagName')
-            notes="**Full Changelog**: https://github.com/${{ github.repository }}/compare/${prev_tag}...${TAG}"
-            gh release create "$TAG" target/release/gta-tools.exe \
-              --title "$TAG" \
-              --notes "$notes"
-          fi

.github/workflows/release-retroactively.yml

@@ -1,43 +0,0 @@
-name: Create releases for existing tags
-
-on:
-  workflow_dispatch:
-
-jobs:
-  release-retroactively:
-    runs-on: windows-latest
-    permissions:
-      contents: write
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-      - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
-      - name: Get tags and create release for each
-        shell: bash
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          mapfile -t tags < <(git tag -l)
-          echo "${#tags[@]} tags found."
-          prev_tag=""
-          for tag in "${tags[@]}"; do
-            if gh release view "$tag" >/dev/null 2>&1; then
-              echo "A release already exists for $tag, skipping"
-            else
-              echo "Proceeding with tag $tag"
-              git checkout "$tag"
-              cargo build --release
-              if [ -n "$prev_tag" ]; then
-                notes="**Full Changelog**: https://github.com/${{ github.repository }}/compare/${prev_tag}...${tag}"
-              else
-                notes="**Full Changelog**: https://github.com/${{ github.repository }}/commits/${tag}"
-              fi
-              gh release create "$tag" target/release/gta-tools.exe \
-                --title "$tag" \
-                --notes "$notes"
-            fi
-            prev_tag="$tag"
-          done

Cargo.toml

@@ -1,42 +1,38 @@
 [package]
 name = "gta-tools"
-version = "0.10.0"
+version = "0.12.0"
 edition = "2024"
 license = "Apache-2.0"
 authors = ["futile <git@futile.eu>"]
 description = "A toolset of convenient things for GTA V Online."
 
 [dependencies]
-catppuccin-egui = { version = "5.6.0", default-features = false, features = [
+anyhow = "1.0"
-    "egui32",
+eframe = { version = "0.35", default-features = false, features = [
-] }
-eframe = { version = "0.32.2", default-features = false, features = [
     "glow",
     "default_fonts",
 ] }
-egui_extras = { version = "0.32.2", default-features = false, features = [
+egui_extras = { version = "0.35", default-features = false, features = [
     "image",
     "svg",
 ] }
 humantime = "2.3.0"
-image = { version = "0.25.8", default-features = false, features = ["png"] }
+image = { version = "0.25", default-features = false, features = ["png"] }
-log = "0.4.28"
+log = "0.4"
-open = "5.3.2"
+open = "5"
-serde = { version = "1.0.219", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0.143"
+serde_json = "1.0"
-strum = { version = "0.27.2", features = ["derive"] }
+strum = { version = "0.28", features = ["derive"] }
-windows = { version = "0.62.0", features = [
+windows = { version = "0.62", features = [
     "Win32_NetworkManagement_WindowsFirewall",
-    "Win32_Security",
     "Win32_System_Com",
     "Win32_System_Diagnostics_ToolHelp",
     "Win32_System_Threading",
     "Win32_UI_Input_KeyboardAndMouse",
-    "Win32_UI_Shell",
     "Win32_UI_WindowsAndMessaging",
 ] }
-winreg = "0.55.0"
+winreg = "0.56"
 
 [build-dependencies]
-static_vcruntime = "2.0.0"
+static_vcruntime = "3.0.0"
-tauri-winres = "0.3.3"
+tauri-winres = "0.3"

README.md

@@ -2,10 +2,11 @@
 
 A toolset of convenient things for GTA V Online.
 
-<picture>
+![](https://i.vgy.me/HVBklM.png)
-    <source srcset="https://i.vgy.me/M4sOHh.png" media="(prefers-color-scheme: dark)">
+![](https://i.vgy.me/yzRGjG.png)
-    <img src="https://i.vgy.me/mpO9uc.png">
+
-</picture>
+> [!NOTE]
+> I have been forced to move this project from [GitHub](https://github.com/elituf/gta-tools) to [here](https://gitlab.com/futile/gta-tools). Sorry for the inconvenience. From now on you may always find the project source code via the redirect at [futile.eu/gta-tools](https://futile.eu/gta-tools).
 
 ## Installing
 
@@ -13,13 +14,13 @@ A toolset of convenient things for GTA V Online.
 Download the latest release [here](https://github.com/elituf/gta-tools/releases/latest/download/gta-tools.exe) and place it somewhere convenient for you, such as Documents. You could then make a shortcut titled "GTA Tools", and pin it to taskbar or Start.
 
 **Option 2** — <ins>Build from source</ins>  
-You will need the Rust toolchain, which can be obtained [here](https://rustup.rs). Follow the instructions of its installer. Once you have Rust installed, clone this repo and navigate to it. At this point, you should probably `git checkout x.x.x`, where `x.x.x` is the latest tag. You can then run `cargo build --release`. Once you do that, you can use the binary located at `.\target\release\gta-tools.exe` in the same way as **Option 1**.
+You will need Rust, which you can get [here](https://rustup.rs). Then, clone this repo and navigate to it. At this point, you should probably `git checkout x.x.x`, where `x.x.x` is the latest tag. You can then run `cargo build --release`. Once you do that, you can use the binary located at `.\target\release\gta-tools.exe` in the same way as **Option 1**.
+
+It is recommended to always use an up-to-date version of GTA Tools from [releases](https://github.com/elituf/gta-tools/releases). You can also easily access this repository by going to the <kbd>About</kbd> page of GTA Tools and clicking the GitHub button beside the version number.
 
 ## Guide
 
-Every feature of GTA Tools is Legacy/Enhanced-agnostic. Some functionality of GTA Tools requires administrator access. If necessary, GTA Tools can either be started as admin manually, or, the user can simply use the <kbd>Elevate</kbd> button to relaunch GTA Tools as admin.
+Every feature of GTA Tools is Legacy/Enhanced-agnostic. GTA Tools requires administrator access.
-
-It is recommended to always use an up-to-date version of GTA Tools from [releases](https://github.com/elituf/gta-tools/releases). You can also easily access this repository by going to the <kbd>About</kbd> page of GTA Tools and clicking the GitHub button beside the version number.
 
 #### Game
 
@@ -33,7 +34,7 @@ There is also a <kbd>Force close game</kbd> feature, which simply kills all game
 
 This section also has two features.
 
-The first being <kbd>Empty current session</kbd>, which "removes everyone" from your session by suspending your game for 10 seconds, and then resuming it. This method is exceedingly similar to the Resource Monitor method, but made convenient in one button. This can be useful in numerous ways:
+The first being <kbd>Empty current session</kbd>, which "removes everyone" from your session by blocking the game's network access for 10 seconds, then unblocking it. This can be useful in numerous ways:
 * You are stuck loading into a session
 * You are stuck loading into an interior
 * You are about to get griefed while doing a freemode mission
@@ -46,10 +47,7 @@ The other feature is <kbd>Anti AFK</kbd>, which, when toggled, prevents you from
 
 #### Network
 
-The last section has a single feature, <kbd>Game's network access</kbd>, with two buttons, <kbd>Block</kbd> and <kbd>Unblock</kbd>, and a coloured indicator dot. This feature requires administrator, and blocks/unblocks GTA V's entire internet access using the Windows Firewall. The coloured indicator dot has these meanings:
+The last section has a single feature, <kbd>Game's network access</kbd>, with two buttons, <kbd>Block</kbd> and <kbd>Unblock</kbd>, and a coloured indicator dot (**green** - normal, **red** - blocked). This feature blocks/unblocks GTA V's entire internet access using the Windows Firewall.
-* **Green** - the game is connected to the internet
-* **Yellow** - the game could not be found running, and thus was not blocked
-* **Red** - the game is blocked from the internet
 
 This feature is primarily useful for **replay glitching**, which is an exploit that allows you to complete any heist/mission finale, get the money for it, and then be able to do it again right away. Here's how you can do a replay glitch:
 1. Get to the finale of a heist/contract/mission series, such as **The Contract: Dr. Dre**
@@ -59,9 +57,15 @@ This feature is primarily useful for **replay glitching**, which is an exploit t
 5. At this point, <kbd>Unblock</kbd> the game's internet access and load back into online
 6. Finally, spend any amount of money, and you should receive the finale cut, but also be able to go play the finale again immediately
 
-## Issues
+This feature can also be changed to <kbd>Rockstar save server access</kbd> via the **Network** dropdown of the settings. When in this mode, instead of blocking the entire game's network, it will only block the Rockstar save server at the IP `192.81.241.171`. The IP can also be changed in the same settings, if ever needed.
 
-- I have noticed that on my current Windows 10 install, when not elevated (administrator), the <kbd>Force close game</kbd> and <kbd>Empty current session</kbd> features can fail due to being denied access. This was tested by other people and is not guaranteed to happen. If this does happen to you, I recommend using GTA Tools always in elevated mode. Check "Always start elevated" in the Settings tab.
+Here's how you can do a replay glitch using this alternative method:
+1. Get to the finale of a heist/contract/mission series, such as **The Contract: Dr. Dre**
+2. At any point before you complete the finale, <kbd>Block</kbd> the save server access (for example, at the beginning of the mission)
+3. Complete the finale as normal
+4. After loading into online, exit to story mode
+5. At this point, <kbd>Unblock</kbd> the save server access and load back into online
+6. Finally, force a save by changing your outfit, and you should receive the finale cut, but also be able to go play the finale again immediately
 
 
 

assets/circle.svg

@@ -1,23 +1 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg width="512" height="512" viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg"><circle style="fill:#fff" cx="256" cy="256" r="256"/></svg>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   width="512"
-   height="512"
-   viewBox="0 0 512 512"
-   version="1.1"
-   id="svg1"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg">
-  <defs
-     id="defs1" />
-  <g
-     id="layer1">
-    <circle
-       style="fill:#ffffff"
-       id="path1"
-       cx="256"
-       cy="256"
-       r="256" />
-  </g>
-</svg>

build.rs

@@ -6,6 +6,17 @@ fn main() {
         .set("LegalCopyright", "futile <git@futile.eu>")
         .set_language(0x0009)
         .set_icon("assets/icon.ico")
+        .set_manifest(
+            r#"<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+          <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+            <security>
+              <requestedPrivileges>
+                <requestedExecutionLevel level="requireAdministrator" uiAccess="false"/>
+              </requestedPrivileges>
+            </security>
+          </trustInfo>
+        </assembly>"#,
+        )
         .compile()
         .unwrap();
     embed_latest_git_hash();

src/features/empty_session.rs

@@ -1,13 +1,14 @@
 use crate::util::{
-    consts::game::{EXE_ENHANCED, EXE_LEGACY},
     countdown::Countdown,
+    firewall::{Firewall, RuleDirection, RuleMode, RuleProtocol},
     system_info::SystemInfo,
 };
+use anyhow::Result;
 use std::time::{Duration, Instant};
-use windows::Win32::{
+
-    Foundation::{HANDLE, NTSTATUS},
+const FILTER_NAME_EMPTY_SESSION_IN: &str = "[GTA Tools] Block inbound UDP traffic for all of GTA V";
-    System::Threading::{OpenProcess, PROCESS_SUSPEND_RESUME},
+const FILTER_NAME_EMPTY_SESSION_OUT: &str =
-};
+    "[GTA Tools] Block outbound UDP traffic for all of GTA V";
 
 const INTERVAL: Duration = Duration::from_secs(10);
 
@@ -29,52 +30,42 @@ impl Default for EmptySession {
 }
 
 impl EmptySession {
-    pub fn run_timers(&mut self, game_handle: &mut HANDLE) {
+    pub fn run_timers(&mut self, firewall: &Firewall) -> Result<()> {
         if self.disabled {
             self.countdown.count();
         } else {
             self.countdown.reset();
         }
         if self.interval.elapsed() >= INTERVAL {
-            deactivate(game_handle);
+            deactivate(firewall)?;
             self.disabled = false;
         }
+        Ok(())
     }
 }
 
-#[link(name = "ntdll")]
+pub fn activate(system_info: &mut SystemInfo, firewall: &Firewall) -> Result<bool> {
-unsafe extern "system" {
+    let Some(exe_path) = system_info.get_game_exe_path() else {
-    unsafe fn NtSuspendProcess(ProcessHandle: HANDLE) -> NTSTATUS;
+        log::info!("wasn't able to find game exe");
-    unsafe fn NtResumeProcess(ProcessHandle: HANDLE) -> NTSTATUS;
+        return Ok(false);
-}
-
-fn get_gta_pid(system_info: &mut SystemInfo) -> Option<u32> {
-    system_info.refresh();
-    system_info
-        .processes()
-        .iter()
-        .find(|p| p.name() == EXE_ENHANCED || p.name() == EXE_LEGACY)
-        .map(|p| p.pid())
-}
-
-pub fn activate(game_handle: &mut HANDLE, system_info: &mut SystemInfo) -> bool {
-    let Some(pid) = get_gta_pid(system_info) else {
-        return false;
     };
-    match unsafe { OpenProcess(PROCESS_SUSPEND_RESUME, false, pid) } {
+    firewall.add(
-        Ok(handle) => *game_handle = handle,
+        FILTER_NAME_EMPTY_SESSION_IN,
-        Err(why) => {
+        RuleMode::Executable(exe_path.to_path_buf()),
-            log::error!("failed to suspend game for empty session:\n{why}");
+        RuleDirection::In,
-            return false;
+        RuleProtocol::Udp,
-        }
+    )?;
-    }
+    firewall.add(
-    unsafe { NtSuspendProcess(*game_handle) }.unwrap();
+        FILTER_NAME_EMPTY_SESSION_OUT,
-    true
+        RuleMode::Executable(exe_path.to_path_buf()),
+        RuleDirection::Out,
+        RuleProtocol::Udp,
+    )?;
+    Ok(true)
 }
 
-pub fn deactivate(game_handle: &mut HANDLE) {
+pub fn deactivate(firewall: &Firewall) -> Result<()> {
-    if !game_handle.is_invalid() {
+    firewall.remove(FILTER_NAME_EMPTY_SESSION_IN)?;
-        // ignoring the return because this function behaves very weirdly
+    firewall.remove(FILTER_NAME_EMPTY_SESSION_OUT)?;
-        let _ = unsafe { NtResumeProcess(*game_handle) };
+    Ok(())
-    }
 }

src/features/game_networking.rs

@@ -1,141 +1,100 @@
-use crate::util::{
+use crate::{
-    consts::game::{EXE_ENHANCED, EXE_LEGACY},
+    gui::settings::BlockMethod,
+    util::{
+        firewall::{Firewall, RuleDirection, RuleMode, RuleProtocol},
         system_info::SystemInfo,
+    },
 };
-use std::{
+use anyhow::Result;
-    path::Path,
-    time::{Duration, Instant},
-};
 use strum::{Display, EnumIter};
-use windows::{
-    Win32::{
-        NetworkManagement::WindowsFirewall::{
-            INetFwPolicy2, INetFwRule, NET_FW_ACTION_BLOCK, NET_FW_IP_PROTOCOL_ANY,
-            NET_FW_RULE_DIR_IN, NET_FW_RULE_DIR_OUT, NetFwPolicy2, NetFwRule,
-        },
-        System::Com::{
-            CLSCTX_INPROC_SERVER, COINIT_MULTITHREADED, CoCreateInstance, CoInitializeEx,
-            CoUninitialize,
-        },
-    },
-    core::BSTR,
-};
 
-const FILTER_NAME_IN: &str = "[GTA Tools] Block all inbound traffic for GTA V";
+const FILTER_NAME_EXE: &str = "[GTA Tools] Block outbound traffic for all of GTA V";
-const FILTER_NAME_OUT: &str = "[GTA Tools] Block all outbound traffic for GTA V";
+const FILTER_NAME_SAVE_SERVER: &str = "[GTA Tools] Block outbound traffic to Rockstar save server";
 
-const INTERVAL: Duration = Duration::from_secs(3);
+#[derive(Clone, Copy, Debug, Default, Display, EnumIter, PartialEq)]
-
-#[derive(Clone, Copy, Debug, Display, PartialEq, Eq, EnumIter)]
 pub enum BlockedStatus {
-    Blocked,
+    #[default]
-    Failed,
     Unblocked,
-}
+    Server,
-
+    Executable,
-impl From<bool> for BlockedStatus {
-    fn from(value: bool) -> Self {
-        if value {
-            Self::Blocked
-        } else {
-            Self::Unblocked
-        }
-    }
 }
 
 #[derive(Debug)]
 pub struct GameNetworking {
-    com_initialized: bool,
+    pub blocked: BlockedStatus,
-    pub blocked_status: BlockedStatus,
-    timer: Instant,
-    counting: bool,
 }
 
 impl Default for GameNetworking {
     fn default() -> Self {
+        let firewall = Firewall::default();
         Self {
-            blocked_status: Self::is_blocked().into(),
+            blocked: if firewall.is_blocked(FILTER_NAME_SAVE_SERVER).unwrap() {
-            com_initialized: unsafe { CoInitializeEx(None, COINIT_MULTITHREADED) }.is_ok(),
+                BlockedStatus::Server
-            timer: Instant::now(),
+            } else if firewall.is_blocked(FILTER_NAME_EXE).unwrap() {
-            counting: false,
+                BlockedStatus::Executable
-        }
+            } else {
-    }
+                BlockedStatus::Unblocked
-}
+            },
-
-impl Drop for GameNetworking {
-    fn drop(&mut self) {
-        if self.com_initialized {
-            unsafe { CoUninitialize() };
         }
     }
 }
 
 impl GameNetworking {
-    pub fn block_all(&mut self, system_info: &mut SystemInfo) {
+    pub fn block_exe(&mut self, system_info: &mut SystemInfo, firewall: &Firewall) -> Result<()> {
-        let Some(exe_path) = get_game_exe_path(system_info) else {
+        let Some(exe_path) = system_info.get_game_exe_path() else {
-            self.blocked_status = BlockedStatus::Failed;
+            log::warn!("Unable to find game executable path.");
-            return;
+            return Ok(());
         };
-        let policy: INetFwPolicy2 =
+        firewall
-            unsafe { CoCreateInstance(&NetFwPolicy2, None, CLSCTX_INPROC_SERVER) }.unwrap();
+            .add(
-        let rules = unsafe { policy.Rules() }.unwrap();
+                FILTER_NAME_EXE,
-        let exe_path = BSTR::from(exe_path.to_string_lossy().to_string());
+                RuleMode::Executable(exe_path.to_path_buf()),
-        for filter in [
+                RuleDirection::Out,
-            (FILTER_NAME_IN, NET_FW_RULE_DIR_IN),
+                RuleProtocol::Any,
-            (FILTER_NAME_OUT, NET_FW_RULE_DIR_OUT),
+            )
-        ] {
+            .inspect(|_| self.blocked = BlockedStatus::Executable)
-            unsafe { rules.Remove(&BSTR::from(filter.0)) }.unwrap();
-            let rule: INetFwRule =
-                unsafe { CoCreateInstance(&NetFwRule, None, CLSCTX_INPROC_SERVER) }.unwrap();
-            unsafe { rule.SetName(&BSTR::from(filter.0)) }.unwrap();
-            unsafe { rule.SetApplicationName(&exe_path) }.unwrap();
-            unsafe { rule.SetDirection(filter.1) }.unwrap();
-            unsafe { rule.SetEnabled(true.into()) }.unwrap();
-            unsafe { rule.SetAction(NET_FW_ACTION_BLOCK) }.unwrap();
-            unsafe { rule.SetProtocol(NET_FW_IP_PROTOCOL_ANY.0) }.unwrap();
-            unsafe { rules.Add(&rule) }.unwrap();
-        }
-        self.blocked_status = Self::is_blocked().into();
     }
 
-    pub fn unblock_all(&mut self) {
+    pub fn unblock_exe(&mut self, firewall: &Firewall) -> Result<()> {
-        let policy: INetFwPolicy2 =
+        firewall
-            unsafe { CoCreateInstance(&NetFwPolicy2, None, CLSCTX_INPROC_SERVER) }.unwrap();
+            .remove(FILTER_NAME_EXE)
-        let rules = unsafe { policy.Rules() }.unwrap();
+            .inspect(|_| self.blocked = BlockedStatus::Unblocked)
-        unsafe { rules.Remove(&BSTR::from(FILTER_NAME_IN)) }.unwrap();
-        unsafe { rules.Remove(&BSTR::from(FILTER_NAME_OUT)) }.unwrap();
-        self.blocked_status = Self::is_blocked().into();
     }
 
-    fn is_blocked() -> bool {
+    pub fn block_save_server(&mut self, save_server_ip: &str, firewall: &Firewall) -> Result<()> {
-        let policy: INetFwPolicy2 =
+        firewall
-            unsafe { CoCreateInstance(&NetFwPolicy2, None, CLSCTX_INPROC_SERVER) }.unwrap();
+            .add(
-        let rules = unsafe { policy.Rules() }.unwrap();
+                FILTER_NAME_SAVE_SERVER,
-        let in_rule_exists = unsafe { rules.Item(&BSTR::from(FILTER_NAME_IN)) }.is_ok();
+                RuleMode::Address(save_server_ip.to_owned()),
-        let out_rule_exists = unsafe { rules.Item(&BSTR::from(FILTER_NAME_OUT)) }.is_ok();
+                RuleDirection::Out,
-        in_rule_exists || out_rule_exists
+                RuleProtocol::Any,
+            )
+            .inspect(|_| self.blocked = BlockedStatus::Server)
     }
 
-    pub fn if_failed_return_to_boolean(&mut self) {
+    pub fn unblock_save_server(&mut self, firewall: &Firewall) -> Result<()> {
-        if self.blocked_status == BlockedStatus::Failed && !self.counting {
+        firewall
-            self.counting = true;
+            .remove(FILTER_NAME_SAVE_SERVER)
-            self.timer = Instant::now();
+            .inspect(|_| self.blocked = BlockedStatus::Unblocked)
-        }
-        if self.blocked_status == BlockedStatus::Failed
-            && self.counting
-            && self.timer.elapsed() >= INTERVAL
-        {
-            self.counting = false;
-            self.blocked_status = Self::is_blocked().into();
-        }
-    }
     }
 
-fn get_game_exe_path(system_info: &mut SystemInfo) -> Option<&Path> {
+    pub fn ensure_block_exclusivity(
-    system_info.refresh();
+        &mut self,
-    system_info
+        block_method: BlockMethod,
-        .processes()
+        firewall: &Firewall,
-        .iter()
+    ) -> Result<()> {
-        .find(|p| p.name() == EXE_ENHANCED || p.name() == EXE_LEGACY)
+        match block_method {
-        .and_then(|p| p.exe())
+            BlockMethod::EntireGame => {
+                if self.blocked == BlockedStatus::Server {
+                    self.unblock_save_server(firewall)?;
+                }
+            }
+            BlockMethod::SaveServer => {
+                if self.blocked == BlockedStatus::Executable {
+                    self.unblock_exe(firewall)?;
+                }
+            }
+        }
+        Ok(())
+    }
 }

src/features/launch.rs

@@ -34,18 +34,19 @@ pub fn launch(platform: &Platform, version: &LaunchVersion) {
                 LaunchVersion::Enhanced => r"SOFTWARE\WOW6432Node\Rockstar Games\GTAV Enhanced",
                 LaunchVersion::Legacy => r"SOFTWARE\WOW6432Node\Rockstar Games\Grand Theft Auto V",
             };
-            let Ok(gta_v_enhanced) = hklm.open_subkey(rockstar_url) else {
+            let Ok(gta_key) = hklm.open_subkey(rockstar_url) else {
                 return;
             };
             let Ok(install_folder): Result<String, std::io::Error> =
-                gta_v_enhanced.get_value("InstallFolder")
+                gta_key.get_value("InstallFolder")
             else {
                 return;
             };
-            let mut play_gtav_path = PathBuf::from(install_folder);
+            let mut exe_path = PathBuf::from(install_folder);
-            play_gtav_path.push("PlayGTAV.exe");
+            exe_path.push("PlayGTAV.exe");
-            // ignoring the return because if it errors that means GTA isn't installed via Rockstar
+            if let Err(why) = Command::new(exe_path).spawn() {
-            let _ = Command::new(play_gtav_path).spawn();
+                log::warn!("Couldn't launch GTA 5 via Rockstar Games Launcher: {why}");
+            }
         }
         Platform::Epic => {
             let epic_url = match version {

src/gui/app.rs

@@ -1,8 +1,13 @@
 use crate::{
-    features,
+    features::{self, game_networking::BlockedStatus},
-    gui::{settings::Settings, tools, ui_ext::UiExt},
+    gui::{
+        settings::{BlockMethod, ROCKSTAR_SAVE_SERVER, Settings},
+        tools,
+        ui_ext::UiExt,
+    },
     util::{
-        consts::{colours, game::WINDOW_TITLE},
+        consts::{colours, game::WINDOW_TITLE, path},
+        firewall::Firewall,
         persistent_state::PersistentState,
         system_info::SystemInfo,
         win,
@@ -24,7 +29,6 @@ enum Stage {
 
 #[derive(Debug)]
 pub struct Flags {
-    pub elevated: bool,
     pub debug: bool,
     closing: bool,
 }
@@ -32,7 +36,6 @@ pub struct Flags {
 impl Default for Flags {
     fn default() -> Self {
         Self {
-            elevated: win::is_elevated(),
             debug: false,
             closing: false,
         }
@@ -45,7 +48,7 @@ pub struct App {
     stage: Stage,
     pub flags: Flags,
     pub system_info: SystemInfo,
-    game_handle: windows::Win32::Foundation::HANDLE,
+    firewall: Firewall,
     pub anti_afk: features::anti_afk::AntiAfk,
     empty_session: features::empty_session::EmptySession,
     force_close: features::force_close::ForceClose,
@@ -54,48 +57,39 @@ pub struct App {
 }
 
 impl eframe::App for App {
-    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+    fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
-        ctx.request_repaint_after(Duration::from_millis(100));
+        ui.request_repaint_after(Duration::from_millis(100));
-        self.empty_session.run_timers(&mut self.game_handle);
+        self.empty_session.run_timers(&self.firewall).unwrap();
-        egui::TopBottomPanel::bottom("bottom_panel")
+        egui::Panel::bottom("bottom_panel")
-            .exact_height(25.0)
+            .exact_size(25.0)
-            .show(ctx, |ui| {
+            .show(ui, |ui| {
                 ui.with_layout(egui::Layout::left_to_right(egui::Align::Center), |ui| {
                     ui.build_menu(&mut self.stage);
-                    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                        let button = ui
-                            .add_enabled(!self.flags.elevated, egui::Button::new("Elevate"))
-                            .on_hover_text("Relaunch ourselves as administrator.")
-                            .on_disabled_hover_text("We are already running elevated.");
-                        if button.clicked() {
-                            win::elevate(win::ElevationExitMethod::Gentle(&mut self.flags.closing));
-                        }
                 });
             });
-            });
+        egui::CentralPanel::default().show(ui, |ui| {
-        egui::CentralPanel::default().show(ctx, |ui| {
             egui::ScrollArea::vertical()
                 .auto_shrink([false, true])
                 .show(ui, |ui| match self.stage {
-                    Stage::Main => self.show_main_stage(ctx, ui),
+                    Stage::Main => self.show_main_stage(ui),
-                    Stage::Settings => self.show_settings_stage(ctx, ui),
+                    Stage::Settings => self.show_settings_stage(ui),
-                    Stage::About => self.show_about_stage(ctx, ui),
+                    Stage::About => self.show_about_stage(ui),
                 });
         });
-        if tools::debug_keycombo_pressed(ctx) || tools::debug_viewport_close_pressed(ctx) {
+        if tools::debug_keycombo_pressed(ui) || tools::debug_viewport_close_pressed(ui) {
             self.flags.debug = !self.flags.debug;
         }
         if self.flags.debug {
-            self.show_debug_viewport(ctx);
+            self.show_debug_viewport(ui);
         }
         if self.flags.closing {
-            ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+            ui.send_viewport_cmd(egui::ViewportCommand::Close);
         }
     }
 }
 
 impl App {
-    fn show_game_section(&mut self, _ctx: &egui::Context, ui: &mut egui::Ui) {
+    fn show_game_section(&mut self, ui: &mut egui::Ui) {
         ui.header("Game");
         ui.horizontal(|ui| {
             if ui.button("Launch").clicked() {
@@ -108,23 +102,18 @@ impl App {
                     ui.build_menu(&mut self.launch.selected);
                 });
         });
-        let force_close_button = ui.add_sized(
+        let force_close_button = ui.button(&self.force_close.button_text);
-            [108.0, 0.0],
-            egui::Button::new(&self.force_close.button_text),
-        );
         self.force_close
             .prompt(force_close_button.clicked(), &mut self.system_info);
     }
 
-    fn show_session_section(&mut self, _ctx: &egui::Context, ui: &mut egui::Ui) {
+    fn show_session_section(&mut self, ui: &mut egui::Ui) {
         ui.header("Session");
         ui.add_enabled_ui(!self.empty_session.disabled, |ui| {
             ui.horizontal(|ui| {
                 if ui.button("Empty current session").clicked()
-                    && features::empty_session::activate(
+                    && features::empty_session::activate(&mut self.system_info, &self.firewall)
-                        &mut self.game_handle,
+                        .unwrap()
-                        &mut self.system_info,
-                    )
                 {
                     self.empty_session.interval = Instant::now();
                     self.empty_session.disabled = true;
@@ -139,9 +128,9 @@ impl App {
                 ui.add_space(8.0);
                 ui.add_enabled_ui(false, |ui| {
                     ui.label(if win::is_window_focused(WINDOW_TITLE) {
-                        "GTA is focused."
+                        "Game is focused."
                     } else {
-                        "GTA is not focused!"
+                        "Game is not focused!"
                     })
                 });
             }
@@ -151,77 +140,148 @@ impl App {
         }
     }
 
-    fn show_network_section(&mut self, _ctx: &egui::Context, ui: &mut egui::Ui) {
+    fn show_network_section(&mut self, ui: &mut egui::Ui) {
         ui.header("Network");
         egui::Frame::new()
             .outer_margin(egui::vec2(0.0, -2.0))
             .show(ui, |ui| {
-                let response = ui.add_enabled_ui(self.flags.elevated, |ui| {
                 let label = ui.horizontal(|ui| {
-                        let label = ui.label("Game's network access");
+                    let label = match self.settings.block_method {
+                        BlockMethod::EntireGame => ui.label("Game's network access"),
+                        BlockMethod::SaveServer => ui.label("Rockstar save server access"),
+                    };
                     ui.add_space(1.0);
-                        ui.create_indicator_dot(self.game_networking.blocked_status)
+                    ui.create_indicator_dot(match self.game_networking.blocked {
-                            .on_hover_text(
+                        BlockedStatus::Executable
-                                "This turns yellow if GTA Tools\ncannot find your game.",
+                            if self.settings.block_method == BlockMethod::EntireGame =>
-                            );
+                        {
-                        self.game_networking.if_failed_return_to_boolean();
+                            colours::RED
+                        }
+                        BlockedStatus::Server
+                            if self.settings.block_method == BlockMethod::SaveServer =>
+                        {
+                            colours::RED
+                        }
+                        _ => colours::GREEN,
+                    });
                     label
                 });
-                    ui.horizontal(|ui| {
+                ui.allocate_ui_with_layout(
-                        let available_width = label.inner.rect.width();
+                    egui::vec2(label.inner.rect.width(), 0.0),
-                        let spacing = ui.spacing().item_spacing.x;
+                    egui::Layout::top_down(egui::Align::Min),
-                        let button_width = (available_width - spacing) / 2.0;
+                    |ui| {
-                        if ui
+                        ui.columns(2, |columns| {
-                            .add_sized([button_width, 18.0], egui::Button::new("Block"))
+                            columns[0].vertical_centered_justified(|ui| {
-                            .clicked()
+                                if ui.button("Block").clicked() {
-                        {
+                                    match self.settings.block_method {
-                            self.game_networking.block_all(&mut self.system_info);
+                                        BlockMethod::EntireGame => {
+                                            self.game_networking
+                                                .block_exe(&mut self.system_info, &self.firewall)
+                                                .unwrap();
+                                        }
+                                        BlockMethod::SaveServer => {
+                                            self.game_networking
+                                                .block_save_server(
+                                                    &self.settings.save_server_ip,
+                                                    &self.firewall,
+                                                )
+                                                .unwrap();
+                                        }
+                                    }
+                                }
+                            });
+                            columns[1].vertical_centered_justified(|ui| {
+                                if ui.button("Unblock").clicked() {
+                                    match self.settings.block_method {
+                                        BlockMethod::EntireGame => {
+                                            self.game_networking
+                                                .unblock_exe(&self.firewall)
+                                                .unwrap();
+                                        }
+                                        BlockMethod::SaveServer => {
+                                            self.game_networking
+                                                .unblock_save_server(&self.firewall)
+                                                .unwrap();
+                                        }
                                     }
-                        if ui
-                            .add_sized([button_width, 18.0], egui::Button::new("Unblock"))
-                            .clicked()
-                        {
-                            self.game_networking.unblock_all();
                                 }
                             });
                         });
-                response.response.on_disabled_hover_text(
+                    },
-                    "This requires administrator.\nUse the Elevate button.",
                 );
             });
     }
 
-    fn show_main_stage(&mut self, ctx: &egui::Context, ui: &mut egui::Ui) {
+    fn show_main_stage(&mut self, ui: &mut egui::Ui) {
-        self.show_game_section(ctx, ui);
+        self.show_game_section(ui);
-        self.show_session_section(ctx, ui);
+        self.show_session_section(ui);
-        self.show_network_section(ctx, ui);
+        self.show_network_section(ui);
     }
 
-    fn show_settings_stage(&mut self, ctx: &egui::Context, ui: &mut egui::Ui) {
+    fn show_settings_stage(&mut self, ui: &mut egui::Ui) {
-        ui.horizontal(|ui| {
+        ui.collapsing("General", |ui| {
-            ui.label("Launch version");
-            egui::ComboBox::from_id_salt("Launch version")
-                .selected_text(self.settings.launch_version.to_string())
-                .show_ui(ui, |ui| {
-                    ui.build_menu(&mut self.settings.launch_version);
-                });
-        });
             ui.horizontal(|ui| {
                 let selection = self.settings.theme;
-            ui.label("Theme");
                 egui::ComboBox::from_id_salt("Theme")
                     .selected_text(self.settings.theme.to_string())
                     .show_ui(ui, |ui| {
                         ui.build_menu(&mut self.settings.theme);
                     });
                 if selection != self.settings.theme {
-                catppuccin_egui::set_theme(ctx, self.settings.theme.into());
+                    ui.set_theme(egui::Theme::from(self.settings.theme));
+                }
+                ui.label("Theme");
+            });
+        });
+        ui.collapsing("Game", |ui| {
+            ui.horizontal(|ui| {
+                egui::ComboBox::from_id_salt("Launch version")
+                    .selected_text(self.settings.launch_version.to_string())
+                    .show_ui(ui, |ui| {
+                        ui.build_menu(&mut self.settings.launch_version);
+                    });
+                ui.label("Launch version");
+            });
+        });
+        ui.collapsing("Network", |ui| {
+            ui.horizontal(|ui| {
+                egui::ComboBox::from_id_salt("Block method")
+                    .selected_text(self.settings.block_method.to_string())
+                    .show_ui(ui, |ui| {
+                        ui.build_menu(&mut self.settings.block_method);
+                    });
+                ui.label("Block method");
+                if let Err(why) = self
+                    .game_networking
+                    .ensure_block_exclusivity(self.settings.block_method, &self.firewall)
+                {
+                    log::warn!("Couldn't ensure block exclusivity: {why}");
+                }
+            });
+            if self.settings.block_method == BlockMethod::SaveServer {
+                ui.horizontal(|ui| {
+                    ui.add(
+                        egui::TextEdit::singleline(&mut self.settings.save_server_ip)
+                            .char_limit(15)
+                            .desired_width(100.0),
+                    );
+                    ui.label("Save server IP");
+                    if self.settings.save_server_ip != Settings::default().save_server_ip {
+                        if ui.button("↺").clicked() {
+                            self.settings.save_server_ip = String::from(ROCKSTAR_SAVE_SERVER);
+                        }
+                    }
+                });
+            };
+        });
+        ui.collapsing("Miscellaneous", |ui| {
+            if ui.button("Open storage path").clicked() {
+                open::that_detached(path::APP_STORAGE.as_path()).unwrap();
             }
         });
-        ui.checkbox(&mut self.settings.start_elevated, "Always start elevated");
     }
 
-    fn show_about_stage(&self, _ctx: &egui::Context, ui: &mut egui::Ui) {
+    fn show_about_stage(&self, ui: &mut egui::Ui) {
         ui.with_layout(egui::Layout::bottom_up(egui::Align::Center), |ui| {
             ui.horizontal(|ui| {
                 ui.horizontal(|ui| {
@@ -232,12 +292,19 @@ impl App {
                         ui.label("❤");
                     });
                     ui.label(" from ");
+                    ui.scope(|ui| {
+                        ui.style_mut().visuals.hyperlink_color =
+                            egui::Theme::from(self.settings.theme)
+                                .default_style()
+                                .visuals
+                                .text_color();
                         ui.hyperlink_to("futile", "https://futile.eu");
                     });
+                });
                 ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                     ui.style_mut().spacing.button_padding = egui::Vec2::new(4.0, 0.0);
-                    if ui.button("").on_hover_text("View source code").clicked() {
+                    if ui.button("").on_hover_text("View source code").clicked() {
-                        open::that("https://github.com/elituf/gta-tools").unwrap();
+                        open::that("https://futile.eu/gta-tools").unwrap();
                     }
                     if cfg!(debug_assertions) {
                         ui.label("(dev)");
@@ -264,7 +331,9 @@ impl Drop for App {
             settings: self.settings.clone(),
         }
         .set();
-        // make sure we are not suspending game
+        // make sure we are not network blocking game
-        features::empty_session::deactivate(&mut self.game_handle);
+        if let Err(why) = features::empty_session::deactivate(&self.firewall) {
+            log::error!("couldn't deactivate empty session: {why}");
+        }
     }
 }

src/gui/debug.rs

@@ -4,19 +4,13 @@ use crate::{
         tools,
         ui_ext::UiExt,
     },
-    util::consts::{
+    util::consts::game::{EXE_ENHANCED, EXE_LEGACY},
-        game::{EXE_ENHANCED, EXE_LEGACY},
-        path,
-    },
 };
 use eframe::egui;
 
 impl App {
     fn add_debug_viewport_contents(&mut self, ui: &mut egui::Ui) {
         ui.collapsing("misc", |ui| {
-            if ui.button("open storage path").clicked() {
-                open::that_detached(path::APP_STORAGE.as_path()).unwrap();
-            }
             ui.scope(|ui| {
                 use windows::Win32::UI::WindowsAndMessaging::{
                     GetForegroundWindow, GetWindowTextW,
@@ -30,15 +24,16 @@ impl App {
                 ui.label(format!("focused: \"{current_title}\""));
             });
             ui.horizontal(|ui| {
-                ui.label("blocked_status");
+                ui.label("blocked");
-                egui::ComboBox::from_id_salt("blocked_status")
+                egui::ComboBox::from_id_salt("blocked")
-                    .selected_text(self.game_networking.blocked_status.to_string())
+                    .selected_text(self.game_networking.blocked.to_string())
-                    .show_ui(ui, |ui| {
+                    .show_ui(ui, |ui| ui.build_menu(&mut self.game_networking.blocked));
-                        ui.build_menu(&mut self.game_networking.blocked_status);
-                    });
             });
             if ui.add(egui::Button::new("force refresh theme")).clicked() {
-                catppuccin_egui::set_theme(ui.ctx(), self.settings.theme.into());
+                ui.set_theme(egui::Theme::from(self.settings.theme));
+            }
+            if ui.button("panic button").clicked() {
+                panic!("this is the panic button");
             }
         });
         ui.collapsing("anti afk", |ui| {

src/gui/run.rs

@@ -3,36 +3,36 @@ use crate::{
         app::{App, WINDOW_SIZE},
         tools,
     },
-    util::{persistent_state::PersistentState, win},
+    util::persistent_state::PersistentState,
 };
 use eframe::egui;
+use windows::Win32::System::Com::{COINIT_APARTMENTTHREADED, CoInitializeEx};
 
 fn app_creator(
     cc: &eframe::CreationContext<'_>,
 ) -> Result<Box<dyn eframe::App>, Box<dyn std::error::Error + Send + Sync>> {
+    // initialize COM just in case
+    if let Err(e) = unsafe { CoInitializeEx(None, COINIT_APARTMENTTHREADED) }.ok() {
+        log::error!("couldn't initialize COM: {e}");
+    }
     // initialize App early to modify some things before returning it
     let mut app = Box::new(App::default());
     // load previously selected launch platform & settings from persistent state
     if let Some(persistent_state) = PersistentState::get() {
         persistent_state.apply_to(&mut app);
     }
-    // check if we're elevated. if not, and the user wants an elevated launch - relaunch elevated
-    if !app.flags.elevated && app.settings.start_elevated {
-        win::elevate(win::ElevationExitMethod::Forced);
-    }
     // refresh system info because it initializes with nothing
     app.system_info.refresh();
     // enable image loading support in egui
     egui_extras::install_image_loaders(&cc.egui_ctx);
-    // set our initial theme, from earlier loaded settings. we set the egui theme
+    // set our initial theme, from earlier loaded settings. we set the egui theme here to work
-    // to dark here to work around system theme based switching of the egui style
+    // around system theme based switching of the egui style
-    cc.egui_ctx.set_theme(egui::Theme::Dark);
+    cc.egui_ctx.set_theme(egui::Theme::from(app.settings.theme));
-    catppuccin_egui::set_theme(&cc.egui_ctx, app.settings.theme.into());
     // apply some global styling that we like
     cc.egui_ctx.all_styles_mut(|style| {
         style.spacing.item_spacing = egui::vec2(4.0, 4.0);
         style.interaction.selectable_labels = false;
-        style.visuals.hyperlink_color = catppuccin_egui::Theme::from(app.settings.theme).text;
+        // style.visuals.hyperlink_color = catppuccin_egui::Theme::from(app.settings.theme).text;
     });
     // load any extra fonts that we need
     let mut fonts = egui::FontDefinitions::default();

src/gui/settings.rs

@@ -1,7 +1,37 @@
 use crate::util::win;
+use eframe::egui;
 use serde::{Deserialize, Serialize};
 use strum::{Display, EnumIter};
 
+pub const ROCKSTAR_SAVE_SERVER: &str = "192.81.241.171";
+
+#[derive(Clone, Copy, Debug, Default, Display, PartialEq, Eq, Serialize, Deserialize, EnumIter)]
+pub enum Theme {
+    #[default]
+    #[strum(to_string = "Auto")]
+    Auto,
+    #[strum(to_string = "Light")]
+    Light,
+    #[strum(to_string = "Dark")]
+    Dark,
+}
+
+impl From<Theme> for egui::Theme {
+    fn from(val: Theme) -> Self {
+        match val {
+            Theme::Auto => {
+                if win::is_system_theme_light() {
+                    egui::Theme::Light
+                } else {
+                    egui::Theme::Dark
+                }
+            }
+            Theme::Light => egui::Theme::Light,
+            Theme::Dark => egui::Theme::Dark,
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, Default, Display, PartialEq, Eq, Serialize, Deserialize, EnumIter)]
 pub enum LaunchVersion {
     #[default]
@@ -10,41 +40,29 @@ pub enum LaunchVersion {
 }
 
 #[derive(Clone, Copy, Debug, Default, Display, PartialEq, Eq, Serialize, Deserialize, EnumIter)]
-pub enum Theme {
+pub enum BlockMethod {
     #[default]
-    #[strum(to_string = "Auto")]
+    #[strum(to_string = "Entire game")]
-    Auto,
+    EntireGame,
-    #[strum(to_string = "Catppuccin Latte")]
+    #[strum(to_string = "Save server")]
-    CatppuccinLatte,
+    SaveServer,
-    #[strum(to_string = "Catppuccin Frappe")]
-    CatppuccinFrappe,
-    #[strum(to_string = "Catppuccin Macchiato")]
-    CatppuccinMacchiato,
-    #[strum(to_string = "Catppuccin Mocha")]
-    CatppuccinMocha,
 }
 
-impl From<Theme> for catppuccin_egui::Theme {
+#[derive(Clone, Debug, Serialize, Deserialize)]
-    fn from(val: Theme) -> Self {
-        match val {
-            Theme::Auto => {
-                if win::is_system_theme_dark() {
-                    catppuccin_egui::MOCHA
-                } else {
-                    catppuccin_egui::LATTE
-                }
-            }
-            Theme::CatppuccinLatte => catppuccin_egui::LATTE,
-            Theme::CatppuccinFrappe => catppuccin_egui::FRAPPE,
-            Theme::CatppuccinMacchiato => catppuccin_egui::MACCHIATO,
-            Theme::CatppuccinMocha => catppuccin_egui::MOCHA,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
 pub struct Settings {
-    pub launch_version: LaunchVersion,
     pub theme: Theme,
-    pub start_elevated: bool,
+    pub launch_version: LaunchVersion,
+    pub save_server_ip: String,
+    pub block_method: BlockMethod,
+}
+
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
+            theme: Theme::default(),
+            launch_version: LaunchVersion::default(),
+            block_method: BlockMethod::default(),
+            save_server_ip: String::from(ROCKSTAR_SAVE_SERVER),
+        }
+    }
 }

src/gui/tools.rs

@@ -11,12 +11,12 @@ pub fn load_icon() -> egui::IconData {
     }
 }
 
-pub fn debug_keycombo_pressed(ctx: &egui::Context) -> bool {
+pub fn debug_keycombo_pressed(ui: &egui::Ui) -> bool {
-    ctx.input(|i| i.modifiers.all() && i.key_pressed(egui::Key::D))
+    ui.input(|i| i.modifiers.all() && i.key_pressed(egui::Key::D))
 }
 
-pub fn debug_viewport_close_pressed(ctx: &egui::Context) -> bool {
+pub fn debug_viewport_close_pressed(ui: &egui::Ui) -> bool {
-    ctx.input(|i| {
+    ui.input(|i| {
         i.raw
             .viewports
             .get(&egui::ViewportId::from_hash_of("debug_viewport"))

src/main.rs

@@ -4,6 +4,8 @@ mod features;
 mod gui;
 mod util;
 
+use std::fmt::Write;
+
 fn init_storage() {
     if !util::consts::path::APP_STORAGE.exists() {
         std::fs::create_dir_all(util::consts::path::APP_STORAGE.as_path()).unwrap();
@@ -14,7 +16,7 @@ fn panic_hook(panic_info: &std::panic::PanicHookInfo<'_>) {
     let backtrace = std::backtrace::Backtrace::capture();
     let mut message = format!("{panic_info}");
     if backtrace.status() == std::backtrace::BacktraceStatus::Captured {
-        message += &format!("\nstack backtrace:\n{backtrace}");
+        write!(message, "\nstack backtrace:\n{backtrace}").unwrap();
     }
     log::error!("{message}");
 }

src/util.rs

@@ -1,5 +1,6 @@
 pub mod consts;
 pub mod countdown;
+pub mod firewall;
 pub mod logging;
 pub mod persistent_state;
 pub mod system_info;

src/util/consts.rs

@@ -15,20 +15,8 @@ pub mod game {
 }
 
 pub mod colours {
-    use crate::features::game_networking::BlockedStatus;
     use eframe::egui;
 
     pub const RED: egui::Color32 = egui::Color32::from_rgb(255, 96, 96);
-    pub const YELLOW: egui::Color32 = egui::Color32::from_rgb(255, 255, 96);
     pub const GREEN: egui::Color32 = egui::Color32::from_rgb(96, 255, 96);
-
-    impl From<BlockedStatus> for egui::Color32 {
-        fn from(value: BlockedStatus) -> Self {
-            match value {
-                BlockedStatus::Blocked => RED,
-                BlockedStatus::Failed => YELLOW,
-                BlockedStatus::Unblocked => GREEN,
-            }
-        }
-    }
 }

src/util/firewall.rs

@@ -0,0 +1,96 @@
+use anyhow::Result;
+use std::path::PathBuf;
+use windows::{
+    Win32::{
+        NetworkManagement::WindowsFirewall::{
+            INetFwPolicy2, INetFwRule, NET_FW_ACTION_BLOCK, NET_FW_IP_PROTOCOL_ANY,
+            NET_FW_IP_PROTOCOL_TCP, NET_FW_IP_PROTOCOL_UDP, NET_FW_RULE_DIR_IN,
+            NET_FW_RULE_DIR_OUT, NetFwPolicy2, NetFwRule,
+        },
+        System::Com::{CLSCTX_INPROC_SERVER, CoCreateInstance},
+    },
+    core::BSTR,
+};
+
+#[derive(Debug)]
+pub struct Firewall {
+    policy: INetFwPolicy2,
+}
+
+impl Default for Firewall {
+    fn default() -> Self {
+        Self {
+            policy: unsafe { CoCreateInstance(&NetFwPolicy2, None, CLSCTX_INPROC_SERVER) }.unwrap(),
+        }
+    }
+}
+
+impl Firewall {
+    pub fn add(
+        &self,
+        name: &str,
+        mode: RuleMode,
+        direction: RuleDirection,
+        protocol: RuleProtocol,
+    ) -> Result<()> {
+        let add_rule = || {
+            let rules = unsafe { self.policy.Rules() }?;
+            unsafe { rules.Remove(&BSTR::from(name)) }?;
+            let rule: INetFwRule =
+                unsafe { CoCreateInstance(&NetFwRule, None, CLSCTX_INPROC_SERVER) }?;
+            unsafe { rule.SetName(&BSTR::from(name)) }?;
+            match mode {
+                RuleMode::Executable(exe) => {
+                    unsafe { rule.SetApplicationName(&BSTR::from(exe.to_string_lossy().as_ref())) }?
+                }
+                RuleMode::Address(ip) => unsafe { rule.SetRemoteAddresses(&BSTR::from(ip)) }?,
+            }
+            match direction {
+                RuleDirection::In => unsafe { rule.SetDirection(NET_FW_RULE_DIR_IN) }?,
+                RuleDirection::Out => unsafe { rule.SetDirection(NET_FW_RULE_DIR_OUT) }?,
+            }
+            unsafe { rule.SetEnabled(true.into()) }?;
+            unsafe { rule.SetAction(NET_FW_ACTION_BLOCK) }?;
+            match protocol {
+                RuleProtocol::Any => unsafe { rule.SetProtocol(NET_FW_IP_PROTOCOL_ANY.0) }?,
+                RuleProtocol::Tcp => unsafe { rule.SetProtocol(NET_FW_IP_PROTOCOL_TCP.0) }?,
+                RuleProtocol::Udp => unsafe { rule.SetProtocol(NET_FW_IP_PROTOCOL_UDP.0) }?,
+            }
+            unsafe { rules.Add(&rule) }?;
+            Ok(())
+        };
+        add_rule().inspect_err(|e| log::warn!("Failed to add rule '{name}': {e}"))
+    }
+
+    pub fn remove(&self, name: &str) -> Result<()> {
+        let remove_rule = || {
+            let rules = unsafe { self.policy.Rules() }?;
+            unsafe { rules.Remove(&BSTR::from(name)) }?;
+            Ok(())
+        };
+        remove_rule().inspect_err(|e| log::warn!("Failed to remove rule '{name}': {e}"))
+    }
+
+    pub fn is_blocked(&self, name: &str) -> Result<bool> {
+        let rules = unsafe { self.policy.Rules() }?;
+        let rule_exists = unsafe { rules.Item(&BSTR::from(name)) }.is_ok();
+        Ok(rule_exists)
+    }
+}
+
+pub enum RuleMode {
+    Executable(PathBuf),
+    Address(String),
+}
+
+pub enum RuleDirection {
+    In,
+    Out,
+}
+
+pub enum RuleProtocol {
+    Any,
+    #[allow(unused)]
+    Tcp,
+    Udp,
+}

src/util/logging.rs

@@ -27,7 +27,7 @@ impl log::Log for Logger {
 
     fn log(&self, record: &log::Record) {
         if self.enabled(record.metadata()) {
-            self.log_to_stderr(record);
+            Self::log_to_stderr(record);
             self.log_to_file(record);
         }
     }
@@ -42,9 +42,9 @@ impl Logger {
 
     fn log_to_file(&self, record: &log::Record) {
         let mut file = self.file.lock().unwrap();
-        write!(
+        writeln!(
             file,
-            "[{}][{}]\n{}\n\n",
+            "[{}][{}] {}",
             humantime::format_rfc3339_seconds(SystemTime::now()),
             record.level(),
             record.args()
@@ -53,12 +53,12 @@ impl Logger {
         file.flush().unwrap();
     }
 
-    fn log_to_stderr(&self, record: &log::Record) {
+    fn log_to_stderr(record: &log::Record) {
         eprintln!(
-            "[{}][{}]\n{}",
+            "[{}][{}] {}",
             humantime::format_rfc3339_seconds(SystemTime::now()),
             record.level(),
             record.args()
-        )
+        );
     }
 }

src/util/system_info.rs

@@ -18,6 +18,8 @@ use windows::{
     core::PWSTR,
 };
 
+use crate::util::consts::game::{EXE_ENHANCED, EXE_LEGACY};
+
 #[derive(Clone, Debug)]
 pub struct Process {
     pid: u32,
@@ -80,6 +82,14 @@ impl SystemInfo {
         self.processes = processes;
     }
 
+    pub fn get_game_exe_path(&mut self) -> Option<&Path> {
+        self.refresh();
+        self.processes()
+            .iter()
+            .find(|p| p.name() == EXE_ENHANCED || p.name() == EXE_LEGACY)
+            .and_then(|p| p.exe())
+    }
+
     pub fn processes(&self) -> &[Process] {
         &self.processes
     }

src/util/win.rs

@@ -1,25 +1,10 @@
-use windows::{
+use windows::Win32::UI::{
-    Win32::{
-        Foundation::{CloseHandle, HANDLE},
-        Security::{GetTokenInformation, TOKEN_ELEVATION, TOKEN_QUERY, TokenElevation},
-        System::Threading::{GetCurrentProcess, OpenProcessToken},
-        UI::{
     Input::KeyboardAndMouse::{GetAsyncKeyState, VIRTUAL_KEY},
-            Shell::ShellExecuteW,
     WindowsAndMessaging::{
         CURSOR_SHOWING, CURSORINFO, GetCursorInfo, GetForegroundWindow, GetWindowTextW,
-                SW_NORMAL,
     },
-        },
-    },
-    core::{HSTRING, PCWSTR},
 };
 
-pub enum ElevationExitMethod<'a> {
-    Gentle(&'a mut bool),
-    Forced,
-}
-
 pub fn is_cursor_visible() -> bool {
     let mut ci = CURSORINFO {
         cbSize: u32::try_from(std::mem::size_of::<CURSORINFO>()).unwrap(),
@@ -42,45 +27,7 @@ pub fn is_any_key_pressed(keys: &[VIRTUAL_KEY]) -> bool {
         .any(|&key| unsafe { GetAsyncKeyState(i32::from(key.0)) } & i16::MIN != 0)
 }
 
-pub fn elevate(closing: ElevationExitMethod) {
+pub fn is_system_theme_light() -> bool {
-    let exe = std::env::current_exe().unwrap();
-    unsafe {
-        ShellExecuteW(
-            None,
-            &HSTRING::from("runas"),
-            &HSTRING::from(exe.as_path()),
-            PCWSTR::null(),
-            PCWSTR::null(),
-            SW_NORMAL,
-        );
-    }
-    match closing {
-        ElevationExitMethod::Gentle(closing) => *closing = true,
-        ElevationExitMethod::Forced => std::process::exit(0),
-    }
-}
-
-pub fn is_elevated() -> bool {
-    let mut token: HANDLE = HANDLE::default();
-    if unsafe { OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &raw mut token) }.is_err() {
-        return false;
-    }
-    let mut elevation = TOKEN_ELEVATION::default();
-    let mut size = u32::try_from(std::mem::size_of::<TOKEN_ELEVATION>()).unwrap();
-    let result = unsafe {
-        GetTokenInformation(
-            token,
-            TokenElevation,
-            Some((&raw mut elevation).cast()),
-            size,
-            &raw mut size,
-        )
-    };
-    unsafe { CloseHandle(token) }.unwrap();
-    result.is_ok() && elevation.TokenIsElevated != 0
-}
-
-pub fn is_system_theme_dark() -> bool {
     use winreg::RegKey;
     let hkcu = RegKey::predef(winreg::enums::HKEY_CURRENT_USER);
     let Ok(subkey) =
@@ -88,8 +35,10 @@ pub fn is_system_theme_dark() -> bool {
     else {
         return true;
     };
-    let Ok(dword): Result<u32, std::io::Error> = subkey.get_value("AppsUseLightTheme") else {
+    let Ok(apps_use_light_theme): Result<u32, std::io::Error> =
+        subkey.get_value("AppsUseLightTheme")
+    else {
         return true;
     };
-    dword != 1
+    apps_use_light_theme == 1
 }