plan 9 kernel history: overview | file list | diff list

1996/0223/port/devenv.c (diff list | history)

port/devenv.c on 1990/0227
1990/0227    
#include	"u.h" 
1992/0321    
#include	"../port/lib.h" 
1990/0227    
#include	"mem.h" 
#include	"dat.h" 
#include	"fns.h" 
1992/0111    
#include	"../port/error.h" 
1990/0227    
 
 
1992/0623    
enum 
1990/0227    
{ 
1992/0623    
	Maxenvsize = 16300, 
1990/0227    
}; 
 
void 
envreset(void) 
{ 
} 
 
void 
envinit(void) 
{ 
} 
 
int 
1995/0804    
envgen(Chan *c, Dirtab*, int, int s, Dir *dp) 
1990/0227    
{ 
1991/0705    
	Egrp *eg; 
1992/0623    
	Evalue *e; 
1990/0227    
 
1993/0501    
	eg = up->egrp; 
1992/0623    
	qlock(eg); 
 
	for(e = eg->entries; e && s; e = e->link) 
		s--; 
 
	if(e == 0) { 
		qunlock(eg); 
		return -1; 
1990/0227    
	} 
1992/0623    
 
	devdir(c, (Qid){e->path, 0}, e->name, e->len, eve, 0666, dp); 
	qunlock(eg); 
	return 1; 
1990/0227    
} 
 
Chan* 
envattach(char *spec) 
{ 
	return devattach('e', spec); 
} 
 
Chan* 
envclone(Chan *c, Chan *nc) 
{ 
	return devclone(c, nc); 
} 
 
int 
envwalk(Chan *c, char *name) 
{ 
1991/1018    
	return devwalk(c, name, 0, 0, envgen); 
1990/0227    
} 
 
void 
envstat(Chan *c, char *db) 
{ 
	devstat(c, db, 0, 0, envgen); 
} 
 
Chan * 
envopen(Chan *c, int omode) 
{ 
1991/0705    
	Egrp *eg; 
1992/0623    
	Evalue *e; 
	 
1993/0501    
	eg = up->egrp; 
1992/0625    
	if(c->qid.path & CHDIR) { 
1991/1018    
		if(omode != OREAD) 
1990/11211    
			error(Eperm); 
1992/0623    
	} 
	else { 
		qlock(eg); 
		for(e = eg->entries; e; e = e->link) 
			if(e->path == c->qid.path) 
				break; 
 
		if(e == 0) { 
			qunlock(eg); 
1991/1018    
			error(Enonexist); 
1990/0227    
		} 
1992/0623    
		if(omode == (OWRITE|OTRUNC) && e->value) { 
			free(e->value); 
			e->value = 0; 
			e->len = 0; 
1990/0227    
		} 
1992/0623    
		qunlock(eg); 
1990/0227    
	} 
1992/0623    
	c->mode = openmode(omode); 
1990/0227    
	c->flag |= COPEN; 
	c->offset = 0; 
	return c; 
} 
 
void 
1995/0726    
envcreate(Chan *c, char *name, int omode, ulong) 
1990/0227    
{ 
1991/0705    
	Egrp *eg; 
1992/0623    
	Evalue *e; 
1990/0227    
 
1990/11211    
	if(c->qid.path != CHDIR) 
		error(Eperm); 
1992/0623    
 
1991/1018    
	omode = openmode(omode); 
1993/0501    
	eg = up->egrp; 
1992/0623    
 
	qlock(eg); 
	if(waserror()) { 
		qunlock(eg); 
		nexterror(); 
1990/0227    
	} 
1992/0623    
 
	for(e = eg->entries; e; e = e->link) 
		if(strcmp(e->name, name) == 0) 
			error(Einuse); 
 
	e = smalloc(sizeof(Evalue)); 
	e->name = smalloc(strlen(name)+1); 
	strcpy(e->name, name); 
 
	e->path = ++eg->path; 
	e->link = eg->entries; 
	eg->entries = e; 
	c->qid = (Qid){e->path, 0}; 
	 
	qunlock(eg); 
	poperror(); 
 
1990/0227    
	c->offset = 0; 
1991/1018    
	c->mode = omode; 
1990/0227    
	c->flag |= COPEN; 
} 
 
void 
envremove(Chan *c) 
{ 
1991/0705    
	Egrp *eg; 
1992/0623    
	Evalue *e, **l; 
1990/0227    
 
1990/11211    
	if(c->qid.path & CHDIR) 
		error(Eperm); 
1992/0623    
 
1993/0501    
	eg = up->egrp; 
1992/0623    
	qlock(eg); 
 
	l = &eg->entries; 
	for(e = *l; e; e = e->link) { 
		if(e->path == c->qid.path) 
			break; 
		l = &e->link; 
	} 
 
	if(e == 0) { 
		qunlock(eg); 
1990/11211    
		error(Enonexist); 
1990/0227    
	} 
1992/0623    
 
	*l = e->link; 
	qunlock(eg); 
	free(e->name); 
	if(e->value) 
		free(e->value); 
	free(e); 
1990/0227    
} 
 
void 
1995/0804    
envwstat(Chan*, char*) 
1991/1018    
{ 
	error(Eperm); 
1990/0227    
} 
 
void 
1995/0804    
envclose(Chan*) 
1990/0227    
{ 
1991/1018    
} 
1990/0227    
 
long 
1991/1018    
envread(Chan *c, void *a, long n, ulong offset) 
1990/0227    
{ 
1991/1018    
	Egrp *eg; 
1992/0623    
	Evalue *e; 
1990/0227    
 
1990/11211    
	if(c->qid.path & CHDIR) 
1990/0227    
		return devdirread(c, a, n, 0, 0, envgen); 
1992/0623    
 
1993/0501    
	eg = up->egrp; 
1992/0623    
	qlock(eg); 
	for(e = eg->entries; e; e = e->link) 
		if(e->path == c->qid.path) 
			break; 
 
	if(e == 0) { 
		qunlock(eg); 
1991/1018    
		error(Enonexist); 
1990/0227    
	} 
1992/0623    
 
	if(offset + n > e->len) 
		n = e->len - offset; 
1990/0227    
	if(n <= 0) 
		n = 0; 
	else 
1992/0623    
		memmove(a, e->value+offset, n); 
	qunlock(eg); 
1990/0227    
	return n; 
} 
 
1995/0108    
Block* 
envbread(Chan *c, long n, ulong offset) 
{ 
	return devbread(c, n, offset); 
} 
 
1990/0227    
long 
1991/1018    
envwrite(Chan *c, void *a, long n, ulong offset) 
1990/0227    
{ 
1992/0623    
	char *s; 
	int vend; 
1991/1018    
	Egrp *eg; 
1992/0623    
	Evalue *e; 
1990/0227    
 
	if(n <= 0) 
		return 0; 
1992/0623    
 
	vend = offset+n; 
	if(vend > Maxenvsize) 
1991/1018    
		error(Etoobig); 
1992/0623    
 
1993/0501    
	eg = up->egrp; 
1992/0623    
	qlock(eg); 
	for(e = eg->entries; e; e = e->link) 
		if(e->path == c->qid.path) 
			break; 
 
	if(e == 0) { 
		qunlock(eg); 
1991/1018    
		error(Enonexist); 
1990/0227    
	} 
 
1992/0623    
	if(vend > e->len) { 
		s = smalloc(offset+n); 
		memmove(s, e->value, e->len); 
		if(e->value) 
			free(e->value); 
		e->value = s; 
		e->len = vend; 
1991/1018    
	} 
1992/0623    
	memmove(e->value+offset, a, n); 
	qunlock(eg); 
	return n; 
1995/0108    
} 
 
long 
envbwrite(Chan *c, Block *bp, ulong offset) 
{ 
	return devbwrite(c, bp, offset); 
1992/0625    
} 
 
void 
envcpy(Egrp *to, Egrp *from) 
{ 
	Evalue **l, *ne, *e; 
 
	l = &to->entries; 
	qlock(from); 
	for(e = from->entries; e; e = e->link) { 
		ne = smalloc(sizeof(Evalue)); 
		ne->name = smalloc(strlen(e->name)+1); 
		strcpy(ne->name, e->name); 
		if(e->value) { 
			ne->value = smalloc(e->len); 
			memmove(ne->value, e->value, e->len); 
			ne->len = e->len; 
		} 
		ne->path = ++to->path; 
		*l = ne; 
		l = &ne->link; 
	} 
	qunlock(from); 
} 
 
void 
closeegrp(Egrp *eg) 
{ 
	Evalue *e, *next; 
 
	if(decref(eg) == 0) { 
		for(e = eg->entries; e; e = next) { 
			next = e->link; 
			free(e->name); 
			if(e->value) 
				free(e->value); 
			free(e); 
		} 
		free(eg); 
	} 
1991/1022    
} 
 
1991/0927    
/* 
 *  to let the kernel set environment variables 
 */ 
void 
ksetenv(char *ename, char *eval) 
{ 
	Chan *c; 
	char buf[2*NAMELEN]; 
 
	sprint(buf, "#e/%s", ename); 
	c = namec(buf, Acreate, OWRITE, 0600); 
	(*devtab[c->type].write)(c, eval, strlen(eval), 0); 
	close(c); 
1991/1102    
} 


source code copyright © 1990-2005 Lucent Technologies; see license
Plan 9 distribution
comments to russ cox (rsc@swtch.com)