TSG-13500 tsg-service-chaining-engine扫描策略

common/src/raw_packet.cpp

@@ -12,6 +12,7 @@
 #include <linux/ppp_defs.h>
 
 #include "log.h"
+#include "uthash.h"
 #include "addr_tuple4.h"
 #include "raw_packet.h"
 
@@ -89,6 +90,8 @@ struct raw_pkt_parser
  * Static API
  ******************************************************************************/
 
+static const char *ldbc_method_to_string(enum ldbc_method ldbc_method);
+
 // parser utils
 static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct addr_tuple4 *addr);
 static const char *layer_type2str(enum layer_type this_type);
@@ -353,10 +356,157 @@ int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, str
     return -1;
 }
 
+uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum ldbc_method method, int dir_is_internal)
+{
+    uint64_t temp = 0;
+    uint64_t hash_value = 1;
+
+    int inner_addr_len = 0;
+    int outer_addr_len = 0;
+    const char *inner_src_addr = NULL;
+    const char *inner_dst_addr = NULL;
+    const char *outer_src_addr = NULL;
+    const char *outer_dst_addr = NULL;
+
+    struct addr_tuple4 inner_addr;
+    struct addr_tuple4 outer_addr;
+    memset(&inner_addr, 0, sizeof(inner_addr));
+    memset(&outer_addr, 0, sizeof(outer_addr));
+
+    if (handler == NULL)
+    {
+        return hash_value;
+    }
+
+    if (raw_packet_parser_get_most_inner_address(handler, &inner_addr) == -1)
+    {
+        return hash_value;
+    }
+
+    if (raw_packet_parser_get_most_outer_address(handler, &outer_addr) == -1)
+    {
+        return hash_value;
+    }
+
+    if (inner_addr.addr_type == ADDR_TUPLE4_TYPE_V4)
+    {
+        inner_src_addr = (const char *)&(inner_addr.addr_v4.src_addr);
+        inner_dst_addr = (const char *)&(inner_addr.addr_v4.dst_addr);
+        inner_addr_len = sizeof(inner_addr.addr_v4.dst_addr);
+    }
+    else
+    {
+        inner_src_addr = (const char *)&(inner_addr.addr_v6.src_addr);
+        inner_dst_addr = (const char *)&(inner_addr.addr_v6.dst_addr);
+        inner_addr_len = sizeof(inner_addr.addr_v6.dst_addr);
+    }
+
+    if (outer_addr.addr_type == ADDR_TUPLE4_TYPE_V4)
+    {
+        outer_src_addr = (const char *)&(outer_addr.addr_v4.src_addr);
+        outer_dst_addr = (const char *)&(outer_addr.addr_v4.dst_addr);
+        outer_addr_len = sizeof(outer_addr.addr_v4.dst_addr);
+    }
+    else
+    {
+        outer_src_addr = (const char *)&(outer_addr.addr_v6.src_addr);
+        outer_dst_addr = (const char *)&(outer_addr.addr_v6.dst_addr);
+        outer_addr_len = sizeof(outer_addr.addr_v6.dst_addr);
+    }
+
+    switch (method)
+    {
+    case LDBC_METHOD_HASH_INT_IP:
+        if (dir_is_internal)
+        {
+            // outer src ip
+            HASH_VALUE(outer_src_addr, outer_addr_len, hash_value);
+        }
+        else
+        {
+            // outer dst ip
+            HASH_VALUE(outer_dst_addr, outer_addr_len, hash_value);
+        }
+        break;
+    case LDBC_METHOD_HASH_EXT_IP:
+        if (dir_is_internal)
+        {
+            // outer dst ip
+            HASH_VALUE(outer_dst_addr, outer_addr_len, hash_value);
+        }
+        else
+        {
+            // outer src ip
+            HASH_VALUE(outer_src_addr, outer_addr_len, hash_value);
+        }
+        break;
+    case LDBC_METHOD_HASH_INT_IP_AND_EXT_IP:
+        // outer dst ip ^ outer src ip
+        HASH_VALUE(outer_src_addr, outer_addr_len, hash_value);
+        HASH_VALUE(outer_dst_addr, outer_addr_len, temp);
+        hash_value = hash_value ^ temp;
+        break;
+    case LDBC_METHOD_HASH_INNERMOST_INT_IP:
+        if (dir_is_internal)
+        {
+            // innner src ip
+            HASH_VALUE(inner_src_addr, inner_addr_len, hash_value);
+        }
+        else
+        {
+            // innner dst ip
+            HASH_VALUE(inner_dst_addr, inner_addr_len, hash_value);
+        }
+        break;
+    case LDBC_METHOD_HASH_INNERMOST_EXT_IP:
+        if (dir_is_internal)
+        {
+            // innner dst ip
+            HASH_VALUE(inner_dst_addr, inner_addr_len, hash_value);
+        }
+        else
+        {
+            // innner src ip
+            HASH_VALUE(inner_src_addr, inner_addr_len, hash_value);
+        }
+        break;
+    default:
+        return hash_value;
+    }
+
+    char *inner_addr_str = addr_tuple4_to_str(&inner_addr);
+    char *outer_addr_str = addr_tuple4_to_str(&outer_addr);
+    LOG_ERROR("%s: pkt_trace_id: %lu, outer_addr: %s, inner_addr: %s, is_internal: %d, hash_method: %s, hash_value: %lu",
+              LOG_TAG, handler->pkt_trace_id, outer_addr_str, inner_addr_str, dir_is_internal, ldbc_method_to_string(method), hash_value);
+    free(inner_addr_str);
+    free(outer_addr_str);
+
+    return hash_value;
+}
+
 /******************************************************************************
  * Private API
  ******************************************************************************/
 
+static const char *ldbc_method_to_string(enum ldbc_method ldbc_method)
+{
+    switch (ldbc_method)
+    {
+    case LDBC_METHOD_HASH_INT_IP:
+        return "outter_internal_ip";
+    case LDBC_METHOD_HASH_EXT_IP:
+        return "outter_external_ip";
+    case LDBC_METHOD_HASH_INT_IP_AND_EXT_IP:
+        return "outter_internal_ip_and_external_ip";
+    case LDBC_METHOD_HASH_INNERMOST_INT_IP:
+        return "inner_internal_ip";
+    case LDBC_METHOD_HASH_INNERMOST_EXT_IP:
+        return "inner_external_ip";
+    default:
+        return "unknown";
+    }
+}
+
 static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct addr_tuple4 *addr)
 {
     const struct tcphdr *tcp_hdr = NULL;

common/src/utils.cpp

@@ -0,0 +1,63 @@
+#include <string.h>
+#include <assert.h>
+
+#include "utils.h"
+#include "log.h"
+
+void fixed_num_array_init(struct fixed_num_array *array)
+{
+    memset(array, 0, sizeof(fixed_num_array));
+    array->num = 0;
+    array->size = sizeof(array->elems) / sizeof(array->elems[0]);
+}
+
+void fixed_num_array_add_elem(struct fixed_num_array *array, int elem)
+{
+    if (array->num < array->size)
+    {
+        array->elems[array->num] = elem;
+        array->num++;
+    }
+    else
+    {
+        LOG_ERROR("%s: fixed num array add elem too much !!!", LOG_TAG_UTILS);
+    }
+}
+
+void fixed_num_array_del_elem(struct fixed_num_array *array, int elem)
+{
+    for (int i = 0; i < array->num; i++)
+    {
+        if (array->elems[i] == elem)
+        {
+            if (i + 1 != array->size)
+            {
+                memmove(&(array->elems[i]), &(array->elems[i + 1]), sizeof(array->elems[0]) * (array->num - i - 1));
+            }
+            i--;
+            array->num--;
+        }
+    }
+}
+
+int fixed_num_array_count_elem(struct fixed_num_array *array)
+{
+    if (array)
+    {
+        return array->num;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+int fixed_num_array_index_elem(struct fixed_num_array *array, int index)
+{
+    if (index >= array->num)
+    {
+        assert(0);
+    }
+
+    return array->elems[index];
+}