DHCPv6_Server_service.c

00001 /*
00002  * Copyright (c) 2014-2018, Arm Limited and affiliates.
00003  * SPDX-License-Identifier: Apache-2.0
00004  *
00005  * Licensed under the Apache License, Version 2.0 (the "License");
00006  * you may not use this file except in compliance with the License.
00007  * You may obtain a copy of the License at
00008  *
00009  *     http://www.apache.org/licenses/LICENSE-2.0
00010  *
00011  * Unless required by applicable law or agreed to in writing, software
00012  * distributed under the License is distributed on an "AS IS" BASIS,
00013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014  * See the License for the specific language governing permissions and
00015  * limitations under the License.
00016  */
00017 
00018 /*
00019  * \file DHCPv6_Server_service.c
00020  * \brief Add short description about this file!!!
00021  *
00022  */
00023 #include "nsconfig.h"
00024 #ifdef HAVE_DHCPV6_SERVER
00025 #include <string.h>
00026 #include <ns_types.h>
00027 #include <ns_trace.h>
00028 #include "eventOS_event.h"
00029 #include "eventOS_scheduler.h"
00030 #include "eventOS_event_timer.h"
00031 #include <nsdynmemLIB.h>
00032 #include "libDHCPv6/libDHCPv6.h"
00033 #include "libDHCPv6/libDHCPv6_server.h"
00034 #include "DHCPv6_Server/DHCPv6_server_service.h"
00035 #include "common_functions.h"
00036 #include "NWK_INTERFACE/Include/protocol.h"
00037 #include "6LoWPAN/Thread/thread_bbr_api_internal.h"
00038 #include "Common_Protocols/icmpv6.h"
00039 #include "dhcp_service_api.h"
00040 
00041 #define TRACE_GROUP "dhcp"
00042 
00043 #define DHCPV6_GUA_IF "dhcp"
00044 #define DHCPV6_SERVER_SERVICE_TASKLET_INIT      1
00045 #define DHCPV6_SERVER_SERVICE_TIMER             2
00046 
00047 #define DHCPV6_SERVER_SERVICE_TIMER_ID          1
00048 
00049 #define DHCPV6_TIMER_UPDATE_PERIOD_IN_SECONDS   10
00050 
00051 typedef struct dhcpv6_gua_response {
00052     uint16_t    responseLength;
00053     uint8_t     *responsePtr;
00054 } dhcpv6_gua_response_t;
00055 
00056 static int8_t dhcpv6_service_tasklet = -1;
00057 
00058 static arm_event_storage_t *dhcp_timer_storage = NULL;
00059 
00060 static void DHCPV6_server_service_remove_GUA_from_neighcache(protocol_interface_info_entry_t *cur, uint8_t *targetAddress);
00061 
00062 
00063 static bool DHCP_server_service_timer_start(void)
00064 {
00065     if(!dhcp_timer_storage) {
00066         arm_event_s event = {
00067                 .receiver = dhcpv6_service_tasklet,
00068                 .sender = 0,
00069                 .event_id = DHCPV6_SERVER_SERVICE_TIMER_ID,
00070                 .data_ptr = NULL,
00071                 .event_type = DHCPV6_SERVER_SERVICE_TIMER,
00072                 .priority = ARM_LIB_LOW_PRIORITY_EVENT,
00073         };
00074 
00075         dhcp_timer_storage  = eventOS_event_timer_request_every(&event, eventOS_event_timer_ms_to_ticks(DHCPV6_TIMER_UPDATE_PERIOD_IN_SECONDS * 1000));
00076         if (!dhcp_timer_storage) {
00077             tr_error("Dhcp server timer start fail");
00078             return false;
00079         }
00080     }
00081     return true;
00082 }
00083 
00084 static void DHCP_server_service_timer_stop(void)
00085 {
00086     if (dhcp_timer_storage && libdhcpv6_gua_server_list_empty() ) {
00087         eventOS_cancel(dhcp_timer_storage);
00088         dhcp_timer_storage = NULL;
00089     }
00090 }
00091 
00092 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)
00093 {
00094     dhcpv6_alloacted_address_entry_t *dhcp_allocated_address;
00095     dhcpv6_ia_non_temporal_address_s nonTemporalAddress;
00096     bool address_allocated = false;
00097     dhcp_allocated_address = libdhcpv6_address_allocated_list_scan(serverBase, replyPacket->clientDUID.linkID, replyPacket->clientDUID.linkType, dhcp_ia_non_temporal_params->iaId, dhcp_ia_non_temporal_params->T0, dhcp_ia_non_temporal_params->T1, allocateNew);
00098     if (dhcp_allocated_address) {
00099         address_allocated = true;
00100         nonTemporalAddress.requestedAddress = dhcp_allocated_address->nonTemporalAddress;
00101         nonTemporalAddress.validLifeTime = dhcp_allocated_address->lifetime;
00102         nonTemporalAddress.preferredLifeTime = dhcp_allocated_address->preferredLifetime;
00103 
00104         // If this is solicit from existing address, flush ND cache.
00105         if (allocateNew) {
00106             // coverity[returned_null] for ignoring protocol_stack_interface_info_get_by_id NULL return
00107             DHCPV6_server_service_remove_GUA_from_neighcache(protocol_stack_interface_info_get_by_id(serverBase->interfaceId), nonTemporalAddress.requestedAddress);
00108         }
00109         if (thread_bbr_nd_entry_add(serverBase->interfaceId,dhcp_allocated_address->nonTemporalAddress, nonTemporalAddress.validLifeTime, serverBase->guaPrefix) == -1) {
00110             // No nanostack BBR present we will put entry for application implemented BBR
00111             ipv6_route_t *route = ipv6_route_add_with_info(dhcp_allocated_address->nonTemporalAddress, 128, serverBase->interfaceId, NULL, ROUTE_THREAD_PROXIED_HOST,serverBase->guaPrefix,0, nonTemporalAddress.validLifeTime, 0);
00112             if (!route) {
00113                 address_allocated = false;
00114                 libdhcpv6_address_rm_from_allocated_list(serverBase,dhcp_allocated_address->nonTemporalAddress);
00115             }
00116 
00117         }
00118     }
00119 
00120     response->responseLength = libdhcpv6_address_reply_message_len(replyPacket->clientDUID.linkType, replyPacket->serverDUID.linkType, 0, replyPacket->rapidCommit, address_allocated);
00121     response->responsePtr = ns_dyn_mem_temporary_alloc(response->responseLength);
00122     if (response->responsePtr) {
00123         if (address_allocated) {
00124             libdhcpv6_reply_message_write(response->responsePtr, replyPacket, &nonTemporalAddress, NULL);
00125         } else {
00126             libdhcpv6_reply_message_write(response->responsePtr, replyPacket, NULL, NULL);
00127         }
00128         return 0;
00129     }
00130     return -1;
00131 }
00132 
00133 
00134 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)
00135 {
00136     int retVal = RET_MSG_NOT_MINE;
00137     dhcp_ia_non_temporal_params_t dhcp_ia_non_temporal_params;
00138     dhcpv6_reply_packet_s replyPacket;
00139     dhcpv6_gua_response_t responseBuf;
00140     dhcpv6_gua_server_entry_s *serverBase;
00141 
00142     tr_debug("GUA Handler");
00143     switch (message_type) {
00144         case DHCPV6_SOLICATION_TYPE:
00145             if (libdhcpv6_solication_message_options_validate(msg_ptr, msg_len, &replyPacket.clientDUID, &dhcp_ia_non_temporal_params) == 0) {
00146                 //Start Build Response
00147                 serverBase = libdhcpv6_server_data_get_by_prefix_and_socketinstance(instance_id, dhcp_ia_non_temporal_params.nonTemporalAddress);
00148                 if (serverBase) {
00149                     //Here Allocate address
00150                     replyPacket.rapidCommit = libdhcpv6_rapid_commit_option_at_packet(msg_ptr, msg_len);
00151                     replyPacket.serverDUID.linkID = serverBase->serverDUID;
00152                     replyPacket.serverDUID.linkType = serverBase->serverLinkType;
00153                     replyPacket.T0 = dhcp_ia_non_temporal_params.T0;
00154                     replyPacket.T1 = dhcp_ia_non_temporal_params.T1;
00155                     replyPacket.iaId = dhcp_ia_non_temporal_params.iaId;
00156                     replyPacket.transaction_ID = msg_tr_id;
00157                     //Check First Current list
00158                     if (DHCPv6_server_respond_client(serverBase, &replyPacket, &dhcp_ia_non_temporal_params, &responseBuf, true) == 0) {
00159                         //Respond
00160                         dhcp_service_send_resp(msg_tr_id, TX_OPT_NONE, responseBuf.responsePtr, responseBuf.responseLength);
00161                         ns_dyn_mem_free(responseBuf.responsePtr);
00162                         retVal = RET_MSG_ACCEPTED;
00163                     }
00164 
00165                 }
00166             }
00167             break;
00168 
00169         case DHCPV6_RELEASE_TYPE:
00170 
00171             break;
00172 
00173         case DHCPV6_RENEW_TYPE:
00174             if (libdhcpv6_renew_message_options_validate(msg_ptr, msg_len, &replyPacket.clientDUID, &replyPacket.serverDUID, &dhcp_ia_non_temporal_params) == 0) {
00175                 // Discover SERVER
00176                 serverBase = libdhcpv6_server_data_get_by_prefix_and_socketinstance(instance_id, dhcp_ia_non_temporal_params.nonTemporalAddress);
00177                 if (serverBase) {
00178                     dhcp_link_options_params_t serverInfoDui;
00179                     serverInfoDui.linkID = serverBase->serverDUID;
00180                     serverInfoDui.linkType = serverBase->serverLinkType;
00181                     if (libdhcpv6_compare_DUID(&serverInfoDui, &replyPacket.serverDUID) == 0) {
00182                         replyPacket.rapidCommit = libdhcpv6_rapid_commit_option_at_packet(msg_ptr, msg_len);
00183                         replyPacket.T0 = dhcp_ia_non_temporal_params.T0;
00184                         replyPacket.T1 = dhcp_ia_non_temporal_params.T1;
00185                         replyPacket.iaId = dhcp_ia_non_temporal_params.iaId;
00186                         replyPacket.transaction_ID = msg_tr_id;
00187                         //Check First Current list
00188                         if (DHCPv6_server_respond_client(serverBase, &replyPacket, &dhcp_ia_non_temporal_params, &responseBuf, false) == 0) {
00189                             //Respond
00190                             dhcp_service_send_resp(msg_tr_id, TX_OPT_NONE, responseBuf.responsePtr, responseBuf.responseLength);
00191                             ns_dyn_mem_free(responseBuf.responsePtr);
00192                             retVal = RET_MSG_ACCEPTED;
00193                         }
00194                     }
00195 
00196                 }
00197             }
00198             break;
00199 
00200         default:
00201             tr_warn("UnSupported MessageId: %02x", message_type);
00202     }
00203     return retVal;
00204 }
00205 
00206 
00207 void DHCPv6_server_service_tasklet(arm_event_s *event)
00208 {
00209     if (event->event_type == DHCPV6_SERVER_SERVICE_TASKLET_INIT) {
00210         //We should define peridiocally timer service!!
00211     } else if (event->event_type == DHCPV6_SERVER_SERVICE_TIMER) {
00212         libdhcpv6_gua_servers_time_update(DHCPV6_TIMER_UPDATE_PERIOD_IN_SECONDS);
00213     }
00214 }
00215 
00216 static void DHCPV6_server_service_remove_GUA_from_neighcache(protocol_interface_info_entry_t *cur, uint8_t *targetAddress)
00217 {
00218     ipv6_neighbour_t *neighbour_entry;
00219 
00220     neighbour_entry = ipv6_neighbour_lookup(&cur->ipv6_neighbour_cache, targetAddress);
00221     if (neighbour_entry) {
00222         tr_debug("Remove from neigh Cache: %s", tr_ipv6(targetAddress));
00223         ipv6_neighbour_entry_remove(&cur->ipv6_neighbour_cache, neighbour_entry);
00224     }
00225 }
00226 
00227 void DHCPv6_server_service_address_preferred_timeout_handler(int8_t interfaceId, uint8_t *targetAddress)
00228 {
00229     tr_warn("Address Preferred Timeout");
00230     protocol_interface_info_entry_t *cur = 0;
00231     //allocate Socket Service
00232 
00233     cur = protocol_stack_interface_info_get_by_id(interfaceId);
00234     if (cur) {
00235         ipv6_route_delete(targetAddress, 128, interfaceId, NULL, ROUTE_THREAD_PROXIED_HOST);
00236         DHCPV6_server_service_remove_GUA_from_neighcache(cur, targetAddress);
00237     }
00238 }
00239 
00240 static int8_t dhcpv6_server_service_tasklet_generated(void)
00241 {
00242     if (dhcpv6_service_tasklet == -1) {
00243         dhcpv6_service_tasklet = eventOS_event_handler_create(DHCPv6_server_service_tasklet, DHCPV6_SERVER_SERVICE_TASKLET_INIT);
00244     }
00245 
00246     return dhcpv6_service_tasklet;
00247 }
00248 
00249 /* Initialize dhcp Global address server.
00250  *
00251  * This instance needs to bee initialized once for each thread network interface.
00252  * if only one thread instance is supported this is needed to call only once.
00253  *
00254  * /param interface interface id of this thread instance.
00255  * /param guaPrefix Global prefix /64
00256  * /param serverDUID Server Device ID (64-bit MAC)
00257  * /param serverDUIDType
00258  *
00259  */
00260 int DHCPv6_server_service_init(int8_t interface, uint8_t guaPrefix[static 16], uint8_t serverDUID[static 8], uint16_t serverDUIDType)
00261 {
00262     int retVal = -1;
00263     uint16_t socketInstance;
00264     protocol_interface_info_entry_t *cur;
00265     (void)serverDUID;
00266     (void)serverDUIDType;
00267     //allocate Socket Service
00268     socketInstance  = dhcp_service_init(interface, DHCP_INSTANCE_SERVER, DHCPV6_server_service_request_handler);
00269     cur = protocol_stack_interface_info_get_by_id(interface);
00270     if (cur) {
00271         if (dhcpv6_server_service_tasklet_generated() < 0) {
00272             retVal = -2;
00273         } else if (!DHCP_server_service_timer_start()) {
00274             retVal = -2;
00275         } else {
00276             //allocate server
00277             dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_gua_server_allocate(guaPrefix, interface, cur->mac, DHCPV6_DUID_HARDWARE_EUI64_TYPE, DHCPv6_server_service_address_preferred_timeout_handler);
00278             if (serverInfo) {
00279                 //if_address_entry_t *def_address = NULL;
00280                 uint8_t temp[16];
00281                 uint8_t *ptr = temp;
00282                 //define address & Route advert's
00283                 memcpy(ptr, guaPrefix, 8);
00284                 ptr += 8;
00285                 memcpy(ptr, cur->iid_slaac, 8);
00286 
00287                 serverInfo->socketInstance_id = socketInstance;
00288                 socketInstance = 0;
00289                 //Generate Address for current interface
00290                 retVal = 0;
00291             }
00292         }
00293     }
00294     if (socketInstance > 0) {
00295         dhcp_service_delete(socketInstance);
00296         DHCP_server_service_timer_stop();
00297     }
00298     return retVal;
00299 }
00300 
00301 void DHCPv6_server_service_timeout_cb(uint32_t timeUpdateInSeconds)
00302 {
00303     libdhcpv6_gua_servers_time_update(timeUpdateInSeconds);
00304 }
00305 
00306 void DHCPv6_GUA64_ML64_route_control(int8_t interfaceId, uint8_t *allocatedGuaAddress, uint8_t *clientEUID64, uint8_t *meshLocalPrefix, bool deleteMapping)
00307 {
00308     uint8_t ml64[16];
00309     uint8_t *ptr = ml64;
00310     memcpy(ptr, meshLocalPrefix, 8);
00311     ptr += 8;
00312     memcpy(ptr, clientEUID64, 8);
00313     *ptr ^= 2;
00314     //Generate Route Info
00315     if (deleteMapping) {
00316         ipv6_route_delete(allocatedGuaAddress, 128, interfaceId, ml64, ROUTE_STATIC);
00317     } else if (ipv6_route_add(allocatedGuaAddress, 128, interfaceId, ml64, ROUTE_STATIC, 0xffffffff, 0) == 0) {
00318         tr_debug("Route ADD OK");
00319     } else {
00320         tr_warn("Route Add fail");
00321     }
00322 
00323 }
00324 
00325 /* Delete dhcp thread dhcp router ID server.
00326  *
00327  * When this is called it close selected service and free all allocated memory.
00328  *
00329  *  /param interface interface id of this thread instance.
00330  *  /param guaPrefix Prefix which will be removed
00331  *  /param delete_gua_addresses Whether or not assigned addresses with the prefix should be removed from the interface.
00332  */
00333 void DHCPv6_server_service_delete(int8_t interface, uint8_t guaPrefix[static 16], bool delete_gua_addresses)
00334 {
00335     protocol_interface_info_entry_t *curPtr = 0;
00336     //allocate Socket Service
00337 
00338     curPtr = protocol_stack_interface_info_get_by_id(interface);
00339     if (curPtr) {
00340         dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
00341         if (serverInfo) {
00342             ns_list_foreach_safe(dhcpv6_alloacted_address_entry_t, cur, &serverInfo->allocatedAddressList) {
00343                 //Delete Server data base
00344                 DHCPV6_server_service_remove_GUA_from_neighcache(curPtr, cur->nonTemporalAddress);
00345             }
00346             // Clean all /128 'Thread Proxy' routes to self and others added when acting as a DHCP server
00347             ipv6_route_table_remove_info(curPtr->id, ROUTE_THREAD_PROXIED_HOST,serverInfo->guaPrefix);
00348             dhcp_service_delete(serverInfo->socketInstance_id);
00349         }
00350 
00351         if (delete_gua_addresses) {
00352             protocol_core_dhcpv6_allocated_address_remove(curPtr, guaPrefix);
00353         }
00354 
00355         libdhcpv6_gua_server_free_by_prefix_and_interfaceid(guaPrefix, interface);
00356 
00357         DHCP_server_service_timer_stop();
00358     }
00359 }
00360 
00361 /* Control GUA address for client by DUI.Default value is true
00362  *
00363  *
00364  *  /param interface interface id of this thread instance.
00365  *  /param guaPrefix Prefix which will be removed
00366  *  /param mode true trig autonous mode, false define address by default suffics + client id
00367  */
00368 int DHCPv6_server_service_set_address_autonous_flag(int8_t interface, uint8_t guaPrefix[static 16], bool mode)
00369 {
00370     int retVal = -1;
00371     dhcpv6_gua_server_entry_s *serverInfo;
00372 
00373     serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
00374     if (serverInfo) {
00375         serverInfo->enableAddressAutonous = mode;
00376         retVal = 0;
00377     }
00378 
00379     return retVal;
00380 }
00381 
00382 /* Enable or disable GUA64 Address mapping to ML64
00383  *
00384  *
00385  *  /param interface interface id of this thread instance.
00386  *  /param guaPrefix Prefix which will be removed
00387  *  /param mode
00388  *  /param meshLocalPrefix mesh local prefix for generate ML6 from client EUID64
00389  */
00390 int DHCPv6_server_service_set_gua_address_mapping(int8_t interface, uint8_t guaPrefix[static 16], bool mode, uint8_t meshLocalPrefix[8])
00391 {
00392     int retVal = -1;
00393     dhcpv6_gua_server_entry_s *serverInfo;
00394 
00395     serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
00396     if (serverInfo) {
00397         if (mode == true && meshLocalPrefix == NULL) {
00398             retVal = -2;
00399         } else {
00400             serverInfo->enableAddressMapping = mode;
00401             if (meshLocalPrefix) {
00402                 memcpy(serverInfo->meshLocalPrefix, meshLocalPrefix, 8);
00403             }
00404             retVal = 0;
00405         }
00406     }
00407 
00408     return retVal;
00409 }
00410 
00411 /* SET max accepted clients to server, Default is 200
00412  *
00413  *
00414  *  /param interface interface id of this thread instance.
00415  *  /param guaPrefix Prefix which will be removed
00416  *  /param maxClientCount
00417  */
00418 int DHCPv6_server_service_set_max_clients_accepts_count(int8_t interface, uint8_t guaPrefix[static 16], uint32_t maxClientCount)
00419 {
00420     int retVal = -1;
00421     dhcpv6_gua_server_entry_s *serverInfo;
00422     if (maxClientCount == 0) {
00423         return -2;
00424     } else {
00425         serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
00426         if (serverInfo) {
00427             serverInfo->maxSuppertedClients = maxClientCount;
00428             retVal = 0;
00429         }
00430     }
00431     return retVal;
00432 }
00433 
00434 /** SET Address Valid Lifetime parameter for allocated address, Default is 7200 seconds
00435  *
00436  *
00437  *  /param interface interface id of this thread instance.
00438  *  /param guaPrefix Prefix which will be removed
00439  *  /param validLifeTimne in seconds
00440  */
00441 int DHCPv6_server_service_set_address_validlifetime(int8_t interface, uint8_t guaPrefix[static 16], uint32_t validLifeTimne)
00442 {
00443     int retVal = -1;
00444     dhcpv6_gua_server_entry_s *serverInfo;
00445     if (validLifeTimne < 120) {
00446         retVal = -2;
00447     } else {
00448         serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
00449         if (serverInfo) {
00450             serverInfo->validLifetime = validLifeTimne;
00451             retVal = 0;
00452         }
00453     }
00454     return retVal;
00455 }
00456 
00457 int DHCPv6_server_service_gua_target_mac_check(int8_t interfaceId, const uint8_t *targetGUA, uint8_t *targetEUI64)
00458 {
00459     dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interfaceId, targetGUA);
00460     if (serverInfo) {
00461         dhcpv6_alloacted_address_entry_t *entry = libdhcpv6_address_get_from_allocated_list(serverInfo, targetGUA);
00462         if (entry) {
00463             if (entry->preferredLifetime && (entry->linkType == DHCPV6_DUID_HARDWARE_EUI64_TYPE)) {
00464                 memcpy(targetEUI64, entry->linkId, 8);
00465                 return 0;
00466             }
00467         }
00468     }
00469     return -1;
00470 }
00471 #else
00472 
00473 int DHCPv6_server_service_init(int8_t interface, uint8_t guaPrefix[static 16], uint8_t serverDUID[static 8], uint16_t serverDUIDType)
00474 {
00475     (void) interface;
00476     (void) guaPrefix;
00477     (void) serverDUID;
00478     (void) serverDUIDType;
00479 
00480     return -1;
00481 }
00482 void DHCPv6_server_service_delete(int8_t interface, uint8_t guaPrefix[static 16], bool delete_gua_addresses)
00483 {
00484     (void) interface;
00485     (void) guaPrefix;
00486     (void) delete_gua_addresses;
00487 }
00488 void DHCPv6_server_service_timeout_cb(uint32_t timeUpdateInSeconds)
00489 {
00490     (void) timeUpdateInSeconds;
00491 }
00492 int DHCPv6_server_service_set_address_autonous_flag(int8_t interface, uint8_t guaPrefix[static 16], bool mode)
00493 {
00494     (void) interface;
00495     (void) guaPrefix;
00496     (void) mode;
00497 
00498     return -1;
00499 }
00500 int DHCPv6_server_service_set_gua_address_mapping(int8_t interface, uint8_t guaPrefix[static 16], bool mode, uint8_t meshLocalPrefix[8])
00501 {
00502     (void) interface;
00503     (void) guaPrefix;
00504     (void) mode;
00505     (void) meshLocalPrefix;
00506 
00507     return -1;
00508 }
00509 int DHCPv6_server_service_set_max_clients_accepts_count(int8_t interface, uint8_t guaPrefix[static 16], uint32_t maxClientCount)
00510 {
00511     (void) interface;
00512     (void) guaPrefix;
00513     (void) maxClientCount;
00514 
00515     return -1;
00516 }
00517 int DHCPv6_server_service_set_address_validlifetime(int8_t interface, uint8_t guaPrefix[static 16], uint32_t validLifeTimne)
00518 {
00519     (void) interface;
00520     (void) guaPrefix;
00521     (void) validLifeTimne;
00522 
00523     return -1;
00524 }
00525 int DHCPv6_server_service_gua_target_mac_check(int8_t interfaceId, const uint8_t *targetGUA, uint8_t *targetEUI64)
00526 {
00527     (void) interfaceId;
00528     (void) targetGUA;
00529     (void) targetEUI64;
00530 
00531     return -1;
00532 }
00533 
00534 #endif