convS2M.c - 9base - revived minimalist port of Plan 9 userland to Unix
(HTM) git clone git://git.suckless.org/9base
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) README
(DIR) LICENSE
---
convS2M.c (5756B)
---
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 }