oversip_p 1.0.0

data/lib/oversip/sip/uac_request.rb

@@ -0,0 +1,84 @@
+module OverSIP::SIP
+
+  class UacRequest
+
+    DEFAULT_MAX_FORWARDS = "20"
+    DEFAULT_FROM = "\"OverSIP #{::OverSIP::VERSION}\" <sip:uac@oversip.net>"
+
+    attr_reader :sip_method, :ruri, :from, :from_tag, :to, :body, :call_id, :cseq
+    attr_reader :antiloop_id, :via_branch_id
+    attr_reader :routes  # Always nil (needed for OverSIP::SIP::Tags.create_antiloop_id().
+    attr_accessor :tvars  # Transaction variables (a hash).
+
+
+    def initialize data, extra_headers=[], body=nil
+      unless (@sip_method = data[:sip_method])
+        raise ::OverSIP::RuntimeError, "no data[:sip_method] given"
+      end
+      unless (ruri = data[:ruri])
+        raise ::OverSIP::RuntimeError, "no data[:ruri] given"
+      end
+
+      case ruri
+      when ::OverSIP::SIP::Uri, ::OverSIP::SIP::NameAddr
+        @ruri = ruri
+      when ::String
+        @ruri = OverSIP::SIP::Uri.parse ruri
+      else
+        raise ::OverSIP::RuntimeError, "invalid URI #{ruri.inspect}"
+      end
+
+      @from = data[:from] || DEFAULT_FROM
+      @from_tag = data[:from_tag] || ::SecureRandom.hex(4)
+      @to = data[:to] || @ruri
+      @call_id = data[:call_id] || ::SecureRandom.hex(8)
+      @cseq = data[:cseq] || rand(1000)
+      @max_forwards = data[:max_forwards] || DEFAULT_MAX_FORWARDS
+
+      @headers = {}
+      @extra_headers = extra_headers
+
+      @body = body
+
+      @antiloop_id = ::OverSIP::SIP::Tags.create_antiloop_id(self)
+      @via_branch_id = ::SecureRandom.hex(4)
+    end
+
+
+    def insert_header name, value
+      @headers[name] = value.to_s
+    end
+
+
+    def delete_header_top name
+      @headers.delete name
+    end
+
+
+    def to_s
+      msg = "#{@sip_method.to_s} #{@ruri.uri} SIP/2.0\r\n"
+
+      @headers.each do |name, value|
+        msg << name << ": #{value}\r\n"
+      end
+
+      msg << "From: #{@from.to_s};tag=#{@from_tag}\r\n"
+      msg << "To: #{@to.to_s}\r\n"
+      msg << "Call-ID: #{@call_id}\r\n"
+      msg << "CSeq: #{@cseq.to_s} #{@sip_method.to_s}\r\n"
+      msg << "Content-Length: #{@body ? @body.bytesize : "0"}\r\n"
+      msg << "Max-Forwards: #{@max_forwards.to_s}\r\n"
+      msg << HDR_USER_AGENT << CRLF
+
+      @extra_headers.each do |header|
+        msg << header << CRLF
+      end
+
+      msg << CRLF
+      msg << @body  if @body
+      msg
+    end
+
+  end  # class Request
+
+end

data/lib/oversip/sip/uri.rb

@@ -0,0 +1,208 @@
+module OverSIP::SIP
+
+  class Uri
+    attr_reader :scheme, :user, :host, :host_type, :port, :params, :transport_param, :phone_context_param, :ovid_param, :headers
+
+
+    def self.parse value
+      uri = ::OverSIP::SIP::MessageParser.parse_uri value, false
+      raise ::OverSIP::ParsingError, "invalid URI #{value.inspect}"  unless uri.is_a? (::OverSIP::SIP::Uri)
+      uri
+    end
+
+
+    def initialize scheme=:sip, user=nil, host=nil, port=nil
+      @scheme = scheme.to_sym
+      @user = user
+      @host = host
+      @host_type = ::OverSIP::Utils.ip_type(host) || :domain  if host
+      @port = port
+
+      @uri_modified = true
+    end
+
+    def sip?
+      @scheme == :sip or @scheme == :sips
+    end
+
+    def tel?
+      @scheme == :tel
+    end
+
+    def scheme= value
+      return nil  if unknown_scheme?
+      @scheme = value
+      @uri_modified = true
+    end
+
+    def unknown_scheme?
+      not @scheme.is_a? Symbol
+    end
+
+    def user= value
+      return nil  if unknown_scheme?
+      @user = value
+      @uri_modified = true
+    end
+    alias :number :user
+    alias :number= :user=
+
+    def host= value
+      return nil  if unknown_scheme?
+      @host = value
+      @host_type = ::OverSIP::Utils.ip_type(value) || :domain
+      @uri_modified = true
+    end
+    alias :domain :host
+    alias :domain= :host=
+
+    def host_type= value
+      return nil  if unknown_scheme?
+      @host_type = value
+    end
+
+    def port= value
+      return nil  if unknown_scheme?
+      @port = value
+      @uri_modified = true
+    end
+
+    def params
+      @params ||= {}
+    end
+
+    def has_param? k
+      return nil  if unknown_scheme?
+      params.include? k.to_s.downcase
+    end
+
+    def get_param k
+      return nil  if unknown_scheme?
+      params[k.to_s.downcase]
+    end
+
+    def set_param k, v
+      return nil  if unknown_scheme?
+      @params ||= {}
+      @params[k.downcase] = v
+      @uri_modified = true
+    end
+
+    def del_param k
+      return nil  if unknown_scheme?
+      return false  unless @params
+      if @params.include?(k=k.downcase)
+        @uri_modified = true
+        return @params.delete(k)
+      end
+      false
+    end
+
+    def clear_params
+      return nil  if unknown_scheme?
+      return false  unless @params
+      @params.clear
+      @transport_param = nil
+      @phone_context_param = nil
+      @uri_modified = true
+      true
+    end
+
+    def transport_param= value
+      return nil  unless @scheme == :sip or @scheme == :sips
+      if value
+        @transport_param = value.to_sym
+        set_param "transport", value.to_s
+      else
+        @transport_param = nil
+        del_param "transport"
+      end
+    end
+
+    def phone_context_param= value
+      return nil  unless @scheme == :tel
+      if value
+        @phone_context_param = value.to_sym
+        set_param "phone-context", value.to_s
+      else
+        @phone_context_param = nil
+        del_param "phone-context"
+      end
+    end
+
+    def lr_param?
+      @lr_param ? true : false
+    end
+
+    def ob_param?
+      @ob_param ? true : false
+    end
+
+    def headers= value
+      return nil  if unknown_scheme?
+      @headers = value
+      @uri_modified = true
+    end
+
+    def uri
+      return @uri  unless @uri_modified
+
+      case @scheme
+        when :sip, :sips
+          @uri = @scheme.to_s << ":"
+          ( @uri << ::EscapeUtils.escape_uri(@user) << "@" )  if @user
+          @uri << @host
+          ( @uri << ":" << @port.to_s )  if @port
+
+          @params.each do |k,v|
+            @uri << ";" << k
+            ( @uri << "=" << v.to_s )  if v
+          end  if @params
+
+          @uri << @headers  if @headers
+
+        when :tel
+          @uri = "tel:"
+          @uri << @user
+
+          @params.each do |k,v|
+            @uri << ";" << k
+            ( @uri << "=" << v.to_s )  if v
+          end  if @params
+
+        end
+
+      @uri_modified = false
+      @uri
+    end
+    alias :to_s :uri
+    alias :inspect :uri
+
+    # Returns a String with the AoR of the URI:
+    # - SIP URI: sip:user@domain.
+    # - TEL URI: tel:number
+    # - Others: nil
+    #
+    def aor
+      case @scheme
+        when :sip, :sips
+          aor = "sip:"
+          ( aor << ::EscapeUtils.escape_uri(@user) << "@" )  if @user
+          aor << @host
+
+        when :tel
+          aor = "tel:"
+          aor << @user
+
+        end
+
+      aor
+    end
+
+    def modified?
+      @uri_modified
+    end
+
+  end  # class Uri
+
+end

data/lib/oversip/syslog.rb

@@ -0,0 +1,68 @@
+module OverSIP
+
+  module Syslog
+
+    SYSLOG_FACILITY_MAPPING = {
+      "kern"    => ::Syslog::LOG_KERN,
+      "user"    => ::Syslog::LOG_USER,
+      "daemon"  => ::Syslog::LOG_DAEMON,
+      "local0"  => ::Syslog::LOG_LOCAL0,
+      "local1"  => ::Syslog::LOG_LOCAL1,
+      "local2"  => ::Syslog::LOG_LOCAL2,
+      "local3"  => ::Syslog::LOG_LOCAL3,
+      "local4"  => ::Syslog::LOG_LOCAL4,
+      "local5"  => ::Syslog::LOG_LOCAL5,
+      "local6"  => ::Syslog::LOG_LOCAL6,
+      "local7"  => ::Syslog::LOG_LOCAL7
+    }
+
+    SYSLOG_SEVERITY_MAPPING = {
+      "debug"  => 0,
+      "info"   => 1,
+      "notice" => 2,
+      "warn"   => 3,
+      "error"  => 4,
+      "crit"   => 5,
+      "alert"  => 6,
+      "emerg"  => 7
+    }
+
+    def self.log level_value, msg, log_id, user
+      user = user ? " [user] " : " "
+
+      msg = case msg
+      when ::String
+        "<#{log_id}>#{user}#{msg}"
+      when ::Exception
+        "<#{log_id}>#{user}#{msg.message} (#{msg.class })\n#{(msg.backtrace || [])[0..3].join("\n")}"
+      else
+        "<#{log_id}>#{user}#{msg.inspect}"
+      end
+
+      msg = msg.gsub(/%/,"%%").gsub(/\x00/,"")
+
+      case level_value
+      when 0
+        ::Syslog.debug sprintf("%7s %s", "DEBUG:", msg)
+      when 1
+        ::Syslog.info sprintf("%7s %s", "INFO:", msg)
+      when 2
+        ::Syslog.notice sprintf("%7s %s", "NOTICE:", msg)
+      when 3
+        ::Syslog.warning sprintf("%7s %s", "WARN:", msg)
+      when 4
+        ::Syslog.err sprintf("%7s %s", "ERROR:", msg)
+      when 5
+        ::Syslog.crit sprintf("%7s %s", "CRIT:", msg)
+      when 6
+        ::Syslog.alert sprintf("%7s %s", "ALERT:", msg)
+      when 7
+        ::Syslog.emerg sprintf("%7s %s", "EMERG:", msg)
+      else  # Shouldn't occur.
+        ::Syslog.err sprintf("%7s %s", "UNKNOWN:", msg)
+      end
+    end
+
+  end
+
+end

data/lib/oversip/system_callbacks.rb

@@ -0,0 +1,45 @@
+module OverSIP
+
+  # This module is intended for 3rd party modules that need custom code to be
+  # executed when OverSIP is started, reloaded or terminated.
+  #
+  module SystemCallbacks
+
+    extend ::OverSIP::Logger
+
+    @log_id = "SystemCallbacks"
+
+    class << self
+      attr_reader :on_started_callbacks
+      attr_reader :on_terminated_callbacks
+      attr_reader :on_reload_callbacks
+    end
+
+    @on_started_callbacks = []
+    @on_terminated_callbacks = []
+    @on_reload_callbacks = []
+
+    def self.on_started pr=nil, &bl
+      block = pr || bl
+      raise ::ArgumentError, "no block given"  unless block.is_a? ::Proc
+
+      @on_started_callbacks << block
+    end
+
+    def self.on_terminated pr=nil, &bl
+      block = pr || bl
+      raise ::ArgumentError, "no block given"  unless block.is_a? ::Proc
+
+      @on_terminated_callbacks << block
+    end
+
+    def self.on_reload pr=nil, &bl
+      block = pr || bl
+      raise ::ArgumentError, "no block given"  unless block.is_a? ::Proc
+
+      @on_reload_callbacks << block
+    end
+
+  end
+
+end

data/lib/oversip/tls.rb

@@ -0,0 +1,172 @@
+module OverSIP
+
+  module TLS
+
+    extend ::OverSIP::Logger
+
+    TLS_PEM_CHAIN_REGEXP = /-{5}BEGIN CERTIFICATE-{5}\n.*?-{5}END CERTIFICATE-{5}\n/m
+
+    @log_id = "TLS"
+
+
+    def self.module_init
+      configuration = ::OverSIP.configuration
+      if configuration[:tls][:public_cert] and configuration[:tls][:private_cert]
+        log_system_info "TLS enabled"
+        ::OverSIP.tls_public_cert = configuration[:tls][:public_cert]
+        ::OverSIP.tls_private_cert = configuration[:tls][:private_cert]
+      else
+        log_system_info "TLS disabled"
+        return
+      end
+
+      if (ca_dir = configuration[:tls][:ca_dir])
+        @store = ::OpenSSL::X509::Store.new
+        num_certs_added = 0
+
+        ::Dir.chdir ca_dir
+        ca_files = ::Dir["*"]
+        ca_files.select! { |ca_file| ::File.file?(ca_file) and ::File.readable?(ca_file) }
+        ca_files.each do |ca_file|
+          log_system_info "inspecting CA file '#{ca_file}'..."
+
+          ca_file_content = ::File.read(ca_file)
+          unless ca_file_content.valid_encoding?
+            log_system_error "ignoring '#{ca_file}', invalid symbols found"
+            next
+          end
+
+          pems = ca_file_content.scan(TLS_PEM_CHAIN_REGEXP).flatten
+          num_pems = pems.size
+
+          if num_pems == 0
+            log_system_warn "'#{ca_file}': no public certificates found"
+            next
+          end
+          log_system_info "'#{ca_file}': #{num_pems} public certificates found"
+
+          now = ::Time.now
+          certs = []
+          pems.each do |pem|
+            begin
+              certs << ::OpenSSL::X509::Certificate.new(pem)
+            rescue => e
+              log_system_error "ignoring invalid X509 certificate: #{e.message} (#{e.class})"
+              num_pems -= 1
+            end
+          end
+
+          certs.reject! { |cert| cert.not_after < now }
+          if certs.size != num_pems
+            log_system_info "'#{ca_file}': ignoring #{num_pems - certs.size} expired certificates"
+          end
+
+          certs.each do |cert|
+            begin
+              @store.add_cert cert
+              num_certs_added += 1
+            # This occurs when a certificate is repeated.
+            rescue ::OpenSSL::X509::StoreError => e
+              log_system_warn "'#{ca_file}': ignoring certificate: #{e.message} (#{e.class})"
+            end
+          end
+        end
+
+        if num_certs_added == 0
+          log_system_notice "zero public certificates found in '#{ca_dir}' directory, disabling TLS validation"
+          @store = nil
+        end
+        log_system_info "#{num_certs_added} public certificates available for TLS validation"
+      end
+
+    end  # def self.module_init
+
+
+    # Return an array with the result of the TLS certificate validation as follows:
+    #   cert, validated, tls_error, tls_error_string
+    # where:
+    # - cert:      the ::OpenSSL::X509::Certificate instance of the first PEM provided by
+    #              the peer, nil otherwise.
+    # - validated: true if the given certificate(s) have been validated, false otherwise
+    #              and nil if no certificate is provided by peer or no CA's were configured
+    #              for TLS validation.
+    # - tls_error: OpenSSL validation error code (Fixnum) in case of validation error.
+    # - tls_error_string: OpenSSL validation error string in case of validation error.
+    def self.validate pems
+      return nil, nil, nil, "no CAs provided, validation disabled"  unless @store
+      return nil, false, nil, "no certificate provided by peer"  unless pems.any?
+
+      pem = pems.pop
+      intermediate_pems = pems
+
+      begin
+        cert = ::OpenSSL::X509::Certificate.new pem
+
+        if intermediate_pems and intermediate_pems.any?
+          intermediate_certs = []
+          intermediate_pems.each do |pem|
+            intermediate_certs << ::OpenSSL::X509::Certificate.new(pem)
+          end
+        else
+          intermediate_certs = nil
+        end
+
+        if @store.verify cert, intermediate_certs
+          return cert, true
+        else
+          return cert, false, @store.error, @store.error_string
+        end
+
+      rescue => e
+        log_system_error "exception validating a certificate: #{e.class}: #{e.message}"
+        return nil, false, e.class, e.message
+      end
+    end  # def self.validate
+
+
+    def self.get_sip_identities cert
+      return []  unless cert
+
+      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
+        unless verify_subjectAltName_DNS
+          subjectAltName_URI_sip_entries.each {|domain| sip_identities[domain] = true}
+        else
+          subjectAltName_DNS_entries.each {|domain| sip_identities[domain] = true}
+        end
+
+      else
+        cert.subject.to_a.each do |oid, value|
+          if oid == "CN"
+            sip_identities[value.downcase] = true
+            break
+          end
+        end
+      end
+
+      # Return an array with the SIP identities (domains) in the certificate.
+      return sip_identities.keys
+    end
+
+  end
+
+end

data/lib/oversip/utils.rb

@@ -0,0 +1,30 @@
+module OverSIP
+
+  module Utils
+
+    # It ensures that two identical byte secuences are matched regardless
+    # they have different encoding.
+    # For example in Ruby the following returns false:
+    #   "iñaki".force_encoding(::Encoding::BINARY) == "iñaki"
+    def self.string_compare string1, string2
+      string1.to_s.force_encoding(::Encoding::BINARY) == string2.to_s.force_encoding(::Encoding::BINARY)
+    end
+
+    # This avoid "invalid byte sequence in UTF-8" when the directly doing:
+    #   string =~ /EXPRESSION/
+    # and string has invalid UTF-8 bytes secuence.
+    # Also avoids "incompatible encoding regexp match (UTF-8 regexp with ASCII-8BIT string)"
+    # NOTE: expression argument must be a String or a Regexp.
+    def self.regexp_compare string, expression
+      string = string.to_s.force_encoding(::Encoding::BINARY)
+      if expression.is_a? ::Regexp
+        expression = /#{expression.source.force_encoding(::Encoding::BINARY)}/
+      else
+        expression = /#{expression.to_s.force_encoding(::Encoding::BINARY)}/
+      end
+      string =~ expression
+    end
+
+  end
+
+end

data/lib/oversip/version.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+module OverSIP
+
+  module Version
+    MAJOR = 2
+    MINOR = 0
+    TINY  = 4
+    DEVEL = nil  # Set to nil for stable releases.
+  end
+
+  PROGRAM_NAME     = "OverSIP"
+  VERSION = [Version::MAJOR, Version::MINOR, Version::TINY].join(".")
+  VERSION << ".#{Version::DEVEL}"  if Version::DEVEL
+  AUTHOR = "Inaki Baz Castillo"
+  AUTHOR_EMAIL = "ibc@aliax.net"
+  HOMEPAGE = "http://oversip.net"
+  year = "2012-2014"
+  DESCRIPTION = "#{PROGRAM_NAME} #{VERSION}\n#{HOMEPAGE}\n#{year}, #{AUTHOR} <#{AUTHOR_EMAIL}>"
+
+end

data/lib/oversip/websocket/constants.rb

@@ -0,0 +1,55 @@
+module OverSIP::WebSocket
+
+  CRLF = "\r\n"
+
+  REASON_PHRASE = {
+    100 => "Continue",
+    101 => "Switching Protocols",
+    200 => "OK",
+    201 => "Created",
+    202 => "Accepted",
+    203 => "Non-Authoritative Information",
+    204 => "No Content",
+    205 => "Reset Content",
+    206 => "Partial Content",
+    300 => "Multiple Choices",
+    301 => "Moved Permanently",
+    302 => "Found",
+    303 => "See Other",
+    304 => "Not Modified",
+    305 => "Use Proxy",
+    307 => "Temporary Redirect",
+    400 => "Bad Request",
+    401 => "Unauthorized",
+    402 => "Payment Required",
+    403 => "Forbidden",
+    404 => "Not Found",
+    405 => "Method Not Allowed",
+    406 => "Not Acceptable",
+    407 => "Proxy Authentication Required",
+    408 => "Request Timeout",
+    409 => "Conflict",
+    410 => "Gone",
+    411 => "Length Required",
+    412 => "Precondition Failed",
+    413 => "Request Entity Too Large",
+    414 => "Request-URI Too Long",
+    415 => "Unsupported Media Type",
+    416 => "Requested Range Not Satisfiable",
+    417 => "Expectation Failed",
+    426 => "Upgrade Required",  # RFC 2817
+    500 => "Server Internal Error",
+    501 => "Not Implemented",
+    502 => "Bad Gateway",
+    503 => "Service Unavailable",
+    504 => "Gateway Time-out",
+    505 => "HTTP Version Not Supported"
+  }
+
+  REASON_PHRASE_NOT_SET = "Reason Phrase Not Set"
+
+  HDR_SERVER = "Server: #{::OverSIP::PROGRAM_NAME}/#{::OverSIP::VERSION}".freeze
+
+  WS_SIP_PROTOCOL = "sip"
+
+end