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 <auth.h>
4 
#include	"9p1.h"
5 
#pragma	varargck	type	"D"	Dir*	/* from fcall.h */
6 
 
7 
static void dumpsome(char*, char*, long);
8 
 
9 
int
10 
fcallfmt9p1(Fmt *f1)
11 
{
12 
	Fcall9p1 *f;
13 
	int fid, type, tag, n;
14 
	char buf[512];
15 
	Dir d;
16 
 
17 
	f = va_arg(f1->args, Fcall9p1*);
18 
	type = f->type;
19 
	fid = f->fid;
20 
	tag = f->tag;
21 
	switch(type){
22 
	case Tnop9p1:	/* 50 */
23 
		sprint(buf, "old Tnop tag %ud", tag);
24 
		break;
25 
	case Rnop9p1:
26 
		sprint(buf, "old Rnop tag %ud", tag);
27 
		break;
28 
	case Tsession9p1:	/* 52 */
29 
		sprint(buf, "old Tsession tag %ud", tag);
30 
		break;
31 
	case Rsession9p1:
32 
		sprint(buf, "old Rsession tag %ud", tag);
33 
		break;
34 
	case Rerror9p1:	/* 55 */
35 
		sprint(buf, "old Rerror tag %ud error %.64s", tag, f->ename);
36 
		break;
37 
	case Tflush9p1:	/* 56 */
38 
		sprint(buf, "old Tflush tag %ud oldtag %d", tag, f->oldtag);
39 
		break;
40 
	case Rflush9p1:
41 
		sprint(buf, "old Rflush tag %ud", tag);
42 
		break;
43 
	case Tattach9p1:	/* 58 */
44 
		sprint(buf, "old Tattach tag %ud fid %d uname %.28s aname %.28s auth %.28s",
45 
			tag, f->fid, f->uname, f->aname, f->auth);
46 
		break;
47 
	case Rattach9p1:
48 
		sprint(buf, "old Rattach tag %ud fid %d qid 0x%lux|0x%lux",
49 
			tag, fid, f->qid.path, f->qid.version);
50 
		break;
51 
	case Tclone9p1:	/* 60 */
52 
		sprint(buf, "old Tclone tag %ud fid %d newfid %d", tag, fid, f->newfid);
53 
		break;
54 
	case Rclone9p1:
55 
		sprint(buf, "old Rclone tag %ud fid %d", tag, fid);
56 
		break;
57 
	case Twalk9p1:	/* 62 */
58 
		sprint(buf, "old Twalk tag %ud fid %d name %.28s", tag, fid, f->name);
59 
		break;
60 
	case Rwalk9p1:
61 
		sprint(buf, "old Rwalk tag %ud fid %d qid 0x%lux|0x%lux",
62 
			tag, fid, f->qid.path, f->qid.version);
63 
		break;
64 
	case Topen9p1:	/* 64 */
65 
		sprint(buf, "old Topen tag %ud fid %d mode %d", tag, fid, f->mode);
66 
		break;
67 
	case Ropen9p1:
68 
		sprint(buf, "old Ropen tag %ud fid %d qid 0x%lux|0x%lux",
69 
			tag, fid, f->qid.path, f->qid.version);
70 
		break;
71 
	case Tcreate9p1:	/* 66 */
72 
		sprint(buf, "old Tcreate tag %ud fid %d name %.28s perm 0x%lux mode %d",
73 
			tag, fid, f->name, f->perm, f->mode);
74 
		break;
75 
	case Rcreate9p1:
76 
		sprint(buf, "old Rcreate tag %ud fid %d qid 0x%lux|0x%lux",
77 
			tag, fid, f->qid.path, f->qid.version);
78 
		break;
79 
	case Tread9p1:	/* 68 */
80 
		sprint(buf, "old Tread tag %ud fid %d offset %ld count %ld",
81 
			tag, fid, f->offset, f->count);
82 
		break;
83 
	case Rread9p1:
84 
		n = sprint(buf, "old Rread tag %ud fid %d count %ld ", tag, fid, f->count);
85 
			dumpsome(buf+n, f->data, f->count);
86 
		break;
87 
	case Twrite9p1:	/* 70 */
88 
		n = sprint(buf, "old Twrite tag %ud fid %d offset %ld count %ld ",
89 
			tag, fid, f->offset, f->count);
90 
		dumpsome(buf+n, f->data, f->count);
91 
		break;
92 
	case Rwrite9p1:
93 
		sprint(buf, "old Rwrite tag %ud fid %d count %ld", tag, fid, f->count);
94 
		break;
95 
	case Tclunk9p1:	/* 72 */
96 
		sprint(buf, "old Tclunk tag %ud fid %d", tag, fid);
97 
		break;
98 
	case Rclunk9p1:
99 
		sprint(buf, "old Rclunk tag %ud fid %d", tag, fid);
100 
		break;
101 
	case Tremove9p1:	/* 74 */
102 
		sprint(buf, "old Tremove tag %ud fid %d", tag, fid);
103 
		break;
104 
	case Rremove9p1:
105 
		sprint(buf, "old Rremove tag %ud fid %d", tag, fid);
106 
		break;
107 
	case Tstat9p1:	/* 76 */
108 
		sprint(buf, "old Tstat tag %ud fid %d", tag, fid);
109 
		break;
110 
	case Rstat9p1:
111 
		convM2D9p1(f->stat, &d);
112 
		sprint(buf, "old Rstat tag %ud fid %d stat %D", tag, fid, &d);
113 
		break;
114 
	case Twstat9p1:	/* 78 */
115 
		convM2D9p1(f->stat, &d);
116 
		sprint(buf, "old Twstat tag %ud fid %d stat %D", tag, fid, &d);
117 
		break;
118 
	case Rwstat9p1:
119 
		sprint(buf, "old Rwstat tag %ud fid %d", tag, fid);
120 
		break;
121 
	case Tclwalk9p1:	/* 81 */
122 
		sprint(buf, "old Tclwalk tag %ud fid %d newfid %d name %.28s",
123 
			tag, fid, f->newfid, f->name);
124 
		break;
125 
	case Rclwalk9p1:
126 
		sprint(buf, "old Rclwalk tag %ud fid %d qid 0x%lux|0x%lux",
127 
			tag, fid, f->qid.path, f->qid.version);
128 
		break;
129 
	default:
130 
		sprint(buf,  "unknown type %d", type);
131 
	}
132 
	return fmtstrcpy(f1, buf);
133 
}
134 
 
135 
/*
136 
 * dump out count (or DUMPL, if count is bigger) bytes from
137 
 * buf to ans, as a string if they are all printable,
138 
 * else as a series of hex bytes
139 
 */
140 
#define DUMPL 64
141 
 
142 
static void
143 
dumpsome(char *ans, char *buf, long count)
144 
{
145 
	int i, printable;
146 
	char *p;
147 
 
148 
	printable = 1;
149 
	if(count > DUMPL)
150 
		count = DUMPL;
151 
	for(i=0; i<count && printable; i++)
152 
		if((buf[i]<32 && buf[i] !='\n' && buf[i] !='\t') || (uchar)buf[i]>127)
153 
			printable = 0;
154 
	p = ans;
155 
	*p++ = '\'';
156 
	if(printable){
157 
		memmove(p, buf, count);
158 
		p += count;
159 
	}else{
160 
		for(i=0; i<count; i++){
161 
			if(i>0 && i%4==0)
162 
				*p++ = ' ';
163 
			sprint(p, "%2.2ux", buf[i]);
164 
			p += 2;
165 
		}
166 
	}
167 
	*p++ = '\'';
168 
	*p = 0;
169 
}
170 
 
171 
#define	CHAR(x)		*p++ = f->x
172 
#define	SHORT(x)	{ ulong vvv = f->x; p[0] = vvv; p[1] = vvv>>8; p += 2; }
173 
#define	VLONG(q)	p[0] = (q); p[1] = (q)>>8; p[2] = (q)>>16; p[3] = (q)>>24; p += 4
174 
#define	LONG(x)		{ ulong vvv = f->x; VLONG(vvv); }
175 
#define	BYTES(x,n)	memmove(p, f->x, n); p += n
176 
#define	STRING(x,n)	strncpy((char*)p, f->x, n); p += n
177 
 
178 
int
179 
convS2M9p1(Fcall9p1 *f, char *ap)
180 
{
181 
	uchar *p;
182 
	int t;
183 
 
184 
	p = (uchar*)ap;
185 
	CHAR(type);
186 
	t = f->type;
187 
	SHORT(tag);
188 
	switch(t)
189 
	{
190 
	default:
191 
		fprint(2, "convS2M9p1: bad type: %d\n", t);
192 
		return 0;
193 
 
194 
	case Tnop9p1:
195 
	case Tosession9p1:
196 
		break;
197 
 
198 
	case Tsession9p1:
199 
		BYTES(chal, sizeof(f->chal));
200 
		break;
201 
 
202 
	case Tflush9p1:
203 
		SHORT(oldtag);
204 
		break;
205 
 
206 
	case Tattach9p1:
207 
		SHORT(fid);
208 
		STRING(uname, sizeof(f->uname));
209 
		STRING(aname, sizeof(f->aname));
210 
		BYTES(ticket, sizeof(f->ticket));
211 
		BYTES(auth, sizeof(f->auth));
212 
		break;
213 
 
214 
	case Toattach9p1:
215 
		SHORT(fid);
216 
		STRING(uname, sizeof(f->uname));
217 
		STRING(aname, sizeof(f->aname));
218 
		BYTES(ticket, NAMEREC);
219 
		break;
220 
 
221 
	case Tclone9p1:
222 
		SHORT(fid);
223 
		SHORT(newfid);
224 
		break;
225 
 
226 
	case Twalk9p1:
227 
		SHORT(fid);
228 
		STRING(name, sizeof(f->name));
229 
		break;
230 
 
231 
	case Tclwalk9p1:
232 
		SHORT(fid);
233 
		SHORT(newfid);
234 
		STRING(name, sizeof(f->name));
235 
		break;
236 
 
237 
	case Topen9p1:
238 
		SHORT(fid);
239 
		CHAR(mode);
240 
		break;
241 
 
242 
	case Tcreate9p1:
243 
		SHORT(fid);
244 
		STRING(name, sizeof(f->name));
245 
		LONG(perm);
246 
		CHAR(mode);
247 
		break;
248 
 
249 
	case Tread9p1:
250 
		SHORT(fid);
251 
		LONG(offset); VLONG(0);
252 
		SHORT(count);
253 
		break;
254 
 
255 
	case Twrite9p1:
256 
		SHORT(fid);
257 
		LONG(offset); VLONG(0);
258 
		SHORT(count);
259 
		p++;
260 
		if((uchar*)p == (uchar*)f->data) {
261 
			p += f->count;
262 
			break;
263 
		}
264 
		BYTES(data, f->count);
265 
		break;
266 
 
267 
	case Tclunk9p1:
268 
	case Tremove9p1:
269 
	case Tstat9p1:
270 
		SHORT(fid);
271 
		break;
272 
 
273 
	case Twstat9p1:
274 
		SHORT(fid);
275 
		BYTES(stat, sizeof(f->stat));
276 
		break;
277 
/*
278 
 */
279 
	case Rnop9p1:
280 
	case Rosession9p1:
281 
	case Rflush9p1:
282 
		break;
283 
 
284 
	case Rsession9p1:
285 
		BYTES(chal, sizeof(f->chal));
286 
		BYTES(authid, sizeof(f->authid));
287 
		BYTES(authdom, sizeof(f->authdom));
288 
		break;
289 
 
290 
	case Rerror9p1:
291 
		STRING(ename, sizeof(f->ename));
292 
		break;
293 
 
294 
	case Rclone9p1:
295 
	case Rclunk9p1:
296 
	case Rremove9p1:
297 
	case Rwstat9p1:
298 
		SHORT(fid);
299 
		break;
300 
 
301 
	case Rwalk9p1:
302 
	case Ropen9p1:
303 
	case Rcreate9p1:
304 
	case Rclwalk9p1:
305 
		SHORT(fid);
306 
		LONG(qid.path);
307 
		LONG(qid.version);
308 
		break;
309 
 
310 
	case Rattach9p1:
311 
		SHORT(fid);
312 
		LONG(qid.path);
313 
		LONG(qid.version);
314 
		BYTES(rauth, sizeof(f->rauth));
315 
		break;
316 
 
317 
	case Roattach9p1:
318 
		SHORT(fid);
319 
		LONG(qid.path);
320 
		LONG(qid.version);
321 
		break;
322 
 
323 
	case Rread9p1:
324 
		SHORT(fid);
325 
		SHORT(count);
326 
		p++;
327 
		if((uchar*)p == (uchar*)f->data) {
328 
			p += f->count;
329 
			break;
330 
		}
331 
		BYTES(data, f->count);
332 
		break;
333 
 
334 
	case Rwrite9p1:
335 
		SHORT(fid);
336 
		SHORT(count);
337 
		break;
338 
 
339 
	case Rstat9p1:
340 
		SHORT(fid);
341 
		BYTES(stat, sizeof(f->stat));
342 
		break;
343 
	}
344 
	return p - (uchar*)ap;
345 
}
346 
 
347 
int
348 
convD2M9p1(Dir *f, char *ap)
349 
{
350 
	uchar *p;
351 
	ulong q;
352 
 
353 
	p = (uchar*)ap;
354 
	STRING(name, NAMEREC);
355 
	STRING(uid, NAMEREC);
356 
	STRING(gid, NAMEREC);
357 
 
358 
	q = f->qid.path & ~0x80000000;
359 
	if(f->qid.type & QTDIR)
360 
		q |= 0x80000000;
361 
	VLONG(q);
362 
	LONG(qid.vers);
363 
	LONG(mode);
364 
	LONG(atime);
365 
	LONG(mtime);
366 
	LONG(length); VLONG(0);
367 
	VLONG(0);
368 
	return p - (uchar*)ap;
369 
}
370 
 
371 
int
372 
convA2M9p1(Authenticator *f, char *ap, char *key)
373 
{
374 
	int n;
375 
	uchar *p;
376 
 
377 
	p = (uchar*)ap;
378 
	CHAR(num);
379 
	STRING(chal, CHALLEN);
380 
	LONG(id);
381 
	n = p - (uchar*)ap;
382 
	if(key)
383 
		encrypt(key, ap, n);
384 
	return n;
385 
}
386 
 
387 
#undef	CHAR
388 
#undef	SHORT
389 
#undef	LONG
390 
#undef	VLONG
391 
#undef	BYTES
392 
#undef	STRING
393 
 
394 
#define	CHAR(x)		f->x = *p++
395 
#define	SHORT(x)	f->x = (p[0] | (p[1]<<8)); p += 2
396 
#define	VLONG(q)	q = (p[0] | (p[1]<<8) | (p[2]<<16) | (p[3]<<24)); p += 4
397 
#define	LONG(x)		VLONG(f->x)
398 
#define	BYTES(x,n)	memmove(f->x, p, n); p += n
399 
#define	STRING(x,n)	memmove(f->x, p, n); p += n
400 
 
401 
int
402 
convM2S9p1(char *ap, Fcall9p1 *f, int n)
403 
{
404 
	uchar *p;
405 
	int t;
406 
 
407 
	p = (uchar*)ap;
408 
	CHAR(type);
409 
	t = f->type;
410 
	SHORT(tag);
411 
	switch(t)
412 
	{
413 
	default:
414 
		fprint(2, "convM2S9p1: bad type: %d\n", f->type);
415 
		return 0;
416 
 
417 
	case Tnop9p1:
418 
	case Tosession9p1:
419 
		break;
420 
 
421 
	case Tsession9p1:
422 
		BYTES(chal, sizeof(f->chal));
423 
		break;
424 
 
425 
	case Tflush9p1:
426 
		SHORT(oldtag);
427 
		break;
428 
 
429 
	case Tattach9p1:
430 
		SHORT(fid);
431 
		BYTES(uname, sizeof(f->uname));
432 
		BYTES(aname, sizeof(f->aname));
433 
		BYTES(ticket, sizeof(f->ticket));
434 
		BYTES(auth, sizeof(f->auth));
435 
		break;
436 
 
437 
	case Toattach9p1:
438 
		SHORT(fid);
439 
		BYTES(uname, sizeof(f->uname));
440 
		BYTES(aname, sizeof(f->aname));
441 
		BYTES(ticket, NAMEREC);
442 
		break;
443 
 
444 
	case Tclone9p1:
445 
		SHORT(fid);
446 
		SHORT(newfid);
447 
		break;
448 
 
449 
	case Twalk9p1:
450 
		SHORT(fid);
451 
		BYTES(name, sizeof(f->name));
452 
		break;
453 
 
454 
	case Tclwalk9p1:
455 
		SHORT(fid);
456 
		SHORT(newfid);
457 
		BYTES(name, sizeof(f->name));
458 
		break;
459 
 
460 
	case Tremove9p1:
461 
		SHORT(fid);
462 
		break;
463 
 
464 
	case Topen9p1:
465 
		SHORT(fid);
466 
		CHAR(mode);
467 
		break;
468 
 
469 
	case Tcreate9p1:
470 
		SHORT(fid);
471 
		BYTES(name, sizeof(f->name));
472 
		LONG(perm);
473 
		CHAR(mode);
474 
		break;
475 
 
476 
	case Tread9p1:
477 
		SHORT(fid);
478 
		LONG(offset); p += 4;
479 
		SHORT(count);
480 
		break;
481 
 
482 
	case Twrite9p1:
483 
		SHORT(fid);
484 
		LONG(offset); p += 4;
485 
		SHORT(count);
486 
		p++;
487 
		f->data = (char*)p; p += f->count;
488 
		break;
489 
 
490 
	case Tclunk9p1:
491 
	case Tstat9p1:
492 
		SHORT(fid);
493 
		break;
494 
 
495 
	case Twstat9p1:
496 
		SHORT(fid);
497 
		BYTES(stat, sizeof(f->stat));
498 
		break;
499 
 
500 
/*
501 
 */
502 
	case Rnop9p1:
503 
	case Rosession9p1:
504 
		break;
505 
 
506 
	case Rsession9p1:
507 
		BYTES(chal, sizeof(f->chal));
508 
		BYTES(authid, sizeof(f->authid));
509 
		BYTES(authdom, sizeof(f->authdom));
510 
		break;
511 
 
512 
	case Rerror9p1:
513 
		BYTES(ename, sizeof(f->ename));
514 
		break;
515 
 
516 
	case Rflush9p1:
517 
		break;
518 
 
519 
	case Rclone9p1:
520 
	case Rclunk9p1:
521 
	case Rremove9p1:
522 
	case Rwstat9p1:
523 
		SHORT(fid);
524 
		break;
525 
 
526 
	case Rwalk9p1:
527 
	case Rclwalk9p1:
528 
	case Ropen9p1:
529 
	case Rcreate9p1:
530 
		SHORT(fid);
531 
		LONG(qid.path);
532 
		LONG(qid.version);
533 
		break;
534 
 
535 
	case Rattach9p1:
536 
		SHORT(fid);
537 
		LONG(qid.path);
538 
		LONG(qid.version);
539 
		BYTES(rauth, sizeof(f->rauth));
540 
		break;
541 
 
542 
	case Roattach9p1:
543 
		SHORT(fid);
544 
		LONG(qid.path);
545 
		LONG(qid.version);
546 
		break;
547 
 
548 
	case Rread9p1:
549 
		SHORT(fid);
550 
		SHORT(count);
551 
		p++;
552 
		f->data = (char*)p; p += f->count;
553 
		break;
554 
 
555 
	case Rwrite9p1:
556 
		SHORT(fid);
557 
		SHORT(count);
558 
		break;
559 
 
560 
	case Rstat9p1:
561 
		SHORT(fid);
562 
		BYTES(stat, sizeof(f->stat));
563 
		break;
564 
	}
565 
	if((uchar*)ap+n == p)
566 
		return n;
567 
	return 0;
568 
}
569 
 
570 
int
571 
convM2D9p1(char *ap, Dir *f)
572 
{
573 
	uchar *p;
574 
 
575 
	p = (uchar*)ap;
576 
	f->name = (char*)p;
577 
	p += NAMEREC;
578 
	f->uid = (char*)p;
579 
	f->muid = (char*)p;
580 
	p += NAMEREC;
581 
	f->gid = (char*)p;
582 
	p += NAMEREC;
583 
 
584 
	LONG(qid.path);
585 
	f->qid.path &= ~0x80000000;
586 
 
587 
	LONG(qid.vers);
588 
	LONG(mode);
589 
	f->qid.type = f->mode >> 24;
590 
	LONG(atime);
591 
	LONG(mtime);
592 
	LONG(length); p += 4;
593 
	p += 4;
594 
	return p - (uchar*)ap;
595 
}
596 
 
597 
void
598 
convM2A9p1(char *ap, Authenticator *f, char *key)
599 
{
600 
	uchar *p;
601 
 
602 
	if(key)
603 
		decrypt(key, ap, AUTHENTLEN);
604 
	p = (uchar*)ap;
605 
	CHAR(num);
606 
	STRING(chal, CHALLEN);
607 
	LONG(id);
608 
	USED(p);
609 
}
610 
 
611 
void
612 
convM2T9p1(char *ap, Ticket *f, char *key)
613 
{
614 
	uchar *p;
615 
 
616 
	if(key)
617 
		decrypt(key, ap, TICKETLEN);
618 
	p = (uchar*)ap;
619 
	CHAR(num);
620 
	STRING(chal, CHALLEN);
621 
	STRING(cuid, NAMEREC);
622 
	f->cuid[NAMEREC-1] = 0;
623 
	STRING(suid, NAMEREC);
624 
	f->suid[NAMEREC-1] = 0;
625 
	STRING(key, DESKEYLEN);
626 
	USED(p);
627 
};