sys/netproto/key/keydb.c

   1 /*      $FreeBSD: src/sys/netkey/keydb.c,v 1.1.2.1 2000/07/15 07:14:42 kris Exp $       */
   2 /*      $DragonFly: src/sys/netproto/key/keydb.c,v 1.7 2005/06/10 22:34:50 dillon Exp $ */
   3 /*      $KAME: keydb.c,v 1.64 2000/05/11 17:02:30 itojun Exp $  */
   4
   5 /*
   6  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. Neither the name of the project nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "opt_inet.h"
  35 #include "opt_inet6.h"
  36
  37 #include <sys/param.h>
  38 #include <sys/types.h>
  39 #include <sys/socket.h>
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/kernel.h>
  43 #include <sys/malloc.h>
  44 #include <sys/errno.h>
  45 #include <sys/queue.h>
  46 #include <sys/thread2.h>
  47
  48 #include <net/if.h>
  49 #include <net/route.h>
  50
  51 #include <netinet/in.h>
  52
  53 #include <net/pfkeyv2.h>
  54 #include "keydb.h"
  55 #include <netinet6/ipsec.h>
  56
  57 #include <net/net_osdep.h>
  58
  59 MALLOC_DEFINE(M_SECA, "key mgmt", "security associations, key management");
  60
  61 static void keydb_delsecasvar (struct secasvar *);
  62
  63 /*
  64  * secpolicy management
  65  */
  66 struct secpolicy *
  67 keydb_newsecpolicy()
  68 {
  69         struct secpolicy *p;
  70
  71         p = malloc(sizeof(*p), M_SECA, M_INTWAIT | M_NULLOK);
  72         if (!p)
  73                 return p;
  74         bzero(p, sizeof(*p));
  75         return p;
  76 }
  77
  78 void
  79 keydb_delsecpolicy(p)
  80         struct secpolicy *p;
  81 {
  82
  83         free(p, M_SECA);
  84 }
  85
  86 /*
  87  * secashead management
  88  */
  89 struct secashead *
  90 keydb_newsecashead()
  91 {
  92         struct secashead *p;
  93         int i;
  94
  95         p = malloc(sizeof(*p), M_SECA, M_INTWAIT | M_NULLOK);
  96         if (!p)
  97                 return p;
  98         bzero(p, sizeof(*p));
  99         for (i = 0; i < sizeof(p->savtree)/sizeof(p->savtree[0]); i++)
 100                 LIST_INIT(&p->savtree[i]);
 101         return p;
 102 }
 103
 104 void
 105 keydb_delsecashead(p)
 106         struct secashead *p;
 107 {
 108
 109         free(p, M_SECA);
 110 }
 111
 112 /*
 113  * secasvar management (reference counted)
 114  */
 115 struct secasvar *
 116 keydb_newsecasvar()
 117 {
 118         struct secasvar *p;
 119
 120         p = malloc(sizeof(*p), M_SECA, M_INTWAIT | M_NULLOK);
 121         if (!p)
 122                 return p;
 123         bzero(p, sizeof(*p));
 124         p->refcnt = 1;
 125         return p;
 126 }
 127
 128 void
 129 keydb_refsecasvar(p)
 130         struct secasvar *p;
 131 {
 132         crit_enter();
 133         p->refcnt++;
 134         crit_exit();
 135 }
 136
 137 void
 138 keydb_freesecasvar(p)
 139         struct secasvar *p;
 140 {
 141         crit_enter();
 142         p->refcnt--;
 143         /* negative refcnt will cause panic intentionally */
 144         if (p->refcnt <= 0)
 145                 keydb_delsecasvar(p);
 146         crit_exit();
 147 }
 148
 149 static void
 150 keydb_delsecasvar(p)
 151         struct secasvar *p;
 152 {
 153
 154         if (p->refcnt)
 155                 panic("keydb_delsecasvar called with refcnt != 0");
 156
 157         free(p, M_SECA);
 158 }
 159
 160 /*
 161  * secreplay management
 162  */
 163 struct secreplay *
 164 keydb_newsecreplay(wsize)
 165         size_t wsize;
 166 {
 167         struct secreplay *p;
 168
 169         p = malloc(sizeof(*p), M_SECA, M_INTWAIT | M_NULLOK);
 170         if (!p)
 171                 return p;
 172
 173         bzero(p, sizeof(*p));
 174         if (wsize != 0) {
 175                 p->bitmap = (caddr_t)malloc(wsize, M_SECA, M_INTWAIT | M_NULLOK);
 176                 if (!p->bitmap) {
 177                         free(p, M_SECA);
 178                         return NULL;
 179                 }
 180                 bzero(p->bitmap, wsize);
 181         }
 182         p->wsize = wsize;
 183         return p;
 184 }
 185
 186 void
 187 keydb_delsecreplay(p)
 188         struct secreplay *p;
 189 {
 190
 191         if (p->bitmap)
 192                 free(p->bitmap, M_SECA);
 193         free(p, M_SECA);
 194 }
 195
 196 /*
 197  * secreg management
 198  */
 199 struct secreg *
 200 keydb_newsecreg()
 201 {
 202         struct secreg *p;
 203
 204         p = malloc(sizeof(*p), M_SECA, M_INTWAIT | M_ZERO | M_NULLOK);
 205         return p;
 206 }
 207
 208 void
 209 keydb_delsecreg(p)
 210         struct secreg *p;
 211 {
 212
 213         free(p, M_SECA);
 214 }