package mountlib import (	"io"	"log"	"os"	"path/filepath"	"runtime"	"strings"	"time" 	"github.com/pkg/errors"	"github.com/rclone/rclone/cmd"	"github.com/rclone/rclone/fs"	"github.com/rclone/rclone/fs/config"	"github.com/rclone/rclone/fs/config/flags"	"github.com/rclone/rclone/vfs"	"github.com/rclone/rclone/vfs/vfsflags"	"github.com/spf13/cobra") // Options set by command line flagsvar (	DebugFUSE                        = false	AllowNonEmpty                    = false	AllowRoot                        = false	AllowOther                       = false	DefaultPermissions               = false	WritebackCache                   = false	Daemon                           = false	MaxReadAhead       fs.SizeSuffix = 128 * 1024	ExtraOptions       []string	ExtraFlags         []string	AttrTimeout        = 1 * time.Second // how long the kernel caches attribute for	VolumeName         string	NoAppleDouble      = true        // use noappledouble by default	NoAppleXattr       = false       // do not use noapplexattr by default	DaemonTimeout      time.Duration // OSXFUSE only	AsyncRead          = true        // do async reads by default) type (	// UnmountFn is called to unmount the file system	UnmountFn func() error	// MountFn is called to mount the file system	MountFn func(f fs.Fs, mountpoint string) (*vfs.VFS, <-chan error, func() error, error)) // Global constantsconst (	MaxLeafSize = 1024 // don't pass file names longer than this) func init() {	// DaemonTimeout defaults to non zero for macOS	if runtime.GOOS == "darwin" {		DaemonTimeout = 15 * time.Minute	}} // Check is folder is emptyfunc checkMountEmpty(mountpoint string) error {	fp, fpErr := os.Open(mountpoint) 	if fpErr != nil {		return errors.Wrap(fpErr, "Can not open: "+mountpoint)	}	defer fs.CheckClose(fp, &fpErr) 	_, fpErr = fp.Readdirnames(1) 	// directory is not empty	if fpErr != io.EOF {		var e error		var errorMsg = "Directory is not empty: " + mountpoint + " If you want to mount it anyway use: --allow-non-empty option"		if fpErr == nil {			e = errors.New(errorMsg)		} else {			e = errors.Wrap(fpErr, errorMsg)		}		return e	}	return nil} // Check the root doesn't overlap the mountpointfunc checkMountpointOverlap(root, mountpoint string) error {	abs := func(x string) string {		if absX, err := filepath.EvalSymlinks(x); err == nil {			x = absX		}		if absX, err := filepath.Abs(x); err == nil {			x = absX		}		x = filepath.ToSlash(x)		if !strings.HasSuffix(x, "/") {			x += "/"		}		return x	}	rootAbs, mountpointAbs := abs(root), abs(mountpoint)	if strings.HasPrefix(rootAbs, mountpointAbs) || strings.HasPrefix(mountpointAbs, rootAbs) {		return errors.Errorf("mount point %q and directory to be mounted %q mustn't overlap", mountpoint, root)	}	return nil} // NewMountCommand makes a mount command with the given name and Mount functionfunc NewMountCommand(commandName string, hidden bool, Mount func(f fs.Fs, mountpoint string) error) *cobra.Command {	var commandDefinition = &cobra.Command{		Use:    commandName + " remote:path /path/to/mountpoint",		Hidden: hidden,		Short:  `Mount the remote as file system on a mountpoint.`,		Long: `rclone ` + commandName + ` allows Linux, FreeBSD, macOS and Windows tomount any of Rclone's cloud storage systems as a file system withFUSE. First set up your remote using ` + "`rclone config`" + `.  Check it works with ` + "`rclone ls`" + ` etc. You can either run mount in foreground mode or background (daemon) mode. Mount runs inforeground mode by default, use the --daemon flag to specify background mode mode.Background mode is only supported on Linux and OSX, you can only run mount inforeground mode on Windows. On Linux/macOS/FreeBSD Start the mount like this where ` + "`/path/to/local/mount`" + `is an **empty** **existing** directory.     rclone ` + commandName + ` remote:path/to/files /path/to/local/mount Or on Windows like this where ` + "`X:`" + ` is an unused drive letteror use a path to **non-existent** directory.     rclone ` + commandName + ` remote:path/to/files X:    rclone ` + commandName + ` remote:path/to/files C:\path\to\nonexistent\directory When running in background mode the user will have to stop the mount manually (specified below). When the program ends while in foreground mode, either via Ctrl+C or receivinga SIGINT or SIGTERM signal, the mount is automatically stopped. The umount operation can fail, for example when the mountpoint is busy.When that happens, it is the user's responsibility to stop the mount manually. Stopping the mount manually:     # Linux    fusermount -u /path/to/local/mount    # OS X    umount /path/to/local/mount ### Installing on Windows To run rclone ` + commandName + ` on Windows, you will need todownload and install [WinFsp](http://www.secfs.net/winfsp/). [WinFsp](https://github.com/billziss-gh/winfsp) is an open sourceWindows File System Proxy which makes it easy to write user space filesystems for Windows.  It provides a FUSE emulation layer which rcloneuses combination with[cgofuse](https://github.com/billziss-gh/cgofuse).  Both of thesepackages are by Bill Zissimopoulos who was very helpful during theimplementation of rclone ` + commandName + ` for Windows. #### Windows caveats Note that drives created as Administrator are not visible by otheraccounts (including the account that was elevated asAdministrator). So if you start a Windows drive from an AdministrativeCommand Prompt and then try to access the same drive from Explorer(which does not run as Administrator), you will not be able to see thenew drive. The easiest way around this is to start the drive from a normalcommand prompt. It is also possible to start a drive from the SYSTEMaccount (using [the WinFsp.Launcherinfrastructure](https://github.com/billziss-gh/winfsp/wiki/WinFsp-Service-Architecture))which creates drives accessible for everyone on the system oralternatively using [the nssm service manager](https://nssm.cc/usage). #### Mount as a network drive By default, rclone will mount the remote as a normal drive. However,you can also mount it as a **Network Drive** (or **Network Share**, asmentioned in some places) Unlike other systems, Windows provides a different filesystem type fornetwork drives.  Windows and other programs treat the network drivesand fixed/removable drives differently: In network drives, many I/Ooperations are optimized, as the high latency and low reliability(compared to a normal drive) of a network is expected. Although many people prefer network shares to be mounted as normalsystem drives, this might cause some issues, such as programs notworking as expected or freezes and errors while operating with themounted remote in Windows Explorer. If you experience any of those,consider mounting rclone remotes as network shares, as Windows expectsnormal drives to be fast and reliable, while cloud storage is far fromthat.  See also [Limitations](#limitations) section below for moreinfo Add "--fuse-flag --VolumePrefix=\server\share" to your "mount"command, **replacing "share" with any other name of your choice if youare mounting more than one remote**. Otherwise, the mountpoints willconflict and your mounted filesystems will overlap. [Read more about drive mapping](https://en.wikipedia.org/wiki/Drive_mapping) ### Limitations Without the use of "--vfs-cache-mode" this can only write filessequentially, it can only seek when reading.  This means that manyapplications won't work with their files on an rclone mount without"--vfs-cache-mode writes" or "--vfs-cache-mode full".  See the [FileCaching](#file-caching) section for more info. The bucket based remotes (eg Swift, S3, Google Compute Storage, B2,Hubic) do not support the concept of empty directories, so emptydirectories will have a tendency to disappear once they fall out ofthe directory cache. Only supported on Linux, FreeBSD, OS X and Windows at the moment. ### rclone ` + commandName + ` vs rclone sync/copy File systems expect things to be 100% reliable, whereas cloud storagesystems are a long way from 100% reliable. The rclone sync/copycommands cope with this with lots of retries.  However rclone ` + commandName + `can't use retries in the same way without making local copies of theuploads. Look at the [file caching](#file-caching)for solutions to make ` + commandName + ` more reliable. ### Attribute caching You can use the flag --attr-timeout to set the time the kernel cachesthe attributes (size, modification time etc) for directory entries. The default is "1s" which caches files just long enough to avoidtoo many callbacks to rclone from the kernel. In theory 0s should be the correct value for filesystems which canchange outside the control of the kernel. However this causes quite afew problems such as[rclone using too much memory](https://github.com/rclone/rclone/issues/2157),[rclone not serving files to samba](https://forum.rclone.org/t/rclone-1-39-vs-1-40-mount-issue/5112)and [excessive time listing directories](https://github.com/rclone/rclone/issues/2095#issuecomment-371141147). The kernel can cache the info about a file for the time given by"--attr-timeout". You may see corruption if the remote file changeslength during this window.  It will show up as either a truncated fileor a file with garbage on the end.  With "--attr-timeout 1s" this isvery unlikely but not impossible.  The higher you set "--attr-timeout"the more likely it is.  The default setting of "1s" is the lowestsetting which mitigates the problems above. If you set it higher ('10s' or '1m' say) then the kernel will callback to rclone less often making it more efficient, however there ismore chance of the corruption issue above. If files don't change on the remote outside of the control of rclonethen there is no chance of corruption. This is the same as setting the attr_timeout option in mount.fuse. ### Filters Note that all the rclone filters can be used to select a subset of thefiles to be visible in the mount. ### systemd When running rclone ` + commandName + ` as a systemd service, it is possibleto use Type=notify. In this case the service will enter the started stateafter the mountpoint has been successfully set up.Units having the rclone ` + commandName + ` service specified as a requirementwill see all files and folders immediately in this mode. ### chunked reading ### --vfs-read-chunk-size will enable reading the source objects in parts.This can reduce the used download quota for some remotes by requesting only chunksfrom the remote that are actually read at the cost of an increased number of requests. When --vfs-read-chunk-size-limit is also specified and greater than --vfs-read-chunk-size,the chunk size for each open file will get doubled for each chunk read, until thespecified value is reached. A value of -1 will disable the limit and the chunk size willgrow indefinitely. With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the followingparts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on.When --vfs-read-chunk-size-limit 500M is specified, the result would be0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Chunked reading will only work with --vfs-cache-mode < full, as the file will alwaysbe copied to the vfs cache before opening with --vfs-cache-mode full.` + vfs.Help,		Run: func(command *cobra.Command, args []string) {			cmd.CheckArgs(2, 2, command, args) 			if Daemon {				config.PassConfigKeyForDaemonization = true			} 			mountpoint := args[1]			fdst := cmd.NewFsDir(args)			if fdst.Name() == "" || fdst.Name() == "local" {				err := checkMountpointOverlap(fdst.Root(), mountpoint)				if err != nil {					log.Fatalf("Fatal error: %v", err)				}			} 			// Show stats if the user has specifically requested them			if cmd.ShowStats() {				defer cmd.StartStats()()			} 			// Skip checkMountEmpty if --allow-non-empty flag is used or if			// the Operating System is Windows			if !AllowNonEmpty && runtime.GOOS != "windows" {				err := checkMountEmpty(mountpoint)				if err != nil {					log.Fatalf("Fatal error: %v", err)				}			} else if AllowNonEmpty && runtime.GOOS == "windows" {				fs.Logf(nil, "--allow-non-empty flag does nothing on Windows")			} 			// Work out the volume name, removing special			// characters from it if necessary			if VolumeName == "" {				VolumeName = fdst.Name() + ":" + fdst.Root()			}			VolumeName = strings.Replace(VolumeName, ":", " ", -1)			VolumeName = strings.Replace(VolumeName, "/", " ", -1)			VolumeName = strings.TrimSpace(VolumeName)			if runtime.GOOS == "windows" && len(VolumeName) > 32 {				VolumeName = VolumeName[:32]			} 			// Start background task if --background is specified			if Daemon {				daemonized := startBackgroundMode()				if daemonized {					return				}			} 			err := Mount(fdst, mountpoint)			if err != nil {				log.Fatalf("Fatal error: %v", err)			}		},	} 	// Register the command	cmd.Root.AddCommand(commandDefinition) 	// Add flags	cmdFlags := commandDefinition.Flags()	flags.BoolVarP(cmdFlags, &DebugFUSE, "debug-fuse", "", DebugFUSE, "Debug the FUSE internals - needs -v.")	// mount options	flags.BoolVarP(cmdFlags, &AllowNonEmpty, "allow-non-empty", "", AllowNonEmpty, "Allow mounting over a non-empty directory (not Windows).")	flags.BoolVarP(cmdFlags, &AllowRoot, "allow-root", "", AllowRoot, "Allow access to root user.")	flags.BoolVarP(cmdFlags, &AllowOther, "allow-other", "", AllowOther, "Allow access to other users.")	flags.BoolVarP(cmdFlags, &DefaultPermissions, "default-permissions", "", DefaultPermissions, "Makes kernel enforce access control based on the file mode.")	flags.BoolVarP(cmdFlags, &WritebackCache, "write-back-cache", "", WritebackCache, "Makes kernel buffer writes before sending them to rclone. Without this, writethrough caching is used.")	flags.FVarP(cmdFlags, &MaxReadAhead, "max-read-ahead", "", "The number of bytes that can be prefetched for sequential reads.")	flags.DurationVarP(cmdFlags, &AttrTimeout, "attr-timeout", "", AttrTimeout, "Time for which file/directory attributes are cached.")	flags.StringArrayVarP(cmdFlags, &ExtraOptions, "option", "o", []string{}, "Option for libfuse/WinFsp. Repeat if required.")	flags.StringArrayVarP(cmdFlags, &ExtraFlags, "fuse-flag", "", []string{}, "Flags or arguments to be passed direct to libfuse/WinFsp. Repeat if required.")	flags.BoolVarP(cmdFlags, &Daemon, "daemon", "", Daemon, "Run mount as a daemon (background mode).")	flags.StringVarP(cmdFlags, &VolumeName, "volname", "", VolumeName, "Set the volume name (not supported by all OSes).")	flags.DurationVarP(cmdFlags, &DaemonTimeout, "daemon-timeout", "", DaemonTimeout, "Time limit for rclone to respond to kernel (not supported by all OSes).")	flags.BoolVarP(cmdFlags, &AsyncRead, "async-read", "", AsyncRead, "Use asynchronous reads.") 	if runtime.GOOS == "darwin" {		flags.BoolVarP(cmdFlags, &NoAppleDouble, "noappledouble", "", NoAppleDouble, "Sets the OSXFUSE option noappledouble.")		flags.BoolVarP(cmdFlags, &NoAppleXattr, "noapplexattr", "", NoAppleXattr, "Sets the OSXFUSE option noapplexattr.")	} 	// Add in the generic flags	vfsflags.AddFlags(cmdFlags) 	return commandDefinition} // ClipBlocks clips the blocks pointed to the OS maxfunc ClipBlocks(b *uint64) {	var max uint64	switch runtime.GOOS {	case "windows":		if runtime.GOARCH == "386" {			max = (1 << 32) - 1		} else {			max = (1 << 43) - 1		}	case "darwin":		// OSX FUSE only supports 32 bit number of blocks		// https://github.com/osxfuse/osxfuse/issues/396		max = (1 << 32) - 1	default:		// no clipping		return	}	if *b > max {		*b = max	}}