[moira.git] / server / mr_scall.c

/*
 *	$Source$
 *	$Author$
 *	$Header$
 *
 *	Copyright (C) 1987 by the Massachusetts Institute of Technology
 *
 *	$Log$
 *	Revision 1.6  1987-06-30 20:04:43  wesommer
 *	Free returned tuples when possible.
 *
 * Revision 1.5  87/06/26  10:55:53  wesommer
 * Added sms_access, now paiys attention to return code from 
 * sms_process_query, sms_check_access.
 * 
 * Revision 1.4  87/06/21  16:42:00  wesommer
 * Performance work, rearrangement of include files.
 * 
 * Revision 1.3  87/06/04  01:35:01  wesommer
 * Added a working query request handler.
 * 
 * Revision 1.2  87/06/03  16:07:50  wesommer
 * Fixes for lint.
 * 
 * Revision 1.1  87/06/02  20:07:10  wesommer
 * Initial revision
 * 
 */

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

#include <krb.h>
#include <errno.h>
#include "sms_server.h"
extern char buf1[];
extern int nclients;
extern char *whoami;

extern void clist_delete(), do_auth(), do_shutdown();
void do_call();

/*
 * Welcome to the (finite state) machine (highest level).
 */
void
do_client(cp)
	client *cp;
{
	free_rtn_tuples(cp);
	if (OP_STATUS(cp->pending_op) == OP_CANCELLED) {
		(void) sprintf(buf1, "Closed connection (now %d client%s)",
			       nclients-1,
			       nclients!=2?"s":"");
		com_err(whoami, 0, buf1);
		clist_delete(cp);
		return;
	}
	switch (cp->action) {
	case CL_ACCEPT:
	case CL_SEND:
		/* Start recieving next request */
		initialize_operation(cp->pending_op, sms_start_recv,
				     (char *)&cp->args, (int (*)())NULL);
		queue_operation(cp->con, CON_INPUT, cp->pending_op);
		cp->action = CL_RECEIVE;
		break;
	case CL_RECEIVE:
		/* Data is here. Process it & start it heading back */
		do_call(cp); /* This may block for a while. */
		initialize_operation(cp->pending_op, sms_start_send,
				     (char *)&cp->reply, (int (*)())NULL);
		queue_operation(cp->con, CON_OUTPUT, cp->pending_op);
		cp->action = CL_SEND;
		break;
	}
}		

#ifdef notdef
char *procnames[] = {
	 "noop",
	 "auth",
	 "shutdown",
	 "query",
	 };
#endif notdef

void
do_call(cl)
	client *cl;
{
	int pn;
	cl->reply.sms_argc = 0;
	cl->reply.sms_status = 0;
	if (((pn = cl->args->sms_procno) < 0) ||
	    (pn > SMS_MAX_PROC)) {
		com_err(whoami, 0, "procno out of range");
		cl->reply.sms_status = SMS_UNKNOWN_PROC;
		return;
	}
#ifdef SMS_DBG
	fprintf(stderr, "[#%d] %s(", cl->id, procnames[pn]);
	for (i=0; i < cl->args->sms_argc; i++) {
		if (i) fputc(',', stderr);
		frequote(stderr,cl->args->sms_argv[i]);
	}
	fprintf(stderr, ")\n");
#endif SMS_DBG

	switch(pn) {
	case SMS_NOOP:
		cl->reply.sms_status = 0;
		com_err(whoami, 0, "noop");
		return;

	case SMS_AUTH:
		do_auth(cl);
		return;

	case SMS_QUERY:
		do_retr(cl);
		return;

	case SMS_ACCESS:
		do_access(cl);
		return;
		
	case SMS_SHUTDOWN:
		do_shutdown(cl);
		return;
	}
}

free_rtn_tuples(cp)
	client *cp;
{
	register returned_tuples *temp;
	for (temp=cp->first; temp && OP_DONE(temp->op); ) {
		register returned_tuples *t1=temp;
		temp = t1->next;
		if (t1 == cp->last) cp->last = NULL;
#ifdef notdef
		sms_destroy_reply(t1->retval);
#endif notdef
		if (t1->retval) {
			register sms_params *p = t1->retval;
			if (p->sms_flattened)
				free(p->sms_flattened);
			if (p->sms_argl)
				free(p->sms_argl);
			free(p);
		}
		delete_operation(t1->op);
		free(t1);
	}
	cp->first = temp;
}	

retr_callback(argc, argv, p_cp)
	int argc;
	char **argv;
	char *p_cp;
{
	register client *cp = (client *)p_cp;
	/*
	 * This takes too much advantage of the fact that
	 * serialization of the data happens during the queue operation.
	 */
	sms_params *arg_tmp = (sms_params *)db_alloc(sizeof(sms_params));
	returned_tuples *tp = (returned_tuples *)
		db_alloc(sizeof(returned_tuples));
	
	OPERATION op_tmp = create_operation();

#ifdef notdef			/* We really don't want this logged */
	com_err(whoami, 0, "Returning next data:");
	log_args(argc, argv);
#endif notdef
	tp->op = op_tmp;
	tp->retval = arg_tmp;
	tp->next = NULL;
	
	arg_tmp->sms_status = SMS_MORE_DATA;
	arg_tmp->sms_argc = argc;
	arg_tmp->sms_argv = argv;
	arg_tmp->sms_flattened = (char *)NULL;
	arg_tmp->sms_argl = (int *)NULL;

	if (cp->last) {
		cp->last->next = tp;
		cp->last = tp;
	} else {
		cp->last = cp->first = tp;
	}
	
	reset_operation(op_tmp);
	initialize_operation(op_tmp, sms_start_send, (char *)arg_tmp,
			     (int (*)())NULL);
	queue_operation(cp->con, CON_OUTPUT, op_tmp);
}


do_retr(cl)
	client *cl;
{
	cl->reply.sms_argc = 0;
	cl->reply.sms_status = 0;
#ifdef notdef
	if (!cl->clname) {
		com_err(whoami, 0, "Unauthenticated query rejected");
		cl->reply.sms_status = EACCES;
		return;
	}
#endif notdef
	com_err(whoami, 0, "Processing query: ");
	log_args(cl->args->sms_argc, cl->args->sms_argv);
	
	cl->reply.sms_status = 
	  sms_process_query(cl,
			    cl->args->sms_argv[0],
			    cl->args->sms_argc-1,
			    cl->args->sms_argv+1,
			    retr_callback,
			    (char *)cl);

	com_err(whoami, 0, "Query complete.");
}

do_access(cl)
	client *cl;
{
	cl->reply.sms_argc = 0;
	cl->reply.sms_status = 0;
#ifdef notdef
	if (!cl->clname) {
		com_err(whoami, 0, "Unauthenticated query rejected");
		cl->reply.sms_status = EACCES;
		return;
	}
#endif notdef
	com_err(whoami, 0, "Checking access: ");
	log_args(cl->args->sms_argc, cl->args->sms_argv);
	
	cl->reply.sms_status = 
	  sms_check_access(cl,
			   cl->args->sms_argv[0],
			   cl->args->sms_argc-1,
			   cl->args->sms_argv+1);
	
	com_err(whoami, 0, "Access check complete.");
}
Commit	Line	Data
a3cf6921	1	/*
	2	* $Source$
	3	* $Author$
	4	* $Header$
	5	*
	6	* Copyright (C) 1987 by the Massachusetts Institute of Technology
	7	*
	8	* $Log$
ed31e0d1	9	* Revision 1.6 1987-06-30 20:04:43 wesommer
ed31e0d1	10	* Free returned tuples when possible.
a3cf6921	11	*
ed31e0d1	12	* Revision 1.5 87/06/26 10:55:53 wesommer
	13	* Added sms_access, now paiys attention to return code from
	14	* sms_process_query, sms_check_access.
	15	*
3630192b	16	* Revision 1.4 87/06/21 16:42:00 wesommer
	17	* Performance work, rearrangement of include files.
	18	*
c27b3454	19	* Revision 1.3 87/06/04 01:35:01 wesommer
	20	* Added a working query request handler.
	21	*
78849033	22	* Revision 1.2 87/06/03 16:07:50 wesommer
	23	* Fixes for lint.
	24	*
5dbd09a0	25	* Revision 1.1 87/06/02 20:07:10 wesommer
	26	* Initial revision
	27	*
a3cf6921	28	*/
	29
	30	#ifndef lint
	31	static char *rcsid_sms_scall_c = "$Header$";
	32	#endif lint
	33
	34	#include <krb.h>
78849033	35	#include <errno.h>
a3cf6921	36	#include "sms_server.h"
	37	extern char buf1[];
	38	extern int nclients;
	39	extern char *whoami;
	40
	41	extern void clist_delete(), do_auth(), do_shutdown();
	42	void do_call();
	43
	44	/*
	45	* Welcome to the (finite state) machine (highest level).
	46	*/
	47	void
	48	do_client(cp)
	49	client *cp;
	50	{
ed31e0d1	51	free_rtn_tuples(cp);
a3cf6921	52	if (OP_STATUS(cp->pending_op) == OP_CANCELLED) {
	53	(void) sprintf(buf1, "Closed connection (now %d client%s)",
	54	nclients-1,
	55	nclients!=2?"s":"");
	56	com_err(whoami, 0, buf1);
	57	clist_delete(cp);
	58	return;
	59	}
	60	switch (cp->action) {
	61	case CL_ACCEPT:
	62	case CL_SEND:
	63	/* Start recieving next request */
	64	initialize_operation(cp->pending_op, sms_start_recv,
5dbd09a0	65	(char )&cp->args, (int ()())NULL);
a3cf6921	66	queue_operation(cp->con, CON_INPUT, cp->pending_op);
	67	cp->action = CL_RECEIVE;
	68	break;
	69	case CL_RECEIVE:
	70	/* Data is here. Process it & start it heading back */
	71	do_call(cp); /* This may block for a while. */
	72	initialize_operation(cp->pending_op, sms_start_send,
5dbd09a0	73	(char )&cp->reply, (int ()())NULL);
a3cf6921	74	queue_operation(cp->con, CON_OUTPUT, cp->pending_op);
	75	cp->action = CL_SEND;
	76	break;
	77	}
	78	}
	79
	80	#ifdef notdef
	81	char *procnames[] = {
	82	"noop",
	83	"auth",
	84	"shutdown",
78849033	85	"query",
a3cf6921	86	};
	87	#endif notdef
	88
	89	void
	90	do_call(cl)
	91	client *cl;
	92	{
	93	int pn;
	94	cl->reply.sms_argc = 0;
	95	cl->reply.sms_status = 0;
	96	if (((pn = cl->args->sms_procno) < 0) \|\|
	97	(pn > SMS_MAX_PROC)) {
	98	com_err(whoami, 0, "procno out of range");
	99	cl->reply.sms_status = SMS_UNKNOWN_PROC;
	100	return;
	101	}
	102	#ifdef SMS_DBG
	103	fprintf(stderr, "[#%d] %s(", cl->id, procnames[pn]);
	104	for (i=0; i < cl->args->sms_argc; i++) {
	105	if (i) fputc(',', stderr);
	106	frequote(stderr,cl->args->sms_argv[i]);
	107	}
	108	fprintf(stderr, ")\n");
	109	#endif SMS_DBG
	110
	111	switch(pn) {
	112	case SMS_NOOP:
	113	cl->reply.sms_status = 0;
	114	com_err(whoami, 0, "noop");
	115	return;
3630192b	116
a3cf6921	117	case SMS_AUTH:
	118	do_auth(cl);
	119	return;
78849033	120
78849033	121	case SMS_QUERY:
a3cf6921	122	do_retr(cl);
a3cf6921	123	return;
a3cf6921	124
3630192b	125	case SMS_ACCESS:
	126	do_access(cl);
	127	return;
	128
a3cf6921	129	case SMS_SHUTDOWN:
	130	do_shutdown(cl);
	131	return;
	132	}
	133	}
	134
ed31e0d1	135	free_rtn_tuples(cp)
	136	client *cp;
	137	{
	138	register returned_tuples *temp;
	139	for (temp=cp->first; temp && OP_DONE(temp->op); ) {
	140	register returned_tuples *t1=temp;
	141	temp = t1->next;
	142	if (t1 == cp->last) cp->last = NULL;
	143	#ifdef notdef
	144	sms_destroy_reply(t1->retval);
	145	#endif notdef
	146	if (t1->retval) {
	147	register sms_params *p = t1->retval;
	148	if (p->sms_flattened)
	149	free(p->sms_flattened);
	150	if (p->sms_argl)
	151	free(p->sms_argl);
	152	free(p);
	153	}
	154	delete_operation(t1->op);
	155	free(t1);
	156	}
	157	cp->first = temp;
	158	}
	159
78849033	160	retr_callback(argc, argv, p_cp)
	161	int argc;
	162	char **argv;
	163	char *p_cp;
	164	{
	165	register client cp = (client )p_cp;
78849033	166	/*
	167	* This takes too much advantage of the fact that
	168	* serialization of the data happens during the queue operation.
	169	*/
	170	sms_params arg_tmp = (sms_params )db_alloc(sizeof(sms_params));
ed31e0d1	171	returned_tuples tp = (returned_tuples )
	172	db_alloc(sizeof(returned_tuples));
	173
78849033	174	OPERATION op_tmp = create_operation();
78849033	175
	176	#ifdef notdef /* We really don't want this logged */
	177	com_err(whoami, 0, "Returning next data:");
	178	log_args(argc, argv);
	179	#endif notdef
ed31e0d1	180	tp->op = op_tmp;
	181	tp->retval = arg_tmp;
	182	tp->next = NULL;
78849033	183
	184	arg_tmp->sms_status = SMS_MORE_DATA;
	185	arg_tmp->sms_argc = argc;
	186	arg_tmp->sms_argv = argv;
	187	arg_tmp->sms_flattened = (char *)NULL;
	188	arg_tmp->sms_argl = (int *)NULL;
ed31e0d1	189
	190	if (cp->last) {
	191	cp->last->next = tp;
	192	cp->last = tp;
	193	} else {
	194	cp->last = cp->first = tp;
	195	}
	196
78849033	197	reset_operation(op_tmp);
	198	initialize_operation(op_tmp, sms_start_send, (char *)arg_tmp,
	199	(int (*)())NULL);
	200	queue_operation(cp->con, CON_OUTPUT, op_tmp);
	201	}
	202
	203
a3cf6921	204	do_retr(cl)
	205	client *cl;
	206	{
78849033	207	cl->reply.sms_argc = 0;
78849033	208	cl->reply.sms_status = 0;
c27b3454	209	#ifdef notdef
78849033	210	if (!cl->clname) {
	211	com_err(whoami, 0, "Unauthenticated query rejected");
	212	cl->reply.sms_status = EACCES;
	213	return;
	214	}
c27b3454	215	#endif notdef
78849033	216	com_err(whoami, 0, "Processing query: ");
78849033	217	log_args(cl->args->sms_argc, cl->args->sms_argv);
a3cf6921	218
3630192b	219	cl->reply.sms_status =
	220	sms_process_query(cl,
	221	cl->args->sms_argv[0],
	222	cl->args->sms_argc-1,
	223	cl->args->sms_argv+1,
	224	retr_callback,
	225	(char *)cl);
78849033	226
78849033	227	com_err(whoami, 0, "Query complete.");
a3cf6921	228	}
78849033	229
3630192b	230	do_access(cl)
	231	client *cl;
	232	{
	233	cl->reply.sms_argc = 0;
	234	cl->reply.sms_status = 0;
	235	#ifdef notdef
	236	if (!cl->clname) {
	237	com_err(whoami, 0, "Unauthenticated query rejected");
	238	cl->reply.sms_status = EACCES;
	239	return;
	240	}
	241	#endif notdef
	242	com_err(whoami, 0, "Checking access: ");
	243	log_args(cl->args->sms_argc, cl->args->sms_argv);
	244
	245	cl->reply.sms_status =
	246	sms_check_access(cl,
	247	cl->args->sms_argv[0],
	248	cl->args->sms_argc-1,
	249	cl->args->sms_argv+1);
	250
	251	com_err(whoami, 0, "Access check complete.");
	252	}