prot_main.c

来自「<B>Digital的Unix操作系统VAX 4.2源码</B>」· C语言 代码 · 共 759 行 · 第 1/2 页

	extern klm_testrply *proc_klm_test();
	extern klm_stat *proc_klm_lock();
	extern klm_stat *proc_klm_cancel();
	extern klm_stat *proc_klm_unlock();

	reclock *req;
	msg_entry *msgp;
	int oldmask;

	oldmask = sigblock (1 << (SIGALRM -1));
		
	klm_transp = Transp;
	klm_msg = NULL;

	switch (Rqstp->rq_proc) {
	case NULLPROC:
		svc_sendreply(Transp, xdr_void, NULL);
		(void) sigsetmask(oldmask);
		return;

	case DEBUG_ON:
		debug = 2;
		svc_sendreply(Transp, xdr_void, NULL);
		(void) sigsetmask(oldmask);
		return;

	case DEBUG_OFF:
		debug = 0;
		svc_sendreply(Transp, xdr_void, NULL);
		(void) sigsetmask(oldmask);
		return;

	case KILL_IT:
		svc_sendreply(Transp, xdr_void, NULL);
		fprintf(stderr, "rpc.lockd killed upon request\n");
		exit(2);

	case KLM_TEST:
		xdr_Argument = xdr_klm_testargs;
		xdr_Result = xdr_klm_testrply;
		Local = (char *(*)()) proc_klm_test;
		break;

	case KLM_LOCK:
		xdr_Argument = xdr_klm_lockargs;
		xdr_Result = xdr_klm_stat;
		Local = (char *(*)()) proc_klm_lock;
		break;

	case KLM_CANCEL:
		xdr_Argument = xdr_klm_lockargs;
		xdr_Result = xdr_klm_stat;
		Local = (char *(*)()) proc_klm_cancel;
		break;

	case KLM_UNLOCK:
		xdr_Argument = xdr_klm_unlockargs;
		xdr_Result = xdr_klm_stat;
		Local = (char *(*)()) proc_klm_unlock;
		break;

	default:
		svcerr_noproc(Transp);
		(void) sigsetmask(oldmask);
		return;
	}

	if ((req = get_le()) != NULL) {
		if (!svc_getargs(Transp, xdr_Argument, req)) {
			svcerr_decode(Transp);
			(void) sigsetmask(oldmask);
			return;
		}
		if (debug == 3){
			if (fwrite(&klm, sizeof(int), 1, fp) == 0)
				fprintf(stderr, "fwrite klm error\n");
			if (fwrite(&Rqstp->rq_proc, sizeof(int), 1, fp) == 0)
				fprintf(stderr, "fwrite klm_proc error\n");
			(*xdr_Argument)(&x, req);
			printf("range[%d, %d)\n", req->lck.l_offset, req->lck.l_len);
			(void) fflush(fp);
		}

		if (map_kernel_klm(req) != -1) {
			if (Rqstp->rq_proc == KLM_LOCK ||
			 Rqstp->rq_proc == KLM_UNLOCK) {
				if ((req->pre_le = copy_le(req)) != NULL) {
					if (Rqstp->rq_proc == KLM_LOCK) {
						if ((req->pre_fe =  (char *)copy_fe(req)) == NULL)
							goto abnormal;
					}
				}
				else
					goto abnormal;
			}
		}
		else
			goto abnormal;
		if (grace_period > 0 && !(req->reclaim)) {
			/* put msg in queue and delay reply, unless there is no queue space */
			if (debug)
				printf("during grace period, please retry later\n");
			if ((msgp = queue(req, (int) Rqstp->rq_proc)) == NULL)
			{
				klm_reply(Rqstp->rq_proc, &res_working);
				req->rel = 1;
				release_le(req);
				(void) sigsetmask(oldmask);
				return;
			}
			req->rel = 1;
			klm_msg = msgp;
			(void) sigsetmask(oldmask);
			return;
		}
		if (grace_period >0 && debug)
			printf("accept reclaim request\n");
		if (Rqstp->rq_proc == KLM_LOCK) /* only monitor lock req */
			if (add_mon(req, 1) == -1) {
				req->rel = 1;
				release_le(req);
				fprintf(stderr, "req discard due status monitor problem\n");
			(void) sigsetmask(oldmask);
				return;
				}


		/* local routine replies individually */
		(*Local)(req);
		release_le(req);
		call_back();
		release_me();
		release_fe();
	}
	else { /* malloc failure */
		klm_reply((int) Rqstp->rq_proc, &res_nolock);
	}
	if (debug)
		pr_all();
	(void) sigsetmask(oldmask);
	return;

abnormal:

	klm_reply((int) Rqstp->rq_proc, &res_nolock);
	req->rel = 1;
	release_le(req);
	(void) sigsetmask(oldmask);
	return;
}


main(argc, argv)
	int argc;
	char ** argv;
{
	SVCXPRT *Transp;
	int c;
	int t;
	int ppid;
	FILE *fopen();
	extern int optind;
	extern char *optarg;
	extern int svcudp_enablecache ();  /* Ultrix mod - fsg */
	int	nofork;  /* Ultrix mod - fsg for dbx */

	LM_GRACE = LM_GRACE_DEFAULT;
	LM_TIMEOUT = LM_TIMEOUT_DEFAULT;
	HASH_SIZE = 29;
	report_sharing_conflicts = 0;

	while ((c = getopt(argc, argv, "s:t:d:g:h:")) != EOF)
		switch(c) {
		case 's':
			report_sharing_conflicts++;
			break;
		case 't':
			(void) sscanf(optarg, "%d", &LM_TIMEOUT);
			break;
		case 'd':
			(void) sscanf(optarg, "%d", &debug);
			break;
		case 'g':
			(void) sscanf(optarg, "%d", &t);
			LM_GRACE = 1 + t/LM_TIMEOUT;
			break;
		case 'h':
			(void) sscanf(optarg, "%d", &HASH_SIZE);
			break;

		/* Ultrix mod - fsg */
		case 'f':
			nofork = 1;
			break;

		default:
			fprintf(stderr, "rpc.lockd -t[timeout] -g[grace_period] -d[debug]\n");
			return(0);
		}
	if (debug)
		printf("lm_timeout = %d secs, grace_period = %d secs, hashsize = %d\n",
		 LM_TIMEOUT,  LM_GRACE * LM_TIMEOUT, HASH_SIZE);

	/* Ultrix mod - fsg */

	if (!debug && !nofork) {
		ppid = fork();
		if (ppid == -1) {
			(void) fprintf(stderr, "rpc.lockd: fork failure\n");
			(void) fflush(stderr);
			abort();
		}
		if (ppid != 0) {
			exit(0);
		}
		for (t = 0; t< 20; t++) {
			(void) close(t);
		}

		(void) open("/dev/console", 2);
		(void) open("/dev/console", 2);
		(void) open("/dev/console", 2);

		(void) setpgrp(0, 0);
	}
	else {
		setlinebuf(stderr);
		setlinebuf(stdout);
	}

	(void) signal(SIGALRM, xtimer);


	/* Ignore other signals */


	signal (SIGHUP, SIG_IGN);
	signal (SIGINT, SIG_IGN);
	signal (SIGQUIT, SIG_IGN);
	signal (SIGILL, SIG_IGN);
	signal (SIGTRAP, SIG_IGN);
	signal (SIGIOT, SIG_IGN);
	signal (SIGEMT, SIG_IGN);
	signal (SIGFPE, SIG_IGN);
	signal (SIGBUS, SIG_IGN);
	signal (SIGSEGV, SIG_IGN);
	signal (SIGSYS, SIG_IGN);
	signal (SIGPIPE, SIG_IGN);
	signal (SIGTERM, SIG_IGN);
	signal (SIGURG, SIG_IGN);
	signal (SIGSTOP, SIG_IGN);
	signal (SIGTSTP, SIG_IGN);
	signal (SIGCONT, SIG_IGN);
	signal (SIGCHLD, SIG_IGN);
	signal (SIGTTIN, SIG_IGN);
	signal (SIGTTOU, SIG_IGN);
	signal (SIGIO, SIG_IGN);
	signal (SIGXCPU, SIG_IGN);
	signal (SIGXFSZ, SIG_IGN);
	signal (SIGVTALRM, SIG_IGN);
	signal (SIGPROF, SIG_IGN);
	signal (SIGWINCH, SIG_IGN);
	signal (SIGUSR1, SIG_IGN);
	signal (SIGUSR2, SIG_IGN);

	/* NLM declaration */
	pmap_unset(NLM_PROG, NLM_VERS);

	Transp = svctcp_create(RPC_ANYSOCK, 0, 0);
	if (Transp == NULL) {
		fprintf(stderr,"cannot create tcp service.\n");
		exit(1);
	}
	if (!svc_register(Transp, NLM_PROG, NLM_VERS, nlm_prog, IPPROTO_TCP)) {
		fprintf(stderr,"unable to register (NLM_PROG, NLM_VERS, tcp).\n");
		exit(1);
	}

	Transp = svcudp_bufcreate(RPC_ANYSOCK, 1000, 1000);
	if (Transp == NULL) {
		fprintf(stderr,"cannot create udp service.\n");
		exit(1);
	}
	if (!svc_register(Transp, NLM_PROG, NLM_VERS, nlm_prog, IPPROTO_UDP)) {
		fprintf(stderr,"unable to register (NLM_PROG, NLM_VERS, udp).\n");
		exit(1);
	}
	if (!svcudp_enablecache(Transp, 15)) {
		fprintf(stderr,"svcudp_enablecache failed\n");
		exit(1);
	}

	/* NLM V3 declaration */
	pmap_unset(NLM_PROG, NLM_VERSX);
 
	Transp = svctcp_create(RPC_ANYSOCK, 0, 0);
	if (Transp == NULL) {
		fprintf(stderr,"cannot create tcp service.\n");
		exit(1);
	}
	if (!svc_register(Transp, NLM_PROG, NLM_VERSX, nlm_prog, IPPROTO_TCP)) {
		fprintf(stderr,"unable to register (NLM_PROG, NLM_VERSX, tcp).\n");
		exit(1);
	}
 
	Transp = svcudp_bufcreate(RPC_ANYSOCK, 1000, 1000);
	if (Transp == NULL) {
		fprintf(stderr,"cannot create udp service.\n");
		exit(1);
	}
	if (!svc_register(Transp, NLM_PROG, NLM_VERSX, nlm_prog, IPPROTO_UDP)) {
		fprintf(stderr,"unable to register (NLM_PROG, NLM_VERSX, udp).\n");
		exit(1);
	}
	if (!svcudp_enablecache(Transp, 15)) {
		fprintf(stderr,"svcudp_enablecache failed\n");
		exit(1);
	}

	/* KLM declaration */
	pmap_unset(KLM_PROG, KLM_VERS);

	Transp = svcudp_bufcreate(RPC_ANYSOCK, 1000, 1000);
	if (Transp == NULL) {
		fprintf(stderr,"cannot create udp service.\n");
		exit(1);
	}
	if (!svc_register(Transp, KLM_PROG, KLM_VERS, klm_prog, IPPROTO_UDP)) {
		fprintf(stderr,"unable to register (KLM_PROG, KLM_VERS, udp).\n");
		exit(1);
	}
	if (!svcudp_enablecache(Transp, 15)) {
		fprintf(stderr,"svcudp_enablecache failed\n");
		exit(1);
	}

	Transp = svctcp_create(RPC_ANYSOCK, 0, 0);
	if (Transp == NULL) {
		fprintf(stderr,"cannot create tcp service.\n");
		exit(1);
	}
	if (!svc_register(Transp, KLM_PROG, KLM_VERS, klm_prog, IPPROTO_TCP)) {
		fprintf(stderr,"unable to register (KLM_PROG, KLM_VERS, tcp).\n");
		exit(1);
	}

	/* PRIV declaration */
	pmap_unset(PRIV_PROG, PRIV_VERS);

	Transp = svctcp_create(RPC_ANYSOCK, 0, 0);
	if (Transp == NULL) {
		fprintf(stderr,"cannot create tcp service.\n");
		exit(1);
	}
	if (!svc_register(Transp, PRIV_PROG, PRIV_VERS, priv_prog, IPPROTO_TCP)) {
		fprintf(stderr,"unable to register (PRIV_PROG, PRIV_VERS, tcp).\n");
		exit(1);
	}

	init();
	init_nlm_share();

	if (debug == 3) {
		printf("lockd create logfile\n");
		klm = KLM_PROG;
		nlm = NLM_PROG;
		if ((fp = fopen("logfile", "w+")) == NULL) {
			perror("logfile fopen:");
			exit(1);
		}
		xdrstdio_create(&x, fp, XDR_ENCODE);
	}
	(void) alarm(LM_TIMEOUT);
	svc_run();
	fprintf(stderr,"svc_run returned\n");
	exit(1);
	/* NOTREACHED */
}