llib-lc

操作系统SunOS 4.1.3版本的源码

/*	@(#)llib-lc 1.1 92/07/30 SMI; from S5R2 2.14	*/
/*LINTLIBRARY*/

/*
 * All include files, no particular order.
 */
#include <stdio.h>
#include <errno.h>
#include <sys/param.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/sem.h>
#include <pwd.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <sys/stat.h>
#include <sys/stropts.h>
#include <sys/resource.h>
#include <sys/poll.h>
#include <sys/ptrace.h>
#include <sys/shm.h>
#include <sys/times.h>
#include <sys/utsname.h>
#include <ustat.h>
#include <utime.h>
#include <sys/wait.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netinet/if_ether.h>
#include <dirent.h>
#include <exportent.h>
#include <fstab.h>
#include <grp.h>
#include <netdb.h>
#include <mntent.h>
#include <ttyent.h>
#include <search.h>
#include <arpa/inet.h>
#include <malloc.h>
#include <mon.h>
#include <ndbm.h>
#include <a.out.h>
#include <setjmp.h>
#include <termios.h>
#include <varargs.h>
#include <rpcsvc/ypclnt.h>
#include <rpc/rpc.h>
#include <grpadj.h>
#include <sys/label.h>
#include <sys/audit.h>
#include <pwdadj.h>
#include <nfs/nfs.h>
#include <nfs/export.h>
#include <sys/vfs.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 <locale.h>

/*
 * All undefs, alpha order
 */
#undef assert
#undef clearerr
#undef feof
#undef ferror
#undef fileno
#undef getc
#undef getchar
#undef htonl
#undef htons
#undef isalnum
#undef isalpha
#undef isascii
#undef iscntrl
#undef isdigit
#undef isgraph
#undef islower
#undef isprint
#undef ispunct
#undef isspace
#undef isupper
#undef isxdigit
#undef ntohl
#undef ntohs
#undef putc
#undef putchar
#undef rewinddir
#undef toascii
#undef _tolower
#undef _toupper

/*
 * Gross garbage for yp people.  Clean up your act, RPC!
 */
#ifndef	bool
#define	bool	bool_t
#endif

/*
 * All externs (yuck).
 * !}sort +1 order
 */
char	_ctype_[129];
FILE	_iob[];
int	daylight;
int	end, etext, edata;
char**	environ;
int	errno;
char*	optarg;
int	opterr;
int	optind;
int	optopt; /* undocumented */
char*	sys_errlist[1];
int	sys_nerr;
char*	sys_siglist[1];
long	timezone;
char*	tzname[2];
struct	qelem { struct qelem *q_forw, *q_back; char q_data[1]; };
struct	rpc_createerr rpc_createerr;	/* rpc_commondata */
fd_set svc_fdset;			/* rpc_commondata */

/*
 * All function names, alpha order by function name
 * Note: _foo and foo are considered alphabetically very close, with
 * _foo coming second.
 */
long		a64l(s) char *s; { return (0L); }
void		abort() {}
int		abs(i) { return (i); }
int		accept(s, a, l) struct sockaddr *a; int *l; { return (s); }
int		access(f, m) char *f; mode_t m; { return (m); }
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); }
unsigned	alarm(s) unsigned s; { return (s); }
int		alphasort(d1, d2) struct dirent **d1, **d2; { return (0); }
char		*asctime(t) struct tm *t; { static char *x; return (x); }
void		_assert(a, f, n) char *a, *f; {}
void		assert(exp) {}
void		async_daemon() {}
double		atof(s) char *s; { return (0.0); }
int		atoi(s) char *s; { return (0); }
long		atol(s) char *s; { return (0L); }
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, l) char *b1, *b2; { return (0); }
void		bcopy(b1, b2, l) char *b1, *b2; {}
int		bind(s, n, l) struct sockaddr *n; { return (0); }
int		bindresvport(d, s) struct sockaddr_in *s; { return (0); }
int		brk(e) char *e; { return (0); }
void		*bsearch(k, b, n, w, c) void *k, *b; size_t n, w; int (*c)(); { return (k); }
void		bzero(b, l) char *b; {}
void		*calloc(n, e) size_t n, e; { static void *x; return (x); }
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(t) struct termios *t; { static speed_t x; return (x); }
speed_t		cfgetospeed(t) struct termios *t; { static speed_t x; return (x); }
void		cfree(p) char* p; { }
int		cfsetispeed(t, s) struct termios *t; speed_t s; { return (0); }
int		cfsetospeed(t, s) struct termios *t; speed_t s; { return (0); }
int		chdir(s) char *s; { return (0); }
int		chmod(s, m) char *s; mode_t m; { return (0); }
int		chown(s, o, g) char *s; uid_t o; gid_t g; { return (o); }
int		chroot(p) char *p; { return (0); }
void		clearerr(f) FILE *f; {}
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(d) DIR *d; { return (0); }
void		closelog() {}
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; mode_t m; { return (m); }
char		*crypt(k, s) char *k, *s; { return (k); }
char		*ctermid(s) char *s; { return (s); }
char		*ctime(t) time_t *t; { static char *x; return (x); }
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_nextkey(db) DBM *db; { datum key; return key; }
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); }
void		dbm_setdefwrite(d) DBM *d; {}
DBM		*dbm_open(file, flags, mode) char *file; { return (DBM *) 0; }
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(f1, f2) { return (f2); }
int		dysize(x) { return (x); }