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 		break;
78 
79 	case Tattach:
80 		n += BIT32SZ;
81 		n += BIT32SZ;
82 		n += stringsz(f->uname);
83 		n += stringsz(f->aname);
84 		break;
85 
86 	case Twalk:
87 		n += BIT32SZ;
88 		n += BIT32SZ;
89 		n += BIT16SZ;
90 		for(i=0; i<f->nwname; i++)
91 			n += stringsz(f->wname[i]);
92 		break;
93 
94 	case Topen:
95 	case Topenfd:
96 		n += BIT32SZ;
97 		n += BIT8SZ;
98 		break;
99 
100 	case Tcreate:
101 		n += BIT32SZ;
102 		n += stringsz(f->name);
103 		n += BIT32SZ;
104 		n += BIT8SZ;
105 		if(dotu)
106 			n += stringsz(f->extension);
107 		break;
108 
109 	case Tread:
110 		n += BIT32SZ;
111 		n += BIT64SZ;
112 		n += BIT32SZ;
113 		break;
114 
115 	case Twrite:
116 		n += BIT32SZ;
117 		n += BIT64SZ;
118 		n += BIT32SZ;
119 		n += f->count;
120 		break;
121 
122 	case Tclunk:
123 	case Tremove:
124 		n += BIT32SZ;
125 		break;
126 
127 	case Tstat:
128 		n += BIT32SZ;
129 		break;
130 
131 	case Twstat:
132 		n += BIT32SZ;
133 		n += BIT16SZ;
134 		n += f->nstat;
135 		break;
136 /*
137  */
138 
139 	case Rversion:
140 		n += BIT32SZ;
141 		n += stringsz(f->version);
142 		break;
143 
144 	case Rerror:
145 		n += stringsz(f->ename);
146 		if(dotu)
147 			n += BIT16SZ;
148 		break;
149 
150 	case Rflush:
151 		break;
152 
153 	case Rauth:
154 		n += QIDSZ;
155 		break;
156 
157 	case Rattach:
158 		n += QIDSZ;
159 		break;
160 
161 	case Rwalk:
162 		n += BIT16SZ;
163 		n += f->nwqid*QIDSZ;
164 		break;
165 
166 	case Ropen:
167 	case Rcreate:
168 		n += QIDSZ;
169 		n += BIT32SZ;
170 		break;
171 
172 	case Ropenfd:
173 		n += QIDSZ;
174 		n += BIT32SZ;
175 		n += BIT32SZ;
176 		break;
177 
178 	case Rread:
179 		n += BIT32SZ;
180 		n += f->count;
181 		break;
182 
183 	case Rwrite:
184 		n += BIT32SZ;
185 		break;
186 
187 	case Rclunk:
188 		break;
189 
190 	case Rremove:
191 		break;
192 
193 	case Rstat:
194 		n += BIT16SZ;
195 		n += f->nstat;
196 		break;
197 
198 	case Rwstat:
199 		break;
200 	}
201 	return n;
202 }
203 
204 uint
205 sizeS2M(Fcall *f)
206 {
207 	return sizeS2Mu(f, 0);
208 }
209 
210 uint
211 convS2Mu(Fcall *f, uchar *ap, uint nap, int dotu)
212 {
213 	uchar *p;
214 	uint i, size;
215 
216 	size = sizeS2Mu(f, dotu);
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 	case Tflush:
243 		PBIT16(p, f->oldtag);
244 		p += BIT16SZ;
245 		break;
246 
247 	case Tauth:
248 		PBIT32(p, f->afid);
249 		p += BIT32SZ;
250 		p  = pstring(p, f->uname);
251 		p  = pstring(p, f->aname);
252 		break;
253 
254 	case Tattach:
255 		PBIT32(p, f->fid);
256 		p += BIT32SZ;
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 Twalk:
264 		PBIT32(p, f->fid);
265 		p += BIT32SZ;
266 		PBIT32(p, f->newfid);
267 		p += BIT32SZ;
268 		PBIT16(p, f->nwname);
269 		p += BIT16SZ;
270 		if(f->nwname > MAXWELEM)
271 			return 0;
272 		for(i=0; i<f->nwname; i++)
273 			p = pstring(p, f->wname[i]);
274 		break;
275 
276 	case Topen:
277 	case Topenfd:
278 		PBIT32(p, f->fid);
279 		p += BIT32SZ;
280 		PBIT8(p, f->mode);
281 		p += BIT8SZ;
282 		break;
283 
284 	case Tcreate:
285 		PBIT32(p, f->fid);
286 		p += BIT32SZ;
287 		p = pstring(p, f->name);
288 		PBIT32(p, f->perm);
289 		p += BIT32SZ;
290 		PBIT8(p, f->mode);
291 		p += BIT8SZ;
292 		if(dotu)
293 			p = pstring(p, f->extension);
294 		break;
295 
296 	case Tread:
297 		PBIT32(p, f->fid);
298 		p += BIT32SZ;
299 		PBIT64(p, f->offset);
300 		p += BIT64SZ;
301 		PBIT32(p, f->count);
302 		p += BIT32SZ;
303 		break;
304 
305 	case Twrite:
306 		PBIT32(p, f->fid);
307 		p += BIT32SZ;
308 		PBIT64(p, f->offset);
309 		p += BIT64SZ;
310 		PBIT32(p, f->count);
311 		p += BIT32SZ;
312 		memmove(p, f->data, f->count);
313 		p += f->count;
314 		break;
315 
316 	case Tclunk:
317 	case Tremove:
318 		PBIT32(p, f->fid);
319 		p += BIT32SZ;
320 		break;
321 
322 	case Tstat:
323 		PBIT32(p, f->fid);
324 		p += BIT32SZ;
325 		break;
326 
327 	case Twstat:
328 		PBIT32(p, f->fid);
329 		p += BIT32SZ;
330 		PBIT16(p, f->nstat);
331 		p += BIT16SZ;
332 		memmove(p, f->stat, f->nstat);
333 		p += f->nstat;
334 		break;
335 /*
336  */
337 
338 	case Rversion:
339 		PBIT32(p, f->msize);
340 		p += BIT32SZ;
341 		p = pstring(p, f->version);
342 		break;
343 
344 	case Rerror:
345 		p = pstring(p, f->ename);
346 		if(dotu){
347 			PBIT16(p, f->errornum);
348 			p += BIT16SZ;
349 		}
350 		break;
351 
352 	case Rflush:
353 		break;
354 
355 	case Rauth:
356 		p = pqid(p, &f->aqid);
357 		break;
358 
359 	case Rattach:
360 		p = pqid(p, &f->qid);
361 		break;
362 
363 	case Rwalk:
364 		PBIT16(p, f->nwqid);
365 		p += BIT16SZ;
366 		if(f->nwqid > MAXWELEM)
367 			return 0;
368 		for(i=0; i<f->nwqid; i++)
369 			p = pqid(p, &f->wqid[i]);
370 		break;
371 
372 	case Ropen:
373 	case Rcreate:
374 	case Ropenfd:
375 		p = pqid(p, &f->qid);
376 		PBIT32(p, f->iounit);
377 		p += BIT32SZ;
378 		if(f->type == Ropenfd){
379 			PBIT32(p, f->unixfd);
380 			p += BIT32SZ;
381 		}
382 		break;
383 
384 	case Rread:
385 		PBIT32(p, f->count);
386 		p += BIT32SZ;
387 		memmove(p, f->data, f->count);
388 		p += f->count;
389 		break;
390 
391 	case Rwrite:
392 		PBIT32(p, f->count);
393 		p += BIT32SZ;
394 		break;
395 
396 	case Rclunk:
397 		break;
398 
399 	case Rremove:
400 		break;
401 
402 	case Rstat:
403 		PBIT16(p, f->nstat);
404 		p += BIT16SZ;
405 		memmove(p, f->stat, f->nstat);
406 		p += f->nstat;
407 		break;
408 
409 	case Rwstat:
410 		break;
411 	}
412 	if(size != p-ap)
413 		return 0;
414 	return size;
415 }
416 
417 uint
418 convS2M(Fcall *f, uchar *ap, uint nap)
419 {
420 	return convS2Mu(f, ap, nap, 0);
421 }