rpcprocs.c

操作系统SunOS 4.1.3版本的源码

                break;

          case FATAL_MSG:
          case ERROR_MSG:
                if (!svc_getargs(t_transp, xdr_wrapstring, &msg)) {
			svcerr_decode(t_transp);
			return;
		}

		write_log(msg, info_fp);	/* write to info. log */
		write_log(msg, error_fp);	/* write to error log */

		if (!ats_nohost)
		  send_host(msg, 0);/* not running anymore */

		if (!tty_mode)			/* write to console */
		{
		  ttysw_print(msg+16, strlen(msg)-16);
		}
		else
		  console_message(msg+16);

		svc_freeargs(t_transp, xdr_wrapstring, &msg);
                if (!svc_sendreply(t_transp, xdr_void, (caddr_t)NULL))
		  rpc_pass = 1;

		if (send_email==1 || send_email==3)
		  sd_send_mail();

		break;

	  case CONSOLE_MSG:
                if (!svc_getargs(t_transp, xdr_wrapstring, &msg)) {
			svcerr_decode(t_transp);
			return;
		}

		if (!tty_mode)		/* write to console only */
		  ttysw_print(msg, strlen(msg));
		else
		  console_message(msg);

		svc_freeargs(t_transp, xdr_wrapstring, &msg);
                if (!svc_sendreply(t_transp, xdr_void, (caddr_t)NULL))
		  rpc_pass = 1;

                break;
		
	  case PROBE_DEVS:
		f_dev.cpuname = NULL;
        	f_dev.found_dev = NULL;
                if (!svc_getargs(t_transp, xdr_f_devs, &f_dev)) {
                        svcerr_decode(t_transp);
                        exit(1);
		}

		init_tests(&f_dev);		/* in tests.c */

                svc_freeargs(t_transp, xdr_f_devs, &f_dev);
                if (!svc_sendreply(t_transp, xdr_void, (caddr_t)NULL))
		{
		  rpc_pass = 1;
		  break;
		}

                return;

	  case ATS_SUNDIAG_START_TESTS:
		if (!svc_getargs (t_transp, xdr_int, &seq_num)) {
			svcerr_decode(t_transp);
			return;
  		}
		amp_send_ack(client,SUNDIAG_ATS_ACK,t_rqstp->rq_proc,seq_num);
		if (running == IDLE)		/* should return status too */
		  start_proc();

                if (!svc_sendreply(t_transp, xdr_void, (caddr_t)NULL))
		{
		  rpc_pass = 1;
		  break;
		}

		return;

	  case ATS_SUNDIAG_STOP_TESTS:
		if (!svc_getargs (t_transp, xdr_int, &seq_num)) {
			svcerr_decode(t_transp);
			return;
  		}
		amp_send_ack(client,SUNDIAG_ATS_ACK,t_rqstp->rq_proc,seq_num);
		if (running == GO)		/* should return status too */
		  stop_proc();

                if (!svc_sendreply(t_transp, xdr_void, (caddr_t)NULL))
		{
		  rpc_pass = 1;
		  break;
		}

		return;

	  case ATS_SUNDIAG_SELECT_TEST:
		if (!svc_getargs (t_transp, xdr_int, &seq_num)) {
			svcerr_decode(t_transp);
			return;
  		}
		amp_send_ack(client,SUNDIAG_ATS_ACK,t_rqstp->rq_proc,seq_num);
                if (!svc_getargs(t_transp, xdr_strings, &str)) {
                        svcerr_decode(t_transp);
                        return;
                }

		ats_start_test(str.op[0], str.op[1]);

                if (!svc_sendreply(t_transp, xdr_void, (caddr_t)NULL))
		{
		  rpc_pass = 1;
		  break;
		}

		return;

	  case ATS_SUNDIAG_DESELECT_TEST:
		if (!svc_getargs (t_transp, xdr_int, &seq_num)) {
			svcerr_decode(t_transp);
			return;
  		}
		amp_send_ack(client,SUNDIAG_ATS_ACK,t_rqstp->rq_proc,seq_num);
                if (!svc_getargs(t_transp, xdr_strings, &str)) {
                        svcerr_decode(t_transp);
                        return;
                }

		ats_stop_test(str.op[0], str.op[1]);

                if (!svc_sendreply(t_transp, xdr_void, (caddr_t)NULL))
		{
		  rpc_pass = 1;
		  break;
		}

		return;

	  case ATS_SUNDIAG_HALT:
		if (!svc_getargs (t_transp, xdr_int, &seq_num)) {
			svcerr_decode(t_transp);
			return;
  		}
		amp_send_ack(client,SUNDIAG_ATS_ACK,t_rqstp->rq_proc,seq_num);
                if (!svc_sendreply(t_transp, xdr_void, (caddr_t)NULL))
		{
		  rpc_pass = 1;
		  break;
		}

		reboot(RB_HALT);

		return;

	  case ATS_SUNDIAG_QUIT:
		if (!svc_getargs (t_transp, xdr_int, &seq_num)) {
			svcerr_decode(t_transp);
			return;
  		}
		amp_send_ack(client,SUNDIAG_ATS_ACK,t_rqstp->rq_proc,seq_num);
                if (!svc_sendreply(t_transp, xdr_void, (caddr_t)NULL))
		{
		  rpc_pass = 1;
		  break;
		}

		(void)kill_proc();		/* never return */

	  case ATS_SUNDIAG_INTERVEN:
		if (!svc_getargs (t_transp, xdr_int, &seq_num)) {
			svcerr_decode(t_transp);
			return;
  		}
		amp_send_ack(client,SUNDIAG_ATS_ACK,t_rqstp->rq_proc,seq_num);
                if (!svc_getargs(t_transp, xdr_int, &mode)) {
                        svcerr_decode(t_transp);
                        return;
                }

		interven_proc((Panel_item)NULL, mode, (Event *)NULL);

		svc_freeargs(t_transp, xdr_int, &mode);
		if (!svc_sendreply(t_transp, xdr_void, (caddr_t)NULL))
		{
		  rpc_pass = 1;
		  break;
		}

		return;

	  case ATS_SUNDIAG_OPT_COREFILE:
		if (!svc_getargs (t_transp, xdr_int, &seq_num)) {
			svcerr_decode(t_transp);
			return;
  		}
		amp_send_ack(client,SUNDIAG_ATS_ACK,t_rqstp->rq_proc,seq_num);
                if (!svc_getargs(t_transp, xdr_int, &mode)) {
                        svcerr_decode(t_transp);
                        return;
                }

		if (running == IDLE)
		    core_file = mode;	/* ==1, enabled; ==0, disabled */

		svc_freeargs(t_transp, xdr_int, &mode);
		if (!svc_sendreply(t_transp, xdr_void, (caddr_t)NULL))
		{
		  rpc_pass = 1;
		  break;
		}

		return;

	  case ATS_SUNDIAG_RESET:
		if (!svc_getargs (t_transp, xdr_int, &seq_num)) {
			svcerr_decode(t_transp);
			return;
  		}
		amp_send_ack(client,SUNDIAG_ATS_ACK,t_rqstp->rq_proc,seq_num);
                if (!svc_sendreply(t_transp, xdr_void, (caddr_t)NULL))
		{
		  rpc_pass = 1;
		  break;
		}

		if (running == IDLE)
		  reset_proc();

		return;

	  case ATS_SUNDIAG_OPTION_FILE:
		if (!svc_getargs (t_transp, xdr_int, &seq_num)) {
			svcerr_decode(t_transp);
			return;
  		}
		amp_send_ack(client,SUNDIAG_ATS_ACK,t_rqstp->rq_proc,seq_num);
                if (!svc_getargs(t_transp, xdr_option, &optfile)) {
                        svcerr_decode(t_transp);
                        return;
                }

		if (optfile.action == 1)
		  (void)load_option(optfile.fname, 2);
		else
		  (void)store_option(optfile.fname);

                if (!svc_sendreply(t_transp, xdr_void, (caddr_t)NULL))
		{
		  rpc_pass = 1;
		  break;
		}

		return;

	  case ATS_SUNDIAG_OPTION:
		if (!svc_getargs (t_transp, xdr_int, &seq_num)) {
			svcerr_decode(t_transp);
			return;
  		}
		amp_send_ack(client,SUNDIAG_ATS_ACK,t_rqstp->rq_proc,seq_num);
                if (!svc_getargs(t_transp, xdr_strings, &str)) {
                        svcerr_decode(t_transp);
                        return;
                }

	        if (str.num >= 3)		/* check format first */
		{
		  for (i=0; i < str.num; ++i)
		    param[i] = str.op[i];
		  param[i] = NULL;

		  if (strcmp(param[0], "option")==0)
				/* this is an entry for system option */
		    load_system_options(param);	/* load system-wide options */
		  else
		    load_test_options(param);
				/* otherwise, individual test options */

		  if (!tty_mode)
		  {
		    (void)panel_set(select_item, PANEL_FEEDBACK,
							PANEL_NONE, 0);

		    if (option_frame != NULL)
				/* destroy the popup test option frame */
		      frame_destroy_proc(option_frame);
		  }

		  if (tty_mode)
		    tty_int_sel();
		  optfile_update();	/* update the screen if needed */
		}

                if (!svc_sendreply(t_transp, xdr_void, (caddr_t)NULL))
		{
		  rpc_pass = 1;
		  break;
		}

		return;
	}

	if (rpc_pass == 1)  /* print the message if svc_send_reply() failed */
	{
          (void)printf("\nrpc error with svc_send_reply.\n");
	  return;
	}
}

send_start_stop(msgnum, testname, devname, pass)
int msgnum;
char *testname;
char *devname;
int  pass;
{
  struct test	test;
  S_AMP_MSG_CB	msgbuf;

      strcpy(test.testname,testname);
      strcpy(test.devname,devname);
      test.hostid = hostid;
      test.pass_count = pass;
      msgbuf.message_num = msgnum;
      msgbuf.data=NULL;
      msgbuf.data_size=0;
      msgbuf.action=NULL;
      msgbuf.max_retransmit=4;
      msgbuf.max_wack=60;
      amp_rpc_send(client, &test, sizeof(struct test),
						xdr_test, &msgbuf);
}

send_test_msg(msgnum, teststatus, testname, devname, msg)
int msgnum;
int teststatus;
char *testname;
char *devname;
char *msg;
{
  struct failure	failure;
  S_AMP_MSG_CB	msgbuf;

      strcpy(failure.testname,testname);
      strcpy(failure.devname,devname);
      if (strlen(msg) < 256)
        strcpy(failure.message,msg);
      else
      {
	strncpy(failure.message,msg,255);
	failure.message[255] = '\0';
      }
      failure.hostid = hostid;
      failure.run_status = teststatus;
      msgbuf.message_num = msgnum;
      msgbuf.data=NULL;
      msgbuf.data_size=0;
      msgbuf.action=NULL;
      msgbuf.max_retransmit=4;
      msgbuf.max_wack=60;
      amp_rpc_send(client, &failure, sizeof(struct failure),
						xdr_failure, &msgbuf);
}

/******************************************************************************
 * Parses the message from the test to get the device name and test name,     *
 * then send the entire message to the host in the format understood by the   *
 * Host.								      *
 * Input: msg, the message from test.					      *
 *	  status, ==1: test is still running; ==0: test is stopped.	      *
 ******************************************************************************/
static	send_host(msg, status)
char	*msg;
int	status;
{
  char	*temp, *buf, *delimit;
  char	*testname;
  char	*devname;

  delimit = " \t";
  testname = "";
  devname = "";
  buf = malloc((unsigned)strlen(msg)+2);
  (void)strcpy(buf, msg);			/* make a copy of it */

  if (strtok(buf, delimit) != NULL)		/* message id */
   if (strtok((char *)NULL, delimit) != NULL)	/* date */
    if (strtok((char *)NULL, delimit) != NULL)	/* time */
      if ((temp=strtok((char *)NULL, delimit)) != NULL)	/* device name */
      {
	devname = temp;
	if ((temp=strtok((char *)NULL, delimit)) != NULL)    /* test name */
	  testname=temp;
      }

  if (strcmp(testname, "probe") != 0)	/* don't send the probe messages */
    send_test_msg(SUNDIAG_ATS_FAILURE, status, testname, devname, msg);

  free(buf);
}

/* to be call by msq.c(amp.c) */
udpcall(clnt, procnum, inproc, in, outproc, out, timeout)
CLIENT *clnt;
u_long procnum;
xdrproc_t inproc, outproc;
char *in, *out;
int timeout;
{
  static struct timeval waittime = {0,0};

  waittime.tv_sec = timeout;
  return(clnt_call(clnt, procnum, inproc, in, outproc, out, waittime));
}