21ceae9002
Previously the callers were only setting errorValue on Success, when it's ignored, and leaving it alone on failure, when it's sent to the client. Since SetFontPath takes the ClientPtr, let it set client->errorValue instead of letting the callers continue to get it wrong. Signed-off-by: Jamey Sharp <jamey@minilop.net> Reviewed-by: Julien Cristau <jcristau@debian.org> Signed-off-by: Keith Packard <keithp@keithp.com>
554 lines
16 KiB
C
554 lines
16 KiB
C
/*
|
|
* 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 = malloc(*npaths + len);
|
|
c = (unsigned char *)newfp;
|
|
fp = malloc(*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)
|
|
{
|
|
free(fp[0]);
|
|
free(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;
|
|
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 = malloc(nOldPaths + lenOldPaths);
|
|
memmove(oldFontPath, tmpFontPath, nOldPaths + lenOldPaths);
|
|
|
|
result = SetFontPath(client, stuff->nFonts, (unsigned char *)&stuff[1]);
|
|
if (!result) {
|
|
int error = 0;
|
|
for (i = 0; i < dmxNumScreens; i++)
|
|
if ((result = dmxCheckFontPath(&dmxScreens[i], &error)))
|
|
break;
|
|
|
|
if (result) {
|
|
/* Restore old fontpath in the DMX server */
|
|
SetFontPath(client, nOldPaths, oldFontPath);
|
|
client->errorValue = error;
|
|
} else {
|
|
result = client->noClientException;
|
|
}
|
|
}
|
|
|
|
free(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);
|
|
const 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 = malloc(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;
|
|
|
|
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);
|
|
free(goodfps);
|
|
return FALSE;
|
|
}
|
|
|
|
newfp = malloc(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)) {
|
|
/* 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);
|
|
free(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 = 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 = malloc(sizeof(dmxFontPrivRec));
|
|
if (!pFontPriv) return FALSE;
|
|
pFontPriv->font = NULL;
|
|
MAXSCREENSALLOC(pFontPriv->font);
|
|
if (!pFontPriv->font) {
|
|
free(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);
|
|
free(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);
|
|
free(pFontPriv);
|
|
FontSetPrivate(pFont, dmxFontPrivateIndex, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|