clients/moira/lists.c

   1 #if (!defined(lint) && !defined(SABER))
   2   static char rcsid_module_c[] = "$Header$";
   3 #endif lint
   4
   5 /*      This is the file lists.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: All list manipulation functions, except delete.
   8  *
   9  *      Created:        4/12/88
  10  *      By:             Chris D. Peterson
  11  *
  12  *      $Source$
  13  *      $Author$
  14  *      $Header$
  15  *
  16  *      Copyright 1988 by the Massachusetts Institute of Technology.
  17  *
  18  *      For further information on copyright and distribution
  19  *      see the file mit-copyright.h
  20  */
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <moira.h>
  25 #include <moira_site.h>
  26 #include <menu.h>
  27
  28 #include "mit-copyright.h"
  29 #include "defs.h"
  30 #include "f_defs.h"
  31 #include "globals.h"
  32
  33 #define LIST    0
  34 #define MEMBERS 1
  35 #define GLOM    2
  36 #define ACE_USE 3
  37
  38 #define DEFAULT_ACTIVE      DEFAULT_YES
  39 #define DEFAULT_PUBLIC      DEFAULT_YES
  40 #define DEFAULT_HIDDEN      DEFAULT_NO
  41 #define DEFAULT_MAILLIST    DEFAULT_YES
  42 #define DEFAULT_GROUP       DEFAULT_NO
  43 #define DEFAULT_GID         UNIQUE_GID
  44 #define DEFAULT_ACE_TYPE    "user"
  45 #define DEFAULT_ACE_NAME    (user)
  46 #define DEFAULT_DESCRIPTION DEFAULT_COMMENT
  47
  48 /* globals only for this file. */
  49
  50 static char current_list[BUFSIZ];
  51
  52 /*      Function Name: PrintListAce
  53  *      Description: This function prints the list ace information.
  54  *      Arguments: info - an info structure.
  55  *      Returns: none.
  56  */
  57
  58 static void
  59 PrintListAce(info)
  60 char ** info;
  61 {
  62     char buf[BUFSIZ];
  63
  64     sprintf(buf, "Item: %-20s Name: %s", info[ACE_TYPE],
  65             info[ACE_NAME]);
  66     Put_message(buf);
  67 }
  68
  69 /*      Function Name: PrintListInfo
  70  *      Description: This function Prints out the List info in a coherent form.
  71  *      Arguments: info - the List info.
  72  *      Returns: none.
  73  */
  74
  75 static void
  76 PrintListInfo(info)
  77 char ** info;
  78 {
  79     char buf[BUFSIZ];
  80
  81     Put_message(" ");
  82     (void) sprintf(buf, "%20sList: %s", "", info[L_NAME]);
  83     (void) Put_message(buf);
  84     (void) sprintf(buf, "Description: %s", info[L_DESC]);
  85     (void) Put_message(buf);
  86     if ( atoi(info[L_MAILLIST]))
  87         Put_message("This list is a mailing list.");
  88     else
  89         Put_message("This list is NOT a mailing list.");
  90     if ( atoi(info[L_GROUP]) ) {
  91         (void) sprintf(buf,"This list is a Group and its ID number is %s",
  92                        info[L_GID]);
  93         Put_message(buf);
  94     }
  95     else
  96         Put_message("This list is NOT a Group.");
  97
  98     if (strcmp(info[L_ACE_TYPE],"NONE") == 0)
  99         Put_message("This list has no Administrator, how strange?!");
 100     else {
 101         sprintf(buf, "The Administrator of this list is the %s: %s",
 102                 info[L_ACE_TYPE], info[L_ACE_NAME]);
 103         Put_message(buf);
 104     }
 105
 106     (void) sprintf(buf, "This list is: %s, %s, and %s",
 107                    atoi(info[L_ACTIVE]) ? "active" : "inactive",
 108                    atoi(info[L_PUBLIC]) ? "public" : "private",
 109                    atoi(info[L_HIDDEN]) ? "hidden" : "visible");
 110     (void) Put_message(buf);
 111     sprintf(buf, MOD_FORMAT, info[L_MODBY], info[L_MODTIME], info[L_MODWITH]);
 112     (void) Put_message(buf);
 113 }
 114
 115 /*      Function Name: GetListInfo
 116  *      Description: Stores all info about a group of lists in a queue.
 117  *      Arguments: type - type of info to store.
 118  *                 name - name of the info.
 119  *      Returns: the first element in the queue.
 120  */
 121
 122 /* ARGSUSED */
 123 struct qelem *
 124 GetListInfo(type, name1, name2)
 125 int type;
 126 char * name1, *name2;
 127 {
 128     char *args[2];
 129     struct qelem * elem = NULL;
 130     register int status;
 131
 132     switch(type) {
 133     case LIST:
 134         args[0] = name1;
 135         if ( (status = do_mr_query("get_list_info", 1, args,
 136                                StoreInfo, (char *) &elem)) != 0) {
 137             com_err(program_name, status, " in get_list_info");
 138             return (NULL);
 139         }
 140         break;
 141     case MEMBERS:
 142         args[0] = name1;
 143         if ( (status = do_mr_query("get_members_of_list", 1, args,
 144                                StoreInfo, (char *) &elem)) != 0) {
 145             com_err(program_name, status, " in get_members_of_list");
 146             return (NULL);
 147         }
 148         break;
 149     case GLOM:
 150         args[0] = name1;
 151         args[1] = name2;
 152         if ( (status =  do_mr_query("get_lists_of_member", 2, args,
 153                                StoreInfo, (char *) &elem)) != 0) {
 154             com_err(program_name, status, " in get_list_of_members");
 155             return (NULL);
 156         }
 157         break;
 158     case ACE_USE:
 159         args[0] = name1;
 160         args[1] = name2;
 161         if ( (status =  do_mr_query("get_ace_use", 2, args,
 162                                StoreInfo, (char *) &elem)) != 0) {
 163             com_err(program_name, status, " in get_ace_use");
 164             return (NULL);
 165         }
 166         break;
 167     }
 168     return( QueueTop(elem) );
 169 }
 170
 171 /*      Function Name: AskListInfo.
 172  *      Description: This function askes the user for information about a
 173  *                   machine and saves it into a structure.
 174  *      Arguments: info - a pointer the the structure to put the
 175  *                             info into.
 176  *                 name - add a newname field? (T/F)
 177  *      Returns: SUB_ERROR or SUB_NORMAL.
 178  */
 179
 180 char **
 181 AskListInfo(info, name)
 182 char ** info;
 183 Bool name;
 184 {
 185     char temp_buf[BUFSIZ], *newname;
 186
 187     Put_message(" ");
 188     sprintf(temp_buf,"Setting information of list %s.",info[L_NAME]);
 189     Put_message(temp_buf);
 190     Put_message(" ");
 191
 192     if (name) {
 193         while (1) {
 194             newname = Strsave(info[L_NAME]);
 195             if (GetValueFromUser("The new name for this list", &newname) ==
 196                 SUB_ERROR)
 197               return(NULL);
 198             if (ValidName(newname))
 199               break;
 200         }
 201     }
 202     if (GetYesNoValueFromUser("Is this an active list", &info[L_ACTIVE]) ==
 203         SUB_ERROR)
 204       return(NULL);
 205     if (GetYesNoValueFromUser("Is this a public list", &info[L_PUBLIC]) ==
 206         SUB_ERROR)
 207       return(NULL);
 208     if (GetYesNoValueFromUser("Is this a hidden list", &info[L_HIDDEN]) ==
 209         SUB_ERROR)
 210       return(NULL);
 211     if (GetYesNoValueFromUser("Is this a maillist", &info[L_MAILLIST]) ==
 212         SUB_ERROR)
 213       return(NULL);
 214     if (GetYesNoValueFromUser("Is this a group", &info[L_GROUP]) == SUB_ERROR)
 215       return(NULL);
 216     if (atoi(info[L_GROUP]))
 217       if (GetValueFromUser("What is the GID for this group.", &info[L_GID]) ==
 218           SUB_ERROR)
 219         return(NULL);
 220
 221     if (GetTypeFromUser("What Type of Administrator", "ace_type",
 222                         &info[L_ACE_TYPE]) == SUB_ERROR)
 223       return(NULL);
 224     if ((strcasecmp(info[L_ACE_TYPE], "NONE") != 0) &&
 225         (strcasecmp(info[L_ACE_TYPE], "none") != 0)) {
 226         sprintf(temp_buf, "Which %s will be the administrator of this list: ",
 227                 info[L_ACE_TYPE]);
 228         if (GetValueFromUser(temp_buf, &info[L_ACE_NAME]) == SUB_ERROR)
 229           return(NULL);
 230     }
 231     if (GetValueFromUser("Description: ", &info[L_DESC]) == SUB_ERROR)
 232       return(NULL);
 233
 234     FreeAndClear(&info[L_MODTIME], TRUE);
 235     FreeAndClear(&info[L_MODBY], TRUE);
 236     FreeAndClear(&info[L_MODWITH], TRUE);
 237 /*
 238  * Slide the newname into the #2 slot, this screws up all future references
 239  * to this list.
 240  */
 241     if (name)                   /* slide the newname into the #2 slot. */
 242         SlipInNewName(info, newname);
 243
 244     return(info);
 245 }
 246
 247 /* -------------- List functions. -------------- */
 248
 249 /*      Function Name: ShowListInfo.
 250  *      Description: shows info on a list.
 251  *      Arguments: argc, argv - name of list in argv[1].
 252  *      Returns: DM status code.
 253  */
 254
 255 /* ARGSUSED */
 256 int
 257 ShowListInfo(argc, argv)
 258 int argc;
 259 char **argv;
 260 {
 261     struct qelem *top, *list;
 262
 263     top = list = GetListInfo(LIST, argv[1], (char *) NULL);
 264     while (list != NULL) {
 265         PrintListInfo( (char **) list->q_data);
 266         list = list->q_forw;
 267     }
 268
 269     FreeQueue(top);
 270     return(DM_NORMAL);
 271 }
 272
 273 /*      Function Name: RealUpdateList
 274  *      Description: performs the actual update of the list.
 275  *      Arguments: info - all information needed to update the list.
 276  *                 junk - an UNUSED boolean.
 277  *      Returns: none.
 278  */
 279
 280 /* ARGSUSED */
 281 static void
 282 RealUpdateList(info, junk)
 283 char ** info;
 284 Bool junk;
 285 {
 286     register int stat;
 287     char ** args;
 288
 289     if ((args = AskListInfo(info, TRUE)) == NULL) {
 290         Put_message("Aborted.");
 291         return;
 292     }
 293     if ( (stat = do_mr_query("update_list", CountArgs(args), args,
 294                            Scream, (char *) NULL)) != MR_SUCCESS) {
 295         com_err(program_name, stat, " in UpdateList.");
 296         Put_message("List ** NOT ** Updated.");
 297     }
 298     else
 299         Put_message("List successfully updated.");
 300 }
 301
 302 /*      Function Name: UpdateList
 303  *      Description: updates the information on a list.
 304  *      Arguments: argc, argv - name of list in argv[1].
 305  *      Returns: DM Status code.
 306  */
 307
 308 /* ARGSUSED */
 309 int
 310 UpdateList(argc, argv)
 311 int argc;
 312 char **argv;
 313 {
 314     struct qelem *top;
 315
 316     top = GetListInfo(LIST, argv[1], (char *) NULL);
 317     QueryLoop(top, NullPrint, RealUpdateList, "Update the list");
 318
 319     FreeQueue(top);
 320     return(DM_NORMAL);
 321 }
 322
 323 /*      Function Name: SetDefaults
 324  *      Description: sets defaults for AddList function
 325  *      Arguments: info - the array to add them to.
 326  *                 name - name of the program to add.
 327  *      Returns: defaults - the default information.
 328  */
 329
 330 static char **
 331 SetDefaults(info, name)
 332 char ** info;
 333 char * name;
 334 {
 335    info[L_NAME] =     Strsave(name);
 336    info[L_ACTIVE] =   Strsave(DEFAULT_ACTIVE);
 337    info[L_PUBLIC] =   Strsave(DEFAULT_PUBLIC);
 338    info[L_HIDDEN] =   Strsave(DEFAULT_HIDDEN);
 339    info[L_MAILLIST] = Strsave(DEFAULT_MAILLIST);
 340    info[L_GROUP] =    Strsave(DEFAULT_GROUP);
 341    info[L_GID] =      Strsave(DEFAULT_GID);
 342    info[L_ACE_TYPE] = Strsave(DEFAULT_ACE_TYPE);
 343    info[L_ACE_NAME] = Strsave(DEFAULT_ACE_NAME);
 344    info[L_DESC] =     Strsave(DEFAULT_DESCRIPTION);
 345    info[L_MODTIME] = info[L_MODBY] = info[L_MODWITH] = info[L_END] = NULL;
 346    return(info);
 347 }
 348
 349 /*      Function Name: AddList
 350  *      Description:
 351  *      Arguments: argc, argv - name of list in argv[1].
 352  *      Returns: SUB_ERROR if list not created.
 353  */
 354
 355 /* ARGSUSED */
 356 int
 357 AddList(argc, argv)
 358 int argc;
 359 char **argv;
 360 {
 361     static char *info[MAX_ARGS_SIZE], **add_args;
 362     int status, ret_code = SUB_NORMAL;
 363     struct qelem *elem = NULL;
 364
 365     if (!ValidName(argv[1]))
 366       return(DM_NORMAL);
 367     status = do_mr_query("get_list_info", 1, argv + 1, NullFunc,
 368                        (char *) NULL);
 369     if (status != MR_NO_MATCH) {
 370         if (status == MR_SUCCESS)
 371             Put_message("This list already exists.");
 372         else
 373             com_err(program_name, status, " in AddList.");
 374         return(SUB_ERROR);
 375     }
 376
 377     /*
 378      * If the listname is less than 8 characters, make sure it doesn't
 379      * collide with a username.
 380      */
 381     if ((strlen(argv[1]) <= 8) &&
 382         do_mr_query("get_user_account_by_login", 1, argv + 1,
 383                     StoreInfo, (char *) &elem) == 0) {
 384             Put_message("A user by that name already exists in the database.");
 385             Loop(QueueTop(elem), FreeInfo);
 386             FreeQueue(elem);
 387             if (YesNoQuestion("Crate a list with the same name",
 388                               FALSE) != TRUE)
 389                     return(SUB_ERROR);
 390     }
 391
 392     if ((add_args = AskListInfo(SetDefaults(info,argv[1]), FALSE)) == NULL) {
 393         Put_message("Aborted.");
 394         return(SUB_ERROR);
 395     }
 396
 397     if ( (status = do_mr_query("add_list", CountArgs(add_args), add_args,
 398                              Scream, (char *) NULL)) != MR_SUCCESS) {
 399         com_err(program_name, status, " in AddList.");
 400         Put_message("List Not Created.");
 401         ret_code = SUB_ERROR;
 402     }
 403
 404     FreeInfo(info);
 405     return(ret_code);
 406 }
 407
 408 /*      Function Name: Instructions
 409  *      Description: This func prints out instruction on manipulating lists.
 410  *      Arguments: none
 411  *      Returns: DM Status Code.
 412  */
 413
 414 int
 415 ListHelp()
 416 {
 417     static char * message[] = {
 418         "Listmaint handles the creation, deletion, and updating of lists.",
 419         "A list can be a mailing list, a group list, or both.",
 420         "The concept behind lists is that a list has an owner",
 421         "- administrator -  and members.",
 422         "The administrator of a list may be another list.",
 423         "The members of a list can be users (login names), other lists,",
 424         "or address strings.",
 425         "You can use certain keys to do the following:",
 426         "    Refresh the screen - Type ctrl-L.",
 427         "    Escape from a function - Type ctrl-C.",
 428         "    Suspend the program (temporarily) - Type ctrl-Z.",
 429         NULL,
 430     };
 431
 432     return(PrintHelp(message));
 433 }
 434
 435 /*-*-* LISTMAINT UPDATE MENU *-*-*/
 436
 437 /*      Function Name: ListmaintMemberMenuEntry
 438  *      Description: entry routine into the listmaint member menu.
 439  *      Arguments: m - the member menu.
 440  *                 argc, argv - name of the list in argv[1].
 441  *      Returns: none.
 442  */
 443
 444 /* ARGSUSED */
 445 int
 446 ListmaintMemberMenuEntry(m, argc, argv)
 447 Menu *m;
 448 int argc;
 449 char **argv;
 450 {
 451     char temp_buf[BUFSIZ];
 452     char *list_name = argv[1];
 453     register int stat;
 454
 455     if (!ValidName(list_name))
 456         return(DM_QUIT);
 457
 458     if (*argv[0] == 'a') {      /* add_list */
 459         if (AddList(argc, argv) == SUB_ERROR)
 460             return(DM_QUIT);
 461         (void) sprintf(temp_buf, "List '%s' created. Do you want to %s",
 462                        list_name, "change its membership (y/n)? ");
 463         if (YesNoQuestion(temp_buf, TRUE) != TRUE )
 464             return(DM_QUIT);
 465     }
 466     else
 467         /* All we want to know is if it exists. */
 468         switch( (stat = do_mr_query("count_members_of_list", 1, argv + 1,
 469                                    NullFunc, (char *) NULL))) {
 470         case MR_SUCCESS:
 471             break;
 472         case MR_LIST:
 473             Put_message("This list does not exist.");
 474             return(DM_QUIT);
 475         case MR_PERM:
 476             Put_message("You are not allowed to view this list.");
 477             break;
 478         default:
 479             com_err(program_name, stat, " in get_list_info");
 480             return(DM_QUIT);
 481         }
 482
 483     (void) sprintf(temp_buf,
 484                    "Change/Display membership of '%s'", list_name);
 485     m->m_title = Strsave(temp_buf);
 486     strcpy(current_list, list_name);
 487     return(DM_NORMAL);
 488 }
 489
 490 /*      Function Name: ListmaintMemberMenuExit
 491  *      Description: This is the function called when the member menu is
 492  *                   exited, it frees the memory that is storing the name.
 493  *      Arguments: m - the menu
 494  *      Returns: DM_NORMAL
 495  */
 496
 497 int
 498 ListmaintMemberMenuExit(m)
 499 Menu *m;
 500 {
 501     free(m->m_title);
 502     strcpy(current_list, "");
 503     return(DM_NORMAL);
 504 }
 505
 506 /*      Function Name: ListMembersByType
 507  *      Description: This function lists the users of a list by type.
 508  *      Arguments: type - the type of the list "USER", "LIST", or "STRING".
 509  *      Returns: none.
 510  *      NOTE: if type is NULL, all lists members are listed.
 511  */
 512
 513 int
 514 ListMembersByType(type)
 515 char * type;
 516 {
 517     char temp_buf[BUFSIZ];
 518     register int status;
 519     char * args[10];
 520
 521     args[0] = current_list;
 522     args[1] = NULL;
 523
 524     found_some = FALSE;
 525     if ( (status = do_mr_query("get_members_of_list", CountArgs(args), args,
 526                              PrintByType, type)) != 0) {
 527         com_err(program_name, status, " in ListMembersByType");
 528         return(DM_NORMAL);
 529     }
 530     if (!found_some) {
 531         if (type == NULL)
 532             Put_message("List is empty (no members).");
 533         else {
 534             sprintf(temp_buf,"No %s Members",type);
 535             Put_message(temp_buf);
 536         }
 537     }
 538 }
 539
 540 /*      Function Name: ListAllMembers
 541  *      Description: lists all members of the current list.
 542  *      Arguments:
 543  *      Returns: DM_NORMAL
 544  */
 545
 546 int
 547 ListAllMembers()
 548 {
 549     ListMembersByType(NULL);
 550     return (DM_NORMAL);
 551 }
 552
 553 /*      Function Name: ListUserMembers
 554  *      Description: This function lists all members of a list of type "USER".
 555  *      Arguments: none
 556  *      Returns: DM_NORMAL.
 557  */
 558
 559 ListUserMembers()
 560 {
 561     ListMembersByType("USER");
 562     return(DM_NORMAL);
 563 }
 564
 565 /*      Function Name: ListListMembers
 566  *      Description: This function lists all members of a list of type "LIST".
 567  *      Arguments: none
 568  *      Returns: DM_NORMAL.
 569  */
 570
 571 ListListMembers()
 572 {
 573     ListMembersByType("LIST");
 574     return(DM_NORMAL);
 575 }
 576
 577 /*      Function Name: ListStringMembers
 578  *      Description:This function lists all members of a list of type "STRING".
 579  *      Arguments: none
 580  *      Returns: DM_NORMAL.
 581  */
 582
 583 ListStringMembers()
 584 {
 585     ListMembersByType("STRING");
 586     return(DM_NORMAL);
 587 }
 588
 589 /*      Function Name: GetMemberInfo
 590  *      Description: This function gets the information needed to
 591  *                   add or delete a user from a list.
 592  *      Arguments: argc, argv - standard.
 593  *                 action - name of the action to be performed either
 594  *                          "add" or "delete".
 595  *                 ret_argc, ret_argv - the returned value of argc and argv.
 596  *      Returns: SUB_ERROR or SUB_NORMAL.
 597  */
 598
 599 int
 600 GetMemberInfo(action, ret_argv)
 601 char *action, **ret_argv;
 602 {
 603     char temp_buf[BUFSIZ];
 604
 605     ret_argv[LM_LIST] = Strsave(current_list);
 606
 607     ret_argv[LM_TYPE] = Strsave("user");
 608     if (GetTypeFromUser("Type of member", "member", &ret_argv[LM_TYPE]) ==
 609         SUB_ERROR)
 610       return(SUB_ERROR);
 611
 612     sprintf(temp_buf,"Name of %s to %s", ret_argv[LM_TYPE], action);
 613     ret_argv[LM_MEMBER] = Strsave(user);
 614     if (GetValueFromUser(temp_buf, &ret_argv[LM_MEMBER]) == SUB_ERROR)
 615       return(SUB_ERROR);
 616     ret_argv[LM_END] = NULL;            /* NULL terminate this list. */
 617
 618     if (strcasecmp(ret_argv[LM_TYPE], "string") &&
 619         !ValidName( ret_argv[LM_MEMBER] ) ) {
 620         FreeInfo(ret_argv);
 621         return(SUB_ERROR);
 622     }
 623     return(SUB_NORMAL);
 624 }
 625
 626 /*      Function Name: AddMember
 627  *      Description: This function adds a member to a list.
 628  *      Arguments: none.
 629  *      Returns: DM_NORMAL.
 630  */
 631
 632 int
 633 AddMember()
 634 {
 635     char *args[10], temp_buf[BUFSIZ], *p;
 636     register int status;
 637     struct qelem *mailhubs, *elem, *GetTypeValues();
 638
 639     if ( GetMemberInfo("add", args) == SUB_ERROR )
 640         return(DM_NORMAL);
 641
 642     if (!strcmp(args[LM_TYPE], "STRING")) {
 643         if (p = strchr(args[LM_MEMBER], '@')) {
 644             char *host = canonicalize_hostname(strsave(++p));
 645             mailhubs = GetTypeValues("mailhub");
 646             for (elem = mailhubs; elem; elem = elem->q_forw) {
 647                 if (!strcasecmp(host, elem->q_data)) {
 648                     free(host);
 649                     host = strsave(args[LM_MEMBER]);
 650                     *(--p) = 0;
 651                     sprintf(temp_buf, "String \"%s\" should be USER or LIST \"%s\" because it is a local name.",
 652                             host, args[LM_MEMBER]);
 653                     Put_message(temp_buf);
 654                     free(args[LM_TYPE]);
 655                     free(host);
 656                     return(DM_NORMAL);
 657                 }
 658             }
 659             free(host);
 660         } else if (!strchr(args[LM_MEMBER], '!')) {
 661             Put_message("Member which is not a foreign mail address should not be type STRING.");
 662             return(DM_NORMAL);
 663         }
 664     }
 665
 666     if ( (status = do_mr_query("add_member_to_list", CountArgs(args), args,
 667                            Scream, NULL)) != MR_SUCCESS) {
 668         if (status == MR_EXISTS) {
 669             sprintf(temp_buf, "The %s %s is already a member of LIST %s.",
 670                     args[LM_TYPE], args[LM_MEMBER], args[LM_LIST]);
 671             Put_message(temp_buf);
 672         }
 673         else
 674             com_err(program_name, status, " in AddMember");
 675     }
 676
 677     FreeInfo(args);
 678     return(DM_NORMAL);
 679 }
 680
 681 /*      Function Name: DeleteMember
 682  *      Description: This function deletes a member from a list.
 683  *      Arguments: none.
 684  *      Returns: DM_NORMAL
 685  */
 686
 687 int
 688 DeleteMember()
 689 {
 690     char *args[10];
 691     register int status;
 692
 693     if( GetMemberInfo("delete", args) == SUB_ERROR )
 694         return(DM_NORMAL);
 695
 696     if (Confirm("Are you sure you want to delete this member?") ) {
 697         if (status = do_mr_query("delete_member_from_list", CountArgs(args),
 698                                args, Scream, NULL))
 699             com_err(program_name, status, " in DeleteMember");
 700         else
 701             Put_message("Deletion Completed.");
 702     }
 703     else
 704         Put_message("Deletion has been Aborted.");
 705
 706     FreeInfo(args);
 707     return(DM_NORMAL);
 708 }
 709
 710 /*      Function Name: InterRemoveItemFromLists
 711  *      Description: This function allows interactive removal of an item
 712  *                   (user, string, list) for all list  that it is on.
 713  *      Arguments: none.
 714  *      Returns: DM_NORMAL.
 715  *      NOTES: QueryLoop() does not work here because info does not have
 716  *             enough information in it to delete the member from the list.
 717  */
 718
 719 int
 720 InterRemoveItemFromLists()
 721 {
 722     register int status;
 723     char *type, *name, *args[10], buf[BUFSIZ];
 724     struct qelem *top, *elem;
 725
 726     type = strsave("USER");
 727     if (GetTypeFromUser("Type of member", "member", &type) == SUB_ERROR)
 728         return(DM_NORMAL);
 729
 730     sprintf(buf, "Name of %s", type);
 731     name = strsave(user);
 732     if (GetValueFromUser(buf, &name) == SUB_ERROR)
 733       return(DM_NORMAL);
 734
 735     if (!ValidName(name))
 736         return(DM_NORMAL);
 737
 738     top = elem = GetListInfo(GLOM, type, name);
 739
 740     while(elem != NULL) {
 741         char line[BUFSIZ];
 742         char ** info = (char **) elem->q_data;
 743         sprintf(line, "Delete %s %s from the list \"%s\" (y/n/q)? ", type,
 744                 name, info[GLOM_NAME]);
 745         switch (YesNoQuitQuestion(line, FALSE)) {
 746         case TRUE:
 747             Put_message("deleting...");
 748             args[DM_LIST] = info[GLOM_NAME];
 749             args[DM_TYPE] = type;
 750             args[DM_MEMBER] = name;
 751             if ( (status = do_mr_query("delete_member_from_list", 3, args,
 752                                Scream, (char *) NULL)) != 0)
 753                 /* should probabally check to delete list. */
 754                 com_err(program_name, status, " in delete_member");
 755             break;
 756         case FALSE:
 757             break;
 758         default:
 759             Put_message("Aborting...");
 760             FreeQueue(top);
 761             return(DM_NORMAL);
 762         }
 763         elem = elem->q_forw;
 764     }
 765     FreeQueue(top);
 766     return(DM_NORMAL);
 767 }
 768
 769 /*-*-* LIST MENU *-*-*/
 770
 771 /*      Function Name: ListByMember
 772  *      Description: This gets all lists that a given member is a member of.
 773  *      Arguments: none.
 774  *      Returns: DM_NORMAL.
 775  */
 776
 777 int
 778 ListByMember()
 779 {
 780     char buf[BUFSIZ], temp_buf[BUFSIZ], *type, *name, **info;
 781     Bool maillist, group;
 782     struct qelem *top, *elem;
 783
 784     type = strsave("USER");
 785     if (GetTypeFromUser("Type of member", "member", &type) == SUB_ERROR)
 786         return(DM_NORMAL);
 787
 788     sprintf(buf, "Name of %s", type);
 789     name = strsave(user);
 790     if (GetValueFromUser(buf, &name) == SUB_ERROR)
 791       return(DM_NORMAL);
 792
 793     /* What we really want is a recursive search */
 794     sprintf(temp_buf, "R%s", type);
 795     free(type); type = Strsave(temp_buf);
 796
 797     if ((maillist = YesNoQuestion("Show Lists that are Maillists (y/n) ?",
 798                                   TRUE)) == -1)
 799       return(DM_NORMAL);
 800     if ((group = YesNoQuestion("Show Lists that are Groups (y/n) ?",
 801                                TRUE)) == -1)
 802       return(DM_NORMAL);
 803
 804     elem = top = GetListInfo(GLOM, type, name);
 805
 806     while (elem != NULL) {
 807         info = (char**) elem->q_data;
 808         if ((maillist == TRUE && !strcmp(info[GLOM_MAILLIST], "1")) ||
 809             (group == TRUE && !strcmp(info[GLOM_GROUP], "1")))
 810                 Put_message(info[GLOM_NAME]);
 811         elem = elem->q_forw;
 812     }
 813     FreeQueue(top);
 814     return (DM_NORMAL);
 815 }
 816
 817 /*      Function Name: ListByAdministrator
 818  *      Description: This function prints all lists which a given user or
 819  *                   group administers.
 820  *      Arguments: none.
 821  *      Returns: DM_NORMAL.
 822  */
 823
 824 int
 825 ListByAdministrator()
 826 {
 827     char buf[BUFSIZ], temp_buf[BUFSIZ], *type, *name;
 828     struct qelem *top;
 829
 830     type = strsave("USER");
 831     if (GetTypeFromUser("Type of member", "member", &type) == SUB_ERROR)
 832         return(DM_NORMAL);
 833
 834     sprintf(buf, "Name of %s", type);
 835     name = strsave(user);
 836     if (GetValueFromUser(buf, &name) == SUB_ERROR)
 837       return(DM_NORMAL);
 838
 839     switch (YesNoQuestion("Do you want a recursive search (y/n)", FALSE)) {
 840     case TRUE:
 841         sprintf(temp_buf, "R%s", type); /* "USER" to "RUSER" etc. */
 842         free(type);
 843         type = Strsave(temp_buf);
 844         break;
 845     case FALSE:
 846         break;
 847     default:
 848         return(DM_NORMAL);
 849     }
 850
 851     top = GetListInfo(ACE_USE, type, name);
 852     Loop(top, PrintListAce);
 853
 854     FreeQueue(top);
 855     return (DM_NORMAL);
 856 }
 857
 858 /*      Function Name: ListAllPublicMailLists
 859  *      Description: This function lists all public mailing lists.
 860  *      Arguments: none
 861  *      Returns: DM_NORMAL.
 862  */
 863
 864 ListAllPublicMailLists()
 865 {
 866     register int status;
 867     static char * args[] = {
 868         "TRUE",                 /* active */
 869         "TRUE",                 /* public */
 870         "FALSE",                /* hidden */
 871         "TRUE",                 /* maillist */
 872         "DONTCARE",             /* group. */
 873     };
 874
 875     if (YesNoQuestion("This query will take a while. Do you wish to continue?",
 876                        TRUE) == TRUE )
 877         if (status = do_mr_query("qualified_get_lists", 5, args,
 878                                Print, (char *) NULL) != 0)
 879             com_err(program_name, status, " in ListAllGroups");
 880
 881     return (DM_NORMAL);
 882 }