op public repos

Blob

Date:: Sun Mar 21 04:33:13 2004 UTC
Message:: Small tweaks Lots of new code imported.
Actions:: History | Blame | Raw File
1 #include <u.h>
2 #include <libc.h>
3 #include <auth.h>
4 #include <fcall.h>
5 #include <thread.h>
6 #include <9p.h>
7 
8 // static char Ebadattach[] = "unknown specifier in attach";
9 static char Ebadoffset[] = "bad offset";
10 // static char Ebadcount[] = "bad count";
11 static char Ebotch[] = "9P protocol botch";
12 static char Ecreatenondir[] = "create in non-directory";
13 static char Edupfid[] = "duplicate fid";
14 static char Eduptag[] = "duplicate tag";
15 static char Eisdir[] = "is a directory";
16 static char Enocreate[] = "create prohibited";
17 // static char Enomem[] = "out of memory";
18 static char Enoremove[] = "remove prohibited";
19 static char Enostat[] = "stat prohibited";
20 static char Enotfound[] = "file not found";
21 // static char Enowrite[] = "write prohibited";
22 static char Enowstat[] = "wstat prohibited";
23 static char Eperm[] = "permission denied";
24 static char Eunknownfid[] = "unknown fid";
25 static char Ebaddir[] = "bad directory in wstat";
26 static char Ewalknodir[] = "walk in non-directory";
27 
28 static void
29 setfcallerror(Fcall *f, char *err)
30 {
31 	f->ename = err;
32 	f->type = Rerror;
33 }
34 
35 static void
36 changemsize(Srv *srv, int msize)
37 {
38 	if(srv->rbuf && srv->wbuf && srv->msize == msize)
39 		return;
40 	qlock(&srv->rlock);
41 	qlock(&srv->wlock);
42 	srv->msize = msize;
43 	free(srv->rbuf);
44 	free(srv->wbuf);
45 	srv->rbuf = emalloc9p(msize);
46 	srv->wbuf = emalloc9p(msize);
47 	qunlock(&srv->rlock);
48 	qunlock(&srv->wlock);
49 }
50 
51 static Req*
52 getreq(Srv *s)
53 {
54 	long n;
55 	uchar *buf;
56 	Fcall f;
57 	Req *r;
58 
59 	qlock(&s->rlock);
60 	if((n = read9pmsg(s->infd, s->rbuf, s->msize)) <= 0){
61 		qunlock(&s->rlock);
62 		return nil;
63 	}
64 
65 	buf = emalloc9p(n);
66 	memmove(buf, s->rbuf, n);
67 	qunlock(&s->rlock);
68 
69 	if(convM2S(buf, n, &f) != n){
70 		free(buf);
71 		return nil;
72 	}
73 
74 	if((r=allocreq(s->rpool, f.tag)) == nil){	/* duplicate tag: cons up a fake Req */
75 		r = emalloc9p(sizeof *r);
76 		incref(&r->ref);
77 		r->tag = f.tag;
78 		r->ifcall = f;
79 		r->error = Eduptag;
80 		r->buf = buf;
81 		r->responded = 0;
82 		r->type = 0;
83 		r->srv = s;
84 		r->pool = nil;
85 if(chatty9p)
86 	fprint(2, "<-%d- %F: dup tag\n", s->infd, &f);
87 		return r;
88 	}
89 
90 	r->srv = s;
91 	r->responded = 0;
92 	r->buf = buf;
93 	r->ifcall = f;
94 	memset(&r->ofcall, 0, sizeof r->ofcall);
95 	r->type = r->ifcall.type;
96 
97 if(chatty9p)
98 	if(r->error)
99 		fprint(2, "<-%d- %F: %s\n", s->infd, &r->ifcall, r->error);
100 	else	
101 		fprint(2, "<-%d- %F\n", s->infd, &r->ifcall);
102 
103 	return r;
104 }
105 
106 static void
107 filewalk(Req *r)
108 {
109 	int i;
110 	File *f;
111 
112 	f = r->fid->file;
113 	assert(f != nil);
114 
115 	incref(&f->ref);
116 	for(i=0; i<r->ifcall.nwname; i++)
117 		if(f = walkfile(f, r->ifcall.wname[i]))
118 			r->ofcall.wqid[i] = f->dir.qid;
119 		else
120 			break;
121 
122 	r->ofcall.nwqid = i;
123 	if(f){
124 		r->newfid->file = f;
125 		r->newfid->qid = r->newfid->file->dir.qid;
126 	}
127 	respond(r, nil);
128 }
129 
130 void
131 walkandclone(Req *r, char *(*walk1)(Fid*, char*, void*), char *(*clone)(Fid*, Fid*, void*), void *arg)
132 {
133 	int i;
134 	char *e;
135 
136 	if(r->fid == r->newfid && r->ifcall.nwname > 1){
137 		respond(r, "lib9p: unused documented feature not implemented");
138 		return;
139 	}
140 
141 	if(r->fid != r->newfid){
142 		r->newfid->qid = r->fid->qid;
143 		if(clone && (e = clone(r->fid, r->newfid, arg))){
144 			respond(r, e);
145 			return;
146 		}
147 	}
148 
149 	e = nil;
150 	for(i=0; i<r->ifcall.nwname; i++){
151 		if(e = walk1(r->newfid, r->ifcall.wname[i], arg))
152 			break;
153 		r->ofcall.wqid[i] = r->newfid->qid;
154 	}
155 
156 	r->ofcall.nwqid = i;
157 	if(e && i==0)
158 		respond(r, e);
159 	else
160 		respond(r, nil);
161 }
162 
163 static void
164 sversion(Srv *srv, Req *r)
165 {
166 	USED(srv);
167 
168 	if(strncmp(r->ifcall.version, "9P", 2) != 0){
169 		r->ofcall.version = "unknown";
170 		respond(r, nil);
171 		return;
172 	}
173 
174 	r->ofcall.version = "9P2000";
175 	r->ofcall.msize = r->ifcall.msize;
176 	respond(r, nil);
177 }
178 static void
179 rversion(Req *r, char *error)
180 {
181 	assert(error == nil);
182 	changemsize(r->srv, r->ofcall.msize);
183 }
184 
185 static void
186 sauth(Srv *srv, Req *r)
187 {
188 	char e[ERRMAX];
189 
190 	if((r->afid = allocfid(srv->fpool, r->ifcall.afid)) == nil){
191 		respond(r, Edupfid);
192 		return;
193 	}
194 	if(srv->auth)
195 		srv->auth(r);
196 	else{
197 		snprint(e, sizeof e, "%s: authentication not required", argv0);
198 		respond(r, e);
199 	}
200 }
201 static void
202 rauth(Req *r, char *error)
203 {
204 	if(error && r->afid)
205 		closefid(removefid(r->srv->fpool, r->afid->fid));
206 }
207 
208 static void
209 sattach(Srv *srv, Req *r)
210 {
211 	if((r->fid = allocfid(srv->fpool, r->ifcall.fid)) == nil){
212 		respond(r, Edupfid);
213 		return;
214 	}
215 	r->afid = nil;
216 	if(r->ifcall.afid != NOFID && (r->afid = lookupfid(srv->fpool, r->ifcall.afid)) == nil){
217 		respond(r, Eunknownfid);
218 		return;
219 	}
220 	r->fid->uid = estrdup9p(r->ifcall.uname);
221 	if(srv->tree){
222 		r->fid->file = srv->tree->root;
223 		/* BUG? incref(r->fid->file) ??? */
224 		r->ofcall.qid = r->fid->file->dir.qid;
225 		r->fid->qid = r->ofcall.qid;
226 	}
227 	if(srv->attach)
228 		srv->attach(r);
229 	else
230 		respond(r, nil);
231 	return;
232 }
233 static void
234 rattach(Req *r, char *error)
235 {
236 	if(error && r->fid)
237 		closefid(removefid(r->srv->fpool, r->fid->fid));
238 }
239 
240 static void
241 sflush(Srv *srv, Req *r)
242 {
243 	r->oldreq = lookupreq(srv->rpool, r->ifcall.oldtag);
244 	if(r->oldreq == nil || r->oldreq == r)
245 		respond(r, nil);
246 	else if(srv->flush)
247 		srv->flush(r);
248 	else
249 		respond(r, nil);
250 }
251 static int
252 rflush(Req *r, char *error)
253 {
254 	Req *or;
255 
256 	assert(error == nil);
257 	or = r->oldreq;
258 	if(or){
259 		qlock(&or->lk);
260 		if(or->responded == 0){
261 			or->flush = erealloc9p(or->flush, (or->nflush+1)*sizeof(or->flush[0]));
262 			or->flush[or->nflush++] = r;
263 			qunlock(&or->lk);
264 			return -1;		/* delay response until or is responded */
265 		}
266 		qunlock(&or->lk);
267 		closereq(or);
268 	}
269 	r->oldreq = nil;
270 	return 0;
271 }
272 
273 static char*
274 oldwalk1(Fid *fid, char *name, void *arg)
275 {
276 	char *e;
277 	Qid qid;
278 	Srv *srv;
279 
280 	srv = arg;
281 	e = srv->walk1(fid, name, &qid);
282 	if(e)
283 		return e;
284 	fid->qid = qid;
285 	return nil;
286 }
287 
288 static char*
289 oldclone(Fid *fid, Fid *newfid, void *arg)
290 {
291 	Srv *srv;
292 
293 	srv = arg;
294 	if(srv->clone == nil)
295 		return nil;
296 	return srv->clone(fid, newfid);
297 }
298 
299 static void
300 swalk(Srv *srv, Req *r)
301 {
302 	if((r->fid = lookupfid(srv->fpool, r->ifcall.fid)) == nil){
303 		respond(r, Eunknownfid);
304 		return;
305 	}
306 	if(r->fid->omode != -1){
307 		respond(r, "cannot clone open fid");
308 		return;
309 	}
310 	if(r->ifcall.nwname && !(r->fid->qid.type&QTDIR)){
311 		respond(r, Ewalknodir);
312 		return;
313 	}
314 	if(r->ifcall.fid != r->ifcall.newfid){
315 		if((r->newfid = allocfid(srv->fpool, r->ifcall.newfid)) == nil){
316 			respond(r, Edupfid);
317 			return;
318 		}
319 		r->newfid->uid = estrdup9p(r->fid->uid);
320 	}else{
321 		incref(&r->fid->ref);
322 		r->newfid = r->fid;
323 	}
324 	if(r->fid->file){
325 		filewalk(r);
326 	}else if(srv->walk1)
327 		walkandclone(r, oldwalk1, oldclone, srv);
328 	else if(srv->walk)
329 		srv->walk(r);
330 	else
331 		sysfatal("no walk function, no file trees");
332 }
333 static void
334 rwalk(Req *r, char *error)
335 {
336 	if(error || r->ofcall.nwqid < r->ifcall.nwname){
337 		if(r->ifcall.fid != r->ifcall.newfid && r->newfid)
338 			closefid(removefid(r->srv->fpool, r->newfid->fid));
339 		if (r->ofcall.nwqid==0){
340 			if(error==nil && r->ifcall.nwname!=0)
341 				r->error = Enotfound;
342 		}else
343 			r->error = nil;	// No error on partial walks
344 	}else{
345 		if(r->ofcall.nwqid == 0){
346 			/* Just a clone */
347 			r->newfid->qid = r->fid->qid;
348 		}else{
349 			/* if file trees are in use, filewalk took care of the rest */
350 			r->newfid->qid = r->ofcall.wqid[r->ofcall.nwqid-1];
351 		}
352 	}
353 }
354 
355 static void
356 sopen(Srv *srv, Req *r)
357 {
358 	int p;
359 
360 	if((r->fid = lookupfid(srv->fpool, r->ifcall.fid)) == nil){
361 		respond(r, Eunknownfid);
362 		return;
363 	}
364 	if(r->fid->omode != -1){
365 		respond(r, Ebotch);
366 		return;
367 	}
368 	if((r->fid->qid.type&QTDIR) && (r->ifcall.mode&~ORCLOSE) != OREAD){
369 		respond(r, Eisdir);
370 		return;
371 	}
372 	r->ofcall.qid = r->fid->qid;
373 	switch(r->ifcall.mode&3){
374 	default:
375 		assert(0);
376 	case OREAD:
377 		p = AREAD;	
378 		break;
379 	case OWRITE:
380 		p = AWRITE;
381 		break;
382 	case ORDWR:
383 		p = AREAD|AWRITE;
384 		break;
385 	case OEXEC:
386 		p = AEXEC;	
387 		break;
388 	}
389 	if(r->ifcall.mode&OTRUNC)
390 		p |= AWRITE;
391 	if((r->fid->qid.type&QTDIR) && p!=AREAD){
392 		respond(r, Eperm);
393 		return;
394 	}
395 	if(r->fid->file){
396 		if(!hasperm(r->fid->file, r->fid->uid, p)){
397 			respond(r, Eperm);
398 			return;
399 		}
400 	/* BUG RACE */
401 		if((r->ifcall.mode&ORCLOSE)
402 		&& !hasperm(r->fid->file->parent, r->fid->uid, AWRITE)){
403 			respond(r, Eperm);
404 			return;
405 		}
406 		r->ofcall.qid = r->fid->file->dir.qid;
407 		if((r->ofcall.qid.type&QTDIR)
408 		&& (r->fid->rdir = opendirfile(r->fid->file)) == nil){
409 			respond(r, "opendirfile failed");
410 			return;
411 		}
412 	}
413 	if(srv->open)
414 		srv->open(r);
415 	else
416 		respond(r, nil);
417 }
418 static void
419 ropen(Req *r, char *error)
420 {
421 	char errbuf[ERRMAX];
422 	if(error)
423 		return;
424 	if(chatty9p){
425 		snprint(errbuf, sizeof errbuf, "fid mode is 0x%ux\n", r->ifcall.mode);
426 		write(2, errbuf, strlen(errbuf));
427 	}
428 	r->fid->omode = r->ifcall.mode;
429 	r->fid->qid = r->ofcall.qid;
430 	if(r->ofcall.qid.type&QTDIR)
431 		r->fid->diroffset = 0;
432 }
433 
434 static void
435 screate(Srv *srv, Req *r)
436 {
437 	if((r->fid = lookupfid(srv->fpool, r->ifcall.fid)) == nil)
438 		respond(r, Eunknownfid);
439 	else if(r->fid->omode != -1)
440 		respond(r, Ebotch);
441 	else if(!(r->fid->qid.type&QTDIR))
442 		respond(r, Ecreatenondir);
443 	else if(r->fid->file && !hasperm(r->fid->file, r->fid->uid, AWRITE))
444 		respond(r, Eperm);
445 	else if(srv->create)
446 		srv->create(r);
447 	else
448 		respond(r, Enocreate);
449 }
450 static void
451 rcreate(Req *r, char *error)
452 {
453 	if(error)
454 		return;
455 	r->fid->omode = r->ifcall.mode;
456 	r->fid->qid = r->ofcall.qid;
457 }
458 
459 static void
460 sread(Srv *srv, Req *r)
461 {
462 	int o;
463 
464 	if((r->fid = lookupfid(srv->fpool, r->ifcall.fid)) == nil){
465 		respond(r, Eunknownfid);
466 		return;
467 	}
468 	if(r->ifcall.count < 0){
469 		respond(r, Ebotch);
470 		return;
471 	}
472 	if(r->ifcall.offset < 0
473 	|| ((r->fid->qid.type&QTDIR) && r->ifcall.offset != 0 && r->ifcall.offset != r->fid->diroffset)){
474 		respond(r, Ebadoffset);
475 		return;
476 	}
477 
478 	if(r->ifcall.count > srv->msize - IOHDRSZ)
479 		r->ifcall.count = srv->msize - IOHDRSZ;
480 	r->rbuf = emalloc9p(r->ifcall.count);
481 	r->ofcall.data = r->rbuf;
482 	o = r->fid->omode & 3;
483 	if(o != OREAD && o != ORDWR && o != OEXEC){
484 		respond(r, Ebotch);
485 		return;
486 	}
487 	if((r->fid->qid.type&QTDIR) && r->fid->file){
488 		r->ofcall.count = readdirfile(r->fid->rdir, r->rbuf, r->ifcall.count);
489 		respond(r, nil);
490 		return;
491 	}
492 	if(srv->read)
493 		srv->read(r);
494 	else
495 		respond(r, "no srv->read");
496 }
497 static void
498 rread(Req *r, char *error)
499 {
500 	if(error==nil && (r->fid->qid.type&QTDIR))
501 		r->fid->diroffset += r->ofcall.count;
502 }
503 
504 static void
505 swrite(Srv *srv, Req *r)
506 {
507 	int o;
508 	char e[ERRMAX];
509 
510 	if((r->fid = lookupfid(srv->fpool, r->ifcall.fid)) == nil){
511 		respond(r, Eunknownfid);
512 		return;
513 	}
514 	if(r->ifcall.count < 0){
515 		respond(r, Ebotch);
516 		return;
517 	}
518 	if(r->ifcall.offset < 0){
519 		respond(r, Ebotch);
520 		return;
521 	}
522 	if(r->ifcall.count > srv->msize - IOHDRSZ)
523 		r->ifcall.count = srv->msize - IOHDRSZ;
524 	o = r->fid->omode & 3;
525 	if(o != OWRITE && o != ORDWR){
526 		snprint(e, sizeof e, "write on fid with open mode 0x%ux", r->fid->omode);
527 		respond(r, e);
528 		return;
529 	}
530 	if(srv->write)
531 		srv->write(r);
532 	else
533 		respond(r, "no srv->write");
534 }
535 static void
536 rwrite(Req *r, char *error)
537 {
538 	if(error)
539 		return;
540 	if(r->fid->file)
541 		r->fid->file->dir.qid.vers++;
542 }
543 
544 static void
545 sclunk(Srv *srv, Req *r)
546 {
547 	if((r->fid = removefid(srv->fpool, r->ifcall.fid)) == nil)
548 		respond(r, Eunknownfid);
549 	else
550 		respond(r, nil);
551 }
552 static void
553 rclunk(Req *r, char *msg)
554 {
555 	USED(r);
556 	USED(msg);
557 }
558 
559 static void
560 sremove(Srv *srv, Req *r)
561 {
562 	if((r->fid = removefid(srv->fpool, r->ifcall.fid)) == nil){
563 		respond(r, Eunknownfid);
564 		return;
565 	}
566 	/* BUG RACE */
567 	if(r->fid->file && !hasperm(r->fid->file->parent, r->fid->uid, AWRITE)){
568 		respond(r, Eperm);
569 		return;
570 	}
571 	if(srv->remove)
572 		srv->remove(r);
573 	else
574 		respond(r, r->fid->file ? nil : Enoremove);
575 }
576 static void
577 rremove(Req *r, char *error, char *errbuf)
578 {
579 	if(error)
580 		return;
581 	if(r->fid->file){
582 		if(removefile(r->fid->file) < 0){
583 			snprint(errbuf, ERRMAX, "remove %s: %r", 
584 				r->fid->file->dir.name);
585 			r->error = errbuf;
586 		}
587 		r->fid->file = nil;
588 	}
589 }
590 
591 static void
592 sstat(Srv *srv, Req *r)
593 {
594 	if((r->fid = lookupfid(srv->fpool, r->ifcall.fid)) == nil){
595 		respond(r, Eunknownfid);
596 		return;
597 	}
598 	if(r->fid->file){
599 		r->d = r->fid->file->dir;
600 		if(r->d.name)
601 			r->d.name = estrdup9p(r->d.name);
602 		if(r->d.uid)
603 			r->d.uid = estrdup9p(r->d.uid);
604 		if(r->d.gid)
605 			r->d.gid = estrdup9p(r->d.gid);
606 		if(r->d.muid)
607 			r->d.muid = estrdup9p(r->d.muid);
608 	}
609 	if(srv->stat)	
610 		srv->stat(r);	
611 	else if(r->fid->file)
612 		respond(r, nil);
613 	else
614 		respond(r, Enostat);
615 }
616 static void
617 rstat(Req *r, char *error)
618 {
619 	int n;
620 	uchar *statbuf;
621 	uchar tmp[BIT16SZ];
622 
623 	if(error)
624 		return;
625 	if(convD2M(&r->d, tmp, BIT16SZ) != BIT16SZ){
626 		r->error = "convD2M(_,_,BIT16SZ) did not return BIT16SZ";
627 		return;
628 	}
629 	n = GBIT16(tmp)+BIT16SZ;
630 	statbuf = emalloc9p(n);
631 	if(statbuf == nil){
632 		r->error = "out of memory";
633 		return;
634 	}
635 	r->ofcall.nstat = convD2M(&r->d, statbuf, n);
636 	r->ofcall.stat = statbuf;	/* freed in closereq */
637 	if(r->ofcall.nstat <= BIT16SZ){
638 		r->error = "convD2M fails";
639 		free(statbuf);
640 		return;
641 	}
642 }
643 
644 static void
645 swstat(Srv *srv, Req *r)
646 {
647 	if((r->fid = lookupfid(srv->fpool, r->ifcall.fid)) == nil){
648 		respond(r, Eunknownfid);
649 		return;
650 	}
651 	if(srv->wstat == nil){
652 		respond(r, Enowstat);
653 		return;
654 	}
655 	if(convM2D(r->ifcall.stat, r->ifcall.nstat, &r->d, (char*)r->ifcall.stat) != r->ifcall.nstat){
656 		respond(r, Ebaddir);
657 		return;
658 	}
659 	if((ushort)~r->d.type){
660 		respond(r, "wstat -- attempt to change type");
661 		return;
662 	}
663 	if((uint)~r->d.dev){
664 		respond(r, "wstat -- attempt to change dev");
665 		return;
666 	}
667 	if((uchar)~r->d.qid.type || (ulong)~r->d.qid.vers || (uvlong)~r->d.qid.path){
668 		respond(r, "wstat -- attempt to change qid");
669 		return;
670 	}
671 	if(r->d.muid && r->d.muid[0]){
672 		respond(r, "wstat -- attempt to change muid");
673 		return;
674 	}
675 	if((ulong)~r->d.mode && ((r->d.mode&DMDIR)>>24) != (r->fid->qid.type&QTDIR)){
676 		respond(r, "wstat -- attempt to change DMDIR bit");
677 		return;
678 	}
679 	srv->wstat(r);
680 }
681 static void
682 rwstat(Req *r, char *msg)
683 {
684 	USED(r);
685 	USED(msg);
686 }
687 
688 void
689 srv(Srv *srv)
690 {
691 	Req *r;
692 
693 	fmtinstall('D', dirfmt);
694 	fmtinstall('F', fcallfmt);
695 
696 	if(srv->fpool == nil)
697 		srv->fpool = allocfidpool(srv->destroyfid);
698 	if(srv->rpool == nil)
699 		srv->rpool = allocreqpool(srv->destroyreq);
700 	if(srv->msize == 0)
701 		srv->msize = 8192+IOHDRSZ;
702 
703 	changemsize(srv, srv->msize);
704 
705 	srv->fpool->srv = srv;
706 	srv->rpool->srv = srv;
707 
708 	while(r = getreq(srv)){
709 		if(r->error){
710 			respond(r, r->error);
711 			continue;	
712 		}
713 		switch(r->ifcall.type){
714 		default:
715 			respond(r, "unknown message");
716 			break;
717 		case Tversion:	sversion(srv, r);	break;
718 		case Tauth:	sauth(srv, r);	break;
719 		case Tattach:	sattach(srv, r);	break;
720 		case Tflush:	sflush(srv, r);	break;
721 		case Twalk:	swalk(srv, r);	break;
722 		case Topen:	sopen(srv, r);	break;
723 		case Tcreate:	screate(srv, r);	break;
724 		case Tread:	sread(srv, r);	break;
725 		case Twrite:	swrite(srv, r);	break;
726 		case Tclunk:	sclunk(srv, r);	break;
727 		case Tremove:	sremove(srv, r);	break;
728 		case Tstat:	sstat(srv, r);	break;
729 		case Twstat:	swstat(srv, r);	break;
730 		}
731 	}
732 
733 	if(srv->end)
734 		srv->end(srv);
735 }
736 
737 void
738 respond(Req *r, char *error)
739 {
740 	int i, m, n;
741 	char errbuf[ERRMAX];
742 	Srv *srv;
743 
744 	srv = r->srv;
745 	assert(srv != nil);
746 
747 	assert(r->responded == 0);
748 	r->error = error;
749 
750 	switch(r->ifcall.type){
751 	default:
752 		assert(0);
753 	/*
754 	 * Flush is special.  If the handler says so, we return
755 	 * without further processing.  Respond will be called
756 	 * again once it is safe.
757 	 */
758 	case Tflush:
759 		if(rflush(r, error)<0)
760 			return;
761 		break;
762 	case Tversion:	rversion(r, error);	break;
763 	case Tauth:	rauth(r, error);	break;
764 	case Tattach:	rattach(r, error);	break;
765 	case Twalk:	rwalk(r, error);	break;
766 	case Topen:	ropen(r, error);	break;
767 	case Tcreate:	rcreate(r, error);	break;
768 	case Tread:	rread(r, error);	break;
769 	case Twrite:	rwrite(r, error);	break;
770 	case Tclunk:	rclunk(r, error);	break;
771 	case Tremove:	rremove(r, error, errbuf);	break;
772 	case Tstat:	rstat(r, error);	break;
773 	case Twstat:	rwstat(r, error);	break;
774 	}
775 
776 	r->ofcall.tag = r->ifcall.tag;
777 	r->ofcall.type = r->ifcall.type+1;
778 	if(r->error)
779 		setfcallerror(&r->ofcall, r->error);
780 
781 if(chatty9p)
782 	fprint(2, "-%d-> %F\n", srv->outfd, &r->ofcall);
783 
784 	qlock(&srv->wlock);
785 	n = convS2M(&r->ofcall, srv->wbuf, srv->msize);
786 	if(n <= 0){
787 		fprint(2, "n = %d %F\n", n, &r->ofcall);
788 		abort();
789 	}
790 	assert(n > 2);
791 	if(r->pool)	/* not a fake */
792 		closereq(removereq(r->pool, r->ifcall.tag));
793 	m = write(srv->outfd, srv->wbuf, n);
794 	if(m != n)
795 		sysfatal("lib9p srv: write %d returned %d on fd %d: %r", n, m, srv->outfd);
796 	qunlock(&srv->wlock);
797 
798 	qlock(&r->lk);	/* no one will add flushes now */
799 	r->responded = 1;
800 	qunlock(&r->lk);
801 
802 	for(i=0; i<r->nflush; i++)
803 		respond(r->flush[i], nil);
804 	free(r->flush);
805 
806 	if(r->pool)
807 		closereq(r);
808 	else
809 		free(r);
810 }
811 
812 int
813 postfd(char *name, int pfd)
814 {
815 	int fd;
816 	char buf[80];
817 
818 	snprint(buf, sizeof buf, "/srv/%s", name);
819 	if(chatty9p)
820 		fprint(2, "postfd %s\n", buf);
821 	fd = create(buf, OWRITE|ORCLOSE|OCEXEC, 0600);
822 	if(fd < 0){
823 		if(chatty9p)
824 			fprint(2, "create fails: %r\n");
825 		return -1;
826 	}
827 	if(fprint(fd, "%d", pfd) < 0){
828 		if(chatty9p)
829 			fprint(2, "write fails: %r\n");
830 		close(fd);
831 		return -1;
832 	}
833 	if(chatty9p)
834 		fprint(2, "postfd successful\n");
835 	return 0;
836 }
837