bsd/kern/uipc_domain.c

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_OSREFERENCE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License.  The rights granted to you under the
  10  * License may not be used to create, or enable the creation or
  11  * redistribution of, unlawful or unlicensed copies of an Apple operating
  12  * system, or to circumvent, violate, or enable the circumvention or
  13  * violation of, any terms of an Apple operating system software license
  14  * agreement.
  15  *
  16  * Please obtain a copy of the License at
  17  * http://www.opensource.apple.com/apsl/ and read it before using this
  18  * file.
  19  *
  20  * The Original Code and all software distributed under the License are
  21  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  22  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  23  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  25  * Please see the License for the specific language governing rights and
  26  * limitations under the License.
  27  *
  28  * @APPLE_LICENSE_OSREFERENCE_HEADER_END@
  29  */
  30 /* Copyright (c) 1998, 1999 Apple Computer, Inc. All Rights Reserved */
  31 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
  32 /*
  33  * Copyright (c) 1982, 1986, 1993
  34  *      The Regents of the University of California.  All rights reserved.
  35  *
  36  * Redistribution and use in source and binary forms, with or without
  37  * modification, are permitted provided that the following conditions
  38  * are met:
  39  * 1. Redistributions of source code must retain the above copyright
  40  *    notice, this list of conditions and the following disclaimer.
  41  * 2. Redistributions in binary form must reproduce the above copyright
  42  *    notice, this list of conditions and the following disclaimer in the
  43  *    documentation and/or other materials provided with the distribution.
  44  * 3. All advertising materials mentioning features or use of this software
  45  *    must display the following acknowledgement:
  46  *      This product includes software developed by the University of
  47  *      California, Berkeley and its contributors.
  48  * 4. Neither the name of the University nor the names of its contributors
  49  *    may be used to endorse or promote products derived from this software
  50  *    without specific prior written permission.
  51  *
  52  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  53  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  54  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  55  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  56  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  57  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  58  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  59  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  60  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  61  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  62  * SUCH DAMAGE.
  63  *
  64  *      @(#)uipc_domain.c       8.3 (Berkeley) 2/14/95
  65  */
  66
  67 #include <sys/param.h>
  68 #include <sys/socket.h>
  69 #include <sys/protosw.h>
  70 #include <sys/domain.h>
  71 #include <sys/mbuf.h>
  72 #include <sys/time.h>
  73 #include <sys/kernel.h>
  74 #include <sys/systm.h>
  75 #include <sys/proc_internal.h>
  76 #include <sys/sysctl.h>
  77 #include <sys/syslog.h>
  78 #include <sys/queue.h>
  79
  80 void    pffasttimo(void *);
  81 void    pfslowtimo(void *);
  82
  83 /*
  84  * Add/delete 'domain': Link structure into system list,
  85  *  invoke the domain init, and then the proto inits.
  86  * To delete, just remove from the list (dom_refs must be zero)
  87  */
  88
  89 lck_grp_t               *domain_proto_mtx_grp;
  90 lck_attr_t      *domain_proto_mtx_attr;
  91 static lck_grp_attr_t   *domain_proto_mtx_grp_attr;
  92 lck_mtx_t               *domain_proto_mtx;
  93 extern int              do_reclaim;
  94
  95 void init_domain(register struct domain *dp)
  96 {
  97         struct protosw  *pr;
  98
  99         if ((dp->dom_mtx = lck_mtx_alloc_init(domain_proto_mtx_grp, domain_proto_mtx_attr)) == NULL) {
 100                 printf("init_domain: can't init domain mtx for domain=%s\n", dp->dom_name);
 101                 return; /* we have a problem... */
 102         }
 103
 104         if (dp->dom_init)
 105                 (*dp->dom_init)();
 106
 107         /* and then init the currently installed protos in this domain */
 108
 109         for (pr = dp->dom_protosw; pr; pr = pr->pr_next) {
 110                 if (pr->pr_usrreqs == 0)
 111                         panic("domaininit: %ssw[%d] has no usrreqs!",
 112                               dp->dom_name,
 113                               (int)(pr - dp->dom_protosw));
 114
 115                 if (pr->pr_init)
 116                         (*pr->pr_init)();
 117         }
 118
 119         /* Recompute for new protocol */
 120         if (max_linkhdr < 16)           /* XXX - Sheesh; everything's ether? */
 121                 max_linkhdr = 16;
 122         if (dp->dom_protohdrlen > max_protohdr)
 123                 max_protohdr = dp->dom_protohdrlen;
 124         max_hdr = max_linkhdr + max_protohdr;
 125         max_datalen = MHLEN - max_hdr;
 126 }
 127
 128 void    concat_domain(struct domain *dp)
 129 {
 130         lck_mtx_assert(domain_proto_mtx, LCK_MTX_ASSERT_OWNED);
 131         dp->dom_next = domains;
 132         domains = dp;
 133 }
 134
 135 void
 136 net_add_domain(register struct domain *dp)
 137 {       register struct protosw *pr;
 138
 139         kprintf("Adding domain %s (family %d)\n", dp->dom_name,
 140                 dp->dom_family);
 141         /* First, link in the domain */
 142
 143         lck_mtx_lock(domain_proto_mtx);
 144         concat_domain(dp);
 145
 146         init_domain(dp);
 147         lck_mtx_unlock(domain_proto_mtx);
 148
 149 }
 150
 151 int
 152 net_del_domain(register struct domain *dp)
 153 {       register struct domain *dp1, *dp2;
 154         register int retval = 0;
 155
 156         lck_mtx_lock(domain_proto_mtx);
 157
 158         if (dp->dom_refs) {
 159                 lck_mtx_unlock(domain_proto_mtx);
 160                 return(EBUSY);
 161      }
 162
 163         for (dp2 = NULL, dp1 = domains; dp1; dp2 = dp1, dp1 = dp1->dom_next)
 164         {       if (dp == dp1)
 165                         break;
 166         }
 167         if (dp1)
 168         {       if (dp2)
 169                         dp2->dom_next = dp1->dom_next;
 170                 else
 171                         domains = dp1->dom_next;
 172         } else
 173                 retval = EPFNOSUPPORT;
 174         lck_mtx_unlock(domain_proto_mtx);
 175
 176         return(retval);
 177 }
 178
 179 /*
 180  * net_add_proto - link a protosw into a domain's protosw chain
 181  *
 182  * note: protocols must use their own domain lock before calling net_add_proto
 183  */
 184 int
 185 net_add_proto(register struct protosw *pp,
 186               register struct domain *dp)
 187 {       register struct protosw *pp1, *pp2;
 188
 189         for (pp2 = NULL, pp1 = dp->dom_protosw; pp1; pp1 = pp1->pr_next)
 190         {       if (pp1->pr_type == pp->pr_type &&
 191                     pp1->pr_protocol == pp->pr_protocol) {
 192                         return(EEXIST);
 193                 }
 194                 pp2 = pp1;
 195         }
 196         if (pp2 == NULL)
 197                 dp->dom_protosw = pp;
 198         else
 199                 pp2->pr_next = pp;
 200         pp->pr_next = NULL;
 201         TAILQ_INIT(&pp->pr_filter_head);
 202         if (pp->pr_init)
 203                 (*pp->pr_init)();
 204
 205         /* Make sure pr_init isn't called again!! */
 206         pp->pr_init = 0;
 207         return(0);
 208 }
 209
 210 /*
 211  * net_del_proto - remove a protosw from a domain's protosw chain.
 212  * Search the protosw chain for the element with matching data.
 213  * Then unlink and return.
 214  *
 215  * note: protocols must use their own domain lock before calling net_del_proto
 216  */
 217 int
 218 net_del_proto(register int type,
 219               register int protocol,
 220               register struct domain *dp)
 221 {       register struct protosw *pp1, *pp2;
 222
 223         for (pp2 = NULL, pp1 = dp->dom_protosw; pp1; pp1 = pp1->pr_next)
 224         {       if (pp1->pr_type == type &&
 225                     pp1->pr_protocol == protocol)
 226                         break;
 227                 pp2 = pp1;
 228         }
 229         if (pp1 == NULL) {
 230                         return(ENXIO);
 231                 }
 232         if (pp2)
 233                 pp2->pr_next = pp1->pr_next;
 234         else
 235                 dp->dom_protosw = pp1->pr_next;
 236         return(0);
 237 }
 238
 239
 240 void
 241 domaininit()
 242 {       register struct domain *dp;
 243         register struct protosw *pr;
 244         extern struct domain localdomain, routedomain, ndrvdomain, inetdomain;
 245         extern struct domain systemdomain;
 246 #if NS
 247         extern struct domain nsdomain;
 248 #endif
 249 #if ISO
 250         extern struct domain isodomain;
 251 #endif
 252 #if CCITT
 253         extern struct domain ccittdomain;
 254 #endif
 255
 256 #if NETAT
 257         extern struct domain atalkdomain;
 258 #endif
 259 #if INET6
 260         extern struct domain inet6domain;
 261 #endif
 262 #if IPSEC
 263         extern struct domain keydomain;
 264 #endif
 265
 266         /*
 267          * allocate lock group attribute and group for domain mutexes
 268          */
 269         domain_proto_mtx_grp_attr = lck_grp_attr_alloc_init();
 270
 271         domain_proto_mtx_grp = lck_grp_alloc_init("domain", domain_proto_mtx_grp_attr);
 272
 273         /*
 274          * allocate the lock attribute for per domain mutexes
 275          */
 276         domain_proto_mtx_attr = lck_attr_alloc_init();
 277
 278         if ((domain_proto_mtx = lck_mtx_alloc_init(domain_proto_mtx_grp, domain_proto_mtx_attr)) == NULL) {
 279                 printf("domaininit: can't init domain mtx for domain list\n");
 280                 return; /* we have a problem... */
 281         }
 282         /*
 283          * Add all the static domains to the domains list
 284          */
 285
 286         lck_mtx_lock(domain_proto_mtx);
 287
 288         concat_domain(&localdomain);
 289         concat_domain(&routedomain);
 290         concat_domain(&inetdomain);
 291 #if NETAT
 292         concat_domain(&atalkdomain);
 293 #endif
 294 #if INET6
 295         concat_domain(&inet6domain);
 296 #endif
 297 #if IPSEC
 298         concat_domain(&keydomain);
 299 #endif
 300
 301 #if NS
 302         concat_domain(&nsdomain);
 303 #endif
 304 #if ISO
 305         concat_domain(&isodomain);
 306 #endif
 307 #if CCITT
 308         concat_domain(&ccittdomain);
 309 #endif
 310         concat_domain(&ndrvdomain);
 311
 312         concat_domain(&systemdomain);
 313
 314         /*
 315          * Now ask them all to init (XXX including the routing domain,
 316          * see above)
 317          */
 318         for (dp = domains; dp; dp = dp->dom_next)
 319                 init_domain(dp);
 320
 321         lck_mtx_unlock(domain_proto_mtx);
 322         timeout(pffasttimo, NULL, 1);
 323         timeout(pfslowtimo, NULL, 1);
 324 }
 325
 326 struct protosw *
 327 pffindtype(family, type)
 328         int family, type;
 329 {
 330         register struct domain *dp;
 331         register struct protosw *pr;
 332
 333         lck_mtx_assert(domain_proto_mtx, LCK_MTX_ASSERT_NOTOWNED);
 334         lck_mtx_lock(domain_proto_mtx);
 335         for (dp = domains; dp; dp = dp->dom_next)
 336                 if (dp->dom_family == family)
 337                         goto found;
 338         lck_mtx_unlock(domain_proto_mtx);
 339         return (0);
 340 found:
 341         for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
 342                 if (pr->pr_type && pr->pr_type == type) {
 343                         lck_mtx_unlock(domain_proto_mtx);
 344                         return (pr);
 345                 }
 346         lck_mtx_unlock(domain_proto_mtx);
 347         return (0);
 348 }
 349
 350 struct domain *
 351 pffinddomain(int pf)
 352 {       struct domain *dp;
 353
 354         lck_mtx_assert(domain_proto_mtx, LCK_MTX_ASSERT_NOTOWNED);
 355         lck_mtx_lock(domain_proto_mtx);
 356         dp = domains;
 357         while (dp)
 358         {       if (dp->dom_family == pf) {
 359                         lck_mtx_unlock(domain_proto_mtx);
 360                         return(dp);
 361                 }
 362                 dp = dp->dom_next;
 363         }
 364         lck_mtx_unlock(domain_proto_mtx);
 365         return(NULL);
 366 }
 367
 368 struct protosw *
 369 pffindproto(family, protocol, type)
 370         int family, protocol, type;
 371 {
 372         register struct protosw *pr;
 373         lck_mtx_assert(domain_proto_mtx, LCK_MTX_ASSERT_NOTOWNED);
 374         lck_mtx_lock(domain_proto_mtx);
 375         pr = pffindproto_locked(family, protocol, type);
 376         lck_mtx_unlock(domain_proto_mtx);
 377         return (pr);
 378 }
 379
 380 struct protosw *
 381 pffindproto_locked(family, protocol, type)
 382         int family, protocol, type;
 383 {
 384         register struct domain *dp;
 385         register struct protosw *pr;
 386         struct protosw *maybe = 0;
 387
 388         if (family == 0)
 389                 return (0);
 390         for (dp = domains; dp; dp = dp->dom_next)
 391                 if (dp->dom_family == family)
 392                         goto found;
 393         return (0);
 394 found:
 395         for (pr = dp->dom_protosw; pr; pr = pr->pr_next) {
 396                 if ((pr->pr_protocol == protocol) && (pr->pr_type == type))
 397                         return (pr);
 398
 399                 if (type == SOCK_RAW && pr->pr_type == SOCK_RAW &&
 400                     pr->pr_protocol == 0 && maybe == (struct protosw *)0)
 401                         maybe = pr;
 402         }
 403         return (maybe);
 404 }
 405
 406 int
 407 net_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
 408            user_addr_t newp, size_t newlen, struct proc *p)
 409 {
 410         register struct domain *dp;
 411         register struct protosw *pr;
 412         int family, protocol, error;
 413
 414         /*
 415          * All sysctl names at this level are nonterminal;
 416          * next two components are protocol family and protocol number,
 417          * then at least one addition component.
 418          */
 419         if (namelen < 3)
 420                 return (EISDIR);                /* overloaded */
 421         family = name[0];
 422         protocol = name[1];
 423
 424         if (family == 0)
 425                 return (0);
 426         lck_mtx_lock(domain_proto_mtx);
 427         for (dp = domains; dp; dp = dp->dom_next)
 428                 if (dp->dom_family == family)
 429                         goto found;
 430         lck_mtx_unlock(domain_proto_mtx);
 431         return (ENOPROTOOPT);
 432 found:
 433         for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
 434                 if (pr->pr_protocol == protocol && pr->pr_sysctl) {
 435                         error = (*pr->pr_sysctl)(name + 2, namelen - 2,
 436                             oldp, oldlenp, newp, newlen);
 437                         lck_mtx_unlock(domain_proto_mtx);
 438                         return (error);
 439                 }
 440         lck_mtx_unlock(domain_proto_mtx);
 441         return (ENOPROTOOPT);
 442 }
 443
 444 void
 445 pfctlinput(cmd, sa)
 446         int cmd;
 447         struct sockaddr *sa;
 448 {
 449         pfctlinput2(cmd, sa, (void*)0);
 450 }
 451
 452 void
 453 pfctlinput2(cmd, sa, ctlparam)
 454         int cmd;
 455         struct sockaddr *sa;
 456         void *ctlparam;
 457 {
 458         struct domain *dp;
 459         struct protosw *pr;
 460
 461         if (!sa)
 462                 return;
 463
 464         lck_mtx_lock(domain_proto_mtx);
 465         for (dp = domains; dp; dp = dp->dom_next)
 466                 for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
 467                         if (pr->pr_ctlinput)
 468                                 (*pr->pr_ctlinput)(cmd, sa, ctlparam);
 469         lck_mtx_unlock(domain_proto_mtx);
 470 }
 471
 472 void
 473 pfslowtimo(arg)
 474         void *arg;
 475 {
 476         register struct domain *dp;
 477         register struct protosw *pr;
 478
 479         lck_mtx_lock(domain_proto_mtx);
 480         for (dp = domains; dp; dp = dp->dom_next)
 481                 for (pr = dp->dom_protosw; pr; pr = pr->pr_next) {
 482                         if (pr->pr_slowtimo)
 483                                 (*pr->pr_slowtimo)();
 484                         if (do_reclaim && pr->pr_drain)
 485                                 (*pr->pr_drain)();
 486                 }
 487         do_reclaim = 0;
 488         lck_mtx_unlock(domain_proto_mtx);
 489         timeout(pfslowtimo, NULL, hz/2);
 490
 491 }
 492
 493 void
 494 pffasttimo(arg)
 495         void *arg;
 496 {
 497         register struct domain *dp;
 498         register struct protosw *pr;
 499
 500         lck_mtx_lock(domain_proto_mtx);
 501         for (dp = domains; dp; dp = dp->dom_next)
 502                 for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
 503                         if (pr->pr_fasttimo)
 504                                 (*pr->pr_fasttimo)();
 505         lck_mtx_unlock(domain_proto_mtx);
 506         timeout(pffasttimo, NULL, hz/5);
 507 }