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
|
/*
* Copyright (c) 2017-2022 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <core/facade.h>
#include <hicn/transport/auth/verifier.h>
#include <hicn/transport/core/content_object.h>
#include <protocols/rtc/rtc_state.h>
namespace transport {
namespace protocol {
namespace rtc {
class RTCVerifier {
public:
explicit RTCVerifier(std::shared_ptr<auth::Verifier> verifier,
uint32_t max_unverified_interval,
double max_unverified_ratio);
virtual ~RTCVerifier() = default;
void setState(std::shared_ptr<RTCState> rtc_state);
void setVerifier(std::shared_ptr<auth::Verifier> verifier);
void setMaxUnverifiedInterval(uint32_t max_unverified_interval);
void setMaxUnverifiedRatio(double max_unverified_ratio);
auth::VerificationPolicy verify(core::ContentObject &content_object,
bool is_fec = false);
auth::VerificationPolicy verifyProbe(core::ContentObject &content_object);
auth::VerificationPolicy verifyNack(core::ContentObject &content_object);
auth::VerificationPolicy verifyFec(core::ContentObject &content_object);
auth::VerificationPolicy verifyData(core::ContentObject &content_object);
auth::VerificationPolicy verifyManifest(core::ContentObject &content_object);
auth::VerificationPolicy processManifest(core::ContentObject &content_object);
void onDataRecoveredFec(uint32_t suffix);
void onJumpForward(uint32_t next_suffix);
double getBufferRatio() const;
protected:
struct Packet;
using Timestamp = uint64_t;
using PacketSet = std::set<Packet>;
struct Packet {
auth::Suffix suffix;
Timestamp timestamp;
size_t size;
bool operator==(const Packet &b) const {
return timestamp == b.timestamp && suffix == b.suffix;
}
bool operator<(const Packet &b) const {
return timestamp == b.timestamp ? suffix < b.suffix
: timestamp < b.timestamp;
}
};
class Packets {
public:
virtual std::pair<PacketSet::iterator, bool> add(const Packet &packet);
virtual PacketSet::iterator remove(PacketSet::iterator packet_it);
const PacketSet &set() const;
size_t size() const;
protected:
PacketSet packets_;
size_t size_;
};
class PacketsVerif : public Packets {};
class PacketsUnverif : public Packets {
public:
using Packets::add;
std::pair<PacketSet::iterator, bool> add(const Packet &packet,
const auth::CryptoHash &digest);
PacketSet::iterator remove(PacketSet::iterator packet_it) override;
PacketSet::iterator packetIt(auth::Suffix suffix);
const auth::Verifier::SuffixMap &suffixMap() const;
private:
std::unordered_map<auth::Suffix, PacketSet::iterator> packets_map_;
auth::Verifier::SuffixMap digests_map_;
};
// The RTC state.
std::shared_ptr<RTCState> rtc_state_;
// The verifier instance.
std::shared_ptr<auth::Verifier> verifier_;
// Window to consider when verifying packets.
uint32_t max_unverified_interval_;
// Ratio of unverified packets over which an alert is triggered.
double max_unverified_ratio_;
// The suffix of the last processed manifest.
auth::Suffix last_manifest_;
// Hash algorithm used by manifests.
auth::CryptoHashType manifest_hash_algo_;
// Digests extracted from all manifests received.
auth::Verifier::SuffixMap manifest_digests_;
// Verified packets with timestamp >= now - max_unverified_interval_.
PacketsVerif packets_verif_;
// Unverified packets with timestamp >= now - max_unverified_interval_.
PacketsUnverif packets_unverif_;
// Unverified erased packets with timestamp < now - max_unverified_interval_.
std::unordered_set<auth::Suffix> packets_unverif_erased_;
// Flushes all packets with timestamp < now - max_unverified_interval_.
// Returns the timestamp of the oldest packet, verified or not.
Timestamp flush_packets(Timestamp now);
};
} // namespace rtc
} // namespace protocol
} // namespace transport
|
