Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 1 | /* |
| 2 | * NetLabel Domain Hash Table |
| 3 | * |
| 4 | * This file manages the domain hash table that NetLabel uses to determine |
| 5 | * which network labeling protocol to use for a given domain. The NetLabel |
| 6 | * system manages static and dynamic label mappings for network protocols such |
| 7 | * as CIPSO and RIPSO. |
| 8 | * |
| 9 | * Author: Paul Moore <paul.moore@hp.com> |
| 10 | * |
| 11 | */ |
| 12 | |
| 13 | /* |
| 14 | * (c) Copyright Hewlett-Packard Development Company, L.P., 2006 |
| 15 | * |
| 16 | * This program is free software; you can redistribute it and/or modify |
| 17 | * it under the terms of the GNU General Public License as published by |
| 18 | * the Free Software Foundation; either version 2 of the License, or |
| 19 | * (at your option) any later version. |
| 20 | * |
| 21 | * This program is distributed in the hope that it will be useful, |
| 22 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 23 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See |
| 24 | * the GNU General Public License for more details. |
| 25 | * |
| 26 | * You should have received a copy of the GNU General Public License |
| 27 | * along with this program; if not, write to the Free Software |
| 28 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 29 | * |
| 30 | */ |
| 31 | |
| 32 | #include <linux/types.h> |
| 33 | #include <linux/rcupdate.h> |
| 34 | #include <linux/list.h> |
| 35 | #include <linux/skbuff.h> |
| 36 | #include <linux/spinlock.h> |
| 37 | #include <linux/string.h> |
Paul Moore | 32f50cd | 2006-09-28 14:51:47 -0700 | [diff] [blame] | 38 | #include <linux/audit.h> |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 39 | #include <net/netlabel.h> |
| 40 | #include <net/cipso_ipv4.h> |
| 41 | #include <asm/bug.h> |
| 42 | |
| 43 | #include "netlabel_mgmt.h" |
| 44 | #include "netlabel_domainhash.h" |
Paul Moore | 32f50cd | 2006-09-28 14:51:47 -0700 | [diff] [blame] | 45 | #include "netlabel_user.h" |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 46 | |
| 47 | struct netlbl_domhsh_tbl { |
| 48 | struct list_head *tbl; |
| 49 | u32 size; |
| 50 | }; |
| 51 | |
| 52 | /* Domain hash table */ |
| 53 | /* XXX - updates should be so rare that having one spinlock for the entire |
| 54 | * hash table should be okay */ |
Adrian Bunk | 8ce11e6 | 2006-08-07 21:50:48 -0700 | [diff] [blame] | 55 | static DEFINE_SPINLOCK(netlbl_domhsh_lock); |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 56 | static struct netlbl_domhsh_tbl *netlbl_domhsh = NULL; |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 57 | static struct netlbl_dom_map *netlbl_domhsh_def = NULL; |
| 58 | |
| 59 | /* |
| 60 | * Domain Hash Table Helper Functions |
| 61 | */ |
| 62 | |
| 63 | /** |
| 64 | * netlbl_domhsh_free_entry - Frees a domain hash table entry |
| 65 | * @entry: the entry's RCU field |
| 66 | * |
| 67 | * Description: |
| 68 | * This function is designed to be used as a callback to the call_rcu() |
| 69 | * function so that the memory allocated to a hash table entry can be released |
| 70 | * safely. |
| 71 | * |
| 72 | */ |
| 73 | static void netlbl_domhsh_free_entry(struct rcu_head *entry) |
| 74 | { |
| 75 | struct netlbl_dom_map *ptr; |
| 76 | |
| 77 | ptr = container_of(entry, struct netlbl_dom_map, rcu); |
| 78 | kfree(ptr->domain); |
| 79 | kfree(ptr); |
| 80 | } |
| 81 | |
| 82 | /** |
| 83 | * netlbl_domhsh_hash - Hashing function for the domain hash table |
| 84 | * @domain: the domain name to hash |
| 85 | * |
| 86 | * Description: |
| 87 | * This is the hashing function for the domain hash table, it returns the |
| 88 | * correct bucket number for the domain. The caller is responsibile for |
| 89 | * calling the rcu_read_[un]lock() functions. |
| 90 | * |
| 91 | */ |
| 92 | static u32 netlbl_domhsh_hash(const char *key) |
| 93 | { |
| 94 | u32 iter; |
| 95 | u32 val; |
| 96 | u32 len; |
| 97 | |
| 98 | /* This is taken (with slight modification) from |
| 99 | * security/selinux/ss/symtab.c:symhash() */ |
| 100 | |
| 101 | for (iter = 0, val = 0, len = strlen(key); iter < len; iter++) |
| 102 | val = (val << 4 | (val >> (8 * sizeof(u32) - 4))) ^ key[iter]; |
| 103 | return val & (rcu_dereference(netlbl_domhsh)->size - 1); |
| 104 | } |
| 105 | |
| 106 | /** |
| 107 | * netlbl_domhsh_search - Search for a domain entry |
| 108 | * @domain: the domain |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 109 | * |
| 110 | * Description: |
| 111 | * Searches the domain hash table and returns a pointer to the hash table |
Paul Moore | b64397e | 2008-01-29 08:37:54 -0500 | [diff] [blame] | 112 | * entry if found, otherwise NULL is returned. The caller is responsibile for |
| 113 | * the rcu hash table locks (i.e. the caller much call rcu_read_[un]lock()). |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 114 | * |
| 115 | */ |
Paul Moore | b64397e | 2008-01-29 08:37:54 -0500 | [diff] [blame] | 116 | static struct netlbl_dom_map *netlbl_domhsh_search(const char *domain) |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 117 | { |
| 118 | u32 bkt; |
| 119 | struct netlbl_dom_map *iter; |
| 120 | |
| 121 | if (domain != NULL) { |
| 122 | bkt = netlbl_domhsh_hash(domain); |
Paul Moore | 3482fd9 | 2007-08-07 17:53:10 -0700 | [diff] [blame] | 123 | list_for_each_entry_rcu(iter, |
| 124 | &rcu_dereference(netlbl_domhsh)->tbl[bkt], |
| 125 | list) |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 126 | if (iter->valid && strcmp(iter->domain, domain) == 0) |
| 127 | return iter; |
| 128 | } |
| 129 | |
Paul Moore | b64397e | 2008-01-29 08:37:54 -0500 | [diff] [blame] | 130 | return NULL; |
| 131 | } |
| 132 | |
| 133 | /** |
| 134 | * netlbl_domhsh_search_def - Search for a domain entry |
| 135 | * @domain: the domain |
| 136 | * @def: return default if no match is found |
| 137 | * |
| 138 | * Description: |
| 139 | * Searches the domain hash table and returns a pointer to the hash table |
| 140 | * entry if an exact match is found, if an exact match is not present in the |
| 141 | * hash table then the default entry is returned if valid otherwise NULL is |
| 142 | * returned. The caller is responsibile for the rcu hash table locks |
| 143 | * (i.e. the caller much call rcu_read_[un]lock()). |
| 144 | * |
| 145 | */ |
| 146 | static struct netlbl_dom_map *netlbl_domhsh_search_def(const char *domain) |
| 147 | { |
| 148 | struct netlbl_dom_map *entry; |
| 149 | |
| 150 | entry = netlbl_domhsh_search(domain); |
| 151 | if (entry == NULL) { |
| 152 | entry = rcu_dereference(netlbl_domhsh_def); |
| 153 | if (entry != NULL && entry->valid) |
| 154 | return entry; |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 155 | } |
| 156 | |
| 157 | return NULL; |
| 158 | } |
| 159 | |
| 160 | /* |
| 161 | * Domain Hash Table Functions |
| 162 | */ |
| 163 | |
| 164 | /** |
| 165 | * netlbl_domhsh_init - Init for the domain hash |
| 166 | * @size: the number of bits to use for the hash buckets |
| 167 | * |
| 168 | * Description: |
| 169 | * Initializes the domain hash table, should be called only by |
| 170 | * netlbl_user_init() during initialization. Returns zero on success, non-zero |
| 171 | * values on error. |
| 172 | * |
| 173 | */ |
| 174 | int netlbl_domhsh_init(u32 size) |
| 175 | { |
| 176 | u32 iter; |
| 177 | struct netlbl_domhsh_tbl *hsh_tbl; |
| 178 | |
| 179 | if (size == 0) |
| 180 | return -EINVAL; |
| 181 | |
| 182 | hsh_tbl = kmalloc(sizeof(*hsh_tbl), GFP_KERNEL); |
| 183 | if (hsh_tbl == NULL) |
| 184 | return -ENOMEM; |
| 185 | hsh_tbl->size = 1 << size; |
| 186 | hsh_tbl->tbl = kcalloc(hsh_tbl->size, |
| 187 | sizeof(struct list_head), |
| 188 | GFP_KERNEL); |
| 189 | if (hsh_tbl->tbl == NULL) { |
| 190 | kfree(hsh_tbl); |
| 191 | return -ENOMEM; |
| 192 | } |
| 193 | for (iter = 0; iter < hsh_tbl->size; iter++) |
| 194 | INIT_LIST_HEAD(&hsh_tbl->tbl[iter]); |
| 195 | |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 196 | spin_lock(&netlbl_domhsh_lock); |
| 197 | rcu_assign_pointer(netlbl_domhsh, hsh_tbl); |
| 198 | spin_unlock(&netlbl_domhsh_lock); |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 199 | |
| 200 | return 0; |
| 201 | } |
| 202 | |
| 203 | /** |
| 204 | * netlbl_domhsh_add - Adds a entry to the domain hash table |
| 205 | * @entry: the entry to add |
Paul Moore | 95d4e6b | 2006-09-29 17:05:05 -0700 | [diff] [blame] | 206 | * @audit_info: NetLabel audit information |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 207 | * |
| 208 | * Description: |
| 209 | * Adds a new entry to the domain hash table and handles any updates to the |
| 210 | * lower level protocol handler (i.e. CIPSO). Returns zero on success, |
| 211 | * negative on failure. |
| 212 | * |
| 213 | */ |
Paul Moore | 95d4e6b | 2006-09-29 17:05:05 -0700 | [diff] [blame] | 214 | int netlbl_domhsh_add(struct netlbl_dom_map *entry, |
| 215 | struct netlbl_audit *audit_info) |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 216 | { |
| 217 | int ret_val; |
| 218 | u32 bkt; |
Paul Moore | 32f50cd | 2006-09-28 14:51:47 -0700 | [diff] [blame] | 219 | struct audit_buffer *audit_buf; |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 220 | |
| 221 | switch (entry->type) { |
| 222 | case NETLBL_NLTYPE_UNLABELED: |
| 223 | ret_val = 0; |
| 224 | break; |
| 225 | case NETLBL_NLTYPE_CIPSOV4: |
| 226 | ret_val = cipso_v4_doi_domhsh_add(entry->type_def.cipsov4, |
| 227 | entry->domain); |
| 228 | break; |
| 229 | default: |
| 230 | return -EINVAL; |
| 231 | } |
| 232 | if (ret_val != 0) |
| 233 | return ret_val; |
| 234 | |
| 235 | entry->valid = 1; |
| 236 | INIT_RCU_HEAD(&entry->rcu); |
| 237 | |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 238 | rcu_read_lock(); |
Paul Moore | 1c3fad9 | 2008-01-29 08:37:57 -0500 | [diff] [blame] | 239 | spin_lock(&netlbl_domhsh_lock); |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 240 | if (entry->domain != NULL) { |
| 241 | bkt = netlbl_domhsh_hash(entry->domain); |
Paul Moore | b64397e | 2008-01-29 08:37:54 -0500 | [diff] [blame] | 242 | if (netlbl_domhsh_search(entry->domain) == NULL) |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 243 | list_add_tail_rcu(&entry->list, |
Paul Moore | 3482fd9 | 2007-08-07 17:53:10 -0700 | [diff] [blame] | 244 | &rcu_dereference(netlbl_domhsh)->tbl[bkt]); |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 245 | else |
| 246 | ret_val = -EEXIST; |
Paul Moore | 4be2700 | 2007-10-26 04:29:08 -0700 | [diff] [blame] | 247 | } else { |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 248 | INIT_LIST_HEAD(&entry->list); |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 249 | if (rcu_dereference(netlbl_domhsh_def) == NULL) |
| 250 | rcu_assign_pointer(netlbl_domhsh_def, entry); |
| 251 | else |
| 252 | ret_val = -EEXIST; |
Paul Moore | 4be2700 | 2007-10-26 04:29:08 -0700 | [diff] [blame] | 253 | } |
Paul Moore | 1c3fad9 | 2008-01-29 08:37:57 -0500 | [diff] [blame] | 254 | spin_unlock(&netlbl_domhsh_lock); |
Paul Moore | 95d4e6b | 2006-09-29 17:05:05 -0700 | [diff] [blame] | 255 | audit_buf = netlbl_audit_start_common(AUDIT_MAC_MAP_ADD, audit_info); |
Paul Moore | de64688 | 2006-11-17 17:38:55 -0500 | [diff] [blame] | 256 | if (audit_buf != NULL) { |
Paul Moore | 95d4e6b | 2006-09-29 17:05:05 -0700 | [diff] [blame] | 257 | audit_log_format(audit_buf, |
Paul Moore | de64688 | 2006-11-17 17:38:55 -0500 | [diff] [blame] | 258 | " nlbl_domain=%s", |
| 259 | entry->domain ? entry->domain : "(default)"); |
| 260 | switch (entry->type) { |
| 261 | case NETLBL_NLTYPE_UNLABELED: |
| 262 | audit_log_format(audit_buf, " nlbl_protocol=unlbl"); |
| 263 | break; |
| 264 | case NETLBL_NLTYPE_CIPSOV4: |
| 265 | audit_log_format(audit_buf, |
| 266 | " nlbl_protocol=cipsov4 cipso_doi=%u", |
| 267 | entry->type_def.cipsov4->doi); |
| 268 | break; |
| 269 | } |
| 270 | audit_log_format(audit_buf, " res=%u", ret_val == 0 ? 1 : 0); |
| 271 | audit_log_end(audit_buf); |
Paul Moore | 32f50cd | 2006-09-28 14:51:47 -0700 | [diff] [blame] | 272 | } |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 273 | rcu_read_unlock(); |
| 274 | |
| 275 | if (ret_val != 0) { |
| 276 | switch (entry->type) { |
| 277 | case NETLBL_NLTYPE_CIPSOV4: |
| 278 | if (cipso_v4_doi_domhsh_remove(entry->type_def.cipsov4, |
| 279 | entry->domain) != 0) |
| 280 | BUG(); |
| 281 | break; |
| 282 | } |
| 283 | } |
| 284 | |
| 285 | return ret_val; |
| 286 | } |
| 287 | |
| 288 | /** |
| 289 | * netlbl_domhsh_add_default - Adds the default entry to the domain hash table |
| 290 | * @entry: the entry to add |
Paul Moore | 95d4e6b | 2006-09-29 17:05:05 -0700 | [diff] [blame] | 291 | * @audit_info: NetLabel audit information |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 292 | * |
| 293 | * Description: |
| 294 | * Adds a new default entry to the domain hash table and handles any updates |
| 295 | * to the lower level protocol handler (i.e. CIPSO). Returns zero on success, |
| 296 | * negative on failure. |
| 297 | * |
| 298 | */ |
Paul Moore | 95d4e6b | 2006-09-29 17:05:05 -0700 | [diff] [blame] | 299 | int netlbl_domhsh_add_default(struct netlbl_dom_map *entry, |
| 300 | struct netlbl_audit *audit_info) |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 301 | { |
Paul Moore | 95d4e6b | 2006-09-29 17:05:05 -0700 | [diff] [blame] | 302 | return netlbl_domhsh_add(entry, audit_info); |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 303 | } |
| 304 | |
| 305 | /** |
| 306 | * netlbl_domhsh_remove - Removes an entry from the domain hash table |
| 307 | * @domain: the domain to remove |
Paul Moore | 95d4e6b | 2006-09-29 17:05:05 -0700 | [diff] [blame] | 308 | * @audit_info: NetLabel audit information |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 309 | * |
| 310 | * Description: |
| 311 | * Removes an entry from the domain hash table and handles any updates to the |
| 312 | * lower level protocol handler (i.e. CIPSO). Returns zero on success, |
| 313 | * negative on failure. |
| 314 | * |
| 315 | */ |
Paul Moore | 95d4e6b | 2006-09-29 17:05:05 -0700 | [diff] [blame] | 316 | int netlbl_domhsh_remove(const char *domain, struct netlbl_audit *audit_info) |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 317 | { |
| 318 | int ret_val = -ENOENT; |
| 319 | struct netlbl_dom_map *entry; |
Paul Moore | 32f50cd | 2006-09-28 14:51:47 -0700 | [diff] [blame] | 320 | struct audit_buffer *audit_buf; |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 321 | |
| 322 | rcu_read_lock(); |
Paul Moore | b64397e | 2008-01-29 08:37:54 -0500 | [diff] [blame] | 323 | if (domain) |
| 324 | entry = netlbl_domhsh_search(domain); |
| 325 | else |
| 326 | entry = netlbl_domhsh_search_def(domain); |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 327 | if (entry == NULL) |
| 328 | goto remove_return; |
| 329 | switch (entry->type) { |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 330 | case NETLBL_NLTYPE_CIPSOV4: |
Paul Moore | 4be2700 | 2007-10-26 04:29:08 -0700 | [diff] [blame] | 331 | cipso_v4_doi_domhsh_remove(entry->type_def.cipsov4, |
| 332 | entry->domain); |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 333 | break; |
| 334 | } |
Paul Moore | 1c3fad9 | 2008-01-29 08:37:57 -0500 | [diff] [blame] | 335 | spin_lock(&netlbl_domhsh_lock); |
| 336 | if (entry->valid) { |
| 337 | entry->valid = 0; |
| 338 | if (entry != rcu_dereference(netlbl_domhsh_def)) |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 339 | list_del_rcu(&entry->list); |
Paul Moore | 1c3fad9 | 2008-01-29 08:37:57 -0500 | [diff] [blame] | 340 | else |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 341 | rcu_assign_pointer(netlbl_domhsh_def, NULL); |
Paul Moore | 1c3fad9 | 2008-01-29 08:37:57 -0500 | [diff] [blame] | 342 | ret_val = 0; |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 343 | } |
Paul Moore | 1c3fad9 | 2008-01-29 08:37:57 -0500 | [diff] [blame] | 344 | spin_unlock(&netlbl_domhsh_lock); |
Paul Moore | 32f50cd | 2006-09-28 14:51:47 -0700 | [diff] [blame] | 345 | |
Paul Moore | 95d4e6b | 2006-09-29 17:05:05 -0700 | [diff] [blame] | 346 | audit_buf = netlbl_audit_start_common(AUDIT_MAC_MAP_DEL, audit_info); |
Paul Moore | de64688 | 2006-11-17 17:38:55 -0500 | [diff] [blame] | 347 | if (audit_buf != NULL) { |
| 348 | audit_log_format(audit_buf, |
| 349 | " nlbl_domain=%s res=%u", |
| 350 | entry->domain ? entry->domain : "(default)", |
| 351 | ret_val == 0 ? 1 : 0); |
| 352 | audit_log_end(audit_buf); |
| 353 | } |
Paul Moore | 95d4e6b | 2006-09-29 17:05:05 -0700 | [diff] [blame] | 354 | |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 355 | remove_return: |
| 356 | rcu_read_unlock(); |
Paul Moore | 4be2700 | 2007-10-26 04:29:08 -0700 | [diff] [blame] | 357 | if (ret_val == 0) |
| 358 | call_rcu(&entry->rcu, netlbl_domhsh_free_entry); |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 359 | return ret_val; |
| 360 | } |
| 361 | |
| 362 | /** |
| 363 | * netlbl_domhsh_remove_default - Removes the default entry from the table |
Paul Moore | 95d4e6b | 2006-09-29 17:05:05 -0700 | [diff] [blame] | 364 | * @audit_info: NetLabel audit information |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 365 | * |
| 366 | * Description: |
| 367 | * Removes/resets the default entry for the domain hash table and handles any |
| 368 | * updates to the lower level protocol handler (i.e. CIPSO). Returns zero on |
| 369 | * success, non-zero on failure. |
| 370 | * |
| 371 | */ |
Paul Moore | 95d4e6b | 2006-09-29 17:05:05 -0700 | [diff] [blame] | 372 | int netlbl_domhsh_remove_default(struct netlbl_audit *audit_info) |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 373 | { |
Paul Moore | 95d4e6b | 2006-09-29 17:05:05 -0700 | [diff] [blame] | 374 | return netlbl_domhsh_remove(NULL, audit_info); |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 375 | } |
| 376 | |
| 377 | /** |
| 378 | * netlbl_domhsh_getentry - Get an entry from the domain hash table |
| 379 | * @domain: the domain name to search for |
| 380 | * |
| 381 | * Description: |
| 382 | * Look through the domain hash table searching for an entry to match @domain, |
| 383 | * return a pointer to a copy of the entry or NULL. The caller is responsibile |
| 384 | * for ensuring that rcu_read_[un]lock() is called. |
| 385 | * |
| 386 | */ |
| 387 | struct netlbl_dom_map *netlbl_domhsh_getentry(const char *domain) |
| 388 | { |
Paul Moore | b64397e | 2008-01-29 08:37:54 -0500 | [diff] [blame] | 389 | return netlbl_domhsh_search_def(domain); |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 390 | } |
| 391 | |
| 392 | /** |
Paul Moore | fcd4828 | 2006-09-25 15:56:09 -0700 | [diff] [blame] | 393 | * netlbl_domhsh_walk - Iterate through the domain mapping hash table |
| 394 | * @skip_bkt: the number of buckets to skip at the start |
| 395 | * @skip_chain: the number of entries to skip in the first iterated bucket |
| 396 | * @callback: callback for each entry |
| 397 | * @cb_arg: argument for the callback function |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 398 | * |
| 399 | * Description: |
Paul Moore | fcd4828 | 2006-09-25 15:56:09 -0700 | [diff] [blame] | 400 | * Interate over the domain mapping hash table, skipping the first @skip_bkt |
| 401 | * buckets and @skip_chain entries. For each entry in the table call |
| 402 | * @callback, if @callback returns a negative value stop 'walking' through the |
| 403 | * table and return. Updates the values in @skip_bkt and @skip_chain on |
| 404 | * return. Returns zero on succcess, negative values on failure. |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 405 | * |
| 406 | */ |
Paul Moore | fcd4828 | 2006-09-25 15:56:09 -0700 | [diff] [blame] | 407 | int netlbl_domhsh_walk(u32 *skip_bkt, |
| 408 | u32 *skip_chain, |
| 409 | int (*callback) (struct netlbl_dom_map *entry, void *arg), |
| 410 | void *cb_arg) |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 411 | { |
Paul Moore | fcd4828 | 2006-09-25 15:56:09 -0700 | [diff] [blame] | 412 | int ret_val = -ENOENT; |
| 413 | u32 iter_bkt; |
| 414 | struct netlbl_dom_map *iter_entry; |
| 415 | u32 chain_cnt = 0; |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 416 | |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 417 | rcu_read_lock(); |
Paul Moore | fcd4828 | 2006-09-25 15:56:09 -0700 | [diff] [blame] | 418 | for (iter_bkt = *skip_bkt; |
| 419 | iter_bkt < rcu_dereference(netlbl_domhsh)->size; |
| 420 | iter_bkt++, chain_cnt = 0) { |
| 421 | list_for_each_entry_rcu(iter_entry, |
Paul Moore | 3482fd9 | 2007-08-07 17:53:10 -0700 | [diff] [blame] | 422 | &rcu_dereference(netlbl_domhsh)->tbl[iter_bkt], |
| 423 | list) |
Paul Moore | fcd4828 | 2006-09-25 15:56:09 -0700 | [diff] [blame] | 424 | if (iter_entry->valid) { |
| 425 | if (chain_cnt++ < *skip_chain) |
| 426 | continue; |
| 427 | ret_val = callback(iter_entry, cb_arg); |
| 428 | if (ret_val < 0) { |
| 429 | chain_cnt--; |
| 430 | goto walk_return; |
| 431 | } |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 432 | } |
Paul Moore | fcd4828 | 2006-09-25 15:56:09 -0700 | [diff] [blame] | 433 | } |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 434 | |
Paul Moore | fcd4828 | 2006-09-25 15:56:09 -0700 | [diff] [blame] | 435 | walk_return: |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 436 | rcu_read_unlock(); |
Paul Moore | fcd4828 | 2006-09-25 15:56:09 -0700 | [diff] [blame] | 437 | *skip_bkt = iter_bkt; |
| 438 | *skip_chain = chain_cnt; |
| 439 | return ret_val; |
Paul Moore | d15c345 | 2006-08-03 16:48:37 -0700 | [diff] [blame] | 440 | } |