![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to llib-lcompat CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / compat|
Return to llib-lcompat CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / compat |
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.