1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
1996-04-18 15:49:06 +00:00
|
|
|
#define _IP_VHL
|
|
|
|
|
1998-07-06 05:04:33 +00:00
|
|
|
#include "opt_ipfw.h"
|
1998-12-14 18:09:13 +00:00
|
|
|
#include "opt_ipdn.h"
|
1997-11-05 20:17:23 +00:00
|
|
|
#include "opt_ipdivert.h"
|
1998-03-21 11:34:28 +00:00
|
|
|
#include "opt_ipfilter.h"
|
1999-12-22 19:13:38 +00:00
|
|
|
#include "opt_ipsec.h"
|
2000-07-31 13:11:42 +00:00
|
|
|
#include "opt_pfil_hooks.h"
|
2001-06-01 10:02:28 +00:00
|
|
|
#include "opt_random_ip_id.h"
|
1997-11-05 20:17:23 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
1994-05-25 09:21:21 +00:00
|
|
|
#include <sys/systm.h>
|
1998-12-21 21:36:40 +00:00
|
|
|
#include <sys/kernel.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/mbuf.h>
|
|
|
|
#include <sys/protosw.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/socketvar.h>
|
|
|
|
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <net/route.h>
|
|
|
|
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <netinet/in_systm.h>
|
|
|
|
#include <netinet/ip.h>
|
|
|
|
#include <netinet/in_pcb.h>
|
|
|
|
#include <netinet/in_var.h>
|
|
|
|
#include <netinet/ip_var.h>
|
|
|
|
|
1996-04-18 15:49:06 +00:00
|
|
|
#include <machine/in_cksum.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-10-12 20:26:33 +00:00
|
|
|
static MALLOC_DEFINE(M_IPMOPTS, "ip_moptions", "internet multicast options");
|
1997-10-11 18:31:40 +00:00
|
|
|
|
1999-12-22 19:13:38 +00:00
|
|
|
#ifdef IPSEC
|
|
|
|
#include <netinet6/ipsec.h>
|
|
|
|
#include <netkey/key.h>
|
|
|
|
#ifdef IPSEC_DEBUG
|
|
|
|
#include <netkey/key_debug.h>
|
|
|
|
#else
|
|
|
|
#define KEYDEBUG(lev,arg)
|
|
|
|
#endif
|
|
|
|
#endif /*IPSEC*/
|
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
#include <netinet/ip_fw.h>
|
1998-12-14 18:09:13 +00:00
|
|
|
#include <netinet/ip_dummynet.h>
|
|
|
|
|
1998-07-06 03:20:19 +00:00
|
|
|
#ifdef IPFIREWALL_FORWARD_DEBUG
|
|
|
|
#define print_ip(a) printf("%ld.%ld.%ld.%ld",(ntohl(a.s_addr)>>24)&0xFF,\
|
|
|
|
(ntohl(a.s_addr)>>16)&0xFF,\
|
|
|
|
(ntohl(a.s_addr)>>8)&0xFF,\
|
|
|
|
(ntohl(a.s_addr))&0xFF);
|
|
|
|
#endif
|
|
|
|
|
1994-08-18 22:36:09 +00:00
|
|
|
u_short ip_id;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
static struct mbuf *ip_insertoptions __P((struct mbuf *, struct mbuf *, int *));
|
2001-06-11 12:39:29 +00:00
|
|
|
static struct ifnet *ip_multicast_if __P((struct in_addr *, int *));
|
1995-11-14 20:34:56 +00:00
|
|
|
static void ip_mloopback
|
1997-05-06 21:22:04 +00:00
|
|
|
__P((struct ifnet *, struct mbuf *, struct sockaddr_in *, int));
|
1995-11-14 20:34:56 +00:00
|
|
|
static int ip_getmoptions
|
1998-08-23 03:07:17 +00:00
|
|
|
__P((struct sockopt *, struct ip_moptions *));
|
|
|
|
static int ip_pcbopts __P((int, struct mbuf **, struct mbuf *));
|
1995-11-14 20:34:56 +00:00
|
|
|
static int ip_setmoptions
|
1998-08-23 03:07:17 +00:00
|
|
|
__P((struct sockopt *, struct ip_moptions **));
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-04-03 10:47:12 +00:00
|
|
|
int ip_optcopy __P((struct ip *, struct ip *));
|
1997-02-10 11:45:37 +00:00
|
|
|
|
|
|
|
|
1996-07-10 19:44:30 +00:00
|
|
|
extern struct protosw inetsw[];
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
ip_output(m0, opt, ro, flags, imo)
|
|
|
|
struct mbuf *m0;
|
|
|
|
struct mbuf *opt;
|
|
|
|
struct route *ro;
|
|
|
|
int flags;
|
|
|
|
struct ip_moptions *imo;
|
|
|
|
{
|
1996-04-03 13:52:20 +00:00
|
|
|
struct ip *ip, *mhip;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
struct mbuf *m = m0;
|
|
|
|
int hlen = sizeof (struct ip);
|
1994-05-24 10:09:53 +00:00
|
|
|
int len, off, error = 0;
|
2001-12-01 13:48:16 +00:00
|
|
|
struct route iproute;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct sockaddr_in *dst;
|
|
|
|
struct in_ifaddr *ia;
|
2000-03-27 19:14:27 +00:00
|
|
|
int isbroadcast, sw_csum;
|
2001-12-28 21:21:57 +00:00
|
|
|
struct in_addr pkt_dst;
|
1999-12-22 19:13:38 +00:00
|
|
|
#ifdef IPSEC
|
2000-01-09 03:06:28 +00:00
|
|
|
struct socket *so = NULL;
|
1999-12-22 19:13:38 +00:00
|
|
|
struct secpolicy *sp = NULL;
|
|
|
|
#endif
|
1999-12-06 00:43:07 +00:00
|
|
|
u_int16_t divert_cookie; /* firewall cookie */
|
2000-07-31 13:11:42 +00:00
|
|
|
#ifdef PFIL_HOOKS
|
|
|
|
struct packet_filter_hook *pfh;
|
|
|
|
struct mbuf *m1;
|
|
|
|
int rv;
|
|
|
|
#endif /* PFIL_HOOKS */
|
1998-07-06 03:20:19 +00:00
|
|
|
#ifdef IPFIREWALL_FORWARD
|
|
|
|
int fwd_rewrite_src = 0;
|
|
|
|
#endif
|
2001-09-27 23:44:27 +00:00
|
|
|
struct ip_fw *rule = NULL;
|
1999-12-06 00:43:07 +00:00
|
|
|
|
|
|
|
#ifdef IPDIVERT
|
|
|
|
/* Get and reset firewall cookie */
|
|
|
|
divert_cookie = ip_divert_cookie;
|
|
|
|
ip_divert_cookie = 0;
|
|
|
|
#else
|
|
|
|
divert_cookie = 0;
|
1998-12-14 18:09:13 +00:00
|
|
|
#endif
|
1999-12-22 19:13:38 +00:00
|
|
|
|
1998-12-14 18:09:13 +00:00
|
|
|
/*
|
|
|
|
* dummynet packet are prepended a vestigial mbuf with
|
|
|
|
* m_type = MT_DUMMYNET and m_data pointing to the matching
|
|
|
|
* rule.
|
|
|
|
*/
|
|
|
|
if (m->m_type == MT_DUMMYNET) {
|
|
|
|
/*
|
|
|
|
* the packet was already tagged, so part of the
|
|
|
|
* processing was already done, and we need to go down.
|
2000-02-10 14:19:53 +00:00
|
|
|
* Get parameters from the header.
|
1998-12-14 18:09:13 +00:00
|
|
|
*/
|
2001-09-27 23:44:27 +00:00
|
|
|
rule = (struct ip_fw *)(m->m_data) ;
|
2000-01-08 11:28:23 +00:00
|
|
|
opt = NULL ;
|
|
|
|
ro = & ( ((struct dn_pkt *)m)->ro ) ;
|
|
|
|
imo = NULL ;
|
|
|
|
dst = ((struct dn_pkt *)m)->dn_dst ;
|
|
|
|
ifp = ((struct dn_pkt *)m)->ifp ;
|
2000-01-09 03:06:28 +00:00
|
|
|
flags = ((struct dn_pkt *)m)->flags ;
|
2000-01-08 11:28:23 +00:00
|
|
|
|
1999-02-19 18:32:55 +00:00
|
|
|
m0 = m = m->m_next ;
|
2000-01-09 03:06:28 +00:00
|
|
|
#ifdef IPSEC
|
2000-07-04 16:35:15 +00:00
|
|
|
so = ipsec_getsocket(m);
|
2001-06-11 12:39:29 +00:00
|
|
|
(void)ipsec_setsocket(m, NULL);
|
2000-01-09 03:06:28 +00:00
|
|
|
#endif
|
1998-12-14 18:09:13 +00:00
|
|
|
ip = mtod(m, struct ip *);
|
|
|
|
hlen = IP_VHL_HL(ip->ip_vhl) << 2 ;
|
2001-09-29 03:23:44 +00:00
|
|
|
ia = ifatoia(ro->ro_rt->rt_ifa);
|
1998-12-14 18:09:13 +00:00
|
|
|
goto sendit;
|
|
|
|
} else
|
|
|
|
rule = NULL ;
|
2000-01-09 03:06:28 +00:00
|
|
|
#ifdef IPSEC
|
2000-07-04 16:35:15 +00:00
|
|
|
so = ipsec_getsocket(m);
|
2001-06-11 12:39:29 +00:00
|
|
|
(void)ipsec_setsocket(m, NULL);
|
2000-01-09 03:06:28 +00:00
|
|
|
#endif
|
1998-12-14 18:09:13 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#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 *);
|
2001-12-28 21:21:57 +00:00
|
|
|
pkt_dst = ip_fw_fwd_addr == NULL
|
|
|
|
? ip->ip_dst : ip_fw_fwd_addr->sin_addr;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Fill in IP header.
|
|
|
|
*/
|
|
|
|
if ((flags & (IP_FORWARDING|IP_RAWOUTPUT)) == 0) {
|
1996-04-18 15:49:06 +00:00
|
|
|
ip->ip_vhl = IP_MAKE_VHL(IPVERSION, hlen >> 2);
|
1994-05-24 10:09:53 +00:00
|
|
|
ip->ip_off &= IP_DF;
|
2001-06-01 10:02:28 +00:00
|
|
|
#ifdef RANDOM_IP_ID
|
|
|
|
ip->ip_id = ip_randomid();
|
|
|
|
#else
|
2000-09-14 14:42:04 +00:00
|
|
|
ip->ip_id = htons(ip_id++);
|
2001-06-01 10:02:28 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
ipstat.ips_localout++;
|
|
|
|
} else {
|
1996-04-18 15:49:06 +00:00
|
|
|
hlen = IP_VHL_HL(ip->ip_vhl) << 2;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1996-04-18 15:49:06 +00:00
|
|
|
|
2001-12-01 13:48:16 +00:00
|
|
|
/* Route packet. */
|
|
|
|
if (ro == NULL) {
|
|
|
|
ro = &iproute;
|
|
|
|
bzero(ro, sizeof(*ro));
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
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.
|
2002-01-21 20:04:22 +00:00
|
|
|
* The address family should also be checked in case of sharing the
|
|
|
|
* cache with IPv6.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
if (ro->ro_rt && ((ro->ro_rt->rt_flags & RTF_UP) == 0 ||
|
2002-01-21 20:04:22 +00:00
|
|
|
dst->sin_family != AF_INET ||
|
|
|
|
dst->sin_addr.s_addr != pkt_dst.s_addr)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
RTFREE(ro->ro_rt);
|
|
|
|
ro->ro_rt = (struct rtentry *)0;
|
|
|
|
}
|
|
|
|
if (ro->ro_rt == 0) {
|
2002-01-21 20:04:22 +00:00
|
|
|
bzero(dst, sizeof(*dst));
|
1994-05-24 10:09:53 +00:00
|
|
|
dst->sin_family = AF_INET;
|
|
|
|
dst->sin_len = sizeof(*dst);
|
2001-12-28 21:21:57 +00:00
|
|
|
dst->sin_addr = pkt_dst;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If routing to interface only,
|
|
|
|
* short circuit routing lookup.
|
|
|
|
*/
|
|
|
|
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;
|
1996-05-06 17:42:13 +00:00
|
|
|
isbroadcast = in_broadcast(dst->sin_addr, ifp);
|
2001-07-17 18:47:48 +00:00
|
|
|
} else if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) &&
|
2001-07-23 16:50:01 +00:00
|
|
|
imo != NULL && imo->imo_multicast_ifp != NULL) {
|
2001-07-17 18:47:48 +00:00
|
|
|
/*
|
2001-07-23 16:50:01 +00:00
|
|
|
* Bypass the normal routing lookup for multicast
|
|
|
|
* packets if the interface is specified.
|
2001-07-17 18:47:48 +00:00
|
|
|
*/
|
2001-07-23 16:50:01 +00:00
|
|
|
ifp = imo->imo_multicast_ifp;
|
|
|
|
IFP_TO_IA(ifp, ia);
|
|
|
|
isbroadcast = 0; /* fool gcc */
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
1994-12-13 23:08:12 +00:00
|
|
|
/*
|
2001-07-19 07:10:30 +00:00
|
|
|
* If this is the case, we probably don't want to allocate
|
|
|
|
* a protocol-cloned route since we didn't get one from the
|
|
|
|
* ULP. This lets TCP do its thing, while not burdening
|
|
|
|
* forwarding or ICMP with the overhead of cloning a route.
|
|
|
|
* Of course, we still want to do any cloning requested by
|
|
|
|
* the link layer, as this is probably required in all cases
|
|
|
|
* for correct operation (as it is for ARP).
|
1994-12-13 23:08:12 +00:00
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ro->ro_rt == 0)
|
1994-12-13 23:08:12 +00:00
|
|
|
rtalloc_ign(ro, RTF_PRCLONING);
|
1994-05-24 10:09:53 +00:00
|
|
|
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)
|
2001-07-19 07:10:30 +00:00
|
|
|
dst = (struct sockaddr_in *)ro->ro_rt->rt_gateway;
|
1996-05-06 17:42:13 +00:00
|
|
|
if (ro->ro_rt->rt_flags & RTF_HOST)
|
2001-07-19 07:10:30 +00:00
|
|
|
isbroadcast = (ro->ro_rt->rt_flags & RTF_BROADCAST);
|
1996-05-06 17:42:13 +00:00
|
|
|
else
|
|
|
|
isbroadcast = in_broadcast(dst->sin_addr, ifp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-12-28 21:21:57 +00:00
|
|
|
if (IN_MULTICAST(ntohl(pkt_dst.s_addr))) {
|
1994-05-24 10:09:53 +00:00
|
|
|
struct in_multi *inm;
|
|
|
|
|
|
|
|
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;
|
|
|
|
/*
|
|
|
|
* See if the caller provided any multicast options
|
|
|
|
*/
|
|
|
|
if (imo != NULL) {
|
|
|
|
ip->ip_ttl = imo->imo_multicast_ttl;
|
1995-06-13 17:51:16 +00:00
|
|
|
if (imo->imo_multicast_vif != -1)
|
|
|
|
ip->ip_src.s_addr =
|
|
|
|
ip_mcast_src(imo->imo_multicast_vif);
|
1994-05-24 10:09:53 +00:00
|
|
|
} else
|
|
|
|
ip->ip_ttl = IP_DEFAULT_MULTICAST_TTL;
|
|
|
|
/*
|
|
|
|
* Confirm that the outgoing interface supports multicast.
|
|
|
|
*/
|
1995-06-13 17:51:16 +00:00
|
|
|
if ((imo == NULL) || (imo->imo_multicast_vif == -1)) {
|
|
|
|
if ((ifp->if_flags & IFF_MULTICAST) == 0) {
|
|
|
|
ipstat.ips_noroute++;
|
|
|
|
error = ENETUNREACH;
|
|
|
|
goto bad;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If source address not specified yet, use address
|
|
|
|
* of outgoing interface.
|
|
|
|
*/
|
|
|
|
if (ip->ip_src.s_addr == INADDR_ANY) {
|
2001-07-23 16:50:01 +00:00
|
|
|
/* Interface may have no addresses. */
|
|
|
|
if (ia != NULL)
|
|
|
|
ip->ip_src = IA_SIN(ia)->sin_addr;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2002-01-05 18:23:53 +00:00
|
|
|
if (ip_mrouter && (flags & IP_FORWARDING) == 0) {
|
|
|
|
/*
|
|
|
|
* XXX
|
|
|
|
* delayed checksums are not currently
|
|
|
|
* compatible with IP multicast routing
|
|
|
|
*/
|
|
|
|
if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
|
|
|
|
in_delayed_cksum(m);
|
|
|
|
m->m_pkthdr.csum_flags &=
|
|
|
|
~CSUM_DELAY_DATA;
|
|
|
|
}
|
|
|
|
}
|
2001-12-28 21:21:57 +00:00
|
|
|
IN_LOOKUP_MULTI(pkt_dst, ifp, inm);
|
1994-05-24 10:09:53 +00:00
|
|
|
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.
|
|
|
|
*/
|
1997-05-06 21:22:04 +00:00
|
|
|
ip_mloopback(ifp, m, dst, hlen);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
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 (ip_mrouter && (flags & IP_FORWARDING) == 0) {
|
1994-09-06 22:42:31 +00:00
|
|
|
/*
|
|
|
|
* Check if rsvp daemon is running. If not, don't
|
|
|
|
* set ip_moptions. This ensures that the packet
|
|
|
|
* is multicast and not just sent down one link
|
|
|
|
* as prescribed by rsvpd.
|
|
|
|
*/
|
1995-07-26 18:05:16 +00:00
|
|
|
if (!rsvp_on)
|
1994-09-06 22:42:31 +00:00
|
|
|
imo = NULL;
|
|
|
|
if (ip_mforward(ip, ifp, m, imo) != 0) {
|
1994-05-24 10:09:53 +00:00
|
|
|
m_freem(m);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1994-09-14 03:10:15 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
1995-04-26 18:10:58 +00:00
|
|
|
if (ip->ip_ttl == 0 || ifp->if_flags & IFF_LOOPBACK) {
|
1994-05-24 10:09:53 +00:00
|
|
|
m_freem(m);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
goto sendit;
|
|
|
|
}
|
|
|
|
#ifndef notdef
|
|
|
|
/*
|
|
|
|
* If source address not specified yet, use address
|
|
|
|
* of outgoing interface.
|
|
|
|
*/
|
1998-07-06 03:20:19 +00:00
|
|
|
if (ip->ip_src.s_addr == INADDR_ANY) {
|
2001-07-23 16:50:01 +00:00
|
|
|
/* Interface may have no addresses. */
|
|
|
|
if (ia != NULL) {
|
|
|
|
ip->ip_src = IA_SIN(ia)->sin_addr;
|
1998-07-06 03:20:19 +00:00
|
|
|
#ifdef IPFIREWALL_FORWARD
|
2001-07-23 16:50:01 +00:00
|
|
|
/* Keep note that we did this - if the firewall changes
|
|
|
|
* the next-hop, our interface may change, changing the
|
|
|
|
* default source IP. It's a shame so much effort happens
|
|
|
|
* twice. Oh well.
|
|
|
|
*/
|
|
|
|
fwd_rewrite_src++;
|
1998-07-06 03:20:19 +00:00
|
|
|
#endif /* IPFIREWALL_FORWARD */
|
2001-07-23 16:50:01 +00:00
|
|
|
}
|
1998-07-06 03:20:19 +00:00
|
|
|
}
|
|
|
|
#endif /* notdef */
|
1994-08-01 12:01:45 +00:00
|
|
|
/*
|
|
|
|
* Verify that we have any chance at all of being able to queue
|
|
|
|
* the packet or packet fragments
|
|
|
|
*/
|
|
|
|
if ((ifp->if_snd.ifq_len + ip->ip_len / ifp->if_mtu + 1) >=
|
|
|
|
ifp->if_snd.ifq_maxlen) {
|
|
|
|
error = ENOBUFS;
|
2001-10-30 14:58:27 +00:00
|
|
|
ipstat.ips_odropped++;
|
1994-08-01 12:01:45 +00:00
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Look for broadcast address and
|
2002-01-21 13:59:42 +00:00
|
|
|
* verify user is allowed to send
|
1994-05-24 10:09:53 +00:00
|
|
|
* such a packet.
|
|
|
|
*/
|
1996-05-06 17:42:13 +00:00
|
|
|
if (isbroadcast) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((ifp->if_flags & IFF_BROADCAST) == 0) {
|
|
|
|
error = EADDRNOTAVAIL;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
if ((flags & IP_ALLOWBROADCAST) == 0) {
|
|
|
|
error = EACCES;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
/* don't allow broadcast messages to be fragmented */
|
|
|
|
if ((u_short)ip->ip_len > ifp->if_mtu) {
|
|
|
|
error = EMSGSIZE;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
m->m_flags |= M_BCAST;
|
1996-05-06 17:42:13 +00:00
|
|
|
} else {
|
1994-05-24 10:09:53 +00:00
|
|
|
m->m_flags &= ~M_BCAST;
|
1996-05-06 17:42:13 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-02-19 14:02:27 +00:00
|
|
|
sendit:
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef IPSEC
|
|
|
|
/* get SP for this packet */
|
|
|
|
if (so == NULL)
|
|
|
|
sp = ipsec4_getpolicybyaddr(m, IPSEC_DIR_OUTBOUND, flags, &error);
|
|
|
|
else
|
|
|
|
sp = ipsec4_getpolicybysock(m, IPSEC_DIR_OUTBOUND, so, &error);
|
|
|
|
|
|
|
|
if (sp == NULL) {
|
|
|
|
ipsecstat.out_inval++;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
/* check policy */
|
|
|
|
switch (sp->policy) {
|
|
|
|
case IPSEC_POLICY_DISCARD:
|
|
|
|
/*
|
|
|
|
* This packet is just discarded.
|
|
|
|
*/
|
|
|
|
ipsecstat.out_polvio++;
|
|
|
|
goto bad;
|
|
|
|
|
|
|
|
case IPSEC_POLICY_BYPASS:
|
|
|
|
case IPSEC_POLICY_NONE:
|
|
|
|
/* no need to do IPsec. */
|
|
|
|
goto skip_ipsec;
|
|
|
|
|
|
|
|
case IPSEC_POLICY_IPSEC:
|
|
|
|
if (sp->req == NULL) {
|
|
|
|
/* acquire a policy */
|
|
|
|
error = key_spdacquire(sp);
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPSEC_POLICY_ENTRUST:
|
|
|
|
default:
|
|
|
|
printf("ip_output: Invalid policy found. %d\n", sp->policy);
|
|
|
|
}
|
|
|
|
{
|
|
|
|
struct ipsec_output_state state;
|
|
|
|
bzero(&state, sizeof(state));
|
|
|
|
state.m = m;
|
|
|
|
if (flags & IP_ROUTETOIF) {
|
|
|
|
state.ro = &iproute;
|
|
|
|
bzero(&iproute, sizeof(iproute));
|
|
|
|
} else
|
|
|
|
state.ro = ro;
|
|
|
|
state.dst = (struct sockaddr *)dst;
|
|
|
|
|
|
|
|
ip->ip_sum = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX
|
|
|
|
* delayed checksums are not currently compatible with IPsec
|
|
|
|
*/
|
|
|
|
if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
|
|
|
|
in_delayed_cksum(m);
|
|
|
|
m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
|
|
|
|
}
|
|
|
|
|
2002-02-18 20:35:27 +00:00
|
|
|
ip->ip_len = htons(ip->ip_len);
|
|
|
|
ip->ip_off = htons(ip->ip_off);
|
2001-06-11 12:39:29 +00:00
|
|
|
|
|
|
|
error = ipsec4_output(&state, sp, flags);
|
|
|
|
|
|
|
|
m = state.m;
|
|
|
|
if (flags & IP_ROUTETOIF) {
|
|
|
|
/*
|
|
|
|
* if we have tunnel mode SA, we may need to ignore
|
|
|
|
* IP_ROUTETOIF.
|
|
|
|
*/
|
|
|
|
if (state.ro != &iproute || state.ro->ro_rt != NULL) {
|
|
|
|
flags &= ~IP_ROUTETOIF;
|
|
|
|
ro = state.ro;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
ro = state.ro;
|
|
|
|
dst = (struct sockaddr_in *)state.dst;
|
|
|
|
if (error) {
|
|
|
|
/* mbuf is already reclaimed in ipsec4_output. */
|
|
|
|
m0 = NULL;
|
|
|
|
switch (error) {
|
|
|
|
case EHOSTUNREACH:
|
|
|
|
case ENETUNREACH:
|
|
|
|
case EMSGSIZE:
|
|
|
|
case ENOBUFS:
|
|
|
|
case ENOMEM:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf("ip4_output (ipsec): error code %d\n", error);
|
|
|
|
/*fall through*/
|
|
|
|
case ENOENT:
|
|
|
|
/* don't show these error codes to the user */
|
|
|
|
error = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* be sure to update variables that are affected by ipsec4_output() */
|
|
|
|
ip = mtod(m, struct ip *);
|
|
|
|
#ifdef _IP_VHL
|
|
|
|
hlen = IP_VHL_HL(ip->ip_vhl) << 2;
|
|
|
|
#else
|
|
|
|
hlen = ip->ip_hl << 2;
|
|
|
|
#endif
|
|
|
|
if (ro->ro_rt == NULL) {
|
|
|
|
if ((flags & IP_ROUTETOIF) == 0) {
|
|
|
|
printf("ip_output: "
|
|
|
|
"can't update route after IPsec processing\n");
|
|
|
|
error = EHOSTUNREACH; /*XXX*/
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ia = ifatoia(ro->ro_rt->rt_ifa);
|
|
|
|
ifp = ro->ro_rt->rt_ifp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* make it flipped, again. */
|
2002-02-18 20:35:27 +00:00
|
|
|
ip->ip_len = ntohs(ip->ip_len);
|
|
|
|
ip->ip_off = ntohs(ip->ip_off);
|
2001-06-11 12:39:29 +00:00
|
|
|
skip_ipsec:
|
|
|
|
#endif /*IPSEC*/
|
|
|
|
|
1997-02-10 11:45:37 +00:00
|
|
|
/*
|
1998-03-21 11:34:28 +00:00
|
|
|
* IpHack's section.
|
|
|
|
* - Xlate: translate packet's addr/port (NAT).
|
|
|
|
* - Firewall: deny/allow/etc.
|
|
|
|
* - Wrap: fake packet's addr/port <unimpl.>
|
|
|
|
* - Encapsulate: put it in another IP and send out. <unimp.>
|
|
|
|
*/
|
2000-07-31 13:11:42 +00:00
|
|
|
#ifdef PFIL_HOOKS
|
|
|
|
/*
|
|
|
|
* Run through list of hooks for output packets.
|
|
|
|
*/
|
|
|
|
m1 = m;
|
|
|
|
pfh = pfil_hook_get(PFIL_OUT, &inetsw[ip_protox[IPPROTO_IP]].pr_pfh);
|
2001-02-04 13:13:25 +00:00
|
|
|
for (; pfh; pfh = TAILQ_NEXT(pfh, pfil_link))
|
2000-07-31 13:11:42 +00:00
|
|
|
if (pfh->pfil_func) {
|
|
|
|
rv = pfh->pfil_func(ip, hlen, ifp, 1, &m1);
|
|
|
|
if (rv) {
|
|
|
|
error = EHOSTUNREACH;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
m = m1;
|
|
|
|
if (m == NULL)
|
|
|
|
goto done;
|
|
|
|
ip = mtod(m, struct ip *);
|
|
|
|
}
|
|
|
|
#endif /* PFIL_HOOKS */
|
1996-08-21 21:37:07 +00:00
|
|
|
|
1996-02-23 15:47:58 +00:00
|
|
|
/*
|
|
|
|
* Check with the firewall...
|
2001-12-28 21:21:57 +00:00
|
|
|
* but not if we are already being fwd'd from a firewall.
|
1996-02-23 15:47:58 +00:00
|
|
|
*/
|
2001-12-28 21:21:57 +00:00
|
|
|
if (fw_enable && IPFW_LOADED && !ip_fw_fwd_addr) {
|
1998-08-01 08:44:33 +00:00
|
|
|
struct sockaddr_in *old = dst;
|
1998-12-14 18:09:13 +00:00
|
|
|
|
2001-11-04 22:56:25 +00:00
|
|
|
off = ip_fw_chk_ptr(&ip,
|
1999-12-06 00:43:07 +00:00
|
|
|
hlen, ifp, &divert_cookie, &m, &rule, &dst);
|
1998-12-14 18:09:13 +00:00
|
|
|
/*
|
|
|
|
* On return we must do the following:
|
2001-02-02 00:18:00 +00:00
|
|
|
* m == NULL -> drop the pkt (old interface, deprecated)
|
2001-12-14 19:34:11 +00:00
|
|
|
* (off & IP_FW_PORT_DENY_FLAG) -> drop the pkt (new interface)
|
|
|
|
* 1<=off<= 0xffff -> DIVERT
|
|
|
|
* (off & IP_FW_PORT_DYNT_FLAG) -> send to a DUMMYNET pipe
|
|
|
|
* (off & IP_FW_PORT_TEE_FLAG) -> TEE the packet
|
|
|
|
* dst != old -> IPFIREWALL_FORWARD
|
|
|
|
* off==0, dst==old -> accept
|
|
|
|
* If some of the above modules are not compiled in, then
|
1998-12-14 18:09:13 +00:00
|
|
|
* we should't have to check the corresponding condition
|
|
|
|
* (because the ipfw control socket should not accept
|
|
|
|
* unsupported rules), but better play safe and drop
|
|
|
|
* packets in case of doubt.
|
|
|
|
*/
|
2001-02-02 00:18:00 +00:00
|
|
|
if (off & IP_FW_PORT_DENY_FLAG) { /* XXX new interface-denied */
|
2001-12-14 19:34:11 +00:00
|
|
|
if (m)
|
|
|
|
m_freem(m);
|
|
|
|
error = EACCES;
|
|
|
|
goto done;
|
2001-02-02 00:18:00 +00:00
|
|
|
}
|
2001-12-14 19:34:11 +00:00
|
|
|
if (!m) { /* firewall said to reject */
|
|
|
|
static int __debug=10;
|
|
|
|
|
|
|
|
if (__debug > 0) {
|
|
|
|
printf(
|
|
|
|
"firewall returns NULL, please update!\n");
|
|
|
|
__debug--;
|
|
|
|
}
|
|
|
|
error = EACCES;
|
|
|
|
goto done;
|
1997-06-02 05:02:37 +00:00
|
|
|
}
|
2001-12-14 19:34:11 +00:00
|
|
|
if (off == 0 && dst == old) /* common case */
|
|
|
|
goto pass;
|
2001-11-04 22:56:25 +00:00
|
|
|
if (DUMMYNET_LOADED && (off & IP_FW_PORT_DYNT_FLAG) != 0) {
|
2001-12-14 19:34:11 +00:00
|
|
|
/*
|
|
|
|
* pass the pkt to dummynet. Need to include
|
|
|
|
* pipe number, m, ifp, ro, dst because these are
|
|
|
|
* not recomputed in the next pass.
|
|
|
|
* All other parameters have been already used and
|
|
|
|
* so they are not needed anymore.
|
|
|
|
* XXX note: if the ifp or ro entry are deleted
|
|
|
|
* while a pkt is in dummynet, we are in trouble!
|
|
|
|
*/
|
|
|
|
error = ip_dn_io_ptr(off & 0xffff, DN_TO_IP_OUT, m,
|
|
|
|
ifp, ro, dst, rule, flags);
|
|
|
|
goto done;
|
1997-06-02 05:02:37 +00:00
|
|
|
}
|
1998-12-14 18:09:13 +00:00
|
|
|
#ifdef IPDIVERT
|
1999-12-06 00:43:07 +00:00
|
|
|
if (off != 0 && (off & IP_FW_PORT_DYNT_FLAG) == 0) {
|
|
|
|
struct mbuf *clone = NULL;
|
|
|
|
|
|
|
|
/* Clone packet if we're doing a 'tee' */
|
|
|
|
if ((off & IP_FW_PORT_TEE_FLAG) != 0)
|
|
|
|
clone = m_dup(m, M_DONTWAIT);
|
|
|
|
|
2000-04-01 18:51:03 +00:00
|
|
|
/*
|
|
|
|
* XXX
|
|
|
|
* delayed checksums are not currently compatible
|
|
|
|
* with divert sockets.
|
|
|
|
*/
|
|
|
|
if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
|
|
|
|
in_delayed_cksum(m);
|
|
|
|
m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
|
|
|
|
}
|
|
|
|
|
1999-12-06 00:43:07 +00:00
|
|
|
/* Restore packet header fields to original values */
|
2002-02-18 20:35:27 +00:00
|
|
|
ip->ip_len = htons(ip->ip_len);
|
|
|
|
ip->ip_off = htons(ip->ip_off);
|
1999-12-06 00:43:07 +00:00
|
|
|
|
|
|
|
/* Deliver packet to divert input routine */
|
|
|
|
ip_divert_cookie = divert_cookie;
|
|
|
|
divert_packet(m, 0, off & 0xffff);
|
|
|
|
|
|
|
|
/* If 'tee', continue with original packet */
|
|
|
|
if (clone != NULL) {
|
|
|
|
m = clone;
|
|
|
|
ip = mtod(m, struct ip *);
|
|
|
|
goto pass;
|
|
|
|
}
|
1997-06-02 05:02:37 +00:00
|
|
|
goto done;
|
1996-07-10 19:44:30 +00:00
|
|
|
}
|
1998-12-14 18:09:13 +00:00
|
|
|
#endif
|
|
|
|
|
1998-07-06 03:20:19 +00:00
|
|
|
#ifdef IPFIREWALL_FORWARD
|
|
|
|
/* Here we check dst to make sure it's directly reachable on the
|
|
|
|
* interface we previously thought it was.
|
|
|
|
* If it isn't (which may be likely in some situations) we have
|
|
|
|
* to re-route it (ie, find a route for the next-hop and the
|
|
|
|
* associated interface) and set them here. This is nested
|
|
|
|
* forwarding which in most cases is undesirable, except where
|
|
|
|
* such control is nigh impossible. So we do it here.
|
|
|
|
* And I'm babbling.
|
|
|
|
*/
|
1998-12-14 18:09:13 +00:00
|
|
|
if (off == 0 && old != dst) {
|
1998-07-06 03:20:19 +00:00
|
|
|
struct in_ifaddr *ia;
|
|
|
|
|
|
|
|
/* It's changed... */
|
|
|
|
/* There must be a better way to do this next line... */
|
|
|
|
static struct route sro_fwd, *ro_fwd = &sro_fwd;
|
|
|
|
#ifdef IPFIREWALL_FORWARD_DEBUG
|
|
|
|
printf("IPFIREWALL_FORWARD: New dst ip: ");
|
|
|
|
print_ip(dst->sin_addr);
|
|
|
|
printf("\n");
|
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* We need to figure out if we have been forwarded
|
|
|
|
* to a local socket. If so then we should somehow
|
|
|
|
* "loop back" to ip_input, and get directed to the
|
|
|
|
* PCB as if we had received this packet. This is
|
|
|
|
* because it may be dificult to identify the packets
|
|
|
|
* you want to forward until they are being output
|
|
|
|
* and have selected an interface. (e.g. locally
|
|
|
|
* initiated packets) If we used the loopback inteface,
|
|
|
|
* we would not be able to control what happens
|
|
|
|
* as the packet runs through ip_input() as
|
|
|
|
* it is done through a ISR.
|
|
|
|
*/
|
2001-09-29 04:34:11 +00:00
|
|
|
LIST_FOREACH(ia,
|
|
|
|
INADDR_HASH(dst->sin_addr.s_addr), ia_hash) {
|
1998-07-06 03:20:19 +00:00
|
|
|
/*
|
|
|
|
* If the addr to forward to is one
|
|
|
|
* of ours, we pretend to
|
|
|
|
* be the destination for this packet.
|
|
|
|
*/
|
|
|
|
if (IA_SIN(ia)->sin_addr.s_addr ==
|
|
|
|
dst->sin_addr.s_addr)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (ia) {
|
|
|
|
/* tell ip_input "dont filter" */
|
|
|
|
ip_fw_fwd_addr = dst;
|
|
|
|
if (m->m_pkthdr.rcvif == NULL)
|
|
|
|
m->m_pkthdr.rcvif = ifunit("lo0");
|
2000-03-30 02:16:40 +00:00
|
|
|
if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
|
|
|
|
m->m_pkthdr.csum_flags |=
|
|
|
|
CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
|
|
|
|
m0->m_pkthdr.csum_data = 0xffff;
|
|
|
|
}
|
|
|
|
m->m_pkthdr.csum_flags |=
|
|
|
|
CSUM_IP_CHECKED | CSUM_IP_VALID;
|
2002-02-18 20:35:27 +00:00
|
|
|
ip->ip_len = htons(ip->ip_len);
|
|
|
|
ip->ip_off = htons(ip->ip_off);
|
1998-07-06 03:20:19 +00:00
|
|
|
ip_input(m);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
/* Some of the logic for this was
|
|
|
|
* nicked from above.
|
|
|
|
*
|
|
|
|
* This rewrites the cached route in a local PCB.
|
|
|
|
* Is this what we want to do?
|
|
|
|
*/
|
|
|
|
bcopy(dst, &ro_fwd->ro_dst, sizeof(*dst));
|
|
|
|
|
|
|
|
ro_fwd->ro_rt = 0;
|
|
|
|
rtalloc_ign(ro_fwd, RTF_PRCLONING);
|
|
|
|
|
|
|
|
if (ro_fwd->ro_rt == 0) {
|
|
|
|
ipstat.ips_noroute++;
|
|
|
|
error = EHOSTUNREACH;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
|
|
|
ia = ifatoia(ro_fwd->ro_rt->rt_ifa);
|
|
|
|
ifp = ro_fwd->ro_rt->rt_ifp;
|
|
|
|
ro_fwd->ro_rt->rt_use++;
|
|
|
|
if (ro_fwd->ro_rt->rt_flags & RTF_GATEWAY)
|
|
|
|
dst = (struct sockaddr_in *)ro_fwd->ro_rt->rt_gateway;
|
|
|
|
if (ro_fwd->ro_rt->rt_flags & RTF_HOST)
|
|
|
|
isbroadcast =
|
|
|
|
(ro_fwd->ro_rt->rt_flags & RTF_BROADCAST);
|
|
|
|
else
|
|
|
|
isbroadcast = in_broadcast(dst->sin_addr, ifp);
|
2001-12-19 14:54:13 +00:00
|
|
|
if (ro->ro_rt)
|
|
|
|
RTFREE(ro->ro_rt);
|
1998-07-06 03:20:19 +00:00
|
|
|
ro->ro_rt = ro_fwd->ro_rt;
|
|
|
|
dst = (struct sockaddr_in *)&ro_fwd->ro_dst;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we added a default src ip earlier,
|
|
|
|
* which would have been gotten from the-then
|
|
|
|
* interface, do it again, from the new one.
|
|
|
|
*/
|
|
|
|
if (fwd_rewrite_src)
|
|
|
|
ip->ip_src = IA_SIN(ia)->sin_addr;
|
1998-12-14 18:09:13 +00:00
|
|
|
goto pass ;
|
1998-07-06 03:20:19 +00:00
|
|
|
}
|
|
|
|
#endif /* IPFIREWALL_FORWARD */
|
1998-12-14 18:09:13 +00:00
|
|
|
/*
|
|
|
|
* if we get here, none of the above matches, and
|
|
|
|
* we have to drop the pkt
|
|
|
|
*/
|
|
|
|
m_freem(m);
|
|
|
|
error = EACCES; /* not sure this is the right error msg */
|
|
|
|
goto done;
|
1996-07-10 19:44:30 +00:00
|
|
|
}
|
1996-02-23 15:47:58 +00:00
|
|
|
|
2001-12-28 21:21:57 +00:00
|
|
|
ip_fw_fwd_addr = NULL;
|
1998-12-14 18:09:13 +00:00
|
|
|
pass:
|
2002-02-15 12:19:03 +00:00
|
|
|
/* 127/8 must not appear on wire - RFC1122. */
|
|
|
|
if ((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||
|
|
|
|
(ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) {
|
|
|
|
if ((ifp->if_flags & IFF_LOOPBACK) == 0) {
|
|
|
|
ipstat.ips_badaddr++;
|
|
|
|
error = EADDRNOTAVAIL;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
RFC768 (UDP) requires that "if the computed checksum is zero, it
is transmitted as all ones". This got broken after introduction
of delayed checksums as follows. Some guys (including Jonathan)
think that it is allowed to transmit all ones in place of a zero
checksum for TCP the same way as for UDP. (The discussion still
takes place on -net.) Thus, the 0 -> 0xffff checksum fixup was
first moved from udp_output() (see udp_usrreq.c, 1.64 -> 1.65)
to in_cksum_skip() (see sys/i386/i386/in_cksum.c, 1.17 -> 1.18,
INVERT expression). Besides that I disagree that it is valid for
TCP, there was no real problem until in_cksum.c,v 1.20, where the
in_cksum() was made just a special version of in_cksum_skip().
The side effect was that now every incoming IP datagram failed to
pass the checksum test (in_cksum() returned 0xffff when it should
actually return zero). It was fixed next day in revision 1.21,
by removing the INVERT expression. The latter also broke the
0 -> 0xffff fixup for UDP checksums.
Before this change:
: tcpdump: listening on lo0
: 127.0.0.1.33005 > 127.0.0.1.33006: udp 0 (ttl 64, id 1)
: 4500 001c 0001 0000 4011 7cce 7f00 0001
: 7f00 0001 80ed 80ee 0008 0000
After this change:
: tcpdump: listening on lo0
: 127.0.0.1.33005 > 127.0.0.1.33006: udp 0 (ttl 64, id 1)
: 4500 001c 0001 0000 4011 7cce 7f00 0001
: 7f00 0001 80ed 80ee 0008 ffff
2001-03-13 17:07:06 +00:00
|
|
|
m->m_pkthdr.csum_flags |= CSUM_IP;
|
|
|
|
sw_csum = m->m_pkthdr.csum_flags & ~ifp->if_hwassist;
|
2000-03-27 19:14:27 +00:00
|
|
|
if (sw_csum & CSUM_DELAY_DATA) {
|
|
|
|
in_delayed_cksum(m);
|
|
|
|
sw_csum &= ~CSUM_DELAY_DATA;
|
|
|
|
}
|
RFC768 (UDP) requires that "if the computed checksum is zero, it
is transmitted as all ones". This got broken after introduction
of delayed checksums as follows. Some guys (including Jonathan)
think that it is allowed to transmit all ones in place of a zero
checksum for TCP the same way as for UDP. (The discussion still
takes place on -net.) Thus, the 0 -> 0xffff checksum fixup was
first moved from udp_output() (see udp_usrreq.c, 1.64 -> 1.65)
to in_cksum_skip() (see sys/i386/i386/in_cksum.c, 1.17 -> 1.18,
INVERT expression). Besides that I disagree that it is valid for
TCP, there was no real problem until in_cksum.c,v 1.20, where the
in_cksum() was made just a special version of in_cksum_skip().
The side effect was that now every incoming IP datagram failed to
pass the checksum test (in_cksum() returned 0xffff when it should
actually return zero). It was fixed next day in revision 1.21,
by removing the INVERT expression. The latter also broke the
0 -> 0xffff fixup for UDP checksums.
Before this change:
: tcpdump: listening on lo0
: 127.0.0.1.33005 > 127.0.0.1.33006: udp 0 (ttl 64, id 1)
: 4500 001c 0001 0000 4011 7cce 7f00 0001
: 7f00 0001 80ed 80ee 0008 0000
After this change:
: tcpdump: listening on lo0
: 127.0.0.1.33005 > 127.0.0.1.33006: udp 0 (ttl 64, id 1)
: 4500 001c 0001 0000 4011 7cce 7f00 0001
: 7f00 0001 80ed 80ee 0008 ffff
2001-03-13 17:07:06 +00:00
|
|
|
m->m_pkthdr.csum_flags &= ifp->if_hwassist;
|
2000-03-27 19:14:27 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2000-03-27 19:14:27 +00:00
|
|
|
* If small enough for interface, or the interface will take
|
|
|
|
* care of the fragmentation for us, can just send directly.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2000-03-27 19:14:27 +00:00
|
|
|
if ((u_short)ip->ip_len <= ifp->if_mtu ||
|
|
|
|
ifp->if_hwassist & CSUM_FRAGMENT) {
|
2002-02-18 20:35:27 +00:00
|
|
|
ip->ip_len = htons(ip->ip_len);
|
|
|
|
ip->ip_off = htons(ip->ip_off);
|
1994-05-24 10:09:53 +00:00
|
|
|
ip->ip_sum = 0;
|
2000-03-27 19:14:27 +00:00
|
|
|
if (sw_csum & CSUM_DELAY_IP) {
|
|
|
|
if (ip->ip_vhl == IP_VHL_BORING) {
|
|
|
|
ip->ip_sum = in_cksum_hdr(ip);
|
|
|
|
} else {
|
|
|
|
ip->ip_sum = in_cksum(m, hlen);
|
|
|
|
}
|
1996-04-18 15:49:06 +00:00
|
|
|
}
|
2000-10-19 23:15:54 +00:00
|
|
|
|
|
|
|
/* Record statistics for this interface address. */
|
2001-07-23 16:50:01 +00:00
|
|
|
if (!(flags & IP_FORWARDING) && ia) {
|
2000-10-19 23:15:54 +00:00
|
|
|
ia->ia_ifa.if_opackets++;
|
|
|
|
ia->ia_ifa.if_obytes += m->m_pkthdr.len;
|
|
|
|
}
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef IPSEC
|
|
|
|
/* clean ipsec history once it goes out of the node */
|
|
|
|
ipsec_delaux(m);
|
|
|
|
#endif
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
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;
|
1995-10-16 18:21:26 +00:00
|
|
|
/*
|
|
|
|
* This case can happen if the user changed the MTU
|
|
|
|
* of an interface after enabling IP on it. Because
|
|
|
|
* most netifs don't keep track of routes pointing to
|
|
|
|
* them, there is no way for one to update all its
|
|
|
|
* routes when the MTU is changed.
|
|
|
|
*/
|
|
|
|
if ((ro->ro_rt->rt_flags & (RTF_UP | RTF_HOST))
|
|
|
|
&& !(ro->ro_rt->rt_rmx.rmx_locks & RTV_MTU)
|
|
|
|
&& (ro->ro_rt->rt_rmx.rmx_mtu > ifp->if_mtu)) {
|
|
|
|
ro->ro_rt->rt_rmx.rmx_mtu = ifp->if_mtu;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
ipstat.ips_cantfrag++;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
len = (ifp->if_mtu - hlen) &~ 7;
|
|
|
|
if (len < 8) {
|
|
|
|
error = EMSGSIZE;
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
2000-03-27 19:14:27 +00:00
|
|
|
/*
|
|
|
|
* if the interface will not calculate checksums on
|
|
|
|
* fragmented packets, then do it here.
|
|
|
|
*/
|
|
|
|
if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA &&
|
|
|
|
(ifp->if_hwassist & CSUM_IP_FRAGS) == 0) {
|
|
|
|
in_delayed_cksum(m);
|
|
|
|
m->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
int mhlen, firstlen = len;
|
|
|
|
struct mbuf **mnext = &m->m_nextpkt;
|
2000-03-27 19:14:27 +00:00
|
|
|
int nfrags = 1;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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) {
|
|
|
|
MGETHDR(m, M_DONTWAIT, MT_HEADER);
|
|
|
|
if (m == 0) {
|
|
|
|
error = ENOBUFS;
|
|
|
|
ipstat.ips_odropped++;
|
|
|
|
goto sendorfree;
|
|
|
|
}
|
2000-03-27 19:14:27 +00:00
|
|
|
m->m_flags |= (m0->m_flags & M_MCAST) | M_FRAG;
|
1994-05-24 10:09:53 +00:00
|
|
|
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);
|
1996-04-18 15:49:06 +00:00
|
|
|
mhip->ip_vhl = IP_MAKE_VHL(IPVERSION, mhlen >> 2);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
m->m_len = mhlen;
|
2000-10-20 14:10:37 +00:00
|
|
|
mhip->ip_off = ((off - hlen) >> 3) + ip->ip_off;
|
1994-05-24 10:09:53 +00:00
|
|
|
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;
|
|
|
|
m->m_pkthdr.rcvif = (struct ifnet *)0;
|
2000-03-27 19:14:27 +00:00
|
|
|
m->m_pkthdr.csum_flags = m0->m_pkthdr.csum_flags;
|
2002-02-18 20:35:27 +00:00
|
|
|
mhip->ip_off = htons(mhip->ip_off);
|
1994-05-24 10:09:53 +00:00
|
|
|
mhip->ip_sum = 0;
|
2000-03-27 19:14:27 +00:00
|
|
|
if (sw_csum & CSUM_DELAY_IP) {
|
|
|
|
if (mhip->ip_vhl == IP_VHL_BORING) {
|
|
|
|
mhip->ip_sum = in_cksum_hdr(mhip);
|
|
|
|
} else {
|
|
|
|
mhip->ip_sum = in_cksum(m, mhlen);
|
|
|
|
}
|
1996-04-18 15:49:06 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
*mnext = m;
|
|
|
|
mnext = &m->m_nextpkt;
|
2000-03-27 19:14:27 +00:00
|
|
|
nfrags++;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2000-03-27 19:14:27 +00:00
|
|
|
ipstat.ips_ofragments += nfrags;
|
|
|
|
|
|
|
|
/* set first/last markers for fragment chain */
|
|
|
|
m->m_flags |= M_LASTFRAG;
|
|
|
|
m0->m_flags |= M_FIRSTFRAG | M_FRAG;
|
|
|
|
m0->m_pkthdr.csum_data = nfrags;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Update first fragment by trimming what's been copied out
|
|
|
|
* and updating header, then send each fragment (in order).
|
|
|
|
*/
|
|
|
|
m = m0;
|
|
|
|
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);
|
Fixed broken ICMP error generation, unified conversion of IP header
fields between host and network byte order. The details:
o icmp_error() now does not add IP header length. This fixes the problem
when icmp_error() is called from ip_forward(). In this case the ip_len
of the original IP datagram returned with ICMP error was wrong.
o icmp_error() expects all three fields, ip_len, ip_id and ip_off in host
byte order, so DTRT and convert these fields back to network byte order
before sending a message. This fixes the problem described in PR 16240
and PR 20877 (ip_id field was returned in host byte order).
o ip_ttl decrement operation in ip_forward() was moved down to make sure
that it does not corrupt the copy of original IP datagram passed later
to icmp_error().
o A copy of original IP datagram in ip_forward() was made a read-write,
independent copy. This fixes the problem I first reported to Garrett
Wollman and Bill Fenner and later put in audit trail of PR 16240:
ip_output() (not always) converts fields of original datagram to network
byte order, but because copy (mcopy) and its original (m) most likely
share the same mbuf cluster, ip_output()'s manipulations on original
also corrupted the copy.
o ip_output() now expects all three fields, ip_len, ip_off and (what is
significant) ip_id in host byte order. It was a headache for years that
ip_id was handled differently. The only compatibility issue here is the
raw IP socket interface with IP_HDRINCL socket option set and a non-zero
ip_id field, but ip.4 manual page was unclear on whether in this case
ip_id field should be in host or network byte order.
2000-09-01 12:33:03 +00:00
|
|
|
ip->ip_off |= IP_MF;
|
2002-02-18 20:35:27 +00:00
|
|
|
ip->ip_off = htons(ip->ip_off);
|
1994-05-24 10:09:53 +00:00
|
|
|
ip->ip_sum = 0;
|
2000-03-27 19:14:27 +00:00
|
|
|
if (sw_csum & CSUM_DELAY_IP) {
|
|
|
|
if (ip->ip_vhl == IP_VHL_BORING) {
|
|
|
|
ip->ip_sum = in_cksum_hdr(ip);
|
|
|
|
} else {
|
|
|
|
ip->ip_sum = in_cksum(m, hlen);
|
|
|
|
}
|
1996-04-18 15:49:06 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
sendorfree:
|
|
|
|
for (m = m0; m; m = m0) {
|
|
|
|
m0 = m->m_nextpkt;
|
|
|
|
m->m_nextpkt = 0;
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef IPSEC
|
|
|
|
/* clean ipsec history once it goes out of the node */
|
|
|
|
ipsec_delaux(m);
|
|
|
|
#endif
|
2001-08-03 17:36:06 +00:00
|
|
|
if (error == 0) {
|
2000-10-29 01:05:09 +00:00
|
|
|
/* Record statistics for this interface address. */
|
2001-08-03 17:36:06 +00:00
|
|
|
if (ia != NULL) {
|
|
|
|
ia->ia_ifa.if_opackets++;
|
|
|
|
ia->ia_ifa.if_obytes += m->m_pkthdr.len;
|
|
|
|
}
|
2000-10-29 01:05:09 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
error = (*ifp->if_output)(ifp, m,
|
|
|
|
(struct sockaddr *)dst, ro->ro_rt);
|
2000-10-29 01:05:09 +00:00
|
|
|
} else
|
1994-05-24 10:09:53 +00:00
|
|
|
m_freem(m);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (error == 0)
|
|
|
|
ipstat.ips_fragmented++;
|
|
|
|
}
|
|
|
|
done:
|
1999-12-22 19:13:38 +00:00
|
|
|
#ifdef IPSEC
|
|
|
|
if (ro == &iproute && ro->ro_rt) {
|
|
|
|
RTFREE(ro->ro_rt);
|
|
|
|
ro->ro_rt = NULL;
|
|
|
|
}
|
|
|
|
if (sp != NULL) {
|
|
|
|
KEYDEBUG(KEYDEBUG_IPSEC_STAMP,
|
|
|
|
printf("DP ip_output call free SP:%p\n", sp));
|
|
|
|
key_freesp(sp);
|
|
|
|
}
|
|
|
|
#endif /* IPSEC */
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
bad:
|
2001-10-30 18:15:48 +00:00
|
|
|
m_freem(m);
|
1994-05-24 10:09:53 +00:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2000-05-21 21:26:06 +00:00
|
|
|
void
|
2000-03-27 19:14:27 +00:00
|
|
|
in_delayed_cksum(struct mbuf *m)
|
|
|
|
{
|
|
|
|
struct ip *ip;
|
|
|
|
u_short csum, offset;
|
|
|
|
|
|
|
|
ip = mtod(m, struct ip *);
|
|
|
|
offset = IP_VHL_HL(ip->ip_vhl) << 2 ;
|
|
|
|
csum = in_cksum_skip(m, ip->ip_len, offset);
|
RFC768 (UDP) requires that "if the computed checksum is zero, it
is transmitted as all ones". This got broken after introduction
of delayed checksums as follows. Some guys (including Jonathan)
think that it is allowed to transmit all ones in place of a zero
checksum for TCP the same way as for UDP. (The discussion still
takes place on -net.) Thus, the 0 -> 0xffff checksum fixup was
first moved from udp_output() (see udp_usrreq.c, 1.64 -> 1.65)
to in_cksum_skip() (see sys/i386/i386/in_cksum.c, 1.17 -> 1.18,
INVERT expression). Besides that I disagree that it is valid for
TCP, there was no real problem until in_cksum.c,v 1.20, where the
in_cksum() was made just a special version of in_cksum_skip().
The side effect was that now every incoming IP datagram failed to
pass the checksum test (in_cksum() returned 0xffff when it should
actually return zero). It was fixed next day in revision 1.21,
by removing the INVERT expression. The latter also broke the
0 -> 0xffff fixup for UDP checksums.
Before this change:
: tcpdump: listening on lo0
: 127.0.0.1.33005 > 127.0.0.1.33006: udp 0 (ttl 64, id 1)
: 4500 001c 0001 0000 4011 7cce 7f00 0001
: 7f00 0001 80ed 80ee 0008 0000
After this change:
: tcpdump: listening on lo0
: 127.0.0.1.33005 > 127.0.0.1.33006: udp 0 (ttl 64, id 1)
: 4500 001c 0001 0000 4011 7cce 7f00 0001
: 7f00 0001 80ed 80ee 0008 ffff
2001-03-13 17:07:06 +00:00
|
|
|
if (m->m_pkthdr.csum_flags & CSUM_UDP && csum == 0)
|
|
|
|
csum = 0xffff;
|
2000-03-27 19:14:27 +00:00
|
|
|
offset += m->m_pkthdr.csum_data; /* checksum offset */
|
|
|
|
|
|
|
|
if (offset + sizeof(u_short) > m->m_len) {
|
|
|
|
printf("delayed m_pullup, m->len: %d off: %d p: %d\n",
|
|
|
|
m->m_len, offset, ip->ip_p);
|
|
|
|
/*
|
|
|
|
* XXX
|
|
|
|
* this shouldn't happen, but if it does, the
|
|
|
|
* correct behavior may be to insert the checksum
|
|
|
|
* in the existing chain instead of rearranging it.
|
|
|
|
*/
|
|
|
|
m = m_pullup(m, offset + sizeof(u_short));
|
|
|
|
}
|
|
|
|
*(u_short *)(m->m_data + offset) = csum;
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
1996-03-13 08:02:45 +00:00
|
|
|
*
|
|
|
|
* XXX This routine assumes that the packet has no options in place.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
static struct mbuf *
|
|
|
|
ip_insertoptions(m, opt, phlen)
|
|
|
|
register struct mbuf *m;
|
|
|
|
struct mbuf *opt;
|
|
|
|
int *phlen;
|
|
|
|
{
|
|
|
|
register struct ipoption *p = mtod(opt, struct ipoption *);
|
|
|
|
struct mbuf *n;
|
|
|
|
register struct ip *ip = mtod(m, struct ip *);
|
|
|
|
unsigned optlen;
|
|
|
|
|
|
|
|
optlen = opt->m_len - sizeof(p->ipopt_dst);
|
|
|
|
if (optlen + (u_short)ip->ip_len > IP_MAXPACKET)
|
|
|
|
return (m); /* XXX should fail */
|
|
|
|
if (p->ipopt_dst.s_addr)
|
|
|
|
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);
|
|
|
|
if (n == 0)
|
|
|
|
return (m);
|
2000-01-10 18:46:05 +00:00
|
|
|
n->m_pkthdr.rcvif = (struct ifnet *)0;
|
1994-05-24 10:09:53 +00:00
|
|
|
n->m_pkthdr.len = m->m_pkthdr.len + optlen;
|
|
|
|
m->m_len -= sizeof(struct ip);
|
|
|
|
m->m_data += sizeof(struct ip);
|
|
|
|
n->m_next = m;
|
|
|
|
m = n;
|
|
|
|
m->m_len = optlen + sizeof(struct ip);
|
|
|
|
m->m_data += max_linkhdr;
|
1995-05-09 13:35:48 +00:00
|
|
|
(void)memcpy(mtod(m, void *), ip, sizeof(struct ip));
|
1994-05-24 10:09:53 +00:00
|
|
|
} else {
|
|
|
|
m->m_data -= optlen;
|
|
|
|
m->m_len += optlen;
|
|
|
|
m->m_pkthdr.len += optlen;
|
|
|
|
ovbcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
|
|
|
|
}
|
|
|
|
ip = mtod(m, struct ip *);
|
1996-06-08 08:19:03 +00:00
|
|
|
bcopy(p->ipopt_list, ip + 1, optlen);
|
1994-05-24 10:09:53 +00:00
|
|
|
*phlen = sizeof(struct ip) + optlen;
|
1996-04-18 15:49:06 +00:00
|
|
|
ip->ip_vhl = IP_MAKE_VHL(IPVERSION, *phlen >> 2);
|
1994-05-24 10:09:53 +00:00
|
|
|
ip->ip_len += optlen;
|
|
|
|
return (m);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy options from ip to jp,
|
|
|
|
* omitting those not copied during fragmentation.
|
|
|
|
*/
|
1997-04-03 10:47:12 +00:00
|
|
|
int
|
1994-05-24 10:09:53 +00:00
|
|
|
ip_optcopy(ip, jp)
|
|
|
|
struct ip *ip, *jp;
|
|
|
|
{
|
|
|
|
register u_char *cp, *dp;
|
|
|
|
int opt, optlen, cnt;
|
|
|
|
|
|
|
|
cp = (u_char *)(ip + 1);
|
|
|
|
dp = (u_char *)(jp + 1);
|
1996-04-18 15:49:06 +00:00
|
|
|
cnt = (IP_VHL_HL(ip->ip_vhl) << 2) - sizeof (struct ip);
|
1994-05-24 10:09:53 +00:00
|
|
|
for (; cnt > 0; cnt -= optlen, cp += optlen) {
|
|
|
|
opt = cp[0];
|
|
|
|
if (opt == IPOPT_EOL)
|
|
|
|
break;
|
|
|
|
if (opt == IPOPT_NOP) {
|
|
|
|
/* Preserve for IP mcast tunnel's LSRR alignment. */
|
|
|
|
*dp++ = IPOPT_NOP;
|
|
|
|
optlen = 1;
|
|
|
|
continue;
|
2000-07-04 16:35:15 +00:00
|
|
|
}
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (cnt < IPOPT_OLEN + sizeof(*cp))
|
|
|
|
panic("malformed IPv4 option passed to ip_optcopy");
|
|
|
|
#endif
|
|
|
|
optlen = cp[IPOPT_OLEN];
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (optlen < IPOPT_OLEN + sizeof(*cp) || optlen > cnt)
|
|
|
|
panic("malformed IPv4 option passed to ip_optcopy");
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
/* bogus lengths should have been caught by ip_dooptions */
|
|
|
|
if (optlen > cnt)
|
|
|
|
optlen = cnt;
|
|
|
|
if (IPOPT_COPIED(opt)) {
|
1996-06-08 08:19:03 +00:00
|
|
|
bcopy(cp, dp, optlen);
|
1994-05-24 10:09:53 +00:00
|
|
|
dp += optlen;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++)
|
|
|
|
*dp++ = IPOPT_EOL;
|
|
|
|
return (optlen);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IP socket option processing.
|
|
|
|
*/
|
|
|
|
int
|
1998-08-23 03:07:17 +00:00
|
|
|
ip_ctloutput(so, sopt)
|
1994-05-24 10:09:53 +00:00
|
|
|
struct socket *so;
|
1998-08-23 03:07:17 +00:00
|
|
|
struct sockopt *sopt;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1998-08-23 03:07:17 +00:00
|
|
|
struct inpcb *inp = sotoinpcb(so);
|
|
|
|
int error, optval;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
error = optval = 0;
|
|
|
|
if (sopt->sopt_level != IPPROTO_IP) {
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
switch (sopt->sopt_dir) {
|
|
|
|
case SOPT_SET:
|
|
|
|
switch (sopt->sopt_name) {
|
1994-05-24 10:09:53 +00:00
|
|
|
case IP_OPTIONS:
|
|
|
|
#ifdef notyet
|
|
|
|
case IP_RETOPTS:
|
|
|
|
#endif
|
1998-08-23 03:07:17 +00:00
|
|
|
{
|
|
|
|
struct mbuf *m;
|
|
|
|
if (sopt->sopt_valsize > MLEN) {
|
|
|
|
error = EMSGSIZE;
|
|
|
|
break;
|
|
|
|
}
|
2001-09-12 08:38:13 +00:00
|
|
|
MGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT, MT_HEADER);
|
1998-08-23 03:07:17 +00:00
|
|
|
if (m == 0) {
|
|
|
|
error = ENOBUFS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
m->m_len = sopt->sopt_valsize;
|
|
|
|
error = sooptcopyin(sopt, mtod(m, char *), m->m_len,
|
|
|
|
m->m_len);
|
|
|
|
|
|
|
|
return (ip_pcbopts(sopt->sopt_name, &inp->inp_options,
|
|
|
|
m));
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case IP_TOS:
|
|
|
|
case IP_TTL:
|
|
|
|
case IP_RECVOPTS:
|
|
|
|
case IP_RECVRETOPTS:
|
|
|
|
case IP_RECVDSTADDR:
|
1996-11-11 04:56:32 +00:00
|
|
|
case IP_RECVIF:
|
1999-12-22 19:13:38 +00:00
|
|
|
case IP_FAITH:
|
1998-08-23 03:07:17 +00:00
|
|
|
error = sooptcopyin(sopt, &optval, sizeof optval,
|
|
|
|
sizeof optval);
|
|
|
|
if (error)
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
switch (sopt->sopt_name) {
|
|
|
|
case IP_TOS:
|
|
|
|
inp->inp_ip_tos = optval;
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
case IP_TTL:
|
|
|
|
inp->inp_ip_ttl = optval;
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
#define OPTSET(bit) \
|
|
|
|
if (optval) \
|
|
|
|
inp->inp_flags |= bit; \
|
|
|
|
else \
|
|
|
|
inp->inp_flags &= ~bit;
|
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
case IP_RECVOPTS:
|
|
|
|
OPTSET(INP_RECVOPTS);
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
case IP_RECVRETOPTS:
|
|
|
|
OPTSET(INP_RECVRETOPTS);
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
case IP_RECVDSTADDR:
|
|
|
|
OPTSET(INP_RECVDSTADDR);
|
|
|
|
break;
|
1996-11-11 04:56:32 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
case IP_RECVIF:
|
|
|
|
OPTSET(INP_RECVIF);
|
|
|
|
break;
|
1999-12-22 19:13:38 +00:00
|
|
|
|
|
|
|
case IP_FAITH:
|
|
|
|
OPTSET(INP_FAITH);
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
#undef OPTSET
|
|
|
|
|
|
|
|
case IP_MULTICAST_IF:
|
1994-09-06 22:42:31 +00:00
|
|
|
case IP_MULTICAST_VIF:
|
1994-05-24 10:09:53 +00:00
|
|
|
case IP_MULTICAST_TTL:
|
|
|
|
case IP_MULTICAST_LOOP:
|
|
|
|
case IP_ADD_MEMBERSHIP:
|
|
|
|
case IP_DROP_MEMBERSHIP:
|
1998-08-23 03:07:17 +00:00
|
|
|
error = ip_setmoptions(sopt, &inp->inp_moptions);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
1996-02-22 21:32:23 +00:00
|
|
|
case IP_PORTRANGE:
|
1998-08-23 03:07:17 +00:00
|
|
|
error = sooptcopyin(sopt, &optval, sizeof optval,
|
|
|
|
sizeof optval);
|
|
|
|
if (error)
|
|
|
|
break;
|
1996-02-22 21:32:23 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
switch (optval) {
|
|
|
|
case IP_PORTRANGE_DEFAULT:
|
|
|
|
inp->inp_flags &= ~(INP_LOWPORT);
|
|
|
|
inp->inp_flags &= ~(INP_HIGHPORT);
|
|
|
|
break;
|
1996-02-22 21:32:23 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
case IP_PORTRANGE_HIGH:
|
|
|
|
inp->inp_flags &= ~(INP_LOWPORT);
|
|
|
|
inp->inp_flags |= INP_HIGHPORT;
|
|
|
|
break;
|
1996-02-22 21:32:23 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
case IP_PORTRANGE_LOW:
|
|
|
|
inp->inp_flags &= ~(INP_HIGHPORT);
|
|
|
|
inp->inp_flags |= INP_LOWPORT;
|
|
|
|
break;
|
1996-02-22 21:32:23 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
default:
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
1996-02-22 21:32:23 +00:00
|
|
|
}
|
1996-05-21 20:47:31 +00:00
|
|
|
break;
|
1996-02-22 21:32:23 +00:00
|
|
|
|
1999-12-22 19:13:38 +00:00
|
|
|
#ifdef IPSEC
|
|
|
|
case IP_IPSEC_POLICY:
|
|
|
|
{
|
|
|
|
caddr_t req;
|
2000-07-04 16:35:15 +00:00
|
|
|
size_t len = 0;
|
1999-12-22 19:13:38 +00:00
|
|
|
int priv;
|
|
|
|
struct mbuf *m;
|
|
|
|
int optname;
|
|
|
|
|
|
|
|
if ((error = soopt_getm(sopt, &m)) != 0) /* XXX */
|
|
|
|
break;
|
|
|
|
if ((error = soopt_mcopyin(sopt, m)) != 0) /* XXX */
|
|
|
|
break;
|
2001-09-12 08:38:13 +00:00
|
|
|
priv = (sopt->sopt_td != NULL &&
|
|
|
|
suser_td(sopt->sopt_td) != 0) ? 0 : 1;
|
1999-12-22 19:13:38 +00:00
|
|
|
req = mtod(m, caddr_t);
|
2000-07-04 16:35:15 +00:00
|
|
|
len = m->m_len;
|
1999-12-22 19:13:38 +00:00
|
|
|
optname = sopt->sopt_name;
|
2000-07-04 16:35:15 +00:00
|
|
|
error = ipsec4_set_policy(inp, optname, req, len, priv);
|
1999-12-22 19:13:38 +00:00
|
|
|
m_freem(m);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif /*IPSEC*/
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
default:
|
|
|
|
error = ENOPROTOOPT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
case SOPT_GET:
|
|
|
|
switch (sopt->sopt_name) {
|
1994-05-24 10:09:53 +00:00
|
|
|
case IP_OPTIONS:
|
|
|
|
case IP_RETOPTS:
|
1998-08-23 03:07:17 +00:00
|
|
|
if (inp->inp_options)
|
|
|
|
error = sooptcopyout(sopt,
|
|
|
|
mtod(inp->inp_options,
|
|
|
|
char *),
|
|
|
|
inp->inp_options->m_len);
|
|
|
|
else
|
|
|
|
sopt->sopt_valsize = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case IP_TOS:
|
|
|
|
case IP_TTL:
|
|
|
|
case IP_RECVOPTS:
|
|
|
|
case IP_RECVRETOPTS:
|
|
|
|
case IP_RECVDSTADDR:
|
1996-11-11 04:56:32 +00:00
|
|
|
case IP_RECVIF:
|
1998-08-23 03:07:17 +00:00
|
|
|
case IP_PORTRANGE:
|
1999-12-22 19:13:38 +00:00
|
|
|
case IP_FAITH:
|
1998-08-23 03:07:17 +00:00
|
|
|
switch (sopt->sopt_name) {
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case IP_TOS:
|
1997-04-03 05:14:45 +00:00
|
|
|
optval = inp->inp_ip_tos;
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case IP_TTL:
|
1997-04-03 05:14:45 +00:00
|
|
|
optval = inp->inp_ip_ttl;
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
#define OPTBIT(bit) (inp->inp_flags & bit ? 1 : 0)
|
|
|
|
|
|
|
|
case IP_RECVOPTS:
|
|
|
|
optval = OPTBIT(INP_RECVOPTS);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IP_RECVRETOPTS:
|
|
|
|
optval = OPTBIT(INP_RECVRETOPTS);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IP_RECVDSTADDR:
|
|
|
|
optval = OPTBIT(INP_RECVDSTADDR);
|
|
|
|
break;
|
1996-11-11 04:56:32 +00:00
|
|
|
|
|
|
|
case IP_RECVIF:
|
|
|
|
optval = OPTBIT(INP_RECVIF);
|
|
|
|
break;
|
1998-08-23 03:07:17 +00:00
|
|
|
|
|
|
|
case IP_PORTRANGE:
|
|
|
|
if (inp->inp_flags & INP_HIGHPORT)
|
|
|
|
optval = IP_PORTRANGE_HIGH;
|
|
|
|
else if (inp->inp_flags & INP_LOWPORT)
|
|
|
|
optval = IP_PORTRANGE_LOW;
|
|
|
|
else
|
|
|
|
optval = 0;
|
|
|
|
break;
|
1999-12-22 19:13:38 +00:00
|
|
|
|
|
|
|
case IP_FAITH:
|
|
|
|
optval = OPTBIT(INP_FAITH);
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1998-08-23 03:07:17 +00:00
|
|
|
error = sooptcopyout(sopt, &optval, sizeof optval);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case IP_MULTICAST_IF:
|
1994-09-06 22:42:31 +00:00
|
|
|
case IP_MULTICAST_VIF:
|
1994-05-24 10:09:53 +00:00
|
|
|
case IP_MULTICAST_TTL:
|
|
|
|
case IP_MULTICAST_LOOP:
|
|
|
|
case IP_ADD_MEMBERSHIP:
|
|
|
|
case IP_DROP_MEMBERSHIP:
|
1998-08-23 03:07:17 +00:00
|
|
|
error = ip_getmoptions(sopt, inp->inp_moptions);
|
1996-02-22 21:32:23 +00:00
|
|
|
break;
|
|
|
|
|
1999-12-22 19:13:38 +00:00
|
|
|
#ifdef IPSEC
|
|
|
|
case IP_IPSEC_POLICY:
|
|
|
|
{
|
2000-03-09 14:57:16 +00:00
|
|
|
struct mbuf *m = NULL;
|
1999-12-22 19:13:38 +00:00
|
|
|
caddr_t req = NULL;
|
2000-07-04 16:35:15 +00:00
|
|
|
size_t len = 0;
|
1999-12-22 19:13:38 +00:00
|
|
|
|
2000-07-04 16:35:15 +00:00
|
|
|
if (m != 0) {
|
1999-12-22 19:13:38 +00:00
|
|
|
req = mtod(m, caddr_t);
|
2000-07-04 16:35:15 +00:00
|
|
|
len = m->m_len;
|
|
|
|
}
|
|
|
|
error = ipsec4_get_policy(sotoinpcb(so), req, len, &m);
|
1999-12-22 19:13:38 +00:00
|
|
|
if (error == 0)
|
|
|
|
error = soopt_mcopyout(sopt, m); /* XXX */
|
2000-03-09 14:57:16 +00:00
|
|
|
if (error == 0)
|
|
|
|
m_freem(m);
|
1999-12-22 19:13:38 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif /*IPSEC*/
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
default:
|
|
|
|
error = ENOPROTOOPT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
1995-11-14 20:34:56 +00:00
|
|
|
static int
|
1994-05-24 10:09:53 +00:00
|
|
|
ip_pcbopts(optname, pcbopt, m)
|
|
|
|
int optname;
|
|
|
|
struct mbuf **pcbopt;
|
|
|
|
register struct mbuf *m;
|
|
|
|
{
|
1998-02-20 13:37:40 +00:00
|
|
|
register int cnt, optlen;
|
1994-05-24 10:09:53 +00:00
|
|
|
register u_char *cp;
|
|
|
|
u_char opt;
|
|
|
|
|
|
|
|
/* turn off any old options */
|
|
|
|
if (*pcbopt)
|
|
|
|
(void)m_free(*pcbopt);
|
|
|
|
*pcbopt = 0;
|
|
|
|
if (m == (struct mbuf *)0 || m->m_len == 0) {
|
|
|
|
/*
|
|
|
|
* Only turning off any previous options.
|
|
|
|
*/
|
|
|
|
if (m)
|
|
|
|
(void)m_free(m);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1998-07-13 12:12:25 +00:00
|
|
|
if (m->m_len % sizeof(int32_t))
|
1994-05-24 10:09:53 +00:00
|
|
|
goto bad;
|
|
|
|
/*
|
|
|
|
* 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])
|
|
|
|
goto bad;
|
|
|
|
cnt = m->m_len;
|
|
|
|
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) {
|
|
|
|
opt = cp[IPOPT_OPTVAL];
|
|
|
|
if (opt == IPOPT_EOL)
|
|
|
|
break;
|
|
|
|
if (opt == IPOPT_NOP)
|
|
|
|
optlen = 1;
|
|
|
|
else {
|
2000-06-02 20:18:38 +00:00
|
|
|
if (cnt < IPOPT_OLEN + sizeof(*cp))
|
|
|
|
goto bad;
|
1994-05-24 10:09:53 +00:00
|
|
|
optlen = cp[IPOPT_OLEN];
|
2000-06-02 20:18:38 +00:00
|
|
|
if (optlen < IPOPT_OLEN + sizeof(*cp) || optlen > cnt)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
switch (opt) {
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPOPT_LSRR:
|
|
|
|
case IPOPT_SSRR:
|
|
|
|
/*
|
|
|
|
* user process specifies route as:
|
|
|
|
* ->A->B->C->D
|
|
|
|
* 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))
|
|
|
|
goto bad;
|
|
|
|
m->m_len -= sizeof(struct in_addr);
|
|
|
|
cnt -= sizeof(struct in_addr);
|
|
|
|
optlen -= sizeof(struct in_addr);
|
|
|
|
cp[IPOPT_OLEN] = optlen;
|
|
|
|
/*
|
|
|
|
* Move first hop before start of options.
|
|
|
|
*/
|
|
|
|
bcopy((caddr_t)&cp[IPOPT_OFFSET+1], mtod(m, caddr_t),
|
|
|
|
sizeof(struct in_addr));
|
|
|
|
/*
|
|
|
|
* Then copy rest of options back
|
|
|
|
* to close up the deleted entry.
|
|
|
|
*/
|
|
|
|
ovbcopy((caddr_t)(&cp[IPOPT_OFFSET+1] +
|
|
|
|
sizeof(struct in_addr)),
|
|
|
|
(caddr_t)&cp[IPOPT_OFFSET+1],
|
|
|
|
(unsigned)cnt + sizeof(struct in_addr));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (m->m_len > MAX_IPOPTLEN + sizeof(struct in_addr))
|
|
|
|
goto bad;
|
|
|
|
*pcbopt = m;
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
bad:
|
|
|
|
(void)m_free(m);
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
/*
|
|
|
|
* XXX
|
|
|
|
* The whole multicast option thing needs to be re-thought.
|
|
|
|
* Several of these options are equally applicable to non-multicast
|
|
|
|
* transmission, and one (IP_MULTICAST_TTL) totally duplicates a
|
|
|
|
* standard option (IP_TTL).
|
|
|
|
*/
|
2001-06-11 12:39:29 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* following RFC1724 section 3.3, 0.0.0.0/8 is interpreted as interface index.
|
|
|
|
*/
|
|
|
|
static struct ifnet *
|
|
|
|
ip_multicast_if(a, ifindexp)
|
|
|
|
struct in_addr *a;
|
|
|
|
int *ifindexp;
|
|
|
|
{
|
|
|
|
int ifindex;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
|
|
|
|
if (ifindexp)
|
|
|
|
*ifindexp = 0;
|
|
|
|
if (ntohl(a->s_addr) >> 24 == 0) {
|
|
|
|
ifindex = ntohl(a->s_addr) & 0xffffff;
|
|
|
|
if (ifindex < 0 || if_index < ifindex)
|
|
|
|
return NULL;
|
2001-09-06 02:40:43 +00:00
|
|
|
ifp = ifnet_byindex(ifindex);
|
2001-06-11 12:39:29 +00:00
|
|
|
if (ifindexp)
|
|
|
|
*ifindexp = ifindex;
|
|
|
|
} else {
|
|
|
|
INADDR_TO_IFP(*a, ifp);
|
|
|
|
}
|
|
|
|
return ifp;
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Set the IP multicast options in response to user setsockopt().
|
|
|
|
*/
|
1995-11-14 20:34:56 +00:00
|
|
|
static int
|
1998-08-23 03:07:17 +00:00
|
|
|
ip_setmoptions(sopt, imop)
|
|
|
|
struct sockopt *sopt;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct ip_moptions **imop;
|
|
|
|
{
|
1998-08-23 03:07:17 +00:00
|
|
|
int error = 0;
|
|
|
|
int i;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct in_addr addr;
|
1998-08-23 03:07:17 +00:00
|
|
|
struct ip_mreq mreq;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
struct ip_moptions *imo = *imop;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct route ro;
|
1998-08-23 03:07:17 +00:00
|
|
|
struct sockaddr_in *dst;
|
2001-06-11 12:39:29 +00:00
|
|
|
int ifindex;
|
1995-03-20 18:11:31 +00:00
|
|
|
int s;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if (imo == NULL) {
|
|
|
|
/*
|
|
|
|
* No multicast option buffer attached to the pcb;
|
|
|
|
* allocate one and initialize to default values.
|
|
|
|
*/
|
|
|
|
imo = (struct ip_moptions*)malloc(sizeof(*imo), M_IPMOPTS,
|
|
|
|
M_WAITOK);
|
|
|
|
|
|
|
|
if (imo == NULL)
|
|
|
|
return (ENOBUFS);
|
|
|
|
*imop = imo;
|
|
|
|
imo->imo_multicast_ifp = NULL;
|
2001-06-11 12:39:29 +00:00
|
|
|
imo->imo_multicast_addr.s_addr = INADDR_ANY;
|
1995-06-13 17:51:16 +00:00
|
|
|
imo->imo_multicast_vif = -1;
|
1994-05-24 10:09:53 +00:00
|
|
|
imo->imo_multicast_ttl = IP_DEFAULT_MULTICAST_TTL;
|
|
|
|
imo->imo_multicast_loop = IP_DEFAULT_MULTICAST_LOOP;
|
|
|
|
imo->imo_num_memberships = 0;
|
|
|
|
}
|
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
switch (sopt->sopt_name) {
|
1994-09-06 22:42:31 +00:00
|
|
|
/* store an index number for the vif you wanna use in the send */
|
|
|
|
case IP_MULTICAST_VIF:
|
1998-08-23 03:07:17 +00:00
|
|
|
if (legal_vif_num == 0) {
|
1994-09-14 03:10:15 +00:00
|
|
|
error = EOPNOTSUPP;
|
|
|
|
break;
|
|
|
|
}
|
1998-08-23 03:07:17 +00:00
|
|
|
error = sooptcopyin(sopt, &i, sizeof i, sizeof i);
|
|
|
|
if (error)
|
1994-09-06 22:42:31 +00:00
|
|
|
break;
|
1995-06-13 17:51:16 +00:00
|
|
|
if (!legal_vif_num(i) && (i != -1)) {
|
1994-09-06 22:42:31 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
imo->imo_multicast_vif = i;
|
|
|
|
break;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
case IP_MULTICAST_IF:
|
|
|
|
/*
|
|
|
|
* Select the interface for outgoing multicast packets.
|
|
|
|
*/
|
1998-08-23 03:07:17 +00:00
|
|
|
error = sooptcopyin(sopt, &addr, sizeof addr, sizeof addr);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* The selected interface is identified by its local
|
|
|
|
* IP address. Find the interface and confirm that
|
|
|
|
* it supports multicasting.
|
|
|
|
*/
|
1995-03-20 18:31:51 +00:00
|
|
|
s = splimp();
|
2001-06-11 12:39:29 +00:00
|
|
|
ifp = ip_multicast_if(&addr, &ifindex);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
|
1996-03-26 18:56:51 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
error = EADDRNOTAVAIL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
imo->imo_multicast_ifp = ifp;
|
2001-06-11 12:39:29 +00:00
|
|
|
if (ifindex)
|
|
|
|
imo->imo_multicast_addr = addr;
|
|
|
|
else
|
|
|
|
imo->imo_multicast_addr.s_addr = INADDR_ANY;
|
1995-03-20 18:11:31 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case IP_MULTICAST_TTL:
|
|
|
|
/*
|
|
|
|
* Set the IP time-to-live for outgoing multicast packets.
|
1998-08-23 03:07:17 +00:00
|
|
|
* The original multicast API required a char argument,
|
|
|
|
* which is inconsistent with the rest of the socket API.
|
|
|
|
* We allow either a char or an int.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1998-08-23 03:07:17 +00:00
|
|
|
if (sopt->sopt_valsize == 1) {
|
|
|
|
u_char ttl;
|
|
|
|
error = sooptcopyin(sopt, &ttl, 1, 1);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
imo->imo_multicast_ttl = ttl;
|
|
|
|
} else {
|
|
|
|
u_int ttl;
|
|
|
|
error = sooptcopyin(sopt, &ttl, sizeof ttl,
|
|
|
|
sizeof ttl);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
if (ttl > 255)
|
|
|
|
error = EINVAL;
|
|
|
|
else
|
|
|
|
imo->imo_multicast_ttl = ttl;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IP_MULTICAST_LOOP:
|
|
|
|
/*
|
|
|
|
* Set the loopback flag for outgoing multicast packets.
|
1998-08-23 03:07:17 +00:00
|
|
|
* Must be zero or one. The original multicast API required a
|
|
|
|
* char argument, which is inconsistent with the rest
|
|
|
|
* of the socket API. We allow either a char or an int.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1998-08-23 03:07:17 +00:00
|
|
|
if (sopt->sopt_valsize == 1) {
|
|
|
|
u_char loop;
|
|
|
|
error = sooptcopyin(sopt, &loop, 1, 1);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
imo->imo_multicast_loop = !!loop;
|
|
|
|
} else {
|
|
|
|
u_int loop;
|
|
|
|
error = sooptcopyin(sopt, &loop, sizeof loop,
|
|
|
|
sizeof loop);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
imo->imo_multicast_loop = !!loop;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IP_ADD_MEMBERSHIP:
|
|
|
|
/*
|
|
|
|
* Add a multicast group membership.
|
|
|
|
* Group must be a valid IP multicast address.
|
|
|
|
*/
|
1998-08-23 03:07:17 +00:00
|
|
|
error = sooptcopyin(sopt, &mreq, sizeof mreq, sizeof mreq);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
1998-08-23 03:07:17 +00:00
|
|
|
|
|
|
|
if (!IN_MULTICAST(ntohl(mreq.imr_multiaddr.s_addr))) {
|
1994-05-24 10:09:53 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
1995-03-20 18:31:51 +00:00
|
|
|
s = splimp();
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* If no interface address was provided, use the interface of
|
|
|
|
* the route to the given multicast address.
|
|
|
|
*/
|
1998-08-23 03:07:17 +00:00
|
|
|
if (mreq.imr_interface.s_addr == INADDR_ANY) {
|
1995-06-13 17:51:16 +00:00
|
|
|
bzero((caddr_t)&ro, sizeof(ro));
|
1994-05-24 10:09:53 +00:00
|
|
|
dst = (struct sockaddr_in *)&ro.ro_dst;
|
|
|
|
dst->sin_len = sizeof(*dst);
|
|
|
|
dst->sin_family = AF_INET;
|
1998-08-23 03:07:17 +00:00
|
|
|
dst->sin_addr = mreq.imr_multiaddr;
|
1994-05-24 10:09:53 +00:00
|
|
|
rtalloc(&ro);
|
|
|
|
if (ro.ro_rt == NULL) {
|
|
|
|
error = EADDRNOTAVAIL;
|
1995-03-20 18:11:31 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
ifp = ro.ro_rt->rt_ifp;
|
|
|
|
rtfree(ro.ro_rt);
|
|
|
|
}
|
|
|
|
else {
|
2001-06-11 12:39:29 +00:00
|
|
|
ifp = ip_multicast_if(&mreq.imr_interface, NULL);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1995-03-20 18:11:31 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* See if we found an interface, and confirm that it
|
|
|
|
* supports multicast.
|
|
|
|
*/
|
|
|
|
if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
|
|
|
|
error = EADDRNOTAVAIL;
|
1995-03-20 18:11:31 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* 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
|
1998-08-23 03:07:17 +00:00
|
|
|
== mreq.imr_multiaddr.s_addr)
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i < imo->imo_num_memberships) {
|
|
|
|
error = EADDRINUSE;
|
1995-03-20 18:11:31 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i == IP_MAX_MEMBERSHIPS) {
|
|
|
|
error = ETOOMANYREFS;
|
1995-03-20 18:11:31 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Everything looks good; add a new record to the multicast
|
|
|
|
* address list for the given interface.
|
|
|
|
*/
|
|
|
|
if ((imo->imo_membership[i] =
|
1998-08-23 03:07:17 +00:00
|
|
|
in_addmulti(&mreq.imr_multiaddr, ifp)) == NULL) {
|
1994-05-24 10:09:53 +00:00
|
|
|
error = ENOBUFS;
|
1995-03-20 18:11:31 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
++imo->imo_num_memberships;
|
1995-03-20 18:11:31 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case IP_DROP_MEMBERSHIP:
|
|
|
|
/*
|
|
|
|
* Drop a multicast group membership.
|
|
|
|
* Group must be a valid IP multicast address.
|
|
|
|
*/
|
1998-08-23 03:07:17 +00:00
|
|
|
error = sooptcopyin(sopt, &mreq, sizeof mreq, sizeof mreq);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
1998-08-23 03:07:17 +00:00
|
|
|
|
|
|
|
if (!IN_MULTICAST(ntohl(mreq.imr_multiaddr.s_addr))) {
|
1994-05-24 10:09:53 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
1995-03-20 18:11:31 +00:00
|
|
|
|
1995-03-20 18:31:51 +00:00
|
|
|
s = splimp();
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* If an interface address was specified, get a pointer
|
|
|
|
* to its ifnet structure.
|
|
|
|
*/
|
1998-08-23 03:07:17 +00:00
|
|
|
if (mreq.imr_interface.s_addr == INADDR_ANY)
|
1994-05-24 10:09:53 +00:00
|
|
|
ifp = NULL;
|
|
|
|
else {
|
2001-06-11 12:39:29 +00:00
|
|
|
ifp = ip_multicast_if(&mreq.imr_interface, NULL);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ifp == NULL) {
|
|
|
|
error = EADDRNOTAVAIL;
|
1995-03-20 18:11:31 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Find the membership in the membership array.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < imo->imo_num_memberships; ++i) {
|
|
|
|
if ((ifp == NULL ||
|
|
|
|
imo->imo_membership[i]->inm_ifp == ifp) &&
|
|
|
|
imo->imo_membership[i]->inm_addr.s_addr ==
|
1998-08-23 03:07:17 +00:00
|
|
|
mreq.imr_multiaddr.s_addr)
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i == imo->imo_num_memberships) {
|
|
|
|
error = EADDRNOTAVAIL;
|
1995-03-20 18:11:31 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Give up the multicast address record to which the
|
|
|
|
* membership points.
|
|
|
|
*/
|
|
|
|
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;
|
1995-03-20 18:11:31 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
error = EOPNOTSUPP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If all options have default values, no need to keep the mbuf.
|
|
|
|
*/
|
|
|
|
if (imo->imo_multicast_ifp == NULL &&
|
1995-06-13 17:51:16 +00:00
|
|
|
imo->imo_multicast_vif == -1 &&
|
1994-05-24 10:09:53 +00:00
|
|
|
imo->imo_multicast_ttl == IP_DEFAULT_MULTICAST_TTL &&
|
|
|
|
imo->imo_multicast_loop == IP_DEFAULT_MULTICAST_LOOP &&
|
|
|
|
imo->imo_num_memberships == 0) {
|
|
|
|
free(*imop, M_IPMOPTS);
|
|
|
|
*imop = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the IP multicast options in response to user getsockopt().
|
|
|
|
*/
|
1995-11-14 20:34:56 +00:00
|
|
|
static int
|
1998-08-23 03:07:17 +00:00
|
|
|
ip_getmoptions(sopt, imo)
|
|
|
|
struct sockopt *sopt;
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct ip_moptions *imo;
|
|
|
|
{
|
1998-08-23 03:07:17 +00:00
|
|
|
struct in_addr addr;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct in_ifaddr *ia;
|
1998-08-23 03:07:17 +00:00
|
|
|
int error, optval;
|
|
|
|
u_char coptval;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-08-23 03:07:17 +00:00
|
|
|
error = 0;
|
|
|
|
switch (sopt->sopt_name) {
|
1995-06-13 17:51:16 +00:00
|
|
|
case IP_MULTICAST_VIF:
|
1994-09-06 22:42:31 +00:00
|
|
|
if (imo != NULL)
|
1998-08-23 03:07:17 +00:00
|
|
|
optval = imo->imo_multicast_vif;
|
1994-09-06 22:42:31 +00:00
|
|
|
else
|
1998-08-23 03:07:17 +00:00
|
|
|
optval = -1;
|
|
|
|
error = sooptcopyout(sopt, &optval, sizeof optval);
|
|
|
|
break;
|
1994-09-06 22:42:31 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
case IP_MULTICAST_IF:
|
|
|
|
if (imo == NULL || imo->imo_multicast_ifp == NULL)
|
1998-08-23 03:07:17 +00:00
|
|
|
addr.s_addr = INADDR_ANY;
|
2001-06-11 12:39:29 +00:00
|
|
|
else if (imo->imo_multicast_addr.s_addr) {
|
|
|
|
/* return the value user has set */
|
|
|
|
addr = imo->imo_multicast_addr;
|
|
|
|
} else {
|
1994-05-24 10:09:53 +00:00
|
|
|
IFP_TO_IA(imo->imo_multicast_ifp, ia);
|
1998-08-23 03:07:17 +00:00
|
|
|
addr.s_addr = (ia == NULL) ? INADDR_ANY
|
|
|
|
: IA_SIN(ia)->sin_addr.s_addr;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1998-08-23 03:07:17 +00:00
|
|
|
error = sooptcopyout(sopt, &addr, sizeof addr);
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case IP_MULTICAST_TTL:
|
1998-08-23 03:07:17 +00:00
|
|
|
if (imo == 0)
|
|
|
|
optval = coptval = IP_DEFAULT_MULTICAST_TTL;
|
|
|
|
else
|
|
|
|
optval = coptval = imo->imo_multicast_ttl;
|
|
|
|
if (sopt->sopt_valsize == 1)
|
|
|
|
error = sooptcopyout(sopt, &coptval, 1);
|
|
|
|
else
|
|
|
|
error = sooptcopyout(sopt, &optval, sizeof optval);
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
case IP_MULTICAST_LOOP:
|
1998-08-23 03:07:17 +00:00
|
|
|
if (imo == 0)
|
|
|
|
optval = coptval = IP_DEFAULT_MULTICAST_LOOP;
|
|
|
|
else
|
|
|
|
optval = coptval = imo->imo_multicast_loop;
|
|
|
|
if (sopt->sopt_valsize == 1)
|
|
|
|
error = sooptcopyout(sopt, &coptval, 1);
|
|
|
|
else
|
|
|
|
error = sooptcopyout(sopt, &optval, sizeof optval);
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
default:
|
1998-08-23 03:07:17 +00:00
|
|
|
error = ENOPROTOOPT;
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1998-08-23 03:07:17 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Discard the IP multicast options.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ip_freemoptions(imo)
|
|
|
|
register struct ip_moptions *imo;
|
|
|
|
{
|
|
|
|
register int i;
|
|
|
|
|
|
|
|
if (imo != NULL) {
|
|
|
|
for (i = 0; i < imo->imo_num_memberships; ++i)
|
|
|
|
in_delmulti(imo->imo_membership[i]);
|
|
|
|
free(imo, M_IPMOPTS);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
1995-04-26 18:10:58 +00:00
|
|
|
* pointer that might NOT be a loopback interface -- evil, but easier than
|
|
|
|
* replicating that code here.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
static void
|
1997-05-06 21:22:04 +00:00
|
|
|
ip_mloopback(ifp, m, dst, hlen)
|
1994-05-24 10:09:53 +00:00
|
|
|
struct ifnet *ifp;
|
|
|
|
register struct mbuf *m;
|
|
|
|
register struct sockaddr_in *dst;
|
1997-05-06 21:22:04 +00:00
|
|
|
int hlen;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct ip *ip;
|
|
|
|
struct mbuf *copym;
|
|
|
|
|
|
|
|
copym = m_copy(m, 0, M_COPYALL);
|
1997-05-06 21:22:04 +00:00
|
|
|
if (copym != NULL && (copym->m_flags & M_EXT || copym->m_len < hlen))
|
|
|
|
copym = m_pullup(copym, hlen);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (copym != NULL) {
|
|
|
|
/*
|
|
|
|
* 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 *);
|
2002-02-18 20:35:27 +00:00
|
|
|
ip->ip_len = htons(ip->ip_len);
|
|
|
|
ip->ip_off = htons(ip->ip_off);
|
1994-05-24 10:09:53 +00:00
|
|
|
ip->ip_sum = 0;
|
1996-04-18 15:49:06 +00:00
|
|
|
if (ip->ip_vhl == IP_VHL_BORING) {
|
|
|
|
ip->ip_sum = in_cksum_hdr(ip);
|
|
|
|
} else {
|
1997-05-06 21:22:04 +00:00
|
|
|
ip->ip_sum = in_cksum(copym, hlen);
|
1996-04-18 15:49:06 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* NB:
|
1997-02-28 19:40:48 +00:00
|
|
|
* It's not clear whether there are any lingering
|
|
|
|
* reentrancy problems in other areas which might
|
|
|
|
* be exposed by using ip_input directly (in
|
|
|
|
* particular, everything which modifies the packet
|
|
|
|
* in-place). Yet another option is using the
|
|
|
|
* protosw directly to deliver the looped back
|
|
|
|
* packet. For the moment, we'll err on the side
|
1998-06-12 03:48:19 +00:00
|
|
|
* of safety by using if_simloop().
|
1996-04-18 15:49:06 +00:00
|
|
|
*/
|
1998-06-14 20:58:17 +00:00
|
|
|
#if 1 /* XXX */
|
|
|
|
if (dst->sin_family != AF_INET) {
|
1998-06-15 00:35:47 +00:00
|
|
|
printf("ip_mloopback: bad address family %d\n",
|
1998-06-14 20:58:17 +00:00
|
|
|
dst->sin_family);
|
|
|
|
dst->sin_family = AF_INET;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1996-04-18 15:49:06 +00:00
|
|
|
#ifdef notdef
|
1997-02-28 19:40:48 +00:00
|
|
|
copym->m_pkthdr.rcvif = ifp;
|
1998-06-12 03:48:19 +00:00
|
|
|
ip_input(copym);
|
1996-04-18 15:49:06 +00:00
|
|
|
#else
|
2000-05-25 02:27:14 +00:00
|
|
|
/* if the checksum hasn't been computed, mark it as valid */
|
|
|
|
if (copym->m_pkthdr.csum_flags & CSUM_DELAY_DATA) {
|
|
|
|
copym->m_pkthdr.csum_flags |=
|
|
|
|
CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
|
|
|
|
copym->m_pkthdr.csum_data = 0xffff;
|
|
|
|
}
|
2000-05-24 21:16:56 +00:00
|
|
|
if_simloop(ifp, copym, dst->sin_family, 0);
|
1996-04-18 15:49:06 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|