2 * Copyright (c) 1982, 1986, 1988, 1993
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * @(#)ip_icmp.c 8.2 (Berkeley) 1/4/94
30 * $FreeBSD: src/sys/netinet/ip_icmp.c,v 1.39.2.19 2003/01/24 05:11:34 sam Exp $
33 #include <sys/param.h>
34 #include <sys/systm.h>
36 #include <sys/protosw.h>
37 #include <sys/socket.h>
38 #include <sys/socketops.h>
40 #include <sys/kernel.h>
41 #include <sys/sysctl.h>
42 #include <sys/in_cksum.h>
44 #include <machine/stdarg.h>
47 #include <net/if_types.h>
48 #include <net/netisr2.h>
49 #include <net/netmsg2.h>
50 #include <net/route.h>
53 #include <netinet/in.h>
54 #include <netinet/in_systm.h>
55 #include <netinet/in_var.h>
56 #include <netinet/ip.h>
57 #include <netinet/ip_icmp.h>
58 #include <netinet/ip_var.h>
59 #include <netinet/icmp_var.h>
62 * ICMP routines: error generation, receive packet processing, and
63 * routines to turnaround packets back to the originator, and
64 * host table maintenance routines.
67 struct icmpstat icmpstat
;
68 SYSCTL_STRUCT(_net_inet_icmp
, ICMPCTL_STATS
, stats
, CTLFLAG_RW
,
69 &icmpstat
, icmpstat
, "ICMP statistics");
71 static int icmpmaskrepl
= 0;
72 SYSCTL_INT(_net_inet_icmp
, ICMPCTL_MASKREPL
, maskrepl
, CTLFLAG_RW
,
73 &icmpmaskrepl
, 0, "Allow replies to netmask requests");
75 static int drop_redirect
= 0;
76 SYSCTL_INT(_net_inet_icmp
, OID_AUTO
, drop_redirect
, CTLFLAG_RW
,
77 &drop_redirect
, 0, "Ignore ICMP redirects");
79 static int log_redirect
= 0;
80 SYSCTL_INT(_net_inet_icmp
, OID_AUTO
, log_redirect
, CTLFLAG_RW
,
81 &log_redirect
, 0, "Enable output about ICMP redirects");
83 static int discard_sourcequench
= 1;
84 SYSCTL_INT(_net_inet_icmp
, OID_AUTO
, discard_sourcequench
, CTLFLAG_RW
,
85 &discard_sourcequench
, 0, "Discard ICMP Source Quench");
90 * ICMP error-response bandwidth limiting sysctl. If not enabled, sysctl
91 * variable content is -1 and read-only.
94 static int icmplim
= 200;
95 SYSCTL_INT(_net_inet_icmp
, ICMPCTL_ICMPLIM
, icmplim
, CTLFLAG_RW
,
96 &icmplim
, 0, "ICMP bandwidth limit");
99 static int icmplim
= -1;
100 SYSCTL_INT(_net_inet_icmp
, ICMPCTL_ICMPLIM
, icmplim
, CTLFLAG_RD
,
101 &icmplim
, 0, "ICMP bandwidth limit");
105 static int icmplim_output
= 0;
106 SYSCTL_INT(_net_inet_icmp
, OID_AUTO
, icmplim_output
, CTLFLAG_RW
,
107 &icmplim_output
, 0, "Enable output about ICMP bandwidth limits");
110 * ICMP broadcast echo sysctl
113 static int icmpbmcastecho
= 0;
114 SYSCTL_INT(_net_inet_icmp
, OID_AUTO
, bmcastecho
, CTLFLAG_RW
,
115 &icmpbmcastecho
, 0, "");
117 static char icmp_reply_src
[IFNAMSIZ
];
118 SYSCTL_STRING(_net_inet_icmp
, OID_AUTO
, reply_src
, CTLFLAG_RW
,
119 icmp_reply_src
, IFNAMSIZ
, "icmp reply source for non-local packets.");
122 SYSCTL_INT(_net_inet_icmp
, OID_AUTO
, reply_from_interface
, CTLFLAG_RW
,
123 &icmp_rfi
, 0, "ICMP reply from incoming interface for "
124 "non-local packets");
127 static int icmpprintfs
= 0;
128 SYSCTL_INT(_net_inet_icmp
, OID_AUTO
, debug_prints
, CTLFLAG_RW
,
129 &icmpprintfs
, 0, "extra ICMP debug prints");
132 static void icmp_reflect (struct mbuf
*);
133 static void icmp_send (struct mbuf
*, struct mbuf
*, struct route
*);
135 extern struct protosw inetsw
[];
138 * Generate an error packet of type error
139 * in response to bad packet ip.
142 icmp_error(struct mbuf
*n
, int type
, int code
, n_long dest
, int destmtu
)
144 struct ip
*oip
= mtod(n
, struct ip
*), *nip
;
145 unsigned oiplen
= IP_VHL_HL(oip
->ip_vhl
) << 2;
152 kprintf("icmp_error(%p, %d, %d)\n", oip
, type
, code
);
154 if (type
!= ICMP_REDIRECT
)
155 icmpstat
.icps_error
++;
157 * Don't send error if the original packet was encrypted.
158 * Don't send error if not the first fragment of message.
159 * Don't error if the old packet protocol was ICMP
160 * error message, only known informational types.
162 if (n
->m_flags
& M_DECRYPTED
)
164 if (oip
->ip_off
&~ (IP_MF
|IP_DF
))
166 if (oip
->ip_p
== IPPROTO_ICMP
&& type
!= ICMP_REDIRECT
&&
167 n
->m_len
>= oiplen
+ ICMP_MINLEN
&&
168 !ICMP_INFOTYPE(((struct icmp
*)((caddr_t
)oip
+ oiplen
))->icmp_type
)) {
169 icmpstat
.icps_oldicmp
++;
172 /* Don't send error in response to a multicast or broadcast packet */
173 if (n
->m_flags
& (M_BCAST
|M_MCAST
))
176 * First, formulate icmp message
178 m
= m_gethdr(M_NOWAIT
, MT_HEADER
);
181 icmplen
= min(oiplen
+ 8, oip
->ip_len
);
182 if (icmplen
< sizeof(struct ip
))
183 panic("icmp_error: bad length");
184 m
->m_len
= icmplen
+ ICMP_MINLEN
;
185 MH_ALIGN(m
, m
->m_len
);
186 icp
= mtod(m
, struct icmp
*);
187 if ((u_int
)type
> ICMP_MAXTYPE
)
189 icmpstat
.icps_outhist
[type
]++;
190 icp
->icmp_type
= type
;
191 if (type
== ICMP_REDIRECT
)
192 icp
->icmp_gwaddr
.s_addr
= dest
;
196 * The following assignments assume an overlay with the
197 * zeroed icmp_void field.
199 if (type
== ICMP_PARAMPROB
) {
200 icp
->icmp_pptr
= code
;
202 } else if (type
== ICMP_UNREACH
&&
203 code
== ICMP_UNREACH_NEEDFRAG
&& destmtu
) {
204 icp
->icmp_nextmtu
= htons(destmtu
);
208 icp
->icmp_code
= code
;
209 m_copydata(n
, 0, icmplen
, (caddr_t
)&icp
->icmp_ip
);
213 * Convert fields to network representation.
215 nip
->ip_len
= htons(nip
->ip_len
);
216 nip
->ip_off
= htons(nip
->ip_off
);
219 * Now, copy old ip header (without options)
220 * in front of icmp message.
222 if (m
->m_data
- sizeof(struct ip
) < m
->m_pktdat
)
224 m
->m_data
-= sizeof(struct ip
);
225 m
->m_len
+= sizeof(struct ip
);
226 m
->m_pkthdr
.len
= m
->m_len
;
227 m
->m_pkthdr
.rcvif
= n
->m_pkthdr
.rcvif
;
228 nip
= mtod(m
, struct ip
*);
229 bcopy(oip
, nip
, sizeof(struct ip
));
230 nip
->ip_len
= m
->m_len
;
231 nip
->ip_vhl
= IP_VHL_BORING
;
232 nip
->ip_p
= IPPROTO_ICMP
;
234 m
->m_pkthdr
.fw_flags
|= n
->m_pkthdr
.fw_flags
& FW_MBUF_GENERATED
;
242 icmp_ctlinput_done_handler(netmsg_t nmsg
)
244 struct netmsg_ctlinput
*msg
= (struct netmsg_ctlinput
*)nmsg
;
245 struct mbuf
*m
= msg
->m
;
246 int hlen
= msg
->hlen
;
248 rip_input(&m
, &hlen
, msg
->proto
);
252 icmp_ctlinput_done(struct mbuf
*m
)
254 struct netmsg_ctlinput
*msg
= &m
->m_hdr
.mh_ctlmsg
;
256 netmsg_init(&msg
->base
, NULL
, &netisr_apanic_rport
, 0,
257 icmp_ctlinput_done_handler
);
258 lwkt_sendmsg(netisr_cpuport(0), &msg
->base
.lmsg
);
262 icmp_mtudisc(struct mbuf
*m
, int hlen
)
264 struct sockaddr_in icmpsrc
= { sizeof(struct sockaddr_in
), AF_INET
};
268 KASSERT(curthread
->td_type
== TD_TYPE_NETISR
, ("not in netisr"));
270 icp
= mtodoff(m
, struct icmp
*, hlen
);
271 icmpsrc
.sin_addr
= icp
->icmp_ip
.ip_dst
;
275 * If we got a needfrag and there is a host route to the original
276 * destination, and the MTU is not locked, then set the MTU in the
277 * route to the suggested new value (if given) and then notify as
278 * usual. The ULPs will notice that the MTU has changed and adapt
279 * accordingly. If no new MTU was suggested, then we guess a new
280 * one less than the current value. If the new MTU is unreasonably
281 * small (arbitrarily set at 296), then we reset the MTU to the
282 * interface value and enable the lock bit, indicating that we are
283 * no longer doing MTU discovery.
285 rt
= rtpurelookup((struct sockaddr
*)&icmpsrc
);
286 if (rt
!= NULL
&& (rt
->rt_flags
& RTF_HOST
) &&
287 !(rt
->rt_rmx
.rmx_locks
& RTV_MTU
)) {
289 char src_buf
[INET_ADDRSTRLEN
];
293 mtu
= ntohs(icp
->icmp_nextmtu
);
295 mtu
= ip_next_mtu(rt
->rt_rmx
.rmx_mtu
, 1);
297 kprintf("MTU for %s reduced to %d\n",
298 inet_ntop(AF_INET
, &icmpsrc
.sin_addr
,
299 src_buf
, INET_ADDRSTRLEN
), mtu
);
302 /* rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu; */
303 rt
->rt_rmx
.rmx_locks
|= RTV_MTU
;
304 } else if (rt
->rt_rmx
.rmx_mtu
> mtu
) {
305 rt
->rt_rmx
.rmx_mtu
= mtu
;
312 * XXX if the packet contains [IPv4 AH TCP], we can't make a
313 * notification to TCP layer.
315 so_pr_ctlinput_direct(&inetsw
[ip_protox
[icp
->icmp_ip
.ip_p
]],
316 PRC_MSGSIZE
, (struct sockaddr
*)&icmpsrc
, &icp
->icmp_ip
);
320 icmp_mtudisc_handler(netmsg_t nmsg
)
322 struct netmsg_ctlinput
*msg
= (struct netmsg_ctlinput
*)nmsg
;
325 ASSERT_NETISR_NCPUS(mycpuid
);
327 icmp_mtudisc(msg
->m
, msg
->hlen
);
329 nextcpu
= mycpuid
+ 1;
330 if (nextcpu
< netisr_ncpus
)
331 lwkt_forwardmsg(netisr_cpuport(nextcpu
), &msg
->base
.lmsg
);
333 icmp_ctlinput_done(msg
->m
);
337 icmp_mtudisc_start(struct mbuf
*m
, int hlen
, int proto
)
339 struct netmsg_ctlinput
*msg
;
343 icmp_mtudisc(m
, hlen
);
345 if (netisr_ncpus
== 1) {
346 /* There is only one netisr; done */
350 msg
= &m
->m_hdr
.mh_ctlmsg
;
351 netmsg_init(&msg
->base
, NULL
, &netisr_apanic_rport
, 0,
352 icmp_mtudisc_handler
);
354 msg
->cmd
= PRC_MSGSIZE
;
358 lwkt_sendmsg(netisr_cpuport(1), &msg
->base
.lmsg
);
363 icmp_ctlinput(struct mbuf
*m
, int cmd
, int hlen
)
365 struct sockaddr_in icmpsrc
= { sizeof(struct sockaddr_in
), AF_INET
};
368 KASSERT(curthread
->td_type
== TD_TYPE_NETISR
, ("not in netisr"));
370 icp
= mtodoff(m
, struct icmp
*, hlen
);
371 icmpsrc
.sin_addr
= icp
->icmp_ip
.ip_dst
;
374 * XXX if the packet contains [IPv4 AH TCP], we can't make a
375 * notification to TCP layer.
377 so_pr_ctlinput_direct(&inetsw
[ip_protox
[icp
->icmp_ip
.ip_p
]],
378 cmd
, (struct sockaddr
*)&icmpsrc
, &icp
->icmp_ip
);
382 icmp_ctlinput_handler(netmsg_t nmsg
)
384 struct netmsg_ctlinput
*msg
= (struct netmsg_ctlinput
*)nmsg
;
386 ASSERT_NETISR_NCPUS(mycpuid
);
388 icmp_ctlinput(msg
->m
, msg
->cmd
, msg
->hlen
);
389 icmp_ctlinput_done(msg
->m
);
393 icmp_ctlinput_start(struct mbuf
*m
, struct lwkt_port
*port
,
394 int cmd
, int hlen
, int proto
)
396 struct netmsg_ctlinput
*msg
;
398 KASSERT(&curthread
->td_msgport
!= port
,
399 ("send icmp ctlinput to the current netisr"));
401 msg
= &m
->m_hdr
.mh_ctlmsg
;
402 netmsg_init(&msg
->base
, NULL
, &netisr_apanic_rport
, 0,
403 icmp_ctlinput_handler
);
409 lwkt_sendmsg(port
, &msg
->base
.lmsg
);
413 icmp_ctlinput_global_handler(netmsg_t nmsg
)
415 struct netmsg_ctlinput
*msg
= (struct netmsg_ctlinput
*)nmsg
;
418 ASSERT_NETISR_NCPUS(mycpuid
);
420 icmp_ctlinput(msg
->m
, msg
->cmd
, msg
->hlen
);
422 nextcpu
= mycpuid
+ 1;
423 if (nextcpu
< netisr_ncpus
)
424 lwkt_forwardmsg(netisr_cpuport(nextcpu
), &msg
->base
.lmsg
);
426 icmp_ctlinput_done(msg
->m
);
430 icmp_ctlinput_global_start(struct mbuf
*m
, int cmd
, int hlen
, int proto
)
432 struct netmsg_ctlinput
*msg
;
435 KASSERT(netisr_ncpus
> 1, ("there is only 1 netisr cpu"));
437 icmp_ctlinput(m
, cmd
, hlen
);
439 msg
= &m
->m_hdr
.mh_ctlmsg
;
440 netmsg_init(&msg
->base
, NULL
, &netisr_apanic_rport
, 0,
441 icmp_ctlinput_global_handler
);
447 lwkt_sendmsg(netisr_cpuport(1), &msg
->base
.lmsg
);
450 #define ICMP_RTREDIRECT_FLAGS (RTF_GATEWAY | RTF_HOST)
453 icmp_redirect(struct mbuf
*m
, int hlen
, boolean_t prt
)
455 struct sockaddr_in icmpsrc
= { sizeof(struct sockaddr_in
), AF_INET
};
456 struct sockaddr_in icmpdst
= { sizeof(struct sockaddr_in
), AF_INET
};
457 struct sockaddr_in icmpgw
= { sizeof(struct sockaddr_in
), AF_INET
};
461 KASSERT(curthread
->td_type
== TD_TYPE_NETISR
, ("not in netisr"));
463 ip
= mtod(m
, struct ip
*);
464 icp
= mtodoff(m
, struct icmp
*, hlen
);
467 * Short circuit routing redirects to force immediate change
468 * in the kernel's routing tables. The message is also handed
469 * to anyone listening on a raw socket (e.g. the routing daemon
470 * for use in updating its tables).
473 if (icmpprintfs
&& prt
) {
474 char dst_buf
[INET_ADDRSTRLEN
], gw_buf
[INET_ADDRSTRLEN
];
476 kprintf("redirect dst %s to %s\n",
477 inet_ntop(AF_INET
, &icp
->icmp_ip
.ip_dst
,
478 dst_buf
, INET_ADDRSTRLEN
),
479 inet_ntop(AF_INET
, &icp
->icmp_gwaddr
,
480 gw_buf
, INET_ADDRSTRLEN
));
483 icmpgw
.sin_addr
= ip
->ip_src
;
484 icmpdst
.sin_addr
= icp
->icmp_gwaddr
;
485 icmpsrc
.sin_addr
= icp
->icmp_ip
.ip_dst
;
486 rtredirect_oncpu((struct sockaddr
*)&icmpsrc
,
487 (struct sockaddr
*)&icmpdst
, NULL
, ICMP_RTREDIRECT_FLAGS
,
488 (struct sockaddr
*)&icmpgw
);
489 kpfctlinput_direct(PRC_REDIRECT_HOST
, (struct sockaddr
*)&icmpsrc
);
493 icmp_redirect_done_handler(netmsg_t nmsg
)
495 struct netmsg_ctlinput
*msg
= (struct netmsg_ctlinput
*)nmsg
;
496 struct mbuf
*m
= msg
->m
;
497 int hlen
= msg
->hlen
;
499 rip_input(&m
, &hlen
, msg
->proto
);
503 icmp_redirect_done(struct mbuf
*m
, int hlen
, boolean_t dispatch_rip
)
505 struct rt_addrinfo rtinfo
;
506 struct sockaddr_in icmpsrc
= { sizeof(struct sockaddr_in
), AF_INET
};
507 struct sockaddr_in icmpdst
= { sizeof(struct sockaddr_in
), AF_INET
};
508 struct sockaddr_in icmpgw
= { sizeof(struct sockaddr_in
), AF_INET
};
512 ip
= mtod(m
, struct ip
*);
513 icp
= mtodoff(m
, struct icmp
*, hlen
);
515 icmpgw
.sin_addr
= ip
->ip_src
;
516 icmpdst
.sin_addr
= icp
->icmp_gwaddr
;
517 icmpsrc
.sin_addr
= icp
->icmp_ip
.ip_dst
;
519 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
520 rtinfo
.rti_info
[RTAX_DST
] = (struct sockaddr
*)&icmpsrc
;
521 rtinfo
.rti_info
[RTAX_GATEWAY
] = (struct sockaddr
*)&icmpdst
;
522 rtinfo
.rti_info
[RTAX_NETMASK
] = NULL
;
523 rtinfo
.rti_info
[RTAX_AUTHOR
] = (struct sockaddr
*)&icmpgw
;
524 rt_missmsg(RTM_REDIRECT
, &rtinfo
, ICMP_RTREDIRECT_FLAGS
, 0);
527 struct netmsg_ctlinput
*msg
= &m
->m_hdr
.mh_ctlmsg
;
529 netmsg_init(&msg
->base
, NULL
, &netisr_apanic_rport
, 0,
530 icmp_redirect_done_handler
);
531 lwkt_sendmsg(netisr_cpuport(0), &msg
->base
.lmsg
);
536 icmp_redirect_handler(netmsg_t nmsg
)
538 struct netmsg_ctlinput
*msg
= (struct netmsg_ctlinput
*)nmsg
;
541 ASSERT_NETISR_NCPUS(mycpuid
);
543 icmp_redirect(msg
->m
, msg
->hlen
, FALSE
);
545 nextcpu
= mycpuid
+ 1;
546 if (nextcpu
< netisr_ncpus
)
547 lwkt_forwardmsg(netisr_cpuport(nextcpu
), &msg
->base
.lmsg
);
549 icmp_redirect_done(msg
->m
, msg
->hlen
, TRUE
);
553 icmp_redirect_start(struct mbuf
*m
, int hlen
, int proto
)
555 struct netmsg_ctlinput
*msg
;
559 icmp_redirect(m
, hlen
, TRUE
);
561 if (netisr_ncpus
== 1) {
562 /* There is only one netisr; done */
563 icmp_redirect_done(m
, hlen
, FALSE
);
567 msg
= &m
->m_hdr
.mh_ctlmsg
;
568 netmsg_init(&msg
->base
, NULL
, &netisr_apanic_rport
, 0,
569 icmp_redirect_handler
);
571 msg
->cmd
= PRC_REDIRECT_HOST
;
575 lwkt_sendmsg(netisr_cpuport(1), &msg
->base
.lmsg
);
580 * Process a received ICMP message.
583 icmp_input(struct mbuf
**mp
, int *offp
, int proto
)
585 struct sockaddr_in icmpsrc
= { sizeof(struct sockaddr_in
), AF_INET
};
586 struct sockaddr_in icmpdst
= { sizeof(struct sockaddr_in
), AF_INET
};
588 struct in_ifaddr
*ia
;
589 struct mbuf
*m
= *mp
;
590 struct ip
*ip
= mtod(m
, struct ip
*);
591 int icmplen
= ip
->ip_len
;
601 * Locate icmp structure in mbuf, and check
602 * that not corrupted and of at least minimum length.
606 char src_buf
[INET_ADDRSTRLEN
], dst_buf
[INET_ADDRSTRLEN
];
608 kprintf("icmp_input from %s to %s, len %d\n",
609 inet_ntop(AF_INET
, &ip
->ip_src
, src_buf
, INET_ADDRSTRLEN
),
610 inet_ntop(AF_INET
, &ip
->ip_dst
, dst_buf
, INET_ADDRSTRLEN
),
614 if (icmplen
< ICMP_MINLEN
) {
615 icmpstat
.icps_tooshort
++;
618 i
= hlen
+ min(icmplen
, ICMP_ADVLENMIN
);
619 if (m
->m_len
< i
&& (m
= m_pullup(m
, i
)) == NULL
) {
620 icmpstat
.icps_tooshort
++;
621 return(IPPROTO_DONE
);
623 ip
= mtod(m
, struct ip
*);
625 if (in_cksum_skip(m
, hlen
+ icmplen
, hlen
)) {
626 icmpstat
.icps_checksum
++;
629 icp
= (struct icmp
*)((caddr_t
)ip
+ hlen
);
633 kprintf("icmp_input, type %d code %d\n", icp
->icmp_type
,
638 * Message type specific processing.
640 if (icp
->icmp_type
> ICMP_MAXTYPE
)
642 icmpstat
.icps_inhist
[icp
->icmp_type
]++;
643 code
= icp
->icmp_code
;
644 switch (icp
->icmp_type
) {
648 case ICMP_UNREACH_NET
:
649 case ICMP_UNREACH_HOST
:
650 case ICMP_UNREACH_SRCFAIL
:
651 case ICMP_UNREACH_NET_UNKNOWN
:
652 case ICMP_UNREACH_HOST_UNKNOWN
:
653 case ICMP_UNREACH_ISOLATED
:
654 case ICMP_UNREACH_TOSNET
:
655 case ICMP_UNREACH_TOSHOST
:
656 case ICMP_UNREACH_HOST_PRECEDENCE
:
657 case ICMP_UNREACH_PRECEDENCE_CUTOFF
:
658 code
= PRC_UNREACH_NET
;
661 case ICMP_UNREACH_NEEDFRAG
:
666 * RFC 1122, Sections 3.2.2.1 and 4.2.3.9.
667 * Treat subcodes 2,3 as immediate RST
669 case ICMP_UNREACH_PROTOCOL
:
670 case ICMP_UNREACH_PORT
:
671 code
= PRC_UNREACH_PORT
;
674 case ICMP_UNREACH_NET_PROHIB
:
675 case ICMP_UNREACH_HOST_PROHIB
:
676 case ICMP_UNREACH_FILTER_PROHIB
:
677 code
= PRC_UNREACH_ADMIN_PROHIB
;
688 code
+= PRC_TIMXCEED_INTRANS
;
694 code
= PRC_PARAMPROB
;
697 case ICMP_SOURCEQUENCH
:
700 if (discard_sourcequench
)
705 * Problem with datagram; advise higher level routines.
707 if (icmplen
< ICMP_ADVLENMIN
|| icmplen
< ICMP_ADVLEN(icp
) ||
708 IP_VHL_HL(icp
->icmp_ip
.ip_vhl
) < (sizeof(struct ip
) >> 2)) {
709 icmpstat
.icps_badlen
++;
712 /* Discard ICMP's in response to multicast packets */
713 if (IN_MULTICAST(ntohl(icp
->icmp_ip
.ip_dst
.s_addr
)))
717 kprintf("deliver to protocol %d\n", icp
->icmp_ip
.ip_p
);
719 icmpsrc
.sin_addr
= icp
->icmp_ip
.ip_dst
;
724 if (code
== PRC_MSGSIZE
) {
725 /* Run MTU discovery in all netisrs */
726 if (icmp_mtudisc_start(m
, hlen
, proto
)) {
727 /* Forwarded; done */
730 /* Move on; run rip_input() directly */
733 struct lwkt_port
*port
;
736 pr
= &inetsw
[ip_protox
[icp
->icmp_ip
.ip_p
]];
737 port
= so_pr_ctlport(pr
, code
,
738 (struct sockaddr
*)&icmpsrc
, &icp
->icmp_ip
, &cpu
);
740 if (cpu
== netisr_ncpus
) {
741 if (netisr_ncpus
> 1) {
743 * Run pr_ctlinput in all
746 icmp_ctlinput_global_start(m
,
751 * There is only one netisr; run
752 * pr_ctlinput directly.
754 } else if (cpu
!= mycpuid
) {
756 * Send to the target netisr to run
759 icmp_ctlinput_start(m
, port
,
765 * The target netisr is this netisr.
767 * XXX if the packet contains [IPv4 AH TCP],
768 * we can't make a notification to TCP layer.
770 so_pr_ctlinput_direct(pr
, code
,
771 (struct sockaddr
*)&icmpsrc
, &icp
->icmp_ip
);
773 /* Move on; run rip_input() directly */
777 icmpstat
.icps_badcode
++;
782 && (m
->m_flags
& (M_MCAST
| M_BCAST
)) != 0) {
783 icmpstat
.icps_bmcastecho
++;
786 icp
->icmp_type
= ICMP_ECHOREPLY
;
788 if (badport_bandlim(BANDLIM_ICMP_ECHO
) < 0)
796 && (m
->m_flags
& (M_MCAST
| M_BCAST
)) != 0) {
797 icmpstat
.icps_bmcasttstamp
++;
800 if (icmplen
< ICMP_TSLEN
) {
801 icmpstat
.icps_badlen
++;
804 icp
->icmp_type
= ICMP_TSTAMPREPLY
;
805 icp
->icmp_rtime
= iptime();
806 icp
->icmp_ttime
= icp
->icmp_rtime
; /* bogus, do later! */
808 if (badport_bandlim(BANDLIM_ICMP_TSTAMP
) < 0)
815 if (icmpmaskrepl
== 0)
818 * We are not able to respond with all ones broadcast
819 * unless we receive it over a point-to-point interface.
821 if (icmplen
< ICMP_MASKLEN
)
823 switch (ip
->ip_dst
.s_addr
) {
825 case INADDR_BROADCAST
:
827 icmpdst
.sin_addr
= ip
->ip_src
;
831 icmpdst
.sin_addr
= ip
->ip_dst
;
833 ia
= (struct in_ifaddr
*)ifaof_ifpforaddr(
834 (struct sockaddr
*)&icmpdst
, m
->m_pkthdr
.rcvif
);
839 icp
->icmp_type
= ICMP_MASKREPLY
;
840 icp
->icmp_mask
= ia
->ia_sockmask
.sin_addr
.s_addr
;
841 if (ip
->ip_src
.s_addr
== 0) {
842 if (ia
->ia_ifp
->if_flags
& IFF_BROADCAST
)
843 ip
->ip_src
= satosin(&ia
->ia_broadaddr
)->sin_addr
;
844 else if (ia
->ia_ifp
->if_flags
& IFF_POINTOPOINT
)
845 ip
->ip_src
= satosin(&ia
->ia_dstaddr
)->sin_addr
;
848 ip
->ip_len
+= hlen
; /* since ip_input deducts this */
849 icmpstat
.icps_reflect
++;
850 icmpstat
.icps_outhist
[icp
->icmp_type
]++;
852 return(IPPROTO_DONE
);
856 char src_buf
[INET_ADDRSTRLEN
];
857 char dst_buf
[INET_ADDRSTRLEN
];
858 char gwy_buf
[INET_ADDRSTRLEN
];
860 kprintf("icmp redirect from %s: %s => %s\n",
861 inet_ntop(AF_INET
, &ip
->ip_src
,
862 src_buf
, INET_ADDRSTRLEN
),
863 inet_ntop(AF_INET
, &icp
->icmp_ip
.ip_dst
,
864 dst_buf
, INET_ADDRSTRLEN
),
865 inet_ntop(AF_INET
, &icp
->icmp_gwaddr
,
866 gwy_buf
, INET_ADDRSTRLEN
));
872 if (icmplen
< ICMP_ADVLENMIN
|| icmplen
< ICMP_ADVLEN(icp
) ||
873 IP_VHL_HL(icp
->icmp_ip
.ip_vhl
) < (sizeof(struct ip
) >> 2)) {
874 icmpstat
.icps_badlen
++;
879 char dst_buf
[INET_ADDRSTRLEN
], gw_buf
[INET_ADDRSTRLEN
];
881 kprintf("redirect dst %s to %s\n",
882 inet_ntop(AF_INET
, &icp
->icmp_ip
.ip_dst
,
883 dst_buf
, INET_ADDRSTRLEN
),
884 inet_ntop(AF_INET
, &icp
->icmp_gwaddr
,
885 gw_buf
, INET_ADDRSTRLEN
));
888 icmpsrc
.sin_addr
= icp
->icmp_ip
.ip_dst
;
890 /* Run redirect in all netisrs */
891 if (icmp_redirect_start(m
, hlen
, proto
)) {
892 /* Forwarded; done */
895 /* Move on; run rip_input() directly */
899 * No kernel processing for the following;
900 * just fall through to send to raw listener.
903 case ICMP_ROUTERADVERT
:
904 case ICMP_ROUTERSOLICIT
:
905 case ICMP_TSTAMPREPLY
:
914 rip_input(mp
, offp
, proto
);
915 return(IPPROTO_DONE
);
919 return(IPPROTO_DONE
);
923 * Reflect the ip packet back to the source
926 icmp_reflect(struct mbuf
*m
)
928 struct ip
*ip
= mtod(m
, struct ip
*);
929 struct in_ifaddr
*ia
;
930 struct in_ifaddr_container
*iac
;
931 struct ifaddr_container
*ifac
;
934 struct mbuf
*opts
= NULL
;
935 int optlen
= (IP_VHL_HL(ip
->ip_vhl
) << 2) - sizeof(struct ip
);
936 struct route
*ro
= NULL
, rt
;
938 if (!in_canforward(ip
->ip_src
) &&
939 ((ntohl(ip
->ip_src
.s_addr
) & IN_CLASSA_NET
) !=
940 (IN_LOOPBACKNET
<< IN_CLASSA_NSHIFT
))) {
941 m_freem(m
); /* Bad return address */
942 icmpstat
.icps_badaddr
++;
943 goto done
; /* Ip_output() will check for broadcast */
946 ip
->ip_dst
= ip
->ip_src
;
949 bzero(ro
, sizeof *ro
);
952 * If the incoming packet was addressed directly to us,
953 * use dst as the src for the reply. Otherwise (broadcast
954 * or anonymous), use the address which corresponds
955 * to the incoming interface.
958 LIST_FOREACH(iac
, INADDR_HASH(t
.s_addr
), ia_hash
) {
959 if (t
.s_addr
== IA_SIN(iac
->ia
)->sin_addr
.s_addr
) {
964 ifp
= m
->m_pkthdr
.rcvif
;
965 if (ifp
!= NULL
&& (ifp
->if_flags
& IFF_BROADCAST
)) {
966 TAILQ_FOREACH(ifac
, &ifp
->if_addrheads
[mycpuid
], ifa_link
) {
967 struct ifaddr
*ifa
= ifac
->ifa
;
969 if (ifa
->ifa_addr
->sa_family
!= AF_INET
)
972 if (satosin(&ia
->ia_broadaddr
)->sin_addr
.s_addr
==
978 * If the packet was transiting through us, use the address of
979 * the interface the packet came through in. If that interface
980 * doesn't have a suitable IP address, the normal selection
983 if (icmp_rfi
&& ifp
!= NULL
) {
984 TAILQ_FOREACH(ifac
, &ifp
->if_addrheads
[mycpuid
], ifa_link
) {
985 struct ifaddr
*ifa
= ifac
->ifa
;
987 if (ifa
->ifa_addr
->sa_family
!= AF_INET
)
994 * If the incoming packet was not addressed directly to us, use
995 * designated interface for icmp replies specified by sysctl
996 * net.inet.icmp.reply_src (default not set). Otherwise continue
997 * with normal source selection.
999 if (icmp_reply_src
[0] != '\0' &&
1000 (ifp
= ifunit_netisr(icmp_reply_src
))) {
1001 TAILQ_FOREACH(ifac
, &ifp
->if_addrheads
[mycpuid
], ifa_link
) {
1002 struct ifaddr
*ifa
= ifac
->ifa
;
1004 if (ifa
->ifa_addr
->sa_family
!= AF_INET
)
1011 * If the packet was transiting through us, use the address of
1012 * the interface that is the closest to the packet source.
1013 * When we don't have a route back to the packet source, stop here
1014 * and drop the packet.
1016 ia
= ip_rtaddr(ip
->ip_dst
, ro
);
1019 icmpstat
.icps_noroute
++;
1023 t
= IA_SIN(ia
)->sin_addr
;
1025 ip
->ip_ttl
= ip_defttl
;
1033 * Retrieve any source routing from the incoming packet;
1034 * add on any record-route or timestamp options.
1036 cp
= (u_char
*) (ip
+ 1);
1037 if ((opts
= ip_srcroute(m
)) == NULL
&&
1038 (opts
= m_gethdr(M_NOWAIT
, MT_HEADER
))) {
1039 opts
->m_len
= sizeof(struct in_addr
);
1040 mtod(opts
, struct in_addr
*)->s_addr
= 0;
1045 kprintf("icmp_reflect optlen %d rt %d => ",
1046 optlen
, opts
->m_len
);
1048 for (cnt
= optlen
; cnt
> 0; cnt
-= len
, cp
+= len
) {
1049 opt
= cp
[IPOPT_OPTVAL
];
1050 if (opt
== IPOPT_EOL
)
1052 if (opt
== IPOPT_NOP
)
1055 if (cnt
< IPOPT_OLEN
+ sizeof *cp
)
1057 len
= cp
[IPOPT_OLEN
];
1058 if (len
< IPOPT_OLEN
+ sizeof *cp
||
1063 * Should check for overflow, but it
1066 if (opt
== IPOPT_RR
|| opt
== IPOPT_TS
||
1067 opt
== IPOPT_SECURITY
) {
1069 mtod(opts
, caddr_t
) + opts
->m_len
,
1074 /* Terminate & pad, if necessary */
1075 cnt
= opts
->m_len
% 4;
1077 for (; cnt
< 4; cnt
++) {
1078 *(mtod(opts
, caddr_t
) + opts
->m_len
) =
1085 kprintf("%d\n", opts
->m_len
);
1089 * Now strip out original options by copying rest of first
1090 * mbuf's data back, and adjust the IP length.
1092 ip
->ip_len
-= optlen
;
1093 ip
->ip_vhl
= IP_VHL_BORING
;
1095 if (m
->m_flags
& M_PKTHDR
)
1096 m
->m_pkthdr
.len
-= optlen
;
1097 optlen
+= sizeof(struct ip
);
1098 bcopy((caddr_t
)ip
+ optlen
, ip
+ 1,
1099 m
->m_len
- sizeof(struct ip
));
1101 m
->m_pkthdr
.fw_flags
&= FW_MBUF_GENERATED
;
1102 m
->m_flags
&= ~(M_BCAST
|M_MCAST
);
1103 icmp_send(m
, opts
, ro
);
1107 if (ro
&& ro
->ro_rt
)
1112 * Send an icmp packet back to the ip level,
1113 * after supplying a checksum.
1116 icmp_send(struct mbuf
*m
, struct mbuf
*opts
, struct route
*rt
)
1118 struct ip
*ip
= mtod(m
, struct ip
*);
1122 hlen
= IP_VHL_HL(ip
->ip_vhl
) << 2;
1125 icp
= mtod(m
, struct icmp
*);
1126 icp
->icmp_cksum
= 0;
1127 icp
->icmp_cksum
= in_cksum(m
, ip
->ip_len
- hlen
);
1130 m
->m_pkthdr
.rcvif
= NULL
;
1133 char dst_buf
[INET_ADDRSTRLEN
], src_buf
[INET_ADDRSTRLEN
];
1135 kprintf("icmp_send dst %s src %s\n",
1136 inet_ntop(AF_INET
, &ip
->ip_dst
, dst_buf
, INET_ADDRSTRLEN
),
1137 inet_ntop(AF_INET
, &ip
->ip_src
, src_buf
, INET_ADDRSTRLEN
));
1140 ip_output(m
, opts
, rt
, 0, NULL
, NULL
);
1150 t
= (atv
.tv_sec
% (24*60*60)) * 1000 + atv
.tv_usec
/ 1000;
1156 * Return the next larger or smaller MTU plateau (table from RFC 1191)
1157 * given current value MTU. If DIR is less than zero, a larger plateau
1158 * is returned; otherwise, a smaller value is returned.
1161 ip_next_mtu(int mtu
, int dir
)
1163 static int mtutab
[] = {
1164 65535, 32000, 17914, 8166, 4352, 2002, 1492, 1006, 508, 296,
1169 for (i
= 0; i
< (sizeof mtutab
) / (sizeof mtutab
[0]); i
++) {
1170 if (mtu
>= mtutab
[i
])
1178 return mtutab
[i
- 1];
1181 if (mtutab
[i
] == 0) {
1183 } else if(mtu
> mtutab
[i
]) {
1186 return mtutab
[i
+ 1];
1194 * badport_bandlim() - check for ICMP bandwidth limit
1196 * Return 0 if it is ok to send an ICMP error response, -1 if we have
1197 * hit our bandwidth limit and it is not ok.
1199 * If icmplim is <= 0, the feature is disabled and 0 is returned.
1201 * For now we separate the TCP and UDP subsystems w/ different 'which'
1202 * values. We may eventually remove this separation (and simplify the
1205 * Note that the printing of the error message is delayed so we can
1206 * properly print the icmp error rate that the system was trying to do
1207 * (i.e. 22000/100 pps, etc...). This can cause long delays in printing
1208 * the 'final' error, but it doesn't make sense to solve the printing
1209 * delay with more complex code.
1212 badport_bandlim(int which
)
1214 static int lticks
[BANDLIM_MAX
+ 1];
1215 static int lpackets
[BANDLIM_MAX
+ 1];
1217 const char *bandlimittype
[] = {
1218 "Limiting icmp unreach response",
1219 "Limiting icmp ping response",
1220 "Limiting icmp tstamp response",
1221 "Limiting closed port RST response",
1222 "Limiting open port RST response"
1226 * Return ok status if feature disabled or argument out of
1230 if (icmplim
<= 0 || which
> BANDLIM_MAX
|| which
< 0)
1232 dticks
= ticks
- lticks
[which
];
1235 * reset stats when cumulative dt exceeds one second.
1238 if ((unsigned int)dticks
> hz
) {
1239 if (lpackets
[which
] > icmplim
&& icmplim_output
) {
1240 kprintf("%s from %d to %d packets per second\n",
1241 bandlimittype
[which
],
1246 lticks
[which
] = ticks
;
1247 lpackets
[which
] = 0;
1254 if (++lpackets
[which
] > icmplim
) {