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 void rdictprog_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 void scsi_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; }
void l2tp_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 void serverprog_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 void numeradorcliente_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 void notifymeprog_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*)¬ice, 0, sizeof(notice)); if (!svc_getargs(transp, (xdrproc_t)xdr_prod_info, (caddr_t)¬ice)) { 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, ¬ice, 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) ¬ice)) { log_error_q("unable to free arguments"); exit(1); } /* no break */ default: svcerr_noproc(transp); return; } }
static void universal (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 void calcula_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 void universal (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 void server_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 void calccompprog_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 void geom_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 void smoker_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 void bank_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; }
void ldmprog_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 void train_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 void bootparamprog_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 void universal (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 void osdprog_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; }
void autofs_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. */ void ypnext(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; } }
void ypmaplist(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; } }
void ypoldnext(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_t rfs4_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); }
void autofs_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 ; }
void nlm_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; }