Initial revision

1 files changed, 537 insertions, 0 deletions

diff --git a/unix/tkUnixXId.c b/unix/tkUnixXId.c
new file mode 100644
index 0000000..f67c35c
--- /dev/null
+++ b/unix/tkUnixXId.c
@@ -0,0 +1,537 @@
+/* 
+ * tkUnixXId.c --
+ *
+ *	This file provides a replacement function for the default X
+ *	resource allocator (_XAllocID).  The problem with the default
+ *	allocator is that it never re-uses ids, which causes long-lived
+ *	applications to crash when X resource identifiers wrap around.
+ *	The replacement functions in this file re-use old identifiers
+ *	to prevent this problem.
+ *
+ *	The code in this file is based on similar implementations by
+ *	George C. Kaplan and Michael Hoegeman.
+ *
+ * Copyright (c) 1993 The Regents of the University of California.
+ * Copyright (c) 1994-1995 Sun Microsystems, Inc.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * SCCS: @(#) tkUnixXId.c 1.22 97/06/25 13:16:47
+ */
+
+/*
+ * The definition below is needed on some systems so that we can access
+ * the resource_alloc field of Display structures in order to replace
+ * the resource allocator.
+ */
+
+#define XLIB_ILLEGAL_ACCESS 1
+
+#include "tkInt.h"
+#include "tkPort.h"
+#include "tkUnixInt.h"
+
+/*
+ * A structure of the following type is used to hold one or more
+ * available resource identifiers.  There is a list of these structures
+ * for each display.
+ */
+
+#define IDS_PER_STACK 10
+typedef struct TkIdStack {
+    XID ids[IDS_PER_STACK];		/* Array of free identifiers. */
+    int numUsed;			/* Indicates how many of the entries
+					 * in ids are currently in use. */
+    TkDisplay *dispPtr;			/* Display to which ids belong. */
+    struct TkIdStack *nextPtr;		/* Next bunch of free identifiers
+					 * for the same display. */
+} TkIdStack;
+
+/*
+ * Forward declarations for procedures defined in this file:
+ */
+
+static XID		AllocXId _ANSI_ARGS_((Display *display));
+static Tk_RestrictAction CheckRestrictProc _ANSI_ARGS_((
+			    ClientData clientData, XEvent *eventPtr));
+static void		WindowIdCleanup _ANSI_ARGS_((ClientData clientData));
+static void		WindowIdCleanup2 _ANSI_ARGS_((ClientData clientData));
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkInitXId --
+ *
+ *	This procedure is called to initialize the id allocator for
+ *	a given display.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The official allocator for the display is set up to be Tk_AllocXID.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TkInitXId(dispPtr)
+    TkDisplay *dispPtr;			/* Tk's information about the
+					 * display. */
+{
+    dispPtr->idStackPtr = NULL;
+    dispPtr->defaultAllocProc = (XID (*) _ANSI_ARGS_((Display *display))) 
+            dispPtr->display->resource_alloc;
+    dispPtr->display->resource_alloc = AllocXId;
+    dispPtr->windowStackPtr = NULL;
+    dispPtr->idCleanupScheduled = 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * AllocXId --
+ *
+ *	This procedure is invoked by Xlib as the resource allocator
+ *	for a display.
+ *
+ * Results:
+ *	The return value is an X resource identifier that isn't currently
+ *	in use.
+ *
+ * Side effects:
+ *	The identifier is removed from the stack of free identifiers,
+ *	if it was previously on the stack.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static XID
+AllocXId(display)
+    Display *display;			/* Display for which to allocate. */
+{
+    TkDisplay *dispPtr;
+    TkIdStack *stackPtr;
+
+    /*
+     * Find Tk's information about the display.
+     */
+
+    dispPtr = TkGetDisplay(display);
+    
+    /*
+     * If the topmost chunk on the stack is empty then free it.  Then
+     * check for a free id on the stack and return it if it exists.
+     */
+
+    stackPtr = dispPtr->idStackPtr;
+    if (stackPtr != NULL) {
+	while (stackPtr->numUsed == 0) {
+	    dispPtr->idStackPtr = stackPtr->nextPtr;
+	    ckfree((char *) stackPtr);
+	    stackPtr = dispPtr->idStackPtr;
+	    if (stackPtr == NULL) {
+		goto defAlloc;
+	    }
+	}
+	stackPtr->numUsed--;
+	return stackPtr->ids[stackPtr->numUsed];
+    }
+
+    /*
+     * No free ids in the stack:  just get one from the default
+     * allocator.
+     */
+
+    defAlloc:
+    return (*dispPtr->defaultAllocProc)(display);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tk_FreeXId --
+ *
+ *	This procedure is called to indicate that an X resource identifier
+ *	is now free.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The identifier is added to the stack of free identifiers for its
+ *	display, so that it can be re-used.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tk_FreeXId(display, xid)
+    Display *display;			/* Display for which xid was
+					 * allocated. */
+    XID xid;				/* Identifier that is no longer
+					 * in use. */
+{
+    TkDisplay *dispPtr;
+    TkIdStack *stackPtr;
+
+    /*
+     * Find Tk's information about the display.
+     */
+
+    dispPtr = TkGetDisplay(display);
+
+    /*
+     * Add a new chunk to the stack if the current chunk is full.
+     */
+    
+    stackPtr = dispPtr->idStackPtr;
+    if ((stackPtr == NULL) || (stackPtr->numUsed >= IDS_PER_STACK)) {
+	stackPtr = (TkIdStack *) ckalloc(sizeof(TkIdStack));
+	stackPtr->numUsed = 0;
+	stackPtr->dispPtr = dispPtr;
+	stackPtr->nextPtr = dispPtr->idStackPtr;
+	dispPtr->idStackPtr = stackPtr;
+    }
+
+    /*
+     * Add the id to the current chunk.
+     */
+
+    stackPtr->ids[stackPtr->numUsed] = xid;
+    stackPtr->numUsed++;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkFreeWindowId --
+ *
+ *	This procedure is invoked instead of TkFreeXId for window ids.
+ *	See below for the reason why.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The id given by w will eventually be freed, so that it can be
+ *	reused for other resources.
+ *
+ * Design:
+ *	Freeing window ids is very tricky because there could still be
+ *	events pending for a window in the event queue (or even in the
+ *	server) at the time the window is destroyed.  If the window
+ *	id were to get reused immediately for another window, old
+ *	events could "drop in" on the new window, causing unexpected
+ *	behavior.
+ *
+ *	Thus we have to wait to re-use a window id until we know that
+ *	there are no events left for it.  Right now this is done in
+ *	two steps.  First, we wait until we know that the server
+ *	has seen the XDestroyWindow request, so we can be sure that
+ *	it won't generate more events for the window and that any
+ *	existing events are in our queue.  Second, we make sure that
+ *	there are no events whatsoever in our queue (this is conservative
+ *	but safe).
+ *
+ * 	The first step is done by remembering the request id of the
+ *	XDestroyWindow request and using LastKnownRequestProcessed to
+ *	see what events the server has processed.  If multiple windows
+ *	get destroyed at about the same time, we just remember the
+ *	most recent request number for any of them (again, conservative
+ *	but safe).
+ *
+ *	There are a few other complications as well.  When Tk destroys a
+ *	sub-tree of windows, it only issues a single XDestroyWindow call,
+ *	at the very end for the root of the subtree.  We can't free any of
+ *	the window ids until the final XDestroyWindow call.  To make sure
+ *	that this happens, we have to keep track of deletions in progress,
+ *	hence the need for the "destroyCount" field of the display.
+ *
+ *	One final problem.  Some servers, like Sun X11/News servers still
+ *	seem to have problems with ids getting reused too quickly.  I'm
+ *	not completely sure why this is a problem, but delaying the
+ *	recycling of ids appears to eliminate it.  Therefore, we wait
+ *	an additional few seconds, even after "the coast is clear"
+ *	before reusing the ids.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TkFreeWindowId(dispPtr, w)
+    TkDisplay *dispPtr;		/* Display that w belongs to. */
+    Window w;			/* X identifier for window on dispPtr. */
+{
+    TkIdStack *stackPtr;
+
+    /*
+     * Put the window id on a separate stack of window ids, rather
+     * than the main stack, so it won't get reused right away.  Add
+     * a new chunk to the stack if the current chunk is full.
+     */
+
+    stackPtr = dispPtr->windowStackPtr;
+    if ((stackPtr == NULL) || (stackPtr->numUsed >= IDS_PER_STACK)) {
+	stackPtr = (TkIdStack *) ckalloc(sizeof(TkIdStack));
+	stackPtr->numUsed = 0;
+	stackPtr->dispPtr = dispPtr;
+	stackPtr->nextPtr = dispPtr->windowStackPtr;
+	dispPtr->windowStackPtr = stackPtr;
+    }
+
+    /*
+     * Add the id to the current chunk.
+     */
+
+    stackPtr->ids[stackPtr->numUsed] = w;
+    stackPtr->numUsed++;
+
+    /*
+     * Schedule a call to WindowIdCleanup if one isn't already
+     * scheduled.
+     */
+
+    if (!dispPtr->idCleanupScheduled) {
+	dispPtr->idCleanupScheduled = 1;
+	Tcl_CreateTimerHandler(100, WindowIdCleanup, (ClientData) dispPtr);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * WindowIdCleanup --
+ *
+ *	See if we can now free up all the accumulated ids of
+ *	deleted windows.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	If it's safe to move the window ids back to the main free
+ *	list, we schedule this to happen after a few mores seconds
+ *	of delay.  If it's not safe to move them yet, a timer handler
+ *	gets invoked to try again later.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+WindowIdCleanup(clientData)
+    ClientData clientData;	/* Pointer to TkDisplay for display */
+{
+    TkDisplay *dispPtr = (TkDisplay *) clientData;
+    int anyEvents, delta;
+    Tk_RestrictProc *oldProc;
+    ClientData oldData;
+    static Tcl_Time timeout = {0, 0};
+
+    dispPtr->idCleanupScheduled = 0;
+
+    /*
+     * See if it's safe to recycle the window ids.  It's safe if:
+     * (a) no deletions are in progress.
+     * (b) the server has seen all of the requests up to the last
+     *     XDestroyWindow request.
+     * (c) there are no events in the event queue; the only way to
+     *     test for this right now is to create a restrict proc that
+     *     will filter the events, then call Tcl_DoOneEvent to see if
+     *	   the procedure gets invoked.
+     */
+
+    if (dispPtr->destroyCount > 0) {
+	goto tryAgain;
+    }
+    delta = LastKnownRequestProcessed(dispPtr->display)
+	    - dispPtr->lastDestroyRequest;
+    if (delta < 0) {
+	XSync(dispPtr->display, False);
+    }
+    anyEvents = 0;
+    oldProc = Tk_RestrictEvents(CheckRestrictProc, (ClientData) &anyEvents,
+	    &oldData);
+    TkUnixDoOneXEvent(&timeout);
+    Tk_RestrictEvents(oldProc, oldData, &oldData);
+    if (anyEvents) {
+	goto tryAgain;
+    }
+
+    /*
+     * These ids look safe to recycle, but we still need to delay a bit
+     * more (see comments for TkFreeWindowId).  Schedule the final freeing.
+     */
+
+    if (dispPtr->windowStackPtr != NULL) {
+	Tcl_CreateTimerHandler(5000, WindowIdCleanup2,
+		(ClientData) dispPtr->windowStackPtr);
+	dispPtr->windowStackPtr = NULL;
+    }
+    return;
+
+    /*
+     * It's still not safe to free up the ids.  Try again a bit later.
+     */
+
+    tryAgain:
+    dispPtr->idCleanupScheduled = 1;
+    Tcl_CreateTimerHandler(500, WindowIdCleanup, (ClientData) dispPtr);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * WindowIdCleanup2 --
+ *
+ *	This procedure is the last one in the chain that recycles
+ *	window ids.  It takes all of the ids indicated by its
+ *	argument and adds them back to the main id free list.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Window ids get added to the main free list for their display.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+WindowIdCleanup2(clientData)
+    ClientData clientData;	/* Pointer to TkIdStack list. */
+{
+    TkIdStack *stackPtr = (TkIdStack *) clientData;
+    TkIdStack *lastPtr;
+
+    lastPtr = stackPtr;
+    while (lastPtr->nextPtr != NULL) {
+	lastPtr = lastPtr->nextPtr;
+    }
+    lastPtr->nextPtr = stackPtr->dispPtr->idStackPtr;
+    stackPtr->dispPtr->idStackPtr = stackPtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CheckRestrictProc --
+ *
+ *	This procedure is a restrict procedure, called by Tcl_DoOneEvent
+ *	to filter X events.  All it does is to set a flag to indicate
+ *	that there are X events present.
+ *
+ * Results:
+ *	Sets the integer pointed to by the argument, then returns
+ *	TK_DEFER_EVENT.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static Tk_RestrictAction
+CheckRestrictProc(clientData, eventPtr)
+    ClientData clientData;	/* Pointer to flag to set. */
+    XEvent *eventPtr;		/* Event to filter;  not used. */
+{
+    int *flag = (int *) clientData;
+    *flag = 1;
+    return TK_DEFER_EVENT;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tk_GetPixmap --
+ *
+ *	Same as the XCreatePixmap procedure except that it manages
+ *	resource identifiers better.
+ *
+ * Results:
+ *	Returns a new pixmap.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Pixmap
+Tk_GetPixmap(display, d, width, height, depth)
+    Display *display;		/* Display for new pixmap. */
+    Drawable d;			/* Drawable where pixmap will be used. */
+    int width, height;		/* Dimensions of pixmap. */
+    int depth;			/* Bits per pixel for pixmap. */
+{
+    return XCreatePixmap(display, d, (unsigned) width, (unsigned) height,
+	    (unsigned) depth);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tk_FreePixmap --
+ *
+ *	Same as the XFreePixmap procedure except that it also marks
+ *	the resource identifier as free.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The pixmap is freed in the X server and its resource identifier
+ *	is saved for re-use.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tk_FreePixmap(display, pixmap)
+    Display *display;		/* Display for which pixmap was allocated. */
+    Pixmap pixmap;		/* Identifier for pixmap. */
+{
+    XFreePixmap(display, pixmap);
+    Tk_FreeXId(display, (XID) pixmap);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkpWindowWasRecentlyDeleted --
+ *
+ *	Checks whether the window was recently deleted. This is called
+ *	by the generic error handler to detect asynchronous notification
+ *	of errors due to operations by Tk on a window that was already
+ *	deleted by the server.
+ *
+ * Results:
+ *	1 if the window was deleted recently, 0 otherwise.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+TkpWindowWasRecentlyDeleted(win, dispPtr)
+    Window win;		/* The window to check for. */
+    TkDisplay *dispPtr;	/* The window belongs to this display. */
+{
+    TkIdStack *stackPtr;
+    int i;
+
+    for (stackPtr = dispPtr->windowStackPtr;
+         stackPtr != NULL;
+         stackPtr = stackPtr->nextPtr) {
+        for (i = 0; i < stackPtr->numUsed; i++) {
+            if ((Window) stackPtr->ids[i] == win) {
+                return 1;
+            }
+        }
+    }
+    return 0;
+}