1/*-
2 * Copyright (c) 2014 Yandex LLC
3 * Copyright (c) 2014 Alexander V. Chernikov
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: releng/11.0/sys/netpfil/ipfw/ip_fw_table_value.c 299152 2016-05-06 03:18:51Z ae $");
29
30/*
31 * Multi-field value support for ipfw tables.
32 *
33 * This file contains necessary functions to convert
34 * large multi-field values into u32 indices suitable to be fed
35 * to various table algorithms. Other machinery like proper refcounting,
36 * internal structures resizing are also kept here.
37 */
38
39#include "opt_ipfw.h"
40
41#include <sys/param.h>
42#include <sys/systm.h>
43#include <sys/malloc.h>
44#include <sys/kernel.h>
45#include <sys/hash.h>
46#include <sys/lock.h>
47#include <sys/rwlock.h>
48#include <sys/rmlock.h>
49#include <sys/socket.h>
50#include <sys/socketvar.h>
51#include <sys/queue.h>
52#include <net/if.h>	/* ip_fw.h requires IFNAMSIZ */
53
54#include <netinet/in.h>
55#include <netinet/ip_var.h>	/* struct ipfw_rule_ref */
56#include <netinet/ip_fw.h>
57
58#include <netpfil/ipfw/ip_fw_private.h>
59#include <netpfil/ipfw/ip_fw_table.h>
60
61static uint32_t hash_table_value(struct namedobj_instance *ni, const void *key,
62    uint32_t kopt);
63static int cmp_table_value(struct named_object *no, const void *key,
64    uint32_t kopt);
65
66static int list_table_values(struct ip_fw_chain *ch, ip_fw3_opheader *op3,
67    struct sockopt_data *sd);
68
69static struct ipfw_sopt_handler	scodes[] = {
70	{ IP_FW_TABLE_VLIST,	0,	HDIR_GET,	list_table_values },
71};
72
73#define	CHAIN_TO_VI(chain)	(CHAIN_TO_TCFG(chain)->valhash)
74
75struct table_val_link
76{
77	struct named_object	no;
78	struct table_value	*pval;	/* Pointer to real table value */
79};
80#define	VALDATA_START_SIZE	64	/* Allocate 64-items array by default */
81
82struct vdump_args {
83	struct ip_fw_chain *ch;
84	struct sockopt_data *sd;
85	struct table_value *pval;
86	int error;
87};
88
89
90static uint32_t
91hash_table_value(struct namedobj_instance *ni, const void *key, uint32_t kopt)
92{
93
94	return (hash32_buf(key, 56, 0));
95}
96
97static int
98cmp_table_value(struct named_object *no, const void *key, uint32_t kopt)
99{
100
101	return (memcmp(((struct table_val_link *)no)->pval, key, 56));
102}
103
104static void
105mask_table_value(struct table_value *src, struct table_value *dst,
106    uint32_t mask)
107{
108#define	_MCPY(f, b)	if ((mask & (b)) != 0) { dst->f = src->f; }
109
110	memset(dst, 0, sizeof(*dst));
111	_MCPY(tag, IPFW_VTYPE_TAG);
112	_MCPY(pipe, IPFW_VTYPE_PIPE);
113	_MCPY(divert, IPFW_VTYPE_DIVERT);
114	_MCPY(skipto, IPFW_VTYPE_SKIPTO);
115	_MCPY(netgraph, IPFW_VTYPE_NETGRAPH);
116	_MCPY(fib, IPFW_VTYPE_FIB);
117	_MCPY(nat, IPFW_VTYPE_NAT);
118	_MCPY(dscp, IPFW_VTYPE_DSCP);
119	_MCPY(nh4, IPFW_VTYPE_NH4);
120	_MCPY(nh6, IPFW_VTYPE_NH6);
121	_MCPY(zoneid, IPFW_VTYPE_NH6);
122#undef	_MCPY
123}
124
125static void
126get_value_ptrs(struct ip_fw_chain *ch, struct table_config *tc, int vshared,
127    struct table_value **ptv, struct namedobj_instance **pvi)
128{
129	struct table_value *pval;
130	struct namedobj_instance *vi;
131
132	if (vshared != 0) {
133		pval = (struct table_value *)ch->valuestate;
134		vi = CHAIN_TO_VI(ch);
135	} else {
136		pval = NULL;
137		vi = NULL;
138		//pval = (struct table_value *)&tc->ti.data;
139	}
140
141	if (ptv != NULL)
142		*ptv = pval;
143	if (pvi != NULL)
144		*pvi = vi;
145}
146
147/*
148 * Update pointers to real vaues after @pval change.
149 */
150static int
151update_tvalue(struct namedobj_instance *ni, struct named_object *no, void *arg)
152{
153	struct vdump_args *da;
154	struct table_val_link *ptv;
155	struct table_value *pval;
156
157	da = (struct vdump_args *)arg;
158	ptv = (struct table_val_link *)no;
159
160	pval = da->pval;
161	ptv->pval = &pval[ptv->no.kidx];
162	ptv->no.name = (char *)&pval[ptv->no.kidx];
163	return (0);
164}
165
166/*
167 * Grows value storage shared among all tables.
168 * Drops/reacquires UH locks.
169 * Notifies other running adds on @ch shared storage resize.
170 * Note function does not guarantee that free space
171 * will be available after invocation, so one caller needs
172 * to roll cycle himself.
173 *
174 * Returns 0 if case of no errors.
175 */
176static int
177resize_shared_value_storage(struct ip_fw_chain *ch)
178{
179	struct tables_config *tcfg;
180	struct namedobj_instance *vi;
181	struct table_value *pval, *valuestate, *old_valuestate;
182	void *new_idx;
183	struct vdump_args da;
184	int new_blocks;
185	int val_size, val_size_old;
186
187	IPFW_UH_WLOCK_ASSERT(ch);
188
189	valuestate = NULL;
190	new_idx = NULL;
191
192	pval = (struct table_value *)ch->valuestate;
193	vi = CHAIN_TO_VI(ch);
194	tcfg = CHAIN_TO_TCFG(ch);
195
196	val_size = tcfg->val_size * 2;
197
198	if (val_size == (1 << 30))
199		return (ENOSPC);
200
201	IPFW_UH_WUNLOCK(ch);
202
203	valuestate = malloc(sizeof(struct table_value) * val_size, M_IPFW,
204	    M_WAITOK | M_ZERO);
205	ipfw_objhash_bitmap_alloc(val_size, (void *)&new_idx,
206	    &new_blocks);
207
208	IPFW_UH_WLOCK(ch);
209
210	/*
211	 * Check if we still need to resize
212	 */
213	if (tcfg->val_size >= val_size)
214		goto done;
215
216	/* Update pointers and notify everyone we're changing @ch */
217	pval = (struct table_value *)ch->valuestate;
218	rollback_toperation_state(ch, ch);
219
220	/* Good. Let's merge */
221	memcpy(valuestate, pval, sizeof(struct table_value) * tcfg->val_size);
222	ipfw_objhash_bitmap_merge(CHAIN_TO_VI(ch), &new_idx, &new_blocks);
223
224	IPFW_WLOCK(ch);
225	/* Change pointers */
226	old_valuestate = ch->valuestate;
227	ch->valuestate = valuestate;
228	valuestate = old_valuestate;
229	ipfw_objhash_bitmap_swap(CHAIN_TO_VI(ch), &new_idx, &new_blocks);
230
231	val_size_old = tcfg->val_size;
232	tcfg->val_size = val_size;
233	val_size = val_size_old;
234	IPFW_WUNLOCK(ch);
235	/* Update pointers to reflect resize */
236	memset(&da, 0, sizeof(da));
237	da.pval = (struct table_value *)ch->valuestate;
238	ipfw_objhash_foreach(vi, update_tvalue, &da);
239
240done:
241	free(valuestate, M_IPFW);
242	ipfw_objhash_bitmap_free(new_idx, new_blocks);
243
244	return (0);
245}
246
247/*
248 * Drops reference for table value with index @kidx, stored in @pval and
249 * @vi. Frees value if it has no references.
250 */
251static void
252unref_table_value(struct namedobj_instance *vi, struct table_value *pval,
253    uint32_t kidx)
254{
255	struct table_val_link *ptvl;
256
257	KASSERT(pval[kidx].refcnt > 0, ("Refcount is 0 on kidx %d", kidx));
258	if (--pval[kidx].refcnt > 0)
259		return;
260
261	/* Last reference, delete item */
262	ptvl = (struct table_val_link *)ipfw_objhash_lookup_kidx(vi, kidx);
263	KASSERT(ptvl != NULL, ("lookup on value kidx %d failed", kidx));
264	ipfw_objhash_del(vi, &ptvl->no);
265	ipfw_objhash_free_idx(vi, kidx);
266	free(ptvl, M_IPFW);
267}
268
269struct flush_args {
270	struct ip_fw_chain *ch;
271	struct table_algo *ta;
272	struct table_info *ti;
273	void *astate;
274	ipfw_obj_tentry tent;
275};
276
277static int
278unref_table_value_cb(void *e, void *arg)
279{
280	struct flush_args *fa;
281	struct ip_fw_chain *ch;
282	struct table_algo *ta;
283	ipfw_obj_tentry *tent;
284	int error;
285
286	fa = (struct flush_args *)arg;
287
288	ta = fa->ta;
289	memset(&fa->tent, 0, sizeof(fa->tent));
290	tent = &fa->tent;
291	error = ta->dump_tentry(fa->astate, fa->ti, e, tent);
292	if (error != 0)
293		return (error);
294
295	ch = fa->ch;
296
297	unref_table_value(CHAIN_TO_VI(ch),
298	    (struct table_value *)ch->valuestate, tent->v.kidx);
299
300	return (0);
301}
302
303/*
304 * Drop references for each value used in @tc.
305 */
306void
307ipfw_unref_table_values(struct ip_fw_chain *ch, struct table_config *tc,
308    struct table_algo *ta, void *astate, struct table_info *ti)
309{
310	struct flush_args fa;
311
312	IPFW_UH_WLOCK_ASSERT(ch);
313
314	memset(&fa, 0, sizeof(fa));
315	fa.ch = ch;
316	fa.ta = ta;
317	fa.astate = astate;
318	fa.ti = ti;
319
320	ta->foreach(astate, ti, unref_table_value_cb, &fa);
321}
322
323/*
324 * Table operation state handler.
325 * Called when we are going to change something in @tc which
326 * may lead to inconsistencies in on-going table data addition.
327 *
328 * Here we rollback all already committed state (table values, currently)
329 * and set "modified" field to non-zero value to indicate
330 * that we need to restart original operation.
331 */
332void
333rollback_table_values(struct tableop_state *ts)
334{
335	struct ip_fw_chain *ch;
336	struct table_value *pval;
337	struct tentry_info *ptei;
338	struct namedobj_instance *vi;
339	int i;
340
341	ch = ts->ch;
342
343	IPFW_UH_WLOCK_ASSERT(ch);
344
345	/* Get current table value pointer */
346	get_value_ptrs(ch, ts->tc, ts->vshared, &pval, &vi);
347
348	for (i = 0; i < ts->count; i++) {
349		ptei = &ts->tei[i];
350
351		if (ptei->value == 0)
352			continue;
353
354		unref_table_value(vi, pval, ptei->value);
355	}
356}
357
358/*
359 * Allocate new value index in either shared or per-table array.
360 * Function may drop/reacquire UH lock.
361 *
362 * Returns 0 on success.
363 */
364static int
365alloc_table_vidx(struct ip_fw_chain *ch, struct tableop_state *ts,
366    struct namedobj_instance *vi, uint16_t *pvidx)
367{
368	int error, vlimit;
369	uint16_t vidx;
370
371	IPFW_UH_WLOCK_ASSERT(ch);
372
373	error = ipfw_objhash_alloc_idx(vi, &vidx);
374	if (error != 0) {
375
376		/*
377		 * We need to resize array. This involves
378		 * lock/unlock, so we need to check "modified"
379		 * state.
380		 */
381		ts->opstate.func(ts->tc, &ts->opstate);
382		error = resize_shared_value_storage(ch);
383		return (error); /* ts->modified should be set, we will restart */
384	}
385
386	vlimit = ts->ta->vlimit;
387	if (vlimit != 0 && vidx >= vlimit) {
388
389		/*
390		 * Algorithm is not able to store given index.
391		 * We have to rollback state, start using
392		 * per-table value array or return error
393		 * if we're already using it.
394		 *
395		 * TODO: do not rollback state if
396		 * atomicity is not required.
397		 */
398		if (ts->vshared != 0) {
399			/* shared -> per-table  */
400			return (ENOSPC); /* TODO: proper error */
401		}
402
403		/* per-table. Fail for now. */
404		return (ENOSPC); /* TODO: proper error */
405	}
406
407	*pvidx = vidx;
408	return (0);
409}
410
411/*
412 * Drops value reference for unused values (updates, deletes, partially
413 * successful adds or rollbacks).
414 */
415void
416ipfw_garbage_table_values(struct ip_fw_chain *ch, struct table_config *tc,
417    struct tentry_info *tei, uint32_t count, int rollback)
418{
419	int i;
420	struct tentry_info *ptei;
421	struct table_value *pval;
422	struct namedobj_instance *vi;
423
424	/*
425	 * We have two slightly different ADD cases here:
426	 * either (1) we are successful / partially successful,
427	 * in that case we need
428	 * * to ignore ADDED entries values
429	 * * rollback every other values (either UPDATED since
430	 *   old value has been stored there, or some failure like
431	 *   EXISTS or LIMIT or simply "ignored" case.
432	 *
433	 * (2): atomic rollback of partially successful operation
434	 * in that case we simply need to unref all entries.
435	 *
436	 * DELETE case is simpler: no atomic support there, so
437	 * we simply unref all non-zero values.
438	 */
439
440	/*
441	 * Get current table value pointers.
442	 * XXX: Properly read vshared
443	 */
444	get_value_ptrs(ch, tc, 1, &pval, &vi);
445
446	for (i = 0; i < count; i++) {
447		ptei = &tei[i];
448
449		if (ptei->value == 0) {
450
451			/*
452			 * We may be deleting non-existing record.
453			 * Skip.
454			 */
455			continue;
456		}
457
458		if ((ptei->flags & TEI_FLAGS_ADDED) != 0 && rollback == 0) {
459			ptei->value = 0;
460			continue;
461		}
462
463		unref_table_value(vi, pval, ptei->value);
464		ptei->value = 0;
465	}
466}
467
468/*
469 * Main function used to link values of entries going to be added,
470 * to the index. Since we may perform many UH locks drops/acquires,
471 * handle changes by checking tablestate "modified" field.
472 *
473 * Success: return 0.
474 */
475int
476ipfw_link_table_values(struct ip_fw_chain *ch, struct tableop_state *ts)
477{
478	int error, i, found;
479	struct namedobj_instance *vi;
480	struct table_config *tc;
481	struct tentry_info *tei, *ptei;
482	uint32_t count, vlimit;
483	uint16_t vidx;
484	struct table_val_link *ptv;
485	struct table_value tval, *pval;
486
487	/*
488	 * Stage 1: reference all existing values and
489	 * save their indices.
490	 */
491	IPFW_UH_WLOCK_ASSERT(ch);
492	get_value_ptrs(ch, ts->tc, ts->vshared, &pval, &vi);
493
494	error = 0;
495	found = 0;
496	vlimit = ts->ta->vlimit;
497	vidx = 0;
498	tc = ts->tc;
499	tei = ts->tei;
500	count = ts->count;
501	for (i = 0; i < count; i++) {
502		ptei = &tei[i];
503		ptei->value = 0; /* Ensure value is always 0 in the beginning */
504		mask_table_value(ptei->pvalue, &tval, ts->vmask);
505		ptv = (struct table_val_link *)ipfw_objhash_lookup_name(vi, 0,
506		    (char *)&tval);
507		if (ptv == NULL)
508			continue;
509		/* Deal with vlimit later */
510		if (vlimit > 0 && vlimit <= ptv->no.kidx)
511			continue;
512
513		/* Value found. Bump refcount */
514		ptv->pval->refcnt++;
515		ptei->value = ptv->no.kidx;
516		found++;
517	}
518
519	if (ts->count == found) {
520		/* We've found all values , no need ts create new ones */
521		return (0);
522	}
523
524	/*
525	 * we have added some state here, let's attach operation
526	 * state ts the list ts be able ts rollback if necessary.
527	 */
528	add_toperation_state(ch, ts);
529	/* Ensure table won't disappear */
530	tc_ref(tc);
531	IPFW_UH_WUNLOCK(ch);
532
533	/*
534	 * Stage 2: allocate objects for non-existing values.
535	 */
536	for (i = 0; i < count; i++) {
537		ptei = &tei[i];
538		if (ptei->value != 0)
539			continue;
540		if (ptei->ptv != NULL)
541			continue;
542		ptei->ptv = malloc(sizeof(struct table_val_link), M_IPFW,
543		    M_WAITOK | M_ZERO);
544	}
545
546	/*
547	 * Stage 3: allocate index numbers for new values
548	 * and link them to index.
549	 */
550	IPFW_UH_WLOCK(ch);
551	tc_unref(tc);
552	del_toperation_state(ch, ts);
553	if (ts->modified != 0) {
554
555		/*
556		 * In general, we should free all state/indexes here
557		 * and return. However, we keep allocated state instead
558		 * to ensure we achieve some progress on each restart.
559		 */
560		return (0);
561	}
562
563	KASSERT(pval == ch->valuestate, ("resize_storage() notify failure"));
564
565	/* Let's try to link values */
566	for (i = 0; i < count; i++) {
567		ptei = &tei[i];
568
569		/* Check if record has appeared */
570		mask_table_value(ptei->pvalue, &tval, ts->vmask);
571		ptv = (struct table_val_link *)ipfw_objhash_lookup_name(vi, 0,
572		    (char *)&tval);
573		if (ptv != NULL) {
574			ptv->pval->refcnt++;
575			ptei->value = ptv->no.kidx;
576			continue;
577		}
578
579		/* May perform UH unlock/lock */
580		error = alloc_table_vidx(ch, ts, vi, &vidx);
581		if (error != 0) {
582			ts->opstate.func(ts->tc, &ts->opstate);
583			return (error);
584		}
585		/* value storage resize has happened, return */
586		if (ts->modified != 0)
587			return (0);
588
589		/* Finally, we have allocated valid index, let's add entry */
590		ptei->value = vidx;
591		ptv = (struct table_val_link *)ptei->ptv;
592		ptei->ptv = NULL;
593
594		ptv->no.kidx = vidx;
595		ptv->no.name = (char *)&pval[vidx];
596		ptv->pval = &pval[vidx];
597		memcpy(ptv->pval, &tval, sizeof(struct table_value));
598		pval[vidx].refcnt = 1;
599		ipfw_objhash_add(vi, &ptv->no);
600	}
601
602	return (0);
603}
604
605/*
606 * Compatibility function used to import data from old
607 * IP_FW_TABLE_ADD / IP_FW_TABLE_XADD opcodes.
608 */
609void
610ipfw_import_table_value_legacy(uint32_t value, struct table_value *v)
611{
612
613	memset(v, 0, sizeof(*v));
614	v->tag = value;
615	v->pipe = value;
616	v->divert = value;
617	v->skipto = value;
618	v->netgraph = value;
619	v->fib = value;
620	v->nat = value;
621	v->nh4 = value; /* host format */
622	v->dscp = value;
623	v->limit = value;
624}
625
626/*
627 * Export data to legacy table dumps opcodes.
628 */
629uint32_t
630ipfw_export_table_value_legacy(struct table_value *v)
631{
632
633	/*
634	 * TODO: provide more compatibility depending on
635	 * vmask value.
636	 */
637	return (v->tag);
638}
639
640/*
641 * Imports table value from current userland format.
642 * Saves value in kernel format to the same place.
643 */
644void
645ipfw_import_table_value_v1(ipfw_table_value *iv)
646{
647	struct table_value v;
648
649	memset(&v, 0, sizeof(v));
650	v.tag = iv->tag;
651	v.pipe = iv->pipe;
652	v.divert = iv->divert;
653	v.skipto = iv->skipto;
654	v.netgraph = iv->netgraph;
655	v.fib = iv->fib;
656	v.nat = iv->nat;
657	v.dscp = iv->dscp;
658	v.nh4 = iv->nh4;
659	v.nh6 = iv->nh6;
660	v.limit = iv->limit;
661	v.zoneid = iv->zoneid;
662
663	memcpy(iv, &v, sizeof(ipfw_table_value));
664}
665
666/*
667 * Export real table value @v to current userland format.
668 * Note that @v and @piv may point to the same memory.
669 */
670void
671ipfw_export_table_value_v1(struct table_value *v, ipfw_table_value *piv)
672{
673	ipfw_table_value iv;
674
675	memset(&iv, 0, sizeof(iv));
676	iv.tag = v->tag;
677	iv.pipe = v->pipe;
678	iv.divert = v->divert;
679	iv.skipto = v->skipto;
680	iv.netgraph = v->netgraph;
681	iv.fib = v->fib;
682	iv.nat = v->nat;
683	iv.dscp = v->dscp;
684	iv.limit = v->limit;
685	iv.nh4 = v->nh4;
686	iv.nh6 = v->nh6;
687	iv.zoneid = v->zoneid;
688
689	memcpy(piv, &iv, sizeof(iv));
690}
691
692/*
693 * Exports real value data into ipfw_table_value structure.
694 * Utilizes "spare1" field to store kernel index.
695 */
696static int
697dump_tvalue(struct namedobj_instance *ni, struct named_object *no, void *arg)
698{
699	struct vdump_args *da;
700	struct table_val_link *ptv;
701	struct table_value *v;
702
703	da = (struct vdump_args *)arg;
704	ptv = (struct table_val_link *)no;
705
706	v = (struct table_value *)ipfw_get_sopt_space(da->sd, sizeof(*v));
707	/* Out of memory, returning */
708	if (v == NULL) {
709		da->error = ENOMEM;
710		return (ENOMEM);
711	}
712
713	memcpy(v, ptv->pval, sizeof(*v));
714	v->spare1 = ptv->no.kidx;
715	return (0);
716}
717
718/*
719 * Dumps all shared/table value data
720 * Data layout (v1)(current):
721 * Request: [ ipfw_obj_lheader ], size = ipfw_obj_lheader.size
722 * Reply: [ ipfw_obj_lheader ipfw_table_value x N ]
723 *
724 * Returns 0 on success
725 */
726static int
727list_table_values(struct ip_fw_chain *ch, ip_fw3_opheader *op3,
728    struct sockopt_data *sd)
729{
730	struct _ipfw_obj_lheader *olh;
731	struct namedobj_instance *vi;
732	struct vdump_args da;
733	uint32_t count, size;
734
735	olh = (struct _ipfw_obj_lheader *)ipfw_get_sopt_header(sd,sizeof(*olh));
736	if (olh == NULL)
737		return (EINVAL);
738	if (sd->valsize < olh->size)
739		return (EINVAL);
740
741	IPFW_UH_RLOCK(ch);
742	vi = CHAIN_TO_VI(ch);
743
744	count = ipfw_objhash_count(vi);
745	size = count * sizeof(ipfw_table_value) + sizeof(ipfw_obj_lheader);
746
747	/* Fill in header regadless of buffer size */
748	olh->count = count;
749	olh->objsize = sizeof(ipfw_table_value);
750
751	if (size > olh->size) {
752		olh->size = size;
753		IPFW_UH_RUNLOCK(ch);
754		return (ENOMEM);
755	}
756	olh->size = size;
757
758	/*
759	 * Do the actual value dump
760	 */
761	memset(&da, 0, sizeof(da));
762	da.ch = ch;
763	da.sd = sd;
764	ipfw_objhash_foreach(vi, dump_tvalue, &da);
765
766	IPFW_UH_RUNLOCK(ch);
767
768	return (0);
769}
770
771void
772ipfw_table_value_init(struct ip_fw_chain *ch, int first)
773{
774	struct tables_config *tcfg;
775
776	ch->valuestate = malloc(VALDATA_START_SIZE * sizeof(struct table_value),
777	    M_IPFW, M_WAITOK | M_ZERO);
778
779	tcfg = ch->tblcfg;
780
781	tcfg->val_size = VALDATA_START_SIZE;
782	tcfg->valhash = ipfw_objhash_create(tcfg->val_size);
783	ipfw_objhash_set_funcs(tcfg->valhash, hash_table_value,
784	    cmp_table_value);
785
786	IPFW_ADD_SOPT_HANDLER(first, scodes);
787}
788
789static int
790destroy_value(struct namedobj_instance *ni, struct named_object *no,
791    void *arg)
792{
793
794	free(no, M_IPFW);
795	return (0);
796}
797
798void
799ipfw_table_value_destroy(struct ip_fw_chain *ch, int last)
800{
801
802	IPFW_DEL_SOPT_HANDLER(last, scodes);
803
804	free(ch->valuestate, M_IPFW);
805	ipfw_objhash_foreach(CHAIN_TO_VI(ch), destroy_value, ch);
806	ipfw_objhash_destroy(CHAIN_TO_VI(ch));
807}
808
809