[moira.git] / server / mr_scall.c

/*
 *	$Source$
 *	$Author$
 *	$Header$
 *
 *	Copyright (C) 1987 by the Massachusetts Institute of Technology
 *	For copying and distribution information, please see the file
 *	<mit-copyright.h>.
 *
 */

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

#include <mit-copyright.h>
#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, %d new queries, %d old)",
			nclients-1,
			nclients!=2?"s":"",
			newqueries,
			oldqueries);
		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;
	cl->reply.sms_version_no = cl->args->sms_version_no;
	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_version_no,
			 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(0, 0, 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 (sms_trim_args(argc, argv) == SMS_NO_MEM) {
	    com_err(whoami, SMS_NO_MEM, "while trimming args");
	}
	if (log_flags & LOG_RESP)
		log_args("return: ", cp->args->sms_version_no, argc, argv);

	tp->op = op_tmp;
	tp->retval = arg_tmp;
	tp->next = NULL;
	
	arg_tmp->sms_status = SMS_MORE_DATA;
	arg_tmp->sms_version_no = cp->args->sms_version_no;
	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 (cl->args->sms_version_no == SMS_VERSION_2)
	  newqueries++;
	else
	  oldqueries++;

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


/* trigger_dcm is also used as a followup routine to the 
 * set_server_host_override query, hence the two dummy arguments.
 */

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

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

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

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

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