oversip 0.9.0

data/lib/oversip/sip/server_transaction.rb

@@ -0,0 +1,295 @@
+module OverSIP::SIP
+
+  class ServerTransaction
+
+    include ::OverSIP::Logger
+
+    attr_reader :request
+    attr_accessor :last_response, :core
+    attr_reader :state
+
+    def initialize request
+      @request = request
+      @request.server_transaction = self
+      @transaction_id = request.via_branch_id
+    end
+
+    def retransmit_last_response
+      @request.send_response @last_response  if @last_response
+    end
+
+  end  # class ServerTransaction
+
+
+  class InviteServerTransaction < ServerTransaction
+
+    def initialize request
+      super
+      @request.connection.class.invite_server_transactions[@transaction_id] = self
+
+      @log_id = "IST #{@transaction_id}"
+      # Can be :proceeding, :completed, :confirmed, :accepted or :terminated.
+      @state = :proceeding
+
+      # NOTE: This is a timer of INVITE client transactions, but we also need it here to avoid
+      # that an INVITE server transaction never ends.
+      start_timer_C2
+
+      @request.reply 100
+    end
+
+    def start_timer_G
+      @timer_G_interval = TIMER_G
+      @timer_G = ::EM::PeriodicTimer.new(@timer_G_interval) do
+        log_system_debug "timer G expires, retransmitting last response"  if $oversip_debug
+        retransmit_last_response
+        @timer_G_interval = @timer_G.interval = [2*@timer_G_interval, T2].min
+      end
+    end
+
+    def start_timer_H
+      @timer_H = ::EM::Timer.new(TIMER_H) do
+        log_system_debug "timer H expires and no ACK received, transaction terminated"  if $oversip_debug
+        terminate_transaction
+        @timer_G.cancel  if @timer_G
+      end
+    end
+
+    def start_timer_I
+      ::EM.add_timer(TIMER_I_UDP) do
+        log_system_debug "timer I expires, transaction terminated"  if $oversip_debug
+        terminate_transaction
+      end
+    end
+
+    # RFC 6026.
+    def start_timer_L
+      ::EM.add_timer(TIMER_L) do
+        log_system_debug "timer L expires, transaction terminated"  if $oversip_debug
+        terminate_transaction
+      end
+    end
+
+    # Timer to delete the transaction if final response is never sent by the TU.
+    def start_timer_C2
+      @timer_C2 = ::EM::Timer.new(TIMER_C2) do
+        log_system_debug "no final response within #{TIMER_C2} seconds, transaction terminated"  if $oversip_debug
+        terminate_transaction
+      end
+    end
+
+    # This method is called by SipReactor#check_transaction upon receipt of an ACK
+    # matching an INVITE transaction (so it has been rejected with [3456]XX).
+    def receive_ack
+      case @state
+      when :proceeding
+        log_system_debug "ACK received during proceeding state, ignoring it"  if $oversip_debug
+      when :completed
+        log_system_debug "ACK received during completed state, now confirmed"  if $oversip_debug
+        @state = :confirmed
+        @timer_G.cancel  if @timer_G
+        @timer_H.cancel
+        if @request.transport == :udp
+          start_timer_I
+        else
+          terminate_transaction
+        end
+      else
+        log_system_debug "ACK received during #{@state} state, ignoring it"  if $oversip_debug
+      end
+    end
+
+    # This method is called by SipReactor#check_transaction upon receipt of an CANCEL
+    # matching an INVITE transaction.
+    def receive_cancel cancel
+      @core.receive_cancel(cancel)  if @core
+    end
+
+    # Terminate current transaction and delete from the list of transactions.
+    def terminate_transaction
+      @state = :terminated
+      @request.connection.class.invite_server_transactions.delete(@transaction_id)
+    end
+
+    def receive_response status_code
+      # Provisional response
+      if status_code < 200
+        case @state
+        when :proceeding
+          return true
+        else
+          log_system_notice "attempt to send a provisional response while in #{@state} state"
+          return false
+        end
+
+      # 2XX final response.
+      elsif status_code >= 200 and status_code < 300
+        case @state
+        when :proceeding
+          @state = :accepted
+          @timer_C2.cancel
+          start_timer_L
+          return true
+        when :accepted
+          return true
+        else
+          log_system_notice "attempt to send a final 2XX response while in #{@state} state"
+          return false
+        end
+
+      # [3456]XX final response.
+      else
+        case @state
+        when :proceeding
+          @state = :completed
+          @timer_C2.cancel
+          start_timer_G if @request.transport == :udp
+          start_timer_H
+          return true
+        else
+          log_system_notice "attempt to send a final #{status_code} response while in #{@state} state"
+          return false
+        end
+      end
+    end
+
+    def valid_response? status_code
+      # Provisional response
+      if status_code < 200
+        case @state
+        when :proceeding
+          return true
+        else
+          return false
+        end
+
+      # 2XX final response.
+      elsif status_code >= 200 and status_code < 300
+        case @state
+        when :proceeding
+          return true
+        when :accepted
+          return true
+        else
+          return false
+        end
+
+        # [3456]XX final response.
+      else
+        case @state
+        when :proceeding
+          return true
+        else
+          return false
+        end
+      end
+    end
+
+  end  # class InviteServerTransaction
+
+
+  class NonInviteServerTransaction < ServerTransaction
+
+    def initialize request
+      super
+      @request.connection.class.non_invite_server_transactions[@transaction_id] = self
+
+      @log_id = "NIST #{@transaction_id}"
+      # Can be :trying, :proceeding, :completed or :terminated.
+      @state = :trying
+
+      start_timer_INT1
+    end
+
+    # RFC 4320 - Section 4.1.
+    def start_timer_INT1
+      @timer_INT1 = ::EM::Timer.new(INT1) do
+        unless @last_response
+          log_system_debug "no final response within #{INT1} seconds => 100"  if $oversip_debug
+          @request.reply 100, "I'm alive"
+        end
+        start_timer_INT2
+      end
+    end
+
+    # RFC 4320 - Section 4.2.
+    def start_timer_INT2
+      @timer_INT2 = ::EM::Timer.new(INT2) do
+        log_system_debug "no final response within #{INT1+INT2} seconds, transaction terminated"  if $oversip_debug
+        terminate_transaction
+      end
+    end
+
+    def start_timer_J
+      ::EM.add_timer(TIMER_J_UDP) do
+        log_system_debug "timer J expires, transaction terminated"  if $oversip_debug
+        terminate_transaction
+      end
+    end
+
+    # Terminate current transaction and delete from the list of transactions.
+    def terminate_transaction
+      @state = :terminated
+      @request.connection.class.non_invite_server_transactions.delete(@transaction_id)
+    end
+
+    def receive_response(status_code)
+      # Provisional response
+      if status_code < 200
+        case @state
+        when :trying
+          @state = :proceeding
+          return true
+        when :proceeding
+          return true
+        when :completed, :terminated
+          log_system_notice "attempt to send a provisional response while in #{@state} state"
+          return false
+        end
+
+      # Final response.
+      else
+        case @state
+        when :trying, :proceeding
+          @timer_INT1.cancel
+          @timer_INT2.cancel  if @timer_INT2
+          @state = :completed
+          if @request.transport == :udp
+            start_timer_J
+          else
+            terminate_transaction
+          end
+          return true
+        when :completed, :terminated
+          log_system_notice "attempt to send a final response while in #{@state} state"
+          return false
+        end
+      end
+    end
+
+    def valid_response? status_code
+      # Provisional response
+      if status_code < 200
+        case @state
+        when :trying
+          return true
+        when :proceeding
+          return true
+        when :completed, :terminated
+          return false
+        end
+
+      # Final response.
+      else
+        case @state
+        when :trying, :proceeding
+          return true
+        when :completed, :terminated
+          return false
+        end
+      end
+    end
+
+  end  # class NonInviteServerTransaction
+
+end

data/lib/oversip/sip/sip.rb

@@ -0,0 +1,74 @@
+module OverSIP::SIP
+
+  # This hash contains the proxies defined by the user. It will be filled after loading the
+  # configuration (proxies.conf file).
+  PROXIES = {}
+
+  def self.module_init
+    conf = ::OverSIP.configuration
+
+    @local_ipv4 = conf[:sip][:listen_ipv4]
+    @local_ipv6 = conf[:sip][:listen_ipv6]
+
+    @tcp_keepalive_interval = conf[:sip][:tcp_keepalive_interval]
+
+    @local_aliases = {}
+
+    sip_local_domains = conf[:sip][:local_domains] || []
+    sip_local_ips = []
+    sip_local_ips << conf[:sip][:listen_ipv4]  if conf[:sip][:enable_ipv4]
+    sip_local_ips << "[#{OverSIP::Utils.normalize_ipv6(conf[:sip][:listen_ipv6])}]"  if conf[:sip][:enable_ipv6]
+    sip_local_ports = [ conf[:sip][:listen_port], conf[:sip][:listen_port_tls] ].compact
+    sip_local_domains.each do |domain|
+      @local_aliases[domain] = true
+      sip_local_ports.each do |port|
+        @local_aliases["#{domain}:#{port}"] = true
+      end
+    end
+    sip_local_ips.each do |ip|
+      sip_local_ports.each do |port|
+        @local_aliases["#{ip}:#{port}"] = true
+      end
+    end
+    sip_local_ips.each do |ip|
+      @local_aliases[ip] = true  if conf[:sip][:listen_port] == 5060 or conf[:sip][:listen_port_tls] == 5061
+    end
+
+    ws_local_domains = conf[:sip][:local_domains] || []
+    ws_local_ips = []
+    ws_local_ips << conf[:websocket][:listen_ipv4]  if conf[:websocket][:enable_ipv4]
+    ws_local_ips << "[#{OverSIP::Utils.normalize_ipv6(conf[:websocket][:listen_ipv6])}]"  if conf[:websocket][:enable_ipv6]
+    ws_local_ports = [ conf[:websocket][:listen_port], conf[:websocket][:listen_port_tls] ].compact
+    ws_local_domains.each do |domain|
+      @local_aliases[domain] = true
+      ws_local_ports.each do |port|
+        @local_aliases["#{domain}:#{port}"] = true
+      end
+    end
+    ws_local_ips.each do |ip|
+      ws_local_ports.each do |port|
+        @local_aliases["#{ip}:#{port}"] = true
+      end
+    end
+    ws_local_ips.each do |ip|
+      @local_aliases[ip] = true  if conf[:websocket][:listen_port] == 80 or conf[:websocket][:listen_port_tls] == 443
+    end
+  end
+
+  def self.local_aliases
+    @local_aliases
+  end
+
+  def self.tcp_keepalive_interval
+    @tcp_keepalive_interval
+  end
+
+  def self.local_ipv4
+    @local_ipv4
+  end
+
+  def self.local_ipv6
+    @local_ipv6
+  end
+
+end

data/lib/oversip/sip/tags.rb

@@ -0,0 +1,39 @@
+module OverSIP::SIP
+
+  module Tags
+
+    PREFIX_FOR_TOTAG_SL_REPLIED = ::SecureRandom.hex(4) + "."
+    REGEX_PREFIX_FOR_TOTAG_SL_REPLIED = /^#{PREFIX_FOR_TOTAG_SL_REPLIED}/
+
+    ROUTE_OVID_VALUE = ::SecureRandom.hex(4)
+    ROUTE_OVID_VALUE_HASH = ROUTE_OVID_VALUE.hash
+
+    ANTILOOP_CONST = ::SecureRandom.hex(1)
+
+
+    def self.totag_for_sl_reply
+      PREFIX_FOR_TOTAG_SL_REPLIED + ::SecureRandom.hex(4)
+    end
+
+    def self.check_totag_for_sl_reply totag
+      return nil unless totag
+      totag =~ REGEX_PREFIX_FOR_TOTAG_SL_REPLIED
+    end
+
+    def self.value_for_route_ovid
+      ROUTE_OVID_VALUE
+    end
+
+    def self.check_value_for_route_ovid value
+      return nil unless value
+      value.hash == ROUTE_OVID_VALUE_HASH
+    end
+
+    def self.create_antiloop_id request
+      # It produces a 32 chars string.
+      ::Digest::MD5.hexdigest "#{ANTILOOP_CONST}#{request.ruri.uri}#{request.call_id}#{request.routes[0].uri if request.routes}"
+    end
+
+  end
+
+end

data/lib/oversip/sip/timers.rb

@@ -0,0 +1,55 @@
+module OverSIP::SIP
+
+  ### SIP timer values.
+  #
+  # RTT Estimate (RFC 3261 17.1.2.1).
+  T1          = 0.5
+  # The maximum retransmit interval for non-INVITE requests and INVITE
+  # responses (RFC 3261 17.1.2.2).
+  T2          = 4
+  # Maximum duration a message will remain in the network (RFC 3261 17.1.2.2).
+  T4          = 5
+  # INVITE request retransmit interval, for UDP only (RFC 3261 17.1.1.2).
+  TIMER_A     = T1  # initially T1.
+  # INVITE transaction timeout timer (RFC 3261 17.1.1.2).
+  TIMER_B     = 64*T1
+  # Proxy INVITE transaction timeout (RFC 3261 16.6 bullet 11).
+  TIMER_C     = 180  # > 3min.
+  # NOTE: This is a custom timer we use for INVITE server transactions in order to avoid they never end.
+  TIMER_C2    = TIMER_C + 2
+  # Wait time for response retransmits (RFC 3261 17.1.1.2).
+  TIMER_D_UDP = 32  # > 32s for UDP.
+  TIMER_D_TCP = 0   # 0s for TCP/SCTP.
+  # Non-INVITE request retransmit interval, UDP only (RFC 3261 17.1.2.2).
+  TIMER_E     = T1  # initially T1
+  # Non-INVITE transaction timeout timer.
+  TIMER_F     = 64*T1
+  # INVITE response retransmit interval (RFC 3261 17.2.1).
+  TIMER_G     = T1  # initially T1.
+  # Wait time for ACK receipt (RFC 3261 17.2.1).
+  TIMER_H     = 64*T1
+  # Wait time for ACK retransmits (RFC 3261 17.2.1).
+  TIMER_I_UDP = T4  # T4 for UDP.
+  TIMER_I_TCP = 0   # 0s for TCP/SCTP.
+  # Wait time for non-INVITE requests (RFC 3261 17.2.2).
+  TIMER_J_UDP = 64*T1  # 64*T1 for UDP.
+  TIMER_J_TCP = 0      # 0s for TCP/SCTP.
+  # Wait time for response retransmits (RFC 3261 17.1.2.2).
+  TIMER_K_UDP = T4  # T4 for UDP.
+  TIMER_K_TCP = 0   # 0s for TCP/SCTP.
+  # Wait time for accepted INVITE request retransmits (RFC 6026 17.2.1).
+  TIMER_L     = 64*T1
+  # Wait time for retransmission of 2xx to INVITE or additional 2xx from
+  # other branches of a forked INVITE (RFC 6026 17.1.1).
+  TIMER_M     = 64*T1
+
+  ### Custom values.
+  #
+  # Interval waiting in a non INVITE server transaction before sending 100
+  # (RFC 4320 - Section 4.1).
+  INT1        = T2 + 1
+  # Interval waiting in a non INVITE server transaction before assuming
+  # timeout (RFC 4320 - Section 4.2).
+  INT2        = TIMER_F - INT1
+
+end

data/lib/oversip/sip/transport_manager.rb

@@ -0,0 +1,129 @@
+module OverSIP::SIP
+
+  module TransportManager
+
+    extend ::OverSIP::Logger
+
+    @log_id = "TransportManager"
+    @outbound_connections = {}
+
+
+    # Get an existing connection or create a new one (TCP/TLS).
+    # For UDP it always return the single UDP reactor instance.
+    # client_transaction is passed when creating a new clien transaction. In case the
+    # outgoing connection is a TCP/TLS client connection and it's not connected yet,
+    # the client transaction is stored in the @pending_client_transactions of the client
+    # connection.
+    # This method always returns a connection object, never nil or false.
+    def self.get_connection klass, ip, port, client_transaction=nil, tls_validation=false
+      # A normal connection (so we arrive here after RFC 3263 procedures).
+      case klass.transport
+
+      # In UDP there is a single connection (the UDP server unique instance).
+      when :udp
+        conn = klass.connections
+
+      # In TCP/TLS first check if there is an existing connection to the given destination.
+      # If not create a new one.
+      when :tcp
+        case klass.ip_type
+          when :ipv4
+            conn = klass.connections["#{ip}_#{port}"] || ::EM.oversip_connect_tcp_server(::OverSIP::SIP.local_ipv4, ip, port, IPv4TcpClient, ip, port)
+
+            if conn.is_a? ::OverSIP::SIP::IPv4TcpClient and not conn.connected
+              conn.pending_client_transactions << client_transaction
+            end
+          when :ipv6
+            conn = klass.connections["#{::OverSIP::Utils.normalize_ipv6 ip}_#{port}"] || ::EM.oversip_connect_tcp_server(::OverSIP::SIP.local_ipv6, ip, port, IPv6TcpClient, ip, port)
+
+            if conn.is_a? ::OverSIP::SIP::IPv6TcpClient and not conn.connected
+              conn.pending_client_transactions << client_transaction
+            end
+          end
+
+      when :tls
+        case klass.ip_type
+          when :ipv4
+            conn = klass.connections["#{ip}_#{port}"] || ::EM.oversip_connect_tcp_server(::OverSIP::SIP.local_ipv4, ip, port, IPv4TlsClient, ip, port)
+
+            if conn.is_a? ::OverSIP::SIP::IPv4TlsClient and not conn.connected
+              conn.tls_validation = tls_validation
+              conn.pending_client_transactions << client_transaction
+            end
+          when :ipv6
+            conn = klass.connections["#{::OverSIP::Utils.normalize_ipv6 ip}_#{port}"] || ::EM.oversip_connect_tcp_server(::OverSIP::SIP.local_ipv6, ip, port, IPv6TlsClient, ip, port)
+
+            if conn.is_a? ::OverSIP::SIP::IPv6TlsClient and not conn.connected
+              conn.tls_validation = tls_validation
+              conn.pending_client_transactions << client_transaction
+            end
+          end
+      end
+
+      # NOTE: Should never happen.
+      unless conn
+        log_system_error "no connection (nil) retrieved from TransportManager.get_connection(), FIXME, it should never occur!!!"
+        raise "no connection (nil) retrieved from TransportManager.get_connection(), FIXME, it should never occur!!!"
+      end
+      conn
+    end
+
+
+    def self.add_connection server, server_class, ip_type, ip, port
+      connection_id = case ip_type
+        when :ipv4
+          "#{ip}_#{port}"
+        when :ipv6
+          "#{::OverSIP::Utils.normalize_ipv6 ip}_#{port}"
+        end
+
+      server_class.connections[connection_id] = server
+
+      # Return the connection_id.
+      connection_id
+    end
+
+
+    # Return a SIP server instance. It could return nil (if the requested connection no longer
+    # exists) or false (if it's a tampered flow token).
+    def self.get_outbound_connection flow_token
+      # If the token flow has been generated for UDP it is "_" followed by the Base64
+      # encoded representation of "IP_port", so getbyte(0) would return 95.
+      if flow_token.getbyte(0) == 95
+        # NOTE: Doing Base64.decode64 automatically removes the leading "_".
+        # NOTE: Previously when the Outbound flow token was generated, "=" was replaced with "-" so it becomes
+        # valid for a SIP URI param (in case of using Contact mangling if the registrar does not support Path).
+        ip_type, ip, port = ::OverSIP::Utils.parse_outbound_udp_flow_token(::Base64.decode64 flow_token.gsub(/-/,"="))
+
+        case ip_type
+          when :ipv4
+            return [ ::OverSIP::SIP::IPv4UdpServer.connections, ip, port ]
+          when :ipv6
+            return [ ::OverSIP::SIP::IPv6UdpServer.connections, ip, port ]
+          else
+            log_system_notice "udp flow token does not contain valid IP and port encoded value"
+            return false
+          end
+
+      # It not, the flow token has been generated for a TCP/TLS/WS connection so let's lookup
+      # it into the Outbound connection collection and return nil for IP and port.
+      else
+        @outbound_connections[flow_token]
+      end
+    end
+
+
+    def self.add_outbound_connection connection
+      outbound_flow_token = ::SecureRandom.hex(5)
+      @outbound_connections[outbound_flow_token] = connection
+      outbound_flow_token
+    end
+
+
+    def self.delete_outbound_connection outbound_flow_token
+      @outbound_connections.delete outbound_flow_token
+    end
+
+  end  # module TransportManager
+
+end