rustdds 0.11.8

Native Rust DDS implementation with RTPS
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

use crate::security::cryptographic::cryptographic_builtin::*;
use super::key_material::*;

impl CryptoKeyExchange for CryptographicBuiltin {
  fn create_local_participant_crypto_tokens(
    &mut self,
    _local_participant_crypto_handle: ParticipantCryptoHandle,
    remote_participant_crypto_handle: ParticipantCryptoHandle,
  ) -> SecurityResult<Vec<ParticipantCryptoToken>> {
    //TODO: this is only a mock implementation (or is it?)
    self
      .get_receiver_specific_encode_key_materials(&remote_participant_crypto_handle)
      .cloned()
      // Convert to CryptoTokens
      .and_then(Vec::<DatawriterCryptoToken>::try_from)
  }

  fn set_remote_participant_crypto_tokens(
    &mut self,
    _local_participant_crypto_handle: ParticipantCryptoHandle,
    remote_participant_crypto_handle: ParticipantCryptoHandle,
    remote_participant_tokens: Vec<ParticipantCryptoToken>,
  ) -> SecurityResult<()> {
    //TODO: this is only a mock implementation (or is it?)
    KeyMaterial_AES_GCM_GMAC_seq::try_from(remote_participant_tokens).and_then(|key_materials| {
      self.insert_decode_key_materials(remote_participant_crypto_handle, key_materials)
    })
  }

  fn create_local_datawriter_crypto_tokens(
    &mut self,
    _local_datawriter_crypto_handle: DatawriterCryptoHandle,
    remote_datareader_crypto_handle: DatareaderCryptoHandle,
  ) -> SecurityResult<Vec<DatawriterCryptoToken>> {
    //TODO: this is only a mock implementation (or is it?)

    self
      .get_receiver_specific_encode_key_materials(&remote_datareader_crypto_handle)
      .cloned()
      // Convert to CryptoTokens
      .and_then(Vec::<DatawriterCryptoToken>::try_from)
  }

  fn set_remote_datawriter_crypto_tokens(
    &mut self,
    _local_datareader_crypto_handle: DatareaderCryptoHandle,
    remote_datawriter_crypto_handle: DatawriterCryptoHandle,
    remote_datawriter_tokens: Vec<DatawriterCryptoToken>,
  ) -> SecurityResult<()> {
    //TODO: this is only a mock implementation
    KeyMaterial_AES_GCM_GMAC_seq::try_from(remote_datawriter_tokens).and_then(|key_materials| {
      self.insert_decode_key_materials(remote_datawriter_crypto_handle, key_materials)
    })
  }

  fn create_local_datareader_crypto_tokens(
    &mut self,
    _local_datareader_crypto_handle: DatareaderCryptoHandle,
    remote_datawriter_crypto_handle: DatawriterCryptoHandle,
  ) -> SecurityResult<Vec<DatareaderCryptoToken>> {
    //TODO: this is only a mock implementation (or is it?)

    self
      .get_receiver_specific_encode_key_materials(&remote_datawriter_crypto_handle)
      .cloned()
      // Convert to CryptoTokens
      .and_then(Vec::<DatawriterCryptoToken>::try_from)
  }

  fn set_remote_datareader_crypto_tokens(
    &mut self,
    _local_datawriter_crypto_handle: DatawriterCryptoHandle,
    remote_datareader_crypto_handle: DatareaderCryptoHandle,
    remote_datareader_tokens: Vec<DatareaderCryptoToken>,
  ) -> SecurityResult<()> {
    //TODO: this is only a mock implementation
    KeyMaterial_AES_GCM_GMAC_seq::try_from(remote_datareader_tokens).and_then(|key_materials| {
      self.insert_decode_key_materials(remote_datareader_crypto_handle, key_materials)
    })
  }

  fn return_crypto_tokens(&mut self, _crypto_tokens: Vec<CryptoToken>) -> SecurityResult<()> {
    //TODO: this is only a mock implementation
    Ok(())
  }
}