diff options
Diffstat (limited to 'libtransport')
65 files changed, 578 insertions, 634 deletions
diff --git a/libtransport/src/hicn/transport/core/CMakeLists.txt b/libtransport/src/hicn/transport/core/CMakeLists.txt index c8dea8328..a97e74b2a 100755 --- a/libtransport/src/hicn/transport/core/CMakeLists.txt +++ b/libtransport/src/hicn/transport/core/CMakeLists.txt @@ -17,8 +17,6 @@ list(APPEND HEADER_FILES ${CMAKE_CURRENT_SOURCE_DIR}/content_object.h ${CMAKE_CURRENT_SOURCE_DIR}/facade.h ${CMAKE_CURRENT_SOURCE_DIR}/interest.h - ${CMAKE_CURRENT_SOURCE_DIR}/key_locator.h - ${CMAKE_CURRENT_SOURCE_DIR}/key_locator_type.h ${CMAKE_CURRENT_SOURCE_DIR}/socket_connector.h ${CMAKE_CURRENT_SOURCE_DIR}/manifest.h ${CMAKE_CURRENT_SOURCE_DIR}/manifest_inline.h @@ -41,7 +39,6 @@ list(APPEND HEADER_FILES list(APPEND SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/content_object.cc ${CMAKE_CURRENT_SOURCE_DIR}/interest.cc - ${CMAKE_CURRENT_SOURCE_DIR}/key_locator.cc ${CMAKE_CURRENT_SOURCE_DIR}/socket_connector.cc ${CMAKE_CURRENT_SOURCE_DIR}/pending_interest.cc ${CMAKE_CURRENT_SOURCE_DIR}/packet.cc diff --git a/libtransport/src/hicn/transport/core/connector.cc b/libtransport/src/hicn/transport/core/connector.cc index ff567d78a..ff567d78a 100755..100644 --- a/libtransport/src/hicn/transport/core/connector.cc +++ b/libtransport/src/hicn/transport/core/connector.cc diff --git a/libtransport/src/hicn/transport/core/connector.h b/libtransport/src/hicn/transport/core/connector.h index 14201879c..c5250486c 100755..100644 --- a/libtransport/src/hicn/transport/core/connector.h +++ b/libtransport/src/hicn/transport/core/connector.h @@ -33,7 +33,7 @@ enum class ConnectorType : uint8_t { VPP_CONNECTOR, }; -static constexpr std::size_t packet_size = 2000; +static constexpr std::size_t packet_size = 2048; static constexpr std::size_t queue_size = 4096; static constexpr std::size_t packet_pool_size = 4096; @@ -72,6 +72,10 @@ class Connector { result = packet_pool_.get(); } + if (result.second->isChained()) { + result.second->separateChain(result.second->next(), + result.second->prev()); + } result.second->clear(); return std::move(result.second); } diff --git a/libtransport/src/hicn/transport/core/content_object.cc b/libtransport/src/hicn/transport/core/content_object.cc index dc2056582..dc2056582 100755..100644 --- a/libtransport/src/hicn/transport/core/content_object.cc +++ b/libtransport/src/hicn/transport/core/content_object.cc diff --git a/libtransport/src/hicn/transport/core/content_object.h b/libtransport/src/hicn/transport/core/content_object.h index c85259f20..c85259f20 100755..100644 --- a/libtransport/src/hicn/transport/core/content_object.h +++ b/libtransport/src/hicn/transport/core/content_object.h diff --git a/libtransport/src/hicn/transport/core/facade.h b/libtransport/src/hicn/transport/core/facade.h index c28c84671..c28c84671 100755..100644 --- a/libtransport/src/hicn/transport/core/facade.h +++ b/libtransport/src/hicn/transport/core/facade.h diff --git a/libtransport/src/hicn/transport/core/forwarder_interface.h b/libtransport/src/hicn/transport/core/forwarder_interface.h index e7b6fb1a6..e7b6fb1a6 100755..100644 --- a/libtransport/src/hicn/transport/core/forwarder_interface.h +++ b/libtransport/src/hicn/transport/core/forwarder_interface.h diff --git a/libtransport/src/hicn/transport/core/hicn_binary_api.c b/libtransport/src/hicn/transport/core/hicn_binary_api.c index c49cb5c88..d909578a2 100755..100644 --- a/libtransport/src/hicn/transport/core/hicn_binary_api.c +++ b/libtransport/src/hicn/transport/core/hicn_binary_api.c @@ -19,11 +19,12 @@ #include <hicn/transport/core/hicn_binary_api.h> #include <hicn/transport/core/vpp_binary_api_internal.h> - -#include <hicn/transport/core/hicn_binary_api.h> -#include <hicn/transport/core/vpp_binary_api_internal.h> #include <hicn/transport/utils/log.h> +#define HICN_VPP_PLUGIN +#include <hicn/name.h> +#undef HICN_VPP_PLUGIN + #include <fcntl.h> #include <inttypes.h> #include <semaphore.h> @@ -66,21 +67,9 @@ const char *HICN_ERROR_STRING[] = { }; ///////////////////////////////////////////////////// -#define POINTER_MAP_SIZE 32 -static void *global_pointers_map[POINTER_MAP_SIZE]; -static uint8_t global_pointers_map_index = 0; - -#define CONTEXT_SAVE(pointer, mp) \ - do { \ - global_pointers_map[global_pointers_map_index] = pointer; \ - mp->context = global_pointers_map_index++; \ - global_pointers_map_index %= POINTER_MAP_SIZE; \ - } while (0); - -#define CONTEXT_GET(mp, pointer) \ - do { \ - pointer = global_pointers_map[mp->context]; \ - } while (0); +static context_store_t context_store = { + .global_pointers_map_index = 0, +}; /* * Table of message reply handlers, must include boilerplate handlers @@ -96,22 +85,19 @@ int hicn_binary_api_register_prod_app( hicn_producer_output_params *output_params) { vl_api_hicn_api_register_prod_app_t *mp; vpp_plugin_binary_api_t *hm = api; - api->vpp_api->user_param = output_params; + vpp_binary_api_set_user_param(api->vpp_api, output_params); /* Construct the API message */ M(HICN_API_REGISTER_PROD_APP, mp); - CONTEXT_SAVE(api, mp) + CONTEXT_SAVE(context_store, api, mp) - mp->len = (u8)input_params->prefix.prefix_length; + mp->len = (u8)input_params->prefix->prefix_len; mp->swif = clib_host_to_net_u32(input_params->swif); mp->cs_reserved = clib_host_to_net_u32(input_params->cs_reserved); - mp->prefix[0] = clib_host_to_net_u64(input_params->prefix.ip6.as_u64[0]); - mp->prefix[1] = clib_host_to_net_u64(input_params->prefix.ip6.as_u64[1]); - - TRANSPORT_LOGI("Prefix length: %u", mp->len); - TRANSPORT_LOGI("Memif ID: %u", mp->swif); + mp->prefix[0] = clib_host_to_net_u64(input_params->prefix->as_u64[0]); + mp->prefix[1] = clib_host_to_net_u64(input_params->prefix->as_u64[1]); return vpp_binary_api_send_request_wait_reply(api->vpp_api, mp); } @@ -119,17 +105,17 @@ int hicn_binary_api_register_prod_app( static void vl_api_hicn_api_register_prod_app_reply_t_handler( vl_api_hicn_api_register_prod_app_reply_t *mp) { vpp_plugin_binary_api_t *binary_api; - CONTEXT_GET(mp, binary_api); - hicn_producer_output_params *params = binary_api->vpp_api->user_param; + CONTEXT_GET(context_store, mp, binary_api); + hicn_producer_output_params *params = + vpp_binary_api_get_user_param(binary_api->vpp_api); - binary_api->vpp_api->ret_val = clib_net_to_host_u32(mp->retval); + vpp_binary_api_set_ret_value(binary_api->vpp_api, + clib_net_to_host_u32(mp->retval)); params->cs_reserved = mp->cs_reserved; - params->prod_addr.ip6.as_u64[0] = mp->prod_addr[0]; - params->prod_addr.ip6.as_u64[1] = mp->prod_addr[1]; + params->prod_addr->as_u64[0] = mp->prod_addr[0]; + params->prod_addr->as_u64[1] = mp->prod_addr[1]; params->face_id = clib_net_to_host_u32(mp->faceid); - TRANSPORT_LOGI("ret :%s", get_error_string(binary_api->vpp_api->ret_val)); - vpp_binary_api_unlock_waiting_thread(binary_api->vpp_api); } @@ -139,14 +125,14 @@ int hicn_binary_api_register_cons_app( vl_api_hicn_api_register_cons_app_t *mp; vpp_plugin_binary_api_t *hm = api; - hm->vpp_api->user_param = output_params; + vpp_binary_api_set_user_param(hm->vpp_api, output_params); /* Construct the API message */ M(HICN_API_REGISTER_CONS_APP, mp); mp->swif = clib_host_to_net_u32(input_params->swif); - CONTEXT_SAVE(api, mp) + CONTEXT_SAVE(context_store, api, mp) TRANSPORT_LOGI("Message created"); @@ -156,14 +142,16 @@ int hicn_binary_api_register_cons_app( static void vl_api_hicn_api_register_cons_app_reply_t_handler( vl_api_hicn_api_register_cons_app_reply_t *mp) { vpp_plugin_binary_api_t *binary_api; - CONTEXT_GET(mp, binary_api); - hicn_consumer_output_params *params = binary_api->vpp_api->user_param; + CONTEXT_GET(context_store, mp, binary_api); + hicn_consumer_output_params *params = + vpp_binary_api_get_user_param(binary_api->vpp_api); - binary_api->vpp_api->ret_val = clib_net_to_host_u32(mp->retval); + vpp_binary_api_set_ret_value(binary_api->vpp_api, + clib_net_to_host_u32(mp->retval)); - params->src4.ip4.as_u32 = clib_net_to_host_u32(mp->src_addr4); - params->src6.ip6.as_u64[0] = clib_net_to_host_u64(mp->src_addr6[0]); - params->src6.ip6.as_u64[1] = clib_net_to_host_u64(mp->src_addr6[1]); + params->src4->as_ip46.ip4.as_u32 = clib_net_to_host_u32(mp->src_addr4); + params->src6->as_u64[0] = clib_net_to_host_u64(mp->src_addr6[0]); + params->src6->as_u64[1] = clib_net_to_host_u64(mp->src_addr6[1]); params->face_id = clib_host_to_net_u32(mp->faceid); vpp_binary_api_unlock_waiting_thread(binary_api->vpp_api); @@ -178,11 +166,11 @@ int hicn_binary_api_register_route( /* Construct the API message */ M(HICN_API_ROUTE_NHOPS_ADD, mp); - CONTEXT_SAVE(api, mp) + CONTEXT_SAVE(context_store, api, mp) - mp->prefix[0] = input_params->prefix.ip6.as_u64[0]; - mp->prefix[1] = input_params->prefix.ip6.as_u64[1]; - mp->len = input_params->prefix.prefix_length; + mp->prefix[0] = input_params->prefix->as_u64[0]; + mp->prefix[1] = input_params->prefix->as_u64[1]; + mp->len = input_params->prefix->prefix_len; mp->face_ids[0] = input_params->face_id; mp->n_faces = 1; @@ -192,9 +180,10 @@ int hicn_binary_api_register_route( static void vl_api_hicn_api_route_nhops_add_reply_t_handler( vl_api_hicn_api_route_nhops_add_reply_t *mp) { vpp_plugin_binary_api_t *binary_api; - CONTEXT_GET(mp, binary_api); + CONTEXT_GET(context_store, mp, binary_api); - binary_api->vpp_api->ret_val = clib_net_to_host_u32(mp->retval); + vpp_binary_api_set_ret_value(binary_api->vpp_api, + clib_net_to_host_u32(mp->retval)); vpp_binary_api_unlock_waiting_thread(binary_api->vpp_api); } @@ -220,7 +209,7 @@ vpp_plugin_binary_api_t *hicn_binary_api_init(vpp_binary_api_t *api) { u8 *name = format(0, "hicn_%08x%c", api_version, 0); ret->msg_id_base = vl_client_get_first_plugin_msg_id((char *)name); ret->vpp_api = api; - ret->my_client_index = api->my_client_index; + ret->my_client_index = vpp_binary_api_get_client_index(api); hicn_binary_api_setup_handlers(ret); return ret; } diff --git a/libtransport/src/hicn/transport/core/hicn_binary_api.h b/libtransport/src/hicn/transport/core/hicn_binary_api.h index 752844153..410ffb96c 100755..100644 --- a/libtransport/src/hicn/transport/core/hicn_binary_api.h +++ b/libtransport/src/hicn/transport/core/hicn_binary_api.h @@ -27,35 +27,10 @@ extern "C" { #include "stdint.h" -typedef union { - uint8_t data[4]; - uint32_t data_u32; - /* Aliases. */ - uint8_t as_u8[4]; - uint16_t as_u16[2]; - uint32_t as_u32; -} ip4_address; - -typedef union { - uint8_t as_u8[16]; - uint16_t as_u16[8]; - uint32_t as_u32[4]; - uint64_t as_u64[2]; -} ip6_address; - -typedef enum { IP_TYPE_ANY, IP_TYPE_IP4, IP_TYPE_IP6 } ip46_type; +typedef struct ip_address ip_address_t; typedef struct { - ip46_type type; - uint8_t prefix_length; - union { - ip4_address ip4; - ip6_address ip6; - }; -} ip46_address; - -typedef struct { - ip46_address prefix; + ip_address_t* prefix; uint32_t swif; uint32_t cs_reserved; } hicn_producer_input_params; @@ -66,18 +41,18 @@ typedef struct { typedef struct { uint32_t cs_reserved; - ip46_address prod_addr; + ip_address_t* prod_addr; uint32_t face_id; } hicn_producer_output_params; typedef struct { - ip46_address src4; - ip46_address src6; + ip_address_t* src4; + ip_address_t* src6; uint32_t face_id; } hicn_consumer_output_params; typedef struct { - ip46_address prefix; + ip_address_t* prefix; uint32_t face_id; } hicn_producer_set_route_params; diff --git a/libtransport/src/hicn/transport/core/hicn_forwarder_interface.cc b/libtransport/src/hicn/transport/core/hicn_forwarder_interface.cc index 03a294957..1d82ff0b0 100755..100644 --- a/libtransport/src/hicn/transport/core/hicn_forwarder_interface.cc +++ b/libtransport/src/hicn/transport/core/hicn_forwarder_interface.cc @@ -15,6 +15,7 @@ #include <hicn/transport/core/hicn_forwarder_interface.h> + #define ADDR_INET 1 #define ADDR_INET6 2 #define ADD_ROUTE 3 @@ -73,7 +74,6 @@ void HicnForwarderInterface::registerRoute(Prefix &prefix) { route_to_self->command_id = ADD_ROUTE; route_to_self->message_type = REQUEST_LIGHT; route_to_self->length = 1; - // route_to_self->seq_num not needed for now send((uint8_t *)route_to_self, sizeof(RouteToSelfCommand), [route_to_self]() { delete route_to_self; }); diff --git a/libtransport/src/hicn/transport/core/hicn_forwarder_interface.h b/libtransport/src/hicn/transport/core/hicn_forwarder_interface.h index e57fae105..e57fae105 100755..100644 --- a/libtransport/src/hicn/transport/core/hicn_forwarder_interface.h +++ b/libtransport/src/hicn/transport/core/hicn_forwarder_interface.h diff --git a/libtransport/src/hicn/transport/core/hicn_memif_api.c b/libtransport/src/hicn/transport/core/hicn_memif_api.c deleted file mode 100755 index e69de29bb..000000000 --- a/libtransport/src/hicn/transport/core/hicn_memif_api.c +++ /dev/null diff --git a/libtransport/src/hicn/transport/core/interest.cc b/libtransport/src/hicn/transport/core/interest.cc index ff4a5bb34..ff4a5bb34 100755..100644 --- a/libtransport/src/hicn/transport/core/interest.cc +++ b/libtransport/src/hicn/transport/core/interest.cc diff --git a/libtransport/src/hicn/transport/core/interest.h b/libtransport/src/hicn/transport/core/interest.h index 75fcba8eb..75fcba8eb 100755..100644 --- a/libtransport/src/hicn/transport/core/interest.h +++ b/libtransport/src/hicn/transport/core/interest.h diff --git a/libtransport/src/hicn/transport/core/key_locator.cc b/libtransport/src/hicn/transport/core/key_locator.cc deleted file mode 100755 index 509fc35ff..000000000 --- a/libtransport/src/hicn/transport/core/key_locator.cc +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright (c) 2017-2019 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. - */ - -#include <hicn/transport/core/key_locator.h> - -namespace transport { - -namespace core { - -KeyLocator::KeyLocator() : type_(KeyLocatorType::UNKNOWN) {} - -KeyLocator::KeyLocator(KeyLocatorType type, Name &name) - : type_(type), name_(name) {} - -Name &KeyLocator::getName() { return name_; } - -void KeyLocator::setName(Name &name) { name_ = name; } - -void KeyLocator::setType(KeyLocatorType type) { type_ = type; } - -KeyLocatorType KeyLocator::getType() { return type_; } - -void KeyLocator::clear() { - type_ = KeyLocatorType::UNKNOWN; - name_.clear(); -} - -} // end namespace core - -} // end namespace transport
\ No newline at end of file diff --git a/libtransport/src/hicn/transport/core/key_locator.h b/libtransport/src/hicn/transport/core/key_locator.h deleted file mode 100755 index ae3a4ab08..000000000 --- a/libtransport/src/hicn/transport/core/key_locator.h +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright (c) 2017-2019 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/core/key_locator_type.h> -#include <hicn/transport/core/name.h> - -namespace transport { - -namespace core { - -class KeyLocator : public std::enable_shared_from_this<KeyLocator> { - public: - KeyLocator(); - - KeyLocator(KeyLocatorType type, Name &name); - - KeyLocatorType getType(); - - void setType(KeyLocatorType type); - - void setName(Name &name); - - Name &getName(); - - void clear(); - - private: - KeyLocatorType type_; - Name name_; -}; - -} // end namespace core - -} // end namespace transport diff --git a/libtransport/src/hicn/transport/core/key_locator_type.h b/libtransport/src/hicn/transport/core/key_locator_type.h deleted file mode 100755 index 0c84a43ca..000000000 --- a/libtransport/src/hicn/transport/core/key_locator_type.h +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Copyright (c) 2017-2019 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 - -namespace transport { - -namespace core { - -enum Type { NAME = 0, KEY_DIGEST = 1, UNKNOWN = 255 }; - -typedef enum Type KeyLocatorType; - -} // end namespace core - -} // end namespace transport diff --git a/libtransport/src/hicn/transport/core/manifest.cc b/libtransport/src/hicn/transport/core/manifest.cc index 3f890f3d0..3f890f3d0 100755..100644 --- a/libtransport/src/hicn/transport/core/manifest.cc +++ b/libtransport/src/hicn/transport/core/manifest.cc diff --git a/libtransport/src/hicn/transport/core/manifest.h b/libtransport/src/hicn/transport/core/manifest.h index 767addb2e..558a96804 100755..100644 --- a/libtransport/src/hicn/transport/core/manifest.h +++ b/libtransport/src/hicn/transport/core/manifest.h @@ -45,21 +45,21 @@ class Manifest : public Base { Base::setPayloadType(PayloadType::MANIFEST); } - Manifest(const core::Name& name) + Manifest(const core::Name &name) : packet_(new Base(name, HF_INET6_TCP_AH), nullptr), encoder_(*packet_), decoder_(*packet_) { Base::setPayloadType(PayloadType::MANIFEST); } - Manifest(typename Base::Ptr&& base) + Manifest(typename Base::Ptr &&base) : packet_(std::move(base)), encoder_(*packet_), decoder_(*packet_) { Base::setPayloadType(PayloadType::MANIFEST); } template <typename T> - Manifest(T&& base) - : packet_(new Base(std::move<T&&>(base)), nullptr), + Manifest(T &&base) + : packet_(new Base(std::move<T &&>(base)), nullptr), encoder_(*packet_), decoder_(*packet_) { Base::setPayloadType(PayloadType::MANIFEST); @@ -67,12 +67,12 @@ class Manifest : public Base { virtual ~Manifest() = default; - bool operator==(const Manifest& other) { + bool operator==(const Manifest &other) { return this->packet_ == other.packet_; } std::size_t estimateManifestSize(std::size_t additional_entries = 0) { - return static_cast<ManifestImpl&>(*this).estimateManifestSizeImpl( + return static_cast<ManifestImpl &>(*this).estimateManifestSizeImpl( additional_entries); } @@ -80,29 +80,29 @@ class Manifest : public Base { * After the call to encode, users MUST call clear before adding data * to the manifest. */ - Manifest& encode() { return static_cast<ManifestImpl&>(*this).encodeImpl(); } + Manifest &encode() { return static_cast<ManifestImpl &>(*this).encodeImpl(); } - Manifest& decode() { + Manifest &decode() { Manifest::decoder_.decode(); manifest_type_ = decoder_.getManifestType(); hash_algorithm_ = decoder_.getHashAlgorithm(); is_last_ = decoder_.getIsFinalManifest(); - return static_cast<ManifestImpl&>(*this).decodeImpl(); + return static_cast<ManifestImpl &>(*this).decodeImpl(); } static std::size_t getManifestHeaderSize() { return Encoder::getManifestHeaderSize(); } - Manifest& setManifestType(ManifestType type) { + Manifest &setManifestType(ManifestType type) { manifest_type_ = type; encoder_.setManifestType(manifest_type_); return *this; } - Manifest& setHashAlgorithm(HashAlgorithm hash_algorithm) { + Manifest &setHashAlgorithm(HashAlgorithm hash_algorithm) { hash_algorithm_ = hash_algorithm; encoder_.setHashAlgorithm(hash_algorithm_); return *this; @@ -114,12 +114,12 @@ class Manifest : public Base { bool isFinalManifest() const { return is_last_; } - Manifest& setVersion(ManifestVersion version) { + Manifest &setVersion(ManifestVersion version) { encoder_.setVersion(version); return *this; } - Manifest& setFinalBlockNumber(std::uint32_t final_block_number) { + Manifest &setFinalBlockNumber(std::uint32_t final_block_number) { encoder_.setFinalBlockNumber(final_block_number); return *this; } @@ -130,13 +130,13 @@ class Manifest : public Base { ManifestVersion getVersion() const { return decoder_.getVersion(); } - Manifest& setFinalManifest(bool is_final_manifest) { + Manifest &setFinalManifest(bool is_final_manifest) { encoder_.setIsFinalManifest(is_final_manifest); is_last_ = is_final_manifest; return *this; } - Manifest& clear() { + Manifest &clear() { encoder_.clear(); decoder_.clear(); return *this; @@ -147,7 +147,7 @@ class Manifest : public Base { encoder_.update(); } - typename Base::Ptr&& getPacket() { return std::move(packet_); } + typename Base::Ptr &&getPacket() { return std::move(packet_); } protected: typename Base::Ptr packet_; diff --git a/libtransport/src/hicn/transport/core/manifest_format.h b/libtransport/src/hicn/transport/core/manifest_format.h index 1dcf013dc..00782f14d 100755..100644 --- a/libtransport/src/hicn/transport/core/manifest_format.h +++ b/libtransport/src/hicn/transport/core/manifest_format.h @@ -71,28 +71,28 @@ class ManifestEncoder { virtual ~ManifestEncoder() = default; ManifestEncoder encode() { - return static_cast<Implementation&>(*this).encodeImpl(); + return static_cast<Implementation &>(*this).encodeImpl(); } - ManifestEncoder& clear() { - return static_cast<Implementation&>(*this).clearImpl(); + ManifestEncoder &clear() { + return static_cast<Implementation &>(*this).clearImpl(); } - ManifestEncoder& setManifestType(ManifestType type) { - return static_cast<Implementation&>(*this).setManifestTypeImpl(type); + ManifestEncoder &setManifestType(ManifestType type) { + return static_cast<Implementation &>(*this).setManifestTypeImpl(type); } - ManifestEncoder& setHashAlgorithm(HashAlgorithm hash) { - return static_cast<Implementation&>(*this).setHashAlgorithmImpl(hash); + ManifestEncoder &setHashAlgorithm(HashAlgorithm hash) { + return static_cast<Implementation &>(*this).setHashAlgorithmImpl(hash); } - ManifestEncoder& setFinalChunkNumber(uint32_t final_chunk) { - return static_cast<Implementation&>(*this).setFinalChunkImpl(final_chunk); + ManifestEncoder &setFinalChunkNumber(uint32_t final_chunk) { + return static_cast<Implementation &>(*this).setFinalChunkImpl(final_chunk); } - ManifestEncoder& setNextSegmentCalculationStrategy( + ManifestEncoder &setNextSegmentCalculationStrategy( NextSegmentCalculationStrategy strategy) { - return static_cast<Implementation&>(*this) + return static_cast<Implementation &>(*this) .setNextSegmentCalculationStrategyImpl(strategy); } @@ -100,35 +100,35 @@ class ManifestEncoder { typename T, typename = std::enable_if_t<std::is_same< std::remove_const_t<std::remove_reference_t<T>>, core::Name>::value>> - ManifestEncoder& setBaseName(T&& name) { - return static_cast<Implementation&>(*this).setBaseNameImpl(name); + ManifestEncoder &setBaseName(T &&name) { + return static_cast<Implementation &>(*this).setBaseNameImpl(name); } template <typename Hash> - ManifestEncoder& addSuffixAndHash(uint32_t suffix, Hash&& hash) { - return static_cast<Implementation&>(*this).addSuffixAndHashImpl( - suffix, std::forward<Hash&&>(hash)); + ManifestEncoder &addSuffixAndHash(uint32_t suffix, Hash &&hash) { + return static_cast<Implementation &>(*this).addSuffixAndHashImpl( + suffix, std::forward<Hash &&>(hash)); } - ManifestEncoder& setIsFinalManifest(bool is_last) { - return static_cast<Implementation&>(*this).setIsFinalManifestImpl(is_last); + ManifestEncoder &setIsFinalManifest(bool is_last) { + return static_cast<Implementation &>(*this).setIsFinalManifestImpl(is_last); } - ManifestEncoder& setVersion(ManifestVersion version) { - return static_cast<Implementation&>(*this).setVersionImpl(version); + ManifestEncoder &setVersion(ManifestVersion version) { + return static_cast<Implementation &>(*this).setVersionImpl(version); } std::size_t estimateSerializedLength(std::size_t number_of_entries) { - return static_cast<Implementation&>(*this).estimateSerializedLengthImpl( + return static_cast<Implementation &>(*this).estimateSerializedLengthImpl( number_of_entries); } - ManifestEncoder& update() { - return static_cast<Implementation&>(*this).updateImpl(); + ManifestEncoder &update() { + return static_cast<Implementation &>(*this).updateImpl(); } - ManifestEncoder& setFinalBlockNumber(std::uint32_t final_block_number) { - return static_cast<Implementation&>(*this).setFinalBlockNumberImpl( + ManifestEncoder &setFinalBlockNumber(std::uint32_t final_block_number) { + return static_cast<Implementation &>(*this).setFinalBlockNumberImpl( final_block_number); } @@ -142,52 +142,52 @@ class ManifestDecoder { public: virtual ~ManifestDecoder() = default; - ManifestDecoder& clear() { - return static_cast<Implementation&>(*this).clearImpl(); + ManifestDecoder &clear() { + return static_cast<Implementation &>(*this).clearImpl(); } - void decode() { static_cast<Implementation&>(*this).decodeImpl(); } + void decode() { static_cast<Implementation &>(*this).decodeImpl(); } ManifestType getManifestType() const { - return static_cast<const Implementation&>(*this).getManifestTypeImpl(); + return static_cast<const Implementation &>(*this).getManifestTypeImpl(); } HashAlgorithm getHashAlgorithm() const { - return static_cast<const Implementation&>(*this).getHashAlgorithmImpl(); + return static_cast<const Implementation &>(*this).getHashAlgorithmImpl(); } uint32_t getFinalChunkNumber() const { - return static_cast<const Implementation&>(*this).getFinalChunkImpl(); + return static_cast<const Implementation &>(*this).getFinalChunkImpl(); } NextSegmentCalculationStrategy getNextSegmentCalculationStrategy() const { - return static_cast<const Implementation&>(*this) + return static_cast<const Implementation &>(*this) .getNextSegmentCalculationStrategyImpl(); } core::Name getBaseName() const { - return static_cast<const Implementation&>(*this).getBaseNameImpl(); + return static_cast<const Implementation &>(*this).getBaseNameImpl(); } auto getSuffixHashList() { - return static_cast<Implementation&>(*this).getSuffixHashListImpl(); + return static_cast<Implementation &>(*this).getSuffixHashListImpl(); } bool getIsFinalManifest() const { - return static_cast<const Implementation&>(*this).getIsFinalManifestImpl(); + return static_cast<const Implementation &>(*this).getIsFinalManifestImpl(); } ManifestVersion getVersion() const { - return static_cast<const Implementation&>(*this).getVersionImpl(); + return static_cast<const Implementation &>(*this).getVersionImpl(); } std::size_t estimateSerializedLength(std::size_t number_of_entries) const { - return static_cast<const Implementation&>(*this) + return static_cast<const Implementation &>(*this) .estimateSerializedLengthImpl(number_of_entries); } uint32_t getFinalBlockNumber() const { - return static_cast<const Implementation&>(*this).getFinalBlockNumberImpl(); + return static_cast<const Implementation &>(*this).getFinalBlockNumberImpl(); } }; diff --git a/libtransport/src/hicn/transport/core/manifest_format_fixed.cc b/libtransport/src/hicn/transport/core/manifest_format_fixed.cc index f26f20adb..6141ae311 100755..100644 --- a/libtransport/src/hicn/transport/core/manifest_format_fixed.cc +++ b/libtransport/src/hicn/transport/core/manifest_format_fixed.cc @@ -23,72 +23,72 @@ namespace transport { namespace core { // TODO use preallocated pool of membufs -FixedManifestEncoder::FixedManifestEncoder(Packet& packet) +FixedManifestEncoder::FixedManifestEncoder(Packet &packet) : packet_(packet), max_size_(Packet::default_mtu - packet_.headerSize()), manifest_( utils::MemBuf::create(Packet::default_mtu - packet_.headerSize())), manifest_header_( - reinterpret_cast<ManifestHeader*>(manifest_->writableData())), - manifest_entries_(reinterpret_cast<ManifestEntry*>( + reinterpret_cast<ManifestHeader *>(manifest_->writableData())), + manifest_entries_(reinterpret_cast<ManifestEntry *>( manifest_->writableData() + sizeof(ManifestHeader))), current_entry_(0) {} FixedManifestEncoder::~FixedManifestEncoder() {} -FixedManifestEncoder& FixedManifestEncoder::encodeImpl() { +FixedManifestEncoder &FixedManifestEncoder::encodeImpl() { packet_.appendPayload(std::move(manifest_)); return *this; } -FixedManifestEncoder& FixedManifestEncoder::clearImpl() { +FixedManifestEncoder &FixedManifestEncoder::clearImpl() { manifest_ = utils::MemBuf::create(Packet::default_mtu - packet_.headerSize()); return *this; } -FixedManifestEncoder& FixedManifestEncoder::setHashAlgorithmImpl( +FixedManifestEncoder &FixedManifestEncoder::setHashAlgorithmImpl( HashAlgorithm algorithm) { manifest_header_->hash_algorithm = static_cast<uint8_t>(algorithm); return *this; } -FixedManifestEncoder& FixedManifestEncoder::setManifestTypeImpl( +FixedManifestEncoder &FixedManifestEncoder::setManifestTypeImpl( ManifestType manifest_type) { manifest_header_->manifest_type = static_cast<uint8_t>(manifest_type); return *this; } -FixedManifestEncoder& +FixedManifestEncoder & FixedManifestEncoder::setNextSegmentCalculationStrategyImpl( NextSegmentCalculationStrategy strategy) { manifest_header_->next_segment_strategy = static_cast<uint8_t>(strategy); return *this; } -FixedManifestEncoder& FixedManifestEncoder::setBaseNameImpl( - const core::Name& base_name) { +FixedManifestEncoder &FixedManifestEncoder::setBaseNameImpl( + const core::Name &base_name) { base_name.copyToDestination( - reinterpret_cast<uint8_t*>(&manifest_header_->prefix[0]), false); + reinterpret_cast<uint8_t *>(&manifest_header_->prefix[0]), false); manifest_header_->flags.ipv6 = base_name.getAddressFamily() == AF_INET6 ? 1_U8 : 0_U8; return *this; } -FixedManifestEncoder& FixedManifestEncoder::addSuffixAndHashImpl( - uint32_t suffix, const utils::CryptoHash& hash) { +FixedManifestEncoder &FixedManifestEncoder::addSuffixAndHashImpl( + uint32_t suffix, const utils::CryptoHash &hash) { auto _hash = hash.getDigest<std::uint8_t>(); addSuffixHashBytes(suffix, _hash.data(), _hash.length()); return *this; } void FixedManifestEncoder::addSuffixHashBytes(uint32_t suffix, - const uint8_t* hash, + const uint8_t *hash, std::size_t length) { manifest_entries_[current_entry_].suffix = utils::hton(suffix); // std::copy(hash, hash + length, // manifest_entries_[current_entry_].hash); std::memcpy( - reinterpret_cast<uint8_t*>(manifest_entries_[current_entry_].hash), hash, + reinterpret_cast<uint8_t *>(manifest_entries_[current_entry_].hash), hash, length); manifest_header_->number_of_entries++; @@ -99,13 +99,13 @@ void FixedManifestEncoder::addSuffixHashBytes(uint32_t suffix, } } -FixedManifestEncoder& FixedManifestEncoder::setIsFinalManifestImpl( +FixedManifestEncoder &FixedManifestEncoder::setIsFinalManifestImpl( bool is_last) { manifest_header_->flags.is_last = static_cast<uint8_t>(is_last); return *this; } -FixedManifestEncoder& FixedManifestEncoder::setVersionImpl( +FixedManifestEncoder &FixedManifestEncoder::setVersionImpl( ManifestVersion version) { manifest_header_->version = static_cast<uint8_t>(version); return *this; @@ -118,17 +118,17 @@ std::size_t FixedManifestEncoder::estimateSerializedLengthImpl( sizeof(ManifestEntry); } -FixedManifestEncoder& FixedManifestEncoder::updateImpl() { +FixedManifestEncoder &FixedManifestEncoder::updateImpl() { max_size_ = Packet::default_mtu - packet_.headerSize(); - manifest_header_ = reinterpret_cast<ManifestHeader*>( - const_cast<uint8_t*>(packet_.getPayload().data())); - manifest_entries_ = reinterpret_cast<ManifestEntry*>( - const_cast<uint8_t*>(packet_.getPayload().data()) + + manifest_header_ = reinterpret_cast<ManifestHeader *>( + const_cast<uint8_t *>(packet_.getPayload().data())); + manifest_entries_ = reinterpret_cast<ManifestEntry *>( + const_cast<uint8_t *>(packet_.getPayload().data()) + sizeof(ManifestHeader)); return *this; } -FixedManifestEncoder& FixedManifestEncoder::setFinalBlockNumberImpl( +FixedManifestEncoder &FixedManifestEncoder::setFinalBlockNumberImpl( std::uint32_t final_block_number) { manifest_header_->final_block_number = utils::hton(final_block_number); return *this; @@ -138,12 +138,12 @@ std::size_t FixedManifestEncoder::getManifestHeaderSizeImpl() { return sizeof(ManifestHeader); } -FixedManifestDecoder::FixedManifestDecoder(Packet& packet) +FixedManifestDecoder::FixedManifestDecoder(Packet &packet) : packet_(packet), - manifest_header_(reinterpret_cast<ManifestHeader*>( - const_cast<uint8_t*>(packet_.getPayload().data()))), - manifest_entries_(reinterpret_cast<ManifestEntry*>( - const_cast<uint8_t*>(packet_.getPayload().data()) + + manifest_header_(reinterpret_cast<ManifestHeader *>( + const_cast<uint8_t *>(packet_.getPayload().data()))), + manifest_entries_(reinterpret_cast<ManifestEntry *>( + const_cast<uint8_t *>(packet_.getPayload().data()) + sizeof(ManifestHeader))) {} FixedManifestDecoder::~FixedManifestDecoder() {} @@ -158,7 +158,7 @@ void FixedManifestDecoder::decodeImpl() { } } -FixedManifestDecoder& FixedManifestDecoder::clearImpl() { return *this; } +FixedManifestDecoder &FixedManifestDecoder::clearImpl() { return *this; } ManifestType FixedManifestDecoder::getManifestTypeImpl() const { return static_cast<ManifestType>(manifest_header_->manifest_type); @@ -180,7 +180,7 @@ typename Fixed::SuffixList FixedManifestDecoder::getSuffixHashListImpl() { for (int i = 0; i < manifest_header_->number_of_entries; i++) { hash_list.insert(hash_list.end(), std::make_pair(utils::ntoh(manifest_entries_[i].suffix), - reinterpret_cast<uint8_t*>( + reinterpret_cast<uint8_t *>( &manifest_entries_[i].hash[0]))); } @@ -190,10 +190,10 @@ typename Fixed::SuffixList FixedManifestDecoder::getSuffixHashListImpl() { core::Name FixedManifestDecoder::getBaseNameImpl() const { if (static_cast<bool>(manifest_header_->flags.ipv6)) { return core::Name(AF_INET6, - reinterpret_cast<uint8_t*>(&manifest_header_->prefix)); + reinterpret_cast<uint8_t *>(&manifest_header_->prefix)); } else { return core::Name(AF_INET, - reinterpret_cast<uint8_t*>(&manifest_header_->prefix)); + reinterpret_cast<uint8_t *>(&manifest_header_->prefix)); } } diff --git a/libtransport/src/hicn/transport/core/manifest_format_fixed.h b/libtransport/src/hicn/transport/core/manifest_format_fixed.h index 66825e2f4..82817ddfb 100755..100644 --- a/libtransport/src/hicn/transport/core/manifest_format_fixed.h +++ b/libtransport/src/hicn/transport/core/manifest_format_fixed.h @@ -53,7 +53,7 @@ struct Fixed { using Encoder = FixedManifestEncoder; using Decoder = FixedManifestDecoder; using HashType = utils::CryptoHash; - using SuffixList = std::list<std::pair<std::uint32_t, std::uint8_t*>>; + using SuffixList = std::list<std::pair<std::uint32_t, std::uint8_t *>>; }; struct Flags { @@ -83,60 +83,60 @@ static const constexpr std::uint8_t manifest_version = 1; class FixedManifestEncoder : public ManifestEncoder<FixedManifestEncoder> { public: - FixedManifestEncoder(Packet& packet); + FixedManifestEncoder(Packet &packet); ~FixedManifestEncoder(); - FixedManifestEncoder& encodeImpl(); + FixedManifestEncoder &encodeImpl(); - FixedManifestEncoder& clearImpl(); + FixedManifestEncoder &clearImpl(); - FixedManifestEncoder& setManifestTypeImpl(ManifestType manifest_type); + FixedManifestEncoder &setManifestTypeImpl(ManifestType manifest_type); - FixedManifestEncoder& setHashAlgorithmImpl(HashAlgorithm algorithm); + FixedManifestEncoder &setHashAlgorithmImpl(HashAlgorithm algorithm); - FixedManifestEncoder& setNextSegmentCalculationStrategyImpl( + FixedManifestEncoder &setNextSegmentCalculationStrategyImpl( NextSegmentCalculationStrategy strategy); - FixedManifestEncoder& setBaseNameImpl(const core::Name& base_name); + FixedManifestEncoder &setBaseNameImpl(const core::Name &base_name); - FixedManifestEncoder& addSuffixAndHashImpl(uint32_t suffix, - const utils::CryptoHash& hash); + FixedManifestEncoder &addSuffixAndHashImpl(uint32_t suffix, + const utils::CryptoHash &hash); - FixedManifestEncoder& setIsFinalManifestImpl(bool is_last); + FixedManifestEncoder &setIsFinalManifestImpl(bool is_last); - FixedManifestEncoder& setVersionImpl(ManifestVersion version); + FixedManifestEncoder &setVersionImpl(ManifestVersion version); std::size_t estimateSerializedLengthImpl(std::size_t additional_entries = 0); - FixedManifestEncoder& updateImpl(); + FixedManifestEncoder &updateImpl(); - FixedManifestEncoder& setFinalBlockNumberImpl( + FixedManifestEncoder &setFinalBlockNumberImpl( std::uint32_t final_block_number); static std::size_t getManifestHeaderSizeImpl(); private: - void addSuffixHashBytes(uint32_t suffix, const uint8_t* hash, + void addSuffixHashBytes(uint32_t suffix, const uint8_t *hash, std::size_t length); - Packet& packet_; + Packet &packet_; std::size_t max_size_; std::unique_ptr<utils::MemBuf> manifest_; - ManifestHeader* manifest_header_; - ManifestEntry* manifest_entries_; + ManifestHeader *manifest_header_; + ManifestEntry *manifest_entries_; std::size_t current_entry_; }; class FixedManifestDecoder : public ManifestDecoder<FixedManifestDecoder> { public: - FixedManifestDecoder(Packet& packet); + FixedManifestDecoder(Packet &packet); ~FixedManifestDecoder(); void decodeImpl(); - FixedManifestDecoder& clearImpl(); + FixedManifestDecoder &clearImpl(); ManifestType getManifestTypeImpl() const; @@ -158,9 +158,9 @@ class FixedManifestDecoder : public ManifestDecoder<FixedManifestDecoder> { uint32_t getFinalBlockNumberImpl() const; private: - Packet& packet_; - ManifestHeader* manifest_header_; - ManifestEntry* manifest_entries_; + Packet &packet_; + ManifestHeader *manifest_header_; + ManifestEntry *manifest_entries_; }; } // namespace core diff --git a/libtransport/src/hicn/transport/core/manifest_format_json_jsoncpp.cc b/libtransport/src/hicn/transport/core/manifest_format_json_jsoncpp.cc index 512cdba5b..0ffca39f6 100755..100644 --- a/libtransport/src/hicn/transport/core/manifest_format_json_jsoncpp.cc +++ b/libtransport/src/hicn/transport/core/manifest_format_json_jsoncpp.cc @@ -25,38 +25,38 @@ namespace core { namespace { template <typename T> -TRANSPORT_ALWAYS_INLINE void checkPointer(T* pointer) { +TRANSPORT_ALWAYS_INLINE void checkPointer(T *pointer) { if (pointer == nullptr) { throw errors::NullPointerException(); } } template <typename EnumType> -TRANSPORT_ALWAYS_INLINE void setValueToJson(Json::Value& root, EnumType value) { +TRANSPORT_ALWAYS_INLINE void setValueToJson(Json::Value &root, EnumType value) { root[JSONKey<EnumType>::key] = static_cast<uint8_t>(value); } template <typename EnumType> -TRANSPORT_ALWAYS_INLINE EnumType getValueFromJson(const Json::Value& root) { +TRANSPORT_ALWAYS_INLINE EnumType getValueFromJson(const Json::Value &root) { return static_cast<EnumType>(root[JSONKey<EnumType>::key].asUInt()); }; } // namespace -JSONManifestEncoder::JSONManifestEncoder(Packet& packet) : packet_(packet) {} +JSONManifestEncoder::JSONManifestEncoder(Packet &packet) : packet_(packet) {} JSONManifestEncoder::~JSONManifestEncoder() {} -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& JSONManifestEncoder::encodeImpl() { +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder &JSONManifestEncoder::encodeImpl() { Json::StreamWriterBuilder writer_builder; - Json::StreamWriter* fast_writer = writer_builder.newStreamWriter(); + Json::StreamWriter *fast_writer = writer_builder.newStreamWriter(); asio::streambuf strbuf; strbuf.prepare(1500); std::ostream stream(&strbuf); fast_writer->write(root_, &stream); - const uint8_t* buffer = asio::buffer_cast<const uint8_t*>(strbuf.data()); + const uint8_t *buffer = asio::buffer_cast<const uint8_t *>(strbuf.data()); packet_.setPayload(buffer, strbuf.size()); @@ -65,38 +65,38 @@ TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& JSONManifestEncoder::encodeImpl() { return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& JSONManifestEncoder::clearImpl() { +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder &JSONManifestEncoder::clearImpl() { root_.clear(); return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder & JSONManifestEncoder::setHashAlgorithmImpl(HashAlgorithm algorithm) { setValueToJson(root_, algorithm); return *this; } -JSONManifestEncoder& JSONManifestEncoder::setManifestTypeImpl( +JSONManifestEncoder &JSONManifestEncoder::setManifestTypeImpl( ManifestType manifest_type) { setValueToJson(root_, manifest_type); return *this; } -JSONManifestEncoder& JSONManifestEncoder::setNextSegmentCalculationStrategyImpl( +JSONManifestEncoder &JSONManifestEncoder::setNextSegmentCalculationStrategyImpl( NextSegmentCalculationStrategy strategy) { setValueToJson(root_, strategy); return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& -JSONManifestEncoder::setBaseNameImpl(const core::Name& base_name) { +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder & +JSONManifestEncoder::setBaseNameImpl(const core::Name &base_name) { root_[JSONKey<core::Name>::key] = base_name.toString().c_str(); return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder & JSONManifestEncoder::addSuffixAndHashImpl(uint32_t suffix, - const utils::CryptoHash& hash) { + const utils::CryptoHash &hash) { throw errors::NotImplementedException(); // Json::Value value(Json::arrayValue); // value.append(Json::Value(suffix)); @@ -106,21 +106,21 @@ JSONManifestEncoder::addSuffixAndHashImpl(uint32_t suffix, return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder & JSONManifestEncoder::setIsFinalManifestImpl(bool is_last) { root_[JSONKey<bool>::final_manifest] = is_last; return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder & JSONManifestEncoder::setVersionImpl(ManifestVersion version) { setValueToJson(root_, version); return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder & JSONManifestEncoder::setSuffixHashListImpl( - const typename JSON::SuffixList& name_hash_list) { + const typename JSON::SuffixList &name_hash_list) { throw errors::NotImplementedException(); // for (auto &suffix : name_hash_list) { // addSuffixAndHashImpl(suffix.first, suffix.second); @@ -133,7 +133,7 @@ TRANSPORT_ALWAYS_INLINE std::size_t JSONManifestEncoder::estimateSerializedLengthImpl( std::size_t number_of_entries) { Json::StreamWriterBuilder writer_builder; - Json::StreamWriter* fast_writer = writer_builder.newStreamWriter(); + Json::StreamWriter *fast_writer = writer_builder.newStreamWriter(); asio::streambuf strbuf; strbuf.prepare(1500); @@ -143,11 +143,11 @@ JSONManifestEncoder::estimateSerializedLengthImpl( return strbuf.size(); } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& JSONManifestEncoder::updateImpl() { +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder &JSONManifestEncoder::updateImpl() { throw errors::NotImplementedException(); } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder & JSONManifestEncoder::setFinalBlockNumberImpl(std::uint32_t final_block_number) { throw errors::NotImplementedException(); } @@ -157,7 +157,7 @@ JSONManifestEncoder::getManifestHeaderSizeImpl() { return 0; } -JSONManifestDecoder::JSONManifestDecoder(Packet& packet) : packet_(packet) {} +JSONManifestDecoder::JSONManifestDecoder(Packet &packet) : packet_(packet) {} JSONManifestDecoder::~JSONManifestDecoder() {} @@ -167,10 +167,10 @@ TRANSPORT_ALWAYS_INLINE void JSONManifestDecoder::decodeImpl() { auto payload_size = array.length(); Json::CharReaderBuilder reader_builder; - Json::CharReader* reader = reader_builder.newCharReader(); + Json::CharReader *reader = reader_builder.newCharReader(); std::string errors; - if (!reader->parse((char*)payload, (char*)payload + payload_size, &root_, + if (!reader->parse((char *)payload, (char *)payload + payload_size, &root_, &errors)) { TRANSPORT_LOGE("Error parsing manifest!"); TRANSPORT_LOGE("%s", errors.c_str()); @@ -183,7 +183,7 @@ TRANSPORT_ALWAYS_INLINE void JSONManifestDecoder::decodeImpl() { delete reader; } -TRANSPORT_ALWAYS_INLINE JSONManifestDecoder& JSONManifestDecoder::clearImpl() { +TRANSPORT_ALWAYS_INLINE JSONManifestDecoder &JSONManifestDecoder::clearImpl() { root_.clear(); return *this; } diff --git a/libtransport/src/hicn/transport/core/manifest_format_json_jsoncpp.h b/libtransport/src/hicn/transport/core/manifest_format_json_jsoncpp.h index 39f0cf351..84d2ba29a 100755..100644 --- a/libtransport/src/hicn/transport/core/manifest_format_json_jsoncpp.h +++ b/libtransport/src/hicn/transport/core/manifest_format_json_jsoncpp.h @@ -38,7 +38,7 @@ struct JSON { using Encoder = JSONManifestEncoder; using Decoder = JSONManifestDecoder; using HashType = utils::CryptoHash; - using SuffixList = std::unordered_map<std::uint32_t, std::uint8_t*>; + using SuffixList = std::unordered_map<std::uint32_t, std::uint8_t *>; }; template <typename T> @@ -46,91 +46,91 @@ struct JSONKey; template <> struct JSONKey<ManifestVersion> { - static const constexpr char* key = "manifest_version"; + static const constexpr char *key = "manifest_version"; }; template <> struct JSONKey<HashAlgorithm> { - static const constexpr char* key = "hash_algorithm"; + static const constexpr char *key = "hash_algorithm"; }; template <> struct JSONKey<ManifestType> { - static const constexpr char* key = "manifest_type"; + static const constexpr char *key = "manifest_type"; }; template <> struct JSONKey<NextSegmentCalculationStrategy> { - static const constexpr char* key = "next_segment_strategy"; + static const constexpr char *key = "next_segment_strategy"; }; template <> struct JSONKey<typename JSON::SuffixList> { - static const constexpr char* key = "suffix_hash_list"; + static const constexpr char *key = "suffix_hash_list"; }; template <> struct JSONKey<core::Name> { - static const constexpr char* key = "base_name"; + static const constexpr char *key = "base_name"; }; template <> struct JSONKey<bool> { - static const constexpr char* final_manifest = "final_manifest"; + static const constexpr char *final_manifest = "final_manifest"; }; class JSONManifestEncoder : public ManifestEncoder<JSONManifestEncoder> { public: - JSONManifestEncoder(Packet& packet); + JSONManifestEncoder(Packet &packet); ~JSONManifestEncoder() override; - JSONManifestEncoder& encodeImpl(); + JSONManifestEncoder &encodeImpl(); - JSONManifestEncoder& clearImpl(); + JSONManifestEncoder &clearImpl(); - JSONManifestEncoder& setManifestTypeImpl(ManifestType manifest_type); + JSONManifestEncoder &setManifestTypeImpl(ManifestType manifest_type); - JSONManifestEncoder& setHashAlgorithmImpl(HashAlgorithm algorithm); + JSONManifestEncoder &setHashAlgorithmImpl(HashAlgorithm algorithm); - JSONManifestEncoder& setNextSegmentCalculationStrategyImpl( + JSONManifestEncoder &setNextSegmentCalculationStrategyImpl( NextSegmentCalculationStrategy strategy); - JSONManifestEncoder& setSuffixHashListImpl( - const typename JSON::SuffixList& name_hash_list); + JSONManifestEncoder &setSuffixHashListImpl( + const typename JSON::SuffixList &name_hash_list); - JSONManifestEncoder& setBaseNameImpl(const core::Name& base_name); + JSONManifestEncoder &setBaseNameImpl(const core::Name &base_name); - JSONManifestEncoder& addSuffixAndHashImpl(uint32_t suffix, - const utils::CryptoHash& hash); + JSONManifestEncoder &addSuffixAndHashImpl(uint32_t suffix, + const utils::CryptoHash &hash); - JSONManifestEncoder& setIsFinalManifestImpl(bool is_last); + JSONManifestEncoder &setIsFinalManifestImpl(bool is_last); - JSONManifestEncoder& setVersionImpl(ManifestVersion version); + JSONManifestEncoder &setVersionImpl(ManifestVersion version); std::size_t estimateSerializedLengthImpl(std::size_t number_of_entries); - JSONManifestEncoder& updateImpl(); + JSONManifestEncoder &updateImpl(); - JSONManifestEncoder& setFinalBlockNumberImpl( + JSONManifestEncoder &setFinalBlockNumberImpl( std::uint32_t final_block_number); static std::size_t getManifestHeaderSizeImpl(); private: - Packet& packet_; + Packet &packet_; Json::Value root_; }; class JSONManifestDecoder : public ManifestDecoder<JSONManifestDecoder> { public: - JSONManifestDecoder(Packet& packet); + JSONManifestDecoder(Packet &packet); ~JSONManifestDecoder() override; void decodeImpl(); - JSONManifestDecoder& clearImpl(); + JSONManifestDecoder &clearImpl(); ManifestType getManifestTypeImpl() const; @@ -153,7 +153,7 @@ class JSONManifestDecoder : public ManifestDecoder<JSONManifestDecoder> { uint32_t getFinalBlockNumberImpl() const; private: - Packet& packet_; + Packet &packet_; Json::Value root_; }; diff --git a/libtransport/src/hicn/transport/core/manifest_format_json_libparc_deprecated.cc b/libtransport/src/hicn/transport/core/manifest_format_json_libparc_deprecated.cc index d0365d2fe..a3a47e62b 100755..100644 --- a/libtransport/src/hicn/transport/core/manifest_format_json_libparc_deprecated.cc +++ b/libtransport/src/hicn/transport/core/manifest_format_json_libparc_deprecated.cc @@ -29,23 +29,23 @@ namespace core { namespace { template <typename T> -TRANSPORT_ALWAYS_INLINE void checkPointer(T* pointer) { +TRANSPORT_ALWAYS_INLINE void checkPointer(T *pointer) { if (pointer == nullptr) { throw errors::NullPointerException(); } } template <typename EnumType> -TRANSPORT_ALWAYS_INLINE void setValueToJson(PARCJSON* root, EnumType value) { +TRANSPORT_ALWAYS_INLINE void setValueToJson(PARCJSON *root, EnumType value) { parcJSON_AddInteger(root, JSONKey<EnumType>::key, static_cast<int64_t>(value)); } template <typename EnumType> -TRANSPORT_ALWAYS_INLINE EnumType getValueFromJson(PARCJSON* root) { +TRANSPORT_ALWAYS_INLINE EnumType getValueFromJson(PARCJSON *root) { checkPointer(root); - PARCJSONValue* value = parcJSON_GetValueByName(root, JSONKey<EnumType>::key); + PARCJSONValue *value = parcJSON_GetValueByName(root, JSONKey<EnumType>::key); EnumType ret = static_cast<EnumType>(parcJSONValue_GetInteger(value)); // parcJSONValue_Release(&value); @@ -65,17 +65,17 @@ JSONManifestEncoder::~JSONManifestEncoder() { } } -TRANSPORT_ALWAYS_INLINE SONManifestEncoder& JSONManifestEncoder::encodeImpl( - Packet& packet) { - char* json_string = parcJSON_ToString(root_); - packet.setPayload(reinterpret_cast<uint8_t*>(json_string), +TRANSPORT_ALWAYS_INLINE SONManifestEncoder &JSONManifestEncoder::encodeImpl( + Packet &packet) { + char *json_string = parcJSON_ToString(root_); + packet.setPayload(reinterpret_cast<uint8_t *>(json_string), std::strlen(json_string)); parcMemory_Deallocate(&json_string); return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& JSONManifestEncoder::clearImpl() { +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder &JSONManifestEncoder::clearImpl() { if (root_) { parcJSON_Release(&root_); } @@ -85,35 +85,35 @@ TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& JSONManifestEncoder::clearImpl() { return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder & JSONManifestEncoder::setHashAlgorithmImpl(HashAlgorithm algorithm) { setValueToJson(root_, algorithm); return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder & JSONManifestEncoder::setManifestTypeImpl(ManifestType manifest_type) { setValueToJson(root_, manifest_type); return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder & JSONManifestEncoder::setNextSegmentCalculationStrategyImpl( NextSegmentCalculationStrategy strategy) { setValueToJson(root_, strategy); return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& -JSONManifestEncoder::setBaseNameImpl(const core::Name& base_name) { +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder & +JSONManifestEncoder::setBaseNameImpl(const core::Name &base_name) { parcJSON_AddString(root_, JSONKey<core::Name>::key, base_name.toString().c_str()); return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder & JSONManifestEncoder::addSuffixAndHashImpl(uint32_t suffix, - utils::CryptoHash& hash) { + utils::CryptoHash &hash) { throw errors::NotImplementedException(); // PARCJSONValue *value = parcJSON_GetValueByName(root_, // JSONKey<SuffixHashList>::key); @@ -151,17 +151,17 @@ JSONManifestEncoder::addSuffixAndHashImpl(uint32_t suffix, return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder & JSONManifestEncoder::setIsFinalManifestImpl(bool is_last) { parcJSON_AddBoolean(root_, JSONKey<bool>::final_manifest, is_last); return *this; } -TRANSPORT_ALWAYS_INLINE JSONManifestEncoder& +TRANSPORT_ALWAYS_INLINE JSONManifestEncoder & JSONManifestEncoder::setSuffixHashListImpl( - const SuffixHashList& name_hash_list) { - for (auto& suffix : name_hash_list) { + const SuffixHashList &name_hash_list) { + for (auto &suffix : name_hash_list) { addSuffixAndHashImpl(suffix.first, suffix.second); } @@ -178,18 +178,18 @@ TRANSPORT_ALWAYS_INLINE JSONManifestDecoder::~JSONManifestDecoder() { } TRANSPORT_ALWAYS_INLINE void JSONManifestDecoder::decodeImpl( - const uint8_t* payload, std::size_t payload_size) { - PARCBuffer* b = parcBuffer_Wrap(const_cast<uint8_t*>(payload), payload_size, + const uint8_t *payload, std::size_t payload_size) { + PARCBuffer *b = parcBuffer_Wrap(const_cast<uint8_t *>(payload), payload_size, 0, payload_size); clearImpl(); root_ = parcJSON_ParseBuffer(b); parcBuffer_Release(&b); - char* str = parcJSON_ToString(root_); + char *str = parcJSON_ToString(root_); } -TRANSPORT_ALWAYS_INLINE JSONManifestDecoder& JSONManifestDecoder::clearImpl() { +TRANSPORT_ALWAYS_INLINE JSONManifestDecoder &JSONManifestDecoder::clearImpl() { if (root_) { parcJSON_Release(&root_); } @@ -261,11 +261,11 @@ JSONManifestDecoder::getSuffixHashListImpl() { TRANSPORT_ALWAYS_INLINE core::Name JSONManifestDecoder::getBaseNameImpl() const { checkPointer(root_); - PARCJSONValue* value = + PARCJSONValue *value = parcJSON_GetValueByName(root_, JSONKey<core::Name>::key); - PARCBuffer* b = parcJSONValue_GetString(value); - char* string = parcBuffer_ToString(b); + PARCBuffer *b = parcJSONValue_GetString(value); + char *string = parcBuffer_ToString(b); core::Name ret(string); @@ -277,7 +277,7 @@ TRANSPORT_ALWAYS_INLINE core::Name JSONManifestDecoder::getBaseNameImpl() TRANSPORT_ALWAYS_INLINE bool JSONManifestDecoder::getIsFinalManifestImpl() { checkPointer(root_); - PARCJSONValue* value = + PARCJSONValue *value = parcJSON_GetValueByName(root_, JSONKey<bool>::final_manifest); bool ret = parcJSONValue_GetBoolean(value); diff --git a/libtransport/src/hicn/transport/core/manifest_format_json_libparc_deprecated.h b/libtransport/src/hicn/transport/core/manifest_format_json_libparc_deprecated.h index 28c6c1b40..c89f4af7b 100755..100644 --- a/libtransport/src/hicn/transport/core/manifest_format_json_libparc_deprecated.h +++ b/libtransport/src/hicn/transport/core/manifest_format_json_libparc_deprecated.h @@ -42,37 +42,37 @@ struct JSONKey; template <> struct JSONKey<HashAlgorithm> { - static const constexpr char* key = "hash_algorithm"; + static const constexpr char *key = "hash_algorithm"; }; template <> struct JSONKey<ManifestType> { - static const constexpr char* key = "manifest_type"; + static const constexpr char *key = "manifest_type"; }; template <> struct JSONKey<NextSegmentCalculationStrategy> { - static const constexpr char* key = "next_segment_strategy"; + static const constexpr char *key = "next_segment_strategy"; }; template <> struct JSONKey<NameHashList> { - static const constexpr char* key = "name_hash_list"; + static const constexpr char *key = "name_hash_list"; }; template <> struct JSONKey<SuffixHashList> { - static const constexpr char* key = "suffix_hash_list"; + static const constexpr char *key = "suffix_hash_list"; }; template <> struct JSONKey<core::Name> { - static const constexpr char* key = "base_name"; + static const constexpr char *key = "base_name"; }; template <> struct JSONKey<bool> { - static const constexpr char* final_manifest = "final_manifest"; + static const constexpr char *final_manifest = "final_manifest"; }; // template <> @@ -95,28 +95,28 @@ class JSONManifestEncoder : public ManifestEncoder<JSONManifestEncoder> { ~JSONManifestEncoder(); - JSONManifestEncoder& encodeImpl(Packet& packet); + JSONManifestEncoder &encodeImpl(Packet &packet); - JSONManifestEncoder& clearImpl(); + JSONManifestEncoder &clearImpl(); - JSONManifestEncoder& setManifestTypeImpl(ManifestType manifest_type); + JSONManifestEncoder &setManifestTypeImpl(ManifestType manifest_type); - JSONManifestEncoder& setHashAlgorithmImpl(HashAlgorithm algorithm); + JSONManifestEncoder &setHashAlgorithmImpl(HashAlgorithm algorithm); - JSONManifestEncoder& setNextSegmentCalculationStrategyImpl( + JSONManifestEncoder &setNextSegmentCalculationStrategyImpl( NextSegmentCalculationStrategy strategy); - JSONManifestEncoder& setSuffixHashListImpl( - const SuffixHashList& name_hash_list); + JSONManifestEncoder &setSuffixHashListImpl( + const SuffixHashList &name_hash_list); - JSONManifestEncoder& setBaseNameImpl(const core::Name& base_name); + JSONManifestEncoder &setBaseNameImpl(const core::Name &base_name); - JSONManifestEncoder& addSuffixAndHashImpl(uint32_t suffix, uint64_t hash); + JSONManifestEncoder &addSuffixAndHashImpl(uint32_t suffix, uint64_t hash); - JSONManifestEncoder& setIsFinalManifestImpl(bool is_last); + JSONManifestEncoder &setIsFinalManifestImpl(bool is_last); private: - PARCJSON* root_; + PARCJSON *root_; }; class JSONManifestDecoder : public ManifestDecoder<JSONManifestDecoder> { @@ -125,9 +125,9 @@ class JSONManifestDecoder : public ManifestDecoder<JSONManifestDecoder> { ~JSONManifestDecoder(); - void decodeImpl(const uint8_t* payload, std::size_t payload_size); + void decodeImpl(const uint8_t *payload, std::size_t payload_size); - JSONManifestDecoder& clearImpl(); + JSONManifestDecoder &clearImpl(); ManifestType getManifestTypeImpl() const; @@ -144,7 +144,7 @@ class JSONManifestDecoder : public ManifestDecoder<JSONManifestDecoder> { bool getIsFinalManifestImpl(); private: - PARCJSON* root_; + PARCJSON *root_; }; } // namespace core diff --git a/libtransport/src/hicn/transport/core/manifest_inline.h b/libtransport/src/hicn/transport/core/manifest_inline.h index fd1a9abd3..1f2c4edb4 100755..100644 --- a/libtransport/src/hicn/transport/core/manifest_inline.h +++ b/libtransport/src/hicn/transport/core/manifest_inline.h @@ -37,15 +37,15 @@ class ManifestInline public: ManifestInline() : ManifestBase() {} - ManifestInline(const core::Name& name) : ManifestBase(name) {} + ManifestInline(const core::Name &name) : ManifestBase(name) {} template <typename T> - ManifestInline(T&& base) : ManifestBase(std::forward<T&&>(base)) {} + ManifestInline(T &&base) : ManifestBase(std::forward<T &&>(base)) {} - static TRANSPORT_ALWAYS_INLINE ManifestInline* createManifest( - const core::Name& manifest_name, ManifestVersion version, + static TRANSPORT_ALWAYS_INLINE ManifestInline *createManifest( + const core::Name &manifest_name, ManifestVersion version, ManifestType type, HashAlgorithm algorithm, bool is_last, - const Name& base_name, NextSegmentCalculationStrategy strategy, + const Name &base_name, NextSegmentCalculationStrategy strategy, std::size_t signature_size) { auto manifest = new ManifestInline(manifest_name); manifest->setSignatureSize(signature_size); @@ -59,12 +59,12 @@ class ManifestInline return manifest; } - ManifestInline& encodeImpl() { + ManifestInline &encodeImpl() { ManifestBase::encoder_.encode(); return *this; } - ManifestInline& decodeImpl() { + ManifestInline &decodeImpl() { base_name_ = ManifestBase::decoder_.getBaseName(); next_segment_strategy_ = ManifestBase::decoder_.getNextSegmentCalculationStrategy(); @@ -77,23 +77,23 @@ class ManifestInline return ManifestBase::encoder_.estimateSerializedLength(additional_entries); } - ManifestInline& setBaseName(const Name& name) { + ManifestInline &setBaseName(const Name &name) { base_name_ = name; ManifestBase::encoder_.setBaseName(base_name_); return *this; } - const Name& getBaseName() { return base_name_; } + const Name &getBaseName() { return base_name_; } - ManifestInline& addSuffixHash(uint32_t suffix, const HashType& hash) { + ManifestInline &addSuffixHash(uint32_t suffix, const HashType &hash) { ManifestBase::encoder_.addSuffixAndHash(suffix, hash); return *this; } // Call this function only after the decode function! - const SuffixList& getSuffixList() { return suffix_hash_map_; } + const SuffixList &getSuffixList() { return suffix_hash_map_; } - ManifestInline& setNextSegmentCalculationStrategy( + ManifestInline &setNextSegmentCalculationStrategy( NextSegmentCalculationStrategy strategy) { next_segment_strategy_ = strategy; ManifestBase::encoder_.setNextSegmentCalculationStrategy( diff --git a/libtransport/src/hicn/transport/core/memif_binary_api.c b/libtransport/src/hicn/transport/core/memif_binary_api.c index b443b51ce..834c8db13 100755..100644 --- a/libtransport/src/hicn/transport/core/memif_binary_api.c +++ b/libtransport/src/hicn/transport/core/memif_binary_api.c @@ -57,6 +57,10 @@ #include <vpp/api/vpe_all_api_h.h> #undef vl_typedefs +static context_store_t context_store = { + .global_pointers_map_index = 0, +}; + /* * Table of message reply handlers, must include boilerplate handlers * we just generated @@ -66,35 +70,34 @@ _(MEMIF_DELETE_REPLY, memif_delete_reply) \ _(MEMIF_DETAILS, memif_details) -#define POINTER_MAP_SIZE 32 -static void *global_pointers_map[POINTER_MAP_SIZE]; -static uint8_t global_pointers_map_index = 0; - -uint32_t memif_binary_api_get_next_memif_id(vpp_plugin_binary_api_t *api) { +int memif_binary_api_get_next_memif_id(vpp_plugin_binary_api_t *api, + uint32_t *memif_id) { // Dump all the memif interfaces and return the next to the largest memif id vl_api_memif_dump_t *mp; vpp_plugin_binary_api_t *hm = api; M(MEMIF_DUMP, mp); - api->vpp_api->user_param = malloc(sizeof(uint32_t)); - *(uint32_t *)(api->vpp_api->user_param) = 0; - global_pointers_map[global_pointers_map_index] = api; - mp->context = global_pointers_map_index++; - global_pointers_map_index %= POINTER_MAP_SIZE; + uint32_t *user_param = malloc(sizeof(uint32_t)); + *user_param = 0; + vpp_binary_api_set_user_param(api->vpp_api, user_param); + + CONTEXT_SAVE(context_store, api, mp); vpp_binary_api_send_request(api->vpp_api, mp); vpp_binary_api_send_receive_ping(api->vpp_api); - uint32_t ret = *(uint32_t *)(api->vpp_api->user_param); - free(api->vpp_api->user_param); + user_param = vpp_binary_api_get_user_param(api->vpp_api); + *memif_id = *(uint32_t *)(user_param); + free(user_param); - return ret; + return vpp_binary_api_get_ret_value(api->vpp_api); } static void vl_api_memif_details_t_handler(vl_api_memif_details_t *mp) { - vpp_plugin_binary_api_t *binary_api = global_pointers_map[mp->context]; - uint32_t *last_memif_id = binary_api->vpp_api->user_param; + vpp_plugin_binary_api_t *binary_api; + CONTEXT_GET(context_store, mp, binary_api); + uint32_t *last_memif_id = vpp_binary_api_get_user_param(binary_api->vpp_api); uint32_t current_memif_id = clib_net_to_host_u32(mp->id); if (current_memif_id >= *last_memif_id) { *last_memif_id = current_memif_id + 1; @@ -127,14 +130,12 @@ int memif_binary_api_create_memif(vpp_plugin_binary_api_t *api, return -1; } - api->vpp_api->user_param = output_params; + vpp_binary_api_set_user_param(api->vpp_api, output_params); /* Construct the API message */ M(MEMIF_CREATE, mp); - global_pointers_map[global_pointers_map_index] = api; - mp->context = global_pointers_map_index++; - global_pointers_map_index %= POINTER_MAP_SIZE; + CONTEXT_SAVE(context_store, api, mp) mp->role = input_params->role; mp->mode = input_params->mode; @@ -161,9 +162,7 @@ int memif_binary_api_delete_memif(vpp_plugin_binary_api_t *api, /* Construct the API message */ M(MEMIF_DELETE, mp); - global_pointers_map[global_pointers_map_index] = api; - mp->context = global_pointers_map_index++; - global_pointers_map_index %= POINTER_MAP_SIZE; + CONTEXT_SAVE(context_store, api, mp) mp->sw_if_index = htonl(sw_if_index); @@ -172,22 +171,25 @@ int memif_binary_api_delete_memif(vpp_plugin_binary_api_t *api, static void vl_api_memif_create_reply_t_handler( vl_api_memif_create_reply_t *mp) { - vpp_plugin_binary_api_t *binary_api = global_pointers_map[mp->context]; - memif_output_params_t *params = binary_api->vpp_api->user_param; + vpp_plugin_binary_api_t *binary_api; + CONTEXT_GET(context_store, mp, binary_api); + memif_output_params_t *params = + vpp_binary_api_get_user_param(binary_api->vpp_api); - binary_api->vpp_api->ret_val = ntohl(mp->retval); + vpp_binary_api_set_ret_value(binary_api->vpp_api, + clib_net_to_host_u32(mp->retval)); params->sw_if_index = clib_net_to_host_u32(mp->sw_if_index); - TRANSPORT_LOGI("ret :%d", binary_api->vpp_api->ret_val); - vpp_binary_api_unlock_waiting_thread(binary_api->vpp_api); } static void vl_api_memif_delete_reply_t_handler( vl_api_memif_delete_reply_t *mp) { - vpp_plugin_binary_api_t *binary_api = global_pointers_map[mp->context]; + vpp_plugin_binary_api_t *binary_api; + CONTEXT_GET(context_store, mp, binary_api); - binary_api->vpp_api->ret_val = ntohl(mp->retval); + vpp_binary_api_set_ret_value(binary_api->vpp_api, + clib_net_to_host_u32(mp->retval)); vpp_binary_api_unlock_waiting_thread(binary_api->vpp_api); } @@ -210,7 +212,7 @@ vpp_plugin_binary_api_t *memif_binary_api_init(vpp_binary_api_t *api) { u8 *name = format(0, "memif_%08x%c", api_version, 0); ret->msg_id_base = vl_client_get_first_plugin_msg_id((char *)name); ret->vpp_api = api; - ret->my_client_index = api->my_client_index; + ret->my_client_index = vpp_binary_api_get_client_index(api); memif_binary_api_setup_handlers(ret); return ret; } diff --git a/libtransport/src/hicn/transport/core/memif_binary_api.h b/libtransport/src/hicn/transport/core/memif_binary_api.h index 582aeb1a0..b950292b9 100755..100644 --- a/libtransport/src/hicn/transport/core/memif_binary_api.h +++ b/libtransport/src/hicn/transport/core/memif_binary_api.h @@ -43,15 +43,16 @@ typedef struct memif_output_params_s { uint32_t sw_if_index; } memif_output_params_t; -vpp_plugin_binary_api_t* memif_binary_api_init(vpp_binary_api_t* api); +vpp_plugin_binary_api_t *memif_binary_api_init(vpp_binary_api_t *api); -uint32_t memif_binary_api_get_next_memif_id(vpp_plugin_binary_api_t* api); +int memif_binary_api_get_next_memif_id(vpp_plugin_binary_api_t *api, + uint32_t *memif_id); -int memif_binary_api_create_memif(vpp_plugin_binary_api_t* api, - memif_create_params_t* input_params, - memif_output_params_t* output_params); +int memif_binary_api_create_memif(vpp_plugin_binary_api_t *api, + memif_create_params_t *input_params, + memif_output_params_t *output_params); -int memif_binary_api_delete_memif(vpp_plugin_binary_api_t* api, +int memif_binary_api_delete_memif(vpp_plugin_binary_api_t *api, uint32_t sw_if_index); #ifdef __cplusplus diff --git a/libtransport/src/hicn/transport/core/memif_connector.cc b/libtransport/src/hicn/transport/core/memif_connector.cc index 7a672314e..b3785e5c3 100755..100644 --- a/libtransport/src/hicn/transport/core/memif_connector.cc +++ b/libtransport/src/hicn/transport/core/memif_connector.cc @@ -46,6 +46,7 @@ MemifConnector::MemifConnector(PacketReceivedCallback &&receive_callback, is_reconnection_(false), data_available_(false), enable_burst_(false), + closed_(false), app_name_(app_name), receive_callback_(receive_callback), on_reconnect_callback_(on_reconnect_callback), @@ -342,11 +343,14 @@ int MemifConnector::onInterrupt(memif_conn_handle_t conn, void *private_ctx, goto error; } + std::size_t packet_length; for (int i = 0; i < rx; i++) { auto packet = connector->getPacket(); + packet_length = (c->rx_bufs + i)->len; std::memcpy(packet->writableData(), reinterpret_cast<const uint8_t *>((c->rx_bufs + i)->data), - (c->rx_bufs + i)->len); + packet_length); + packet->append(packet_length); if (!connector->input_buffer_.push(std::move(packet))) { TRANSPORT_LOGI("Error pushing packet. Ring buffer full."); @@ -394,20 +398,19 @@ error: return 0; } -// void MemifConnector::runEventsLoop() { -// io_service_.run(); -//} - void MemifConnector::close() { - event_reactor_.stop(); - io_service_.stop(); - - if (memif_worker_ && memif_worker_->joinable()) { - memif_worker_->join(); - TRANSPORT_LOGD("Memif worker joined"); - deleteMemif(); - } else { - TRANSPORT_LOGD("Memif worker not joined"); + if (!closed_) { + closed_ = true; + event_reactor_.stop(); + io_service_.stop(); + + if (memif_worker_ && memif_worker_->joinable()) { + memif_worker_->join(); + TRANSPORT_LOGD("Memif worker joined"); + deleteMemif(); + } else { + TRANSPORT_LOGD("Memif worker not joined"); + } } } diff --git a/libtransport/src/hicn/transport/core/memif_connector.h b/libtransport/src/hicn/transport/core/memif_connector.h index 24c8ac16c..4667ec0b2 100755..100644 --- a/libtransport/src/hicn/transport/core/memif_connector.h +++ b/libtransport/src/hicn/transport/core/memif_connector.h @@ -143,6 +143,7 @@ class MemifConnector : public Connector { volatile bool is_reconnection_; bool data_available_; bool enable_burst_; + bool closed_; uint32_t memif_id_; uint8_t memif_mode_; std::string app_name_; diff --git a/libtransport/src/hicn/transport/core/name.cc b/libtransport/src/hicn/transport/core/name.cc index 10c45eb08..10c45eb08 100755..100644 --- a/libtransport/src/hicn/transport/core/name.cc +++ b/libtransport/src/hicn/transport/core/name.cc diff --git a/libtransport/src/hicn/transport/core/name.h b/libtransport/src/hicn/transport/core/name.h index b0da15026..b0da15026 100755..100644 --- a/libtransport/src/hicn/transport/core/name.h +++ b/libtransport/src/hicn/transport/core/name.h diff --git a/libtransport/src/hicn/transport/core/packet.cc b/libtransport/src/hicn/transport/core/packet.cc index 74f407ff7..69cbb3cb3 100755..100644 --- a/libtransport/src/hicn/transport/core/packet.cc +++ b/libtransport/src/hicn/transport/core/packet.cc @@ -48,7 +48,6 @@ Packet::Packet(MemBufPtr &&buffer) header_head_(packet_.get()), payload_head_(nullptr), format_(getFormatFromBuffer(packet_start_)) { - auto header_size = getHeaderSizeFromFormat(format_); int signature_size = 0; @@ -79,8 +78,6 @@ Packet::Packet(MemBufPtr &&buffer) packet_->prependChain(std::move(payload)); packet_->append(header_size); } - - } Packet::Packet(const uint8_t *buffer, std::size_t size) @@ -98,11 +95,7 @@ Packet::Packet(Packet &&other) other.format_ = HF_UNSPEC; } -Packet::~Packet() { - if (packet_->isChained()) { - packet_->separateChain(packet_->next(), packet_->prev()); - } -} +Packet::~Packet() {} std::size_t Packet::getHeaderSizeFromFormat(Format format, size_t signature_size) { @@ -317,7 +310,7 @@ void Packet::setSignature(std::unique_ptr<utils::MemBuf> &&signature) { void Packet::setSignatureTimestamp(const uint64_t ×tamp) { int ret = hicn_packet_set_signature_timestamp( - format_, (hicn_header_t *)packet_start_, timestamp); + format_, (hicn_header_t *)packet_start_, timestamp); if (ret < 0) { throw errors::RuntimeException("Error setting the signature timestamp."); @@ -327,7 +320,7 @@ void Packet::setSignatureTimestamp(const uint64_t ×tamp) { uint64_t Packet::getSignatureTimestamp() const { uint64_t return_value; int ret = hicn_packet_get_signature_timestamp( - format_, (hicn_header_t *)packet_start_, &return_value); + format_, (hicn_header_t *)packet_start_, &return_value); if (ret < 0) { throw errors::RuntimeException("Error getting the signature timestamp."); @@ -336,9 +329,10 @@ uint64_t Packet::getSignatureTimestamp() const { return return_value; } -void Packet::setValidationAlgorithm(const utils::CryptoSuite &validation_algorithm) { +void Packet::setValidationAlgorithm( + const utils::CryptoSuite &validation_algorithm) { int ret = hicn_packet_set_validation_algorithm( - format_, (hicn_header_t *)packet_start_, uint8_t(validation_algorithm)); + format_, (hicn_header_t *)packet_start_, uint8_t(validation_algorithm)); if (ret < 0) { throw errors::RuntimeException("Error setting the validation algorithm."); @@ -348,7 +342,7 @@ void Packet::setValidationAlgorithm(const utils::CryptoSuite &validation_algorit utils::CryptoSuite Packet::getValidationAlgorithm() const { uint8_t return_value; int ret = hicn_packet_get_validation_algorithm( - format_, (hicn_header_t *)packet_start_, &return_value); + format_, (hicn_header_t *)packet_start_, &return_value); if (ret < 0) { throw errors::RuntimeException("Error getting the validation algorithm."); @@ -358,8 +352,8 @@ utils::CryptoSuite Packet::getValidationAlgorithm() const { } void Packet::setKeyId(const utils::KeyId &key_id) { - int ret = hicn_packet_set_key_id( - format_, (hicn_header_t *)packet_start_, key_id.first); + int ret = hicn_packet_set_key_id(format_, (hicn_header_t *)packet_start_, + key_id.first); if (ret < 0) { throw errors::RuntimeException("Error setting the key id."); @@ -368,8 +362,8 @@ void Packet::setKeyId(const utils::KeyId &key_id) { utils::KeyId Packet::getKeyId() const { utils::KeyId return_value; - int ret = hicn_packet_get_key_id( - format_, (hicn_header_t *)packet_start_, &return_value.first, &return_value.second); + int ret = hicn_packet_get_key_id(format_, (hicn_header_t *)packet_start_, + &return_value.first, &return_value.second); if (ret < 0) { throw errors::RuntimeException("Error getting the validation algorithm."); diff --git a/libtransport/src/hicn/transport/core/packet.h b/libtransport/src/hicn/transport/core/packet.h index 0a5673401..bc23588dc 100755..100644 --- a/libtransport/src/hicn/transport/core/packet.h +++ b/libtransport/src/hicn/transport/core/packet.h @@ -20,10 +20,10 @@ #include <hicn/transport/portability/portability.h> #include <hicn/transport/utils/branch_prediction.h> #include <hicn/transport/utils/crypto_hasher.h> -#include <hicn/transport/utils/membuf.h> -#include <hicn/transport/utils/object_pool.h> #include <hicn/transport/utils/crypto_suite.h> #include <hicn/transport/utils/key_id.h> +#include <hicn/transport/utils/membuf.h> +#include <hicn/transport/utils/object_pool.h> namespace utils { class Signer; diff --git a/libtransport/src/hicn/transport/core/payload_type.h b/libtransport/src/hicn/transport/core/payload_type.h index fa79db35a..fa79db35a 100755..100644 --- a/libtransport/src/hicn/transport/core/payload_type.h +++ b/libtransport/src/hicn/transport/core/payload_type.h diff --git a/libtransport/src/hicn/transport/core/pending_interest.cc b/libtransport/src/hicn/transport/core/pending_interest.cc index 8f6de1839..8f6de1839 100755..100644 --- a/libtransport/src/hicn/transport/core/pending_interest.cc +++ b/libtransport/src/hicn/transport/core/pending_interest.cc diff --git a/libtransport/src/hicn/transport/core/pending_interest.h b/libtransport/src/hicn/transport/core/pending_interest.h index cbcafb5d9..cbcafb5d9 100755..100644 --- a/libtransport/src/hicn/transport/core/pending_interest.h +++ b/libtransport/src/hicn/transport/core/pending_interest.h diff --git a/libtransport/src/hicn/transport/core/portal.h b/libtransport/src/hicn/transport/core/portal.h index 88020447f..a79717037 100755..100644 --- a/libtransport/src/hicn/transport/core/portal.h +++ b/libtransport/src/hicn/transport/core/portal.h @@ -224,7 +224,7 @@ class Portal { TRANSPORT_ALWAYS_INLINE void killConnection() { connector_.close(); } - TRANSPORT_ALWAYS_INLINE void clear() { pending_interest_hash_table_.clear();} + TRANSPORT_ALWAYS_INLINE void clear() { pending_interest_hash_table_.clear(); } TRANSPORT_ALWAYS_INLINE asio::io_service &getIoService() { return io_service_; diff --git a/libtransport/src/hicn/transport/core/prefix.cc b/libtransport/src/hicn/transport/core/prefix.cc index 69c2b845a..69c2b845a 100755..100644 --- a/libtransport/src/hicn/transport/core/prefix.cc +++ b/libtransport/src/hicn/transport/core/prefix.cc diff --git a/libtransport/src/hicn/transport/core/prefix.h b/libtransport/src/hicn/transport/core/prefix.h index b68c6bdf6..b68c6bdf6 100755..100644 --- a/libtransport/src/hicn/transport/core/prefix.h +++ b/libtransport/src/hicn/transport/core/prefix.h diff --git a/libtransport/src/hicn/transport/core/raw_socket_connector.cc b/libtransport/src/hicn/transport/core/raw_socket_connector.cc index 5cfff39fb..5cfff39fb 100755..100644 --- a/libtransport/src/hicn/transport/core/raw_socket_connector.cc +++ b/libtransport/src/hicn/transport/core/raw_socket_connector.cc diff --git a/libtransport/src/hicn/transport/core/raw_socket_connector.h b/libtransport/src/hicn/transport/core/raw_socket_connector.h index 5e39efa0e..5e39efa0e 100755..100644 --- a/libtransport/src/hicn/transport/core/raw_socket_connector.h +++ b/libtransport/src/hicn/transport/core/raw_socket_connector.h diff --git a/libtransport/src/hicn/transport/core/raw_socket_interface.cc b/libtransport/src/hicn/transport/core/raw_socket_interface.cc index 37aaff7e0..37aaff7e0 100755..100644 --- a/libtransport/src/hicn/transport/core/raw_socket_interface.cc +++ b/libtransport/src/hicn/transport/core/raw_socket_interface.cc diff --git a/libtransport/src/hicn/transport/core/raw_socket_interface.h b/libtransport/src/hicn/transport/core/raw_socket_interface.h index c030af662..c030af662 100755..100644 --- a/libtransport/src/hicn/transport/core/raw_socket_interface.h +++ b/libtransport/src/hicn/transport/core/raw_socket_interface.h diff --git a/libtransport/src/hicn/transport/core/socket_connector.cc b/libtransport/src/hicn/transport/core/socket_connector.cc index 332b87ec7..332b87ec7 100755..100644 --- a/libtransport/src/hicn/transport/core/socket_connector.cc +++ b/libtransport/src/hicn/transport/core/socket_connector.cc diff --git a/libtransport/src/hicn/transport/core/socket_connector.h b/libtransport/src/hicn/transport/core/socket_connector.h index d7a05aab4..d7a05aab4 100755..100644 --- a/libtransport/src/hicn/transport/core/socket_connector.h +++ b/libtransport/src/hicn/transport/core/socket_connector.h diff --git a/libtransport/src/hicn/transport/core/test/test_core_manifest.cc b/libtransport/src/hicn/transport/core/test/test_core_manifest.cc index 58563d8f9..58563d8f9 100755..100644 --- a/libtransport/src/hicn/transport/core/test/test_core_manifest.cc +++ b/libtransport/src/hicn/transport/core/test/test_core_manifest.cc diff --git a/libtransport/src/hicn/transport/core/vpp_binary_api.c b/libtransport/src/hicn/transport/core/vpp_binary_api.c index ab23d3cf5..09ffb2ec6 100755..100644 --- a/libtransport/src/hicn/transport/core/vpp_binary_api.c +++ b/libtransport/src/hicn/transport/core/vpp_binary_api.c @@ -53,13 +53,22 @@ #include <vpp/api/vpe_all_api_h.h> #undef vl_msg_name_crc_list -// #define vl_api_version(n,v) static u32 vpe_api_version = (v); -// #include <vpp/api/vpe.api.h> -// #undef vl_api_version - -#define POINTER_MAP_SIZE 32 -static void *global_pointers_map[POINTER_MAP_SIZE]; -static uint8_t global_pointers_map_index = 0; +#include <semaphore.h> + +struct vpp_binary_api { + api_main_t *api_main; + u32 my_client_index; + unix_shared_memory_queue_t *vl_input_queue; + vlib_main_t *vlib_main; + sem_t *semaphore; + u32 ping_id; + int ret_val; + void *user_param; +}; + +static context_store_t context_store = { + .global_pointers_map_index = 0, +}; /* * Table of message reply handlers, must include boilerplate handlers @@ -91,7 +100,8 @@ typedef struct __attribute__((packed)) vl_generic_reply_s { static void vl_api_control_ping_reply_t_handler( vl_api_control_ping_reply_t *mp) { // Just unblock main thread - vpp_binary_api_t *binary_api = global_pointers_map[mp->context]; + vpp_binary_api_t *binary_api; + CONTEXT_GET(context_store, mp, binary_api); binary_api->ret_val = ntohl(mp->retval); vpp_binary_api_unlock_waiting_thread(binary_api); } @@ -99,7 +109,8 @@ static void vl_api_control_ping_reply_t_handler( static void vl_api_sw_interface_set_flags_reply_t_handler( vl_api_control_ping_reply_t *mp) { // Unblock main thread setting reply message status code - vpp_binary_api_t *binary_api = global_pointers_map[mp->context]; + vpp_binary_api_t *binary_api; + CONTEXT_GET(context_store, mp, binary_api); binary_api->ret_val = ntohl(mp->retval); vpp_binary_api_unlock_waiting_thread(binary_api); } @@ -160,9 +171,7 @@ void vpp_binary_api_send_receive_ping(vpp_binary_api_t *api) { vl_msg_api_get_msg_index((u8 *)(VL_API_CONTROL_PING_CRC))); mp_ping->client_index = api->my_client_index; - global_pointers_map[global_pointers_map_index] = api; - mp_ping->context = global_pointers_map_index++; - global_pointers_map_index %= POINTER_MAP_SIZE; + CONTEXT_SAVE(context_store, api, mp_ping); TRANSPORT_LOGI("Sending ping id %u", mp_ping->_vl_msg_id); @@ -191,9 +200,7 @@ int vpp_binary_api_set_int_state(vpp_binary_api_t *api, uint32_t sw_index, mp->sw_if_index = clib_host_to_net_u32(sw_index); mp->admin_up_down = (u8)state; - global_pointers_map[global_pointers_map_index] = api; - mp->context = global_pointers_map_index++; - global_pointers_map_index %= POINTER_MAP_SIZE; + CONTEXT_SAVE(context_store, api, mp); TRANSPORT_LOGI("Sending set int flags id %u", mp->_vl_msg_id); @@ -209,6 +216,29 @@ void vpp_binary_api_send_request(vpp_binary_api_t *api, void *request) { S(api, req); } +int vpp_binary_api_get_ret_value(vpp_binary_api_t *api) { return api->ret_val; } + +void vpp_binary_api_set_ret_value(vpp_binary_api_t *api, int ret_val) { + api->ret_val = ret_val; +} + +void *vpp_binary_api_get_user_param(vpp_binary_api_t *api) { + return api->user_param; +} + +void vpp_binary_api_set_user_param(vpp_binary_api_t *api, void *user_param) { + api->user_param = user_param; +} + +uint32_t vpp_binary_api_get_client_index(vpp_binary_api_t *api) { + return api->my_client_index; +} + +void vpp_binary_api_set_client_index(vpp_binary_api_t *api, + uint32_t client_index) { + api->my_client_index = client_index; +} + int vpp_binary_api_send_request_wait_reply(vpp_binary_api_t *api, void *request) { vpp_binary_api_send_request(api, request); diff --git a/libtransport/src/hicn/transport/core/vpp_binary_api.h b/libtransport/src/hicn/transport/core/vpp_binary_api.h index 1eb10e766..932a59ec2 100755..100644 --- a/libtransport/src/hicn/transport/core/vpp_binary_api.h +++ b/libtransport/src/hicn/transport/core/vpp_binary_api.h @@ -35,27 +35,40 @@ typedef enum link_state_s { UP = 1, DOWN = 0 } link_state_t; * @brief Instantiate a new vpp_binary_api_t data structure and * connect the application to the local VPP forwarder. */ -vpp_binary_api_t* vpp_binary_api_init(const char* app_name); +vpp_binary_api_t *vpp_binary_api_init(const char *app_name); /** * @brief Destroy the vpp_binary_api_t and disconnect from VPP. */ -void vpp_binary_api_destroy(vpp_binary_api_t* api); +void vpp_binary_api_destroy(vpp_binary_api_t *api); -void vpp_binary_api_send_receive_ping(vpp_binary_api_t* api); +void vpp_binary_api_send_receive_ping(vpp_binary_api_t *api); -int vpp_binary_api_set_int_state(vpp_binary_api_t* api, uint32_t sw_index, +int vpp_binary_api_set_int_state(vpp_binary_api_t *api, uint32_t sw_index, link_state_t state); /** * @brief Send request to VPP and wait for reply. */ -int vpp_binary_api_send_request_wait_reply(vpp_binary_api_t* api, - void* request); +int vpp_binary_api_send_request_wait_reply(vpp_binary_api_t *api, + void *request); -void vpp_binary_api_unlock_waiting_thread(vpp_binary_api_t* api); +void vpp_binary_api_unlock_waiting_thread(vpp_binary_api_t *api); -void vpp_binary_api_send_request(vpp_binary_api_t* api, void* request); +void vpp_binary_api_send_request(vpp_binary_api_t *api, void *request); + +int vpp_binary_api_get_ret_value(vpp_binary_api_t *api); + +void vpp_binary_api_set_ret_value(vpp_binary_api_t *api, int ret_val); + +void *vpp_binary_api_get_user_param(vpp_binary_api_t *api); + +void vpp_binary_api_set_user_param(vpp_binary_api_t *api, void *user_param); + +uint32_t vpp_binary_api_get_client_index(vpp_binary_api_t *api); + +void vpp_binary_api_set_client_index(vpp_binary_api_t *api, + uint32_t client_index); #ifdef __cplusplus } diff --git a/libtransport/src/hicn/transport/core/vpp_binary_api_internal.h b/libtransport/src/hicn/transport/core/vpp_binary_api_internal.h index 22b665e96..a6e2c01a3 100755..100644 --- a/libtransport/src/hicn/transport/core/vpp_binary_api_internal.h +++ b/libtransport/src/hicn/transport/core/vpp_binary_api_internal.h @@ -27,16 +27,9 @@ extern "C" { #include <vlibapi/api.h> #include <vlibmemory/api.h> -struct vpp_binary_api { - api_main_t *api_main; - u32 my_client_index; - unix_shared_memory_queue_t *vl_input_queue; - vlib_main_t *vlib_main; - sem_t *semaphore; - u32 ping_id; - int ret_val; - void *user_param; -}; +#include <stdint.h> + +typedef struct vpp_binary_api vpp_binary_api_t; struct vpp_plugin_binary_api { vpp_binary_api_t *vpp_api; @@ -44,6 +37,26 @@ struct vpp_plugin_binary_api { u32 my_client_index; }; +#define POINTER_MAP_SIZE 32 +typedef struct { + void *global_pointers_map[POINTER_MAP_SIZE]; + uint8_t global_pointers_map_index; +} context_store_t; + +#define CONTEXT_SAVE(context_store, pointer, mp) \ + do { \ + context_store \ + .global_pointers_map[context_store.global_pointers_map_index] = \ + pointer; \ + mp->context = context_store.global_pointers_map_index++; \ + context_store.global_pointers_map_index %= POINTER_MAP_SIZE; \ + } while (0); + +#define CONTEXT_GET(context_store, mp, pointer) \ + do { \ + pointer = context_store.global_pointers_map[mp->context]; \ + } while (0); + #define M(T, mp) \ do { \ mp = vl_msg_api_alloc_as_if_client(sizeof(*mp)); \ diff --git a/libtransport/src/hicn/transport/core/vpp_forwarder_interface.cc b/libtransport/src/hicn/transport/core/vpp_forwarder_interface.cc index 3a748c821..0335c3829 100755..100644 --- a/libtransport/src/hicn/transport/core/vpp_forwarder_interface.cc +++ b/libtransport/src/hicn/transport/core/vpp_forwarder_interface.cc @@ -19,6 +19,7 @@ #include <hicn/transport/core/hicn_binary_api.h> #include <hicn/transport/core/memif_binary_api.h> +#include <hicn/transport/core/prefix.h> #include <hicn/transport/core/vpp_forwarder_interface.h> typedef enum { MASTER = 0, SLAVE = 1 } memif_role_t; @@ -42,7 +43,19 @@ VPPForwarderInterface::VPPForwarderInterface(MemifConnector &connector) sw_if_index_(~0), face_id_(~0) {} -VPPForwarderInterface::~VPPForwarderInterface() {} +VPPForwarderInterface::~VPPForwarderInterface() { + if (sw_if_index_ != uint32_t(~0) && VPPForwarderInterface::memif_api_) { + int ret = memif_binary_api_delete_memif(VPPForwarderInterface::memif_api_, sw_if_index_); + + if (ret < 0) { + TRANSPORT_LOGE("Error deleting memif with sw idx %u.", sw_if_index_); + } + } + + if (VPPForwarderInterface::api_) { + vpp_binary_api_destroy(VPPForwarderInterface::api_); + } +} /** * @brief Create a memif interface in the local VPP forwarder. @@ -50,8 +63,13 @@ VPPForwarderInterface::~VPPForwarderInterface() {} uint32_t VPPForwarderInterface::getMemifConfiguration() { memif_create_params_t input_params = {0}; - memif_id_ = - memif_binary_api_get_next_memif_id(VPPForwarderInterface::memif_api_); + int ret = memif_binary_api_get_next_memif_id( + VPPForwarderInterface::memif_api_, &memif_id_); + + if (ret < 0) { + throw errors::RuntimeException( + "Error getting next memif id. Could not create memif interface."); + } input_params.id = memif_id_; input_params.role = memif_role_t::MASTER; @@ -63,8 +81,10 @@ uint32_t VPPForwarderInterface::getMemifConfiguration() { memif_output_params_t output_params = {0}; - if (memif_binary_api_create_memif(VPPForwarderInterface::memif_api_, - &input_params, &output_params) < 0) { + ret = memif_binary_api_create_memif(VPPForwarderInterface::memif_api_, + &input_params, &output_params); + + if (ret < 0) { throw errors::RuntimeException( "Error creating memif interface in the local VPP forwarder."); } @@ -75,23 +95,30 @@ uint32_t VPPForwarderInterface::getMemifConfiguration() { void VPPForwarderInterface::consumerConnection() { hicn_consumer_input_params input = {0}; hicn_consumer_output_params output; + ip_address_t ip4_address; + ip_address_t ip6_address; std::memset(&output, 0, sizeof(hicn_consumer_output_params)); + output.src4 = &ip4_address; + output.src6 = &ip6_address; + input.swif = sw_if_index_; - if (int ret = hicn_binary_api_register_cons_app( - VPPForwarderInterface::hicn_api_, &input, &output) < 0) { + int ret = hicn_binary_api_register_cons_app( + VPPForwarderInterface::hicn_api_, &input, &output); + + if (ret < 0) { throw errors::RuntimeException(hicn_binary_api_get_error_string(ret)); } inet_address_.family = AF_INET; - inet_address_.prefix_len = output.src4.prefix_length; - std::memcpy(inet_address_.buffer, output.src4.ip4.as_u8, IPV4_ADDR_LEN); + inet_address_.prefix_len = output.src4->prefix_len; + std::memcpy(inet_address_.buffer, output.src4->buffer, IPV6_ADDR_LEN); inet6_address_.family = AF_INET6; - inet6_address_.prefix_len = output.src6.prefix_length; - std::memcpy(inet6_address_.buffer, output.src6.ip6.as_u8, IPV6_ADDR_LEN); + inet6_address_.prefix_len = output.src6->prefix_len; + std::memcpy(inet6_address_.buffer, output.src6->buffer, IPV6_ADDR_LEN); } void VPPForwarderInterface::producerConnection() { @@ -127,6 +154,9 @@ void VPPForwarderInterface::connect(bool is_consumer) { void VPPForwarderInterface::registerRoute(Prefix &prefix) { auto &addr = prefix.toIpAddressStruct(); + // Same ip address for input and outurt params + ip_address_t ip_address; + if (face_id_ == uint32_t(~0)) { hicn_producer_input_params input; std::memset(&input, 0, sizeof(input)); @@ -134,44 +164,52 @@ void VPPForwarderInterface::registerRoute(Prefix &prefix) { hicn_producer_output_params output; std::memset(&output, 0, sizeof(output)); + input.prefix = &ip_address; + output.prod_addr = &ip_address; + // Here we have to ask to the actual connector what is the // memif_id, since this function should be called after the // memif creation. input.swif = sw_if_index_; - input.prefix.ip6.as_u64[0] = addr.as_u64[0]; - input.prefix.ip6.as_u64[1] = addr.as_u64[1]; - input.prefix.type = addr.family == AF_INET6 ? IP_TYPE_IP6 : IP_TYPE_IP4; - input.prefix.prefix_length = addr.prefix_len; + input.prefix->as_u64[0] = addr.as_u64[0]; + input.prefix->as_u64[1] = addr.as_u64[1]; + input.prefix->family = addr.family == AF_INET6 ? AF_INET6 : AF_INET; + input.prefix->prefix_len = addr.prefix_len; input.cs_reserved = content_store_reserved_; - if (int ret = hicn_binary_api_register_prod_app( - VPPForwarderInterface::hicn_api_, &input, &output) < 0) { + int ret = hicn_binary_api_register_prod_app( + VPPForwarderInterface::hicn_api_, &input, &output); + + if (ret < 0) { throw errors::RuntimeException(hicn_binary_api_get_error_string(ret)); } if (addr.family == AF_INET6) { - inet6_address_.prefix_len = output.prod_addr.prefix_length; - std::memcpy(inet6_address_.buffer, output.prod_addr.ip6.as_u8, - IPV6_ADDR_LEN); + inet6_address_.prefix_len = output.prod_addr->prefix_len; + inet6_address_.as_u64[0] = output.prod_addr->as_u64[0]; + inet6_address_.as_u64[1] = output.prod_addr->as_u64[1]; } else { - inet_address_.prefix_len = output.prod_addr.prefix_length; + inet_address_.prefix_len = output.prod_addr->prefix_len; // The ipv4 is written in the last 4 bytes of the ipv6 address, so we need // to copy from the byte 12 - std::memcpy(inet_address_.buffer, output.prod_addr.ip6.as_u8 + 12, - IPV4_ADDR_LEN); + inet_address_.as_u64[0] = output.prod_addr->as_u64[0]; + inet_address_.as_u64[1] = output.prod_addr->as_u64[1]; } face_id_ = output.face_id; } else { hicn_producer_set_route_params params; - params.prefix.ip6.as_u64[0] = addr.as_u64[0]; - params.prefix.ip6.as_u64[1] = addr.as_u64[1]; - params.prefix.type = addr.family == AF_INET6 ? IP_TYPE_IP6 : IP_TYPE_IP4; - params.prefix.prefix_length = addr.prefix_len; + params.prefix = &ip_address; + params.prefix->as_u64[0] = addr.as_u64[0]; + params.prefix->as_u64[1] = addr.as_u64[1]; + params.prefix->family = addr.family == AF_INET6 ? AF_INET6 : AF_INET; + params.prefix->prefix_len = addr.prefix_len; params.face_id = face_id_; - if (int ret = hicn_binary_api_register_route( - VPPForwarderInterface::hicn_api_, ¶ms) < 0) { + int ret = hicn_binary_api_register_route( + VPPForwarderInterface::hicn_api_, ¶ms); + + if (ret < 0) { throw errors::RuntimeException(hicn_binary_api_get_error_string(ret)); } } diff --git a/libtransport/src/hicn/transport/core/vpp_forwarder_interface.h b/libtransport/src/hicn/transport/core/vpp_forwarder_interface.h index 322cd1f8b..322cd1f8b 100755..100644 --- a/libtransport/src/hicn/transport/core/vpp_forwarder_interface.h +++ b/libtransport/src/hicn/transport/core/vpp_forwarder_interface.h diff --git a/libtransport/src/hicn/transport/interfaces/full_duplex_socket.cc b/libtransport/src/hicn/transport/interfaces/full_duplex_socket.cc index 7b6342262..37e1d7b3e 100755..100644 --- a/libtransport/src/hicn/transport/interfaces/full_duplex_socket.cc +++ b/libtransport/src/hicn/transport/interfaces/full_duplex_socket.cc @@ -68,9 +68,10 @@ AsyncFullDuplexSocket::AsyncFullDuplexSocket(const Prefix &locator, ConsumerSocket & s, const ContentObject &c) ->bool { return true; }); - consumer_->setSocketOption( - ConsumerCallbacksOptions::CONTENT_RETRIEVED, - std::bind(&AsyncFullDuplexSocket::onContentRetrieved, this, _1, _2, _3)); + ConsumerContentCallback callback = + std::bind(&AsyncFullDuplexSocket::onContentRetrieved, this, _1, _2, _3); + consumer_->setSocketOption(ConsumerCallbacksOptions::CONTENT_RETRIEVED, + callback); consumer_->setSocketOption(GeneralTransportOptions::MAX_INTEREST_RETX, uint32_t{4}); diff --git a/libtransport/src/hicn/transport/interfaces/rtc_socket_producer.cc b/libtransport/src/hicn/transport/interfaces/rtc_socket_producer.cc index d8a9d53b9..ec8c4c69e 100755..100644 --- a/libtransport/src/hicn/transport/interfaces/rtc_socket_producer.cc +++ b/libtransport/src/hicn/transport/interfaces/rtc_socket_producer.cc @@ -13,9 +13,9 @@ * limitations under the License. */ +#include <hicn/transport/interfaces/rtc_socket_producer.h> #include <stdlib.h> #include <time.h> -#include <hicn/transport/interfaces/rtc_socket_producer.h> #define NACK_HEADER_SIZE 8 // bytes #define TIMESTAMP_LEN 8 // bytes diff --git a/libtransport/src/hicn/transport/interfaces/socket_consumer.cc b/libtransport/src/hicn/transport/interfaces/socket_consumer.cc index 8109d0e99..27ed4e65f 100755..100644 --- a/libtransport/src/hicn/transport/interfaces/socket_consumer.cc +++ b/libtransport/src/hicn/transport/interfaces/socket_consumer.cc @@ -137,11 +137,11 @@ void ConsumerSocket::stop() { transport_protocol_->stop(); } - //is_running_ = false; + // is_running_ = false; } void ConsumerSocket::resume() { - if(!transport_protocol_->isRunning()){ + if (!transport_protocol_->isRunning()) { transport_protocol_->resume(); } } @@ -548,7 +548,7 @@ int ConsumerSocket::getSocketOption(int socket_option_key, case GeneralTransportOptions::RUNNING: socket_option_value = transport_protocol_->isRunning(); - return SOCKET_OPTION_GET; + return SOCKET_OPTION_GET; case OtherOptions::VIRTUAL_DOWNLOAD: socket_option_value = virtual_download_; diff --git a/libtransport/src/hicn/transport/protocols/rtc.cc b/libtransport/src/hicn/transport/protocols/rtc.cc index 1f42cf230..ee90e5d9e 100755..100644 --- a/libtransport/src/hicn/transport/protocols/rtc.cc +++ b/libtransport/src/hicn/transport/protocols/rtc.cc @@ -48,9 +48,7 @@ RTCTransportProtocol::~RTCTransportProtocol() { void RTCTransportProtocol::start( utils::SharableVector<uint8_t> &content_buffer) { - - if(is_running_) - return; + if (is_running_) return; is_running_ = true; content_buffer_ = content_buffer.shared_from_this(); @@ -63,29 +61,26 @@ void RTCTransportProtocol::start( } void RTCTransportProtocol::stop() { - if(!is_running_) - return; + if (!is_running_) return; is_running_ = false; portal_->stopEventsLoop(); } -void RTCTransportProtocol::resume(){ - if(is_running_) - return; - - is_running_ = true; - - lastRoundBegin_ = std::chrono::steady_clock::now(); - inflightInterestsCount_ = 0; - if(content_buffer_) - content_buffer_->clear(); +void RTCTransportProtocol::resume() { + if (is_running_) return; - scheduleNextInterest(); - - portal_->runEventsLoop(); + is_running_ = true; - is_running_ = false; + lastRoundBegin_ = std::chrono::steady_clock::now(); + inflightInterestsCount_ = 0; + if (content_buffer_) content_buffer_->clear(); + + scheduleNextInterest(); + + portal_->runEventsLoop(); + + is_running_ = false; } void RTCTransportProtocol::onRTCPPacket(uint8_t *packet, size_t len) { @@ -452,8 +447,7 @@ void RTCTransportProtocol::sendInterest() { void RTCTransportProtocol::scheduleNextInterest() { checkRound(); - if(!is_running_) - return; + if (!is_running_) return; uint32_t MAX_RECOVER = 40; // if the packet is more than MAX_RECOVER seq in the past we drop it @@ -573,8 +567,8 @@ void RTCTransportProtocol::onNack(const ContentObject &content_object) { estimatedBw_ = (double)productionRate; // if(inflightInterests_[segmentNumber % - // default_values::default_buffer_size].retransmissions != 0){ ignore nacks for - // retransmissions + // default_values::default_buffer_size].retransmissions != 0){ ignore nacks + // for retransmissions // return; //} diff --git a/libtransport/src/hicn/transport/protocols/rtc_data_path.h b/libtransport/src/hicn/transport/protocols/rtc_data_path.h index ace16ff12..b55139d52 100755..100644 --- a/libtransport/src/hicn/transport/protocols/rtc_data_path.h +++ b/libtransport/src/hicn/transport/protocols/rtc_data_path.h @@ -15,8 +15,8 @@ #pragma once -#include <stdint.h> #include <hicn/transport/utils/min_filter.h> +#include <stdint.h> #include <climits> #define ALPHA_RTC 0.125 diff --git a/libtransport/src/hicn/transport/protocols/vegas.cc b/libtransport/src/hicn/transport/protocols/vegas.cc index b6d79bfcc..1431020a6 100755..100644 --- a/libtransport/src/hicn/transport/protocols/vegas.cc +++ b/libtransport/src/hicn/transport/protocols/vegas.cc @@ -95,9 +95,7 @@ void VegasTransportProtocol::reset() { void VegasTransportProtocol::start( utils::SharableVector<uint8_t> &content_buffer) { - - if(is_running_) - return; + if (is_running_) return; socket_->t0_ = std::chrono::steady_clock::now(); @@ -110,15 +108,13 @@ void VegasTransportProtocol::start( portal_->runEventsLoop(); removeAllPendingInterests(); is_running_ = false; - } -void VegasTransportProtocol::resume(){ - if(is_running_) - return; +void VegasTransportProtocol::resume() { + if (is_running_) return; is_running_ = true; - sendInterest(next_suffix_++); + sendInterest(next_suffix_++); portal_->runEventsLoop(); removeAllPendingInterests(); is_running_ = false; @@ -539,7 +535,7 @@ void VegasTransportProtocol::reassemble() { uint64_t index = last_reassembled_segment_; auto it = receive_buffer_.find(index); - do { + while (it != receive_buffer_.end()) { if (it->second->getPayloadType() == PayloadType::CONTENT_OBJECT) { copyContent(*it->second); receive_buffer_.erase(it); @@ -547,7 +543,7 @@ void VegasTransportProtocol::reassemble() { index = ++last_reassembled_segment_; it = receive_buffer_.find(index); - } while (it != receive_buffer_.end()); + } } void VegasTransportProtocol::partialDownload() { diff --git a/libtransport/src/hicn/transport/utils/identity.cc b/libtransport/src/hicn/transport/utils/identity.cc index bdf7f29f9..1b2fd4828 100755..100644 --- a/libtransport/src/hicn/transport/utils/identity.cc +++ b/libtransport/src/hicn/transport/utils/identity.cc @@ -33,10 +33,11 @@ Identity::Identity(const std::string &keystore_name, parcCryptoSuite_GetSigningAlgorithm(static_cast<PARCCryptoSuite>(suite)), key_length, validity_days); - parcAssertTrue(success, - "parcPkcs12KeyStore_CreateFile('%s', '%s', '%s', %d, %d) failed.", - keystore_name.c_str(), keystore_password.c_str(), - subject_name.c_str(), static_cast<int>(key_length), validity_days); + parcAssertTrue( + success, + "parcPkcs12KeyStore_CreateFile('%s', '%s', '%s', %d, %d) failed.", + keystore_name.c_str(), keystore_password.c_str(), subject_name.c_str(), + static_cast<int>(key_length), validity_days); PARCIdentityFile *identity_file = parcIdentityFile_Create(keystore_name.c_str(), keystore_password.c_str()); diff --git a/libtransport/src/hicn/transport/utils/log.cc b/libtransport/src/hicn/transport/utils/log.cc index 064625ec0..00bd7d54f 100755..100644 --- a/libtransport/src/hicn/transport/utils/log.cc +++ b/libtransport/src/hicn/transport/utils/log.cc @@ -25,8 +25,8 @@ * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, @@ -321,19 +321,19 @@ #include <assert.h> #include <ctype.h> +#include <hicn/transport/utils/log.h> #include <stdarg.h> #include <stddef.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h> -#include <hicn/transport/utils/log.h> #if defined(_WIN32) || defined(_WIN64) #include <windows.h> #else -#include <unistd.h> #include <sys/time.h> +#include <unistd.h> #if defined(__linux__) #include <linux/limits.h> #else diff --git a/libtransport/src/hicn/transport/utils/log.h b/libtransport/src/hicn/transport/utils/log.h index 17e47e7df..3c4f1277a 100755..100644 --- a/libtransport/src/hicn/transport/utils/log.h +++ b/libtransport/src/hicn/transport/utils/log.h @@ -25,8 +25,8 @@ * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, diff --git a/libtransport/src/hicn/transport/utils/object_pool.h b/libtransport/src/hicn/transport/utils/object_pool.h index d4d8e18d6..c369f7e12 100755 --- a/libtransport/src/hicn/transport/utils/object_pool.h +++ b/libtransport/src/hicn/transport/utils/object_pool.h @@ -45,7 +45,11 @@ class ObjectPool { public: using Ptr = std::unique_ptr<T, ObjectDeleter>; - ObjectPool() {} + ObjectPool() : destructor_(false) {} + + ~ObjectPool() { + destructor_ = true; + } std::pair<bool, Ptr> get() { if (object_pool_.empty()) { @@ -60,7 +64,9 @@ class ObjectPool { void add(T *object) { utils::SpinLock::Acquire locked(object_pool_lock_); - object_pool_.emplace_back(makePtr(object)); + if (TRANSPORT_EXPECT_TRUE(!destructor_)) { + object_pool_.emplace_back(makePtr(object)); + } } Ptr makePtr(T *object) { return Ptr(object, ObjectDeleter(this)); } @@ -71,6 +77,7 @@ class ObjectPool { utils::SpinLock object_pool_lock_; std::deque<Ptr> object_pool_; + bool destructor_; }; } // namespace utils
\ No newline at end of file diff --git a/libtransport/src/hicn/transport/utils/signer.cc b/libtransport/src/hicn/transport/utils/signer.cc index c11d5e183..579b08aff 100755..100644 --- a/libtransport/src/hicn/transport/utils/signer.cc +++ b/libtransport/src/hicn/transport/utils/signer.cc @@ -17,10 +17,9 @@ #include <hicn/transport/errors/malformed_ahpacket_exception.h> #include <hicn/transport/utils/endianess.h> +#include <hicn/transport/utils/key_id.h> #include <hicn/transport/utils/membuf.h> #include <hicn/transport/utils/signer.h> -#include <hicn/transport/utils/key_id.h> - extern "C" { TRANSPORT_CLANG_DISABLE_WARNING("-Wextern-c-compat") @@ -77,7 +76,7 @@ Signer::~Signer() { void Signer::sign(Packet &packet) { // header chain points to the IP + TCP hicn header utils::MemBuf *header_chain = packet.header_head_; - utils::MemBuf * payload_chain = packet.payload_head_; + utils::MemBuf *payload_chain = packet.payload_head_; uint8_t *hicn_packet = header_chain->writableData(); Packet::Format format = packet.getFormat(); std::size_t sign_len_bytes = parcSigner_GetSignatureSize(signer_); @@ -101,46 +100,51 @@ void Signer::sign(Packet &packet) { /* Fill the hicn_ah header */ using namespace std::chrono; - auto now = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count(); + auto now = duration_cast<milliseconds>(system_clock::now().time_since_epoch()) + .count(); packet.setSignatureTimestamp(now); // *reinterpret_cast<uint64_t*>(ah->signTime) = utils::hton<uint64_t>(now); - // // std::memcpy(&ah->hicn_ah.signTime, &sign_time, sizeof(ah->hicn_ah.signTime)); + // // std::memcpy(&ah->hicn_ah.signTime, &sign_time, + // sizeof(ah->hicn_ah.signTime)); - packet.setValidationAlgorithm(CryptoSuite(parcSigner_GetCryptoSuite(this->signer_))); + packet.setValidationAlgorithm( + CryptoSuite(parcSigner_GetCryptoSuite(this->signer_))); // ah->validationAlgorithm = parcSigner_GetCryptoSuite(this->signer_); KeyId key_id; - key_id.first = (uint8_t *)parcBuffer_Overlay((PARCBuffer *) parcKeyId_GetKeyId(this->key_id_), 0); + key_id.first = (uint8_t *)parcBuffer_Overlay( + (PARCBuffer *)parcKeyId_GetKeyId(this->key_id_), 0); packet.setKeyId(key_id); // memcpy(ah->keyId, - // parcBuffer_Overlay((PARCBuffer *) parcKeyId_GetKeyId(this->key_id_), 0), - // sizeof(_ah_header_t::keyId)); + // parcBuffer_Overlay((PARCBuffer *) parcKeyId_GetKeyId(this->key_id_), + // 0), sizeof(_ah_header_t::keyId)); // Calculate hash utils::CryptoHasher hasher(parcSigner_GetCryptoHasher(signer_)); hasher.init(); hasher.updateBytes(hicn_packet, header_len); hasher.updateBytes(zeros, sign_len_bytes); - - for (utils::MemBuf *current = payload_chain; current != header_chain; current = current->next()) { + + for (utils::MemBuf *current = payload_chain; current != header_chain; + current = current->next()) { hasher.updateBytes(current->data(), current->length()); } utils::CryptoHash hash = hasher.finalize(); - + PARCSignature *signature = parcSigner_SignDigest(this->signer_, hash.hash_); PARCBuffer *buffer = parcSignature_GetSignature(signature); - PARCByteArray * byte_array = parcBuffer_Array(buffer); - uint8_t * bytes = parcByteArray_Array(byte_array); + PARCByteArray *byte_array = parcBuffer_Array(buffer); + uint8_t *bytes = parcByteArray_Array(byte_array); size_t bytes_len = parcBuffer_Remaining(buffer); if (bytes_len > sign_len_bytes) { throw errors::MalformedAHPacketException(); } - /* Restore the resetted fields */ + /* Restore the resetted fields */ if (format & HFO_INET) { memcpy(hicn_packet, &header_copy, sizeof(hicn_v4_hdr_t)); } else if (format & HFO_INET6) { @@ -151,12 +155,11 @@ void Signer::sign(Packet &packet) { std::unique_ptr<utils::MemBuf> signature_buffer; std::unique_ptr<utils::MemBuf> tmp_buf = utils::MemBuf::takeOwnership( - bytes, - bytes_len, - bytes_len, - [](void* buf, void* userData){ parcSignature_Release((PARCSignature **)&userData); }, - signature, - true); + bytes, bytes_len, bytes_len, + [](void *buf, void *userData) { + parcSignature_Release((PARCSignature **)&userData); + }, + signature, true); if (offset) { signature_buffer = utils::MemBuf::create(offset); diff --git a/libtransport/src/hicn/transport/utils/verifier.cc b/libtransport/src/hicn/transport/utils/verifier.cc index 9a3de43c1..93efe063a 100755..100644 --- a/libtransport/src/hicn/transport/utils/verifier.cc +++ b/libtransport/src/hicn/transport/utils/verifier.cc @@ -65,9 +65,9 @@ bool Verifier::addKey(PARCKey *key) { return true; } -PARCKeyId * Verifier::addKeyFromCertificate(const std::string &file_name) { - PARCCertificateFactory *factory = parcCertificateFactory_Create(PARCCertificateType_X509, - PARCContainerEncoding_PEM); +PARCKeyId *Verifier::addKeyFromCertificate(const std::string &file_name) { + PARCCertificateFactory *factory = parcCertificateFactory_Create( + PARCCertificateType_X509, PARCContainerEncoding_PEM); parcAssertNotNull(factory, "Expected non-NULL factory"); if (!file_exists(file_name)) { |