domain-core 0.4.0

A DNS library for Rust – Core.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! EDNS Options from RFC 6975.

use std::slice;
use bytes::{BufMut, Bytes};
use ::bits::compose::Compose;
use ::bits::message_builder::OptBuilder;
use ::bits::parse::{ParseAll, Parser, ShortBuf};
use ::iana::{OptionCode, SecAlg};
use super::CodeOptData;


//------------ Dau, Dhu, N3u -------------------------------------------------

macro_rules! option_type {
    ( $name:ident ) => {
        #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
        pub struct $name {
            bytes: Bytes,
        }

        impl $name {

            pub fn from_bytes(bytes: Bytes) -> Self {
                $name { bytes }
            }

            pub fn iter(&self) -> SecAlgsIter {
                SecAlgsIter::new(self.bytes.as_ref())
            }

            pub fn push(builder: &mut OptBuilder, algs: &[SecAlg])
                        -> Result<(), ShortBuf> {
                assert!(algs.len() <= ::std::u16::MAX as usize);
                builder.build(OptionCode::$name, algs.len() as u16, |buf| {
                    for alg in algs {
                        buf.compose(&alg.to_int())?
                    }
                    Ok(())
                })
            }
        }

        //--- ParseAll, Compose

        impl ParseAll for $name {
            type Err = ShortBuf;

            fn parse_all(parser: &mut Parser, len: usize)
                         -> Result<Self, Self::Err> {
                parser.parse_bytes(len).map(Self::from_bytes)
            }
        }

        impl Compose for $name {
            fn compose_len(&self) -> usize {
                self.bytes.len()
            }

            fn compose<B: BufMut>(&self, buf: &mut B) {
                buf.put_slice(self.bytes.as_ref())
            }
        }


        //--- CodeOptData
        
        impl CodeOptData for $name {
            const CODE: OptionCode = OptionCode::$name;
        }

        
        //--- IntoIter

        impl<'a> IntoIterator for &'a $name {
            type Item = SecAlg;
            type IntoIter = SecAlgsIter<'a>;

            fn into_iter(self) -> Self::IntoIter {
                self.iter()
            }
        }
    }
}

option_type!(Dau);
option_type!(Dhu);
option_type!(N3u);


//------------ SecAlgsIter ---------------------------------------------------

pub struct SecAlgsIter<'a>(slice::Iter<'a, u8>);

impl<'a> SecAlgsIter<'a> {
    fn new(slice: &'a [u8]) -> Self {
        SecAlgsIter(slice.iter())
    }
}

impl<'a> Iterator for SecAlgsIter<'a> {
    type Item = SecAlg;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.next().map(|x| SecAlg::from_int(*x))
    }
}