oversip_p 1.0.0

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

@@ -0,0 +1,89 @@
+module OverSIP::SIP
+
+  class TlsTunnelConnection < TcpConnection
+
+    # Max size (bytes) of the buffered data when receiving message headers
+    # (avoid DoS attacks).
+    HEADERS_MAX_SIZE = 16384
+
+    def process_received_data
+      @state == :ignore and return
+
+      while (case @state
+        when :init
+          @parser.reset
+          @parser_nbytes = 0
+          # If it's a TCP connection from the TLS tunnel then parse the HAProxy Protocol line
+          # if it's not yet done.
+          unless @haproxy_protocol_parsed
+            @state = :haproxy_protocol
+          else
+            @state = :headers
+          end
+
+        when :haproxy_protocol
+          parse_haproxy_protocol
+
+        when :headers
+          parse_headers
+
+        when :body
+          get_body
+
+        when :finished
+          if @msg.request?
+            process_request
+          else
+            process_response
+          end
+
+          # Set state to :init.
+          @state = :init
+          # Return true to continue processing possible remaining data.
+          true
+
+        when :ignore
+          false
+        end)
+      end  # while
+
+    end
+
+    def parse_haproxy_protocol
+      if (haproxy_protocol_data = ::OverSIP::Utils.parse_haproxy_protocol(@buffer.to_str))
+        @haproxy_protocol_parsed = true
+
+        # Update connection information.
+        @remote_ip_type = haproxy_protocol_data[1]
+        @remote_ip = haproxy_protocol_data[2]
+        @remote_port = haproxy_protocol_data[3]
+
+        # Add the connection with the client's source data. Note that we pass a TlsServer as class, but
+        # the server instance is a TcpServer.
+        @connection_id = case @remote_ip_type
+          when :ipv4
+            ::OverSIP::SIP::TransportManager.add_connection self, ::OverSIP::SIP::IPv4TlsServer, :ipv4, @remote_ip, @remote_port
+          when :ipv6
+            ::OverSIP::SIP::TransportManager.add_connection self, ::OverSIP::SIP::IPv6TlsServer, :ipv6, @remote_ip, @remote_port
+          end
+
+        # Update log information.
+        remote_desc true
+
+        # Remove the HAProxy Protocol line from the received data.
+        @buffer.read haproxy_protocol_data[0]
+
+        @state = :headers
+
+      else
+        log_system_error "HAProxy Protocol parsing error, closing connection"
+        close_connection_after_writing
+        @state = :ignore
+        return false
+      end
+    end
+
+  end
+
+end
+

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

@@ -0,0 +1,61 @@
+module OverSIP::SIP
+
+  class TlsTunnelServer < TlsTunnelConnection
+
+    attr_reader :outbound_flow_token
+
+    def post_connection
+      begin
+        # Temporal @remote_ip and @remote_port until the HAProxy protocol line is parsed.
+        @remote_port, @remote_ip = ::Socket.unpack_sockaddr_in(get_peername)
+      rescue => e
+        log_system_error "error obtaining remote IP/port (#{e.class}: #{e.message}), closing connection"
+        close_connection
+        @state = :ignore
+        return
+      end
+
+      # Create an Outbound (RFC 5626) flow token for this connection.
+      @outbound_flow_token = ::OverSIP::SIP::TransportManager.add_outbound_connection self
+
+      log_system_debug ("connection from the TLS tunnel " << remote_desc)  if $oversip_debug
+    end
+
+    def remote_desc force=nil
+      if force
+        @remote_desc = case @remote_ip_type
+          when :ipv4  ; "#{@remote_ip}:#{@remote_port.to_s}"
+          when :ipv6  ; "[#{@remote_ip}]:#{@remote_port.to_s}"
+          end
+      else
+        @remote_desc ||= case self.class.ip_type
+          when :ipv4  ; "#{@remote_ip}:#{@remote_port.to_s}"
+          when :ipv6  ; "[#{@remote_ip}]:#{@remote_port.to_s}"
+          end
+      end
+    end
+
+
+    def unbind cause=nil
+      @state = :ignore
+
+      # Remove the connection.
+      self.class.connections.delete @connection_id  if @connection_id
+
+      # Remove the Outbound token flow.
+      ::OverSIP::SIP::TransportManager.delete_outbound_connection @outbound_flow_token
+
+      @local_closed = true  if cause == ::Errno::ETIMEDOUT
+
+      if $oversip_debug
+        log_msg = "connection from the TLS tunnel #{remote_desc} "
+        log_msg << ( @local_closed ? "locally closed" : "remotely closed" )
+        log_msg << " (cause: #{cause.inspect})"  if cause
+        log_system_debug log_msg
+      end unless $!
+    end
+
+  end
+
+end
+

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

@@ -0,0 +1,214 @@
+module OverSIP::SIP
+
+  class UdpConnection < Connection
+
+    def receive_data data
+      @buffer << data
+
+      while (case @state
+        when :init
+          @parser.reset
+          @parser_nbytes = 0
+          @state = :message
+
+        when :message
+          parse_message
+
+        when :finished
+          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? @parser
+        @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
+      unless $!
+        log_system_crit "UDP socket closed!!! cause: #{cause.inspect}"
+      end
+    end
+
+  end
+
+end
+

data/lib/oversip/sip/listeners.rb

@@ -0,0 +1,24 @@
+# OverSIP files
+
+require "oversip/sip/listeners/connection"
+require "oversip/sip/listeners/udp_connection"
+require "oversip/sip/listeners/tcp_connection"
+require "oversip/sip/listeners/tls_tunnel_connection"
+require "oversip/sip/listeners/tcp_server"
+require "oversip/sip/listeners/tls_server"
+require "oversip/sip/listeners/tls_tunnel_server"
+require "oversip/sip/listeners/tcp_client"
+require "oversip/sip/listeners/tls_client"
+
+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/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/message.rb

@@ -0,0 +1,177 @@
+module OverSIP::SIP
+
+  class Message
+
+    include ::OverSIP::Logger
+
+    DIALOG_FORMING_METHODS = { :INVITE=>true, :SUBSCRIBE=>true, :REFER=>true }
+    RECORD_ROUTING_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 wss?               ; @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 contact_reg_id?    ; @contact_has_reg_id         end
+
+    def dialog_forming?
+      DIALOG_FORMING_METHODS[@sip_method]
+    end
+
+    def record_routing_aware?
+      RECORD_ROUTING_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.unshift 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
+
+    # Close the connection from which the SIP request/response has been
+    # received.
+    def close_connection
+      return false  if @transport == :udp
+      @connection.close
+      true
+    end
+
+  end  # class Message
+
+end