[moira.git] / server / qrtn.qc

/*
 *	$Source$
 *	$Author$
 *	$Header$
 *
 *	Copyright (C) 1987 by the Massachusetts Institute of Technology
 *
 *	$Log$
 *	Revision 1.4  1987-06-08 05:03:27  wesommer
 *	Reindented; added header and trailer.
 *
 */

#ifndef lint
static char *rcsid_qrtn_qc = "$Header$";
#endif lint

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

char *Argv[16];

static int ingres_errno = 0;

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

static int ingerr(num)
    int *num;
{
    ingres_errno = SMS_INGRES_ERR;
    return *num;
}

int 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;
}

int 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;

    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);
    }

##}

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;
      
    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);
    }

##}

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;
      
    rvar = q->rvar;
    rtable = q->rtable;
##  range of rvar is rtable

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

##}

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

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

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

##}

do_delete(q, qual, action, actarg)
    register struct query *q;
    char *qual;
    int (*action)();
    char *actarg;
##{
##  char *rvar;
##  char *rtable;
##  char *cqual;

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

    cqual = qual;
##  delete rvar where cqual

##}

/* 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);
    return(0);
##}

/**
 ** 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;
##}

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