1 #include "lib9.h"
2 #include "fcall.h"
3
4 static
5 uchar*
pstring(uchar * p,char * s)6 pstring(uchar *p, char *s)
7 {
8 uint n;
9
10 if(s == nil){
11 PBIT16(p, 0);
12 p += BIT16SZ;
13 return p;
14 }
15
16 n = strlen(s);
17 PBIT16(p, n);
18 p += BIT16SZ;
19 memmove(p, s, n);
20 p += n;
21 return p;
22 }
23
24 static
25 uchar*
pqid(uchar * p,Qid * q)26 pqid(uchar *p, Qid *q)
27 {
28 PBIT8(p, q->type);
29 p += BIT8SZ;
30 PBIT32(p, q->vers);
31 p += BIT32SZ;
32 PBIT64(p, q->path);
33 p += BIT64SZ;
34 return p;
35 }
36
37 static
38 uint
stringsz(char * s)39 stringsz(char *s)
40 {
41 if(s == nil)
42 return BIT16SZ;
43
44 return BIT16SZ+strlen(s);
45 }
46
47 uint
sizeS2M(Fcall * f)48 sizeS2M(Fcall *f)
49 {
50 uint n;
51 int i;
52
53 n = 0;
54 n += BIT32SZ; /* size */
55 n += BIT8SZ; /* type */
56 n += BIT16SZ; /* tag */
57
58 switch(f->type)
59 {
60 default:
61 return 0;
62
63 case Tversion:
64 n += BIT32SZ;
65 n += stringsz(f->version);
66 break;
67
68 case Tflush:
69 n += BIT16SZ;
70 break;
71
72 case Tauth:
73 n += BIT32SZ;
74 n += stringsz(f->uname);
75 n += stringsz(f->aname);
76 break;
77
78 case Tattach:
79 n += BIT32SZ;
80 n += BIT32SZ;
81 n += stringsz(f->uname);
82 n += stringsz(f->aname);
83 break;
84
85 case Twalk:
86 n += BIT32SZ;
87 n += BIT32SZ;
88 n += BIT16SZ;
89 for(i=0; i<f->nwname; i++)
90 n += stringsz(f->wname[i]);
91 break;
92
93 case Topen:
94 n += BIT32SZ;
95 n += BIT8SZ;
96 break;
97
98 case Tcreate:
99 n += BIT32SZ;
100 n += stringsz(f->name);
101 n += BIT32SZ;
102 n += BIT8SZ;
103 break;
104
105 case Tread:
106 n += BIT32SZ;
107 n += BIT64SZ;
108 n += BIT32SZ;
109 break;
110
111 case Twrite:
112 n += BIT32SZ;
113 n += BIT64SZ;
114 n += BIT32SZ;
115 n += f->count;
116 break;
117
118 case Tclunk:
119 case Tremove:
120 n += BIT32SZ;
121 break;
122
123 case Tstat:
124 n += BIT32SZ;
125 break;
126
127 case Twstat:
128 n += BIT32SZ;
129 n += BIT16SZ;
130 n += f->nstat;
131 break;
132 /*
133 */
134
135 case Rversion:
136 n += BIT32SZ;
137 n += stringsz(f->version);
138 break;
139
140 case Rerror:
141 n += stringsz(f->ename);
142 break;
143
144 case Rflush:
145 break;
146
147 case Rauth:
148 n += QIDSZ;
149 break;
150
151 case Rattach:
152 n += QIDSZ;
153 break;
154
155 case Rwalk:
156 n += BIT16SZ;
157 n += f->nwqid*QIDSZ;
158 break;
159
160 case Ropen:
161 case Rcreate:
162 n += QIDSZ;
163 n += BIT32SZ;
164 break;
165
166 case Rread:
167 n += BIT32SZ;
168 n += f->count;
169 break;
170
171 case Rwrite:
172 n += BIT32SZ;
173 break;
174
175 case Rclunk:
176 break;
177
178 case Rremove:
179 break;
180
181 case Rstat:
182 n += BIT16SZ;
183 n += f->nstat;
184 break;
185
186 case Rwstat:
187 break;
188 }
189 return n;
190 }
191
192 uint
convS2M(Fcall * f,uchar * ap,uint nap)193 convS2M(Fcall *f, uchar *ap, uint nap)
194 {
195 uchar *p;
196 uint i, size;
197
198 size = sizeS2M(f);
199 if(size == 0)
200 return 0;
201 if(size > nap)
202 return 0;
203
204 p = (uchar*)ap;
205
206 PBIT32(p, size);
207 p += BIT32SZ;
208 PBIT8(p, f->type);
209 p += BIT8SZ;
210 PBIT16(p, f->tag);
211 p += BIT16SZ;
212
213 switch(f->type)
214 {
215 default:
216 return 0;
217
218 case Tversion:
219 PBIT32(p, f->msize);
220 p += BIT32SZ;
221 p = pstring(p, f->version);
222 break;
223
224 case Tflush:
225 PBIT16(p, f->oldtag);
226 p += BIT16SZ;
227 break;
228
229 case Tauth:
230 PBIT32(p, f->afid);
231 p += BIT32SZ;
232 p = pstring(p, f->uname);
233 p = pstring(p, f->aname);
234 break;
235
236 case Tattach:
237 PBIT32(p, f->fid);
238 p += BIT32SZ;
239 PBIT32(p, f->afid);
240 p += BIT32SZ;
241 p = pstring(p, f->uname);
242 p = pstring(p, f->aname);
243 break;
244
245 case Twalk:
246 PBIT32(p, f->fid);
247 p += BIT32SZ;
248 PBIT32(p, f->newfid);
249 p += BIT32SZ;
250 PBIT16(p, f->nwname);
251 p += BIT16SZ;
252 if(f->nwname > MAXWELEM)
253 return 0;
254 for(i=0; i<f->nwname; i++)
255 p = pstring(p, f->wname[i]);
256 break;
257
258 case Topen:
259 PBIT32(p, f->fid);
260 p += BIT32SZ;
261 PBIT8(p, f->mode);
262 p += BIT8SZ;
263 break;
264
265 case Tcreate:
266 PBIT32(p, f->fid);
267 p += BIT32SZ;
268 p = pstring(p, f->name);
269 PBIT32(p, f->perm);
270 p += BIT32SZ;
271 PBIT8(p, f->mode);
272 p += BIT8SZ;
273 break;
274
275 case Tread:
276 PBIT32(p, f->fid);
277 p += BIT32SZ;
278 PBIT64(p, f->offset);
279 p += BIT64SZ;
280 PBIT32(p, f->count);
281 p += BIT32SZ;
282 break;
283
284 case Twrite:
285 PBIT32(p, f->fid);
286 p += BIT32SZ;
287 PBIT64(p, f->offset);
288 p += BIT64SZ;
289 PBIT32(p, f->count);
290 p += BIT32SZ;
291 memmove(p, f->data, f->count);
292 p += f->count;
293 break;
294
295 case Tclunk:
296 case Tremove:
297 PBIT32(p, f->fid);
298 p += BIT32SZ;
299 break;
300
301 case Tstat:
302 PBIT32(p, f->fid);
303 p += BIT32SZ;
304 break;
305
306 case Twstat:
307 PBIT32(p, f->fid);
308 p += BIT32SZ;
309 PBIT16(p, f->nstat);
310 p += BIT16SZ;
311 memmove(p, f->stat, f->nstat);
312 p += f->nstat;
313 break;
314 /*
315 */
316
317 case Rversion:
318 PBIT32(p, f->msize);
319 p += BIT32SZ;
320 p = pstring(p, f->version);
321 break;
322
323 case Rerror:
324 p = pstring(p, f->ename);
325 break;
326
327 case Rflush:
328 break;
329
330 case Rauth:
331 p = pqid(p, &f->aqid);
332 break;
333
334 case Rattach:
335 p = pqid(p, &f->qid);
336 break;
337
338 case Rwalk:
339 PBIT16(p, f->nwqid);
340 p += BIT16SZ;
341 if(f->nwqid > MAXWELEM)
342 return 0;
343 for(i=0; i<f->nwqid; i++)
344 p = pqid(p, &f->wqid[i]);
345 break;
346
347 case Ropen:
348 case Rcreate:
349 p = pqid(p, &f->qid);
350 PBIT32(p, f->iounit);
351 p += BIT32SZ;
352 break;
353
354 case Rread:
355 PBIT32(p, f->count);
356 p += BIT32SZ;
357 memmove(p, f->data, f->count);
358 p += f->count;
359 break;
360
361 case Rwrite:
362 PBIT32(p, f->count);
363 p += BIT32SZ;
364 break;
365
366 case Rclunk:
367 break;
368
369 case Rremove:
370 break;
371
372 case Rstat:
373 PBIT16(p, f->nstat);
374 p += BIT16SZ;
375 memmove(p, f->stat, f->nstat);
376 p += f->nstat;
377 break;
378
379 case Rwstat:
380 break;
381 }
382 if(size != p-ap)
383 return 0;
384 return size;
385 }
386