clients/moira/attach.c

   1 #if (!defined(lint) && !defined(SABER))
   2   static char rcsid_module_c[] = "$Header$";
   3 #endif
   4
   5 /*      This is the file attach.c for allmaint, the SMS client that allows
   6  *      a user to maintaint most important parts of the SMS database.
   7  *      It Contains: Functions for maintaining data used by Hesiod
   8  *                   to map courses/projects/users to their file systems,
   9  *                   and maintain filesys info.
  10  *
  11  *      Created:        5/4/88
  12  *      By:             Chris D. Peterson
  13  *      Based Upon:     attach.c 87/07/24 marcus
  14  *
  15  *      $Source$
  16  *      $Author$
  17  *      $Header$
  18  *
  19  *      Copyright 1987, 1988 by the Massachusetts Institute of Technology.
  20  *
  21  *      For further information on copyright and distribution
  22  *      see the file mit-copyright.h
  23  */
  24
  25 #include <stdio.h>
  26 #include <strings.h>
  27 #include <sms.h>
  28 #include <menu.h>
  29
  30 #include "mit-copyright.h"
  31 #include "allmaint.h"
  32 #include "allmaint_funcs.h"
  33 #include "globals.h"
  34 #include "infodefs.h"
  35
  36 #define FS_ALIAS_TYPE "FILESYS"
  37
  38 #define LABEL        0
  39 #define MACHINE      1
  40 #define GROUP        2
  41 #define ALIAS        3
  42
  43 #define DEFAULT_TYPE     ("NFS")
  44 #define DEFAULT_MACHINE  DEFAULT_NONE
  45 #define DEFAULT_PACK     DEFAULT_NONE
  46 #define DEFAULT_M_POINT  DEFAULT_NONE
  47 #define DEFAULT_ACCESS   ("r")
  48 #define DEFAULT_COMMENTS DEFAULT_COMMENT
  49 #define DEFAULT_OWNER    (user)
  50 #define DEFAULT_OWNERS   (user)
  51 #define DEFAULT_CREATE   DEFAULT_YES
  52 #define DEFAULT_L_TYPE   ("HOMEDIR")
  53
  54 /*      Function Name: SetDefaults
  55  *      Description: sets the default values for filesystem additions.
  56  *      Arguments: info - an array of char pointers to recieve defaults.
  57  *      Returns: char ** (this array, now filled).
  58  */
  59
  60 static char **
  61 SetDefaults(info, name)
  62 char ** info;
  63 char * name;
  64 {
  65     info[FS_NAME] =     Strsave(name);
  66     info[FS_TYPE] =     Strsave(DEFAULT_TYPE);
  67     info[FS_MACHINE] =  Strsave(DEFAULT_MACHINE);
  68     info[FS_PACK] =     Strsave(DEFAULT_PACK);
  69     info[FS_M_POINT] =  Strsave(DEFAULT_M_POINT);
  70     info[FS_ACCESS] =   Strsave(DEFAULT_ACCESS);
  71     info[FS_COMMENTS] = Strsave(DEFAULT_COMMENTS);
  72     info[FS_OWNER] =    Strsave(DEFAULT_OWNER);
  73     info[FS_OWNERS] =   Strsave(DEFAULT_OWNERS);
  74     info[FS_CREATE] =   Strsave(DEFAULT_CREATE);
  75     info[FS_L_TYPE] =   Strsave(DEFAULT_L_TYPE);
  76     info[FS_MODTIME] = info[FS_MODBY] = info[FS_MODWITH] = info[FS_END] = NULL;
  77     return(info);
  78 }
  79
  80 /*      Function Name: GetFSInfo
  81  *      Description: Stores the info in a queue.
  82  *      Arguments: type - type of information to get.
  83  *                 name - name of the item to get information on.
  84  *      Returns: a pointer to the first element in the queue.
  85  */
  86
  87 static struct qelem *
  88 GetFSInfo(type, name)
  89 int type;
  90 char *name;
  91 {
  92     int stat;
  93     struct qelem * elem = NULL;
  94     char * args[5];
  95
  96     switch (type) {
  97     case LABEL:
  98         if ( (stat = sms_query("get_filesys_by_label", 1, &name,
  99                                StoreInfo, &elem)) != 0) {
 100             com_err(program_name, stat, NULL);
 101             return(NULL);
 102         }
 103         break;
 104     case MACHINE:
 105         if ( (stat = sms_query("get_filesys_by_machine", 1, &name,
 106                                StoreInfo, &elem)) != 0) {
 107             com_err(program_name, stat, NULL);
 108             return(NULL);
 109         }
 110         break;
 111     case GROUP:
 112         if ( (stat = sms_query("get_filesys_by_group", 1, &name,
 113                                StoreInfo, &elem)) != 0) {
 114             com_err(program_name, stat, NULL);
 115             return(NULL);
 116         }
 117         break;
 118     case ALIAS:
 119         args[ALIAS_NAME] = name;
 120         args[ALIAS_TYPE] = FS_ALIAS_TYPE;
 121         args[ALIAS_TRANS] = "*";
 122         if ( (stat = sms_query("get_alias", 3, args, StoreInfo, &elem)) != 0) {
 123             com_err(program_name, stat, " in get_alias.");
 124             return(NULL);
 125         }
 126     }
 127
 128     return(QueueTop(elem));
 129 }
 130
 131 /*      Function Name: PrintFSAlias
 132  *      Description: Prints a filesystem alias
 133  *      Arguments: info - an array contains the strings of info.
 134  *      Returns: the name of the filesys - used be QueryLoop().
 135  */
 136
 137 static char *
 138 PrintFSAlias(info)
 139 char ** info;
 140 {
 141     char buf[BUFSIZ];
 142
 143     sprintf(buf,"Alias: %-25s Filesystem: %s",info[ALIAS_NAME],
 144             info[ALIAS_TRANS]);
 145     Put_message(buf);
 146     return(info[ALIAS_NAME]);
 147 }
 148
 149 /*      Function Name: PrintFSInfo
 150  *      Description: Prints the filesystem information.
 151  *      Arguments: info - a pointer to the filesystem information.
 152  *      Returns: none.
 153  */
 154
 155 static char *
 156 PrintFSInfo(info)
 157 char ** info;
 158 {
 159     char print_buf[BUFSIZ];
 160     FORMFEED;
 161     sprintf(print_buf,"%20s Filesystem: %s",
 162             " ",info[FS_NAME]);
 163     Put_message(print_buf);
 164     sprintf(print_buf,"Type: %-40s Machine: %-15s",
 165             info[FS_TYPE], info[FS_MACHINE]);
 166     Put_message(print_buf);
 167     sprintf(print_buf,"Default Access: %-2s Packname: %-17s Mountpoint %s ",
 168             info[FS_ACCESS], info[FS_PACK], info[FS_M_POINT]);
 169     Put_message(print_buf);
 170     sprintf(print_buf,"Comments; %s",info[FS_COMMENTS]);
 171     Put_message(print_buf);
 172     sprintf(print_buf, "User Ownership: %-30s Group Ownership: %s",
 173             info[FS_OWNER], info[FS_OWNERS]);
 174     Put_message(print_buf);
 175     sprintf(print_buf, "Auto Create: %-34s Locker Type: %s",
 176             atoi(info[FS_CREATE]) ? "ON" : "OFF",
 177             info[FS_L_TYPE]);
 178     Put_message(print_buf);
 179     sprintf(print_buf, MOD_FORMAT, info[FS_MODBY], info[FS_MODTIME],
 180             info[FS_MODWITH]);
 181     Put_message(print_buf);
 182     return(info[FS_NAME]);
 183 }
 184
 185 /*      Function Name: AskFSInfo.
 186  *      Description: This function askes the user for information about a
 187  *                   machine and saves it into a structure.
 188  *      Arguments: info - a pointer the the structure to put the
 189  *                             info into.
 190  *                 name - add a newname field? (T/F)
 191  *      Returns: none.
 192  */
 193
 194 static char **
 195 AskFSInfo(info, name)
 196 char ** info;
 197 Bool name;
 198 {
 199     char temp_buf[BUFSIZ], *newname;
 200
 201     Put_message("");
 202     sprintf(temp_buf, "Changing Attributes of filesystem %s.",
 203             info[FS_NAME]);
 204     Put_message(temp_buf);
 205     Put_message("");
 206
 207     if (name) {
 208         newname = Strsave(info[FS_NAME]);
 209         GetValueFromUser("The new name for this filesystem",
 210                          &newname);
 211     }
 212
 213     GetValueFromUser("Filesystem's Type", &info[FS_TYPE]);
 214     GetValueFromUser("Filesystem's Machine", &info[FS_MACHINE]);
 215     strcpy(temp_buf, CanonicalizeHostname(info[FS_MACHINE]));
 216     free(info[FS_MACHINE]);
 217     info[FS_MACHINE] = Strsave(temp_buf);
 218     GetValueFromUser("Filesystem's Pack Name", &info[FS_PACK]);
 219     GetValueFromUser("Filesystem's Mount Point", &info[FS_M_POINT]);
 220     GetValueFromUser("Filesystem's Default Access", &info[FS_ACCESS]);
 221     GetValueFromUser("Comments about this Filesystem", &info[FS_COMMENTS]);
 222     GetValueFromUser("Filesystem's owner (user)", &info[FS_OWNER]);
 223     GetValueFromUser("Filesystem's owners (group)", &info[FS_OWNERS]);
 224     GetYesNoValueFromUser("Automatically create this filsystem",
 225                      &info[FS_CREATE]);
 226     GetValueFromUser("Filesystem's lockertype", &info[FS_L_TYPE]);
 227
 228     FreeAndClear(&info[FS_MODTIME], TRUE);
 229     FreeAndClear(&info[FS_MODBY], TRUE);
 230     FreeAndClear(&info[FS_MODWITH], TRUE);
 231
 232     if (name)                   /* slide the newname into the #2 slot. */
 233         SlipInNewName(info, newname);
 234
 235     return(info);
 236 }
 237
 238 /* --------------- Filesystem Menu ------------- */
 239
 240 /*      Function Name: GetFS
 241  *      Description: Get Filesystem information by name.
 242  *      Arguments: argc, argv - name of filsys in argv[1].
 243  *      Returns: DM_NORMAL.
 244  */
 245
 246 /* ARGSUSED */
 247 int
 248 GetFS(argc, argv)
 249 int argc;
 250 char **argv;
 251 {
 252     struct qelem *top, *elem;
 253
 254     top = elem = GetFSInfo(LABEL, argv[1]); /* get info. */
 255     while(elem != NULL) {
 256         char ** info = (char **) elem->q_data;
 257         (void) PrintFSInfo(info);
 258         elem = elem->q_forw;
 259     }
 260     FreeQueue(top);             /* clean the queue. */
 261     return (DM_NORMAL);
 262 }
 263
 264 /*      Function Name: RealDeleteFS
 265  *      Description: Does the real deletion work.
 266  *      Arguments: info - array of char *'s containing all useful info.
 267  *                 one_item - a Boolean that is true if only one item
 268  *                              in queue that dumped us here.
 269  *      Returns: none.
 270  */
 271
 272 void
 273 RealDeleteFS(info, one_item)
 274 char ** info;
 275 Bool one_item;
 276 {
 277     int stat;
 278     char temp_buf[BUFSIZ];
 279
 280 /*
 281  * Deletetions are  performed if the user hits 'y' on a list of multiple
 282  * filesystem, or if the user confirms on a unique alias.
 283  */
 284     sprintf(temp_buf, "Are you sure that you want to delete filesystem %s",
 285             info[FS_NAME]);
 286     if(!one_item || Confirm(temp_buf)) {
 287         if ( (stat = sms_query("delete_filesys", 1,
 288                                &info[FS_NAME], Scream, NULL)) != 0)
 289             com_err(program_name, stat, " filesystem not deleted.");
 290         else
 291             Put_message("Filesystem deleted.");
 292     }
 293     else
 294         Put_message("Filesystem not deleted.");
 295 }
 296
 297 /*      Function Name: DeleteFS
 298  *      Description: Delete a filesystem give its name.
 299  *      Arguments: argc, argv - argv[1] is the name of the filesystem.
 300  *      Returns: none.
 301  */
 302
 303 /* ARGSUSED */
 304
 305 int
 306 DeleteFS(argc, argv)
 307 int argc;
 308 char **argv;
 309 {
 310     struct qelem *elem = GetFSInfo(LABEL, argv[1]);
 311     QueryLoop(elem, PrintFSInfo, RealDeleteFS, "Delete the Filesystem");
 312
 313     FreeQueue(elem);
 314     return (DM_NORMAL);
 315 }
 316
 317 /*      Function Name: RealChangeFS
 318  *      Description: performs the actual change to the filesys.
 319  *      Arguments: info - the information
 320  *                 junk - an unused boolean.
 321  *      Returns: none.
 322  */
 323
 324 /* ARGSUSED. */
 325 static void
 326 RealChangeFS(info, junk)
 327 char ** info;
 328 Bool junk;
 329 {
 330     int stat;
 331     char ** args = AskFSInfo(info, TRUE);
 332
 333     if ( (stat = sms_query("update_filesys", CountArgs(args),
 334                            args, NullFunc, NULL)) != 0)
 335         com_err(program_name, stat, ", filesystem not updated");
 336     else
 337         Put_message("filesystem sucessfully updated.");
 338 }
 339
 340 /*      Function Name: ChangeFS
 341  *      Description: change the information in a filesys record.
 342  *      Arguments: arc, argv - value of filsys in argv[1].
 343  *      Returns: DM_NORMAL.
 344  */
 345
 346 /* ARGSUSED */
 347 int
 348 ChangeFS(argc, argv)
 349 char **argv;
 350 int argc;
 351 {
 352     struct qelem *elem = GetFSInfo(LABEL, argv[1]);
 353     QueryLoop(elem, NullPrint, RealChangeFS, "Update the Filesystem");
 354
 355     FreeQueue(elem);
 356     return (DM_NORMAL);
 357 }
 358
 359 /*      Function Name: AddFS
 360  *      Description: change the information in a filesys record.
 361  *      Arguments: arc, argv - name of filsys in argv[1].
 362  *      Returns: DM_NORMAL.
 363  */
 364
 365 /* ARGSUSED */
 366 int
 367 AddFS(argc, argv)
 368 char **argv;
 369 int argc;
 370 {
 371     char *info[MAX_ARGS_SIZE], **args;
 372     int stat;
 373
 374     if ( !ValidName(argv[1]) )
 375         return(DM_NORMAL);
 376
 377     if ( (stat = sms_query("get_filesys_by_label", 1, argv + 1,
 378                            NullFunc, NULL)) == 0) {
 379         Put_message ("A Filesystem by that name already exists.");
 380         return(DM_NORMAL);
 381     } else if (stat != SMS_NO_MATCH) {
 382         com_err(program_name, stat, " in AddFS");
 383         return(DM_NORMAL);
 384     }
 385
 386     args = AskFSInfo(SetDefaults(info, argv[1]), FALSE );
 387
 388     if ( (stat = sms_query("add_filesys", CountArgs(args), args,
 389                          NullFunc, NULL)) != 0)
 390         com_err(program_name, stat, " in AddFS");
 391
 392     FreeInfo(info);
 393     return (DM_NORMAL);
 394 }
 395
 396 /* -------------- Top Level Menu ---------------- */
 397
 398 /*      Function Name: GetFSAlias
 399  *      Description: Gets the value for a Filesystem Alias.
 400  *      Arguments: argc, argv - name of alias in argv[1].
 401  *      Returns: DM_NORMAL.
 402  *      NOTES: There should only be one filesystem per alias, thus
 403  *             this will work correctly.
 404  */
 405
 406 /* ARGSUSED */
 407 int
 408 GetFSAlias(argc, argv)
 409 int argc;
 410 char **argv;
 411 {
 412     struct qelem *top, *elem;
 413
 414     top = elem = GetFSInfo(ALIAS, argv[1]);
 415
 416     Put_message(" ");           /* blank line. */
 417     while (elem != NULL) {
 418         char **info = (char **) elem->q_data;
 419         PrintFSAlias(info);
 420         elem = elem->q_forw;
 421     }
 422
 423     FreeQueue(top);
 424     return(DM_NORMAL);
 425 }
 426
 427 /*      Function Name: CreateFSAlias
 428  *      Description: Create an alias name for a filsystem
 429  *      Arguments: argc, argv - name of alias in argv[1].
 430  *      Returns: DM_NORMAL.
 431  *      NOTES:  This requires (name, type, transl)  I get {name, translation}
 432  *              from the user.  I provide type, which is well-known.
 433  */
 434
 435 /* ARGSUSED */
 436 int
 437 CreateFSAlias(argc, argv)
 438 int argc;
 439 char **argv;
 440 {
 441     register int stat;
 442     struct qelem *elem, *top;
 443     char *args[MAX_ARGS_SIZE], buf[BUFSIZ], **info;
 444
 445     elem = NULL;
 446
 447     if (!ValidName(argv[1]))
 448         return(DM_NORMAL);
 449
 450     args[ALIAS_NAME] = Strsave(argv[1]);
 451     args[ALIAS_TYPE] = Strsave(FS_ALIAS_TYPE);
 452     args[ALIAS_TRANS] = Strsave("*");
 453
 454 /*
 455  * Check to see if this alias already exists in the database, if so then
 456  * print out values, free memory used and then exit.
 457  */
 458
 459     if ( (stat = sms_query("get_alias", 3, args, StoreInfo, &elem)) == 0) {
 460         top = elem = QueueTop(elem);
 461         while (elem != NULL) {
 462             info = (char **) elem->q_data;
 463             sprintf(buf,"The alias: %s currently describes the filesystem %s",
 464                     info[ALIAS_NAME], info[ALIAS_TRANS]);
 465             Put_message(buf);
 466             elem = elem->q_forw;
 467         }
 468         FreeQueue(top);
 469         return(DM_NORMAL);
 470     }
 471     else if ( stat != SMS_NO_MATCH) {
 472         com_err(program_name, stat, " in CreateFSAlias.");
 473         return(DM_NORMAL);
 474     }
 475
 476     args[ALIAS_TRANS]= args[ALIAS_END] = NULL;  /* set to NULL initially. */
 477     GetValueFromUser("Which filesystem will this alias point to?",
 478                      &args[ALIAS_TRANS]);
 479
 480     if ( (stat = sms_query("add_alias", 3, args, NullFunc, NULL)) != 0)
 481         com_err(program_name, stat, " in CreateFSAlias.");
 482
 483     FreeInfo(args);
 484     return (DM_NORMAL);
 485 }
 486
 487 /*      Function Name: RealDeleteFSAlias
 488  *      Description: Does the real deletion work.
 489  *      Arguments: info - array of char *'s containing all useful info.
 490  *                 one_item - a Boolean that is true if only one item
 491  *                              in queue that dumped us here.
 492  *      Returns: none.
 493  */
 494
 495 void
 496 RealDeleteFSAlias(info, one_item)
 497 char ** info;
 498 Bool one_item;
 499 {
 500     int stat;
 501     char temp_buf[BUFSIZ];
 502
 503 /*
 504  * Deletetions are  performed if the user hits 'y' on a list of multiple
 505  * filesystem, or if the user confirms on a unique alias.
 506  */
 507     sprintf(temp_buf,
 508             "Are you sure that you want to delete the filesystem alias %s",
 509             info[ALIAS_NAME]);
 510     if(!one_item || Confirm(temp_buf)) {
 511         if ( (stat = sms_query("delete_alias", CountArgs(info),
 512                                info, Scream, NULL)) != 0 )
 513             com_err(program_name, stat, " filesystem alias not deleted.");
 514         else
 515             Put_message("Filesystem alias deleted.");
 516     }
 517     else
 518         Put_message("Filesystem alias not deleted.");
 519 }
 520
 521 /*      Function Name: DeleteFSAlias
 522  *      Description: Delete an alias name for a filsystem
 523  *      Arguments: argc, argv - name of alias in argv[1].
 524  *      Returns: DM_NORMAL.
 525  *      NOTES:  This requires (name, type, transl)  I get {name, translation}
 526  *              from the user.  I provide type, which is well-known.
 527  */
 528
 529 /* ARGSUSED */
 530 int
 531 DeleteFSAlias(argc, argv)
 532 int argc;
 533 char **argv;
 534 {
 535     struct qelem *elem = GetFSInfo(ALIAS, argv[1]);
 536     QueryLoop(elem, PrintFSAlias, RealDeleteFSAlias,
 537               "Delete the Filesystem Alias");
 538     FreeQueue(elem);
 539     return (DM_NORMAL);
 540 }
 541
 542 /*      Function Name: AttachHelp
 543  *      Description: Print help info on attachmaint.
 544  *      Arguments: none
 545  *      Returns: DM_NORMAL.
 546  */
 547
 548 int
 549 AttachHelp()
 550 {
 551     static char *message[] = {
 552       "These are the options:\n\n",
 553       "get - get information about a filesystem.\n",
 554       "add - add a new filesystem to the data base.\n",
 555       "update - update the information in the database on a filesystem.\n",
 556       "delete - delete a filesystem from the database.\n",
 557       "check - check information about association of a name and a filesys.\n",
 558       "alias - associate a name with a filsystem.\n",
 559       "unalias - disassociate a name with a filesystem.\n",
 560       "verbose - toggle the request for delete confirmation.\n",
 561         NULL,
 562     };
 563
 564     return(PrintHelp(message));
 565 }
 566
 567 /*
 568  * Local Variables:
 569  * mode: c
 570  * c-indent-level: 4
 571  * c-continued-statement-offset: 4
 572  * c-brace-offset: -4
 573  * c-argdecl-indent: 4
 574  * c-label-offset: -4
 575  * End:
 576  */