cde/programs/dtfile/ModAttr.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: ModAttr.c /main/11 1999/12/09 13:07:05 mgreess $ */
  24 /************************************<+>*************************************
  25  ****************************************************************************
  26  *
  27  *   FILE:           ModAttr.c
  28  *
  29  *   COMPONENT_NAME: Desktop File Manager (dtfile)
  30  *
  31  *   Description:    Source file for the modify file attributes dialog.
  32  *
  33  *   FUNCTIONS: Create
  34  *              Destroy
  35  *              FreeValues
  36  *              GetDefaultValues
  37  *              GetModAttrValues
  38  *              GetResourceValues
  39  *              GetValues
  40  *              InstallChange
  41  *              InstallClose
  42  *              InvalidModAttrMessage
  43  *              LoadFileAttributes
  44  *              OkCallback
  45  *              SetValues
  46  *              WriteResourceValues
  47  *              _LoadFileAttributes
  48  *              displayFSDialog
  49  *
  50  *   (c) Copyright 1993, 1994, 1995 Hewlett-Packard Company
  51  *   (c) Copyright 1993, 1994, 1995 International Business Machines Corp.
  52  *   (c) Copyright 1993, 1994, 1995 Sun Microsystems, Inc.
  53  *   (c) Copyright 1993, 1994, 1995 Novell, Inc.
  54  *
  55  ****************************************************************************
  56  ************************************<+>*************************************/
  57
  58 #include <stdio.h>
  59 #include <errno.h>
  60 #include <time.h>
  61 #include <sys/types.h>
  62 #include <sys/stat.h>
  63 #include <unistd.h>
  64 #include <limits.h>
  65 #include <grp.h>
  66 #include <pwd.h>
  67
  68 #include <Xm/XmP.h>
  69 #include <Xm/BulletinB.h>
  70 #include <Xm/CascadeBG.h>
  71 #include <Xm/DialogS.h>
  72 #include <Xm/Frame.h>
  73 #include <Xm/Form.h>
  74 #include <Xm/LabelG.h>
  75 #include <Xm/MessageB.h>
  76 #include <Xm/PushBG.h>
  77 #include <Xm/RowColumn.h>
  78 #include <Xm/ScrolledW.h>
  79 #include <Xm/TextF.h>
  80 #include <Xm/ToggleBG.h>
  81 #include <Xm/SeparatoG.h>
  82 #include <Xm/VendorSEP.h>
  83 #include <Xm/MwmUtil.h>
  84 #include <Xm/Protocols.h>
  85
  86 #include <Dt/Icon.h>
  87 #include <Dt/IconP.h>
  88 #include <Dt/IconFile.h>
  89 #include <Dt/TitleBox.h>
  90 #include <Dt/Dts.h>
  91 #include <Dt/SharedProcs.h>
  92
  93 #include <X11/ShellP.h>
  94 #include <X11/Shell.h>
  95 #include <X11/Xatom.h>
  96
  97 #include <Dt/Connect.h>
  98 #include <Dt/DtNlUtils.h>
  99
 100 #include <Tt/tttk.h>
 101
 102 #include "Encaps.h"
 103 #include "SharedProcs.h"
 104 #include "FileMgr.h"
 105 #include "Desktop.h"
 106 #include "Main.h"
 107 #include "Common.h"
 108 #include "ModAttr.h"
 109 #include "Help.h"
 110
 111 #ifndef CDE_INSTALLATION_TOP
 112 #define CDE_INSTALLATION_TOP "/usr/dt"
 113 #endif
 114
 115 /* Error message defines */
 116
 117 #define UNKNOWN_USER      0
 118 #define UNKNOWN_GROUP     1
 119
 120
 121 /* Field defines */
 122 #define HOST       0x01
 123 #define DIR        0x02
 124 #define NAME       0x04
 125 #define FILETYPE   0x08
 126 #define GROUP      0x10
 127 #define OWNER      0x20
 128 #define BITS       0x40
 129 #define SIZE       0x80
 130 #define MODTIME    0x100
 131
 132 #define GMA_VALID           0
 133 #define GMA_INVALID         1
 134 #define GMA_NO_FILE         2
 135
 136 #define ALL_FIELDS       HOST|DIR|NAME|FILETYPE|GROUP|OWNER|BITS|SIZE|MODTIME
 137 #define ALL_BUT_ACCESS   HOST|DIR|NAME|FILETYPE|GROUP|OWNER|SIZE|MODTIME
 138 #define ALL_BUT_OWNER_GROUP_ACCESS    HOST|DIR|NAME|FILETYPE|SIZE|MODTIME
 139
 140 #define FM_TYPE_LABEL  "TYPE_LABEL"
 141
 142 static char * MODIFY_ATTR = "ModifyAttributes";
 143 ModAttrApply *globalApplyData;
 144 char *parentDir;
 145
 146 /*  Resource definitions for the modify file attribute dialog  */
 147
 148 static DialogResource resources[] =
 149 {
 150    { "host", XmRString, sizeof(String),
 151      XtOffset(ModAttrDataPtr, host),
 152      (XtPointer) NULL, _DtStringToString },
 153
 154    { "directory", XmRString, sizeof(String),
 155      XtOffset(ModAttrDataPtr, directory),
 156      (XtPointer) NULL, _DtStringToString },
 157
 158    { "name", XmRString, sizeof(String),
 159      XtOffset(ModAttrDataPtr, name),
 160      (XtPointer) NULL, _DtStringToString },
 161
 162    { "link_name", XmRString, sizeof(String),
 163      XtOffset(ModAttrDataPtr, link_name),
 164      (XtPointer) NULL, _DtStringToString },
 165
 166    { "access", XmRInt, sizeof(int),
 167      XtOffset(ModAttrDataPtr, accessBits),
 168      (XtPointer) 0, _DtIntToString },
 169 };
 170
 171
 172 /********    Static Function Declarations    ********/
 173
 174 static void Create(
 175                         Display *display,
 176                         Widget parent,
 177                         Widget *return_widget,
 178                         XtPointer *dialog) ;
 179 static void InstallChange(
 180                         ModAttrRec *modAttr_rec,
 181                         XtCallbackProc callback,
 182                         XtPointer client_data) ;
 183 static void InstallClose(
 184                         ModAttrRec *modAttr_rec,
 185                         XtCallbackProc callback,
 186                         XtPointer client_data) ;
 187 static void Destroy(
 188                         ModAttrRec *modAttr_rec) ;
 189 static XtPointer GetValues(
 190                         ModAttrRec *modAttr_rec) ;
 191 static XtPointer GetDefaultValues( void ) ;
 192 static XtPointer GetResourceValues(
 193                         XrmDatabase data_base,
 194                         char **name_list) ;
 195 static void SetValues(
 196                         ModAttrRec *modAttr_rec,
 197                         ModAttrData *modAttr_data) ;
 198 static void WriteResourceValues(
 199                         DialogData *values,
 200                         int fd,
 201                         char **name_list) ;
 202 static void FreeValues(
 203                         ModAttrData *modAttr_data) ;
 204 static void OkCallback(
 205                         Widget w,
 206                         ModAttrApply *apply_data,
 207                         XtPointer call_data) ;
 208 static short GetModAttrValues(
 209                         ModAttrRec *modAttr_rec,
 210                         ModAttrData *modAttr_data,
 211                         Boolean validate) ;
 212 static void InvalidModAttrMessage(
 213                         Widget w,
 214                         int messageIndex) ;
 215 static Boolean _LoadFileAttributes(
 216                         String host,
 217                         String dir,
 218                         String file,
 219                         ModAttrData *modAttr_data,
 220                         unsigned long mask) ;
 221 static void displayFSDialog(
 222                             Widget                        w,
 223                             dtFSData                    * fileSystem,
 224                             XmPushButtonCallbackStruct  * cbs);
 225 static void DontChangeCB(
 226                         Widget w,
 227                         XtPointer client_data,
 228                         XtPointer call_data );
 229 static void ChangeCB(
 230                         Widget w,
 231                         XtPointer client_data,
 232                         XtPointer call_data );
 233
 234 /********    End Static Function Declarations    ********/
 235
 236
 237 /*
 238  *  The Dialog Class structure.
 239  */
 240 static DialogClass modAttrClassRec =
 241 {
 242    resources,
 243    XtNumber(resources),
 244    Create,
 245    (DialogInstallChangeProc) InstallChange,
 246    (DialogInstallCloseProc) InstallClose,
 247    (DialogDestroyProc) Destroy,
 248    (DialogGetValuesProc) GetValues,
 249    GetDefaultValues,
 250    GetResourceValues,
 251    (DialogSetValuesProc) SetValues,
 252    WriteResourceValues,
 253    (DialogFreeValuesProc) FreeValues,
 254    (DialogMapWindowProc) _DtGenericMapWindow,
 255    NULL,
 256 };
 257
 258 DialogClass * modAttrClass = (DialogClass *) &modAttrClassRec;
 259
 260 /************************************************************************
 261  *
 262  *  Create
 263  *
 264  ************************************************************************/
 265
 266 static void
 267 Create(
 268         Display *display,
 269         Widget parent,
 270         Widget *return_widget,
 271         XtPointer *dialog )
 272 {
 273    ModAttrRec * modAttr_rec;
 274    Widget shell, form, nameLabel, name;
 275    Widget link_label, link_name;
 276    Widget fileType, ownerLabel, owner;
 277    Widget groupLabel, group, permissionLabel, permissionForm;
 278    Widget ownerPLabel, groupPLabel, otherPLabel;
 279    Widget readLabel, writeLabel, executeLabel;
 280    Widget ownerRead, ownerWrite, ownerExecute;
 281    Widget groupRead, groupWrite, groupExecute;
 282    Widget otherRead, otherWrite, otherExecute;
 283    Widget fsPushButton, fsWarning;
 284    Widget sizeLabel, size;
 285    Widget modLabel, mod;
 286    Widget groupL, ownerL;
 287    Widget separator, ok, cancel, help;
 288    XmString label_string;
 289    XmString empty_label_string;
 290    Arg args[15];
 291    int n;
 292    char * tmpStr;
 293    Dimension len[2];
 294    int flag=FLAG_RESET;
 295
 296
 297    /*  Allocate the modify file attributes dialog instance record.  */
 298
 299    modAttr_rec = (ModAttrRec *) XtMalloc (sizeof (ModAttrRec));
 300
 301    /*  Create the shell form used for the dialog.  */
 302
 303    n = 0;
 304    XtSetArg (args[n], XmNmwmFunctions, MWM_FUNC_MOVE |
 305              MWM_FUNC_CLOSE);                                           ++n;
 306    XtSetArg (args[n], XmNmwmDecorations, MWM_DECOR_BORDER |
 307              MWM_DECOR_TITLE);                                          ++n;
 308    XtSetArg (args[n], XmNallowShellResize, True);                       ++n;
 309    shell = XmCreateDialogShell (parent, "file_properties", args, n);
 310
 311    /* Set the useAsyncGeo on the shell */
 312    XtSetArg (args[0], XmNuseAsyncGeometry, True);
 313    XtSetValues (XtParent(shell), args, 1);
 314
 315    n = 0;
 316    XtSetArg (args[n], XmNshadowThickness, 1);                   n++;
 317    XtSetArg (args[n], XmNshadowType, XmSHADOW_OUT);             n++;
 318    XtSetArg (args[n], XmNautoUnmanage, False);                  n++;
 319    form = XmCreateForm (shell, "form", args, n);
 320    XtAddCallback(form, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 321                  HELP_PROPERTIES_DIALOG_STR);
 322
 323
 324    /* Create the field displaying the selected file name */
 325
 326    label_string = XmStringCreateLocalized (((char *) GETMESSAGE(21,30, "Name: ")));
 327    n = 0;
 328    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 329    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 330    XtSetArg (args[n], XmNleftOffset, 5);                        n++;
 331    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
 332    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
 333    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 334    nameLabel = XmCreateLabelGadget (form, "file_name_label", args, n);
 335    XtManageChild (nameLabel);
 336    XmStringFree (label_string);
 337    XtAddCallback(nameLabel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 338                  HELP_PROPERTIES_DIALOG_STR);
 339
 340    n = 0;
 341    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);      n++;
 342    XtSetArg (args[n], XmNleftWidget, nameLabel);                n++;
 343    XtSetArg (args[n], XmNleftOffset, 0);                        n++;
 344    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
 345    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
 346    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 347    name = XmCreateLabelGadget (form, "file_name", args, n);
 348    XtManageChild (name);
 349    XtAddCallback(name, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 350                  HELP_PROPERTIES_DIALOG_STR);
 351
 352    /* Create the optional field displaying the symbolic link name */
 353
 354    label_string = XmStringCreateLocalized ((GETMESSAGE(21,18, "Is Linked To: ")));
 355    n = 0;
 356    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 357    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 358    XtSetArg (args[n], XmNleftOffset, 5);                        n++;
 359    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 360    XtSetArg (args[n], XmNtopWidget, name);                      n++;
 361    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
 362    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 363    link_label= XmCreateLabelGadget (form, "link_name_label", args, n);
 364    XtManageChild (link_label);
 365    XmStringFree (label_string);
 366    XtAddCallback(link_label, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 367                  HELP_PROPERTIES_DIALOG_STR);
 368
 369    n = 0;
 370    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);      n++;
 371    XtSetArg (args[n], XmNleftWidget, link_label);               n++;
 372    XtSetArg (args[n], XmNleftOffset, 0);                        n++;
 373    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 374    XtSetArg (args[n], XmNtopWidget, name);                      n++;
 375    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
 376    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 377    link_name = XmCreateLabelGadget (form, "link_name", args, n);
 378    XtManageChild (link_name);
 379    XtAddCallback(link_name, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 380                  HELP_PROPERTIES_DIALOG_STR);
 381
 382
 383    /* Create the field displaying the owner name and the group name*/
 384
 385    label_string = XmStringCreateLocalized (((char *)
 386                GETMESSAGE(21, 3, "Owner Name: ")));
 387    n = 0;
 388    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 389    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 390    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 391    XtSetArg (args[n], XmNtopWidget, link_name);                 n++;
 392    XtSetArg (args[n], XmNtopOffset, 15);                        n++;
 393    XtSetArg (args[n], XmNleftOffset, 5);                        n++;
 394    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 395    ownerLabel = XmCreateLabelGadget (form, "owner_name", args, n);
 396    XtManageChild (ownerLabel);
 397    XmStringFree (label_string);
 398    XtAddCallback(ownerLabel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 399                  HELP_PROPERTIES_DIALOG_STR);
 400
 401    label_string = XmStringCreateLocalized (((char *)
 402                GETMESSAGE(21, 4, "Group Name: ")));
 403    n = 0;
 404    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 405    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 406    XtSetArg (args[n], XmNleftOffset, 5);                        n++;
 407    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 408    XtSetArg (args[n], XmNtopWidget, ownerLabel);                n++;
 409    XtSetArg (args[n], XmNtopOffset, 22);                        n++;
 410    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 411    groupLabel = XmCreateLabelGadget (form, "group_name", args, n);
 412    XtManageChild (groupLabel);
 413    XmStringFree (label_string);
 414    XtAddCallback(groupLabel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 415                  HELP_PROPERTIES_DIALOG_STR);
 416
 417    XtSetArg (args[0], XmNwidth, &len[0]);
 418    XtGetValues(ownerLabel, args, 1);
 419    XtSetArg (args[0], XmNwidth, &len[1]);
 420    XtGetValues(groupLabel, args, 1);
 421
 422    n = 0;
 423    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);      n++;
 424    if(len[0] > len[1]) {
 425        XtSetArg (args[n], XmNleftWidget, ownerLabel);           n++;
 426    }
 427    else {
 428        XtSetArg (args[n], XmNleftWidget, groupLabel);           n++;
 429    }
 430    XtSetArg (args[n], XmNleftOffset, 0);                        n++;
 431    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 432    XtSetArg (args[n], XmNtopWidget, link_name);                 n++;
 433    XtSetArg (args[n], XmNtopOffset, 8);                         n++;
 434    owner = XmCreateTextField (form, "owner_text", args, n);
 435    XtManageChild (owner);
 436    XtAddCallback(owner, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 437                  HELP_PROPERTIES_DIALOG_STR);
 438
 439    n = 0;
 440    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);      n++;
 441    if(len[0] > len[1]) {
 442        XtSetArg (args[n], XmNleftWidget, ownerLabel);           n++;
 443    }
 444    else {
 445        XtSetArg (args[n], XmNleftWidget, groupLabel);           n++;
 446    }
 447    XtSetArg (args[n], XmNleftOffset, 5);                        n++;
 448    XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET);    n++;
 449    XtSetArg (args[n], XmNtopWidget, ownerLabel);                n++;
 450    XtSetArg (args[n], XmNtopOffset, 0);                         n++;
 451    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 452    ownerL = XmCreateLabelGadget (form, "owner_textL", args, n);
 453    XtAddCallback(ownerL, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 454                  HELP_PROPERTIES_DIALOG_STR);
 455
 456    n = 0;
 457    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);      n++;
 458    if(len[0] > len[1]) {
 459        XtSetArg (args[n], XmNleftWidget, ownerLabel);           n++;
 460    }
 461    else {
 462        XtSetArg (args[n], XmNleftWidget, groupLabel);           n++;
 463    }
 464    XtSetArg (args[n], XmNleftOffset, 0);                        n++;
 465    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 466    XtSetArg (args[n], XmNtopWidget, ownerLabel);                n++;
 467    XtSetArg (args[n], XmNtopOffset, 15);                        n++;
 468    group = XmCreateTextField (form, "group_text", args, n);
 469    XtManageChild (group);
 470    XtAddCallback(group, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 471                  HELP_PROPERTIES_DIALOG_STR);
 472
 473    n = 0;
 474    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);      n++;
 475    if(len[0] > len[1]) {
 476        XtSetArg (args[n], XmNleftWidget, ownerLabel);           n++;
 477    }
 478    else {
 479        XtSetArg (args[n], XmNleftWidget, groupLabel);           n++;
 480    }
 481    XtSetArg (args[n], XmNleftOffset, 5);                        n++;
 482    XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET);    n++;
 483    XtSetArg (args[n], XmNtopWidget, groupLabel);                n++;
 484    XtSetArg (args[n], XmNtopOffset, 0);                         n++;
 485    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 486    groupL = XmCreateLabelGadget (form, "group_textL", args, n);
 487    XtAddCallback(groupL, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 488                  HELP_PROPERTIES_DIALOG_STR);
 489
 490    /* Create the field displaying the file type info */
 491
 492    n = 0;
 493    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 494    XtSetArg (args[n], XmNtopWidget, link_name);                 n++;
 495    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
 496    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);      n++;
 497    XtSetArg (args[n], XmNleftWidget, owner);                    n++;
 498    XtSetArg (args[n], XmNleftOffset, 20);                       n++;
 499    XtSetArg (args[n], XmNshadowThickness, 2);                   n++;
 500    XtSetArg (args[n], XmNshadowType, XmSHADOW_ETCHED_IN);       n++;
 501    XtSetArg (args[n], XmNhighlightThickness, 5);                n++;
 502    XtSetArg (args[n], XmNmarginWidth, 4);                       n++;
 503    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
 504    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 505    XtSetArg (args[n], XmNpixmapPosition, XmPIXMAP_TOP);         n++;
 506    XtSetArg (args[n], XmNbehavior, XmICON_LABEL);               n++;
 507    fileType = _DtCreateIcon (form, "file_type", args, n);
 508    XtManageChild (fileType);
 509    XtAddCallback(fileType, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 510                  HELP_PROPERTIES_DIALOG_STR);
 511
 512    /* Create the label for the permissions */
 513
 514    label_string = XmStringCreateLocalized (((char *)
 515                GETMESSAGE(21, 5, "Permissions:")));
 516    n = 0;
 517    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 518    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 519    XtSetArg (args[n], XmNleftOffset, 5);                        n++;
 520    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 521    XtSetArg (args[n], XmNtopWidget, groupLabel);                n++;
 522    XtSetArg (args[n], XmNtopOffset, 15);                        n++;
 523    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 524    permissionLabel = XmCreateLabelGadget (form, "permission_label", args, n);
 525    XtManageChild (permissionLabel);
 526    XmStringFree (label_string);
 527    XtAddCallback(permissionLabel, XmNhelpCallback,
 528                  (XtCallbackProc)HelpRequestCB,
 529                  HELP_PROPERTIES_DIALOG_STR);
 530
 531    /* Create the box containing the permission settings */
 532
 533    n = 0;
 534    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 535    XtSetArg (args[n], XmNleftOffset, 10);                       n++;
 536    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);       n++;
 537    XtSetArg (args[n], XmNrightOffset, 5);                       n++;
 538    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 539    XtSetArg (args[n], XmNtopWidget, permissionLabel);           n++;
 540    XtSetArg (args[n], XmNtopOffset, 3);                         n++;
 541    XtSetArg (args[n], XmNshadowThickness, 2);                   n++;
 542    XtSetArg (args[n], XmNshadowType, XmSHADOW_IN);              n++;
 543    permissionForm = XmCreateForm (form, "permission_form", args, n);
 544    XtManageChild (permissionForm);
 545    XtAddCallback(permissionForm, XmNhelpCallback,
 546                  (XtCallbackProc)HelpRequestCB,
 547                  HELP_PROPERTIES_DIALOG_STR);
 548
 549    /* Create the labels and toggles for the permissions */
 550
 551    label_string = XmStringCreateLocalized (((char *)
 552                GETMESSAGE(21, 6, "Read")));
 553    n = 0;
 554    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 555    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 556    XtSetArg (args[n], XmNleftPosition, 20);                     n++;
 557    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
 558    XtSetArg (args[n], XmNrightPosition, 45);                    n++;
 559    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
 560    XtSetArg (args[n], XmNtopOffset, 10);                        n++;
 561    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 562    readLabel = XmCreateLabelGadget (permissionForm, "read_label", args, n);
 563    XtManageChild (readLabel);
 564    XmStringFree (label_string);
 565    XtAddCallback(readLabel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 566                  HELP_PROPERTIES_DIALOG_STR);
 567
 568    label_string = XmStringCreateLocalized (((char *)
 569                GETMESSAGE(21, 7, "Write")));
 570    n = 0;
 571    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 572    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 573    XtSetArg (args[n], XmNleftPosition, 45);                     n++;
 574    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
 575    XtSetArg (args[n], XmNrightPosition, 70);                    n++;
 576    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
 577    XtSetArg (args[n], XmNtopOffset, 10);                        n++;
 578    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 579    writeLabel = XmCreateLabelGadget (permissionForm, "write_label", args, n);
 580    XtManageChild (writeLabel);
 581    XmStringFree (label_string);
 582    XtAddCallback(writeLabel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 583                  HELP_PROPERTIES_DIALOG_STR);
 584
 585    label_string = XmStringCreateLocalized (((char *)
 586                GETMESSAGE(21, 8, "Execute")));
 587    n = 0;
 588    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 589    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 590    XtSetArg (args[n], XmNleftPosition, 70);                     n++;
 591    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
 592    XtSetArg (args[n], XmNrightPosition, 95);                    n++;
 593    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
 594    XtSetArg (args[n], XmNtopOffset, 10);                        n++;
 595    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 596    executeLabel = XmCreateLabelGadget(permissionForm, "execute_label", args, n);
 597    XtAddCallback(executeLabel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 598                  HELP_PROPERTIES_DIALOG_STR);
 599    XtManageChild (executeLabel);
 600    XmStringFree (label_string);
 601
 602    label_string = XmStringCreateLocalized (((char *)
 603                GETMESSAGE(21, 9, "Owner:")));
 604    n = 0;
 605    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 606    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 607    XtSetArg (args[n], XmNleftPosition, 5);                      n++;
 608    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 609    XtSetArg (args[n], XmNtopWidget, readLabel);                 n++;
 610    XtSetArg (args[n], XmNtopOffset, 10);                        n++;
 611    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 612    ownerPLabel = XmCreateLabelGadget (permissionForm, "owner_label", args, n);
 613    XtManageChild (ownerPLabel);
 614    XmStringFree (label_string);
 615    XtAddCallback(ownerPLabel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 616                  HELP_PROPERTIES_DIALOG_STR);
 617
 618    empty_label_string = XmStringCreateLocalized ("");
 619    n = 0;
 620    XtSetArg (args[n], XmNlabelString, empty_label_string);              n++;
 621    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 622    XtSetArg (args[n], XmNleftPosition, 30);                             n++;
 623    XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET);      n++;
 624    XtSetArg (args[n], XmNtopWidget, ownerPLabel);                       n++;
 625    XtSetArg (args[n], XmNtopOffset, 0);                                 n++;
 626    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);   n++;
 627    XtSetArg (args[n], XmNbottomWidget, ownerPLabel);                    n++;
 628    XtSetArg (args[n], XmNshadowThickness, 0);                           n++;
 629    ownerRead =
 630          XmCreateToggleButtonGadget (permissionForm, "owner_read", args, n);
 631    XtManageChild (ownerRead);
 632    XtAddCallback(ownerRead, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 633                  HELP_PROPERTIES_DIALOG_STR);
 634
 635    n = 0;
 636    XtSetArg (args[n], XmNlabelString, empty_label_string);              n++;
 637    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 638    XtSetArg (args[n], XmNleftPosition, 54);                             n++;
 639    XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET);      n++;
 640    XtSetArg (args[n], XmNtopWidget, ownerPLabel);                       n++;
 641    XtSetArg (args[n], XmNtopOffset, 0);                                 n++;
 642    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);   n++;
 643    XtSetArg (args[n], XmNbottomWidget, ownerPLabel);                    n++;
 644    XtSetArg (args[n], XmNshadowThickness, 0);                           n++;
 645    ownerWrite =
 646          XmCreateToggleButtonGadget (permissionForm, "owner_write", args, n);
 647    XtManageChild (ownerWrite);
 648    XtAddCallback(ownerWrite, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 649                  HELP_PROPERTIES_DIALOG_STR);
 650
 651    n = 0;
 652    XtSetArg (args[n], XmNlabelString, empty_label_string);              n++;
 653    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 654    XtSetArg (args[n], XmNleftPosition, 78);                             n++;
 655    XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET);      n++;
 656    XtSetArg (args[n], XmNtopWidget, ownerPLabel);                       n++;
 657    XtSetArg (args[n], XmNtopOffset, 0);                                 n++;
 658    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);   n++;
 659    XtSetArg (args[n], XmNbottomWidget, ownerPLabel);                    n++;
 660    XtSetArg (args[n], XmNshadowThickness, 0);                           n++;
 661    ownerExecute =
 662       XmCreateToggleButtonGadget (permissionForm, "owner_execute", args, n);
 663    XtManageChild (ownerExecute);
 664    XtAddCallback(ownerExecute, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 665                  HELP_PROPERTIES_DIALOG_STR);
 666
 667    label_string = XmStringCreateLocalized (((char *)
 668                GETMESSAGE(21, 10, "Group:")));
 669    n = 0;
 670    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 671    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 672    XtSetArg (args[n], XmNleftPosition, 5);                      n++;
 673    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 674    XtSetArg (args[n], XmNtopWidget, ownerPLabel);               n++;
 675    XtSetArg (args[n], XmNtopOffset, 10);                        n++;
 676    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 677    groupPLabel = XmCreateLabelGadget (permissionForm, "group_label", args, n);
 678    XtManageChild (groupPLabel);
 679    XmStringFree (label_string);
 680    XtAddCallback(groupPLabel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 681                  HELP_PROPERTIES_DIALOG_STR);
 682
 683    n = 0;
 684    XtSetArg (args[n], XmNlabelString, empty_label_string);              n++;
 685    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 686    XtSetArg (args[n], XmNleftPosition, 30);                             n++;
 687    XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET);      n++;
 688    XtSetArg (args[n], XmNtopWidget, groupPLabel);                       n++;
 689    XtSetArg (args[n], XmNtopOffset, 0);                                 n++;
 690    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);   n++;
 691    XtSetArg (args[n], XmNbottomWidget, groupPLabel);                    n++;
 692    XtSetArg (args[n], XmNshadowThickness, 0);                           n++;
 693    groupRead =
 694           XmCreateToggleButtonGadget (permissionForm, "group_read", args, n);
 695    XtManageChild (groupRead);
 696    XtAddCallback(groupRead, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 697                  HELP_PROPERTIES_DIALOG_STR);
 698
 699    n = 0;
 700    XtSetArg (args[n], XmNlabelString, empty_label_string);              n++;
 701    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 702    XtSetArg (args[n], XmNleftPosition, 54);                             n++;
 703    XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET);      n++;
 704    XtSetArg (args[n], XmNtopWidget, groupPLabel);                       n++;
 705    XtSetArg (args[n], XmNtopOffset, 0);                                 n++;
 706    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);   n++;
 707    XtSetArg (args[n], XmNbottomWidget, groupPLabel);                    n++;
 708    XtSetArg (args[n], XmNshadowThickness, 0);                           n++;
 709    groupWrite =
 710         XmCreateToggleButtonGadget (permissionForm, "group_write", args, n);
 711    XtManageChild (groupWrite);
 712    XtAddCallback(groupWrite, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 713                  HELP_PROPERTIES_DIALOG_STR);
 714
 715    n = 0;
 716    XtSetArg (args[n], XmNlabelString, empty_label_string);              n++;
 717    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 718    XtSetArg (args[n], XmNleftPosition, 78);                             n++;
 719    XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET);      n++;
 720    XtSetArg (args[n], XmNtopWidget, groupPLabel);                       n++;
 721    XtSetArg (args[n], XmNtopOffset, 0);                                 n++;
 722    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);   n++;
 723    XtSetArg (args[n], XmNbottomWidget, groupPLabel);                    n++;
 724    XtSetArg (args[n], XmNshadowThickness, 0);                           n++;
 725    groupExecute =
 726          XmCreateToggleButtonGadget (permissionForm, "group_execute", args, n);
 727    XtManageChild (groupExecute);
 728    XtAddCallback(groupExecute, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 729                  HELP_PROPERTIES_DIALOG_STR);
 730
 731    label_string = XmStringCreateLocalized (((char *)
 732                GETMESSAGE(21, 11, "Other:")));
 733    n = 0;
 734    XtSetArg (args[n], XmNlabelString, label_string);                    n++;
 735    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 736    XtSetArg (args[n], XmNleftPosition, 5);                              n++;
 737    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);               n++;
 738    XtSetArg (args[n], XmNtopWidget, groupPLabel);                       n++;
 739    XtSetArg (args[n], XmNtopOffset, 10);                                n++;
 740    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);              n++;
 741    XtSetArg (args[n], XmNbottomOffset, 15);                             n++;
 742    XtSetArg (args[n], XmNtraversalOn, False);                           n++;
 743    otherPLabel = XmCreateLabelGadget (permissionForm, "other_label", args, n);
 744    XtManageChild (otherPLabel);
 745    XmStringFree (label_string);
 746    XtAddCallback(otherPLabel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 747                  HELP_PROPERTIES_DIALOG_STR);
 748
 749    n = 0;
 750    XtSetArg (args[n], XmNlabelString, empty_label_string);              n++;
 751    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 752    XtSetArg (args[n], XmNleftPosition, 30);                             n++;
 753    XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET);      n++;
 754    XtSetArg (args[n], XmNtopWidget, otherPLabel);                       n++;
 755    XtSetArg (args[n], XmNtopOffset, 0);                                 n++;
 756    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);   n++;
 757    XtSetArg (args[n], XmNbottomWidget, otherPLabel);                    n++;
 758    XtSetArg (args[n], XmNshadowThickness, 0);                           n++;
 759    otherRead =
 760          XmCreateToggleButtonGadget (permissionForm, "other_read", args, n);
 761    XtManageChild (otherRead);
 762    XtAddCallback(otherRead, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 763                  HELP_PROPERTIES_DIALOG_STR);
 764
 765    n = 0;
 766    XtSetArg (args[n], XmNlabelString, empty_label_string);              n++;
 767    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 768    XtSetArg (args[n], XmNleftPosition, 54);                             n++;
 769    XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET);      n++;
 770    XtSetArg (args[n], XmNtopWidget, otherPLabel);                       n++;
 771    XtSetArg (args[n], XmNtopOffset, 0);                                 n++;
 772    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);   n++;
 773    XtSetArg (args[n], XmNbottomWidget, otherPLabel);                    n++;
 774    XtSetArg (args[n], XmNshadowThickness, 0);                           n++;
 775    otherWrite =
 776         XmCreateToggleButtonGadget (permissionForm, "other_write", args, n);
 777    XtManageChild (otherWrite);
 778    XtAddCallback(otherWrite, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 779                  HELP_PROPERTIES_DIALOG_STR);
 780
 781    n = 0;
 782    XtSetArg (args[n], XmNlabelString, empty_label_string);              n++;
 783    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);            n++;
 784    XtSetArg (args[n], XmNleftPosition, 78);                             n++;
 785    XtSetArg (args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET);      n++;
 786    XtSetArg (args[n], XmNtopWidget, otherPLabel);                       n++;
 787    XtSetArg (args[n], XmNtopOffset, 0);                                 n++;
 788    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);   n++;
 789    XtSetArg (args[n], XmNbottomWidget, otherPLabel);                    n++;
 790    XtSetArg (args[n], XmNshadowThickness, 0);                           n++;
 791    otherExecute =
 792       XmCreateToggleButtonGadget (permissionForm, "other_execute", args, n);
 793    XtManageChild (otherExecute);
 794    XmStringFree (empty_label_string);
 795    XtAddCallback(otherExecute, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 796                  HELP_PROPERTIES_DIALOG_STR);
 797
 798
 799    /* Create the optional label and push button to invoke a file-system specific dialog */
 800    /* Bottom and top attachments will be made when we know which of these widgets will be mannaged */
 801    /* The callback will be registered in SetValues after the config file has been read */
 802
 803    n = 0;
 804    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 805    XtSetArg (args[n], XmNleftPosition, 5);                      n++;
 806    fsWarning = XmCreateLabelGadget (permissionForm, "fs_warning_label",
 807                                             args, n);
 808
 809    n = 0;
 810    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 811    XtSetArg (args[n], XmNleftPosition, 5);                      n++;
 812    fsPushButton = XmCreatePushButtonGadget (permissionForm, "fs_dialog_button",
 813                                             args, n);
 814
 815
 816
 817    /* Create the field displaying the size */
 818
 819    label_string = XmStringCreateLocalized (((char *)
 820            GETMESSAGE(21, 12, "Size (in bytes): ")));
 821    n = 0;
 822    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 823    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 824    XtSetArg (args[n], XmNtopWidget, permissionForm);            n++;
 825    XtSetArg (args[n], XmNtopOffset, 10);                        n++;
 826    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 827    XtSetArg (args[n], XmNleftOffset, 5);                        n++;
 828    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 829    sizeLabel = XmCreateLabelGadget (form, "size_label", args, n);
 830    XtManageChild (sizeLabel);
 831    XmStringFree (label_string);
 832    XtAddCallback(sizeLabel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 833                  HELP_PROPERTIES_DIALOG_STR);
 834
 835    n = 0;
 836    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);      n++;
 837    XtSetArg (args[n], XmNleftWidget, sizeLabel);                n++;
 838    XtSetArg (args[n], XmNleftOffset, 0);                        n++;
 839    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 840    XtSetArg (args[n], XmNtopWidget, permissionForm);            n++;
 841    XtSetArg (args[n], XmNtopOffset, 10);                        n++;
 842    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 843    size = XmCreateLabelGadget (form, "size", args, n);
 844    XtManageChild (size);
 845    XtAddCallback(size, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 846                  HELP_PROPERTIES_DIALOG_STR);
 847
 848
 849    /* Create the field displaying the modification time */
 850
 851    label_string = XmStringCreateLocalized (((char *)
 852              GETMESSAGE(21, 13, "Modified: ")));
 853    n = 0;
 854    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 855    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);      n++;
 856    XtSetArg (args[n], XmNleftWidget, size);                     n++;
 857    XtSetArg (args[n], XmNleftOffset, 20);                       n++;
 858    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 859    XtSetArg (args[n], XmNtopWidget, permissionForm);            n++;
 860    XtSetArg (args[n], XmNtopOffset, 10);                        n++;
 861    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 862    modLabel = XmCreateLabelGadget (form, "modify_date_label", args, n);
 863    XtManageChild (modLabel);
 864    XmStringFree (label_string);
 865    XtAddCallback(modLabel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 866                  HELP_PROPERTIES_DIALOG_STR);
 867
 868    n = 0;
 869    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);      n++;
 870    XtSetArg (args[n], XmNleftOffset, 0);                        n++;
 871    XtSetArg (args[n], XmNleftWidget, modLabel);                 n++;
 872    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 873    XtSetArg (args[n], XmNtopWidget, permissionForm);            n++;
 874    XtSetArg (args[n], XmNtopOffset, 10);                        n++;
 875    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 876    mod = XmCreateLabelGadget (form, "modify_date", args, n);
 877    XtManageChild (mod);
 878    XtAddCallback(mod, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 879                  HELP_PROPERTIES_DIALOG_STR);
 880
 881
 882    /*  Create a separator between the buttons  */
 883
 884    n = 0;
 885    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 886    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);       n++;
 887    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 888    XtSetArg (args[n], XmNtopWidget, sizeLabel);                 n++;
 889    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
 890    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 891    separator =  XmCreateSeparatorGadget (form, "separator", args, n);
 892    XtManageChild (separator);
 893
 894    /*  Create the ok, cancel and help buttons  */
 895
 896    n = 0;
 897    XtSetArg (args[n], XmNlabelString, okXmString);              n++;
 898    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 899    XtSetArg (args[n], XmNleftPosition, 2);                      n++;
 900    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
 901    XtSetArg (args[n], XmNrightPosition, 32);                    n++;
 902    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 903    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
 904    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
 905    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
 906    XtSetArg (args[n], XmNbottomOffset, 5);                      n++;
 907    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
 908    XtSetArg (args[n], XmNuserData, flag);                        n++;
 909    ok = XmCreatePushButtonGadget (form, "ok", args, n);
 910    XtManageChild (ok);
 911    XtAddCallback(ok, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 912                  HELP_PROPERTIES_DIALOG_STR);
 913
 914
 915    /* Set the default action */
 916    XtSetArg (args[0], XmNdefaultButton, ok);
 917    XtSetValues (form, args, 1);
 918
 919
 920    n = 0;
 921    XtSetArg (args[n], XmNlabelString, cancelXmString);          n++;
 922    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 923    XtSetArg (args[n], XmNleftPosition, 35);                     n++;
 924    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
 925    XtSetArg (args[n], XmNrightPosition, 65);                    n++;
 926    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 927    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
 928    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
 929    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
 930    XtSetArg (args[n], XmNbottomOffset, 5);                      n++;
 931    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
 932    XtSetArg (args[n], XmNuserData, flag);                        n++;
 933    cancel = XmCreatePushButtonGadget (form, "cancel", args, n);
 934    XtManageChild (cancel);
 935    XtAddCallback(cancel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 936                  HELP_PROPERTIES_DIALOG_STR);
 937
 938
 939    n = 0;
 940    XtSetArg (args[n], XmNlabelString, helpXmString);            n++;
 941    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 942    XtSetArg (args[n], XmNleftPosition, 68);                     n++;
 943    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
 944    XtSetArg (args[n], XmNrightPosition, 98);                    n++;
 945    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 946    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
 947    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
 948    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
 949    XtSetArg (args[n], XmNbottomOffset, 5);                      n++;
 950    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
 951    help = XmCreatePushButtonGadget (form, "help", args, n);
 952    XtManageChild (help);
 953    XtAddCallback(help, XmNactivateCallback, (XtCallbackProc)HelpRequestCB,
 954                  HELP_PROPERTIES_DIALOG_STR);
 955    XtAddCallback(help, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 956                  HELP_PROPERTIES_DIALOG_STR);
 957
 958
 959    XtSetArg (args[0], XmNcancelButton, cancel);
 960    XtSetValues (form, args, 1);
 961
 962    /* Fill in our instance structure */
 963
 964    modAttr_rec->shell = shell;
 965    modAttr_rec->bboard = form;
 966    modAttr_rec->name = name;
 967    modAttr_rec->link_name = link_name;
 968    modAttr_rec->link_label = link_label;
 969    modAttr_rec->fileType = fileType;
 970    modAttr_rec->owner_label = ownerLabel;
 971    modAttr_rec->owner = owner;
 972    modAttr_rec->group = group;
 973    modAttr_rec->ownerL = ownerL;
 974    modAttr_rec->groupL = groupL;
 975    modAttr_rec->ownerRead = ownerRead;
 976    modAttr_rec->ownerWrite = ownerWrite;
 977    modAttr_rec->ownerExecute = ownerExecute;
 978    modAttr_rec->groupRead = groupRead;
 979    modAttr_rec->groupWrite = groupWrite;
 980    modAttr_rec->groupExecute = groupExecute;
 981    modAttr_rec->otherRead = otherRead;
 982    modAttr_rec->otherWrite = otherWrite;
 983    modAttr_rec->otherExecute = otherExecute;
 984    modAttr_rec->otherPLabel = otherPLabel;
 985    modAttr_rec->fsWarning = fsWarning;
 986    modAttr_rec->fsPushButton = fsPushButton;
 987    modAttr_rec->size = size;
 988    modAttr_rec->modTime = mod;
 989    modAttr_rec->ok = ok;
 990    modAttr_rec->cancel = cancel;
 991    modAttr_rec->help = help;
 992
 993
 994    /*  Set the return values for the dialog widget and dialog instance.  */
 995
 996    *return_widget = form;
 997    *dialog = (XtPointer) modAttr_rec;
 998 }
 999
1000
1001
1002
1003 /************************************************************************
1004  *
1005  *  InstallChange
1006  *
1007  ************************************************************************/
1008
1009 static void
1010 InstallChange(
1011         ModAttrRec *modAttr_rec,
1012         XtCallbackProc callback,
1013         XtPointer client_data )
1014 {
1015    ModAttrApply * apply_data;
1016
1017
1018    /*  Setup the callback data to be sent to the Ok callback.   */
1019    /*  This contains the encapsulation callback to invoke upon  */
1020    /*  the data within the dialog being changed.                */
1021
1022    apply_data = (ModAttrApply *) XtMalloc (sizeof (ModAttrApply));
1023    apply_data->callback = callback;
1024    apply_data->client_data = client_data;
1025    apply_data->modAttr_rec = (XtPointer) modAttr_rec;
1026    modAttr_rec->apply_data = apply_data;
1027
1028
1029    XtAddCallback (modAttr_rec->ok, XmNactivateCallback,
1030                   (XtCallbackProc)OkCallback, (XtPointer) apply_data);
1031 }
1032
1033
1034
1035
1036 /************************************************************************
1037  *
1038  *  InstallClose
1039  *
1040  ************************************************************************/
1041
1042 static void
1043 InstallClose(
1044         ModAttrRec *modAttr_rec,
1045         XtCallbackProc callback,
1046         XtPointer client_data )
1047 {
1048    Atom delete_window_atom;
1049
1050    XtAddCallback (modAttr_rec->cancel,
1051                   XmNactivateCallback, callback, client_data);
1052
1053    /* This callback is removed in SetValues if the config file does  */
1054    /* not include a dismiss=yes directive. Thus for some filesystems */
1055    /* you can Cancel the regular permissions dialog when the fs      */
1056    /* dialog button is pressed (e.g. for DFS?) or you can let the    */
1057    /* the regular permissions dialog stay on screen along with the   */
1058    /* fs-specfic dialog.                                             */
1059   if (modAttr_rec->fsPushButton != NULL)
1060       XtAddCallback (modAttr_rec->fsPushButton,
1061                      XmNactivateCallback, callback, client_data);
1062
1063    delete_window_atom = XmInternAtom (XtDisplay(modAttr_rec->shell),
1064                                       "WM_DELETE_WINDOW", True);
1065    XmRemoveWMProtocols( modAttr_rec->shell, &delete_window_atom, 1 );
1066    XmAddWMProtocolCallback( modAttr_rec->shell, delete_window_atom, callback,
1067                             (XtPointer) client_data );
1068 }
1069
1070
1071
1072
1073 /************************************************************************
1074  *
1075  *  Destroy
1076  *
1077  ************************************************************************/
1078
1079 static void
1080 Destroy(
1081         ModAttrRec *modAttr_rec )
1082 {
1083    XtDestroyWidget (modAttr_rec->shell);
1084    XtFree ((char *) modAttr_rec->apply_data);
1085    XtFree ((char *) modAttr_rec);
1086 }
1087
1088
1089
1090
1091 /************************************************************************
1092  *
1093  *  GetValues
1094  *
1095  ************************************************************************/
1096
1097 static XtPointer
1098 GetValues(
1099         ModAttrRec *modAttr_rec )
1100 {
1101    ModAttrData * modAttr_data;
1102
1103
1104    /*  Allocate and initialize the modify file attribute dialog data.  */
1105
1106    modAttr_data = (ModAttrData *) XtCalloc (1, sizeof (ModAttrData));
1107
1108    modAttr_data->displayed = True;
1109
1110    (void) GetModAttrValues(modAttr_rec, modAttr_data, False);
1111
1112    return ((XtPointer) modAttr_data);
1113 }
1114
1115
1116
1117
1118 /************************************************************************
1119  *
1120  *  GetDefaultValues
1121  *
1122  ************************************************************************/
1123
1124 static XtPointer
1125 GetDefaultValues( void )
1126 {
1127    ModAttrData * modAttr_data;
1128
1129
1130    /*  Allocate and initialize the default file attribute dialog data.  */
1131
1132    modAttr_data = (ModAttrData *) XtCalloc (1, sizeof (ModAttrData));
1133
1134    modAttr_data->displayed = False;
1135    modAttr_data->x = 0;
1136    modAttr_data->y = 0;
1137    modAttr_data->height = 0;
1138    modAttr_data->width = 0;
1139
1140    modAttr_data->name = NULL;
1141    modAttr_data->link_name = NULL;
1142    modAttr_data->filetype = NULL;
1143    modAttr_data->pixmapData = NULL;
1144    modAttr_data->owner = NULL;
1145    modAttr_data->group = NULL;
1146    modAttr_data->accessBits = 0;
1147    modAttr_data->setuidBits = 0;
1148    modAttr_data->size = 0;
1149    modAttr_data->modTime = time(NULL);
1150    modAttr_data->host = NULL;
1151    modAttr_data->directory = NULL;
1152
1153    return ((XtPointer) modAttr_data);
1154 }
1155
1156
1157
1158
1159 /************************************************************************
1160  *
1161  *  GetResourceValues
1162  *
1163  ************************************************************************/
1164
1165 static XtPointer
1166 GetResourceValues(
1167         XrmDatabase data_base,
1168         char **name_list )
1169 {
1170
1171    /* We are not using this code so we commented it out for now */
1172
1173
1174    ModAttrData * modAttr_data;
1175    String host, directory, name;
1176
1177
1178    /*  Allocate and get the resources for modify file attrs dialog data.  */
1179
1180    modAttr_data = (ModAttrData *) XtCalloc (1, sizeof (ModAttrData));
1181
1182    _DtDialogGetResources (data_base, name_list, MODIFY_ATTR, (char *)modAttr_data,
1183                        resources, modAttrClass->resource_count);
1184
1185
1186    modAttr_data->link_name = XtNewString(modAttr_data->link_name);
1187
1188    /*
1189     * Since the other fields are dynamic, use the obtained name to
1190     * stat the file, and use the current values.  If the file no
1191     * longer exists, then return the default values.
1192     */
1193    (void) _LoadFileAttributes (modAttr_data->host, modAttr_data->directory,
1194                                modAttr_data->name, modAttr_data,
1195                                ALL_BUT_ACCESS);
1196    return ((XtPointer) modAttr_data);
1197 }
1198
1199
1200
1201
1202 /************************************************************************
1203  *
1204  *  SetValues
1205  *
1206  ************************************************************************/
1207
1208 static void
1209 SetValues(
1210         ModAttrRec *modAttr_rec,
1211         ModAttrData *modAttr_data )
1212 {
1213    Arg args[10];
1214    XmString string;
1215    char buf[20];
1216    char date_string[256];
1217    Arg trueArg[1];
1218    Arg falseArg[1];
1219    Boolean sensitivity;
1220    struct passwd * user_data;
1221    String temp;
1222    struct tm * tms;
1223    char * timeString;
1224    int mode;
1225    char * fullPath;
1226    uid_t effective_user;
1227    int n;
1228
1229    Pixel background;
1230    Pixel foreground;
1231    Pixel top_shadow;
1232    Pixel bottom_shadow;
1233    Pixel select;
1234    Colormap colormap;
1235    XmString labelString;
1236    char * tmpStr;
1237    Tt_status tt_status;
1238
1239    /*  Get the select color  */
1240
1241    XtSetArg (args[0], XmNbackground, &background);
1242    XtSetArg (args[1], XmNcolormap,  &colormap);
1243    XtGetValues (modAttr_rec->bboard, args, 2);
1244
1245    XmGetColors (XtScreen (modAttr_rec->bboard), colormap, background,
1246                 &foreground, &top_shadow, &bottom_shadow, &select);
1247
1248    /* Adjust the colors of the icon */
1249    SetToNormalColors (modAttr_rec->fileType, modAttr_rec->bboard,
1250                       modAttr_data->main_widget, 0);
1251
1252    /* Verify that we are allowed to change the attributes */
1253    if (modAttr_data->owner)
1254       user_data = getpwnam(modAttr_data->owner);
1255    else
1256       user_data = NULL;
1257    effective_user = geteuid();
1258
1259
1260    if (user_data && user_data->pw_uid == getuid()
1261        || effective_user == root_user)
1262    {
1263       /* Check for root user */
1264       if (effective_user == root_user)
1265       {
1266         fullPath = ResolveLocalPathName (modAttr_data->host,
1267                                          modAttr_data->directory,
1268                                          modAttr_data->name,
1269                                          home_host_name, &tt_status);
1270
1271         if( TT_OK == tt_status )
1272         {
1273           /* Check for access rights (e.g. NFS mounted filesystem)  */
1274           mode  = chmod(fullPath, modAttr_data->accessBits +
1275                         modAttr_data->setuidBits);
1276           XtFree(fullPath);
1277
1278           if (mode == 0)
1279             sensitivity = True;
1280           else
1281             sensitivity = False;
1282         }
1283         else
1284           sensitivity = False;
1285       }
1286       else
1287         sensitivity = True;
1288    }
1289    else
1290      sensitivity = False;
1291
1292    if (modAttr_data->link_name)
1293    {
1294       Widget children[2];
1295
1296       children[0] = modAttr_rec->link_name;
1297       children[1] = modAttr_rec->link_label;
1298       XtManageChildren(children, 2);
1299       XtSetArg(args[0], XmNtopWidget, modAttr_rec->link_name);
1300       XtSetValues(modAttr_rec->owner, args, 1);
1301       XtSetValues(modAttr_rec->owner_label, args, 1);
1302       XtSetValues(modAttr_rec->fileType, args, 1);
1303    }
1304    else
1305    {
1306       Widget children[2];
1307
1308       children[0] = modAttr_rec->link_name;
1309       children[1] = modAttr_rec->link_label;
1310       XtUnmanageChildren(children, 2);
1311       XtSetArg(args[0], XmNtopWidget, modAttr_rec->name);
1312       XtSetValues(modAttr_rec->owner, args, 1);
1313       XtSetValues(modAttr_rec->owner_label, args, 1);
1314       XtSetValues(modAttr_rec->fileType, args, 1);
1315    }
1316
1317
1318    if (sensitivity == True)
1319    {
1320       /* Only allow root user to change the ownership.
1321       */
1322       if (effective_user == root_user)
1323       {
1324         XtManageChild(modAttr_rec->owner);
1325         XmTextFieldSetEditable(modAttr_rec->owner, True);
1326         XtSetArg (args[0], XmNcursorPositionVisible, True);
1327         XtSetArg (args[1], XmNshadowThickness, 2);
1328         XtSetValues(modAttr_rec->owner, args, 2);
1329
1330         if (modAttr_data->owner)
1331         {
1332           if (getpwnam(modAttr_data->owner) == NULL)
1333           {
1334             char *newstring =  XtMalloc(strlen(modAttr_data->owner) +
1335                                      strlen(GETMESSAGE(21,19, "Unknown")) + 10);
1336             sprintf( newstring,"%s (%s) ",modAttr_data->owner,
1337                      GETMESSAGE(21,19, "Unknown") );
1338             XmTextFieldSetString(modAttr_rec->owner, newstring);
1339             XtFree( newstring );
1340           }
1341           else
1342             XmTextFieldSetString(modAttr_rec->owner, modAttr_data->owner);
1343         }
1344         else
1345           XmTextFieldSetString(modAttr_rec->owner,
1346                                (GETMESSAGE(21,19, "Unknown")));
1347
1348         XtUnmanageChild(modAttr_rec->ownerL);
1349         XtUnmanageChild(modAttr_rec->groupL);
1350         XtManageChild(modAttr_rec->group);
1351         XmTextFieldSetEditable(modAttr_rec->group, True);
1352
1353         XtSetArg (args[0], XmNcursorPositionVisible, True);
1354         XtSetArg (args[1], XmNshadowThickness, 2);
1355         XtSetValues(modAttr_rec->group, args, 2);
1356
1357         XtSetArg (args[0], XmNshadowType, XmSHADOW_IN);
1358         XtSetArg (args[1], XmNbackground, select);
1359         XtSetValues(XtParent (modAttr_rec->ownerRead), args, 2);
1360
1361       }
1362       else
1363       {
1364         XtUnmanageChild(modAttr_rec->owner);
1365
1366         if (modAttr_data->owner)
1367         {
1368           if (getpwnam(modAttr_data->owner) == NULL)
1369           {
1370             char *newstring =  XtMalloc(strlen(modAttr_data->owner) +
1371                                         strlen(GETMESSAGE(21,19, "Unknown")) + 10);
1372             sprintf( newstring,"%s ( %s ) ",modAttr_data->owner,
1373                      GETMESSAGE(21,19, "Unknown") );
1374             labelString = XmStringCreateLocalized( newstring );
1375             XtFree( newstring );
1376           }
1377           else
1378             labelString = XmStringCreateLocalized(modAttr_data->owner);
1379         }
1380         else
1381         {
1382           labelString = XmStringCreateLocalized((GETMESSAGE(21,19, "Unknown")));
1383         }
1384
1385         XtSetArg (args[0], XmNlabelString, labelString);
1386         XtSetValues(modAttr_rec->ownerL, args, 1);
1387         XmStringFree (labelString);
1388         XtManageChild(modAttr_rec->ownerL);
1389
1390         XtUnmanageChild(modAttr_rec->group);
1391         if (modAttr_data->group)
1392         {
1393          if (getgrnam(modAttr_data->group) == NULL)
1394          {
1395             char *newstring =  XtMalloc(strlen(modAttr_data->group) +
1396                strlen(GETMESSAGE(21,19, "Unknown")) + 10);
1397             sprintf(newstring,"%s ( %s ) ",modAttr_data->group,
1398                GETMESSAGE(21,19, "Unknown"));
1399             labelString = XmStringCreateLocalized(newstring);
1400             XtFree(newstring);
1401          }
1402          else
1403             labelString = XmStringCreateLocalized(modAttr_data->group);
1404         }
1405         else
1406         {
1407          labelString = XmStringCreateLocalized((GETMESSAGE(21,19, "Unknown")));
1408         }
1409         XtSetArg (args[0], XmNlabelString, labelString);
1410         XtSetValues(modAttr_rec->groupL, args, 1);
1411         XmStringFree (labelString);
1412         XtManageChild(modAttr_rec->groupL);
1413
1414         XtSetArg (args[0], XmNshadowType, XmSHADOW_ETCHED_IN);
1415         XtSetArg (args[1], XmNbackground, background);
1416         XtSetValues(XtParent (modAttr_rec->ownerRead), args, 2);
1417
1418       }
1419
1420       if (modAttr_data->group)
1421       {
1422         if(getgrnam(modAttr_data->group) == NULL)
1423         {
1424           char *newstring =  XtMalloc(strlen(modAttr_data->group) +
1425                                       strlen(GETMESSAGE(21,19, "Unknown")) + 10);
1426           sprintf(newstring,"%s (%s) ",modAttr_data->group,
1427                   GETMESSAGE(21,19, "Unknown"));
1428           XmTextFieldSetString(modAttr_rec->group, newstring);
1429           XtFree(newstring);
1430         }
1431         else
1432           XmTextFieldSetString(modAttr_rec->group, modAttr_data->group);
1433       }
1434       else
1435       {
1436          XmTextFieldSetString(modAttr_rec->group,
1437                               (GETMESSAGE(21,19, "Unknown")));
1438       }
1439    }
1440    else
1441    {
1442       XtUnmanageChild(modAttr_rec->owner);
1443       XtUnmanageChild(modAttr_rec->group);
1444 /*    I'm not sure why we care to set all these up.
1445       Both widgets are being unmanaged by the above 2 statements
1446
1447       XmTextFieldSetEditable(modAttr_rec->owner, False);
1448       XmTextFieldSetEditable(modAttr_rec->group, False);
1449       XtSetArg (args[0], XmNcursorPositionVisible, False);
1450       XtSetArg (args[1], XmNshadowThickness, 0);
1451       XtSetArg (args[2], XmNbackground, background);
1452       XtSetValues(modAttr_rec->owner, args, 3);
1453       XtSetValues(modAttr_rec->group, args, 3);
1454 */
1455
1456       if (modAttr_data->owner)
1457       {
1458          if (getpwnam(modAttr_data->owner) == NULL)
1459          {
1460             char *newstring =  XtMalloc(strlen(modAttr_data->owner) +
1461                strlen(GETMESSAGE(21,19, "Unknown")) + 10);
1462             sprintf(newstring,"%s ( %s ) ",modAttr_data->owner,
1463                GETMESSAGE(21,19, "Unknown"));
1464             labelString = XmStringCreateLocalized(newstring);
1465             XtFree(newstring);
1466          }
1467          else
1468             labelString = XmStringCreateLocalized(modAttr_data->owner);
1469       }
1470       else
1471       {
1472          labelString = XmStringCreateLocalized((GETMESSAGE(21,19, "Unknown")));
1473       }
1474       XtSetArg (args[0], XmNlabelString, labelString);
1475       XtSetValues(modAttr_rec->ownerL, args, 1);
1476       XmStringFree (labelString);
1477
1478       if (modAttr_data->group)
1479       {
1480          if (getgrnam(modAttr_data->group) == NULL)
1481          {
1482             char *newstring =  XtMalloc(strlen(modAttr_data->group) +
1483                strlen(GETMESSAGE(21,19, "Unknown")) + 10);
1484             sprintf(newstring,"%s ( %s ) ",modAttr_data->group,
1485                GETMESSAGE(21,19, "Unknown"));
1486             labelString = XmStringCreateLocalized(newstring);
1487             XtFree(newstring);
1488          }
1489          else
1490             labelString = XmStringCreateLocalized(modAttr_data->group);
1491       }
1492       else
1493       {
1494          labelString = XmStringCreateLocalized((GETMESSAGE(21,19, "Unknown")));
1495       }
1496       XtSetArg (args[0], XmNlabelString, labelString);
1497       XtSetValues(modAttr_rec->groupL, args, 1);
1498       XmStringFree (labelString);
1499       XtManageChild(modAttr_rec->ownerL);
1500       XtManageChild(modAttr_rec->groupL);
1501
1502       XtSetArg (args[0], XmNshadowType, XmSHADOW_ETCHED_IN);
1503       XtSetArg (args[1], XmNbackground, background);
1504       XtSetValues(XtParent (modAttr_rec->ownerRead), args, 2);
1505    }
1506
1507
1508    if(modAttr_data->filetype && (
1509                strcmp(modAttr_data->filetype,LT_RECURSIVE_LINK) == 0 ||
1510                strcmp(modAttr_data->filetype,LT_BROKEN_LINK) == 0))
1511       sensitivity = False;
1512
1513    /* User doesn't have modification privileges */
1514    XtSetSensitive(modAttr_rec->ok, sensitivity);
1515    XtSetSensitive(modAttr_rec->ownerRead, sensitivity);
1516    XtSetSensitive(modAttr_rec->ownerWrite, sensitivity);
1517    XtSetSensitive(modAttr_rec->ownerExecute, sensitivity);
1518    XtSetSensitive(modAttr_rec->groupRead, sensitivity);
1519    XtSetSensitive(modAttr_rec->groupWrite, sensitivity);
1520    XtSetSensitive(modAttr_rec->groupExecute, sensitivity);
1521    XtSetSensitive(modAttr_rec->otherRead, sensitivity);
1522    XtSetSensitive(modAttr_rec->otherWrite, sensitivity);
1523    XtSetSensitive(modAttr_rec->otherExecute, sensitivity);
1524
1525
1526    if (modAttr_data->name)
1527    {
1528       /* Build host:dir/name string */
1529       temp = XtMalloc(strlen(modAttr_data->host) +
1530                       strlen(modAttr_data->directory) +
1531                       strlen(modAttr_data->name) + 3);
1532       temp[0] = '\0';
1533       if (modAttr_data->host)
1534       {
1535          (void) strcat(temp, modAttr_data->host);
1536          (void) strcat(temp, ":");
1537       }
1538       if (modAttr_data->directory)
1539       {
1540          (void) strcat(temp, modAttr_data->directory);
1541          if (strcmp (modAttr_data->directory, "/") != 0)
1542             (void) strcat(temp, "/");
1543       }
1544       (void) strcat(temp, modAttr_data->name);
1545       string = XmStringCreateLocalized(temp);
1546       XtFree ((char *) temp);
1547    }
1548    else
1549       string = XmStringCreateLocalized(" ");
1550
1551
1552    XtSetArg (args[0], XmNlabelString, string);
1553    XtSetValues(modAttr_rec->name, args, 1);
1554    XmStringFree(string);
1555
1556    if (modAttr_data->link_name)
1557    {
1558       string = XmStringCreateLocalized(modAttr_data->link_name);
1559       XtSetArg (args[0], XmNlabelString, string);
1560       XtSetValues(modAttr_rec->link_name, args, 1);
1561       XmStringFree(string);
1562    }
1563
1564    if (modAttr_data->filetype)
1565    {
1566       char *ptr;
1567
1568       if (ptr = (char *)DtDtsDataTypeToAttributeValue(modAttr_data->filetype,
1569                                                       FM_TYPE_LABEL,
1570                                                       NULL))
1571       {
1572          string = XmStringCreateLocalized(ptr);
1573          DtDtsFreeAttributeValue(ptr);
1574       }
1575       else
1576       {
1577          string = XmStringCreateLocalized(modAttr_data->filetype);
1578       }
1579    }
1580    else
1581       string = XmStringCreateLocalized(" ");
1582
1583    XtSetArg (args[0], XmNstring, string);
1584    if (modAttr_data->pixmapData)
1585      XtSetArg (args[1], XmNimageName, modAttr_data->pixmapData->iconFileName);
1586    else
1587      XtSetArg (args[1], XmNimageName, NULL);
1588    XtSetValues(modAttr_rec->fileType, args, 2);
1589
1590    _DtCheckAndFreePixmapData(modAttr_data->filetype,
1591                              toplevel,
1592                              (DtIconGadget) modAttr_rec->fileType,
1593                              modAttr_data->pixmapData);
1594    modAttr_data->pixmapData = NULL;
1595    XmStringFree(string);
1596    fullPath = ResolveLocalPathName (modAttr_data->host,
1597                                     modAttr_data->directory,
1598                                     modAttr_data->name,
1599                                     home_host_name, &tt_status);
1600    if (fsDialogAvailable(fullPath, &modAttr_rec->fileSystem))
1601    {
1602       if (strlen(modAttr_rec->fileSystem.warningMessage) == 0) /* fs dialog is available and there is no warning message */
1603       {
1604          string = XmStringCreateLocalized (modAttr_rec->fileSystem.buttonLabel);
1605          n = 0;
1606          XtSetArg (args[n], XmNlabelString, string);                    n++;
1607          XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);         n++;
1608          XtSetArg (args[n], XmNtopWidget, modAttr_rec->otherPLabel);    n++;
1609          XtSetArg (args[n], XmNtopOffset, 15);                          n++;
1610          XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);        n++;
1611          XtSetArg (args[n], XmNbottomOffset, 15);                       n++;
1612          XtSetValues(modAttr_rec->fsPushButton, args, n);
1613          XmStringFree(string);
1614       }
1615       else /* fs dialog is available and there is a warning message */
1616       {
1617          n = 0;
1618          string = XmStringCreateLocalized (modAttr_rec->fileSystem.warningMessage);
1619          XtSetArg (args[n], XmNlabelString, string);                    n++;
1620          XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);         n++;
1621          XtSetArg (args[n], XmNtopWidget, modAttr_rec->otherPLabel);    n++;
1622          XtSetArg (args[n], XmNtopOffset, 15);                          n++;
1623          XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);         n++;
1624          XtSetArg (args[n], XmNrightOffset, 15);                        n++;
1625          XtSetValues(modAttr_rec->fsWarning, args, n);
1626          XmStringFree(string);
1627          n = 0;
1628          string = XmStringCreateLocalized (modAttr_rec->fileSystem.buttonLabel);
1629          XtSetArg (args[n], XmNlabelString, string);                    n++;
1630          XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);         n++;
1631          XtSetArg (args[n], XmNtopWidget, modAttr_rec->fsWarning);      n++;
1632          XtSetArg (args[n], XmNtopOffset, 15);                          n++;
1633          XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);        n++;
1634          XtSetArg (args[n], XmNbottomOffset, 15);                       n++;
1635          XtSetValues(modAttr_rec->fsPushButton, args, n);
1636          XmStringFree(string);
1637      }
1638      n = 0;
1639      XtSetArg (args[n], XmNbottomAttachment, XmATTACH_NONE);            n++;
1640      XtSetValues(modAttr_rec->otherPLabel, args, n);
1641      if (strlen(modAttr_rec->fileSystem.warningMessage) != 0)
1642         XtManageChild (modAttr_rec->fsWarning);
1643      else
1644         XtUnmanageChild (modAttr_rec->fsWarning);
1645      /* the fs dialog pushbutton is created with a callback to cancel the   */
1646      /* permissions dialog ... here that callback is removed if that was    */
1647      /* requested by a directive in the configuration file dtfile.config    */
1648      if (!modAttr_rec->fileSystem.dismissStdPermissionDialog)
1649      {
1650         XtRemoveAllCallbacks(modAttr_rec->fsPushButton, XmNactivateCallback);
1651      }
1652      XtAddCallback(modAttr_rec->fsPushButton,
1653                    XmNactivateCallback,
1654                    (XtCallbackProc)displayFSDialog,
1655                    &modAttr_rec->fileSystem);
1656      XtManageChild (modAttr_rec->fsPushButton);
1657    }
1658    else
1659    {
1660       if (strlen(modAttr_rec->fileSystem.warningMessage) == 0) /* fs dialog not available and there is no warning message */
1661       {
1662          XtUnmanageChild (modAttr_rec->fsPushButton);
1663          XtUnmanageChild (modAttr_rec->fsWarning);
1664          n = 0;
1665          XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);        n++;
1666          XtSetValues(modAttr_rec->otherPLabel, args, n);
1667       }
1668       else /* fs dialog is not available and there is a warning message */
1669       {
1670          n = 0;
1671          XtSetArg (args[n], XmNbottomAttachment, XmATTACH_NONE);        n++;
1672          XtSetValues(modAttr_rec->otherPLabel, args, n);
1673          n = 0;
1674          string = XmStringCreateLocalized (modAttr_rec->fileSystem.warningMessage);
1675          XtSetArg (args[n], XmNlabelString, string);                    n++;
1676          XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);         n++;
1677          XtSetArg (args[n], XmNtopWidget, modAttr_rec->otherPLabel);    n++;
1678          XtSetArg (args[n], XmNtopOffset, 15);                          n++;
1679          XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);        n++;
1680          XtSetArg (args[n], XmNbottomOffset, 15);                       n++;
1681          XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);         n++;
1682          XtSetArg (args[n], XmNrightOffset, 15);                        n++;
1683          XtSetValues(modAttr_rec->fsWarning, args, n);
1684          XmStringFree(string);
1685          XtUnmanageChild (modAttr_rec->fsPushButton);
1686          XtManageChild (modAttr_rec->fsWarning);
1687          XtUnmanageChild (modAttr_rec->fsPushButton);
1688       }
1689    }
1690
1691    XtFree(fullPath);
1692
1693
1694    if(modAttr_data->filetype && (
1695                strcmp(modAttr_data->filetype,LT_RECURSIVE_LINK) == 0 ||
1696                strcmp(modAttr_data->filetype,LT_BROKEN_LINK) == 0 ))
1697    {
1698      tmpStr = GETMESSAGE(21,19, "Unknown");
1699      sprintf(date_string, "  %s",tmpStr);
1700      string = XmStringCreateLocalized(date_string);
1701      XtSetArg (args[0], XmNlabelString, string);
1702      XtSetValues(modAttr_rec->size, args, 1);
1703      XtSetArg (args[0], XmNlabelString, string);
1704      XtSetValues(modAttr_rec->modTime, args, 1);
1705      XmStringFree(string);
1706    }
1707    else
1708    {
1709      (void) sprintf(buf, "%d", modAttr_data->size);
1710      string = XmStringCreateLocalized(buf);
1711      XtSetArg (args[0], XmNlabelString, string);
1712      XtSetValues(modAttr_rec->size, args, 1);
1713      XmStringFree(string);
1714
1715      tms = localtime(&modAttr_data->modTime);
1716      tmpStr = GETMESSAGE(21, 14, "%x %X ");
1717      timeString = XtNewString(tmpStr);
1718      (void)strftime(date_string, 256, timeString, tms);
1719      XtFree(timeString);
1720      string = XmStringCreateLocalized(date_string);
1721      XtSetArg (args[0], XmNlabelString, string);
1722      XtSetValues(modAttr_rec->modTime, args, 1);
1723      XmStringFree(string);
1724    }
1725
1726    XtSetArg (trueArg[0], XmNset, True);
1727    XtSetArg (falseArg[0], XmNset, False);
1728
1729    /* Set the access bits */
1730    if (modAttr_data->accessBits & S_IRUSR)
1731       XtSetValues(modAttr_rec->ownerRead, trueArg, 1);
1732    else
1733       XtSetValues(modAttr_rec->ownerRead, falseArg, 1);
1734
1735    if (modAttr_data->accessBits & S_IWUSR)
1736       XtSetValues(modAttr_rec->ownerWrite, trueArg, 1);
1737    else
1738       XtSetValues(modAttr_rec->ownerWrite, falseArg, 1);
1739
1740    if (modAttr_data->accessBits & S_IXUSR)
1741       XtSetValues(modAttr_rec->ownerExecute, trueArg, 1);
1742    else
1743       XtSetValues(modAttr_rec->ownerExecute, falseArg, 1);
1744
1745    if (modAttr_data->accessBits & S_IRGRP)
1746       XtSetValues(modAttr_rec->groupRead, trueArg, 1);
1747    else
1748       XtSetValues(modAttr_rec->groupRead, falseArg, 1);
1749
1750    if (modAttr_data->accessBits & S_IWGRP)
1751       XtSetValues(modAttr_rec->groupWrite, trueArg, 1);
1752    else
1753       XtSetValues(modAttr_rec->groupWrite, falseArg, 1);
1754
1755    if (modAttr_data->accessBits & S_IXGRP)
1756       XtSetValues(modAttr_rec->groupExecute, trueArg, 1);
1757    else
1758       XtSetValues(modAttr_rec->groupExecute, falseArg, 1);
1759
1760    if (modAttr_data->accessBits & S_IROTH)
1761       XtSetValues(modAttr_rec->otherRead, trueArg, 1);
1762    else
1763       XtSetValues(modAttr_rec->otherRead, falseArg, 1);
1764
1765    if (modAttr_data->accessBits & S_IWOTH)
1766       XtSetValues(modAttr_rec->otherWrite, trueArg, 1);
1767    else
1768       XtSetValues(modAttr_rec->otherWrite, falseArg, 1);
1769
1770    if (modAttr_data->accessBits & S_IXOTH)
1771       XtSetValues(modAttr_rec->otherExecute, trueArg, 1);
1772    else
1773       XtSetValues(modAttr_rec->otherExecute, falseArg, 1);
1774 }
1775
1776
1777
1778
1779 /************************************************************************
1780  *
1781  *  WriteResourceValues
1782  *
1783  ************************************************************************/
1784
1785 static void
1786 WriteResourceValues(
1787         DialogData *values,
1788         int fd,
1789         char **name_list )
1790 {
1791
1792    /* We are not using this code so we commented it out for now */
1793
1794
1795    ModAttrData * modAttr_data = (ModAttrData *) values->data;
1796    ModAttrRec  * modAttr_rec;
1797    Arg args[4];
1798
1799
1800    /*  If the dialog is currently displayed, update the geometry  */
1801    /*  fields to their current values.                            */
1802
1803    if (modAttr_data->displayed == True)
1804    {
1805       _DtGenericUpdateWindowPosition(values);
1806       modAttr_rec = (ModAttrRec *) _DtGetDialogInstance(values);
1807    }
1808
1809    _DtDialogPutResources (fd, name_list, MODIFY_ATTR, values->data,
1810                        resources, modAttrClass->resource_count);
1811 }
1812
1813
1814
1815
1816 /************************************************************************
1817  *
1818  *  FreeValues
1819  *
1820  ************************************************************************/
1821
1822 static void
1823 FreeValues(
1824         ModAttrData *modAttr_data )
1825 {
1826    XtFree ((char *) modAttr_data->host);
1827    XtFree ((char *) modAttr_data->directory);
1828    XtFree ((char *) modAttr_data->name);
1829    XtFree ((char *) modAttr_data->link_name);
1830    XtFree ((char *) modAttr_data->filetype);
1831    XtFree ((char *) modAttr_data->owner);
1832    XtFree ((char *) modAttr_data->group);
1833
1834    if( modAttr_data->pixmapData )
1835    {
1836      DtDtsFreeAttributeValue(modAttr_data->pixmapData->hostPrefix);
1837      DtDtsFreeAttributeValue(modAttr_data->pixmapData->instanceIconName);
1838      DtDtsFreeAttributeValue(modAttr_data->pixmapData->iconName);
1839      DtDtsFreeAttributeValue(modAttr_data->pixmapData->iconFileName);
1840      XtFree((char *) modAttr_data->pixmapData);
1841    }
1842    XtFree ((char *) modAttr_data);
1843 }
1844
1845
1846
1847
1848 /************************************************************************
1849  *
1850  *  OkCallback
1851  *      This is a callback function called when the (Ok) button
1852  *      is pressed.  It makes any indicated modifications, and then
1853  *      discards the data and brings down the dialog.
1854  *
1855  ************************************************************************/
1856
1857 static void
1858 OkCallback(
1859         Widget w,
1860         ModAttrApply *apply_data,
1861         XtPointer call_data )
1862 {
1863   ModAttrRec  * modAttr_rec = (ModAttrRec *) apply_data->modAttr_rec;
1864   ModAttrData * new_attr_data;
1865   FileMgrRec *file_mgr_rec;
1866   Widget close = modAttr_rec->cancel;
1867   DialogData * old_dialog;
1868   ModAttrData * old;
1869   Boolean question = False;
1870   short result;
1871
1872   old_dialog = _DtGetInstanceData ((XtPointer)modAttr_rec);
1873   old = (ModAttrData *) old_dialog->data;
1874
1875   if(RecheckFlag(NULL,w))
1876     return;
1877   else if(RecheckFlag(NULL,close))
1878     return;
1879
1880   new_attr_data = (ModAttrData *) XtCalloc (1, sizeof (ModAttrData));
1881   new_attr_data->displayed = True;
1882
1883   /* Verify the user and group names */
1884   result = GetModAttrValues(modAttr_rec, new_attr_data, True);
1885   if (result == GMA_VALID)
1886   {
1887     /* Check to see if the file we are changing is the CURRENT directory.
1888      * If it is we need to see if after the changes, the user will have
1889      * permissions to read this folder. If he/she doesn't we want to warn
1890      * the user that this will be the case and allow them to back out of
1891      * the change.  If they don't want to back out of the change, we need
1892      * to make the change, then move them up to the parent directory.
1893      */
1894     if(strcmp(old->name, ".") == 0)
1895     {
1896       /* It is the current directory, now we need to test the cases where
1897        * by changing permissions the user would no should be in this
1898        * directory because lack of priviledges.
1899        * Cases where this is true:
1900        *   1. If the execute bit for owner has been changed to off and the
1901        *      user is the owner.
1902        *   2. The user changes the owner, and the execute bit is for owner
1903        *      is the only execute bit set.
1904        *   3. The read access bit for owner has been turned off.
1905        *
1906        *   Others?
1907        */
1908       if(strcmp(old->owner, new_attr_data->owner) == 0 &&
1909          (new_attr_data->accessBits & 64) == 0)
1910       {
1911         /* Criteria 1 above has been meet */
1912         question = True;
1913       }
1914       else if (strcmp(old->owner, new_attr_data->owner) != 0 &&
1915                ((new_attr_data->accessBits & 73) == 0 ||
1916                 (new_attr_data->accessBits & 73) == 64))
1917       {
1918         /* Criteria 2 above has been meet */
1919           question = True;
1920       }
1921       else if((new_attr_data->accessBits & 256) == 0)
1922       {
1923           /* Criteria 3 above has been meet */
1924           question = True;
1925       }
1926     }
1927
1928     if(question)
1929     {
1930       char *title, *message;
1931
1932       globalApplyData = apply_data;
1933       parentDir = XtNewString(old->directory);
1934       title = XtNewString(GETMESSAGE(21, 36, "Change Permissions Warning"));
1935       message = XtNewString(GETMESSAGE(21, 37, "You are changing the permissions on the Current\nFolder in a way that won't allow you to view\nthis folder any longer.  It will be automatically\nclosed and you will no longer be able to reopen\nthe folder.\n\nIs this what you want to do?"));
1936       _DtMessageDialog(modAttr_rec->shell, title, message, NULL, TRUE,
1937                        DontChangeCB, ChangeCB, NULL, HelpRequestCB, False,
1938                        QUESTION_DIALOG);
1939       XtFree(title);
1940       XtFree(message);
1941     }
1942     else
1943       /* Information was valid */
1944       (*(apply_data->callback)) (w, apply_data->client_data, NULL);
1945   }
1946   else if (result == GMA_NO_FILE)
1947   {
1948      DialogData * old_dialog;
1949      char *title,*tmpmsg,*msg;
1950      ModAttrData * old;
1951
1952      old_dialog = _DtGetInstanceData ((XtPointer)modAttr_rec);
1953      old = (ModAttrData *) old_dialog->data;
1954
1955      file_mgr_rec =  (FileMgrRec *) LocateRecordStructure(w);
1956      ResetFlag(NULL,w);
1957      ResetFlag(NULL,close);
1958      title  = XtNewString(GETMESSAGE(21,33, "Permissions Error"));
1959      tmpmsg = GETMESSAGE(21,35,"The Permissions dialog for the object\n\n%s/%s\n\nhas been closed because this object has been deleted\nfrom your system.");
1960      msg = XtMalloc(strlen(tmpmsg)+strlen(old->directory)+strlen(old->name)+3);
1961      sprintf(msg,tmpmsg,old->directory,old->name);
1962
1963      ModAttrClose ((XtPointer)file_mgr_rec, old_dialog, NULL);
1964      _DtMessage(toplevel, title, msg, NULL, HelpRequestCB);
1965      XtFree(title);
1966      XtFree(msg);
1967   }
1968
1969   FreeValues (new_attr_data);
1970 }
1971
1972
1973
1974 /************************************************************************
1975  *
1976  *  GetModAttrValues
1977  *      Update the current file attribute values within the data structure.
1978  *
1979  ************************************************************************/
1980
1981 static short
1982 GetModAttrValues(
1983         ModAttrRec *modAttr_rec,
1984         ModAttrData *modAttr_data,
1985         Boolean validate )
1986 {
1987    Arg args[4];
1988    DialogData * old_dialog;
1989    ModAttrData * old;
1990    int error;
1991    Boolean retStatus;
1992
1993    old_dialog = _DtGetInstanceData ((XtPointer)modAttr_rec);
1994    old = (ModAttrData *) old_dialog->data;
1995    retStatus =  _LoadFileAttributes (old->host, old->directory, old->name,
1996                                modAttr_data, ALL_BUT_OWNER_GROUP_ACCESS);
1997
1998    if(!retStatus)
1999      return ((short)GMA_NO_FILE);
2000
2001    /* Get the current geometry */
2002    XtSetArg (args[0], XmNx, &modAttr_data->x);
2003    XtSetArg (args[1], XmNy, &modAttr_data->y);
2004    XtSetArg (args[2], XmNwidth, &modAttr_data->width);
2005    XtSetArg (args[3], XmNheight, &modAttr_data->height);
2006    XtGetValues (modAttr_rec->shell, args, 4);
2007
2008    /* Get the user, group and access bits */
2009    if( XtIsManaged( modAttr_rec->owner ) )
2010      modAttr_data->owner = XmTextFieldGetString(modAttr_rec->owner);
2011    else
2012      modAttr_data->owner = XtNewString( old->owner );
2013
2014    modAttr_data->group = XmTextFieldGetString(modAttr_rec->group);
2015    modAttr_data->accessBits = 0;
2016
2017    if (XmToggleButtonGadgetGetState(modAttr_rec->ownerRead))
2018       modAttr_data->accessBits |= S_IRUSR;
2019    if (XmToggleButtonGadgetGetState(modAttr_rec->ownerWrite))
2020       modAttr_data->accessBits |= S_IWUSR;
2021    if (XmToggleButtonGadgetGetState(modAttr_rec->ownerExecute))
2022       modAttr_data->accessBits |= S_IXUSR;
2023    if (XmToggleButtonGadgetGetState(modAttr_rec->groupRead))
2024       modAttr_data->accessBits |= S_IRGRP;
2025    if (XmToggleButtonGadgetGetState(modAttr_rec->groupWrite))
2026       modAttr_data->accessBits |= S_IWGRP;
2027    if (XmToggleButtonGadgetGetState(modAttr_rec->groupExecute))
2028       modAttr_data->accessBits |= S_IXGRP;
2029    if (XmToggleButtonGadgetGetState(modAttr_rec->otherRead))
2030       modAttr_data->accessBits |= S_IROTH;
2031    if (XmToggleButtonGadgetGetState(modAttr_rec->otherWrite))
2032       modAttr_data->accessBits |= S_IWOTH;
2033    if (XmToggleButtonGadgetGetState(modAttr_rec->otherExecute))
2034       modAttr_data->accessBits |= S_IXOTH;
2035
2036    if (old->link_name)
2037       modAttr_data->link_name = XtNewString(old->link_name);
2038    else
2039       modAttr_data->link_name = NULL;
2040
2041
2042    /* Validate the entry */
2043    if (validate)
2044    {
2045       /* Valid user name */
2046       error = -1;
2047       if (getpwnam(modAttr_data->owner) == NULL)
2048          error = UNKNOWN_USER;
2049       else if (getgrnam(modAttr_data->group) == NULL)
2050          error = UNKNOWN_GROUP;
2051
2052       if (error != -1)
2053       {
2054          /* Bad entry; free up everything allocated so far */
2055          ResetFlag(NULL,modAttr_rec->ok);
2056          ResetFlag(NULL,modAttr_rec->cancel);
2057          InvalidModAttrMessage(modAttr_rec->shell, error);
2058          XtFree ((char *) modAttr_data->host);
2059           modAttr_data->host = NULL;
2060          XtFree ((char *) modAttr_data->directory);
2061           modAttr_data->directory = NULL;
2062          XtFree ((char *) modAttr_data->name);
2063           modAttr_data->name = NULL;
2064          XtFree ((char *) modAttr_data->filetype);
2065           modAttr_data->filetype = NULL;
2066          XtFree ((char *) modAttr_data->owner);
2067           modAttr_data->owner = NULL;
2068          XtFree ((char *) modAttr_data->group);
2069           modAttr_data->group = NULL;
2070          XtFree ((char *) modAttr_data->link_name);
2071          modAttr_data->link_name = NULL;
2072          XSync(XtDisplay(modAttr_rec->ok), False);
2073          return ((short)GMA_INVALID);
2074       }
2075    }
2076
2077    return((short)GMA_VALID);
2078 }
2079
2080
2081
2082
2083 /************************************************************************
2084  *
2085  *  InvalidModAttrMessage
2086  *      Display an error message.
2087  *
2088  ************************************************************************/
2089
2090 static void
2091 InvalidModAttrMessage(
2092         Widget w,
2093         int messageIndex )
2094 {
2095    String string;
2096    char * title;
2097    char * tmpStr;
2098    static String unknownUser = NULL;
2099    static String unknownGroup = NULL;
2100
2101    if (unknownUser == NULL)
2102    {
2103       tmpStr = GETMESSAGE(21,31, "Owner Name is invalid.\nThe specified user does not exist.");
2104       unknownUser = XtNewString(tmpStr);
2105       tmpStr = GETMESSAGE(21,32, "Group Name is invalid.\n\nNo group of users with this name has been created on your system.\nUse your system administration software if you want to create\na user group with this name.");
2106       unknownGroup = XtNewString(tmpStr);
2107    }
2108
2109    switch (messageIndex)
2110    {
2111       case UNKNOWN_USER:
2112            string = unknownUser;
2113            break;
2114       case UNKNOWN_GROUP:
2115            string = unknownGroup;
2116            break;
2117    }
2118
2119    tmpStr = GETMESSAGE(21,33, "Permissions Error");
2120    title = XtNewString(tmpStr);
2121    _DtMessage (w, title, string, NULL, HelpRequestCB);
2122    XtFree(title);
2123 }
2124
2125
2126
2127
2128 /************************************************************************
2129  *
2130  *  _LoadFileAttributes
2131  *      Load the data structure with the data describing the indicated file.
2132  *
2133  *      THIS IS A Private FUNCTION
2134  *
2135  ************************************************************************/
2136
2137 static Boolean
2138 _LoadFileAttributes(
2139         String host,
2140         String dir,
2141         String file,
2142         ModAttrData *modAttr_data,
2143         unsigned long mask )
2144 {
2145    String filetype;
2146    FileData *file_data=NULL;
2147    struct group * group_data;
2148    struct passwd * user_data;
2149    Boolean returnStatus=TRUE;
2150    char buf[32];
2151
2152    file_data = (FileData *) ReadFileData(dir,file);
2153
2154    if (file_data && (file_data->errnum == 0 || file_data->link))
2155    {
2156       /* Extract the most uptodate attributes */
2157       if (mask & HOST)
2158       {
2159          if (host)
2160             modAttr_data->host = XtNewString(host);
2161          else
2162             modAttr_data->host = NULL;
2163       }
2164       else
2165          modAttr_data->host = NULL;
2166
2167       if (mask & DIR)
2168       {
2169          if (dir)
2170             modAttr_data->directory = XtNewString(dir);
2171          else
2172             modAttr_data->directory = NULL;
2173       }
2174       else
2175          modAttr_data->directory = NULL;
2176
2177       if (mask & NAME)
2178          modAttr_data->name = XtNewString(file);
2179       else
2180          modAttr_data->name = NULL;
2181
2182       if (mask & FILETYPE)
2183       {
2184          modAttr_data->filetype = XtNewString(file_data->logical_type);
2185
2186          if (modAttr_data->pixmapData)
2187          {
2188              /* free old pixmap data */
2189            DtDtsFreeAttributeValue(modAttr_data->pixmapData->hostPrefix);
2190            DtDtsFreeAttributeValue(modAttr_data->pixmapData->instanceIconName);
2191            DtDtsFreeAttributeValue(modAttr_data->pixmapData->iconName);
2192            DtDtsFreeAttributeValue(modAttr_data->pixmapData->iconFileName);
2193            XtFree((char *) modAttr_data->pixmapData);
2194            modAttr_data->pixmapData = NULL;
2195          }
2196
2197          modAttr_data->pixmapData = _DtRetrievePixmapData(
2198                                        file_data->logical_type,
2199                                        NULL,
2200                                        NULL,
2201                                        toplevel,
2202                                        LARGE);
2203       }
2204       else
2205       {
2206          modAttr_data->filetype = NULL;
2207          modAttr_data->pixmapData = NULL;
2208       }
2209
2210       if (file_data->errnum == 0  &&
2211           (file_data->stat.st_mode & S_IFMT) != S_IFLNK )
2212       {
2213          if (mask & GROUP)
2214          {
2215             group_data = getgrgid(file_data->stat.st_gid);
2216             if(group_data != NULL)
2217                modAttr_data->group = XtNewString(group_data->gr_name);
2218             else
2219             {
2220                sprintf(buf, "%ld", (long)file_data->stat.st_gid);
2221                modAttr_data->group = XtNewString(buf);
2222             }
2223          }
2224          else
2225             modAttr_data->group = NULL;
2226
2227          if (mask & OWNER)
2228          {
2229             user_data = getpwuid(file_data->stat.st_uid);
2230             if(user_data != NULL)
2231                modAttr_data->owner = XtNewString(user_data->pw_name);
2232             else
2233             {
2234                sprintf(buf, "%ld", (long)file_data->stat.st_uid);
2235                modAttr_data->owner = XtNewString(buf);
2236             }
2237          }
2238          else
2239             modAttr_data->owner = NULL;
2240
2241          modAttr_data->setuidBits = file_data->stat.st_mode & 07000;
2242          if (mask & BITS)
2243             modAttr_data->accessBits = file_data->stat.st_mode & 0777;
2244          if (mask & SIZE)
2245             modAttr_data->size = file_data->stat.st_size;
2246          if (mask & MODTIME)
2247             modAttr_data->modTime = file_data->stat.st_mtime;
2248       }
2249       else
2250       {
2251          modAttr_data->owner = NULL;
2252          modAttr_data->group = NULL;
2253          modAttr_data->accessBits = 0;
2254          modAttr_data->size = 0;
2255          modAttr_data->modTime = 0;
2256       }
2257    }
2258    else
2259    {
2260       /* File did not exist or can't be accessed; use defaults */
2261       modAttr_data->host = NULL;
2262       modAttr_data->link_name = NULL;
2263       modAttr_data->directory = NULL;
2264       modAttr_data->name = NULL;
2265       modAttr_data->filetype = NULL;
2266       modAttr_data->pixmapData = NULL;
2267       modAttr_data->owner = NULL;
2268       modAttr_data->group = NULL;
2269       modAttr_data->accessBits = 0;
2270       modAttr_data->size = 0;
2271       modAttr_data->modTime = 0;
2272       returnStatus = False;
2273    }
2274
2275    if(file_data)
2276      FreeFileData(file_data,True);
2277
2278    return(returnStatus);
2279
2280 }
2281
2282
2283 /************************************************************************
2284  *
2285  *  LoadFileAttributes
2286  *      Load the data structure with the data describing the indicated file.
2287  *
2288  *      THIS IS A Public FUNCTION
2289  *
2290  ************************************************************************/
2291
2292 Boolean
2293 LoadFileAttributes(
2294         String host,
2295         String dir,
2296         String file,
2297         ModAttrData *modAttr_data )
2298 {
2299    FileData *file_data=NULL;
2300
2301    file_data = (FileData *) ReadFileData( dir, file);
2302
2303    /* Get the link attributes */
2304    if (file_data && file_data->link)
2305       modAttr_data->link_name = XtNewString(file_data->link);
2306    else
2307       modAttr_data->link_name = NULL;
2308
2309    if(file_data)
2310      FreeFileData(file_data,True);
2311
2312    return _LoadFileAttributes (host, dir, file, modAttr_data, ALL_FIELDS);
2313 }
2314
2315
2316
2317 /************************************************************************
2318  *
2319  *  displayFSDialog
2320  *      Display dialog to edit file-system-specific attributes,
2321  *      e.g. AFS Access Control Lists. The dialog is displayed
2322  *      be executing an independent program. There is no communication
2323  *      between the two. While this is ok for filesystems like AFS
2324  *      where file-system specific attributes are independent of
2325  *      unix attributes, it might not be ok for file systems where
2326  *      the two are dependent on each other (e.g. DFS?).
2327  *
2328  ************************************************************************/
2329
2330
2331 static void
2332 displayFSDialog (Widget                      w,
2333                  dtFSData                    *fileSystem,
2334                  XmPushButtonCallbackStruct  *cbs)
2335
2336 {
2337    static char *pname = "displayFSDialog";
2338    pid_t     pid;
2339    int       n;
2340    Arg       args[20];
2341    Widget    dialog;
2342    String    s;
2343    XmString  xm_string;
2344    String    errorScript = CDE_INSTALLATION_TOP "/bin/dtfile_error";
2345
2346    switch ((pid = fork()))
2347    {
2348       case -1:  /* error forking */
2349          s = GETMESSAGE(21, 26, "Unable to create a process for file system dialog");
2350          xm_string = XmStringCreateLocalized(s);
2351          n = 0;
2352          XtSetArg(args[n], XmNmessageString, xm_string);        n++;
2353          dialog = XmCreateErrorDialog(XtParent(w),"fork_error",args,1);
2354          XmStringFree(xm_string);
2355          XtManageChild(dialog);
2356          break;
2357
2358       case 0:  /* child */
2359
2360          DBGFORK(("%s:  child forked\n", pname));
2361
2362          execl(fileSystem->fsDialogProgram,
2363                fileSystem->fsDialogProgram,   /* argv[0] */
2364                fileSystem->path,              /* argv[1] */
2365                NULL);
2366          /* if the exec fails, build a string and execute a script */
2367          /*   to display it                                        */
2368          s = (char *)XtMalloc( 50
2369                                + strlen( GETMESSAGE(21, 27, "Error executing file system dialog") )
2370                                + strlen( GETMESSAGE(21, 28, "Attempting to execute: ") )
2371                                + strlen( fileSystem->fsDialogProgram )
2372                                + strlen( fileSystem->path )
2373                                + strlen( strerror(errno) ) );
2374
2375          strcpy (s, GETMESSAGE(21, 27, "Error executing file system dialog"));
2376          strcat (s, "\n");
2377          strcat (s, GETMESSAGE(21, 28, "Attempting to execute: "));
2378          strcat (s, fileSystem->fsDialogProgram);
2379          strcat (s, " ");
2380          strcat (s, fileSystem->path);
2381          strcat (s, "\n");
2382          strcat (s, strerror(errno));
2383          strcat (s, "\n");
2384
2385          execl(errorScript,
2386                errorScript,    /* argv[0] */
2387                s,              /* argv[1] */
2388                NULL);
2389
2390          XtFree( s );
2391
2392          DBGFORK(("%s:  child exiting\n", pname));
2393
2394          exit(EXIT_FAILURE);   /* just in case */
2395          break;
2396
2397       default:  /* parent */
2398          DPRINTF(("in parent after forking file system dialog\n"));
2399          break;
2400
2401    }  /* end switch */
2402
2403    DBGFORK(("%s:  forked child<%d>\n", pname, pid));
2404 }  /* end displayFSDialog */
2405
2406
2407 /************************************************************************
2408  *
2409  *  DontChangeCB -
2410  *
2411  ************************************************************************/
2412 static void
2413 DontChangeCB(
2414         Widget w,
2415         XtPointer client_data,
2416         XtPointer call_data )
2417 {
2418    ModAttrRec  * modAttr_rec = (ModAttrRec *) globalApplyData->modAttr_rec;
2419    Widget close = modAttr_rec->cancel;
2420    Widget ok = modAttr_rec->ok;
2421
2422    XtUnmanageChild((Widget)client_data);
2423    XmUpdateDisplay((Widget)client_data);
2424    XtDestroyWidget((Widget)client_data);
2425
2426    ResetFlag(NULL, ok);
2427    ResetFlag(NULL, close);
2428 }
2429
2430 /************************************************************************
2431  *
2432  *  ChangeCB -
2433  *
2434  *
2435  ************************************************************************/
2436 static void
2437 ChangeCB(
2438         Widget w,
2439         XtPointer client_data,
2440         XtPointer call_data )
2441 {
2442    char *ptr;
2443
2444    XtUnmanageChild((Widget)client_data);
2445    XmUpdateDisplay((Widget)client_data);
2446    XtDestroyWidget((Widget)client_data);
2447
2448    /* user says they want to go ahead with the change, so first let's
2449     * apply the change.
2450     */
2451    (*(globalApplyData->callback)) (w, globalApplyData->client_data, NULL);
2452
2453    /* Now let's change the directory to the Parent directory */
2454    ptr = DtStrrchr(parentDir, '/');
2455    if(ptr != NULL && strcmp(parentDir, "/") != 0)
2456    {
2457       *ptr = '\0';
2458       _DtChangeTo(globalApplyData->client_data, parentDir);
2459    }
2460
2461    XtFree(parentDir);
2462 }
2463 void
2464 ModAttrFreeValues(
2465         ModAttrData *modAttr_data )
2466 {
2467    FreeValues(modAttr_data);
2468 }