//! # High level notes
//!
//! The contents of this module are generated mostly by macros, which
//! implement the appropriate traits necessary to both be
//! serialized/deserialized and also provide an additional level of
//! type safety when contstructing netlink packets. Some of the traits
//! generated in this module allow netlink structures to implement
//! trait bounds assuring that only compatible constant-based enums
//! are allowed to be passed in as parameters.  The macros are
//! exported - you can use them too! See [impl_var], [impl_trait], and
//! [impl_flags] for more details.
//!
//! Note that most of these constants come from the Linux kernel
//! headers, which can be found in `/usr/include/linux` on many
//! distros. You can also see `man 3 netlink`, `man 7 netlink`,
//! and `man 7 rtnetlink` for more information.
//!
//! # Design decisions
//!
//! * Macros are exported so that these conventions are extensible and
//! usable for data types implemented by the user in the case of new
//! netlink families (which is supported by the protocol). In this
//! case, there is no way in which I can support every custom netlink
//! family but my aim is to make this library as flexible as possible
//! so that it is painless to hook your custom netlink data type into
//! the existing library support.
//! * Enums are used so that:
//!   * Values can be checked based on a finite number of inputs as
//!   opposed to the range of whatever integer data type C defines as
//!   the struct member type. This makes it easier to catch garbage
//!   responses and corruption when an invalid netlink message is sent
//!   to the kernel.
//!   * Only the enum or an enum implementing a marker trait in the
//!   case of type parameters can be used in the appropriate places
//!   when constructing netlink messages. This takes guess work out of
//!   which constants can be used where. Netlink documentation is not
//!   always complete and sometimes takes a bit of trial and error
//!   sending messages to the kernel to figure out if you are using
//!   the correct constants. This setup should let you know at compile
//!   time if you are doing something you should not be doing.
//! * `UnrecognizedVariant` is included in each enum because
//! completeness cannot be guaranteed for every constant for every
//! protocol. This allows you to inspect the integer value returned
//! and if you are sure that it is correct, you can use it. If it is
//! a garbage value, this can also be useful for error reporting.

#[macro_use]
mod macros;

/// Constants related to generic netlink
pub mod genl;
/// Constants related to netfilter netlink integration
pub mod netfilter;
/// Constants related to generic netlink top level headers
pub mod nl;
/// Constants related to rtnetlink
pub mod rtnl;
/// Constants related to netlink socket operations
pub mod socket;

/// Reimplementation of alignto macro in C
pub fn alignto(len: usize) -> usize {
    (len + libc::NLA_ALIGNTO as usize - 1) & !(libc::NLA_ALIGNTO as usize - 1)
}

#[cfg(test)]
mod test {
    use super::genl::*;

    #[test]
    fn test_generated_enum_into_from() {
        let unspec: u8 = CtrlCmd::Unspec.into();
        assert_eq!(unspec, libc::CTRL_CMD_UNSPEC as u8);

        let unspec_variant = CtrlCmd::from(libc::CTRL_CMD_UNSPEC as u8);
        assert_eq!(unspec_variant, CtrlCmd::Unspec);
    }
}
