tools/tools/net80211/wesside/dics/dics.c

   1 /*-
   2  * Copyright (c) 2006, Andrea Bittau <a.bittau@cs.ucl.ac.uk>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/tools/tools/net80211/wesside/dics/dics.c,v 1.1 2006/08/07 00:05:03 sam Exp $
  27  */
  28 #include <sys/types.h>
  29 #include <sys/socket.h>
  30 #include <sys/select.h>
  31 #include <netinet/in.h>
  32 #include <arpa/inet.h>
  33 #include <netinet/in_systm.h>
  34 #include <netinet/ip.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <unistd.h>
  38 #include <string.h>
  39 #define __FAVOR_BSD
  40 #include <netinet/udp.h>
  41
  42 #if 0
  43 #include <pcap.h>
  44 #endif
  45
  46 #define MAGIC_LEN (20+8+5)
  47
  48 #define PRGA_LEN (1500-14-20-8)
  49
  50 #define BSD
  51 #define LINUX
  52
  53 #ifdef LINUX
  54 struct ippseudo {
  55         struct  in_addr ippseudo_src;   /* source internet address */
  56         struct  in_addr ippseudo_dst;   /* destination internet address */
  57         u_char          ippseudo_pad;   /* pad, must be zero */
  58         u_char          ippseudo_p;     /* protocol */
  59         u_short         ippseudo_len;   /* protocol length */
  60 };
  61 #endif
  62
  63 #define DPORT 6969
  64 #define TTLSENT 128
  65
  66 int pps = 10;
  67 int poll_rate =5;
  68
  69 /********** RIPPED
  70 ************/
  71 unsigned short in_cksum (unsigned short *ptr, int nbytes) {
  72   register long sum;
  73   u_short oddbyte;
  74   register u_short answer;
  75
  76   sum = 0;
  77   while (nbytes > 1)
  78     {
  79       sum += *ptr++;
  80       nbytes -= 2;
  81     }
  82
  83   if (nbytes == 1)
  84     {
  85       oddbyte = 0;
  86       *((u_char *) & oddbyte) = *(u_char *) ptr;
  87       sum += oddbyte;
  88     }
  89
  90   sum = (sum >> 16) + (sum & 0xffff);
  91   sum += (sum >> 16);
  92   answer = ~sum;
  93   return (answer);
  94 }
  95 /**************
  96 ************/
  97
  98 void hexdump(unsigned char *ptr, int len) {
  99         while(len > 0) {
 100                 printf("%.2X ", *ptr);
 101                 ptr++; len--;
 102         }
 103         printf("\n");
 104 }
 105
 106 int check_signal(int s, char* ip, unsigned char* ttl, unsigned short* port) {
 107         unsigned char buf[1024];
 108         int rd;
 109         struct msghdr msg;
 110         struct iovec iv;
 111         struct sockaddr_in s_in;
 112         struct {
 113                 struct cmsghdr hdr;
 114                 unsigned char ttl;
 115         } ctl;
 116
 117         iv.iov_base = buf;
 118         iv.iov_len = sizeof(buf);
 119
 120         memset(&msg, 0, sizeof(msg));
 121         memset(&ctl, 0, sizeof(ctl));
 122         msg.msg_name = &s_in;
 123         msg.msg_namelen = sizeof(s_in);
 124         msg.msg_iov = &iv;
 125         msg.msg_iovlen = 1;
 126         msg.msg_control = &ctl;
 127         msg.msg_controllen = sizeof(ctl);
 128
 129         rd = recvmsg(s, &msg, 0);
 130         if (rd == -1) {
 131                 perror("recvmsg()");
 132                 exit(1);
 133         }
 134
 135         if (rd != 5)
 136                 return 0;
 137
 138         if ( ctl.hdr.cmsg_level != IPPROTO_IP ||
 139 #ifdef LINUX
 140             ctl.hdr.cmsg_type != IP_TTL
 141 #else
 142             ctl.hdr.cmsg_type != IP_RECVTTL
 143 #endif
 144             ) {
 145
 146             printf("Didn't get ttl! len=%d level=%d type=%d\n",
 147                    ctl.hdr.cmsg_len, ctl.hdr.cmsg_level, ctl.hdr.cmsg_type);
 148             exit(1);
 149         }
 150
 151         if (memcmp(buf, "sorbo", 5) != 0)
 152                 return 0;
 153
 154         strcpy(ip, inet_ntoa(s_in.sin_addr));
 155         *ttl = ctl.ttl;
 156         *port = ntohs(s_in.sin_port);
 157         return 1;
 158 }
 159
 160 #if 0
 161 int check_signal(const unsigned char* buf, int rd,
 162                  char* ip, char* ttl, unsigned short *port) {
 163         int got_it;
 164         struct ip* iph;
 165         struct udphdr* uh;
 166
 167         if (rd != MAGIC_LEN)
 168                 return 0;
 169
 170         iph = (struct ip*) buf;
 171         uh = (struct udphdr*) ((char*)iph + 20);
 172
 173         if ( htons(uh->uh_dport) != DPORT)
 174                 return 0;
 175
 176         got_it = memcmp(&buf[rd-5], "sorbo", 5) == 0;
 177
 178         strcpy(ip, inet_ntoa(iph->ip_src));
 179         *ttl = iph->ip_ttl;
 180
 181         *port = ntohs(uh->uh_sport);
 182         return got_it;
 183 }
 184 #endif
 185
 186 unsigned int udp_checksum(unsigned char *stuff0, int len, struct in_addr *sip,
 187                           struct in_addr *dip) {
 188         unsigned char *stuff;
 189         struct ippseudo *ph;
 190
 191         stuff = (unsigned char*) malloc(len + sizeof(struct ippseudo));
 192         if(!stuff) {
 193                 perror("malloc()");
 194                 exit(1);
 195         }
 196
 197         ph = (struct ippseudo*) stuff;
 198
 199         memcpy(&ph->ippseudo_src, sip, 4);
 200         memcpy(&ph->ippseudo_dst, dip, 4);
 201         ph->ippseudo_pad =  0;
 202         ph->ippseudo_p = IPPROTO_UDP;
 203         ph->ippseudo_len = htons(len);
 204
 205         memcpy(stuff + sizeof(struct ippseudo), stuff0, len);
 206
 207         return in_cksum((unsigned short*)stuff, len+sizeof(struct ippseudo));
 208 }
 209
 210 void send_stuff(int s, char* sip, char* ip, unsigned short port, int dlen) {
 211         static unsigned char buf[PRGA_LEN+128] = "\x69";
 212         static int plen = 0;
 213         static struct sockaddr_in dst;
 214         int rd;
 215         struct in_addr tmp_dst;
 216         int stuff, delay;
 217         int i;
 218
 219         stuff = poll_rate*pps;
 220         delay = (int) ((double)1.0/pps*1000.0*1000.0);
 221
 222         inet_aton(ip, &tmp_dst);
 223         if (tmp_dst.s_addr != dst.sin_addr.s_addr ||
 224             dlen != (plen - 20 - 8)) {
 225
 226             buf[0] = '\x69';
 227         }
 228
 229         // create packet
 230         if (buf[0] == '\x69') {
 231                 struct ip* iph;
 232                 struct udphdr* uh;
 233                 char* ptr;
 234
 235 //              printf("Initializing packet...\n");
 236                 memset(buf, 0, sizeof(buf));
 237                 iph = (struct ip*) buf;
 238                 iph->ip_hl = 5;
 239                 iph->ip_v = 4;
 240                 iph->ip_tos = 0;
 241                 iph->ip_len = htons(20+8+dlen);
 242                 iph->ip_id = htons(666);
 243                 iph->ip_off = 0;
 244                 iph->ip_ttl = TTLSENT;
 245                 iph->ip_p = IPPROTO_UDP;
 246                 iph->ip_sum = 0;
 247
 248                 inet_aton(sip, &iph->ip_src);
 249                 inet_aton(ip, &iph->ip_dst);
 250
 251                 memset(&dst, 0, sizeof(dst));
 252                 dst.sin_family = PF_INET;
 253                 dst.sin_port = htons(port);
 254                 memcpy(&dst.sin_addr, &iph->ip_dst, sizeof(dst.sin_addr));
 255
 256                 iph->ip_sum = in_cksum((unsigned short*)iph, 20);
 257
 258                 uh = (struct udphdr*) ((char*)iph + 20);
 259                 uh->uh_sport = htons(DPORT);
 260                 uh->uh_dport = htons(port);
 261                 uh->uh_ulen = htons(8+dlen);
 262                 uh->uh_sum = 0;
 263
 264                 ptr = (char*) uh + 8;
 265
 266                 memset(ptr, 0, dlen);
 267
 268                 uh->uh_sum = udp_checksum((unsigned char*)uh, 8+dlen,
 269                                           &iph->ip_src, &iph->ip_dst);
 270
 271 #ifdef BSD
 272                 iph->ip_len = ntohs(iph->ip_len);
 273 #endif
 274                 plen = 20+8+dlen;
 275         }
 276 #if 0
 277         printf("Packet %d %s %d\n", plen, inet_ntoa(dst.sin_addr),
 278         ntohs(dst.sin_port));
 279         hexdump (buf, plen);
 280 #endif
 281
 282 //      printf("sending stuff to %s\n", ip);
 283         for (i = 0; i < stuff; i++) {
 284                 rd = sendto(s, buf, plen, 0, (struct sockaddr*)&dst, sizeof(dst));
 285                 if (rd == -1) {
 286                         perror("sendto()");
 287                         exit(1);
 288                 }
 289                 if (rd != plen) {
 290                         printf("wrote %d out of %d\n", rd, plen);
 291                         exit(1);
 292                 }
 293
 294                 // sending ttl..
 295                 if (dlen != PRGA_LEN)
 296                         break;
 297                 usleep(delay);
 298         }
 299 }
 300
 301 int main(int argc, char *argv[]) {
 302         int s, us;
 303         int rd = 1;
 304
 305 #if 0
 306         const u_char* buf;
 307         char errbuf[PCAP_ERRBUF_SIZE];
 308         struct pcap_pkthdr phdr;
 309         pcap_t* p;
 310         int dtl;
 311 #endif
 312
 313         int got_it = 0;
 314         char ip[16] = "\x00";
 315         unsigned char ttl = 0;
 316         unsigned short port;
 317         struct sockaddr_in s_in;
 318         struct timeval tv;
 319         fd_set rfds;
 320         unsigned char* sip = NULL;
 321
 322         if (argc < 2) {
 323                 printf("Usage: %s <sip> [pps]\n", argv[0]);
 324                 exit(1);
 325         }
 326
 327         if (argc > 2) {
 328                 pps = atoi(argv[2]);
 329         }
 330
 331         printf("PPS=%d\n", pps);
 332
 333         sip = argv[1];
 334
 335         memset(&s_in, 0, sizeof(&s_in));
 336         us = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP);
 337         if (s == -1) {
 338                 perror("socket()");
 339                 exit(1);
 340         }
 341         s_in.sin_family = PF_INET;
 342         s_in.sin_addr.s_addr = INADDR_ANY;
 343         s_in.sin_port = htons(DPORT);
 344         if (bind (us, (struct sockaddr*)&s_in, sizeof(s_in)) == -1) {
 345                 perror("bind()");
 346                 exit(1);
 347         }
 348
 349         rd = 1;
 350         if (setsockopt(us, IPPROTO_IP, IP_RECVTTL, &rd, sizeof(rd)) == -1) {
 351                 perror("setsockopt()");
 352                 exit(1);
 353         }
 354
 355         s = socket (PF_INET, SOCK_RAW, IPPROTO_UDP);
 356         if (s == -1) {
 357                 perror("socket()");
 358                 exit(1);
 359         }
 360
 361         rd = 1;
 362         if (setsockopt(s, IPPROTO_IP, IP_HDRINCL, &rd, sizeof(rd)) == -1) {
 363                 perror("setsockopt()");
 364                 exit(1);
 365         }
 366
 367
 368 #if 0
 369         p = pcap_open_live(argv[1], 512, 0, 25, errbuf);
 370         if (!p) {
 371                 printf("pcap_open_live(): %s\n", errbuf);
 372                 exit(1);
 373         }
 374
 375         dtl = pcap_datalink(p);
 376
 377         switch (dtl) {
 378                 case DLT_NULL:
 379                         dtl = 4;
 380                         break;
 381
 382                 case DLT_EN10MB:
 383                         dtl = 14;
 384                         break;
 385
 386                 default:
 387                         printf("Unknown datalink %d\n", dtl);
 388                         exit(1);
 389         }
 390
 391         printf("Datalink size=%d\n", dtl);
 392 #endif
 393         while (1) {
 394 #if 0
 395                 buf = pcap_next(p, &phdr);
 396                 if (buf) {
 397                         if (check_signal(buf+dtl, phdr.caplen-dtl,
 398                                          ip, &ttl, &port)) {
 399                                 got_it = 2;
 400                                 printf("Got signal from %s:%d TTL=%d\n",
 401                                        ip, port, ttl);
 402                         }
 403                 }
 404 #endif
 405                 FD_ZERO(&rfds);
 406                 FD_SET(us, &rfds);
 407                 tv.tv_sec = 0;
 408                 tv.tv_usec = 10*1000;
 409                 rd = select(us+1, &rfds, NULL, NULL, &tv);
 410                 if (rd == -1) {
 411                         perror("select()");
 412                         exit(1);
 413                 }
 414                 if (rd == 1 && FD_ISSET(us, &rfds)) {
 415                         char ipnew[16];
 416                         unsigned char ttlnew;
 417                         if (check_signal(us, ipnew, &ttlnew, &port)) {
 418                                 int send_ttl = 0;
 419                                 if (ttlnew != ttl || strcmp(ipnew, ip) != 0 ||
 420                                     got_it == 0) {
 421                                         send_ttl = 1;
 422                                 }
 423                                 ttl = ttlnew;
 424                                 strcpy(ip, ipnew);
 425
 426                                 printf("Got signal from %s:%d TTL=%d\n",
 427                                        ip, port, ttl);
 428                                 got_it = 2;
 429
 430                                 if (send_ttl) {
 431                                         printf("Sending ttl (%d)...\n", ttl);
 432                                         send_stuff(s, sip, ip, port, 69 + (TTLSENT-ttl));
 433                                 }
 434                         }
 435                 }
 436
 437                 if (got_it) {
 438                         printf("Sending stuff to %s...\n", ip);
 439                         send_stuff(s, sip, ip, port, PRGA_LEN);
 440                         got_it--;
 441
 442                         if (got_it == 0) {
 443                                 printf("Stopping send\n");
 444                         }
 445                 }
 446         }
 447
 448 #if 0
 449         pcap_close(p);
 450 #endif
 451
 452         close(s);
 453         close(us);
 454         exit(0);
 455 }