ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
mbed-os/connectivity/nanostack/sal-stack-nanostack/source/DHCPv6_Server/DHCPv6_Server_service.c

562 lines
21 KiB
C
Raw Blame History

/*
* Copyright (c) 2014-2021, Pelion and affiliates.
* SPDX-License-Identifier: Apache-2.0
*
* 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 DHCPv6_Server_service.c
* \brief Add short description about this file!!!
*
*/
#include "nsconfig.h"
#ifdef HAVE_DHCPV6_SERVER
#include <string.h>
#include <ns_types.h>
#include <ns_trace.h>
#include "eventOS_event.h"
#include "eventOS_scheduler.h"
#include "eventOS_event_timer.h"
#include <nsdynmemLIB.h>
#include "libDHCPv6/libDHCPv6.h"
#include "libDHCPv6/libDHCPv6_server.h"
#include "DHCPv6_Server/DHCPv6_server_service.h"
#include "common_functions.h"
#include "NWK_INTERFACE/Include/protocol.h"
#include "Common_Protocols/icmpv6.h"
#include "dhcp_service_api.h"
#define TRACE_GROUP "dhcp"
#define DHCPV6_GUA_IF "dhcp"
#define DHCPV6_SERVER_SERVICE_TASKLET_INIT 1
#define DHCPV6_SERVER_SERVICE_TIMER 2
#define DHCPV6_SERVER_SERVICE_TIMER_ID 1
#define DHCPV6_TIMER_UPDATE_PERIOD_IN_SECONDS 10
typedef struct dhcpv6_gua_response {
uint16_t responseLength;
uint8_t *responsePtr;
} dhcpv6_gua_response_t;
static int8_t dhcpv6_service_tasklet = -1;
static arm_event_storage_t *dhcp_timer_storage = NULL;
static bool DHCP_server_service_timer_start(void)
{
if (!dhcp_timer_storage) {
arm_event_s event = {
.receiver = dhcpv6_service_tasklet,
.sender = 0,
.event_id = DHCPV6_SERVER_SERVICE_TIMER_ID,
.data_ptr = NULL,
.event_type = DHCPV6_SERVER_SERVICE_TIMER,
.priority = ARM_LIB_LOW_PRIORITY_EVENT,
};
dhcp_timer_storage = eventOS_event_timer_request_every(&event, eventOS_event_timer_ms_to_ticks(DHCPV6_TIMER_UPDATE_PERIOD_IN_SECONDS * 1000));
if (!dhcp_timer_storage) {
tr_error("Dhcp server timer start fail");
return false;
}
}
return true;
}
static void DHCP_server_service_timer_stop(void)
{
if (dhcp_timer_storage && libdhcpv6_gua_server_list_empty()) {
eventOS_cancel(dhcp_timer_storage);
dhcp_timer_storage = NULL;
}
}
int DHCPv6_server_respond_client(dhcpv6_gua_server_entry_s *serverBase, dhcpv6_reply_packet_s *replyPacket, dhcp_ia_non_temporal_params_t *dhcp_ia_non_temporal_params, dhcpv6_gua_response_t *response, bool allocateNew)
{
dhcpv6_allocated_address_t *dhcp_allocated_address = NULL;
//Validate Client DUID
dhcp_link_options_params_t clientDUID;
if (libdhcpv6_get_link_address_from_duid(replyPacket->clientDUID.duid, replyPacket->clientDUID.duid_length, replyPacket->clientDUID.type, &clientDUID) == 0) {
dhcp_allocated_address = libdhcpv6_address_allocate(serverBase, clientDUID.link_id, clientDUID.link_type, dhcp_ia_non_temporal_params->iaId, dhcp_ia_non_temporal_params->T0, dhcp_ia_non_temporal_params->T1, allocateNew);
}
if (dhcp_allocated_address) {
if (serverBase->addCb) {
dhcp_address_cache_update_t update_info;
update_info.allocatedAddress = dhcp_allocated_address->nonTemporalAddress;
update_info.allocatedNewAddress = allocateNew;
update_info.validLifeTime = dhcp_allocated_address->lifetime;
if (!serverBase->addCb(serverBase->interfaceId, &update_info, serverBase->guaPrefix)) {
libdhcpv6_address_delete(serverBase, dhcp_allocated_address->nonTemporalAddress);
dhcp_allocated_address = NULL;
}
}
}
response->responseLength = libdhcpv6_address_reply_message_len(replyPacket->clientDUID.duid_length, replyPacket->serverDUID.duid_length, 0, replyPacket->rapidCommit, (dhcp_allocated_address != NULL));
//Calculate DNS LIST and Vendor data lengths here
if (dhcp_allocated_address) {
response->responseLength += libdhcpv6_dns_server_message_sizes(serverBase);
response->responseLength += libdhcpv6_vendor_data_message_sizes(serverBase);
}
response->responsePtr = ns_dyn_mem_temporary_alloc(response->responseLength);
if (response->responsePtr) {
uint8_t *ptr = response->responsePtr;
//Write Generic data at beginning
ptr = libdhcpv6_header_write(ptr, DHCPV6_REPLY_TYPE, replyPacket->transaction_ID);
ptr = libdhcpv6_duid_option_write(ptr, DHCPV6_SERVER_ID_OPTION, &replyPacket->serverDUID); //16
ptr = libdhcpv6_duid_option_write(ptr, DHCPV6_CLIENT_ID_OPTION, &replyPacket->clientDUID); //16
if (dhcp_allocated_address) {
ptr = libdhcpv6_identity_association_option_write(ptr, replyPacket->iaId, replyPacket->T0, replyPacket->T1, true);
ptr = libdhcpv6_ia_address_option_write(ptr, dhcp_allocated_address->nonTemporalAddress, dhcp_allocated_address->preferredLifetime, dhcp_allocated_address->lifetime);
//Write DNS LIST and Vendor data here
ptr = libdhcpv6_dns_server_message_writes(serverBase, ptr);
ptr = libdhcpv6_vendor_data_message_writes(serverBase, ptr);
} else {
ptr = libdhcpv6_identity_association_option_write_with_status(ptr, replyPacket->iaId, replyPacket->T0, replyPacket->T1, DHCPV6_STATUS_NO_ADDR_AVAILABLE_CODE);
}
if (replyPacket->rapidCommit) {
ptr = libdhcpv6_rapid_commit_option_write(ptr);
}
return 0;
}
return -1;
}
int DHCPV6_server_service_request_handler(uint16_t instance_id, uint32_t msg_tr_id, uint8_t message_type, uint8_t *msg_ptr, uint16_t msg_len)
{
int retVal = RET_MSG_NOT_MINE;
dhcp_ia_non_temporal_params_t dhcp_ia_non_temporal_params;
dhcpv6_reply_packet_s replyPacket;
dhcpv6_gua_response_t responseBuf;
dhcpv6_gua_server_entry_s *serverBase;
tr_debug("GUA Handler");
switch (message_type) {
case DHCPV6_SOLICATION_TYPE:
if (libdhcpv6_solication_message_options_validate(msg_ptr, msg_len, &replyPacket.clientDUID, &dhcp_ia_non_temporal_params) == 0) {
//Start Build Response
serverBase = libdhcpv6_server_data_get_by_prefix_and_socketinstance(instance_id, dhcp_ia_non_temporal_params.nonTemporalAddress);
if (serverBase) {
//Here Allocate address
replyPacket.rapidCommit = libdhcpv6_rapid_commit_option_at_packet(msg_ptr, msg_len);
replyPacket.serverDUID = serverBase->serverDUID;
replyPacket.T0 = dhcp_ia_non_temporal_params.T0;
replyPacket.T1 = dhcp_ia_non_temporal_params.T1;
replyPacket.iaId = dhcp_ia_non_temporal_params.iaId;
replyPacket.transaction_ID = msg_tr_id;
tr_debug("Response dhcp sol %s clientDUID", trace_array(replyPacket.clientDUID.duid, replyPacket.clientDUID.duid_length));
//Check First Current list
if (DHCPv6_server_respond_client(serverBase, &replyPacket, &dhcp_ia_non_temporal_params, &responseBuf, true) == 0) {
//Respond
dhcp_service_send_resp(msg_tr_id, TX_OPT_NONE, responseBuf.responsePtr, responseBuf.responseLength);
ns_dyn_mem_free(responseBuf.responsePtr);
retVal = RET_MSG_ACCEPTED;
}
}
}
break;
case DHCPV6_RELEASE_TYPE:
break;
case DHCPV6_RENEW_TYPE:
if (libdhcpv6_renew_message_options_validate(msg_ptr, msg_len, &replyPacket.clientDUID, &replyPacket.serverDUID, &dhcp_ia_non_temporal_params) == 0) {
// Discover SERVER
serverBase = libdhcpv6_server_data_get_by_prefix_and_socketinstance(instance_id, dhcp_ia_non_temporal_params.nonTemporalAddress);
if (serverBase) {
if (libdhcpv6_compare_DUID(&serverBase->serverDUID, &replyPacket.serverDUID) == 0) {
replyPacket.rapidCommit = libdhcpv6_rapid_commit_option_at_packet(msg_ptr, msg_len);
replyPacket.T0 = dhcp_ia_non_temporal_params.T0;
replyPacket.T1 = dhcp_ia_non_temporal_params.T1;
replyPacket.iaId = dhcp_ia_non_temporal_params.iaId;
replyPacket.transaction_ID = msg_tr_id;
//Check First Current list
if (DHCPv6_server_respond_client(serverBase, &replyPacket, &dhcp_ia_non_temporal_params, &responseBuf, false) == 0) {
//Respond
dhcp_service_send_resp(msg_tr_id, TX_OPT_NONE, responseBuf.responsePtr, responseBuf.responseLength);
ns_dyn_mem_free(responseBuf.responsePtr);
retVal = RET_MSG_ACCEPTED;
}
}
}
}
break;
default:
tr_warn("UnSupported MessageId: %02x", message_type);
}
return retVal;
}
void DHCPv6_server_service_tasklet(arm_event_s *event)
{
if (event->event_type == DHCPV6_SERVER_SERVICE_TASKLET_INIT) {
//We should define peridiocally timer service!!
} else if (event->event_type == DHCPV6_SERVER_SERVICE_TIMER) {
libdhcpv6_gua_servers_time_update(DHCPV6_TIMER_UPDATE_PERIOD_IN_SECONDS);
}
}
static int8_t dhcpv6_server_service_tasklet_generated(void)
{
if (dhcpv6_service_tasklet == -1) {
dhcpv6_service_tasklet = eventOS_event_handler_create(DHCPv6_server_service_tasklet, DHCPV6_SERVER_SERVICE_TASKLET_INIT);
}
return dhcpv6_service_tasklet;
}
/* Initialize dhcp Global address server.
*
* This instance needs to bee initialized once for each thread network interface.
* if only one thread instance is supported this is needed to call only once.
*
* /param interface interface id of this thread instance.
* /param guaPrefix Global prefix /64
* /param serverDUID Server Device ID (64-bit MAC)
* /param serverDUIDType
*
*/
int DHCPv6_server_service_init(int8_t interface, uint8_t guaPrefix[static 16], uint8_t serverDUID[static 8], uint16_t serverDUIDType)
{
int retVal = -1;
uint16_t socketInstance;
protocol_interface_info_entry_t *cur;
(void)serverDUID;
//allocate Socket Service
socketInstance = dhcp_service_init(interface, DHCP_INSTANCE_SERVER, DHCPV6_server_service_request_handler);
cur = protocol_stack_interface_info_get_by_id(interface);
if (!cur) {
return -1;
}
if (dhcpv6_server_service_tasklet_generated() < 0) {
retVal = -2;
} else if (!DHCP_server_service_timer_start()) {
retVal = -2;
} else {
//allocate server
dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_gua_server_allocate(guaPrefix, interface, cur->mac, serverDUIDType);
if (serverInfo) {
serverInfo->socketInstance_id = socketInstance;
socketInstance = 0;
retVal = 0;
}
}
if (socketInstance > 0) {
dhcp_service_delete(socketInstance);
DHCP_server_service_timer_stop();
}
return retVal;
}
void DHCPv6_server_service_timeout_cb(uint32_t timeUpdateInSeconds)
{
libdhcpv6_gua_servers_time_update(timeUpdateInSeconds);
}
/* Delete dhcp thread dhcp router ID server.
*
* When this is called it close selected service and free all allocated memory.
*
* /param interface interface id of this thread instance.
* /param guaPrefix Prefix which will be removed
* /param delete_gua_addresses Whether or not assigned addresses with the prefix should be removed from the interface.
*/
void DHCPv6_server_service_delete(int8_t interface, uint8_t guaPrefix[static 8], bool delete_gua_addresses)
{
dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
if (serverInfo) {
ns_list_foreach_safe(dhcpv6_allocated_address_entry_t, cur, &serverInfo->allocatedAddressList) {
//Delete Server data base
if (serverInfo->removeCb) {
uint8_t ipAddress[16];
libdhcpv6_allocated_address_write(ipAddress, cur, serverInfo);
serverInfo->removeCb(interface, ipAddress, NULL);
}
}
if (serverInfo->removeCb) {
// Clean all /128 'Thread Proxy' routes to self and others added when acting as a DHCP server
serverInfo->removeCb(interface, NULL, serverInfo->guaPrefix);
}
dhcp_service_delete(serverInfo->socketInstance_id);
}
if (delete_gua_addresses) {
protocol_interface_info_entry_t *curPtr = protocol_stack_interface_info_get_by_id(interface);
if (curPtr) {
protocol_core_dhcpv6_allocated_address_remove(curPtr, guaPrefix);
}
}
libdhcpv6_gua_server_free_by_prefix_and_interfaceid(guaPrefix, interface);
DHCP_server_service_timer_stop();
}
/* Control GUA address for client by DUI.Default value is true
*
* Anonymous and disable address list can optimize either
* Using 16 bit suffix to optimize data amount in network
* and having list of assigned addresses meaning larger RAM usage at border router
*
* or Using SLAAC type address generation and not have a list of addresses at Border router
* -> Less RAM usage, but more bandwidth used
*
* /param interface interface id of this thread instance.
* /param guaPrefix Prefix which will be removed
* /param mode true assign addresses anonymously. false define address by Prefix + client id
* /param disable_address_list Dont keep track of assigned Addresses (Can't be used if anonymous)
*/
int DHCPv6_server_service_set_address_generation_anonymous(int8_t interface, uint8_t guaPrefix[static 16], bool mode, bool disable_address_list)
{
dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
if (!serverInfo) {
return -1;
}
serverInfo->anonymousAddress = mode;
if (mode) {
serverInfo->disableAddressList = disable_address_list;
} else {
serverInfo->disableAddressList = false;
}
tr_info("DHCPv6 %s, address list %s", mode ? "anonymous address" : "address mode SLAAC", disable_address_list ? "Not Stored" : "Stored");
return 0;
}
void DHCPv6_server_service_callback_set(int8_t interface, uint8_t guaPrefix[static 16], dhcp_address_prefer_remove_cb *remove_cb, dhcp_address_add_notify_cb *add_cb)
{
dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
if (!serverInfo) {
return;
}
serverInfo->addCb = add_cb;
serverInfo->removeCb = remove_cb;
}
int DHCPv6_server_service_duid_update(int8_t interface, uint8_t guaPrefix[static 16], uint8_t *duid_ptr, uint16_t duid_type, uint8_t duid_length)
{
//Validate length and type
if (!libdhcpv6_duid_length_validate(duid_type, duid_length)) {
return -1;
}
dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
if (!serverInfo) {
return -1;
}
tr_info("DHCPv6 duid %s", trace_array(duid_ptr, duid_length));
return libdhcpv6_server_duid_set(serverInfo, duid_ptr, duid_type, duid_length);
}
/* SET max accepted clients to server, Default is 200
*
*
* /param interface interface id of this thread instance.
* /param guaPrefix Prefix which will be removed
* /param maxClientCount
*/
int DHCPv6_server_service_set_max_clients_accepts_count(int8_t interface, uint8_t guaPrefix[static 16], uint32_t maxClientCount)
{
dhcpv6_gua_server_entry_s *serverInfo;
if (maxClientCount == 0 || maxClientCount > MAX_SUPPORTED_ADDRESS_LIST_SIZE) {
return -2;
}
serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
if (!serverInfo) {
return -1;
}
serverInfo->maxSupportedClients = maxClientCount;
tr_info("DHCPv6 maximum clients %"PRIu32, serverInfo->maxSupportedClients);
return 0;
}
/** SET Address Valid Lifetime parameter for allocated address, Default is 7200 seconds
*
*
* /param interface interface id of this thread instance.
* /param guaPrefix Prefix which will be removed
* /param validLifeTimne in seconds
*/
int DHCPv6_server_service_set_address_validlifetime(int8_t interface, uint8_t guaPrefix[static 16], uint32_t validLifeTimne)
{
dhcpv6_gua_server_entry_s *serverInfo;
if (validLifeTimne < 120) {
return -2;
}
serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
if (!serverInfo) {
return -1;
}
serverInfo->validLifetime = validLifeTimne;
tr_info("DHCPv6 Valid lifetime %"PRIu32, serverInfo->validLifetime);
return 0;
}
int DHCPv6_server_service_set_dns_server(int8_t interface, uint8_t guaPrefix[static 16], uint8_t dns_server_address[static 16], uint8_t *dns_search_list_ptr, uint8_t dns_search_list_len)
{
dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
if (!serverInfo) {
return -1;
}
dhcpv6_dns_server_data_t *dns_entry = libdhcpv6_dns_server_allocate(serverInfo, dns_server_address);
if (!dns_entry) {
return -1;
}
if (dns_entry->search_list_length != dns_search_list_len) {
ns_dyn_mem_free(dns_entry->search_list);
dns_entry->search_list = NULL;
dns_entry->search_list_length = 0;
if (dns_search_list_len) {
dns_entry->search_list = ns_dyn_mem_alloc(dns_search_list_len);
if (dns_entry->search_list) {
dns_entry->search_list_length = dns_search_list_len;
}
}
}
if (dns_entry->search_list_length) {
//Copy Search List to allocated buffer
memcpy(dns_entry->search_list, dns_search_list_ptr, dns_entry->search_list_length);
}
return 0;
}
int DHCPv6_server_service_set_vendor_data(int8_t interface, uint8_t guaPrefix[static 16], uint32_t enterprise_number, uint8_t *dhcp_vendor_data_ptr, uint16_t dhcp_vendor_data_len)
{
dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
if (!serverInfo) {
return -1;
}
dhcpv6_vendor_data_t *vendor_data_entry = libdhcpv6_vendor_data_allocate(serverInfo, enterprise_number);
if (!vendor_data_entry) {
return -1;
}
if (vendor_data_entry->vendor_data_length != dhcp_vendor_data_len) {
ns_dyn_mem_free(vendor_data_entry->vendor_data);
vendor_data_entry->vendor_data = NULL;
vendor_data_entry->vendor_data_length = 0;
if (dhcp_vendor_data_len) {
vendor_data_entry->vendor_data = ns_dyn_mem_alloc(dhcp_vendor_data_len);
if (vendor_data_entry->vendor_data) {
vendor_data_entry->vendor_data_length = dhcp_vendor_data_len;
}
}
}
if (vendor_data_entry->vendor_data_length) {
//Copy Venfor Data to allocated buffer
memcpy(vendor_data_entry->vendor_data, dhcp_vendor_data_ptr, vendor_data_entry->vendor_data_length);
}
return 0;
}
int DHCPv6_server_service_set_vendor_data_callback(int8_t interface, uint8_t guaPrefix[static 16], uint32_t enterprise_number, dhcp_vendor_data_cb *vendor_data_cb)
{
dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
if (!serverInfo) {
return -1;
}
dhcpv6_vendor_data_t *vendor_data_entry = libdhcpv6_vendor_data_allocate(serverInfo, enterprise_number);
if (!vendor_data_entry) {
return -1;
}
vendor_data_entry->vendor_data_cb = vendor_data_cb;
return 0;
}
#else
int DHCPv6_server_service_init(int8_t interface, uint8_t guaPrefix[static 16], uint8_t serverDUID[static 8], uint16_t serverDUIDType)
{
(void) interface;
(void) guaPrefix;
(void) serverDUID;
(void) serverDUIDType;
return -1;
}
void DHCPv6_server_service_delete(int8_t interface, uint8_t guaPrefix[static 8], bool delete_gua_addresses)
{
(void) interface;
(void) guaPrefix;
(void) delete_gua_addresses;
}
void DHCPv6_server_service_timeout_cb(uint32_t timeUpdateInSeconds)
{
(void) timeUpdateInSeconds;
}
int DHCPv6_server_service_set_address_generation_anonymous(int8_t interface, uint8_t guaPrefix[static 16], bool mode, bool autonomous_skip_list)
{
(void) interface;
(void) guaPrefix;
(void) mode;
(void) autonomous_skip_list;
return -1;
}
int DHCPv6_server_service_set_max_clients_accepts_count(int8_t interface, uint8_t guaPrefix[static 16], uint32_t maxClientCount)
{
(void) interface;
(void) guaPrefix;
(void) maxClientCount;
return -1;
}
int DHCPv6_server_service_set_address_validlifetime(int8_t interface, uint8_t guaPrefix[static 16], uint32_t validLifeTimne)
{
(void) interface;
(void) guaPrefix;
(void) validLifeTimne;
return -1;
}
#endif
Reference in New Issue View Git Blame Copy Permalink