?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PARISC] Fix compile warning in pci.h
[linux-2.6.22.y-op.git] / fs / 9p / conv.c
blob18121af99d3ef141cb5b641538defb6f1301c008
1 /*
2 * linux/fs/9p/conv.c
3 *
4 * 9P protocol conversion functions
5 *
6 * Copyright (C) 2004, 2005 by Latchesar Ionkov <lucho@ionkov.net>
7 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
8 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to:
22 * Free Software Foundation
23 * 51 Franklin Street, Fifth Floor
24 * Boston, MA 02111-1301 USA
25 *
26 */
27
28 #include <linux/config.h>
29 #include <linux/module.h>
30 #include <linux/errno.h>
31 #include <linux/fs.h>
32 #include <linux/idr.h>
33
34 #include "debug.h"
35 #include "v9fs.h"
36 #include "9p.h"
37 #include "conv.h"
38
39 /*
40 * Buffer to help with string parsing
41 */
42 struct cbuf {
43 unsigned char *sp;
44 unsigned char *p;
45 unsigned char *ep;
46 };
47
48 static inline void buf_init(struct cbuf *buf, void *data, int datalen)
49 {
50 buf->sp = buf->p = data;
51 buf->ep = data + datalen;
52 }
53
54 static inline int buf_check_overflow(struct cbuf *buf)
55 {
56 return buf->p > buf->ep;
57 }
58
59 static inline int buf_check_size(struct cbuf *buf, int len)
60 {
61 if (buf->p+len > buf->ep) {
62 if (buf->p < buf->ep) {
63 eprintk(KERN_ERR, "buffer overflow\n");
64 buf->p = buf->ep + 1;
65 return 0;
66 }
67 }
68
69 return 1;
70 }
71
72 static inline void *buf_alloc(struct cbuf *buf, int len)
73 {
74 void *ret = NULL;
75
76 if (buf_check_size(buf, len)) {
77 ret = buf->p;
78 buf->p += len;
79 }
80
81 return ret;
82 }
83
84 static inline void buf_put_int8(struct cbuf *buf, u8 val)
85 {
86 if (buf_check_size(buf, 1)) {
87 buf->p[0] = val;
88 buf->p++;
89 }
90 }
91
92 static inline void buf_put_int16(struct cbuf *buf, u16 val)
93 {
94 if (buf_check_size(buf, 2)) {
95 *(__le16 *) buf->p = cpu_to_le16(val);
96 buf->p += 2;
97 }
98 }
99
100 static inline void buf_put_int32(struct cbuf *buf, u32 val)
101 {
102 if (buf_check_size(buf, 4)) {
103 *(__le32 *)buf->p = cpu_to_le32(val);
104 buf->p += 4;
105 }
106 }
107
108 static inline void buf_put_int64(struct cbuf *buf, u64 val)
109 {
110 if (buf_check_size(buf, 8)) {
111 *(__le64 *)buf->p = cpu_to_le64(val);
112 buf->p += 8;
113 }
114 }
115
116 static inline void buf_put_stringn(struct cbuf *buf, const char *s, u16 slen)
117 {
118 if (buf_check_size(buf, slen + 2)) {
119 buf_put_int16(buf, slen);
120 memcpy(buf->p, s, slen);
121 buf->p += slen;
122 }
123 }
124
125 static inline void buf_put_string(struct cbuf *buf, const char *s)
126 {
127 buf_put_stringn(buf, s, strlen(s));
128 }
129
130 static inline void buf_put_data(struct cbuf *buf, void *data, u32 datalen)
131 {
132 if (buf_check_size(buf, datalen)) {
133 memcpy(buf->p, data, datalen);
134 buf->p += datalen;
135 }
136 }
137
138 static inline u8 buf_get_int8(struct cbuf *buf)
139 {
140 u8 ret = 0;
141
142 if (buf_check_size(buf, 1)) {
143 ret = buf->p[0];
144 buf->p++;
145 }
146
147 return ret;
148 }
149
150 static inline u16 buf_get_int16(struct cbuf *buf)
151 {
152 u16 ret = 0;
153
154 if (buf_check_size(buf, 2)) {
155 ret = le16_to_cpu(*(__le16 *)buf->p);
156 buf->p += 2;
157 }
158
159 return ret;
160 }
161
162 static inline u32 buf_get_int32(struct cbuf *buf)
163 {
164 u32 ret = 0;
165
166 if (buf_check_size(buf, 4)) {
167 ret = le32_to_cpu(*(__le32 *)buf->p);
168 buf->p += 4;
169 }
170
171 return ret;
172 }
173
174 static inline u64 buf_get_int64(struct cbuf *buf)
175 {
176 u64 ret = 0;
177
178 if (buf_check_size(buf, 8)) {
179 ret = le64_to_cpu(*(__le64 *)buf->p);
180 buf->p += 8;
181 }
182
183 return ret;
184 }
185
186 static inline int
187 buf_get_string(struct cbuf *buf, char *data, unsigned int datalen)
188 {
189 u16 len = 0;
190
191 len = buf_get_int16(buf);
192 if (!buf_check_overflow(buf) && buf_check_size(buf, len) && len+1>datalen) {
193 memcpy(data, buf->p, len);
194 data[len] = 0;
195 buf->p += len;
196 len++;
197 }
198
199 return len;
200 }
201
202 static inline char *buf_get_stringb(struct cbuf *buf, struct cbuf *sbuf)
203 {
204 char *ret;
205 u16 len;
206
207 ret = NULL;
208 len = buf_get_int16(buf);
209
210 if (!buf_check_overflow(buf) && buf_check_size(buf, len) &&
211 buf_check_size(sbuf, len+1)) {
212
213 memcpy(sbuf->p, buf->p, len);
214 sbuf->p[len] = 0;
215 ret = sbuf->p;
216 buf->p += len;
217 sbuf->p += len + 1;
218 }
219
220 return ret;
221 }
222
223 static inline int buf_get_data(struct cbuf *buf, void *data, int datalen)
224 {
225 int ret = 0;
226
227 if (buf_check_size(buf, datalen)) {
228 memcpy(data, buf->p, datalen);
229 buf->p += datalen;
230 ret = datalen;
231 }
232
233 return ret;
234 }
235
236 static inline void *buf_get_datab(struct cbuf *buf, struct cbuf *dbuf,
237 int datalen)
238 {
239 char *ret = NULL;
240 int n = 0;
241
242 if (buf_check_size(dbuf, datalen)) {
243 n = buf_get_data(buf, dbuf->p, datalen);
244 if (n > 0) {
245 ret = dbuf->p;
246 dbuf->p += n;
247 }
248 }
249
250 return ret;
251 }
252
253 /**
254 * v9fs_size_stat - calculate the size of a variable length stat struct
255 * @v9ses: session information
256 * @stat: metadata (stat) structure
257 *
258 */
259
260 static int v9fs_size_stat(struct v9fs_session_info *v9ses,
261 struct v9fs_stat *stat)
262 {
263 int size = 0;
264
265 if (stat == NULL) {
266 eprintk(KERN_ERR, "v9fs_size_stat: got a NULL stat pointer\n");
267 return 0;
268 }
269
270 size = /* 2 + *//* size[2] */
271 2 + /* type[2] */
272 4 + /* dev[4] */
273 1 + /* qid.type[1] */
274 4 + /* qid.vers[4] */
275 8 + /* qid.path[8] */
276 4 + /* mode[4] */
277 4 + /* atime[4] */
278 4 + /* mtime[4] */
279 8 + /* length[8] */
280 8; /* minimum sum of string lengths */
281
282 if (stat->name)
283 size += strlen(stat->name);
284 if (stat->uid)
285 size += strlen(stat->uid);
286 if (stat->gid)
287 size += strlen(stat->gid);
288 if (stat->muid)
289 size += strlen(stat->muid);
290
291 if (v9ses->extended) {
292 size += 4 + /* n_uid[4] */
293 4 + /* n_gid[4] */
294 4 + /* n_muid[4] */
295 2; /* string length of extension[4] */
296 if (stat->extension)
297 size += strlen(stat->extension);
298 }
299
300 return size;
301 }
302
303 /**
304 * serialize_stat - safely format a stat structure for transmission
305 * @v9ses: session info
306 * @stat: metadata (stat) structure
307 * @bufp: buffer to serialize structure into
308 *
309 */
310
311 static int
312 serialize_stat(struct v9fs_session_info *v9ses, struct v9fs_stat *stat,
313 struct cbuf *bufp)
314 {
315 buf_put_int16(bufp, stat->size);
316 buf_put_int16(bufp, stat->type);
317 buf_put_int32(bufp, stat->dev);
318 buf_put_int8(bufp, stat->qid.type);
319 buf_put_int32(bufp, stat->qid.version);
320 buf_put_int64(bufp, stat->qid.path);
321 buf_put_int32(bufp, stat->mode);
322 buf_put_int32(bufp, stat->atime);
323 buf_put_int32(bufp, stat->mtime);
324 buf_put_int64(bufp, stat->length);
325
326 buf_put_string(bufp, stat->name);
327 buf_put_string(bufp, stat->uid);
328 buf_put_string(bufp, stat->gid);
329 buf_put_string(bufp, stat->muid);
330
331 if (v9ses->extended) {
332 buf_put_string(bufp, stat->extension);
333 buf_put_int32(bufp, stat->n_uid);
334 buf_put_int32(bufp, stat->n_gid);
335 buf_put_int32(bufp, stat->n_muid);
336 }
337
338 if (buf_check_overflow(bufp))
339 return 0;
340
341 return stat->size;
342 }
343
344 /**
345 * deserialize_stat - safely decode a recieved metadata (stat) structure
346 * @v9ses: session info
347 * @bufp: buffer to deserialize
348 * @stat: metadata (stat) structure
349 * @dbufp: buffer to deserialize variable strings into
350 *
351 */
352
353 static inline int
354 deserialize_stat(struct v9fs_session_info *v9ses, struct cbuf *bufp,
355 struct v9fs_stat *stat, struct cbuf *dbufp)
356 {
357
358 stat->size = buf_get_int16(bufp);
359 stat->type = buf_get_int16(bufp);
360 stat->dev = buf_get_int32(bufp);
361 stat->qid.type = buf_get_int8(bufp);
362 stat->qid.version = buf_get_int32(bufp);
363 stat->qid.path = buf_get_int64(bufp);
364 stat->mode = buf_get_int32(bufp);
365 stat->atime = buf_get_int32(bufp);
366 stat->mtime = buf_get_int32(bufp);
367 stat->length = buf_get_int64(bufp);
368 stat->name = buf_get_stringb(bufp, dbufp);
369 stat->uid = buf_get_stringb(bufp, dbufp);
370 stat->gid = buf_get_stringb(bufp, dbufp);
371 stat->muid = buf_get_stringb(bufp, dbufp);
372
373 if (v9ses->extended) {
374 stat->extension = buf_get_stringb(bufp, dbufp);
375 stat->n_uid = buf_get_int32(bufp);
376 stat->n_gid = buf_get_int32(bufp);
377 stat->n_muid = buf_get_int32(bufp);
378 }
379
380 if (buf_check_overflow(bufp) || buf_check_overflow(dbufp))
381 return 0;
382
383 return stat->size + 2;
384 }
385
386 /**
387 * deserialize_statb - wrapper for decoding a received metadata structure
388 * @v9ses: session info
389 * @bufp: buffer to deserialize
390 * @dbufp: buffer to deserialize variable strings into
391 *
392 */
393
394 static inline struct v9fs_stat *deserialize_statb(struct v9fs_session_info
395 *v9ses, struct cbuf *bufp,
396 struct cbuf *dbufp)
397 {
398 struct v9fs_stat *ret = buf_alloc(dbufp, sizeof(struct v9fs_stat));
399
400 if (ret) {
401 int n = deserialize_stat(v9ses, bufp, ret, dbufp);
402 if (n <= 0)
403 return NULL;
404 }
405
406 return ret;
407 }
408
409 /**
410 * v9fs_deserialize_stat - decode a received metadata structure
411 * @v9ses: session info
412 * @buf: buffer to deserialize
413 * @buflen: length of received buffer
414 * @stat: metadata structure to decode into
415 * @statlen: length of destination metadata structure
416 *
417 */
418
419 int
420 v9fs_deserialize_stat(struct v9fs_session_info *v9ses, void *buf,
421 u32 buflen, struct v9fs_stat *stat, u32 statlen)
422 {
423 struct cbuf buffer;
424 struct cbuf *bufp = &buffer;
425 struct cbuf dbuffer;
426 struct cbuf *dbufp = &dbuffer;
427
428 buf_init(bufp, buf, buflen);
429 buf_init(dbufp, (char *)stat + sizeof(struct v9fs_stat),
430 statlen - sizeof(struct v9fs_stat));
431
432 return deserialize_stat(v9ses, bufp, stat, dbufp);
433 }
434
435 static inline int
436 v9fs_size_fcall(struct v9fs_session_info *v9ses, struct v9fs_fcall *fcall)
437 {
438 int size = 4 + 1 + 2; /* size[4] msg[1] tag[2] */
439 int i = 0;
440
441 switch (fcall->id) {
442 default:
443 eprintk(KERN_ERR, "bad msg type %d\n", fcall->id);
444 return 0;
445 case TVERSION: /* msize[4] version[s] */
446 size += 4 + 2 + strlen(fcall->params.tversion.version);
447 break;
448 case TAUTH: /* afid[4] uname[s] aname[s] */
449 size += 4 + 2 + strlen(fcall->params.tauth.uname) +
450 2 + strlen(fcall->params.tauth.aname);
451 break;
452 case TFLUSH: /* oldtag[2] */
453 size += 2;
454 break;
455 case TATTACH: /* fid[4] afid[4] uname[s] aname[s] */
456 size += 4 + 4 + 2 + strlen(fcall->params.tattach.uname) +
457 2 + strlen(fcall->params.tattach.aname);
458 break;
459 case TWALK: /* fid[4] newfid[4] nwname[2] nwname*(wname[s]) */
460 size += 4 + 4 + 2;
461 /* now compute total for the array of names */
462 for (i = 0; i < fcall->params.twalk.nwname; i++)
463 size += 2 + strlen(fcall->params.twalk.wnames[i]);
464 break;
465 case TOPEN: /* fid[4] mode[1] */
466 size += 4 + 1;
467 break;
468 case TCREATE: /* fid[4] name[s] perm[4] mode[1] */
469 size += 4 + 2 + strlen(fcall->params.tcreate.name) + 4 + 1;
470 break;
471 case TREAD: /* fid[4] offset[8] count[4] */
472 size += 4 + 8 + 4;
473 break;
474 case TWRITE: /* fid[4] offset[8] count[4] data[count] */
475 size += 4 + 8 + 4 + fcall->params.twrite.count;
476 break;
477 case TCLUNK: /* fid[4] */
478 size += 4;
479 break;
480 case TREMOVE: /* fid[4] */
481 size += 4;
482 break;
483 case TSTAT: /* fid[4] */
484 size += 4;
485 break;
486 case TWSTAT: /* fid[4] stat[n] */
487 fcall->params.twstat.stat->size =
488 v9fs_size_stat(v9ses, fcall->params.twstat.stat);
489 size += 4 + 2 + 2 + fcall->params.twstat.stat->size;
490 }
491 return size;
492 }
493
494 /*
495 * v9fs_serialize_fcall - marshall fcall struct into a packet
496 * @v9ses: session information
497 * @fcall: structure to convert
498 * @data: buffer to serialize fcall into
499 * @datalen: length of buffer to serialize fcall into
500 *
501 */
502
503 int
504 v9fs_serialize_fcall(struct v9fs_session_info *v9ses, struct v9fs_fcall *fcall,
505 void *data, u32 datalen)
506 {
507 int i = 0;
508 struct v9fs_stat *stat = NULL;
509 struct cbuf buffer;
510 struct cbuf *bufp = &buffer;
511
512 buf_init(bufp, data, datalen);
513
514 if (!fcall) {
515 eprintk(KERN_ERR, "no fcall\n");
516 return -EINVAL;
517 }
518
519 fcall->size = v9fs_size_fcall(v9ses, fcall);
520
521 buf_put_int32(bufp, fcall->size);
522 buf_put_int8(bufp, fcall->id);
523 buf_put_int16(bufp, fcall->tag);
524
525 dprintk(DEBUG_CONV, "size %d id %d tag %d\n", fcall->size, fcall->id,
526 fcall->tag);
527
528 /* now encode it */
529 switch (fcall->id) {
530 default:
531 eprintk(KERN_ERR, "bad msg type: %d\n", fcall->id);
532 return -EPROTO;
533 case TVERSION:
534 buf_put_int32(bufp, fcall->params.tversion.msize);
535 buf_put_string(bufp, fcall->params.tversion.version);
536 break;
537 case TAUTH:
538 buf_put_int32(bufp, fcall->params.tauth.afid);
539 buf_put_string(bufp, fcall->params.tauth.uname);
540 buf_put_string(bufp, fcall->params.tauth.aname);
541 break;
542 case TFLUSH:
543 buf_put_int16(bufp, fcall->params.tflush.oldtag);
544 break;
545 case TATTACH:
546 buf_put_int32(bufp, fcall->params.tattach.fid);
547 buf_put_int32(bufp, fcall->params.tattach.afid);
548 buf_put_string(bufp, fcall->params.tattach.uname);
549 buf_put_string(bufp, fcall->params.tattach.aname);
550 break;
551 case TWALK:
552 buf_put_int32(bufp, fcall->params.twalk.fid);
553 buf_put_int32(bufp, fcall->params.twalk.newfid);
554 buf_put_int16(bufp, fcall->params.twalk.nwname);
555 for (i = 0; i < fcall->params.twalk.nwname; i++)
556 buf_put_string(bufp, fcall->params.twalk.wnames[i]);
557 break;
558 case TOPEN:
559 buf_put_int32(bufp, fcall->params.topen.fid);
560 buf_put_int8(bufp, fcall->params.topen.mode);
561 break;
562 case TCREATE:
563 buf_put_int32(bufp, fcall->params.tcreate.fid);
564 buf_put_string(bufp, fcall->params.tcreate.name);
565 buf_put_int32(bufp, fcall->params.tcreate.perm);
566 buf_put_int8(bufp, fcall->params.tcreate.mode);
567 break;
568 case TREAD:
569 buf_put_int32(bufp, fcall->params.tread.fid);
570 buf_put_int64(bufp, fcall->params.tread.offset);
571 buf_put_int32(bufp, fcall->params.tread.count);
572 break;
573 case TWRITE:
574 buf_put_int32(bufp, fcall->params.twrite.fid);
575 buf_put_int64(bufp, fcall->params.twrite.offset);
576 buf_put_int32(bufp, fcall->params.twrite.count);
577 buf_put_data(bufp, fcall->params.twrite.data,
578 fcall->params.twrite.count);
579 break;
580 case TCLUNK:
581 buf_put_int32(bufp, fcall->params.tclunk.fid);
582 break;
583 case TREMOVE:
584 buf_put_int32(bufp, fcall->params.tremove.fid);
585 break;
586 case TSTAT:
587 buf_put_int32(bufp, fcall->params.tstat.fid);
588 break;
589 case TWSTAT:
590 buf_put_int32(bufp, fcall->params.twstat.fid);
591 stat = fcall->params.twstat.stat;
592
593 buf_put_int16(bufp, stat->size + 2);
594 serialize_stat(v9ses, stat, bufp);
595 break;
596 }
597
598 if (buf_check_overflow(bufp))
599 return -EIO;
600
601 return fcall->size;
602 }
603
604 /**
605 * deserialize_fcall - unmarshal a response
606 * @v9ses: session information
607 * @msgsize: size of rcall message
608 * @buf: recieved buffer
609 * @buflen: length of received buffer
610 * @rcall: fcall structure to populate
611 * @rcalllen: length of fcall structure to populate
612 *
613 */
614
615 int
616 v9fs_deserialize_fcall(struct v9fs_session_info *v9ses, u32 msgsize,
617 void *buf, u32 buflen, struct v9fs_fcall *rcall,
618 int rcalllen)
619 {
620
621 struct cbuf buffer;
622 struct cbuf *bufp = &buffer;
623 struct cbuf dbuffer;
624 struct cbuf *dbufp = &dbuffer;
625 int i = 0;
626
627 buf_init(bufp, buf, buflen);
628 buf_init(dbufp, (char *)rcall + sizeof(struct v9fs_fcall),
629 rcalllen - sizeof(struct v9fs_fcall));
630
631 rcall->size = msgsize;
632 rcall->id = buf_get_int8(bufp);
633 rcall->tag = buf_get_int16(bufp);
634
635 dprintk(DEBUG_CONV, "size %d id %d tag %d\n", rcall->size, rcall->id,
636 rcall->tag);
637 switch (rcall->id) {
638 default:
639 eprintk(KERN_ERR, "unknown message type: %d\n", rcall->id);
640 return -EPROTO;
641 case RVERSION:
642 rcall->params.rversion.msize = buf_get_int32(bufp);
643 rcall->params.rversion.version = buf_get_stringb(bufp, dbufp);
644 break;
645 case RFLUSH:
646 break;
647 case RATTACH:
648 rcall->params.rattach.qid.type = buf_get_int8(bufp);
649 rcall->params.rattach.qid.version = buf_get_int32(bufp);
650 rcall->params.rattach.qid.path = buf_get_int64(bufp);
651 break;
652 case RWALK:
653 rcall->params.rwalk.nwqid = buf_get_int16(bufp);
654 rcall->params.rwalk.wqids = buf_alloc(dbufp,
655 rcall->params.rwalk.nwqid * sizeof(struct v9fs_qid));
656 if (rcall->params.rwalk.wqids)
657 for (i = 0; i < rcall->params.rwalk.nwqid; i++) {
658 rcall->params.rwalk.wqids[i].type =
659 buf_get_int8(bufp);
660 rcall->params.rwalk.wqids[i].version =
661 buf_get_int16(bufp);
662 rcall->params.rwalk.wqids[i].path =
663 buf_get_int64(bufp);
664 }
665 break;
666 case ROPEN:
667 rcall->params.ropen.qid.type = buf_get_int8(bufp);
668 rcall->params.ropen.qid.version = buf_get_int32(bufp);
669 rcall->params.ropen.qid.path = buf_get_int64(bufp);
670 rcall->params.ropen.iounit = buf_get_int32(bufp);
671 break;
672 case RCREATE:
673 rcall->params.rcreate.qid.type = buf_get_int8(bufp);
674 rcall->params.rcreate.qid.version = buf_get_int32(bufp);
675 rcall->params.rcreate.qid.path = buf_get_int64(bufp);
676 rcall->params.rcreate.iounit = buf_get_int32(bufp);
677 break;
678 case RREAD:
679 rcall->params.rread.count = buf_get_int32(bufp);
680 rcall->params.rread.data = buf_get_datab(bufp, dbufp,
681 rcall->params.rread.count);
682 break;
683 case RWRITE:
684 rcall->params.rwrite.count = buf_get_int32(bufp);
685 break;
686 case RCLUNK:
687 break;
688 case RREMOVE:
689 break;
690 case RSTAT:
691 buf_get_int16(bufp);
692 rcall->params.rstat.stat =
693 deserialize_statb(v9ses, bufp, dbufp);
694 break;
695 case RWSTAT:
696 break;
697 case RERROR:
698 rcall->params.rerror.error = buf_get_stringb(bufp, dbufp);
699 if (v9ses->extended)
700 rcall->params.rerror.errno = buf_get_int16(bufp);
701 break;
702 }
703
704 if (buf_check_overflow(bufp) || buf_check_overflow(dbufp))
705 return -EIO;
706
707 return rcall->size;
708 }
linux v2.6.22.y-op