oversip_p 1.0.0

data/etc/tls/demo-tls.oversip.net.crt

@@ -0,0 +1,17 @@
+-----BEGIN CERTIFICATE-----
+MIICrzCCAhigAwIBAgIET/1hdzANBgkqhkiG9w0BAQUFADBxMR0wGwYDVQQDDBRk
+ZW1vLXRscy5vdmVyc2lwLm5ldDELMAkGA1UEBhMCRVMxEjAQBgNVBAoMCVZlcnNh
+dGljYTEQMA4GA1UECwwHT3ZlclNJUDEdMBsGCgmSJomT8ixkAQMMDWliY0BhbGlh
+eC5uZXQwHhcNMTIwNzEwMTEyMDMyWhcNMTcwNzEwMTEyMDMyWjBxMR0wGwYDVQQD
+DBRkZW1vLXRscy5vdmVyc2lwLm5ldDELMAkGA1UEBhMCRVMxEjAQBgNVBAoMCVZl
+cnNhdGljYTEQMA4GA1UECwwHT3ZlclNJUDEdMBsGCgmSJomT8ixkAQMMDWliY0Bh
+bGlheC5uZXQwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBALXVloxokaERx4xL
+0pH4rEe5liijlScKLGFJtpESUiG1pMTtWCxNzNTZ4J6mgdE07umS7567tHAEpRbr
+C+yJ+VzoLNEpOf+x9zm83NTs3xg55SbhfVEL1vQqlnsfr5YG0iTy2znUPM3r3LVS
+rTXz9UsIpnJO9ICvi28wz2a+HgStAgMBAAGjVDBSMAwGA1UdEwQFMAMBAf8wHQYD
+VR0OBBYEFLMUKsF6Xm3uI2UnBTXZihnyOv90MCMGA1UdEQQcMBqGGHNpcDpkZW1v
+LXRscy5vdmVyc2lwLm5ldDANBgkqhkiG9w0BAQUFAAOBgQAPj8XD5/snSPgjJocn
+TpWqbOIbsQBMn11+sRpftf2SsC82wQ4iZy3E1nEDVItO+YzGkxtt2VV+uFoWYNKp
+kzlTJDjvuE2lHwpiWgHIK4qcuC3NBYRKqopfmEtNj2vojQ3DPqyOA5v1YZyGw+SI
+AhSZ8W6FTvfiHCO5ut/d7036VA==
+-----END CERTIFICATE-----

data/etc/tls/demo-tls.oversip.net.key

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICWwIBAAKBgQC11ZaMaJGhEceMS9KR+KxHuZYoo5UnCixhSbaRElIhtaTE7Vgs
+TczU2eCepoHRNO7pku+eu7RwBKUW6wvsiflc6CzRKTn/sfc5vNzU7N8YOeUm4X1R
+C9b0KpZ7H6+WBtIk8ts51DzN69y1Uq018/VLCKZyTvSAr4tvMM9mvh4ErQIDAQAB
+AoGAVFzCOmaRmk8ra9YJ3hunoqdiGXy7yJ8ZtBGFGI2NeYJS7eLIU9XMwLxNUI4k
+ELIkXk4Dynt/3bDp/1YR9C6XeFEZkmLcA3jbaX74/mcx6GgeCdAUg1bvrzpSFqyk
+UYUw2ioFTKyfI1Z3VQmtWDxtz9BkHQ7uakOyu/HA8N8m0EECQQDe1velUoiQUTTn
+DlsdrMvwFhBvJHstXzZMA6Rwp7HKwh6kmaqycr4Lv5UZX/6nzpqiM7EO7eCD6l9n
+x7zIoOD5AkEA0OSHbCzJr0Wlxuq8joQe+ZXRz5BS+A3XWLG2ahnw/FdtLuxzNsWi
+PdDiUOO4xdPoVj/9l2xwkPTfDLsxmDRiVQJAWfZ7QBkT3P+L1gQrsM1EAAdIVzZp
+LCYWK5YE2x44Xt0Dtfv7t9Mu+ls7/GSO0HxOXVF1F8vdKiSCo8k1Y+HfMQJAcrLY
+zQP2ph+2+/cOG67eFys1biQP+pYXBWNnBvFBij0y/U3loVB5Wjnk2od/gFhvvVQb
+mVZ4pI9gHex3OdyhlQJAXNLuufGOEjnUC8lsmupiAQApMXscYPP0ahNES+hfX5uS
+ylXyHsIJp7h6tBbK/bv/BW4HYFsWUpLbjl71EC2ymg==
+-----END RSA PRIVATE KEY-----

data/etc/tls/upgrade-cacert.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# This script downloads the Root CAs list from Mozilla and stores
+# it under ca/ directory for TLS validation.
+# cacert.pem is downloaded from http://curl.haxx.se/docs/caextract.html
+# (the exact link is http://curl.haxx.se/ca/cacert.pem).
+# cacert.pem is just downloaded in case the server version is newer than
+# the local version of the file.
+
+cd ca/
+wget -N http://curl.haxx.se/ca/cacert.pem
+

data/etc/tls/utils/create-cert.rb

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+
+require "openssl"
+require "socket"
+require "readline"
+require "term/ansicolor"
+
+
+module OverSIP
+  module Cert
+
+    class Error < ::StandardError ; end
+
+    extend Term::ANSIColor
+
+    def self.create_cert
+
+      begin
+        puts
+        puts bold(green("OverSIP TLS Certificate Generator"))
+
+        puts
+        puts bold("Certificate informational fields.")
+
+        ca = OpenSSL::X509::Name.new
+
+        cert_common_name = Readline.readline("- Common Name (eg, your name or your server's hostname): ").downcase.strip
+        cert_common_name = nil if cert_common_name.empty?
+        ca.add_entry "CN", cert_common_name if cert_common_name
+
+        cert_country_code = Readline.readline("- Country Name (2 letter code): ").upcase.strip
+        ca.add_entry "C", cert_country_code unless cert_country_code.empty?
+
+        cert_state = Readline.readline("- State or Province Name (full name): ").strip
+        ca.add_entry "ST", cert_state unless cert_state.empty?
+
+        cert_locality = Readline.readline("- Locality Name (eg, city): ").strip
+        ca.add_entry "L", cert_locality unless cert_locality.empty?
+
+        cert_organization = Readline.readline("- Organization Name (eg, company): ").strip
+        ca.add_entry "O", cert_organization unless cert_organization.empty?
+
+        cert_organization_unit = Readline.readline("- Organizational Unit Name (eg, section): ").strip
+        ca.add_entry "OU", cert_organization_unit unless cert_organization_unit.empty?
+
+        cert_mail = Readline.readline("- Email: ").strip
+        ca.add_entry "mail", cert_mail unless cert_mail.empty?
+
+        puts
+        puts bold("SubjectAltName SIP URI domains. ") + "For each given _domain_ an entry \"URI:sip:_domain_\" will be added to the SubjectAltName field."
+        cert_sipuri_domains = Readline.readline("- SubjectAltName SIP URI domains (multiple values separated by space): ").downcase.strip.split
+        cert_sipuri_domains = nil if cert_sipuri_domains.empty?
+
+        puts
+        puts bold("SubjectAltName DNS domains. ") + "For each given _domain_ an entry \"DNS:_domain_\" will be added to the SubjectAltName field."
+        cert_dns_domains = Readline.readline("- SubjectAltName DNS domains (multiple values separated by space): ").downcase.strip.split
+        cert_dns_domains = nil if cert_dns_domains.empty?
+
+        puts
+        puts bold("Signing data.")
+
+        rsa_key_bits = Readline.readline("- RSA key bits (1024/2048/4096) [1024]: ").strip.to_i
+        unless rsa_key_bits.zero?
+          unless [1024, 2048, 4096].include? rsa_key_bits
+            raise OverSIP::Cert::Error, "invalid number of bits (#{rsa_key_bits}) for RSA key"
+          end
+        else
+          rsa_key_bits = 1024
+        end
+
+        key = OpenSSL::PKey::RSA.generate(rsa_key_bits)
+
+        cert = OpenSSL::X509::Certificate.new
+        cert.version = 2
+        cert.subject = ca
+        cert.issuer = ca
+        cert.serial = Time.now.to_i
+        cert.public_key = key.public_key
+
+        years_to_expire = Readline.readline("- Expiration (in years from now) [1]: ").strip.to_i
+        years_to_expire = 1 if years_to_expire.zero?
+        cert.not_after = Time.now + (years_to_expire * 365 * 24 * 60 * 60)
+        cert.not_before = Time.now - (24 * 60 * 60)
+
+        factory = OpenSSL::X509::ExtensionFactory.new
+        factory.subject_certificate = cert
+        factory.issuer_certificate = cert
+
+        subject_alt_name_fields = []
+
+        cert_sipuri_domains.each do |sipuri_domain|
+          subject_alt_name_fields.<< "URI:sip:#{sipuri_domain}"
+        end if cert_sipuri_domains
+
+        cert_dns_domains.each do |dns_domain|
+          subject_alt_name_fields.<< "DNS:#{dns_domain}"
+        end if cert_dns_domains
+
+        extensions = {
+          "basicConstraints" => "CA:TRUE",
+          "subjectKeyIdentifier" => "hash"
+        }
+        if subject_alt_name_fields.any?
+          extensions["subjectAltName"] = subject_alt_name_fields.join(",")
+        end
+
+        cert.extensions = extensions.map {|k,v| factory.create_ext(k,v) }
+
+        cert.sign(key, OpenSSL::Digest::SHA1.new)
+
+        puts
+        puts bold("File name. ") + "For the given _name_ a public certificate _name_.crt and a private key _name_.key will be created. Also a file _name_.key.crt containing both the public certificate and the private key will be created."
+        file_name = Readline.readline("- File name [#{cert_common_name}]: ").strip
+        file_name = cert_common_name  if file_name.empty?
+        unless file_name
+          raise OverSIP::Cert::Error, "a file name must be set"
+        end
+
+        puts
+
+        # Make two files:
+        # - file_name.crt => public certificate.
+        # - file_name.key => private key.
+        {"key" => key, "crt" => cert}.each_pair do |ext, o|
+          name = "#{file_name}.#{ext}"
+          File.open(name, "w") {|f| f.write(o.to_pem) }
+          File.chmod(0600, name) if ext == "key"
+
+          case ext
+          when "key"
+            puts yellow(">> private key generated in file '#{bold("#{name}")}'")
+          when "crt"
+            puts yellow(">> public certificate generated in file '#{bold("#{name}")}'")
+          end
+        end
+
+        # Make a single file containing both the public certificate and the private key.
+        name = "#{file_name}.key.crt"
+        File.open(name, "w") do |f|
+          f.write(cert.to_pem)
+          f.write(key.to_pem)
+        end
+        File.chmod(0600, name)
+        puts yellow(">> public certificate + private key generated in file '#{bold("#{name}")}'")
+
+      rescue ::Interrupt => e
+        puts "\n\n" + red("Interrupted")
+        exit
+
+      rescue ::OverSIP::Cert::Error => e
+        puts "\n" + bold(red("ERROR: #{e}"))
+        exit 1
+      end
+
+    end # def create_cert
+
+  end
+end
+
+
+OverSIP::Cert.create_cert
+

data/etc/tls/utils/get-sip-identities.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+# Runs as follows:
+#
+# ~$ ruby get-sip-identities.rb PEM_FILE
+
+
+require "openssl"
+
+
+module TLS
+
+  # Extracts the SIP identities in a public certificate following
+  # the mechanism in http://tools.ietf.org/html/rfc5922#section-7.1
+  # and returns an array containing them.
+  #
+  # Arguments:
+  # - _cert_: must be a public X.509 certificate in PEM format.
+  #
+  def self.get_sip_identities cert
+    puts "DEBUG: following rules in RFC 5922 \"Domain Certificates in SIP\" section 7.1 \"Finding SIP Identities in a Certificate\""
+    verify_subjectAltName_DNS = true
+    verify_CN = true
+    subjectAltName_URI_sip_entries = []
+    subjectAltName_DNS_entries = []
+    sip_identities = {}
+
+    cert.extensions.each do |ext|
+      next if ext.oid != "subjectAltName"
+      verify_CN = false
+
+      ext.value.split(/,\s+/).each do |name|
+        if /^URI:sip:([^@]*)/i =~ name
+          verify_subjectAltName_DNS = false
+          subjectAltName_URI_sip_entries << $1.downcase
+        elsif verify_subjectAltName_DNS && /^DNS:(.*)/i =~ name
+          subjectAltName_DNS_entries << $1.downcase
+        end
+      end
+    end
+
+    unless verify_CN
+      puts "DEBUG: certificate contains 'subjectAltName' extensions, 'CommonName' ignored"
+      unless verify_subjectAltName_DNS
+        subjectAltName_URI_sip_entries.each {|domain| sip_identities[domain] = true}
+        puts "DEBUG: 'subjectAltName' entries of type \"URI:sip:\" found, 'subjectAltName' entries of type \"DNS\" ignored"
+      else
+        subjectAltName_DNS_entries.each {|domain| sip_identities[domain] = true}
+        puts "DEBUG: 'subjectAltName' entries of type \"URI:sip:\" not found, using 'subjectAltName' entries of type \"DNS\""
+      end
+
+    else
+      puts "DEBUG: no 'subjectAltName' extension found, using 'CommonName' value"
+      cert.subject.to_a.each do |oid, value|
+        if oid == "CN"
+          sip_identities[value.downcase] = true
+          break
+        end
+      end
+    end
+
+    return sip_identities
+  end
+
+end
+
+
+unless (file = ARGV[0])
+  $stderr.puts "ERROR: no file given as argument"
+  exit false
+end
+
+unless ::File.file?(file) and ::File.readable?(file)
+  $stderr.puts "ERROR: given file is not a readable file"
+  exit false
+end
+
+begin
+  cert = ::OpenSSL::X509::Certificate.new(::File.read(file))
+rescue => e
+  $stderr.puts "ERROR: cannot get a PEM certificate in the given file: #{e.message} (#{e.class})"
+  exit false
+end
+
+sip_identities = TLS.get_sip_identities cert
+
+puts
+if sip_identities.any?
+  puts "SIP identities found in the certificate:"
+  puts
+  sip_identities.each_key {|name| puts "  - #{name}"}
+else
+  puts "No SIP identities found in the certificate"
+end
+puts

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: Unescapes 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,210 @@
+#ifndef common_headers_h
+#define common_headers_h
+
+#include "../common/c_util.h"
+#include "ruby.h"
+#include <ctype.h>  // toupper()
+
+
+/* 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")