Introduction
Introduction Statistics Contact Development Disclaimer Help
convS2M.c - 9base - revived minimalist port of Plan 9 userland to Unix
git clone git://git.suckless.org/9base
Log
Files
Refs
README
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 }
You are viewing proxied material from suckless.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.