sctp_module.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2019-2020 The FreeBSD Foundation
    5  *
    6  * This software was developed by Mark Johnston under sponsorship from
    7  * the FreeBSD Foundation.
    8  *
    9  * Redistribution and use in source and binary forms, with or without
   10  * modification, are permitted provided that the following conditions are
   11  * 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
   16  *    the documentation and/or other materials provided with the distribution.
   17  *
   18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   28  * SUCH DAMAGE.
   29  */
   30 
   31 #include <sys/cdefs.h>
   32 __FBSDID("$FreeBSD$");
   33 
   34 #include "opt_inet.h"
   35 #include "opt_inet6.h"
   36 
   37 #include <sys/param.h>
   38 #include <sys/systm.h>
   39 #include <sys/kernel.h>
   40 #include <sys/module.h>
   41 #include <sys/protosw.h>
   42 #include <sys/socket.h>
   43 
   44 #include <netinet/in.h>
   45 #include <netinet/ip.h>
   46 #include <netinet/ip_var.h>
   47 #include <netinet/sctp.h>
   48 #include <netinet/sctp_pcb.h>
   49 #include <netinet/sctp_var.h>
   50 #include <netinet/sctp_os_bsd.h>
   51 
   52 #include <netinet6/ip6_var.h>
   53 #include <netinet6/sctp6_var.h>
   54 
   55 #ifdef INET
   56 extern struct domain inetdomain;
   57 
   58 struct protosw sctp_stream_protosw = {
   59         .pr_type =              SOCK_STREAM,
   60         .pr_domain =            &inetdomain,
   61         .pr_protocol =          IPPROTO_SCTP,
   62         .pr_flags =             PR_CONNREQUIRED|PR_WANTRCVD|PR_LASTHDR,
   63         .pr_input =             sctp_input,
   64         .pr_ctlinput =          sctp_ctlinput,
   65         .pr_ctloutput =         sctp_ctloutput,
   66         .pr_drain =             sctp_drain,
   67         .pr_usrreqs =           &sctp_usrreqs,
   68 };
   69 
   70 struct protosw sctp_seqpacket_protosw = {
   71         .pr_type =              SOCK_SEQPACKET,
   72         .pr_domain =            &inetdomain,
   73         .pr_protocol =          IPPROTO_SCTP,
   74         .pr_flags =             PR_WANTRCVD|PR_LASTHDR,
   75         .pr_input =             sctp_input,
   76         .pr_ctlinput =          sctp_ctlinput,
   77         .pr_ctloutput =         sctp_ctloutput,
   78         .pr_drain =             sctp_drain,
   79         .pr_usrreqs =           &sctp_usrreqs,
   80 };
   81 #endif
   82 
   83 #ifdef INET6
   84 extern struct domain inet6domain;
   85 
   86 struct protosw sctp6_stream_protosw = {
   87         .pr_type =              SOCK_STREAM,
   88         .pr_domain =            &inet6domain,
   89         .pr_protocol =          IPPROTO_SCTP,
   90         .pr_flags =             PR_CONNREQUIRED|PR_WANTRCVD|PR_LASTHDR,
   91         .pr_input =             sctp6_input,
   92         .pr_ctlinput =          sctp6_ctlinput,
   93         .pr_ctloutput =         sctp_ctloutput,
   94         .pr_init =              sctp_init,
   95         .pr_drain =             sctp_drain,
   96         .pr_usrreqs =           &sctp6_usrreqs,
   97 };
   98 
   99 struct protosw sctp6_seqpacket_protosw = {
  100         .pr_type =              SOCK_SEQPACKET,
  101         .pr_domain =            &inet6domain,
  102         .pr_protocol =          IPPROTO_SCTP,
  103         .pr_flags =             PR_WANTRCVD|PR_LASTHDR,
  104         .pr_input =             sctp6_input,
  105         .pr_ctlinput =          sctp6_ctlinput,
  106         .pr_ctloutput =         sctp_ctloutput,
  107 #ifndef INET    /* Do not call initialization and drain routines twice. */
  108         .pr_init =              sctp_init,
  109         .pr_drain =             sctp_drain,
  110 #endif
  111         .pr_usrreqs =           &sctp6_usrreqs,
  112 };
  113 #endif
  114 
  115 static int
  116 sctp_module_load(void)
  117 {
  118         int error;
  119 
  120 #ifdef INET
  121         error = pf_proto_register(PF_INET, &sctp_stream_protosw);
  122         if (error != 0)
  123                 return (error);
  124         error = pf_proto_register(PF_INET, &sctp_seqpacket_protosw);
  125         if (error != 0)
  126                 return (error);
  127         error = ipproto_register(IPPROTO_SCTP);
  128         if (error != 0)
  129                 return (error);
  130 #endif
  131 #ifdef INET6
  132         error = pf_proto_register(PF_INET6, &sctp6_stream_protosw);
  133         if (error != 0)
  134                 return (error);
  135         error = pf_proto_register(PF_INET6, &sctp6_seqpacket_protosw);
  136         if (error != 0)
  137                 return (error);
  138         error = ip6proto_register(IPPROTO_SCTP);
  139         if (error != 0)
  140                 return (error);
  141 #endif
  142         error = sctp_syscalls_init();
  143         if (error != 0)
  144                 return (error);
  145         return (0);
  146 }
  147 
  148 static int __unused
  149 sctp_module_unload(void)
  150 {
  151 
  152         (void)sctp_syscalls_uninit();
  153 
  154 #ifdef INET
  155         (void)ipproto_unregister(IPPROTO_SCTP);
  156         (void)pf_proto_unregister(PF_INET, IPPROTO_SCTP, SOCK_STREAM);
  157         (void)pf_proto_unregister(PF_INET, IPPROTO_SCTP, SOCK_SEQPACKET);
  158 #endif
  159 #ifdef INET6
  160         (void)ip6proto_unregister(IPPROTO_SCTP);
  161         (void)pf_proto_unregister(PF_INET6, IPPROTO_SCTP, SOCK_STREAM);
  162         (void)pf_proto_unregister(PF_INET6, IPPROTO_SCTP, SOCK_SEQPACKET);
  163 #endif
  164         return (0);
  165 }
  166 
  167 static int
  168 sctp_modload(struct module *module, int cmd, void *arg)
  169 {
  170         int error;
  171 
  172         switch (cmd) {
  173         case MOD_LOAD:
  174                 error = sctp_module_load();
  175                 break;
  176         case MOD_UNLOAD:
  177                 /*
  178                  * Unloading SCTP is currently unsupported.  Currently, SCTP
  179                  * iterator threads are not stopped during unload.
  180                  */
  181                 error = EOPNOTSUPP;
  182                 break;
  183         default:
  184                 error = 0;
  185                 break;
  186         }
  187         return (error);
  188 }
  189 
  190 static moduledata_t sctp_mod = {
  191         "sctp",
  192         &sctp_modload,
  193         NULL,
  194 };
  195 
  196 DECLARE_MODULE(sctp, sctp_mod, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY);
  197 MODULE_VERSION(sctp, 1);

Cache object: 186df2dc2176d3d53422c7be0c774da2

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/netinet/sctp_module.c

FreeBSD/Linux Kernel Cross Reference
sys/netinet/sctp_module.c