cde/programs/dtsession/SmGlobals.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* $TOG: SmGlobals.c /main/37 1998/10/26 17:21:18 mgreess $ */
  24 /*
  25  * (c) Copyright 1995 Digital Equipment Corporation.
  26  * (c) Copyright 1993, 1994, 1995 Hewlett-Packard Company
  27  * (c) Copyright 1993, 1994, 1995 International Business Machines Corp.
  28  * (c) Copyright 1993, 1994, 1995 Sun Microsystems, Inc.
  29  * (c) Copyright 1993, 1994, 1995 Novell, Inc.
  30  * (c) Copyright 1995 FUJITSU LIMITED.
  31  * (c) Copyright 1995 Hitachi.
  32  */
  33 /*************************************<+>*************************************
  34  *****************************************************************************
  35  **
  36  **  File:        SmGlobals.c
  37  **
  38  **  Project:     HP DT Session Manager (dtsession)
  39  **
  40  **  Description:
  41  **  -----------
  42  **  This file contains all routines in charge of managing all global
  43  **  variables used by the session manager.  These variables include
  44  **  mostly state and setting information.
  45  **
  46  **
  47  **
  48  *******************************************************************
  49  **  (c) Copyright Hewlett-Packard Company, 1990.  All rights are
  50  **  reserved.  Copying or other reproduction of this program
  51  **  except for archival purposes is prohibited without prior
  52  **  written consent of Hewlett-Packard Company.
  53  ********************************************************************
  54  **
  55  **
  56  **
  57  *****************************************************************************
  58  *************************************<+>*************************************/
  59 #include <stdio.h>
  60 #include <ctype.h>
  61 #include <sys/wait.h>
  62 #include <sys/types.h>
  63 #include <sys/utsname.h>
  64 #include <unistd.h>
  65 #ifdef __apollo
  66 #include <X11/apollosys.h>      /* for pid_t, in hp-ux sys/types.h */
  67 #endif
  68 #include <sys/stat.h>
  69 #include <sys/param.h>
  70 #include <X11/Intrinsic.h>
  71 #include <X11/Xutil.h>
  72 #include <X11/StringDefs.h>
  73 #include <Xm/Xm.h>
  74 #include <Dt/DtP.h>
  75 #include <Dt/SessionP.h>
  76 #include <Dt/Wsm.h>
  77 #include <Dt/WsmP.h>
  78 #include <Dt/UserMsg.h>
  79 #include <Dt/HourGlass.h>
  80 #include <Dt/SessionM.h>
  81 #include <Dt/EnvControlP.h>
  82 #include <Dt/Qualify.h>
  83 #include <Dt/MsgLog.h>
  84 #include "Sm.h"
  85 #include "SmResource.h"
  86 #include "SmError.h"
  87 #include "SmUI.h"
  88 #include "SmGlobals.h"
  89 #include "SmLock.h"
  90 #include "SmRestore.h"
  91 #include "SmProtocol.h"
  92 #include "SmXSMP.h"
  93
  94 /*
  95  * Internal Variable Declaraions
  96  */
  97 static char savedDir    [MAXPATHLEN];
  98 static char savedOldDir [MAXPATHLEN];
  99 static char savedTmpDir [MAXPATHLEN];
 100
 101 /*
 102  * Internal Function Declaraions
 103  */
 104
 105 static int SetSysDefaults( void ) ;
 106 static int SetResSet( void ) ;
 107 static void RemoveFiles( char *) ;
 108 static void TrimErrorlog(void);
 109
 110 static void _SmWaitClientTimeoutDefault (
 111         Widget widget,
 112        int offset,
 113        XrmValue *value);
 114
 115 static void _SmWaitWmTimeoutDefault (
 116         Widget widget,
 117         int offset,
 118         XrmValue *value);
 119
 120 void SmCvtStringToContManagement (
 121         XrmValue *args,
 122         Cardinal numArgs,
 123         XrmValue *fromVal,
 124         XrmValue *toVal);
 125
 126 unsigned char *_DtNextToken (
 127         unsigned char *pchIn,
 128         int *pLen,
 129         unsigned char **ppchNext);
 130
 131 Boolean _DtWmStringsAreEqual (
 132         unsigned char *pch1,
 133         unsigned char *pch2,
 134         int len);
 135
 136 static Boolean InitializeSpecificSession (
 137         char            *session_name,
 138         Display         *disp,
 139         unsigned int    argc,
 140         char            **argv);
 141
 142 static void InitializeGenericSession (
 143         Display         *disp);
 144
 145 static void InitializePaths (
 146         char            *session_option,
 147         Display         *disp);
 148
 149 static Boolean SetAlternateSession (
 150         char            * session_dir,
 151         char            * alt_dir,
 152         Boolean         make_dir);
 153
 154 /*
 155  * Global Data
 156  */
 157
 158 /*
 159  * These are the global structures used throughout dtsession
 160  * They are defined in Sm.h
 161  */
 162 SessionResources     smRes;
 163 SaverResources       smSaverRes;
 164 SettingsSet           smToSet;
 165 SettingsCust     smCust;
 166 SessionSettings      smSettings;
 167 GeneralData          smGD;
 168 char SM_SCREEN_SAVER_LOC [MAXPATHLEN + 1];
 169
 170 /*
 171  * Internal Global Data
 172  */
 173 static char     tmpDisplayName[MAXPATHLEN + 1];
 174 int machineType = 0;
 175
 176 static XtResource sessionResources[]=
 177 {
 178    {SmNwmStartup, SmCwmStartup, XtRString, sizeof(String),
 179         XtOffset(SessionResourcesPtr, wmStartup),
 180         XtRImmediate, (XtPointer) NULL},
 181    {SmNquerySettings, SmCquerySettings, XtRBoolean, sizeof(Boolean),
 182         XtOffset(SessionResourcesPtr, querySettings),
 183         XtRImmediate, (XtPointer) False},
 184    {SmNkeys, SmCkeys, XtRString, sizeof(String),
 185         XtOffset(SessionResourcesPtr, keyholders), XtRString, NULL},
 186    {SmNalarmTime, SmCalarmTime, XtRInt, sizeof(int),
 187         XtOffset(SessionResourcesPtr, alarmTime),
 188         XtRImmediate, (XtPointer) 10},
 189    {SmNmemThreshold, SmCmemThreshold, XtRInt, sizeof(int),
 190         XtOffset(SessionResourcesPtr, memThreshold),
 191         XtRImmediate, (XtPointer) 100},
 192    {SmNsessionVersion, SmCsessionVersion, XtRString, sizeof(String),
 193         XtOffset(SessionResourcesPtr, sessionVersion),
 194         XtRImmediate, (XtPointer) NULL},
 195    {SmNdisplayResolution, SmCdisplayResolution, XtRInt, sizeof(int),
 196         XtOffset(SessionResourcesPtr, displayResolution),
 197         XtRImmediate, (XtPointer) 0},
 198    {SmNsessionLang, SmCsessionLang, XtRString, sizeof(String),
 199         XtOffset(SessionResourcesPtr, sessionLang),
 200         XtRImmediate, (XtPointer) ""},
 201    {SmNcontManagement, SmCContManagement, SmRContManagement, sizeof(long),
 202         XtOffset(SessionResourcesPtr, contManagement),
 203         XtRImmediate, (XtPointer) (SM_CM_DEFAULT)},
 204    {SmNwaitClientTimeout, SmCWaitClientTimeout, XtRInt, sizeof(int),
 205         XtOffset(SessionResourcesPtr, waitClientTimeout),
 206         XtRCallProc, (XtPointer)_SmWaitClientTimeoutDefault },
 207    {SmNwaitWmTimeout, SmCWaitWmTimeout, XtRInt, sizeof(int),
 208         XtOffset(SessionResourcesPtr, waitWmTimeout),
 209         XtRCallProc, (XtPointer)_SmWaitWmTimeoutDefault },
 210    {SmNuseMessaging, SmCUseMessaging, XtRBoolean, sizeof(Boolean),
 211         XtOffset(SessionResourcesPtr, useBMS),
 212         XtRImmediate, (XtPointer) True},
 213    {SmNsaveFontPath, SmCsaveFontPath, XtRBoolean, sizeof(Boolean),
 214         XtOffset(SessionResourcesPtr, saveFontPath),
 215         XtRImmediate, (XtPointer) False},
 216    {SmNsaveYourselfTimeout, SmCsaveYourselfTimeout, XtRInt, sizeof(int),
 217         XtOffset(SessionResourcesPtr, saveYourselfTimeout),
 218         XtRImmediate, (XtPointer) 5},
 219    {SmNnumSessionsBackedup, SmCnumSessionsBackedup, XtRInt, sizeof(int),
 220         XtOffset(SessionResourcesPtr, numSessionsBackedup),
 221         XtRImmediate, (XtPointer) DEFAULT_NUM_SESSIONS_BACKED_UP},
 222    {SmNignoreEnvironment, SmCignoreEnvironment, XtRString, sizeof(String),
 223         XtOffset(SessionResourcesPtr, ignoreEnvironment),
 224         XtRImmediate, (XtPointer) NULL},
 225 #if defined(USE_XINERAMA)       /* JET - Xinerama */
 226    {SmNxineramaPreferredScreen, SmCxineramaPreferredScreen, XtRInt, sizeof(int),
 227         XtOffset(SessionResourcesPtr, xineramaPreferredScreen),
 228         XtRImmediate, (XtPointer) 0},
 229 #endif
 230
 231 }
 232 ;
 233
 234
 235 static XtResource saverResources[]=
 236 {
 237    {SmNcycleTimeout, SmCcycleTimeout, XtRInt, sizeof(int),
 238         XtOffset(SaverResourcesPtr, cycleTimeout),
 239         XtRImmediate, (XtPointer) -1},
 240    {SmNlockTimeout, SmClockTimeout, XtRInt, sizeof(int),
 241         XtOffset(SaverResourcesPtr, lockTimeout),
 242         XtRImmediate, (XtPointer) -1},
 243    {SmNsaverTimeout, SmCsaverTimeout, XtRInt, sizeof(int),
 244         XtOffset(SaverResourcesPtr, saverTimeout),
 245         XtRImmediate, (XtPointer) -1},
 246    {SmNrandom, SmCrandom, XtRBoolean, sizeof(Boolean),
 247         XtOffset(SaverResourcesPtr, random),
 248         XtRImmediate, (XtPointer) False},
 249    {SmNsaverList, SmCsaverList, XtRString, sizeof(String),
 250         XtOffset(SaverResourcesPtr, saverList),
 251         XtRImmediate, (XtPointer) ""},
 252
 253 }
 254 ;
 255
 256
 257
 258 /*
 259  * Machine specific defaults.
 260  */
 261  static struct
 262  {
 263    int machineType;
 264    int clientTimeout;
 265    int wmTimeout;
 266  }
 267  machineDefault[] =
 268  {
 269    {  0,  20,  60},               /* Machine independent default */
 270 #ifdef __hpux
 271    {300,  10,  60},               /* HP s300                     */
 272    {400,  10,  60},               /* HP s400                     */
 273    {600,   5,  60},               /* HP s600                     */
 274    {700,   5,  60},               /* HP s700                     */
 275    {800,   5,  60},               /* HP s800                     */
 276 #endif /* __hpux */
 277  };
 278  #define MACHINEDEFAULTS (sizeof(machineDefault) / sizeof(machineDefault[0]))
 279
 280 \f
 281 /*************************************<->*************************************
 282  *
 283  *  _SmWaitClientTimeoutDefault (widget, offset, value)
 284  *
 285  *
 286  *  Description:
 287  *  -----------
 288  *  This function generates a default value for the waitClientTimeout resource.
 289  *  We dynamically default to 10 seconds for s400/s300 and to
 290  *  5 seconds for s700/s800.
 291  *
 292  *  Inputs:
 293  *  ------
 294  *  widget = this is not used
 295  *
 296  *  offset = this is the resource offset
 297  *
 298  *  value = this is a pointer to a XrmValue in which to store the result
 299  *
 300  *  Outputs:
 301  *  -------
 302  *  value = default resource value and size
 303  *
 304  *************************************<->***********************************/
 305 static
 306 void
 307 _SmWaitClientTimeoutDefault (Widget widget, int offset, XrmValue *value)
 308 {
 309     int i;
 310
 311     for (i = 0; i < MACHINEDEFAULTS; i++)
 312     {
 313       if (machineDefault[i].machineType == machineType)
 314       {
 315         break;
 316       }
 317     }
 318
 319     if (i == MACHINEDEFAULTS)
 320     {
 321       i = 0;
 322     }
 323
 324     value->addr = (char *)&machineDefault[i].clientTimeout;
 325     value->size = sizeof (int);
 326
 327 } /* END OF FUNCTION _SmWaitClientTimeoutDefault */
 328
 329
 330 \f
 331 /*************************************<->*************************************
 332  *
 333  *  _SmWaitWmTimeoutDefault (widget, offset, value)
 334  *
 335  *
 336  *  Description:
 337  *  -----------
 338  *  This function generates a default value for the waitWmTimeout resource.
 339  *  We dynamically default to 60 seconds for s400/s300 and to
 340  *  60 seconds for s700/s800.  This could change if we get feedback indicating
 341  *  the need for a new default.
 342  *
 343  *  Inputs:
 344  *  ------
 345  *  widget = this is not used
 346  *
 347  *  offset = this is the resource offset
 348  *
 349  *  value = this is a pointer to a XrmValue in which to store the result
 350  *
 351  *  Outputs:
 352  *  -------
 353  *  value = default resource value and size
 354  *
 355  *************************************<->***********************************/
 356 static
 357 void
 358 _SmWaitWmTimeoutDefault (Widget widget, int offset, XrmValue *value)
 359 {
 360     int i;
 361
 362     smGD.userSetWaitWmTimeout = False; /* if we are here, it is not user set */
 363
 364     for (i = 0; i < MACHINEDEFAULTS; i++)
 365     {
 366       if (machineDefault[i].machineType == machineType)
 367       {
 368         break;
 369       }
 370     }
 371
 372     if (i == MACHINEDEFAULTS)
 373     {
 374       i = 0;
 375     }
 376
 377     value->addr = (char *)&machineDefault[i].wmTimeout;
 378     value->size = sizeof (int);
 379
 380 } /* END OF FUNCTION _SmWaitWmTimeoutDefault */
 381
 382
 383 \f
 384 /*************************************<->*************************************
 385  *
 386  *  InitSMGlobals ()
 387  *
 388  *
 389  *  Description:
 390  *  -----------
 391  *  Sets SM global resources and global settings to a starting value.
 392  *
 393  *
 394  *  Inputs:
 395  *  ------
 396  *  buttonForm = form widget for button that allows cursor to get colors
 397  *  smRes(global) = structure that holds session resources.
 398  *  smToSet(global) = structure that holds "which settings to set and how" info
 399  *  smGD(global) = structure that holds general data info
 400  *
 401  *  Outputs:
 402  *  -------
 403  *  smRes(global) = structure that holds session resources.
 404  *  smToSet(global) = structure that holds "which settings to set and how" info
 405  *  smGD(global) = structure that holds general data info
 406  *
 407  *  Comments:
 408  *  --------
 409  *  Resources are set to an initial value by the resource manager.  The
 410  *  rest are set in the routine.
 411  *
 412  *************************************<->***********************************/
 413 void
 414 InitSMGlobals( void )
 415 {
 416     int i;
 417     PropDtSmWindowInfo property;
 418     struct utsname nameRec;
 419     char *firstSlash;
 420     char *keyNum;
 421
 422     smGD.userSetWaitWmTimeout = True; /* assume it is */
 423
 424 #ifdef __hpux
 425     if (uname(&nameRec) == 0)
 426     {
 427         keyNum = nameRec.machine;
 428         if (firstSlash = strchr(keyNum, '/'))
 429         {
 430             keyNum = ++firstSlash;
 431
 432             if (     keyNum[0] == '3')
 433             {
 434                 machineType = 300;
 435             }
 436             else if (keyNum[0] == '4')
 437             {
 438                 machineType = 400;
 439             }
 440             else if (keyNum[0] == '6')
 441             {
 442                 machineType = 600;
 443             }
 444             else if (keyNum[0] == '7')
 445             {
 446                 machineType = 700;
 447             }
 448             else if (keyNum[0] == '8')
 449             {
 450                 machineType = 800;
 451             }
 452         }
 453     }
 454 #endif /* __hpux */
 455
 456     /*
 457      * Get application specific resource values
 458      */
 459     XtAppAddConverter (smGD.appCon, XtRString, SmRContManagement,
 460                        (XtConverter)SmCvtStringToContManagement, NULL, 0);
 461     XtGetApplicationResources(smGD.topLevelWid, (XtPointer) &smRes,
 462                               sessionResources,
 463                               XtNumber(sessionResources), NULL, 0);
 464
 465     if (smGD.lockOnTimeoutStatus == True)
 466     {
 467      /*
 468       * Pull screen saver resources from Dtsession*extension.<name>.
 469       */
 470       smGD.SmNextension = "extension";
 471       smGD.SmCextension = "Extension";
 472       smGD.extensionSpec = "extension.";
 473     }
 474     else
 475     {
 476      /*
 477       * Pull screen saver resources from Dtsession*<name>.
 478       */
 479       smGD.SmNextension = smGD.SmCextension = smGD.extensionSpec = "";
 480     }
 481
 482     XtGetSubresources(smGD.topLevelWid, (XtPointer) &smSaverRes,
 483                       smGD.SmNextension, smGD.SmCextension,
 484                       saverResources,
 485                       XtNumber(saverResources), NULL, 0);
 486
 487     smGD.wmStartup = SmNewString(smRes.wmStartup);
 488     smGD.keyholders = SmNewString(smRes.keyholders);
 489     smGD.sessionLang = SmNewString(smRes.sessionLang);
 490     smGD.saverList = SmNewString(smSaverRes.saverList);
 491
 492     /*
 493      * Initialize general data used by apps not initialized by
 494      * XtInitialize or DtInitialize
 495      */
 496     smGD.topLevelWindow = XtWindow(smGD.topLevelWid);
 497     smGD.numSavedScreens = (ScreenCount(smGD.display) > MAX_SCREENS_SAVED)
 498          ? MAX_SCREENS_SAVED : ScreenCount(smGD.display);
 499     smGD.dtwmRunning = False;
 500     smSettings.confirmMode = DtSM_VERBOSE_MODE;
 501     if (smGD.sessionType == CURRENT_SESSION ||
 502         smGD.sessionType == DEFAULT_SESSION)
 503         smSettings.startState = DtSM_CURRENT_STATE;
 504     else
 505         smSettings.startState = DtSM_HOME_STATE;
 506     smGD.homeSave = False;
 507     smGD.saverListParse = NULL;
 508
 509     smGD.loggingOut = False;
 510
 511     /*
 512      * Sanity check on timeouts for negative numbers
 513      */
 514     if (smRes.waitClientTimeout < 0)
 515     {
 516         smRes.waitClientTimeout = -smRes.waitClientTimeout;
 517     }
 518     if (smRes.waitWmTimeout < 0)
 519     {
 520         smRes.waitWmTimeout = -smRes.waitWmTimeout;
 521     }
 522     if (smRes.saveYourselfTimeout < 0)
 523     {
 524         smRes.saveYourselfTimeout = -smRes.saveYourselfTimeout;
 525     }
 526
 527
 528     /*
 529      * Now convert users view of seconds in to XtAppAddTimout's
 530      * need for milliseconds.
 531      */
 532     smRes.waitClientTimeout = 1000 * smRes.waitClientTimeout;
 533     smRes.waitWmTimeout = 1000 * smRes.waitWmTimeout;
 534     smRes.saveYourselfTimeout = 1000 * smRes.saveYourselfTimeout;
 535     smGD.savedWaitWmTimeout = smRes.waitWmTimeout;
 536
 537     /*
 538      * Initialize lock data
 539      */
 540     smGD.screen = XDefaultScreen(smGD.display);
 541     smGD.blackPixel = XBlackPixel(smGD.display, smGD.screen);
 542     smGD.whitePixel = XWhitePixel(smGD.display, smGD.screen);
 543     smDD.lockDialog = NULL;
 544     smDD.lockCoverDialog = NULL;
 545     for(i = 0;i < smGD.numSavedScreens;i++)
 546     {
 547         smDD.coverDialog[i] = NULL;
 548         smDD.coverDrawing[i] = NULL;
 549     }
 550     smGD.lockedState = UNLOCKED;
 551
 552    /*
 553     * Sanity check screen saver resource values.
 554     */
 555     if (smRes.alarmTime < 0) smRes.alarmTime = 0;
 556
 557     #define SMBOUND(A) (A < 0 ? 0 : A)
 558
 559     smSaverRes.lockTimeout = SMBOUND(smSaverRes.lockTimeout) * 60;
 560     smSaverRes.saverTimeout = SMBOUND(smSaverRes.saverTimeout) * 60;
 561     smSaverRes.cycleTimeout = SMBOUND(smSaverRes.cycleTimeout) * 60;
 562
 563     CreateLockCursor();
 564     smGD.waitCursor = _DtGetHourGlassCursor(smGD.display);
 565
 566     /*
 567      * Initialize other global data related to dialogs
 568      */
 569     smDD.confExit = NULL;
 570     smDD.qExit = NULL;
 571     smDD.compatExit = NULL;
 572     smDD.deadWid = NULL;
 573     smDD.saveSession = NULL;            /* Error dialog for Save_Session */
 574
 575     if (!smDD.smHelpDialog)
 576         /*
 577          * Don't wipe it out if it is already created
 578          */
 579         smDD.smHelpDialog = NULL;
 580
 581     /*
 582      * Intern all the atoms needed for the WSM communication
 583      */
 584     {
 585       enum { XA_DT_SM_WINDOW_INFO, XA_DT_SM_WM_PROTOCOL,
 586              XA_DT_SM_START_ACK_WINDOWS, XA_DT_SM_STOP_ACK_WINDOWS,
 587              XA_DT_WM_WINDOW_ACK, XA_DT_WM_EXIT_SESSION,
 588              XA_DT_WM_LOCK_DISPLAY, XA_DT_WM_READY, NUM_ATOMS };
 589       static char *atom_names[] = {
 590              _XA_DT_SM_WINDOW_INFO, _XA_DT_SM_WM_PROTOCOL,
 591              _XA_DT_SM_START_ACK_WINDOWS, _XA_DT_SM_STOP_ACK_WINDOWS,
 592              _XA_DT_WM_WINDOW_ACK, _XA_DT_WM_EXIT_SESSION,
 593              _XA_DT_WM_LOCK_DISPLAY, _XA_DT_WM_READY };
 594
 595       Atom atoms[XtNumber(atom_names)];
 596
 597       XInternAtoms(smGD.display, atom_names, XtNumber(atom_names),
 598                    False, atoms);
 599
 600       XaVsmInfo = atoms[XA_DT_SM_WINDOW_INFO];
 601       XaSmWmProtocol = atoms[XA_DT_SM_WM_PROTOCOL];
 602       XaSmStartAckWindow = atoms[XA_DT_SM_START_ACK_WINDOWS];
 603       XaSmStopAckWindow = atoms[XA_DT_SM_STOP_ACK_WINDOWS];
 604       XaWmWindowAck = atoms[XA_DT_WM_WINDOW_ACK];
 605       XaWmExitSession = atoms[XA_DT_WM_EXIT_SESSION];
 606       XaWmLockDisplay = atoms[XA_DT_WM_LOCK_DISPLAY];
 607       XaWmReady = atoms[XA_DT_WM_READY];
 608     }
 609
 610     /*
 611      * Set the session manager window property on the root window
 612      */
 613     property.flags = 0;
 614     property.smWindow = (unsigned long) smGD.topLevelWindow;
 615     XChangeProperty (smGD.display, RootWindow(smGD.display, 0),
 616                      XaVsmInfo, XaVsmInfo,
 617                      32, PropModeReplace, (unsigned char *)&property,
 618                      PROP_DT_SM_WINDOW_INFO_ELEMENTS);
 619
 620     /*
 621      * Set up the signal handler for forking and execing
 622      */
 623     sigaction(SIGCHLD, &smGD.childvec, (struct sigaction *) NULL);
 624 }
 625
 626
 627 \f
 628 /*************************************<->*************************************
 629  *
 630  *  SetRestorePath ()
 631  *
 632  *
 633  *  Description:
 634  *  -----------
 635  *  Sets SM global resources and global settings to a starting value.
 636  *
 637  *
 638  *  Inputs:
 639  *  ------
 640  *  smGD.display = display structure for session manager.  Used to construct
 641  *                     a display directory
 642  *
 643  *  Outputs:
 644  *  -------
 645  *  smGD.resourcePath(global) = Path where the resources to be restored are
 646  *                              held
 647  *  smGD.settingPath(global) = Path where the settings to be restored are
 648  *                              held
 649  *  smGD.clientPath(global) = Path where the clients to be restored are
 650  *                              held
 651  *  smGD.savePath(global) = Path where all save files are to be saved
 652  *
 653  *  Return:
 654  *  ------
 655  *  Display connection
 656  *
 657  *  Comments:
 658  *  --------
 659  *  WARNING:  This routine also determines whether dtsession is being started
 660  *            in compatibility mode.  If so - no restore paths are set up and
 661  *            the routine is exited.
 662  *
 663  *************************************<->***********************************/
 664 int
 665 SetRestorePath(
 666         unsigned int argc,
 667         char *argv[] )
 668 {
 669     Display  *tmpDisplay;
 670     int         i;
 671     char        *displayName = NULL;
 672     char        *session_option = NULL;
 673
 674     smGD.compatMode = False;
 675
 676     for(i = 0;i < argc;i++)
 677     {
 678         if(!strcmp(argv[i], "-display"))
 679         {
 680             displayName = argv[i + 1];
 681             /*
 682              * If -display is used but DISPLAY is not set,
 683              * put DISPLAY into the environment
 684              */
 685             if (getenv("DISPLAY") == 0)
 686             {
 687                 snprintf(tmpDisplayName, MAXPATHLEN, "DISPLAY=%s", displayName);
 688                 putenv(tmpDisplayName);
 689             }
 690         }
 691
 692         if(!strcmp(argv[i], "-norestore"))
 693         {
 694             smGD.compatMode = True;
 695         }
 696
 697         if(!strcmp(argv[i], "-session"))
 698         {
 699             i++;
 700             if (i >= argc)
 701             {
 702                 char            *pch;
 703
 704                 pch = strdup ((char *) GETMESSAGE (40, 15,
 705                         " No session name was provided for the -session command line option."));
 706                 if (pch)
 707                 {
 708                     DtMsgLogMessage (argv[0], DtMsgLogWarning, pch);
 709                     free (pch);
 710                 }
 711                 break;
 712             }
 713             session_option = argv[i];
 714         }
 715     }
 716
 717     /*
 718      *  If we are in compatibility mode - no restore paths are set
 719      *  up and we just return
 720      */
 721     if(smGD.compatMode == True)
 722     {
 723         smGD.clientPath[0] = 0;
 724         smGD.resourcePath[0] = 0;
 725         smGD.settingPath[0] = 0;
 726         smGD.sessionType = DEFAULT_SESSION;
 727         smGD.restoreSession = NULL;
 728         return(0);
 729     }
 730
 731     tmpDisplay = XOpenDisplay(displayName);
 732     if(tmpDisplay == NULL)
 733     {
 734         PrintError(DtError, GETMESSAGE(4, 1, "Invalid display name - exiting."));
 735         SM_EXIT(-1);
 736     }
 737
 738     if (session_option)
 739     {
 740         if (!InitializeSpecificSession (session_option, tmpDisplay, argc, argv))
 741                 InitializeGenericSession (tmpDisplay);
 742     }
 743     else
 744         InitializeGenericSession (tmpDisplay);
 745
 746     /*
 747      * Need to know if the session is for a specific display
 748      */
 749     smGD.displaySpecific = True;
 750     if (session_option = strrchr (smGD.savePath, '/'))
 751     {
 752         session_option++;
 753         if (!strcmp (session_option, DtSM_SESSION_DIRECTORY))
 754             smGD.displaySpecific = False;
 755     }
 756
 757     TrimErrorlog();
 758     XCloseDisplay(tmpDisplay);
 759
 760     /*
 761     ** User's session startup script:
 762     **   $HOME/.dt/sessions/sessionetc
 763     */
 764     strcpy(smGD.etcPath, smGD.savePath);
 765     strcat(smGD.etcPath, "/");
 766     strcat(smGD.etcPath, smEtcFile);
 767
 768     /*
 769     ** User's session shutdown script:
 770     **   $HOME/.dt/sessions/sessionexit
 771     */
 772     strcpy(smGD.exitPath, smGD.savePath);
 773     strcat(smGD.exitPath, "/");
 774     strcat(smGD.exitPath, smExitFile);
 775
 776     return(0);
 777 }
 778
 779 void
 780 FixPath
 781     (
 782     char * the1stPath
 783     )
 784 {
 785     char * tempPath;
 786     char * pathList = (char *)XtMalloc(strlen(SM_SYSTEM_PATH) +
 787                          strlen(":" CDE_INSTALLATION_TOP "/config") + 1);
 788
 789     strcpy(pathList,SM_SYSTEM_PATH);
 790     strcat(pathList,":" CDE_INSTALLATION_TOP "/config");
 791
 792     tempPath = _DtQualifyWithFirst(the1stPath,pathList);
 793     if (tempPath != NULL) {
 794         strcpy(the1stPath,tempPath);
 795         free(tempPath);
 796     }
 797
 798     XtFree(pathList);
 799 }
 800
 801 \f
 802 /*************************************<->*************************************
 803  *
 804  *  SetSysDefaults ()
 805  *
 806  *
 807  *  Description:
 808  *  -----------
 809  *  Sets the path to restore the system default files. A convenience routine
 810  *
 811  *
 812  *  Inputs:
 813  *  ------
 814  *  smGD.savePath = path that files are to be saved in (set up in
 815  *                      SetRestorePaths)
 816  *
 817  *  Outputs:
 818  *  -------
 819  *  smGD.resourcePath(global) = Path where the resources to be saved are
 820  *                              to be saved.
 821  *  smGD.settingPath(global) = Path where the settings to be saved are
 822  *                              to be saved.
 823  *  smGD.clientPath(global) = Path where the clients to be saved are
 824  *                              to be saved.
 825  *
 826  *  Comments:
 827  *  --------
 828  *
 829  *************************************<->***********************************/
 830 static int
 831 SetSysDefaults( void )
 832 {
 833     int status;
 834     struct stat buf;
 835     String tmpString;
 836     char        *langSpec;
 837     char        *tempPath;
 838
 839     /*
 840      * No files exist for restoration - use the
 841      * system defaults
 842      */
 843     strcpy(smGD.resourcePath, "");
 844     strcpy(smGD.clientPath, "");
 845     smGD.settingPath[0] = 0;
 846     smGD.sessionType = DEFAULT_SESSION;
 847     smGD.restoreSession = (char *) SM_SYSTEM_DIRECTORY;
 848
 849     langSpec = getenv("LANG");
 850     if ((langSpec != NULL) && (*langSpec != 0))
 851     {
 852         strcat(smGD.clientPath, "/");
 853         strncat(smGD.clientPath, langSpec, MAXPATHLEN-2);
 854         smGD.clientPath[MAXPATHLEN-1] = 0;
 855     }
 856
 857     strcat(smGD.clientPath, "/");
 858     strcat(smGD.clientPath, SM_SYSTEM_CLIENT_FILE);
 859
 860     FixPath(smGD.clientPath);
 861
 862     /*
 863      * If the system files don't exist - we're in
 864      * trouble - First try LANG location then default
 865      */
 866     status = stat(smGD.clientPath, &buf);
 867     if(status == -1)
 868     {
 869         if((langSpec == NULL) || (*langSpec == 0))
 870         {
 871             PrintErrnoError(DtError, GETMESSAGE(4, 2,
 872                         "No defaults files exist.  "
 873                         "No applications will be restarted."));
 874             smGD.clientPath[0] = 0;
 875             smGD.resourcePath[0] = 0;
 876         }
 877         else
 878         {
 879             strcpy(smGD.clientPath, "/C/");
 880             strcat(smGD.clientPath, SM_SYSTEM_CLIENT_FILE);
 881
 882             FixPath(smGD.clientPath);
 883
 884             status = stat(smGD.clientPath, &buf);
 885             if(status == -1)
 886             {
 887                 PrintErrnoError(DtError, GETMESSAGE(4, 3,
 888                             "No defaults files exist.  "
 889                             "No applications will be restarted."));
 890                 smGD.clientPath[0] = 0;
 891                 smGD.resourcePath[0] = 0;
 892             }
 893         }
 894     }
 895
 896     return(0);
 897 }
 898
 899
 900 \f
 901 /*************************************<->*************************************
 902  *
 903  *  SetResSet ()
 904  *
 905  *
 906  *  Description:
 907  *  -----------
 908  *  Sets the path to restore the settings and resource files.
 909  *  A convenience routine
 910  *
 911  *
 912  *  Inputs:
 913  *  ------
 914  *  smGD.savePath = path that files are to be saved in (set up in
 915  *                      SetRestorePaths)
 916  *
 917  *  Outputs:
 918  *  -------
 919  *  smGD.resourcePath(global) = Path where the resources to be saved are
 920  *                              to be saved.
 921  *  smGD.settingPath(global) = Path where the settings to be saved are
 922  *                              to be saved.
 923  *  smGD.clientPath(global) = Path where the clients to be saved are
 924  *                              to be saved.
 925  *
 926  *  Comments:
 927  *  --------
 928  *
 929  *************************************<->***********************************/
 930 static int
 931 SetResSet( void )
 932 {
 933     int status;
 934     struct stat buf;
 935
 936     /*
 937      * If resource or settings file does not exist - just null out
 938      * the path so these things will not get restored
 939      */
 940     status = stat(smGD.resourcePath, &buf);
 941     if(status == -1)
 942     {
 943         smGD.resourcePath[0] = 0;
 944     }
 945
 946     status = stat(smGD.settingPath, &buf);
 947     if(status == -1)
 948     {
 949         smGD.settingPath[0] = 0;
 950     }
 951     return(0);
 952 }
 953
 954
 955 /*************************************<->*************************************
 956  *
 957  *  UndoSetSavePath () - Undoes the directory manipulations done by
 958  *      SetSavePath.  This function is only called if a shutdown/save
 959  *      is canceled.
 960  *
 961  *************************************<->***********************************/
 962 void
 963 UndoSetSavePath ( )
 964 {
 965         char                    * buf;
 966
 967         if (strcmp ("", savedDir)) {
 968
 969                 /*
 970                  * Remove the directory where the save occurred, e.g.:
 971                  *
 972                  *    ~/.dt/<session_dir>/current
 973                  *    ~/.dt/<session_dir>/home
 974                  */
 975                 buf = XtMalloc (strlen (savedDir) + 9);
 976                 sprintf (buf, "rm -rf %s", savedDir);
 977                 SystemCmd (buf);
 978                 XtFree (buf);
 979
 980                 if (strcmp ("", savedOldDir)) {
 981
 982                         MoveDirectory (savedOldDir, savedDir, False);
 983
 984                         if (strcmp ("", savedTmpDir)) {
 985                                 MoveDirectory (savedTmpDir, savedOldDir, False);
 986                         }
 987                 }
 988         }
 989 }
 990
 991 \f
 992 /*************************************<->*************************************
 993  *
 994  *  SetSavePath (saveToHome, mode)
 995  *
 996  *
 997  *  Description:
 998  *  -----------
 999  *  Sets up paths for files that need to be saved.  Also removes any files
1000  *  that shouldn't be there after the save.
1001  *
1002  *
1003  *  Inputs:
1004  *  ------
1005  *  smGD.display = display structure for session manager.  Used to construct
1006  *                     a display directory
1007  *  saveToHome = whether this is a save to home session or not
1008  *  mode = whether we are resetting or restarting
1009  *
1010  *  Outputs:
1011  *  -------
1012  *  smGD.resourcePath(global) = Path where the resources to be saved are
1013  *                              to be saved.
1014  *  smGD.settingPath(global) = Path where the settings to be saved are
1015  *                              to be saved.
1016  *  smGD.clientPath(global) = Path where the clients to be saved are
1017  *                              to be saved.
1018  *
1019  *  Comments:
1020  *  --------
1021  *
1022  *************************************<->***********************************/
1023 int
1024 SetSavePath(
1025         Boolean saveToHome,
1026         int mode )
1027 {
1028     struct stat         buf;
1029     int                 status;
1030
1031     /*
1032      * These directory paths are needed in UndoSetSavePaths
1033      * if a shutdown/save is canceled.
1034      */
1035     strcpy (savedDir, "");
1036     strcpy (savedOldDir, "");
1037     strcpy (savedTmpDir, "");
1038
1039     /*
1040      * Make sure the user hasn't done something like delete the .dt
1041      * directories during the session.  If so - recreate them
1042      */
1043     SM_FREE(smGD.savePath);
1044     smGD.savePath = _DtCreateDtDirs(smGD.display);
1045     if(smGD.savePath == NULL)
1046     {
1047         PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1048         smGD.clientPath[0] = 0;
1049         smGD.settingPath[0] = 0;
1050         smGD.resourcePath[0] = 0;
1051         return(-1);
1052     }
1053
1054
1055     /*
1056      * Path for a save defaults to save the current session.
1057      * Otherwise just remove the directories
1058      */
1059     strcpy(smGD.clientPath, smGD.savePath);
1060     strcpy(smGD.settingPath, smGD.savePath);
1061     strcpy(smGD.resourcePath, smGD.savePath);
1062     strcat(smGD.clientPath, "/");
1063     strcat(smGD.settingPath, "/");
1064     strcat(smGD.resourcePath, "/");
1065
1066     if(saveToHome == False)
1067     {
1068         strcat(smGD.clientPath, SM_CURRENT_DIRECTORY);
1069         strcat(smGD.resourcePath, SM_CURRENT_DIRECTORY);
1070         strcat(smGD.settingPath, SM_CURRENT_DIRECTORY);
1071         smGD.restoreSession = SM_CURRENT_DIRECTORY;
1072     }
1073     else
1074     {
1075         strcat(smGD.clientPath, SM_HOME_DIRECTORY);
1076         strcat(smGD.resourcePath, SM_HOME_DIRECTORY);
1077         strcat(smGD.settingPath, SM_HOME_DIRECTORY);
1078         smGD.restoreSession = SM_HOME_DIRECTORY;
1079     }
1080
1081     if ((mode == DtSM_HOME_STATE) && (saveToHome == False) &&
1082        (smSettings.startState == DtSM_HOME_STATE))
1083     {
1084         /*
1085          * The only time this should should be true is if the
1086          * current session is a Home session and the session
1087          * is being exited.  The idea is that if a "current"
1088          * directory exits, it must be moved because when the
1089          * user next logs in, a Home session should be started
1090          * (if a session is not selected at the login screen)
1091          * and the Session Manager decides whether or not it
1092          * starts a Home or Current session based on if a
1093          * "current" directory exists.  If a "current" directory
1094          * exists, a Current session will be started.
1095          */
1096         status = stat(smGD.clientPath, &buf);
1097         if(status != -1)
1098         {
1099             /*
1100              * The "current" directory exists and must be moved to its
1101              * ".old" version.  But first, if the ".old" version exists,
1102              * it must be moved to a temporary directory.  This temporary
1103              * directory will eventually be pruned - when a user next
1104              * runs a Current session and saves the session.
1105              */
1106             strcpy (savedDir, smGD.clientPath);
1107             sprintf(smGD.etcPath, "%s.%s", smGD.clientPath, SM_OLD_EXTENSION);
1108             status = stat(smGD.etcPath, &buf);
1109             if(status == 0)
1110             {
1111                 char            * tmpName;
1112                 int len, tfd;
1113
1114                 strcpy(savedOldDir, smGD.etcPath);
1115
1116                 len = strlen(smGD.restoreSession) + strlen("XXXXXX") + 2;
1117                 tmpName = (char *) XtCalloc(1, len);
1118
1119                 sprintf(tmpName, "%s.XXXXXX", smGD.restoreSession);
1120                 if ((tfd = mkstemp(tmpName)) == -1)
1121                   {
1122                     PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1123                   }
1124                 else
1125                   {
1126                     close(tfd);
1127                     unlink(tmpName);
1128
1129                     MoveDirectory(smGD.etcPath, tmpName, False);
1130
1131                     strncpy(savedTmpDir, tmpName, len - 1);
1132                   }
1133                 XtFree((char *) tmpName);
1134             }
1135             MoveDirectory(smGD.clientPath, smGD.etcPath, False);
1136         }
1137
1138         smGD.clientPath[0] = 0;
1139         smGD.settingPath[0] = 0;
1140         smGD.resourcePath[0] = 0;
1141     }
1142     else
1143     {
1144         strcpy (savedDir, smGD.clientPath);
1145
1146         /*
1147          * If the desired directory doesn't exist, create it.
1148          */
1149         status = stat(smGD.clientPath, &buf);
1150         if(status == -1)
1151         {
1152             status = mkdir(smGD.clientPath, 0000);
1153             if(status == -1)
1154             {
1155                 PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1156                 smGD.clientPath[0] = 0;
1157                 smGD.settingPath[0] = 0;
1158                 smGD.resourcePath[0] = 0;
1159                 return(-1);
1160             }
1161             chmod(smGD.clientPath, 0755);
1162         }
1163         else
1164         {
1165             /*
1166              * The desired directory already exists so it must
1167              * be archived by moving it to its ".old" version. But
1168              * first, if its ".old" version already exists, it must
1169              * be moved to a temporary directory that will be removed
1170              * when the session directories are pruned - after the
1171              * save is complete.
1172              */
1173             char                * tmpName;
1174
1175             sprintf(smGD.etcPath, "%s.%s", smGD.clientPath, SM_OLD_EXTENSION);
1176             status = stat(smGD.etcPath, &buf);
1177             if(status == 0)
1178             {
1179               int len, tfd;
1180
1181               len = strlen(smGD.restoreSession) + strlen("XXXXXX") + 2;
1182               tmpName = (char *) XtCalloc(1, len);
1183               sprintf(tmpName, "%s.XXXXXX", smGD.restoreSession);
1184
1185               strcpy (savedOldDir, smGD.etcPath);
1186
1187               if ((tfd = mkstemp(tmpName)) == -1)
1188                 {
1189                   PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1190                 }
1191               else
1192                 {
1193                   close(tfd);
1194                   unlink(tmpName);
1195
1196                   MoveDirectory (smGD.etcPath, tmpName, False);
1197
1198                   strcpy (savedTmpDir, tmpName);
1199                 }
1200               XtFree((char *) tmpName);
1201             }
1202
1203             MoveDirectory(smGD.clientPath, smGD.etcPath, False);
1204
1205             /*
1206              * Now re-make the directory
1207              */
1208                status = mkdir(smGD.clientPath, 0000);
1209                if(status == -1)
1210                {
1211                  PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1212                  smGD.clientPath[0] = 0;
1213                  smGD.settingPath[0] = 0;
1214                  smGD.resourcePath[0] = 0;
1215                  return(-1);
1216                }
1217             status = chmod(smGD.clientPath, 0755);
1218             if(status == -1)
1219               {
1220                 PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1221                 smGD.clientPath[0] = 0;
1222                 smGD.settingPath[0] = 0;
1223                 smGD.resourcePath[0] = 0;
1224                 return(-1);
1225               }
1226         }
1227
1228         strcat(smGD.clientPath, "/");
1229         strcat(smGD.clientPath, SM_CLIENT_FILE2);
1230         strcat(smGD.settingPath, "/");
1231         strcat(smGD.settingPath, SM_SETTING_FILE);
1232         strcat(smGD.resourcePath, "/");
1233         strcat(smGD.resourcePath, SM_RESOURCE_FILE);
1234     }
1235
1236     return(0);
1237 }
1238
1239 \f
1240 /*************************************<->*************************************
1241  *
1242  *  SetFontSavePath (saveToHome, mode)
1243  *
1244  *
1245  *  Description:
1246  *  -----------
1247  *  Sets up the save path for the auxillary directory.
1248  *
1249  *
1250  *  Inputs:
1251  *  ------
1252  *
1253  *  Outputs:
1254  *  -------
1255  *
1256  *  Comments:
1257  *  --------
1258  *
1259  *************************************<->***********************************/
1260 int
1261 SetFontSavePath(char *langPtr)
1262 {
1263     struct stat         buf;
1264     int                 status;
1265     char                *sessionSaved;
1266
1267
1268     /*
1269      * Set up the session font directory and see if it exists
1270      */
1271     if(smGD.sessionType == CURRENT_SESSION)
1272     {
1273         sessionSaved = SM_CURRENT_FONT_DIRECTORY;
1274     }
1275     else
1276     {
1277         sessionSaved = SM_HOME_FONT_DIRECTORY;
1278     }
1279
1280     snprintf(smGD.fontPath, MAXPATHLEN, "%s/%s", smGD.savePath, sessionSaved);
1281     status = stat(smGD.fontPath, &buf);
1282     if(status == -1)
1283     {
1284         status = mkdir(smGD.fontPath, 0000);
1285         if(status == -1)
1286         {
1287             PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1288             smGD.fontPath[0] = 0;
1289             return(-1);
1290         }
1291         chmod(smGD.fontPath, 0755);
1292     }
1293
1294     /*
1295      * Now add the lang subdirectory and see if it exists
1296      */
1297     strncat(smGD.fontPath, "/", MAXPATHLEN);
1298     strncat(smGD.fontPath, langPtr, MAXPATHLEN);
1299     status = stat(smGD.fontPath, &buf);
1300     if(status == -1)
1301     {
1302         status = mkdir(smGD.fontPath, 0000);
1303         if(status == -1)
1304         {
1305             PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1306             smGD.fontPath[0] = 0;
1307             return(-1);
1308         }
1309         status = chmod(smGD.fontPath, 0755);
1310         if(status == -1)
1311           {
1312             PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1313             smGD.fontPath[0] = 0;
1314             return(-1);
1315           }
1316     }
1317
1318     return(0);
1319 }
1320
1321
1322 \f
1323 /*************************************<->*************************************
1324  *
1325  *  RemoveFiles()
1326  *
1327  *
1328  *  Description:
1329  *  -----------
1330  *  Remove the files that need to be removed
1331  *
1332  *
1333  *  Inputs:
1334  *  ------
1335  *
1336  *  Outputs:
1337  *  -------
1338  *
1339  *
1340  *  Comments:
1341  *  --------
1342  *
1343  *************************************<->***********************************/
1344 static void
1345 RemoveFiles(
1346         char *path )
1347 {
1348     pid_t  clientFork;
1349     int    execStatus, childStatus, i, statLoc;
1350     String tmpString;
1351
1352     /*
1353      * Fork and exec the client process
1354      */
1355     sigaction(SIGCHLD, &smGD.defvec, (struct sigaction *) NULL);
1356
1357     clientFork = vfork();
1358
1359     /*
1360      * If the fork fails - Send out an error and return
1361      */
1362     if(clientFork < 0)
1363     {
1364         PrintErrnoError(DtError, smNLS.cantForkClientString);
1365         return;
1366     }
1367
1368     /*
1369      * Fork succeeded - now do the exec
1370      */
1371     if(clientFork == 0)
1372     {
1373         SetSIGPIPEToDefault ();
1374
1375         /*
1376          * Set the gid of the process back from bin
1377          */
1378 #ifndef __hpux
1379 #ifndef SVR4
1380         setregid(smGD.runningGID, smGD.runningGID);
1381 #else
1382         setgid(smGD.runningGID);
1383         setegid(smGD.runningGID);
1384 #endif
1385 #endif
1386
1387         _DtEnvControl(DT_ENV_RESTORE_PRE_DT);
1388
1389 #if defined(__osf__) || defined(CSRG_BASED)
1390         setsid();
1391 #else
1392         (void) setpgrp();
1393 #endif /* __osf__ */
1394
1395         execStatus = execlp("rm","rm", "-rf", path, (char *) 0);
1396         if(execStatus != 0)
1397         {
1398             tmpString = ((char *)GETMESSAGE(4, 4, "Unable to remove session directory.  Make sure write permissions exist on $HOME/.dt directory.  Invalid session files will not be removed.")) ;
1399             PrintErrnoError(DtError, tmpString);
1400             SM_FREE(tmpString);
1401             SM_EXIT(-1);
1402         }
1403     }
1404
1405     while(wait(&statLoc) != clientFork);
1406
1407     sigaction(SIGCHLD, &smGD.childvec, (struct sigaction *) NULL);
1408 }
1409
1410 \f
1411 /*************************************<->*************************************
1412  *
1413  *  MoveDirectory()
1414  *
1415  *  Description:
1416  *  -----------
1417  *  Move the directory specified by pathFrom - to the directory specified
1418  *  by pathTo.
1419  *
1420  *  Inputs:
1421  *  ------
1422  *  pathFrom = the directory to move from
1423  *  pathTo = the directory to move to
1424  *  removeDestDir = if True, directory pathTo is removed before the
1425  *      move occurs
1426  *
1427  *  Outputs:
1428  *  -------
1429  *
1430  *  Comments:
1431  *  --------
1432  *
1433  *************************************<->***********************************/
1434 void
1435 MoveDirectory(
1436         char            *pathFrom,
1437         char            *pathTo,
1438         Boolean         removeDestDir)
1439 {
1440     struct stat buf;
1441     pid_t  clientFork;
1442     int    status, execStatus, childStatus, i, statLoc;
1443     String tmpString;
1444
1445     /*
1446      * If the pathTo directory exists - remove it
1447      */
1448     if (removeDestDir)
1449     {
1450         status = stat(pathTo, &buf);
1451         if(status != -1)
1452         {
1453             RemoveFiles(pathTo);
1454         }
1455     }
1456
1457     /*
1458      * Fork and exec the client process
1459      */
1460     sigaction(SIGCHLD, &smGD.defvec, (struct sigaction *) NULL);
1461
1462     clientFork = vfork();
1463
1464     /*
1465      * If the fork fails - Send out an error and return
1466      */
1467     if(clientFork < 0)
1468     {
1469         PrintErrnoError(DtError, smNLS.cantForkClientString);
1470         return;
1471     }
1472
1473     /*
1474      * Fork succeeded - now do the exec
1475      */
1476     if(clientFork == 0)
1477     {
1478         SetSIGPIPEToDefault ();
1479
1480         /*
1481          * Set the gid of the process back from bin
1482          */
1483 #ifndef __hpux
1484 #ifndef SVR4
1485         setregid(smGD.runningGID, smGD.runningGID);
1486 #else
1487         setgid(smGD.runningGID);
1488         setegid(smGD.runningGID);
1489 #endif
1490 #endif
1491
1492         _DtEnvControl(DT_ENV_RESTORE_PRE_DT);
1493
1494 #if defined(__osf__) || defined(CSRG_BASED)
1495         setsid();
1496 #else
1497         (void) setpgrp();
1498 #endif /* __osf__ */
1499
1500         execStatus = execlp("mv","mv", pathFrom, pathTo, (char *) 0);
1501         if(execStatus != 0)
1502         {
1503             tmpString = ((char *)GETMESSAGE(4, 4, "Unable to remove session directory.  Make sure write permissions exist on $HOME/.dt directory.  Invalid session files will not be removed.")) ;
1504             PrintErrnoError(DtError, tmpString);
1505             SM_FREE(tmpString);
1506             SM_EXIT(-1);
1507         }
1508     }
1509
1510     while(wait(&statLoc) != clientFork);
1511
1512     sigaction(SIGCHLD, &smGD.childvec, (struct sigaction *) NULL);
1513 }
1514
1515
1516 \f
1517 /*************************************<->*************************************
1518  *
1519  *  InitNlsStrings()
1520  *
1521  *
1522  *  Description:
1523  *  -----------
1524  *  Initialize the NLS strings used in dtsession
1525  *
1526  *
1527  *  Inputs:
1528  *  ------
1529  *
1530  *  Outputs:
1531  *  -------
1532  *
1533  *
1534  *  Comments:
1535  *  --------
1536  *
1537  *************************************<->***********************************/
1538 void
1539 InitNlsStrings( void )
1540 {
1541     char        *tmpString;
1542
1543     /*
1544      * Malloc failure error message - THIS MESSAGE MUST BE INITIALIZED FIRST
1545      */
1546     smNLS.cantMallocErrorString = strdup (((char *)GETMESSAGE(4, 5, "Unable to malloc memory for operation.")));
1547
1548     /*
1549      * Error message when dtsession cant lock the display
1550      */
1551     smNLS.cantLockErrorString = strdup (((char *)GETMESSAGE(4, 6, "Unable to lock display.  Another application may have the pointer or keyboard grabbed.")));
1552
1553     /*
1554      * Error message when dtsession cant open files for reading or writing
1555      */
1556     smNLS.cantOpenFileString = strdup (((char *)GETMESSAGE(4, 7, "Unable to open session file.  No clients will be restarted.")));
1557
1558     /*
1559      * Error message when dtsession cant fork client process
1560      */
1561     smNLS.cantForkClientString = strdup (((char *)GETMESSAGE(4, 8, "Unable to fork client process.")));
1562
1563     /*
1564      * Error message when dtsession cant create dt directories
1565      */
1566     smNLS.cantCreateDirsString = strdup (((char *)GETMESSAGE(4, 9, "Unable to create DT directories.  Check permissions on home directory.")));
1567
1568     /*
1569      * Error message when trying to lock display on trusted system
1570      */
1571     smNLS.trustedSystemErrorString = strdup (((char *)GETMESSAGE(4, 10, "Unable to lock display due to security restrictions")));
1572 }
1573
1574
1575 \f
1576 /*************************************<->*************************************
1577  *
1578  *  WaitChildDeath()
1579  *
1580  *
1581  *  Description:
1582  *  -----------
1583  *  When a SIGCHLD signal comes in, wait for all child processes to die.
1584  *
1585  *
1586  *  Inputs:
1587  *  ------
1588  *
1589  *  Outputs:
1590  *  -------
1591  *
1592  *
1593  *  Comments:
1594  *  --------
1595  *
1596  *************************************<->***********************************/
1597
1598 void
1599 WaitChildDeath( int i )
1600 {
1601   int   stat_loc;
1602   pid_t pid;
1603
1604  /*
1605   * Wait on any children that have died since the last SIGCHLD we
1606   * received. Any child process death that occurs while we are
1607   * in WaitChildDeath() will not result in a SIGCHLD. Any
1608   * child proceses that die after our last call to waitpid() will
1609   * remain zombiefied until the next invocation of WaitChildDeath().
1610   */
1611   while ((pid = waitpid(-1, &stat_loc, WNOHANG)) > 0)
1612   ;
1613
1614   sigaction(SIGCHLD, &smGD.childvec, (struct sigaction *) NULL);
1615 }
1616
1617
1618 \f
1619 /*************************************<->*************************************
1620  *
1621  *  TrimErrorlog()
1622  *
1623  *
1624  *  Description:
1625  *  -----------
1626  *  Trim the errorlog file using the following algorithm:
1627  *      if(errorlog.old exists and is not empty) move it to errorlog.oldest
1628  *      if(errorlog exists and is not empty) move it to errorlog.old
1629  *
1630  *
1631  *  Inputs:
1632  *  ------
1633  *
1634  *  Outputs:
1635  *  -------
1636  *
1637  *
1638  *  Comments:
1639  *  --------
1640  *
1641  *************************************<->***********************************/
1642 static void
1643 TrimErrorlog( void )
1644 {
1645     char        *savePath,      /* common path element for all pathnames */
1646                 *checkPath1,
1647                 *checkPath2;
1648     struct stat buf;
1649     int len, status;
1650     char *home;
1651
1652     /*
1653      * Allocate the strings needed
1654      */
1655     savePath = (char *) SM_MALLOC(MAXPATHLEN + 1);
1656     checkPath1 = (char *) SM_MALLOC(MAXPATHLEN + 1);
1657     checkPath2 = (char *) SM_MALLOC(MAXPATHLEN + 1);
1658     if ((home=getenv("HOME")) == NULL)
1659         home="";
1660
1661     len = strlen(home) + strlen(DtPERSONAL_CONFIG_DIRECTORY) + 2;
1662     if (len > MAXPATHLEN) savePath = SM_REALLOC(savePath, len);
1663     snprintf(savePath, len - 1, "%s/%s", home, DtPERSONAL_CONFIG_DIRECTORY);
1664
1665     /*
1666      * If errorlog.old exists and it is not empty, delete
1667      * errorlog.older and then move errolog.old to
1668      * errorlog.older
1669      */
1670     if (len + strlen(DtOLDER_ERRORLOG_FILE) > MAXPATHLEN)
1671       checkPath1 = SM_REALLOC(savePath, len + strlen(DtOLDER_ERRORLOG_FILE));
1672     sprintf(checkPath1, "%s/%s", savePath, DtOLDER_ERRORLOG_FILE);
1673
1674     if (len + strlen(DtOLD_ERRORLOG_FILE) > MAXPATHLEN)
1675       checkPath2 = SM_REALLOC(savePath, len + strlen(DtOLD_ERRORLOG_FILE));
1676     sprintf(checkPath2, "%s/%s", savePath, DtOLD_ERRORLOG_FILE);
1677
1678     status = stat(checkPath2, &buf);
1679     if((status != -1) && (buf.st_size > 0))
1680     {
1681         (void) unlink(checkPath1);
1682         (void) link(checkPath2, checkPath1);
1683         (void) unlink(checkPath2);
1684     }
1685
1686     /*
1687      * If errorlog exists and it is not empty, move it to
1688      * errorlog.old
1689      */
1690     if (len + strlen(DtERRORLOG_FILE) > MAXPATHLEN)
1691       checkPath1 = SM_REALLOC(savePath, len + strlen(DtERRORLOG_FILE));
1692     sprintf(checkPath1, "%s/%s", savePath, DtERRORLOG_FILE);
1693
1694     status = stat(checkPath1, &buf);
1695     if((status != -1) && (buf.st_size > 0))
1696     {
1697         (void) link(checkPath1, checkPath2);
1698         (void) unlink(checkPath1);
1699     }
1700
1701     SM_FREE((char *) savePath);
1702     SM_FREE((char *) checkPath1);
1703     SM_FREE((char *) checkPath2);
1704
1705     return;
1706 }
1707
1708
1709 \f
1710 /*************************************<->*************************************
1711  *
1712  *  SetSystemReady()
1713  *
1714  *
1715  *  Description:
1716  *  -----------
1717  *  Do everything that needs to be done to get the system back into a
1718  *  READY state.  This includes checking to be sure that the BMS did not
1719  *  die while we were in process
1720  *
1721  *
1722  *  Inputs:
1723  *  ------
1724  *
1725  *  Outputs:
1726  *  -------
1727  *
1728  *
1729  *  Comments:
1730  *  --------
1731  *
1732  *************************************<->***********************************/
1733 void
1734 SetSystemReady( void )
1735 {
1736     smGD.smState = READY;
1737     if(smGD.bmsDead == True)
1738     {
1739         WarnMsgFailure();
1740     }
1741
1742     return;
1743 }
1744
1745
1746 /*************************************<->*************************************
1747  *
1748  *  SmCvtStringToContManagement (args, numArgs, fromVal, toVal)
1749  *
1750  *
1751  *  Description:
1752  *  -----------
1753  *  This function converts a string to a value for the
1754  *  contention management flag set.
1755  *
1756  *
1757  *  Inputs:
1758  *  ------
1759  *  args = additional XrmValue arguments to the converter - NULL here
1760  *
1761  *  numArgs = number of XrmValue arguments - 0 here
1762  *
1763  *  fromVal = resource value to convert
1764  *
1765  *
1766  *  Outputs:
1767  *  -------
1768  *  toVal = descriptor to use to return converted value
1769  *
1770  *************************************<->***********************************/
1771
1772 void SmCvtStringToContManagement (XrmValue *args, Cardinal numArgs, XrmValue *fromVal, XrmValue *toVal)
1773 {
1774
1775     unsigned char       *pch = (unsigned char *) (fromVal->addr);
1776     unsigned char       *pchNext;
1777     int         len;
1778     static long cval;
1779     Boolean     fHit = False;
1780     Boolean    fAddNext = True;
1781
1782 /*
1783  * Names of contention management options
1784  */
1785
1786 #define CM_ALL_STR              (unsigned char *)"all"
1787 #define CM_SYSTEM_STR           (unsigned char *)"system"
1788 #define CM_HANDSHAKE_STR        (unsigned char *)"handshake"
1789 #define CM_NONE_STR             (unsigned char *)"none"
1790
1791     /*
1792      * Check first token. If '-' we subtract from all options.
1793      * Otherwise, we start with no contention management and add things in.
1794      */
1795
1796     if (*pch &&
1797         (_DtNextToken (pch, &len, &pchNext)) &&
1798         (*pch == '-'))
1799     {
1800         cval = SM_CM_ALL;
1801         fHit = True;
1802     }
1803     else
1804     {
1805         cval = SM_CM_NONE;
1806     }
1807
1808     while (*pch && _DtNextToken (pch, &len, &pchNext))
1809     {
1810            /*
1811             * Strip off "sign" if prepended to another token, and process
1812             * that token the next time through.
1813             */
1814
1815         if (*pch == '+')
1816         {
1817             if (len != 1)
1818             {
1819                 pchNext = pch + 1;
1820             }
1821             fAddNext = TRUE;
1822         }
1823
1824         else if (*pch == '-')
1825         {
1826             if (len != 1)
1827             {
1828                 pchNext = pch + 1;
1829             }
1830             fAddNext = FALSE;
1831         }
1832
1833         if ((*pch == 'A') || (*pch == 'a'))
1834         {
1835             if (_DtWmStringsAreEqual (pch, CM_ALL_STR, len))
1836             {
1837                 cval = fAddNext ? (cval | SM_CM_ALL) :
1838                                   (cval & ~SM_CM_ALL);
1839                 fHit = True;
1840             }
1841         }
1842
1843         else if ((*pch == 'S') || (*pch == 's'))
1844         {
1845             if (_DtWmStringsAreEqual (pch, CM_SYSTEM_STR, len))
1846             {
1847                 cval = fAddNext ? (cval | SM_CM_SYSTEM) :
1848                                   (cval & ~SM_CM_SYSTEM);
1849                 fHit = True;
1850             }
1851         }
1852
1853         else if ((*pch == 'H') || (*pch == 'h'))
1854         {
1855             if (_DtWmStringsAreEqual (pch, CM_HANDSHAKE_STR, len))
1856             {
1857                 cval = fAddNext ? (cval | SM_CM_HANDSHAKE) :
1858                                   (cval & ~SM_CM_HANDSHAKE);
1859                 fHit = True;
1860             }
1861         }
1862
1863         else if ((*pch == 'N') || (*pch == 'n'))
1864         {
1865             if (_DtWmStringsAreEqual (pch, CM_NONE_STR, len))
1866             {
1867                 /* don't bother adding or subtracting nothing */
1868                 fHit = True;
1869             }
1870         }
1871
1872         pch = pchNext;
1873     }
1874
1875
1876
1877     /*
1878      * If we didn't match anything then set to default.
1879      */
1880     if (!fHit)
1881     {
1882         cval =  SM_CM_DEFAULT;
1883     }
1884
1885
1886     (*toVal).size = sizeof (long);
1887     (*toVal).addr = (caddr_t) &cval;
1888
1889
1890 } /* END OF FUNCTION SmCvtStringToContManagement */
1891
1892
1893 /*************************************<->*************************************
1894  *
1895  *  _DtNextToken (pchIn, pLen, ppchNext)
1896  *
1897  *
1898  *  Description:
1899  *  -----------
1900  *  XXDescription ...
1901  *
1902  *
1903  *  Inputs:
1904  *  ------
1905  *  pchIn = pointer to start of next token
1906  *
1907  *
1908  *  Outputs:
1909  *  -------
1910  *  pLen  =    pointer to integer containing number of characters in next token
1911  *  ppchNext = address of pointer to following token
1912  *
1913  *  Return =   next token or NULL
1914  *
1915  *
1916  *  Comments:
1917  *  --------
1918  *  None.
1919  *
1920  *************************************<->***********************************/
1921
1922 unsigned char *_DtNextToken (unsigned char *pchIn, int *pLen,
1923         unsigned char **ppchNext)
1924 {
1925     unsigned char *pchR = pchIn;
1926     register int   i;
1927
1928 #ifdef MULTIBYTE
1929     register int   chlen;
1930
1931     for (i = 0; ((chlen = mblen ((char *)pchIn, MB_CUR_MAX)) > 0); i++)
1932     /* find end of word: requires singlebyte whitespace terminator */
1933     {
1934         if ((chlen == 1) && isspace (*pchIn))
1935         {
1936             break;
1937         }
1938         pchIn += chlen;
1939     }
1940
1941 #else
1942     for (i = 0; *pchIn && !isspace (*pchIn); i++, pchIn++)
1943     /* find end of word */
1944     {
1945     }
1946 #endif
1947
1948     /* skip to next word */
1949     ScanWhitespace (&pchIn);
1950
1951     *ppchNext = pchIn;
1952     *pLen = i;
1953     if (i)
1954     {
1955         return(pchR);
1956     }
1957     else
1958     {
1959        return(NULL);
1960     }
1961
1962 } /* END OF FUNCTION _DtNextToken */
1963
1964
1965 \f
1966 /*************************************<->*************************************
1967  *
1968  *  _DtWmStringsAreEqual (pch1, pch2, len)
1969  *
1970  *
1971  *  Description:
1972  *  -----------
1973  *  XXDescription ...
1974  *
1975  *
1976  *  Inputs:
1977  *  ------
1978  *  pch1 =
1979  *  pch2 =
1980  *  len  =
1981  *
1982  *
1983  *  Outputs:
1984  *  -------
1985  *  Return = (Boolean) True iff strings match (case insensitive)
1986  *
1987  *
1988  *  Comments:
1989  *  --------
1990  *  None.
1991  *
1992  *************************************<->***********************************/
1993
1994 Boolean _DtWmStringsAreEqual (unsigned char *pch1, unsigned char *pch2, int len)
1995 {
1996 #ifdef MULTIBYTE
1997     int       chlen1;
1998     int       chlen2;
1999     wchar_t   wch1;
2000     wchar_t   wch2;
2001
2002     while (len  &&
2003            ((chlen1 = mbtowc (&wch1, (char *) pch1, 2)) > 0) &&
2004            ((chlen2 = mbtowc (&wch2, (char *) pch2, 2)) == chlen1) )
2005     {
2006         if (chlen1 == 1)
2007         /* singlebyte characters -- make case insensitive */
2008         {
2009             if ((isupper (*pch1) ? tolower(*pch1) : *pch1) !=
2010                 (isupper (*pch2) ? tolower(*pch2) : *pch2))
2011             {
2012                 break;
2013             }
2014         }
2015         else
2016         /* multibyte characters */
2017         {
2018             if (wch1 != wch2)
2019             {
2020                 break;
2021             }
2022         }
2023         pch1 += chlen1;
2024         pch2 += chlen2;
2025         len--;
2026     }
2027
2028 #else
2029     while (len  && *pch1 && *pch2 &&
2030            ((isupper (*pch1) ? tolower(*pch1) : *pch1) ==
2031             (isupper (*pch2) ? tolower(*pch2) : *pch2)))
2032     {
2033         *pch1++;
2034         *pch2++;
2035         len--;
2036     }
2037 #endif
2038
2039     return (len == 0);
2040
2041 } /* END OF _DtWmStringsAreEqual */
2042
2043 /*************************************<->*************************************
2044  *
2045  *  InitializeGenericSession - set the smGD paths using the CDE 1.0
2046  *       session starting algorithm.
2047  *
2048  *  Description:
2049  *  -----------
2050  *  Initializes several variables in smGD
2051  *
2052  *  Inputs:
2053  *  ------
2054  *  tmpDisplay
2055  *
2056  *  Outputs:
2057  *  -------
2058  *  Return = void
2059  *
2060  *  Comments:
2061  *  --------
2062  *
2063  *************************************<->***********************************/
2064 static void
2065 InitializeGenericSession (
2066         Display         *tmpDisplay)
2067 {
2068     struct      stat buf;
2069     int         session_needed = 1;
2070     int         status;
2071     char        tmpPath[MAXPATHLEN];
2072
2073     smGD.savePath = _DtCreateDtDirs(tmpDisplay);
2074
2075     if (session_needed)
2076     {
2077       strcpy(smGD.clientPath, smGD.savePath);
2078       strcat(smGD.clientPath, "/");
2079       strcat(smGD.clientPath, SM_CURRENT_DIRECTORY);
2080       strcat(smGD.clientPath, "/");
2081       strcpy (tmpPath, smGD.clientPath);
2082       strcat(smGD.clientPath, SM_CLIENT_FILE2);
2083
2084       status = stat(smGD.clientPath, &buf);
2085
2086       if (status != 0) {
2087          strcpy (smGD.clientPath, tmpPath);
2088          strcat (smGD.clientPath, SM_CLIENT_FILE);
2089          status = stat(smGD.clientPath, &buf);
2090       }
2091
2092       if(status == 0)
2093       {
2094        /*
2095         * sessions/current/dt.settings exist, restore to 'current' session
2096         */
2097         strcpy(smGD.resourcePath, smGD.savePath);
2098         strcat(smGD.resourcePath, "/");
2099         strcat(smGD.resourcePath, SM_CURRENT_DIRECTORY);
2100         strcat(smGD.resourcePath, "/");
2101         strcat(smGD.resourcePath, SM_RESOURCE_FILE);
2102         strcpy(smGD.settingPath, smGD.savePath);
2103         strcat(smGD.settingPath, "/");
2104         strcat(smGD.settingPath, SM_CURRENT_DIRECTORY);
2105         strcat(smGD.settingPath, "/");
2106         strcat(smGD.settingPath, SM_SETTING_FILE);
2107         SetResSet();
2108         smGD.sessionType = CURRENT_SESSION;
2109         smGD.restoreSession = (char *) SM_CURRENT_DIRECTORY;
2110         session_needed = 0;
2111       }
2112     }
2113
2114     if (session_needed)
2115     {
2116       strcpy(smGD.clientPath, smGD.savePath);
2117       strcat(smGD.clientPath, "/");
2118       strcat(smGD.clientPath, SM_HOME_DIRECTORY);
2119       strcat(smGD.clientPath, "/");
2120       strcpy(tmpPath, smGD.clientPath);
2121       strcat(smGD.clientPath, SM_CLIENT_FILE2);
2122
2123       status = stat(smGD.clientPath, &buf);
2124
2125       if (status != 0) {
2126          strcpy (smGD.clientPath, tmpPath);
2127          strcat (smGD.clientPath, SM_CLIENT_FILE);
2128          status = stat(smGD.clientPath, &buf);
2129       }
2130
2131       if(status == 0)
2132       {
2133        /*
2134         * sessions/home/dt.settings exist, restore to 'home' session
2135         */
2136         strcpy(smGD.resourcePath, smGD.savePath);
2137         strcat(smGD.resourcePath, "/");
2138         strcat(smGD.resourcePath, SM_HOME_DIRECTORY);
2139         strcat(smGD.resourcePath, "/");
2140         strcat(smGD.resourcePath, SM_RESOURCE_FILE);
2141         strcpy(smGD.settingPath, smGD.savePath);
2142         strcat(smGD.settingPath, "/");
2143         strcat(smGD.settingPath, SM_HOME_DIRECTORY);
2144         strcat(smGD.settingPath, "/");
2145         strcat(smGD.settingPath, SM_SETTING_FILE);
2146         SetResSet();
2147         smGD.sessionType = HOME_SESSION;
2148         smGD.restoreSession = (char *) SM_HOME_DIRECTORY;
2149         session_needed = 0;
2150       }
2151     }
2152
2153     if (session_needed)
2154     {
2155       SetSysDefaults();
2156     }
2157 }
2158
2159 /*************************************<->*************************************
2160  *
2161  *  InternSessionDir - intern the session dir property and put it
2162  *     on the root window
2163  *
2164  *     NOTE: - also checks the validity of the -session command line
2165  *         option
2166  *
2167  *  Inputs:
2168  *  ------
2169  *  session_option - as given in the command line
2170  *  display
2171  *
2172  *  Outputs:
2173  *  ------
2174  *  smGD.restoreSession - initialized
2175  *
2176  *  Return = void
2177  *
2178  *************************************<->***********************************/
2179 static Boolean
2180 InternSessionDir (
2181         char            *session_option,
2182         Display         *disp)
2183 {
2184         char            *pch;
2185
2186         if (!strcmp (session_option, SM_CURRENT_DIRECTORY)) {
2187                 pch = DtSM_SESSION_DIRECTORY;
2188                 smGD.restoreSession = SM_CURRENT_DIRECTORY;
2189         }
2190         else if (!strcmp (session_option, SM_HOME_DIRECTORY)) {
2191                 pch = DtSM_SESSION_DIRECTORY;
2192                 smGD.restoreSession = SM_HOME_DIRECTORY;
2193         }
2194         else if (!strcmp (session_option, SM_DISPLAY_HOME)) {
2195                 pch = DtSM_SESSION_DISPLAY_DIRECTORY;
2196                 smGD.restoreSession = SM_HOME_DIRECTORY;
2197         }
2198         else if (!strcmp (session_option, SM_DISPLAY_CURRENT)) {
2199                 pch = DtSM_SESSION_DISPLAY_DIRECTORY;
2200                 smGD.restoreSession = SM_CURRENT_DIRECTORY;
2201         }
2202         else
2203                 /*
2204                  * The session_option is not supported
2205                  */
2206                 return (False);
2207
2208         XaSmRestoreDir = XInternAtom(disp, _XA_DT_RESTORE_DIR, False);
2209
2210         XChangeProperty(disp, RootWindow(disp, 0),
2211                 XaSmRestoreDir, XA_STRING, 8, PropModeReplace,
2212                 (unsigned char *)pch, strlen(pch));
2213
2214         XFlush(disp);
2215
2216
2217         return (True);
2218 }
2219
2220
2221 /*************************************<->*************************************
2222  *
2223  *  InitializeSpecificSession - set the smGD paths based on the session
2224  *       name given on the command line.
2225  *
2226  *  Description:
2227  *  -----------
2228  *  Initializes several variables in smGD
2229  *
2230  *  Inputs:
2231  *  ------
2232  *  session_option
2233  *  tmpDisplay
2234  *
2235  *  Outputs:
2236  *  -------
2237  *  Return = void
2238  *
2239  *  Comments:
2240  *  --------
2241  *
2242  *************************************<->***********************************/
2243 static Boolean
2244 InitializeSpecificSession (
2245         char            *session_option,
2246         Display         *disp,
2247         unsigned int    argc,
2248         char            **argv)
2249 {
2250         char            *session_dir = (char *) XtMalloc(MAXPATHLEN);
2251         char            *alt_dir = (char *) XtMalloc(MAXPATHLEN);
2252         int             len;
2253         struct stat     buf;
2254
2255         if (!InternSessionDir (session_option, disp))
2256                 return (False);
2257
2258         InitializePaths (smGD.restoreSession, disp);
2259
2260         if (!strcmp (session_option, SM_HOME_DIRECTORY)) {
2261                 /*
2262                  * Home session
2263                  */
2264                 if (smGD.clientPath[0] == '\0') {
2265                         if ((stat (smGD.savePath, &buf)) != 0) {
2266                                 if ((mkdir (smGD.savePath, 0000)) == 0)
2267                                         (void) chmod (smGD.savePath, 0755);
2268                                 else
2269                                         PrintErrnoError(DtError,
2270                                                 smNLS.cantCreateDirsString);
2271                         }
2272                         SetSysDefaults ();
2273                 }
2274                 smGD.sessionType = HOME_SESSION;
2275                 smGD.restoreSession = SM_HOME_DIRECTORY;
2276         }
2277         else if (!strcmp (session_option, SM_CURRENT_DIRECTORY)) {
2278                 /*
2279                  * Current session
2280                  */
2281                 if (smGD.clientPath[0] == '\0') {
2282                         /*
2283                          * Fallback to the generic home session
2284                          */
2285                         (void) sprintf (session_dir, "%s/%s",
2286                                         smGD.savePath, SM_CURRENT_DIRECTORY);
2287                         (void) sprintf (alt_dir, "%s/%s",
2288                                         smGD.savePath, SM_HOME_DIRECTORY);
2289
2290                         if (!SetAlternateSession (session_dir, alt_dir, True))
2291                                 SetSysDefaults ();
2292                 }
2293                 smGD.sessionType = CURRENT_SESSION;
2294                 smGD.restoreSession = SM_CURRENT_DIRECTORY;
2295         }
2296         else if (!strcmp (session_option, SM_DISPLAY_HOME)) {
2297                 /*
2298                  * Display-specific Home session
2299                  */
2300                 (void) sprintf (session_dir, "%s/%s",
2301                                 smGD.savePath, SM_HOME_DIRECTORY);
2302
2303                 if ((stat(session_dir, &buf)) != 0){
2304                         /*
2305                          * The session does not exist, give the user a
2306                          * change to exit.
2307                          */
2308                         if (!ConfirmSessionCreation (HOME_SESSION, argc, argv))
2309                                 SM_EXIT (0);
2310
2311                 }
2312
2313                 if (smGD.clientPath[0] == '\0') {
2314                         /*
2315                          * Fallback to the generic home session
2316                          */
2317                         char            *home;
2318
2319                         if ((home = getenv ("HOME")) == 0)
2320                                 home = "";
2321
2322                         /* JET - VU#497553 */
2323                         len = strlen(home) +
2324                           strlen(DtPERSONAL_CONFIG_DIRECTORY) +
2325                           strlen(DtSM_SESSION_DIRECTORY) +
2326                           strlen(SM_HOME_DIRECTORY);
2327
2328                         if (len > MAXPATHLEN)
2329                           alt_dir = XtRealloc(alt_dir, len + 1);
2330
2331                         (void) sprintf (alt_dir, "%s/%s/%s/%s",
2332                                         home,
2333                                         DtPERSONAL_CONFIG_DIRECTORY,
2334                                         DtSM_SESSION_DIRECTORY,
2335                                         SM_HOME_DIRECTORY);
2336                         if (!SetAlternateSession (session_dir, alt_dir, True))
2337                                 SetSysDefaults ();
2338                 }
2339                 smGD.sessionType = HOME_SESSION;
2340                 smGD.restoreSession = SM_HOME_DIRECTORY;
2341         }
2342         else if (!strcmp (session_option, SM_DISPLAY_CURRENT)) {
2343                 /*
2344                  * Display-specific Current session
2345                  */
2346                 (void) sprintf (session_dir, "%s/%s",
2347                                 smGD.savePath, SM_CURRENT_DIRECTORY);
2348
2349                 if ((stat(session_dir, &buf)) != 0){
2350                         /*
2351                          * The session does not exist, give the user a
2352                          * change to exit.
2353                          */
2354                         if (!ConfirmSessionCreation (CURRENT_SESSION, argc, argv))
2355                                 SM_EXIT (0);
2356                 }
2357
2358                 if (smGD.clientPath[0] == '\0') {
2359                         /*
2360                          * First, fallback to the display-specific home session
2361                          */
2362                         char            *home;
2363
2364                         (void) sprintf (alt_dir, "%s/%s",
2365                                         smGD.savePath, SM_HOME_DIRECTORY);
2366
2367                         if (!SetAlternateSession (session_dir, alt_dir, False)){
2368                                 /*
2369                                  * Try the generic home session
2370                                  */
2371                                 if ((home = getenv ("HOME")) == 0)
2372                                         home = "";
2373
2374                                 /* JET - VU#497553 */
2375                                 len = strlen(home) +
2376                                   strlen(DtPERSONAL_CONFIG_DIRECTORY) +
2377                                   strlen(DtSM_SESSION_DIRECTORY) +
2378                                   strlen(SM_HOME_DIRECTORY);
2379
2380                                 if (len > MAXPATHLEN)
2381                                   alt_dir = XtRealloc(alt_dir, len + 1);
2382
2383                                 snprintf(alt_dir, len, "%s/%s/%s/%s",
2384                                          home,
2385                                          DtPERSONAL_CONFIG_DIRECTORY,
2386                                          DtSM_SESSION_DIRECTORY,
2387                                          SM_HOME_DIRECTORY);
2388
2389                                 if (!SetAlternateSession (session_dir,
2390                                                           alt_dir,
2391                                                           True))
2392                                         SetSysDefaults ();
2393                         }
2394                 }
2395                 smGD.sessionType = CURRENT_SESSION;
2396                 smGD.restoreSession = SM_CURRENT_DIRECTORY;
2397         }
2398         else {
2399                 if (session_dir) XtFree(session_dir);
2400                 if (alt_dir) XtFree(alt_dir);
2401                 return (False);
2402         }
2403
2404         if (session_dir) XtFree(session_dir);
2405         if (alt_dir) XtFree(alt_dir);
2406         return (True);
2407 }
2408
2409
2410 /*************************************<->*************************************
2411  *
2412  *  InitializePaths
2413  *
2414  *  Description:
2415  *  -----------
2416  *  Initializes the following variables:
2417  *
2418  *     smGD.savePath
2419  *     smGD.settingsPath
2420  *     smGD.resourcePath
2421  *     smGD.clientPath - [0] = '\0' if the database files do not exist
2422  *
2423  *  Inputs:
2424  *  ------
2425  *  session_name = "current" or "home"
2426  *
2427  *  Outputs:
2428  *  -------
2429  *  Return = void
2430  *
2431  *  Comments:
2432  *  --------
2433  *
2434  *************************************<->***********************************/
2435 static void
2436 InitializePaths (
2437         char            * session_name,
2438         Display         * disp)
2439 {
2440         char            *db_file = (char *) XtMalloc(MAXPATHLEN);
2441         struct stat     buf;
2442
2443         if (!db_file)
2444           {
2445             PrintError(DtError, smNLS.cantMallocErrorString);
2446             return;
2447           }
2448
2449         smGD.savePath = _DtCreateDtDirs(disp);
2450
2451         (void) sprintf (smGD.settingPath, "%s/%s/%s",
2452                         smGD.savePath, session_name, SM_SETTING_FILE);
2453
2454         (void) sprintf (smGD.resourcePath, "%s/%s/%s",
2455                         smGD.savePath, session_name, SM_RESOURCE_FILE);
2456
2457
2458         smGD.clientPath[0] = '\0';
2459
2460         (void) sprintf (db_file, "%s/%s/%s",
2461                         smGD.savePath, session_name, SM_CLIENT_FILE2);
2462
2463         if ((stat(db_file, &buf)) == 0)
2464                 (void) strcpy (smGD.clientPath, db_file);
2465         else {
2466                 (void) sprintf (db_file, "%s/%s/%s",
2467                                 smGD.savePath, session_name, SM_CLIENT_FILE);
2468                 if ((stat(db_file, &buf)) == 0)
2469                         (void) strcpy (smGD.clientPath, db_file);
2470         }
2471         XtFree(db_file);
2472 }
2473
2474
2475 /*************************************<->*************************************
2476  *
2477  *  SetAlternateSession
2478  *
2479  *  Assumptions:
2480  *
2481  *     Neither of the client databases in the session_dir directory
2482  *     exist.
2483  *
2484  *  Inputs:
2485  *  ------
2486  *  session_dir - the directory path for the session including home
2487  *     or current
2488  *  alt_dir - the directory to use in the search for an alternate
2489  *     or fallback session database
2490  *  make_dir - if True, a session_dir will be created if it does not
2491  *     exits; if False, session_dir will not be created
2492  *
2493  *  Outputs:
2494  *  -------
2495  *  Return = Boolean
2496  *
2497  *************************************<->***********************************/
2498 static Boolean
2499 SetAlternateSession (
2500         char            * session_dir,
2501         char            * alt_dir,
2502         Boolean         make_dir)
2503 {
2504         char            *tmp_dir = NULL;
2505         char            *db_file1 = (char *) XtMalloc(MAXPATHLEN);
2506         char            *db_file2 = (char *) XtMalloc(MAXPATHLEN);
2507         struct stat     buf;
2508
2509         if (!db_file1 || !db_file2)
2510           {
2511             PrintError(DtError, smNLS.cantMallocErrorString);
2512             return False;
2513           }
2514
2515
2516         if ((stat (session_dir, &buf)) != 0) {
2517                 /*
2518                  * The requested dir does not exist, create it
2519                  * by either copying the session from alt_dir (if
2520                  * it exists and has a client database) or by
2521                  * calling mkdir.
2522                  */
2523
2524                 (void) sprintf (db_file1, "%s/%s",
2525                                 alt_dir, SM_CLIENT_FILE2);
2526                 (void) sprintf (db_file2, "%s/%s",
2527                                 alt_dir, SM_CLIENT_FILE);
2528
2529                 if ((stat(db_file1, &buf)) == 0)
2530                         tmp_dir = db_file1;
2531                 else if ((stat(db_file2, &buf)) == 0)
2532                         tmp_dir = db_file2;
2533
2534                 if (!tmp_dir && !make_dir) {
2535                         if (db_file1) XtFree(db_file1);
2536                         if (db_file2) XtFree(db_file2);
2537                         /*
2538                          * This alt_dir doesn't have a session database
2539                          * return now and try another directory
2540                          */
2541                         return (False);
2542                 }
2543
2544                 if (tmp_dir) {
2545                         /*
2546                          * The alt_dir has a session database, create
2547                          * a copy of its entire directory because all
2548                          * of the sessions state is needed.
2549                          */
2550                         char            *tmp;
2551
2552                         tmp = XtMalloc (strlen (alt_dir) +
2553                                         strlen (session_dir) + 10);
2554                         if (!tmp)
2555                                 return (False);
2556
2557                         (void) sprintf (tmp, "cp -r %s %s",
2558                                         alt_dir, session_dir);
2559
2560                         if ((system (tmp)) == -1)
2561                                 return (False);
2562                         XtFree (tmp);
2563
2564                         if ((stat(session_dir, &buf)) != 0)
2565                                 /*
2566                                  * It should have been created by the cp
2567                                  */
2568                                 return (False);
2569
2570                         /*
2571                          * The session database needs to be updated.
2572                          */
2573                         if (tmp_dir == db_file1)
2574                                 sprintf (smGD.clientPath, "%s/%s",
2575                                         session_dir, SM_CLIENT_FILE2);
2576                         else
2577                                 sprintf (smGD.clientPath, "%s/%s",
2578                                         session_dir, SM_CLIENT_FILE);
2579                 } else {
2580                         /*
2581                          * The alt_dir did not have a session database.
2582                          * Create a directory and load the system defaults
2583                          */
2584                         if ((mkdir (session_dir, 0000)) == 0)
2585                                 (void) chmod (session_dir, 0755);
2586                         else {
2587                                 PrintErrnoError(DtError,
2588                                         smNLS.cantCreateDirsString);
2589                                 return (False);
2590                         }
2591                         SetSysDefaults ();
2592                 }
2593         } else {
2594                 /*
2595                  * The directory for the specified session exists
2596                  * but it doesn't have any client databases.  Start
2597                  * a new user session.  If a user wants a sesssion
2598                  * with no apps, they should create a zero-length
2599                  * session database.
2600                  */
2601                 SetSysDefaults ();
2602         }
2603
2604         XtFree(db_file1);
2605         XtFree(db_file2);
2606         return (True);
2607 }
2608
2609
2610 void
2611 SmExit (
2612         int             exitStatus)
2613 {
2614   /* JET - needed to rework this to avoid exiting before we are
2615    *  *really* ready to
2616    */
2617   if (smGD.ExitComplete)
2618     {
2619       if (smXSMP.saveState.saveComplete &&
2620           smXSMP.saveState.shutdown &&
2621           !smXSMP.saveState.shutdownCanceled)
2622         XSMPExit ();
2623       exit(exitStatus);
2624     }
2625   else
2626     return;
2627 }
2628
2629 void
2630 SetSIGPIPEToDefault ()
2631 {
2632         struct sigaction pipeSig;
2633
2634         sigemptyset(&pipeSig.sa_mask);
2635         pipeSig.sa_flags = 0;
2636         pipeSig.sa_handler = SIG_DFL;
2637         (void) sigaction(SIGPIPE, &pipeSig, (struct sigaction *) NULL);
2638 }