sys/netpfil/ipfw/ip_fw_table_value.c

   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$");
  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
  61 static uint32_t hash_table_value(struct namedobj_instance *ni, const void *key,
  62     uint32_t kopt);
  63 static int cmp_table_value(struct named_object *no, const void *key,
  64     uint32_t kopt);
  65
  66 static int list_table_values(struct ip_fw_chain *ch, ip_fw3_opheader *op3,
  67     struct sockopt_data *sd);
  68
  69 static 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
  75 struct 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
  82 struct vdump_args {
  83         struct ip_fw_chain *ch;
  84         struct sockopt_data *sd;
  85         struct table_value *pval;
  86         int error;
  87 };
  88
  89
  90 static uint32_t
  91 hash_table_value(struct namedobj_instance *ni, const void *key, uint32_t kopt)
  92 {
  93
  94         return (hash32_buf(key, 56, 0));
  95 }
  96
  97 static int
  98 cmp_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
 104 static void
 105 mask_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
 125 static void
 126 get_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  */
 150 static int
 151 update_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  */
 176 static int
 177 resize_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
 240 done:
 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  */
 251 static void
 252 unref_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
 269 struct 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
 277 static int
 278 unref_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  */
 306 void
 307 ipfw_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  */
 332 void
 333 rollback_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  */
 364 static int
 365 alloc_table_vidx(struct ip_fw_chain *ch, struct tableop_state *ts,
 366     struct namedobj_instance *vi, uint16_t *pvidx, uint8_t flags)
 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 && !(flags & IPFW_CTF_ATOMIC)) {
 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                 if (ts->vshared != 0) {
 396                         /* shared -> per-table  */
 397                         return (ENOSPC); /* TODO: proper error */
 398                 }
 399
 400                 /* per-table. Fail for now. */
 401                 return (ENOSPC); /* TODO: proper error */
 402         }
 403
 404         *pvidx = vidx;
 405         return (0);
 406 }
 407
 408 /*
 409  * Drops value reference for unused values (updates, deletes, partially
 410  * successful adds or rollbacks).
 411  */
 412 void
 413 ipfw_garbage_table_values(struct ip_fw_chain *ch, struct table_config *tc,
 414     struct tentry_info *tei, uint32_t count, int rollback)
 415 {
 416         int i;
 417         struct tentry_info *ptei;
 418         struct table_value *pval;
 419         struct namedobj_instance *vi;
 420
 421         /*
 422          * We have two slightly different ADD cases here:
 423          * either (1) we are successful / partially successful,
 424          * in that case we need
 425          * * to ignore ADDED entries values
 426          * * rollback every other values if atomicity is not
 427          * * required (either UPDATED since old value has been
 428          *   stored there, or some failure like EXISTS or LIMIT
 429          *   or simply "ignored" case.
 430          *
 431          * (2): atomic rollback of partially successful operation
 432          * in that case we simply need to unref all entries.
 433          *
 434          * DELETE case is simpler: no atomic support there, so
 435          * we simply unref all non-zero values.
 436          */
 437
 438         /*
 439          * Get current table value pointers.
 440          * XXX: Properly read vshared
 441          */
 442         get_value_ptrs(ch, tc, 1, &pval, &vi);
 443
 444         for (i = 0; i < count; i++) {
 445                 ptei = &tei[i];
 446
 447                 if (ptei->value == 0) {
 448
 449                         /*
 450                          * We may be deleting non-existing record.
 451                          * Skip.
 452                          */
 453                         continue;
 454                 }
 455
 456                 if ((ptei->flags & TEI_FLAGS_ADDED) != 0 && rollback == 0) {
 457                         ptei->value = 0;
 458                         continue;
 459                 }
 460
 461                 unref_table_value(vi, pval, ptei->value);
 462                 ptei->value = 0;
 463         }
 464 }
 465
 466 /*
 467  * Main function used to link values of entries going to be added,
 468  * to the index. Since we may perform many UH locks drops/acquires,
 469  * handle changes by checking tablestate "modified" field.
 470  *
 471  * Success: return 0.
 472  */
 473 int
 474 ipfw_link_table_values(struct ip_fw_chain *ch, struct tableop_state *ts,
 475     uint8_t flags)
 476 {
 477         int error, i, found;
 478         struct namedobj_instance *vi;
 479         struct table_config *tc;
 480         struct tentry_info *tei, *ptei;
 481         uint32_t count, vlimit;
 482         uint16_t vidx;
 483         struct table_val_link *ptv;
 484         struct table_value tval, *pval;
 485
 486         /*
 487          * Stage 1: reference all existing values and
 488          * save their indices.
 489          */
 490         IPFW_UH_WLOCK_ASSERT(ch);
 491         get_value_ptrs(ch, ts->tc, ts->vshared, &pval, &vi);
 492
 493         error = 0;
 494         found = 0;
 495         vlimit = ts->ta->vlimit;
 496         vidx = 0;
 497         tc = ts->tc;
 498         tei = ts->tei;
 499         count = ts->count;
 500         for (i = 0; i < count; i++) {
 501                 ptei = &tei[i];
 502                 ptei->value = 0; /* Ensure value is always 0 in the beginning */
 503                 mask_table_value(ptei->pvalue, &tval, ts->vmask);
 504                 ptv = (struct table_val_link *)ipfw_objhash_lookup_name(vi, 0,
 505                     (char *)&tval);
 506                 if (ptv == NULL)
 507                         continue;
 508                 /* Deal with vlimit later */
 509                 if (vlimit > 0 && vlimit <= ptv->no.kidx)
 510                         continue;
 511
 512                 /* Value found. Bump refcount */
 513                 ptv->pval->refcnt++;
 514                 ptei->value = ptv->no.kidx;
 515                 found++;
 516         }
 517
 518         if (ts->count == found) {
 519                 /* We've found all values , no need ts create new ones */
 520                 return (0);
 521         }
 522
 523         /*
 524          * we have added some state here, let's attach operation
 525          * state ts the list ts be able ts rollback if necessary.
 526          */
 527         add_toperation_state(ch, ts);
 528         /* Ensure table won't disappear */
 529         tc_ref(tc);
 530         IPFW_UH_WUNLOCK(ch);
 531
 532         /*
 533          * Stage 2: allocate objects for non-existing values.
 534          */
 535         for (i = 0; i < count; i++) {
 536                 ptei = &tei[i];
 537                 if (ptei->value != 0)
 538                         continue;
 539                 if (ptei->ptv != NULL)
 540                         continue;
 541                 ptei->ptv = malloc(sizeof(struct table_val_link), M_IPFW,
 542                     M_WAITOK | M_ZERO);
 543         }
 544
 545         /*
 546          * Stage 3: allocate index numbers for new values
 547          * and link them to index.
 548          */
 549         IPFW_UH_WLOCK(ch);
 550         tc_unref(tc);
 551         del_toperation_state(ch, ts);
 552         if (ts->modified != 0) {
 553
 554                 /*
 555                  * In general, we should free all state/indexes here
 556                  * and return. However, we keep allocated state instead
 557                  * to ensure we achieve some progress on each restart.
 558                  */
 559                 return (0);
 560         }
 561
 562         KASSERT(pval == ch->valuestate, ("resize_storage() notify failure"));
 563
 564         /* Let's try to link values */
 565         for (i = 0; i < count; i++) {
 566                 ptei = &tei[i];
 567
 568                 /* Check if record has appeared */
 569                 mask_table_value(ptei->pvalue, &tval, ts->vmask);
 570                 ptv = (struct table_val_link *)ipfw_objhash_lookup_name(vi, 0,
 571                     (char *)&tval);
 572                 if (ptv != NULL) {
 573                         ptv->pval->refcnt++;
 574                         ptei->value = ptv->no.kidx;
 575                         continue;
 576                 }
 577
 578                 /* May perform UH unlock/lock */
 579                 error = alloc_table_vidx(ch, ts, vi, &vidx, flags);
 580                 if (error != 0) {
 581                         ts->opstate.func(ts->tc, &ts->opstate);
 582                         return (error);
 583                 }
 584                 /* value storage resize has happened, return */
 585                 if (ts->modified != 0)
 586                         return (0);
 587
 588                 /* Finally, we have allocated valid index, let's add entry */
 589                 ptei->value = vidx;
 590                 ptv = (struct table_val_link *)ptei->ptv;
 591                 ptei->ptv = NULL;
 592
 593                 ptv->no.kidx = vidx;
 594                 ptv->no.name = (char *)&pval[vidx];
 595                 ptv->pval = &pval[vidx];
 596                 memcpy(ptv->pval, &tval, sizeof(struct table_value));
 597                 pval[vidx].refcnt = 1;
 598                 ipfw_objhash_add(vi, &ptv->no);
 599         }
 600
 601         return (0);
 602 }
 603
 604 /*
 605  * Compatibility function used to import data from old
 606  * IP_FW_TABLE_ADD / IP_FW_TABLE_XADD opcodes.
 607  */
 608 void
 609 ipfw_import_table_value_legacy(uint32_t value, struct table_value *v)
 610 {
 611
 612         memset(v, 0, sizeof(*v));
 613         v->tag = value;
 614         v->pipe = value;
 615         v->divert = value;
 616         v->skipto = value;
 617         v->netgraph = value;
 618         v->fib = value;
 619         v->nat = value;
 620         v->nh4 = value; /* host format */
 621         v->dscp = value;
 622         v->limit = value;
 623 }
 624
 625 /*
 626  * Export data to legacy table dumps opcodes.
 627  */
 628 uint32_t
 629 ipfw_export_table_value_legacy(struct table_value *v)
 630 {
 631
 632         /*
 633          * TODO: provide more compatibility depending on
 634          * vmask value.
 635          */
 636         return (v->tag);
 637 }
 638
 639 /*
 640  * Imports table value from current userland format.
 641  * Saves value in kernel format to the same place.
 642  */
 643 void
 644 ipfw_import_table_value_v1(ipfw_table_value *iv)
 645 {
 646         struct table_value v;
 647
 648         memset(&v, 0, sizeof(v));
 649         v.tag = iv->tag;
 650         v.pipe = iv->pipe;
 651         v.divert = iv->divert;
 652         v.skipto = iv->skipto;
 653         v.netgraph = iv->netgraph;
 654         v.fib = iv->fib;
 655         v.nat = iv->nat;
 656         v.dscp = iv->dscp;
 657         v.nh4 = iv->nh4;
 658         v.nh6 = iv->nh6;
 659         v.limit = iv->limit;
 660         v.zoneid = iv->zoneid;
 661
 662         memcpy(iv, &v, sizeof(ipfw_table_value));
 663 }
 664
 665 /*
 666  * Export real table value @v to current userland format.
 667  * Note that @v and @piv may point to the same memory.
 668  */
 669 void
 670 ipfw_export_table_value_v1(struct table_value *v, ipfw_table_value *piv)
 671 {
 672         ipfw_table_value iv;
 673
 674         memset(&iv, 0, sizeof(iv));
 675         iv.tag = v->tag;
 676         iv.pipe = v->pipe;
 677         iv.divert = v->divert;
 678         iv.skipto = v->skipto;
 679         iv.netgraph = v->netgraph;
 680         iv.fib = v->fib;
 681         iv.nat = v->nat;
 682         iv.dscp = v->dscp;
 683         iv.limit = v->limit;
 684         iv.nh4 = v->nh4;
 685         iv.nh6 = v->nh6;
 686         iv.zoneid = v->zoneid;
 687
 688         memcpy(piv, &iv, sizeof(iv));
 689 }
 690
 691 /*
 692  * Exports real value data into ipfw_table_value structure.
 693  * Utilizes "spare1" field to store kernel index.
 694  */
 695 static int
 696 dump_tvalue(struct namedobj_instance *ni, struct named_object *no, void *arg)
 697 {
 698         struct vdump_args *da;
 699         struct table_val_link *ptv;
 700         struct table_value *v;
 701
 702         da = (struct vdump_args *)arg;
 703         ptv = (struct table_val_link *)no;
 704
 705         v = (struct table_value *)ipfw_get_sopt_space(da->sd, sizeof(*v));
 706         /* Out of memory, returning */
 707         if (v == NULL) {
 708                 da->error = ENOMEM;
 709                 return (ENOMEM);
 710         }
 711
 712         memcpy(v, ptv->pval, sizeof(*v));
 713         v->spare1 = ptv->no.kidx;
 714         return (0);
 715 }
 716
 717 /*
 718  * Dumps all shared/table value data
 719  * Data layout (v1)(current):
 720  * Request: [ ipfw_obj_lheader ], size = ipfw_obj_lheader.size
 721  * Reply: [ ipfw_obj_lheader ipfw_table_value x N ]
 722  *
 723  * Returns 0 on success
 724  */
 725 static int
 726 list_table_values(struct ip_fw_chain *ch, ip_fw3_opheader *op3,
 727     struct sockopt_data *sd)
 728 {
 729         struct _ipfw_obj_lheader *olh;
 730         struct namedobj_instance *vi;
 731         struct vdump_args da;
 732         uint32_t count, size;
 733
 734         olh = (struct _ipfw_obj_lheader *)ipfw_get_sopt_header(sd,sizeof(*olh));
 735         if (olh == NULL)
 736                 return (EINVAL);
 737         if (sd->valsize < olh->size)
 738                 return (EINVAL);
 739
 740         IPFW_UH_RLOCK(ch);
 741         vi = CHAIN_TO_VI(ch);
 742
 743         count = ipfw_objhash_count(vi);
 744         size = count * sizeof(ipfw_table_value) + sizeof(ipfw_obj_lheader);
 745
 746         /* Fill in header regadless of buffer size */
 747         olh->count = count;
 748         olh->objsize = sizeof(ipfw_table_value);
 749
 750         if (size > olh->size) {
 751                 olh->size = size;
 752                 IPFW_UH_RUNLOCK(ch);
 753                 return (ENOMEM);
 754         }
 755         olh->size = size;
 756
 757         /*
 758          * Do the actual value dump
 759          */
 760         memset(&da, 0, sizeof(da));
 761         da.ch = ch;
 762         da.sd = sd;
 763         ipfw_objhash_foreach(vi, dump_tvalue, &da);
 764
 765         IPFW_UH_RUNLOCK(ch);
 766
 767         return (0);
 768 }
 769
 770 void
 771 ipfw_table_value_init(struct ip_fw_chain *ch, int first)
 772 {
 773         struct tables_config *tcfg;
 774
 775         ch->valuestate = malloc(VALDATA_START_SIZE * sizeof(struct table_value),
 776             M_IPFW, M_WAITOK | M_ZERO);
 777
 778         tcfg = ch->tblcfg;
 779
 780         tcfg->val_size = VALDATA_START_SIZE;
 781         tcfg->valhash = ipfw_objhash_create(tcfg->val_size);
 782         ipfw_objhash_set_funcs(tcfg->valhash, hash_table_value,
 783             cmp_table_value);
 784
 785         IPFW_ADD_SOPT_HANDLER(first, scodes);
 786 }
 787
 788 static int
 789 destroy_value(struct namedobj_instance *ni, struct named_object *no,
 790     void *arg)
 791 {
 792
 793         free(no, M_IPFW);
 794         return (0);
 795 }
 796
 797 void
 798 ipfw_table_value_destroy(struct ip_fw_chain *ch, int last)
 799 {
 800
 801         IPFW_DEL_SOPT_HANDLER(last, scodes);
 802
 803         free(ch->valuestate, M_IPFW);
 804         ipfw_objhash_foreach(CHAIN_TO_VI(ch), destroy_value, ch);
 805         ipfw_objhash_destroy(CHAIN_TO_VI(ch));
 806 }
 807