[moira.git] / gen / aliases.dc

/* $Header$
 *
 * This generates the /usr/lib/aliases mail aliases file for the mailhub.
 * The aliases file will contain:
 *	user pobox entries
 *	maillist expansions
 *	sublists of maillists
 *
 *  (c) Copyright 1988, 1990 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 <moira.h>
#include <moira_site.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
EXEC SQL INCLUDE sqlca;


#define ML_WID	72
#define AL_MAX_WID 592

char *divide = "########################################################################";
extern int errno;
char *whoami = "aliases.gen";
FILE *out;

main(argc, argv)
int argc;
char **argv;
{
    long tm = time(NULL);
    char filename[64], *targetfile;
    struct stat sb;
    int flag1, flag2, flag3;

    out = stdout;
    initialize_sms_error_table();
#ifsql INGRES
    EXEC SQL CONNECT moira;
    EXEC SQL SET LOCKMODE SESSION WHERE LEVEL=TABLE, READLOCK=SHARED;
#endsql
#ifsql INFORMIX
    EXEC SQL DATABASE moira;
#endsql


    if (argc == 2) {
	if (stat(argv[1], &sb) == 0) {

	  if (ModDiff (&flag1, "list", sb.st_mtime) ||
	      ModDiff (&flag2, "imembers", sb.st_mtime) ||
	      ModDiff (&flag3, "users", sb.st_mtime)) exit (MR_DATE);

	  if (flag1 < 0 && flag2 < 0 && flag3 < 0) {
	    fprintf(stderr, "File %s does not need to be rebuilt.\n",
		    argv[1]);
	    exit(MR_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(MR_OCONFIG);
	}
    } else if (argc != 1) {
	fprintf(stderr, "usage: %s [outfile]\n", argv[0]);
	exit(MR_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);

    get_info();
#ifsql INFORMIX
    EXEC SQL COMMIT WORK;
#endif
#ifsql INGRES
    EXEC SQL DISCONNECT;
#endsql

    fprintf(stderr, "Dumping information\n");
    do_mlists(out);
    do_poboxes(out);

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


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

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


struct hash *users, *machines, *strings, *lists;
struct user {
    char login[9];
    char *pobox;
};
struct member {
    struct member *next;
    char *name;
    int list_id;
};
struct list {
    char *name;
    char maillist;
    char acl_t;
    char *description;
    int acl_id;
    struct member *m;
};


get_info()
{
    EXEC SQL BEGIN DECLARE SECTION;
    int id, maillistp, acl, pid, bid, mid;
    char name[129], type[9], buf[257];
    EXEC SQL END DECLARE SECTION;
    char *s;
    register struct user *u;
    register struct list *l;
    register struct member *m;
    register struct list *memberlist;

    EXEC SQL WHENEVER SQLERROR GOTO sqlerr;

    /* get locks */
    EXEC SQL SELECT modtime INTO :buf FROM imembers WHERE list_id = 0;
    EXEC SQL SELECT modtime INTO :buf FROM users WHERE USERS_ID = 0;
    EXEC SQL SELECT modtime INTO :buf FROM machine WHERE mach_id = 0;
    EXEC SQL SELECT modtime INTO :buf FROM list WHERE LIST_ID = 0;

    fprintf(stderr, "Loading machines\n");
    machines = create_hash(1000);

    EXEC SQL DECLARE m_cursor CURSOR FOR 
      SELECT mach_id, name 
      FROM machine WHERE mach_id != 0
      ORDER BY mach_id;
    EXEC SQL OPEN m_cursor;
    while (1) {
      EXEC SQL FETCH m_cursor INTO :id, :name;
      if (sqlca.sqlcode != 0) break;
      if (s = index(name, '.'))
	*s = 0;
#ifdef ATHENA
      strcat(name, ".LOCAL");
#endif
      hash_store(machines, id, strsave(name));
    }
    EXEC SQL CLOSE m_cursor;


    fprintf(stderr, "Loading strings\n");
    strings = create_hash(11001);

    EXEC SQL DECLARE s_cursor CURSOR FOR 
      SELECT string_id, trim(string) 
      FROM strings
      ORDER BY string_id;
    EXEC SQL OPEN s_cursor;
    while (1) {
      EXEC SQL FETCH s_cursor INTO :id, :name;
      if (sqlca.sqlcode != 0) break;
      hash_store(strings, id, strsave(name));
    }
    EXEC SQL CLOSE s_cursor;

    fprintf(stderr, "Loading users\n");
    users = create_hash(12001);

    EXEC SQL DECLARE u_cursor CURSOR FOR
      SELECT users_id, login, potype, pop_id, box_id
      FROM users WHERE status = 1 OR status = 5 OR status = 6
      ORDER BY users_id;
    EXEC SQL OPEN u_cursor;
    while (1) {
        EXEC SQL FETCH u_cursor INTO :id, :name, :type, :pid, :bid;
	if (sqlca.sqlcode != 0) break;
	u = (struct user *) malloc(sizeof(struct user));
	strcpy(u->login, strtrim(name));
	if (type[0] == 'P') {
	    if (s = hash_lookup(machines, pid)) {
		sprintf(buf, "%s@%s", name, s);
		u->pobox = strsave(buf);
	    } else {
		u->pobox = (char *) NULL;
		fprintf(stderr, "User %s's pobox is on a missing machine!\n",
			u->login);
	    }
	} else if (type[0] ==  'S') {
	    if ((u->pobox = hash_lookup(strings, bid)) == NULL) {
		u->pobox = (char *) NULL;
		fprintf(stderr, "User %s's pobox string is missing!\n",
			u->login);
	    }
	} else
	  u->pobox = (char *) NULL;
	hash_store(users, id, u);
     }
    EXEC SQL CLOSE u_cursor;
    EXEC SQL COMMIT;

    fprintf(stderr, "Loading lists\n");
    lists = create_hash(15001);

    EXEC SQL DECLARE l_cursor CURSOR FOR
      SELECT list_id, name, maillist, description, acl_type, acl_id
      FROM list WHERE active != 0 AND list_id != 0
      ORDER BY list_id;
    EXEC SQL OPEN l_cursor;
    while (1) {
        EXEC SQL FETCH l_cursor INTO :id, :name, :maillistp,
	                             :buf, :type, :acl;
	if (sqlca.sqlcode != 0) break;
	l = (struct list *) malloc(sizeof(struct list));
	l->name = strsave(strtrim(name));
	l->maillist = maillistp;
	l->description = strsave(strtrim(buf));
	l->acl_t = type[0];
	l->acl_id = acl;
	l->m = (struct member *) NULL;
	hash_store(lists, id, l);
      }
    EXEC SQL CLOSE l_cursor;
    EXEC SQL COMMIT;

    fprintf(stderr, "Loading members\n");

    EXEC SQL DECLARE mem_cursor CURSOR FOR
      SELECT list_id, member_type, member_id
      FROM imembers WHERE direct = 1
      ORDER BY list_id;
    EXEC SQL OPEN mem_cursor;
    while (1) {
        EXEC SQL FETCH mem_cursor INTO :id, :type, :mid;
	if (sqlca.sqlcode != 0) break;
        if (id == 0)
            continue;
	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->name = s;
		m->next = l->m;
		l->m = m;
	    }
	}
    }
    EXEC SQL CLOSE mem_cursor;
    return;
 sqlerr:
    com_err(whoami, MR_INGRES_ERR, " code %d\n", sqlca.sqlcode);
    critical_alert("DCM", "Alias build encountered INGRES ERROR %d",
		   sqlca.sqlcode);
    exit(MR_INGRES_ERR);
}


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

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

    if (l->m && l->m->next == NULL &&
	!strcasecmp(l->name, l->m->name)) {
	l->maillist = 0;
	return;
    }
    l->maillist = 2;
    output_mlist(id, l);

    if (l->acl_t == 'L' && (l1 = (struct list *)hash_lookup(lists, l->acl_id)))
      save_mlist(0, l1, 1);
    
    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, 1);
    }
}


int lwid, bol, awid;

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

    put_fill(out, l->description);
    if (l->acl_t ==  'L') {
	if (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') {
	if (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");
}


/* Extract mailing lists.  Make a list of all mailinglists, then
 * process them, adding any sub-lists or acl lists to the list of lists
 * to be processed.  If further sublists are encountered, repeat...
 */

do_mlists(out)
FILE *out;
{
    fprintf(out, "\n%s\n# Mailing lists\n%s\n", divide, divide);
    hash_step(lists, save_mlist, 0);
}


/* 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_pobox(id, u, out)
int id;
register struct user *u;
FILE *out;
{
    if (u->pobox)
      fprintf(out, "%s: %s\n", u->login, u->pobox);
}


/* Do user poboxes.  Just step through the users table, and print any
 * we extracted earlier.
 */

do_poboxes(out)
FILE *out;
{
    fprintf(out, "\n%s\n# User Poboxes\n%s\n", divide, divide);

    hash_step(users, do_pobox, out);
}


put_fill(aliases, string)
FILE *aliases;
register char *string;
{
    register char *c;
    register int lwid;
    register int wwid;

    if (*string == 0) return;
    fputs("#  ", aliases);
    lwid = 3;

    while (1) {
	while (*string && *string == ' ') string++;
	c = (char *)index(string, ' ');
	if (c == 0) {
	    wwid = strlen(string);
	} else {
	    wwid = c - string;
	    *c = 0;
	}

	if ((lwid + wwid) > ML_WID) {
	    fputs("\n#  ", aliases);
	    lwid = 3;
	    fputs(string, aliases);
	} else {
	    fputs(string, aliases);
	}

	if (c == (char *)0) break;
	/* add a space after the word */
	(void) fputc(' ', aliases);
	wwid++;
	lwid += wwid;
	string += wwid;
	/* add another if after a period */
	if (*--c == '.') {
	    (void) fputc(' ', aliases);
	    lwid++;
	}
    }

    (void) fputc('\n', aliases);
}
Commit	Line	Data
5d5f5413	1	/* $Header$
	2	*
	3	* This generates the /usr/lib/aliases mail aliases file for the mailhub.
	4	* The aliases file will contain:
	5	* user pobox entries
	6	* maillist expansions
	7	* sublists of maillists
	8	*
	9	* (c) Copyright 1988, 1990 by the Massachusetts Institute of Technology.
	10	* For copying and distribution information, please see the file
	11	* <mit-copyright.h>.
	12	*/
	13
	14
	15	#include <mit-copyright.h>
	16	#include <stdio.h>
	17	#include <string.h>
	18	#include <moira.h>
	19	#include <moira_site.h>
	20	#include <sys/types.h>
	21	#include <sys/stat.h>
	22	#include <sys/time.h>
	23	EXEC SQL INCLUDE sqlca;
	24
	25
	26	#define ML_WID 72
f1567ffb	27	#define AL_MAX_WID 592
5d5f5413	28
	29	char *divide = "########################################################################";
	30	extern int errno;
	31	char *whoami = "aliases.gen";
5d5f5413	32	FILE *out;
	33
	34	main(argc, argv)
	35	int argc;
	36	char **argv;
	37	{
	38	long tm = time(NULL);
	39	char filename[64], *targetfile;
	40	struct stat sb;
	41	int flag1, flag2, flag3;
	42
	43	out = stdout;
	44	initialize_sms_error_table();
	45	#ifsql INGRES
bcdea6a2	46	EXEC SQL CONNECT moira;
22bc6c27	47	EXEC SQL SET LOCKMODE SESSION WHERE LEVEL=TABLE, READLOCK=SHARED;
5d5f5413	48	#endsql
5d5f5413	49	#ifsql INFORMIX
bcdea6a2	50	EXEC SQL DATABASE moira;
5d5f5413	51	#endsql
	52
	53
	54	if (argc == 2) {
	55	if (stat(argv[1], &sb) == 0) {
	56
	57	if (ModDiff (&flag1, "list", sb.st_mtime) \|\|
	58	ModDiff (&flag2, "imembers", sb.st_mtime) \|\|
	59	ModDiff (&flag3, "users", sb.st_mtime)) exit (MR_DATE);
	60
	61	if (flag1 < 0 && flag2 < 0 && flag3 < 0) {
	62	fprintf(stderr, "File %s does not need to be rebuilt.\n",
	63	argv[1]);
	64	exit(MR_NO_CHANGE);
	65	}
	66	}
	67	targetfile = argv[1];
	68	sprintf(filename, "%s~", targetfile);
	69	if ((out = fopen(filename, "w")) == NULL) {
	70	fprintf(stderr, "unable to open %s for output\n", filename);
	71	exit(MR_OCONFIG);
	72	}
	73	} else if (argc != 1) {
	74	fprintf(stderr, "usage: %s [outfile]\n", argv[0]);
	75	exit(MR_ARGS);
	76	}
	77
	78	fprintf(out, "%s\n# Aliases File Extract of %s", divide, ctime(&tm));
	79	fprintf(out, "# This file is automatically generated, do not edit it directly.\n%s\n\n", divide);
	80
	81	get_info();
	82	#ifsql INFORMIX
	83	EXEC SQL COMMIT WORK;
	84	#endif
	85	#ifsql INGRES
	86	EXEC SQL DISCONNECT;
	87	#endsql
	88
	89	fprintf(stderr, "Dumping information\n");
	90	do_mlists(out);
	91	do_poboxes(out);
	92
	93	fprintf(out, "\n%s\n# End of aliases file\n%s\n", divide, divide);
	94
	95
	96	if (fclose(out)) {
	97	perror("close failed");
	98	exit(MR_CCONFIG);
	99	}
	100
	101	if (argc == 2)
	102	fix_file(targetfile);
	103	exit(MR_SUCCESS);
	104	}
	105
	106
	107	struct hash users, machines, strings, lists;
	108	struct user {
	109	char login[9];
	110	char *pobox;
	111	};
	112	struct member {
	113	struct member *next;
	114	char *name;
115	int list_id;
116	};
117	struct list {
118	char *name;
119	char maillist;
120	char acl_t;
121	char *description;
122	int acl_id;
123	struct member *m;
124	};
125
126
127	get_info()
128	{
129	EXEC SQL BEGIN DECLARE SECTION;
130	int id, maillistp, acl, pid, bid, mid;
131	char name[129], type[9], buf[257];
132	EXEC SQL END DECLARE SECTION;
133	char *s;
134	register struct user *u;
135	register struct list *l;
136	register struct member *m;
137	register struct list *memberlist;
138
139	EXEC SQL WHENEVER SQLERROR GOTO sqlerr;
140
141	/* get locks */
741abed8	142	EXEC SQL SELECT modtime INTO :buf FROM imembers WHERE list_id = 0;
bcdea6a2	143	EXEC SQL SELECT modtime INTO :buf FROM users WHERE USERS_ID = 0;
741abed8	144	EXEC SQL SELECT modtime INTO :buf FROM machine WHERE mach_id = 0;
741abed8	145	EXEC SQL SELECT modtime INTO :buf FROM list WHERE LIST_ID = 0;
5d5f5413	146
5d5f5413	147	fprintf(stderr, "Loading machines\n");
3ba8b540	148	machines = create_hash(1000);
5d5f5413	149
	150	EXEC SQL DECLARE m_cursor CURSOR FOR
	151	SELECT mach_id, name
741abed8	152	FROM machine WHERE mach_id != 0
22bc6c27	153	ORDER BY mach_id;
5d5f5413	154	EXEC SQL OPEN m_cursor;
	155	while (1) {
	156	EXEC SQL FETCH m_cursor INTO :id, :name;
	157	if (sqlca.sqlcode != 0) break;
	158	if (s = index(name, '.'))
	159	*s = 0;
	160	#ifdef ATHENA
	161	strcat(name, ".LOCAL");
	162	#endif
	163	hash_store(machines, id, strsave(name));
	164	}
	165	EXEC SQL CLOSE m_cursor;
	166
	167
	168	fprintf(stderr, "Loading strings\n");
22bc6c27	169	strings = create_hash(11001);
5d5f5413	170
5d5f5413	171	EXEC SQL DECLARE s_cursor CURSOR FOR
22bc6c27	172	SELECT string_id, trim(string)
	173	FROM strings
	174	ORDER BY string_id;
5d5f5413	175	EXEC SQL OPEN s_cursor;
	176	while (1) {
	177	EXEC SQL FETCH s_cursor INTO :id, :name;
	178	if (sqlca.sqlcode != 0) break;
22bc6c27	179	hash_store(strings, id, strsave(name));
5d5f5413	180	}
	181	EXEC SQL CLOSE s_cursor;
	182
	183	fprintf(stderr, "Loading users\n");
	184	users = create_hash(12001);
	185
	186	EXEC SQL DECLARE u_cursor CURSOR FOR
	187	SELECT users_id, login, potype, pop_id, box_id
22bc6c27	188	FROM users WHERE status = 1 OR status = 5 OR status = 6
22bc6c27	189	ORDER BY users_id;
5d5f5413	190	EXEC SQL OPEN u_cursor;
	191	while (1) {
	192	EXEC SQL FETCH u_cursor INTO :id, :name, :type, :pid, :bid;
	193	if (sqlca.sqlcode != 0) break;
	194	u = (struct user *) malloc(sizeof(struct user));
	195	strcpy(u->login, strtrim(name));
	196	if (type[0] == 'P') {
	197	if (s = hash_lookup(machines, pid)) {
	198	sprintf(buf, "%s@%s", name, s);
	199	u->pobox = strsave(buf);
	200	} else {
	201	u->pobox = (char *) NULL;
	202	fprintf(stderr, "User %s's pobox is on a missing machine!\n",
	203	u->login);
	204	}
	205	} else if (type[0] == 'S') {
	206	if ((u->pobox = hash_lookup(strings, bid)) == NULL) {
	207	u->pobox = (char *) NULL;
	208	fprintf(stderr, "User %s's pobox string is missing!\n",
	209	u->login);
	210	}
	211	} else
	212	u->pobox = (char *) NULL;
	213	hash_store(users, id, u);
	214	}
	215	EXEC SQL CLOSE u_cursor;
22bc6c27	216	EXEC SQL COMMIT;
5d5f5413	217
	218	fprintf(stderr, "Loading lists\n");
	219	lists = create_hash(15001);
	220
	221	EXEC SQL DECLARE l_cursor CURSOR FOR
bcdea6a2	222	SELECT list_id, name, maillist, description, acl_type, acl_id
741abed8	223	FROM list WHERE active != 0 AND list_id != 0
22bc6c27	224	ORDER BY list_id;
5d5f5413	225	EXEC SQL OPEN l_cursor;
	226	while (1) {
	227	EXEC SQL FETCH l_cursor INTO :id, :name, :maillistp,
	228	:buf, :type, :acl;
	229	if (sqlca.sqlcode != 0) break;
	230	l = (struct list *) malloc(sizeof(struct list));
	231	l->name = strsave(strtrim(name));
	232	l->maillist = maillistp;
	233	l->description = strsave(strtrim(buf));
	234	l->acl_t = type[0];
	235	l->acl_id = acl;
	236	l->m = (struct member *) NULL;
	237	hash_store(lists, id, l);
	238	}
	239	EXEC SQL CLOSE l_cursor;
22bc6c27	240	EXEC SQL COMMIT;
5d5f5413	241
	242	fprintf(stderr, "Loading members\n");
	243
	244	EXEC SQL DECLARE mem_cursor CURSOR FOR
	245	SELECT list_id, member_type, member_id
22bc6c27	246	FROM imembers WHERE direct = 1
22bc6c27	247	ORDER BY list_id;
5d5f5413	248	EXEC SQL OPEN mem_cursor;
	249	while (1) {
	250	EXEC SQL FETCH mem_cursor INTO :id, :type, :mid;
	251	if (sqlca.sqlcode != 0) break;
741abed8	252	if (id == 0)
741abed8	253	continue;
5d5f5413	254	if (l = (struct list *) hash_lookup(lists, id)) {
	255	m = (struct member *) malloc(sizeof(struct member));
	256	if (type[0] == 'U' &&
	257	(u = (struct user *) hash_lookup(users, mid))) {
	258	m->list_id = 0;
	259	m->name = u->login;
	260	m->next = l->m;
	261	l->m = m;
	262	} else if (type[0] == 'L' &&
	263	(memberlist = (struct list *) hash_lookup(lists, mid))) {
	264	m->list_id = mid;
	265	m->name = memberlist->name;
	266	m->next = l->m;
	267	l->m = m;
	268	} else if (type[0] == 'S' &&
	269	(s = hash_lookup(strings, mid))) {
	270	m->list_id = 0;
	271	m->name = s;
	272	m->next = l->m;
	273	l->m = m;
	274	}
	275	}
	276	}
	277	EXEC SQL CLOSE mem_cursor;
	278	return;
	279	sqlerr:
	280	com_err(whoami, MR_INGRES_ERR, " code %d\n", sqlca.sqlcode);
	281	critical_alert("DCM", "Alias build encountered INGRES ERROR %d",
	282	sqlca.sqlcode);
	283	exit(MR_INGRES_ERR);
	284	}
	285
	286
	287	save_mlist(id, l, force)
	288	int id;
	289	register struct list *l;
	290	int force;
	291	{
	292	register struct member *m;
	293	struct list *l1;
	294
	295	if (l->maillist == 2 \|\|
	296	(l->maillist == 0 && !force))
	297	return;
	298
	299	if (l->m && l->m->next == NULL &&
	300	!strcasecmp(l->name, l->m->name)) {
	301	l->maillist = 0;
	302	return;
	303	}
	304	l->maillist = 2;
	305	output_mlist(id, l);
	306
	307	if (l->acl_t == 'L' && (l1 = (struct list *)hash_lookup(lists, l->acl_id)))
	308	save_mlist(0, l1, 1);
	309
	310	for (m = l->m; m; m = m->next) {
	311	if (m->list_id && (l1 = (struct list *)hash_lookup(lists, m->list_id)))
	312	save_mlist(0, l1, 1);
	313	}
	314	}
	315
	316
	317	int lwid, bol, awid;
318
319	output_mlist(id, l)
320	int id;
321	register struct list *l;
322	{
323	struct list *l1;
324	register struct member *m;
325	struct user *u;
326
327	put_fill(out, l->description);
328	if (l->acl_t == 'L') {
329	if (l1 = (struct list *) hash_lookup(lists, l->acl_id))
330	fprintf(out, "owner-%s: %s\n", l->name, l1->name);
331	} else if (l->acl_t == 'U') {
332	if (u = (struct user *) hash_lookup(users, l->acl_id))
333	fprintf(out, "owner-%s: %s\n", l->name, u->login);
334	}
335
336	fprintf(out, "%s: ", l->name);
337	lwid = strlen(l->name) + 2;
338	bol = 1;
339	for (m = l->m; m; m = m->next)
340	do_member(out, m->name);
341	if (l->m == (struct member *)NULL)
342	fprintf(out, "/dev/null");
343	fprintf(out, "\n\n");
344	}
345
346
347	/* Extract mailing lists. Make a list of all mailinglists, then
348	* process them, adding any sub-lists or acl lists to the list of lists
349	* to be processed. If further sublists are encountered, repeat...
350	*/
351
352	do_mlists(out)
353	FILE *out;
354	{
355	fprintf(out, "\n%s\n# Mailing lists\n%s\n", divide, divide);
356	hash_step(lists, save_mlist, 0);
357	}
358
359
360	/* print out strings separated by commas, doing line breaks as appropriate */
361
362	do_member(out, s)
363	FILE *out;
364	register char *s;
365	{
366	register wwid;
367	static int cont = 1;
368
369	wwid = strlen(s);
370
371	if (!bol && awid + wwid + 2 > AL_MAX_WID) {
372	fprintf(out, ",\n\tcontinuation-%d\ncontinuation-%d: ", cont, cont);
373	cont++;
374	awid = lwid = 17 + wwid;
375	fputs(s, out);
376	return;
377	}
378
379	if (bol) {
380	lwid += wwid;
381	awid = lwid;
382	fputs(s, out);
383	bol = 0;
384	return;
385	}
386	if (lwid + wwid + 2 > ML_WID) {
387	fprintf(out, ",\n\t%s", s);
388	awid += lwid + wwid + 2;
389	lwid = wwid + 8;
390	return;
391	}
392	lwid += wwid + 2;
393	fprintf(out, ", %s", s);
394	}
395
396	do_pobox(id, u, out)
397	int id;
398	register struct user *u;
399	FILE *out;
400	{
401	if (u->pobox)
402	fprintf(out, "%s: %s\n", u->login, u->pobox);
403	}
404
405
406	/* Do user poboxes. Just step through the users table, and print any
407	* we extracted earlier.
408	*/
409
410	do_poboxes(out)
411	FILE *out;
412	{
413	fprintf(out, "\n%s\n# User Poboxes\n%s\n", divide, divide);
414
415	hash_step(users, do_pobox, out);
416	}
417
418
419	put_fill(aliases, string)
420	FILE *aliases;
421	register char *string;
422	{
423	register char *c;
424	register int lwid;
425	register int wwid;
426
427	if (*string == 0) return;
428	fputs("# ", aliases);
429	lwid = 3;
430
431	while (1) {
432	while (string && string == ' ') string++;
433	c = (char *)index(string, ' ');
434	if (c == 0) {
435	wwid = strlen(string);
436	} else {
437	wwid = c - string;
438	*c = 0;
439	}
440
441	if ((lwid + wwid) > ML_WID) {
442	fputs("\n# ", aliases);
443	lwid = 3;
444	fputs(string, aliases);
445	} else {
446	fputs(string, aliases);
447	}
448
449	if (c == (char *)0) break;
450	/* add a space after the word */
451	(void) fputc(' ', aliases);
452	wwid++;
453	lwid += wwid;
454	string += wwid;
455	/* add another if after a period */
456	if (*--c == '.') {
457	(void) fputc(' ', aliases);
458	lwid++;
459	}
460	}
461
462	(void) fputc('\n', aliases);
463	}
741abed8	464
	465
	466