[moira.git] / server / mr_scall.c

/*
 *	$Source$
 *	$Author$
 *	$Header$
 *
 *	Copyright (C) 1987 by the Massachusetts Institute of Technology
 *
 *	$Log$
 *	Revision 1.11  1987-08-19 22:03:52  wesommer
 *	Added the trigger_dcm function, which fires off a DCM to do the
 *	update.
 *
 * Revision 1.10  87/08/19  18:39:04  wesommer
 * Added list_users query.
 * 
 * Revision 1.9  87/08/04  02:41:22  wesommer
 * Clean up messages.
 * 
 * Revision 1.8  87/07/16  15:43:19  wesommer
 * Fixed bug where the argv was not copied to private storage
 * (it got changed out from under us before it got sent..).
 * 
 * Revision 1.7  87/07/14  00:39:01  wesommer
 * Rearranged loggin.
 * 
 * Revision 1.6  87/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 "query.h"
#include "sms_server.h"
extern char buf1[];
extern int nclients;
extern char *whoami;
extern char *malloc();
extern int errno;

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) {
		com_err(whoami, 0, "Closed connection (now %d client%s)",
			nclients-1,
			nclients!=2?"s":"");
		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. */
		sms_destroy_reply(cp->args);
		cp->args = NULL;
		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;
	}
}		

char *procnames[] = {
	 "noop",
	 "auth",
	 "shutdown",
	 "query",
	 "access",
};


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;
	}
	if (log_flags & LOG_ARGS)
		log_args(procnames[pn], cl->args->sms_argc,
			 cl->args->sms_argv);
	else if (log_flags & LOG_REQUESTS)
		com_err(whoami, 0, "%s", procnames[pn]);

	switch(pn) {
	case SMS_NOOP:
		cl->reply.sms_status = 0;
		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;

	case SMS_DO_UPDATE:
		trigger_dcm(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;

		sms_destroy_reply(t1->retval);
#ifdef 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);
		}
#endif notdef
		delete_operation(t1->op);
		free(t1);
	}
	cp->first = temp;
}	

retr_callback(argc, argv, p_cp)
	register int argc;
	register 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));
	register char **nargv = (char **)malloc(argc * sizeof(char *));
	register int i;
	
	OPERATION op_tmp = create_operation();

	if (log_flags & LOG_RESP)
		log_args("return: ", argc, argv);

	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 = nargv;
	for (i = 0; i < argc; i++) {
		register int len = strlen(argv[i]) + 1;
		nargv[i] = malloc(len);
		bcopy(argv[i], nargv[i], len);
	}
	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);
}

list_users(callbk, callarg)
	int (*callbk)();
	char *callarg;
{
	char *argv[6];
	char buf[30];
	char buf1[30];
	int i;
	extern client **clients;
	extern char *inet_ntoa();
	char *cp;
	char *index();
	char *ctime();

	for (i = 0; i < nclients; i++) {
		register client *cl = clients[i];
		if (cl->clname) 
			argv[0] = cl->clname;
		else argv[0] = "unauthenticated";
		
		argv[1] = inet_ntoa(cl->haddr.sin_addr);
		argv[2] = buf;
		sprintf(buf, "port %d", ntohs(cl->haddr.sin_port));
		argv[3] = ctime(&cl->last_time_used);
		cp = index(argv[3], '\n');
		if (cp) *cp = '\0';
		argv[4] = buf1;
		sprintf(buf1, "[#%d]", cl->id);
		(*callbk)(5, argv, callarg);
	}
	return 0;
}

do_retr(cl)
	register client *cl;
{
	register char *queryname;

	cl->reply.sms_argc = 0;
	cl->reply.sms_status = 0;

	queryname = cl->args->sms_argv[0];
	
	if (strcmp(queryname, "_list_users") == 0)
		cl->reply.sms_status = list_users(retr_callback, (char *)cl);
	else {
		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);
	}
	if (log_flags & LOG_RES)
		com_err(whoami, 0, "Query complete.");
}

do_access(cl)
	client *cl;
{
	cl->reply.sms_argc = 0;

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

struct query pseudo_query = {
	"trigger_dcm",
	"tdcm",
};

trigger_dcm(cl)
	client *cl;
{
	register int pid;
	
	cl->reply.sms_argc = 0;

	if (cl->reply.sms_status = check_query_access(&pseudo_query, 0, cl) )
		return;

	pid = vfork();
	switch (pid) {
	case 0:
		execl("/u1/sms/bin/dcm", "dcm", 0);
		exit(1);
		
	case -1:
		cl->reply.sms_status = errno;
		return;

	default:
		return;
	}
}
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$
8165c536	9	* Revision 1.11 1987-08-19 22:03:52 wesommer
	10	* Added the trigger_dcm function, which fires off a DCM to do the
	11	* update.
a3cf6921	12	*
8165c536	13	* Revision 1.10 87/08/19 18:39:04 wesommer
	14	* Added list_users query.
	15	*
de24f12d	16	* Revision 1.9 87/08/04 02:41:22 wesommer
	17	* Clean up messages.
	18	*
f17535a4	19	* Revision 1.8 87/07/16 15:43:19 wesommer
	20	* Fixed bug where the argv was not copied to private storage
	21	* (it got changed out from under us before it got sent..).
	22	*
28222705	23	* Revision 1.7 87/07/14 00:39:01 wesommer
	24	* Rearranged loggin.
	25	*
630e8323	26	* Revision 1.6 87/06/30 20:04:43 wesommer
	27	* Free returned tuples when possible.
	28	*
ed31e0d1	29	* Revision 1.5 87/06/26 10:55:53 wesommer
	30	* Added sms_access, now paiys attention to return code from
	31	* sms_process_query, sms_check_access.
	32	*
3630192b	33	* Revision 1.4 87/06/21 16:42:00 wesommer
	34	* Performance work, rearrangement of include files.
	35	*
c27b3454	36	* Revision 1.3 87/06/04 01:35:01 wesommer
	37	* Added a working query request handler.
	38	*
78849033	39	* Revision 1.2 87/06/03 16:07:50 wesommer
	40	* Fixes for lint.
	41	*
5dbd09a0	42	* Revision 1.1 87/06/02 20:07:10 wesommer
	43	* Initial revision
	44	*
a3cf6921	45	*/
	46
	47	#ifndef lint
	48	static char *rcsid_sms_scall_c = "$Header$";
	49	#endif lint
	50
	51	#include <krb.h>
78849033	52	#include <errno.h>
8165c536	53	#include "query.h"
a3cf6921	54	#include "sms_server.h"
	55	extern char buf1[];
	56	extern int nclients;
	57	extern char *whoami;
28222705	58	extern char *malloc();
8165c536	59	extern int errno;
a3cf6921	60
	61	extern void clist_delete(), do_auth(), do_shutdown();
	62	void do_call();
	63
	64	/*
	65	* Welcome to the (finite state) machine (highest level).
	66	*/
	67	void
	68	do_client(cp)
	69	client *cp;
	70	{
ed31e0d1	71	free_rtn_tuples(cp);
a3cf6921	72	if (OP_STATUS(cp->pending_op) == OP_CANCELLED) {
f17535a4	73	com_err(whoami, 0, "Closed connection (now %d client%s)",
	74	nclients-1,
	75	nclients!=2?"s":"");
a3cf6921	76	clist_delete(cp);
	77	return;
	78	}
	79	switch (cp->action) {
	80	case CL_ACCEPT:
	81	case CL_SEND:
	82	/* Start recieving next request */
	83	initialize_operation(cp->pending_op, sms_start_recv,
5dbd09a0	84	(char )&cp->args, (int ()())NULL);
a3cf6921	85	queue_operation(cp->con, CON_INPUT, cp->pending_op);
	86	cp->action = CL_RECEIVE;
	87	break;
	88	case CL_RECEIVE:
	89	/* Data is here. Process it & start it heading back */
	90	do_call(cp); /* This may block for a while. */
de24f12d	91	sms_destroy_reply(cp->args);
de24f12d	92	cp->args = NULL;
a3cf6921	93	initialize_operation(cp->pending_op, sms_start_send,
5dbd09a0	94	(char )&cp->reply, (int ()())NULL);
a3cf6921	95	queue_operation(cp->con, CON_OUTPUT, cp->pending_op);
	96	cp->action = CL_SEND;
	97	break;
	98	}
	99	}
	100
a3cf6921	101	char *procnames[] = {
	102	"noop",
	103	"auth",
	104	"shutdown",
78849033	105	"query",
630e8323	106	"access",
	107	};
	108
a3cf6921	109
	110	void
	111	do_call(cl)
	112	client *cl;
	113	{
	114	int pn;
	115	cl->reply.sms_argc = 0;
	116	cl->reply.sms_status = 0;
	117	if (((pn = cl->args->sms_procno) < 0) \|\|
	118	(pn > SMS_MAX_PROC)) {
	119	com_err(whoami, 0, "procno out of range");
	120	cl->reply.sms_status = SMS_UNKNOWN_PROC;
	121	return;
	122	}
630e8323	123	if (log_flags & LOG_ARGS)
	124	log_args(procnames[pn], cl->args->sms_argc,
	125	cl->args->sms_argv);
	126	else if (log_flags & LOG_REQUESTS)
f17535a4	127	com_err(whoami, 0, "%s", procnames[pn]);
a3cf6921	128
	129	switch(pn) {
	130	case SMS_NOOP:
	131	cl->reply.sms_status = 0;
a3cf6921	132	return;
3630192b	133
a3cf6921	134	case SMS_AUTH:
	135	do_auth(cl);
	136	return;
78849033	137
78849033	138	case SMS_QUERY:
a3cf6921	139	do_retr(cl);
a3cf6921	140	return;
a3cf6921	141
3630192b	142	case SMS_ACCESS:
	143	do_access(cl);
	144	return;
	145
a3cf6921	146	case SMS_SHUTDOWN:
	147	do_shutdown(cl);
	148	return;
8165c536	149
	150	case SMS_DO_UPDATE:
	151	trigger_dcm(cl);
	152	return;
a3cf6921	153	}
	154	}
	155
ed31e0d1	156	free_rtn_tuples(cp)
	157	client *cp;
	158	{
	159	register returned_tuples *temp;
	160	for (temp=cp->first; temp && OP_DONE(temp->op); ) {
	161	register returned_tuples *t1=temp;
	162	temp = t1->next;
	163	if (t1 == cp->last) cp->last = NULL;
28222705	164
ed31e0d1	165	sms_destroy_reply(t1->retval);
28222705	166	#ifdef notdef
ed31e0d1	167	if (t1->retval) {
	168	register sms_params *p = t1->retval;
	169	if (p->sms_flattened)
	170	free(p->sms_flattened);
	171	if (p->sms_argl)
	172	free(p->sms_argl);
	173	free(p);
	174	}
28222705	175	#endif notdef
ed31e0d1	176	delete_operation(t1->op);
	177	free(t1);
	178	}
	179	cp->first = temp;
	180	}
	181
78849033	182	retr_callback(argc, argv, p_cp)
28222705	183	register int argc;
28222705	184	register char **argv;
78849033	185	char *p_cp;
	186	{
	187	register client cp = (client )p_cp;
78849033	188	/*
	189	* This takes too much advantage of the fact that
	190	* serialization of the data happens during the queue operation.
	191	*/
	192	sms_params arg_tmp = (sms_params )db_alloc(sizeof(sms_params));
ed31e0d1	193	returned_tuples tp = (returned_tuples )
ed31e0d1	194	db_alloc(sizeof(returned_tuples));
28222705	195	register char nargv = (char )malloc(argc * sizeof(char *));
28222705	196	register int i;
ed31e0d1	197
78849033	198	OPERATION op_tmp = create_operation();
78849033	199
630e8323	200	if (log_flags & LOG_RESP)
	201	log_args("return: ", argc, argv);
	202
ed31e0d1	203	tp->op = op_tmp;
	204	tp->retval = arg_tmp;
	205	tp->next = NULL;
78849033	206
	207	arg_tmp->sms_status = SMS_MORE_DATA;
	208	arg_tmp->sms_argc = argc;
28222705	209	arg_tmp->sms_argv = nargv;
	210	for (i = 0; i < argc; i++) {
	211	register int len = strlen(argv[i]) + 1;
	212	nargv[i] = malloc(len);
	213	bcopy(argv[i], nargv[i], len);
	214	}
78849033	215	arg_tmp->sms_flattened = (char *)NULL;
78849033	216	arg_tmp->sms_argl = (int *)NULL;
ed31e0d1	217
	218	if (cp->last) {
	219	cp->last->next = tp;
	220	cp->last = tp;
	221	} else {
	222	cp->last = cp->first = tp;
	223	}
	224
78849033	225	reset_operation(op_tmp);
	226	initialize_operation(op_tmp, sms_start_send, (char *)arg_tmp,
	227	(int (*)())NULL);
	228	queue_operation(cp->con, CON_OUTPUT, op_tmp);
	229	}
	230
de24f12d	231	list_users(callbk, callarg)
	232	int (*callbk)();
	233	char *callarg;
	234	{
	235	char *argv[6];
	236	char buf[30];
	237	char buf1[30];
	238	int i;
	239	extern client **clients;
	240	extern char *inet_ntoa();
	241	char *cp;
	242	char *index();
	243	char *ctime();
	244
	245	for (i = 0; i < nclients; i++) {
	246	register client *cl = clients[i];
	247	if (cl->clname)
	248	argv[0] = cl->clname;
	249	else argv[0] = "unauthenticated";
	250
	251	argv[1] = inet_ntoa(cl->haddr.sin_addr);
	252	argv[2] = buf;
	253	sprintf(buf, "port %d", ntohs(cl->haddr.sin_port));
	254	argv[3] = ctime(&cl->last_time_used);
	255	cp = index(argv[3], '\n');
	256	if (cp) *cp = '\0';
	257	argv[4] = buf1;
	258	sprintf(buf1, "[#%d]", cl->id);
	259	(*callbk)(5, argv, callarg);
	260	}
	261	return 0;
	262	}
78849033	263
a3cf6921	264	do_retr(cl)
de24f12d	265	register client *cl;
a3cf6921	266	{
de24f12d	267	register char *queryname;
de24f12d	268
78849033	269	cl->reply.sms_argc = 0;
78849033	270	cl->reply.sms_status = 0;
630e8323	271
de24f12d	272	queryname = cl->args->sms_argv[0];
	273
	274	if (strcmp(queryname, "_list_users") == 0)
	275	cl->reply.sms_status = list_users(retr_callback, (char *)cl);
	276	else {
	277	cl->reply.sms_status =
	278	sms_process_query(cl,
	279	cl->args->sms_argv[0],
	280	cl->args->sms_argc-1,
	281	cl->args->sms_argv+1,
	282	retr_callback,
	283	(char *)cl);
	284	}
630e8323	285	if (log_flags & LOG_RES)
630e8323	286	com_err(whoami, 0, "Query complete.");
a3cf6921	287	}
78849033	288
3630192b	289	do_access(cl)
	290	client *cl;
	291	{
	292	cl->reply.sms_argc = 0;
630e8323	293
3630192b	294	cl->reply.sms_status =
	295	sms_check_access(cl,
	296	cl->args->sms_argv[0],
	297	cl->args->sms_argc-1,
	298	cl->args->sms_argv+1);
	299
	300	com_err(whoami, 0, "Access check complete.");
	301	}
8165c536	302
	303	struct query pseudo_query = {
	304	"trigger_dcm",
	305	"tdcm",
	306	};
	307
	308	trigger_dcm(cl)
	309	client *cl;
	310	{
	311	register int pid;
	312
	313	cl->reply.sms_argc = 0;
	314
	315	if (cl->reply.sms_status = check_query_access(&pseudo_query, 0, cl) )
	316	return;
	317
	318	pid = vfork();
	319	switch (pid) {
	320	case 0:
	321	execl("/u1/sms/bin/dcm", "dcm", 0);
	322	exit(1);
	323
	324	case -1:
	325	cl->reply.sms_status = errno;
	326	return;
	327
	328	default:
	329	return;
	330	}
	331	}
	332