oversip 0.9.0

data/lib/oversip/websocket/ws_framing.rb

@@ -0,0 +1,597 @@
+module OverSIP::WebSocket
+
+  class WsFraming
+
+    include ::OverSIP::Logger
+
+    OPCODE = {
+      0  => :continuation,
+      1  => :text,
+      2  => :binary,
+      8  => :close,
+      9  => :ping,
+      10 => :pong
+    }
+
+    keepalive_ping_frame = "".encode ::Encoding::BINARY
+    keepalive_ping_frame << 137
+    keepalive_ping_frame << "keep-alive".bytesize
+    keepalive_ping_frame << "keep-alive".encode(::Encoding::BINARY)
+    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
+
+
+    def log_id
+      @log_id ||= "WsFramming #{@connection.connection_log_id}"
+    end
+
+
+    def initialize connection, buffer
+      @connection = connection
+      @buffer = buffer
+      @utf8_validator = ::OverSIP::WebSocket::FramingUtils::Utf8Validator.allocate
+      @state = :init
+    end
+
+
+    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
+        @connection.send_data KEEPALIVE_PING_FRAME
+      end
+    end
+
+
+    def receive_data
+      while (case @state
+        when :init
+          return false  if @buffer.size < 2
+
+          byte1 = @buffer.read(1).getbyte(0)
+          byte2 = @buffer.read(1).getbyte(0)
+
+          # FIN is the bit 0.
+          @fin = (byte1 & 0b10000000) == 0b10000000
+
+          # RSV1-3 are bits 1-3.
+          @rsv1 = (byte1 & 0b01000000) == 0b01000000
+          @rsv2 = (byte1 & 0b00100000) == 0b00100000
+          @rsv3 = (byte1 & 0b00010000) == 0b00010000
+
+          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"
+            return false
+          end
+
+          # opcode are bits 4-7.
+          @opcode = byte1 & 0b00001111
+          unless (@sym_opcode = OPCODE[@opcode])
+            send_close_frame 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"
+            return false
+          end
+
+          # payload_len are bits 9-15.
+          length = byte2 & 0b01111111
+
+          case length
+          # Length defined by 8 bytes.
+          when 127
+            @state = :payload_length_8_bytes
+          # Length defined by 2 bytes.
+          when 126
+            @state = :payload_length_2_bytes
+          # Length defined by already received 7 bits.
+          else
+            @payload_length = length
+            @state = :masking_key
+          end
+
+          @payload = nil
+          true
+
+        when :payload_length_2_bytes
+          return false  if @buffer.size < 2
+
+          # Get the payload length and remove first two bytes fro
+          # the buffer at the same time.
+          @payload_length = @buffer.read(2).unpack('n').first
+
+          @state = :masking_key
+          true
+
+        when :payload_length_8_bytes
+          return false  if @buffer.size < 8
+
+          # Get the payload length.
+          # NOTE: Just take the last 4 bytes (4 GB frame is enough!!!),
+          # Check that first 4 bytes are 0000. If not then the frame is bigger
+          # than 4 GB and must be rejected!
+
+          if @buffer.read(4).unpack('N').first != 0
+            log_system_notice "frame size bigger than 4 GB, rejected"
+            send_close_frame 1008
+            return false
+          end
+
+          @payload_length = @buffer.read(4).unpack('N').first
+
+          @state = :masking_key
+          true
+
+        when :masking_key
+          return false  if @buffer.size < 4
+
+          # Get the masking key (4 bytes) and remove first 4 bytes
+          # from the buffer.
+          @masking_key = @buffer.read(4)
+
+          @state = :check_frame
+          true
+
+        when :check_frame
+          # All control frames MUST have a payload length of 125 bytes or
+          # 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
+            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"
+            return false
+          end
+
+          # A continuation frame can only arrive if previously a text/binary frame
+          # 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"
+            return false
+          end
+
+          # If a previous frame had FIN=0 and opcode=text/binary, then it cannot arrive
+          # 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"
+            return false
+          end
+
+          # Check max frame size.
+          if @payload_length > @@max_frame_size
+            send_close_frame 1009, "frame too big"
+            return false
+          end
+
+          @state = :payload_data
+          true
+
+        when :payload_data
+          return false  if @buffer.size < @payload_length
+
+          unless @payload_length.zero?
+            # NOTE: @payload will always be Encoding::BINARY
+            @payload = ::OverSIP::WebSocket::FramingUtils.unmask @buffer.read(@payload_length), @masking_key
+          end
+          # NOTE: @payload could be nil.
+
+          @state = :process_frame
+          true
+
+        when :process_frame
+          # Set it here as it could be changed later in this block.
+          @state = :init
+
+          case @sym_opcode
+
+          when :text
+            log_system_debug "received text frame: FIN=#{@fin}, RSV1-3=#{@rsv1}/#{@rsv2}/#{@rsv3}, payload_length=#{@payload_length}"  if $oversip_debug
+
+            # Store the opcode of the first frame (if there is more frames for same message
+            # they will have opcode=continuation).
+            @msg_sym_opcode = @sym_opcode
+
+            # Reset the UTF8 validator.
+            @utf8_validator.reset
+
+            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"
+                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"
+                return false
+              end
+
+              return false  unless @ws_app.receive_payload_data @payload
+            end
+
+            # If message is finished tell it to the WS application.
+            if @fin
+              @ws_app.message_done @msg_sym_opcode
+              @msg_sym_opcode = nil
+            end
+
+          when :binary
+            log_system_debug "received binary frame: FIN=#{@fin}, RSV1-3=#{@rsv1}/#{@rsv2}/#{@rsv3}, payload_length=#{@payload_length}"  if $oversip_debug
+
+            # Store the opcode of the first frame (if there is more frames for same message
+            # they will have opcode=continuation).
+            @msg_sym_opcode = @sym_opcode
+
+            if @payload
+              return false  unless @ws_app.receive_payload_data @payload
+            end
+
+            # If message is finished tell it to the WS application.
+            if @fin
+              @ws_app.message_done @msg_sym_opcode
+              @msg_sym_opcode = nil
+            end
+
+          when :continuation
+            log_system_debug "received continuation frame: FIN=#{@fin}, RSV1-3=#{@rsv1}/#{@rsv2}/#{@rsv3}, payload_length=#{@payload_length}"  if $oversip_debug
+
+            if @payload
+              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"
+                  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"
+                  return false
+                end
+              end
+
+              return false  unless @ws_app.receive_payload_data @payload
+            end
+
+            # If message is finished tell it to the WS application.
+            if @fin
+              @ws_app.message_done @msg_sym_opcode
+              @msg_sym_opcode = nil
+            end
+
+          when :close
+            if @payload_length >= 2
+              status = ""
+              status << @payload.getbyte(0) << @payload.getbyte(1)
+              status =  status.unpack('n').first
+              if (reason = @payload[2..-1])
+                # Reset the UTF8 validator.
+                @utf8_validator.reset
+
+                # The UTF-8 validator returns:
+                # - true: Valid UTF-8 string.
+                # - nil: Valid but not terminated UTF-8 string.
+                # - false: Invalid UTF-8 string.
+                # 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"
+                  return false
+                end
+              end
+            else
+              status = nil
+            end
+
+            case status
+            when 1002
+              log_system_notice "received close frame due to WS protocol error: status=1002, reason=#{reason.inspect}"
+            when 1003
+              log_system_notice "received close frame due to sent data type: status=1003, reason=#{reason.inspect}"
+            when 1007
+              log_system_notice "received close frame due to non valid UTF-8 data sent: status=1007, reason=#{reason.inspect}"
+            when 1009
+              log_system_notice "received close frame due to too big message sent: status=1009, reason=#{reason.inspect}"
+            when 1010
+              log_system_notice "received close frame due to extensions negotiation failure: status=1010, reason=#{reason.inspect}"
+            else
+              log_system_debug "received close frame: status=#{status.inspect}, reason=#{reason.inspect}"  if $oversip_debug
+            end
+
+            send_close_frame nil, nil, true
+            return false
+
+          when :ping
+            log_system_debug "received ping frame: payload_length=#{@payload_length}"  if $oversip_debug
+            send_pong_frame @payload
+
+          when :pong
+            log_system_debug "received pong frame: payload_length=#{@payload_length}"  if $oversip_debug
+
+          end
+
+          true
+
+        when :ws_closed
+          false
+
+        when :tcp_closed
+          false
+
+        end)
+      end # while
+
+    end  # receive_data
+
+
+    def control_frame?
+      @opcode > 2
+    end
+
+
+    def text_or_binary_frame?
+      @opcode == 1 or @opcode == 2
+    end
+
+
+    def continuation_frame?
+      @opcode == 0
+    end
+
+
+    # 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
+
+      # byte1 = OPCODE_TO_INT[:text] | 0b10000000 => 129
+      #
+      # - FIN bit set.
+      # - RSV1-3 bits not set.
+      # - opcode = 1
+      frame << 129
+
+      length = message.bytesize
+      if length <= 125
+        frame << length # since rsv4 is 0
+      elsif length < 65536 # write 2 byte length
+        frame << 126
+        frame << [length].pack('n')
+      else # write 8 byte length
+        frame << 127
+        frame << [length >> 32, length & 0xFFFFFFFF].pack("NN")
+      end
+
+      if message.encoding == ::Encoding::BINARY
+        frame << message
+      else
+        frame << message.force_encoding(::Encoding::BINARY)
+      end
+
+      @connection.send_data frame
+      true
+    end
+
+
+    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
+
+      # byte1 = OPCODE_TO_INT[:binary] | 0b10000000 => 130
+      #
+      # - FIN bit set.
+      # - RSV1-3 bits not set.
+      # - opcode = 2
+      frame << 130
+
+      length = message.bytesize
+      if length <= 125
+        frame << length # since rsv4 is 0
+      elsif length < 65536 # write 2 byte length
+        frame << 126
+        frame << [length].pack('n')
+      else # write 8 byte length
+        frame << 127
+        frame << [length >> 32, length & 0xFFFFFFFF].pack("NN")
+      end
+
+      if message.encoding == ::Encoding::BINARY
+        frame << message
+      else
+        frame << message.force_encoding(::Encoding::BINARY)
+      end
+
+      @connection.send_data frame
+      true
+    end
+
+
+    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
+        log_system_debug "sending ping frame: payload_length=0"  if $oversip_debug
+      end
+
+      frame = "".encode ::Encoding::BINARY
+
+      # byte1 = OPCODE_TO_INT[:ping] | 0b10000000 => 137
+      #
+      # - FIN bit set.
+      # - RSV1-3 bits not set.
+      # - opcode = 9
+      frame << 137
+
+      length = ( data ? data.bytesize : 0 )
+      frame << length
+
+      if data
+        if data.encoding == ::Encoding::BINARY
+          frame << data
+        else
+          frame << data.force_encoding(::Encoding::BINARY)
+        end
+      end
+
+      @connection.send_data frame
+      true
+    end
+
+
+    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
+        log_system_debug "sending pong frame: payload_length=0"  if $oversip_debug
+      end
+
+      frame = "".encode ::Encoding::BINARY
+
+      # byte1 = OPCODE_TO_INT[:pong] | 0b10000000 => 138
+      #
+      # - FIN bit set.
+      # - RSV1-3 bits not set.
+      # - opcode = 10
+      frame << 138
+
+      length = ( data ? data.bytesize : 0 )
+      frame << length
+
+      if data
+        if data.encoding == ::Encoding::BINARY
+          frame << data
+        else
+          frame << data.force_encoding(::Encoding::BINARY)
+        end
+      end
+
+      @connection.send_data frame
+      true
+    end
+
+
+    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_notice "sending close frame: status=#{status.inspect}, reason=#{reason.inspect}"
+      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
+
+      # byte1 = OPCODE_TO_INT[:close] | 0b10000000 => 136
+      #
+      # - FIN bit set.
+      # - RSV1-3 bits not set.
+      # - opcode = 8
+      frame << 136
+      if status
+        length = ( reason ? 2 + reason.bytesize : 2 )
+      else
+        length = 0
+      end
+
+      frame << length # since rsv4 is 0
+      if status
+        frame << [status].pack('n')
+        if reason
+          if reason.encoding == ::Encoding::BINARY
+            frame << reason
+          else
+            frame << reason.force_encoding(::Encoding::BINARY)
+          end
+        end
+      end
+
+      @connection.ignore_incoming_data
+      @connection.send_data frame
+
+      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.
+        EM.add_timer(0.2) do
+          @connection.close_connection_after_writing
+        end
+      else
+        @connection.close_connection_after_writing
+      end
+      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

data/lib/oversip.rb

@@ -0,0 +1,59 @@
+# Ruby built-in libraries.
+
+require "etc"
+require "fileutils"
+require "socket"
+require "timeout"
+require "yaml"
+require "tempfile"
+
+
+# Ruby external gems.
+
+require "term/ansicolor"
+require "posix_mq"
+
+
+# OverSIP files.
+
+require "oversip/version.rb"
+require "oversip/logger.rb"
+require "oversip/config.rb"
+require "oversip/config_validators.rb"
+require "oversip/proxies_config.rb"
+require "oversip/errors.rb"
+require "oversip/launcher.rb"
+require "oversip/utils.so"
+require "oversip/utils.rb"
+require "oversip/posix_mq.rb"
+
+
+
+
+module OverSIP
+
+  class << self
+    attr_accessor :pid_file, :master_name, :master_pid, :daemonized,
+                  :syslogger_pid, :syslogger_mq_name,
+                  :configuration,
+                  :proxies,
+                  :tls, :tls_public_cert, :tls_private_cert, :tls_proxy_ipv4, :tls_proxy_ipv6
+
+    def master?
+      @master_pid == $$
+    end
+
+    def daemonized?
+      @daemonized
+    end
+
+    def syslogger_ready?
+      @syslogger_pid and true
+    end
+  end
+
+  # Pre-declare internal modules.
+  module SIP ; end
+  module WebSocket ; end
+
+end

data/test/oversip_test_helper.rb

@@ -0,0 +1,20 @@
+require "test/unit"
+require "oversip"
+require "oversip/master_process"
+
+
+class OverSIPTest < Test::Unit::TestCase
+
+  def assert_true(object, message="")
+    assert_equal(object, true, message)
+  end
+
+  def assert_false(object, message="")
+    assert_equal(object, false, message)
+  end
+
+  def assert_equal_options(options, element)
+    assert options.include?(element)
+  end
+
+end