upstream/oracle/x-cons/x-s12-clone: comparison open-src/xserver/xorg/sun-src/IA/interactive.c

equal deleted inserted replaced

-:e5259db5befc
+:068c11b419c9
 /*
-* Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
+* 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,
 * 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.
 */
-#pragma ident   "@(#)interactive.c 35.18     08/06/16 SMI"
+#pragma ident   "@(#)interactive.c 35.19     09/01/14 SMI"
 /************************************************************
 	Basic boilerplate extension.
 	This file also contains the code to make the priocntl on behalf
 #define UNSET_PRIORITY 		0
 #define SET_PRIORITY		1
 #define SET_INTERACTIVE 	2
-#define SERVER			0x1
-#define WMGR			0x2
-#define BOTH			0x3
 typedef struct _ClientProcessInfo {
-	int count;
+int 		count;
-	ConnectionPidPtr pids;
+ConnectionPidPtr	pids;
-} ClientProcessRec, * ClientProcessPtr;
+Bool		boosted;
+} ClientProcessRec, *ClientProcessPtr;
+typedef struct {
+ClientProcessPtr    process; /* Process id information */
+Bool		wmgr;
+} IAClientPrivateRec, *IAClientPrivatePtr;
 static int ProcIADispatch(ClientPtr client), SProcIADispatch(ClientPtr client);
 static int ProcIASetProcessInfo(ClientPtr client), SProcIASetProcessInfo(ClientPtr client);
 static int ProcIAGetProcessInfo(ClientPtr client), SProcIAGetProcessInfo(ClientPtr client);
 static int ProcIAQueryVersion(ClientPtr client), SProcIAQueryVersion(ClientPtr client);
 static void IAClientStateChange(CallbackListPtr *pcbl, pointer nulldata, pointer calldata);
 static int InitializeClass(void );
 static void SetIAPrivate(int*);
 static void ChangeInteractive(ClientPtr);
-static int SetPriority(int, int);
+static int SetPriority(const ClientProcessPtr, int);
-static void UnsetLastPriority(ClientProcessPtr LastPid);
 static void ChangePriority(register ClientPtr client);
 static int SetClientPrivate(ClientPtr client, ConnectionPidPtr stuff, int length);
-static void FreeProcessList(ClientPtr client);
+static void FreeProcessList(IAClientPrivatePtr priv);
 /* static int LocalConnection(OsCommPtr); */
 static int PidSetEqual(ClientProcessPtr, ClientProcessPtr);
 static int IAWrapProcVectors(void);
 static int IAUnwrapProcVectors(void);
 static CARD32 IAInitTimerCall(OsTimerPtr timer,CARD32 now,pointer arg);
 static iaclass_t 	IAClass;
 static id_t		TScid;
 static ClientProcessPtr	LastPids = NULL;
-static int 		specialIAset = 0;
 static int 		ia_nice = IA_BOOST;
-static Bool 		InteractiveOS = xTrue;
+static Bool 		InteractiveOS = TRUE;
-static ClientPtr 	wmClientptr = NULL;
 static unsigned long 	IAExtensionGeneration = 0;
 static OsTimerPtr 	IAInitTimer = NULL;
 static int (* IASavedProcVector[256]) (ClientPtr client);
-typedef struct {
+static int IAPrivKeyIndex;
-ClientProcessPtr    process; /* Process id information */
+static DevPrivateKey IAPrivKey = &IAPrivKeyIndex;
-Bool		wmgr;
-} IAClientPrivateRec, *IAClientPrivatePtr;
+#define GetIAClient(pClient)	\
+((IAClientPrivatePtr) dixLookupPrivate(&(pClient)->devPrivates, IAPrivKey))
-static int	IAClientPrivateIndex;
+static inline ClientProcessPtr
-#define GetIAClient(pClient)    ((IAClientPrivatePtr) (pClient)->devPrivates[IAClientPrivateIndex].ptr)
+GetConnectionPids(ClientPtr pClient)
-#define GetConnectionPids(pClient)	(GetIAClient(pClient)->process)
+{
+IAClientPrivatePtr priv = GetIAClient(pClient);
+if (priv == NULL) {
+	return NULL;
+} else {
+	return priv->process;
+}
+}
 /* Set via xorg.conf option in loadable module */
 int IADebugLevel = 0;
 #define IA_DEBUG(level, func)	\
 #define IA_DEBUG_PRIOCNTL	3
 void
 IAExtensionInit(void)
 {
+ConnectionPidRec	myPid = P_MYID;
+ClientProcessRec	myProc = { 1, &myPid, FALSE };
 IA_DEBUG(IA_DEBUG_BASIC,
-LogMessage(X_INFO, "SolarisIA: Initializing (generation %ld)\n",
+	     LogMessage(X_INFO, "SolarisIA: Initializing (generation %ld)\n",
-	IAExtensionGeneration));
+			IAExtensionGeneration));
 if (IAExtensionGeneration == serverGeneration)
 	return;
-InteractiveOS=xFalse;
+InteractiveOS = FALSE;
 if (InitializeClass() != Success)
 	return;
-if (SetPriority(P_MYID, SET_INTERACTIVE) != Success)
+if (SetPriority(&myProc, SET_INTERACTIVE) != Success)
 	return;
-if (SetPriority(P_MYID, SET_PRIORITY) != Success)
+if (SetPriority(&myProc, SET_PRIORITY) != Success)
 	return;
-IAClientPrivateIndex = AllocateClientPrivateIndex();
-if (IAClientPrivateIndex < 0)
-	return;
-if (!AllocateClientPrivate (IAClientPrivateIndex,
-				      sizeof (IAClientPrivateRec)))
-return;
 if (!AddCallback(&ClientStateCallback, IAClientStateChange, NULL))
 return;
 if (IAWrapProcVectors() != 0)
 	return;
 if (!AddExtension(IANAME, IANumberEvents, IANumberErrors,
-				 ProcIADispatch, SProcIADispatch,
+		      ProcIADispatch, SProcIADispatch,
-				 IACloseDown, StandardMinorOpcode))
+		      IACloseDown, StandardMinorOpcode))
 	return;
 /* InitExtensions is called before InitClientPrivates(serverClient)
 so we set this timer to callback as soon as we hit WaitForSomething
 to initialize the serverClient */
 IAInitTimer = TimerSet(IAInitTimer, 0, 1, IAInitTimerCall, NULL);
-specialIAset = 0;
+InteractiveOS = TRUE;
-InteractiveOS = xTrue;
 IAExtensionGeneration = serverGeneration;
 IA_DEBUG(IA_DEBUG_BASIC,
-LogMessage(X_INFO, "SolarisIA: Finished initializing (generation %ld)\n",
+	     LogMessage(X_INFO,
-	IAExtensionGeneration));
+			"SolarisIA: Finished initializing (generation %ld)\n",
+			IAExtensionGeneration));
+}
+/* Allocate client private structure for this client */
+static int
+IAInitClientPrivate(ClientPtr pClient)
+{
+IAClientPrivatePtr priv;
+priv = GetIAClient(pClient);
+if (priv != NULL) {
+	return Success;
+}
+priv = xalloc(sizeof(IAClientPrivateRec));
+if (priv == NULL) {
+	return BadAlloc;
+}
+priv->process = NULL;
+priv->wmgr = FALSE;
+dixSetPrivate(&(pClient)->devPrivates, IAPrivKey, priv);
+return Success;
 }
 /* Called when we first hit WaitForSomething to initialize serverClient */
 static CARD32
 IAInitTimerCall(OsTimerPtr timer,CARD32 now,pointer arg)
 {
 ConnectionPidRec serverPid;
-if (InteractiveOS != xTrue)
+if (InteractiveOS != TRUE)
 	return 0;
-GetConnectionPids(serverClient) = NULL;
+IAInitClientPrivate(serverClient);
-GetIAClient(serverClient)->wmgr = FALSE;
 serverPid = getpid();
 SetClientPrivate(serverClient, &serverPid, 1);
 ChangePriority(serverClient);
 IAClientStateChange(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
 {
 NewClientInfoRec *pci = (NewClientInfoRec *)calldata;
 ClientPtr pClient = pci->client;
 ClientProcessPtr CurrentPids;
+IAClientPrivatePtr priv;
 switch (pClient->clientState) {
 case ClientStateGone:
 case ClientStateRetained:
-	CurrentPids = GetConnectionPids(pClient);
+	priv = GetIAClient(pClient);
+	if (priv == NULL) {
-	if (pClient==wmClientptr) {
+	    return;
+	}
+	CurrentPids = priv->process;
+	if (priv->wmgr) {
 	    IA_DEBUG(IA_DEBUG_BASIC,
-	      LogMessage(X_INFO, "SolarisIA: WindowManager closed (pid %d)\n",
+		     LogMessage(X_INFO,
-	      (CurrentPids && CurrentPids->pids) ? CurrentPids->pids[0] : -1));
+				"SolarisIA: WindowManager closed (pid %d)\n",
-	    wmClientptr=NULL;
+				(CurrentPids && CurrentPids->pids) ?
-	}
+				 CurrentPids->pids[0] : -1));
+	}
-	if (CurrentPids && LastPids && PidSetEqual(CurrentPids, LastPids))
-	    LastPids=NULL;
+	if (CurrentPids && CurrentPids->boosted) {
+	    SetPriority(CurrentPids, UNSET_PRIORITY);
-	FreeProcessList(pClient);
+	}
-	GetIAClient(pClient)->wmgr = FALSE;
+	if (CurrentPids && LastPids && PidSetEqual(CurrentPids, LastPids)) {
+	    LastPids = NULL;
+	}
+	FreeProcessList(priv);
+	xfree(priv);
+	dixSetPrivate(&(pClient)->devPrivates, IAPrivKey, NULL);
 	break;
 case ClientStateInitial:
-	GetConnectionPids(pClient) = NULL;
+	IAInitClientPrivate(pClient);
-	GetIAClient(pClient)->wmgr = FALSE;
 	break;
 default:
 	break;
 }
 	ServerUid=getuid();
 if ((stuff->flags & INTERACTIVE_INFO) &&
 	(stuff->uid==ServerUid || ServerUid==0 || stuff->uid==0) &&
 	LocalClient(client)) {
-	length=stuff->length-(sizeof(xIASetProcessInfoReq)>>2);
+	length = stuff->length - (sizeof(xIASetProcessInfoReq)>>2);
 	SetClientPrivate(client, (ConnectionPidPtr)&stuff[1], length);
 	ChangeInteractive(client);
 }
 if ((stuff->flags & INTERACTIVE_SETTING) &&
 }
 static int
 ProcIAGetProcessInfo(ClientPtr client)
 {
-ClientProcessPtr CurrentPids=GetConnectionPids(client);
+IAClientPrivatePtr	priv;
+ClientProcessPtr CurrentPids;
 REQUEST(xIAGetProcessInfoReq);
 xIAGetProcessInfoReply rep;
-register int length=0;
+register int length = 0;
-caddr_t write_back=NULL;
+caddr_t write_back = NULL;
 REQUEST_SIZE_MATCH(xIAGetProcessInfoReq);
 rep.type = X_Reply;
 rep.length = 0;
 rep.sequenceNumber = client->sequence;
 if (stuff->flags & INTERACTIVE_INFO) {
-	    if (!CurrentPids)
+	priv = GetIAClient(client);
-		rep.count = 0;
+	if ( (priv == NULL) || (priv->process == NULL) ) {
-	    else {
+	    rep.count = 0;
-		rep.count = CurrentPids->count;
+	} else {
-		length = rep.count << 2;
+	    CurrentPids = priv->process;
-	        write_back=(caddr_t)CurrentPids->pids;
+	    rep.count = CurrentPids->count;
-	    }
+	    length = rep.count << 2;
+	    write_back=(caddr_t)CurrentPids->pids;
+	}
 }
 if (stuff->flags & INTERACTIVE_SETTING) {
 	rep.count=1;
 	length=rep.count << 2;
 	write_back=(caddr_t)&ia_nice;
 }
 static void
 IACloseDown(ExtensionEntry *ext)
 {
-InteractiveOS=xFalse;
+InteractiveOS = FALSE;
 IAUnwrapProcVectors();
 DeleteCallback(&ClientStateCallback, IAClientStateChange, NULL);
 }
 }
 static void
 ChangeInteractive(ClientPtr client)
 {
-ClientProcessPtr CurrentPids=GetConnectionPids(client);
+ClientProcessPtr CurrentPids = GetConnectionPids(client);
-register int count;
+if (InteractiveOS==FALSE)
-if (InteractiveOS==xFalse)
 return;
 if (!CurrentPids || !CurrentPids->pids)
 	return;
-count=CurrentPids->count;
+SetPriority(CurrentPids, SET_INTERACTIVE);
-while(count--)
-SetPriority(CurrentPids->pids[count], SET_INTERACTIVE);
 }
 /*
-Loop through pids associated with client. Magically make last focus
+* Loop through pids associated with client. Magically make last focus
-group go non-interactive -IA_BOOST.
+* group go non-interactive -IA_BOOST.
 */
 static void
 ChangePriority(register ClientPtr client)
 {
-ClientProcessPtr CurrentPids=GetConnectionPids(client);
+IAClientPrivatePtr priv = GetIAClient(client);
-register int count;
+ClientProcessPtr CurrentPids = (priv == NULL ? NULL : priv->process);
-/* If no pid info for current client make sure to unset last focus group. */
+if (CurrentPids && LastPids && PidSetEqual(CurrentPids, LastPids)) {
-/* This can happen if we have a remote client with focus or if the client */
+	/* Shortcut. Focus changed between two windows with same pid */
-/* is statically linked or if it is using a down rev version of libX11.   */
+	return;
-if (!CurrentPids || !CurrentPids->pids) {
+}
-	if (LastPids && LastPids->pids) {
-	    UnsetLastPriority(LastPids);
+/* Remove priority boost for last focus group */
-	    LastPids=NULL;
+if (LastPids) {
-	}
+	SetPriority(LastPids, UNSET_PRIORITY);
-	return;
+	LastPids = NULL;
 }
-/* Make sure server or wmgr isn't unset by testing for them */
+/* If no pid info for current client, then we're done here.
-/* this way LastPids is never set to point to the server or */
+* This can happen if we have a remote client with focus or if the client
-/* wmgr pid.						       */
+* is statically linked or if it is using a down rev version of libX11.
-if ((client->index==serverClient->index ||
+*/
-GetIAClient(client)->wmgr==xTrue)) {
+if ( (CurrentPids == NULL) || (CurrentPids->count == 0) ||
+	 (CurrentPids->pids == NULL) ) {
-if ((specialIAset < BOTH) && CurrentPids->pids) {
+	return;
+}
-	   if (client->index == serverClient->index) {
-	       specialIAset |= SERVER;
+/* Set the priority boost if it isn't already active */
-	   }
+if (!CurrentPids->boosted) {
-	   else {
+	SetPriority(CurrentPids, SET_PRIORITY);
-	       specialIAset |= WMGR;
+}
-	   }
-	   SetPriority(CurrentPids->pids[0], SET_PRIORITY);
+/* Make sure server or wmgr isn't unset by testing for them, so
-}
+* that LastPids is never set to point to the server or wmgr pid.
-return;
+*/
-}
+if ((client->index != serverClient->index) && (priv->wmgr != TRUE)) {
+	LastPids = CurrentPids;
-if (LastPids && LastPids->pids) {
+}
-	if (CurrentPids && LastPids && PidSetEqual(CurrentPids, LastPids))
-		return;				/*Shortcut. Focus changed
-						  between two windows with
-						  same pid */
-	UnsetLastPriority(LastPids);
-}
-count=CurrentPids->count;
-while(count--)
-SetPriority(CurrentPids->pids[count], SET_PRIORITY);
-LastPids=CurrentPids;
-}
-static void
-UnsetLastPriority(ClientProcessPtr LastPids)
-{
-register int LastPidcount=LastPids->count;
-while(LastPidcount--)
-	SetPriority(LastPids->pids[LastPidcount], UNSET_PRIORITY);
 }
 static int
 InitializeClass(void)
 {
 pcinfo_t  pcinfo;
-/* Get TS class information 					*/
+/* Get TS class information */
+strcpy (pcinfo.pc_clname, "TS");
-strcpy (pcinfo.pc_clname, "TS");
+priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo);
-priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo);
+TScid = pcinfo.pc_cid;
-TScid=pcinfo.pc_cid;
+/* Get IA class information */
-/* Get IA class information */
+strcpy (pcinfo.pc_clname, "IA");
-strcpy (pcinfo.pc_clname, "IA");
+if ((priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo)) == -1)
-if ((priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo)) == -1)
 return ~Success;
-IAClass.pc_cid=pcinfo.pc_cid;
+IAClass.pc_cid = pcinfo.pc_cid;
-((iaparms_t*)IAClass.pc_clparms)->ia_uprilim=IA_NOCHANGE;
+((iaparms_t*)IAClass.pc_clparms)->ia_uprilim = IA_NOCHANGE;
-((iaparms_t*)IAClass.pc_clparms)->ia_upri=IA_NOCHANGE;
+((iaparms_t*)IAClass.pc_clparms)->ia_upri = IA_NOCHANGE;
 return Success;
 }
 static int
-SetPriority(int pid, int cmd)
+SetPriority(const ClientProcessPtr cpp, int cmd)
 {
-pcparms_t pcinfo;
+pcparms_t 	pcinfo;
-long	ret;
+long	ret = Success;
 gid_t	usr_egid = getegid();
+int		i;
-if ( setegid(0) < 0 )
+if ( (cpp == NULL) || (cpp->pids == NULL) || (cpp->count == 0) ) {
+	return Success;
+}
+if ( setegid(0) < 0 ) {
 	Error("Error in setting egid to 0");
+}
-pcinfo.pc_cid=PC_CLNULL;
+for (i = 0; i < cpp->count ; i++) {
-if ((priocntl(P_PID, pid, PC_GETPARMS, (caddr_t)&pcinfo)) < 0) {
+	id_t	pid = cpp->pids[i];
-	if ( setegid(usr_egid) < 0 )
-	    Error("Error in resetting egid");
+	pcinfo.pc_cid=PC_CLNULL;
+	if ((priocntl(P_PID, pid, PC_GETPARMS, (caddr_t)&pcinfo)) < 0) {
-	return ~Success; /* Scary time; punt */
+	    if ( setegid(usr_egid) < 0 ) {
-}
+		Error("Error in resetting egid");
+	    }
-/* If process is in TS or IA class we can safely set parameters */
+	    return ~Success; /* Scary time; punt */
-if ((pcinfo.pc_cid == IAClass.pc_cid) || (pcinfo.pc_cid == TScid)) {
+	}
-switch (cmd) {
+	/* If process is in TS or IA class we can safely set parameters */
-case UNSET_PRIORITY:
+	if ((pcinfo.pc_cid == IAClass.pc_cid) || (pcinfo.pc_cid == TScid)) {
+	    switch (cmd) {
+	      case UNSET_PRIORITY:
 		((iaparms_t*)IAClass.pc_clparms)->ia_mode=IA_INTERACTIVE_OFF;
 		break;
-case SET_PRIORITY:
+	      case SET_PRIORITY:
 		((iaparms_t*)IAClass.pc_clparms)->ia_mode=IA_SET_INTERACTIVE;
 		break;
-case SET_INTERACTIVE:
+	      case SET_INTERACTIVE:
-/* If this returns true, the process is already in the IA class */
+		/* If this returns true, the process is already in the 	*/
-/* So just return.						   */
+		/* IA class, so we don't need to update it.		*/
-		 if ( pcinfo.pc_cid == IAClass.pc_cid)
+		if ( pcinfo.pc_cid == IAClass.pc_cid)
-			return Success;
+		    continue;
 		((iaparms_t*)IAClass.pc_clparms)->ia_mode=IA_INTERACTIVE_OFF;
 		break;
-}
+	    }
-	if ( priocntl(P_PID, pid, PC_SETPARMS, (caddr_t)&IAClass) == -1 )
+	    if (priocntl(P_PID, pid, PC_SETPARMS, (caddr_t)&IAClass) == -1)
 	    {
-	    ret = ~Success;
+		ret = ~Success;
 	    }
-	else
+	    IA_DEBUG(IA_DEBUG_PRIOCNTL,
 	    {
-	    ret = Success;
+		const char *cmdmsg;
-	    }
+		switch (cmd) {
+		  case UNSET_PRIORITY:	cmdmsg = "UNSET_PRIORITY";	break;
-	IA_DEBUG(IA_DEBUG_PRIOCNTL,
+		  case SET_PRIORITY:	cmdmsg = "SET_PRIORITY"; 	break;
-	{
+		  case SET_INTERACTIVE:	cmdmsg = "SET_INTERACTIVE"; 	break;
-	    const char *cmdmsg;
+		  default:		cmdmsg = "UNKNOWN_CMD!!!"; 	break;
+		}
-	    switch (cmd) {
+		LogMessage(X_INFO, "SolarisIA: SetPriority(%ld, %s): %s\n",
-	    case UNSET_PRIORITY:   cmdmsg = "UNSET_PRIORITY"; break;
+			   pid, cmdmsg,
-	    case SET_PRIORITY:     cmdmsg = "SET_PRIORITY"; break;
+			   (ret == Success) ? "succeeeded" : "failed");
-	    case SET_INTERACTIVE:  cmdmsg = "SET_INTERACTIVE"; break;
+	    });
-	    default:		   cmdmsg = "UNKNOWN_CMD!!!"; break;
+	}
-	    }
+}
-	    LogMessage(X_INFO, "SolarisIA: SetPriority(%d, %s): %s\n",
-	      pid, cmdmsg, (ret == Success) ? "succeeeded" : "failed");
+if (setegid(usr_egid) < 0)
-	});
+	Error("Error in resetting egid");
+if (ret == Success) {
-	if ( setegid(usr_egid) < 0 )
+	if (cmd == SET_PRIORITY) {
-	    Error("Error in resetting egid");
+	    cpp->boosted = TRUE;
+	} else if (cmd == UNSET_PRIORITY) {
-	return ret;
+	    cpp->boosted = FALSE;
-}
+	}
+}
-return ~Success;
+return ret;
 }
 static void
 SetIAPrivate(int * value)
 {
-	ia_nice=*value;
+ia_nice = *value;
 }
 /*****************************************************************************
 * Various utility functions - in Xsun these lived in Xserver/os/process.c
 */
 /* In Xsun we used the osPrivate in OsCommPtr, so this was SetOsPrivate. */
 static int
 SetClientPrivate(ClientPtr client, ConnectionPidPtr stuff, int length)
 {
 ClientProcessPtr	cpp;
+IAClientPrivatePtr priv;
-FreeProcessList(client);
+priv = GetIAClient(client);
+if (priv == NULL) {
+	IAInitClientPrivate(client);
+} else {
+	FreeProcessList(priv);
+}
 cpp = (ClientProcessPtr)xalloc(sizeof(ClientProcessRec));
 if (cpp == NULL)
 	return BadAlloc;
 if (cpp->pids == NULL) {
 	xfree(cpp);
 	return BadAlloc;
 }
-GetConnectionPids(client) = cpp;
 cpp->count = length;
 memcpy(cpp->pids, stuff, sizeof(ConnectionPidRec)*length);
+cpp->boosted = FALSE;
+priv->process = cpp;
 return Success;
 }
 static void
-FreeProcessList(ClientPtr client)
+FreeProcessList(IAClientPrivatePtr priv)
 {
-ClientProcessPtr	cpp = GetConnectionPids(client);
+ClientProcessPtr	cpp = priv->process;
 if (cpp == NULL)
 	return;
+priv->process = NULL;
 if ( LastPids == cpp )
 	LastPids = NULL;
 if (cpp->pids != NULL)
 	xfree(cpp->pids);
 xfree(cpp);
-GetConnectionPids(client) = NULL;
 }
 /*
-Check to see that all in current (a) are in
+Check to see that all in current (a) are in last (b).
-last (b). And that a and b have the same number
+And that a and b have the same number of members in the set.
-of members in the set.
 */
-int
+static int
 PidSetEqual(ClientProcessPtr a, ClientProcessPtr b)
 {
-register int currentcount=a->count;
+int aN, bN;
-register int lastcount=b->count;
+int count = a->count;
-int retval;
+int retval = 1;
-if (currentcount != lastcount)
+if (a->count != b->count) {
-return 0; /* definately NOT the same set */
+	return 0; /* definately NOT the same set */
+}
-while(currentcount--) {
-retval=0;
+for (aN = 0; aN < count; aN++) {
-while(lastcount--)
+	retval = 0;
-if (a->pids[currentcount]==b->pids[lastcount]) {
+	for (bN = 0; bN < count ; bN++) {
-retval=1;
+	    if (a->pids[aN] == b->pids[bN]) {
-break;
+		retval = 1;
-}
+		break;
-if (retval==0)
+	    }
-return retval;
+	}
-lastcount=b->count;
+	if (retval == 0)
-}
+	    return retval;
+}
-return retval;
+return retval;
 }
 /*****************************************************************************
 * Wrappers for normal procs - in Xsun we modified the original procs directly
 static int
 IAProcSetInputFocus(ClientPtr client)
 {
 int res;
 Window focusID;
-register WindowPtr focusWin;
+WindowPtr focusWin;
 REQUEST(xSetInputFocusReq);
 res = (*IASavedProcVector[X_SetInputFocus])(client);
-if ((res != Success) || (InteractiveOS != xTrue))
+if ((res != Success) || (InteractiveOS != TRUE))
 	return res;
 focusID = stuff->focus;
 switch (focusID) {
 	break;
 case PointerRoot:
 	focusWin = PointerRootWin;
 	break;
 default:
-	if (!(focusWin = SecurityLookupWindow(focusID, client,
+	res = dixLookupWindow(&focusWin, focusID, client, DixReadAccess);
-SecurityReadAccess)))
+	if (res != Success)
-	    return BadWindow;
+	    return res;
 }
 if ((focusWin != NullWindow) && (focusWin != PointerRootWin)) {
-	register ClientPtr requestee;
+	register ClientPtr requestee = wClient(focusWin);
-ClientProcessPtr wmPid=NULL;
+	ChangePriority(requestee);
-ClientProcessPtr RequesteePids=NULL;
-if (wmClientptr)
-wmPid=GetConnectionPids(wmClientptr);
-requestee=wClient(focusWin);
-RequesteePids=GetConnectionPids(requestee);
-/* if wm is not setting focus to himself */
-if (wmPid && RequesteePids && !PidSetEqual(wmPid, RequesteePids))
-ChangePriority(requestee);
-else  {
-/* If wm is setting focus to himself and Lastpids exists and
-LastPids pids are valid Unset the priority for the LastPids
-focus group */
-if (wmPid && RequesteePids && PidSetEqual(wmPid, RequesteePids))
-if (LastPids && LastPids->pids) {
-UnsetLastPriority(LastPids);
-LastPids=NULL;
-}
-}
 }
 return res;
 }
 {
 int res;
 REQUEST(xSendEventReq);
 res = (*IASavedProcVector[X_SendEvent])(client);
-if ((res != Success) || (InteractiveOS != xTrue))
+if ((res != Success) || (InteractiveOS != TRUE))
 	return res;
-if ((InteractiveOS==xTrue) &&
+if ((InteractiveOS==TRUE) &&
-(client == wmClientptr) &&
+(GetIAClient(client)->wmgr == TRUE) &&
 (stuff->event.u.u.type == ClientMessage) &&
 (stuff->event.u.u.detail == 32) ) {
 register ClientPtr requestee;
-ClientProcessPtr wmPid=NULL;
+	WindowPtr pWin = NULL;
-ClientProcessPtr RequesteePids=NULL;
-	WindowPtr pWin;
 	if (stuff->destination == PointerWindow)
 	    pWin = GetSpriteWindow();
 	else if (stuff->destination == InputFocus)
 	{
 		pWin = GetSpriteWindow();
 	    else
 		pWin = inputFocus;
 	}
 	else
-	    pWin = SecurityLookupWindow(stuff->destination, client,
+	{
-	    				SecurityReadAccess);
+	    res = dixLookupWindow(&pWin, stuff->destination, client,
+				  DixReadAccess);
+	    if (res != Success)
+		return res;
+	}
 	if (!pWin)
 	    return BadWindow;
-if (wmClientptr)
+requestee = wClient(pWin);
-	    wmPid=GetConnectionPids(wmClientptr);
+	ChangePriority(requestee);
-requestee=wClient(pWin);
-RequesteePids=GetConnectionPids(requestee);
-/* if wm is not setting focus to himself */
-if (wmPid && RequesteePids && !PidSetEqual(wmPid, RequesteePids)) {
-ChangePriority(requestee);
-	}
-	else {
-/* If wm is setting focus to himself and Lastpids exists and
-LastPids pids are valid Unset the priority for the LastPids
-focus group */
-if (LastPids && LastPids->pids) {
-UnsetLastPriority(LastPids);
-LastPids=NULL;
-}
-}
 }
 return res;
 }
 static Bool
 IAProcChangeWindowAttributes(ClientPtr client)
 {
 REQUEST(xChangeWindowAttributesReq);
-if ((InteractiveOS==xTrue) && (stuff->valueMask & CWEventMask) &&
+if ((InteractiveOS==TRUE) && (stuff->valueMask & CWEventMask) &&
-	(GetIAClient(client)->wmgr == xFalse) ) {
+	(GetIAClient(client)->wmgr == FALSE) ) {
 	register XID *pVlist = (XID *) &stuff[1];
 	register Mask tmask = stuff->valueMask;
 	register Mask index2 = 0;
 	    pVlist++;
 	}
 	if ((index2 == CWEventMask) && (*pVlist & SubstructureRedirectMask)) {
 	    IA_DEBUG(IA_DEBUG_BASIC,
-	    ClientProcessPtr CurrentPids=GetConnectionPids(client);
+		     ClientProcessPtr CurrentPids=GetConnectionPids(client);
-	    LogMessage(X_INFO, "SolarisIA: WindowManager detected (pid %d)\n",
+		     LogMessage(X_INFO,
-	      (CurrentPids && CurrentPids->pids) ? CurrentPids->pids[0] : -1));
+				"SolarisIA: WindowManager detected (pid %d)\n",
+				(CurrentPids && CurrentPids->pids) ?
+				 CurrentPids->pids[0] : -1));
-	    GetIAClient(client)->wmgr=xTrue;
-	    wmClientptr = client;
+	    GetIAClient(client)->wmgr = TRUE;
 	    ChangePriority(client);
+	    LastPids = NULL;
 	}
 }
 return (*IASavedProcVector[X_ChangeWindowAttributes])(client);
 }

changeset 606	068c11b419c9
parent 436	4c79f0dc36ed
child 705	24ca414edbff