#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include <ruby.h>
#include <libnet.h>

VALUE cLibnet;

extern void define_ipv4_methods(void);
extern void define_ipv6_methods(void);
extern void define_udp_methods(void);
extern void define_ipv4_methods(void);
extern void define_ethernet_methods(void);
extern void define_vlan_methods(void);
extern void define_arp_methods(void);

/* call-seq:
 *   Libnet.new(injection_type=:raw4, device=nil)   # -> a new Libnet object
 *
 *   Creates a new Libnet object.  The +injection_type+ parameter defines
 *   how the constructed packet get injected into the network.
 *
 *   If +injection_type+ is <tt>:link</tt>, the packet gets injected at the data
 *   link layer (which provides more granular control over the IP layer).  If
 *   +injection_type+ is <tt>:link</tt> and +device+ is not +nil+, Libnet
 *   attempts to use the specified network device for packet injection.  The
 *   +device+ parameter is either a canonical string that references the device
 *   (such as "eth0" for a 100MB Ethernet card on Linux or "fxp0" for a 100MB
 *   Ethernet card on OpenBSD) or the dotted decimal representation of the
 *   device's IP address (e.g. 192.168.0.1).  If +device+ is +nil+, Libnet
 *   attempts to find a suitable device to use.
 *
 *   If +injection_type+ is <tt>:raw4</tt>, the packet gets injected using a raw
 *   socket interface.
 */
static VALUE net_s_new(int argc, VALUE *argv, VALUE self)
{
    libnet_t *l;
    VALUE     obj;
    char      errbuf[LIBNET_ERRBUF_SIZE];
    int       inj_type = LIBNET_RAW4_ADV;
    char     *inj_str = NULL;
    size_t    inj_str_len = 0;
    char     *dev_str = NULL;

    /* get the injection type */
    if (argc > 0) {
        switch (TYPE(argv[0])) {
            case T_STRING:
                inj_str     = RSTRING(argv[0])->ptr;
                inj_str_len = RSTRING(argv[0])->len;
                break;
            case T_SYMBOL:
                inj_str     = rb_id2name(SYM2ID(argv[0]));
                inj_str_len = strlen(inj_str);
                break;
            default:
                rb_raise(rb_eTypeError,
                        "invalid type, expecting a String or Symbol");
        }

        if (strncasecmp("raw", inj_str, inj_str_len) == 0 ||
            strncasecmp("raw4", inj_str, inj_str_len) == 0) {
            inj_type = LIBNET_RAW4_ADV;
        }
        else if (strncasecmp("raw6", inj_str, inj_str_len) == 0) {
            inj_type = LIBNET_RAW6_ADV;
        }
        else if (strncasecmp("link", inj_str, inj_str_len) == 0) {
            inj_type = LIBNET_LINK_ADV;
        }
        else {
            rb_raise(rb_eArgError,
                    "%s is not a valid initialization type, should be one of: 'raw4', 'raw6', or 'link'",
                    inj_str);
        }
    }

    /* get the device string */
    if (argc > 1) {
        dev_str = StringValuePtr(argv[1]);
    }

    l = libnet_init(inj_type, dev_str, errbuf);

    if (l == NULL) {
        rb_raise(rb_eRuntimeError, errbuf);
    }

    obj = Data_Wrap_Struct(self, NULL, libnet_destroy, l);

    /* set the injection type attribute */
    switch (inj_type) {
        case LIBNET_RAW4_ADV:
            rb_iv_set(obj, "@injection_type", ID2SYM(rb_intern("raw4")));
            break;
        case LIBNET_RAW6_ADV:
            rb_iv_set(obj, "@injection_type", ID2SYM(rb_intern("raw6")));
            break;
        case LIBNET_LINK_ADV:
            rb_iv_set(obj, "@injection_type", ID2SYM(rb_intern("link")));
            break;
        default:
            rb_bug("BUG: %d is an invalid injection type (this should not happen)",
                    inj_type); 
    }


    return obj;
}

/* call-seq:
 *   Libnet.addr2name4(addr, do_dns_lookup=true)  # -> DNS name or dotted decimal string
 *
 *   Takes a network byte ordered IPv4 address and returns a string containing
 *   either the canonical DNS name (if it has one) or a dotted decimal
 *   respresentation of the IP address.  This may incur a DNS lookup if the
 *   +do_dns_lookup+ parameter is set to true.  If the +do_dns_lookup+
 *   parameter is set to false, no DNS lookup will be performed and the dotted
 *   decimal representation of the IP address will be returned.
 */
static VALUE net_s_addr2name4(int argc, VALUE *argv, VALUE self)
{
    VALUE      addr_v, use_name_v, name_v;
    u_int32_t  addr;
    u_int8_t   use_name = LIBNET_RESOLVE;
    char      *name = NULL;

    rb_scan_args(argc, argv, "11", &addr_v, &use_name_v);

    addr = NUM2ULONG(addr_v);

    addr = htonl(addr);

    if (!NIL_P(use_name_v) && use_name_v == Qfalse) {
        use_name = LIBNET_DONT_RESOLVE;
    }

    name = libnet_addr2name4(addr, use_name);

    name_v = rb_str_new2(name);

    /* don't free the returned name here as its stored in a static buffer by
     * libnet */

    return name_v;
}

/* call-seq:
 *   Libnet.addr2name6(addr, do_dns_lookup=true) # -> DNS name or printable IPv6 string
 *
 * Takes a 16 byte IPv6 address and returns either the canonical DNS name (if
 * it has one) or a printable representation of the address.
 */
static VALUE net_s_addr2name6(int argc, VALUE *argv, VALUE self)
{
    VALUE      addr_v, use_name_v, name_v;
    struct libnet_in6_addr addr;
    u_int8_t   use_name = LIBNET_RESOLVE;
    char       name[100];

    rb_scan_args(argc, argv, "11", &addr_v, &use_name_v);

    if (RSTRING(addr_v)->len != 16) {
      rb_raise(rb_eArgError, "invalid IPv6 address");
    }

    memcpy(addr.libnet_s6_addr, RSTRING(addr_v)->ptr, sizeof(addr.libnet_s6_addr));

    if (!NIL_P(use_name_v) && use_name_v == Qfalse) {
        use_name = LIBNET_DONT_RESOLVE;
    }

    libnet_addr2name6_r(addr, use_name, name, sizeof(name));

    name_v = rb_str_new2(name);

    return name_v;
}

/* call-seq:
 *   Libnet.hex_aton(string)  # -> string
 *
 * Takes a colon separated hexidecimal address and returns a byte string
 * suitable for use in a protocol builder method.
 */
static VALUE net_s_hex_aton(VALUE self, VALUE str)
{
    u_int8_t *rv;
    int       len;
    VALUE     s;

    rv = libnet_hex_aton((int8_t *)StringValuePtr(str), &len);

    if (rv == NULL) {
        rb_raise(rb_eArgError, "could not convert input string");
    }

    s = rb_str_new((char *)rv, len);

    free(rv);

    return s;
}


/* call-seq:
 *   Libnet.ipv4_aton(string) # -> integer
 *
 * Takes a dotted-decimal representation of an IPv4 address and returns a 4
 * byte integer suitable for use in a header builder method.
 */
static VALUE net_s_ipv4_aton(VALUE self, VALUE str)
{
  char          *ip_s;
  int            len = RSTRING(str)->len;
  unsigned long  ipv4;
  VALUE          r;

  ip_s = malloc(len + 1);

  memcpy(ip_s, RSTRING(str)->ptr, len);
  ip_s[len] = '\0';

  if (inet_pton(AF_INET, ip_s, &ipv4) == 1) {
    ipv4 = htonl(ipv4);
    r = ULONG2NUM(ipv4);
  }
  else {
    free(ip_s);
    rb_raise(rb_eArgError, "invalid IPv4 address: %s\n", ip_s);
  }

  free(ip_s);

  return r;
}

/* call-seq:
 *   Libnet.ipv6_aton(string) # -> integer
 *
 * Takes a string representation of an IPv6 address and returns a 16
 * byte string suitable for use in a header builder method.
 */
static VALUE net_s_ipv6_aton(VALUE self, VALUE str)
{
  char          *ip_s;
  int            len = RSTRING(str)->len;
  unsigned char  ipv6[16];
  VALUE          r;

  ip_s = malloc(len + 1);

  memcpy(ip_s, RSTRING(str)->ptr, len);
  ip_s[len] = '\0';

  if (inet_pton(AF_INET6, ip_s, ipv6) == 1) {
    r = rb_str_new(ipv6, sizeof(ipv6));
  }
  else {
    free(ip_s);
    rb_raise(rb_eArgError, "invalid IPv6 address: %s\n", ip_s);
  }

  free(ip_s);

  return r;
}

/* call-seq:
 *   Libnet.ipv4_ntoa(integer) # -> string
 *
 * Takes a network formated IPv4 address and converts it to its dotted-decimal
 * string representation.
 */
static VALUE net_s_ipv4_ntoa(VALUE self, VALUE integer)
{
  unsigned long ipv4 = NUM2ULONG(integer);
  char          pbuf[100];
  VALUE         r;

  ipv4 = htonl(ipv4);

  if (inet_ntop(AF_INET, &ipv4, pbuf, sizeof(pbuf))) {
    r = rb_str_new2(pbuf);
  }
  else {
    rb_raise(rb_eArgError,
        "could not convert integer value %#x to a printable IPv4 string",
        ipv4);
  }

  return r;
}

/* call-seq:
 *   Libnet.ipv6_ntoa(string) # -> string
 *
 * Takes a network formated IPv6 address and converts it to its printable
 * format.
 */
static VALUE net_s_ipv6_ntoa(VALUE self, VALUE str)
{
  char         *ip_s;
  int           len = RSTRING(str)->len;
  char          pbuf[100];
  VALUE         r;

  if (len != 16) {
    rb_raise(rb_eArgError, "invalid IPv6 address");
  }

  ip_s = malloc(len + 1);

  memcpy(ip_s, RSTRING(str)->ptr, len);
  ip_s[len] = '\0';

  if (inet_ntop(AF_INET6, ip_s, pbuf, sizeof(pbuf))) {
    r = rb_str_new2(pbuf);
  }
  else {
    rb_raise(rb_eArgError,
        "could not convert IPv6 address to a printable string");
  }

  return r;
}

/* call-seq:
 *  l.get_device # -> string
 *
 * Returns the canonical name of the device used for packet injection.
 */
static VALUE net_get_device(VALUE self)
{
    libnet_t *l;
    char     *dev;

    Data_Get_Struct(self, libnet_t, l);

    dev = (char *)libnet_getdevice(l);

    if (dev == NULL) {
        dev = "";
    }

    return rb_str_new2(dev);
}

/* call-seq:
 *   l.write # -> num bytes written
 *
 * Writes a prebuilt packet to the network.  The method assumes that a
 * packet has been constructed inside the Libnet object via one or more
 * Libnet#build_* methods and is ready to go.  Depending on how this
 * Libnet object was initialized, the method will write the packet to the
 * wire either via the raw or link layer interface.
 *
 * Note: It is necessary for the UID or EUID of the process running this method
 * to be 0.
 */
static VALUE net_write(VALUE self)
{
    libnet_t *l;
    int       num_bytes;

    Data_Get_Struct(self, libnet_t, l);

    num_bytes = libnet_write(l);

    if (num_bytes == -1) {
        rb_raise(rb_eRuntimeError, libnet_geterror(l));
    }

    return INT2NUM(num_bytes);
}

/* call-seq:
 *   l.write_bytes(string) # -> num bytes written
 *
 * Writes a packet to the wire.  This method is usedful to write a packet
 * that has been constructed by hand or to write a packet that has been
 * returned from Libnet#pack.
 *
 * Note: It is necessary for the UID or EUID of the process running this method
 * to be 0.
 */
static VALUE net_write_bytes(VALUE self, VALUE bytes)
{
    libnet_t *l;
    int       num_bytes;
    VALUE     str;
    VALUE     inj_type;

    str = StringValue(bytes);

    Data_Get_Struct(self, libnet_t, l);

    inj_type = rb_iv_get(self, "@injection_type");

    if (ID2SYM(rb_intern("raw4")) == inj_type) {
        num_bytes = libnet_write_raw_ipv4(l, RSTRING(str)->ptr, RSTRING(str)->len);
    }
    else if (ID2SYM(rb_intern("raw6")) == inj_type) {
        num_bytes = libnet_write_raw_ipv6(l, RSTRING(str)->ptr, RSTRING(str)->len);
    }
    else if (ID2SYM(rb_intern("link")) == inj_type) {
        num_bytes = libnet_write_link(l, RSTRING(str)->ptr, RSTRING(str)->len);
    }
    else {
        rb_bug("BUG: invalid injection type found (this should not happen)");
    }

    if (num_bytes == -1) {
        rb_raise(rb_eRuntimeError, libnet_geterror(l));
    }

    return INT2NUM(num_bytes);
}

/* call-seq:
 *   l.pack # -> string
 *
 * Yanks a prebuilt, wire-ready packet from the Libnet object.
 */
static VALUE net_pack(VALUE self)
{
    libnet_t  *l;
    u_int8_t  *packet;
    u_int32_t  packet_s;
    VALUE      str;

    Data_Get_Struct(self, libnet_t, l);

    if (libnet_pblock_coalesce(l, &packet, &packet_s) == -1) {
        rb_raise(rb_eRuntimeError, libnet_geterror(l));
    }

    str = rb_str_new((char *)packet, packet_s);

    libnet_adv_free_packet(l, packet);

    return str;
}

/* call-seq:
 *   l.dump # -> nil
 *
 * Prints the contents of the Libnet object to STDOUT.
 */
static VALUE net_dump(VALUE self)
{
    libnet_t  *l;

    Data_Get_Struct(self, libnet_t, l);

    libnet_diag_dump_context(l);

    return Qnil;
}

/* call-seq:
 *   l.clear # -> nil
 *
 * Clears the current packet inside the Libnet object.  Should be called
 * when the programmer wants to send a completely new packet of a different
 * type using the same Libnet object.
 */
static VALUE net_clear(VALUE self)
{
    libnet_t  *l;

    Data_Get_Struct(self, libnet_t, l);

    libnet_clear_packet(l);

    return Qnil;
}

/* call-seq:
 *   l.hwaddr # -> string
 *
 * Returns the MAC address for the device the Libnet object was initialized
 * with.  If the Libnet object was initialized without a device, the method
 * will attempt to find one.  If the method fails to find a device, a
 * RuntimeError will be raised.
 */
static VALUE net_hwaddr(VALUE self)
{
    libnet_t                  *l;
    struct  libnet_ether_addr *eth;
    int                        i;
    char                       eth_s[18];
    char                       byte_s[3];

    Data_Get_Struct(self, libnet_t, l);

    eth = libnet_get_hwaddr(l);

    if (eth == NULL) {
        rb_raise(rb_eRuntimeError, libnet_geterror(l));
    }

    memset(eth_s, 0, sizeof(eth_s));

    for (i = 0; i < 6; i++) {
        snprintf(byte_s, sizeof(byte_s), "%02x", eth->ether_addr_octet[i]);
        strcat(eth_s, byte_s);

        if (i != 5) {
            strcat(eth_s, ":");
        }
    }

    return rb_str_new2(eth_s);
}

/* Ruby bindings for the Libnet[http://www.packetfactory.net/libnet/] Packet
 * Construction Library.
 */
void Init_libnet4r()
{
    cLibnet = rb_define_class("Libnet", rb_cObject);

    /* libnet header length constants */
    rb_define_const(cLibnet, "HL_802_1Q", INT2FIX(LIBNET_802_1Q_H));
    rb_define_const(cLibnet, "HL_802_1X", INT2FIX(LIBNET_802_1X_H));
    rb_define_const(cLibnet, "HL_802_2", INT2FIX(LIBNET_802_2_H));
    rb_define_const(cLibnet, "HL_802_2SNAP", INT2FIX(LIBNET_802_2SNAP_H));
    rb_define_const(cLibnet, "HL_802_3", INT2FIX(LIBNET_802_3_H));
    rb_define_const(cLibnet, "HL_ARP", INT2FIX(LIBNET_ARP_H));
    rb_define_const(cLibnet, "HL_ARP_ETH_IP", INT2FIX(LIBNET_ARP_ETH_IP_H));
    rb_define_const(cLibnet, "HL_BGP4_HEADER", INT2FIX(LIBNET_BGP4_HEADER_H));
    rb_define_const(cLibnet, "HL_BGP4_OPEN", INT2FIX(LIBNET_BGP4_OPEN_H));
    rb_define_const(cLibnet, "HL_BGP4_UPDATE", INT2FIX(LIBNET_BGP4_UPDATE_H));
    rb_define_const(cLibnet, "HL_BGP4_NOTIFICATION", INT2FIX(LIBNET_BGP4_NOTIFICATION_H));
    rb_define_const(cLibnet, "HL_CDP", INT2FIX(LIBNET_CDP_H));
    rb_define_const(cLibnet, "HL_DHCPV4", INT2FIX(LIBNET_DHCPV4_H));
    rb_define_const(cLibnet, "HL_UDP_DNSV4", INT2FIX(LIBNET_UDP_DNSV4_H));
    rb_define_const(cLibnet, "HL_TCP_DNSV4", INT2FIX(LIBNET_TCP_DNSV4_H));
    rb_define_const(cLibnet, "HL_ETH", INT2FIX(LIBNET_ETH_H));
    rb_define_const(cLibnet, "HL_FDDI", INT2FIX(LIBNET_FDDI_H));
    rb_define_const(cLibnet, "HL_ICMPV4", INT2FIX(LIBNET_ICMPV4_H));
    rb_define_const(cLibnet, "HL_ICMPV4_ECHO", INT2FIX(LIBNET_ICMPV4_ECHO_H));
    rb_define_const(cLibnet, "HL_ICMPV4_MASK", INT2FIX(LIBNET_ICMPV4_MASK_H));
    rb_define_const(cLibnet, "HL_ICMPV4_UNREACH", INT2FIX(LIBNET_ICMPV4_UNREACH_H));
    rb_define_const(cLibnet, "HL_ICMPV4_TIMXCEED", INT2FIX(LIBNET_ICMPV4_TIMXCEED_H));
    rb_define_const(cLibnet, "HL_ICMPV4_REDIRECT", INT2FIX(LIBNET_ICMPV4_REDIRECT_H));
    rb_define_const(cLibnet, "HL_ICMPV4_TS", INT2FIX(LIBNET_ICMPV4_TS_H));
    rb_define_const(cLibnet, "HL_ICMPV6", INT2FIX(LIBNET_ICMPV6_H));
    rb_define_const(cLibnet, "HL_IGMP", INT2FIX(LIBNET_IGMP_H));
    rb_define_const(cLibnet, "HL_IPV4", INT2FIX(LIBNET_IPV4_H));
    rb_define_const(cLibnet, "HL_IPV6", INT2FIX(LIBNET_IPV6_H));
    rb_define_const(cLibnet, "HL_IPV6_FRAG", INT2FIX(LIBNET_IPV6_FRAG_H));
    rb_define_const(cLibnet, "HL_IPV6_ROUTING", INT2FIX(LIBNET_IPV6_ROUTING_H));
    rb_define_const(cLibnet, "HL_IPV6_DESTOPTS", INT2FIX(LIBNET_IPV6_DESTOPTS_H));
    rb_define_const(cLibnet, "HL_IPV6_HBHOPTS", INT2FIX(LIBNET_IPV6_HBHOPTS_H));
    rb_define_const(cLibnet, "HL_IPSEC_ESP_HDR", INT2FIX(LIBNET_IPSEC_ESP_HDR_H));
    rb_define_const(cLibnet, "HL_IPSEC_ESP_FTR", INT2FIX(LIBNET_IPSEC_ESP_FTR_H));
    rb_define_const(cLibnet, "HL_IPSEC_AH", INT2FIX(LIBNET_IPSEC_AH_H));
    rb_define_const(cLibnet, "HL_ISL", INT2FIX(LIBNET_ISL_H));
    rb_define_const(cLibnet, "HL_GRE", INT2FIX(LIBNET_GRE_H));
    rb_define_const(cLibnet, "HL_GRE_SRE", INT2FIX(LIBNET_GRE_SRE_H));
    rb_define_const(cLibnet, "HL_MPLS", INT2FIX(LIBNET_MPLS_H));
    rb_define_const(cLibnet, "HL_OSPF", INT2FIX(LIBNET_OSPF_H));
    rb_define_const(cLibnet, "HL_OSPF_HELLO", INT2FIX(LIBNET_OSPF_HELLO_H));
    rb_define_const(cLibnet, "HL_OSPF_DBD", INT2FIX(LIBNET_OSPF_DBD_H));
    rb_define_const(cLibnet, "HL_OSPF_LSR", INT2FIX(LIBNET_OSPF_LSR_H));
    rb_define_const(cLibnet, "HL_OSPF_LSU", INT2FIX(LIBNET_OSPF_LSU_H));
    rb_define_const(cLibnet, "HL_OSPF_LSA", INT2FIX(LIBNET_OSPF_LSA_H));
    rb_define_const(cLibnet, "HL_OSPF_AUTH", INT2FIX(LIBNET_OSPF_AUTH_H));
    rb_define_const(cLibnet, "HL_OSPF_CKSUM", INT2FIX(LIBNET_OSPF_CKSUM));
    rb_define_const(cLibnet, "HL_OSPF_LS_RTR", INT2FIX(LIBNET_OSPF_LS_RTR_H));
    rb_define_const(cLibnet, "HL_OSPF_LS_NET", INT2FIX(LIBNET_OSPF_LS_NET_H));
    rb_define_const(cLibnet, "HL_OSPF_LS_SUM", INT2FIX(LIBNET_OSPF_LS_SUM_H));
    rb_define_const(cLibnet, "HL_OSPF_LS_AS_EXT", INT2FIX(LIBNET_OSPF_LS_AS_EXT_H));
    rb_define_const(cLibnet, "HL_NTP", INT2FIX(LIBNET_NTP_H));
    rb_define_const(cLibnet, "HL_RIP", INT2FIX(LIBNET_RIP_H));
    rb_define_const(cLibnet, "HL_RPC_CALL", INT2FIX(LIBNET_RPC_CALL_H));
    rb_define_const(cLibnet, "HL_RPC_CALL_TCP", INT2FIX(LIBNET_RPC_CALL_TCP_H));
    rb_define_const(cLibnet, "HL_SEBEK", INT2FIX(LIBNET_SEBEK_H));
    rb_define_const(cLibnet, "HL_STP_CONF", INT2FIX(LIBNET_STP_CONF_H));
    rb_define_const(cLibnet, "HL_STP_TCN", INT2FIX(LIBNET_STP_TCN_H));
    rb_define_const(cLibnet, "HL_TOKEN_RING", INT2FIX(LIBNET_TOKEN_RING_H));
    rb_define_const(cLibnet, "HL_TCP", INT2FIX(LIBNET_TCP_H));
    rb_define_const(cLibnet, "HL_UDP", INT2FIX(LIBNET_UDP_H));
    rb_define_const(cLibnet, "HL_VRRP", INT2FIX(LIBNET_VRRP_H));

    /* IP protocol constants */
#ifdef HAVE_IPPROTO_IP
    rb_define_const(cLibnet, "IPPROTO_IP", INT2FIX(IPPROTO_IP));
#endif
#ifdef HAVE_IPPROTO_HOPOPTS
    rb_define_const(cLibnet, "IPPROTO_HOPOPTS", INT2FIX(IPPROTO_HOPOPTS));
#endif
#ifdef HAVE_IPPROTO_ICMP
    rb_define_const(cLibnet, "IPPROTO_ICMP", INT2FIX(IPPROTO_ICMP));
#endif
#ifdef HAVE_IPPROTO_IGMP
    rb_define_const(cLibnet, "IPPROTO_IGMP", INT2FIX(IPPROTO_IGMP));
#endif
#ifdef HAVE_IPPROTO_GGP
    rb_define_const(cLibnet, "IPPROTO_GGP", INT2FIX(IPPROTO_GGP));
#endif
#ifdef HAVE_IPPROTO_ENCAP
    rb_define_const(cLibnet, "IPPROTO_ENCAP", INT2FIX(IPPROTO_ENCAP));
#endif
#ifdef HAVE_IPPROTO_TCP
    rb_define_const(cLibnet, "IPPROTO_TCP", INT2FIX(IPPROTO_TCP));
#endif
#ifdef HAVE_IPPROTO_EGP
    rb_define_const(cLibnet, "IPPROTO_EGP", INT2FIX(IPPROTO_EGP));
#endif
#ifdef HAVE_IPPROTO_PUP
    rb_define_const(cLibnet, "IPPROTO_PUP", INT2FIX(IPPROTO_PUP));
#endif
#ifdef HAVE_IPPROTO_UDP
    rb_define_const(cLibnet, "IPPROTO_UDP", INT2FIX(IPPROTO_UDP));
#endif
#ifdef HAVE_IPPROTO_IDP
    rb_define_const(cLibnet, "IPPROTO_IDP", INT2FIX(IPPROTO_IDP));
#endif
#ifdef HAVE_IPPROTO_IPV6
    rb_define_const(cLibnet, "IPPROTO_IPV6", INT2FIX(IPPROTO_IPV6));
#endif
#ifdef HAVE_IPPROTO_ROUTING
    rb_define_const(cLibnet, "IPPROTO_ROUTING", INT2FIX(IPPROTO_ROUTING));
#endif
#ifdef HAVE_IPPROTO_FRAGMENT
    rb_define_const(cLibnet, "IPPROTO_FRAGMENT", INT2FIX(IPPROTO_FRAGMENT));
#endif
#ifdef HAVE_IPPROTO_RSVP
    rb_define_const(cLibnet, "IPPROTO_RSVP", INT2FIX(IPPROTO_RSVP));
#endif
#ifdef HAVE_IPPROTO_ESP
    rb_define_const(cLibnet, "IPPROTO_ESP", INT2FIX(IPPROTO_ESP));
#endif
#ifdef HAVE_IPPROTO_AH
    rb_define_const(cLibnet, "IPPROTO_AH", INT2FIX(IPPROTO_AH));
#endif
#ifdef HAVE_IPPROTO_ICMPV6
    rb_define_const(cLibnet, "IPPROTO_ICMPV6", INT2FIX(IPPROTO_ICMPV6));
#endif
#ifdef HAVE_IPPROTO_NONE
    rb_define_const(cLibnet, "IPPROTO_NONE", INT2FIX(IPPROTO_NONE));
#endif
#ifdef HAVE_IPPROTO_DSTOPTS
    rb_define_const(cLibnet, "IPPROTO_DSTOPTS", INT2FIX(IPPROTO_DSTOPTS));
#endif
#ifdef HAVE_IPPROTO_HELLO
    rb_define_const(cLibnet, "IPPROTO_HELLO", INT2FIX(IPPROTO_HELLO));
#endif
#ifdef HAVE_IPPROTO_ND
    rb_define_const(cLibnet, "IPPROTO_ND", INT2FIX(IPPROTO_ND));
#endif
#ifdef HAVE_IPPROTO_EON
    rb_define_const(cLibnet, "IPPROTO_EON", INT2FIX(IPPROTO_EON));
#endif
#ifdef HAVE_IPPROTO_PIM
    rb_define_const(cLibnet, "IPPROTO_PIM", INT2FIX(IPPROTO_PIM));
#endif
#ifdef HAVE_IPPROTO_SCTP
    rb_define_const(cLibnet, "IPPROTO_SCTP", INT2FIX(IPPROTO_SCTP));
#endif
#ifdef HAVE_IPPROTO_RAW
    rb_define_const(cLibnet, "IPPROTO_RAW", INT2FIX(IPPROTO_RAW));
#endif
#ifdef HAVE_IPPROTO_MAX
    rb_define_const(cLibnet, "IPPROTO_MAX", INT2FIX(IPPROTO_MAX));
#endif

    /* require the pure ruby protocol classes */
    rb_require("libnet4r/libnet.rb");
    rb_require("libnet4r/helpers.rb");
    rb_require("libnet4r/header.rb");

    /* class methods */
    rb_define_singleton_method(cLibnet, "new",        net_s_new,        -1);
    rb_define_singleton_method(cLibnet, "addr2name4", net_s_addr2name4, -1);
    rb_define_singleton_method(cLibnet, "addr2name6", net_s_addr2name6, -1);
    rb_define_singleton_method(cLibnet, "hex_aton",   net_s_hex_aton,    1);
    rb_define_singleton_method(cLibnet, "ipv4_aton",  net_s_ipv4_aton,   1);
    rb_define_singleton_method(cLibnet, "ipv4_ntoa",  net_s_ipv4_ntoa,   1);
    rb_define_singleton_method(cLibnet, "ipv6_aton",  net_s_ipv6_aton,   1);
    rb_define_singleton_method(cLibnet, "ipv6_ntoa",  net_s_ipv6_ntoa,   1);

    /* instance methods */
    rb_define_method(cLibnet, "device",        net_get_device,  0);
    rb_define_method(cLibnet, "write",         net_write,       0);
    rb_define_method(cLibnet, "write_bytes",   net_write_bytes, 1);
    rb_define_method(cLibnet, "cull_packet",   net_pack,        0);
    rb_define_method(cLibnet, "pack",          net_pack,        0);
    rb_define_method(cLibnet, "hwaddr",        net_hwaddr,      0);
    rb_define_method(cLibnet, "dump",          net_dump,        0);
    rb_define_method(cLibnet, "clear",         net_clear,        0);

    /* define the individual protocol methods */
    define_udp_methods();
    define_ipv4_methods();
    define_ipv6_methods();
    define_ethernet_methods();
    define_vlan_methods();
    define_arp_methods();
}