DHCPv6_Server_service.c

00001 /*
00002  * Copyright (c) 2014-2017, 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, NULL) == -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 
00121     response->responseLength = libdhcpv6_address_reply_message_len(replyPacket->clientDUID.linkType, replyPacket->serverDUID.linkType, 0, replyPacket->rapidCommit, address_allocated);
00122     response->responsePtr = ns_dyn_mem_temporary_alloc(response->responseLength);
00123     if (response->responsePtr) {
00124         if (address_allocated) {
00125             libdhcpv6_reply_message_write(response->responsePtr, replyPacket, &nonTemporalAddress, NULL);
00126         } else {
00127             libdhcpv6_reply_message_write(response->responsePtr, replyPacket, NULL, NULL);
00128         }
00129         return 0;
00130     }
00131     return -1;
00132 }
00133 
00134 
00135 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)
00136 {
00137     int retVal = RET_MSG_NOT_MINE;
00138     dhcp_ia_non_temporal_params_t dhcp_ia_non_temporal_params;
00139     dhcpv6_reply_packet_s replyPacket;
00140     dhcpv6_gua_response_t responseBuf;
00141     dhcpv6_gua_server_entry_s *serverBase;
00142 
00143     tr_debug("GUA Handler");
00144     switch (message_type) {
00145         case DHCPV6_SOLICATION_TYPE:
00146             if (libdhcpv6_solication_message_options_validate(msg_ptr, msg_len, &replyPacket.clientDUID, &dhcp_ia_non_temporal_params) == 0) {
00147                 //Start Build Response
00148                 serverBase = libdhcpv6_server_data_get_by_prefix_and_socketinstance(instance_id, dhcp_ia_non_temporal_params.nonTemporalAddress);
00149                 if (serverBase) {
00150                     //Here Allocate address
00151                     replyPacket.rapidCommit = libdhcpv6_rapid_commit_option_at_packet(msg_ptr, msg_len);
00152                     replyPacket.serverDUID.linkID = serverBase->serverDUID;
00153                     replyPacket.serverDUID.linkType = serverBase->serverLinkType;
00154                     replyPacket.T0 = dhcp_ia_non_temporal_params.T0;
00155                     replyPacket.T1 = dhcp_ia_non_temporal_params.T1;
00156                     replyPacket.iaId = dhcp_ia_non_temporal_params.iaId;
00157                     replyPacket.transaction_ID = msg_tr_id;
00158                     //Check First Current list
00159                     if (DHCPv6_server_respond_client(serverBase, &replyPacket, &dhcp_ia_non_temporal_params, &responseBuf, true) == 0) {
00160                         //Respond
00161                         dhcp_service_send_resp(msg_tr_id, TX_OPT_NONE, responseBuf.responsePtr, responseBuf.responseLength);
00162                         ns_dyn_mem_free(responseBuf.responsePtr);
00163                         retVal = RET_MSG_ACCEPTED;
00164                     }
00165 
00166                 }
00167             }
00168             break;
00169 
00170         case DHCPV6_RELEASE_TYPE:
00171 
00172             break;
00173 
00174         case DHCPV6_RENEW_TYPE:
00175             if (libdhcpv6_renew_message_options_validate(msg_ptr, msg_len, &replyPacket.clientDUID, &replyPacket.serverDUID, &dhcp_ia_non_temporal_params) == 0) {
00176                 // Discover SERVER
00177                 serverBase = libdhcpv6_server_data_get_by_prefix_and_socketinstance(instance_id, dhcp_ia_non_temporal_params.nonTemporalAddress);
00178                 if (serverBase) {
00179                     dhcp_link_options_params_t serverInfoDui;
00180                     serverInfoDui.linkID = serverBase->serverDUID;
00181                     serverInfoDui.linkType = serverBase->serverLinkType;
00182                     if (libdhcpv6_compare_DUID(&serverInfoDui, &replyPacket.serverDUID) == 0) {
00183                         replyPacket.rapidCommit = libdhcpv6_rapid_commit_option_at_packet(msg_ptr, msg_len);
00184                         replyPacket.T0 = dhcp_ia_non_temporal_params.T0;
00185                         replyPacket.T1 = dhcp_ia_non_temporal_params.T1;
00186                         replyPacket.iaId = dhcp_ia_non_temporal_params.iaId;
00187                         replyPacket.transaction_ID = msg_tr_id;
00188                         //Check First Current list
00189                         if (DHCPv6_server_respond_client(serverBase, &replyPacket, &dhcp_ia_non_temporal_params, &responseBuf, false) == 0) {
00190                             //Respond
00191                             dhcp_service_send_resp(msg_tr_id, TX_OPT_NONE, responseBuf.responsePtr, responseBuf.responseLength);
00192                             ns_dyn_mem_free(responseBuf.responsePtr);
00193                             retVal = RET_MSG_ACCEPTED;
00194                         }
00195                     }
00196 
00197                 }
00198             }
00199             break;
00200 
00201         default:
00202             tr_warn("UnSupported MessageId: %02x", message_type);
00203     }
00204     return retVal;
00205 }
00206 
00207 
00208 void DHCPv6_server_service_tasklet(arm_event_s *event)
00209 {
00210     if (event->event_type == DHCPV6_SERVER_SERVICE_TASKLET_INIT) {
00211         //We should define peridiocally timer service!!
00212     } else if (event->event_type == DHCPV6_SERVER_SERVICE_TIMER) {
00213         libdhcpv6_gua_servers_time_update(DHCPV6_TIMER_UPDATE_PERIOD_IN_SECONDS);
00214     }
00215 }
00216 
00217 static void DHCPV6_server_service_remove_GUA_from_neighcache(protocol_interface_info_entry_t *cur, uint8_t *targetAddress)
00218 {
00219     ipv6_neighbour_t *neighbour_entry;
00220 
00221     neighbour_entry = ipv6_neighbour_lookup(&cur->ipv6_neighbour_cache, targetAddress);
00222     if (neighbour_entry) {
00223         tr_debug("Remove from neigh Cache: %s", tr_ipv6(targetAddress));
00224         ipv6_neighbour_entry_remove(&cur->ipv6_neighbour_cache, neighbour_entry);
00225     }
00226 }
00227 
00228 void DHCPv6_server_service_address_preferred_timeout_handler(int8_t interfaceId, uint8_t *targetAddress)
00229 {
00230     tr_warn("Address Preferred Timeout");
00231     protocol_interface_info_entry_t *cur = 0;
00232     //allocate Socket Service
00233 
00234     cur = protocol_stack_interface_info_get_by_id(interfaceId);
00235     if (cur) {
00236         ipv6_route_delete(targetAddress, 128, interfaceId, NULL, ROUTE_THREAD_PROXIED_HOST);
00237         DHCPV6_server_service_remove_GUA_from_neighcache(cur, targetAddress);
00238     }
00239 }
00240 
00241 static int8_t dhcpv6_server_service_tasklet_generated(void)
00242 {
00243     if (dhcpv6_service_tasklet == -1) {
00244         dhcpv6_service_tasklet = eventOS_event_handler_create(DHCPv6_server_service_tasklet, DHCPV6_SERVER_SERVICE_TASKLET_INIT);
00245     }
00246 
00247     return dhcpv6_service_tasklet;
00248 }
00249 
00250 /* Initialize dhcp Global address server.
00251  *
00252  * This instance needs to bee initialized once for each thread network interface.
00253  * if only one thread instance is supported this is needed to call only once.
00254  *
00255  * /param interface interface id of this thread instance.
00256  * /param guaPrefix Global prefix /64
00257  * /param serverDUID Server Device ID (64-bit MAC)
00258  * /param serverDUIDType
00259  *
00260  */
00261 int DHCPv6_server_service_init(int8_t interface, uint8_t guaPrefix[static 16], uint8_t serverDUID[static 8], uint16_t serverDUIDType)
00262 {
00263     int retVal = -1;
00264     uint16_t socketInstance;
00265     protocol_interface_info_entry_t *cur;
00266     (void)serverDUID;
00267     (void)serverDUIDType;
00268     //allocate Socket Service
00269     socketInstance  = dhcp_service_init(interface, DHCP_INSTANCE_SERVER, DHCPV6_server_service_request_handler);
00270     cur = protocol_stack_interface_info_get_by_id(interface);
00271     if (cur) {
00272         if (dhcpv6_server_service_tasklet_generated() < 0) {
00273             retVal = -2;
00274         } else if (!DHCP_server_service_timer_start()) {
00275             retVal = -2;
00276         } else {
00277             //allocate server
00278             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);
00279             if (serverInfo) {
00280                 //if_address_entry_t *def_address = NULL;
00281                 uint8_t temp[16];
00282                 uint8_t *ptr = temp;
00283                 //define address & Route advert's
00284                 memcpy(ptr, guaPrefix, 8);
00285                 ptr += 8;
00286                 memcpy(ptr, cur->iid_slaac, 8);
00287 
00288                 serverInfo->socketInstance_id = socketInstance;
00289                 socketInstance = 0;
00290                 //Generate Address for current interface
00291                 retVal = 0;
00292             }
00293         }
00294     }
00295     if (socketInstance > 0) {
00296         dhcp_service_delete(socketInstance);
00297         DHCP_server_service_timer_stop();
00298     }
00299     return retVal;
00300 }
00301 
00302 void DHCPv6_server_service_timeout_cb(uint32_t timeUpdateInSeconds)
00303 {
00304     libdhcpv6_gua_servers_time_update(timeUpdateInSeconds);
00305 }
00306 
00307 void DHCPv6_GUA64_ML64_route_control(int8_t interfaceId, uint8_t *allocatedGuaAddress, uint8_t *clientEUID64, uint8_t *meshLocalPrefix, bool deleteMapping)
00308 {
00309     uint8_t ml64[16];
00310     uint8_t *ptr = ml64;
00311     memcpy(ptr, meshLocalPrefix, 8);
00312     ptr += 8;
00313     memcpy(ptr, clientEUID64, 8);
00314     *ptr ^= 2;
00315     //Generate Route Info
00316     if (deleteMapping) {
00317         ipv6_route_delete(allocatedGuaAddress, 128, interfaceId, ml64, ROUTE_STATIC);
00318     } else if (ipv6_route_add(allocatedGuaAddress, 128, interfaceId, ml64, ROUTE_STATIC, 0xffffffff, 0) == 0) {
00319         tr_debug("Route ADD OK");
00320     } else {
00321         tr_warn("Route Add fail");
00322     }
00323 
00324 }
00325 
00326 /* Delete dhcp thread dhcp router ID server.
00327  *
00328  * When this is called it close selected service and free all allocated memory.
00329  *
00330  *  /param interface interface id of this thread instance.
00331  *  /param guaPrefix Prefix which will be removed
00332  *  /param delete_gua_addresses Whether or not assigned addresses with the prefix should be removed from the interface.
00333  */
00334 void DHCPv6_server_service_delete(int8_t interface, uint8_t guaPrefix[static 16], bool delete_gua_addresses)
00335 {
00336     protocol_interface_info_entry_t *curPtr = 0;
00337     //allocate Socket Service
00338 
00339     curPtr = protocol_stack_interface_info_get_by_id(interface);
00340     if (curPtr) {
00341         dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
00342         if (serverInfo) {
00343             ns_list_foreach_safe(dhcpv6_alloacted_address_entry_t, cur, &serverInfo->allocatedAddressList) {
00344                 //Delete Server data base
00345                 DHCPV6_server_service_remove_GUA_from_neighcache(curPtr, cur->nonTemporalAddress);
00346             }
00347             // Clean all /128 'Thread Proxy' routes to self and others added when acting as a DHCP server
00348             ipv6_route_table_remove_info(curPtr->id, ROUTE_THREAD_PROXIED_HOST,serverInfo->guaPrefix);
00349             dhcp_service_delete(serverInfo->socketInstance_id);
00350         }
00351 
00352         if (delete_gua_addresses) {
00353             protocol_core_dhcpv6_allocated_address_remove(curPtr, guaPrefix);
00354         }
00355 
00356         libdhcpv6_gua_server_free_by_prefix_and_interfaceid(guaPrefix, interface);
00357 
00358         DHCP_server_service_timer_stop();
00359     }
00360 }
00361 
00362 /* Control GUA address for client by DUI.Default value is true
00363  *
00364  *
00365  *  /param interface interface id of this thread instance.
00366  *  /param guaPrefix Prefix which will be removed
00367  *  /param mode true trig autonous mode, false define address by default suffics + client id
00368  */
00369 int DHCPv6_server_service_set_address_autonous_flag(int8_t interface, uint8_t guaPrefix[static 16], bool mode)
00370 {
00371     int retVal = -1;
00372     dhcpv6_gua_server_entry_s *serverInfo;
00373 
00374     serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
00375     if (serverInfo) {
00376         serverInfo->enableAddressAutonous = mode;
00377         retVal = 0;
00378     }
00379 
00380     return retVal;
00381 }
00382 
00383 /* Enable or disable GUA64 Address mapping to ML64
00384  *
00385  *
00386  *  /param interface interface id of this thread instance.
00387  *  /param guaPrefix Prefix which will be removed
00388  *  /param mode
00389  *  /param meshLocalPrefix mesh local prefix for generate ML6 from client EUID64
00390  */
00391 int DHCPv6_server_service_set_gua_address_mapping(int8_t interface, uint8_t guaPrefix[static 16], bool mode, uint8_t meshLocalPrefix[8])
00392 {
00393     int retVal = -1;
00394     dhcpv6_gua_server_entry_s *serverInfo;
00395 
00396     serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
00397     if (serverInfo) {
00398         if (mode == true && meshLocalPrefix == NULL) {
00399             retVal = -2;
00400         } else {
00401             serverInfo->enableAddressMapping = mode;
00402             if (meshLocalPrefix) {
00403                 memcpy(serverInfo->meshLocalPrefix, meshLocalPrefix, 8);
00404             }
00405             retVal = 0;
00406         }
00407     }
00408 
00409     return retVal;
00410 }
00411 
00412 /* SET max accepted clients to server, Default is 200
00413  *
00414  *
00415  *  /param interface interface id of this thread instance.
00416  *  /param guaPrefix Prefix which will be removed
00417  *  /param maxClientCount
00418  */
00419 int DHCPv6_server_service_set_max_clients_accepts_count(int8_t interface, uint8_t guaPrefix[static 16], uint32_t maxClientCount)
00420 {
00421     int retVal = -1;
00422     dhcpv6_gua_server_entry_s *serverInfo;
00423     if (maxClientCount == 0) {
00424         return -2;
00425     } else {
00426         serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
00427         if (serverInfo) {
00428             serverInfo->maxSuppertedClients = maxClientCount;
00429             retVal = 0;
00430         }
00431     }
00432     return retVal;
00433 }
00434 
00435 /** SET Address Valid Lifetime parameter for allocated address, Default is 7200 seconds
00436  *
00437  *
00438  *  /param interface interface id of this thread instance.
00439  *  /param guaPrefix Prefix which will be removed
00440  *  /param validLifeTimne in seconds
00441  */
00442 int DHCPv6_server_service_set_address_validlifetime(int8_t interface, uint8_t guaPrefix[static 16], uint32_t validLifeTimne)
00443 {
00444     int retVal = -1;
00445     dhcpv6_gua_server_entry_s *serverInfo;
00446     if (validLifeTimne < 120) {
00447         retVal = -2;
00448     } else {
00449         serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interface, guaPrefix);
00450         if (serverInfo) {
00451             serverInfo->validLifetime = validLifeTimne;
00452             retVal = 0;
00453         }
00454     }
00455     return retVal;
00456 }
00457 
00458 int DHCPv6_server_service_gua_target_mac_check(int8_t interfaceId, const uint8_t *targetGUA, uint8_t *targetEUI64)
00459 {
00460     dhcpv6_gua_server_entry_s *serverInfo = libdhcpv6_server_data_get_by_prefix_and_interfaceid(interfaceId, targetGUA);
00461     if (serverInfo) {
00462         dhcpv6_alloacted_address_entry_t *entry = libdhcpv6_address_get_from_allocated_list(serverInfo, targetGUA);
00463         if (entry) {
00464             if (entry->preferredLifetime && (entry->linkType == DHCPV6_DUID_HARDWARE_EUI64_TYPE)) {
00465                 memcpy(targetEUI64, entry->linkId, 8);
00466                 return 0;
00467             }
00468         }
00469     }
00470     return -1;
00471 }
00472 #else
00473 
00474 int DHCPv6_server_service_init(int8_t interface, uint8_t guaPrefix[static 16], uint8_t serverDUID[static 8], uint16_t serverDUIDType)
00475 {
00476     (void) interface;
00477     (void) guaPrefix;
00478     (void) serverDUID;
00479     (void) serverDUIDType;
00480 
00481     return -1;
00482 }
00483 void DHCPv6_server_service_delete(int8_t interface, uint8_t guaPrefix[static 16], bool delete_gua_addresses)
00484 {
00485     (void) interface;
00486     (void) guaPrefix;
00487     (void) delete_gua_addresses;
00488 }
00489 void DHCPv6_server_service_timeout_cb(uint32_t timeUpdateInSeconds)
00490 {
00491     (void) timeUpdateInSeconds;
00492 }
00493 int DHCPv6_server_service_set_address_autonous_flag(int8_t interface, uint8_t guaPrefix[static 16], bool mode)
00494 {
00495     (void) interface;
00496     (void) guaPrefix;
00497     (void) mode;
00498 
00499     return -1;
00500 }
00501 int DHCPv6_server_service_set_gua_address_mapping(int8_t interface, uint8_t guaPrefix[static 16], bool mode, uint8_t meshLocalPrefix[8])
00502 {
00503     (void) interface;
00504     (void) guaPrefix;
00505     (void) mode;
00506     (void) meshLocalPrefix;
00507 
00508     return -1;
00509 }
00510 int DHCPv6_server_service_set_max_clients_accepts_count(int8_t interface, uint8_t guaPrefix[static 16], uint32_t maxClientCount)
00511 {
00512     (void) interface;
00513     (void) guaPrefix;
00514     (void) maxClientCount;
00515 
00516     return -1;
00517 }
00518 int DHCPv6_server_service_set_address_validlifetime(int8_t interface, uint8_t guaPrefix[static 16], uint32_t validLifeTimne)
00519 {
00520     (void) interface;
00521     (void) guaPrefix;
00522     (void) validLifeTimne;
00523 
00524     return -1;
00525 }
00526 int DHCPv6_server_service_gua_target_mac_check(int8_t interfaceId, const uint8_t *targetGUA, uint8_t *targetEUI64)
00527 {
00528     (void) interfaceId;
00529     (void) targetGUA;
00530     (void) targetEUI64;
00531 
00532     return -1;
00533 }
00534 
00535 #endif