Importing from X.Org indiviual releases

1 files changed, 672 insertions, 0 deletions

diff --git a/app/xfs/difs/difsutils.c b/app/xfs/difs/difsutils.c
new file mode 100644
index 000000000..48f7d5254
--- /dev/null
+++ b/app/xfs/difs/difsutils.c
@@ -0,0 +1,672 @@
+/* $Xorg: difsutils.c,v 1.4 2001/02/09 02:05:42 xorgcvs Exp $ */
+/*
+ * misc utility routines
+ */
+/*
+ 
+Copyright 1990, 1991, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice 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 NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP 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.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+ * Copyright 1990, 1991 Network Computing Devices;
+ * Portions Copyright 1987 by Digital Equipment Corporation 
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the names of Network Computing Devices, or Digital
+ * not be used in advertising or publicity pertaining to distribution
+ * of the software without specific, written prior permission.
+ *
+ * NETWORK COMPUTING DEVICES, AND DIGITAL DISCLAIM ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES,
+ * OR DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ * THIS SOFTWARE.
+ */
+/* $XFree86: xc/programs/xfs/difs/difsutils.c,v 1.6 2001/01/17 23:45:28 dawes Exp $ */
+
+#define	XK_LATIN1
+
+#include	<difsutils.h>
+
+#include	<stdio.h>
+#include	<ctype.h>
+#include	"misc.h"
+#include	"globals.h"
+#include	"clientstr.h"
+#include	"accstr.h"
+#include	<X11/fonts/fontstruct.h>
+#include	<X11/keysymdef.h>
+
+#include	"authstr.h"
+#include	"auth.h"
+#include	"client.h"
+
+extern ClientPtr currentClient;
+static FontResolutionPtr default_resolutions;
+static int  num_resolutions;
+static int  default_point_size = 120;
+
+AuthContextPtr
+GetClientAuthorization(void)
+{
+    return currentClient->auth;
+}
+
+void
+SetDefaultPointSize(int ps)
+{
+    int         i;
+
+    default_point_size = ps;
+    for (i = 0; i < num_resolutions; i++)
+	default_resolutions[i].point_size = ps;
+}
+
+int
+SetDefaultResolutions(char *str)
+{
+    int         num,
+                numr = 0,
+                n;
+    char       *s;
+    FontResolutionPtr new,
+                nr;
+    int         state;
+
+    s = str;
+    while (*s) {		/* count commas */
+	if (*s == ',')
+	    numr++;
+	s++;
+    }
+
+    if ((numr % 2) != 1) {	/* must be multiple of 2 + 1 */
+	return FSBadResolution;
+    }
+    numr = (numr + 1) / 2;
+    nr = new = (FontResolutionPtr) fsalloc(sizeof(FontResolutionRec)
+					   * numr);
+    if (!new)
+	return FSBadAlloc;
+    s = str;
+    num = 0;
+    state = 0;
+    while (*s) {
+	if (*s == ',') {
+	    if (state == 0) {
+		nr->x_resolution = num;
+		state++;
+	    } else {
+		state = 0;
+		nr->y_resolution = num;
+		nr->point_size = default_point_size;
+		nr++;
+	    }
+	    num = 0;
+	    s++;
+	    continue;
+	}
+	if (!isdigit(*s)) {
+	    fsfree((char *) new);
+	    return FSBadResolution;
+	}
+	n = *s - '0';
+	num = num * 10 + n;
+	s++;
+    }
+
+    /* do the last one */
+    assert(state == 1);
+    nr->y_resolution = num;
+    nr->point_size = default_point_size;
+
+    if (default_resolutions) {
+	fsfree((char *) default_resolutions);
+    }
+    default_resolutions = new;
+    num_resolutions = numr;
+    return FSSuccess;
+}
+
+FontResolutionPtr
+GetClientResolutions(int *num)
+{
+    /* return the client's if it has them, otherwise the default values */
+    if (currentClient->num_resolutions) {
+	*num = currentClient->num_resolutions;
+	return (FontResolutionPtr) currentClient->resolutions;
+    } else {
+	*num = num_resolutions;
+	return default_resolutions;
+    }
+}
+
+int
+GetDefaultPointSize(void)
+{
+    FontResolutionPtr res;
+    int         num;
+
+    res = GetClientResolutions(&num);
+    if (res)
+	return res->point_size;
+    else
+	return default_point_size;
+}
+
+Bool
+XpClientIsBitmapClient(ClientPtr client)
+{
+    return TRUE;
+}
+
+Bool
+XpClientIsPrintClient(ClientPtr client, FontPathElementPtr fpe)
+{
+    return FALSE;
+}
+
+void
+CopyISOLatin1Lowered(unsigned char *dest, unsigned char *source, int length)
+{
+    register int i;
+
+    for (i = 0; i < length; i++, source++, dest++) {
+	if ((*source >= XK_A) && (*source <= XK_Z))
+	    *dest = *source + (XK_a - XK_A);
+	else if ((*source >= XK_Agrave) && (*source <= XK_Odiaeresis))
+	    *dest = *source + (XK_agrave - XK_Agrave);
+	else if ((*source >= XK_Ooblique) && (*source <= XK_Thorn))
+	    *dest = *source + (XK_oslash - XK_Ooblique);
+	else
+	    *dest = *source;
+    }
+    *dest = '\0';
+}
+
+int
+strncmpnocase(
+    char       *first,
+    char       *second,
+    int         n)
+{
+    register unsigned char *ap,
+               *bp;
+
+    for (ap = (unsigned char *) first,
+	    bp = (unsigned char *) second;
+    /* SUPPRESS 112 */
+	    n > 0 && *ap && *bp; n--, ap++, bp++) {
+	register unsigned char a,
+	            b;
+
+	/* SUPPRESS 112 */
+	if ((a = *ap) != (b = *bp)) {
+	    /* try lowercasing and try again */
+
+	    if ((a >= XK_A) && (a <= XK_Z))
+		a += (XK_a - XK_A);
+	    else if ((a >= XK_Agrave) && (a <= XK_Odiaeresis))
+		a += (XK_agrave - XK_Agrave);
+	    else if ((a >= XK_Ooblique) && (a <= XK_Thorn))
+		a += (XK_oslash - XK_Ooblique);
+
+	    if ((b >= XK_A) && (b <= XK_Z))
+		b += (XK_a - XK_A);
+	    else if ((b >= XK_Agrave) && (b <= XK_Odiaeresis))
+		b += (XK_agrave - XK_Agrave);
+	    else if ((b >= XK_Ooblique) && (b <= XK_Thorn))
+		b += (XK_oslash - XK_Ooblique);
+
+	    if (a != b)
+		break;
+	}
+    }
+    /* SUPPRESS 112 */
+    return (n ? (((int) *ap) - ((int) *bp)) : 0);
+}
+
+void
+NoopDDA(void)
+{
+}
+
+/* host list manipulation */
+int
+AddHost(
+    HostList   *list,
+    HostAddress *addr)
+{
+    HostAddress *new;
+
+    new = (HostAddress *) fsalloc(sizeof(HostAddress));
+    if (!new)
+	return FSBadAlloc;
+    new->address = (pointer) fsalloc(addr->addr_len);
+    if (!new->address) {
+	fsfree((char *) addr);
+	return FSBadAlloc;
+    }
+    new->type = addr->type;
+    new->addr_len = addr->addr_len;
+    memmove( (char *) new->address, (char *) addr->address, new->addr_len);
+
+    new->next = *list;
+    *list = new;
+    return FSSuccess;
+}
+
+int
+RemoveHost(
+    HostList   *list,
+    HostAddress *addr)
+{
+    HostAddress *t,
+               *last;
+
+    last = (HostAddress *) 0;
+    t = *list;
+    while (t) {
+	if (t->type == addr->type &&
+		t->addr_len == addr->addr_len &&
+		memcmp((char *) t->address, (char *) addr->address,
+		     min(t->addr_len, addr->addr_len)) == 0) {
+	    if (last) {
+		last->next = t->next;
+	    } else {
+		*list = t->next;
+	    }
+	    fsfree((char *) t->address);
+	    fsfree((char *) t);
+	    return FSSuccess;
+	}
+	last = t;
+	t = t->next;
+    }
+    return FSBadName;		/* bad host name */
+}
+
+Bool
+ValidHost(
+    HostList    list,
+    HostAddress *addr)
+{
+    HostAddress *t;
+
+    t = list;
+    while (t) {
+	if (t->type == addr->type &&
+		t->addr_len == addr->addr_len &&
+		memcmp((char *) t->address, (char *) addr->address,
+		     min(t->addr_len, addr->addr_len)) == 0) {
+	    return TRUE;
+	}
+    }
+    return FALSE;
+}
+
+/* block & wakeup handlers */
+
+typedef struct _BlockHandler {
+    BlockHandlerProcPtr	BlockHandler;
+    DifsWakeupFunc	WakeupHandler;
+    pointer     	blockData;
+    Bool        	deleted;
+}           BlockHandlerRec, *BlockHandlerPtr;
+
+static BlockHandlerPtr handlers;
+static int  numHandlers;
+static int  sizeHandlers;
+static Bool inHandler;
+static Bool handlerDeleted;
+
+/* called from the OS layer */
+void
+BlockHandler(
+    OSTimePtr   pTimeout,	/* DIX doesn't want to know how OS represents
+				 * time */
+    pointer     pReadmask)	/* nor how it represents the set of
+				 * descriptors */
+{
+    register int i,
+                j;
+
+    ++inHandler;
+    for (i = 0; i < numHandlers; i++)
+	(*handlers[i].BlockHandler) (handlers[i].blockData,
+				     pTimeout, pReadmask);
+    if (handlerDeleted) {
+	for (i = 0; i < numHandlers;)
+	    if (handlers[i].deleted) {
+		for (j = i; j < numHandlers - 1; j++)
+		    handlers[j] = handlers[j + 1];
+		numHandlers--;
+	    } else
+		i++;
+    }
+    --inHandler;
+}
+
+
+void
+WakeupHandler(
+    int		result,		/* result from the wait */
+    unsigned long * pReadmask)	/* the resulting descriptor mask */
+{
+    register int i,
+                j;
+
+    ++inHandler;
+    for (i = numHandlers - 1; i >= 0; i--)
+	(*handlers[i].WakeupHandler) (handlers[i].blockData,
+				      result, pReadmask);
+    if (handlerDeleted) {
+	for (i = 0; i < numHandlers;)
+	    if (handlers[i].deleted) {
+		for (j = i; j < numHandlers - 1; j++)
+		    handlers[j] = handlers[j + 1];
+		numHandlers--;
+	    } else
+		i++;
+    }
+    --inHandler;
+}
+
+/* Reentrant with BlockHandler and WakeupHandler, except wakeup won't
+ * get called until next time
+ */
+
+Bool
+RegisterBlockAndWakeupHandlers(
+    BlockHandlerProcPtr blockHandler,
+    DifsWakeupFunc wakeupHandler,
+    pointer     blockData)
+{
+    BlockHandlerPtr new;
+
+    if (numHandlers >= sizeHandlers) {
+	new = (BlockHandlerPtr) fsrealloc(handlers, (numHandlers + 1) *
+					  sizeof(BlockHandlerRec));
+	if (!new)
+	    return FALSE;
+	handlers = new;
+	sizeHandlers = numHandlers + 1;
+    }
+    handlers[numHandlers].BlockHandler = blockHandler;
+    handlers[numHandlers].WakeupHandler = wakeupHandler;
+    handlers[numHandlers].blockData = blockData;
+    numHandlers = numHandlers + 1;
+    return TRUE;
+}
+
+void
+RemoveBlockAndWakeupHandlers(
+    BlockHandlerProcPtr blockHandler,
+    DifsWakeupFunc wakeupHandler,
+    pointer     blockData)
+{
+    int         i;
+
+    for (i = 0; i < numHandlers; i++)
+	if (handlers[i].BlockHandler == blockHandler &&
+		handlers[i].WakeupHandler == wakeupHandler &&
+		handlers[i].blockData == blockData) {
+	    if (inHandler) {
+		handlerDeleted = TRUE;
+		handlers[i].deleted = TRUE;
+	    } else {
+		for (; i < numHandlers - 1; i++)
+		    handlers[i] = handlers[i + 1];
+		numHandlers--;
+	    }
+	    break;
+	}
+}
+
+void
+InitBlockAndWakeupHandlers(void)
+{
+    fsfree(handlers);
+    handlers = (BlockHandlerPtr) 0;
+    numHandlers = 0;
+    sizeHandlers = 0;
+}
+
+/*
+ * A general work queue.  Perform some task before the server
+ * sleeps for input.
+ */
+
+WorkQueuePtr workQueue;
+static WorkQueuePtr *workQueueLast = &workQueue;
+
+/* ARGSUSED */
+void
+ProcessWorkQueue(void)
+{
+    WorkQueuePtr q,
+                n,
+                p;
+
+    p = NULL;
+    /*
+     * Scan the work queue once, calling each function.  Those which return
+     * TRUE are removed from the queue, otherwise they will be called again.
+     * This must be reentrant with QueueWorkProc, hence the crufty usage of
+     * variables.
+     */
+    for (q = workQueue; q; q = n) {
+	if ((*q->function) (q->client, q->closure)) {
+	    /* remove q from the list */
+	    n = q->next;	/* don't fetch until after func called */
+	    if (p)
+		p->next = n;
+	    else
+		workQueue = n;
+	    fsfree(q);
+	} else {
+	    n = q->next;	/* don't fetch until after func called */
+	    p = q;
+	}
+    }
+    if (p)
+	workQueueLast = &p->next;
+    else {
+	workQueueLast = &workQueue;
+    }
+}
+
+Bool
+QueueWorkProc(
+    Bool        (*function) (ClientPtr, pointer),
+    ClientPtr   client,
+    pointer     data)
+{
+    WorkQueuePtr q;
+
+    q = (WorkQueuePtr) fsalloc(sizeof *q);
+    if (!q)
+	return FALSE;
+    q->function = function;
+    q->client = client;
+    q->closure = data;
+    q->next = NULL;
+    *workQueueLast = q;
+    workQueueLast = &q->next;
+    return TRUE;
+}
+
+/*
+ * Manage a queue of sleeping clients, awakening them
+ * when requested, by using the OS functions IgnoreClient
+ * and AttendClient.  Note that this *ignores* the troubles
+ * with request data interleaving itself with events, but
+ * we'll leave that until a later time.
+ */
+
+typedef struct _SleepQueue {
+    struct _SleepQueue *next;
+    ClientPtr   client;
+    Bool        (*function) (ClientPtr, pointer);
+    pointer     closure;
+}           SleepQueueRec, *SleepQueuePtr;
+
+static SleepQueuePtr sleepQueue = NULL;
+
+Bool
+ClientSleep(
+    ClientPtr   client,
+    Bool        (*function) (ClientPtr, pointer),
+    pointer     data)
+{
+    SleepQueuePtr q;
+
+    q = (SleepQueuePtr) fsalloc(sizeof *q);
+    if (!q)
+	return FALSE;
+
+    IgnoreClient(client);
+    q->next = sleepQueue;
+    q->client = client;
+    q->function = function;
+    q->closure = data;
+    sleepQueue = q;
+    return TRUE;
+}
+
+Bool
+ClientSignal(ClientPtr client)
+{
+    SleepQueuePtr q;
+
+    for (q = sleepQueue; q; q = q->next)
+	if (q->client == client) {
+	    return QueueWorkProc(q->function, q->client, q->closure);
+	}
+    return FALSE;
+}
+
+void
+ClientWakeup(ClientPtr client)
+{
+    SleepQueuePtr q,
+               *prev;
+
+    prev = &sleepQueue;
+    while ((q = *prev) != (SleepQueuePtr) 0) {
+	if (q->client == client) {
+	    *prev = q->next;
+	    fsfree(q);
+	    if (client->clientGone == CLIENT_GONE)
+		CloseDownClient(client);
+	    else
+		AttendClient(client);
+	    break;
+	}
+	prev = &q->next;
+    }
+}
+
+Bool
+ClientIsAsleep(ClientPtr client)
+{
+    SleepQueuePtr q;
+
+    for (q = sleepQueue; q; q = q->next)
+	if (q->client == client)
+	    return TRUE;
+    return FALSE;
+}
+
+pointer
+Xalloc(unsigned long m)
+{
+    return fsalloc(m);
+}
+
+pointer
+Xrealloc(pointer n, unsigned long m)
+{
+    return fsrealloc(n, m);
+}
+
+void
+Xfree(unsigned long *n)
+{
+    fsfree(n);
+}
+
+pointer
+Xcalloc(unsigned long n)
+{
+    pointer ret;
+
+    ret = fsalloc(n);
+    if (ret && n)
+	bzero(ret, n);
+    return ret;
+}
+
+int
+set_font_authorizations(char **authorizations, int *authlen, ClientPtr client)
+{
+#define AUTH1_NAME "hp-hostname-1"
+#define AUTH2_NAME "hp-printername-1"
+    static char result[1024];
+    char *p;
+    AuthContextPtr acp = client->auth;
+    int len1, len2;
+
+    if (acp != NULL && acp->authname != NULL && acp->authdata != NULL &&
+	(!strcmp(AUTH1_NAME, acp->authname) ||
+	 !strcmp(AUTH2_NAME, acp->authname)) &&
+	(len1 = strlen(acp->authname) + 1) +
+	(len2 = strlen(acp->authdata) + 1) + 2 * sizeof(short) <= 1024)
+    {
+	p = result;
+	*p++ = len1 >> 8;
+	*p++ = len1 &0xff;
+	*p++ = len2 >> 8;
+	*p++ = len2 & 0xff;
+	memmove( p, acp->authname, len1);
+	p += len1;
+	memmove( p, acp->authdata, len2);
+	p += len2;
+	*authlen = p - result;
+	*authorizations = result;
+	return 1;
+    }
+
+    *authlen = 0;
+    return 0;
+}
+
+int
+client_auth_generation(ClientPtr client)
+{
+    return client->auth_generation;
+}