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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
/*
* Copyright (c) 2021-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 <hicn/transport/auth/crypto_hash.h>
#include <hicn/transport/auth/crypto_suite.h>
#include <hicn/transport/auth/key_id.h>
#include <hicn/transport/core/name.h>
#include <hicn/transport/core/payload_type.h>
#include <hicn/transport/errors/malformed_packet_exception.h>
#include <hicn/transport/portability/portability.h>
#include <hicn/transport/utils/branch_prediction.h>
#include <hicn/transport/utils/membuf.h>
#include <hicn/transport/utils/object_pool.h>
extern "C" {
#ifndef _WIN32
TRANSPORT_CLANG_DISABLE_WARNING("-Wextern-c-compat")
#endif
#include <hicn/packet.h>
}
namespace transport {
namespace auth {
class Signer;
class Verifier;
} // namespace auth
namespace core {
/*
* Basic IP packet, modelled as circular chain of buffers:
* Header = H
* Payload = P
*
* H_0 --> H_1 --> H_2 --> P_0 --> P_1 --> P_2
* \_______________________________________|
*/
class Packet : public utils::MemBuf,
public std::enable_shared_from_this<Packet> {
friend class auth::Signer;
friend class auth::Verifier;
public:
using Ptr = std::shared_ptr<Packet>;
using MemBufPtr = std::shared_ptr<utils::MemBuf>;
using Format = hicn_packet_format_t;
using Type = hicn_packet_type_t;
static constexpr size_t default_mtu = 1500;
/**
* Create new IP packet. Here we allocate just the header,
* the eventual payload will be added by prepending the payload buffer
* to the buffer chain whose the fist buffer is the header itself.
*/
Packet(Type type, Format format, std::size_t additional_header_size = 0);
/* Copy buffer */
Packet(CopyBufferOp, const uint8_t *buffer, std::size_t size);
/* Wrap buffer */
Packet(WrapBufferOp, uint8_t *buffer, std::size_t length, std::size_t size);
/* Create new using pre-allocated buffer */
Packet(CreateOp, Type type, uint8_t *buffer, std::size_t length,
std::size_t size, Format format,
std::size_t additional_header_size = 0);
Packet(MemBuf &&buffer);
Packet(Packet &&other);
Packet(const Packet &other);
// Destructor
virtual ~Packet();
// Operators
Packet &operator=(const Packet &other);
friend bool operator==(const Packet &l_packet, const Packet &r_packet);
// Cast to MemBuf
std::shared_ptr<utils::MemBuf> acquireMemBufReference();
// Format
Format getFormat() const;
void setFormat(Packet::Format format);
void initialize(std::size_t additional_header_size = 0);
void analyze();
void initializeType(Packet::Type type);
hicn_packet_type_t getType() const;
void setType(Packet::Type type);
void setBuffer();
// Name
virtual const Name &getName() const = 0;
virtual Name &getWritableName() = 0;
virtual void setName(const Name &name) = 0;
// Lifetime
virtual void setLifetime(uint32_t lifetime) = 0;
virtual uint32_t getLifetime() const = 0;
// Locator
virtual void setLocator(const hicn_ip_address_t &locator) = 0;
virtual hicn_ip_address_t getLocator() const = 0;
// Payload type
PayloadType getPayloadType() const;
Packet &setPayloadType(PayloadType payload_type);
// Payload
std::unique_ptr<utils::MemBuf> getPayload() const;
Packet &appendPayload(std::unique_ptr<utils::MemBuf> &&payload);
Packet &appendPayload(const uint8_t *buffer, std::size_t length);
// Sizes
std::size_t headerSize() const;
std::size_t payloadSize() const;
// Digest
auth::CryptoHash computeDigest(auth::CryptoHashType algorithm) const;
bool isInterest();
// Reset packet
void reset();
// Utils
Packet &updateLength(std::size_t length = 0);
void dump() const;
// TCP methods
void setChecksum();
bool checkIntegrity() const;
// Authentication Header methods
bool hasAH() const;
utils::MemBuf::Ptr getSignature() const;
std::size_t getSignatureFieldSize() const;
std::size_t getSignatureSize() const;
uint64_t getSignatureTimestamp() const;
auth::KeyId getKeyId() const;
auth::CryptoSuite getValidationAlgorithm() const;
void setSignature(const utils::MemBuf::Ptr &signature);
void setSignatureFieldSize(std::size_t size);
void setSignatureSize(std::size_t size);
void setSignatureTimestamp(const uint64_t ×tamp_ms);
void setKeyId(const auth::KeyId &key_id);
void setValidationAlgorithm(const auth::CryptoSuite &algo);
void saveHeader(u8 *header, size_t *header_len);
void loadHeader(u8 *header, size_t header_len);
// Static methods
static Format toAHFormat(const Format &format);
static Format getFormatFromBuffer(const uint8_t *buffer, std::size_t length);
static std::size_t getHeaderSizeFromFormat(Format format,
std::size_t signature_size = 0);
static std::size_t getHeaderSizeFromBuffer(const uint8_t *buffer,
size_t length);
static std::size_t getPayloadSizeFromBuffer(const uint8_t *buffer,
size_t length);
static void dump(uint8_t *buffer, std::size_t length);
private:
virtual void resetForHash() = 0;
void prependPayload(const uint8_t **buffer, std::size_t *size);
protected:
hicn_packet_buffer_t pkbuf_;
Name name_;
mutable PayloadType payload_type_;
static const core::Name base_name;
};
} // end namespace core
} // end namespace transport
|
