diff options
Diffstat (limited to 'hicn-light')
69 files changed, 3526 insertions, 508 deletions
diff --git a/hicn-light/CMakeLists.txt b/hicn-light/CMakeLists.txt index 5637c1dbb..31d189a3b 100644 --- a/hicn-light/CMakeLists.txt +++ b/hicn-light/CMakeLists.txt @@ -54,7 +54,6 @@ find_package_wrapper(Libparc REQUIRED) if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR) find_package_wrapper(Libhicn REQUIRED) - find_package_wrapper(Libparc REQUIRED) set(HICN_LIGHT hicn-light) set(HICN_LIGHT_CONTROL ${HICN_LIGHT}-control) set(HICN_LIGHT_DAEMON ${HICN_LIGHT}-daemon) @@ -108,4 +107,4 @@ if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang") message(STATUS "Set \"-undefined dynamic_lookup\" for shared libraries") endif() -add_subdirectory(src/hicn)
\ No newline at end of file +add_subdirectory(src/hicn) diff --git a/hicn-light/src/hicn/CMakeLists.txt b/hicn-light/src/hicn/CMakeLists.txt index a9861c32d..0f711e353 100644 --- a/hicn-light/src/hicn/CMakeLists.txt +++ b/hicn-light/src/hicn/CMakeLists.txt @@ -3,6 +3,18 @@ include(BuildMacros) configure_file(config.h.in hicn-light/config.h @ONLY) +if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux" AND ENABLE_PUNTING) + list(APPEND COMPILER_DEFINITIONS + "-DPUNTING" + ) +endif() + +list(APPEND COMPILER_DEFINITIONS + "-DWITH_MAPME" + "-DWITH_POLICY" +) + + if(NOT ANDROID_API AND NOT COMPILE_FOR_IOS) add_subdirectory(command_line) endif () @@ -22,16 +34,6 @@ list(APPEND HEADER_FILES ${CMAKE_CURRENT_BINARY_DIR}/hicn-light/config.h ) -if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux" AND ENABLE_PUNTING) - list(APPEND COMPILER_DEFINITIONS - "-DPUNTING" - ) -endif() - -list(APPEND COMPILER_DEFINITIONS - "-DWITH_MAPME -DWITH_MAPME_FIXES" -) - list(INSERT HICN_LIGHT_INCLUDE_DIRS 0 ${CMAKE_CURRENT_SOURCE_DIR}/.. ${CMAKE_CURRENT_BINARY_DIR}/.. @@ -41,6 +43,9 @@ list(APPEND TO_INSTALL_HEADER_FILES ${CMAKE_CURRENT_BINARY_DIR}/hicn-light/config.h ) +set(TO_INSTALL_HEADER_FILES +) + if (ANDROID_API) build_library(${LIBHICN_LIGHT} STATIC diff --git a/hicn-light/src/hicn/command_line/controller/CMakeLists.txt b/hicn-light/src/hicn/command_line/controller/CMakeLists.txt index c0a584dae..405654052 100644 --- a/hicn-light/src/hicn/command_line/controller/CMakeLists.txt +++ b/hicn-light/src/hicn/command_line/controller/CMakeLists.txt @@ -20,4 +20,5 @@ build_executable(${HICN_LIGHT_CONTROL} LINK_LIBRARIES ${HICN_LIGHT_LINK_LIBRARIES} DEPENDS ${LIBHICN_LIGHT_STATIC} COMPONENT ${HICN_LIGHT} + DEFINITIONS ${COMPILER_DEFINITIONS} ) diff --git a/hicn-light/src/hicn/command_line/controller/hicnLightControl_main.c b/hicn-light/src/hicn/command_line/controller/hicnLightControl_main.c index 8cbccde34..f704d237e 100644 --- a/hicn-light/src/hicn/command_line/controller/hicnLightControl_main.c +++ b/hicn-light/src/hicn/command_line/controller/hicnLightControl_main.c @@ -74,7 +74,15 @@ static int payloadLengthController[LAST_COMMAND_VALUE] = { sizeof(mapme_activator_command), sizeof(mapme_activator_command), sizeof(mapme_timing_command), - sizeof(mapme_timing_command)}; + sizeof(mapme_timing_command), + sizeof(connection_set_admin_state_command), +#ifdef WITH_POLICY + sizeof(add_policy_command), + sizeof(list_policies_command), + sizeof(remove_policy_command), + sizeof(update_connection_command), +#endif +}; typedef struct controller_main_state { ControlState *controlState; @@ -320,9 +328,11 @@ int main(int argc, char *argv[]) { char **commandOutputMain = controlState_GetCommandOutput(mainState.controlState); if (commandOutputMain != NULL && commandOutputLen > 0) { +#if 0 for (size_t j = 0; j < commandOutputLen; j++) { printf("Output %zu: %s \n", j, commandOutputMain[j]); } +#endif controlState_ReleaseCommandOutput(mainState.controlState, commandOutputMain, commandOutputLen); } diff --git a/hicn-light/src/hicn/command_line/daemon/CMakeLists.txt b/hicn-light/src/hicn/command_line/daemon/CMakeLists.txt index ca8c02ef0..ff9d31ebc 100644 --- a/hicn-light/src/hicn/command_line/daemon/CMakeLists.txt +++ b/hicn-light/src/hicn/command_line/daemon/CMakeLists.txt @@ -20,4 +20,5 @@ build_executable(${HICN_LIGHT_DAEMON} LINK_LIBRARIES ${HICN_LIGHT_LINK_LIBRARIES} DEPENDS ${LIBHICN_LIGHT_STATIC} COMPONENT ${HICN_LIGHT} -)
\ No newline at end of file + DEFINITIONS ${COMPILER_DEFINITIONS} +) diff --git a/hicn-light/src/hicn/config/CMakeLists.txt b/hicn-light/src/hicn/config/CMakeLists.txt index 5ce680bfc..b1e475aee 100644 --- a/hicn-light/src/hicn/config/CMakeLists.txt +++ b/hicn-light/src/hicn/config/CMakeLists.txt @@ -26,15 +26,18 @@ list(APPEND HEADER_FILES ${CMAKE_CURRENT_SOURCE_DIR}/configurationFile.h ${CMAKE_CURRENT_SOURCE_DIR}/configurationListeners.h ${CMAKE_CURRENT_SOURCE_DIR}/controlAddRoute.h + ${CMAKE_CURRENT_SOURCE_DIR}/controlAddPolicy.h ${CMAKE_CURRENT_SOURCE_DIR}/controlAddListener.h ${CMAKE_CURRENT_SOURCE_DIR}/controlListConnections.h ${CMAKE_CURRENT_SOURCE_DIR}/controlList.h ${CMAKE_CURRENT_SOURCE_DIR}/controlListListeners.h ${CMAKE_CURRENT_SOURCE_DIR}/controlListRoutes.h + ${CMAKE_CURRENT_SOURCE_DIR}/controlListPolicies.h ${CMAKE_CURRENT_SOURCE_DIR}/controlQuit.h ${CMAKE_CURRENT_SOURCE_DIR}/controlRemove.h ${CMAKE_CURRENT_SOURCE_DIR}/controlRemoveConnection.h ${CMAKE_CURRENT_SOURCE_DIR}/controlRemoveRoute.h + ${CMAKE_CURRENT_SOURCE_DIR}/controlRemovePolicy.h ${CMAKE_CURRENT_SOURCE_DIR}/controlSet.h ${CMAKE_CURRENT_SOURCE_DIR}/controlUnset.h ${CMAKE_CURRENT_SOURCE_DIR}/controlSetDebug.h @@ -51,6 +54,8 @@ list(APPEND HEADER_FILES ${CMAKE_CURRENT_SOURCE_DIR}/controlSetWldr.h ${CMAKE_CURRENT_SOURCE_DIR}/controlAddPunting.h ${CMAKE_CURRENT_SOURCE_DIR}/controlRemovePunting.h + ${CMAKE_CURRENT_SOURCE_DIR}/controlUpdate.h + ${CMAKE_CURRENT_SOURCE_DIR}/controlUpdateConnection.h ) list(APPEND SOURCE_FILES @@ -64,15 +69,18 @@ list(APPEND SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/controlAdd.c ${CMAKE_CURRENT_SOURCE_DIR}/controlAddConnection.c ${CMAKE_CURRENT_SOURCE_DIR}/controlAddRoute.c + ${CMAKE_CURRENT_SOURCE_DIR}/controlAddPolicy.c ${CMAKE_CURRENT_SOURCE_DIR}/controlAddListener.c ${CMAKE_CURRENT_SOURCE_DIR}/controlList.c ${CMAKE_CURRENT_SOURCE_DIR}/controlListConnections.c ${CMAKE_CURRENT_SOURCE_DIR}/controlListListeners.c ${CMAKE_CURRENT_SOURCE_DIR}/controlListRoutes.c + ${CMAKE_CURRENT_SOURCE_DIR}/controlListPolicies.c ${CMAKE_CURRENT_SOURCE_DIR}/controlQuit.c ${CMAKE_CURRENT_SOURCE_DIR}/controlRemove.c ${CMAKE_CURRENT_SOURCE_DIR}/controlRemoveConnection.c ${CMAKE_CURRENT_SOURCE_DIR}/controlRemoveRoute.c + ${CMAKE_CURRENT_SOURCE_DIR}/controlRemovePolicy.c ${CMAKE_CURRENT_SOURCE_DIR}/controlRoot.c ${CMAKE_CURRENT_SOURCE_DIR}/controlSet.c ${CMAKE_CURRENT_SOURCE_DIR}/controlSetDebug.c @@ -91,7 +99,9 @@ list(APPEND SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/controlSetWldr.c ${CMAKE_CURRENT_SOURCE_DIR}/controlAddPunting.c ${CMAKE_CURRENT_SOURCE_DIR}/controlRemovePunting.c + ${CMAKE_CURRENT_SOURCE_DIR}/controlUpdate.c + ${CMAKE_CURRENT_SOURCE_DIR}/controlUpdateConnection.c ) set(SOURCE_FILES ${SOURCE_FILES} PARENT_SCOPE) -set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE)
\ No newline at end of file +set(HEADER_FILES ${HEADER_FILES} PARENT_SCOPE) diff --git a/hicn-light/src/hicn/config/configuration.c b/hicn-light/src/hicn/config/configuration.c index 07120f95b..182c2fdc1 100644 --- a/hicn-light/src/hicn/config/configuration.c +++ b/hicn-light/src/hicn/config/configuration.c @@ -356,8 +356,8 @@ struct iovec *configuration_ProcessCreateTunnel(Configuration *config, add_connection_command *control = request[1].iov_base; bool success = false; - bool exists = true; + Connection *conn; const char *symbolicName = control->symbolic; Address *source = NULL; @@ -379,18 +379,15 @@ struct iovec *configuration_ProcessCreateTunnel(Configuration *config, } AddressPair *pair = addressPair_Create(source, destination); - const Connection *conn = connectionTable_FindByAddressPair( + conn = (Connection *)connectionTable_FindByAddressPair( forwarder_GetConnectionTable(config->forwarder), pair); addressPair_Release(&pair); - - if (conn == NULL) { - // the connection does not exists (even without a name) - exists = false; - } + } else { + conn = NULL; } - if (!exists) { + if (!conn) { IoOperations *ops = NULL; switch (control->connectionType) { case TCP_CONN: @@ -420,6 +417,9 @@ struct iovec *configuration_ProcessCreateTunnel(Configuration *config, if (ops != NULL) { Connection *conn = connection_Create(ops); +#ifdef WITH_POLICY + connection_SetTags(conn, control->tags); +#endif /* WITH_POLICY */ connection_SetAdminState(conn, control->admin_state); @@ -428,6 +428,11 @@ struct iovec *configuration_ProcessCreateTunnel(Configuration *config, symbolicNameTable_Add(config->symbolicNameTable, symbolicName, connection_GetConnectionId(conn)); +#ifdef WITH_MAPME + /* Hook: new connection created through the control protocol */ + forwarder_onConnectionEvent(config->forwarder, conn, CONNECTION_EVENT_CREATE); +#endif /* WITH_MAPME */ + success = true; } else { @@ -435,23 +440,31 @@ struct iovec *configuration_ProcessCreateTunnel(Configuration *config, } } else { - printf("failed, symbolic name or connextion already exist\n"); - } +#ifdef WITH_POLICY + connection_SetTags(conn, control->tags); + connection_SetAdminState(conn, control->admin_state); - addressDestroy(&source); - addressDestroy(&destination); +#ifdef WITH_MAPME + /* Hook: new connection created through the control protocol */ + forwarder_onConnectionEvent(config->forwarder, conn, CONNECTION_EVENT_UPDATE); +#endif /* WITH_MAPME */ - // generate ACK/NACK - struct iovec *response; + success = true; +#else + printf("failed, symbolic name or connection already exist\n"); +#endif /* WITH_POLICY */ + } + + if (source) + addressDestroy(&source); + if (destination) + addressDestroy(&destination); if (success) { // ACK - response = utils_CreateAck(header, control, sizeof(add_connection_command)); + return utils_CreateAck(header, control, sizeof(add_connection_command)); } else { // NACK - response = - utils_CreateNack(header, control, sizeof(add_connection_command)); + return utils_CreateNack(header, control, sizeof(add_connection_command)); } - - return response; } /** @@ -479,6 +492,12 @@ struct iovec *configuration_ProcessRemoveTunnel(Configuration *config, if (strcmp(symbolicOrConnid, "SELF") == 0) { forwarder_RemoveConnectionIdFromRoutes(config->forwarder, ingressId); connectionTable_RemoveById(table, ingressId); + +#ifdef WITH_MAPME + /* Hook: new connection created through the control protocol */ + forwarder_onConnectionEvent(config->forwarder, NULL, CONNECTION_EVENT_DELETE); +#endif /* WITH_MAPME */ + success = true; } else if (utils_IsNumber(symbolicOrConnid)) { // case for connid as input @@ -492,6 +511,11 @@ struct iovec *configuration_ProcessRemoveTunnel(Configuration *config, // remove connection connectionTable_RemoveById(table, connid); +#ifdef WITH_MAPME + /* Hook: new connection created through the control protocol */ + forwarder_onConnectionEvent(config->forwarder, NULL, CONNECTION_EVENT_DELETE); +#endif /* WITH_MAPME */ + success = true; } else { logger_Log(forwarder_GetLogger(config->forwarder), LoggerFacility_IO, @@ -520,6 +544,12 @@ struct iovec *configuration_ProcessRemoveTunnel(Configuration *config, connectionTable_RemoveById(table, connid); // remove connection from symbolicNameTable since we have symbolic input symbolicNameTable_Remove(config->symbolicNameTable, symbolicOrConnid); + +#ifdef WITH_MAPME + /* Hook: new connection created through the control protocol */ + forwarder_onConnectionEvent(config->forwarder, NULL, CONNECTION_EVENT_DELETE); +#endif /* WITH_MAPME */ + success = true; // to write } else { if (logger_IsLoggable(config->logger, LoggerFacility_Config, @@ -580,6 +610,10 @@ struct iovec *configuration_ProcessConnectionList(Configuration *config, listConnectionsCommand->connectionData.admin_state = connection_GetAdminState(original); +#ifdef WITH_POLICY + listConnectionsCommand->connectionData.tags = connection_GetTags(original); +#endif /* WITH_POLICY */ + if (addressGetType(localAddress) == ADDR_INET && addressGetType(remoteAddress) == ADDR_INET) { listConnectionsCommand->connectionData.ipType = ADDR_INET; @@ -1017,15 +1051,119 @@ struct iovec *configuration_ConnectionSetAdminState(Configuration *config, header_control_message *header = request[0].iov_base; connection_set_admin_state_command *control = request[1].iov_base; + if ((control->admin_state != CONNECTION_STATE_UP) && (control->admin_state != CONNECTION_STATE_DOWN)) + return utils_CreateNack(header, control, sizeof(connection_set_admin_state_command)); + Connection * conn = getConnectionBySymbolicOrId(config, control->symbolicOrConnid); if (!conn) return utils_CreateNack(header, control, sizeof(connection_set_admin_state_command)); connection_SetAdminState(conn, control->admin_state); +#ifdef WITH_MAPME + /* Hook: new connection created through the control protocol */ + forwarder_onConnectionEvent(config->forwarder, conn, + control->admin_state == CONNECTION_STATE_UP + ? CONNECTION_EVENT_SET_UP + : CONNECTION_EVENT_SET_DOWN); +#endif /* WITH_MAPME */ + return utils_CreateAck(header, control, sizeof(connection_set_admin_state_command)); } +#ifdef WITH_POLICY +struct iovec *configuration_ProcessPolicyAdd(Configuration *config, + struct iovec *request) { + header_control_message *header = request[0].iov_base; + add_policy_command *control = request[1].iov_base; + + if (forwarder_AddOrUpdatePolicy(config->forwarder, control)) { + return utils_CreateAck(header, control, sizeof(add_policy_command)); + } else { + return utils_CreateNack(header, control, sizeof(add_policy_command)); + } +} + +struct iovec *configuration_ProcessPolicyList(Configuration *config, + struct iovec *request) { + FibEntryList *fibList = forwarder_GetFibEntries(config->forwarder); + + size_t payloadSize = fibEntryList_Length(fibList); + struct sockaddr_in tmpAddr; + struct sockaddr_in6 tmpAddr6; + + // allocate payload, cast from void* to uint8_t* = bytes granularity + uint8_t *payloadResponse = + parcMemory_AllocateAndClear(sizeof(list_policies_command) * payloadSize); + + for (size_t i = 0; i < fibEntryList_Length(fibList); i++) { + FibEntry *entry = (FibEntry *)fibEntryList_Get(fibList, i); + NameBitvector *prefix = name_GetContentName(fibEntry_GetPrefix(entry)); + + list_policies_command *listPoliciesCommand = + (list_policies_command *)(payloadResponse + + (i * sizeof(list_policies_command))); + + Address *addressEntry = nameBitvector_ToAddress(prefix); + if (addressGetType(addressEntry) == ADDR_INET) { + addressGetInet(addressEntry, &tmpAddr); + listPoliciesCommand->addressType = ADDR_INET; + listPoliciesCommand->address.ipv4 = tmpAddr.sin_addr.s_addr; + } else if (addressGetType(addressEntry) == ADDR_INET6) { + addressGetInet6(addressEntry, &tmpAddr6); + listPoliciesCommand->addressType = ADDR_INET6; + listPoliciesCommand->address.ipv6 = tmpAddr6.sin6_addr; + } + listPoliciesCommand->len = nameBitvector_GetLength(prefix); + listPoliciesCommand->policy = fibEntry_GetPolicy(entry); + + addressDestroy(&addressEntry); + } + + // send response + header_control_message *header = request[0].iov_base; + header->messageType = RESPONSE_LIGHT; + header->length = (unsigned)payloadSize; + + struct iovec *response = + parcMemory_AllocateAndClear(sizeof(struct iovec) * 2); + + response[0].iov_base = header; + response[0].iov_len = sizeof(header_control_message); + response[1].iov_base = payloadResponse; + response[1].iov_len = sizeof(list_policies_command) * payloadSize; + + fibEntryList_Destroy(&fibList); + return response; +} + +struct iovec *configuration_ProcessPolicyRemove(Configuration *config, + struct iovec *request) { + header_control_message *header = request[0].iov_base; + remove_policy_command *control = request[1].iov_base; + + if (forwarder_RemovePolicy(config->forwarder, control)) + return utils_CreateAck(header, control, sizeof(remove_policy_command)); + else + return utils_CreateNack(header, control, sizeof(remove_policy_command)); +} + +struct iovec *configuration_UpdateConnection(Configuration *config, + struct iovec *request) { + header_control_message *header = request[0].iov_base; + update_connection_command *control = request[1].iov_base; + + Connection * conn = getConnectionBySymbolicOrId(config, control->symbolicOrConnid); + if (!conn) + return utils_CreateNack(header, control, sizeof(connection_set_admin_state_command)); + + connection_SetTags(conn, control->tags); + connection_SetAdminState(conn, control->admin_state); + + return utils_CreateAck(header, control, sizeof(remove_policy_command)); +} +#endif /* WITH_POLICY */ + // =========================== // Main functions that deal with receiving commands, executing them, and sending // ACK/NACK @@ -1114,6 +1252,24 @@ struct iovec *configuration_DispatchCommand(Configuration *config, response = configuration_ConnectionSetAdminState(config, control); break; +#ifdef WITH_POLICY + case ADD_POLICY: + response = configuration_ProcessPolicyAdd(config, control); + break; + + case LIST_POLICIES: + response = configuration_ProcessPolicyList(config, control); + break; + + case REMOVE_POLICY: + response = configuration_ProcessPolicyRemove(config, control); + break; + + case UPDATE_CONNECTION: + response = configuration_UpdateConnection(config, control); + break; +#endif /* WITH_POLICY */ + default: break; } diff --git a/hicn-light/src/hicn/config/controlAdd.c b/hicn-light/src/hicn/config/controlAdd.c index 7667f467e..519e11e40 100644 --- a/hicn-light/src/hicn/config/controlAdd.c +++ b/hicn-light/src/hicn/config/controlAdd.c @@ -28,6 +28,9 @@ #include <hicn/config/controlAddListener.h> #include <hicn/config/controlAddPunting.h> #include <hicn/config/controlAddRoute.h> +#ifdef WITH_POLICY +#include <hicn/config/controlAddPolicy.h> +#endif /* WITH_POLICY */ // =================================================== @@ -60,18 +63,27 @@ static CommandReturn _controlAdd_HelpExecute(CommandParser *parser, CommandOps *ops_add_route = controlAddRoute_Create(NULL); CommandOps *ops_add_punting = controlAddPunting_Create(NULL); CommandOps *ops_add_listener = controlAddListener_Create(NULL); +#ifdef WITH_POLICY + CommandOps *ops_add_policy = controlAddPolicy_Create(NULL); +#endif /* WITH_POLICY */ printf("Available commands:\n"); printf(" %s\n", ops_add_connection->command); printf(" %s\n", ops_add_route->command); printf(" %s\n", ops_add_punting->command); printf(" %s\n", ops_add_listener->command); +#ifdef WITH_POLICIES + printf(" %s\n", ops_add_policy->command); +#endif /* WITH_POLICIES */ printf("\n"); commandOps_Destroy(&ops_add_connection); commandOps_Destroy(&ops_add_route); commandOps_Destroy(&ops_add_punting); commandOps_Destroy(&ops_add_listener); +#ifdef WITH_POLICY + commandOps_Destroy(&ops_add_policy); +#endif /* WITH_POLICY */ return CommandReturn_Success; } @@ -85,6 +97,10 @@ static void _controlAdd_Init(CommandParser *parser, CommandOps *ops) { controlState_RegisterCommand(state, controlAddRoute_Create(state)); controlState_RegisterCommand(state, controlAddPunting_Create(state)); controlState_RegisterCommand(state, controlAddPunting_HelpCreate(state)); +#ifdef WITH_POLICY + controlState_RegisterCommand(state, controlAddPolicy_HelpCreate(state)); + controlState_RegisterCommand(state, controlAddPolicy_Create(state)); +#endif /* WITH_POLICY */ } static CommandReturn _controlAdd_Execute(CommandParser *parser, CommandOps *ops, diff --git a/hicn-light/src/hicn/config/controlAddPolicy.c b/hicn-light/src/hicn/config/controlAddPolicy.c new file mode 100644 index 000000000..9bca3355e --- /dev/null +++ b/hicn-light/src/hicn/config/controlAddPolicy.c @@ -0,0 +1,175 @@ +/* + * 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. + */ + +#ifdef WITH_POLICY + +#include <hicn/hicn-light/config.h> + +#include <ctype.h> +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> + +#include <parc/assert/parc_Assert.h> + +#include <parc/algol/parc_Memory.h> +#include <parc/algol/parc_Network.h> + +#include <hicn/config/controlAddPolicy.h> + +#include <hicn/utils/commands.h> +#include <hicn/utils/utils.h> +#include <hicn/utils/token.h> + +static CommandReturn _controlAddPolicy_Execute(CommandParser *parser, + CommandOps *ops, PARCList *args); +static CommandReturn _controlAddPolicy_HelpExecute(CommandParser *parser, + CommandOps *ops, + PARCList *args); + +static const char *_commandAddPolicy = "add policy"; +static const char *_commandAddPolicyHelp = "help add policy"; + +CommandOps *controlAddPolicy_Create(ControlState *state) { + return commandOps_Create(state, _commandAddPolicy, NULL, + _controlAddPolicy_Execute, commandOps_Destroy); +} + +CommandOps *controlAddPolicy_HelpCreate(ControlState *state) { + return commandOps_Create(state, _commandAddPolicyHelp, NULL, + _controlAddPolicy_HelpExecute, commandOps_Destroy); +} + +// ==================================================== + +static CommandReturn _controlAddPolicy_HelpExecute(CommandParser *parser, + CommandOps *ops, + PARCList *args) { + printf("commands:\n"); + printf(" add policy <prefix> <app_name>" + #define _(x, y) " FLAG:%s" + foreach_policy_tag + #undef _ + "%s", + #define _(x, y) policy_tag_str[POLICY_TAG_ ## x], + foreach_policy_tag + #undef _ + "\n"); + printf("\n"); + printf( + " prefix: The hicn name as IPv4 or IPv6 address (e.g 1234::0/64)\n"); + printf(" app_name: The application name associated to this policy\n"); + printf(" FLAG:*: A value among [neutral|require|prefer|avoid|prohibit] with an optional '!' character prefix for disabling changes\n"); + printf("\n"); + return CommandReturn_Success; +} + +static CommandReturn _controlAddPolicy_Execute(CommandParser *parser, + CommandOps *ops, PARCList *args) { + ControlState *state = ops->closure; + + if (parcList_Size(args) != 11) { + _controlAddPolicy_HelpExecute(parser, ops, args); + return CommandReturn_Failure; + } + + const char *prefixStr = parcList_GetAtIndex(args, 2); + char *addr = (char *)malloc((strlen(prefixStr) + 1) * sizeof(char)); + + // separate address and len + char *slash; + uint32_t len = 0; + strcpy(addr, prefixStr); + slash = strrchr(addr, '/'); + if (slash != NULL) { + len = atoi(slash + 1); + *slash = '\0'; + } + + // allocate command payload + add_policy_command *addPolicyCommand = + parcMemory_AllocateAndClear(sizeof(add_policy_command)); + + // check and set IP address + if (inet_pton(AF_INET, addr, &addPolicyCommand->address.ipv4) == 1) { + if (len > 32) { + printf("ERROR: exceeded INET mask length, max=32\n"); + parcMemory_Deallocate(&addPolicyCommand); + free(addr); + return CommandReturn_Failure; + } + addPolicyCommand->addressType = ADDR_INET; + } else if (inet_pton(AF_INET6, addr, &addPolicyCommand->address.ipv6) == 1) { + if (len > 128) { + printf("ERROR: exceeded INET6 mask length, max=128\n"); + parcMemory_Deallocate(&addPolicyCommand); + free(addr); + return CommandReturn_Failure; + } + addPolicyCommand->addressType = ADDR_INET6; + } else { + printf("Error: %s is not a valid network address \n", addr); + parcMemory_Deallocate(&addPolicyCommand); + free(addr); + return CommandReturn_Failure; + } + + free(addr); + + addPolicyCommand->len = len; + + policy_t policy; + snprintf((char*)policy.app_name, APP_NAME_LEN, "%s", (char*)parcList_GetAtIndex(args, 3)); + for (int i=4; i < 11; i++) { + const char *tag = parcList_GetAtIndex(args, i); + policy_tag_state_t tag_state; + tag_state.disabled = (tag[0] == '!') ? 1 : 0; + if (strcmp(&tag[tag_state.disabled], "neutral") == 0) { + tag_state.state = POLICY_STATE_NEUTRAL; + } else if (strcmp(&tag[tag_state.disabled], "require") == 0) { + tag_state.state = POLICY_STATE_REQUIRE; + } else if (strcmp(&tag[tag_state.disabled], "prefer") == 0) { + tag_state.state = POLICY_STATE_PREFER; + } else if (strcmp(&tag[tag_state.disabled], "avoid") == 0) { + tag_state.state = POLICY_STATE_AVOID; + } else if (strcmp(&tag[tag_state.disabled], "prohibit") == 0) { + tag_state.state = POLICY_STATE_PROHIBIT; + } else { + printf("ERROR: invalid tag value '%s'\n", tag); + parcMemory_Deallocate(&addPolicyCommand); + free(addr); + return CommandReturn_Failure; + } + + policy.tags[i-4] = tag_state; + + } + + addPolicyCommand->policy = policy; + + // send message and receive response + struct iovec *response = utils_SendRequest(state, ADD_POLICY, addPolicyCommand, + sizeof(add_policy_command)); + + if (!response) { // get NULL pointer + return CommandReturn_Failure; + } + + parcMemory_Deallocate(&response); // free iovec pointer + return CommandReturn_Success; +} + +#endif /* WITH_POLICY */ diff --git a/hicn-light/src/hicn/config/controlAddPolicy.h b/hicn-light/src/hicn/config/controlAddPolicy.h new file mode 100644 index 000000000..273e3a476 --- /dev/null +++ b/hicn-light/src/hicn/config/controlAddPolicy.h @@ -0,0 +1,35 @@ +/* + * 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. + */ + +/** + * @file control_AddPolicy.h + * @brief Add a static policy + * + * Implements the "add policy" node of the CLI tree + * + */ + +#ifndef Control_AddPolicy_h +#define Control_AddPolicy_h + +#ifdef WITH_POLICY + +#include <hicn/config/controlState.h> +CommandOps *controlAddPolicy_Create(ControlState *state); +CommandOps *controlAddPolicy_HelpCreate(ControlState *state); + +#endif /* WITH_POLICY */ + +#endif // Control_AddPolicy_h diff --git a/hicn-light/src/hicn/config/controlAddPunting.c b/hicn-light/src/hicn/config/controlAddPunting.c index 61308b33b..ff441f7f0 100644 --- a/hicn-light/src/hicn/config/controlAddPunting.c +++ b/hicn-light/src/hicn/config/controlAddPunting.c @@ -104,12 +104,6 @@ static CommandReturn _controlAddPunting_Execute(CommandParser *parser, *slash = '\0'; } - if (len == 0) { - printf("ERROR: a prefix can not be of length 0\n"); - free(addr); - return CommandReturn_Failure; - } - // allocate command payload add_punting_command *addPuntingCommand = parcMemory_AllocateAndClear(sizeof(add_punting_command)); diff --git a/hicn-light/src/hicn/config/controlAddRoute.c b/hicn-light/src/hicn/config/controlAddRoute.c index d7847f837..086cf3a2b 100644 --- a/hicn-light/src/hicn/config/controlAddRoute.c +++ b/hicn-light/src/hicn/config/controlAddRoute.c @@ -108,12 +108,6 @@ static CommandReturn _controlAddRoute_Execute(CommandParser *parser, *slash = '\0'; } - if (len == 0) { - printf("ERROR: a prefix can not be of length 0\n"); - free(addr); - return CommandReturn_Failure; - } - // allocate command payload add_route_command *addRouteCommand = parcMemory_AllocateAndClear(sizeof(add_route_command)); diff --git a/hicn-light/src/hicn/config/controlList.c b/hicn-light/src/hicn/config/controlList.c index 8ec47ad23..c45f05428 100644 --- a/hicn-light/src/hicn/config/controlList.c +++ b/hicn-light/src/hicn/config/controlList.c @@ -31,6 +31,9 @@ //#include <hicn/config/controlListInterfaces.h> #include <hicn/config/controlListListeners.h> #include <hicn/config/controlListRoutes.h> +#ifdef WITH_POLICY +#include <hicn/config/controlListPolicies.h> +#endif /* WITH_POLICY */ static void _controlList_Init(CommandParser *parser, CommandOps *ops); static CommandReturn _controlList_Execute(CommandParser *parser, @@ -59,18 +62,27 @@ static CommandReturn _controlList_HelpExecute(CommandParser *parser, // CommandOps *ops_list_interfaces = controlListInterfaces_HelpCreate(NULL); CommandOps *ops_list_routes = controlListRoutes_HelpCreate(NULL); CommandOps *ops_list_listeners = controlListListeners_HelpCreate(NULL); +#ifdef WITH_POLICY + CommandOps *ops_list_policies = controlListPolicies_HelpCreate(NULL); +#endif /* WITH_POLICY */ printf("Available commands:\n"); printf(" %s\n", ops_list_connections->command); // printf(" %s\n", ops_list_interfaces->command); printf(" %s\n", ops_list_routes->command); printf(" %s\n", ops_list_listeners->command); +#ifdef WITH_POLICY + printf(" %s\n", ops_list_policies->command); +#endif /* WITH_POLICY */ printf("\n"); commandOps_Destroy(&ops_list_connections); // commandOps_Destroy(&ops_list_interfaces); commandOps_Destroy(&ops_list_routes); commandOps_Destroy(&ops_list_listeners); +#ifdef WITH_POLICY + commandOps_Destroy(&ops_list_policies); +#endif /* WITH_POLICY */ return CommandReturn_Success; } @@ -86,6 +98,10 @@ static void _controlList_Init(CommandParser *parser, CommandOps *ops) { // controlState_RegisterCommand(state, controlListInterfaces_Create(state)); controlState_RegisterCommand(state, controlListRoutes_Create(state)); controlState_RegisterCommand(state, controlListListeners_Create(state)); +#ifdef WITH_POLICY + controlState_RegisterCommand(state, controlListPolicies_HelpCreate(state)); + controlState_RegisterCommand(state, controlListPolicies_Create(state)); +#endif /* WITH_POLICY */ } static CommandReturn _controlList_Execute(CommandParser *parser, diff --git a/hicn-light/src/hicn/config/controlListConnections.c b/hicn-light/src/hicn/config/controlListConnections.c index f94a1e7ca..0eb6392ea 100644 --- a/hicn-light/src/hicn/config/controlListConnections.c +++ b/hicn-light/src/hicn/config/controlListConnections.c @@ -82,6 +82,10 @@ static CommandReturn _controlListConnections_Execute(CommandParser *parser, _controlListConnections_HelpExecute(parser, ops, args); return CommandReturn_Failure; } +#ifdef WITH_POLICY + char flags_str[POLICY_TAG_N]; + char *s; +#endif /* WITH_POLICY */ ControlState *state = ops->closure; @@ -127,11 +131,28 @@ static CommandReturn _controlListConnections_Execute(CommandParser *parser, PARCBufferComposer *composer = parcBufferComposer_Create(); +#ifdef WITH_POLICY + + s = flags_str; +#define _(x, y) *s++ = policy_tags_has(listConnectionsCommand->connectionData.tags, POLICY_TAG_ ## x) ? y : '.'; +foreach_policy_tag +#undef _ + *s = '\0'; + + parcBufferComposer_Format( + composer, "%5d %4s %s %s %s [%s]", listConnectionsCommand->connid, + stateString[listConnectionsCommand->state], sourceString, + destinationString, + connTypeString[listConnectionsCommand->connectionData.connectionType], + flags_str); + +#else parcBufferComposer_Format( composer, "%5d %4s %s %s %s", listConnectionsCommand->connid, stateString[listConnectionsCommand->state], sourceString, destinationString, connTypeString[listConnectionsCommand->connectionData.connectionType]); +#endif /* WITH_POLICY */ PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(composer); char *result = parcBuffer_ToString(tempBuffer); diff --git a/hicn-light/src/hicn/config/controlListPolicies.c b/hicn-light/src/hicn/config/controlListPolicies.c new file mode 100644 index 000000000..c70d8baea --- /dev/null +++ b/hicn-light/src/hicn/config/controlListPolicies.c @@ -0,0 +1,240 @@ +/* + * 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. + */ + +#ifdef WITH_POLICY + +#include <hicn/hicn-light/config.h> + +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> + +#include <parc/assert/parc_Assert.h> + +#include <parc/algol/parc_Memory.h> +#include <parc/algol/parc_Time.h> + +#include <hicn/config/controlListPolicies.h> + +#include <hicn/utils/commands.h> +#include <hicn/utils/utils.h> + +static CommandReturn _controlListPolicies_Execute(CommandParser *parser, + CommandOps *ops, + PARCList *args); +static CommandReturn _controlListPolicies_HelpExecute(CommandParser *parser, + CommandOps *ops, + PARCList *args); + +static const char *_commandListPolicies = "list policies"; +static const char *_commandListPoliciesHelp = "help list policies"; + +// ==================================================== + +CommandOps *controlListPolicies_Create(ControlState *state) { + return commandOps_Create(state, _commandListPolicies, NULL, + _controlListPolicies_Execute, commandOps_Destroy); +} + +CommandOps *controlListPolicies_HelpCreate(ControlState *state) { + return commandOps_Create(state, _commandListPoliciesHelp, NULL, + _controlListPolicies_HelpExecute, commandOps_Destroy); +} + +// ==================================================== + +static CommandReturn _controlListPolicies_HelpExecute(CommandParser *parser, + CommandOps *ops, + PARCList *args) { + printf("command: list policies\n"); + printf("\n"); + return CommandReturn_Success; +} + +#define MAX(x,y) (x > y ? x : y) +#define MAXSZ_COLUMN MAX(MAXSZ_POLICY_TAG, MAXSZ_POLICY_TAG_STATE) + +#define MAXSZ_STR_STAT 10 +#define MAXSZ_APP_NAME 25 +#define MAXSZ_PREFIX 25 + +typedef struct { + #define _(x, y) char x[MAXSZ_POLICY_TAG_STATE]; + foreach_policy_tag + #undef _ +} tag_state_str_t; + +static CommandReturn _controlListPolicies_Execute(CommandParser *parser, + CommandOps *ops, + PARCList *args) { + if (parcList_Size(args) != 2) { + _controlListPolicies_HelpExecute(parser, ops, args); + return CommandReturn_Failure; + } + + ControlState *state = ops->closure; + + // send message and receive response + struct iovec *response = utils_SendRequest(state, LIST_POLICIES, NULL, 0); + if (!response) { // get NULL pointer = FAILURE + return CommandReturn_Failure; + } + + // Process/Print message + header_control_message *receivedHeader = + (header_control_message *)response[0].iov_base; + uint8_t *receivedPayload = (uint8_t *)response[1].iov_base; + if (!receivedPayload) { + printf("No payload!\n"); + return CommandReturn_Failure; + } + + // Allocate output to pass to the main function if the call is not interactive + char **commandOutputMain = NULL; + if (!controlState_IsInteractive(state) && receivedHeader->length > 0) { + commandOutputMain = + parcMemory_Allocate(sizeof(char *) * receivedHeader->length); + for (size_t j = 0; j < receivedHeader->length; j++) { + commandOutputMain[j] = parcMemory_Allocate(sizeof(char) * 128); + } + } + + char *addrString = NULL; + in_port_t port = htons(1234); // this is a random port number that is ignored + + if (receivedHeader->length > 0) { + printf("%*s %*s" + #define _(x, y) " %*s" + foreach_policy_tag + #undef _ + "%s", + MAXSZ_PREFIX, "prefix", MAXSZ_APP_NAME /*APP_NAME_LEN*/, "app_name", + #define _(x, y) MAXSZ_COLUMN, policy_tag_str[POLICY_TAG_ ## x], + foreach_policy_tag + #undef _ + "\n"); + } else { + printf(" --- No entry in the list \n"); + } + + tag_state_str_t str; + + for (int i = 0; i < receivedHeader->length; i++) { + list_policies_command *listPoliciesCommand = + (list_policies_command *)(receivedPayload + + (i * sizeof(list_policies_command))); + +#if 0 + char tag_s[MAXSZ_POLICY_TAG_STATE * POLICY_TAG_N]; + + policy_tag_state_snprintf((char*)&tag_s[MAXSZ_POLICY_TAG_STATE * POLICY_TAG_ ## x], \ + MAXSZ_POLICY_TAG_STATE, \ + &listPoliciesCommand->policy.tags[POLICY_TAG_ ## x]); +#endif + + #define _(x, y) policy_tag_state_snprintf(str.x, MAXSZ_POLICY_TAG_STATE, &listPoliciesCommand->policy.tags[POLICY_TAG_ ## x]); + foreach_policy_tag + #undef _ + + addrString = utils_CommandAddressToString( + listPoliciesCommand->addressType, &listPoliciesCommand->address, &port); + +#if 0 + PARCBufferComposer *composer = parcBufferComposer_Create(); + + parcBufferComposer_Format( + composer, "%*s %*s" + #define _(x, y) " %*s" + foreach_policy_tag + #undef _ + "%s", + MAXSZ_PREFIX, addrString, APP_NAME_LEN, listPoliciesCommand->policy.app_name, + #define _(x, y) MAXSZ_COLUMN, str.x, + foreach_policy_tag + #undef _ + ""); + + PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(composer); + char *result = parcBuffer_ToString(tempBuffer); + parcBuffer_Release(&tempBuffer); + + if (!controlState_IsInteractive(state)) { + strcpy(commandOutputMain[i], result); + } + + puts(result); + parcMemory_Deallocate((void **)&result); + parcBufferComposer_Release(&composer); +#else + printf("%*s %*s" + #define _(x, y) " %*s" + foreach_policy_tag + #undef _ + "%s\n", + MAXSZ_PREFIX, addrString, MAXSZ_APP_NAME /*APP_NAME_LEN*/, listPoliciesCommand->policy.app_name, + #define _(x, y) MAXSZ_COLUMN, str.x, + foreach_policy_tag + #undef _ + ""); + +#endif + } + + printf("\nSTATISTICS\n\n"); + // STATISTICS + printf("%*s %*s %*s | %*s | %*s | %*s\n", + MAXSZ_PREFIX, "", MAXSZ_APP_NAME /*APP_NAME_LEN*/, "", + 3*MAXSZ_STR_STAT+2, "WIRED", 3*MAXSZ_STR_STAT+2, "WIFI", 3*MAXSZ_STR_STAT+2, "CELLULAR", 3*MAXSZ_STR_STAT+2, "ALL"); + printf("%*s %*s %*s %*s %*s | %*s %*s %*s | %*s %*s %*s | %*s %*s %*s\n", + MAXSZ_PREFIX, "prefix", MAXSZ_APP_NAME /*APP_NAME_LEN*/, "app_name", + MAXSZ_STR_STAT, "throughput", MAXSZ_STR_STAT, "latency", MAXSZ_STR_STAT, "loss_rate", + MAXSZ_STR_STAT, "throughput", MAXSZ_STR_STAT, "latency", MAXSZ_STR_STAT, "loss_rate", + MAXSZ_STR_STAT, "throughput", MAXSZ_STR_STAT, "latency", MAXSZ_STR_STAT, "loss_rate", + MAXSZ_STR_STAT, "throughput", MAXSZ_STR_STAT, "latency", MAXSZ_STR_STAT, "loss_rate"); + for (int i = 0; i < receivedHeader->length; i++) { + list_policies_command *listPoliciesCommand = + (list_policies_command *)(receivedPayload + + (i * sizeof(list_policies_command))); + addrString = utils_CommandAddressToString( + listPoliciesCommand->addressType, &listPoliciesCommand->address, &port); + printf("%*s %*s %*.2f %*.2f %*.2f | %*.2f %*.2f %*.2f | %*.2f %*.2f %*.2f | %*.2f %*.2f %*.2f\n", + MAXSZ_PREFIX, addrString, MAXSZ_APP_NAME, listPoliciesCommand->policy.app_name, + MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.wired.throughput, + MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.wired.latency, + MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.wired.loss_rate, + MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.wifi.throughput, + MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.wifi.latency, + MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.wifi.loss_rate, + MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.cellular.throughput, + MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.cellular.latency, + MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.cellular.loss_rate, + MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.all.throughput, + MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.all.latency, + MAXSZ_STR_STAT, listPoliciesCommand->policy.stats.all.loss_rate); + } + + controlState_SetCommandOutput(state, commandOutputMain); + + // DEALLOCATE + parcMemory_Deallocate((void **)&addrString); + parcMemory_Deallocate(&receivedHeader); // free response[0].iov_base + parcMemory_Deallocate(&receivedPayload); // free response[1].iov_base + parcMemory_Deallocate(&response); // free iovec pointer + + return CommandReturn_Success; +} + +#endif /* WITH_POLICY */ diff --git a/hicn-light/src/hicn/config/controlListPolicies.h b/hicn-light/src/hicn/config/controlListPolicies.h new file mode 100644 index 000000000..7aa0bdd26 --- /dev/null +++ b/hicn-light/src/hicn/config/controlListPolicies.h @@ -0,0 +1,34 @@ +/* + * 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. + */ + +/** + * @file control_ListPolicies.h + * @brief List the icn-light policies + * + * Implements the "list policies" and "help list policies" nodes of the command tree + * + */ +#ifndef Control_ListPolicies_h +#define Control_ListPolicies_h + +#ifdef WITH_POLICY + +#include <hicn/config/controlState.h> +CommandOps *controlListPolicies_Create(ControlState *state); +CommandOps *controlListPolicies_HelpCreate(ControlState *state); + +#endif /* WITH_POLICY */ + +#endif // Control_ListPolicies_h diff --git a/hicn-light/src/hicn/config/controlRemove.c b/hicn-light/src/hicn/config/controlRemove.c index d33d57206..af833dc8b 100644 --- a/hicn-light/src/hicn/config/controlRemove.c +++ b/hicn-light/src/hicn/config/controlRemove.c @@ -30,6 +30,9 @@ #include <hicn/config/controlRemoveConnection.h> #include <hicn/config/controlRemovePunting.h> #include <hicn/config/controlRemoveRoute.h> +#ifdef WITH_POLICY +#include <hicn/config/controlRemovePolicy.h> +#endif /* WITH_POLICY */ static void _controlRemove_Init(CommandParser *parser, CommandOps *ops); static CommandReturn _controlRemove_Execute(CommandParser *parser, @@ -61,16 +64,25 @@ static CommandReturn _controlRemove_HelpExecute(CommandParser *parser, CommandOps *ops_remove_connection = controlRemoveConnection_Create(NULL); CommandOps *ops_remove_route = controlRemoveRoute_Create(NULL); CommandOps *ops_remove_punting = controlRemovePunting_Create(NULL); +#ifdef WITH_POLICY + CommandOps *ops_remove_policy = controlRemovePolicy_Create(NULL); +#endif /* WITH_POLICY */ printf("Available commands:\n"); printf(" %s\n", ops_remove_connection->command); printf(" %s\n", ops_remove_route->command); printf(" %s\n", ops_remove_punting->command); +#ifdef WITH_POLICY + printf(" %s\n", ops_remove_policy->command); +#endif /* WITH_POLICY */ printf("\n"); commandOps_Destroy(&ops_remove_connection); commandOps_Destroy(&ops_remove_route); commandOps_Destroy(&ops_remove_punting); +#ifdef WITH_POLICY + commandOps_Destroy(&ops_remove_policy); +#endif /* WITH_POLICY */ return CommandReturn_Success; } @@ -83,6 +95,10 @@ static void _controlRemove_Init(CommandParser *parser, CommandOps *ops) { controlState_RegisterCommand(state, controlRemoveRoute_Create(state)); controlState_RegisterCommand(state, controlRemovePunting_Create(state)); controlState_RegisterCommand(state, controlRemovePunting_HelpCreate(state)); +#ifdef WITH_POLICY + controlState_RegisterCommand(state, controlRemovePolicy_HelpCreate(state)); + controlState_RegisterCommand(state, controlRemovePolicy_Create(state)); +#endif /* WITH_POLICY */ } static CommandReturn _controlRemove_Execute(CommandParser *parser, diff --git a/hicn-light/src/hicn/config/controlRemovePolicy.c b/hicn-light/src/hicn/config/controlRemovePolicy.c new file mode 100644 index 000000000..510203886 --- /dev/null +++ b/hicn-light/src/hicn/config/controlRemovePolicy.c @@ -0,0 +1,139 @@ +/* + * 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. + */ + +#ifdef WITH_POLICY + +#include <hicn/hicn-light/config.h> + +#include <ctype.h> +#include <parc/algol/parc_List.h> +#include <parc/algol/parc_Memory.h> +#include <parc/algol/parc_Network.h> +#include <parc/assert/parc_Assert.h> +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> + +#include <hicn/utils/address.h> + +#include <hicn/config/controlRemovePolicy.h> + +#include <hicn/utils/commands.h> +#include <hicn/utils/utils.h> + +static CommandReturn _controlRemovePolicy_Execute(CommandParser *parser, + CommandOps *ops, + PARCList *args); +static CommandReturn _controlRemovePolicy_HelpExecute(CommandParser *parser, + CommandOps *ops, + PARCList *args); + +// =================================================== + +static const char *_commandRemovePolicy = "remove policy"; +static const char *_commandRemovePolicyHelp = "help remove policy"; + +// ==================================================== + +CommandOps *controlRemovePolicy_Create(ControlState *state) { + return commandOps_Create(state, _commandRemovePolicy, NULL, + _controlRemovePolicy_Execute, commandOps_Destroy); +} + +CommandOps *controlRemovePolicy_HelpCreate(ControlState *state) { + return commandOps_Create(state, _commandRemovePolicyHelp, NULL, + _controlRemovePolicy_HelpExecute, commandOps_Destroy); +} + +// ==================================================== + +static CommandReturn _controlRemovePolicy_HelpExecute(CommandParser *parser, + CommandOps *ops, + PARCList *args) { + printf("commands:\n"); + printf(" remove policy <prefix>\n"); + return CommandReturn_Success; +} + +static CommandReturn _controlRemovePolicy_Execute(CommandParser *parser, + CommandOps *ops, + PARCList *args) { + ControlState *state = ops->closure; + + if (parcList_Size(args) != 3) { + _controlRemovePolicy_HelpExecute(parser, ops, args); + return CommandReturn_Failure; + } + + const char *prefixStr = parcList_GetAtIndex(args, 2); + char *addr = (char *)malloc(sizeof(char) * (strlen(prefixStr) + 1)); + + // separate address and len + char *slash; + uint32_t len = 0; + strcpy(addr, prefixStr); + slash = strrchr(addr, '/'); + if (slash != NULL) { + len = atoi(slash + 1); + *slash = '\0'; + } + + // allocate command payload + remove_policy_command *removePolicyCommand = + parcMemory_AllocateAndClear(sizeof(remove_policy_command)); + + // check and set IP address + if (inet_pton(AF_INET, addr, &removePolicyCommand->address.ipv4) == 1) { + if (len > 32) { + printf("ERROR: exceeded INET mask length, max=32\n"); + parcMemory_Deallocate(&removePolicyCommand); + free(addr); + return CommandReturn_Failure; + } + removePolicyCommand->addressType = ADDR_INET; + } else if (inet_pton(AF_INET6, addr, &removePolicyCommand->address.ipv6) == + 1) { + if (len > 128) { + printf("ERROR: exceeded INET6 mask length, max=128\n"); + parcMemory_Deallocate(&removePolicyCommand); + free(addr); + return CommandReturn_Failure; + } + removePolicyCommand->addressType = ADDR_INET6; + } else { + printf("Error: %s is not a valid network address \n", addr); + parcMemory_Deallocate(&removePolicyCommand); + free(addr); + return CommandReturn_Failure; + } + + free(addr); + // Fill remaining payload fields + removePolicyCommand->len = len; + + // send message and receive response + struct iovec *response = utils_SendRequest( + state, REMOVE_POLICY, removePolicyCommand, sizeof(remove_policy_command)); + + if (!response) { // get NULL pointer + return CommandReturn_Failure; + } + + parcMemory_Deallocate(&response); // free iovec pointer + return CommandReturn_Success; +} + +#endif /* WITH_POLICY */ diff --git a/hicn-light/src/hicn/config/controlRemovePolicy.h b/hicn-light/src/hicn/config/controlRemovePolicy.h new file mode 100644 index 000000000..ebe098985 --- /dev/null +++ b/hicn-light/src/hicn/config/controlRemovePolicy.h @@ -0,0 +1,36 @@ +/* + * 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. + */ + +/** + * @file control_RemovePolicy.h + * @brief Remove a policy from the FIB + * + * Implements the "remove policy" and "help remove policy" nodes of the command + * tree + * + */ + +#ifndef Control_RemovePolicy_h +#define Control_RemovePolicy_h + +#ifdef WITH_POLICY + +#include <hicn/config/controlState.h> +CommandOps *controlRemovePolicy_Create(ControlState *state); +CommandOps *controlRemovePolicy_HelpCreate(ControlState *state); + +#endif /* WITH_POLICY */ + +#endif // Control_RemovePolicy_h diff --git a/hicn-light/src/hicn/config/controlRemoveRoute.c b/hicn-light/src/hicn/config/controlRemoveRoute.c index 8cb888f7c..0626886de 100644 --- a/hicn-light/src/hicn/config/controlRemoveRoute.c +++ b/hicn-light/src/hicn/config/controlRemoveRoute.c @@ -99,12 +99,6 @@ static CommandReturn _controlRemoveRoute_Execute(CommandParser *parser, *slash = '\0'; } - if (len == 0) { - printf("ERROR: a prefix can not be of length 0\n"); - free(addr); - return CommandReturn_Failure; - } - // allocate command payload remove_route_command *removeRouteCommand = parcMemory_AllocateAndClear(sizeof(remove_route_command)); diff --git a/hicn-light/src/hicn/config/controlRoot.c b/hicn-light/src/hicn/config/controlRoot.c index 675fe4c6e..e135dfc50 100644 --- a/hicn-light/src/hicn/config/controlRoot.c +++ b/hicn-light/src/hicn/config/controlRoot.c @@ -31,6 +31,9 @@ #include <hicn/config/controlRoot.h> #include <hicn/config/controlSet.h> #include <hicn/config/controlUnset.h> +#ifdef WITH_POLICY +#include <hicn/config/controlUpdate.h> +#endif /* WITH_POLICY */ static void _controlRoot_Init(CommandParser *parser, CommandOps *ops); static CommandReturn _controlRoot_Execute(CommandParser *parser, @@ -79,6 +82,9 @@ static CommandReturn _controlRoot_HelpExecute(CommandParser *parser, CommandOps *ops_help_unset = controlUnset_HelpCreate(NULL); CommandOps *ops_help_cache = controlCache_HelpCreate(NULL); CommandOps *ops_help_mapme = controlMapMe_HelpCreate(NULL); +#ifdef WITH_POLICY + CommandOps *ops_help_update = controlUpdate_HelpCreate(NULL); +#endif /* WITH_POLICY */ printf("Available commands:\n"); printf(" %s\n", ops_help_add->command); @@ -89,6 +95,9 @@ static CommandReturn _controlRoot_HelpExecute(CommandParser *parser, printf(" %s\n", ops_help_unset->command); printf(" %s\n", ops_help_cache->command); printf(" %s\n", ops_help_mapme->command); +#ifdef WITH_POLICY + printf(" %s\n", ops_help_update->command); +#endif /* WITH_POLICY */ printf("\n"); commandOps_Destroy(&ops_help_add); @@ -99,6 +108,9 @@ static CommandReturn _controlRoot_HelpExecute(CommandParser *parser, commandOps_Destroy(&ops_help_unset); commandOps_Destroy(&ops_help_cache); commandOps_Destroy(&ops_help_mapme); +#ifdef WITH_POLICY + commandOps_Destroy(&ops_help_update); +#endif /* WITH_POLICY */ return CommandReturn_Success; } @@ -114,6 +126,9 @@ static void _controlRoot_Init(CommandParser *parser, CommandOps *ops) { controlState_RegisterCommand(state, controlUnset_HelpCreate(state)); controlState_RegisterCommand(state, controlCache_HelpCreate(state)); controlState_RegisterCommand(state, controlMapMe_HelpCreate(state)); +#ifdef WITH_POLICY + controlState_RegisterCommand(state, controlUpdate_HelpCreate(state)); +#endif /* WITH_POLICY */ controlState_RegisterCommand(state, webControlAdd_Create(state)); controlState_RegisterCommand(state, controlList_Create(state)); @@ -123,6 +138,9 @@ static void _controlRoot_Init(CommandParser *parser, CommandOps *ops) { controlState_RegisterCommand(state, controlUnset_Create(state)); controlState_RegisterCommand(state, controlCache_Create(state)); controlState_RegisterCommand(state, controlMapMe_Create(state)); +#ifdef WITH_POLICY + controlState_RegisterCommand(state, controlUpdate_Create(state)); +#endif /* WITH_POLICY */ } static CommandReturn _controlRoot_Execute(CommandParser *parser, diff --git a/hicn-light/src/hicn/config/controlSetStrategy.c b/hicn-light/src/hicn/config/controlSetStrategy.c index 1b1396342..b2968712f 100644 --- a/hicn-light/src/hicn/config/controlSetStrategy.c +++ b/hicn-light/src/hicn/config/controlSetStrategy.c @@ -47,8 +47,7 @@ static const char *_commandSetStrategyOptions[LAST_STRATEGY_VALUE] = { "random", "random_per_dash_segment", "loadbalancer_with_delay", - "loadbalancer_by_rate", - "loadbalancer_best_route"}; +}; // ==================================================== @@ -118,11 +117,6 @@ static CommandReturn _controlSetStrategy_Execute(CommandParser *parser, len = atoi(slash + 1); *slash = '\0'; } - if (len == 0) { - printf("ERROR: a prefix can not be of length 0\n"); - free(addr); - return CommandReturn_Failure; - } // allocate command payload set_strategy_command *setStrategyCommand = diff --git a/hicn-light/src/hicn/config/controlUpdate.c b/hicn-light/src/hicn/config/controlUpdate.c new file mode 100644 index 000000000..4c74660c2 --- /dev/null +++ b/hicn-light/src/hicn/config/controlUpdate.c @@ -0,0 +1,95 @@ +/* + * 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. + */ + +#ifdef WITH_POLICY + +#include <hicn/hicn-light/config.h> + +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> + +#include <parc/assert/parc_Assert.h> + +#include <parc/security/parc_Security.h> + +#include <parc/algol/parc_Memory.h> + +#include <hicn/config/controlUpdate.h> +#include <hicn/config/controlUpdateConnection.h> + +static void _controlUpdate_Init(CommandParser *parser, CommandOps *ops); +static CommandReturn _controlUpdate_Execute(CommandParser *parser, + CommandOps *ops, PARCList *args); +static CommandReturn _controlUpdate_HelpExecute(CommandParser *parser, + CommandOps *ops, PARCList *args); + +static const char *_commandUpdate = "update"; +static const char *_commandUpdateHelp = "help update"; + +CommandOps *controlUpdate_Create(ControlState *state) { + return commandOps_Create(state, _commandUpdate, _controlUpdate_Init, + _controlUpdate_Execute, commandOps_Destroy); +} + +CommandOps *controlUpdate_HelpCreate(ControlState *state) { + return commandOps_Create(state, _commandUpdateHelp, NULL, + _controlUpdate_HelpExecute, commandOps_Destroy); +} + +// ===================================================== + +static CommandReturn _controlUpdate_HelpExecute(CommandParser *parser, + CommandOps *ops, PARCList *args) { + //CommandOps *ops_update_connections = controlUpdateConnections_HelpCreate(NULL); + // CommandOps *ops_update_interfaces = controlUpdateInterfaces_HelpCreate(NULL); + //CommandOps *ops_update_routes = controlUpdateRoutes_HelpCreate(NULL); + CommandOps *ops_update_listeners = controlUpdateConnection_HelpCreate(NULL); + + printf("Available commands:\n"); + //printf(" %s\n", ops_update_connections->command); + // printf(" %s\n", ops_update_interfaces->command); + //printf(" %s\n", ops_update_routes->command); + printf(" %s\n", ops_update_listeners->command); + printf("\n"); + + // commandOps_Destroy(&ops_update_connections); + // commandOps_Destroy(&ops_update_interfaces); + //commandOps_Destroy(&ops_update_routes); + commandOps_Destroy(&ops_update_listeners); + + return CommandReturn_Success; +} + +static void _controlUpdate_Init(CommandParser *parser, CommandOps *ops) { + ControlState *state = ops->closure; + //controlState_RegisterCommand(state, controlUpdateConnections_HelpCreate(state)); + // controlState_RegisterCommand(state, + // controlUpdateInterfaces_HelpCreate(state)); + controlState_RegisterCommand(state, controlUpdateConnection_HelpCreate(state)); + //controlState_RegisterCommand(state, controlUpdateRoutes_HelpCreate(state)); + //controlState_RegisterCommand(state, controlUpdateConnections_Create(state)); + // controlState_RegisterCommand(state, controlUpdateInterfaces_Create(state)); + //controlState_RegisterCommand(state, controlUpdateRoutes_Create(state)); + controlState_RegisterCommand(state, controlUpdateConnection_Create(state)); +} + +static CommandReturn _controlUpdate_Execute(CommandParser *parser, + CommandOps *ops, PARCList *args) { + return _controlUpdate_HelpExecute(parser, ops, args); +} + +#endif /* WITH_POLICY */ diff --git a/hicn-light/src/hicn/config/controlUpdate.h b/hicn-light/src/hicn/config/controlUpdate.h new file mode 100644 index 000000000..0007ab653 --- /dev/null +++ b/hicn-light/src/hicn/config/controlUpdate.h @@ -0,0 +1,35 @@ +/* + * 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. + */ + +/** + * @file control_Update.h + * @brief Root node for the "update" commands + * + * Implements the "update" node of the CLI tree. + * + */ + +#ifndef controlUpdate_h +#define controlUpdate_h + +#ifdef WITH_POLICY + +#include <hicn/config/controlState.h> +CommandOps *controlUpdate_Create(ControlState *state); +CommandOps *controlUpdate_HelpCreate(ControlState *state); + +#endif /* WITH_POLICY */ + +#endif // controlUpdate_h diff --git a/hicn-light/src/hicn/config/controlUpdateConnection.c b/hicn-light/src/hicn/config/controlUpdateConnection.c new file mode 100644 index 000000000..3e573d41d --- /dev/null +++ b/hicn-light/src/hicn/config/controlUpdateConnection.c @@ -0,0 +1,145 @@ +/* + * 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. + */ + +#ifdef WITH_POLICY + +#include <hicn/hicn-light/config.h> + +#include <ctype.h> +#include <inttypes.h> +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> + +#include <parc/assert/parc_Assert.h> + +#include <parc/algol/parc_Memory.h> +#include <parc/algol/parc_Network.h> + +#include <hicn/config/controlUpdateConnection.h> + +#include <hicn/utils/commands.h> +#include <hicn/utils/utils.h> +#include <hicn/utils/policy.h> + +static CommandReturn _controlUpdateConnection_Execute(CommandParser *parser, + CommandOps *ops, + PARCList *args); +static CommandReturn _controlUpdateConnection_HelpExecute(CommandParser *parser, + CommandOps *ops, + PARCList *args); + +static const char *command_update_connection = "update connection"; +static const char *command_help_update_connection = "help update connection"; + +CommandOps *controlUpdateConnection_Create(ControlState *state) { + return commandOps_Create(state, command_update_connection, NULL, + _controlUpdateConnection_Execute, commandOps_Destroy); +} + +CommandOps *controlUpdateConnection_HelpCreate(ControlState *state) { + return commandOps_Create(state, command_help_update_connection, NULL, + _controlUpdateConnection_HelpExecute, commandOps_Destroy); +} + +// ==================================================== + +static const int _indexSymbolic = 2; +static const int _indexTags = 3; + +static CommandReturn _controlUpdateConnection_HelpExecute(CommandParser *parser, + CommandOps *ops, + PARCList *args) { + printf("commands:\n"); + printf(" update connection <symbolic | id> <tags> \n"); + printf("\n"); + printf( + " symbolic: User defined name for connection, must start with " + "alpha and be alphanum\n"); + printf(" id: Identifier for the connection\n"); + printf(" tags: A string representing tags\n"); + return CommandReturn_Success; +} + + +static CommandReturn _controlUpdateConnection_Execute(CommandParser *parser, + CommandOps *ops, + PARCList *args) { + if ((parcList_Size(args) != 3) && (parcList_Size(args) != 4)) { + _controlUpdateConnection_HelpExecute(parser, ops, args); + return CommandReturn_Failure; + } + + const char *symbolicOrConnid = parcList_GetAtIndex(args, _indexSymbolic); + + if (!utils_ValidateSymbolicName(symbolicOrConnid) && + !utils_IsNumber(symbolicOrConnid)) { + printf( + "ERROR: Invalid symbolic or connid:\nsymbolic name must begin with an " + "alpha followed by alphanum;\nconnid must be an integer\n"); + return CommandReturn_Failure; + } + + policy_tags_t tags = POLICY_TAGS_EMPTY; + if (parcList_Size(args) == 4) { + const char *str_tags = parcList_GetAtIndex(args, _indexTags); + + for (unsigned i = 0; str_tags[i] != 0; i++) { + switch(tolower(str_tags[i])) { + case 'e': + policy_tags_add(&tags, POLICY_TAG_WIRED); + break; + case 'w': + policy_tags_add(&tags, POLICY_TAG_WIFI); + break; + case 'c': + policy_tags_add(&tags, POLICY_TAG_CELLULAR); + break; + case 'b': + policy_tags_add(&tags, POLICY_TAG_BEST_EFFORT); + break; + case 'r': + policy_tags_add(&tags, POLICY_TAG_REALTIME); + break; + case 'm': + policy_tags_add(&tags, POLICY_TAG_MULTIPATH); + break; + case 't': + policy_tags_add(&tags, POLICY_TAG_TRUSTED); + break; + } + } + } + ControlState *state = ops->closure; + + // allocate command payload + update_connection_command *updateConnectionCommand = + parcMemory_AllocateAndClear(sizeof(update_connection_command)); + updateConnectionCommand->tags = tags; + strcpy(updateConnectionCommand->symbolicOrConnid, symbolicOrConnid); + + // send message and receive response + struct iovec *response = utils_SendRequest( + state, UPDATE_CONNECTION, updateConnectionCommand, sizeof(update_connection_command)); + + if (!response) // get NULL pointer + return CommandReturn_Failure; + + parcMemory_Deallocate(&response); // free iovec pointer + return CommandReturn_Success; +} + +#endif /* WITH_POLICY */ diff --git a/hicn-light/src/hicn/config/controlUpdateConnection.h b/hicn-light/src/hicn/config/controlUpdateConnection.h new file mode 100644 index 000000000..eea303202 --- /dev/null +++ b/hicn-light/src/hicn/config/controlUpdateConnection.h @@ -0,0 +1,35 @@ +/* + * 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. + */ + +/** + * @file control_UpdateConnection.h + * @brief Update a connection to an interface + * + * <#Detailed Description#> + * + */ + +#ifndef Control_UpdateConnection_h +#define Control_UpdateConnection_h + +#ifdef WITH_POLICY + +#include <hicn/config/controlState.h> +CommandOps *controlUpdateConnection_Create(ControlState *state); +CommandOps *controlUpdateConnection_HelpCreate(ControlState *state); + +#endif /* WITH_POLICY */ + +#endif // Control_UpdateConnection_h diff --git a/hicn-light/src/hicn/core/connection.c b/hicn-light/src/hicn/core/connection.c index d9b2770b9..2f50dbf7f 100644 --- a/hicn-light/src/hicn/core/connection.c +++ b/hicn-light/src/hicn/core/connection.c @@ -27,6 +27,9 @@ #include <parc/algol/parc_Memory.h> #include <parc/assert/parc_Assert.h> +#ifdef WITH_POLICY +#include <hicn/utils/policy.h> +#endif /* WITH_POLICY */ struct connection { const AddressPair *addressPair; @@ -46,6 +49,11 @@ struct connection { // file/hicnLightControl) this value is set to false so // that a base station can not disable wldr at the client Wldr *wldr; + +#ifdef WITH_POLICY + policy_tags_t tags; +#endif /* WITH_POLICY */ + }; Connection *connection_Create(IoOperations *ops) { @@ -68,6 +76,10 @@ Connection *connection_Create(IoOperations *ops) { /* By default, a connection will aim at the UP state */ connection_SetAdminState(conn, CONNECTION_STATE_UP); +#ifdef WITH_POLICY + conn->tags = POLICY_TAGS_EMPTY; +#endif /* WITH_POLICY */ + return conn; } @@ -316,3 +328,37 @@ void connection_SetAdminState(Connection *conn, connection_state_t admin_state) return; ioOperations_SetAdminState(conn->ops, admin_state); } + +#ifdef WITH_POLICY + +void connection_AddTag(Connection *conn, policy_tag_t tag) +{ + policy_tags_add(&conn->tags, tag); +} + +void connection_RemoveTag(Connection *conn, policy_tag_t tag) +{ + policy_tags_remove(&conn->tags, tag); +} + +policy_tags_t connection_GetTags(const Connection *conn) +{ + return conn->tags; +} + +void connection_SetTags(Connection *conn, policy_tags_t tags) +{ + conn->tags = tags; +} + +void connection_ClearTags(Connection *conn) +{ + conn->tags = POLICY_TAGS_EMPTY; +} + +int connection_HasTag(const Connection *conn, policy_tag_t tag) +{ + return policy_tags_has(conn->tags, tag); +} + +#endif /* WITH_POLICY */ diff --git a/hicn-light/src/hicn/core/connection.h b/hicn-light/src/hicn/core/connection.h index df1c780a1..c007a1a26 100644 --- a/hicn-light/src/hicn/core/connection.h +++ b/hicn-light/src/hicn/core/connection.h @@ -29,6 +29,21 @@ #include <hicn/io/ioOperations.h> #include <hicn/utils/address.h> +#ifdef WITH_MAPME +typedef enum { + CONNECTION_EVENT_CREATE, + CONNECTION_EVENT_DELETE, + CONNECTION_EVENT_UPDATE, + CONNECTION_EVENT_SET_UP, + CONNECTION_EVENT_SET_DOWN, +} connection_event_t; + +#endif /* WITH_MAPME */ + +#ifdef WITH_POLICY +#include <hicn/utils/policy.h> +#endif /* WITH_POLICY */ + // packet types for probing #define PACKET_TYPE_PROBE_REQUEST 5 #define PACKET_TYPE_PROBE_REPLY 6 @@ -168,4 +183,13 @@ connection_state_t connection_GetAdminState(const Connection *conn); void connection_SetAdminState(Connection *conn, connection_state_t admin_state); +#ifdef WITH_POLICY +void connection_AddTag(Connection *conn, policy_tag_t tag); +void connection_RemoveTag(Connection *conn, policy_tag_t tag); +policy_tags_t connection_GetTags(const Connection *conn); +void connection_SetTags(Connection *conn, policy_tags_t tags); +void connection_ClearTags(Connection *conn); +int connection_HasTag(const Connection *conn, policy_tag_t tag); +#endif /* WITH_POLICY */ + #endif // connection_h diff --git a/hicn-light/src/hicn/core/connectionTable.c b/hicn-light/src/hicn/core/connectionTable.c index 0a1301328..f8589c12b 100644 --- a/hicn-light/src/hicn/core/connectionTable.c +++ b/hicn-light/src/hicn/core/connectionTable.c @@ -206,7 +206,7 @@ const Connection *connectionTable_FindByAddressPair(ConnectionTable *table, return (Connection *)parcHashCodeTable_Get(table->indexByAddressPair, pair); } -const Connection *connectionTable_FindById(ConnectionTable *table, +const Connection *connectionTable_FindById(const ConnectionTable *table, unsigned id) { parcAssertNotNull(table, "Parameter table must be non-null"); return (Connection *)parcHashCodeTable_Get(table->storageTableById, &id); diff --git a/hicn-light/src/hicn/core/connectionTable.h b/hicn-light/src/hicn/core/connectionTable.h index bd8f553c2..548ef8e6e 100644 --- a/hicn-light/src/hicn/core/connectionTable.h +++ b/hicn-light/src/hicn/core/connectionTable.h @@ -84,7 +84,7 @@ const Connection *connectionTable_FindByAddressPair(ConnectionTable *table, * @abstract Find a connection by its numeric id. * @return NULL if not found */ -const Connection *connectionTable_FindById(ConnectionTable *table, unsigned id); +const Connection *connectionTable_FindById(const ConnectionTable *table, unsigned id); /** * @function connectionTable_GetEntries diff --git a/hicn-light/src/hicn/core/forwarder.c b/hicn-light/src/hicn/core/forwarder.c index c8cac98ba..c9527bb49 100644 --- a/hicn-light/src/hicn/core/forwarder.c +++ b/hicn-light/src/hicn/core/forwarder.c @@ -313,7 +313,11 @@ Dispatcher *forwarder_GetDispatcher(Forwarder *forwarder) { return forwarder->dispatcher; } +#ifdef WITH_POLICY +ConnectionTable *forwarder_GetConnectionTable(const Forwarder *forwarder) { +#else ConnectionTable *forwarder_GetConnectionTable(Forwarder *forwarder) { +#endif /* WITH_POLICY */ parcAssertNotNull(forwarder, "Parameter must be non-null"); return forwarder->connectionTable; } @@ -412,6 +416,7 @@ bool forwarder_AddOrUpdateRoute(Forwarder *forwarder, return res; } + bool forwarder_RemoveRoute(Forwarder *forwarder, remove_route_command *control, unsigned ifidx) { parcAssertNotNull(forwarder, "Parameter hicn-light must be non-null"); @@ -421,6 +426,25 @@ bool forwarder_RemoveRoute(Forwarder *forwarder, remove_route_command *control, return messageProcessor_RemoveRoute(forwarder->processor, control, ifidx); } +#ifdef WITH_POLICY + +bool forwarder_AddOrUpdatePolicy(Forwarder *forwarder, + add_policy_command *control) { + parcAssertNotNull(forwarder, "Parameter forwarder must be non-null"); + parcAssertNotNull(control, "Parameter control must be non-null"); + + return messageProcessor_AddOrUpdatePolicy(forwarder->processor, control); +} + +bool forwarder_RemovePolicy(Forwarder *forwarder, remove_policy_command *control) { + parcAssertNotNull(forwarder, "Parameter forwarder must be non-null"); + parcAssertNotNull(control, "Parameter control must be non-null"); + + return messageProcessor_RemovePolicy(forwarder->processor, control); +} + +#endif /* WITH_POLICY */ + void forwarder_RemoveConnectionIdFromRoutes(Forwarder *forwarder, unsigned connectionId) { parcAssertNotNull(forwarder, "Parameter hicn-light must be non-null"); @@ -504,16 +528,22 @@ FIB *forwarder_getFib(Forwarder *forwarder) { return messageProcessor_getFib(forwarder->processor); } -void forwarder_onConnectionAdded(Forwarder *forwarder, const Connection *conn) { - mapMe_onConnectionAdded(forwarder->mapme, conn); +void forwarder_onConnectionEvent(Forwarder *forwarder, const Connection *conn, connection_event_t event) { +#ifdef WITH_POLICY + messageProcessor_onConnectionEvent(forwarder->processor, conn, event); +#else + mapMe_onConnectionEvent(forwarder->mapme, conn, event); +#endif /* WITH_POLICY */ } -void forwarder_onConnectionRemoved(Forwarder *forwarder, - const Connection *conn) {} - -void forwarder_ProcessMapMe(Forwarder *forwarder, uint8_t *msgBuffer, +void forwarder_ProcessMapMe(Forwarder *forwarder, const uint8_t *msgBuffer, unsigned conn_id) { mapMe_Process(forwarder->mapme, msgBuffer, conn_id); } +MapMe * +forwarder_getMapmeInstance(const Forwarder *forwarder) { + return forwarder->mapme; +} + #endif /* WITH_MAPME */ diff --git a/hicn-light/src/hicn/core/forwarder.h b/hicn-light/src/hicn/core/forwarder.h index c1b279d2e..b8e68f0e4 100644 --- a/hicn-light/src/hicn/core/forwarder.h +++ b/hicn-light/src/hicn/core/forwarder.h @@ -156,7 +156,11 @@ ListenerSet *forwarder_GetListenerSet(Forwarder *forwarder); * @retval null An error * */ +#ifdef WITH_POLICY +ConnectionTable *forwarder_GetConnectionTable(const Forwarder *forwarder); +#else ConnectionTable *forwarder_GetConnectionTable(Forwarder *forwarder); +#endif /* WITH_POLICY */ /** * Returns a Tick-based clock @@ -209,6 +213,20 @@ bool forwarder_AddOrUpdateRoute(Forwarder *forwarder, bool forwarder_RemoveRoute(Forwarder *forwarder, remove_route_command *control, unsigned ifidx); +#ifdef WITH_POLICY +/** + * @function forwarder_AddOrUpdatePolicy + * @abstract Adds or updates a policy on the message processor + */ +bool forwarder_AddOrUpdatePolicy(Forwarder *forwarder, add_policy_command *control); + +/** + * @function forwarder_RemovePolicy + * @abstract Removes a policy from the message processor + */ +bool forwarder_RemovePolicy(Forwarder *forwarder, remove_policy_command *control); +#endif /* WITH_POLICY */ + /** * Removes a connection id from all routes */ @@ -260,23 +278,14 @@ hicn_socket_helper_t *forwarder_GetHicnSocketHelper(Forwarder *forwarder); FIB *forwarder_getFib(Forwarder *forwarder); /** - * @function forwarder_onConnectionAdded + * @function forwarder_onConnectionEvent * @abstract Callback fired upon addition of a new connection through the * control protocol. * @param [in] forwarder - Pointer to the hICN forwarder. * @param [in] conn - Pointer to the newly added connection. + * @param [in] event - Connection event */ -void forwarder_onConnectionAdded(Forwarder *forwarder, const Connection *conn); - -/** - * @function forwarder_onConnectionRemoved - * @abstract Callback fired upon removal of a connection through the control - * protocol. - * @param [in] forwarder - Pointer to the hICN forwarder. - * @param [in] conn - Pointer to the removed connection. - */ -void forwarder_onConnectionRemoved(Forwarder *forwarder, - const Connection *conn); +void forwarder_onConnectionEvent(Forwarder *forwarder, const Connection *conn, connection_event_t event); /** * @function forwarder_ProcessMapMe @@ -286,9 +295,12 @@ void forwarder_onConnectionRemoved(Forwarder *forwarder, * @param [in] msgBuffer - MAP-Me buffer * @param [in] conn_id - Ingress connection id */ -void forwarder_ProcessMapMe(Forwarder *forwarder, uint8_t *msgBuffer, +void forwarder_ProcessMapMe(Forwarder *forwarder, const uint8_t *msgBuffer, unsigned conn_id); +struct mapme; +struct mapme * forwarder_getMapmeInstance(const Forwarder *forwarder); + #endif /* WITH_MAPME */ #endif // forwarder_h diff --git a/hicn-light/src/hicn/core/mapMe.c b/hicn-light/src/hicn/core/mapMe.c index 74ff1ed96..865841f67 100644 --- a/hicn-light/src/hicn/core/mapMe.c +++ b/hicn-light/src/hicn/core/mapMe.c @@ -24,6 +24,7 @@ #include <hicn/core/mapMe.h> #include <stdio.h> // printf +#include <hicn/core/connection.h> #include <hicn/core/connectionList.h> #include <hicn/core/forwarder.h> #include <hicn/core/logger.h> @@ -87,8 +88,6 @@ static MapMe MapMeDefault = {.retx = MAPME_DEFAULT_RETX, /******************************************************************************/ -#include <hicn/core/connection.h> - bool mapMe_Init(MapMe **mapme, Forwarder *forwarder) { *mapme = malloc(sizeof(MapMe)); if (!mapme) goto ERR_MALLOC; @@ -98,12 +97,9 @@ bool mapMe_Init(MapMe **mapme, Forwarder *forwarder) { (*mapme)->forwarder = forwarder; - /* Install hook on Face events to onConnectionAdded */ - // see. config/configuration.c - - /* Install hook for signalization processing. See : - * - io/hicnListener.c - * - src/core/connection.{c,h} + /* As there is no face table and no related events, we need to install hooks + * in various places in the forwarder, where both control commands and + * signalization are processed. */ return true; @@ -117,20 +113,20 @@ ERR_MALLOC: ******************************************************************************/ #define INVALID_SEQ 0 -#define INIT_SEQ 1 +#define INIT_SEQ 0 typedef struct { uint32_t seq; PARCHashMap *nexthops; /* Update/Notification heuristic */ - Ticks lastAckedUpdate; // XXX This is only for producer !!! + Ticks lastAckedUpdate; } MapMeTFIB; static MapMeTFIB *mapMeTFIB_Create() { MapMeTFIB *tfib; tfib = malloc(sizeof(MapMeTFIB)); if (!tfib) goto ERR_MALLOC; - tfib->seq = 0; + tfib->seq = INIT_SEQ; tfib->lastAckedUpdate = 0; tfib->nexthops = parcHashMap_Create(); if (!tfib->nexthops) goto ERR_HASHMAP; @@ -239,7 +235,7 @@ static Message *mapMe_createMessage(const MapMe *mapme, const Name *name, INFO(mapme, "[MAP-Me] Creating MAP-Me packet"); size_t len = hicn_mapme_create_packet(icmp_pkt, &prefix, params); - if (len != 0) { + if (len == 0) { ERR(mapme, "[MAP-Me] Failed to create mapme packet through lib"); goto ERR_CREATE; } @@ -341,7 +337,6 @@ static bool mapMe_setFacePending(const MapMe *mapme, const Name *name, // set the timer. // - in the network, we always forward an IU, and never an IN if (is_first || send) { - // XXX mapme_params_t params = { .protocol = IPPROTO_IPV6, .type = is_first ? mapMe_getTypeFromHeuristic(mapme, fibEntry) : UPDATE, @@ -357,7 +352,11 @@ static bool mapMe_setFacePending(const MapMe *mapme, const Name *name, const Connection *conn = connectionTable_FindById((ConnectionTable *)table, conn_id); if (conn) { - INFO(mapme, "[MAP-Me] Sending MAP-Me packet"); + const Name * name = message_GetName(special_interest); + char * name_str = name_ToString(name); + INFO(mapme, "[MAP-Me] Sending MAP-Me packet name=%s seq=%d conn=%d", + name_str, params.seq, conn_id); + free(name_str); connection_ReSend(conn, special_interest, NOT_A_NOTIFICATION); } else { INFO(mapme, "[MAP-Me] Stopped retransmissions as face went down"); @@ -439,42 +438,85 @@ static bool mapMe_hasLocalNextHops(const MapMe *mapme, /* * Callback called everytime a new connection is created by the control protocol */ -void mapMe_onConnectionAdded(const MapMe *mapme, const Connection *conn_added) { - /* bool ret; */ - FibEntryList *fiblist; +void mapMe_onConnectionEvent(const MapMe *mapme, const Connection *conn_added, connection_event_t event) { + switch(event) { + case CONNECTION_EVENT_CREATE: + case CONNECTION_EVENT_SET_UP: + { + FibEntryList *fiblist; + + /* Ignore local connections corresponding to applications for now */ + if (connection_IsLocal(conn_added)) + return; + + unsigned conn_added_id = connection_GetConnectionId(conn_added); + INFO(mapme, "[MAP-Me] New connection %d", conn_added_id); + + /* + * Iterate on FIB to find locally served prefix + * Ideally, we want to avoid a FIB scan everytime a face is added/removed + */ + fiblist = forwarder_GetFibEntries(mapme->forwarder); + for (size_t i = 0; i < fibEntryList_Length(fiblist); i++) { + FibEntry *fibEntry = (FibEntry *)fibEntryList_Get(fiblist, i); + const Name *name = fibEntry_GetPrefix(fibEntry); + + /* Skip entries that have no local connection as next hop */ + if (!mapMe_hasLocalNextHops(mapme, fibEntry)) + continue; + + /* This entry corresponds to a locally served prefix, set + * Special Interest */ + if (!TFIB(fibEntry)) /* Create TFIB associated to FIB entry */ + mapMe_CreateTFIB(fibEntry); + TFIB(fibEntry)->seq++; + + char *name_str = name_ToString(name); + INFO(mapme, "[MAP-Me] sending IU/IN for name %s on connection %d", name_str, + conn_added_id); + free(name_str); + + mapMe_setFacePending(mapme, name, fibEntry, conn_added_id, true, true, 0); + } + break; + } + case CONNECTION_EVENT_DELETE: + case CONNECTION_EVENT_SET_DOWN: + case CONNECTION_EVENT_UPDATE: + break; + } +} +#ifdef WITH_POLICY +void mapMe_onPolicyUpdate(const MapMe *mapme, const Connection *conn_selected, FibEntry * fibEntry) +{ /* Ignore local connections corresponding to applications for now */ - if (connection_IsLocal(conn_added)) return; + if (connection_IsLocal(conn_selected)) + return; - unsigned conn_added_id = connection_GetConnectionId(conn_added); - INFO(mapme, "[MAP-Me] New connection %d", conn_added_id); + unsigned conn_selected_id = connection_GetConnectionId(conn_selected); + INFO(mapme, "[MAP-Me] New connection %d", conn_selected_id); - /* - * Iterate on FIB to find locally served prefix - * Ideally, we want to avoid a FIB scan everytime a face is added/removed - */ - fiblist = forwarder_GetFibEntries(mapme->forwarder); - for (size_t i = 0; i < fibEntryList_Length(fiblist); i++) { - FibEntry *fibEntry = (FibEntry *)fibEntryList_Get(fiblist, i); - const Name *name = fibEntry_GetPrefix(fibEntry); - - /* Skip entries that have no local connection as next hop */ - if (!mapMe_hasLocalNextHops(mapme, fibEntry)) continue; - - /* This entry corresponds to a locally served prefix, set - * Special Interest */ - if (!TFIB(fibEntry)) /* Create TFIB associated to FIB entry */ - mapMe_CreateTFIB(fibEntry); - TFIB(fibEntry)->seq++; - - char *name_str = name_ToString(name); - INFO(mapme, "[MAP-Me] sending IU/IN for name %s on connection %d", name_str, - conn_added_id); - free(name_str); - - mapMe_setFacePending(mapme, name, fibEntry, conn_added_id, true, true, 0); - } + const Name *name = fibEntry_GetPrefix(fibEntry); + + /* Skip entries that have no local connection as next hop */ + if (!mapMe_hasLocalNextHops(mapme, fibEntry)) + return; + + /* This entry corresponds to a locally served prefix, set + * Special Interest */ + if (!TFIB(fibEntry)) /* Create TFIB associated to FIB entry */ + mapMe_CreateTFIB(fibEntry); + TFIB(fibEntry)->seq++; + + char *name_str = name_ToString(name); + INFO(mapme, "[MAP-Me] sending IU/IN for name %s on connection %d", name_str, + conn_selected_id); + free(name_str); + + mapMe_setFacePending(mapme, name, fibEntry, conn_selected_id, true, true, 0); } +#endif /* WITH_POLICY */ /*------------------------------------------------------------------------------ * Special Interest handling @@ -497,6 +539,7 @@ static bool mapMe_onSpecialInterest(const MapMe *mapme, bool rv; Name *name = name_CreateFromPacket(msgBuffer, MessagePacketType_Interest); + name_setLen(name, prefix->len); char *name_str = name_ToString(name); INFO(mapme, "[MAP-Me] Ack'ed Special Interest on connection %d - prefix=%s type=XX " @@ -530,12 +573,34 @@ static bool mapMe_onSpecialInterest(const MapMe *mapme, */ strategy_type fwdStrategy = LAST_STRATEGY_VALUE; + /* + * It might also be due to the announcement of a more specific prefix. In + * that case we need to perform a FIB lookup to find the next hops to which + * the message should be propagated. + */ +#ifdef WITH_POLICY + fibEntry = fibEntry_Create(name, fwdStrategy, mapme->forwarder); +#else fibEntry = fibEntry_Create(name, fwdStrategy); - fibEntry_AddNexthopByConnectionId(fibEntry, conn_in_id); +#endif /* WITH_POLICY */ + FibEntry *lpm = fib_LPM(fib, name); mapMe_CreateTFIB(fibEntry); - TFIB(fibEntry)->seq = seq; // INIT_SEQ; fib_Add(fib, fibEntry); - return true; // with proper seq, we are done + if (!lpm) { + TFIB(fibEntry)->seq = seq; + fibEntry_AddNexthop(fibEntry, conn_in_id); + return true; + } + + /* + * We make a clone of the FIB entry (zero'ing the sequence number ?) with + * the more specific name, and proceed as usual. Worst case we clone the + * default route... + */ + const NumberSet *lpm_nexthops = fibEntry_GetNexthops(lpm); + for (size_t i = 0; i < numberSet_Length(lpm_nexthops); i++) { + fibEntry_AddNexthop(fibEntry, numberSet_GetItem(lpm_nexthops, i)); + } } else if (!TFIB(fibEntry)) { /* Create TFIB associated to FIB entry */ @@ -613,7 +678,7 @@ static bool mapMe_onSpecialInterest(const MapMe *mapme, INFO(mapme, "[MAP-Me] - Replaced next hops by connection %d", conn_id); fibEntry_RemoveNexthopByConnectionId(fibEntry, conn_id); } - fibEntry_AddNexthopByConnectionId(fibEntry, conn_in_id); + fibEntry_AddNexthop(fibEntry, conn_in_id); INFO(mapme, "[MAP-Me] - (2/3) processing next hops"); bool complete = true; @@ -658,7 +723,7 @@ static bool mapMe_onSpecialInterest(const MapMe *mapme, INFO(mapme, "[MAP-Me] - Adding multipath next hop on connection %d", conn_in_id); - fibEntry_AddNexthopByConnectionId(fibEntry, conn_in_id); + fibEntry_AddNexthop(fibEntry, conn_in_id); } else { // seq < fibSeq /* @@ -688,11 +753,19 @@ void mapMe_onSpecialInterestAck(const MapMe *mapme, const uint8_t *msgBuffer, mapme_params_t *params) { INFO(mapme, "[MAP-Me] Receive IU/IN Ack on connection %d", conn_in_id); - const Name *name = - name_CreateFromPacket(msgBuffer, MessagePacketType_Interest); + const Name * name = + name_CreateFromPacket(msgBuffer, MessagePacketType_ContentObject); + name_setLen(name, prefix->len); + char * name_str = name_ToString(name); + INFO(mapme, "[MAP-Me] Received ack for name prefix=%s seq=%d on conn id=%d", + name_str, params->seq, conn_in_id); + free(name_str); FIB *fib = forwarder_getFib(mapme->forwarder); FibEntry *fibEntry = fib_Contains(fib, name); + if (!fibEntry) { + return; + } parcAssertNotNull(fibEntry, "No corresponding FIB entry for name contained in IU Ack"); @@ -758,23 +831,21 @@ void mapMe_onSpecialInterestAck(const MapMe *mapme, const uint8_t *msgBuffer, /* * Returns true iif the message corresponds to a MAP-Me packet */ -bool mapMe_isMapMe(const uint8_t *msgBuffer) { - uint8_t next_header = messageHandler_NextHeaderType(msgBuffer); - - const uint8_t *icmp_ptr; - if (next_header == IPPROTO_ICMP) { - icmp_ptr = msgBuffer + IPV4_HDRLEN; - } else if (next_header == IPPROTO_ICMPV6) { - icmp_ptr = msgBuffer + IPV6_HDRLEN; - } else { - return false; +bool mapMe_isMapMe(const uint8_t *packet) { + hicn_mapme_header_t * mapme = (hicn_mapme_header_t*)packet; + + switch(HICN_IP_VERSION(packet)) { + case 4: + if (mapme->v4.ip.protocol != IPPROTO_ICMP) + return false; + return HICN_IS_MAPME(mapme->v4.icmp_rd.type, mapme->v4.icmp_rd.code); + case 6: + if (mapme->v6.ip.nxt != IPPROTO_ICMPV6) + return false; + return HICN_IS_MAPME(mapme->v6.icmp_rd.type, mapme->v6.icmp_rd.code); + default: + return false; } - - uint8_t type = ((_icmp_header_t *)icmp_ptr)->type; - uint8_t code = ((_icmp_header_t *)icmp_ptr)->code; - if (HICN_IS_MAPME(type, code)) return true; - - return false; } /** @@ -794,7 +865,6 @@ void mapMe_Process(const MapMe *mapme, const uint8_t *msgBuffer, mapme_params_t params; hicn_mapme_parse_packet(msgBuffer, &prefix, ¶ms); - // XXX Dispatch message dependenging on type switch (params.type) { case UPDATE: case NOTIFICATION: @@ -805,7 +875,7 @@ void mapMe_Process(const MapMe *mapme, const uint8_t *msgBuffer, mapMe_onSpecialInterestAck(mapme, msgBuffer, conn_id, &prefix, ¶ms); break; default: - printf("E:Unknown message\n"); + ERR(mapme, "[MAP-Me] Unknown message"); break; } } diff --git a/hicn-light/src/hicn/core/mapMe.h b/hicn-light/src/hicn/core/mapMe.h index a99d4710b..7ea90d299 100644 --- a/hicn-light/src/hicn/core/mapMe.h +++ b/hicn-light/src/hicn/core/mapMe.h @@ -26,9 +26,9 @@ #include <stdbool.h> #include <stdint.h> -#include <hicn/io/hicnListener.h> - #include <hicn/hicn.h> +#include <hicn/core/forwarder.h> +#include <hicn/core/connection.h> #include <hicn/utils/commands.h> struct mapme; @@ -63,14 +63,23 @@ void mapMe_Process(const MapMe *mapme, const uint8_t *msgBuffer, unsigned conn_id); /** - * @function mapMe_onConnectionAdded + * @function mapMe_onConnectionEvent * @abstract Callback following the addition of the face though the control * protocol. * @discussion This callback triggers the sending of control packets by MAP-Me. * @param [in] mapme - Pointer to the MAP-Me data structure. * @param [in] conn - The newly added connection. + * @param [in] event - Connection event + */ +void mapMe_onConnectionEvent(const MapMe *mapme, const Connection *conn, connection_event_t event); + +#ifdef WITH_POLICY + +/** + * @function mapMe_onPolicyUpdate */ -void mapMe_onConnectionAdded(const MapMe *mapme, const Connection *conn); +void mapMe_onPolicyUpdate(const MapMe *mapme, const Connection *conn_added, FibEntry * fibEntry); +#endif /* WITH_POLICY */ /** * @function mapMe_getNextHops diff --git a/hicn-light/src/hicn/core/message.c b/hicn-light/src/hicn/core/message.c index b0140eda4..5d0d04ae4 100644 --- a/hicn-light/src/hicn/core/message.c +++ b/hicn-light/src/hicn/core/message.c @@ -220,7 +220,6 @@ Message *message_CreateWldrNotification(Message *original, uint16_t expected, // set notification stuff. messageHandler_SetWldrNotification( message->messageHead, original->messageHead, expected, lastReceived); - // XXX: what about the checksum? return message; } diff --git a/hicn-light/src/hicn/core/messageHandler.h b/hicn-light/src/hicn/core/messageHandler.h index c1fc0481a..74535d80f 100644 --- a/hicn-light/src/hicn/core/messageHandler.h +++ b/hicn-light/src/hicn/core/messageHandler.h @@ -55,6 +55,11 @@ #include <hicn/core/forwarder.h> +#ifdef WITH_MAPME +#include <hicn/core/mapMe.h> +#include <hicn/socket/api.h> +#endif /* WITH_MAPME */ + #define CONNECTION_ID_UNDEFINED -1 static inline uint8_t messageHandler_GetIPPacketType(const uint8_t *message) { @@ -168,76 +173,32 @@ static inline uint8_t messageHandler_NextHeaderType(const uint8_t *message) { /* Forward declarations */ static inline void * messageHandler_GetSource(const uint8_t *message); - -/* Helpers */ - -// NOTE: this function is generalized from the one in hICN listener and takes a -// forwarder as parameter -static inline -const Connection * -_getConnectionFromPacket(Forwarder * forwarder, Address * localAddress, Address *packetSourceAddress) -{ - if (!packetSourceAddress) - return NULL; - - AddressPair *pair = addressPair_Create(localAddress, - packetSourceAddress); - const Connection * conn = connectionTable_FindByAddressPair( - forwarder_GetConnectionTable(forwarder), pair); - addressPair_Release(&pair); - - return conn; -} - -static inline -Address * -_createAddressFromPacket(const uint8_t *msgBuffer) -{ - Address *packetAddr = NULL; - if (messageHandler_GetIPPacketType(msgBuffer) == IPv6_TYPE) { - struct sockaddr_in6 addr_in6; - addr_in6.sin6_family = AF_INET6; - addr_in6.sin6_port = htons(1234); - addr_in6.sin6_flowinfo = 0; - addr_in6.sin6_scope_id = 0; - memcpy(&addr_in6.sin6_addr, - (struct in6_addr *)messageHandler_GetSource(msgBuffer), 16); - packetAddr = addressCreateFromInet6(&addr_in6); - } else if (messageHandler_GetIPPacketType(msgBuffer) == IPv4_TYPE) { - struct sockaddr_in addr_in; - addr_in.sin_family = AF_INET; - addr_in.sin_port = htons(1234); - memcpy(&addr_in.sin_addr, - (struct in_addr *)messageHandler_GetSource(msgBuffer), 4); - packetAddr = addressCreateFromInet(&addr_in); - } - return packetAddr; -} - -/* Hooks */ - -/* ... */ +static inline void *messageHandler_GetDestination(const uint8_t *message); /* Main hook handler */ /** * \brief Handle incoming messages * \param [in] forwarder - Reference to the Forwarder instance - * \param [in] connection_id - A hint on the connection ID on which the packet - * was received, CONNECTION_ID_UNDEFINED (-1) otherwise. - * \param [in] localAddress - Local listener address - * \param [in] messsage - Buffer possibly containing a hooked message + * \param [in] packet - Packet buffer + * \param [in] conn_id - A hint on the connection ID on which the packet + * was received * \return Flag indicating whether the packet matched a hook and was * (successfully or not) processed. */ static inline bool messageHandler_handleHooks(Forwarder * forwarder, - int connection_id, Address * localAddress, const uint8_t * message) + const uint8_t * packet, int conn_id) { - /* ... */ +#ifdef WITH_MAPME + if (mapMe_isMapMe(packet)) { + forwarder_ProcessMapMe(forwarder, packet, conn_id); + goto END; + } +#endif /* WITH_MAPME */ return false; -#if 0 // Enable and jump here when a handler has successfully processed the packet +#if 1 // Enable and jump here when a handler has successfully processed the packet END: return true; #endif diff --git a/hicn-light/src/hicn/core/name.c b/hicn-light/src/hicn/core/name.c index ed3432ec5..8cf8dacbc 100644 --- a/hicn-light/src/hicn/core/name.c +++ b/hicn-light/src/hicn/core/name.c @@ -234,3 +234,9 @@ char *name_ToString(const Name *name) { void name_setLen(const Name *name, uint8_t len) { nameBitvector_setLen(name->content_name, len); } + +#ifdef WITH_POLICY +uint32_t name_GetSuffix(const Name * name) { + return name->segment; +} +#endif /* WITH_POLICY */ diff --git a/hicn-light/src/hicn/core/name.h b/hicn-light/src/hicn/core/name.h index 8ab75cf05..4eb80cf36 100644 --- a/hicn-light/src/hicn/core/name.h +++ b/hicn-light/src/hicn/core/name.h @@ -102,4 +102,8 @@ void name_setLen(const Name *name, uint8_t len); Name *name_CreateFromAddress(address_type addressType, union commandAddr addr, uint8_t len); +#ifdef WITH_POLICY +uint32_t name_GetSuffix(const Name * name); +#endif /* WITH_POLICY */ + #endif // name_h diff --git a/hicn-light/src/hicn/io/hicnConnection.c b/hicn-light/src/hicn/io/hicnConnection.c index 6193e8696..124885b33 100644 --- a/hicn-light/src/hicn/io/hicnConnection.c +++ b/hicn-light/src/hicn/io/hicnConnection.c @@ -218,7 +218,6 @@ static void _destroy(IoOperations **opsPtr) { __func__, "HicnConnection %p destroyed", (void *)hicnConnState); } - // XXX // do not close hicListenerSocket, the listener will close // that when its done // should I say something to libhicn? @@ -279,7 +278,6 @@ static bool _send(IoOperations *ops, const Address *dummy, Message *message) { _HicnState *hicnConnState = (_HicnState *)ioOperations_GetClosure(ops); // NAT for HICN - // XXX if (message_GetType(message) == MessagePacketType_ContentObject) { // this is a data packet. We need to put the remote address in the // destination field diff --git a/hicn-light/src/hicn/io/hicnListener.c b/hicn-light/src/hicn/io/hicnListener.c index 40cdadcd6..e8cab9aca 100644 --- a/hicn-light/src/hicn/io/hicnListener.c +++ b/hicn-light/src/hicn/io/hicnListener.c @@ -29,12 +29,6 @@ #include <hicn/core/connection.h> #include <hicn/core/connectionTable.h> #include <hicn/core/forwarder.h> -#ifdef WITH_MAPME -#include <hicn/config/symbolicNameTable.h> -#include <hicn/core/mapMe.h> -#include <hicn/core/message.h> -#include <hicn/io/hicnTunnel.h> -#endif /* WITH_MAPME */ #include <parc/algol/parc_Memory.h> #include <parc/algol/parc_Network.h> #include <parc/assert/parc_Assert.h> @@ -82,13 +76,19 @@ static unsigned _getInterfaceIndex(const ListenerOps *ops); static const Address *_getListenAddress(const ListenerOps *ops); static EncapType _getEncapType(const ListenerOps *ops); static int _getSocket(const ListenerOps *ops); - -static ListenerOps _hicnTemplate = {.context = NULL, - .destroy = &_destroy, - .getInterfaceIndex = &_getInterfaceIndex, - .getListenAddress = &_getListenAddress, - .getEncapType = &_getEncapType, - .getSocket = &_getSocket}; +static unsigned _createNewConnection(ListenerOps *listener, int fd, const AddressPair *pair); +static const Connection * _lookupConnection(ListenerOps * listener, const AddressPair *pair); + +static ListenerOps _hicnTemplate = { + .context = NULL, + .destroy = &_destroy, + .getInterfaceIndex = &_getInterfaceIndex, + .getListenAddress = &_getListenAddress, + .getEncapType = &_getEncapType, + .getSocket = &_getSocket, + .createConnection = &_createNewConnection, + .lookupConnection = &_lookupConnection, +}; static void _hicnListener_readcb(int fd, PARCEventType what, void *hicnVoid); @@ -177,12 +177,6 @@ ListenerOps *hicnListener_CreateInet(Forwarder *forwarder, char *symbolic, parcAssertFalse(failure, "fcntl failed to set file descriptor flags (%d)", errno); - hicn->hicn_event = dispatcher_CreateNetworkEvent( - forwarder_GetDispatcher(forwarder), true, _hicnListener_readcb, - (void *)hicn, hicn->hicn_fd); - dispatcher_StartNetworkEvent(forwarder_GetDispatcher(forwarder), - hicn->hicn_event); - ListenerOps *ops = parcMemory_AllocateAndClear(sizeof(ListenerOps)); parcAssertNotNull(ops, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(ListenerOps)); @@ -190,6 +184,13 @@ ListenerOps *hicnListener_CreateInet(Forwarder *forwarder, char *symbolic, memcpy(ops, &_hicnTemplate, sizeof(ListenerOps)); ops->context = hicn; + hicn->hicn_event = dispatcher_CreateNetworkEvent( + forwarder_GetDispatcher(forwarder), true, _hicnListener_readcb, + (void *)ops, hicn->hicn_fd); + dispatcher_StartNetworkEvent(forwarder_GetDispatcher(forwarder), + hicn->hicn_event); + + if (logger_IsLoggable(hicn->logger, LoggerFacility_IO, PARCLogLevel_Debug)) { logger_Log(hicn->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__, "HicnListener %s created", symbolic); @@ -267,12 +268,6 @@ ListenerOps *hicnListener_CreateInet6(Forwarder *forwarder, char *symbolic, parcAssertFalse(failure, "fcntl failed to set file descriptor flags (%d)", errno); - hicn->hicn_event = dispatcher_CreateNetworkEvent( - forwarder_GetDispatcher(forwarder), true, _hicnListener_readcb, - (void *)hicn, hicn->hicn_fd); - dispatcher_StartNetworkEvent(forwarder_GetDispatcher(forwarder), - hicn->hicn_event); - ListenerOps *ops = parcMemory_AllocateAndClear(sizeof(ListenerOps)); parcAssertNotNull(ops, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(ListenerOps)); @@ -280,6 +275,12 @@ ListenerOps *hicnListener_CreateInet6(Forwarder *forwarder, char *symbolic, memcpy(ops, &_hicnTemplate, sizeof(ListenerOps)); ops->context = hicn; + hicn->hicn_event = dispatcher_CreateNetworkEvent( + forwarder_GetDispatcher(forwarder), true, _hicnListener_readcb, + (void *)ops, hicn->hicn_fd); + dispatcher_StartNetworkEvent(forwarder_GetDispatcher(forwarder), + hicn->hicn_event); + if (logger_IsLoggable(hicn->logger, LoggerFacility_IO, PARCLogLevel_Debug)) { logger_Log(hicn->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__, "HicnListener %s created", symbolic); @@ -405,7 +406,6 @@ static void _hicnListener_Destroy(HicnListener **listenerPtr) { HicnListener *hicn = *listenerPtr; - // close(hicn->hicn_fd); //XXX close the fd in the hicnlib (detroy listener?) dispatcher_DestroyNetworkEvent(forwarder_GetDispatcher(hicn->forwarder), &hicn->hicn_event); logger_Release(&hicn->logger); @@ -454,8 +454,6 @@ static void _readFrameToDiscard(HicnListener *hicn, int fd) { "Discarded frame from fd %d", fd); } } else if (nread < 0) { - printf("Error trying to discard frame from fd %d: (%d) %s", fd, errno, - strerror(errno)); if (logger_IsLoggable(hicn->logger, LoggerFacility_IO, PARCLogLevel_Error)) { logger_Log(hicn->logger, LoggerFacility_IO, PARCLogLevel_Error, __func__, @@ -465,8 +463,9 @@ static void _readFrameToDiscard(HicnListener *hicn, int fd) { } } -static unsigned _createNewConnection(HicnListener *hicn, int fd, +static unsigned _createNewConnection(ListenerOps * listener, int fd, const AddressPair *pair) { + HicnListener * hicn = (HicnListener *)listener->context; bool isLocal = false; // udpConnection_Create takes ownership of the pair @@ -479,8 +478,11 @@ static unsigned _createNewConnection(HicnListener *hicn, int fd, return connid; } -const Connection *_findConnectionFromPacket(HicnListener *hicn, - Address *packetSourceAddress) { +static const Connection * _lookupConnection(ListenerOps * listener, + const AddressPair *pair) { + HicnListener * hicn = (HicnListener*)listener->context; + const Address * packetSourceAddress = addressPair_GetLocal(pair); + const Connection *conn = NULL; if (hicn->connection_id != -1) { conn = connectionTable_FindById( @@ -500,7 +502,6 @@ const Connection *_findConnectionFromPacket(HicnListener *hicn, return conn; } -#if 0 static Address *_createAddressFromPacket(uint8_t *msgBuffer) { Address *packetAddr = NULL; if (messageHandler_GetIPPacketType(msgBuffer) == IPv6_TYPE) { @@ -522,25 +523,33 @@ static Address *_createAddressFromPacket(uint8_t *msgBuffer) { } return packetAddr; } -#endif -static void _handleProbeMessage(HicnListener *hicn, uint8_t *msgBuffer) { +static void _handleProbeMessage(ListenerOps * listener, uint8_t *msgBuffer) { + HicnListener * hicn = (HicnListener *)listener->context; + Address *packetAddr = _createAddressFromPacket(msgBuffer); + AddressPair * pair = addressPair_Create(packetAddr, /* dummy */ hicn->localAddress); - if (packetAddr != NULL) { - const Connection *conn = _findConnectionFromPacket(hicn, packetAddr); - if (conn != NULL) { - // we drop all the probes for a connection that does not exists - connection_HandleProbe((Connection *)conn, msgBuffer, - forwarder_GetTicks(hicn->forwarder)); - } - } + if (!packetAddr) + goto DROP; + + // we drop all the probes for a connection that does not exists + const Connection *conn = _lookupConnection(listener, pair); + if (!conn) + goto DROP; + + connection_HandleProbe((Connection *)conn, msgBuffer, + forwarder_GetTicks(hicn->forwarder)); +DROP: + addressPair_Release(&pair); addressDestroy(&packetAddr); parcMemory_Deallocate((void **)&msgBuffer); } -static void _handleWldrNotification(HicnListener *hicn, uint8_t *msgBuffer) { +static void _handleWldrNotification(ListenerOps *listener, uint8_t *msgBuffer) { + HicnListener * hicn = (HicnListener *)listener->context; + Address *packetAddr = _createAddressFromPacket(msgBuffer); if (packetAddr == NULL) { @@ -548,14 +557,18 @@ static void _handleWldrNotification(HicnListener *hicn, uint8_t *msgBuffer) { return; } - const Connection *conn = _findConnectionFromPacket(hicn, packetAddr); + AddressPair * pair = addressPair_Create(packetAddr, /* dummy */ hicn->localAddress); + + const Connection *conn = _lookupConnection(listener, pair); + + addressPair_Release(&pair); + addressDestroy(&packetAddr); + if (conn == NULL) { - addressDestroy(&packetAddr); + parcMemory_Deallocate((void **)&msgBuffer); return; } - addressDestroy(&packetAddr); - Message *message = message_CreateFromByteArray( connection_GetConnectionId(conn), msgBuffer, MessagePacketType_WldrNotification, forwarder_GetTicks(hicn->forwarder), @@ -566,75 +579,87 @@ static void _handleWldrNotification(HicnListener *hicn, uint8_t *msgBuffer) { message_Release(&message); } -#ifdef WITH_MAPME -static void _handleMapMe(HicnListener *hicn, int fd, uint8_t *msgBuffer) { - Address *packetAddr = _createAddressFromPacket(msgBuffer); - - if (packetAddr == NULL) { - parcMemory_Deallocate((void **)&msgBuffer); - return; - } - - const Connection *conn = _findConnectionFromPacket(hicn, packetAddr); - unsigned conn_id; - if (conn == NULL) { - /* Unlike the interest path, we don't create virtual connections bound - * on the listener, whose only interest is to send data, but full - * tunnels to be able to route interests - * - * packetAddr is the remote address, we need to ask the lib for our - * local address - * hicn->localAddress is None as the interest is received by the main - * listener. - */ - printf("MapMe, connection did not exist, creating\n"); - - /* Populate remote_address through packetAddr */ - struct sockaddr_in6 sockaddr; // XXX IPv6 only - addressGetInet6(packetAddr, &sockaddr); - ip_address_t remote_address = {.family = AF_INET6, - .prefix_len = IPV6_ADDR_LEN_BITS}; - memcpy(&remote_address.buffer, &sockaddr.sin6_addr, - ip_address_len(&remote_address)); - - /* Get local address through libhicn */ - ip_address_t local_address; - int rc = hicn_get_local_address(&remote_address, &local_address); - if (rc < 0) { - printf("Error getting local address. Discarded mapme packet.\n"); - return; - } +static const +AddressPair * +_createRecvAddressPairFromPacket(const uint8_t *msgBuffer) { + Address *packetSrcAddr = NULL; /* This one is in the packet */ + Address *localAddr = NULL; /* This one is to be determined */ + if (messageHandler_GetIPPacketType(msgBuffer) == IPv6_TYPE) { struct sockaddr_in6 addr_in6; addr_in6.sin6_family = AF_INET6; addr_in6.sin6_port = htons(1234); addr_in6.sin6_flowinfo = 0; addr_in6.sin6_scope_id = 0; - memcpy(&addr_in6.sin6_addr, (struct in6_addr *)&(local_address.buffer), 16); + memcpy(&addr_in6.sin6_addr, + (struct in6_addr *)messageHandler_GetSource(msgBuffer), 16); + packetSrcAddr = addressCreateFromInet6(&addr_in6); + + /* We now determine the local address used to reach the packet src address */ + int sock = socket (AF_INET6, SOCK_DGRAM, 0); + if (sock < 0) + goto ERR; + + struct sockaddr_in6 remote, local; + memset(&remote, 0, sizeof(remote)); + remote.sin6_family = AF_INET6; + remote.sin6_addr = addr_in6.sin6_addr; + remote.sin6_port = htons(1234); + + socklen_t locallen = sizeof(local); + if (connect(sock, (const struct sockaddr*)&remote, sizeof(remote)) == -1) + goto ERR; + if (getsockname(sock, (struct sockaddr*) &local, &locallen) == -1) + goto ERR; - Address *localAddr = addressCreateFromInet6(&addr_in6); - IoOperations *ops = - hicnTunnel_Create(hicn->forwarder, localAddr, packetAddr); + local.sin6_port = htons(1234); + localAddr = addressCreateFromInet6(&local); - if (!ops) { - printf("Error creating tunnel. Discarded mapme packet.\n"); - return; + close(sock); + + } else if (messageHandler_GetIPPacketType(msgBuffer) == IPv4_TYPE) { + struct sockaddr_in addr_in; + addr_in.sin_family = AF_INET; + addr_in.sin_port = htons(1234); + memcpy(&addr_in.sin_addr, + (struct in_addr *)messageHandler_GetSource(msgBuffer), 4); + packetSrcAddr = addressCreateFromInet(&addr_in); + + /* We now determine the local address used to reach the packet src address */ + + int sock = socket (AF_INET, SOCK_DGRAM, 0); + if (sock < 0) { + perror("Socket error"); + goto ERR; } - conn = connection_Create(ops); + struct sockaddr_in remote, local; + memset(&remote, 0, sizeof(remote)); + remote.sin_family = AF_INET; + remote.sin_addr = addr_in.sin_addr; + remote.sin_port = htons(1234); - connectionTable_Add(forwarder_GetConnectionTable(hicn->forwarder), - (Connection *)conn); - } - conn_id = connection_GetConnectionId(conn); + socklen_t locallen = sizeof(local); + if (connect(sock, (const struct sockaddr*)&remote, sizeof(remote)) == -1) + goto ERR; + if (getsockname(sock, (struct sockaddr*) &local, &locallen) == -1) + goto ERR; - addressDestroy(&packetAddr); + local.sin_port = htons(1234); + localAddr = addressCreateFromInet(&local); + + close(sock); + } + /* As this is a receive pair, we swap src and dst */ + return addressPair_Create(localAddr, packetSrcAddr); - forwarder_ProcessMapMe(hicn->forwarder, msgBuffer, conn_id); +ERR: + perror("Socket error"); + return NULL; } -#endif /* WITH_MAPME */ -static Message *_readMessage(HicnListener *hicn, int fd, uint8_t *msgBuffer) { +static Message *_readMessage(ListenerOps * listener, int fd, uint8_t *msgBuffer) { + HicnListener * hicn = (HicnListener*)listener->context; Message *message = NULL; ssize_t readLength = read(fd, msgBuffer, MTU_SIZE); @@ -667,11 +692,13 @@ static Message *_readMessage(HicnListener *hicn, int fd, uint8_t *msgBuffer) { // run time) uses as a local address 0::0, so the main tun pktType = MessagePacketType_Interest; Address *packetAddr = _createAddressFromPacket(msgBuffer); - const Connection *conn = _findConnectionFromPacket(hicn, packetAddr); + AddressPair *pair_find = addressPair_Create(packetAddr, /* dummy */ hicn->localAddress); + const Connection *conn = _lookupConnection(listener, pair_find); + addressPair_Release(&pair_find); if (conn == NULL) { AddressPair *pair = addressPair_Create(hicn->localAddress, packetAddr); - connid = _createNewConnection(hicn, fd, pair); + connid = _createNewConnection(listener, fd, pair); addressPair_Release(&pair); } else { connid = connection_GetConnectionId(conn); @@ -690,42 +717,52 @@ static Message *_readMessage(HicnListener *hicn, int fd, uint8_t *msgBuffer) { parcMemory_Deallocate((void **)&msgBuffer); } } else if (messageHandler_IsWldrNotification(msgBuffer)) { - _handleWldrNotification(hicn, msgBuffer); + _handleWldrNotification(listener, msgBuffer); } else if (messageHandler_IsLoadBalancerProbe(msgBuffer)) { - _handleProbeMessage(hicn, msgBuffer); -#ifdef WITH_MAPME - } else if (mapMe_isMapMe(msgBuffer)) { - /* This function triggers the handling of the MAP-Me message, and we - * will return NULL so as to terminate the processing of this - * msgBuffer. */ - _handleMapMe(hicn, fd, msgBuffer); -#endif /* WITH_MAPME */ - } + _handleProbeMessage(listener, msgBuffer); + } else { + const AddressPair * pair = _createRecvAddressPairFromPacket(msgBuffer); + if (!pair) + goto ERR; + + /* Find connection and eventually create it */ + const Connection * conn = connectionTable_FindByAddressPair( + forwarder_GetConnectionTable(hicn->forwarder), pair); + unsigned conn_id; + if (conn == NULL) { + conn_id = listener->createConnection(listener, fd, pair); + } else { + conn_id = connection_GetConnectionId(conn); + } - if (messageHandler_handleHooks(hicn->forwarder, hicn->connection_id, - hicn->localAddress, msgBuffer)) - goto END; + messageHandler_handleHooks(hicn->forwarder, msgBuffer, conn_id); + +ERR: + parcMemory_Deallocate((void **)&msgBuffer); + + } -END: return message; } -static void _receivePacket(HicnListener *hicn, int fd) { +static void _receivePacket(ListenerOps * listener, int fd) { + HicnListener * hicn = (HicnListener*)listener->context; Message *msg = NULL; uint8_t *msgBuffer = parcMemory_AllocateAndClear(MTU_SIZE); - msg = _readMessage(hicn, fd, msgBuffer); + msg = _readMessage(listener, fd, msgBuffer); if (msg) { forwarder_Receive(hicn->forwarder, msg); } } -static void _hicnListener_readcb(int fd, PARCEventType what, void *hicnVoid) { - HicnListener *hicn = (HicnListener *)hicnVoid; +static void _hicnListener_readcb(int fd, PARCEventType what, void *listener_void) { + ListenerOps * listener = (ListenerOps *)listener_void; + HicnListener *hicn = (HicnListener *)listener->context; if (hicn->inetFamily == IPv4 || hicn->inetFamily == IPv6) { if (what & PARCEventType_Read) { - _receivePacket(hicn, fd); + _receivePacket(listener, fd); } } else { _readFrameToDiscard(hicn, fd); diff --git a/hicn-light/src/hicn/io/listener.h b/hicn-light/src/hicn/io/listener.h index 3d195ee88..ef1955b12 100644 --- a/hicn-light/src/hicn/io/listener.h +++ b/hicn-light/src/hicn/io/listener.h @@ -27,6 +27,8 @@ #define listener_h #include <hicn/utils/address.h> +#include <hicn/io/addressPair.h> +#include <hicn/core/connection.h> struct listener_ops; typedef struct listener_ops ListenerOps; @@ -101,5 +103,8 @@ struct listener_ops { * @endcode */ int (*getSocket)(const ListenerOps *ops); + + unsigned (*createConnection)(ListenerOps *listener, int fd, const AddressPair *pair); + const Connection * (*lookupConnection)(ListenerOps * listener, const AddressPair *pair); }; #endif // listener_h diff --git a/hicn-light/src/hicn/io/udpListener.c b/hicn-light/src/hicn/io/udpListener.c index 3dd4b466c..32f633984 100644 --- a/hicn-light/src/hicn/io/udpListener.c +++ b/hicn-light/src/hicn/io/udpListener.c @@ -36,10 +36,6 @@ #include <hicn/core/forwarder.h> #include <hicn/core/messagePacketType.h> -#ifdef WITH_MAPME -#include <hicn/core/mapMe.h> -#endif /* WITH_MAPME */ - #define IPv4 4 #define IPv6 6 @@ -60,15 +56,21 @@ static unsigned _getInterfaceIndex(const ListenerOps *ops); static const Address *_getListenAddress(const ListenerOps *ops); static EncapType _getEncapType(const ListenerOps *ops); static int _getSocket(const ListenerOps *ops); +static unsigned _createNewConnection(ListenerOps *listener, int fd, const AddressPair *pair); +static const Connection * _lookupConnection(ListenerOps * listener, const AddressPair *pair); + +static ListenerOps udpTemplate = { + .context = NULL, + .destroy = &_destroy, + .getInterfaceIndex = &_getInterfaceIndex, + .getListenAddress = &_getListenAddress, + .getEncapType = &_getEncapType, + .getSocket = &_getSocket, + .createConnection = &_createNewConnection, + .lookupConnection = &_lookupConnection, +}; -static ListenerOps udpTemplate = {.context = NULL, - .destroy = &_destroy, - .getInterfaceIndex = &_getInterfaceIndex, - .getListenAddress = &_getListenAddress, - .getEncapType = &_getEncapType, - .getSocket = &_getSocket}; - -static void _readcb(int fd, PARCEventType what, void *udpVoid); +static void _readcb(int fd, PARCEventType what, void * listener_void); #ifdef __linux__ ListenerOps *udpListener_CreateInet6(Forwarder *forwarder, @@ -123,11 +125,6 @@ ListenerOps *udpListener_CreateInet6(Forwarder *forwarder, setsockopt(udp->udp_socket, SOL_SOCKET, SO_BINDTODEVICE, interfaceName, strlen(interfaceName) + 1); #endif - udp->udp_event = - dispatcher_CreateNetworkEvent(forwarder_GetDispatcher(forwarder), true, - _readcb, (void *)udp, udp->udp_socket); - dispatcher_StartNetworkEvent(forwarder_GetDispatcher(forwarder), - udp->udp_event); ops = parcMemory_AllocateAndClear(sizeof(ListenerOps)); parcAssertNotNull(ops, "parcMemory_AllocateAndClear(%zu) returned NULL", @@ -135,6 +132,12 @@ ListenerOps *udpListener_CreateInet6(Forwarder *forwarder, memcpy(ops, &udpTemplate, sizeof(ListenerOps)); ops->context = udp; + udp->udp_event = + dispatcher_CreateNetworkEvent(forwarder_GetDispatcher(forwarder), true, + _readcb, (void*)ops, udp->udp_socket); + dispatcher_StartNetworkEvent(forwarder_GetDispatcher(forwarder), + udp->udp_event); + if (logger_IsLoggable(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug)) { char *str = addressToString(udp->localAddress); logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__, @@ -214,18 +217,19 @@ ListenerOps *udpListener_CreateInet(Forwarder *forwarder, setsockopt(udp->udp_socket, SOL_SOCKET, SO_BINDTODEVICE, interfaceName, strlen(interfaceName) + 1); #endif - udp->udp_event = - dispatcher_CreateNetworkEvent(forwarder_GetDispatcher(forwarder), true, - _readcb, (void *)udp, udp->udp_socket); - dispatcher_StartNetworkEvent(forwarder_GetDispatcher(forwarder), - udp->udp_event); - ops = parcMemory_AllocateAndClear(sizeof(ListenerOps)); parcAssertNotNull(ops, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(ListenerOps)); memcpy(ops, &udpTemplate, sizeof(ListenerOps)); ops->context = udp; + udp->udp_event = + dispatcher_CreateNetworkEvent(forwarder_GetDispatcher(forwarder), true, + _readcb, (void *)ops, udp->udp_socket); + dispatcher_StartNetworkEvent(forwarder_GetDispatcher(forwarder), + udp->udp_event); + + if (logger_IsLoggable(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug)) { char *str = addressToString(udp->localAddress); logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__, @@ -341,28 +345,12 @@ static AddressPair *_constructAddressPair(UdpListener *udp, return pair; } -/** - * @function _lookupConnectionId - * @abstract Lookup a connection in the connection table - * @discussion - * Looks up the connection in the connection table and returns the connection - * id if it exists. - * - * @param outputConnectionIdPtr is the output parameter - * @return true if connection found and outputConnectionIdPtr set - */ -static bool _lookupConnectionId(UdpListener *udp, AddressPair *pair, - unsigned *outputConnectionIdPtr) { +static const Connection * _lookupConnection(ListenerOps * listener, + const AddressPair *pair) { + UdpListener * udp = (UdpListener *)listener->context; ConnectionTable *connTable = forwarder_GetConnectionTable(udp->forwarder); + return connectionTable_FindByAddressPair(connTable, pair); - const Connection *conn = connectionTable_FindByAddressPair(connTable, pair); - if (conn) { - *outputConnectionIdPtr = connection_GetConnectionId(conn); - return true; - } else { - *outputConnectionIdPtr = 0; - return false; - } } /** @@ -378,8 +366,10 @@ static bool _lookupConnectionId(UdpListener *udp, AddressPair *pair, * @return The connection id for the new connection */ -static unsigned _createNewConnection(UdpListener *udp, int fd, +static unsigned _createNewConnection(ListenerOps * listener, int fd, const AddressPair *pair) { + UdpListener * udp = (UdpListener *)listener->context; + //check it the connection is local bool isLocal = false; const Address *localAddress = addressPair_GetLocal(pair); @@ -428,13 +418,23 @@ static void _handleWldrNotification(UdpListener *udp, unsigned connId, message_Release(&message); } -static Message *_readMessage(UdpListener *udp, int fd, +static Message *_readMessage(ListenerOps * ops, int fd, AddressPair *pair, uint8_t * packet, bool * processed) { + UdpListener * udp = (UdpListener *)ops->context; Message *message = NULL; - unsigned connid = 0; - bool foundConnection = _lookupConnectionId(udp, pair, &connid); + unsigned connid; + bool foundConnection; + + const Connection *conn = _lookupConnection(ops, pair); + if (conn) { + connid = connection_GetConnectionId(conn); + foundConnection = true; + } else { + connid = 0; + foundConnection = false; + } if (messageHandler_IsTCP(packet)) { *processed = true; @@ -449,7 +449,7 @@ static Message *_readMessage(UdpListener *udp, int fd, } else if (messageHandler_IsInterest(packet)) { pktType = MessagePacketType_Interest; if (!foundConnection) { - connid = _createNewConnection(udp, fd, pair); + connid = _createNewConnection(ops, fd, pair); } } else { printf("Got a packet that is not a data nor an interest, drop it!\n"); @@ -470,25 +470,20 @@ static Message *_readMessage(UdpListener *udp, int fd, } else if (messageHandler_IsLoadBalancerProbe(packet)) { *processed = true; _handleProbeMessage(udp, packet); -#ifdef WITH_MAPME - } else if (mapMe_isMapMe(packet)) { - *processed = true; - forwarder_ProcessMapMe(udp->forwarder, packet, connid); -#endif /* WITH_MAPME */ - } + } else { + /* Generic hook handler */ + if (!foundConnection) + connid = _createNewConnection(ops, fd, pair); - /* Generic hook handler */ - if (messageHandler_handleHooks(udp->forwarder, CONNECTION_ID_UNDEFINED, - udp->localAddress, packet)) - goto END; -END: + *processed = messageHandler_handleHooks(udp->forwarder, packet, connid); + } return message; } -static void _readCommand(UdpListener *udp, int fd, - AddressPair *pair, - uint8_t * command) { +static void _readCommand(ListenerOps * listener, int fd, + AddressPair *pair, uint8_t * command) { + UdpListener * udp = (UdpListener *)listener->context; if (*command != REQUEST_LIGHT){ printf("the message received is not a command, drop\n"); @@ -502,10 +497,13 @@ static void _readCommand(UdpListener *udp, int fd, return; } - unsigned connid = 0; - bool foundConnection = _lookupConnectionId(udp, pair, &connid); - if(!foundConnection){ - connid = _createNewConnection(udp, fd, pair); + unsigned connid; + + const Connection *conn = _lookupConnection(listener, pair); + if (conn) { + connid = connection_GetConnectionId(conn); + } else { + connid = _createNewConnection(listener, fd, pair); } struct iovec *request; @@ -525,11 +523,12 @@ static void _readCommand(UdpListener *udp, int fd, } -static bool _receivePacket(UdpListener *udp, int fd, +static bool _receivePacket(ListenerOps * listener, int fd, AddressPair *pair, uint8_t * packet) { + UdpListener * udp = (UdpListener *)listener->context; bool processed = false; - Message *message = _readMessage(udp, fd, pair, + Message *message = _readMessage(listener, fd, pair, packet, &processed); if (message) { forwarder_Receive(udp->forwarder, message); @@ -537,8 +536,9 @@ static bool _receivePacket(UdpListener *udp, int fd, return processed; } -static void _readcb(int fd, PARCEventType what, void *udpVoid) { - UdpListener *udp = (UdpListener *)udpVoid; +static void _readcb(int fd, PARCEventType what, void * listener_void) { + ListenerOps * listener = (ListenerOps *)listener_void; + UdpListener * udp = (UdpListener *)listener->context; if (logger_IsLoggable(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug)) { logger_Log(udp->logger, LoggerFacility_IO, PARCLogLevel_Debug, __func__, @@ -546,7 +546,7 @@ static void _readcb(int fd, PARCEventType what, void *udpVoid) { (what & PARCEventType_Timeout) ? " timeout" : "", (what & PARCEventType_Read) ? " read" : "", (what & PARCEventType_Write) ? " write" : "", - (what & PARCEventType_Signal) ? " signal" : "", udpVoid); + (what & PARCEventType_Signal) ? " signal" : "", udp); } if (what & PARCEventType_Read) { @@ -570,9 +570,9 @@ static void _readcb(int fd, PARCEventType what, void *udpVoid) { AddressPair *pair = _constructAddressPair( udp, (struct sockaddr *)&peerIpAddress, peerIpAddressLength); - bool done = _receivePacket(udp, fd, pair, packet); + bool done = _receivePacket(listener, fd, pair, packet); if(!done){ - _readCommand(udp, fd, pair, packet); + _readCommand(listener, fd, pair, packet); } addressPair_Release(&pair); diff --git a/hicn-light/src/hicn/processor/fib.c b/hicn-light/src/hicn/processor/fib.c index 19e4db60b..7cb94d4ba 100644 --- a/hicn-light/src/hicn/processor/fib.c +++ b/hicn-light/src/hicn/processor/fib.c @@ -81,7 +81,6 @@ void _destroyNode(FibNode *n) { } void _destroyFib(FIB *fib) { - // XXX // to be done return; } @@ -103,6 +102,13 @@ void fib_Add(FIB *fib, FibEntry *entry) { NameBitvector *name = name_GetContentName(fibEntry_GetPrefix(entry)); + //if the name len is 0, we add this entry on the root + if(nameBitvector_GetLength(name) == 0){ + fib->size++; + fib->root->entry = entry; + return; + } + // search the name FibNode *prev = fib->root; FibNode *curr; @@ -122,7 +128,7 @@ void fib_Add(FIB *fib, FibEntry *entry) { } } - if (curr->entry != NULL && + if (curr->entry != NULL && curr->pos != NULL_POS && nameBitvector_Equals( name, name_GetContentName(fibEntry_GetPrefix(curr->entry)))) { // there is already an entry with this name @@ -134,9 +140,10 @@ void fib_Add(FIB *fib, FibEntry *entry) { // if the name is not in the FIB search for the first different bit between // the new name to add and the node found in the trie uint8_t pos = MSB_POS; - if (curr->entry != NULL) + if (curr->entry != NULL && curr->pos != NULL_POS){ pos = nameBitvector_firstDiff( name, name_GetContentName(fibEntry_GetPrefix(curr->entry))); + } // reset pointer and search the insertion point prev = fib->root; @@ -182,6 +189,13 @@ FibEntry *fib_Contains(const FIB *fib, const Name *prefix) { NameBitvector *name = name_GetContentName(prefix); + //if prefix len is 0 it must be stored in the root. + //if the root entry is null we need to create it, otherwise + //we just need to add an other nexthop + if(nameBitvector_GetLength(name) == 0){ + return fib->root->entry; + } + // this is the same as the first part of the add function // we cannnot call this function inside the add because // we need the pointer prev and curr for the insertion @@ -204,7 +218,7 @@ FibEntry *fib_Contains(const FIB *fib, const Name *prefix) { } } - if (curr->entry != NULL && + if (curr->entry != NULL && curr->pos != NULL_POS && nameBitvector_Equals( name, name_GetContentName(fibEntry_GetPrefix(curr->entry)))) { return curr->entry; @@ -333,7 +347,17 @@ void fib_Remove(FIB *fib, const Name *name, unsigned connId) { fibEntry_RemoveNexthopByConnectionId(entry, connId); if (fibEntry_NexthopCount(entry) == 0) { - _removeNode(fib, name); + //if the len is 0, just release the fibEntry on the root node + if(nameBitvector_GetLength( + name_GetContentName(fibEntry_GetPrefix(entry))) == 0){ + parcAssertTrue(entry == fib->root->entry, + "prefix len == 0, entry is not in the FIB root"); + fib->size--; + fibEntry_Release(&entry); + fib->root->entry = NULL; + } else { + _removeNode(fib, name); + } } } @@ -352,10 +376,20 @@ void _removeConnectionId(FibNode *n, unsigned pos, unsigned connectionId, void fib_RemoveConnectionId(FIB *fib, unsigned connectionId) { parcAssertNotNull(fib, "Parameter must be non-null"); + // 0 - remove the connection id from the root // 1 - we vist the tree to remove the connection id // 2 - during the visit we collect the fib entry with 0 nexthop // 3 - after the visit we remove this entries + if(fib->root->entry){ + fibEntry_RemoveNexthopByConnectionId(fib->root->entry, connectionId); + if(fibEntry_NexthopCount(fib->root->entry) == 0){ + fib->size--; + fibEntry_Release(&fib->root->entry); + fib->root->entry = NULL; + } + } + FibEntryList *list = fibEntryList_Create(); _removeConnectionId(fib->root->left, fib->root->pos, connectionId, list); @@ -393,7 +427,7 @@ FibEntry *fib_Match(const FIB *fib, const Message *interestMessage) { while (prev->pos > curr->pos) { prev = curr; - if (curr->entry != NULL) { + if (curr->entry != NULL && curr->pos != NULL_POS) { if (nameBitvector_StartsWith( name, name_GetContentName(fibEntry_GetPrefix(curr->entry))) && nameBitvector_GetLength( @@ -410,7 +444,7 @@ FibEntry *fib_Match(const FIB *fib, const Message *interestMessage) { curr = curr->left; } - if (curr->entry != NULL) { + if (curr->entry != NULL && curr->pos != NULL_POS) { if (nameBitvector_StartsWith( name, name_GetContentName(fibEntry_GetPrefix(curr->entry))) && nameBitvector_GetLength( @@ -424,10 +458,73 @@ FibEntry *fib_Match(const FIB *fib, const Message *interestMessage) { if (match != NULL && match->entry != NULL) { return match->entry; } else { - return NULL; + //if there is a default route, return it. + //the dafualt route is in the route + return fib->root->entry; } } +#ifdef WITH_MAPME + +FibEntry *fib_LPM(const FIB *fib, const Name * prefix) { + parcAssertNotNull(fib, "Parameter must be non-null"); + parcAssertNotNull(prefix, "Parameter must be non-null"); + + NameBitvector *name = name_GetContentName(prefix); + + FibNode *prev = fib->root; + FibNode *curr; + + FibNode *match = NULL; + unsigned len = 0; + + if (nameBitvector_testBit(name, MSB_POS)) + curr = fib->root->right; + else + curr = fib->root->left; + + while (prev->pos > curr->pos) { + prev = curr; + + if (curr->entry != NULL && curr->pos != NULL_POS) { + if (nameBitvector_StartsWith( + name, name_GetContentName(fibEntry_GetPrefix(curr->entry))) && + nameBitvector_GetLength( + name_GetContentName(fibEntry_GetPrefix(curr->entry))) > len) { + match = curr; + len = nameBitvector_GetLength( + name_GetContentName(fibEntry_GetPrefix(curr->entry))); + } + } + + if (nameBitvector_testBit(name, curr->pos)) + curr = curr->right; + else + curr = curr->left; + } + + if (curr->entry != NULL && curr->pos != NULL_POS) { + if (nameBitvector_StartsWith( + name, name_GetContentName(fibEntry_GetPrefix(curr->entry))) && + nameBitvector_GetLength( + name_GetContentName(fibEntry_GetPrefix(curr->entry))) > len) { + match = curr; + len = nameBitvector_GetLength( + name_GetContentName(fibEntry_GetPrefix(curr->entry))); + } + } + + if (match != NULL && match->entry != NULL) { + return match->entry; + } else { + //if there is a default route, return it. + //the dafualt route is in the route + return fib->root->entry; + } +} + +#endif /* WITH_MAPME */ + void _collectFibEntries(FibNode *n, int pos, FibEntryList *list) { if (n->pos < (unsigned)pos) { fibEntryList_Append(list, n->entry); @@ -441,6 +538,10 @@ FibEntryList *fib_GetEntries(const FIB *fib) { FibEntryList *list = fibEntryList_Create(); + if(fib->root->entry){ + fibEntryList_Append(list, fib->root->entry); + } + _collectFibEntries(fib->root->left, fib->root->pos, list); _collectFibEntries(fib->root->right, fib->root->pos, list); diff --git a/hicn-light/src/hicn/processor/fib.h b/hicn-light/src/hicn/processor/fib.h index 28ea19a0d..8c03537fe 100644 --- a/hicn-light/src/hicn/processor/fib.h +++ b/hicn-light/src/hicn/processor/fib.h @@ -37,6 +37,10 @@ void fib_RemoveConnectionId(FIB *fib, unsigned connectionId); FibEntry *fib_Match(const FIB *fib, const Message *interestMessage); +#ifdef WITH_MAPME +FibEntry *fib_LPM(const FIB *fib, const Name * name); +#endif /* WITH_MAPME */ + size_t fib_Length(const FIB *fib); FibEntryList *fib_GetEntries(const FIB *fib); diff --git a/hicn-light/src/hicn/processor/fibEntry.c b/hicn-light/src/hicn/processor/fibEntry.c index 6f6b3aa12..15d754168 100644 --- a/hicn-light/src/hicn/processor/fibEntry.c +++ b/hicn-light/src/hicn/processor/fibEntry.c @@ -35,18 +35,47 @@ #include <parc/assert/parc_Assert.h> #include <hicn/utils/commands.h> +#include <hicn/core/connectionState.h> + +#ifdef WITH_POLICY +#include <hicn/core/forwarder.h> +#include <hicn/utils/policy.h> + +#ifdef WITH_MAPME +#include <hicn/core/mapMe.h> +#endif /* WITH_MAPME */ + +#define ALPHA 0.5 + +#endif /* WITH_POLICY */ struct fib_entry { Name *name; unsigned refcount; StrategyImpl *fwdStrategy; +#ifdef WITH_POLICY + NumberSet *nexthops; + const Forwarder * forwarder; + policy_t policy; + policy_counters_t policy_counters; + NumberSet *available_nexthops; +#ifdef WITH_MAPME + /* In case of no multipath, this stores the previous decision taken by policy */ + unsigned previous_nexthop; +#endif /* WITH_MAPME */ +#endif /* WITH_POLICY */ #ifdef WITH_MAPME void *userData; void (*userDataRelease)(void **userData); #endif /* WITH_MAPME */ }; +#ifdef WITH_POLICY +FibEntry *fibEntry_Create(Name *name, strategy_type fwdStrategy, const Forwarder * forwarder) { + ConnectionTable * table = forwarder_GetConnectionTable(forwarder); +#else FibEntry *fibEntry_Create(Name *name, strategy_type fwdStrategy) { +#endif /* WITH_POLICY */ FibEntry *fibEntry = parcMemory_AllocateAndClear(sizeof(FibEntry)); parcAssertNotNull(fibEntry, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(FibEntry)); @@ -55,27 +84,47 @@ FibEntry *fibEntry_Create(Name *name, strategy_type fwdStrategy) { if (fwdStrategy) { switch (fwdStrategy) { case SET_STRATEGY_LOADBALANCER: +#ifdef WITH_POLICY + fibEntry->fwdStrategy = strategyLoadBalancer_Create(table); +#else fibEntry->fwdStrategy = strategyLoadBalancer_Create(); +#endif /* WITH_POLICY */ break; case SET_STRATEGY_RANDOM_PER_DASH_SEGMENT: +#ifdef WITH_POLICY + fibEntry->fwdStrategy = strategyRndSegment_Create(table); +#else fibEntry->fwdStrategy = strategyRndSegment_Create(); +#endif /* WITH_POLICY */ break; case SET_STRATEGY_LOADBALANCER_WITH_DELAY: +#ifdef WITH_POLICY + fibEntry->fwdStrategy = strategyLoadBalancerWithPD_Create(table); +#else fibEntry->fwdStrategy = strategyLoadBalancerWithPD_Create(); +#endif /* WITH_POLICY */ break; default: - // LB is the defualt strategy + // LB is the default strategy +#ifdef WITH_POLICY + fibEntry->fwdStrategy = strategyLoadBalancer_Create(table); +#else fibEntry->fwdStrategy = strategyLoadBalancer_Create(); +#endif /* WITH_POLICY */ // the LB strategy is the default one // other strategies can be set using the appropiate function break; } } else { +#ifdef WITH_POLICY + fibEntry->fwdStrategy = strategyLoadBalancer_Create(table); +#else fibEntry->fwdStrategy = strategyLoadBalancer_Create(); +#endif /* WITH_POLICY */ } fibEntry->refcount = 1; @@ -85,6 +134,16 @@ FibEntry *fibEntry_Create(Name *name, strategy_type fwdStrategy) { fibEntry->userDataRelease = NULL; #endif /* WITH_MAPME */ +#ifdef WITH_POLICY + fibEntry->nexthops = numberSet_Create(); + fibEntry->forwarder = forwarder; + fibEntry->policy = POLICY_NONE; + fibEntry->policy_counters = POLICY_COUNTERS_NONE; +#ifdef WITH_MAPME + fibEntry->previous_nexthop = ~0; +#endif /* WITH_MAPME */ +#endif /* WITH_POLICY */ + return fibEntry; } @@ -114,23 +173,42 @@ void fibEntry_Release(FibEntry **fibEntryPtr) { void fibEntry_SetStrategy(FibEntry *fibEntry, strategy_type strategy) { StrategyImpl *fwdStrategyImpl; +#ifdef WITH_POLICY + ConnectionTable * table = forwarder_GetConnectionTable(fibEntry->forwarder); +#endif /* WITH_POLICY */ switch (strategy) { case SET_STRATEGY_LOADBALANCER: +#ifdef WITH_POLICY + fwdStrategyImpl = strategyLoadBalancer_Create(table); +#else fwdStrategyImpl = strategyLoadBalancer_Create(); +#endif /* WITH_POLICY */ break; case SET_STRATEGY_RANDOM_PER_DASH_SEGMENT: +#ifdef WITH_POLICY + fwdStrategyImpl = strategyRndSegment_Create(table); +#else fwdStrategyImpl = strategyRndSegment_Create(); +#endif /* WITH_POLICY */ break; case SET_STRATEGY_LOADBALANCER_WITH_DELAY: +#ifdef WITH_POLICY + fwdStrategyImpl = strategyLoadBalancerWithPD_Create(table); +#else fwdStrategyImpl = strategyLoadBalancerWithPD_Create(); +#endif /* WITH_POLICY */ break; default: // LB is the defualt strategy +#ifdef WITH_POLICY + fwdStrategyImpl = strategyLoadBalancer_Create(table); +#else fwdStrategyImpl = strategyLoadBalancer_Create(); +#endif /* WITH_POLICY */ // the LB strategy is the default one // other strategies can be set using the appropiate function break; @@ -145,47 +223,648 @@ void fibEntry_SetStrategy(FibEntry *fibEntry, strategy_type strategy) { fibEntry->fwdStrategy->destroy(&(fibEntry->fwdStrategy)); fibEntry->fwdStrategy = fwdStrategyImpl; } + +#ifdef WITH_POLICY + +/* + * Update available next hops following policy update. + */ +NumberSet * +fibEntry_GetAvailableNextHops(const FibEntry *fibEntry, unsigned in_connection) { + ConnectionTable * table = forwarder_GetConnectionTable(fibEntry->forwarder); + NumberSet * nexthops; + policy_t policy = fibEntry_GetPolicy(fibEntry); + + /* Reset available next hops and start filtering */ + NumberSet * available_nexthops = numberSet_Create(); + + /* + * Give absolute preference to local faces, with no policy, unless + * in_connection == ~0, which means we are searching faces on which to + * advertise our prefix + */ + if (in_connection == ~0) { + /* We might advertise among all available up connections */ + nexthops = numberSet_Create(); + + ConnectionList * list = connectionTable_GetEntries(table); + for (size_t i = 0; i < connectionList_Length(list); i++) { + Connection *conn = connectionList_Get(list, i); + if (connection_GetState(conn) == CONNECTION_STATE_DOWN) + continue; + if (connection_IsLocal(conn)) + continue; + numberSet_Add(nexthops, connection_GetConnectionId(conn)); + } + + } else { + nexthops = (NumberSet*)fibEntry_GetNexthops(fibEntry); + for (size_t k = 0; k < numberSet_Length(nexthops); k++) { + unsigned conn_id = numberSet_GetItem(nexthops, k); + /* Filtering out ingress face */ + if (conn_id == in_connection) + continue; + /* Filtering out DOWN faces */ + const Connection * conn = connectionTable_FindById(table, conn_id); + if (!conn) + continue; + if (connection_GetState(conn) == CONNECTION_STATE_DOWN) + continue; + if (!connection_IsLocal(conn)) + continue; + numberSet_Add(available_nexthops, conn_id); + } + + if (numberSet_Length(available_nexthops) > 0) + return available_nexthops; + } + + for (size_t k = 0; k < numberSet_Length(nexthops); k++) { + unsigned conn_id = numberSet_GetItem(nexthops, k); + const Connection * conn; + + /* Filtering out ingress face */ + if (conn_id == in_connection) + continue; + + /* Filtering out DOWN faces */ + conn = connectionTable_FindById(table, conn_id); + if (!conn) + continue; + if (connection_GetState(conn) == CONNECTION_STATE_DOWN) + continue; + + /* Policy filtering : next hops */ + if ((policy.tags[POLICY_TAG_WIRED].state == POLICY_STATE_REQUIRE) && + (!connection_HasTag(conn, POLICY_TAG_WIRED))) + continue; + if ((policy.tags[POLICY_TAG_WIRED].state == POLICY_STATE_PROHIBIT) && + (connection_HasTag(conn, POLICY_TAG_WIRED))) + continue; + if ((policy.tags[POLICY_TAG_WIFI].state == POLICY_STATE_REQUIRE) && + (!connection_HasTag(conn, POLICY_TAG_WIFI))) + continue; + if ((policy.tags[POLICY_TAG_WIFI].state == POLICY_STATE_PROHIBIT) && + (connection_HasTag(conn, POLICY_TAG_WIFI))) + continue; + if ((policy.tags[POLICY_TAG_CELLULAR].state == POLICY_STATE_REQUIRE) && + (!connection_HasTag(conn, POLICY_TAG_CELLULAR))) + continue; + if ((policy.tags[POLICY_TAG_CELLULAR].state == POLICY_STATE_PROHIBIT) && + (connection_HasTag(conn, POLICY_TAG_CELLULAR))) + continue; + if ((policy.tags[POLICY_TAG_TRUSTED].state == POLICY_STATE_REQUIRE) && + (!connection_HasTag(conn, POLICY_TAG_TRUSTED))) + continue; + if ((policy.tags[POLICY_TAG_TRUSTED].state == POLICY_STATE_PROHIBIT) && + (connection_HasTag(conn, POLICY_TAG_TRUSTED))) + continue; + + numberSet_Add(available_nexthops, conn_id); + } + + if (numberSet_Length(available_nexthops) == 0) + return available_nexthops; + + /* We have at least one matching next hop, implement heuristic */ + + /* + * As VPN connections might trigger duplicate uses of one interface, we start + * by filtering out interfaces based on trust status. + */ + NumberSet * filtered_nexthops = numberSet_Create(); + if ((policy.tags[POLICY_TAG_TRUSTED].state == POLICY_STATE_REQUIRE) || + (policy.tags[POLICY_TAG_TRUSTED].state == POLICY_STATE_PREFER)) { + /* Try to filter out NON TRUSTED faces */ + for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) { + unsigned conn_id = numberSet_GetItem(available_nexthops, k); + const Connection * conn = connectionTable_FindById(table, conn_id); + if (!connection_HasTag(conn, POLICY_TAG_TRUSTED)) + continue; + numberSet_Add(filtered_nexthops, conn_id); + } + } else { + /* Try to filter out TRUSTED faces */ + for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) { + unsigned conn_id = numberSet_GetItem(available_nexthops, k); + const Connection * conn = connectionTable_FindById(table, conn_id); + if (connection_HasTag(conn, POLICY_TAG_TRUSTED)) + continue; + numberSet_Add(filtered_nexthops, conn_id); + } + } + if (numberSet_Length(filtered_nexthops) > 0) { + numberSet_Release(&available_nexthops); + available_nexthops = numberSet_Create(); + numberSet_AddSet(available_nexthops, filtered_nexthops); + } + numberSet_Release(&filtered_nexthops); + + /* Other preferences */ + if (policy.tags[POLICY_TAG_WIRED].state == POLICY_STATE_AVOID) { + filtered_nexthops = numberSet_Create(); + for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) { + unsigned conn_id = numberSet_GetItem(available_nexthops, k); + const Connection * conn = connectionTable_FindById(table, conn_id); + if (connection_HasTag(conn, POLICY_TAG_WIRED)) + continue; + numberSet_Add(filtered_nexthops, conn_id); + } + if (numberSet_Length(filtered_nexthops) > 0) { + numberSet_Release(&available_nexthops); + available_nexthops = numberSet_Create(); + numberSet_AddSet(available_nexthops, filtered_nexthops); + } + numberSet_Release(&filtered_nexthops); + } + if (policy.tags[POLICY_TAG_WIFI].state == POLICY_STATE_AVOID) { + filtered_nexthops = numberSet_Create(); + for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) { + unsigned conn_id = numberSet_GetItem(available_nexthops, k); + const Connection * conn = connectionTable_FindById(table, conn_id); + if (connection_HasTag(conn, POLICY_TAG_WIFI)) + continue; + numberSet_Add(filtered_nexthops, conn_id); + } + if (numberSet_Length(filtered_nexthops) > 0) { + numberSet_Release(&available_nexthops); + available_nexthops = numberSet_Create(); + numberSet_AddSet(available_nexthops, filtered_nexthops); + } + numberSet_Release(&filtered_nexthops); + } + if (policy.tags[POLICY_TAG_CELLULAR].state == POLICY_STATE_AVOID) { + filtered_nexthops = numberSet_Create(); + for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) { + unsigned conn_id = numberSet_GetItem(available_nexthops, k); + const Connection * conn = connectionTable_FindById(table, conn_id); + if (connection_HasTag(conn, POLICY_TAG_CELLULAR)) + continue; + numberSet_Add(filtered_nexthops, conn_id); + } + if (numberSet_Length(filtered_nexthops) > 0) { + numberSet_Release(&available_nexthops); + available_nexthops = numberSet_Create(); + numberSet_AddSet(available_nexthops, filtered_nexthops); + } + numberSet_Release(&filtered_nexthops); + } + + if (policy.tags[POLICY_TAG_WIRED].state == POLICY_STATE_PREFER) { + filtered_nexthops = numberSet_Create(); + for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) { + unsigned conn_id = numberSet_GetItem(available_nexthops, k); + const Connection * conn = connectionTable_FindById(table, conn_id); + if (!connection_HasTag(conn, POLICY_TAG_WIRED)) + continue; + numberSet_Add(filtered_nexthops, conn_id); + } + if (numberSet_Length(filtered_nexthops) > 0) { + numberSet_Release(&available_nexthops); + available_nexthops = numberSet_Create(); + numberSet_AddSet(available_nexthops, filtered_nexthops); + } + numberSet_Release(&filtered_nexthops); + } + if (policy.tags[POLICY_TAG_WIFI].state == POLICY_STATE_PREFER) { + filtered_nexthops = numberSet_Create(); + for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) { + unsigned conn_id = numberSet_GetItem(available_nexthops, k); + const Connection * conn = connectionTable_FindById(table, conn_id); + if (!connection_HasTag(conn, POLICY_TAG_WIFI)) + continue; + numberSet_Add(filtered_nexthops, conn_id); + } + if (numberSet_Length(filtered_nexthops) > 0) { + numberSet_Release(&available_nexthops); + available_nexthops = numberSet_Create(); + numberSet_AddSet(available_nexthops, filtered_nexthops); + } + numberSet_Release(&filtered_nexthops); + } + if (policy.tags[POLICY_TAG_CELLULAR].state == POLICY_STATE_PREFER) { + filtered_nexthops = numberSet_Create(); + for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) { + unsigned conn_id = numberSet_GetItem(available_nexthops, k); + const Connection * conn = connectionTable_FindById(table, conn_id); + if (!connection_HasTag(conn, POLICY_TAG_CELLULAR)) + continue; + numberSet_Add(filtered_nexthops, conn_id); + } + if (numberSet_Length(filtered_nexthops) > 0) { + numberSet_Release(&available_nexthops); + available_nexthops = numberSet_Create(); + numberSet_AddSet(available_nexthops, filtered_nexthops); + } + numberSet_Release(&filtered_nexthops); + } + + return available_nexthops; +} + +policy_t fibEntry_GetPolicy(const FibEntry *fibEntry) { + return fibEntry->policy; +} + +void fibEntry_ReconsiderPolicy(FibEntry *fibEntry) { +#ifdef WITH_MAPME + NumberSet * available_nexthops = fibEntry_GetAvailableNextHops(fibEntry, ~0); + + if (numberSet_Length(available_nexthops) == 0) + goto END; + + /* Multipath */ + if ((fibEntry->policy.tags[POLICY_TAG_MULTIPATH].state != POLICY_STATE_PROHIBIT) && + (fibEntry->policy.tags[POLICY_TAG_MULTIPATH].state != POLICY_STATE_AVOID)) + goto END; + + unsigned nexthop = numberSet_GetItem(available_nexthops, 0); + if (nexthop != fibEntry->previous_nexthop) { + /* Policy has elected a new nexthop, signal it using MAP-Me */ + fibEntry->previous_nexthop = nexthop; + ConnectionTable * table = forwarder_GetConnectionTable(fibEntry->forwarder); + const Connection * conn = connectionTable_FindById(table, nexthop); + mapMe_onPolicyUpdate(forwarder_getMapmeInstance(fibEntry->forwarder), conn, fibEntry); + } + +END: + numberSet_Release(&available_nexthops); +#endif /* WITH_MAPME */ +} + +void fibEntry_SetPolicy(FibEntry *fibEntry, policy_t policy) { + fibEntry->policy = policy; + fibEntry_ReconsiderPolicy(fibEntry); +} + +#endif /* WITH_POLICY */ + void fibEntry_AddNexthop(FibEntry *fibEntry, unsigned connectionId) { parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null"); +#ifdef WITH_POLICY + if (!numberSet_Contains(fibEntry->nexthops, connectionId)) { + numberSet_Add(fibEntry->nexthops, connectionId); + } +#endif /* WITH_POLICY */ fibEntry->fwdStrategy->addNexthop(fibEntry->fwdStrategy, connectionId); } void fibEntry_RemoveNexthopByConnectionId(FibEntry *fibEntry, unsigned connectionId) { parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null"); +#ifdef WITH_POLICY + if (numberSet_Contains(fibEntry->nexthops, connectionId)) { + numberSet_Remove(fibEntry->nexthops, connectionId); + } +#endif /* WITH_POLICY */ fibEntry->fwdStrategy->removeNexthop(fibEntry->fwdStrategy, connectionId); } size_t fibEntry_NexthopCount(const FibEntry *fibEntry) { parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null"); +#ifdef WITH_POLICY + return numberSet_Length(fibEntry->nexthops); +#else return fibEntry->fwdStrategy->countNexthops(fibEntry->fwdStrategy); +#endif /* WITH_POLICY */ } const NumberSet *fibEntry_GetNexthops(const FibEntry *fibEntry) { parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null"); +#ifdef WITH_POLICY + return fibEntry->nexthops; +#else return fibEntry->fwdStrategy->returnNexthops(fibEntry->fwdStrategy); +#endif /* WITH_POLICY */ } const NumberSet *fibEntry_GetNexthopsFromForwardingStrategy( +#ifdef WITH_POLICY + FibEntry *fibEntry, const Message *interestMessage, bool is_retransmission) { +#else const FibEntry *fibEntry, const Message *interestMessage) { +#endif /* WITH_POLICY */ parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null"); +#ifdef WITH_POLICY + ConnectionTable * table = forwarder_GetConnectionTable(fibEntry->forwarder); + unsigned in_connection = message_GetIngressConnectionId(interestMessage); + + policy_t policy = fibEntry_GetPolicy(fibEntry); + + NumberSet * out; + + /* Filtering */ + NumberSet * available_nexthops = fibEntry_GetAvailableNextHops(fibEntry, in_connection); + if (numberSet_Length(available_nexthops) == 0) { + numberSet_Release(&available_nexthops); + out = numberSet_Create(); + return out; + } + + /* + * Update statistics about loss rates. We only detect losses upon + * retransmissions, and assume for the computation that the candidate set of + * output faces is the same as previously (i.e. does not take into account + * event such as face up/down, policy update, etc. Otherwise we would need to + * know what was the previous choice ! + */ + if (is_retransmission) { + for (size_t k = 0; k < numberSet_Length(available_nexthops); k++) { + unsigned conn_id = numberSet_GetItem(available_nexthops, k); + const Connection * conn = connectionTable_FindById(table, conn_id); + + if (connection_HasTag(conn, POLICY_TAG_WIRED)) + fibEntry->policy_counters.wired.num_losses++; + if (connection_HasTag(conn, POLICY_TAG_WIFI)) + fibEntry->policy_counters.wifi.num_losses++; + if (connection_HasTag(conn, POLICY_TAG_CELLULAR)) + fibEntry->policy_counters.cellular.num_losses++; + fibEntry->policy_counters.all.num_losses++; + } + } + + /* + * NOTE: We might want to call a forwarding strategy even with no nexthop to + * take a fallback decision. + */ + if (numberSet_Length(available_nexthops) == 0) { + out = numberSet_Create(); + } else { + /* Multipath */ + if ((policy.tags[POLICY_TAG_MULTIPATH].state != POLICY_STATE_PROHIBIT) && + (policy.tags[POLICY_TAG_MULTIPATH].state != POLICY_STATE_AVOID)) { + out = fibEntry->fwdStrategy->lookupNexthop(fibEntry->fwdStrategy, available_nexthops, + interestMessage); + } else { + unsigned nexthop = numberSet_GetItem(available_nexthops, 0); + out = numberSet_Create(); + numberSet_Add(out, nexthop); + } + } + + numberSet_Release(&available_nexthops); + + return out; +#else return fibEntry->fwdStrategy->lookupNexthop(fibEntry->fwdStrategy, - interestMessage); + interestMessage); +#endif /* WITH_POLICY */ } +#ifdef WITH_POLICY +void fibEntry_ReceiveObjectMessage(FibEntry *fibEntry, +#else void fibEntry_ReceiveObjectMessage(const FibEntry *fibEntry, +#endif /* WITH_POLICY */ const NumberSet *egressId, const Message *objectMessage, Ticks rtt) { parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null"); + +#ifdef WITH_POLICY + ConnectionTable * table = forwarder_GetConnectionTable(fibEntry->forwarder); + + /* Update statistic counters : */ + + size_t msg_size = message_Length(objectMessage); + + for (unsigned i = 0; i < numberSet_Length(egressId); i++) { + unsigned conn_id = numberSet_GetItem(egressId, i); + const Connection * conn = connectionTable_FindById(table, conn_id); + if (!conn) + continue; + if (connection_HasTag(conn, POLICY_TAG_WIRED)) { + fibEntry->policy_counters.wired.num_packets++; + fibEntry->policy_counters.wired.num_bytes += msg_size; + fibEntry->policy.stats.wired.latency = \ + ALPHA * fibEntry->policy.stats.wired.latency + \ + (1 - ALPHA) * (double)rtt; + fibEntry->policy_counters.wired.latency_idle = 0; + } + if (connection_HasTag(conn, POLICY_TAG_WIFI)) { + fibEntry->policy_counters.wifi.num_packets++; + fibEntry->policy_counters.wifi.num_bytes += msg_size; + fibEntry->policy.stats.wifi.latency = \ + ALPHA * fibEntry->policy.stats.wifi.latency + \ + (1 - ALPHA) * (double)rtt; + fibEntry->policy_counters.wifi.latency_idle = 0; + + } + if (connection_HasTag(conn, POLICY_TAG_CELLULAR)) { + fibEntry->policy_counters.cellular.num_packets++; + fibEntry->policy_counters.cellular.num_bytes += msg_size; + fibEntry->policy.stats.cellular.latency = \ + ALPHA * fibEntry->policy.stats.cellular.latency + \ + (1 - ALPHA) * (double)rtt; + fibEntry->policy_counters.cellular.latency_idle = 0; + } + } + + fibEntry->policy.stats.all.latency = \ + ALPHA * fibEntry->policy.stats.all.latency + \ + (1 - ALPHA) * (double)rtt; + fibEntry->policy_counters.all.latency_idle = 0; + + fibEntry->policy_counters.all.num_packets++; + fibEntry->policy_counters.all.num_bytes += msg_size; + +#endif /* WITH_POLICY */ + fibEntry->fwdStrategy->receiveObject(fibEntry->fwdStrategy, egressId, objectMessage, rtt); } +#ifdef WITH_POLICY +void fibEntry_OnTimeout(FibEntry *fibEntry, const NumberSet *egressId) { +#else void fibEntry_OnTimeout(const FibEntry *fibEntry, const NumberSet *egressId) { +#endif /* WITH_POLICY */ parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null"); + +#ifdef WITH_POLICY + + ConnectionTable * table = forwarder_GetConnectionTable(fibEntry->forwarder); + + for (unsigned i = 0; i < numberSet_Length(egressId); i++) { + unsigned conn_id = numberSet_GetItem(egressId, i); + const Connection * conn = connectionTable_FindById(table, conn_id); + if (!conn) + continue; + if (connection_HasTag(conn, POLICY_TAG_WIRED)) { + fibEntry->policy_counters.wired.num_losses++; + } + if (connection_HasTag(conn, POLICY_TAG_WIFI)) { + fibEntry->policy_counters.wifi.num_losses++; + } + if (connection_HasTag(conn, POLICY_TAG_CELLULAR)) { + fibEntry->policy_counters.cellular.num_losses++; + } + } + + fibEntry->policy_counters.all.num_losses++; + +#endif /* WITH_POLICY */ + fibEntry->fwdStrategy->onTimeout(fibEntry->fwdStrategy, egressId); } +#ifdef WITH_POLICY +void fibEntry_UpdateStats(FibEntry *fibEntry, uint64_t now) { + double throughput; + double loss_rate; + + if (now == fibEntry->policy_counters.last_update) + return ; + + /* WIRED */ + + /* a) throughput */ + if (fibEntry->policy_counters.wired.num_bytes > 0) { + throughput = fibEntry->policy_counters.wired.num_bytes / \ + (now - fibEntry->policy_counters.last_update) ; + throughput = throughput * 8 / 1024; + if (throughput < 0) + throughput = 0; + } else { + throughput = 0; + } + fibEntry->policy.stats.wired.throughput = \ + ALPHA * fibEntry->policy.stats.wired.throughput + \ + (1-ALPHA) * throughput; + + /* b) loss rate */ + if ((fibEntry->policy_counters.wired.num_losses > 0) && \ + (fibEntry->policy_counters.wired.num_packets > 0)){ + loss_rate = fibEntry->policy_counters.wired.num_losses / \ + fibEntry->policy_counters.wired.num_packets; + loss_rate *= 100; + } else { + loss_rate = 0; + } + fibEntry->policy.stats.wired.loss_rate = \ + ALPHA * fibEntry->policy.stats.wired.loss_rate + \ + (1-ALPHA) * loss_rate; + + /* Latency */ + fibEntry->policy_counters.wired.latency_idle++; + if (fibEntry->policy_counters.wired.latency_idle > 1) + fibEntry->policy.stats.wired.latency = 0; + fibEntry->policy_counters.wifi.latency_idle++; + if (fibEntry->policy_counters.wifi.latency_idle > 1) + fibEntry->policy.stats.wifi.latency = 0; + fibEntry->policy_counters.cellular.latency_idle++; + if (fibEntry->policy_counters.cellular.latency_idle > 1) + fibEntry->policy.stats.cellular.latency = 0; + fibEntry->policy_counters.all.latency_idle++; + if (fibEntry->policy_counters.all.latency_idle > 1) + fibEntry->policy.stats.all.latency = 0; + + fibEntry->policy_counters.wired.num_bytes = 0; + fibEntry->policy_counters.wired.num_losses = 0; + fibEntry->policy_counters.wired.num_packets = 0; + + /* WIFI */ + + /* a) throughput */ + if (fibEntry->policy_counters.wifi.num_bytes > 0) { + throughput = fibEntry->policy_counters.wifi.num_bytes / \ + (now - fibEntry->policy_counters.last_update); + throughput = throughput * 8 / 1024; + if (throughput < 0) + throughput = 0; + } else { + throughput = 0; + } + fibEntry->policy.stats.wifi.throughput = \ + ALPHA * fibEntry->policy.stats.wifi.throughput + \ + (1-ALPHA) * throughput; + + /* b) loss rate */ + if ((fibEntry->policy_counters.wifi.num_losses > 0) && \ + (fibEntry->policy_counters.wifi.num_packets > 0)) { + loss_rate = fibEntry->policy_counters.wifi.num_losses / \ + fibEntry->policy_counters.wifi.num_packets; + loss_rate *= 100; + } else { + loss_rate = 0; + } + fibEntry->policy.stats.wifi.loss_rate = \ + ALPHA * fibEntry->policy.stats.wifi.loss_rate + \ + (1-ALPHA) * loss_rate; + + fibEntry->policy_counters.wifi.num_bytes = 0; + fibEntry->policy_counters.wifi.num_losses = 0; + fibEntry->policy_counters.wifi.num_packets = 0; + + /* CELLULAR */ + + /* a) throughput */ + if (fibEntry->policy_counters.cellular.num_bytes > 0) { + throughput = fibEntry->policy_counters.cellular.num_bytes / \ + (now - fibEntry->policy_counters.last_update) ; + throughput = throughput * 8 / 1024; + if (throughput < 0) + throughput = 0; + } else { + throughput = 0; + } + fibEntry->policy.stats.cellular.throughput = \ + ALPHA * fibEntry->policy.stats.cellular.throughput + \ + (1-ALPHA) * throughput; + + /* b) loss rate */ + if ((fibEntry->policy_counters.cellular.num_losses > 0) && \ + (fibEntry->policy_counters.cellular.num_packets > 0)) { + loss_rate = fibEntry->policy_counters.cellular.num_losses / \ + fibEntry->policy_counters.cellular.num_packets; + loss_rate *= 100; + } else { + loss_rate = 0; + } + fibEntry->policy.stats.cellular.loss_rate = \ + ALPHA * fibEntry->policy.stats.cellular.loss_rate + \ + (1-ALPHA) * loss_rate; + + fibEntry->policy_counters.cellular.num_bytes = 0; + fibEntry->policy_counters.cellular.num_losses = 0; + fibEntry->policy_counters.cellular.num_packets = 0; + + /* ALL */ + + /* a) throughput */ + if (fibEntry->policy_counters.all.num_bytes > 0) { + throughput = fibEntry->policy_counters.all.num_bytes / \ + (now - fibEntry->policy_counters.last_update); + throughput = throughput * 8 / 1024; + if (throughput < 0) + throughput = 0; + } else { + throughput = 0; + } + fibEntry->policy.stats.all.throughput = \ + ALPHA * fibEntry->policy.stats.all.throughput + \ + (1-ALPHA) * throughput; + + /* b) loss rate */ + if ((fibEntry->policy_counters.all.num_losses > 0) && \ + (fibEntry->policy_counters.all.num_packets > 0)) { + loss_rate = fibEntry->policy_counters.all.num_losses / \ + fibEntry->policy_counters.all.num_packets; + loss_rate *= 100; + } else { + loss_rate = 0; + } + fibEntry->policy.stats.all.loss_rate = \ + ALPHA * fibEntry->policy.stats.all.loss_rate + \ + (1-ALPHA) * loss_rate; + + fibEntry->policy_counters.all.num_bytes = 0; + fibEntry->policy_counters.all.num_losses = 0; + fibEntry->policy_counters.all.num_packets = 0; + + fibEntry->policy_counters.last_update = now; +} +#endif /* WITH_POLICY */ + Name *fibEntry_GetPrefix(const FibEntry *fibEntry) { parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null"); return fibEntry->name; @@ -202,12 +881,6 @@ StrategyImpl *fibEntry_GetFwdStrategy(const FibEntry *fibEntry) { #ifdef WITH_MAPME -void fibEntry_AddNexthopByConnectionId(FibEntry *fibEntry, - unsigned connectionId) { - parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null"); - fibEntry->fwdStrategy->addNexthop(fibEntry->fwdStrategy, connectionId); -} - void *fibEntry_getUserData(const FibEntry *fibEntry) { parcAssertNotNull(fibEntry, "Parameter fibEntry must be non-null"); return fibEntry->userData; diff --git a/hicn-light/src/hicn/processor/fibEntry.h b/hicn-light/src/hicn/processor/fibEntry.h index d677ae998..11a00e836 100644 --- a/hicn-light/src/hicn/processor/fibEntry.h +++ b/hicn-light/src/hicn/processor/fibEntry.h @@ -40,6 +40,10 @@ #include <hicn/core/name.h> #include <hicn/strategies/strategyImpl.h> +#ifdef WITH_POLICY +#include <hicn/core/connectionTable.h> +#endif /* WITH_POLICY */ + #ifdef WITH_MAPME #include <parc/algol/parc_EventTimer.h> #include <parc/algol/parc_Iterator.h> @@ -48,7 +52,12 @@ struct fib_entry; typedef struct fib_entry FibEntry; +#ifdef WITH_POLICY +struct forwarder; +FibEntry *fibEntry_Create(Name *name, strategy_type fwdStrategy, const struct forwarder * table); +#else FibEntry *fibEntry_Create(Name *name, strategy_type fwdStrategy); +#endif /** * Decrements the reference count by one, and destroys the memory after last @@ -72,6 +81,16 @@ FibEntry *fibEntry_Acquire(const FibEntry *fibEntry); void fibEntry_SetStrategy(FibEntry *fibEntry, strategy_type strategy); +#ifdef WITH_POLICY + +policy_t fibEntry_GetPolicy(const FibEntry *fibEntry); + +void fibEntry_ReconsiderPolicy(FibEntry *fibEntry); + +void fibEntry_SetPolicy(FibEntry *fibEntry, policy_t policy); + +#endif /* WITH_POLICY */ + void fibEntry_AddNexthop(FibEntry *fibEntry, unsigned connectionId); void fibEntry_RemoveNexthopByConnectionId(FibEntry *fibEntry, @@ -89,13 +108,29 @@ size_t fibEntry_NexthopCount(const FibEntry *fibEntry); const NumberSet *fibEntry_GetNexthops(const FibEntry *fibEntry); const NumberSet *fibEntry_GetNexthopsFromForwardingStrategy( +#ifdef WITH_POLICY + FibEntry *fibEntry, const Message *interestMessage, bool is_retransmission); +#else const FibEntry *fibEntry, const Message *interestMessage); +#endif /* WITH_POLICY */ +#ifdef WITH_POLICY +void fibEntry_ReceiveObjectMessage(FibEntry *fibEntry, +#else void fibEntry_ReceiveObjectMessage(const FibEntry *fibEntry, +#endif /* WITH_POLICY */ const NumberSet *egressId, const Message *objectMessage, Ticks rtt); +#ifdef WITH_POLICY +void fibEntry_OnTimeout(FibEntry *fibEntry, const NumberSet *egressId); +#else void fibEntry_OnTimeout(const FibEntry *fibEntry, const NumberSet *egressId); +#endif /* WITH_POLICY */ + +#ifdef WITH_POLICY +void fibEntry_UpdateStats(FibEntry *fibEntry, uint64_t now); +#endif /* WITH_POLICY */ strategy_type fibEntry_GetFwdStrategyType(const FibEntry *fibEntry); @@ -111,15 +146,6 @@ Name *fibEntry_GetPrefix(const FibEntry *fibEntry); #ifdef WITH_MAPME /** - * @function fibEntry_AddNexthopByConnectionId - * @abstract Adds a next hop directly from the connection id. - * @param [in] fibEntry - Pointer to the FIB entry. - * @return The sequence number stored in the FIB entry. - */ -void fibEntry_AddNexthopByConnectionId(FibEntry *fibEntry, - unsigned connectionId); - -/** * @function fibEntry_getUserData * @abstract Returns user data associated to the FIB entry. * @param [in] fibEntry - Pointer to the FIB entry. diff --git a/hicn-light/src/hicn/processor/messageProcessor.c b/hicn-light/src/hicn/processor/messageProcessor.c index 4db1a0eb2..7e0ece257 100644 --- a/hicn-light/src/hicn/processor/messageProcessor.c +++ b/hicn-light/src/hicn/processor/messageProcessor.c @@ -19,6 +19,12 @@ #include <parc/algol/parc_ArrayList.h> #include <parc/algol/parc_Memory.h> +#ifdef WITH_POLICY +#include <parc/algol/parc_EventTimer.h> +#ifdef WITH_MAPME +#include <hicn/core/connection.h> +#endif /* WITH_MAPME */ +#endif /* WITH_POLICY */ #include <hicn/processor/messageProcessor.h> #include <hicn/processor/fib.h> @@ -28,7 +34,9 @@ #include <hicn/content_store/contentStoreLRU.h> #include <hicn/strategies/loadBalancer.h> +#ifndef WITH_POLICY #include <hicn/strategies/loadBalancerWithPD.h> +#endif /* ! WITH_POLICY */ #include <hicn/strategies/rnd.h> #include <hicn/strategies/rndSegment.h> #include <hicn/strategies/strategyImpl.h> @@ -43,6 +51,10 @@ #include <hicn/utils/address.h> +#ifdef WITH_POLICY +#define STATS_INTERVAL 1000 /* ms */ +#endif /* WITH_POLICY */ + /* * Copyright (c) 2017-2019 Cisco and/or its affiliates. * Licensed under the Apache License, Version 2.0 (the "License"); @@ -94,6 +106,10 @@ struct message_processor { bool serve_from_cache; _ProcessorStats stats; + +#ifdef WITH_POLICY + void * timer; +#endif /* WITH_POLICY */ }; static void messageProcessor_Drop(MessageProcessor *processor, @@ -113,6 +129,23 @@ static void messageProcessor_ForwardToInterfaceId(MessageProcessor *processor, // ============================================================ // Public API +#ifdef WITH_POLICY +static void +messageProcessor_Tick(int fd, PARCEventType type, void *user_data) +{ + MessageProcessor *processor = (MessageProcessor*)user_data; + uint64_t now = (uint64_t)forwarder_GetTicks(processor->forwarder); + + /* Loop over FIB entries to compute statistics from counters */ + FibEntryList *fibList = forwarder_GetFibEntries(processor->forwarder); + + for (size_t i = 0; i < fibEntryList_Length(fibList); i++) { + FibEntry *entry = (FibEntry *)fibEntryList_Get(fibList, i); + fibEntry_UpdateStats(entry, now); + } +} +#endif /* WITH_POLICY */ + MessageProcessor *messageProcessor_Create(Forwarder *forwarder) { size_t objectStoreSize = configuration_GetObjectStoreSize(forwarder_GetConfiguration(forwarder)); @@ -148,6 +181,20 @@ MessageProcessor *messageProcessor_Create(Forwarder *forwarder) { processor->store_in_cache = true; processor->serve_from_cache = true; +#ifdef WITH_POLICY + /* Create statistics timer */ + Dispatcher *dispatcher = forwarder_GetDispatcher(forwarder); + if (!dispatcher) + goto ERR; + processor->timer = dispatcher_CreateTimer(dispatcher, /* repeat */ true, + messageProcessor_Tick, processor); + if (!processor->timer) + goto ERR; + struct timeval timeout = {STATS_INTERVAL / 1000, (STATS_INTERVAL % 1000) * 1000}; + dispatcher_StartTimer(dispatcher, processor->timer, &timeout); +ERR: +#endif /* WITH_POLICY */ + return processor; } @@ -201,6 +248,15 @@ void messageProcessor_Destroy(MessageProcessor **processorPtr) { contentStoreInterface_Release(&processor->contentStore); pit_Release(&processor->pit); +#ifdef WITH_POLICY + Dispatcher *dispatcher = forwarder_GetDispatcher(processor->forwarder); + if (!dispatcher) + goto ERR; + dispatcher_StopTimer(dispatcher, processor->timer); + dispatcher_DestroyTimerEvent(dispatcher, (PARCEventTimer**)&processor->timer); +ERR: +#endif /* WITH_POLICY */ + parcMemory_Deallocate((void **)&processor); *processorPtr = NULL; } @@ -255,22 +311,33 @@ bool messageProcessor_AddOrUpdateRoute(MessageProcessor *processor, Name *prefix = name_CreateFromAddress(control->addressType, control->address, control->len); FibEntry *entry = fib_Contains(processor->fib, prefix); +#ifndef WITH_POLICY bool newEntry = false; +#endif /* ! WITH_POLICY */ if (entry != NULL) { fibEntry_AddNexthop(entry, ifidx); } else { +#ifdef WITH_POLICY + entry = fibEntry_Create(prefix, fwdStrategy, processor->forwarder); +#else newEntry = true; entry = fibEntry_Create(prefix, fwdStrategy); +#endif /* WITH_POLICY */ fibEntry_AddNexthop(entry, ifidx); fib_Add(processor->fib, entry); } name_Release(&prefix); + +#ifndef WITH_POLICY + /* For policy implementation, we need access to the ConnectionTable in all + * Forwarding Strategies, so it is setup during FIB Entry creation */ if (newEntry && (fwdStrategy == SET_STRATEGY_LOADBALANCER_WITH_DELAY)) { strategyLoadBalancerWithPD_SetConnectionTable( fibEntry_GetFwdStrategy(entry), forwarder_GetConnectionTable(processor->forwarder)); } +#endif /* ! WITH_POLICY */ return true; } @@ -286,6 +353,65 @@ bool messageProcessor_RemoveRoute(MessageProcessor *processor, return true; } +#ifdef WITH_POLICY + +bool messageProcessor_AddOrUpdatePolicy(MessageProcessor *processor, + add_policy_command *control) { + Configuration *config = forwarder_GetConfiguration(processor->forwarder); + + const char *prefixStr = utils_PrefixLenToString( + control->addressType, &control->address, &control->len); + + Name *prefix = name_CreateFromAddress(control->addressType, control->address, + control->len); + FibEntry *entry = fib_Contains(processor->fib, prefix); + if (!entry) { + strategy_type fwdStrategy = + configuration_GetForwardingStrategy(config, prefixStr); + if (fwdStrategy == LAST_STRATEGY_VALUE) { + fwdStrategy = SET_STRATEGY_LOADBALANCER; + } + entry = fibEntry_Create(prefix, fwdStrategy, processor->forwarder); + fib_Add(processor->fib, entry); + } + fibEntry_SetPolicy(entry, control->policy); + + name_Release(&prefix); + + return true; +} + +bool messageProcessor_RemovePolicy(MessageProcessor *processor, + remove_policy_command *control) { + Name *prefix = name_CreateFromAddress(control->addressType, control->address, + control->len); + FibEntry *entry = fib_Contains(processor->fib, prefix); + name_Release(&prefix); + + if (!entry) + return false; + + fibEntry_SetPolicy(entry, POLICY_NONE); + + return true; +} + + +#ifdef WITH_MAPME +void messageProcessor_onConnectionEvent(const MessageProcessor *processor, + const Connection *conn_added, connection_event_t event) +{ + FibEntryList *fiblist = forwarder_GetFibEntries(processor->forwarder); + for (size_t i = 0; i < fibEntryList_Length(fiblist); i++) { + FibEntry *fibEntry = (FibEntry *)fibEntryList_Get(fiblist, i); + fibEntry_ReconsiderPolicy(fibEntry); + } + +} +#endif /* WITH_MAPME */ + +#endif /* WITH_POLICY */ + void messageProcessor_RemoveConnectionIdFromRoutes(MessageProcessor *processor, unsigned connectionId) { fib_RemoveConnectionId(processor->fib, connectionId); @@ -295,12 +421,14 @@ void processor_SetStrategy(MessageProcessor *processor, Name *prefix, strategy_type strategy) { FibEntry *entry = fib_Contains(processor->fib, prefix); if (entry != NULL) { +#ifndef WITH_POLICY fibEntry_SetStrategy(entry, strategy); if (strategy == SET_STRATEGY_LOADBALANCER_WITH_DELAY) { strategyLoadBalancerWithPD_SetConnectionTable( fibEntry_GetFwdStrategy(entry), forwarder_GetConnectionTable(processor->forwarder)); } +#endif /* ! WITH_POLICY */ } } @@ -352,8 +480,13 @@ static void messageProcessor_Drop(MessageProcessor *processor, * @return true if interest aggregagted (no more forwarding needed), false if * need to keep processing it. */ +#ifdef WITH_POLICY +static PITVerdict messageProcessor_AggregateInterestInPit(MessageProcessor *processor, + Message *interestMessage) { +#else static bool messageProcessor_AggregateInterestInPit(MessageProcessor *processor, Message *interestMessage) { +#endif /* WITH_POLICY */ PITVerdict verdict = pit_ReceiveInterest(processor->pit, interestMessage); if (verdict == PITVerdict_Aggregate) { @@ -444,8 +577,13 @@ static bool _satisfyFromContentStore(MessageProcessor *processor, * * @return true if we found a route and tried to forward it, false if no route */ +#ifdef WITH_POLICY +static bool messageProcessor_ForwardViaFib(MessageProcessor *processor, + Message *interestMessage, PITVerdict verdict) { +#else static bool messageProcessor_ForwardViaFib(MessageProcessor *processor, Message *interestMessage) { +#endif /* WITH_POLICY */ FibEntry *fibEntry = fib_Match(processor->fib, interestMessage); if (fibEntry == NULL) { return false; @@ -459,7 +597,12 @@ static bool messageProcessor_ForwardViaFib(MessageProcessor *processor, pitEntry_AddFibEntry(pitEntry, fibEntry); NumberSet *nexthops = (NumberSet *)fibEntry_GetNexthopsFromForwardingStrategy( +#ifdef WITH_POLICY + fibEntry, interestMessage, verdict); +#else fibEntry, interestMessage); +#endif /* WITH_POLICY */ + // this requires some additional checks. It may happen that some of the output // faces selected by the forwarding strategy are not usable. So far all the // forwarding strategy return only valid faces (or an empty list) @@ -503,10 +646,23 @@ static void messageProcessor_ReceiveInterest(MessageProcessor *processor, processor->stats.countInterestsReceived++; // (1) Try to aggregate in PIT +#ifdef WITH_POLICY + PITVerdict verdict = messageProcessor_AggregateInterestInPit(processor, interestMessage); + switch(verdict) { + case PITVerdict_Aggregate: + //done + return; + + case PITVerdict_Forward: + case PITVerdict_Retransmit: + break; + } +#else if (messageProcessor_AggregateInterestInPit(processor, interestMessage)) { // done return; } +#endif /* WITH_POLICY */ // At this point, we just created a PIT entry. If we don't forward the // interest, we need to remove the PIT entry. @@ -520,7 +676,11 @@ static void messageProcessor_ReceiveInterest(MessageProcessor *processor, } // (3) Try to forward it +#ifdef WITH_POLICY + if (messageProcessor_ForwardViaFib(processor, interestMessage, verdict)) { +#else if (messageProcessor_ForwardViaFib(processor, interestMessage)) { +#endif /* WITH_POLICY */ // done return; } @@ -595,6 +755,7 @@ static void messageProcessor_ReceiveContentObject(MessageProcessor *processor, } // (3) Reverse path forward via PIT entries messageProcessor_ForwardToNexthops(processor, message, ingressSetUnion); + } numberSet_Release(&ingressSetUnion); diff --git a/hicn-light/src/hicn/processor/messageProcessor.h b/hicn-light/src/hicn/processor/messageProcessor.h index 64b08272d..6804ba018 100644 --- a/hicn-light/src/hicn/processor/messageProcessor.h +++ b/hicn-light/src/hicn/processor/messageProcessor.h @@ -32,6 +32,12 @@ #include <hicn/utils/commands.h> +#ifdef WITH_POLICY +#ifdef WITH_MAPME +#include <hicn/core/connection.h> +#endif /* WITH_MAPME */ +#endif /* WITH_POLICY */ + struct message_processor; typedef struct message_processor MessageProcessor; @@ -100,6 +106,43 @@ bool messageProcessor_RemoveRoute(MessageProcessor *processor, remove_route_command *control, unsigned ifidx); +#ifdef WITH_POLICY + +/** + * Adds or updates a policy in the FIB + * + * If the policy is already set, it is replaced + * + * @param [in] procesor An allocated message processor + * @param [in] control Control message + * + * @retval true added or updated + * @retval false An error + */ +bool messageProcessor_AddOrUpdatePolicy(MessageProcessor *processor, + add_policy_command *control); + +/** + * Removes a policy from the FIB + * + * Reset the policy in the FIB to the default (empty) policy. + * + * @param [in] procesor An allocated message processor + * @param [in] control Control message + * + * @retval true Policy completely removed + * @retval false There is still a nexthop for the policy + */ +bool messageProcessor_RemovePolicy(MessageProcessor *processor, + remove_policy_command *control); + +#ifdef WITH_MAPME +void messageProcessor_onConnectionEvent(const MessageProcessor *processor, + const Connection *conn_added, connection_event_t event); +#endif /* WITH_MAPME */ + +#endif /* WITH_POLICY */ + /** * Removes a given connection id from all FIB entries * diff --git a/hicn-light/src/hicn/processor/pitStandard.c b/hicn-light/src/hicn/processor/pitStandard.c index 9a3a829bd..edf0b5e98 100644 --- a/hicn-light/src/hicn/processor/pitStandard.c +++ b/hicn-light/src/hicn/processor/pitStandard.c @@ -160,7 +160,11 @@ static PITVerdict _pitStandard_ReceiveInterest(PIT *generic, (void *)interestMessage, pitEntry_GetExpiryTime(pitEntry)); } +#ifdef WITH_POLICY + return PITVerdict_Retransmit; +#else return PITVerdict_Forward; +#endif /* WITH_POLICY */ } // It is in the PIT but this is the first interest for the reverse path diff --git a/hicn-light/src/hicn/processor/pitVerdict.h b/hicn-light/src/hicn/processor/pitVerdict.h index 16631fa51..f37242027 100644 --- a/hicn-light/src/hicn/processor/pitVerdict.h +++ b/hicn-light/src/hicn/processor/pitVerdict.h @@ -32,5 +32,9 @@ * @constant PITVerdict_Aggregate The Interest was aggregated in the PIT, does * not need to be forwarded */ +#ifdef WITH_POLICY +typedef enum { PITVerdict_Forward, PITVerdict_Aggregate, PITVerdict_Retransmit } PITVerdict; +#else typedef enum { PITVerdict_Forward, PITVerdict_Aggregate } PITVerdict; +#endif /* WITH_POLICY */ #endif // pitVerdict_h diff --git a/hicn-light/src/hicn/socket/api.c b/hicn-light/src/hicn/socket/api.c index aede01efe..213163675 100644 --- a/hicn-light/src/hicn/socket/api.c +++ b/hicn-light/src/hicn/socket/api.c @@ -36,7 +36,6 @@ static hicn_conf_t hicn_default_conf = { }; /* Global state */ -// FIXME move into helper state ? struct ip_rule_state_ { char tun_name[IF_NAMESIZE]; @@ -61,8 +60,6 @@ uint16_t routes_counter; static ip_rule_state rules_to_remove[MAX_TABLES]; static ip_route_state routes_to_remove[MAX_TABLES]; -// END FIXME - hicn_socket_helper_t *hicn_create() { int rc; @@ -265,8 +262,6 @@ end: return rc; } -// XXX This could be used by hicn_set_remote_endpoint -// XXX This has been introduced for mapme int hicn_get_local_address(const ip_address_t *remote_address, ip_address_t *local_address) { int rc = 0; @@ -520,11 +515,9 @@ int hicn_bind(hicn_socket_helper_t *hicn, int fd, // each connection is associated a table id, let's take it equal to the // tun ID by default (% MAX_TABLES, assuming TUN IDs do not overlap modulo // 256...). - // XXX we need to make sure the corresponding table is flushed. socket->connection.table_id = socket->tun_id % MAX_TABLES; // interface_id; // ops.get_free_table_id(); - // XXX use IP address rc = hicn_set_remote_endpoint(socket, remote_ip_address); if (rc < 0) { goto ERR; diff --git a/hicn-light/src/hicn/socket/api.h b/hicn-light/src/hicn/socket/api.h index 3a1ae92b4..283065fc7 100644 --- a/hicn-light/src/hicn/socket/api.h +++ b/hicn-light/src/hicn/socket/api.h @@ -155,7 +155,14 @@ int hicn_set_conf(hicn_socket_helper_t *hicn, hicn_conf_t *hicn_conf); */ void hicn_free(hicn_socket_helper_t *hicn); -// FIXME doc +/** + * Returns the local address used to reach the remote address + * + * @param [in] remote_address + * @param [out] local address + * + * @return 0 in case of success, -1 otherwise. + */ int hicn_get_local_address(const ip_address_t *remote_address, ip_address_t *local_address); @@ -207,8 +214,6 @@ int hicn_listen(hicn_socket_helper_t *hicn, int fd, const char *prefix); * RFC-compliant presentation format. * @return 0 in case of success, -1 otherwise. * - * XXX adjacency does not perform any copy heresofar - * * @see hicn_socket */ int hicn_bind(hicn_socket_helper_t *hicn, int fd, diff --git a/hicn-light/src/hicn/socket/error.h b/hicn-light/src/hicn/socket/error.h index 8195efd84..f7c1d9f19 100644 --- a/hicn-light/src/hicn/socket/error.h +++ b/hicn-light/src/hicn/socket/error.h @@ -1,7 +1,6 @@ #ifndef HICN_SOCKET_ERROR_H #define HICN_SOCKET_ERROR_H -// FIXME remove unused errors #define foreach_hicn_socket_error \ _(NONE, 0, "OK") \ _(UNSPEC, 1, "unspecified error") \ diff --git a/hicn-light/src/hicn/socket/ops_linux.c b/hicn-light/src/hicn/socket/ops_linux.c index 1356e1ba0..0b1c6b817 100644 --- a/hicn-light/src/hicn/socket/ops_linux.c +++ b/hicn-light/src/hicn/socket/ops_linux.c @@ -1,6 +1,5 @@ #include <sys/ioctl.h> // ioctl #include <sys/socket.h> // needed by linux/if.h -//#include <linux/if.h> #include <errno.h> #include <fcntl.h> // '' #include <linux/if_tun.h> @@ -26,22 +25,6 @@ #include <stdint.h> #include <stdlib.h> -// DEPRECATED|/* Socket */ -// DEPRECATED|int _nl_get_socket(); -// DEPRECATED|int _nl_send(int s, uint8_t * buffer, size_t len); -// DEPRECATED|size_t _nl_receive(uint8_t * buffer, size_t len); -// DEPRECATED| -// DEPRECATED|/* Netlink packet format */ -// DEPRECATED|int _nl_header(int request, uint8_t * buffer, size_t len, uint32_t -// flags); DEPRECATED|int _nl_payload_rule(uint8_t table_id, uint8_t * buffer, -// size_t len); DEPRECATED|int _nl_payload_link(uint32_t ifindex, uint8_t * -// buffer, size_t len); DEPRECATED|int _nl_payload_route(uint8_t table_id, -// uint8_t dst_len, uint8_t * buffer, size_t len); DEPRECATED| DEPRECATED|int -// _nl_parse(uint8_t * buffer, size_t len); DEPRECATED|int _nl_parse_ret(uint8_t -// * buffer, size_t len); DEPRECATED|int _nl_parse_link_ifid(uint8_t * buffer, -// size_t len, uint32_t * interface_id); DEPRECATED|int -// _nl_parse_link_ip_addr(uint8_t * buffer, size_t len, struct in6_addr * addr); - /* Public interface */ /** @@ -127,25 +110,22 @@ int _nl_del_lo_prio_rule(const ip_address_t *ip_address, * * More specifically, it consists of the following functionalities: * - LINK - . map interface name to ID - . set and interface up + * . map interface name to ID + * . set and interface up * - ADDR - . get and set ip addresses on a given interface ID + * . get and set ip addresses on a given interface ID * - ROUTE - . get output interface id towards IP (ip route get IP > interface_id) - . add input route (ip route add PREFIX dev INTERFACE) for punting - interests . add output route (ip route add default GATEWAY table TABLE) for - routing interests (2, 3) . delete local route towards IP (ip route del IP table - local) for ??? - /!\ could this be avoided by removing the local attribute in the - netlink call ? + * . get output interface id towards IP (ip route get IP > interface_id) + * . add input route (ip route add PREFIX dev INTERFACE) for punting + * interests . add output route (ip route add default GATEWAY table TABLE) + * for routing interests (2, 3) + * . delete local route towards IP (ip route del IP table local) * - RULE * . add output rule (ip rule add iif interface table TABLE) for routing - interests (2, 3) - * - ND PROXY + * interests (2, 3) - ND PROXY * . enable NDP proxy functionality for IP on interface ID (ip -6 neigh add - proxy IP dev INTERFACE) - * for allowing the TUN to be reachable on the reverse data path + * proxy IP dev INTERFACE) for allowing the TUN to be reachable on the + * reverse data path * * Implementation notes: * (1) We have not been using the libnl library because it requires @@ -209,16 +189,11 @@ int _nl_del_lo_prio_rule(const ip_address_t *ip_address, #include <sys/socket.h> // '' #include <sys/types.h> // send, recv -//#include "../../hicn.h" -//#include "../../hicn_util.h" // ARRAY_SIZE, hicn_packet_dump_iov - #define BUFSIZE 4096 #define FLAGS_CREATE NLM_F_REQUEST | NLM_F_CREATE | NLM_F_ACK -// ?? #define FLAGS_CREATE_MATCH \ NLM_F_REQUEST | NLM_F_CREATE | NLM_F_ACK | NLM_F_MATCH -// XXX putting ACK poses a prolem for the value received by get_if_id. #define FLAGS_GET NLM_F_REQUEST #define FLAGS_GET_ROOT (NLM_F_REQUEST | NLM_F_ROOT) @@ -226,7 +201,7 @@ int _nl_del_lo_prio_rule(const ip_address_t *ip_address, #ifndef __ANDROID__ #define IF_NAMESIZE 16 -#endif +#endif #define FR_ACT_TO_TBL 1 #define NLMSG_BOTTOM(nlmsg) \ ((struct rtattr *)(((void *)(nlmsg)) + NLMSG_ALIGN((nlmsg)->nlmsg_len))) @@ -651,15 +626,10 @@ int _nl_set_ip_addr(uint32_t interface_id, ip_address_t *ip_address) { /* Set attributes = length/type/value */ struct rtattr ifa_address = {RTA_LENGTH(ip_address_len(ip_address)), IFA_ADDRESS}; - // XXX maybe the reason why we have a local route ? - // struct rtattr ifa_local = { RTA_LENGTH(ip_address_len(ip_address)), - // IFA_LOCAL }; struct iovec iov[] = { {&msg, sizeof(msg)}, {&ifa_address, sizeof(ifa_address)}, {(void *)&ip_address->buffer, sizeof(ip_address->buffer)}, - // { &ifa_local, sizeof(ifa_local) }, - // { (void*)&ip_address->buffer, sizeof(ip_address->buffer) }, }; msg.hdr.nlmsg_len = iov_length(iov, ARRAY_SIZE(iov)); @@ -1075,11 +1045,8 @@ int _nl_add_rule(const char *interface_name, uint8_t address_family, _nl_header(RTM_NEWRULE, (uint8_t *)buffer, BUFSIZE, FLAGS_CREATE); _nl_payload_rule(table_id, address_family, (uint8_t *)buffer, BUFSIZE); - /* XXX iif */ addAttr(hdr, BUFSIZE, FRA_IIFNAME, (void *)interface_name, strlen(interface_name)); - // attr1 = addNestedAttr(hdr, IFLA_LINKINFO); - // endNestedAttr(hdr, attr1); fd = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE); if (fd < 0) { @@ -1124,7 +1091,6 @@ int _nl_del_rule(const char *interface_name, uint8_t address_family, _nl_header(RTM_DELRULE, (uint8_t *)buffer, BUFSIZE, FLAGS_CREATE); _nl_payload_rule(table_id, address_family, (uint8_t *)buffer, BUFSIZE); - /* XXX iif */ addAttr(hdr, BUFSIZE, FRA_IIFNAME, (void *)interface_name, strlen(interface_name)); @@ -1253,7 +1219,7 @@ int _nl_add_in_route_table(const ip_address_t *prefix, .hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_ACK | NLM_F_EXCL, .hdr.nlmsg_seq = seq++, .payload.rtm_family = prefix->family, - .payload.rtm_dst_len = prefix->prefix_len, // XXX ? XXX dst_len, + .payload.rtm_dst_len = prefix->prefix_len, .payload.rtm_src_len = 0, .payload.rtm_tos = 0, .payload.rtm_table = table_id, /* RT_TABLE_MAIN, etc. */ @@ -1265,7 +1231,6 @@ int _nl_add_in_route_table(const ip_address_t *prefix, }; /* Message attributes = length/type/value */ - // XXX This could be put directly inside the iovec maybe ? XXX struct rtattr a_dst = {RTA_LENGTH(ip_address_len(prefix)), RTA_DST}; struct rtattr a_oif = {RTA_LENGTH(sizeof(uint32_t)), RTA_OIF}; @@ -1332,7 +1297,6 @@ int _nl_add_in_route_s(const char *prefix, const uint32_t interface_id) { return _nl_add_in_route_table_s(prefix, interface_id, RT_TABLE_MAIN); } -////////* ip -6 rule add from all prio 10 table local */ /* ip -6 rule add from b001::/16 prio 0 table 100 */ int _nl_add_prio_rule(const ip_address_t *ip_address, uint8_t address_family, const uint32_t priority, const uint8_t table_id) { diff --git a/hicn-light/src/hicn/strategies/loadBalancer.c b/hicn-light/src/hicn/strategies/loadBalancer.c index 6ab26b7ca..b66de217e 100644 --- a/hicn-light/src/hicn/strategies/loadBalancer.c +++ b/hicn-light/src/hicn/strategies/loadBalancer.c @@ -36,9 +36,15 @@ static void _strategyLoadBalancer_ReceiveObject(StrategyImpl *strategy, static void _strategyLoadBalancer_OnTimeout(StrategyImpl *strategy, const NumberSet *egressId); static NumberSet *_strategyLoadBalancer_LookupNexthop( - StrategyImpl *strategy, const Message *interestMessage); + StrategyImpl *strategy, +#ifdef WITH_POLICY + NumberSet * nexthops, +#endif /* WITH_POLICY */ + const Message *interestMessage); +#ifndef WITH_POLICY static NumberSet *_strategyLoadBalancer_ReturnNexthops(StrategyImpl *strategy); static unsigned _strategyLoadBalancer_CountNexthops(StrategyImpl *strategy); +#endif /* ! WITH_POLICY */ static void _strategyLoadBalancer_AddNexthop(StrategyImpl *strategy, unsigned connectionId); static void _strategyLoadBalancer_RemoveNexthop(StrategyImpl *strategy, @@ -51,8 +57,10 @@ static StrategyImpl _template = { .receiveObject = &_strategyLoadBalancer_ReceiveObject, .onTimeout = &_strategyLoadBalancer_OnTimeout, .lookupNexthop = &_strategyLoadBalancer_LookupNexthop, +#ifndef WITH_POLICY .returnNexthops = &_strategyLoadBalancer_ReturnNexthops, .countNexthops = &_strategyLoadBalancer_CountNexthops, +#endif /* ! WITH_POLICY */ .addNexthop = &_strategyLoadBalancer_AddNexthop, .removeNexthop = &_strategyLoadBalancer_RemoveNexthop, .destroy = &_strategyLoadBalancer_ImplDestroy, @@ -63,10 +71,14 @@ struct strategy_load_balancer; typedef struct strategy_load_balancer StrategyLoadBalancer; struct strategy_load_balancer { +#ifndef WITH_POLICY double weights_sum; +#endif /* ! WITH_POLICY */ // hash map from connectionId to StrategyNexthopState PARCHashMap *strategy_state; +#ifndef WITH_POLICY NumberSet *nexthops; +#endif /* ! WITH_POLICY */ }; StrategyImpl *strategyLoadBalancer_Create() { @@ -75,9 +87,13 @@ StrategyImpl *strategyLoadBalancer_Create() { parcAssertNotNull(strategy, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(StrategyLoadBalancer)); +#ifndef WITH_POLICY strategy->weights_sum = 0.0; +#endif /* ! WITH_POLICY */ strategy->strategy_state = parcHashMap_Create(); +#ifndef WITH_POLICY strategy->nexthops = numberSet_Create(); +#endif /* ! WITH_POLICY */ srand((unsigned int)time(NULL)); StrategyImpl *impl = parcMemory_AllocateAndClear(sizeof(StrategyImpl)); @@ -99,12 +115,17 @@ strategy_type _strategyLoadBalancer_GetStrategy(StrategyImpl *strategy) { static void _update_Stats(StrategyLoadBalancer *strategy, StrategyNexthopState *state, bool inc) { const double ALPHA = 0.9; +#ifdef WITH_POLICY + strategyNexthopState_UpdateState(state, inc, ALPHA); +#else double w = strategyNexthopState_GetWeight(state); strategy->weights_sum -= w; w = strategyNexthopState_UpdateState(state, inc, ALPHA); strategy->weights_sum += w; +#endif /* WITH_POLICY */ } +#ifndef WITH_POLICY static unsigned _select_Nexthop(StrategyLoadBalancer *strategy) { double rnd = (double)rand() / (double)RAND_MAX; double start_range = 0.0; @@ -135,6 +156,7 @@ static unsigned _select_Nexthop(StrategyLoadBalancer *strategy) { // this! return nexthop; } +#endif /* ! WITH_POLICY */ static void _strategyLoadBalancer_ReceiveObject(StrategyImpl *strategy, const NumberSet *egressId, @@ -164,14 +186,47 @@ static void _strategyLoadBalancer_OnTimeout(StrategyImpl *strategy, } static NumberSet *_strategyLoadBalancer_LookupNexthop( - StrategyImpl *strategy, const Message *interestMessage) { + StrategyImpl *strategy, +#ifdef WITH_POLICY + NumberSet * nexthops, +#endif /* WITH_POLICY */ + const Message *interestMessage) { StrategyLoadBalancer *lb = (StrategyLoadBalancer *)strategy->context; + NumberSet *outList = numberSet_Create(); +#ifdef WITH_POLICY + /* Compute the sum of weights of potential next hops */ + double sum = 0; + for (unsigned i = 0; i < numberSet_Length(nexthops); i++) { + PARCUnsigned *cid = parcUnsigned_Create(numberSet_GetItem(nexthops, i)); + const StrategyNexthopState *elem = + parcHashMap_Get(lb->strategy_state, cid); + if (!elem) + continue; + sum += strategyNexthopState_GetWeight(elem); + } + + /* Perform weighted random selection */ + double distance = (double)rand() * sum / ((double)RAND_MAX + 1); + + for (unsigned i = 0; i < numberSet_Length(nexthops); i++) { + PARCUnsigned *cid = parcUnsigned_Create(numberSet_GetItem(nexthops, i)); + const StrategyNexthopState *state = + parcHashMap_Get(lb->strategy_state, cid); + if (!state) + continue; + distance -= strategyNexthopState_GetWeight(state); + if (distance < 0) { + numberSet_Add(outList, parcUnsigned_GetUnsigned(cid)); + _update_Stats(lb, (StrategyNexthopState *)state, true); + break; + } + } +#else unsigned in_connection = message_GetIngressConnectionId(interestMessage); PARCUnsigned *in = parcUnsigned_Create(in_connection); unsigned mapSize = (unsigned)parcHashMap_Size(lb->strategy_state); - NumberSet *outList = numberSet_Create(); if ((mapSize == 0) || ((mapSize == 1) && parcHashMap_Contains(lb->strategy_state, in))) { @@ -201,9 +256,12 @@ static NumberSet *_strategyLoadBalancer_LookupNexthop( parcUnsigned_Release(&out); numberSet_Add(outList, out_connection); +#endif /* WITH_POLICY */ + return outList; } +#ifndef WITH_POLICY static NumberSet *_strategyLoadBalancer_ReturnNexthops(StrategyImpl *strategy) { StrategyLoadBalancer *lb = (StrategyLoadBalancer *)strategy->context; return lb->nexthops; @@ -213,10 +271,13 @@ unsigned _strategyLoadBalancer_CountNexthops(StrategyImpl *strategy) { StrategyLoadBalancer *lb = (StrategyLoadBalancer *)strategy->context; return (unsigned)numberSet_Length(lb->nexthops); } +#endif /* ! WITH_POLICY */ static void _strategyLoadBalancer_resetState(StrategyImpl *strategy) { StrategyLoadBalancer *lb = (StrategyLoadBalancer *)strategy->context; +#ifndef WITH_POLICY lb->weights_sum = 0.0; +#endif/* ! WITH_POLICY */ PARCIterator *it = parcHashMap_CreateKeyIterator(lb->strategy_state); while (parcIterator_HasNext(it)) { @@ -225,7 +286,9 @@ static void _strategyLoadBalancer_resetState(StrategyImpl *strategy) { (StrategyNexthopState *)parcHashMap_Get(lb->strategy_state, cid); strategyNexthopState_Reset(elem); +#ifndef WITH_POLICY lb->weights_sum += strategyNexthopState_GetWeight(elem); +#endif /* ! WITH_POLICY */ } parcIterator_Release(&it); @@ -241,7 +304,9 @@ static void _strategyLoadBalancer_AddNexthop(StrategyImpl *strategy, if (!parcHashMap_Contains(lb->strategy_state, cid)) { parcHashMap_Put(lb->strategy_state, cid, state); +#ifndef WITH_POLICY numberSet_Add(lb->nexthops, connectionId); +#endif /* WITH_POLICY */ _strategyLoadBalancer_resetState(strategy); } } @@ -254,7 +319,9 @@ static void _strategyLoadBalancer_RemoveNexthop(StrategyImpl *strategy, if (parcHashMap_Contains(lb->strategy_state, cid)) { parcHashMap_Remove(lb->strategy_state, cid); +#ifndef WITH_POLICY numberSet_Remove(lb->nexthops, connectionId); +#endif /* WITH_POLICY */ _strategyLoadBalancer_resetState(strategy); } @@ -270,7 +337,9 @@ static void _strategyLoadBalancer_ImplDestroy(StrategyImpl **strategyPtr) { StrategyLoadBalancer *strategy = (StrategyLoadBalancer *)impl->context; parcHashMap_Release(&(strategy->strategy_state)); +#ifndef WITH_POLICY numberSet_Release(&(strategy->nexthops)); +#endif /* ! WITH_POLICY */ parcMemory_Deallocate((void **)&strategy); parcMemory_Deallocate((void **)&impl); diff --git a/hicn-light/src/hicn/strategies/loadBalancer.h b/hicn-light/src/hicn/strategies/loadBalancer.h index d0f4faece..74920768d 100644 --- a/hicn-light/src/hicn/strategies/loadBalancer.h +++ b/hicn-light/src/hicn/strategies/loadBalancer.h @@ -23,4 +23,5 @@ #include <hicn/strategies/strategyImpl.h> StrategyImpl *strategyLoadBalancer_Create(); + #endif // loadBalancer_h diff --git a/hicn-light/src/hicn/strategies/loadBalancerWithPD.c b/hicn-light/src/hicn/strategies/loadBalancerWithPD.c index 58f3b25fc..b0aae4cbb 100644 --- a/hicn-light/src/hicn/strategies/loadBalancerWithPD.c +++ b/hicn-light/src/hicn/strategies/loadBalancerWithPD.c @@ -38,11 +38,17 @@ static void _strategyLoadBalancerWithPD_ReceiveObject( static void _strategyLoadBalancerWithPD_OnTimeout(StrategyImpl *strategy, const NumberSet *egressId); static NumberSet *_strategyLoadBalancerWithPD_LookupNexthop( - StrategyImpl *strategy, const Message *interestMessage); + StrategyImpl *strategy, +#ifdef WITH_POLICY + NumberSet * nexthops, +#endif + const Message *interestMessage); +#ifndef WITH_POLICY static NumberSet *_strategyLoadBalancerWithPD_ReturnNexthops( StrategyImpl *strategy); static unsigned _strategyLoadBalancerWithPD_CountNexthops( StrategyImpl *strategy); +#endif /* ! WITH_POLICY */ static void _strategyLoadBalancerWithPD_AddNexthop(StrategyImpl *strategy, unsigned connectionId); static void _strategyLoadBalancerWithPD_RemoveNexthop(StrategyImpl *strategy, @@ -56,8 +62,10 @@ static StrategyImpl _template = { .receiveObject = &_strategyLoadBalancerWithPD_ReceiveObject, .onTimeout = &_strategyLoadBalancerWithPD_OnTimeout, .lookupNexthop = &_strategyLoadBalancerWithPD_LookupNexthop, +#ifndef WITH_POLICY .returnNexthops = &_strategyLoadBalancerWithPD_ReturnNexthops, .countNexthops = &_strategyLoadBalancerWithPD_CountNexthops, +#endif /* ! WITH_POLICY */ .addNexthop = &_strategyLoadBalancerWithPD_AddNexthop, .removeNexthop = &_strategyLoadBalancerWithPD_RemoveNexthop, .destroy = &_strategyLoadBalancerWithPD_ImplDestroy, @@ -72,13 +80,19 @@ struct strategy_load_balancer_with_pd { unsigned min_delay; // hash map from connectionId to StrategyNexthopState PARCHashMap *strategy_state; +#ifndef WITH_POLICY NumberSet *nexthops; - ConnectionTable *connTable; +#endif /* ! WITH_POLICY */ + const ConnectionTable *connTable; bool toInit; unsigned int fwdPackets; }; +#ifdef WITH_POLICY +StrategyImpl *strategyLoadBalancerWithPD_Create(const ConnectionTable *table) { +#else StrategyImpl *strategyLoadBalancerWithPD_Create() { +#endif /* WITH_POLICY */ StrategyLoadBalancerWithPD *strategy = parcMemory_AllocateAndClear(sizeof(StrategyLoadBalancerWithPD)); parcAssertNotNull(strategy, "parcMemory_AllocateAndClear(%zu) returned NULL", @@ -87,7 +101,9 @@ StrategyImpl *strategyLoadBalancerWithPD_Create() { strategy->weights_sum = 0.0; strategy->min_delay = INT_MAX; strategy->strategy_state = parcHashMap_Create(); +#ifndef WITH_POLICY strategy->nexthops = numberSet_Create(); +#endif /* ! WITH_POLICY */ srand((unsigned int)time(NULL)); StrategyImpl *impl = parcMemory_AllocateAndClear(sizeof(StrategyImpl)); @@ -127,6 +143,31 @@ static void _update_Stats(StrategyLoadBalancerWithPD *strategy, strategy->weights_sum += w; } +#ifdef WITH_POLICY +static void _sendProbes(StrategyLoadBalancerWithPD *strategy, NumberSet * nexthops) { + unsigned size = (unsigned)numberSet_Length(nexthops); + for (unsigned i = 0; i < size; i++) { + unsigned nhop = numberSet_GetItem(nexthops, i); + Connection *conn = + (Connection *)connectionTable_FindById(strategy->connTable, nhop); + if (!conn) + continue; + + connection_Probe(conn); + unsigned delay = (unsigned)connection_GetDelay(conn); + PARCUnsigned *cid = parcUnsigned_Create(nhop); + StrategyNexthopStateWithPD *elem = + (StrategyNexthopStateWithPD *)parcHashMap_Get( + strategy->strategy_state, cid); + strategyNexthopStateWithPD_SetDelay(elem, delay); + if (delay < strategy->min_delay && delay != 0) { + strategy->min_delay = delay; + } + + parcUnsigned_Release(&cid); + } +} +#else static void _sendProbes(StrategyLoadBalancerWithPD *strategy) { unsigned size = (unsigned)numberSet_Length(strategy->nexthops); for (unsigned i = 0; i < size; i++) { @@ -149,7 +190,53 @@ static void _sendProbes(StrategyLoadBalancerWithPD *strategy) { } } } +#endif /* WITH_POLICY */ + +#ifdef WITH_POLICY +static unsigned _select_Nexthop(StrategyLoadBalancerWithPD *strategy, NumberSet * nexthops) { + strategy->fwdPackets++; + if (strategy->toInit || strategy->fwdPackets == PROBE_FREQUENCY) { + strategy->toInit = false; + strategy->fwdPackets = 0; + _sendProbes(strategy, nexthops); + } + double rnd = (double)rand() / (double)RAND_MAX; + double start_range = 0.0; + + PARCIterator *it = parcHashMap_CreateKeyIterator(strategy->strategy_state); + + unsigned nexthop = 100000; + while (parcIterator_HasNext(it)) { + PARCUnsigned *cid = parcIterator_Next(it); + const StrategyNexthopStateWithPD *elem = + parcHashMap_Get(strategy->strategy_state, cid); + double w = strategyNexthopStateWithPD_GetWeight(elem); + + // printf("next = %u .. pi %u avgpi %f w %f avgrtt + // %f\n",parcUnsigned_GetUnsigned(cid), + // strategyNexthopStateWithPD_GetPI(elem), + // strategyNexthopStateWithPD_GetWeight(elem), + // strategyNexthopStateWithPD_GetWeight(elem), + // strategyNexthopStateWithPD_GetAvgRTT(elem)); + + double prob = w / strategy->weights_sum; + if ((rnd >= start_range) && (rnd < (start_range + prob))) { + nexthop = parcUnsigned_GetUnsigned(cid); + break; + } else { + start_range += prob; + } + } + + parcIterator_Release(&it); + + // if no face is selected by the algorithm (for example because of a wrong + // round in the weights) we may always select the last face here. Double check + // this! + return nexthop; +} +#else static unsigned _select_Nexthop(StrategyLoadBalancerWithPD *strategy) { strategy->fwdPackets++; if (strategy->toInit || strategy->fwdPackets == PROBE_FREQUENCY) { @@ -193,6 +280,7 @@ static unsigned _select_Nexthop(StrategyLoadBalancerWithPD *strategy) { // this! return nexthop; } +#endif /* WITH_POLICY */ static void _strategyLoadBalancerWithPD_ReceiveObject( StrategyImpl *strategy, const NumberSet *egressId, @@ -242,7 +330,11 @@ static void _strategyLoadBalancerWithPD_OnTimeout(StrategyImpl *strategy, // function never returns NULL. in case we have no output face we need to return // an empty NumberSet static NumberSet *_strategyLoadBalancerWithPD_LookupNexthop( - StrategyImpl *strategy, const Message *interestMessage) { + StrategyImpl *strategy, +#ifdef WITH_POLICY + NumberSet * nexthops, +#endif + const Message *interestMessage) { StrategyLoadBalancerWithPD *lb = (StrategyLoadBalancerWithPD *)strategy->context; @@ -262,7 +354,11 @@ static NumberSet *_strategyLoadBalancerWithPD_LookupNexthop( unsigned out_connection; do { +#ifdef WITH_POLICY + out_connection = _select_Nexthop(lb, nexthops); +#else out_connection = _select_Nexthop(lb); +#endif /* WITH_POLICY */ } while (out_connection == in_connection); PARCUnsigned *out = parcUnsigned_Create(out_connection); @@ -284,6 +380,7 @@ static NumberSet *_strategyLoadBalancerWithPD_LookupNexthop( return outList; } +#ifndef WITH_POLICY static NumberSet *_strategyLoadBalancerWithPD_ReturnNexthops( StrategyImpl *strategy) { StrategyLoadBalancerWithPD *lb = @@ -296,6 +393,7 @@ unsigned _strategyLoadBalancerWithPD_CountNexthops(StrategyImpl *strategy) { (StrategyLoadBalancerWithPD *)strategy->context; return (unsigned)numberSet_Length(lb->nexthops); } +#endif /* WITH_POLICY */ static void _strategyLoadBalancerWithPD_resetState(StrategyImpl *strategy) { StrategyLoadBalancerWithPD *lb = @@ -328,7 +426,9 @@ static void _strategyLoadBalancerWithPD_AddNexthop(StrategyImpl *strategy, if (!parcHashMap_Contains(lb->strategy_state, cid)) { parcHashMap_Put(lb->strategy_state, cid, state); +#ifndef WITH_POLICY numberSet_Add(lb->nexthops, connectionId); +#endif /* ! WITH_POLICY */ _strategyLoadBalancerWithPD_resetState(strategy); } } @@ -342,7 +442,9 @@ static void _strategyLoadBalancerWithPD_RemoveNexthop(StrategyImpl *strategy, if (parcHashMap_Contains(lb->strategy_state, cid)) { parcHashMap_Remove(lb->strategy_state, cid); +#ifndef WITH_POLICY numberSet_Remove(lb->nexthops, connectionId); +#endif /* ! WITH_POLICY */ _strategyLoadBalancerWithPD_resetState(strategy); } @@ -360,7 +462,9 @@ static void _strategyLoadBalancerWithPD_ImplDestroy( (StrategyLoadBalancerWithPD *)impl->context; parcHashMap_Release(&(strategy->strategy_state)); +#ifndef WITH_POLICY numberSet_Release(&(strategy->nexthops)); +#endif /* ! WITH_POLICY */ parcMemory_Deallocate((void **)&strategy); parcMemory_Deallocate((void **)&impl); diff --git a/hicn-light/src/hicn/strategies/loadBalancerWithPD.h b/hicn-light/src/hicn/strategies/loadBalancerWithPD.h index d8a215913..e6c9f8271 100644 --- a/hicn-light/src/hicn/strategies/loadBalancerWithPD.h +++ b/hicn-light/src/hicn/strategies/loadBalancerWithPD.h @@ -21,10 +21,15 @@ #ifndef loadBalancerWithPD_h #define loadBalancerWithPD_h -#include <hicn/core/connectionTable.h> #include <hicn/strategies/strategyImpl.h> +#include <hicn/core/connectionTable.h> +#ifdef WITH_POLICY +StrategyImpl *strategyLoadBalancerWithPD_Create(const ConnectionTable * table); +#else StrategyImpl *strategyLoadBalancerWithPD_Create(); +#endif /* WITH_POLICY */ + void strategyLoadBalancerWithPD_SetConnectionTable(StrategyImpl *strategy, ConnectionTable *connTable); #endif // loadBalancerWithPD_h diff --git a/hicn-light/src/hicn/strategies/nexthopState.c b/hicn-light/src/hicn/strategies/nexthopState.c index 0997193ce..40af14832 100644 --- a/hicn-light/src/hicn/strategies/nexthopState.c +++ b/hicn-light/src/hicn/strategies/nexthopState.c @@ -23,6 +23,8 @@ #include <parc/assert/parc_Assert.h> #include <hicn/strategies/nexthopState.h> +#define AVG_PI_THRESHOLD 1e-3 + struct strategy_nexthop_state { unsigned int pi; double avg_pi; @@ -197,7 +199,11 @@ double strategyNexthopState_UpdateState(StrategyNexthopState *x, bool inc, } } x->avg_pi = (x->avg_pi * alpha) + (x->pi * (1 - alpha)); +#ifdef WITH_POLICY + if (x->avg_pi < AVG_PI_THRESHOLD) { +#else if (x->avg_pi == 0.0) { +#endif /* WITH_POLICY */ x->avg_pi = 0.1; } x->weight = 1 / x->avg_pi; diff --git a/hicn-light/src/hicn/strategies/rnd.c b/hicn-light/src/hicn/strategies/rnd.c index e2d74036c..637fd90f9 100644 --- a/hicn-light/src/hicn/strategies/rnd.c +++ b/hicn-light/src/hicn/strategies/rnd.c @@ -32,9 +32,14 @@ static void _strategyRnd_ReceiveObject(StrategyImpl *strategy, static void _strategyRnd_OnTimeout(StrategyImpl *strategy, const NumberSet *egressId); static NumberSet *_strategyRnd_LookupNexthop(StrategyImpl *strategy, - const Message *interestMessage); +#ifdef WITH_POLICY + NumberSet * nexthops, +#endif /* WITH_POLICY */ + const Message *interestMessage); +#ifndef WITH_POLICY static NumberSet *_strategyRnd_ReturnNexthops(StrategyImpl *strategy); static unsigned _strategyRnd_CountNexthops(StrategyImpl *strategy); +#endif /* ! WITH_POLICY */ static void _strategyRnd_AddNexthop(StrategyImpl *strategy, unsigned connectionId); static void _strategyRnd_RemoveNexthop(StrategyImpl *strategy, @@ -47,8 +52,10 @@ static StrategyImpl _template = { .receiveObject = &_strategyRnd_ReceiveObject, .onTimeout = &_strategyRnd_OnTimeout, .lookupNexthop = &_strategyRnd_LookupNexthop, +#ifndef WITH_POLICY .returnNexthops = &_strategyRnd_ReturnNexthops, .countNexthops = &_strategyRnd_CountNexthops, +#endif /* ! WITH_POLICY */ .addNexthop = &_strategyRnd_AddNexthop, .removeNexthop = &_strategyRnd_RemoveNexthop, .destroy = &_strategyRnd_ImplDestroy, @@ -59,7 +66,9 @@ struct strategy_rnd; typedef struct strategy_rnd StrategyRnd; struct strategy_rnd { +#ifndef WITH_POLICY NumberSet *nexthops; +#endif /* ! WITH_POLICY */ }; StrategyImpl *strategyRnd_Create() { @@ -67,7 +76,9 @@ StrategyImpl *strategyRnd_Create() { parcAssertNotNull(strategy, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(StrategyRnd)); +#ifndef WITH_POLICY strategy->nexthops = numberSet_Create(); +#endif /* ! WITH_POLICY */ srand((unsigned int)time(NULL)); StrategyImpl *impl = parcMemory_AllocateAndClear(sizeof(StrategyImpl)); @@ -85,6 +96,7 @@ strategy_type _strategyRnd_GetStrategy(StrategyImpl *strategy) { return SET_STRATEGY_RANDOM; } +#ifndef WITH_POLICY static int _select_Nexthop(StrategyRnd *strategy) { unsigned len = (unsigned)numberSet_Length(strategy->nexthops); if (len == 0) { @@ -94,6 +106,7 @@ static int _select_Nexthop(StrategyRnd *strategy) { int rnd = (rand() % len); return numberSet_GetItem(strategy->nexthops, rnd); } +#endif /* ! WITH_POLICY */ static void _strategyRnd_ReceiveObject(StrategyImpl *strategy, const NumberSet *egressId, @@ -104,13 +117,22 @@ static void _strategyRnd_OnTimeout(StrategyImpl *strategy, const NumberSet *egressId) {} static NumberSet *_strategyRnd_LookupNexthop(StrategyImpl *strategy, - const Message *interestMessage) { - StrategyRnd *srnd = (StrategyRnd *)strategy->context; +#ifdef WITH_POLICY + NumberSet * nexthops, +#endif /* WITH_POLICY */ + const Message *interestMessage) { + unsigned out_connection; + NumberSet *out = numberSet_Create(); + +#ifdef WITH_POLICY + // We return one next hop at random + out_connection = numberSet_GetItem(nexthops, rand() % numberSet_Length(nexthops)); +#else + StrategyRnd *srnd = (StrategyRnd *)strategy->context; unsigned in_connection = message_GetIngressConnectionId(interestMessage); unsigned nexthopSize = (unsigned)numberSet_Length(srnd->nexthops); - NumberSet *out = numberSet_Create(); if ((nexthopSize == 0) || ((nexthopSize == 1) && numberSet_Contains(srnd->nexthops, in_connection))) { @@ -119,7 +141,6 @@ static NumberSet *_strategyRnd_LookupNexthop(StrategyImpl *strategy, return out; } - unsigned out_connection; do { out_connection = _select_Nexthop(srnd); } while (out_connection == in_connection); @@ -127,11 +148,13 @@ static NumberSet *_strategyRnd_LookupNexthop(StrategyImpl *strategy, if (out_connection == -1) { return out; } +#endif /* WITH_POLICY */ numberSet_Add(out, out_connection); return out; } +#ifndef WITH_POLICY static NumberSet *_strategyRnd_ReturnNexthops(StrategyImpl *strategy) { StrategyRnd *srnd = (StrategyRnd *)strategy->context; return srnd->nexthops; @@ -141,22 +164,27 @@ unsigned _strategyRnd_CountNexthops(StrategyImpl *strategy) { StrategyRnd *srnd = (StrategyRnd *)strategy->context; return (unsigned)numberSet_Length(srnd->nexthops); } +#endif /* ! WITH_POLICY */ static void _strategyRnd_AddNexthop(StrategyImpl *strategy, unsigned connectionId) { +#ifndef WITH_POLICY StrategyRnd *srnd = (StrategyRnd *)strategy->context; if (!numberSet_Contains(srnd->nexthops, connectionId)) { numberSet_Add(srnd->nexthops, connectionId); } +#endif /* ! WITH_POLICY */ } static void _strategyRnd_RemoveNexthop(StrategyImpl *strategy, unsigned connectionId) { +#ifndef WITH_POLICY StrategyRnd *srnd = (StrategyRnd *)strategy->context; if (numberSet_Contains(srnd->nexthops, connectionId)) { numberSet_Remove(srnd->nexthops, connectionId); } +#endif /* ! WITH_POLICY */ } static void _strategyRnd_ImplDestroy(StrategyImpl **strategyPtr) { @@ -167,7 +195,9 @@ static void _strategyRnd_ImplDestroy(StrategyImpl **strategyPtr) { StrategyImpl *impl = *strategyPtr; StrategyRnd *strategy = (StrategyRnd *)impl->context; +#ifndef WITH_POLICY numberSet_Release(&(strategy->nexthops)); +#endif /* ! WITH_POLICY */ parcMemory_Deallocate((void **)&strategy); parcMemory_Deallocate((void **)&impl); diff --git a/hicn-light/src/hicn/strategies/rnd.h b/hicn-light/src/hicn/strategies/rnd.h index b57b41ccf..78fb34758 100644 --- a/hicn-light/src/hicn/strategies/rnd.h +++ b/hicn-light/src/hicn/strategies/rnd.h @@ -23,4 +23,5 @@ #include <hicn/strategies/strategyImpl.h> StrategyImpl* strategyRnd_Create(); + #endif // rnd_h diff --git a/hicn-light/src/hicn/strategies/rndSegment.c b/hicn-light/src/hicn/strategies/rndSegment.c index d7a5c6aec..93e39ee74 100644 --- a/hicn-light/src/hicn/strategies/rndSegment.c +++ b/hicn-light/src/hicn/strategies/rndSegment.c @@ -33,9 +33,15 @@ static void _strategyRndSegment_ReceiveObject(StrategyImpl *strategy, static void _strategyRndSegment_OnTimeout(StrategyImpl *strategy, const NumberSet *egressId); static NumberSet *_strategyRndSegment_LookupNexthop( - StrategyImpl *strategy, const Message *interestMessage); + StrategyImpl *strategy, +#ifdef WITH_POLICY + NumberSet * nexthops, +#endif /* WITH_POLICY */ + const Message *interestMessage); +#ifndef WITH_POLICY static NumberSet *_strategyRndSegment_ReturnNexthops(StrategyImpl *strategy); static unsigned _strategyRndSegment_CountNexthops(StrategyImpl *strategy); +#endif /* ! WITH_POLICY */ static void _strategyRndSegment_AddNexthop(StrategyImpl *strategy, unsigned connectionId); static void _strategyRndSegment_RemoveNexthop(StrategyImpl *strategy, @@ -48,8 +54,10 @@ static StrategyImpl _template = { .receiveObject = &_strategyRndSegment_ReceiveObject, .onTimeout = &_strategyRndSegment_OnTimeout, .lookupNexthop = &_strategyRndSegment_LookupNexthop, +#ifndef WITH_POLICY .returnNexthops = &_strategyRndSegment_ReturnNexthops, .countNexthops = &_strategyRndSegment_CountNexthops, +#endif /* ! WITH_POLICY */ .addNexthop = &_strategyRndSegment_AddNexthop, .removeNexthop = &_strategyRndSegment_RemoveNexthop, .destroy = &_strategyRndSegment_ImplDestroy, @@ -111,7 +119,11 @@ static void _strategyRndSegment_OnTimeout(StrategyImpl *strategy, const NumberSet *egressId) {} static NumberSet *_strategyRndSegment_LookupNexthop( - StrategyImpl *strategy, const Message *interestMessage) { + StrategyImpl *strategy, +#ifdef WITH_POLICY + NumberSet * nexthops, +#endif /* WITH_POLICY */ + const Message *interestMessage) { StrategyRndSegment *srnd = (StrategyRndSegment *)strategy->context; unsigned in_connection = message_GetIngressConnectionId(interestMessage); @@ -161,6 +173,7 @@ static NumberSet *_strategyRndSegment_LookupNexthop( return out; } +#ifndef WITH_POLICY static NumberSet *_strategyRndSegment_ReturnNexthops(StrategyImpl *strategy) { StrategyRndSegment *srnd = (StrategyRndSegment *)strategy->context; return srnd->nexthops; @@ -170,22 +183,27 @@ unsigned _strategyRndSegment_CountNexthops(StrategyImpl *strategy) { StrategyRndSegment *srnd = (StrategyRndSegment *)strategy->context; return (unsigned)numberSet_Length(srnd->nexthops); } +#endif /* ! WITH_POLICY */ static void _strategyRndSegment_AddNexthop(StrategyImpl *strategy, unsigned connectionId) { +#ifndef WITH_POLICY StrategyRndSegment *srnd = (StrategyRndSegment *)strategy->context; if (!numberSet_Contains(srnd->nexthops, connectionId)) { numberSet_Add(srnd->nexthops, connectionId); } +#endif /* ! WITH_POLICY */ } static void _strategyRndSegment_RemoveNexthop(StrategyImpl *strategy, unsigned connectionId) { +#ifndef WITH_POLICY StrategyRndSegment *srnd = (StrategyRndSegment *)strategy->context; if (numberSet_Contains(srnd->nexthops, connectionId)) { numberSet_Remove(srnd->nexthops, connectionId); } +#endif /* ! WITH_POLICY */ } static void _strategyRndSegment_ImplDestroy(StrategyImpl **strategyPtr) { diff --git a/hicn-light/src/hicn/strategies/rndSegment.h b/hicn-light/src/hicn/strategies/rndSegment.h index 897ccca47..6694f03e5 100644 --- a/hicn-light/src/hicn/strategies/rndSegment.h +++ b/hicn-light/src/hicn/strategies/rndSegment.h @@ -23,5 +23,6 @@ #include <hicn/strategies/strategyImpl.h> -StrategyImpl* strategyRndSegment_Create(); +StrategyImpl *strategyRndSegment_Create(); + #endif // rnd_Segment_h diff --git a/hicn-light/src/hicn/strategies/strategyImpl.h b/hicn-light/src/hicn/strategies/strategyImpl.h index 2634665eb..d4001194a 100644 --- a/hicn-light/src/hicn/strategies/strategyImpl.h +++ b/hicn-light/src/hicn/strategies/strategyImpl.h @@ -55,12 +55,18 @@ struct strategy_impl { const Message *objectMessage, Ticks rtt); void (*onTimeout)(StrategyImpl *strategy, const NumberSet *egressId); NumberSet *(*lookupNexthop)(StrategyImpl *strategy, +#ifdef WITH_POLICY + NumberSet * nexthops, +#endif /* WITH_POLICY */ const Message *interestMessage); +#ifndef WITH_POLICY NumberSet *(*returnNexthops)(StrategyImpl *strategy); unsigned (*countNexthops)(StrategyImpl *strategy); +#endif /* ! WITH_POLICY */ void (*addNexthop)(StrategyImpl *strategy, unsigned connectionId); void (*removeNexthop)(StrategyImpl *strategy, unsigned connectionId); void (*destroy)(StrategyImpl **strategyPtr); strategy_type (*getStrategy)(StrategyImpl *strategy); }; + #endif // strategyImpl_h diff --git a/hicn-light/src/hicn/utils/CMakeLists.txt b/hicn-light/src/hicn/utils/CMakeLists.txt index ad9c8e4c1..dd9e12c15 100644 --- a/hicn-light/src/hicn/utils/CMakeLists.txt +++ b/hicn-light/src/hicn/utils/CMakeLists.txt @@ -19,7 +19,9 @@ list(APPEND HEADER_FILES ${CMAKE_CURRENT_SOURCE_DIR}/commands.h ${CMAKE_CURRENT_SOURCE_DIR}/interface.h ${CMAKE_CURRENT_SOURCE_DIR}/interfaceSet.h + ${CMAKE_CURRENT_SOURCE_DIR}/policy.h ${CMAKE_CURRENT_SOURCE_DIR}/punting.h + ${CMAKE_CURRENT_SOURCE_DIR}/token.h ${CMAKE_CURRENT_SOURCE_DIR}/utils.h ) @@ -28,6 +30,7 @@ list(APPEND SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/addressList.c ${CMAKE_CURRENT_SOURCE_DIR}/interface.c ${CMAKE_CURRENT_SOURCE_DIR}/interfaceSet.c + ${CMAKE_CURRENT_SOURCE_DIR}/policy.c ${CMAKE_CURRENT_SOURCE_DIR}/punting.c ${CMAKE_CURRENT_SOURCE_DIR}/utils.c ) diff --git a/hicn-light/src/hicn/utils/commands.h b/hicn-light/src/hicn/utils/commands.h index 96415d8da..223bbffaa 100644 --- a/hicn-light/src/hicn/utils/commands.h +++ b/hicn-light/src/hicn/utils/commands.h @@ -31,6 +31,8 @@ #include <stdint.h> #include <stdlib.h> +#include <hicn/utils/policy.h> + typedef struct in6_addr ipv6_addr_t; typedef uint32_t ipv4_addr_t; @@ -67,6 +69,12 @@ typedef enum { MAPME_TIMESCALE, MAPME_RETX, CONNECTION_SET_ADMIN_STATE, +#ifdef WITH_POLICY + ADD_POLICY, + LIST_POLICIES, + REMOVE_POLICY, + UPDATE_CONNECTION, +#endif /* WITH_POLICY */ LAST_COMMAND_VALUE } command_id; @@ -129,6 +137,9 @@ typedef struct { uint8_t ipType; uint8_t connectionType; uint8_t admin_state; +#ifdef WITH_POLICY + policy_tags_t tags; +#endif /* WITH_POLICY */ } add_connection_command; // SIZE=56 @@ -291,6 +302,36 @@ typedef struct { uint8_t admin_state; } connection_set_admin_state_command; +#ifdef WITH_POLICY + +typedef struct { + union commandAddr address; + uint8_t addressType; + uint8_t len; + policy_t policy; +} add_policy_command; + +typedef struct { + union commandAddr address; + uint8_t addressType; + uint8_t len; + policy_t policy; +} list_policies_command; + +typedef struct { + union commandAddr address; + uint8_t addressType; + uint8_t len; +} remove_policy_command; + +typedef struct { + char symbolicOrConnid[16]; + uint8_t admin_state; + policy_tags_t tags; +} update_connection_command; + +#endif /* WITH_POLICY */ + //===== size of commands ====== // REMINDER: when a new_command is added, the following switch has to be // updated. @@ -334,6 +375,16 @@ static inline int payloadLengthDaemon(command_id id) { return sizeof(mapme_timing_command); case CONNECTION_SET_ADMIN_STATE: return sizeof(connection_set_admin_state_command); +#ifdef WITH_POLICY + case ADD_POLICY: + return sizeof(add_policy_command); + case LIST_POLICIES: + return 0; // list policies: payload always 0 + case REMOVE_POLICY: + return sizeof(remove_policy_command); + case UPDATE_CONNECTION: + return sizeof(update_connection_command); +#endif /* WITH_POLICY */ case LAST_COMMAND_VALUE: return 0; default: diff --git a/hicn-light/src/hicn/utils/policy.c b/hicn-light/src/hicn/utils/policy.c new file mode 100644 index 000000000..6c8651ee3 --- /dev/null +++ b/hicn-light/src/hicn/utils/policy.c @@ -0,0 +1,59 @@ +/* + * 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. + */ + +/** + * \file policy.h + * \brief Implementation of policy description + */ + +#include <stdio.h> +#include "policy.h" + +const char * policy_tag_str[] = { + #define _(x, y) [POLICY_TAG_ ## x] = STRINGIZE(x), + foreach_policy_tag + #undef _ +}; + +const char policy_tag_short_str[] = { + #define _(x, y) [POLICY_TAG_ ## x] = y, + foreach_policy_tag + #undef _ +}; + +const char * policy_state_str[] = { + #define _(x) [POLICY_STATE_ ## x] = STRINGIZE(x), + foreach_policy_state + #undef _ +}; + +int +policy_tag_state_snprintf(char * s, size_t size, const policy_tag_state_t * tag_state) +{ + char *cur = s; + int rc; + + if (tag_state->disabled > 1) + return -1; + + rc = snprintf(cur, s + size - cur, "%s%s", (tag_state->disabled == 1) ? "!" : "", policy_state_str[tag_state->state]); + if (rc < 0) + return rc; + cur += rc; + if (size != 0 && cur >= s + size) + return cur - s; + + return cur - s; +} diff --git a/hicn-light/src/hicn/utils/policy.h b/hicn-light/src/hicn/utils/policy.h new file mode 100644 index 000000000..993fdca44 --- /dev/null +++ b/hicn-light/src/hicn/utils/policy.h @@ -0,0 +1,232 @@ +/* + * 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. + */ + +/** + * \file policy.h + * \brief Policy description + */ +#ifndef HICN_POLICY_H +#define HICN_POLICY_H + +#include <netinet/in.h> // INET*_ADDRSTRLEN +#include <string.h> // strcasecmp +#include "token.h" + +/* POLICY TAG */ + +#define foreach_policy_tag \ + /* Interface type */ \ + _(WIRED, 'E') \ + _(WIFI, 'W') \ + _(CELLULAR, 'C') \ + /* QoS */ \ + _(BEST_EFFORT, 'b') \ + _(REALTIME, 'r') \ + _(MULTIPATH, 'M') \ + /* Security */ \ + _(TRUSTED, 'T') + +typedef enum { +#define _(x, y) POLICY_TAG_ ## x, +foreach_policy_tag +#undef _ + POLICY_TAG_N +} policy_tag_t; + +#define MAXSZ_POLICY_TAG_ 11 +#define MAXSZ_POLICY_TAG MAXSZ_POLICY_TAG_ + 1 + +extern const char * policy_tag_str[]; +extern const char policy_tag_short_str[]; + +static inline +policy_tag_t +policy_tag_from_str(const char * str) +{ +#define _(x, y) if (strcasecmp(str, policy_tag_str[POLICY_TAG_ ## x] ) == 0) { return POLICY_TAG_ ## x; } else +foreach_policy_tag +#undef _ + return POLICY_TAG_N; +} + +/* POLICY_TAGS */ + +typedef int policy_tags_t; + +static inline +void policy_tags_add(policy_tags_t * tags, policy_tag_t tag) +{ + *tags |= (1 << tag); +} + +static inline +void policy_tags_remove(policy_tags_t * tags, policy_tag_t tag) +{ + *tags &= ~(1 << tag); +} + +static inline +int policy_tags_has(policy_tags_t tags, policy_tag_t tag) +{ + return tags & (1 << tag); +} + +#define POLICY_TAGS_EMPTY 0 + +static inline +int +policy_tags_snprintf(char * s, size_t size, policy_tags_t tags) +{ +#define _(x, y) s[POLICY_TAG_ ## x] = policy_tags_has(tags, POLICY_TAG_ ## x) ? y : '.'; +foreach_policy_tag +#undef _ + s[POLICY_TAG_N] = '\0'; + return POLICY_TAG_N + 1; +} + +#define MAXSZ_POLICY_TAGS_ POLICY_TAG_N +#define MAXSZ_POLICY_TAGS MAXSZ_POLICY_TAGS_ + 1 + +/* POLICY STATE */ + +#define foreach_policy_state \ + _(NEUTRAL) \ + _(REQUIRE) \ + _(PREFER) \ + _(AVOID) \ + _(PROHIBIT) \ + _(N) + +typedef enum { +#define _(x) POLICY_STATE_ ## x, +foreach_policy_state +#undef _ +} policy_state_t; + +#define MAXSZ_POLICY_STATE_ 8 +#define MAXSZ_POLICY_STATE MAXSZ_POLICY_STATE_ + 1 + +extern const char * policy_state_str[]; + + +/* POLICY TAG STATE */ + +typedef struct { + policy_state_t state; + uint8_t disabled; +} policy_tag_state_t; + +#define MAXSZ_POLICY_TAG_STATE_ 8 +#define MAXSZ_POLICY_TAG_STATE MAXSZ_POLICY_TAG_STATE_ + 1 + +int policy_tag_state_snprintf(char * s, size_t size, const policy_tag_state_t * tag_state); + + +/* INTERFACE STATS */ + +typedef struct { + float throughput; + float latency; + float loss_rate; +} interface_stats_t; + +#define INTERFACE_STATS_NONE { \ + .throughput = 0, \ + .latency = 0, \ + .loss_rate = 0, \ +} + + +/* POLICY STATS */ + +typedef struct { + interface_stats_t wired; + interface_stats_t wifi; + interface_stats_t cellular; + interface_stats_t all; +} policy_stats_t; + +#define POLICY_STATS_NONE { \ + .wired = INTERFACE_STATS_NONE, \ + .wifi = INTERFACE_STATS_NONE, \ + .cellular = INTERFACE_STATS_NONE, \ + .all = INTERFACE_STATS_NONE, \ +} + +typedef struct { + uint32_t num_packets; + uint32_t num_bytes; + uint32_t num_losses; + uint32_t latency_idle; +} interface_counters_t; + +#define INTERFACE_COUNTERS_NONE { \ + .num_packets = 0, \ + .num_bytes = 0, \ + .num_losses = 0, \ + .latency_idle = 0, \ +} + +typedef struct { + interface_counters_t wired; + interface_counters_t wifi; + interface_counters_t cellular; + interface_counters_t all; + uint64_t last_update; +} policy_counters_t; + +#define POLICY_COUNTERS_NONE (policy_counters_t) { \ + .wired = INTERFACE_COUNTERS_NONE, \ + .wifi = INTERFACE_COUNTERS_NONE, \ + .cellular = INTERFACE_COUNTERS_NONE, \ + .all = INTERFACE_COUNTERS_NONE, \ + .last_update = 0, \ +} + +/* POLICY */ + +#define APP_NAME_LEN 128 + +typedef struct { + char app_name[APP_NAME_LEN]; + policy_tag_state_t tags[POLICY_TAG_N]; + policy_stats_t stats; +} policy_t; + +static const policy_t POLICY_NONE = { + .app_name = { 0 }, + .tags = { +#define _(x, y) [POLICY_TAG_ ## x] = { POLICY_STATE_NEUTRAL, 0 }, +foreach_policy_tag +#undef _ + }, + .stats = POLICY_STATS_NONE, +}; + + +/* POLICY DESCRIPTION */ + +#define PFX_STRLEN 4 /* eg. /128 */ + +typedef struct { + int family; + union { + char ipv4_prefix[INET_ADDRSTRLEN + PFX_STRLEN]; + char ipv6_prefix[INET6_ADDRSTRLEN + PFX_STRLEN]; + }; + policy_t policy; +} policy_description_t; + +#endif /* HICN_POLICY_H */ diff --git a/hicn-light/src/hicn/utils/token.h b/hicn-light/src/hicn/utils/token.h new file mode 100644 index 000000000..43e0a77b2 --- /dev/null +++ b/hicn-light/src/hicn/utils/token.h @@ -0,0 +1,40 @@ +/* + * 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. + */ + +/* Token concatenation */ + +/* + * Concatenate preprocessor tokens A and B without expanding macro definitions + * (however, if invoked from a macro, macro arguments are expanded). + */ +#define PPCAT_NX(A, B) A ## B + +/* + * Concatenate preprocessor tokens A and B after macro-expanding them. + */ +#define PPCAT(A, B) PPCAT_NX(A, B) + +/* Token stringification */ + +/* + * Turn A into a string literal without expanding macro definitions + * (however, if invoked from a macro, macro arguments are expanded). + */ +#define STRINGIZE_NX(A) #A + +/* + * Turn A into a string literal after macro-expanding it. + */ +#define STRINGIZE(A) STRINGIZE_NX(A) |