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(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                 argv[Q_TYPE] = "USER";
 667                 argv[Q_QUOTA] = def_quota;
 668                 if ((stat = do_mr_query("add_quota", Q_QUOTA+1, argv, Scream,
 669                                          (char *) NULL)) != MR_SUCCESS) {
 670                     com_err(program_name, stat, " while adding quota");
 671                 }
 672             }
 673         }
 674     }
 675
 676     FreeInfo(info);
 677     return (DM_NORMAL);
 678 }
 679
 680 /*      Function Name: SortAfter
 681  *      Description: choose a sortkey to cause an item to be added after
 682  *              the count element in the queue
 683  *      Arguments: queue of filesys names & sortkeys, queue count pointer
 684  *      Returns: sort key to use.
 685  */
 686
 687 /* ARGSUSED */
 688 char *
 689 SortAfter(elem, count)
 690 struct qelem *elem;
 691 int count;
 692 {
 693     char *prev, *next, prevnext, *key, keybuf[9];
 694
 695     /* first find the two keys we need to insert between */
 696     prev = "A";
 697     for (; count > 0; count--) {
 698         prev = ((char **)elem->q_data)[1];
 699         if (elem->q_forw)
 700           elem = elem->q_forw;
 701         else
 702           break;
 703     }
 704     if (count > 0)
 705       next = "Z";
 706     else
 707       next = ((char **)elem->q_data)[1];
 708
 709     /* now copy the matching characters */
 710     for (key = keybuf; *prev && *prev == *next; next++) {
 711         *key++ = *prev++;
 712     }
 713
 714     /* and set the last character */
 715     if (*prev == 0)
 716       *prev = prevnext = 'A';
 717     else
 718       prevnext = prev[1];
 719     if (prevnext == 0)
 720       prevnext = 'A';
 721     if (*next == 0)
 722       *next = 'Z';
 723     if (*next - *prev > 1) {
 724         *key++ = (*next + *prev)/2;
 725     } else {
 726         *key++ = *prev;
 727         *key++ = (prevnext + 'Z')/2;
 728     }
 729     *key = 0;
 730     return(Strsave(keybuf));
 731 }
 732
 733 /*      Function Name: AddFSToGroup
 734  *      Description: add a filesystem to an FS group
 735  *      Arguments: arc, argv - name of group in argv[1], filesys in argv[2].
 736  *      Returns: DM_NORMAL.
 737  */
 738
 739 /* ARGSUSED */
 740 int
 741 AddFSToGroup(argc, argv)
 742 char **argv;
 743 int argc;
 744 {
 745     int stat, count;
 746     struct qelem *elem = NULL;
 747     char buf[BUFSIZ], *args[5], *bufp;
 748
 749     if ((stat = do_mr_query("get_fsgroup_members", 1, argv+1, StoreInfo,
 750                              (char *)&elem)) != 0) {
 751         if (stat != MR_NO_MATCH)
 752           com_err(program_name, stat, " in AddFSToGroup");
 753     }
 754     if (elem == NULL) {
 755         args[0] = argv[1];
 756         args[1] = argv[2];
 757         args[2] = "M";
 758         stat = do_mr_query("add_filesys_to_fsgroup", 3, args, Scream, NULL);
 759         if (stat)
 760           com_err(program_name, stat, " in AddFSToGroup");
 761         return(DM_NORMAL);
 762     }
 763     elem = QueueTop(elem);
 764     fsgCount = 1;
 765     Loop(elem, (void *) PrintFSGMembers);
 766     sprintf(buf, "%d", QueueCount(elem));
 767     bufp = Strsave(buf);
 768     if (GetValueFromUser("Enter number of filesystem it should follow (0 to make it first):", &bufp) == SUB_ERROR)
 769       return(DM_NORMAL);
 770     count = atoi(bufp);
 771     free(bufp);
 772     args[2] = SortAfter(elem, count);
 773
 774     FreeQueue(QueueTop(elem));
 775     args[0] = argv[1];
 776     args[1] = argv[2];
 777     stat = do_mr_query("add_filesys_to_fsgroup", 3, args, Scream, NULL);
 778     if (stat == MR_EXISTS) {
 779         Put_message("That filesystem is already a member of the group.");
 780         Put_message("Use the order command if you want to change the sorting order.");
 781     } else if (stat)
 782       com_err(program_name, stat, " in AddFSToGroup");
 783     return(DM_NORMAL);
 784 }
 785
 786
 787 /*      Function Name: RemoveFSFromGroup
 788  *      Description: delete a filesystem from an FS group
 789  *      Arguments: arc, argv - name of group in argv[1].
 790  *      Returns: DM_NORMAL.
 791  */
 792
 793 /* ARGSUSED */
 794 int
 795 RemoveFSFromGroup(argc, argv)
 796 char **argv;
 797 int argc;
 798 {
 799     int stat;
 800     char buf[BUFSIZ];
 801
 802     sprintf(buf, "Delete filesystem %s from FS group %s", argv[2], argv[1]);
 803     if (!Confirm(buf))
 804       return(DM_NORMAL);
 805     if ((stat = do_mr_query("remove_filesys_from_fsgroup", 2, argv+1,
 806                              Scream, NULL)) != 0) {
 807         com_err(program_name, stat, ", not removed.");
 808     }
 809     return(DM_NORMAL);
 810 }
 811
 812 /*      Function Name: ChangeFSGroupOrder
 813  *      Description: change the sortkey on a filesys in an FSgroup
 814  *      Arguments: arc, argv - name of group in argv[1].
 815  *      Returns: DM_NORMAL.
 816  */
 817
 818 /* ARGSUSED */
 819 int
 820 ChangeFSGroupOrder(argc, argv)
 821 char **argv;
 822 int argc;
 823 {
 824     int stat, src, dst, i;
 825     struct qelem *elem = NULL, *top, *tmpelem;
 826     char buf[BUFSIZ], *bufp, *args[3];
 827
 828     if ((stat = do_mr_query("get_fsgroup_members", 1, argv+1, StoreInfo,
 829                              (char *)&elem)) != 0) {
 830         if (stat == MR_NO_MATCH) {
 831             sprintf(buf,
 832                     "Ether %s is not a filesystem group or it has no members",
 833                     argv[1]);
 834             Put_message(buf);
 835         } else
 836           com_err(program_name, stat, " in ChangeFSGroupOrder");
 837         return(DM_NORMAL);
 838     }
 839     top = QueueTop(elem);
 840     fsgCount = 1;
 841     Loop(top, (void *) PrintFSGMembers);
 842     while (1) {
 843         bufp = Strsave("1");
 844         if (GetValueFromUser("Enter number of the filesystem to move:",
 845                              &bufp) == SUB_ERROR)
 846           return(DM_NORMAL);
 847         src = atoi(bufp);
 848         free(bufp);
 849         if (src < 0) {
 850             Put_message("You must enter a positive number (or 0 to abort).");
 851             continue;
 852         } else if (src == 0) {
 853             Put_message("Aborted.");
 854             return(DM_NORMAL);
 855         }
 856         for (elem = top, i = src; i-- > 1 && elem->q_forw; elem = elem->q_forw);
 857         if (i > 0) {
 858             Put_message("You entered a number that is too high");
 859             continue;
 860         }
 861         break;
 862     }
 863     while (1) {
 864         bufp = Strsave("0");
 865         if (GetValueFromUser("Enter number of filesystem it should follow (0 to make it first):", &bufp) == SUB_ERROR)
 866           return(DM_NORMAL);
 867         dst = atoi(bufp);
 868         free(bufp);
 869         if (src == dst || src == dst + 1) {
 870             Put_message("That has no effect on the sorting order!");
 871             return(DM_NORMAL);
 872         }
 873         if (dst < 0) {
 874             Put_message("You must enter a non-negative number.");
 875             continue;
 876         }
 877         for (tmpelem = top, i = dst;
 878              i-- > 1 && tmpelem->q_forw;
 879              tmpelem = tmpelem->q_forw);
 880         if (i > 0) {
 881             Put_message("You entered a number that is too high");
 882             continue;
 883         }
 884         break;
 885     }
 886     args[2] = SortAfter(top, dst);
 887     args[0] = argv[1];
 888     args[1] = ((char **)elem->q_data)[0];
 889     if ((stat = do_mr_query("remove_filesys_from_fsgroup", 2, args,
 890                              Scream, NULL)) != 0) {
 891         com_err(program_name, stat, " in ChangeFSGroupOrder");
 892         return(DM_NORMAL);
 893     }
 894     if ((stat = do_mr_query("add_filesys_to_fsgroup", 3, args,
 895                              Scream, NULL)) != 0) {
 896         com_err(program_name, stat, " in ChangeFSGroupOrder");
 897     }
 898     return(DM_NORMAL);
 899 }
 900
 901
 902 /* -------------- Top Level Menu ---------------- */
 903
 904 /*      Function Name: GetFSAlias
 905  *      Description: Gets the value for a Filesystem Alias.
 906  *      Arguments: argc, argv - name of alias in argv[1].
 907  *      Returns: DM_NORMAL.
 908  *      NOTES: There should only be one filesystem per alias, thus
 909  *             this will work correctly.
 910  */
 911
 912 /* ARGSUSED */
 913 int
 914 GetFSAlias(argc, argv)
 915 int argc;
 916 char **argv;
 917 {
 918     struct qelem *top;
 919
 920     top = GetFSInfo(ALIAS, argv[1]);
 921     Put_message(" ");           /* blank line. */
 922     Loop(top, (void *) PrintFSAlias);
 923     FreeQueue(top);
 924     return(DM_NORMAL);
 925 }
 926
 927 /*      Function Name: CreateFSAlias
 928  *      Description: Create an alias name for a filesystem
 929  *      Arguments: argc, argv - name of alias in argv[1].
 930  *      Returns: DM_NORMAL.
 931  *      NOTES:  This requires (name, type, transl)  I get {name, translation}
 932  *              from the user.  I provide type, which is well-known.
 933  */
 934
 935 /* ARGSUSED */
 936 int
 937 CreateFSAlias(argc, argv)
 938 int argc;
 939 char **argv;
 940 {
 941     register int stat;
 942     struct qelem *elem, *top;
 943     char *args[MAX_ARGS_SIZE], buf[BUFSIZ], **info;
 944
 945     elem = NULL;
 946
 947     if (!ValidName(argv[1]))
 948         return(DM_NORMAL);
 949
 950     args[ALIAS_NAME] = Strsave(argv[1]);
 951     args[ALIAS_TYPE] = Strsave(FS_ALIAS_TYPE);
 952     args[ALIAS_TRANS] = Strsave("*");
 953
 954 /*
 955  * Check to see if this alias already exists in the database, if so then
 956  * print out values, free memory used and then exit.
 957  */
 958
 959     if ( (stat = do_mr_query("get_alias", 3, args, StoreInfo,
 960                               (char *)&elem)) == 0) {
 961         top = elem = QueueTop(elem);
 962         while (elem != NULL) {
 963             info = (char **) elem->q_data;
 964             sprintf(buf,"The alias: %s currently describes the filesystem %s",
 965                     info[ALIAS_NAME], info[ALIAS_TRANS]);
 966             Put_message(buf);
 967             elem = elem->q_forw;
 968         }
 969         FreeQueue(top);
 970         return(DM_NORMAL);
 971     }
 972     else if ( stat != MR_NO_MATCH) {
 973         com_err(program_name, stat, " in CreateFSAlias.");
 974         return(DM_NORMAL);
 975     }
 976
 977     args[ALIAS_TRANS]= Strsave("");
 978     args[ALIAS_END] = NULL;
 979     if (GetValueFromUser("Which filesystem will this alias point to?",
 980                          &args[ALIAS_TRANS]) == SUB_ERROR)
 981       return(DM_NORMAL);
 982
 983     if ( (stat = do_mr_query("add_alias", 3, args, NullFunc, NULL)) != 0)
 984         com_err(program_name, stat, " in CreateFSAlias.");
 985
 986     FreeInfo(args);
 987     return (DM_NORMAL);
 988 }
 989
 990 /*      Function Name: RealDeleteFSAlias
 991  *      Description: Does the real deletion work.
 992  *      Arguments: info - array of char *'s containing all useful info.
 993  *                 one_item - a Boolean that is true if only one item
 994  *                              in queue that dumped us here.
 995  *      Returns: none.
 996  */
 997
 998 void
 999 RealDeleteFSAlias(info, one_item)
1000 char ** info;
1001 Bool one_item;
1002 {
1003     int stat;
1004     char temp_buf[BUFSIZ];
1005
1006 /*
1007  * Deletetions are  performed if the user hits 'y' on a list of multiple
1008  * filesystem, or if the user confirms on a unique alias.
1009  */
1010     sprintf(temp_buf,
1011             "Are you sure that you want to delete the filesystem alias %s",
1012             info[ALIAS_NAME]);
1013     if(!one_item || Confirm(temp_buf)) {
1014         if ( (stat = do_mr_query("delete_alias", CountArgs(info),
1015                                   info, Scream, NULL)) != 0 )
1016             com_err(program_name, stat, " filesystem alias not deleted.");
1017         else
1018             Put_message("Filesystem alias deleted.");
1019     }
1020     else
1021         Put_message("Filesystem alias not deleted.");
1022 }
1023
1024 /*      Function Name: DeleteFSAlias
1025  *      Description: Delete an alias name for a filesystem
1026  *      Arguments: argc, argv - name of alias in argv[1].
1027  *      Returns: DM_NORMAL.
1028  *      NOTES:  This requires (name, type, transl)  I get {name, translation}
1029  *              from the user.  I provide type, which is well-known.
1030  */
1031
1032 /* ARGSUSED */
1033 int
1034 DeleteFSAlias(argc, argv)
1035 int argc;
1036 char **argv;
1037 {
1038     struct qelem *elem = GetFSInfo(ALIAS, argv[1]);
1039     QueryLoop(elem, PrintFSAlias, RealDeleteFSAlias,
1040               "Delete the Filesystem Alias");
1041     FreeQueue(elem);
1042     return (DM_NORMAL);
1043 }
1044
1045 /*      Function Name: AttachHelp
1046  *      Description: Print help info on attachmaint.
1047  *      Arguments: none
1048  *      Returns: DM_NORMAL.
1049  */
1050
1051 int
1052 AttachHelp()
1053 {
1054     static char *message[] = {
1055       "These are the options:",
1056       "",
1057       "get - get information about a filesystem.",
1058       "add - add a new filesystem to the data base.",
1059       "update - update the information in the database on a filesystem.",
1060       "delete - delete a filesystem from the database.",
1061       "check - check information about association of a name and a filesys.",
1062       "alias - associate a name with a filesystem.",
1063       "unalias - disassociate a name with a filesystem.",
1064       "verbose - toggle the request for delete confirmation.",
1065         NULL,
1066     };
1067
1068     return(PrintHelp(message));
1069 }
1070
1071 /*      Function Name: FSGroupHelp
1072  *      Description: Print help info on fsgroups.
1073  *      Arguments: none
1074  *      Returns: DM_NORMAL.
1075  */
1076
1077 int
1078 FSGroupHelp()
1079 {
1080     static char *message[] = {
1081         "A filesystem group is a named sorted list of filesystems.",
1082         "",
1083         "To create, modify, or delete a group itself, use the menu above",
1084         "  this one, and manipulate a filesystem of type FSGROUP.",
1085         "Options here are:",
1086         "  get - get info about a group and show its members",
1087         "  add - add a new member to a group.",
1088         "  remove - remove a member from a group.",
1089         "  order - change the sorting order of a group.",
1090         NULL
1091     };
1092
1093     return(PrintHelp(message));
1094 }