SmbMount.vala

Go to the documentation of this file.

/*
 * SmbMount.vala
 *
 * Copyright 2025-2026 Calogero Scarnà — BastionGuard Backup
 *
 * GPL-2.0-or-later
 *
 * Helper class to mount, list and unmount SMB/CIFS network shares
 * (NAS, Samba servers, Windows shared folders) so that snapshots
 * can be created/restored/listed from these locations.
 */
 
using GLib;
using Gee;
using Json;
 
using TeeJee.Logging;
using TeeJee.FileSystem;
using TeeJee.JsonHelper;
using TeeJee.ProcessHelper;
using TeeJee.Misc;
 
/**
 * Represents a single SMB/CIFS share that BastionGuard Backup is
 * aware of. Either currently-mounted or remembered for re-use.
 */
public class SmbShare : GLib.Object {
 
    public string server   = "";   // e.g. "nas.local" or "192.168.1.10"
    public string share    = "";   // e.g. "backups"
    public string subpath  = "";   // optional path inside the share, e.g. "machineA"
    public string username = "";
    public string domain   = "";
    public string label    = "";   // free-text user label (optional)
 
    public string mount_point = ""; // populated once mounted
 
    // password is intentionally NOT serialized to disk
    public string password = "";
    public bool   save_credentials = false;
 
    public string unc_path {
        owned get {
            string s = "//%s/%s".printf(server, share);
            if (subpath.length > 0){
                s += "/" + subpath;
            }
            return s;
        }
    }
 
    public string display_name {
        owned get {
            if (label.length > 0){
                return "%s  (%s)".printf(label, unc_path);
            }
            return unc_path;
        }
    }
 
    public Json.Object to_json(){
        var obj = new Json.Object();
        obj.set_string_member("server",   server);
        obj.set_string_member("share",    share);
        obj.set_string_member("subpath",  subpath);
        obj.set_string_member("username", username);
        obj.set_string_member("domain",   domain);
        obj.set_string_member("label",    label);
        return obj;
    }
 
    public static SmbShare from_json(Json.Object obj){
        var s = new SmbShare();
        s.server   = json_get_string(obj, "server",   "");
        s.share    = json_get_string(obj, "share",    "");
        s.subpath  = json_get_string(obj, "subpath",  "");
        s.username = json_get_string(obj, "username", "");
        s.domain   = json_get_string(obj, "domain",   "");
        s.label    = json_get_string(obj, "label",    "");
        return s;
    }
}
 
/**
 * Static helper: drives mount.cifs, tracks active mounts and
 * persists the user's recently-used shares.
 */
public class SmbMount : GLib.Object {
 
    // Where we mount remote shares. Lives under the per-pid app
    // mount_point dir (set up by Main) so cleanup follows the
    // existing pattern.
    public static string mount_root {
        owned get {
            return (App != null && App.mount_point_app.length > 0)
                ? App.mount_point_app + "/smb"
                : "/run/bastionguard-backup/smb";
        }
    }
 
    // JSON file where we remember the user's network shares
    // (everything except the password).
    private const string SHARES_CONF = "/etc/bastionguard-backup/smb-shares.json";
 
    /**
     * Returns true if both `mount.cifs` and `cifs-utils` look usable
     * on this system. Sets `error_message` with a hint otherwise.
     */
    public static bool is_available(out string error_message){
        error_message = "";
        if (!cmd_exists("mount.cifs")){
            error_message = _("Network shares (SMB/CIFS) are not available on this system.")
                + "\n\n"
                + _("Please install the 'cifs-utils' package and try again.");
            return false;
        }
        return true;
    }
 
    /**
     * Mount the SMB share described by `share`. On success the
     * `mount_point` field of `share` is populated and the path is
     * returned. On failure returns an empty string and `error_message`
     * carries a translated explanation.
     */
    public static string mount(SmbShare share, out string error_message){
        error_message = "";
 
        if (share.server.length == 0 || share.share.length == 0){
            error_message = _("Server and share name must both be provided.");
            return "";
        }
 
        string avail_err;
        if (!is_available(out avail_err)){
            error_message = avail_err;
            return "";
        }
 
        // Build a stable-but-readable mount point.
        string slug = "%s_%s".printf(
            share.server.replace("/", "_").replace(":", "_"),
            share.share.replace("/", "_"));
        string mp = path_combine(mount_root, slug);
        dir_create(mp);
 
        // Already mounted at our path? Reuse.
        if (is_mounted_at(mp)){
            share.mount_point = mp;
            log_msg(_("SMB share already mounted at") + ": %s".printf(mp));
            return mp;
        }
 
        // Build mount options. We deliberately keep them conservative
        // so most NASes "just work" while still allowing rsync to set
        // permissions and create hardlinks.
        var opts = new Gee.ArrayList<string>();
 
        // Credentials. Empty user => guest mount.
        if (share.username.length > 0){
            opts.add("username=" + share.username);
            if (share.password.length > 0){
                opts.add("password=" + share.password);
            }
            if (share.domain.length > 0){
                opts.add("domain=" + share.domain);
            }
        }
        else{
            opts.add("guest");
        }
 
        // Run as root inside the mount (rsync needs this to
        // preserve ownership of system files).
        opts.add("uid=0");
        opts.add("gid=0");
        opts.add("file_mode=0644");
        opts.add("dir_mode=0755");
 
        // Prefer the most modern dialect that is widely supported.
        opts.add("vers=3.0");
 
        // rsync uses unix sockets/temp files inside the share, so allow
        // "noperm" as a fallback if the server is overly strict. This
        // is safe because the device side already gates access.
        opts.add("noperm");
 
        string opt_str = string.joinv(",", opts.to_array());
 
        string unc = "//%s/%s".printf(share.server, share.share);
        // mount.cifs takes the share without the optional subpath; the
        // subpath is just appended to the resulting mount_point later.
 
        string cmd = "mount -t cifs -o %s \"%s\" \"%s\"".printf(
            Shell.quote(opt_str).replace("'", "'\\''"),
            unc,
            mp);
 
        // Avoid leaking the password into the log
        string safe_opt_str = opt_str;
        if (share.password.length > 0){
            safe_opt_str = safe_opt_str.replace(
                "password=" + share.password, "password=***");
        }
        log_debug("SmbMount.mount(): mount -t cifs -o %s %s %s".printf(
            safe_opt_str, unc, mp));
 
        string std_out, std_err;
        int ret_val = exec_sync(cmd, out std_out, out std_err);
 
        if (ret_val != 0){
            // Map a few common errors to friendlier messages.
            string err = (std_err ?? "").strip();
            if (err.length == 0){ err = (std_out ?? "").strip(); }
 
            if (err.down().contains("permission denied")
                || err.down().contains("logon failure")
                || err.down().contains("nt_status_logon_failure")){
                error_message = _("Authentication failed. Please check the username, password and domain.");
            }
            else if (err.down().contains("no route to host")
                || err.down().contains("connection refused")
                || err.down().contains("connection timed out")
                || err.down().contains("host is down")){
                error_message = _("Could not reach the server. Please check the address and that the share is online.");
            }
            else if (err.down().contains("no such file or directory")
                || err.down().contains("bad share name")){
                error_message = _("The share was not found on the server. Please check the share name.");
            }
            else{
                error_message = _("Failed to mount the network share.") + "\n\n" + err;
            }
            log_error(error_message);
            return "";
        }
 
        share.mount_point = mp;
        log_msg(_("Mounted network share") + ": %s → %s".printf(unc, mp));
        return mp;
    }
 
    public static bool unmount(SmbShare share){
        if (share.mount_point.length == 0){
            return true;
        }
        bool ok = Device.unmount(share.mount_point);
        if (ok){
            share.mount_point = "";
        }
        return ok;
    }
 
    public static bool unmount_path(string mount_point){
        if (mount_point.length == 0){
            return true;
        }
        return Device.unmount(mount_point);
    }
 
    public static bool is_mounted_at(string mount_point){
        try {
            string contents;
            FileUtils.get_contents("/proc/mounts", out contents);
            foreach (string line in contents.split("\n")){
                var parts = line.split(" ");
                if (parts.length >= 3 && parts[1] == mount_point && parts[2] == "cifs"){
                    return true;
                }
            }
        }
        catch (Error e){
            log_debug(e.message);
        }
        return false;
    }
 
    /**
     * Returns every CIFS mount currently visible in /proc/mounts as
     * an SmbShare with the `mount_point` field populated. Username
     * and credentials are NOT recoverable from the kernel.
     */
    public static Gee.ArrayList<SmbShare> list_active_mounts(){
        var list = new Gee.ArrayList<SmbShare>();
        try {
            string contents;
            FileUtils.get_contents("/proc/mounts", out contents);
            foreach (string line in contents.split("\n")){
                if (line.strip().length == 0){ continue; }
                var parts = line.split(" ");
                if (parts.length < 3){ continue; }
                if (parts[2] != "cifs" && parts[2] != "smb3"){ continue; }
 
                string source = parts[0]; // e.g. //server/share
                string mp     = parts[1];
 
                // /proc/mounts escapes spaces as \040 etc — decode.
                mp = mp.replace("\\040", " ");
 
                var share = new SmbShare();
                share.mount_point = mp;
                if (source.has_prefix("//")){
                    string rest = source.substring(2);
                    int slash = rest.index_of("/");
                    if (slash > 0){
                        share.server = rest.substring(0, slash);
                        share.share  = rest.substring(slash + 1);
                    }
                    else {
                        share.server = rest;
                    }
                }
                list.add(share);
            }
        }
        catch (Error e){
            log_debug(e.message);
        }
        return list;
    }
 
    // ---- persistence of remembered shares ------------------------
 
    public static Gee.ArrayList<SmbShare> load_saved_shares(){
        var list = new Gee.ArrayList<SmbShare>();
        var f = File.new_for_path(SHARES_CONF);
        if (!f.query_exists()){
            return list;
        }
        try {
            var parser = new Json.Parser();
            parser.load_from_file(SHARES_CONF);
            var root = parser.get_root();
            if (root == null){ return list; }
            var arr = root.get_array();
            if (arr == null){ return list; }
            arr.foreach_element((a, idx, node) => {
                var obj = node.get_object();
                if (obj != null){
                    list.add(SmbShare.from_json(obj));
                }
            });
        }
        catch (Error e){
            log_error("SmbMount.load_saved_shares(): " + e.message);
        }
        return list;
    }
 
    public static void save_share(SmbShare share){
        // merge: replace if the same server+share+subpath already exists,
        // otherwise append.
        var list = load_saved_shares();
        bool replaced = false;
        for (int i = 0; i < list.size; i++){
            var existing = list[i];
            if (existing.server == share.server
                && existing.share == share.share
                && existing.subpath == share.subpath){
                list[i] = share;
                replaced = true;
                break;
            }
        }
        if (!replaced){
            list.add(share);
        }
        write_shares(list);
    }
 
    public static void forget_share(SmbShare share){
        var list = load_saved_shares();
        var keep = new Gee.ArrayList<SmbShare>();
        foreach (var existing in list){
            if (existing.server == share.server
                && existing.share == share.share
                && existing.subpath == share.subpath){
                continue;
            }
            keep.add(existing);
        }
        write_shares(keep);
    }
 
    private static void write_shares(Gee.ArrayList<SmbShare> list){
        try {
            dir_create(GLib.Path.get_dirname(SHARES_CONF));
            var arr = new Json.Array();
            foreach (var s in list){
                arr.add_object_element(s.to_json());
            }
            var node = new Json.Node(Json.NodeType.ARRAY);
            node.set_array(arr);
 
            var generator = new Json.Generator();
            generator.pretty = true;
            generator.set_root(node);
            generator.to_file(SHARES_CONF);
 
            // Best effort: lock down the file because it contains
            // usernames (no passwords, but still).
            Posix.chmod(SHARES_CONF, 0600);
        }
        catch (Error e){
            log_error("SmbMount.write_shares(): " + e.message);
        }
    }
}