llib-lc

操作系统SunOS 4.1.3版本的源码

/*	@(#)llib-lc 1.1 92/07/30 SMI; from UCB 1.37 5/17/86	*/

/* LINTLIBRARY */
#include <sys/types.h>
#include <sys/time.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 <sys/wait.h>
#include <sys/ptrace.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/stropts.h>
#include <sys/poll.h>
#include <sys/label.h>
#include <sys/audit.h>
#include <rpc/rpc.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <varargs.h>
#include <exportent.h>
#include <dirent.h>
#include <fstab.h>
#include <grp.h>
#include <mntent.h>
#include <ndbm.h>
#include <netdb.h>
#include <nlist.h>
#include <pwd.h>
#include <search.h>
#include <setjmp.h>
#include <signal.h>
#include <ttyent.h>
#include <termio.h>	/* instead of sgtty.h */
#include <rpcsvc/ypclnt.h>
#include <signal.h>
#include <ustat.h>
#include <floatingpoint.h>
#include <sys/mman.h>
#include <rpcsvc/pwdnm.h>
#include <rpc/key_prot.h>
#include <rpc/pmap_prot.h>
#include <rpc/pmap_rmt.h>
#include <pwdadj.h>
#include <grpadj.h>
#include <sys/vfs.h>
#include <sys/utsname.h>


#undef isalpha
#undef isupper
#undef islower
#undef isdigit
#undef isxdigit
#undef isalnum
#undef isspace
#undef ispunct
#undef isprint
#undef isgraph
#undef iscntrl
#undef isascii
#undef toupper
#undef tolower
#undef toascii
#undef clearerr
#undef feof
#undef ferror
#undef fileno
#undef getchar
#undef putchar
#undef rewinddir
#undef ntohl
#undef ntohs
#undef htonl
#undef htons

/*
 * Damn RPC garbage.
 */
#ifndef	bool
#define	bool	bool_t
#endif

struct qelem {	/* this should really be defined in an include file */
	struct qelem	*q_forw;
	struct qelem	*q_back;
	char		data[1];
};
char	_ctype_[129];
int	end, etext, edata;
char *	*environ;
char	*optarg;
int	optind;
int	opterr;
int	optopt; /* undocumented */
char	*sys_errlist[];
char	*sys_siglist[];
int	sys_nerr;
struct _iobuf _iob[];

long	a64l(s) char *s; { return (0L); }
int	abort() {;}
int	abs(i) int i; { return(i); }
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	addexportent(f, d, o) FILE *f; char *d, *o; {}
int	addmntent(f, m) FILE *f; struct mntent *m; { return (0); }
int	adjtime(delta, odelta) struct timeval *delta, *odelta; { return 0; }
int	advfs(fs, nm, flg, cl) char *fs, *nm, *cl; { return (flg); }
int	alarm(s) unsigned s; { return(s); }
int	alphasort( d1, d2) struct direct **d1, **d2; { return 0;}
char	*asctime(t) struct tm *t; { return(""); }
void	async_daemon() {}
double	atof(s) char *s; { return(1.); }
int	atoi(s) char *s; { return 1;   }
long	atol(s) char *s; { return 1L;   }
int	audit(r) audit_record_t *r; { return (0); }
void	audit_args(event, argc, argv) char** argv; { }
void	audit_text(event, e, r, argc, argv) char** argv; { }
int	auditon(c) { return (c); }
int	auditsvc(f, l) { return (f); }
AUTH	*authdes_create(servername, window, syncaddr, ckey) char *servername; u_int window; struct sockaddr *syncaddr; des_block *ckey;  { return ((AUTH *)0); }
int	authdes_getucred(adc, uid, gid, grouplen, groups) struct authdes_cred *adc; short *uid, *gid, *grouplen; int *groups; { return (0); }
AUTH	*authnone_create() { return ((AUTH *)0); }
AUTH	*authunix_create(host, uid, gid, len, aup_gids) char *host; int uid, gid, len, *aup_gids; { return ((AUTH *)0); }
AUTH	*authunix_create_default() { return ((AUTH *)0); }
int	bcmp(b1, b2, length) char *b1, *b2; { return 0; }
int	bcopy(src, dst, length) char *src, *dst; { ; }
int	bind(s, n, l) struct sockaddr *n; { return 0; }
int	bindresvport(d, s) struct sockaddr_in *s; { return(0); }
char	*brk(a) char *a; { return(a); }
char	*bsearch(k, b, n, w, c) char *k, *b; unsigned n, w; int (*c)(); { return (k); }
int	bzero(b, length) char *b; { ; }
char	*calloc(n,s) unsigned n, s; { static char c[1]; return(c); }
int	callrpc(host, prog, vers, proc, inproc, in, outproc, out) char *host; u_long prog, vers, proc; xdrproc_t inproc, outproc; char *in, *out; { return (0); }
int	cbc_crypt(key, buf, len, mode, ivec) char *key, *buf, *ivec; unsigned len, mode; { return (0); }
speed_t	cfgetispeed(p) struct termios *p; { return ((speed_t)0); }
speed_t	cfgetospeed(p) struct termios *p; { return ((speed_t)0); }
void	cfree(p) char* p; { }
int	cfsetispeed(p, spd) struct termios *p; speed_t spd; { return (0); }
int	cfsetospeed(p, spd) struct termios *p; speed_t spd; { return (0); }
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; }
void	clearerr(f) FILE *f; {}
void	closelog() {}
enum clnt_stat	clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult) u_long prog, vers, proc; xdrproc_t xargs; char *argsp; xdrproc_t xresults; char *resultsp; bool_t (*eachresult)(); { return ((enum clnt_stat)0); }
CLIENT	*clnt_create(hostname, prog, vers, proto) char *hostname; u_long prog, vers; char *proto; { return ((CLIENT *)0); }
CLIENT	*clnt_create_vers(hostname, prog, vers_out, low, high, proto) char *hostname; unsigned prog, vers_out; unsigned low, high; char *proto; { return ((CLIENT *)0); }
void	clnt_pcreateerror(s) char *s; {}
void	clnt_perrno(num) enum clnt_stat num; {}
void	clnt_perror(rpch, s) CLIENT *rpch; char *s; {}
char	*clnt_spcreateerror(s) char *s; { return (""); }
char	*clnt_sperrno(num) enum clnt_stat num; { return (""); }
char	*clnt_sperror(rpch, s) CLIENT *rpch; char *s; { return (""); }
CLIENT	*clntraw_create(prog, vers) u_long prog, vers; { return ((CLIENT *)0); }
CLIENT	*clnttcp_create(raddr, prog, vers, sockp, sendsz, recvsz) struct sockaddr_in *raddr; u_long prog, vers; int *sockp; u_int sendsz, recvsz; { return ((CLIENT *)0); }
CLIENT	*clntudp_bufcreate(raddr, prog, vers, waittime, sockp, sendsz, recvsz) struct sockaddr_in *raddr; u_long prog, vers; struct timeval waittime; int *sockp; u_int sendsz, recvsz; { return ((CLIENT *)0); }
CLIENT	*clntudp_create(raddr, prog, vers, waittime, sockp) struct sockaddr_in *raddr; u_long prog, vers; struct timeval waittime; int *sockp; { return ((CLIENT *)0); }
long	clock() { return (0L); }
int	close(f) { return(0); }
int	closedir( p ) DIR *p; { return(0); }
int	connect( s, n, l) struct sockaddr *n; { return 0; }
double	copysign(x,y) double x,y; { return (x); }
int	creat(s, m) char *s; { return(0); }
char	*crypt(k,s) char *k, *s; { return(""); }
char	*ctermid(s) char *s; { return (s); }
char	*ctime(c) time_t *c;{ return(""); }
char	*cuserid(s) char *s; { return (s); }
void	dbm_close(db) DBM *db; { ; }
int	dbm_close_status(d) DBM *d; { return(0); }
int	dbm_delete(db, key) DBM *db; datum key; { return 0; }
datum	dbm_fetch(db, key) DBM *db; datum key; { return key; }
datum	dbm_firsthash(db, h) DBM *db; long h; { datum key; return key; }
datum	dbm_firstkey(db) DBM *db; { datum key; return key; }
int	dbm_flush(d) DBM *d; { return(0); }
int	dbm_flushdir(d) DBM *d; { return(0); }
int	dbm_flushpag(d) DBM *d; { return(0); }
long	dbm_forder(d,k) DBM *d; datum k; { return (0L); }
datum	dbm_nextkey(db) DBM *db; { datum key; return key; }
DBM	*dbm_open(file, flags, mode) char *file; { return (DBM *) 0; }
void	dbm_setdefwrite(d) DBM *d; {}
int	dbm_store(db, key, cont, flags) DBM *db; datum key, cont; { return 0; }
void	decimal_to_double(px, pm, pd, ps) double *px ; decimal_mode *pm; decimal_record *pd; fp_exception_field_type *ps; {}
void	decimal_to_extended(px, pm, pd, ps) extended *px ; decimal_mode *pm; decimal_record *pd; fp_exception_field_type *ps; {}
void	decimal_to_quadruple(px, pm, pd, ps) quadruple *px; decimal_mode *pm; decimal_record *pd; fp_exception_field_type *ps; {}
void	decimal_to_single(px, pm, pd, ps) single *px ; decimal_mode *pm; decimal_record *pd; fp_exception_field_type *ps; {}
void	des_setparity(p) char *p; { }
void	double_to_decimal(px, pm, pd, ps) double *px ; decimal_mode *pm; decimal_record *pd; fp_exception_field_type *ps; {}
double	drand48() { return (0.0); }
int	dup(f) { return(f); }
int	dup2( o, n) { return o; }
int	dysize(x) { return (x); }
int	ecb_crypt(key, buf, len, mode) char *key, *buf; unsigned len, mode; { return (0); }
char	*econvert(v, n, d, s, b) double v; int *d, *s; char *b; { return (""); }
char	*ecvt(v, n, d, s) double v; int *d, *s; { return(""); }
int	encrypt(s, i) char *s; {}
void	endac() {}
void	endexportent(f) FILE *f; {}
int	endfsent() { return 0; }
void	endgrent() {}
void	endgraent() {}
void	endhostent() {}
int	endmntent(f) FILE *f; { return (0); }
int	endnetent() { ; }
int	endnetgrent() {}
void	endprotoent() {}
void	endpwent() {}
void	endpwaent() {}
void	endrpcent() {}
void	endttyent() {}
void	endservent() {}
void	endusershell() {}
double	erand48(x) unsigned short x[3]; { return (0.0); }
int	ether_hostton(h, e) char *h; struct ether_addr *e; { return (0); }
int	ether_line(l, e, h) char *l, *h; struct ether_addr *e; { return (0); }
char	*ether_ntoa(e) struct ether_addr *e; { return (""); }
int	ether_ntohost(h, e) char *h; struct ether_addr *e; { return (0); }
	/*VARARGS2*/
int	execl(f, a) char *f, *a; { return (0); }
	/*VARARGS2*/
int	execle(f, a, e) char *f, *a, *e[]; { return (0); }
	/*VARARGS2*/
int	execlp(f, a) char *f, *a; { return (0); }
int	execv(s, v) char *s, *v[]; { return (0); }
int	execve(f, a, e) char *f, *a[], *e[]; { return (0); }
int	execvp(s, v) char *s, *v[]; { return (0); }
void	exit(s) {}
int	_exit(s) {}
int	exportfs(d, uex) char *d; struct export *uex; { return (0); }
void	extended_to_decimal(px, pm, pd, ps) extended *px ; decimal_mode *pm; decimal_record *pd; fp_exception_field_type *ps; { }
double	fabs(x) double x; { return (x); }
int	fchdir(d) { return (d); }
int	fchmod(f, m) { return(0); }
int	fchown(f, u, g) { return(0); }
int	fchroot(d) { return (d); }
int	fclose(f) FILE *f; {return(0);}
	/*VARARGS2*/
int	fcntl(f, c, a) { return (0); }
char	*fconvert(v, n, d, s, b) double v; int *d, *s; char *b; { return (""); }
char	*fcvt(v, n, d, s) double v; int *d, *s; { return(""); }
FILE	*fdopen(fd, m) char *m; { return(stdin);}
int	feof(f) FILE *f; { return (0); }
int	ferror(f) FILE *f; { return (0); }
int	fflush(f) FILE *f; {return(0);}
int	ffs(i) { return i; }
int	fgetc(f)  FILE *f; {return 0; }
struct group_adjunct	*fgetgraent(f) FILE *f; { static struct group_adjunct x; return (&x); }
struct group	*fgetgrent(f) FILE *f; { return (struct group *)NULL; }
struct passwd_adjunct	*fgetpwaent(f) FILE *f; { static struct passwd_adjunct x; return (&x); }
struct passwd	*fgetpwent(f) FILE *f; { return (struct passwd *)NULL; }
char	*fgets( s, l, f ) char *s; FILE *f; { return(s); }
int	_filbuf( f ) FILE *f; { return 0; }
void	file_to_decimal(pc,nmax,fortran_conventions,pd,pform,pechar,pf,pnread) char **pc; int nmax; int fortran_conventions; decimal_record *pd; enum decimal_string_form *pform; char **pechar; FILE *pf; int *pnread; {}
int	fileno(f) FILE *f; { static int fd; return (fd); }
int	flock( f, o ) { return 0; }
int	_flsbuf( c, f ) unsigned char c; FILE *f; { return 0; }
double	fmod(x,y) double x, y; { return (x); }
FILE	*fopen(s,m) char *s, *m; { return(stdin); }
int	fork() { return(0); }
long	fpathconf(fd, name) { return(1L); }
	/*VARARGS2 PRINTFLIKE2*/
int	fprintf( f, s ) FILE *f; char *s; {return 1;}
int	fputc(c, f) char c; FILE *f; {return 0; }
int	fputs(s, f) char *s; FILE *f; {return 0; }
int	fread( p, s, n, f ) char *p; FILE *f; {return(1);}
int	free(p) char *p; {;}
FILE	*freopen(s, m, f) char *s, *m; FILE *f; { return(stdin); }
double	frexp( v, e) double v; int *e; { return v; }
	/*VARARGS2 SCANFLIKE2*/
int	fscanf( f, s ) FILE *f; char *s; {return(1);}
int	fseek(f, o, p) FILE *f; long o; { return(0); }
int	fstat(f, b) struct stat *b; { return(0); }
int	fstatfs(f, b) struct statfs *b; { return (0); }
int	fsync( f ) { return 0; }
long	ftell(f) FILE *f; { return(0L); }
int	ftime(tp) struct timeb *tp; { ; }
key_t	ftok(s, i) char *s; { return ((key_t)0); }
int	ftruncate( d, l) off_t l; { return 0;}
int	ftw(p, f, d) char *p; int (*f)(); { return (d); }
void	func_to_decimal(pc,nmax,fortran_conventions,pd,pform,pechar,pget,pnread,punget) char **pc; int nmax; int fortran_conventions; decimal_record *pd; enum decimal_string_form *pform; char **pechar; int (*pget)(); int *pnread; int (*punget)(); {}
int	fwrite( p, s, n, f ) char *p; FILE *f; {return(0);}
char	*gconvert(v, n, t, b) double v; char *b; { return (b); }
char	*gcvt(v, n, b) double v; char *b; { return(""); }
int	get_myaddress(addr) struct sockaddr_in *addr; { }