cde/programs/dtfile/ModAttr.c

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