oversip 0.9.0

data/AUTHORS.txt

@@ -0,0 +1,11 @@
+MAIN AUTHOR
+===========
+
+- Iñaki Baz Castillo <ibc@aliax.net> (Github @ibc)
+
+
+
+CONTRIBUTORS
+============
+
+- Jon Bonilla <manwe@aholab.ehu.es> (Github @manwe)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2012 Iñaki Baz Castillo <ibc@aliax.net>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,16 @@
+OverSIP
+=======
+
+**UNDER CONSTRUCTION:** please wait a bit...
+
+OverSIP is an async SIP proxy/server programmable in Ruby language.
+
+Some features of OverSIP are:
+* SIP transports: UDP, TCP, TLS and WebSocket.
+* Full IPv4 and IPv6 support.
+* RFC 3263: SIP DNS mechanism (NAPTR, SRV, A, AAAA) for failover and load balancing based on DNS.
+* RFC 5626: OverSIP is a perfect Outbound EDGE proxy, including an integrated STUN server.
+* Fully programmable in Ruby language (make SIP easy).
+* Fast and efficient: OverSIP core is coded in C language.
+
+OverSIP is build on top of EventMachine async library which follows the Reactor Pattern design, allowing thousands of concurrent connections and requests in a never-blocking fashion.

data/Rakefile

@@ -0,0 +1,55 @@
+require "rake/testtask"
+require "rake/clean"
+
+
+OVERSIP_EXTENSIONS = [
+  { :dir => "ext/sip_parser", :so => "sip_parser.so", :dest => "lib/oversip/sip" },
+  { :dir => "ext/stun", :so => "stun.so", :dest => "lib/oversip" },
+  { :dir => "ext/utils", :so => "utils.so", :dest => "lib/oversip" },
+  { :dir => "ext/websocket_framing_utils", :so => "ws_framing_utils.so", :dest => "lib/oversip/websocket" },
+  { :dir => "ext/websocket_http_parser", :so => "ws_http_parser.so", :dest => "lib/oversip/websocket" },
+]
+
+OVERSIP_EXTENSIONS.each do |ext|
+  file ext[:so] => Dir.glob(["#{ext[:dir]}/*{.c,.h}"]) do
+    Dir.chdir(ext[:dir]) do
+      ruby "extconf.rb"
+      sh "make"
+    end
+    cp "#{ext[:dir]}/#{ext[:so]}", "#{ext[:dest]}/"
+  end
+
+  CLEAN.include("#{ext[:dir]}/*{.o,.log,.so,.a}")
+  CLEAN.include("#{ext[:dir]}/Makefile")
+  CLEAN.include("#{ext[:dest]}/#{ext[:so]}")
+end
+
+# Stud stuff.
+directory "tmp"
+file "bin/oversip_stud" => "tmp" do
+  Dir.chdir("ext/stud") do
+    ruby "extconf.rb"
+  end
+  FileUtils.remove_dir "tmp"
+end
+CLEAN.include("ext/stud/Makefile")
+CLEAN.include("ext/stud/mkmf.log")
+CLEAN.include("bin/oversip_stud")
+
+
+OVERSIP_COMPILE_ITEMS = OVERSIP_EXTENSIONS.map {|e| e[:so]} << "bin/oversip_stud"
+
+
+task :default => :compile
+
+desc "Compile"
+task :compile => OVERSIP_COMPILE_ITEMS
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+end
+
+# Make the :test task depend on the shared object, so it will be built automatically
+# before running the tests.
+desc "Run tests"
+task :test => OVERSIP_COMPILE_ITEMS

data/bin/oversip

@@ -0,0 +1,182 @@
+#!/usr/bin/ruby1.9
+# -*- encoding: binary -*-
+
+unless RUBY_VERSION >= "1.9.2"
+  raise LoadError, "OverSIP requires Ruby version >= 1.9.2 (current version is #{RUBY_VERSION})"
+end
+
+
+# First of all, trap some signals in order to ignore them if they arrive while
+# loading server libraries.
+[:HUP, :INT, :USR1, :USR2].each {|signal| trap(signal) {} }
+
+
+require "optparse"
+require "etc"
+require "oversip"
+
+
+module OverSIP
+
+  class Executable
+
+    @log_id = "executable"
+
+    def self.run
+      ::OverSIP::Logger.load_methods
+      extend ::OverSIP::Logger
+
+      # Options by default.
+      options = {
+        :colorize  => true
+      }
+
+      OptionParser.new("", 24, "  ") do |opts|
+        opts.banner = "#{::OverSIP::DESCRIPTION}" \
+                      "\n\nUsage: #{File.basename(__FILE__)} " \
+                      "[#{::OverSIP::PROGRAM_NAME} options] [Ruby options]"
+
+        opts.separator "\n#{::OverSIP::PROGRAM_NAME} options:"
+
+        opts.on("-P", "--pid FILE", "Create a PID file (required)") do |value|
+          options[:pid_file] = value
+        end
+
+        opts.on("-p", "--process_name NAME", "Change the running process name, also affects to syslogger process and Posix Message Queue name (default 'oversip')") do |value|
+          options[:process_name] = value
+        end
+
+        opts.on("-c", "--dir_config DIR", "Absolute path to the directory with user configuration files (default '/etc/oversip/')") do |value|
+          options[:dir_config] = value
+        end
+
+        opts.on("-u", "--user USER", "System user to run with") do |value|
+          options[:user] = value
+        end
+
+        opts.on("-g", "--group GROUP", "System group to run with") do |value|
+          options[:group] = value
+        end
+
+        opts.on("--no-color", "Don't colorize text printed in stdout") do |value|
+          options[:colorize] = false
+        end
+
+        opts.on("--remove-mqueue MQUEUE", "Destroy the Posix Message Queue with the given name and exit") do |value|
+          require "posix_mq"
+
+          begin
+            POSIX_MQ.unlink value
+          rescue ::Errno::ENOENT
+          rescue ::Errno::EACCES => e
+            fatal "cannot remove '#{value}' posix message queue due file permissions"
+            exit 1
+          rescue ::Errno::EINVAL => e
+            fatal "cannot remove '#{value}' posix message queue, invalid name"
+            exit 1
+          ensure
+            exit
+          end
+        end
+
+        opts.separator "\nRuby options:"
+
+        opts.on("-d", "--debug", "Set debugging flags ($DEBUG = true)") do
+          $DEBUG = true
+        end
+
+        opts.on("-w", "--warn", "Turn warnings on ($-w = true)") do
+          $-w = true
+        end
+
+        opts.on("-I", "--include PATH", "Add PATH to $LOAD_PATH (may be used more than once)") do |path|
+          $LOAD_PATH.unshift(*path.split(/:/))
+        end
+
+        opts.on("-r", "--require LIBRARY", "Load LIBRARY before running the programm (may be used more than once)") do |library|
+          require library
+        end
+
+        opts.separator "\nCommon options:"
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts.to_s
+          exit
+        end
+
+        opts.on_tail("-v", "--version", "Show version") do
+          puts ::OverSIP::DESCRIPTION
+          exit
+        end
+
+        begin
+          opts.parse! ARGV
+        rescue ::OptionParser::InvalidOption => e
+          log_system_error e.message
+          puts
+          puts opts.to_s
+          exit! 1
+        rescue ::OptionParser::MissingArgument => e
+          log_system_error e.message
+          puts
+          puts opts.to_s
+          exit! 1
+        end
+      end
+
+      log_system_info "#{::OverSIP::PROGRAM_NAME} #{::OverSIP::VERSION} starting..."
+
+      # Options checks.
+
+      # PID file is required.
+      unless options[:pid_file]
+        fatal "PID file is required (use -P or --pid option)"
+      end
+
+      # Ignore user/group if the launcher is not being running as root.
+      unless Process.euid == 0
+        log_system_warn "ignoring user/group parameters when not running as root"
+        options.delete :user
+        options.delete :group
+      else
+        # Get the uid and gid to run with.
+        if options[:user]
+          begin
+            Etc.getpwnam options[:user]
+          rescue ArgumentError
+            fatal "user '#{options[:user]}' does not exist in the system"
+          end
+        end
+        if options[:group]
+          begin
+            Etc.getgrnam options[:group]
+          rescue ArgumentError
+            fatal "group '#{options[:group]}' does not exist in the system"
+          end
+        end
+      end
+
+      # Set the command name (as it appears in "ps" output) to given --process_name option (-p)
+      # or to the script filename otherwise.
+      $0 = options[:process_name] || File.basename(__FILE__)
+
+      OverSIP.master_name = $0
+      log_system_info "master process name: #{OverSIP.master_name}"
+
+      OverSIP::Config.load options[:dir_config]
+      log_system_info "applied configuration:"
+      OverSIP::Config.print options[:colorize]
+
+      log_system_info "creating Posix Message Queue for communicating master and syslogger processes"
+      OverSIP::Logger.init_logger_mq options[:group]
+      OverSIP::Logger.load_methods
+
+      OverSIP::Launcher.daemonize!(options)
+      OverSIP::Launcher.run(options)
+
+    end  # def run
+  end  # class Executable
+end  # module OverSIP
+
+
+::OverSIP::Executable.run

data/ext/common/c_util.h

@@ -0,0 +1,74 @@
+/*
+ * Generic C functions and macros go here, there are no dependencies
+ * on OverSIP internal structures or the Ruby C API in here.
+ */
+
+#ifndef c_util_h
+#define c_util_h
+
+
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
+
+
+/*
+ * str_to_int: Given a pointer to char and length returns an int (but just possitive).
+ */
+static int str_to_int(const char* str, size_t len)
+{
+  TRACE();
+  int number = 0;
+  const char *s = str;
+
+  while (len--) {
+    /* Ignore zeroes at the beginning. */
+    if (number || *s != '0')
+      number = number*10 + (*s)-'0';
+    s++;
+  }
+  return number;
+}
+
+
+/*
+ * strnchr: Find the first character in a length limited string.
+ * @s: The string to be searched
+ * @len: The number of characters to be searched
+ * @c: The character to search for
+ */
+static char *strnchr(const char *s, size_t len, size_t c)
+{
+  TRACE();
+  for (; len--; ++s)
+    if (*s == (char)c)
+      return (char *)s;
+    return NULL;
+}
+
+
+/*
+ * str_find_upcase: Returns non zero if the string (*str, len) contains at least
+ * an upcase letter.
+ */
+static char *str_find_upcase(const char *s, size_t len)
+{
+  TRACE();
+  for (; len--; ++s)
+    if (*s >= 'A' && *s <= 'Z')
+      return (char *)s;
+    return NULL;
+}
+
+
+/*
+ * capitalizes all lower-case ASCII characters.
+ */
+static void downcase_char(char *c)
+{
+  TRACE();
+  if (*c >= 'A' && *c <= 'Z')
+    *c += 32;
+}
+
+
+#endif
+

data/ext/common/ruby_c_util.h

@@ -0,0 +1,88 @@
+/*
+ * Generic Ruby C functions and macros go here.
+ */
+
+#ifndef ruby_c_util_h
+#define ruby_c_util_h
+
+
+#include <ruby.h>
+#include <ruby/encoding.h>  /* Required:  http://redmine.ruby-lang.org/issues/show/4272 */
+#include "c_util.h"
+
+
+#define RB_STR_UTF8_NEW(s, len) (rb_enc_str_new(s, len, rb_utf8_encoding()))
+
+
+/*
+ * my_rb_str_hex_unescape: Unexcapes hexadecimal encoded symbols (%NN).
+ */
+static VALUE my_rb_str_hex_unescape(const char *str, size_t len)
+{
+  TRACE();
+  /* Check if hexadecimal unescaping is required. */
+  if (strnchr(str, len, '%')) {
+    char *new_str;
+    VALUE str_unescaped;
+
+    new_str = ALLOC_N(char, len);
+    memcpy(new_str, str, len);
+
+    char *s, *t;
+    char hex[3] = {0, 0, 0};
+    int i;
+
+    for (s = t = new_str, i = 0 ; i < len ; s++, i++) {
+      if (*s != '%' || !(*(s+1)) || !(*(s+2)))
+        *t++ = *s;
+      else {
+        hex[0] = *(s+1);
+        hex[1] = *(s+2);
+        *t++ = (strtol(hex, NULL, 16) & 0xFF);
+        s += 2;
+        len -= 2;
+      }
+    }
+
+    str_unescaped = RB_STR_UTF8_NEW(new_str, len);
+    xfree(new_str);
+    return(str_unescaped);
+  }
+  /* If unescaping is not required, then create a Ruby string with original pointer and length. */
+  else
+    return(RB_STR_UTF8_NEW(str, len));
+}
+
+/*
+ * my_rb_str_downcase: Downcases a string formed by simple symbols (ASCII).
+ */
+static VALUE my_rb_str_downcase(const char *str, size_t len)
+{
+  TRACE();
+  /* Check if there is at least an upcase char. */
+  if (str_find_upcase(str, len)) {
+    char *new_str;
+    VALUE str_downcased;
+
+    new_str = ALLOC_N(char, len);
+    memcpy(new_str, str, len);
+
+    char *s;
+    int i;
+
+    for (s = new_str, i = 0 ; i < len ; s++, i++)
+      if (*s >= 'A' && *s <= 'Z')
+        *s += 32;
+
+    str_downcased = RB_STR_UTF8_NEW(new_str, len);
+    xfree(new_str);
+    return(str_downcased);
+  }
+  /* If not, then create a Ruby string with original pointer and length. */
+  else
+    return(RB_STR_UTF8_NEW(str, len));
+}
+
+
+#endif
+

data/ext/sip_parser/common_headers.h

@@ -0,0 +1,209 @@
+#ifndef common_headers_h
+#define common_headers_h
+
+#include "../common/c_util.h"
+#include "ruby.h"
+
+
+/* There are 20 headers with sort representation. */
+#define NUM_SHORT_HEADERS 20
+
+
+struct common_header_name {
+  const signed long len;
+  const char *name;
+  VALUE value;
+  const char short_name;
+};
+
+
+struct short_header {
+  char abbr;
+  VALUE value;
+};
+
+
+/*
+ * A list of common SIP headers we expect to receive.
+ * This allows us to avoid repeatedly creating identical string
+ * objects to be used with rb_hash_aset().
+ */
+static struct common_header_name common_headers[] = {
+#define f(N, S) { (sizeof(N) - 1), N, Qnil, S }
+  f("Accept", ' '),
+  f("Accept-Contact", 'A'),
+  f("Accept-Encoding", ' '),
+  f("Accept-Language", ' '),
+  f("Alert-Info", ' '),
+  f("Allow", ' '),
+  f("Allow-Events", 'U'),
+  f("Authentication-Info", ' '),
+  f("Authorization", ' '),
+  f("Call-ID", 'I'),
+  f("Call-Info", ' '),
+  f("Contact", 'M'),
+  f("Content-Disposition", ' '),
+  f("Content-Encoding", 'E'),
+  f("Content-Language", ' '),
+  f("Content-Length", 'L'),
+  f("Content-Type", 'C'),
+  f("CSeq", ' '),
+  f("Date", ' '),
+  f("Event", 'O'),
+  f("Error-Info", ' '),
+  f("Expires", ' '),
+  f("From", 'F'),
+  f("Identity", 'Y'),
+  f("Identity-Info", 'N'),
+  f("In-Reply-To", ' '),
+  f("Max-Forwards", ' '),
+  f("Min-Expires", ' '),
+  f("MIME-Version", ' '),
+  f("Organization", ' '),
+  f("Priority", ' '),
+  f("Proxy-Authenticate", ' '),
+  f("Proxy-Authorization", ' '),
+  f("Proxy-Require", ' '),
+  f("Record-Route", ' '),
+  f("Refer-To", 'R'),
+  f("Referred-By", 'B'),
+  f("Reject-Contact", 'J'),
+  f("Reply-To", ' '),
+  f("Request-Disposition", 'D'),
+  f("Require", ' '),
+  f("Retry-After", ' '),
+  f("Route", ' '),
+  f("Server", ' '),
+  f("Session-Expires", 'X'),
+  f("Subject", 'S'),
+  f("Supported", 'K'),
+  f("Timestamp", ' '),
+  f("To", 'T'),
+  f("Unsupported", ' '),
+  f("User-Agent", ' '),
+  f("Via", 'V'),
+  f("Warning", ' '),
+  f("WWW-Authenticate", ' ')
+# undef f
+};
+
+
+/*
+ * The list of short headers. This list is filled by the funcion
+ * init_short_header_names.
+ */ 
+static struct short_header short_headers[NUM_SHORT_HEADERS];
+
+
+/* this function is not performance-critical, called only at load time */
+static void init_common_headers(void)
+{
+  TRACE();
+  int i;
+  struct common_header_name *cf = common_headers;
+
+  for(i = ARRAY_SIZE(common_headers); --i >= 0; cf++) {
+    cf->value = rb_str_new(cf->name, cf->len);
+    cf->value = rb_obj_freeze(cf->value);
+    /* This tell Ruby not to GC global variables which refer to Ruby's objects,
+    but are not exported to the Ruby world. */
+    rb_global_variable(&cf->value);
+  }
+}
+
+/* this funcion fills the list of short headers taken the data from
+ * common_headers array.
+ */
+static void init_short_headers(void)
+{
+  TRACE();
+  int i, j;
+  struct common_header_name *cf = common_headers;
+
+  for(i = ARRAY_SIZE(common_headers), j=0; --i >= 0; cf++) {
+    if (cf->short_name != ' ') {
+      short_headers[j].abbr = cf->short_name;
+      short_headers[j].value = cf->value;
+      j++;
+    }
+  }
+}
+
+/* this function is called for every header set */
+static VALUE find_common_header_name(const char *name, size_t len)
+{
+  TRACE();
+  int i;
+  struct common_header_name *cf = common_headers;
+
+  for(i = ARRAY_SIZE(common_headers); --i >= 0; cf++) {
+    if (cf->len == (long)len && !strncasecmp(cf->name, name, len))
+      return cf->value;
+  }
+  return Qnil;
+}
+
+/* This function is called for every short header found */
+static VALUE find_short_header_name(char abbr)
+{
+  TRACE();
+  int i;
+  struct short_header *sh = short_headers;
+
+  for(i = ARRAY_SIZE(short_headers); --i >= 0; sh++) {
+    if (sh->abbr == toupper(abbr))
+      return sh->value;
+  }
+  return Qnil;
+}
+
+
+/* Tries to lookup the header name in a list of well-known headers. If so,
+ * returns the retrieved VALUE. It also works for short headers.
+ * In case the header is unknown, it normalizes it (by capitalizing the
+ * first letter and each letter under a "-" or "_" symbol).
+ */
+static VALUE headerize(const char* hname, size_t hname_len)
+{
+  TRACE();
+  VALUE headerized;
+  char* str;
+  int i;
+
+  /* Header short name. */
+  if (hname_len == 1) {
+    headerized = find_short_header_name(hname[0]);
+    if (NIL_P(headerized)) {
+      headerized = rb_str_new(hname, hname_len);
+      /* Downcase the header name. */
+      downcase_char(RSTRING_PTR(headerized));
+    }
+  }
+
+  /* Header long name. */
+  else {
+    headerized = find_common_header_name(hname, hname_len);
+    if (NIL_P(headerized)) {
+      headerized = rb_str_new(hname, hname_len);
+      str = RSTRING_PTR(headerized);
+      if (*str >= 'a' && *str <= 'z')
+        *str &= ~0x20;
+
+      for(i = 1; i < hname_len; i++) {
+        if (str[i-1] == '-' || str[i-1] == '_') {
+          if (str[i] >= 'a' && str[i] <= 'z')
+            str[i] &= ~0x20;
+        }
+        else {
+          if (str[i] >= 'A' && str[i] <= 'Z')
+            str[i] += 32;
+        }
+      }
+    }
+  }
+
+  return(headerized);
+}
+
+
+#endif

data/ext/sip_parser/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/sip_parser/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile("oversip/sip/sip_parser")