Return to llib-lcompat CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / compat

Annotation of 43BSDReno/contrib/isode-beta/compat/llib-lcompat, revision 1.1

1.1     ! root        1: /* llib-licompat - lint library for -licompat */
        !             2: 
        !             3: /* 
        !             4:  * $Header: /f/osi/compat/RCS/llib-lcompat,v 7.4 90/02/19 13:07:13 mrose Exp $
        !             5:  *
        !             6:  *
        !             7:  * $Log:       llib-lcompat,v $
        !             8:  * Revision 7.4  90/02/19  13:07:13  mrose
        !             9:  * update
        !            10:  * 
        !            11:  * Revision 7.3  90/01/11  18:35:13  mrose
        !            12:  * real-sync
        !            13:  * 
        !            14:  * Revision 7.2  89/12/19  16:17:55  mrose
        !            15:  * dgram
        !            16:  * 
        !            17:  * Revision 7.1  89/11/30  23:53:14  mrose
        !            18:  * pa2str
        !            19:  * 
        !            20:  * Revision 7.0  89/11/23  21:23:14  mrose
        !            21:  * Release 6.0
        !            22:  * 
        !            23:  */
        !            24: 
        !            25: /*
        !            26:  *                               NOTICE
        !            27:  *
        !            28:  *    Acquisition, use, and distribution of this module and related
        !            29:  *    materials are subject to the restrictions of a license agreement.
        !            30:  *    Consult the Preface in the User's Manual for the full terms of
        !            31:  *    this agreement.
        !            32:  *
        !            33:  */
        !            34: 
        !            35: 
        !            36: /* LINTLIBRARY */
        !            37: 
        !            38: #include <varargs.h>
        !            39: #include "manifest.h"
        !            40: #include "general.h"
        !            41: #include "isoaddrs.h"
        !            42: #include "isoservent.h"
        !            43: #include "logger.h"
        !            44: #ifdef TCP
        !            45: #include "internet.h"
        !            46: #endif
        !            47: #ifdef X25
        !            48: #include "x25.h"
        !            49: #endif
        !            50: #ifdef TP4
        !            51: #include "tp4.h"
        !            52: #endif
        !            53: 
        !            54: /*  */
        !            55: 
        !            56: /*    EMULATION */
        !            57: 
        !            58: #ifdef SYS5
        !            59: int    dup2 (d1, d2)
        !            60: int    d1,
        !            61:        d2;
        !            62: {
        !            63:     return dup2 (d1, d2);
        !            64: }
        !            65: #endif
        !            66: 
        !            67: 
        !            68: #ifndef        SWABLIB
        !            69: #undef ntohs
        !            70: u_short        ntohs (netshort) u_short netshort; { return ntohs (netshort); }
        !            71: 
        !            72: #undef htons
        !            73: u_short        htons (hostshort) u_short hostshort; { return htons (hostshort); }
        !            74: 
        !            75: #undef ntohl
        !            76: u_long ntohl (netlong) u_long netlong; { return ntohl (netlong); }
        !            77: 
        !            78: #undef htonl
        !            79: u_long htonl (hostlong) u_long hostlong; { return htonl (hostlong); }
        !            80: #endif
        !            81: 
        !            82: 
        !            83: int    ll_open (lp)
        !            84: LLog   *lp;
        !            85: {
        !            86:     return ll_open (lp);
        !            87: }
        !            88: 
        !            89: 
        !            90: int    ll_close (lp)
        !            91: LLog   *lp;
        !            92: {
        !            93:     return ll_close (lp);
        !            94: }
        !            95: 
        !            96: 
        !            97: /* VARARGS4 */
        !            98: 
        !            99: int    ll_log (lp, event, what, fmt)
        !           100: LLog   *lp;
        !           101: int    event;
        !           102: char   *what,
        !           103:        *fmt;
        !           104: {
        !           105:     return ll_log (lp, event, what, fmt);
        !           106: }
        !           107: 
        !           108: 
        !           109: int    _ll_log (lp, event, ap)
        !           110: LLog   *lp;
        !           111: int    event;
        !           112: va_list ap;
        !           113: {
        !           114:     return _ll_log (lp, event, ap);
        !           115: }
        !           116: 
        !           117: 
        !           118: void   ll_hdinit (lp, prefix)
        !           119: LLog   *lp;
        !           120: char   *prefix;
        !           121: {
        !           122:     ll_hdinit (lp, prefix);
        !           123: }
        !           124: 
        !           125: 
        !           126: void   ll_dbinit (lp, prefix)
        !           127: LLog   *lp;
        !           128: char   *prefix;
        !           129: {
        !           130:     ll_dbinit (lp, prefix);
        !           131: }
        !           132: 
        !           133: 
        !           134: /* VARARGS2 */
        !           135: 
        !           136: int    ll_printf (lp, fmt)
        !           137: LLog   *lp;
        !           138: char   *fmt;
        !           139: {
        !           140:     return ll_printf (lp, fmt);
        !           141: }
        !           142: 
        !           143: 
        !           144: int    ll_sync (lp)
        !           145: LLog   *lp;
        !           146: {
        !           147:     return ll_sync (lp);
        !           148: }
        !           149: 
        !           150: 
        !           151: /* VARARGS1 */
        !           152: 
        !           153: char   *ll_preset (fmt)
        !           154: char   *fmt;
        !           155: {
        !           156:     return ll_preset (fmt);
        !           157: }
        !           158: 
        !           159: 
        !           160: int    ll_check (lp)
        !           161: LLog   *lp;
        !           162: {
        !           163:     return ll_check (lp);
        !           164: }
        !           165: 
        !           166: 
        !           167: int    selsocket (nfds, rfds, wfds, efds, secs)
        !           168: int    nfds;
        !           169: fd_set *rfds,
        !           170:        *wfds,
        !           171:        *efds;
        !           172: int    secs;
        !           173: {
        !           174:     return selsocket (nfds, rfds, wfds, efds, secs);
        !           175: }
        !           176: 
        !           177: 
        !           178: IFP    set_select_fd (fd, fnx)
        !           179: int    fd;
        !           180: IFP    fnx;
        !           181: {
        !           182:     return set_select_fd (fd, fnx);
        !           183: }
        !           184: 
        !           185: 
        !           186: int    xselect (nfds, rfds, wfds, efds, secs)
        !           187: int    nfds;
        !           188: fd_set *rfds,
        !           189:        *wfds,
        !           190:        *efds;
        !           191: int    secs;
        !           192: {
        !           193:     return xselect (nfds, rfds, wfds, efds, secs);
        !           194: }
        !           195: 
        !           196: 
        !           197: #ifdef BSDSIGS
        !           198: #ifdef AIX
        !           199: IFP    signal (sig, func)
        !           200: int    sig;
        !           201: IFP    func;
        !           202: {
        !           203:     return signal (sig, func);
        !           204: }
        !           205: #endif
        !           206: #else
        !           207: int    sigblock (mask)
        !           208: int    mask;
        !           209: {
        !           210:     return sigblock (mask);
        !           211: }
        !           212: 
        !           213: int    sigsetmask (mask)
        !           214: int    mask;
        !           215: {
        !           216:     return sigsetmask (mask);
        !           217: }
        !           218: #endif
        !           219: 
        !           220: /*    UTILITY */
        !           221: 
        !           222: void   asprintf (bp, ap)
        !           223: char   *bp;
        !           224: va_list        ap;
        !           225: {
        !           226:     asprintf (bp, ap);
        !           227: }
        !           228: 
        !           229: 
        !           230: void   _asprintf (bp, what, ap)
        !           231: char   *bp,
        !           232:        *what;
        !           233: va_list        ap;
        !           234: {
        !           235:     _asprintf (bp, what, ap);
        !           236: }
        !           237: 
        !           238: 
        !           239: int    expode (a, b, n)
        !           240: char   *a;
        !           241: u_char *b;
        !           242: int    n;
        !           243: {
        !           244:     return explode (a, b, n);
        !           245: }
        !           246: 
        !           247: 
        !           248: int    implode (a, b, n)
        !           249: u_char *a;
        !           250: char   *b;
        !           251: int    n;
        !           252: {
        !           253:     return implode (a, b, n);
        !           254: }
        !           255: 
        !           256: 
        !           257: char   *_isodefile (path, file)
        !           258: char   *path,
        !           259:        *file;
        !           260: {
        !           261:     return _isodefile (path, file);
        !           262: }
        !           263: 
        !           264: 
        !           265: char   *getlocalhost ()
        !           266: {
        !           267:     return getlocalhost ();
        !           268: }
        !           269: 
        !           270: 
        !           271: char   *sel2str (sel, len, quoted)
        !           272: char   *sel;
        !           273: int    len,
        !           274:        quoted;
        !           275: {
        !           276:     return sel2str (sel, len, quoted);
        !           277: }
        !           278: 
        !           279: 
        !           280: char   *sys_errname (i)
        !           281: int    i;
        !           282: {
        !           283:     return sys_errname (i);
        !           284: }
        !           285: 
        !           286: 
        !           287: char  *sprintb (v, bits)
        !           288: int    v;
        !           289: char   *bits;
        !           290: {
        !           291:     return sprintb (v, bits);
        !           292: }
        !           293: 
        !           294: 
        !           295: int    str2elem (s, elements)
        !           296: char   *s;
        !           297: unsigned int elements[];
        !           298: {
        !           299:     return str2elem (s, elements);
        !           300: }
        !           301: 
        !           302: 
        !           303: int    str2sel (s, quoted, sel, n)
        !           304: char   *s,
        !           305:        *sel;
        !           306: int    quoted,
        !           307:        n;
        !           308: {
        !           309:     return str2sel (s, quoted, sel, n);
        !           310: }
        !           311: 
        !           312: 
        !           313: int    str2vecX (s, vec, nmask, mask, brk)
        !           314: char   *s,
        !           315:       **vec,
        !           316:        brk;
        !           317: int    nmask,
        !           318:        *mask;
        !           319: {
        !           320:     return str2vecX (s, vec, nmask, mask, brk);
        !           321: }
        !           322: 
        !           323: 
        !           324: char   *getpassword (prompt)
        !           325: char   *prompt;
        !           326: {
        !           327:     return getpassword (prompt);
        !           328: }
        !           329: 
        !           330: 
        !           331: int    baduser (file, user)
        !           332: char   *file,
        !           333:        *user;
        !           334: {
        !           335:     return baduser (file, user);
        !           336: }
        !           337: 
        !           338: 
        !           339: int    setenv (name, value)
        !           340: char   *name,
        !           341:        *value;
        !           342: {
        !           343:     return setenv (name, value);
        !           344: }
        !           345: 
        !           346: 
        !           347: int    unsetenv (name)
        !           348: char   *name;
        !           349: {
        !           350:     unsetenv (name);
        !           351: }
        !           352: 
        !           353: 
        !           354: #include "cmd_srch.h"
        !           355: 
        !           356: int    cmd_src (str, cmd)
        !           357: char   *str;
        !           358: CMD_TABLE *cmd;
        !           359: {
        !           360:     return cmd_src (str, cmd);
        !           361: }
        !           362: 
        !           363: 
        !           364: int    lexequ (str1, str2)
        !           365: char   *str1,
        !           366:        *str2;
        !           367: {
        !           368:     return lexequ (str1, str2);
        !           369: }
        !           370: 
        !           371: 
        !           372: int    lexnequ (str1, str2, len)
        !           373: char   *str1,
        !           374:        *str2;
        !           375: int    len;
        !           376: {
        !           377:     return lexnequ (str1, str2, len);
        !           378: }
        !           379: 
        !           380: 
        !           381: int    log_tai (lgptr, av, ac)
        !           382: LLog   *lgptr;
        !           383: char  **av;
        !           384: int    ac;
        !           385: {
        !           386:     log_tai (lgptr, av, ac);
        !           387: }
        !           388: 
        !           389: 
        !           390: char   *rcmd_srch (val, cmd)
        !           391: int    val;
        !           392: CMD_TABLE *cmd;
        !           393: {
        !           394:     return rcmd_srch (val, cmd);
        !           395: }
        !           396: 
        !           397: 
        !           398: char   *strdup (str)
        !           399: char   *str;
        !           400: {
        !           401:     return strdup (str);
        !           402: }
        !           403: 
        !           404: 
        !           405: int    sstr2arg (srcptr, maxpf, argv, dlmstr)
        !           406: char   *srcptr;
        !           407: int    maxpf;
        !           408: char   *argv[],
        !           409:        *dlmstr;
        !           410: {
        !           411:     return sstr2arg (srcptr, maxpf, argv, dlmstr);
        !           412: }
        !           413: 
        !           414: 
        !           415: char   *smalloc (size)
        !           416: int    size;
        !           417: {
        !           418:     return smalloc (size);
        !           419: }
        !           420: 
        !           421: 
        !           422: char   *isodesetailor (file)
        !           423: char   *file;
        !           424: {
        !           425:     return isodesetailor (file);
        !           426: }
        !           427: 
        !           428: 
        !           429: void   isodetailor (myname, wantuser)
        !           430: char   *myname;
        !           431: int    wantuser;
        !           432: {
        !           433:     isodetailor (myname, wantuser);
        !           434: }
        !           435: 
        !           436: int    isodesetvar (name, value, dynamic)
        !           437: char   *name,
        !           438:        *value;
        !           439: int    dynamic;
        !           440: {
        !           441:     return isodesetvar (name, value, dynamic);
        !           442: }
        !           443: 
        !           444: 
        !           445: void   isodexport (myname)
        !           446: char   *myname;
        !           447: {
        !           448:     isodexport (myname);
        !           449: }
        !           450: 
        !           451: 
        !           452: /*    ISOSERVENT */
        !           453: 
        !           454: int     setisoservent (f)
        !           455: int     f;
        !           456: {
        !           457:     return setisoservent (f);
        !           458: }
        !           459: 
        !           460: 
        !           461: int     endisoservent () {
        !           462:     return endisoservent ();
        !           463: }
        !           464: 
        !           465: 
        !           466: struct isoservent  *getisoservent () {
        !           467:     return getisoservent ();
        !           468: }
        !           469: 
        !           470: 
        !           471: struct isoservent  *getisoserventbyname (entity, provider)
        !           472: char   *entity,
        !           473:        *provider;
        !           474: {
        !           475:     return getisoserventbyname (entity, provider);
        !           476: }
        !           477: 
        !           478: 
        !           479: struct isoservent  *getisoserventbyselector (provider, selector, selectlen)
        !           480: char   *provider,
        !           481:        *selector;
        !           482: int    selectlen;
        !           483: {
        !           484:     return getisoserventbyselector (provider, selector, selectlen);
        !           485: }
        !           486: 
        !           487: 
        !           488: struct isoservent  *getisoserventbyport (provider, port)
        !           489: char   *provider;
        !           490: unsigned short port;
        !           491: {
        !           492:     return getisoserventbyport (provider, port);
        !           493: }
        !           494: 
        !           495: /*    NETWORK */
        !           496: 
        !           497: struct PSAPaddr *str2paddr (str)
        !           498: char   *str;
        !           499: {
        !           500:     return str2paddr (str);
        !           501: }
        !           502: 
        !           503: 
        !           504: struct TSAPaddr *str2taddr (str)
        !           505: char   *str;
        !           506: {
        !           507:     return str2taddr (str);
        !           508: }
        !           509: 
        !           510: 
        !           511: char   *_paddr2str (pa, na, compact)
        !           512: struct PSAPaddr *pa;
        !           513: struct NSAPaddr *na;
        !           514: int    compact;
        !           515: {
        !           516:     return _paddr2str (pa, na, compact);
        !           517: }
        !           518: 
        !           519: 
        !           520: char   *saddr2str (sa)
        !           521: struct SSAPaddr *sa;
        !           522: {
        !           523:     return saddr2str (sa);
        !           524: }
        !           525: 
        !           526: 
        !           527: char   *taddr2str (ta)
        !           528: struct TSAPaddr *ta;
        !           529: {
        !           530:     return taddr2str (ta);
        !           531: }
        !           532: 
        !           533: 
        !           534: struct NSAPaddr *na2norm (na)
        !           535: struct NSAPaddr *na;
        !           536: {
        !           537:     return na2norm (na);
        !           538: }
        !           539: 
        !           540: 
        !           541: char   *na2str (na)
        !           542: struct NSAPaddr *na;
        !           543: {
        !           544:     return na2str (na);
        !           545: }
        !           546: 
        !           547: 
        !           548: char   *pa2str (pa)
        !           549: struct PSAPaddr *pa;
        !           550: {
        !           551:     return pa2str (pa);
        !           552: }
        !           553: 
        !           554: /*    TCP */
        !           555: 
        !           556: #ifdef TCP
        !           557: 
        !           558: int    start_tcp_client (sock, priv)
        !           559: struct sockaddr_in *sock;
        !           560: int    priv;
        !           561: {
        !           562:     return start_tcp_client (sock, priv);
        !           563: }
        !           564: 
        !           565: 
        !           566: int    start_tcp_server (sock, backlog, opt1, opt2)
        !           567: struct sockaddr_in *sock;
        !           568: int    backlog,
        !           569:        opt1,
        !           570:        opt2;
        !           571: {
        !           572:     return start_tcp_server (sock, backlog, opt1, opt2);
        !           573: }
        !           574: 
        !           575: 
        !           576: #ifndef        join_tcp_client
        !           577: int    join_tcp_client (fd, sock)
        !           578: int    fd;
        !           579: struct sockaddr_in *sock;
        !           580: {
        !           581:     return join_tcp_client (fd, sock);
        !           582: }
        !           583: #endif
        !           584: 
        !           585: 
        !           586: struct hostent *gethostbystring (s)
        !           587: char   *s;
        !           588: {
        !           589:     return gethostbystring (s);
        !           590: }
        !           591: 
        !           592: 
        !           593: #ifdef EXOS
        !           594: struct hostent *gethostbyaddr (addr, len, type)
        !           595: char   *addr;
        !           596: int    len,
        !           597:        type;
        !           598: {
        !           599:     return gethostbyaddr (addr, len, type);
        !           600: }
        !           601: 
        !           602: 
        !           603: struct hostent *gethostbyname (name)
        !           604: char   *name;
        !           605: {
        !           606:     return gethostbyname (name);
        !           607: }
        !           608: 
        !           609: 
        !           610: struct servent *getservbyname (name, proto)
        !           611: char   *name,
        !           612:        *proto;
        !           613: {
        !           614:     return getservbyname (name, proto);
        !           615: }
        !           616: 
        !           617: 
        !           618: char   *inet_ntoa (in)
        !           619: struct in_addr in;
        !           620: {
        !           621:     return inet_ntoa (in);
        !           622: }
        !           623: 
        !           624: 
        !           625: u_long inet_addr (cp)
        !           626: char   *cp;
        !           627: {
        !           628:     return inet_addr (cp);
        !           629: }
        !           630: #endif
        !           631: 
        !           632: #endif
        !           633: 
        !           634: /*    DGRAM */
        !           635: 
        !           636: #if    defined(SOCKETS) && (defined(TCP) || defined(CLTS))
        !           637: 
        !           638: #ifdef TCP
        !           639: int    start_udp_server (sock, backlog, opt1, opt2)
        !           640: struct sockaddr_in *sock;
        !           641: int    backlog,
        !           642:        opt1,
        !           643:        opt2;
        !           644: {
        !           645:     return start_udp_server (sock, backlog, opt1, opt2);
        !           646: }
        !           647: #endif
        !           648: 
        !           649: 
        !           650: #ifdef CLTS
        !           651: int    start_clts_server (sock, backlog, opt1, opt2)
        !           652: union sockaddr_osi *sock;
        !           653: int    backlog,
        !           654:        opt1,
        !           655:        opt2;
        !           656: {
        !           657:     return start_clts_server (sock, backlog, opt1, opt2);
        !           658: }
        !           659: #endif
        !           660: 
        !           661: 
        !           662: int    join_dgram_aux (fd, sock, newfd)
        !           663: int    fd,
        !           664:        newfd;
        !           665: struct sockaddr *sock;
        !           666: {
        !           667:     return join_dgram_aux (fd, sock, newfd);
        !           668: }
        !           669: 
        !           670: 
        !           671: int    read_dgram_socket (fd, qb)
        !           672: int    fd;
        !           673: struct qbuf **qb;
        !           674: {
        !           675:     return read_dgram_socket (fd, qb);
        !           676: }
        !           677: 
        !           678: 
        !           679: int    hack_dgram_socket (fd, sock)
        !           680: int    fd;
        !           681: struct sockaddr *sock;
        !           682: {
        !           683:     return hack_dgram_socket (fd, sock);
        !           684: }
        !           685: 
        !           686: 
        !           687: int    write_dgram_socket (fd, qb)
        !           688: int    fd;
        !           689: struct qbuf *qb;
        !           690: {
        !           691:     return write_dgram_socket (fd, qb);
        !           692: }
        !           693: 
        !           694: 
        !           695: int    close_dgram_socket (fd)
        !           696: int    fd;
        !           697: {
        !           698:     return close_dgram_socket (fd);
        !           699: }
        !           700: 
        !           701: 
        !           702: int    select_dgram_socket (nfds, rfds, wfds, efds, secs)
        !           703: int    nfds;
        !           704: fd_set *rfds,
        !           705:        *wfds,
        !           706:        *efds;
        !           707: int    secs;
        !           708: {
        !           709:     return select_dgram_socket (nfds, rfds, wfds, efds, secs);
        !           710: }
        !           711: #endif
        !           712: 
        !           713: /*    X.25 */
        !           714: 
        !           715: #ifdef X25
        !           716: CONN_DB *gen2if (generic, specific, context)
        !           717: struct NSAPaddr *generic;
        !           718: CONN_DB *specific;
        !           719: int    context;
        !           720: {
        !           721:     return gen2if (generic, specific, context);
        !           722: }
        !           723: 
        !           724: 
        !           725: struct NSAPaddr *if2gen (generic, specific, context)
        !           726: struct NSAPaddr *generic;
        !           727: CONN_DB *specific;
        !           728: int    context;
        !           729: {
        !           730:     return if2gen (generic, specific, context);
        !           731: }
        !           732: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.