/* Copyright 2009 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"

#include "dixstruct.h"

#include "xace.h"

#include "xacestr.h"

#ifdef PANORAMIX

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

#endif

#ifdef XCSECURITY

#define _SECURITY_SERVER

#include "security.h"

#include "../Xext/securitysrv.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

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(ExtensionEntry *extension);

static void BreakAllGrabs(ClientPtr client);

static unsigned char TsolReqCode = 0;

static int tsolEventBase = -1;

static int ScreenStripeHeight[MAX_SCREENS] = {0, 0};

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

int tsolMultiLevel = TRUE;

static int OwnerUIDint;

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

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

static SecurityHook tsolSecHook;

static XID TsolCheckAuthorization (unsigned int name_length,

	char *name, unsigned int data_length,

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

static void TsolSetClientInfo(ClientPtr client);

/* XACE hook callbacks */

static CALLBACK(TsolCheckExtensionAccess);

static CALLBACK(TsolCheckResourceIDAccess);

static CALLBACK(TsolProcessKeyboard);

/* other callbacks */

static CALLBACK(TsolClientStateCallback);

/*

 * Initialize the extension. Main entry point for this loadable

 * module.

 */

_X_EXPORT void

TsolExtensionInit(void)

{

	ExtensionEntry *extEntry;

	int i;

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

	}

        TsolReqCode = (unsigned char) extEntry->base;

        tsolEventBase = extEntry->eventBase;

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

		return;

	/* Allocate storage in devPrivates */

	if (!dixRequestPrivate(tsolPrivKey, sizeof (TsolPrivRec))) {

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

		return;

	}

	LoadTsolConfig();

	MakeTSOLAtoms();

	UpdateTsolNode();

	/* Initialize security hooks */

	tsolSecHook.CheckAuthorization = TsolCheckAuthorization;

	tsolSecHook.DeleteClientFromAnySelections = TsolDeleteClientFromAnySelections;

	tsolSecHook.DeleteWindowFromAnySelections = TsolDeleteWindowFromAnySelections;

	pSecHook = &tsolSecHook;

	XaceRegisterCallback(XACE_EXT_ACCESS, TsolCheckExtensionAccess, NULL);

	XaceRegisterCallback(XACE_KEY_AVAIL, TsolProcessKeyboard, NULL);

	XaceRegisterCallback(XACE_AUDIT_BEGIN, TsolAuditStart, NULL);

	XaceRegisterCallback(XACE_AUDIT_END, TsolAuditEnd, NULL);

	/* Save original Proc vectors */

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

		TsolSavedProcVector[i] = ProcVector[i];

		TsolSavedSwappedProcVector[i] = SwappedProcVector[i];

	}

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

	ProcVector[X_InternAtom] = ProcTsolInternAtom;

	ProcVector[X_CreateWindow] = ProcTsolCreateWindow;

	ProcVector[X_ConfigureWindow] = ProcTsolConfigureWindow;

	ProcVector[X_CirculateWindow] = ProcTsolCirculateWindow;

	ProcVector[X_ReparentWindow] = ProcTsolReparentWindow;

	ProcVector[X_GetGeometry] = ProcTsolGetGeometry;

	ProcVector[X_GrabServer] = ProcTsolGrabServer;

	ProcVector[X_UngrabServer] = ProcTsolUngrabServer;

	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_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 CALLBACK(

    TsolCheckResourceIDAccess)

{

    XaceResourceAccessRec *rec = calldata;

    ClientPtr client = rec->client;

    XID id = rec->id;

    RESTYPE rtype = rec->rtype;

    pointer rval = rec->res;

    Mask access_mode = rec->access_mode;

    Mask check_mode = access_mode;

    TsolInfoPtr tsolinfo;

    int msgType;

    int msgVerb;

    int reqtype;

    if (client->requestBuffer) {

	reqtype = MAJOROP;  /* protocol */

    } else {

	reqtype = -1;

    }

#define CHECK_RESOURCE_POLICY(DIX_MODE, TSOL_TYPE, TSOL_MODE, VAL, ID)	\

	    if (check_mode & (DIX_MODE)) {				\

		check_mode &= ~(DIX_MODE);				\

	    }

    switch (rtype) {

        case RT_GC:

	    CHECK_RESOURCE_POLICY(DixCreateAccess, TSOL_RES_GC, TSOL_CREATE,

				  NULL, id);

	    CHECK_RESOURCE_POLICY(DixDestroyAccess, TSOL_RES_GC, TSOL_DESTROY,

				  NULL, id);

	    break;

	case RT_WINDOW:		/* Drawables */

	    }

	    /* The rest falls through to code shared with RT_PIXMAP */

	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:

		    CHECK_RESOURCE_POLICY((DixReadAccess | DixBlendAccess),

		    CHECK_RESOURCE_POLICY(DixWriteAccess,

		break;

		case X_ClearArea:

		    rec->status = Success;

		    break;

	    }

	    break;

		rec->status = Success;

		break;

    }

#ifndef NO_TSOL_DEBUG_MESSAGES

    if (check_mode) { /* Any access mode bits not yet handled ? */

	LogMessageVerb(X_NOT_IMPLEMENTED, TSOL_MSG_UNIMPLEMENTED,

		       TSOL_LOG_PREFIX

		       "policy not implemented for CheckResourceAccess, "

		       "rtype=0x%x (%s), mode=0x%x (%s)\n",

		       (int) rtype, TsolResourceTypeString(rtype),

		       check_mode, TsolDixAccessModeNameString(check_mode));

    }

#endif /* !NO_TSOL_DEBUG_MESSAGES */

	msgType = X_ERROR;

	msgVerb = TSOL_MSG_ERROR;

    } else {

#ifdef NO_TSOL_DEBUG_MESSAGES

	/* rest of the function is just printing error or debug messages */

	return;

#else

	/* Trace messages for debugging */

	msgType = X_INFO;

	msgVerb = TSOL_MSG_ACCESS_TRACE;

#endif /* NO_TSOL_DEBUG_MESSAGES */

    }

    tsolinfo = GetClientTsolInfo(client);

    LogMessageVerb(msgType, msgVerb,

		   TSOL_LOG_PREFIX

		   "CheckResourceAccess(%s, %s, 0x%x, %s, %s) = %s\n",

		   tsolinfo->pname,

		   TsolResourceTypeString(rtype), id,

		   TsolDixAccessModeNameString(access_mode),

		   TsolRequestNameString(reqtype),

		   TsolErrorNameString(rec->status));

}

static