libnet4r 0.1

data/ext/libnet_arp.c

@@ -0,0 +1,152 @@
+#include <arpa/inet.h>
+#include <ruby.h>
+#include <libnet.h>
+
+extern VALUE cLibnet;
+static VALUE cARP;
+
+static VALUE net_s_decode_arp(VALUE self, VALUE bytes) 
+{
+    VALUE                  arp_obj;
+    VALUE                  str;
+    VALUE                  payload;
+    struct libnet_arp_hdr *arp;
+    u_int16_t              ar_hrd;
+    u_int16_t              ar_pro;
+    u_int8_t               ar_hln;
+    u_int8_t               ar_pln;
+    u_int16_t              ar_op;
+    int                    msg_len;
+    int                    offset;
+
+    arp_obj = rb_funcall(self, rb_intern("new"), 0);
+
+    str = StringValue(bytes);
+
+    if (RSTRING(str)->len < LIBNET_ARP_H) {
+        rb_raise(rb_eArgError, "string is too small to contain an ARP header");
+    }
+
+    arp = (struct libnet_arp_hdr *)RSTRING(str)->ptr;
+
+    ar_hrd = ntohs(arp->ar_hrd);
+    ar_pro = ntohs(arp->ar_pro);
+    ar_hln = arp->ar_hln;
+    ar_pln = arp->ar_pln;
+    ar_op  = ntohs(arp->ar_op);
+
+    rb_iv_set(arp_obj, "@htype",     UINT2NUM(ar_hrd));
+    rb_iv_set(arp_obj, "@protocol",  UINT2NUM(ar_pro));
+    rb_iv_set(arp_obj, "@hlen",      UINT2NUM(ar_hln));
+    rb_iv_set(arp_obj, "@plen",      UINT2NUM(ar_pln));
+    rb_iv_set(arp_obj, "@operation", UINT2NUM(ar_op));
+
+    msg_len = LIBNET_ARP_H + (2 * ar_hln) + (2 * ar_pln);
+
+    if (RSTRING(str)->len < msg_len) {
+        rb_raise(rb_eArgError, "string is too small to contain an ARP message");
+    }
+
+    /* unpack the addresses */
+    offset = LIBNET_ARP_H;
+    rb_iv_set(arp_obj, "@sender_haddr", rb_str_new(RSTRING(str)->ptr + offset, ar_hln));
+    offset += ar_hln;
+    rb_iv_set(arp_obj, "@sender_paddr", rb_str_new(RSTRING(str)->ptr + offset, ar_pln));
+    offset += ar_pln;
+    rb_iv_set(arp_obj, "@target_haddr", rb_str_new(RSTRING(str)->ptr + offset, ar_hln));
+    offset += ar_hln;
+    rb_iv_set(arp_obj, "@target_paddr", rb_str_new(RSTRING(str)->ptr + offset, ar_pln));
+    offset += ar_pln;
+
+    /* unpack the payload */
+    if (RSTRING(str)->len > msg_len) {
+        payload = rb_str_new(RSTRING(str)->ptr + msg_len,
+                RSTRING(str)->len - msg_len);
+    }
+    else {
+        payload = Qnil;
+    }
+
+    rb_iv_set(arp_obj, "@payload", payload);
+
+    return arp_obj;
+}
+
+static VALUE net_build_arp(int argc, VALUE *argv, VALUE self)
+{
+    libnet_t      *l;
+    VALUE          arp_obj, v;
+    u_int16_t      hrd, pro, op;
+    u_int8_t       hln, pln;
+    VALUE          sha, spa, tha, tpa; 
+    char          *payload   = NULL;
+    u_int32_t      payload_s = 0;
+    VALUE          ptag_obj;
+    libnet_ptag_t  ptag = 0;
+
+    rb_scan_args(argc, argv, "01", &arp_obj);
+
+    Data_Get_Struct(self, libnet_t, l);
+
+    if (NIL_P(arp_obj)) {
+        arp_obj = rb_class_new_instance(0, NULL, cARP);
+        rb_yield(arp_obj);
+    }
+
+    /* check that all required fields are set */
+    rb_funcall(arp_obj, rb_intern("check_packable"), 0);
+
+    v   = rb_funcall(arp_obj, rb_intern("htype"), 0);
+    hrd = NUM2UINT(v);
+    v   = rb_funcall(arp_obj, rb_intern("protocol"), 0);
+    pro = NUM2UINT(v);
+    v   = rb_funcall(arp_obj, rb_intern("hlen"), 0);
+    hln = NUM2UINT(v);
+    v   = rb_funcall(arp_obj, rb_intern("plen"), 0);
+    pln = NUM2UINT(v);
+    v   = rb_funcall(arp_obj, rb_intern("operation"), 0);
+    op  = NUM2UINT(v);
+    v   = rb_funcall(arp_obj, rb_intern("sender_haddr"), 0);
+    sha = StringValue(v);
+    v   = rb_funcall(arp_obj, rb_intern("sender_paddr"), 0);
+    spa = StringValue(v);
+    v   = rb_funcall(arp_obj, rb_intern("target_haddr"), 0);
+    tha = StringValue(v);
+    v   = rb_funcall(arp_obj, rb_intern("target_paddr"), 0);
+    tpa = StringValue(v);
+
+    /* get the payload */
+    if ((v = rb_funcall(arp_obj, rb_intern("payload"), 0)) != Qnil) {
+        v         = StringValue(v);
+        payload   = RSTRING(v)->ptr;
+        payload_s = RSTRING(v)->len;
+    }
+
+    ptag_obj = rb_iv_get(arp_obj, "@ptag");
+
+    if (!NIL_P(ptag_obj)) {
+        ptag = NUM2LONG(ptag_obj);
+    }
+
+    ptag = libnet_build_arp(hrd, pro, hln, pln, op, RSTRING(sha)->ptr,
+            RSTRING(spa)->ptr, RSTRING(tha)->ptr, RSTRING(tpa)->ptr,
+            payload, payload_s, l, ptag);
+            
+    if (ptag == -1) {
+        rb_raise(rb_eRuntimeError, libnet_geterror(l));
+    }
+
+    rb_iv_set(arp_obj, "@ptag", LONG2NUM(ptag));
+
+    return arp_obj;
+}
+
+void define_arp_methods()
+{
+    cARP = rb_const_get(cLibnet, rb_intern("ARP"));
+
+    rb_define_singleton_method(cARP, "decode", net_s_decode_arp, 1);
+
+    rb_define_method(cLibnet, "build_arp", net_build_arp, -1);
+}
+

data/ext/libnet_ethernet.c

@@ -0,0 +1,115 @@
+#include <arpa/inet.h>
+#include <ruby.h>
+#include <libnet.h>
+
+extern VALUE cLibnet;
+
+static VALUE net_s_decode_ethernet(VALUE self, VALUE bytes) 
+{
+    VALUE                       eth_obj;
+    VALUE                       str;
+    VALUE                       payload;
+    struct libnet_ethernet_hdr *eth;
+    u_int16_t                   ether_type;
+
+    eth_obj = rb_funcall(self, rb_intern("new"), 0);
+
+    str = StringValue(bytes);
+
+    if (RSTRING(str)->len < LIBNET_ETH_H) {
+        rb_raise(rb_eArgError, "string is too small to contain an Ethernet header");
+    }
+
+    eth = (struct libnet_ethernet_hdr *)RSTRING(str)->ptr;
+
+    ether_type = ntohs(eth->ether_type);
+
+    /*
+    rb_iv_set(eth_obj, "@dst", rb_str_new(eth->ether_dhost, ETHER_ADDR_LEN));
+    rb_iv_set(eth_obj, "@src", rb_str_new(eth->ether_shost, ETHER_ADDR_LEN));
+    rb_iv_set(eth_obj, "@type", UINT2NUM(ether_type));
+    */
+    rb_funcall(eth_obj, rb_intern("dst="), 1, rb_str_new((char *)eth->ether_dhost, ETHER_ADDR_LEN));
+    rb_funcall(eth_obj, rb_intern("src="), 1, rb_str_new((char *)eth->ether_shost, ETHER_ADDR_LEN));
+    rb_funcall(eth_obj, rb_intern("type="), 1, UINT2NUM(ether_type));
+
+    if (RSTRING(str)->len > LIBNET_ETH_H) {
+        payload = rb_str_new(RSTRING(str)->ptr + LIBNET_ETH_H,
+                RSTRING(str)->len - LIBNET_ETH_H);
+    }
+    else {
+        payload = Qnil;
+    }
+
+    //rb_iv_set(eth_obj, "@payload", payload);
+    rb_funcall(eth_obj, rb_intern("payload="), 1, payload);
+
+    return eth_obj;
+}
+
+static VALUE net_build_ethernet(int argc, VALUE *argv, VALUE self)
+{
+    libnet_t      *l;
+    VALUE          eth, v;
+    u_int8_t      *dst = NULL;
+    u_int8_t      *src = NULL;
+    u_int16_t      type;
+    char          *payload = NULL;
+    u_int32_t      payload_s = 0;
+    VALUE          ptag_obj;
+    libnet_ptag_t  ptag = 0;
+
+    rb_scan_args(argc, argv, "01", &eth);
+
+    Data_Get_Struct(self, libnet_t, l);
+
+    if (NIL_P(eth)) {
+        eth = rb_class_new_instance(0, NULL, rb_const_get(cLibnet, rb_intern("Ethernet")));
+        rb_yield(eth);
+    }
+
+    /* check that all required fields are set */
+    rb_funcall(eth, rb_intern("check_packable"), 0);
+
+    /* required parameters */
+    v    = rb_funcall(eth, rb_intern("dst"), 0);
+    dst  = (u_int8_t *)StringValuePtr(v);
+    v    = rb_funcall(eth, rb_intern("type"), 0);
+    type = NUM2UINT(v);
+
+    /* optional parameters */
+    v   = rb_funcall(eth, rb_intern("src"), 0);
+    src = (u_int8_t *)StringValuePtr(v);
+
+    if ((v = rb_funcall(eth, rb_intern("payload"), 0)) != Qnil) {
+        v         = StringValue(v);
+        payload   = RSTRING(v)->ptr;
+        payload_s = RSTRING(v)->len;
+    }
+
+    ptag_obj = rb_iv_get(eth, "@ptag");
+
+    if (!NIL_P(ptag_obj)) {
+        ptag = NUM2LONG(ptag_obj);
+    }
+
+    ptag = libnet_build_ethernet(dst, src, type, (u_int8_t *)payload,
+        payload_s, l, ptag);
+
+    if (ptag == -1) {
+        rb_raise(rb_eRuntimeError, libnet_geterror(l));
+    }
+
+    rb_iv_set(eth, "@ptag", LONG2NUM(ptag));
+
+    return eth;
+}
+
+void define_ethernet_methods()
+{
+    VALUE cEthernet = rb_const_get(cLibnet, rb_intern("Ethernet"));
+
+    rb_define_singleton_method(cEthernet, "decode", net_s_decode_ethernet, 1);
+
+    rb_define_method(cLibnet, "build_ethernet", net_build_ethernet, -1);
+}

data/ext/libnet_ipv4.c

@@ -0,0 +1,140 @@
+#include <arpa/inet.h>
+#include <ruby.h>
+#include <libnet.h>
+
+extern VALUE cLibnet;
+
+static VALUE net_s_decode_ipv4(VALUE self, VALUE bytes) 
+{
+    VALUE                   ip_obj;
+    VALUE                   str;
+    VALUE                   payload;
+    struct libnet_ipv4_hdr *ip;
+    u_int8_t                ip_hl, ip_v, ip_tos, ip_ttl, ip_p, ip_sum;
+    u_int16_t               ip_len, ip_id, ip_off;
+    u_int32_t               ip_src, ip_dst;
+
+    ip_obj = rb_funcall(self, rb_intern("new"), 0);
+
+    str = StringValue(bytes);
+
+    if (RSTRING(str)->len < LIBNET_IPV4_H) {
+        rb_raise(rb_eArgError, "string is too small to contain an IPv4 header");
+    }
+
+    ip = (struct libnet_ipv4_hdr *)RSTRING(str)->ptr;
+
+    ip_hl  = ip->ip_hl;
+    ip_v   = ip->ip_v;
+    ip_tos = ip->ip_tos;
+    ip_len = ntohs(ip->ip_len);
+    ip_id  = ntohs(ip->ip_id);
+    ip_off = ntohs(ip->ip_off);
+    ip_ttl = ip->ip_ttl;
+    ip_p   = ip->ip_p;
+    ip_sum = ntohs(ip->ip_sum);
+    ip_src = ntohl(ip->ip_src.s_addr);
+    ip_dst = ntohl(ip->ip_dst.s_addr);
+
+    rb_iv_set(ip_obj, "@version",  UINT2NUM(ip_v));
+    rb_iv_set(ip_obj, "@ihl",      UINT2NUM(ip_hl));
+    rb_iv_set(ip_obj, "@tos",      UINT2NUM(ip_tos));
+    rb_iv_set(ip_obj, "@length",   UINT2NUM(ip_len));
+    rb_iv_set(ip_obj, "@id",       UINT2NUM(ip_id));
+    rb_iv_set(ip_obj, "@frag_off", UINT2NUM(ip_off));
+    rb_iv_set(ip_obj, "@ttl",      UINT2NUM(ip_ttl));
+    rb_iv_set(ip_obj, "@protocol", UINT2NUM(ip_p));
+    rb_iv_set(ip_obj, "@checksum", UINT2NUM(ip_sum));
+    rb_iv_set(ip_obj, "@src_ip",   ULONG2NUM(ip_src));
+    rb_iv_set(ip_obj, "@dst_ip",   ULONG2NUM(ip_dst));
+
+    if (RSTRING(str)->len >= ip_len) {
+        payload = rb_str_new(RSTRING(str)->ptr + LIBNET_IPV4_H,
+                ip_len - LIBNET_IPV4_H);
+    }
+    else {
+        payload = Qnil;
+    }
+
+    rb_iv_set(ip_obj, "@payload", payload);
+
+    return ip_obj;
+}
+
+static VALUE net_build_ipv4(int argc, VALUE *argv, VALUE self)
+{
+    libnet_t      *l;
+    VALUE          ipv4, v;
+    u_int8_t       tos = 0, ttl = 0, prot = 0;
+    u_int16_t      len = 0, id = 0, frag = 0, sum = 0;
+    u_int32_t      src = 0, dst = 0;
+    char          *payload = NULL;
+    u_int32_t      payload_s = 0;
+    VALUE          ptag_obj;
+    libnet_ptag_t  ptag = 0;
+
+    rb_scan_args(argc, argv, "01", &ipv4);
+
+    Data_Get_Struct(self, libnet_t, l);
+
+    if (NIL_P(ipv4)) {
+        ipv4 = rb_class_new_instance(0, NULL, rb_const_get(cLibnet, rb_intern("IPv4")));
+        rb_yield(ipv4);
+    }
+
+    /* check that all required fields are set */
+    rb_funcall(ipv4, rb_intern("check_packable"), 0);
+
+    v    = rb_funcall(ipv4, rb_intern("length"), 0);
+    len  = NUM2UINT(v);
+    v    = rb_funcall(ipv4, rb_intern("protocol"), 0);
+    prot = NUM2UINT(v);
+    v    = rb_funcall(ipv4, rb_intern("tos"), 0);
+    tos  = NUM2UINT(v);
+    v    = rb_funcall(ipv4, rb_intern("id"), 0);
+    id   = NUM2UINT(v);
+    v    = rb_funcall(ipv4, rb_intern("frag_off"), 0);
+    frag = NUM2UINT(v);
+    v    = rb_funcall(ipv4, rb_intern("ttl"), 0);
+    ttl  = NUM2UINT(v);
+    v    = rb_funcall(ipv4, rb_intern("checksum"), 0);
+    sum  = NUM2UINT(v);
+    v    = rb_funcall(ipv4, rb_intern("src_ip"), 0);
+    src  = htonl(NUM2ULONG(v));
+    v    = rb_funcall(ipv4, rb_intern("dst_ip"), 0);
+    dst  = htonl(NUM2ULONG(v));
+
+    /* payload is optional */
+    if ((v = rb_funcall(ipv4, rb_intern("payload"), 0)) != Qnil) {
+        v         = StringValue(v);
+        payload   = RSTRING(v)->ptr;
+        payload_s = RSTRING(v)->len;
+    }
+
+    ptag_obj = rb_iv_get(ipv4, "@ptag");
+
+    if (!NIL_P(ptag_obj)) {
+        ptag = NUM2LONG(ptag_obj);
+    }
+
+    ptag = libnet_build_ipv4(len, tos, id, frag, ttl, prot, sum, src, dst,
+            (u_int8_t *)payload, payload_s, l, ptag);
+
+    if (ptag == -1) {
+        rb_raise(rb_eRuntimeError, libnet_geterror(l));
+    }
+
+    rb_iv_set(ipv4, "@ptag", LONG2NUM(ptag));
+
+    return ipv4;
+}
+
+void define_ipv4_methods()
+{
+    VALUE cIPv4 = rb_const_get(cLibnet, rb_intern("IPv4"));
+
+    rb_define_singleton_method(cIPv4, "decode", net_s_decode_ipv4, 1);
+
+    rb_define_method(cLibnet, "build_ipv4",     net_build_ipv4, -1);
+    //rb_define_method(cLibnet, "autobuild_ipv4", net_autobuild_ipv4, 0);
+}

data/ext/libnet_ipv6.c

@@ -0,0 +1,138 @@
+#include <arpa/inet.h>
+#include <ruby.h>
+#include <libnet.h>
+
+extern VALUE cLibnet;
+
+static VALUE net_s_decode_ipv6(VALUE self, VALUE bytes) 
+{
+    VALUE                   ip_obj;
+    VALUE                   str;
+    VALUE                   payload;
+    struct libnet_ipv6_hdr *ip;
+    u_int8_t                ip_v, ip_tc;
+    u_int32_t               ip_fl;
+    u_int16_t               ip_len;
+    u_int8_t                ip_nh;
+    u_int8_t                ip_hl;
+
+    ip_obj = rb_funcall(self, rb_intern("new"), 0);
+
+    str = StringValue(bytes);
+
+    if (RSTRING(str)->len < LIBNET_IPV6_H) {
+        rb_raise(rb_eArgError, "string is too small to contain an IPv6 header");
+    }
+
+    ip = (struct libnet_ipv6_hdr *)RSTRING(str)->ptr;
+
+    ip_v   = (ip->ip_flags[0] & 0xf0) >> 4;
+    ip_tc  = (ip->ip_flags[0] & 0x0f) << 4;
+    ip_tc |= (ip->ip_flags[1] & 0xf0) >> 4;
+    ip_fl  = (ip->ip_flags[1] & 0x0f) << 16;
+    ip_fl |= (ip->ip_flags[2]) << 8;
+    ip_fl |= (ip->ip_flags[3]);
+    ip_len = ntohs(ip->ip_len);
+    ip_nh  = ip->ip_nh;
+    ip_hl  = ip->ip_hl;
+
+    rb_iv_set(ip_obj, "@version",       UINT2NUM(ip_v));
+    rb_iv_set(ip_obj, "@traffic_class", UINT2NUM(ip_tc));
+    rb_iv_set(ip_obj, "@flow_label",    ULONG2NUM(ip_fl));
+    rb_iv_set(ip_obj, "@length",        UINT2NUM(ip_len));
+    rb_iv_set(ip_obj, "@next_header",   UINT2NUM(ip_nh));
+    rb_iv_set(ip_obj, "@hop_limit",     UINT2NUM(ip_hl));
+    rb_iv_set(ip_obj, "@src_ip",        rb_str_new((u_int8_t *)&ip->ip_src,
+                sizeof(ip->ip_src)));
+    rb_iv_set(ip_obj, "@dst_ip",        rb_str_new((u_int8_t *)&ip->ip_dst,
+                sizeof(ip->ip_dst)));
+
+    if (RSTRING(str)->len >= LIBNET_IPV6_H + ip_len) {
+        payload = rb_str_new(RSTRING(str)->ptr + LIBNET_IPV6_H,
+                ip_len);
+    }
+    else {
+        payload = Qnil;
+    }
+
+    rb_iv_set(ip_obj, "@payload", payload);
+
+    return ip_obj;
+}
+
+static VALUE net_build_ipv6(int argc, VALUE *argv, VALUE self)
+{
+    libnet_t               *l;
+    VALUE                   ipv6, v;
+    u_int8_t                tc, nh, hl;
+    u_int16_t               len;
+    u_int32_t               fl;
+    struct libnet_in6_addr  src, dst;
+    u_int8_t               *payload = NULL;
+    u_int32_t               payload_s = 0;
+    VALUE                   ptag_obj;
+    libnet_ptag_t           ptag = 0;
+
+    rb_scan_args(argc, argv, "01", &ipv6);
+
+    Data_Get_Struct(self, libnet_t, l);
+
+    if (NIL_P(ipv6)) {
+        ipv6 = rb_class_new_instance(0, NULL, rb_const_get(cLibnet, rb_intern("IPv6")));
+        rb_yield(ipv6);
+    }
+
+    /* check that all required fields are set */
+    rb_funcall(ipv6, rb_intern("check_packable"), 0);
+
+    v    = rb_funcall(ipv6, rb_intern("traffic_class"), 0);
+    tc   = NUM2UINT(v);
+    v    = rb_funcall(ipv6, rb_intern("flow_label"), 0);
+    fl   = NUM2ULONG(v);
+    v    = rb_funcall(ipv6, rb_intern("length"), 0);
+    len  = NUM2ULONG(v);
+    v    = rb_funcall(ipv6, rb_intern("next_header"), 0);
+    nh   = NUM2ULONG(v);
+    v    = rb_funcall(ipv6, rb_intern("hop_limit"), 0);
+    hl   = NUM2ULONG(v);
+    v    = rb_funcall(ipv6, rb_intern("src_ip"), 0);
+    v    = StringValue(v);
+    memcpy(&src, RSTRING(v)->ptr, sizeof(src)); 
+    v    = rb_funcall(ipv6, rb_intern("dst_ip"), 0);
+    v    = StringValue(v);
+    memcpy(&dst, RSTRING(v)->ptr, sizeof(dst)); 
+
+    /* payload is optional */
+    if ((v = rb_funcall(ipv6, rb_intern("payload"), 0)) != Qnil) {
+        v         = StringValue(v);
+        payload   = RSTRING(v)->ptr;
+        payload_s = RSTRING(v)->len;
+    }
+
+    ptag_obj = rb_iv_get(ipv6, "@ptag");
+
+    if (!NIL_P(ptag_obj)) {
+        ptag = NUM2LONG(ptag_obj);
+    }
+
+    ptag = libnet_build_ipv6(tc, fl, len, nh, hl, src, dst, (u_int8_t *)payload,
+            payload_s, l, ptag);
+
+    if (ptag == -1) {
+        rb_raise(rb_eRuntimeError, libnet_geterror(l));
+    }
+
+    rb_iv_set(ipv6, "@ptag", LONG2NUM(ptag));
+
+    return ipv6;
+}
+
+void define_ipv6_methods()
+{
+    VALUE cIPv6 = rb_const_get(cLibnet, rb_intern("IPv6"));
+
+    rb_define_singleton_method(cIPv6, "decode", net_s_decode_ipv6, 1);
+
+    rb_define_method(cLibnet, "build_ipv6", net_build_ipv6, -1);
+}
+

data/ext/libnet_udp.c

@@ -0,0 +1,112 @@
+#include <arpa/inet.h>
+#include <ruby.h>
+#include <libnet.h>
+
+extern VALUE cLibnet;
+
+static VALUE net_s_decode_udp(VALUE self, VALUE bytes) 
+{
+    VALUE                  udp_obj;
+    VALUE                  str;
+    VALUE                  payload;
+    struct libnet_udp_hdr *udp;
+    u_int16_t              uh_sport, uh_dport, uh_ulen, uh_sum;
+
+    udp_obj = rb_funcall(self, rb_intern("new"), 0);
+
+    str = StringValue(bytes);
+
+    if (RSTRING(str)->len < LIBNET_UDP_H) {
+        rb_raise(rb_eArgError, "string is too small to contain an UDP header");
+    }
+
+    udp = (struct libnet_udp_hdr *)RSTRING(str)->ptr;
+
+    uh_sport = ntohs(udp->uh_sport);
+    uh_dport = ntohs(udp->uh_dport);
+    uh_ulen  = ntohs(udp->uh_ulen);
+    uh_sum   = ntohs(udp->uh_sum);
+
+    rb_iv_set(udp_obj, "@src_port", UINT2NUM(uh_sport));
+    rb_iv_set(udp_obj, "@dst_port", UINT2NUM(uh_dport));
+    rb_iv_set(udp_obj, "@length",   UINT2NUM(uh_ulen));
+    rb_iv_set(udp_obj, "@checksum", UINT2NUM(uh_sum));
+
+    if (RSTRING(str)->len >= uh_ulen) {
+        payload = rb_str_new(RSTRING(str)->ptr + LIBNET_UDP_H,
+                uh_ulen - LIBNET_UDP_H);
+    }
+    else {
+        payload = Qnil;
+    }
+
+    rb_iv_set(udp_obj, "@payload", payload);
+
+    return udp_obj;
+}
+
+static VALUE net_build_udp(int argc, VALUE *argv, VALUE self)
+{
+    libnet_t      *l;
+    VALUE          udp, v;
+    u_int16_t      sp, dp, len, sum;
+    char          *payload   = NULL;
+    u_int32_t      payload_s = 0;
+    VALUE          ptag_obj;
+    libnet_ptag_t  ptag = 0;
+
+    rb_scan_args(argc, argv, "01", &udp);
+
+    Data_Get_Struct(self, libnet_t, l);
+
+    if (NIL_P(udp)) {
+        udp = rb_class_new_instance(0, NULL, rb_const_get(cLibnet, rb_intern("UDP")));
+        rb_yield(udp);
+    }
+
+    /* check that all required fields are set */
+    rb_funcall(udp, rb_intern("check_packable"), 0);
+
+    v   = rb_funcall(udp, rb_intern("src_port"), 0);
+    sp  = NUM2UINT(v);
+    v   = rb_funcall(udp, rb_intern("dst_port"), 0);
+    dp  = NUM2UINT(v);
+    v   = rb_funcall(udp, rb_intern("length"), 0);
+    len = NUM2UINT(v);
+    v   = rb_funcall(udp, rb_intern("checksum"), 0);
+    sum = NUM2UINT(v);
+
+    /* get the payload */
+    if ((v = rb_funcall(udp, rb_intern("payload"), 0)) != Qnil) {
+        v         = StringValue(v);
+        payload   = RSTRING(v)->ptr;
+        payload_s = RSTRING(v)->len;
+    }
+
+    ptag_obj = rb_iv_get(udp, "@ptag");
+
+    if (!NIL_P(ptag_obj)) {
+        ptag = NUM2LONG(ptag_obj);
+    }
+
+    ptag = libnet_build_udp(sp, dp, len, sum, (u_int8_t *)payload,
+        payload_s, l, ptag);
+
+    if (ptag == -1) {
+        rb_raise(rb_eRuntimeError, libnet_geterror(l));
+    }
+
+    rb_iv_set(udp, "@ptag", LONG2NUM(ptag));
+
+    return udp;
+}
+
+void define_udp_methods()
+{
+    VALUE cUDP = rb_const_get(cLibnet, rb_intern("UDP"));
+
+    rb_define_singleton_method(cUDP, "decode", net_s_decode_udp, 1);
+
+    rb_define_method(cLibnet, "build_udp", net_build_udp, -1);
+}
+