[moira.git] / gen / mailhub.qc


/* $Header$
 *
 * This generates the /usr/lib/aliases file for the mailhub.
 *
 *  (c) Copyright 1988 by the Massachusetts Institute of Technology.
 *  For copying and distribution information, please see the file
 *  <mit-copyright.h>.
 */

#include <mit-copyright.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <sms.h>
#include <sms_app.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>


extern int errno;
char *whoami = "mailhub.gen";
char *ingres_date_and_time();
char *divide = "##############################################################";

#define ML_WID	72
#define AL_MAX_WID 896

#define FALSE 0
#define TRUE (!FALSE)


main(argc, argv)
int argc;
char **argv;
{
    long tm = time(NULL);
    FILE *out= stdout;
    char filename[64], *targetfile;
    struct stat sb;
##  int flag;
##  char *filetime;
    int ingerr();

    IIseterr(ingerr);
##  ingres sms
##  set lockmode session where level = table

    if (argc == 2) {
	if (stat(argv[1], &sb) == 0) {
	    filetime = ingres_date_and_time(sb.st_mtime);
##	    retrieve (flag = int4(interval("min",tblstats.modtime - filetime)))
##		where tblstats.table = "users"
	    if (flag < 0) {
		fprintf(stderr, "File %s does not need to be rebuilt.\n",
			argv[1]);
		exit(SMS_NO_CHANGE);
	    }
	}
	targetfile = argv[1];
	sprintf(filename, "%s~", targetfile);
	if ((out = fopen(filename, "w")) == NULL) {
	    fprintf(stderr, "unable to open %s for output\n", filename);
	    exit(SMS_OCONFIG);
	}
    } else if (argc != 1) {
	fprintf(stderr, "usage: %s [outfile]\n", argv[0]);
	exit(SMS_ARGS);
    }

    fprintf(out, "%s\n# Aliases File Extract of %s", divide, ctime(&tm));
    fprintf(out, "# This file is automatically generated, do not edit it directly.\n%s\n\n", divide);

##  begin transaction
    get_info();
##  end transaction
##  exit

    fprintf(stderr, "Sorting Info\n");
    sort_info();

    fprintf(stderr, "Dumping information\n");
    do_lists(out);
    do_people(out);

    fprintf(out, "\n%s\n# End of aliases file\n", divide);

    if (fclose(out)) {
	perror("close failed");
	exit(SMS_CCONFIG);
    }

    if (argc == 2)
      fix_file(targetfile);
    exit(SMS_SUCCESS);
}


/*
 * ingerr: (supposedly) called when Ingres indicates an error.
 * I have not yet been able to get this to work to intercept a
 * database open error.
 */
#define INGRES_DEADLOCK 4700

static int ingerr(num)
    int *num;
{
    char buf[256];
    int ingres_errno;

    switch (*num) {
    case INGRES_DEADLOCK:
	ingres_errno = SMS_DEADLOCK;
	break;
    default:
	ingres_errno = SMS_INGRES_ERR;
    }
    com_err(whoami, SMS_INGRES_ERR, " code %d\n", *num);
    critical_alert("DCM", "Alias build encountered INGRES ERROR %d", *num);
    exit(ingres_errno);
}

struct hash *users, *machines, *strings, *lists, *names;
struct user {
    char *login;
    char *first;
    char *last;
    char mi;
    char *pobox;
};
struct member {
    struct member *next;
    char *name;
    int list_id;
};
struct list {
    char *name;
    char maillist;
    char acl_t;
    int acl_id;
    struct member *m;
};
struct names {
    char *name;
    struct names *next;
    int keep:1;
    int id:31;
};


get_info()
##{
##  int id, pid, bid, stat, cnt, maillistp, acl, mid;
##  char name[129], type[9], fname[17], mname[17], lname[17], buf[257];
    char *s;
    register struct user *u;
    struct list *l, *memberlist;
    register struct member *m;

    /* get locks */
##  retrieve (buf = users.modtime) where users.users_id = 0
##  retrieve (buf = list.modtime) where list.list_id = 0

    cnt = 0;
    machines = create_hash(1000);
##  retrieve (id = machine.mach_id, name = machine.#name) {
      if (s = index(name, '.'))
	*s = 0;
      sprintf(buf, "%s.LOCAL", name);
      if (hash_store(machines, id, strsave(buf)) < 0) {
	  fprintf(stderr, "Out of memory!\n");
	  exit(SMS_NO_MEM);
      }
      cnt++;
##  }
    fprintf(stderr, "Loaded %d machines\n", cnt);

    cnt = 0;
    strings = create_hash(2000);
##  retrieve (id = strings.string_id, name = strings.string) {
	if (hash_store(strings, id, strsave(strtrim(name))) < 0) {
	    fprintf(stderr, "Out of memory!\n");
	    exit(SMS_NO_MEM);
	}
	cnt++;
##  }
    fprintf(stderr, "Loaded %d strings\n", cnt);

    cnt = 0;
    users = create_hash(12001);
##  range of u is users
##  retrieve (id = u.users_id, name = u.login, fname = u.first,
##	      mname = u.middle, lname = u.last,
##	      type = u.potype, pid = u.pop_id, bid = u.box_id) 
##	where u.status != 3 {
	u = (struct user *) malloc(sizeof(struct user));
	u->login = strsave(strtrim(name));
	u->first = strsave(strtrim(fname));
	u->last  = strsave(strtrim(lname));
	if (mname[0] != ' ')
	  u->mi = mname[0];
	else
	  u->mi = 0;

	if (type[0] == 'P' && (s = hash_lookup(machines, pid))) {
	    sprintf(buf, "%s@%s", strtrim(name), s);
	    u->pobox = strsave(buf);
	} else if (type[0] ==  'S') {
	    u->pobox = hash_lookup(strings, bid);
	} else
	  u->pobox = (char *) NULL;
	if (hash_store(users, id, u) < 0) {
	    fprintf(stderr, "Out of memory!\n");
	    exit(SMS_NO_MEM);
	}
	cnt++;
##  }
    fprintf(stderr, "Loaded %d users\n", cnt);

    cnt = 0;
    lists = create_hash(15000);
##  range of l is list
##  retrieve (id = l.list_id, name = l.#name, maillistp = l.maillist,
##	      type = l.acl_type, acl = l.acl_id)
##    where l.active != 0 {
	l = (struct list *) malloc(sizeof(struct list));
	l->name = strsave(strtrim(name));
	l->maillist = maillistp;
	l->acl_t = type[0];
	l->acl_id = acl;
	l->m = (struct member *) NULL;
	if (hash_store(lists, id, l) < 0) {
	    fprintf(stderr, "Out of memory!\n");
	    exit(SMS_NO_MEM);
	}
	cnt++;
##  }
    fprintf(stderr, "Loaded %d lists\n", cnt);

    cnt = 0;
##  range of m is imembers
##  retrieve (id = m.list_id, type = m.member_type, mid = m.member_id)
##    	where m.direct = 1  {
	cnt++;
	if (l = (struct list *) hash_lookup(lists, id)) {
	    m = (struct member *) malloc(sizeof(struct member));
	    if (type[0] == 'U' &&
		(u = (struct user *) hash_lookup(users, mid))) {
		m->list_id = 0;
		m->name = u->login;
		m->next = l->m;
		l->m = m;
	    } else if (type[0] == 'L' && 
		       (memberlist = (struct list *) hash_lookup(lists, mid))) {
		m->list_id = mid;
		m->name = memberlist->name;
		m->next = l->m;
		l->m = m;
	    } else if (type[0] == 'S' &&
		       (s = hash_lookup(strings, mid))) {
		m->list_id = 0;
		m->next = l->m;
		l->m = m;
		m->name = s;
	    }
	}
##  }
    fprintf(stderr, "Loaded %d members\n", cnt);
##}


save_mlist(id, l, force)
int id;
struct list *l;
int force;
{
    register struct member *m;
    register struct list *l1;

    if (l->maillist == 2 ||
	l->maillist == 3 ||
	(l->maillist == 0 && !force))
      return;

    if (l->m && l->m->next == NULL &&
	!strcasecmp(l->name, l->m->name)) {
	l->maillist = 3;
	return;
    }
    l->maillist = 2;
    insert_name(l->name, -id, TRUE, FALSE);

    if (l->acl_t == 'L' && (l1 = (struct list *)hash_lookup(lists, l->acl_id)))
      save_mlist(0, l1, TRUE);
    
    for (m = l->m; m; m = m->next) {
	if (m->list_id && (l1 = (struct list *)hash_lookup(lists, m->list_id)))
	  save_mlist(0, l1, TRUE);
    }
}


insert_login(id, u, dummy)
int id;
struct user *u;
int dummy;
{
    if (u->pobox && u->login[0] != '#')
      insert_name(u->login, id, TRUE, FALSE);
}

void insert_names(id, u, dummy)
int id;
struct user *u;
int dummy;
{
    char buffer[256];

    insert_name(u->last, id, FALSE, FALSE);
    sprintf(buffer, "%s_%s", u->first, u->last);
    insert_name(buffer, id, FALSE, TRUE);
    sprintf(buffer, "%c_%s", u->first[0], u->last);
    insert_name(buffer, id, FALSE, TRUE);
    if (u->mi) {
	sprintf(buffer, "%s_%c_%s", u->first, u->mi, u->last);
	insert_name(buffer, id, FALSE, TRUE);
    }
}

int incount = 0;

insert_name(s, id, nodups, copy)
char *s;
int id;
int nodups;
int copy;
{
    int code;
    register struct names *ns;
    register int count;
    register struct idblock *ra;

    incount++;
    code = hashstr(s);
    ns = (struct names *) hash_lookup(names, code);
    if (ns == NULL) {
	if ((ns = (struct names *) malloc(sizeof(struct names))) == NULL) {
	    fprintf(stderr, "ran out of memory inserting name (sorting)\n");
	    exit(SMS_NO_MEM);
	}
	if (copy)
	  ns->name = strsave(s);
	else
	  ns->name = s;
	ns->keep = nodups;
	ns->id = id;
	if (hash_store(names, code, ns) < 0) {
	    fprintf(stderr, "Out of memory!\n");
	    exit(SMS_NO_MEM);
	}
	return;
    }
    if (strcasecmp(ns->name, s)) {
	while (ns->next) {
	    ns = ns->next;
	    if (!strcasecmp(ns->name, s))
	      goto foundns;
	}
	if ((ns->next = (struct names *)malloc(sizeof(struct names))) == NULL) {
	    fprintf(stderr, "ran out of memory insterting name (sorting)\n");
	    exit(SMS_NO_MEM);
	}
	ns = ns->next;
	if (copy)
	  ns->name = strsave(s);
	else
	  ns->name = s;
	ns->keep = nodups;
	ns->id = id;
	return;
    }
 foundns:
    if (nodups || ns->keep)
      return;
    ns->id = 0;
}


int hashstr(s)
register char *s;
{
    register int result;
    register int c;

    for (result = 0; c = *s; s++) {
	if (isupper(c))
	  c = *s = tolower(c);
/*	result = result * 31 + *s; */
	result = (result << 5) - result + c - '`';
    }
    return(result < 0 ? -result : result);
}


sort_info()
{
    names = create_hash(20001);
    hash_step(users, insert_login, NULL);
    hash_step(lists, save_mlist, FALSE);
    hash_step(users, insert_names, NULL);
    fprintf(stderr, "Inserted %d names\n", incount);
}


output_data(dummy, nms, out)
int dummy;
struct names *nms;
FILE *out;
{
    register struct names *ns;
    register struct user *u;
    int i;

    incount++;
    for (ns = nms; ns; ns = ns->next) {
	if (ns->name[0] == 0 || ns->name[1] == 0) {
	    fprintf(stderr, "punting %s due to short name\n", ns->name);
	    continue;
	}
	if (ns->id > 0) {
	    u = (struct user *) hash_lookup(users, ns->id);
	    if (u->pobox) {
		fprintf(out, "%s: %s\n", ns->name, u->pobox);
	    } else {
		fprintf(out, "%s: =%s=@nobox\n", ns->name, ns->name);
	    }
	} else if (ns->id == 0) {
	    fprintf(out, "%s: =%s=@ambig\n", ns->name, ns->name);
	}
    }
}


int lwid, bol, awid;

output_mlist(id, l, out)
int id;
register struct list *l;
FILE *out;
{
    struct list *l1;
    register struct member *m;
    register struct user *u;

    if (l->maillist != 2)
      return;
    if (l->acl_t ==  'L' &&
	(l1 = (struct list *) hash_lookup(lists, l->acl_id)))
      fprintf(out, "owner-%s: %s\n", l->name, l1->name);
    else if (l->acl_t ==  'U' &&
	     (u = (struct user *) hash_lookup(users, l->acl_id)))
      fprintf(out, "owner-%s: %s\n", l->name, u->login);

    fprintf(out, "%s: ", l->name);
    lwid = strlen(l->name) + 2;
    bol = 1;
    for (m = l->m; m; m = m->next) {
	do_member(out, m->name);
    }
    if (l->m == (struct member *)NULL)
      fprintf(out, "/dev/null");
    fprintf(out, "\n\n");
    incount++;
}


/* print out strings separated by commas, doing line breaks as appropriate */

do_member(out, s)
FILE *out;
register char *s;
{
    register wwid;
    static int cont = 1;

    wwid = strlen(s);

    if (!bol && awid + wwid + 2 > AL_MAX_WID) {
	fprintf(out, ",\n\tcontinuation-%d\ncontinuation-%d: ", cont, cont);
	cont++;
	awid = lwid = 17 + wwid;
	fputs(s, out);
	return;
    }

    if (bol) {
	lwid += wwid;
	awid = lwid;
	fputs(s, out);
	bol = 0;
	return;
    }
    if (lwid + wwid + 2 > ML_WID) {
	fprintf(out, ",\n\t%s", s);
	awid += lwid + wwid + 2;
	lwid = wwid + 8;
	return;
    }
    lwid += wwid + 2;
    fprintf(out, ", %s", s);
}


do_lists(out)
FILE *out;
{
    incount = 0;
    fprintf(out, "\n%s\n# Mailing lists\n%s\n", divide, divide);
    hash_step(lists, output_mlist, out);
    fprintf(stderr, "Output %d lists\n", incount);
}

do_people(out)
FILE *out;
{
    incount = 0;
    fprintf(out, "\n%s\n# People\n%s\n", divide, divide);
    hash_step(names, output_data, out);
    fprintf(stderr, "Output %d entries\n", incount);
}
Commit	Line	Data
8e7a00be	1
63812b62	2	/* $Header$
63812b62	3	*
8e7a00be	4	* This generates the /usr/lib/aliases file for the mailhub.
63812b62	5	*
	6	* (c) Copyright 1988 by the Massachusetts Institute of Technology.
	7	* For copying and distribution information, please see the file
	8	* <mit-copyright.h>.
	9	*/
	10
	11	#include <mit-copyright.h>
	12	#include <stdio.h>
	13	#include <string.h>
	14	#include <ctype.h>
	15	#include <sms.h>
	16	#include <sms_app.h>
	17	#include <sys/types.h>
	18	#include <sys/stat.h>
	19	#include <sys/time.h>
	20
8e7a00be	21
63812b62	22	extern int errno;
8e7a00be	23	char *whoami = "mailhub.gen";
63812b62	24	char *ingres_date_and_time();
8e7a00be	25	char *divide = "##############################################################";
	26
	27	#define ML_WID 72
	28	#define AL_MAX_WID 896
	29
	30	#define FALSE 0
	31	#define TRUE (!FALSE)
63812b62	32
	33
	34	main(argc, argv)
	35	int argc;
	36	char **argv;
	37	{
	38	long tm = time(NULL);
	39	FILE *out= stdout;
	40	char filename[64], *targetfile;
	41	struct stat sb;
	42	## int flag;
	43	## char *filetime;
	44	int ingerr();
	45
	46	IIseterr(ingerr);
	47	## ingres sms
	48	## set lockmode session where level = table
	49
	50	if (argc == 2) {
	51	if (stat(argv[1], &sb) == 0) {
	52	filetime = ingres_date_and_time(sb.st_mtime);
	53	## retrieve (flag = int4(interval("min",tblstats.modtime - filetime)))
	54	## where tblstats.table = "users"
	55	if (flag < 0) {
	56	fprintf(stderr, "File %s does not need to be rebuilt.\n",
	57	argv[1]);
	58	exit(SMS_NO_CHANGE);
	59	}
	60	}
	61	targetfile = argv[1];
	62	sprintf(filename, "%s~", targetfile);
	63	if ((out = fopen(filename, "w")) == NULL) {
	64	fprintf(stderr, "unable to open %s for output\n", filename);
	65	exit(SMS_OCONFIG);
	66	}
	67	} else if (argc != 1) {
	68	fprintf(stderr, "usage: %s [outfile]\n", argv[0]);
	69	exit(SMS_ARGS);
	70	}
	71
	72	fprintf(out, "%s\n# Aliases File Extract of %s", divide, ctime(&tm));
	73	fprintf(out, "# This file is automatically generated, do not edit it directly.\n%s\n\n", divide);
	74
	75	## begin transaction
	76	get_info();
	77	## end transaction
	78	## exit
	79
	80	fprintf(stderr, "Sorting Info\n");
	81	sort_info();
	82
	83	fprintf(stderr, "Dumping information\n");
8e7a00be	84	do_lists(out);
63812b62	85	do_people(out);
	86
	87	fprintf(out, "\n%s\n# End of aliases file\n", divide);
	88
	89	if (fclose(out)) {
	90	perror("close failed");
	91	exit(SMS_CCONFIG);
	92	}
	93
	94	if (argc == 2)
	95	fix_file(targetfile);
	96	exit(SMS_SUCCESS);
	97	}
	98
	99
	100	/*
	101	* ingerr: (supposedly) called when Ingres indicates an error.
	102	* I have not yet been able to get this to work to intercept a
	103	* database open error.
	104	*/
	105	#define INGRES_DEADLOCK 4700
	106
	107	static int ingerr(num)
	108	int *num;
	109	{
	110	char buf[256];
	111	int ingres_errno;
	112
	113	switch (*num) {
	114	case INGRES_DEADLOCK:
	115	ingres_errno = SMS_DEADLOCK;
	116	break;
	117	default:
	118	ingres_errno = SMS_INGRES_ERR;
	119	}
	120	com_err(whoami, SMS_INGRES_ERR, " code %d\n", *num);
	121	critical_alert("DCM", "Alias build encountered INGRES ERROR %d", *num);
	122	exit(ingres_errno);
	123	}
	124
8e7a00be	125	struct hash users, machines, strings, lists, *names;
63812b62	126	struct user {
63812b62	127	char *login;
63812b62	128	char *first;
	129	char *last;
	130	char mi;
63812b62	131	char *pobox;
63812b62	132	};
8e7a00be	133	struct member {
	134	struct member *next;
	135	char *name;
	136	int list_id;
	137	};
	138	struct list {
	139	char *name;
	140	char maillist;
	141	char acl_t;
	142	int acl_id;
	143	struct member *m;
	144	};
63812b62	145	struct names {
	146	char *name;
	147	struct names *next;
8e7a00be	148	int keep:1;
8e7a00be	149	int id:31;
63812b62	150	};
	151
	152
	153	get_info()
	154	##{
8e7a00be	155	## int id, pid, bid, stat, cnt, maillistp, acl, mid;
	156	## char name[129], type[9], fname[17], mname[17], lname[17], buf[257];
	157	char *s;
63812b62	158	register struct user *u;
8e7a00be	159	struct list l, memberlist;
8e7a00be	160	register struct member *m;
63812b62	161
	162	/* get locks */
	163	## retrieve (buf = users.modtime) where users.users_id = 0
8e7a00be	164	## retrieve (buf = list.modtime) where list.list_id = 0
63812b62	165
	166	cnt = 0;
	167	machines = create_hash(1000);
	168	## retrieve (id = machine.mach_id, name = machine.#name) {
	169	if (s = index(name, '.'))
	170	*s = 0;
	171	sprintf(buf, "%s.LOCAL", name);
8e7a00be	172	if (hash_store(machines, id, strsave(buf)) < 0) {
	173	fprintf(stderr, "Out of memory!\n");
	174	exit(SMS_NO_MEM);
	175	}
63812b62	176	cnt++;
	177	## }
	178	fprintf(stderr, "Loaded %d machines\n", cnt);
	179
	180	cnt = 0;
	181	strings = create_hash(2000);
	182	## retrieve (id = strings.string_id, name = strings.string) {
8e7a00be	183	if (hash_store(strings, id, strsave(strtrim(name))) < 0) {
	184	fprintf(stderr, "Out of memory!\n");
	185	exit(SMS_NO_MEM);
	186	}
63812b62	187	cnt++;
	188	## }
	189	fprintf(stderr, "Loaded %d strings\n", cnt);
	190
	191	cnt = 0;
8e7a00be	192	users = create_hash(12001);
63812b62	193	## range of u is users
8e7a00be	194	## retrieve (id = u.users_id, name = u.login, fname = u.first,
	195	## mname = u.middle, lname = u.last,
	196	## type = u.potype, pid = u.pop_id, bid = u.box_id)
	197	## where u.status != 3 {
63812b62	198	u = (struct user *) malloc(sizeof(struct user));
63812b62	199	u->login = strsave(strtrim(name));
	200	u->first = strsave(strtrim(fname));
	201	u->last = strsave(strtrim(lname));
	202	if (mname[0] != ' ')
	203	u->mi = mname[0];
	204	else
	205	u->mi = 0;
63812b62	206
8e7a00be	207	if (type[0] == 'P' && (s = hash_lookup(machines, pid))) {
	208	sprintf(buf, "%s@%s", strtrim(name), s);
	209	u->pobox = strsave(buf);
	210	} else if (type[0] == 'S') {
	211	u->pobox = hash_lookup(strings, bid);
63812b62	212	} else
8e7a00be	213	u->pobox = (char *) NULL;
	214	if (hash_store(users, id, u) < 0) {
	215	fprintf(stderr, "Out of memory!\n");
	216	exit(SMS_NO_MEM);
63812b62	217	}
63812b62	218	cnt++;
	219	## }
	220	fprintf(stderr, "Loaded %d users\n", cnt);
8e7a00be	221
	222	cnt = 0;
	223	lists = create_hash(15000);
	224	## range of l is list
	225	## retrieve (id = l.list_id, name = l.#name, maillistp = l.maillist,
	226	## type = l.acl_type, acl = l.acl_id)
	227	## where l.active != 0 {
	228	l = (struct list *) malloc(sizeof(struct list));
	229	l->name = strsave(strtrim(name));
	230	l->maillist = maillistp;
	231	l->acl_t = type[0];
	232	l->acl_id = acl;
	233	l->m = (struct member *) NULL;
	234	if (hash_store(lists, id, l) < 0) {
	235	fprintf(stderr, "Out of memory!\n");
	236	exit(SMS_NO_MEM);
	237	}
	238	cnt++;
	239	## }
	240	fprintf(stderr, "Loaded %d lists\n", cnt);
	241
	242	cnt = 0;
	243	## range of m is imembers
	244	## retrieve (id = m.list_id, type = m.member_type, mid = m.member_id)
	245	## where m.direct = 1 {
	246	cnt++;
	247	if (l = (struct list *) hash_lookup(lists, id)) {
	248	m = (struct member *) malloc(sizeof(struct member));
	249	if (type[0] == 'U' &&
	250	(u = (struct user *) hash_lookup(users, mid))) {
	251	m->list_id = 0;
	252	m->name = u->login;
	253	m->next = l->m;
	254	l->m = m;
	255	} else if (type[0] == 'L' &&
	256	(memberlist = (struct list *) hash_lookup(lists, mid))) {
	257	m->list_id = mid;
	258	m->name = memberlist->name;
	259	m->next = l->m;
	260	l->m = m;
	261	} else if (type[0] == 'S' &&
	262	(s = hash_lookup(strings, mid))) {
	263	m->list_id = 0;
	264	m->next = l->m;
	265	l->m = m;
	266	m->name = s;
	267	}
	268	}
	269	## }
	270	fprintf(stderr, "Loaded %d members\n", cnt);
63812b62	271	##}
	272
	273
8e7a00be	274	save_mlist(id, l, force)
	275	int id;
	276	struct list *l;
	277	int force;
63812b62	278	{
8e7a00be	279	register struct member *m;
	280	register struct list *l1;
	281
	282	if (l->maillist == 2 \|\|
	283	l->maillist == 3 \|\|
	284	(l->maillist == 0 && !force))
	285	return;
	286
	287	if (l->m && l->m->next == NULL &&
	288	!strcasecmp(l->name, l->m->name)) {
	289	l->maillist = 3;
	290	return;
63812b62	291	}
8e7a00be	292	l->maillist = 2;
	293	insert_name(l->name, -id, TRUE, FALSE);
	294
	295	if (l->acl_t == 'L' && (l1 = (struct list *)hash_lookup(lists, l->acl_id)))
	296	save_mlist(0, l1, TRUE);
	297
	298	for (m = l->m; m; m = m->next) {
	299	if (m->list_id && (l1 = (struct list *)hash_lookup(lists, m->list_id)))
	300	save_mlist(0, l1, TRUE);
63812b62	301	}
63812b62	302	}
	303
	304
8e7a00be	305	insert_login(id, u, dummy)
	306	int id;
	307	struct user *u;
	308	int dummy;
	309	{
	310	if (u->pobox && u->login[0] != '#')
	311	insert_name(u->login, id, TRUE, FALSE);
	312	}
	313
63812b62	314	void insert_names(id, u, dummy)
	315	int id;
	316	struct user *u;
	317	int dummy;
	318	{
	319	char buffer[256];
	320
8e7a00be	321	insert_name(u->last, id, FALSE, FALSE);
63812b62	322	sprintf(buffer, "%s_%s", u->first, u->last);
8e7a00be	323	insert_name(buffer, id, FALSE, TRUE);
	324	sprintf(buffer, "%c_%s", u->first[0], u->last);
	325	insert_name(buffer, id, FALSE, TRUE);
63812b62	326	if (u->mi) {
63812b62	327	sprintf(buffer, "%s_%c_%s", u->first, u->mi, u->last);
8e7a00be	328	insert_name(buffer, id, FALSE, TRUE);
63812b62	329	}
	330	}
	331
	332	int incount = 0;
	333
8e7a00be	334	insert_name(s, id, nodups, copy)
63812b62	335	char *s;
63812b62	336	int id;
8e7a00be	337	int nodups;
8e7a00be	338	int copy;
63812b62	339	{
	340	int code;
	341	register struct names *ns;
	342	register int count;
	343	register struct idblock *ra;
	344
	345	incount++;
	346	code = hashstr(s);
	347	ns = (struct names *) hash_lookup(names, code);
	348	if (ns == NULL) {
	349	if ((ns = (struct names *) malloc(sizeof(struct names))) == NULL) {
	350	fprintf(stderr, "ran out of memory inserting name (sorting)\n");
8e7a00be	351	exit(SMS_NO_MEM);
	352	}
	353	if (copy)
	354	ns->name = strsave(s);
	355	else
	356	ns->name = s;
	357	ns->keep = nodups;
	358	ns->id = id;
	359	if (hash_store(names, code, ns) < 0) {
	360	fprintf(stderr, "Out of memory!\n");
	361	exit(SMS_NO_MEM);
63812b62	362	}
63812b62	363	return;
	364	}
	365	if (strcasecmp(ns->name, s)) {
	366	while (ns->next) {
	367	ns = ns->next;
	368	if (!strcasecmp(ns->name, s))
	369	goto foundns;
	370	}
	371	if ((ns->next = (struct names *)malloc(sizeof(struct names))) == NULL) {
	372	fprintf(stderr, "ran out of memory insterting name (sorting)\n");
8e7a00be	373	exit(SMS_NO_MEM);
63812b62	374	}
63812b62	375	ns = ns->next;
8e7a00be	376	if (copy)
	377	ns->name = strsave(s);
	378	else
	379	ns->name = s;
	380	ns->keep = nodups;
	381	ns->id = id;
63812b62	382	return;
	383	}
	384	foundns:
8e7a00be	385	if (nodups \|\| ns->keep)
	386	return;
	387	ns->id = 0;
63812b62	388	}
	389
	390
	391	int hashstr(s)
	392	register char *s;
	393	{
	394	register int result;
	395	register int c;
	396
8e7a00be	397	for (result = 0; c = *s; s++) {
	398	if (isupper(c))
	399	c = *s = tolower(c);
63812b62	400	/* result = result * 31 + s; /
8e7a00be	401	result = (result << 5) - result + c - '`';
63812b62	402	}
	403	return(result < 0 ? -result : result);
	404	}
	405
	406
	407	sort_info()
	408	{
8e7a00be	409	names = create_hash(20001);
	410	hash_step(users, insert_login, NULL);
	411	hash_step(lists, save_mlist, FALSE);
63812b62	412	hash_step(users, insert_names, NULL);
	413	fprintf(stderr, "Inserted %d names\n", incount);
	414	}
	415
	416
63812b62	417	output_data(dummy, nms, out)
	418	int dummy;
	419	struct names *nms;
	420	FILE *out;
	421	{
	422	register struct names *ns;
	423	register struct user *u;
	424	int i;
	425
	426	incount++;
	427	for (ns = nms; ns; ns = ns->next) {
8e7a00be	428	if (ns->name[0] == 0 \|\| ns->name[1] == 0) {
	429	fprintf(stderr, "punting %s due to short name\n", ns->name);
	430	continue;
	431	}
	432	if (ns->id > 0) {
	433	u = (struct user *) hash_lookup(users, ns->id);
63812b62	434	if (u->pobox) {
63812b62	435	fprintf(out, "%s: %s\n", ns->name, u->pobox);
8e7a00be	436	} else {
8e7a00be	437	fprintf(out, "%s: =%s=@nobox\n", ns->name, ns->name);
63812b62	438	}
8e7a00be	439	} else if (ns->id == 0) {
8e7a00be	440	fprintf(out, "%s: =%s=@ambig\n", ns->name, ns->name);
63812b62	441	}
	442	}
	443	}
	444
	445
8e7a00be	446	int lwid, bol, awid;
	447
	448	output_mlist(id, l, out)
	449	int id;
	450	register struct list *l;
	451	FILE *out;
	452	{
	453	struct list *l1;
	454	register struct member *m;
	455	register struct user *u;
	456
	457	if (l->maillist != 2)
	458	return;
	459	if (l->acl_t == 'L' &&
	460	(l1 = (struct list *) hash_lookup(lists, l->acl_id)))
	461	fprintf(out, "owner-%s: %s\n", l->name, l1->name);
	462	else if (l->acl_t == 'U' &&
	463	(u = (struct user *) hash_lookup(users, l->acl_id)))
	464	fprintf(out, "owner-%s: %s\n", l->name, u->login);
	465
	466	fprintf(out, "%s: ", l->name);
	467	lwid = strlen(l->name) + 2;
	468	bol = 1;
	469	for (m = l->m; m; m = m->next) {
	470	do_member(out, m->name);
	471	}
	472	if (l->m == (struct member *)NULL)
	473	fprintf(out, "/dev/null");
	474	fprintf(out, "\n\n");
	475	incount++;
	476	}
	477
	478
	479	/* print out strings separated by commas, doing line breaks as appropriate */
	480
	481	do_member(out, s)
	482	FILE *out;
	483	register char *s;
	484	{
	485	register wwid;
	486	static int cont = 1;
	487
	488	wwid = strlen(s);
	489
	490	if (!bol && awid + wwid + 2 > AL_MAX_WID) {
	491	fprintf(out, ",\n\tcontinuation-%d\ncontinuation-%d: ", cont, cont);
	492	cont++;
	493	awid = lwid = 17 + wwid;
	494	fputs(s, out);
	495	return;
	496	}
	497
	498	if (bol) {
	499	lwid += wwid;
	500	awid = lwid;
	501	fputs(s, out);
	502	bol = 0;
	503	return;
	504	}
	505	if (lwid + wwid + 2 > ML_WID) {
	506	fprintf(out, ",\n\t%s", s);
	507	awid += lwid + wwid + 2;
	508	lwid = wwid + 8;
	509	return;
510	}
511	lwid += wwid + 2;
512	fprintf(out, ", %s", s);
513	}
514
515
516	do_lists(out)
63812b62	517	FILE *out;
	518	{
	519	incount = 0;
8e7a00be	520	fprintf(out, "\n%s\n# Mailing lists\n%s\n", divide, divide);
	521	hash_step(lists, output_mlist, out);
	522	fprintf(stderr, "Output %d lists\n", incount);
	523	}
63812b62	524
8e7a00be	525	do_people(out)
	526	FILE *out;
	527	{
	528	incount = 0;
	529	fprintf(out, "\n%s\n# People\n%s\n", divide, divide);
63812b62	530	hash_step(names, output_data, out);
63812b62	531	fprintf(stderr, "Output %d entries\n", incount);
63812b62	532	}