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                     MoveDirectory(smGD.etcPath, tmpName, False);
1128
1129                     strncpy(savedTmpDir, tmpName, len - 1);
1130                   }
1131                 XtFree((char *) tmpName);
1132             }
1133             MoveDirectory(smGD.clientPath, smGD.etcPath, False);
1134         }
1135
1136         smGD.clientPath[0] = 0;
1137         smGD.settingPath[0] = 0;
1138         smGD.resourcePath[0] = 0;
1139     }
1140     else
1141     {
1142         strcpy (savedDir, smGD.clientPath);
1143
1144         /*
1145          * If the desired directory doesn't exist, create it.
1146          */
1147         status = stat(smGD.clientPath, &buf);
1148         if(status == -1)
1149         {
1150             status = mkdir(smGD.clientPath, 0000);
1151             if(status == -1)
1152             {
1153                 PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1154                 smGD.clientPath[0] = 0;
1155                 smGD.settingPath[0] = 0;
1156                 smGD.resourcePath[0] = 0;
1157                 return(-1);
1158             }
1159             chmod(smGD.clientPath, 0755);
1160         }
1161         else
1162         {
1163             /*
1164              * The desired directory already exists so it must
1165              * be archived by moving it to its ".old" version. But
1166              * first, if its ".old" version already exists, it must
1167              * be moved to a temporary directory that will be removed
1168              * when the session directories are pruned - after the
1169              * save is complete.
1170              */
1171             char                * tmpName;
1172
1173             sprintf(smGD.etcPath, "%s.%s", smGD.clientPath, SM_OLD_EXTENSION);
1174             status = stat(smGD.etcPath, &buf);
1175             if(status == 0)
1176             {
1177               int len, tfd;
1178
1179               len = strlen(smGD.restoreSession) + strlen("XXXXXX") + 2;
1180               tmpName = (char *) XtCalloc(1, len);
1181               sprintf(tmpName, "%s.XXXXXX", smGD.restoreSession);
1182
1183               strcpy (savedOldDir, smGD.etcPath);
1184
1185               if ((tfd = mkstemp(tmpName)) == -1)
1186                 {
1187                   PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1188                 }
1189               else
1190                 {
1191                   close(tfd);
1192                   MoveDirectory (smGD.etcPath, tmpName, False);
1193
1194                   strcpy (savedTmpDir, tmpName);
1195                 }
1196               XtFree((char *) tmpName);
1197             }
1198
1199             MoveDirectory(smGD.clientPath, smGD.etcPath, False);
1200
1201             /*
1202              * Now re-make the directory
1203              */
1204                status = mkdir(smGD.clientPath, 0000);
1205                if(status == -1)
1206                {
1207                  PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1208                  smGD.clientPath[0] = 0;
1209                  smGD.settingPath[0] = 0;
1210                  smGD.resourcePath[0] = 0;
1211                  return(-1);
1212                }
1213             status = chmod(smGD.clientPath, 0755);
1214             if(status == -1)
1215               {
1216                 PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1217                 smGD.clientPath[0] = 0;
1218                 smGD.settingPath[0] = 0;
1219                 smGD.resourcePath[0] = 0;
1220                 return(-1);
1221               }
1222         }
1223
1224         strcat(smGD.clientPath, "/");
1225         strcat(smGD.clientPath, SM_CLIENT_FILE2);
1226         strcat(smGD.settingPath, "/");
1227         strcat(smGD.settingPath, SM_SETTING_FILE);
1228         strcat(smGD.resourcePath, "/");
1229         strcat(smGD.resourcePath, SM_RESOURCE_FILE);
1230     }
1231
1232     return(0);
1233 }
1234
1235 \f
1236 /*************************************<->*************************************
1237  *
1238  *  SetFontSavePath (saveToHome, mode)
1239  *
1240  *
1241  *  Description:
1242  *  -----------
1243  *  Sets up the save path for the auxillary directory.
1244  *
1245  *
1246  *  Inputs:
1247  *  ------
1248  *
1249  *  Outputs:
1250  *  -------
1251  *
1252  *  Comments:
1253  *  --------
1254  *
1255  *************************************<->***********************************/
1256 int
1257 SetFontSavePath(char *langPtr)
1258 {
1259     struct stat         buf;
1260     int                 status;
1261     char                *sessionSaved;
1262
1263
1264     /*
1265      * Set up the session font directory and see if it exists
1266      */
1267     if(smGD.sessionType == CURRENT_SESSION)
1268     {
1269         sessionSaved = SM_CURRENT_FONT_DIRECTORY;
1270     }
1271     else
1272     {
1273         sessionSaved = SM_HOME_FONT_DIRECTORY;
1274     }
1275
1276     snprintf(smGD.fontPath, MAXPATHLEN, "%s/%s", smGD.savePath, sessionSaved);
1277     status = stat(smGD.fontPath, &buf);
1278     if(status == -1)
1279     {
1280         status = mkdir(smGD.fontPath, 0000);
1281         if(status == -1)
1282         {
1283             PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1284             smGD.fontPath[0] = 0;
1285             return(-1);
1286         }
1287         chmod(smGD.fontPath, 0755);
1288     }
1289
1290     /*
1291      * Now add the lang subdirectory and see if it exists
1292      */
1293     strncat(smGD.fontPath, "/", MAXPATHLEN);
1294     strncat(smGD.fontPath, langPtr, MAXPATHLEN);
1295     status = stat(smGD.fontPath, &buf);
1296     if(status == -1)
1297     {
1298         status = mkdir(smGD.fontPath, 0000);
1299         if(status == -1)
1300         {
1301             PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1302             smGD.fontPath[0] = 0;
1303             return(-1);
1304         }
1305         status = chmod(smGD.fontPath, 0755);
1306         if(status == -1)
1307           {
1308             PrintErrnoError(DtError, smNLS.cantCreateDirsString);
1309             smGD.fontPath[0] = 0;
1310             return(-1);
1311           }
1312     }
1313
1314     return(0);
1315 }
1316
1317
1318 \f
1319 /*************************************<->*************************************
1320  *
1321  *  RemoveFiles()
1322  *
1323  *
1324  *  Description:
1325  *  -----------
1326  *  Remove the files that need to be removed
1327  *
1328  *
1329  *  Inputs:
1330  *  ------
1331  *
1332  *  Outputs:
1333  *  -------
1334  *
1335  *
1336  *  Comments:
1337  *  --------
1338  *
1339  *************************************<->***********************************/
1340 static void
1341 RemoveFiles(
1342         char *path )
1343 {
1344     pid_t  clientFork;
1345     int    execStatus, childStatus, i, statLoc;
1346     String tmpString;
1347
1348     /*
1349      * Fork and exec the client process
1350      */
1351     sigaction(SIGCHLD, &smGD.defvec, (struct sigaction *) NULL);
1352
1353     clientFork = vfork();
1354
1355     /*
1356      * If the fork fails - Send out an error and return
1357      */
1358     if(clientFork < 0)
1359     {
1360         PrintErrnoError(DtError, smNLS.cantForkClientString);
1361         return;
1362     }
1363
1364     /*
1365      * Fork succeeded - now do the exec
1366      */
1367     if(clientFork == 0)
1368     {
1369         SetSIGPIPEToDefault ();
1370
1371         /*
1372          * Set the gid of the process back from bin
1373          */
1374 #ifndef __hpux
1375 #ifndef SVR4
1376         setregid(smGD.runningGID, smGD.runningGID);
1377 #else
1378         setgid(smGD.runningGID);
1379         setegid(smGD.runningGID);
1380 #endif
1381 #endif
1382
1383         _DtEnvControl(DT_ENV_RESTORE_PRE_DT);
1384
1385 #if defined(__osf__) || defined(CSRG_BASED)
1386         setsid();
1387 #else
1388         (void) setpgrp();
1389 #endif /* __osf__ */
1390
1391         execStatus = execlp("rm","rm", "-rf", path, (char *) 0);
1392         if(execStatus != 0)
1393         {
1394             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.")) ;
1395             PrintErrnoError(DtError, tmpString);
1396             SM_FREE(tmpString);
1397             SM_EXIT(-1);
1398         }
1399     }
1400
1401     while(wait(&statLoc) != clientFork);
1402
1403     sigaction(SIGCHLD, &smGD.childvec, (struct sigaction *) NULL);
1404 }
1405
1406 \f
1407 /*************************************<->*************************************
1408  *
1409  *  MoveDirectory()
1410  *
1411  *  Description:
1412  *  -----------
1413  *  Move the directory specified by pathFrom - to the directory specified
1414  *  by pathTo.
1415  *
1416  *  Inputs:
1417  *  ------
1418  *  pathFrom = the directory to move from
1419  *  pathTo = the directory to move to
1420  *  removeDestDir = if True, directory pathTo is removed before the
1421  *      move occurs
1422  *
1423  *  Outputs:
1424  *  -------
1425  *
1426  *  Comments:
1427  *  --------
1428  *
1429  *************************************<->***********************************/
1430 void
1431 MoveDirectory(
1432         char            *pathFrom,
1433         char            *pathTo,
1434         Boolean         removeDestDir)
1435 {
1436     struct stat buf;
1437     pid_t  clientFork;
1438     int    status, execStatus, childStatus, i, statLoc;
1439     String tmpString;
1440
1441     /*
1442      * If the pathTo directory exists - remove it
1443      */
1444     if (removeDestDir)
1445     {
1446         status = stat(pathTo, &buf);
1447         if(status != -1)
1448         {
1449             RemoveFiles(pathTo);
1450         }
1451     }
1452
1453     /*
1454      * Fork and exec the client process
1455      */
1456     sigaction(SIGCHLD, &smGD.defvec, (struct sigaction *) NULL);
1457
1458     clientFork = vfork();
1459
1460     /*
1461      * If the fork fails - Send out an error and return
1462      */
1463     if(clientFork < 0)
1464     {
1465         PrintErrnoError(DtError, smNLS.cantForkClientString);
1466         return;
1467     }
1468
1469     /*
1470      * Fork succeeded - now do the exec
1471      */
1472     if(clientFork == 0)
1473     {
1474         SetSIGPIPEToDefault ();
1475
1476         /*
1477          * Set the gid of the process back from bin
1478          */
1479 #ifndef __hpux
1480 #ifndef SVR4
1481         setregid(smGD.runningGID, smGD.runningGID);
1482 #else
1483         setgid(smGD.runningGID);
1484         setegid(smGD.runningGID);
1485 #endif
1486 #endif
1487
1488         _DtEnvControl(DT_ENV_RESTORE_PRE_DT);
1489
1490 #if defined(__osf__) || defined(CSRG_BASED)
1491         setsid();
1492 #else
1493         (void) setpgrp();
1494 #endif /* __osf__ */
1495
1496         execStatus = execlp("mv","mv", pathFrom, pathTo, (char *) 0);
1497         if(execStatus != 0)
1498         {
1499             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.")) ;
1500             PrintErrnoError(DtError, tmpString);
1501             SM_FREE(tmpString);
1502             SM_EXIT(-1);
1503         }
1504     }
1505
1506     while(wait(&statLoc) != clientFork);
1507
1508     sigaction(SIGCHLD, &smGD.childvec, (struct sigaction *) NULL);
1509 }
1510
1511
1512 \f
1513 /*************************************<->*************************************
1514  *
1515  *  InitNlsStrings()
1516  *
1517  *
1518  *  Description:
1519  *  -----------
1520  *  Initialize the NLS strings used in dtsession
1521  *
1522  *
1523  *  Inputs:
1524  *  ------
1525  *
1526  *  Outputs:
1527  *  -------
1528  *
1529  *
1530  *  Comments:
1531  *  --------
1532  *
1533  *************************************<->***********************************/
1534 void
1535 InitNlsStrings( void )
1536 {
1537     char        *tmpString;
1538
1539     /*
1540      * Malloc failure error message - THIS MESSAGE MUST BE INITIALIZED FIRST
1541      */
1542     smNLS.cantMallocErrorString = strdup (((char *)GETMESSAGE(4, 5, "Unable to malloc memory for operation.")));
1543
1544     /*
1545      * Error message when dtsession cant lock the display
1546      */
1547     smNLS.cantLockErrorString = strdup (((char *)GETMESSAGE(4, 6, "Unable to lock display.  Another application may have the pointer or keyboard grabbed.")));
1548
1549     /*
1550      * Error message when dtsession cant open files for reading or writing
1551      */
1552     smNLS.cantOpenFileString = strdup (((char *)GETMESSAGE(4, 7, "Unable to open session file.  No clients will be restarted.")));
1553
1554     /*
1555      * Error message when dtsession cant fork client process
1556      */
1557     smNLS.cantForkClientString = strdup (((char *)GETMESSAGE(4, 8, "Unable to fork client process.")));
1558
1559     /*
1560      * Error message when dtsession cant create dt directories
1561      */
1562     smNLS.cantCreateDirsString = strdup (((char *)GETMESSAGE(4, 9, "Unable to create DT directories.  Check permissions on home directory.")));
1563
1564     /*
1565      * Error message when trying to lock display on trusted system
1566      */
1567     smNLS.trustedSystemErrorString = strdup (((char *)GETMESSAGE(4, 10, "Unable to lock display due to security restrictions")));
1568 }
1569
1570
1571 \f
1572 /*************************************<->*************************************
1573  *
1574  *  WaitChildDeath()
1575  *
1576  *
1577  *  Description:
1578  *  -----------
1579  *  When a SIGCHLD signal comes in, wait for all child processes to die.
1580  *
1581  *
1582  *  Inputs:
1583  *  ------
1584  *
1585  *  Outputs:
1586  *  -------
1587  *
1588  *
1589  *  Comments:
1590  *  --------
1591  *
1592  *************************************<->***********************************/
1593
1594 void
1595 WaitChildDeath( int i )
1596 {
1597   int   stat_loc;
1598   pid_t pid;
1599
1600  /*
1601   * Wait on any children that have died since the last SIGCHLD we
1602   * received. Any child process death that occurs while we are
1603   * in WaitChildDeath() will not result in a SIGCHLD. Any
1604   * child proceses that die after our last call to waitpid() will
1605   * remain zombiefied until the next invocation of WaitChildDeath().
1606   */
1607   while ((pid = waitpid(-1, &stat_loc, WNOHANG)) > 0)
1608   ;
1609
1610   sigaction(SIGCHLD, &smGD.childvec, (struct sigaction *) NULL);
1611 }
1612
1613
1614 \f
1615 /*************************************<->*************************************
1616  *
1617  *  TrimErrorlog()
1618  *
1619  *
1620  *  Description:
1621  *  -----------
1622  *  Trim the errorlog file using the following algorithm:
1623  *      if(errorlog.old exists and is not empty) move it to errorlog.oldest
1624  *      if(errorlog exists and is not empty) move it to errorlog.old
1625  *
1626  *
1627  *  Inputs:
1628  *  ------
1629  *
1630  *  Outputs:
1631  *  -------
1632  *
1633  *
1634  *  Comments:
1635  *  --------
1636  *
1637  *************************************<->***********************************/
1638 static void
1639 TrimErrorlog( void )
1640 {
1641     char        *savePath,      /* common path element for all pathnames */
1642                 *checkPath1,
1643                 *checkPath2;
1644     struct stat buf;
1645     int len, status;
1646     char *home;
1647
1648     /*
1649      * Allocate the strings needed
1650      */
1651     savePath = (char *) SM_MALLOC(MAXPATHLEN + 1);
1652     checkPath1 = (char *) SM_MALLOC(MAXPATHLEN + 1);
1653     checkPath2 = (char *) SM_MALLOC(MAXPATHLEN + 1);
1654     if ((home=getenv("HOME")) == NULL)
1655         home="";
1656
1657     len = strlen(home) + strlen(DtPERSONAL_CONFIG_DIRECTORY) + 2;
1658     if (len > MAXPATHLEN) savePath = SM_REALLOC(savePath, len);
1659     snprintf(savePath, len - 1, "%s/%s", home, DtPERSONAL_CONFIG_DIRECTORY);
1660
1661     /*
1662      * If errorlog.old exists and it is not empty, delete
1663      * errorlog.older and then move errolog.old to
1664      * errorlog.older
1665      */
1666     if (len + strlen(DtOLDER_ERRORLOG_FILE) > MAXPATHLEN)
1667       checkPath1 = SM_REALLOC(savePath, len + strlen(DtOLDER_ERRORLOG_FILE));
1668     sprintf(checkPath1, "%s/%s", savePath, DtOLDER_ERRORLOG_FILE);
1669
1670     if (len + strlen(DtOLD_ERRORLOG_FILE) > MAXPATHLEN)
1671       checkPath2 = SM_REALLOC(savePath, len + strlen(DtOLD_ERRORLOG_FILE));
1672     sprintf(checkPath2, "%s/%s", savePath, DtOLD_ERRORLOG_FILE);
1673
1674     status = stat(checkPath2, &buf);
1675     if((status != -1) && (buf.st_size > 0))
1676     {
1677         (void) unlink(checkPath1);
1678         (void) link(checkPath2, checkPath1);
1679         (void) unlink(checkPath2);
1680     }
1681
1682     /*
1683      * If errorlog exists and it is not empty, move it to
1684      * errorlog.old
1685      */
1686     if (len + strlen(DtERRORLOG_FILE) > MAXPATHLEN)
1687       checkPath1 = SM_REALLOC(savePath, len + strlen(DtERRORLOG_FILE));
1688     sprintf(checkPath1, "%s/%s", savePath, DtERRORLOG_FILE);
1689
1690     status = stat(checkPath1, &buf);
1691     if((status != -1) && (buf.st_size > 0))
1692     {
1693         (void) link(checkPath1, checkPath2);
1694         (void) unlink(checkPath1);
1695     }
1696
1697     SM_FREE((char *) savePath);
1698     SM_FREE((char *) checkPath1);
1699     SM_FREE((char *) checkPath2);
1700
1701     return;
1702 }
1703
1704
1705 \f
1706 /*************************************<->*************************************
1707  *
1708  *  SetSystemReady()
1709  *
1710  *
1711  *  Description:
1712  *  -----------
1713  *  Do everything that needs to be done to get the system back into a
1714  *  READY state.  This includes checking to be sure that the BMS did not
1715  *  die while we were in process
1716  *
1717  *
1718  *  Inputs:
1719  *  ------
1720  *
1721  *  Outputs:
1722  *  -------
1723  *
1724  *
1725  *  Comments:
1726  *  --------
1727  *
1728  *************************************<->***********************************/
1729 void
1730 SetSystemReady( void )
1731 {
1732     smGD.smState = READY;
1733     if(smGD.bmsDead == True)
1734     {
1735         WarnMsgFailure();
1736     }
1737
1738     return;
1739 }
1740
1741
1742 /*************************************<->*************************************
1743  *
1744  *  SmCvtStringToContManagement (args, numArgs, fromVal, toVal)
1745  *
1746  *
1747  *  Description:
1748  *  -----------
1749  *  This function converts a string to a value for the
1750  *  contention management flag set.
1751  *
1752  *
1753  *  Inputs:
1754  *  ------
1755  *  args = additional XrmValue arguments to the converter - NULL here
1756  *
1757  *  numArgs = number of XrmValue arguments - 0 here
1758  *
1759  *  fromVal = resource value to convert
1760  *
1761  *
1762  *  Outputs:
1763  *  -------
1764  *  toVal = descriptor to use to return converted value
1765  *
1766  *************************************<->***********************************/
1767
1768 void SmCvtStringToContManagement (XrmValue *args, Cardinal numArgs, XrmValue *fromVal, XrmValue *toVal)
1769 {
1770
1771     unsigned char       *pch = (unsigned char *) (fromVal->addr);
1772     unsigned char       *pchNext;
1773     int         len;
1774     static long cval;
1775     Boolean     fHit = False;
1776     Boolean    fAddNext = True;
1777
1778 /*
1779  * Names of contention management options
1780  */
1781
1782 #define CM_ALL_STR              (unsigned char *)"all"
1783 #define CM_SYSTEM_STR           (unsigned char *)"system"
1784 #define CM_HANDSHAKE_STR        (unsigned char *)"handshake"
1785 #define CM_NONE_STR             (unsigned char *)"none"
1786
1787     /*
1788      * Check first token. If '-' we subtract from all options.
1789      * Otherwise, we start with no contention management and add things in.
1790      */
1791
1792     if (*pch &&
1793         (_DtNextToken (pch, &len, &pchNext)) &&
1794         (*pch == '-'))
1795     {
1796         cval = SM_CM_ALL;
1797         fHit = True;
1798     }
1799     else
1800     {
1801         cval = SM_CM_NONE;
1802     }
1803
1804     while (*pch && _DtNextToken (pch, &len, &pchNext))
1805     {
1806            /*
1807             * Strip off "sign" if prepended to another token, and process
1808             * that token the next time through.
1809             */
1810
1811         if (*pch == '+')
1812         {
1813             if (len != 1)
1814             {
1815                 pchNext = pch + 1;
1816             }
1817             fAddNext = TRUE;
1818         }
1819
1820         else if (*pch == '-')
1821         {
1822             if (len != 1)
1823             {
1824                 pchNext = pch + 1;
1825             }
1826             fAddNext = FALSE;
1827         }
1828
1829         if ((*pch == 'A') || (*pch == 'a'))
1830         {
1831             if (_DtWmStringsAreEqual (pch, CM_ALL_STR, len))
1832             {
1833                 cval = fAddNext ? (cval | SM_CM_ALL) :
1834                                   (cval & ~SM_CM_ALL);
1835                 fHit = True;
1836             }
1837         }
1838
1839         else if ((*pch == 'S') || (*pch == 's'))
1840         {
1841             if (_DtWmStringsAreEqual (pch, CM_SYSTEM_STR, len))
1842             {
1843                 cval = fAddNext ? (cval | SM_CM_SYSTEM) :
1844                                   (cval & ~SM_CM_SYSTEM);
1845                 fHit = True;
1846             }
1847         }
1848
1849         else if ((*pch == 'H') || (*pch == 'h'))
1850         {
1851             if (_DtWmStringsAreEqual (pch, CM_HANDSHAKE_STR, len))
1852             {
1853                 cval = fAddNext ? (cval | SM_CM_HANDSHAKE) :
1854                                   (cval & ~SM_CM_HANDSHAKE);
1855                 fHit = True;
1856             }
1857         }
1858
1859         else if ((*pch == 'N') || (*pch == 'n'))
1860         {
1861             if (_DtWmStringsAreEqual (pch, CM_NONE_STR, len))
1862             {
1863                 /* don't bother adding or subtracting nothing */
1864                 fHit = True;
1865             }
1866         }
1867
1868         pch = pchNext;
1869     }
1870
1871
1872
1873     /*
1874      * If we didn't match anything then set to default.
1875      */
1876     if (!fHit)
1877     {
1878         cval =  SM_CM_DEFAULT;
1879     }
1880
1881
1882     (*toVal).size = sizeof (long);
1883     (*toVal).addr = (caddr_t) &cval;
1884
1885
1886 } /* END OF FUNCTION SmCvtStringToContManagement */
1887
1888
1889 /*************************************<->*************************************
1890  *
1891  *  _DtNextToken (pchIn, pLen, ppchNext)
1892  *
1893  *
1894  *  Description:
1895  *  -----------
1896  *  XXDescription ...
1897  *
1898  *
1899  *  Inputs:
1900  *  ------
1901  *  pchIn = pointer to start of next token
1902  *
1903  *
1904  *  Outputs:
1905  *  -------
1906  *  pLen  =    pointer to integer containing number of characters in next token
1907  *  ppchNext = address of pointer to following token
1908  *
1909  *  Return =   next token or NULL
1910  *
1911  *
1912  *  Comments:
1913  *  --------
1914  *  None.
1915  *
1916  *************************************<->***********************************/
1917
1918 unsigned char *_DtNextToken (unsigned char *pchIn, int *pLen,
1919         unsigned char **ppchNext)
1920 {
1921     unsigned char *pchR = pchIn;
1922     register int   i;
1923
1924 #ifdef MULTIBYTE
1925     register int   chlen;
1926
1927     for (i = 0; ((chlen = mblen ((char *)pchIn, MB_CUR_MAX)) > 0); i++)
1928     /* find end of word: requires singlebyte whitespace terminator */
1929     {
1930         if ((chlen == 1) && isspace (*pchIn))
1931         {
1932             break;
1933         }
1934         pchIn += chlen;
1935     }
1936
1937 #else
1938     for (i = 0; *pchIn && !isspace (*pchIn); i++, pchIn++)
1939     /* find end of word */
1940     {
1941     }
1942 #endif
1943
1944     /* skip to next word */
1945     ScanWhitespace (&pchIn);
1946
1947     *ppchNext = pchIn;
1948     *pLen = i;
1949     if (i)
1950     {
1951         return(pchR);
1952     }
1953     else
1954     {
1955        return(NULL);
1956     }
1957
1958 } /* END OF FUNCTION _DtNextToken */
1959
1960
1961 \f
1962 /*************************************<->*************************************
1963  *
1964  *  _DtWmStringsAreEqual (pch1, pch2, len)
1965  *
1966  *
1967  *  Description:
1968  *  -----------
1969  *  XXDescription ...
1970  *
1971  *
1972  *  Inputs:
1973  *  ------
1974  *  pch1 =
1975  *  pch2 =
1976  *  len  =
1977  *
1978  *
1979  *  Outputs:
1980  *  -------
1981  *  Return = (Boolean) True iff strings match (case insensitive)
1982  *
1983  *
1984  *  Comments:
1985  *  --------
1986  *  None.
1987  *
1988  *************************************<->***********************************/
1989
1990 Boolean _DtWmStringsAreEqual (unsigned char *pch1, unsigned char *pch2, int len)
1991 {
1992 #ifdef MULTIBYTE
1993     int       chlen1;
1994     int       chlen2;
1995     wchar_t   wch1;
1996     wchar_t   wch2;
1997
1998     while (len  &&
1999            ((chlen1 = mbtowc (&wch1, (char *) pch1, 2)) > 0) &&
2000            ((chlen2 = mbtowc (&wch2, (char *) pch2, 2)) == chlen1) )
2001     {
2002         if (chlen1 == 1)
2003         /* singlebyte characters -- make case insensitive */
2004         {
2005             if ((isupper (*pch1) ? tolower(*pch1) : *pch1) !=
2006                 (isupper (*pch2) ? tolower(*pch2) : *pch2))
2007             {
2008                 break;
2009             }
2010         }
2011         else
2012         /* multibyte characters */
2013         {
2014             if (wch1 != wch2)
2015             {
2016                 break;
2017             }
2018         }
2019         pch1 += chlen1;
2020         pch2 += chlen2;
2021         len--;
2022     }
2023
2024 #else
2025     while (len  && *pch1 && *pch2 &&
2026            ((isupper (*pch1) ? tolower(*pch1) : *pch1) ==
2027             (isupper (*pch2) ? tolower(*pch2) : *pch2)))
2028     {
2029         *pch1++;
2030         *pch2++;
2031         len--;
2032     }
2033 #endif
2034
2035     return (len == 0);
2036
2037 } /* END OF _DtWmStringsAreEqual */
2038
2039 /*************************************<->*************************************
2040  *
2041  *  InitializeGenericSession - set the smGD paths using the CDE 1.0
2042  *       session starting algorithm.
2043  *
2044  *  Description:
2045  *  -----------
2046  *  Initializes several variables in smGD
2047  *
2048  *  Inputs:
2049  *  ------
2050  *  tmpDisplay
2051  *
2052  *  Outputs:
2053  *  -------
2054  *  Return = void
2055  *
2056  *  Comments:
2057  *  --------
2058  *
2059  *************************************<->***********************************/
2060 static void
2061 InitializeGenericSession (
2062         Display         *tmpDisplay)
2063 {
2064     struct      stat buf;
2065     int         session_needed = 1;
2066     int         status;
2067     char        tmpPath[MAXPATHLEN];
2068
2069     smGD.savePath = _DtCreateDtDirs(tmpDisplay);
2070
2071     if (session_needed)
2072     {
2073       strcpy(smGD.clientPath, smGD.savePath);
2074       strcat(smGD.clientPath, "/");
2075       strcat(smGD.clientPath, SM_CURRENT_DIRECTORY);
2076       strcat(smGD.clientPath, "/");
2077       strcpy (tmpPath, smGD.clientPath);
2078       strcat(smGD.clientPath, SM_CLIENT_FILE2);
2079
2080       status = stat(smGD.clientPath, &buf);
2081
2082       if (status != 0) {
2083          strcpy (smGD.clientPath, tmpPath);
2084          strcat (smGD.clientPath, SM_CLIENT_FILE);
2085          status = stat(smGD.clientPath, &buf);
2086       }
2087
2088       if(status == 0)
2089       {
2090        /*
2091         * sessions/current/dt.settings exist, restore to 'current' session
2092         */
2093         strcpy(smGD.resourcePath, smGD.savePath);
2094         strcat(smGD.resourcePath, "/");
2095         strcat(smGD.resourcePath, SM_CURRENT_DIRECTORY);
2096         strcat(smGD.resourcePath, "/");
2097         strcat(smGD.resourcePath, SM_RESOURCE_FILE);
2098         strcpy(smGD.settingPath, smGD.savePath);
2099         strcat(smGD.settingPath, "/");
2100         strcat(smGD.settingPath, SM_CURRENT_DIRECTORY);
2101         strcat(smGD.settingPath, "/");
2102         strcat(smGD.settingPath, SM_SETTING_FILE);
2103         SetResSet();
2104         smGD.sessionType = CURRENT_SESSION;
2105         smGD.restoreSession = (char *) SM_CURRENT_DIRECTORY;
2106         session_needed = 0;
2107       }
2108     }
2109
2110     if (session_needed)
2111     {
2112       strcpy(smGD.clientPath, smGD.savePath);
2113       strcat(smGD.clientPath, "/");
2114       strcat(smGD.clientPath, SM_HOME_DIRECTORY);
2115       strcat(smGD.clientPath, "/");
2116       strcpy(tmpPath, smGD.clientPath);
2117       strcat(smGD.clientPath, SM_CLIENT_FILE2);
2118
2119       status = stat(smGD.clientPath, &buf);
2120
2121       if (status != 0) {
2122          strcpy (smGD.clientPath, tmpPath);
2123          strcat (smGD.clientPath, SM_CLIENT_FILE);
2124          status = stat(smGD.clientPath, &buf);
2125       }
2126
2127       if(status == 0)
2128       {
2129        /*
2130         * sessions/home/dt.settings exist, restore to 'home' session
2131         */
2132         strcpy(smGD.resourcePath, smGD.savePath);
2133         strcat(smGD.resourcePath, "/");
2134         strcat(smGD.resourcePath, SM_HOME_DIRECTORY);
2135         strcat(smGD.resourcePath, "/");
2136         strcat(smGD.resourcePath, SM_RESOURCE_FILE);
2137         strcpy(smGD.settingPath, smGD.savePath);
2138         strcat(smGD.settingPath, "/");
2139         strcat(smGD.settingPath, SM_HOME_DIRECTORY);
2140         strcat(smGD.settingPath, "/");
2141         strcat(smGD.settingPath, SM_SETTING_FILE);
2142         SetResSet();
2143         smGD.sessionType = HOME_SESSION;
2144         smGD.restoreSession = (char *) SM_HOME_DIRECTORY;
2145         session_needed = 0;
2146       }
2147     }
2148
2149     if (session_needed)
2150     {
2151       SetSysDefaults();
2152     }
2153 }
2154
2155 /*************************************<->*************************************
2156  *
2157  *  InternSessionDir - intern the session dir property and put it
2158  *     on the root window
2159  *
2160  *     NOTE: - also checks the validity of the -session command line
2161  *         option
2162  *
2163  *  Inputs:
2164  *  ------
2165  *  session_option - as given in the command line
2166  *  display
2167  *
2168  *  Outputs:
2169  *  ------
2170  *  smGD.restoreSession - initialized
2171  *
2172  *  Return = void
2173  *
2174  *************************************<->***********************************/
2175 static Boolean
2176 InternSessionDir (
2177         char            *session_option,
2178         Display         *disp)
2179 {
2180         char            *pch;
2181
2182         if (!strcmp (session_option, SM_CURRENT_DIRECTORY)) {
2183                 pch = DtSM_SESSION_DIRECTORY;
2184                 smGD.restoreSession = SM_CURRENT_DIRECTORY;
2185         }
2186         else if (!strcmp (session_option, SM_HOME_DIRECTORY)) {
2187                 pch = DtSM_SESSION_DIRECTORY;
2188                 smGD.restoreSession = SM_HOME_DIRECTORY;
2189         }
2190         else if (!strcmp (session_option, SM_DISPLAY_HOME)) {
2191                 pch = DtSM_SESSION_DISPLAY_DIRECTORY;
2192                 smGD.restoreSession = SM_HOME_DIRECTORY;
2193         }
2194         else if (!strcmp (session_option, SM_DISPLAY_CURRENT)) {
2195                 pch = DtSM_SESSION_DISPLAY_DIRECTORY;
2196                 smGD.restoreSession = SM_CURRENT_DIRECTORY;
2197         }
2198         else
2199                 /*
2200                  * The session_option is not supported
2201                  */
2202                 return (False);
2203
2204         XaSmRestoreDir = XInternAtom(disp, _XA_DT_RESTORE_DIR, False);
2205
2206         XChangeProperty(disp, RootWindow(disp, 0),
2207                 XaSmRestoreDir, XA_STRING, 8, PropModeReplace,
2208                 (unsigned char *)pch, strlen(pch));
2209
2210         XFlush(disp);
2211
2212
2213         return (True);
2214 }
2215
2216
2217 /*************************************<->*************************************
2218  *
2219  *  InitializeSpecificSession - set the smGD paths based on the session
2220  *       name given on the command line.
2221  *
2222  *  Description:
2223  *  -----------
2224  *  Initializes several variables in smGD
2225  *
2226  *  Inputs:
2227  *  ------
2228  *  session_option
2229  *  tmpDisplay
2230  *
2231  *  Outputs:
2232  *  -------
2233  *  Return = void
2234  *
2235  *  Comments:
2236  *  --------
2237  *
2238  *************************************<->***********************************/
2239 static Boolean
2240 InitializeSpecificSession (
2241         char            *session_option,
2242         Display         *disp,
2243         unsigned int    argc,
2244         char            **argv)
2245 {
2246         char            *session_dir = (char *) XtMalloc(MAXPATHLEN);
2247         char            *alt_dir = (char *) XtMalloc(MAXPATHLEN);
2248         int             len;
2249         struct stat     buf;
2250
2251         if (!InternSessionDir (session_option, disp))
2252                 return (False);
2253
2254         InitializePaths (smGD.restoreSession, disp);
2255
2256         if (!strcmp (session_option, SM_HOME_DIRECTORY)) {
2257                 /*
2258                  * Home session
2259                  */
2260                 if (smGD.clientPath[0] == '\0') {
2261                         if ((stat (smGD.savePath, &buf)) != 0) {
2262                                 if ((mkdir (smGD.savePath, 0000)) == 0)
2263                                         (void) chmod (smGD.savePath, 0755);
2264                                 else
2265                                         PrintErrnoError(DtError,
2266                                                 smNLS.cantCreateDirsString);
2267                         }
2268                         SetSysDefaults ();
2269                 }
2270                 smGD.sessionType = HOME_SESSION;
2271                 smGD.restoreSession = SM_HOME_DIRECTORY;
2272         }
2273         else if (!strcmp (session_option, SM_CURRENT_DIRECTORY)) {
2274                 /*
2275                  * Current session
2276                  */
2277                 if (smGD.clientPath[0] == '\0') {
2278                         /*
2279                          * Fallback to the generic home session
2280                          */
2281                         (void) sprintf (session_dir, "%s/%s",
2282                                         smGD.savePath, SM_CURRENT_DIRECTORY);
2283                         (void) sprintf (alt_dir, "%s/%s",
2284                                         smGD.savePath, SM_HOME_DIRECTORY);
2285
2286                         if (!SetAlternateSession (session_dir, alt_dir, True))
2287                                 SetSysDefaults ();
2288                 }
2289                 smGD.sessionType = CURRENT_SESSION;
2290                 smGD.restoreSession = SM_CURRENT_DIRECTORY;
2291         }
2292         else if (!strcmp (session_option, SM_DISPLAY_HOME)) {
2293                 /*
2294                  * Display-specific Home session
2295                  */
2296                 (void) sprintf (session_dir, "%s/%s",
2297                                 smGD.savePath, SM_HOME_DIRECTORY);
2298
2299                 if ((stat(session_dir, &buf)) != 0){
2300                         /*
2301                          * The session does not exist, give the user a
2302                          * change to exit.
2303                          */
2304                         if (!ConfirmSessionCreation (HOME_SESSION, argc, argv))
2305                                 SM_EXIT (0);
2306
2307                 }
2308
2309                 if (smGD.clientPath[0] == '\0') {
2310                         /*
2311                          * Fallback to the generic home session
2312                          */
2313                         char            *home;
2314
2315                         if ((home = getenv ("HOME")) == 0)
2316                                 home = "";
2317
2318                         /* JET - VU#497553 */
2319                         len = strlen(home) +
2320                           strlen(DtPERSONAL_CONFIG_DIRECTORY) +
2321                           strlen(DtSM_SESSION_DIRECTORY) +
2322                           strlen(SM_HOME_DIRECTORY);
2323
2324                         if (len > MAXPATHLEN)
2325                           alt_dir = XtRealloc(alt_dir, len + 1);
2326
2327                         (void) sprintf (alt_dir, "%s/%s/%s/%s",
2328                                         home,
2329                                         DtPERSONAL_CONFIG_DIRECTORY,
2330                                         DtSM_SESSION_DIRECTORY,
2331                                         SM_HOME_DIRECTORY);
2332                         if (!SetAlternateSession (session_dir, alt_dir, True))
2333                                 SetSysDefaults ();
2334                 }
2335                 smGD.sessionType = HOME_SESSION;
2336                 smGD.restoreSession = SM_HOME_DIRECTORY;
2337         }
2338         else if (!strcmp (session_option, SM_DISPLAY_CURRENT)) {
2339                 /*
2340                  * Display-specific Current session
2341                  */
2342                 (void) sprintf (session_dir, "%s/%s",
2343                                 smGD.savePath, SM_CURRENT_DIRECTORY);
2344
2345                 if ((stat(session_dir, &buf)) != 0){
2346                         /*
2347                          * The session does not exist, give the user a
2348                          * change to exit.
2349                          */
2350                         if (!ConfirmSessionCreation (CURRENT_SESSION, argc, argv))
2351                                 SM_EXIT (0);
2352                 }
2353
2354                 if (smGD.clientPath[0] == '\0') {
2355                         /*
2356                          * First, fallback to the display-specific home session
2357                          */
2358                         char            *home;
2359
2360                         (void) sprintf (alt_dir, "%s/%s",
2361                                         smGD.savePath, SM_HOME_DIRECTORY);
2362
2363                         if (!SetAlternateSession (session_dir, alt_dir, False)){
2364                                 /*
2365                                  * Try the generic home session
2366                                  */
2367                                 if ((home = getenv ("HOME")) == 0)
2368                                         home = "";
2369
2370                                 /* JET - VU#497553 */
2371                                 len = strlen(home) +
2372                                   strlen(DtPERSONAL_CONFIG_DIRECTORY) +
2373                                   strlen(DtSM_SESSION_DIRECTORY) +
2374                                   strlen(SM_HOME_DIRECTORY);
2375
2376                                 if (len > MAXPATHLEN)
2377                                   alt_dir = XtRealloc(alt_dir, len + 1);
2378
2379                                 snprintf(alt_dir, len, "%s/%s/%s/%s",
2380                                          home,
2381                                          DtPERSONAL_CONFIG_DIRECTORY,
2382                                          DtSM_SESSION_DIRECTORY,
2383                                          SM_HOME_DIRECTORY);
2384
2385                                 if (!SetAlternateSession (session_dir,
2386                                                           alt_dir,
2387                                                           True))
2388                                         SetSysDefaults ();
2389                         }
2390                 }
2391                 smGD.sessionType = CURRENT_SESSION;
2392                 smGD.restoreSession = SM_CURRENT_DIRECTORY;
2393         }
2394         else {
2395                 if (session_dir) XtFree(session_dir);
2396                 if (alt_dir) XtFree(alt_dir);
2397                 return (False);
2398         }
2399
2400         if (session_dir) XtFree(session_dir);
2401         if (alt_dir) XtFree(alt_dir);
2402         return (True);
2403 }
2404
2405
2406 /*************************************<->*************************************
2407  *
2408  *  InitializePaths
2409  *
2410  *  Description:
2411  *  -----------
2412  *  Initializes the following variables:
2413  *
2414  *     smGD.savePath
2415  *     smGD.settingsPath
2416  *     smGD.resourcePath
2417  *     smGD.clientPath - [0] = '\0' if the database files do not exist
2418  *
2419  *  Inputs:
2420  *  ------
2421  *  session_name = "current" or "home"
2422  *
2423  *  Outputs:
2424  *  -------
2425  *  Return = void
2426  *
2427  *  Comments:
2428  *  --------
2429  *
2430  *************************************<->***********************************/
2431 static void
2432 InitializePaths (
2433         char            * session_name,
2434         Display         * disp)
2435 {
2436         char            *db_file = (char *) XtMalloc(MAXPATHLEN);
2437         struct stat     buf;
2438
2439         if (!db_file)
2440           {
2441             PrintError(DtError, smNLS.cantMallocErrorString);
2442             return;
2443           }
2444
2445         smGD.savePath = _DtCreateDtDirs(disp);
2446
2447         (void) sprintf (smGD.settingPath, "%s/%s/%s",
2448                         smGD.savePath, session_name, SM_SETTING_FILE);
2449
2450         (void) sprintf (smGD.resourcePath, "%s/%s/%s",
2451                         smGD.savePath, session_name, SM_RESOURCE_FILE);
2452
2453
2454         smGD.clientPath[0] = '\0';
2455
2456         (void) sprintf (db_file, "%s/%s/%s",
2457                         smGD.savePath, session_name, SM_CLIENT_FILE2);
2458
2459         if ((stat(db_file, &buf)) == 0)
2460                 (void) strcpy (smGD.clientPath, db_file);
2461         else {
2462                 (void) sprintf (db_file, "%s/%s/%s",
2463                                 smGD.savePath, session_name, SM_CLIENT_FILE);
2464                 if ((stat(db_file, &buf)) == 0)
2465                         (void) strcpy (smGD.clientPath, db_file);
2466         }
2467         XtFree(db_file);
2468 }
2469
2470
2471 /*************************************<->*************************************
2472  *
2473  *  SetAlternateSession
2474  *
2475  *  Assumptions:
2476  *
2477  *     Neither of the client databases in the session_dir directory
2478  *     exist.
2479  *
2480  *  Inputs:
2481  *  ------
2482  *  session_dir - the directory path for the session including home
2483  *     or current
2484  *  alt_dir - the directory to use in the search for an alternate
2485  *     or fallback session database
2486  *  make_dir - if True, a session_dir will be created if it does not
2487  *     exits; if False, session_dir will not be created
2488  *
2489  *  Outputs:
2490  *  -------
2491  *  Return = Boolean
2492  *
2493  *************************************<->***********************************/
2494 static Boolean
2495 SetAlternateSession (
2496         char            * session_dir,
2497         char            * alt_dir,
2498         Boolean         make_dir)
2499 {
2500         char            *tmp_dir = NULL;
2501         char            *db_file1 = (char *) XtMalloc(MAXPATHLEN);
2502         char            *db_file2 = (char *) XtMalloc(MAXPATHLEN);
2503         struct stat     buf;
2504
2505         if (!db_file1 || !db_file2)
2506           {
2507             PrintError(DtError, smNLS.cantMallocErrorString);
2508             return False;
2509           }
2510
2511
2512         if ((stat (session_dir, &buf)) != 0) {
2513                 /*
2514                  * The requested dir does not exist, create it
2515                  * by either copying the session from alt_dir (if
2516                  * it exists and has a client database) or by
2517                  * calling mkdir.
2518                  */
2519
2520                 (void) sprintf (db_file1, "%s/%s",
2521                                 alt_dir, SM_CLIENT_FILE2);
2522                 (void) sprintf (db_file2, "%s/%s",
2523                                 alt_dir, SM_CLIENT_FILE);
2524
2525                 if ((stat(db_file1, &buf)) == 0)
2526                         tmp_dir = db_file1;
2527                 else if ((stat(db_file2, &buf)) == 0)
2528                         tmp_dir = db_file2;
2529
2530                 if (!tmp_dir && !make_dir) {
2531                         if (db_file1) XtFree(db_file1);
2532                         if (db_file2) XtFree(db_file2);
2533                         /*
2534                          * This alt_dir doesn't have a session database
2535                          * return now and try another directory
2536                          */
2537                         return (False);
2538                 }
2539
2540                 if (tmp_dir) {
2541                         /*
2542                          * The alt_dir has a session database, create
2543                          * a copy of its entire directory because all
2544                          * of the sessions state is needed.
2545                          */
2546                         char            *tmp;
2547
2548                         tmp = XtMalloc (strlen (alt_dir) +
2549                                         strlen (session_dir) + 10);
2550                         if (!tmp)
2551                                 return (False);
2552
2553                         (void) sprintf (tmp, "cp -r %s %s",
2554                                         alt_dir, session_dir);
2555
2556                         if ((system (tmp)) == -1)
2557                                 return (False);
2558                         XtFree (tmp);
2559
2560                         if ((stat(session_dir, &buf)) != 0)
2561                                 /*
2562                                  * It should have been created by the cp
2563                                  */
2564                                 return (False);
2565
2566                         /*
2567                          * The session database needs to be updated.
2568                          */
2569                         if (tmp_dir == db_file1)
2570                                 sprintf (smGD.clientPath, "%s/%s",
2571                                         session_dir, SM_CLIENT_FILE2);
2572                         else
2573                                 sprintf (smGD.clientPath, "%s/%s",
2574                                         session_dir, SM_CLIENT_FILE);
2575                 } else {
2576                         /*
2577                          * The alt_dir did not have a session database.
2578                          * Create a directory and load the system defaults
2579                          */
2580                         if ((mkdir (session_dir, 0000)) == 0)
2581                                 (void) chmod (session_dir, 0755);
2582                         else {
2583                                 PrintErrnoError(DtError,
2584                                         smNLS.cantCreateDirsString);
2585                                 return (False);
2586                         }
2587                         SetSysDefaults ();
2588                 }
2589         } else {
2590                 /*
2591                  * The directory for the specified session exists
2592                  * but it doesn't have any client databases.  Start
2593                  * a new user session.  If a user wants a sesssion
2594                  * with no apps, they should create a zero-length
2595                  * session database.
2596                  */
2597                 SetSysDefaults ();
2598         }
2599
2600         XtFree(db_file1);
2601         XtFree(db_file2);
2602         return (True);
2603 }
2604
2605
2606 void
2607 SmExit (
2608         int             exitStatus)
2609 {
2610   /* JET - needed to rework this to avoid exiting before we are
2611    *  *really* ready to
2612    */
2613   if (smGD.ExitComplete)
2614     {
2615       if (smXSMP.saveState.saveComplete &&
2616           smXSMP.saveState.shutdown &&
2617           !smXSMP.saveState.shutdownCanceled)
2618         XSMPExit ();
2619       exit(exitStatus);
2620     }
2621   else
2622     return;
2623 }
2624
2625 void
2626 SetSIGPIPEToDefault ()
2627 {
2628         struct sigaction pipeSig;
2629
2630         sigemptyset(&pipeSig.sa_mask);
2631         pipeSig.sa_flags = 0;
2632         pipeSig.sa_handler = SIG_DFL;
2633         (void) sigaction(SIGPIPE, &pipeSig, (struct sigaction *) NULL);
2634 }