*

 * 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 the rights to use, copy, modify, merge, publish,

 * distribute, and/or sell copies of the Software, and to permit persons

 * to whom the Software is furnished to do so, provided that the above

 * copyright notice(s) and this permission notice appear in all copies of

 * the Software and that both the above copyright notice(s) and this

 * permission notice appear in supporting documentation.

 *

 * 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

 * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

 * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR 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.

 *

 * Except as contained in this notice, the name of a copyright holder

 * shall not be used in advertising or otherwise to promote the sale, use

 * or other dealings in this Software without prior written authorization

 * of the copyright holder.

#include <sys/param.h>

#include <fcntl.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#include <ucred.h>

#include <pwd.h>

#include <strings.h>

#include <sys/wait.h>

#include "auditwrite.h"

#include <bsm/libbsm.h>

#include <bsm/audit_uevents.h>

#include "tsol.h"

#include "inputstr.h"

#define NEED_REPLIES

#include "selection.h"

#include "osdep.h"

#include "tsolpolicy.h"

#include "swaprep.h"

#include "swapreq.h"

#include "servermd.h"

#ifdef PANORAMIX

#include "../Xext/panoramiXsrv.h"

#endif

#ifdef XCSECURITY

#endif

/*

 * The event # here match those in /usr/include/bsm/audit_uevents.h.

 * Changes in one should go with corresponding changes in another.

 */

#define MAX_AUDIT_EVENTS 100

int audit_eventsid[100][2] = {

};

extern int (*TsolSavedProcVector[PROCVECTORSIZE])(ClientPtr /*client*/);

extern int (*TsolSavedSwappedProcVector[PROCVECTORSIZE])(ClientPtr /*client*/);

Atom MakeTSOLAtom(ClientPtr client, char *string, unsigned int len, Bool makeit);

#define INITIAL_TSOL_NODELENGTH 1500

extern WindowPtr XYToWindow(int x, int y);

	WindowPtr pHead, BoxPtr box);

extern Atom tsol_lastAtom;

extern int tsol_nodelength;

extern TsolNodePtr tsol_node;

extern WindowPtr tpwin;

extern int tsolMultiLevel;

extern char     *ConnectionInfo;

extern int      connBlockScreenStart;

static int tsol_sel_agnt = -1; /* index this to CurrentSelection to get seln */

/*

 * Get number of atoms defined in the system

 */

static Atom

{

	Atom a = (Atom) 1; /* atoms start at 1 */

	while (ValidAtom(a)) {

		a++;

	}

	return (--a);

}

/*

 * Update Tsol info for atoms. This function gets

 * called typically during initialization. But, it could also get

 * called if some atoms are created internally by server.

 */

void

{

	Atom lastAtom = GetLastAtom();

	Atom ia;

	/* Update may not be needed */

	if (lastAtom == None || lastAtom == tsol_lastAtom)

		return;

	if (tsol_node == NULL) {

		int newsize = (lastAtom > INITIAL_TSOL_NODELENGTH ? lastAtom : INITIAL_TSOL_NODELENGTH);

		/* Initialize */

		tsol_node = (TsolNodePtr )xalloc((newsize + 1) * sizeof(TsolNodeRec));

		tsol_nodelength = newsize;

		if (tsol_node != NULL) {

			/* Atom id 0 is invalid */

			tsol_lastAtom = 0;

			tsol_node[0].flags = 0;

			tsol_node[0].slcount = 0;

			tsol_node[0].sl = NULL;

			tsol_node[0].slsize = 0;

			tsol_node[0].IsSpecial = 0;

		}

	}

	if (tsol_nodelength <= lastAtom) {

		tsol_node = (TsolNodePtr )xrealloc(tsol_node, (lastAtom + 1) * sizeof(TsolNodeRec));

		tsol_nodelength = lastAtom + 1;

	}

	if (tsol_node == NULL) {

		ErrorF("Cannot allocate memory for Tsol node\n");

		return;

	}

	 * Initialize the tsol node for each atom

	 */

	for (ia = tsol_lastAtom + 1; ia <= lastAtom; ia++) {

		char *atomname = NameForAtom(ia);

		tsol_node[ia].slcount = 0;

		tsol_node[ia].sl = NULL;

		tsol_node[ia].slsize= 0;

		tsol_node[ia].flags = MatchTsolConfig(atomname, strlen(atomname));

		tsol_node[ia].IsSpecial = SpecialName(atomname, strlen(atomname));

	}

	tsol_lastAtom = lastAtom;

}

int

{

    Atom atom;

    char *tchar;

    REQUEST(xInternAtomReq);

    REQUEST_FIXED_SIZE(xInternAtomReq, stuff->nbytes);

    if ((stuff->onlyIfExists != xTrue) && (stuff->onlyIfExists != xFalse))

    {

	client->errorValue = stuff->onlyIfExists;

        return(BadValue);

    }

    tchar = (char *) &stuff[1];

    atom = MakeTSOLAtom(client, tchar, stuff->nbytes, !stuff->onlyIfExists);

    if (atom != BAD_RESOURCE)

    {

	xInternAtomReply reply;

	reply.type = X_Reply;

	reply.length = 0;

	reply.sequenceNumber = client->sequence;

	reply.atom = atom;

	WriteReplyToClient(client, sizeof(xInternAtomReply), &reply);

	return(client->noClientException);

    }

    else

	return (BadAlloc);

}

int

{

    char *str;

    xGetAtomNameReply reply;

    int len;

    REQUEST(xResourceReq);

    REQUEST_SIZE_MATCH(xResourceReq);

    /* TBD: NameForTSOLAtom */

    if ( (str = NameForAtom(stuff->id)) )

    {

	len = strlen(str);

	reply.type = X_Reply;

	reply.length = (len + 3) >> 2;

	reply.sequenceNumber = client->sequence;

	reply.nameLength = len;

	WriteReplyToClient(client, sizeof(xGetAtomNameReply), &reply);

	(void)WriteToClient(client, len, str);

	return(client->noClientException);

    }

	client->errorValue = stuff->id;

	return (BadAtom);

    }

}

Atom

MakeTSOLAtom(ClientPtr client, char *string, unsigned int len, Bool makeit)

{

	TsolNodePtr tndp;

	int k;

	int newsize;

	Atom newAtom;

	TsolInfoPtr tsolinfo;

	/* Make the atom as usual */

	newAtom = MakeAtom(string, len, makeit);

	if (newAtom == None || newAtom == BAD_RESOURCE) {

		return (newAtom);

	}

	tsolinfo = GetClientTsolInfo(client);

	/* tsol node info already present? */

	if (newAtom <= tsol_lastAtom) {

		tndp = &(tsol_node[newAtom]);

		/* public atoms have null sl */

		if (tndp->sl == NULL) {

			return newAtom;

		}

		/* private atoms must have a matching sl */

		for (k = 0; k < tndp->slcount; k++) {

			if (tsolinfo->sl == tndp->sl[k]) {

				return newAtom; /* found one */

			}

		}

	} else {

		/* tsol node table not big enough, expand it */

		UpdateTsolNode();

		tndp = &(tsol_node[newAtom]);

	}

	/* Allocate storage for sl if needed */

	if (tndp->sl == NULL) {

		tndp->sl = (bslabel_t **)xalloc(NODE_SLSIZE * (sizeof(bslabel_t *)));

		tndp->slcount = 0;

		tndp->slsize = NODE_SLSIZE;

	}

	/* Expand storage space for sl if needed */

	if (tndp->slsize < tndp->slcount) {

		newsize = tndp->slsize + NODE_SLSIZE;

		tndp->sl = (bslabel_t **)xrealloc(tndp->sl, newsize * (sizeof(bslabel_t *)));

		tndp->slsize = newsize;

	}

	if (tndp->sl == NULL) {

		ErrorF("Not enough memory for atoms\n");

		return (Atom)None;

	}

	/* Store client's sl */

	tndp->sl[tndp->slcount] = tsolinfo->sl;

	tndp->slcount++;

	return newAtom;

}

int

{

    TimeStamp time;

#ifdef TSOL

    TsolSelnPtr tsolseln = NULL;

    TsolSelnPtr prevtsolseln = NULL;

    TsolInfoPtr tsolinfo = GetClientTsolInfo(client);

#endif /* TSOL */

    REQUEST_SIZE_MATCH(xSetSelectionOwnerReq);

    UpdateCurrentTime();

    time = ClientTimeToServerTime(stuff->time);

    /* If the client's time stamp is in the future relative to the server's

	time stamp, do not set the selection, just return success. */

    if (CompareTimeStamps(time, currentTime) == LATER)

    	return Success;

    if (stuff->window != None)

    {

    }

	int i = 0;

	/*

	 * special processing for selection agent. Just note

	 * the owner of this special selection

	 */

	if (stuff->selection == MakeAtom("_TSOL_SEL_AGNT", 14, 1))

	{

	    if (HasWinSelection(tsolinfo))

	    {

	    }

	    else

	    {

	    }

	    {

	    }

		== EARLIER)

		return Success;

	    {

		event.u.u.type = SelectionClear;

		event.u.selectionClear.time = time.milliseconds;