*

 * 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, sublicense,

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

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice (including the next

 * paragraph) 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 AUTHORS OR COPYRIGHT HOLDERS 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.

 */

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

#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

#include <X11/extensions/secur.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};

int tsolMultiLevel = TRUE;

int tsol_mac_enabled;

static int OwnerUIDint;

static Selection *tsol_sel_agnt = NULL; /* entry in CurrentSelection to get seln */

static Atom tsol_atom_sel_agnt = 0; /* selection agent atom created during init */

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

static CALLBACK(TsolCheckResourceIDAccess);

static CALLBACK(TsolCheckSendAccess);

static CALLBACK(TsolCheckReceiveAccess);

static CALLBACK(TsolCheckSelectionAccess);

static CALLBACK(TsolProcessKeyboard);

CALLBACK(TsolCheckDeviceAccess);

CALLBACK(TsolCheckServerAccess);

CALLBACK(TsolCheckClientAccess);

/* other callbacks */

static CALLBACK(TsolClientStateCallback);

static CALLBACK(TsolSelectionCallback);

	xpolicy_t flags, int reqcode);

	pointer calldata);

	pointer calldata);

extern Bool client_has_privilege(TsolInfoPtr tsolinfo, priv_set_t *priv);

extern priv_set_t *pset_win_mac_write;

extern priv_set_t *pset_win_dac_write;

extern priv_set_t *pset_win_config;

extern RESTYPE RREventType;

/*

 * Initialize the extension. Main entry point for this loadable

 * module.

 */

_X_EXPORT void

TsolExtensionInit(void)

{

	ExtensionEntry *extEntry;

	int i;

	/* sleep(20); */

	if (is_system_labeled()) {

		tsol_mac_enabled = TRUE;

	} else {

		/* DAC support can be added in future */

		tsol_mac_enabled = FALSE;

		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;

	if (!AddCallback(&SelectionCallback, TsolSelectionCallback, NULL))

		return;

	/* Allocate storage in devPrivates */

		return;

	}

	/* Initialize the client info for server itself */

    	if (serverClient) {

        	TsolInfoPtr tsolinfo = GetClientTsolInfo(serverClient);

		if (tsolinfo->sl == NULL) {

			tsolinfo->sl = (bslabel_t *)lookupSL_low();

			tsolinfo->uid = 0;

			tsolinfo->pid = getpid();

		}

	}

	LoadTsolConfig();

	MakeTSOLAtoms();

	UpdateTsolNode(0, NULL);

	tsol_atom_sel_agnt = MakeAtom("_TSOL_SEL_AGNT", 14, 1);

	/* Initialize security hooks */

	tsolSecHook.CheckAuthorization = TsolCheckAuthorization;

	pSecHook = &tsolSecHook;

	XaceRegisterCallback(XACE_EXT_DISPATCH, TsolCheckExtensionAccess, NULL);

	XaceRegisterCallback(XACE_RESOURCE_ACCESS, TsolCheckResourceIDAccess, NULL);

	XaceRegisterCallback(XACE_PROPERTY_ACCESS, TsolCheckPropertyAccess, NULL);

	XaceRegisterCallback(XACE_SEND_ACCESS, TsolCheckSendAccess, NULL);

	XaceRegisterCallback(XACE_RECEIVE_ACCESS, TsolCheckReceiveAccess, NULL);

	XaceRegisterCallback(XACE_EXT_ACCESS, TsolCheckExtensionAccess, NULL);

	XaceRegisterCallback(XACE_DEVICE_ACCESS, TsolCheckDeviceAccess, NULL);

	XaceRegisterCallback(XACE_SCREEN_ACCESS, TsolCheckDeviceAccess, NULL);

	XaceRegisterCallback(XACE_SCREENSAVER_ACCESS, TsolCheckDeviceAccess, NULL);

	XaceRegisterCallback(XACE_SELECTION_ACCESS, TsolCheckSelectionAccess, NULL);

	XaceRegisterCallback(XACE_SERVER_ACCESS, TsolCheckServerAccess, NULL);

	XaceRegisterCallback(XACE_CLIENT_ACCESS, TsolCheckClientAccess, 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];

	}

	ProcVector[X_InternAtom] = ProcTsolInternAtom;

	ProcVector[X_GetAtomName] = ProcTsolGetAtomName;

	ProcVector[X_CreateWindow] = ProcTsolCreateWindow;

	ProcVector[X_ChangeWindowAttributes] = ProcTsolChangeWindowAttributes;

	ProcVector[X_ConfigureWindow] = ProcTsolConfigureWindow;

	ProcVector[X_CirculateWindow] = ProcTsolCirculateWindow;

	ProcVector[X_ReparentWindow] = ProcTsolReparentWindow;

	ProcVector[X_GrabServer] = ProcTsolGrabServer;

	ProcVector[X_UngrabServer] = ProcTsolUngrabServer;

	ProcVector[X_GetImage] = ProcTsolGetImage;

	ProcVector[X_QueryTree] = ProcTsolQueryTree;

	ProcVector[X_QueryPointer] = ProcTsolQueryPointer;

	ProcVector[X_GetGeometry] = ProcTsolGetGeometry;

	ProcVector[X_CopyArea] = ProcTsolCopyArea;

	ProcVector[X_CopyPlane] = ProcTsolCopyPlane;

	ProcVector[X_PolySegment] = ProcTsolPolySegment;

	ProcVector[X_PolyRectangle] = ProcTsolPolyRectangle;

}

static CALLBACK(

    TsolCheckResourceIDAccess)

{

	XaceResourceAccessRec *rec = calldata;

	RESTYPE rtype = rec->rtype;

	switch (rtype) {

	case RT_WINDOW:

		/* Drawables policy */

		TsolCheckDrawableAccess(pcbl, nulldata, calldata);

		break;

	case RT_GC:

	case RT_CURSOR:

	case RT_FONT:

		TsolCheckXIDAccess(pcbl, nulldata, calldata);

		break;

	default:

		 * Handle other resource types.

		 * enforced before checking for RREventType.

		 */

		if (rtype == RREventType) {

			rec->status = Success;

		}

		break;

	}

}

static

CALLBACK(TsolSelectionCallback)

{

	SelectionInfoRec *pselinfo = (SelectionInfoRec *)calldata;

	Selection *pSel = pselinfo->selection;

	switch (pselinfo->kind) {

	case SelectionClientClose:

	    if (tsol_sel_agnt && pSel->selection ==  tsol_sel_agnt->selection) {

		tsol_sel_agnt = NULL; /* selection manager died. */

	    }

	/* fall through to reset the SL */

	case SelectionWindowDestroy:

	    break;

	default:

	    /* All others handled in SelectionAccess handler */

	    break;

	}

}

static

CALLBACK(TsolClientStateCallback)

{

 	NewClientInfoRec *pci = (NewClientInfoRec *)calldata;

	ClientPtr client = pci->client;

	TsolInfoPtr tsolinfo = TsolClientPrivate(client);

	switch (client->clientState) {

	case ClientStateInitial:

		/* Got a new connection */

		TsolSetClientInfo(client);

		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;

	default:

                break;

	}

}

static void

TsolReset(ExtensionEntry *extension)

{

    free_win_privsets();

    XaceDeleteCallback(XACE_EXT_DISPATCH, TsolCheckExtensionAccess, NULL);

    XaceDeleteCallback(XACE_RESOURCE_ACCESS, TsolCheckResourceIDAccess, NULL);

    XaceDeleteCallback(XACE_PROPERTY_ACCESS, TsolCheckPropertyAccess, NULL);

    XaceDeleteCallback(XACE_SEND_ACCESS, TsolCheckSendAccess, NULL);

    XaceDeleteCallback(XACE_RECEIVE_ACCESS, TsolCheckReceiveAccess, NULL);

    XaceDeleteCallback(XACE_EXT_ACCESS, TsolCheckExtensionAccess, NULL);

    XaceDeleteCallback(XACE_DEVICE_ACCESS, TsolCheckDeviceAccess, NULL);

    XaceDeleteCallback(XACE_SCREEN_ACCESS, TsolCheckDeviceAccess, NULL);

    XaceDeleteCallback(XACE_SCREENSAVER_ACCESS, TsolCheckDeviceAccess, NULL);

    XaceDeleteCallback(XACE_SELECTION_ACCESS, TsolCheckSelectionAccess, NULL);

    XaceDeleteCallback(XACE_SERVER_ACCESS, TsolCheckServerAccess, NULL);

    XaceDeleteCallback(XACE_CLIENT_ACCESS, TsolCheckClientAccess, NULL);

    XaceDeleteCallback(XACE_KEY_AVAIL, TsolProcessKeyboard, NULL);

    XaceDeleteCallback(XACE_AUDIT_BEGIN, TsolAuditStart, NULL);

    XaceDeleteCallback(XACE_AUDIT_END, TsolAuditEnd, NULL);

}

/*

 * Dispatch routine

 *

 */

static int

ProcTsolDispatch(register ClientPtr client)

{

    int retval;

    REQUEST(xReq);

    switch (stuff->data)

    {

        case X_SetPolyInstInfo:

            retval =  ProcSetPolyInstInfo(client);

            break;

        case X_SetPropLabel:

            retval =  ProcSetPropLabel(client);

            break;

        case X_SetPropUID:

            retval =  ProcSetPropUID(client);

            break;

        case X_SetResLabel:

            retval =  ProcSetResLabel(client);

            break;

        case X_SetResUID:

            retval =  ProcSetResUID(client);

            break;

        case X_GetClientAttributes:

            retval =  ProcGetClientAttributes(client);

            break;

        case X_GetClientLabel:

            retval = ProcGetClientLabel(client);

            break;

        case X_GetPropAttributes:

            retval =  ProcGetPropAttributes(client);

            break;

        case X_GetResAttributes:

            retval =  ProcGetResAttributes(client);

            break;

        case X_MakeTPWindow:

            retval =  ProcMakeTPWindow(client);

            break;

        case X_MakeTrustedWindow:

            retval =  ProcMakeTrustedWindow(client);

            break;

        case X_MakeUntrustedWindow:

            retval =  ProcMakeUntrustedWindow(client);

            break;

        default:

            SendErrorToClient(client, TsolReqCode, stuff->data, 0, BadRequest);

            retval = BadRequest;

    }

    return (retval);

}