d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

MFC: Use sparse initializers for "struct domain" and "struct protosw".

Browse Source
This commit is contained in:
ru 2005-11-16 10:31:23 +00:00
parent f012cfe982
commit 539591f019
17 changed files with 641 additions and 498 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
sys/kern/uipc_proto.c
View File

@ -48,29 +48,35 @@ __FBSDID("$FreeBSD$");
*/ */
static struct protosw localsw[] = { static struct protosw localsw[] = {
{ SOCK_STREAM, &localdomain, 0, PR_CONNREQUIRED|PR_WANTRCVD|PR_RIGHTS, {
0, 0, 0, &uipc_ctloutput, .pr_type = SOCK_STREAM,
0, .pr_domain = &localdomain,
0, 0, 0, 0, .pr_flags = PR_CONNREQUIRED|PR_WANTRCVD|PR_RIGHTS,
&uipc_usrreqs .pr_ctloutput = &uipc_ctloutput,
.pr_usrreqs = &uipc_usrreqs
}, },
{ SOCK_DGRAM, &localdomain, 0, PR_ATOMIC|PR_ADDR|PR_RIGHTS, {
0, 0, 0, 0, .pr_type = SOCK_DGRAM,
0, .pr_domain = &localdomain,
0, 0, 0, 0, .pr_flags = PR_ATOMIC|PR_ADDR|PR_RIGHTS,
&uipc_usrreqs .pr_usrreqs = &uipc_usrreqs
}, },
{ 0, 0, 0, 0, {
0, 0, raw_ctlinput, 0, .pr_ctlinput = raw_ctlinput,
0, .pr_init = raw_init,
raw_init, 0, 0, 0, .pr_usrreqs = &raw_usrreqs
&raw_usrreqs
} }
}; };
struct domain localdomain = struct domain localdomain = {
{ AF_LOCAL, "local", unp_init, unp_externalize, unp_dispose, .dom_family = AF_LOCAL,
localsw, &localsw[sizeof(localsw)/sizeof(localsw[0])] }; .dom_name = "local",
.dom_init = unp_init,
.dom_externalize = unp_externalize,
.dom_dispose = unp_dispose,
.dom_protosw = localsw,
.dom_protoswNPROTOSW = &localsw[sizeof(localsw)/sizeof(localsw[0])]
};
DOMAIN_SET(local); DOMAIN_SET(local);
SYSCTL_NODE(_net, PF_LOCAL, local, CTLFLAG_RW, 0, "Local domain"); SYSCTL_NODE(_net, PF_LOCAL, local, CTLFLAG_RW, 0, "Local domain");

32
sys/net/if_gre.c
View File

@ -118,19 +118,27 @@ static void greattach(void);
#ifdef INET #ifdef INET
extern struct domain inetdomain; extern struct domain inetdomain;
static const struct protosw in_gre_protosw = static const struct protosw in_gre_protosw = {
{ SOCK_RAW, &inetdomain, IPPROTO_GRE, PR_ATOMIC|PR_ADDR, .pr_type = SOCK_RAW,
(pr_input_t*)gre_input, (pr_output_t*)rip_output, rip_ctlinput, rip_ctloutput, .pr_domain = &inetdomain,
0, .pr_protocol = IPPROTO_GRE,
0, 0, 0, 0, .pr_flags = PR_ATOMIC|PR_ADDR,
&rip_usrreqs .pr_input = (pr_input_t *)gre_input,
.pr_output = (pr_output_t *)rip_output,
.pr_ctlinput = rip_ctlinput,
.pr_ctloutput = rip_ctloutput,
.pr_usrreqs = &rip_usrreqs
}; };
static const struct protosw in_mobile_protosw = static const struct protosw in_mobile_protosw = {
{ SOCK_RAW, &inetdomain, IPPROTO_MOBILE, PR_ATOMIC|PR_ADDR, .pr_type = SOCK_RAW,
(pr_input_t*)gre_mobile_input, (pr_output_t*)rip_output, rip_ctlinput, rip_ctloutput, .pr_domain = &inetdomain,
0, .pr_protocol = IPPROTO_MOBILE,
0, 0, 0, 0, .pr_flags = PR_ATOMIC|PR_ADDR,
&rip_usrreqs .pr_input = (pr_input_t *)gre_mobile_input,
.pr_output = (pr_output_t *)rip_output,
.pr_ctlinput = rip_ctlinput,
.pr_ctloutput = rip_ctloutput,
.pr_usrreqs = &rip_usrreqs
}; };
#endif #endif

15
sys/net/if_stf.c
View File

@ -155,12 +155,15 @@ static MALLOC_DEFINE(M_STF, STFNAME, "6to4 Tunnel Interface");
static const int ip_stf_ttl = 40; static const int ip_stf_ttl = 40;
extern struct domain inetdomain; extern struct domain inetdomain;
struct protosw in_stf_protosw = struct protosw in_stf_protosw = {
{ SOCK_RAW, &inetdomain, IPPROTO_IPV6, PR_ATOMIC|PR_ADDR, .pr_type = SOCK_RAW,
in_stf_input, (pr_output_t*)rip_output, 0, rip_ctloutput, .pr_domain = &inetdomain,
0, .pr_protocol = IPPROTO_IPV6,
0, 0, 0, 0, .pr_flags = PR_ATOMIC|PR_ADDR,
&rip_usrreqs .pr_input = in_stf_input,
.pr_output = (pr_output_t *)rip_output,
.pr_ctloutput = rip_ctloutput,
.pr_usrreqs = &rip_usrreqs
}; };
static char *stfnames[] = {"stf0", "stf", "6to4", NULL}; static char *stfnames[] = {"stf0", "stf", "6to4", NULL};

22
sys/net/rtsock.c
View File

@ -1238,16 +1238,22 @@ SYSCTL_NODE(_net, PF_ROUTE, routetable, CTLFLAG_RD, sysctl_rtsock, "");
extern struct domain routedomain; /* or at least forward */ extern struct domain routedomain; /* or at least forward */
static struct protosw routesw[] = { static struct protosw routesw[] = {
{ SOCK_RAW, &routedomain, 0, PR_ATOMIC|PR_ADDR, {
0, route_output, raw_ctlinput, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &routedomain,
raw_init, 0, 0, 0, .pr_flags = PR_ATOMIC|PR_ADDR,
&route_usrreqs .pr_output = route_output,
.pr_ctlinput = raw_ctlinput,
.pr_init = raw_init,
.pr_usrreqs = &route_usrreqs
} }
}; };
static struct domain routedomain = static struct domain routedomain = {
{ PF_ROUTE, "route", 0, 0, 0, .dom_family = PF_ROUTE,
routesw, &routesw[sizeof(routesw)/sizeof(routesw[0])] }; .dom_name = "route",
.dom_protosw = routesw,
.dom_protoswNPROTOSW = &routesw[sizeof(routesw)/sizeof(routesw[0])]
};
DOMAIN_SET(route); DOMAIN_SET(route);

34
sys/netatalk/at_proto.c
View File

@ -41,30 +41,24 @@ extern struct domain atalkdomain;
static struct protosw atalksw[] = { static struct protosw atalksw[] = {
{ {
/* Identifiers */ /* Identifiers */
SOCK_DGRAM, &atalkdomain, ATPROTO_DDP, PR_ATOMIC|PR_ADDR, .pr_type = SOCK_DGRAM,
/* .pr_domain = &atalkdomain,
* protocol-protocol interface. .pr_protocol = ATPROTO_DDP,
* fields are pr_input, pr_output, pr_ctlinput, and pr_ctloutput. .pr_flags = PR_ATOMIC|PR_ADDR,
* pr_input can be called from the udp protocol stack for iptalk .pr_output = ddp_output,
* packets bound for a local socket. .pr_init = ddp_init,
* pr_output can be used by higher level appletalk protocols, should .pr_usrreqs = &ddp_usrreqs
* they be included in the kernel.
*/
0, ddp_output, 0, 0,
/* socket-protocol interface. deprecated */
NULL,
/* utility routines. */
ddp_init, 0, 0, 0,
&ddp_usrreqs
}, },
}; };
static struct domain atalkdomain = { static struct domain atalkdomain = {
AF_APPLETALK, "appletalk", 0, 0, 0, .dom_family = AF_APPLETALK,
atalksw, &atalksw[sizeof(atalksw)/sizeof(atalksw[0])], .dom_name = "appletalk",
0, rn_inithead, .dom_protosw = atalksw,
8 * (u_long) &((struct sockaddr_at *) 0)->sat_addr, .dom_protoswNPROTOSW = &atalksw[sizeof(atalksw)/sizeof(atalksw[0])],
sizeof(struct sockaddr_at) .dom_rtattach = rn_inithead,
.dom_rtoffset = offsetof(struct sockaddr_at, sat_addr) << 3,
.dom_maxrtkey = sizeof(struct sockaddr_at)
}; };
DOMAIN_SET(atalk); DOMAIN_SET(atalk);

76
sys/netatm/atm_proto.c
View File

@ -54,65 +54,43 @@ __FBSDID("$FreeBSD$");
NET_NEEDS_GIANT("netatm"); NET_NEEDS_GIANT("netatm");
struct protosw atmsw[] = { struct protosw atmsw[] = {
{ SOCK_DGRAM, /* ioctl()-only */ {
&atmdomain, .pr_type = SOCK_DGRAM, /* ioctl()-only */
0, .pr_domain = &atmdomain,
0, .pr_usrreqs = &atm_dgram_usrreqs
0, /* pr_input */
0, /* pr_output */
0, /* pr_ctlinput */
0, /* pr_ctloutput */
0, /* pr_ousrreq */
0, /* pr_init */
0, /* pr_fasttimo */
0, /* pr_slowtimo */
0, /* pr_drain */
&atm_dgram_usrreqs, /* pr_usrreqs */
}, },
{ SOCK_SEQPACKET, /* AAL-5 */ {
&atmdomain, .pr_type = SOCK_SEQPACKET, /* AAL-5 */
ATM_PROTO_AAL5, .pr_domain = &atmdomain,
PR_ATOMIC|PR_CONNREQUIRED, .pr_protocol = ATM_PROTO_AAL5,
0, /* pr_input */ .pr_flags = PR_ATOMIC|PR_CONNREQUIRED,
0, /* pr_output */ .pr_ctloutput = atm_aal5_ctloutput,
0, /* pr_ctlinput */ .pr_usrreqs = &atm_aal5_usrreqs
atm_aal5_ctloutput, /* pr_ctloutput */
0, /* pr_ousrreq */
0, /* pr_init */
0, /* pr_fasttimo */
0, /* pr_slowtimo */
0, /* pr_drain */
&atm_aal5_usrreqs, /* pr_usrreqs */
}, },
#ifdef XXX #ifdef XXX
{ SOCK_SEQPACKET, /* SSCOP */ {
&atmdomain, .pr_type = SOCK_SEQPACKET, /* SSCOP */
ATM_PROTO_SSCOP, .pr_domain = &atmdomain,
PR_ATOMIC|PR_CONNREQUIRED|PR_WANTRCVD, .pr_protocol = ATM_PROTO_SSCOP,
x, /* pr_input */ .pr_flags = PR_ATOMIC|PR_CONNREQUIRED|PR_WANTRCVD,
x, /* pr_output */ .pr_input = x,
x, /* pr_ctlinput */ .pr_output = x,
x, /* pr_ctloutput */ .pr_ctlinput = x,
0, /* pr_ousrreq */ .pr_ctloutput = x,
0, /* pr_init */ .pr_drain = x,
0, /* pr_fasttimo */ .pr_usrreqs = x
0, /* pr_slowtimo */
x, /* pr_drain */
x, /* pr_usrreqs */
}, },
#endif #endif
}; };
struct domain atmdomain = { struct domain atmdomain = {
AF_ATM, .dom_family = AF_ATM,
"atm", .dom_name = "atm",
atm_initialize, .dom_init = atm_initialize,
0, .dom_protosw = atmsw,
0, .dom_protoswNPROTOSW = &atmsw[sizeof(atmsw) / sizeof(atmsw[0])]
atmsw,
&atmsw[sizeof(atmsw) / sizeof(atmsw[0])]
}; };
DOMAIN_SET(atm); DOMAIN_SET(atm);

86
sys/netgraph/bluetooth/socket/ng_btsocket.c
View File

@ -140,56 +140,39 @@ static struct pr_usrreqs ng_btsocket_rfcomm_usrreqs = {
static struct protosw ng_btsocket_protosw[] = { static struct protosw ng_btsocket_protosw[] = {
{ {
SOCK_RAW, /* protocol type */ .pr_type = SOCK_RAW,
&ng_btsocket_domain, /* backpointer to domain */ .pr_domain = &ng_btsocket_domain,
BLUETOOTH_PROTO_HCI, /* protocol */ .pr_protocol = BLUETOOTH_PROTO_HCI,
PR_ATOMIC | PR_ADDR, /* flags */ .pr_flags = PR_ATOMIC|PR_ADDR,
NULL, NULL, NULL, /* input, output, ctlinput */ .pr_ctloutput = ng_btsocket_hci_raw_ctloutput,
ng_btsocket_hci_raw_ctloutput, /* ctloutput */ .pr_init = ng_btsocket_hci_raw_init,
NULL, /* ousrreq() */ .pr_usrreqs = &ng_btsocket_hci_raw_usrreqs,
ng_btsocket_hci_raw_init, /* init */
NULL, NULL, NULL, /* fasttimeo, slowtimo, drain */
&ng_btsocket_hci_raw_usrreqs, /* usrreq table (above) */
/* { NULL } */ /* pfh (protocol filter head?) */
}, },
{ {
SOCK_RAW, /* protocol type */ .pr_type = SOCK_RAW,
&ng_btsocket_domain, /* backpointer to domain */ .pr_domain = &ng_btsocket_domain,
BLUETOOTH_PROTO_L2CAP, /* protocol */ .pr_protocol = BLUETOOTH_PROTO_L2CAP,
PR_ATOMIC | PR_ADDR, /* flags */ .pr_flags = PR_ATOMIC|PR_ADDR,
NULL, NULL, NULL, /* input, output, ctlinput */ .pr_init = ng_btsocket_l2cap_raw_init,
NULL, /* ctloutput */ .pr_usrreqs = &ng_btsocket_l2cap_raw_usrreqs,
NULL, /* ousrreq() */
ng_btsocket_l2cap_raw_init, /* init */
NULL, NULL, NULL, /* fasttimeo, slowtimo, drain */
&ng_btsocket_l2cap_raw_usrreqs, /* usrreq table (above) */
/* { NULL } */ /* pfh (protocol filter head?) */
}, },
{ {
SOCK_SEQPACKET, /* protocol type */ .pr_type = SOCK_SEQPACKET,
&ng_btsocket_domain, /* backpointer to domain */ .pr_domain = &ng_btsocket_domain,
BLUETOOTH_PROTO_L2CAP, /* protocol */ .pr_protocol = BLUETOOTH_PROTO_L2CAP,
PR_ATOMIC | PR_CONNREQUIRED, /* flags */ .pr_flags = PR_ATOMIC|PR_CONNREQUIRED,
NULL, NULL, NULL, /* input, output, ctlinput */ .pr_ctloutput = ng_btsocket_l2cap_ctloutput,
ng_btsocket_l2cap_ctloutput, /* ctloutput */ .pr_init = ng_btsocket_l2cap_init,
NULL, /* ousrreq() */ .pr_usrreqs = &ng_btsocket_l2cap_usrreqs,
ng_btsocket_l2cap_init, /* init */
NULL, NULL, NULL, /* fasttimeo, slowtimo, drain */
&ng_btsocket_l2cap_usrreqs, /* usrreq table (above) */
/* { NULL } */ /* pfh (protocol filter head?) */
}, },
{ {
SOCK_STREAM, /* protocol type */ .pr_type = SOCK_STREAM,
&ng_btsocket_domain, /* backpointer to domain */ .pr_domain = &ng_btsocket_domain,
BLUETOOTH_PROTO_RFCOMM, /* protocol */ .pr_protocol = BLUETOOTH_PROTO_RFCOMM,
PR_CONNREQUIRED, /* flags */ .pr_flags = PR_CONNREQUIRED,
NULL, NULL, NULL, /* input, output, ctlinput */ .pr_ctloutput = ng_btsocket_rfcomm_ctloutput,
ng_btsocket_rfcomm_ctloutput, /* ctloutput */ .pr_init = ng_btsocket_rfcomm_init,
NULL, /* ousrreq() */ .pr_usrreqs = &ng_btsocket_rfcomm_usrreqs,
ng_btsocket_rfcomm_init, /* init */
NULL, NULL, NULL, /* fasttimeo, slowtimo, drain */
&ng_btsocket_rfcomm_usrreqs, /* usrreq table (above) */
/* { NULL } */ /* pfh (protocol filter head?) */
} }
}; };
#define ng_btsocket_protosw_size \ #define ng_btsocket_protosw_size \
@ -202,17 +185,10 @@ static struct protosw ng_btsocket_protosw[] = {
*/ */
struct domain ng_btsocket_domain = { struct domain ng_btsocket_domain = {
AF_BLUETOOTH, /* family */ .dom_family = AF_BLUETOOTH,
"bluetooth", /* domain name */ .dom_name = "bluetooth",
NULL, /* init() */ .dom_protosw = ng_btsocket_protosw,
NULL, /* externalize() */ .dom_protoswNPROTOSW = ng_btsocket_protosw_end
NULL, /* dispose() */
ng_btsocket_protosw, /* protosw entry */
ng_btsocket_protosw_end, /* end of protosw entries */
NULL, /* next domain in list */
NULL, /* rtattach() */
0, /* arg to rtattach in bits */
0 /* maxrtkey */
}; };
/* /*

51
sys/netgraph/ng_socket.c
View File

@ -1110,42 +1110,27 @@ static struct pr_usrreqs ngd_usrreqs = {
extern struct domain ngdomain; /* stop compiler warnings */ extern struct domain ngdomain; /* stop compiler warnings */
static struct protosw ngsw[] = { static struct protosw ngsw[] = {
{ {
SOCK_DGRAM, /* protocol type */ .pr_type = SOCK_DGRAM,
&ngdomain, /* backpointer to domain */ .pr_domain = &ngdomain,
NG_CONTROL, .pr_protocol = NG_CONTROL,
PR_ATOMIC | PR_ADDR /* | PR_RIGHTS */, /* flags */ .pr_flags = PR_ATOMIC | PR_ADDR /* | PR_RIGHTS */,
0, 0, 0, 0, /* input, output, ctlinput, ctloutput */ .pr_usrreqs = &ngc_usrreqs
NULL, /* ousrreq */ },
0, 0, 0, 0, /* init, fasttimeo, slowtimo, drain */ {
&ngc_usrreqs, /* usrreq table (above) */ .pr_type = SOCK_DGRAM,
/*{NULL}*/ /* pffh (protocol filter head?) */ .pr_domain = &ngdomain,
}, .pr_protocol = NG_DATA,
{ .pr_flags = PR_ATOMIC | PR_ADDR,
SOCK_DGRAM, /* protocol type */ .pr_usrreqs = &ngd_usrreqs
&ngdomain, /* backpointer to domain */ }
NG_DATA,
PR_ATOMIC | PR_ADDR, /* flags */
0, 0, 0, 0, /* input, output, ctlinput, ctloutput */
NULL, /* ousrreq() */
0, 0, 0, 0, /* init, fasttimeo, slowtimo, drain */
&ngd_usrreqs, /* usrreq table (above) */
/*{NULL}*/ /* pffh (protocol filter head?) */
}
}; };
struct domain ngdomain = { struct domain ngdomain = {
AF_NETGRAPH, .dom_family = AF_NETGRAPH,
"netgraph", .dom_name = "netgraph",
NULL, /* init() */ .dom_protosw = ngsw,
NULL, /* externalise() */ .dom_protoswNPROTOSW = &ngsw[sizeof(ngsw) / sizeof(ngsw[0])]
NULL, /* dispose() */
ngsw, /* protosw entry */
&ngsw[sizeof(ngsw) / sizeof(ngsw[0])], /* Number of protosw entries */
NULL, /* next domain in list */
NULL, /* rtattach() */
0, /* arg to rtattach in bits */
0 /* maxrtkey */
}; };
/* /*

15
sys/netinet/in_gif.c
View File

@ -74,12 +74,15 @@ static int gif_validate4(const struct ip *, struct gif_softc *,
struct ifnet *); struct ifnet *);
extern struct domain inetdomain; extern struct domain inetdomain;
struct protosw in_gif_protosw = struct protosw in_gif_protosw = {
{ SOCK_RAW, &inetdomain, 0/* IPPROTO_IPV[46] */, PR_ATOMIC|PR_ADDR, .pr_type = SOCK_RAW,
in_gif_input, (pr_output_t*)rip_output, 0, rip_ctloutput, .pr_domain = &inetdomain,
0, .pr_protocol = 0/* IPPROTO_IPV[46] */,
0, 0, 0, 0, .pr_flags = PR_ATOMIC|PR_ADDR,
&rip_usrreqs .pr_input = in_gif_input,
.pr_output = (pr_output_t*)rip_output,
.pr_ctloutput = rip_ctloutput,
.pr_usrreqs = &rip_usrreqs
}; };
static int ip_gif_ttl = GIF_TTL; static int ip_gif_ttl = GIF_TTL;

324
sys/netinet/in_proto.c
View File

@ -98,156 +98,228 @@
extern struct domain inetdomain; extern struct domain inetdomain;
/* Spacer for loadable protocols. */ /* Spacer for loadable protocols. */
#define IPPROTOSPACER \ #define IPPROTOSPACER \
{ 0, &inetdomain, PROTO_SPACER, 0, \ { \
NULL, NULL, NULL, NULL, \ .pr_domain = &inetdomain, \
NULL, \ .pr_protocol = PROTO_SPACER, \
NULL, NULL, NULL, NULL, \ .pr_usrreqs = &nousrreqs \
&nousrreqs \
} }
struct protosw inetsw[] = { struct protosw inetsw[] = {
{ 0, &inetdomain, 0, 0, {
0, 0, 0, 0, .pr_type = 0,
0, .pr_domain = &inetdomain,
ip_init, 0, ip_slowtimo, ip_drain, .pr_protocol = IPPROTO_IP,
&nousrreqs .pr_init = ip_init,
.pr_slowtimo = ip_slowtimo,
.pr_drain = ip_drain,
.pr_usrreqs = &nousrreqs
}, },
{ SOCK_DGRAM, &inetdomain, IPPROTO_UDP, PR_ATOMIC|PR_ADDR, {
udp_input, 0, udp_ctlinput, ip_ctloutput, .pr_type = SOCK_DGRAM,
0, .pr_domain = &inetdomain,
udp_init, 0, 0, 0, .pr_protocol = IPPROTO_UDP,
&udp_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = udp_input,
.pr_ctlinput = udp_ctlinput,
.pr_ctloutput = ip_ctloutput,
.pr_init = udp_init,
.pr_usrreqs = &udp_usrreqs
}, },
{ SOCK_STREAM, &inetdomain, IPPROTO_TCP, {
PR_CONNREQUIRED|PR_IMPLOPCL|PR_WANTRCVD, .pr_type = SOCK_STREAM,
tcp_input, 0, tcp_ctlinput, tcp_ctloutput, .pr_domain = &inetdomain,
0, .pr_protocol = IPPROTO_TCP,
tcp_init, 0, tcp_slowtimo, tcp_drain, .pr_flags = PR_CONNREQUIRED|PR_IMPLOPCL|PR_WANTRCVD,
&tcp_usrreqs .pr_input = tcp_input,
.pr_ctlinput = tcp_ctlinput,
.pr_ctloutput = tcp_ctloutput,
.pr_init = tcp_init,
.pr_slowtimo = tcp_slowtimo,
.pr_drain = tcp_drain,
.pr_usrreqs = &tcp_usrreqs
}, },
{ SOCK_RAW, &inetdomain, IPPROTO_RAW, PR_ATOMIC|PR_ADDR, {
rip_input, 0, rip_ctlinput, rip_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
0, 0, 0, 0, .pr_protocol = IPPROTO_RAW,
&rip_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = rip_input,
.pr_ctlinput = rip_ctlinput,
.pr_ctloutput = rip_ctloutput,
.pr_usrreqs = &rip_usrreqs
}, },
{ SOCK_RAW, &inetdomain, IPPROTO_ICMP, PR_ATOMIC|PR_ADDR|PR_LASTHDR, {
icmp_input, 0, 0, rip_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
0, 0, 0, 0, .pr_protocol = IPPROTO_ICMP,
&rip_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR,
.pr_input = icmp_input,
.pr_ctloutput = rip_ctloutput,
.pr_usrreqs = &rip_usrreqs
}, },
{ SOCK_RAW, &inetdomain, IPPROTO_IGMP, PR_ATOMIC|PR_ADDR|PR_LASTHDR, {
igmp_input, 0, 0, rip_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
igmp_init, igmp_fasttimo, igmp_slowtimo, 0, .pr_protocol = IPPROTO_IGMP,
&rip_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR,
.pr_input = igmp_input,
.pr_ctloutput = rip_ctloutput,
.pr_init = igmp_init,
.pr_fasttimo = igmp_fasttimo,
.pr_slowtimo = igmp_slowtimo,
.pr_usrreqs = &rip_usrreqs
}, },
{ SOCK_RAW, &inetdomain, IPPROTO_RSVP, PR_ATOMIC|PR_ADDR|PR_LASTHDR, {
rsvp_input, 0, 0, rip_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
0, 0, 0, 0, .pr_protocol = IPPROTO_RSVP,
&rip_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR,
.pr_input = rsvp_input,
.pr_ctloutput = rip_ctloutput,
.pr_usrreqs = &rip_usrreqs
}, },
#ifdef IPSEC #ifdef IPSEC
{ SOCK_RAW, &inetdomain, IPPROTO_AH, PR_ATOMIC|PR_ADDR, {
ah4_input, 0, 0, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
0, 0, 0, 0, .pr_protocol = IPPROTO_AH,
&nousrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = ah4_input,
.pr_usrreqs = &nousrreqs
}, },
#ifdef IPSEC_ESP #ifdef IPSEC_ESP
{ SOCK_RAW, &inetdomain, IPPROTO_ESP, PR_ATOMIC|PR_ADDR, {
esp4_input, 0, 0, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
0, 0, 0, 0, .pr_protocol = IPPROTO_ESP,
&nousrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = esp4_input,
.pr_usrreqs = &nousrreqs
}, },
#endif #endif
{ SOCK_RAW, &inetdomain, IPPROTO_IPCOMP, PR_ATOMIC|PR_ADDR, {
ipcomp4_input, 0, 0, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
0, 0, 0, 0, .pr_protocol = IPPROTO_IPCOMP,
&nousrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = ipcomp4_input,
.pr_usrreqs = &nousrreqs
}, },
#endif /* IPSEC */ #endif /* IPSEC */
#ifdef FAST_IPSEC #ifdef FAST_IPSEC
{ SOCK_RAW, &inetdomain, IPPROTO_AH, PR_ATOMIC|PR_ADDR, {
ah4_input, 0, ah4_ctlinput, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
0, 0, 0, 0, .pr_protocol = IPPROTO_AH,
&nousrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = ah4_input,
.pr_ctlinput = ah4_ctlinput,
.pr_usrreqs = &nousrreqs
}, },
{ SOCK_RAW, &inetdomain, IPPROTO_ESP, PR_ATOMIC|PR_ADDR, {
esp4_input, 0, esp4_ctlinput, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
0, 0, 0, 0, .pr_protocol = IPPROTO_ESP,
&nousrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = esp4_input,
.pr_ctlinput = esp4_ctlinput,
.pr_usrreqs = &nousrreqs
}, },
{ SOCK_RAW, &inetdomain, IPPROTO_IPCOMP, PR_ATOMIC|PR_ADDR, {
ipcomp4_input, 0, 0, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
0, 0, 0, 0, .pr_protocol = IPPROTO_IPCOMP,
&nousrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = ipcomp4_input,
.pr_usrreqs = &nousrreqs
}, },
#endif /* FAST_IPSEC */ #endif /* FAST_IPSEC */
{ SOCK_RAW, &inetdomain, IPPROTO_IPV4, PR_ATOMIC|PR_ADDR|PR_LASTHDR, {
encap4_input, 0, 0, rip_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
encap_init, 0, 0, 0, .pr_protocol = IPPROTO_IPV4,
&rip_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR,
.pr_input = encap4_input,
.pr_ctloutput = rip_ctloutput,
.pr_init = encap_init,
.pr_usrreqs = &rip_usrreqs
}, },
{ SOCK_RAW, &inetdomain, IPPROTO_MOBILE, PR_ATOMIC|PR_ADDR|PR_LASTHDR, {
encap4_input, 0, 0, rip_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
encap_init, 0, 0, 0, .pr_protocol = IPPROTO_MOBILE,
&rip_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR,
.pr_input = encap4_input,
.pr_ctloutput = rip_ctloutput,
.pr_init = encap_init,
.pr_usrreqs = &rip_usrreqs
}, },
{ SOCK_RAW, &inetdomain, IPPROTO_GRE, PR_ATOMIC|PR_ADDR|PR_LASTHDR, {
encap4_input, 0, 0, rip_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
encap_init, 0, 0, 0, .pr_protocol = IPPROTO_GRE,
&rip_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR,
.pr_input = encap4_input,
.pr_ctloutput = rip_ctloutput,
.pr_init = encap_init,
.pr_usrreqs = &rip_usrreqs
}, },
# ifdef INET6 # ifdef INET6
{ SOCK_RAW, &inetdomain, IPPROTO_IPV6, PR_ATOMIC|PR_ADDR|PR_LASTHDR, {
encap4_input, 0, 0, rip_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
encap_init, 0, 0, 0, .pr_protocol = IPPROTO_IPV6,
&rip_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR,
.pr_input = encap4_input,
.pr_ctloutput = rip_ctloutput,
.pr_init = encap_init,
.pr_usrreqs = &rip_usrreqs
}, },
#endif #endif
#ifdef IPXIP #ifdef IPXIP
{ SOCK_RAW, &inetdomain, IPPROTO_IDP, PR_ATOMIC|PR_ADDR|PR_LASTHDR, {
ipxip_input, 0, ipxip_ctlinput, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
0, 0, 0, 0, .pr_protocol = IPPROTO_IDP,
&rip_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR,
.pr_input = ipxip_input,
.pr_ctlinput = ipxip_ctlinput,
.pr_usrreqs = &rip_usrreqs
}, },
#endif #endif
#ifdef PIM #ifdef PIM
{ SOCK_RAW, &inetdomain, IPPROTO_PIM, PR_ATOMIC|PR_ADDR|PR_LASTHDR, {
pim_input, 0, 0, rip_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
0, 0, 0, 0, .pr_protocol = IPPROTO_PIM,
&rip_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR,
.pr_input = pim_input,
.pr_ctloutput = rip_ctloutput,
.pr_usrreqs = &rip_usrreqs
}, },
#endif /* PIM */ #endif /* PIM */
#ifdef DEV_PFSYNC #ifdef DEV_PFSYNC
{ SOCK_RAW, &inetdomain, IPPROTO_PFSYNC, PR_ATOMIC|PR_ADDR, {
pfsync_input, 0, 0, rip_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
0, 0, 0, 0, .pr_protocol = IPPROTO_PFSYNC,
&rip_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = pfsync_input,
.pr_ctloutput = rip_ctloutput,
.pr_usrreqs = &rip_usrreqs
}, },
#endif /* DEV_PFSYNC */ #endif /* DEV_PFSYNC */
#ifdef DEV_CARP #ifdef DEV_CARP
{ SOCK_RAW, &inetdomain, IPPROTO_CARP, PR_ATOMIC|PR_ADDR, {
carp_input, (pr_output_t*)rip_output, 0, rip_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
0, 0, 0, 0, .pr_protocol = IPPROTO_CARP,
&rip_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = carp_input,
.pr_output = (pr_output_t*)rip_output,
.pr_ctloutput = rip_ctloutput,
.pr_usrreqs = &rip_usrreqs
}, },
#endif /* DEV_CARP */ #endif /* DEV_CARP */
/* Spacer n-times for loadable protocols. */ /* Spacer n-times for loadable protocols. */
@ -260,22 +332,28 @@ IPPROTOSPACER,
IPPROTOSPACER, IPPROTOSPACER,
IPPROTOSPACER, IPPROTOSPACER,
/* raw wildcard */ /* raw wildcard */
{ SOCK_RAW, &inetdomain, 0, PR_ATOMIC|PR_ADDR, {
rip_input, 0, 0, rip_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
rip_init, 0, 0, 0, .pr_flags = PR_ATOMIC|PR_ADDR,
&rip_usrreqs .pr_input = rip_input,
.pr_ctloutput = rip_ctloutput,
.pr_init = rip_init,
.pr_usrreqs = &rip_usrreqs
}, },
}; };
extern int in_inithead(void **, int); extern int in_inithead(void **, int);
struct domain inetdomain = struct domain inetdomain = {
{ AF_INET, "internet", 0, 0, 0, .dom_family = AF_INET,
inetsw, .dom_name = "internet",
&inetsw[sizeof(inetsw)/sizeof(inetsw[0])], 0, .dom_protosw = inetsw,
in_inithead, 32, sizeof(struct sockaddr_in) .dom_protoswNPROTOSW = &inetsw[sizeof(inetsw)/sizeof(inetsw[0])],
}; .dom_rtattach = in_inithead,
.dom_rtoffset = 32,
.dom_maxrtkey = sizeof(struct sockaddr_in)
};
DOMAIN_SET(inet); DOMAIN_SET(inet);

13
sys/netinet/ip_divert.c
View File

@ -649,11 +649,14 @@ struct pr_usrreqs div_usrreqs = {
}; };
struct protosw div_protosw = { struct protosw div_protosw = {
SOCK_RAW, NULL, IPPROTO_DIVERT, PR_ATOMIC|PR_ADDR, .pr_type = SOCK_RAW,
div_input, NULL, div_ctlinput, ip_ctloutput, .pr_protocol = IPPROTO_DIVERT,
NULL, .pr_flags = PR_ATOMIC|PR_ADDR,
div_init, NULL, NULL, NULL, .pr_input = div_input,
&div_usrreqs .pr_ctlinput = div_ctlinput,
.pr_ctloutput = ip_ctloutput,
.pr_init = div_init,
.pr_usrreqs = &div_usrreqs
}; };
static int static int

13
sys/netinet/ip_mroute.c
View File

@ -920,11 +920,14 @@ mroute_encap_input(struct mbuf *m, int off)
extern struct domain inetdomain; extern struct domain inetdomain;
static struct protosw mroute_encap_protosw = static struct protosw mroute_encap_protosw =
{ SOCK_RAW, &inetdomain, IPPROTO_IPV4, PR_ATOMIC|PR_ADDR, {
mroute_encap_input, 0, 0, rip_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inetdomain,
0, 0, 0, 0, .pr_protocol = IPPROTO_IPV4,
&rip_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = mroute_encap_input,
.pr_ctloutput = rip_ctloutput,
.pr_usrreqs = &rip_usrreqs
}; };
/* /*

249
sys/netinet6/in6_proto.c
View File

@ -145,135 +145,196 @@
*/ */
extern struct domain inet6domain; extern struct domain inet6domain;
static struct pr_usrreqs nousrreqs; static struct pr_usrreqs nousrreqs;
#define PR_LISTEN 0 #define PR_LISTEN 0
#define PR_ABRTACPTDIS 0 #define PR_ABRTACPTDIS 0
struct ip6protosw inet6sw[] = { struct ip6protosw inet6sw[] = {
{ 0, &inet6domain, IPPROTO_IPV6, 0, {
0, 0, 0, 0, .pr_type = 0,
0, .pr_domain = &inet6domain,
ip6_init, 0, frag6_slowtimo, frag6_drain, .pr_protocol = IPPROTO_IPV6,
&nousrreqs, .pr_init = ip6_init,
.pr_slowtimo = frag6_slowtimo,
.pr_drain = frag6_drain,
.pr_usrreqs = &nousrreqs,
}, },
{ SOCK_DGRAM, &inet6domain, IPPROTO_UDP, PR_ATOMIC|PR_ADDR, {
udp6_input, 0, udp6_ctlinput, ip6_ctloutput, .pr_type = SOCK_DGRAM,
0, .pr_domain = &inet6domain,
0, 0, 0, 0, .pr_protocol = IPPROTO_UDP,
&udp6_usrreqs, .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = udp6_input,
.pr_ctlinput = udp6_ctlinput,
.pr_ctloutput = ip6_ctloutput,
.pr_usrreqs = &udp6_usrreqs,
}, },
{ SOCK_STREAM, &inet6domain, IPPROTO_TCP, PR_CONNREQUIRED|PR_WANTRCVD|PR_LISTEN, {
tcp6_input, 0, tcp6_ctlinput, tcp_ctloutput, .pr_type = SOCK_STREAM,
0, .pr_domain = &inet6domain,
#ifdef INET /* don't call initialization and timeout routines twice */ .pr_protocol = IPPROTO_TCP,
0, 0, 0, tcp_drain, .pr_flags = PR_CONNREQUIRED|PR_WANTRCVD|PR_LISTEN,
#else .pr_input = tcp6_input,
tcp_init, tcp_fasttimo, tcp_slowtimo, tcp_drain, .pr_ctlinput = tcp6_ctlinput,
.pr_ctloutput = tcp_ctloutput,
#ifndef INET /* don't call initialization and timeout routines twice */
.pr_init = tcp_init,
.pr_fasttimo = tcp_fasttimo,
.pr_slowtimo = tcp_slowtimo,
#endif #endif
&tcp6_usrreqs, .pr_drain = tcp_drain,
.pr_usrreqs = &tcp6_usrreqs,
}, },
{ SOCK_RAW, &inet6domain, IPPROTO_RAW, PR_ATOMIC|PR_ADDR, {
rip6_input, rip6_output, rip6_ctlinput, rip6_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inet6domain,
0, 0, 0, 0, .pr_protocol = IPPROTO_RAW,
&rip6_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = rip6_input,
.pr_output = rip6_output,
.pr_ctlinput = rip6_ctlinput,
.pr_ctloutput = rip6_ctloutput,
.pr_usrreqs = &rip6_usrreqs
}, },
{ SOCK_RAW, &inet6domain, IPPROTO_ICMPV6, PR_ATOMIC|PR_ADDR|PR_LASTHDR, {
icmp6_input, rip6_output, rip6_ctlinput, rip6_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inet6domain,
icmp6_init, icmp6_fasttimo, 0, 0, .pr_protocol = IPPROTO_ICMPV6,
&rip6_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR,
.pr_input = icmp6_input,
.pr_output = rip6_output,
.pr_ctlinput = rip6_ctlinput,
.pr_ctloutput = rip6_ctloutput,
.pr_init = icmp6_init,
.pr_fasttimo = icmp6_fasttimo,
.pr_usrreqs = &rip6_usrreqs
}, },
{ SOCK_RAW, &inet6domain, IPPROTO_DSTOPTS,PR_ATOMIC|PR_ADDR, {
dest6_input, 0, 0, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &inet6domain,
0, 0, 0, 0, .pr_protocol = IPPROTO_DSTOPTS,
&nousrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = dest6_input,
.pr_usrreqs = &nousrreqs
}, },
{ SOCK_RAW, &inet6domain, IPPROTO_ROUTING,PR_ATOMIC|PR_ADDR, {
route6_input, 0, 0, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &inet6domain,
0, 0, 0, 0, .pr_protocol = IPPROTO_ROUTING,
&nousrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = route6_input,
.pr_usrreqs = &nousrreqs
}, },
{ SOCK_RAW, &inet6domain, IPPROTO_FRAGMENT,PR_ATOMIC|PR_ADDR, {
frag6_input, 0, 0, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &inet6domain,
0, 0, 0, 0, .pr_protocol = IPPROTO_FRAGMENT,
&nousrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = frag6_input,
.pr_usrreqs = &nousrreqs
}, },
#ifdef IPSEC #ifdef IPSEC
{ SOCK_RAW, &inet6domain, IPPROTO_AH, PR_ATOMIC|PR_ADDR, {
ah6_input, 0, 0, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &inet6domain,
0, 0, 0, 0, .pr_protocol = IPPROTO_AH,
&nousrreqs, .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = ah6_input,
.pr_usrreqs = &nousrreqs,
}, },
#ifdef IPSEC_ESP #ifdef IPSEC_ESP
{ SOCK_RAW, &inet6domain, IPPROTO_ESP, PR_ATOMIC|PR_ADDR, {
esp6_input, 0, .pr_type = SOCK_RAW,
esp6_ctlinput, .pr_domain = &inet6domain,
0, .pr_protocol = IPPROTO_ESP,
0, .pr_flags = PR_ATOMIC|PR_ADDR,
0, 0, 0, 0, .pr_input = esp6_input,
&nousrreqs, .pr_ctlinput = esp6_ctlinput,
.pr_usrreqs = &nousrreqs,
}, },
#endif #endif
{ SOCK_RAW, &inet6domain, IPPROTO_IPCOMP, PR_ATOMIC|PR_ADDR, {
ipcomp6_input, 0, 0, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &inet6domain,
0, 0, 0, 0, .pr_protocol = IPPROTO_IPCOMP,
&nousrreqs, .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = ipcomp6_input,
.pr_usrreqs = &nousrreqs,
}, },
#endif /* IPSEC */ #endif /* IPSEC */
#ifdef INET #ifdef INET
{ SOCK_RAW, &inet6domain, IPPROTO_IPV4, PR_ATOMIC|PR_ADDR|PR_LASTHDR, {
encap6_input, rip6_output, 0, rip6_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inet6domain,
encap_init, 0, 0, 0, .pr_protocol = IPPROTO_IPV4,
&rip6_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR,
.pr_input = encap6_input,
.pr_output = rip6_output,
.pr_ctloutput = rip6_ctloutput,
.pr_init = encap_init,
.pr_usrreqs = &rip6_usrreqs
}, },
#endif /* INET */ #endif /* INET */
{ SOCK_RAW, &inet6domain, IPPROTO_IPV6, PR_ATOMIC|PR_ADDR|PR_LASTHDR, {
encap6_input, rip6_output, 0, rip6_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inet6domain,
encap_init, 0, 0, 0, .pr_protocol = IPPROTO_IPV6,
&rip6_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR,
.pr_input = encap6_input,
.pr_output = rip6_output,
.pr_ctloutput = rip6_ctloutput,
.pr_init = encap_init,
.pr_usrreqs = &rip6_usrreqs
}, },
{ SOCK_RAW, &inet6domain, IPPROTO_PIM, PR_ATOMIC|PR_ADDR|PR_LASTHDR, {
pim6_input, rip6_output, 0, rip6_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inet6domain,
0, 0, 0, 0, .pr_protocol = IPPROTO_PIM,
&rip6_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR|PR_LASTHDR,
.pr_input = pim6_input,
.pr_output = rip6_output,
.pr_ctloutput = rip6_ctloutput,
.pr_usrreqs = &rip6_usrreqs
}, },
#ifdef DEV_CARP #ifdef DEV_CARP
{ SOCK_RAW, &inet6domain, IPPROTO_CARP, PR_ATOMIC|PR_ADDR, {
carp6_input, rip6_output, 0, rip6_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inet6domain,
0, 0, 0, 0, .pr_protocol = IPPROTO_CARP,
&rip6_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_input = carp6_input,
.pr_output = rip6_output,
.pr_ctloutput = rip6_ctloutput,
.pr_usrreqs = &rip6_usrreqs
}, },
#endif /* DEV_CARP */ #endif /* DEV_CARP */
/* raw wildcard */ /* raw wildcard */
{ SOCK_RAW, &inet6domain, 0, PR_ATOMIC|PR_ADDR, {
rip6_input, rip6_output, 0, rip6_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &inet6domain,
0, 0, 0, 0, .pr_flags = PR_ATOMIC|PR_ADDR,
&rip6_usrreqs .pr_input = rip6_input,
.pr_output = rip6_output,
.pr_ctloutput = rip6_ctloutput,
.pr_usrreqs = &rip6_usrreqs
}, },
}; };
extern int in6_inithead __P((void **, int)); extern int in6_inithead __P((void **, int));
struct domain inet6domain = struct domain inet6domain = {
{ AF_INET6, "internet6", 0, 0, 0, .dom_family = AF_INET6,
(struct protosw *)inet6sw, .dom_name = "internet6",
(struct protosw *)&inet6sw[sizeof(inet6sw)/sizeof(inet6sw[0])], 0, .dom_protosw = (struct protosw *)inet6sw,
in6_inithead, .dom_protoswNPROTOSW = (struct protosw *)
offsetof(struct sockaddr_in6, sin6_addr) << 3, &inet6sw[sizeof(inet6sw)/sizeof(inet6sw[0])],
sizeof(struct sockaddr_in6), .dom_rtattach = in6_inithead,
in6_domifattach, in6_domifdetach, }; .dom_rtoffset = offsetof(struct sockaddr_in6, sin6_addr) << 3,
.dom_maxrtkey = sizeof(struct sockaddr_in6),
.dom_ifattach = in6_domifattach,
.dom_ifdetach = in6_domifdetach
};
DOMAIN_SET(inet6); DOMAIN_SET(inet6);

24
sys/netipsec/keysock.c
View File

@ -585,11 +585,15 @@ SYSCTL_NODE(_net, PF_KEY, key, CTLFLAG_RW, 0, "Key Family");
extern struct domain keydomain; extern struct domain keydomain;
struct protosw keysw[] = { struct protosw keysw[] = {
{ SOCK_RAW, &keydomain, PF_KEY_V2, PR_ATOMIC|PR_ADDR, {
0, (pr_output_t *)key_output, raw_ctlinput, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &keydomain,
raw_init, 0, 0, 0, .pr_protocol = PF_KEY_V2,
&key_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_output = (pr_output_t *)key_output,
.pr_ctlinput = raw_ctlinput,
.pr_init = raw_init,
.pr_usrreqs = &key_usrreqs
} }
}; };
@ -600,8 +604,12 @@ key_init0(void)
key_init(); key_init();
} }
struct domain keydomain = struct domain keydomain = {
{ PF_KEY, "key", key_init0, 0, 0, .dom_family = PF_KEY,
keysw, &keysw[sizeof(keysw)/sizeof(keysw[0])] }; .dom_name = "key",
.dom_init = key_init0,
.dom_protosw = keysw,
.dom_protoswNPROTOSW = &keysw[sizeof(keysw)/sizeof(keysw[0])]
};
DOMAIN_SET(key); DOMAIN_SET(key);

75
sys/netipx/ipx_proto.c
View File

@ -61,42 +61,59 @@ static struct pr_usrreqs nousrreqs;
*/ */
static struct protosw ipxsw[] = { static struct protosw ipxsw[] = {
{ 0, &ipxdomain, 0, 0, {
0, 0, 0, 0, .pr_domain = &ipxdomain,
0, .pr_init = ipx_init,
ipx_init, 0, 0, 0, .pr_usrreqs = &nousrreqs
&nousrreqs
}, },
{ SOCK_DGRAM, &ipxdomain, 0, PR_ATOMIC|PR_ADDR, {
0, 0, ipx_ctlinput, ipx_ctloutput, .pr_type = SOCK_DGRAM,
0, .pr_domain = &ipxdomain,
0, 0, 0, 0, .pr_flags = PR_ATOMIC|PR_ADDR,
&ipx_usrreqs .pr_ctlinput = ipx_ctlinput,
.pr_ctloutput = ipx_ctloutput,
.pr_usrreqs = &ipx_usrreqs
}, },
{ SOCK_STREAM, &ipxdomain, IPXPROTO_SPX, PR_CONNREQUIRED|PR_WANTRCVD, {
0, 0, spx_ctlinput, spx_ctloutput, .pr_type = SOCK_STREAM,
0, .pr_domain = &ipxdomain,
spx_init, spx_fasttimo, spx_slowtimo, 0, .pr_protocol = IPXPROTO_SPX,
&spx_usrreqs .pr_flags = PR_CONNREQUIRED|PR_WANTRCVD,
.pr_ctlinput = spx_ctlinput,
.pr_ctloutput = spx_ctloutput,
.pr_init = spx_init,
.pr_fasttimo = spx_fasttimo,
.pr_slowtimo = spx_slowtimo,
.pr_usrreqs = &spx_usrreqs
}, },
{ SOCK_SEQPACKET,&ipxdomain, IPXPROTO_SPX, PR_CONNREQUIRED|PR_WANTRCVD|PR_ATOMIC, {
0, 0, spx_ctlinput, spx_ctloutput, .pr_type = SOCK_SEQPACKET,
0, .pr_domain = &ipxdomain,
0, 0, 0, 0, .pr_protocol = IPXPROTO_SPX,
&spx_usrreq_sps .pr_flags = PR_CONNREQUIRED|PR_WANTRCVD|PR_ATOMIC,
.pr_ctlinput = spx_ctlinput,
.pr_ctloutput = spx_ctloutput,
.pr_usrreqs = &spx_usrreq_sps
}, },
{ SOCK_RAW, &ipxdomain, IPXPROTO_RAW, PR_ATOMIC|PR_ADDR, {
0, 0, 0, ipx_ctloutput, .pr_type = SOCK_RAW,
0, .pr_domain = &ipxdomain,
0, 0, 0, 0, .pr_protocol = IPXPROTO_RAW,
&ripx_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_ctloutput = ipx_ctloutput,
.pr_usrreqs = &ripx_usrreqs
}, },
}; };
static struct domain ipxdomain = static struct domain ipxdomain = {
{ AF_IPX, "network systems", 0, 0, 0, .dom_family = AF_IPX,
ipxsw, &ipxsw[sizeof(ipxsw)/sizeof(ipxsw[0])], 0, .dom_name = "network systems",
rn_inithead, 16, sizeof(struct sockaddr_ipx)}; .dom_protosw = ipxsw,
.dom_protoswNPROTOSW = &ipxsw[sizeof(ipxsw)/sizeof(ipxsw[0])],
.dom_rtattach = rn_inithead,
.dom_rtoffset = 16,
.dom_maxrtkey = sizeof(struct sockaddr_ipx)
};
DOMAIN_SET(ipx); DOMAIN_SET(ipx);
SYSCTL_NODE(_net, PF_IPX, ipx, CTLFLAG_RW, 0, SYSCTL_NODE(_net, PF_IPX, ipx, CTLFLAG_RW, 0,

24
sys/netkey/keysock.c
View File

@ -495,16 +495,24 @@ SYSCTL_NODE(_net, PF_KEY, key, CTLFLAG_RW, 0, "Key Family");
extern struct domain keydomain; extern struct domain keydomain;
struct protosw keysw[] = { struct protosw keysw[] = {
{ SOCK_RAW, &keydomain, PF_KEY_V2, PR_ATOMIC|PR_ADDR, {
0, (pr_output_t *)key_output, raw_ctlinput, 0, .pr_type = SOCK_RAW,
0, .pr_domain = &keydomain,
raw_init, 0, 0, 0, .pr_protocol = PF_KEY_V2,
&key_usrreqs .pr_flags = PR_ATOMIC|PR_ADDR,
.pr_output = (pr_output_t *)key_output,
.pr_ctlinput = raw_ctlinput,
.pr_init = raw_init,
.pr_usrreqs = &key_usrreqs
} }
}; };
struct domain keydomain = struct domain keydomain = {
{ PF_KEY, "key", key_init, 0, 0, .dom_family = PF_KEY,
keysw, &keysw[sizeof(keysw)/sizeof(keysw[0])] }; .dom_name = "key",
.dom_init = key_init,
.dom_protosw = keysw,
.dom_protoswNPROTOSW = &keysw[sizeof(keysw)/sizeof(keysw[0])]
};
DOMAIN_SET(key); DOMAIN_SET(key);

44
sys/netnatm/natm_proto.c
View File

@ -57,30 +57,36 @@ extern struct domain natmdomain;
static void natm_init(void); static void natm_init(void);
static struct protosw natmsw[] = { static struct protosw natmsw[] = {
{ SOCK_STREAM, &natmdomain, PROTO_NATMAAL5, PR_CONNREQUIRED, {
0, 0, 0, 0, .pr_type = SOCK_STREAM,
0, .pr_domain = &natmdomain,
0, 0, 0, 0, .pr_protocol = PROTO_NATMAAL5,
&natm_usrreqs .pr_flags = PR_CONNREQUIRED,
.pr_usrreqs = &natm_usrreqs
}, },
{ SOCK_DGRAM, &natmdomain, PROTO_NATMAAL5, PR_CONNREQUIRED | PR_ATOMIC, {
0, 0, 0, 0, .pr_type = SOCK_DGRAM,
0, .pr_domain = &natmdomain,
0, 0, 0, 0, .pr_protocol = PROTO_NATMAAL5,
&natm_usrreqs .pr_flags = PR_CONNREQUIRED|PR_ATOMIC,
.pr_usrreqs = &natm_usrreqs
}, },
{ SOCK_STREAM, &natmdomain, PROTO_NATMAAL0, PR_CONNREQUIRED, {
0, 0, 0, 0, .pr_type = SOCK_STREAM,
0, .pr_domain = &natmdomain,
0, 0, 0, 0, .pr_protocol = PROTO_NATMAAL0,
&natm_usrreqs .pr_flags = PR_CONNREQUIRED,
.pr_usrreqs = &natm_usrreqs
}, },
}; };
static struct domain natmdomain = static struct domain natmdomain = {
{ AF_NATM, "natm", natm_init, 0, 0, .dom_family = AF_NATM,
natmsw, &natmsw[sizeof(natmsw)/sizeof(natmsw[0])], 0, .dom_name = "natm",
0, 0, 0}; .dom_init = natm_init,
.dom_protosw = natmsw,
.dom_protoswNPROTOSW = &natmsw[sizeof(natmsw)/sizeof(natmsw[0])],
};
static int natmqmaxlen = 1000 /* IFQ_MAXLEN */; /* max # of packets on queue */ static int natmqmaxlen = 1000 /* IFQ_MAXLEN */; /* max # of packets on queue */
static struct ifqueue natmintrq; static struct ifqueue natmintrq;