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.6 2004/04/22 05:09: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
  47 #include <net/if.h>
  48 #include <net/route.h>
  49
  50 #include <netinet/in.h>
  51
  52 #include <net/pfkeyv2.h>
  53 #include "keydb.h"
  54 #include <netinet6/ipsec.h>
  55
  56 #include <net/net_osdep.h>
  57
  58 MALLOC_DEFINE(M_SECA, "key mgmt", "security associations, key management");
  59
  60 static void keydb_delsecasvar (struct secasvar *);
  61
  62 /*
  63  * secpolicy management
  64  */
  65 struct secpolicy *
  66 keydb_newsecpolicy()
  67 {
  68         struct secpolicy *p;
  69
  70         p = malloc(sizeof(*p), M_SECA, M_INTWAIT | M_NULLOK);
  71         if (!p)
  72                 return p;
  73         bzero(p, sizeof(*p));
  74         return p;
  75 }
  76
  77 void
  78 keydb_delsecpolicy(p)
  79         struct secpolicy *p;
  80 {
  81
  82         free(p, M_SECA);
  83 }
  84
  85 /*
  86  * secashead management
  87  */
  88 struct secashead *
  89 keydb_newsecashead()
  90 {
  91         struct secashead *p;
  92         int i;
  93
  94         p = malloc(sizeof(*p), M_SECA, M_INTWAIT | M_NULLOK);
  95         if (!p)
  96                 return p;
  97         bzero(p, sizeof(*p));
  98         for (i = 0; i < sizeof(p->savtree)/sizeof(p->savtree[0]); i++)
  99                 LIST_INIT(&p->savtree[i]);
 100         return p;
 101 }
 102
 103 void
 104 keydb_delsecashead(p)
 105         struct secashead *p;
 106 {
 107
 108         free(p, M_SECA);
 109 }
 110
 111 /*
 112  * secasvar management (reference counted)
 113  */
 114 struct secasvar *
 115 keydb_newsecasvar()
 116 {
 117         struct secasvar *p;
 118
 119         p = malloc(sizeof(*p), M_SECA, M_INTWAIT | M_NULLOK);
 120         if (!p)
 121                 return p;
 122         bzero(p, sizeof(*p));
 123         p->refcnt = 1;
 124         return p;
 125 }
 126
 127 void
 128 keydb_refsecasvar(p)
 129         struct secasvar *p;
 130 {
 131         int s;
 132
 133         s = splnet();
 134         p->refcnt++;
 135         splx(s);
 136 }
 137
 138 void
 139 keydb_freesecasvar(p)
 140         struct secasvar *p;
 141 {
 142         int s;
 143
 144         s = splnet();
 145         p->refcnt--;
 146         /* negative refcnt will cause panic intentionally */
 147         if (p->refcnt <= 0)
 148                 keydb_delsecasvar(p);
 149         splx(s);
 150 }
 151
 152 static void
 153 keydb_delsecasvar(p)
 154         struct secasvar *p;
 155 {
 156
 157         if (p->refcnt)
 158                 panic("keydb_delsecasvar called with refcnt != 0");
 159
 160         free(p, M_SECA);
 161 }
 162
 163 /*
 164  * secreplay management
 165  */
 166 struct secreplay *
 167 keydb_newsecreplay(wsize)
 168         size_t wsize;
 169 {
 170         struct secreplay *p;
 171
 172         p = malloc(sizeof(*p), M_SECA, M_INTWAIT | M_NULLOK);
 173         if (!p)
 174                 return p;
 175
 176         bzero(p, sizeof(*p));
 177         if (wsize != 0) {
 178                 p->bitmap = (caddr_t)malloc(wsize, M_SECA, M_INTWAIT | M_NULLOK);
 179                 if (!p->bitmap) {
 180                         free(p, M_SECA);
 181                         return NULL;
 182                 }
 183                 bzero(p->bitmap, wsize);
 184         }
 185         p->wsize = wsize;
 186         return p;
 187 }
 188
 189 void
 190 keydb_delsecreplay(p)
 191         struct secreplay *p;
 192 {
 193
 194         if (p->bitmap)
 195                 free(p->bitmap, M_SECA);
 196         free(p, M_SECA);
 197 }
 198
 199 /*
 200  * secreg management
 201  */
 202 struct secreg *
 203 keydb_newsecreg()
 204 {
 205         struct secreg *p;
 206
 207         p = malloc(sizeof(*p), M_SECA, M_INTWAIT | M_ZERO | M_NULLOK);
 208         return p;
 209 }
 210
 211 void
 212 keydb_delsecreg(p)
 213         struct secreg *p;
 214 {
 215
 216         free(p, M_SECA);
 217 }