![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to XlibInt.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 XlibInt.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / X / client |
1.1 root 1: /*
2: * $XConsortium: XlibInt.c,v 11.90 88/09/30 17:25:18 jim Exp $
3: */
4:
5: #include "copyright.h"
6: /* Copyright Massachusetts Institute of Technology 1985, 1986, 1987 */
7:
8: /*
9: * XlibInternal.c - Internal support routines for the C subroutine
10: * interface library (Xlib) to the X Window System Protocol V11.0.
11: */
12: #define NEED_EVENTS
13: #define NEED_REPLIES
14:
15: #include <stdio.h>
16: #include "Xlibint.h"
17:
18: #ifdef ISOCONN
19: #include <isode/psap.h>
20: #include <isode/tsap.h>
21: #include <isode/isoservent.h>
22:
23: #endif /* ISOCONN */
24:
25: #ifdef CRAY
26:
27: /*
28: * Cray UniCOS does not have readv and writev so we emulate
29: */
30: #include <sys/socket.h>
31:
32: static int readv (fd, iov, iovcnt)
33: int fd;
34: struct iovec *iov;
35: int iovcnt;
36: {
37: struct msghdr hdr;
38:
39: hdr.msg_iov = iov;
40: hdr.msg_iovlen = iovcnt;
41: hdr.msg_accrights = 0;
42: hdr.msg_accrightslen = 0;
43: hdr.msg_name = 0;
44: hdr.msg_namelen = 0;
45:
46: return (recvmsg (fd, &hdr, 0));
47: }
48:
49: static int writev (fd, iov, iovcnt)
50: int fd;
51: struct iovec *iov;
52: int iovcnt;
53: {
54: struct msghdr hdr;
55:
56: hdr.msg_iov = iov;
57: hdr.msg_iovlen = iovcnt;
58: hdr.msg_accrights = 0;
59: hdr.msg_accrightslen = 0;
60: hdr.msg_name = 0;
61: hdr.msg_namelen = 0;
62:
63: return (sendmsg (fd, &hdr, 0));
64: }
65:
66: #endif /* CRAY */
67:
68: #ifdef ISOCONN
69: /*
70: * Need these Convenience routines to map IO to T-service
71: * XXX
72: * Should map error returns in td->td_reason into
73: * errno's appropriately...
74: */
75:
76: /*
77: * Check if any bytes queued that could be read...
78: */
79: TBytesReadable(fd, ptr)
80: int fd;
81: long *ptr;
82: {
83: struct TSAPdisconnect tds;
84: struct TSAPdisconnect *td = &tds;
85: int ret = TSelectOctets (fd, ptr, td);
86: if (ret == NOTOK) {
87: fprintf(stderr, "Client TBytesReadable: %s\n",
88: TErrString(td->td_reason));
89: }
90: return ret;
91: }
92:
93: /*
94: * need followinf for arg mismatch
95: */
96: UBytesReadable(fd, ptr)
97: int fd;
98: long *ptr;
99: {
100: return ioctl(fd, FIONREAD, ptr);
101: }
102:
103: /*
104: * Simple read from transport cx, client
105: */
106: TReadFromServer(fd, data, size)
107: int fd;
108: unsigned size;
109: char *data;
110: {
111: char *aptr = data;
112: struct TSAPdisconnect tds;
113: struct TSAPdisconnect *td = &tds;
114: static struct TSAPdata txs;
115: static struct TSAPdata *tx = &txs;
116: static struct qbuf *qb;
117: static char *qptr;
118: static int ingot, qcpy, result = 0;
119: int q2data, ret;
120:
121: #ifdef ISODEBUG
122: if (isodexbug) {
123: fprintf(stderr, "TReadFromServer %d want %d (%d buffered)\n",
124: fd, size, result);
125: }
126: #endif /* ISODEBUG */
127: if (result == 0) {
128: if ((ret = TReadRequest(fd, tx, OK, td)) == NOTOK) {
129: #ifdef ISODEBUG
130: if (errno == EWOULDBLOCK) {
131: fprintf(stderr, "Client TReadReq would block: %s\n",
132: TErrString(td->td_reason));
133: if (!DR_FATAL(td->td_reason))
134: errno = EWOULDBLOCK;
135: else
136: errno = EBADF;
137: return ret;
138: }
139: if (isodexbug)
140: fprintf(stderr, "Client TReadReq: %s\n",
141: TErrString(td->td_reason));
142: #endif /* ISODEBUG */
143: /*
144: * map problems here - eg fTimeOut...
145: */
146: if (td->td_reason == DR_TIMER)
147: errno = EWOULDBLOCK;
148: return ret;
149: }
150: result = tx->tx_cc;
151: qb = &(tx->tx_qbuf);
152: qptr = qb->qb_data;
153: #ifdef ISODEBUG
154: if (isodexbug)
155: fprintf(stderr, "TReadRequest want %d got %d\n",
156: size, result);
157: #endif
158: }
159: #ifdef ISODEBUG
160: else {
161: if (isodexbug)
162: fprintf(stderr, "TReadFromServer want %d buffered %d\n",
163: size, result);
164: }
165: #endif
166: /*
167: * Buffer it
168: */
169: ingot = 0;
170: aptr = data;
171: for(ingot = 0, aptr = data, q2data = min(size, result);
172: ingot<q2data;
173: aptr += qcpy, ingot+= qcpy) {
174: int aleft = q2data - ingot;
175: if (qb->qb_len > aleft) {
176: qcpy = aleft;
177: bcopy(qptr, aptr, qcpy);
178: qptr += aleft;
179: } else {
180: qcpy = qb->qb_len;
181: bcopy(qb->qb_data, aptr, qcpy);
182: if ((qb = qb->qb_forw) == NULL)
183: break;
184: qptr = qb->qb_data;
185: }
186: }
187: if ((result -= ingot) <= 0) {
188: result = 0;
189: TXFREE(tx);
190: }
191: return ingot;
192:
193: }
194:
195: /*
196: * Simple write on transport descriptor client
197: */
198: TWriteToServer(fd, data, size)
199: int fd;
200: unsigned size;
201: char *data;
202: {
203: struct TSAPdisconnect tds;
204: struct TSAPdisconnect *td = &tds;
205:
206: #ifdef ISODEBUG
207: if (isodexbug)
208: fprintf(stderr, "TWriteToServer %d: %d\n", fd, size);
209: #endif
210: if (TDataRequest(fd, data, size, td) == NOTOK) {
211: if (errno != EWOULDBLOCK)
212: fprintf(stderr, "Client TDataReq: %s\n",
213: TErrString(td->td_reason));
214: return -1;
215: } else
216: return size;
217: }
218:
219: /*
220: * This is really disgusting, as we do 2 copies - one qbuf into data,
221: * one data into iovecs...should really do something utterly neater or
222: * ask mtr to provide another T-Service interface for pre-alloced
223: * bufs - ideally iovec style
224: *
225: * or change the structure of X to do async...
226: */
227: TReadvFromServer(fd, iov, iovcnt)
228: int fd, iovcnt;
229: struct iovec *iov;
230: {
231: int i, size, result, left, bcp;
232: char *data, *dp;
233: struct iovec *iovp;
234:
235: for(i=0, size = 0, iovp = iov; i < iovcnt; i++, iovp++)
236: size += iovp->iov_len;
237:
238: #ifdef ISODEBUG
239: if (isodexbug)
240: fprintf(stderr, "TReadvFromServer %d, want %d\n", fd, size);
241: #endif
242: if ((data = Xmalloc(size)) == NULL) {
243: #ifdef ISODEBUG
244: if (isodexbug)
245: fprintf(stderr, "TReadvFromServer, malloc failed\n");
246: #endif
247: /*
248: * Could map to EWOULDBLOCK...?
249: */
250: return(-1);
251: }
252:
253: /*
254: * Note, TReadFromServer is written to *NOT* return more than size
255: */
256: if ((result = TReadFromServer(fd, data, size)) == NOTOK) {
257: if (errno != EWOULDBLOCK)
258: fprintf(stderr, "TReadvReq err\n");
259: return(-1);
260: }
261:
262: left = result;
263: dp = data;
264: while (left > 0) {
265: bcp = iov->iov_len;
266: if (bcp > left )
267: bcp = left;
268: bcopy(dp, iov->iov_base, bcp);
269: if (bcp < left)
270: iov++;
271: dp += bcp;
272: left -= bcp;
273: }
274: Xfree(data);
275: return result;
276: }
277:
278: /*
279: * scatter gather write to transport descriptor
280: */
281: TWritevToServer(fd, iov, iovcnt)
282: int fd, iovcnt;
283: struct iovec *iov;
284: {
285: struct TSAPdisconnect tds;
286: struct TSAPdisconnect *td = &tds;
287: struct udvec uv[64], *uvp;
288: int i, ret, tot = 0;
289:
290: /*
291: * Yuck needs dynamicising, or else rely on
292: * iov's being same as uv's
293: */
294: if (iovcnt >= 64) {
295: fprintf(stderr, "Very Bad News i am afraid\n");
296: return -99;
297: }
298: for (i=0, uvp = uv; i<iovcnt; uvp++, iov++, i++) {
299: uvp->uv_base = iov->iov_base;
300: uvp->uv_len = iov->iov_len;
301: tot += uvp->uv_len;
302: }
303: #ifdef ISODEBUG
304: if (isodexbug)
305: fprintf(stderr, "TWritevToServer %d: %d\n",fd, tot);
306: #endif
307: uv[iovcnt].uv_base = NULLCP;
308: uv[iovcnt].uv_len = 0;
309: if ((ret = TWriteRequest(fd, uv, td)) == NOTOK) {
310: if (errno != EWOULDBLOCK)
311: fprintf(stderr, "Client TReadReq: %s\n", TErrString(td->td_reason));
312: return -1;
313: }
314: return tot;
315: }
316:
317: TDiscFromServer(fd)
318: int fd;
319: {
320: struct TSAPdisconnect tds;
321: struct TSAPdisconnect *td = &tds;
322:
323: if (TDiscRequest(fd, NULLCP, 0, td) == NOTOK)
324: fprintf(stderr, "TDR failed %s\n", TErrString(td->td_reason));
325: }
326:
327: #endif /* ISOCONN */
328:
329: /*
330: * The following routines are internal routines used by Xlib for protocol
331: * packet transmission and reception.
332: *
333: * XIOError(Display *) will be called if any sort of system call error occurs.
334: * This is assumed to be a fatal condition, i.e., XIOError should not return.
335: *
336: * XError(Display *, XErrorEvent *) will be called whenever an X_Error event is
337: * received. This is not assumed to be a fatal condition, i.e., it is
338: * acceptable for this procedure to return. However, XError should NOT
339: * perform any operations (directly or indirectly) on the DISPLAY.
340: *
341: * Routines declared with a return type of 'Status' return 0 on failure,
342: * and non 0 on success. Routines with no declared return type don't
343: * return anything. Whenever possible routines that create objects return
344: * the object they have created.
345: */
346:
347: _XQEvent *_qfree = NULL; /* NULL _XQEvent. */
348:
349: static int padlength[4] = {0, 3, 2, 1};
350: /* lookup table for adding padding bytes to data that is read from
351: or written to the X socket. */
352:
353: static xReq _dummy_request = {
354: 0, 0, 0
355: };
356: /*
357: * _XFlush - Flush the X request buffer. If the buffer is empty, no
358: * action is taken. This routine correctly handles incremental writes.
359: * This routine may have to be reworked if int < long.
360: */
361: _XFlush (dpy)
362: register Display *dpy;
363: {
364: register long size, todo;
365: register int write_stat;
366: register char *bufindex;
367:
368: size = todo = dpy->bufptr - dpy->buffer;
369: bufindex = dpy->bufptr = dpy->buffer;
370: /*
371: * While write has not written the entire buffer, keep looping
372: * until the entire buffer is written. bufindex will be incremented
373: * and size decremented as buffer is written out.
374: */
375: while (size) {
376: errno = 0;
377: write_stat = WriteToServer(dpy->fd, bufindex, (int) todo);
378: if (write_stat >= 0) {
379: size -= write_stat;
380: todo = size;
381: bufindex += write_stat;
382: #ifdef EWOULDBLOCK
383: } else if (errno == EWOULDBLOCK) {
384: _XWaitForWritable(dpy);
385: #endif
386: #ifdef SUNSYSV
387: } else if (errno == 0) {
388: _XWaitForWritable(dpy);
389: #endif
390: #ifdef EMSGSIZE
391: } else if (errno == EMSGSIZE) {
392: todo >>= 1;
393: #endif
394: } else {
395: /* Write failed! */
396: /* errno set by write system call. */
397: (*_XIOErrorFunction)(dpy);
398: }
399: }
400: dpy->last_req = (char *)&_dummy_request;
401: }
402:
403: int
404: _XEventsQueued (dpy, mode)
405: register Display *dpy;
406: int mode;
407: {
408: register int len;
409: int pend;
410: char buf[BUFSIZE];
411: register xReply *rep;
412:
413: if (mode == QueuedAfterFlush)
414: _XFlush(dpy);
415: if (BytesReadable(dpy->fd, (char *) &pend) < 0)
416: (*_XIOErrorFunction)(dpy);
417: if ((len = pend) < SIZEOF(xReply))
418: return(dpy->qlen); /* _XFlush can enqueue events */
419: else if (len > BUFSIZE)
420: len = BUFSIZE;
421: len /= SIZEOF(xReply);
422: pend = len * SIZEOF(xReply);
423: _XRead (dpy, buf, (long) pend);
424:
425: /* no space between comma and type or else macro will die */
426: STARTITERATE (rep,xReply, buf, (len > 0), len--) {
427: if (rep->generic.type == X_Error)
428: _XError(dpy, (xError *)rep);
429: else /* must be an event packet */
430: _XEnq(dpy, (xEvent *) rep);
431: }
432: ENDITERATE
433: return(dpy->qlen);
434: }
435:
436: /* _XReadEvents - Flush the output queue,
437: * then read as many events as possible (but at least 1) and enqueue them
438: */
439: _XReadEvents(dpy)
440: register Display *dpy;
441: {
442: char buf[BUFSIZE];
443: long pend_not_register; /* because can't "&" a register variable */
444: register long pend;
445: register xEvent *ev;
446: Bool not_yet_flushed = True;
447:
448: do {
449: /* find out how much data can be read */
450: if (BytesReadable(dpy->fd, (char *) &pend_not_register) < 0)
451: (*_XIOErrorFunction)(dpy);
452: pend = pend_not_register;
453:
454: /* must read at least one xEvent; if none is pending, then
455: we'll just flush and block waiting for it */
456: if (pend < SIZEOF(xEvent)) {
457: pend = SIZEOF(xEvent);
458: /* don't flush until we block the first time */
459: if (not_yet_flushed) {
460: int qlen = dpy->qlen;
461: _XFlush (dpy);
462: if (qlen != dpy->qlen) return;
463: not_yet_flushed = False;
464: }
465: }
466:
467: /* but we won't read more than the max buffer size */
468: if (pend > BUFSIZE)
469: pend = BUFSIZE;
470:
471: /* round down to an integral number of XReps */
472: pend = (pend / SIZEOF(xEvent)) * SIZEOF(xEvent);
473:
474: _XRead (dpy, buf, pend);
475:
476: /* no space between comma and type or else macro will die */
477: STARTITERATE (ev,xEvent, buf, (pend > 0),
478: pend -= SIZEOF(xEvent)) {
479: if (ev->u.u.type == X_Error)
480: _XError (dpy, (xError *) ev);
481: else /* it's an event packet; enqueue it */
482: _XEnq (dpy, ev);
483: }
484: ENDITERATE
485: } while (dpy->head == NULL);
486: }
487:
488: /*
489: * _XRead - Read bytes from the socket taking into account incomplete
490: * reads. This routine may have to be reworked if int < long.
491: */
492: _XRead (dpy, data, size)
493: register Display *dpy;
494: register char *data;
495: register long size;
496: {
497: register long bytes_read;
498:
499: if (size == 0) return;
500: errno = 0;
501: while ((bytes_read = ReadFromServer(dpy->fd, data, (int)size))
502: != size) {
503:
504: if (bytes_read > 0) {
505: size -= bytes_read;
506: data += bytes_read;
507: }
508: #ifdef EWOULDBLOCK
509: else if (errno == EWOULDBLOCK) {
510: _XWaitForReadable(dpy);
511: errno = 0;
512: }
513: #endif
514: #ifdef SUNSYSV
515: else if (errno == 0) {
516: _XWaitForReadable(dpy);
517: }
518: #endif
519: else if (bytes_read == 0) {
520: /* Read failed because of end of file! */
521: errno = EPIPE;
522: (*_XIOErrorFunction)(dpy);
523: }
524:
525: else /* bytes_read is less than 0; presumably -1 */ {
526: /* If it's a system call interrupt, it's not an error. */
527: if (errno != EINTR)
528: (*_XIOErrorFunction)(dpy);
529: }
530: }
531: }
532:
533: #ifdef WORD64
534:
535: /*
536: * XXX This is a *really* stupid way of doing this....
537: */
538:
539: #define PACKBUFFERSIZE 4096
540:
541:
542: /*
543: * _XRead32 - Read bytes from the socket unpacking each 32 bits
544: * into a long (64 bits on a CRAY computer).
545: *
546: */
547: static _doXRead32 (dpy, data, size, packbuffer)
548: register Display *dpy;
549: register long *data;
550: register long size;
551: register char *packbuffer;
552: {
553: long *lpack,*lp;
554: long mask32 = 0x00000000ffffffff;
555: long maskw, nwords, i, bits;
556:
557: _XReadPad (dpy, packbuffer, size);
558:
559: lp = data;
560: lpack = (long *) packbuffer;
561: nwords = size >> 2;
562: bits = 32;
563:
564: for(i=0;i<nwords;i++){
565: maskw = mask32 << bits;
566: *lp++ = ( *lpack & maskw ) >> bits;
567: bits = bits ^32;
568: if(bits){
569: lpack++;
570: }
571: }
572: }
573:
574: _XRead32 (dpy, data, len)
575: Display *dpy;
576: long *data;
577: long len;
578: {
579: char packbuffer[PACKBUFFERSIZE];
580: unsigned nwords = (PACKBUFFERSIZE >> 2); /* bytes to CARD32 */
581:
582: for (; len > nwords; len -= nwords, data += nwords) {
583: _doXRead32 (dpy, data, nwords, packbuffer);
584: }
585: _doXRead32 (dpy, data, len, packbuffer);
586: }
587:
588:
589:
590: /*
591: * _XRead16 - Read bytes from the socket unpacking each 16 bits
592: * into a long (64 bits on a CRAY computer).
593: *
594: */
595: static _doXRead16 (dpy, data, size, packbuffer)
596: register Display *dpy;
597: register short *data;
598: register long size;
599: char *packbuffer;
600: {
601: long *lpack,*lp;
602: long mask16 = 0x000000000000ffff;
603: long maskw, nwords, i, bits;
604:
605: _XRead(dpy,packbuffer,size); /* don't do a padded read... */
606:
607: lp = (long *) data;
608: lpack = (long *) packbuffer;
609: nwords = size >> 1; /* number of 16 bit words to be unpacked */
610: bits = 48;
611: for(i=0;i<nwords;i++){
612: maskw = mask16 << bits;
613: *lp++ = ( *lpack & maskw ) >> bits;
614: bits -= 16;
615: if(bits < 0){
616: lpack++;
617: bits = 48;
618: }
619: }
620: }
621:
622: _XRead16 (dpy, data, len)
623: Display *dpy;
624: short *data;
625: long len;
626: {
627: char packbuffer[PACKBUFFERSIZE];
628: unsigned nwords = (PACKBUFFERSIZE >> 1); /* bytes to CARD16 */
629:
630: for (; len > nwords; len -= nwords, data += nwords) {
631: _doXRead16 (dpy, data, nwords, packbuffer);
632: }
633: _doXRead16 (dpy, data, len, packbuffer);
634: }
635:
636: _XRead16Pad (dpy, data, size)
637: Display *dpy;
638: short *data;
639: long size;
640: {
641: int slop = (size & 3);
642: short slopbuf[3];
643:
644: _XRead16 (dpy, data, size);
645: if (slop > 0) {
646: _XRead16 (dpy, slopbuf, 4 - slop);
647: }
648: }
649: #endif /* WORD64 */
650:
651:
652: /*
653: * _XReadPad - Read bytes from the socket taking into account incomplete
654: * reads. If the number of bytes is not 0 mod 32, read additional pad
655: * bytes. This routine may have to be reworked if int < long.
656: */
657: _XReadPad (dpy, data, size)
658: register Display *dpy;
659: register char *data;
660: register long size;
661: {
662: register long bytes_read;
663: struct iovec iov[2];
664: char pad[3];
665:
666: if (size == 0) return;
667: iov[0].iov_len = (int)size;
668: iov[0].iov_base = data;
669: /*
670: * The following hack is used to provide 32 bit long-word
671: * aligned padding. The [1] vector is of length 0, 1, 2, or 3,
672: * whatever is needed.
673: */
674:
675: iov[1].iov_len = padlength[size & 3];
676: iov[1].iov_base = pad;
677: size += iov[1].iov_len;
678:
679: errno = 0;
680: while ((bytes_read = ReadvFromServer (dpy->fd, iov, 2)) != size) {
681:
682: if (bytes_read > 0) {
683: size -= bytes_read;
684: if ((iov[0].iov_len -= bytes_read) < 0) {
685: iov[1].iov_len += iov[0].iov_len;
686: iov[1].iov_base -= iov[0].iov_len;
687: iov[0].iov_len = 0;
688: }
689: else
690: iov[0].iov_base += bytes_read;
691: }
692: #ifdef EWOULDBLOCK
693: else if (errno == EWOULDBLOCK) {
694: _XWaitForReadable(dpy);
695: errno = 0;
696: }
697: #endif
698: #ifdef SUNSYSV
699: else if (errno == 0) {
700: _XWaitForReadable(dpy);
701: }
702: #endif
703: else if (bytes_read == 0) {
704: /* Read failed because of end of file! */
705: errno = EPIPE;
706: (*_XIOErrorFunction)(dpy);
707: }
708:
709: else /* bytes_read is less than 0; presumably -1 */ {
710: /* If it's a system call interrupt, it's not an error. */
711: if (errno != EINTR)
712: (*_XIOErrorFunction)(dpy);
713: }
714: }
715:
716: }
717:
718: /*
719: * _XSend - Flush the buffer and send the client data. 32 bit word aligned
720: * transmission is used, if size is not 0 mod 4, extra bytes are transmitted.
721: * This routine may have to be reworked if int < long;
722: */
723: _XSend (dpy, data, size)
724: register Display *dpy;
725: char *data;
726: register long size;
727: {
728: struct iovec iov[3];
729: static char pad[3] = {0, 0, 0};
730: /* XText8 and XText16 require that the padding bytes be zero! */
731:
732: long skip = 0;
733: long total = (dpy->bufptr - dpy->buffer) + ((size + 3) & ~3);
734: long todo = total;
735:
736: while (total) {
737: long before = skip;
738: long remain = todo;
739: int i = 0;
740: long len;
741:
742: /* You could be very general here and have "in" and "out" iovecs
743: * and write a loop without using a macro, but what the heck
744: */
745:
746: #define InsertIOV(pointer, length) \
747: len = (length) - before; \
748: if (len > remain) \
749: len = remain; \
750: if (len <= 0) { \
751: before = -len; \
752: } else { \
753: iov[i].iov_len = len; \
754: iov[i].iov_base = (pointer) + before; \
755: i++; \
756: remain -= len; \
757: before = 0; \
758: }
759:
760: InsertIOV(dpy->buffer, dpy->bufptr - dpy->buffer)
761: InsertIOV(data, size)
762: /* Provide 32-bit aligned padding as necessary */
763: InsertIOV(pad, padlength[size & 3])
764:
765: errno = 0;
766: if ((len = WritevToServer(dpy->fd, iov, i)) >= 0) {
767: skip += len;
768: total -= len;
769: todo = total;
770: #ifdef EWOULDBLOCK
771: } else if (errno == EWOULDBLOCK) {
772: _XWaitForWritable(dpy);
773: #endif
774: #ifdef SUNSYSV
775: } else if (errno == 0) {
776: _XWaitForWritable(dpy);
777: #endif
778: #ifdef EMSGSIZE
779: } else if (errno == EMSGSIZE) {
780: todo = todo >> 1;
781: #endif
782: } else {
783: (*_XIOErrorFunction)(dpy);
784: }
785: }
786:
787: dpy->bufptr = dpy->buffer;
788: dpy->last_req = (char *) & _dummy_request;
789: }
790:
791: /*
792: * _XAllocID - normal resource ID allocation routine. A client
793: * can roll his own and instatantiate it if he wants, but must
794: * follow the rules.
795: */
796: XID _XAllocID(dpy)
797: register Display *dpy;
798: {
799: return (dpy->resource_base + (dpy->resource_id++ << dpy->resource_shift));
800: }
801:
802: /*
803: * The hard part about this is that we only get 16 bits from a reply. Well,
804: * then, we have three values that will march along, with the following
805: * invariant:
806: * dpy->last_request_read <= rep->sequenceNumber <= dpy->request
807: * The right choice for rep->sequenceNumber is the largest that
808: * still meets these constraints.
809: */
810: static unsigned long
811: _SetLastRequestRead(dpy, rep)
812: register Display *dpy;
813: register xGenericReply *rep;
814: {
815: register unsigned long newseq, lastseq;
816:
817: /*
818: * KeymapNotify has no sequence number, but is always guaranteed
819: * to immediately follow another event, except when generated via
820: * SendEvent (hmmm).
821: */
822: if ((rep->type & 0x7f) == KeymapNotify)
823: return(dpy->last_request_read);
824:
825: newseq = (dpy->last_request_read & ~((unsigned long)0xffff)) |
826: rep->sequenceNumber;
827: lastseq = dpy->last_request_read;
828: while (newseq < lastseq) {
829: newseq += 0x10000;
830: if (newseq > dpy->request) {
831: (void) fprintf (stderr,
832: "Xlib: sequence lost (0x%lx > 0x%lx) in reply type 0x%x!\n",
833: newseq, dpy->request,
834: (unsigned int) rep->type);
835: newseq -= 0x10000;
836: break;
837: }
838: }
839:
840: dpy->last_request_read = newseq;
841: return(newseq);
842: }
843:
844: /*
845: * _XReply - Wait for a reply packet and copy its contents into the
846: * specified rep. Mean while we must handle error and event packets that
847: * we may encounter.
848: */
849: Status _XReply (dpy, rep, extra, discard)
850: register Display *dpy;
851: register xReply *rep;
852: int extra; /* number of 32-bit words expected after the reply */
853: Bool discard; /* should I discard data followind "extra" words? */
854: {
855: /* Pull out the serial number now, so that (currently illegal) requests
856: * generated by an error handler don't confuse us.
857: */
858: unsigned long cur_request = dpy->request;
859:
860: _XFlush(dpy);
861: while (1) {
862: _XRead(dpy, (char *)rep, (long)SIZEOF(xReply));
863: switch ((int)rep->generic.type) {
864:
865: case X_Reply:
866: /* Reply received. Fast update for synchronous replies,
867: * but deal with multiple outstanding replies.
868: */
869: if (rep->generic.sequenceNumber == (cur_request & 0xffff))
870: dpy->last_request_read = cur_request;
871: else
872: (void) _SetLastRequestRead(dpy, &rep->generic);
873: if (extra == 0) {
874: if (discard && (rep->generic.length > 0))
875: /* unexpectedly long reply! */
876: _EatData (dpy, rep->generic.length);
877: return (1);
878: }
879: if (extra == rep->generic.length) {
880: /*
881: * Read the extra data into storage immediately following
882: * the GenericReply structure.
883: */
884: _XRead (dpy, NEXTPTR(rep,xReply), ((long)extra) << 2);
885: return (1);
886: }
887: if (extra < rep->generic.length) {
888: /* Actual reply is longer than "extra" */
889: _XRead (dpy, NEXTPTR(rep,xReply), ((long)extra) << 2);
890: if (discard)
891: _EatData (dpy, rep->generic.length - extra);
892: return (1);
893: }
894: /*
895: *if we get here, then extra > rep->generic.length--meaning we
896: * read a reply that's shorter than we expected. This is an
897: * error, but we still need to figure out how to handle it...
898: */
899: _XRead (dpy, NEXTPTR(rep,xReply),
900: ((long) rep->generic.length) << 2);
901: (*_XIOErrorFunction) (dpy);
902: return (0);
903:
904: case X_Error:
905: {
906: register _XExtension *ext;
907: register Bool ret = False;
908: int ret_code;
909: xError *err = (xError *) rep;
910: unsigned long serial;
911:
912: serial = _SetLastRequestRead(dpy, (xGenericReply *)rep);
913: if (serial == cur_request)
914: /* do not die on "no such font", "can't allocate",
915: "can't grab" failures */
916: switch ((int)err->errorCode) {
917: case BadName:
918: switch (err->majorCode) {
919: case X_OpenFont:
920: case X_LookupColor:
921: case X_AllocNamedColor:
922: return(0);
923: }
924: break;
925: case BadFont:
926: if (err->majorCode == X_QueryFont)
927: return (0);
928: break;
929: case BadAlloc:
930: case BadAccess:
931: return (0);
932: /*
933: * we better see if there is an extension who may
934: * want to suppress the error.
935: */
936: default:
937: ext = dpy->ext_procs;
938: while (ext) {
939: if (ext->error != NULL)
940: ret = (*ext->error)
941: (dpy, err, &ext->codes, &ret_code);
942: ext = ext->next;
943: }
944: if (ret) return (ret_code);
945: break;
946: }
947: _XError(dpy, err);
948: if (serial == cur_request)
949: return(0);
950: }
951: break;
952: default:
953: _XEnq(dpy, (xEvent *) rep);
954: break;
955: }
956: }
957: }
958:
959:
960: /* Read and discard "n" 32-bit words. */
961:
962: static _EatData (dpy, n)
963: Display *dpy;
964: unsigned long n;
965: {
966: unsigned int bufsize;
967: char *buf;
968: n <<= 2; /* convert to number of bytes */
969: buf = Xmalloc (bufsize = (n > 2048) ? 2048 : n);
970: while (n) {
971: long bytes_read = (n > bufsize) ? bufsize : n;
972: _XRead (dpy, buf, bytes_read);
973: n -= bytes_read;
974: }
975: Xfree (buf);
976: }
977:
978: /*
979: * _XEnq - Place event packets on the display's queue.
980: * note that no squishing of move events in V11, since there
981: * is pointer motion hints....
982: */
983: _XEnq (dpy, event)
984: register Display *dpy;
985: register xEvent *event;
986: {
987: register _XQEvent *qelt;
988:
989: /*NOSTRICT*/
990: if (qelt = _qfree) {
991: /* If _qfree is non-NULL do this, else malloc a new one. */
992: _qfree = qelt->next;
993: }
994: else if ((qelt =
995: (_XQEvent *) Xmalloc((unsigned)sizeof(_XQEvent))) == NULL) {
996: /* Malloc call failed! */
997: errno = ENOMEM;
998: (*_XIOErrorFunction)(dpy);
999: }
1000: qelt->next = NULL;
1001: /* go call through display to find proper event reformatter */
1002: if ((*dpy->event_vec[event->u.u.type & 0177])(dpy, &qelt->event, event)) {
1003: if (dpy->tail) dpy->tail->next = qelt;
1004: else dpy->head = qelt;
1005:
1006: dpy->tail = qelt;
1007: dpy->qlen++;
1008: } else {
1009: /* ignored, or stashed away for many-to-one compression */
1010: qelt->next = _qfree;
1011: _qfree = qelt;
1012: }
1013: }
1014: /*
1015: * EventToWire in seperate file in that often not needed.
1016: */
1017:
1018: /*ARGSUSED*/
1019: Bool
1020: _XUnknownWireEvent(dpy, re, event)
1021: register Display *dpy; /* pointer to display structure */
1022: register XEvent *re; /* pointer to where event should be reformatted */
1023: register xEvent *event; /* wire protocol event */
1024: {
1025: #ifdef notdef
1026: (void) fprintf(stderr,
1027: "Xlib: unhandled wire event! event number = %d, display = %x\n.",
1028: event->u.u.type, dpy);
1029: #endif
1030: return(False);
1031: }
1032:
1033: /*ARGSUSED*/
1034: Status
1035: _XUnknownNativeEvent(dpy, re, event)
1036: register Display *dpy; /* pointer to display structure */
1037: register XEvent *re; /* pointer to where event should be reformatted */
1038: register xEvent *event; /* wire protocol event */
1039: {
1040: #ifdef notdef
1041: (void) fprintf(stderr,
1042: "Xlib: unhandled native event! event number = %d, display = %x\n.",
1043: re->type, dpy);
1044: #endif
1045: return(0);
1046: }
1047: /*
1048: * reformat a wire event into an XEvent structure of the right type.
1049: */
1050: Bool
1051: _XWireToEvent(dpy, re, event)
1052: register Display *dpy; /* pointer to display structure */
1053: register XEvent *re; /* pointer to where event should be reformatted */
1054: register xEvent *event; /* wire protocol event */
1055: {
1056:
1057: re->type = event->u.u.type & 0x7f;
1058: ((XAnyEvent *)re)->serial = _SetLastRequestRead(dpy,
1059: (xGenericReply *)event);
1060: ((XAnyEvent *)re)->send_event = ((event->u.u.type & 0x80) != 0);
1061: ((XAnyEvent *)re)->display = dpy;
1062:
1063: /* Ignore the leading bit of the event type since it is set when a
1064: client sends an event rather than the server. */
1065:
1066: switch (event-> u.u.type & 0177) {
1067: case KeyPress:
1068: case KeyRelease:
1069: {
1070: register XKeyEvent *ev = (XKeyEvent*) re;
1071: ev->root = event->u.keyButtonPointer.root;
1072: ev->window = event->u.keyButtonPointer.event;
1073: ev->subwindow = event->u.keyButtonPointer.child;
1074: ev->time = event->u.keyButtonPointer.time;
1075: ev->x = event->u.keyButtonPointer.eventX;
1076: ev->y = event->u.keyButtonPointer.eventY;
1077: ev->x_root = event->u.keyButtonPointer.rootX;
1078: ev->y_root = event->u.keyButtonPointer.rootY;
1079: ev->state = event->u.keyButtonPointer.state;
1080: ev->same_screen = event->u.keyButtonPointer.sameScreen;
1081: ev->keycode = event->u.u.detail;
1082: }
1083: break;
1084: case ButtonPress:
1085: case ButtonRelease:
1086: {
1087: register XButtonEvent *ev = (XButtonEvent *) re;
1088: ev->root = event->u.keyButtonPointer.root;
1089: ev->window = event->u.keyButtonPointer.event;
1090: ev->subwindow = event->u.keyButtonPointer.child;
1091: ev->time = event->u.keyButtonPointer.time;
1092: ev->x = event->u.keyButtonPointer.eventX;
1093: ev->y = event->u.keyButtonPointer.eventY;
1094: ev->x_root = event->u.keyButtonPointer.rootX;
1095: ev->y_root = event->u.keyButtonPointer.rootY;
1096: ev->state = event->u.keyButtonPointer.state;
1097: ev->same_screen = event->u.keyButtonPointer.sameScreen;
1098: ev->button = event->u.u.detail;
1099: }
1100: break;
1101: case MotionNotify:
1102: {
1103: register XMotionEvent *ev = (XMotionEvent *)re;
1104: ev->root = event->u.keyButtonPointer.root;
1105: ev->window = event->u.keyButtonPointer.event;
1106: ev->subwindow = event->u.keyButtonPointer.child;
1107: ev->time = event->u.keyButtonPointer.time;
1108: ev->x = event->u.keyButtonPointer.eventX;
1109: ev->y = event->u.keyButtonPointer.eventY;
1110: ev->x_root = event->u.keyButtonPointer.rootX;
1111: ev->y_root = event->u.keyButtonPointer.rootY;
1112: ev->state = event->u.keyButtonPointer.state;
1113: ev->same_screen = event->u.keyButtonPointer.sameScreen;
1114: ev->is_hint = event->u.u.detail;
1115: }
1116: break;
1117: case EnterNotify:
1118: case LeaveNotify:
1119: {
1120: register XCrossingEvent *ev = (XCrossingEvent *) re;
1121: ev->root = event->u.enterLeave.root;
1122: ev->window = event->u.enterLeave.event;
1123: ev->subwindow = event->u.enterLeave.child;
1124: ev->time = event->u.enterLeave.time;
1125: ev->x = event->u.enterLeave.eventX;
1126: ev->y = event->u.enterLeave.eventY;
1127: ev->x_root = event->u.enterLeave.rootX;
1128: ev->y_root = event->u.enterLeave.rootY;
1129: ev->state = event->u.enterLeave.state;
1130: ev->mode = event->u.enterLeave.mode;
1131: ev->same_screen = (event->u.enterLeave.flags &
1132: ELFlagSameScreen) && True;
1133: ev->focus = (event->u.enterLeave.flags &
1134: ELFlagFocus) && True;
1135: ev->detail = event->u.u.detail;
1136: }
1137: break;
1138: case FocusIn:
1139: case FocusOut:
1140: {
1141: register XFocusChangeEvent *ev = (XFocusChangeEvent *) re;
1142: ev->window = event->u.focus.window;
1143: ev->mode = event->u.focus.mode;
1144: ev->detail = event->u.u.detail;
1145: }
1146: break;
1147: case KeymapNotify:
1148: {
1149: register XKeymapEvent *ev = (XKeymapEvent *) re;
1150: ev->window = dpy->current;
1151: bcopy ((char *)((xKeymapEvent *) event)->map,
1152: &ev->key_vector[1],
1153: sizeof (((xKeymapEvent *) event)->map));
1154: }
1155: break;
1156: case Expose:
1157: {
1158: register XExposeEvent *ev = (XExposeEvent *) re;
1159: ev->window = event->u.expose.window;
1160: ev->x = event->u.expose.x;
1161: ev->y = event->u.expose.y;
1162: ev->width = event->u.expose.width;
1163: ev->height = event->u.expose.height;
1164: ev->count = event->u.expose.count;
1165: }
1166: break;
1167: case GraphicsExpose:
1168: {
1169: register XGraphicsExposeEvent *ev =
1170: (XGraphicsExposeEvent *) re;
1171: ev->drawable = event->u.graphicsExposure.drawable;
1172: ev->x = event->u.graphicsExposure.x;
1173: ev->y = event->u.graphicsExposure.y;
1174: ev->width = event->u.graphicsExposure.width;
1175: ev->height = event->u.graphicsExposure.height;
1176: ev->count = event->u.graphicsExposure.count;
1177: ev->major_code = event->u.graphicsExposure.majorEvent;
1178: ev->minor_code = event->u.graphicsExposure.minorEvent;
1179: }
1180: break;
1181: case NoExpose:
1182: {
1183: register XNoExposeEvent *ev = (XNoExposeEvent *) re;
1184: ev->drawable = event->u.noExposure.drawable;
1185: ev->major_code = event->u.noExposure.majorEvent;
1186: ev->minor_code = event->u.noExposure.minorEvent;
1187: }
1188: break;
1189: case VisibilityNotify:
1190: {
1191: register XVisibilityEvent *ev = (XVisibilityEvent *) re;
1192: ev->window = event->u.visibility.window;
1193: ev->state = event->u.visibility.state;
1194: }
1195: break;
1196: case CreateNotify:
1197: {
1198: register XCreateWindowEvent *ev =
1199: (XCreateWindowEvent *) re;
1200: ev->window = event->u.createNotify.window;
1201: ev->parent = event->u.createNotify.parent;
1202: ev->x = event->u.createNotify.x;
1203: ev->y = event->u.createNotify.y;
1204: ev->width = event->u.createNotify.width;
1205: ev->height = event->u.createNotify.height;
1206: ev->border_width = event->u.createNotify.borderWidth;
1207: ev->override_redirect = event->u.createNotify.override;
1208: }
1209: break;
1210: case DestroyNotify:
1211: {
1212: register XDestroyWindowEvent *ev =
1213: (XDestroyWindowEvent *) re;
1214: ev->window = event->u.destroyNotify.window;
1215: ev->event = event->u.destroyNotify.event;
1216: }
1217: break;
1218: case UnmapNotify:
1219: {
1220: register XUnmapEvent *ev = (XUnmapEvent *) re;
1221: ev->window = event->u.unmapNotify.window;
1222: ev->event = event->u.unmapNotify.event;
1223: ev->from_configure = event->u.unmapNotify.fromConfigure;
1224: }
1225: break;
1226: case MapNotify:
1227: {
1228: register XMapEvent *ev = (XMapEvent *) re;
1229: ev->window = event->u.mapNotify.window;
1230: ev->event = event->u.mapNotify.event;
1231: ev->override_redirect = event->u.mapNotify.override;
1232: }
1233: break;
1234: case MapRequest:
1235: {
1236: register XMapRequestEvent *ev = (XMapRequestEvent *) re;
1237: ev->window = event->u.mapRequest.window;
1238: ev->parent = event->u.mapRequest.parent;
1239: }
1240: break;
1241: case ReparentNotify:
1242: {
1243: register XReparentEvent *ev = (XReparentEvent *) re;
1244: ev->event = event->u.reparent.event;
1245: ev->window = event->u.reparent.window;
1246: ev->parent = event->u.reparent.parent;
1247: ev->x = event->u.reparent.x;
1248: ev->y = event->u.reparent.y;
1249: ev->override_redirect = event->u.reparent.override;
1250: }
1251: break;
1252: case ConfigureNotify:
1253: {
1254: register XConfigureEvent *ev = (XConfigureEvent *) re;
1255: ev->event = event->u.configureNotify.event;
1256: ev->window = event->u.configureNotify.window;
1257: ev->above = event->u.configureNotify.aboveSibling;
1258: ev->x = event->u.configureNotify.x;
1259: ev->y = event->u.configureNotify.y;
1260: ev->width = event->u.configureNotify.width;
1261: ev->height = event->u.configureNotify.height;
1262: ev->border_width = event->u.configureNotify.borderWidth;
1263: ev->override_redirect = event->u.configureNotify.override;
1264: }
1265: break;
1266: case ConfigureRequest:
1267: {
1268: register XConfigureRequestEvent *ev =
1269: (XConfigureRequestEvent *) re;
1270: ev->window = event->u.configureRequest.window;
1271: ev->parent = event->u.configureRequest.parent;
1272: ev->above = event->u.configureRequest.sibling;
1273: ev->x = event->u.configureRequest.x;
1274: ev->y = event->u.configureRequest.y;
1275: ev->width = event->u.configureRequest.width;
1276: ev->height = event->u.configureRequest.height;
1277: ev->border_width = event->u.configureRequest.borderWidth;
1278: ev->value_mask = event->u.configureRequest.valueMask;
1279: ev->detail = event->u.u.detail;
1280: }
1281: break;
1282: case GravityNotify:
1283: {
1284: register XGravityEvent *ev = (XGravityEvent *) re;
1285: ev->window = event->u.gravity.window;
1286: ev->event = event->u.gravity.event;
1287: ev->x = event->u.gravity.x;
1288: ev->y = event->u.gravity.y;
1289: }
1290: break;
1291: case ResizeRequest:
1292: {
1293: register XResizeRequestEvent *ev =
1294: (XResizeRequestEvent *) re;
1295: ev->window = event->u.resizeRequest.window;
1296: ev->width = event->u.resizeRequest.width;
1297: ev->height = event->u.resizeRequest.height;
1298: }
1299: break;
1300: case CirculateNotify:
1301: {
1302: register XCirculateEvent *ev = (XCirculateEvent *) re;
1303: ev->window = event->u.circulate.window;
1304: ev->event = event->u.circulate.event;
1305: ev->place = event->u.circulate.place;
1306: }
1307: break;
1308: case CirculateRequest:
1309: {
1310: register XCirculateRequestEvent *ev =
1311: (XCirculateRequestEvent *) re;
1312: ev->window = event->u.circulate.window;
1313: ev->parent = event->u.circulate.event;
1314: ev->place = event->u.circulate.place;
1315: }
1316: break;
1317: case PropertyNotify:
1318: {
1319: register XPropertyEvent *ev = (XPropertyEvent *) re;
1320: ev->window = event->u.property.window;
1321: ev->atom = event->u.property.atom;
1322: ev->time = event->u.property.time;
1323: ev->state = event->u.property.state;
1324: }
1325: break;
1326: case SelectionClear:
1327: {
1328: register XSelectionClearEvent *ev =
1329: (XSelectionClearEvent *) re;
1330: ev->window = event->u.selectionClear.window;
1331: ev->selection = event->u.selectionClear.atom;
1332: ev->time = event->u.selectionClear.time;
1333: }
1334: break;
1335: case SelectionRequest:
1336: {
1337: register XSelectionRequestEvent *ev =
1338: (XSelectionRequestEvent *) re;
1339: ev->owner = event->u.selectionRequest.owner;
1340: ev->requestor = event->u.selectionRequest.requestor;
1341: ev->selection = event->u.selectionRequest.selection;
1342: ev->target = event->u.selectionRequest.target;
1343: ev->property = event->u.selectionRequest.property;
1344: ev->time = event->u.selectionRequest.time;
1345: }
1346: break;
1347: case SelectionNotify:
1348: {
1349: register XSelectionEvent *ev = (XSelectionEvent *) re;
1350: ev->requestor = event->u.selectionNotify.requestor;
1351: ev->selection = event->u.selectionNotify.selection;
1352: ev->target = event->u.selectionNotify.target;
1353: ev->property = event->u.selectionNotify.property;
1354: ev->time = event->u.selectionNotify.time;
1355: }
1356: break;
1357: case ColormapNotify:
1358: {
1359: register XColormapEvent *ev = (XColormapEvent *) re;
1360: ev->window = event->u.colormap.window;
1361: ev->colormap = event->u.colormap.colormap;
1362: ev->new = event->u.colormap.new;
1363: ev->state = event->u.colormap.state;
1364: }
1365: break;
1366: case ClientMessage:
1367: {
1368: register int i;
1369: register XClientMessageEvent *ev
1370: = (XClientMessageEvent *) re;
1371: ev->window = event->u.clientMessage.window;
1372: ev->format = event->u.u.detail;
1373: switch (ev->format) {
1374: case 8:
1375: ev->message_type = event->u.clientMessage.u.b.type;
1376: for (i = 0; i < 20; i++)
1377: ev->data.b[i] = event->u.clientMessage.u.b.bytes[i];
1378: break;
1379: case 16:
1380: ev->message_type = event->u.clientMessage.u.s.type;
1381: ev->data.s[0] = event->u.clientMessage.u.s.shorts0;
1382: ev->data.s[1] = event->u.clientMessage.u.s.shorts1;
1383: ev->data.s[2] = event->u.clientMessage.u.s.shorts2;
1384: ev->data.s[3] = event->u.clientMessage.u.s.shorts3;
1385: ev->data.s[4] = event->u.clientMessage.u.s.shorts4;
1386: ev->data.s[5] = event->u.clientMessage.u.s.shorts5;
1387: ev->data.s[6] = event->u.clientMessage.u.s.shorts6;
1388: ev->data.s[7] = event->u.clientMessage.u.s.shorts7;
1389: ev->data.s[8] = event->u.clientMessage.u.s.shorts8;
1390: ev->data.s[9] = event->u.clientMessage.u.s.shorts9;
1391: break;
1392: case 32:
1393: ev->message_type = event->u.clientMessage.u.l.type;
1394: ev->data.l[0] = event->u.clientMessage.u.l.longs0;
1395: ev->data.l[1] = event->u.clientMessage.u.l.longs1;
1396: ev->data.l[2] = event->u.clientMessage.u.l.longs2;
1397: ev->data.l[3] = event->u.clientMessage.u.l.longs3;
1398: ev->data.l[4] = event->u.clientMessage.u.l.longs4;
1399: break;
1400: default: /* XXX should never occur */
1401: break;
1402: }
1403: }
1404: break;
1405: case MappingNotify:
1406: {
1407: register XMappingEvent *ev = (XMappingEvent *)re;
1408: ev->first_keycode = event->u.mappingNotify.firstKeyCode;
1409: ev->request = event->u.mappingNotify.request;
1410: ev->count = event->u.mappingNotify.count;
1411: }
1412: break;
1413: default:
1414: return(_XUnknownWireEvent(dpy, re, event));
1415: }
1416: return(True);
1417: }
1418:
1419:
1420: static char *_SysErrorMsg (n)
1421: int n;
1422: {
1423: extern char *sys_errlist[];
1424: extern int sys_nerr;
1425: char *s = ((n >= 0 && n < sys_nerr) ? sys_errlist[n] : "unknown error");
1426:
1427: return (s ? s : "no such error");
1428: }
1429:
1430: /*
1431: * _XIOError - Default fatal system error reporting routine. Called when
1432: * an X internal system error is encountered.
1433: */
1434: _XIOError (dpy)
1435: Display *dpy;
1436: {
1437: (void) fprintf (stderr,
1438: "XIO: fatal IO error %d (%s) on X server \"%s\"\r\n",
1439: errno, _SysErrorMsg (errno), DisplayString (dpy));
1440: (void) fprintf (stderr,
1441: " after %lu requests (%lu known processed) with %d events remaining.\r\n",
1442: NextRequest(dpy) - 1, LastKnownRequestProcessed(dpy),
1443: QLength(dpy));
1444:
1445: if (errno == EPIPE) {
1446: (void) fprintf (stderr,
1447: " The connection was probably broken by a server shutdown or KillClient.\r\n");
1448: }
1449:
1450: exit (1);
1451: }
1452:
1453: /*
1454: * _XError - Default non-fatal error reporting routine. Called when an
1455: * X_Error packet is encountered in the input stream.
1456: */
1457: int _XError (dpy, rep)
1458: Display *dpy;
1459: xError *rep;
1460: {
1461: XErrorEvent event;
1462: /*
1463: * X_Error packet encountered! We need to unpack the error before
1464: * giving it to the user.
1465: */
1466:
1467: event.display = dpy;
1468: event.type = X_Error;
1469: event.serial = _SetLastRequestRead(dpy, (xGenericReply *)rep);
1470: event.resourceid = rep->resourceID;
1471: event.error_code = rep->errorCode;
1472: event.request_code = rep->majorCode;
1473: event.minor_code = rep->minorCode;
1474: if (_XErrorFunction != NULL) {
1475: return ((*_XErrorFunction)(dpy, &event));
1476: }
1477: exit(1);
1478: /*NOTREACHED*/
1479: }
1480:
1481: int _XPrintDefaultError (dpy, event, fp)
1482: Display *dpy;
1483: XErrorEvent *event;
1484: FILE *fp;
1485: {
1486: char buffer[BUFSIZ];
1487: char mesg[BUFSIZ];
1488: char number[32];
1489: char *mtype = "XlibMessage";
1490: XGetErrorText(dpy, event->error_code, buffer, BUFSIZ);
1491: XGetErrorDatabaseText(dpy, mtype, "XError", "X Error", mesg, BUFSIZ);
1492: (void) fprintf(fp, "%s: %s\n ", mesg, buffer);
1493: XGetErrorDatabaseText(dpy, mtype, "MajorCode", "Request Major code %d",
1494: mesg, BUFSIZ);
1495: (void) fprintf(fp, mesg, event->request_code);
1496: sprintf(number, "%d", event->request_code);
1497: XGetErrorDatabaseText(dpy, "XRequest", number, "", buffer, BUFSIZ);
1498: (void) fprintf(fp, " (%s)", buffer);
1499: fputs("\n ", fp);
1500: XGetErrorDatabaseText(dpy, mtype, "MinorCode", "Request Minor code",
1501: mesg, BUFSIZ);
1502: (void) fprintf(fp, mesg, event->minor_code);
1503: fputs("\n ", fp);
1504: XGetErrorDatabaseText(dpy, mtype, "ResourceID", "ResourceID 0x%x",
1505: mesg, BUFSIZ);
1506: (void) fprintf(fp, mesg, event->resourceid);
1507: fputs("\n ", fp);
1508: XGetErrorDatabaseText(dpy, mtype, "ErrorSerial", "Error Serial #%d",
1509: mesg, BUFSIZ);
1510: (void) fprintf(fp, mesg, event->serial);
1511: fputs("\n ", fp);
1512: XGetErrorDatabaseText(dpy, mtype, "CurrentSerial", "Current Serial #%d",
1513: mesg, BUFSIZ);
1514: (void) fprintf(fp, mesg, dpy->request);
1515: fputs("\n", fp);
1516: if (event->error_code == BadImplementation) return 0;
1517: return 1;
1518: }
1519:
1520: int _XDefaultError(dpy, event)
1521: Display *dpy;
1522: XErrorEvent *event;
1523: {
1524: if (_XPrintDefaultError (dpy, event, stderr) == 0) return 0;
1525: exit(1);
1526: /*NOTREACHED*/
1527: }
1528:
1529: int (*_XIOErrorFunction)() = _XIOError;
1530: int (*_XErrorFunction)() = _XDefaultError;
1531:
1532: /*
1533: * This routine can be used to (cheaply) get some memory within a single
1534: * Xlib routine for scratch space. It is reallocated from the same place
1535: * each time, unless the library needs a large scratch space.
1536: */
1537: char *_XAllocScratch (dpy, nbytes)
1538: register Display *dpy;
1539: unsigned long nbytes;
1540: {
1541: if (nbytes > dpy->scratch_length) {
1542: if (dpy->scratch_buffer != NULL) Xfree (dpy->scratch_buffer);
1543: return( dpy->scratch_length = nbytes,
1544: dpy->scratch_buffer = Xmalloc ((unsigned)nbytes) );
1545: }
1546: return (dpy->scratch_buffer);
1547: }
1548:
1549: /*
1550: * Given a visual id, find the visual structure for this id on this display.
1551: */
1552: Visual *_XVIDtoVisual (dpy, id)
1553: Display *dpy;
1554: VisualID id;
1555: {
1556: register int i, j, k;
1557: register Screen *sp;
1558: register Depth *dp;
1559: register Visual *vp;
1560: for (i = 0; i < dpy->nscreens; i++) {
1561: sp = &dpy->screens[i];
1562: for (j = 0; j < sp->ndepths; j++) {
1563: dp = &sp->depths[j];
1564: for (k = 0; k < dp->nvisuals; k++) {
1565: vp = &dp->visuals[k];
1566: if (vp->visualid == id) return (vp);
1567: }
1568: }
1569: }
1570: return (NULL);
1571: }
1572:
1573: XFree (data)
1574: char *data;
1575: {
1576: Xfree (data);
1577: }
1578:
1579: #ifdef DataRoutineIsProcedure
1580: void Data (dpy, data, len)
1581: Display *dpy;
1582: char *data;
1583: long len;
1584: {
1585: if (dpy->bufptr + (len) <= dpy->bufmax) {
1586: bcopy(data, dpy->bufptr, (int)len);
1587: dpy->bufptr += ((len) + 3) & ~3;
1588: } else {
1589: _XSend(dpy, data, len);
1590: }
1591: }
1592: #endif /* DataRoutineIsProcedure */
1593:
1594:
1595: #ifdef WORD64
1596:
1597: /*
1598: * XXX This is a *really* stupid way of doing this. It should just use
1599: * dpy->bufptr directly, taking into account where in the word it is.
1600: */
1601:
1602: /*
1603: * Data16 - Place 16 bit data in the buffer.
1604: *
1605: * "dpy" is a pointer to a Display.
1606: * "data" is a pointer to the data.
1607: * "len" is the length in bytes of the data.
1608: */
1609:
1610: static doData16(dpy, data, len, packbuffer)
1611: register Display *dpy;
1612: short *data;
1613: unsigned len;
1614: char *packbuffer;
1615: {
1616: long *lp,*lpack;
1617: long i, nwords,bits;
1618: long mask16 = 0x000000000000ffff;
1619:
1620: lp = (long *)data;
1621: lpack = (long *)packbuffer;
1622: *lpack = 0;
1623:
1624: /* nwords is the number of 16 bit values to be packed,
1625: * the low order 16 bits of each word will be packed
1626: * into 64 bit words
1627: */
1628: nwords = len >> 1;
1629: bits = 48;
1630:
1631: for(i=0;i<nwords;i++){
1632: *lpack ^= (*lp & mask16) << bits;
1633: bits -= 16 ;
1634: lp++;
1635: if(bits < 0){
1636: lpack++;
1637: *lpack = 0;
1638: bits = 48;
1639: }
1640: }
1641: Data(dpy, packbuffer, len);
1642: }
1643:
1644: Data16 (dpy, data, len)
1645: Display *dpy;
1646: short *data;
1647: unsigned len;
1648: {
1649: char packbuffer[PACKBUFFERSIZE];
1650: unsigned nwords = (PACKBUFFERSIZE >> 1); /* bytes to CARD16 */
1651:
1652: for (; len > nwords; len -= nwords, data += nwords) {
1653: doData16 (dpy, data, nwords, packbuffer);
1654: }
1655: doData16 (dpy, data, len, packbuffer);
1656: }
1657:
1658: /*
1659: * Data32 - Place 32 bit data in the buffer.
1660: *
1661: * "dpy" is a pointer to a Display.
1662: * "data" is a pointer to the data.
1663: * "len" is the length in bytes of the data.
1664: */
1665:
1666: static doData32 (dpy, data, len, packbuffer)
1667: register Display *dpy;
1668: long *data;
1669: unsigned len;
1670: char *packbuffer;
1671: {
1672: long *lp,*lpack;
1673: long i,bits,nwords;
1674: long mask32 = 0x00000000ffffffff;
1675:
1676: lpack = (long *) packbuffer;
1677: lp = data;
1678:
1679: *lpack = 0;
1680:
1681: /* nwords is the number of 32 bit values to be packed
1682: * the low order 32 bits of each word will be packed
1683: * into 64 bit words
1684: */
1685: nwords = len >> 2;
1686: bits = 32;
1687:
1688: for(i=0;i<nwords;i++){
1689: *lpack ^= (*lp & mask32) << bits;
1690: bits = bits ^32;
1691: lp++;
1692: if(bits){
1693: lpack++;
1694: *lpack = 0;
1695: }
1696: }
1697: Data(dpy, packbuffer, len);
1698: }
1699:
1700: Data32 (dpy, data, len)
1701: Display *dpy;
1702: short *data;
1703: unsigned len;
1704: {
1705: char packbuffer[PACKBUFFERSIZE];
1706: unsigned nwords = (PACKBUFFERSIZE >> 2); /* bytes to CARD32 */
1707:
1708: for (; len > nwords; len -= nwords, data += nwords) {
1709: doData32 (dpy, data, nwords, packbuffer);
1710: }
1711: doData32 (dpy, data, len, packbuffer);
1712: }
1713:
1714: #endif /* WORD64 */
1715:
1716:
1717:
1718: /*
1719: * _XFreeQ - free the queue of events, called by XCloseDisplay when there are
1720: * no more displays left on the display list
1721: */
1722:
1723: void _XFreeQ ()
1724: {
1725: register _XQEvent *qelt = _qfree;
1726:
1727: while (qelt) {
1728: register _XQEvent *qnext = qelt->next;
1729: Xfree (qelt);
1730: qelt = qnext;
1731: }
1732: _qfree = NULL;
1733: return;
1734: }
1735:
1736:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.