[unix-history] / usr / src / cmd / net / mach.c

/*
   This file is meant to handle all the machine
   dependencies in the network code.
   Everything is conditionally compiled.

   It can be uses w/o network stuff to simulate
   v7 for other programs, too.
*/
# include <stdio.h>
# include "mach.h"

char shomedir[100];

# ifndef CC
submit(a) {}
# endif

# ifdef FUID
setgid() {};
# endif

/* 
   Set the owner uid/gid of a file.
   On v7, this is done by the chown command
   with three args - (file, uid, gid).
   On Vanilla V6 this is done using the
   top byte of the second parameter as the gid byte.
   On Berkeley Funny uids on V6, no gid is specified.
*/
mchown(sfn,uid,gid)
	char *sfn;
	int uid;
	int gid;
{
# ifndef V6
	chown(sfn,uid,gid);
# else
# ifndef FUID
		uid = uidmask(uid);
		uid = ((gid&0377) << 8) | (uid & 0377);
# endif
	chown(sfn,uid);
# endif
}
	

char vaxtovax;
long fixuplong(a)
	long a; {
# ifdef ISVAX
	register char *p,c1,c2;
	char c3,c4;
	if(!vaxtovax){
		p = (char*) &a;
		c1 = *p++;
		c2 = *p++;
		c3 = *p++;
		c4 = *p++;
		p = (char*) &a;
		*p++ = c3;
		*p++ = c4;
		*p++ = c1;
		*p++ = c2;
		}
# endif
	return(a);
	}
/*
	SnFromuid(uid)

	The login name corresponding to uid.
	Reads the password file.
	Successive calls overwrite the static string returned.
	Returns NULL if error.
*/
char *SnFromUid(uid)
	register int uid;
{
	register struct passwd *pwd;
	static int ouid = -1;
	static char oresult[20] = "";
	uid = uidmask(uid);
	if(uid == ouid)
		return(oresult);
# ifdef HPASSWD
	if(getname(uid,oresult) == 0){
		ouid = uid;
		return(oresult);
	}
# endif
	pwd = getpwuid(uid);
	if(pwd != NULL){
		strcpy(oresult,pwd->pw_name);
		ouid = uid;
		return(oresult);
	}
	return(NULL);
}

/* handle the regular unix and local mods difference for user id's */
/* this call returns the 1 word uid = to what getuid will return */
guid(uid,gid){
	uid = uidmask(uid);
# ifdef FUID
	return((uid & 0377) | (gid << 8));
# else
	return(uid);
# endif
	}

# ifdef OLDTTY
isatty(i){
	return(ttyn(i) != 'x');
	}
char *ttyname(i){		/* return NULL if not TTY */
	char c;
	static char ttystr[] = "/dev/ttyx";
	c = ttyn(i);
	ttystr[8] = c;
	return(c == 'x' ? NULL : ttystr);
	}
# endif

# ifdef CCTTY
# undef ttyname()
myttyname(i){		/* return NULL for non tty */
	static char s[15],*p;
	p = ttyname(i);
	if(p == NULL)return(NULL);
	strcpy(s,"/dev/");
	strcat(s,p);
	return(s);
	}
# define ttyname(S) myttyname(S)
# endif

/* get passwd from passwdf */
getpwdf(pwd)
  struct passwd *pwd; {
# ifdef PASSWDF
# ifndef TESTING
	register char *p, *q;
	char buf1[BUFSIZ], found;
	FILE *pw;
	pwd->pw_passwd[0] = 0;
	pw = fopen("/etc/passwdf","r");
	if(pw == NULL) return;
	found = 0;
	while(fgets(buf1,BUFSIZ,pw) != NULL){
		for(p=buf1; *p && *p != ':'; p++);
		*p = 0;
		if(strcmp(buf1,pwd->pw_name) == 0){
			found = 1;
			break;
			}
		}
	fclose(pw);
	if(!found)return;
	q = ++p;
	for(;*p && *p != ':';p++);
	*p = 0;
	strcpy(pwd->pw_passwd,q);
	/*
	debug("user %s passwd %s %s",pwd->pw_name,pwd->pw_passwd);
	*/
# endif
# endif
	}
/*
   these are all the v7 routines not available on the v6 machines
*/

# ifdef V6

char **environ;			/* global environment pointer */

ioctl(a,b,c){
	return(0);		/* always succeeds */
	}
long atol(s)
  register char *s; {
	long i = 0;
	while('0' <= *s && *s <= '9')
		i = i * 10 + (*s++ - '0');
	return(i);
	}
long gettime(){
	long tt;
	time(&tt);
	return(tt);
	}
long getsize(str)
  struct stat *str; {
	long wk;
	wk = ((long)(str->st_size0 & 0377)) << 16;
	wk += (long)((unsigned)str->st_size1);
	return(wk);
	}
/*
	getenv("HOME")

	always returns home directory.
	returns NULL if there is error.
*/
char *getenv(){
	register char *shdir = NULL;
	register struct passwd *pwd;
	register int it;
	if(shomedir[0] != 0)return(shomedir);
	it = ttyn(2);
# ifdef OLDTTY
	if(it == 'x')it = ttyn(1);
	if(it == 'x')it = ttyn(0);
	if(it != 'x' && hget(it) == 0)shdir = hgethome();
# endif
# ifdef CCTTY
	if(it == -1)it = ttyn(1);
	if(it == -1)it = ttyn(0);
	if(it != -1 && hget(it) == 0)shdir = hgethome();
# endif
	if(shdir == NULL){
		pwd = PwdCurrent();
		if(pwd != NULL)shdir = pwd->pw_dir;
		}
	if(shdir != NULL)strcpy(shomedir,shdir);
	return(shdir);
	}

/* doesn't handle split passwd files */
struct passwd *
getpwuid(uid)
register uid;
{
	register struct passwd *p;
	struct passwd *getpwent();

	uid = uidmask(uid);
	setpwent();
	while( (p = getpwent()) && guid(p->pw_uid,p->pw_gid) != uid );
	endpwent();
	return(p);
}

static char PASSWD[]	= "/etc/passwd";
static char EMPTY[] = "";
static FILE *pwf = NULL;
static char line[BUFSIZ+1];
static struct passwd passwd;

setpwent()
{
	if( pwf == NULL )
		pwf = fopen( PASSWD, "r" );
	else
		rewind( pwf );
}

endpwent()
{
	if( pwf != NULL ){
		fclose( pwf );
		pwf = NULL;
	}
}

static char *
pwskip(p)
register char *p;
{
	while( *p && *p != ':' )
		++p;
	if( *p ) *p++ = 0;
	return(p);
}

struct passwd *
getpwent()
{
	register char *p;

	if (pwf == NULL) {
		if( (pwf = fopen( PASSWD, "r" )) == NULL )
			return(0);
	}
	p = fgets(line, BUFSIZ, pwf);
	if (p==NULL)
		return(0);
	passwd.pw_name = p;
	p = pwskip(p);
	passwd.pw_passwd = p;
	p = pwskip(p);
	passwd.pw_uid = atoi(p);
	passwd.pw_uid = uidmask(passwd.pw_uid);
	p = pwskip(p);
	passwd.pw_gid = atoi(p);
	passwd.pw_quota = 0;
	passwd.pw_comment = EMPTY;
	p = pwskip(p);
	passwd.pw_gecos = p;
	p = pwskip(p);
	passwd.pw_dir = p;
	p = pwskip(p);
	passwd.pw_shell = p;
	while(*p && *p != '\n') p++;
	*p = '\0';
	return(&passwd);
}

struct passwd *
getpwnam(name)
char *name;
{
	register struct passwd *p;
	struct passwd *getpwent();

	setpwent();
	while( (p = getpwent()) && strcmp(name,p->pw_name) );
	endpwent();
	return(p);
}
/*
	getlogin()

	Return current user name by looking at /etc/utmp.
	Returns NULL if not found.
*/
char *getlogin()
{
	struct utmp utmpstr;
	static char snSave[10];
	register char *sttyname,*s;
	register FILE *fp;

	sttyname = ttyname(2);
	if(sttyname == NULL)sttyname = ttyname(1);
	if(sttyname == NULL)sttyname = ttyname(0);
	if(sttyname == NULL)return(NULL);

	fp = fopen("/etc/utmp","r");
	if(fp == NULL)return(NULL);

	snSave[0] = 0;
	while(fread(&utmpstr,1,sizeof utmpstr,fp) == sizeof utmpstr){
# ifdef OLDTTY
		if(utmpstr.ut_tty == sttyname[8]){
# else
		if(strcmp(utmpstr.ut_line,sttyname+5) == 0){
# endif
			utmpstr.ut_tty = 0;
			strcpy(snSave,utmpstr.ut_name);
		}
	}

	fclose(fp);
	s = snSave;
	while(*s != 0 && *s != ' ')s++;
	*s = 0;
	if(snSave[0] == 0)return(NULL);
	return(snSave);
}
/*
 * Unix routine to do an "fopen" on file descriptor
 * The mode has to be repeated because you can't query its
 * status
 */

FILE *
fdopen(fd, mode)
register char *mode;
{
	extern int errno;
	register FILE *iop;
	extern FILE *_lastbuf;

	for (iop = _iob; iop->_flag&(_IOREAD|_IOWRT); iop++)
		if (iop >= _lastbuf)
			return(NULL);
	iop->_cnt = 0;
	iop->_file = fd;
	if (*mode != 'r') {
		iop->_flag |= _IOWRT;
		if (*mode == 'a')
			lseek(fd, 0L, 2);
	} else
		iop->_flag |= _IOREAD;
	return(iop);
}
system(s)
char *s;
{
	int status, pid, w;
	register int (*istat)(), (*qstat)();

	while((pid = fork()) == -1)sleep(2);
	if (pid == 0) {
		execl("/bin/sh", "sh", "-c", s, 0);
		_exit(127);
	}
	istat = signal(SIGINT, SIG_IGN);
	qstat = signal(SIGQUIT, SIG_IGN);
	while ((w = wait(&status)) != pid && w != -1)
		;
	if (w == -1)
		status = -1;
	signal(SIGINT, istat);
	signal(SIGQUIT, qstat);
	return(status);
}

char *
getpass(prompt)
char *prompt;
{
	struct sgttyb ttyb;
	int flags;
	register char *p;
	register c;
	FILE *fi = NULL;
	static char pbuf[9];
	int (*signal())();
	int (*sig)();

	/*	modified because Cory needs super-user to stty /dev/tty */
# ifndef CORY
	if ((fi = fopen("/dev/tty", "r")) == NULL)
		fi = stdin;
	else
		setbuf(fi, (char *)NULL);
	gtty(fileno(fi), &ttyb);
# else
	if(gtty(0,&ttyb) >= 0)fi = stdin;
	else if(gtty(2,&ttyb) >= 0)fi = stderr;
	else {
		pbuf[0] = 0;
		return(pbuf);
		}
# endif
	sig = signal(SIGINT, SIG_IGN);
	flags = ttyb.sg_flags;
	ttyb.sg_flags &= ~ECHO;
	if(stty(fileno(fi), &ttyb) < 0) perror("stty:");
	fprintf(stderr, prompt);
	for (p=pbuf; (c = getc(fi))!='\n' && c!=EOF;) {
		if (p < &pbuf[8])
			*p++ = c;
	}
	*p = '\0';
	fprintf(stderr, "\n");
	ttyb.sg_flags = flags;
	stty(fileno(fi), &ttyb);
	signal(SIGINT, sig);
# ifndef CORY
	if (fi != stdin)
		fclose(fi);
# endif
	return(pbuf);
}
/* end of non-vax v7 routines */
# endif
Commit	Line	Data
91978b44 ES	1	/*
	2	This file is meant to handle all the machine
	3	dependencies in the network code.
	4	Everything is conditionally compiled.
	5
	6	It can be uses w/o network stuff to simulate
	7	v7 for other programs, too.
	8	*/
	9	# include <stdio.h>
	10	# include "mach.h"
	11
	12	char shomedir[100];
	13
	14	# ifndef CC
	15	submit(a) {}
	16	# endif
	17
	18	# ifdef FUID
	19	setgid() {};
	20	# endif
	21
	22	/*
	23	Set the owner uid/gid of a file.
	24	On v7, this is done by the chown command
	25	with three args - (file, uid, gid).
	26	On Vanilla V6 this is done using the
	27	top byte of the second parameter as the gid byte.
	28	On Berkeley Funny uids on V6, no gid is specified.
	29	*/
	30	mchown(sfn,uid,gid)
	31	char *sfn;
	32	int uid;
	33	int gid;
	34	{
	35	# ifndef V6
	36	chown(sfn,uid,gid);
	37	# else
	38	# ifndef FUID
	39	uid = uidmask(uid);
	40	uid = ((gid&0377) << 8) \| (uid & 0377);
	41	# endif
	42	chown(sfn,uid);
	43	# endif
	44	}
	45
	46
	47	char vaxtovax;
	48	long fixuplong(a)
	49	long a; {
	50	# ifdef ISVAX
	51	register char *p,c1,c2;
	52	char c3,c4;
	53	if(!vaxtovax){
	54	p = (char*) &a;
	55	c1 = *p++;
	56	c2 = *p++;
	57	c3 = *p++;
	58	c4 = *p++;
	59	p = (char*) &a;
	60	*p++ = c3;
	61	*p++ = c4;
	62	*p++ = c1;
	63	*p++ = c2;
	64	}
65	# endif
66	return(a);
67	}
68	/*
69	SnFromuid(uid)
70
71	The login name corresponding to uid.
72	Reads the password file.
73	Successive calls overwrite the static string returned.
74	Returns NULL if error.
75	*/
76	char *SnFromUid(uid)
77	register int uid;
78	{
79	register struct passwd *pwd;
80	static int ouid = -1;
81	static char oresult[20] = "";
82	uid = uidmask(uid);
83	if(uid == ouid)
84	return(oresult);
85	# ifdef HPASSWD
86	if(getname(uid,oresult) == 0){
87	ouid = uid;
88	return(oresult);
89	}
90	# endif
91	pwd = getpwuid(uid);
92	if(pwd != NULL){
93	strcpy(oresult,pwd->pw_name);
94	ouid = uid;
95	return(oresult);
96	}
97	return(NULL);
98	}
99
100	/* handle the regular unix and local mods difference for user id's */
101	/* this call returns the 1 word uid = to what getuid will return */
102	guid(uid,gid){
103	uid = uidmask(uid);
104	# ifdef FUID
105	return((uid & 0377) \| (gid << 8));
106	# else
107	return(uid);
108	# endif
109	}
110
111	# ifdef OLDTTY
112	isatty(i){
113	return(ttyn(i) != 'x');
114	}
115	char ttyname(i){ / return NULL if not TTY */
116	char c;
117	static char ttystr[] = "/dev/ttyx";
118	c = ttyn(i);
119	ttystr[8] = c;
120	return(c == 'x' ? NULL : ttystr);
121	}
122	# endif
123
124	# ifdef CCTTY
125	# undef ttyname()
126	myttyname(i){ /* return NULL for non tty */
127	static char s[15],*p;
128	p = ttyname(i);
129	if(p == NULL)return(NULL);
130	strcpy(s,"/dev/");
131	strcat(s,p);
132	return(s);
133	}
134	# define ttyname(S) myttyname(S)
135	# endif
136
137	/* get passwd from passwdf */
138	getpwdf(pwd)
139	struct passwd *pwd; {
140	# ifdef PASSWDF
141	# ifndef TESTING
142	register char p, q;
143	char buf1[BUFSIZ], found;
144	FILE *pw;
145	pwd->pw_passwd[0] = 0;
146	pw = fopen("/etc/passwdf","r");
147	if(pw == NULL) return;
148	found = 0;
149	while(fgets(buf1,BUFSIZ,pw) != NULL){
150	for(p=buf1; p && p != ':'; p++);
151	*p = 0;
152	if(strcmp(buf1,pwd->pw_name) == 0){
153	found = 1;
154	break;
155	}
156	}
157	fclose(pw);
158	if(!found)return;
159	q = ++p;
160	for(;p && p != ':';p++);
161	*p = 0;
162	strcpy(pwd->pw_passwd,q);
163	/*
164	debug("user %s passwd %s %s",pwd->pw_name,pwd->pw_passwd);
165	*/
166	# endif
167	# endif
168	}
169	/*
170	these are all the v7 routines not available on the v6 machines
171	*/
172
173	# ifdef V6
174
175	char *environ; / global environment pointer */
176
177	ioctl(a,b,c){
178	return(0); /* always succeeds */
179	}
180	long atol(s)
181	register char *s; {
182	long i = 0;
183	while('0' <= s && s <= '9')
184	i = i * 10 + (*s++ - '0');
185	return(i);
186	}
187	long gettime(){
188	long tt;
189	time(&tt);
190	return(tt);
191	}
192	long getsize(str)
193	struct stat *str; {
194	long wk;
195	wk = ((long)(str->st_size0 & 0377)) << 16;
196	wk += (long)((unsigned)str->st_size1);
197	return(wk);
198	}
199	/*
200	getenv("HOME")
201
202	always returns home directory.
203	returns NULL if there is error.
204	*/
205	char *getenv(){
206	register char *shdir = NULL;
207	register struct passwd *pwd;
208	register int it;
209	if(shomedir[0] != 0)return(shomedir);
210	it = ttyn(2);
211	# ifdef OLDTTY
212	if(it == 'x')it = ttyn(1);
213	if(it == 'x')it = ttyn(0);
214	if(it != 'x' && hget(it) == 0)shdir = hgethome();
215	# endif
216	# ifdef CCTTY
217	if(it == -1)it = ttyn(1);
218	if(it == -1)it = ttyn(0);
219	if(it != -1 && hget(it) == 0)shdir = hgethome();
220	# endif
221	if(shdir == NULL){
222	pwd = PwdCurrent();
223	if(pwd != NULL)shdir = pwd->pw_dir;
224	}
225	if(shdir != NULL)strcpy(shomedir,shdir);
226	return(shdir);
227	}
228
229	/* doesn't handle split passwd files */
230	struct passwd *
231	getpwuid(uid)
232	register uid;
233	{
234	register struct passwd *p;
235	struct passwd *getpwent();
236
237	uid = uidmask(uid);
238	setpwent();
239	while( (p = getpwent()) && guid(p->pw_uid,p->pw_gid) != uid );
240	endpwent();
241	return(p);
242	}
243
244	static char PASSWD[] = "/etc/passwd";
245	static char EMPTY[] = "";
246	static FILE *pwf = NULL;
247	static char line[BUFSIZ+1];
248	static struct passwd passwd;
249
250	setpwent()
251	{
252	if( pwf == NULL )
253	pwf = fopen( PASSWD, "r" );
254	else
255	rewind( pwf );
256	}
257
258	endpwent()
259	{
260	if( pwf != NULL ){
261	fclose( pwf );
262	pwf = NULL;
263	}
264	}
265
266	static char *
267	pwskip(p)
268	register char *p;
269	{
270	while( p && p != ':' )
271	++p;
272	if( p ) p++ = 0;
273	return(p);
274	}
275
276	struct passwd *
277	getpwent()
278	{
279	register char *p;
280
281	if (pwf == NULL) {
282	if( (pwf = fopen( PASSWD, "r" )) == NULL )
283	return(0);
284	}
285	p = fgets(line, BUFSIZ, pwf);
286	if (p==NULL)
287	return(0);
288	passwd.pw_name = p;
289	p = pwskip(p);
290	passwd.pw_passwd = p;
291	p = pwskip(p);
292	passwd.pw_uid = atoi(p);
293	passwd.pw_uid = uidmask(passwd.pw_uid);
294	p = pwskip(p);
295	passwd.pw_gid = atoi(p);
296	passwd.pw_quota = 0;
297	passwd.pw_comment = EMPTY;
298	p = pwskip(p);
299	passwd.pw_gecos = p;
300	p = pwskip(p);
301	passwd.pw_dir = p;
302	p = pwskip(p);
303	passwd.pw_shell = p;
304	while(p && p != '\n') p++;
305	*p = '\0';
306	return(&passwd);
307	}
308
309	struct passwd *
310	getpwnam(name)
311	char *name;
312	{
313	register struct passwd *p;
314	struct passwd *getpwent();
315
316	setpwent();
317	while( (p = getpwent()) && strcmp(name,p->pw_name) );
318	endpwent();
319	return(p);
320	}
321	/*
322	getlogin()
323
324	Return current user name by looking at /etc/utmp.
325	Returns NULL if not found.
326	*/
327	char *getlogin()
328	{
329	struct utmp utmpstr;
330	static char snSave[10];
331	register char sttyname,s;
332	register FILE *fp;
333
334	sttyname = ttyname(2);
335	if(sttyname == NULL)sttyname = ttyname(1);
336	if(sttyname == NULL)sttyname = ttyname(0);
337	if(sttyname == NULL)return(NULL);
338
339	fp = fopen("/etc/utmp","r");
340	if(fp == NULL)return(NULL);
341
342	snSave[0] = 0;
343	while(fread(&utmpstr,1,sizeof utmpstr,fp) == sizeof utmpstr){
344	# ifdef OLDTTY
345	if(utmpstr.ut_tty == sttyname[8]){
346	# else
347	if(strcmp(utmpstr.ut_line,sttyname+5) == 0){
348	# endif
349	utmpstr.ut_tty = 0;
350	strcpy(snSave,utmpstr.ut_name);
351	}
352	}
353
354	fclose(fp);
355	s = snSave;
356	while(s != 0 && s != ' ')s++;
357	*s = 0;
358	if(snSave[0] == 0)return(NULL);
359	return(snSave);
360	}
361	/*
362	* Unix routine to do an "fopen" on file descriptor
363	* The mode has to be repeated because you can't query its
364	* status
365	*/
366
367	FILE *
368	fdopen(fd, mode)
369	register char *mode;
370	{
371	extern int errno;
372	register FILE *iop;
373	extern FILE *_lastbuf;
374
375	for (iop = _iob; iop->_flag&(_IOREAD\|_IOWRT); iop++)
376	if (iop >= _lastbuf)
377	return(NULL);
378	iop->_cnt = 0;
379	iop->_file = fd;
380	if (*mode != 'r') {
381	iop->_flag \|= _IOWRT;
382	if (*mode == 'a')
383	lseek(fd, 0L, 2);
384	} else
385	iop->_flag \|= _IOREAD;
386	return(iop);
387	}
388	system(s)
389	char *s;
390	{
391	int status, pid, w;
392	register int (istat)(), (qstat)();
393
394	while((pid = fork()) == -1)sleep(2);
395	if (pid == 0) {
396	execl("/bin/sh", "sh", "-c", s, 0);
397	_exit(127);
398	}
399	istat = signal(SIGINT, SIG_IGN);
400	qstat = signal(SIGQUIT, SIG_IGN);
401	while ((w = wait(&status)) != pid && w != -1)
402	;
403	if (w == -1)
404	status = -1;
405	signal(SIGINT, istat);
406	signal(SIGQUIT, qstat);
407	return(status);
408	}
409
410	char *
411	getpass(prompt)
412	char *prompt;
413	{
414	struct sgttyb ttyb;
415	int flags;
416	register char *p;
417	register c;
418	FILE *fi = NULL;
419	static char pbuf[9];
420	int (*signal())();
421	int (*sig)();
422
423	/* modified because Cory needs super-user to stty /dev/tty */
424	# ifndef CORY
425	if ((fi = fopen("/dev/tty", "r")) == NULL)
426	fi = stdin;
427	else
428	setbuf(fi, (char *)NULL);
429	gtty(fileno(fi), &ttyb);
430	# else
431	if(gtty(0,&ttyb) >= 0)fi = stdin;
432	else if(gtty(2,&ttyb) >= 0)fi = stderr;
433	else {
434	pbuf[0] = 0;
435	return(pbuf);
436	}
437	# endif
438	sig = signal(SIGINT, SIG_IGN);
439	flags = ttyb.sg_flags;
440	ttyb.sg_flags &= ~ECHO;
441	if(stty(fileno(fi), &ttyb) < 0) perror("stty:");
442	fprintf(stderr, prompt);
443	for (p=pbuf; (c = getc(fi))!='\n' && c!=EOF;) {
444	if (p < &pbuf[8])
445	*p++ = c;
446	}
447	*p = '\0';
448	fprintf(stderr, "\n");
449	ttyb.sg_flags = flags;
450	stty(fileno(fi), &ttyb);
451	signal(SIGINT, sig);
452	# ifndef CORY
453	if (fi != stdin)
454	fclose(fi);
455	# endif
456	return(pbuf);
457	}
458	/* end of non-vax v7 routines */
459	# endif