Merge branches 'release' and 'autoload' into release
[linux-2.6] / net / netlabel / netlabel_domainhash.c
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>
38 #include <linux/audit.h>
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"
45 #include "netlabel_user.h"
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 */
55 static DEFINE_SPINLOCK(netlbl_domhsh_lock);
56 static struct netlbl_domhsh_tbl *netlbl_domhsh = NULL;
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
109  *
110  * Description:
111  * Searches the domain hash table and returns a pointer to the hash table
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()).
114  *
115  */
116 static struct netlbl_dom_map *netlbl_domhsh_search(const char *domain)
117 {
118         u32 bkt;
119         struct netlbl_dom_map *iter;
120
121         if (domain != NULL) {
122                 bkt = netlbl_domhsh_hash(domain);
123                 list_for_each_entry_rcu(iter,
124                                      &rcu_dereference(netlbl_domhsh)->tbl[bkt],
125                                      list)
126                         if (iter->valid && strcmp(iter->domain, domain) == 0)
127                                 return iter;
128         }
129
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;
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
196         spin_lock(&netlbl_domhsh_lock);
197         rcu_assign_pointer(netlbl_domhsh, hsh_tbl);
198         spin_unlock(&netlbl_domhsh_lock);
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
206  * @audit_info: NetLabel audit information
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  */
214 int netlbl_domhsh_add(struct netlbl_dom_map *entry,
215                       struct netlbl_audit *audit_info)
216 {
217         int ret_val;
218         u32 bkt;
219         struct audit_buffer *audit_buf;
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
238         rcu_read_lock();
239         spin_lock(&netlbl_domhsh_lock);
240         if (entry->domain != NULL) {
241                 bkt = netlbl_domhsh_hash(entry->domain);
242                 if (netlbl_domhsh_search(entry->domain) == NULL)
243                         list_add_tail_rcu(&entry->list,
244                                     &rcu_dereference(netlbl_domhsh)->tbl[bkt]);
245                 else
246                         ret_val = -EEXIST;
247         } else {
248                 INIT_LIST_HEAD(&entry->list);
249                 if (rcu_dereference(netlbl_domhsh_def) == NULL)
250                         rcu_assign_pointer(netlbl_domhsh_def, entry);
251                 else
252                         ret_val = -EEXIST;
253         }
254         spin_unlock(&netlbl_domhsh_lock);
255         audit_buf = netlbl_audit_start_common(AUDIT_MAC_MAP_ADD, audit_info);
256         if (audit_buf != NULL) {
257                 audit_log_format(audit_buf,
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);
272         }
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
291  * @audit_info: NetLabel audit information
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  */
299 int netlbl_domhsh_add_default(struct netlbl_dom_map *entry,
300                               struct netlbl_audit *audit_info)
301 {
302         return netlbl_domhsh_add(entry, audit_info);
303 }
304
305 /**
306  * netlbl_domhsh_remove - Removes an entry from the domain hash table
307  * @domain: the domain to remove
308  * @audit_info: NetLabel audit information
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  */
316 int netlbl_domhsh_remove(const char *domain, struct netlbl_audit *audit_info)
317 {
318         int ret_val = -ENOENT;
319         struct netlbl_dom_map *entry;
320         struct audit_buffer *audit_buf;
321
322         rcu_read_lock();
323         if (domain)
324                 entry = netlbl_domhsh_search(domain);
325         else
326                 entry = netlbl_domhsh_search_def(domain);
327         if (entry == NULL)
328                 goto remove_return;
329         switch (entry->type) {
330         case NETLBL_NLTYPE_CIPSOV4:
331                 cipso_v4_doi_domhsh_remove(entry->type_def.cipsov4,
332                                            entry->domain);
333                 break;
334         }
335         spin_lock(&netlbl_domhsh_lock);
336         if (entry->valid) {
337                 entry->valid = 0;
338                 if (entry != rcu_dereference(netlbl_domhsh_def))
339                         list_del_rcu(&entry->list);
340                 else
341                         rcu_assign_pointer(netlbl_domhsh_def, NULL);
342                 ret_val = 0;
343         }
344         spin_unlock(&netlbl_domhsh_lock);
345
346         audit_buf = netlbl_audit_start_common(AUDIT_MAC_MAP_DEL, audit_info);
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         }
354
355 remove_return:
356         rcu_read_unlock();
357         if (ret_val == 0)
358                 call_rcu(&entry->rcu, netlbl_domhsh_free_entry);
359         return ret_val;
360 }
361
362 /**
363  * netlbl_domhsh_remove_default - Removes the default entry from the table
364  * @audit_info: NetLabel audit information
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  */
372 int netlbl_domhsh_remove_default(struct netlbl_audit *audit_info)
373 {
374         return netlbl_domhsh_remove(NULL, audit_info);
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 {
389         return netlbl_domhsh_search_def(domain);
390 }
391
392 /**
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
398  *
399  * Description:
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.
405  *
406  */
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)
411 {
412         int ret_val = -ENOENT;
413         u32 iter_bkt;
414         struct netlbl_dom_map *iter_entry;
415         u32 chain_cnt = 0;
416
417         rcu_read_lock();
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,
422                                 &rcu_dereference(netlbl_domhsh)->tbl[iter_bkt],
423                                 list)
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                                 }
432                         }
433         }
434
435 walk_return:
436         rcu_read_unlock();
437         *skip_bkt = iter_bkt;
438         *skip_chain = chain_cnt;
439         return ret_val;
440 }