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