1 files changed, 181 insertions, 0 deletions
diff --git a/libtransport/src/io_modules/udp/hicn_forwarder_module.cc b/libtransport/src/io_modules/udp/hicn_forwarder_module.cc
new file mode 100644
index 000000000..ba08dd8c0
--- /dev/null
+++ b/libtransport/src/io_modules/udp/hicn_forwarder_module.cc
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2017-2020 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 <io_modules/udp/hicn_forwarder_module.h>
+#include <io_modules/udp/udp_socket_connector.h>
+
+union AddressLight {
+  uint32_t ipv4;
+  struct in6_addr ipv6;
+};
+
+typedef struct {
+  uint8_t message_type;
+  uint8_t command_id;
+  uint16_t length;
+  uint32_t seq_num;
+} CommandHeader;
+
+typedef struct {
+  uint8_t message_type;
+  uint8_t command_id;
+  uint16_t length;
+  uint32_t seq_num;
+  char symbolic_or_connid[16];
+  union AddressLight address;
+  uint16_t cost;
+  uint8_t address_type;
+  uint8_t len;
+} RouteToSelfCommand;
+
+typedef struct {
+  uint8_t message_type;
+  uint8_t command_id;
+  uint16_t length;
+  uint32_t seq_num;
+  char symbolic_or_connid[16];
+} DeleteSelfConnectionCommand;
+
+namespace {
+static constexpr uint8_t addr_inet = 1;
+static constexpr uint8_t addr_inet6 = 2;
+static constexpr uint8_t add_route_command = 3;
+static constexpr uint8_t delete_connection_command = 5;
+static constexpr uint8_t request_light = 0xc0;
+static constexpr char identifier[] = "SELF";
+
+void fillCommandHeader(CommandHeader *header) {
+  // Allocate and fill the header
+  header->message_type = request_light;
+  header->length = 1;
+}
+
+RouteToSelfCommand createCommandRoute(std::unique_ptr<sockaddr> &&addr,
+                                      uint8_t prefix_length) {
+  RouteToSelfCommand command = {0};
+
+  // check and set IP address
+  if (addr->sa_family == AF_INET) {
+    command.address_type = addr_inet;
+    command.address.ipv4 = ((sockaddr_in *)addr.get())->sin_addr.s_addr;
+  } else if (addr->sa_family == AF_INET6) {
+    command.address_type = addr_inet6;
+    command.address.ipv6 = ((sockaddr_in6 *)addr.get())->sin6_addr;
+  }
+
+  // Fill remaining payload fields
+#ifndef _WIN32
+  strcpy(command.symbolic_or_connid, identifier);
+#else
+  strcpy_s(command.symbolic_or_connid, 16, identifier);
+#endif
+  command.cost = 1;
+  command.len = (uint8_t)prefix_length;
+
+  // Allocate and fill the header
+  command.command_id = add_route_command;
+  fillCommandHeader((CommandHeader *)&command);
+
+  return command;
+}
+
+DeleteSelfConnectionCommand createCommandDeleteConnection() {
+  DeleteSelfConnectionCommand command = {0};
+  fillCommandHeader((CommandHeader *)&command);
+  command.command_id = delete_connection_command;
+
+#ifndef _WIN32
+  strcpy(command.symbolic_or_connid, identifier);
+#else
+  strcpy_s(command.symbolic_or_connid, 16, identifier);
+#endif
+
+  return command;
+}
+
+}  // namespace
+
+namespace transport {
+
+namespace core {
+
+HicnForwarderModule::HicnForwarderModule() : IoModule(), connector_(nullptr) {}
+
+HicnForwarderModule::~HicnForwarderModule() {}
+
+void HicnForwarderModule::connect(bool is_consumer) {
+  connector_->connect();
+  connector_->setRole(is_consumer ? Connector::Role::CONSUMER
+                                  : Connector::Role::PRODUCER);
+}
+
+bool HicnForwarderModule::isConnected() { return connector_->isConnected(); }
+
+void HicnForwarderModule::send(Packet &packet) {
+  IoModule::send(packet);
+  packet.setChecksum();
+  connector_->send(packet);
+}
+
+void HicnForwarderModule::send(const uint8_t *packet, std::size_t len) {
+  counters_.tx_packets++;
+  counters_.tx_bytes += len;
+
+  // Perfect forwarding
+  connector_->send(packet, len);
+}
+
+void HicnForwarderModule::registerRoute(const Prefix &prefix) {
+  auto command = createCommandRoute(prefix.toSockaddr(),
+                                    (uint8_t)prefix.getPrefixLength());
+  send((uint8_t *)&command, sizeof(RouteToSelfCommand));
+}
+
+void HicnForwarderModule::closeConnection() {
+  auto command = createCommandDeleteConnection();
+  send((uint8_t *)&command, sizeof(DeleteSelfConnectionCommand));
+  connector_->close();
+}
+
+void HicnForwarderModule::init(
+    Connector::PacketReceivedCallback &&receive_callback,
+    Connector::OnReconnectCallback &&reconnect_callback,
+    asio::io_service &io_service, const std::string &app_name) {
+  if (!connector_) {
+    connector_ = new UdpSocketConnector(std::move(receive_callback), nullptr,
+                                        nullptr, std::move(reconnect_callback),
+                                        io_service, app_name);
+  }
+}
+
+void HicnForwarderModule::processControlMessageReply(
+    utils::MemBuf &packet_buffer) {
+  if (packet_buffer.data()[0] == nack_code) {
+    throw errors::RuntimeException(
+        "Received Nack message from hicn light forwarder.");
+  }
+}
+
+std::uint32_t HicnForwarderModule::getMtu() { return interface_mtu; }
+
+bool HicnForwarderModule::isControlMessage(const uint8_t *message) {
+  return message[0] == ack_code || message[0] == nack_code;
+}
+
+extern "C" IoModule *create_module(void) { return new HicnForwarderModule(); }
+
+}  // namespace core
+
+}  // namespace transport