clients/blanche/blanche.c

   1 /* $Id$
   2  *
   3  * Command line oriented Moira List tool.
   4  *
   5  * by Mark Rosenstein, September 1988.
   6  *
   7  * Copyright (C) 1988-1998 by the Massachusetts Institute of Technology.
   8  * For copying and distribution information, please see the file
   9  * <mit-copyright.h>.
  10  */
  11
  12 #include <mit-copyright.h>
  13 #include <moira.h>
  14 #include <moira_site.h>
  15 #include <mrclient.h>
  16
  17 #include <ctype.h>
  18 #include <errno.h>
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 RCSID("$Header$");
  24
  25 struct member {
  26   int type;
  27   char *name, *tag;
  28 };
  29
  30 /* It is important to membercmp that M_USER < M_LIST < M_STRING */
  31 #define M_ANY           0
  32 #define M_USER          1
  33 #define M_LIST          2
  34 #define M_STRING        3
  35 #define M_KERBEROS      4
  36
  37 char *typename[] = { "ANY", "USER", "LIST", "STRING", "KERBEROS" };
  38
  39 /* argument parsing macro */
  40 #define argis(a, b) (!strcmp(*arg + 1, a) || !strcmp(*arg + 1, b))
  41
  42 /* flags from command line */
  43 int infoflg, verbose, syncflg, memberflg, recursflg, noauth;
  44 int showusers, showstrings, showkerberos, showlists, showtags;
  45 int createflag, setinfo, active, public, hidden, maillist, grouplist;
  46 int nfsgroup;
  47 struct member *owner, *memacl;
  48 char *desc, *newname;
  49
  50 /* various member lists */
  51 struct save_queue *addlist, *dellist, *memberlist, *synclist, *taglist;
  52
  53 char *listname, *whoami;
  54
  55 void usage(char **argv);
  56 void show_list_member(struct member *memberstruct);
  57 int show_list_info(int argc, char **argv, void *hint);
  58 int save_list_info(int argc, char **argv, void *hint);
  59 int show_list_count(int argc, char **argv, void *hint);
  60 void recursive_display_list_members(void);
  61 void unique_add_member(struct save_queue *q, struct member *m);
  62 int get_list_members(int argc, char **argv, void *sq);
  63 void get_members_from_file(char *filename, struct save_queue *queue);
  64 int collect(int argc, char **argv, void *l);
  65 struct member *parse_member(char *s);
  66 int membercmp(const void *mem1, const void *mem2);
  67 int sq_count_elts(struct save_queue *q);
  68 char *get_username(void);
  69
  70 int main(int argc, char **argv)
  71 {
  72   int status, success;
  73   char **arg = argv;
  74   char *membervec[4];
  75   struct member *memberstruct;
  76   char *server = NULL, *p;
  77
  78   /* clear all flags & lists */
  79   infoflg = verbose = syncflg = memberflg = recursflg = 0;
  80   noauth = showusers = showstrings = showkerberos = showlists = 0;
  81   createflag = setinfo = 0;
  82   active = public = hidden = maillist = grouplist = nfsgroup = -1;
  83   listname = newname = desc = NULL;
  84   owner = NULL;
  85   memacl = NULL;
  86   addlist = sq_create();
  87   dellist = sq_create();
  88   memberlist = sq_create();
  89   synclist = sq_create();
  90   taglist = sq_create();
  91   whoami = argv[0];
  92
  93   success = 1;
  94
  95   /* parse args, building addlist, dellist, & synclist */
  96   while (++arg - argv < argc)
  97     {
  98       if (**arg == '-')
  99         {
 100           if (argis("m", "members"))
 101             memberflg++;
 102           else if (argis("u", "users"))
 103             showusers++;
 104           else if (argis("s", "strings"))
 105             showstrings++;
 106           else if (argis("l", "lists"))
 107             showlists++;
 108           else if (argis("k", "kerberos"))
 109             showkerberos++;
 110           else if (argis("t", "tags"))
 111             showtags++;
 112           else if (argis("i", "info"))
 113             infoflg++;
 114           else if (argis("n", "noauth"))
 115             noauth++;
 116           else if (argis("v", "verbose"))
 117             verbose++;
 118           else if (argis("r", "recursive"))
 119             recursflg++;
 120           else if (argis("S", "server") || argis("db", "database"))
 121             {
 122               if (arg - argv < argc - 1)
 123                 {
 124                   ++arg;
 125                   server = *arg;
 126                 }
 127               else
 128                 usage(argv);
 129             }
 130           else if (argis("a", "add"))
 131             {
 132               if (arg - argv < argc - 1)
 133                 {
 134                   ++arg;
 135                   if ((memberstruct = parse_member(*arg)))
 136                     sq_save_data(addlist, memberstruct);
 137                 }
 138               else
 139                 usage(argv);
 140             }
 141           else if (argis("at", "addtagged"))
 142             {
 143               if (arg - argv < argc - 2)
 144                 {
 145                   ++arg;
 146                   if ((memberstruct = parse_member(*arg)))
 147                     sq_save_data(addlist, memberstruct);
 148                   memberstruct->tag = *++arg;
 149                 }
 150               else
 151                 usage(argv);
 152             }
 153           else if (argis("al", "addlist"))
 154             {
 155               if (arg - argv < argc - 1)
 156                 {
 157                   ++arg;
 158                   get_members_from_file(*arg, addlist);
 159                 }
 160               else
 161                 usage(argv);
 162             }
 163           else if (argis("d", "delete"))
 164             {
 165               if (arg - argv < argc - 1)
 166                 {
 167                   ++arg;
 168                   if ((memberstruct = parse_member(*arg)))
 169                     sq_save_data(dellist, memberstruct);
 170                 }
 171               else
 172                 usage(argv);
 173             }
 174           else if (argis("dl", "deletelist"))
 175             {
 176               if (arg - argv < argc - 1)
 177                 {
 178                   ++arg;
 179                   get_members_from_file(*arg, dellist);
 180                 }
 181               else
 182                 usage(argv);
 183             }
 184           else if (argis("f", "file"))
 185             {
 186               if (arg - argv < argc - 1)
 187                 {
 188                   syncflg++;
 189                   ++arg;
 190                   get_members_from_file(*arg, synclist);
 191                 }
 192               else
 193                 usage(argv);
 194             }
 195           else if (argis("ct", "changetag"))
 196             {
 197               if (arg - argv < argc - 2)
 198                 {
 199                   ++arg;
 200                   if ((memberstruct = parse_member(*arg)))
 201                     sq_save_data(taglist, memberstruct);
 202                   memberstruct->tag = *++arg;
 203                 }
 204               else
 205                 usage(argv);
 206             }
 207           else if (argis("C", "create"))
 208             createflag++;
 209           else if (argis("P", "public"))
 210             {
 211               setinfo++;
 212               public = 1;
 213             }
 214           else if (argis("NP", "private"))
 215             {
 216               setinfo++;
 217               public = 0;
 218             }
 219           else if (argis("A", "active"))
 220             {
 221               setinfo++;
 222               active = 1;
 223             }
 224           else if (argis("I", "inactive"))
 225             {
 226               setinfo++;
 227               active = 0;
 228             }
 229           else if (argis("V", "visible"))
 230             {
 231               setinfo++;
 232               hidden = 0;
 233             }
 234           else if (argis("H", "hidden"))
 235             {
 236               setinfo++;
 237               hidden = 1;
 238             }
 239           else if (argis("M", "mail"))
 240             {
 241               setinfo++;
 242               maillist = 1;
 243             }
 244           else if (argis("NM", "notmail"))
 245             {
 246               setinfo++;
 247               maillist = 0;
 248             }
 249           else if (argis("G", "group"))
 250             {
 251               setinfo++;
 252               grouplist = 1;
 253             }
 254           else if (argis("NG", "notgroup"))
 255             {
 256               setinfo++;
 257               grouplist = 0;
 258             }
 259           else if (argis("N", "nfs"))
 260             {
 261               setinfo++;
 262               nfsgroup = 1;
 263             }
 264           else if (argis("NN", "notnfs"))
 265             {
 266               setinfo++;
 267               nfsgroup = 0;
 268             }
 269           else if (argis("D", "desc"))
 270             {
 271               if (arg - argv < argc - 1)
 272                 {
 273                   setinfo++;
 274                   ++arg;
 275                   desc = *arg;
 276                 }
 277               else
 278                 usage(argv);
 279             }
 280           else if (argis("O", "owner"))
 281             {
 282               if (arg - argv < argc - 1)
 283                 {
 284                   setinfo++;
 285                   ++arg;
 286                   owner = parse_member(*arg);
 287                 }
 288               else
 289                 usage(argv);
 290             }
 291           else if (argis("MA", "memacl"))
 292             {
 293               if (arg - argv < argc -1)
 294                 {
 295                   setinfo++;
 296                   ++arg;
 297                   memacl = parse_member(*arg);
 298                 }
 299               else
 300                 usage(argv);
 301             }
 302           else if (argis("R", "rename"))
 303             {
 304               if (arg - argv < argc - 1)
 305                 {
 306                   setinfo++;
 307                   ++arg;
 308                   newname = *arg;
 309                 }
 310               else
 311                 usage(argv);
 312             }
 313           else
 314             usage(argv);
 315         }
 316       else if (listname == NULL)
 317         listname = *arg;
 318       else
 319         usage(argv);
 320     }
 321   if (listname == NULL)
 322     usage(argv);
 323
 324   /* if no other options specified, turn on list members flag */
 325   if (!(infoflg || syncflg || createflag || setinfo ||
 326         addlist->q_next != addlist || dellist->q_next != dellist ||
 327         taglist->q_next != taglist))
 328     memberflg++;
 329
 330   /* If none of {users,strings,lists,kerberos} specified, turn them all on */
 331   if (!(showusers || showstrings || showlists || showkerberos))
 332     showusers = showstrings = showlists = showkerberos = 1;
 333
 334   /* fire up Moira */
 335   status = mrcl_connect(server, "blanche", 4, !noauth);
 336   if (status == MRCL_AUTH_ERROR)
 337     {
 338       com_err(whoami, 0, "Try the -noauth flag if you don't "
 339               "need authentication.");
 340     }
 341   if (status)
 342     exit(2);
 343
 344   /* check for username/listname clash */
 345   if (createflag || (setinfo && newname && strcmp(newname, listname)))
 346     {
 347       status = mr_query("get_user_account_by_login", 1,
 348                         createflag ? &listname : &newname,
 349                         NULL, NULL);
 350       if (status != MR_NO_MATCH)
 351         fprintf(stderr, "WARNING: A user by that name already exists.\n");
 352     }
 353
 354   /* create if needed */
 355   if (createflag)
 356     {
 357       char *argv[13];
 358
 359       argv[L_NAME] = listname;
 360       argv[L_ACTIVE] = (active == 0) ? "0" : "1";
 361       argv[L_PUBLIC] = (public == 1) ? "1" : "0";
 362       argv[L_HIDDEN] = (hidden == 1) ? "1" : "0";
 363       argv[L_MAILLIST] = (maillist == 0) ? "0" : "1";
 364       argv[L_GROUP] = (grouplist == 1) ? "1" : "0";
 365       argv[L_GID] = UNIQUE_GID;
 366       argv[L_NFSGROUP] = (nfsgroup == 1) ? "1" : "0";
 367       argv[L_DESC] = desc ? desc : "none";
 368
 369       if (memacl)
 370         {
 371           if (memacl->type == M_ANY)
 372             {
 373               status = mr_query("get_user_account_by_login", 1,
 374                                 &memacl->name, NULL, NULL);
 375               if (status == MR_NO_MATCH)
 376                 memacl->type = M_LIST;
 377               else
 378                 memacl->type = M_USER;
 379             }
 380           argv[L_MEMACE_TYPE] = typename[memacl->type];
 381           argv[L_MEMACE_NAME] = memacl->name;
 382         }
 383       else
 384         argv[L_MEMACE_TYPE] = argv[L_MEMACE_NAME] = "NONE";
 385
 386       if (owner)
 387         {
 388           argv[L_ACE_NAME] = owner->name;
 389           switch (owner->type)
 390             {
 391             case M_ANY:
 392             case M_USER:
 393               argv[L_ACE_TYPE] = "USER";
 394               status = mr_query("add_list", 13, argv, NULL, NULL);
 395               if (owner->type != M_ANY || status != MR_USER)
 396                 break;
 397
 398             case M_LIST:
 399               argv[L_ACE_TYPE] = "LIST";
 400               status = mr_query("add_list", 13, argv, NULL, NULL);
 401               break;
 402
 403             case M_KERBEROS:
 404               argv[L_ACE_TYPE] = "KERBEROS";
 405               status = mr_query("add_list", 13, argv, NULL, NULL);
 406               break;
 407             }
 408         }
 409       else
 410         {
 411           argv[L_ACE_TYPE] = "USER";
 412           argv[L_ACE_NAME] = get_username();
 413
 414           status = mr_query("add_list", 13, argv, NULL, NULL);
 415         }
 416
 417       if (status)
 418         {
 419           com_err(whoami, status, "while creating list.");
 420           exit(1);
 421         }
 422     }
 423   else if (setinfo)
 424     {
 425       char *argv[14];
 426
 427       status = mr_query("get_list_info", 1, &listname,
 428                         save_list_info, argv);
 429       if (status)
 430         {
 431           com_err(whoami, status, "while getting list information");
 432           exit(1);
 433         }
 434
 435       argv[0] = listname;
 436       if (newname)
 437         argv[L_NAME + 1] = newname;
 438       if (active != -1)
 439         argv[L_ACTIVE + 1] = active ? "1" : "0";
 440       if (public != -1)
 441         argv[L_PUBLIC + 1] = public ? "1" : "0";
 442       if (hidden != -1)
 443         argv[L_HIDDEN + 1] = hidden ? "1" : "0";
 444       if (maillist != -1)
 445         argv[L_MAILLIST + 1] = maillist ? "1" : "0";
 446       if (grouplist != -1)
 447         argv[L_GROUP + 1] = grouplist ? "1" : "0";
 448       if (nfsgroup != -1)
 449         argv[L_NFSGROUP + 1] = nfsgroup ? "1" : "0";
 450       if (desc)
 451         argv[L_DESC + 1] = desc;
 452
 453       if (memacl)
 454         {
 455           if (memacl->type == M_ANY)
 456             {
 457               status = mr_query("get_user_account_by_login", 1,
 458                                 &memacl->name, NULL, NULL);
 459               if (status == MR_NO_MATCH)
 460                 memacl->type = M_LIST;
 461               else
 462                 memacl->type = M_USER;
 463             }
 464           argv[L_MEMACE_TYPE + 1] = typename[memacl->type];
 465           argv[L_MEMACE_NAME + 1] = memacl->name;
 466         }
 467
 468       if (owner)
 469         {
 470           argv[L_ACE_NAME + 1] = owner->name;
 471           switch (owner->type)
 472             {
 473             case M_ANY:
 474             case M_USER:
 475               argv[L_ACE_TYPE + 1] = "USER";
 476               status = mr_query("update_list", 14, argv, NULL, NULL);
 477               if (owner->type != M_ANY || status != MR_USER)
 478                 break;
 479
 480             case M_LIST:
 481               argv[L_ACE_TYPE + 1] = "LIST";
 482               status = mr_query("update_list", 14, argv, NULL, NULL);
 483               break;
 484
 485             case M_KERBEROS:
 486               argv[L_ACE_TYPE + 1] = "KERBEROS";
 487               status = mr_query("update_list", 14, argv, NULL, NULL);
 488               break;
 489             }
 490         }
 491       else
 492         status = mr_query("update_list", 14, argv, NULL, NULL);
 493
 494       if (status)
 495         {
 496           com_err(whoami, status, "while updating list.");
 497           success = 0;
 498         }
 499       else if (newname)
 500         listname = newname;
 501     }
 502
 503   /* display list info if requested to */
 504   if (infoflg)
 505     {
 506       status = mr_query("get_list_info", 1, &listname, show_list_info, NULL);
 507       if (status)
 508         {
 509           com_err(whoami, status, "while getting list information");
 510           success = 0;
 511         }
 512       if (verbose && !memberflg)
 513         {
 514           status = mr_query("count_members_of_list", 1, &listname,
 515                             show_list_count, NULL);
 516           if (status)
 517             {
 518               com_err(whoami, status, "while getting list count");
 519               success = 0;
 520             }
 521         }
 522     }
 523
 524   /* if we're synchronizing to a file, we need to:
 525    *  get the current members of the list
 526    *    for each member of the sync file
 527    *       if they are on the list, remove them from the in-memory copy
 528    *       if they're not on the list, add them to add-list
 529    *    if anyone is left on the in-memory copy, put them on the delete-list
 530    * lastly, reset memberlist so we can use it again later
 531    */
 532   if (syncflg)
 533     {
 534       status = mr_query("get_members_of_list", 1, &listname,
 535                         get_list_members, memberlist);
 536       if (status)
 537         {
 538           com_err(whoami, status, "getting members of list %s", listname);
 539           exit(2);
 540         }
 541       while (sq_get_data(synclist, &memberstruct))
 542         {
 543           struct save_queue *q;
 544           int removed = 0;
 545
 546           for (q = memberlist->q_next; q != memberlist; q = q->q_next)
 547             {
 548               if (membercmp(q->q_data, memberstruct) == 0)
 549                 {
 550                   q->q_prev->q_next = q->q_next;
 551                   q->q_next->q_prev = q->q_prev;
 552                   removed++;
 553                   break;
 554                 }
 555             }
 556           if (!removed)
 557             sq_save_data(addlist, memberstruct);
 558         }
 559       while (sq_get_data(memberlist, &memberstruct))
 560         sq_save_data(dellist, memberstruct);
 561       sq_destroy(memberlist);
 562       memberlist = sq_create();
 563     }
 564
 565   /* Process the add list */
 566   while (sq_get_data(addlist, &memberstruct))
 567     {
 568       /* canonicalize string if necessary */
 569       if (memberstruct->type != M_KERBEROS &&
 570           (p = strchr(memberstruct->name, '@')))
 571         {
 572           char *host = canonicalize_hostname(strdup(++p));
 573           static char **mailhubs = NULL;
 574           char *argv[4];
 575           int i;
 576
 577           if (!mailhubs)
 578             {
 579               argv[0] = "mailhub";
 580               argv[1] = "TYPE";
 581               argv[2] = "*";
 582               mailhubs = malloc(sizeof(char *));
 583               mailhubs[0] = NULL;
 584               status = mr_query("get_alias", 3, argv, collect,
 585                                 &mailhubs);
 586               if (status != MR_SUCCESS && status != MR_NO_MATCH)
 587                 {
 588                   com_err(whoami, status,
 589                           " while reading list of MAILHUB servers");
 590                   mailhubs[0] = NULL;
 591                 }
 592             }
 593           for (i = 0; (p = mailhubs[i]); i++)
 594             {
 595               if (!strcasecmp(p, host))
 596                 {
 597                   host = strdup(memberstruct->name);
 598                   *(strchr(memberstruct->name, '@')) = 0;
 599                   if (memberstruct->type == M_STRING)
 600                       memberstruct->type = M_ANY;
 601                   fprintf(stderr, "Warning: \"%s\" converted to "
 602                           "\"%s\" because it is a local name.\n",
 603                           host, memberstruct->name);
 604                   break;
 605                 }
 606             }
 607           free(host);
 608         }
 609       /* now continue adding member */
 610       membervec[0] = listname;
 611       membervec[2] = memberstruct->name;
 612       membervec[3] = memberstruct->tag;
 613       if (verbose)
 614         {
 615           printf("Adding member ");
 616           show_list_member(memberstruct);
 617         }
 618       switch (memberstruct->type)
 619         {
 620         case M_ANY:
 621         case M_USER:
 622           membervec[1] = "USER";
 623           status = mr_query("add_tagged_member_to_list", 4, membervec,
 624                             NULL, NULL);
 625           if (status == MR_SUCCESS)
 626             break;
 627           else if (status != MR_USER || memberstruct->type != M_ANY)
 628             {
 629               com_err(whoami, status, "while adding member %s to %s",
 630                       memberstruct->name, listname);
 631               success = 0;
 632               break;
 633             }
 634         case M_LIST:
 635           membervec[1] = "LIST";
 636           status = mr_query("add_tagged_member_to_list", 4, membervec,
 637                             NULL, NULL);
 638           if (status == MR_SUCCESS)
 639             {
 640               if (!strcmp(membervec[0], get_username()))
 641                 {
 642                   fprintf(stderr, "\nWARNING: \"LIST:%s\" was just added "
 643                           "to list \"%s\".\n", membervec[2], membervec[0]);
 644                   fprintf(stderr, "If you meant to add yourself to the list "
 645                           "\"%s\", type:\n", membervec[2]);
 646                   fprintf(stderr, "\tblanche %s -d %s\t(to undo this)\n",
 647                           membervec[0], membervec[2]);
 648                   fprintf(stderr, "\tblanche %s -a %s\t(to add yourself to "
 649                           "that list)\n", membervec[2], membervec[0]);
 650                 }
 651               break;
 652             }
 653           else if (status != MR_LIST || memberstruct->type != M_ANY)
 654             {
 655               com_err(whoami, status, "while adding member %s to %s",
 656                       memberstruct->name, listname);
 657               success = 0;
 658               break;
 659             }
 660         case M_STRING:
 661           status = mrcl_validate_string_member(memberstruct->name);
 662           if (status == MRCL_REJECT)
 663             {
 664               mrcl_com_err(whoami);
 665               success = 0;
 666               break;
 667             }
 668           else if (memberstruct->type == M_ANY && status != MR_SUCCESS)
 669             {
 670               /* if user is trying to add something which isn't a
 671                  remote string, or a list, or a user, and didn't
 672                  explicitly specify `STRING:', it's probably a typo */
 673               com_err(whoami, MR_NO_MATCH, "while adding member %s to %s",
 674                       memberstruct->name, listname);
 675               success = 0;
 676               break;
 677             }
 678
 679           membervec[1] = "STRING";
 680           status = mr_query("add_tagged_member_to_list", 4, membervec,
 681                             NULL, NULL);
 682           if (status != MR_SUCCESS)
 683             {
 684               com_err(whoami, status, "while adding member %s to %s",
 685                       memberstruct->name, listname);
 686               success = 0;
 687             }
 688           break;
 689         case M_KERBEROS:
 690           membervec[1] = "KERBEROS";
 691           status = mrcl_validate_kerberos_member(membervec[2], &membervec[2]);
 692           if (mrcl_get_message())
 693             mrcl_com_err(whoami);
 694           status = mr_query("add_tagged_member_to_list", 4, membervec,
 695                             NULL, NULL);
 696           if (status != MR_SUCCESS)
 697             {
 698               com_err(whoami, status, "while adding member %s to %s",
 699                       memberstruct->name, listname);
 700               success = 0;
 701             }
 702           free(membervec[2]);
 703         }
 704     }
 705
 706   /* Process the delete list */
 707   while (sq_get_data(dellist, &memberstruct))
 708     {
 709       membervec[0] = listname;
 710       membervec[2] = memberstruct->name;
 711       if (verbose)
 712         {
 713           printf("Deleting member ");
 714           show_list_member(memberstruct);
 715         }
 716       switch (memberstruct->type)
 717         {
 718         case M_ANY:
 719         case M_USER:
 720           membervec[1] = "USER";
 721           status = mr_query("delete_member_from_list", 3, membervec,
 722                             NULL, NULL);
 723           if (status == MR_SUCCESS)
 724             break;
 725           else if ((status != MR_USER && status != MR_NO_MATCH) ||
 726                    memberstruct->type != M_ANY)
 727             {
 728               com_err(whoami, status, "while deleting member %s from %s",
 729                       memberstruct->name, listname);
 730               success = 0;
 731               break;
 732             }
 733         case M_LIST:
 734           membervec[1] = "LIST";
 735           status = mr_query("delete_member_from_list", 3, membervec,
 736                             NULL, NULL);
 737           if (status == MR_SUCCESS)
 738             break;
 739           else if ((status != MR_LIST && status != MR_NO_MATCH) ||
 740                    memberstruct->type != M_ANY)
 741             {
 742               if (status == MR_PERM && memberstruct->type == M_ANY &&
 743                   !strcmp(membervec[2], get_username()))
 744                 {
 745                   /* M_ANY means we've fallen through from the user
 746                    * case. The user is trying to remove himself from
 747                    * a list, but we got MR_USER or MR_NO_MATCH above,
 748                    * meaning he's not really on it, and we got MR_PERM
 749                    * when trying to remove LIST:$USER because he's not
 750                    * on the acl. That error is useless, so return
 751                    * MR_NO_MATCH instead. However, this will generate the
 752                    * wrong error if the user was trying to remove the list
 753                    * with his username from a list he doesn't administrate
 754                    * without explicitly specifying "list:".
 755                    */
 756                   status = MR_NO_MATCH;
 757                 }
 758               com_err(whoami, status, "while deleting member %s from %s",
 759                       memberstruct->name, listname);
 760               success = 0;
 761               break;
 762             }
 763         case M_STRING:
 764           membervec[1] = "STRING";
 765           status = mr_query("delete_member_from_list", 3, membervec,
 766                             NULL, NULL);
 767           if (status == MR_STRING && memberstruct->type == M_ANY)
 768             {
 769               com_err(whoami, 0, " Unable to find member %s to delete from %s",
 770                       memberstruct->name, listname);
 771               success = 0;
 772               if (!strcmp(membervec[0], get_username()))
 773                 {
 774                   fprintf(stderr, "(If you were trying to remove yourself "
 775                           "from the list \"%s\",\n", membervec[2]);
 776                   fprintf(stderr, "the correct command is \"blanche %s -d "
 777                           "%s\".)\n", membervec[2], membervec[0]);
 778                 }
 779             }
 780           else if (status != MR_SUCCESS)
 781             {
 782               com_err(whoami, status, "while deleting member %s from %s",
 783                       memberstruct->name, listname);
 784               success = 0;
 785             }
 786           break;
 787         case M_KERBEROS:
 788           membervec[1] = "KERBEROS";
 789           status = mr_query("delete_member_from_list", 3, membervec,
 790                             NULL, NULL);
 791           if (status == MR_STRING || status == MR_NO_MATCH)
 792             {
 793               /* Try canonicalizing the Kerberos principal and trying
 794                * again.  If we succeed, print the message from mrcl.
 795                * Otherwise, just pretend we never did this and print
 796                * the original error message.
 797                */
 798               mrcl_validate_kerberos_member(membervec[2], &membervec[2]);
 799               if (mrcl_get_message())
 800                 {
 801                   if (mr_query("delete_member_from_list", 3, membervec,
 802                                NULL, NULL) == MR_SUCCESS)
 803                     mrcl_com_err(whoami);
 804                   status = MR_SUCCESS;
 805                 }
 806             }
 807           if (status != MR_SUCCESS)
 808             {
 809               com_err(whoami, status, "while deleting member %s from %s",
 810                       memberstruct->name, listname);
 811               success = 0;
 812             }
 813         }
 814     }
 815
 816   /* Process the tag list */
 817   while (sq_get_data(taglist, &memberstruct))
 818     {
 819       membervec[0] = listname;
 820       membervec[2] = memberstruct->name;
 821       membervec[3] = memberstruct->tag;
 822       if (verbose)
 823         {
 824           printf("Tagging member ");
 825           show_list_member(memberstruct);
 826         }
 827       switch (memberstruct->type)
 828         {
 829         case M_ANY:
 830         case M_USER:
 831           membervec[1] = "USER";
 832           status = mr_query("tag_member_of_list", 4, membervec,
 833                             NULL, NULL);
 834           if (status == MR_SUCCESS)
 835             break;
 836           else if ((status != MR_USER && status != MR_NO_MATCH) ||
 837                    memberstruct->type != M_ANY)
 838             {
 839               com_err(whoami, status, "while changing tag on member %s of %s",
 840                       memberstruct->name, listname);
 841               success = 0;
 842               break;
 843             }
 844         case M_LIST:
 845           membervec[1] = "LIST";
 846           status = mr_query("tag_member_of_list", 4, membervec,
 847                             NULL, NULL);
 848           if (status == MR_SUCCESS)
 849             break;
 850           else if ((status != MR_LIST && status != MR_NO_MATCH) ||
 851                    memberstruct->type != M_ANY)
 852             {
 853               com_err(whoami, status, "while changing tag on member %s of %s",
 854                       memberstruct->name, listname);
 855               success = 0;
 856               break;
 857             }
 858         case M_STRING:
 859           membervec[1] = "STRING";
 860           status = mr_query("tag_member_of_list", 4, membervec,
 861                             NULL, NULL);
 862           if (status == MR_STRING && memberstruct->type == M_ANY)
 863             {
 864               com_err(whoami, 0, " Unable to find member %s on list %s",
 865                       memberstruct->name, listname);
 866               success = 0;
 867             }
 868           else if (status != MR_SUCCESS)
 869             {
 870               com_err(whoami, status, "while retagging member %s on %s",
 871                       memberstruct->name, listname);
 872               success = 0;
 873             }
 874           break;
 875         case M_KERBEROS:
 876           membervec[1] = "KERBEROS";
 877           status = mr_query("tag_member_of_list", 4, membervec,
 878                             NULL, NULL);
 879           if (status == MR_STRING || status == MR_NO_MATCH)
 880             {
 881               /* Try canonicalizing the Kerberos principal and trying
 882                * again.  If we succeed, print the message from mrcl.
 883                * Otherwise, just pretend we never did this and print
 884                * the original error message.
 885                */
 886               mrcl_validate_kerberos_member(membervec[2], &membervec[2]);
 887               if (mrcl_get_message())
 888                 {
 889                   if (mr_query("tag_member_of_list", 4, membervec,
 890                                NULL, NULL) == MR_SUCCESS)
 891                     mrcl_com_err(whoami);
 892                   status = MR_SUCCESS;
 893                 }
 894             }
 895           if (status != MR_SUCCESS)
 896             {
 897               com_err(whoami, status, "while changing tag on member %s of %s",
 898                       memberstruct->name, listname);
 899               success = 0;
 900             }
 901         }
 902     }
 903
 904   /* Display the members of the list now, if requested */
 905   if (memberflg)
 906     {
 907       if (recursflg)
 908         recursive_display_list_members();
 909       else
 910         {
 911           status = mr_query(showtags ? "get_tagged_members_of_list" :
 912                             "get_members_of_list", 1, &listname,
 913                             get_list_members, memberlist);
 914           if (status)
 915             com_err(whoami, status, "while getting members of list %s",
 916                     listname);
 917           while (sq_get_data(memberlist, &memberstruct))
 918             show_list_member(memberstruct);
 919         }
 920     }
 921
 922   /* We're done! */
 923   mr_disconnect();
 924   exit(success ? 0 : 1);
 925 }
 926
 927 void usage(char **argv)
 928 {
 929 #define USAGE_OPTIONS_FORMAT "  %-39s%s\n"
 930   fprintf(stderr, "Usage: %s listname [options]\n", argv[0]);
 931   fprintf(stderr, "Options are\n");
 932   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-v  | -verbose",
 933           "-C  | -create");
 934   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-m  | -members",
 935           "-R  | -rename newname");
 936   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-u  | -users",
 937           "-P  | -public");
 938   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-l  | -lists",
 939           "-NP | -private");
 940   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-s  | -strings",
 941           "-A  | -active");
 942   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-k  | -kerberos",
 943           "-I  | -inactive");
 944   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-i  | -info",
 945           "-V  | -visible");
 946   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-r  | -recursive",
 947           "-H  | -hidden");
 948   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-a  | -add member",
 949           "-M  | -mail");
 950   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-d  | -delete member",
 951           "-NM | -notmail");
 952   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-al | -addlist filename",
 953           "-G  | -group");
 954   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-dl | -deletelist filename",
 955           "-NG | -notgroup");
 956   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-f  | -file filename",
 957           "-N  | -nfs");
 958   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-at | -addtagged member tag",
 959           "-NN | -notnfs");
 960   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-ct | -changetag member tag",
 961           "-D  | -desc description");
 962   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-t  | -tags",
 963           "-O  | -owner owner");
 964   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-n  | -noauth",
 965           "-MA | -memacl membership_acl");
 966   fprintf(stderr, USAGE_OPTIONS_FORMAT, "-db | -database host[:port]",
 967           "");
 968   exit(1);
 969 }
 970
 971
 972 /* Display the members stored in the queue */
 973
 974 void show_list_member(struct member *memberstruct)
 975 {
 976   char *s = "";
 977
 978   switch (memberstruct->type)
 979     {
 980     case M_USER:
 981       if (!showusers)
 982         return;
 983       s = "USER";
 984       break;
 985     case M_LIST:
 986       if (!showlists)
 987         return;
 988       s = "LIST";
 989       break;
 990     case M_STRING:
 991       if (!showstrings)
 992         return;
 993       s = "STRING";
 994       break;
 995     case M_KERBEROS:
 996       if (!showkerberos)
 997         return;
 998       s = "KERBEROS";
 999       break;
1000     case M_ANY:
1001       printf("%s\n", memberstruct->name);
1002       return;
1003     }
1004
1005   if (verbose)
1006     printf("%s:%s", s, memberstruct->name);
1007   else
1008     {
1009       if (memberstruct->type == M_LIST)
1010         printf("LIST:%s", memberstruct->name);
1011       else if (memberstruct->type == M_KERBEROS)
1012         printf("KERBEROS:%s", memberstruct->name);
1013       else if (memberstruct->type == M_STRING &&
1014                !strchr(memberstruct->name, '@'))
1015         printf("STRING:%s", memberstruct->name);
1016       else
1017         printf("%s", memberstruct->name);
1018     }
1019   if (showtags && *(memberstruct->tag))
1020     printf(" (%s)\n", memberstruct->tag);
1021   else
1022     printf("\n");
1023 }
1024
1025
1026 /* Show the retrieved information about a list */
1027
1028 int show_list_info(int argc, char **argv, void *hint)
1029 {
1030   printf("List: %s\n", argv[L_NAME]);
1031   printf("Description: %s\n", argv[L_DESC]);
1032   printf("Flags: %s, %s, and %s\n",
1033          atoi(argv[L_ACTIVE]) ? "active" : "inactive",
1034          atoi(argv[L_PUBLIC]) ? "public" : "private",
1035          atoi(argv[L_HIDDEN]) ? "hidden" : "visible");
1036   printf("%s is %sa maillist and is %sa group", argv[L_NAME],
1037          atoi(argv[L_MAILLIST]) ? "" : "not ",
1038          atoi(argv[L_GROUP]) ? "" : "not ");
1039   if (atoi(argv[L_GROUP]))
1040     {
1041       if (atoi(argv[L_NFSGROUP]))
1042         printf(" (and an NFS group)");
1043       printf(" with GID %d\n", atoi(argv[L_GID]));
1044     }
1045   else
1046     printf("\n");
1047   printf("Owner: %s %s\n", argv[L_ACE_TYPE], argv[L_ACE_NAME]);
1048   if (strcmp(argv[L_MEMACE_TYPE], "NONE"))
1049     printf("Membership ACL: %s %s\n", argv[L_MEMACE_TYPE],
1050            argv[L_MEMACE_NAME]);
1051   printf("Last modified by %s with %s on %s\n",
1052          argv[L_MODBY], argv[L_MODWITH], argv[L_MODTIME]);
1053   return MR_CONT;
1054 }
1055
1056
1057 /* Copy retrieved information about a list into a new argv */
1058
1059 int save_list_info(int argc, char **argv, void *hint)
1060 {
1061   char **nargv = hint;
1062
1063   for (argc = 0; argc < 14; argc++)
1064     nargv[argc + 1] = strdup(argv[argc]);
1065   return MR_CONT;
1066 }
1067
1068 /* Show the retrieve list member count */
1069
1070 int show_list_count(int argc, char **argv, void *hint)
1071 {
1072   printf("Members: %s\n", argv[0]);
1073   return MR_CONT;
1074 }
1075
1076
1077 /* Recursively find all of the members of listname, and then display them */
1078
1079 void recursive_display_list_members(void)
1080 {
1081   int status, count, savecount;
1082   struct save_queue *lists, *members;
1083   struct member *m, *m1, *data;
1084
1085   lists = sq_create();
1086   members = sq_create();
1087   m = malloc(sizeof(struct member));
1088   m->type = M_LIST;
1089   m->name = listname;
1090   sq_save_data(lists, m);
1091
1092   while (sq_get_data(lists, &m))
1093     {
1094       sq_destroy(memberlist);
1095       memberlist = sq_create();
1096       status = mr_query("get_members_of_list", 1, &(m->name),
1097                         get_list_members, memberlist);
1098       if (status)
1099         com_err(whoami, status, "while getting members of list %s", m->name);
1100       while (sq_get_data(memberlist, &m1))
1101         {
1102           if (m1->type == M_LIST)
1103             unique_add_member(lists, m1);
1104           else
1105             unique_add_member(members, m1);
1106         }
1107     }
1108   savecount = count = sq_count_elts(members);
1109   data = malloc(count * sizeof(struct member));
1110   count = 0;
1111   while (sq_get_data(members, &m))
1112     memcpy(&data[count++], m, sizeof(struct member));
1113   qsort(data, count, sizeof(struct member), membercmp);
1114   for (count = 0; count < savecount; count++)
1115     show_list_member(&data[count]);
1116 }
1117
1118
1119 /* add a struct member to a queue if that member isn't already there. */
1120
1121 void unique_add_member(struct save_queue *q, struct member *m)
1122 {
1123   struct save_queue *qp;
1124
1125   for (qp = q->q_next; qp != q; qp = qp->q_next)
1126     {
1127       if (!membercmp(qp->q_data, m))
1128         return;
1129     }
1130   sq_save_data(q, m);
1131 }
1132
1133
1134 /* Collect the retrieved members of the list */
1135
1136 int get_list_members(int argc, char **argv, void *sq)
1137 {
1138   struct save_queue *q = sq;
1139   struct member *m;
1140
1141   m = malloc(sizeof(struct member));
1142   switch (argv[0][0])
1143     {
1144     case 'U':
1145       m->type = M_USER;
1146       break;
1147     case 'L':
1148       m->type = M_LIST;
1149       break;
1150     case 'S':
1151       m->type = M_STRING;
1152       break;
1153     case 'K':
1154       m->type = M_KERBEROS;
1155       break;
1156     }
1157   m->name = strdup(argv[1]);
1158   if (argc == 3)
1159     m->tag = strdup(argv[2]);
1160   else
1161     m->tag = strdup("");
1162   sq_save_data(q, m);
1163   return MR_CONT;
1164 }
1165
1166
1167 /* Open file, parse members from file, and put them on the specified queue */
1168 void get_members_from_file(char *filename, struct save_queue *queue)
1169 {
1170   FILE *in;
1171   char buf[BUFSIZ];
1172   struct member *memberstruct;
1173
1174   if (!strcmp(filename, "-"))
1175     in = stdin;
1176   else
1177     {
1178       in = fopen(filename, "r");
1179       if (!in)
1180         {
1181           com_err(whoami, errno, "while opening %s for input", filename);
1182           exit(2);
1183         }
1184     }
1185
1186   while (fgets(buf, BUFSIZ, in))
1187     {
1188       if ((memberstruct = parse_member(buf)))
1189         sq_save_data(queue, memberstruct);
1190     }
1191   if (!feof(in))
1192     {
1193       com_err(whoami, errno, "while reading from %s", filename);
1194       exit(2);
1195     }
1196 }
1197
1198
1199 /* Collect the possible expansions of the alias MAILHUB */
1200
1201 int collect(int argc, char **argv, void *l)
1202 {
1203   char ***list = l;
1204   int i;
1205
1206   for (i = 0; (*list)[i]; i++)
1207     ;
1208   *list = realloc(*list, (i + 2) * sizeof(char *));
1209   (*list)[i] = strdup(argv[2]);
1210   (*list)[i + 1] = NULL;
1211   return MR_CONT;
1212 }
1213
1214
1215 /* Parse a line of input, fetching a member.  NULL is returned if a member
1216  * is not found.  ';' is a comment character.
1217  */
1218
1219 struct member *parse_member(char *s)
1220 {
1221   struct member *m;
1222   char *p, *lastchar;
1223
1224   while (*s && isspace(*s))
1225     s++;
1226   lastchar = p = s;
1227   while (*p && *p != '\n' && *p != ';')
1228     {
1229       if (isprint(*p) && !isspace(*p))
1230         lastchar = p++;
1231       else
1232         p++;
1233     }
1234   lastchar++;
1235   *lastchar = '\0';
1236   if (p == s || strlen(s) == 0)
1237     return NULL;
1238
1239   if (!(m = malloc(sizeof(struct member))))
1240     return NULL;
1241   m->tag = strdup("");
1242
1243   if ((p = strchr(s, ':')))
1244     {
1245       *p = '\0';
1246       m->name = ++p;
1247       if (!strcasecmp("user", s))
1248         m->type = M_USER;
1249       else if (!strcasecmp("list", s))
1250         m->type = M_LIST;
1251       else if (!strcasecmp("string", s))
1252         m->type = M_STRING;
1253       else if (!strcasecmp("kerberos", s))
1254         m->type = M_KERBEROS;
1255       else
1256         {
1257           m->type = M_ANY;
1258           *(--p) = ':';
1259           m->name = s;
1260         }
1261       m->name = strdup(m->name);
1262     }
1263   else
1264     {
1265       m->name = strdup(s);
1266       m->type = M_ANY;
1267     }
1268   return m;
1269 }
1270
1271
1272 /*
1273  * This routine two compares members by the following rules:
1274  * 1.  A USER is less than a LIST
1275  * 2.  A LIST is less than a STRING
1276  * 3.  If two members are of the same type, the one alphabetically first
1277  *     is less than the other
1278  * It returs < 0 if the first member is less, 0 if they are identical, and
1279  * > 0 if the second member is less (the first member is greater).
1280  */
1281
1282 int membercmp(const void *mem1, const void *mem2)
1283 {
1284   const struct member *m1 = mem1, *m2 = mem2;
1285
1286   if (m1->type == M_ANY || m2->type == M_ANY || (m1->type == m2->type))
1287     return strcmp(m1->name, m2->name);
1288   else
1289     return m1->type - m2->type;
1290 }
1291
1292
1293 int sq_count_elts(struct save_queue *q)
1294 {
1295   char *foo;
1296   int count;
1297
1298   count = 0;
1299   while (sq_get_data(q, &foo))
1300     count++;
1301   return count;
1302 }
1303
1304 char *get_username(void)
1305 {
1306   char *username;
1307
1308   username = getenv("USER");
1309   if (!username)
1310     {
1311       username = mrcl_krb_user();
1312       if (!username)
1313         {
1314           com_err(whoami, 0, "Could not determine username");
1315           exit(1);
1316         }
1317     }
1318   return username;
1319 }