[moira.git] / clients / blanche / blanche.c

/* $Header$
 *
 * Command line oriented SMS List tool.
 *
 * by Mark Rosenstein, September 1988.
 *
 * Copyright 1989 by the Massachusetts Institute of Technology.
 */

#include <mit-copyright.h>
#include <stdio.h>
#include <ctype.h>
#include <sms.h>
#include <sms_app.h>

#ifndef LINT
static char smslist_rcsid[] = "$Header$";
#endif


struct member {
    int type;
    char *name;
};

/* member types */
#define M_ANY		0
#define M_USER		1
#define M_LIST		2
#define M_STRING	3

/* flags from command line */
int infoflg, verbose, syncflg, memberflg, debugflg;

/* various member lists */
struct save_queue *addlist, *dellist, *memberlist, *synclist;

char *listname, *whoami;

extern char *index();
extern int errno;

int show_list_info(), show_list_count(), get_list_members(), scream();
struct member *parse_member();


main(argc, argv)
int argc;
char **argv;
{
    int status;
    char **arg = argv;
    char *membervec[3];
    struct member *memberstruct;

    /* clear all flags & lists */
    infoflg = verbose = syncflg = memberflg = debugflg = 0;
    listname = NULL;
    addlist = sq_create();
    dellist = sq_create();
    memberlist = sq_create();
    synclist = sq_create();
    whoami = argv[0];

    /* parse args, building addlist, dellist, & synclist */
    while (++arg - argv < argc) {
	if  (**arg == '-')
	  switch((*arg)[1]) {
	  case 'm':
	      memberflg++;
	      break;
	  case 'D':
	      debugflg++;
	      break;
	  case 'i':
	      infoflg++;
	      break;
	  case 'v':
	      verbose++;
	      break;
	  case 'a':
	      if (arg - argv < argc - 1) {
		  ++arg;
		  if (memberstruct = parse_member(*arg))
		    sq_save_data(addlist, memberstruct);
	      } else
		usage(argv);
	      break;
	  case 'd':
	      if (arg - argv < argc - 1) {
		  ++arg;
		  if (memberstruct = parse_member(*arg))
		    sq_save_data(dellist, memberstruct);
	      } else
		usage(argv);
	      break;
	  case 'f':
	      if (arg - argv < argc - 1) {
		  FILE *in;
		  char buf[BUFSIZ];

		  syncflg++;
		  ++arg;
		  if (!strcmp(*arg, "-"))
		    in = stdin;
		  else {
		      in = fopen(*arg, "r");
		      if (!in) {
			  com_err(whoami, errno, " while opening %s for input",
				  *arg);
			  exit(2);
		      }
		  }
		  while (fgets(buf, BUFSIZ, in))
		    if (memberstruct = parse_member(buf))
		      sq_save_data(synclist, memberstruct);
		  if (!feof(in))
		    com_err(whoami, errno, " while reading from %s", *arg);
	      } else
		usage(argv);
	      break;
	  default:
	      usage(argv);
	  }
	else if (listname == NULL)
	  listname = *arg;
	else
	  usage(argv);
    }
    if (listname == NULL)
      usage(argv);

    /* if no other options specified, turn on list members flag */
    if (!(infoflg || syncflg ||
	  addlist->q_next != addlist || dellist->q_next != dellist))
      memberflg++;

    /* fire up SMS */
    if (status = sms_connect()) {
	com_err(whoami, status, " unable to connect to SMS");
	exit(2);
    }
    if (status = sms_auth("blanche")) {
	com_err(whoami, status, " unable to authenticate to SMS");
	exit(2);
    }

    /* display list info if requested to */
    if (infoflg) {
	status = sms_query("get_list_info", 1, &listname, show_list_info,NULL);
	if (status)
	  com_err(whoami, status, " while getting list information");
	if (verbose && !memberflg) {
	    status = sms_query("count_members_of_list", 1, &listname,
			       show_list_count, NULL);
	    if (status)
	      com_err(whoami, status, " while getting list count");
	}
    }

    /* if we're synchronizing to a file, we need to:
     *  get the current members of the list
     *	for each member of the sync file
     *	   if they are on the list, remove them from the in-memory copy
     *	   if they're not on the list, add them to add-list
     *	if anyone is left on the in-memory copy, put them on the delete-list
     * lastly, reset memberlist so we can use it again later
     */
    if (syncflg) {
	status = sms_query("get_members_of_list", 1, &listname,
			   get_list_members, memberlist);
	if (status)
	  com_err(whoami, status, " while getting members of list");
	while (sq_get_data(synclist, &memberstruct)) {
	    struct save_queue *q;
	    int removed = 0;

	    for (q = memberlist->q_next; q != memberlist; q = q->q_next) {
		if (membermatch(q->q_data, memberstruct)) {
		    q->q_prev->q_next = q->q_next;
		    q->q_next->q_prev = q->q_prev;
		    removed++;
		    break;
		}
	    }
	    if (!removed)
	      sq_save_data(addlist, memberstruct);
	}
	while (sq_get_data(memberlist, &memberstruct))
	  sq_save_data(dellist, memberstruct);
	sq_destroy(memberlist);
	memberlist = sq_create();
    }

    /* Process the add list */
    while (sq_get_data(addlist, &memberstruct)) {
	membervec[0] = listname;
	membervec[2] = memberstruct->name;
	switch (memberstruct->type) {
	case M_ANY:
	case M_USER:
	    membervec[1] = "USER";
	    status = sms_query("add_member_to_list", 3, membervec, scream, NULL);
	    if (status == SMS_SUCCESS)
	      break;
	    else if (status != SMS_USER || memberstruct->type != M_ANY) {
		com_err(whoami, status, " while adding member %s to %s",
			memberstruct->name, listname);
		break;
	    }
	case M_LIST:
	    membervec[1] = "LIST";
	    status = sms_query("add_member_to_list", 3, membervec,
			       scream, NULL);
	    if (status == SMS_SUCCESS)
	      break;
	    else if (status != SMS_LIST || memberstruct->type != M_ANY) {
		com_err(whoami, status, " while adding member %s to %s",
			memberstruct->name, listname);
		break;
	    }
	case M_STRING:
	    membervec[1] = "STRING";
	    status = sms_query("add_member_to_list", 3, membervec,
			       scream, NULL);
	    if (status != SMS_SUCCESS)
	      com_err(whoami, status, " while adding member %s to %s",
		      memberstruct->name, listname);
	}
    }

    /* Process the delete list */
    while (sq_get_data(dellist, &memberstruct)) {
	membervec[0] = listname;
	membervec[2] = memberstruct->name;
	switch (memberstruct->type) {
	case M_ANY:
	case M_USER:
	    membervec[1] = "USER";
	    status = sms_query("delete_member_from_list", 3, membervec,
			       scream, NULL);
	    if (status == SMS_SUCCESS)
	      break;
	    else if ((status != SMS_USER && status != SMS_NO_MATCH) ||
		     memberstruct->type != M_ANY) {
		com_err(whoami, status, " while deleteing member %s from %s",
			memberstruct->name, listname);
		break;
	    }
	case M_LIST:
	    membervec[1] = "LIST";
	    status = sms_query("delete_member_from_list", 3, membervec,
			       scream, NULL);
	    if (status == SMS_SUCCESS)
	      break;
	    else if ((status != SMS_LIST && status != SMS_NO_MATCH) ||
		     memberstruct->type != M_ANY) {
		com_err(whoami, status, " while deleteing member %s from %s",
			memberstruct->name, listname);
		break;
	    }
	case M_STRING:
	    membervec[1] = "STRING";
	    status = sms_query("delete_member_from_list", 3, membervec,
			       scream, NULL);
	    if (status == SMS_STRING && memberstruct->type == M_ANY)
	      com_err(whoami, 0, "Unable to find member %s to delete from %s",
		      memberstruct->name, listname);
	    else if (status != SMS_SUCCESS)
	      com_err(whoami, status, " while deleteing member %s from %s",
		      memberstruct->name, listname);
	}
    }

    /* Display the members of the list now, if requested */
    if (memberflg) {
	status = sms_query("get_members_of_list", 1, &listname,
			   get_list_members, memberlist);
	if (status)
	  com_err(whoami, status, " while getting members of list");
	while (sq_get_data(memberlist, &memberstruct)) {
	    if (verbose) {
		char *s;
		switch (memberstruct->type) {
		case M_USER:
		    s = "USER";
		    break;
		case M_LIST:
		    s = "LIST";
		    break;
		case M_STRING:
		    s = "STRING";
		    break;
		}
		printf("%s: %s\n", s, memberstruct->name);
	    } else {
		if (memberstruct->type == M_LIST)
		  printf("LIST:%s\n", memberstruct->name);
		else if (memberstruct->type == M_STRING &&
			 !index(memberstruct->name, '@'))
		  printf("STRING:%s\n", memberstruct->name);
		else
		  printf("%s\n", memberstruct->name);
	    }
	}
    }

    /* We're done! */
    sms_disconnect();
    exit(0);
}

usage(argv)
char **argv;
{
    printf("Usage: %s [-i] [-v] [-m] listname [-a member] [-d member] [-f file]\n",
	   argv[0]);
    exit(1);
}


show_list_info(argc, argv, hint)
int argc;
char **argv;
int hint;
{
    printf("List: %s\n", argv[0]);
    printf("Description: %s\n", argv[9]);
    printf("Flags: %s, %s, and %s\n",
	   atoi(argv[1]) ? "active" : "inactive",
	   atoi(argv[2]) ? "public" : "private",
	   atoi(argv[3]) ? "hidden" : "visible");
    printf("%s is %sa maillist, and is %sa group", argv[0],
	   atoi(argv[4]) ? "" : "not ",
	   atoi(argv[5]) ? "" : "not ");
    if (atoi(argv[5]))
      printf(" with GID %d\n", atoi(argv[6]));
    else
      printf("\n");
    printf("Owner: %s %s\n", argv[7], argv[8]);
    printf("Last modified by %s with %s on %s\n", argv[11], argv[12], argv[10]);
    return(SMS_CONT);
}


show_list_count(argc, argv, hint)
int argc;
char **argv;
int hint;
{
    printf("Members: %s\n", argv[0]);
}


get_list_members(argc, argv, q)
int argc;
char **argv;
struct save_queue *q;
{
    struct member *m;

    m = (struct member *) malloc(sizeof(struct member));
    switch (argv[0][0]) {
    case 'U':
	m->type = M_USER;
	break;
    case 'L':
	m->type = M_LIST;
	break;
    case 'S':
	m->type = M_STRING;
	break;
    }
    m->name = strsave(argv[1]);
    sq_save_data(q, m);
    return(SMS_CONT);
}


scream()
{
    fprintf(stderr, "Programmer botch\n");
    exit(3);
}


struct member *parse_member(s)
register char *s;
{
    register struct member *m;
    char *p;

    while (*s && isspace(*s))
      s++;
    p = s;
    while (*p && isprint(*p) && !isspace(*p) && *p != ';')
      p++;
    *p = 0;
    if (p == s || strlen(s) == 0)
      return(NULL);

    if ((m = (struct member *) malloc(sizeof(struct member))) == NULL)
      return(NULL);

    if (p = index(s, ':')) {
	*p = 0;
	m->name = ++p;
	if (!strcasecmp("user", s))
	  m->type = M_USER;
	else if (!strcasecmp("list", s))
	  m->type = M_LIST;
	else if (!strcasecmp("string", s))
	  m->type = M_STRING;
	else {
	    m->type = M_STRING;
	    *(--p) = ':';
	    m->name = s;
	}
	m->name = strsave(m->name);
	return(m);
    }
    m->name = strsave(s);
    if (index(s, '@') || index(s, '!') || index(s, '%'))
      m->type = M_STRING;
    else
      m->type = M_ANY;
    return(m);
}


int membermatch(m1, m2)
struct member *m1, *m2;
{
    if (strcmp(m1->name, m2->name))
      return(0);
    if (m1->type == M_ANY || m2->type  == M_ANY)
      return(1);
    if (m1->type == m2->type)
      return(1);
    else
      return(0);
}
Commit	Line	Data
2d7360ca	1	/* $Header$
	2	*
	3	* Command line oriented SMS List tool.
	4	*
	5	* by Mark Rosenstein, September 1988.
	6	*
	7	* Copyright 1989 by the Massachusetts Institute of Technology.
	8	*/
	9
	10	#include <mit-copyright.h>
	11	#include <stdio.h>
	12	#include <ctype.h>
	13	#include <sms.h>
	14	#include <sms_app.h>
	15
	16	#ifndef LINT
	17	static char smslist_rcsid[] = "$Header$";
	18	#endif
	19
	20
	21	struct member {
	22	int type;
	23	char *name;
	24	};
	25
	26	/* member types */
	27	#define M_ANY 0
	28	#define M_USER 1
	29	#define M_LIST 2
	30	#define M_STRING 3
	31
	32	/* flags from command line */
	33	int infoflg, verbose, syncflg, memberflg, debugflg;
	34
	35	/* various member lists */
	36	struct save_queue addlist, dellist, memberlist, synclist;
	37
	38	char listname, whoami;
	39
	40	extern char *index();
	41	extern int errno;
	42
	43	int show_list_info(), show_list_count(), get_list_members(), scream();
	44	struct member *parse_member();
	45
	46
	47
	48	main(argc, argv)
	49	int argc;
	50	char **argv;
	51	{
	52	int status;
	53	char **arg = argv;
	54	char *membervec[3];
	55	struct member *memberstruct;
	56
	57	/* clear all flags & lists */
	58	infoflg = verbose = syncflg = memberflg = debugflg = 0;
	59	listname = NULL;
	60	addlist = sq_create();
	61	dellist = sq_create();
	62	memberlist = sq_create();
	63	synclist = sq_create();
	64	whoami = argv[0];
65
66	/* parse args, building addlist, dellist, & synclist */
67	while (++arg - argv < argc) {
68	if (**arg == '-')
69	switch((*arg)[1]) {
70	case 'm':
71	memberflg++;
72	break;
73	case 'D':
74	debugflg++;
75	break;
76	case 'i':
77	infoflg++;
78	break;
79	case 'v':
80	verbose++;
81	break;
82	case 'a':
83	if (arg - argv < argc - 1) {
84	++arg;
85	if (memberstruct = parse_member(*arg))
86	sq_save_data(addlist, memberstruct);
87	} else
88	usage(argv);
89	break;
90	case 'd':
91	if (arg - argv < argc - 1) {
92	++arg;
93	if (memberstruct = parse_member(*arg))
94	sq_save_data(dellist, memberstruct);
95	} else
96	usage(argv);
97	break;
98	case 'f':
99	if (arg - argv < argc - 1) {
100	FILE *in;
101	char buf[BUFSIZ];
102
103	syncflg++;
104	++arg;
105	if (!strcmp(*arg, "-"))
106	in = stdin;
107	else {
108	in = fopen(*arg, "r");
109	if (!in) {
110	com_err(whoami, errno, " while opening %s for input",
111	*arg);
112	exit(2);
113	}
114	}
115	while (fgets(buf, BUFSIZ, in))
116	if (memberstruct = parse_member(buf))
117	sq_save_data(synclist, memberstruct);
118	if (!feof(in))
119	com_err(whoami, errno, " while reading from %s", *arg);
120	} else
121	usage(argv);
122	break;
123	default:
124	usage(argv);
125	}
126	else if (listname == NULL)
127	listname = *arg;
128	else
129	usage(argv);
130	}
131	if (listname == NULL)
132	usage(argv);
133
134	/* if no other options specified, turn on list members flag */
135	if (!(infoflg \|\| syncflg \|\|
136	addlist->q_next != addlist \|\| dellist->q_next != dellist))
137	memberflg++;
138
139	/* fire up SMS */
140	if (status = sms_connect()) {
141	com_err(whoami, status, " unable to connect to SMS");
142	exit(2);
143	}
144	if (status = sms_auth("blanche")) {
145	com_err(whoami, status, " unable to authenticate to SMS");
146	exit(2);
147	}
148
149	/* display list info if requested to */
150	if (infoflg) {
151	status = sms_query("get_list_info", 1, &listname, show_list_info,NULL);
152	if (status)
153	com_err(whoami, status, " while getting list information");
154	if (verbose && !memberflg) {
155	status = sms_query("count_members_of_list", 1, &listname,
156	show_list_count, NULL);
157	if (status)
158	com_err(whoami, status, " while getting list count");
159	}
160	}
161
162	/* if we're synchronizing to a file, we need to:
163	* get the current members of the list
164	* for each member of the sync file
165	* if they are on the list, remove them from the in-memory copy
166	* if they're not on the list, add them to add-list
167	* if anyone is left on the in-memory copy, put them on the delete-list
168	* lastly, reset memberlist so we can use it again later
169	*/
170	if (syncflg) {
171	status = sms_query("get_members_of_list", 1, &listname,
172	get_list_members, memberlist);
173	if (status)
174	com_err(whoami, status, " while getting members of list");
175	while (sq_get_data(synclist, &memberstruct)) {
176	struct save_queue *q;
177	int removed = 0;
178
179	for (q = memberlist->q_next; q != memberlist; q = q->q_next) {
180	if (membermatch(q->q_data, memberstruct)) {
181	q->q_prev->q_next = q->q_next;
182	q->q_next->q_prev = q->q_prev;
183	removed++;
184	break;
185	}
186	}
187	if (!removed)
188	sq_save_data(addlist, memberstruct);
189	}
190	while (sq_get_data(memberlist, &memberstruct))
191	sq_save_data(dellist, memberstruct);
192	sq_destroy(memberlist);
193	memberlist = sq_create();
194	}
195
196	/* Process the add list */
197	while (sq_get_data(addlist, &memberstruct)) {
198	membervec[0] = listname;
199	membervec[2] = memberstruct->name;
200	switch (memberstruct->type) {
201	case M_ANY:
202	case M_USER:
203	membervec[1] = "USER";
204	status = sms_query("add_member_to_list", 3, membervec, scream, NULL);
205	if (status == SMS_SUCCESS)
206	break;
207	else if (status != SMS_USER \|\| memberstruct->type != M_ANY) {
208	com_err(whoami, status, " while adding member %s to %s",
209	memberstruct->name, listname);
210	break;
211	}
212	case M_LIST:
213	membervec[1] = "LIST";
214	status = sms_query("add_member_to_list", 3, membervec,
215	scream, NULL);
216	if (status == SMS_SUCCESS)
217	break;
218	else if (status != SMS_LIST \|\| memberstruct->type != M_ANY) {
219	com_err(whoami, status, " while adding member %s to %s",
220	memberstruct->name, listname);
221	break;
222	}
223	case M_STRING:
224	membervec[1] = "STRING";
225	status = sms_query("add_member_to_list", 3, membervec,
226	scream, NULL);
227	if (status != SMS_SUCCESS)
228	com_err(whoami, status, " while adding member %s to %s",
229	memberstruct->name, listname);
230	}
231	}
232
233	/* Process the delete list */
234	while (sq_get_data(dellist, &memberstruct)) {
235	membervec[0] = listname;
236	membervec[2] = memberstruct->name;
237	switch (memberstruct->type) {
238	case M_ANY:
239	case M_USER:
240	membervec[1] = "USER";
241	status = sms_query("delete_member_from_list", 3, membervec,
242	scream, NULL);
243	if (status == SMS_SUCCESS)
244	break;
245	else if ((status != SMS_USER && status != SMS_NO_MATCH) \|\|
246	memberstruct->type != M_ANY) {
247	com_err(whoami, status, " while deleteing member %s from %s",
248	memberstruct->name, listname);
249	break;
250	}
251	case M_LIST:
252	membervec[1] = "LIST";
253	status = sms_query("delete_member_from_list", 3, membervec,
254	scream, NULL);
255	if (status == SMS_SUCCESS)
256	break;
257	else if ((status != SMS_LIST && status != SMS_NO_MATCH) \|\|
258	memberstruct->type != M_ANY) {
259	com_err(whoami, status, " while deleteing member %s from %s",
260	memberstruct->name, listname);
261	break;
262	}
263	case M_STRING:
264	membervec[1] = "STRING";
265	status = sms_query("delete_member_from_list", 3, membervec,
266	scream, NULL);
267	if (status == SMS_STRING && memberstruct->type == M_ANY)
268	com_err(whoami, 0, "Unable to find member %s to delete from %s",
269	memberstruct->name, listname);
270	else if (status != SMS_SUCCESS)
271	com_err(whoami, status, " while deleteing member %s from %s",
272	memberstruct->name, listname);
273	}
274	}
275
276	/* Display the members of the list now, if requested */
277	if (memberflg) {
278	status = sms_query("get_members_of_list", 1, &listname,
279	get_list_members, memberlist);
280	if (status)
281	com_err(whoami, status, " while getting members of list");
282	while (sq_get_data(memberlist, &memberstruct)) {
283	if (verbose) {
284	char *s;
285	switch (memberstruct->type) {
286	case M_USER:
287	s = "USER";
288	break;
289	case M_LIST:
290	s = "LIST";
291	break;
292	case M_STRING:
293	s = "STRING";
294	break;
295	}
296	printf("%s: %s\n", s, memberstruct->name);
297	} else {
298	if (memberstruct->type == M_LIST)
299	printf("LIST:%s\n", memberstruct->name);
300	else if (memberstruct->type == M_STRING &&
301	!index(memberstruct->name, '@'))
302	printf("STRING:%s\n", memberstruct->name);
303	else
304	printf("%s\n", memberstruct->name);
305	}
306	}
307	}
308
309	/* We're done! */
310	sms_disconnect();
311	exit(0);
312	}
313
314	usage(argv)
315	char **argv;
316	{
317	printf("Usage: %s [-i] [-v] [-m] listname [-a member] [-d member] [-f file]\n",
318	argv[0]);
319	exit(1);
320	}
321
322
323	show_list_info(argc, argv, hint)
324	int argc;
325	char **argv;
326	int hint;
327	{
328	printf("List: %s\n", argv[0]);
329	printf("Description: %s\n", argv[9]);
330	printf("Flags: %s, %s, and %s\n",
331	atoi(argv[1]) ? "active" : "inactive",
332	atoi(argv[2]) ? "public" : "private",
333	atoi(argv[3]) ? "hidden" : "visible");
334	printf("%s is %sa maillist, and is %sa group", argv[0],
335	atoi(argv[4]) ? "" : "not ",
336	atoi(argv[5]) ? "" : "not ");
337	if (atoi(argv[5]))
338	printf(" with GID %d\n", atoi(argv[6]));
339	else
340	printf("\n");
341	printf("Owner: %s %s\n", argv[7], argv[8]);
342	printf("Last modified by %s with %s on %s\n", argv[11], argv[12], argv[10]);
343	return(SMS_CONT);
344	}
345
346
347	show_list_count(argc, argv, hint)
348	int argc;
349	char **argv;
350	int hint;
351	{
352	printf("Members: %s\n", argv[0]);
353	}
354
355
356	get_list_members(argc, argv, q)
357	int argc;
358	char **argv;
359	struct save_queue *q;
360	{
361	struct member *m;
362
363	m = (struct member *) malloc(sizeof(struct member));
364	switch (argv[0][0]) {
365	case 'U':
366	m->type = M_USER;
367	break;
368	case 'L':
369	m->type = M_LIST;
370	break;
371	case 'S':
372	m->type = M_STRING;
373	break;
374	}
375	m->name = strsave(argv[1]);
376	sq_save_data(q, m);
377	return(SMS_CONT);
378	}
379
380
381	scream()
382	{
383	fprintf(stderr, "Programmer botch\n");
384	exit(3);
385	}
386
387
388	struct member *parse_member(s)
389	register char *s;
390	{
391	register struct member *m;
392	char *p;
393
394	while (s && isspace(s))
395	s++;
396	p = s;
397	while (p && isprint(p) && !isspace(p) && p != ';')
398	p++;
399	*p = 0;
400	if (p == s \|\| strlen(s) == 0)
401	return(NULL);
402
403	if ((m = (struct member *) malloc(sizeof(struct member))) == NULL)
404	return(NULL);
405
406	if (p = index(s, ':')) {
407	*p = 0;
408	m->name = ++p;
409	if (!strcasecmp("user", s))
410	m->type = M_USER;
411	else if (!strcasecmp("list", s))
412	m->type = M_LIST;
413	else if (!strcasecmp("string", s))
414	m->type = M_STRING;
415	else {
416	m->type = M_STRING;
417	*(--p) = ':';
418	m->name = s;
419	}
420	m->name = strsave(m->name);
421	return(m);
422	}
423	m->name = strsave(s);
424	if (index(s, '@') \|\| index(s, '!') \|\| index(s, '%'))
425	m->type = M_STRING;
426	else
427	m->type = M_ANY;
428	return(m);
429	}
430
431
432	int membermatch(m1, m2)
433	struct member m1, m2;
434	{
435	if (strcmp(m1->name, m2->name))
436	return(0);
437	if (m1->type == M_ANY \|\| m2->type == M_ANY)
438	return(1);
439	if (m1->type == m2->type)
440	return(1);
441	else
442	return(0);
443	}