1 package p9p
2 
3 import (
4 	"io"
5 	"net"
6 
7 	"context"
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{}, err
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 	n = copy(p, rread.Data)
154 	switch {
155 	case len(rread.Data) == 0:
156 		err = io.EOF
157 	case n < len(p):
158 		// TODO(stevvooe): Technically, we should treat this as an io.EOF.
159 		// However, we cannot tell if the short read was due to EOF or due to
160 		// truncation.
161 	}
162 
163 	return n, err
164 }
165 
166 func (c *client) Write(ctx context.Context, fid Fid, p []byte, offset int64) (n int, err error) {
167 	resp, err := c.transport.send(ctx, MessageTwrite{
168 		Fid:    fid,
169 		Offset: uint64(offset),
170 		Data:   p,
171 	})
172 	if err != nil {
173 		return 0, err
174 	}
175 
176 	rwrite, ok := resp.(MessageRwrite)
177 	if !ok {
178 		return 0, ErrUnexpectedMsg
179 	}
180 
181 	if int(rwrite.Count) < len(p) {
182 		err = io.ErrShortWrite
183 	}
184 
185 	return int(rwrite.Count), err
186 }
187 
188 func (c *client) Open(ctx context.Context, fid Fid, mode Flag) (Qid, uint32, error) {
189 	resp, err := c.transport.send(ctx, MessageTopen{
190 		Fid:  fid,
191 		Mode: mode,
192 	})
193 	if err != nil {
194 		return Qid{}, 0, err
195 	}
196 
197 	ropen, ok := resp.(MessageRopen)
198 	if !ok {
199 		return Qid{}, 0, ErrUnexpectedMsg
200 	}
201 
202 	return ropen.Qid, ropen.IOUnit, nil
203 }
204 
205 func (c *client) Create(ctx context.Context, parent Fid, name string, perm uint32, mode Flag) (Qid, uint32, error) {
206 	resp, err := c.transport.send(ctx, MessageTcreate{
207 		Fid:  parent,
208 		Name: name,
209 		Perm: perm,
210 		Mode: mode,
211 	})
212 	if err != nil {
213 		return Qid{}, 0, err
214 	}
215 
216 	rcreate, ok := resp.(MessageRcreate)
217 	if !ok {
218 		return Qid{}, 0, ErrUnexpectedMsg
219 	}
220 
221 	return rcreate.Qid, rcreate.IOUnit, nil
222 }
223 
224 func (c *client) Stat(ctx context.Context, fid Fid) (Dir, error) {
225 	resp, err := c.transport.send(ctx, MessageTstat{Fid: fid})
226 	if err != nil {
227 		return Dir{}, err
228 	}
229 
230 	rstat, ok := resp.(MessageRstat)
231 	if !ok {
232 		return Dir{}, ErrUnexpectedMsg
233 	}
234 
235 	return rstat.Stat, nil
236 }
237 
238 func (c *client) WStat(ctx context.Context, fid Fid, dir Dir) error {
239 	resp, err := c.transport.send(ctx, MessageTwstat{
240 		Fid:  fid,
241 		Stat: dir,
242 	})
243 	if err != nil {
244 		return err
245 	}
246 
247 	_, ok := resp.(MessageRwstat)
248 	if !ok {
249 		return ErrUnexpectedMsg
250 	}
251 
252 	return nil
253 }