![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to access.c 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 / others / X / server|
Return to access.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / X / server |
1.1 root 1: /***********************************************************
2: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
3: and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
4:
5: All Rights Reserved
6:
7: Permission to use, copy, modify, and distribute this software and its
8: documentation for any purpose and without fee is hereby granted,
9: provided that the above copyright notice appear in all copies and that
10: both that copyright notice and this permission notice appear in
11: supporting documentation, and that the names of Digital or MIT not be
12: used in advertising or publicity pertaining to distribution of the
13: software without specific, written prior permission.
14:
15: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
16: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
17: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
18: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
19: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
20: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
21: SOFTWARE.
22:
23: ******************************************************************/
24:
25: /* $XConsortium: access.c,v 1.26 88/09/06 15:51:03 jim Exp $ */
26: #ifdef ISOCONN
27: #include <math.h>
28: /*
29: * i'm sorry, i'm sorry
30: *
31: * By Analogy with per host auth, we keep all the TSAPaddr but
32: * do access control on NSAPaddr part only...
33: */
34: #endif /* ISOCONN */
35:
36: #include "X.h"
37: #include "Xproto.h"
38: #include "misc.h"
39: #include "site.h"
40: #include <errno.h>
41: #include <sys/types.h>
42: #include <sys/socket.h>
43: #include <sys/ioctl.h>
44:
45: #ifdef hpux
46: #include <sys/utsname.h>
47: #else
48: #include <net/if.h>
49: #endif /* hpux */
50:
51: #include <netdb.h>
52: #ifdef TCPCONN
53: #include <netinet/in.h>
54: #endif /* TCPCONN */
55: #ifdef DNETCONN
56: #include <netdnet/dn.h>
57: #include <netdnet/dnetdb.h>
58: #endif
59: #ifdef ISOCONN
60: #include <isode/psap.h>
61: #include <isode/tsap.h>
62: #include <isode/isoservent.h>
63: #endif
64: #undef NULL
65: #include <stdio.h>
66: #include "dixstruct.h"
67: #include "osdep.h"
68:
69: #define acmp(a1, a2, len) bcmp((char *)(a1), (char *)(a2), len)
70: #define acopy(a1, a2, len) bcopy((char *)(a1), (char *)(a2), len)
71:
72: #define DONT_CHECK -1
73: extern char *index();
74:
75: typedef struct _host {
76: short family;
77: short len;
78: #ifdef ISOCONN
79: struct TSAPaddr addr; /* and so it is!! */
80: #else /* ISOCONN */
81: unsigned char addr[4]; /* will need to be bigger eventually */
82: #endif /* ISOCONN */
83: struct _host *next;
84: } HOST;
85:
86: static HOST *selfhosts = NULL;
87: static HOST *validhosts = NULL;
88: static int AccessEnabled = DEFAULT_ACCESS_CONTROL;
89:
90: typedef struct {
91: int af, xf;
92: } FamilyMap;
93:
94: static FamilyMap familyMap[] = {
95: #ifdef ISOCONN
96: /*
97: * This has to be visible to the protocol via X.h...
98: */
99: {AF_OSI, FamilyIso},
100: #endif /* ISOCONN */
101: #ifdef AF_DECnet
102: {AF_DECnet, FamilyDECnet},
103: #endif /* AF_DECnet */
104: #ifdef AF_CHAOS
105: {AF_CHAOS, FamilyChaos},
106: #endif /* AF_CHAOS */
107: #ifdef AF_INET
108: {AF_INET, FamilyInternet}
109: #endif
110: };
111:
112: #define FAMILIES ((sizeof familyMap)/(sizeof familyMap[0]))
113:
114: #ifdef hpux
115: /* Define this host for access control. Find all the hosts the OS knows about
116: * for this fd and add them to the selfhosts list.
117: * HPUX version - hpux does not have SIOCGIFCONF ioctl;
118: */
119: DefineSelf (fd)
120: int fd;
121: {
122: register int n;
123: int len;
124: caddr_t addr;
125: int family;
126: register HOST *host;
127:
128: struct utsname name;
129: register struct hostent *hp;
130:
131: union {
132: struct sockaddr sa;
133: struct sockaddr_in in;
134: } saddr;
135:
136: struct sockaddr_in *inetaddr;
137:
138: /* Why not use gethostname()? Well, at least on my system, I've had to
139: * make an ugly kernel patch to get a name longer than 8 characters, and
140: * uname() lets me access to the whole string (it smashes release, you
141: * see), whereas gethostname() kindly truncates it for me.
142: */
143: uname(&name);
144: hp = gethostbyname (name.nodename);
145: if (hp != NULL) {
146: saddr.sa.sa_family = hp->h_addrtype;
147: inetaddr = (struct sockaddr_in *) (&(saddr.sa));
148: acopy ( hp->h_addr, &(inetaddr->sin_addr), hp->h_length);
149: family = ConvertAddr ( &(saddr.sa), &len, &addr);
150: if ( family > 0) {
151: for (host = selfhosts;
152: host && ( family != host->family ||
153: acmp ( addr, host->addr, len));
154: host = host->next) ;
155: if (!host) {
156: /* add this host to the host list. */
157: host = (HOST *) xalloc (sizeof (HOST));
158: host->family = family;
159: host->len = len;
160: acopy ( addr, host->addr, len);
161: host->next = selfhosts;
162: selfhosts = host;
163: }
164: }
165: }
166: }
167:
168: #else
169: /* Define this host for access control. Find all the hosts the OS knows about
170: * for this fd and add them to the selfhosts list.
171: */
172: DefineSelf (fd)
173: int fd;
174: {
175: char buf[2048];
176: struct ifconf ifc;
177: register int n;
178: int len;
179: pointer addr;
180: int family;
181: register HOST *host;
182: register struct ifreq *ifr;
183: #ifdef ISOCONN
184: AEI aei;
185: struct PSAPaddr *pa;
186: #endif /* ISOCONN */
187:
188: #ifdef TCPCONN || UNIXCONN || DNETCONN
189: ifc.ifc_len = sizeof (buf);
190: ifc.ifc_buf = buf;
191: if (ioctl (fd, (int) SIOCGIFCONF, (pointer) &ifc) < 0)
192: Error ("Getting interface configuration");
193: for (ifr = ifc.ifc_req, n = ifc.ifc_len / sizeof (struct ifreq); --n >= 0;
194: ifr++)
195: {
196: #ifdef DNETCONN
197: /*
198: * this is ugly but SIOCGIFCONF returns decnet addresses in
199: * a different form from other decnet calls
200: */
201: if (ifr->ifr_addr.sa_family == AF_DECnet) {
202: len = sizeof (struct dn_naddr);
203: addr = (pointer)ifr->ifr_addr.sa_data;
204: family = AF_DECnet;
205: } else
206: #endif /* DNETCONN */
207: if ((family = ConvertAddr (&ifr->ifr_addr, &len, &addr)) <= 0)
208: continue;
209: for (host = selfhosts; host && (family != host->family ||
210: acmp (addr, host->addr, len)); host = host->next)
211: ;
212: if (host)
213: continue;
214: host = (HOST *) xalloc (sizeof (HOST));
215: host->family = family;
216: host->len = len;
217: acopy(addr, host->addr, len);
218: host->next = selfhosts;
219: selfhosts = host;
220: }
221: #endif TCPCONN
222: #ifdef ISOCONN
223: /*
224: * This is dubious - we should be able to take an fd (transport
225: * descriptor) and get the list of possible transport interfaces...
226: *
227: * Well strictly, for this TSAP, a list of NSAPs that are valid
228: */
229: host = (HOST *)xalloc (sizeof (HOST));
230: host->family = AF_OSI;
231: aei = str2aei(TLocalHostName(), DEFAULTTSERVICE);
232: if (aei == NULLAEI) {
233: Error("Unknown Display\n");
234: return;
235: }
236: if ((pa = aei2addr (aei)) == NULLPA) {
237: fprintf (stderr, "address translation failed");
238: return;
239: }
240: acopy(&(pa->pa_addr.sa_addr), &(host->addr), sizeof(struct TSAPaddr));
241: host->len = NASIZE;
242: host->next = selfhosts;
243: selfhosts = host;
244: #ifdef ISODEBUG
245: if (isodexbug) {
246: int i; char *hp = (char *)&(host->addr);
247: fprintf(stderr, "Self: ");
248: for(i=0; i<host->len; i++)
249: fprintf(stderr, "%x ", (*hp++)&0xff);
250: fprintf(stderr, "\n");
251: }
252: #endif /* ISODEBUG */
253: #endif /* ISOCONN */
254: }
255: #endif hpux
256:
257: /* Reset access control list to initial hosts */
258: ResetHosts (display)
259: char *display;
260: {
261: register HOST *host, *self;
262: char hostname[120];
263: char fname[32];
264: FILE *fd;
265: char *ptr;
266: union {
267: struct sockaddr sa;
268: #ifdef TCPCONN
269: struct sockaddr_in in;
270: #endif /* TCPCONN */
271: #ifdef DNETCONN
272: struct sockaddr_dn dn;
273: #endif
274: #ifdef ISOCONN
275: struct TSAPaddr ta;
276: #endif /* ISOCONN */
277: } saddr;
278: #ifdef DNETCONN
279: struct nodeent *np;
280: struct dn_naddr dnaddr, *dnaddrp, *dnet_addr();
281: #endif
282: int family;
283: int len;
284: pointer addr;
285: register struct hostent *hp;
286:
287: AccessEnabled = DEFAULT_ACCESS_CONTROL;
288: while (host = validhosts)
289: {
290: validhosts = host->next;
291: xfree (host);
292: }
293: for (self = selfhosts; self; self = self->next)
294: {
295: host = (HOST *) xalloc (sizeof (HOST));
296: *host = *self;
297: host->next = validhosts;
298: validhosts = host;
299: }
300: strcpy (fname, "/etc/X");
301: strcat (fname, display);
302: strcat (fname, ".hosts");
303: if (fd = fopen (fname, "r"))
304: {
305: while (fgets (hostname, sizeof (hostname), fd))
306: {
307: if (ptr = index (hostname, '\n'))
308: *ptr = 0;
309: #ifdef DNETCONN
310: if ((ptr = index (hostname, ':')) && (*(ptr + 1) == ':'))
311: {
312: /* node name (DECnet names end in "::") */
313: *ptr = 0;
314: if (dnaddrp = dnet_addr(hostname))
315: {
316: /* allow nodes to be specified by address */
317: NewHost ((short) AF_DECnet, (pointer) dnaddrp);
318: }
319: else
320: {
321: if (np = getnodebyname (hostname))
322: {
323: /* node was specified by name */
324: saddr.sa.sa_family = np->n_addrtype;
325: if ((family = ConvertAddr (&saddr.sa, &len, &addr)) ==
326: AF_DECnet)
327: {
328: bzero ((pointer) &dnaddr, sizeof (dnaddr));
329: dnaddr.a_len = np->n_length;
330: acopy (np->n_addr, dnaddr.a_addr, np->n_length);
331: NewHost (family, (pointer) &dnaddr);
332: }
333: }
334: }
335: }
336: else
337: {
338: #endif /* DNETCONN */
339: #ifdef ISOCONN
340: /*
341: * ISO displays are host:T-Namedisplay number
342: * only AEI are allowed (i.e. no raw addrs)
343: * XXX Fix to allow T/X and other T-Names...
344: */
345: if ((ptr = index (hostname, ':')) &&
346: ((*(ptr + 1) == 'X') || (*(ptr + 1) == 'T')))
347: {
348: AEI aei;
349: struct PSAPaddr *pa;
350: *ptr++ = '\0';
351: if (ptr)
352: aei = str2aei(hostname, ptr);
353: else
354: aei = str2aei(hostname, DEFAULTTSERVICE);
355: if (aei == NULLAEI) {
356: fprintf (stderr, "%s %s Unknown Display\n",
357: hostname, ptr);
358: continue;
359: }
360: if ((pa = aei2addr (aei)) == NULLPA) {
361: fprintf (stderr, "address translation failed");
362: continue;
363: }
364: family = AF_OSI;
365: NewHost(family, pa);
366: }
367: #endif ISOCONN
368: #ifdef TCPCONN
369: /* host name */
370: if (hp = gethostbyname (hostname))
371: {
372: saddr.sa.sa_family = hp->h_addrtype;
373: if ((family = ConvertAddr (&saddr.sa, &len, &addr)) > 0)
374: #ifdef NEW_HEADER_WITH_OLD_LIBRARY
375: NewHost (family, (pointer)hp->h_addr_list);
376: #else
377: NewHost (family, (pointer)hp->h_addr);
378: #endif
379:
380: }
381: #endif /* TCPCONN */
382: #ifdef DNETCONN
383: }
384: #endif /* DNETCONN */
385: }
386: fclose (fd);
387: }
388: }
389:
390: static Bool
391: AuthorizedClient(client)
392: ClientPtr client;
393: {
394: int alen, family;
395: #ifndef ISOCONN
396: struct sockaddr from;
397: #endif
398: pointer addr;
399: register HOST *host;
400: #ifdef ISOCONN
401: struct TSAPaddr from;
402: #endif /* ISOCONN */
403: #ifdef ISOCONN
404: /*
405: * XXXXXXXXXXXXXXXXX
406: * Just til I fix the X.25 calling addr stuff
407: */
408: return TRUE;
409: #endif /* ISOCONN */
410:
411: alen = sizeof (from);
412: #ifdef ISOCONN
413: if (!SGetPeerName (((OsCommPtr)client->osPrivate)->fd, &from, &alen))
414: #else /* ISOCONN */
415: if (!getpeername (((OsCommPtr)client->osPrivate)->fd, &from, &alen))
416: #endif /* ISOCONN */
417: {
418: if ((family = ConvertAddr (&from, &alen, &addr)) >= 0)
419: {
420: if (family == 0)
421: return TRUE;
422: for (host = selfhosts; host; host = host->next)
423: {
424: #ifdef ISOCONN
425: if (family == host->family && !acmp (addr, &(host->addr), alen))
426: #else /* ISOCONN */
427: if (family == host->family && !acmp (addr, host->addr, alen))
428: #endif /* ISOCONN */
429: return TRUE;
430: }
431: }
432: }
433: return FALSE;
434: }
435:
436: /* Add a host to the access control list. This is the external interface
437: * called from the dispatcher */
438:
439: int
440: AddHost (client, family, length, pAddr)
441: ClientPtr client;
442: int family;
443: unsigned length; /* of bytes in pAddr */
444: pointer pAddr;
445: {
446: int len;
447: register HOST *host;
448: int unixFamily;
449:
450: if (!AuthorizedClient(client))
451: return(BadAccess);
452: unixFamily = UnixFamily(family);
453: if ((len = CheckFamily (DONT_CHECK, unixFamily)) < 0)
454: {
455: client->errorValue = family;
456: return(-len);
457: }
458:
459: if (len != length)
460: {
461: client->errorValue = length;
462: return(BadValue);
463: }
464: for (host = validhosts; host; host = host->next)
465: {
466: #ifdef ISOCONN
467: if (unixFamily == host->family && !acmp (pAddr, &(host->addr), len))
468: return (Success);
469: #else /* ISOCONN */
470: if (unixFamily == host->family && !acmp (pAddr, host->addr, len))
471: return (Success);
472: #endif /* ISOCONN */
473: }
474: host = (HOST *) xalloc (sizeof (HOST));
475: host->family = unixFamily;
476: host->len = len;
477: #ifdef ISOCONN
478: acopy(pAddr, &(host->addr), len);
479: #else /* ISOCONN */
480: acopy(pAddr, host->addr, len);
481: #endif /* ISOCONN */
482: host->next = validhosts;
483: validhosts = host;
484: return (Success);
485: }
486:
487: /* Add a host to the access control list. This is the internal interface
488: * called when starting or resetting the server */
489: NewHost (family, addr)
490: short family;
491: pointer addr;
492: {
493: int len;
494: register HOST *host;
495:
496: if ((len = CheckFamily (DONT_CHECK, family)) < 0)
497: return;
498: for (host = validhosts; host; host = host->next)
499: {
500: #ifdef ISOCONN
501: if (family == host->family && !acmp (addr, &(host->addr), len))
502: return;
503: #else /* ISOCONN */
504: if (family == host->family && !acmp (addr, host->addr, len))
505: return;
506: #endif /* ISOCONN */
507: }
508: host = (HOST *) xalloc (sizeof (HOST));
509: host->family = family;
510: host->len = len;
511: #ifdef ISOCONN
512: acopy(addr, &(host->addr), len);
513: #else /* ISOCONN */
514: acopy(addr, host->addr, len);
515: #endif /* ISOCONN */
516: host->next = validhosts;
517: validhosts = host;
518: }
519:
520: /* Remove a host from the access control list */
521:
522: int
523: RemoveHost (client, family, length, pAddr)
524: ClientPtr client;
525: int family;
526: unsigned length; /* of bytes in pAddr */
527: pointer pAddr;
528: {
529: int len,
530: unixFamily;
531: register HOST *host, **prev;
532:
533: if (!AuthorizedClient(client))
534: return(BadAccess);
535: unixFamily = UnixFamily(family);
536: if ((len = CheckFamily (DONT_CHECK, unixFamily)) < 0)
537: {
538: client->errorValue = family;
539: return(-len);
540: }
541: if (len != length)
542: {
543: client->errorValue = length;
544: return(BadValue);
545: }
546: for (prev = &validhosts;
547: (host = *prev) && (unixFamily != host->family ||
548: #ifdef ISOCONN
549: acmp (pAddr, &(host->addr), len));
550: #else /* ISOCONN */
551: acmp (pAddr, host->addr, len));
552: #endif /* ISOCONN */
553: prev = &host->next)
554: ;
555: if (host)
556: {
557: *prev = host->next;
558: xfree (host);
559: }
560: return (Success);
561: }
562:
563: /* Get all hosts in the access control list */
564: int
565: GetHosts (data, pnHosts, pEnabled)
566: pointer *data;
567: int *pnHosts;
568: BOOL *pEnabled;
569: {
570: int len;
571: register int n = 0;
572: register pointer ptr;
573: register HOST *host;
574: int nHosts = 0;
575: int *lengths = (int *) NULL;
576:
577: *pEnabled = AccessEnabled ? EnableAccess : DisableAccess;
578: for (host = validhosts; host; host = host->next)
579: {
580: if ((len = CheckFamily (DONT_CHECK, host->family)) < 0)
581: return (-1);
582: lengths = (int *) xrealloc(lengths, (nHosts + 1) * sizeof(int));
583: lengths[nHosts++] = len;
584: n += (((len + 3) >> 2) << 2) + sizeof(xHostEntry);
585: }
586: if (n)
587: {
588: *data = ptr = (pointer) xalloc (n);
589: nHosts = 0;
590: for (host = validhosts; host; host = host->next)
591: {
592: #ifdef ISOCONN
593: #ifdef ISODEBUG
594: if (isodexbug)
595: {
596: int i; char *hp = (char *)(&host->addr);
597: fprintf(stderr, "List(%d): ", host->family);
598: for(i=0; i<len; i++)
599: fprintf(stderr, "%x ", (*hp++)&0xff);
600: fprintf(stderr, "\n");
601: }
602: #endif ISODEBUG
603: #endif /* ISOCONN */
604:
605: len = lengths[nHosts++];
606: ((xHostEntry *)ptr)->family = XFamily(host->family);
607: ((xHostEntry *)ptr)->length = len;
608: ptr += sizeof(xHostEntry);
609: #ifdef ISOCONN
610: acopy (&host->addr, ptr, len);
611: #else /* ISOCONN */
612: acopy (host->addr, ptr, len);
613: #endif /* ISOCONN */
614: ptr += ((len + 3) >> 2) << 2;
615: }
616: }
617: *pnHosts = nHosts;
618: xfree(lengths);
619: return (n);
620: }
621:
622: /* Check for valid address family, and for local host if client modification.
623: * Return address length.
624: */
625:
626: CheckFamily (connection, family)
627: int connection;
628: int family;
629: {
630: #ifdef ISOCONN
631: struct TSAPaddr from;
632: #else /* ISOCONN */
633: struct sockaddr from;
634: #endif /* ISOCONN */
635: int alen;
636: pointer addr;
637: register HOST *host;
638: int len;
639:
640: switch (family)
641: {
642: #ifdef TCPCONN
643: case AF_INET:
644: len = sizeof (struct in_addr);
645: break;
646: #endif
647: #ifdef DNETCONN
648: case AF_DECnet:
649: len = sizeof (struct dn_naddr);
650: break;
651: #endif
652: #ifdef ISOCONN
653: case AF_OSI:
654: len = NASIZE;
655: break;
656: #endif /* ISOCONN */
657: default:
658: return (-BadValue);
659: }
660: if (connection == DONT_CHECK)
661: return (len);
662: #ifdef ISOCONN
663: alen = NASIZE;
664: if (!SGetPeerName(connection, &from, &alen))
665: #else /* ISOCONN */
666: alen = sizeof (from);
667: if (!getpeername (connection, &from, &alen))
668: #endif /* ISOCONN */
669: {
670: if ((family = ConvertAddr (&from, &alen, &addr)) >= 0)
671: {
672: if (family == 0)
673: return (len);
674: for (host = selfhosts; host; host = host->next)
675: {
676: if (family == host->family &&
677: #ifdef ISOCONN
678: !acmp (addr, &(host->addr), alen))
679: #else /* ISOCONN */
680: !acmp (addr, host->addr, alen))
681: #endif /* ISOCONN */
682: return (len);
683: }
684: }
685: }
686: /* Bad Access */
687: return (-1);
688: }
689:
690: /* Check if a host is not in the access control list.
691: * Returns 1 if host is invalid, 0 if we've found it. */
692:
693: InvalidHost (saddr, len)
694: #ifdef ISOCONN
695: register struct TSAPaddr *saddr;
696: #else /* ISOCONN */
697: register struct sockaddr *saddr;
698: #endif /* ISOCONN */
699: int len;
700: {
701: int family;
702: pointer addr;
703: register HOST *host;
704: #ifdef ISOCONN
705: len = NASIZE;
706: #endif /* ISOCONN */
707:
708: if ((family = ConvertAddr (saddr, len ? &len : 0, &addr)) < 0)
709: return (1);
710: #ifdef ISOCONN
711: #ifdef ISODEBUG
712: if (isodexbug) {
713: int i; char *hp = (char *)(addr);
714: fprintf(stderr, "Other(%d): ", family);
715: for(i=0; i<len; i++)
716: fprintf(stderr, "%x ", (*hp++)&0xff);
717: fprintf(stderr, "\n");
718: }
719: #endif /* ISODEBUG */
720: #endif /* ISOCONN */
721: if (family == 0)
722: return (0);
723:
724: #ifdef ISOCONN
725: /*
726: * XXXXXXXXXXXXXXXXX
727: * Just til I fix the X.25 calling addr stuff
728: */
729: return 0;
730: #endif
731:
732: if (!AccessEnabled) /* just let them in */
733: return(0);
734: for (host = validhosts; host; host = host->next)
735: {
736: #ifdef ISOCONN
737: #ifdef ISODEBUG
738: if (isodexbug) {
739: int i; char *hp = (char *)&(host->addr);
740: fprintf(stderr, "List(%d): ", host->family);
741: for(i=0; i<host->len; i++)
742: fprintf(stderr, "%x ", (*hp++)&0xff);
743: fprintf(stderr, "\n");
744: }
745: #endif /* ISODEBUG */
746: if (family == host->family && !acmp (addr, &(host->addr), len))
747: #else /* ISOCONN */
748: if (family == host->family && !acmp (addr, host->addr, len))
749: #endif /* ISOCONN */
750: return (0);
751: }
752: return (1);
753: }
754:
755: ConvertAddr (saddr, len, addr)
756: #ifdef ISOCONN
757: register struct TSAPaddr *saddr;
758: #else /* ISOCONN */
759: register struct sockaddr *saddr;
760: #endif /* ISOCONN */
761: int *len;
762: pointer *addr;
763: {
764: if (len == 0)
765: return (0);
766: #ifdef ISOCONN
767: /*
768: * NULL ish type acttion, but maybe later we'd change this to
769: * use AEIs as the thing for access ctl, and need to get from
770: * transport descriptor to T-SAPs to AEI...
771: */
772: *len = NASIZE;
773: *addr = (pointer)saddr;
774: return (AF_OSI);
775:
776: #else /* ISOCONN */
777: switch (saddr->sa_family)
778: {
779: case AF_UNSPEC:
780: #ifndef hpux
781: case AF_UNIX:
782: #endif
783: return (0);
784: case AF_INET:
785: #ifdef TCPCONN
786: *len = sizeof (struct in_addr);
787: *addr = (pointer) &(((struct sockaddr_in *) saddr)->sin_addr);
788: return (AF_INET);
789: #else
790: break;
791: #endif
792:
793: #ifdef DNETCONN
794: case AF_DECnet:
795: *len = sizeof (struct dn_naddr);
796: *addr = (pointer) &(((struct sockaddr_dn *) saddr)->sdn_add);
797: return (AF_DECnet);
798: #else
799: break;
800: #endif
801: default:
802: break;
803: }
804: return (-1);
805: #endif /* ISOCONN */
806: }
807:
808: int
809: ChangeAccessControl(client, fEnabled)
810: ClientPtr client;
811: int fEnabled;
812: {
813: if (!AuthorizedClient(client))
814: return BadAccess;
815: AccessEnabled = fEnabled;
816: return Success;
817: }
818:
819: static int XFamily(af)
820: int af;
821: {
822: int i;
823: for (i = 0; i < FAMILIES; i++)
824: if (familyMap[i].af == af)
825: return familyMap[i].xf;
826: return -1;
827: }
828:
829: static int UnixFamily(xf)
830: int xf;
831: {
832: int i;
833: for (i = 0; i < FAMILIES; i++)
834: if (familyMap[i].xf == xf)
835: return familyMap[i].af;
836: return -1;
837: }
838:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.