sustaining/oi_151a/xnv: comparison open-src/xserver/xorg/sun-src/tsol/tsolextension.c

equal deleted inserted replaced

-:a8aa060182e1
+:1c99106ccbe0
-/* Copyright (c) 2004, 2009, Oracle and/or its affiliates. All rights reserved.
+/*
+* Copyright (c) 2004, 2011, Oracle and/or its affiliates. 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, sublicense,
 #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"
 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 */
+/*
+* Key to lookup devPrivate data in various structures
+*/
+DevPrivateKeyRec tsolClientPrivateKeyRec;
+DevPrivateKeyRec tsolPixmapPrivateKeyRec;
+DevPrivateKeyRec tsolWindowPrivateKeyRec;
+DevPrivateKeyRec tsolPropertyPrivateKeyRec;
+DevPrivateKeyRec tsolSelectionPrivateKeyRec;
+DevPrivateKeyRec tsolDevicePrivateKeyRec;
 int (*TsolSavedProcVector[PROCVECTORSIZE])(ClientPtr client);
 int (*TsolSavedSwappedProcVector[PROCVECTORSIZE])(ClientPtr client);
 static SecurityHook tsolSecHook;
 /* other callbacks */
 static CALLBACK(TsolClientStateCallback);
 static CALLBACK(TsolSelectionCallback);
 extern int tsol_check_policy(TsolInfoPtr tsolinfo, TsolResPtr tsolres,
 	xpolicy_t flags, int reqcode);
 extern void TsolCheckDrawableAccess(CallbackListPtr *pcbl, pointer nulldata,
 	pointer calldata);
 extern void TsolCheckXIDAccess(CallbackListPtr *pcbl, pointer nulldata,
 	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;
 	ExtensionEntry *extEntry;
 	int i;
 	/* sleep(20); */
 	/* MAC/Label support is available only if labeld svc is enabled */
 	if (is_system_labeled()) {
 		tsol_mac_enabled = TRUE;
 	} else {
 		/* DAC support can be added in future */
 		tsol_mac_enabled = FALSE;
 	if (!AddCallback(&SelectionCallback, TsolSelectionCallback, NULL))
 		return;
 	/* Allocate storage in devPrivates */
-	if (!dixRequestPrivate(tsolPrivateKey, sizeof (TsolPrivateRec))) {
+	if (!dixRegisterPrivateKey(tsolClientPrivateKey, PRIVATE_CLIENT,
-		ErrorF("TsolExtensionInit: Cannot allocate devPrivate.\n");
+				   sizeof (TsolInfoRec))) {
+		ErrorF("TsolExtensionInit: Cannot allocate client private.\n");
+		return;
+	}
+	if (!dixRegisterPrivateKey(tsolPixmapPrivateKey, PRIVATE_PIXMAP,
+				   sizeof (TsolResRec))) {
+		ErrorF("TsolExtensionInit: Cannot allocate pixmap private.\n");
+		return;
+	}
+	if (!dixRegisterPrivateKey(tsolWindowPrivateKey, PRIVATE_WINDOW,
+				   sizeof (TsolResRec))) {
+		ErrorF("TsolExtensionInit: Cannot allocate window private.\n");
+		return;
+	}
+	if (!dixRegisterPrivateKey(tsolPropertyPrivateKey, PRIVATE_PROPERTY,
+				   sizeof (TsolResRec))) {
+		ErrorF("TsolExtensionInit: Cannot allocate property private.\n");
+		return;
+	}
+	if (!dixRegisterPrivateKey(tsolSelectionPrivateKey, PRIVATE_SELECTION,
+				   sizeof (TsolResRec))) {
+		ErrorF("TsolExtensionInit: Cannot allocate selection private.\n");
+		return;
+	}
+	if (!dixRegisterPrivateKey(tsolDevicePrivateKey, PRIVATE_DEVICE,
+				   sizeof (HotKeyRec))) {
+		ErrorF("TsolExtensionInit: Cannot allocate device private.\n");
 		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();
-			snprintf(tsolinfo->pname, MAXNAME, "client id %d (pid %d)",
+			snprintf(tsolinfo->pname, MAXNAME,
-				serverClient->index, tsolinfo->pid);
+				 "client id %d (pid %d)",
+				 serverClient->index, tsolinfo->pid);
 		}
 	}
 	LoadTsolConfig();
 	XaceResourceAccessRec *rec = calldata;
 	RESTYPE rtype = rec->rtype;
 	switch (rtype) {
 	case RT_WINDOW:
 	case RT_PIXMAP:
 		/* 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.
 		 * In RANDR extension, usual window policy is
 		 * enforced before checking for RREventType.
 		 */
 		if (rtype == RREventType) {
 			rec->status = Success;
 		}
 static
 CALLBACK(TsolSelectionCallback)
 {
 	SelectionInfoRec *pselinfo = (SelectionInfoRec *)calldata;
 	Selection *pSel = pselinfo->selection;
-	TsolResPtr tsolseln = TsolResourcePrivate(pSel);
+	TsolResPtr tsolseln = TsolSelectionPrivate(pSel);
 	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:
 	    tsolseln->sl = NULL;
 	    break;
 	default:
 	    /* All others handled in SelectionAccess handler */
 	    break;
 static int
 ProcSetPolyInstInfo(ClientPtr client)
 {
 TsolInfoPtr tsolinfo = GetClientTsolInfo(client);
 bslabel_t *sl;
-int        err_code;
 extern priv_set_t *pset_win_mac_write;
 REQUEST(xSetPolyInstInfoReq);
 REQUEST_AT_LEAST_SIZE(xSetPolyInstInfoReq);
 TsolInfoPtr tsolinfo = GetClientTsolInfo(client);
 bslabel_t   *sl;
 WindowPtr    pWin;
 TsolResPtr  tsolprop;
 PropertyPtr  pProp;
-int          err_code;
 int rc;
 REQUEST(xSetPropLabelReq);
 REQUEST_AT_LEAST_SIZE(xSetPropLabelReq);
 if (!client_has_privilege(tsolinfo, pset_win_mac_write)) {
 return (BadAccess);
 }
 /* Initialize property created internally by server */
-tsolprop = TsolResourcePrivate(pProp);
+tsolprop = TsolPropertyPrivate(pProp);
 sl = (bslabel_t *)(stuff + 1);
 if (!blequal(tsolprop->sl, sl)) {
 tsolprop->sl = lookupSL(sl);
 {
 TsolInfoPtr tsolinfo = GetClientTsolInfo(client);
 WindowPtr   pWin;
 TsolResPtr tsolprop;
 PropertyPtr pProp;
-int         err_code;
 int 	rc;
 REQUEST(xSetPropUIDReq);
 REQUEST_SIZE_MATCH(xSetPropUIDReq);
 if (!client_has_privilege(tsolinfo, pset_win_mac_write)) {
 return (BadAccess);
 }
 /* Initialize property created internally by server */
-tsolprop = TsolResourcePrivate(pProp);
+tsolprop = TsolPropertyPrivate(pProp);
 tsolprop->uid = stuff->uid;
 return (client->noClientException);
 }
 bslabel_t  *sl;
 PixmapPtr   pMap;
 WindowPtr   pWin;
 xEvent      message;
 TsolResPtr  tsolres;
-int         err_code;
 int		rc;
 REQUEST(xSetResLabelReq);
 REQUEST_AT_LEAST_SIZE(xSetResLabelReq);
 memcpy(&SessionLO, sl, SL_SIZE);
 return (client->noClientException);
 case IsWindow:
 	    rc = dixLookupWindow(&pWin, stuff->id, client, DixWriteAccess);
 	    if (rc != Success)
 		return rc;
 if (pWin)
 {
-tsolres = TsolResourcePrivate(pWin);
+tsolres = TsolWindowPrivate(pWin);
 }
 else
 {
 client->errorValue = stuff->id;
 return (BadWindow);
 break;
 case IsPixmap:
 	    rc = dixLookupDrawable((DrawablePtr *)&pMap, stuff->id, client,
 				   M_DRAWABLE_PIXMAP, DixWriteAccess);
 	    if (rc != Success)
 		return rc;
 if (pMap)
 {
-tsolres = TsolResourcePrivate(pMap);
+tsolres = TsolPixmapPrivate(pMap);
 }
 else
 {
 client->errorValue = stuff->id;
 return (BadPixmap);
 TsolInfoPtr tsolinfo = GetClientTsolInfo(client);
 int       ScreenNumber;
 PixmapPtr pMap;
 WindowPtr pWin;
 TsolResPtr tsolres;
-int        err_code;
 int        rc;
 extern priv_set_t *pset_win_dac_write;
 REQUEST(xSetResUIDReq);
 AddUID(&OwnerUIDint);
 return (client->noClientException);
 case IsWindow:
 	    rc = dixLookupWindow(&pWin, stuff->id, client, DixWriteAccess);
 	    if (rc != Success)
 		return rc;
 if (pWin)
 {
-tsolres = TsolResourcePrivate(pWin);
+tsolres = TsolWindowPrivate(pWin);
 }
 else
 {
 client->errorValue = stuff->id;
 return (BadWindow);
 	    if (rc != Success)
 		return rc;
 if (pMap)
 {
-tsolres = TsolResourcePrivate(pMap);
+tsolres = TsolPixmapPrivate(pMap);
 }
 else
 {
 client->errorValue = stuff->id;
 return (BadPixmap);
 static int
 ProcGetClientAttributes(ClientPtr client)
 {
 int         n;
-int         err_code;
 int         rc;
 ClientPtr   res_client; /* resource owner client */
 TsolInfoPtr tsolinfo, res_tsolinfo;
 WindowPtr	pWin;
 ProcGetClientLabel(ClientPtr client)
 {
 int         n;
 int         reply_length = 0;
 int         rc;
-int         err_code;
 Bool        write_to_client = 0;
 bslabel_t   *sl;
 ClientPtr   res_client; /* resource owner client */
 TsolInfoPtr tsolinfo, res_tsolinfo;
 WindowPtr	pWin;
 /* Transfer the client info to reply rec */
 rep.type = X_Reply;
 rep.sequenceNumber = client->sequence;
 /* allocate temp storage for labels */
-sl = (bslabel_t *)(xalloc(SL_SIZE));
+sl = malloc(SL_SIZE);
 rep.data00 = rep.data01 = 0;
 if (sl == NULL)
 return (BadAlloc);
 /* fill the fields as per request mask */
 if (write_to_client == 1)
 {
 WriteToClient(client, reply_length, (char *)sl);
 }
-xfree(sl);
+free(sl);
 return (client->noClientException);
 }
 static int
 /* first see if property already exists */
 pProp = wUserProps (pWin);
 while (pProp)
 {
-tsolprop = TsolResourcePrivate(pProp);
+tsolprop = TsolPropertyPrivate(pProp);
 if (pProp->propertyName == stuff->atom) {
 if (tsolpolyinstinfo.enabled) {
 if (tsolprop->uid == tsolpolyinstinfo.uid &&
 }
 if (!pProp)
 {
 /* property does not exist, use window's attributes */
-	tsolres = TsolResourcePrivate(pWin);
+	tsolres = TsolWindowPrivate(pWin);
 	tsolprop = NULL;
 }
 if (stuff->mask & RES_UID)
 {
 rep.uid = tsolprop ? tsolprop->uid : tsolres->uid;
 }
 /* allocate temp storage for labels */
-sl = (bslabel_t *)(xalloc(SL_SIZE));
+sl = malloc(SL_SIZE);
 rep.sllength = rep.illength = 0;
 if (sl == NULL)
 return (BadAlloc);
 /* fill the fields as per request mask */
 if (write_to_client == 1)
 {
 WriteToClient(client, reply_length, (char *)sl);
 }
-xfree(sl);
+free(sl);
 return (client->noClientException);
 }
 static int
 {
 	rc = dixLookupWindow(&pWin, stuff->id, client, DixReadAccess);
 	if (rc != Success)
 	    return rc;
-	tsolres = TsolResourcePrivate(pWin);
+	tsolres = TsolWindowPrivate(pWin);
 }
 if (stuff->resourceType == IsPixmap &&
 (stuff->mask & (RES_UID | RES_SL )))
 {
 	rc = dixLookupDrawable((DrawablePtr *)&pMap, stuff->id, client,
 			       M_DRAWABLE_PIXMAP, DixWriteAccess);
 	if (rc != Success)
 	    return rc;
-	tsolres = TsolResourcePrivate(pMap);
+	tsolres = TsolPixmapPrivate(pMap);
 }
 if (stuff->mask & RES_UID)
 {
 rep.uid = tsolres->uid;
 }
 /* allocate temp storage for labels */
-sl = (bslabel_t *)(xalloc(SL_SIZE));
+sl = malloc(SL_SIZE);
 rep.sllength = rep.illength = rep.iillength = 0;
 if (sl == NULL)
 return (BadAlloc);
 /* fill the fields as per request mask */
 if (write_to_client == 1)
 {
 WriteToClient(client, reply_length, (char *)sl);
 }
-xfree(sl);
+free(sl);
 return (client->noClientException);
 }
 int
 ProcMakeTPWindow(ClientPtr client)
 {
 WindowPtr pWin = NULL, pParent;
 int       rc;
-int       err_code;
 TsolInfoPtr  tsolinfo;
 REQUEST(xMakeTPWindowReq);
 REQUEST_SIZE_MATCH(xMakeTPWindowReq);
 if (!noPanoramiXExtension)
 {
 PanoramiXRes     *panres = NULL;
 int         j;
-	if ((panres = (PanoramiXRes *)LookupIDByType(stuff->id, XRT_WINDOW))
+	rc = dixLookupResourceByType((pointer *) &panres, stuff->id,
-		== NULL)
+				     XRT_WINDOW, client, DixWriteAccess);
-	    return BadWindow;
+	if (rc != Success)
+	    return rc;
 	FOR_NSCREENS_BACKWARD(j)
 	{
 		rc = dixLookupWindow(&pWin, panres->info[j].id,
 			client, DixWriteAccess);
 		if (rc != Success)
 		    return rc;
 		/* window should not be root but child of root */
 static int
 ProcMakeTrustedWindow(ClientPtr client)
 {
 WindowPtr    pWin;
 int          rc;
-int          err_code;
 TsolInfoPtr  tsolinfo;
 REQUEST(xMakeTrustedWindowReq);
 REQUEST_SIZE_MATCH(xMakeTrustedWindowReq);
 static int
 ProcMakeUntrustedWindow(ClientPtr client)
 {
 WindowPtr    pWin;
 int          rc;
-int          err_code;
 TsolInfoPtr  tsolinfo;
 REQUEST(xMakeUntrustedWindowReq);
 REQUEST_SIZE_MATCH(xMakeUntrustedWindowReq);
 GrabPtr         kbdgrab = keybd->deviceGrab.grab;
 DeviceIntPtr    mouse = PickPointer(client);
 GrabPtr         ptrgrab = mouse->deviceGrab.grab;
 	if (kbdgrab) {
-	    	grabclient = clients[CLIENT_ID(kbdgrab->resource)];
+		grabclient = clients[CLIENT_ID(kbdgrab->resource)];
 		if (client->index != grabclient->index)
 			(*keybd->deviceGrab.DeactivateGrab)(keybd);
 	}
 	if (ptrgrab) {
-	    	grabclient = clients[CLIENT_ID(ptrgrab->resource)];
+		grabclient = clients[CLIENT_ID(ptrgrab->resource)];
 		if (client->index != grabclient->index)
 			(*mouse->deviceGrab.DeactivateGrab)(mouse);
 }
 }
 struct svc_req  r;
 bool_t          res0, res1;
 XDR             xdr;
 SVCXPRT         xprt;
-temp_inmsg = (char *) xalloc(len);
+temp_inmsg = malloc(len);
 memmove(temp_inmsg, inmsg, len);
 memset((char *)&msg, 0, sizeof(msg));
 memset((char *)&r, 0, sizeof(r));
 memset(cred_area, 0, sizeof(cred_area));
 msg.rm_call.cb_cred.oa_base = cred_area;
 msg.rm_call.cb_verf.oa_base = verf_area;
 tsol_why = AUTH_FAILED;
 xdrmem_create(&xdr, temp_inmsg, len, XDR_DECODE);
-if ((r.rq_clntcred = (caddr_t) xalloc(MAX_AUTH_BYTES)) == NULL)
+if ((r.rq_clntcred = malloc(MAX_AUTH_BYTES)) == NULL)
 goto bad1;
 r.rq_xprt = &xprt;
 /* decode into msg */
 res0 = xdr_opaque_auth(&xdr, &(msg.rm_call.cb_cred));
 goto bad2;
 }
 return (((struct authdes_cred *) r.rq_clntcred)->adc_fullname.name);
 bad2:
-Xfree(r.rq_clntcred);
+free(r.rq_clntcred);
 bad1:
 return ((char *)0); /* ((struct authdes_cred *) NULL); */
 }
 static Bool
 		       ClientPtr client, char **reason)
 {
 	char	domainname[128];
 	char	netname[128];
 	char	audit_ret;
-	u_int	audit_val;
+	uint_t	audit_val;
 	uid_t	client_uid;
 	gid_t	client_gid;
 	int	client_gidlen;
 	char	*fullname;
 	gid_t	client_gidlist;
 	/*
 	 * For multilevel desktop, limit connections to the trusted path
 	 * i.e. global zone until a user logs in and the trusted stripe
 	 * is in place. Unlabeled connections are rejected.
 	 */
-	if ((OwnerUID == (uid_t )(-1)) || (tsolMultiLevel && tpwin == NULL)) {
+	if ((OwnerUID == (uid_t)(-1)) || (tsolMultiLevel && tpwin == NULL)) {
 		if (HasTrustedPath(tsolinfo)) {
 			auth_token = CheckAuthorization(name_length, name, data_length,
 				data, client, reason);
 		}
 	} else {
 	if (system_audit_on &&
 		(au_preselect(AUE_ClientConnect, &(tsolinfo->amask),
 AU_PRS_BOTH, AU_PRS_USECACHE) == 1)) {
 		int status;
-		u_short connect_port = 0;
+		ushort_t connect_port = 0;
 		struct in_addr *connect_addr = NULL;
 		struct sockaddr_in *sin;
 		struct sockaddr_in6 *sin6;
 		switch (tsolinfo->saddr.ss_family) {
 		rec->status = Success;
 		return;
 	}
 	tsolinfo = GetClientTsolInfo(client);
-	tsolres = TsolResourcePrivate(pWin);
+	tsolres = TsolWindowPrivate(pWin);
 	flags = (TSOL_MAC|TSOL_DAC|TSOL_DOMINATE|TSOL_READOP);
 	rec->status = tsol_check_policy(tsolinfo, tsolres, flags, MAJOROP_CODE);
 #ifndef NO_TSOL_DEBUG_MESSAGES
 if (rec->status != Success) {
 * The callback function is only called if at least one matching selection exists.
 * If it has no tsol attributes then we know it is the only match so we don't need to
 * check for polyinstantiation. Just initialize it and return.
 */
-	tsolseln = TsolResourcePrivate(pSel);
+	tsolseln = TsolSelectionPrivate(pSel);
 	if (tsolseln->sl == NULL) {
 tsolseln->sl = tsolinfo->sl;
 tsolseln->uid = tsolinfo->uid;
 	    break;
 	    /* for poly-selections, search from the beginning to see if sl,uid match */
 	    for (pSel = CurrentSelections; pSel; pSel = pSel->next) {
 		if (pSel->selection == selAtom) {
-		    tsolseln = TsolResourcePrivate(pSel);
+		    tsolseln = TsolSelectionPrivate(pSel);
 		    if (tsolseln->uid == tsolinfo->uid &&
 			 tsolseln->sl == tsolinfo->sl)
 		        break;
 		}
 	    }
 	    if (pSel) {
 		/* found a match */
 	        *rec->ppSel = pSel;
 	    } else {
 		/*
 		* Doesn't match yet; we'll get called again
 		* After it gets created.
 		*/
 		/* for poly-selections, search from the beginning to see if sl,uid match */
 		for (pSel = CurrentSelections; pSel; pSel = pSel->next) {
 		    if (pSel->selection == selAtom) {
-		        tsolseln = TsolResourcePrivate(pSel);
+		        tsolseln = TsolSelectionPrivate(pSel);
 		        if (tsolseln->uid == tsolinfo->uid &&
 			     tsolseln->sl == tsolinfo->sl)
 		            break;
 		    }
 		}
 	        if (pSel) {
 	            *rec->ppSel = pSel; /* found match */
 	        } else {
 		    /*
 	    }
 	    /*
 	     * Selection Agent processing. Override the owner
 	     */
-	    tsolseln = TsolResourcePrivate(pSel);
+	    tsolseln = TsolSelectionPrivate(pSel);
 	    if (!HasWinSelection(tsolinfo) &&
 			(tsolseln->uid != tsolinfo->uid ||
 			tsolseln->sl != tsolinfo->sl) &&
 			pSel->window != None && tsol_sel_agnt != NULL) {
 pSel = tsol_sel_agnt;
 } else {
 		if (HasWinSelection(tsolinfo) &&
 			(tsolinfo->flags & TSOL_AUDITEVENT)) {
 		    auditwrite(AW_USEOFPRIV, 1, PRIV_WIN_SELECTION, AW_APPEND, AW_END);
 		}
 	    }
 	    *rec->ppSel = pSel;
 Mask access_mode = rec->access_mode;
 TsolInfoPtr tsolinfo = GetClientTsolInfo(client);
 int reqtype;
 TsolResPtr tsolprop;
 TsolResPtr tsolres;
-int tsol_method;
 Status retcode;
 xpolicy_t flags = 0;
 reqtype = MAJOROP_CODE;
-tsolres = TsolResourcePrivate(pWin);
+tsolres = TsolWindowPrivate(pWin);
 if (pProp != NULL) {
 	int polyprop = PolyProperty(propertyName, pWin);
-	tsolprop = TsolResourcePrivate(pProp);
+	tsolprop = TsolPropertyPrivate(pProp);
 	if (!polyprop) {
-	    tsolres = TsolResourcePrivate(pWin);
+	    tsolres = TsolWindowPrivate(pWin);
 	    if (tsolprop->sl == NULL) {
 		/* Initialize with label/uid etc */
 		if (WindowIsRoot(pWin)) {
 		    tsolprop->sl = tsolinfo->sl;        /* use client's sl/uid */
 		    tsolprop->uid = tsolinfo->uid;
 	    if (access_mode & (DixWriteAccess | DixSetAttrAccess))
 	        flags = (TSOL_MAC|TSOL_DAC|TSOL_WRITEOP);
 	    retcode = tsol_check_policy(tsolinfo, tsolprop, flags, MAJOROP_CODE);
 	    if (retcode != Success && (access_mode & DixGetAttrAccess)) {
 		/* If current property is not accessible, move on to
 		 *  next one for ListProperty
 		 */
 		retcode = Success;
 		*rec->ppProp = pProp->next; /* ignore failurefor List Prop */
 	    }
 		tsolprop->uid = tsolinfo->uid;
 		rec->status = Success;
 	    } else {
 		/* search for a matching (sl, uid) pair */
 		while (pProp) {
-	    	    tsolprop = TsolResourcePrivate(pProp);
+		    tsolprop = TsolPropertyPrivate(pProp);
 		    if (pProp->propertyName == propertyName &&
 			    tsolprop->sl == tsolinfo->sl &&
 			    tsolprop->uid == tsolinfo->uid)
 			break; /* match found */
 		    pProp = pProp->next;
 		}
 		if (pProp) {
 		    *rec->ppProp = pProp; /* found */
 		    rec->status = Success;
 		} else {

changeset 1088	1c99106ccbe0
parent 943	294f64612d23
child 1187	c380a2754b65