419 lines
9.2 KiB
Go
419 lines
9.2 KiB
Go
// Command ollie-9p is a 9P client for interacting with olliesrv.
|
|
// Auto-discovers the server via $NAMESPACE and identity via $OLLIE_UNAME.
|
|
//
|
|
// Usage:
|
|
//
|
|
// ollie-9p [-a addr] cmd args...
|
|
//
|
|
// Commands:
|
|
//
|
|
// read path read file contents to stdout
|
|
// write path write stdin to file
|
|
// rdwr path write stdin then read response (request-response files)
|
|
// stat path print file metadata
|
|
// ls [-l] [-d] path list directory contents
|
|
// create path create a file
|
|
// rm path remove a file
|
|
// mkdir path create a directory
|
|
// mv old new rename/move a file or directory (Twstat)
|
|
package main
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"strings"
|
|
"text/tabwriter"
|
|
"time"
|
|
|
|
"9fans.net/go/plan9"
|
|
"9fans.net/go/plan9/client"
|
|
)
|
|
|
|
var (
|
|
addr = flag.String("a", "", "server address (default: unix!$NAMESPACE/ollie)")
|
|
)
|
|
|
|
func usage() {
|
|
fmt.Fprintf(os.Stderr, "usage: ollie-9p [-a addr] cmd args...\n")
|
|
fmt.Fprintf(os.Stderr, "commands: read write rdwr stat ls create rm mkdir mv\n")
|
|
os.Exit(1)
|
|
}
|
|
|
|
func fatalf(format string, args ...any) {
|
|
fmt.Fprintf(os.Stderr, "ollie-9p: "+format+"\n", args...)
|
|
os.Exit(1)
|
|
}
|
|
|
|
func main() {
|
|
flag.Usage = usage
|
|
flag.Parse()
|
|
if flag.NArg() < 1 {
|
|
usage()
|
|
}
|
|
|
|
cmd := flag.Arg(0)
|
|
args := flag.Args()[1:]
|
|
|
|
switch cmd {
|
|
case "read":
|
|
openMarker := false
|
|
if len(args) == 2 && args[0] == "--open-marker" {
|
|
openMarker = true
|
|
args = args[1:]
|
|
}
|
|
if len(args) != 1 {
|
|
fatalf("usage: ollie-9p read [--open-marker] path")
|
|
}
|
|
cmdRead(args[0], openMarker)
|
|
case "write":
|
|
if len(args) != 1 {
|
|
fatalf("usage: ollie-9p write path")
|
|
}
|
|
cmdWrite(args[0])
|
|
case "rdwr":
|
|
if len(args) != 1 {
|
|
fatalf("usage: ollie-9p rdwr path")
|
|
}
|
|
cmdRdwr(args[0])
|
|
case "stat":
|
|
if len(args) != 1 {
|
|
fatalf("usage: ollie-9p stat path")
|
|
}
|
|
cmdStat(args[0])
|
|
case "ls":
|
|
cmdLs(args)
|
|
case "create":
|
|
if len(args) != 1 {
|
|
fatalf("usage: ollie-9p create path")
|
|
}
|
|
cmdCreate(args[0])
|
|
case "rm":
|
|
if len(args) != 1 {
|
|
fatalf("usage: ollie-9p rm path")
|
|
}
|
|
cmdRemove(args[0])
|
|
case "mkdir":
|
|
if len(args) != 1 {
|
|
fatalf("usage: ollie-9p mkdir path")
|
|
}
|
|
cmdMkdir(args[0])
|
|
case "mv":
|
|
if len(args) != 2 {
|
|
fatalf("usage: ollie-9p mv old new")
|
|
}
|
|
cmdMv(args[0], args[1])
|
|
default:
|
|
fatalf("unknown command: %s", cmd)
|
|
}
|
|
}
|
|
|
|
func dial() *client.Fsys {
|
|
address := *addr
|
|
if address == "" {
|
|
ns := os.Getenv("NAMESPACE")
|
|
if ns == "" {
|
|
ns = client.Namespace()
|
|
}
|
|
if ns == "" {
|
|
fatalf("cannot determine namespace; use -a flag or set $NAMESPACE")
|
|
}
|
|
address = ns + "/ollie"
|
|
}
|
|
// Strip plan9port-style unix! prefix if present
|
|
address = strings.TrimPrefix(address, "unix!")
|
|
|
|
aname := os.Getenv("OLLIE_UNAME")
|
|
if aname == "" {
|
|
if os.Getenv("OLLIE_SESSION_ID") != "" {
|
|
fatalf("OLLIE_UNAME not set")
|
|
}
|
|
// Outside a session context, use $USER
|
|
aname = os.Getenv("USER")
|
|
if aname == "" {
|
|
aname = "none"
|
|
}
|
|
}
|
|
// If OLLIE_SESSION_ID is set, we're inside a session and must use OLLIE_UNAME.
|
|
// If it's not set, we're outside (e.g. GUI) and use $USER.
|
|
// The GUI calls renameSession which spawns ollie-9p without OLLIE_SESSION_ID,
|
|
// so it falls through to $USER. That's correct — the server accepts $USER
|
|
// as a valid attach identity for non-session operations.
|
|
|
|
fsys, err := mountWithAname(address, aname)
|
|
if err != nil {
|
|
fatalf("dial %s: %v", address, err)
|
|
}
|
|
return fsys
|
|
}
|
|
|
|
// mountWithAname connects and attaches with a specific aname.
|
|
// Address format: "unix!/path" or "/path" for unix sockets, "tcp!host:port" or "host:port" for TCP.
|
|
func mountWithAname(address, aname string) (*client.Fsys, error) {
|
|
network := "unix"
|
|
addr := address
|
|
if strings.HasPrefix(address, "tcp!") {
|
|
network = "tcp"
|
|
addr = strings.TrimPrefix(address, "tcp!")
|
|
} else if strings.HasPrefix(address, "unix!") {
|
|
addr = strings.TrimPrefix(address, "unix!")
|
|
} else if strings.Contains(address, ":") && !strings.HasPrefix(address, "/") {
|
|
// Looks like host:port, assume TCP
|
|
network = "tcp"
|
|
}
|
|
conn, err := client.Dial(network, addr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fsys, err := conn.Attach(nil, getuser(), aname)
|
|
if err != nil {
|
|
conn.Close()
|
|
return nil, err
|
|
}
|
|
return fsys, nil
|
|
}
|
|
|
|
func getuser() string {
|
|
if u := os.Getenv("USER"); u != "" {
|
|
return u
|
|
}
|
|
return "none"
|
|
}
|
|
|
|
func cmdRead(path string, openMarker bool) {
|
|
fsys := dial()
|
|
fid, err := fsys.Open(path, plan9.OREAD)
|
|
if err != nil {
|
|
fatalf("open %s: %v", path, err)
|
|
}
|
|
defer fid.Close()
|
|
// This marker is emitted only after the remote 9P open succeeds. It lets
|
|
// connection-aware GUI clients distinguish an opened operation from a
|
|
// merely started local helper process.
|
|
if openMarker {
|
|
fmt.Fprintln(os.Stderr, "Open")
|
|
}
|
|
if _, err := io.Copy(os.Stdout, fid); err != nil {
|
|
fatalf("read %s: %v", path, err)
|
|
}
|
|
}
|
|
|
|
func cmdWrite(path string) {
|
|
fsys := dial()
|
|
fid, err := fsys.Open(path, plan9.OWRITE)
|
|
if err != nil {
|
|
fatalf("open %s: %v", path, err)
|
|
}
|
|
if _, err := io.Copy(fid, os.Stdin); err != nil {
|
|
fid.Close()
|
|
fatalf("write %s: %v", path, err)
|
|
}
|
|
// Close flushes buffered writes; errors (e.g., validation failures)
|
|
// are returned via Rclunk.
|
|
if err := fid.Close(); err != nil {
|
|
fatalf("close %s: %v", path, err)
|
|
}
|
|
}
|
|
|
|
func cmdRdwr(path string) {
|
|
fsys := dial()
|
|
fid, err := fsys.Open(path, plan9.ORDWR)
|
|
if err != nil {
|
|
fatalf("open %s: %v", path, err)
|
|
}
|
|
|
|
// Write stdin
|
|
data, err := io.ReadAll(os.Stdin)
|
|
if err != nil {
|
|
fid.Close()
|
|
fatalf("read stdin: %v", err)
|
|
}
|
|
if _, err := fid.Write(data); err != nil {
|
|
fid.Close()
|
|
fatalf("write %s: %v", path, err)
|
|
}
|
|
|
|
// Seek back to 0 and read response
|
|
if _, err := fid.Seek(0, 0); err != nil {
|
|
fid.Close()
|
|
fatalf("seek %s: %v", path, err)
|
|
}
|
|
if _, err := io.Copy(os.Stdout, fid); err != nil {
|
|
fid.Close()
|
|
fatalf("read %s: %v", path, err)
|
|
}
|
|
if err := fid.Close(); err != nil {
|
|
fatalf("close %s: %v", path, err)
|
|
}
|
|
}
|
|
|
|
func cmdStat(path string) {
|
|
fsys := dial()
|
|
dir, err := fsys.Stat(path)
|
|
if err != nil {
|
|
fatalf("stat %s: %v", path, err)
|
|
}
|
|
printDir(dir)
|
|
}
|
|
|
|
func cmdLs(args []string) {
|
|
fs := flag.NewFlagSet("ls", flag.ExitOnError)
|
|
long := fs.Bool("l", false, "long format")
|
|
dirOnly := fs.Bool("d", false, "list directory itself, not contents")
|
|
fs.Parse(args)
|
|
|
|
paths := fs.Args()
|
|
if len(paths) == 0 {
|
|
paths = []string{"/"}
|
|
}
|
|
|
|
fsys := dial()
|
|
|
|
for _, path := range paths {
|
|
if *dirOnly {
|
|
dir, err := fsys.Stat(path)
|
|
if err != nil {
|
|
fatalf("stat %s: %v", path, err)
|
|
}
|
|
if *long {
|
|
printDir(dir)
|
|
} else {
|
|
fmt.Println(dir.Name)
|
|
}
|
|
continue
|
|
}
|
|
|
|
dir, err := fsys.Stat(path)
|
|
if err != nil {
|
|
fatalf("stat %s: %v", path, err)
|
|
}
|
|
|
|
if dir.Mode&plan9.DMDIR == 0 {
|
|
// It's a file
|
|
if *long {
|
|
printDir(dir)
|
|
} else {
|
|
fmt.Println(dir.Name)
|
|
}
|
|
continue
|
|
}
|
|
|
|
// It's a directory — list contents
|
|
fid, err := fsys.Open(path, plan9.OREAD)
|
|
if err != nil {
|
|
fatalf("open %s: %v", path, err)
|
|
}
|
|
dirs, err := fid.Dirreadall()
|
|
fid.Close()
|
|
if err != nil {
|
|
fatalf("dirread %s: %v", path, err)
|
|
}
|
|
if *long {
|
|
for _, d := range dirs {
|
|
printDir(d)
|
|
}
|
|
} else {
|
|
for _, d := range dirs {
|
|
fmt.Println(d.Name)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func cmdCreate(path string) {
|
|
fsys := dial()
|
|
dir, name := splitPath(path)
|
|
|
|
parent, err := fsys.Open(dir, plan9.OREAD)
|
|
if err != nil {
|
|
fatalf("open %s: %v", dir, err)
|
|
}
|
|
defer parent.Close()
|
|
|
|
_, err = parent.Walk(name)
|
|
if err == nil {
|
|
fatalf("%s: already exists", path)
|
|
}
|
|
|
|
fid, err := fsys.Create(path, plan9.OWRITE, 0666)
|
|
if err != nil {
|
|
fatalf("create %s: %v", path, err)
|
|
}
|
|
fid.Close()
|
|
}
|
|
|
|
func cmdRemove(path string) {
|
|
fsys := dial()
|
|
if err := fsys.Remove(path); err != nil {
|
|
fatalf("rm %s: %v", path, err)
|
|
}
|
|
}
|
|
|
|
func cmdMkdir(path string) {
|
|
fsys := dial()
|
|
fid, err := fsys.Create(path, plan9.OREAD, plan9.DMDIR|0755)
|
|
if err != nil {
|
|
fatalf("mkdir %s: %v", path, err)
|
|
}
|
|
fid.Close()
|
|
}
|
|
|
|
func printDir(d *plan9.Dir) {
|
|
w := tabwriter.NewWriter(os.Stdout, 0, 8, 1, ' ', 0)
|
|
modeStr := modeString(d.Mode)
|
|
t := time.Unix(int64(d.Mtime), 0).Format("Jan _2 15:04")
|
|
fmt.Fprintf(w, "%s\t%s\t%s\t%d\t%s\t%s\n", modeStr, d.Uid, d.Gid, d.Length, t, d.Name)
|
|
w.Flush()
|
|
}
|
|
|
|
func modeString(mode plan9.Perm) string {
|
|
var buf [10]byte
|
|
if mode&plan9.DMDIR != 0 {
|
|
buf[0] = 'd'
|
|
} else {
|
|
buf[0] = '-'
|
|
}
|
|
const rwx = "rwx"
|
|
for i := 0; i < 3; i++ {
|
|
for j := 0; j < 3; j++ {
|
|
if mode&(1<<uint(8-i*3-j)) != 0 {
|
|
buf[1+i*3+j] = rwx[j]
|
|
} else {
|
|
buf[1+i*3+j] = '-'
|
|
}
|
|
}
|
|
}
|
|
return string(buf[:])
|
|
}
|
|
|
|
func cmdMv(oldPath, newPath string) {
|
|
fsys := dial()
|
|
// Twstat takes a destination basename. Both paths must refer to the
|
|
// same directory; normalize redundant trailing slashes before comparing.
|
|
oldPath = strings.TrimRight(oldPath, "/")
|
|
newPath = strings.TrimRight(newPath, "/")
|
|
oldParent, _ := splitPath(oldPath)
|
|
newParent, newLeaf := splitPath(newPath)
|
|
if oldParent != newParent {
|
|
fatalf("mv: old and new paths must be in the same directory (%s != %s)", oldParent, newParent)
|
|
}
|
|
if newLeaf == "" || newLeaf == "." || newLeaf == ".." {
|
|
fatalf("mv: invalid destination %q", newPath)
|
|
}
|
|
if err := fsys.Wstat(oldPath, &plan9.Dir{Name: newLeaf}); err != nil {
|
|
fatalf("mv %s %s: %v", oldPath, newPath, err)
|
|
}
|
|
}
|
|
|
|
func splitPath(path string) (string, string) {
|
|
i := strings.LastIndex(path, "/")
|
|
if i < 0 {
|
|
return "/", path
|
|
}
|
|
if i == 0 {
|
|
return "/", path[1:]
|
|
}
|
|
return path[:i], path[i+1:]
|
|
}
|