+ packet_seq=rand();
+ buildRequestPacket(sbuffer,&slen,packet_seq);
+ if(parms.ip_type==AF_INET){
+ addrlen=sizeof(struct sockaddr_in);
+ }else{
+ addrlen=sizeof(struct sockaddr_in6);
+ }
+
+ /*Start Message*/
+ printf("PINGING %s (%s) on DCCP port %i\n",parms.hostname, addr2str(&parms.dest_addr,1),parms.dest_port);
+
+ while(!done){
+ /*Send Ping*/
+ if(sendto(rs, &sbuffer, slen, MSG_DONTWAIT,(struct sockaddr*)parms.dest_addr.gen,addrlen)<0){
+ if(errno!=EINTR){
+ dbgprintf(0,"Error: sendto() failed (%s)\n",strerror(errno));
+ }
+ }
+ if(parms.count==0){done=1; break;}
+
+ if (logPacket(request_seq,packet_seq)<0){
+ dbgprintf(0,"Error: Couldn't record request!\n");
+ }
+ dbgprintf(2, "Sending DCCP Request to %s\n", addr2str(&parms.dest_addr,1));
+
+ /*Use select to wait on packets or until interval has passed*/
+ add.tv_sec=parms.interval/1000;
+ add.tv_usec=(parms.interval%1000)*1000;
+ gettimeofday(&t,NULL);
+ timeradd(&t,&add,&delay);
+ while(timercmp(&t,&delay,<)){
+ /*Prepare for select*/
+ FD_ZERO(&sel);
+ FD_SET(ds,&sel);
+ FD_SET(is4,&sel);
+ FD_SET(is6,&sel);
+ timersub(&delay,&t,&timeout);
+
+ /*Do select call*/
+ if(select(MAX(ds+1,MAX(is4+1,is6+1)),&sel, NULL,NULL,&timeout)<0){
+ if(errno!=EINTR){
+ dbgprintf(0,"Select() error (%s)\n",strerror(errno));
+ }
+ }
+ if(parms.count==0){done=1;break;}
+
+ if(FD_ISSET(ds,&sel)){
+ /*Data on the DCCP socket*/
+ handleDCCPpacket(ds,rs);
+
+ }
+ if(FD_ISSET(is4,&sel) && parms.ip_type==AF_INET){
+ /*Data on the ICMPv4 socket*/
+ handleICMP4packet(is4);
+ }
+ if(FD_ISSET(is6,&sel) && parms.ip_type==AF_INET6){
+ /*Data on the ICMPv6 socket*/
+ handleICMP6packet(is6);
+ }
+ gettimeofday(&t,NULL);
+ }
+
+ /*Update count*/
+ if(parms.count>-1){
+ parms.count--;
+ }
+ request_seq++;
+ packet_seq=rand();
+ updateRequestPacket(sbuffer,&slen, packet_seq);
+ }
+
+ printStats();
+
+ close(rs);
+ close(is4);
+ close(is6);
+ close(ds);
+}
+
+void handleDCCPpacket(int rcv_socket, int send_socket){
+ int rlen=1500;
+ unsigned char rbuffer[rlen];
+ ipaddr_ptr_t rcv_addr;
+ socklen_t rcv_addr_len;
+ struct dccp_hdr *dhdr;
+ struct dccp_hdr_reset *dhdr_re;
+ struct dccp_hdr_response *dhdr_rp;
+ struct dccp_hdr_ack_bits *dhdr_sync;
+ unsigned char* ptr;
+ struct iphdr* iph;
+
+ /*Memory for socket address*/
+ rcv_addr_len=sizeof(struct sockaddr_storage);
+ rcv_addr.gen=malloc(rcv_addr_len);
+ if(rcv_addr.gen==NULL){
+ dbgprintf(0,"Error: Can't Allocate Memory!\n");
+ exit(1);
+ }
+
+ /*Receive Packet*/
+ rcv_addr_len=sizeof(struct sockaddr_storage);
+ if((rlen=recvfrom(rcv_socket, &rbuffer, 1500,0,rcv_addr.gen,&rcv_addr_len))<0){
+ if(errno!=EINTR){
+ dbgprintf(0, "Error on receive from DCCP socket (%s)\n",strerror(errno));
+ }
+ }
+ if(rlen<0){
+ return;
+ }
+
+ if(rcv_addr.gen->sa_family!=parms.ip_type){ //confirm IP type
+ dbgprintf(2, "DCCP packet on %s. Tossing.\n", (parms.ip_type==AF_INET) ? "IPv4" : "IPv6");
+ free(rcv_addr.gen);
+ return;
+ }
+
+ if(rcv_addr.gen->sa_family==AF_INET){
+ /*IPv4*/
+ if(memcmp(&rcv_addr.ipv4->sin_addr,&parms.dest_addr.ipv4->sin_addr,
+ sizeof(parms.dest_addr.ipv4->sin_addr))!=0){ //not from destination
+ dbgprintf(2,"DCCP packet from 3rd host\n");
+ free(rcv_addr.gen);
+ return;
+ }
+ if(rlen < sizeof(struct dccp_hdr)+sizeof(struct iphdr)){ //check packet size
+
+ dbgprintf(2, "Packet smaller than possible DCCP packet received on DCCP socket\n");
+ free(rcv_addr.gen);
+ return;
+ }
+ iph=(struct iphdr*)rbuffer;
+ ptr=rbuffer+iph->ihl*4;
+ }else{
+ /*IPv6*/
+ if(memcmp(&rcv_addr.ipv6->sin6_addr, &parms.dest_addr.ipv6->sin6_addr,
+ sizeof(parms.dest_addr.ipv6->sin6_addr))!=0){ //not from destination
+ dbgprintf(2,"DCCP packet from 3rd host\n");
+ free(rcv_addr.gen);
+ return;
+ }
+ if(rlen < sizeof(struct dccp_hdr)){ //check packet size
+
+ dbgprintf(2, "Packet smaller than possible DCCP packet received on DCCP socket\n");
+ free(rcv_addr.gen);
+ return;
+ }
+ ptr=rbuffer;
+ }
+
+ /*DCCP checks*/
+ dhdr=(struct dccp_hdr*)ptr;
+ if(dhdr->dccph_sport!=htons(parms.dest_port)){
+ dbgprintf(2,"DCCP packet with wrong Source Port (%i)\n", ntohs(dhdr->dccph_sport));
+ free(rcv_addr.gen);
+ return;
+ }
+ if(dhdr->dccph_dport!=htons(parms.src_port)){
+ dbgprintf(2,"DCCP packet with wrong Destination Port\n");
+ free(rcv_addr.gen);
+ return;
+ }
+
+ /*Pick Response*/
+ if(dhdr->dccph_type==DCCP_PKT_RESET){
+ if(rlen < (ptr-rbuffer)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_reset)){
+ dbgprintf(2, "Tossing DCCP Reset packet that's small!\n");
+ return;
+ }
+ dhdr_re=(struct dccp_hdr_reset*)(ptr+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
+
+ /*Log*/
+ if(dhdr_re->dccph_reset_code==DCCP_RESET_CODE_NO_CONNECTION){
+ logResponse(&rcv_addr, ntohl(dhdr_re->dccph_reset_ack.dccph_ack_nr_low), DCCP_RESET,dhdr_re->dccph_reset_code,0);
+ }
+ /*Nothing else to do*/
+ }
+ if(dhdr->dccph_type==DCCP_PKT_RESPONSE){
+ if(rlen < (ptr-rbuffer)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_response)){
+ dbgprintf(2, "Tossing DCCP Response packet that's too small!\n");
+ return;
+ }
+
+ /*Log*/
+ dhdr_rp=(struct dccp_hdr_response*)(ptr+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
+ logResponse(&rcv_addr,ntohl(dhdr_rp->dccph_resp_ack.dccph_ack_nr_low),DCCP_RESPONSE,0,0);
+
+ /*DCCP socket opened in getAddresses() will send Reset*/
+ }
+ if(dhdr->dccph_type==DCCP_PKT_SYNC || dhdr->dccph_type==DCCP_PKT_SYNCACK){
+ if(rlen < (ptr-rbuffer)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_ack_bits)){
+ dbgprintf(2, "Tossing DCCP Sync/SyncAck packet that's too small!\n");
+ return;
+ }
+
+ /*Log*/
+ dhdr_sync=(struct dccp_hdr_ack_bits*)(ptr+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));
+ logResponse(&rcv_addr,ntohl(dhdr_sync->dccph_ack_nr_low),DCCP_SYNC,0,0);
+
+ /*DCCP socket opened in getAddresses() will send Reset*/
+ }
+
+ free(rcv_addr.gen);
+}
+
+void handleICMP4packet(int rcv_socket){
+ int rlen=1500;
+ unsigned char rbuffer[rlen];
+ ipaddr_ptr_t rcv_addr;
+ socklen_t rcv_addr_len;
+ struct icmphdr *icmp4;
+ struct dccp_hdr *dhdr;
+ struct dccp_hdr_ext *dhdre;
+ struct iphdr* ip4hdr;
+ struct iphdr* iph;
+
+ /*Memory for socket address*/
+ rcv_addr_len=sizeof(struct sockaddr_storage);
+ rcv_addr.gen=malloc(rcv_addr_len);
+ if(rcv_addr.gen==NULL){
+ dbgprintf(0,"Error: Can't Allocate Memory!\n");
+ exit(1);
+ }
+
+ /*Receive Packet*/
+ if((rlen=recvfrom(rcv_socket, &rbuffer, 1500,0,rcv_addr.gen,&rcv_addr_len))<0){
+ if(errno!=EINTR){
+ dbgprintf(0, "Error on receive from ICMPv4 socket (%s)\n",strerror(errno));
+ }
+ }
+ if(rlen<0){
+ return;
+ }
+
+ iph=(struct iphdr*)rbuffer;
+
+
+ if(rlen < sizeof(struct icmphdr)+sizeof(struct iphdr)){ //check packet size
+ dbgprintf(2, "Packet smaller than possible ICMPv4 packet!\n");
+ free(rcv_addr.gen);
+ return;
+ }
+
+ icmp4=(struct icmphdr*)(rbuffer+iph->ihl*4);
+ if(icmp4->type!=ICMP_DEST_UNREACH && icmp4->type!=ICMP_TIME_EXCEEDED){ //check icmp types
+ dbgprintf(2, "Tossing ICMPv4 packet of type %i\n", icmp4->type);
+ free(rcv_addr.gen);
+ return;
+ }
+
+ /*Check packet size again*/
+ if(rlen<sizeof(struct icmphdr)+2*sizeof(struct iphdr)+4){
+ dbgprintf(2, "Tossing ICMPv4 packet that's too small to contain DCCP header!\n");
+ free(rcv_addr.gen);
+ return;
+ }
+
+ /*Decode IPv4 header*/
+ ip4hdr=(struct iphdr*)(rbuffer+iph->ihl*4+sizeof(struct icmphdr));
+ if(memcmp(&parms.src_addr.ipv4->sin_addr,&ip4hdr->saddr,sizeof(parms.src_addr.ipv4->sin_addr))!=0){
+ /*Source address doesn't match*/
+ dbgprintf(2,"Tossing ICMPv4 packet because the embedded IPv4 source address isn't us\n");
+ free(rcv_addr.gen);
+ return;
+ }
+ if(memcmp(&parms.dest_addr.ipv4->sin_addr,&ip4hdr->daddr,sizeof(parms.dest_addr.ipv4->sin_addr))!=0){
+ /*Destination address doesn't match*/
+ dbgprintf(2,"Tossing ICMPv4 packet because the embedded IPv4 destination address isn't our target\n");
+ free(rcv_addr.gen);
+ return;
+ }
+ if(ip4hdr->protocol!=IPPROTO_DCCP){
+ /*Not DCCP!*/
+ dbgprintf(2,"Tossing ICMPv4 packet because the embedded packet isn't DCCP\n");
+ free(rcv_addr.gen);
+ return;
+ }
+
+ /*Decode DCCP header*/
+ dhdr=(struct dccp_hdr*)(rbuffer+iph->ihl*4+sizeof(struct icmphdr)+ip4hdr->ihl*4);
+ if(dhdr->dccph_dport!=htons(parms.dest_port)){
+ /*DCCP Destination Ports don't match*/
+ dbgprintf(2,"Tossing ICMPv4 packet because the embedded packet doesn't have our DCCP destination port\n");
+ free(rcv_addr.gen);
+ return;
+ }
+ if(dhdr->dccph_sport!=htons(parms.src_port)){
+ /*DCCP Source Ports don't match*/
+ dbgprintf(2,"Tossing ICMPv4 packet because the embedded packet doesn't have our DCCP source port\n");
+ free(rcv_addr.gen);
+ return;
+ }
+ dhdre=(struct dccp_hdr_ext*)(rbuffer+iph->ihl*4+sizeof(struct icmphdr)+ip4hdr->ihl*4+sizeof(struct dccp_hdr));
+
+ /*Log*/
+ if(rlen<sizeof(struct icmphdr)+2*sizeof(struct iphdr)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)){
+ logResponse(&rcv_addr,-1,ICMPv4,icmp4->type,icmp4->code);
+ }else{
+ logResponse(&rcv_addr,ntohl(dhdre->dccph_seq_low),ICMPv4,icmp4->type,icmp4->code);
+ }
+ free(rcv_addr.gen);
+ return;
+}
+
+void handleICMP6packet(int rcv_socket){
+ int rlen=1500;
+ unsigned char rbuffer[rlen];
+ ipaddr_ptr_t rcv_addr;
+ socklen_t rcv_addr_len;
+ struct icmp6_hdr *icmp6;
+ struct ip6_hdr* ip6hdr;
+ struct dccp_hdr *dhdr;
+ struct dccp_hdr_ext *dhdre;
+
+ /*Memory for socket address*/
+ rcv_addr_len=sizeof(struct sockaddr_storage);
+ rcv_addr.gen=malloc(rcv_addr_len);
+ if(rcv_addr.gen==NULL){
+ dbgprintf(0,"Error: Can't Allocate Memory!\n");
+ exit(1);
+ }
+
+ /*Receive Packet*/
+ if((rlen=recvfrom(rcv_socket, &rbuffer, 1500,0,rcv_addr.gen,&rcv_addr_len))<0){
+ dbgprintf(0, "Error on receive from ICMPv6 socket (%s)\n",strerror(errno));
+ }
+
+ if(rlen < sizeof(struct icmp6_hdr)){ //check packet size
+ dbgprintf(2, "Packet smaller than possible ICMPv6 packet!\n");
+ free(rcv_addr.gen);
+ return;
+ }
+
+ icmp6=(struct icmp6_hdr*)rbuffer;
+ if(icmp6->icmp6_type!=ICMP6_DST_UNREACH && icmp6->icmp6_type!=ICMP6_PACKET_TOO_BIG
+ && icmp6->icmp6_type!=ICMP6_TIME_EXCEEDED && icmp6->icmp6_type!=ICMP6_PARAM_PROB){ //check icmp types
+ dbgprintf(2, "Tossing ICMPv6 packet of type %i\n", icmp6->icmp6_type);
+ free(rcv_addr.gen);
+ return;
+ }
+
+ /*Check packet size again*/
+ if(rlen<sizeof(struct icmp6_hdr)+sizeof(struct ip6_hdr)+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)){
+ dbgprintf(2, "Tossing ICMPv6 packet that's too small to contain DCCP header!\n");
+ free(rcv_addr.gen);
+ return;
+ }
+
+ /*Decode IPv6 header*/
+ ip6hdr=(struct ip6_hdr*)(rbuffer+sizeof(struct icmp6_hdr));
+ if(memcmp(&parms.src_addr.ipv6->sin6_addr,&ip6hdr->ip6_src,sizeof(parms.src_addr.ipv6->sin6_addr))!=0){
+ dbgprintf(2,"Tossing ICMPv6 packet because the embedded IPv6 source address isn't us\n");
+ /*Source address doesn't match*/
+ free(rcv_addr.gen);
+ return;
+ }
+ if(memcmp(&parms.dest_addr.ipv6->sin6_addr,&ip6hdr->ip6_dst,sizeof(parms.dest_addr.ipv6->sin6_addr))!=0){
+ /*Destination address doesn't match*/
+ dbgprintf(2,"Tossing ICMPv6 packet because the embedded IPv6 destination address isn't our target\n");
+ free(rcv_addr.gen);
+ return;
+ }
+ if(ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt!=IPPROTO_DCCP){
+ /*Not DCCP!*/
+ dbgprintf(2,"Tossing ICMPv6 packet because the embedded packet isn't DCCP\n");
+ free(rcv_addr.gen);
+ return;
+ }
+
+ /*Decode DCCP header*/
+ dhdr=(struct dccp_hdr*)(rbuffer+sizeof(struct icmp6_hdr)+sizeof(struct ip6_hdr));
+ if(dhdr->dccph_dport!=htons(parms.dest_port)){
+ /*DCCP Destination Ports don't match*/
+ dbgprintf(2,"Tossing ICMPv6 packet because the embedded packet doesn't have our DCCP destination port\n");
+ free(rcv_addr.gen);
+ return;
+ }
+ if(dhdr->dccph_sport!=htons(parms.src_port)){
+ /*DCCP Source Ports don't match*/
+ dbgprintf(2,"Tossing ICMPv6 packet because the embedded packet doesn't have our DCCP source port\n");
+ free(rcv_addr.gen);
+ return;
+ }
+ dhdre=(struct dccp_hdr_ext*)(rbuffer+sizeof(struct icmp6_hdr)+sizeof(struct ip6_hdr)+sizeof(struct dccp_hdr));
+
+ /*Log*/
+ logResponse(&rcv_addr,ntohl(dhdre->dccph_seq_low), ICMPv6, icmp6->icmp6_type,icmp6->icmp6_code);
+ free(rcv_addr.gen);
+ return;
+}
+
+void buildRequestPacket(unsigned char* buffer, int *len, int seq){
+ struct dccp_hdr *dhdr;
+ struct dccp_hdr_ext *dhdre;
+ struct dccp_hdr_request *dhdrr;
+ struct iphdr* ip4hdr;
+ struct ip6_hdr* ip6hdr;
+
+ int ip_hdr_len;
+ int dccp_hdr_len=sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext)+sizeof(struct dccp_hdr_request);
+
+ if(*len < dccp_hdr_len+sizeof(struct ip6_hdr)){
+ dbgprintf(0, "Error: Insufficient buffer space\n");
+ exit(1);
+ }
+
+ memset(buffer, 0, *len);
+
+ /*IP header*/
+ ip4hdr=NULL;
+ if(parms.ip_type==AF_INET){
+ ip_hdr_len=sizeof(struct iphdr);
+ ip4hdr=(struct iphdr*)buffer;
+ ip4hdr->check=htons(0);
+ memcpy(&ip4hdr->daddr, &parms.dest_addr.ipv4->sin_addr, sizeof(parms.dest_addr.ipv4->sin_addr));
+ ip4hdr->frag_off=htons(0);
+ ip4hdr->id=htons(1);//first
+ ip4hdr->ihl=5;
+ ip4hdr->protocol=IPPROTO_DCCP;
+ memcpy(&ip4hdr->saddr, &parms.src_addr.ipv4->sin_addr, sizeof(parms.src_addr.ipv4->sin_addr));
+ ip4hdr->tos=0;
+ ip4hdr->tot_len=htons(ip_hdr_len+dccp_hdr_len);
+ ip4hdr->ttl=parms.ttl;
+ ip4hdr->version=4;
+ }else{
+ ip_hdr_len=sizeof(struct ip6_hdr);
+ ip6hdr=(struct ip6_hdr*)buffer;
+ memcpy(&ip6hdr->ip6_dst, &parms.dest_addr.ipv6->sin6_addr, sizeof(parms.dest_addr.ipv6->sin6_addr));
+ memcpy(&ip6hdr->ip6_src, &parms.src_addr.ipv6->sin6_addr, sizeof(parms.src_addr.ipv6->sin6_addr));
+ ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_flow=htonl(6<<28); //version, traffic class, flow label
+ ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_hlim=parms.ttl;
+ ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt=IPPROTO_DCCP;
+ ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_plen=htons(dccp_hdr_len);
+ }
+
+ /*DCCP header*/
+ dhdr=(struct dccp_hdr*)(buffer+ip_hdr_len);
+ dhdre=(struct dccp_hdr_ext*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr));
+ dhdrr=(struct dccp_hdr_request*)(buffer+ip_hdr_len+sizeof(struct dccp_hdr)+sizeof(struct dccp_hdr_ext));