oversip_p 1.0.0

data/lib/oversip/logger.rb

@@ -0,0 +1,84 @@
+module OverSIP
+
+  # Logging client module. Any class desiring to log messages must include (or extend) this module.
+  # In order to identify itself in the logs, the class can define log_id() method or set @log_id
+  # attribute.
+  module Logger
+
+    def self.load_methods
+      ::Syslog.close  if ::Syslog.opened?
+
+      syslog_options = ::Syslog::LOG_PID | ::Syslog::LOG_NDELAY
+      syslog_facility = ::OverSIP::Syslog::SYSLOG_FACILITY_MAPPING[::OverSIP.configuration[:core][:syslog_facility]] rescue ::Syslog::LOG_DAEMON
+      ::Syslog.open(::OverSIP.master_name, syslog_options, syslog_facility)
+
+      begin
+        @@threshold = ::OverSIP::Syslog::SYSLOG_SEVERITY_MAPPING[::OverSIP.configuration[:core][:syslog_level]]
+      rescue
+        @@threshold = 0  # debug.
+      end
+
+      $oversip_debug = ( @@threshold == 0 ? true : false )
+
+      ::OverSIP::Syslog::SYSLOG_SEVERITY_MAPPING.each do |level_str, level_value|
+        method_str = "
+          def log_system_#{level_str}(msg)
+        "
+
+        method_str << "
+          return false if @@threshold > #{level_value}
+
+          ::OverSIP::Syslog.log #{level_value}, msg, log_id, false
+        "
+
+        if not ::OverSIP.daemonized?
+          if %w{debug info notice}.include? level_str
+            method_str << "
+              puts ::OverSIP::Logger.fg_system_msg2str('#{level_str}', msg, log_id)
+              "
+          else
+            method_str << "
+              $stderr.puts ::OverSIP::Logger.fg_system_msg2str('#{level_str}', msg, log_id)
+            "
+          end
+        end
+
+        method_str << "end"
+
+        self.module_eval method_str
+
+
+        # User logs.
+        method_str = "
+          def log_#{level_str}(msg)
+            return false if @@threshold > #{level_value}
+
+            ::OverSIP::Syslog.log #{level_value}, msg, log_id, true
+          end
+        "
+
+        self.module_eval method_str
+
+      end  # .each
+    end
+
+    def self.fg_system_msg2str(level_str, msg, log_id)
+      case msg
+      when ::String
+        "#{level_str.upcase}: <#{log_id}> " << msg
+      when ::Exception
+        "#{level_str.upcase}: <#{log_id}> #{msg.message} (#{msg.class })\n#{(msg.backtrace || [])[0..3].join("\n")}"
+      else
+        "#{level_str.upcase}: <#{log_id}> " << msg.inspect
+      end
+    end
+
+    # Default logging identifier is the class name. If log_id() method is redefined by the
+    # class including this module, or it sets @log_id, then such a value takes preference.
+    def log_id
+      @log_id ||= (self.is_a?(::Module) ? self.name.split("::").last : self.class.name)
+    end
+
+  end  # module Logger
+
+end

data/lib/oversip/modules/outbound_mangling.rb

@@ -0,0 +1,56 @@
+module OverSIP::Modules
+
+  module OutboundMangling
+
+    extend ::OverSIP::Logger
+
+    @log_id = "OutboundMangling module"
+
+    def self.add_outbound_to_contact proxy
+      unless proxy.is_a? ::OverSIP::SIP::Proxy
+        raise ::OverSIP::RuntimeError, "proxy must be a OverSIP::SIP::Proxy instance"
+      end
+
+      proxy.on_target do |target|
+        request = proxy.request
+        # Just act in case the request has a single Contact, its connection uses Outbound
+        # and  no ;ov-ob param exists in Contact URI.
+        if request.contact and request.connection_outbound_flow_token and not request.contact.has_param? "ov-ob"
+          log_system_debug "performing Contact mangling (adding ;ov-ob Outbound param) for #{request.log_id}"  if $oversip_debug
+
+          request.contact.set_param "ov-ob", request.connection_outbound_flow_token
+
+          proxy.on_success_response do |response|
+            if (contacts = response.headers["Contact"])
+              log_system_debug "reverting original Contact value (removing ;ov-ob Outbound param) from response"  if $oversip_debug
+              contacts.each { |contact| contact.gsub! /;ov-ob=[_\-0-9A-Za-z]+/, "" }
+            end
+          end
+        end
+      end
+    end
+
+    def self.extract_outbound_from_ruri request
+      # Do nothing if the request already contains a Route header with the Outbound flow token (so
+      # the registrar *does* support Path).
+      unless request.incoming_outbound_requested?
+        if (ov_ob = request.ruri.del_param("ov-ob"))
+          log_system_debug "incoming Outbound flow token extracted from ;ov-ob param in RURI for #{request.log_id}"  if $oversip_debug
+          request.route_outbound_flow_token = ov_ob
+          request.incoming_outbound_requested = true
+          return true
+        else
+          return false
+        end
+
+      else
+        # If the request already contains a proper Outbound Route header, then at least try to remove
+        # the ;ov-ob param from the RURI.
+        request.ruri.del_param("ov-ob")
+        return false
+      end
+    end
+
+  end  # module OutboundMangling
+
+end

data/lib/oversip/modules/user_assertion.rb

@@ -0,0 +1,73 @@
+module OverSIP::Modules
+
+  module UserAssertion
+
+    extend ::OverSIP::Logger
+
+    @log_id = "UserAssertion module"
+
+    def self.assert_connection message
+      case message
+      when ::OverSIP::SIP::Request
+        request = message
+      when ::OverSIP::SIP::Response
+        request = message.request
+      else
+        raise ::OverSIP::RuntimeError, "message must be a OverSIP::SIP::Request or OverSIP::SIP::Response"
+      end
+
+      # Don't do this stuf for UDP or for outbound connections.
+      return false  unless request.connection.class.reliable_transport_listener?
+      # Return if already set.
+      return request.cvars[:asserted_user]  if request.cvars[:asserted_user]
+      # Don't do this stuf in case of P-Preferred-Identity header is present.
+      return false  if request.headers["P-Preferred-Identity"]
+
+      log_system_debug "user #{request.from.uri} asserted to connection"  if $oversip_debug
+      # Store the request From URI as "asserted_user" for this connection.
+      request.cvars[:asserted_user] = request.from.uri
+    end
+
+    def self.revoke_assertion message
+      case message
+      when ::OverSIP::SIP::Request
+        request = message
+      when ::OverSIP::SIP::Response
+        request = message.request
+      else
+        raise ::OverSIP::RuntimeError, "message must be a OverSIP::SIP::Request or OverSIP::SIP::Response"
+      end
+
+      request.cvars.delete :asserted_user
+      true
+    end
+
+    def self.add_pai request
+      # Add P-Asserted-Identity if the user has previously been asserted but JUST
+      # in case it matches request From URI !
+      # NOTE: If the connection is not asserted (it's null) then it will not match this
+      # comparisson, so OK.
+      if request.cvars[:asserted_user] == request.from.uri
+        # Don't add P-Asserted-Identity if the request contains P-Preferred-Identity header.
+        unless request.headers["P-Preferred-Identity"]
+          log_system_debug "user asserted, adding P-Asserted-Identity for #{request.log_id}"  if $oversip_debug
+          request.set_header "P-Asserted-Identity", "<" << request.cvars[:asserted_user] << ">"
+          return true
+        else
+          # Remove posible P-Asserted-Identity header!
+          log_system_debug "user asserted but P-Preferred-Identity header present, P-Asserted-Identity not added for #{request.log_id}"  if $oversip_debug
+          request.headers.delete "P-Asserted-Identity"
+          return nil
+        end
+
+      # Otherwise ensure the request has no spoofed P-Asserted-Identity headers!
+      else
+        request.headers.delete "P-Asserted-Identity"
+        return false
+
+      end
+    end
+
+  end  # module UserAssertion
+
+end

data/lib/oversip/proxies_config.rb

@@ -0,0 +1,189 @@
+module OverSIP
+
+  module ProxiesConfig
+
+    extend ::OverSIP::Logger
+    extend ::OverSIP::Config::Validators
+
+    def self.log_id
+      @log_id ||= "ProxiesConfig"
+    end
+
+    @proxy_configuration = {
+      :do_record_routing          => true,
+      :record_route_all           => false,
+      :use_dns                    => true,
+      :use_dns_cache              => true,
+      :dns_cache_time             => 300,
+      :use_blacklist              => true,
+      :blacklist_time             => 10,
+      :use_naptr                  => true,
+      :use_srv                    => true,
+      :transport_preference       => ["tls", "tcp", "udp"],
+      :force_transport_preference => false,
+      :ip_type_preference         => ["ipv6", "ipv4"],
+      :dns_failover_on_503        => true,
+      :timer_B                    => 32,
+      :timer_C                    => 120,
+      :timer_F                    => 32,
+      :callback_on_server_tls_handshake => true
+    }
+
+    PROXY_CONFIG_VALIDATIONS = {
+      :do_record_routing          => :boolean,
+      :record_route_all           => :boolean,
+      :use_dns                    => :boolean, 
+      :use_dns_cache              => :boolean,
+      :dns_cache_time             => [ :fixnum, [ :greater_equal_than, 300 ] ],
+      :use_blacklist              => :boolean,
+      :blacklist_time             => [ :fixnum, [ :greater_equal_than, 2 ], [ :minor_equal_than, 600 ] ],
+      :use_naptr                  => :boolean,
+      :use_srv                    => :boolean,
+      :transport_preference       => [ [ :choices, %w{tls tcp udp}], :multi_value, :non_empty ],
+      :force_transport_preference => :boolean,
+      :ip_type_preference         => [ [ :choices, %w{ipv4 ipv6}], :multi_value, :non_empty ],
+      :dns_failover_on_503        => :boolean,
+      :timer_B                    => [ :fixnum, [ :greater_equal_than, 2 ], [ :minor_equal_than, 64 ] ],
+      :timer_C                    => [ :fixnum, [ :greater_equal_than, 8 ], [ :minor_equal_than, 180 ] ],
+      :timer_F                    => [ :fixnum, [ :greater_equal_than, 2 ], [ :minor_equal_than, 64 ] ],
+      :callback_on_server_tls_handshake => :boolean
+    }
+
+    def self.load proxies_yaml, reload=false
+      begin
+        unless proxies_yaml.is_a? ::Hash
+          raise "invalid proxies configuration file, it is not a collection"
+        end
+
+        proxies = {}
+
+        proxies_yaml.each do |proxy, conf|
+          unless proxy.is_a? ::String
+            raise "proxy name is not a string (#{proxy.inspect})"
+          end
+
+          proxies[proxy.to_sym] = @proxy_configuration.dup
+          proxies[proxy.to_sym].each do |parameter, default_value|
+            proxies[proxy.to_sym][parameter] = case default_value
+            when ::TrueClass, ::FalseClass, ::NilClass, ::Fixnum
+              default_value
+            else
+              default_value.clone
+            end
+          end
+
+          PROXY_CONFIG_VALIDATIONS.each do |parameter, validations|
+            values = proxies_yaml[proxy][parameter.to_s]
+            validations = [ validations ]  unless validations.is_a?(::Array)
+
+            if values == nil
+              if validations.include? :required
+                raise "#{proxy}[#{parameter}] requires a value"
+              end
+              next
+            end
+
+            if values.is_a? ::Array
+              unless validations.include? :multi_value
+                raise "#{proxy}[#{parameter}] does not allow multiple values"
+              end
+
+              if validations.include? :non_empty and values.empty?
+                raise "#{proxy}[#{parameter}] does not allow empty values"
+              end
+            end
+
+            values = ( values.is_a?(::Array) ? values : [ values ] )
+
+            values.each do |value|
+              validations.each do |validation|
+
+                if validation.is_a? ::Symbol
+                  args = []
+                elsif validation.is_a? ::Array
+                  args = validation[1..-1]
+                  validation = validation[0]
+                end
+
+                next if [:required, :multi_value, :non_empty].include? validation
+
+                unless send validation, value, *args
+                  raise "#{proxy}[#{parameter}] has invalid value '#{::OverSIP::Config.humanize_value value}' (does not satisfy '#{validation}' validation requirement)"
+                end
+              end
+
+              proxies[proxy.to_sym][parameter] = ( validations.include?(:multi_value) ? values : values[0] )
+            end
+
+          end  # PROXY_CONFIG_VALIDATIONS[section].each
+        end  # proxies_yaml.each
+
+      rescue ::Exception => e
+        unless reload
+          ::OverSIP::Launcher.fatal e.message
+        else
+          raise ::OverSIP::ConfigurationError, e.message
+        end
+      end
+
+      @proxies = proxies
+      post_process
+
+      ::OverSIP.proxies = @proxies
+    end
+
+
+    def self.post_process
+      @proxies.each_key do |proxy|
+        # Add a string parameter with the proxy name itself.
+        @proxies[proxy][:name] = proxy.to_s
+
+        # If use_srv is not set then ensure use_naptr is also not set.
+        @proxies[proxy][:use_naptr] = false  unless @proxies[proxy][:use_srv]
+
+        # Convert transport values into Symbols.
+        @proxies[proxy][:transport_preference] = @proxies[proxy][:transport_preference].map do |transport|
+          transport.to_sym
+        end
+
+        # Ensure there are not duplicate transports.
+        @proxies[proxy][:transport_preference].uniq!
+
+        # Remove transports that are not supported.
+        @proxies[proxy][:transport_preference].delete :tls  unless ::OverSIP.configuration[:sip][:sip_tls]
+        @proxies[proxy][:transport_preference].delete :tcp  unless ::OverSIP.configuration[:sip][:sip_tcp]
+        @proxies[proxy][:transport_preference].delete :udp  unless ::OverSIP.configuration[:sip][:sip_udp]
+
+        # Convert IP type values into Symbols.
+        @proxies[proxy][:ip_type_preference] = @proxies[proxy][:ip_type_preference].map do |ip_type|
+          ip_type.to_sym
+        end
+
+        # Ensure there are not duplicate IP types.
+        @proxies[proxy][:ip_type_preference].uniq!
+
+        # Remove IP types that are not supported.
+        @proxies[proxy][:ip_type_preference].delete :ipv4  unless ::OverSIP.configuration[:sip][:listen_ipv4]
+        @proxies[proxy][:ip_type_preference].delete :ipv6  unless ::OverSIP.configuration[:sip][:listen_ipv6]
+
+        # Add new parameters for fast access.
+        @proxies[proxy][:has_sip_ipv4] = @proxies[proxy][:ip_type_preference].include?(:ipv4)
+        @proxies[proxy][:has_sip_ipv6] = @proxies[proxy][:ip_type_preference].include?(:ipv6)
+        @proxies[proxy][:has_sip_udp] = @proxies[proxy][:transport_preference].include?(:udp)
+        @proxies[proxy][:has_sip_tcp] = @proxies[proxy][:transport_preference].include?(:tcp)
+        @proxies[proxy][:has_sip_tls] = @proxies[proxy][:transport_preference].include?(:tls)
+
+        # Add a hash for the DNS cache.
+        @proxies[proxy][:dns_cache] = {}
+
+        # Add a hash for the blacklist.
+        @proxies[proxy][:blacklist] = {}
+        
+        # Only allow record routing for all requsts if record routing is enabled
+        @proxies[proxy][:record_route_all] = false  unless @proxies[proxy][:do_record_routing]
+      end
+    end
+
+  end
+
+end 

data/lib/oversip/ruby_ext/eventmachine.rb

@@ -0,0 +1,38 @@
+module EventMachine
+
+  # Fast method for setting an outgoing TCP connection.
+  def self.oversip_connect_tcp_server bind_addr, server, port, klass, *args
+    s = bind_connect_server bind_addr, 0, server, port
+    c = klass.new s, *args
+    @conns[s] = c
+    block_given? and yield c
+    c
+  end
+
+
+  class Connection
+
+    # We require Ruby 1.9 so don't check String#bytesize method.
+    def send_data data
+      ::EventMachine::send_data @signature, data, data.bytesize
+    end
+
+    def send_datagram data, address, port
+      ::EventMachine::send_datagram @signature, data, data.bytesize, address, port
+    end
+
+    # Rewrite close_connection so it set an internal attribute (which can be
+    # inspected when unbind() callback is called).
+    alias _em_close_connection close_connection
+    def close_connection after_writing=false
+      @local_closed = true
+      _em_close_connection after_writing
+    end
+
+    def close_connection_after_writing
+      close_connection true
+    end
+
+  end
+
+end