oversip 1.1.0.beta5 → 1.1.0

data/lib/oversip/websocket/listeners/{tcp_server.rb → ws_server.rb}

@@ -1,10 +1,8 @@
 module OverSIP::WebSocket
 
-  class TcpServer < ::EM::Connection
+  class WsServer < Connection
 
-    include ::OverSIP::Logger
-
-    # Max size (bytes) of the buffered data when receiving message headers
+   # Max size (bytes) of the buffered data when receiving HTTP headers
     # (avoid DoS attacks).
     HEADERS_MAX_SIZE = 2048
 
@@ -13,23 +11,25 @@ module OverSIP::WebSocket
     HDR_SUPPORTED_WEBSOCKET_VERSIONS = [ "X-Supported-WebSocket-Versions: #{WS_VERSIONS.keys.join(", ")}" ]
 
 
-    class << self
-      attr_accessor :ip_type, :transport
-    end
+    attr_reader :outbound_flow_token
+    attr_writer :ws_established, :client_closed
+
 
-    attr_accessor :ws_protocol, :ws_app_klass
-    attr_reader :connection_log_id, :remote_ip_type, :remote_ip, :remote_port
-    attr_reader :cvars  # A Hash for storing user provided data.
-    attr_accessor :ws_locally_closed
+    def remote_ip_type
+      @remote_ip_type || self.class.ip_type
+    end
 
+    def remote_ip
+      @remote_ip
+    end
 
-    def initialize
-      @http_parser = ::OverSIP::WebSocket::HttpRequestParser.new
-      @buffer = ::IO::Buffer.new
-      @state = :init
-      @cvars = {}
+    def remote_port
+      @remote_port
     end
 
+    def transport
+      self.class.transport
+    end
 
     def post_connection
       begin
@@ -40,9 +40,13 @@ module OverSIP::WebSocket
         @state = :ignore
         return
       end
-      @connection_log_id = ::SecureRandom.hex(4)
 
-      log_system_info "connection opened from " << remote_desc
+      @connection_id = ::OverSIP::SIP::TransportManager.add_connection self, self.class, self.class.ip_type, @remote_ip, @remote_port
+
+      # Create an Outbound (RFC 5626) flow token for this connection.
+      @outbound_flow_token = ::OverSIP::SIP::TransportManager.add_outbound_connection self
+
+      log_system_debug("connection opened from " << remote_desc)  if $oversip_debug
     end
 
 
@@ -62,7 +66,16 @@ module OverSIP::WebSocket
 
 
     def unbind cause=nil
+      @state = :ignore
+
+      # Remove the connection.
+      self.class.connections.delete @connection_id
+
+      # Remove the Outbound token flow.
+      ::OverSIP::SIP::TransportManager.delete_outbound_connection @outbound_flow_token
+
       @local_closed = true  if cause == ::Errno::ETIMEDOUT
+      @local_closed = false  if @client_closed
 
       if $oversip_debug
         log_msg = "connection from #{remote_desc} "
@@ -71,11 +84,9 @@ module OverSIP::WebSocket
         log_system_debug log_msg
       end unless $!
 
-      @ws_framing.tcp_closed  if @ws_framing
-
-      if @ws_handshake_done
+      if @ws_established
         begin
-          ::OverSIP::WebSocketEvents.on_disconnection self, !@ws_locally_closed
+          ::OverSIP::WebSocketEvents.on_disconnection self, !@local_closed
         rescue ::Exception => e
           log_system_error "error calling OverSIP::WebSocketEvents.on_disconnection():"
           log_system_error e
@@ -90,8 +101,8 @@ module OverSIP::WebSocket
 
       while (case @state
         when :init
+          @http_parser = ::OverSIP::WebSocket::HttpRequestParser.new
           @http_request = ::OverSIP::WebSocket::HttpRequest.new
-          @http_parser.reset
           @http_parser_nbytes = 0
           @bytes_remaining = 0
           @state = :http_headers
@@ -103,14 +114,13 @@ module OverSIP::WebSocket
           check_http_request
 
         when :ws_connection_callback
-          check_ws_connection_callback
+          ws_connection_callback
 
         when :accept_ws_handshake
           accept_ws_handshake
 
-        when :websocket_frames
-          return false  if @buffer.size.zero?
-
+        when :websocket
+          @ws_established = true
           @ws_framing.receive_data
           false
 
@@ -147,10 +157,6 @@ module OverSIP::WebSocket
       @buffer.read(@http_parser_nbytes)
 
       @http_request.connection = self
-      @http_request.transport = self.class.transport
-      @http_request.source_ip = @remote_ip
-      @http_request.source_port = @remote_port
-      @http_request.source_ip_type = @remote_ip_type ||= self.class.ip_type
 
       @state = :check_http_request
       true
@@ -200,7 +206,7 @@ module OverSIP::WebSocket
 
       # Check Sec-WebSocket-Protocol.
       if @http_request.hdr_sec_websocket_protocol
-        if @http_request.hdr_sec_websocket_protocol.include? @ws_protocol
+        if @http_request.hdr_sec_websocket_protocol.include? WS_SIP_PROTOCOL
           @websocket_protocol_negotiated = true
         else
           log_system_notice "Sec-WebSocket-Protocol does not contain a supported protocol but #{@http_request.hdr_sec_websocket_protocol} => 501"
@@ -214,7 +220,7 @@ module OverSIP::WebSocket
     end
 
 
-    def check_ws_connection_callback
+    def ws_connection_callback
       begin
         ::OverSIP::WebSocketEvents.on_connection self, @http_request
       rescue ::Exception => e
@@ -245,7 +251,7 @@ module OverSIP::WebSocket
       ]
 
       if @websocket_protocol_negotiated
-        extra_headers << "Sec-WebSocket-Protocol: #{@ws_protocol}"
+        extra_headers << "Sec-WebSocket-Protocol: #{WS_SIP_PROTOCOL}"
       end
 
       if @websocket_extensions
@@ -254,12 +260,12 @@ module OverSIP::WebSocket
 
       @http_request.reply 101, nil, extra_headers
 
-      # Set the WS framming layer and WS application layer.
-      @ws_framing = ::OverSIP::WebSocket::WsFraming.new(self, @buffer)
-      @ws_framing.ws_app = @ws_app_klass.new(self, @ws_framing)
+      # Set the WS framing layer and WS application layer.
+      @ws_framing = ::OverSIP::WebSocket::WsFraming.new self, @buffer
+      ws_sip_app = ::OverSIP::WebSocket::WsSipApp.new self, @ws_framing
+      @ws_framing.ws_app = ws_sip_app
 
-      @ws_handshake_done = true
-      @state = :websocket_frames
+      @state = :websocket
       true
     end
 
@@ -271,12 +277,26 @@ module OverSIP::WebSocket
     end
 
 
-    def ignore_incoming_data
-      @state = :ignore  # The WS application needs to set the connection in :ignore state
-                        # after sending a close frame to the client.
+    # Parameters ip and port are just included because they are needed in UDP, so the API remains equal.
+    def send_sip_msg msg, ip=nil, port=nil
+      if self.error?
+        log_system_notice "SIP message could not be sent, connection is closed"
+        return false
+      end
+
+      # If the SIP message is fully valid UTF-8 send a WS text frame.
+      if msg.force_encoding(::Encoding::UTF_8).valid_encoding?
+        @ws_framing.send_text_frame msg
+
+      # If not, send a WS binary frame.
+      else
+        @ws_framing.send_binary_frame msg
+      end
+
+      true
     end
 
-  end  # class TcpServer
+  end
 
 end
 

data/lib/oversip/websocket/listeners/{tls_server.rb → wss_server.rb}

@@ -1,8 +1,8 @@
 module OverSIP::WebSocket
 
-  class TlsServer < TcpServer
+  class WssServer < WsServer
 
-    TLS_HANDSHAKE_MAX_TIME = 8
+    TLS_HANDSHAKE_MAX_TIME = 4
 
 
     def post_init
@@ -44,25 +44,26 @@ module OverSIP::WebSocket
     def ssl_handshake_completed
       log_system_info "TLS connection established from " << remote_desc
 
-      # TODO: What to do it falidation fails? always do validation?
-
-      validated, cert, tls_error, tls_error_string = ::OverSIP::TLS.validate @client_pems.pop, @client_pems
-      if validated
-        log_system_info "client provides a valid TLS certificate"
-      else
-        log_system_notice "client's TLS certificate validation failed (TLS error: #{tls_error.inspect}, description: #{tls_error_string.inspect})"
-      end
-
-      # @connected in TlsServer means "TLS connection" rather than
+      # @connected in WssServer means "TLS connection" rather than
       # just "TCP connection".
       @connected = true
       @timer_tls_handshake.cancel  if @timer_tls_handshake
+
+      if ::OverSIP::WebSocket.callback_on_client_tls_handshake
+        begin
+          ::OverSIP::WebSocketEvents.on_client_tls_handshake self, @client_pems
+        rescue ::Exception => e
+          log_system_error "error calling OverSIP::WebSocketEvents.on_client_tls_handshake():"
+          log_system_error e
+          close_connection
+        end
+      end
     end
 
 
     def unbind cause=nil
-      @timer_tls_handshake.cancel  if @timer_tls_handshake
       super
+      @timer_tls_handshake.cancel  if @timer_tls_handshake
     end
 
   end

data/lib/oversip/websocket/listeners/{tls_tunnel_server.rb → wss_tunnel_server.rb}

@@ -1,16 +1,10 @@
 module OverSIP::WebSocket
 
-  class TlsTunnelServer < TcpServer
-
-    def initialize
-      @http_parser = ::OverSIP::WebSocket::HttpRequestParser.new
-      @buffer = ::IO::Buffer.new
-      @state = :init
-    end
-
+  class WssTunnelServer < WsServer
 
     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"
@@ -18,9 +12,40 @@ module OverSIP::WebSocket
         @state = :ignore
         return
       end
-      @connection_log_id = ::SecureRandom.hex(4)
 
-      log_system_info "connection from the TLS tunnel " << remote_desc
+      # 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 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 $!
+
+      if @state == :websocket
+        begin
+          ::OverSIP::WebSocketEvents.on_disconnection self, !@local_closed
+        rescue ::Exception => e
+          log_system_error "error calling OverSIP::WebSocketEvents.on_disconnection():"
+          log_system_error e
+        end
+      end unless $!
     end
 
 
@@ -30,6 +55,7 @@ module OverSIP::WebSocket
 
       while (case @state
         when :init
+          @http_parser = ::OverSIP::WebSocket::HttpRequestParser.new
           @http_request = ::OverSIP::WebSocket::HttpRequest.new
           @http_parser.reset
           @http_parser_nbytes = 0

data/lib/oversip/websocket/listeners.rb

@@ -1,12 +1,13 @@
 # OverSIP files
 
-require "oversip/websocket/listeners/tcp_server"
-require "oversip/websocket/listeners/tls_server"
-require "oversip/websocket/listeners/tls_tunnel_server"
+require "oversip/websocket/listeners/connection"
+require "oversip/websocket/listeners/ws_server"
+require "oversip/websocket/listeners/wss_server"
+require "oversip/websocket/listeners/wss_tunnel_server"
 
-require "oversip/websocket/listeners/ipv4_tcp_server"
-require "oversip/websocket/listeners/ipv6_tcp_server"
-require "oversip/websocket/listeners/ipv4_tls_server"
-require "oversip/websocket/listeners/ipv6_tls_server"
-require "oversip/websocket/listeners/ipv4_tls_tunnel_server"
-require "oversip/websocket/listeners/ipv6_tls_tunnel_server"
+require "oversip/websocket/listeners/ipv4_ws_server"
+require "oversip/websocket/listeners/ipv6_ws_server"
+require "oversip/websocket/listeners/ipv4_wss_server"
+require "oversip/websocket/listeners/ipv6_wss_server"
+require "oversip/websocket/listeners/ipv4_wss_tunnel_server"
+require "oversip/websocket/listeners/ipv6_wss_tunnel_server"

data/lib/oversip/websocket/websocket.rb

@@ -0,0 +1,13 @@
+module OverSIP::WebSocket
+
+  def self.module_init
+    conf = ::OverSIP.configuration
+
+    @callback_on_client_tls_handshake = conf[:websocket][:callback_on_client_tls_handshake]
+  end
+
+  def self.callback_on_client_tls_handshake
+    @callback_on_client_tls_handshake
+  end
+
+end

data/lib/oversip/websocket/ws_framing.rb

@@ -20,16 +20,17 @@ module OverSIP::WebSocket
     KEEPALIVE_PING_FRAME = keepalive_ping_frame
 
 
-    attr_writer :ws_app
-
-
     def self.class_init
       @@max_frame_size = ::OverSIP.configuration[:websocket][:max_ws_frame_size]
     end
 
 
+    attr_writer :ws_app
+
+
+    LOG_ID = "WsFraming"
     def log_id
-      @log_id ||= "WsFramming #{@connection.connection_log_id}"
+      LOG_ID
     end
 
 
@@ -43,7 +44,7 @@ module OverSIP::WebSocket
 
     def do_keep_alive interval
       @keep_alive_timer = ::EM::PeriodicTimer.new(interval) do
-        log_system_debug "sending keep-alive ping frame: payload_length=10"  if $oversip_debug
+        log_system_debug "sending keep-alive ping frame"  if $oversip_debug
         @connection.send_data KEEPALIVE_PING_FRAME
       end
     end
@@ -67,21 +68,21 @@ module OverSIP::WebSocket
 
           if @rsv1 or @rsv2 or @rsv3
             log_system_notice "frame has RSV bits set, clossing the connection"
-            send_close_frame 1002, "RSV bit set not supported"
+            @connection.close 1002, "RSV bit set not supported"
             return false
           end
 
           # opcode are bits 4-7.
           @opcode = byte1 & 0b00001111
           unless (@sym_opcode = OPCODE[@opcode])
-            send_close_frame 1002, "unknown opcode=#{@opcode}"
+            @connection.close 1002, "unknown opcode=#{@opcode}"
             return false
           end
 
           # MASK is bit 8.
           @mask = (byte2 & 0b10000000) == 0b10000000
           unless @mask
-            send_close_frame 1002, "MASK bit not set"
+            @connection.close 1002, "MASK bit not set"
             return false
           end
 
@@ -124,7 +125,7 @@ module OverSIP::WebSocket
 
           if @buffer.read(4).unpack('N').first != 0
             log_system_notice "frame size bigger than 4 GB, rejected"
-            send_close_frame 1008
+            @connection.close 1008
             return false
           end
 
@@ -148,13 +149,13 @@ module OverSIP::WebSocket
           # less and MUST NOT be fragmented.
           if control_frame? and @payload_length > 125
             log_system_notice "received invalid control frame (payload_length > 125), sending close frame"
-            send_close_frame 1002
+            @connection.close 1002
             return false
           end
 
           if control_frame? and not @fin
             log_system_notice "received invalid control frame (FIN=0), sending close frame"
-            send_close_frame 1002, "forbidden FIN=0 in control frame"
+            @connection.close 1002, "forbidden FIN=0 in control frame"
             return false
           end
 
@@ -162,7 +163,7 @@ module OverSIP::WebSocket
           # arrived with FIN=0.
           if continuation_frame? and not @msg_sym_opcode
             log_system_notice "invalid continuation frame received (no previous unfinished message), sending close frame"
-            send_close_frame 1002, "invalid continuation frame received"
+            @connection.close 1002, "invalid continuation frame received"
             return false
           end
 
@@ -170,13 +171,13 @@ module OverSIP::WebSocket
           # a new frame with opcode=text/binary.
           if @msg_sym_opcode and text_or_binary_frame?
             log_system_notice "invalid text/binary frame received (expecting a continuation frame), sending close frame"
-            send_close_frame 1002, "expected a continuation frame"
+            @connection.close 1002, "expected a continuation frame"
             return false
           end
 
           # Check max frame size.
           if @payload_length > @@max_frame_size
-            send_close_frame 1009, "frame too big"
+            @connection.close 1009, "frame too big"
             return false
           end
 
@@ -214,17 +215,22 @@ module OverSIP::WebSocket
             if @payload
               if (valid_utf8 = @utf8_validator.validate(@payload)) == false
                 log_system_notice "received single text frame contains invalid UTF-8, closing the connection"
-                send_close_frame 1007, "single text frame contains invalid UTF-8"
+                @connection.close 1007, "single text frame contains invalid UTF-8"
                 return false
               end
 
               if @fin and not valid_utf8
                 log_system_notice "received single text frame contains incomplete UTF-8, closing the connection"
-                send_close_frame 1007, "single text frame contains incomplete UTF-8"
+                @connection.close 1007, "single text frame contains incomplete UTF-8"
                 return false
               end
 
-              return false  unless @ws_app.receive_payload_data @payload
+              # If @ws_app.receive_payload_data returns false it means that total
+              # message size is too big.
+              unless @ws_app.receive_payload_data @payload
+                @connection.close 1009, "message too big"
+                return false
+              end
             end
 
             # If message is finished tell it to the WS application.
@@ -241,7 +247,12 @@ module OverSIP::WebSocket
             @msg_sym_opcode = @sym_opcode
 
             if @payload
-              return false  unless @ws_app.receive_payload_data @payload
+              # If @ws_app.receive_payload_data returns false it means that total
+              # message size is too big.
+              unless @ws_app.receive_payload_data @payload
+                @connection.close 1009, "message too big"
+                return false
+              end
             end
 
             # If message is finished tell it to the WS application.
@@ -257,13 +268,13 @@ module OverSIP::WebSocket
               if @msg_sym_opcode == :text
                 if (valid_utf8 = @utf8_validator.validate(@payload)) == false
                   log_system_notice "received continuation text frame contains invalid UTF-8, closing the connection"
-                  send_close_frame 1007, "continuation text frame contains invalid UTF-8"
+                  @connection.close 1007, "continuation text frame contains invalid UTF-8"
                   return false
                 end
 
                 if @fin and not valid_utf8
                   log_system_notice "received continuation final text frame contains incomplete UTF-8, closing the connection"
-                  send_close_frame 1007, "continuation final text frame contains incomplete UTF-8"
+                  @connection.close 1007, "continuation final text frame contains incomplete UTF-8"
                   return false
                 end
               end
@@ -293,7 +304,7 @@ module OverSIP::WebSocket
                 # So it must be true for the close frame reason.
                 unless @utf8_validator.validate(reason)
                   log_system_notice "received close frame with invalid UTF-8 data in the reason: status=#{status.inspect}"
-                  send_close_frame 1007, "close frame reason contains incomplete UTF-8"
+                  @connection.close 1007, "close frame reason contains incomplete UTF-8"
                   return false
                 end
               end
@@ -316,7 +327,8 @@ module OverSIP::WebSocket
               log_system_debug "received close frame: status=#{status.inspect}, reason=#{reason.inspect}"  if $oversip_debug
             end
 
-            send_close_frame nil, nil, true
+            @connection.client_closed = true
+            @connection.close nil, nil
             return false
 
           when :ping
@@ -329,13 +341,6 @@ module OverSIP::WebSocket
           end
 
           true
-
-        when :ws_closed
-          false
-
-        when :tcp_closed
-          false
-
         end)
       end # while
 
@@ -359,14 +364,6 @@ module OverSIP::WebSocket
 
     # NOTE: A WS message is always set in a single WS frame.
     def send_text_frame message
-      case @state
-      when :ws_closed
-        log_system_debug "cannot send text frame, WebSocket session is closed"  if $oversip_debug
-        return false
-      when :tcp_closed
-        log_system_debug "cannot send text frame, TCP session is closed"  if $oversip_debug
-        return false
-      end
       log_system_debug "sending text frame: payload_length=#{message.bytesize}"  if $oversip_debug
 
       frame = "".encode ::Encoding::BINARY
@@ -401,14 +398,6 @@ module OverSIP::WebSocket
 
 
     def send_binary_frame message
-      case @state
-      when :ws_closed
-        log_system_debug "cannot send binary frame, WebSocket session is closed"  if $oversip_debug
-        return false
-      when :tcp_closed
-        log_system_debug "cannot send binary frame, TCP session is closed"  if $oversip_debug
-        return false
-      end
       log_system_debug "sending binary frame: payload_length=#{message.bytesize}"  if $oversip_debug
 
       frame = "".encode ::Encoding::BINARY
@@ -443,14 +432,6 @@ module OverSIP::WebSocket
 
 
     def send_ping_frame data=nil
-      case @state
-      when :ws_closed
-        log_system_debug "cannot send ping frame, WebSocket session is closed"  if $oversip_debug
-        return false
-      when :tcp_closed
-        log_system_debug "cannot send ping frame, TCP session is closed"  if $oversip_debug
-        return false
-      end
       if data
         log_system_debug "sending ping frame: payload_length=#{data.bytesize}"  if $oversip_debug
       else
@@ -483,14 +464,6 @@ module OverSIP::WebSocket
 
 
     def send_pong_frame data=nil
-      case @state
-      when :ws_closed
-        log_system_debug "cannot send pong frame, WebSocket session is closed"  if $oversip_debug
-        return false
-      when :tcp_closed
-        log_system_debug "cannot send pong frame, TCP session is closed"  if $oversip_debug
-        return false
-      end
       if data
         log_system_debug "sending pong frame: payload_length=#{data.bytesize}"  if $oversip_debug
       else
@@ -525,22 +498,12 @@ module OverSIP::WebSocket
     def send_close_frame status=nil, reason=nil, in_reply_to_close=nil
       @keep_alive_timer.cancel  if @keep_alive_timer
 
-      case @state
-      when :ws_closed
-        log_system_debug "cannot send close frame, WebSocket session is closed"  if $oversip_debug
-        return false
-      when :tcp_closed
-        log_system_debug "cannot send close frame, TCP session is closed"  if $oversip_debug
-        return false
-      end
-
       unless in_reply_to_close
         log_system_debug "sending close frame: status=#{status.inspect}, reason=#{reason.inspect}"  if $oversip_debug
       else
         log_system_debug "sending reply close frame: status=#{status.inspect}, reason=#{reason.inspect}"  if $oversip_debug
       end
 
-      @state = :ws_closed
       @buffer.clear
 
       frame = "".encode ::Encoding::BINARY
@@ -569,35 +532,10 @@ module OverSIP::WebSocket
         end
       end
 
-      @connection.ignore_incoming_data
       @connection.send_data frame
-
-      # NOTE: Don't do it since it "seems" that the connection has been closed
-      # by the client.
-      #unless in_reply_to_close
-        # Let's some time for the client to send us a close frame (it will
-        # be ignored anyway) before closing the TCP connection.
-        # NOTE: Don't do it since it "seems" that the connection has been closed
-        # by the client.
-        #::EM.add_timer(0.2) do
-          #@connection.close_connection_after_writing
-        #end
-      #else
-        #@connection.close_connection_after_writing
-      #end
-
-      @connection.close_connection_after_writing
       true
     end
 
-
-    def tcp_closed
-      @keep_alive_timer.cancel  if @keep_alive_timer
-      @state = :tcp_closed
-      # Tell it to the WS application.
-      @ws_app.tcp_closed rescue nil
-    end
-
-  end  # class WsFraming
+  end
 
 end