* Copyright (c) 1982, 1986, 1988, 1990, 1993
* The Regents of the University of California. All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* @(#)ip_output.c 8.3 (Berkeley) 1/21/94
#include <sys/socketvar.h>
#include <netinet/in_systm.h>
#include <netinet/in_pcb.h>
#include <netinet/in_var.h>
#include <netinet/ip_var.h>
#include <machine/mtpr.h>
static struct mbuf
*ip_insertoptions
__P((struct mbuf
*, struct mbuf
*, int *));
__P((struct ifnet
*, struct mbuf
*, struct sockaddr_in
*));
* IP output. The packet in mbuf chain m contains a skeletal IP
* header (with len, off, ttl, proto, tos, src, dst).
* The mbuf chain containing the packet will be freed.
* The mbuf opt, if present, will not be freed.
ip_output(m0
, opt
, ro
, flags
, imo
)
register struct ip
*ip
, *mhip
;
register struct ifnet
*ifp
;
register struct mbuf
*m
= m0
;
register int hlen
= sizeof (struct ip
);
if ((m
->m_flags
& M_PKTHDR
) == 0)
panic("ip_output no HDR");
m
= ip_insertoptions(m
, opt
, &len
);
ip
= mtod(m
, struct ip
*);
if ((flags
& (IP_FORWARDING
|IP_RAWOUTPUT
)) == 0) {
ip
->ip_id
= htons(ip_id
++);
bzero((caddr_t
)ro
, sizeof (*ro
));
dst
= (struct sockaddr_in
*)&ro
->ro_dst
;
* If there is a cached route,
* check that it is to the same destination
* and is still up. If not, free it and try again.
if (ro
->ro_rt
&& ((ro
->ro_rt
->rt_flags
& RTF_UP
) == 0 ||
dst
->sin_addr
.s_addr
!= ip
->ip_dst
.s_addr
)) {
ro
->ro_rt
= (struct rtentry
*)0;
dst
->sin_family
= AF_INET
;
dst
->sin_len
= sizeof(*dst
);
dst
->sin_addr
= ip
->ip_dst
;
* If routing to interface only,
* short circuit routing lookup.
#define ifatoia(ifa) ((struct in_ifaddr *)(ifa))
#define sintosa(sin) ((struct sockaddr *)(sin))
if (flags
& IP_ROUTETOIF
) {
if ((ia
= ifatoia(ifa_ifwithdstaddr(sintosa(dst
)))) == 0 &&
(ia
= ifatoia(ifa_ifwithnet(sintosa(dst
)))) == 0) {
ia
= ifatoia(ro
->ro_rt
->rt_ifa
);
if (ro
->ro_rt
->rt_flags
& RTF_GATEWAY
)
dst
= (struct sockaddr_in
*)ro
->ro_rt
->rt_gateway
;
if (IN_MULTICAST(ntohl(ip
->ip_dst
.s_addr
))) {
extern struct ifnet loif
;
* IP destination address is multicast. Make sure "dst"
* still points to the address in "ro". (It may have been
* changed to point to a gateway address, above.)
dst
= (struct sockaddr_in
*)&ro
->ro_dst
;
* See if the caller provided any multicast options
ip
->ip_ttl
= imo
->imo_multicast_ttl
;
if (imo
->imo_multicast_ifp
!= NULL
)
ifp
= imo
->imo_multicast_ifp
;
ip
->ip_ttl
= IP_DEFAULT_MULTICAST_TTL
;
* Confirm that the outgoing interface supports multicast.
if ((ifp
->if_flags
& IFF_MULTICAST
) == 0) {
* If source address not specified yet, use address
if (ip
->ip_src
.s_addr
== INADDR_ANY
) {
register struct in_ifaddr
*ia
;
for (ia
= in_ifaddr
; ia
; ia
= ia
->ia_next
)
ip
->ip_src
= IA_SIN(ia
)->sin_addr
;
IN_LOOKUP_MULTI(ip
->ip_dst
, ifp
, inm
);
(imo
== NULL
|| imo
->imo_multicast_loop
)) {
* If we belong to the destination multicast group
* on the outgoing interface, and the caller did not
* forbid loopback, loop back a copy.
ip_mloopback(ifp
, m
, dst
);
* If we are acting as a multicast router, perform
* multicast forwarding as if the packet had just
* arrived on the interface to which we are about
* to send. The multicast forwarding function
* recursively calls this function, using the
* IP_FORWARDING flag to prevent infinite recursion.
* Multicasts that are looped back by ip_mloopback(),
* above, will be forwarded by the ip_input() routine,
extern struct socket
*ip_mrouter
;
if (ip_mrouter
&& (flags
& IP_FORWARDING
) == 0) {
if (ip_mforward(m
, ifp
) != 0) {
* Multicasts with a time-to-live of zero may be looped-
* back, above, but must not be transmitted on a network.
* Also, multicasts addressed to the loopback interface
* are not sent -- the above call to ip_mloopback() will
* loop back a copy if this host actually belongs to the
* destination group on the loopback interface.
if (ip
->ip_ttl
== 0 || ifp
== &loif
) {
* If source address not specified yet, use address
if (ip
->ip_src
.s_addr
== INADDR_ANY
)
ip
->ip_src
= IA_SIN(ia
)->sin_addr
;
* Look for broadcast address and
* and verify user is allowed to send
if (in_broadcast(dst
->sin_addr
, ifp
)) {
if ((ifp
->if_flags
& IFF_BROADCAST
) == 0) {
if ((flags
& IP_ALLOWBROADCAST
) == 0) {
/* don't allow broadcast messages to be fragmented */
if ((u_short
)ip
->ip_len
> ifp
->if_mtu
) {
* If small enough for interface, can just send directly.
if ((u_short
)ip
->ip_len
<= ifp
->if_mtu
) {
ip
->ip_len
= htons((u_short
)ip
->ip_len
);
ip
->ip_off
= htons((u_short
)ip
->ip_off
);
ip
->ip_sum
= in_cksum(m
, hlen
);
error
= (*ifp
->if_output
)(ifp
, m
,
(struct sockaddr
*)dst
, ro
->ro_rt
);
* Too large for interface; fragment if possible.
* Must be able to put at least 8 bytes per fragment.
if (ip
->ip_off
& IP_DF
) {
len
= (ifp
->if_mtu
- hlen
) &~ 7;
int mhlen
, firstlen
= len
;
struct mbuf
**mnext
= &m
->m_nextpkt
;
* Loop through length of segment after first fragment,
* make new header and copy data of each part and link onto chain.
mhlen
= sizeof (struct ip
);
for (off
= hlen
+ len
; off
< (u_short
)ip
->ip_len
; off
+= len
) {
MGETHDR(m
, M_DONTWAIT
, MT_HEADER
);
m
->m_data
+= max_linkhdr
;
mhip
= mtod(m
, struct ip
*);
if (hlen
> sizeof (struct ip
)) {
mhlen
= ip_optcopy(ip
, mhip
) + sizeof (struct ip
);
mhip
->ip_hl
= mhlen
>> 2;
mhip
->ip_off
= ((off
- hlen
) >> 3) + (ip
->ip_off
& ~IP_MF
);
if (off
+ len
>= (u_short
)ip
->ip_len
)
len
= (u_short
)ip
->ip_len
- off
;
mhip
->ip_len
= htons((u_short
)(len
+ mhlen
));
m
->m_next
= m_copy(m0
, off
, len
);
error
= ENOBUFS
; /* ??? */
m
->m_pkthdr
.len
= mhlen
+ len
;
m
->m_pkthdr
.rcvif
= (struct ifnet
*)0;
mhip
->ip_off
= htons((u_short
)mhip
->ip_off
);
mhip
->ip_sum
= in_cksum(m
, mhlen
);
* Update first fragment by trimming what's been copied out
* and updating header, then send each fragment (in order).
m_adj(m
, hlen
+ firstlen
- (u_short
)ip
->ip_len
);
m
->m_pkthdr
.len
= hlen
+ firstlen
;
ip
->ip_len
= htons((u_short
)m
->m_pkthdr
.len
);
ip
->ip_off
= htons((u_short
)(ip
->ip_off
| IP_MF
));
ip
->ip_sum
= in_cksum(m
, hlen
);
for (m
= m0
; m
; m
= m0
) {
error
= (*ifp
->if_output
)(ifp
, m
,
(struct sockaddr
*)dst
, ro
->ro_rt
);
if (ro
== &iproute
&& (flags
& IP_ROUTETOIF
) == 0 && ro
->ro_rt
)
* Insert IP options into preformed packet.
* Adjust IP destination as required for IP source routing,
* as indicated by a non-zero in_addr at the start of the options.
ip_insertoptions(m
, opt
, phlen
)
register struct ipoption
*p
= mtod(opt
, struct ipoption
*);
register struct ip
*ip
= mtod(m
, struct ip
*);
optlen
= opt
->m_len
- sizeof(p
->ipopt_dst
);
if (optlen
+ (u_short
)ip
->ip_len
> IP_MAXPACKET
)
return (m
); /* XXX should fail */
ip
->ip_dst
= p
->ipopt_dst
;
if (m
->m_flags
& M_EXT
|| m
->m_data
- optlen
< m
->m_pktdat
) {
MGETHDR(n
, M_DONTWAIT
, MT_HEADER
);
n
->m_pkthdr
.len
= m
->m_pkthdr
.len
+ optlen
;
m
->m_len
-= sizeof(struct ip
);
m
->m_data
+= sizeof(struct ip
);
m
->m_len
= optlen
+ sizeof(struct ip
);
m
->m_data
+= max_linkhdr
;
bcopy((caddr_t
)ip
, mtod(m
, caddr_t
), sizeof(struct ip
));
m
->m_pkthdr
.len
+= optlen
;
ovbcopy((caddr_t
)ip
, mtod(m
, caddr_t
), sizeof(struct ip
));
ip
= mtod(m
, struct ip
*);
bcopy((caddr_t
)p
->ipopt_list
, (caddr_t
)(ip
+ 1), (unsigned)optlen
);
*phlen
= sizeof(struct ip
) + optlen
;
* Copy options from ip to jp,
* omitting those not copied during fragmentation.
register u_char
*cp
, *dp
;
cnt
= (ip
->ip_hl
<< 2) - sizeof (struct ip
);
for (; cnt
> 0; cnt
-= optlen
, cp
+= optlen
) {
/* Preserve for IP mcast tunnel's LSRR alignment. */
/* bogus lengths should have been caught by ip_dooptions */
bcopy((caddr_t
)cp
, (caddr_t
)dp
, (unsigned)optlen
);
for (optlen
= dp
- (u_char
*)(jp
+1); optlen
& 0x3; optlen
++)
* IP socket option processing.
ip_ctloutput(op
, so
, level
, optname
, mp
)
register struct inpcb
*inp
= sotoinpcb(so
);
register struct mbuf
*m
= *mp
;
if (level
!= IPPROTO_IP
) {
if (op
== PRCO_SETOPT
&& *mp
)
return (ip_pcbopts(optname
, &inp
->inp_options
, m
));
return (ip_pcbopts(&inp
->inp_options
, m
));
if (m
->m_len
!= sizeof(int))
optval
= *mtod(m
, int *);
inp
->inp_ip
.ip_tos
= optval
;
inp
->inp_ip
.ip_ttl
= optval
;
error
= ip_setmoptions(optname
, &inp
->inp_moptions
, m
);
*mp
= m
= m_get(M_WAIT
, MT_SOOPTS
);
m
->m_len
= inp
->inp_options
->m_len
;
bcopy(mtod(inp
->inp_options
, caddr_t
),
mtod(m
, caddr_t
), (unsigned)m
->m_len
);
*mp
= m
= m_get(M_WAIT
, MT_SOOPTS
);
optval
= inp
->inp_ip
.ip_tos
;
optval
= inp
->inp_ip
.ip_ttl
;
#define OPTBIT(bit) (inp->inp_flags & bit ? 1 : 0)
optval
= OPTBIT(INP_RECVOPTS
);
optval
= OPTBIT(INP_RECVRETOPTS
);
optval
= OPTBIT(INP_RECVDSTADDR
);
*mtod(m
, int *) = optval
;
error
= ip_getmoptions(optname
, inp
->inp_moptions
, mp
);
* Set up IP options in pcb for insertion in output packets.
* Store in mbuf with pointer in pcbopt, adding pseudo-option
* with destination address if source routed.
ip_pcbopts(optname
, pcbopt
, m
)
/* turn off any old options */
if (m
== (struct mbuf
*)0 || m
->m_len
== 0) {
* Only turning off any previous options.
if (m
->m_len
% sizeof(long))
* IP first-hop destination address will be stored before
* actual options; move other options back
* and clear it when none present.
if (m
->m_data
+ m
->m_len
+ sizeof(struct in_addr
) >= &m
->m_dat
[MLEN
])
m
->m_len
+= sizeof(struct in_addr
);
cp
= mtod(m
, u_char
*) + sizeof(struct in_addr
);
ovbcopy(mtod(m
, caddr_t
), (caddr_t
)cp
, (unsigned)cnt
);
bzero(mtod(m
, caddr_t
), sizeof(struct in_addr
));
for (; cnt
> 0; cnt
-= optlen
, cp
+= optlen
) {
if (optlen
<= IPOPT_OLEN
|| optlen
> cnt
)
* user process specifies route as:
* D must be our final destination (but we can't
* check that since we may not have connected yet).
* A is first hop destination, which doesn't appear in
* actual IP option, but is stored before the options.
if (optlen
< IPOPT_MINOFF
- 1 + sizeof(struct in_addr
))
m
->m_len
-= sizeof(struct in_addr
);
cnt
-= sizeof(struct in_addr
);
optlen
-= sizeof(struct in_addr
);
* Move first hop before start of options.
bcopy((caddr_t
)&cp
[IPOPT_OFFSET
+1], mtod(m
, caddr_t
),
* Then copy rest of options back
* to close up the deleted entry.
ovbcopy((caddr_t
)(&cp
[IPOPT_OFFSET
+1] +
(caddr_t
)&cp
[IPOPT_OFFSET
+1],
(unsigned)cnt
+ sizeof(struct in_addr
));
if (m
->m_len
> MAX_IPOPTLEN
+ sizeof(struct in_addr
))
* Set the IP multicast options in response to user setsockopt().
ip_setmoptions(optname
, imop
, m
)
struct ip_moptions
**imop
;
register struct ip_mreq
*mreq
;
register struct ifnet
*ifp
;
register struct ip_moptions
*imo
= *imop
;
register struct sockaddr_in
*dst
;
* No multicast option buffer attached to the pcb;
* allocate one and initialize to default values.
imo
= (struct ip_moptions
*)malloc(sizeof(*imo
), M_IPMOPTS
,
imo
->imo_multicast_ifp
= NULL
;
imo
->imo_multicast_ttl
= IP_DEFAULT_MULTICAST_TTL
;
imo
->imo_multicast_loop
= IP_DEFAULT_MULTICAST_LOOP
;
imo
->imo_num_memberships
= 0;
* Select the interface for outgoing multicast packets.
if (m
== NULL
|| m
->m_len
!= sizeof(struct in_addr
)) {
addr
= *(mtod(m
, struct in_addr
*));
* INADDR_ANY is used to remove a previous selection.
* When no interface is selected, a default one is
* chosen every time a multicast packet is sent.
if (addr
.s_addr
== INADDR_ANY
) {
imo
->imo_multicast_ifp
= NULL
;
* The selected interface is identified by its local
* IP address. Find the interface and confirm that
* it supports multicasting.
INADDR_TO_IFP(addr
, ifp
);
if (ifp
== NULL
|| (ifp
->if_flags
& IFF_MULTICAST
) == 0) {
imo
->imo_multicast_ifp
= ifp
;
* Set the IP time-to-live for outgoing multicast packets.
if (m
== NULL
|| m
->m_len
!= 1) {
imo
->imo_multicast_ttl
= *(mtod(m
, u_char
*));
* Set the loopback flag for outgoing multicast packets.
if (m
== NULL
|| m
->m_len
!= 1 ||
(loop
= *(mtod(m
, u_char
*))) > 1) {
imo
->imo_multicast_loop
= loop
;
* Add a multicast group membership.
* Group must be a valid IP multicast address.
if (m
== NULL
|| m
->m_len
!= sizeof(struct ip_mreq
)) {
mreq
= mtod(m
, struct ip_mreq
*);
if (!IN_MULTICAST(ntohl(mreq
->imr_multiaddr
.s_addr
))) {
* If no interface address was provided, use the interface of
* the route to the given multicast address.
if (mreq
->imr_interface
.s_addr
== INADDR_ANY
) {
dst
= (struct sockaddr_in
*)&ro
.ro_dst
;
dst
->sin_len
= sizeof(*dst
);
dst
->sin_family
= AF_INET
;
dst
->sin_addr
= mreq
->imr_multiaddr
;
INADDR_TO_IFP(mreq
->imr_interface
, ifp
);
* See if we found an interface, and confirm that it
if (ifp
== NULL
|| (ifp
->if_flags
& IFF_MULTICAST
) == 0) {
* See if the membership already exists or if all the
* membership slots are full.
for (i
= 0; i
< imo
->imo_num_memberships
; ++i
) {
if (imo
->imo_membership
[i
]->inm_ifp
== ifp
&&
imo
->imo_membership
[i
]->inm_addr
.s_addr
== mreq
->imr_multiaddr
.s_addr
)
if (i
< imo
->imo_num_memberships
) {
if (i
== IP_MAX_MEMBERSHIPS
) {
* Everything looks good; add a new record to the multicast
* address list for the given interface.
if ((imo
->imo_membership
[i
] =
in_addmulti(&mreq
->imr_multiaddr
, ifp
)) == NULL
) {
++imo
->imo_num_memberships
;
* Drop a multicast group membership.
* Group must be a valid IP multicast address.
if (m
== NULL
|| m
->m_len
!= sizeof(struct ip_mreq
)) {
mreq
= mtod(m
, struct ip_mreq
*);
if (!IN_MULTICAST(ntohl(mreq
->imr_multiaddr
.s_addr
))) {
* If an interface address was specified, get a pointer
* to its ifnet structure.
if (mreq
->imr_interface
.s_addr
== INADDR_ANY
)
INADDR_TO_IFP(mreq
->imr_interface
, ifp
);
* Find the membership in the membership array.
for (i
= 0; i
< imo
->imo_num_memberships
; ++i
) {
imo
->imo_membership
[i
]->inm_ifp
== ifp
) &&
imo
->imo_membership
[i
]->inm_addr
.s_addr
==
mreq
->imr_multiaddr
.s_addr
)
if (i
== imo
->imo_num_memberships
) {
* Give up the multicast address record to which the
in_delmulti(imo
->imo_membership
[i
]);
* Remove the gap in the membership array.
for (++i
; i
< imo
->imo_num_memberships
; ++i
)
imo
->imo_membership
[i
-1] = imo
->imo_membership
[i
];
--imo
->imo_num_memberships
;
* If all options have default values, no need to keep the mbuf.
if (imo
->imo_multicast_ifp
== NULL
&&
imo
->imo_multicast_ttl
== IP_DEFAULT_MULTICAST_TTL
&&
imo
->imo_multicast_loop
== IP_DEFAULT_MULTICAST_LOOP
&&
imo
->imo_num_memberships
== 0) {
* Return the IP multicast options in response to user getsockopt().
ip_getmoptions(optname
, imo
, mp
)
register struct ip_moptions
*imo
;
register struct mbuf
**mp
;
*mp
= m_get(M_WAIT
, MT_SOOPTS
);
addr
= mtod(*mp
, struct in_addr
*);
(*mp
)->m_len
= sizeof(struct in_addr
);
if (imo
== NULL
|| imo
->imo_multicast_ifp
== NULL
)
addr
->s_addr
= INADDR_ANY
;
IFP_TO_IA(imo
->imo_multicast_ifp
, ia
);
addr
->s_addr
= (ia
== NULL
) ? INADDR_ANY
: IA_SIN(ia
)->sin_addr
.s_addr
;
ttl
= mtod(*mp
, u_char
*);
*ttl
= (imo
== NULL
) ? IP_DEFAULT_MULTICAST_TTL
: imo
->imo_multicast_ttl
;
loop
= mtod(*mp
, u_char
*);
*loop
= (imo
== NULL
) ? IP_DEFAULT_MULTICAST_LOOP
: imo
->imo_multicast_loop
;
* Discard the IP multicast options.
register struct ip_moptions
*imo
;
for (i
= 0; i
< imo
->imo_num_memberships
; ++i
)
in_delmulti(imo
->imo_membership
[i
]);
* Routine called from ip_output() to loop back a copy of an IP multicast
* packet to the input queue of a specified interface. Note that this
* calls the output routine of the loopback "driver", but with an interface
* pointer that might NOT be &loif -- easier than replicating that code here.
ip_mloopback(ifp
, m
, dst
)
register struct sockaddr_in
*dst
;
copym
= m_copy(m
, 0, M_COPYALL
);
* We don't bother to fragment if the IP length is greater
* than the interface's MTU. Can this possibly matter?
ip
= mtod(copym
, struct ip
*);
ip
->ip_len
= htons((u_short
)ip
->ip_len
);
ip
->ip_off
= htons((u_short
)ip
->ip_off
);
ip
->ip_sum
= in_cksum(copym
, ip
->ip_hl
<< 2);
(void) looutput(ifp
, copym
, (struct sockaddr
*)dst
, NULL
);