- Rewrite Buffer object to maintain only write pointer. There is no
[dragonfly.git] / 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 }