llib-lbsd

操作系统SunOS 4.1.3版本的源码

/*	
 * BSD 4.3-tahoe lint library
 * @(#)llib-lc	1.47 (Berkeley) 10/1/89	
 */

/* LINTLIBRARY */

#include <sys/types.h>
#include <sys/dir.h>
#define	KERNEL	/* prevents function prototypes */
#include <sys/time.h>

#include <sys/wait.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/timeb.h>
#include <sys/times.h>
#include <sys/uio.h>
#include <sys/vtimes.h>

#include <netinet/in.h>

/*#include <netns/ns.h>		no got */

#include <arpa/inet.h>

/*#include <sys/disklabel.h>	no got */
#include <fstab.h>
#include <grp.h>
#include <ndbm.h>
#include <netdb.h>
#include <nlist.h>
#include <pwd.h>
/*#include <setjmp.h>		type conflicts */
#include <sgtty.h>
#include <signal.h>
/*#include <stdio.h>		type conflicts */
#include <ttyent.h>

struct ns_addr { int filler[10]; };	/* dummy */
typedef int jmp_buf[9];
typedef int sigjmp_buf[10];
struct _iobuf { int filler[5]; };

/*
 * All stolen from stdio.h
 */
struct _iobuf _iob[];
#define	FILE	struct _iobuf
#define	EOF	(-1)
#define	stdin	(&_iob[0])
#define	stdout	(&_iob[1])
#define	stderr	(&_iob[2])

	/***	SECTION 2	***/
int	errno;

int	accept(s, a, l) struct sockaddr *a; int *l; { return s; }
int	access( p, m) char *p; { return 0; }
int	acct(f) char *f; { return 0;}
int	adjtime(delta, odelta) struct timeval *delta, *odelta; { return 0; }
int	bind(s, n, l) struct sockaddr *n; { return 0; }
char	*brk(a) char *a; { return(a); }
int	chdir(s) char *s; { return(0); }
int	chmod(s, m) char *s; { return(0); }
int	chown(s, u, g) char *s; { return(0); }
int	chroot( d ) char *d; { return 0; }
int	close(f) { return(0); }
int	connect( s, n, l) struct sockaddr *n; { return 0; }
int	dup(f) { return(f); }
int	dup2( o, n) { return o; }
	execve(s, v, e) char *s, *v[], *e[]; {;}
	_exit(s) {;}
int	fchmod(f, m) { return(0); }
int	fchown(f, u, g) { return(0); }
int	fcntl(f, c, a) { return (0); }
int	flock( f, o ) { return 0; }
int	fork() { return(0); }
int	fsync( f ) { return 0; }
int	fstat(f, b) struct stat *b; { return(0); }
int	ftruncate( d, l) off_t l; { return 0;}
int	getdtablesize() { return 20 ; }
gid_t	getegid() { return((gid_t)1); }
uid_t	geteuid() { return((uid_t)1); }
gid_t	getgid() { return((gid_t)1); }
int	getgroups( n, g ) int n, *g; { return 0; }
long	gethostid() { return 1L; }
int	gethostname( n, l ) char *n; int l; { return 0 ;}
int	getitimer( w, v ) struct itimerval *v; { return 0; }
int	getpagesize() { return 1; }
int	getpeername(s, n, l) struct sockaddr *n; int *l; { return (0); }
int	getpgrp(p) { return 1; }
int	getpid() { return(1); }
int	getppid() { return(1); }
int	getpriority( w, who) { return 1;}
int	getrlimit( res, rip) struct rlimit *rip; { return 0;}
int	getrusage( res, rip) struct rusage *rip; { return 0;}
int	getsockname(s, name, namelen) struct sockaddr *name; int *namelen; { return(0); }
int	getsockopt( s, level, opt, buf, len ) char *buf; int *len; { return 0;}
int	gettimeofday( t, z ) struct timeval *t; struct timezone *z; { return 0;}
uid_t	getuid() { return((uid_t)1); }
int	ioctl( d, r, p) u_long r; char *p; { return 0;}
int	kill(p, s) { return(0); }
int	killpg( pg, s) { return 0;}
int	link(a, b) char *a, *b; { return(0); }
int	listen( s, b ){ return 0; }
off_t	lseek(f, o, d) off_t o; { return(o); }
int	lstat(s, b) char *s; struct stat *b; { return(0); }
#ifdef notdef
int	madvise( a, l, b ) char * a; int l, b; { return 0;}
int	mmap( a, l, p, s, f, o ) char * a; off_t o; { return 0;}
int	mincore( a, l, v ) char * a; int l; char *v; { return 0; }
#endif
int	mkdir( p, m ) char *p; { return 0; }
int	mknod(n, m, a) char *n; { return(0); }
int	mount(s, n, f) char *s, *n; { return(0); }
#ifdef notdef
int	mprotect( a, l, p) char * a; { return 0;}
int	mremap( a, l, p, s, f) char * a, f; { return 0;}
int	munmap( a, l) char * a; { return 0;}
#endif
	/* VARARGS2 */
int	open(f, m, stuff) char *f; { return(0); }
int	pipe(f) int f[2]; { return(0); }
	profil(b, s, o, i) char *b; {;}
int	ptrace(r, p, a, d) int *a; { return(0); }
int	quota(c, u, a, ad) char *ad; { return(0); }
int	read(f, b, l) char *b; { return(l); }
int	readv( d, v, l) struct iovec *v; { return l; }
int	readlink( p, b, s ) char *p, *b; { return 1; }
	reboot( h ) {;}
int	recv( s, b, l, f ) char *b; { return l ; }
int	recvfrom( s, b, l, f, fr, fl ) char *b; struct sockaddr *fr; int *fl;
		{ return l; }
int	recvmsg( s, m, f ) struct msghdr m[]; { return 1; }
int	rename( f, t ) char *f, *t; { return 0;}
int	rmdir( p ) char *p; { return 0;}
char	*sbrk(i) { return((char *)0); }
int	select( n, r, w, e, t ) fd_set *r, *w, *e; struct timeval *t; { return n; }
int	send( s, m, l, f )  char *m; { return l; }
int	sendto( s, m, l, f, t, tl ) char *m; struct sockaddr *t; { return l; }
int	sendmsg( s, m, l) struct msghdr m[]; { return l; }
int	setgroups( n, g) int *g; { return 0; }
int	sethostid( h ) long h; { return 0;}
int	sethostname( n, l ) char *n; int l; { return 0 ;}
int	setitimer( w, v, ov ) struct itimerval *v, *ov; { return 0; }
int	setpgrp( g, pg) { return 0; }
int	setpriority( w, who, pri ) { return 1;}
int	setquota(s, f) char *s, *f; { return 0; }
int	setregid( r, e) int r, e; { return 0; }
int	setreuid( r, e) int r, e; { return 0; }
int	setrlimit( res, rip) struct rlimit *rip; { return 0;}
	/* VARARGS */
int	setsockopt( s, level, opt, buf, len ) char *buf; { return 0;}
int	settimeofday( t, z ) struct timeval *t; struct timezone *z; { return 0;}
int	shutdown( s, h ){ return 0;}
void	(*signal(c, f))() void (*f)(); { return(f); }
int	sigvec(c, f, m) struct sigvec *f, *m; { return 0; }
int	sigblock(m) { return (m); }
int	sigsetmask(m) { return (m); }
	sigpause(m) { ; }
int	sigreturn(scp) struct sigcontext *scp; { return -1; }
int	sigstack(ss, oss) struct sigstack *ss, *oss; { return 0 ; }
int	socket( a, t, p) {return 1;}
int	socketpair( d, t, p, s ) int s[2]; { return 0; }
int	stat(s, b) char *s; struct stat *b; { return(0); }
#ifdef notdef
char *	stk( a ) char * a; { return a; }
char *	sstk( a ) int a; { return (char *)0; }
#endif
int	swapon( s ) char *s; { return 0;}
int	symlink( t, f) char *t, *f; { return 0;}
	sync(){;}
int	truncate( p, l) char *p; off_t l; { return 0;}
int	umask( n ) { return n; }
int	umount(s) char *s; { return 0; }
int	unlink(s) char *s; { return(0); }
int	utimes( f, t ) char *f; struct timeval t[2]; { return 0 ;}
int	vfork() { return(0); }
	vhangup() { ; }
int	wait(s) union wait *s; { return(1); }
int	wait3( s, o, r) union wait *s; struct rusage *r; { return 1;}
int	write(f, b, l) char *b; { return(l); }
int	writev( f, v, l) struct iovec *v; { return l; }


	/***	SECTION 3	***/

struct qelem {	/* this should really be defined in an include file */
	struct qelem	*q_forw;
	struct qelem	*q_back;
	char		data[1];
}

	/* antique system calls and unclassified */
	_longjmp( e, v) jmp_buf e; {;}
int	_setjmp(e) jmp_buf e; { return(0); }
	abort() {;}
int	abs(i) int i; { return(i); }
int	alarm(s) unsigned s; { return(s); }
	alphasort( d1, d2) struct direct **d1, **d2; { return 0;}
char *	asctime(t) struct tm *t; { return(""); }
double	atof(s) char *s; { return(1.); }
int	atoi(s) char *s; { return 1;   }
long	atol(s) char *s; { return 1L;   }
int	bcmp(b1, b2, length) char *b1, *b2; { return 0; }
	bcopy(src, dst, length) char *src, *dst; { ; }
	bzero(b, length) char *b; { ; }
char *	calloc(n,s) unsigned n, s; { static char c[1]; return(c); }
int	closedir( p ) DIR *p; {}		/* SunOS change: was int */
	closelog() {}
int	creat(s, m) char *s; { return(0); }
char *	crypt(k,s) char *k, *s; { return(""); }
char *	ctime(c) long *c;{ return(""); }
char	_ctype_[];
DBM *	dbm_open(file, flags, mode) char *file; { return (DBM *) 0; }
void	dbm_close(db) DBM *db; { ; }
datum	dbm_fetch(db, key) DBM *db; datum key; { return key; }
int	dbm_store(db, key, cont, flags) DBM *db; datum key, cont; { return 0; }
int	dbm_delete(db, key) DBM *db; datum key; { return 0; }
datum	dbm_firstkey(db) DBM *db; { datum key; return key; }
datum	dbm_nextkey(db) DBM *db; { datum key; return key; }
char *	ecvt(v, n, d, s) double v; int *d, *s; { return(""); }
	encrypt(s, i) char *s; {}
int	endfsent() {}				/* SunOS change: was void */
void	endgrent() { ; }
	endhostent() { ; }
	endnetent() { ; }
	endprotoent() { ; }
void	endpwent() {}
	endservent() { ; }