![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ip_icmp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / netinet|
Return to ip_icmp.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / netinet |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)ip_icmp.c 7.2 (Berkeley) 1/10/87
7: */
8:
9: #include "param.h"
10: #include "systm.h"
11: #include "mbuf.h"
12: #include "protosw.h"
13: #include "socket.h"
14: #include "time.h"
15: #include "kernel.h"
16:
17: #include "../net/route.h"
18: #include "../net/if.h"
19:
20: #include "in.h"
21: #include "in_systm.h"
22: #include "in_var.h"
23: #include "ip.h"
24: #include "ip_icmp.h"
25: #include "icmp_var.h"
26:
27: #ifdef ICMPPRINTFS
28: /*
29: * ICMP routines: error generation, receive packet processing, and
30: * routines to turnaround packets back to the originator, and
31: * host table maintenance routines.
32: */
33: int icmpprintfs = 0;
34: #endif
35:
36: /*
37: * Generate an error packet of type error
38: * in response to bad packet ip.
39: */
40: /*VARARGS4*/
41: icmp_error(oip, type, code, ifp, dest)
42: struct ip *oip;
43: int type, code;
44: struct ifnet *ifp;
45: struct in_addr dest;
46: {
47: register unsigned oiplen = oip->ip_hl << 2;
48: register struct icmp *icp;
49: struct mbuf *m;
50: struct ip *nip;
51: unsigned icmplen;
52:
53: #ifdef ICMPPRINTFS
54: if (icmpprintfs)
55: printf("icmp_error(%x, %d, %d)\n", oip, type, code);
56: #endif
57: if (type != ICMP_REDIRECT)
58: icmpstat.icps_error++;
59: /*
60: * Don't send error if not the first fragment of message.
61: * Don't EVER error if the old packet protocol was ICMP.
62: * (Could do ECHO, etc, but not error indications.)
63: */
64: if (oip->ip_off &~ (IP_MF|IP_DF))
65: goto free;
66: if (oip->ip_p == IPPROTO_ICMP && type != ICMP_REDIRECT) {
67: icmpstat.icps_oldicmp++;
68: goto free;
69: }
70:
71: /*
72: * First, formulate icmp message
73: */
74: m = m_get(M_DONTWAIT, MT_HEADER);
75: if (m == NULL)
76: goto free;
77: icmplen = oiplen + MIN(8, oip->ip_len);
78: m->m_len = icmplen + ICMP_MINLEN;
79: m->m_off = MMAXOFF - m->m_len;
80: icp = mtod(m, struct icmp *);
81: if ((u_int)type > ICMP_MAXTYPE)
82: panic("icmp_error");
83: icmpstat.icps_outhist[type]++;
84: icp->icmp_type = type;
85: if (type == ICMP_REDIRECT)
86: icp->icmp_gwaddr = dest;
87: else
88: icp->icmp_void = 0;
89: if (type == ICMP_PARAMPROB) {
90: icp->icmp_pptr = code;
91: code = 0;
92: }
93: icp->icmp_code = code;
94: bcopy((caddr_t)oip, (caddr_t)&icp->icmp_ip, icmplen);
95: nip = &icp->icmp_ip;
96: nip->ip_len += oiplen;
97: nip->ip_len = htons((u_short)nip->ip_len);
98:
99: /*
100: * Now, copy old ip header in front of icmp message.
101: */
102: if (m->m_len + oiplen > MLEN)
103: oiplen = sizeof(struct ip);
104: if (m->m_len + oiplen > MLEN)
105: panic("icmp len");
106: m->m_off -= oiplen;
107: m->m_len += oiplen;
108: nip = mtod(m, struct ip *);
109: bcopy((caddr_t)oip, (caddr_t)nip, oiplen);
110: nip->ip_len = m->m_len;
111: nip->ip_p = IPPROTO_ICMP;
112: icmp_reflect(nip, ifp);
113:
114: free:
115: m_freem(dtom(oip));
116: }
117:
118: static struct sockproto icmproto = { AF_INET, IPPROTO_ICMP };
119: static struct sockaddr_in icmpsrc = { AF_INET };
120: static struct sockaddr_in icmpdst = { AF_INET };
121: static struct sockaddr_in icmpgw = { AF_INET };
122: struct in_ifaddr *ifptoia();
123:
124: /*
125: * Process a received ICMP message.
126: */
127: icmp_input(m, ifp)
128: register struct mbuf *m;
129: struct ifnet *ifp;
130: {
131: register struct icmp *icp;
132: register struct ip *ip = mtod(m, struct ip *);
133: int icmplen = ip->ip_len, hlen = ip->ip_hl << 2;
134: register int i;
135: struct in_ifaddr *ia;
136: int (*ctlfunc)(), code;
137: extern u_char ip_protox[];
138: extern struct in_addr in_makeaddr();
139:
140: /*
141: * Locate icmp structure in mbuf, and check
142: * that not corrupted and of at least minimum length.
143: */
144: #ifdef ICMPPRINTFS
145: if (icmpprintfs)
146: printf("icmp_input from %x, len %d\n", ip->ip_src, icmplen);
147: #endif
148: if (icmplen < ICMP_MINLEN) {
149: icmpstat.icps_tooshort++;
150: goto free;
151: }
152: i = hlen + MIN(icmplen, ICMP_ADVLENMIN);
153: if ((m->m_off > MMAXOFF || m->m_len < i) &&
154: (m = m_pullup(m, i)) == 0) {
155: icmpstat.icps_tooshort++;
156: return;
157: }
158: ip = mtod(m, struct ip *);
159: m->m_len -= hlen;
160: m->m_off += hlen;
161: icp = mtod(m, struct icmp *);
162: if (in_cksum(m, icmplen)) {
163: icmpstat.icps_checksum++;
164: goto free;
165: }
166: m->m_len += hlen;
167: m->m_off -= hlen;
168:
169: #ifdef ICMPPRINTFS
170: /*
171: * Message type specific processing.
172: */
173: if (icmpprintfs)
174: printf("icmp_input, type %d code %d\n", icp->icmp_type,
175: icp->icmp_code);
176: #endif
177: if (icp->icmp_type > ICMP_MAXTYPE)
178: goto raw;
179: icmpstat.icps_inhist[icp->icmp_type]++;
180: code = icp->icmp_code;
181: switch (icp->icmp_type) {
182:
183: case ICMP_UNREACH:
184: if (code > 5)
185: goto badcode;
186: code += PRC_UNREACH_NET;
187: goto deliver;
188:
189: case ICMP_TIMXCEED:
190: if (code > 1)
191: goto badcode;
192: code += PRC_TIMXCEED_INTRANS;
193: goto deliver;
194:
195: case ICMP_PARAMPROB:
196: if (code)
197: goto badcode;
198: code = PRC_PARAMPROB;
199: goto deliver;
200:
201: case ICMP_SOURCEQUENCH:
202: if (code)
203: goto badcode;
204: code = PRC_QUENCH;
205: deliver:
206: /*
207: * Problem with datagram; advise higher level routines.
208: */
209: icp->icmp_ip.ip_len = ntohs((u_short)icp->icmp_ip.ip_len);
210: if (icmplen < ICMP_ADVLENMIN || icmplen < ICMP_ADVLEN(icp)) {
211: icmpstat.icps_badlen++;
212: goto free;
213: }
214: #ifdef ICMPPRINTFS
215: if (icmpprintfs)
216: printf("deliver to protocol %d\n", icp->icmp_ip.ip_p);
217: #endif
218: icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
219: if (ctlfunc = inetsw[ip_protox[icp->icmp_ip.ip_p]].pr_ctlinput)
220: (*ctlfunc)(code, (struct sockaddr *)&icmpsrc);
221: break;
222:
223: badcode:
224: icmpstat.icps_badcode++;
225: break;
226:
227: case ICMP_ECHO:
228: icp->icmp_type = ICMP_ECHOREPLY;
229: goto reflect;
230:
231: case ICMP_TSTAMP:
232: if (icmplen < ICMP_TSLEN) {
233: icmpstat.icps_badlen++;
234: break;
235: }
236: icp->icmp_type = ICMP_TSTAMPREPLY;
237: icp->icmp_rtime = iptime();
238: icp->icmp_ttime = icp->icmp_rtime; /* bogus, do later! */
239: goto reflect;
240:
241: case ICMP_IREQ:
242: #define satosin(sa) ((struct sockaddr_in *)(sa))
243: if (in_netof(ip->ip_src) == 0 && (ia = ifptoia(ifp)))
244: ip->ip_src = in_makeaddr(in_netof(IA_SIN(ia)->sin_addr),
245: in_lnaof(ip->ip_src));
246: icp->icmp_type = ICMP_IREQREPLY;
247: goto reflect;
248:
249: case ICMP_MASKREQ:
250: if (icmplen < ICMP_MASKLEN || (ia = ifptoia(ifp)) == 0)
251: break;
252: icp->icmp_type = ICMP_MASKREPLY;
253: icp->icmp_mask = ia->ia_netmask;
254: if (ip->ip_src.s_addr == 0) {
255: if (ia->ia_ifp->if_flags & IFF_BROADCAST)
256: ip->ip_src = satosin(&ia->ia_broadaddr)->sin_addr;
257: else if (ia->ia_ifp->if_flags & IFF_POINTOPOINT)
258: ip->ip_src = satosin(&ia->ia_dstaddr)->sin_addr;
259: }
260: reflect:
261: ip->ip_len += hlen; /* since ip_input deducts this */
262: icmpstat.icps_reflect++;
263: icmpstat.icps_outhist[icp->icmp_type]++;
264: icmp_reflect(ip, ifp);
265: return;
266:
267: case ICMP_REDIRECT:
268: if (icmplen < ICMP_ADVLENMIN || icmplen < ICMP_ADVLEN(icp)) {
269: icmpstat.icps_badlen++;
270: break;
271: }
272: /*
273: * Short circuit routing redirects to force
274: * immediate change in the kernel's routing
275: * tables. The message is also handed to anyone
276: * listening on a raw socket (e.g. the routing
277: * daemon for use in updating its tables).
278: */
279: icmpgw.sin_addr = ip->ip_src;
280: icmpdst.sin_addr = icp->icmp_gwaddr;
281: #ifdef ICMPPRINTFS
282: if (icmpprintfs)
283: printf("redirect dst %x to %x\n", icp->icmp_ip.ip_dst,
284: icp->icmp_gwaddr);
285: #endif
286: if (code == ICMP_REDIRECT_NET || code == ICMP_REDIRECT_TOSNET) {
287: icmpsrc.sin_addr =
288: in_makeaddr(in_netof(icp->icmp_ip.ip_dst), INADDR_ANY);
289: rtredirect((struct sockaddr *)&icmpsrc,
290: (struct sockaddr *)&icmpdst, RTF_GATEWAY,
291: (struct sockaddr *)&icmpgw);
292: icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
293: pfctlinput(PRC_REDIRECT_NET,
294: (struct sockaddr *)&icmpsrc);
295: } else {
296: icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
297: rtredirect((struct sockaddr *)&icmpsrc,
298: (struct sockaddr *)&icmpdst, RTF_GATEWAY | RTF_HOST,
299: (struct sockaddr *)&icmpgw);
300: pfctlinput(PRC_REDIRECT_HOST,
301: (struct sockaddr *)&icmpsrc);
302: }
303: break;
304:
305: /*
306: * No kernel processing for the following;
307: * just fall through to send to raw listener.
308: */
309: case ICMP_ECHOREPLY:
310: case ICMP_TSTAMPREPLY:
311: case ICMP_IREQREPLY:
312: case ICMP_MASKREPLY:
313: default:
314: break;
315: }
316:
317: raw:
318: icmpsrc.sin_addr = ip->ip_src;
319: icmpdst.sin_addr = ip->ip_dst;
320: raw_input(m, &icmproto, (struct sockaddr *)&icmpsrc,
321: (struct sockaddr *)&icmpdst);
322: return;
323:
324: free:
325: m_freem(m);
326: }
327:
328: /*
329: * Reflect the ip packet back to the source
330: */
331: icmp_reflect(ip, ifp)
332: register struct ip *ip;
333: struct ifnet *ifp;
334: {
335: register struct in_ifaddr *ia;
336: struct in_addr t;
337: struct mbuf *opts = 0, *ip_srcroute();
338: int optlen = (ip->ip_hl << 2) - sizeof(struct ip);
339:
340: t = ip->ip_dst;
341: ip->ip_dst = ip->ip_src;
342: /*
343: * If the incoming packet was addressed directly to us,
344: * use dst as the src for the reply. Otherwise (broadcast
345: * or anonymous), use the address which corresponds
346: * to the incoming interface.
347: */
348: for (ia = in_ifaddr; ia; ia = ia->ia_next) {
349: if (t.s_addr == IA_SIN(ia)->sin_addr.s_addr)
350: break;
351: if ((ia->ia_ifp->if_flags & IFF_BROADCAST) &&
352: t.s_addr == satosin(&ia->ia_broadaddr)->sin_addr.s_addr)
353: break;
354: }
355: if (ia == (struct in_ifaddr *)0)
356: ia = ifptoia(ifp);
357: if (ia == (struct in_ifaddr *)0)
358: ia = in_ifaddr;
359: t = IA_SIN(ia)->sin_addr;
360: ip->ip_src = t;
361:
362: if (optlen > 0) {
363: /*
364: * Retrieve any source routing from the incoming packet
365: * and strip out other options. Adjust the IP length.
366: */
367: opts = ip_srcroute();
368: ip->ip_len -= optlen;
369: ip_stripoptions(ip, (struct mbuf *)0);
370: }
371: icmp_send(ip, opts);
372: if (opts)
373: (void)m_free(opts);
374: }
375:
376: struct in_ifaddr *
377: ifptoia(ifp)
378: struct ifnet *ifp;
379: {
380: register struct in_ifaddr *ia;
381:
382: for (ia = in_ifaddr; ia; ia = ia->ia_next)
383: if (ia->ia_ifp == ifp)
384: return (ia);
385: return ((struct in_ifaddr *)0);
386: }
387:
388: /*
389: * Send an icmp packet back to the ip level,
390: * after supplying a checksum.
391: */
392: icmp_send(ip, opts)
393: register struct ip *ip;
394: struct mbuf *opts;
395: {
396: register int hlen;
397: register struct icmp *icp;
398: register struct mbuf *m;
399:
400: m = dtom(ip);
401: hlen = ip->ip_hl << 2;
402: m->m_off += hlen;
403: m->m_len -= hlen;
404: icp = mtod(m, struct icmp *);
405: icp->icmp_cksum = 0;
406: icp->icmp_cksum = in_cksum(m, ip->ip_len - hlen);
407: m->m_off -= hlen;
408: m->m_len += hlen;
409: #ifdef ICMPPRINTFS
410: if (icmpprintfs)
411: printf("icmp_send dst %x src %x\n", ip->ip_dst, ip->ip_src);
412: #endif
413: (void) ip_output(m, opts, (struct route *)0, 0);
414: }
415:
416: n_time
417: iptime()
418: {
419: struct timeval atv;
420: u_long t;
421:
422: microtime(&atv);
423: t = (atv.tv_sec % (24*60*60)) * 1000 + atv.tv_usec / 1000;
424: return (htonl(t));
425: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.