⟦4a67542c8⟧

TextFile

/* llib-lcompat - lint library for -lcompat */

/* 
 * $Header: /f/osi/compat/RCS/llib-lcompat,v 6.0 89/03/18 23:25:21 mrose Rel $
 *
 *
 * $Log:	llib-lcompat,v $
 * Revision 6.0  89/03/18  23:25:21  mrose
 * Release 5.0
 * 
 */

/*
 *				  NOTICE
 *
 *    Acquisition, use, and distribution of this module and related
 *    materials are subject to the restrictions of a license agreement.
 *    Consult the Preface in the User's Manual for the full terms of
 *    this agreement.
 *
 */


/* LINTLIBRARY */

#include <varargs.h>
#include "manifest.h"
#include "general.h"
#include "isoaddrs.h"
#include "isoservent.h"
#include "logger.h"
#ifdef	TCP
#include "internet.h"
#endif
#ifdef	X25
#include "x25.h"
#endif

/* \f

 */

/* \f

   EMULATION */

#ifdef	SYS5
int	dup2 (d1, d2)
int	d1,
	d2;
{
    return dup2 (d1, d2);
}
#endif


#ifndef	SWABLIB
#undef	ntohs
u_short	ntohs (netshort) u_short netshort; { return ntohs (netshort); }

#undef	htons
u_short	htons (hostshort) u_short hostshort; { return htons (hostshort); }

#undef	ntohl
u_long	ntohl (netlong) u_long netlong; { return ntohl (netlong); }

#undef	htonl
u_long	htonl (hostlong) u_long hostlong; { return htonl (hostlong); }
#endif


int	ll_open (lp)
LLog   *lp;
{
    return ll_open (lp);
}


int	ll_close (lp)
LLog   *lp;
{
    return ll_close (lp);
}


/* VARARGS4 */

int	ll_log (lp, event, what, fmt)
LLog   *lp;
int	event;
char   *what,
       *fmt;
{
    return ll_log (lp, event, what, fmt);
}


int	_ll_log (lp, event, ap)
LLog   *lp;
int	event;
va_list ap;
{
    return _ll_log (lp, event, ap);
}


void	ll_hdinit (lp, prefix)
LLog   *lp;
char   *prefix;
{
    ll_hdinit (lp, prefix);
}


void	ll_dbinit (lp, prefix)
LLog   *lp;
char   *prefix;
{
    ll_dbinit (lp, prefix);
}


/* VARARGS2 */

int	ll_printf (lp, fmt)
LLog   *lp;
char   *fmt;
{
    return ll_printf (lp, fmt);
}


int	ll_sync (lp)
LLog   *lp;
{
    return ll_sync (lp);
}


/* VARARGS1 */

char   *ll_preset (fmt)
char   *fmt;
{
    return ll_preset (fmt);
}


int	ll_check (lp)
LLog   *lp;
{
    return ll_check (lp);
}


int	selsocket (nfds, rfds, wfds, efds, secs)
int	nfds;
fd_set *rfds,
       *wfds,
       *efds;
int	secs;
{
    return selsocket (nfds, rfds, wfds, efds, secs);
}


IFP	set_select_fd (fd, fnx)
int	fd;
IFP	fnx;
{
    return set_select_fd (fd, fnx);
}


int	xselect (nfds, rfds, wfds, efds, secs)
int	nfds;
fd_set *rfds,
       *wfds,
       *efds;
int	secs;
{
    return xselect (nfds, rfds, wfds, efds, secs);
}


#ifdef	BSDSIGS
#ifdef	AIX
IFP	signal (sig, func)
int	sig;
IFP	func;
{
    return signal (sig, func);
}
#endif
#else
int	sigblock (mask)
int	mask;
{
    return sigblock (mask);
}

int	sigsetmask (mask)
int	mask;
{
    return sigsetmask (mask);
}
#endif

/* \f

   UTILITY */

void	asprintf (bp, ap)
char   *bp;
va_list	ap;
{
    asprintf (bp, ap);
}


void	_asprintf (bp, what, ap)
char   *bp,
       *what;
va_list	ap;
{
    _asprintf (bp, what, ap);
}


int	expode (a, b, n)
char   *a;
u_char *b;
int	n;
{
    return explode (a, b, n);
}


int	implode (a, b, n)
u_char *a;
char   *b;
int	n;
{
    return implode (a, b, n);
}


char   *_isodefile (path, file)
char   *path,
       *file;
{
    return _isodefile (path, file);
}


char   *getlocalhost ()
{
    return getlocalhost ();
}


char   *sel2str (sel, len, quoted)
char   *sel;
int	len,
	quoted;
{
    return sel2str (sel, len, quoted);
}


char   *sys_errname (i)
int	i;
{
    return sys_errname (i);
}


char  *sprintb (v, bits)
int	v;
char   *bits;
{
    return sprintb (v, bits);
}


int	str2elem (s, elements)
char   *s;
unsigned int elements[];
{
    return str2elem (s, elements);
}


int	str2sel (s, quoted, sel, n)
char   *s,
       *sel;
int	quoted,
	n;
{
    return str2sel (s, quoted, sel, n);
}


int	str2vecX (s, vec, nmask, mask, brk)
char   *s,
      **vec,
    	brk;
int	nmask,
       *mask;
{
    return str2vecX (s, vec, nmask, mask, brk);
}


char   *getpassword (prompt)
char   *prompt;
{
    return getpassword (prompt);
}


int	baduser (file, user)
char   *file,
       *user;
{
    return baduser (file, user);
}


#include "cmd_srch.h"

int	cmd_src (str, cmd)
char   *str;
CMD_TABLE *cmd;
{
    return cmd_src (str, cmd);
}


int	lexequ (str1, str2)
char   *str1,
       *str2;
{
    return lexequ (str1, str2);
}


int	lexnequ (str1, str2, len)
char   *str1,
       *str2;
int	len;
{
    return lexnequ (str1, str2, len);
}


int	log_tai (lgptr, av, ac)
LLog   *lgptr;
char  **av;
int	ac;
{
    log_tai (lgptr, av, ac);
}


char   *rcmd_srch (val, cmd)
int	val;
CMD_TABLE *cmd;
{
    return rcmd_srch (val, cmd);
}


char   *strdup (str)
char   *str;
{
    return strdup (str);
}


int	sstr2arg (srcptr, maxpf, argv, dlmstr)
char   *srcptr;
int	maxpf;
char   *argv[],
       *dlmstr;
{
    return sstr2arg (srcptr, maxpf, argv, dlmstr);
}


char   *smalloc (size)
int	size;
{
    return smalloc (size);
}


char   *isodesetailor (file)
char   *file;
{
    return isodesetailor (file);
}


void	isodetailor (myname, wantuser)
char   *myname;
int	wantuser;
{
    isodetailor (myname, wantuser);
}

int	isodesetvar (name, value, dynamic)
char   *name,
       *value;
int	dynamic;
{
    return isodesetvar (name, value, dynamic);
}


void	isodexport ()
{
    isodexport ();
}


/* \f

   ISOSERVENT */

int     setisoservent (f)
int     f;
{
    return setisoservent (f);
}


int     endisoservent () {
    return endisoservent ();
}


struct isoservent  *getisoservent () {
    return getisoservent ();
}


struct isoservent  *getisoserventbyname (entity, provider)
char   *entity,
       *provider;
{
    return getisoserventbyname (entity, provider);
}


struct isoservent  *getisoserventbyselector (provider, selector, selectlen)
char   *provider,
       *selector;
int	selectlen;
{
    return getisoserventbyselector (provider, selector, selectlen);
}


struct isoservent  *getisoserventbyport (provider, port)
char   *provider;
unsigned short port;
{
    return getisoserventbyport (provider, port);
}

/* \f

   NETWORK */

struct PSAPaddr *str2paddr (str)
char   *str;
{
    return str2paddr (str);
}


struct TSAPaddr *str2taddr (str)
char   *str;
{
    return str2taddr (str);
}


char   *_paddr2str (pa, na, compact)
struct PSAPaddr *pa;
struct NSAPaddr *na;
int	compact;
{
    return _paddr2str (pa, na, compact);
}


char   *saddr2str (sa)
struct SSAPaddr *sa;
{
    return saddr2str (sa);
}


char   *taddr2str (ta)
struct TSAPaddr *ta;
{
    return taddr2str (ta);
}


struct NSAPaddr *na2norm (na)
struct NSAPaddr *na;
{
    return na2norm (na);
}


char   *na2str (na)
struct NSAPaddr *na;
{
    return na2str (na);
}

/* \f

   TCP */

#ifdef	TCP

int	start_tcp_client (sock, priv)
struct sockaddr_in *sock;
int	priv;
{
    return start_tcp_client (sock, priv);
}


int	start_tcp_server (sock, backlog, opt1, opt2)
struct sockaddr_in *sock;
int	backlog,
    	opt1,
    	opt2;
{
    return start_tcp_server (sock, backlog, opt1, opt2);
}


#ifndef	join_tcp_client
int	join_tcp_client (fd, sock)
int	fd;
struct sockaddr_in *sock;
{
    return join_tcp_client (fd, sock);
}
#endif


int	start_udp_server (sock, backlog, opt1, opt2)
struct sockaddr_in *sock;
int	backlog,
	opt1,
	opt2;
{
    return start_udp_server (sock, backlog, opt1, opt2);
}


int	join_udp_aux (fd, sock, newfd)
int	fd,
	newfd;
struct sockaddr_in *sock;
{
    return join_udp_aux (fd, sock, newfd);
}


int	read_udp_socket (fd, qb)
int	fd;
struct qbuf **qb;
{
    return read_udp_socket (fd, qb);
}


int	write_udp_socket (fd, qb)
int	fd;
struct qbuf *qb;
{
    return write_udp_socket (fd, qb);
}


int	close_udp_socket (fd)
int	fd;
{
    return close_udp_socket (fd);
}


int	select_udp_socket (nfds, rfds, wfds, efds, secs)
int	nfds;
fd_set *rfds,
       *wfds,
       *efds;
int	secs;
{
    return select_udp_socket (nfds, rfds, wfds, efds, secs);
}


struct hostent *gethostbystring (s)
char   *s;
{
    return gethostbystring (s);
}


#ifdef	EXOS
struct hostent *gethostbyaddr (addr, len, type)
char   *addr;
int	len,
	type;
{
    return gethostbyaddr (addr, len, type);
}


struct hostent *gethostbyname (name)
char   *name;
{
    return gethostbyname (name);
}


struct servent *getservbyname (name, proto)
char   *name,
       *proto;
{
    return getservbyname (name, proto);
}


char   *inet_ntoa (in)
struct in_addr in;
{
    return inet_ntoa (in);
}


u_long	inet_addr (cp)
char   *cp;
{
    return inet_addr (cp);
}
#endif

#endif

/* \f

   X.25 */

#ifdef	X25
CONN_DB *gen2if (generic, specific, context)
struct NSAPaddr *generic;
CONN_DB *specific;
int	context;
{
    return gen2if (generic, specific, context);
}


struct NSAPaddr *if2gen (generic, specific, context)
struct NSAPaddr *generic;
CONN_DB *specific;
int	context;
{
    return if2gen (generic, specific, context);
}
#endif
DataMuseum.dk

DKUUG/EUUG Conference tapes

⟦4a67542c8⟧ TextFile

Derivation

TextFile
