自学教程：C++ svc_sendreply函数代码示例

void service_request(struct svc_req *rqstp, SVCXPRT * transp){	struct data *buffer;	switch (rqstp->rq_proc) {	case 0:		svc_sendreply(transp, xdr_void, (char *)0);		breakpoint();		return;	case 99:		exit(0);	case 1:		svc_getargs(transp, xdr_receive_data, (unsigned char *)&buffer);		svc_sendreply(transp, xdr_send_data, (unsigned char *)buffer);		free(buffer->data);		free(buffer);		return;	default:		svcerr_noproc(transp);		return;	}}

static voidrdictprog_1(struct svc_req *rqstp, register SVCXPRT *transp){	union {		char *insertw_1_arg;		char *deletew_1_arg;		char *lookupw_1_arg;	} argument;	char *result;	xdrproc_t _xdr_argument, _xdr_result;	char *(*local)(char *, struct svc_req *);	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);		return;	case INITW:		_xdr_argument = (xdrproc_t) xdr_void;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) initw_1_svc;		break;	case INSERTW:		_xdr_argument = (xdrproc_t) xdr_wrapstring;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) insertw_1_svc;		break;	case DELETEW:		_xdr_argument = (xdrproc_t) xdr_wrapstring;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) deletew_1_svc;		break;	case LOOKUPW:		_xdr_argument = (xdrproc_t) xdr_wrapstring;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) lookupw_1_svc;		break;	default:		svcerr_noproc (transp);		return;	}	memset ((char *)&argument, 0, sizeof (argument));	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		svcerr_decode (transp);		return;	}	result = (*local)((char *)&argument, rqstp);	if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {		svcerr_systemerr (transp);	}	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		fprintf (stderr, "%s", "unable to free arguments");		exit (1);	}	return;}

static void serverDisp(struct svc_req *rqstp, SVCXPRT *transp){     int numRec;     fprintf(stderr, "in server proc/n");     switch(rqstp->rq_proc) {     case 0:          if (svc_sendreply(transp, (xdrproc_t)xdr_void, 0) == FALSE) {               fprintf(stderr, "error in null proc/n");               exit(1);          }          return;     case PROCNUM:          break;     default:          svcerr_noproc(transp);          return;     }     if (!svc_getargs(transp, (xdrproc_t)xdr_int, (char *)&numRec)) {          svcerr_decode(transp);          return;     }     numRec++;     if (svc_sendreply(transp, (xdrproc_t)xdr_int, (char *)&numRec) == FALSE) {          fprintf(stderr, "error in sending answer/n");          exit(1);     }     return;}

/*  Función: centro_prog_1    Entrada:        rqstp: Apuntador a la structura svc_req        transp: Apuntador al registro SVCXPRT    Salida:        N/A     Función que gestiona las funciones del RPC del lado del servidor*/static void centro_prog_1(struct svc_req *rqstp, register SVCXPRT *transp){	union {		datos solicitar_desafio_1_arg;		datos respodnder_desafio_1_arg;		char *solicitar_tiempo_1_arg;		char *solicitar_gasolina_1_arg;	} argument;	char *result;	xdrproc_t _xdr_argument, _xdr_result;	char *(*local)(char *, struct svc_req *);	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);		return;	case SOLICITAR_DESAFIO:		_xdr_argument = (xdrproc_t) xdr_datos;		_xdr_result = (xdrproc_t) xdr_wrapstring;		local = (char *(*)(char *, struct svc_req *)) solicitar_desafio_1_svc;		break;	case RESPODNDER_DESAFIO:		_xdr_argument = (xdrproc_t) xdr_datos;		_xdr_result = (xdrproc_t) xdr_wrapstring;		local = (char *(*)(char *, struct svc_req *)) respodnder_desafio_1_svc;		break;	case SOLICITAR_TIEMPO:		_xdr_argument = (xdrproc_t) xdr_wrapstring;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) solicitar_tiempo_1_svc;		break;	case SOLICITAR_GASOLINA:		_xdr_argument = (xdrproc_t) xdr_wrapstring;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) solicitar_gasolina_1_svc;		break;	default:		svcerr_noproc (transp);		return;	}	memset ((char *)&argument, 0, sizeof (argument));	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		svcerr_decode (transp);		return;	}	result = (*local)((char *)&argument, rqstp);	if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {		svcerr_systemerr (transp);	}	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		fprintf (stderr, "%s", "unable to free arguments");		exit (1);	}	return;}

static voidscsi_prog_1(struct svc_req *rqstp, register SVCXPRT *transp){	union {		send_cdb_params send_cdb_1_arg;		char *reset_1_arg;	} argument;	char *result;	xdrproc_t xdr_argument, xdr_result;	char *(*local)(char *, struct svc_req *);	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply(transp, (xdrproc_t) xdr_void, (char *)NULL);		return;	case SEND_CDB:		xdr_argument = (xdrproc_t) xdr_send_cdb_params;		xdr_result = (xdrproc_t) xdr_send_cdb_retval;		local = (char *(*)(char *, struct svc_req *)) send_cdb_1_svc;		break;	case RESET:		xdr_argument = (xdrproc_t) xdr_wrapstring;		xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) reset_1_svc;		break;	default:		svcerr_noproc(transp);		return;	}	if (USE_CHILDREN) {		pid_t pid;		pid = fork();		if (pid > 0)			return;		if (pid < 0) {			perror("fork");			return;		}	}	(void) memset((char *)&argument, 0, sizeof (argument));	if (!svc_getargs(transp, xdr_argument, (caddr_t) &argument)) {		svcerr_decode(transp);		return;	}	result = (*local)((char *)&argument, rqstp);	if (result != NULL && !svc_sendreply(transp, xdr_result, result)) {		svcerr_systemerr(transp);	}	if (!svc_freeargs(transp, xdr_argument, (caddr_t) &argument)) {		fprintf(stderr, "unable to free arguments");		exit(1);	}	if (USE_CHILDREN)		_exit(0);	else		return;}

voidl2tp_event_prog_1(struct svc_req *rqstp, register SVCXPRT *transp){	union {		l2tp_session_ppp_updown_ind_1_argument l2tp_session_ppp_updown_ind_1_arg;		l2tp_session_ppp_status_ind_1_argument l2tp_session_ppp_status_ind_1_arg;		l2tp_session_ppp_accm_ind_1_argument l2tp_session_ppp_accm_ind_1_arg;	} argument;	union {	} result;	bool_t retval;	xdrproc_t _xdr_argument, _xdr_result;	bool_t (*local)(char *, void *, struct svc_req *);	if (l2tp_api_rpc_check_request(transp) < 0) return; switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);		return;	case L2TP_SESSION_PPP_UPDOWN_IND:		_xdr_argument = (xdrproc_t) xdr_l2tp_session_ppp_updown_ind_1_argument;		_xdr_result = (xdrproc_t) xdr_void;		local = (bool_t (*) (char *, void *,  struct svc_req *))_l2tp_session_ppp_updown_ind_1;		break;	case L2TP_SESSION_PPP_STATUS_IND:		_xdr_argument = (xdrproc_t) xdr_l2tp_session_ppp_status_ind_1_argument;		_xdr_result = (xdrproc_t) xdr_void;		local = (bool_t (*) (char *, void *,  struct svc_req *))_l2tp_session_ppp_status_ind_1;		break;	case L2TP_SESSION_PPP_ACCM_IND:		_xdr_argument = (xdrproc_t) xdr_l2tp_session_ppp_accm_ind_1_argument;		_xdr_result = (xdrproc_t) xdr_void;		local = (bool_t (*) (char *, void *,  struct svc_req *))_l2tp_session_ppp_accm_ind_1;		break;	default:		svcerr_noproc (transp);		return;	}	memset ((char *)&argument, 0, sizeof (argument));	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		svcerr_decode (transp);		return;	}	retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);	if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {		svcerr_systemerr (transp);	}	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		syslog (LOG_ERR, "%s", "unable to free arguments");		exit (1);	}	if (!l2tp_event_prog_1_freeresult (transp, _xdr_result, (caddr_t) &result))		syslog (LOG_ERR, "%s", "unable to free results");	return;}

static voidserverprog_1(struct svc_req *rqstp, register SVCXPRT *transp){	union {		int get_1_arg;		Message put_1_arg;	} argument;	char *result;	xdrproc_t _xdr_argument, _xdr_result;	char *(*local)(char *, struct svc_req *);	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);		return;	case get:		_xdr_argument = (xdrproc_t) xdr_int;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) get_1_svc;		break;	case put:		_xdr_argument = (xdrproc_t) xdr_Message;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) put_1_svc;		break;	case initialize:		_xdr_argument = (xdrproc_t) xdr_void;		_xdr_result = (xdrproc_t) xdr_void;		local = (char *(*)(char *, struct svc_req *)) initialize_1_svc;		break;	case teardown:		_xdr_argument = (xdrproc_t) xdr_void;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) teardown_1_svc;		break;	default:		svcerr_noproc (transp);		return;	}	memset ((char *)&argument, 0, sizeof (argument));	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		svcerr_decode (transp);		return;	}	result = (*local)((char *)&argument, rqstp);	if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {		svcerr_systemerr (transp);	}	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		fprintf (stderr, "%s", "unable to free arguments");		exit (1);	}	return;}

static voidnumeradorcliente_1(struct svc_req *rqstp, register SVCXPRT *transp){	union {		int devolveridcliente_1_arg;	} argument;	char *result;	xdrproc_t _xdr_argument, _xdr_result;	char *(*local)(char *, struct svc_req *);	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);		return;	case OBTENERIDCLIENTE:		_xdr_argument = (xdrproc_t) xdr_void;		_xdr_result = (xdrproc_t) xdr_retorno;		local = (char *(*)(char *, struct svc_req *)) obteneridcliente_1_svc;		break;	case DEVOLVERIDCLIENTE:		_xdr_argument = (xdrproc_t) xdr_int;		_xdr_result = (xdrproc_t) xdr_void;		local = (char *(*)(char *, struct svc_req *)) devolveridcliente_1_svc;		break;	case RESETEARCLIENTES:		_xdr_argument = (xdrproc_t) xdr_void;		_xdr_result = (xdrproc_t) xdr_void;		local = (char *(*)(char *, struct svc_req *)) resetearclientes_1_svc;		break;	case LISTADOCLIENTES:		_xdr_argument = (xdrproc_t) xdr_void;		_xdr_result = (xdrproc_t) xdr_retorno;		local = (char *(*)(char *, struct svc_req *)) listadoclientes_1_svc;		break;	default:		svcerr_noproc (transp);		return;	}	memset ((char *)&argument, 0, sizeof (argument));	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		svcerr_decode (transp);		return;	}	result = (*local)((char *)&argument, rqstp);	if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {		svcerr_systemerr (transp);	}	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		fprintf (stderr, "%s", "unable to free arguments");		exit (1);	}	return;}

/* * The RPC dispatch routine for this program. * Registered as a callback by svc_register() below. * Note that only NULLPROC and NOTIFICATION rpc procs are * handled by this program. */static voidnotifymeprog_5(struct svc_req *rqstp, SVCXPRT *transp){        prod_info notice;        switch (rqstp->rq_proc) {        case NULLPROC:                (void)svc_sendreply(transp, (xdrproc_t)xdr_void, (caddr_t)NULL);                return;        case NOTIFICATION:                (void) memset((char*)&notice, 0, sizeof(notice));                if (!svc_getargs(transp, (xdrproc_t)xdr_prod_info,                    (caddr_t)&notice))                {                        svcerr_decode(transp);                        return;                }                (void)exitIfDone(0);                /*                 * Update the request filter with the timestamp                 * we just recieved.                 * N.B.: There can still be duplicates after                 * a reconnect.                 */                clss.from = notice.arrival;                timestamp_incr(&clss.from);                /*                  * your code here, example just logs it                  */                log_info_q("%s", s_prod_info(NULL, 0, &notice,                        log_is_enabled_debug));                if(!svc_sendreply(transp, (xdrproc_t)xdr_ldm_replyt,                    (caddr_t) &reply))                {                        svcerr_systemerr(transp);                }                (void)exitIfDone(0);                if(!svc_freeargs(transp, xdr_prod_info, (caddr_t) &notice)) {                        log_error_q("unable to free arguments");                        exit(1);                }                /* no break */        default:                svcerr_noproc(transp);                return;        }}

static voiduniversal (struct svc_req *rqstp, SVCXPRT *transp_l){  int prog, proc;  char *outdata;  char xdrbuf[UDPMSGSIZE];  struct proglst_ *pl;  char *buf = NULL;  /*   * enforce "procnum 0 is echo" convention   */  if (rqstp->rq_proc == NULLPROC)    {      if (svc_sendreply (transp_l, (xdrproc_t)xdr_void, (char *) NULL) == FALSE)	{	  write (STDERR_FILENO, "xxx/n", 4);	  exit (1);	}      return;    }  prog = rqstp->rq_prog;  proc = rqstp->rq_proc;  for (pl = proglst; pl != NULL; pl = pl->p_nxt)    if (pl->p_prognum == prog && pl->p_procnum == proc)      {	/* decode arguments into a CLEAN buffer */	memset (xdrbuf, 0, sizeof (xdrbuf));	/* required ! */	if (!svc_getargs (transp_l, pl->p_inproc, xdrbuf))	  {	    svcerr_decode (transp_l);	    return;	  }	outdata = (*(pl->p_progname)) (xdrbuf);	if (outdata == NULL && pl->p_outproc != (xdrproc_t)xdr_void)	  /* there was an error */	  return;	if (!svc_sendreply (transp_l, pl->p_outproc, outdata))	  {	    (void) asprintf (&buf,			       _("trouble replying to prog %d/n"),			       pl->p_prognum);	    exit (1);	  }	/* free the decoded arguments */	(void) svc_freeargs (transp_l, pl->p_inproc, xdrbuf);	return;      }  (void) asprintf (&buf, _("never registered prog %d/n"), prog);#ifdef USE_IN_LIBIO  if (_IO_fwide (stderr, 0) > 0)    __fwprintf (stderr, L"%s", buf);  else#endif    fputs (buf, stderr);  free (buf);  exit (1);}

static voidcalcula_1(struct svc_req *rqstp, register SVCXPRT *transp){	union {		int start_servers_1_arg;	} argument;	char *result;	xdrproc_t _xdr_argument, _xdr_result;	char *(*local)(char *, struct svc_req *);	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);		return;	case START_SERVERS:		_xdr_argument = (xdrproc_t) xdr_int;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) start_servers_1_svc;		break;	case PASS_TOKEN:		_xdr_argument = (xdrproc_t) xdr_void;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) pass_token_1_svc;		break;	case P:		_xdr_argument = (xdrproc_t) xdr_void;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) p_1_svc;		break;	case V:		_xdr_argument = (xdrproc_t) xdr_void;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) v_1_svc;		break;	default:		svcerr_noproc (transp);		return;	}	memset ((char *)&argument, 0, sizeof (argument));	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		svcerr_decode (transp);		return;	}	result = (*local)((char *)&argument, rqstp);	if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {		svcerr_systemerr (transp);	}	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		fprintf (stderr, "%s", "unable to free arguments");		exit (1);	}	return;}

static voiduniversal (struct svc_req *rqstp, SVCXPRT *transp_l){  int prog, proc;  char *outdata;  char xdrbuf[UDPMSGSIZE];  struct proglst_ *pl;  char *buf = NULL;  /*   * enforce "procnum 0 is echo" convention   */  if (rqstp->rq_proc == NULLPROC)    {      if (svc_sendreply (transp_l, (xdrproc_t)xdr_void,			 (char *) NULL) == FALSE)	{	  __write (STDERR_FILENO, "xxx/n", 4);	  exit (1);	}      return;    }  prog = rqstp->rq_prog;  proc = rqstp->rq_proc;  for (pl = proglst; pl != NULL; pl = pl->p_nxt)    if (pl->p_prognum == prog && pl->p_procnum == proc)      {	/* decode arguments into a CLEAN buffer */	__bzero (xdrbuf, sizeof (xdrbuf));	/* required ! */	if (!svc_getargs (transp_l, pl->p_inproc, xdrbuf))	  {	    svcerr_decode (transp_l);	    return;	  }	outdata = (*(pl->p_progname)) (xdrbuf);	if (outdata == NULL && pl->p_outproc != (xdrproc_t)xdr_void)	  /* there was an error */	  return;	if (!svc_sendreply (transp_l, pl->p_outproc, outdata))	  {	    if (__asprintf (&buf, _("trouble replying to prog %d/n"),			    pl->p_prognum) < 0)	      buf = NULL;	    goto err_out2;	  }	/* free the decoded arguments */	(void) svc_freeargs (transp_l, pl->p_inproc, xdrbuf);	return;      }  if (__asprintf (&buf, _("never registered prog %d/n"), prog) < 0)    buf = NULL; err_out2:  if (buf == NULL)    exit (1);  __fxprintf (NULL, "%s", buf);  free (buf);  exit (1);}

static voidserver_program_1(struct svc_req *rqstp, register SVCXPRT *transp){	rpc_gss_rawcred_t *rcred;	rpc_gss_ucred_t *ucred;	int		i, num;	if (rqstp->rq_cred.oa_flavor != RPCSEC_GSS) {		svcerr_weakauth(transp);		return;	}					if (!rpc_gss_getcred(rqstp, &rcred, &ucred, NULL)) {		svcerr_systemerr(transp);		return;	}	printf("svc=%d, mech=%s, uid=%d, gid=%d, gids={",	    rcred->service, rcred->mechanism, ucred->uid, ucred->gid);	for (i = 0; i < ucred->gidlen; i++) {		if (i > 0) printf(",");		printf("%d", ucred->gidlist[i]);	}	printf("}/n");	switch (rqstp->rq_proc) {	case 0:		if (!svc_getargs(transp, (xdrproc_t) xdr_void, 0)) {			svcerr_decode(transp);			goto out;		}		if (!svc_sendreply(transp, (xdrproc_t) xdr_void, 0)) {			svcerr_systemerr(transp);		}		goto out;	case 1:		if (!svc_getargs(transp, (xdrproc_t) xdr_int,			(char *) &num)) {			svcerr_decode(transp);			goto out;		}		num += 100;		if (!svc_sendreply(transp, (xdrproc_t) xdr_int,			(char *) &num)) {			svcerr_systemerr(transp);		}		goto out;	default:		svcerr_noproc(transp);		goto out;	}out:	return;}

static voidcalccompprog_1(struct svc_req *rqstp, register SVCXPRT *transp){	union {		complexe add_1_arg;		complexe mul_1_arg;		complexe init_1_arg;	} argument;	char *result;	xdrproc_t _xdr_argument, _xdr_result;	char *(*local)(char *, struct svc_req *);	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);		return;	case ADD:		_xdr_argument = (xdrproc_t) xdr_complexe;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) add_1_svc;		break;	case MUL:		_xdr_argument = (xdrproc_t) xdr_complexe;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) mul_1_svc;		break;	case INIT:		_xdr_argument = (xdrproc_t) xdr_complexe;		_xdr_result = (xdrproc_t) xdr_void;		local = (char *(*)(char *, struct svc_req *)) init_1_svc;		break;	default:		svcerr_noproc (transp);		return;	}	memset ((char *)&argument, 0, sizeof (argument));	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		svcerr_decode (transp);		return;	}	result = (*local)((char *)&argument, rqstp);	if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {		svcerr_systemerr (transp);	}	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		fprintf (stderr, "%s", "unable to free arguments");		exit (1);	}	return;}

static voidgeom_prog_1(struct svc_req *rqstp, register SVCXPRT *transp){	union {		rectangle surface_rectangle_1_arg;		coordonnees creer_rectangle_1_arg;		param_inclus inclus_1_arg;	} argument;	char *result;	xdrproc_t _xdr_argument, _xdr_result;	char *(*local)(char *, struct svc_req *);	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);		return;	case SURFACE_RECTANGLE:		_xdr_argument = (xdrproc_t) xdr_rectangle;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) surface_rectangle_1_svc;		break;	case CREER_RECTANGLE:		_xdr_argument = (xdrproc_t) xdr_coordonnees;		_xdr_result = (xdrproc_t) xdr_rectangle;		local = (char *(*)(char *, struct svc_req *)) creer_rectangle_1_svc;		break;	case INCLUS:		_xdr_argument = (xdrproc_t) xdr_param_inclus;		_xdr_result = (xdrproc_t) xdr_booleen;		local = (char *(*)(char *, struct svc_req *)) inclus_1_svc;		break;	default:		svcerr_noproc (transp);		return;	}	memset ((char *)&argument, 0, sizeof (argument));	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		svcerr_decode (transp);		return;	}	result = (*local)((char *)&argument, rqstp);	if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {		svcerr_systemerr (transp);	}	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		fprintf (stderr, "%s", "unable to free arguments");		exit (1);	}	return;}

static voidsmoker_prog_1(struct svc_req *rqstp, register SVCXPRT *transp){	union {		struct smoker_id smoker_start_1_arg;		struct smoker_info smoker_proc_1_arg;		struct smoker_id smoker_exit_1_arg;	} argument;	char *result;	xdrproc_t _xdr_argument, _xdr_result;	char *(*local)(char *, struct svc_req *);	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);		return;	case SMOKER_START:		_xdr_argument = (xdrproc_t) xdr_smoker_id;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) smoker_start_1_svc;		break;	case SMOKER_PROC:		_xdr_argument = (xdrproc_t) xdr_smoker_info;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) smoker_proc_1_svc;		break;	case SMOKER_EXIT:		_xdr_argument = (xdrproc_t) xdr_smoker_id;		_xdr_result = (xdrproc_t) xdr_void;		local = (char *(*)(char *, struct svc_req *)) smoker_exit_1_svc;		break;	default:		svcerr_noproc (transp);		return;	}	memset ((char *)&argument, 0, sizeof (argument));	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		svcerr_decode (transp);		return;	}	result = (*local)((char *)&argument, rqstp);	if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {		svcerr_systemerr (transp);	}	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		fprintf (stderr, "%s", "unable to free arguments");		exit (1);	}	return;}

static voidbank_1(struct svc_req *rqstp, register SVCXPRT *transp){	union {		usr_pass init_1_arg;		usr_pass verify_1_arg;		double balance_1_arg;	} argument;	char *result;	xdrproc_t _xdr_argument, _xdr_result;	char *(*local)(char *, struct svc_req *);	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);		return;	case INIT:		_xdr_argument = (xdrproc_t) xdr_usr_pass;		_xdr_result = (xdrproc_t) xdr_double;		local = (char *(*)(char *, struct svc_req *)) init_1_svc;		break;	case VERIFY:		_xdr_argument = (xdrproc_t) xdr_usr_pass;		_xdr_result = (xdrproc_t) xdr_double;		local = (char *(*)(char *, struct svc_req *)) verify_1_svc;		break;	case BALANCE:		_xdr_argument = (xdrproc_t) xdr_double;		_xdr_result = (xdrproc_t) xdr_double;		local = (char *(*)(char *, struct svc_req *)) balance_1_svc;		break;	default:		svcerr_noproc (transp);		return;	}	memset ((char *)&argument, 0, sizeof (argument));	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		svcerr_decode (transp);		return;	}	result = (*local)((char *)&argument, rqstp);	if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {		svcerr_systemerr (transp);	}	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		fprintf (stderr, "%s", "unable to free arguments");		exit (1);	}	return;}

voidldmprog_7(struct svc_req *rqstp, register SVCXPRT *transp){	union {		char subscribe_7_arg;		VcmtpFileId request_product_7_arg;		MissedProduct deliver_product_7_arg;	} argument;	char *result;	xdrproc_t _xdr_argument, _xdr_result;	char *(*local)(char *, struct svc_req *);	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);		return;	case SUBSCRIBE:		_xdr_argument = (xdrproc_t) xdr_char;		_xdr_result = (xdrproc_t) xdr_SubscriptionReply;		local = (char *(*)(char *, struct svc_req *)) subscribe_7_svc;		break;	case REQUEST_PRODUCT:		_xdr_argument = (xdrproc_t) xdr_VcmtpFileId;		_xdr_result = (xdrproc_t) xdr_void;		local = (char *(*)(char *, struct svc_req *)) request_product_7_svc;		break;	case DELIVER_PRODUCT:		_xdr_argument = (xdrproc_t) xdr_MissedProduct;		_xdr_result = (xdrproc_t) xdr_void;		local = (char *(*)(char *, struct svc_req *)) deliver_product_7_svc;		break;	default:		svcerr_noproc (transp);		return;	}	memset ((char *)&argument, 0, sizeof (argument));	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		svcerr_decode (transp);		return;	}	result = (*local)((char *)&argument, rqstp);	if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {		svcerr_systemerr (transp);	}	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		fprintf (stderr, "%s", "unable to free arguments");		exit (1);	}	return;}

static voidtrain_1(struct svc_req *rqstp, register SVCXPRT *transp){	union {		seat is_seat_taken_1_arg;		seat reserve_seat_1_arg;	} argument;	char *result;	xdrproc_t _xdr_argument, _xdr_result;	char *(*local)(char *, struct svc_req *);	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);		return;	case is_wagon_full:		_xdr_argument = (xdrproc_t) xdr_void;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) is_wagon_full_1_svc;		break;	case is_seat_taken:		_xdr_argument = (xdrproc_t) xdr_seat;		_xdr_result = (xdrproc_t) xdr_available;		local = (char *(*)(char *, struct svc_req *)) is_seat_taken_1_svc;		break;	case reserve_seat:		_xdr_argument = (xdrproc_t) xdr_seat;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) reserve_seat_1_svc;		break;	default:		svcerr_noproc (transp);		return;	}	memset ((char *)&argument, 0, sizeof (argument));	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		svcerr_decode (transp);		return;	}	result = (*local)((char *)&argument, rqstp);	if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {		svcerr_systemerr (transp);	}	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		fprintf (stderr, "%s", "unable to free arguments");		exit (1);	}	return;}

static voidbootparamprog_1(struct svc_req *rqstp, register SVCXPRT *transp){	union {		bp_whoami_arg bootparamproc_whoami_1_arg;		bp_getfile_arg bootparamproc_getfile_1_arg;	} argument;	char *result;	bool_t (*xdr_argument)(), (*xdr_result)();	char *(*local)();	_rpcsvcdirty = 1;	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply(transp, xdr_void, (char *)NULL);		_rpcsvcdirty = 0;		return;	case BOOTPARAMPROC_WHOAMI:		xdr_argument = xdr_bp_whoami_arg;		xdr_result = xdr_bp_whoami_res;		local = (char *(*)()) bootparamproc_whoami_1;		break;	case BOOTPARAMPROC_GETFILE:		xdr_argument = xdr_bp_getfile_arg;		xdr_result = xdr_bp_getfile_res;		local = (char *(*)()) bootparamproc_getfile_1;		break;	default:		svcerr_noproc(transp);		_rpcsvcdirty = 0;		return;	}	(void) memset((char *)&argument, 0, sizeof (argument));	if (!svc_getargs(transp, xdr_argument, (caddr_t)&argument)) {		svcerr_decode(transp);		_rpcsvcdirty = 0;		return;	}	result = (*local)(&argument, rqstp);	if (result != NULL && !svc_sendreply(transp, xdr_result, result)) {		svcerr_systemerr(transp);	}	if (!svc_freeargs(transp, xdr_argument, (caddr_t)&argument)) {		msgout("unable to free arguments");		exit(EXIT_FAILURE);	}	_rpcsvcdirty = 0;}

static voiduniversal (struct svc_req *rqstp, SVCXPRT *transp){  int prog, proc;  char *outdata;  char xdrbuf[UDPMSGSIZE];  struct proglst *pl;  /*   * enforce "procnum 0 is echo" convention   */  if (rqstp->rq_proc == NULLPROC)    {      if (svc_sendreply (transp, (xdrproc_t)xdr_void, (char *) NULL) == FALSE)	{	  (void) fprintf (stderr, "xxx/n");	  exit (1);	}      return;    }  prog = rqstp->rq_prog;  proc = rqstp->rq_proc;  for (pl = proglst; pl != NULL; pl = pl->p_nxt)    if (pl->p_prognum == prog && pl->p_procnum == proc)      {	/* decode arguments into a CLEAN buffer */	__bzero (xdrbuf, sizeof (xdrbuf));	/* required ! */	if (!svc_getargs (transp, pl->p_inproc, xdrbuf))	  {	    svcerr_decode (transp);	    return;	  }	outdata = (*(pl->p_progname)) (xdrbuf);	if (outdata == NULL && pl->p_outproc != (xdrproc_t)xdr_void)	  /* there was an error */	  return;	if (!svc_sendreply (transp, pl->p_outproc, outdata))	  {	    (void) fprintf (stderr,			    _ ("trouble replying to prog %d/n"),			    pl->p_prognum);	    exit (1);	  }	/* free the decoded arguments */	(void) svc_freeargs (transp, pl->p_inproc, xdrbuf);	return;      }  (void) fprintf (stderr, _ ("never registered prog %d/n"), prog);  exit (1);}

static voidosdprog_1(struct svc_req *rqstp, register SVCXPRT *transp){	union {		data_arg date_write_1_arg;		data_req date_read_1_arg;	} argument;	char *result;	xdrproc_t _xdr_argument, _xdr_result;	char *(*local)(char *, struct svc_req *);	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);		return;	case DATE_WRITE:		_xdr_argument = (xdrproc_t) xdr_data_arg;		_xdr_result = (xdrproc_t) xdr_int;		local = (char *(*)(char *, struct svc_req *)) date_write_1_svc;		break;	case DATE_READ:		_xdr_argument = (xdrproc_t) xdr_data_req;		_xdr_result = (xdrproc_t) xdr_data_arg;		local = (char *(*)(char *, struct svc_req *)) date_read_1_svc;		break;	default:		svcerr_noproc (transp);		return;	}	memset ((char *)&argument, 0, sizeof (argument));	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		svcerr_decode (transp);		return;	}	result = (*local)((char *)&argument, rqstp);	if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) {		svcerr_systemerr (transp);	}	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {		fprintf (stderr, "%s", "unable to free arguments");		exit (1);	}	free(result);	return;}

voidautofs_mount_succeeded(am_node *mp){  SVCXPRT *transp = mp->am_transp;  struct stat stb;  if (transp) {    /* this was a mount request */    mntres res;    res.status = 0;    if (!svc_sendreply(transp,		       (XDRPROC_T_TYPE) xdr_mntres,		       (SVC_IN_ARG_TYPE) &res))      svcerr_systemerr(transp);    dlog("Quick reply sent for %s", mp->am_mnt->mf_mount);    XFREE(transp);    mp->am_transp = NULL;  }  /*   * Store dev and rdev -- but not for symlinks   */  if (!mp->am_link) {    if (!lstat(mp->am_mnt->mf_real_mount, &stb)) {      mp->am_dev = stb.st_dev;      mp->am_rdev = stb.st_rdev;    }    /* don't expire the entries -- the kernel will do it for us */    mp->am_flags |= AMF_NOTIMEOUT;  }  plog(XLOG_INFO, "autofs: mounting %s succeeded", mp->am_path);}

/* * This implements the yp "get next" function. */voidypnext(SVCXPRT *transp){	struct ypreq_key req;	struct ypresp_key_val resp;	char *fun = "ypnext";	DBM *fdb;	memset(&req, 0, sizeof (req));	memset(&resp, 0, sizeof (resp));	if (!svc_getargs(transp, (xdrproc_t)xdr_ypreq_key, (char *)&req)) {		svcerr_decode(transp);		return;	}	if ((fdb = ypset_current_map(req.map, req.domain,					&resp.status)) != NULL &&		yp_map_access(transp, &resp.status, fdb)) {		ypfilter(fdb, &req.keydat,			&resp.keydat, &resp.valdat, &resp.status, FALSE);	}	if (!svc_sendreply(transp,				(xdrproc_t)xdr_ypresp_key_val,				(char *)&resp)) {		RESPOND_ERR;	}	if (!svc_freeargs(transp,				(xdrproc_t)xdr_ypreq_key,				(char *)&req)) {		FREE_ERR;	}}

voidypmaplist(SVCXPRT *transp){	char domain_name[YPMAXDOMAIN + 1];	char *pdomain = domain_name;	char *fun = "ypmaplist";	struct ypresp_maplist maplist;	struct ypmaplist *tmp;	maplist.list = (struct ypmaplist *)NULL;	memset(domain_name, 0, sizeof (domain_name));	if (!svc_getargs(transp,				(xdrproc_t)xdr_ypdomain_wrap_string,				(caddr_t)&pdomain)) {		svcerr_decode(transp);		return;	}	maplist.status = yplist_maps(domain_name, &maplist.list);	if (!svc_sendreply(transp,				(xdrproc_t)xdr_ypresp_maplist,				(char *)&maplist)) {		RESPOND_ERR;	}	while (maplist.list) {		tmp = maplist.list->ypml_next;		free((char *)maplist.list);		maplist.list = tmp;	}}

voidypoldnext(SVCXPRT *transp){	bool dbmop_ok = TRUE;	struct yprequest req;	struct ypresponse resp;	char *fun = "ypoldnext";	DBM *fdb;	memset((void *) &req, 0, sizeof (req));	memset((void *) &resp, 0, sizeof (resp));	if (!svc_getargs(transp,				(xdrproc_t)_xdr_yprequest,				(caddr_t)&req)) {		svcerr_decode(transp);		return;	}	if (req.yp_reqtype != YPNEXT_REQTYPE) {		resp.ypnext_resp_status = (unsigned)YP_BADARGS;		dbmop_ok = FALSE;	}	if (dbmop_ok &&		((fdb = ypset_current_map(req.ypnext_req_map,					req.ypnext_req_domain,					&resp.ypnext_resp_status)) != NULL &&		yp_map_access(transp, &resp.ypnext_resp_status, fdb))) {		resp.ypnext_resp_keydat = dbm_nextkey(fdb);		if (resp.ypnext_resp_keyptr != NULL) {			resp.ypnext_resp_valdat =			dbm_fetch(fdb, resp.ypnext_resp_keydat);			if (resp.ypnext_resp_valptr != NULL) {				resp.ypnext_resp_status = YP_TRUE;			} else {				resp.ypnext_resp_status = (unsigned)YP_BADDB;			}		} else {			resp.ypnext_resp_status = (unsigned)YP_NOMORE;		}	}	resp.yp_resptype = YPNEXT_RESPTYPE;	if (!svc_sendreply(transp,				(xdrproc_t)_xdr_ypresponse,				(caddr_t)&resp)) {		RESPOND_ERR;	}	if (!svc_freeargs(transp,				(xdrproc_t)_xdr_yprequest,				(caddr_t)&req)) {		FREE_ERR;	}}

bool_trfs4_minorvers_mismatch(struct svc_req *req, SVCXPRT *xprt, void *args){	COMPOUND4args *argsp;	COMPOUND4res res_buf, *resp;	if (req->rq_vers != 4)		return (FALSE);	argsp = (COMPOUND4args *)args;	if (argsp->minorversion <= NFS4_MAX_MINOR_VERSION)		return (FALSE);	resp = &res_buf;	/*	 * Form a reply tag by copying over the reqeuest tag.	 */	resp->tag.utf8string_val =	    kmem_alloc(argsp->tag.utf8string_len, KM_SLEEP);	resp->tag.utf8string_len = argsp->tag.utf8string_len;	bcopy(argsp->tag.utf8string_val, resp->tag.utf8string_val,	    resp->tag.utf8string_len);	resp->array_len = 0;	resp->array = NULL;	resp->status = NFS4ERR_MINOR_VERS_MISMATCH;	if (!svc_sendreply(xprt,  xdr_COMPOUND4res_srv, (char *)resp)) {		DTRACE_PROBE2(nfss__e__minorvers_mismatch,		    SVCXPRT *, xprt, char *, resp);		svcerr_systemerr(xprt);	}	rfs4_compound_free(resp);	return (TRUE);}

voidautofs_mount_succeeded(am_node *mp){    SVCXPRT *transp = mp->am_transp;    struct stat stb;    char *space_hack;    if (transp) {        /* this was a mount request */        mntres res;        res.status = 0;        if (!svc_sendreply(transp,                           (XDRPROC_T_TYPE) xdr_mntres,                           (SVC_IN_ARG_TYPE) &res))            svcerr_systemerr(transp);        dlog("Quick reply sent for %s", mp->am_al->al_mnt->mf_mount);        XFREE(transp);        mp->am_transp = NULL;    }    space_hack = autofs_strdup_space_hack(mp->am_path);    if (!lstat(space_hack, &stb)) {        mp->am_dev = stb.st_dev;        mp->am_rdev = stb.st_rdev;    }    XFREE(space_hack);    /* don't expire the entries -- the kernel will do it for us */    mp->am_flags |= AMF_NOTIMEOUT;    plog(XLOG_INFO, "autofs: mounting %s succeeded", mp->am_path);}

int *is_alive_6_svc(        unsigned *id,        struct svc_req *rqstp){    static int alive;    SVCXPRT * const xprt = rqstp->rq_xprt;    int error = 0;    alive = cps_contains((pid_t) *id);    if (ulogIsDebug()) {        udebug("LDM %u is %s", *id, alive ? "alive" : "dead");    }    if (!svc_sendreply(xprt, (xdrproc_t) xdr_bool, (caddr_t) &alive)) {        svcerr_systemerr(xprt);        error = 1;    }    if (!svc_freeargs(xprt, xdr_u_int, (caddr_t)id)) {        uerror("Couldn't free arguments");        error = 1;    }    svc_destroy(xprt);    exit(error);    /*NOTREACHED*/    return NULL ;}

voidnlm_prog_0(struct svc_req *rqstp, SVCXPRT *transp){	union {		struct nlm_sm_status nlm_sm_notify_0_arg;	} argument;	char result;	bool_t retval;	xdrproc_t xdr_argument, xdr_result;	bool_t (*local)(char *, void *, struct svc_req *);	switch (rqstp->rq_proc) {	case NULLPROC:		(void) svc_sendreply(rqstp,			(xdrproc_t) xdr_void, (char *)NULL);		svc_freereq(rqstp);		return;	case NLM_SM_NOTIFY:		xdr_argument = (xdrproc_t) xdr_nlm_sm_status;		xdr_result = (xdrproc_t) xdr_void;		local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_sm_notify_0_svc;		break;	default:		svcerr_noproc(rqstp);		svc_freereq(rqstp);		return;	}	(void) memset((char *)&argument, 0, sizeof (argument));	if (!svc_getargs(rqstp, xdr_argument, (char *)(caddr_t) &argument)) {		svcerr_decode(rqstp);		svc_freereq(rqstp);		return;	}	retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);	if (retval > 0 && !svc_sendreply(rqstp, xdr_result, (char *)&result)) {		svcerr_systemerr(rqstp);	}	if (!svc_freeargs(rqstp, xdr_argument, (char *)(caddr_t) &argument)) {		printf("unable to free arguments");		//exit(1);	}	svc_freereq(rqstp);	return;}