1 package main
2 
3 import (
4 	"bytes"
5 	"context"
6 	"flag"
7 	"fmt"
8 	"io"
9 	"log"
10 	"net"
11 	"net/http"
12 	_ "net/http/pprof"
13 	"os"
14 	"path"
15 	"strings"
16 	"text/tabwriter"
17 	"time"
18 
19 	"git.omarpolo.com/go-p9p"
20 	"github.com/chzyer/readline"
21 )
22 
23 var addr string
24 
25 func init() {
26 	flag.StringVar(&addr, "addr", ":5640", "addr of 9p service")
27 }
28 
29 func main() {
30 	go func() {
31 		log.Println(http.ListenAndServe("localhost:6060", nil))
32 	}()
33 
34 	ctx := context.Background()
35 	log.SetFlags(0)
36 	flag.Parse()
37 
38 	proto := "tcp"
39 	if strings.HasPrefix(addr, "unix:") {
40 		proto = "unix"
41 		addr = addr[5:]
42 	}
43 
44 	log.Println("dialing", addr)
45 	conn, err := net.Dial(proto, addr)
46 	if err != nil {
47 		log.Fatal(err)
48 	}
49 
50 	csession, err := p9p.NewSession(ctx, conn)
51 	if err != nil {
52 		log.Fatalln(err)
53 	}
54 
55 	commander := &fsCommander{
56 		ctx:     context.Background(),
57 		session: csession,
58 		pwd:     "/",
59 		stdout:  os.Stdout,
60 		stderr:  os.Stderr,
61 	}
62 
63 	completer := readline.NewPrefixCompleter(
64 		readline.PcItem("ls"),
65 		// readline.PcItem("find"),
66 		readline.PcItem("stat"),
67 		readline.PcItem("cat"),
68 		readline.PcItem("cd"),
69 		readline.PcItem("pwd"),
70 	)
71 
72 	rl, err := readline.NewEx(&readline.Config{
73 		HistoryFile:  ".history",
74 		AutoComplete: completer,
75 	})
76 	if err != nil {
77 		log.Fatalln(err)
78 	}
79 	commander.readline = rl
80 
81 	msize, version := commander.session.Version()
82 	if err != nil {
83 		log.Fatalln(err)
84 	}
85 	log.Println("9p version", version, msize)
86 
87 	// attach root
88 	commander.nextfid = 1
89 	if _, err := commander.session.Attach(commander.ctx, commander.nextfid, p9p.NOFID, "anyone", "/"); err != nil {
90 		log.Fatalln(err)
91 	}
92 	commander.rootfid = commander.nextfid
93 	commander.nextfid++
94 
95 	// clone the pwd fid so we can clunk it
96 	if _, err := commander.session.Walk(commander.ctx, commander.rootfid, commander.nextfid); err != nil {
97 		log.Fatalln(err)
98 	}
99 	commander.pwdfid = commander.nextfid
100 	commander.nextfid++
101 
102 	for {
103 		commander.readline.SetPrompt(fmt.Sprintf("%s 🐳 > ", commander.pwd))
104 
105 		line, err := rl.Readline()
106 		if err != nil {
107 			log.Fatalln("error: ", err)
108 		}
109 
110 		if line == "" {
111 			continue
112 		}
113 
114 		args := strings.Fields(line)
115 
116 		name := args[0]
117 		var cmd func(ctx context.Context, args ...string) error
118 
119 		switch name {
120 		case "ls":
121 			cmd = commander.cmdls
122 		case "cd":
123 			cmd = commander.cmdcd
124 		case "pwd":
125 			cmd = commander.cmdpwd
126 		case "cat":
127 			cmd = commander.cmdcat
128 		case "stat":
129 			cmd = commander.cmdstat
130 		default:
131 			cmd = func(ctx context.Context, args ...string) error {
132 				return fmt.Errorf("command not implemented")
133 			}
134 		}
135 
136 		ctx, _ = context.WithTimeout(commander.ctx, 5*time.Second)
137 		if err := cmd(ctx, args[1:]...); err != nil {
138 			if err == p9p.ErrClosed {
139 				log.Println("connection closed, shutting down")
140 				return
141 			}
142 
143 			log.Printf("👹 %s: %v", name, err)
144 		}
145 	}
146 }
147 
148 type fsCommander struct {
149 	ctx     context.Context
150 	session p9p.Session
151 	pwd     string
152 	pwdfid  p9p.Fid
153 	rootfid p9p.Fid
154 
155 	nextfid p9p.Fid
156 
157 	readline *readline.Instance
158 	stdout   io.Writer
159 	stderr   io.Writer
160 }
161 
162 func (c *fsCommander) cmdls(ctx context.Context, args ...string) error {
163 	ps := []string{c.pwd}
164 	if len(args) > 0 {
165 		ps = args
166 	}
167 
168 	wr := tabwriter.NewWriter(c.stdout, 0, 8, 8, ' ', 0)
169 
170 	for _, p := range ps {
171 		// create a header if have more than one path.
172 		if len(ps) > 1 {
173 			fmt.Fprintln(wr, p+":")
174 		}
175 
176 		if !path.IsAbs(p) {
177 			p = path.Join(c.pwd, p)
178 		}
179 
180 		targetfid := c.nextfid
181 		c.nextfid++
182 		components := strings.Split(strings.Trim(p, "/"), "/")
183 		if _, err := c.session.Walk(ctx, c.rootfid, targetfid, components...); err != nil {
184 			return err
185 		}
186 		defer c.session.Clunk(ctx, targetfid)
187 
188 		_, iounit, err := c.session.Open(ctx, targetfid, p9p.OREAD)
189 		if err != nil {
190 			return err
191 		}
192 
193 		if iounit < 1 {
194 			msize, _ := c.session.Version()
195 			iounit = uint32(msize - 24) // size of message max minus fcall io header (Rread)
196 		}
197 
198 		p := make([]byte, iounit)
199 
200 		n, err := c.session.Read(ctx, targetfid, p, 0)
201 		if err != nil {
202 			return err
203 		}
204 
205 		rd := bytes.NewReader(p[:n])
206 		codec := p9p.NewCodec() // TODO(stevvooe): Need way to resolve codec based on session.
207 		for {
208 			var d p9p.Dir
209 			if err := p9p.DecodeDir(codec, rd, &d); err != nil {
210 				if err == io.EOF {
211 					break
212 				}
213 
214 				return err
215 			}
216 
217 			fmt.Fprintf(wr, "%v\t%v\t%v\t%s\n", os.FileMode(d.Mode), d.Length, d.ModTime, d.Name)
218 		}
219 
220 		if len(ps) > 1 {
221 			fmt.Fprintln(wr, "")
222 		}
223 	}
224 
225 	// all output is dumped only after success.
226 	return wr.Flush()
227 }
228 
229 func (c *fsCommander) cmdcd(ctx context.Context, args ...string) error {
230 	var p string
231 	switch len(args) {
232 	case 0:
233 		p = "/"
234 	case 1:
235 		p = args[0]
236 	default:
237 		return fmt.Errorf("cd: invalid args: %v", args)
238 	}
239 
240 	if !path.IsAbs(p) {
241 		p = path.Join(c.pwd, p)
242 	}
243 
244 	targetfid := c.nextfid
245 	c.nextfid++
246 	components := strings.Split(strings.TrimSpace(strings.Trim(p, "/")), "/")
247 	if _, err := c.session.Walk(c.ctx, c.rootfid, targetfid, components...); err != nil {
248 		return err
249 	}
250 	defer c.session.Clunk(c.ctx, c.pwdfid)
251 
252 	log.Println("cd", p, targetfid)
253 	c.pwd = p
254 	c.pwdfid = targetfid
255 
256 	return nil
257 }
258 
259 func (c *fsCommander) cmdstat(ctx context.Context, args ...string) error {
260 	ps := []string{c.pwd}
261 	if len(args) > 0 {
262 		ps = args
263 	}
264 
265 	wr := tabwriter.NewWriter(c.stdout, 0, 8, 8, ' ', 0)
266 
267 	for _, p := range ps {
268 		targetfid := c.nextfid
269 		c.nextfid++
270 		components := strings.Split(strings.Trim(p, "/"), "/")
271 		if _, err := c.session.Walk(ctx, c.rootfid, targetfid, components...); err != nil {
272 			return err
273 		}
274 		defer c.session.Clunk(ctx, targetfid)
275 
276 		d, err := c.session.Stat(ctx, targetfid)
277 		if err != nil {
278 			return err
279 		}
280 
281 		fmt.Fprintf(wr, "%v\t%v\t%v\t%s\n", os.FileMode(d.Mode), d.Length, d.ModTime, d.Name)
282 	}
283 
284 	return wr.Flush()
285 }
286 
287 func (c *fsCommander) cmdpwd(ctx context.Context, args ...string) error {
288 	if len(args) != 0 {
289 		return fmt.Errorf("pwd takes no arguments")
290 	}
291 
292 	fmt.Println(c.pwd)
293 	return nil
294 }
295 
296 func (c *fsCommander) cmdcat(ctx context.Context, args ...string) error {
297 	var p string
298 	switch len(args) {
299 	case 0:
300 		p = "/"
301 	case 1:
302 		p = args[0]
303 	default:
304 		return fmt.Errorf("cd: invalid args: %v", args)
305 	}
306 
307 	if !path.IsAbs(p) {
308 		p = path.Join(c.pwd, p)
309 	}
310 
311 	targetfid := c.nextfid
312 	c.nextfid++
313 	components := strings.Split(strings.TrimSpace(strings.Trim(p, "/")), "/")
314 	if _, err := c.session.Walk(ctx, c.rootfid, targetfid, components...); err != nil {
315 		return err
316 	}
317 	defer c.session.Clunk(ctx, c.pwdfid)
318 
319 	_, iounit, err := c.session.Open(ctx, targetfid, p9p.OREAD)
320 	if err != nil {
321 		return err
322 	}
323 
324 	if iounit < 1 {
325 		msize, _ := c.session.Version()
326 		iounit = uint32(msize - 24) // size of message max minus fcall io header (Rread)
327 	}
328 
329 	b := make([]byte, iounit)
330 
331 	n, err := c.session.Read(ctx, targetfid, b, 0)
332 	if err != nil {
333 		return err
334 	}
335 
336 	if _, err := os.Stdout.Write(b[:n]); err != nil {
337 		return err
338 	}
339 
340 	os.Stdout.Write([]byte("\n"))
341 
342 	return nil
343 }