Adds ruby-lorcon2 to the tree, (from lorcon2 trunk). Still some bugs to go, see #378

git-svn-id: file:///home/svn/framework3/trunk@7227 4d416f70-5f16-0410-b530-b9f4589650da

external/ruby-lorcon2/Lorcon2.c

@@ -0,0 +1,609 @@
+#include "Lorcon2.h"
+#include "ruby.h"
+
+/*
+	self.license = GPLv2;
+*/
+
+/*
+    This is a derivative of the tx.c sample included with lorcon:
+		http://802.11ninja.net/lorcon/
+
+    lorcon is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    lorcon is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with lorcon; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Copyright (c) 2005 dragorn and Joshua Wright
+	
+*/
+
+/*
+	Lots of code borrowed from Tom Wambold's pylorcon:
+		http://pylorcon.googlecode.com/ - tom5760[at]gmail.com
+*/
+
+/*	
+	All ruby-lorcon/rubyisms are by Metasploit LLC (C) 2006-2007
+		http://metasploit.com/ - msfdev[at]metasploit.com
+*/
+
+VALUE mLorcon;
+VALUE cDevice;
+VALUE cPacket;
+
+VALUE Lorcon_get_version(VALUE self) {
+	return INT2NUM(lorcon_get_version());
+}
+
+static VALUE Lorcon_list_drivers(VALUE self) {
+	VALUE list;
+	VALUE hash;
+
+	lorcon_driver_t *drvlist, *dri;
+
+	list = rb_hash_new();
+
+	dri = drvlist = lorcon_list_drivers();
+
+	if (dri == NULL)
+		return Qnil;
+
+	while (dri) {
+		hash = rb_hash_new();
+		rb_hash_aset(hash, rb_str_new2("name"), rb_str_new2(dri->name));
+		rb_hash_aset(hash, rb_str_new2("description"), rb_str_new2(dri->details));
+		rb_hash_aset(list, rb_str_new2(dri->name),hash);
+		dri = dri->next;
+	}
+
+	lorcon_free_driver_list(drvlist);
+
+	return(list);
+}
+
+static VALUE Lorcon_find_driver(VALUE self, VALUE driver) {
+	VALUE hash;
+	lorcon_driver_t *dri;
+	char *drivert = StringValuePtr(driver);
+
+	dri = lorcon_find_driver(drivert);
+
+	if (dri == NULL)
+		return Qnil;
+
+	hash = rb_hash_new();
+
+	rb_hash_aset(hash, rb_str_new2("name"), rb_str_new2(dri->name));
+	rb_hash_aset(hash, rb_str_new2("description"), rb_str_new2(dri->details));
+
+	lorcon_free_driver_list(dri);
+
+	return(hash);
+}
+
+static VALUE Lorcon_auto_driver(VALUE self, VALUE interface) {
+	VALUE hash;
+	lorcon_driver_t *dri;
+	char *intf = StringValuePtr(interface);
+
+	dri = lorcon_auto_driver(intf);
+
+	if (dri == NULL)
+		return Qnil;
+
+	hash = rb_hash_new();
+	rb_hash_aset(hash, rb_str_new2("name"), rb_str_new2(dri->name));
+	rb_hash_aset(hash, rb_str_new2("description"), rb_str_new2(dri->details));
+
+	lorcon_free_driver_list(dri);
+
+	return hash;
+}
+
+void Lorcon_free(struct rldev *rld) {
+	if (rld->context != NULL)
+		lorcon_free(rld->context);
+}
+
+static VALUE Lorcon_create(int argc, VALUE *argv, VALUE self) {
+	struct rldev *rld;
+	int ret = 0;
+	char *intf = NULL, *driver = NULL;
+	VALUE rbdriver, rbintf, obj;
+	lorcon_driver_t *dri;
+
+	if (argc == 2) {
+		rb_scan_args(argc, argv, "2", &rbintf, &rbdriver);
+		intf = STR2CSTR(rbintf);
+		driver = STR2CSTR(rbdriver);
+	} else {
+		rb_scan_args(argc, argv, "1", &rbintf);
+		intf = STR2CSTR(rbintf);
+	}
+
+	if (driver == NULL) {
+		if ((dri = lorcon_auto_driver(intf)) == NULL) {
+			rb_raise(rb_eRuntimeError,
+					 "LORCON could not detect a driver and none specified");
+			return (Qnil);
+		}
+	} else {
+		if ((dri = lorcon_find_driver(driver)) == NULL) {
+			rb_raise(rb_eArgError,
+					 "LORCON could not recognize the specified driver");
+			return (Qnil);
+		}
+	}
+
+	obj = Data_Make_Struct(cDevice, struct rldev, 0, Lorcon_free, rld);
+
+	rld->context = lorcon_create(intf, dri);
+
+	if (rld->context == NULL) {
+		rb_raise(rb_eRuntimeError,
+				 "LORCON could not create context");
+		return (Qnil);
+	}
+
+	lorcon_free_driver_list(dri);
+
+	rb_obj_call_init(obj, 0, 0);	
+	return(obj);
+}
+
+
+static VALUE Lorcon_open_inject(VALUE self) {
+	struct rldev *rld;
+
+	Data_Get_Struct(self, struct rldev, rld);
+
+	if (lorcon_open_inject(rld->context) < 0)
+		return Qfalse;
+
+	return Qtrue;
+}
+
+static VALUE Lorcon_open_monitor(VALUE self) {
+	struct rldev *rld;
+
+	Data_Get_Struct(self, struct rldev, rld);
+
+	if (lorcon_open_monitor(rld->context) < 0)
+		return Qfalse;
+
+	return Qtrue;
+}
+
+static VALUE Lorcon_open_injmon(VALUE self) {
+	struct rldev *rld;
+
+	Data_Get_Struct(self, struct rldev, rld);
+
+	if (lorcon_open_injmon(rld->context) < 0)
+		return Qfalse;
+
+	return Qtrue;
+}
+
+static VALUE Lorcon_get_error(VALUE self) {
+	struct rldev *rld;
+
+	Data_Get_Struct(self, struct rldev, rld);
+
+	return rb_str_new2(lorcon_get_error(rld->context));
+}
+
+static VALUE Lorcon_get_capiface(VALUE self) {
+	struct rldev *rld;
+	Data_Get_Struct(self, struct rldev, rld);
+
+	return rb_str_new2(lorcon_get_capiface(rld->context));
+}
+
+void Lorcon_packet_free(struct rlpack *rlp) {
+	/*
+	if (rlp->packet != NULL)
+		lorcon_packet_free(rlp->packet);
+		*/
+}
+
+static VALUE Lorcon_packet_create(int argc, VALUE *argv, VALUE self) {
+	struct rlpack *rlp;
+	VALUE obj;
+
+	obj = Data_Make_Struct(cPacket, struct rlpack, 0, Lorcon_packet_free, rlp);
+
+	rlp->packet = (struct lorcon_packet *) malloc(sizeof(struct lorcon_packet));
+	memset(rlp->packet, 0, sizeof(struct lorcon_packet));
+
+	rlp->bssid = NULL;
+	rlp->dot3 = NULL;
+	rlp->len = 0;
+	rlp->dir = 0;
+
+	rb_obj_call_init(obj, 0, 0);	
+	return(obj);
+}
+
+static VALUE Lorcon_packet_get_channel(VALUE self) {
+	struct rlpack *rlp;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	return INT2FIX(rlp->packet->channel);
+}
+
+static VALUE Lorcon_packet_set_channel(VALUE self, VALUE channel) {
+	struct rlpack *rlp;
+	int ret;
+
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	lorcon_packet_set_channel(rlp->packet, NUM2INT(channel));
+
+	return channel;
+}
+
+static VALUE Lorcon_packet_get_dlt(VALUE self) {
+	struct rlpack *rlp;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	return INT2FIX(rlp->packet->dlt);
+}
+
+static VALUE Lorcon_packet_get_bssid(VALUE self) {
+	struct rlpack *rlp;
+	struct lorcon_dot11_extra *extra;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	if (rlp->packet->extra_info == NULL ||
+		rlp->packet->extra_type != LORCON_PACKET_EXTRA_80211)
+		return Qnil;
+
+	extra = (struct lorcon_dot11_extra *) rlp->packet->extra_info;
+
+	if (extra->bssid_mac == NULL)
+		return Qnil;
+
+	return rb_str_new(extra->bssid_mac, 6);
+}
+
+static VALUE Lorcon_packet_get_source(VALUE self) {
+	struct rlpack *rlp;
+	struct lorcon_dot11_extra *extra;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	if (rlp->packet->extra_info == NULL ||
+		rlp->packet->extra_type != LORCON_PACKET_EXTRA_80211)
+		return Qnil;
+
+	extra = (struct lorcon_dot11_extra *) rlp->packet->extra_info;
+
+	if (extra->source_mac == NULL)
+		return Qnil;
+
+	return rb_str_new(extra->source_mac, 6);
+}
+
+static VALUE Lorcon_packet_get_dest(VALUE self) {
+	struct rlpack *rlp;
+	struct lorcon_dot11_extra *extra;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	if (rlp->packet->extra_info == NULL ||
+		rlp->packet->extra_type != LORCON_PACKET_EXTRA_80211)
+		return Qnil;
+
+	extra = (struct lorcon_dot11_extra *) rlp->packet->extra_info;
+
+	if (extra->dest_mac == NULL)
+		return Qnil;
+
+	return rb_str_new(extra->dest_mac, 6);
+}
+
+static VALUE Lorcon_packet_get_rawdata(VALUE self) {
+	struct rlpack *rlp;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	if (rlp->packet->packet_raw == NULL)
+		return Qnil;
+
+	return rb_str_new(rlp->packet->packet_raw, rlp->packet->length);
+}
+
+static VALUE Lorcon_packet_get_headerdata(VALUE self) {
+	struct rlpack *rlp;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	if (rlp->packet->packet_header == NULL)
+		return Qnil;
+
+	return rb_str_new(rlp->packet->packet_header, rlp->packet->length_header);
+}
+
+static VALUE Lorcon_packet_get_data(VALUE self) {
+	struct rlpack *rlp;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	if (rlp->packet->packet_data == NULL)
+		return Qnil;
+
+	return rb_str_new(rlp->packet->packet_data, rlp->packet->length_data);
+}
+
+
+static VALUE Lorcon_packet_getdot3(VALUE self) {
+	struct rlpack *rlp;
+	Data_Get_Struct(self, struct rlpack, rlp);
+	u_char *pdata;
+	int len;
+	VALUE ret;
+
+	if (rlp->packet->packet_data == NULL)
+		return Qnil;
+
+	len = lorcon_packet_to_dot3(rlp->packet, &pdata);
+
+	ret = rb_str_new(pdata, len);
+
+	free(pdata);
+
+	return ret;
+}
+
+static VALUE Lorcon_packet_prepdot3(VALUE self, VALUE dot3) {
+	struct rlpack *rlp;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	rlp->dot3 = StringValuePtr(dot3);
+	rlp->len = RSTRING(dot3)->len;
+
+	return dot3;
+}
+
+static VALUE Lorcon_packet_prepbssid(VALUE self, VALUE bssid) {
+	struct rlpack *rlp;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	rlp->bssid = StringValuePtr(bssid);
+
+	return bssid;
+}
+
+static VALUE Lorcon_packet_prepdir(VALUE self, VALUE dir) {
+	struct rlpack *rlp;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	rlp->dir = NUM2INT(dir);
+
+	return dir;
+}
+
+static VALUE Lorcon_packet_getdir(VALUE self) {
+	struct rlpack *rlp;
+	struct lorcon_dot11_extra *extra;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	if (rlp->dir != 0)
+		return INT2FIX(rlp->dir);
+
+	if (rlp->packet == NULL)
+		return Qnil;
+
+	if (rlp->packet->extra_info == NULL ||
+		rlp->packet->extra_type != LORCON_PACKET_EXTRA_80211)
+		return Qnil;
+
+	extra = (struct lorcon_dot11_extra *) rlp->packet->extra_info;
+
+	if (extra->from_ds && !extra->to_ds)
+		return INT2FIX(LORCON_DOT11_DIR_FROMDS);
+	else if (!extra->from_ds && extra->to_ds)
+		return INT2FIX(LORCON_DOT11_DIR_TODS);
+	else if (!extra->from_ds && !extra->to_ds)
+		return INT2FIX(LORCON_DOT11_DIR_ADHOCDS);
+	else if (extra->from_ds && extra->to_ds)
+		return INT2FIX(LORCON_DOT11_DIR_INTRADS);
+
+	return Qnil;
+}
+
+static VALUE Lorcon_packet_get_rawlength(VALUE self) {
+	struct rlpack *rlp;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	return INT2FIX(rlp->packet->length);
+}
+
+static VALUE Lorcon_packet_get_headerlength(VALUE self) {
+	struct rlpack *rlp;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	return INT2FIX(rlp->packet->length_header);
+}
+
+static VALUE Lorcon_packet_get_datalength(VALUE self) {
+	struct rlpack *rlp;
+	Data_Get_Struct(self, struct rlpack, rlp);
+
+	return INT2FIX(rlp->packet->length_data);
+}
+
+VALUE new_lorcon_packet(struct lorcon_packet *packet) {
+	struct rlpack *rlp;
+	VALUE obj;
+
+	obj = Data_Make_Struct(cPacket, struct rlpack, 0, Lorcon_packet_free, rlp);
+
+	rlp->packet = packet;
+
+	rb_obj_call_init(obj, 0, 0);	
+	return(obj);
+}
+
+static VALUE Lorcon_inject_packet(VALUE self, VALUE packet) {
+	struct rldev *rld;
+	struct rlpack *rlp;
+	lorcon_packet_t *pack = NULL;
+	int ret;
+
+	if (rb_obj_is_kind_of(packet, cPacket) == 0) {
+		rb_raise(rb_eTypeError, "wrong type %s expected %s",
+				 rb_class2name(packet), rb_class2name(cPacket));
+		return Qnil;
+	}
+
+	Data_Get_Struct(self, struct rldev, rld);
+	Data_Get_Struct(packet, struct rlpack, rlp);
+
+	if (rlp->bssid != NULL && rlp->dot3 != NULL) {
+		pack = lorcon_packet_from_dot3(rlp->bssid, rlp->dir, rlp->dot3, rlp->len);
+		ret = lorcon_inject(rld->context, pack);
+		lorcon_packet_free(pack);
+	} else {
+		ret = lorcon_inject(rld->context, rlp->packet);
+	}
+
+	return INT2FIX(ret);
+}
+
+static VALUE Lorcon_set_filter(VALUE self, VALUE filter) {
+	struct rldev *rld;
+	int ret;
+
+	Data_Get_Struct(self, struct rldev, rld);
+
+	return INT2FIX(lorcon_set_filter(rld->context, StringValuePtr(filter)));
+}
+
+static VALUE Lorcon_set_channel(VALUE self, VALUE channel) {
+	struct rldev *rld;
+	int ret;
+
+	Data_Get_Struct(self, struct rldev, rld);
+
+	return INT2FIX(lorcon_set_channel(rld->context, NUM2INT(channel)));
+}
+
+static VALUE Lorcon_capture_loop(int argc, VALUE *argv, VALUE self) {
+	struct rldev *rld;
+	int count, ret, p = 0;
+	struct lorcon_packet *packet;
+	VALUE v_cnt;
+	fd_set rset;
+	struct timeval tm;
+	int fd;
+
+	Data_Get_Struct(self, struct rldev, rld);
+
+	if (rb_scan_args(argc, argv, "01", &v_cnt) >= 1) {
+		FIXNUM_P(v_cnt);
+		count = FIX2INT(v_cnt);
+	} else {
+		count = -1;
+	}
+
+	FD_ZERO(&rset);
+	tm.tv_sec = 0;
+	tm.tv_usec = 0;
+
+	fd = lorcon_get_selectable_fd(rld->context);
+
+	if (fd < 0) {
+		rb_raise(rb_eRuntimeError,
+				 "LORCON context could not provide a pollable descriptor "
+				 "and we need one for the threaded dispatch loop");
+	}
+
+	while (p < count || count <= 0) {
+		FD_SET(fd, &rset);
+		if (select(fd + 1, &rset, NULL, NULL, &tm) == 0) 
+			rb_thread_wait_fd(fd);
+		
+		ret = lorcon_next_ex(rld->context, &packet);
+
+		/* timeout */
+		if (ret == 0)
+			continue;
+
+		if (ret < 0 || packet == NULL)
+			return INT2FIX(ret);
+
+		rb_yield(new_lorcon_packet(packet));
+
+		p++;
+	}
+
+	return INT2FIX(ret);
+}
+
+
+void Init_Lorcon2() {	
+	mLorcon = rb_define_module("Lorcon");
+
+	cPacket = rb_define_class_under(mLorcon, "Packet", rb_cObject);
+
+	rb_define_const(cPacket, "LORCON_FROM_DS", INT2NUM(LORCON_DOT11_DIR_FROMDS));
+	rb_define_const(cPacket, "LORCON_TO_DS", INT2NUM(LORCON_DOT11_DIR_TODS));
+	rb_define_const(cPacket, "LORCON_INTRA_DS", INT2NUM(LORCON_DOT11_DIR_INTRADS));
+	rb_define_const(cPacket, "LORCON_ADHOC_DS", INT2NUM(LORCON_DOT11_DIR_ADHOCDS));
+
+	rb_define_singleton_method(cPacket, "new", Lorcon_packet_create, -1);
+	rb_define_method(cPacket, "bssid", Lorcon_packet_get_bssid, 0);
+	rb_define_method(cPacket, "source", Lorcon_packet_get_source, 0);
+	rb_define_method(cPacket, "dest", Lorcon_packet_get_dest, 0);
+
+	rb_define_method(cPacket, "channel", Lorcon_packet_get_channel, 0);
+	rb_define_method(cPacket, "channel=", Lorcon_packet_set_channel, 1);
+	rb_define_method(cPacket, "dlt", Lorcon_packet_get_dlt, 0);
+
+	rb_define_method(cPacket, "rawdata", Lorcon_packet_get_rawdata, 0);
+	rb_define_method(cPacket, "headerdata", Lorcon_packet_get_headerdata, 0);
+	rb_define_method(cPacket, "data", Lorcon_packet_get_data, 0);
+
+	rb_define_method(cPacket, "dot3", Lorcon_packet_getdot3, 0);
+
+	rb_define_method(cPacket, "dot3=", Lorcon_packet_prepdot3, 1);
+	rb_define_method(cPacket, "bssid=", Lorcon_packet_prepbssid, 1);
+	rb_define_method(cPacket, "direction=", Lorcon_packet_prepdir, 1);
+	rb_define_method(cPacket, "direction", Lorcon_packet_getdir, 0);
+
+	rb_define_method(cPacket, "size", Lorcon_packet_get_rawlength, 0);
+	rb_define_method(cPacket, "linesize", Lorcon_packet_get_rawlength, 0);
+	rb_define_method(cPacket, "headersize", Lorcon_packet_get_headerlength, 0);
+	rb_define_method(cPacket, "datasize", Lorcon_packet_get_datalength, 0);
+
+	cDevice = rb_define_class_under(mLorcon, "Device", rb_cObject);
+	rb_define_singleton_method(cDevice, "new", Lorcon_create, -1);
+	rb_define_method(cDevice, "openinject", Lorcon_open_inject, 0);
+	rb_define_method(cDevice, "openmonitor", Lorcon_open_monitor, 0);
+	rb_define_method(cDevice, "openinjmon", Lorcon_open_injmon, 0);
+	rb_define_method(cDevice, "error", Lorcon_get_error, 0);
+	rb_define_method(cDevice, "capiface", Lorcon_get_capiface, 0);
+
+	rb_define_method(cDevice, "filter=", Lorcon_set_filter, 1);
+	rb_define_method(cPacket, "channel=", Lorcon_set_channel, 1);
+
+	rb_define_method(cDevice, "loop", Lorcon_capture_loop, -1);
+	rb_define_method(cDevice, "each", Lorcon_capture_loop, -1);
+	rb_define_method(cDevice, "each_packet", Lorcon_capture_loop, -1);
+
+	rb_define_method(cDevice, "inject", Lorcon_inject_packet, 1);
+
+	rb_define_module_function(mLorcon, "drivers", Lorcon_list_drivers, 0);
+	rb_define_module_function(mLorcon, "version", Lorcon_get_version, 0);
+	rb_define_module_function(mLorcon, "find_driver", Lorcon_find_driver, 1);
+	rb_define_module_function(mLorcon, "auto_driver", Lorcon_auto_driver, 1);
+}
+
+

external/ruby-lorcon2/Lorcon2.h

@@ -0,0 +1,25 @@
+#ifndef _MSFLORCON_H
+#define _MSFLORCON_H
+
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/socket.h>
+
+#include <lorcon2/lorcon.h>
+#include <lorcon2/lorcon_packet.h>
+
+struct rldev {
+	struct lorcon *context;
+};
+
+struct rlpack {
+	struct lorcon_packet *packet;
+
+	/* dot3 construction via multiple elements */
+	u_char *bssid, *dot3;
+	int dir, len;
+};
+
+#endif

external/ruby-lorcon2/README

@@ -0,0 +1,41 @@
+This is an experimental interface for lorcon, a 802.11 library
+developed by Joshua Wright and dragorn. This interface is only
+available on Linux and with lorcon-supported wireless drivers.
+
+For more information, please see the lorcon documentation and code:
+http://www.802.11mercenary.net/lorcon/
+
+To build this extension:
+
+1) Download, compile, and install lorcon
+The latest version of lorcon can pulled from SVN:
+$ svn co https://802.11ninja.net/svn/lorcon/trunk/ lorcon
+$ cd lorcon
+$ ./configure
+$ make
+  $ sudo make install
+   -- or --
+  $ su 
+  # make install
+  # exit
+$ cd ..
+
+2) build the ruby extension.. 
+$ ruby extconf.rb
+$ make
+$ sudo make install 
+   -- or --
+$ su
+# make install
+
+
+NOTES: 
+
+if Ubuntu 8.04 (and probably others) bitches about 'mkmf', 
+you need ruby dev package.
+
+:~/metasploit/external/ruby-lorcon$ ruby extconf.rb 
+extconf.rb:2:in `require': no such file to load -- mkmf (LoadError)
+       from extconf.rb:2
+
+:~/metasploit/external/ruby-lorcon$ sudo apt-get install ruby1.8-dev

external/ruby-lorcon2/apitest.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.dirname(__FILE__))
+require "Lorcon"
+require "pp"
+
+pp Lorcon.version
+pp Lorcon.drivers
+
+# Beacon frame from tx.c
+packet = [
+	0x80, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, # dur ffff
+	0xff, 0xff, 0x00, 0x0f, 0x66, 0xe3, 0xe4, 0x03, 
+	0x00, 0x0f, 0x66, 0xe3, 0xe4, 0x03, 0x00, 0x00, # 0x0000 - seq no.
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, # BSS timestamp 
+	0x64, 0x00, 0x11, 0x00, 0x00, 0x0f, 0x73, 0x6f, 
+	0x6d, 0x65, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x63, 
+	0x6c, 0x65, 0x76, 0x65, 0x72, 0x01, 0x08, 0x82, 
+	0x84, 0x8b, 0x96, 0x24, 0x30, 0x48, 0x6c, 0x03, 
+	0x01, 0x01, 0x05, 0x04, 0x00, 0x01, 0x00, 0x00, 
+	0x2a, 0x01, 0x05, 0x2f, 0x01, 0x05, 0x32, 0x04, 
+	0x0c, 0x12, 0x18, 0x60, 0xdd, 0x05, 0x00, 0x10, 
+	0x18, 0x01, 0x01, 0xdd, 0x16, 0x00, 0x50, 0xf2, 
+	0x01, 0x01, 0x00, 0x00, 0x50, 0xf2, 0x02, 0x01, 
+	0x00, 0x00, 0x50, 0xf2, 0x02, 0x01, 0x00, 0x00, 
+	0x50, 0xf2, 0x02
+].pack('C*')
+
+
+# Configure the card for reliable injection
+
+tx = Lorcon::Device.new('ath0', 'madwifing')
+tx.fmode      = "INJECT"
+tx.channel    = 11
+tx.txrate     = 2
+tx.modulation = "DSSS"
+
+sa = Time.now.to_f
+tx.write(packet, 500, 0)
+ea = Time.now.to_f - sa
+
+sb = Time.now.to_f
+500.times { tx.write(packet, 1, 0) }
+eb = Time.now.to_f - sb
+
+$stdout.puts "Sent 500 packets (C) in #{ea.to_s} seconds"
+$stdout.puts "Sent 500 packets (Ruby) in #{eb.to_s} seconds"

external/ruby-lorcon2/extconf.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'mkmf'
+
+if (have_library("orcon2", "lorcon_list_drivers", "lorcon2/lorcon.h") or find_library("orcon2", "lorcon_list_drivers", "lorcon2/lorcon.h"))
+	create_makefile("Lorcon2")
+else
+	puts "Error: the lorcon2 library was not found, please see the README"
+end

external/ruby-lorcon2/test.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.dirname(__FILE__))
+require "Lorcon2"
+require "pp"
+
+$stdout.puts "Checking LORCON version"
+
+pp Lorcon.version
+
+$stdout.puts "\nFetching LORCON driver list" 
+
+pp Lorcon.drivers
+
+$stdout.puts "\nResolving driver by name 'mac80211'"
+
+pp Lorcon.find_driver("mac80211")
+
+$stdout.puts "\nAuto-detecting driver for interface wlan0"
+
+pp Lorcon.auto_driver("wlan0")
+
+#tx = Lorcon::Device.new('kismet0', 'tuntap')
+tx = Lorcon::Device.new('wlan0')
+$stdout.puts "\nCreated LORCON context"
+
+if tx.openinjmon()
+	$stdout.puts "\nOpened as INJMON: " + tx.capiface
+else
+	$stdout.puts "\nFAILED to open " + tx.capiface + " as INJMON: " + tx.error
+end
+
+scan_patterns = ["^GET ([^ ?]+)"]
+
+tx.each_packet { |pkt| 
+	d3 = pkt.dot3
+
+	if d3 != nil then 
+		p3pfu = PacketFu::Packet.parse(d3)
+
+		scan_patterns.each {|sig| hit = p3pfu.payload.scan(/#{sig}/i) || nil 
+		 	printf "#{Time.now}: %s HTTP GET %s [%s] SEQ %u\n" % [p3pfu.ip_saddr, p3pfu.ip_daddr, sig, p3pfu.tcp_seq] unless hit.size.zero? 
+		}
+	end
+}
+
+
+# tx.fmode      = "INJECT"
+# tx.channel    = 11
+# tx.txrate     = 2
+# tx.modulation = "DSSS"
+# 
+# sa = Time.now.to_f
+# tx.write(packet, 500, 0)
+# ea = Time.now.to_f - sa
+# 
+# sb = Time.now.to_f
+# 500.times { tx.write(packet, 1, 0) }
+# eb = Time.now.to_f - sb
+# 
+# $stdout.puts "Sent 500 packets (C) in #{ea.to_s} seconds"
+# $stdout.puts "Sent 500 packets (Ruby) in #{eb.to_s} seconds"

external/ruby-lorcon2/upstream.svn

@@ -0,0 +1,11 @@
+Path: .
+URL: http://802.11ninja.net/svn/lorcon/trunk/ruby-lorcon
+Repository Root: http://802.11ninja.net/svn/lorcon
+Repository UUID: 61418039-352c-0410-8488-9e586b2135b2
+Revision: 204
+Node Kind: directory
+Schedule: normal
+Last Changed Author: dragorn
+Last Changed Rev: 202
+Last Changed Date: 2009-09-15 09:31:29 -0500 (Tue, 15 Sep 2009)
+