/* ip_output.c - internet output routines *//* Copyright 1984-1997 Wind River Systems, Inc. */#include "copyright_wrs.h"/* * 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 * are met: * 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 * SUCH DAMAGE. * *	@(#)ip_output.c	8.3 (Berkeley) 1/21/94 *//*modification history--------------------01o,03sep98,n_s  fixed fragmentation problem for mcast and bcast. spr #21071.01n,26aug98,n_s  added return val check for mBufClGet in ip_ctloutput and                 ip_getmoptions. spr #22238.01m,09jan98,vin  changed IP_CKSUM_SEND_MASK to IP_DO_CHECKSUM_SND01l,08dec97,vin  fixed ip_freemoptions() SPR 9970. 01k,19nov97,vin  changed extern declaration of _ipCfgFlags to int from UCHAR.01j,13nov97,vin  provided an additional flag for sending large BCAST pkts.01i,05oct97,vin  added fast multicasting.01h,15jul97,spm  made IP checksum calculation configurable (SPR #7836)01g,08mar97,vin  added mCastRouteFwdHook to access mcast routing code.01f,24mar97,vin  bug fixed in ip_mloopback() ip hdr being shared, SPR825201e,13feb97,rjc  fixed bad parameter to TOS_SET	01d,05feb97,rjc  changes for tos routing and fix for multicast bug.01c,05dec96,vin  changed malloc(..) to MALLOC(..) to use only network buffers,		 changed free(..) to FREE(..).01b,22nov96,vin  added cluster support replaced m_get(..) with mBufClGet(..)		 replaced m_gethdr with mHdrClGet(..)01a,03mar96,vin  created from BSD4.4 stuff,integrated with 02n of ip_output.c*/#include "vxWorks.h"#include "netLib.h"#include "net/mbuf.h"#include "errno.h"#include "net/protosw.h"#include "sys/socket.h"#include "net/socketvar.h"#include "net/if.h"#include "net/route.h"#include "netinet/in.h"#include "netinet/in_pcb.h"#include "netinet/in_systm.h"#include "netinet/in_var.h"#include "netinet/ip.h"#include "netinet/ip_var.h"#include "net/systm.h"/* externs */IMPORT int 	_ipCfgFlags; 		/* Calculate IP checksum? */extern FUNCPTR _mCastRouteFwdHook;	/* WRS mcast forward command hook */extern  looutput();static struct mbuf *ip_insertoptions (struct mbuf *, struct mbuf *, int *);static void ip_mloopback (struct ifnet *, struct mbuf *, struct sockaddr_in *);static int  ip_setmoptions (int, struct inpcb *, struct mbuf *);/* * 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. */intip_output(m0, opt, ro, flags, imo)	struct mbuf *m0;	struct mbuf *opt;	struct route *ro;	int flags;	struct ip_moptions *imo;{	register struct ip *ip, *mhip;	register struct ifnet *ifp;	register struct mbuf *m = m0;	register int hlen = sizeof (struct ip);	int len, off, error = 0;	struct route iproute;	struct sockaddr_in *dst;	struct in_ifaddr *ia;#ifdef	DIAGNOSTIC	if ((m->m_flags & M_PKTHDR) == 0)		panic("ip_output no HDR");#endif	if (opt) {		m = ip_insertoptions(m, opt, &len);		hlen = len;	}	ip = mtod(m, struct ip *);	/*	 * Fill in IP header.	 */	if ((flags & (IP_FORWARDING|IP_RAWOUTPUT)) == 0) {		ip->ip_v = IPVERSION;		ip->ip_off &= IP_DF;		ip->ip_id = htons(ip_id++);		ip->ip_hl = hlen >> 2;		ipstat.ips_localout++;	} else {		hlen = ip->ip_hl << 2;	}	/*	 * Route packet.	 */	if (ro == 0) {		ro = &iproute;		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)) {		RTFREE(ro->ro_rt);		ro->ro_rt = (struct rtentry *)0;	}	if (ro->ro_rt == 0) {		dst->sin_family = AF_INET;		dst->sin_len = sizeof(*dst);		dst->sin_addr = ip->ip_dst;		TOS_SET (dst, ip->ip_tos);	}	/*	 * 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) {			ipstat.ips_noroute++;			error = ENETUNREACH;			goto bad;		}		ifp = ia->ia_ifp;		ip->ip_ttl = 1;	} else if (! (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) && imo &&	              ((imo->imo_multicast_ifp != NULL)))) {		if (ro->ro_rt == 0)			rtalloc(ro);		if (ro->ro_rt == 0) {			ipstat.ips_noroute++;			error = EHOSTUNREACH;			goto bad;		}		ia = ifatoia(ro->ro_rt->rt_ifa);		ifp = ro->ro_rt->rt_ifp;		ro->ro_rt->rt_use++;		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))) {		struct in_multi *inm;		extern struct ifnet loif;		m->m_flags |= M_MCAST;		/*		 * 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;               if (imo && imo->imo_multicast_ifp != NULL)                    {                   register struct in_ifaddr *ia;                   for (ia = in_ifaddr; ia; ia = ia->ia_next)                       if (ia->ia_ifp == ifp)                            {		           dst->sin_addr.s_addr = IA_SIN(ia)->sin_addr.s_addr;	                   break;			   }                   if (ro->ro_rt)                       {                       RTFREE(ro->ro_rt);                       ro->ro_rt = (struct rtentry *)0;                       }                   }		/*		 * See if the caller provided any multicast options		 */		if (imo != NULL) {			ip->ip_ttl = imo->imo_multicast_ttl;			if (imo->imo_multicast_ifp != NULL)				ifp = imo->imo_multicast_ifp;		} else			ip->ip_ttl = IP_DEFAULT_MULTICAST_TTL;		/*		 * Confirm that the outgoing interface supports multicast.		 */		if ((ifp->if_flags & IFF_MULTICAST) == 0) {			ipstat.ips_noroute++;			error = ENETUNREACH;			goto bad;		}		/*		 * If source address not specified yet, use address		 * of outgoing interface.		 */		if (ip->ip_src.s_addr == INADDR_ANY) {			register struct in_ifaddr *ia;			for (ia = in_ifaddr; ia; ia = ia->ia_next)				if (ia->ia_ifp == ifp) {					ip->ip_src = IA_SIN(ia)->sin_addr;					break;				}		}		IN_LOOKUP_MULTI(ip->ip_dst, ifp, inm);		if (inm != NULL &&		   (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);		}		else {			/*			 * 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,			 * if necessary.			 */                	if ((_mCastRouteFwdHook != NULL) &&                            ((flags & IP_FORWARDING) == 0)) {				if ((*_mCastRouteFwdHook)(m, ifp) != 0) {					m_freem(m);					goto done;				}			}		}		/*		 * 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) {			m_freem(m);			goto done;		}		goto sendit;	}#ifndef notdef	/*	 * If source address not specified yet, use address	 * of outgoing interface.	 */	if (ip->ip_src.s_addr == INADDR_ANY)		ip->ip_src = IA_SIN(ia)->sin_addr;#endif	/*	 * Look for broadcast address and	 * and verify user is allowed to send	 * such a packet.	 */	if (in_broadcast(dst->sin_addr, ifp)) {		if ((ifp->if_flags & IFF_BROADCAST) == 0) {			error = EADDRNOTAVAIL;			goto bad;		}		if ((flags & IP_ALLOWBROADCAST) == 0) {			error = EACCES;			goto bad;		}		/* allow broadcast messages to be fragmented if flag set */		if (((u_short)ip->ip_len > ifp->if_mtu) &&                    !(_ipCfgFlags & IP_DO_LARGE_BCAST)) {			error = EMSGSIZE;			goto bad;		}		m->m_flags |= M_BCAST;	} else		m->m_flags &= ~M_BCAST;sendit:	/*	 * 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 = 0;                if (_ipCfgFlags & IP_DO_CHECKSUM_SND)                    ip->ip_sum = in_cksum(m, hlen);		error = (*ifp->if_output)(ifp, m,				(struct sockaddr *)dst, ro->ro_rt);		goto done;	}	/*	 * Too large for interface; fragment if possible.	 * Must be able to put at least 8 bytes per fragment.	 */	if (ip->ip_off & IP_DF) {		error = EMSGSIZE;		ipstat.ips_cantfrag++;		goto bad;	}	len = (ifp->if_mtu - hlen) &~ 7;	if (len < 8) {		error = EMSGSIZE;		goto bad;	}    {	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.	 */	m0 = m;	mhlen = sizeof (struct ip);	for (off = hlen + len; off < (u_short)ip->ip_len; off += len) {		m= mHdrClGet(M_DONTWAIT, MT_HEADER, CL_SIZE_128, TRUE);		if (m == 0) {			error = ENOBUFS;			ipstat.ips_odropped++;			goto sendorfree;		}		m->m_flags = m0->m_flags;		m->m_data += max_linkhdr;		mhip = mtod(m, struct ip *);		*mhip = *ip;		if (hlen > sizeof (struct ip)) {			mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip);			mhip->ip_hl = mhlen >> 2;		}		m->m_len = mhlen;		mhip->ip_off = ((off - hlen) >> 3) + (ip->ip_off & ~IP_MF);		if (ip->ip_off & IP_MF)			mhip->ip_off |= IP_MF;		if (off + len >= (u_short)ip->ip_len)			len = (u_short)ip->ip_len - off;		else			mhip->ip_off |= IP_MF;		mhip->ip_len = htons((u_short)(len + mhlen));		m->m_next = m_copy(m0, off, len);		if (m->m_next == 0) {			(void) m_free(m);			error = ENOBUFS;	/* ??? */			ipstat.ips_odropped++;			goto sendorfree;		}		m->m_pkthdr.len = mhlen + len;