1 files changed, 298 insertions, 0 deletions

diff --git a/ctrl/libhicnctrl/src/objects/connection.c b/ctrl/libhicnctrl/src/objects/connection.c
new file mode 100644
index 000000000..ca09d9a54
--- /dev/null
+++ b/ctrl/libhicnctrl/src/objects/connection.c
@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) 2021-2022 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * \file connection.c
+ * \brief Implementation of connection object.
+ */
+
+#include <assert.h>
+
+#include <hicn/ctrl/api.h>
+#include <hicn/ctrl/object.h>
+#include <hicn/ctrl/objects/connection.h>
+#include <hicn/util/log.h>
+
+#include "../object_private.h"
+#include "../object_vft.h"
+#include "base.h"
+
+bool hc_connection_is_local(const hc_connection_t *connection) {
+  return (strncmp(connection->interface_name, "lo", INTERFACE_LEN) == 0);
+}
+
+bool hc_connection_has_local(const hc_connection_t *connection) {
+  assert(connection);
+  return IS_VALID_PORT(connection->local_port) &&
+         IS_VALID_ADDRESS(connection->local_addr);
+}
+
+/* CONNECTION VALIDATE */
+
+int hc_connection_validate(const hc_connection_t *connection,
+                           bool allow_partial) {
+  int has_id = 0;
+  int has_name = 0;
+#if 0
+  int has_interface_name = 0;
+#endif
+  int has_netdevice_type = 0;
+  int has_type = 0;
+  int has_family = 0;
+  int has_local_addr = 0;
+  int has_local_port = 0;
+  int has_remote_addr = 0;
+  int has_remote_port = 0;
+  int has_admin_state = 0;
+  int has_priority = 0;
+  int has_tags = 0;
+  int has_state = 0;
+
+  if (connection->id == ~0) {
+    ERROR("[hc_listener_validate] Invalid id specified");
+    return -1;
+  }
+  has_id = 1;
+
+  if (!isempty(connection->name)) {
+    if (!IS_VALID_NAME(connection->name)) {
+      ERROR("[hc_connection_validate] Invalid name specified");
+      return -1;
+    }
+    has_name = 1;
+  }
+
+#if 0
+  if (!isempty(connection->interface_name)) {
+    if (!IS_VALID_INTERFACE_NAME(connection->interface_name)) {
+      ERROR("[hc_connection_validate] Invalid interface_name specified");
+      return -1;
+    }
+    has_interface_name = 1;
+  }
+#endif
+
+  if (connection->type != FACE_TYPE_UNDEFINED) {
+    if (!IS_VALID_TYPE(connection->type)) {
+      ERROR("[hc_connection_validate] Invalid type specified");
+      return -1;
+    }
+    has_type = 1;
+  }
+
+  if (connection->family != AF_UNSPEC) {
+    if (!IS_VALID_FAMILY(connection->family)) {
+      ERROR("[hc_connection_validate] Invalid family specified");
+      return -1;
+    }
+    has_family = 1;
+  }
+
+  if (!hicn_ip_address_empty(&connection->local_addr)) {
+    if (!IS_VALID_ADDRESS(connection->local_addr)) {
+      ERROR("[hc_connection_validate] Invalid local_addr specified");
+      return -1;
+    }
+    has_local_addr = 1;
+  }
+
+  if (connection->local_port != 0) {
+    if (!IS_VALID_PORT(connection->local_port)) {
+      ERROR("[hc_connection_validate] Invalid local_port specified");
+      return -1;
+    }
+    has_local_port = 1;
+  }
+
+  if (!hicn_ip_address_empty(&connection->remote_addr)) {
+    if (!IS_VALID_ADDRESS(connection->remote_addr)) {
+      ERROR("[hc_connection_validate] Invalid remote_addr specified");
+      return -1;
+    }
+    has_remote_addr = 1;
+  }
+
+  if (connection->remote_port != 0) {
+    if (!IS_VALID_PORT(connection->remote_port)) {
+      ERROR("[hc_connection_validate] Invalid remote_port specified");
+      return -1;
+    }
+    has_remote_port = 1;
+  }
+
+  /* Interface name is optional */
+  int has_key = has_id || has_name;
+  int has_mandatory_attributes = has_type && has_family && has_local_addr &&
+                                 has_local_port && has_remote_addr &&
+                                 has_remote_port;
+  int has_optional_attributes =
+      has_netdevice_type && has_admin_state && has_state;
+  has_optional_attributes = has_optional_attributes && has_priority && has_tags;
+
+  if (allow_partial) {
+    if (has_key && !has_mandatory_attributes && !has_optional_attributes)
+      return 0;
+    else if (has_mandatory_attributes)
+      return 0;
+    else
+      return -1;
+  } else {
+    if (has_key && has_mandatory_attributes) return 0;
+    return -1;
+  }
+}
+
+int _hc_connection_validate(const hc_object_t *object, bool allow_partial) {
+  return hc_connection_validate(&object->connection, allow_partial);
+}
+
+/* CONNECTION CMP */
+
+/*
+ * hICN light uses ports even for hICN connections, but their value is
+ * ignored. As connections are specific to hicn-light, we can safely use IP
+ * and ports for comparison independently of the face type.
+ */
+int hc_connection_cmp(const hc_connection_t *c1, const hc_connection_t *c2) {
+  int rc;
+
+  rc = INT_CMP(c1->type, c2->type);
+  if (rc != 0) return rc;
+
+  rc = INT_CMP(c1->family, c2->family);
+  if (rc != 0) return rc;
+
+  if (!isempty(c1->interface_name) && !isempty(c2->interface_name)) {
+    rc = strncmp(c1->interface_name, c2->interface_name, INTERFACE_LEN);
+    if (rc != 0) return rc;
+  }
+
+  rc = hicn_ip_address_cmp(&c1->local_addr, &c2->local_addr);
+  if (rc != 0) return rc;
+
+  rc = INT_CMP(c1->local_port, c2->local_port);
+  if (rc != 0) return rc;
+
+  rc = hicn_ip_address_cmp(&c1->remote_addr, &c2->remote_addr);
+  if (rc != 0) return rc;
+
+  rc = INT_CMP(c1->remote_port, c2->remote_port);
+
+  return rc;
+}
+
+int _hc_connection_cmp(const hc_object_t *object1, const hc_object_t *object2) {
+  return hc_connection_cmp(&object1->connection, &object2->connection);
+}
+
+int hc_connection_has_valid_id(const hc_connection_t *connection) {
+  return connection->id != INVALID_FACE_ID;
+}
+
+/* CONNECTION SNPRINTF */
+
+/* /!\ Please update constants in header file upon changes */
+int hc_connection_snprintf(char *s, size_t size,
+                           const hc_connection_t *connection) {
+  char local[MAXSZ_URL];
+  char remote[MAXSZ_URL];
+  int rc;
+
+  // assert(connection->connection_state)
+  if (strcmp(connection->name, "SELF") == 0) {
+    return snprintf(s, size, "%s", connection->name);
+  }
+
+  rc = url_snprintf(local, MAXSZ_URL, &connection->local_addr,
+                    connection->local_port);
+  if (rc >= MAXSZ_URL)
+    WARN("[hc_connection_snprintf] Unexpected truncation of URL string");
+  if (rc < 0) return rc;
+  rc = url_snprintf(remote, MAXSZ_URL, &connection->remote_addr,
+                    connection->remote_port);
+  if (rc >= MAXSZ_URL)
+    WARN("[hc_connection_snprintf] Unexpected truncation of URL string");
+  if (rc < 0) return rc;
+
+  return snprintf(s, size, "%s %s %s %s", connection->name, local, remote,
+                  face_type_str(connection->type));
+}
+
+int _hc_connection_snprintf(char *s, size_t size, const hc_object_t *object) {
+  return hc_connection_snprintf(s, size, &object->connection);
+}
+
+int hc_connection_create(hc_sock_t *s, hc_connection_t *connection) {
+  hc_object_t object;
+  memset(&object, 0, sizeof(hc_object_t));
+  object.connection = *connection;
+  return hc_execute(s, ACTION_CREATE, OBJECT_TYPE_CONNECTION, &object, NULL);
+}
+
+int hc_connection_get(hc_sock_t *s, hc_connection_t *connection,
+                      hc_data_t **pdata) {
+  hc_object_t object;
+  memset(&object, 0, sizeof(hc_object_t));
+  object.connection = *connection;
+  return hc_execute(s, ACTION_GET, OBJECT_TYPE_CONNECTION, &object, pdata);
+}
+
+int hc_connection_delete(hc_sock_t *s, hc_connection_t *connection) {
+  hc_object_t object;
+  memset(&object, 0, sizeof(hc_object_t));
+  object.connection = *connection;
+  return hc_execute(s, ACTION_DELETE, OBJECT_TYPE_CONNECTION, &object, NULL);
+}
+
+int hc_connection_list(hc_sock_t *s, hc_data_t **pdata) {
+  return hc_execute(s, ACTION_LIST, OBJECT_TYPE_CONNECTION, NULL, pdata);
+}
+
+int hc_connection_set_admin_state(hc_sock_t *s, const char *conn_id_or_name,
+                                  face_state_t state) {
+  hc_object_t object;
+  memset(&object, 0, sizeof(hc_object_t));
+  int rc = snprintf(object.connection.name, SYMBOLIC_NAME_LEN, "%s",
+                    conn_id_or_name);
+  if (rc < 0 || rc >= SYMBOLIC_NAME_LEN) return -1;
+  object.connection.admin_state = state;
+  return hc_execute(s, ACTION_UPDATE, OBJECT_TYPE_CONNECTION, &object, NULL);
+}
+
+int hc_connection_set_priority(hc_sock_t *s, const char *conn_id_or_name,
+                               uint32_t priority) {
+  hc_object_t object;
+  memset(&object, 0, sizeof(hc_object_t));
+  int rc = snprintf(object.connection.name, SYMBOLIC_NAME_LEN, "%s",
+                    conn_id_or_name);
+  if (rc < 0 || rc >= SYMBOLIC_NAME_LEN) return -1;
+  object.connection.priority = priority;
+  return hc_execute(s, ACTION_UPDATE, OBJECT_TYPE_CONNECTION, &object, NULL);
+}
+
+int hc_connection_set_tags(hc_sock_t *s, const char *conn_id_or_name,
+                           policy_tags_t tags) {
+  hc_object_t object;
+  memset(&object, 0, sizeof(hc_object_t));
+  int rc = snprintf(object.connection.name, SYMBOLIC_NAME_LEN, "%s",
+                    conn_id_or_name);
+  if (rc < 0 || rc >= SYMBOLIC_NAME_LEN) return -1;
+  object.connection.tags = tags;
+  return hc_execute(s, ACTION_UPDATE, OBJECT_TYPE_CONNECTION, &object, NULL);
+}
+
+GENERATE_FIND(connection);
+
+DECLARE_OBJECT_OPS(OBJECT_TYPE_CONNECTION, connection);