In Windows, `Server` should allow a pseudo-directory for `/` which enumerates available drives

[powellnorma]

When I use sshfs host:/ mnt, the current working directory gets mounted to mnt.
Is it possible to let the sshfs server behave the way a cygwin compiled openssh server does, e.g. that it lists /c:, /d:, ... in the root directory?

[puellanivis]

This is not the issue board for the sshfs project? I don’t believe anyone here has knowledge of how this would be done, and it wouldn’t really be an appropriate place for it even if someone did.

You can checkout their project’s issue board her: https://github.com/libfuse/sshfs/issues?q=is%3Aissue

[powellnorma]

Isn't it the sftp server that answers with what the content of / is? Currently for some reason it just gives me the entries of the current working directory the sftp server was started in.

[puellanivis]

The sftp server does indeed answer what the contents of / are. If you’re running some sort of ssh server based on this library, and it is showing you the entries of the current working directory, then this is a matter for either: 1) your individual implementation of RequestServer or A) sshfs as we just use whatever path the client sends, and if it’s sending relative paths, then we’re going to share relative paths.

Without more details about how you’re actually using this package, we really cannot answer anything.

[powellnorma]

I use the example from here:
https://github.com/gliderlabs/ssh/blob/master/_examples/ssh-sftpserver/sftp.go

It seems to use the default RequestServer Handler? Do you have an idea why it behaves the way I described for /?

[puellanivis]

Hm, that code is not using RequestServer but instead is using Server. This is a very minimal wrapper around system calls, and limited in how useful it is.

After some trouble, I’ve managed to set up a repro. My behavior is that I get a listing of C:\ when I use cd / ; dir in sftp. This is the same as if I cd /c:/ ; dir. However, if I cd /d:/ ; dir I get a listing of that drive instead.

Getting this working is going to be a piece of work. This definitely isn’t anything easy, because there’s no actual directory to stat or readdir from to get an enumeration of available drives. So we would need to write a whole separate pathway to support one single pseudo-directory for only one OS, which handles the / case, and enumerates the windows drives… just even adding support to use a pseudo-directory in Server would be a pain, because right now our handles are all mapping directly to an actual *os.File which—as noted above—cannot exist for this pseudo-directory. And the Server implementation already has known limitations that we’re unwilling to address, because we would like people to switch to RequestServer as a more generic interface, rather than being a raw passthrough into the underlying filesystem.

😩 So, I’m sorry to give sad news, but I don’t think we’ll actually be able to get this feature done. If you want to sit down and invest the work necessary to get it done, we would consider a PR for this, as it’s not an unreasonable feature… just a lot of work, which I don’t think any of volunteers have time to help with.

[powellnorma]

I think it would make sense to put here, in handlePacket:

sftp/server.go

Lines 177 to 180 in 22452ea

	func handlePacket(s *Server, p orderedRequest) error {
	var rpkt responsePacket
	orderID := p.orderID()
	switch p := p.requestPacket.(type) {

a call to a new handleSepcialPath function, that is implemented per OS. In server_windows.go we then check if p.Path == "/" and if so handle it in a special way. For getting a list of logical drives we could use https://stackoverflow.com/a/23135463

What do you think about that approach?

And the Server implementation already has known limitations that we’re unwilling to address, because we would like people to switch to RequestServer as a more generic interface, rather than being a raw passthrough into the underlying filesystem

How would I implement it with that interface? Do I need to implement all the Handlers Interfaces myself? That seems like a lot of work, or am I missing something?

[puellanivis]

Again, one doesn’t just list a directory, first you SSH_FXP_OPENDIR and then you issue SSH_FXP_READDIR packets to read entries of that directory. This means we must work it into the handle system, which as noted, currently is a map[string]*os.File this will require reworking the whole of the handle system to allow an interface that incorporates all methods we use from os.File in order to also parallel implement the pseudo directory.

Do not use the code in that stackoverflow, use https://pkg.go.dev/golang.org/x/sys/windows#GetLogicalDrives also OMG, do not use the bitsToDrives given use:

func bitsToDrives(bitmap uint32) []string {
	var drive rune = 'A'
	var drives []string

	for bitmap != 0 {
		if bitmap&1 == 1 {
			drives = append(drives, string(drive))
		}
		drive++
		bitmap >>= 1
	}

	return drives
}

As for how you would implement it in the RequestServer I’m going to admit that I am less knowledgeable in that area. I’m not familiar with it, and how it would be implemented, but it should likely but significantly easier, but of course, with more code, since the interface is more flexible than just using the raw underlying filesystem.

[drakkan]

Hello and Happy New Year

How would I implement it with that interface? Do I need to implement all the Handlers Interfaces myself? That seems like a lot of work, or am I missing something?

Yes, you have to implement at least these 4 handlers/methods yourself and any other optional interface needed for your use case.

This may seem like a lot of work initially, but it allows you to make the SFTP server work the way you want and have much more control than using the old Server implementation.

[powellnorma]

Happy new year!

Again, one doesn’t just list a directory, first you SSH_FXP_OPENDIR and then you issue SSH_FXP_READDIR packets to read entries of that directory. This means we must work it into the handle system

I see handle is a string, which normally always just encodes a number. Why not make it such that in case of / on windows, instead of normal nextHandle the method sshFxpOpenPacket.respond stores the pair ("root-%d", nil) ? Then in sshFxpReaddirPacket.respond we check if strings.HasPrefix(p.Handle, "root-"), and if true handle it differently.

And for making sure that other methods don't get confused by the nil handle (in case the user for some reason requests other operations than "readdir" for that handle), we could adjust Server.getHandle to check if f is nil, and if so just act as if doesn't exist.

What do you think of that approach?

This may seem like a lot of work initially, but it allows you to make the SFTP server work the way you want and have much more control than using the old Server implementation.

Is there some example of a standard SFTP server I could use as a basis? Like Server but implemented via the Handlers Interface?

[drakkan]

Is there some example of a standard SFTP server I could use as a basis? Like Server but implemented via the Handlers Interface?

The example in the repo uses InMemHandler. Several projects uses the request server, for example SFTPGo and rclone. Take a look here for example

[drakkan]

Here is a simple example to use as base (review carefully the code before using it in production)

package main

import (
	"fmt"
	"io"
	"log"
	"net"
	"os"

	"github.com/pkg/sftp"
	"golang.org/x/crypto/ssh"
)

func main() {
	hostKey := []byte(`-----BEGIN OPENSSH PRIVATE KEY-----
b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
QyNTUxOQAAACAY/pePhhw4I5c/PP0RDZgNhbqggxvnlkObssNIDqJWLAAAAJBVB0cQVQdH
EAAAAAtzc2gtZWQyNTUxOQAAACAY/pePhhw4I5c/PP0RDZgNhbqggxvnlkObssNIDqJWLA
AAAEB+jbwnXNd0sypQhBp1TiJVb2y74QH/0ywKkh7B7/UxEhj+l4+GHDgjlz88/RENmA2F
uqCDG+eWQ5uyw0gOolYsAAAACW5pY29sYUBwMQECAwQ=
-----END OPENSSH PRIVATE KEY-----`)

	private, err := ssh.ParsePrivateKey(hostKey)
	if err != nil {
		log.Fatal(err)
	}
	config := &ssh.ServerConfig{
		PasswordCallback: func(c ssh.ConnMetadata, pass []byte) (*ssh.Permissions, error) {
			if c.User() == "testuser" && string(pass) == "tiger" {
				return nil, nil
			}
			return nil, fmt.Errorf("password rejected for %q", c.User())
		},
	}
	config.AddHostKey(private)

	listener, err := net.Listen("tcp", "0.0.0.0:20222")
	if err != nil {
		log.Fatal("failed to listen for connection", err)
	}
	fmt.Printf("Listening on %v\n", listener.Addr())

	nConn, err := listener.Accept()
	if err != nil {
		log.Fatal("failed to accept incoming connection", err)
	}

	// Before use, a handshake must be performed on the incoming net.Conn.
	sconn, chans, reqs, err := ssh.NewServerConn(nConn, config)
	if err != nil {
		log.Fatal("failed to handshake", err)
	}
	log.Println("login detected:", sconn.User())

	go ssh.DiscardRequests(reqs)

	for newChannel := range chans {
		// Channels have a type, depending on the application level
		// protocol intended. In the case of an SFTP session, this is "subsystem"
		// with a payload string of "<length=4>sftp"
		if newChannel.ChannelType() != "session" {
			newChannel.Reject(ssh.UnknownChannelType, "unknown channel type")
			continue
		}
		channel, requests, err := newChannel.Accept()
		if err != nil {
			log.Fatal("could not accept channel.", err)
		}

		// Sessions have out-of-band requests such as "shell",
		// "pty-req" and "env".  Here we handle only the
		// "subsystem" request.
		go func(in <-chan *ssh.Request) {
			for req := range in {
				ok := false
				switch req.Type {
				case "subsystem":
					if string(req.Payload[4:]) == "sftp" {
						ok = true
					}
				}
				req.Reply(ok, nil)
			}
		}(requests)

		h := &rsHandler{}
		server := sftp.NewRequestServer(channel, sftp.Handlers{
			FileGet:  h,
			FilePut:  h,
			FileCmd:  h,
			FileList: h,
		})
		if err := server.Serve(); err != nil {
			if err != io.EOF {
				log.Fatal("sftp server completed with error:", err)
			}
		}
		server.Close()
		log.Print("sftp client exited session.")
	}

}

type rsHandler struct{}

func (h *rsHandler) Fileread(r *sftp.Request) (io.ReaderAt, error) {
	f, err := os.Open(r.Filepath)
	if err != nil {
		return nil, err
	}
	return f, nil
}

func (h *rsHandler) Filewrite(r *sftp.Request) (io.WriterAt, error) {
	f, err := os.OpenFile(r.Filepath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0777)
	if err != nil {
		return nil, err
	}
	return f, nil
}

func (h *rsHandler) Filecmd(r *sftp.Request) error {
	switch r.Method {
	case "Rename":
		return os.Rename(r.Filepath, r.Target)
	case "Rmdir", "Remove":
		return os.Remove(r.Filepath)
	case "Mkdir":
		return os.Mkdir(r.Filepath, os.ModePerm)
	default:
		return sftp.ErrSSHFxOpUnsupported
	}
}

func (h *rsHandler) Filelist(r *sftp.Request) (l sftp.ListerAt, err error) {
	switch r.Method {
	case "List":
		f, err := os.Open(r.Filepath)
		if err != nil {
			return nil, err
		}
		files, err := f.Readdir(-1)
		f.Close()
		if err != nil {
			return nil, err
		}
		return listerAt(files), nil
	case "Stat":
		fi, err := os.Stat(r.Filepath)
		if err != nil {
			return nil, err
		}
		return listerAt([]os.FileInfo{fi}), nil
	default:
		return nil, sftp.ErrSSHFxOpUnsupported
	}
}

type listerAt []os.FileInfo

func (l listerAt) ListAt(f []os.FileInfo, offset int64) (int, error) {
	if offset >= int64(len(l)) {
		return 0, io.EOF
	}

	n := copy(f, l[offset:])
	if n < len(f) {
		return n, io.EOF
	}
	return n, nil
}

[puellanivis]

Again, one doesn’t just list a directory, first you SSH_FXP_OPENDIR and then you issue SSH_FXP_READDIR packets to read entries of that directory. This means we must work it into the handle system

I see handle is a string, which normally always just encodes a number. Why not make it such that in case of / on windows, instead of normal nextHandle the method sshFxpOpenPacket.respond stores the pair ("root-%d", nil) ? Then in sshFxpReaddirPacket.respond we check if strings.HasPrefix(p.Handle, "root-"), and if true handle it differently.

And for making sure that other methods don't get confused by the nil handle (in case the user for some reason requests other operations than "readdir" for that handle), we could adjust Server.getHandle to check if f is nil, and if so just act as if doesn't exist.

What do you think of that approach?

I mean, we could do something like this, but we would still need to implement a second pseudo *os.File. Basically, this wouldn’t actually save any effort over doing it the way I already said. It’s not hard work what I mentioned, it’s just a lot of work. And we’re all volunteers here, finding spare time during our day to provide support.

[powellnorma]

I mean, we could do something like this, but we would still need to implement a second pseudo *os.File

I might be missing something obvious, but why is that? In my understanding, all we need for the "virtual root" is to replace the "filling of sshFxpNamePacket.NameAttrs via f.Readdir" with a "fill sshFxpNamePacket.NameAttrs via a 'list logical drive letters' function"?

We can't copy into that folder anyways etc - So I think it might be fine to let Server.getHandle give an "handle does not exist" error. Are there any other legitimate file operations for this virtual directory, other than readdir?

And we’re all volunteers here, finding spare time during our day to provide support.

You are right, and it is appreciated! 🙂 My goal is to figure out how much work it would be to realize this, and why. I have the hope that it is not as much work as one might first think 🤞