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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! Module containing everything related to Nested payloads
use crate::payloads::Ipv8Payload;
use crate::serialization::varlen::VarLen16;
use crate::serialization::Packet;
use serde;
use serde::de::Deserialize;
use serde::de::Deserializer;
use serde::ser::Serialize;
use serde::ser::SerializeStruct;
use serde::ser::Serializer;

#[derive(PartialEq, Debug)]
/// A struct containing a packet, thus creating a NestedPacket if you will
pub struct NestedPacket(pub Packet);

impl Ipv8Payload for NestedPacket {
    // doesnt have anything but needed for the default implementation (as of right now)
}

impl Serialize for NestedPacket {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let i = VarLen16((self.0).0.to_owned());

        let mut state = serializer.serialize_struct("NestedPacket", self.0.len())?;
        state.serialize_field("payload", &i)?;
        state.end()
    }
}

#[derive(Debug, PartialEq, serde::Deserialize)]
/// this is the actual pattern of a NestedPayload.
/// Used for deserializing. This is again needed because there is no 1:1 mapping between the
/// serialized data and the payload struct. This is the intermediate representation.
struct NestedPayloadPattern(VarLen16);

impl<'de> Deserialize<'de> for NestedPacket {
    /// deserializes an IntroductionRequestPayload
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        // first deserialize it to a temporary struct which literally represents the packer
        let payload_temporary: NestedPayloadPattern =
            NestedPayloadPattern::deserialize(deserializer)?;
        Ok(NestedPacket(Packet((payload_temporary.0).0)))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::serialization::Packet;
    use serde;

    #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
    struct TestPayload1 {
        test: NestedPacket,
    }

    impl Ipv8Payload for TestPayload1 {
        // doesnt have anything but needed for the default implementation (as of right now)
    }

    #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
    struct TestPayload2 {
        test: u16,
    }

    impl Ipv8Payload for TestPayload2 {
        // doesnt have anything but needed for the default implementation (as of right now)
    }

    #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
    struct TestPayload3 {}

    impl Ipv8Payload for TestPayload3 {
        // doesnt have anything but needed for the default implementation (as of right now)
    }

    #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
    struct TestPayload4 {
        test: Vec<u8>,
    }

    impl Ipv8Payload for TestPayload4 {
        // doesnt have anything but needed for the default implementation (as of right now)
    }

    #[test]
    fn integration_test_creation() {
        let mut packet = Packet::new(create_test_header!()).unwrap();
        packet.add(&TestPayload2 { test: 10 }).unwrap();

        let mut packet2 = Packet::new(create_test_header!()).unwrap();
        packet2.add(&TestPayload2 { test: 10 }).unwrap();

        let i = TestPayload1 {
            test: NestedPacket(packet),
        };
        let mut newpacket = Packet::new(create_test_header!()).unwrap();
        newpacket.add(&i).unwrap();

        assert_eq!(
            i,
            newpacket
                .start_deserialize()
                .skip_header()
                .unwrap()
                .next_payload()
                .unwrap()
        );
    }

    #[test]
    fn test_empty() {
        let mut packet = Packet::new(create_test_header!()).unwrap();
        packet.add(&TestPayload3 {}).unwrap();

        let mut packet2 = Packet::new(create_test_header!()).unwrap();
        packet2.add(&TestPayload3 {}).unwrap();

        let i = TestPayload1 {
            test: NestedPacket(packet),
        };

        let mut newpacket = Packet::new(create_test_header!()).unwrap();
        newpacket.add(&i).unwrap();

        assert_eq!(
            i,
            newpacket
                .start_deserialize()
                .skip_header()
                .unwrap()
                .next_payload()
                .unwrap()
        );
    }

    #[test]
    fn test_too_large() {
        let tmp: Vec<u8> = vec![0; (1u32 << 17) as usize];
        let mut packet = Packet::new(create_test_header!()).unwrap();
        packet.add(&TestPayload4 { test: tmp }).unwrap();

        let i = TestPayload1 {
            test: NestedPacket(packet),
        };

        let mut packet = Packet::new(create_test_header!()).unwrap();
        match packet.add(&i) {
            Ok(_) => assert!(false),
            Err(_) => assert!(true),
        }
    }
}