1 /******************************************************************************
2 Author: Samuel Jero <sj323707@ohio.edu>
6 Description: Program to ping hosts using DCCP REQ packets to test for DCCP connectivity.
7 ******************************************************************************/
16 #include <sys/types.h>
18 #include <sys/socket.h>
19 #include <sys/select.h>
20 #include <netinet/ip.h>
21 #include <netinet/ip6.h>
22 #include <netinet/in.h>
23 #include <netinet/ip_icmp.h>
24 #include <netinet/icmp6.h>
25 #include <arpa/inet.h>
29 #include <linux/dccp.h>
30 #include "checksums.h"
33 #define MAX(x,y) (x>y ? x : y)
34 /*Structure for simpler IPv4/IPv6 Address handling*/
37 struct sockaddr_in *ipv4;
38 struct sockaddr_in6 *ipv6;
52 char* response_label[]= {
54 "Closed Port (Reset)",
55 "Open Port (Response)",
57 "Destination Unreachable",
60 "DCCP Not Supported (Parameter Problem)",
61 "Protocol Error (DCCP Reset)"
71 enum responses reply_type;
93 int debug=0; /*set to 1 to turn on debugging information*/
94 int count=-1; /*Default number of pings (-1 is infinity)*/
95 int dest_port=33434; /*Default port*/
96 int ttl=64; /*Default TTL*/
97 long interval=1000; /*Default delay between pings in ms*/
98 int ip_type=AF_UNSPEC; /*IPv4 or IPv6*/
99 ipaddr_ptr_t dest_addr; /*Destination Address*/
100 ipaddr_ptr_t src_addr; /*Source Address*/
101 struct request_queue queue;
102 struct stats ping_stats;
106 void getAddresses(char *src, char* dst);
108 void handleDCCPpacket(int rcv_socket, int send_socket);
109 void handleICMP4packet(int rcv_socket);
110 void handleICMP6packet(int rcv_socket);
111 void buildRequestPacket(unsigned char* buffer, int *len, int seq);
112 void updateRequestPacket(unsigned char* buffer, int *len, int seq);
113 void sendClose(int seq, u_int16_t ack_h, u_int32_t ack_l, int socket);
114 void sendReset(int seq, u_int16_t ack_h, u_int32_t ack_l, int socket);
115 int logPacket(int seq);
116 int logResponse(ipaddr_ptr_t *src, int seq, int type);
120 void sanitize_environment();
121 void dbgprintf(int level, const char *fmt, ...);
124 /*Parse commandline options*/
125 int main(int argc, char *argv[])
132 ping_stats.replies_received=0;
133 ping_stats.requests_sent=0;
134 ping_stats.rtt_avg=0;
135 ping_stats.rtt_max=0;
136 ping_stats.rtt_min=0;
139 sanitize_environment();
141 while ((c = getopt(argc, argv, "64c:p:i:dt:S:")) != -1) {
150 count = atoi(optarg);
152 dbgprintf(0, "Error: count must be positive");
157 dest_port = atoi(optarg);
160 interval = (long)(atof(optarg) * 1000.0);
162 fprintf(stderr, "Invalid interval\n");
171 if (ttl < 1 || ttl > 255) {
172 fprintf(stderr, "Invalid TTL\n");
192 getAddresses(src, dst);
193 if(src_addr.gen==NULL || dest_addr.gen==NULL){
194 dbgprintf(0,"Error: Can't determine source or destination address\n");
198 signal(SIGINT, sigHandler);
207 void getAddresses(char *src, char* dst){
208 struct addrinfo hint;
209 struct addrinfo *dtmp, *stmp;
210 struct ifaddrs *temp, *cur;
211 struct sockaddr_in6* iv6;
215 /*Lookup destination Address*/
216 memset(&hint,0,sizeof(struct addrinfo));
217 hint.ai_family=ip_type;
218 hint.ai_flags=AI_V4MAPPED | AI_ADDRCONFIG;
220 if((err=getaddrinfo(dst,NULL,&hint,&dtmp))!=0){
221 dbgprintf(0,"Error: Couldn't lookup destination %s (%s)\n", dst, gai_strerror(err));
225 dbgprintf(0,"Error: Unknown Host %s\n", dst);
228 addrlen=dtmp->ai_addrlen;
229 hint.ai_family=ip_type=dtmp->ai_family;
230 dest_addr.gen=malloc(dtmp->ai_addrlen);
231 if(dest_addr.gen==NULL){
232 dbgprintf(0,"Error: Can't allocate Memory\n");
235 memcpy(dest_addr.gen,dtmp->ai_addr,dtmp->ai_addrlen);
239 /*Get a meaningful source address*/
241 /*Use Commandline arg*/
242 if((err=getaddrinfo(src,NULL,&hint,&stmp))!=0){
243 dbgprintf(0,"Error: Source Address %s is invalid (%s)\n", src, gai_strerror(err));
247 dbgprintf(0,"Error: Unknown Host %s\n", dst);
250 addrlen=stmp->ai_addrlen;
251 src_addr.gen=malloc(stmp->ai_addrlen);
252 if(src_addr.gen==NULL){
253 dbgprintf(0,"Error: Can't allocate Memory\n");
256 memcpy(src_addr.gen,stmp->ai_addr,stmp->ai_addrlen);
260 /*Guess a good source address*/
264 if(cur->ifa_addr==NULL || cur->ifa_addr->sa_family!=ip_type){ /*Not matching ipv4/ipv6 of dest*/
268 if(cur->ifa_flags & IFF_LOOPBACK){ /*Don't use loopback addresses*/
272 if(cur->ifa_addr!=NULL && cur->ifa_addr->sa_family==AF_INET6){
273 iv6=(struct sockaddr_in6*)cur->ifa_addr;
275 if(iv6->sin6_scope_id!=0){ /*Not globally valid address, if ipv6*/
281 src_addr.gen=malloc(sizeof(struct sockaddr_storage));
282 if(src_addr.gen==NULL){
283 dbgprintf(0,"Error: Can't allocate Memory\n");
286 src_addr.gen->sa_family=ip_type;
287 memcpy(src_addr.gen,cur->ifa_addr,addrlen);
296 /*Preform the ping functionality*/
302 unsigned char sbuffer[slen];
304 struct timeval timeout;
305 struct timeval t,delay, add;
310 rs=socket(ip_type, SOCK_RAW ,IPPROTO_RAW);
312 dbgprintf(0, "Error opening raw socket\n");
315 ds=socket(ip_type, SOCK_RAW ,IPPROTO_DCCP);
317 dbgprintf(0, "Error opening raw DCCP socket\n");
320 is4=socket(ip_type,SOCK_RAW,IPPROTO_ICMP);
322 dbgprintf(0,"Error opening raw ICMPv4 socket\n");
325 is6=socket(ip_type,SOCK_RAW,IPPROTO_ICMPV6);
327 dbgprintf(0,"Error opening raw ICMPv6 socket\n");
332 /*Build DCCP packet*/
333 buildRequestPacket(sbuffer,&slen,seq);
334 if(ip_type==AF_INET){
335 addrlen=sizeof(struct sockaddr_in);
337 addrlen=sizeof(struct sockaddr_in6);
341 if(ip_type==AF_INET){
342 dbgprintf(0, "PINGING %s on DCCP port %i\n",
343 inet_ntop(ip_type, (void*)&dest_addr.ipv4->sin_addr, pbuf, 1000),dest_port);
345 dbgprintf(0, "PINGING %s on DCCP port %i\n",
346 inet_ntop(ip_type, (void*)&dest_addr.ipv6->sin6_addr, pbuf, 1000),dest_port);
351 if(sendto(rs, &sbuffer, slen, MSG_DONTWAIT,(struct sockaddr*)dest_addr.gen,addrlen)<0){
353 dbgprintf(0,"Error: sendto failed\n");
356 if(count==0){done=1; break;}
358 if (logPacket(seq)<0){
359 dbgprintf(0,"Error: Couldn't record request!\n");
361 if(ip_type==AF_INET){
362 dbgprintf(1, "Sending DCCP Request to %s\n",inet_ntop(ip_type, (void*)&dest_addr.ipv4->sin_addr, pbuf, 1000));
364 dbgprintf(1, "Sending DCCP Request to %s\n",inet_ntop(ip_type, (void*)&dest_addr.ipv6->sin6_addr, pbuf, 1000));
367 /*Use select to wait on packets or until interval has passed*/
368 add.tv_sec=interval/1000;
369 add.tv_usec=(interval%1000)*1000;
370 gettimeofday(&t,NULL);
371 timeradd(&t,&add,&delay);
372 while(timercmp(&t,&delay,<)){
373 /*Prepare for select*/
378 timersub(&delay,&t,&timeout);
381 if(select(MAX(ds+1,MAX(is4+1,is6+1)),&sel, NULL,NULL,&timeout)<0){
383 dbgprintf(0,"Select() error (%s)\n",strerror(errno));
386 if(count==0){done=1;break;}
388 if(FD_ISSET(ds,&sel)){
389 /*Data on the DCCP socket*/
390 handleDCCPpacket(ds,rs);
393 if(FD_ISSET(is4,&sel) && ip_type==AF_INET){
394 /*Data on the ICMPv4 socket*/
395 handleICMP4packet(is4);
397 if(FD_ISSET(is6,&sel) && ip_type==AF_INET6){
398 /*Data on the ICMPv6 socket*/
399 handleICMP6packet(is6);
401 gettimeofday(&t,NULL);
409 updateRequestPacket(sbuffer,&slen, seq);
418 void handleDCCPpacket(int rcv_socket, int send_socket){
420 unsigned char rbuffer[rlen];
421 ipaddr_ptr_t rcv_addr;
422 socklen_t rcv_addr_len;
423 struct dccp_hdr *dhdr;
424 struct dccp_hdr_reset *dhdr_re;
425 struct dccp_hdr_ext *dhdre;
426 struct dccp_hdr_response *dhdr_rp;
427 struct dccp_hdr_ack_bits *dhdr_sync;
431 /*Memory for socket address*/
432 rcv_addr_len=sizeof(struct sockaddr_storage);
433 rcv_addr.gen=malloc(rcv_addr_len);
434 if(rcv_addr.gen==NULL){
435 dbgprintf(0,"Error: Can't Allocate Memory!\n");
440 rcv_addr_len=sizeof(struct sockaddr_storage);
441 if((rlen=recvfrom(rcv_socket, &rbuffer, 1000,0,rcv_addr.gen,&rcv_addr_len))<0){
443 dbgprintf(0, "Error on receive from DCCP socket (%s)\n",strerror(errno));
450 if(rcv_addr.gen->sa_family!=ip_type){ //confirm IP type
451 dbgprintf(1, "DCCP packet on %s. Tossing.\n", (ip_type==AF_INET) ? "IPv4" : "IPv6");
456 if(rcv_addr.gen->sa_family==AF_INET){
458 if(memcmp(&rcv_addr.ipv4->sin_addr,&dest_addr.ipv4->sin_addr,
459 sizeof(dest_addr.ipv4->sin_addr))!=0){ //not from destination
460 dbgprintf(1,"DCCP packet from 3rd host\n");
464 if(rlen < sizeof(struct dccp_hdr)+sizeof(struct iphdr)){ //check packet size
466 dbgprintf(1, "Packet smaller than possible DCCP packet received on DCCP socket\n");
470 iph=(struct iphdr*)rbuffer;
471 ptr=rbuffer+iph->ihl*4;
474 if(memcmp(&rcv_addr.ipv6->sin6_addr, &dest_addr.ipv6->sin6_addr,
475 sizeof(dest_addr.ipv6->sin6_addr))!=0){ //not from destination
476 dbgprintf(1,"DCCP packet from 3rd host\n");
480 if(rlen < sizeof(struct dccp_hdr)){ //check packet size
482 dbgprintf(1, "Packet smaller than possible DCCP packet received on DCCP socket\n");
490 dhdr=(struct dccp_hdr*)ptr;
491 if(dhdr->dccph_sport!=htons(dest_port)){
492 dbgprintf(1,"DCCP packet with wrong Source Port (%i)\n", ntohs(dhdr->dccph_sport));
496 if(dhdr->dccph_dport!=htons(dest_port)){
497 dbgprintf(1,"DCCP packet with wrong Destination Port\n");
503 if(dhdr->dccph_type==DCCP_PKT_RESET){
504 if(rlen < (ptr-rbuffer)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_reset)){
505 dbgprintf(1, "Error: Reset packet too small!");
508 dhdr_re=(struct dccp_hdr_reset*)(ptr+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
511 if(dhdr_re->dccph_reset_code==DCCP_RESET_CODE_NO_CONNECTION){
512 logResponse(&rcv_addr, ntohl(dhdr_re->dccph_reset_ack.dccph_ack_nr_low), RESET);
514 logResponse(&rcv_addr, ntohl(dhdr_re->dccph_reset_ack.dccph_ack_nr_low), DCCP_ERROR);
516 /*Nothing else to do*/
518 if(dhdr->dccph_type==DCCP_PKT_RESPONSE){
519 if(rlen < (ptr-rbuffer)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_response)){
520 dbgprintf(1, "Error: Response packet too small!");
525 dhdre=(struct dccp_hdr_ext*)(ptr+sizeof(struct dccp_hdr));
526 dhdr_rp=(struct dccp_hdr_response*)(ptr+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
527 logResponse(&rcv_addr,ntohl(dhdr_rp->dccph_resp_ack.dccph_ack_nr_low),RESPONSE);
530 sendClose(ntohl(dhdr_rp->dccph_resp_ack.dccph_ack_nr_low),
531 dhdr->dccph_seq, dhdre->dccph_seq_low,send_socket);
533 if(dhdr->dccph_type==DCCP_PKT_SYNC || dhdr->dccph_type==DCCP_PKT_SYNCACK){
534 if(rlen < (ptr-rbuffer)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_ack_bits)){
535 dbgprintf(1, "Error: Response packet too small!");
540 dhdre=(struct dccp_hdr_ext*)(ptr+sizeof(struct dccp_hdr));
541 dhdr_sync=(struct dccp_hdr_ack_bits*)(ptr+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
542 logResponse(&rcv_addr,ntohl(dhdr_sync->dccph_ack_nr_low),SYNC);
545 sendReset(ntohl(dhdr_sync->dccph_ack_nr_low),
546 dhdr->dccph_seq, dhdre->dccph_seq_low,send_socket);
552 void handleICMP4packet(int rcv_socket){
554 unsigned char rbuffer[rlen];
555 ipaddr_ptr_t rcv_addr;
556 socklen_t rcv_addr_len;
557 struct icmphdr *icmp4;
558 struct dccp_hdr *dhdr;
559 struct dccp_hdr_ext *dhdre;
560 struct iphdr* ip4hdr;
563 /*Memory for socket address*/
564 rcv_addr_len=sizeof(struct sockaddr_storage);
565 rcv_addr.gen=malloc(rcv_addr_len);
566 if(rcv_addr.gen==NULL){
567 dbgprintf(0,"Error: Can't Allocate Memory!\n");
572 if((rlen=recvfrom(rcv_socket, &rbuffer, 1000,0,rcv_addr.gen,&rcv_addr_len))<0){
574 dbgprintf(0, "Error on receive from ICMPv4 socket (%s)\n",strerror(errno));
581 if(rlen < sizeof(struct icmphdr)){ //check packet size
582 dbgprintf(1, "Packet smaller than possible ICMPv4 packet!\n");
587 icmp4=(struct icmphdr*)rbuffer;
588 if(icmp4->type!=ICMP_DEST_UNREACH && icmp4->type!=ICMP_TIME_EXCEEDED){ //check icmp types
589 dbgprintf(1, "Tossing ICMPv4 packet of type %i\n", icmp4->type);
594 /*Check packet size again*/
595 if(rlen<sizeof(struct icmphdr)+sizeof(struct iphdr)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)){
596 dbgprintf(1, "Tossing ICMPv4 packet that's too small to contain DCCP header!\n");
601 /*Decode IPv4 header*/
602 ip4hdr=(struct iphdr*)(rbuffer+sizeof(struct icmphdr));
603 if(memcmp(&src_addr.ipv4->sin_addr,&ip4hdr->saddr,sizeof(src_addr.ipv4->sin_addr))!=0){
604 /*Source address doesn't match*/
605 dbgprintf(1,"Tossing ICMPv4 packet because the embedded IPv4 source address isn't us\n");
609 if(memcmp(&dest_addr.ipv4->sin_addr,&ip4hdr->daddr,sizeof(dest_addr.ipv4->sin_addr))!=0){
610 /*Destination address doesn't match*/
611 dbgprintf(1,"Tossing ICMPv4 packet because the embedded IPv4 destination address isn't our target\n");
615 if(ip4hdr->protocol!=IPPROTO_DCCP){
617 dbgprintf(1,"Tossing ICMPv4 packet because the embedded packet isn't DCCP\n");
622 /*Decode DCCP header*/
623 dhdr=(struct dccp_hdr*)(rbuffer+sizeof(struct icmphdr)+ip4hdr->ihl*4);
624 if(dhdr->dccph_dport!=htons(dest_port)){
625 /*DCCP Destination Ports don't match*/
626 dbgprintf(1,"Tossing ICMPv4 packet because the embedded packet doesn't have our DCCP destination port\n");
630 if(dhdr->dccph_sport!=htons(dest_port)){
631 /*DCCP Source Ports don't match*/
632 dbgprintf(1,"Tossing ICMPv4 packet because the embedded packet doesn't have our DCCP source port\n");
636 dhdre=(struct dccp_hdr_ext*)(rbuffer+sizeof(struct icmphdr)+ip4hdr->ihl*4+sizeof(struct dccp_hdr));
639 if(icmp4->type==ICMP_DEST_UNREACH){
640 type=DEST_UNREACHABLE;
642 if(icmp4->type==ICMP_TIME_EXCEEDED){
645 logResponse(&rcv_addr,ntohl(dhdre->dccph_seq_low),type);
650 void handleICMP6packet(int rcv_socket){
652 unsigned char rbuffer[rlen];
653 ipaddr_ptr_t rcv_addr;
654 socklen_t rcv_addr_len;
655 struct icmp6_hdr *icmp6;
656 struct ip6_hdr* ip6hdr;
657 struct dccp_hdr *dhdr;
658 struct dccp_hdr_ext *dhdre;
661 /*Memory for socket address*/
662 rcv_addr_len=sizeof(struct sockaddr_storage);
663 rcv_addr.gen=malloc(rcv_addr_len);
664 if(rcv_addr.gen==NULL){
665 dbgprintf(0,"Error: Can't Allocate Memory!\n");
670 if((rlen=recvfrom(rcv_socket, &rbuffer, 1000,0,rcv_addr.gen,&rcv_addr_len))<0){
671 dbgprintf(0, "Error on receive from ICMPv6 socket (%s)\n",strerror(errno));
674 if(rlen < sizeof(struct icmp6_hdr)){ //check packet size
675 dbgprintf(1, "Packet smaller than possible ICMPv6 packet!\n");
680 icmp6=(struct icmp6_hdr*)rbuffer;
681 if(icmp6->icmp6_type!=ICMP6_DST_UNREACH && icmp6->icmp6_type!=ICMP6_PACKET_TOO_BIG
682 && icmp6->icmp6_type!=ICMP6_TIME_EXCEEDED && icmp6->icmp6_type!=ICMP6_PARAM_PROB){ //check icmp types
683 dbgprintf(1, "Tossing ICMPv6 packet of type %i\n", icmp6->icmp6_type);
688 /*Check packet size again*/
689 if(rlen<sizeof(struct icmp6_hdr)+sizeof(struct ip6_hdr)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)){
690 dbgprintf(1, "Tossing ICMPv6 packet that's too small to contain DCCP header!\n");
695 /*Decode IPv6 header*/
696 ip6hdr=(struct ip6_hdr*)(rbuffer+sizeof(struct icmp6_hdr));
697 if(memcmp(&src_addr.ipv6->sin6_addr,&ip6hdr->ip6_src,sizeof(src_addr.ipv6->sin6_addr))!=0){
698 dbgprintf(1,"Tossing ICMPv6 packet because the embedded IPv6 source address isn't us\n");
699 /*Source address doesn't match*/
703 if(memcmp(&dest_addr.ipv6->sin6_addr,&ip6hdr->ip6_dst,sizeof(dest_addr.ipv6->sin6_addr))!=0){
704 /*Destination address doesn't match*/
705 dbgprintf(1,"Tossing ICMPv6 packet because the embedded IPv6 destination address isn't our target\n");
709 if(ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt!=IPPROTO_DCCP){
711 dbgprintf(1,"Tossing ICMPv6 packet because the embedded packet isn't DCCP\n");
716 /*Decode DCCP header*/
717 dhdr=(struct dccp_hdr*)(rbuffer+sizeof(struct icmp6_hdr)+sizeof(struct ip6_hdr));
718 if(dhdr->dccph_dport!=htons(dest_port)){
719 /*DCCP Destination Ports don't match*/
720 dbgprintf(1,"Tossing ICMPv6 packet because the embedded packet doesn't have our DCCP destination port\n");
724 if(dhdr->dccph_sport!=htons(dest_port)){
725 /*DCCP Source Ports don't match*/
726 dbgprintf(1,"Tossing ICMPv6 packet because the embedded packet doesn't have our DCCP source port\n");
730 dhdre=(struct dccp_hdr_ext*)(rbuffer+sizeof(struct icmp6_hdr)+sizeof(struct ip6_hdr)+sizeof(struct dccp_hdr));
733 if(icmp6->icmp6_type==ICMP6_DST_UNREACH){
734 type=DEST_UNREACHABLE;
736 if(icmp6->icmp6_type==ICMP6_PACKET_TOO_BIG){
739 if(icmp6->icmp6_type==ICMP6_TIME_EXCEEDED){
742 if(icmp6->icmp6_type==ICMP6_PARAM_PROB){
743 type=PARAMETER_PROBLEM;
745 logResponse(&rcv_addr,ntohl(dhdre->dccph_seq_low),type);
750 void buildRequestPacket(unsigned char* buffer, int *len, int seq){
751 struct dccp_hdr *dhdr;
752 struct dccp_hdr_ext *dhdre;
753 struct dccp_hdr_request *dhdrr;
754 struct iphdr* ip4hdr;
755 struct ip6_hdr* ip6hdr;
758 int dccp_hdr_len=sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_request);
760 if(*len < dccp_hdr_len+sizeof(struct ip6_hdr)){
761 dbgprintf(0, "Error: Insufficient buffer space\n");
765 memset(buffer, 0, *len);
769 if(ip_type==AF_INET){
770 ip_hdr_len=sizeof(struct iphdr);
771 ip4hdr=(struct iphdr*)buffer;
772 ip4hdr->check=htons(0);
773 memcpy(&ip4hdr->daddr, &dest_addr.ipv4->sin_addr, sizeof(dest_addr.ipv4->sin_addr));
774 ip4hdr->frag_off=htons(0);
775 ip4hdr->id=htons(1);//first
777 ip4hdr->protocol=IPPROTO_DCCP;
778 memcpy(&ip4hdr->saddr, &src_addr.ipv4->sin_addr, sizeof(src_addr.ipv4->sin_addr));
780 ip4hdr->tot_len=htons(ip_hdr_len+dccp_hdr_len);
784 ip_hdr_len=sizeof(struct ip6_hdr);
785 ip6hdr=(struct ip6_hdr*)buffer;
786 memcpy(&ip6hdr->ip6_dst, &dest_addr.ipv6->sin6_addr, sizeof(dest_addr.ipv6->sin6_addr));
787 memcpy(&ip6hdr->ip6_src, &src_addr.ipv6->sin6_addr, sizeof(src_addr.ipv6->sin6_addr));
788 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_flow=htonl(6<<28); //version, traffic class, flow label
789 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_hlim=ttl;
790 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt=IPPROTO_DCCP;
791 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_plen=htons(dccp_hdr_len);
795 dhdr=(struct dccp_hdr*)(buffer+ip_hdr_len);
796 dhdre=(struct dccp_hdr_ext*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr));
797 dhdrr=(struct dccp_hdr_request*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
799 dhdr->dccph_checksum=0;
801 dhdr->dccph_doff=dccp_hdr_len/4;
802 dhdr->dccph_dport=htons(dest_port);
803 dhdr->dccph_reserved=0;
804 dhdr->dccph_sport=htons(dest_port);
806 dhdr->dccph_type=DCCP_PKT_REQUEST;
807 dhdr->dccph_seq2=htonl(0); //Reserved if using 48 bit sequence numbers
808 dhdr->dccph_seq=htonl(0); //High 16bits of sequence number. Always make 0 for simplicity.
809 dhdre->dccph_seq_low=htonl(seq);
810 dhdrr->dccph_req_service= htonl(0x50455246);
813 if(ip_type==AF_INET){
814 dhdr->dccph_checksum=ipv4_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
815 (unsigned char*) &dest_addr.ipv4->sin_addr,
816 (unsigned char*)&src_addr.ipv4->sin_addr, IPPROTO_DCCP);
817 ip4hdr->check=ipv4_chksum(buffer,ip_hdr_len);
819 dhdr->dccph_checksum=ipv6_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
820 (unsigned char*) &dest_addr.ipv6->sin6_addr,
821 (unsigned char*)&src_addr.ipv6->sin6_addr, IPPROTO_DCCP);
823 *len=ip_hdr_len+dccp_hdr_len;
827 void updateRequestPacket(unsigned char* buffer, int *len, int seq){
828 struct dccp_hdr *dhdr;
829 struct dccp_hdr_ext *dhdre;
830 struct iphdr* ip4hdr;
833 int dccp_hdr_len=sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_request);
837 if(ip_type==AF_INET){
838 ip_hdr_len=sizeof(struct iphdr);
839 ip4hdr=(struct iphdr*)buffer;
840 ip4hdr->check=htons(0);
841 ip4hdr->id=htons(seq);
843 ip_hdr_len=sizeof(struct ip6_hdr);
847 dhdr=(struct dccp_hdr*)(buffer+ip_hdr_len);
848 dhdre=(struct dccp_hdr_ext*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr));
849 dhdr->dccph_checksum=0;
850 dhdre->dccph_seq_low=htonl(seq);
853 if(ip_type==AF_INET){
854 dhdr->dccph_checksum=ipv4_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
855 (unsigned char*) &dest_addr.ipv4->sin_addr,
856 (unsigned char*)&src_addr.ipv4->sin_addr, IPPROTO_DCCP);
857 ip4hdr->check=ipv4_chksum(buffer,ip_hdr_len);
859 dhdr->dccph_checksum=ipv6_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
860 (unsigned char*) &dest_addr.ipv6->sin6_addr,
861 (unsigned char*)&src_addr.ipv6->sin6_addr, IPPROTO_DCCP);
863 *len=ip_hdr_len+dccp_hdr_len;
867 void sendClose(int seq, u_int16_t ack_h, u_int32_t ack_l, int socket){
868 unsigned char buffer[1500];
869 struct dccp_hdr *dhdr;
870 struct dccp_hdr_ext *dhdre;
871 struct dccp_hdr_ack_bits *dhd_ack;
872 struct iphdr* ip4hdr;
873 struct ip6_hdr* ip6hdr;
878 int dccp_hdr_len=sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_ack_bits);
880 memset(buffer, 0, 1500);
884 if(ip_type==AF_INET){
885 ip_hdr_len=sizeof(struct iphdr);
886 ip4hdr=(struct iphdr*)buffer;
887 ip4hdr->check=htons(0);
888 memcpy(&ip4hdr->daddr, &dest_addr.ipv4->sin_addr, sizeof(dest_addr.ipv4->sin_addr));
889 ip4hdr->frag_off=htons(0);
890 ip4hdr->id=htons(1);//first
892 ip4hdr->protocol=IPPROTO_DCCP;
893 memcpy(&ip4hdr->saddr, &src_addr.ipv4->sin_addr, sizeof(src_addr.ipv4->sin_addr));
895 ip4hdr->tot_len=htons(ip_hdr_len+dccp_hdr_len);
899 ip_hdr_len=sizeof(struct ip6_hdr);
900 ip6hdr=(struct ip6_hdr*)buffer;
901 memcpy(&ip6hdr->ip6_dst, &dest_addr.ipv6->sin6_addr, sizeof(dest_addr.ipv6->sin6_addr));
902 memcpy(&ip6hdr->ip6_src, &src_addr.ipv6->sin6_addr, sizeof(src_addr.ipv6->sin6_addr));
903 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_flow=htonl(6<<28); //version, traffic class, flow label
904 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_hlim=ttl;
905 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt=IPPROTO_DCCP;
906 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_plen=htons(dccp_hdr_len);
910 dhdr=(struct dccp_hdr*)(buffer+ip_hdr_len);
911 dhdre=(struct dccp_hdr_ext*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr));
912 dhd_ack=(struct dccp_hdr_ack_bits*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
914 dhdr->dccph_checksum=0;
916 dhdr->dccph_doff=dccp_hdr_len/4;
917 dhdr->dccph_dport=htons(dest_port);
918 dhdr->dccph_reserved=0;
919 dhdr->dccph_sport=htons(dest_port);
921 dhdr->dccph_type=DCCP_PKT_CLOSE;
922 dhdr->dccph_seq2=htonl(0); //Reserved if using 48 bit sequence numbers
923 dhdr->dccph_seq=htonl(0); //High 16bits of sequence number. Always make 0 for simplicity.
924 dhdre->dccph_seq_low=htonl(seq+1);
925 dhd_ack->dccph_ack_nr_high=ack_h;
926 dhd_ack->dccph_ack_nr_low=ack_l;
929 if(ip_type==AF_INET){
930 dhdr->dccph_checksum=ipv4_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
931 (unsigned char*) &dest_addr.ipv4->sin_addr,
932 (unsigned char*)&src_addr.ipv4->sin_addr, IPPROTO_DCCP);
933 ip4hdr->check=ipv4_chksum(buffer,ip_hdr_len);
935 dhdr->dccph_checksum=ipv6_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
936 (unsigned char*) &dest_addr.ipv6->sin6_addr,
937 (unsigned char*)&src_addr.ipv6->sin6_addr, IPPROTO_DCCP);
939 len=ip_hdr_len+dccp_hdr_len;
942 if(ip_type==AF_INET){
943 addrlen=sizeof(struct sockaddr_in);
945 addrlen=sizeof(struct sockaddr_in6);
947 if(sendto(socket, &buffer, len, MSG_DONTWAIT,(struct sockaddr*)dest_addr.gen,addrlen)<0){
949 dbgprintf(0,"Error: sendto failed\n");
955 void sendReset(int seq, u_int16_t ack_h, u_int32_t ack_l, int socket){
956 unsigned char buffer[1500];
957 struct dccp_hdr *dhdr;
958 struct dccp_hdr_ext *dhdre;
959 struct dccp_hdr_reset *dh_re;
960 struct iphdr* ip4hdr;
961 struct ip6_hdr* ip6hdr;
966 int dccp_hdr_len=sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_reset);
968 memset(buffer, 0, 1500);
972 if(ip_type==AF_INET){
973 ip_hdr_len=sizeof(struct iphdr);
974 ip4hdr=(struct iphdr*)buffer;
975 ip4hdr->check=htons(0);
976 memcpy(&ip4hdr->daddr, &dest_addr.ipv4->sin_addr, sizeof(dest_addr.ipv4->sin_addr));
977 ip4hdr->frag_off=htons(0);
978 ip4hdr->id=htons(1);//first
980 ip4hdr->protocol=IPPROTO_DCCP;
981 memcpy(&ip4hdr->saddr, &src_addr.ipv4->sin_addr, sizeof(src_addr.ipv4->sin_addr));
983 ip4hdr->tot_len=htons(ip_hdr_len+dccp_hdr_len);
987 ip_hdr_len=sizeof(struct ip6_hdr);
988 ip6hdr=(struct ip6_hdr*)buffer;
989 memcpy(&ip6hdr->ip6_dst, &dest_addr.ipv6->sin6_addr, sizeof(dest_addr.ipv6->sin6_addr));
990 memcpy(&ip6hdr->ip6_src, &src_addr.ipv6->sin6_addr, sizeof(src_addr.ipv6->sin6_addr));
991 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_flow=htonl(6<<28); //version, traffic class, flow label
992 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_hlim=ttl;
993 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt=IPPROTO_DCCP;
994 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_plen=htons(dccp_hdr_len);
998 dhdr=(struct dccp_hdr*)(buffer+ip_hdr_len);
999 dhdre=(struct dccp_hdr_ext*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr));
1000 dh_re=(struct dccp_hdr_reset*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
1001 dhdr->dccph_ccval=0;
1002 dhdr->dccph_checksum=0;
1003 dhdr->dccph_cscov=0;
1004 dhdr->dccph_doff=dccp_hdr_len/4;
1005 dhdr->dccph_dport=htons(dest_port);
1006 dhdr->dccph_reserved=0;
1007 dhdr->dccph_sport=htons(dest_port);
1009 dhdr->dccph_type=DCCP_PKT_RESET;
1010 dhdr->dccph_seq2=htonl(0); //Reserved if using 48 bit sequence numbers
1011 dhdr->dccph_seq=htonl(0); //High 16bits of sequence number. Always make 0 for simplicity.
1012 dhdre->dccph_seq_low=htonl(seq+1);
1013 dh_re->dccph_reset_ack.dccph_ack_nr_high=ack_h;
1014 dh_re->dccph_reset_ack.dccph_ack_nr_low=ack_l;
1015 dh_re->dccph_reset_code=DCCP_RESET_CODE_CLOSED;
1016 dh_re->dccph_reset_data[0]=0;
1017 dh_re->dccph_reset_data[1]=0;
1018 dh_re->dccph_reset_data[2]=0;
1021 if(ip_type==AF_INET){
1022 dhdr->dccph_checksum=ipv4_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
1023 (unsigned char*) &dest_addr.ipv4->sin_addr,
1024 (unsigned char*)&src_addr.ipv4->sin_addr, IPPROTO_DCCP);
1025 ip4hdr->check=ipv4_chksum(buffer,ip_hdr_len);
1027 dhdr->dccph_checksum=ipv6_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
1028 (unsigned char*) &dest_addr.ipv6->sin6_addr,
1029 (unsigned char*)&src_addr.ipv6->sin6_addr, IPPROTO_DCCP);
1031 len=ip_hdr_len+dccp_hdr_len;
1034 if(ip_type==AF_INET){
1035 addrlen=sizeof(struct sockaddr_in);
1037 addrlen=sizeof(struct sockaddr_in6);
1039 if(sendto(socket, &buffer, len, MSG_DONTWAIT,(struct sockaddr*)dest_addr.gen,addrlen)<0){
1041 dbgprintf(0,"Error: sendto failed\n");
1047 int logPacket(int seq){
1048 struct request *tmp;
1050 /*Add new request to queue*/
1051 tmp=malloc(sizeof(struct request));
1053 dbgprintf(0,"Error: Can't allocate Memory!\n");
1061 tmp->reply_type=UNKNOWN;
1062 gettimeofday(&tmp->sent,NULL);
1064 if(queue.head==NULL){
1065 queue.head=queue.tail=tmp;
1067 queue.head->prev=tmp;
1068 tmp->next=queue.head;
1072 /*Update Statistics*/
1073 if(ping_stats.requests_sent==0){
1074 gettimeofday(&ping_stats.start,NULL);
1076 ping_stats.requests_sent++;
1080 int logResponse(ipaddr_ptr_t *src, int seq, int type){
1081 struct request *cur;
1085 if(queue.tail==NULL){
1086 dbgprintf(1,"Response received but no requests sent!\n");
1094 gettimeofday(&cur->reply,NULL);
1095 if(cur->num_replies>0){
1096 dbgprintf(0,"Duplicate packet detected! (%i)\n", seq);
1098 if(type<DEST_UNREACHABLE && type!=UNKNOWN){
1103 cur->reply_type=type;
1110 dbgprintf(1,"Response received but no requests sent with sequence number %i!\n", seq);
1114 diff=(cur->reply.tv_usec + 1000000*cur->reply.tv_sec) - (cur->sent.tv_usec + 1000000*cur->sent.tv_sec);
1118 if(type<DEST_UNREACHABLE && type!=UNKNOWN){
1119 if(ip_type==AF_INET){
1120 dbgprintf(0, "Response from %s : seq=%i time=%.1fms status=%s\n",
1121 inet_ntop(ip_type, (void*)&src->ipv4->sin_addr, pbuf, 1000),
1122 seq, diff,response_label[type]);
1124 dbgprintf(0, "Response from %s : seq=%i time=%.1fms status=%s\n",
1125 inet_ntop(ip_type, (void*)&src->ipv6->sin6_addr, pbuf, 1000),
1126 seq, diff,response_label[type]);
1129 if(ip_type==AF_INET){
1130 dbgprintf(0, "%s from %s : seq=%i\n",response_label[type],
1131 inet_ntop(ip_type, (void*)&src->ipv4->sin_addr, pbuf, 1000),
1134 dbgprintf(0, "%s from %s : seq=%i\n",response_label[type],
1135 inet_ntop(ip_type, (void*)&src->ipv6->sin6_addr, pbuf, 1000),
1140 /*Update statistics*/
1141 if(type<DEST_UNREACHABLE && type!=UNKNOWN){
1143 if(cur->num_replies==1){
1144 ping_stats.rtt_avg=((ping_stats.replies_received*ping_stats.rtt_avg)+(diff))/(ping_stats.replies_received+1);
1145 ping_stats.replies_received++;
1147 ping_stats.errors++;
1149 if(diff < ping_stats.rtt_min || ping_stats.rtt_min==0){
1150 ping_stats.rtt_min=diff;
1152 if(diff > ping_stats.rtt_max){
1153 ping_stats.rtt_max=diff;
1157 ping_stats.errors++;
1159 gettimeofday(&ping_stats.stop,NULL);
1164 struct request *cur;
1165 struct request *tmp;
1184 if(ip_type==AF_INET){
1185 dbgprintf(0,"-----------%s PING STATISTICS-----------\n",
1186 inet_ntop(ip_type, (void*)&dest_addr.ipv4->sin_addr, pbuf, 1000));
1187 }else if(ip_type==AF_INET6){
1188 dbgprintf(0,"-----------%s PING STATISTICS-----------\n",
1189 inet_ntop(ip_type, (void*)&dest_addr.ipv6->sin6_addr, pbuf, 1000));
1191 diff=(ping_stats.stop.tv_usec + 1000000*ping_stats.stop.tv_sec) -
1192 (ping_stats.start.tv_usec + 1000000*ping_stats.start.tv_sec);
1194 ploss=(1.0*(ping_stats.requests_sent-ping_stats.replies_received)/ping_stats.requests_sent*1.0)*100;
1195 dbgprintf(0,"%i packets transmitted, %i received, %i errors, %.2f%% loss, time %ims\n",
1196 ping_stats.requests_sent,ping_stats.replies_received,ping_stats.errors,
1198 dbgprintf(0,"rtt min/avg/max = %.1f/%.1f/%.1f ms\n",
1199 ping_stats.rtt_min,ping_stats.rtt_avg,ping_stats.rtt_max);
1206 /*Usage information for program*/
1209 dbgprintf(0, "dccpping: [-d] [-6|-4] [-c count] [-p port] [-i interval] [-t ttl] [-S srcaddress] remote_host\n");
1213 /*Program will probably be run setuid, so be extra careful*/
1214 void sanitize_environment()
1216 #if defined(_SVID_SOURCE) || defined(_XOPEN_SOURCE)
1219 extern char **environ;
1225 void dbgprintf(int level, const char *fmt, ...)
1229 va_start(args, fmt);
1230 vfprintf(stderr, fmt, args);