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