components/x11/xorg-server/srcs/IA/interactive.c

   1 /*
   2  * Copyright (c) 1993, 2015, Oracle and/or its affiliates. All rights reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24
  25 /************************************************************
  26         Basic boilerplate extension.
  27
  28         This file also contains the code to make the priocntl on behalf
  29         of the clients.
  30
  31         Note that ChangePriority also sets the last client with focus
  32         to the normal priority.
  33
  34         If there are knobs to be added to the system, for say the nice
  35         values for the IA class, they would be added here.
  36 ********************************************************/
  37
  38 /* THIS IS NOT AN X CONSORTIUM STANDARD */
  39
  40 #ifdef HAVE_DIX_CONFIG_H
  41 #include <dix-config.h>
  42 #endif
  43
  44 #include <errno.h>
  45 #include <sys/types.h>
  46 #include <stdio.h>
  47
  48 #include <sys/priocntl.h>
  49 #include <sys/iapriocntl.h>
  50 #include <unistd.h>
  51
  52
  53 #include <X11/X.h>
  54 #include <X11/Xproto.h>
  55 #include "os.h"
  56 #include "dixstruct.h"
  57 #include "windowstr.h"
  58 #include "inputstr.h"
  59 #include "extnsionst.h"
  60 #define _XIA_SERVER_
  61 #include <X11/extensions/interactive.h>
  62 #include <X11/Xfuncproto.h>
  63 #include "dix.h"
  64 #include "client.h"
  65
  66 #include "interactive_srv.h"
  67
  68 static int ProcIADispatch(ClientPtr client);
  69 static int SProcIADispatch(ClientPtr client);
  70 static int ProcIASetProcessInfo(ClientPtr client);
  71 static int SProcIASetProcessInfo(ClientPtr client);
  72 static int ProcIAGetProcessInfo(ClientPtr client);
  73 static int SProcIAGetProcessInfo(ClientPtr client);
  74 static int ProcIAQueryVersion(ClientPtr client);
  75 static int SProcIAQueryVersion(ClientPtr client);
  76 static void IACloseDown(ExtensionEntry *ext);
  77 static void IAClientStateChange(CallbackListPtr *pcbl, void *nulldata,
  78                                 void *calldata);
  79
  80 static int InitializeClass(void);
  81 static void SetIAPrivate(int *);
  82 static void ChangeInteractive(ClientPtr);
  83 static int SetPriority(const ClientProcessPtr, int);
  84 static void ChangePriority(register ClientPtr client);
  85
  86 static int SetClientPrivate(ClientPtr client, ConnectionPidPtr stuff,
  87                             int length);
  88 static void FreeProcessList(IAClientPrivatePtr priv);
  89 /* static int LocalConnection(OsCommPtr); */
  90 static int PidSetEqual(ClientProcessPtr, ClientProcessPtr);
  91
  92 static int IAWrapProcVectors(void);
  93 static int IAUnwrapProcVectors(void);
  94
  95 static CARD32 IAInitTimerCall(OsTimerPtr timer, CARD32 now, void *arg);
  96
  97 static iaclass_t        IAClass;
  98 static id_t             TScid;
  99 static ClientProcessPtr LastPids = NULL;
 100 static int              ia_nice = IA_BOOST;
 101 static Bool             InteractiveOS = TRUE;
 102 static unsigned long    IAExtensionGeneration = 0;
 103 static OsTimerPtr       IAInitTimer = NULL;
 104 static int (* IASavedProcVector[256]) (ClientPtr client);
 105
 106 static DevPrivateKeyRec IAPrivKeyRec;
 107 #define IAPrivKey (&IAPrivKeyRec)
 108
 109 #define GetIAClient(pClient)    \
 110     ((IAClientPrivatePtr) dixLookupPrivate(&(pClient)->devPrivates, IAPrivKey))
 111
 112 static inline ClientProcessPtr
 113 GetConnectionPids(ClientPtr pClient)
 114 {
 115     IAClientPrivatePtr priv = GetIAClient(pClient);
 116
 117     if (priv == NULL) {
 118         return NULL;
 119     } else {
 120         return priv->process;
 121     }
 122 }
 123
 124 /* Set via xorg.conf option in loadable module */
 125 int IADebugLevel = 0;
 126
 127 #define IA_DEBUG(level, func)   \
 128         if (IADebugLevel >= level) { func; } else (void)(0)
 129
 130 #define IA_DEBUG_BASIC          1
 131 #define IA_DEBUG_PRIOCNTL       3
 132
 133 void
 134 IAExtensionInit(void)
 135 {
 136     ConnectionPidRec    myPid = P_MYID;
 137     ClientProcessRec    myProc = { 1, &myPid, FALSE };
 138
 139     IA_DEBUG(IA_DEBUG_BASIC,
 140              LogMessage(X_INFO, "SolarisIA: Initializing (generation %ld)\n",
 141                         IAExtensionGeneration));
 142
 143     if (IAExtensionGeneration == serverGeneration)
 144         return;
 145
 146     InteractiveOS = FALSE;
 147
 148     if (InitializeClass() != Success)
 149         return;
 150
 151     if (SetPriority(&myProc, SET_INTERACTIVE) != Success)
 152         return;
 153
 154     if (SetPriority(&myProc, SET_PRIORITY) != Success)
 155         return;
 156
 157     if (!dixRegisterPrivateKey(&IAPrivKeyRec, PRIVATE_CLIENT, 0))
 158         return;
 159
 160     if (!AddCallback(&ClientStateCallback, IAClientStateChange, NULL))
 161         return;
 162
 163     if (IAWrapProcVectors() != 0)
 164         return;
 165
 166     if (!AddExtension(IANAME, IANumberEvents, IANumberErrors,
 167                       ProcIADispatch, SProcIADispatch,
 168                       IACloseDown, StandardMinorOpcode))
 169         return;
 170
 171     /* InitExtensions is called before InitClientPrivates(serverClient)
 172        so we set this timer to callback as soon as we hit WaitForSomething
 173        to initialize the serverClient */
 174     IAInitTimer = TimerSet(IAInitTimer, 0, 1, IAInitTimerCall, NULL);
 175
 176     InteractiveOS = TRUE;
 177     IAExtensionGeneration = serverGeneration;
 178
 179     IA_DEBUG(IA_DEBUG_BASIC,
 180              LogMessage(X_INFO,
 181                         "SolarisIA: Finished initializing (generation %ld)\n",
 182                         IAExtensionGeneration));
 183 }
 184
 185 /* Allocate client private structure for this client */
 186 static int
 187 IAInitClientPrivate(ClientPtr pClient)
 188 {
 189     IAClientPrivatePtr priv;
 190
 191     priv = GetIAClient(pClient);
 192     if (priv != NULL) {
 193         return Success;
 194     }
 195
 196     priv = malloc(sizeof(IAClientPrivateRec));
 197     if (priv == NULL) {
 198         return BadAlloc;
 199     }
 200
 201     priv->process = NULL;
 202     priv->wmgr = FALSE;
 203
 204     dixSetPrivate(&(pClient)->devPrivates, IAPrivKey, priv);
 205
 206     return Success;
 207 }
 208
 209 /* Called when we first hit WaitForSomething to initialize serverClient */
 210 static CARD32
 211 IAInitTimerCall(OsTimerPtr timer, CARD32 now, void *arg)
 212 {
 213     ConnectionPidRec serverPid;
 214
 215     if (InteractiveOS != TRUE)
 216         return 0;
 217
 218     IAInitClientPrivate(serverClient);
 219
 220     serverPid = getpid();
 221     SetClientPrivate(serverClient, &serverPid, 1);
 222
 223     ChangePriority(serverClient);
 224     return 0;
 225 }
 226
 227 /* Called when new client connects or existing client disconnects */
 228 static void
 229 IAClientStateChange(CallbackListPtr *pcbl, void *nulldata, void *calldata)
 230 {
 231     NewClientInfoRec *pci = (NewClientInfoRec *)calldata;
 232     ClientPtr pClient = pci->client;
 233     ClientProcessPtr CurrentPids;
 234     IAClientPrivatePtr priv;
 235     LocalClientCredRec *lcc;
 236
 237     switch (pClient->clientState) {
 238       case ClientStateGone:
 239       case ClientStateRetained:
 240         priv = GetIAClient(pClient);
 241         if (priv == NULL) {
 242             return;
 243         }
 244         CurrentPids = priv->process;
 245
 246         if (priv->wmgr) {
 247             IA_DEBUG(IA_DEBUG_BASIC,
 248                      LogMessage(X_INFO,
 249                                 "SolarisIA: WindowManager closed (pid %d)\n",
 250                                 (CurrentPids && CurrentPids->pids) ?
 251                                  CurrentPids->pids[0] : -1));
 252         }
 253
 254         if (CurrentPids && CurrentPids->boosted) {
 255             SetPriority(CurrentPids, UNSET_PRIORITY);
 256         }
 257
 258         if (CurrentPids && LastPids && PidSetEqual(CurrentPids, LastPids)) {
 259             LastPids = NULL;
 260         }
 261
 262         FreeProcessList(priv);
 263         free(priv);
 264         dixSetPrivate(&(pClient)->devPrivates, IAPrivKey, NULL);
 265         break;
 266
 267     case ClientStateInitial:
 268         IAInitClientPrivate(pClient);
 269         {
 270             ConnectionPidRec clientPid = GetClientPid(pClient);
 271             if (clientPid != -1) {
 272                 SetClientPrivate(pClient, &clientPid, 1);
 273                 ChangeInteractive(pClient);
 274             }
 275         }
 276         break;
 277
 278     default:
 279         break;
 280     }
 281 }
 282
 283
 284 static int
 285 ProcIADispatch (ClientPtr client)
 286 {
 287     REQUEST(xReq);
 288     switch (stuff->data)
 289     {
 290     case X_IAQueryVersion:
 291         return ProcIAQueryVersion(client);
 292     case X_IASetProcessInfo:
 293         return ProcIASetProcessInfo(client);
 294     case X_IAGetProcessInfo:
 295         return ProcIAGetProcessInfo(client);
 296     default:
 297         return BadRequest;
 298     }
 299 }
 300
 301 static int
 302 ProcIAQueryVersion(ClientPtr client)
 303 {
 304     REQUEST(xIAQueryVersionReq);
 305     xIAQueryVersionReply rep;
 306
 307     REQUEST_SIZE_MATCH(xIAQueryVersionReq);
 308     rep.type = X_Reply;
 309     rep.length = 0;
 310     rep.sequenceNumber = client->sequence;
 311     rep.majorVersion = IA_MAJOR_VERSION;
 312     rep.minorVersion = IA_MINOR_VERSION;
 313     WriteToClient(client, sizeof(xIAQueryVersionReply), (char *)&rep);
 314     return (client->noClientException);
 315 }
 316
 317 static int
 318 ProcIASetProcessInfo(ClientPtr client)
 319 {
 320
 321     REQUEST(xIASetProcessInfoReq);
 322     register int length;
 323     static uid_t ServerUid = (uid_t)-1;
 324
 325     REQUEST_AT_LEAST_SIZE(xIASetProcessInfoReq);
 326
 327     if (ServerUid == (uid_t)-1)
 328         ServerUid=getuid();
 329
 330     if ((stuff->flags & INTERACTIVE_INFO) &&
 331         (stuff->uid==ServerUid || ServerUid==0 || stuff->uid==0) &&
 332         client->local) {
 333         length = stuff->length - (sizeof(xIASetProcessInfoReq)>>2);
 334         SetClientPrivate(client, (ConnectionPidPtr)&stuff[1], length);
 335         ChangeInteractive(client);
 336     }
 337
 338     if ((stuff->flags & INTERACTIVE_SETTING) &&
 339         (stuff->uid==ServerUid || ServerUid==0) &&
 340         client->local) {
 341         SetIAPrivate((int *)&stuff[1]);
 342     }
 343
 344     return (client->noClientException);
 345 }
 346
 347 static int
 348 ProcIAGetProcessInfo(ClientPtr client)
 349 {
 350     IAClientPrivatePtr  priv;
 351     ClientProcessPtr CurrentPids;
 352     REQUEST(xIAGetProcessInfoReq);
 353     xIAGetProcessInfoReply rep;
 354     register int length = 0;
 355     int i;
 356     int32_t *write_back = NULL;
 357
 358     REQUEST_SIZE_MATCH(xIAGetProcessInfoReq);
 359     rep.type = X_Reply;
 360     rep.length = 0;
 361     rep.sequenceNumber = client->sequence;
 362
 363     if (stuff->flags & INTERACTIVE_INFO) {
 364         priv = GetIAClient(client);
 365         if ( (priv == NULL) || (priv->process == NULL) ) {
 366             rep.count = 0;
 367         } else {
 368             CurrentPids = priv->process;
 369             rep.count = CurrentPids->count;
 370             length = rep.count << 2;
 371             rep.length = rep.count;
 372             write_back = malloc((size_t) rep.count * sizeof(int32_t));
 373             if (write_back == NULL)
 374                 return ~Success;
 375             else {
 376                 int32_t *tmp = write_back;
 377
 378                 for (i = 0; i < CurrentPids->count; ++i)
 379                     *tmp++ = *CurrentPids->pids++;
 380             }
 381         }
 382     }
 383     if (stuff->flags & INTERACTIVE_SETTING) {
 384         rep.count=1;
 385         length=rep.count << 2;
 386         rep.length = rep.count;
 387
 388         write_back = malloc(sizeof(int32_t));
 389         if (write_back == NULL)
 390             return ~Success;
 391
 392         *write_back = (int32_t) ia_nice;
 393     }
 394
 395     WriteToClient(client, sizeof(xIAGetProcessInfoReply), (char *)&rep);
 396
 397     if (rep.length > 0) {
 398         (void) WriteToClient(client, (int) sizeof(int32_t) * rep.count,
 399                 (char *) write_back);
 400         free(write_back);
 401     }
 402
 403     return (client->noClientException);
 404 }
 405
 406 static void
 407 IACloseDown(ExtensionEntry *ext)
 408 {
 409     InteractiveOS = FALSE;
 410
 411     IAUnwrapProcVectors();
 412
 413     DeleteCallback(&ClientStateCallback, IAClientStateChange, NULL);
 414 }
 415
 416 /*
 417    The SProc* functions are here for completeness. They should never get
 418    called. But since they do the server has to eat the request and
 419    return thanks for sharing.
 420 */
 421
 422 /*ARGSUSED*/
 423 static int
 424 SProcIADispatch (ClientPtr client)
 425 {
 426     REQUEST(xReq);
 427     switch (stuff->data)
 428     {
 429     case X_IAQueryVersion:
 430         return SProcIAQueryVersion(client);
 431     case X_IASetProcessInfo:
 432         return SProcIASetProcessInfo(client);
 433     case X_IAGetProcessInfo:
 434         return SProcIAGetProcessInfo(client);
 435     default:
 436         return BadRequest;
 437     }
 438 }
 439
 440 /*ARGSUSED*/
 441 static int
 442 SProcIAQueryVersion(ClientPtr client)
 443 {
 444     REQUEST_SIZE_MATCH(xIAQueryVersionReq);
 445     return (client->noClientException);
 446 }
 447
 448 /*ARGSUSED*/
 449 static int
 450 SProcIASetProcessInfo(ClientPtr client)
 451 {
 452     REQUEST(xIASetProcessInfoReq);
 453     REQUEST_AT_LEAST_SIZE(xIASetProcessInfoReq);
 454
 455     return (client->noClientException);
 456 }
 457
 458 /*ARGSUSED*/
 459 static int
 460 SProcIAGetProcessInfo(ClientPtr client)
 461 {
 462     REQUEST(xIAGetProcessInfoReq);
 463     REQUEST_SIZE_MATCH(xIAGetProcessInfoReq);
 464
 465     return (client->noClientException);
 466 }
 467
 468 static void
 469 ChangeInteractive(ClientPtr client)
 470 {
 471     ClientProcessPtr CurrentPids = GetConnectionPids(client);
 472
 473     if (InteractiveOS==FALSE)
 474         return;
 475
 476     if (!CurrentPids || !CurrentPids->pids)
 477         return;
 478
 479     SetPriority(CurrentPids, SET_INTERACTIVE);
 480 }
 481
 482 /*
 483  * Loop through pids associated with client. Magically make last focus
 484  * group go non-interactive -IA_BOOST.
 485  */
 486 static void
 487 ChangePriority(register ClientPtr client)
 488 {
 489     IAClientPrivatePtr priv = GetIAClient(client);
 490     ClientProcessPtr CurrentPids = (priv == NULL ? NULL : priv->process);
 491
 492     if (CurrentPids && LastPids && PidSetEqual(CurrentPids, LastPids)) {
 493         /* Shortcut. Focus changed between two windows with same pid */
 494         return;
 495     }
 496
 497     /* Remove priority boost for last focus group */
 498     if (LastPids) {
 499         SetPriority(LastPids, UNSET_PRIORITY);
 500         LastPids = NULL;
 501     }
 502
 503     /* If no pid info for current client, then we're done here.
 504      * This can happen if we have a remote client with focus or if the client
 505      * is statically linked or if it is using a down rev version of libX11.
 506      */
 507     if ( (CurrentPids == NULL) || (CurrentPids->count == 0) ||
 508          (CurrentPids->pids == NULL) ) {
 509         return;
 510     }
 511
 512     /* Set the priority boost if it isn't already active */
 513     if (!CurrentPids->boosted) {
 514         SetPriority(CurrentPids, SET_PRIORITY);
 515     }
 516
 517     /* Make sure server or wmgr isn't unset by testing for them, so
 518      * that LastPids is never set to point to the server or wmgr pid.
 519      */
 520     if ((client->index != serverClient->index) && (priv->wmgr != TRUE)) {
 521         LastPids = CurrentPids;
 522     }
 523 }
 524
 525 static int
 526 InitializeClass(void)
 527 {
 528     pcinfo_t  pcinfo;
 529
 530     /* Get TS class information */
 531     strcpy (pcinfo.pc_clname, "TS");
 532     priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo);
 533     TScid = pcinfo.pc_cid;
 534
 535     /* Get IA class information */
 536     strcpy (pcinfo.pc_clname, "IA");
 537     if ((priocntl(0, 0, PC_GETCID, (caddr_t)&pcinfo)) == -1)
 538         return ~Success;
 539
 540     IAClass.pc_cid = pcinfo.pc_cid;
 541     ((iaparms_t*)IAClass.pc_clparms)->ia_uprilim = IA_NOCHANGE;
 542     ((iaparms_t*)IAClass.pc_clparms)->ia_upri = IA_NOCHANGE;
 543
 544     return Success;
 545 }
 546
 547 static int
 548 SetPriority(const ClientProcessPtr cpp, int cmd)
 549 {
 550     pcparms_t   pcinfo;
 551     long        ret = Success;
 552     gid_t       usr_egid = getegid();
 553     int         i;
 554
 555     if ( (cpp == NULL) || (cpp->pids == NULL) || (cpp->count == 0) ) {
 556         return Success;
 557     }
 558
 559     if ( setegid(0) < 0 ) {
 560         ErrorF("Error in setting egid to 0: %s\n", strerror(errno));
 561     }
 562
 563     for (i = 0; i < cpp->count ; i++) {
 564         id_t    pid = cpp->pids[i];
 565
 566         pcinfo.pc_cid = PC_CLNULL;
 567         if ((priocntl(P_PID, pid, PC_GETPARMS, (caddr_t)&pcinfo)) < 0) {
 568             if ( setegid(usr_egid) < 0 ) {
 569                 ErrorF("Error in resetting egid: %s\n", strerror(errno));
 570             }
 571             return ~Success; /* Scary time; punt */
 572         }
 573
 574         /* If process is in TS or IA class we can safely set parameters */
 575         if ((pcinfo.pc_cid == IAClass.pc_cid) || (pcinfo.pc_cid == TScid)) {
 576
 577             switch (cmd) {
 578               case UNSET_PRIORITY:
 579                 ((iaparms_t*)IAClass.pc_clparms)->ia_mode=IA_INTERACTIVE_OFF;
 580                 break;
 581               case SET_PRIORITY:
 582                 ((iaparms_t*)IAClass.pc_clparms)->ia_mode=IA_SET_INTERACTIVE;
 583                 break;
 584               case SET_INTERACTIVE:
 585                 /* If this returns true, the process is already in the  */
 586                 /* IA class, so we don't need to update it.             */
 587                 if ( pcinfo.pc_cid == IAClass.pc_cid)
 588                     continue;
 589
 590                 ((iaparms_t*)IAClass.pc_clparms)->ia_mode=IA_INTERACTIVE_OFF;
 591                 break;
 592             }
 593
 594             if (priocntl(P_PID, pid, PC_SETPARMS, (caddr_t)&IAClass) == -1)
 595             {
 596                 ret = ~Success;
 597             }
 598
 599             IA_DEBUG(IA_DEBUG_PRIOCNTL,
 600             {
 601                 const char *cmdmsg;
 602
 603                 switch (cmd) {
 604                   case UNSET_PRIORITY:  cmdmsg = "UNSET_PRIORITY";      break;
 605                   case SET_PRIORITY:    cmdmsg = "SET_PRIORITY";        break;
 606                   case SET_INTERACTIVE: cmdmsg = "SET_INTERACTIVE";     break;
 607                   default:              cmdmsg = "UNKNOWN_CMD!!!";      break;
 608                 }
 609                 LogMessage(X_INFO, "SolarisIA: SetPriority(%d, %s): %s\n",
 610                            pid, cmdmsg,
 611                            (ret == Success) ? "succeeeded" : "failed");
 612             });
 613         }
 614     }
 615
 616     if (setegid(usr_egid) < 0)
 617         ErrorF("Error in resetting egid: %s\n", strerror(errno));
 618
 619     if (ret == Success) {
 620         if (cmd == SET_PRIORITY) {
 621             cpp->boosted = TRUE;
 622         } else if (cmd == UNSET_PRIORITY) {
 623             cpp->boosted = FALSE;
 624         }
 625     }
 626
 627     return ret;
 628 }
 629
 630 static void
 631 SetIAPrivate(int *value)
 632 {
 633     ia_nice = *value;
 634 }
 635
 636 /*****************************************************************************
 637  * Various utility functions - in Xsun these lived in Xserver/os/process.c
 638  */
 639
 640 /* In Xsun we used the osPrivate in OsCommPtr, so this was SetOsPrivate. */
 641 static int
 642 SetClientPrivate(ClientPtr client, ConnectionPidPtr stuff, int length)
 643 {
 644     ClientProcessPtr    cpp;
 645     IAClientPrivatePtr priv;
 646
 647     priv = GetIAClient(client);
 648     if (priv == NULL) {
 649         IAInitClientPrivate(client);
 650     } else {
 651         FreeProcessList(priv);
 652     }
 653
 654     cpp = malloc(sizeof(ClientProcessRec));
 655
 656     if (cpp == NULL)
 657         return BadAlloc;
 658
 659     cpp->pids = malloc(sizeof(ConnectionPidRec)*length);
 660
 661     if (cpp->pids == NULL) {
 662         free(cpp);
 663         return BadAlloc;
 664     }
 665
 666     cpp->count = length;
 667     memcpy(cpp->pids, stuff, sizeof(ConnectionPidRec)*length);
 668     cpp->boosted = FALSE;
 669
 670     priv->process = cpp;
 671     return Success;
 672 }
 673
 674 static void
 675 FreeProcessList(IAClientPrivatePtr priv)
 676 {
 677     ClientProcessPtr    cpp = priv->process;
 678
 679     if (cpp == NULL)
 680         return;
 681     priv->process = NULL;
 682
 683     if (LastPids == cpp)
 684         LastPids = NULL;
 685
 686     if (cpp->pids != NULL)
 687         free(cpp->pids);
 688
 689     free(cpp);
 690 }
 691
 692 /*
 693   Check to see that all in current (a) are in last (b).
 694   And that a and b have the same number of members in the set.
 695 */
 696 static int
 697 PidSetEqual(ClientProcessPtr a, ClientProcessPtr b)
 698 {
 699     int aN, bN;
 700     int count = a->count;
 701     int retval = 1;
 702
 703     if (a->count != b->count) {
 704         return 0; /* definately NOT the same set */
 705     }
 706
 707     for (aN = 0; aN < count; aN++) {
 708         retval = 0;
 709         for (bN = 0; bN < count ; bN++) {
 710             if (a->pids[aN] == b->pids[bN]) {
 711                 retval = 1;
 712                 break;
 713             }
 714         }
 715         if (retval == 0)
 716             return retval;
 717     }
 718
 719     return retval;
 720 }
 721
 722
 723 /*****************************************************************************
 724  * Wrappers for normal procs - in Xsun we modified the original procs directly
 725  * in dix, but here we wrap them for a small performance loss but a large
 726  * increase in maintainability and ease of porting to new releases.
 727  */
 728
 729 static int
 730 IAProcSetInputFocus(ClientPtr client)
 731 {
 732     int res;
 733     Window focusID;
 734     WindowPtr focusWin;
 735     REQUEST(xSetInputFocusReq);
 736
 737     res = (*IASavedProcVector[X_SetInputFocus])(client);
 738     if ((res != Success) || (InteractiveOS != TRUE))
 739         return res;
 740
 741     focusID = stuff->focus;
 742
 743     switch (focusID) {
 744       case None:
 745         focusWin = NullWindow;
 746         break;
 747       case PointerRoot:
 748         focusWin = PointerRootWin;
 749         break;
 750       default:
 751         res = dixLookupWindow(&focusWin, focusID, client, DixReadAccess);
 752         if (res != Success)
 753             return res;
 754     }
 755
 756     if ((focusWin != NullWindow) && (focusWin != PointerRootWin)) {
 757         register ClientPtr requestee = wClient(focusWin);
 758         ChangePriority(requestee);
 759     }
 760
 761     return res;
 762 }
 763
 764 static int
 765 IAProcSendEvent(ClientPtr client)
 766 {
 767     int res;
 768     REQUEST(xSendEventReq);
 769
 770     res = (*IASavedProcVector[X_SendEvent])(client);
 771     if ((res != Success) || (InteractiveOS != TRUE))
 772         return res;
 773
 774     if ((InteractiveOS==TRUE) &&
 775         (GetIAClient(client)->wmgr == TRUE) &&
 776         (stuff->event.u.u.type == ClientMessage) &&
 777         (stuff->event.u.u.detail == 32) ) {
 778
 779         register ClientPtr requestee;
 780         WindowPtr pWin = NULL;
 781         DeviceIntPtr pPtr = PickPointer(client);
 782
 783         if (stuff->destination == PointerWindow)
 784             pWin = GetSpriteWindow(pPtr);
 785         else if (stuff->destination == InputFocus)
 786         {
 787             WindowPtr inputFocus = inputInfo.keyboard->focus->win;
 788
 789             if (inputFocus == NoneWin)
 790                 return Success;
 791
 792          /* If the input focus is PointerRootWin, send the event to where
 793             the pointer is if possible, then perhaps propogate up to root. */
 794             if (inputFocus == PointerRootWin)
 795                 inputFocus = GetCurrentRootWindow(pPtr);
 796
 797             if (IsParent(inputFocus, GetSpriteWindow(pPtr)))
 798                 pWin = GetSpriteWindow(pPtr);
 799             else
 800                 pWin = inputFocus;
 801         }
 802         else
 803         {
 804             res = dixLookupWindow(&pWin, stuff->destination, client,
 805                                   DixReadAccess);
 806             if (res != Success)
 807                 return res;
 808         }
 809
 810
 811         if (!pWin)
 812             return BadWindow;
 813
 814         requestee = wClient(pWin);
 815         ChangePriority(requestee);
 816     }
 817     return res;
 818 }
 819
 820 static Bool
 821 IAProcChangeWindowAttributes(ClientPtr client)
 822 {
 823     REQUEST(xChangeWindowAttributesReq);
 824
 825     if ((InteractiveOS==TRUE) && (stuff->valueMask & CWEventMask) &&
 826         (GetIAClient(client)->wmgr == FALSE) ) {
 827
 828         register XID *pVlist = (XID *) &stuff[1];
 829         register Mask tmask = stuff->valueMask;
 830         register Mask index2 = 0;
 831
 832         while (tmask) {
 833             index2 = (Mask) lowbit (tmask);
 834             tmask &= ~index2;
 835             if (index2 == CWEventMask) {
 836                 break;
 837             }
 838             pVlist++;
 839         }
 840
 841         if ((index2 == CWEventMask) && (*pVlist & SubstructureRedirectMask)) {
 842             IA_DEBUG(IA_DEBUG_BASIC,
 843                      ClientProcessPtr CurrentPids=GetConnectionPids(client);
 844
 845                      LogMessage(X_INFO,
 846                                 "SolarisIA: WindowManager detected (pid %d)\n",
 847                                 (CurrentPids && CurrentPids->pids) ?
 848                                  CurrentPids->pids[0] : -1));
 849
 850             GetIAClient(client)->wmgr = TRUE;
 851             ChangePriority(client);
 852             LastPids = NULL;
 853         }
 854     }
 855
 856     return (*IASavedProcVector[X_ChangeWindowAttributes])(client);
 857 }
 858
 859
 860 static int
 861 IAWrapProcVectors(void)
 862 {
 863     IASavedProcVector[X_SetInputFocus] = ProcVector[X_SetInputFocus];
 864     ProcVector[X_SetInputFocus] = IAProcSetInputFocus;
 865
 866     IASavedProcVector[X_SendEvent] = ProcVector[X_SendEvent];
 867     ProcVector[X_SendEvent] = IAProcSendEvent;
 868
 869     IASavedProcVector[X_ChangeWindowAttributes]
 870       = ProcVector[X_ChangeWindowAttributes];
 871     ProcVector[X_ChangeWindowAttributes] = IAProcChangeWindowAttributes;
 872
 873     return 0;
 874 }
 875
 876 static int
 877 IAUnwrapProcVectors(void)
 878 {
 879     ProcVector[X_SetInputFocus] = IASavedProcVector[X_SetInputFocus];
 880     ProcVector[X_SendEvent] = IASavedProcVector[X_SendEvent];
 881     ProcVector[X_ChangeWindowAttributes] = IASavedProcVector[X_ChangeWindowAttributes];
 882
 883     return 0;
 884 }
 885
 886