Checked in the following released items:

xkeyboard-config-1.4.tar.gz
ttf-bitstream-vera-1.10.tar.gz
font-alias-1.0.1.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sony-misc-1.0.0.tar.gz
font-schumacher-misc-1.0.0.tar.gz
font-mutt-misc-1.0.0.tar.gz
font-misc-misc-1.0.0.tar.gz
font-misc-meltho-1.0.0.tar.gz
font-micro-misc-1.0.0.tar.gz
font-jis-misc-1.0.0.tar.gz
font-isas-misc-1.0.0.tar.gz
font-dec-misc-1.0.0.tar.gz
font-daewoo-misc-1.0.0.tar.gz
font-cursor-misc-1.0.0.tar.gz
font-arabic-misc-1.0.0.tar.gz
font-winitzki-cyrillic-1.0.0.tar.gz
font-misc-cyrillic-1.0.0.tar.gz
font-cronyx-cyrillic-1.0.0.tar.gz
font-screen-cyrillic-1.0.1.tar.gz
font-xfree86-type1-1.0.1.tar.gz
font-adobe-utopia-type1-1.0.1.tar.gz
font-ibm-type1-1.0.0.tar.gz
font-bitstream-type1-1.0.0.tar.gz
font-bitstream-speedo-1.0.0.tar.gz
font-bh-ttf-1.0.0.tar.gz
font-bh-type1-1.0.0.tar.gz
font-bitstream-100dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-100dpi-1.0.0.tar.gz
font-bh-100dpi-1.0.0.tar.gz
font-adobe-utopia-100dpi-1.0.1.tar.gz
font-adobe-100dpi-1.0.0.tar.gz
font-util-1.0.1.tar.gz
font-bitstream-75dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-75dpi-1.0.0.tar.gz
font-adobe-utopia-75dpi-1.0.1.tar.gz
font-bh-75dpi-1.0.0.tar.gz
bdftopcf-1.0.1.tar.gz
font-adobe-75dpi-1.0.0.tar.gz
mkfontscale-1.0.6.tar.gz
openssl-0.9.8k.tar.gz
bigreqsproto-1.0.2.tar.gz
xtrans-1.2.2.tar.gz
resourceproto-1.0.2.tar.gz
inputproto-1.4.4.tar.gz
compositeproto-0.4.tar.gz
damageproto-1.1.0.tar.gz
zlib-1.2.3.tar.gz
xkbcomp-1.0.5.tar.gz
freetype-2.3.9.tar.gz
pthreads-w32-2-8-0-release.tar.gz
pixman-0.12.0.tar.gz
kbproto-1.0.3.tar.gz
evieext-1.0.2.tar.gz
fixesproto-4.0.tar.gz
recordproto-1.13.2.tar.gz
randrproto-1.2.2.tar.gz
scrnsaverproto-1.1.0.tar.gz
renderproto-0.9.3.tar.gz
xcmiscproto-1.1.2.tar.gz
fontsproto-2.0.2.tar.gz
xextproto-7.0.3.tar.gz
xproto-7.0.14.tar.gz
libXdmcp-1.0.2.tar.gz
libxkbfile-1.0.5.tar.gz
libfontenc-1.0.4.tar.gz
libXfont-1.3.4.tar.gz
libX11-1.1.5.tar.gz
libXau-1.0.4.tar.gz
libxcb-1.1.tar.gz
xorg-server-1.5.3.tar.gz

1 files changed, 559 insertions, 0 deletions

diff --git a/xorg-server/hw/dmx/dmxfont.c b/xorg-server/hw/dmx/dmxfont.c
new file mode 100644
index 000000000..b70f7d2df
--- /dev/null
+++ b/xorg-server/hw/dmx/dmxfont.c
@@ -0,0 +1,559 @@
+/*
+ * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina.
+ *
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation on the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/*
+ * Authors:
+ *   Kevin E. Martin <kem@redhat.com>
+ *
+ */
+
+/** \file
+ * This file provides support for fonts. */
+
+#ifdef HAVE_DMX_CONFIG_H
+#include <dmx-config.h>
+#endif
+
+#define DMX_FONTPATH_DEBUG 0
+
+#include "dmx.h"
+#include "dmxsync.h"
+#include "dmxfont.h"
+#include "dmxlog.h"
+
+#include <X11/fonts/fontstruct.h>
+#include "dixfont.h"
+#include "dixstruct.h"
+
+static int (*dmxSaveProcVector[256])(ClientPtr);
+static int   dmxFontLastError;
+
+static int dmxFontErrorHandler(Display *dpy, XErrorEvent *ev)
+{
+    dmxFontLastError = ev->error_code;
+
+    return 0;
+}
+
+static char **dmxGetFontPath(int *npaths)
+{
+    char          **fp;
+    unsigned char  *c, *paths;
+    char           *newfp;
+    int             len, l, i;
+
+    GetFontPath(serverClient, npaths, &len, &paths);
+
+    newfp = xalloc(*npaths + len);
+    c = (unsigned char *)newfp;
+    fp = xalloc(*npaths * sizeof(*fp));
+
+    memmove(newfp, paths+1, *npaths + len - 1);
+    l = *paths;
+    for (i = 0; i < *npaths; i++) {
+	fp[i] = (char *)c;
+	c += l;
+	l = *c;
+	*c++ = '\0';
+    }
+
+#if DMX_FONTPATH_DEBUG
+    for (i = 0; i < *npaths; i++)
+        dmxLog(dmxDebug, "FontPath[%d] = %s\n", i, fp[i]);
+#endif
+
+    return fp;
+}
+
+static void dmxFreeFontPath(char **fp)
+{
+    xfree(fp[0]);
+    xfree(fp);
+}
+
+static Bool dmxCheckFontPathElement(DMXScreenInfo *dmxScreen, char *fp)
+{
+    int  (*oldErrorHandler)(Display *, XErrorEvent *);
+
+    if (!dmxScreen->beDisplay)
+	return TRUE;
+
+    dmxFontLastError = 0;
+    oldErrorHandler = XSetErrorHandler(dmxFontErrorHandler);
+    XSetFontPath(dmxScreen->beDisplay, &fp, 1);
+    dmxSync(dmxScreen, TRUE);   /* Must complete before removing handler */
+    XSetErrorHandler(oldErrorHandler);
+
+    return (dmxFontLastError == 0);
+}
+
+static int dmxSetFontPath(DMXScreenInfo *dmxScreen)
+{
+    int  (*oldErrorHandler)(Display *, XErrorEvent *);
+    char **fp;
+    int    result = Success;
+    int    npaths;
+
+    if (!dmxScreen->beDisplay)
+	return result;
+
+    fp = dmxGetFontPath(&npaths);
+    if (!fp) return BadAlloc;
+
+    dmxFontLastError = 0;
+    oldErrorHandler = XSetErrorHandler(dmxFontErrorHandler);
+    XSetFontPath(dmxScreen->beDisplay, fp, npaths);
+    dmxSync(dmxScreen, TRUE);   /* Must complete before removing handler */
+    XSetErrorHandler(oldErrorHandler);
+
+    if (dmxFontLastError) {
+	result = dmxFontLastError;
+	/* We could set *error here to the offending path, but it is
+	 * ignored, so we don't bother figuring out which path is bad.
+	 * If we do add this support in the future, we'll need to add
+	 * error to the function's argument list.
+	 */
+    }
+
+    dmxFreeFontPath(fp);
+
+    return result;
+}
+
+static int dmxCheckFontPath(DMXScreenInfo *dmxScreen, int *error)
+{
+    char **oldFontPath;
+    int    nOldPaths;
+    int    result = Success;
+
+    if (!dmxScreen->beDisplay)
+	return result;
+
+    /* Save old font path */
+    oldFontPath = XGetFontPath(dmxScreen->beDisplay, &nOldPaths);
+
+    result = dmxSetFontPath(dmxScreen);
+
+    /* Restore old font path */
+    XSetFontPath(dmxScreen->beDisplay, oldFontPath, nOldPaths);
+    XFreeFontPath(oldFontPath);
+    dmxSync(dmxScreen, FALSE);
+
+    return result;
+}
+
+static int dmxProcSetFontPath(ClientPtr client)
+{
+    unsigned char *ptr;
+    unsigned long  nbytes, total, n;
+    long           nfonts;
+    int            i, result;
+    int            error;
+    unsigned char *oldFontPath, *tmpFontPath;
+    int            nOldPaths;
+    int            lenOldPaths;
+    REQUEST(xSetFontPathReq);
+    
+    REQUEST_AT_LEAST_SIZE(xSetFontPathReq);
+    
+    nbytes = (client->req_len << 2) - sizeof(xSetFontPathReq);
+    total = nbytes;
+    ptr = (unsigned char *)&stuff[1];
+    nfonts = stuff->nFonts;
+
+    while (--nfonts >= 0) {
+	if ((total == 0) || (total < (n = (*ptr + 1))))
+	    return BadLength;
+	total -= n;
+	ptr += n;
+    }
+    if (total >= 4)
+        return BadLength;
+
+    GetFontPath(serverClient, &nOldPaths, &lenOldPaths, &tmpFontPath);
+    oldFontPath = xalloc(nOldPaths + lenOldPaths);
+    memmove(oldFontPath, tmpFontPath, nOldPaths + lenOldPaths);
+
+    result = SetFontPath(client, stuff->nFonts, (unsigned char *)&stuff[1],
+			 &error);
+    if (!result) {
+	for (i = 0; i < dmxNumScreens; i++)
+	    if ((result = dmxCheckFontPath(&dmxScreens[i], &error)))
+		break;
+
+	if (result) {
+	    int  ignoreresult, ignoreerror;
+
+	    /* Restore old fontpath in the DMX server */
+	    ignoreresult = SetFontPath(client, nOldPaths, oldFontPath,
+				       &ignoreerror);
+	} else {
+	    result = client->noClientException;
+	    client->errorValue = error;
+	}
+    }
+
+    xfree(oldFontPath);
+    return result;
+}
+
+/** Initialize font support.  In addition to the screen function call
+ *  pointers, DMX also hooks in at the ProcVector[] level.  Here the old
+ *  ProcVector function pointers are saved and the new ProcVector
+ *  function pointers are initialized. */
+void dmxInitFonts(void)
+{
+    int  i;
+
+    for (i = 0; i < 256; i++)
+	dmxSaveProcVector[i] = ProcVector[i];
+
+    ProcVector[X_SetFontPath] = dmxProcSetFontPath;
+}
+
+/** Reset font support by restoring the original ProcVector function
+ *  pointers. */
+void dmxResetFonts(void)
+{
+    int  i;
+
+    for (i = 0; i < 256; i++)
+	ProcVector[i] = dmxSaveProcVector[i];
+}
+
+/** Load the font, \a pFont, on the back-end server associated with \a
+ *  pScreen.  When a font is loaded, the font path on back-end server is
+ *  first initialized to that specified on the command line with the
+ *  -fontpath options, and then the font is loaded. */
+Bool dmxBELoadFont(ScreenPtr pScreen, FontPtr pFont)
+{
+    DMXScreenInfo  *dmxScreen = &dmxScreens[pScreen->myNum];
+    dmxFontPrivPtr  pFontPriv = FontGetPrivate(pFont, dmxFontPrivateIndex);
+    char           *name;
+    char          **oldFontPath = NULL;
+    int             nOldPaths;
+    Atom            name_atom, value_atom;
+    int             i;
+
+    /* Make sure we have a font private struct to work with */
+    if (!pFontPriv)
+	return FALSE;
+
+    /* Don't load a font over top of itself */
+    if (pFontPriv->font[pScreen->myNum]) {
+	return TRUE; /* Already loaded font */
+    }
+
+    /* Save old font path */
+    oldFontPath = XGetFontPath(dmxScreen->beDisplay, &nOldPaths);
+
+    /* Set the font path for the font about to be loaded on the back-end */
+    if (dmxSetFontPath(dmxScreen)) {
+	char **fp;
+	int    npaths;
+	Bool  *goodfps;
+
+	/* This could fail only when first starting the X server and
+	 * loading the default font.  If it fails here, then the default
+	 * font path is invalid, no default font path will be set, the
+	 * DMX server will fail to load the default font, and it will
+	 * exit with an error unless we remove the offending font paths
+	 * with the -ignorebadfontpaths command line option.
+	 */
+
+	fp = dmxGetFontPath(&npaths);
+	if (!fp) {
+	    dmxLog(dmxError,
+		   "No default font path set.\n");
+	    dmxLog(dmxError,
+		   "Please see the Xdmx man page for information on how to\n");
+	    dmxLog(dmxError,
+		   "initialize the DMX server's default font path.\n");
+	    XFreeFontPath(oldFontPath);
+	    return FALSE;
+	}
+
+	if (!dmxFontPath)
+	    dmxLog(dmxWarning, "No default font path is set.\n");
+
+	goodfps = xalloc(npaths * sizeof(*goodfps));
+
+	dmxLog(dmxError,
+	       "The DMX server failed to set the following font paths on "
+	       "screen #%d:\n", pScreen->myNum);
+	
+	for (i = 0; i < npaths; i++)
+	    if (!(goodfps[i] = dmxCheckFontPathElement(dmxScreen, fp[i])))
+		dmxLog(dmxError, "    %s\n", fp[i]);
+
+	if (dmxIgnoreBadFontPaths) {
+	    char *newfp;
+	    int   newnpaths = 0;
+	    int   len = 0;
+	    int   j = 0;
+	    int   error;
+
+	    dmxLog(dmxError,
+		   "These font paths will not be used because the "
+		   "\"-ignorebadfontpaths\"\n");
+	    dmxLog(dmxError,
+		   "option is set.\n");
+
+	    for (i = 0; i < npaths; i++)
+		if (goodfps[i]) {
+		    len += strlen(fp[i]) + 1;
+		    newnpaths++;
+		}
+
+	    if (!newnpaths) {
+		/* No valid font paths were found */
+		dmxLog(dmxError,
+		       "After removing the font paths above, no valid font "
+		       "paths were\n");
+		dmxLog(dmxError,
+		       "available.  Please check that the font paths set on "
+		       "the command\n");
+		dmxLog(dmxError,
+		       "line or in the configuration file via the "
+		       "\"-fontpath\" option\n");
+		dmxLog(dmxError,
+		       "are valid on all back-end servers.  See the Xdmx man "
+		       "page for\n");
+		dmxLog(dmxError,
+		       "more information on font paths.\n");
+		dmxFreeFontPath(fp);
+		XFreeFontPath(oldFontPath);
+		xfree(goodfps);
+		return FALSE;
+	    }
+
+	    newfp = xalloc(len * sizeof(*newfp));
+	    for (i = 0; i < npaths; i++) {
+		if (goodfps[i]) {
+		    int n = strlen(fp[i]);
+		    newfp[j++] = n;
+		    strncpy(&newfp[j], fp[i], n);
+		    j += n;
+		}
+	    }
+
+	    if (SetFontPath(serverClient, newnpaths, (unsigned char *)newfp,
+			    &error)) {
+		/* Note that this should never happen since all of the
+		 * FPEs were previously valid. */
+		dmxLog(dmxError, "Cannot reset the default font path.\n");
+	    }
+	} else if (dmxFontPath) {
+	    dmxLog(dmxError,
+		   "Please remove these font paths from the command line "
+		   "or\n");
+	    dmxLog(dmxError,
+		   "configuration file, or set the \"-ignorebadfontpaths\" "
+		   "option to\n");
+	    dmxLog(dmxError,
+		   "ignore them.  For more information on these options, see "
+		   "the\n");
+	    dmxLog(dmxError,
+		   "Xdmx man page.\n");
+	} else {
+	    dmxLog(dmxError,
+		   "Please specify the font paths that are available on all "
+		   "back-end\n");
+	    dmxLog(dmxError,
+		   "servers with the \"-fontpath\" option, or use the "
+                   "\"-ignorebadfontpaths\"\n");
+            dmxLog(dmxError,
+                   "to ignore bad defaults.  For more information on "
+                   "these and other\n");
+	    dmxLog(dmxError,
+		   "font-path-related options, see the Xdmx man page.\n");
+	}
+
+	if (!dmxIgnoreBadFontPaths ||
+	    (dmxIgnoreBadFontPaths && dmxSetFontPath(dmxScreen))) {
+	    /* We still have errors so return with error */
+	    dmxFreeFontPath(fp);
+	    XFreeFontPath(oldFontPath);
+	    xfree(goodfps);
+	    return FALSE;
+	}
+    }
+
+    /* Find requested font on back-end server */
+    name_atom = MakeAtom("FONT", 4, TRUE);
+    value_atom = 0L;
+
+    for (i = 0; i < pFont->info.nprops; i++) {
+	if ((Atom)pFont->info.props[i].name == name_atom) {
+	    value_atom = pFont->info.props[i].value;
+	    break;
+	}
+    }
+    if (!value_atom) return FALSE;
+
+    name = (char *)NameForAtom(value_atom);
+    if (!name) return FALSE;
+
+    pFontPriv->font[pScreen->myNum] = 
+	XLoadQueryFont(dmxScreen->beDisplay, name);
+
+    /* Restore old font path */
+    XSetFontPath(dmxScreen->beDisplay, oldFontPath, nOldPaths);
+    XFreeFontPath(oldFontPath);
+    dmxSync(dmxScreen, FALSE);
+
+    if (!pFontPriv->font[pScreen->myNum]) return FALSE;
+
+    return TRUE;
+}
+
+/** Realize the font, \a pFont, on the back-end server associated with
+ *  \a pScreen. */
+Bool dmxRealizeFont(ScreenPtr pScreen, FontPtr pFont)
+{
+    DMXScreenInfo  *dmxScreen = &dmxScreens[pScreen->myNum];
+    dmxFontPrivPtr  pFontPriv;
+
+    if (!(pFontPriv = FontGetPrivate(pFont, dmxFontPrivateIndex))) {
+	FontSetPrivate(pFont, dmxFontPrivateIndex, NULL);
+	pFontPriv = xalloc(sizeof(dmxFontPrivRec));
+	if (!pFontPriv) return FALSE;
+        pFontPriv->font = NULL;
+        MAXSCREENSALLOC(pFontPriv->font);
+        if (!pFontPriv->font) {
+            xfree(pFontPriv);
+            return FALSE;
+        }
+	pFontPriv->refcnt = 0;
+    }
+
+    FontSetPrivate(pFont, dmxFontPrivateIndex, (pointer)pFontPriv);
+
+    if (dmxScreen->beDisplay) {
+	if (!dmxBELoadFont(pScreen, pFont))
+	    return FALSE;
+
+	pFontPriv->refcnt++;
+    } else {
+	pFontPriv->font[pScreen->myNum] = NULL;
+    }
+
+    return TRUE;
+}
+
+/** Free \a pFont on the back-end associated with \a pScreen. */
+Bool dmxBEFreeFont(ScreenPtr pScreen, FontPtr pFont)
+{
+    DMXScreenInfo  *dmxScreen = &dmxScreens[pScreen->myNum];
+    dmxFontPrivPtr  pFontPriv = FontGetPrivate(pFont, dmxFontPrivateIndex);
+
+    if (pFontPriv && pFontPriv->font[pScreen->myNum]) {
+	XFreeFont(dmxScreen->beDisplay, pFontPriv->font[pScreen->myNum]);
+	pFontPriv->font[pScreen->myNum] = NULL;
+	return TRUE;
+    }
+
+    return FALSE;
+}
+
+/** Unrealize the font, \a pFont, on the back-end server associated with
+ *  \a pScreen. */
+Bool dmxUnrealizeFont(ScreenPtr pScreen, FontPtr pFont)
+{
+    DMXScreenInfo  *dmxScreen = &dmxScreens[pScreen->myNum];
+    dmxFontPrivPtr  pFontPriv;
+
+    if ((pFontPriv = FontGetPrivate(pFont, dmxFontPrivateIndex))) {
+	/* In case the font failed to load properly */
+	if (!pFontPriv->refcnt) {
+            MAXSCREENSFREE(pFontPriv->font);
+	    xfree(pFontPriv);
+	    FontSetPrivate(pFont, dmxFontPrivateIndex, NULL);
+	} else if (pFontPriv->font[pScreen->myNum]) {
+	    if (dmxScreen->beDisplay)
+		dmxBEFreeFont(pScreen, pFont);
+
+	    /* The code below is non-obvious, so here's an explanation...
+	     *
+	     * When creating the default GC, the server opens up the
+	     * default font once for each screen, which in turn calls
+	     * the RealizeFont function pointer once for each screen.
+	     * During this process both dix's font refcnt and DMX's font
+	     * refcnt are incremented once for each screen.
+	     *
+	     * Later, when shutting down the X server, dix shuts down
+	     * each screen in reverse order.  During this shutdown
+	     * procedure, each screen's default GC is freed and then
+	     * that screen is closed by calling the CloseScreen function
+	     * pointer.  screenInfo.numScreens is then decremented after
+	     * closing each screen.  This procedure means that the dix's
+	     * font refcnt for the font used by the default GC's is
+	     * decremented once for each screen # greater than 0.
+	     * However, since dix's refcnt for the default font is not
+	     * yet 0 for each screen greater than 0, no call to the
+	     * UnrealizeFont function pointer is made for those screens.
+	     * Then, when screen 0 is being closed, dix's font refcnt
+	     * for the default GC's font is finally 0 and the font is
+	     * unrealized.  However, since screenInfo.numScreens has
+	     * been decremented already down to 1, only one call to
+	     * UnrealizeFont is made (for screen 0).  Thus, even though
+	     * RealizeFont was called once for each screen,
+	     * UnrealizeFont is only called for screen 0.
+	     *
+	     * This is a bug in dix.
+	     *
+	     * To avoid the memory leak of pFontPriv for each server
+	     * generation, we can also free pFontPriv if the refcnt is
+	     * not yet 0 but the # of screens is 1 -- i.e., the case
+	     * described in the dix bug above.  This is only a temporary
+	     * workaround until the bug in dix is solved.
+	     *
+	     * The other problem is that the font structure allocated by
+	     * XLoadQueryFont() above is not freed for screens > 0.
+	     * This problem cannot be worked around here since the back-
+	     * end displays for screens > 0 have already been closed by
+	     * the time this code is called from dix.
+	     *
+	     * When the bug in dix described above is fixed, then we can
+	     * remove the "|| screenInfo.numScreens == 1" code below and
+	     * the memory leaks will be eliminated.
+	     */
+	    if (--pFontPriv->refcnt == 0
+#if 1
+		/* Remove this code when the dix bug is fixed */
+		|| screenInfo.numScreens == 1
+#endif
+		) {
+                MAXSCREENSFREE(pFontPriv->font);
+		xfree(pFontPriv);
+		FontSetPrivate(pFont, dmxFontPrivateIndex, NULL);
+	    }
+	}
+    }
+
+    return TRUE;
+}