sjero.net Git - dccpping/blob - dccpping.c

   1 /******************************************************************************
   2 Author: Samuel Jero <sj323707@ohio.edu>
   3
   4 Date: 10/2012
   5
   6 Description: Program to ping hosts using DCCP REQ packets to test for DCCP connectivity.
   7 ******************************************************************************/
   8 #include <stdarg.h>
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <strings.h>
  13 #include <unistd.h>
  14 #include <errno.h>
  15 #include <sys/types.h>
  16 #include <sys/time.h>
  17 #include <sys/socket.h>
  18 #include <sys/select.h>
  19 #include <netinet/ip.h>
  20 #include <netinet/ip6.h>
  21 #include <netinet/in.h>
  22 #include <netinet/ip_icmp.h>
  23 #include <netinet/icmp6.h>
  24 #include <arpa/inet.h>
  25 #include <netdb.h>
  26 #include <net/if.h>
  27 #include <ifaddrs.h>
  28 #include <linux/dccp.h>
  29 #include "checksums.h"
  30
  31
  32 #define MAX(x,y) (x>y ? x : y)
  33 /*Structure for simpler IPv4/IPv6 Address handling*/
  34 typedef union ipaddr{
  35         struct sockaddr *gen;
  36         struct sockaddr_in *ipv4;
  37         struct sockaddr_in6 *ipv6;
  38 } ipaddr_ptr_t;
  39
  40 enum responses{
  41         UNKNOWN=0,
  42         RESET,
  43         RESPONSE,
  44         SYNC,
  45         DEST_UNREACHABLE,
  46         TTL_EXPIRATION,
  47         TOO_BIG,
  48         PARAMETER_PROBLEM
  49 };
  50 char* response_label[]= {
  51 "Unknown",
  52 "Closed Port (Reset)",
  53 "Open Port (Response)",
  54 "Open Port (Sync)",
  55 "Destination Unreachable",
  56 "TTL Expiration",
  57 "Packet Too Big",
  58 "DCCP Not Supported (Parameter Problem)"
  59 };
  60
  61
  62 struct request{
  63         int                             seq;
  64         int                             num_replies;
  65         int                             num_errors;
  66         struct timeval  sent;
  67         struct timeval  reply;
  68         enum responses  reply_type;
  69         struct request  *next;
  70         struct request  *prev;
  71 };
  72
  73 struct stats{
  74         int                             requests_sent;
  75         int                             replies_received;
  76         int                             errors;
  77         double                  rtt_min;
  78         double                  rtt_avg;
  79         double                  rtt_max;
  80         struct timeval  start;
  81         struct timeval  stop;
  82 };
  83
  84 struct request_queue{
  85         struct request *head;
  86         struct request *tail;
  87 };
  88
  89
  90 int debug=0;                    /*set to 1 to turn on debugging information*/
  91 int count=-1;                   /*Default number of pings (-1 is infinity)*/
  92 int dest_port=33434;    /*Default port*/
  93 int ttl=64;                             /*Default TTL*/
  94 long interval=1000;             /*Default delay between pings in ms*/
  95 int ip_type=AF_UNSPEC;  /*IPv4 or IPv6*/
  96 ipaddr_ptr_t dest_addr; /*Destination Address*/
  97 ipaddr_ptr_t src_addr;  /*Source Address*/
  98 struct request_queue    queue;
  99 struct stats                    ping_stats;
 100 extern int errno;
 101
 102
 103 void getAddresses(char *src, char* dst);
 104 void doping();
 105 void handleDCCPpacket(int rcv_socket, int send_socket);
 106 void handleICMP4packet(int rcv_socket);
 107 void handleICMP6packet(int rcv_socket);
 108 void buildRequestPacket(unsigned char* buffer, int *len, int seq);
 109 void updateRequestPacket(unsigned char* buffer, int *len, int seq);
 110 int logPacket(int seq);
 111 int logResponse(ipaddr_ptr_t *src, int seq, int type);
 112 void dbgprintf(int level, const char *fmt, ...);
 113 void sanitize_environment();
 114 void usage();
 115
 116
 117 /*Parse commandline options*/
 118 int main(int argc, char *argv[])
 119 {
 120         char c;
 121         char *src=NULL;
 122         char *dst=NULL;
 123         queue.head=NULL;
 124         queue.tail=NULL;
 125         ping_stats.replies_received=0;
 126         ping_stats.requests_sent=0;
 127         ping_stats.rtt_avg=0;
 128         ping_stats.rtt_max=0;
 129         ping_stats.rtt_min=0;
 130         ping_stats.errors=0;
 131
 132         sanitize_environment();
 133
 134         while ((c = getopt(argc, argv, "64c:p:i:dt:S:")) != -1) {
 135                 switch (c) {
 136                         case '6':
 137                                 ip_type=AF_INET6;
 138                                 break;
 139                         case '4':
 140                                 ip_type=AF_INET;
 141                                 break;
 142                         case 'c':
 143                                 count = atoi(optarg);
 144                                 if(count<=0){
 145                                         dbgprintf(0, "Error: count must be positive");
 146                                         exit(1);
 147                                 }
 148                                 break;
 149                         case 'p':
 150                                 dest_port = atoi(optarg);
 151                                 break;
 152                         case 'i':
 153                                 interval = (long)(atof(optarg) * 1000.0);
 154                                 if (interval <= 0) {
 155                                         fprintf(stderr, "Invalid interval\n");
 156                                         exit(1);
 157                                 }
 158                                 break;
 159                         case 'd':
 160                                 debug++;
 161                                 break;
 162                         case 't':
 163                                 ttl = atoi(optarg);
 164                                 if (ttl < 1 || ttl > 255) {
 165                                         fprintf(stderr, "Invalid TTL\n");
 166                                 }
 167                                 break;
 168                         case 'S':
 169                                 src=optarg;
 170                                 break;
 171                         default:
 172                                 usage();
 173                                 break;
 174                 }
 175         }
 176
 177         argc -= optind;
 178         argv += optind;
 179
 180         if (argc != 1) {
 181                 usage();
 182         }
 183         dst=argv[0];
 184
 185         getAddresses(src, dst);
 186         if(src_addr.gen==NULL || dest_addr.gen==NULL){
 187                 dbgprintf(0,"Error: Can't determine source or destination address\n");
 188                 exit(1);
 189         }
 190
 191         doping();
 192
 193         free(src_addr.gen);
 194         free(dest_addr.gen);
 195         return 0;
 196 }
 197
 198 void getAddresses(char *src, char* dst){
 199         struct addrinfo hint;
 200         struct addrinfo *dtmp, *stmp;
 201         struct ifaddrs *temp, *cur;
 202         struct sockaddr_in6* iv6;
 203         int addrlen;
 204         int err;
 205
 206         /*Lookup destination Address*/
 207         memset(&hint,0,sizeof(struct addrinfo));
 208         hint.ai_family=ip_type;
 209         hint.ai_flags=AI_V4MAPPED | AI_ADDRCONFIG;
 210
 211         if((err=getaddrinfo(dst,NULL,&hint,&dtmp))!=0){
 212                 dbgprintf(0,"Error: Couldn't lookup destination %s (%s)\n", dst, gai_strerror(err));
 213                 exit(1);
 214         }
 215         if(dtmp==NULL){
 216                 dbgprintf(0,"Error: Unknown Host %s\n", dst);
 217                 exit(1);
 218         }else{
 219                 addrlen=dtmp->ai_addrlen;
 220                 hint.ai_family=ip_type=dtmp->ai_family;
 221                 dest_addr.gen=malloc(dtmp->ai_addrlen);
 222                 if(dest_addr.gen==NULL){
 223                         dbgprintf(0,"Error: Can't allocate Memory\n");
 224                         exit(1);
 225                 }
 226                 memcpy(dest_addr.gen,dtmp->ai_addr,dtmp->ai_addrlen);
 227         }
 228         freeaddrinfo(dtmp);
 229
 230         /*Get a meaningful source address*/
 231         if(src!=NULL){
 232                 /*Use Commandline arg*/
 233                 if((err=getaddrinfo(src,NULL,&hint,&stmp))!=0){
 234                         dbgprintf(0,"Error: Source Address %s is invalid (%s)\n", src, gai_strerror(err));
 235                         exit(1);
 236                 }
 237                 if(stmp==NULL){
 238                         dbgprintf(0,"Error: Unknown Host %s\n", dst);
 239                         exit(1);
 240                 }else{
 241                         addrlen=stmp->ai_addrlen;
 242                         src_addr.gen=malloc(stmp->ai_addrlen);
 243                         if(src_addr.gen==NULL){
 244                                 dbgprintf(0,"Error: Can't allocate Memory\n");
 245                                 exit(1);
 246                         }
 247                         memcpy(src_addr.gen,stmp->ai_addr,stmp->ai_addrlen);
 248                 }
 249                 freeaddrinfo(stmp);
 250         }else{
 251                 /*Guess a good source address*/
 252                 getifaddrs(&temp);
 253                 cur=temp;
 254                 while(cur!=NULL){
 255                         if(cur->ifa_addr==NULL || cur->ifa_addr->sa_family!=ip_type){ /*Not matching ipv4/ipv6 of dest*/
 256                                 cur=cur->ifa_next;
 257                                 continue;
 258                         }
 259                         if(cur->ifa_flags & IFF_LOOPBACK){ /*Don't use loopback addresses*/
 260                                 cur=cur->ifa_next;
 261                                 continue;
 262                         }
 263                         if(cur->ifa_addr!=NULL && cur->ifa_addr->sa_family==AF_INET6){
 264                                 iv6=(struct sockaddr_in6*)cur->ifa_addr;
 265
 266                                 if(iv6->sin6_scope_id!=0){ /*Not globally valid address, if ipv6*/
 267                                         cur=cur->ifa_next;
 268                                         continue;
 269                                 }
 270                         }
 271
 272                         src_addr.gen=malloc(sizeof(struct sockaddr_storage));
 273                         if(src_addr.gen==NULL){
 274                                 dbgprintf(0,"Error: Can't allocate Memory\n");
 275                                 exit(1);
 276                         }
 277                         src_addr.gen->sa_family=ip_type;
 278                         memcpy(src_addr.gen,cur->ifa_addr,addrlen);
 279                         //break;
 280                         cur=cur->ifa_next;
 281                 }
 282                 freeifaddrs(temp);
 283         }
 284         return;
 285 }
 286
 287 /*Preform the ping functionality*/
 288 void doping(){
 289         int rs, is4,is6,ds;
 290         int done=0;
 291         int addrlen;
 292         int slen=1500;
 293         unsigned char sbuffer[slen];
 294         fd_set sel;
 295         struct timeval timeout;
 296         struct timeval t,delay, add;
 297         char pbuf[1000];
 298         int seq=1;
 299
 300         /*Open Sockets*/
 301         rs=socket(ip_type, SOCK_RAW ,IPPROTO_RAW);
 302         if(rs<0){
 303                 dbgprintf(0, "Error opening raw socket\n");
 304                 exit(1);
 305         }
 306         ds=socket(ip_type, SOCK_RAW ,IPPROTO_DCCP);
 307         if(ds<0){
 308                 dbgprintf(0, "Error opening raw DCCP socket\n");
 309                 exit(1);
 310         }
 311         is4=socket(ip_type,SOCK_RAW,IPPROTO_ICMP);
 312         if(is4<0){
 313                 dbgprintf(0,"Error opening raw ICMPv4 socket\n");
 314                 exit(1);
 315         }
 316         is6=socket(ip_type,SOCK_RAW,IPPROTO_ICMPV6);
 317         if(is6<0){
 318                 dbgprintf(0,"Error opening raw ICMPv6 socket\n");
 319                 exit(1);
 320         }
 321
 322
 323         /*Build DCCP packet*/
 324         buildRequestPacket(sbuffer,&slen,seq);
 325         if(ip_type==AF_INET){
 326                 addrlen=sizeof(struct sockaddr_in);
 327         }else{
 328                 addrlen=sizeof(struct sockaddr_in6);
 329         }
 330
 331         /*Start Message*/
 332         if(ip_type==AF_INET){
 333                 dbgprintf(0, "PINGING %s on DCCP port %i\n",
 334                                 inet_ntop(ip_type, (void*)&dest_addr.ipv4->sin_addr, pbuf, 1000),dest_port);
 335         }else{
 336                 dbgprintf(0, "PINGING %s on DCCP port %i\n",
 337                                 inet_ntop(ip_type, (void*)&dest_addr.ipv6->sin6_addr, pbuf, 1000),dest_port);
 338         }
 339
 340         while(!done){
 341                 /*Send Ping*/
 342                 if(sendto(rs, &sbuffer, slen, MSG_DONTWAIT,(struct sockaddr*)dest_addr.gen,addrlen)<0){
 343                         dbgprintf(0,"Error: sendto failed\n");
 344                 }
 345                 if (logPacket(seq)<0){
 346                         dbgprintf(0,"Error: Couldn't record request!\n");
 347                 }
 348                 if(ip_type==AF_INET){
 349                         dbgprintf(1, "Sending DCCP Request to %s\n",inet_ntop(ip_type, (void*)&dest_addr.ipv4->sin_addr, pbuf, 1000));
 350                 }else{
 351                         dbgprintf(1, "Sending DCCP Request to %s\n",inet_ntop(ip_type, (void*)&dest_addr.ipv6->sin6_addr, pbuf, 1000));
 352                 }
 353
 354                 /*Use select to wait on packets or until interval has passed*/
 355                 add.tv_sec=interval/1000;
 356                 add.tv_usec=(interval%1000)*1000;
 357                 gettimeofday(&t,NULL);
 358                 timeradd(&t,&add,&delay);
 359                 while(timercmp(&t,&delay,<)){
 360                         /*Prepare for select*/
 361                         FD_ZERO(&sel);
 362                         FD_SET(ds,&sel);
 363                         FD_SET(is4,&sel);
 364                         FD_SET(is6,&sel);
 365                         timersub(&delay,&t,&timeout);
 366
 367                         /*Do select call*/
 368                         if(select(MAX(ds+1,MAX(is4+1,is6+1)),&sel, NULL,NULL,&timeout)<0){
 369                                 dbgprintf(0,"Select() error\n");
 370                         }
 371
 372                         if(FD_ISSET(ds,&sel)){
 373                                 /*Data on the DCCP socket*/
 374                                 handleDCCPpacket(ds,rs);
 375
 376                         }
 377                         if(FD_ISSET(is4,&sel) && ip_type==AF_INET){
 378                                 /*Data on the ICMPv4 socket*/
 379                                 handleICMP4packet(is4);
 380                         }
 381                         if(FD_ISSET(is6,&sel) && ip_type==AF_INET6){
 382                                 /*Data on the ICMPv6 socket*/
 383                                 handleICMP6packet(is6);
 384                         }
 385                         gettimeofday(&t,NULL);
 386                 }
 387
 388                 /*Update count*/
 389                 if(count>-1){
 390                         count--;
 391                 }
 392                 if(count==0){
 393                         done=1;
 394                         break;
 395                 }
 396                 seq++;
 397                 updateRequestPacket(sbuffer,&slen, seq);
 398         }
 399
 400         close(rs);
 401         close(is4);
 402         close(is6);
 403         close(ds);
 404 }
 405
 406 void handleDCCPpacket(int rcv_socket, int send_socket){
 407         int rlen=1500;
 408         unsigned char rbuffer[rlen];
 409         ipaddr_ptr_t rcv_addr;
 410         socklen_t rcv_addr_len;
 411         struct dccp_hdr *dhdr;
 412         struct dccp_hdr_reset *dhdr_re;
 413         struct dccp_hdr_response *dhdr_rp;
 414         struct dccp_hdr_ack_bits *dhdr_sync;
 415         unsigned char* ptr;
 416         struct iphdr* iph;
 417
 418         /*Memory for socket address*/
 419         rcv_addr_len=sizeof(struct sockaddr_storage);
 420         rcv_addr.gen=malloc(rcv_addr_len);
 421         if(rcv_addr.gen==NULL){
 422                 dbgprintf(0,"Error: Can't Allocate Memory!\n");
 423                 exit(1);
 424         }
 425
 426         /*Receive Packet*/
 427         rcv_addr_len=sizeof(struct sockaddr_storage);
 428         if((rlen=recvfrom(rcv_socket, &rbuffer, 1000,0,rcv_addr.gen,&rcv_addr_len))<0){
 429                         dbgprintf(0, "Error on receive from DCCP socket (%s)\n",strerror(errno));
 430         }
 431
 432         if(rcv_addr.gen->sa_family!=ip_type){ //confirm IP type
 433                 dbgprintf(1, "DCCP packet on %s. Tossing.\n", (ip_type==AF_INET) ? "IPv4" : "IPv6");
 434                 free(rcv_addr.gen);
 435                 return;
 436         }
 437
 438         if(rcv_addr.gen->sa_family==AF_INET){
 439                 /*IPv4*/
 440                 if(memcmp(&rcv_addr.ipv4->sin_addr,&dest_addr.ipv4->sin_addr,
 441                                 sizeof(dest_addr.ipv4->sin_addr))!=0){ //not from destination
 442                         dbgprintf(1,"DCCP packet from 3rd host\n");
 443                         free(rcv_addr.gen);
 444                         return;
 445                 }
 446                 if(rlen < sizeof(struct dccp_hdr)+sizeof(struct iphdr)){ //check packet size
 447
 448                         dbgprintf(1, "Packet smaller than possible DCCP packet received on DCCP socket\n");
 449                         free(rcv_addr.gen);
 450                         return;
 451                 }
 452                 iph=(struct iphdr*)rbuffer;
 453                 ptr=rbuffer+iph->ihl*4;
 454         }else{
 455                 /*IPv6*/
 456                 if(memcmp(&rcv_addr.ipv6->sin6_addr, &dest_addr.ipv6->sin6_addr,
 457                                 sizeof(dest_addr.ipv6->sin6_addr))!=0){ //not from destination
 458                         dbgprintf(1,"DCCP packet from 3rd host\n");
 459                         free(rcv_addr.gen);
 460                         return;
 461                 }
 462                 if(rlen < sizeof(struct dccp_hdr)){ //check packet size
 463
 464                         dbgprintf(1, "Packet smaller than possible DCCP packet received on DCCP socket\n");
 465                         free(rcv_addr.gen);
 466                         return;
 467                 }
 468                 ptr=rbuffer;
 469         }
 470
 471         /*DCCP checks*/
 472         dhdr=(struct dccp_hdr*)ptr;
 473         if(dhdr->dccph_sport!=htons(dest_port)){
 474                 dbgprintf(1,"DCCP packet with wrong Source Port (%i)\n", ntohs(dhdr->dccph_sport));
 475                 free(rcv_addr.gen);
 476                 return;
 477         }
 478         if(dhdr->dccph_dport!=htons(dest_port)){
 479                 dbgprintf(1,"DCCP packet with wrong Destination Port\n");
 480                 free(rcv_addr.gen);
 481                 return;
 482         }
 483
 484         /*Pick Response*/
 485         if(dhdr->dccph_type==DCCP_PKT_RESET){
 486                 if(rlen < (ptr-rbuffer)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_reset)){
 487                         dbgprintf(1, "Error: Reset packet too small!");
 488                         return;
 489                 }
 490                 dhdr_re=(struct dccp_hdr_reset*)(ptr+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
 491                 logResponse(&rcv_addr, ntohl(dhdr_re->dccph_reset_ack.dccph_ack_nr_low), RESET);
 492                 /*Nothing else to do*/
 493         }
 494         if(dhdr->dccph_type==DCCP_PKT_RESPONSE){
 495                 if(rlen < (ptr-rbuffer)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_response)){
 496                         dbgprintf(1, "Error: Response packet too small!");
 497                         return;
 498                 }
 499                 dhdr_rp=(struct dccp_hdr_response*)(ptr+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
 500                 logResponse(&rcv_addr,ntohl(dhdr_rp->dccph_resp_ack.dccph_ack_nr_low),RESPONSE);
 501                 /*TODO:Send Close back*/
 502         }
 503         if(dhdr->dccph_type==DCCP_PKT_SYNC || dhdr->dccph_type==DCCP_PKT_SYNCACK){
 504                 if(rlen < (ptr-rbuffer)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_ack_bits)){
 505                         dbgprintf(1, "Error: Response packet too small!");
 506                         return;
 507                 }
 508                 dhdr_sync=(struct dccp_hdr_ack_bits*)(ptr+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
 509                 logResponse(&rcv_addr,ntohl(dhdr_sync->dccph_ack_nr_low),SYNC);
 510                 /*TODO:Send Reset*/
 511         }
 512
 513         free(rcv_addr.gen);
 514 }
 515
 516 void handleICMP4packet(int rcv_socket){
 517         int rlen=1500;
 518         unsigned char rbuffer[rlen];
 519         ipaddr_ptr_t rcv_addr;
 520         socklen_t rcv_addr_len;
 521         struct icmphdr *icmp4;
 522         struct dccp_hdr *dhdr;
 523         struct dccp_hdr_ext *dhdre;
 524         struct iphdr* ip4hdr;
 525         int type;
 526
 527         /*Memory for socket address*/
 528         rcv_addr_len=sizeof(struct sockaddr_storage);
 529         rcv_addr.gen=malloc(rcv_addr_len);
 530         if(rcv_addr.gen==NULL){
 531                 dbgprintf(0,"Error: Can't Allocate Memory!\n");
 532                 exit(1);
 533         }
 534
 535         /*Receive Packet*/
 536         if((rlen=recvfrom(rcv_socket, &rbuffer, 1000,0,rcv_addr.gen,&rcv_addr_len))<0){
 537                 dbgprintf(0, "Error on receive from ICMPv4 socket (%s)\n",strerror(errno));
 538         }
 539
 540         if(rlen < sizeof(struct icmphdr)){ //check packet size
 541                 dbgprintf(1, "Packet smaller than possible ICMPv4 packet!\n");
 542                 free(rcv_addr.gen);
 543                 return;
 544         }
 545
 546         icmp4=(struct icmphdr*)rbuffer;
 547         if(icmp4->type!=ICMP_DEST_UNREACH && icmp4->type!=ICMP_TIME_EXCEEDED){ //check icmp types
 548                 dbgprintf(1, "Tossing ICMPv4 packet of type %i\n", icmp4->type);
 549                 free(rcv_addr.gen);
 550                 return;
 551         }
 552
 553         /*Check packet size again*/
 554         if(rlen<sizeof(struct icmphdr)+sizeof(struct iphdr)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)){
 555                 dbgprintf(1, "Tossing ICMPv4 packet that's too small to contain DCCP header!\n");
 556                 free(rcv_addr.gen);
 557                 return;
 558         }
 559
 560         /*Decode IPv4 header*/
 561         ip4hdr=(struct iphdr*)(rbuffer+sizeof(struct icmphdr));
 562         if(memcmp(&src_addr.ipv4->sin_addr,&ip4hdr->saddr,sizeof(src_addr.ipv4->sin_addr))!=0){
 563                 /*Source address doesn't match*/
 564                 free(rcv_addr.gen);
 565                 return;
 566         }
 567         if(memcmp(&dest_addr.ipv4->sin_addr,&ip4hdr->daddr,sizeof(dest_addr.ipv4->sin_addr))!=0){
 568                 /*Destination address doesn't match*/
 569                 free(rcv_addr.gen);
 570                 return;
 571         }
 572         if(ip4hdr->protocol!=IPPROTO_DCCP){
 573                 /*Not DCCP!*/
 574                 free(rcv_addr.gen);
 575                 return;
 576         }
 577
 578         /*Decode DCCP header*/
 579         dhdr=(struct dccp_hdr*)(rbuffer+sizeof(struct icmphdr)+ip4hdr->ihl*4);
 580         if(dhdr->dccph_dport!=htons(dest_port)){
 581                 /*DCCP Destination Ports don't match*/
 582                 free(rcv_addr.gen);
 583                 return;
 584         }
 585         if(dhdr->dccph_sport!=htons(dest_port)){
 586                 /*DCCP Source Ports don't match*/
 587                 free(rcv_addr.gen);
 588                 return;
 589         }
 590         dhdre=(struct dccp_hdr_ext*)(rbuffer+sizeof(struct icmphdr)+ip4hdr->ihl*4+sizeof(struct dccp_hdr));
 591
 592         /*Log*/
 593         if(icmp4->type==ICMP_DEST_UNREACH){
 594                 type=DEST_UNREACHABLE;
 595         }
 596         if(icmp4->type==ICMP_TIME_EXCEEDED){
 597                 type=TTL_EXPIRATION;
 598         }
 599         logResponse(&rcv_addr,ntohl(dhdre->dccph_seq_low),type);
 600         free(rcv_addr.gen);
 601         return;
 602 }
 603
 604 void handleICMP6packet(int rcv_socket){
 605         int rlen=1500;
 606         unsigned char rbuffer[rlen];
 607         ipaddr_ptr_t rcv_addr;
 608         socklen_t rcv_addr_len;
 609         struct icmp6_hdr *icmp6;
 610         struct ip6_hdr* ip6hdr;
 611         struct dccp_hdr *dhdr;
 612         struct dccp_hdr_ext *dhdre;
 613         int type;
 614
 615         /*Memory for socket address*/
 616         rcv_addr_len=sizeof(struct sockaddr_storage);
 617         rcv_addr.gen=malloc(rcv_addr_len);
 618         if(rcv_addr.gen==NULL){
 619                 dbgprintf(0,"Error: Can't Allocate Memory!\n");
 620                 exit(1);
 621         }
 622
 623         /*Receive Packet*/
 624         if((rlen=recvfrom(rcv_socket, &rbuffer, 1000,0,rcv_addr.gen,&rcv_addr_len))<0){
 625                 dbgprintf(0, "Error on receive from ICMPv6 socket (%s)\n",strerror(errno));
 626         }
 627
 628         if(rlen < sizeof(struct icmp6_hdr)){ //check packet size
 629                 dbgprintf(1, "Packet smaller than possible ICMPv6 packet!\n");
 630                 free(rcv_addr.gen);
 631                 return;
 632         }
 633
 634         icmp6=(struct icmp6_hdr*)rbuffer;
 635         if(icmp6->icmp6_type!=ICMP6_DST_UNREACH && icmp6->icmp6_type!=ICMP6_PACKET_TOO_BIG
 636                         && icmp6->icmp6_type!=ICMP6_TIME_EXCEEDED && icmp6->icmp6_type!=ICMP6_PARAM_PROB){ //check icmp types
 637                 dbgprintf(1, "Tossing ICMPv6 packet of type %i\n", icmp6->icmp6_type);
 638                 free(rcv_addr.gen);
 639                 return;
 640         }
 641
 642         /*Check packet size again*/
 643         if(rlen<sizeof(struct icmp6_hdr)+sizeof(struct ip6_hdr)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)){
 644                 dbgprintf(1, "Tossing ICMPv6 packet that's too small to contain DCCP header!\n");
 645                 free(rcv_addr.gen);
 646                 return;
 647         }
 648
 649         /*Decode IPv6 header*/
 650         ip6hdr=(struct ip6_hdr*)(rbuffer+sizeof(struct icmp6_hdr));
 651         if(memcmp(&src_addr.ipv6->sin6_addr,&ip6hdr->ip6_src,sizeof(src_addr.ipv6->sin6_addr))!=0){
 652                 /*Source address doesn't match*/
 653                 free(rcv_addr.gen);
 654                 return;
 655         }
 656         if(memcmp(&dest_addr.ipv6->sin6_addr,&ip6hdr->ip6_dst,sizeof(dest_addr.ipv6->sin6_addr))!=0){
 657                 /*Destination address doesn't match*/
 658                 free(rcv_addr.gen);
 659                 return;
 660         }
 661         if(ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt!=IPPROTO_DCCP){
 662                 /*Not DCCP!*/
 663                 free(rcv_addr.gen);
 664                 return;
 665         }
 666
 667         /*Decode DCCP header*/
 668         dhdr=(struct dccp_hdr*)(rbuffer+sizeof(struct icmp6_hdr)+sizeof(struct ip6_hdr));
 669         if(dhdr->dccph_dport!=htons(dest_port)){
 670                 /*DCCP Destination Ports don't match*/
 671                 free(rcv_addr.gen);
 672                 return;
 673         }
 674         if(dhdr->dccph_sport!=htons(dest_port)){
 675                 /*DCCP Source Ports don't match*/
 676                 free(rcv_addr.gen);
 677                 return;
 678         }
 679         dhdre=(struct dccp_hdr_ext*)(rbuffer+sizeof(struct icmp6_hdr)+sizeof(struct ip6_hdr)+sizeof(struct dccp_hdr));
 680
 681
 682
 683         /*Log*/
 684         if(icmp6->icmp6_type==ICMP6_DST_UNREACH){
 685                 type=DEST_UNREACHABLE;
 686         }
 687         if(icmp6->icmp6_type==ICMP6_PACKET_TOO_BIG){
 688                 type=TOO_BIG;
 689         }
 690         if(icmp6->icmp6_type==ICMP6_TIME_EXCEEDED){
 691                 type=TTL_EXPIRATION;
 692         }
 693         if(icmp6->icmp6_type==ICMP6_PARAM_PROB){
 694                 type=PARAMETER_PROBLEM;
 695         }
 696         logResponse(&rcv_addr,ntohl(dhdre->dccph_seq_low),type);
 697         free(rcv_addr.gen);
 698         return;
 699 }
 700
 701 void buildRequestPacket(unsigned char* buffer, int *len, int seq){
 702         struct dccp_hdr *dhdr;
 703         struct dccp_hdr_ext *dhdre;
 704         struct dccp_hdr_request *dhdrr;
 705         struct iphdr* ip4hdr;
 706         struct ip6_hdr* ip6hdr;
 707
 708         int ip_hdr_len;
 709         int dccp_hdr_len=sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_request);
 710
 711         if(*len < dccp_hdr_len+sizeof(struct ip6_hdr)){
 712                 dbgprintf(0, "Error: Insufficient buffer space\n");
 713                 exit(1);
 714         }
 715
 716         memset(buffer, 0, *len);
 717
 718         /*IP header*/
 719         ip4hdr=NULL;
 720         if(ip_type==AF_INET){
 721                 ip_hdr_len=sizeof(struct iphdr);
 722                 ip4hdr=(struct iphdr*)buffer;
 723                 ip4hdr->check=htons(0);
 724                 memcpy(&ip4hdr->daddr, &dest_addr.ipv4->sin_addr, sizeof(dest_addr.ipv4->sin_addr));
 725                 ip4hdr->frag_off=htons(0);
 726                 ip4hdr->id=htons(1);//first
 727                 ip4hdr->ihl=5;
 728                 ip4hdr->protocol=IPPROTO_DCCP;
 729                 memcpy(&ip4hdr->saddr, &src_addr.ipv4->sin_addr, sizeof(src_addr.ipv4->sin_addr));
 730                 ip4hdr->tos=0;
 731                 ip4hdr->tot_len=htons(ip_hdr_len+dccp_hdr_len);
 732                 ip4hdr->ttl=ttl;
 733                 ip4hdr->version=4;
 734         }else{
 735                 ip_hdr_len=sizeof(struct ip6_hdr);
 736                 ip6hdr=(struct ip6_hdr*)buffer;
 737                 memcpy(&ip6hdr->ip6_dst, &dest_addr.ipv6->sin6_addr, sizeof(dest_addr.ipv6->sin6_addr));
 738                 memcpy(&ip6hdr->ip6_src, &src_addr.ipv6->sin6_addr, sizeof(src_addr.ipv6->sin6_addr));
 739                 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_flow=htonl(6<<28); //version, traffic class, flow label
 740                 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_hlim=ttl;
 741                 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt=IPPROTO_DCCP;
 742                 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_plen=htons(dccp_hdr_len);
 743         }
 744
 745         /*DCCP header*/
 746         dhdr=(struct dccp_hdr*)(buffer+ip_hdr_len);
 747         dhdre=(struct dccp_hdr_ext*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr));
 748         dhdrr=(struct dccp_hdr_request*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
 749         dhdr->dccph_ccval=0;
 750         dhdr->dccph_checksum=0;
 751         dhdr->dccph_cscov=0;
 752         dhdr->dccph_doff=dccp_hdr_len/4;
 753         dhdr->dccph_dport=htons(dest_port);
 754         dhdr->dccph_reserved=0;
 755         dhdr->dccph_sport=htons(dest_port);
 756         dhdr->dccph_x=1;
 757         dhdr->dccph_type=DCCP_PKT_REQUEST;
 758         dhdr->dccph_seq2=htonl(0); //Reserved if using 48 bit sequence numbers
 759         dhdr->dccph_seq=htonl(0);  //High 16bits of sequence number. Always make 0 for simplicity.
 760         dhdre->dccph_seq_low=htonl(seq);
 761         dhdrr->dccph_req_service= htonl(0x50455246);
 762
 763         /*Checksums*/
 764         if(ip_type==AF_INET){
 765                 dhdr->dccph_checksum=ipv4_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
 766                                 (unsigned char*) &dest_addr.ipv4->sin_addr,
 767                                 (unsigned char*)&src_addr.ipv4->sin_addr, IPPROTO_DCCP);
 768                 ip4hdr->check=ipv4_chksum(buffer,ip_hdr_len);
 769         }else{
 770                 dhdr->dccph_checksum=ipv6_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
 771                                 (unsigned char*) &dest_addr.ipv6->sin6_addr,
 772                                 (unsigned char*)&src_addr.ipv6->sin6_addr, IPPROTO_DCCP);
 773         }
 774         *len=ip_hdr_len+dccp_hdr_len;
 775         return;
 776 }
 777
 778 void updateRequestPacket(unsigned char* buffer, int *len, int seq){
 779         struct dccp_hdr *dhdr;
 780         struct dccp_hdr_ext *dhdre;
 781         struct iphdr* ip4hdr;
 782
 783         int ip_hdr_len;
 784         int dccp_hdr_len=sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_request);
 785
 786         /*IP header*/
 787         ip4hdr=NULL;
 788         if(ip_type==AF_INET){
 789                 ip_hdr_len=sizeof(struct iphdr);
 790                 ip4hdr=(struct iphdr*)buffer;
 791                 ip4hdr->check=htons(0);
 792                 ip4hdr->id=htons(seq);
 793         }else{
 794                 ip_hdr_len=sizeof(struct ip6_hdr);
 795         }
 796
 797         /*DCCP header*/
 798         dhdr=(struct dccp_hdr*)(buffer+ip_hdr_len);
 799         dhdre=(struct dccp_hdr_ext*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr));
 800         dhdr->dccph_checksum=0;
 801         dhdre->dccph_seq_low=htonl(seq);
 802
 803         /*Checksums*/
 804         if(ip_type==AF_INET){
 805                 dhdr->dccph_checksum=ipv4_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
 806                                 (unsigned char*) &dest_addr.ipv4->sin_addr,
 807                                 (unsigned char*)&src_addr.ipv4->sin_addr, IPPROTO_DCCP);
 808                 ip4hdr->check=ipv4_chksum(buffer,ip_hdr_len);
 809         }else{
 810                 dhdr->dccph_checksum=ipv6_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
 811                                 (unsigned char*) &dest_addr.ipv6->sin6_addr,
 812                                 (unsigned char*)&src_addr.ipv6->sin6_addr, IPPROTO_DCCP);
 813         }
 814         *len=ip_hdr_len+dccp_hdr_len;
 815         return;
 816 }
 817
 818 int logPacket(int seq){
 819         struct request *tmp;
 820
 821         /*Add new request to queue*/
 822         tmp=malloc(sizeof(struct request));
 823         if(tmp==NULL){
 824                 dbgprintf(0,"Error: Can't allocate Memory!\n");
 825                 exit(1);
 826         }
 827         tmp->next=NULL;
 828         tmp->prev=NULL;
 829         tmp->num_replies=0;
 830         tmp->num_errors=0;
 831         tmp->seq=seq;
 832         tmp->reply_type=UNKNOWN;
 833         gettimeofday(&tmp->sent,NULL);
 834
 835         if(queue.head==NULL){
 836                 queue.head=queue.tail=tmp;
 837                 return 0;
 838         }
 839         queue.head->prev=tmp;
 840         tmp->next=queue.head;
 841         queue.head=tmp;
 842
 843         /*Update Statistics*/
 844         if(ping_stats.requests_sent==0){
 845                 gettimeofday(&ping_stats.start,NULL);
 846         }
 847         ping_stats.requests_sent++;
 848         return 0;
 849 }
 850
 851 int logResponse(ipaddr_ptr_t *src, int seq, int type){
 852         struct request *cur;
 853         double diff;
 854         char pbuf[1000];
 855
 856         if(queue.tail==NULL){
 857                 dbgprintf(1,"Response received but no requests sent!\n");
 858                 return -1;
 859         }
 860
 861         /*Locate request*/
 862         cur=queue.tail;
 863         while(cur!=NULL){
 864                 if(cur->seq==seq){
 865                         gettimeofday(&cur->reply,NULL);
 866                         if(type<DEST_UNREACHABLE && type!=UNKNOWN){
 867                                 cur->num_replies++;
 868                         }else{
 869                                 cur->num_errors++;
 870                         }
 871                         cur->reply_type=type;
 872                         break;
 873                 }
 874                 cur=cur->prev;
 875         }
 876
 877         if(cur==NULL){
 878                 dbgprintf(1,"Response received but no requests sent with sequence number %i!\n", seq);
 879                 return -1;
 880         }
 881
 882         diff=(cur->reply.tv_usec + 1000000*cur->reply.tv_sec) - (cur->sent.tv_usec + 1000000*cur->sent.tv_sec);
 883         diff=diff/1000.0;
 884
 885         /*Print Message*/
 886         if(type<DEST_UNREACHABLE && type!=UNKNOWN){
 887                 if(ip_type==AF_INET){
 888                         dbgprintf(0, "Response from %s : seq=%i  time=%.1fms  status=%s\n",
 889                                         inet_ntop(ip_type, (void*)&src->ipv4->sin_addr, pbuf, 1000),
 890                                         seq, diff,response_label[type]);
 891                 }else{
 892                         dbgprintf(0, "Response from %s : seq=%i  time=%.1fms  status=%s\n",
 893                                         inet_ntop(ip_type, (void*)&src->ipv6->sin6_addr, pbuf, 1000),
 894                                         seq, diff,response_label[type]);
 895                 }
 896         }else{
 897                 if(ip_type==AF_INET){
 898                         dbgprintf(0, "%s from %s : seq=%i\n",response_label[type],
 899                                         inet_ntop(ip_type, (void*)&src->ipv4->sin_addr, pbuf, 1000),
 900                                         seq);
 901                 }else{
 902                         dbgprintf(0, "%s from %s : seq=%i\n",response_label[type],
 903                                         inet_ntop(ip_type, (void*)&src->ipv6->sin6_addr, pbuf, 1000),
 904                                         seq);
 905                 }
 906         }
 907
 908         /*Update statistics*/
 909         if(type<DEST_UNREACHABLE && type!=UNKNOWN){
 910                 /*Good Response*/
 911                 ping_stats.rtt_avg=((ping_stats.replies_received*ping_stats.rtt_avg)+(diff))/(ping_stats.replies_received+1);
 912                 ping_stats.replies_received++;
 913                 if(diff < ping_stats.rtt_min){
 914                         ping_stats.rtt_min=diff;
 915                 }
 916                 if(diff > ping_stats.rtt_max){
 917                         ping_stats.rtt_max=diff;
 918                 }
 919         }else{
 920                 /*Error*/
 921                 cur->num_errors++;
 922         }
 923         gettimeofday(&ping_stats.stop,NULL);
 924         return 0;
 925 }
 926
 927 /*Usage information for program*/
 928 void usage()
 929 {
 930         dbgprintf(0, "dccpping: [-d] [-6|-4] [-c count] [-p port] [-i interval] [-t ttl] [-S srcaddress] remote_host\n");
 931         exit(0);
 932 }
 933
 934 /*Program will probably be run setuid, so be extra careful*/
 935 void sanitize_environment()
 936 {
 937 #if defined(_SVID_SOURCE) || defined(_XOPEN_SOURCE)
 938         clearenv();
 939 #else
 940         extern char **environ;
 941         environ = NULL;
 942 #endif
 943 }
 944
 945 /*Debug Printf*/
 946 void dbgprintf(int level, const char *fmt, ...)
 947 {
 948     va_list args;
 949     if(debug>=level){
 950         va_start(args, fmt);
 951         vfprintf(stderr, fmt, args);
 952         va_end(args);
 953     }
 954 }