blacklist.c

00001 /*
00002  * Copyright (c) 2017-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 #include "nsconfig.h"
00018 #include "string.h"
00019 #include "ns_types.h"
00020 #include "ns_trace.h"
00021 #include "eventOS_scheduler.h"
00022 #include "nsdynmemLIB.h"
00023 #include "randLIB.h"
00024 #include "NWK_INTERFACE/Include/protocol.h"
00025 #include "Service_Libs/blacklist/blacklist.h"
00026 
00027 #define TRACE_GROUP "bl"
00028 
00029 static blacklist_entry_t *blacklist_entry_find(const uint8_t *eui64);
00030 static void blacklist_entry_add(const uint8_t *eui64);
00031 static int8_t blacklist_entry_free(blacklist_entry_t *blacklist_entry);
00032 static uint16_t blacklist_entries_count(void);
00033 
00034 static blacklist_data_t *blacklist_data = NULL;
00035 
00036 uint8_t blacklist_init(void)
00037 {
00038     if (blacklist_data) {
00039         return 0;
00040     }
00041 
00042     blacklist_data = ns_dyn_mem_alloc(sizeof(blacklist_data_t));
00043 
00044     if (!blacklist_data) {
00045         return 1;
00046     }
00047 
00048     ns_list_init(&blacklist_data->blacklist);
00049 
00050     blacklist_data->blacklist_purge_ttl = BLACKLIST_DEFAULT_PURGE_TIMER_TIMEOUT;
00051     blacklist_data->blacklist_entry_lifetime = BLACKLIST_DEFAULT_ENTRY_LIFETIME;
00052     blacklist_data->blacklist_timer_max_timeout = BLACKLIST_DEFAULT_TIMER_MAX_TIMEOUT;
00053     blacklist_data->blacklist_timer_timeout = BLACKLIST_DEFAULT_TIMER_TIMEOUT;
00054     blacklist_data->blacklist_entry_max_nbr = BLACKLIST_DEFAULT_ENTRY_MAX_NBR;
00055     blacklist_data->blacklist_purge_nbr = BLACKLIST_DEFAULT_PURGE_NBR;
00056     blacklist_data->blacklist_purge_timer_timeout = BLACKLIST_DEFAULT_PURGE_TIMER_TIMEOUT;
00057 
00058     return 0;
00059 }
00060 
00061 void blacklist_params_set(uint16_t entry_lifetime, uint16_t timer_max_timeout, uint16_t timer_timeout, uint16_t entry_max_nbr, uint16_t purge_nbr, uint16_t purge_timer_timeout)
00062 {
00063     if (!blacklist_data) {
00064         return;
00065     }
00066 
00067     blacklist_data->blacklist_purge_ttl = purge_timer_timeout;
00068     blacklist_data->blacklist_entry_lifetime = entry_lifetime;
00069     blacklist_data->blacklist_timer_max_timeout = timer_max_timeout;
00070     blacklist_data->blacklist_timer_timeout = timer_timeout;
00071     blacklist_data->blacklist_entry_max_nbr = entry_max_nbr;
00072     blacklist_data->blacklist_purge_nbr = purge_nbr;
00073     blacklist_data->blacklist_purge_timer_timeout = purge_timer_timeout;
00074 }
00075 
00076 bool blacklist_reject(const uint8_t *ll64_address)
00077 {
00078     if (!blacklist_data) {
00079         return false;
00080     }
00081 
00082     blacklist_entry_t *blacklist_entry;
00083 
00084     blacklist_entry = blacklist_entry_find(ll64_address + 8);
00085 
00086     // If blacklist entry exists
00087     if (blacklist_entry) {
00088         // If address is blacklisted rejects
00089         if (blacklist_entry->ttl > blacklist_data->blacklist_entry_lifetime) {
00090             tr_debug("blacklist reject: %s", trace_array(ll64_address + 8, 8));
00091             return true;
00092             // Neighbor heard; updates blacklist entry TTL to full lifetime
00093         } else {
00094             blacklist_entry->ttl = blacklist_data->blacklist_entry_lifetime;
00095             return false;
00096         }
00097     } else {
00098         // If blacklist is full rejects
00099         if (blacklist_entries_count() >= blacklist_data->blacklist_entry_max_nbr) {
00100             tr_debug("blacklist full reject");
00101             return true;
00102         } else {
00103             return false;
00104         }
00105     }
00106 }
00107 
00108 void blacklist_update(const uint8_t *ll64_address, bool success)
00109 {
00110     if (!blacklist_data) {
00111         return;
00112     }
00113 
00114     blacklist_entry_t *blacklist_entry;
00115 
00116     if (!ll64_address) {
00117         return;
00118     }
00119 
00120     // Check that address is LL64 (not LL16)
00121     if (memcmp(ll64_address, ADDR_LINK_LOCAL_PREFIX, 8) != 0) {
00122         return;
00123     }
00124 
00125     if (memcmp((ll64_address + 8), ADDR_SHORT_ADR_SUFFIC, 6) == 0) {
00126         return;
00127     }
00128 
00129     blacklist_entry = blacklist_entry_find(ll64_address + 8);
00130 
00131     // On successful link establishment remove address from blacklist
00132     if (success) {
00133         if (blacklist_entry) {
00134             tr_debug("Blacklist removed");
00135             blacklist_entry_free(blacklist_entry);
00136         }
00137         // On failure add address to blacklist or update timeout
00138     } else {
00139         if (blacklist_entry) {
00140             blacklist_entry->interval = blacklist_entry->interval * 2;
00141             if (blacklist_entry->interval > blacklist_data->blacklist_timer_max_timeout) {
00142                 blacklist_entry->interval = blacklist_data->blacklist_timer_max_timeout;
00143             }
00144             /* TTL is blacklist entry lifetime + from 1.0 to 1.5 * interval */
00145             blacklist_entry->ttl = blacklist_data->blacklist_entry_lifetime + randLIB_randomise_base(blacklist_entry->interval, 0x8000, 0xC000);
00146         } else {
00147             tr_debug("Blacklist add");
00148             blacklist_entry_add(ll64_address + 8);
00149         }
00150     }
00151 }
00152 
00153 void blacklist_clear(void)
00154 {
00155     if (!blacklist_data) {
00156         return;
00157     }
00158 
00159     ns_list_foreach_safe(blacklist_entry_t, blacklist_entry, &blacklist_data->blacklist) {
00160         blacklist_entry_free(blacklist_entry);
00161     }
00162 }
00163 
00164 void blacklist_free(void)
00165 {
00166     if (!blacklist_data) {
00167         return;
00168     }
00169 
00170     ns_dyn_mem_free(blacklist_data);
00171     blacklist_data = NULL;
00172 }
00173 
00174 void blacklist_ttl_update(uint16_t ticks)
00175 {
00176     if (!blacklist_data) {
00177         return;
00178     }
00179 
00180     if (blacklist_data->blacklist_purge_ttl > ticks) {
00181         blacklist_data->blacklist_purge_ttl -= ticks;
00182     } else {
00183         /* 0.5 to 1.5 times timeout */
00184         blacklist_data->blacklist_purge_ttl = randLIB_randomise_base(blacklist_data->blacklist_purge_timer_timeout, 0x4000, 0xC000);
00185 
00186         if (blacklist_entries_count() >= blacklist_data->blacklist_entry_max_nbr - blacklist_data->blacklist_purge_nbr) {
00187             uint8_t count = 0;
00188             blacklist_entry_t *blacklist_entry_min_ttl;
00189 
00190             tr_debug("Blacklist entries purge");
00191 
00192             while (count++ < blacklist_data->blacklist_purge_nbr) {
00193                 blacklist_entry_min_ttl = NULL;
00194                 ns_list_foreach(blacklist_entry_t, blacklist_entry, &blacklist_data->blacklist) {
00195                     if (!blacklist_entry_min_ttl) {
00196                         blacklist_entry_min_ttl = blacklist_entry;
00197                     } else if (blacklist_entry->ttl < blacklist_entry_min_ttl->ttl) {
00198                         blacklist_entry_min_ttl = blacklist_entry;
00199                     }
00200                 }
00201                 if (blacklist_entry_min_ttl) {
00202                     blacklist_entry_free(blacklist_entry_min_ttl);
00203                 }
00204             }
00205         }
00206     }
00207 
00208     ns_list_foreach_safe(blacklist_entry_t, blacklist_entry, &blacklist_data->blacklist) {
00209         if (blacklist_entry->ttl > ticks) {
00210             blacklist_entry->ttl -= ticks;
00211         } else {
00212             tr_debug("Blacklist remove entry: %s", trace_array(blacklist_entry->eui64, 8));
00213             blacklist_entry_free(blacklist_entry);
00214         }
00215     }
00216 }
00217 
00218 static blacklist_entry_t *blacklist_entry_find(const uint8_t *eui64)
00219 {
00220     if (!eui64) {
00221         return NULL;
00222     }
00223 
00224     if (!blacklist_data) {
00225         return NULL;
00226     }
00227 
00228     ns_list_foreach(blacklist_entry_t, blacklist_entry, &blacklist_data->blacklist) {
00229         if (memcmp(blacklist_entry->eui64, eui64, 8) == 0) {
00230             return blacklist_entry;
00231         }
00232     }
00233     return NULL;
00234 }
00235 
00236 static void blacklist_entry_add(const uint8_t *eui64)
00237 {
00238     blacklist_entry_t *blacklist_entry;
00239 
00240     if (!eui64) {
00241         return;
00242     }
00243 
00244     if (!blacklist_data) {
00245         return;
00246     }
00247 
00248     if (blacklist_entries_count() >= blacklist_data->blacklist_entry_max_nbr) {
00249         return;
00250     }
00251 
00252     blacklist_entry = ns_dyn_mem_alloc(sizeof(blacklist_entry_t));
00253 
00254     if (!blacklist_entry) {
00255         return;
00256     }
00257 
00258     blacklist_entry->interval = blacklist_data->blacklist_timer_timeout;
00259 
00260     /* TTL is blacklist entry lifetime + from 1.0 to 1.5 * interval */
00261     blacklist_entry->ttl = blacklist_data->blacklist_entry_lifetime + randLIB_randomise_base(blacklist_entry->interval, 0x8000, 0xC000);
00262 
00263     memcpy(blacklist_entry->eui64, eui64, 8);
00264     tr_debug("Blacklist add, ttl=%"PRIu16, blacklist_entry->ttl);
00265     ns_list_add_to_start(&blacklist_data->blacklist, blacklist_entry);
00266 }
00267 
00268 static int8_t blacklist_entry_free(blacklist_entry_t *blacklist_entry)
00269 {
00270     if (!blacklist_entry) {
00271         return -1;
00272     }
00273 
00274     if (!blacklist_data) {
00275         return -2;
00276     }
00277 
00278     ns_list_remove(&blacklist_data->blacklist, blacklist_entry); //Remove from the list
00279     ns_dyn_mem_free(blacklist_entry); // Free entry
00280     return 0;
00281 }
00282 
00283 static uint16_t blacklist_entries_count(void)
00284 {
00285     uint16_t entry_count = 0;
00286 
00287     if (!blacklist_data) {
00288         return 0;
00289     }
00290 
00291     entry_count = ns_list_count(&blacklist_data->blacklist);
00292 
00293     return entry_count;
00294 }