Fix compile error on non-i386.
[wine.git] / dlls / icmp / icmp_main.c
blob4971a7ced777ffe1a60191af96501f655055dfd8
1 /*
2 * ICMP
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
24 /* Future work:
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
31 * handle's structure?
32 * - This API should probably be thread safe. Is it really?
33 * - Using the winsock functions has not been tested.
36 #include "config.h"
38 #include <sys/types.h>
39 #ifdef HAVE_SYS_SOCKET_H
40 # include <sys/socket.h>
41 #endif
42 #ifdef HAVE_NETDB_H
43 # include <netdb.h>
44 #endif
45 #ifdef HAVE_NETINET_IN_SYSTM_H
46 # include <netinet/in_systm.h>
47 #endif
48 #ifdef HAVE_NETINET_IN_H
49 # include <netinet/in.h>
50 #endif
52 #ifdef HAVE_SYS_TIME_H
53 # include <sys/time.h>
54 #endif
55 #include <stdarg.h>
56 #include <string.h>
57 #include <errno.h>
58 #ifdef HAVE_UNISTD_H
59 # include <unistd.h>
60 #endif
61 #ifdef HAVE_ARPA_INET_H
62 # include <arpa/inet.h>
63 #endif
65 #include "windef.h"
66 #include "winbase.h"
67 #include "winerror.h"
68 #include "ipexport.h"
69 #include "icmpapi.h"
70 #include "wine/debug.h"
72 /* Set up endiannes macros for the ip and ip_icmp BSD headers */
73 #ifndef BIG_ENDIAN
74 #define BIG_ENDIAN 4321
75 #endif
76 #ifndef LITTLE_ENDIAN
77 #define LITTLE_ENDIAN 1234
78 #endif
79 #ifndef BYTE_ORDER
80 #ifdef WORDS_BIGENDIAN
81 #define BYTE_ORDER BIG_ENDIAN
82 #else
83 #define BYTE_ORDER LITTLE_ENDIAN
84 #endif
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.
95 #include "ip.h"
96 #include "ip_icmp.h"
99 WINE_DEFAULT_DEBUG_CHANNEL(icmp);
102 typedef struct {
103 int sid;
104 IP_OPTION_INFORMATION default_opts;
105 } icmp_t;
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)
118 int nleft=len;
119 u_short *w = addr;
120 int sum = 0;
121 u_short answer = 0;
123 while (nleft > 1) {
124 sum += *w++;
125 nleft -= 2;
128 if (nleft == 1) {
129 *(u_char *)(&answer) = *(u_char *)w;
130 sum += answer;
133 sum = (sum >> 16) + (sum & 0xffff);
134 sum += (sum >> 16);
135 answer = ~sum;
136 return(answer);
142 * Exported Routines.
145 /***********************************************************************
146 * IcmpCreateFile (ICMP.@)
148 HANDLE WINAPI IcmpCreateFile(VOID)
150 icmp_t* icp;
152 int sid=socket(AF_INET,SOCK_RAW,IPPROTO_ICMP);
153 if (sid < 0) {
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));
160 if (icp==NULL) {
161 SetLastError(IP_NO_RESOURCES);
162 return INVALID_HANDLE_VALUE;
164 icp->sid=sid;
165 icp->default_opts.OptionsSize=IP_OPTS_UNKNOWN;
166 return (HANDLE)icp;
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);
179 return FALSE;
182 shutdown(icp->sid,2);
183 HeapFree(GetProcessHeap (), 0, icp);
184 return TRUE;
188 /***********************************************************************
189 * IcmpSendEcho (ICMP.@)
191 DWORD WINAPI IcmpSendEcho(
192 HANDLE IcmpHandle,
193 IPAddr DestinationAddress,
194 LPVOID RequestData,
195 WORD RequestSize,
196 PIP_OPTION_INFORMATION RequestOptions,
197 LPVOID ReplyBuffer,
198 DWORD ReplySize,
199 DWORD Timeout
202 icmp_t* icp=(icmp_t*)IcmpHandle;
203 unsigned char* reqbuf;
204 int reqsize;
206 struct icmp_echo_reply* ier;
207 struct ip* ip_header;
208 struct icmp* icmp_header;
209 char* endbuf;
210 int ip_header_len;
211 int maxlen;
212 fd_set fdr;
213 struct timeval timeout,send_time,recv_time;
214 struct sockaddr_in addr;
215 int addrlen;
216 unsigned short id,seq,cksum;
217 int res;
219 if (IcmpHandle==INVALID_HANDLE_VALUE) {
220 /* FIXME: in fact win98 seems to ignore the handle value !!! */
221 SetLastError(ERROR_INVALID_HANDLE);
222 return 0;
225 if (ReplySize<sizeof(ICMP_ECHO_REPLY)+ICMP_MINLEN) {
226 SetLastError(IP_BUF_TOO_SMALL);
227 return 0;
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);
237 if (reqbuf==NULL) {
238 SetLastError(ERROR_OUTOFMEMORY);
239 return 0;
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;
253 addr.sin_port=0;
255 if (RequestOptions!=NULL) {
256 int val;
257 if (icp->default_opts.OptionsSize==IP_OPTS_UNKNOWN) {
258 int len;
259 /* Before we mess with the options, get the default values */
260 len=sizeof(val);
261 getsockopt(icp->sid,IPPROTO_IP,IP_TTL,(char *)&val,&len);
262 icp->default_opts.Ttl=val;
264 len=sizeof(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) {
278 int val;
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
293 FD_ZERO(&fdr);
294 FD_SET(icp->sid,&fdr);
295 timeout.tv_sec=Timeout/1000;
296 timeout.tv_usec=(Timeout % 1000)*1000;
297 addrlen=sizeof(addr);
298 ier=ReplyBuffer;
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));
305 #if 0
306 if (TRACE_ON(icmp)){
307 unsigned char* buf=(unsigned char*)reqbuf;
308 int i;
309 printf("Output buffer:\n");
310 for (i=0;i<reqsize;i++)
311 printf("%2x,", buf[i]);
312 printf("\n");
314 #endif
316 gettimeofday(&send_time,NULL);
317 res=sendto(icp->sid, reqbuf, reqsize, 0, (struct sockaddr*)&addr, sizeof(addr));
318 HeapFree(GetProcessHeap (), 0, reqbuf);
319 if (res<0) {
320 if (errno==EMSGSIZE)
321 SetLastError(IP_PACKET_TOO_BIG);
322 else {
323 switch (errno) {
324 case ENETUNREACH:
325 SetLastError(IP_DEST_NET_UNREACHABLE);
326 break;
327 case EHOSTUNREACH:
328 SetLastError(IP_DEST_HOST_UNREACHABLE);
329 break;
330 default:
331 TRACE("unknown error: errno=%d\n",errno);
332 SetLastError(IP_GENERAL_FAILURE);
335 return 0;
338 /* Get the reply */
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;
354 } else {
355 switch (icmp_header->icmp_type) {
356 case ICMP_UNREACH:
357 switch (icmp_header->icmp_code) {
358 case ICMP_UNREACH_HOST:
359 #ifdef ICMP_UNREACH_HOST_UNKNOWN
360 case ICMP_UNREACH_HOST_UNKNOWN:
361 #endif
362 #ifdef ICMP_UNREACH_ISOLATED
363 case ICMP_UNREACH_ISOLATED:
364 #endif
365 #ifdef ICMP_UNREACH_HOST_PROHIB
366 case ICMP_UNREACH_HOST_PROHIB:
367 #endif
368 #ifdef ICMP_UNREACH_TOSHOST
369 case ICMP_UNREACH_TOSHOST:
370 #endif
371 ier->Status=IP_DEST_HOST_UNREACHABLE;
372 break;
373 case ICMP_UNREACH_PORT:
374 ier->Status=IP_DEST_PORT_UNREACHABLE;
375 break;
376 case ICMP_UNREACH_PROTOCOL:
377 ier->Status=IP_DEST_PROT_UNREACHABLE;
378 break;
379 case ICMP_UNREACH_SRCFAIL:
380 ier->Status=IP_BAD_ROUTE;
381 break;
382 default:
383 ier->Status=IP_DEST_NET_UNREACHABLE;
385 break;
386 case ICMP_TIMXCEED:
387 if (icmp_header->icmp_code==ICMP_TIMXCEED_REASS)
388 ier->Status=IP_TTL_EXPIRED_REASSEM;
389 else
390 ier->Status=IP_TTL_EXPIRED_TRANSIT;
391 break;
392 case ICMP_PARAMPROB:
393 ier->Status=IP_PARAM_PROBLEM;
394 break;
395 case ICMP_SOURCEQUENCH:
396 ier->Status=IP_SOURCE_QUENCH;
397 break;
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",
422 id,seq,
423 cksum);
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;
439 timeout.tv_sec--;
441 continue;
442 } else {
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;
448 ier->Reserved=0;
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;
460 } else {
461 ier->Options.OptionsData=NULL;
462 endbuf=ier->Data;
465 /* Prepare for the next packet */
466 ier++;
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 */
471 timeout.tv_sec=0;
472 timeout.tv_usec=0;
474 FD_ZERO(&fdr);
475 FD_SET(icp->sid,&fdr);
477 res=ier-(ICMP_ECHO_REPLY*)ReplyBuffer;
478 if (res==0)
479 SetLastError(IP_REQ_TIMED_OUT);
480 TRACE("received %d replies\n",res);
481 return 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
489 * Mike Muuss.
491 * Redistribution and use in source and binary forms, with or without
492 * modification, are permitted provided that the following conditions
493 * are met:
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
513 * SUCH DAMAGE.