Simplified NFS proxy based on own NFS/XDR implementation

README-ru.md

@@ -52,6 +52,7 @@ Vitastor на данный момент находится в статусе п
 - Слияние снапшотов (vitastor-cli {snap-rm,flatten,merge})
 - Консольный интерфейс для управления образами (vitastor-cli {ls,create,modify})
 - Плагин для Proxmox
+- Упрощённая NFS-прокси для эмуляции файлового доступа к образам (подходит для VMWare)
 
 ## Планы развития
 
@@ -59,7 +60,6 @@ Vitastor на данный момент находится в статусе п
 - Другие инструменты администрирования
 - Плагины для OpenNebula и других облачных систем
 - iSCSI-прокси
-- Упрощённый NFS прокси
 - Более быстрое переключение при отказах
 - Фоновая проверка целостности без контрольных сумм (сверка реплик)
 - Контрольные суммы
@@ -530,9 +530,48 @@ vitastor-nbd map --etcd_address 10.115.0.10:2379/v3 --image testimg
 Для обращения по номеру инода, аналогично другим командам, можно использовать опции
 `--pool <POOL> --inode <INODE> --size <SIZE>` вместо `--image testimg`.
 
+### NFS
+
+В Vitastor реализована упрощённая NFS 3.0 прокси для эмуляции файлового доступа к образам.
+Это не полноценная файловая система, т.к. метаданные всех файлов (образов) сохраняются
+в etcd и всё время хранятся в оперативной памяти - то есть, положить туда много файлов
+не получится.
+
+Однако в качестве способа доступа к образам виртуальных машин NFS прокси прекрасно подходит
+и позволяет подключить Vitastor, например, к VMWare.
+
+При этом, если вы используете режим immediate_commit=all (для SSD с конденсаторами или HDD
+с отключённым кэшем), то NFS-сервер не имеет состояния и вы можете свободно поднять
+его в нескольких экземплярах и использовать поверх них сетевой балансировщик нагрузки или
+схему с отказоустойчивостью.
+
+Использование vitastor-nfs:
+
+```
+vitastor-nfs [--etcd_address ADDR] [ДРУГИЕ ОПЦИИ]
+
+--subdir <DIR>    экспортировать "поддиректорию" - образы с префиксом имени <DIR>/ (по умолчанию пусто - экспортировать все образы)
+--portmap 0       отключить сервис portmap/rpcbind на порту 111 (по умолчанию включён и требует root привилегий)
+--bind <IP>       принимать соединения по адресу <IP> (по умолчанию 0.0.0.0 - на всех)
+--nfspath <PATH>  установить путь NFS-экспорта в <PATH> (по умолчанию /)
+--port <PORT>     использовать порт <PORT> для NFS-сервисов (по умолчанию 2049)
+--pool <POOL>     исползовать пул <POOL> для новых образов (обязательно, если пул в кластере не один)
+--foreground 1    не уходить в фон после запуска
+```
+
+Пример монтирования Vitastor через NFS:
+
+```
+vitastor-nfs --etcd_address 192.168.5.10:2379 --portmap 0 --port 2050 --pool testpool
+```
+
+```
+mount localhost:/ /mnt/ -o port=2050,mountport=2050,nfsvers=3,soft,nolock,tcp
+```
+
 ### Kubernetes
 
-У Vitastor есть CSI-плагин для Kubernetes, поддерживающий RWO-тома.
+У Vitastor есть CSI-плагин для Kubernetes, поддерживающий RWO, а также блочные RWX, тома.
 
 Для установки возьмите манифесты из директории [csi/deploy/](csi/deploy/), поместите
 вашу конфигурацию подключения к Vitastor в [csi/deploy/001-csi-config-map.yaml](001-csi-config-map.yaml),

README.md

@@ -46,6 +46,7 @@ breaking changes in the future. However, the following is implemented:
 - Snapshot merge tool (vitastor-cli {snap-rm,flatten,merge})
 - Image management CLI (vitastor-cli {ls,create,modify})
 - Proxmox storage plugin
+- Simplified NFS proxy for file-based image access emulation (suitable for VMWare)
 
 ## Roadmap
 
@@ -53,7 +54,6 @@ breaking changes in the future. However, the following is implemented:
 - Other administrative tools
 - Plugins for OpenNebula and other cloud systems
 - iSCSI proxy
-- Simplified NFS proxy
 - Faster failover
 - Scrubbing without checksums (verification of replicas)
 - Checksums
@@ -479,9 +479,49 @@ It will output the device name, like /dev/nbd0 which you can then format and mou
 
 Again, you can use `--pool <POOL> --inode <INODE> --size <SIZE>` insteaf of `--image <IMAGE>` if you want.
 
+### NFS
+
+Vitastor has a simplified NFS 3.0 proxy for file-based image access emulation. It's not
+suitable as a full-featured file system, at least because all file/image metadata is stored
+in etcd and kept in memory all the time - thus you can't put a lot of files in it.
+
+However, NFS proxy is totally fine as a method to provide VM image access and allows to
+plug Vitastor into, for example, VMWare. It's important to note that for VMWare it's a much
+better access method than iSCSI, because with iSCSI we'd have to put all VM images into one
+Vitastor image exported as a LUN to VMWare and formatted with VMFS. VMWare doesn't use VMFS
+over NFS.
+
+NFS proxy is stateless if you use immediate_commit=all mode (for SSD with capacitors or
+HDDs with disabled cache), so you can run multiple NFS proxies and use a network load
+balancer or any failover method you want to in that case.
+
+vitastor-nfs usage:
+
+```
+vitastor-nfs [--etcd_address ADDR] [OTHER OPTIONS]
+
+--subdir <DIR>    export images prefixed <DIR>/ (default empty - export all images)
+--portmap 0       do not listen on port 111 (portmap/rpcbind, requires root)
+--bind <IP>       bind service to <IP> address (default 0.0.0.0)
+--nfspath <PATH>  set NFS export path to <PATH> (default is /)
+--port <PORT>     use port <PORT> for NFS services (default is 2049)
+--pool <POOL>     use <POOL> as default pool for new files (images)
+--foreground 1    stay in foreground, do not daemonize
+```
+
+Example start and mount commands:
+
+```
+vitastor-nfs --etcd_address 192.168.5.10:2379 --portmap 0 --port 2050 --pool testpool
+```
+
+```
+mount localhost:/ /mnt/ -o port=2050,mountport=2050,nfsvers=3,soft,nolock,tcp
+```
+
 ### Kubernetes
 
-Vitastor has a CSI plugin for Kubernetes which supports RWO volumes.
+Vitastor has a CSI plugin for Kubernetes which supports RWO (and block RWX) volumes.
 
 To deploy it, take manifests from [csi/deploy/](csi/deploy/) directory, put your
 Vitastor configuration in [csi/deploy/001-csi-config-map.yaml](001-csi-config-map.yaml),

cpp-btree

@@ -1 +1 @@
-Subproject commit 6e201464060ace53db809d65da7b0e2800673f8f
+Subproject commit 903ec858bc8ab00fc0fbd44c23f0ab7770772353

debian/vitastor-client.install

@@ -2,5 +2,6 @@ usr/bin/vita
 usr/bin/vitastor-cli
 usr/bin/vitastor-rm
 usr/bin/vitastor-nbd
+usr/bin/vitastor-nfs
 usr/lib/*/libvitastor*.so*
 mon/make-osd.sh /usr/lib/vitastor

rpm/vitastor-el7.spec

@@ -119,6 +119,7 @@ cp -r mon %buildroot/usr/lib/vitastor
 
 %files -n vitastor-client
 %_bindir/vitastor-nbd
+%_bindir/vitastor-nfs
 %_bindir/vitastor-cli
 %_bindir/vitastor-rm
 %_bindir/vita

rpm/vitastor-el8.spec

@@ -116,6 +116,7 @@ cp -r mon %buildroot/usr/lib/vitastor
 
 %files -n vitastor-client
 %_bindir/vitastor-nbd
+%_bindir/vitastor-nfs
 %_bindir/vitastor-cli
 %_bindir/vitastor-rm
 %_bindir/vita

src/CMakeLists.txt

@@ -164,6 +164,21 @@ target_link_libraries(vitastor-nbd
 	vitastor_client
 )
 
+# vitastor-nfs
+add_executable(vitastor-nfs
+	nfs_proxy.cpp
+	nfs_conn.cpp
+	nfs_portmap.cpp
+	sha256.c
+	nfs/xdr_impl.cpp
+	nfs/rpc_xdr.cpp
+	nfs/portmap_xdr.cpp
+	nfs/nfs_xdr.cpp
+)
+target_link_libraries(vitastor-nfs
+	vitastor_client
+)
+
 # vitastor-cli
 add_executable(vitastor-cli
 	cli.cpp

src/cli_create.cpp

@@ -25,7 +25,9 @@ struct image_creator_t
     pool_id_t new_pool_id = 0;
     std::string new_pool_name;
     std::string image_name, new_snap, new_parent;
+    json11::Json new_meta;
     uint64_t size;
+    bool force_size = false;
 
     pool_id_t old_pool_id = 0;
     inode_t new_parent_id = 0;
@@ -137,7 +139,7 @@ struct image_creator_t
             state = 100;
             return;
         }
-        if (!size)
+        if (!size && !force_size)
         {
             result = (cli_result_t){ .err = EINVAL, .text = "Image size is missing" };
             state = 100;
@@ -387,6 +389,7 @@ resume_3:
             .size = size,
             .parent_id = (new_snap != "" ? INODE_WITH_POOL(old_pool_id, old_id) : new_parent_id),
             .readonly = false,
+            .meta = new_meta,
         };
         json11::Json::array checks = json11::Json::array {
             json11::Json::object {
@@ -538,6 +541,11 @@ std::function<bool(cli_result_t &)> cli_tool_t::start_create(json11::Json cfg)
     image_creator->image_name = cfg["image"].string_value();
     image_creator->new_pool_id = cfg["pool"].uint64_value();
     image_creator->new_pool_name = cfg["pool"].string_value();
+    image_creator->force_size = cfg["force_size"].bool_value();
+    if (cfg["image_meta"].is_object())
+    {
+        image_creator->new_meta = cfg["image-meta"];
+    }
     if (cfg["snapshot"].string_value() != "")
     {
         image_creator->new_snap = cfg["snapshot"].string_value();
@@ -554,7 +562,7 @@ std::function<bool(cli_result_t &)> cli_tool_t::start_create(json11::Json cfg)
                 return true;
             };
         }
-        if (image_creator->size % 4096)
+        if ((image_creator->size % 4096) && !cfg["force_size"].bool_value())
         {
             delete image_creator;
             return [](cli_result_t & result)

src/cli_modify.cpp

@@ -81,14 +81,14 @@ struct image_changer_t
         }
         if ((!set_readwrite || !cfg.readonly) &&
             (!set_readonly || cfg.readonly) &&
-            (!new_size || cfg.size == new_size) &&
+            (!new_size && !force_size || cfg.size == new_size) &&
             (new_name == "" || new_name == image_name))
         {
             result = (cli_result_t){ .text = "No change" };
             state = 100;
             return;
         }
-        if (new_size != 0)
+        if (new_size != 0 || force_size)
         {
             if (cfg.size >= new_size)
             {

src/cluster_client.cpp

@@ -374,6 +374,11 @@ void cluster_client_t::on_change_hook(std::map<std::string, etcd_kv_t> & changes
     continue_ops();
 }
 
+bool cluster_client_t::get_immediate_commit()
+{
+    return immediate_commit;
+}
+
 void cluster_client_t::on_change_osd_state_hook(uint64_t peer_osd)
 {
     if (msgr.wanted_peers.find(peer_osd) != msgr.wanted_peers.end())

src/cluster_client.h

@@ -118,6 +118,8 @@ public:
     bool is_ready();
     void on_ready(std::function<void(void)> fn);
 
+    bool get_immediate_commit();
+
     static void copy_write(cluster_op_t *op, std::map<object_id, cluster_buffer_t> & dirty_buffers);
     void continue_ops(bool up_retry = false);
     inode_list_t *list_inode_start(inode_t inode,

src/etcd_state_client.cpp

@@ -338,9 +338,14 @@ void etcd_state_client_t::start_etcd_watcher()
             {
                 if (data["result"]["created"].bool_value())
                 {
-                    if (etcd_watches_initialised == 3 && this->log_level > 0)
+                    uint64_t watch_id = data["result"]["watch_id"].uint64_value();
+                    if (watch_id == ETCD_CONFIG_WATCH_ID ||
+                        watch_id == ETCD_PG_STATE_WATCH_ID ||
+                        watch_id == ETCD_PG_HISTORY_WATCH_ID ||
+                        watch_id == ETCD_OSD_STATE_WATCH_ID)
+                        etcd_watches_initialised++;
+                    if (etcd_watches_initialised == 4 && this->log_level > 0)
                         fprintf(stderr, "Successfully subscribed to etcd at %s\n", selected_etcd_address.c_str());
-                    etcd_watches_initialised++;
                 }
                 if (data["result"]["canceled"].bool_value())
                 {
@@ -469,6 +474,10 @@ void etcd_state_client_t::start_etcd_watcher()
             { "progress_notify", true },
         } }
     }).dump());
+    if (on_start_watcher_hook)
+    {
+        on_start_watcher_hook(etcd_watch_ws);
+    }
     if (ws_keepalive_timer < 0)
     {
         ws_keepalive_timer = tfd->set_timer(etcd_ws_keepalive_interval*1000, true, [this](int)
@@ -954,6 +963,10 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
             }
             if (!value.is_object())
             {
+                if (on_inode_change_hook != NULL)
+                {
+                    on_inode_change_hook(inode_num, true);
+                }
                 this->inode_config.erase(inode_num);
             }
             else
@@ -981,6 +994,7 @@ void etcd_state_client_t::parse_state(const etcd_kv_t & kv)
                     .size = value["size"].uint64_value(),
                     .parent_id = parent_inode_num,
                     .readonly = value["readonly"].bool_value(),
+                    .meta = value["meta"],
                     .mod_revision = kv.mod_revision,
                 });
             }
@@ -1002,6 +1016,10 @@ void etcd_state_client_t::insert_inode_config(const inode_config_t & cfg)
             }
         }
     }
+    if (on_inode_change_hook != NULL)
+    {
+        on_inode_change_hook(cfg.num, false);
+    }
 }
 
 inode_watch_t* etcd_state_client_t::watch_inode(std::string name)
@@ -1046,6 +1064,10 @@ json11::Json::object etcd_state_client_t::serialize_inode_cfg(inode_config_t *cf
     {
         new_cfg["readonly"] = true;
     }
+    if (cfg->meta.is_object())
+    {
+        new_cfg["meta"] = cfg->meta;
+    }
     return new_cfg;
 }
 

src/etcd_state_client.h

@@ -56,6 +56,8 @@ struct inode_config_t
     uint64_t size;
     inode_t parent_id;
     bool readonly;
+    // Arbitrary metadata
+    json11::Json meta;
     // Change revision of the metadata in etcd
     uint64_t mod_revision;
 };
@@ -109,6 +111,8 @@ public:
     std::function<void(pool_id_t, pg_num_t)> on_change_pg_history_hook;
     std::function<void(osd_num_t)> on_change_osd_state_hook;
     std::function<void()> on_reload_hook;
+    std::function<void(inode_t, bool)> on_inode_change_hook;
+    std::function<void(http_co_t *)> on_start_watcher_hook;
 
     json11::Json::object serialize_inode_cfg(inode_config_t *cfg);
     etcd_kv_t parse_etcd_kv(const json11::Json & kv_json);

src/nfs/portmap.h

@@ -0,0 +1,190 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#ifndef _PORTMAP_H_RPCGEN
+#define _PORTMAP_H_RPCGEN
+
+#include "xdr_impl.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PMAP_PORT 111
+
+struct pmap2_mapping {
+	u_int prog;
+	u_int vers;
+	u_int prot;
+	u_int port;
+};
+typedef struct pmap2_mapping pmap2_mapping;
+
+struct pmap2_call_args {
+	u_int prog;
+	u_int vers;
+	u_int proc;
+	xdr_string_t args;
+};
+typedef struct pmap2_call_args pmap2_call_args;
+
+struct pmap2_call_result {
+	u_int port;
+	xdr_string_t res;
+};
+typedef struct pmap2_call_result pmap2_call_result;
+
+struct pmap2_mapping_list {
+	pmap2_mapping map;
+	struct pmap2_mapping_list *next;
+};
+typedef struct pmap2_mapping_list pmap2_mapping_list;
+
+struct pmap2_dump_result {
+	struct pmap2_mapping_list *list;
+};
+typedef struct pmap2_dump_result pmap2_dump_result;
+
+struct pmap3_string_result {
+	xdr_string_t addr;
+};
+typedef struct pmap3_string_result pmap3_string_result;
+
+struct pmap3_mapping {
+	u_int prog;
+	u_int vers;
+	xdr_string_t netid;
+	xdr_string_t addr;
+	xdr_string_t owner;
+};
+typedef struct pmap3_mapping pmap3_mapping;
+
+struct pmap3_mapping_list {
+	pmap3_mapping map;
+	struct pmap3_mapping_list *next;
+};
+typedef struct pmap3_mapping_list pmap3_mapping_list;
+
+struct pmap3_dump_result {
+	struct pmap3_mapping_list *list;
+};
+typedef struct pmap3_dump_result pmap3_dump_result;
+
+struct pmap3_call_args {
+	u_int prog;
+	u_int vers;
+	u_int proc;
+	xdr_string_t args;
+};
+typedef struct pmap3_call_args pmap3_call_args;
+
+struct pmap3_call_result {
+	u_int port;
+	xdr_string_t res;
+};
+typedef struct pmap3_call_result pmap3_call_result;
+
+struct pmap3_netbuf {
+	u_int maxlen;
+	xdr_string_t buf;
+};
+typedef struct pmap3_netbuf pmap3_netbuf;
+
+typedef pmap2_mapping PMAP2SETargs;
+
+typedef pmap2_mapping PMAP2UNSETargs;
+
+typedef pmap2_mapping PMAP2GETPORTargs;
+
+typedef pmap2_call_args PMAP2CALLITargs;
+
+typedef pmap2_call_result PMAP2CALLITres;
+
+typedef pmap2_dump_result PMAP2DUMPres;
+
+typedef pmap3_mapping PMAP3SETargs;
+
+typedef pmap3_mapping PMAP3UNSETargs;
+
+typedef pmap3_mapping PMAP3GETADDRargs;
+
+typedef pmap3_string_result PMAP3GETADDRres;
+
+typedef pmap3_dump_result PMAP3DUMPres;
+
+typedef pmap3_call_result PMAP3CALLITargs;
+
+typedef pmap3_call_result PMAP3CALLITres;
+
+typedef pmap3_netbuf PMAP3UADDR2TADDRres;
+
+typedef pmap3_netbuf PMAP3TADDR2UADDRargs;
+
+typedef pmap3_string_result PMAP3TADDR2UADDRres;
+
+#define PMAP_PROGRAM 100000
+#define PMAP_V2 2
+
+
+#define PMAP2_NULL 0
+#define PMAP2_SET 1
+#define PMAP2_UNSET 2
+#define PMAP2_GETPORT 3
+#define PMAP2_DUMP 4
+#define PMAP2_CALLIT 5
+
+#define PMAP_V3 3
+
+
+#define PMAP3_NULL 0
+#define PMAP3_SET 1
+#define PMAP3_UNSET 2
+#define PMAP3_GETADDR 3
+#define PMAP3_DUMP 4
+#define PMAP3_CALLIT 5
+#define PMAP3_GETTIME 6
+#define PMAP3_UADDR2TADDR 7
+#define PMAP3_TADDR2UADDR 8
+
+
+/* the xdr functions */
+
+
+extern  bool_t xdr_pmap2_mapping (XDR *, pmap2_mapping*);
+extern  bool_t xdr_pmap2_call_args (XDR *, pmap2_call_args*);
+extern  bool_t xdr_pmap2_call_result (XDR *, pmap2_call_result*);
+extern  bool_t xdr_pmap2_mapping_list (XDR *, pmap2_mapping_list*);
+extern  bool_t xdr_pmap2_dump_result (XDR *, pmap2_dump_result*);
+extern  bool_t xdr_pmap3_string_result (XDR *, pmap3_string_result*);
+extern  bool_t xdr_pmap3_mapping (XDR *, pmap3_mapping*);
+extern  bool_t xdr_pmap3_mapping_list (XDR *, pmap3_mapping_list*);
+extern  bool_t xdr_pmap3_dump_result (XDR *, pmap3_dump_result*);
+extern  bool_t xdr_pmap3_call_args (XDR *, pmap3_call_args*);
+extern  bool_t xdr_pmap3_call_result (XDR *, pmap3_call_result*);
+extern  bool_t xdr_pmap3_netbuf (XDR *, pmap3_netbuf*);
+extern  bool_t xdr_PMAP2SETargs (XDR *, PMAP2SETargs*);
+extern  bool_t xdr_PMAP2UNSETargs (XDR *, PMAP2UNSETargs*);
+extern  bool_t xdr_PMAP2GETPORTargs (XDR *, PMAP2GETPORTargs*);
+extern  bool_t xdr_PMAP2CALLITargs (XDR *, PMAP2CALLITargs*);
+extern  bool_t xdr_PMAP2CALLITres (XDR *, PMAP2CALLITres*);
+extern  bool_t xdr_PMAP2DUMPres (XDR *, PMAP2DUMPres*);
+extern  bool_t xdr_PMAP3SETargs (XDR *, PMAP3SETargs*);
+extern  bool_t xdr_PMAP3UNSETargs (XDR *, PMAP3UNSETargs*);
+extern  bool_t xdr_PMAP3GETADDRargs (XDR *, PMAP3GETADDRargs*);
+extern  bool_t xdr_PMAP3GETADDRres (XDR *, PMAP3GETADDRres*);
+extern  bool_t xdr_PMAP3DUMPres (XDR *, PMAP3DUMPres*);
+extern  bool_t xdr_PMAP3CALLITargs (XDR *, PMAP3CALLITargs*);
+extern  bool_t xdr_PMAP3CALLITres (XDR *, PMAP3CALLITres*);
+extern  bool_t xdr_PMAP3UADDR2TADDRres (XDR *, PMAP3UADDR2TADDRres*);
+extern  bool_t xdr_PMAP3TADDR2UADDRargs (XDR *, PMAP3TADDR2UADDRargs*);
+extern  bool_t xdr_PMAP3TADDR2UADDRres (XDR *, PMAP3TADDR2UADDRres*);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_PORTMAP_H_RPCGEN */

src/nfs/portmap.x

@@ -0,0 +1,168 @@
+/*
+Copyright (c) 2014, Ronnie Sahlberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies, 
+either expressed or implied, of the FreeBSD Project.
+*/
+
+const PMAP_PORT = 111;      /* portmapper port number */
+
+struct pmap2_mapping {
+	unsigned int prog;
+	unsigned int vers;
+	unsigned int prot;
+	unsigned int port;
+};
+
+struct pmap2_call_args {
+	unsigned int prog;
+	unsigned int vers;
+	unsigned int proc;
+	opaque args<>;
+};
+
+struct pmap2_call_result {
+	unsigned int port;
+	opaque res<>;
+};
+
+struct pmap2_mapping_list {
+	pmap2_mapping map;
+	pmap2_mapping_list *next;
+};
+
+struct pmap2_dump_result {
+	struct pmap2_mapping_list *list;
+};
+
+struct pmap3_string_result {
+	string addr<>;
+};
+
+struct pmap3_mapping {
+	unsigned int prog;
+	unsigned int vers;
+	string netid<>;
+	string addr<>;
+	string owner<>;
+};
+
+struct pmap3_mapping_list {
+	pmap3_mapping map;
+	pmap3_mapping_list *next;
+};
+
+struct pmap3_dump_result {
+	struct pmap3_mapping_list *list;
+};
+
+struct pmap3_call_args {
+	unsigned int prog;
+	unsigned int vers;
+	unsigned int proc;
+	opaque args<>;
+};
+
+struct pmap3_call_result {
+	unsigned int port;
+	opaque res<>;
+};
+
+struct pmap3_netbuf {
+	unsigned int maxlen;
+	/* This pretty much contains a sockaddr_storage.
+	 * Beware differences in endianess for ss_family
+	 * and whether or not ss_len exists.
+	 */
+	opaque buf<>;
+};
+
+typedef pmap2_mapping     PMAP2SETargs;
+typedef pmap2_mapping     PMAP2UNSETargs;
+typedef pmap2_mapping     PMAP2GETPORTargs;
+typedef pmap2_call_args   PMAP2CALLITargs;
+typedef pmap2_call_result PMAP2CALLITres;
+typedef pmap2_dump_result PMAP2DUMPres;
+
+typedef pmap3_mapping       PMAP3SETargs;
+typedef pmap3_mapping       PMAP3UNSETargs;
+typedef pmap3_mapping       PMAP3GETADDRargs;
+typedef pmap3_string_result PMAP3GETADDRres;
+typedef pmap3_dump_result   PMAP3DUMPres;
+typedef pmap3_call_result   PMAP3CALLITargs;
+typedef pmap3_call_result   PMAP3CALLITres;
+typedef pmap3_netbuf        PMAP3UADDR2TADDRres;
+typedef pmap3_netbuf        PMAP3TADDR2UADDRargs;
+typedef pmap3_string_result PMAP3TADDR2UADDRres;
+
+program PMAP_PROGRAM {
+	version PMAP_V2 {
+		void
+		PMAP2_NULL(void)              = 0;
+
+		uint32_t
+		PMAP2_SET(PMAP2SETargs)       = 1;
+
+		uint32_t
+		PMAP2_UNSET(PMAP2UNSETargs)   = 2;
+
+		uint32_t
+		PMAP2_GETPORT(PMAP2GETPORTargs) = 3;
+
+		PMAP2DUMPres
+		PMAP2_DUMP(void)               = 4;
+
+		PMAP2CALLITres
+		PMAP2_CALLIT(PMAP2CALLITargs)  = 5;
+	} = 2;
+	version PMAP_V3 {
+		void
+		PMAP3_NULL(void)              = 0;
+
+		uint32_t
+		PMAP3_SET(PMAP3SETargs)       = 1;
+
+		uint32_t
+		PMAP3_UNSET(PMAP3UNSETargs)   = 2;
+
+		PMAP3GETADDRres
+		PMAP3_GETADDR(PMAP3GETADDRargs) = 3;
+
+		PMAP3DUMPres
+		PMAP3_DUMP(void)              = 4;
+
+		PMAP3CALLITres
+		PMAP3_CALLIT(PMAP3CALLITargs) = 5;
+
+		uint32_t
+		PMAP3_GETTIME(void)           = 6;
+
+		PMAP3UADDR2TADDRres
+		PMAP3_UADDR2TADDR(string)     = 7;
+
+		PMAP3TADDR2UADDRres
+		PMAP3_TADDR2UADDR(PMAP3TADDR2UADDRargs) = 8;
+	} = 3;
+} = 100000;

src/nfs/portmap_xdr.cpp

@@ -0,0 +1,406 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "portmap.h"
+#include "xdr_impl_inline.h"
+
+bool_t
+xdr_pmap2_mapping (XDR *xdrs, pmap2_mapping *objp)
+{
+	
+
+	if (xdrs->x_op == XDR_ENCODE) {
+				if (1) {
+			 if (!xdr_u_int (xdrs, &objp->prog))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->vers))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->prot))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->port))
+				 return FALSE;
+		} else {
+			IXDR_PUT_U_LONG(buf, objp->prog);
+			IXDR_PUT_U_LONG(buf, objp->vers);
+			IXDR_PUT_U_LONG(buf, objp->prot);
+			IXDR_PUT_U_LONG(buf, objp->port);
+		}
+		return TRUE;
+	} else if (xdrs->x_op == XDR_DECODE) {
+				if (1) {
+			 if (!xdr_u_int (xdrs, &objp->prog))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->vers))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->prot))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->port))
+				 return FALSE;
+		} else {
+			objp->prog = IXDR_GET_U_LONG(buf);
+			objp->vers = IXDR_GET_U_LONG(buf);
+			objp->prot = IXDR_GET_U_LONG(buf);
+			objp->port = IXDR_GET_U_LONG(buf);
+		}
+	 return TRUE;
+	}
+
+	 if (!xdr_u_int (xdrs, &objp->prog))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->vers))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->prot))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->port))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_pmap2_call_args (XDR *xdrs, pmap2_call_args *objp)
+{
+	
+
+	if (xdrs->x_op == XDR_ENCODE) {
+				if (1) {
+			 if (!xdr_u_int (xdrs, &objp->prog))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->vers))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->proc))
+				 return FALSE;
+
+		} else {
+		IXDR_PUT_U_LONG(buf, objp->prog);
+		IXDR_PUT_U_LONG(buf, objp->vers);
+		IXDR_PUT_U_LONG(buf, objp->proc);
+		}
+		 if (!xdr_bytes(xdrs, &objp->args, ~0))
+			 return FALSE;
+		return TRUE;
+	} else if (xdrs->x_op == XDR_DECODE) {
+				if (1) {
+			 if (!xdr_u_int (xdrs, &objp->prog))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->vers))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->proc))
+				 return FALSE;
+
+		} else {
+		objp->prog = IXDR_GET_U_LONG(buf);
+		objp->vers = IXDR_GET_U_LONG(buf);
+		objp->proc = IXDR_GET_U_LONG(buf);
+		}
+		 if (!xdr_bytes(xdrs, &objp->args, ~0))
+			 return FALSE;
+	 return TRUE;
+	}
+
+	 if (!xdr_u_int (xdrs, &objp->prog))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->vers))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->proc))
+		 return FALSE;
+	 if (!xdr_bytes(xdrs, &objp->args, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_pmap2_call_result (XDR *xdrs, pmap2_call_result *objp)
+{
+	
+	 if (!xdr_u_int (xdrs, &objp->port))
+		 return FALSE;
+	 if (!xdr_bytes(xdrs, &objp->res, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_pmap2_mapping_list (XDR *xdrs, pmap2_mapping_list *objp)
+{
+	
+	 if (!xdr_pmap2_mapping (xdrs, &objp->map))
+		 return FALSE;
+	 if (!xdr_pointer (xdrs, (char **)&objp->next, sizeof (pmap2_mapping_list), (xdrproc_t) xdr_pmap2_mapping_list))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_pmap2_dump_result (XDR *xdrs, pmap2_dump_result *objp)
+{
+	
+	 if (!xdr_pointer (xdrs, (char **)&objp->list, sizeof (pmap2_mapping_list), (xdrproc_t) xdr_pmap2_mapping_list))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_pmap3_string_result (XDR *xdrs, pmap3_string_result *objp)
+{
+	
+	 if (!xdr_string (xdrs, &objp->addr, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_pmap3_mapping (XDR *xdrs, pmap3_mapping *objp)
+{
+	
+	 if (!xdr_u_int (xdrs, &objp->prog))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->vers))
+		 return FALSE;
+	 if (!xdr_string (xdrs, &objp->netid, ~0))
+		 return FALSE;
+	 if (!xdr_string (xdrs, &objp->addr, ~0))
+		 return FALSE;
+	 if (!xdr_string (xdrs, &objp->owner, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_pmap3_mapping_list (XDR *xdrs, pmap3_mapping_list *objp)
+{
+	
+	 if (!xdr_pmap3_mapping (xdrs, &objp->map))
+		 return FALSE;
+	 if (!xdr_pointer (xdrs, (char **)&objp->next, sizeof (pmap3_mapping_list), (xdrproc_t) xdr_pmap3_mapping_list))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_pmap3_dump_result (XDR *xdrs, pmap3_dump_result *objp)
+{
+	
+	 if (!xdr_pointer (xdrs, (char **)&objp->list, sizeof (pmap3_mapping_list), (xdrproc_t) xdr_pmap3_mapping_list))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_pmap3_call_args (XDR *xdrs, pmap3_call_args *objp)
+{
+	
+
+	if (xdrs->x_op == XDR_ENCODE) {
+				if (1) {
+			 if (!xdr_u_int (xdrs, &objp->prog))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->vers))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->proc))
+				 return FALSE;
+
+		} else {
+		IXDR_PUT_U_LONG(buf, objp->prog);
+		IXDR_PUT_U_LONG(buf, objp->vers);
+		IXDR_PUT_U_LONG(buf, objp->proc);
+		}
+		 if (!xdr_bytes(xdrs, &objp->args, ~0))
+			 return FALSE;
+		return TRUE;
+	} else if (xdrs->x_op == XDR_DECODE) {
+				if (1) {
+			 if (!xdr_u_int (xdrs, &objp->prog))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->vers))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->proc))
+				 return FALSE;
+
+		} else {
+		objp->prog = IXDR_GET_U_LONG(buf);
+		objp->vers = IXDR_GET_U_LONG(buf);
+		objp->proc = IXDR_GET_U_LONG(buf);
+		}
+		 if (!xdr_bytes(xdrs, &objp->args, ~0))
+			 return FALSE;
+	 return TRUE;
+	}
+
+	 if (!xdr_u_int (xdrs, &objp->prog))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->vers))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->proc))
+		 return FALSE;
+	 if (!xdr_bytes(xdrs, &objp->args, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_pmap3_call_result (XDR *xdrs, pmap3_call_result *objp)
+{
+	
+	 if (!xdr_u_int (xdrs, &objp->port))
+		 return FALSE;
+	 if (!xdr_bytes(xdrs, &objp->res, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_pmap3_netbuf (XDR *xdrs, pmap3_netbuf *objp)
+{
+	
+	 if (!xdr_u_int (xdrs, &objp->maxlen))
+		 return FALSE;
+	 if (!xdr_bytes(xdrs, &objp->buf, ~0))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP2SETargs (XDR *xdrs, PMAP2SETargs *objp)
+{
+	
+	 if (!xdr_pmap2_mapping (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP2UNSETargs (XDR *xdrs, PMAP2UNSETargs *objp)
+{
+	
+	 if (!xdr_pmap2_mapping (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP2GETPORTargs (XDR *xdrs, PMAP2GETPORTargs *objp)
+{
+	
+	 if (!xdr_pmap2_mapping (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP2CALLITargs (XDR *xdrs, PMAP2CALLITargs *objp)
+{
+	
+	 if (!xdr_pmap2_call_args (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP2CALLITres (XDR *xdrs, PMAP2CALLITres *objp)
+{
+	
+	 if (!xdr_pmap2_call_result (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP2DUMPres (XDR *xdrs, PMAP2DUMPres *objp)
+{
+	
+	 if (!xdr_pmap2_dump_result (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP3SETargs (XDR *xdrs, PMAP3SETargs *objp)
+{
+	
+	 if (!xdr_pmap3_mapping (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP3UNSETargs (XDR *xdrs, PMAP3UNSETargs *objp)
+{
+	
+	 if (!xdr_pmap3_mapping (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP3GETADDRargs (XDR *xdrs, PMAP3GETADDRargs *objp)
+{
+	
+	 if (!xdr_pmap3_mapping (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP3GETADDRres (XDR *xdrs, PMAP3GETADDRres *objp)
+{
+	
+	 if (!xdr_pmap3_string_result (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP3DUMPres (XDR *xdrs, PMAP3DUMPres *objp)
+{
+	
+	 if (!xdr_pmap3_dump_result (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP3CALLITargs (XDR *xdrs, PMAP3CALLITargs *objp)
+{
+	
+	 if (!xdr_pmap3_call_result (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP3CALLITres (XDR *xdrs, PMAP3CALLITres *objp)
+{
+	
+	 if (!xdr_pmap3_call_result (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP3UADDR2TADDRres (XDR *xdrs, PMAP3UADDR2TADDRres *objp)
+{
+	
+	 if (!xdr_pmap3_netbuf (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP3TADDR2UADDRargs (XDR *xdrs, PMAP3TADDR2UADDRargs *objp)
+{
+	
+	 if (!xdr_pmap3_netbuf (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_PMAP3TADDR2UADDRres (XDR *xdrs, PMAP3TADDR2UADDRres *objp)
+{
+	
+	 if (!xdr_pmap3_string_result (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}

src/nfs/rpc.h

@@ -0,0 +1,160 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#ifndef _RPC_H_RPCGEN
+#define _RPC_H_RPCGEN
+
+#include "xdr_impl.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define RPC_MSG_VERSION 2
+
+enum rpc_auth_flavor {
+	RPC_AUTH_NONE = 0,
+	RPC_AUTH_SYS = 1,
+	RPC_AUTH_SHORT = 2,
+	RPC_AUTH_DH = 3,
+	RPC_RPCSEC_GSS = 6,
+};
+typedef enum rpc_auth_flavor rpc_auth_flavor;
+
+enum rpc_msg_type {
+	RPC_CALL = 0,
+	RPC_REPLY = 1,
+};
+typedef enum rpc_msg_type rpc_msg_type;
+
+enum rpc_reply_stat {
+	RPC_MSG_ACCEPTED = 0,
+	RPC_MSG_DENIED = 1,
+};
+typedef enum rpc_reply_stat rpc_reply_stat;
+
+enum rpc_accept_stat {
+	RPC_SUCCESS = 0,
+	RPC_PROG_UNAVAIL = 1,
+	RPC_PROG_MISMATCH = 2,
+	RPC_PROC_UNAVAIL = 3,
+	RPC_GARBAGE_ARGS = 4,
+	RPC_SYSTEM_ERR = 5,
+};
+typedef enum rpc_accept_stat rpc_accept_stat;
+
+enum rpc_reject_stat {
+	RPC_MISMATCH = 0,
+	RPC_AUTH_ERROR = 1,
+};
+typedef enum rpc_reject_stat rpc_reject_stat;
+
+enum rpc_auth_stat {
+	RPC_AUTH_OK = 0,
+	RPC_AUTH_BADCRED = 1,
+	RPC_AUTH_REJECTEDCRED = 2,
+	RPC_AUTH_BADVERF = 3,
+	RPC_AUTH_REJECTEDVERF = 4,
+	RPC_AUTH_TOOWEAK = 5,
+	RPC_AUTH_INVALIDRESP = 6,
+	RPC_AUTH_FAILED = 7,
+};
+typedef enum rpc_auth_stat rpc_auth_stat;
+
+struct rpc_opaque_auth {
+	rpc_auth_flavor flavor;
+	xdr_string_t body;
+};
+typedef struct rpc_opaque_auth rpc_opaque_auth;
+
+struct rpc_call_body {
+	u_int rpcvers;
+	u_int prog;
+	u_int vers;
+	u_int proc;
+	rpc_opaque_auth cred;
+	rpc_opaque_auth verf;
+};
+typedef struct rpc_call_body rpc_call_body;
+
+struct rpc_mismatch_info {
+	u_int min_version;
+	u_int max_version;
+};
+typedef struct rpc_mismatch_info rpc_mismatch_info;
+
+struct rpc_accepted_reply_body {
+	rpc_accept_stat stat;
+	union {
+		rpc_mismatch_info mismatch_info;
+	};
+};
+typedef struct rpc_accepted_reply_body rpc_accepted_reply_body;
+
+struct rpc_accepted_reply {
+	rpc_opaque_auth verf;
+	rpc_accepted_reply_body reply_data;
+};
+typedef struct rpc_accepted_reply rpc_accepted_reply;
+
+struct rpc_rejected_reply {
+	rpc_reject_stat stat;
+	union {
+		rpc_mismatch_info mismatch_info;
+		rpc_auth_stat auth_stat;
+	};
+};
+typedef struct rpc_rejected_reply rpc_rejected_reply;
+
+struct rpc_reply_body {
+	rpc_reply_stat stat;
+	union {
+		rpc_accepted_reply areply;
+		rpc_rejected_reply rreply;
+	};
+};
+typedef struct rpc_reply_body rpc_reply_body;
+
+struct rpc_msg_body {
+	rpc_msg_type dir;
+	union {
+		rpc_call_body cbody;
+		rpc_reply_body rbody;
+	};
+};
+typedef struct rpc_msg_body rpc_msg_body;
+
+struct rpc_msg {
+	u_int xid;
+	rpc_msg_body body;
+};
+typedef struct rpc_msg rpc_msg;
+
+/* the xdr functions */
+
+
+extern  bool_t xdr_rpc_auth_flavor (XDR *, rpc_auth_flavor*);
+extern  bool_t xdr_rpc_msg_type (XDR *, rpc_msg_type*);
+extern  bool_t xdr_rpc_reply_stat (XDR *, rpc_reply_stat*);
+extern  bool_t xdr_rpc_accept_stat (XDR *, rpc_accept_stat*);
+extern  bool_t xdr_rpc_reject_stat (XDR *, rpc_reject_stat*);
+extern  bool_t xdr_rpc_auth_stat (XDR *, rpc_auth_stat*);
+extern  bool_t xdr_rpc_opaque_auth (XDR *, rpc_opaque_auth*);
+extern  bool_t xdr_rpc_call_body (XDR *, rpc_call_body*);
+extern  bool_t xdr_rpc_mismatch_info (XDR *, rpc_mismatch_info*);
+extern  bool_t xdr_rpc_accepted_reply_body (XDR *, rpc_accepted_reply_body*);
+extern  bool_t xdr_rpc_accepted_reply (XDR *, rpc_accepted_reply*);
+extern  bool_t xdr_rpc_rejected_reply (XDR *, rpc_rejected_reply*);
+extern  bool_t xdr_rpc_reply_body (XDR *, rpc_reply_body*);
+extern  bool_t xdr_rpc_msg_body (XDR *, rpc_msg_body*);
+extern  bool_t xdr_rpc_msg (XDR *, rpc_msg*);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_RPC_H_RPCGEN */

src/nfs/rpc.x

@@ -0,0 +1,113 @@
+/* Based on RFC 5531 - RPC: Remote Procedure Call Protocol Specification Version 2 */
+
+const RPC_MSG_VERSION = 2;
+
+enum rpc_auth_flavor {
+	RPC_AUTH_NONE  = 0,
+	RPC_AUTH_SYS   = 1,
+	RPC_AUTH_SHORT = 2,
+	RPC_AUTH_DH    = 3,
+	RPC_RPCSEC_GSS = 6
+};
+
+enum rpc_msg_type {
+	RPC_CALL  = 0,
+	RPC_REPLY = 1
+};
+
+enum rpc_reply_stat {
+	RPC_MSG_ACCEPTED = 0,
+	RPC_MSG_DENIED   = 1
+};
+
+enum rpc_accept_stat {
+	RPC_SUCCESS       = 0,
+	RPC_PROG_UNAVAIL  = 1,
+	RPC_PROG_MISMATCH = 2,
+	RPC_PROC_UNAVAIL  = 3,
+	RPC_GARBAGE_ARGS  = 4,
+	RPC_SYSTEM_ERR    = 5
+};
+
+enum rpc_reject_stat {
+	RPC_MISMATCH   = 0,
+	RPC_AUTH_ERROR = 1
+};
+
+enum rpc_auth_stat {
+	RPC_AUTH_OK = 0,
+	/*
+	 * failed at remote end
+	 */
+	RPC_AUTH_BADCRED      = 1, /* bogus credentials (seal broken) */
+	RPC_AUTH_REJECTEDCRED = 2, /* client should begin new session */
+	RPC_AUTH_BADVERF      = 3, /* bogus verifier (seal broken) */
+	RPC_AUTH_REJECTEDVERF = 4, /* verifier expired or was replayed */
+	RPC_AUTH_TOOWEAK      = 5, /* rejected due to security reasons */
+	/*
+	 * failed locally
+	 */
+	RPC_AUTH_INVALIDRESP  = 6, /* bogus response verifier */
+	RPC_AUTH_FAILED       = 7  /* some unknown reason */
+};
+
+struct rpc_opaque_auth {
+	rpc_auth_flavor flavor;
+	opaque body<400>;
+};
+
+struct rpc_call_body {
+	u_int rpcvers;
+	u_int prog;
+	u_int vers;
+	u_int proc;
+	rpc_opaque_auth cred;
+	rpc_opaque_auth verf;
+	/* procedure-specific parameters start here */
+};
+
+struct rpc_mismatch_info {
+	unsigned int min_version;
+	unsigned int max_version;
+};
+
+union rpc_accepted_reply_body switch (rpc_accept_stat stat) {
+case RPC_SUCCESS:
+	void;
+	/* procedure-specific results start here */
+case RPC_PROG_MISMATCH:
+	rpc_mismatch_info mismatch_info;
+default:
+	void;
+};
+
+struct rpc_accepted_reply {
+	rpc_opaque_auth verf;
+	rpc_accepted_reply_body reply_data;
+};
+
+union rpc_rejected_reply switch (rpc_reject_stat stat) {
+case RPC_MISMATCH:
+	rpc_mismatch_info mismatch_info;
+case RPC_AUTH_ERROR:
+	rpc_auth_stat auth_stat;
+};
+
+union rpc_reply_body switch (rpc_reply_stat stat) {
+case RPC_MSG_ACCEPTED:
+	rpc_accepted_reply areply;
+case RPC_MSG_DENIED:
+	rpc_rejected_reply rreply;
+};
+
+union rpc_msg_body switch (rpc_msg_type dir) {
+case RPC_CALL:
+	rpc_call_body cbody;
+case RPC_REPLY:
+	rpc_reply_body rbody;
+};
+
+struct rpc_msg {
+	u_int xid;
+	rpc_msg_body body;
+};

src/nfs/rpc_impl.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "rpc.h"
+
+struct rpc_op_t;
+
+// Handler should return 1 if the request is processed asynchronously
+// and requires the incoming message to not be freed until processing ends,
+// 0 otherwise.
+typedef int (*rpc_handler_t)(void *opaque, rpc_op_t *rop);
+
+struct rpc_service_proc_t
+{
+    uint32_t prog;
+    uint32_t vers;
+    uint32_t proc;
+    rpc_handler_t handler_fn;
+    xdrproc_t req_fn;
+    uint32_t req_size;
+    xdrproc_t resp_fn;
+    uint32_t resp_size;
+    void *opaque;
+};
+
+inline bool operator < (const rpc_service_proc_t & a, const rpc_service_proc_t & b)
+{
+    return a.prog < b.prog || a.prog == b.prog && (a.vers < b.vers || a.vers == b.vers && a.proc < b.proc);
+}
+
+struct rpc_op_t
+{
+    void *client;
+    uint8_t *buffer;
+    XDR *xdrs;
+    rpc_msg in_msg, out_msg;
+    void *request;
+    void *reply;
+    xdrproc_t reply_fn;
+    uint32_t reply_marker;
+    bool referenced;
+};
+
+void rpc_queue_reply(rpc_op_t *rop);

src/nfs/rpc_xdr.cpp

@@ -0,0 +1,253 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "rpc.h"
+#include "xdr_impl_inline.h"
+
+bool_t
+xdr_rpc_auth_flavor (XDR *xdrs, rpc_auth_flavor *objp)
+{
+	
+	 if (!xdr_enum (xdrs, (enum_t *) objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_rpc_msg_type (XDR *xdrs, rpc_msg_type *objp)
+{
+	
+	 if (!xdr_enum (xdrs, (enum_t *) objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_rpc_reply_stat (XDR *xdrs, rpc_reply_stat *objp)
+{
+	
+	 if (!xdr_enum (xdrs, (enum_t *) objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_rpc_accept_stat (XDR *xdrs, rpc_accept_stat *objp)
+{
+	
+	 if (!xdr_enum (xdrs, (enum_t *) objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_rpc_reject_stat (XDR *xdrs, rpc_reject_stat *objp)
+{
+	
+	 if (!xdr_enum (xdrs, (enum_t *) objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_rpc_auth_stat (XDR *xdrs, rpc_auth_stat *objp)
+{
+	
+	 if (!xdr_enum (xdrs, (enum_t *) objp))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_rpc_opaque_auth (XDR *xdrs, rpc_opaque_auth *objp)
+{
+	
+	 if (!xdr_rpc_auth_flavor (xdrs, &objp->flavor))
+		 return FALSE;
+	 if (!xdr_bytes(xdrs, &objp->body, 400))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_rpc_call_body (XDR *xdrs, rpc_call_body *objp)
+{
+	
+
+	if (xdrs->x_op == XDR_ENCODE) {
+				if (1) {
+			 if (!xdr_u_int (xdrs, &objp->rpcvers))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->prog))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->vers))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->proc))
+				 return FALSE;
+
+		} else {
+		IXDR_PUT_U_LONG(buf, objp->rpcvers);
+		IXDR_PUT_U_LONG(buf, objp->prog);
+		IXDR_PUT_U_LONG(buf, objp->vers);
+		IXDR_PUT_U_LONG(buf, objp->proc);
+		}
+		 if (!xdr_rpc_opaque_auth (xdrs, &objp->cred))
+			 return FALSE;
+		 if (!xdr_rpc_opaque_auth (xdrs, &objp->verf))
+			 return FALSE;
+		return TRUE;
+	} else if (xdrs->x_op == XDR_DECODE) {
+				if (1) {
+			 if (!xdr_u_int (xdrs, &objp->rpcvers))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->prog))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->vers))
+				 return FALSE;
+			 if (!xdr_u_int (xdrs, &objp->proc))
+				 return FALSE;
+
+		} else {
+		objp->rpcvers = IXDR_GET_U_LONG(buf);
+		objp->prog = IXDR_GET_U_LONG(buf);
+		objp->vers = IXDR_GET_U_LONG(buf);
+		objp->proc = IXDR_GET_U_LONG(buf);
+		}
+		 if (!xdr_rpc_opaque_auth (xdrs, &objp->cred))
+			 return FALSE;
+		 if (!xdr_rpc_opaque_auth (xdrs, &objp->verf))
+			 return FALSE;
+	 return TRUE;
+	}
+
+	 if (!xdr_u_int (xdrs, &objp->rpcvers))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->prog))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->vers))
+		 return FALSE;
+	 if (!xdr_u_int (xdrs, &objp->proc))