/* Copyright 2006 Sun Microsystems, Inc.  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 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 <bsm/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

#define _SECURITY_SERVER

#include "security.h"

#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 void Swap32Write();

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 Atom tsol_lastAtom;

extern int tsol_nodelength;

extern TsolNodePtr tsol_node;

extern int NumCurrentSelections;

extern Selection *CurrentSelections;

extern WindowPtr tpwin;

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

/*

 * Get number of atoms defined in the system

 */

static Atom

GetLastAtom()

{

	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

UpdateTsolNode()

{

	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

ProcTsolInternAtom(client)

    register ClientPtr client;

{

    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

ProcTsolGetAtomName(client)

    register ClientPtr client;

{

    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);

    }

    else 

    { 

	client->errorValue = stuff->id;

	return (BadAtom);

    }

}

Atom

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

{

	TsolNodePtr tndp;

	int count;

	int k;

	int newsize;

	Atom lastAtom;

	Atom newAtom;

	bslabel_t **newsl;

	TsolInfoPtr tsolinfo;

	bslabel_t *sl;

	/* 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

ProcTsolSetSelectionOwner(client)

    register ClientPtr client;

{

    WindowPtr pWin;

    TimeStamp time;

    REQUEST(xSetSelectionOwnerReq);

#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)

    {

        pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,

					       SecurityReadAccess);

        if (!pWin)

            return(BadWindow);

    }

    else

        pWin = (WindowPtr)None;

    if (ValidAtom(stuff->selection))

    {

	int i = 0;

	/*

	 * First, see if the selection is already set... 

	 */

	while ((i < NumCurrentSelections) && 

	       CurrentSelections[i].selection != stuff->selection) 

            i++;

#ifdef TSOL

	/* 

	 * 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))

	    {

            if (tsolinfo->flags & TSOL_AUDITEVENT)

               auditwrite(AW_USEOFPRIV, 1, PRIV_WIN_SELECTION,

                          AW_APPEND, AW_END);

            tsol_sel_agnt = i; /* owner of this seln */

	    }

	    else

	    {

            if (tsolinfo->flags & TSOL_AUDITEVENT)

               auditwrite(AW_USEOFPRIV, 0, PRIV_WIN_SELECTION,

                          AW_APPEND, AW_END);

            client->errorValue = stuff->selection;

            return(BadAtom);

	    }

	}	

#endif /* TSOL */

        if (i < NumCurrentSelections)

        {        

	    xEvent event;

	  #ifdef TSOL

	    /* for poly-selections, search further to see if sl,uid match */

	    tsolseln = (TsolSelnPtr)CurrentSelections[i].secPrivate;

	    if (PolySelection(CurrentSelections[i].selection))

	    {

	        prevtsolseln = tsolseln;

            while (tsolseln)

            {

                if (tsolseln->uid == tsolinfo->uid &&

                    tsolseln->sl == tsolinfo->sl)

		            break; /* match found */

                prevtsolseln = tsolseln;

                tsolseln = tsolseln->next;

            }

	    }	    

	    if (PolySelection(CurrentSelections[i].selection) && tsolseln)

	    {

            if (CompareTimeStamps(time, tsolseln->lastTimeChanged) == EARLIER)

                return Success;

	        if (tsolseln->client && (!pWin || (tsolseln->client != client)))

	        {

                event.u.u.type = SelectionClear;

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

                event.u.selectionClear.window = tsolseln->window;

                event.u.selectionClear.atom = CurrentSelections[i].selection;

                (void)TryClientEvents (tsolseln->client,

                                       &event,

                                       1,

                                       NoEventMask,

                                       NoEventMask /* CantBeFiltered */,

                                       NullGrab);

	        }

	    }

	    else if (tsolseln)

	    {

            /* we use the existing code. So we left it unindented */

#endif /* TSOL */

            /* If the timestamp in client's request is in the past relative

		to the time stamp indicating the last time the owner of the

		selection was set, do not set the selection, just return 

		success. */

            if (CompareTimeStamps(time, CurrentSelections[i].lastTimeChanged)

		== EARLIER)

		return Success;

	    if (CurrentSelections[i].client &&

		(!pWin || (CurrentSelections[i].client != client)))

	    {

		event.u.u.type = SelectionClear;

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

		event.u.selectionClear.window = CurrentSelections[i].window;

		event.u.selectionClear.atom = CurrentSelections[i].selection;

		(void) TryClientEvents (CurrentSelections[i].client, &event, 1,

				NoEventMask, NoEventMask /* CantBeFiltered */,

				NullGrab);