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/w00t/ap/ap.c,v 1.2 2009/07/24 15:31:22 sam Exp $ 27 */ 28 #include <sys/types.h> 29 #include <sys/select.h> 30 #include <sys/time.h> 31 #include <sys/endian.h> 32 #include <stdio.h> 33 #include <stdlib.h> 34 #include <string.h> 35 #include <unistd.h> 36 #include <err.h> 37 #include <assert.h> 38 #include "w00t.h" 39 40 struct client { 41 char mac[6]; 42 int seq; 43 44 struct client *next; 45 }; 46 47 struct params { 48 /* fds */ 49 int tx; 50 int rx; 51 int tap; 52 53 /* ap params */ 54 char mac[6]; 55 char ssid[256]; 56 int chan; 57 58 /* beacon */ 59 int bint; 60 struct timeval blast; 61 62 int seq; 63 64 /* wep */ 65 int wep_len; 66 char wep_key[13]; 67 int wep_iv; 68 69 struct client *clients; 70 71 /* lame window */ 72 char packet[4096]; 73 int packet_len; 74 int packet_try; 75 struct timeval plast; 76 }; 77 78 void usage(char *name) 79 { 80 printf("Usage: %s <opts>\n" 81 "-h\thelp\n" 82 "-i\t<iface>\n" 83 "-s\t<ssid>\n" 84 "-m\t<mac>\n" 85 "-w\t<wep key>\n" 86 "-c\t<chan>\n" 87 "-t\t<tap>\n" 88 , name); 89 exit(0); 90 } 91 92 void fill_basic(struct ieee80211_frame *wh, struct params *p) 93 { 94 short *seq; 95 96 wh->i_dur[0] = 0x69; 97 wh->i_dur[1] = 0x00; 98 99 memcpy(wh->i_addr2, p->mac, 6); 100 101 seq = (short*)wh->i_seq; 102 *seq = seqfn(p->seq, 0); 103 } 104 105 void send_frame(struct params *p, void *buf, int len) 106 { 107 int rc; 108 109 rc = inject(p->tx, buf, len); 110 if (rc == -1) 111 err(1, "inject()"); 112 if (rc != len) { 113 printf("injected %d/%d\n", rc, len); 114 exit(1); 115 } 116 p->seq++; 117 } 118 119 int fill_beacon(struct params *p, struct ieee80211_frame *wh) 120 { 121 int len; 122 char *ptr; 123 124 ptr = (char*) (wh+1); 125 ptr += 8; /* timestamp */ 126 ptr += 2; /* bint */ 127 *ptr |= IEEE80211_CAPINFO_ESS; 128 ptr += 2; /* capa */ 129 130 /* ssid */ 131 len = strlen(p->ssid); 132 *ptr++ = 0; 133 *ptr++ = len; 134 memcpy(ptr, p->ssid, len); 135 ptr += len; 136 137 /* rates */ 138 *ptr++ = 1; 139 *ptr++ = 4; 140 *ptr++ = 2 | 0x80; 141 *ptr++ = 4 | 0x80; 142 *ptr++ = 11; 143 *ptr++ = 22; 144 145 /* ds param */ 146 *ptr++ = 3; 147 *ptr++ = 1; 148 *ptr++ = p->chan; 149 150 return ptr - ((char*) wh); 151 } 152 153 void send_beacon(struct params *p) 154 { 155 char buf[4096]; 156 struct ieee80211_frame *wh; 157 int len; 158 char *ptr; 159 160 wh = (struct ieee80211_frame*) buf; 161 162 memset(buf, 0, sizeof(buf)); 163 fill_basic(wh, p); 164 memset(wh->i_addr1, 0xff, 6); 165 memcpy(wh->i_addr3, p->mac, 6); 166 167 wh->i_fc[0] |= IEEE80211_FC0_TYPE_MGT; 168 wh->i_fc[0] |= IEEE80211_FC0_SUBTYPE_BEACON; 169 170 len = fill_beacon(p, wh); 171 172 /* TIM */ 173 ptr = (char*)wh + len; 174 *ptr++ = 5; 175 *ptr++ = 4; 176 len += 2+4; 177 #if 0 178 printf("sending beacon\n"); 179 #endif 180 send_frame(p, wh, len); 181 182 if (gettimeofday(&p->blast, NULL) == -1) 183 err(1, "gettimeofday()"); 184 } 185 186 187 void send_pres(struct params *p, char *mac) 188 { 189 char buf[4096]; 190 struct ieee80211_frame *wh; 191 int len; 192 193 wh = (struct ieee80211_frame*) buf; 194 195 memset(buf, 0, sizeof(buf)); 196 fill_basic(wh, p); 197 memcpy(wh->i_addr1, mac, 6); 198 memcpy(wh->i_addr3, p->mac, 6); 199 200 wh->i_fc[0] |= IEEE80211_FC0_TYPE_MGT; 201 wh->i_fc[0] |= IEEE80211_FC0_SUBTYPE_PROBE_RESP; 202 203 len = fill_beacon(p, wh); 204 205 printf("sending probe response\n"); 206 send_frame(p, wh, len); 207 } 208 209 void read_preq(struct params *p, struct ieee80211_frame *wh, int len) 210 { 211 unsigned char *ptr; 212 unsigned char *end; 213 unsigned char macs[6*3]; 214 215 ptr = (unsigned char*) (wh+1); 216 217 /* ssid */ 218 if (*ptr != 0) { 219 printf("weird pr %x\n", *ptr); 220 return; 221 } 222 ptr++; 223 224 end = ptr + (*ptr) + 1; 225 *end = 0; 226 ptr++; 227 228 mac2str(macs, wh->i_addr2); 229 printf("Probe request for [%s] from %s\n", ptr, macs); 230 231 if ((strcmp(ptr, "") == 0) || (strcmp(ptr, p->ssid) == 0)) 232 send_pres(p, wh->i_addr2); 233 } 234 235 void send_auth(struct params* p, char *mac) 236 { 237 char buf[4096]; 238 struct ieee80211_frame *wh; 239 unsigned short *ptr; 240 int len; 241 242 wh = (struct ieee80211_frame*) buf; 243 244 memset(buf, 0, sizeof(buf)); 245 fill_basic(wh, p); 246 memcpy(wh->i_addr1, mac, 6); 247 memcpy(wh->i_addr3, p->mac, 6); 248 249 wh->i_fc[0] |= IEEE80211_FC0_TYPE_MGT; 250 wh->i_fc[0] |= IEEE80211_FC0_SUBTYPE_AUTH; 251 252 ptr = (unsigned short*) (wh+1); 253 *ptr++ = htole16(0); 254 *ptr++ = htole16(2); 255 *ptr++ = htole16(0); 256 257 len = ((char*)ptr) - ((char*) wh); 258 printf("sending auth\n"); 259 send_frame(p, wh, len); 260 } 261 262 void read_auth(struct params *p, struct ieee80211_frame *wh, int len) 263 { 264 unsigned short *ptr; 265 char mac[6*3]; 266 267 if (memcmp(wh->i_addr1, p->mac, 6) != 0) 268 return; 269 270 ptr = (unsigned short*) (wh+1); 271 if (le16toh(*ptr) != 0) { 272 printf("Unknown auth algo %d\n", le16toh(*ptr)); 273 return; 274 } 275 ptr++; 276 if (le16toh(*ptr) == 1) { 277 mac2str(mac, wh->i_addr2); 278 printf("Got auth from %s\n", mac); 279 send_auth(p, wh->i_addr2); 280 } else { 281 printf("Weird seq in auth %d\n", le16toh(*ptr)); 282 } 283 } 284 285 void send_assoc(struct params *p, char *mac) 286 { 287 char buf[4096]; 288 struct ieee80211_frame *wh; 289 char *ptr; 290 int len; 291 292 wh = (struct ieee80211_frame*) buf; 293 294 memset(buf, 0, sizeof(buf)); 295 fill_basic(wh, p); 296 memcpy(wh->i_addr1, mac, 6); 297 memcpy(wh->i_addr3, p->mac, 6); 298 299 wh->i_fc[0] |= IEEE80211_FC0_TYPE_MGT; 300 wh->i_fc[0] |= IEEE80211_FC0_SUBTYPE_ASSOC_RESP; 301 302 ptr = (char*) (wh+1); 303 *ptr |= IEEE80211_CAPINFO_ESS; 304 ptr += 2; /* cap */ 305 ptr += 2; /* status */ 306 ptr += 2; /* aid */ 307 308 /* rates */ 309 *ptr++ = 1; 310 *ptr++ = 4; 311 *ptr++ = 2 | 0x80; 312 *ptr++ = 4 | 0x80; 313 *ptr++ = 11; 314 *ptr++ = 22; 315 316 len = ptr - ((char*) wh); 317 printf("sending assoc response\n"); 318 send_frame(p, wh, len); 319 } 320 321 void read_assoc(struct params *p, struct ieee80211_frame *wh, int len) 322 { 323 unsigned char *ptr; 324 unsigned char *end; 325 unsigned char macs[6*3]; 326 327 if (memcmp(wh->i_addr1, p->mac, 6) != 0) 328 return; 329 330 ptr = (unsigned char*) (wh+1); 331 ptr += 2; /* capa */ 332 ptr += 2; /* list interval */ 333 334 /* ssid */ 335 if (*ptr != 0) { 336 printf("weird pr %x\n", *ptr); 337 return; 338 } 339 ptr++; 340 341 end = ptr + (*ptr) + 1; 342 *end = 0; 343 ptr++; 344 345 mac2str(macs, wh->i_addr2); 346 printf("Assoc request for [%s] from %s\n", ptr, macs); 347 348 if (strcmp(ptr, p->ssid) == 0) 349 send_assoc(p, wh->i_addr2); 350 } 351 352 void read_mgt(struct params *p, struct ieee80211_frame *wh, int len) 353 { 354 switch (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) { 355 case IEEE80211_FC0_SUBTYPE_PROBE_REQ: 356 read_preq(p, wh, len); 357 break; 358 359 case IEEE80211_FC0_SUBTYPE_PROBE_RESP: 360 break; 361 362 case IEEE80211_FC0_SUBTYPE_AUTH: 363 read_auth(p, wh, len); 364 break; 365 366 case IEEE80211_FC0_SUBTYPE_ASSOC_REQ: 367 read_assoc(p, wh, len); 368 break; 369 370 case IEEE80211_FC0_SUBTYPE_ASSOC_RESP: 371 case IEEE80211_FC0_SUBTYPE_BEACON: 372 break; 373 374 default: 375 printf("wtf %d\n", (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) >> 376 IEEE80211_FC0_SUBTYPE_SHIFT); 377 abort(); 378 break; 379 } 380 } 381 382 void send_cts(struct params *p, char *mac) 383 { 384 char buf[64]; 385 struct ieee80211_frame *wh; 386 387 memset(buf, 0, sizeof(buf)); 388 wh = (struct ieee80211_frame*) buf; 389 wh->i_fc[0] |= IEEE80211_FC0_TYPE_CTL; 390 wh->i_fc[0] |= IEEE80211_FC0_SUBTYPE_CTS; 391 wh->i_dur[0] = 0x69; 392 wh->i_dur[1] = 0x00; 393 memcpy(wh->i_addr1, mac, 6); 394 395 send_frame(p, wh, 10); 396 } 397 398 void read_rts(struct params *p, struct ieee80211_frame *wh, int len) 399 { 400 if (memcmp(wh->i_addr1, p->mac, 6) != 0) 401 return; 402 403 send_cts(p, wh->i_addr2); 404 } 405 406 void read_ack(struct params *p, struct ieee80211_frame *wh, int len) 407 { 408 if (memcmp(wh->i_addr1, p->mac, 6) == 0) 409 p->packet_try = 0; 410 } 411 412 void read_ctl(struct params *p, struct ieee80211_frame *wh, int len) 413 { 414 switch (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) { 415 case IEEE80211_FC0_SUBTYPE_RTS: 416 read_rts(p, wh, len); 417 break; 418 419 case IEEE80211_FC0_SUBTYPE_ACK: 420 read_ack(p, wh, len); 421 break; 422 423 case IEEE80211_FC0_SUBTYPE_CTS: 424 break; 425 426 default: 427 printf("wtf %d\n", (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) >> 428 IEEE80211_FC0_SUBTYPE_SHIFT); 429 abort(); 430 break; 431 } 432 #if 0 433 printf("ctl\n"); 434 #endif 435 } 436 437 int broadcast(struct ieee80211_frame *wh) 438 { 439 /* XXX multicast */ 440 441 if (memcmp(wh->i_addr1, "\xff\xff\xff\xff\xff\xff", 6) == 0) 442 return 1; 443 444 return 0; 445 } 446 447 void enque(struct params *p, struct ieee80211_frame *wh, int len) 448 { 449 if (broadcast(wh)) 450 return; 451 452 assert(sizeof(p->packet) >= len); 453 454 memcpy(p->packet, wh, len); 455 p->packet_len = len; 456 p->packet_try = 1; 457 458 wh = (struct ieee80211_frame*) p->packet; 459 wh->i_fc[1] |= IEEE80211_FC1_RETRY; 460 461 if (gettimeofday(&p->plast, NULL) == -1) 462 err(1, "gettimeofday()"); 463 } 464 465 void relay_data(struct params *p, struct ieee80211_frame *wh, int len) 466 { 467 char seq[2]; 468 char fc[2]; 469 unsigned short *ps; 470 471 /* copy crap */ 472 memcpy(fc, wh->i_fc, 2); 473 memcpy(seq, wh->i_seq, 2); 474 475 /* relay frame */ 476 wh->i_fc[1] &= ~(IEEE80211_FC1_DIR_TODS | IEEE80211_FC1_RETRY); 477 wh->i_fc[1] |= IEEE80211_FC1_DIR_FROMDS; 478 memcpy(wh->i_addr1, wh->i_addr3, sizeof(wh->i_addr1)); 479 memcpy(wh->i_addr3, wh->i_addr2, sizeof(wh->i_addr3)); 480 memcpy(wh->i_addr2, p->mac, sizeof(wh->i_addr2)); 481 ps = (unsigned short*)wh->i_seq; 482 *ps = seqfn(p->seq, 0); 483 484 send_frame(p, wh, len); 485 enque(p, wh, len); 486 487 /* restore */ 488 memcpy(wh->i_fc, fc, sizeof(fc)); 489 memcpy(wh->i_addr2, wh->i_addr3, sizeof(wh->i_addr2)); 490 memcpy(wh->i_addr3, wh->i_addr1, sizeof(wh->i_addr2)); 491 memcpy(wh->i_addr1, p->mac, sizeof(wh->i_addr1)); 492 memcpy(wh->i_seq, seq, sizeof(seq)); 493 } 494 495 void read_real_data(struct params *p, struct ieee80211_frame *wh, int len) 496 { 497 char dst[6]; 498 int rc; 499 char *ptr = (char*) (wh+1); 500 501 /* stuff not for this net */ 502 if (memcmp(wh->i_addr1, p->mac, 6) != 0) 503 return; 504 505 /* relay data */ 506 if (memcmp(wh->i_addr3, p->mac, 6) != 0) 507 relay_data(p, wh, len); 508 509 memcpy(dst, wh->i_addr3, 6); 510 511 512 if (wh->i_fc[1] & IEEE80211_FC1_WEP) { 513 if (!p->wep_len) { 514 printf("Got wep but i aint wep\n"); 515 return; 516 } 517 518 if (wep_decrypt(wh, len, p->wep_key, p->wep_len) == -1){ 519 printf("Can't decrypt\n"); 520 return; 521 } 522 523 ptr += 4; 524 len -= 8; 525 } 526 527 /* ether header */ 528 ptr += 8 - 2; 529 ptr -= 6; 530 memcpy(ptr, wh->i_addr2, 6); 531 ptr -= 6; 532 memcpy(ptr, dst, 6); 533 534 len -= sizeof(*wh); 535 len -= 8; 536 len += 14; 537 538 /* send to tap */ 539 rc = write(p->tap, ptr, len); 540 if (rc == -1) 541 err(1, "write()"); 542 if (rc != len) { 543 printf("Wrote %d/%d\n", rc, len); 544 exit(1); 545 } 546 } 547 548 void read_data(struct params *p, struct ieee80211_frame *wh, int len) 549 { 550 switch (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) { 551 case IEEE80211_FC0_SUBTYPE_DATA: 552 read_real_data(p, wh, len); 553 break; 554 555 case IEEE80211_FC0_SUBTYPE_NODATA: 556 break; 557 558 default: 559 printf("wtf %d\n", (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) >> 560 IEEE80211_FC0_SUBTYPE_SHIFT); 561 abort(); 562 break; 563 } 564 } 565 566 struct client* client_find(struct params *p, char *mac) 567 { 568 struct client* c = p->clients; 569 570 while (c) { 571 if (memcmp(c->mac, mac, 6) == 0) 572 return c; 573 574 c = c->next; 575 } 576 577 return NULL; 578 } 579 580 void client_insert(struct params *p, struct client *c) 581 { 582 #if 1 583 do { 584 char mac[6*3]; 585 586 mac2str(mac, c->mac); 587 printf("Adding client %s\n", mac); 588 } while(0); 589 #endif 590 591 c->next = p->clients; 592 p->clients = c; 593 } 594 595 int duplicate(struct params *p, struct ieee80211_frame *wh, int rc) 596 { 597 struct client *c; 598 int s; 599 600 if (!frame_type(wh, IEEE80211_FC0_TYPE_DATA, 601 IEEE80211_FC0_SUBTYPE_DATA)) 602 return 0; 603 604 s = seqno(wh); 605 606 c = client_find(p, wh->i_addr2); 607 if (!c) { 608 c = malloc(sizeof(*c)); 609 if (!c) 610 err(1, "malloc()"); 611 612 memset(c, 0, sizeof(*c)); 613 memcpy(c->mac, wh->i_addr2, 6); 614 615 c->seq = s-1; 616 client_insert(p, c); 617 } 618 619 if (wh->i_fc[1] & IEEE80211_FC1_RETRY) { 620 if ( (s <= c->seq) && ((c->seq - s ) < 5)) { 621 #if 0 622 printf("Dup seq %d prev %d\n", 623 s, c->seq); 624 #endif 625 return 1; 626 } 627 } 628 629 #if 0 630 do { 631 char mac[3*6]; 632 633 mac2str(mac, c->mac); 634 printf("%s seq %d prev %d\n", mac, s, c->seq); 635 } while (0); 636 #endif 637 638 c->seq = s; 639 return 0; 640 } 641 642 void ack(struct params *p, struct ieee80211_frame *wh) 643 { 644 if (memcmp(wh->i_addr1, p->mac, 6) != 0) 645 return; 646 647 if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) == IEEE80211_FC0_TYPE_CTL) 648 return; 649 650 send_ack(p->tx, wh->i_addr2); 651 } 652 653 void read_wifi(struct params *p) 654 { 655 char buf[4096]; 656 int rc; 657 struct ieee80211_frame *wh; 658 659 rc = sniff(p->rx, buf, sizeof(buf)); 660 if (rc == -1) 661 err(1, "sniff()"); 662 663 wh = get_wifi(buf, &rc); 664 if (!wh) 665 return; 666 667 /* filter my own shit */ 668 if (memcmp(wh->i_addr2, p->mac, 6) == 0) { 669 /* XXX CTL frames */ 670 if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) != 671 IEEE80211_FC0_TYPE_CTL) 672 return; 673 } 674 675 #if 1 676 ack(p, wh); 677 #endif 678 679 if (duplicate(p, wh, rc)) { 680 #if 0 681 printf("Dup\n"); 682 #endif 683 return; 684 } 685 686 switch (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) { 687 case IEEE80211_FC0_TYPE_MGT: 688 read_mgt(p, wh, rc); 689 break; 690 691 case IEEE80211_FC0_TYPE_CTL: 692 read_ctl(p, wh, rc); 693 break; 694 695 case IEEE80211_FC0_TYPE_DATA: 696 read_data(p, wh, rc); 697 break; 698 699 default: 700 printf("wtf\n"); 701 abort(); 702 break; 703 } 704 } 705 706 void read_tap(struct params *p) 707 { 708 char buf[4096]; 709 char *ptr; 710 int len = sizeof(buf); 711 int offset; 712 char src[6], dst[6]; 713 struct ieee80211_frame *wh; 714 int rd; 715 716 ptr = buf; 717 offset = sizeof(struct ieee80211_frame) + 8 - 14; 718 if (p->wep_len) 719 offset += 4; 720 721 ptr += offset; 722 len -= offset; 723 724 /* read packet */ 725 memset(buf, 0, sizeof(buf)); 726 rd = read(p->tap, ptr, len); 727 if (rd == -1) 728 err(1, "read()"); 729 730 /* 802.11 header */ 731 wh = (struct ieee80211_frame*) buf; 732 memcpy(dst, ptr, sizeof(dst)); 733 memcpy(src, ptr+6, sizeof(src)); 734 fill_basic(wh, p); 735 memcpy(wh->i_addr3, src, sizeof(wh->i_addr3)); 736 memcpy(wh->i_addr1, dst, sizeof(wh->i_addr1)); 737 wh->i_fc[0] |= IEEE80211_FC0_TYPE_DATA; 738 wh->i_fc[1] |= IEEE80211_FC1_DIR_FROMDS; 739 if (p->wep_len) 740 wh->i_fc[1] |= IEEE80211_FC1_WEP; 741 742 /* LLC & SNAP */ 743 ptr = (char*) (wh+1); 744 if (p->wep_len) 745 ptr += 4; 746 *ptr++ = 0xAA; 747 *ptr++ = 0xAA; 748 *ptr++ = 0x03; 749 *ptr++ = 0x00; 750 *ptr++ = 0x00; 751 *ptr++ = 0x00; 752 /* ether type overlaps w00t */ 753 754 rd += offset; 755 756 /* WEP */ 757 if (p->wep_len) { 758 ptr = (char*) (wh+1); 759 memcpy(ptr, &p->wep_iv, 3); 760 ptr[3] = 0; 761 p->wep_iv++; 762 763 wep_encrypt(wh, rd, p->wep_key, p->wep_len); 764 rd += 4; /* ICV */ 765 } 766 767 send_frame(p, wh, rd); 768 } 769 770 int retransmit(struct params *p) 771 { 772 #if 0 773 printf("RETRANS %d\n", p->packet_try); 774 #endif 775 776 send_frame(p, p->packet, p->packet_len); 777 p->packet_try++; 778 779 if (p->packet_try > 3) 780 p->packet_try = 0; 781 else { 782 if (gettimeofday(&p->plast, NULL) == -1) 783 err(1, "gettimeofday()"); 784 } 785 786 return p->packet_try; 787 } 788 789 void next_event(struct params *p) 790 { 791 struct timeval to, now; 792 int el; 793 int max; 794 fd_set fds; 795 int rtr = 3*1000; 796 797 /* figure out select timeout */ 798 if (gettimeofday(&now, NULL) == -1) 799 err(1, "gettimeofday()"); 800 801 /* check beacon timeout */ 802 el = elapsed(&p->blast, &now); 803 if (el >= p->bint) { 804 send_beacon(p); 805 el = 0; 806 } 807 el = p->bint - el; 808 to.tv_sec = el/1000/1000; 809 to.tv_usec = el - to.tv_sec*1000*1000; 810 811 /* check tx timeout */ 812 if (p->packet_try) { 813 el = elapsed(&p->plast, &now); 814 if (el >= rtr) { 815 /* check if we gotta retransmit more */ 816 if (retransmit(p)) { 817 el = 0; 818 } 819 else 820 el = -1; 821 } 822 823 /* gotta retransmit in future */ 824 if (el != -1) { 825 el = rtr - el; 826 if ((to.tv_sec*1000*1000 + to.tv_usec) > el) { 827 to.tv_sec = el/1000/1000; 828 to.tv_usec = el - to.tv_sec*1000*1000; 829 } 830 } 831 } 832 833 /* select */ 834 FD_ZERO(&fds); 835 FD_SET(p->rx, &fds); 836 FD_SET(p->tap, &fds); 837 max = p->rx > p->tap ? p->rx : p->tap; 838 if (select(max+1, &fds, NULL, NULL, &to) == -1) 839 err(1, "select()"); 840 841 if (FD_ISSET(p->tap, &fds)) 842 read_tap(p); 843 if (FD_ISSET(p->rx, &fds)) 844 read_wifi(p); 845 } 846 847 int main(int argc, char *argv[]) 848 { 849 char *iface = "wlan0"; 850 char *tap = "tap0"; 851 struct params p; 852 int ch; 853 854 /* default params */ 855 memset(&p, 0, sizeof(p)); 856 memcpy(p.mac, "\x00\x00\xde\xfa\xce\x0d", 6); 857 strcpy(p.ssid, "sorbo"); 858 p.bint = 500*1000; 859 p.seq = getpid(); 860 if (gettimeofday(&p.blast, NULL) == -1) 861 err(1, "gettimeofday()"); 862 p.chan = 3; 863 864 while ((ch = getopt(argc, argv, "hi:s:m:w:c:t:")) != -1) { 865 switch (ch) { 866 case 'i': 867 iface = optarg; 868 break; 869 case 't': 870 tap = optarg; 871 break; 872 873 case 'c': 874 p.chan = atoi(optarg); 875 break; 876 877 case 's': 878 strncpy(p.ssid, optarg, sizeof(p.ssid)-1); 879 p.ssid[sizeof(p.ssid)-1] = 0; 880 break; 881 882 case 'm': 883 str2mac(p.mac, optarg); 884 break; 885 886 case 'w': 887 if (str2wep(p.wep_key, &p.wep_len, optarg)) { 888 printf("Error parsing WEP key\n"); 889 exit(1); 890 } 891 break; 892 893 case 'h': 894 default: 895 usage(argv[0]); 896 break; 897 } 898 } 899 900 /* init */ 901 if ((p.tx = open_tx(iface)) == -1) 902 err(1, "open_tx()"); 903 if ((p.rx = open_rx(iface)) == -1) 904 err(1, "open_rx()"); 905 906 if ((p.tap = open_tap(tap)) == -1) 907 err(1, "open_tap()"); 908 if (set_iface_mac(tap, p.mac) == -1) 909 err(1, "set_iface_mac()"); 910 911 while (1) { 912 next_event(&p); 913 } 914 915 exit(0); 916 } 917