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 the MOIRA Client, which allows a nieve
   6  *      user to quickly and easily maintain most parts of the MOIRA 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  *
  14  *      $Source$
  15  *      $Author$
  16  *      $Header$
  17  *
  18  *      Copyright 1988 by the Massachusetts Institute of Technology.
  19  *
  20  *      For further information on copyright and distribution
  21  *      see the file mit-copyright.h
  22  */
  23
  24 #include <stdio.h>
  25 #include <strings.h>
  26 #include <moira.h>
  27 #include <moira_site.h>
  28 #include <menu.h>
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <ctype.h>
  32
  33 #include "mit-copyright.h"
  34 #include "defs.h"
  35 #include "f_defs.h"
  36 #include "globals.h"
  37
  38 #define FS_ALIAS_TYPE "FILESYS"
  39
  40 #define LABEL        0
  41 #define MACHINE      1
  42 #define GROUP        2
  43 #define ALIAS        3
  44
  45 #define NO_MACHINE       ("\\[NONE\\]") /* C will remove one of the /'s here,
  46                                          * and the other quotes the [ for
  47                                          * ingres' regexp facility. */
  48 #define NO_MACHINE_BAD   ("[NONE]")
  49
  50 #define DEFAULT_TYPE     ("NFS")
  51 #define DEFAULT_MACHINE  DEFAULT_NONE
  52 #define DEFAULT_PACK     DEFAULT_NONE
  53 #define DEFAULT_ACCESS   ("w")
  54 #define DEFAULT_COMMENTS DEFAULT_COMMENT
  55 #define DEFAULT_OWNER    (user)
  56 #define DEFAULT_OWNERS   (user)
  57 #define DEFAULT_CREATE   DEFAULT_YES
  58 #define DEFAULT_L_TYPE   ("PROJECT")
  59 #define DEFAULT_CELL     ("athena.mit.edu")
  60
  61 /*      Function Name: SetDefaults
  62  *      Description: sets the default values for filesystem additions.
  63  *      Arguments: info - an array of char pointers to recieve defaults.
  64  *      Returns: char ** (this array, now filled).
  65  */
  66
  67 static char **
  68 SetDefaults(info, name)
  69 char ** info;
  70 char * name;
  71 {
  72     char buf[BUFSIZ];
  73
  74     info[FS_NAME] =     Strsave(name);
  75     info[FS_TYPE] =     Strsave(DEFAULT_TYPE);
  76     info[FS_MACHINE] =  Strsave(DEFAULT_MACHINE);
  77     info[FS_PACK] =     Strsave(DEFAULT_PACK);
  78     sprintf(buf, "/mit/%s", name);
  79     info[FS_M_POINT] =  Strsave(buf);
  80     info[FS_ACCESS] =   Strsave(DEFAULT_ACCESS);
  81     info[FS_COMMENTS] = Strsave(DEFAULT_COMMENTS);
  82     info[FS_OWNER] =    Strsave(DEFAULT_OWNER);
  83     info[FS_OWNERS] =   Strsave(DEFAULT_OWNERS);
  84     info[FS_CREATE] =   Strsave(DEFAULT_CREATE);
  85     info[FS_L_TYPE] =   Strsave(DEFAULT_L_TYPE);
  86     info[FS_MODTIME] = info[FS_MODBY] = info[FS_MODWITH] = info[FS_END] = NULL;
  87     return(info);
  88 }
  89
  90 /*      Function Name: GetFSInfo
  91  *      Description: Stores the info in a queue.
  92  *      Arguments: type - type of information to get.
  93  *                 name - name of the item to get information on.
  94  *      Returns: a pointer to the first element in the queue.
  95  */
  96
  97 static struct qelem *
  98 GetFSInfo(type, name)
  99 int type;
 100 char *name;
 101 {
 102     int stat;
 103     struct qelem * elem = NULL;
 104     char * args[5];
 105
 106     switch (type) {
 107     case LABEL:
 108         if ( (stat = do_mr_query("get_filesys_by_label", 1, &name,
 109                                   StoreInfo, (char *)&elem)) != 0) {
 110             com_err(program_name, stat, " in GetFSInfo");
 111             return(NULL);
 112         }
 113         break;
 114     case MACHINE:
 115         if ( (stat = do_mr_query("get_filesys_by_machine", 1, &name,
 116                                   StoreInfo, (char *)&elem)) != 0) {
 117             com_err(program_name, stat, " in GetFSInfo");
 118             return(NULL);
 119         }
 120         break;
 121     case GROUP:
 122         if ( (stat = do_mr_query("get_filesys_by_group", 1, &name,
 123                                   StoreInfo, (char *)&elem)) != 0) {
 124             com_err(program_name, stat, " in GetFSInfo");
 125             return(NULL);
 126         }
 127         break;
 128     case ALIAS:
 129         args[ALIAS_NAME] = name;
 130         args[ALIAS_TYPE] = FS_ALIAS_TYPE;
 131         args[ALIAS_TRANS] = "*";
 132         if ( (stat = do_mr_query("get_alias", 3, args, StoreInfo,
 133                                   (char *) &elem)) != 0) {
 134             com_err(program_name, stat, " in get_alias.");
 135             return(NULL);
 136         }
 137     }
 138
 139     return(QueueTop(elem));
 140 }
 141
 142 /*      Function Name: PrintFSAlias
 143  *      Description: Prints a filesystem alias
 144  *      Arguments: info - an array contains the strings of info.
 145  *      Returns: the name of the filesys - used be QueryLoop().
 146  */
 147
 148 static char *
 149 PrintFSAlias(info)
 150 char ** info;
 151 {
 152     char buf[BUFSIZ];
 153
 154     sprintf(buf,"Alias: %-25s Filesystem: %s",info[ALIAS_NAME],
 155             info[ALIAS_TRANS]);
 156     Put_message(buf);
 157     return(info[ALIAS_NAME]);
 158 }
 159
 160 static int fsgCount = 1;
 161
 162 static char *
 163 PrintFSGMembers(info)
 164 char ** info;
 165 {
 166     char print_buf[BUFSIZ];
 167
 168     sprintf(print_buf, "  %d. Filesystem: %-32s (sort key: %s)", fsgCount++, info[0], info[1]);
 169     Put_message(print_buf);
 170     return(info[0]);
 171 }
 172
 173
 174 /*      Function Name: PrintFSInfo
 175  *      Description: Prints the filesystem information.
 176  *      Arguments: info - a pointer to the filesystem information.
 177  *      Returns: none.
 178  */
 179
 180 static char *
 181 PrintFSInfo(info)
 182 char ** info;
 183 {
 184     char print_buf[BUFSIZ];
 185
 186     FORMFEED;
 187
 188     if (!strcmp(info[FS_TYPE], "FSGROUP") || !strcmp(info[FS_TYPE], "MUL")) {
 189         int stat;
 190         struct qelem *elem = NULL;
 191
 192         if (!strcmp(info[FS_TYPE], "MUL"))
 193           sprintf(print_buf,"%20s Multiple Filesystem: %s", " ", info[FS_NAME]);
 194         else
 195           sprintf(print_buf,"%20s Filesystem Group: %s", " ", info[FS_NAME]);
 196         Put_message(print_buf);
 197
 198         sprintf(print_buf,"Comments: %s",info[FS_COMMENTS]);
 199         Put_message(print_buf);
 200         sprintf(print_buf, MOD_FORMAT, info[FS_MODBY], info[FS_MODTIME],
 201                 info[FS_MODWITH]);
 202         Put_message(print_buf);
 203         Put_message("Containing the filesystems (in order):");
 204         if ((stat = do_mr_query("get_fsgroup_members", 1, &info[FS_NAME],
 205                                  StoreInfo, (char *)&elem)) != 0) {
 206             if (stat == MR_NO_MATCH)
 207               Put_message("    [no members]");
 208             else
 209               com_err(program_name, stat, " in PrintFSInfo");
 210         } else {
 211             fsgCount = 1;
 212             Loop(QueueTop(elem), (void *) PrintFSGMembers);
 213             FreeQueue(elem);
 214         }
 215     } else {
 216         sprintf(print_buf,"%20s Filesystem: %s", " ", info[FS_NAME]);
 217         Put_message(print_buf);
 218         sprintf(print_buf,"Type: %-40s Machine: %-15s",
 219                 info[FS_TYPE], info[FS_MACHINE]);
 220         Put_message(print_buf);
 221         sprintf(print_buf,"Default Access: %-2s Packname: %-17s Mountpoint %s ",
 222                 info[FS_ACCESS], info[FS_PACK], info[FS_M_POINT]);
 223         Put_message(print_buf);
 224         sprintf(print_buf,"Comments: %s",info[FS_COMMENTS]);
 225         Put_message(print_buf);
 226         sprintf(print_buf, "User Ownership: %-30s Group Ownership: %s",
 227                 info[FS_OWNER], info[FS_OWNERS]);
 228         Put_message(print_buf);
 229         sprintf(print_buf, "Auto Create: %-34s Locker Type: %s",
 230                 atoi(info[FS_CREATE]) ? "ON" : "OFF",
 231                 info[FS_L_TYPE]);
 232         Put_message(print_buf);
 233         sprintf(print_buf, MOD_FORMAT, info[FS_MODBY], info[FS_MODTIME],
 234                 info[FS_MODWITH]);
 235         Put_message(print_buf);
 236     }
 237     return(info[FS_NAME]);
 238 }
 239
 240
 241 char *canonicalize_cell(c)
 242 char *c;
 243 {
 244     struct stat stbuf;
 245     char path[512];
 246     int count;
 247
 248     sprintf(path, "/afs/%s", c);
 249     if (lstat(path, &stbuf) || !stbuf.st_mode&S_IFLNK)
 250       return(c);
 251     count = readlink(path, path, sizeof(path));
 252     if (count < 1) return(c);
 253     path[count] = 0;
 254     free(c);
 255     return(strsave(path));
 256 }
 257
 258
 259 int GetAliasValue(argc, argv, retval)
 260 int argc;
 261 char **argv;
 262 char **retval;
 263 {
 264     *retval = strsave(argv[2]);
 265     return(MR_CONT);
 266 }
 267
 268 /*      Function Name: AskFSInfo.
 269  *      Description: This function askes the user for information about a
 270  *                   machine and saves it into a structure.
 271  *      Arguments: info - a pointer the the structure to put the
 272  *                             info into.
 273  *                 name - add a newname field? (T/F)
 274  *      Returns: none.
 275  */
 276
 277 static char **
 278 AskFSInfo(info, name)
 279 char ** info;
 280 Bool name;
 281 {
 282     char temp_buf[BUFSIZ], *newname, access_type[32];
 283     int fsgroup = 0, newdefaults = 0;
 284
 285     Put_message("");
 286     sprintf(temp_buf, "Changing Attributes of filesystem %s.",
 287             info[FS_NAME]);
 288     Put_message(temp_buf);
 289     Put_message("");
 290
 291     if (name) {
 292         newname = Strsave(info[FS_NAME]);
 293         if (GetValueFromUser("The new name for this filesystem",
 294                              &newname) == SUB_ERROR)
 295           return(NULL);
 296     }
 297
 298     strcpy(temp_buf, info[FS_TYPE]);
 299     if (GetTypeFromUser("Filesystem's Type", "filesys", &info[FS_TYPE]) ==
 300         SUB_ERROR)
 301       return(NULL);
 302     if (!strcasecmp(info[FS_TYPE], "FSGROUP") ||
 303         !strcasecmp(info[FS_TYPE], "MUL"))
 304       fsgroup++;
 305     if (strcasecmp(info[FS_TYPE], temp_buf))
 306       newdefaults++;
 307     if (fsgroup) {
 308         free(info[FS_MACHINE]);
 309         info[FS_MACHINE] = Strsave(NO_MACHINE);
 310     } else {
 311         if (!strcmp(info[FS_MACHINE], NO_MACHINE_BAD)) {
 312             free(info[FS_MACHINE]);
 313             info[FS_MACHINE] = Strsave(NO_MACHINE);
 314         }
 315         if (!strcasecmp(info[FS_TYPE], "AFS")) {
 316             if (!name || newdefaults) {
 317                 free(info[FS_MACHINE]);
 318                 info[FS_MACHINE] = strsave(DEFAULT_CELL);
 319             }
 320             if (GetValueFromUser("Filesystem's Cell", &info[FS_MACHINE]) ==
 321                 SUB_ERROR)
 322               return(NULL);
 323             info[FS_MACHINE] = canonicalize_cell(info[FS_MACHINE]);
 324         } else {
 325             if (GetValueFromUser("Filesystem's Machine", &info[FS_MACHINE]) ==
 326                 SUB_ERROR)
 327               return(NULL);
 328             info[FS_MACHINE] = canonicalize_hostname(info[FS_MACHINE]);
 329         }
 330     }
 331     if (!fsgroup) {
 332         if (!strcasecmp(info[FS_TYPE], "AFS")) {
 333             char *path, *args[3], *p;
 334             int status, depth, i;
 335             if (GetTypeFromUser("Filesystem's lockertype", "lockertype",
 336                                 &info[FS_L_TYPE]) == SUB_ERROR)
 337               return(NULL);
 338             if (!name || newdefaults) {
 339                 free(info[FS_PACK]);
 340                 lowercase(info[FS_MACHINE]);
 341                 sprintf(temp_buf, "%s:%s", info[FS_MACHINE], info[FS_L_TYPE]);
 342                 args[0] = temp_buf;
 343                 args[1] = "AFSPATH";
 344                 args[2] = "*";
 345                 path = "???";
 346                 status = do_mr_query("get_alias", 3, args,
 347                                      GetAliasValue, &path);
 348                 if (status == MR_SUCCESS) {
 349                     p = index(path, ':');
 350                     if (p) {
 351                         *p = 0;
 352                         depth = atoi(++p);
 353                     } else
 354                       depth = 0;
 355                     sprintf(temp_buf, "/afs/%s/%s", info[FS_MACHINE], path);
 356                     if (depth >= 0) {
 357                         for (p=info[FS_NAME]; *p&&(p-info[FS_NAME])<depth; p++) {
 358                             if (islower(*p)) {
 359                                 strcat(temp_buf, "/x");
 360                                 temp_buf[strlen(temp_buf)-1] = *p;
 361                             } else
 362                               strcat(temp_buf, "/other");
 363                         }
 364                     } else if (depth = -1) {
 365                         if (isdigit(info[FS_NAME][0])) {
 366                             strcat(temp_buf, "/");
 367                             depth = strlen(temp_buf);
 368                             for (p = info[FS_NAME]; *p && isdigit(*p); p++) {
 369                                 temp_buf[depth++] = *p;
 370                                 temp_buf[depth] = 0;
 371                             }
 372                         } else
 373                           strcat(temp_buf, "/other");
 374                     } else {
 375                         /* no default */
 376                     }
 377                     strcat(temp_buf, "/");
 378                     strcat(temp_buf, info[FS_NAME]);
 379                     free(path);
 380                 } else {
 381                     sprintf(temp_buf, "/afs/%s/%s/%s", info[FS_MACHINE],
 382                             lowercase(info[FS_L_TYPE]), info[FS_NAME]);
 383                 }
 384                 info[FS_PACK] = strsave(temp_buf);
 385             }
 386         }
 387         if (GetValueFromUser("Filesystem's Pack Name", &info[FS_PACK]) ==
 388             SUB_ERROR)
 389           return(NULL);
 390         if (GetValueFromUser("Filesystem's Mount Point", &info[FS_M_POINT]) ==
 391             SUB_ERROR)
 392           return(NULL);
 393         sprintf(access_type, "fs_access_%s", info[FS_TYPE]);
 394         if (GetTypeFromUser("Filesystem's Default Access", access_type,
 395                             &info[FS_ACCESS]) == SUB_ERROR)
 396           return(NULL);
 397     }
 398     if (GetValueFromUser("Comments about this Filesystem", &info[FS_COMMENTS])
 399         == SUB_ERROR)
 400       return(NULL);
 401     if (GetValueFromUser("Filesystem's owner (user)", &info[FS_OWNER]) ==
 402         SUB_ERROR)
 403       return(NULL);
 404     if (GetValueFromUser("Filesystem's owners (group)", &info[FS_OWNERS]) ==
 405         SUB_ERROR)
 406       return(NULL);
 407     if (!fsgroup)
 408       if (GetYesNoValueFromUser("Automatically create this filesystem",
 409                                 &info[FS_CREATE]) == SUB_ERROR)
 410         return(NULL);
 411     if (strcasecmp(info[FS_TYPE], "AFS")) {
 412         if (GetTypeFromUser("Filesystem's lockertype", "lockertype",
 413                             &info[FS_L_TYPE]) == SUB_ERROR)
 414           return(NULL);
 415     }
 416
 417     FreeAndClear(&info[FS_MODTIME], TRUE);
 418     FreeAndClear(&info[FS_MODBY], TRUE);
 419     FreeAndClear(&info[FS_MODWITH], TRUE);
 420
 421     if (name)                   /* slide the newname into the #2 slot. */
 422         SlipInNewName(info, newname);
 423
 424     return(info);
 425 }
 426
 427
 428 /* --------------- Filesystem Menu ------------- */
 429
 430 /*      Function Name: GetFS
 431  *      Description: Get Filesystem information by name.
 432  *      Arguments: argc, argv - name of filsys in argv[1].
 433  *      Returns: DM_NORMAL.
 434  */
 435
 436 /* ARGSUSED */
 437 int
 438 GetFS(argc, argv)
 439 int argc;
 440 char **argv;
 441 {
 442     struct qelem *top;
 443
 444     top = GetFSInfo(LABEL, argv[1]); /* get info. */
 445     Loop(top, (void *) PrintFSInfo);
 446     FreeQueue(top);             /* clean the queue. */
 447     return (DM_NORMAL);
 448 }
 449
 450 /*      Function Name: GetFSM
 451  *      Description: Get Filesystem information by machine.
 452  *      Arguments: argc, argv - name of server in argv[1].
 453  *      Returns: DM_NORMAL.
 454  */
 455
 456 /* ARGSUSED */
 457 int
 458 GetFSM(argc, argv)
 459 int argc;
 460 char **argv;
 461 {
 462     struct qelem *top;
 463
 464     argv[1] = canonicalize_hostname(strsave(argv[1]));
 465     top = GetFSInfo(MACHINE, argv[1]); /* get info. */
 466     Loop(top, (void *) PrintFSInfo);
 467     FreeQueue(top);             /* clean the queue. */
 468     return (DM_NORMAL);
 469 }
 470
 471 /*      Function Name: RealDeleteFS
 472  *      Description: Does the real deletion work.
 473  *      Arguments: info - array of char *'s containing all useful info.
 474  *                 one_item - a Boolean that is true if only one item
 475  *                              in queue that dumped us here.
 476  *      Returns: none.
 477  */
 478
 479 void
 480 RealDeleteFS(info, one_item)
 481 char ** info;
 482 Bool one_item;
 483 {
 484     int stat;
 485     char temp_buf[BUFSIZ];
 486
 487 /*
 488  * Deletetions are  performed if the user hits 'y' on a list of multiple
 489  * filesystem, or if the user confirms on a unique alias.
 490  */
 491     sprintf(temp_buf, "Are you sure that you want to delete filesystem %s",
 492             info[FS_NAME]);
 493     if(!one_item || Confirm(temp_buf)) {
 494         if ( (stat = do_mr_query("delete_filesys", 1,
 495                                   &info[FS_NAME], Scream, NULL)) != 0)
 496             com_err(program_name, stat, " filesystem not deleted.");
 497         else
 498             Put_message("Filesystem deleted.");
 499     }
 500     else
 501         Put_message("Filesystem not deleted.");
 502 }
 503
 504 /*      Function Name: DeleteFS
 505  *      Description: Delete a filesystem give its name.
 506  *      Arguments: argc, argv - argv[1] is the name of the filesystem.
 507  *      Returns: none.
 508  */
 509
 510 /* ARGSUSED */
 511
 512 int
 513 DeleteFS(argc, argv)
 514 int argc;
 515 char **argv;
 516 {
 517     struct qelem *elem = GetFSInfo(LABEL, argv[1]);
 518     QueryLoop(elem, PrintFSInfo, RealDeleteFS, "Delete the Filesystem");
 519
 520     FreeQueue(elem);
 521     return (DM_NORMAL);
 522 }
 523
 524 /*      Function Name: RealChangeFS
 525  *      Description: performs the actual change to the filesys.
 526  *      Arguments: info - the information
 527  *                 junk - an unused boolean.
 528  *      Returns: none.
 529  */
 530
 531 /* ARGSUSED. */
 532 static void
 533 RealChangeFS(info, junk)
 534 char ** info;
 535 Bool junk;
 536 {
 537     int stat;
 538     char ** args;
 539     extern Menu nfsphys_menu;
 540
 541     args = AskFSInfo(info, TRUE);
 542     if (args == NULL) {
 543         Put_message("Aborted.");
 544         return;
 545     }
 546     stat = do_mr_query("update_filesys", CountArgs(args), args,
 547                         NullFunc, NULL);
 548     switch (stat) {
 549     case MR_NFS:
 550         Put_message("That NFS filesystem is not exported.");
 551         if (YesNoQuestion("Fix this now (Y/N)", TRUE) == TRUE) {
 552             Do_menu(&nfsphys_menu, 0, NULL);
 553             if (YesNoQuestion("Retry filesystem update now (Y/N)", TRUE)
 554                 == TRUE) {
 555                 if (stat = do_mr_query("update_filesys", CountArgs(args), args,
 556                                         NullFunc, NULL))
 557                     com_err(program_name, stat, " filesystem not updated");
 558                 else
 559                     Put_message("filesystem sucessfully updated.");
 560             }
 561         }
 562         break;
 563     case MR_SUCCESS:
 564         break;
 565     default:
 566         com_err(program_name, stat, " in UpdateFS");
 567     }
 568 }
 569
 570 /*      Function Name: ChangeFS
 571  *      Description: change the information in a filesys record.
 572  *      Arguments: arc, argv - value of filsys in argv[1].
 573  *      Returns: DM_NORMAL.
 574  */
 575
 576 /* ARGSUSED */
 577 int
 578 ChangeFS(argc, argv)
 579 char **argv;
 580 int argc;
 581 {
 582     struct qelem *elem = GetFSInfo(LABEL, argv[1]);
 583     QueryLoop(elem, NullPrint, RealChangeFS, "Update the Filesystem");
 584
 585     FreeQueue(elem);
 586     return (DM_NORMAL);
 587 }
 588
 589 /*      Function Name: AddFS
 590  *      Description: change the information in a filesys record.
 591  *      Arguments: arc, argv - name of filsys in argv[1].
 592  *      Returns: DM_NORMAL.
 593  */
 594
 595 /* ARGSUSED */
 596 int
 597 AddFS(argc, argv)
 598 char **argv;
 599 int argc;
 600 {
 601     char *info[MAX_ARGS_SIZE], **args, buf[BUFSIZ];
 602     int stat;
 603     extern Menu nfsphys_menu;
 604
 605     if ( !ValidName(argv[1]) )
 606         return(DM_NORMAL);
 607
 608     if ( (stat = do_mr_query("get_filesys_by_label", 1, argv + 1,
 609                               NullFunc, NULL)) == 0) {
 610         Put_message ("A Filesystem by that name already exists.");
 611         return(DM_NORMAL);
 612     } else if (stat != MR_NO_MATCH) {
 613         com_err(program_name, stat, " in AddFS");
 614         return(DM_NORMAL);
 615     }
 616
 617     if ((args = AskFSInfo(SetDefaults(info, argv[1]), FALSE )) == NULL) {
 618         Put_message("Aborted.");
 619         return(DM_NORMAL);
 620     }
 621
 622     stat = do_mr_query("add_filesys", CountArgs(args), args, NullFunc, NULL);
 623     switch (stat) {
 624     case MR_NFS:
 625         Put_message("That NFS filesystem is not exported.");
 626         if (YesNoQuestion("Fix this now (Y/N)", TRUE) == TRUE) {
 627             Do_menu(&nfsphys_menu, 0, NULL);
 628             if (YesNoQuestion("Retry filesystem creation now (Y/N)", TRUE)
 629                 == TRUE) {
 630                 if (stat = do_mr_query("add_filesys", CountArgs(args), args,
 631                                         NullFunc, NULL))
 632                     com_err(program_name, stat, " in AddFS");
 633                 else
 634                     Put_message("Created.");
 635             }
 636         }
 637         break;
 638     case MR_SUCCESS:
 639         break;
 640     default:
 641         com_err(program_name, stat, " in AddFS");
 642     }
 643
 644     if (stat == MR_SUCCESS && !strcasecmp(info[FS_L_TYPE], "HOMEDIR")) {
 645         static char *val[] = {"def_quota", NULL};
 646         static char *def_quota = NULL;
 647         char *argv[Q_QUOTA + 1];
 648         struct qelem *top = NULL;
 649
 650         if (def_quota == NULL) {
 651             stat = do_mr_query("get_value", CountArgs(val), val,
 652                                 StoreInfo, (char *) &top);
 653             if (stat != MR_SUCCESS) {
 654                 com_err(program_name, stat, " getting default quota");
 655             } else {
 656                 top = QueueTop(top);
 657                 def_quota = Strsave(((char **)top->q_data)[0]);
 658                 FreeQueue(top);
 659             }
 660         }
 661         if (def_quota != NULL) {
 662             sprintf(buf, "Give user %s a quota of %s on filesys %s (Y/N)",
 663                     info[FS_NAME], def_quota, info[FS_NAME]);
 664             if (YesNoQuestion(buf, 1) == TRUE) {
 665                 argv[Q_NAME] = argv[Q_FILESYS] = info[FS_NAME];
 666                 if (!strcmp(info[FS_TYPE], "NFS"))
 667                   argv[Q_TYPE] = "USER";
 668                 else
 669                   argv[Q_TYPE] = "ANY";
 670                 argv[Q_QUOTA] = def_quota;
 671                 if ((stat = do_mr_query("add_quota", Q_QUOTA+1, argv, Scream,
 672                                          (char *) NULL)) != MR_SUCCESS) {
 673                     com_err(program_name, stat, " while adding quota");
 674                 }
 675             }
 676         }
 677     } else if (stat == MR_SUCCESS) {
 678         if (YesNoQuestion("Assign a quota on this filesystem (Y/N)", 1)
 679             == TRUE) {
 680             parsed_argc = 1;
 681             parsed_argv[0] = info[FS_NAME];
 682             AddQuota();
 683         }
 684     }
 685
 686     FreeInfo(info);
 687     return (DM_NORMAL);
 688 }
 689
 690 /*      Function Name: SortAfter
 691  *      Description: choose a sortkey to cause an item to be added after
 692  *              the count element in the queue
 693  *      Arguments: queue of filesys names & sortkeys, queue count pointer
 694  *      Returns: sort key to use.
 695  */
 696
 697 /* ARGSUSED */
 698 char *
 699 SortAfter(elem, count)
 700 struct qelem *elem;
 701 int count;
 702 {
 703     char *prev, *next, prevnext, *key, keybuf[9];
 704
 705     /* first find the two keys we need to insert between */
 706     prev = "A";
 707     for (; count > 0; count--) {
 708         prev = ((char **)elem->q_data)[1];
 709         if (elem->q_forw)
 710           elem = elem->q_forw;
 711         else
 712           break;
 713     }
 714     if (count > 0)
 715       next = "Z";
 716     else
 717       next = ((char **)elem->q_data)[1];
 718
 719     /* now copy the matching characters */
 720     for (key = keybuf; *prev && *prev == *next; next++) {
 721         *key++ = *prev++;
 722     }
 723
 724     /* and set the last character */
 725     if (*prev == 0)
 726       *prev = prevnext = 'A';
 727     else
 728       prevnext = prev[1];
 729     if (prevnext == 0)
 730       prevnext = 'A';
 731     if (*next == 0)
 732       *next = 'Z';
 733     if (*next - *prev > 1) {
 734         *key++ = (*next + *prev)/2;
 735     } else {
 736         *key++ = *prev;
 737         *key++ = (prevnext + 'Z')/2;
 738     }
 739     *key = 0;
 740     return(Strsave(keybuf));
 741 }
 742
 743 /*      Function Name: AddFSToGroup
 744  *      Description: add a filesystem to an FS group
 745  *      Arguments: arc, argv - name of group in argv[1], filesys in argv[2].
 746  *      Returns: DM_NORMAL.
 747  */
 748
 749 /* ARGSUSED */
 750 int
 751 AddFSToGroup(argc, argv)
 752 char **argv;
 753 int argc;
 754 {
 755     int stat, count;
 756     struct qelem *elem = NULL;
 757     char buf[BUFSIZ], *args[5], *bufp;
 758
 759     if ((stat = do_mr_query("get_fsgroup_members", 1, argv+1, StoreInfo,
 760                              (char *)&elem)) != 0) {
 761         if (stat != MR_NO_MATCH)
 762           com_err(program_name, stat, " in AddFSToGroup");
 763     }
 764     if (elem == NULL) {
 765         args[0] = argv[1];
 766         args[1] = argv[2];
 767         args[2] = "M";
 768         stat = do_mr_query("add_filesys_to_fsgroup", 3, args, Scream, NULL);
 769         if (stat)
 770           com_err(program_name, stat, " in AddFSToGroup");
 771         return(DM_NORMAL);
 772     }
 773     elem = QueueTop(elem);
 774     fsgCount = 1;
 775     Loop(elem, (void *) PrintFSGMembers);
 776     sprintf(buf, "%d", QueueCount(elem));
 777     bufp = Strsave(buf);
 778     if (GetValueFromUser("Enter number of filesystem it should follow (0 to make it first):", &bufp) == SUB_ERROR)
 779       return(DM_NORMAL);
 780     count = atoi(bufp);
 781     free(bufp);
 782     args[2] = SortAfter(elem, count);
 783
 784     FreeQueue(QueueTop(elem));
 785     args[0] = argv[1];
 786     args[1] = argv[2];
 787     stat = do_mr_query("add_filesys_to_fsgroup", 3, args, Scream, NULL);
 788     if (stat == MR_EXISTS) {
 789         Put_message("That filesystem is already a member of the group.");
 790         Put_message("Use the order command if you want to change the sorting order.");
 791     } else if (stat)
 792       com_err(program_name, stat, " in AddFSToGroup");
 793     return(DM_NORMAL);
 794 }
 795
 796
 797 /*      Function Name: RemoveFSFromGroup
 798  *      Description: delete a filesystem from an FS group
 799  *      Arguments: arc, argv - name of group in argv[1].
 800  *      Returns: DM_NORMAL.
 801  */
 802
 803 /* ARGSUSED */
 804 int
 805 RemoveFSFromGroup(argc, argv)
 806 char **argv;
 807 int argc;
 808 {
 809     int stat;
 810     char buf[BUFSIZ];
 811
 812     sprintf(buf, "Delete filesystem %s from FS group %s", argv[2], argv[1]);
 813     if (!Confirm(buf))
 814       return(DM_NORMAL);
 815     if ((stat = do_mr_query("remove_filesys_from_fsgroup", 2, argv+1,
 816                              Scream, NULL)) != 0) {
 817         com_err(program_name, stat, ", not removed.");
 818     }
 819     return(DM_NORMAL);
 820 }
 821
 822 /*      Function Name: ChangeFSGroupOrder
 823  *      Description: change the sortkey on a filesys in an FSgroup
 824  *      Arguments: arc, argv - name of group in argv[1].
 825  *      Returns: DM_NORMAL.
 826  */
 827
 828 /* ARGSUSED */
 829 int
 830 ChangeFSGroupOrder(argc, argv)
 831 char **argv;
 832 int argc;
 833 {
 834     int stat, src, dst, i;
 835     struct qelem *elem = NULL, *top, *tmpelem;
 836     char buf[BUFSIZ], *bufp, *args[3];
 837
 838     if ((stat = do_mr_query("get_fsgroup_members", 1, argv+1, StoreInfo,
 839                              (char *)&elem)) != 0) {
 840         if (stat == MR_NO_MATCH) {
 841             sprintf(buf,
 842                     "Ether %s is not a filesystem group or it has no members",
 843                     argv[1]);
 844             Put_message(buf);
 845         } else
 846           com_err(program_name, stat, " in ChangeFSGroupOrder");
 847         return(DM_NORMAL);
 848     }
 849     top = QueueTop(elem);
 850     fsgCount = 1;
 851     Loop(top, (void *) PrintFSGMembers);
 852     while (1) {
 853         bufp = Strsave("1");
 854         if (GetValueFromUser("Enter number of the filesystem to move:",
 855                              &bufp) == SUB_ERROR)
 856           return(DM_NORMAL);
 857         src = atoi(bufp);
 858         free(bufp);
 859         if (src < 0) {
 860             Put_message("You must enter a positive number (or 0 to abort).");
 861             continue;
 862         } else if (src == 0) {
 863             Put_message("Aborted.");
 864             return(DM_NORMAL);
 865         }
 866         for (elem = top, i = src; i-- > 1 && elem->q_forw; elem = elem->q_forw);
 867         if (i > 0) {
 868             Put_message("You entered a number that is too high");
 869             continue;
 870         }
 871         break;
 872     }
 873     while (1) {
 874         bufp = Strsave("0");
 875         if (GetValueFromUser("Enter number of filesystem it should follow (0 to make it first):", &bufp) == SUB_ERROR)
 876           return(DM_NORMAL);
 877         dst = atoi(bufp);
 878         free(bufp);
 879         if (src == dst || src == dst + 1) {
 880             Put_message("That has no effect on the sorting order!");
 881             return(DM_NORMAL);
 882         }
 883         if (dst < 0) {
 884             Put_message("You must enter a non-negative number.");
 885             continue;
 886         }
 887         for (tmpelem = top, i = dst;
 888              i-- > 1 && tmpelem->q_forw;
 889              tmpelem = tmpelem->q_forw);
 890         if (i > 0) {
 891             Put_message("You entered a number that is too high");
 892             continue;
 893         }
 894         break;
 895     }
 896     args[2] = SortAfter(top, dst);
 897     args[0] = argv[1];
 898     args[1] = ((char **)elem->q_data)[0];
 899     if ((stat = do_mr_query("remove_filesys_from_fsgroup", 2, args,
 900                              Scream, NULL)) != 0) {
 901         com_err(program_name, stat, " in ChangeFSGroupOrder");
 902         return(DM_NORMAL);
 903     }
 904     if ((stat = do_mr_query("add_filesys_to_fsgroup", 3, args,
 905                              Scream, NULL)) != 0) {
 906         com_err(program_name, stat, " in ChangeFSGroupOrder");
 907     }
 908     return(DM_NORMAL);
 909 }
 910
 911
 912 /* -------------- Top Level Menu ---------------- */
 913
 914 /*      Function Name: GetFSAlias
 915  *      Description: Gets the value for a Filesystem Alias.
 916  *      Arguments: argc, argv - name of alias in argv[1].
 917  *      Returns: DM_NORMAL.
 918  *      NOTES: There should only be one filesystem per alias, thus
 919  *             this will work correctly.
 920  */
 921
 922 /* ARGSUSED */
 923 int
 924 GetFSAlias(argc, argv)
 925 int argc;
 926 char **argv;
 927 {
 928     struct qelem *top;
 929
 930     top = GetFSInfo(ALIAS, argv[1]);
 931     Put_message(" ");           /* blank line. */
 932     Loop(top, (void *) PrintFSAlias);
 933     FreeQueue(top);
 934     return(DM_NORMAL);
 935 }
 936
 937 /*      Function Name: CreateFSAlias
 938  *      Description: Create an alias name for a filesystem
 939  *      Arguments: argc, argv - name of alias in argv[1].
 940  *      Returns: DM_NORMAL.
 941  *      NOTES:  This requires (name, type, transl)  I get {name, translation}
 942  *              from the user.  I provide type, which is well-known.
 943  */
 944
 945 /* ARGSUSED */
 946 int
 947 CreateFSAlias(argc, argv)
 948 int argc;
 949 char **argv;
 950 {
 951     register int stat;
 952     struct qelem *elem, *top;
 953     char *args[MAX_ARGS_SIZE], buf[BUFSIZ], **info;
 954
 955     elem = NULL;
 956
 957     if (!ValidName(argv[1]))
 958         return(DM_NORMAL);
 959
 960     args[ALIAS_NAME] = Strsave(argv[1]);
 961     args[ALIAS_TYPE] = Strsave(FS_ALIAS_TYPE);
 962     args[ALIAS_TRANS] = Strsave("*");
 963
 964 /*
 965  * Check to see if this alias already exists in the database, if so then
 966  * print out values, free memory used and then exit.
 967  */
 968
 969     if ( (stat = do_mr_query("get_alias", 3, args, StoreInfo,
 970                               (char *)&elem)) == 0) {
 971         top = elem = QueueTop(elem);
 972         while (elem != NULL) {
 973             info = (char **) elem->q_data;
 974             sprintf(buf,"The alias: %s currently describes the filesystem %s",
 975                     info[ALIAS_NAME], info[ALIAS_TRANS]);
 976             Put_message(buf);
 977             elem = elem->q_forw;
 978         }
 979         FreeQueue(top);
 980         return(DM_NORMAL);
 981     }
 982     else if ( stat != MR_NO_MATCH) {
 983         com_err(program_name, stat, " in CreateFSAlias.");
 984         return(DM_NORMAL);
 985     }
 986
 987     args[ALIAS_TRANS]= Strsave("");
 988     args[ALIAS_END] = NULL;
 989     if (GetValueFromUser("Which filesystem will this alias point to?",
 990                          &args[ALIAS_TRANS]) == SUB_ERROR)
 991       return(DM_NORMAL);
 992
 993     if ( (stat = do_mr_query("add_alias", 3, args, NullFunc, NULL)) != 0)
 994         com_err(program_name, stat, " in CreateFSAlias.");
 995
 996     FreeInfo(args);
 997     return (DM_NORMAL);
 998 }
 999
1000 /*      Function Name: RealDeleteFSAlias
1001  *      Description: Does the real deletion work.
1002  *      Arguments: info - array of char *'s containing all useful info.
1003  *                 one_item - a Boolean that is true if only one item
1004  *                              in queue that dumped us here.
1005  *      Returns: none.
1006  */
1007
1008 void
1009 RealDeleteFSAlias(info, one_item)
1010 char ** info;
1011 Bool one_item;
1012 {
1013     int stat;
1014     char temp_buf[BUFSIZ];
1015
1016 /*
1017  * Deletetions are  performed if the user hits 'y' on a list of multiple
1018  * filesystem, or if the user confirms on a unique alias.
1019  */
1020     sprintf(temp_buf,
1021             "Are you sure that you want to delete the filesystem alias %s",
1022             info[ALIAS_NAME]);
1023     if(!one_item || Confirm(temp_buf)) {
1024         if ( (stat = do_mr_query("delete_alias", CountArgs(info),
1025                                   info, Scream, NULL)) != 0 )
1026             com_err(program_name, stat, " filesystem alias not deleted.");
1027         else
1028             Put_message("Filesystem alias deleted.");
1029     }
1030     else
1031         Put_message("Filesystem alias not deleted.");
1032 }
1033
1034 /*      Function Name: DeleteFSAlias
1035  *      Description: Delete an alias name for a filesystem
1036  *      Arguments: argc, argv - name of alias in argv[1].
1037  *      Returns: DM_NORMAL.
1038  *      NOTES:  This requires (name, type, transl)  I get {name, translation}
1039  *              from the user.  I provide type, which is well-known.
1040  */
1041
1042 /* ARGSUSED */
1043 int
1044 DeleteFSAlias(argc, argv)
1045 int argc;
1046 char **argv;
1047 {
1048     struct qelem *elem = GetFSInfo(ALIAS, argv[1]);
1049     QueryLoop(elem, PrintFSAlias, RealDeleteFSAlias,
1050               "Delete the Filesystem Alias");
1051     FreeQueue(elem);
1052     return (DM_NORMAL);
1053 }
1054
1055 /*      Function Name: AttachHelp
1056  *      Description: Print help info on attachmaint.
1057  *      Arguments: none
1058  *      Returns: DM_NORMAL.
1059  */
1060
1061 int
1062 AttachHelp()
1063 {
1064     static char *message[] = {
1065       "These are the options:",
1066       "",
1067       "get - get information about a filesystem.",
1068       "add - add a new filesystem to the data base.",
1069       "update - update the information in the database on a filesystem.",
1070       "delete - delete a filesystem from the database.",
1071       "check - check information about association of a name and a filesys.",
1072       "alias - associate a name with a filesystem.",
1073       "unalias - disassociate a name with a filesystem.",
1074       "verbose - toggle the request for delete confirmation.",
1075         NULL,
1076     };
1077
1078     return(PrintHelp(message));
1079 }
1080
1081 /*      Function Name: FSGroupHelp
1082  *      Description: Print help info on fsgroups.
1083  *      Arguments: none
1084  *      Returns: DM_NORMAL.
1085  */
1086
1087 int
1088 FSGroupHelp()
1089 {
1090     static char *message[] = {
1091         "A filesystem group is a named sorted list of filesystems.",
1092         "",
1093         "To create, modify, or delete a group itself, use the menu above",
1094         "  this one, and manipulate a filesystem of type FSGROUP.",
1095         "Options here are:",
1096         "  get - get info about a group and show its members",
1097         "  add - add a new member to a group.",
1098         "  remove - remove a member from a group.",
1099         "  order - change the sorting order of a group.",
1100         NULL
1101     };
1102
1103     return(PrintHelp(message));
1104 }