/** * Gets FSID and PID by path and cuts path to relative path for FS * @param path Path to file * @param parent If FS of parent directory of file is needed * @return FSID */ static struct fslist_item *fsbypath(char *path,int parent) { if (path==NULL || path[0]==0) return NULL; struct fslist_item *fs = mp_match(path,parent); if (fs==NULL) { fs = malloc(sizeof(struct fslist_item)); char *mountpoint = strdup(path); fs->id = rpc_call("vfs_getfsid",RPC_FLAG_RETPARAMS,path,parent); if (fs->id<0) { free(mountpoint); errno = -fs->id; return NULL; } fs->pid = rpc_call("vfs_getpid",0,fs->id); if (fs->pid<0) { errno = -fs->pid; return NULL; } mountpoint[strlen(mountpoint)-strlen(path)] = 0; fs->mountpoint = path_parse(mountpoint); fs->mountpoint_str = path_output(fs->mountpoint,NULL); free(mountpoint); llist_push(fslist,fs); } return fs; }
/* * Bare-bones access to getattr: this is for nfs_read_super. */ static int nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *info) { struct nfs_fattr *fattr = info->fattr; struct nfs2_fsstat fsinfo; int status; dprintk("%s: call getattr\n", __FUNCTION__); fattr->valid = 0; status = rpc_call(server->client_sys, NFSPROC_GETATTR, fhandle, fattr, 0); dprintk("%s: reply getattr %d\n", __FUNCTION__, status); if (status) return status; dprintk("%s: call statfs\n", __FUNCTION__); status = rpc_call(server->client_sys, NFSPROC_STATFS, fhandle, &fsinfo, 0); dprintk("%s: reply statfs %d\n", __FUNCTION__, status); if (status) return status; info->rtmax = NFS_MAXDATA; info->rtpref = fsinfo.tsize; info->rtmult = fsinfo.bsize; info->wtmax = NFS_MAXDATA; info->wtpref = fsinfo.tsize; info->wtmult = fsinfo.bsize; info->dtpref = fsinfo.tsize; info->maxfilesize = 0x7FFFFFFF; info->lease_time = 0; return 0; }
int main(int argn, char *argc[]) { //Program parameters : argc[1] : HostName or Host IP // argc[2] : Server Program Number // other arguments depend on test case //run_mode can switch into stand alone program or program launch by shell script //1 : stand alone, debug mode, more screen information //0 : launch by shell script as test case, only one printf -> result status int run_mode = 0; int test_status = 1; //Default test result set to FAILED int progNum = atoi(argc[2]); char nettype[16] = "visible"; int sndVar = 0; int recVar = -1; struct timeval total_timeout; enum clnt_stat rslt; CLIENT *clnt = NULL; if (run_mode == 1) { printf("Server : %s\n", argc[1]); printf("Server # %d\n", progNum); printf("Net : %s\n", nettype); } //Initialisation total_timeout.tv_sec = 1; total_timeout.tv_usec = 1; /**/ clnt = clnt_create(argc[1], progNum, VERSNUM, nettype); //Multiple test case rslt = rpc_call(argc[1], progNum, VERSNUM, PROCNUM, (xdrproc_t) xdr_int, (char *)&sndVar, (xdrproc_t) xdr_int, (char *)&recVar, nettype); clnt_perror(clnt, "Success"); rslt = rpc_call(argc[1], 1, VERSNUM, PROCNUM, (xdrproc_t) xdr_int, (char *)&sndVar, (xdrproc_t) xdr_int, (char *)&recVar, nettype); clnt_perror(clnt, "Wrong Prog"); rslt = rpc_call(argc[1], progNum, 10, PROCNUM, (xdrproc_t) xdr_int, (char *)&sndVar, (xdrproc_t) xdr_int, (char *)&recVar, nettype); clnt_perror(clnt, "Wrong Vers"); rslt = rpc_call(argc[1], progNum, VERSNUM, PROCNUM, (xdrproc_t) xdr_int, (char *)&sndVar, (xdrproc_t) xdr_int, (char *)&recVar, "wrong"); clnt_perror(clnt, "Wrong Proto"); //If we are here, test has passed test_status = 0; //This last printf gives the result status to the tests suite //normally should be 0: test has passed or 1: test has failed printf("%d\n", test_status); return test_status; }
YAAMP_JOB_TEMPLATE *coind_create_template_memorypool(YAAMP_COIND *coind) { json_value *json = rpc_call(&coind->rpc, "getmemorypool"); if(!json || json->type == json_null) { coind_error(coind, "getmemorypool"); return NULL; } json_value *json_result = json_get_object(json, "result"); if(!json_result || json_result->type == json_null) { coind_error(coind, "getmemorypool"); json_value_free(json); return NULL; } YAAMP_JOB_TEMPLATE *templ = new YAAMP_JOB_TEMPLATE; memset(templ, 0, sizeof(YAAMP_JOB_TEMPLATE)); templ->created = time(NULL); templ->value = json_get_int(json_result, "coinbasevalue"); // templ->height = json_get_int(json_result, "height"); sprintf(templ->version, "%08x", (unsigned int)json_get_int(json_result, "version")); sprintf(templ->ntime, "%08x", (unsigned int)json_get_int(json_result, "time")); strcpy(templ->nbits, json_get_string(json_result, "bits")); strcpy(templ->prevhash_hex, json_get_string(json_result, "previousblockhash")); json_value_free(json); json = rpc_call(&coind->rpc, "getinfo", "[]"); if(!json || json->type == json_null) { coind_error(coind, "coind_getinfo"); return NULL; } json_result = json_get_object(json, "result"); if(!json_result || json_result->type == json_null) { coind_error(coind, "coind_getinfo"); json_value_free(json); return NULL; } templ->height = json_get_int(json_result, "blocks")+1; json_value_free(json); if(coind->isaux) coind_getauxblock(coind); coind->usememorypool = true; return templ; }
int main(int argc, char **argv) { enum clnt_stat stat; char *hostname; nlm4_notify notify; if (argc != 2) { fprintf(stderr, "Usage: clear_locks <hostname>\n"); exit(1); } hostname = argv[1]; if (geteuid() != 0) { fprintf(stderr, "clear_locks: must be root\n"); exit(1); } notify.name = hostname; notify.state = 0; stat = rpc_call("localhost", NLM_PROG, NLM_VERS4, NLM4_FREE_ALL, (xdrproc_t) xdr_nlm4_notify, (void *) ¬ify, (xdrproc_t) xdr_void, NULL, NULL); if (stat != RPC_SUCCESS) { clnt_perrno(stat); exit(1); } fprintf(stderr, "clear_locks: cleared locks for hostname %s\n", hostname); return (0); }
static int8_t rpc_rcmd(node_id_t node, char *cmd) { int8_t rc = NRK_OK; uint8_t reply_len = sizeof(reply_buf); uint8_t req_len = 0; LOG("remote cmd to "); LOGP("%u: ", node); LOGP("%s\r\n", cmd); req_len += strlen(cmd) + 1; /* include null byte */ rc = rpc_call(&rcmd_endpoint.client, node, PORT_RPC_SERVER_RCMD, RPC_RCMD, &rcmd_rpc_time_out, (uint8_t *)cmd_buf, req_len, reply_buf, &reply_len); if (rc != NRK_OK) { LOG("WARN: rcmd rpc failed\r\n"); return rc; } #if 0 /* TODO: make cmds return a code */ if (reply_len != RPC_RCMD_REPLY_LEN) { LOG("WARN: rcmd reply of unexpected length\r\n"); return NRK_ERROR; } rc = reply_buf[RPC_RCMD_REPLY_RC_OFFSET]; LOG("rpc rcmd rc: "); LOGP("%d\r\n", rc); #endif return NRK_OK; }
static int rpc_call_result(rpc_t *rpc, rpc_request_t *req) { LOG_ENTRY; int rc = -1; if (!rpc) { RPC_ERROR("rpc is NULL"); goto fail; } if (!req) { RPC_ERROR("request is NULL"); goto fail; } rc = rpc_call(rpc, req); if (rc < 0) { RPC_ERROR("rpc_call failed %d", rc); goto fail; } RPC_DEBUG("%s: rpc_call done", __func__); size_t idx = 0; RPC_UNPACK(req->reply.buffer, idx, rc); fail: LOG_EXIT; return rc; }
unsigned int map_getport(mapping_t* pmap) { int port; struct pbuf *pbuf; struct pbuf *ret; debug("Getting port\n"); pmap->port = 0; /* add the xid */ pbuf = initbuf(PMAP_NUMBER, PMAP_VERSION, PMAPPROC_GETPORT); /* pack up the map struct */ addtobuf(pbuf, (char*) pmap, sizeof(mapping_t)); /* make the call */ ret = rpc_call(pbuf, PMAP_PORT); assert(ret != NULL); /* now we can extract the port */ getfrombuf(ret, (char*) &port, sizeof(port)); pmap->port = port; debug("Got port %d\n", port); return 0; }
unsigned int mnt_mount(char *dir, struct cookie *pfh) { struct pbuf *pbuf, *ret; int status; pbuf = initbuf(MNT_NUMBER, MNT_VERSION, MNTPROC_MNT); addstring(pbuf, dir); ret = rpc_call(pbuf, mount_port); if (ret == 0) { debug( "mount call failed :(\n" ); return 1; } /* now we do some stuff :) */ getfrombuf(ret, (char*) &status, sizeof(status)); if (status != 0) { debug( "Could not mount %s, %d!\n", dir, status ); return 1; } debug("All seems good for mount: %s!\n", dir); getfrombuf(ret, (char*) pfh, sizeof(struct cookie)); return 0; }
/* * Bare-bones access to getattr: this is for nfs_read_super. */ static int nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *info) { int status; dprintk("%s: call fsinfo\n", __FUNCTION__); info->fattr->valid = 0; status = rpc_call(server->client_sys, NFS3PROC_FSINFO, fhandle, info, 0); dprintk("%s: reply fsinfo: %d\n", __FUNCTION__, status); if (!(info->fattr->valid & NFS_ATTR_FATTR)) { status = rpc_call(server->client_sys, NFS3PROC_GETATTR, fhandle, info->fattr, 0); dprintk("%s: reply getattr: %d\n", __FUNCTION__, status); } return status; }
static void ril_ni_message(uint8_t *msg, size_t len) { LOG_ENTRY; if (!msg || !len) { RPC_ERROR("%s: msg is NULL", __func__); goto fail; } struct rpc_request_t req = { .header = { .code = RIL_NI_MSG, } }; char *buf = req.header.buffer; size_t idx = 0; memset(req.header.buffer, 0, RPC_PAYLOAD_MAX); RPC_PACK(buf, idx, len); RPC_PACK_RAW(buf, idx, msg, len); req.header.buffer[RPC_PAYLOAD_MAX - 1] = '\0'; rpc_call(gps_rpc, &req); fail: LOG_EXIT; }
static int8_t rpc_ping(node_id_t node, uint8_t token) { int8_t rc = NRK_OK; uint8_t reply_token; uint8_t reply_len = sizeof(reply_buf); uint8_t req_len = 0; LOG("call ping rpc\r\n"); req_buf[RPC_PING_REQ_TOKEN_OFFSET] = token; req_len += RPC_PING_REQ_TOKEN_LEN; rc = rpc_call(&rping_endpoint.client, node, PORT_RPC_SERVER_PING, RPC_PING, &ping_time_out, req_buf, req_len, reply_buf, &reply_len); if (rc != NRK_OK) { LOG("WARN: ping rpc failed\r\n"); return rc; } if (reply_len != RPC_PING_REPLY_LEN) { LOG("WARN: ping reply of unexpected length\r\n"); return NRK_ERROR; } reply_token = reply_buf[RPC_PING_REPLY_TOKEN_OFFSET]; if (reply_token != token) { LOG("WARN: unexpected token in ping reply\r\n"); return NRK_ERROR; } return rc; }
int rpc_peer_call(struct rpc *r, uint32_t uuid, uint32_t cmd_id, const void *in_arg, size_t in_len, void *out_arg, size_t out_len) { r->send_pkt.header.uuid_dst = uuid; return rpc_call(r, cmd_id, in_arg, in_len, out_arg, out_len); }
static int8_t rpc_heading(node_id_t node, int16_t *heading) { int8_t rc = NRK_OK; uint8_t reply_len = sizeof(reply_buf); uint8_t req_len = 0; rc = rpc_call(&compass_endpoint.client, node, PORT_RPC_SERVER_COMPASS, RPC_HEADING, &compass_rpc_time_out, req_buf, req_len, reply_buf, &reply_len); if (rc != NRK_OK) { LOG("WARN: heading rpc failed\r\n"); return rc; } if (reply_len != RPC_HEADING_REPLY_LEN) { LOG("WARN: heading reply of unexpected length\r\n"); return NRK_ERROR; } *heading = reply_buf[RPC_HEADING_REPLY_HEADING_OFFSET + 1]; *heading <<= 8; *heading |= reply_buf[RPC_HEADING_REPLY_HEADING_OFFSET]; memcpy(mag_uT, reply_buf + RPC_HEADING_REPLY_MAG_OFFSET, sizeof(mag_uT)); return NRK_OK; }
bool coind_submitgetauxblock(YAAMP_COIND *coind, const char *hash, const char *block) { int paramlen = strlen(block); char *params = (char *)malloc(paramlen+1024); if(!params) return false; sprintf(params, "[\"%s\",\"%s\"]", hash, block); json_value *json = rpc_call(&coind->rpc, "getauxblock", params); free(params); if(!json) return false; json_value *json_error = json_get_object(json, "error"); if(json_error && json_error->type != json_null) { const char *p = json_get_string(json_error, "message"); if(p) stratumlog("ERROR %s %s\n", coind->name, p); // job_reset(); json_value_free(json); return false; } json_value *json_result = json_get_object(json, "result"); bool b = json_result && json_result->type == json_boolean && json_result->u.boolean; json_value_free(json); return b; }
void *my_thread_process(void *arg) { int i; struct datas vars; static double result = 0; if (run_mode == 1) { fprintf(stderr, "Thread %d\n", atoi(arg)); } vars.a = getRand(); vars.b = getRand(); vars.c = getRand(); resTbl[atoi(arg)].locRes = vars.a + (vars.b * vars.c); rpc_call(hostname, progNum, VERSNUM, CALCTHREADPROC, (xdrproc_t) xdr_datas, (char *)&vars, // xdr_in (xdrproc_t) xdr_double, (char *)&resTbl[atoi(arg)].svcRes, // xdr_out nettype); thread_array_result[atoi(arg)] = (resTbl[atoi(arg)].svcRes == resTbl[atoi(arg)].locRes) ? 0 : 1; if (run_mode == 1) { fprintf(stderr, "Thread #%d calc : %lf, received : %lf\n", atoi(arg), resTbl[atoi(arg)].locRes, resTbl[atoi(arg)].svcRes); } pthread_exit(0); }
static void ril_set_ref_location(const AGpsRefLocation *agps_reflocation, size_t sz_struct) { LOG_ENTRY; if (!agps_reflocation || !sz_struct) { RPC_ERROR("%s: agps_reflocation is NULL", __func__); goto fail; } struct rpc_request_t req = { .header = { .code = RIL_SET_REF_LOC, } }; char *buf = req.header.buffer; size_t idx = 0; memset(req.header.buffer, 0, RPC_PAYLOAD_MAX); RPC_PACK(buf, idx, sz_struct); RPC_PACK_RAW(buf, idx, agps_reflocation, sz_struct); rpc_call(gps_rpc, &req); fail: LOG_EXIT; }
static int nfs3_proc_mknod(struct inode *dir, struct qstr *name, struct iattr *sattr, dev_t rdev, struct nfs_fh *fh, struct nfs_fattr *fattr) { struct nfs_fattr dir_attr; struct nfs3_mknodargs arg = { NFS_FH(dir), name->name, name->len, 0, sattr, rdev }; struct nfs3_diropres res = { &dir_attr, fh, fattr }; int status; switch (sattr->ia_mode & S_IFMT) { case S_IFBLK: arg.type = NF3BLK; break; case S_IFCHR: arg.type = NF3CHR; break; case S_IFIFO: arg.type = NF3FIFO; break; case S_IFSOCK: arg.type = NF3SOCK; break; default: return -EINVAL; } dprintk("NFS call mknod %s %x\n", name->name, rdev); dir_attr.valid = 0; fattr->valid = 0; status = rpc_call(NFS_CLIENT(dir), NFS3PROC_MKNOD, &arg, &res, 0); nfs_refresh_inode(dir, &dir_attr); dprintk("NFS reply mknod: %d\n", status); return status; }
static int _nfs_unlink(nfs_fs *nfs, nfs_vnode *dir, const char *name, stream_type type) { int err; uint8 argbuf[NFS_DIROPARGS_MAXLEN]; nfs_diropargs args; size_t arglen; nfs_status res; int proc; /* start building the args */ args.dir = &dir->nfs_handle; args.name.name = name; arglen = nfs_pack_diropargs(argbuf, &args); switch (type) { case STREAM_TYPE_FILE: proc = NFSPROC_REMOVE; break; case STREAM_TYPE_DIR: proc = NFSPROC_RMDIR; break; default: panic("_nfs_unlink asked to remove file type it doesn't understand\n"); } err = rpc_call(&nfs->rpc, NFSPROG, NFSVERS, proc, argbuf, arglen, &res, sizeof(res)); if (err < 0) return err; return nfs_status_to_error(ntohl(res)); }
static void ril_set_set_id(AGpsSetIDType type, const char *setid) { LOG_ENTRY; if (!setid) { RPC_ERROR("%s: setid is NULL", __func__); goto fail; } struct rpc_request_t req = { .header = { .code = RIL_SET_SET_ID, } }; char *buf = req.header.buffer; size_t idx = 0; memset(req.header.buffer, 0, RPC_PAYLOAD_MAX); RPC_PACK(buf, idx, type); RPC_PACK_S(buf, idx, setid); req.header.buffer[RPC_PAYLOAD_MAX - 1] = '\0'; rpc_call(gps_rpc, &req); fail: LOG_EXIT; }
static int nfs3_proc_access(struct inode *inode, int mode, int ruid) { struct nfs_fattr fattr; struct nfs3_accessargs arg = { NFS_FH(inode), 0 }; struct nfs3_accessres res = { &fattr, 0 }; int status, flags; dprintk("NFS call access\n"); fattr.valid = 0; if (mode & MAY_READ) arg.access |= NFS3_ACCESS_READ; if (S_ISDIR(inode->i_mode)) { if (mode & MAY_WRITE) arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE; if (mode & MAY_EXEC) arg.access |= NFS3_ACCESS_LOOKUP; } else { if (mode & MAY_WRITE) arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND; if (mode & MAY_EXEC) arg.access |= NFS3_ACCESS_EXECUTE; } flags = (ruid) ? RPC_CALL_REALUID : 0; status = rpc_call(NFS_CLIENT(inode), NFS3PROC_ACCESS, &arg, &res, flags); nfs_refresh_inode(inode, &fattr); dprintk("NFS reply access\n"); if (status == 0 && (arg.access & res.access) != arg.access) status = -EACCES; return status; }
static int nfs_mount_fs(nfs_fs *nfs, const char *server_path) { uint8 sendbuf[256]; char buf[128]; nfs_mountargs args; size_t arglen; int err; rpc_set_port(&nfs->rpc, nfs->mount_port); args.dirpath = server_path; arglen = nfs_pack_mountargs(sendbuf, &args); err = rpc_call(&nfs->rpc, MOUNTPROG, MOUNTVERS, MOUNTPROC_MNT, sendbuf, arglen, buf, sizeof(buf)); if(err < 0) return err; #if NFS_TRACE TRACE("nfs_mount_fs: have root fhandle: "); dump_fhandle((const nfs_fhandle *)&buf[4]); TRACE("\n"); #endif // we should have the root handle now memcpy(&nfs->root_vnode->nfs_handle, &buf[4], sizeof(nfs->root_vnode->nfs_handle)); // set the rpc port to the nfs server rpc_set_port(&nfs->rpc, nfs->nfs_port); return 0; }
bool coind_validate_address(YAAMP_COIND *coind) { if(!coind->wallet[0]) return false; char params[YAAMP_SMALLBUFSIZE]; sprintf(params, "[\"%s\"]", coind->wallet); json_value *json = rpc_call(&coind->rpc, "validateaddress", params); if(!json) return false; json_value *json_result = json_get_object(json, "result"); if(!json_result) { json_value_free(json); return false; } bool isvalid = json_get_bool(json_result, "isvalid"); if(!isvalid) stratumlog("%s wallet %s is not valid.\n", coind->name, coind->wallet); bool ismine = json_get_bool(json_result, "ismine"); if(!ismine) stratumlog("%s wallet %s is not mine.\n", coind->name, coind->wallet); const char *p = json_get_string(json_result, "pubkey"); if(p) strcpy(coind->pubkey, p); json_value_free(json); base58_decode(coind->wallet, coind->script_pubkey); return isvalid && ismine; }
/* * Common procedure for SM_MON/SM_UNMON calls */ static int nsm_mon_unmon(struct nlm_host *host, u32 proc, struct nsm_res *res) { struct rpc_clnt *clnt; int status; struct nsm_args args; clnt = nsm_create(); if (IS_ERR(clnt)) { status = PTR_ERR(clnt); goto out; } args.addr = host->h_addr.sin_addr.s_addr; args.proto= (host->h_proto<<1) | host->h_server; args.prog = NLM_PROGRAM; args.vers = host->h_version; args.proc = NLMPROC_NSM_NOTIFY; memset(res, 0, sizeof(*res)); status = rpc_call(clnt, proc, &args, res, 0); if (status < 0) printk(KERN_DEBUG "nsm_mon_unmon: rpc failed, status=%d\n", status); else status = 0; out: return status; }
unsigned int mnt_get_export_list(void) { struct pbuf *pbuf; struct pbuf *ret; char str[100]; int opt; pbuf = initbuf(MNT_NUMBER, MNT_VERSION, MNTPROC_EXPORT); ret = rpc_call(pbuf, mount_port); while (getfrombuf(ret, (char*) &opt, sizeof(opt)), opt) { debug( "NFS Export...\n" ); getstring(ret, str, 100); debug( "* Export name is %s\n", (char*) &str ); /* now to extract more stuff... */ while (getfrombuf(ret, (char*) &opt, sizeof(opt)), opt) { getstring(ret, str, 100 ); debug("* Group %s\n", (char*) str); } } return 0; }
void *my_thread_process(void *arg) { enum clnt_stat rslt; int sndVar = atoi(arg); int recVar; int i; if (run_mode == 1) { fprintf(stderr, "Thread %d\n", atoi(arg)); fprintf(stderr, "%s\n", nettype); fprintf(stderr, "%s\n", hostname); fprintf(stderr, "Value sent : %d\n", sndVar); } for (i = 0; i < callNb; i++) { rslt = rpc_call(hostname, progNum + atoi(arg), VERSNUM, PROCNUM, (xdrproc_t) xdr_int, (char *)&sndVar, // xdr_in (xdrproc_t) xdr_int, (char *)&recVar, // xdr_out nettype); /**/ //printf("Value received : %d\n", recVar); thread_array_result[atoi(arg)] = thread_array_result[atoi(arg)] + (rslt == RPC_SUCCESS); } pthread_exit(0); }
void coind_getauxblock(YAAMP_COIND *coind) { if(!coind->isaux) return; json_value *json = rpc_call(&coind->rpc, "getauxblock", "[]"); if(!json) { coind_error(coind, "coind_getauxblock"); return; } json_value *json_result = json_get_object(json, "result"); if(!json_result) { coind_error(coind, "coind_getauxblock"); return; } // coind->aux.height = coind->height+1; coind->aux.chainid = json_get_int(json_result, "chainid"); const char *p = json_get_string(json_result, "target"); if(p) strcpy(coind->aux.target, p); p = json_get_string(json_result, "hash"); if(p) strcpy(coind->aux.hash, p); // if(strcmp(coind->symbol, "UNO") == 0) // { // string_be1(coind->aux.target); // string_be1(coind->aux.hash); // } json_value_free(json); }
int rpc_peer_post_msg(struct rpc *r, void *buf, size_t len) { rpc_call(r, RPC_PEER_POST_MSG, buf, len, NULL, 0); //printf("func_id = %x\n", RPC_PEER_POST_MSG); //dump_packet(&r->packet); return 0; }
/* * For connectionless "udp" transport. Obsoleted by rpc_call(). */ int callrpc(char *host, int prognum, int versnum, int procnum, xdrproc_t inproc, char *in, xdrproc_t outproc, char *out) { return (int)rpc_call(host, (rpcprog_t)prognum, (rpcvers_t)versnum, (rpcproc_t)procnum, inproc, in, outproc, out, "udp"); }
/* * For connectionless "udp" transport. Obsoleted by rpc_call(). */ int callrpc(char *host, rpcprog_t prognum, rpcvers_t versnum, rpcproc_t procnum, xdrproc_t inproc, char *in, xdrproc_t outproc, char *out) { return ((int)rpc_call(host, prognum, versnum, procnum, inproc, in, outproc, out, "udp")); }