WebSVN – planix.SVN – Blame – /os/branches/planix-v0/sys/src/cmd/vac/vacfs.c

Rev	Author	Line No.	Line
2	-	1	`#include "stdinc.h"`
		2	`#include <fcall.h>`
		3	`#include "vac.h"`
		4
		5	`#define convM2Su(a, b, c, d) convM2S(a, b, c)`
		6	`#define convS2Mu(a, b, c, d) convS2M(a, b, c)`
		7	`#define convM2Du(a, b, c, d) convM2D(a, b, c)`
		8	`#define convD2Mu(a, b, c, d) convD2M(a, b, c)`
		9
		10	`typedef struct Fid Fid;`
		11
		12	`enum`
		13	`{`
		14	`Stacksize = 320 * 1024, /* was 32K */`
		15	`OPERM = 0x3 /* mask of all permission types in open mode */`
		16	`};`
		17
		18	`struct Fid`
		19	`{`
		20	`short busy;`
		21	`short open;`
		22	`int fid;`
		23	`char *user;`
		24	`Qid qid;`
		25	`VacFile *file;`
		26	`VacDirEnum *vde;`
		27	`Fid *next;`
		28	`};`
		29
		30	`enum`
		31	`{`
		32	`Pexec = 1,`
		33	`Pwrite = 2,`
		34	`Pread = 4,`
		35	`Pother = 1,`
		36	`Pgroup = 8,`
		37	`Powner = 64`
		38	`};`
		39
		40	`Fid *fids;`
		41	`uchar *data;`
		42	`int mfd[2];`
		43	`int srvfd = -1;`
		44	`char *user;`
		45	`uchar mdata[8192+IOHDRSZ];`
		46	`int messagesize = sizeof mdata;`
		47	`Fcall rhdr;`
		48	`Fcall thdr;`
		49	`VacFs *fs;`
		50	`VtConn *conn;`
		51	`int noperm;`
		52	`int dotu;`
		53	`char *defmnt;`
		54
		55	`Fid * newfid(int);`
		56	`void error(char*);`
		57	`void io(void);`
		58	`void vacshutdown(void);`
		59	`void usage(void);`
		60	`int perm(Fid*, int);`
		61	`int permf(VacFile, char, int);`
		62	`ulong getl(void *p);`
		63	`void init(char, char, long, int);`
		64	`int vacdirread(Fid f, char p, long off, long cnt);`
		65	`int vacstat(VacFile parent, VacDir vd, uchar *p, int np);`
		66	`void srv(void* a);`
		67
		68
		69	`char rflush(Fid), rversion(Fid),`
		70	`rauth(Fid), rattach(Fid), rwalk(Fid),`
		71	`ropen(Fid), rcreate(Fid),`
		72	`rread(Fid), rwrite(Fid), rclunk(Fid),`
		73	`rremove(Fid), rstat(Fid), rwstat(Fid);`
		74
		75	`char (fcalls[Tmax])(Fid*);`
		76
		77	`void`
		78	`initfcalls(void)`
		79	`{`
		80	`fcalls[Tflush]= rflush;`
		81	`fcalls[Tversion]= rversion;`
		82	`fcalls[Tattach]= rattach;`
		83	`fcalls[Tauth]= rauth;`
		84	`fcalls[Twalk]= rwalk;`
		85	`fcalls[Topen]= ropen;`
		86	`fcalls[Tcreate]= rcreate;`
		87	`fcalls[Tread]= rread;`
		88	`fcalls[Twrite]= rwrite;`
		89	`fcalls[Tclunk]= rclunk;`
		90	`fcalls[Tremove]= rremove;`
		91	`fcalls[Tstat]= rstat;`
		92	`fcalls[Twstat]= rwstat;`
		93	`}`
		94
		95	`char Eperm[] = "permission denied";`
		96	`char Enotdir[] = "not a directory";`
		97	`char Enotexist[] = "file does not exist";`
		98	`char Einuse[] = "file in use";`
		99	`char Eexist[] = "file exists";`
		100	`char Enotowner[] = "not owner";`
		101	`char Eisopen[] = "file already open for I/O";`
		102	`char Excl[] = "exclusive use file already open";`
		103	`char Ename[] = "illegal name";`
		104	`char Erdonly[] = "read only file system";`
		105	`char Eio[] = "i/o error";`
		106	`char Eempty[] = "directory is not empty";`
		107	`char Emode[] = "illegal mode";`
		108
		109	`int dflag;`
		110
		111	`void`
		112	`notifyf(void a, char s)`
		113	`{`
		114	`USED(a);`
		115	`if(strncmp(s, "interrupt", 9) == 0)`
		116	`noted(NCONT);`
		117	`noted(NDFLT);`
		118	`}`
		119
		120	`void`
		121	`threadmain(int argc, char *argv[])`
		122	`{`
		123	`char defsrv, srvname;`
		124	`int p[2], fd;`
		125	`int stdio;`
		126	`char *host = nil;`
		127	`long ncache;`
		128
		129	`stdio = 0;`
		130	`ncache = 256;`
		131	`fmtinstall('H', encodefmt);`
		132	`fmtinstall('V', vtscorefmt);`
		133	`fmtinstall('F', vtfcallfmt);`
		134
		135	`defmnt = nil;`
		136	`defsrv = nil;`
		137	`ARGBEGIN{`
		138	`case 'd':`
		139	`fmtinstall('F', fcallfmt);`
		140	`dflag = 1;`
		141	`break;`
		142	`case 'c':`
		143	`ncache = atoi(EARGF(usage()));`
		144	`break;`
		145	`case 'i':`
		146	`defmnt = nil;`
		147	`stdio = 1;`
		148	`mfd[0] = 0;`
		149	`mfd[1] = 1;`
		150	`break;`
		151	`case 'h':`
		152	`host = EARGF(usage());`
		153	`break;`
		154	`case 'S':`
		155	`defsrv = EARGF(usage());`
		156	`break;`
		157	`case 's':`
		158	`defsrv = "vacfs";`
		159	`break;`
		160	`case 'm':`
		161	`defmnt = EARGF(usage());`
		162	`break;`
		163	`case 'p':`
		164	`noperm = 1;`
		165	`break;`
		166	`case 'V':`
		167	`chattyventi = 1;`
		168	`break;`
		169	`default:`
		170	`usage();`
		171	`}ARGEND`
		172
		173	`if(argc != 1)`
		174	`usage();`
		175
		176	`if(defsrv == nil && defmnt == nil && !stdio)`
		177	`defmnt = "/n/vac";`
		178	`if(stdio && defmnt)`
		179	`sysfatal("cannot use -m with -i");`
		180
		181	`initfcalls();`
		182
		183	`notify(notifyf);`
		184	`user = getuser();`
		185
		186	`conn = vtdial(host);`
		187	`if(conn == nil)`
		188	`sysfatal("could not connect to server: %r");`
		189
		190	`if(vtconnect(conn) < 0)`
		191	`sysfatal("vtconnect: %r");`
		192
		193	`fs = vacfsopen(conn, argv[0], VtOREAD, ncache);`
		194	`if(fs == nil)`
		195	`sysfatal("vacfsopen: %r");`
		196
		197	`if(!stdio){`
		198	`if(pipe(p) < 0)`
		199	`sysfatal("pipe failed: %r");`
		200	`mfd[0] = p[0];`
		201	`mfd[1] = p[0];`
		202	`srvfd = p[1];`
		203	`if(defsrv){`
		204	`srvname = smprint("/srv/%s", defsrv);`
		205	`fd = create(srvname, OWRITE\|ORCLOSE, 0666);`
		206	`if(fd < 0)`
		207	`sysfatal("create %s: %r", srvname);`
		208	`if(fprint(fd, "%d", srvfd) < 0)`
		209	`sysfatal("write %s: %r", srvname);`
		210	`free(srvname);`
		211	`}`
		212	`}`
		213
		214	`procrfork(srv, 0, Stacksize, RFFDG\|RFNAMEG\|RFNOTEG);`
		215
		216	`if(!stdio){`
		217	`close(p[0]);`
		218	`if(defmnt){`
		219	`if(mount(srvfd, -1, defmnt, MREPL\|MCREATE, "") < 0)`
		220	`sysfatal("mount %s: %r", defmnt);`
		221	`}`
		222	`}`
		223	`threadexits(0);`
		224	`}`
		225
		226	`void`
		227	`srv(void *a)`
		228	`{`
		229	`USED(a);`
		230	`io();`
		231	`vacshutdown();`
		232	`}`
		233
		234	`void`
		235	`usage(void)`
		236	`{`
		237	`fprint(2, "usage: %s [-sd] [-h host] [-c ncache] [-m mountpoint] vacfile\n", argv0);`
		238	`threadexitsall("usage");`
		239	`}`
		240
		241	`char*`
		242	`rversion(Fid *unused)`
		243	`{`
		244	`Fid *f;`
		245
		246	`USED(unused);`
		247
		248	`for(f = fids; f; f = f->next)`
		249	`if(f->busy)`
		250	`rclunk(f);`
		251
		252	`if(rhdr.msize < 256)`
		253	`return vtstrdup("version: message size too small");`
		254	`messagesize = rhdr.msize;`
		255	`if(messagesize > sizeof mdata)`
		256	`messagesize = sizeof mdata;`
		257	`thdr.msize = messagesize;`
		258	`if(strncmp(rhdr.version, "9P2000", 6) != 0)`
		259	`return vtstrdup("unrecognized 9P version");`
		260	`thdr.version = "9P2000";`
		261	`if(strncmp(rhdr.version, "9P2000.u", 8) == 0){`
		262	`dotu = 1;`
		263	`thdr.version = "9P2000.u";`
		264	`}`
		265	`return nil;`
		266	`}`
		267
		268	`char*`
		269	`rflush(Fid *f)`
		270	`{`
		271	`USED(f);`
		272	`return 0;`
		273	`}`
		274
		275	`char*`
		276	`rauth(Fid *f)`
		277	`{`
		278	`USED(f);`
		279	`return vtstrdup("vacfs: authentication not required");`
		280	`}`
		281
		282	`char*`
		283	`rattach(Fid *f)`
		284	`{`
		285	`/* no authentication for the momment */`
		286	`VacFile *file;`
		287	`char err[80];`
		288
		289	`file = vacfsgetroot(fs);`
		290	`if(file == nil) {`
		291	`rerrstr(err, sizeof err);`
		292	`return vtstrdup(err);`
		293	`}`
		294
		295	`f->busy = 1;`
		296	`f->file = file;`
		297	`f->qid.path = vacfilegetid(f->file);`
		298	`f->qid.vers = 0;`
		299	`f->qid.type = QTDIR;`
		300	`thdr.qid = f->qid;`
		301	`if(rhdr.uname[0])`
		302	`f->user = vtstrdup(rhdr.uname);`
		303	`else`
		304	`f->user = "none";`
		305	`return 0;`
		306	`}`
		307
		308	`char*`
		309	`rwalk(Fid *f)`
		310	`{`
		311	`VacFile file, nfile;`
		312	`Fid *nf;`
		313	`int nqid, nwname;`
		314	`Qid qid;`
		315	`char *err = nil;`
		316
		317	`if(f->busy == 0)`
		318	`return Enotexist;`
		319	`nf = nil;`
		320	`if(rhdr.fid != rhdr.newfid){`
		321	`if(f->open)`
		322	`return vtstrdup(Eisopen);`
		323	`if(f->busy == 0)`
		324	`return vtstrdup(Enotexist);`
		325	`nf = newfid(rhdr.newfid);`
		326	`if(nf->busy)`
		327	`return vtstrdup(Eisopen);`
		328	`nf->busy = 1;`
		329	`nf->open = 0;`
		330	`nf->qid = f->qid;`
		331	`nf->file = vacfileincref(f->file);`
		332	`nf->user = vtstrdup(f->user);`
		333	`f = nf;`
		334	`}`
		335
		336	`nwname = rhdr.nwname;`
		337
		338	`/* easy case */`
		339	`if(nwname == 0) {`
		340	`thdr.nwqid = 0;`
		341	`return 0;`
		342	`}`
		343
		344	`file = f->file;`
		345	`vacfileincref(file);`
		346	`qid = f->qid;`
		347
		348	`for(nqid = 0; nqid < nwname; nqid++){`
		349	`if((qid.type & QTDIR) == 0){`
		350	`err = Enotdir;`
		351	`break;`
		352	`}`
		353	`if(!permf(file, f->user, Pexec)) {`
		354	`err = Eperm;`
		355	`break;`
		356	`}`
		357	`nfile = vacfilewalk(file, rhdr.wname[nqid]);`
		358	`if(nfile == nil)`
		359	`break;`
		360	`vacfiledecref(file);`
		361	`file = nfile;`
		362	`qid.type = QTFILE;`
		363	`if(vacfileisdir(file))`
		364	`qid.type = QTDIR;`
		365	`qid.vers = vacfilegetmcount(file);`
		366	`qid.path = vacfilegetid(file);`
		367	`thdr.wqid[nqid] = qid;`
		368	`}`
		369
		370	`thdr.nwqid = nqid;`
		371
		372	`if(nqid == nwname){`
		373	`/* success */`
		374	`f->qid = thdr.wqid[nqid-1];`
		375	`vacfiledecref(f->file);`
		376	`f->file = file;`
		377	`return 0;`
		378	`}`
		379
		380	`vacfiledecref(file);`
		381	`if(nf != nil)`
		382	`rclunk(nf);`
		383
		384	`/* only error on the first element */`
		385	`if(nqid == 0)`
		386	`return vtstrdup(err);`
		387
		388	`return 0;`
		389	`}`
		390
		391	`char *`
		392	`ropen(Fid *f)`
		393	`{`
		394	`int mode, trunc;`
		395
		396	`if(f->open)`
		397	`return vtstrdup(Eisopen);`
		398	`if(!f->busy)`
		399	`return vtstrdup(Enotexist);`
		400
		401	`mode = rhdr.mode;`
		402	`thdr.iounit = messagesize - IOHDRSZ;`
		403	`if(f->qid.type & QTDIR){`
		404	`if(mode != OREAD)`
		405	`return vtstrdup(Eperm);`
		406	`if(!perm(f, Pread))`
		407	`return vtstrdup(Eperm);`
		408	`thdr.qid = f->qid;`
		409	`f->vde = nil;`
		410	`f->open = 1;`
		411	`return 0;`
		412	`}`
		413	`if(mode & ORCLOSE)`
		414	`return vtstrdup(Erdonly);`
		415	`trunc = mode & OTRUNC;`
		416	`mode &= OPERM;`
		417	`if(mode==OWRITE \|\| mode==ORDWR \|\| trunc)`
		418	`if(!perm(f, Pwrite))`
		419	`return vtstrdup(Eperm);`
		420	`if(mode==OREAD \|\| mode==ORDWR)`
		421	`if(!perm(f, Pread))`
		422	`return vtstrdup(Eperm);`
		423	`if(mode==OEXEC)`
		424	`if(!perm(f, Pexec))`
		425	`return vtstrdup(Eperm);`
		426	`thdr.qid = f->qid;`
		427	`thdr.iounit = messagesize - IOHDRSZ;`
		428	`f->open = 1;`
		429	`return 0;`
		430	`}`
		431
		432	`char*`
		433	`rcreate(Fid* fid)`
		434	`{`
		435	`VacFile *vf;`
		436	`ulong mode;`
		437
		438	`if(fid->open)`
		439	`return vtstrdup(Eisopen);`
		440	`if(!fid->busy)`
		441	`return vtstrdup(Enotexist);`
		442	`if(fs->mode & ModeSnapshot)`
		443	`return vtstrdup(Erdonly);`
		444	`vf = fid->file;`
		445	`if(!vacfileisdir(vf))`
		446	`return vtstrdup(Enotdir);`
		447	`if(!permf(vf, fid->user, Pwrite))`
		448	`return vtstrdup(Eperm);`
		449
		450	`mode = rhdr.perm & 0777;`
		451
		452	`if(rhdr.perm & DMDIR){`
		453	`if((rhdr.mode & OTRUNC) \|\| (rhdr.perm & DMAPPEND))`
		454	`return vtstrdup(Emode);`
		455	`switch(rhdr.mode & OPERM){`
		456	`default:`
		457	`return vtstrdup(Emode);`
		458	`case OEXEC:`
		459	`case OREAD:`
		460	`break;`
		461	`case OWRITE:`
		462	`case ORDWR:`
		463	`return vtstrdup(Eperm);`
		464	`}`
		465	`mode \|= ModeDir;`
		466	`}`
		467	`vf = vacfilecreate(vf, rhdr.name, mode);`
		468	`if(vf == nil) {`
		469	`char err[80];`
		470	`rerrstr(err, sizeof err);`
		471
		472	`return vtstrdup(err);`
		473	`}`
		474
		475	`vacfiledecref(fid->file);`
		476
		477	`fid->file = vf;`
		478	`fid->qid.type = QTFILE;`
		479	`if(vacfileisdir(vf))`
		480	`fid->qid.type = QTDIR;`
		481	`fid->qid.vers = vacfilegetmcount(vf);`
		482	`fid->qid.path = vacfilegetid(vf);`
		483
		484	`thdr.qid = fid->qid;`
		485	`thdr.iounit = messagesize - IOHDRSZ;`
		486
		487	`return 0;`
		488	`}`
		489
		490	`char*`
		491	`rread(Fid *f)`
		492	`{`
		493	`char *buf;`
		494	`vlong off;`
		495	`int cnt;`
		496	`VacFile *vf;`
		497	`char err[80];`
		498	`int n;`
		499
		500	`if(!f->busy)`
		501	`return vtstrdup(Enotexist);`
		502	`vf = f->file;`
		503	`thdr.count = 0;`
		504	`off = rhdr.offset;`
		505	`buf = thdr.data;`
		506	`cnt = rhdr.count;`
		507	`if(f->qid.type & QTDIR)`
		508	`n = vacdirread(f, buf, off, cnt);`
		509	`else if(vacfilegetmode(f->file)&ModeDevice)`
		510	`return vtstrdup("device");`
		511	`else if(vacfilegetmode(f->file)&ModeLink)`
		512	`return vtstrdup("symbolic link");`
		513	`else if(vacfilegetmode(f->file)&ModeNamedPipe)`
		514	`return vtstrdup("named pipe");`
		515	`else`
		516	`n = vacfileread(vf, buf, cnt, off);`
		517	`if(n < 0) {`
		518	`rerrstr(err, sizeof err);`
		519	`return vtstrdup(err);`
		520	`}`
		521	`thdr.count = n;`
		522	`return 0;`
		523	`}`
		524
		525	`char*`
		526	`rwrite(Fid *f)`
		527	`{`
		528	`USED(f);`
		529	`return vtstrdup(Erdonly);`
		530	`}`
		531
		532	`char *`
		533	`rclunk(Fid *f)`
		534	`{`
		535	`f->busy = 0;`
		536	`f->open = 0;`
		537	`vtfree(f->user);`
		538	`f->user = nil;`
		539	`if(f->file)`
		540	`vacfiledecref(f->file);`
		541	`f->file = nil;`
		542	`vdeclose(f->vde);`
		543	`f->vde = nil;`
		544	`return 0;`
		545	`}`
		546
		547	`char *`
		548	`rremove(Fid *f)`
		549	`{`
		550	`VacFile vf, vfp;`
		551	`char errbuf[80];`
		552	`char *err = nil;`
		553
		554	`if(!f->busy)`
		555	`return vtstrdup(Enotexist);`
		556	`vf = f->file;`
		557	`vfp = vacfilegetparent(vf);`
		558
		559	`if(!permf(vfp, f->user, Pwrite)) {`
		560	`err = Eperm;`
		561	`goto Exit;`
		562	`}`
		563
		564	`if(!vacfileremove(vf)) {`
		565	`rerrstr(errbuf, sizeof errbuf);`
		566	`err = errbuf;`
		567	`}`
		568
		569	`Exit:`
		570	`vacfiledecref(vfp);`
		571	`rclunk(f);`
		572	`return vtstrdup(err);`
		573	`}`
		574
		575	`char *`
		576	`rstat(Fid *f)`
		577	`{`
		578	`VacDir dir;`
		579	`static uchar statbuf[1024];`
		580	`VacFile *parent;`
		581
		582	`if(!f->busy)`
		583	`return vtstrdup(Enotexist);`
		584	`parent = vacfilegetparent(f->file);`
		585	`vacfilegetdir(f->file, &dir);`
		586	`thdr.stat = statbuf;`
		587	`thdr.nstat = vacstat(parent, &dir, thdr.stat, sizeof statbuf);`
		588	`vdcleanup(&dir);`
		589	`vacfiledecref(parent);`
		590	`return 0;`
		591	`}`
		592
		593	`char *`
		594	`rwstat(Fid *f)`
		595	`{`
		596	`if(!f->busy)`
		597	`return vtstrdup(Enotexist);`
		598	`return vtstrdup(Erdonly);`
		599	`}`
		600
		601	`int`
		602	`vacstat(VacFile parent, VacDir vd, uchar *p, int np)`
		603	`{`
		604	`int ret;`
		605	`Dir dir;`
		606
		607	`memset(&dir, 0, sizeof(dir));`
		608
		609	`dir.qid.path = vd->qid + vacfilegetqidoffset(parent);`
		610	`if(vd->qidspace)`
		611	`dir.qid.path += vd->qidoffset;`
		612	`dir.qid.vers = vd->mcount;`
		613	`dir.mode = vd->mode & 0777;`
		614	`if(vd->mode & ModeAppend){`
		615	`dir.qid.type \|= QTAPPEND;`
		616	`dir.mode \|= DMAPPEND;`
		617	`}`
		618	`if(vd->mode & ModeExclusive){`
		619	`dir.qid.type \|= QTEXCL;`
		620	`dir.mode \|= DMEXCL;`
		621	`}`
		622	`if(vd->mode & ModeDir){`
		623	`dir.qid.type \|= QTDIR;`
		624	`dir.mode \|= DMDIR;`
		625	`}`
		626
		627
		628	`dir.atime = vd->atime;`
		629	`dir.mtime = vd->mtime;`
		630	`dir.length = vd->size;`
		631
		632	`dir.name = vd->elem;`
		633	`dir.uid = vd->uid;`
		634	`dir.gid = vd->gid;`
		635	`dir.muid = vd->mid;`
		636
		637	`ret = convD2Mu(&dir, p, np, dotu);`
		638	`return ret;`
		639	`}`
		640
		641	`int`
		642	`vacdirread(Fid f, char p, long off, long cnt)`
		643	`{`
		644	`int i, n, nb;`
		645	`VacDir vd;`
		646
		647	`/*`
		648	`* special case of rewinding a directory`
		649	`* otherwise ignore the offset`
		650	`*/`
		651	`if(off == 0 && f->vde){`
		652	`vdeclose(f->vde);`
		653	`f->vde = nil;`
		654	`}`
		655
		656	`if(f->vde == nil){`
		657	`f->vde = vdeopen(f->file);`
		658	`if(f->vde == nil)`
		659	`return -1;`
		660	`}`
		661
		662	`for(nb = 0; nb < cnt; nb += n) {`
		663	`i = vderead(f->vde, &vd);`
		664	`if(i < 0)`
		665	`return -1;`
		666	`if(i == 0)`
		667	`break;`
		668	`n = vacstat(f->file, &vd, (uchar*)p, cnt-nb);`
		669	`if(n <= BIT16SZ) {`
		670	`vdeunread(f->vde);`
		671	`break;`
		672	`}`
		673	`vdcleanup(&vd);`
		674	`p += n;`
		675	`}`
		676	`return nb;`
		677	`}`
		678
		679	`Fid *`
		680	`newfid(int fid)`
		681	`{`
		682	`Fid f, ff;`
		683
		684	`ff = 0;`
		685	`for(f = fids; f; f = f->next)`
		686	`if(f->fid == fid)`
		687	`return f;`
		688	`else if(!ff && !f->busy)`
		689	`ff = f;`
		690	`if(ff){`
		691	`ff->fid = fid;`
		692	`return ff;`
		693	`}`
		694	`f = vtmallocz(sizeof *f);`
		695	`f->fid = fid;`
		696	`f->next = fids;`
		697	`fids = f;`
		698	`return f;`
		699	`}`
		700
		701	`void`
		702	`io(void)`
		703	`{`
		704	`char *err;`
		705	`int n;`
		706
		707	`for(;;){`
		708	`n = read9pmsg(mfd[0], mdata, sizeof mdata);`
		709	`if(n <= 0)`
		710	`break;`
		711	`if(convM2Su(mdata, n, &rhdr, dotu) != n)`
		712	`sysfatal("convM2S conversion error");`
		713
		714	`if(dflag)`
		715	`fprint(2, "vacfs:<-%F\n", &rhdr);`
		716
		717	`thdr.data = (char*)mdata + IOHDRSZ;`
		718	`if(!fcalls[rhdr.type])`
		719	`err = "bad fcall type";`
		720	`else`
		721	`err = (*fcalls[rhdr.type])(newfid(rhdr.fid));`
		722	`if(err){`
		723	`thdr.type = Rerror;`
		724	`thdr.ename = err;`
		725	`}else{`
		726	`thdr.type = rhdr.type + 1;`
		727	`thdr.fid = rhdr.fid;`
		728	`}`
		729	`thdr.tag = rhdr.tag;`
		730	`if(dflag)`
		731	`fprint(2, "vacfs:->%F\n", &thdr);`
		732	`n = convS2Mu(&thdr, mdata, messagesize, dotu);`
		733	`if(n <= BIT16SZ)`
		734	`sysfatal("convS2Mu conversion error");`
		735	`if(err)`
		736	`vtfree(err);`
		737
		738	`if(write(mfd[1], mdata, n) != n)`
		739	`sysfatal("mount write: %r");`
		740	`}`
		741	`}`
		742
		743	`int`
		744	`permf(VacFile vf, char user, int p)`
		745	`{`
		746	`VacDir dir;`
		747	`ulong perm;`
		748
		749	`if(vacfilegetdir(vf, &dir))`
		750	`return 0;`
		751	`perm = dir.mode & 0777;`
		752
		753	`if(noperm)`
		754	`goto Good;`
		755	`if((p*Pother) & perm)`
		756	`goto Good;`
		757	`if(strcmp(user, dir.gid)==0 && ((p*Pgroup) & perm))`
		758	`goto Good;`
		759	`if(strcmp(user, dir.uid)==0 && ((p*Powner) & perm))`
		760	`goto Good;`
		761	`vdcleanup(&dir);`
		762	`return 0;`
		763	`Good:`
		764	`vdcleanup(&dir);`
		765	`return 1;`
		766	`}`
		767
		768	`int`
		769	`perm(Fid *f, int p)`
		770	`{`
		771	`return permf(f->file, f->user, p);`
		772	`}`
		773
		774	`void`
		775	`vacshutdown(void)`
		776	`{`
		777	`Fid *f;`
		778
		779	`for(f = fids; f; f = f->next) {`
		780	`if(!f->busy)`
		781	`continue;`
		782	`rclunk(f);`
		783	`}`
		784
		785	`vacfsclose(fs);`
		786	`vthangup(conn);`
		787	`}`
		788

Subversion Repositories planix.SVN

(root)/os/branches/planix-v0/sys/src/cmd/vac/vacfs.c – Rev 9