4 * Francois Gouget, 1999, based on the work of
5 * RW Hall, 1999, based on public domain code PING.C by Mike Muus (1983)
6 * and later works (c) 1989 Regents of Univ. of California - see copyright
7 * notice at end of source-code.
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 * - Systems like FreeBSD don't seem to support the IP_TTL option and maybe others.
26 * But using IP_HDRINCL and building the IP header by hand might work.
27 * - Not all IP options are supported.
28 * - Are ICMP handles real handles, i.e. inheritable and all? There might be some
29 * more work to do here, including server side stuff with synchronization.
30 * - Is it correct to use malloc for the internal buffer, for allocating the
32 * - This API should probably be thread safe. Is it really?
33 * - Using the winsock functions has not been tested.
38 #include <sys/types.h>
39 #ifdef HAVE_SYS_SOCKET_H
40 # include <sys/socket.h>
45 #ifdef HAVE_NETINET_IN_SYSTM_H
46 # include <netinet/in_systm.h>
48 #ifdef HAVE_NETINET_IN_H
49 # include <netinet/in.h>
52 #ifdef HAVE_SYS_TIME_H
53 # include <sys/time.h>
61 #ifdef HAVE_ARPA_INET_H
62 # include <arpa/inet.h>
70 #include "wine/debug.h"
72 /* Set up endiannes macros for the ip and ip_icmp BSD headers */
74 #define BIG_ENDIAN 4321
77 #define LITTLE_ENDIAN 1234
80 #ifdef WORDS_BIGENDIAN
81 #define BYTE_ORDER BIG_ENDIAN
83 #define BYTE_ORDER LITTLE_ENDIAN
85 #endif /* BYTE_ORDER */
87 #define u_int16_t WORD
88 #define u_int32_t DWORD
90 /* These are BSD headers. We use these here because they are needed on
91 * libc5 Linux systems. On other platforms they are usually simply more
92 * complete than the native stuff, and cause less portability problems
93 * so we use them anyway.
99 WINE_DEFAULT_DEBUG_CHANNEL(icmp);
104 IP_OPTION_INFORMATION default_opts;
107 #define IP_OPTS_UNKNOWN 0
108 #define IP_OPTS_DEFAULT 1
109 #define IP_OPTS_CUSTOM 2
111 /* The sequence number is unique process wide, so that all threads
112 * have a distinct sequence number.
114 static LONG icmp_sequence=0;
116 static int in_cksum(u_short *addr, int len)
129 *(u_char *)(&answer) = *(u_char *)w;
133 sum = (sum >> 16) + (sum & 0xffff);
145 /***********************************************************************
146 * IcmpCreateFile (ICMP.@)
148 HANDLE WINAPI IcmpCreateFile(VOID)
152 int sid=socket(AF_INET,SOCK_RAW,IPPROTO_ICMP);
154 MESSAGE("WARNING: Trying to use ICMP (network ping) will fail unless running as root\n");
155 SetLastError(ERROR_ACCESS_DENIED);
156 return INVALID_HANDLE_VALUE;
159 icp=HeapAlloc(GetProcessHeap(), 0, sizeof(*icp));
161 SetLastError(IP_NO_RESOURCES);
162 return INVALID_HANDLE_VALUE;
165 icp->default_opts.OptionsSize=IP_OPTS_UNKNOWN;
170 /***********************************************************************
171 * IcmpCloseHandle (ICMP.@)
173 BOOL WINAPI IcmpCloseHandle(HANDLE IcmpHandle)
175 icmp_t* icp=(icmp_t*)IcmpHandle;
176 if (IcmpHandle==INVALID_HANDLE_VALUE) {
177 /* FIXME: in fact win98 seems to ignore the handle value !!! */
178 SetLastError(ERROR_INVALID_HANDLE);
182 shutdown(icp->sid,2);
183 HeapFree(GetProcessHeap (), 0, icp);
188 /***********************************************************************
189 * IcmpSendEcho (ICMP.@)
191 DWORD WINAPI IcmpSendEcho(
193 IPAddr DestinationAddress,
196 PIP_OPTION_INFORMATION RequestOptions,
202 icmp_t* icp=(icmp_t*)IcmpHandle;
203 unsigned char* reqbuf;
206 struct icmp_echo_reply* ier;
207 struct ip* ip_header;
208 struct icmp* icmp_header;
213 struct timeval timeout,send_time,recv_time;
214 struct sockaddr_in addr;
216 unsigned short id,seq,cksum;
219 if (IcmpHandle==INVALID_HANDLE_VALUE) {
220 /* FIXME: in fact win98 seems to ignore the handle value !!! */
221 SetLastError(ERROR_INVALID_HANDLE);
225 if (ReplySize<sizeof(ICMP_ECHO_REPLY)+ICMP_MINLEN) {
226 SetLastError(IP_BUF_TOO_SMALL);
229 /* check the request size against SO_MAX_MSG_SIZE using getsockopt */
231 /* Prepare the request */
232 id=getpid() & 0xFFFF;
233 seq=InterlockedIncrement(&icmp_sequence) & 0xFFFF;
235 reqsize=ICMP_MINLEN+RequestSize;
236 reqbuf=HeapAlloc(GetProcessHeap(), 0, reqsize);
238 SetLastError(ERROR_OUTOFMEMORY);
242 icmp_header=(struct icmp*)reqbuf;
243 icmp_header->icmp_type=ICMP_ECHO;
244 icmp_header->icmp_code=0;
245 icmp_header->icmp_cksum=0;
246 icmp_header->icmp_id=id;
247 icmp_header->icmp_seq=seq;
248 memcpy(reqbuf+ICMP_MINLEN, RequestData, RequestSize);
249 icmp_header->icmp_cksum=cksum=in_cksum((u_short*)reqbuf,reqsize);
251 addr.sin_family=AF_INET;
252 addr.sin_addr.s_addr=DestinationAddress;
255 if (RequestOptions!=NULL) {
257 if (icp->default_opts.OptionsSize==IP_OPTS_UNKNOWN) {
259 /* Before we mess with the options, get the default values */
261 getsockopt(icp->sid,IPPROTO_IP,IP_TTL,(char *)&val,&len);
262 icp->default_opts.Ttl=val;
265 getsockopt(icp->sid,IPPROTO_IP,IP_TOS,(char *)&val,&len);
266 icp->default_opts.Tos=val;
267 /* FIXME: missing: handling of IP 'flags', and all the other options */
270 val=RequestOptions->Ttl;
271 setsockopt(icp->sid,IPPROTO_IP,IP_TTL,(char *)&val,sizeof(val));
272 val=RequestOptions->Tos;
273 setsockopt(icp->sid,IPPROTO_IP,IP_TOS,(char *)&val,sizeof(val));
274 /* FIXME: missing: handling of IP 'flags', and all the other options */
276 icp->default_opts.OptionsSize=IP_OPTS_CUSTOM;
277 } else if (icp->default_opts.OptionsSize==IP_OPTS_CUSTOM) {
280 /* Restore the default options */
281 val=icp->default_opts.Ttl;
282 setsockopt(icp->sid,IPPROTO_IP,IP_TTL,(char *)&val,sizeof(val));
283 val=icp->default_opts.Tos;
284 setsockopt(icp->sid,IPPROTO_IP,IP_TOS,(char *)&val,sizeof(val));
285 /* FIXME: missing: handling of IP 'flags', and all the other options */
287 icp->default_opts.OptionsSize=IP_OPTS_DEFAULT;
290 /* Get ready for receiving the reply
291 * Do it before we send the request to minimize the risk of introducing delays
294 FD_SET(icp->sid,&fdr);
295 timeout.tv_sec=Timeout/1000;
296 timeout.tv_usec=(Timeout % 1000)*1000;
297 addrlen=sizeof(addr);
299 ip_header=(struct ip *) ((char *) ReplyBuffer+sizeof(ICMP_ECHO_REPLY));
300 endbuf=(char *) ReplyBuffer+ReplySize;
301 maxlen=ReplySize-sizeof(ICMP_ECHO_REPLY);
303 /* Send the packet */
304 TRACE("Sending %d bytes (RequestSize=%d) to %s\n", reqsize, RequestSize, inet_ntoa(addr.sin_addr));
307 unsigned char* buf=(unsigned char*)reqbuf;
309 printf("Output buffer:\n");
310 for (i=0;i<reqsize;i++)
311 printf("%2x,", buf[i]);
316 gettimeofday(&send_time,NULL);
317 res=sendto(icp->sid, reqbuf, reqsize, 0, (struct sockaddr*)&addr, sizeof(addr));
318 HeapFree(GetProcessHeap (), 0, reqbuf);
321 SetLastError(IP_PACKET_TOO_BIG);
325 SetLastError(IP_DEST_NET_UNREACHABLE);
328 SetLastError(IP_DEST_HOST_UNREACHABLE);
331 TRACE("unknown error: errno=%d\n",errno);
332 SetLastError(IP_GENERAL_FAILURE);
339 ip_header_len=0; /* because gcc was complaining */
340 while ((res=select(icp->sid+1,&fdr,NULL,NULL,&timeout))>0) {
341 gettimeofday(&recv_time,NULL);
342 res=recvfrom(icp->sid, (char*)ip_header, maxlen, 0, (struct sockaddr*)&addr,&addrlen);
343 TRACE("received %d bytes from %s\n",res, inet_ntoa(addr.sin_addr));
344 ier->Status=IP_REQ_TIMED_OUT;
346 /* Check whether we should ignore this packet */
347 if ((ip_header->ip_p==IPPROTO_ICMP) && (res>=sizeof(struct ip)+ICMP_MINLEN)) {
348 ip_header_len=ip_header->ip_hl << 2;
349 icmp_header=(struct icmp*)(((char*)ip_header)+ip_header_len);
350 TRACE("received an ICMP packet of type,code=%d,%d\n",icmp_header->icmp_type,icmp_header->icmp_code);
351 if (icmp_header->icmp_type==ICMP_ECHOREPLY) {
352 if ((icmp_header->icmp_id==id) && (icmp_header->icmp_seq==seq))
353 ier->Status=IP_SUCCESS;
355 switch (icmp_header->icmp_type) {
357 switch (icmp_header->icmp_code) {
358 case ICMP_UNREACH_HOST:
359 #ifdef ICMP_UNREACH_HOST_UNKNOWN
360 case ICMP_UNREACH_HOST_UNKNOWN:
362 #ifdef ICMP_UNREACH_ISOLATED
363 case ICMP_UNREACH_ISOLATED:
365 #ifdef ICMP_UNREACH_HOST_PROHIB
366 case ICMP_UNREACH_HOST_PROHIB:
368 #ifdef ICMP_UNREACH_TOSHOST
369 case ICMP_UNREACH_TOSHOST:
371 ier->Status=IP_DEST_HOST_UNREACHABLE;
373 case ICMP_UNREACH_PORT:
374 ier->Status=IP_DEST_PORT_UNREACHABLE;
376 case ICMP_UNREACH_PROTOCOL:
377 ier->Status=IP_DEST_PROT_UNREACHABLE;
379 case ICMP_UNREACH_SRCFAIL:
380 ier->Status=IP_BAD_ROUTE;
383 ier->Status=IP_DEST_NET_UNREACHABLE;
387 if (icmp_header->icmp_code==ICMP_TIMXCEED_REASS)
388 ier->Status=IP_TTL_EXPIRED_REASSEM;
390 ier->Status=IP_TTL_EXPIRED_TRANSIT;
393 ier->Status=IP_PARAM_PROBLEM;
395 case ICMP_SOURCEQUENCH:
396 ier->Status=IP_SOURCE_QUENCH;
399 if (ier->Status!=IP_REQ_TIMED_OUT) {
400 struct ip* rep_ip_header;
401 struct icmp* rep_icmp_header;
402 /* The ICMP header size of all the packets we accept is the same */
403 rep_ip_header=(struct ip*)(((char*)icmp_header)+ICMP_MINLEN);
404 rep_icmp_header=(struct icmp*)(((char*)rep_ip_header)+(rep_ip_header->ip_hl << 2));
406 /* Make sure that this is really a reply to our packet */
407 if (ip_header_len+ICMP_MINLEN+(rep_ip_header->ip_hl << 2)+ICMP_MINLEN>ip_header->ip_len) {
408 ier->Status=IP_REQ_TIMED_OUT;
409 } else if ((rep_icmp_header->icmp_type!=ICMP_ECHO) ||
410 (rep_icmp_header->icmp_code!=0) ||
411 (rep_icmp_header->icmp_id!=id) ||
412 /* windows doesn't check this checksum, else tracert */
413 /* behind a Linux 2.2 masquerading firewall would fail*/
414 /* (rep_icmp_header->icmp_cksum!=cksum) || */
415 (rep_icmp_header->icmp_seq!=seq)) {
416 /* This was not a reply to one of our packets after all */
417 TRACE("skipping type,code=%d,%d id,seq=%d,%d cksum=%d\n",
418 rep_icmp_header->icmp_type,rep_icmp_header->icmp_code,
419 rep_icmp_header->icmp_id,rep_icmp_header->icmp_seq,
420 rep_icmp_header->icmp_cksum);
421 TRACE("expected type,code=8,0 id,seq=%d,%d cksum=%d\n",
424 ier->Status=IP_REQ_TIMED_OUT;
430 if (ier->Status==IP_REQ_TIMED_OUT) {
431 /* This packet was not for us.
432 * Decrease the timeout so that we don't enter an endless loop even
433 * if we get flooded with ICMP packets that are not for us.
435 timeout.tv_sec=Timeout/1000-(recv_time.tv_sec-send_time.tv_sec);
436 timeout.tv_usec=(Timeout % 1000)*1000+send_time.tv_usec-(recv_time.tv_usec-send_time.tv_usec);
437 if (timeout.tv_usec<0) {
438 timeout.tv_usec+=1000000;
443 /* This is a reply to our packet */
444 memcpy(&ier->Address,&ip_header->ip_src,sizeof(IPAddr));
445 /* Status is already set */
446 ier->RoundTripTime=(recv_time.tv_sec-send_time.tv_sec)*1000+(recv_time.tv_usec-send_time.tv_usec)/1000;
447 ier->DataSize=res-ip_header_len-ICMP_MINLEN;
449 ier->Data=endbuf-ier->DataSize;
450 memmove(ier->Data,((char*)ip_header)+ip_header_len+ICMP_MINLEN,ier->DataSize);
451 ier->Options.Ttl=ip_header->ip_ttl;
452 ier->Options.Tos=ip_header->ip_tos;
453 ier->Options.Flags=ip_header->ip_off >> 13;
454 ier->Options.OptionsSize=ip_header_len-sizeof(struct ip);
455 if (ier->Options.OptionsSize!=0) {
456 ier->Options.OptionsData=(unsigned char *) ier->Data-ier->Options.OptionsSize;
457 /* FIXME: We are supposed to rearrange the option's 'source route' data */
458 memmove(ier->Options.OptionsData,((char*)ip_header)+ip_header_len,ier->Options.OptionsSize);
459 endbuf=ier->Options.OptionsData;
461 ier->Options.OptionsData=NULL;
465 /* Prepare for the next packet */
467 ip_header=(struct ip*)(((char*)ip_header)+sizeof(ICMP_ECHO_REPLY));
468 maxlen=endbuf-(char*)ip_header;
470 /* Check out whether there is more but don't wait this time */
475 FD_SET(icp->sid,&fdr);
477 res=ier-(ICMP_ECHO_REPLY*)ReplyBuffer;
479 SetLastError(IP_REQ_TIMED_OUT);
480 TRACE("received %d replies\n",res);
485 * Copyright (c) 1989 The Regents of the University of California.
486 * All rights reserved.
488 * This code is derived from software contributed to Berkeley by
491 * Redistribution and use in source and binary forms, with or without
492 * modification, are permitted provided that the following conditions
494 * 1. Redistributions of source code must retain the above copyright
495 * notice, this list of conditions and the following disclaimer.
496 * 2. Redistributions in binary form must reproduce the above copyright
497 * notice, this list of conditions and the following disclaimer in the
498 * documentation and/or other materials provided with the distribution.
499 * 3. Neither the name of the University nor the names of its contributors
500 * may be used to endorse or promote products derived from this software
501 * without specific prior written permission.
503 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
504 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
505 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
506 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
507 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
508 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
509 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
510 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
511 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
512 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF