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 typedef union ipaddr{
  34         struct sockaddr *gen;
  35         struct sockaddr_in *ipv4;
  36         struct sockaddr_in6 *ipv6;
  37 } ipaddr_ptr_t;
  38
  39
  40 int debug=0;                    /*set to 1 to turn on debugging information*/
  41 int count=-1;                   /*Default number of pings (-1 is infinity)*/
  42 int dest_port=33434;    /*Default port*/
  43 int ttl=64;                             /*Default TTL*/
  44 long interval=1000;             /*Default delay between pings in ms*/
  45 int ip_type=AF_UNSPEC;  /*IPv4 or IPv6*/
  46 ipaddr_ptr_t dest_addr;
  47 ipaddr_ptr_t src_addr;
  48 extern int errno;
  49
  50
  51 void getAddresses(char *src, char* dst);
  52 void doping();
  53 void handleDCCPpacket(int rcv_socket, int send_socket);
  54 void handleICMP4packet(int rcv_socket);
  55 void handleICMP6packet(int rcv_socket);
  56 void buildRequestPacket(unsigned char* buffer, int *len);
  57 void updateRequestPacket(unsigned char* buffer, int *len);
  58 void dbgprintf(int level, const char *fmt, ...);
  59 void sanitize_environment();
  60 void usage();
  61
  62
  63 /*Parse commandline options*/
  64 int main(int argc, char *argv[])
  65 {
  66         char c;
  67         char *src=NULL;
  68         char *dst=NULL;
  69
  70
  71         sanitize_environment();
  72
  73         while ((c = getopt(argc, argv, "64c:p:i:dt:S:")) != -1) {
  74                 switch (c) {
  75                         case '6':
  76                                 ip_type=AF_INET6;
  77                                 break;
  78                         case '4':
  79                                 ip_type=AF_INET;
  80                                 break;
  81                         case 'c':
  82                                 count = atoi(optarg);
  83                                 if(count<=0){
  84                                         dbgprintf(0, "Error: count must be positive");
  85                                         exit(1);
  86                                 }
  87                                 break;
  88                         case 'p':
  89                                 dest_port = atoi(optarg);
  90                                 break;
  91                         case 'i':
  92                                 interval = (long)(atof(optarg) * 1000.0);
  93                                 if (interval <= 0) {
  94                                         fprintf(stderr, "Invalid interval\n");
  95                                         exit(1);
  96                                 }
  97                                 break;
  98                         case 'd':
  99                                 debug++;
 100                                 break;
 101                         case 't':
 102                                 ttl = atoi(optarg);
 103                                 if (ttl < 1 || ttl > 255) {
 104                                         fprintf(stderr, "Invalid TTL\n");
 105                                 }
 106                                 break;
 107                         case 'S':
 108                                 src=optarg;
 109                                 break;
 110                         default:
 111                                 usage();
 112                                 break;
 113                 }
 114         }
 115
 116         argc -= optind;
 117         argv += optind;
 118
 119         if (argc != 1) {
 120                 usage();
 121         }
 122         dst=argv[0];
 123
 124         getAddresses(src, dst);
 125         if(src_addr.gen==NULL || dest_addr.gen==NULL){
 126                 dbgprintf(0,"Error: Can't determine source or destination address\n");
 127                 exit(1);
 128         }
 129
 130         doping();
 131
 132         free(src_addr.gen);
 133         free(dest_addr.gen);
 134         return 0;
 135 }
 136
 137 void getAddresses(char *src, char* dst){
 138         struct addrinfo hint;
 139         struct addrinfo *dtmp, *stmp;
 140         struct ifaddrs *temp, *cur;
 141         struct sockaddr_in6* iv6;
 142         int addrlen;
 143         int err;
 144
 145         /*Lookup destination Address*/
 146         memset(&hint,0,sizeof(struct addrinfo));
 147         hint.ai_family=ip_type;
 148         hint.ai_flags=AI_V4MAPPED | AI_ADDRCONFIG;
 149
 150         if((err=getaddrinfo(dst,NULL,&hint,&dtmp))!=0){
 151                 dbgprintf(0,"Error: Couldn't lookup destination %s (%s)\n", dst, gai_strerror(err));
 152                 exit(1);
 153         }
 154         if(dtmp==NULL){
 155                 dbgprintf(0,"Error: Unknown Host %s\n", dst);
 156                 exit(1);
 157         }else{
 158                 addrlen=dtmp->ai_addrlen;
 159                 hint.ai_family=ip_type=dtmp->ai_family;
 160                 dest_addr.gen=malloc(dtmp->ai_addrlen);
 161                 if(dest_addr.gen==NULL){
 162                         dbgprintf(0,"Error: Can't allocate Memory\n");
 163                         exit(1);
 164                 }
 165                 memcpy(dest_addr.gen,dtmp->ai_addr,dtmp->ai_addrlen);
 166         }
 167         freeaddrinfo(dtmp);
 168
 169         /*Get a meaningful source address*/
 170         if(src!=NULL){
 171                 /*Use Commandline arg*/
 172                 if((err=getaddrinfo(src,NULL,&hint,&stmp))!=0){
 173                         dbgprintf(0,"Error: Source Address %s is invalid (%s)\n", src, gai_strerror(err));
 174                         exit(1);
 175                 }
 176                 if(stmp==NULL){
 177                         dbgprintf(0,"Error: Unknown Host %s\n", dst);
 178                         exit(1);
 179                 }else{
 180                         addrlen=stmp->ai_addrlen;
 181                         src_addr.gen=malloc(stmp->ai_addrlen);
 182                         if(src_addr.gen==NULL){
 183                                 dbgprintf(0,"Error: Can't allocate Memory\n");
 184                                 exit(1);
 185                         }
 186                         memcpy(src_addr.gen,stmp->ai_addr,stmp->ai_addrlen);
 187                 }
 188                 freeaddrinfo(stmp);
 189         }else{
 190                 /*Guess a good source address*/
 191                 getifaddrs(&temp);
 192                 cur=temp;
 193                 while(cur!=NULL){
 194                         if(cur->ifa_addr==NULL || cur->ifa_addr->sa_family!=ip_type){ /*Not matching ipv4/ipv6 of dest*/
 195                                 cur=cur->ifa_next;
 196                                 continue;
 197                         }
 198                         if(cur->ifa_flags & IFF_LOOPBACK){ /*Don't use loopback addresses*/
 199                                 cur=cur->ifa_next;
 200                                 continue;
 201                         }
 202                         if(cur->ifa_addr!=NULL && cur->ifa_addr->sa_family==AF_INET6){
 203                                 iv6=(struct sockaddr_in6*)cur->ifa_addr;
 204
 205                                 if(iv6->sin6_scope_id!=0){ /*Not globally valid address, if ipv6*/
 206                                         cur=cur->ifa_next;
 207                                         continue;
 208                                 }
 209                         }
 210
 211                         src_addr.gen=malloc(sizeof(struct sockaddr_storage));
 212                         if(src_addr.gen==NULL){
 213                                 dbgprintf(0,"Error: Can't allocate Memory\n");
 214                                 exit(1);
 215                         }
 216                         src_addr.gen->sa_family=ip_type;
 217                         memcpy(src_addr.gen,cur->ifa_addr,addrlen);
 218                         //break;
 219                         cur=cur->ifa_next;
 220                 }
 221                 freeifaddrs(temp);
 222         }
 223         return;
 224 }
 225
 226 /*Preform the ping functionality*/
 227 void doping(){
 228         int rs, is4,is6,ds;
 229         int done=0;
 230         int addrlen;
 231         int slen=1500;
 232         unsigned char sbuffer[slen];
 233         fd_set sel;
 234         struct timeval timeout;
 235         struct timeval t,delay, add;
 236         char pbuf[1000];
 237
 238         /*Open Sockets*/
 239         rs=socket(ip_type, SOCK_RAW ,IPPROTO_RAW);
 240         if(rs<0){
 241                 dbgprintf(0, "Error opening raw socket\n");
 242                 exit(1);
 243         }
 244         ds=socket(ip_type, SOCK_RAW ,IPPROTO_DCCP);
 245         if(ds<0){
 246                 dbgprintf(0, "Error opening raw DCCP socket\n");
 247                 exit(1);
 248         }
 249         is4=socket(ip_type,SOCK_RAW,IPPROTO_ICMP);
 250         if(is4<0){
 251                 dbgprintf(0,"Error opening raw ICMPv4 socket\n");
 252                 exit(1);
 253         }
 254         is6=socket(ip_type,SOCK_RAW,IPPROTO_ICMPV6);
 255         if(is6<0){
 256                 dbgprintf(0,"Error opening raw ICMPv6 socket\n");
 257                 exit(1);
 258         }
 259
 260
 261         /*Build DCCP packet*/
 262         buildRequestPacket(sbuffer,&slen);
 263         if(ip_type==AF_INET){
 264                 addrlen=sizeof(struct sockaddr_in);
 265         }else{
 266                 addrlen=sizeof(struct sockaddr_in6);
 267         }
 268
 269         while(!done){
 270                 /*Send Ping*/
 271                 if(sendto(rs, &sbuffer, slen, MSG_DONTWAIT,(struct sockaddr*)dest_addr.gen,addrlen)<0){
 272                         dbgprintf(0,"Error: sendto failed\n");
 273                 }
 274                 if(ip_type==AF_INET){
 275                         dbgprintf(0, "Sending DCCP Request to %s\n",inet_ntop(ip_type, (void*)&dest_addr.ipv4->sin_addr, pbuf, 1000));
 276                 }else{
 277                         dbgprintf(0, "Sending DCCP Request to %s\n",inet_ntop(ip_type, (void*)&dest_addr.ipv6->sin6_addr, pbuf, 1000));
 278                 }
 279
 280                 /*Use select to wait on packets or until interval has passed*/
 281                 add.tv_sec=interval/1000;
 282                 add.tv_usec=(interval%1000)*1000;
 283                 gettimeofday(&t,NULL);
 284                 timeradd(&t,&add,&delay);
 285                 while(timercmp(&t,&delay,<)){
 286                         /*Prepare for select*/
 287                         FD_ZERO(&sel);
 288                         FD_SET(ds,&sel);
 289                         FD_SET(is4,&sel);
 290                         FD_SET(is6,&sel);
 291                         timersub(&delay,&t,&timeout);
 292
 293                         /*Do select call*/
 294                         if(select(MAX(ds+1,MAX(is4+1,is6+1)),&sel, NULL,NULL,&timeout)<0){
 295                                 dbgprintf(0,"Select() error\n");
 296                         }
 297
 298                         if(FD_ISSET(ds,&sel)){
 299                                 /*Data on the DCCP socket*/
 300                                 handleDCCPpacket(ds,rs);
 301
 302                         }
 303                         if(FD_ISSET(is4,&sel) && ip_type==AF_INET){
 304                                 /*Data on the ICMPv4 socket*/
 305                                 handleICMP4packet(is4);
 306                         }
 307                         if(FD_ISSET(is6,&sel) && ip_type==AF_INET6){
 308                                 /*Data on the ICMPv6 socket*/
 309                                 handleICMP6packet(is6);
 310                         }
 311                         gettimeofday(&t,NULL);
 312                 }
 313
 314                 /*Update count*/
 315                 if(count>-1){
 316                         count--;
 317                 }
 318                 if(count==0){
 319                         done=1;
 320                         break;
 321                 }
 322
 323                 updateRequestPacket(sbuffer,&slen);
 324         }
 325
 326         close(rs);
 327         close(is4);
 328         close(is6);
 329         close(ds);
 330 }
 331
 332 void handleDCCPpacket(int rcv_socket, int send_socket){
 333         int rlen=1500;
 334         unsigned char rbuffer[rlen];
 335         char pbuf[1000];
 336         ipaddr_ptr_t rcv_addr;
 337         socklen_t rcv_addr_len;
 338         struct dccp_hdr *dhdr;
 339         unsigned char* ptr;
 340         struct iphdr* iph;
 341
 342         /*Memory for socket address*/
 343         rcv_addr_len=sizeof(struct sockaddr_storage);
 344         rcv_addr.gen=malloc(rcv_addr_len);
 345         if(rcv_addr.gen==NULL){
 346                 dbgprintf(0,"Error: Can't Allocate Memory!\n");
 347                 exit(1);
 348         }
 349
 350         /*Receive Packet*/
 351         rcv_addr_len=sizeof(struct sockaddr_storage);
 352         if((rlen=recvfrom(rcv_socket, &rbuffer, 1000,0,rcv_addr.gen,&rcv_addr_len))<0){
 353                         dbgprintf(0, "Error on receive from DCCP socket (%s)\n",strerror(errno));
 354         }
 355
 356         if(rcv_addr.gen->sa_family!=ip_type){ //confirm IP type
 357                 dbgprintf(1, "DCCP packet on %s. Tossing.\n", (ip_type==AF_INET) ? "IPv4" : "IPv6");
 358                 free(rcv_addr.gen);
 359                 return;
 360         }
 361
 362         if(rcv_addr.gen->sa_family==AF_INET){
 363                 /*IPv4*/
 364                 if(memcmp(&rcv_addr.ipv4->sin_addr,&dest_addr.ipv4->sin_addr,
 365                                 sizeof(dest_addr.ipv4->sin_addr))!=0){ //not from destination
 366                         dbgprintf(1,"DCCP packet from 3rd host\n");
 367                         free(rcv_addr.gen);
 368                         return;
 369                 }
 370                 if(rlen < sizeof(struct dccp_hdr)+sizeof(struct iphdr)){ //check packet size
 371
 372                         dbgprintf(1, "Packet smaller than possible DCCP packet received on DCCP socket\n");
 373                         free(rcv_addr.gen);
 374                         return;
 375                 }
 376                 iph=(struct iphdr*)rbuffer;
 377                 ptr=rbuffer+iph->ihl*4;
 378         }else{
 379                 /*IPv6*/
 380                 if(memcmp(&rcv_addr.ipv6->sin6_addr, &dest_addr.ipv6->sin6_addr,
 381                                 sizeof(dest_addr.ipv6->sin6_addr))!=0){ //not from destination
 382                         dbgprintf(1,"DCCP packet from 3rd host\n");
 383                         free(rcv_addr.gen);
 384                         return;
 385                 }
 386                 if(rlen < sizeof(struct dccp_hdr)){ //check packet size
 387
 388                         dbgprintf(1, "Packet smaller than possible DCCP packet received on DCCP socket\n");
 389                         free(rcv_addr.gen);
 390                         return;
 391                 }
 392                 ptr=rbuffer;
 393         }
 394
 395         /*DCCP checks*/
 396         dhdr=(struct dccp_hdr*)ptr;
 397         if(dhdr->dccph_sport!=htons(dest_port)){
 398                 dbgprintf(1,"DCCP packet with wrong Source Port (%i)\n", ntohs(dhdr->dccph_sport));
 399                 free(rcv_addr.gen);
 400                 return;
 401         }
 402         if(dhdr->dccph_dport!=htons(dest_port)){
 403                 dbgprintf(1,"DCCP packet with wrong Destination Port\n");
 404                 free(rcv_addr.gen);
 405                 return;
 406         }
 407
 408         /*Print Message*/
 409         if(dhdr->dccph_type==DCCP_PKT_RESET){
 410                 /*Print Message*/
 411                 if(ip_type==AF_INET){
 412                         dbgprintf(0, "Got DCCP RESET from %s\n",inet_ntop(ip_type, (void*)&rcv_addr.ipv4->sin_addr, pbuf, 1000));
 413                 }else{
 414                         dbgprintf(0, "Got DCCP RESET from %s\n",inet_ntop(ip_type, (void*)&rcv_addr.ipv6->sin6_addr, pbuf, 1000));
 415                 }
 416                 /*Nothing else to do*/
 417         }
 418         if(dhdr->dccph_type==DCCP_PKT_RESPONSE){
 419                 /*Print Message*/
 420                 if(ip_type==AF_INET){
 421                         dbgprintf(0, "Got DCCP RESPONSE from %s\n",inet_ntop(ip_type, (void*)&rcv_addr.ipv4->sin_addr, pbuf, 1000));
 422                 }else{
 423                         dbgprintf(0, "Got DCCP RESPONSE from %s\n",inet_ntop(ip_type, (void*)&rcv_addr.ipv6->sin6_addr, pbuf, 1000));
 424                 }
 425                 /*Send Close back*/
 426         }
 427         if(dhdr->dccph_type==DCCP_PKT_SYNC || dhdr->dccph_type==DCCP_PKT_SYNCACK){
 428                 /*Print Message*/
 429                 if(ip_type==AF_INET){
 430                         dbgprintf(0, "Got DCCP SYNC from %s\n",inet_ntop(ip_type, (void*)&rcv_addr.ipv4->sin_addr, pbuf, 1000));
 431                 }else{
 432                         dbgprintf(0, "Got DCCP SYNC from %s\n",inet_ntop(ip_type, (void*)&rcv_addr.ipv6->sin6_addr, pbuf, 1000));
 433                 }
 434                 /*Send Reset*/
 435         }
 436
 437         free(rcv_addr.gen);
 438 }
 439
 440 void handleICMP4packet(int rcv_socket){
 441         int rlen=1500;
 442         unsigned char rbuffer[rlen];
 443         char pbuf[1000];
 444         struct sockaddr_in rcv_addr;
 445         socklen_t rcv_addr_len=sizeof(struct sockaddr_in);
 446         struct icmphdr *icmp4;
 447
 448         /*Receive Packet*/
 449         if((rlen=recvfrom(rcv_socket, &rbuffer, 1000,0,(struct sockaddr*)&rcv_addr,&rcv_addr_len))<0){
 450                 dbgprintf(0, "Error on receive from ICMPv4 socket (%s)\n",strerror(errno));
 451         }
 452
 453         if(rlen < sizeof(struct icmphdr)){ //check packet size
 454                 dbgprintf(1, "Packet smaller than possible ICMPv4 packet!\n");
 455                 return;
 456         }
 457
 458         icmp4=(struct icmphdr*)rbuffer;
 459         if(icmp4->type!=3 && icmp4->type!=11){ //check icmp types
 460                 dbgprintf(1, "Tossing ICMPv4 packet of type %i\n", icmp4->type);
 461                 return;
 462         }
 463
 464         /*Print Message*/
 465         dbgprintf(0, "Got ICMPv4 type %i from %s\n", icmp4->type,
 466                         inet_ntop(ip_type, (void*)&rcv_addr.sin_addr, pbuf, 1000));
 467 }
 468
 469 void handleICMP6packet(int rcv_socket){
 470         int rlen=1500;
 471         unsigned char rbuffer[rlen];
 472         char pbuf[1000];
 473         struct sockaddr_in6 rcv_addr;
 474         socklen_t rcv_addr_len=sizeof(struct sockaddr_in6);
 475         struct icmp6_hdr *icmp6;
 476
 477         /*Receive Packet*/
 478         if((rlen=recvfrom(rcv_socket, &rbuffer, 1000,0,(struct sockaddr*)&rcv_addr,&rcv_addr_len))<0){
 479                 dbgprintf(0, "Error on receive from ICMPv6 socket (%s)\n",strerror(errno));
 480         }
 481
 482         if(rlen < sizeof(struct icmp6_hdr)){ //check packet size
 483                 dbgprintf(1, "Packet smaller than possible ICMPv6 packet!\n");
 484                 return;
 485         }
 486
 487         icmp6=(struct icmp6_hdr*)rbuffer;
 488         if(icmp6->icmp6_type!=1 && icmp6->icmp6_type!=2 && icmp6->icmp6_type!=3
 489                         && icmp6->icmp6_type!=4){ //check icmp types
 490                 dbgprintf(1, "Tossing ICMPv6 packet of type %i\n", icmp6->icmp6_type);
 491                 return;
 492         }
 493
 494         /*Print Message*/
 495         dbgprintf(0, "Got ICMPv6 type %i from %s\n", icmp6->icmp6_type,
 496                         inet_ntop(ip_type, (void*)&rcv_addr.sin6_addr, pbuf, 1000));
 497 }
 498
 499 void buildRequestPacket(unsigned char* buffer, int *len){
 500         struct dccp_hdr *dhdr;
 501         struct dccp_hdr_ext *dhdre;
 502         struct dccp_hdr_request *dhdrr;
 503         struct iphdr* ip4hdr;
 504         struct ip6_hdr* ip6hdr;
 505
 506         int ip_hdr_len;
 507         int dccp_hdr_len=sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_request);
 508         int seq=8;
 509
 510         if(*len < dccp_hdr_len+sizeof(struct ip6_hdr)){
 511                 dbgprintf(0, "Error: Insufficient buffer space\n");
 512                 exit(1);
 513         }
 514
 515         memset(buffer, 0, *len);
 516
 517         /*IP header*/
 518         ip4hdr=NULL;
 519         if(ip_type==AF_INET){
 520                 ip_hdr_len=sizeof(struct iphdr);
 521                 ip4hdr=(struct iphdr*)buffer;
 522                 ip4hdr->check=htons(0);
 523                 memcpy(&ip4hdr->daddr, &dest_addr.ipv4->sin_addr, sizeof(dest_addr.ipv4->sin_addr));
 524                 ip4hdr->frag_off=htons(0);
 525                 ip4hdr->id=htons(1);//first
 526                 ip4hdr->ihl=5;
 527                 ip4hdr->protocol=IPPROTO_DCCP;
 528                 memcpy(&ip4hdr->saddr, &src_addr.ipv4->sin_addr, sizeof(src_addr.ipv4->sin_addr));
 529                 ip4hdr->tos=0;
 530                 ip4hdr->tot_len=htons(ip_hdr_len+dccp_hdr_len);
 531                 ip4hdr->ttl=ttl;
 532                 ip4hdr->version=4;
 533         }else{
 534                 ip_hdr_len=sizeof(struct ip6_hdr);
 535                 ip6hdr=(struct ip6_hdr*)buffer;
 536                 memcpy(&ip6hdr->ip6_dst, &dest_addr.ipv6->sin6_addr, sizeof(dest_addr.ipv6->sin6_addr));
 537                 memcpy(&ip6hdr->ip6_src, &src_addr.ipv6->sin6_addr, sizeof(src_addr.ipv6->sin6_addr));
 538                 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_flow=htonl(6<<28); //version, traffic class, flow label
 539                 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_hlim=ttl;
 540                 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt=IPPROTO_DCCP;
 541                 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_plen=htons(dccp_hdr_len);
 542         }
 543
 544         /*DCCP header*/
 545         dhdr=(struct dccp_hdr*)(buffer+ip_hdr_len);
 546         dhdre=(struct dccp_hdr_ext*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr));
 547         dhdrr=(struct dccp_hdr_request*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
 548         dhdr->dccph_ccval=0;
 549         dhdr->dccph_checksum=0;
 550         dhdr->dccph_cscov=0;
 551         dhdr->dccph_doff=dccp_hdr_len/4;
 552         dhdr->dccph_dport=htons(dest_port);
 553         dhdr->dccph_reserved=0;
 554         dhdr->dccph_sport=htons(dest_port);
 555         dhdr->dccph_x=1;
 556         dhdr->dccph_type=DCCP_PKT_REQUEST;
 557         dhdr->dccph_seq2=htonl(0); //Reserved if using 48 bit sequence numbers
 558         dhdr->dccph_seq=htonl(0);  //High 16bits of sequence number. Always make 0 for simplicity.
 559         dhdre->dccph_seq_low=htonl(seq);
 560         dhdrr->dccph_req_service= htonl(0x50455246);
 561
 562         /*Checksums*/
 563         if(ip_type==AF_INET){
 564                 dhdr->dccph_checksum=ipv4_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
 565                                 (unsigned char*) &dest_addr.ipv4->sin_addr,
 566                                 (unsigned char*)&src_addr.ipv4->sin_addr, IPPROTO_DCCP);
 567                 ip4hdr->check=ipv4_chksum(buffer,ip_hdr_len);
 568         }else{
 569                 dhdr->dccph_checksum=ipv6_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
 570                                 (unsigned char*) &dest_addr.ipv6->sin6_addr,
 571                                 (unsigned char*)&src_addr.ipv6->sin6_addr, IPPROTO_DCCP);
 572         }
 573         *len=ip_hdr_len+dccp_hdr_len;
 574         return;
 575 }
 576
 577 void updateRequestPacket(unsigned char* buffer, int *len){
 578         struct dccp_hdr *dhdr;
 579         struct dccp_hdr_ext *dhdre;
 580         struct iphdr* ip4hdr;
 581
 582         int ip_hdr_len;
 583         int dccp_hdr_len=sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_request);
 584         int tmp;
 585
 586         /*IP header*/
 587         ip4hdr=NULL;
 588         if(ip_type==AF_INET){
 589                 ip_hdr_len=sizeof(struct iphdr);
 590                 ip4hdr=(struct iphdr*)buffer;
 591                 ip4hdr->check=htons(0);
 592                 tmp=ntohs(ip4hdr->id);
 593                 ip4hdr->id=htons(tmp+1);
 594         }else{
 595                 ip_hdr_len=sizeof(struct ip6_hdr);
 596         }
 597
 598         /*DCCP header*/
 599         dhdr=(struct dccp_hdr*)(buffer+ip_hdr_len);
 600         dhdre=(struct dccp_hdr_ext*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr));
 601         dhdr->dccph_checksum=0;
 602         tmp=ntohl(dhdre->dccph_seq_low);
 603         dhdre->dccph_seq_low=htonl(tmp+1);
 604
 605         /*Checksums*/
 606         if(ip_type==AF_INET){
 607                 dhdr->dccph_checksum=ipv4_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
 608                                 (unsigned char*) &dest_addr.ipv4->sin_addr,
 609                                 (unsigned char*)&src_addr.ipv4->sin_addr, IPPROTO_DCCP);
 610                 ip4hdr->check=ipv4_chksum(buffer,ip_hdr_len);
 611         }else{
 612                 dhdr->dccph_checksum=ipv6_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
 613                                 (unsigned char*) &dest_addr.ipv6->sin6_addr,
 614                                 (unsigned char*)&src_addr.ipv6->sin6_addr, IPPROTO_DCCP);
 615         }
 616         *len=ip_hdr_len+dccp_hdr_len;
 617         return;
 618 }
 619
 620 /*Usage information for program*/
 621 void usage()
 622 {
 623         dbgprintf(0, "dccpping: [-d] [-6|-4] [-c count] [-p port] [-i interval] [-t ttl] [-S srcaddress] remote_host\n");
 624         exit(0);
 625 }
 626
 627 /*Program will probably be run setuid, so be extra careful*/
 628 void sanitize_environment()
 629 {
 630 #if defined(_SVID_SOURCE) || defined(_XOPEN_SOURCE)
 631         clearenv();
 632 #else
 633         extern char **environ;
 634         environ = NULL;
 635 #endif
 636 }
 637
 638 /*Debug Printf*/
 639 void dbgprintf(int level, const char *fmt, ...)
 640 {
 641     va_list args;
 642     if(debug>=level){
 643         va_start(args, fmt);
 644         vfprintf(stderr, fmt, args);
 645         va_end(args);
 646     }
 647 }