![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to connection.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 connection.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: /* $XConsortium: connection.c,v 1.88 88/10/22 22:06:31 keith Exp $ */
25: /*****************************************************************
26: * Stuff to create connections --- OS dependent
27: *
28: * EstablishNewConnections, CreateWellKnownSockets, ResetWellKnownSockets,
29: * CloseDownConnection, CheckConnections, AddEnabledDevice,
30: * RemoveEnabledDevice, OnlyListToOneClient,
31: * ListenToAllClients,
32: *
33: * (WaitForSomething is in its own file)
34: *
35: * In this implementation, a client socket table is not kept.
36: * Instead, what would be the index into the table is just the
37: * file descriptor of the socket. This won't work for if the
38: * socket ids aren't small nums (0 - 2^8)
39: *
40: *****************************************************************/
41:
42: #ifdef ISOCONN
43: #include <math.h>
44: #endif /* ISOCONN */
45:
46: #include <dbm.h>
47: #undef NULL
48: #include "X.h"
49: #include "Xproto.h"
50: #include <sys/param.h>
51: #include <errno.h>
52: #include "Xos.h" /* for strings, file, time */
53: #include <sys/socket.h>
54:
55: #include <signal.h>
56: #include <fcntl.h>
57: #include <setjmp.h>
58:
59: #ifdef hpux
60: #include <sys/ioctl.h>
61: #endif
62:
63: #ifdef TCPCONN
64: #include <netinet/in.h>
65: #ifndef hpux
66: #include <netinet/tcp.h>
67: #endif
68: #endif
69:
70: #ifdef UNIXCONN
71: /*
72: * sites should be careful to have separate /tmp directories for diskless nodes
73: */
74: #include <sys/un.h>
75: #include <sys/stat.h>
76: static int unixDomainConnection = -1;
77: #endif
78:
79: #include <stdio.h>
80: #include <sys/uio.h>
81: #include "osstruct.h"
82: #include "osdep.h"
83: #include "opaque.h"
84: #include "dixstruct.h"
85:
86: #ifdef DNETCONN
87: #include <netdnet/dn.h>
88: #endif /* DNETCONN */
89:
90: #ifdef ISOCONN
91: #include <isode/psap.h>
92: #include <isode/tsap.h>
93: #include <isode/isoservent.h>
94:
95: extern char *isodetcpath;
96:
97: #ifdef ISODEBUG
98: /*
99: * Set to true for loads of TSAP messages...
100: */
101: int isodexbug = FALSE;
102: #endif /* ISODEBUG */
103:
104: /*
105: * array of fd 2 family map so we can lookup right function below...
106: * Its initialised at connection setup...
107: */
108: int fd2family[MAXSOCKS];
109: /*
110: * Globals for storing functions appropos each fd/socket type
111: * UNIX_IO (0) map to sys calls
112: * ISODE_IO (1) maps to my fns...
113: */
114:
115: extern int accept(), TAcceptFromClient();
116: int (*acceptfn[])() =
117: {
118: accept, TAcceptFromClient
119: };
120: extern getpeername(), getISOpeername();
121: int (*getpeerfn[])() =
122: {
123: getpeername, getISOpeername
124: };
125: /*
126: * Note yuckiness here XXX
127: * TReadFromClient takes one more param than read - must fix...
128: */
129: extern int read(), TReadFromClient();
130: int (*readfn[])() =
131: {
132: read, TReadFromClient
133: };
134: extern int write(), TWriteToClient();
135: int (*writefn[])() =
136: {
137: write, TWriteToClient
138: };
139: extern writev(), TWritevToClient();
140: int (*writevfn[])() =
141: {
142: writev, TWritevToClient
143: };
144: extern int close(), TDiscFromClient();
145: int (*closefn[])() =
146: {
147: close, TDiscFromClient
148: };
149:
150: #endif /* ISOCONN */
151:
152: typedef long CCID; /* mask of indices into client socket table */
153:
154: #ifndef X_UNIX_PATH
155: #define X_UNIX_DIR "/tmp/.X11-unix"
156: #define X_UNIX_PATH "/tmp/.X11-unix/X"
157: #endif
158:
159: #ifdef ISOCONN
160: char *display = NULLCP; /* The display number */
161: #else /* ISOCONN */
162: char *display; /* The display number */
163: #endif /* ISOCONN */
164: int lastfdesc; /* maximum file descriptor */
165:
166: long WellKnownConnections; /* Listener mask */
167: long EnabledDevices; /* mask for input devices that are on */
168: long AllSockets[mskcnt]; /* select on this */
169: long AllClients[mskcnt]; /* available clients */
170: long LastSelectMask[mskcnt]; /* mask returned from last select call */
171: long ClientsWithInput[mskcnt]; /* clients with FULL requests in buffer */
172: long ClientsWriteBlocked[mskcnt];/* clients who cannot receive output */
173: long OutputPending[mskcnt]; /* clients with reply/event data ready to go */
174: long MaxClients = MAXSOCKS ;
175: long OutputBufferSize = BUFSIZ; /* output buffer size (must be > 0) */
176: long NConnBitArrays = mskcnt;
177: long FirstClient;
178: Bool NewOutputPending; /* not yet attempted to write some new output */
179: Bool AnyClientsWriteBlocked; /* true if some client blocked on write */
180:
181: static Bool debug_conns = FALSE;
182:
183: static char whichByteIsFirst;
184:
185: static int SavedAllClients[mskcnt];
186: static int SavedAllSockets[mskcnt];
187: static int SavedClientsWithInput[mskcnt];
188: static Bool GrabDone = FALSE;
189:
190: ClientPtr ConnectionTranslation[MAXSOCKS];
191: extern ClientPtr NextAvailableClient();
192:
193: extern ConnectionInput inputBuffers[];
194:
195: int swappedClients[MAXSOCKS];
196:
197: extern int AutoResetServer();
198: extern int GiveUp();
199:
200: #ifdef UNIXCONN
201:
202: static struct sockaddr_un unsock;
203:
204: static int open_unix_socket ()
205: {
206: int oldUmask;
207: int request;
208:
209: unsock.sun_family = AF_UNIX;
210: oldUmask = umask (0);
211: #ifdef X_UNIX_DIR
212: mkdir (X_UNIX_DIR, 0777);
213: #endif
214: strcpy (unsock.sun_path, X_UNIX_PATH);
215: strcat (unsock.sun_path, display);
216: unlink (unsock.sun_path);
217: if ((request = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
218: {
219: Notice ("Creating Unix socket");
220: }
221: else
222: {
223: if(bind(request,(struct sockaddr *)&unsock, strlen(unsock.sun_path)+2))
224: Error ("Binding Unix socket");
225: if (listen (request, 5)) Error ("Unix Listening");
226: }
227: (void)umask(oldUmask);
228: return request;
229: }
230: #endif /*UNIXCONN */
231:
232: /*****************
233: * CreateWellKnownSockets
234: * At initialization, create the sockets to listen on for new clients.
235: * There are potentially 4: DECnet, UNIX Domain, TCP-IP with MSB first,
236: * with TCP-IP with LSB first.
237: *****************/
238:
239: void
240: CreateWellKnownSockets()
241: {
242: int request, i;
243: int whichbyte; /* used to figure out whether this is
244: LSB or MSB */
245: #ifdef TCPCONN
246: struct sockaddr_in insock;
247: int tcpportReg; /* port with same byte order as server */
248:
249: #ifdef SO_LINGER
250: static int linger[2] = { 0, 0 };
251: #endif /* SO_LINGER */
252:
253: #endif /* TCPCONN */
254:
255: #ifdef DNETCONN
256: struct sockaddr_dn dnsock;
257: #endif /* DNETCONN */
258:
259: #ifdef ISOCONN
260: struct TSAPdisconnect tds;
261: struct TSAPdisconnect *td = &tds;
262: struct TSAPaddr tas;
263: struct TSAPaddr *ta = &tas;
264: struct PSAPaddr *pa;
265: AEI aei;
266: #endif /* ISOCONN */
267: int retry;
268:
269: #ifdef ISOCONN
270: #ifdef ISODEBUG
271: isodetcpath = ISODEPATH;
272: #endif
273: #endif /* ISOCONN */
274:
275: CLEARBITS(AllSockets);
276: CLEARBITS(AllClients);
277: CLEARBITS(LastSelectMask);
278: CLEARBITS(ClientsWithInput);
279:
280: for (i=0; i<MAXSOCKS; i++) ConnectionTranslation[i] = (ClientPtr)NULL;
281:
282: #ifdef hpux
283: lastfdesc = _NFILE - 1;
284: #else
285: lastfdesc = getdtablesize() - 1;
286: #endif /* hpux */
287:
288: if (lastfdesc > MAXSOCKS)
289: {
290: lastfdesc = MAXSOCKS;
291: if (debug_conns)
292: ErrorF( "GOT TO END OF SOCKETS %d\n", MAXSOCKS);
293: }
294:
295: WellKnownConnections = 0;
296: whichbyte = 1;
297:
298: if (*(char *) &whichbyte)
299: whichByteIsFirst = 'l';
300: else
301: whichByteIsFirst = 'B';
302:
303:
304: #ifdef TCPCONN
305:
306: tcpportReg = atoi (display);
307: tcpportReg += X_TCP_PORT;
308:
309: if ((request = socket (AF_INET, SOCK_STREAM, 0)) < 0)
310: {
311: Notice ("Creating TCP socket");
312: }
313: else
314: {
315: bzero ((char *)&insock, sizeof (insock));
316: insock.sin_family = AF_INET;
317: insock.sin_port = htons (tcpportReg);
318: insock.sin_addr.s_addr = htonl(INADDR_ANY);
319: retry = 20;
320: while (i = bind(request, (struct sockaddr *) &insock, sizeof (insock)))
321: {
322: #ifdef hpux
323: /* Necesary to restart the server without a reboot */
324: if (errno == EADDRINUSE)
325: set_socket_option (request, SO_REUSEADDR);
326: if (--retry == 0)
327: Error ("Binding TCP socket");
328: sleep (1);
329: #else
330: if (--retry == 0)
331: Error ("Binding MSB TCP socket");
332: sleep (10);
333: #endif /* hpux */
334: }
335: #ifdef hpux
336: /* return the socket option to the original */
337: if (errno)
338: unset_socket_option (request, SO_REUSEADDR);
339: #endif /* hpux */
340: #ifdef SO_LINGER
341: if(setsockopt (request, SOL_SOCKET, SO_LINGER,
342: (char *)linger, sizeof(linger)))
343: Notice ("Setting TCP SO_LINGER\n");
344: #endif /* SO_LINGER */
345: if (listen (request, 5))
346: Error ("Reg TCP Listening");
347: WellKnownConnections |= (1 << request);
348: DefineSelf (request);
349: #ifdef ISOCONN
350: fd2family[request] = UNIX_IO;
351: #endif /* ISOCONN */
352: }
353:
354: #endif /* TCPCONN */
355:
356: #ifdef UNIXCONN
357: if ((request = open_unix_socket ()) != -1) {
358: WellKnownConnections |= (1L << request);
359: unixDomainConnection = request;
360: #ifdef ISOCONN
361: fd2family[request] = UNIX_IO;
362: #endif /* ISOCONN */
363: }
364: #endif /*UNIXCONN */
365:
366: #ifdef DNETCONN
367: if ((request = socket (AF_DECnet, SOCK_STREAM, 0)) < 0)
368: {
369: Notice ("Creating DECnet socket");
370: }
371: else
372: {
373: bzero ((char *)&dnsock, sizeof (dnsock));
374: dnsock.sdn_family = AF_DECnet;
375: sprintf(dnsock.sdn_objname, "X$X%d", atoi (display));
376: dnsock.sdn_objnamel = strlen(dnsock.sdn_objname);
377: if (bind (request, (struct sockaddr *) &dnsock, sizeof (dnsock)))
378: Error ("Binding DECnet socket");
379: if (listen (request, 5)) Error ("DECnet Listening");
380: WellKnownConnections |= (1 << request);
381: DefineSelf (request);
382: #ifdef ISOCONN
383: fd2family[request] = UNIX_IO;
384: #endif /* ISOCONN */
385: }
386: #endif /* DNETCONN */
387: #ifdef ISOCONN
388: /*
389: * If display is set, its the string after the Colon:
390: * i.e. X0 or X1 or T0 or T1...
391: */
392: if ((display == NULLCP) || (atoi(display) == 0))
393: aei = str2aei(TLocalHostName(), DEFAULTTSERVICE);
394: else
395: aei = str2aei(TLocalHostName(), display);
396:
397: if (aei == NULLAEI) {
398: ErrorF("No AEI for me:");
399: FatalError(TLocalHostName());
400: }
401:
402: /*
403: * This hack only works if the PSAPaddr and SSAP addrsd are null!!
404: */
405: if ((pa = aei2addr (aei)) == NULLPA)
406: FatalError("address translation failed");
407:
408: ta = (struct TSAPaddr *)&(pa->pa_addr.sa_addr);
409:
410: /*
411: * Just put out a listen for now
412: */
413: if ((request = TNetListen(ta, td)) != OK) {
414: Error(TErrString(td->td_reason));
415: FatalError("TNetListen");
416: }
417:
418: WellKnownConnections |= (1 << request);
419: DefineSelf (request);
420: fd2family[request] = ISODE_IO;
421: #endif /* ISOCONN */
422: if (WellKnownConnections == 0)
423: Error ("No Listeners, nothing to do");
424: signal (SIGPIPE, SIG_IGN);
425: signal (SIGHUP, AutoResetServer);
426: signal (SIGINT, GiveUp);
427: signal (SIGTERM, GiveUp);
428: FirstClient = request + 1;
429: AllSockets[0] = WellKnownConnections;
430: ResetHosts(display);
431:
432: for (i=0; i<MaxClients; i++)
433: {
434: inputBuffers[i].buffer = (char *) NULL;
435: inputBuffers[i].bufptr = (char *) NULL;
436: inputBuffers[i].bufcnt = 0;
437: inputBuffers[i].lenLastReq = 0;
438: inputBuffers[i].size = 0;
439: }
440: }
441:
442: void
443: ResetWellKnownSockets ()
444: {
445: #ifdef UNIXCONN
446: if (unixDomainConnection != -1)
447: {
448: /*
449: * see if the unix domain socket has disappeared
450: */
451: struct stat statb;
452:
453: if (stat (unsock.sun_path, &statb) == -1 ||
454: (statb.st_mode & S_IFMT) != S_IFSOCK)
455: {
456: ErrorF ("Unix domain socket %s trashed, recreating\n",
457: unsock.sun_path);
458: (void) unlink (unsock.sun_path);
459: (void) close (unixDomainConnection);
460: WellKnownConnections &= ~(1L << unixDomainConnection);
461: unixDomainConnection = open_unix_socket ();
462: if (unixDomainConnection != -1)
463: WellKnownConnections |= (1L << unixDomainConnection);
464: }
465: }
466: #endif /* UNIXCONN */
467: }
468:
469: #ifdef ISOCONN
470: /*
471: * Convenience routine...
472: * client = transport descriptor
473: * data, size = buffer
474: * nonblock = NOTOK, blocks, OK, non blocks
475: */
476: TReadFromClient(client, data, size, nonblock)
477: int client, size, nonblock;
478: char *data;
479: {
480: struct TSAPdisconnect tds;
481: struct TSAPdisconnect *td = &tds;
482: int ret;
483: static struct TSAPdata txs;
484: static struct TSAPdata *tx = &txs;
485: char *aptr;
486: static struct qbuf *qb;
487: static char *qptr;
488: static int ingot, qcpy, result = 0;
489: int q2data;
490:
491: #ifdef ISODEBUG
492: if (isodexbug) {
493: fprintf(stderr, "TReadFromClient %d want %d (%d buffered)\n",
494: client, size, result);
495: }
496: #endif /* ISODEBUG */
497: if (result == 0) {
498: if ((ret = TReadRequest(client, tx, nonblock, td)) == NOTOK) {
499: #ifdef ISODEBUG
500: if(errno == EWOULDBLOCK ) {
501: fprintf(stderr, "Server TReadReq: would block %s\n",
502: TErrString(td->td_reason));
503: if (!DR_FATAL(td->td_reason))
504: errno = EWOULDBLOCK;
505: else
506: errno = EBADF;
507: return ret;
508: }
509: if (isodexbug)
510: fprintf(stderr, "Server TReadReq: %s\n",
511: TErrString(td->td_reason));
512: #endif /* ISODEBUG */
513: /*
514: * map problems here - eg TimeOut...
515: */
516: if (td->td_reason == DR_TIMER)
517: errno = EWOULDBLOCK;
518: return ret;
519: }
520: result = tx->tx_cc;
521: qb = &(tx->tx_qbuf);
522: qptr = qb->qb_data;
523: #ifdef ISODEBUG
524: if (isodexbug)
525: fprintf(stderr, "TReadRequest want %d got %d\n",
526: size, result);
527: #endif
528: }
529: #ifdef ISODEBUG
530: else {
531: if (isodexbug)
532: fprintf(stderr, "TReadFromClient want %d buffered %d\n",
533: size, result);
534: }
535: #endif
536: /*
537: * Buffer it
538: */
539: ingot = 0;
540: aptr = data;
541: for(ingot = 0, aptr = data, q2data = min(size, result);
542: ingot<q2data;
543: aptr += qcpy, ingot+= qcpy) {
544: int aleft = q2data - ingot;
545: if (qb->qb_len > aleft) {
546: qcpy = aleft;
547: bcopy(qptr, aptr, qcpy);
548: qptr += aleft;
549: } else {
550: qcpy = qb->qb_len;
551: bcopy(qb->qb_data, aptr, qcpy);
552: if ((qb = qb->qb_forw) == NULL)
553: break;
554: qptr = qb->qb_data;
555: }
556: }
557: if ((result -= ingot) <= 0) {
558: result = 0;
559: TXFREE(tx);
560: }
561: return ingot;
562: }
563:
564: #endif /* ISOCONN */
565:
566: /* We want to read the connection information. If the client doesn't
567: * send us enough data, however, we want to time out eventually.
568: * The scheme is to clear a flag, set an alarm, and keep doing non-blocking
569: * reads until we get all the data we want. If the alarm goes
570: * off, the handler will clear the flag. If we see that the flag is
571: * cleared, we know we've timed out and return with an error.
572: *
573: * there remains one problem with this code:
574: * there is a window of vulnerability in which we might get an alarm
575: * even though all the data has come in properly. This is because I
576: * can't atomically clear the alarm.
577: *
578: * Anyone who sees how to fix this problem should do so and
579: * submit a fix.
580: */
581:
582: jmp_buf env;
583: void TimeOut()
584: {
585: longjmp(env, 1);
586: }
587: static Bool
588: ReadBuffer(conn, buffer, charsWanted)
589: long conn;
590: char *buffer;
591: int charsWanted;
592: {
593: char *bptr = buffer;
594: int got, fTimeOut;
595: struct itimerval itv;
596:
597: signal(SIGALRM, TimeOut);
598: fTimeOut = FALSE;
599: /* only 1 alarm, please, not 1 per minute */
600: timerclear(&itv.it_interval);
601: itv.it_value.tv_sec = TimeOutValue;
602: itv.it_value.tv_usec = 0;
603: setitimer(ITIMER_REAL, &itv, (struct itimerval *)NULL);
604: /* It better not take a full minute to get to the read call */
605:
606: while (charsWanted && (fTimeOut = setjmp(env)) == FALSE)
607: {
608: #ifdef ISOCONN
609: got = SRead(conn, bptr, charsWanted, NOTOK);
610: #else /* ISOCONN */
611: got = read(conn, bptr, charsWanted);
612: #endif /* ISOCONN */
613: if (got <= 0)
614: return FALSE;
615: if(got > 0)
616: {
617: charsWanted -= got;
618: bptr += got;
619: /* Ok, we got something, reset the timer */
620: itv.it_value.tv_sec = TimeOutValue;
621: itv.it_value.tv_usec = 0;
622: setitimer(ITIMER_REAL, &itv, (struct itimerval *)NULL);
623: }
624: }
625: /* disable the timer */
626: timerclear(&itv.it_value);
627: setitimer(ITIMER_REAL, &itv, (struct itimerval *)NULL);
628: /* If we got here and we didn't time out, then return TRUE, because
629: * we must have read what we wanted. If we timed out, return FALSE */
630: if(fTimeOut && debug_conns)
631: ErrorF("Timed out on connection %d\n", conn);
632: return (!fTimeOut);
633: }
634:
635: #ifdef ISOCONN
636: /*
637: * Who's calling us?
638: */
639: getISOpeername (conn, from, alen)
640: int conn;
641: struct TSAPaddr *from;
642: int *alen;
643: {
644: struct TSAPdisconnect td;
645: if (TGetAddresses (conn, from, NULLTA, &td) == NOTOK) {
646: Error(TErrString(td.td_reason));
647: return TRUE;
648: };
649: *alen = sizeof(struct TSAPaddr);
650: return FALSE;
651: }
652: #endif /* ISOCONN */
653: /*****************************************************************
654: * ClientAuthorized
655: *
656: * Sent by the client at connection setup:
657: * typedef struct _xConnClientPrefix {
658: * CARD8 byteOrder;
659: * BYTE pad;
660: * CARD16 majorVersion, minorVersion;
661: * CARD16 nbytesAuthProto;
662: * CARD16 nbytesAuthString;
663: * } xConnClientPrefix;
664: *
665: * It is hoped that eventually one protocol will be agreed upon. In the
666: * mean time, a server that implements a different protocol than the
667: * client expects, or a server that only implements the host-based
668: * mechanism, will simply ignore this information.
669: *
670: *****************************************************************/
671:
672: int
673: ClientAuthorized(conn, pswapped, reason)
674: long conn;
675: int *pswapped;
676: char **reason; /* if authorization fails, put reason in here */
677: {
678: short slen;
679: union {
680: struct sockaddr sa;
681: #ifdef UNIXCONN
682: struct sockaddr_un un;
683: #endif /* UNIXCONN */
684: #ifdef TCPCONN
685: struct sockaddr_in in;
686: #endif /* TCPCONN */
687: #ifdef DNETCONN
688: struct sockaddr_dn dn;
689: #endif /* DNETCONN */
690: #ifdef ISOCONN
691: struct TSAPaddr ts;
692: #endif /* ISOCONN */
693: } from;
694: int fromlen;
695: xConnClientPrefix xccp;
696: char auth_proto[100];
697: char auth_string[100];
698:
699: #ifdef ISOCONN
700: /*
701: * For now we always auth an ISO client!!
702: * should use directory etc etc
703: */
704: *reason = 0;
705: #endif /* ISOCONN */
706: if (!ReadBuffer(conn, (char *)&xccp, sizeof(xConnClientPrefix)))
707: {
708: /* If they can't even give us this much, just blow them off
709: * without an error message */
710: *reason = 0;
711: return 0;
712: }
713: if (xccp.byteOrder != whichByteIsFirst)
714: {
715: SwapConnClientPrefix(&xccp);
716: *pswapped = TRUE;
717: }
718: else
719: *pswapped = FALSE;
720: if ((xccp.majorVersion != X_PROTOCOL) ||
721: (xccp.minorVersion != X_PROTOCOL_REVISION))
722: {
723: #define STR "Protocol version mismatch"
724: *reason = (char *)xalloc(sizeof(STR));
725: strcpy(*reason, STR);
726: if (debug_conns)
727: ErrorF("%s\n", STR);
728: #undef STR
729: return 0;
730: }
731: fromlen = sizeof (from);
732: #ifdef ISOCONN
733: if (SGetPeerName (conn, &(from.ts), &fromlen) ||
734: InvalidHost (&(from.ts), fromlen))
735: #else /* ISOCONN */
736: if (getpeername (conn, &from.sa, &fromlen) ||
737: InvalidHost (&from.sa, fromlen))
738: #endif /* ISOCONN */
739: {
740: #define STR "Server is not authorized to connect to host"
741: *reason = (char *)xalloc(sizeof(STR));
742: strcpy(*reason, STR);
743: #undef STR
744: return 0;
745: }
746:
747: slen = (xccp.nbytesAuthProto + 3) & ~3;
748: if ( slen )
749: if (!ReadBuffer(conn, auth_proto, slen))
750: {
751: #define STR "Length error in xConnClientPrefix for protocol authorization "
752: *reason = (char *)xalloc(sizeof(STR));
753: strcpy(*reason, STR);
754: return 0;
755: #undef STR
756: }
757: auth_proto[slen] = '\0';
758:
759: slen = (xccp.nbytesAuthString + 3) & ~3;
760: if ( slen)
761: if (!ReadBuffer(conn, auth_string, slen))
762: {
763: #define STR "Length error in xConnClientPrefix for protocol string"
764: *reason = (char *)xalloc(sizeof(STR));
765: strcpy(*reason, STR);
766: return 0;
767: #undef STR
768: }
769: auth_string[slen] = '\0';
770:
771: /* At this point, if the client is authorized to change the access control
772: * list, we should getpeername() information, and add the client to
773: * the selfhosts list. It's not really the host machine, but the
774: * true purpose of the selfhosts list is to see who may change the
775: * access control list.
776: */
777: return(1);
778: }
779:
780: static int padlength[4] = {0, 3, 2, 1};
781:
782: /*****************
783: * EstablishNewConnections
784: * If anyone is waiting on listened sockets, accept them.
785: * Returns a mask with indices of new clients. Updates AllClients
786: * and AllSockets.
787: *****************/
788:
789: void
790: #ifdef ISOCONN
791: EstablishNewConnections(newclients, nnew, vecp, vec)
792: ClientPtr *newclients;
793: int *nnew;
794: int vecp;
795: char **vec;
796: #else /* ISOCONN */
797: EstablishNewConnections(newclients, nnew)
798: ClientPtr *newclients;
799: int *nnew;
800: #endif /* ISOCONN */
801: {
802: long readyconnections; /* mask of listeners that are ready */
803: long curconn; /* fd of listener that's ready */
804: long newconn; /* fd of new client */
805: int swapped; /* set by ClientAuthorized if connection is
806: * swapped */
807: char *reason;
808: struct iovec iov[2];
809: #ifdef ISOCONN
810: struct udvec uv[3];
811: struct TSAPdisconnect tds;
812: struct TSAPdisconnect *td = &tds;
813: struct TSAPstart tsts;
814: struct TSAPstart *tst = &tsts;
815: #endif /* ISOCONN */
816: char p[3];
817:
818: #ifdef TCP_NODELAY
819: union {
820: struct sockaddr sa;
821: #ifdef UNIXCONN
822: struct sockaddr_un un;
823: #endif /* UNIXCONN */
824: #ifdef TCPCONN
825: struct sockaddr_in in;
826: #endif /* TCPCONN */
827: #ifdef DNETCONN
828: struct sockaddr_dn dn;
829: #endif /* DNETCONN */
830: } from;
831: int fromlen;
832: #endif TCP_NODELAY
833:
834: *nnew = 0;
835: if (readyconnections = (LastSelectMask[0] & WellKnownConnections))
836: {
837: while (readyconnections)
838: {
839: curconn = ffs (readyconnections) - 1;
840: #ifdef ISOCONN
841: /*
842: * At this point, a TAccept has finished with a vec > 0
843: * so we need to init them...
844: */
845: if ((newconn = SAccept(curconn, vecp, vec)) >= 0)
846: {
847: fd2family[newconn] = ISODE_IO;
848: #else /* ISOCONN */
849: if ((newconn = accept (curconn,
850: (struct sockaddr *) NULL,
851: (int *)NULL)) >= 0)
852: {
853: fd2family[newconn] = UNIX_IO;
854: #endif /* ISOCONN */
855: if (newconn >= lastfdesc)
856: {
857: if (debug_conns)
858: ErrorF("Didn't make connection: Out of file descriptors for connections\n");
859: #ifdef ISOCONN
860: SClose(newconn);
861: #else /* ISOCONN */
862: close (newconn);
863: #endif /* ISOCONN */
864: }
865: else
866: {
867: ClientPtr next = (ClientPtr)NULL;
868:
869: #ifdef TCP_NODELAY
870: #ifdef ISOCONN
871: if (fd2family(newconn) == UNIX_IO)
872: {
873: #endif /* ISOCONN */
874: fromlen = sizeof (from);
875: if (!getpeername (newconn, &from.sa, &fromlen))
876: {
877: if (fromlen && (from.sa.sa_family == AF_INET))
878: {
879: int mi = 1;
880: setsockopt (newconn, IPPROTO_TCP, TCP_NODELAY,
881: (char *)&mi, sizeof (int));
882: }
883: }
884: #ifdef ISOCONN
885: }
886: #endif /* ISOCONN */
887: #endif /* TCP_NODELAY */
888: if (ClientAuthorized(newconn, &swapped, &reason))
889: {
890: #ifdef hpux
891: /*
892: * HPUX does not have FNDELAY
893: */
894: {
895: int arg;
896: arg = 1;
897: ioctl(newconn, FIOSNBIO, &arg);
898: }
899: #else
900: fcntl (newconn, F_SETFL, FNDELAY);
901: #endif /* hpux */
902: inputBuffers[newconn].used = 1;
903: if (! inputBuffers[newconn].size)
904: {
905: inputBuffers[newconn].buffer =
906: (char *)xalloc(BUFSIZE);
907: inputBuffers[newconn].size = BUFSIZE;
908: inputBuffers[newconn].bufptr =
909: inputBuffers[newconn].buffer;
910: }
911: if (GrabDone)
912: {
913: BITSET(SavedAllClients, newconn);
914: BITSET(SavedAllSockets, newconn);
915: }
916: else
917: {
918: BITSET(AllClients, newconn);
919: BITSET(AllSockets, newconn);
920: }
921: next = NextAvailableClient();
922: if (next != (ClientPtr)NULL)
923: {
924: OsCommPtr priv;
925:
926: newclients[(*nnew)++] = next;
927: next->swapped = swapped;
928: ConnectionTranslation[newconn] = next;
929: priv = (OsCommPtr)xalloc(sizeof(OsCommRec));
930: priv->fd = newconn;
931: priv->buf = (unsigned char *)
932: xalloc(OutputBufferSize);
933: priv->bufsize = OutputBufferSize;
934: priv->count = 0;
935: next->osPrivate = (pointer)priv;
936: }
937: else
938: {
939: #define STR "Maximum number of clients exceeded"
940: reason = (char *)xalloc(sizeof(STR));
941: strcpy(reason, STR);
942: #undef STR
943: }
944: }
945: if (next == (ClientPtr)NULL)
946: {
947: xConnSetupPrefix c;
948:
949: if(reason)
950: {
951: c.success = xFalse;
952: c.lengthReason = strlen(reason);
953: c.length = (c.lengthReason + 3) >> 2;
954: c.majorVersion = X_PROTOCOL;
955: c.minorVersion = X_PROTOCOL_REVISION;
956: if(swapped)
957: {
958: int n;
959:
960: swaps(&c.majorVersion, n);
961: swaps(&c.minorVersion, n);
962: swaps(&c.length, n);
963: }
964:
965: #ifdef ISOCONN
966: (void)SWrite(newconn, (char *)&c, sizeof(xConnSetupPrefix));
967: #else /* ISOCONN */
968: write(newconn, (char *)&c, sizeof(xConnSetupPrefix));
969: #endif /* ISOCONN */
970: iov[0].iov_len = c.lengthReason;
971: iov[0].iov_base = reason;
972: iov[1].iov_len = padlength[c.lengthReason & 3];
973: iov[1].iov_base = p;
974: #ifdef ISOCONN
975: SWritev(newconn, iov, 2);
976: #else /* ISOCONN */
977: writev(newconn, iov, 2);
978: #endif /* ISOCONN */
979: if (debug_conns)
980: ErrorF("Didn't make connection:%s\n", reason);
981: }
982: #ifdef ISOCONN
983: SClose(newconn);
984: #else /* ISOCONN */
985: close(newconn);
986: #endif /* ISOCONN */
987: xfree(reason);
988: }
989:
990: }
991: }
992: readyconnections &= ~(1 << curconn);
993: }
994: }
995: }
996:
997: /************
998: * CloseDownFileDescriptor:
999: * Remove this file descriptor and it's inputbuffers, etc.
1000: ************/
1001:
1002: void
1003: CloseDownFileDescriptor(connection)
1004: int connection;
1005: {
1006: #ifdef ISOCONN
1007: struct TSAPdisconnect tds;
1008: #ifdef ISODEBUG
1009: if (isodexbug)
1010: fprintf(stderr, "server: TDiscReq\n");
1011: #endif /* ISODEBUG */
1012: SClose(connection);
1013: #else /* ISOCONN */
1014: close(connection);
1015: #endif /* ISOCONN */
1016:
1017: if (inputBuffers[connection].size)
1018: {
1019: xfree(inputBuffers[connection].buffer);
1020: inputBuffers[connection].buffer = (char *) NULL;
1021: inputBuffers[connection].bufptr = (char *) NULL;
1022: inputBuffers[connection].size = 0;
1023: }
1024: inputBuffers[connection].bufcnt = 0;
1025: inputBuffers[connection].lenLastReq = 0;
1026: inputBuffers[connection].used = 0;
1027:
1028: BITCLEAR(AllSockets, connection);
1029: BITCLEAR(AllClients, connection);
1030: BITCLEAR(ClientsWithInput, connection);
1031: BITCLEAR(ClientsWriteBlocked, connection);
1032: if (!ANYSET(ClientsWriteBlocked))
1033: AnyClientsWriteBlocked = FALSE;
1034: }
1035:
1036: /*****************
1037: * CheckConections
1038: * Some connection has died, go find which one and shut it down
1039: * The file descriptor has been closed, but is still in AllClients.
1040: * If would truly be wonderful if select() would put the bogus
1041: * file descriptors in the exception mask, but nooooo. So we have
1042: * to check each and every socket individually.
1043: *****************/
1044:
1045: void
1046: CheckConnections()
1047: {
1048: long mask[mskcnt];
1049: long tmask[mskcnt];
1050: register int curclient;
1051: int i;
1052: struct timeval notime;
1053: ClientPtr bad;
1054: int r;
1055: #ifdef ISOCONN
1056: struct TSAPdisconnect tds;
1057: struct TSAPdisconnect *td = &tds;
1058: char *vec[4];
1059: int vecp;
1060: #endif /* ISOCONN */
1061:
1062: notime.tv_sec = 0;
1063: notime.tv_usec = 0;
1064:
1065: COPYBITS(AllClients, mask);
1066: for (i=0; i<mskcnt; i++)
1067: {
1068: while (mask[i])
1069: {
1070: curclient = ffs (mask[i]) - 1 + (i << 5);
1071: CLEARBITS(tmask);
1072: BITSET(tmask, curclient);
1073: #ifdef ISOCONN
1074: r = TNetAccept (&vecp, vec,
1075: curclient + 1, tmask, (int *)NULL, (int *)NULL,
1076: OK, td);
1077: if (r == NOTOK)
1078: {
1079: Error(TErrString(td->td_reason));
1080: Error("TNetAccept");
1081: #else /* ISOCONN */
1082: r = select (curclient + 1, tmask, (int *)NULL, (int *)NULL,
1083: ¬ime);
1084: if (r < 0)
1085: {
1086: #endif /* ISOCONN */
1087: if (bad = ConnectionTranslation[curclient])
1088: CloseDownClient(bad);
1089: else
1090: CloseDownFileDescriptor(curclient);
1091: }
1092: BITCLEAR(mask, curclient);
1093: }
1094: }
1095: }
1096:
1097:
1098: /*****************
1099: * CloseDownConnection
1100: * Delete client from AllClients and free resources
1101: *****************/
1102:
1103: CloseDownConnection(client)
1104: ClientPtr client;
1105: {
1106: OsCommPtr oc = (OsCommPtr)client->osPrivate;
1107:
1108: ConnectionTranslation[oc->fd] = (ClientPtr)NULL;
1109: CloseDownFileDescriptor(oc->fd);
1110: if (oc->buf != NULL) /* an Xrealloc may have returned NULL */
1111: xfree(oc->buf);
1112: xfree(client->osPrivate);
1113: }
1114:
1115:
1116: AddEnabledDevice(fd)
1117: int fd;
1118: {
1119: EnabledDevices |= (1<<fd);
1120: BITSET(AllSockets, fd);
1121: }
1122:
1123:
1124: RemoveEnabledDevice(fd)
1125: int fd;
1126: {
1127: EnabledDevices &= ~(1<<fd);
1128: BITCLEAR(AllSockets, fd);
1129: }
1130:
1131: /*****************
1132: * OnlyListenToOneClient:
1133: * Only accept requests from one client. Continue to handle new
1134: * connections, but don't take any protocol requests from the new
1135: * ones. Note that if GrabDone is set, EstablishNewConnections
1136: * needs to put new clients into SavedAllSockets and SavedAllClients.
1137: * Note also that there is no timeout for this in the protocol.
1138: * This routine is "undone" by ListenToAllClients()
1139: *****************/
1140:
1141: OnlyListenToOneClient(client)
1142: ClientPtr client;
1143: {
1144: OsCommPtr oc = (OsCommPtr)client->osPrivate;
1145: int connection = oc->fd;
1146:
1147: if (! GrabDone)
1148: {
1149: COPYBITS (ClientsWithInput, SavedClientsWithInput);
1150: BITCLEAR (SavedClientsWithInput, connection);
1151: if (GETBIT(ClientsWithInput, connection))
1152: {
1153: CLEARBITS(ClientsWithInput);
1154: BITSET(ClientsWithInput, connection);
1155: }
1156: else
1157: {
1158: CLEARBITS(ClientsWithInput);
1159: }
1160: COPYBITS(AllSockets, SavedAllSockets);
1161: COPYBITS(AllClients, SavedAllClients);
1162:
1163: UNSETBITS(AllSockets, AllClients);
1164: BITSET(AllSockets, connection);
1165: CLEARBITS(AllClients);
1166: BITSET(AllClients, connection);
1167: GrabDone = TRUE;
1168: }
1169: }
1170:
1171: /****************
1172: * ListenToAllClients:
1173: * Undoes OnlyListentToOneClient()
1174: ****************/
1175:
1176: ListenToAllClients()
1177: {
1178: if (GrabDone)
1179: {
1180: ORBITS(AllSockets, AllSockets, SavedAllSockets);
1181: ORBITS(AllClients, AllClients, SavedAllClients);
1182: ORBITS(ClientsWithInput, ClientsWithInput, SavedClientsWithInput);
1183: GrabDone = FALSE;
1184: }
1185: }
1186:
1187:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.