bsd/kern/uipc_domain.c

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