![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to XConnDis.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 / client|
Return to XConnDis.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / X / client |
1.1 root 1: #include "copyright.h"
2: /* $XConsortium: XConnDis.c,v 11.36 88/09/16 11:09:34 jim Exp $ */
3: /* Copyright Massachusetts Institute of Technology 1985, 1986 */
4: #define NEED_EVENTS
5: /*
6: * THIS IS AN OS DEPENDENT FILE! It should work on 4.2BSD derived
7: * systems. VMS and System V should plan to have their own version.
8: */
9: #include <stdio.h>
10: #include <X11/Xos.h>
11: #include "Xlibint.h"
12: #include <sys/socket.h>
13: #ifndef hpux
14: #include <netinet/tcp.h>
15: #endif
16:
17: #ifdef hpux
18: #include <sys/utsname.h>
19: #endif
20:
21: #ifdef UNIXCONN
22: #include <sys/un.h>
23: #ifndef X_UNIX_PATH
24: #define X_UNIX_PATH "/tmp/.X11-unix/X"
25: #endif /* X_UNIX_PATH */
26: #endif /* UNIXCONN */
27: void bcopy();
28:
29: #ifdef ISOCONN
30: #include <isode/psap.h>
31: #include <isode/tsap.h>
32: #include <isode/isoservent.h>
33:
34: #ifdef ISODEBUG
35: extern char *isodetcpath;
36:
37: int isodexbug = 0;
38: #endif /* ISODEBUG */
39: #endif /* ISOCONN */
40:
41: #ifdef ISOCONN
42:
43: /*
44: * array of fd 2 family map so we can lookup right function below...
45: * Its initialised at connection setup...
46: */
47: int fd2family[MAXSOCKS];
48: /*
49: * Globals for storing functions appropos each fd/socket type
50: * UNIX_IO (0) map to sys calls
51: * ISODE_IO (1) maps to my fns...
52: */
53: extern int read(), TReadFromServer();
54: int (*readfn[])() =
55: {
56: read, TReadFromServer
57: };
58: extern int write(), TWriteToServer();
59: int (*writefn[])() =
60: {
61: write, TWriteToServer
62: };
63: extern int readv(), TReadvFromServer();
64: int (*readvfn[])() =
65: {
66: readv, TReadvFromServer
67: };
68: extern writev(), TWritevToServer();
69: int (*writevfn[])() =
70: {
71: writev, TWritevToServer
72: };
73: extern int UBytesReadable(), TBytesReadable();
74: int (*ioctlfn[])() =
75: {
76: UBytesReadable, TBytesReadable
77: };
78: extern int close(), TDiscFromServer();
79: int (*closefn[])() =
80: {
81: close, TDiscFromServer
82: };
83:
84: static
85: int iso_conn(server)
86: char *server;
87: {
88: struct TSAPconnect tcs;
89: struct TSAPconnect *tc = &tcs;
90: struct TSAPdisconnect tds;
91: struct TSAPdisconnect *td = &tds;
92: struct QOStype qo;
93: struct QOStype *qos = &qo;
94: AEI aei;
95: struct PSAPaddr *pa, rpa, *mpa, rmpa;
96: int ret;
97: char *x;
98: extern char *index();
99:
100: #ifdef ISODEBUG
101: isodetcpath = ISODEPATH;
102: #endif /* ISODEBUG */
103:
104: /*
105: * Get their TSAP from their AEI
106: */
107: if ((x = index(server, ':')) != NULL) {
108: *(x++) = '\0';
109: aei = str2aei(server, x);
110: } else {
111: aei = str2aei(server, DEFAULTTSERVICE);
112: }
113:
114: if (aei == NULLAEI) {
115: fprintf(stderr, "No AEI for %s\n", server);
116: return -1;
117: }
118:
119: if ((pa = aei2addr (aei)) == NULLPA) {
120: fprintf (stderr, "address translation failed");
121: return -1;
122: }
123: rpa = *pa; /* struct copy */
124: /*
125: * Get my address for completeness
126: */
127: mpa = NULLPA;
128: if (x != NULL)
129: aei = str2aei(TLocalHostName(), x);
130: else
131: aei = str2aei(TLocalHostName(), DEFAULTTSERVICE);
132: if (aei == NULLAEI) {
133: fprintf (stderr, "my AEI lookup failed %s\n",
134: TLocalHostName());
135: return -1;
136: }
137:
138: if ((mpa = aei2addr (aei)) == NULLPA) {
139: fprintf (stderr, "my address translation failed %s\n",
140: TLocalHostName());
141: return -1;
142: }
143:
144: rmpa = *mpa; /* struct copy */
145: /*
146: * No Xpedited required !
147: */
148: tc->tc_expedited = 0;
149: /*
150: * Just a guess - i dont understand
151: * the comment in the documentation about TSDUsizes
152: */
153: tc->tc_tsdusize = 16000;
154: tc->tc_cc = 0;
155: qos->qos_reliability = LOW_QUALITY; /* Well this is X after all */
156:
157: ret = TConnRequest(&(rmpa.pa_addr.sa_addr),
158: &(rpa.pa_addr.sa_addr),
159: 0, 0, NULLCP, qos, tc, td);
160:
161: /*
162: * Should map errors to perrors somehow???
163: */
164: if (ret == NOTOK) {
165: #ifdef ISODEBUG
166: if (isodexbug)
167: fprintf(stderr, "TCR Failed %s\n",
168: TErrString(td->td_reason));
169: #endif /* ISODEBUG */
170: return -1;
171: }
172: else {
173: #ifdef ISODEBUG
174: if (isodexbug)
175: fprintf(stderr, "client: isoconn ok\n");
176: #endif /* ISODEBUG */
177: ret = tc->tc_sd;
178: return ret;
179: }
180: }
181: #endif /* ISOCONN */
182:
183: /*
184: * Attempts to connect to server, given display name. Returns file descriptor
185: * (network socket) or -1 if connection fails. The expanded display name
186: * of the form hostname:number.screen ("::" if DECnet) is returned in a result
187: * parameter. The screen number to use is also returned.
188: */
189: int _XConnectDisplay (display_name, expanded_name, prop_name, screen_num)
190: char *display_name;
191: char *expanded_name; /* return */
192: char *prop_name; /* return */
193: int *screen_num; /* return */
194:
195: {
196: char displaybuf[256]; /* Display string buffer */
197: register char *display_ptr; /* Display string buffer pointer */
198: register char *numbuf_ptr; /* Server number buffer pointer */
199: char *screen_ptr; /* Pointer for locating screen num */
200: int display_num; /* Display number */
201: struct sockaddr_in inaddr; /* INET socket address. */
202: unsigned long hostinetaddr; /* result of inet_addr of arpa addr */
203: #ifdef UNIXCONN
204: struct sockaddr_un unaddr; /* UNIX socket address. */
205: #endif
206: struct sockaddr *addr; /* address to connect to */
207: struct hostent *host_ptr;
208: int addrlen; /* length of address */
209: extern char *getenv();
210: extern struct hostent *gethostbyname();
211: int fd; /* Network socket */
212: char numberbuf[16];
213: char *dot_ptr = NULL; /* Pointer to . before screen num */
214: #ifdef DNETCONN
215: int dnet = 0;
216: char objname[20];
217: extern int dnet_conn();
218: #endif
219: #ifdef ISOCONN
220: int isoconn = 0;
221: char isochar = 'X';
222:
223: /*
224: * ISO Host name are "host:T-Namenumber"
225: * T-Name = T (for TCP) or X (for X.25) should really be
226: * TP4 or TP0 whathaveyou
227: */
228: #endif /* ISOCONN */
229:
230: /*
231: * Find the ':' seperator and extract the hostname and the
232: * display number.
233: * NOTE - if DECnet is to be used, the display name is formatted
234: * as "host::number"
235: */
236: (void) strncpy(displaybuf, display_name, sizeof(displaybuf));
237: if ((display_ptr = SearchString(displaybuf,':')) == NULL) return (-1);
238: #ifdef DNETCONN
239: if (*(display_ptr + 1) == ':') {
240: dnet++;
241: *(display_ptr++) = '\0';
242: }
243: #endif
244: #ifdef ISOCONN
245: if ((*(display_ptr + 1) == 'X') || (*(display_ptr + 1) == 'T')) {
246: isochar = *(display_ptr + 1);
247: isoconn++;
248: *(display_ptr++) = '\0';
249: }
250: #endif /* ISOCONN */
251: *(display_ptr++) = '\0';
252:
253: /* displaybuf now contains only a null-terminated host name, and
254: * display_ptr points to the display number.
255: * If the display number is missing there is an error. */
256:
257: if (*display_ptr == '\0') return(-1);
258:
259: /*
260: * Build a string of the form <display-number>.<screen-number> in
261: * numberbuf, using ".0" as the default.
262: */
263: screen_ptr = display_ptr; /* points to #.#.propname */
264: numbuf_ptr = numberbuf; /* beginning of buffer */
265: while (*screen_ptr != '\0') {
266: if (*screen_ptr == '.') { /* either screen or prop */
267: if (dot_ptr) { /* then found prop_name */
268: screen_ptr++;
269: break;
270: }
271: dot_ptr = numbuf_ptr; /* found screen_num */
272: *(screen_ptr++) = '\0';
273: *(numbuf_ptr++) = '.';
274: } else {
275: *(numbuf_ptr++) = *(screen_ptr++);
276: }
277: }
278:
279: /*
280: * If the spec doesn't include a screen number, add ".0" (or "0" if
281: * only "." is present.)
282: */
283: if (dot_ptr == NULL) { /* no screen num or prop */
284: dot_ptr = numbuf_ptr;
285: *(numbuf_ptr++) = '.';
286: *(numbuf_ptr++) = '0';
287: } else {
288: if (*(numbuf_ptr - 1) == '.')
289: *(numbuf_ptr++) = '0';
290: }
291: *numbuf_ptr = '\0';
292:
293: /*
294: * Return the screen number and property names in the result parameters
295: */
296: *screen_num = atoi(dot_ptr + 1);
297: strcpy (prop_name, screen_ptr);
298:
299: /*
300: * Convert the server number string to an integer.
301: */
302: display_num = atoi(display_ptr);
303:
304: /*
305: * If the display name is missing, use current host.
306: */
307: if (displaybuf[0] == '\0')
308: #ifdef DNETCONN
309: if (dnet)
310: (void) strcpy (displaybuf, "0");
311: else
312: #endif
313: #ifdef UNIXCONN
314: ; /* Do nothing if UNIX DOMAIN. Will be handled below. */
315: #else
316: #ifdef hpux
317: /*
318: * same host name crock as in server and xinit.
319: */
320: {
321: struct utsname name;
322:
323: uname(&name);
324: strcpy(displaybuf, name.nodename);
325: }
326: #else
327: (void) gethostname (displaybuf, sizeof(displaybuf));
328: #endif /* hpux */
329: #endif /* UNIXCONN else TCPCONN (assumed) */
330:
331: #ifdef DNETCONN
332: if (dnet) {
333: /*
334: * build the target object name.
335: */
336: sprintf(objname, "X$X%d", display_num);
337: /*
338: * Attempt to open the DECnet connection, return -1 if fails.
339: */
340: if ((fd = dnet_conn(displaybuf,
341: objname, SOCK_STREAM, 0, 0, 0, 0)) < 0)
342: return(-1); /* errno set by dnet_conn. */
343: #ifdef ISOCONN
344: else
345: fd2family[fd] = UNIX_IO;
346: #endif /* ISOCONN */
347:
348: } else
349: #endif
350: #ifdef ISOCONN
351: if (isoconn) {
352: if ((fd = iso_conn(displaybuf)) < 0)
353: return(-1);
354: else
355: fd2family[fd] = ISODE_IO;
356: } else
357: #endif
358: {
359: #ifdef UNIXCONN
360: if ((displaybuf[0] == '\0') ||
361: (strcmp("unix", displaybuf) == 0)) {
362: /* Connect locally using Unix domain. */
363: unaddr.sun_family = AF_UNIX;
364: (void) strcpy(unaddr.sun_path, X_UNIX_PATH);
365: strcat(unaddr.sun_path, display_ptr);
366: addr = (struct sockaddr *) &unaddr;
367: addrlen = strlen(unaddr.sun_path) + 2;
368: /*
369: * Open the network connection.
370: */
371: if ((fd = socket((int) addr->sa_family, SOCK_STREAM, 0)) < 0)
372: return(-1); /* errno set by system call. */
373: } else
374: #endif
375: {
376: /* Get the statistics on the specified host. */
377: hostinetaddr = inet_addr (displaybuf);
378: if (hostinetaddr == -1) {
379: if ((host_ptr = gethostbyname(displaybuf)) == NULL) {
380: /* No such host! */
381: errno = EINVAL;
382: return(-1);
383: }
384: /* Check the address type for an internet host. */
385: if (host_ptr->h_addrtype != AF_INET) {
386: /* Not an Internet host! */
387: errno = EPROTOTYPE;
388: return(-1);
389: }
390:
391: /* Set up the socket data. */
392: inaddr.sin_family = host_ptr->h_addrtype;
393: #if defined(CRAY) && defined(OLDTCP)
394: /* Only Cray UNICOS3 and UNICOS4 will define this */
395: {
396: long t;
397: bcopy((char *)host_ptr->h_addr,
398: (char *)&t,
399: sizeof(inaddr.sin_addr));
400: inaddr.sin_addr = t;
401: }
402: #else
403: bcopy((char *)host_ptr->h_addr,
404: (char *)&inaddr.sin_addr,
405: sizeof(inaddr.sin_addr));
406: #endif /* CRAY and OLDTCP */
407: } else {
408: #if defined(CRAY) && defined(OLDTCP)
409: /* Only Cray UNICOS3 and UNICOS4 will define this */
410: inaddr.sin_addr = hostinetaddr;
411: #else
412: inaddr.sin_addr.s_addr = hostinetaddr;
413: #endif /* CRAY and OLDTCP */
414: inaddr.sin_family = AF_INET;
415: }
416: addr = (struct sockaddr *) &inaddr;
417: addrlen = sizeof (struct sockaddr_in);
418: inaddr.sin_port = display_num;
419: inaddr.sin_port += X_TCP_PORT;
420: inaddr.sin_port = htons(inaddr.sin_port);
421: /*
422: * Open the network connection.
423: */
424:
425: if ((fd = socket((int) addr->sa_family, SOCK_STREAM, 0)) < 0)
426: return(-1); /* errno set by system call. */
427: #ifdef ISOCONN
428: fd2family[fd] = UNIX_IO;
429: #endif /* ISOCONN */
430: /* make sure to turn off TCP coalescence */
431: #ifdef TCP_NODELAY
432: {
433: int mi = 1;
434: setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, &mi, sizeof (int));
435: }
436: #endif
437: }
438:
439:
440: if (connect(fd, addr, addrlen) == -1) {
441: (void) close (fd);
442: return(-1); /* errno set by system call. */
443: }
444: }
445:
446: #ifdef ISOCONN
447: if (!isoconn) {
448: #endif /* ISOCONN */
449: /*
450: * Not required for ISO T-Service
451: */
452: /*
453: * set it non-blocking. This is so we can read data when blocked
454: * for writing in the library.
455: */
456: #ifdef FIOSNBIO
457: {
458: int arg = 1;
459: ioctl(fd, FIOSNBIO, &arg);
460: }
461: #else
462: (void) fcntl(fd, F_SETFL, FNDELAY);
463: #endif /* FIOSNBIO */
464:
465: #ifdef ISOCONN
466: }
467: #endif /* ISOCONN */
468: /*
469: * Return the id if the connection succeeded. Rebuild the expanded
470: * spec and return it in the result parameter.
471: */
472: display_ptr = displaybuf-1;
473: while (*(++display_ptr) != '\0')
474: ;
475: *(display_ptr++) = ':';
476: #ifdef DNETCONN
477: if (dnet)
478: *(display_ptr++) = ':';
479: #endif
480: #ifdef ISOCONN
481: if (isoconn) {
482: *(display_ptr++) = isochar;
483: }
484: #endif
485: numbuf_ptr = numberbuf;
486: while (*numbuf_ptr != '\0')
487: *(display_ptr++) = *(numbuf_ptr++);
488: if (prop_name[0] != '\0') {
489: char *cp;
490:
491: *(display_ptr++) = '.';
492: for (cp = prop_name; *cp; cp++) *(display_ptr++) = *cp;
493: }
494: *display_ptr = '\0';
495: (void) strcpy(expanded_name, displaybuf);
496: return(fd);
497:
498: }
499:
500: /*
501: * Disconnect from server.
502: */
503:
504: int _XDisconnectDisplay (server)
505:
506: int server;
507:
508: {
509: #ifdef ISOCONN
510: (void)CloseToServer(server);
511: #else /* ISOCONN */
512: (void) close(server);
513: #endif /* ISOCONN */
514: }
515:
516: #undef NULL
517: #define NULL ((char *) 0)
518: /*
519: * This is an OS dependent routine which:
520: * 1) returns as soon as the connection can be written on....
521: * 2) if the connection can be read, must enqueue events and handle errors,
522: * until the connection is writable.
523: */
524: _XWaitForWritable(dpy)
525: Display *dpy;
526: {
527: unsigned long r_mask[MSKCNT];
528: unsigned long w_mask[MSKCNT];
529: int nfound;
530:
531: CLEARBITS(r_mask);
532: CLEARBITS(w_mask);
533:
534: while (1) {
535: BITSET(r_mask, dpy->fd);
536: BITSET(w_mask, dpy->fd);
537:
538: do {
539: #ifdef ISOCONN
540: /*
541: * Note, we shouldnt get any connections to us as we're a client,
542: * But the elements of style say we should check...
543: * and of course, a TDR
544: */
545: int vecp;
546: char *vec[4];
547: struct TSAPdisconnect tds;
548: struct TSAPdisconnect *td = &tds;
549: nfound = TNetAccept(&vecp, vec, dpy->fd + 1, r_mask, w_mask,
550: NULL, NOTOK, td);
551: #ifdef ISODEBUG
552: if (nfound < 0) {
553: int sverrno = errno;
554: fprintf(stderr, "TNetAcc err %d %s\n", errno,
555: TErrString(td->td_reason));
556: errno = sverrno;
557: }
558: #endif /* ISODEBUG */
559: #ifdef ISODEBUG
560: if (vecp > 0) {
561: fprintf(stderr, "Weirdness, connect to a client?\n");
562: }
563: #endif
564: #else /* ISOCONN */
565: nfound = select (dpy->fd + 1, r_mask, w_mask, NULL, NULL);
566: #endif /* ISOCONN */
567: if (nfound < 0 && errno != EINTR)
568: (*_XIOErrorFunction)(dpy);
569: } while (nfound <= 0);
570:
571: if (ANYSET(r_mask)) {
572: char buf[BUFSIZE];
573: long pend_not_register;
574: register long pend;
575: register xEvent *ev;
576:
577: /* find out how much data can be read */
578: if (BytesReadable(dpy->fd, (char *) &pend_not_register) < 0)
579: (*_XIOErrorFunction)(dpy);
580: pend = pend_not_register;
581:
582: /* must read at least one xEvent; if none is pending, then
583: we'll just block waiting for it */
584: if (pend < SIZEOF(xEvent)) pend = SIZEOF(xEvent);
585:
586: /* but we won't read more than the max buffer size */
587: if (pend > BUFSIZE) pend = BUFSIZE;
588:
589: /* round down to an integral number of XReps */
590: pend = (pend / SIZEOF(xEvent)) * SIZEOF(xEvent);
591:
592: _XRead (dpy, buf, pend);
593:
594: /* no space between comma and type or else macro will die */
595: STARTITERATE (ev,xEvent, buf, (pend > 0),
596: (pend -= SIZEOF(xEvent))) {
597: if (ev->u.u.type == X_Error)
598: _XError (dpy, (xError *) ev);
599: else /* it's an event packet; enqueue it */
600: _XEnq (dpy, ev);
601: }
602: ENDITERATE
603: }
604: if (ANYSET(w_mask))
605: return;
606: }
607: }
608:
609:
610: _XWaitForReadable(dpy)
611: Display *dpy;
612: {
613: unsigned long r_mask[MSKCNT];
614: int result;
615:
616: CLEARBITS(r_mask);
617: do {
618: #ifdef ISOCONN
619: /*
620: * Note, we shouldnt get any connections to us as we're a client,
621: * But the elements of style say we should check...
622: * and of course, a TDR
623: */
624: int vecp;
625: char *vec[4];
626: struct TSAPdisconnect tds;
627: struct TSAPdisconnect *td = &tds;
628:
629: BITSET(r_mask, dpy->fd);
630: result = TNetAccept(&vecp, vec, dpy->fd + 1, r_mask, NULL, NULL,
631: NOTOK, td);
632: #else /* ISOCONN */
633: BITSET(r_mask, dpy->fd);
634: result = select(dpy->fd + 1, r_mask, NULL, NULL, NULL);
635: #endif /* ISOCONN */
636: if (result == -1 && errno != EINTR) (*_XIOErrorFunction)(dpy);
637: } while (result <= 0);
638: }
639:
640: static int padlength[4] = {0, 3, 2, 1};
641:
642: _XSendClientPrefix (dpy, client)
643: Display *dpy;
644: xConnClientPrefix *client;
645: {
646: /*
647: * Authorization string stuff.... Must always transmit multiple of 4
648: * bytes.
649: */
650:
651: char *auth_proto = "";
652: int auth_length;
653: char *auth_string = "";
654: int auth_strlen;
655: char pad[3];
656: char buffer[BUFSIZ], *bptr;
657:
658: int bytes=0;
659:
660: auth_length = strlen(auth_proto);
661: auth_strlen = strlen(auth_string);
662: client->nbytesAuthProto = auth_length;
663: client->nbytesAuthString = auth_strlen;
664:
665: bytes = (SIZEOF(xConnClientPrefix) +
666: auth_length + padlength[auth_length & 3] +
667: auth_strlen + padlength[auth_strlen & 3]);
668:
669: bcopy(client, buffer, SIZEOF(xConnClientPrefix));
670: bptr = buffer + SIZEOF(xConnClientPrefix);
671: if (auth_length)
672: {
673: bcopy(auth_proto, bptr, auth_length);
674: bptr += auth_length;
675: if (padlength[auth_length & 3])
676: {
677: bcopy(pad, bptr, padlength[auth_length & 3]);
678: bptr += padlength[auth_length & 3];
679: }
680: }
681: if (auth_strlen)
682: {
683: bcopy(auth_string, bptr, auth_strlen);
684: bptr += auth_strlen;
685: if (padlength[auth_strlen & 3])
686: {
687: bcopy(pad, bptr, padlength[auth_strlen & 3]);
688: bptr += padlength[auth_strlen & 3];
689: }
690: }
691: (void) WriteToServer(dpy->fd, buffer, bytes);
692: return;
693: }
694:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.