resynth 0.4.0

A packet synthesis language
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

use std::rc::Rc;

use pkt::{Packet, vxlan};

use crate::libapi::{Class, ClassDef, FuncDef, Module};
use crate::sym::Symbol;
use crate::val::{Val, ValDef};
use ezpkt::VxlanFlow;

const ENCAP: FuncDef = func!(
    /// Encapsulate a series of packets
    resynth fn encap(
        it: PktGen
        =>
        =>
        Void
    ) -> PktGen
    |mut args| {
        let obj = args.take_this();
        let mut r = obj.borrow_mut();
        let this: &mut VxlanFlow = r.as_mut_any().downcast_mut().unwrap();
        let it: Rc<Box<[Packet]>> = args.next().into();

        let mut ret: Vec<Packet> = Vec::with_capacity(it.len());

        for pkt in it.iter() {
            ret.push(this.encap(pkt.as_slice().get(pkt)));
        }

        Ok(ret.into())
    }
);

const DGRAM: FuncDef = func!(
    /// Encapsulate a single packet
    resynth fn dgram(
        pkt: Pkt
        =>
        =>
        Void
    ) -> Pkt
    |mut args| {
        let obj = args.take_this();
        let mut r = obj.borrow_mut();
        let this: &mut VxlanFlow = r.as_mut_any().downcast_mut().unwrap();
        let pkt: Rc<Packet> = args.next().into();
        Ok(this.encap(pkt.as_slice().get(&pkt)).into())
    }
);

const VXLAN: ClassDef = class!(
    /// # VXLAN Session
    resynth class Vxlan {
        dgram => Symbol::Func(&DGRAM),
        encap => Symbol::Func(&ENCAP),
    }
);

impl Class for VxlanFlow {
    fn def(&self) -> &'static ClassDef {
        &VXLAN
    }
}

const SESSION: FuncDef = func!(
    /// Create a VXLAN session
    resynth fn session(
        cl: Sock4,
        sv: Sock4,
        =>
        sessionid: U32 = 0, // TODO: Make it optional
        raw: Bool = false,
        =>
        Void
    ) -> Obj
    |mut args| {
        let cl = args.next();
        let sv = args.next();
        let vni: u32 = args.next().into();
        let raw: bool = args.next().into();
        Ok(Val::from(VxlanFlow::new(cl.into(), sv.into(), vni, raw)))
    }
);

pub const MODULE: Module = module! {
    /// # VXLAN Encapsulation
    ///
    /// Encapsulates ethernet frames in [UDP](../ipv4/udp/README.md) datagrams.
    resynth mod vxlan {
        Vxlan => Symbol::Class(&VXLAN),
        session => Symbol::Func(&SESSION),
        DEFAULT_PORT => Symbol::u16(vxlan::DEFAULT_PORT),
    }
};