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