static char *rcsid = "$Header: /f/osi/compat/RCS/select.c,v 7.6 91/02/22 09:15:45 mrose Interim $";

 

 


 

 
 

 
 
 
 

 







 
 

extern int errno;





 
 


 

	 

	 


 

 

 

 

 

 

 


 

 

extern int errno;
 
 
 
 

 


 


typedef unsigned long	size_t;

typedef long	fpos_t;

 




 




typedef struct {
	unsigned char	*_ptr;
	int	_cnt;
	unsigned char	*_base;
	unsigned char   *_bufendp;
	short	_flag;
	short	_file;
	int	_unused[3];
} FILE;

extern FILE	_iob[20];


extern size_t 	fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
extern size_t	fwrite(const void *ptr, size_t size, size_t nmemb,FILE *stream);


extern int 	ferror(FILE *stream);
extern int 	feof(FILE *stream);
extern void 	clearerr(FILE * stream);
extern int 	putchar(int c);
extern int 	getchar(void);
extern int 	putc(int c, FILE *stream);
extern int 	getc(FILE *stream);
extern int	remove(const char *filename);
extern int	rename(const char *old, const char *new);
extern FILE 	*tmpfile(void);
extern char 	*tmpnam(char *s);
extern int 	fclose(FILE *stream);
extern int 	fflush(FILE *stream);
extern FILE	*fopen(const char *filename, const char *mode);
extern FILE 	*freopen(const char *filename, const char *mode, FILE *stream);
extern void 	setbuf(FILE *stream, char *buf);
extern int 	setvbuf(FILE *stream, char *buf, int mode, size_t size);
extern int	fprintf(FILE *stream, const char *format, ...); 
extern int	fscanf(FILE *stream, const char *format, ...);
extern int	printf(const char *format, ...); 
extern int	scanf(const char *format, ...); 
extern int	sprintf(char *s, const char *format, ...); 
extern int	sscanf(const char *s, const char *format, ...); 
extern int	vfprintf();
extern int	vprintf(); 
extern int	vsprintf();
extern int 	fgetc(FILE *stream);
extern char 	*fgets(char *s, int n, FILE *stream);
extern int 	fputc(int c, FILE *stream);
extern int 	fputs(const char *s, FILE *stream);
extern char 	*gets(char *s);
extern int 	puts(const char *s);
extern int	ungetc(int c, FILE *stream);
extern int	fgetpos(FILE *stream, fpos_t *pos);
extern int 	fseek(FILE *stream, long int offset, int whence);
extern int	fsetpos(FILE *stream, const fpos_t *pos);
extern long	ftell(FILE *stream);
extern void	rewind(FILE *stream);
extern void 	perror(const char *s); 





 

 
 
 
 
 
 

 

typedef char *		va_list;

typedef int		ptrdiff_t;

typedef unsigned short	wchar_t;


typedef	long		time_t;

typedef int		clock_t;



 
typedef	unsigned char	uchar_t;
typedef	unsigned short	ushort_t;
typedef	unsigned int	uint_t;
typedef unsigned long	ulong_t;

 
typedef	struct { int r[1]; } *	physadr_t;
typedef long		level_t;
typedef	long		daddr_t;	 
typedef	char *		caddr_t;	 
typedef	ulong_t		ino_t;		 
typedef short		cnt_t;
typedef ulong_t		dev_t;		 
typedef	long		chan_t;		 
typedef	long		off_t;		 
typedef	long		paddr_t;
typedef	long		key_t;
typedef long		timer_t;	 
typedef	short		nlink_t;
typedef	ulong_t		mode_t;		 
typedef ulong_t		uid_t;		 
typedef ulong_t		gid_t;		 
typedef	void *		mid_t;		 
typedef	int		pid_t;		 
typedef char		slab_t[12];	 
typedef long            mtyp_t;		 


 


 

typedef struct label_t {		 
	struct label_t *prev;		 
	ulong_t           iar;		 
	ulong_t           stack;		 
	ulong_t           toc;		 
	ulong_t           cr;              
	ulong_t           intpri;		 
	ulong_t           reg[19];	 
} label_t;

typedef long		vmid_t;		 
typedef ulong_t		vmhandle_t;	 

typedef struct vmaddr_t {		 
	vmhandle_t	srval;		 
	caddr_t		offset;		 
} vmaddr_t;

typedef struct adspace_t{		 
	ulong_t		alloc;		 
	vmhandle_t	srval[16];	 
} adspace_t;




 
 
typedef struct sigset_t	{
	unsigned long losigs;
	unsigned long hisigs;
} sigset_t;





 
typedef	uchar_t		uchar;
typedef	ushort_t	ushort;
typedef	uint_t		uint;
typedef ulong_t		ulong;

typedef	physadr_t	physadr;

 
typedef	unsigned char	u_char;
typedef	unsigned short	u_short;
typedef	unsigned int	u_int;
typedef	unsigned long	u_long;

typedef	struct	_quad { long val[2]; } quad;
typedef	long	swblk_t;


 
struct sigset	{
	unsigned long losigs;
	unsigned long hisigs;
};

 
struct fsid {
	long	val[2];
};
typedef struct fsid fsid_t;

 

struct fid {
	uint_t	fid_len;
	char	fid_data[(32 - sizeof(fsid_t) - sizeof(uint_t))];
};
typedef struct fid fid_t;

struct fileid {			 
	uint_t	fid_len;
	ino_t	fid_ino;
	uint_t	fid_gen;
	char	fid_x[(32 - sizeof(fsid_t) - sizeof(uint_t)) - (sizeof(ino_t) + 2) - sizeof(uint_t)];
};

 
struct fhandle {
	char x[32];		 
};
struct filehandle {			 
	fsid_t		fh_fsid;		 
	struct fileid	fh_fid;			 
};
typedef struct fhandle fhandle_t;

 
struct unique_id {
       unsigned long word1;
       unsigned long word2;
       unsigned long word3;
       unsigned long word4;
};
typedef struct unique_id unique_id_t;



extern int 	fileno(FILE *stream);
extern FILE 	*fdopen(int fildes, char *type);




extern int 	getw(FILE *stream);
extern int 	putw(int w, FILE *stream);
extern char 	*tempnam(char*,char*);
extern FILE 	*popen(char *cmd, char *mode);
extern int 	pclose(FILE *ptr);




 
 
 
 

 

 




 

 



 

 


 

 

 




 
 
 

 
 

 









 


 


 


 



 

 
 

	extern  unsigned   int SINFINITY;
	extern  unsigned   int _DBLINF[2];
	extern  unsigned   int SQNAN;
	extern  unsigned   int DQNAN[2];
	extern  unsigned   int SSNAN;
	extern  unsigned   int DSNAN[2];



 

typedef	unsigned short fprnd_t;


fprnd_t fp_read_rnd(void);
fprnd_t fp_swap_rnd(fprnd_t rnd);



 



			 

 


 


















			 
  			 

			 
			 
			 
			 

 





extern char	*ctermid(char *);
extern char 	*cuserid(char *);





 

 

 



			 




 

















 



typedef char *CP;


typedef long integer;

 
 
 







typedef int	*IP;


typedef	int	(*IFP) ();


typedef void   (*VFP) ();




struct udvec {			 
    caddr_t uv_base;
    int	    uv_len;

    int	    uv_inline;
};


struct qbuf {
    struct qbuf *qb_forw;	 
    struct qbuf *qb_back;	 

    int	    qb_len;		 
    char   *qb_data;		 
    char    qb_base[1];		 
};









 


 

 

 



 

 

 



 

 

 



 

typedef struct  ll_struct {
    char   *ll_file;		 

    char   *ll_hdr;		 
    char   *ll_dhdr;		 

    int	    ll_events;		 

    int	    ll_syslog;		 
				 

    int     ll_msize;		 

    int     ll_stat;		 

    int     ll_fd;		 
} LLog;

 







int	ll_open ();
int	ll_log (), _ll_log ();
int	ll_close ();

void	ll_hdinit ();
void	ll_dbinit ();

int	ll_printf ();
int	ll_sync ();

char   *ll_preset ();

int	ll_check ();

int	ll_defmhdr ();
IFP	ll_setmhdr ();


 

extern char    *isodename;
extern char    *isodebinpath;
extern char    *isodesbinpath;
extern char    *isodetcpath;
extern char    *isodelogpath;


 

extern LLog *compat_log, _compat_log;
extern LLog *addr_log, _addr_log;
extern LLog *tsap_log, _tsap_log;
extern LLog *ssap_log, _ssap_log;
extern LLog *psap_log, _psap_log;
extern LLog *psap2_log, _psap2_log;
extern LLog *acsap_log, _acsap_log;
extern LLog *rtsap_log, _rtsap_log;
extern LLog *rosap_log, _rosap_log;


 

extern int	ts_stacks;

struct ts_interim {
    char   *ts_name;		 
    char   *ts_value;		 

    int	    ts_subnet;		 
    int	    ts_syntax;		 

    char    ts_prefix[20];	 
    int	    ts_length;		 
};
extern struct ts_interim ts_interim[];

extern int	ts_communities[];
extern int	ts_comm_nsap_default;
extern int	ts_comm_x25_default;
extern int	ts_comm_tcp_default;

extern char *tsb_addresses[];
extern int tsb_communities[];

extern char *tsb_default_address;



 



 




 

extern int	ses_ab_timer;
extern int	ses_dn_timer;
extern int	ses_rf_timer;


 

extern char	ns_enabled;
extern char    *ns_address;


 

void	isodetailor ();
int	isodesetvar ();
void	isodexport ();


char   *_isodefile ();

char   *getlocalhost ();

 


 

 
 
 
 
 
 
 



 

 
 

 



					 

 




 



 



 





 



 

 



 


 

struct  stat
{
	dev_t	st_dev;			 
					 
					 
					 
	ino_t	st_ino;			 
	mode_t	st_mode;		 
	short	st_nlink;		 
	uid_t	st_uid;			 
	gid_t	st_gid;			 
	dev_t	st_rdev;		 
					 
					 
	off_t	st_size;		 
	time_t	st_atime;		 
	int	st_spare1;
	time_t	st_mtime;		 
	int	st_spare2;
	time_t	st_ctime;		 
	int	st_spare3;
					 
					 
	ulong_t	st_blksize;		 
	ulong_t	st_blocks;		 

	 
	 
	 

	int	st_vfstype;		 
	ulong_t	st_vfs;			 
	ulong_t	st_type;		 
	ulong_t	st_gen;			 
	ulong_t	st_flag;		 
	uid_t	Reserved1;		 
	gid_t	Reserved2;		 

	 
	 
	 

	ushort_t st_access;		 
	ulong_t	st_spare4[5];		 
};
			 


	extern mode_t	umask(mode_t cmask); 

	extern int	mkdir(char *path, mode_t mode); 
	extern int	stat(char *path, struct stat *buf);
	extern int	fstat(int fildes, struct stat *buf);
	extern int	chmod(char *path, mode_t mode);
	extern int	mkfifo(char *path, mode_t mode);



 


 

 



 




extern int errno;


int	xselect_blocking_on_intr = 0;

 


 

 

 

 
					 
					 
					 



 

 
                                 
                                 
                                 
                                 
                                 

 
					 
					 
					 
					 



 
struct timestruc_t {
        unsigned long	tv_sec;          
        	 long	tv_nsec;         
};

 
struct itimerstruc_t {
        struct  timestruc_t it_interval;  
        struct  timestruc_t it_value;     
};



 

 


 


 
struct timeval {
        int		tv_sec;          
        int		tv_usec;         
};


 


 

 
struct	itimerval {
	struct		timeval it_interval;  
	struct		timeval it_value;  
};

 
struct timezone {
	int		tz_minuteswest;	 
	int		tz_dsttime;	 
};


 
 

 

extern	int select(
	unsigned long nfdsmsgs,	 
	void *readlist,		 
	void *writelist,	 
	void *exceptlist,	 
	struct timeval *timeout);	 

 

 

 

 

 

 

 

typedef unsigned int	fd_mask;

typedef	struct fd_set {
	fd_mask	fds_bits[((((sizeof (fd_set) * 8))+(((sizeof(fd_mask) * 8))-1))/((sizeof(fd_mask) * 8)))];
} fd_set;




 

int	selsocket (nfds, rfds, wfds, efds, secs)
int	nfds;
fd_set *rfds,
       *wfds,
       *efds;
int	secs;
{
    int     n;
    fd_set  ifds,
            ofds,
	    xfds;
    struct timeval  tvs;
    register struct timeval *tv = &tvs;

    if (secs != (-1))
	tv -> tv_sec = secs, tv -> tv_usec = 0;
    else
	tv = ((void *)0);

    if (rfds)
	ifds = *rfds;
    if (wfds)
	ofds = *wfds;
    if (efds)
	xfds = *efds;
    for (;;) {
	switch (n = select (nfds, rfds, wfds, efds, tv)) {
	    case 0: 
		if (secs == (-1))
		    break;
		return 0;

	    case (-1):
		if (xselect_blocking_on_intr
			&& errno == 4
		        && secs == (-1))
		    continue;
		 
		    
	    default: 
		return n;
	}

	if (rfds)
	    *rfds = ifds;
	if (wfds)
	    *wfds = ofds;
	if (efds)
	    *efds = xfds;
    }
}

 


 

 

static IFP	sfnx[(sizeof (fd_set) * 8)] = { ((void *)0) };
static caddr_t	sdata[(sizeof (fd_set) * 8)] = { ((void *)0) };


IFP	set_check_fd (fd, fnx, data)
int	fd;
IFP	fnx;
caddr_t	data;
{
    IFP	    ofnx;

    if (fd < 0 || fd >= (sizeof (fd_set) * 8))
	return ((IFP) 0);

    ofnx = sfnx[fd];
    sfnx[fd] = fnx, sdata[fd] = data;

    return ofnx;
}

 

int	xselect (nfds, rfds, wfds, efds, secs)
int	nfds;
fd_set *rfds,
       *wfds,
       *efds;
int	secs;
{
    register int    fd;
    int	    n;
    fd_set  ifds,
	    ofds,
	    xfds;
    static int nsysfds = (-1);

    if (nsysfds == (-1))
	nsysfds = 2000;
    if (nfds > (sizeof (fd_set) * 8))
	nfds = (sizeof (fd_set) * 8);
    if (nfds > nsysfds + 1)
	nfds = nsysfds + 1;

    bzero((char *)(&ifds), sizeof(*(&ifds)));
    n = 0;

    for (fd = 0; fd < nfds; fd++)
	if (sfnx[fd] != ((IFP) 0)
	        && rfds
	        && ((rfds)->fds_bits[(fd)/(sizeof(fd_mask) * 8)] & (1 << ((fd) % (sizeof(fd_mask) * 8))))
		&& (*sfnx[fd]) (fd, sdata[fd]) == 1) {
	    ((&ifds)->fds_bits[(fd)/(sizeof(fd_mask) * 8)] |= (1 << ((fd) % (sizeof(fd_mask) * 8))));
	    n++;
	}

    if (n > 0) {
	*rfds = ifds;	 
	if (wfds)
	    bzero((char *)(wfds), sizeof(*(wfds)));
	if (efds)
	    bzero((char *)(efds), sizeof(*(efds)));
	
	return n;
    }

    if (rfds)
	ifds = *rfds;	 
    if (wfds)
	ofds = *wfds;	 
    if (efds)
	xfds = *efds;	 

    if ((n = selsocket (nfds, rfds, wfds, efds, secs)) != (-1))
	return n;

    if (errno == 9) {
	struct stat st;

	if (rfds)
	    bzero((char *)(rfds), sizeof(*(rfds)));
	if (wfds)
	    bzero((char *)(wfds), sizeof(*(wfds)));
	if (efds)
	    bzero((char *)(efds), sizeof(*(efds)));

	n = 0;
	for (fd = 0; fd < nfds; fd++)
	    if (((rfds && ((&ifds)->fds_bits[(fd)/(sizeof(fd_mask) * 8)] & (1 << ((fd) % (sizeof(fd_mask) * 8)))))
			|| (wfds && ((&ofds)->fds_bits[(fd)/(sizeof(fd_mask) * 8)] & (1 << ((fd) % (sizeof(fd_mask) * 8)))))
			|| (efds && ((&xfds)->fds_bits[(fd)/(sizeof(fd_mask) * 8)] & (1 << ((fd) % (sizeof(fd_mask) * 8))))))
		    && fstat (fd, &st) == (-1)) {
		if (rfds && ((&ifds)->fds_bits[(fd)/(sizeof(fd_mask) * 8)] & (1 << ((fd) % (sizeof(fd_mask) * 8)))))
		    ((rfds)->fds_bits[(fd)/(sizeof(fd_mask) * 8)] |= (1 << ((fd) % (sizeof(fd_mask) * 8))));
		if (wfds && ((&ofds)->fds_bits[(fd)/(sizeof(fd_mask) * 8)] & (1 << ((fd) % (sizeof(fd_mask) * 8)))))
		    ((wfds)->fds_bits[(fd)/(sizeof(fd_mask) * 8)] |= (1 << ((fd) % (sizeof(fd_mask) * 8))));
		if (efds && ((&xfds)->fds_bits[(fd)/(sizeof(fd_mask) * 8)] & (1 << ((fd) % (sizeof(fd_mask) * 8)))))
		    ((efds)->fds_bits[(fd)/(sizeof(fd_mask) * 8)] |= (1 << ((fd) % (sizeof(fd_mask) * 8))));

		if (compat_log -> ll_events & (0x02)) { (void) ll_log (compat_log, 0x02, "", "%s", ll_preset ("fd %d has gone bad", fd)); } else;
		n++;
	    }

	if (n)
	    return n;

	errno = 9;
    }

    return (-1);
}