Subversion Repositories planix.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 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 
	/*
19 
	 * We are moving the string before the length,
20 
	 * so you can S2M a struct into an existing message
21 
	 */
22 
	memmove(p + BIT16SZ, s, n);
23 
	PBIT16(p, n);
24 
	p += n + BIT16SZ;
25 
	return p;
26 
}
27 
 
28 
static
29 
uchar*
30 
pqid(uchar *p, Qid *q)
31 
{
32 
	PBIT8(p, q->type);
33 
	p += BIT8SZ;
34 
	PBIT32(p, q->vers);
35 
	p += BIT32SZ;
36 
	PBIT64(p, q->path);
37 
	p += BIT64SZ;
38 
	return p;
39 
}
40 
 
41 
static
42 
uint
43 
stringsz(char *s)
44 
{
45 
	if(s == nil)
46 
		return BIT16SZ;
47 
 
48 
	return BIT16SZ+strlen(s);
49 
}
50 
 
51 
uint
52 
sizeS2M(Fcall *f)
53 
{
54 
	uint n;
55 
	int i;
56 
 
57 
	n = 0;
58 
	n += BIT32SZ;	/* size */
59 
	n += BIT8SZ;	/* type */
60 
	n += BIT16SZ;	/* tag */
61 
 
62 
	switch(f->type)
63 
	{
64 
	default:
65 
		return 0;
66 
 
67 
	case Tversion:
68 
		n += BIT32SZ;
69 
		n += stringsz(f->version);
70 
		break;
71 
 
72 
	case Tflush:
73 
		n += BIT16SZ;
74 
		break;
75 
 
76 
	case Tauth:
77 
		n += BIT32SZ;
78 
		n += stringsz(f->uname);
79 
		n += stringsz(f->aname);
80 
		break;
81 
 
82 
	case Tattach:
83 
		n += BIT32SZ;
84 
		n += BIT32SZ;
85 
		n += stringsz(f->uname);
86 
		n += stringsz(f->aname);
87 
		break;
88 
 
89 
	case Twalk:
90 
		n += BIT32SZ;
91 
		n += BIT32SZ;
92 
		n += BIT16SZ;
93 
		for(i=0; i<f->nwname; i++)
94 
			n += stringsz(f->wname[i]);
95 
		break;
96 
 
97 
	case Topen:
98 
		n += BIT32SZ;
99 
		n += BIT8SZ;
100 
		break;
101 
 
102 
	case Tcreate:
103 
		n += BIT32SZ;
104 
		n += stringsz(f->name);
105 
		n += BIT32SZ;
106 
		n += BIT8SZ;
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 
		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 Rread:
171 
		n += BIT32SZ;
172 
		n += f->count;
173 
		break;
174 
 
175 
	case Rwrite:
176 
		n += BIT32SZ;
177 
		break;
178 
 
179 
	case Rclunk:
180 
		break;
181 
 
182 
	case Rremove:
183 
		break;
184 
 
185 
	case Rstat:
186 
		n += BIT16SZ;
187 
		n += f->nstat;
188 
		break;
189 
 
190 
	case Rwstat:
191 
		break;
192 
	}
193 
	return n;
194 
}
195 
 
196 
uint
197 
convS2M(Fcall *f, uchar *ap, uint nap)
198 
{
199 
	uchar *p;
200 
	uint i, size;
201 
 
202 
	size = sizeS2M(f);
203 
	if(size == 0)
204 
		return 0;
205 
	if(size > nap)
206 
		return 0;
207 
 
208 
	p = (uchar*)ap;
209 
 
210 
	PBIT32(p, size);
211 
	p += BIT32SZ;
212 
	PBIT8(p, f->type);
213 
	p += BIT8SZ;
214 
	PBIT16(p, f->tag);
215 
	p += BIT16SZ;
216 
 
217 
	switch(f->type)
218 
	{
219 
	default:
220 
		return 0;
221 
 
222 
	case Tversion:
223 
		PBIT32(p, f->msize);
224 
		p += BIT32SZ;
225 
		p = pstring(p, f->version);
226 
		break;
227 
 
228 
	case Tflush:
229 
		PBIT16(p, f->oldtag);
230 
		p += BIT16SZ;
231 
		break;
232 
 
233 
	case Tauth:
234 
		PBIT32(p, f->afid);
235 
		p += BIT32SZ;
236 
		p  = pstring(p, f->uname);
237 
		p  = pstring(p, f->aname);
238 
		break;
239 
 
240 
	case Tattach:
241 
		PBIT32(p, f->fid);
242 
		p += BIT32SZ;
243 
		PBIT32(p, f->afid);
244 
		p += BIT32SZ;
245 
		p  = pstring(p, f->uname);
246 
		p  = pstring(p, f->aname);
247 
		break;
248 
 
249 
	case Twalk:
250 
		PBIT32(p, f->fid);
251 
		p += BIT32SZ;
252 
		PBIT32(p, f->newfid);
253 
		p += BIT32SZ;
254 
		PBIT16(p, f->nwname);
255 
		p += BIT16SZ;
256 
		if(f->nwname > MAXWELEM)
257 
			return 0;
258 
		for(i=0; i<f->nwname; i++)
259 
			p = pstring(p, f->wname[i]);
260 
		break;
261 
 
262 
	case Topen:
263 
		PBIT32(p, f->fid);
264 
		p += BIT32SZ;
265 
		PBIT8(p, f->mode);
266 
		p += BIT8SZ;
267 
		break;
268 
 
269 
	case Tcreate:
270 
		PBIT32(p, f->fid);
271 
		p += BIT32SZ;
272 
		p = pstring(p, f->name);
273 
		PBIT32(p, f->perm);
274 
		p += BIT32SZ;
275 
		PBIT8(p, f->mode);
276 
		p += BIT8SZ;
277 
		break;
278 
 
279 
	case Tread:
280 
		PBIT32(p, f->fid);
281 
		p += BIT32SZ;
282 
		PBIT64(p, f->offset);
283 
		p += BIT64SZ;
284 
		PBIT32(p, f->count);
285 
		p += BIT32SZ;
286 
		break;
287 
 
288 
	case Twrite:
289 
		PBIT32(p, f->fid);
290 
		p += BIT32SZ;
291 
		PBIT64(p, f->offset);
292 
		p += BIT64SZ;
293 
		PBIT32(p, f->count);
294 
		p += BIT32SZ;
295 
		memmove(p, f->data, f->count);
296 
		p += f->count;
297 
		break;
298 
 
299 
	case Tclunk:
300 
	case Tremove:
301 
		PBIT32(p, f->fid);
302 
		p += BIT32SZ;
303 
		break;
304 
 
305 
	case Tstat:
306 
		PBIT32(p, f->fid);
307 
		p += BIT32SZ;
308 
		break;
309 
 
310 
	case Twstat:
311 
		PBIT32(p, f->fid);
312 
		p += BIT32SZ;
313 
		PBIT16(p, f->nstat);
314 
		p += BIT16SZ;
315 
		memmove(p, f->stat, f->nstat);
316 
		p += f->nstat;
317 
		break;
318 
/*
319 
 */
320 
 
321 
	case Rversion:
322 
		PBIT32(p, f->msize);
323 
		p += BIT32SZ;
324 
		p = pstring(p, f->version);
325 
		break;
326 
 
327 
	case Rerror:
328 
		p = pstring(p, f->ename);
329 
		break;
330 
 
331 
	case Rflush:
332 
		break;
333 
 
334 
	case Rauth:
335 
		p = pqid(p, &f->aqid);
336 
		break;
337 
 
338 
	case Rattach:
339 
		p = pqid(p, &f->qid);
340 
		break;
341 
 
342 
	case Rwalk:
343 
		PBIT16(p, f->nwqid);
344 
		p += BIT16SZ;
345 
		if(f->nwqid > MAXWELEM)
346 
			return 0;
347 
		for(i=0; i<f->nwqid; i++)
348 
			p = pqid(p, &f->wqid[i]);
349 
		break;
350 
 
351 
	case Ropen:
352 
	case Rcreate:
353 
		p = pqid(p, &f->qid);
354 
		PBIT32(p, f->iounit);
355 
		p += BIT32SZ;
356 
		break;
357 
 
358 
	case Rread:
359 
		PBIT32(p, f->count);
360 
		p += BIT32SZ;
361 
		memmove(p, f->data, f->count);
362 
		p += f->count;
363 
		break;
364 
 
365 
	case Rwrite:
366 
		PBIT32(p, f->count);
367 
		p += BIT32SZ;
368 
		break;
369 
 
370 
	case Rclunk:
371 
		break;
372 
 
373 
	case Rremove:
374 
		break;
375 
 
376 
	case Rstat:
377 
		PBIT16(p, f->nstat);
378 
		p += BIT16SZ;
379 
		memmove(p, f->stat, f->nstat);
380 
		p += f->nstat;
381 
		break;
382 
 
383 
	case Rwstat:
384 
		break;
385 
	}
386 
	if(size != p-ap)
387 
		return 0;
388 
	return size;
389 
}