rubyipq 0.1.0-i686-linux

data/extconf.rb

@@ -0,0 +1,12 @@
+require "mkmf"
+
+have_library("ipq", "ipq_errstr")
+
+have_header("libipq.h")
+have_header("linux/netfilter.h")
+
+find_header("rubyipq.h", ".")
+find_header("rubyipq_proto.h", ".")
+
+create_makefile("Rubyipq")
+

data/rubyipq.c

@@ -0,0 +1,400 @@
+/*
+ * rubyipq v0.1.0
+ * Ruby bindings for Netfilter's libipq.
+ *
+ * Copyright (c) 2005 Leonardo Eloy
+ * Author: Leonardo Eloy <l.eloy@terra.com.br/leonardo.eloy@gmail.com>
+ * Project Homepage: http://rubyipq.rubyforge.org
+ *
+ *
+ *      This program 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.
+ *
+ *      This program 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 this program; if not, write to the Free Software
+ *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include "rubyipq.h"
+#include "rubyipq_defs.h"
+
+static void rubyipq_free() {
+	ipq_destroy_handle(handle); 
+	rubyipq_open = 0;
+}
+
+VALUE rubyipq_new(VALUE class, VALUE protocol) {
+        VALUE argv[1], struct_data;
+
+        handle = ipq_create_handle(0, NUM2INT(protocol));
+        if (!handle)
+                rb_raise(rb_eRuntimeError, "%s", ipq_errstr());
+
+        rubyipq_open = 1;
+
+        struct_data = Data_Wrap_Struct(class, 0, rubyipq_free, NULL);
+        argv[0] = protocol;
+
+        rb_obj_call_init(struct_data, 1, argv);
+
+        return struct_data;
+}
+
+VALUE rubyipq_destroy(VALUE class) {
+	if (!rubyipq_open) { 
+		rb_raise(rb_eRuntimeError, "rubyipq not properly instantiated");
+	}
+
+	rubyipq_free();
+
+	return Qnil;
+}
+
+VALUE rubyipq_initialize(VALUE class, VALUE protocol) {
+	/* Store the protocol to be used (PF_INET or PF_INET6) */
+	rb_iv_set(class, "@protocol", protocol);
+
+	return class;
+}
+
+VALUE rubyipq_set_mode(VALUE class, VALUE mode) {
+	int ret;
+	
+	ret = ipq_set_mode(handle, NUM2INT(mode), buffer_size);
+	if (ret < 0) 
+		rb_raise(rb_eRuntimeError, "%s", ipq_errstr());
+
+        return Qnil;
+}
+
+
+VALUE rubyipq_is_open(VALUE class) {
+	return (rubyipq_open ? Qtrue : Qfalse);
+}
+
+VALUE rubyipq_set_buffer_size(VALUE class, VALUE bufsize) {
+	int i_bufsize = NUM2INT(bufsize);
+
+	if (i_bufsize <= 0 || i_bufsize > 65535)	
+		rb_raise(rb_eArgError, "invalid buffer size '%d', should be between 1 and 65535", i_bufsize);
+
+	buffer_size = i_bufsize;
+	
+	return bufsize;
+}
+
+VALUE rubyipq_get_buffer_size(VALUE class) {
+	return INT2NUM(buffer_size);
+}
+
+VALUE rubyipq_read(VALUE class, VALUE timeout) {
+	int ret;
+	unsigned char buf[buffer_size];
+	
+	ret = ipq_read(handle, buf, buffer_size, NUM2INT(timeout));
+	if (ret < 0)
+		rb_raise(rb_eRuntimeError, "%s", ipq_errstr());
+
+	/* Clean up "last" variables... */
+	static_cleanup();
+
+	last_packet = buf;
+
+        if (last_packet == NULL) 
+		rb_raise(rb_eRuntimeError, "could not load last_packet");
+
+	return Qtrue;
+}
+
+VALUE rubyipq_get_message_type(VALUE class) {
+	return INT2NUM(ipq_message_type(get_last_packet()));
+}
+
+VALUE rubyipq_set_verdict(VALUE class, VALUE verdict) {
+	int ret, i_verdict = NUM2INT(verdict);
+
+	/* TODO: fix this argument checking condition 
+	if (NF_ACCEPT != i_verdict || NF_DROP != i_verdict) {
+		rb_raise(rb_eArgError, "unknown verdict type '%d' '%d'", i_verdict, NF_ACCEPT);
+	}*/
+	
+
+	ret = ipq_set_verdict(handle, get_last_packet_msg()->packet_id, i_verdict, 0, NULL);
+	if (ret < 0) 
+		rb_raise(rb_eRuntimeError, "%s", ipq_errstr());
+
+	return Qnil;
+}
+
+VALUE rubyipq_set_verdict_inject(VALUE class, VALUE verdict, VALUE payload) {
+	return Qnil;
+}
+
+VALUE rubyipq_get_indev(VALUE class) {
+	return rb_str_new2(get_last_packet_msg()->indev_name);
+}
+
+VALUE rubyipq_get_outdev(VALUE class) {
+	return rb_str_new2(get_last_packet_msg()->outdev_name);
+}
+
+VALUE rubyipq_get_timestamp_sec(VALUE class) {
+        return INT2NUM(get_last_packet_msg()->timestamp_sec);
+}
+
+VALUE rubyipq_get_timestamp_usec(VALUE class) {
+        return INT2NUM(get_last_packet_msg()->timestamp_usec);
+}
+
+VALUE rubyipq_is_incoming_packet(VALUE class) {
+	return (get_last_packet_msg()->indev_name[0] != '\0' ? Qtrue : Qfalse);
+}
+
+VALUE rubyipq_is_outgoing_packet(VALUE class) {
+        return (get_last_packet_msg()->outdev_name[0] != '\0' ? Qtrue : Qfalse);
+}
+
+VALUE rubyipq_get_hw_addr(VALUE class) {
+	VALUE hw_ary;
+	ipq_packet_msg_t *m = get_last_packet_msg();
+
+	hw_ary = rb_ary_new();
+	rb_ary_push(hw_ary, CHR2FIX(m->hw_addr[0]));
+	rb_ary_push(hw_ary, CHR2FIX(m->hw_addr[1]));
+	rb_ary_push(hw_ary, CHR2FIX(m->hw_addr[2]));
+	rb_ary_push(hw_ary, CHR2FIX(m->hw_addr[3]));
+	rb_ary_push(hw_ary, CHR2FIX(m->hw_addr[4]));
+	rb_ary_push(hw_ary, CHR2FIX(m->hw_addr[5]));
+	
+	return hw_ary;
+}
+	
+	
+
+/* Rubyipq class */
+static VALUE cRubyipq, cIPHeader, cTCPHeader, cUDPHeader, cICMPHeader;
+
+void Init_Rubyipq() {
+	rubyipq_open = 0;
+	buffer_size = DEFAULT_BUFFER_SIZE;
+	
+	cRubyipq = rb_define_class("Rubyipq", rb_cObject);
+
+	cIPHeader = rb_define_class_under(cRubyipq, "IPHeader", rb_cObject);
+	cTCPHeader = rb_define_class_under(cRubyipq, "TCPHeader", rb_cObject);
+	cUDPHeader = rb_define_class_under(cRubyipq, "UDPHeader", rb_cObject);
+
+	/* cRubyipq definitions */
+	rb_define_singleton_method(cRubyipq, "new", rubyipq_new, 1);
+	rb_define_method(cRubyipq, "initialize", rubyipq_initialize, 1);
+	rb_define_method(cRubyipq, "destroy", rubyipq_destroy, 0);
+	rb_define_method(cRubyipq, "opened?", rubyipq_is_open, 0);
+	rb_define_method(cRubyipq, "is_open?", rubyipq_is_open, 0);
+	rb_define_method(cRubyipq, "set_mode", rubyipq_set_mode, 1);
+	rb_define_method(cRubyipq, "set_verdict", rubyipq_set_verdict, 1);
+	rb_define_method(cRubyipq, "set_verdict_inject", rubyipq_set_verdict, 2);
+	rb_define_method(cRubyipq, "read", rubyipq_read, 1);
+	rb_define_method(cRubyipq, "get_message_type", rubyipq_get_message_type, 0);
+	rb_define_method(cRubyipq, "set_buffer_size", rubyipq_set_buffer_size, 1);
+	rb_define_method(cRubyipq, "get_buffer_size", rubyipq_get_buffer_size, 0);
+	rb_define_method(cRubyipq, "get_indev", rubyipq_get_indev, 0);
+	rb_define_method(cRubyipq, "get_outdev", rubyipq_get_outdev, 0);
+	rb_define_method(cRubyipq, "get_timestamp_sec", rubyipq_get_timestamp_sec, 0);
+	rb_define_method(cRubyipq, "get_timestamp_usec", rubyipq_get_timestamp_usec, 0);
+	rb_define_method(cRubyipq, "get_hw_addr", rubyipq_get_hw_addr, 0);
+	rb_define_method(cRubyipq, "is_incoming_packet?", rubyipq_is_incoming_packet, 0);
+	rb_define_method(cRubyipq, "is_outgoing_packet?", rubyipq_is_outgoing_packet, 0);
+	
+
+
+#define rb_define_rubyipq_const(var) \
+	rb_define_const(cRubyipq, #var, INT2NUM(var)) 
+	
+	rb_define_rubyipq_const(PF_INET);
+	rb_define_rubyipq_const(PF_INET6);
+	rb_define_rubyipq_const(IPQ_COPY_META);
+	rb_define_rubyipq_const(IPQ_COPY_PACKET);
+	rb_define_rubyipq_const(NF_ACCEPT);
+	rb_define_rubyipq_const(NF_DROP);
+	rb_define_rubyipq_const(NLMSG_ERROR);
+	rb_define_rubyipq_const(IPQM_PACKET);
+
+        rb_define_rubyipq_const(PROTO_HOPOPT);
+        rb_define_rubyipq_const(PROTO_ICMP);
+        rb_define_rubyipq_const(PROTO_IGMP);
+        rb_define_rubyipq_const(PROTO_GGP);
+        rb_define_rubyipq_const(PROTO_IP);
+        rb_define_rubyipq_const(PROTO_ST);
+        rb_define_rubyipq_const(PROTO_TCP);
+        rb_define_rubyipq_const(PROTO_CBT);
+        rb_define_rubyipq_const(PROTO_EGP);
+        rb_define_rubyipq_const(PROTO_IGP);
+        rb_define_rubyipq_const(PROTO_BBN_RCC_MON);
+        rb_define_rubyipq_const(PROTO_NVP_II);
+        rb_define_rubyipq_const(PROTO_PUP);
+        rb_define_rubyipq_const(PROTO_ARGUS);
+        rb_define_rubyipq_const(PROTO_EMCON);
+        rb_define_rubyipq_const(PROTO_XNET);
+        rb_define_rubyipq_const(PROTO_CHAOS);
+        rb_define_rubyipq_const(PROTO_UDP);
+        rb_define_rubyipq_const(PROTO_MUX);
+        rb_define_rubyipq_const(PROTO_DCN_MEAS);
+        rb_define_rubyipq_const(PROTO_HMP);
+        rb_define_rubyipq_const(PROTO_PRM);
+        rb_define_rubyipq_const(PROTO_XNS_IDP);
+        rb_define_rubyipq_const(PROTO_TRUNK_1);
+        rb_define_rubyipq_const(PROTO_TRUNK_2);
+        rb_define_rubyipq_const(PROTO_LEAF_1);
+        rb_define_rubyipq_const(PROTO_LEAF_2);
+        rb_define_rubyipq_const(PROTO_RDP);
+        rb_define_rubyipq_const(PROTO_IRTP);
+        rb_define_rubyipq_const(PROTO_ISO_TP4);
+        rb_define_rubyipq_const(PROTO_NETBLT);
+        rb_define_rubyipq_const(PROTO_MFE_NSP);
+        rb_define_rubyipq_const(PROTO_MERIT_INP);
+        rb_define_rubyipq_const(PROTO_DCCP);
+        rb_define_rubyipq_const(PROTO_3PC);
+        rb_define_rubyipq_const(PROTO_IDPR);
+        rb_define_rubyipq_const(PROTO_XTP);
+        rb_define_rubyipq_const(PROTO_DDP);
+        rb_define_rubyipq_const(PROTO_IDPR_CMTP);
+        rb_define_rubyipq_const(PROTO_TPpp);
+        rb_define_rubyipq_const(PROTO_IL);
+        rb_define_rubyipq_const(PROTO_IPV6);
+        rb_define_rubyipq_const(PROTO_SDRP);
+        rb_define_rubyipq_const(PROTO_IPV6_ROUTE);
+        rb_define_rubyipq_const(PROTO_IPV6_FRAG);
+        rb_define_rubyipq_const(PROTO_IDRP);
+        rb_define_rubyipq_const(PROTO_RSVP);
+        rb_define_rubyipq_const(PROTO_GRE);
+        rb_define_rubyipq_const(PROTO_MHRP);
+        rb_define_rubyipq_const(PROTO_BNA);
+        rb_define_rubyipq_const(PROTO_ESP);
+        rb_define_rubyipq_const(PROTO_AH);
+        rb_define_rubyipq_const(PROTO_I_NLSP);
+        rb_define_rubyipq_const(PROTO_SWIPE);
+        rb_define_rubyipq_const(PROTO_NARP);
+        rb_define_rubyipq_const(PROTO_MOBILE);
+        rb_define_rubyipq_const(PROTO_TLSP);
+        rb_define_rubyipq_const(PROTO_SKIP);
+        rb_define_rubyipq_const(PROTO_IPV6_ICMP);
+        rb_define_rubyipq_const(PROTO_IPV6_NONXT);
+        rb_define_rubyipq_const(PROTO_IPV6_OPTS);
+        rb_define_rubyipq_const(PROTO_ANY_HOST_INTERNAL_PROTOCOL);
+        rb_define_rubyipq_const(PROTO_CFTP);
+        rb_define_rubyipq_const(PROTO_ANY_LOCAL_NETWORK);
+        rb_define_rubyipq_const(PROTO_SAT_EXPAK);
+        rb_define_rubyipq_const(PROTO_KRYPTOLAN);
+        rb_define_rubyipq_const(PROTO_RVD);
+        rb_define_rubyipq_const(PROTO_IPPC);
+        rb_define_rubyipq_const(PROTO_ANY_DISTRIBUTED_FILE_SYSTEM);
+        rb_define_rubyipq_const(PROTO_SAT_MON);
+        rb_define_rubyipq_const(PROTO_VISA);
+        rb_define_rubyipq_const(PROTO_IPCV);
+        rb_define_rubyipq_const(PROTO_CPNX);
+        rb_define_rubyipq_const(PROTO_CPHB);
+        rb_define_rubyipq_const(PROTO_WSN);
+        rb_define_rubyipq_const(PROTO_PVP);
+        rb_define_rubyipq_const(PROTO_BR_SAT_MON);
+        rb_define_rubyipq_const(PROTO_SUN_ND);
+        rb_define_rubyipq_const(PROTO_WB_MON);
+        rb_define_rubyipq_const(PROTO_WB_EXPAK);
+        rb_define_rubyipq_const(PROTO_ISO_IP);
+        rb_define_rubyipq_const(PROTO_VMTP);
+        rb_define_rubyipq_const(PROTO_SECURE_VMTP);
+        rb_define_rubyipq_const(PROTO_VINES);
+        rb_define_rubyipq_const(PROTO_TTP);
+        rb_define_rubyipq_const(PROTO_NSFNET_IGP);
+        rb_define_rubyipq_const(PROTO_DGP);
+        rb_define_rubyipq_const(PROTO_TCF);
+        rb_define_rubyipq_const(PROTO_EIGRP);
+        rb_define_rubyipq_const(PROTO_OSPFIGP);
+        rb_define_rubyipq_const(PROTO_SPRITE_RPC);
+        rb_define_rubyipq_const(PROTO_LARP);
+        rb_define_rubyipq_const(PROTO_MTP);
+        rb_define_rubyipq_const(PROTO_AX_25);
+        rb_define_rubyipq_const(PROTO_IPIP);
+        rb_define_rubyipq_const(PROTO_MICP);
+        rb_define_rubyipq_const(PROTO_SCC_SP);
+        rb_define_rubyipq_const(PROTO_ETHERIP);
+        rb_define_rubyipq_const(PROTO_ENCAP);
+        rb_define_rubyipq_const(PROTO_ANY_PRIVATE_ENCRYPTION_SCHEME);
+        rb_define_rubyipq_const(PROTO_GMTP);
+        rb_define_rubyipq_const(PROTO_IFMP);
+        rb_define_rubyipq_const(PROTO_PNNI);
+        rb_define_rubyipq_const(PROTO_PIM);
+        rb_define_rubyipq_const(PROTO_ARIS);
+        rb_define_rubyipq_const(PROTO_SCPS);
+        rb_define_rubyipq_const(PROTO_QNX);
+        rb_define_rubyipq_const(PROTO_A_N);
+        rb_define_rubyipq_const(PROTO_IPCOMP);
+        rb_define_rubyipq_const(PROTO_SNP);
+        rb_define_rubyipq_const(PROTO_COMPAQ_PEER);
+        rb_define_rubyipq_const(PROTO_IPX_IN_IP);
+        rb_define_rubyipq_const(PROTO_VRRP);
+        rb_define_rubyipq_const(PROTO_PGM);
+        rb_define_rubyipq_const(PROTO_ANY_0_HOP_PROTOCOL);
+        rb_define_rubyipq_const(PROTO_L2TP);
+        rb_define_rubyipq_const(PROTO_DDX);
+        rb_define_rubyipq_const(PROTO_IATP);
+        rb_define_rubyipq_const(PROTO_STP);
+        rb_define_rubyipq_const(PROTO_SRP);
+        rb_define_rubyipq_const(PROTO_UTI);
+        rb_define_rubyipq_const(PROTO_SMP);
+        rb_define_rubyipq_const(PROTO_SM);
+        rb_define_rubyipq_const(PROTO_PTP);
+        rb_define_rubyipq_const(PROTO_ISIS_OVER_IPV4);
+        rb_define_rubyipq_const(PROTO_FIRE);
+        rb_define_rubyipq_const(PROTO_CRTP);
+        rb_define_rubyipq_const(PROTO_CRUDP);
+        rb_define_rubyipq_const(PROTO_SSCOPMCE);
+        rb_define_rubyipq_const(PROTO_IPLT);
+        rb_define_rubyipq_const(PROTO_SPS);
+        rb_define_rubyipq_const(PROTO_PIPE);
+        rb_define_rubyipq_const(PROTO_SCTP);
+        rb_define_rubyipq_const(PROTO_FC);
+        rb_define_rubyipq_const(PROTO_RSVP_E2E_IGNORE);
+        rb_define_rubyipq_const(PROTO_MOBILITY);
+        rb_define_rubyipq_const(PROTO_UDPLITE);
+        rb_define_rubyipq_const(PROTO_MPLS_IN_IP);
+
+
+	/* cIPHeader definitions */
+        rb_define_singleton_method(cIPHeader, "new", ipheader_new, 0);
+        rb_define_singleton_method(cIPHeader, "initialize", ipheader_init, 0);
+        rb_define_singleton_method(cIPHeader, "tos", ipheader_tos, 0);
+        rb_define_singleton_method(cIPHeader, "tot_len", ipheader_tot_len, 0);
+        rb_define_singleton_method(cIPHeader, "id", ipheader_id, 0);
+        rb_define_singleton_method(cIPHeader, "frag_off", ipheader_frag_off, 0);
+        rb_define_singleton_method(cIPHeader, "ttl", ipheader_ttl, 0);
+        rb_define_singleton_method(cIPHeader, "protocol", ipheader_protocol, 0);
+        rb_define_singleton_method(cIPHeader, "check", ipheader_check, 0);
+        rb_define_singleton_method(cIPHeader, "saddr", ipheader_saddr, 0);
+        rb_define_singleton_method(cIPHeader, "daddr", ipheader_daddr, 0);
+
+	/* cTCPHeader definitions */
+        rb_define_singleton_method(cTCPHeader, "new", tcpheader_new, 0);
+        rb_define_singleton_method(cTCPHeader, "initialize", tcpheader_init, 0);
+        rb_define_singleton_method(cTCPHeader, "source", tcpheader_source, 0);
+        rb_define_singleton_method(cTCPHeader, "dest", tcpheader_dest, 0);
+        rb_define_singleton_method(cTCPHeader, "seq", tcpheader_seq, 0);
+        rb_define_singleton_method(cTCPHeader, "ack_seq", tcpheader_ack_seq, 0);
+        rb_define_singleton_method(cTCPHeader, "window", tcpheader_window, 0);
+        rb_define_singleton_method(cTCPHeader, "check", tcpheader_check, 0);
+        rb_define_singleton_method(cTCPHeader, "get_data", tcpheader_get_data, 0);
+
+	/* cUDPHeader definitions */
+	rb_define_singleton_method(cUDPHeader, "new", udpheader_new, 0);
+	rb_define_singleton_method(cUDPHeader, "initialize", udpheader_init, 0);
+	rb_define_singleton_method(cUDPHeader, "source", udpheader_source, 0);
+	rb_define_singleton_method(cUDPHeader, "dest", udpheader_dest, 0);
+	rb_define_singleton_method(cUDPHeader, "len", udpheader_len, 0);
+	rb_define_singleton_method(cUDPHeader, "check", udpheader_check, 0);
+	rb_define_singleton_method(cUDPHeader, "get_data", udpheader_get_data, 0);
+}

data/rubyipq.h

@@ -0,0 +1,36 @@
+/*
+ * rubyipq v0.1.0
+ * Ruby bindings for Netfilter's libipq.
+ *
+ * Copyright (c) 2005 Leonardo Eloy
+ * Author: Leonardo Eloy <l.eloy@terra.com.br/leonardo.eloy@gmail.com>
+ * Project Homepage: http://rubyipq.rubyforge.org
+ *
+ *
+ *      This program 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.
+ *
+ *      This program 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 this program; if not, write to the Free Software
+ *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "ruby.h"
+#include "util.h"
+
+#include "rubyipq_proto.h"
+#include "rubyipq_defs.h"
+
+#include <stdio.h>
+
+/* Needed for __u32_to_str() */
+#define DECIMAL_BYTE_VALUE      255
+
+#define DEFAULT_BUFFER_SIZE	2048