oversip_p 1.0.0

data/ext/utils/outbound_utils.h

@@ -0,0 +1,27 @@
+#ifndef outbound_utils_h
+#define outbound_utils_h
+
+
+#include <sys/types.h>
+
+
+enum enum_outbound_udp_flow_token_ip_type {
+  outbound_udp_flow_token_ip_type_ipv4 = 1,
+  outbound_udp_flow_token_ip_type_ipv6
+};
+
+
+typedef struct struct_outbound_udp_flow_token {
+  unsigned short int                        valid;
+  enum enum_outbound_udp_flow_token_ip_type ip_type;
+  size_t                                    ip_s;
+  size_t                                    ip_len;
+  size_t                                    port_s;
+  size_t                                    port_len;
+} struct_outbound_udp_flow_token;
+
+
+struct_outbound_udp_flow_token outbound_udp_flow_token_parser_execute(const char *str, size_t len);
+
+
+#endif

data/ext/utils/utils_ruby.c

@@ -0,0 +1,392 @@
+#include <ruby.h>
+#include "ext_help.h"
+#include "ip_utils.h"
+#include "utils_ruby.h"
+#include "../common/c_util.h"
+
+
+static VALUE mOverSIP;
+static VALUE mUtils;
+
+static VALUE symbol_ipv4;
+static VALUE symbol_ipv6;
+static VALUE symbol_ipv6_reference;
+
+
+
+/*
+ * Ruby functions.
+ */
+
+VALUE Utils_is_ip(VALUE self, VALUE string)
+{
+  TRACE();
+  char *str;
+  long len;
+
+  if (TYPE(string) != T_STRING)
+    rb_raise(rb_eTypeError, "Argument must be a String");
+
+  str = RSTRING_PTR(string);
+  len = RSTRING_LEN(string);
+
+  if (utils_ip_parser_execute(str, len) != ip_type_error)
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+
+VALUE Utils_is_pure_ip(VALUE self, VALUE string)
+{
+  TRACE();
+  char *str;
+  long len;
+
+  if (TYPE(string) != T_STRING)
+    rb_raise(rb_eTypeError, "Argument must be a String");
+
+  str = RSTRING_PTR(string);
+  len = RSTRING_LEN(string);
+
+  switch(utils_ip_parser_execute(str, len)) {
+    case(ip_type_ipv4):
+      return Qtrue;
+      break;
+    case(ip_type_ipv6):
+      return Qtrue;
+      break;
+    default:
+      return Qfalse;
+      break;
+  }
+}
+
+
+VALUE Utils_ip_type(VALUE self, VALUE string)
+{
+  TRACE();
+  char *str;
+  long len;
+  
+  if (TYPE(string) != T_STRING)
+    rb_raise(rb_eTypeError, "Argument must be a String");
+
+  str = RSTRING_PTR(string);
+  len = RSTRING_LEN(string);
+
+  switch(utils_ip_parser_execute(str, len)) {
+    case(ip_type_ipv4):
+      return symbol_ipv4;
+      break;
+    case(ip_type_ipv6):
+      return symbol_ipv6;
+      break;
+    case(ip_type_ipv6_reference):
+      return symbol_ipv6_reference;
+      break;
+    default:
+      return Qfalse;
+      break;
+  }
+}
+
+
+/*
+ * Returns true if both IP's are equal (binary comparison).
+ * Returns false if both IP's are not equal.
+ * Returns nil if at least one of the IP's is not valid IPv4, IPv6 or IPv6 reference.
+ * This function also allows comparing an IPv6 with an IPv6 reference.
+ */
+VALUE Utils_compare_ips(VALUE self, VALUE string1, VALUE string2)
+{
+  TRACE();
+  char *str1, *str2;
+  long len1, len2;
+  enum enum_ip_type ip1_type, ip2_type;
+
+  if (TYPE(string1) != T_STRING || TYPE(string2) != T_STRING)
+    rb_raise(rb_eTypeError, "Arguments must be two String");
+
+  str1 = RSTRING_PTR(string1);
+  len1 = RSTRING_LEN(string1);
+  str2 = RSTRING_PTR(string2);
+  len2 = RSTRING_LEN(string2);
+
+  switch(ip1_type = utils_ip_parser_execute(str1, len1)) {
+    case(ip_type_error):
+      return Qnil;
+      break;
+    case(ip_type_ipv6_reference):
+      str1 += 1;
+      len1 -= 2;
+      ip1_type = ip_type_ipv6;
+      break;
+    default:
+      break;
+  }
+  switch(ip2_type = utils_ip_parser_execute(str2, len2)) {
+    case(ip_type_error):
+      return Qnil;
+      break;
+    case(ip_type_ipv6_reference):
+      str2 += 1;
+      len2 -= 2;
+      ip2_type = ip_type_ipv6;
+      break;
+    default:
+      break;
+  }
+
+  if (utils_compare_pure_ips(str1, len1, ip1_type, str2, len2, ip2_type))
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+
+/*
+ * Returns true if both IP's are equal (binary comparison).
+ * Returns false if both IP's are not equal.
+ * Returns nil if at least one of the IP's is not valid IPv4 or IPv6.
+ * This function does not allow comparing an IPv6 with an IPv6 reference.
+ */
+VALUE Utils_compare_pure_ips(VALUE self, VALUE string1, VALUE string2)
+{
+  TRACE();
+  char *str1, *str2;
+  long len1, len2;
+  enum enum_ip_type ip1_type, ip2_type;
+
+  if (TYPE(string1) != T_STRING || TYPE(string2) != T_STRING)
+    rb_raise(rb_eTypeError, "Arguments must be two String");
+  
+  str1 = RSTRING_PTR(string1);
+  len1 = RSTRING_LEN(string1);
+  str2 = RSTRING_PTR(string2);
+  len2 = RSTRING_LEN(string2);
+
+  switch(ip1_type = utils_ip_parser_execute(str1, len1)) {
+    case(ip_type_error):
+      return Qnil;
+      break;
+    case(ip_type_ipv6_reference):
+      return Qnil;
+      break;
+    default:
+      break;
+  }
+  switch(ip2_type = utils_ip_parser_execute(str2, len2)) {
+    case(ip_type_error):
+      return Qnil;
+      break;
+    case(ip_type_ipv6_reference):
+      return Qnil;
+      break;
+    default:
+      break;
+  }
+
+  if (utils_compare_pure_ips(str1, len1, ip1_type, str2, len2, ip2_type))
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+
+/*
+ * Returns the normalized printable string of the given IPv6.
+ * - First argument is a string to normalize. It must be a valid IPv6 or
+ *   IPv6 reference. If not, the method returns false.
+ * - Second argument is optional. If true, returned value is a pure IPv6 even
+ *   if the first argument is a IPv6 reference.
+ */
+VALUE Utils_normalize_ipv6(int argc, VALUE *argv, VALUE self)
+{
+  TRACE();
+  VALUE string;
+  int force_pure_ipv6 = 0;
+
+  if (argc == 0 || argc > 2)
+    rb_raise(rb_eTypeError, "Wrong number of arguments (pass one or two)");
+
+  string = argv[0];
+  if (TYPE(string) != T_STRING)
+    rb_raise(rb_eTypeError, "First argument must be a String");
+
+  if (argc == 2 && TYPE(argv[1]) != T_NIL && TYPE(argv[1]) != T_FALSE)
+    force_pure_ipv6 = 1;
+
+  return utils_normalize_ipv6(string, force_pure_ipv6);
+}
+
+
+/*
+ * Returns the normalized printable string of the given IPv4 or IPv6.
+ * - First argument is a string to normalize. It must be a valid IPv4, IPv6 or
+ *   IPv6 reference. If not, the method returns the string itself.
+ * - Second argument is the type of host (:ipv4, :ipv6, :ipv6_reference or :domain).
+ * - Third argument is optional. If true, returned value is a pure IPv6 even
+ *   if the first argument is a IPv6 reference.
+ *
+ * TODO: Not in use and seems really ugly!
+ */
+VALUE Utils_normalize_host(int argc, VALUE *argv, VALUE self)
+{
+  TRACE();
+  VALUE host, ip_type;
+  int force_pure_ipv6 = 0;
+
+  if (argc == 0 || argc > 3)
+    rb_raise(rb_eTypeError, "Wrong number of arguments (pass one, two or three)");
+
+  host = argv[0];
+  if (TYPE(host) != T_STRING)
+    rb_raise(rb_eTypeError, "First argument must be a String");
+
+  ip_type = argv[1];
+  if (TYPE(ip_type) != T_SYMBOL)
+    rb_raise(rb_eTypeError, "Second argument must be a Symbol (:ipv4, :ipv6 or :domain)");
+
+  if (argc == 3 && TYPE(argv[2]) != T_NIL && TYPE(argv[2]) != T_FALSE)
+    force_pure_ipv6 = 1;
+
+  if (ip_type == symbol_ipv6 || ip_type == symbol_ipv6_reference)
+    return utils_normalize_ipv6(host, force_pure_ipv6);
+  else
+    return host;
+}
+
+
+/*
+ * If the given argument is a IPV6 reference it returns a new string with the pure IPv6.
+ * In any other case, return the given argument.
+ *
+ * TODO: Not documented in the API (seems ugly).
+ */
+VALUE Utils_to_pure_ip(VALUE self, VALUE string)
+{
+  TRACE();
+  char *str;
+
+  str = StringValueCStr(string);
+  if (str[0] == '[')
+    return rb_str_new(RSTRING_PTR(string)+1, RSTRING_LEN(string)-2);
+  else
+    return string;
+}
+
+
+/*
+ * TODO: We lack a simple "normalice_host(ip)" method that parses the given ip and so on...
+ */
+
+
+/*
+ * Expects a string like "1.2.3.4_5060" or "1af:43::ab_9090" and returns
+ * an Array as follows:
+ *   [ ip_type, ip, port ]
+ * where:
+ *   - ip_type is :ipv4 or :ipv6,
+ *   - ip is a String,
+ *   - port is a Fixnum
+ * If the string is invalid it returns false.
+ */
+VALUE Utils_parser_outbound_udp_flow_token(VALUE self, VALUE string)
+{
+  TRACE();
+  char *str = NULL;
+  long len = 0;
+  struct_outbound_udp_flow_token outbound_udp_flow_token;
+  VALUE ip_type, ip, port;
+
+  if (TYPE(string) != T_STRING)
+    rb_raise(rb_eTypeError, "Argument must be a String");
+
+  str = RSTRING_PTR(string);
+  len = RSTRING_LEN(string);
+
+  outbound_udp_flow_token = outbound_udp_flow_token_parser_execute(str, len);
+
+  if (outbound_udp_flow_token.valid == 0)
+    return Qfalse;
+  else {
+    if (outbound_udp_flow_token.ip_type == outbound_udp_flow_token_ip_type_ipv4)
+      ip_type = symbol_ipv4;
+    else
+      ip_type = symbol_ipv6;
+
+    ip = rb_str_new((char *)outbound_udp_flow_token.ip_s, outbound_udp_flow_token.ip_len);
+    port = INT2FIX(str_to_int((char *)outbound_udp_flow_token.port_s, outbound_udp_flow_token.port_len));
+
+    return rb_ary_new3(3, ip_type, ip, port);
+  }
+}
+
+
+/*
+ * Expects a string like "PROXY TCP4 192.168.0.1 192.168.0.11 56324 443\r\n" and returns
+ * an Array as follows:
+ *   [ num_bytes, ip_type, ip, port ]
+ * where:
+ *   - num_bytes is the length of the HAProxy Protocol line (to be removed), a Fixnum.
+ *   - ip_type is :ipv4 or :ipv6,
+ *   - ip is a String,
+ *   - port is a Fixnum
+ * If the string is invalid it returns false.
+ */
+VALUE Utils_parser_haproxy_protocol(VALUE self, VALUE string)
+{
+  TRACE();
+  char *str = NULL;
+  long len = 0;
+  struct_haproxy_protocol haproxy_protocol;
+  VALUE num_bytes, ip_type, ip, port;
+
+  if (TYPE(string) != T_STRING)
+    rb_raise(rb_eTypeError, "Argument must be a String");
+
+  str = RSTRING_PTR(string);
+  len = RSTRING_LEN(string);
+
+  haproxy_protocol = struct_haproxy_protocol_parser_execute(str, len);
+
+  if (haproxy_protocol.valid == 0)
+    return Qfalse;
+  else {
+    if (haproxy_protocol.ip_type == haproxy_protocol_ip_type_ipv4)
+      ip_type = symbol_ipv4;
+    else
+      ip_type = symbol_ipv6;
+
+    ip = rb_str_new((char *)haproxy_protocol.ip_s, haproxy_protocol.ip_len);
+    port = INT2FIX(str_to_int((char *)haproxy_protocol.port_s, haproxy_protocol.port_len));
+    num_bytes = INT2FIX(haproxy_protocol.total_len);
+
+    return rb_ary_new3(4, num_bytes, ip_type, ip, port);
+  }
+}
+
+
+void Init_utils()
+{
+  TRACE();
+
+  mOverSIP = rb_define_module("OverSIP");
+  mUtils = rb_define_module_under(mOverSIP, "Utils");
+
+  rb_define_module_function(mUtils, "ip?", Utils_is_ip, 1);
+  rb_define_module_function(mUtils, "pure_ip?", Utils_is_pure_ip, 1);
+  rb_define_module_function(mUtils, "ip_type", Utils_ip_type, 1);
+  rb_define_module_function(mUtils, "compare_ips", Utils_compare_ips, 2);
+  rb_define_module_function(mUtils, "compare_pure_ips", Utils_compare_pure_ips, 2);
+  rb_define_module_function(mUtils, "normalize_ipv6", Utils_normalize_ipv6, -1);
+  rb_define_module_function(mUtils, "normalize_host", Utils_normalize_host, -1);
+  rb_define_module_function(mUtils, "to_pure_ip", Utils_to_pure_ip, 1);
+  rb_define_module_function(mUtils, "parse_outbound_udp_flow_token", Utils_parser_outbound_udp_flow_token, 1);
+  rb_define_module_function(mUtils, "parse_haproxy_protocol", Utils_parser_haproxy_protocol, 1);
+
+  symbol_ipv4 = ID2SYM(rb_intern("ipv4"));
+  symbol_ipv6 = ID2SYM(rb_intern("ipv6"));
+  symbol_ipv6_reference = ID2SYM(rb_intern("ipv6_reference"));
+}

data/ext/utils/utils_ruby.h

@@ -0,0 +1,76 @@
+/*
+ * This file is not used by Ruby OverSIP::Utils module itself, its aim is to
+ * be included by other OverSIP Ruby C extensions.
+ */
+
+#ifndef utils_ruby_h
+#define utils_ruby_h
+
+
+#include "ip_utils.h"
+#include "outbound_utils.h"
+#include "haproxy_protocol.h"
+#include <arpa/inet.h>  // inet_ntop()
+
+
+/* Export the Ruby C functions so other C libraries within OverSIP can use them. */
+VALUE Utils_is_ip(VALUE self, VALUE string);
+VALUE Utils_is_pure_ip(VALUE self, VALUE string);
+VALUE Utils_ip_type(VALUE self, VALUE string);
+VALUE Utils_compare_ips(VALUE self, VALUE string1, VALUE string2);
+VALUE Utils_compare_pure_ips(VALUE self, VALUE string1, VALUE string2);
+VALUE Utils_normalize_ipv6(int argc, VALUE *argv, VALUE self);
+VALUE Utils_normalize_host(int argc, VALUE *argv, VALUE self);
+VALUE Utils_to_pure_ip(VALUE self, VALUE string);
+VALUE Utils_parser_outbound_udp_flow_token(VALUE self, VALUE string);
+VALUE Utils_parser_haproxy_protocol(VALUE self, VALUE string);
+
+
+VALUE utils_normalize_ipv6(VALUE string, int force_pure_ipv6)
+{
+  struct in6_addr addr;
+  char normalized_ipv6[INET6_ADDRSTRLEN + 1];
+  char normalized_ipv6_reference[INET6_ADDRSTRLEN + 3];
+  char *str, str2[INET6_ADDRSTRLEN + 3], *str_pointer;
+  int is_ipv6_reference = 0;
+
+  str = StringValueCStr(string);
+  if (str[0] != '[') {
+    str_pointer = str;
+  }
+  else {
+    is_ipv6_reference = 1;
+    memcpy(str2, str + 1, strlen(str) - 2);
+    str2[strlen(str) - 2] = '\0';
+    str_pointer = str2;
+  }
+
+  switch(inet_pton(AF_INET6, str_pointer, &addr)) {
+    /* Not a valid IPv6. */
+    case 0:
+      return Qfalse;
+      break;
+    /* Some error ocurred. */
+    case -1:
+      return Qnil;
+      break;
+    default:
+      break;
+  }
+
+  if (inet_ntop(AF_INET6, &addr, normalized_ipv6, INET6_ADDRSTRLEN))
+    if (is_ipv6_reference && !force_pure_ipv6) {
+      memcpy(normalized_ipv6_reference, "[", 1);
+      memcpy(normalized_ipv6_reference + 1, normalized_ipv6, strlen(normalized_ipv6));
+      memcpy(normalized_ipv6_reference + strlen(normalized_ipv6) + 1, "]\0", 2);
+      return rb_str_new_cstr(normalized_ipv6_reference);
+    }
+    else
+      return rb_str_new_cstr(normalized_ipv6);
+  /* Some error ocurred. */
+  else
+    return Qnil;
+}
+
+
+#endif

data/ext/websocket_framing_utils/ext_help.h

@@ -0,0 +1,18 @@
+#ifndef ext_help_h
+#define ext_help_h
+
+#define RAISE_NOT_NULL(T) if(T == NULL) rb_raise(rb_eArgError, "NULL found for " # T " when shouldn't be.");
+#define DATA_GET(from,type,name) Data_Get_Struct(from,type,name); RAISE_NOT_NULL(name);
+#define REQUIRE_TYPE(V, T) if(TYPE(V) != T) rb_raise(rb_eTypeError, "Wrong argument type for " # V " required " # T);
+
+
+/* Uncomment for enabling TRACE() function. */
+/*#define DEBUG*/
+
+#ifdef DEBUG
+#define TRACE()  fprintf(stderr, "TRACE: %s:%d:%s\n", __FILE__, __LINE__, __FUNCTION__)
+#else
+#define TRACE() 
+#endif
+
+#endif

data/ext/websocket_framing_utils/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile("oversip/websocket/ws_framing_utils")

data/ext/websocket_framing_utils/ws_framing_utils.h

@@ -0,0 +1,47 @@
+#ifndef ws_framing_utils_h
+#define ws_framing_utils_h
+
+
+#include <stdint.h>
+
+
+/* Extracted from http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ */
+
+#define UTF8_ACCEPT 0
+#define UTF8_REJECT 1
+#define UTF8D_SIZE 400
+
+static const uint8_t utf8d[] = {
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 00..1f */
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 20..3f */
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40..5f */
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 60..7f */
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, /* 80..9f */
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, /* a0..bf */
+  8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, /* c0..df */
+  0xa,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4,0x3,0x3, /* e0..ef */
+  0xb,0x6,0x6,0x6,0x5,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8, /* f0..ff */
+  0x0,0x1,0x2,0x3,0x5,0x8,0x7,0x1,0x1,0x1,0x4,0x6,0x1,0x1,0x1,0x1, /* s0..s0 */
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1, /* s1..s2 */
+  1,2,1,1,1,1,1,2,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1, /* s3..s4 */
+  1,2,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,3,1,1,1,1,1,1, /* s5..s6 */
+  1,3,1,1,1,1,1,3,1,3,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1  /* s7..s8 */
+};
+
+static inline
+uint32_t utf8_decode(uint32_t* state, uint32_t* codep, uint32_t byte) {
+  uint32_t type = utf8d[byte];
+
+  *codep = (*state != UTF8_ACCEPT) ? (byte & 0x3fu) | (*codep << 6) : (0xff >> type) & (byte);
+  *state = utf8d[256 + *state*16 + type];
+  return *state;
+}
+
+
+typedef struct utf8_validator {
+  uint32_t codepoint;
+  uint32_t state;
+} utf8_validator;
+
+
+#endif

data/ext/websocket_framing_utils/ws_framing_utils_ruby.c

@@ -0,0 +1,135 @@
+#include <ruby.h>
+#include "ws_framing_utils.h"
+#include "ext_help.h"
+
+
+static VALUE mOverSIP;
+static VALUE mWebSocket;
+static VALUE mFramingUtils;
+static VALUE cUtf8Validator;
+
+
+
+/*
+ * Ruby functions.
+ */
+
+VALUE WsFramingUtils_unmask(VALUE self, VALUE payload, VALUE mask)
+{
+  char *payload_str, *mask_str;
+  long payload_len;  /* mask length is always 4 bytes. */
+  char *unmasked_payload_str;
+  VALUE rb_unmasked_payload;
+  int i;
+
+  if (TYPE(payload) != T_STRING)
+    rb_raise(rb_eTypeError, "Argument must be a String");
+
+  if (TYPE(mask) != T_STRING)
+    rb_raise(rb_eTypeError, "Argument must be a String");
+
+  if (RSTRING_LEN(mask) != 4)
+    rb_raise(rb_eTypeError, "mask size must be 4 bytes");
+
+  payload_str = RSTRING_PTR(payload);
+  payload_len = RSTRING_LEN(payload);
+  mask_str = RSTRING_PTR(mask);
+
+  /* NOTE: In Ruby C extensions always use:
+   *    pointer = ALLOC_N(type, n)
+   * which means: pointer = (type*)xmalloc(sizeof(type)*(n))
+   * and:
+   *    xfree()
+   */
+
+  unmasked_payload_str = ALLOC_N(char, payload_len);
+
+  for(i=0; i < payload_len; i++)
+    unmasked_payload_str[i] = payload_str[i] ^ mask_str[i % 4];
+
+  rb_unmasked_payload = rb_str_new(unmasked_payload_str, payload_len);
+  xfree(unmasked_payload_str);
+  return(rb_unmasked_payload);
+}
+
+
+static void Utf8Validator_free(void *validator)
+{
+  TRACE();
+  if(validator) {
+    xfree(validator);
+  }
+}
+
+
+VALUE Utf8Validator_alloc(VALUE klass)
+{
+  TRACE();
+  VALUE obj;
+  utf8_validator *validator = ALLOC(utf8_validator);
+
+  validator->state = UTF8_ACCEPT;
+
+  obj = Data_Wrap_Struct(klass, NULL, Utf8Validator_free, validator);
+  return obj;
+}
+
+
+VALUE Utf8Validator_reset(VALUE self)
+{
+  TRACE();
+  utf8_validator *validator = NULL;
+  DATA_GET(self, utf8_validator, validator);
+
+  validator->state = UTF8_ACCEPT;
+
+  return Qnil;
+}
+
+
+/*
+ * Returns:
+ * - true: Valid UTF-8 string.
+ * - nil: Valid but not terminated UTF-8 string.
+ * - false: Invalid UTF-8 string.
+ */
+VALUE Utf8Validator_validate(VALUE self, VALUE string)
+{
+  TRACE();
+  utf8_validator *validator = NULL;
+  uint8_t *str = NULL;
+  int i;
+
+  REQUIRE_TYPE(string, T_STRING);
+  str = (uint8_t *)RSTRING_PTR(string);
+
+  DATA_GET(self, utf8_validator, validator);
+
+  for(i=0; i < RSTRING_LEN(string); i++)
+    if (utf8_decode(&validator->state, &validator->codepoint, str[i]) == UTF8_REJECT)
+      return Qfalse;
+
+  switch(validator->state) {
+    case UTF8_ACCEPT:
+      return Qtrue;
+      break;
+    default:
+      return Qnil;
+      break;
+  }
+}
+
+
+void Init_ws_framing_utils()
+{
+  mOverSIP = rb_define_module("OverSIP");
+  mWebSocket = rb_define_module_under(mOverSIP, "WebSocket");
+  mFramingUtils = rb_define_module_under(mWebSocket, "FramingUtils");
+  cUtf8Validator = rb_define_class_under(mFramingUtils, "Utf8Validator", rb_cObject);
+
+  rb_define_module_function(mFramingUtils, "unmask", WsFramingUtils_unmask,2);
+
+  rb_define_alloc_func(cUtf8Validator, Utf8Validator_alloc);
+  rb_define_method(cUtf8Validator, "reset", Utf8Validator_reset,0);
+  rb_define_method(cUtf8Validator, "validate", Utf8Validator_validate,1);
+}