ruby-pcap 0.7.9 → 0.8.0

data/ext/pcap/packet.c

@@ -11,7 +11,17 @@
 #include <sys/socket.h>
 #include <net/if.h>
 #include <netinet/if_ether.h>
+#ifndef ETH_P_IPV6
+#define ETH_P_IPV6 0x86DD /* IPv6 packet */
+#endif
+
+#ifndef ETH_P_SLOW
+#define ETH_P_SLOW 0x8809 /* Slow Protocol frame */
+#endif
 
+#ifndef ETH_P_ARP
+#define ETH_P_ARP	0x0806		/* Address Resolution packet	*/
+#endif
 #define DL_HDR(pkt)     ((u_char *)LAYER2_HDR(pkt))
 #define DL_DATA(pkt)    ((u_char *)LAYER3_HDR(pkt))
 
@@ -125,14 +135,18 @@ new_packet(data, pkthdr, dl_type)
         case ETHERTYPE_IP:
             class = setup_ip_packet(pkt, nl_len);
             break;
+        case ETH_P_IPV6:
+            class = setup_ipv6_packet(pkt, nl_len);
+            break;
+        case ETH_P_ARP:
+            class = setup_arp_packet(pkt, nl_len);
+            break;
+        case ETH_P_SLOW:
+            class = setup_slow_protocol_packet(pkt, nl_len);
+            break;
         }
     }
-#if DEBUG
-    if (ruby_debug && TYPE(class) != T_CLASS) {
-        rb_fatal("not class");
-    }
-#endif
-    return Data_Wrap_Struct(class, mark_packet, free_packet, pkt);
+  return Data_Wrap_Struct(class, mark_packet, free_packet, pkt);
 }
 
 static VALUE
@@ -282,14 +296,18 @@ static VALUE\
 PACKET_METHOD(packet_get_udata, pkt->udata);
 PACKET_METHOD(packet_datalink, INT2FIX(pkt->hdr.dl_type));
 PACKET_METHOD(packet_ip, rb_obj_is_kind_of(self, cIPPacket));
-PACKET_METHOD(packet_tcp, rb_obj_is_kind_of(self, cTCPPacket));
-PACKET_METHOD(packet_udp, rb_obj_is_kind_of(self, cUDPPacket));
+PACKET_METHOD(packet_ipv6, rb_obj_is_kind_of(self, cIPv6Packet));
+PACKET_METHOD(packet_tcp, rb_obj_is_kind_of(self, cTCPPacket) | rb_obj_is_kind_of(self, cTCPv6Packet));
+PACKET_METHOD(packet_udp, rb_obj_is_kind_of(self, cUDPPacket) | rb_obj_is_kind_of(self, cUDPv6Packet));
 PACKET_METHOD(packet_length, UINT32_2_NUM(pkt->hdr.pkthdr.len));
 PACKET_METHOD(packet_caplen, UINT32_2_NUM(pkt->hdr.pkthdr.caplen));
 PACKET_METHOD(packet_time, rb_time_new(pkt->hdr.pkthdr.ts.tv_sec,
                                        pkt->hdr.pkthdr.ts.tv_usec));
 PACKET_METHOD(packet_time_i, rb_int2inum(pkt->hdr.pkthdr.ts.tv_sec));
 PACKET_METHOD(packet_raw_data, rb_str_new(pkt->data, pkt->hdr.pkthdr.caplen));
+PACKET_METHOD(packet_arp, rb_obj_is_kind_of(self, cARPPacket));
+PACKET_METHOD(packet_lacp, rb_obj_is_kind_of(self, cLACPPacket));
+
 
 void
 Init_packet(void)
@@ -308,9 +326,12 @@ Init_packet(void)
     rb_define_method(cPacket, "udata", packet_get_udata, 0);
     rb_define_method(cPacket, "udata=", packet_set_udata, 1);
     rb_define_method(cPacket, "datalink", packet_datalink, 0);
+    rb_define_method(cPacket, "arp?", packet_arp, 0);
     rb_define_method(cPacket, "ip?", packet_ip, 0);
+    rb_define_method(cPacket, "ipv6?", packet_ipv6, 0);
     rb_define_method(cPacket, "tcp?", packet_tcp, 0);
     rb_define_method(cPacket, "udp?", packet_udp, 0);
+    rb_define_method(cPacket, "lacp?", packet_lacp, 0);
     rb_define_method(cPacket, "length", packet_length, 0);
     rb_define_method(cPacket, "size", packet_length, 0);
     rb_define_method(cPacket, "caplen", packet_caplen, 0);
@@ -325,4 +346,11 @@ Init_packet(void)
     id_load = rb_intern("load");
     id_dump = rb_intern("dump");
     Init_ip_packet();
+    Init_arp_packet();
+    Init_ipv6_packet();
+    Init_tcp_packet();
+    Init_udp_packet();
+    Init_icmp_packet();
+    Init_icmpv6_packet();
+    Init_sp_packet();
 }

data/ext/pcap/ruby_pcap.h

@@ -15,6 +15,8 @@
 #include <netinet/in.h>
 #include <netinet/in_systm.h>
 #include <netinet/ip.h>
+#include <netinet/ip6.h>
+#include <netinet/icmp6.h>
 #include <arpa/inet.h>
 #ifndef IP_OFFMASK
 # define IP_OFFMASK 0x1fff
@@ -29,10 +31,7 @@
 #include <netdb.h>
 
 #ifdef DEBUG
-# define DEBUG_PRINT(x) do {\
-    ((RTEST(ruby_debug) && RTEST(ruby_verbose))?\
-    (fprintf(stderr, "%s\n", x),fflush(stderr)) : 0)\
-} while (0)
+# define DEBUG_PRINT(x) fprintf(stderr, "%s\n", x),fflush(stderr)
 #else
 # define DEBUG_PRINT(x) do {} while (0)
 #endif
@@ -89,11 +88,16 @@ struct packet_object {
         rb_raise(eTruncatedPacket, (emsg)) : 0 \
 )
 
+#define IsTruncated(pkt, from, need) (\
+    (from) + (need) > (pkt)->hdr.pkthdr.caplen ? \
+        1 : 0 \
+)
 #define IsKindOf(v, class) RTEST(rb_obj_is_kind_of(v, class))
 #define CheckClass(v, class) ((IsKindOf(v, class)) ? 0 :\
     rb_raise(rb_eTypeError, "wrong type %s (expected %s)",\
         rb_class2name(CLASS_OF(v)), rb_class2name(class)))
 
+#define DEBUG_CHECKSUM 0
 
 /* Pcap.c */
 extern VALUE mPcap, rbpcap_convert;
@@ -118,17 +122,43 @@ VALUE new_ipaddr(struct in_addr *);
 
 /* tcp_packet.c */
 extern VALUE cTCPPacket;
+extern VALUE cTCPv6Packet;
 void Init_tcp_packet(void);
 VALUE setup_tcp_packet(struct packet_object *, int);
+VALUE setup_tcpv6_packet(struct packet_object *, int);
+
+/* ipv6_packet.c */
+#define IPV6_HDR(pkt)     ((struct ip6_hdr *)LAYER3_HDR(pkt))
+#define IPV6_HDR_OBJ(self) ((struct ip6_hdr *)LAYER3_HDR((struct packet_object *)DATA_PTR(self)))
+extern VALUE cIPv6Packet;
+void Init_ipv6_packet(void);
+VALUE setup_ipv6_packet(struct packet_object *, int);
 
 /* udp_packet.c */
 extern VALUE cUDPPacket;
+extern VALUE cUDPv6Packet;
 void Init_udp_packet(void);
 VALUE setup_udp_packet(struct packet_object *, int);
+VALUE setup_udpv6_packet(struct packet_object *, int);
 
 /* icmp_packet.c */
 extern VALUE cICMPPacket;
+extern VALUE cICMPv6Packet;
 void Init_icmp_packet(void);
+void Init_icmpv6_packet(void);
 VALUE setup_icmp_packet(struct packet_object *, int);
+VALUE setup_icmpv6_packet(struct packet_object *);
 
+
+/* arp_packet.c */
+extern VALUE cARPPacket;
+void Init_arp_packet(void);
+VALUE setup_arp_packet(struct packet_object *, int);
+
+/* slow_protocol_packet.c */
+extern VALUE cSPPacket;
+extern VALUE cLACPPacket;
+void Init_sp_packet(void);
+VALUE setup_slow_protocol_packet(struct packet_object *, int);
 #endif /* RUBY_PCAP_H */
+

data/ext/pcap/slow_protocol_packet.c

@@ -0,0 +1,29 @@
+#include "ruby_pcap.h"
+
+VALUE cSPPacket;
+VALUE cLACPPacket;
+
+VALUE
+setup_slow_protocol_packet(pkt, nl_len)
+  struct packet_object *pkt;
+  int nl_len;
+{
+  VALUE class;
+
+  DEBUG_PRINT("setup_slow_protocol_packet");
+  if (pkt->data[14] == 0x01) {
+    class = cLACPPacket;
+  } else {
+    class = cSPPacket;
+  }
+  return class;
+}
+
+void
+Init_sp_packet(void)
+{
+    DEBUG_PRINT("Init_sp_packet");
+
+    cSPPacket = rb_define_class_under(mPcap, "SPPacket", cPacket);
+    cLACPPacket = rb_define_class_under(mPcap, "LACPPacket", cSPPacket);
+}

data/ext/pcap/tcp_packet.c

@@ -14,10 +14,12 @@
 #define TCP_DATALEN(pkt) (ntohs(IP_HDR(pkt)->ip_len) - \
     (IP_HDR(pkt)->ip_hl + TCP_HDR(pkt)->th_off) * 4)
 
+#define TCP_OPTIONS(pkt)  ((u_char *) &TCP_HDR(pkt)->th_urp + 2)
+#define TCP_OPTIONS_LEN(pkt) (((TCP_HDR(pkt)->th_off) * 4) - 20)
+
 VALUE cTCPPacket;
 
-#define CheckTruncateTcp(pkt, need) \
-    CheckTruncate(pkt, pkt->hdr.layer4_off, need, "truncated TCP")
+#define CheckTruncateTcp(pkt, need) CheckTruncate(pkt, pkt->hdr.layer4_off, need, "truncated TCP")
 
 VALUE
 setup_tcp_packet(pkt, tl_len)
@@ -64,8 +66,8 @@ TCPP_METHOD(tcpp_win,    16, INT2FIX(ntohs(tcp->th_win)))
 TCPP_METHOD(tcpp_sum,    18, INT2FIX(ntohs(tcp->th_sum)))
 TCPP_METHOD(tcpp_urp,    20, INT2FIX(ntohs(tcp->th_urp)))
 
-#define TCPP_FLAG(func, flag) \
-    TCPP_METHOD(func, 14, (tcp->th_flags & flag) ? Qtrue : Qfalse)
+#define TCPP_FLAG(func, flag) TCPP_METHOD(func, 14, (tcp->th_flags & flag) ? Qtrue : Qfalse)
+
 TCPP_FLAG(tcpp_fin, TH_FIN)
 TCPP_FLAG(tcpp_syn, TH_SYN)
 TCPP_FLAG(tcpp_rst, TH_RST)
@@ -78,7 +80,6 @@ tcpp_data(self)
      VALUE self;
 {
     struct packet_object *pkt;
-    VALUE v_len;
     int len;
 
     DEBUG_PRINT("tcpp_data");
@@ -91,6 +92,308 @@ tcpp_data(self)
     return rb_str_new(TCP_DATA(pkt), len);
 }
 
+static VALUE
+tcpp_options(self)
+     VALUE self;
+{
+    struct packet_object *pkt;
+    int len;
+
+    DEBUG_PRINT("tcpp_options");
+    GetPacket(self, pkt);
+    len = TCP_OPTIONS_LEN(pkt);
+    if (len < 1 ) return Qnil;
+    return rb_str_new(TCP_OPTIONS(pkt), len);
+}
+
+static VALUE
+tcpp_csumok(self)
+     VALUE self;
+{
+    struct packet_object *pkt;
+    struct ip *ip;
+    struct tcphdr *tcp;
+    GetPacket(self, pkt);
+    ip = IP_HDR(pkt);
+    tcp = TCP_HDR(pkt);
+    unsigned short *ip_src = (void *)&ip->ip_src.s_addr;
+    unsigned short *ip_dst = (void *)&ip->ip_dst.s_addr;
+    long sum = 0;
+    unsigned short *temp = (unsigned short *)tcp;
+    int len = ntohs(ip->ip_len) - ip->ip_hl*4; // length of ip data
+    unsigned short csum = ntohs(tcp->th_sum); // keep the checksum in packet
+
+    // pseudo header sum
+    sum += ntohs(*(ip_src++));
+    sum += ntohs(*ip_src);
+    sum += ntohs(*(ip_dst++));
+    sum += ntohs(*ip_dst);
+    sum += 6;
+    sum += len;
+    // set checksum to zero and sum
+    tcp->th_sum = 0;
+    while(len > 1){
+      sum += ntohs(*temp++);
+      len -= 2;
+    }
+    if(len)
+      sum += ntohs((unsigned short) *((unsigned char *)temp));
+    while(sum>>16)
+      sum = (sum & 0xFFFF) + (sum >> 16);
+    unsigned short answer = ~sum;
+
+    tcp->th_sum = htons(csum); //restore the checkum in packet
+    if (DEBUG_CHECKSUM)
+      printf("TCP csum in packet:%d should be %d\n", csum, answer);
+    if (answer == csum)
+      return Qtrue;
+    return Qfalse;
+}
+
+static VALUE
+tcpp_truncated(self)
+     VALUE self;
+{
+    struct packet_object *pkt;
+    struct ip *ip;
+    struct tcphdr *tcp;
+    GetPacket(self, pkt);
+    ip = IP_HDR(pkt);
+    tcp = TCP_HDR(pkt);
+    if IsTruncated(pkt, pkt->hdr.layer3_off, ip->ip_hl * 4 + tcp->th_off * 4)
+        return Qtrue;
+    return Qfalse;
+}
+
+static VALUE
+tcpp_data_len(self)
+     VALUE self;
+{
+    struct packet_object *pkt;
+    GetPacket(self, pkt);
+
+    return INT2FIX(TCP_DATALEN(pkt));
+}
+
+/*
+  Calculate TCP checksum and update it in packet
+*/
+static VALUE
+tcpp_csum_update(self)
+     VALUE self;
+{
+    struct packet_object *pkt;
+    struct ip *ip;
+    struct tcphdr *tcp;
+    GetPacket(self, pkt);
+    ip = IP_HDR(pkt);
+    tcp = TCP_HDR(pkt);
+    unsigned short *ip_src = (void *)&ip->ip_src.s_addr;
+    unsigned short *ip_dst = (void *)&ip->ip_dst.s_addr;
+    long sum = 0;
+    /* save checksum in packet */
+    unsigned short th_sum = ntohs(tcp->th_sum);
+    unsigned short *temp = (unsigned short *)tcp;
+    int len = ntohs(ip->ip_len) - ip->ip_hl*4; // length of ip data
+
+    // pseudo header sum
+    sum += ntohs(*(ip_src++));
+    sum += ntohs(*ip_src);
+    sum += ntohs(*(ip_dst++));
+    sum += ntohs(*ip_dst);
+    sum += 6;
+    sum += len;
+    // set checksum to zero and sum
+    tcp->th_sum = 0;
+    while(len > 1){
+      sum += ntohs(*temp++);
+      len -= 2;
+    }
+    if(len)
+      sum += ntohs((unsigned short) *((unsigned char *)temp));
+    while(sum>>16)
+      sum = (sum & 0xFFFF) + (sum >> 16);
+    unsigned short answer = ~sum;
+    /*
+     * set checkum in packet
+     */
+    tcp->th_sum = htons(answer);
+    /*
+     * no change, return nil
+     */
+    if (answer == th_sum)
+      return Qnil;
+    /*
+     * return new checkum
+     */
+    return UINT2NUM(answer);
+}
+
+/*
+ * Set TCP source port and update checksum
+*/
+static VALUE
+tcpp_sport_set(self, val)
+     VALUE self, val;
+{
+    struct packet_object *pkt;
+    struct tcphdr *tcp;
+    GetPacket(self, pkt);
+    tcp = TCP_HDR(pkt);
+    long sum = 0;
+    /*
+     * https://tools.ietf.org/html/rfc1624
+     * HC' = ~(C + (-m) + m')
+    */
+    sum = ~(~ntohs(tcp->th_sum) - ntohs(tcp->th_sport) + NUM2USHORT(val));
+    while(sum>>16)
+      sum = (sum & 0xFFFF) + (sum >> 16);
+    /*
+     * ttps://tools.ietf.org/html/rfc1624 boundary conditions
+    */
+    if (sum == 0xFFFF)
+      sum = ~sum;
+    /*
+     * set desired value and new checksum
+    */
+    tcp->th_sport = htons(NUM2USHORT(val));
+    tcp->th_sum = htons(sum);
+    return val;
+}
+
+/*
+  Set TCP destination port and update checksum
+*/
+static VALUE
+tcpp_dport_set(self, val)
+     VALUE self, val;
+{
+    struct packet_object *pkt;
+    struct tcphdr *tcp;
+    GetPacket(self, pkt);
+    tcp = TCP_HDR(pkt);
+    long sum = 0;
+    /*
+     * https://tools.ietf.org/html/rfc1624
+     * HC' = ~(C + (-m) + m')
+    */
+    sum = ~(~ntohs(tcp->th_sum) - ntohs(tcp->th_dport) + NUM2USHORT(val));
+    while(sum>>16)
+      sum = (sum & 0xFFFF) + (sum >> 16);
+    /*
+     * ttps://tools.ietf.org/html/rfc1624 boundary conditions
+    */
+    if (sum == 0xFFFF)
+      sum = ~sum;
+    /*
+     * set desired value and new checksum
+    */
+    tcp->th_dport = htons(NUM2USHORT(val));
+    tcp->th_sum = htons(sum);
+    return val;
+}
+
+/*
+ * IPv6 Specific methods
+ */
+
+VALUE cTCPv6Packet;
+
+#define TCPV6_DATALEN(pkt) (ntohs(IPV6_HDR(pkt)->ip6_plen) - TCP_HDR(pkt)->th_off * 4)
+
+VALUE
+setup_tcpv6_packet(pkt, tl_len)
+     struct packet_object *pkt;
+     int tl_len;
+{
+    VALUE class;
+
+    class = cTCPv6Packet;
+    if (tl_len > 20) {
+        int hl = TCP_HDR(pkt)->th_off * 4;
+        int layer5_len = tl_len - hl;
+        if (layer5_len > 0) {
+            pkt->hdr.layer5_off = pkt->hdr.layer4_off + hl;
+            /* upper layer */
+        }
+    }
+    return class;
+}
+
+static VALUE
+tcppv6_data_len(self)
+     VALUE self;
+{
+    struct packet_object *pkt;
+    GetPacket(self, pkt);
+
+    return INT2FIX(TCPV6_DATALEN(pkt));
+}
+
+static VALUE
+tcppv6_data(self)
+     VALUE self;
+{
+    struct packet_object *pkt;
+    int len;
+
+    DEBUG_PRINT("tcppv6_data");
+    GetPacket(self, pkt);
+
+    if (pkt->hdr.layer5_off == OFF_NONEXIST) return Qnil;
+
+    len = MIN(Caplen(pkt, pkt->hdr.layer5_off), TCPV6_DATALEN(pkt));
+    if (len < 1) return Qnil;
+    return rb_str_new(TCP_DATA(pkt), len);
+}
+
+static VALUE
+tcpp_csumokv6(self)
+     VALUE self;
+{
+    struct packet_object *pkt;
+    struct ip6_hdr *ip;
+    struct tcphdr *tcp;
+    GetPacket(self, pkt);
+    ip = IPV6_HDR(pkt);
+    tcp = TCP_HDR(pkt);
+    unsigned short *ip_src = (void *)&ip->ip6_src.s6_addr;
+    unsigned short *ip_dst = (void *)&ip->ip6_dst.s6_addr;
+    unsigned long sum = 0;
+    unsigned short *temp = (unsigned short *)tcp;
+    int len = ntohs(ip->ip6_plen); // length of ip data
+    unsigned short csum = ntohs(tcp->th_sum); // keep the checksum in packet
+
+    // pseudo header sum
+    int i = 1;
+    for (i = 0; i < 8; i++) {
+      sum += ntohs(*(ip_src));
+      sum += ntohs(*(ip_dst));
+      ip_src++;
+      ip_dst++;
+    }
+    sum += 0x6; /* TCP type */
+    sum += len; /* packet length */
+    // set checksum to zero and sum
+    tcp->th_sum = 0;
+    while(len > 1){
+      sum += ntohs(*temp++);
+      len -= 2;
+    }
+    if(len)
+      sum += ntohs((unsigned short) *((unsigned char *)temp));
+    while(sum>>16)
+      sum = (sum & 0xFFFF) + (sum >> 16);
+    unsigned short answer = ~sum;
+
+    tcp->th_sum = htons(csum); //restore the checkum in packet
+    if (DEBUG_CHECKSUM)
+      printf("TCPv6 csum in packet:%d should be %d\n", csum, answer);
+    if (answer == csum)
+      return Qtrue;
+    return Qfalse;
+}
+
 void
 Init_tcp_packet(void)
 {
@@ -98,11 +401,15 @@ Init_tcp_packet(void)
 
     /* define class TcpPacket */
     cTCPPacket = rb_define_class_under(mPcap, "TCPPacket", cIPPacket);
-
+    /* define methods under IPv4 */
     rb_define_method(cTCPPacket, "tcp_sport", tcpp_sport, 0);
+    rb_define_method(cTCPPacket, "tcp_sport=", tcpp_sport_set, 1);
     rb_define_method(cTCPPacket, "sport", tcpp_sport, 0);
+    rb_define_method(cTCPPacket, "sport=", tcpp_sport_set, 1);
     rb_define_method(cTCPPacket, "tcp_dport", tcpp_dport, 0);
+    rb_define_method(cTCPPacket, "tcp_dport=", tcpp_dport_set, 1);
     rb_define_method(cTCPPacket, "dport", tcpp_dport, 0);
+    rb_define_method(cTCPPacket, "dport=", tcpp_dport_set, 1);
     rb_define_method(cTCPPacket, "tcp_seq", tcpp_seq, 0);
     rb_define_method(cTCPPacket, "tcp_ack", tcpp_acknum, 0);
     rb_define_method(cTCPPacket, "tcp_off", tcpp_off, 0);
@@ -118,4 +425,37 @@ Init_tcp_packet(void)
     rb_define_method(cTCPPacket, "tcp_ack?", tcpp_ack, 0);
     rb_define_method(cTCPPacket, "tcp_urg?", tcpp_urg, 0);
     rb_define_method(cTCPPacket, "tcp_data", tcpp_data, 0);
+    rb_define_method(cTCPPacket, "tcp_data_len", tcpp_data_len, 0);
+    rb_define_method(cTCPPacket, "tcp_options", tcpp_options, 0);
+    rb_define_method(cTCPPacket, "tcp_csum_ok?", tcpp_csumok, 0);
+    rb_define_method(cTCPPacket, "tcp_truncated?", tcpp_truncated, 0);
+    rb_define_method(cTCPPacket, "tcp_csum_update!", tcpp_csum_update, 0);
+
+    // IPv6
+    cTCPv6Packet = rb_define_class_under(mPcap, "TCPv6Packet", cIPv6Packet);
+    /* define methods under IPv6 */
+    rb_define_method(cTCPv6Packet, "tcp_sport", tcpp_sport, 0);
+    rb_define_method(cTCPv6Packet, "sport", tcpp_sport, 0);
+    rb_define_method(cTCPv6Packet, "tcp_dport", tcpp_dport, 0);
+    rb_define_method(cTCPv6Packet, "dport", tcpp_dport, 0);
+    rb_define_method(cTCPv6Packet, "tcp_seq", tcpp_seq, 0);
+    rb_define_method(cTCPv6Packet, "tcp_ack", tcpp_acknum, 0);
+    rb_define_method(cTCPv6Packet, "tcp_off", tcpp_off, 0);
+    rb_define_method(cTCPv6Packet, "tcp_hlen", tcpp_off, 0);
+    rb_define_method(cTCPv6Packet, "tcp_flags", tcpp_flags, 0);
+    rb_define_method(cTCPv6Packet, "tcp_win", tcpp_win, 0);
+    rb_define_method(cTCPv6Packet, "tcp_sum", tcpp_sum, 0);
+    rb_define_method(cTCPv6Packet, "tcp_csumok?", tcpp_csumokv6, 0);
+    rb_define_method(cTCPv6Packet, "tcp_urp", tcpp_urp, 0);
+    rb_define_method(cTCPv6Packet, "tcp_fin?", tcpp_fin, 0);
+    rb_define_method(cTCPv6Packet, "tcp_syn?", tcpp_syn, 0);
+    rb_define_method(cTCPv6Packet, "tcp_rst?", tcpp_rst, 0);
+    rb_define_method(cTCPv6Packet, "tcp_psh?", tcpp_psh, 0);
+    rb_define_method(cTCPv6Packet, "tcp_ack?", tcpp_ack, 0);
+    rb_define_method(cTCPv6Packet, "tcp_urg?", tcpp_urg, 0);
+    rb_define_method(cTCPv6Packet, "tcp_data", tcppv6_data, 0);
+    rb_define_method(cTCPv6Packet, "tcp_data_len", tcppv6_data_len, 0);
+    rb_define_method(cTCPv6Packet, "tcp_options", tcpp_options, 0);
+
+
 }