[moira.git] / gen / mailhub.dc

/* $Header$
 *
 * This generates the /usr/lib/aliases file for the mailhub.
 *
 *  (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 <ctype.h>
#include <moira.h>
#include <moira_site.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
EXEC SQL INCLUDE sqlca;


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

#define ML_WID	72
#define AL_MAX_WID 896

#define FALSE 0
#define TRUE (!FALSE)

FILE *out= stdout;


main(argc, argv)
int argc;
char **argv;
{
    long tm = time(NULL);
    char filename[64], *targetfile;
    struct stat sb;
    EXEC SQL BEGIN DECLARE SECTION;
    int flag;
    EXEC SQL END DECLARE SECTION;

#ifsql INGRES
    EXEC SQL CONNECT moira;
#endsql
#ifsql INFORMIX
    EXEC SQL DATABASE moira;
#endsql

    if (argc == 2) {
	if (stat(argv[1], &sb) == 0) {
            if (ModDiff (&flag, "users", sb.st_mtime))
	      exit(MR_DATE);
	    if (flag < 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 INGRES
    EXEC SQL DISCONNECT;
#endsql
#ifsql INFORMIX
    EXEC SQL CLOSE DATABASE;
#endsql

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

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

    fprintf(out, "\n%s\n# End of aliases file\n", 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, *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()
{
    EXEC SQL BEGIN DECLARE SECTION;
    int id, pid, bid, cnt, maillistp, acl, mid;
    char name[129], type[9], fname[17], mname[17], lname[17], buf[257];
    EXEC SQL END DECLARE SECTION;
    char *s;
    register struct user *u;
    struct list *l, *memberlist;
    register struct member *m;

    /* The following is declarative, not executed,
     * and so is dependent on where it is in the file,
     * not in the order of execution of statements.
     */
    EXEC SQL WHENEVER SQLERROR GOTO sqlerr;

    EXEC SQL SELECT modtime INTO :buf FROM users WHERE users_id = 0;
    EXEC SQL SELECT modtime INTO :buf FROM list WHERE list_id = 0;

    cnt = 0;
    machines = create_hash(10);

    EXEC SQL DECLARE m_cursor CURSOR FOR
      SELECT m.mach_id, m.name
      FROM machine m, users u
      WHERE m.mach_id = u.pop_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;
	else
	  strtrim(name);
#ifdef ATHENA
	strcat(name, ".LOCAL");
#endif
	if (hash_store(machines, id, pstrsave(name)) < 0) {
	    fprintf(stderr, "Out of memory!\n");
	    exit(MR_NO_MEM);
	}
	cnt++;
    }
    EXEC SQL CLOSE m_cursor;

    fprintf(stderr, "Loaded %d machines\n", cnt);

    cnt = 0;
    strings = create_hash(4000);

    EXEC SQL DECLARE s_cursor CURSOR FOR
      SELECT string_id, string
      FROM strings;
    EXEC SQL OPEN s_cursor;
    while (1) {
	EXEC SQL FETCH s_cursor INTO :id, :name;
	if (sqlca.sqlcode != 0) break;
	if (hash_store(strings, id, pstrsave(strtrim(name))) < 0) {
	    fprintf(stderr, "Out of memory!\n");
	    exit(MR_NO_MEM);
	}
	cnt++;
    }
    EXEC SQL CLOSE s_cursor;

    fprintf(stderr, "Loaded %d strings\n", cnt);

    cnt = 0;
    users = create_hash(12001);

    EXEC SQL DECLARE u_cursor CURSOR FOR
      SELECT users_id, login, first, middle, last, potype, pop_id, box_id
      FROM users
      WHERE status != 3;
    EXEC SQL OPEN u_cursor;
    while (1) {
        EXEC SQL FETCH u_cursor INTO :id, :name, :fname, :mname, :lname,
                                   :type, :pid, :bid;
        if (sqlca.sqlcode != 0) break;
	u = (struct user *) perm_malloc(sizeof(struct user));
	u->login = pstrsave(strtrim(name));
	u->first = pstrsave(strtrim(fname));
	u->last  = pstrsave(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", u->login, s);
	    u->pobox = pstrsave(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(MR_NO_MEM);
	}
	cnt++;
    }
    EXEC SQL CLOSE u_cursor;
    fprintf(stderr, "Loaded %d users\n", cnt);

    cnt = 0;
    lists = create_hash(15000);

    EXEC SQL DECLARE l_cursor CURSOR FOR
      SELECT list_id, name, maillist, acl_type, acl_id
      FROM list
      WHERE active != 0;
    EXEC SQL OPEN l_cursor;
    while (1) {
        EXEC SQL FETCH l_cursor INTO :id, :name, :maillistp, :type, :acl;
        if (sqlca.sqlcode != 0) break;
	l = (struct list *) perm_malloc(sizeof(struct list));
	l->name = pstrsave(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(MR_NO_MEM);
	}
	cnt++;
    }
    EXEC SQL CLOSE l_cursor;
    fprintf(stderr, "Loaded %d lists\n", cnt);

    cnt = 0;

    EXEC SQL DECLARE m_cursor2 CURSOR FOR
      SELECT list_id, member_type, member_id
      FROM imembers
      WHERE direct = 1;
    EXEC SQL OPEN m_cursor2;
    while (1) {
        EXEC SQL FETCH m_cursor2 INTO :id, :type, :mid;
        if (sqlca.sqlcode != 0) break;
	cnt++;
	if (l = (struct list *) hash_lookup(lists, id)) {
	    m = (struct member *) perm_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;
	    }
	}
    }
    EXEC SQL CLOSE m_cursor2;
    fprintf(stderr, "Loaded %d members\n", cnt);
    return;
 sqlerr:
    com_err(whoami, MR_INGRES_ERR, " code %d\n", sqlca.sqlcode);
    critical_alert("DCM", "Hesiod build encountered DATABASE ERROR %d",
		   sqlca.sqlcode);
    exit(MR_INGRES_ERR);
}


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

    if (l->maillist > 1 ||
	(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, -1, TRUE, FALSE);
    output_mlist(id, l);

    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;

    incount++;
    code = hashstr(s);
    ns = (struct names *) hash_lookup(names, code);
    if (ns == NULL) {
	if ((ns = (struct names *) perm_malloc(sizeof(struct names))) == NULL) {
	    fprintf(stderr, "ran out of memory inserting name (sorting)\n");
	    exit(MR_NO_MEM);
	}
	if (copy)
	  ns->name = pstrsave(s);
	else
	  ns->name = s;
	ns->keep = nodups;
	ns->id = id;
	ns->next = NULL;
	if (hash_store(names, code, ns) < 0) {
	    fprintf(stderr, "Out of memory!\n");
	    exit(MR_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 *) perm_malloc(sizeof(struct names)))
	    	== NULL) {
	    fprintf(stderr, "ran out of memory insterting name (sorting)\n");
	    exit(MR_NO_MEM);
	}
	ns = ns->next;
	if (copy)
	  ns->name = pstrsave(s);
	else
	  ns->name = s;
	ns->keep = nodups;
	ns->id = id;
	ns->next = NULL;
	return;
    }
 foundns:
    if (nodups || ns->keep) {
	if (nodups && ns->keep)
	  fprintf(stderr, "duplicated name: %s\n", s);
	return;
    }
    ns->id = 0;
}


/* Illegal chars: ! " % ( ) , . / : ; < = > @ [ \ ] ^ { | } */

static int illegalchars[] = {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^@ - ^O */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^P - ^_ */
    0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, /* SPACE - / */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, /* 0 - ? */
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ - O */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, /* P - _ */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ` - o */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, /* p - ^? */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
};


/* While hashing the string, punt any illegal characters */

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

    for (result = 0; c = *s; s++) {
	if (illegalchars[c]) {
	    register char *p;
	    for (p = s; *p; p++)
	      *p = p[1];
	    continue;
	}
	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);
    incount = 0;
    fprintf(out, "\n%s\n# Mailing lists\n%s\n", divide, divide);
    hash_step(lists, save_mlist, FALSE);
    fprintf(stderr, "Output %d lists\n", incount);
    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;

    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)
int id;
register struct list *l;
{
    struct list *l1;
    register struct member *m;
    register struct user *u;

    if (l->acl_t ==  'L' &&
	(l1 = (struct list *) hash_lookup(lists, l->acl_id)))
      fprintf(out, "owner-%s: %s\n%s: ", l->name, l1->name, l->name);
    else if (l->acl_t ==  'U' &&
	     (u = (struct user *) hash_lookup(users, l->acl_id)))
      fprintf(out, "owner-%s: %s\n%s: ", l->name, u->login, l->name);
    else
      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_people()
{
    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);
}


#define chunk_size	102400

char *perm_malloc(size)
unsigned size;
{
    static char *pool = NULL;
    static unsigned pool_size = 0;
    register char *ret;

    if (size > pool_size) {
	pool = (char *) malloc(chunk_size);
	pool_size = chunk_size;
    }
    ret = pool;
    pool += size;
    pool = (char *)(((unsigned) (pool + 1)) & ~1);
    pool_size -= (pool - ret);
    return(ret);
}


/*
 * Make a (permenant) copy of a string.
 */
char *
pstrsave(s)
    char *s;
{
    register int len;
    register char *p;
    /* Kludge for sloppy string semantics */
    if (!s) {
	    printf("NULL != \"\" !!!!\r\n");
	    p = perm_malloc(1);
	    *p = '\0';
	    return p;
    }
    len = strlen(s) + 1;
    p = perm_malloc((u_int)len);
    if (p) bcopy(s, p, len);
    return p;
}

#define hash_func(h, key) (key >= 0 ? (key % h->size) : (-key % h->size))

/* Create a hash table.  The size is just a hint, not a maximum. */

struct hash *create_hash(size)
int size;
{
    struct hash *h;

    h = (struct hash *) perm_malloc(sizeof(struct hash));
    if (h == (struct hash *) NULL)
      return((struct hash *) NULL);
    h->size = size;
    h->data = (struct bucket **) perm_malloc(size * sizeof(char *));
    if (h->data == (struct bucket **) NULL) {
	free(h);
	return((struct hash *) NULL);
    }
    bzero(h->data, size * sizeof(char *));
    return(h);
}

/* Lookup an object in the hash table.  Returns the value associated with
 * the key, or NULL (thus NULL is not a very good value to store...)
 */

char *hash_lookup(h, key)
struct hash *h;
register int key;
{
    register struct bucket *b;

    b = h->data[hash_func(h, key)];
    while (b && b->key != key)
      b = b->next;
    if (b && b->key == key)
      return(b->data);
    else
      return(NULL);
}


/* Update an existing object in the hash table.  Returns 1 if the object
 * existed, or 0 if not.
 */

int hash_update(h, key, value)
struct hash *h;
register int key;
char *value;
{
    register struct bucket *b;

    b = h->data[hash_func(h, key)];
    while (b && b->key != key)
      b = b->next;
    if (b && b->key == key) {
	b->data = value;
	return(1);
    } else
      return(0);
}


/* Store an item in the hash table.  Returns 0 if the key was not previously
 * there, 1 if it was, or -1 if we ran out of memory.
 */

int hash_store(h, key, value)
struct hash *h;
register int key;
char *value;
{
    register struct bucket *b, **p;

    p = &(h->data[hash_func(h, key)]);
    if (*p == NULL) {
	b = *p = (struct bucket *) perm_malloc(sizeof(struct bucket));
	if (b == (struct bucket *) NULL)
	  return(-1);
	b->next = NULL;
	b->key = key;
	b->data = value;
	return(0);
    }

    for (b = *p; b && b->key != key; b = *p)
      p = (struct bucket **) *p;
    if (b && b->key == key) {
	b->data = value;
	return(1);
    }
    b = *p = (struct bucket *) perm_malloc(sizeof(struct bucket));
    if (b == (struct bucket *) NULL)
      return(-1);
    b->next = NULL;
    b->key = key;
    b->data = value;
    return(0);
}


/* Search through the hash table for a given value.  For each piece of
 * data with that value, call the callback proc with the corresponding key.
 */

hash_search(h, value, callback)
struct hash *h;
register char *value;
void (*callback)();
{
    register struct bucket *b, **p;

    for (p = &(h->data[h->size - 1]); p >= h->data; p--) {
	for (b = *p; b; b = b->next) {
	    if (b->data == value)
	      (*callback)(b->key);
	}
    }
}


/* Step through the hash table, calling the callback proc with each key.
 */

hash_step(h, callback, hint)
struct hash *h;
void (*callback)();
char *hint;
{
    register struct bucket *b, **p;

    for (p = &(h->data[h->size - 1]); p >= h->data; p--) {
	for (b = *p; b; b = b->next) {
	    (*callback)(b->key, b->data, hint);
	}
    }
}


/* Deallocate all of the memory associated with a table */

hash_destroy(h)
struct hash *h;
{
    register struct bucket *b, **p, *b1;

    for (p = &(h->data[h->size - 1]); p >= h->data; p--) {
	for (b = *p; b; b = b1) {
	    b1 = b->next;
	    free(b);
	}
    }
}
Commit	Line	Data
bac4ceaa	1	/* $Header$
	2	*
	3	* This generates the /usr/lib/aliases file for the mailhub.
	4	*
	5	* (c) Copyright 1988, 1990 by the Massachusetts Institute of Technology.
	6	* For copying and distribution information, please see the file
	7	* <mit-copyright.h>.
	8	*/
	9
	10	#include <mit-copyright.h>
	11	#include <stdio.h>
	12	#include <string.h>
	13	#include <ctype.h>
	14	#include <moira.h>
	15	#include <moira_site.h>
	16	#include <sys/types.h>
	17	#include <sys/stat.h>
	18	#include <sys/time.h>
	19	EXEC SQL INCLUDE sqlca;
	20
	21
	22	extern int errno;
	23	char *whoami = "mailhub.gen";
	24	char *perm_malloc();
	25	char *pstrsave();
	26	char *divide = "##############################################################";
	27
	28	#define ML_WID 72
	29	#define AL_MAX_WID 896
	30
	31	#define FALSE 0
	32	#define TRUE (!FALSE)
	33
	34	FILE *out= stdout;
	35
	36
	37	main(argc, argv)
	38	int argc;
	39	char **argv;
	40	{
	41	long tm = time(NULL);
	42	char filename[64], *targetfile;
	43	struct stat sb;
	44	EXEC SQL BEGIN DECLARE SECTION;
	45	int flag;
	46	EXEC SQL END DECLARE SECTION;
	47
	48	#ifsql INGRES
9fd1c2b8	49	EXEC SQL CONNECT moira;
bac4ceaa	50	#endsql
bac4ceaa	51	#ifsql INFORMIX
9fd1c2b8	52	EXEC SQL DATABASE moira;
bac4ceaa	53	#endsql
	54
	55	if (argc == 2) {
	56	if (stat(argv[1], &sb) == 0) {
	57	if (ModDiff (&flag, "users", sb.st_mtime))
	58	exit(MR_DATE);
	59	if (flag < 0) {
	60	fprintf(stderr, "File %s does not need to be rebuilt.\n",
	61	argv[1]);
	62	exit(MR_NO_CHANGE);
	63	}
	64	}
	65	targetfile = argv[1];
	66	sprintf(filename, "%s~", targetfile);
	67	if ((out = fopen(filename, "w")) == NULL) {
	68	fprintf(stderr, "unable to open %s for output\n", filename);
	69	exit(MR_OCONFIG);
	70	}
	71	} else if (argc != 1) {
	72	fprintf(stderr, "usage: %s [outfile]\n", argv[0]);
	73	exit(MR_ARGS);
	74	}
	75
	76	fprintf(out, "%s\n# Aliases File Extract of %s", divide, ctime(&tm));
	77	fprintf(out, "# This file is automatically generated, do not edit it directly.\n%s\n\n", divide);
	78
	79	get_info();
	80
	81	#ifsql INGRES
	82	EXEC SQL DISCONNECT;
	83	#endsql
	84	#ifsql INFORMIX
	85	EXEC SQL CLOSE DATABASE;
	86	#endsql
	87
	88	fprintf(stderr, "Sorting Info\n");
	89	sort_info();
	90
	91	fprintf(stderr, "Dumping information\n");
	92	do_people();
	93
	94	fprintf(out, "\n%s\n# End of aliases file\n", divide);
	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
	108	struct hash users, machines, strings, lists, *names;
	109	struct user {
	110	char *login;
	111	char *first;
	112	char *last;
	113	char mi;
	114	char *pobox;
	115	};
	116	struct member {
117	struct member *next;
118	char *name;
119	int list_id;
120	};
121	struct list {
122	char *name;
123	char maillist;
124	char acl_t;
125	int acl_id;
126	struct member *m;
127	};
128	struct names {
129	char *name;
130	struct names *next;
131	int keep:1;
132	int id:31;
133	};
134
135
136	get_info()
137	{
138	EXEC SQL BEGIN DECLARE SECTION;
139	int id, pid, bid, cnt, maillistp, acl, mid;
140	char name[129], type[9], fname[17], mname[17], lname[17], buf[257];
141	EXEC SQL END DECLARE SECTION;
142	char *s;
143	register struct user *u;
144	struct list l, memberlist;
145	register struct member *m;
146
9fd1c2b8	147	/* The following is declarative, not executed,
	148	* and so is dependent on where it is in the file,
	149	* not in the order of execution of statements.
	150	*/
bac4ceaa	151	EXEC SQL WHENEVER SQLERROR GOTO sqlerr;
	152
	153	EXEC SQL SELECT modtime INTO :buf FROM users WHERE users_id = 0;
	154	EXEC SQL SELECT modtime INTO :buf FROM list WHERE list_id = 0;
	155
	156	cnt = 0;
	157	machines = create_hash(10);
	158
	159	EXEC SQL DECLARE m_cursor CURSOR FOR
	160	SELECT m.mach_id, m.name
	161	FROM machine m, users u
	162	WHERE m.mach_id = u.pop_id;
	163	EXEC SQL OPEN m_cursor;
	164	while (1) {
	165	EXEC SQL FETCH m_cursor INTO :id, :name;
	166	if (sqlca.sqlcode != 0) break;
	167	if (s = index(name, '.'))
	168	*s = 0;
	169	else
	170	strtrim(name);
	171	#ifdef ATHENA
	172	strcat(name, ".LOCAL");
	173	#endif
	174	if (hash_store(machines, id, pstrsave(name)) < 0) {
	175	fprintf(stderr, "Out of memory!\n");
	176	exit(MR_NO_MEM);
	177	}
	178	cnt++;
	179	}
	180	EXEC SQL CLOSE m_cursor;
	181
	182	fprintf(stderr, "Loaded %d machines\n", cnt);
	183
	184	cnt = 0;
	185	strings = create_hash(4000);
	186
	187	EXEC SQL DECLARE s_cursor CURSOR FOR
	188	SELECT string_id, string
	189	FROM strings;
	190	EXEC SQL OPEN s_cursor;
	191	while (1) {
	192	EXEC SQL FETCH s_cursor INTO :id, :name;
	193	if (sqlca.sqlcode != 0) break;
	194	if (hash_store(strings, id, pstrsave(strtrim(name))) < 0) {
	195	fprintf(stderr, "Out of memory!\n");
	196	exit(MR_NO_MEM);
	197	}
	198	cnt++;
	199	}
	200	EXEC SQL CLOSE s_cursor;
	201
	202	fprintf(stderr, "Loaded %d strings\n", cnt);
	203
	204	cnt = 0;
	205	users = create_hash(12001);
	206
	207	EXEC SQL DECLARE u_cursor CURSOR FOR
	208	SELECT users_id, login, first, middle, last, potype, pop_id, box_id
	209	FROM users
	210	WHERE status != 3;
	211	EXEC SQL OPEN u_cursor;
	212	while (1) {
	213	EXEC SQL FETCH u_cursor INTO :id, :name, :fname, :mname, :lname,
	214	:type, :pid, :bid;
215	if (sqlca.sqlcode != 0) break;
216	u = (struct user *) perm_malloc(sizeof(struct user));
217	u->login = pstrsave(strtrim(name));
218	u->first = pstrsave(strtrim(fname));
219	u->last = pstrsave(strtrim(lname));
220	if (mname[0] != ' ')
221	u->mi = mname[0];
222	else
223	u->mi = 0;
224
225	if (type[0] == 'P' && (s = hash_lookup(machines, pid))) {
226	sprintf(buf, "%s@%s", u->login, s);
227	u->pobox = pstrsave(buf);
228	} else if (type[0] == 'S') {
229	u->pobox = hash_lookup(strings, bid);
230	} else
231	u->pobox = (char *) NULL;
232	if (hash_store(users, id, u) < 0) {
233	fprintf(stderr, "Out of memory!\n");
234	exit(MR_NO_MEM);
235	}
236	cnt++;
237	}
238	EXEC SQL CLOSE u_cursor;
239	fprintf(stderr, "Loaded %d users\n", cnt);
240
241	cnt = 0;
242	lists = create_hash(15000);
243
244	EXEC SQL DECLARE l_cursor CURSOR FOR
245	SELECT list_id, name, maillist, acl_type, acl_id
246	FROM list
247	WHERE active != 0;
248	EXEC SQL OPEN l_cursor;
249	while (1) {
250	EXEC SQL FETCH l_cursor INTO :id, :name, :maillistp, :type, :acl;
251	if (sqlca.sqlcode != 0) break;
252	l = (struct list *) perm_malloc(sizeof(struct list));
253	l->name = pstrsave(strtrim(name));
254	l->maillist = maillistp;
255	l->acl_t = type[0];
256	l->acl_id = acl;
257	l->m = (struct member *) NULL;
258	if (hash_store(lists, id, l) < 0) {
259	fprintf(stderr, "Out of memory!\n");
260	exit(MR_NO_MEM);
261	}
262	cnt++;
263	}
264	EXEC SQL CLOSE l_cursor;
265	fprintf(stderr, "Loaded %d lists\n", cnt);
266
267	cnt = 0;
268
269	EXEC SQL DECLARE m_cursor2 CURSOR FOR
270	SELECT list_id, member_type, member_id
271	FROM imembers
272	WHERE direct = 1;
273	EXEC SQL OPEN m_cursor2;
274	while (1) {
275	EXEC SQL FETCH m_cursor2 INTO :id, :type, :mid;
276	if (sqlca.sqlcode != 0) break;
277	cnt++;
278	if (l = (struct list *) hash_lookup(lists, id)) {
279	m = (struct member *) perm_malloc(sizeof(struct member));
280	if (type[0] == 'U' &&
281	(u = (struct user *) hash_lookup(users, mid))) {
282	m->list_id = 0;
283	m->name = u->login;
284	m->next = l->m;
285	l->m = m;
286	} else if (type[0] == 'L' &&
287	(memberlist = (struct list *) hash_lookup(lists, mid))) {
288	m->list_id = mid;
289	m->name = memberlist->name;
290	m->next = l->m;
291	l->m = m;
292	} else if (type[0] == 'S' &&
293	(s = hash_lookup(strings, mid))) {
294	m->list_id = 0;
295	m->next = l->m;
296	l->m = m;
297	m->name = s;
298	}
299	}
300	}
301	EXEC SQL CLOSE m_cursor2;
302	fprintf(stderr, "Loaded %d members\n", cnt);
303	return;
304	sqlerr:
305	com_err(whoami, MR_INGRES_ERR, " code %d\n", sqlca.sqlcode);
306	critical_alert("DCM", "Hesiod build encountered DATABASE ERROR %d",
307	sqlca.sqlcode);
308	exit(MR_INGRES_ERR);
309	}
310
311
312	save_mlist(id, l, force)
313	int id;
314	struct list *l;
315	int force;
316	{
317	register struct member *m;
318	register struct list *l1;
319
320	if (l->maillist > 1 \|\|
321	(l->maillist == 0 && !force))
322	return;
323
324	if (l->m && l->m->next == NULL &&
325	!strcasecmp(l->name, l->m->name)) {
326	l->maillist = 3;
327	return;
328	}
329	l->maillist = 2;
330	insert_name(l->name, -1, TRUE, FALSE);
331	output_mlist(id, l);
332
333	if (l->acl_t == 'L' && (l1 = (struct list *)hash_lookup(lists, l->acl_id)))
334	save_mlist(0, l1, TRUE);
335
336	for (m = l->m; m; m = m->next) {
337	if (m->list_id && (l1 = (struct list *)hash_lookup(lists, m->list_id)))
338	save_mlist(0, l1, TRUE);
339	}
340	}
341
342
343	insert_login(id, u, dummy)
344	int id;
345	struct user *u;
346	int dummy;
347	{
348	if (u->pobox && u->login[0] != '#')
349	insert_name(u->login, id, TRUE, FALSE);
350	}
351
352	void insert_names(id, u, dummy)
353	int id;
354	struct user *u;
355	int dummy;
356	{
357	char buffer[256];
358
359	insert_name(u->last, id, FALSE, FALSE);
360	sprintf(buffer, "%s_%s", u->first, u->last);
361	insert_name(buffer, id, FALSE, TRUE);
362	/* sprintf(buffer, "%c_%s", u->first[0], u->last);
363	insert_name(buffer, id, FALSE, TRUE); */
364	if (u->mi) {
365	sprintf(buffer, "%s_%c_%s", u->first, u->mi, u->last);
366	insert_name(buffer, id, FALSE, TRUE);
367	}
368	}
369
370	int incount = 0;
371
372	insert_name(s, id, nodups, copy)
373	char *s;
374	int id;
375	int nodups;
376	int copy;
377	{
378	int code;
379	register struct names *ns;
380
381	incount++;
382	code = hashstr(s);
383	ns = (struct names *) hash_lookup(names, code);
384	if (ns == NULL) {
385	if ((ns = (struct names *) perm_malloc(sizeof(struct names))) == NULL) {
386	fprintf(stderr, "ran out of memory inserting name (sorting)\n");
387	exit(MR_NO_MEM);
388	}
389	if (copy)
390	ns->name = pstrsave(s);
391	else
392	ns->name = s;
393	ns->keep = nodups;
394	ns->id = id;
395	ns->next = NULL;
396	if (hash_store(names, code, ns) < 0) {
397	fprintf(stderr, "Out of memory!\n");
398	exit(MR_NO_MEM);
399	}
400	return;
401	}
402	if (strcasecmp(ns->name, s)) {
403	while (ns->next) {
404	ns = ns->next;
405	if (!strcasecmp(ns->name, s))
406	goto foundns;
407	}
408	if ((ns->next = (struct names *) perm_malloc(sizeof(struct names)))
409	== NULL) {
410	fprintf(stderr, "ran out of memory insterting name (sorting)\n");
411	exit(MR_NO_MEM);
412	}
413	ns = ns->next;
414	if (copy)
415	ns->name = pstrsave(s);
416	else
417	ns->name = s;
418	ns->keep = nodups;
419	ns->id = id;
420	ns->next = NULL;
421	return;
422	}
423	foundns:
424	if (nodups \|\| ns->keep) {
425	if (nodups && ns->keep)
426	fprintf(stderr, "duplicated name: %s\n", s);
427	return;
428	}
429	ns->id = 0;
430	}
431
432
433	/* Illegal chars: ! " % ( ) , . / : ; < = > @ [ \ ] ^ { \| } */
434
435	static int illegalchars[] = {
436	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^@ - ^O */
437	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* ^P - ^_ */
438	0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, /* SPACE - / */
439	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, /* 0 - ? */
440	1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* @ - O */
441	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, /* P - _ */
442	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ` - o */
443	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, /* p - ^? */
444	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
445	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
446	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
447	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
448	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
449	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
450	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
451	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
452	};
453
454
455	/* While hashing the string, punt any illegal characters */
456
457	int hashstr(s)
458	register char *s;
459	{
460	register int result;
461	register int c;
462
463	for (result = 0; c = *s; s++) {
464	if (illegalchars[c]) {
465	register char *p;
466	for (p = s; *p; p++)
467	*p = p[1];
468	continue;
469	}
470	if (isupper(c))
471	c = *s = tolower(c);
472	/* result = result * 31 + s; /
473	result = (result << 5) - result + c - '`';
474	}
475	return(result < 0 ? -result : result);
476	}
477
478
479	sort_info()
480	{
481	names = create_hash(20001);
482	hash_step(users, insert_login, NULL);
483	incount = 0;
484	fprintf(out, "\n%s\n# Mailing lists\n%s\n", divide, divide);
485	hash_step(lists, save_mlist, FALSE);
486	fprintf(stderr, "Output %d lists\n", incount);
487	hash_step(users, insert_names, NULL);
488	fprintf(stderr, "Inserted %d names\n", incount);
489	}
490
491
492	output_data(dummy, nms, out)
493	int dummy;
494	struct names *nms;
495	FILE *out;
496	{
497	register struct names *ns;
498	register struct user *u;
499
500	incount++;
501	for (ns = nms; ns; ns = ns->next) {
502	if (ns->name[0] == 0 \|\| ns->name[1] == 0) {
503	fprintf(stderr, "punting %s due to short name\n", ns->name);
504	continue;
505	}
506	if (ns->id > 0) {
507	u = (struct user *) hash_lookup(users, ns->id);
508	if (u->pobox) {
509	fprintf(out, "%s: %s\n", ns->name, u->pobox);
510	} else {
511	fprintf(out, "%s: =%s=@nobox\n", ns->name, ns->name);
512	}
513	} else if (ns->id == 0) {
514	fprintf(out, "%s: =%s=@ambig\n", ns->name, ns->name);
515	}
516	}
517	}
518
519
520	int lwid, bol, awid;
521
522	output_mlist(id, l)
523	int id;
524	register struct list *l;
525	{
526	struct list *l1;
527	register struct member *m;
528	register struct user *u;
529
530	if (l->acl_t == 'L' &&
531	(l1 = (struct list *) hash_lookup(lists, l->acl_id)))
532	fprintf(out, "owner-%s: %s\n%s: ", l->name, l1->name, l->name);
533	else if (l->acl_t == 'U' &&
534	(u = (struct user *) hash_lookup(users, l->acl_id)))
535	fprintf(out, "owner-%s: %s\n%s: ", l->name, u->login, l->name);
536	else
537	fprintf(out, "%s: ", l->name);
538
539
540	lwid = strlen(l->name) + 2;
541	bol = 1;
542	for (m = l->m; m; m = m->next) {
543	do_member(out, m->name);
544	}
545	if (l->m == (struct member *)NULL)
546	fprintf(out, "/dev/null");
547	fprintf(out, "\n\n");
548	incount++;
549	}
550
551
552	/* print out strings separated by commas, doing line breaks as appropriate */
553
554	do_member(out, s)
555	FILE *out;
556	register char *s;
557	{
558	register wwid;
559	static int cont = 1;
560
561	wwid = strlen(s);
562
563	if (!bol && awid + wwid + 2 > AL_MAX_WID) {
564	fprintf(out, ",\n\tcontinuation-%d\ncontinuation-%d: ", cont, cont);
565	cont++;
566	awid = lwid = 17 + wwid;
567	fputs(s, out);
568	return;
569	}
570
571	if (bol) {
572	lwid += wwid;
573	awid = lwid;
574	fputs(s, out);
575	bol = 0;
576	return;
577	}
578	if (lwid + wwid + 2 > ML_WID) {
579	fprintf(out, ",\n\t%s", s);
580	awid += lwid + wwid + 2;
581	lwid = wwid + 8;
582	return;
583	}
584	lwid += wwid + 2;
585	fprintf(out, ", %s", s);
586	}
587
588
589	do_people()
590	{
591	incount = 0;
592	fprintf(out, "\n%s\n# People\n%s\n", divide, divide);
593	hash_step(names, output_data, out);
594	fprintf(stderr, "Output %d entries\n", incount);
595	}
596
597
598	#define chunk_size 102400
599
600	char *perm_malloc(size)
601	unsigned size;
602	{
603	static char *pool = NULL;
604	static unsigned pool_size = 0;
605	register char *ret;
606
607	if (size > pool_size) {
608	pool = (char *) malloc(chunk_size);
609	pool_size = chunk_size;
610	}
611	ret = pool;
612	pool += size;
613	pool = (char *)(((unsigned) (pool + 1)) & ~1);
614	pool_size -= (pool - ret);
615	return(ret);
616	}
617
618
619	/*
620	* Make a (permenant) copy of a string.
621	*/
622	char *
623	pstrsave(s)
624	char *s;
625	{
626	register int len;
627	register char *p;
628	/* Kludge for sloppy string semantics */
629	if (!s) {
630	printf("NULL != \"\" !!!!\r\n");
631	p = perm_malloc(1);
632	*p = '\0';
633	return p;
634	}
635	len = strlen(s) + 1;
636	p = perm_malloc((u_int)len);
637	if (p) bcopy(s, p, len);
638	return p;
639	}
640
641	#define hash_func(h, key) (key >= 0 ? (key % h->size) : (-key % h->size))
642
643	/* Create a hash table. The size is just a hint, not a maximum. */
644
645	struct hash *create_hash(size)
646	int size;
647	{
648	struct hash *h;
649
650	h = (struct hash *) perm_malloc(sizeof(struct hash));
651	if (h == (struct hash *) NULL)
652	return((struct hash *) NULL);
653	h->size = size;
654	h->data = (struct bucket *) perm_malloc(size sizeof(char *));
655	if (h->data == (struct bucket **) NULL) {
656	free(h);
657	return((struct hash *) NULL);
658	}
659	bzero(h->data, size * sizeof(char *));
660	return(h);
661	}
662
663	/* Lookup an object in the hash table. Returns the value associated with
664	* the key, or NULL (thus NULL is not a very good value to store...)
665	*/
666
667	char *hash_lookup(h, key)
668	struct hash *h;
669	register int key;
670	{
671	register struct bucket *b;
672
673	b = h->data[hash_func(h, key)];
674	while (b && b->key != key)
675	b = b->next;
676	if (b && b->key == key)
677	return(b->data);
678	else
679	return(NULL);
680	}
681
682
683	/* Update an existing object in the hash table. Returns 1 if the object
684	* existed, or 0 if not.
685	*/
686
687	int hash_update(h, key, value)
688	struct hash *h;
689	register int key;
690	char *value;
691	{
692	register struct bucket *b;
693
694	b = h->data[hash_func(h, key)];
695	while (b && b->key != key)
696	b = b->next;
697	if (b && b->key == key) {
698	b->data = value;
699	return(1);
700	} else
701	return(0);
702	}
703
704
705	/* Store an item in the hash table. Returns 0 if the key was not previously
706	* there, 1 if it was, or -1 if we ran out of memory.
707	*/
708
709	int hash_store(h, key, value)
710	struct hash *h;
711	register int key;
712	char *value;
713	{
714	register struct bucket b, *p;
715
716	p = &(h->data[hash_func(h, key)]);
717	if (*p == NULL) {
718	b = p = (struct bucket ) perm_malloc(sizeof(struct bucket));
719	if (b == (struct bucket *) NULL)
720	return(-1);
721	b->next = NULL;
722	b->key = key;
723	b->data = value;
724	return(0);
725	}
726
727	for (b = p; b && b->key != key; b = p)
728	p = (struct bucket *) p;
729	if (b && b->key == key) {
730	b->data = value;
731	return(1);
732	}
733	b = p = (struct bucket ) perm_malloc(sizeof(struct bucket));
734	if (b == (struct bucket *) NULL)
735	return(-1);
736	b->next = NULL;
737	b->key = key;
738	b->data = value;
739	return(0);
740	}
741
742
743	/* Search through the hash table for a given value. For each piece of
744	* data with that value, call the callback proc with the corresponding key.
745	*/
746
747	hash_search(h, value, callback)
748	struct hash *h;
749	register char *value;
750	void (*callback)();
751	{
752	register struct bucket b, *p;
753
754	for (p = &(h->data[h->size - 1]); p >= h->data; p--) {
755	for (b = *p; b; b = b->next) {
756	if (b->data == value)
757	(*callback)(b->key);
758	}
759	}
760	}
761
762
763	/* Step through the hash table, calling the callback proc with each key.
764	*/
765
766	hash_step(h, callback, hint)
767	struct hash *h;
768	void (*callback)();
769	char *hint;
770	{
771	register struct bucket b, *p;
772
773	for (p = &(h->data[h->size - 1]); p >= h->data; p--) {
774	for (b = *p; b; b = b->next) {
775	(*callback)(b->key, b->data, hint);
776	}
777	}
778	}
779
780
781	/* Deallocate all of the memory associated with a table */
782
783	hash_destroy(h)
784	struct hash *h;
785	{
786	register struct bucket b, p, b1;
787
788	for (p = &(h->data[h->size - 1]); p >= h->data; p--) {
789	for (b = *p; b; b = b1) {
790	b1 = b->next;
791	free(b);
792	}
793	}
794	}