bsd/kern/uipc_domain.c

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