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 /*Use the DCCP source port to multiplex DCCP Ping streams by PID*/
34 #define SRC_PORT_AS_PID_MULTIPLEX 1
37 #define MAX(x,y) (x>y ? x : y)
41 /*Structure for simpler IPv4/IPv6 Address handling*/
44 struct sockaddr_in *ipv4;
45 struct sockaddr_in6 *ipv6;
48 /*Possible Responses to a Request*/
61 /*Output strings corresponding to enum responses*/
62 static const char* response_label[]= {
64 "Closed Port (Reset)",
65 "Open Port (Response)",
67 "Destination Unreachable",
70 "DCCP Not Supported (Parameter Problem)",
71 "Protocol Error (DCCP Reset)"
74 /*Structure to keep track of information about a request*/
82 enum responses reply_type;
87 /*Request Queue head structure*/
93 /*Statistics about the requests and replies sent*/
101 struct timeval start;
106 int count; /*Number of pings (-1 is infinity)*/
107 int dest_port; /*Destination port*/
108 int src_port; /*Source port---used to encode pid*/
110 long interval; /*Delay between pings in ms*/
111 int ip_type; /*IPv4 or IPv6*/
112 ipaddr_ptr_t dest_addr; /*Destination Address*/
113 ipaddr_ptr_t src_addr; /*Source Address*/
117 int debug=0; /*set to 1 to turn on debugging information*/
118 struct request_queue queue; /*Queue of requests to track RTT/duplicate information*/
119 struct stats ping_stats; /*Ping Statistics*/
120 struct params parms; /*Parameters for ping*/
123 void getAddresses(char *src, char* dst);
125 void handleDCCPpacket(int rcv_socket, int send_socket);
126 void handleICMP4packet(int rcv_socket);
127 void handleICMP6packet(int rcv_socket);
128 void buildRequestPacket(unsigned char* buffer, int *len, int seq);
129 void updateRequestPacket(unsigned char* buffer, int *len, int seq);
130 void sendClose(int seq, u_int16_t ack_h, u_int32_t ack_l, int socket);
131 void sendReset(int seq, u_int16_t ack_h, u_int32_t ack_l, int socket);
132 int logPacket(int req_seq, int packet_seq);
133 int logResponse(ipaddr_ptr_t *src, int seq, int type);
137 void sanitize_environment();
138 void dbgprintf(int level, const char *fmt, ...);
141 /*Parse commandline options*/
142 int main(int argc, char *argv[])
151 ping_stats.replies_received=0;
152 ping_stats.requests_sent=0;
153 ping_stats.rtt_avg=0;
154 ping_stats.rtt_max=0;
155 ping_stats.rtt_min=0;
158 parms.dest_port=33434;
160 parms. interval=1000;
161 parms.ip_type=AF_UNSPEC;
162 parms.dest_addr.gen=NULL;
163 parms.src_addr.gen=NULL;
165 sanitize_environment();
167 while ((c = getopt(argc, argv, "64c:p:i:dt:S:")) != -1) {
170 parms.ip_type=AF_INET6;
173 parms.ip_type=AF_INET;
176 parms.count = atoi(optarg);
178 dbgprintf(0, "Error: count must be positive");
183 parms.dest_port = atoi(optarg);
186 parms.interval = (long)(atof(optarg) * 1000.0);
187 if (parms.interval <= 0) {
188 dbgprintf(0, "Error: Invalid interval\n");
196 parms.ttl = atoi(optarg);
197 if (parms.ttl < 1 || parms.ttl > 255) {
198 dbgprintf(0,"Error: Invalid TTL\n");
218 #if SRC_PORT_AS_PID_MULTIPLEX
219 /*Encode PID in source port*/
220 parms.src_port=(getpid()+1024)%65535;
222 parms.src_port=parms.dest_port;
225 getAddresses(src, dst);
226 if(parms.src_addr.gen==NULL || parms.dest_addr.gen==NULL){
227 dbgprintf(0,"Error: Can't determine source or destination address\n");
231 signal(SIGINT, sigHandler);
234 free(parms.src_addr.gen);
235 free(parms.dest_addr.gen);
240 void getAddresses(char *src, char* dst){
241 struct addrinfo hint;
242 struct addrinfo *dtmp, *stmp;
243 struct ifaddrs *temp, *cur;
244 struct sockaddr_in6* iv6;
248 /*Lookup destination Address*/
249 memset(&hint,0,sizeof(struct addrinfo));
250 hint.ai_family=parms.ip_type;
251 hint.ai_flags=AI_V4MAPPED | AI_ADDRCONFIG;
253 if((err=getaddrinfo(dst,NULL,&hint,&dtmp))!=0){
254 dbgprintf(0,"Error: Couldn't lookup destination %s (%s)\n", dst, gai_strerror(err));
258 dbgprintf(0,"Error: Unknown Host %s\n", dst);
261 addrlen=dtmp->ai_addrlen;
262 hint.ai_family=parms.ip_type=dtmp->ai_family;
263 parms.dest_addr.gen=malloc(dtmp->ai_addrlen);
264 if(parms.dest_addr.gen==NULL){
265 dbgprintf(0,"Error: Can't allocate Memory\n");
268 memcpy(parms.dest_addr.gen,dtmp->ai_addr,dtmp->ai_addrlen);
272 /*Get a meaningful source address*/
274 /*Use Commandline arg*/
275 if((err=getaddrinfo(src,NULL,&hint,&stmp))!=0){
276 dbgprintf(0,"Error: Source Address %s is invalid (%s)\n", src, gai_strerror(err));
280 dbgprintf(0,"Error: Unknown Host %s\n", dst);
283 addrlen=stmp->ai_addrlen;
284 parms.src_addr.gen=malloc(stmp->ai_addrlen);
285 if(parms.src_addr.gen==NULL){
286 dbgprintf(0,"Error: Can't allocate Memory\n");
289 memcpy(parms.src_addr.gen,stmp->ai_addr,stmp->ai_addrlen);
293 /*Guess a good source address*/
297 if(cur->ifa_addr==NULL || cur->ifa_addr->sa_family!=parms.ip_type){
298 /*Not matching ipv4/ipv6 of dest*/
302 if(cur->ifa_flags & IFF_LOOPBACK){ /*Don't use loopback addresses*/
306 if(cur->ifa_addr!=NULL && cur->ifa_addr->sa_family==AF_INET6){
307 iv6=(struct sockaddr_in6*)cur->ifa_addr;
309 if(iv6->sin6_scope_id!=0){ /*Not globally valid address, if ipv6*/
315 parms.src_addr.gen=malloc(sizeof(struct sockaddr_storage));
316 if(parms.src_addr.gen==NULL){
317 dbgprintf(0,"Error: Can't allocate Memory\n");
320 parms.src_addr.gen->sa_family=parms.ip_type;
321 memcpy(parms.src_addr.gen,cur->ifa_addr,addrlen);
330 /*Preform the ping functionality*/
336 unsigned char sbuffer[slen];
338 struct timeval timeout;
339 struct timeval t,delay, add;
345 rs=socket(parms.ip_type, SOCK_RAW ,IPPROTO_RAW);
347 dbgprintf(0, "Error opening raw socket\n");
350 ds=socket(parms.ip_type, SOCK_RAW ,IPPROTO_DCCP);
352 dbgprintf(0, "Error opening raw DCCP socket\n");
355 is4=socket(parms.ip_type,SOCK_RAW,IPPROTO_ICMP);
357 dbgprintf(0,"Error opening raw ICMPv4 socket\n");
360 is6=socket(parms.ip_type,SOCK_RAW,IPPROTO_ICMPV6);
362 dbgprintf(0,"Error opening raw ICMPv6 socket\n");
367 /*Build DCCP packet*/
369 buildRequestPacket(sbuffer,&slen,packet_seq);
370 if(parms.ip_type==AF_INET){
371 addrlen=sizeof(struct sockaddr_in);
373 addrlen=sizeof(struct sockaddr_in6);
377 if(parms.ip_type==AF_INET){
378 printf("PINGING %s on DCCP port %i\n",
379 inet_ntop(parms.ip_type, (void*)&parms.dest_addr.ipv4->sin_addr, pbuf, 1000),
382 printf("PINGING %s on DCCP port %i\n",
383 inet_ntop(parms.ip_type, (void*)&parms.dest_addr.ipv6->sin6_addr, pbuf, 1000),
389 if(sendto(rs, &sbuffer, slen, MSG_DONTWAIT,(struct sockaddr*)parms.dest_addr.gen,addrlen)<0){
391 dbgprintf(0,"Error: sendto failed\n");
394 if(parms.count==0){done=1; break;}
396 if (logPacket(request_seq,packet_seq)<0){
397 dbgprintf(0,"Error: Couldn't record request!\n");
399 if(parms.ip_type==AF_INET){
400 dbgprintf(1, "Sending DCCP Request to %s\n",
401 inet_ntop(parms.ip_type, (void*)&parms.dest_addr.ipv4->sin_addr, pbuf, 1000));
403 dbgprintf(1, "Sending DCCP Request to %s\n",
404 inet_ntop(parms.ip_type, (void*)&parms.dest_addr.ipv6->sin6_addr, pbuf, 1000));
407 /*Use select to wait on packets or until interval has passed*/
408 add.tv_sec=parms.interval/1000;
409 add.tv_usec=(parms.interval%1000)*1000;
410 gettimeofday(&t,NULL);
411 timeradd(&t,&add,&delay);
412 while(timercmp(&t,&delay,<)){
413 /*Prepare for select*/
418 timersub(&delay,&t,&timeout);
421 if(select(MAX(ds+1,MAX(is4+1,is6+1)),&sel, NULL,NULL,&timeout)<0){
423 dbgprintf(0,"Select() error (%s)\n",strerror(errno));
426 if(parms.count==0){done=1;break;}
428 if(FD_ISSET(ds,&sel)){
429 /*Data on the DCCP socket*/
430 handleDCCPpacket(ds,rs);
433 if(FD_ISSET(is4,&sel) && parms.ip_type==AF_INET){
434 /*Data on the ICMPv4 socket*/
435 handleICMP4packet(is4);
437 if(FD_ISSET(is6,&sel) && parms.ip_type==AF_INET6){
438 /*Data on the ICMPv6 socket*/
439 handleICMP6packet(is6);
441 gettimeofday(&t,NULL);
450 updateRequestPacket(sbuffer,&slen, packet_seq);
459 void handleDCCPpacket(int rcv_socket, int send_socket){
461 unsigned char rbuffer[rlen];
462 ipaddr_ptr_t rcv_addr;
463 socklen_t rcv_addr_len;
464 struct dccp_hdr *dhdr;
465 struct dccp_hdr_reset *dhdr_re;
466 struct dccp_hdr_ext *dhdre;
467 struct dccp_hdr_response *dhdr_rp;
468 struct dccp_hdr_ack_bits *dhdr_sync;
472 /*Memory for socket address*/
473 rcv_addr_len=sizeof(struct sockaddr_storage);
474 rcv_addr.gen=malloc(rcv_addr_len);
475 if(rcv_addr.gen==NULL){
476 dbgprintf(0,"Error: Can't Allocate Memory!\n");
481 rcv_addr_len=sizeof(struct sockaddr_storage);
482 if((rlen=recvfrom(rcv_socket, &rbuffer, 1500,0,rcv_addr.gen,&rcv_addr_len))<0){
484 dbgprintf(0, "Error on receive from DCCP socket (%s)\n",strerror(errno));
491 if(rcv_addr.gen->sa_family!=parms.ip_type){ //confirm IP type
492 dbgprintf(1, "DCCP packet on %s. Tossing.\n", (parms.ip_type==AF_INET) ? "IPv4" : "IPv6");
497 if(rcv_addr.gen->sa_family==AF_INET){
499 if(memcmp(&rcv_addr.ipv4->sin_addr,&parms.dest_addr.ipv4->sin_addr,
500 sizeof(parms.dest_addr.ipv4->sin_addr))!=0){ //not from destination
501 dbgprintf(1,"DCCP packet from 3rd host\n");
505 if(rlen < sizeof(struct dccp_hdr)+sizeof(struct iphdr)){ //check packet size
507 dbgprintf(1, "Packet smaller than possible DCCP packet received on DCCP socket\n");
511 iph=(struct iphdr*)rbuffer;
512 ptr=rbuffer+iph->ihl*4;
515 if(memcmp(&rcv_addr.ipv6->sin6_addr, &parms.dest_addr.ipv6->sin6_addr,
516 sizeof(parms.dest_addr.ipv6->sin6_addr))!=0){ //not from destination
517 dbgprintf(1,"DCCP packet from 3rd host\n");
521 if(rlen < sizeof(struct dccp_hdr)){ //check packet size
523 dbgprintf(1, "Packet smaller than possible DCCP packet received on DCCP socket\n");
531 dhdr=(struct dccp_hdr*)ptr;
532 if(dhdr->dccph_sport!=htons(parms.dest_port)){
533 dbgprintf(1,"DCCP packet with wrong Source Port (%i)\n", ntohs(dhdr->dccph_sport));
537 if(dhdr->dccph_dport!=htons(parms.src_port)){
538 dbgprintf(1,"DCCP packet with wrong Destination Port\n");
544 if(dhdr->dccph_type==DCCP_PKT_RESET){
545 if(rlen < (ptr-rbuffer)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_reset)){
546 dbgprintf(1, "Tossing DCCP Reset packet that's small!\n");
549 dhdr_re=(struct dccp_hdr_reset*)(ptr+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
552 if(dhdr_re->dccph_reset_code==DCCP_RESET_CODE_NO_CONNECTION){
553 logResponse(&rcv_addr, ntohl(dhdr_re->dccph_reset_ack.dccph_ack_nr_low), RESET);
555 logResponse(&rcv_addr, ntohl(dhdr_re->dccph_reset_ack.dccph_ack_nr_low), DCCP_ERROR);
557 /*Nothing else to do*/
559 if(dhdr->dccph_type==DCCP_PKT_RESPONSE){
560 if(rlen < (ptr-rbuffer)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_response)){
561 dbgprintf(1, "Tossing DCCP Response packet that's too small!\n");
566 dhdre=(struct dccp_hdr_ext*)(ptr+sizeof(struct dccp_hdr));
567 dhdr_rp=(struct dccp_hdr_response*)(ptr+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
568 logResponse(&rcv_addr,ntohl(dhdr_rp->dccph_resp_ack.dccph_ack_nr_low),RESPONSE);
571 sendClose(ntohl(dhdr_rp->dccph_resp_ack.dccph_ack_nr_low),
572 dhdr->dccph_seq, dhdre->dccph_seq_low,send_socket);
574 if(dhdr->dccph_type==DCCP_PKT_SYNC || dhdr->dccph_type==DCCP_PKT_SYNCACK){
575 if(rlen < (ptr-rbuffer)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_ack_bits)){
576 dbgprintf(1, "Tossing DCCP Sync/SyncAck packet that's too small!\n");
581 dhdre=(struct dccp_hdr_ext*)(ptr+sizeof(struct dccp_hdr));
582 dhdr_sync=(struct dccp_hdr_ack_bits*)(ptr+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
583 logResponse(&rcv_addr,ntohl(dhdr_sync->dccph_ack_nr_low),SYNC);
586 sendReset(ntohl(dhdr_sync->dccph_ack_nr_low),
587 dhdr->dccph_seq, dhdre->dccph_seq_low,send_socket);
593 void handleICMP4packet(int rcv_socket){
595 unsigned char rbuffer[rlen];
596 ipaddr_ptr_t rcv_addr;
597 socklen_t rcv_addr_len;
598 struct icmphdr *icmp4;
599 struct dccp_hdr *dhdr;
600 struct dccp_hdr_ext *dhdre;
601 struct iphdr* ip4hdr;
605 /*Memory for socket address*/
606 rcv_addr_len=sizeof(struct sockaddr_storage);
607 rcv_addr.gen=malloc(rcv_addr_len);
608 if(rcv_addr.gen==NULL){
609 dbgprintf(0,"Error: Can't Allocate Memory!\n");
614 if((rlen=recvfrom(rcv_socket, &rbuffer, 1500,0,rcv_addr.gen,&rcv_addr_len))<0){
616 dbgprintf(0, "Error on receive from ICMPv4 socket (%s)\n",strerror(errno));
623 iph=(struct iphdr*)rbuffer;
626 if(rlen < sizeof(struct icmphdr)+sizeof(struct iphdr)){ //check packet size
627 dbgprintf(1, "Packet smaller than possible ICMPv4 packet!\n");
632 icmp4=(struct icmphdr*)(rbuffer+iph->ihl*4);
633 if(icmp4->type!=ICMP_DEST_UNREACH && icmp4->type!=ICMP_TIME_EXCEEDED){ //check icmp types
634 dbgprintf(1, "Tossing ICMPv4 packet of type %i\n", icmp4->type);
639 /*Check packet size again*/
640 if(rlen<sizeof(struct icmphdr)+2*sizeof(struct iphdr)+4){
641 dbgprintf(1, "Tossing ICMPv4 packet that's too small to contain DCCP header!\n");
646 /*Decode IPv4 header*/
647 ip4hdr=(struct iphdr*)(rbuffer+iph->ihl*4+sizeof(struct icmphdr));
648 if(memcmp(&parms.src_addr.ipv4->sin_addr,&ip4hdr->saddr,sizeof(parms.src_addr.ipv4->sin_addr))!=0){
649 /*Source address doesn't match*/
650 dbgprintf(1,"Tossing ICMPv4 packet because the embedded IPv4 source address isn't us\n");
654 if(memcmp(&parms.dest_addr.ipv4->sin_addr,&ip4hdr->daddr,sizeof(parms.dest_addr.ipv4->sin_addr))!=0){
655 /*Destination address doesn't match*/
656 dbgprintf(1,"Tossing ICMPv4 packet because the embedded IPv4 destination address isn't our target\n");
660 if(ip4hdr->protocol!=IPPROTO_DCCP){
662 dbgprintf(1,"Tossing ICMPv4 packet because the embedded packet isn't DCCP\n");
667 /*Decode DCCP header*/
668 dhdr=(struct dccp_hdr*)(rbuffer+iph->ihl*4+sizeof(struct icmphdr)+ip4hdr->ihl*4);
669 if(dhdr->dccph_dport!=htons(parms.dest_port)){
670 /*DCCP Destination Ports don't match*/
671 dbgprintf(1,"Tossing ICMPv4 packet because the embedded packet doesn't have our DCCP destination port\n");
675 if(dhdr->dccph_sport!=htons(parms.src_port)){
676 /*DCCP Source Ports don't match*/
677 dbgprintf(1,"Tossing ICMPv4 packet because the embedded packet doesn't have our DCCP source port\n");
681 dhdre=(struct dccp_hdr_ext*)(rbuffer+iph->ihl*4+sizeof(struct icmphdr)+ip4hdr->ihl*4+sizeof(struct dccp_hdr));
684 if(icmp4->type==ICMP_DEST_UNREACH){
685 type=DEST_UNREACHABLE;
687 if(icmp4->type==ICMP_TIME_EXCEEDED){
690 if(rlen<sizeof(struct icmphdr)+2*sizeof(struct iphdr)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)){
691 logResponse(&rcv_addr,-1,type);
693 logResponse(&rcv_addr,ntohl(dhdre->dccph_seq_low),type);
699 void handleICMP6packet(int rcv_socket){
701 unsigned char rbuffer[rlen];
702 ipaddr_ptr_t rcv_addr;
703 socklen_t rcv_addr_len;
704 struct icmp6_hdr *icmp6;
705 struct ip6_hdr* ip6hdr;
706 struct dccp_hdr *dhdr;
707 struct dccp_hdr_ext *dhdre;
710 /*Memory for socket address*/
711 rcv_addr_len=sizeof(struct sockaddr_storage);
712 rcv_addr.gen=malloc(rcv_addr_len);
713 if(rcv_addr.gen==NULL){
714 dbgprintf(0,"Error: Can't Allocate Memory!\n");
719 if((rlen=recvfrom(rcv_socket, &rbuffer, 1500,0,rcv_addr.gen,&rcv_addr_len))<0){
720 dbgprintf(0, "Error on receive from ICMPv6 socket (%s)\n",strerror(errno));
723 if(rlen < sizeof(struct icmp6_hdr)){ //check packet size
724 dbgprintf(1, "Packet smaller than possible ICMPv6 packet!\n");
729 icmp6=(struct icmp6_hdr*)rbuffer;
730 if(icmp6->icmp6_type!=ICMP6_DST_UNREACH && icmp6->icmp6_type!=ICMP6_PACKET_TOO_BIG
731 && icmp6->icmp6_type!=ICMP6_TIME_EXCEEDED && icmp6->icmp6_type!=ICMP6_PARAM_PROB){ //check icmp types
732 dbgprintf(1, "Tossing ICMPv6 packet of type %i\n", icmp6->icmp6_type);
737 /*Check packet size again*/
738 if(rlen<sizeof(struct icmp6_hdr)+sizeof(struct ip6_hdr)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)){
739 dbgprintf(1, "Tossing ICMPv6 packet that's too small to contain DCCP header!\n");
744 /*Decode IPv6 header*/
745 ip6hdr=(struct ip6_hdr*)(rbuffer+sizeof(struct icmp6_hdr));
746 if(memcmp(&parms.src_addr.ipv6->sin6_addr,&ip6hdr->ip6_src,sizeof(parms.src_addr.ipv6->sin6_addr))!=0){
747 dbgprintf(1,"Tossing ICMPv6 packet because the embedded IPv6 source address isn't us\n");
748 /*Source address doesn't match*/
752 if(memcmp(&parms.dest_addr.ipv6->sin6_addr,&ip6hdr->ip6_dst,sizeof(parms.dest_addr.ipv6->sin6_addr))!=0){
753 /*Destination address doesn't match*/
754 dbgprintf(1,"Tossing ICMPv6 packet because the embedded IPv6 destination address isn't our target\n");
758 if(ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt!=IPPROTO_DCCP){
760 dbgprintf(1,"Tossing ICMPv6 packet because the embedded packet isn't DCCP\n");
765 /*Decode DCCP header*/
766 dhdr=(struct dccp_hdr*)(rbuffer+sizeof(struct icmp6_hdr)+sizeof(struct ip6_hdr));
767 if(dhdr->dccph_dport!=htons(parms.dest_port)){
768 /*DCCP Destination Ports don't match*/
769 dbgprintf(1,"Tossing ICMPv6 packet because the embedded packet doesn't have our DCCP destination port\n");
773 if(dhdr->dccph_sport!=htons(parms.src_port)){
774 /*DCCP Source Ports don't match*/
775 dbgprintf(1,"Tossing ICMPv6 packet because the embedded packet doesn't have our DCCP source port\n");
779 dhdre=(struct dccp_hdr_ext*)(rbuffer+sizeof(struct icmp6_hdr)+sizeof(struct ip6_hdr)+sizeof(struct dccp_hdr));
782 if(icmp6->icmp6_type==ICMP6_DST_UNREACH){
783 type=DEST_UNREACHABLE;
785 if(icmp6->icmp6_type==ICMP6_PACKET_TOO_BIG){
788 if(icmp6->icmp6_type==ICMP6_TIME_EXCEEDED){
791 if(icmp6->icmp6_type==ICMP6_PARAM_PROB){
792 type=PARAMETER_PROBLEM;
794 logResponse(&rcv_addr,ntohl(dhdre->dccph_seq_low),type);
799 void buildRequestPacket(unsigned char* buffer, int *len, int seq){
800 struct dccp_hdr *dhdr;
801 struct dccp_hdr_ext *dhdre;
802 struct dccp_hdr_request *dhdrr;
803 struct iphdr* ip4hdr;
804 struct ip6_hdr* ip6hdr;
807 int dccp_hdr_len=sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_request);
809 if(*len < dccp_hdr_len+sizeof(struct ip6_hdr)){
810 dbgprintf(0, "Error: Insufficient buffer space\n");
814 memset(buffer, 0, *len);
818 if(parms.ip_type==AF_INET){
819 ip_hdr_len=sizeof(struct iphdr);
820 ip4hdr=(struct iphdr*)buffer;
821 ip4hdr->check=htons(0);
822 memcpy(&ip4hdr->daddr, &parms.dest_addr.ipv4->sin_addr, sizeof(parms.dest_addr.ipv4->sin_addr));
823 ip4hdr->frag_off=htons(0);
824 ip4hdr->id=htons(1);//first
826 ip4hdr->protocol=IPPROTO_DCCP;
827 memcpy(&ip4hdr->saddr, &parms.src_addr.ipv4->sin_addr, sizeof(parms.src_addr.ipv4->sin_addr));
829 ip4hdr->tot_len=htons(ip_hdr_len+dccp_hdr_len);
830 ip4hdr->ttl=parms.ttl;
833 ip_hdr_len=sizeof(struct ip6_hdr);
834 ip6hdr=(struct ip6_hdr*)buffer;
835 memcpy(&ip6hdr->ip6_dst, &parms.dest_addr.ipv6->sin6_addr, sizeof(parms.dest_addr.ipv6->sin6_addr));
836 memcpy(&ip6hdr->ip6_src, &parms.src_addr.ipv6->sin6_addr, sizeof(parms.src_addr.ipv6->sin6_addr));
837 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_flow=htonl(6<<28); //version, traffic class, flow label
838 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_hlim=parms.ttl;
839 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt=IPPROTO_DCCP;
840 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_plen=htons(dccp_hdr_len);
844 dhdr=(struct dccp_hdr*)(buffer+ip_hdr_len);
845 dhdre=(struct dccp_hdr_ext*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr));
846 dhdrr=(struct dccp_hdr_request*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
848 dhdr->dccph_checksum=0;
850 dhdr->dccph_doff=dccp_hdr_len/4;
851 dhdr->dccph_dport=htons(parms.dest_port);
852 dhdr->dccph_reserved=0;
853 dhdr->dccph_sport=htons(parms.src_port);
855 dhdr->dccph_type=DCCP_PKT_REQUEST;
856 dhdr->dccph_seq2=htonl(0); //Reserved if using 48 bit sequence numbers
857 dhdr->dccph_seq=htonl(0); //High 16bits of sequence number. Always make 0 for simplicity.
858 dhdre->dccph_seq_low=htonl(seq);
859 dhdrr->dccph_req_service= htonl(0x50455246);
862 if(parms.ip_type==AF_INET){
863 dhdr->dccph_checksum=ipv4_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
864 (unsigned char*) &parms.dest_addr.ipv4->sin_addr,
865 (unsigned char*)&parms.src_addr.ipv4->sin_addr, IPPROTO_DCCP);
866 ip4hdr->check=ipv4_chksum(buffer,ip_hdr_len);
868 dhdr->dccph_checksum=ipv6_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
869 (unsigned char*) &parms.dest_addr.ipv6->sin6_addr,
870 (unsigned char*)&parms.src_addr.ipv6->sin6_addr, IPPROTO_DCCP);
872 *len=ip_hdr_len+dccp_hdr_len;
876 void updateRequestPacket(unsigned char* buffer, int *len, int seq){
877 struct dccp_hdr *dhdr;
878 struct dccp_hdr_ext *dhdre;
879 struct iphdr* ip4hdr;
882 int dccp_hdr_len=sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_request);
886 if(parms.ip_type==AF_INET){
887 ip_hdr_len=sizeof(struct iphdr);
888 ip4hdr=(struct iphdr*)buffer;
889 ip4hdr->check=htons(0);
890 ip4hdr->id=htons(seq);
892 ip_hdr_len=sizeof(struct ip6_hdr);
896 dhdr=(struct dccp_hdr*)(buffer+ip_hdr_len);
897 dhdre=(struct dccp_hdr_ext*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr));
898 dhdr->dccph_checksum=0;
899 dhdre->dccph_seq_low=htonl(seq);
902 if(parms.ip_type==AF_INET){
903 dhdr->dccph_checksum=ipv4_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
904 (unsigned char*) &parms.dest_addr.ipv4->sin_addr,
905 (unsigned char*)&parms.src_addr.ipv4->sin_addr, IPPROTO_DCCP);
906 ip4hdr->check=ipv4_chksum(buffer,ip_hdr_len);
908 dhdr->dccph_checksum=ipv6_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
909 (unsigned char*) &parms.dest_addr.ipv6->sin6_addr,
910 (unsigned char*)&parms.src_addr.ipv6->sin6_addr, IPPROTO_DCCP);
912 *len=ip_hdr_len+dccp_hdr_len;
916 void sendClose(int seq, u_int16_t ack_h, u_int32_t ack_l, int socket){
917 unsigned char buffer[1500];
918 struct dccp_hdr *dhdr;
919 struct dccp_hdr_ext *dhdre;
920 struct dccp_hdr_ack_bits *dhd_ack;
921 struct iphdr* ip4hdr;
922 struct ip6_hdr* ip6hdr;
927 int dccp_hdr_len=sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_ack_bits);
929 memset(buffer, 0, 1500);
933 if(parms.ip_type==AF_INET){
934 ip_hdr_len=sizeof(struct iphdr);
935 ip4hdr=(struct iphdr*)buffer;
936 ip4hdr->check=htons(0);
937 memcpy(&ip4hdr->daddr, &parms.dest_addr.ipv4->sin_addr, sizeof(parms.dest_addr.ipv4->sin_addr));
938 ip4hdr->frag_off=htons(0);
939 ip4hdr->id=htons(1);//first
941 ip4hdr->protocol=IPPROTO_DCCP;
942 memcpy(&ip4hdr->saddr, &parms.src_addr.ipv4->sin_addr, sizeof(parms.src_addr.ipv4->sin_addr));
944 ip4hdr->tot_len=htons(ip_hdr_len+dccp_hdr_len);
945 ip4hdr->ttl=parms.ttl;
948 ip_hdr_len=sizeof(struct ip6_hdr);
949 ip6hdr=(struct ip6_hdr*)buffer;
950 memcpy(&ip6hdr->ip6_dst, &parms.dest_addr.ipv6->sin6_addr, sizeof(parms.dest_addr.ipv6->sin6_addr));
951 memcpy(&ip6hdr->ip6_src, &parms.src_addr.ipv6->sin6_addr, sizeof(parms.src_addr.ipv6->sin6_addr));
952 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_flow=htonl(6<<28); //version, traffic class, flow label
953 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_hlim=parms.ttl;
954 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt=IPPROTO_DCCP;
955 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_plen=htons(dccp_hdr_len);
959 dhdr=(struct dccp_hdr*)(buffer+ip_hdr_len);
960 dhdre=(struct dccp_hdr_ext*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr));
961 dhd_ack=(struct dccp_hdr_ack_bits*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
963 dhdr->dccph_checksum=0;
965 dhdr->dccph_doff=dccp_hdr_len/4;
966 dhdr->dccph_dport=htons(parms.dest_port);
967 dhdr->dccph_reserved=0;
968 dhdr->dccph_sport=htons(parms.src_port);
970 dhdr->dccph_type=DCCP_PKT_CLOSE;
971 dhdr->dccph_seq2=htonl(0); //Reserved if using 48 bit sequence numbers
972 dhdr->dccph_seq=htonl(0); //High 16bits of sequence number. Always make 0 for simplicity.
973 dhdre->dccph_seq_low=htonl(seq+1);
974 dhd_ack->dccph_ack_nr_high=ack_h;
975 dhd_ack->dccph_ack_nr_low=ack_l;
978 if(parms.ip_type==AF_INET){
979 dhdr->dccph_checksum=ipv4_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
980 (unsigned char*) &parms.dest_addr.ipv4->sin_addr,
981 (unsigned char*)&parms.src_addr.ipv4->sin_addr, IPPROTO_DCCP);
982 ip4hdr->check=ipv4_chksum(buffer,ip_hdr_len);
984 dhdr->dccph_checksum=ipv6_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
985 (unsigned char*) &parms.dest_addr.ipv6->sin6_addr,
986 (unsigned char*)&parms.src_addr.ipv6->sin6_addr, IPPROTO_DCCP);
988 len=ip_hdr_len+dccp_hdr_len;
991 if(parms.ip_type==AF_INET){
992 addrlen=sizeof(struct sockaddr_in);
994 addrlen=sizeof(struct sockaddr_in6);
996 if(sendto(socket, &buffer, len, MSG_DONTWAIT,(struct sockaddr*)parms.dest_addr.gen,addrlen)<0){
998 dbgprintf(0,"Error: sendto failed\n");
1004 void sendReset(int seq, u_int16_t ack_h, u_int32_t ack_l, int socket){
1005 unsigned char buffer[1500];
1006 struct dccp_hdr *dhdr;
1007 struct dccp_hdr_ext *dhdre;
1008 struct dccp_hdr_reset *dh_re;
1009 struct iphdr* ip4hdr;
1010 struct ip6_hdr* ip6hdr;
1015 int dccp_hdr_len=sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_reset);
1017 memset(buffer, 0, 1500);
1021 if(parms.ip_type==AF_INET){
1022 ip_hdr_len=sizeof(struct iphdr);
1023 ip4hdr=(struct iphdr*)buffer;
1024 ip4hdr->check=htons(0);
1025 memcpy(&ip4hdr->daddr, &parms.dest_addr.ipv4->sin_addr, sizeof(parms.dest_addr.ipv4->sin_addr));
1026 ip4hdr->frag_off=htons(0);
1027 ip4hdr->id=htons(1);//first
1029 ip4hdr->protocol=IPPROTO_DCCP;
1030 memcpy(&ip4hdr->saddr, &parms.src_addr.ipv4->sin_addr, sizeof(parms.src_addr.ipv4->sin_addr));
1032 ip4hdr->tot_len=htons(ip_hdr_len+dccp_hdr_len);
1033 ip4hdr->ttl=parms.ttl;
1036 ip_hdr_len=sizeof(struct ip6_hdr);
1037 ip6hdr=(struct ip6_hdr*)buffer;
1038 memcpy(&ip6hdr->ip6_dst, &parms.dest_addr.ipv6->sin6_addr, sizeof(parms.dest_addr.ipv6->sin6_addr));
1039 memcpy(&ip6hdr->ip6_src, &parms.src_addr.ipv6->sin6_addr, sizeof(parms.src_addr.ipv6->sin6_addr));
1040 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_flow=htonl(6<<28); //version, traffic class, flow label
1041 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_hlim=parms.ttl;
1042 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt=IPPROTO_DCCP;
1043 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_plen=htons(dccp_hdr_len);
1047 dhdr=(struct dccp_hdr*)(buffer+ip_hdr_len);
1048 dhdre=(struct dccp_hdr_ext*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr));
1049 dh_re=(struct dccp_hdr_reset*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
1050 dhdr->dccph_ccval=0;
1051 dhdr->dccph_checksum=0;
1052 dhdr->dccph_cscov=0;
1053 dhdr->dccph_doff=dccp_hdr_len/4;
1054 dhdr->dccph_dport=htons(parms.dest_port);
1055 dhdr->dccph_reserved=0;
1056 dhdr->dccph_sport=htons(parms.src_port);
1058 dhdr->dccph_type=DCCP_PKT_RESET;
1059 dhdr->dccph_seq2=htonl(0); //Reserved if using 48 bit sequence numbers
1060 dhdr->dccph_seq=htonl(0); //High 16bits of sequence number. Always make 0 for simplicity.
1061 dhdre->dccph_seq_low=htonl(seq+1);
1062 dh_re->dccph_reset_ack.dccph_ack_nr_high=ack_h;
1063 dh_re->dccph_reset_ack.dccph_ack_nr_low=ack_l;
1064 dh_re->dccph_reset_code=DCCP_RESET_CODE_CLOSED;
1065 dh_re->dccph_reset_data[0]=0;
1066 dh_re->dccph_reset_data[1]=0;
1067 dh_re->dccph_reset_data[2]=0;
1070 if(parms.ip_type==AF_INET){
1071 dhdr->dccph_checksum=ipv4_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
1072 (unsigned char*) &parms.dest_addr.ipv4->sin_addr,
1073 (unsigned char*)&parms.src_addr.ipv4->sin_addr, IPPROTO_DCCP);
1074 ip4hdr->check=ipv4_chksum(buffer,ip_hdr_len);
1076 dhdr->dccph_checksum=ipv6_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
1077 (unsigned char*) &parms.dest_addr.ipv6->sin6_addr,
1078 (unsigned char*)&parms.src_addr.ipv6->sin6_addr, IPPROTO_DCCP);
1080 len=ip_hdr_len+dccp_hdr_len;
1083 if(parms.ip_type==AF_INET){
1084 addrlen=sizeof(struct sockaddr_in);
1086 addrlen=sizeof(struct sockaddr_in6);
1088 if(sendto(socket, &buffer, len, MSG_DONTWAIT,(struct sockaddr*)parms.dest_addr.gen,addrlen)<0){
1090 dbgprintf(0,"Error: sendto failed\n");
1096 int logPacket(int req_seq, int packet_seq){
1097 struct request *tmp;
1099 /*Add new request to queue*/
1100 tmp=malloc(sizeof(struct request));
1102 dbgprintf(0,"Error: Can't allocate Memory!\n");
1109 tmp->packet_seq=packet_seq;
1110 tmp->request_seq=req_seq;
1111 tmp->reply_type=UNKNOWN;
1112 gettimeofday(&tmp->sent,NULL);
1114 if(queue.head==NULL){
1115 queue.head=queue.tail=tmp;
1117 queue.head->prev=tmp;
1118 tmp->next=queue.head;
1122 /*Update Statistics*/
1123 if(ping_stats.requests_sent==0){
1124 gettimeofday(&ping_stats.start,NULL);
1126 ping_stats.requests_sent++;
1130 int logResponse(ipaddr_ptr_t *src, int seq, int type){
1131 struct request *cur;
1135 if(queue.tail==NULL){
1136 dbgprintf(1,"Response received but no requests sent!\n");
1143 if(cur->packet_seq==seq){
1144 gettimeofday(&cur->reply,NULL);
1145 if(cur->num_replies>0){
1146 printf("Duplicate packet detected! (%i)\n",cur->request_seq);
1148 if(type<DEST_UNREACHABLE && type!=UNKNOWN){
1153 cur->reply_type=type;
1160 if(parms.ip_type==AF_INET && seq==-1){
1161 /*IPv4 didn't include enough of the packet to get sequence numbers!*/
1162 printf("%s from %s\n",response_label[type],
1163 inet_ntop(parms.ip_type, (void*)&src->ipv4->sin_addr, pbuf, 1000));
1164 ping_stats.errors++;
1167 dbgprintf(1,"Response received but no requests sent with sequence number %i!\n", seq);
1172 diff=(cur->reply.tv_usec + 1000000*cur->reply.tv_sec) - (cur->sent.tv_usec + 1000000*cur->sent.tv_sec);
1176 if(type<DEST_UNREACHABLE && type!=UNKNOWN){
1177 if(parms.ip_type==AF_INET){
1178 printf( "Response from %s : seq=%i time=%.1fms status=%s\n",
1179 inet_ntop(parms.ip_type, (void*)&src->ipv4->sin_addr, pbuf, 1000),
1180 cur->request_seq, diff,response_label[type]);
1182 printf("Response from %s : seq=%i time=%.1fms status=%s\n",
1183 inet_ntop(parms.ip_type, (void*)&src->ipv6->sin6_addr, pbuf, 1000),
1184 cur->request_seq, diff,response_label[type]);
1187 if(parms.ip_type==AF_INET){
1188 printf("%s from %s : seq=%i\n",response_label[type],
1189 inet_ntop(parms.ip_type, (void*)&src->ipv4->sin_addr, pbuf, 1000),
1192 printf("%s from %s : seq=%i\n",response_label[type],
1193 inet_ntop(parms.ip_type, (void*)&src->ipv6->sin6_addr, pbuf, 1000),
1198 /*Update statistics*/
1199 if(type<DEST_UNREACHABLE && type!=UNKNOWN){
1201 if(cur->num_replies==1){
1202 ping_stats.rtt_avg=((ping_stats.replies_received*ping_stats.rtt_avg)+(diff))/(ping_stats.replies_received+1);
1203 ping_stats.replies_received++;
1205 ping_stats.errors++;
1207 if(diff < ping_stats.rtt_min || ping_stats.rtt_min==0){
1208 ping_stats.rtt_min=diff;
1210 if(diff > ping_stats.rtt_max){
1211 ping_stats.rtt_max=diff;
1215 ping_stats.errors++;
1217 gettimeofday(&ping_stats.stop,NULL);
1222 struct request *cur;
1223 struct request *tmp;
1242 gettimeofday(&ping_stats.stop,NULL);
1243 if(parms.ip_type==AF_INET){
1244 printf("-----------%s PING STATISTICS-----------\n",
1245 inet_ntop(parms.ip_type, (void*)&parms.dest_addr.ipv4->sin_addr, pbuf, 1000));
1246 }else if(parms.ip_type==AF_INET6){
1247 printf("-----------%s PING STATISTICS-----------\n",
1248 inet_ntop(parms.ip_type, (void*)&parms.dest_addr.ipv6->sin6_addr, pbuf, 1000));
1250 diff=(ping_stats.stop.tv_usec + 1000000*ping_stats.stop.tv_sec) -
1251 (ping_stats.start.tv_usec + 1000000*ping_stats.start.tv_sec);
1253 ploss=(1.0*(ping_stats.requests_sent-ping_stats.replies_received)/ping_stats.requests_sent*1.0)*100;
1254 printf("%i packets transmitted, %i received, %i errors, %.2f%% loss, time %ims\n",
1255 ping_stats.requests_sent,ping_stats.replies_received,ping_stats.errors,
1257 printf("rtt min/avg/max = %.1f/%.1f/%.1f ms\n",
1258 ping_stats.rtt_min,ping_stats.rtt_avg,ping_stats.rtt_max);
1265 /*Usage information for program*/
1268 dbgprintf(0, "dccpping: [-d] [-6|-4] [-c count] [-p port] [-i interval] [-t ttl] [-S srcaddress] remote_host\n");
1272 /*Program will probably be run setuid, so be extra careful*/
1273 void sanitize_environment()
1275 #if defined(_SVID_SOURCE) || defined(_XOPEN_SOURCE)
1278 extern char **environ;
1284 void dbgprintf(int level, const char *fmt, ...)
1288 va_start(args, fmt);
1289 vfprintf(stderr, fmt, args);