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 <sys/types.h>
  14 #include <unistd.h>
  15 #include <time.h>
  16 #include <sys/time.h>
  17 #include <sys/socket.h>
  18 #include <linux/dccp.h>
  19 #include <netinet/ip.h>
  20 #include <netinet/ip6.h>
  21 #include <netinet/in.h>
  22 #include <netdb.h>
  23 #include <arpa/inet.h>
  24 #include <ifaddrs.h>
  25 #include <net/if.h>
  26 #include <errno.h>
  27 #include "checksums.h"
  28
  29 extern int errno;
  30
  31 typedef union ipaddr{
  32         struct sockaddr *gen;
  33         struct sockaddr_in *ipv4;
  34         struct sockaddr_in6 *ipv6;
  35 } ipaddr_ptr_t;
  36
  37
  38 int debug=0;                    /*set to 1 to turn on debugging information*/
  39 int count=-1;                   /*Default number of pings (-1 is infinity)*/
  40 int dest_port=33434;    /*Default port*/
  41 int ttl=64;                             /*Default TTL*/
  42 long interval=1000;             /*Default delay between pings in ms*/
  43 int ip_type=AF_UNSPEC;  /*IPv4 or IPv6*/
  44 ipaddr_ptr_t dest_addr;
  45 ipaddr_ptr_t src_addr;
  46
  47
  48 void getAddresses(char *src, char* dst);
  49 void doping();
  50 void buildPacket(unsigned char* buffer, int *len);
  51 void dbgprintf(int level, const char *fmt, ...);
  52 void sanitize_environment();
  53 void usage();
  54
  55
  56 /*Parse commandline options*/
  57 int main(int argc, char *argv[])
  58 {
  59         char c;
  60         char *src=NULL;
  61         char *dst=NULL;
  62
  63
  64         sanitize_environment();
  65
  66         while ((c = getopt(argc, argv, "64c:p:i:dt:S:")) != -1) {
  67                 switch (c) {
  68                         case '6':
  69                                 ip_type=AF_INET6;
  70                                 break;
  71                         case '4':
  72                                 ip_type=AF_INET;
  73                                 break;
  74                         case 'c':
  75                                 count = atoi(optarg);
  76                                 if(count<=0){
  77                                         dbgprintf(0, "Error: count must be positive");
  78                                         exit(1);
  79                                 }
  80                                 break;
  81                         case 'p':
  82                                 dest_port = atoi(optarg);
  83                                 break;
  84                         case 'i':
  85                                 interval = (long)(atof(optarg) * 1000.0);
  86                                 if (interval <= 0) {
  87                                         fprintf(stderr, "Invalid interval\n");
  88                                         exit(1);
  89                                 }
  90                                 break;
  91                         case 'd':
  92                                 debug++;
  93                                 break;
  94                         case 't':
  95                                 ttl = atoi(optarg);
  96                                 if (ttl < 1 || ttl > 255) {
  97                                         fprintf(stderr, "Invalid TTL\n");
  98                                 }
  99                                 break;
 100                         case 'S':
 101                                 src=optarg;
 102                                 //r = inet_aton(optarg, &src_ip);
 103                                 break;
 104                         default:
 105                                 usage();
 106                                 break;
 107                 }
 108         }
 109
 110         argc -= optind;
 111         argv += optind;
 112
 113         if (argc != 1) {
 114                 usage();
 115         }
 116         dst=argv[0];
 117
 118         getAddresses(src, dst);
 119
 120         doping();
 121
 122         free(src_addr.gen);
 123         free(dest_addr.gen);
 124         return 0;
 125 }
 126
 127 void getAddresses(char *src, char* dst){
 128         struct addrinfo hint;
 129         struct addrinfo *dtmp, *stmp;
 130         struct ifaddrs *temp, *cur;
 131         struct sockaddr_in6* iv6;
 132         int addrlen;
 133         int err;
 134
 135         /*Lookup destination Address*/
 136         memset(&hint,0,sizeof(struct addrinfo));
 137         hint.ai_family=ip_type;
 138         hint.ai_flags=AI_V4MAPPED | AI_ADDRCONFIG;
 139
 140         if((err=getaddrinfo(dst,NULL,&hint,&dtmp))!=0){
 141                 dbgprintf(0,"Error: Couldn't lookup destination %s (%s)\n", dst, gai_strerror(err));
 142                 exit(1);
 143         }
 144         if(dtmp==NULL){
 145                 dbgprintf(0,"Error: Unknown Host %s\n", dst);
 146                 exit(1);
 147         }else{
 148                 addrlen=dtmp->ai_addrlen;
 149                 hint.ai_family=ip_type=dtmp->ai_family;
 150                 dest_addr.gen=malloc(dtmp->ai_addrlen);
 151                 if(dest_addr.gen==NULL){
 152                         dbgprintf(0,"Error: Can't allocate Memory\n");
 153                         exit(1);
 154                 }
 155                 memcpy(dest_addr.gen,dtmp->ai_addr,dtmp->ai_addrlen);
 156         }
 157         freeaddrinfo(dtmp);
 158
 159         /*Get a meaningful source address*/
 160         if(src!=NULL){
 161                 /*Use Commandline arg*/
 162                 if((err=getaddrinfo(src,NULL,&hint,&stmp))!=0){
 163                         dbgprintf(0,"Error: Source Address %s is invalid (%s)\n", src, gai_strerror(err));
 164                         exit(1);
 165                 }
 166                 if(stmp==NULL){
 167                         dbgprintf(0,"Error: Unknown Host %s\n", dst);
 168                         exit(1);
 169                 }else{
 170                         addrlen=stmp->ai_addrlen;
 171                         src_addr.gen=malloc(stmp->ai_addrlen);
 172                         if(src_addr.gen==NULL){
 173                                 dbgprintf(0,"Error: Can't allocate Memory\n");
 174                                 exit(1);
 175                         }
 176                         memcpy(src_addr.gen,stmp->ai_addr,stmp->ai_addrlen);
 177                 }
 178                 freeaddrinfo(stmp);
 179         }else{
 180                 /*Guess a good source address*/
 181                 getifaddrs(&temp);
 182                 cur=temp;
 183                 while(cur!=NULL){
 184                         if(cur->ifa_addr==NULL || cur->ifa_addr->sa_family!=ip_type){ /*Not matching ipv4/ipv6 of dest*/
 185                                 cur=cur->ifa_next;
 186                                 continue;
 187                         }
 188                         if(cur->ifa_flags & IFF_LOOPBACK){ /*Don't use loopback addresses*/
 189                                 cur=cur->ifa_next;
 190                                 continue;
 191                         }
 192                         if(cur->ifa_addr!=NULL && cur->ifa_addr->sa_family==AF_INET6){
 193                                 iv6=(struct sockaddr_in6*)cur->ifa_addr;
 194
 195                                 if(iv6->sin6_scope_id!=0){ /*Not globally valid address, if ipv6*/
 196                                         cur=cur->ifa_next;
 197                                         continue;
 198                                 }
 199                         }
 200
 201                         src_addr.gen=malloc(sizeof(struct sockaddr_storage));
 202                         if(src_addr.gen==NULL){
 203                                 dbgprintf(0,"Error: Can't allocate Memory\n");
 204                                 exit(1);
 205                         }
 206                         src_addr.gen->sa_family=ip_type;
 207                         memcpy(src_addr.gen,cur->ifa_addr,addrlen);
 208                         //break;
 209                         cur=cur->ifa_next;
 210                 }
 211                 freeifaddrs(temp);
 212         }
 213         return;
 214 }
 215
 216 /*Preform the ping functionality*/
 217 void doping(){
 218         int rs, is,ds;
 219         int done=0;
 220         int addrlen;
 221         int slen=1500;
 222         unsigned char sbuffer[slen];
 223         unsigned char rbuffer[1000];
 224         char pbuf[1000];
 225         struct dccp_hdr *dhdr;
 226         struct sockaddr_storage rcv_addr;
 227         socklen_t rcv_addr_len=sizeof(struct sockaddr_storage);
 228         struct sockaddr_in6 *tmp;
 229         //int opt;
 230         int rlen;
 231
 232         dbgprintf(0, "In doping()\n");
 233
 234         /*Open Sockets*/
 235         rs=socket(ip_type, SOCK_RAW | SOCK_NONBLOCK ,IPPROTO_RAW);
 236         if(rs<0){
 237                 dbgprintf(0, "Error opening raw socket\n");
 238                 exit(1);
 239         }
 240         ds=socket(ip_type, SOCK_RAW | SOCK_NONBLOCK ,IPPROTO_DCCP);
 241         if(ds<0){
 242                 dbgprintf(0, "Error opening raw DCCP socket\n");
 243                 exit(1);
 244         }
 245         is=socket(ip_type,SOCK_RAW | SOCK_NONBLOCK ,IPPROTO_ICMP);
 246         if(is<0){
 247                 dbgprintf(0,"Error opening raw ICMP socket\n");
 248                 exit(1);
 249         }
 250
 251         /*opt=((unsigned char*)&dhdr->dccph_checksum) - &sbuffer[0];
 252         if (setsockopt(ds, IPPROTO_IPV6, IPV6_CHECKSUM, &opt, sizeof(opt)) < 0){
 253                 dbgprintf(0, "Error setting up checksums on raw DCCP socket (%s)\n", strerror(errno));
 254                 exit(1);
 255         }*/
 256
 257         buildPacket(sbuffer,&slen);
 258         if(ip_type==AF_INET){
 259                 addrlen=sizeof(struct sockaddr_in);
 260         }else{
 261                 addrlen=sizeof(struct sockaddr_in6);
 262         }
 263
 264         while(!done){
 265
 266                 if(sendto(rs, &sbuffer, slen, MSG_DONTWAIT,(struct sockaddr*)dest_addr.gen,addrlen)<0){
 267                         dbgprintf(0,"Error: sendto failed\n");
 268                 }
 269
 270                 if(ip_type==AF_INET){
 271                         dbgprintf(0, "Sending DCCP Request to %s\n",inet_ntop(ip_type, (void*)&dest_addr.ipv4->sin_addr, pbuf, 1000));
 272                 }else{
 273                         dbgprintf(0, "Sending DCCP Request to %s\n",inet_ntop(ip_type, (void*)&dest_addr.ipv6->sin6_addr, pbuf, 1000));
 274                 }
 275
 276                 rcv_addr_len=sizeof(struct sockaddr_storage);
 277                 if((rlen=recvfrom(ds, &rbuffer, 1000,MSG_DONTWAIT,(struct sockaddr*)&rcv_addr,&rcv_addr_len))<0){
 278                         if(errno!=EAGAIN){
 279                                 dbgprintf(0, "Error on receive from DCCP socket (%s)\n",strerror(errno));
 280                         }
 281                 }
 282                 if(rlen>0){
 283                         if(rlen< sizeof(struct dccp_hdr)){
 284                                 dbgprintf(0,"Received Non-DCCP data!\n");
 285                         }
 286                         dhdr=(struct dccp_hdr*)rbuffer;
 287                         tmp=(struct sockaddr_in6*)&rcv_addr;
 288                         dbgprintf(0,"Response from %s (%i)\n", inet_ntop(ip_type, (void*)&tmp->sin6_addr, pbuf, 1000),dhdr->dccph_type);
 289                 }
 290
 291                 if((rlen=recvfrom(is, &rbuffer, 1000,MSG_DONTWAIT,(struct sockaddr*)&rcv_addr,&rcv_addr_len))<0){
 292                         if(errno!=EAGAIN){
 293                                 dbgprintf(0, "Error on receive from ICMP socket (%s)\n",strerror(errno));
 294                         }
 295                 }
 296                 if(rlen>0){
 297                         dbgprintf(0,"Received ICMP data!\n");
 298                 }
 299
 300                 if(count>-1){
 301                         count--;
 302                 }
 303                 if(count==0){
 304                         done=1;
 305                         break;
 306                 }
 307                 sleep(interval/1000);
 308         }
 309
 310         close(rs);
 311         close(is);
 312         close(ds);
 313 }
 314
 315 void buildPacket(unsigned char* buffer, int *len){
 316         struct dccp_hdr *dhdr;
 317         struct dccp_hdr_ext *dhdre;
 318         struct dccp_hdr_request *dhdrr;
 319         struct iphdr* ip4hdr;
 320         struct ip6_hdr* ip6hdr;
 321
 322         int ip_hdr_len;
 323         int dccp_hdr_len=sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_request);
 324         int seq=8;
 325
 326         memset(buffer, 0, *len);
 327
 328         /*IP header*/
 329         ip4hdr=NULL;
 330         if(ip_type==AF_INET){
 331                 ip_hdr_len=sizeof(struct iphdr);
 332                 ip4hdr=(struct iphdr*)buffer;
 333                 ip4hdr->check=htons(0);
 334                 memcpy(&ip4hdr->daddr, &dest_addr.ipv4->sin_addr, sizeof(dest_addr.ipv4->sin_addr));
 335                 ip4hdr->frag_off=htons(0);
 336                 ip4hdr->id=htons(1);//first
 337                 ip4hdr->ihl=5;
 338                 ip4hdr->protocol=IPPROTO_DCCP;
 339                 memcpy(&ip4hdr->saddr, &src_addr.ipv4->sin_addr, sizeof(src_addr.ipv4->sin_addr));
 340                 ip4hdr->tos=0;
 341                 ip4hdr->tot_len=htons(ip_hdr_len+dccp_hdr_len);
 342                 ip4hdr->ttl=ttl;
 343                 ip4hdr->version=4;
 344         }else{
 345                 ip_hdr_len=sizeof(struct ip6_hdr);
 346                 ip6hdr=(struct ip6_hdr*)buffer;
 347                 memcpy(&ip6hdr->ip6_dst, &dest_addr.ipv6->sin6_addr, sizeof(dest_addr.ipv6->sin6_addr));
 348                 memcpy(&ip6hdr->ip6_src, &src_addr.ipv6->sin6_addr, sizeof(src_addr.ipv6->sin6_addr));
 349                 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_flow=htonl(6<<28); //version, traffic class, flow label
 350                 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_hlim=ttl;
 351                 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt=IPPROTO_DCCP;
 352                 ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_plen=htons(dccp_hdr_len);
 353         }
 354
 355         /*DCCP header*/
 356         dhdr=(struct dccp_hdr*)(buffer+ip_hdr_len);
 357         dhdre=(struct dccp_hdr_ext*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr));
 358         dhdrr=(struct dccp_hdr_request*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
 359         dhdr->dccph_ccval=0;
 360         dhdr->dccph_checksum=0;
 361         dhdr->dccph_cscov=0;
 362         dhdr->dccph_doff=dccp_hdr_len/4;
 363         dhdr->dccph_dport=htons(dest_port);
 364         dhdr->dccph_reserved=0;
 365         dhdr->dccph_sport=htons(dest_port);
 366         dhdr->dccph_x=1;
 367         dhdr->dccph_type=DCCP_PKT_REQUEST;
 368         dhdr->dccph_seq2=htonl(0); //Reserved if using 48 bit sequence numbers
 369         dhdr->dccph_seq=htonl(0);  //High 16bits of sequence number. Always make 0 for simplicity.
 370         dhdre->dccph_seq_low=htonl(seq);
 371         dhdrr->dccph_req_service= htonl(0x50455246);
 372
 373         /*Checksums*/
 374         if(ip_type==AF_INET){
 375                 dhdr->dccph_checksum=ipv4_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
 376                                 (unsigned char*) &dest_addr.ipv4->sin_addr,
 377                                 (unsigned char*)&src_addr.ipv4->sin_addr, IPPROTO_DCCP);
 378                 ip4hdr->check=ipv4_chksum(buffer,ip_hdr_len);
 379         }else{
 380                 dhdr->dccph_checksum=ipv6_pseudohdr_chksum((buffer+ip_hdr_len), dccp_hdr_len,
 381                                 (unsigned char*) &dest_addr.ipv6->sin6_addr,
 382                                 (unsigned char*)&src_addr.ipv6->sin6_addr, IPPROTO_DCCP);
 383         }
 384         *len=ip_hdr_len+dccp_hdr_len;
 385         return;
 386 }
 387
 388 /*Usage information for program*/
 389 void usage()
 390 {
 391         dbgprintf(0, "dccpping: [-d] [-6|-4] [-c count] [-p port] [-i interval] [-t ttl] [-S srcaddress] remote_host\n");
 392         exit(0);
 393 }
 394
 395 /*Program will probably be run setuid, so be extra careful*/
 396 void sanitize_environment()
 397 {
 398 #if defined(_SVID_SOURCE) || defined(_XOPEN_SOURCE)
 399         clearenv();
 400 #else
 401         extern char **environ;
 402         environ = NULL;
 403 #endif
 404 }
 405
 406 /*Debug Printf*/
 407 void dbgprintf(int level, const char *fmt, ...)
 408 {
 409     va_list args;
 410     if(debug>=level){
 411         va_start(args, fmt);
 412         vfprintf(stderr, fmt, args);
 413         va_end(args);
 414     }
 415 }