[moira.git] / server / mr_scall.c

/*
 *	$Source$
 *	$Author$
 *	$Header$
 *
 *	Copyright (C) 1987 by the Massachusetts Institute of Technology
 *
 *	$Log$
 *	Revision 1.4  1987-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;
{
	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_SHUTDOWN:
		do_shutdown(cl);
		return;
	}
}

retr_callback(argc, argv, p_cp)
	int argc;
	char **argv;
	char *p_cp;
{
	register client *cp = (client *)p_cp;
	/* XXX MEM when are these freed?? */
	/*
	 * 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));
	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
	
	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;
	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);
	
	sms_process_query(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.");
}
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$
c27b3454	9	* Revision 1.4 1987-06-21 16:42:00 wesommer
c27b3454	10	* Performance work, rearrangement of include files.
a3cf6921	11	*
c27b3454	12	* Revision 1.3 87/06/04 01:35:01 wesommer
	13	* Added a working query request handler.
	14	*
78849033	15	* Revision 1.2 87/06/03 16:07:50 wesommer
	16	* Fixes for lint.
	17	*
5dbd09a0	18	* Revision 1.1 87/06/02 20:07:10 wesommer
	19	* Initial revision
	20	*
a3cf6921	21	*/
	22
	23	#ifndef lint
	24	static char *rcsid_sms_scall_c = "$Header$";
	25	#endif lint
	26
	27	#include <krb.h>
78849033	28	#include <errno.h>
a3cf6921	29	#include "sms_server.h"
	30	extern char buf1[];
	31	extern int nclients;
	32	extern char *whoami;
	33
	34	extern void clist_delete(), do_auth(), do_shutdown();
	35	void do_call();
	36
	37	/*
	38	* Welcome to the (finite state) machine (highest level).
	39	*/
	40	void
	41	do_client(cp)
	42	client *cp;
	43	{
	44	if (OP_STATUS(cp->pending_op) == OP_CANCELLED) {
	45	(void) sprintf(buf1, "Closed connection (now %d client%s)",
	46	nclients-1,
	47	nclients!=2?"s":"");
	48	com_err(whoami, 0, buf1);
	49	clist_delete(cp);
	50	return;
	51	}
	52	switch (cp->action) {
	53	case CL_ACCEPT:
	54	case CL_SEND:
	55	/* Start recieving next request */
	56	initialize_operation(cp->pending_op, sms_start_recv,
5dbd09a0	57	(char )&cp->args, (int ()())NULL);
a3cf6921	58	queue_operation(cp->con, CON_INPUT, cp->pending_op);
	59	cp->action = CL_RECEIVE;
	60	break;
	61	case CL_RECEIVE:
	62	/* Data is here. Process it & start it heading back */
	63	do_call(cp); /* This may block for a while. */
	64	initialize_operation(cp->pending_op, sms_start_send,
5dbd09a0	65	(char )&cp->reply, (int ()())NULL);
a3cf6921	66	queue_operation(cp->con, CON_OUTPUT, cp->pending_op);
	67	cp->action = CL_SEND;
	68	break;
	69	}
	70	}
	71
	72	#ifdef notdef
	73	char *procnames[] = {
	74	"noop",
	75	"auth",
	76	"shutdown",
78849033	77	"query",
a3cf6921	78	};
	79	#endif notdef
	80
	81	void
	82	do_call(cl)
	83	client *cl;
	84	{
	85	int pn;
	86	cl->reply.sms_argc = 0;
	87	cl->reply.sms_status = 0;
	88	if (((pn = cl->args->sms_procno) < 0) \|\|
	89	(pn > SMS_MAX_PROC)) {
	90	com_err(whoami, 0, "procno out of range");
	91	cl->reply.sms_status = SMS_UNKNOWN_PROC;
	92	return;
	93	}
	94	#ifdef SMS_DBG
	95	fprintf(stderr, "[#%d] %s(", cl->id, procnames[pn]);
	96	for (i=0; i < cl->args->sms_argc; i++) {
	97	if (i) fputc(',', stderr);
	98	frequote(stderr,cl->args->sms_argv[i]);
	99	}
	100	fprintf(stderr, ")\n");
	101	#endif SMS_DBG
	102
	103	switch(pn) {
	104	case SMS_NOOP:
	105	cl->reply.sms_status = 0;
	106	com_err(whoami, 0, "noop");
	107	return;
	108	case SMS_AUTH:
	109	do_auth(cl);
	110	return;
78849033	111
78849033	112	case SMS_QUERY:
a3cf6921	113	do_retr(cl);
a3cf6921	114	return;
a3cf6921	115
	116	case SMS_SHUTDOWN:
	117	do_shutdown(cl);
	118	return;
	119	}
	120	}
	121
78849033	122	retr_callback(argc, argv, p_cp)
	123	int argc;
	124	char **argv;
	125	char *p_cp;
	126	{
	127	register client cp = (client )p_cp;
	128	/* XXX MEM when are these freed?? */
	129	/*
	130	* This takes too much advantage of the fact that
	131	* serialization of the data happens during the queue operation.
	132	*/
	133	sms_params arg_tmp = (sms_params )db_alloc(sizeof(sms_params));
	134	OPERATION op_tmp = create_operation();
78849033	135
	136	#ifdef notdef /* We really don't want this logged */
	137	com_err(whoami, 0, "Returning next data:");
	138	log_args(argc, argv);
	139	#endif notdef
	140
	141	arg_tmp->sms_status = SMS_MORE_DATA;
	142	arg_tmp->sms_argc = argc;
	143	arg_tmp->sms_argv = argv;
	144	arg_tmp->sms_flattened = (char *)NULL;
	145	arg_tmp->sms_argl = (int *)NULL;
	146	reset_operation(op_tmp);
	147	initialize_operation(op_tmp, sms_start_send, (char *)arg_tmp,
	148	(int (*)())NULL);
	149	queue_operation(cp->con, CON_OUTPUT, op_tmp);
	150	}
	151
	152
a3cf6921	153	do_retr(cl)
	154	client *cl;
	155	{
78849033	156	cl->reply.sms_argc = 0;
78849033	157	cl->reply.sms_status = 0;
c27b3454	158	#ifdef notdef
78849033	159	if (!cl->clname) {
	160	com_err(whoami, 0, "Unauthenticated query rejected");
	161	cl->reply.sms_status = EACCES;
	162	return;
	163	}
c27b3454	164	#endif notdef
78849033	165	com_err(whoami, 0, "Processing query: ");
78849033	166	log_args(cl->args->sms_argc, cl->args->sms_argv);
a3cf6921	167
78849033	168	sms_process_query(cl->args->sms_argv[0],
	169	cl->args->sms_argc-1,
	170	cl->args->sms_argv+1,
	171	retr_callback,
	172	(char *)cl);
	173
	174	com_err(whoami, 0, "Query complete.");
a3cf6921	175	}
78849033	176