1 package p9pnew
2 
3 import "fmt"
4 
5 // Message represents the target of an fcall.
6 type Message interface{}
7 
8 // newMessage returns a new instance of the message based on the Fcall type.
9 func newMessage(typ FcallType) (Message, error) {
10 	switch typ {
11 	case Tversion:
12 		return MessageTversion{}, nil
13 	case Rversion:
14 		return MessageRversion{}, nil
15 	case Tauth:
16 		return MessageTauth{}, nil
17 	case Rauth:
18 		return MessageRauth{}, nil
19 	case Tattach:
20 		return MessageTattach{}, nil
21 	case Rattach:
22 		return MessageRattach{}, nil
23 	case Rerror:
24 		return MessageRerror{}, nil
25 	case Tflush:
26 		return MessageTflush{}, nil
27 	case Rflush:
28 		return MessageRflush{}, nil // No message body for this response.
29 	case Twalk:
30 		return MessageTwalk{}, nil
31 	case Rwalk:
32 		return MessageRwalk{}, nil
33 	case Topen:
34 		return MessageTopen{}, nil
35 	case Ropen:
36 		return MessageRopen{}, nil
37 	case Tcreate:
38 		return MessageTcreate{}, nil
39 	case Rcreate:
40 		return MessageRcreate{}, nil
41 	case Tread:
42 		return MessageTread{}, nil
43 	case Rread:
44 		return MessageRread{}, nil
45 	case Twrite:
46 		return MessageTwrite{}, nil
47 	case Rwrite:
48 		return MessageRwrite{}, nil
49 	case Tclunk:
50 		return MessageTclunk{}, nil
51 	case Rclunk:
52 		return MessageRclunk{}, nil // no response body
53 	case Tremove:
54 		return MessageTremove{}, nil
55 	case Rremove:
56 		return MessageRremove{}, nil
57 	case Tstat:
58 		return MessageTstat{}, nil
59 	case Rstat:
60 		return MessageRstat{}, nil
61 	case Twstat:
62 		return MessageTwstat{}, nil
63 	case Rwstat:
64 		return MessageRwstat{}, nil
65 	}
66 
67 	return nil, fmt.Errorf("unknown message type")
68 }
69 
70 func messageType(m Message) FcallType {
71 	switch v := m.(type) {
72 	case MessageTversion:
73 		return Tversion
74 	case MessageRversion:
75 		return Rversion
76 	case MessageTauth:
77 		return Tauth
78 	case MessageRauth:
79 		return Rauth
80 	case MessageTflush:
81 		return Tflush
82 	case MessageRflush:
83 		return Rflush
84 	case MessageRerror:
85 		return Rerror
86 	case MessageTattach:
87 		return Tattach
88 	case MessageRattach:
89 		return Rattach
90 	case MessageTwalk:
91 		return Twalk
92 	case MessageRwalk:
93 		return Rwalk
94 	case MessageTopen:
95 		return Topen
96 	case MessageRopen:
97 		return Ropen
98 	case MessageTcreate:
99 		return Tcreate
100 	case MessageRcreate:
101 		return Rcreate
102 	case MessageTread:
103 		return Tread
104 	case MessageRread:
105 		return Rread
106 	case MessageTwrite:
107 		return Twrite
108 	case MessageRwrite:
109 		return Rwrite
110 	case MessageTclunk:
111 		return Tclunk
112 	case MessageRclunk:
113 		return Rclunk
114 	case MessageTremove:
115 		return Tremove
116 	case MessageRremove:
117 		return Rremove
118 	case MessageTstat:
119 		return Tstat
120 	case MessageRstat:
121 		return Rstat
122 	case MessageTwstat:
123 		return Twstat
124 	case MessageRwstat:
125 		return Rwstat
126 	case error:
127 		return Rerror
128 	default:
129 		// NOTE(stevvooe): This is considered a programming error.
130 		panic(fmt.Sprintf("unsupported message type: %T", v))
131 	}
132 }
133 
134 // MessageVersion encodes the message body for Tversion and Rversion RPC
135 // calls. The body is identical in both directions.
136 type MessageTversion struct {
137 	MSize   uint32
138 	Version string
139 }
140 
141 type MessageRversion struct {
142 	MSize   uint32
143 	Version string
144 }
145 
146 type MessageTauth struct {
147 	Afid  Fid
148 	Uname string
149 	Aname string
150 }
151 
152 type MessageRauth struct {
153 	Qid Qid
154 }
155 
156 type MessageRerror struct {
157 	Ename string
158 }
159 
160 func (e MessageRerror) Error() string {
161 	return fmt.Sprintf("9p: %v", e.Ename)
162 }
163 
164 type MessageTflush struct {
165 	Oldtag Tag
166 }
167 
168 type MessageRflush struct{}
169 
170 type MessageTattach struct {
171 	Fid   Fid
172 	Afid  Fid
173 	Uname string
174 	Aname string
175 }
176 
177 type MessageRattach struct {
178 	Qid Qid
179 }
180 
181 type MessageTwalk struct {
182 	Fid    Fid
183 	Newfid Fid
184 	Wnames []string
185 }
186 
187 type MessageRwalk struct {
188 	Qids []Qid
189 }
190 
191 type MessageTopen struct {
192 	Fid  Fid
193 	Mode Flag
194 }
195 
196 type MessageRopen struct {
197 	Qid    Qid
198 	IOUnit uint32
199 }
200 
201 type MessageTcreate struct {
202 	Fid  Fid
203 	Name string
204 	Perm uint32
205 	Mode Flag
206 }
207 
208 type MessageRcreate struct {
209 	Qid    Qid
210 	IOUnit uint32
211 }
212 
213 type MessageTread struct {
214 	Fid    Fid
215 	Offset uint64
216 	Count  uint32
217 }
218 
219 type MessageRread struct {
220 	Data []byte
221 }
222 
223 type MessageTwrite struct {
224 	Fid    Fid
225 	Offset uint64
226 	Data   []byte
227 }
228 
229 type MessageRwrite struct {
230 	Count uint32
231 }
232 
233 type MessageTclunk struct {
234 	Fid Fid
235 }
236 
237 type MessageRclunk struct{}
238 
239 type MessageTremove struct {
240 	Fid Fid
241 }
242 
243 type MessageRremove struct{}
244 
245 type MessageTstat struct {
246 	Fid Fid
247 }
248 
249 type MessageRstat struct {
250 	Stat Dir
251 }
252 
253 type MessageTwstat struct {
254 	Fid  Fid
255 	Stat Dir
256 }
257 
258 type MessageRwstat struct{}