* Copyright (c) 1982, 1986, 1988 Regents of the University of California.
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by the University of California, Berkeley. The name of the
* University may not be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
* @(#)ip_output.c 7.13 (Berkeley) 6/29/88
#include "../net/route.h"
#include "../machine/mtpr.h"
struct mbuf
*ip_insertoptions();
* 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
)
register struct ip
*ip
, *mhip
;
register struct ifnet
*ifp
;
register struct mbuf
*m
= m0
;
register int hlen
= sizeof (struct ip
);
m
= ip_insertoptions(m
, opt
, &len
);
ip
= mtod(m
, struct ip
*);
if ((flags
& IP_FORWARDING
) == 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_addr
= ip
->ip_dst
;
* If routing to interface only,
* short circuit routing lookup.
if (flags
& IP_ROUTETOIF
) {
ia
= (struct in_ifaddr
*)ifa_ifwithdstaddr((struct sockaddr
*)dst
);
ia
= in_iaonnetof(in_netof(ip
->ip_dst
));
if (ro
->ro_rt
== 0 || (ifp
= ro
->ro_rt
->rt_ifp
) == 0) {
if (in_localaddr(ip
->ip_dst
))
if (ro
->ro_rt
->rt_flags
& RTF_GATEWAY
)
dst
= (struct sockaddr_in
*)&ro
->ro_rt
->rt_gateway
;
* 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
;
* Look for broadcast address and
* and verify user is allowed to send
if (in_broadcast(dst
->sin_addr
)) {
if ((ifp
->if_flags
& IFF_BROADCAST
) == 0) {
if ((flags
& IP_ALLOWBROADCAST
) == 0) {
/* don't allow broadcast messages to be fragmented */
if (ip
->ip_len
> ifp
->if_mtu
) {
* If small enough for interface, can just send directly.
if (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
);
* 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_act
;
* 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
< ip
->ip_len
; off
+= len
) {
MGET(m
, M_DONTWAIT
, MT_HEADER
);
m
->m_off
= MMAXOFF
- hlen
;
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
>= ip
->ip_len
)
mhip
->ip_len
= htons((u_short
)(len
+ mhlen
));
m
->m_next
= m_copy(m0
, off
, len
);
error
= ENOBUFS
; /* ??? */
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(m0
, hlen
+ firstlen
- ip
->ip_len
);
ip
->ip_len
= htons((u_short
)(hlen
+ firstlen
));
ip
->ip_off
= htons((u_short
)(ip
->ip_off
| IP_MF
));
ip
->ip_sum
= in_cksum(m0
, hlen
);
for (m
= m0
; m
; m
= m0
) {
error
= (*ifp
->if_output
)(ifp
, m
,
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
);
ip
->ip_dst
= p
->ipopt_dst
;
if (m
->m_off
>= MMAXOFF
|| MMINOFF
+ optlen
> m
->m_off
) {
MGET(n
, M_DONTWAIT
, MT_HEADER
);
m
->m_len
-= sizeof(struct ip
);
m
->m_off
+= sizeof(struct ip
);
m
->m_off
= MMAXOFF
- sizeof(struct ip
) - optlen
;
m
->m_len
= optlen
+ sizeof(struct ip
);
bcopy((caddr_t
)ip
, mtod(m
, caddr_t
), sizeof(struct ip
));
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
) {
/* 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
, m
)
struct inpcb
*inp
= sotoinpcb(so
);
return (ip_pcbopts(&inp
->inp_options
, *m
));
*m
= m_get(M_WAIT
, MT_SOOPTS
);
(*m
)->m_off
= inp
->inp_options
->m_off
;
(*m
)->m_len
= inp
->inp_options
->m_len
;
bcopy(mtod(inp
->inp_options
, caddr_t
),
mtod(*m
, caddr_t
), (unsigned)(*m
)->m_len
);
if (op
== PRCO_SETOPT
&& *m
)
* 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.
/* 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 MAX_IPOPTLEN >= MMAXOFF - MMINOFF
if (m
->m_off
+ m
->m_len
+ sizeof(struct in_addr
) > MAX_IPOPTLEN
)
if (m
->m_off
+ m
->m_len
+ sizeof(struct in_addr
) > MMAXOFF
)
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
));