#encoding #protocol #xdr #serialization #rfc4506

bin+lib xdrgen

XDR codec generator from specification. Designed for use with xdr-codec.

23 releases

Uses old Rust 2015

0.4.4 Aug 2, 2017
0.4.3 Jul 18, 2017
0.4.2 Jun 20, 2017
0.4.0 Mar 3, 2017
0.1.7 Nov 11, 2015

#2257 in Parser implementations

Download history 6/week @ 2023-06-03 2/week @ 2023-06-10 45/week @ 2023-06-17 12/week @ 2023-06-24 56/week @ 2023-07-01 29/week @ 2023-07-08 10/week @ 2023-07-15 63/week @ 2023-07-22 57/week @ 2023-07-29 10/week @ 2023-08-05 37/week @ 2023-08-12 12/week @ 2023-08-19 30/week @ 2023-08-26 10/week @ 2023-09-02 44/week @ 2023-09-09 35/week @ 2023-09-16

121 downloads per month
Used in 2 crates



Rust XDR library

Build Status Crates.io Coverage Status

This crate provides xdrgen, which takes an XDR specification in a .x file, and produces Rust code to serialize and deserialize the specified types. It is intended to be used in conjunction with xdr-codec.

The syntax of the .x file follows RFC4506. This has type definitions for XDR but does not include RPC protocol specifications. Correspondingly, xdrgen does not support auto-generation of RPC clients/servers.

Changes in 0.4.0

  • Now uses the quote package, so it will work on stable Rust
  • Detects the use of Rust keywords in XDR specifications, and appends a _ to them.


Usage is straightforward. You can generate the Rust code from a spec a build.rs:

extern crate xdrgen;

fn main() {
    xdrgen::compile("src/simple.x").expect("xdrgen simple.x failed");

This code can then be included into a module:

mod simple {
    use xdr_codec;

    include!(concat!(env!("OUT_DIR"), "/simple_xdr.rs"));

Once you have this, you can call mytype.pack(&mut output), and let mything: MyThing = xdr_codec::unpack(&mut input)?;.

The serializers require your types to implement the Pack and Unpack traits, and generate code to write to std::io::Write implementation, and read from std::io::Read.

All types and fields are generated public, so you can control their access outside your module or crate. If your spec references other types which are not defined within the spec, then you can define them within the module as well, either by aliasing them with other defined types, or implementing the Pack and Unpack traits yourself.

Use can use xdr-codec's XdrRecordReader and XdrRecordWriter types as IO filters that implement XDR-RPC record marking.

More documentation for xdrgen here. See the documentation for xdr-codec for more details about using the generated types and code.


There are currently a few limitations:

  • The generated code uses identifiers as specified in the .x file, so the Rust code will not use normal formatting conventions.
  • Generated code follows no formatting convention - use rustfmt if desired.
  • XDR has discriminated unions, which are a good match for Rust enums. However, it also supports a default case if an unknown discriminator is encountered. This crate supports this for unpacking, but not for packing, as Rust does not allow enums to have unknown values.
  • The generated code uses #[derive(Debug, Clone, ...)] to generate implementations for common traits. However, rustc only supports #[derive] on fixed-size arrays with 0..32 elements; if you have an array larger than this, the generated code will fail to compile. Right now, the only workaround is to manually implement Pack and Unpack for such types. (TODO: add an option to omit derived traits.)


Licensed under either of

at your option.


Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.


~113K SLoC