package nas import ( "context" "fmt" "os" "path/filepath" "strings" ) // linuxConnector reaches a share the way Linux does: through a mount point in // the single filesystem tree. There is no per-path authentication, so the // question is not "can we connect" but "where is this share mounted". // // The default and by far the safest answer is that the host already mounted it // (fstab, autofs, systemd, or `docker run -v`), so the connector looks the // share up in the mount table. Mounting it here is opt-in because it requires // root and changes system state that outlives a failed run. type linuxConnector struct { run commandRunner mountsPath string // geteuid is indirected for tests; production uses os.Geteuid. geteuid func() int } func (c *linuxConnector) Name() string { return "mount" } func (c *linuxConnector) Attach(ctx context.Context, loc Location, cfg NASConfig) (Attachment, error) { entries, err := readMountTable(c.mountsPath) if err != nil { return Attachment{}, err } if point, rest, ok := findMount(entries, loc); ok { return Attachment{ BasePath: filepath.Join(append([]string{point}, rest...)...), Notes: []string{ "share: " + loc.SMBSource(), fmt.Sprintf("resolved via existing mount at %s", point), }, }, nil } if !cfg.AutoMount { return Attachment{}, fmt.Errorf("%s", notMountedMessage(loc, cfg)) } return c.mount(ctx, loc, cfg) } func (c *linuxConnector) Detach(ctx context.Context, att Attachment) error { // Never unmount a share the host had already mounted; other software may // be using it, and we did not put it there. if !att.Owned || att.mountPoint == "" { return nil } if out, err := c.run(ctx, "umount", att.mountPoint); err != nil { return fmt.Errorf("failed to unmount %s: %v", att.mountPoint, summarize(err, out)) } return nil } // mount performs an opt-in mount.cifs of the share. func (c *linuxConnector) mount(ctx context.Context, loc Location, cfg NASConfig) (Attachment, error) { geteuid := c.geteuid if geteuid == nil { geteuid = os.Geteuid } if geteuid() != 0 { return Attachment{}, fmt.Errorf( "NAS_AUTO_MOUNT is set but mounting %s requires root; run as root, or mount the share beforehand and %s", loc.SMBSource(), suggestMountPointConfig(loc)) } point := autoMountPoint(loc, cfg) if err := os.MkdirAll(point, 0755); err != nil { return Attachment{}, fmt.Errorf("failed to create mount point %s: %w", point, err) } credentialsPath, cleanup, err := writeCredentialsFile(cfg) if err != nil { return Attachment{}, err } defer cleanup() if cfg.Timeout > 0 { var cancel context.CancelFunc ctx, cancel = context.WithTimeout(ctx, cfg.Timeout) defer cancel() } if out, err := c.run(ctx, "mount", mountArgs(loc, point, credentialsPath)...); err != nil { return Attachment{}, fmt.Errorf("failed to mount %s at %s: %v", loc.SMBSource(), point, summarize(err, out)) } return Attachment{ BasePath: filepath.Join(append([]string{point}, loc.Sub...)...), Owned: true, mountPoint: point, Notes: []string{ "share: " + loc.SMBSource(), "user: " + usernameNote(cfg.Username), fmt.Sprintf("mounted at %s by this process (will unmount on shutdown)", point), }, }, nil } // mountArgs builds the mount.cifs invocation. Kept pure so it can be asserted // without mounting anything. func mountArgs(loc Location, mountPoint, credentialsPath string) []string { options := "rw" if credentialsPath != "" { options += ",credentials=" + credentialsPath } else { options += ",guest" } return []string{"-t", "cifs", loc.SMBSource(), mountPoint, "-o", options} } // writeCredentialsFile stages the NAS credentials in a 0600 file. mount.cifs // also accepts user=/pass= options, but those land in the process table where // any local user can read the password; a credentials file does not. func writeCredentialsFile(cfg NASConfig) (path string, cleanup func(), err error) { if cfg.Username == "" || cfg.Password == "" { return "", func() {}, nil } dir, err := os.MkdirTemp("", "streamrecorder-cifs-") if err != nil { return "", func() {}, fmt.Errorf("failed to stage NAS credentials: %w", err) } cleanup = func() { os.RemoveAll(dir) } path = filepath.Join(dir, "credentials") content := fmt.Sprintf("username=%s\npassword=%s\n", cfg.Username, cfg.Password) if err := os.WriteFile(path, []byte(content), 0600); err != nil { cleanup() return "", func() {}, fmt.Errorf("failed to write NAS credentials file: %w", err) } return path, cleanup, nil } // autoMountPoint chooses where to mount the share when the operator has not // named a location. Everything lands under one predictable directory so a // leftover mount is easy to find and clean up. func autoMountPoint(loc Location, cfg NASConfig) string { if cfg.MountPoint != "" { return cfg.MountPoint } return filepath.Join("/mnt", "streamrecorder", strings.ToLower(loc.Server), strings.ToLower(loc.Share)) } // notMountedMessage explains the failure in terms of what the operator should // actually type. A bare "no such mount" would leave them guessing. func notMountedMessage(loc Location, cfg NASConfig) string { source := loc.SMBSource() example := filepath.Join("/mnt", strings.ToLower(loc.Share)) credentials := "" if cfg.Username != "" { credentials = fmt.Sprintf(",username=%s,password=***", cfg.Username) } return fmt.Sprintf( "%s is not mounted on this host. Either mount it and %s, for example:\n"+ " sudo mkdir -p %s && sudo mount -t cifs %s %s -o rw%s\n"+ "or set NAS_AUTO_MOUNT=true to have the recorder mount it (requires root)", source, suggestMountPointConfig(loc), example, source, example, credentials) } func suggestMountPointConfig(loc Location) string { if len(loc.Sub) == 0 { return "set NAS_OUTPUT_PATH to the mount point" } return fmt.Sprintf("set NAS_OUTPUT_PATH to the mount point plus %s", loc.SubPath()) }