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