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