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

// Copyright (c) 2019 Maxime “pep” Buquet <pep@bouah.net>
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

use xso::{text::Base64, FromXml, IntoXml};

use crate::date::DateTime;
use crate::ns;
use crate::pubsub::PubSubPayload;

/// Data contained in the PubKey element
// TODO: Merge this container with the PubKey struct
#[derive(FromXml, IntoXml, PartialEq, Debug, Clone)]
#[xml(namespace = ns::OX, name = "data")]
pub struct PubKeyData {
    /// Base64 data
    #[xml(text = Base64)]
    pub data: Vec<u8>,
}

generate_element!(
    /// Pubkey element to be used in PubSub publish payloads.
    PubKey, "pubkey", OX,
    attributes: [
        /// Last updated date
        date: Option<DateTime> = "date"
    ],
    children: [
        /// Public key as base64 data
        data: Required<PubKeyData> = ("data", OX) => PubKeyData
    ]
);

impl PubSubPayload for PubKey {}

/// Public key metadata
#[derive(FromXml, IntoXml, PartialEq, Debug, Clone)]
#[xml(namespace = ns::OX, name = "pubkey-metadata")]
pub struct PubKeyMeta {
    /// OpenPGP v4 fingerprint
    #[xml(attribute = "v4-fingerprint")]
    pub v4fingerprint: String,

    /// Time the key was published or updated
    #[xml(attribute = "date")]
    pub date: DateTime,
}

generate_element!(
    /// List of public key metadata
    PubKeysMeta, "public-key-list", OX,
    children: [
        /// Public keys
        pubkeys: Vec<PubKeyMeta> = ("pubkey-metadata", OX) => PubKeyMeta
    ]
);

impl PubSubPayload for PubKeysMeta {}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ns;
    use crate::pubsub::{
        pubsub::{Item as PubSubItem, Publish},
        Item, NodeName,
    };
    use crate::Element;
    use std::str::FromStr;

    #[test]
    fn pubsub_publish_pubkey_data() {
        let pubkey = PubKey {
            date: None,
            data: PubKeyData {
                data: (&"Foo").as_bytes().to_vec(),
            },
        };
        println!("Foo1: {:?}", pubkey);

        let pubsub = Publish {
            node: NodeName(format!("{}:{}", ns::OX_PUBKEYS, "some-fingerprint")),
            items: vec![PubSubItem(Item::new(None, None, Some(pubkey)))],
        };
        println!("Foo2: {:?}", pubsub);
    }

    #[test]
    fn pubsub_publish_pubkey_meta() {
        let pubkeymeta = PubKeysMeta {
            pubkeys: vec![PubKeyMeta {
                v4fingerprint: "some-fingerprint".to_owned(),
                date: DateTime::from_str("2019-03-30T18:30:25Z").unwrap(),
            }],
        };
        println!("Foo1: {:?}", pubkeymeta);

        let pubsub = Publish {
            node: NodeName("foo".to_owned()),
            items: vec![PubSubItem(Item::new(None, None, Some(pubkeymeta)))],
        };
        println!("Foo2: {:?}", pubsub);
    }

    #[test]
    fn test_serialize_pubkey() {
        let reference: Element = "<pubkey xmlns='urn:xmpp:openpgp:0'><data>AAAA</data></pubkey>"
            .parse()
            .unwrap();

        let pubkey = PubKey {
            date: None,
            data: PubKeyData {
                data: b"\0\0\0".to_vec(),
            },
        };

        let serialized: Element = pubkey.into();
        assert_eq!(serialized, reference);
    }
}