oversip 0.9.0

data/lib/oversip/sip/listeners/udp_reactor.rb

@@ -0,0 +1,213 @@
+module OverSIP::SIP
+
+  class UdpReactor < Reactor
+
+    def receive_data data
+      @buffer << data
+
+      while (case @state
+        when :init
+          @parser.reset
+          @parser_nbytes = 0
+          @state = :message
+
+        when :message
+          parse_message
+
+        when :finished
+          # Invoke the custom logic for requests.
+          if @msg.request?
+            process_request
+          else
+            process_response
+          end
+          @state = :init
+          false
+        end)
+      end  # while
+    end
+
+    def parse_message
+      return false if @buffer.empty?
+
+      buffer_str = @buffer.to_str
+
+      # Quikly ignore single CRLF (widely used by SIP UDP clients as keep-alive.
+      if buffer_str == CRLF
+        @buffer.clear
+        @state = :init
+        return false
+      end
+
+      begin
+        source_port, source_ip = ::Socket.unpack_sockaddr_in(get_peername)
+      rescue => e
+        log_system_crit "error obtaining remote IP/port (#{e.class}: #{e.message})"
+        @buffer.clear
+        @state = :init
+        return false
+      end
+
+      case stun_res = ::OverSIP::Stun.parse_request(buffer_str, source_ip, source_port)
+        # Not a STUN request so continue with SIP parsing.
+        when nil
+        # An invalid STUN request, log it and drop it.
+        when false
+          log_system_debug "invalid STUN message received (not a valid STUN Binding Request)"  if $oversip_debug
+          @buffer.clear
+          @state = :init
+          return false
+        # A valid STUN Binding Request so we get a response to be sent.
+        when String
+          log_system_debug "STUN Binding Request received, replying to it"  if $oversip_debug
+          send_data stun_res
+          @buffer.clear
+          @state = :init
+          return false
+        end          
+
+      # Parse the currently buffered data. If parsing fails @parser_nbytes gets nil value.
+      unless @parser_nbytes = @parser.execute(buffer_str, @parser_nbytes)
+        # The parsed data is invalid, however some data could be parsed so @parsed.parsed
+        # can be:
+        # - SIP::Request
+        # - SIP::Response
+        # - nil (the message is so wrong that cannot be neither a request or response).
+        if wrong_message = @parser.parsed
+          log_system_warn "parsing error for #{MSG_TYPE[wrong_message.class]}: \"#{@parser.error}\""
+        else
+          log_system_warn "parsing error: \"#{@parser.error}\""
+        end
+
+        @buffer.clear
+        @state = :init
+        return false
+      end
+
+      unless @parser.finished?
+        # The parsing has not finished.
+        # If UDP it's invalid as per RFC 3261 a UDP datagram MUST contain an entire
+        # SIP request or response. Note we also allow double CRLF in UDP. If just a
+        # single CRLF arrives ignore it and clear the buffer.
+        # Maybe the parser has gone enought data to determine if the unfinished
+        # message is a SIP request or response, log it if so.
+        # If not, then @parser.parsed returns nil and nothing is logged.
+        unfinished_msg = @parser.parsed
+        log_system_warn "ignoring not finished #{MSG_TYPE[unfinished_msg.class]} via UDP" if
+          unfinished_msg.is_a? ::OverSIP::SIP::Request or unfinished_msg.is_a? ::OverSIP::SIP::Response
+        # Clear the buffer, set :init state and wait for new messages.
+        @buffer.clear
+        @state = :init
+        return false
+      end
+
+      # At this point we've got a SIP::Request, SIP::Response or :outbound_keepalive symbol.
+      @msg = @parser.parsed
+
+      # Clear parsed data from the buffer.
+      @buffer.read(@parser_nbytes)
+
+      # Received data is a Outbound keealive (also allowed in UDP however). Reply single CRLF.
+      if @msg == :outbound_keepalive
+        log_system_debug "Outbound keepalive received, replying single CRLF"  if $oversip_debug
+        # Reply a single CRLF over the same connection.
+        send_data CRLF
+        # If UDP there could be invalid data after double CRLF CRLF, just ignore it
+        # and clear the buffer. Set :init state and return false so we leave receive_data()
+        # method.
+        @buffer.clear
+        @state = :init
+        return false
+      end
+
+      @parser.post_parsing
+
+      # Here we have received the entire headers of a SIP request or response. Fill some
+      # attributes.
+      @msg.connection = self
+      @msg.transport = :udp
+      @msg.source_ip = source_ip
+      @msg.source_port = source_port
+      @msg.source_ip_type = self.class.ip_type
+
+      unless valid_message?
+        @buffer.clear
+        @state = :init
+        return false
+      end
+
+      add_via_received_rport if @msg.request?
+
+      unless check_via_branch
+        @buffer.clear
+        @state = :init
+        return false
+      end
+
+      # Examine Content-Length header.
+      # There is Content-Length header.
+      if cl = @msg.content_length and cl > 0
+        # Body size is correct. Read it and clear the buffer.
+        # Set :finished state and return true so message will be processed.
+        if cl == @buffer.size
+          @msg.body = @buffer.read.force_encoding(::Encoding::UTF_8)
+          @buffer.clear
+          @state = :finished
+          return true
+        # In UDP the remaining data after headers must be the entire body
+        # and fill exactly Content-Length bytes. If not it's invalid. Reply
+        # 400 and clear the buffer.
+        else
+          if @msg.request?
+            unless @msg.sip_method == :ACK
+              log_system_warn "request body size doesn't match Content-Length => 400"
+              @msg.reply 400, "Body size doesn't match Content-Length"
+            else
+              log_system_warn "ACK body size doesn't match Content-Length, ignoring it"
+            end
+          else
+            log_system_warn "response body size doesn't match Content-Length, ignoring it"
+          end
+          @buffer.clear
+          @state = :init
+          return false
+        end
+      # No Content-Length header or 0 value. However it could occur that the datagram
+      # contains remaining unuseful data, in this case reply 400. If not
+      # set :finished state and return true so message will be processed.
+      else
+        # Ensure there is no more data in the buffer. If it's ok set :finished
+        # state and return true so message will be processed.
+        if @buffer.size.zero?
+          @state = :finished
+          return true
+        # Non valid remaining data in the UDP datagram. Reply 400.
+        else
+          if @msg.request?
+            log_system_warn "request contains body but Content-Length is zero or not present => 400"
+            @msg.reply 400, "request contains body but Content-Length is zero or not present"
+          else
+            log_system_warn "response contains body but Content-Length is zero or not present, ignoring it"
+          end
+          @buffer.clear
+          @state = :init
+          return false
+        end
+      end
+
+    end  # parse_headers
+
+    def send_sip_msg msg, ip, port
+      send_datagram msg, ip, port
+      true
+    end
+
+
+    def unbind cause=nil
+      log_system_crit "UDP socket closed!!! cause: #{cause.inspect}"
+    end
+
+  end  # class UdpReactor
+
+end
+

data/lib/oversip/sip/listeners.rb

@@ -0,0 +1,28 @@
+# OverSIP files
+
+require "oversip/sip/listeners/reactor"
+
+require "oversip/sip/listeners/udp_reactor"
+require "oversip/sip/listeners/tcp_reactor"
+require "oversip/sip/listeners/tls_tunnel_reactor"
+
+require "oversip/sip/listeners/tcp_server"
+require "oversip/sip/listeners/tls_server"
+require "oversip/sip/listeners/tls_tunnel_server"
+
+require "oversip/sip/listeners/ipv4_udp_server"
+require "oversip/sip/listeners/ipv6_udp_server"
+require "oversip/sip/listeners/ipv4_tcp_server"
+require "oversip/sip/listeners/ipv6_tcp_server"
+require "oversip/sip/listeners/ipv4_tls_server"
+require "oversip/sip/listeners/ipv6_tls_server"
+require "oversip/sip/listeners/ipv4_tls_tunnel_server"
+require "oversip/sip/listeners/ipv6_tls_tunnel_server"
+
+require "oversip/sip/listeners/tcp_client"
+require "oversip/sip/listeners/tls_client"
+
+require "oversip/sip/listeners/ipv4_tcp_client"
+require "oversip/sip/listeners/ipv6_tcp_client"
+require "oversip/sip/listeners/ipv4_tls_client"
+require "oversip/sip/listeners/ipv6_tls_client"

data/lib/oversip/sip/logic.rb

@@ -0,0 +1,14 @@
+module OverSIP::SIP
+
+  class Logic
+
+    include ::OverSIP::Logger
+
+    def initialize request
+      @log_id = "Logic " << request.via_branch_id
+      @request = request
+    end
+
+  end  # class Logic
+
+end

data/lib/oversip/sip/message.rb

@@ -0,0 +1,168 @@
+module OverSIP::SIP
+
+  class Message
+
+    include ::OverSIP::Logger
+
+    DIALOG_FORMING_METHODS = { :INVITE=>true, :SUBSCRIBE=>true, :REFER=>true }
+    LOOSE_RECORD_AWARE_METHODS = { :INVITE=>true, :REGISTER=>true, :SUBSCRIBE=>true, :REFER=>true }
+    OUTBOUND_AWARE_METHODS = { :INVITE=>true, :REGISTER=>true, :SUBSCRIBE=>true, :REFER=>true }
+    EMPTY_ARRAY = [].freeze
+
+    # SIP related attributes.
+    attr_accessor :transport
+    attr_accessor :source_ip
+    attr_accessor :source_ip_type
+    attr_accessor :source_port
+    attr_accessor :connection
+
+    # SIP message attributes.
+    attr_reader :sip_method
+    attr_reader :sip_version
+    attr_reader :headers
+
+    attr_reader :via_sent_by_host
+    attr_reader :via_sent_by_port
+    attr_reader :via_branch
+    attr_accessor :via_branch_id  # It's the branch value without "z9hG4bK".
+    attr_reader :via_branch_rfc3261
+    attr_reader :via_received
+    attr_reader :via_has_rport
+    attr_accessor :via_rport  # Value not parsed.
+    attr_reader :via_has_alias
+    attr_reader :via_core_value
+    attr_reader :via_params
+    attr_reader :num_vias
+
+    attr_reader :call_id
+    attr_reader :cseq
+    attr_reader :max_forwards
+    attr_reader :content_length
+    attr_reader :routes
+    attr_reader :require
+    attr_reader :supported
+    attr_reader :proxy_require
+
+    attr_accessor :body
+
+    attr_accessor :from  # NameAddr instance.
+    attr_reader :from_tag
+    attr_accessor :to  # NameAddr instance.
+    attr_reader :to_tag
+    attr_reader :contact  # NameAddr instance (when it has a single value).
+    attr_reader :contact_params
+
+    attr_reader :hdr_via  # Array
+    attr_reader :hdr_from  # String
+    attr_reader :hdr_to  # String
+    attr_reader :hdr_route  # Array
+
+    # Other attributes.
+    attr_accessor :tvars  # Transaction variables (a hash).
+
+
+    def udp?               ; @transport == :udp          end
+    def tcp?               ; @transport == :tcp          end
+    def tls?               ; @transport == :tls          end
+    def ws?                ; @transport == :ws           end
+    def tls?               ; @transport == :wss          end
+
+    def websocket?         ; @transport == :ws || @transport == :wss  end
+
+    def unknown_method?    ; @is_unknown_method          end
+
+    def via_rport?         ; @via_has_rport              end
+
+    def via_alias?         ; @via_has_alias              end
+
+    def dialog_forming?
+      DIALOG_FORMING_METHODS[@sip_method]
+    end
+
+    def loose_record_aware?
+      LOOSE_RECORD_AWARE_METHODS[@sip_method]
+    end
+
+    def outbound_aware?
+      OUTBOUND_AWARE_METHODS[@sip_method]
+    end
+
+    # Returns true if a header with the given header _name_ exists, false otherwise.
+    def has_header? name
+      @headers[MessageParser.headerize(name)] && true
+    end
+
+    # Returns the first value of the given header _name_, nil if it doesn't exist.
+    def header_top name
+      ( hdr = @headers[MessageParser.headerize(name)] ) ? hdr[0] : nil
+    end
+    alias :header :header_top
+
+    # Returns an array with all the values of the given header _name_, an empty array
+    # if it doesn't exist.
+    def header_all name
+      ( hdr = @headers[MessageParser.headerize(name)] ) ? hdr : EMPTY_ARRAY
+    end
+
+    # Replaces the header of given _name_ with a the given _value_.
+    # _value_ can be a single value or an array.
+    def set_header name, value
+      @headers[MessageParser.headerize(name)] =
+        case value
+        when Array
+          value
+        else
+          [ value.to_s ]
+        end
+    end
+
+    # Completely deletes the header with given _name_.
+    # Returns an array containing all the header values, nil otherwise.
+    def delete_header name
+      @headers.delete MessageParser.headerize(name)
+    end
+
+    # Removes the first value of a given header _name_.
+    # Returns the extracted value, nil otherwise.
+    def delete_header_top name
+      if hdr = @headers[k=MessageParser.headerize(name)]
+        hdr.size > 1 ? hdr.shift : @headers.delete(k)[0]
+      end
+    end
+
+    # Inserts the given _value_ in the first position of header _name_.
+    # _value_ must be a string.
+    def insert_header name, value
+      if hdr = @headers[k=MessageParser.headerize(name)]
+        hdr.insert 0, value.to_s
+      else
+        #@headers[k] = [ value.to_s ]
+        # NOTE: If the header name doesn't already exist in the mesage, insert
+        # the new header in the first position of the Hash.
+        @headers = { k => [ value.to_s ] }.merge! @headers
+      end
+    end
+
+    # Append the given _value_ in the last position of header _name_.
+    # _value_ must be a string.
+    def append_header name, value
+      if hdr = @headers[k=MessageParser.headerize(name)]
+        hdr.push value.to_s
+      else
+        @headers[k] = [ value.to_s ]
+      end
+    end
+
+    # Replaces the top value of the given header _name_ with the
+    # string given as argument _value_.
+    def replace_header_top name, value
+      if hdr = @headers[k=MessageParser.headerize(name)]
+        hdr[0] = value.to_s
+      else
+        @headers[k] = [ value.to_s ]
+      end
+    end
+
+  end  # class Message
+
+end

data/lib/oversip/sip/message_processor.rb

@@ -0,0 +1,202 @@
+module OverSIP::SIP
+
+  module MessageProcessor
+
+    # Constants for efficiency.
+    MSG_TYPE = {
+      ::OverSIP::SIP::Request   => "SIP request",
+      ::OverSIP::SIP::Response  => "SIP response",
+      :outbound_keepalive       => "Outbound keepalive"
+    }
+
+
+    def valid_message?
+      if header = @parser.missing_core_header?
+        log_system_notice "ignoring #{MSG_TYPE[@msg.class]} missing #{header} header"
+        return false
+      elsif header = @parser.duplicated_core_header?
+        log_system_notice "ignoring #{MSG_TYPE[@msg.class]} with duplicated #{header} header"
+        return false
+      end
+      return true
+    end
+    private :valid_message?
+
+
+    # Via ;received and ;rport stuff.
+    def add_via_received_rport
+      # - If ;rport is present ;received MUST also be set (RFC 3581).
+      # - If not add ;received according to RFC 3261 rules.
+      if @msg.via_rport?
+        via_received = @msg.source_ip
+        @msg.via_rport = @msg.source_port
+      else
+        via_received = (::OverSIP::Utils.compare_ips(@msg.via_sent_by_host, @msg.source_ip) ? nil : @msg.source_ip)
+      end
+
+      if via_received
+        via_params = ";branch=" << @msg.via_branch  if @msg.via_branch
+        via_params << ";received=" << via_received  if via_received
+        via_params << ";rport=" << @msg.via_rport.to_s  if @msg.via_rport
+        via_params << ";alias"  if @msg.via_alias?
+
+        if @msg.via_params
+          @msg.via_params.each { |k,v| via_params << ( v ? ";#{k}=#{v}" : ";#{k}" ) }
+        end
+
+        @msg.hdr_via[0] = "#{@msg.via_core_value}#{via_params}"
+      end
+    end
+    private :add_via_received_rport
+
+
+    # Reject the message in case it doesn't contain a Via branch compliant with RFC 3261
+    def check_via_branch
+      if @msg.via_branch_rfc3261
+        @msg.via_branch_id = @msg.via_branch[7..-1]  # The branch without "z9hG4bK".
+        return true
+      end
+
+      if @msg.is_a? Request
+        unless @msg.sip_method == :ACK
+          log_system_notice "request doesn't contain a RFC 3261 Via branch => 400"
+          @msg.reply 400, "Via branch non RFC 3261 compliant"
+        else
+          log_system_notice "ACK doesn't contain a RFC 3261 Via branch, ignoring it"
+        end
+      else
+        log_system_notice "response doesn't contain a RFC 3261 Via branch, ignoring it"
+      end
+      false
+    end
+    private :check_via_branch
+
+
+    def process_request
+      # Create a new Logic instance for this request (unless it's a retransmission of the request,
+      # a CANCEL or an ACK for a final non-2XX response).
+      unless check_transaction
+        begin
+          # Create the antiloop identifier for this request.
+          @msg.antiloop_id = ::OverSIP::SIP::Tags.create_antiloop_id(@msg)
+
+          # Check loops.
+          if @msg.antiloop_id == @msg.via_branch_id[-32..-1]
+            @msg.reply 482, "Loop Detected"
+            return
+          end
+
+          # Initialize some attributes for the request (for received responses
+          # it's set in Proxy#receive_response).
+          @msg.tvars = {}
+
+          # Create the Logic instance and run it!
+          OverSIP::SIP::Logic.new(@msg).run
+        rescue => e
+          log_system_error e
+          @msg.reply 503, "Internal Error", ["Content-Type: text/plain"], "#{e.class }: #{e.message}"
+        end
+      end
+    end
+    private :process_request
+
+
+    # Process a received response.
+    def process_response
+      case @msg.sip_method
+      when :INVITE
+        ### TODO: Esto va a petar cuando tenga una clase que hereda de, p.ej, IPv4TcpServer que se llame xxxClient,
+        # ya que en ella no existirá @invite_client_transactions. Tengo que hacer que su @invite_client_transactions
+        # se rellene al de la clase padre al hacer el load de las clases.
+        if client_transaction = self.class.invite_client_transactions[@msg.via_branch_id]
+          client_transaction.receive_response(@msg)
+          return
+        end
+      when :ACK
+      when :CANCEL
+        if client_transaction = self.class.invite_client_transactions[@msg.via_branch_id]
+          client_transaction.receive_response_to_cancel(@msg)
+          return
+        end
+      else
+        if client_transaction = self.class.non_invite_client_transactions[@msg.via_branch_id]
+          client_transaction.receive_response(@msg)
+          return
+        end
+      end
+      log_system_debug "ignoring a response non matching a client transaction (#{@msg.sip_method} #{@msg.status_code})"  if $oversip_debug
+    end
+    private :process_response
+
+
+    # Check transaction.
+    def check_transaction
+      case @msg.sip_method
+
+      when :INVITE
+        if server_transaction = @msg.connection.class.invite_server_transactions[@msg.via_branch_id]
+          # If the retranmission arrives via a different connection (for TCP/TLS) then use
+          # the new one.
+          if @msg.connection == server_transaction.request.connection
+            log_system_debug "INVITE retransmission received"  if $oversip_debug
+          else
+            log_system_debug "INVITE retransmission received via other connection, updating server transaction"  if $oversip_debug
+            server_transaction.request.connection = @msg.connection
+          end
+          server_transaction.retransmit_last_response
+          return true
+        end
+
+      when :ACK
+        # If there is associated INVITE transaction (so it has been rejected)
+        # pass ACK to the transaction.
+        if server_transaction = @msg.connection.class.invite_server_transactions[@msg.via_branch_id]
+          server_transaction.receive_ack
+          return true
+        # Absorb ACK for statelessly generated final responses by us.
+        elsif OverSIP::SIP::Tags.check_totag_for_sl_reply(@msg.to_tag)
+          log_system_debug "absorving ACK for a stateless final response"  if $oversip_debug
+          return true
+        else
+          log_system_debug "passing ACK to the core"  if $oversip_debug
+          return false
+        end
+
+      when :CANCEL
+        if server_transaction = @msg.connection.class.invite_server_transactions[@msg.via_branch_id]
+          case state = server_transaction.state
+          when :proceeding
+            log_system_debug "CANCEL matches an INVITE server transaction in proceeding state => 200"  if $oversip_debug
+            @msg.reply 200, "Cancelled"
+            server_transaction.receive_cancel(@msg)
+          else
+            log_system_debug "CANCEL matches an INVITE server transaction in #{state} state => 200"  if $oversip_debug
+            @msg.reply 200, "Cancelled"
+          end
+        else
+          log_system_debug "CANCEL does not match an INVITE server transaction => 481"  if $oversip_debug
+          @msg.reply 481
+        end
+        return true
+
+      else
+        if server_transaction = @msg.connection.class.non_invite_server_transactions[@msg.via_branch_id]
+          # If the retranmission arrives via a different connection (for TCP/TLS) then use
+          # the new one.
+          if @msg.connection == server_transaction.request.connection
+            log_system_debug "#{server_transaction.request.sip_method} retransmission received"  if $oversip_debug
+          else
+            log_system_debug "#{server_transaction.request.sip_method} retransmission received via other connection, updating server transaction"  if $oversip_debug
+            server_transaction.request.connection = @msg.connection
+          end
+          server_transaction.retransmit_last_response
+          return true
+        end
+
+      end
+    end  # def check_transaction
+    private :check_transaction
+
+  end
+
+end