[moira.git] / server / qrtn.qc

#include "query.h"
#include "sms_private.h"
#include "sms_server.h"

char *Argv[16];

static int ingres_errno = 0;

static ingerr(num)
	int *num;
{
	ingres_errno = SMS_INGRES_ERR; /* "Process lacks permission to */
				       /* alter device status.." */
	return *num;
}

sms_open_database()
{
	register int i;

	/* initialize local argv */
	for (i = 0; i < 16; i++)
		Argv[i] = (char *)malloc(128);

	IIseterr(ingerr);
	
	ingres_errno = 0;
	
	/* open the database */
##	ingres sms
	return ingres_errno;
}

sms_close_database()
{
##	exit
}

sms_process_query(name, argc, argv_ro, action, actarg)
	char *name;
	int argc;
	char *argv_ro[];
	int (*action)();
	char *actarg;
{
	register struct query *q;
	register int i;
	struct query *get_query_by_name();
	char qual[128];

	/* copy the arguments into a local argv that we can modify */
	for (i = 0; i < argc; i++)
		strcpy(Argv[i], argv_ro[i]);

	q = get_query_by_name(name);

	switch (q->type) {
	case RETRIEVE:
		if (q->qual) {
			build_qual(q->qual, q->argc, Argv, qual);
			do_retrieve_with_qual(q, qual, action, actarg);
		} else
			do_retrieve(q, action, actarg);
		break;

	case UPDATE:
		if (q->support_rtn) {
			if ((*q->support_rtn)(Argv, action, actarg) == -1) 
			  break;
		}
		build_qual(q->qual, q->argc, &Argv[q->sargc], qual);
		do_update(q, &Argv[q->sargc + q->argc], qual, action, actarg);
		break;

	case APPEND:
		if (q->support_rtn) {
			if ((*q->support_rtn)(Argv, action, actarg) == -1) 
			  break;
		}
		do_append(q, &Argv[q->sargc + q->argc], action, actarg);
		break;

	case DELETE:
		if (q->support_rtn) {
			if ((*q->support_rtn)(Argv, action, actarg) == -1) 
			  break;
		}
		build_qual(q->qual, q->argc, &Argv[q->sargc], qual);
		do_delete(q, qual, action, actarg);
		break;
	}
}

build_qual(fmt, argc, argv, qual)
	char *fmt;
	int argc;
	char *argv[];
	char *qual;
{
	switch (argc) {
	case 0:
		strcpy(qual, fmt);
		break;

	case 1:
		sprintf(qual, fmt, argv[0]);
		break;

	case 2:
		sprintf(qual, fmt, argv[0], argv[1]);
		break;

	case 3:
		sprintf(qual, fmt, argv[0], argv[1], argv[2]);
		break;

	case 4:
		sprintf(qual, fmt, argv[0], argv[1], argv[2], argv[3]);
		break;
	}
}

do_retrieve(q, action, actarg)
	register struct query *q;
	int (*action)();
        char *actarg;
## {
##	char *rvar;
##	char *rtable;
##	int rowcount;
	char status[32];
	char *sp = status;

	if (q->rvar) {
		rvar = q->rvar;
		rtable = q->rtable;
##		range of rvar is rtable
	}

##	retrieve (param (q->tlist, q->vaddr))
##    	{
	       if (q->support_rtn)
		       /* save result */
		       (*q->support_rtn)(q->vcnt, q->vaddr, 0, 0); 
	       else
		       (*action)(q->vcnt, q->vaddr, actarg);
## 	}

## 	inquire_equel (rowcount = "rowcount")

	if (q->support_rtn) {
		/* process and send saved results */
		(*q->support_rtn)(0, 0, &q->vnames[q->argc], action, actarg);
	}

#ifdef notdef
	sprintf(status, "(%d row%s)", rowcount, (rowcount == 1)? "" : "s");
	(*action)(1, &sp, actarg);
#endif notdef
## }

do_retrieve_with_qual(q, qual, action, actarg)
	register struct query *q;
	char *qual;
	int (*action)();
        char *actarg;
## {
##	char *rvar;
##	char *rtable;
##	char *cqual;
##	int rowcount;
	char status[32];
	char *sp = status;
      
	if (q->rvar) {
		rvar = q->rvar;
		rtable = q->rtable;
##		range of rvar is rtable
	}

	cqual = qual;
##	retrieve (param (q->tlist, q->vaddr))
##      where cqual
##    	{
		if (q->support_rtn)
			(*q->support_rtn)(q->vcnt, q->vaddr, 0, 0);
		else
			(*action)(q->vcnt, q->vaddr, actarg);
##    	}

##    	inquire_equel (rowcount = "rowcount")

	if (q->support_rtn) {
		(*q->support_rtn)(0, 0, &q->vnames[q->argc], action, actarg);
	}

#ifdef notdef
	sprintf(status, "(%d row%s)", rowcount, (rowcount == 1)? "" : "s");
	(*action)(1, &sp, actarg);
#endif notdef
## }

do_update(q, argv, qual, action, actarg)
	register struct query *q;
	char *argv[];
	char *qual;
	int (*action)();
        char *actarg;
## {
##    char *rvar;
##    char *rtable;
##    char *cqual;
##    int rowcount;
	char status[32];
	char *sp = status;
      
	rvar = q->rvar;
	rtable = q->rtable;
##	range of rvar is rtable

	cqual = qual;
##	replace rvar (param (q->tlist, argv))
##      where cqual

##    	inquire_equel (rowcount = "rowcount")
	sprintf(status, "(%d row%s)", rowcount, (rowcount == 1)? "" : "s");
	(*action)(1, &sp, actarg);
## }

do_append(q, argv, action, actarg)
	register struct query *q;
	char *argv[];
	int (*action)();
        char *actarg;
## {
##    	char *rvar;
##	char *rtable;
##    	int rowcount;
	char status[32];
	char *sp = status;

	rvar = q->rvar;
	rtable = q->rtable;
##      range of rvar is rtable

##      append to rtable (param (q->tlist, argv))

#ifdef notdef
##      inquire_equel (rowcount = "rowcount")
	sprintf(status, "(%d row%s)", rowcount, (rowcount == 1)? "" : "s");
	(*action)(1, &sp, actarg);
#endif notdef
## }

do_delete(q, qual, action, actarg)
	register struct query *q;
	char *qual;
	int (*action)();
        char *actarg;
## {
##      char *rvar;
##      char *rtable;
##      char *cqual;
##      int rowcount;
	char status[32];
	char *sp = status;

	rvar = q->rvar;
	rtable = q->rtable;
##      range of rvar is rtable

	cqual = qual;
##      delete rvar where cqual

#ifdef notdef
##      inquire_equel (rowcount = "rowcount")
	sprintf(status, "(%d row%s)", rowcount, (rowcount == 1)? "" : "s");
	(*action)(1, &sp, actarg);
#endif notdef
## }

/* Support Queries */

support_alis(argv, action, actarg)
	char *argv[];
	int (*action)();
        char *actarg;
## {
##	static int list_id;

##	range of tbi is tbinfo

##	repeat retrieve (list_id = tbi.value1) where tbi.table = "list"
	list_id++;
##	repeat replace tbi (value1 = @list_id) where tbi.table = "list"

	argv[0] = (char *)&list_id;
## }

/**
 ** support_member():
 **
 ** support for ADD_MEMBER_TO_LIST
 ** support for DELETE_MEMBER_FROM_LIST
 ** support for UPDATE_MEMBER_STATUS
 **
 **           Input                     Output
 ** argv[0]   List Type       argv[4]   List ID
 ** argv[1]   List Name       argv[5]   Member ID
 ** argv[2]   Member Type     argv[6]   Member Type
 ** argv[3]   Member Name
 **/

support_member(argv, action, actarg)
	char *argv[];
	int (*action)();
        char *actarg;
## {
##    char *list_name;
##    char *list_type;
##    char *member_name;
##    char *member_type;
##    int list_id;
##    int value;
##    int rowcount;
      char errmsg[64];
      char *p_errmsg = errmsg;

      list_type = argv[0];
      list_name = argv[1];
      member_type = argv[2];
      member_name = argv[3];

##    range of l is list
##    repeat retrieve (list_id = l.id) 
##        where l.name = @list_name and l.type = @list_type
      sprintf(argv[4], "%d", list_id);

      if (!strcmp(member_type, "acl") || !strcmp(member_type, "group") ||
	  !strcmp(member_type, "mail")) {
##	  repeat retrieve (value = l.id)
##            where l.name = @member_name and l.type = @member_type
##	  inquire_equel (rowcount = "rowcount")
	  if (rowcount == 0) {
	      sprintf(errmsg, "(No such list: %s)", member_name);
	      (*action)(1, p_errmsg, actarg);
	      return(-1);
	    }
	} else if (!strcmp(member_type, "user")) {
##        range of u is users
##        repeat retrieve (value = u.id) where u.login = @member_name
##	  inquire_equel (rowcount = "rowcount")
	  if (rowcount == 0) {
	      sprintf(errmsg, "(No such user: %s)", member_name);
	      (*action)(1, p_errmsg, actarg);
	      return(-1);
	    }
	} else if (!strcmp(member_type, "string")) {
##	  range of s is strings
##	  repeat retrieve (value = s.id) where s.string = @member_name
##        inquire_equel (rowcount = "rowcount")
	  if (rowcount == 0) {
##            range of tbi is tbinfo
##            retrieve (value = tbi.value1) where tbi.table = "strings"
	      value++;
##            replace tbi (value1 = value) where tbi.table = "strings"
##	      append to strings (id = value, string = member_name)
	    }
	} else {
	  sprintf(errmsg, "(Unknown member type: %s)", member_type);
	  (*action)(1, p_errmsg, actarg);
	  return(-1);
	}

      sprintf(argv[5], "%d", value);
      strcpy(argv[6], member_type);
## }

/**
 ** support for GET_LIST_MEMBERS
 **
 **           Input           Output
 ** argv[0]   Member Type     Member Type
 ** argv[1]   Member Id       Member Name (ACL, Group, Maillist, User, String)
 ** argv[2]   Member Status   Member Status
 **
 ** This routine performs two functions:
 **   When called with argc > 0, it copies and saves argv in a queue
 **   When called with argc = 0, it does post-processing on the saved
 **     data, and sends the data to the client using the supplied action
 **     routine.
 **/

support_gmol(argc, argv, vnames, action, actarg)
	int argc;
	char *argv[];
	char *vnames[];
	int (*action)();
        char *actarg;
## {
##      char *member_type;
##      int member_id;
##      char member_name[33];
	char **sargv;
	char *nargv[3];
	register int n;
	static struct save_queue *sq = (struct save_queue *)0;
	struct save_queue *sq_create();

	if (argc > 0) {
		if (sq == (struct save_queue *)0) {
			sq = sq_create();
		}
		sargv = (char **)malloc(3 * sizeof (char *));
		/* copy member_type */
		n = strlen(argv[0]) + 1;
		sargv[0] = (char *)malloc(n);
		bcopy(argv[0], sargv[0], n);
		/* copy member_id */
		sargv[1] = (char *)malloc(sizeof (int));
		*(int *)sargv[1] = *(int *)argv[1];
		/* copy member_status */
		n = strlen(argv[2]) + 1;
		sargv[2] = (char *)malloc(n);
		bcopy(argv[2], sargv[2], n);
		/* store data */
		sq_save_data(sq, sargv);
		return;
	}

	while (sq_get_data(sq, &sargv)) {
		member_type = sargv[0];
		member_id = *(int *)sargv[1];

		nargv[0] = member_type;
		nargv[1] = member_name;
		nargv[2] = sargv[2];

		if (!strcmp(member_type, "acl") ||
		    !strcmp(member_type, "group") ||
		    !strcmp(member_type, "mail")) {
##              	range of l is list
##            		repeat retrieve (member_name = l.name)
##			where l.id = @member_id
	        } else if (!strcmp(member_type, "user")) {
##	      		range of u is users
##	      		repeat retrieve (member_name = u.login) 
##				where u.id = @member_id
		} else if (!strcmp(member_type, "string")) {
##	      		range of s is strings
##	      		repeat retrieve (member_name = s.string)
##			where s.id = @member_id
		} else {
			sprintf(member_name, "%d", member_id);
		}

		(*action)(3, nargv, vnames, actarg);
		free(sargv[0]);
		free(sargv[1]);
		free(sargv[2]);
	}

	sq_destroy(sq);
	sq = (struct save_queue *)0;
## }
Commit	Line	Data
97479f6f	1	#include "query.h"
	2	#include "sms_private.h"
	3	#include "sms_server.h"
	4
	5	char *Argv[16];
	6
	7	static int ingres_errno = 0;
	8
	9	static ingerr(num)
	10	int *num;
	11	{
	12	ingres_errno = SMS_INGRES_ERR; /* "Process lacks permission to */
	13	/* alter device status.." */
	14	return *num;
	15	}
	16
	17	sms_open_database()
	18	{
	19	register int i;
	20
	21	/* initialize local argv */
	22	for (i = 0; i < 16; i++)
	23	Argv[i] = (char *)malloc(128);
	24
	25	IIseterr(ingerr);
	26
	27	ingres_errno = 0;
	28
	29	/* open the database */
	30	## ingres sms
	31	return ingres_errno;
	32	}
	33
	34	sms_close_database()
	35	{
	36	## exit
	37	}
	38
	39	sms_process_query(name, argc, argv_ro, action, actarg)
	40	char *name;
	41	int argc;
	42	char *argv_ro[];
	43	int (*action)();
	44	char *actarg;
	45	{
	46	register struct query *q;
	47	register int i;
	48	struct query *get_query_by_name();
	49	char qual[128];
	50
	51	/* copy the arguments into a local argv that we can modify */
	52	for (i = 0; i < argc; i++)
	53	strcpy(Argv[i], argv_ro[i]);
	54
	55	q = get_query_by_name(name);
	56
	57	switch (q->type) {
	58	case RETRIEVE:
	59	if (q->qual) {
	60	build_qual(q->qual, q->argc, Argv, qual);
e38c941b	61	do_retrieve_with_qual(q, qual, action, actarg);
97479f6f	62	} else
e38c941b	63	do_retrieve(q, action, actarg);
97479f6f	64	break;
	65
	66	case UPDATE:
	67	if (q->support_rtn) {
e38c941b	68	if ((*q->support_rtn)(Argv, action, actarg) == -1)
e38c941b	69	break;
97479f6f	70	}
97479f6f	71	build_qual(q->qual, q->argc, &Argv[q->sargc], qual);
e38c941b	72	do_update(q, &Argv[q->sargc + q->argc], qual, action, actarg);
97479f6f	73	break;
	74
	75	case APPEND:
	76	if (q->support_rtn) {
e38c941b	77	if ((*q->support_rtn)(Argv, action, actarg) == -1)
e38c941b	78	break;
97479f6f	79	}
e38c941b	80	do_append(q, &Argv[q->sargc + q->argc], action, actarg);
97479f6f	81	break;
	82
	83	case DELETE:
	84	if (q->support_rtn) {
e38c941b	85	if ((*q->support_rtn)(Argv, action, actarg) == -1)
e38c941b	86	break;
97479f6f	87	}
97479f6f	88	build_qual(q->qual, q->argc, &Argv[q->sargc], qual);
e38c941b	89	do_delete(q, qual, action, actarg);
97479f6f	90	break;
	91	}
	92	}
	93
	94	build_qual(fmt, argc, argv, qual)
	95	char *fmt;
	96	int argc;
	97	char *argv[];
	98	char *qual;
	99	{
	100	switch (argc) {
	101	case 0:
	102	strcpy(qual, fmt);
	103	break;
	104
	105	case 1:
	106	sprintf(qual, fmt, argv[0]);
	107	break;
	108
	109	case 2:
	110	sprintf(qual, fmt, argv[0], argv[1]);
	111	break;
	112
	113	case 3:
	114	sprintf(qual, fmt, argv[0], argv[1], argv[2]);
	115	break;
	116
	117	case 4:
	118	sprintf(qual, fmt, argv[0], argv[1], argv[2], argv[3]);
	119	break;
	120	}
	121	}
	122
e38c941b	123	do_retrieve(q, action, actarg)
97479f6f	124	register struct query *q;
97479f6f	125	int (*action)();
e38c941b	126	char *actarg;
97479f6f	127	## {
	128	## char *rvar;
	129	## char *rtable;
	130	## int rowcount;
	131	char status[32];
	132	char *sp = status;
	133
	134	if (q->rvar) {
	135	rvar = q->rvar;
	136	rtable = q->rtable;
	137	## range of rvar is rtable
	138	}
	139
	140	## retrieve (param (q->tlist, q->vaddr))
	141	## {
	142	if (q->support_rtn)
	143	/* save result */
	144	(*q->support_rtn)(q->vcnt, q->vaddr, 0, 0);
	145	else
e38c941b	146	(*action)(q->vcnt, q->vaddr, actarg);
97479f6f	147	## }
	148
	149	## inquire_equel (rowcount = "rowcount")
	150
	151	if (q->support_rtn) {
	152	/* process and send saved results */
e38c941b	153	(*q->support_rtn)(0, 0, &q->vnames[q->argc], action, actarg);
97479f6f	154	}
97479f6f	155
9abe7bc4	156	#ifdef notdef
97479f6f	157	sprintf(status, "(%d row%s)", rowcount, (rowcount == 1)? "" : "s");
e38c941b	158	(*action)(1, &sp, actarg);
9abe7bc4	159	#endif notdef
97479f6f	160	## }
97479f6f	161
e38c941b	162	do_retrieve_with_qual(q, qual, action, actarg)
97479f6f	163	register struct query *q;
	164	char *qual;
	165	int (*action)();
e38c941b	166	char *actarg;
97479f6f	167	## {
	168	## char *rvar;
	169	## char *rtable;
	170	## char *cqual;
	171	## int rowcount;
	172	char status[32];
	173	char *sp = status;
	174
	175	if (q->rvar) {
	176	rvar = q->rvar;
	177	rtable = q->rtable;
	178	## range of rvar is rtable
	179	}
	180
	181	cqual = qual;
	182	## retrieve (param (q->tlist, q->vaddr))
	183	## where cqual
	184	## {
	185	if (q->support_rtn)
	186	(*q->support_rtn)(q->vcnt, q->vaddr, 0, 0);
	187	else
e38c941b	188	(*action)(q->vcnt, q->vaddr, actarg);
97479f6f	189	## }
	190
	191	## inquire_equel (rowcount = "rowcount")
	192
	193	if (q->support_rtn) {
e38c941b	194	(*q->support_rtn)(0, 0, &q->vnames[q->argc], action, actarg);
97479f6f	195	}
97479f6f	196
9abe7bc4	197	#ifdef notdef
97479f6f	198	sprintf(status, "(%d row%s)", rowcount, (rowcount == 1)? "" : "s");
e38c941b	199	(*action)(1, &sp, actarg);
9abe7bc4	200	#endif notdef
97479f6f	201	## }
97479f6f	202
e38c941b	203	do_update(q, argv, qual, action, actarg)
97479f6f	204	register struct query *q;
	205	char *argv[];
	206	char *qual;
	207	int (*action)();
e38c941b	208	char *actarg;
97479f6f	209	## {
	210	## char *rvar;
	211	## char *rtable;
	212	## char *cqual;
	213	## int rowcount;
	214	char status[32];
	215	char *sp = status;
	216
	217	rvar = q->rvar;
	218	rtable = q->rtable;
	219	## range of rvar is rtable
	220
	221	cqual = qual;
	222	## replace rvar (param (q->tlist, argv))
	223	## where cqual
	224
	225	## inquire_equel (rowcount = "rowcount")
	226	sprintf(status, "(%d row%s)", rowcount, (rowcount == 1)? "" : "s");
e38c941b	227	(*action)(1, &sp, actarg);
97479f6f	228	## }
97479f6f	229
e38c941b	230	do_append(q, argv, action, actarg)
97479f6f	231	register struct query *q;
	232	char *argv[];
	233	int (*action)();
e38c941b	234	char *actarg;
97479f6f	235	## {
	236	## char *rvar;
	237	## char *rtable;
	238	## int rowcount;
	239	char status[32];
	240	char *sp = status;
	241
	242	rvar = q->rvar;
	243	rtable = q->rtable;
	244	## range of rvar is rtable
	245
	246	## append to rtable (param (q->tlist, argv))
	247
9abe7bc4	248	#ifdef notdef
97479f6f	249	## inquire_equel (rowcount = "rowcount")
97479f6f	250	sprintf(status, "(%d row%s)", rowcount, (rowcount == 1)? "" : "s");
e38c941b	251	(*action)(1, &sp, actarg);
9abe7bc4	252	#endif notdef
97479f6f	253	## }
97479f6f	254
e38c941b	255	do_delete(q, qual, action, actarg)
97479f6f	256	register struct query *q;
	257	char *qual;
	258	int (*action)();
e38c941b	259	char *actarg;
97479f6f	260	## {
	261	## char *rvar;
	262	## char *rtable;
	263	## char *cqual;
	264	## int rowcount;
	265	char status[32];
	266	char *sp = status;
	267
	268	rvar = q->rvar;
	269	rtable = q->rtable;
	270	## range of rvar is rtable
	271
	272	cqual = qual;
	273	## delete rvar where cqual
	274
9abe7bc4	275	#ifdef notdef
97479f6f	276	## inquire_equel (rowcount = "rowcount")
97479f6f	277	sprintf(status, "(%d row%s)", rowcount, (rowcount == 1)? "" : "s");
e38c941b	278	(*action)(1, &sp, actarg);
9abe7bc4	279	#endif notdef
97479f6f	280	## }
	281
	282	/* Support Queries */
	283
e38c941b	284	support_alis(argv, action, actarg)
97479f6f	285	char *argv[];
97479f6f	286	int (*action)();
e38c941b	287	char *actarg;
97479f6f	288	## {
	289	## static int list_id;
	290
	291	## range of tbi is tbinfo
	292
	293	## repeat retrieve (list_id = tbi.value1) where tbi.table = "list"
	294	list_id++;
	295	## repeat replace tbi (value1 = @list_id) where tbi.table = "list"
	296
	297	argv[0] = (char *)&list_id;
	298	## }
	299
	300	/**
	301	** support_member():
	302	**
	303	** support for ADD_MEMBER_TO_LIST
	304	** support for DELETE_MEMBER_FROM_LIST
	305	** support for UPDATE_MEMBER_STATUS
	306	**
	307	** Input Output
	308	** argv[0] List Type argv[4] List ID
	309	** argv[1] List Name argv[5] Member ID
	310	** argv[2] Member Type argv[6] Member Type
	311	** argv[3] Member Name
	312	**/
	313
e38c941b	314	support_member(argv, action, actarg)
97479f6f	315	char *argv[];
97479f6f	316	int (*action)();
e38c941b	317	char *actarg;
97479f6f	318	## {
	319	## char *list_name;
	320	## char *list_type;
	321	## char *member_name;
	322	## char *member_type;
	323	## int list_id;
	324	## int value;
	325	## int rowcount;
	326	char errmsg[64];
	327	char *p_errmsg = errmsg;
	328
	329	list_type = argv[0];
	330	list_name = argv[1];
	331	member_type = argv[2];
	332	member_name = argv[3];
	333
	334	## range of l is list
	335	## repeat retrieve (list_id = l.id)
	336	## where l.name = @list_name and l.type = @list_type
	337	sprintf(argv[4], "%d", list_id);
	338
	339	if (!strcmp(member_type, "acl") \|\| !strcmp(member_type, "group") \|\|
	340	!strcmp(member_type, "mail")) {
	341	## repeat retrieve (value = l.id)
	342	## where l.name = @member_name and l.type = @member_type
	343	## inquire_equel (rowcount = "rowcount")
	344	if (rowcount == 0) {
	345	sprintf(errmsg, "(No such list: %s)", member_name);
e38c941b	346	(*action)(1, p_errmsg, actarg);
97479f6f	347	return(-1);
	348	}
	349	} else if (!strcmp(member_type, "user")) {
	350	## range of u is users
	351	## repeat retrieve (value = u.id) where u.login = @member_name
	352	## inquire_equel (rowcount = "rowcount")
	353	if (rowcount == 0) {
	354	sprintf(errmsg, "(No such user: %s)", member_name);
e38c941b	355	(*action)(1, p_errmsg, actarg);
97479f6f	356	return(-1);
	357	}
	358	} else if (!strcmp(member_type, "string")) {
	359	## range of s is strings
	360	## repeat retrieve (value = s.id) where s.string = @member_name
	361	## inquire_equel (rowcount = "rowcount")
	362	if (rowcount == 0) {
	363	## range of tbi is tbinfo
	364	## retrieve (value = tbi.value1) where tbi.table = "strings"
	365	value++;
	366	## replace tbi (value1 = value) where tbi.table = "strings"
	367	## append to strings (id = value, string = member_name)
	368	}
	369	} else {
	370	sprintf(errmsg, "(Unknown member type: %s)", member_type);
e38c941b	371	(*action)(1, p_errmsg, actarg);
97479f6f	372	return(-1);
	373	}
	374
	375	sprintf(argv[5], "%d", value);
	376	strcpy(argv[6], member_type);
	377	## }
	378
	379	/**
	380	** support for GET_LIST_MEMBERS
	381	**
	382	** Input Output
	383	** argv[0] Member Type Member Type
	384	** argv[1] Member Id Member Name (ACL, Group, Maillist, User, String)
	385	** argv[2] Member Status Member Status
	386	**
	387	** This routine performs two functions:
	388	** When called with argc > 0, it copies and saves argv in a queue
	389	** When called with argc = 0, it does post-processing on the saved
	390	** data, and sends the data to the client using the supplied action
	391	** routine.
	392	**/
	393
e38c941b	394	support_gmol(argc, argv, vnames, action, actarg)
97479f6f	395	int argc;
	396	char *argv[];
	397	char *vnames[];
	398	int (*action)();
e38c941b	399	char *actarg;
97479f6f	400	## {
	401	## char *member_type;
	402	## int member_id;
	403	## char member_name[33];
	404	char **sargv;
	405	char *nargv[3];
	406	register int n;
	407	static struct save_queue sq = (struct save_queue )0;
	408	struct save_queue *sq_create();
	409
	410	if (argc > 0) {
	411	if (sq == (struct save_queue *)0) {
	412	sq = sq_create();
	413	}
	414	sargv = (char *)malloc(3 sizeof (char *));
	415	/* copy member_type */
	416	n = strlen(argv[0]) + 1;
	417	sargv[0] = (char *)malloc(n);
	418	bcopy(argv[0], sargv[0], n);
	419	/* copy member_id */
	420	sargv[1] = (char *)malloc(sizeof (int));
	421	(int )sargv[1] = (int )argv[1];
	422	/* copy member_status */
	423	n = strlen(argv[2]) + 1;
	424	sargv[2] = (char *)malloc(n);
	425	bcopy(argv[2], sargv[2], n);
	426	/* store data */
	427	sq_save_data(sq, sargv);
	428	return;
	429	}
	430
	431	while (sq_get_data(sq, &sargv)) {
	432	member_type = sargv[0];
	433	member_id = (int )sargv[1];
	434
	435	nargv[0] = member_type;
	436	nargv[1] = member_name;
	437	nargv[2] = sargv[2];
	438
	439	if (!strcmp(member_type, "acl") \|\|
	440	!strcmp(member_type, "group") \|\|
	441	!strcmp(member_type, "mail")) {
	442	## range of l is list
	443	## repeat retrieve (member_name = l.name)
	444	## where l.id = @member_id
	445	} else if (!strcmp(member_type, "user")) {
	446	## range of u is users
e38c941b	447	## repeat retrieve (member_name = u.login)
e38c941b	448	## where u.id = @member_id
97479f6f	449	} else if (!strcmp(member_type, "string")) {
	450	## range of s is strings
	451	## repeat retrieve (member_name = s.string)
	452	## where s.id = @member_id
	453	} else {
	454	sprintf(member_name, "%d", member_id);
	455	}
	456
e38c941b	457	(*action)(3, nargv, vnames, actarg);
97479f6f	458	free(sargv[0]);
	459	free(sargv[1]);
	460	free(sargv[2]);
	461	}
	462
	463	sq_destroy(sq);
	464	sq = (struct save_queue *)0;
	465	## }