ruby-pcap 0.7.9 → 0.8.1

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);
+
+
 }

data/ext/pcap/udp_packet.c

@@ -78,6 +78,250 @@ udpp_data(self)
     return rb_str_new(UDP_DATA(pkt), len);
 }
 
+static VALUE
+udpp_csum_update(self)
+     VALUE self;
+{
+    struct packet_object *pkt;
+    struct ip *ip;
+    struct udphdr *udp;
+    GetPacket(self, pkt);
+    ip = IP_HDR(pkt);
+    udp = UDP_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 uh_sum = ntohs(udp->uh_sum);
+    unsigned short answer = 0;
+    unsigned short *temp = (unsigned short *)udp;
+    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 += 17;
+    sum += len;
+    // set checksum to zero and sum
+    udp->uh_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);
+
+    answer = ~sum;
+    if (answer == 0)
+      answer = ~answer;
+    /* 
+     * set checkum in packet
+     */
+    udp->uh_sum = htons(answer);
+    /* 
+     * no change, return nil
+     */
+    if (answer == uh_sum)
+      return Qnil;
+    /* 
+     * return new checkum
+     */
+    return UINT2NUM(answer);
+}
+
+/*
+  Set UDP source port and update checksum
+*/
+static VALUE
+udpp_sport_set(self, val)
+     VALUE self, val;
+{
+    struct packet_object *pkt;
+    struct udphdr *udp;
+    long sum = 0;
+    GetPacket(self, pkt);
+    udp = UDP_HDR(pkt);
+    /*
+     * https://tools.ietf.org/html/rfc1624
+     * HC' = ~(C + (-m) + m')
+    */
+    sum = ~(~ntohs(udp->uh_sum) - ntohs(udp->uh_sport) + NUM2USHORT(val));
+    while(sum>>16)
+      sum = (sum & 0xFFFF) + (sum >> 16);
+    /*
+     * set desired value and new checksum
+    */
+    udp->uh_sport = htons(NUM2USHORT(val));
+    udp->uh_sum = htons(sum);
+    return val;
+}
+/*
+  Set UDP destination port and update checksum
+*/
+static VALUE
+udpp_dport_set(self, val)
+     VALUE self, val;
+{
+    struct packet_object *pkt;
+    struct udphdr *udp;
+    long sum = 0;
+    GetPacket(self, pkt);
+    udp = UDP_HDR(pkt);
+    /*
+     * https://tools.ietf.org/html/rfc1624
+     * HC' = ~(C + (-m) + m')
+    */
+    sum = ~(~ntohs(udp->uh_sum) - ntohs(udp->uh_dport) + NUM2USHORT(val));
+    while(sum>>16)
+      sum = (sum & 0xFFFF) + (sum >> 16);
+    /*
+     * set desired value and new checksum
+    */
+    udp->uh_dport = htons(NUM2USHORT(val));
+    udp->uh_sum = htons(sum);
+    return val;
+}
+/*
+ * IPv6 Specific methods
+ */
+VALUE cUDPv6Packet;
+
+VALUE
+setup_udpv6_packet(pkt, tl_len)
+    struct packet_object *pkt;
+    int tl_len;
+{
+    VALUE class;
+    DEBUG_PRINT("setup_udpv6_packet");
+    class = cUDPv6Packet;
+    if (tl_len > 8) {
+      int hl = 8;
+      int layer5_len;
+
+      tl_len = MIN(tl_len, UDP_LENGTH(pkt));
+      layer5_len = tl_len - hl;
+      if (layer5_len > 0) {
+        pkt->hdr.layer5_off = pkt->hdr.layer4_off + hl;
+        /* upper layer */
+        }
+    }
+    return class;
+}
+
+static VALUE
+udpp_csumokv6(self)
+  VALUE self;
+{
+    struct packet_object *pkt;
+    struct ip6_hdr *ip;
+    struct udphdr *udp;
+    GetPacket(self, pkt);
+    ip = IPV6_HDR(pkt);
+    udp = UDP_HDR(pkt);
+    unsigned short *ip_src = (void *)&ip->ip6_src.s6_addr;
+    unsigned short *ip_dst = (void *)&ip->ip6_dst.s6_addr;
+    long sum = 0;
+    unsigned short answer = 0;
+    unsigned short *temp = (unsigned short *)udp;
+    int len = ntohs(ip->ip6_plen); // length of ip data
+    unsigned short csum = ntohs(udp->uh_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 += 0x11; // UDP
+    sum += len;
+    // set checksum to zero and sum
+    udp->uh_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);
+      answer = ~sum;
+    if (answer == 0)
+      answer = ~answer;
+    udp->uh_sum = htons(csum); //restore the checkum in packet
+    if (DEBUG_CHECKSUM)
+      printf("UDP csum in packet:%d should be %d\n", csum, answer);
+    if (answer == csum)
+      return Qtrue;
+    return Qfalse;
+}
+
+static VALUE
+udpp_csumok(self)
+     VALUE self;
+{
+    struct packet_object *pkt;
+    struct ip *ip;
+    struct udphdr *udp;
+    GetPacket(self, pkt);
+    ip = IP_HDR(pkt);
+    udp = UDP_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 answer = 0;
+    unsigned short *temp = (unsigned short *)udp;
+    int len = ntohs(ip->ip_len) - ip->ip_hl*4; // length of ip data
+    int csum = ntohs(udp->uh_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 += 17;
+    sum += len;
+    // set checksum to zero and sum
+    udp->uh_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);
+
+    answer = ~sum;
+    if (answer == 0)
+      answer = ~answer;
+    udp->uh_sum = csum; //restore the checkum in packet
+    if (DEBUG_CHECKSUM)
+      printf("UDP csum in packet:%d should be %d\n", csum, answer);
+    if (answer == csum)
+      return Qtrue;
+    return Qfalse;
+}
+static VALUE
+udpp_truncated(self)
+     VALUE self;
+{
+    struct packet_object *pkt;
+    struct ip *ip;
+    struct udphdr *udp;
+    GetPacket(self, pkt);
+    ip = IP_HDR(pkt);
+    udp = UDP_HDR(pkt);
+    if IsTruncated(pkt, pkt->hdr.layer3_off, ip->ip_hl * 4 + ntohs(udp->uh_ulen))
+        return Qtrue;
+    return Qfalse;
+}
+
 void
 Init_udp_packet(void)
 {
@@ -85,12 +329,29 @@ Init_udp_packet(void)
 
     /* define class UdpPacket */
     cUDPPacket = rb_define_class_under(mPcap, "UDPPacket", cIPPacket);
-
+    cUDPv6Packet = rb_define_class_under(mPcap, "UDPv6Packet", cIPv6Packet);
+    /* define methods under IPv4 */
     rb_define_method(cUDPPacket, "udp_sport", udpp_sport, 0);
+    rb_define_method(cUDPPacket, "udp_sport=", udpp_sport_set, 1);
     rb_define_method(cUDPPacket, "sport", udpp_sport, 0);
+    rb_define_method(cUDPPacket, "sport=", udpp_sport_set, 1);
     rb_define_method(cUDPPacket, "udp_dport", udpp_dport, 0);
+    rb_define_method(cUDPPacket, "udp_dport=", udpp_dport_set, 1);
     rb_define_method(cUDPPacket, "dport", udpp_dport, 0);
+    rb_define_method(cUDPPacket, "dport=", udpp_dport_set, 1);
     rb_define_method(cUDPPacket, "udp_len", udpp_len, 0);
     rb_define_method(cUDPPacket, "udp_sum", udpp_sum, 0);
     rb_define_method(cUDPPacket, "udp_data", udpp_data, 0);
+    rb_define_method(cUDPPacket, "udp_csum_ok?", udpp_csumok, 0);
+    rb_define_method(cUDPPacket, "udp_truncated?", udpp_truncated, 0);
+    rb_define_method(cUDPPacket, "udp_csum_update!", udpp_csum_update, 0);
+    /* define methods under IPv6 */
+    rb_define_method(cUDPv6Packet, "udp_sport", udpp_sport, 0);
+    rb_define_method(cUDPv6Packet, "sport", udpp_sport, 0);
+    rb_define_method(cUDPv6Packet, "udp_dport", udpp_dport, 0);
+    rb_define_method(cUDPv6Packet, "dport", udpp_dport, 0);
+    rb_define_method(cUDPv6Packet, "udp_len", udpp_len, 0);
+    rb_define_method(cUDPv6Packet, "udp_sum", udpp_sum, 0);
+    rb_define_method(cUDPv6Packet, "udp_data", udpp_data, 0);
+    rb_define_method(cUDPv6Packet, "udp_csum_ok?", udpp_csumokv6, 0);
 }