2017-07-08 02:55:14 +03:00
|
|
|
/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */
|
2011-02-06 07:45:09 +03:00
|
|
|
/*
|
|
|
|
Copyright (C) 2010 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU Lesser General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
|
|
along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
2013-05-29 04:38:37 +04:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
2013-04-14 21:32:01 +04:00
|
|
|
#ifdef AROS
|
|
|
|
#include "aros_compat.h"
|
|
|
|
#endif
|
|
|
|
|
2021-09-10 05:01:31 +03:00
|
|
|
#ifdef PS2_EE
|
|
|
|
#include "ps2_compat.h"
|
|
|
|
#endif
|
|
|
|
|
2020-08-14 17:47:39 +03:00
|
|
|
#ifdef PS3_PPU
|
|
|
|
#include "ps3_compat.h"
|
|
|
|
#endif
|
|
|
|
|
2011-09-01 23:35:54 +04:00
|
|
|
#ifdef WIN32
|
2018-04-16 22:38:38 +03:00
|
|
|
#include <win32/win32_compat.h>
|
2013-05-29 04:54:12 +04:00
|
|
|
#endif
|
2011-08-28 13:43:33 +04:00
|
|
|
|
2013-05-29 04:38:37 +04:00
|
|
|
#ifdef HAVE_NETINET_IN_H
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#endif
|
|
|
|
|
2013-05-29 04:43:47 +04:00
|
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#endif
|
|
|
|
|
2013-05-29 04:54:12 +04:00
|
|
|
#ifdef HAVE_STRINGS_H
|
|
|
|
#include <strings.h>
|
|
|
|
#endif
|
|
|
|
|
2011-08-28 13:43:33 +04:00
|
|
|
#include <stdio.h>
|
2011-06-01 20:06:15 +04:00
|
|
|
#include <stdlib.h>
|
2012-07-04 10:53:12 +04:00
|
|
|
#include <string.h>
|
2012-11-24 20:18:54 +04:00
|
|
|
#include <assert.h>
|
2011-06-26 12:24:24 +04:00
|
|
|
#include <errno.h>
|
2011-02-06 07:45:09 +03:00
|
|
|
#include "slist.h"
|
2012-07-04 10:53:12 +04:00
|
|
|
#include "libnfs-zdr.h"
|
2011-02-06 07:45:09 +03:00
|
|
|
#include "libnfs.h"
|
|
|
|
#include "libnfs-raw.h"
|
|
|
|
#include "libnfs-private.h"
|
|
|
|
|
2014-01-07 14:23:46 +04:00
|
|
|
void rpc_reset_queue(struct rpc_queue *q)
|
|
|
|
{
|
|
|
|
q->head = NULL;
|
|
|
|
q->tail = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Push to the tail end of the queue
|
|
|
|
*/
|
|
|
|
void rpc_enqueue(struct rpc_queue *q, struct rpc_pdu *pdu)
|
|
|
|
{
|
|
|
|
if (q->head == NULL)
|
|
|
|
q->head = pdu;
|
|
|
|
else
|
|
|
|
q->tail->next = pdu;
|
|
|
|
q->tail = pdu;
|
2014-02-27 16:52:54 +04:00
|
|
|
pdu->next = NULL;
|
2014-01-07 14:23:46 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Push to the front/head of the queue
|
|
|
|
*/
|
|
|
|
void rpc_return_to_queue(struct rpc_queue *q, struct rpc_pdu *pdu)
|
|
|
|
{
|
|
|
|
pdu->next = q->head;
|
|
|
|
q->head = pdu;
|
|
|
|
if (q->tail == NULL)
|
|
|
|
q->tail = pdu;
|
|
|
|
}
|
|
|
|
|
2014-02-20 18:02:08 +04:00
|
|
|
unsigned int rpc_hash_xid(uint32_t xid)
|
|
|
|
{
|
|
|
|
return (xid * 7919) % HASHES;
|
|
|
|
}
|
|
|
|
|
2016-02-01 03:12:36 +03:00
|
|
|
#define PAD_TO_8_BYTES(x) ((x + 0x07) & ~0x07)
|
|
|
|
|
2016-11-29 16:36:59 +03:00
|
|
|
static struct rpc_pdu *rpc_allocate_reply_pdu(struct rpc_context *rpc,
|
|
|
|
struct rpc_msg *res,
|
|
|
|
size_t alloc_hint)
|
|
|
|
{
|
|
|
|
struct rpc_pdu *pdu;
|
|
|
|
|
|
|
|
assert(rpc->magic == RPC_CONTEXT_MAGIC);
|
|
|
|
|
|
|
|
pdu = malloc(sizeof(struct rpc_pdu));
|
|
|
|
if (pdu == NULL) {
|
|
|
|
rpc_set_error(rpc, "Out of memory: Failed to allocate pdu structure");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
memset(pdu, 0, sizeof(struct rpc_pdu));
|
|
|
|
pdu->flags = PDU_DISCARD_AFTER_SENDING;
|
|
|
|
pdu->xid = 0;
|
|
|
|
pdu->cb = NULL;
|
|
|
|
pdu->private_data = NULL;
|
|
|
|
pdu->zdr_decode_fn = NULL;
|
|
|
|
pdu->zdr_decode_bufsize = 0;
|
|
|
|
|
|
|
|
pdu->outdata.data = malloc(ZDR_ENCODEBUF_MINSIZE + alloc_hint);
|
|
|
|
if (pdu->outdata.data == NULL) {
|
|
|
|
rpc_set_error(rpc, "Out of memory: Failed to allocate encode buffer");
|
2017-02-08 14:29:49 +03:00
|
|
|
free(pdu);
|
2016-11-29 16:36:59 +03:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
zdrmem_create(&pdu->zdr, pdu->outdata.data, ZDR_ENCODEBUF_MINSIZE + alloc_hint, ZDR_ENCODE);
|
|
|
|
if (rpc->is_udp == 0) {
|
|
|
|
zdr_setpos(&pdu->zdr, 4); /* skip past the record marker */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (zdr_replymsg(rpc, &pdu->zdr, res) == 0) {
|
|
|
|
rpc_set_error(rpc, "zdr_replymsg failed with %s",
|
|
|
|
rpc_get_error(rpc));
|
|
|
|
zdr_destroy(&pdu->zdr);
|
2017-02-08 14:29:49 +03:00
|
|
|
free(pdu->outdata.data);
|
2016-11-29 16:36:59 +03:00
|
|
|
free(pdu);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pdu;
|
|
|
|
}
|
|
|
|
|
2016-06-02 10:12:53 +03:00
|
|
|
struct rpc_pdu *rpc_allocate_pdu2(struct rpc_context *rpc, int program, int version, int procedure, rpc_cb cb, void *private_data, zdrproc_t zdr_decode_fn, int zdr_decode_bufsize, size_t alloc_hint)
|
2011-02-06 07:45:09 +03:00
|
|
|
{
|
|
|
|
struct rpc_pdu *pdu;
|
|
|
|
struct rpc_msg msg;
|
2016-02-01 03:12:36 +03:00
|
|
|
int pdu_size;
|
2011-02-06 07:45:09 +03:00
|
|
|
|
2012-11-24 20:18:54 +04:00
|
|
|
assert(rpc->magic == RPC_CONTEXT_MAGIC);
|
2011-02-06 07:45:09 +03:00
|
|
|
|
2016-02-01 03:12:36 +03:00
|
|
|
/* Since we already know how much buffer we need for the decoding
|
|
|
|
* we can just piggyback in the same alloc as for the pdu.
|
|
|
|
*/
|
|
|
|
pdu_size = PAD_TO_8_BYTES(sizeof(struct rpc_pdu));
|
|
|
|
pdu_size += PAD_TO_8_BYTES(zdr_decode_bufsize);
|
|
|
|
|
|
|
|
pdu = malloc(pdu_size);
|
2011-02-06 07:45:09 +03:00
|
|
|
if (pdu == NULL) {
|
2011-06-19 03:38:20 +04:00
|
|
|
rpc_set_error(rpc, "Out of memory: Failed to allocate pdu structure");
|
2011-02-06 07:45:09 +03:00
|
|
|
return NULL;
|
|
|
|
}
|
2016-02-01 03:12:36 +03:00
|
|
|
memset(pdu, 0, pdu_size);
|
2011-02-06 07:45:09 +03:00
|
|
|
pdu->xid = rpc->xid++;
|
|
|
|
pdu->cb = cb;
|
|
|
|
pdu->private_data = private_data;
|
2012-07-04 10:53:12 +04:00
|
|
|
pdu->zdr_decode_fn = zdr_decode_fn;
|
|
|
|
pdu->zdr_decode_bufsize = zdr_decode_bufsize;
|
2011-02-06 07:45:09 +03:00
|
|
|
|
2016-06-02 10:12:53 +03:00
|
|
|
pdu->outdata.data = malloc(ZDR_ENCODEBUF_MINSIZE + alloc_hint);
|
|
|
|
if (pdu->outdata.data == NULL) {
|
|
|
|
rpc_set_error(rpc, "Out of memory: Failed to allocate encode buffer");
|
2017-02-08 14:29:49 +03:00
|
|
|
free(pdu);
|
2016-06-02 10:12:53 +03:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
zdrmem_create(&pdu->zdr, pdu->outdata.data, ZDR_ENCODEBUF_MINSIZE + alloc_hint, ZDR_ENCODE);
|
2011-06-26 11:30:00 +04:00
|
|
|
if (rpc->is_udp == 0) {
|
2012-07-04 10:53:12 +04:00
|
|
|
zdr_setpos(&pdu->zdr, 4); /* skip past the record marker */
|
2011-06-26 11:30:00 +04:00
|
|
|
}
|
2011-02-06 07:45:09 +03:00
|
|
|
|
2011-09-03 08:11:22 +04:00
|
|
|
memset(&msg, 0, sizeof(struct rpc_msg));
|
2012-11-27 07:42:10 +04:00
|
|
|
msg.xid = pdu->xid;
|
|
|
|
msg.direction = CALL;
|
|
|
|
msg.body.cbody.rpcvers = RPC_MSG_VERSION;
|
|
|
|
msg.body.cbody.prog = program;
|
|
|
|
msg.body.cbody.vers = version;
|
|
|
|
msg.body.cbody.proc = procedure;
|
|
|
|
msg.body.cbody.cred = rpc->auth->ah_cred;
|
|
|
|
msg.body.cbody.verf = rpc->auth->ah_verf;
|
2011-02-06 07:45:09 +03:00
|
|
|
|
2014-03-12 05:52:48 +04:00
|
|
|
if (zdr_callmsg(rpc, &pdu->zdr, &msg) == 0) {
|
|
|
|
rpc_set_error(rpc, "zdr_callmsg failed with %s",
|
|
|
|
rpc_get_error(rpc));
|
2012-07-04 10:53:12 +04:00
|
|
|
zdr_destroy(&pdu->zdr);
|
2017-02-08 14:29:49 +03:00
|
|
|
free(pdu->outdata.data);
|
2011-02-06 07:45:09 +03:00
|
|
|
free(pdu);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pdu;
|
|
|
|
}
|
|
|
|
|
2016-06-02 10:12:53 +03:00
|
|
|
struct rpc_pdu *rpc_allocate_pdu(struct rpc_context *rpc, int program, int version, int procedure, rpc_cb cb, void *private_data, zdrproc_t zdr_decode_fn, int zdr_decode_bufsize)
|
|
|
|
{
|
|
|
|
return rpc_allocate_pdu2(rpc, program, version, procedure, cb, private_data, zdr_decode_fn, zdr_decode_bufsize, 0);
|
|
|
|
}
|
|
|
|
|
2012-11-24 20:18:54 +04:00
|
|
|
void rpc_free_pdu(struct rpc_context *rpc, struct rpc_pdu *pdu)
|
2011-02-06 07:45:09 +03:00
|
|
|
{
|
2012-11-24 20:18:54 +04:00
|
|
|
assert(rpc->magic == RPC_CONTEXT_MAGIC);
|
|
|
|
|
2017-02-08 14:51:58 +03:00
|
|
|
free(pdu->outdata.data);
|
2011-02-06 07:45:09 +03:00
|
|
|
|
2012-07-04 10:53:12 +04:00
|
|
|
if (pdu->zdr_decode_buf != NULL) {
|
|
|
|
zdr_free(pdu->zdr_decode_fn, pdu->zdr_decode_buf);
|
2011-02-06 07:45:09 +03:00
|
|
|
}
|
|
|
|
|
2012-07-04 10:53:12 +04:00
|
|
|
zdr_destroy(&pdu->zdr);
|
2011-06-19 16:31:34 +04:00
|
|
|
|
2011-02-06 07:45:09 +03:00
|
|
|
free(pdu);
|
|
|
|
}
|
|
|
|
|
2013-10-26 18:44:29 +04:00
|
|
|
void rpc_set_next_xid(struct rpc_context *rpc, uint32_t xid)
|
|
|
|
{
|
|
|
|
rpc->xid = xid;
|
|
|
|
}
|
2011-02-06 07:45:09 +03:00
|
|
|
|
|
|
|
int rpc_queue_pdu(struct rpc_context *rpc, struct rpc_pdu *pdu)
|
|
|
|
{
|
|
|
|
int size, recordmarker;
|
|
|
|
|
2012-11-24 20:18:54 +04:00
|
|
|
assert(rpc->magic == RPC_CONTEXT_MAGIC);
|
|
|
|
|
2017-05-09 04:38:42 +03:00
|
|
|
if (rpc->timeout > 0) {
|
2017-07-05 20:49:57 +03:00
|
|
|
pdu->timeout = rpc_current_time() + rpc->timeout;
|
2017-07-08 02:55:14 +03:00
|
|
|
#ifndef HAVE_CLOCK_GETTIME
|
|
|
|
/* If we do not have GETTIME we fallback to time() which
|
|
|
|
* has 1s granularity for its timestamps.
|
|
|
|
* We thus need to bump the timeout by 1000ms
|
|
|
|
* so that the PDU will timeout within 1.0 - 2.0 seconds.
|
|
|
|
* Otherwise setting a 1s timeout would trigger within
|
|
|
|
* 0.001 - 1.0s.
|
|
|
|
*/
|
|
|
|
pdu->timeout += 1000;
|
|
|
|
#endif
|
2017-05-09 04:38:42 +03:00
|
|
|
} else {
|
|
|
|
pdu->timeout = 0;
|
|
|
|
}
|
|
|
|
|
2012-07-04 10:53:12 +04:00
|
|
|
size = zdr_getpos(&pdu->zdr);
|
2011-02-06 07:45:09 +03:00
|
|
|
|
2011-06-26 12:24:24 +04:00
|
|
|
/* for udp we dont queue, we just send it straight away */
|
|
|
|
if (rpc->is_udp != 0) {
|
2014-02-20 18:02:08 +04:00
|
|
|
unsigned int hash;
|
|
|
|
|
2012-07-04 10:53:12 +04:00
|
|
|
// XXX add a rpc->udp_dest_sock_size and get rid of sys/socket.h and netinet/in.h
|
2016-12-02 04:39:46 +03:00
|
|
|
if (sendto(rpc->fd, pdu->zdr.buf, size, MSG_DONTWAIT,
|
|
|
|
(struct sockaddr *)&rpc->udp_dest,
|
|
|
|
sizeof(rpc->udp_dest)) < 0) {
|
2011-06-26 12:24:24 +04:00
|
|
|
rpc_set_error(rpc, "Sendto failed with errno %s", strerror(errno));
|
|
|
|
rpc_free_pdu(rpc, pdu);
|
|
|
|
return -1;
|
|
|
|
}
|
2014-02-20 18:02:08 +04:00
|
|
|
|
|
|
|
hash = rpc_hash_xid(pdu->xid);
|
|
|
|
rpc_enqueue(&rpc->waitpdu[hash], pdu);
|
2017-01-12 16:38:11 +03:00
|
|
|
rpc->waitpdu_len++;
|
2011-06-26 12:24:24 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-06 07:45:09 +03:00
|
|
|
/* write recordmarker */
|
2012-07-04 10:53:12 +04:00
|
|
|
zdr_setpos(&pdu->zdr, 0);
|
2011-02-06 07:45:09 +03:00
|
|
|
recordmarker = (size - 4) | 0x80000000;
|
2012-07-04 10:53:12 +04:00
|
|
|
zdr_int(&pdu->zdr, &recordmarker);
|
2011-02-06 07:45:09 +03:00
|
|
|
|
|
|
|
pdu->outdata.size = size;
|
2014-01-07 14:23:46 +04:00
|
|
|
rpc_enqueue(&rpc->outqueue, pdu);
|
2011-02-06 07:45:09 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-05-30 17:10:56 +03:00
|
|
|
uint32_t rpc_get_pdu_size(char *buf)
|
2011-02-06 07:45:09 +03:00
|
|
|
{
|
|
|
|
uint32_t size;
|
|
|
|
|
2016-06-02 04:14:01 +03:00
|
|
|
size = ntohl(*(uint32_t *)(void *)buf);
|
2011-02-06 07:45:09 +03:00
|
|
|
|
|
|
|
return (size & 0x7fffffff) + 4;
|
|
|
|
}
|
|
|
|
|
2012-07-04 10:53:12 +04:00
|
|
|
static int rpc_process_reply(struct rpc_context *rpc, struct rpc_pdu *pdu, ZDR *zdr)
|
2011-02-06 07:45:09 +03:00
|
|
|
{
|
|
|
|
struct rpc_msg msg;
|
|
|
|
|
2012-11-24 20:18:54 +04:00
|
|
|
assert(rpc->magic == RPC_CONTEXT_MAGIC);
|
|
|
|
|
2011-09-03 08:11:22 +04:00
|
|
|
memset(&msg, 0, sizeof(struct rpc_msg));
|
2012-11-27 07:42:10 +04:00
|
|
|
msg.body.rbody.reply.areply.verf = _null_auth;
|
2012-07-04 10:53:12 +04:00
|
|
|
if (pdu->zdr_decode_bufsize > 0) {
|
2016-02-01 03:12:36 +03:00
|
|
|
pdu->zdr_decode_buf = (char *)pdu + PAD_TO_8_BYTES(sizeof(struct rpc_pdu));
|
2011-02-06 07:45:09 +03:00
|
|
|
}
|
2012-11-27 07:42:10 +04:00
|
|
|
msg.body.rbody.reply.areply.reply_data.results.where = pdu->zdr_decode_buf;
|
|
|
|
msg.body.rbody.reply.areply.reply_data.results.proc = pdu->zdr_decode_fn;
|
2014-03-12 05:52:48 +04:00
|
|
|
if (zdr_replymsg(rpc, zdr, &msg) == 0) {
|
|
|
|
rpc_set_error(rpc, "zdr_replymsg failed in rpc_process_reply: "
|
|
|
|
"%s", rpc_get_error(rpc));
|
|
|
|
pdu->cb(rpc, RPC_STATUS_ERROR, "Message rejected by server",
|
|
|
|
pdu->private_data);
|
2012-07-04 10:53:12 +04:00
|
|
|
if (pdu->zdr_decode_buf != NULL) {
|
|
|
|
pdu->zdr_decode_buf = NULL;
|
2011-02-06 07:45:09 +03:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2012-11-27 07:42:10 +04:00
|
|
|
if (msg.body.rbody.stat != MSG_ACCEPTED) {
|
2011-02-06 07:45:09 +03:00
|
|
|
pdu->cb(rpc, RPC_STATUS_ERROR, "RPC Packet not accepted by the server", pdu->private_data);
|
|
|
|
return 0;
|
|
|
|
}
|
2012-11-27 07:42:10 +04:00
|
|
|
switch (msg.body.rbody.reply.areply.stat) {
|
2011-02-06 07:45:09 +03:00
|
|
|
case SUCCESS:
|
2012-07-04 10:53:12 +04:00
|
|
|
pdu->cb(rpc, RPC_STATUS_SUCCESS, pdu->zdr_decode_buf, pdu->private_data);
|
2011-02-06 07:45:09 +03:00
|
|
|
break;
|
|
|
|
case PROG_UNAVAIL:
|
|
|
|
pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Program not available", pdu->private_data);
|
|
|
|
break;
|
|
|
|
case PROG_MISMATCH:
|
|
|
|
pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Program version mismatch", pdu->private_data);
|
|
|
|
break;
|
|
|
|
case PROC_UNAVAIL:
|
|
|
|
pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Procedure not available", pdu->private_data);
|
|
|
|
break;
|
|
|
|
case GARBAGE_ARGS:
|
|
|
|
pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: Garbage arguments", pdu->private_data);
|
|
|
|
break;
|
|
|
|
case SYSTEM_ERR:
|
|
|
|
pdu->cb(rpc, RPC_STATUS_ERROR, "Server responded: System Error", pdu->private_data);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
pdu->cb(rpc, RPC_STATUS_ERROR, "Unknown rpc response from server", pdu->private_data);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-11-29 16:36:59 +03:00
|
|
|
static int rpc_send_error_reply(struct rpc_context *rpc,
|
|
|
|
struct rpc_msg *call,
|
|
|
|
enum accept_stat err,
|
|
|
|
int min_vers, int max_vers)
|
|
|
|
{
|
|
|
|
struct rpc_pdu *pdu;
|
|
|
|
struct rpc_msg res;
|
|
|
|
|
|
|
|
assert(rpc->magic == RPC_CONTEXT_MAGIC);
|
|
|
|
|
|
|
|
memset(&res, 0, sizeof(struct rpc_msg));
|
|
|
|
res.xid = call->xid;
|
|
|
|
res.direction = REPLY;
|
|
|
|
res.body.rbody.stat = MSG_ACCEPTED;
|
|
|
|
res.body.rbody.reply.areply.reply_data.mismatch_info.low = min_vers;
|
|
|
|
res.body.rbody.reply.areply.reply_data.mismatch_info.high = max_vers;
|
|
|
|
res.body.rbody.reply.areply.verf = _null_auth;
|
|
|
|
res.body.rbody.reply.areply.stat = err;
|
|
|
|
|
|
|
|
if (rpc->is_udp) {
|
|
|
|
/* send the reply back to the client */
|
|
|
|
memcpy(&rpc->udp_dest, &rpc->udp_src, sizeof(rpc->udp_dest));
|
|
|
|
}
|
|
|
|
|
|
|
|
pdu = rpc_allocate_reply_pdu(rpc, &res, 0);
|
|
|
|
if (pdu == NULL) {
|
|
|
|
rpc_set_error(rpc, "Failed to send error_reply: %s",
|
|
|
|
rpc_get_error(rpc));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
rpc_queue_pdu(rpc, pdu);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int rpc_send_reply(struct rpc_context *rpc,
|
|
|
|
struct rpc_msg *call,
|
|
|
|
void *reply,
|
|
|
|
zdrproc_t encode_fn,
|
|
|
|
int alloc_hint)
|
|
|
|
{
|
|
|
|
struct rpc_pdu *pdu;
|
|
|
|
struct rpc_msg res;
|
|
|
|
|
|
|
|
assert(rpc->magic == RPC_CONTEXT_MAGIC);
|
|
|
|
|
|
|
|
memset(&res, 0, sizeof(struct rpc_msg));
|
|
|
|
res.xid = call->xid;
|
|
|
|
res.direction = REPLY;
|
|
|
|
res.body.rbody.stat = MSG_ACCEPTED;
|
|
|
|
res.body.rbody.reply.areply.verf = _null_auth;
|
|
|
|
res.body.rbody.reply.areply.stat = SUCCESS;
|
|
|
|
|
|
|
|
res.body.rbody.reply.areply.reply_data.results.where = reply;
|
|
|
|
res.body.rbody.reply.areply.reply_data.results.proc = encode_fn;
|
|
|
|
|
|
|
|
if (rpc->is_udp) {
|
|
|
|
/* send the reply back to the client */
|
|
|
|
memcpy(&rpc->udp_dest, &rpc->udp_src, sizeof(rpc->udp_dest));
|
|
|
|
}
|
|
|
|
|
|
|
|
pdu = rpc_allocate_reply_pdu(rpc, &res, alloc_hint);
|
|
|
|
if (pdu == NULL) {
|
|
|
|
rpc_set_error(rpc, "Failed to send error_reply: %s",
|
|
|
|
rpc_get_error(rpc));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
rpc_queue_pdu(rpc, pdu);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rpc_process_call(struct rpc_context *rpc, ZDR *zdr)
|
|
|
|
{
|
|
|
|
struct rpc_msg call;
|
|
|
|
struct rpc_endpoint *endpoint;
|
2016-12-27 03:51:28 +03:00
|
|
|
int i, min_version = 0, max_version = 0, found_program = 0;
|
2016-11-29 16:36:59 +03:00
|
|
|
|
|
|
|
assert(rpc->magic == RPC_CONTEXT_MAGIC);
|
|
|
|
|
|
|
|
memset(&call, 0, sizeof(struct rpc_msg));
|
|
|
|
if (zdr_callmsg(rpc, zdr, &call) == 0) {
|
|
|
|
rpc_set_error(rpc, "Failed to decode CALL message. %s",
|
|
|
|
rpc_get_error(rpc));
|
|
|
|
return rpc_send_error_reply(rpc, &call, GARBAGE_ARGS, 0, 0);
|
|
|
|
}
|
|
|
|
for (endpoint = rpc->endpoints; endpoint; endpoint = endpoint->next) {
|
|
|
|
if (call.body.cbody.prog == endpoint->program) {
|
|
|
|
if (!found_program) {
|
|
|
|
min_version = max_version = endpoint->version;
|
|
|
|
}
|
|
|
|
if (endpoint->version < min_version) {
|
|
|
|
min_version = endpoint->version;
|
|
|
|
}
|
|
|
|
if (endpoint->version > max_version) {
|
|
|
|
max_version = endpoint->version;
|
|
|
|
}
|
|
|
|
found_program = 1;
|
|
|
|
if (call.body.cbody.vers == endpoint->version) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (endpoint == NULL) {
|
|
|
|
rpc_set_error(rpc, "No endpoint found for CALL "
|
|
|
|
"program:0x%08x version:%d\n",
|
|
|
|
call.body.cbody.prog, call.body.cbody.vers);
|
|
|
|
if (!found_program) {
|
|
|
|
return rpc_send_error_reply(rpc, &call, PROG_UNAVAIL,
|
|
|
|
0, 0);
|
|
|
|
}
|
|
|
|
return rpc_send_error_reply(rpc, &call, PROG_MISMATCH,
|
|
|
|
min_version, max_version);
|
|
|
|
}
|
|
|
|
for (i = 0; i < endpoint->num_procs; i++) {
|
|
|
|
if (endpoint->procs[i].proc == call.body.cbody.proc) {
|
|
|
|
if (endpoint->procs[i].decode_buf_size) {
|
|
|
|
call.body.cbody.args = zdr_malloc(zdr, endpoint->procs[i].decode_buf_size);
|
|
|
|
}
|
|
|
|
if (!endpoint->procs[i].decode_fn(zdr, call.body.cbody.args)) {
|
|
|
|
rpc_set_error(rpc, "Failed to unmarshall "
|
|
|
|
"call payload");
|
|
|
|
return rpc_send_error_reply(rpc, &call, GARBAGE_ARGS, 0 ,0);
|
|
|
|
}
|
|
|
|
return endpoint->procs[i].func(rpc, &call);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return rpc_send_error_reply(rpc, &call, PROC_UNAVAIL, 0 ,0);
|
|
|
|
}
|
|
|
|
|
2011-02-06 07:45:09 +03:00
|
|
|
int rpc_process_pdu(struct rpc_context *rpc, char *buf, int size)
|
|
|
|
{
|
2014-01-07 14:23:46 +04:00
|
|
|
struct rpc_pdu *pdu, *prev_pdu;
|
2014-02-20 18:02:08 +04:00
|
|
|
struct rpc_queue *q;
|
2012-07-04 10:53:12 +04:00
|
|
|
ZDR zdr;
|
2011-10-04 05:31:56 +04:00
|
|
|
int pos, recordmarker = 0;
|
2014-02-20 18:02:08 +04:00
|
|
|
unsigned int hash;
|
2013-10-22 06:15:11 +04:00
|
|
|
uint32_t xid;
|
2011-10-04 05:31:56 +04:00
|
|
|
char *reasbuf = NULL;
|
2011-02-06 07:45:09 +03:00
|
|
|
|
2012-11-24 20:18:54 +04:00
|
|
|
assert(rpc->magic == RPC_CONTEXT_MAGIC);
|
|
|
|
|
2012-07-04 10:53:12 +04:00
|
|
|
memset(&zdr, 0, sizeof(ZDR));
|
2011-02-06 07:45:09 +03:00
|
|
|
|
2012-07-04 10:53:12 +04:00
|
|
|
zdrmem_create(&zdr, buf, size, ZDR_DECODE);
|
2011-06-26 12:24:24 +04:00
|
|
|
if (rpc->is_udp == 0) {
|
2012-07-04 10:53:12 +04:00
|
|
|
if (zdr_int(&zdr, &recordmarker) == 0) {
|
|
|
|
rpc_set_error(rpc, "zdr_int reading recordmarker failed");
|
|
|
|
zdr_destroy(&zdr);
|
2011-06-26 12:24:24 +04:00
|
|
|
return -1;
|
|
|
|
}
|
2011-10-04 05:31:56 +04:00
|
|
|
if (!(recordmarker&0x80000000)) {
|
2012-07-04 10:53:12 +04:00
|
|
|
zdr_destroy(&zdr);
|
2011-10-04 05:31:56 +04:00
|
|
|
if (rpc_add_fragment(rpc, buf+4, size-4) != 0) {
|
|
|
|
rpc_set_error(rpc, "Failed to queue fragment for reassembly.");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2011-02-06 07:45:09 +03:00
|
|
|
}
|
2011-10-04 05:31:56 +04:00
|
|
|
|
|
|
|
/* reassembly */
|
|
|
|
if (recordmarker != 0 && rpc->fragments != NULL) {
|
|
|
|
struct rpc_fragment *fragment;
|
2012-07-05 01:12:11 +04:00
|
|
|
uint32_t total = size - 4;
|
2011-10-04 05:31:56 +04:00
|
|
|
char *ptr;
|
|
|
|
|
2012-07-04 10:53:12 +04:00
|
|
|
zdr_destroy(&zdr);
|
2011-10-04 05:31:56 +04:00
|
|
|
for (fragment = rpc->fragments; fragment; fragment = fragment->next) {
|
|
|
|
total += fragment->size;
|
2019-03-08 19:01:54 +03:00
|
|
|
if (total < fragment->size) {
|
|
|
|
rpc_set_error(rpc, "Fragments too large");
|
|
|
|
rpc_free_all_fragments(rpc);
|
|
|
|
return -1;
|
|
|
|
}
|
2011-10-04 05:31:56 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
reasbuf = malloc(total);
|
|
|
|
if (reasbuf == NULL) {
|
|
|
|
rpc_set_error(rpc, "Failed to reassemble PDU");
|
|
|
|
rpc_free_all_fragments(rpc);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
ptr = reasbuf;
|
|
|
|
for (fragment = rpc->fragments; fragment; fragment = fragment->next) {
|
|
|
|
memcpy(ptr, fragment->data, fragment->size);
|
|
|
|
ptr += fragment->size;
|
|
|
|
}
|
|
|
|
memcpy(ptr, buf + 4, size - 4);
|
2012-07-04 10:53:12 +04:00
|
|
|
zdrmem_create(&zdr, reasbuf, total, ZDR_DECODE);
|
2011-10-04 05:31:56 +04:00
|
|
|
rpc_free_all_fragments(rpc);
|
|
|
|
}
|
|
|
|
|
2016-11-29 16:36:59 +03:00
|
|
|
if (rpc->is_server_context) {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = rpc_process_call(rpc, &zdr);
|
|
|
|
zdr_destroy(&zdr);
|
|
|
|
if (reasbuf != NULL) {
|
|
|
|
free(reasbuf);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-07-04 10:53:12 +04:00
|
|
|
pos = zdr_getpos(&zdr);
|
|
|
|
if (zdr_int(&zdr, (int *)&xid) == 0) {
|
|
|
|
rpc_set_error(rpc, "zdr_int reading xid failed");
|
|
|
|
zdr_destroy(&zdr);
|
2011-10-04 05:31:56 +04:00
|
|
|
if (reasbuf != NULL) {
|
|
|
|
free(reasbuf);
|
|
|
|
}
|
2011-02-06 07:45:09 +03:00
|
|
|
return -1;
|
|
|
|
}
|
2012-07-04 10:53:12 +04:00
|
|
|
zdr_setpos(&zdr, pos);
|
2011-02-06 07:45:09 +03:00
|
|
|
|
2014-02-20 18:02:08 +04:00
|
|
|
/* Look up the transaction in a hash table of our requests */
|
|
|
|
hash = rpc_hash_xid(xid);
|
|
|
|
q = &rpc->waitpdu[hash];
|
|
|
|
|
|
|
|
/* Follow the hash chain. Linear traverse singly-linked list,
|
|
|
|
* but track previous entry for optimised removal */
|
2014-01-07 14:23:46 +04:00
|
|
|
prev_pdu = NULL;
|
2014-02-20 18:02:08 +04:00
|
|
|
for (pdu=q->head; pdu; pdu=pdu->next) {
|
2011-02-06 07:45:09 +03:00
|
|
|
if (pdu->xid != xid) {
|
2014-01-07 14:23:46 +04:00
|
|
|
prev_pdu = pdu;
|
2011-02-06 07:45:09 +03:00
|
|
|
continue;
|
|
|
|
}
|
2011-06-26 12:24:24 +04:00
|
|
|
if (rpc->is_udp == 0 || rpc->is_broadcast == 0) {
|
2014-01-07 14:23:46 +04:00
|
|
|
/* Singly-linked but we track head and tail */
|
2014-02-20 18:02:08 +04:00
|
|
|
if (pdu == q->head)
|
|
|
|
q->head = pdu->next;
|
|
|
|
if (pdu == q->tail)
|
|
|
|
q->tail = prev_pdu;
|
2014-01-07 14:23:46 +04:00
|
|
|
if (prev_pdu != NULL)
|
|
|
|
prev_pdu->next = pdu->next;
|
2017-01-12 16:38:11 +03:00
|
|
|
rpc->waitpdu_len--;
|
2011-06-26 12:24:24 +04:00
|
|
|
}
|
2012-07-04 10:53:12 +04:00
|
|
|
if (rpc_process_reply(rpc, pdu, &zdr) != 0) {
|
2011-06-19 03:38:20 +04:00
|
|
|
rpc_set_error(rpc, "rpc_procdess_reply failed");
|
2011-02-06 07:45:09 +03:00
|
|
|
}
|
2012-07-04 10:53:12 +04:00
|
|
|
zdr_destroy(&zdr);
|
2011-06-26 12:24:24 +04:00
|
|
|
if (rpc->is_udp == 0 || rpc->is_broadcast == 0) {
|
|
|
|
rpc_free_pdu(rpc, pdu);
|
|
|
|
}
|
2011-10-04 05:31:56 +04:00
|
|
|
if (reasbuf != NULL) {
|
|
|
|
free(reasbuf);
|
|
|
|
}
|
2011-02-06 07:45:09 +03:00
|
|
|
return 0;
|
|
|
|
}
|
2017-06-01 07:06:36 +03:00
|
|
|
|
2012-07-04 10:53:12 +04:00
|
|
|
zdr_destroy(&zdr);
|
2011-10-04 05:31:56 +04:00
|
|
|
if (reasbuf != NULL) {
|
|
|
|
free(reasbuf);
|
|
|
|
}
|
2017-06-01 07:06:36 +03:00
|
|
|
return 0;
|
2011-02-06 07:45:09 +03:00
|
|
|
}
|
|
|
|
|