1 package p9p
2 
3 import (
4 	"golang.org/x/net/context"
5 	"io"
6 
7 	"net"
8 )
9 
10 type client struct {
11 	version   string
12 	msize     int
13 	ctx       context.Context
14 	transport roundTripper
15 }
16 
17 // NewSession returns a session using the connection. The Context ctx provides
18 // a context for out of bad messages, such as flushes, that may be sent by the
19 // session. The session can effectively shutdown with this context.
20 func NewSession(ctx context.Context, conn net.Conn) (Session, error) {
21 	ch := newChannel(conn, codec9p{}, DefaultMSize) // sets msize, effectively.
22 
23 	// negotiate the protocol version
24 	version, err := clientnegotiate(ctx, ch, DefaultVersion)
25 	if err != nil {
26 		return nil, err
27 	}
28 
29 	return &client{
30 		version:   version,
31 		msize:     ch.MSize(),
32 		ctx:       ctx,
33 		transport: newTransport(ctx, ch),
34 	}, nil
35 }
36 
37 var _ Session = &client{}
38 
39 func (c *client) Version() (int, string) {
40 	return c.msize, c.version
41 }
42 
43 func (c *client) Auth(ctx context.Context, afid Fid, uname, aname string) (Qid, error) {
44 	m := MessageTauth{
45 		Afid:  afid,
46 		Uname: uname,
47 		Aname: aname,
48 	}
49 
50 	resp, err := c.transport.send(ctx, m)
51 	if err != nil {
52 		return Qid{}, nil
53 	}
54 
55 	rauth, ok := resp.(MessageRauth)
56 	if !ok {
57 		return Qid{}, ErrUnexpectedMsg
58 	}
59 
60 	return rauth.Qid, nil
61 }
62 
63 func (c *client) Attach(ctx context.Context, fid, afid Fid, uname, aname string) (Qid, error) {
64 	m := MessageTattach{
65 		Fid:   fid,
66 		Afid:  afid,
67 		Uname: uname,
68 		Aname: aname,
69 	}
70 
71 	resp, err := c.transport.send(ctx, m)
72 	if err != nil {
73 		return Qid{}, err
74 	}
75 
76 	rattach, ok := resp.(MessageRattach)
77 	if !ok {
78 		return Qid{}, ErrUnexpectedMsg
79 	}
80 
81 	return rattach.Qid, nil
82 }
83 
84 func (c *client) Clunk(ctx context.Context, fid Fid) error {
85 	resp, err := c.transport.send(ctx, MessageTclunk{
86 		Fid: fid,
87 	})
88 	if err != nil {
89 		return err
90 	}
91 
92 	_, ok := resp.(MessageRclunk)
93 	if !ok {
94 		return ErrUnexpectedMsg
95 	}
96 
97 	return nil
98 }
99 
100 func (c *client) Remove(ctx context.Context, fid Fid) error {
101 	resp, err := c.transport.send(ctx, MessageTremove{
102 		Fid: fid,
103 	})
104 	if err != nil {
105 		return err
106 	}
107 
108 	_, ok := resp.(MessageRremove)
109 	if !ok {
110 		return ErrUnexpectedMsg
111 	}
112 
113 	return nil
114 }
115 
116 func (c *client) Walk(ctx context.Context, fid Fid, newfid Fid, names ...string) ([]Qid, error) {
117 	if len(names) > 16 {
118 		return nil, ErrWalkLimit
119 	}
120 
121 	resp, err := c.transport.send(ctx, MessageTwalk{
122 		Fid:    fid,
123 		Newfid: newfid,
124 		Wnames: names,
125 	})
126 	if err != nil {
127 		return nil, err
128 	}
129 
130 	rwalk, ok := resp.(MessageRwalk)
131 	if !ok {
132 		return nil, ErrUnexpectedMsg
133 	}
134 
135 	return rwalk.Qids, nil
136 }
137 
138 func (c *client) Read(ctx context.Context, fid Fid, p []byte, offset int64) (n int, err error) {
139 	resp, err := c.transport.send(ctx, MessageTread{
140 		Fid:    fid,
141 		Offset: uint64(offset),
142 		Count:  uint32(len(p)),
143 	})
144 	if err != nil {
145 		return 0, err
146 	}
147 
148 	rread, ok := resp.(MessageRread)
149 	if !ok {
150 		return 0, ErrUnexpectedMsg
151 	}
152 
153 	return copy(p, rread.Data), nil
154 }
155 
156 // Readdir implements Plan9 wire protocol specifics for reading Dir entries.
157 func (c *client) Readdir(ctx context.Context, fid Fid) ([]*Dir, error) {
158 
159 	errChan := make(chan error)
160 	doneChan := make(chan []*Dir)
161 
162 	reader, writer := io.Pipe()
163 	buf := make([]byte, 256)
164 	offset := int64(0)
165 
166 	go func() {
167 		for {
168 			n, err := c.Read(ctx, fid, buf, offset)
169 			if err != nil {
170 				errChan <- err
171 				break
172 			}
173 			if n == 0 {
174 				break
175 			}
176 			writer.Write(buf[:n])
177 		}
178 		writer.Close()
179 	}()
180 
181 	go func() {
182 		dirs := []*Dir{}
183 		dir := &Dir{}
184 		for {
185 			err := DecodeDir(NewCodec(), reader, dir)
186 			if err != nil && err != io.EOF {
187 				errChan <- err
188 				break
189 			}
190 			dirs = append(dirs, dir)
191 			if err != nil {
192 				doneChan <- dirs
193 			}
194 		}
195 	}()
196 
197 	select {
198 	case err := <-errChan:
199 		return nil, err
200 	case dirs := <-doneChan:
201 		return dirs, nil
202 	}
203 }
204 
205 func (c *client) Write(ctx context.Context, fid Fid, p []byte, offset int64) (n int, err error) {
206 	resp, err := c.transport.send(ctx, MessageTwrite{
207 		Fid:    fid,
208 		Offset: uint64(offset),
209 		Data:   p,
210 	})
211 	if err != nil {
212 		return 0, err
213 	}
214 
215 	rwrite, ok := resp.(MessageRwrite)
216 	if !ok {
217 		return 0, ErrUnexpectedMsg
218 	}
219 
220 	return int(rwrite.Count), nil
221 }
222 
223 func (c *client) Open(ctx context.Context, fid Fid, mode Flag) (Qid, uint32, error) {
224 	resp, err := c.transport.send(ctx, MessageTopen{
225 		Fid:  fid,
226 		Mode: mode,
227 	})
228 	if err != nil {
229 		return Qid{}, 0, err
230 	}
231 
232 	ropen, ok := resp.(MessageRopen)
233 	if !ok {
234 		return Qid{}, 0, ErrUnexpectedMsg
235 	}
236 
237 	return ropen.Qid, ropen.IOUnit, nil
238 }
239 
240 func (c *client) Create(ctx context.Context, parent Fid, name string, perm uint32, mode Flag) (Qid, uint32, error) {
241 	resp, err := c.transport.send(ctx, MessageTcreate{
242 		Fid:  parent,
243 		Name: name,
244 		Perm: perm,
245 		Mode: mode,
246 	})
247 	if err != nil {
248 		return Qid{}, 0, err
249 	}
250 
251 	rcreate, ok := resp.(MessageRcreate)
252 	if !ok {
253 		return Qid{}, 0, ErrUnexpectedMsg
254 	}
255 
256 	return rcreate.Qid, rcreate.IOUnit, nil
257 }
258 
259 func (c *client) Stat(ctx context.Context, fid Fid) (Dir, error) {
260 	resp, err := c.transport.send(ctx, MessageTstat{Fid: fid})
261 	if err != nil {
262 		return Dir{}, err
263 	}
264 
265 	rstat, ok := resp.(MessageRstat)
266 	if !ok {
267 		return Dir{}, ErrUnexpectedMsg
268 	}
269 
270 	return rstat.Stat, nil
271 }
272 
273 func (c *client) WStat(ctx context.Context, fid Fid, dir Dir) error {
274 	resp, err := c.transport.send(ctx, MessageTwstat{
275 		Fid:  fid,
276 		Stat: dir,
277 	})
278 	if err != nil {
279 		return err
280 	}
281 
282 	_, ok := resp.(MessageRwstat)
283 	if !ok {
284 		return ErrUnexpectedMsg
285 	}
286 
287 	return nil
288 }