1 /* $NetBSD: uipc_domain.c,v 1.39 2003/06/23 11:02:06 martin Exp $ */ 2 3 /* 4 * Copyright (c) 1982, 1986, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by the University of 18 * California, Berkeley and its contributors. 19 * 4. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 * 35 * @(#)uipc_domain.c 8.3 (Berkeley) 2/14/95 36 */ 37 38 #include <sys/cdefs.h> 39 __KERNEL_RCSID(0, "$NetBSD: uipc_domain.c,v 1.39 2003/06/23 11:02:06 martin Exp $"); 40 41 #include "opt_inet.h" 42 #include "opt_ipsec.h" 43 #include "opt_atalk.h" 44 #include "opt_ccitt.h" 45 #include "opt_iso.h" 46 #include "opt_ns.h" 47 #include "opt_mbuftrace.h" 48 #include "opt_natm.h" 49 #include "arp.h" 50 51 #include <sys/param.h> 52 #include <sys/socket.h> 53 #include <sys/protosw.h> 54 #include <sys/domain.h> 55 #include <sys/mbuf.h> 56 #include <sys/time.h> 57 #include <sys/kernel.h> 58 #include <sys/systm.h> 59 #include <sys/callout.h> 60 #include <sys/proc.h> 61 #include <sys/sysctl.h> 62 63 void pffasttimo __P((void *)); 64 void pfslowtimo __P((void *)); 65 66 struct domain *domains; 67 68 struct callout pffasttimo_ch, pfslowtimo_ch; 69 70 /* 71 * Current time values for fast and slow timeouts. We can use u_int 72 * relatively safely. The fast timer will roll over in 27 years and 73 * the slow timer in 68 years. 74 */ 75 u_int pfslowtimo_now; 76 u_int pffasttimo_now; 77 78 #define ADDDOMAIN(x) { \ 79 extern struct domain __CONCAT(x,domain); \ 80 __CONCAT(x,domain.dom_next) = domains; \ 81 domains = &__CONCAT(x,domain); \ 82 } 83 84 void 85 domaininit() 86 { 87 struct domain *dp; 88 struct protosw *pr; 89 90 #undef unix 91 /* 92 * KAME NOTE: ADDDOMAIN(route) is moved to the last part so that 93 * it will be initialized as the *first* element. confusing! 94 */ 95 #ifndef lint 96 ADDDOMAIN(unix); 97 #ifdef INET 98 ADDDOMAIN(inet); 99 #endif 100 #ifdef INET6 101 ADDDOMAIN(inet6); 102 #endif 103 #ifdef NS 104 ADDDOMAIN(ns); 105 #endif 106 #ifdef ISO 107 ADDDOMAIN(iso); 108 #endif 109 #ifdef CCITT 110 ADDDOMAIN(ccitt); 111 #endif 112 #ifdef NATM 113 ADDDOMAIN(natm); 114 #endif 115 #ifdef NETATALK 116 ADDDOMAIN(atalk); 117 #endif 118 #ifdef IPSEC 119 ADDDOMAIN(key); 120 #endif 121 #ifdef INET 122 #if NARP > 0 123 ADDDOMAIN(arp); 124 #endif 125 #endif 126 ADDDOMAIN(route); 127 #endif /* ! lint */ 128 129 for (dp = domains; dp; dp = dp->dom_next) { 130 if (dp->dom_init) 131 (*dp->dom_init)(); 132 #ifdef MBUFTRACE 133 if (dp->dom_mowner.mo_name[0] == '\0') { 134 strncpy(dp->dom_mowner.mo_name, dp->dom_name, 135 sizeof(dp->dom_mowner.mo_name)); 136 MOWNER_ATTACH(&dp->dom_mowner); 137 } 138 #endif 139 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) 140 if (pr->pr_init) 141 (*pr->pr_init)(); 142 } 143 144 if (max_linkhdr < 16) /* XXX */ 145 max_linkhdr = 16; 146 max_hdr = max_linkhdr + max_protohdr; 147 max_datalen = MHLEN - max_hdr; 148 149 callout_init(&pffasttimo_ch); 150 callout_init(&pfslowtimo_ch); 151 152 callout_reset(&pffasttimo_ch, 1, pffasttimo, NULL); 153 callout_reset(&pfslowtimo_ch, 1, pfslowtimo, NULL); 154 } 155 156 struct domain * 157 pffinddomain(family) 158 int family; 159 { 160 struct domain *dp; 161 162 for (dp = domains; dp != NULL; dp = dp->dom_next) 163 if (dp->dom_family == family) 164 return (dp); 165 return (NULL); 166 } 167 168 struct protosw * 169 pffindtype(family, type) 170 int family, type; 171 { 172 struct domain *dp; 173 struct protosw *pr; 174 175 dp = pffinddomain(family); 176 if (dp == NULL) 177 return (NULL); 178 179 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) 180 if (pr->pr_type && pr->pr_type == type) 181 return (pr); 182 183 return (NULL); 184 } 185 186 struct protosw * 187 pffindproto(family, protocol, type) 188 int family, protocol, type; 189 { 190 struct domain *dp; 191 struct protosw *pr; 192 struct protosw *maybe = NULL; 193 194 if (family == 0) 195 return (NULL); 196 197 dp = pffinddomain(family); 198 if (dp == NULL) 199 return (NULL); 200 201 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) { 202 if ((pr->pr_protocol == protocol) && (pr->pr_type == type)) 203 return (pr); 204 205 if (type == SOCK_RAW && pr->pr_type == SOCK_RAW && 206 pr->pr_protocol == 0 && maybe == NULL) 207 maybe = pr; 208 } 209 return (maybe); 210 } 211 212 int 213 net_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) 214 int *name; 215 u_int namelen; 216 void *oldp; 217 size_t *oldlenp; 218 void *newp; 219 size_t newlen; 220 struct proc *p; 221 { 222 struct domain *dp; 223 struct protosw *pr; 224 int family, protocol; 225 226 /* 227 * All sysctl names at this level are nonterminal. 228 * PF_KEY: next component is protocol family, and then at least one 229 * additional component. 230 * usually: next two components are protocol family and protocol 231 * number, then at least one addition component. 232 */ 233 if (namelen < 2) 234 return (EISDIR); /* overloaded */ 235 family = name[0]; 236 237 if (family == 0) 238 return (0); 239 240 dp = pffinddomain(family); 241 if (dp == NULL) 242 return (ENOPROTOOPT); 243 244 switch (family) { 245 #ifdef IPSEC 246 case PF_KEY: 247 pr = dp->dom_protosw; 248 if (pr->pr_sysctl) 249 return ((*pr->pr_sysctl)(name + 1, namelen - 1, 250 oldp, oldlenp, newp, newlen)); 251 return (ENOPROTOOPT); 252 #endif 253 default: 254 break; 255 } 256 if (namelen < 3) 257 return (EISDIR); /* overloaded */ 258 protocol = name[1]; 259 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) 260 if (pr->pr_protocol == protocol && pr->pr_sysctl) 261 return ((*pr->pr_sysctl)(name + 2, namelen - 2, 262 oldp, oldlenp, newp, newlen)); 263 return (ENOPROTOOPT); 264 } 265 266 void 267 pfctlinput(cmd, sa) 268 int cmd; 269 struct sockaddr *sa; 270 { 271 struct domain *dp; 272 struct protosw *pr; 273 274 for (dp = domains; dp; dp = dp->dom_next) 275 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) 276 if (pr->pr_ctlinput) 277 (*pr->pr_ctlinput)(cmd, sa, NULL); 278 } 279 280 void 281 pfctlinput2(cmd, sa, ctlparam) 282 int cmd; 283 struct sockaddr *sa; 284 void *ctlparam; 285 { 286 struct domain *dp; 287 struct protosw *pr; 288 289 if (!sa) 290 return; 291 for (dp = domains; dp; dp = dp->dom_next) { 292 /* 293 * the check must be made by xx_ctlinput() anyways, to 294 * make sure we use data item pointed to by ctlparam in 295 * correct way. the following check is made just for safety. 296 */ 297 if (dp->dom_family != sa->sa_family) 298 continue; 299 300 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) 301 if (pr->pr_ctlinput) 302 (*pr->pr_ctlinput)(cmd, sa, ctlparam); 303 } 304 } 305 306 void 307 pfslowtimo(arg) 308 void *arg; 309 { 310 struct domain *dp; 311 struct protosw *pr; 312 313 pfslowtimo_now++; 314 315 for (dp = domains; dp; dp = dp->dom_next) 316 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) 317 if (pr->pr_slowtimo) 318 (*pr->pr_slowtimo)(); 319 callout_reset(&pfslowtimo_ch, hz / 2, pfslowtimo, NULL); 320 } 321 322 void 323 pffasttimo(arg) 324 void *arg; 325 { 326 struct domain *dp; 327 struct protosw *pr; 328 329 pffasttimo_now++; 330 331 for (dp = domains; dp; dp = dp->dom_next) 332 for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) 333 if (pr->pr_fasttimo) 334 (*pr->pr_fasttimo)(); 335 callout_reset(&pffasttimo_ch, hz / 5, pffasttimo, NULL); 336 } 337