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