1 #include <plan9.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 n = strlen(s);
11 PBIT16(p, n);
12 p += BIT16SZ;
13 memmove(p, s, n);
14 p += n;
15 return p;
16 }
17
18 static
19 uchar*
pqid(uchar * p,Qid * q)20 pqid(uchar *p, Qid *q)
21 {
22 PBIT8(p, q->type);
23 p += BIT8SZ;
24 PBIT32(p, q->vers);
25 p += BIT32SZ;
26 PBIT64(p, q->path);
27 p += BIT64SZ;
28 return p;
29 }
30
31 static
32 uint
stringsz(char * s)33 stringsz(char *s)
34 {
35 return BIT16SZ+strlen(s);
36 }
37
38 static
39 uint
sizeS2M(Fcall * f)40 sizeS2M(Fcall *f)
41 {
42 uint n;
43 int i;
44
45 n = 0;
46 n += BIT32SZ; /* size */
47 n += BIT8SZ; /* type */
48 n += BIT16SZ; /* tag */
49
50 switch(f->type)
51 {
52 default:
53 return 0;
54
55 case Tversion:
56 n += BIT32SZ;
57 n += stringsz(f->version);
58 break;
59
60 /*
61 case Tsession:
62 n += BIT16SZ;
63 n += f->nchal;
64 break;
65 */
66
67 case Tflush:
68 n += BIT16SZ;
69 break;
70
71 case Tauth:
72 n += BIT32SZ;
73 n += stringsz(f->uname);
74 n += stringsz(f->aname);
75 break;
76
77 case Tattach:
78 n += BIT32SZ;
79 n += BIT32SZ;
80 n += stringsz(f->uname);
81 n += stringsz(f->aname);
82 break;
83
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 /*
141 case Rsession:
142 n += BIT16SZ;
143 n += f->nchal;
144 n += stringsz(f->authid);
145 n += stringsz(f->authdom);
146 break;
147
148 */
149 case Rerror:
150 n += stringsz(f->ename);
151 break;
152
153 case Rflush:
154 break;
155
156 case Rauth:
157 n += QIDSZ;
158 break;
159
160 /*
161 case Rattach:
162 n += QIDSZ;
163 n += BIT16SZ;
164 n += f->nrauth;
165 break;
166 */
167
168 case Rattach:
169 n += QIDSZ;
170 break;
171
172
173 case Rwalk:
174 n += BIT16SZ;
175 n += f->nwqid*QIDSZ;
176 break;
177
178 case Ropen:
179 case Rcreate:
180 n += QIDSZ;
181 n += BIT32SZ;
182 break;
183
184 case Rread:
185 n += BIT32SZ;
186 n += f->count;
187 break;
188
189 case Rwrite:
190 n += BIT32SZ;
191 break;
192
193 case Rclunk:
194 break;
195
196 case Rremove:
197 break;
198
199 case Rstat:
200 n += BIT16SZ;
201 n += f->nstat;
202 break;
203
204 case Rwstat:
205 break;
206 }
207 return n;
208 }
209
210 uint
convS2M(Fcall * f,uchar * ap,uint nap)211 convS2M(Fcall *f, uchar *ap, uint nap)
212 {
213 uchar *p;
214 uint i, size;
215
216 size = sizeS2M(f);
217 if(size == 0)
218 return 0;
219 if(size > nap)
220 return 0;
221
222 p = (uchar*)ap;
223
224 PBIT32(p, size);
225 p += BIT32SZ;
226 PBIT8(p, f->type);
227 p += BIT8SZ;
228 PBIT16(p, f->tag);
229 p += BIT16SZ;
230
231 switch(f->type)
232 {
233 default:
234 return 0;
235
236 case Tversion:
237 PBIT32(p, f->msize);
238 p += BIT32SZ;
239 p = pstring(p, f->version);
240 break;
241
242 /*
243 case Tsession:
244 PBIT16(p, f->nchal);
245 p += BIT16SZ;
246 f->chal = p;
247 p += f->nchal;
248 break;
249 */
250
251 case Tflush:
252 PBIT16(p, f->oldtag);
253 p += BIT16SZ;
254 break;
255
256 case Tauth:
257 PBIT32(p, f->afid);
258 p += BIT32SZ;
259 p = pstring(p, f->uname);
260 p = pstring(p, f->aname);
261 break;
262
263 case Tattach:
264 PBIT32(p, f->fid);
265 p += BIT32SZ;
266 PBIT32(p, f->afid);
267 p += BIT32SZ;
268 p = pstring(p, f->uname);
269 p = pstring(p, f->aname);
270 break;
271
272 case Twalk:
273 PBIT32(p, f->fid);
274 p += BIT32SZ;
275 PBIT32(p, f->newfid);
276 p += BIT32SZ;
277 PBIT16(p, f->nwname);
278 p += BIT16SZ;
279 if(f->nwname > MAXWELEM)
280 return 0;
281 for(i=0; i<f->nwname; i++)
282 p = pstring(p, f->wname[i]);
283 break;
284
285 case Topen:
286 PBIT32(p, f->fid);
287 p += BIT32SZ;
288 PBIT8(p, f->mode);
289 p += BIT8SZ;
290 break;
291
292 case Tcreate:
293 PBIT32(p, f->fid);
294 p += BIT32SZ;
295 p = pstring(p, f->name);
296 PBIT32(p, f->perm);
297 p += BIT32SZ;
298 PBIT8(p, f->mode);
299 p += BIT8SZ;
300 break;
301
302 case Tread:
303 PBIT32(p, f->fid);
304 p += BIT32SZ;
305 PBIT64(p, f->offset);
306 p += BIT64SZ;
307 PBIT32(p, f->count);
308 p += BIT32SZ;
309 break;
310
311 case Twrite:
312 PBIT32(p, f->fid);
313 p += BIT32SZ;
314 PBIT64(p, f->offset);
315 p += BIT64SZ;
316 PBIT32(p, f->count);
317 p += BIT32SZ;
318 memmove(p, f->data, f->count);
319 p += f->count;
320 break;
321
322 case Tclunk:
323 case Tremove:
324 PBIT32(p, f->fid);
325 p += BIT32SZ;
326 break;
327
328 case Tstat:
329 PBIT32(p, f->fid);
330 p += BIT32SZ;
331 break;
332
333 case Twstat:
334 PBIT32(p, f->fid);
335 p += BIT32SZ;
336 PBIT16(p, f->nstat);
337 p += BIT16SZ;
338 memmove(p, f->stat, f->nstat);
339 p += f->nstat;
340 break;
341 /*
342 */
343
344 case Rversion:
345 PBIT32(p, f->msize);
346 p += BIT32SZ;
347 p = pstring(p, f->version);
348 break;
349
350 /*
351 case Rsession:
352 PBIT16(p, f->nchal);
353 p += BIT16SZ;
354 f->chal = p;
355 p += f->nchal;
356 p = pstring(p, f->authid);
357 p = pstring(p, f->authdom);
358 break;
359 */
360
361 case Rerror:
362 p = pstring(p, f->ename);
363 break;
364
365 case Rflush:
366 break;
367
368 case Rauth:
369 p = pqid(p, &f->aqid);
370 break;
371
372 case Rattach:
373 p = pqid(p, &f->qid);
374 break;
375
376 case Rwalk:
377 PBIT16(p, f->nwqid);
378 p += BIT16SZ;
379 if(f->nwqid > MAXWELEM)
380 return 0;
381 for(i=0; i<f->nwqid; i++)
382 p = pqid(p, &f->wqid[i]);
383 break;
384
385 case Ropen:
386 case Rcreate:
387 p = pqid(p, &f->qid);
388 PBIT32(p, f->iounit);
389 p += BIT32SZ;
390 break;
391
392 case Rread:
393 PBIT32(p, f->count);
394 p += BIT32SZ;
395 memmove(p, f->data, f->count);
396 p += f->count;
397 break;
398
399 case Rwrite:
400 PBIT32(p, f->count);
401 p += BIT32SZ;
402 break;
403
404 case Rclunk:
405 break;
406
407 case Rremove:
408 break;
409
410 case Rstat:
411 PBIT16(p, f->nstat);
412 p += BIT16SZ;
413 memmove(p, f->stat, f->nstat);
414 p += f->nstat;
415 break;
416
417 case Rwstat:
418 break;
419 }
420 if(size != p-ap)
421 return 0;
422 return size;
423 }
424