VirtualBox

source: vbox/trunk/src/VBox/Devices/Network/slirp/ip_icmp.c@ 15479

最後變更 在這個檔案從15479是 15479,由 vboxsync 提交於 16 年 前

slirp: warnings
  • 屬性 svn:eol-style 設為 native
檔案大小: 22.9 KB
行 
1/*
2 * Copyright (c) 1982, 1986, 1988, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
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. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 *
33 * @(#)ip_icmp.c 8.2 (Berkeley) 1/4/94
34 * ip_icmp.c,v 1.7 1995/05/30 08:09:42 rgrimes Exp
35 */
36
37#include "slirp.h"
38#include "ip_icmp.h"
39#ifdef RT_OS_WINDOWS
40#include <Icmpapi.h>
41#include <Iphlpapi.h>
42#endif
43
44
45/* The message sent when emulating PING */
46/* Be nice and tell them it's just a psuedo-ping packet */
47static const char icmp_ping_msg[] = "This is a psuedo-PING packet used by Slirp to emulate ICMP ECHO-REQUEST packets.\n";
48
49/* list of actions for icmp_error() on RX of an icmp message */
50static const int icmp_flush[19] =
51{
52/* ECHO REPLY (0) */ 0,
53 1,
54 1,
55/* DEST UNREACH (3) */ 1,
56/* SOURCE QUENCH (4)*/ 1,
57/* REDIRECT (5) */ 1,
58 1,
59 1,
60/* ECHO (8) */ 0,
61/* ROUTERADVERT (9) */ 1,
62/* ROUTERSOLICIT (10) */ 1,
63/* TIME EXCEEDED (11) */ 1,
64/* PARAMETER PROBLEM (12) */ 1,
65/* TIMESTAMP (13) */ 0,
66/* TIMESTAMP REPLY (14) */ 0,
67/* INFO (15) */ 0,
68/* INFO REPLY (16) */ 0,
69/* ADDR MASK (17) */ 0,
70/* ADDR MASK REPLY (18) */ 0
71};
72
73#ifdef VBOX_WITH_SLIRP_ICMP
74int
75icmp_init(PNATState pData)
76{
77 pData->icmp_socket.so_type = IPPROTO_ICMP;
78 pData->icmp_socket.so_state = SS_ISFCONNECTED;
79#ifndef RT_OS_WINDOWS
80# ifndef RT_OS_DARWIN
81 pData->icmp_socket.s = socket(PF_INET, SOCK_RAW, IPPROTO_ICMP);
82# else /* !RT_OS_DARWIN */
83 pData->icmp_socket.s = socket(AF_INET, SOCK_DGRAM, IPPROTO_ICMP);
84# endif /* RT_OS_DARWIN */
85 if (pData->icmp_socket.s == -1)
86 {
87 int rc = RTErrConvertFromErrno(errno);
88 LogRel(("NAT: ICMP/ping not available (could open ICMP socket, error %Rrc)\n", rc));
89 return 1;
90 }
91#else /* RT_OS_WINDOWS */
92 pData->hmIcmpLibrary = LoadLibrary("Iphlpapi.dll");
93 if (pData->hmIcmpLibrary != NULL)
94 {
95 pData->pfIcmpParseReplies = (long (WINAPI *)(void *, long))
96 GetProcAddress(pData->hmIcmpLibrary, "IcmpParseReplies");
97 pData->pfIcmpCloseHandle = (BOOL (WINAPI *)(HANDLE))
98 GetProcAddress(pData->hmIcmpLibrary, "IcmpCloseHandle");
99 }
100 if (pData->pfIcmpParseReplies == NULL)
101 {
102 FreeLibrary(pData->hmIcmpLibrary);
103 pData->hmIcmpLibrary = LoadLibrary("Icmp.dll");
104 if (pData->hmIcmpLibrary == NULL)
105 {
106 LogRel(("NAT: Icmp.dll could not be loaded\n"));
107 return 1;
108 }
109 pData->pfIcmpParseReplies = (long (WINAPI *)(void *, long))
110 GetProcAddress(pData->hmIcmpLibrary, "IcmpParseReplies");
111 pData->pfIcmpCloseHandle = (BOOL (WINAPI *)(HANDLE))
112 GetProcAddress(pData->hmIcmpLibrary, "IcmpCloseHandle");
113 }
114 if (pData->pfIcmpParseReplies == NULL)
115 {
116 LogRel(("NAT: Can't find IcmpParseReplies symbol\n"));
117 FreeLibrary(pData->hmIcmpLibrary);
118 return 1;
119 }
120 if (pData->pfIcmpCloseHandle == NULL)
121 {
122 LogRel(("NAT: Can't find IcmpCloseHandle symbol\n"));
123 FreeLibrary(pData->hmIcmpLibrary);
124 return 1;
125 }
126 pData->icmp_socket.sh = IcmpCreateFile();
127 pData->phEvents[VBOX_ICMP_EVENT_INDEX] = CreateEvent(NULL, FALSE, FALSE, NULL);
128 pData->szIcmpBuffer = sizeof(ICMP_ECHO_REPLY) * 10;
129 pData->pvIcmpBuffer = malloc(pData->szIcmpBuffer);
130#endif /* RT_OS_WINDOWS */
131 LIST_INIT(&pData->icmp_msg_head);
132 return 0;
133}
134
135/*
136 * ip here is ip header + 64bytes readed from ICMP packet
137 */
138struct icmp_msg *
139icmp_find_original_mbuf(PNATState pData, struct ip *ip)
140{
141 struct mbuf *m0;
142 struct ip *ip0;
143 struct icmp *icp, *icp0;
144 struct icmp_msg *icm = NULL;
145 int found = 0;
146 struct udphdr *udp;
147 struct tcphdr *tcp;
148 struct socket *head_socket = NULL;
149 struct socket *last_socket = NULL;
150 struct socket *so = NULL;
151 struct in_addr laddr, faddr;
152 u_short lport, fport;
153
154 laddr.s_addr = ~0;
155 faddr.s_addr = ~0;
156
157 lport = ~0;
158 fport = ~0;
159
160
161 LogRel(("%s: processing (proto:%d)\n", __FUNCTION__, ip->ip_p));
162 switch (ip->ip_p)
163 {
164 case IPPROTO_ICMP:
165 icp = (struct icmp *)((char *)ip + (ip->ip_hl << 2));
166 LIST_FOREACH(icm, &pData->icmp_msg_head, im_list)
167 {
168 m0 = icm->im_m;
169 ip0 = mtod(m0, struct ip *);
170 AssertRelease(ip0->ip_p == IPPROTO_ICMP);
171 icp0 = (struct icmp *)((char *)ip0 + (ip0->ip_hl << 2));
172 if ( ( (icp->icmp_type != ICMP_ECHO && ip->ip_src.s_addr == ip0->ip_dst.s_addr)
173 || (icp->icmp_type == ICMP_ECHO && ip->ip_dst.s_addr == ip0->ip_dst.s_addr))
174 && icp->icmp_id == icp0->icmp_id
175 && icp->icmp_seq == icp0->icmp_seq)
176 {
177 found = 1;
178 break;
179 }
180 LogRel(("Have found nothing\n"));
181 }
182 break;
183
184 /*
185 * for TCP and UDP logic little bit reverted, we try to find the HOST socket
186 * from which the IP package has been sent.
187 */
188 case IPPROTO_UDP:
189 head_socket = &udb;
190 udp = (struct udphdr *)((char *)ip + (ip->ip_hl << 2));
191 faddr.s_addr = ip->ip_dst.s_addr;
192 fport = udp->uh_dport;
193 laddr.s_addr = ip->ip_src.s_addr;
194 lport = udp->uh_sport;
195 last_socket = udp_last_so;
196 /* fall through */
197
198 case IPPROTO_TCP:
199 if (head_socket == NULL)
200 {
201 tcp = (struct tcphdr *)((char *)ip + (ip->ip_hl << 2));
202 head_socket = &tcb; /* head_socket could be initialized with udb*/
203 faddr.s_addr = ip->ip_dst.s_addr;
204 fport = tcp->th_dport;
205 laddr.s_addr = ip->ip_src.s_addr;
206 lport = tcp->th_sport;
207 last_socket = tcp_last_so;
208 }
209 /* check last socket first */
210 if ( last_socket->so_faddr.s_addr == faddr.s_addr
211 && last_socket->so_fport == fport
212 && last_socket->so_hlport == lport)
213 {
214 found = 1;
215 so = last_socket;
216 goto sofound;
217 }
218 for (so = head_socket->so_prev; so != head_socket; so = so->so_prev)
219 {
220 /* Should be reaplaced by hash here */
221 LogRel(("trying:%R[natsock] against %R[IP4]:%d lport=%d hlport=%d\n", so, &faddr, fport, lport, so->so_hlport));
222 if ( so->so_faddr.s_addr == faddr.s_addr
223 && so->so_fport == fport
224 && so->so_hlport == lport)
225 {
226 found = 1;
227 break;
228 }
229 }
230 break;
231
232 default:
233 LogRel(("%s:ICMP: unsupported protocol(%d)\n", __FUNCTION__, ip->ip_p));
234 }
235 sofound:
236 if (found == 1 && icm == NULL)
237 {
238 icm = malloc(sizeof(struct icmp_msg));
239 icm->im_m = so->so_m;
240 icm->im_so = so;
241 found = 1;
242 LogRel(("hit:%R[natsock]\n", so));
243 /*XXX: this storage not very long,
244 * better add flag if it should removed from lis
245 */
246 LIST_INSERT_HEAD(&pData->icmp_msg_head, icm, im_list);
247 return (icm);
248 }
249 if (found == 1)
250 return icm;
251
252 return NULL;
253}
254
255static int
256icmp_attach(PNATState pData, struct mbuf *m)
257{
258 struct icmp_msg *icm;
259 struct ip *ip;
260 ip = mtod(m, struct ip *);
261 Assert(ip->ip_p == IPPROTO_ICMP);
262 icm = malloc(sizeof(struct icmp_msg));
263 icm->im_m = m;
264 LIST_INSERT_HEAD(&pData->icmp_msg_head, icm, im_list);
265 return 0;
266}
267#endif /* VBOX_WITH_SLIRP_ICMP */
268
269/*
270 * Process a received ICMP message.
271 */
272void
273icmp_input(PNATState pData, struct mbuf *m, int hlen)
274{
275 register struct icmp *icp;
276 register struct ip *ip = mtod(m, struct ip *);
277 int icmplen = ip->ip_len;
278 int status;
279 uint32_t dst;
280#if defined(VBOX_WITH_SLIRP_ICMP) && !defined(RT_OS_WINDOWS)
281 int ttl;
282#endif
283
284 /* int code; */
285
286 DEBUG_CALL("icmp_input");
287 DEBUG_ARG("m = %lx", (long )m);
288 DEBUG_ARG("m_len = %d", m->m_len);
289
290 icmpstat.icps_received++;
291
292 /*
293 * Locate icmp structure in mbuf, and check
294 * that its not corrupted and of at least minimum length.
295 */
296 if (icmplen < ICMP_MINLEN)
297 {
298 /* min 8 bytes payload */
299 icmpstat.icps_tooshort++;
300freeit:
301 m_freem(pData, m);
302 goto end_error;
303 }
304
305 m->m_len -= hlen;
306 m->m_data += hlen;
307 icp = mtod(m, struct icmp *);
308 if (cksum(m, icmplen))
309 {
310 icmpstat.icps_checksum++;
311 goto freeit;
312 }
313 m->m_len += hlen;
314 m->m_data -= hlen;
315
316 /* icmpstat.icps_inhist[icp->icmp_type]++; */
317 /* code = icp->icmp_code; */
318
319 DEBUG_ARG("icmp_type = %d", icp->icmp_type);
320 switch (icp->icmp_type)
321 {
322 case ICMP_ECHO:
323#ifndef VBOX_WITH_SLIRP_ICMP
324 icp->icmp_type = ICMP_ECHOREPLY;
325#endif /* !VBOX_WITH_SLIRP_ICMP */
326
327 ip->ip_len += hlen; /* since ip_input subtracts this */
328 dst = ip->ip_dst.s_addr;
329 if (dst == alias_addr.s_addr)
330 {
331#ifdef VBOX_WITH_SLIRP_ICMP
332 icp->icmp_type = ICMP_ECHOREPLY;
333 ip->ip_dst.s_addr = ip->ip_src.s_addr;
334 ip->ip_src.s_addr = dst;
335#endif /* VBOX_WITH_SLIRP_ICMP */
336 icmp_reflect(pData, m);
337 }
338 else
339 {
340 struct sockaddr_in addr;
341#ifndef VBOX_WITH_SLIRP_ICMP
342 struct socket *so;
343 if ((so = socreate()) == NULL)
344 goto freeit;
345 if (udp_attach(pData, so) == -1)
346 {
347 DEBUG_MISC((dfd,"icmp_input udp_attach errno = %d-%s\n",
348 errno,strerror(errno)));
349 sofree(pData, so);
350 m_free(pData, m);
351 goto end_error;
352 }
353 so->so_m = m;
354 so->so_faddr = ip->ip_dst;
355 so->so_fport = htons(7);
356 so->so_laddr = ip->ip_src;
357 so->so_lport = htons(9);
358 so->so_iptos = ip->ip_tos;
359 so->so_type = IPPROTO_ICMP;
360 so->so_state = SS_ISFCONNECTED;
361
362 addr.sin_family = AF_INET;
363 if ((so->so_faddr.s_addr & htonl(pData->netmask)) == special_addr.s_addr)
364 {
365 /* It's an alias */
366 switch (ntohl(so->so_faddr.s_addr) & ~pData->netmask)
367 {
368 case CTL_DNS:
369 addr.sin_addr = dns_addr;
370 break;
371 case CTL_ALIAS:
372 default:
373 addr.sin_addr = loopback_addr;
374 break;
375 }
376 }
377 else
378 addr.sin_addr = so->so_faddr;
379 addr.sin_port = so->so_fport;
380 if (sendto(so->s, icmp_ping_msg, strlen(icmp_ping_msg), 0,
381 (struct sockaddr *)&addr, sizeof(addr)) == -1)
382 {
383 DEBUG_MISC((dfd,"icmp_input udp sendto tx errno = %d-%s\n",
384 errno,strerror(errno)));
385 icmp_error(pData, m, ICMP_UNREACH,ICMP_UNREACH_NET, 0,strerror(errno));
386 udp_detach(pData, so);
387 }
388#else /* VBOX_WITH_SLIRP_ICMP */
389# ifdef RT_OS_WINDOWS
390 IP_OPTION_INFORMATION ipopt;
391 int error;
392# endif
393 addr.sin_family = AF_INET;
394 if ((ip->ip_dst.s_addr & htonl(pData->netmask)) == special_addr.s_addr)
395 {
396 /* It's an alias */
397 switch (ntohl(ip->ip_dst.s_addr) & ~pData->netmask)
398 {
399 case CTL_DNS:
400 addr.sin_addr = dns_addr;
401 break;
402 case CTL_ALIAS:
403 default:
404 addr.sin_addr = loopback_addr;
405 break;
406 }
407 }
408 else
409 addr.sin_addr.s_addr = ip->ip_dst.s_addr;
410# ifndef RT_OS_WINDOWS
411 if (pData->icmp_socket.s != -1)
412 {
413 icmp_attach(pData, m);
414 ttl = ip->ip_ttl;
415 LogRel(("NAT/ICMP: try to set TTL(%d)\n", ttl));
416 status = setsockopt(pData->icmp_socket.s, IPPROTO_IP, IP_TTL,
417 (void *)&ttl, sizeof(ttl));
418 if (status < 0)
419 LogRel(("NAT: Error (%s) occurred while setting TTL attribute of IP packet\n",
420 strerror(errno)));
421 if (sendto(pData->icmp_socket.s, icp, icmplen, 0,
422 (struct sockaddr *)&addr, sizeof(addr)) == -1)
423 {
424 DEBUG_MISC((dfd,"icmp_input udp sendto tx errno = %d-%s\n",
425 errno, strerror(errno)));
426 icmp_error(pData, m, ICMP_UNREACH,ICMP_UNREACH_NET, 0, strerror(errno));
427 m_free(pData, m);
428 }
429 }
430# else /* RT_OS_WINDOWS */
431 icmp_attach(pData, m);
432 pData->icmp_socket.so_laddr.s_addr = ip->ip_src.s_addr; /* XXX: hack*/
433 pData->icmp_socket.so_icmp_id = icp->icmp_id;
434 pData->icmp_socket.so_icmp_seq = icp->icmp_seq;
435 memset(&ipopt, 0, sizeof(IP_OPTION_INFORMATION));
436 ipopt.Ttl = ip->ip_ttl;
437 status = IcmpSendEcho2(pData->icmp_socket.sh, pData->phEvents[VBOX_ICMP_EVENT_INDEX],
438 NULL, NULL, addr.sin_addr.s_addr, icp->icmp_data,
439 icmplen - offsetof(struct icmp, icmp_data) , &ipopt,
440 pData->pvIcmpBuffer, pData->szIcmpBuffer, 1);
441 if (status == 0 && (error = GetLastError()) != ERROR_IO_PENDING)
442 {
443 error = GetLastError();
444 LogRel(("NAT: Error (%d) occurred while sending ICMP (", error));
445 switch (error)
446 {
447 case ERROR_INVALID_PARAMETER:
448 LogRel(("icmp_socket:%lx is invalid)\n", pData->icmp_socket.s));
449 break;
450 case ERROR_NOT_SUPPORTED:
451 LogRel(("operation is unsupported)\n"));
452 break;
453 case ERROR_NOT_ENOUGH_MEMORY:
454 LogRel(("OOM!!!)\n"));
455 break;
456 case IP_BUF_TOO_SMALL:
457 LogRel(("Buffer too small)\n"));
458 break;
459 default:
460 LogRel(("Other error!!!)\n"));
461 break;
462 }
463 }
464# endif /* RT_OS_WINDOWS */
465#endif /* VBOX_WITH_SLIRP_ICMP */
466 } /* if ip->ip_dst.s_addr == alias_addr.s_addr */
467 break;
468 case ICMP_UNREACH:
469 /* XXX? report error? close socket? */
470 case ICMP_TIMXCEED:
471 case ICMP_PARAMPROB:
472 case ICMP_SOURCEQUENCH:
473 case ICMP_TSTAMP:
474 case ICMP_MASKREQ:
475 case ICMP_REDIRECT:
476 icmpstat.icps_notsupp++;
477 m_freem(pData, m);
478 break;
479
480 default:
481 icmpstat.icps_badtype++;
482 m_freem(pData, m);
483 } /* switch */
484
485end_error:
486 /* m is m_free()'d xor put in a socket xor or given to ip_send */
487 ;
488}
489
490
491/*
492 * Send an ICMP message in response to a situation
493 *
494 * RFC 1122: 3.2.2 MUST send at least the IP header and 8 bytes of header. MAY send more (we do).
495 * MUST NOT change this header information.
496 * MUST NOT reply to a multicast/broadcast IP address.
497 * MUST NOT reply to a multicast/broadcast MAC address.
498 * MUST reply to only the first fragment.
499 */
500/*
501 * Send ICMP_UNREACH back to the source regarding msrc.
502 * mbuf *msrc is used as a template, but is NOT m_free()'d.
503 * It is reported as the bad ip packet. The header should
504 * be fully correct and in host byte order.
505 * ICMP fragmentation is illegal. All machines must accept 576 bytes in one
506 * packet. The maximum payload is 576-20(ip hdr)-8(icmp hdr)=548
507 */
508
509#define ICMP_MAXDATALEN (IP_MSS-28)
510void icmp_error(PNATState pData, struct mbuf *msrc, u_char type, u_char code, int minsize, const char *message)
511{
512 unsigned hlen, shlen, s_ip_len;
513 register struct ip *ip;
514 register struct icmp *icp;
515 register struct mbuf *m;
516
517 DEBUG_CALL("icmp_error");
518 DEBUG_ARG("msrc = %lx", (long )msrc);
519 DEBUG_ARG("msrc_len = %d", msrc->m_len);
520
521 if (type!=ICMP_UNREACH && type!=ICMP_TIMXCEED)
522 goto end_error;
523
524 /* check msrc */
525 if (!msrc)
526 goto end_error;
527
528 ip = mtod(msrc, struct ip *);
529#if DEBUG
530 {
531 char bufa[20], bufb[20];
532 strcpy(bufa, inet_ntoa(ip->ip_src));
533 strcpy(bufb, inet_ntoa(ip->ip_dst));
534 DEBUG_MISC((dfd, " %.16s to %.16s\n", bufa, bufb));
535 }
536#endif
537 if (ip->ip_off & IP_OFFMASK)
538 goto end_error; /* Only reply to fragment 0 */
539
540 shlen = ip->ip_hl << 2;
541 s_ip_len = ip->ip_len;
542 if (ip->ip_p == IPPROTO_ICMP)
543 {
544 icp = (struct icmp *)((char *)ip + shlen);
545 /*
546 * Assume any unknown ICMP type is an error. This isn't
547 * specified by the RFC, but think about it..
548 */
549 if (icp->icmp_type>18 || icmp_flush[icp->icmp_type])
550 goto end_error;
551 }
552
553 /* make a copy */
554 if (!(m = m_get(pData)))
555 goto end_error; /* get mbuf */
556 {
557 int new_m_size;
558 new_m_size = sizeof(struct ip) + ICMP_MINLEN + msrc->m_len + ICMP_MAXDATALEN;
559 if (new_m_size>m->m_size)
560 m_inc(m, new_m_size);
561 }
562 memcpy(m->m_data, msrc->m_data, msrc->m_len);
563 m->m_len = msrc->m_len; /* copy msrc to m */
564
565 /* make the header of the reply packet */
566 ip = mtod(m, struct ip *);
567 hlen = sizeof(struct ip ); /* no options in reply */
568
569 /* fill in icmp */
570 m->m_data += hlen;
571 m->m_len -= hlen;
572
573 icp = mtod(m, struct icmp *);
574
575 if (minsize)
576 s_ip_len = shlen+ICMP_MINLEN; /* return header+8b only */
577 else if (s_ip_len > ICMP_MAXDATALEN) /* maximum size */
578 s_ip_len = ICMP_MAXDATALEN;
579
580 m->m_len = ICMP_MINLEN + s_ip_len; /* 8 bytes ICMP header */
581
582 /* min. size = 8+sizeof(struct ip)+8 */
583
584 icp->icmp_type = type;
585 icp->icmp_code = code;
586 icp->icmp_id = 0;
587 icp->icmp_seq = 0;
588
589 memcpy(&icp->icmp_ip, msrc->m_data, s_ip_len); /* report the ip packet */
590 HTONS(icp->icmp_ip.ip_len);
591 HTONS(icp->icmp_ip.ip_id);
592 HTONS(icp->icmp_ip.ip_off);
593
594#if DEBUG
595 if (message)
596 {
597 /* DEBUG : append message to ICMP packet */
598 int message_len;
599 char *cpnt;
600 message_len = strlen(message);
601 if (message_len > ICMP_MAXDATALEN)
602 message_len = ICMP_MAXDATALEN;
603 cpnt = (char *)m->m_data+m->m_len;
604 memcpy(cpnt, message, message_len);
605 m->m_len += message_len;
606 }
607#endif
608
609 icp->icmp_cksum = 0;
610 icp->icmp_cksum = cksum(m, m->m_len);
611
612 m->m_data -= hlen;
613 m->m_len += hlen;
614
615 /* fill in ip */
616 ip->ip_hl = hlen >> 2;
617 ip->ip_len = m->m_len;
618
619 ip->ip_tos = ((ip->ip_tos & 0x1E) | 0xC0); /* high priority for errors */
620
621 ip->ip_ttl = MAXTTL;
622 ip->ip_p = IPPROTO_ICMP;
623 ip->ip_dst = ip->ip_src; /* ip adresses */
624 ip->ip_src = alias_addr;
625
626 (void ) ip_output(pData, (struct socket *)NULL, m);
627
628 icmpstat.icps_reflect++;
629
630end_error:
631 ;
632}
633#undef ICMP_MAXDATALEN
634
635/*
636 * Reflect the ip packet back to the source
637 */
638void
639icmp_reflect(PNATState pData, struct mbuf *m)
640{
641 register struct ip *ip = mtod(m, struct ip *);
642 int hlen = ip->ip_hl << 2;
643 int optlen = hlen - sizeof(struct ip );
644 register struct icmp *icp;
645
646 /*
647 * Send an icmp packet back to the ip level,
648 * after supplying a checksum.
649 */
650 m->m_data += hlen;
651 m->m_len -= hlen;
652 icp = mtod(m, struct icmp *);
653
654 icp->icmp_cksum = 0;
655 icp->icmp_cksum = cksum(m, ip->ip_len - hlen);
656
657 m->m_data -= hlen;
658 m->m_len += hlen;
659
660#ifndef VBOX_WITH_SLIRP_ICMP
661 /* fill in ip */
662 if (optlen > 0)
663 {
664 /*
665 * Strip out original options by copying rest of first
666 * mbuf's data back, and adjust the IP length.
667 */
668 memmove((caddr_t)(ip + 1), (caddr_t)ip + hlen,
669 (unsigned )(m->m_len - hlen));
670 hlen -= optlen;
671 ip->ip_hl = hlen >> 2;
672 ip->ip_len -= optlen;
673 m->m_len -= optlen;
674 }
675 ip->ip_ttl = MAXTTL;
676 {
677 /* swap */
678 struct in_addr icmp_dst;
679 icmp_dst = ip->ip_dst;
680 ip->ip_dst = ip->ip_src;
681 ip->ip_src = icmp_dst;
682 }
683#endif /* !VBOX_WITH_SLIRP_ICMP */
684
685 (void ) ip_output(pData, (struct socket *)NULL, m);
686
687 icmpstat.icps_reflect++;
688}
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette