/* Copyright 2008 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 <stdio.h>

#include "auditwrite.h"

#include <bsm/libbsm.h>

#include <bsm/audit_uevents.h>

#include <sys/param.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/wait.h>

#include <ucred.h>

#include <netinet/in.h>

#include <netdb.h>

#include <arpa/inet.h>

#include <sys/tsol/tndb.h>

#include <strings.h>

#include <string.h>

#include <pwd.h>

#include <unistd.h>

#include <sys/stat.h>

#include <rpc/rpc.h>

#include <zone.h>

#define NEED_REPLIES

#ifdef HAVE_DIX_CONFIG_H

#include <dix-config.h>

#endif

#include "misc.h"

#include "osdep.h"

#include <X11/Xauth.h>

#include "tsol.h"

#include "inputstr.h"

#include "extnsionst.h"

#ifdef PANORAMIX

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

#endif

#ifdef XCSECURITY

#define _SECURITY_SERVER

#include "security.h"

#endif

#include "tsolpolicy.h"

#define  BadCmapCookie      0

#define  Tsolextension      0x0080    /* Tsol extensions begin at 128 */

#define  MAX_SCREENS        3         /* screens allowed */

#define EXTNSIZE 128

#define SECURE_RPC_AUTH	"SUN-DES-1"

#define SECURE_RPC_LEN	9

extern bslabel_t *lookupSL();

extern void (*ReplySwapVector[]) ();

extern TsolInfoPtr GetClientTsolInfo();

extern char *NameForAtom(Atom atom);

static int ProcTsolDispatch(ClientPtr);

static int ProcSetPolyInstInfo(ClientPtr);

static int ProcSetPropLabel(ClientPtr);

static int ProcSetPropUID(ClientPtr);

static int ProcSetResLabel(ClientPtr);

static int ProcSetResUID(ClientPtr);

static int ProcGetClientAttributes(ClientPtr);

static int ProcGetClientLabel(ClientPtr);

static int ProcGetPropAttributes(ClientPtr);

static int ProcGetResAttributes(ClientPtr);

static int ProcMakeTPWindow(ClientPtr);

static int ProcMakeTrustedWindow(ClientPtr);

static int ProcMakeUntrustedWindow(ClientPtr);

static int SProcTsolDispatch(ClientPtr);

static int SProcSetPolyInstInfo(ClientPtr);

static int SProcSetPropLabel(ClientPtr);

static int SProcSetPropUID(ClientPtr);

static int SProcSetResLabel(ClientPtr);

static int SProcSetResUID(ClientPtr);

static int SProcGetClientAttributes(ClientPtr);

static int SProcGetClientLabel(ClientPtr);

static int SProcGetPropAttributes(ClientPtr);

static int SProcGetResAttributes(ClientPtr);

static int SProcMakeTPWindow(ClientPtr);

static int SProcMakeTrustedWindow(ClientPtr);

static int SProcMakeUntrustedWindow(ClientPtr);

static void TsolReset();

static void BreakAllGrabs(ClientPtr client);

extern void init_xtsol();

extern void init_win_privsets();

extern void free_win_privsets();

extern int DoScreenStripeHeight(int screen_num);

extern int AddUID(int *userid);

static unsigned char TsolReqCode = 0;

static int tsolEventBase = -1;

extern unsigned int StripeHeight;

int ScreenStripeHeight[MAX_SCREENS - 1] = {0, 0};

extern int tsolClientPrivateIndex;

extern int tsolWindowPrivateIndex;

extern int tsolPixmapPrivateIndex;

static HotKeyRec hotkey = {FALSE, 0, 0, 0, 0};

int tsolMultiLevel = TRUE;

int OwnerUIDint;

extern uid_t OwnerUID;

uid_t PublicObjUID = 0;

extern WindowPtr tpwin;

extern bclear_t SessionHI;        /* HI Clearance */

extern bclear_t SessionLO;        /* LO Clearance */

extern TsolPolyInstInfoRec tsolpolyinstinfo;

extern void LoadTsolConfig();

extern void MakeTSOLAtoms();

extern void UpdateTsolNode();

/*

 * Protocol handling vectors

 */

extern int (*ProcVector[])();

extern int (*SwappedProcVector[])();

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

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

extern SecurityHookPtr pSecHook;

SecurityHook tsolSecHook;

XID TsolCheckAuthorization (unsigned int name_length,

	char *name, unsigned int data_length, 

	char *data, ClientPtr client, char **reason);

void TsolDeleteClientFromAnySelections(ClientPtr);

void TsolDeleteWindowFromAnySelections(WindowPtr);

extern int TsolChangeWindowProperty(ClientPtr, WindowPtr, Atom, Atom, int, int,

	unsigned long, pointer, Bool);

extern int TsolDeleteProperty(ClientPtr, WindowPtr, Atom);

extern int TsolInitWindow(ClientPtr, WindowPtr);

extern void TsolAuditStart(ClientPtr);

extern void TsolAuditEnd(ClientPtr, int);

static void TsolClientStateCallback(CallbackListPtr *pcbl,

	pointer nulldata, pointer calldata);

static void TsolSetClientInfo(ClientPtr client);

static void TsolProcessKeyboard(xEvent *, KeyClassPtr);

static char TsolCheckPropertyAccess(ClientPtr client, WindowPtr pWin, ATOM propertyName,

	Mask access_mode);

extern int ProcTsolInternAtom(ClientPtr client);

extern int ProcTsolSetSelectionOwner(ClientPtr client);

extern int ProcTsolGetSelectionOwner(ClientPtr client);

extern int ProcTsolConvertSelection(ClientPtr client);

extern int ProcTsolGetProperty(ClientPtr client);

extern int ProcTsolListProperties(ClientPtr client);

extern int ProcTsolChangeKeyboardMapping(ClientPtr client);

extern int ProcTsolSetPointerMapping(ClientPtr client);

extern int ProcTsolChangeKeyboardControl(ClientPtr client);

extern int ProcTsolBell(ClientPtr client);

extern int ProcTsolChangePointerControl(ClientPtr client);

extern int ProcTsolSetModifierMapping(ClientPtr client);

extern int ProcTsolCreateWindow(ClientPtr client);

extern int ProcTsolChangeWindowAttributes(ClientPtr client);

extern int ProcTsolConfigureWindow(ClientPtr client);

extern int ProcTsolCirculateWindow(ClientPtr client);

extern int ProcTsolReparentWindow(ClientPtr client);

extern int ProcTsolSetInputFocus(ClientPtr client);

extern int ProcTsolGetInputFocus(ClientPtr client);

extern int ProcTsolSendEvent(ClientPtr client);

extern int ProcTsolSetInputFocus(ClientPtr client);

extern int ProcTsolGetInputFocus(ClientPtr client);

extern int ProcTsolGetGeometry(ClientPtr client);

extern int ProcTsolGrabServer(ClientPtr client);

extern int ProcTsolUngrabServer(ClientPtr client);

extern int ProcTsolCreatePixmap(ClientPtr client);

extern int ProcTsolSetScreenSaver(ClientPtr client);

extern int ProcTsolChangeHosts(ClientPtr client);

extern int ProcTsolChangeAccessControl(ClientPtr client);

extern int ProcTsolKillClient(ClientPtr client);

extern int ProcTsolSetFontPath(ClientPtr client);

extern int ProcTsolChangeCloseDownMode(ClientPtr client);

extern int ProcTsolListInstalledColormaps(ClientPtr client);

extern int ProcTsolGetImage(ClientPtr client);

extern int ProcTsolQueryTree(ClientPtr client);

extern int ProcTsolQueryPointer(ClientPtr client);

extern int ProcTsolQueryExtension(ClientPtr client);

extern int ProcTsolListExtensions(ClientPtr client);

extern int ProcTsolMapWindow(ClientPtr client);

extern int ProcTsolMapSubwindows(ClientPtr client);

extern int ProcTsolCopyArea(ClientPtr client);

extern int ProcTsolCopyPlane(ClientPtr client);

extern int ProcTsolPolySegment(ClientPtr client);

extern int ProcTsolPolyRectangle(ClientPtr client);

extern int TsolPanoramiXGetGeometry(ClientPtr client);

/*

 * Initialize the extension. Main entry point for this loadable

 * module.

 */

void

TsolExtensionInit()

{

	ExtensionEntry *extEntry;

	ScreenPtr pScreen;

	int i;

	priv_set_t	*pset;

	/* sleep(20); */

	/* This extension is supported on a labeled system */

	if (!is_system_labeled()) {

		return;

	}

	tsolMultiLevel = TRUE;

	(void) setpflags(PRIV_AWARE, 1);

	init_xtsol();

	init_win_privsets();

	extEntry = AddExtension(TSOLNAME, TSOL_NUM_EVENTS, TSOL_NUM_ERRORS,

		ProcTsolDispatch, SProcTsolDispatch, TsolReset, 

		StandardMinorOpcode);

	if (extEntry == NULL) {

		ErrorF("TsolExtensionInit: AddExtension failed for X Trusted Extensions\n");

		return;

	}

	extEntry->secure = TRUE;

        TsolReqCode = (unsigned char) extEntry->base;

        tsolEventBase = extEntry->eventBase;

	if (!AddCallback(&ClientStateCallback, TsolClientStateCallback, NULL))

		return;

	/* Allocate the client private index */

	tsolClientPrivateIndex = AllocateClientPrivateIndex();

	if (!AllocateClientPrivate(tsolClientPrivateIndex,

		   sizeof (TsolInfoRec))) {

		ErrorF("TsolExtensionInit: Cannot allocate client private.\n");

		return;

	}

	/* Allocate per screen window/pixmap private index */

	tsolWindowPrivateIndex = AllocateWindowPrivateIndex();

	tsolPixmapPrivateIndex = AllocatePixmapPrivateIndex();

	for (i = 0; i < screenInfo.numScreens; i++) {

		pScreen = screenInfo.screens[i];

		if (!AllocateWindowPrivate(pScreen, tsolWindowPrivateIndex,

			   sizeof (TsolResRec))) {

			ErrorF("TsolExtensionInit: Cannot allocate window private.\n");

            		return;

		}

		if (!AllocatePixmapPrivate(pScreen, tsolPixmapPrivateIndex,

                                   sizeof (TsolResRec))) {

			ErrorF("TsolExtensionInit: Cannot allocate pixmap private.\n");

			return;

		}

	}

	LoadTsolConfig();

	MakeTSOLAtoms();

	UpdateTsolNode();

	/* Save original Proc vectors */

	for (i = 0; i < PROCVECTORSIZE; i++) {

		TsolSavedProcVector[i] = ProcVector[i];

		TsolSavedSwappedProcVector[i] = SwappedProcVector[i];

	}

	/* Initialize security hooks */

	tsolSecHook.CheckAuthorization = TsolCheckAuthorization;

	tsolSecHook.ChangeWindowProperty = TsolChangeWindowProperty;

	tsolSecHook.CheckPropertyAccess = TsolCheckPropertyAccess;

	tsolSecHook.DeleteProperty = TsolDeleteProperty;

	tsolSecHook.InitWindow = TsolInitWindow;

	tsolSecHook.ProcessKeyboard = TsolProcessKeyboard;

	tsolSecHook.DeleteClientFromAnySelections = TsolDeleteClientFromAnySelections;

	tsolSecHook.DeleteWindowFromAnySelections = TsolDeleteWindowFromAnySelections;

	tsolSecHook.AuditStart = TsolAuditStart;

	tsolSecHook.AuditEnd = TsolAuditEnd;

	pSecHook = &tsolSecHook;

	/* Replace some of the original Proc vectors with our own TBD */

	ProcVector[X_InternAtom] = ProcTsolInternAtom;

	ProcVector[X_SetSelectionOwner] = ProcTsolSetSelectionOwner;

	ProcVector[X_GetSelectionOwner] = ProcTsolGetSelectionOwner;

	ProcVector[X_ConvertSelection] = ProcTsolConvertSelection;

	ProcVector[X_GetProperty] = ProcTsolGetProperty;

	ProcVector[X_ListProperties] = ProcTsolListProperties;

	ProcVector[X_ChangeKeyboardMapping] = ProcTsolChangeKeyboardMapping;

	ProcVector[X_SetPointerMapping] = ProcTsolSetPointerMapping;

	ProcVector[X_ChangeKeyboardControl] = ProcTsolChangeKeyboardControl;

	ProcVector[X_Bell] = ProcTsolBell;

	ProcVector[X_ChangePointerControl] = ProcTsolChangePointerControl;

	ProcVector[X_SetModifierMapping] = ProcTsolSetModifierMapping;

	ProcVector[X_CreateWindow] = ProcTsolCreateWindow;

	ProcVector[X_ChangeWindowAttributes] = ProcTsolChangeWindowAttributes;

	ProcVector[X_ConfigureWindow] = ProcTsolConfigureWindow;

	ProcVector[X_CirculateWindow] = ProcTsolCirculateWindow;

	ProcVector[X_ReparentWindow] = ProcTsolReparentWindow;

	ProcVector[X_SetInputFocus] = ProcTsolSetInputFocus;

	ProcVector[X_GetInputFocus] = ProcTsolGetInputFocus;

	ProcVector[X_SendEvent] = ProcTsolSendEvent;

	ProcVector[X_SetInputFocus] = ProcTsolSetInputFocus;

	ProcVector[X_GetInputFocus] = ProcTsolGetInputFocus;

	ProcVector[X_GetGeometry] = ProcTsolGetGeometry;

	ProcVector[X_GrabServer] = ProcTsolGrabServer;

	ProcVector[X_UngrabServer] = ProcTsolUngrabServer;

	ProcVector[X_CreatePixmap] = ProcTsolCreatePixmap;

	ProcVector[X_SetScreenSaver] = ProcTsolSetScreenSaver;

	ProcVector[X_ChangeHosts] = ProcTsolChangeHosts;

	ProcVector[X_SetAccessControl] = ProcTsolChangeAccessControl;

	ProcVector[X_KillClient] = ProcTsolKillClient;

	ProcVector[X_SetFontPath] = ProcTsolSetFontPath;

	ProcVector[X_SetCloseDownMode] = ProcTsolChangeCloseDownMode;

	ProcVector[X_ListInstalledColormaps] = ProcTsolListInstalledColormaps;

	ProcVector[X_GetImage] = ProcTsolGetImage;

	ProcVector[X_QueryTree] = ProcTsolQueryTree;

	ProcVector[X_QueryPointer] = ProcTsolQueryPointer;

	ProcVector[X_QueryExtension] = ProcTsolQueryExtension;

	ProcVector[X_ListExtensions] = ProcTsolListExtensions;

	ProcVector[X_MapWindow] = ProcTsolMapWindow;

	ProcVector[X_MapSubwindows] = ProcTsolMapSubwindows;

	ProcVector[X_CopyArea] = ProcTsolCopyArea;

	ProcVector[X_CopyPlane] = ProcTsolCopyPlane;

	ProcVector[X_PolySegment] = ProcTsolPolySegment;

	ProcVector[X_PolyRectangle] = ProcTsolPolyRectangle;

}

static pointer

TsolCheckResourceIDAccess(

    ClientPtr client,

    XID id,

    RESTYPE rtype,

    Mask access_mode,

    pointer rval)

{

    int cid = CLIENT_ID(id);

    int reqtype = ((xReq *)client->requestBuffer)->reqType;  /* protocol */

    pointer retval;

    char msgbuf[1024];

    retval = rval;

    switch (rtype) {

	case RT_GC:

		switch (access_mode) {

		case SecurityReadAccess:

		    if (xtsol_policy(TSOL_RES_GC, TSOL_READ, (void *)id,

			client, TSOL_ALL, (void *)MAJOROP))

				retval = NULL;

		    break;

		case SecurityWriteAccess:

		    if (xtsol_policy(TSOL_RES_GC, TSOL_MODIFY, (void *)id,

			client, TSOL_ALL, (void *)MAJOROP))

				retval = NULL;

		    break;

		case SecurityDestroyAccess:

		    if (xtsol_policy(TSOL_RES_GC, TSOL_DESTROY, (void *)id,

			client, TSOL_ALL, (void *)MAJOROP))

				retval = NULL;

		    break;

		}

		break;

	case RT_WINDOW:		/* Drawables */

	case RT_PIXMAP:

	    /* Drawing operations use pixel access policy */

	    switch (reqtype) {

		case X_PolyPoint:

		case X_PolyLine:

		case X_PolyArc:

		case X_FillPoly:

		case X_PolyFillRectangle:

		case X_PolyFillArc:

		case X_PutImage:

		case X_PolyText8:

		case X_PolyText16:

		case X_ImageText8:

		case X_ImageText16:

		switch (access_mode) {

		case SecurityReadAccess:

		    if (xtsol_policy(TSOL_RES_PIXEL, TSOL_READ, (void *)rval,

			client, TSOL_ALL, (void *)MAJOROP))

				retval = NULL;

		    break;

		case SecurityWriteAccess:

		    if (xtsol_policy(TSOL_RES_PIXEL, TSOL_MODIFY, (void *)rval,

			client, TSOL_ALL, (void *)MAJOROP))

				retval = NULL;

		    break;

    		}

		break;

		/* Property protocols */

		case X_ChangeProperty:

		case X_DeleteProperty:

		case X_GetProperty:

		case X_ListProperties:

		case X_RotateProperties:

		switch (access_mode) {

		case SecurityReadAccess:

		    if (xtsol_policy(TSOL_RES_PROPWIN, TSOL_READ, (void *)rval,

			client, TSOL_ALL, (void *)MAJOROP))

				retval = NULL;

		    break;

		case SecurityWriteAccess:

		    if (xtsol_policy(TSOL_RES_PROPWIN, TSOL_MODIFY, (void *)rval,

			client, TSOL_ALL, (void *)MAJOROP))

				retval = NULL;

		    break;

    		}

		break;

		}

		break;

    }

    if (retval == NULL) {

    	TsolInfoPtr tsolinfo, res_tsolinfo;

    	tsolinfo = GetClientTsolInfo(client);

	snprintf(msgbuf, sizeof (msgbuf), 

	    "Access failed: cid = %d, rtype=%X, access=%d, xid=%X, proto = %d, pid = %d\n",

		cid, rtype, access_mode, id, reqtype, tsolinfo->pid);

	ErrorF(msgbuf);

    }

    return retval;

}

static void

TsolClientStateCallback(CallbackListPtr *pcbl,

	pointer nulldata,

	pointer calldata)

{

 	NewClientInfoRec *pci = (NewClientInfoRec *)calldata;

	ClientPtr client = pci->client;

	TsolInfoPtr tsolinfo = (TsolInfoPtr)

		(client->devPrivates[tsolClientPrivateIndex].ptr);

	switch (client->clientState) {

	case ClientStateInitial:

		/* Got a new connection */

		TsolSetClientInfo(client);

		client->CheckAccess = TsolCheckResourceIDAccess;

		break;

	case ClientStateRunning:

		break;

	case ClientStateRetained:	/* client disconnected */

		break;

	case ClientStateGone:

		if (tpwin && wClient(tpwin) == client)

		    tpwin = NULL; /* reset tpwin */

		if (tsolinfo != NULL && tsolinfo->privs != NULL) {

			priv_freeset(tsolinfo->privs);

		}

		/* Audit disconnect */

		if (system_audit_on && (au_preselect(AUE_ClientDisconnect, &(tsolinfo->amask),

                              AU_PRS_BOTH, AU_PRS_USECACHE) == 1)) {

			auditwrite(AW_PRESELECT, &(tsolinfo->amask),AW_END);

			auditwrite(AW_EVENTNUM, AUE_ClientDisconnect,

                               AW_XCLIENT, client->index,

			       AW_SLABEL, tsolinfo->sl,

                               AW_RETURN, 0, 0, AW_WRITE, AW_END);

			tsolinfo->flags &= ~TSOL_DOXAUDIT;

			tsolinfo->flags &= ~TSOL_AUDITEVENT;

			auditwrite(AW_FLUSH, AW_END);

			auditwrite(AW_DISCARDRD, tsolinfo->asaverd, AW_END);

			auditwrite(AW_NOPRESELECT, AW_END);

		}

		break;