cosmos 4.4.0 → 4.5.1

data/lib/cosmos/interfaces/tcpip_server_interface.rb

@@ -132,7 +132,7 @@ module Cosmos
             end
           rescue Exception => err
             shutdown_interfaces(@write_interface_infos)
-            Logger.instance.error("Tcpip server write thread unexpectedly died")
+            Logger.instance.error("#{@name}: Tcpip server write thread unexpectedly died")
             Logger.instance.error(err.formatted)
           end
         end
@@ -144,7 +144,7 @@ module Cosmos
             end
           rescue Exception => err
             shutdown_interfaces(@write_interface_infos)
-            Logger.instance.error("Tcpip server write raw thread unexpectedly died")
+            Logger.instance.error("#{@name}: Tcpip server write raw thread unexpectedly died")
             Logger.instance.error(err.formatted)
           end
         end
@@ -298,10 +298,10 @@ module Cosmos
     def change_raw_logging(method)
       if @raw_logger_pair
         @write_interface_infos.each do |interface_info|
-          interface_info.interface.raw_logger_pair.send(method) if interface_info.interface.raw_logger_pair
+          interface_info.interface.raw_logger_pair.public_send(method) if interface_info.interface.raw_logger_pair
         end
         @read_interface_infos.each do |interface_info|
-          interface_info.interface.raw_logger_pair.send(method) if interface_info.interface.raw_logger_pair
+          interface_info.interface.raw_logger_pair.public_send(method) if interface_info.interface.raw_logger_pair
         end
       end
     end
@@ -346,7 +346,7 @@ module Cosmos
             break if @cancel_threads
           end
         rescue => err
-          Logger.instance.error("Tcpip server listen thread unexpectedly died")
+          Logger.instance.error("#{@name}: Tcpip server listen thread unexpectedly died")
           Logger.instance.error(err.formatted)
         end
       end
@@ -372,7 +372,7 @@ module Cosmos
         if not System.instance.acl.allow_addr?(addr)
           # Reject connection
           Cosmos.close_socket(socket)
-          Logger.instance.info "Tcpip server rejected connection from #{hostname}(#{host_ip}):#{port}"
+          Logger.instance.info "#{@name}: Tcpip server rejected connection from #{hostname}(#{host_ip}):#{port}"
           return
         end
       end
@@ -417,7 +417,7 @@ module Cosmos
         end
         start_read_thread(@read_interface_infos[-1])
       end
-      Logger.instance.info "Tcpip server accepted connection from #{hostname}(#{host_ip}):#{port}"
+      Logger.instance.info "#{@name}: Tcpip server accepted connection from #{hostname}(#{host_ip}):#{port}"
     end
 
     def start_read_thread(interface_info)
@@ -427,10 +427,10 @@ module Cosmos
           begin
             read_thread_body(interface_info.interface)
           rescue Exception => err
-            Logger.instance.error "Tcpip server read thread unexpectedly died"
+            Logger.instance.error "#{@name}: Tcpip server read thread unexpectedly died"
             Logger.instance.error err.formatted
           end
-          Logger.instance.info "Tcpip server lost read connection to #{interface_info.hostname}(#{interface_info.host_ip}):#{interface_info.port}"
+          Logger.instance.info "#{@name}: Tcpip server lost read connection to #{interface_info.hostname}(#{interface_info.host_ip}):#{interface_info.port}"
           @read_threads.delete(Thread.current)
 
           index_to_delete = nil
@@ -453,7 +453,7 @@ module Cosmos
             end
           end
         rescue Exception => err
-          Logger.instance.error "Tcpip server read thread unexpectedly died"
+          Logger.instance.error "#{@name}: Tcpip server read thread unexpectedly died"
           Logger.instance.error err.formatted
         end
       end
@@ -500,7 +500,7 @@ module Cosmos
     end
 
     def interface_disconnect(interface_info)
-      Logger.instance.info "Tcpip server lost write connection to "\
+      Logger.instance.info "#{@name}: Tcpip server lost write connection to "\
         "#{interface_info.hostname}(#{interface_info.host_ip}):#{interface_info.port}"
       interface_info.interface.disconnect
       interface_info.interface.raw_logger_pair.stop if interface_info.interface.raw_logger_pair
@@ -552,13 +552,13 @@ module Cosmos
               next
             end
             # Client has disconnected (or is invalidly sending data on the socket)
-            Logger.instance.info "Tcpip server lost write connection to #{interface_info.hostname}(#{interface_info.host_ip}):#{interface_info.port}"
+            Logger.instance.info "#{@name}: Tcpip server lost write connection to #{interface_info.hostname}(#{interface_info.host_ip}):#{interface_info.port}"
             interface_info.interface.disconnect
             interface_info.interface.raw_logger_pair.stop if interface_info.interface.raw_logger_pair
             indexes_to_delete.unshift(index) # Put later indexes at front of array
           rescue Errno::ECONNRESET, Errno::ECONNABORTED, IOError
             # Client has disconnected
-            Logger.instance.info "Tcpip server lost write connection to #{interface_info.hostname}(#{interface_info.host_ip}):#{interface_info.port}"
+            Logger.instance.info "#{@name}: Tcpip server lost write connection to #{interface_info.hostname}(#{interface_info.host_ip}):#{interface_info.port}"
             interface_info.interface.disconnect
             interface_info.interface.raw_logger_pair.stop if interface_info.interface.raw_logger_pair
             indexes_to_delete.unshift(index) # Put later indexes at front of array
@@ -590,7 +590,7 @@ module Cosmos
           need_disconnect = false
           begin
             interface_bytes_written = interface_info.interface.bytes_written
-            interface_info.interface.send(method, packet_or_data)
+            interface_info.interface.public_send(method, packet_or_data)
             diff = interface_info.interface.bytes_written - interface_bytes_written
             @written_raw_data_time = interface_info.interface.written_raw_data_time
             @written_raw_data = interface_info.interface.written_raw_data
@@ -600,13 +600,13 @@ module Cosmos
             need_disconnect = true
           rescue Exception => err
             if err.message != "Stream not connected for write_raw"
-              Logger.instance.error "Error sending to client: #{err.class} #{err.message}"
+              Logger.instance.error "#{@name}: Error sending to client: #{err.class} #{err.message}"
             end
             need_disconnect = true
           end
 
           if need_disconnect
-            Logger.instance.info "Tcpip server lost write connection to #{interface_info.hostname}(#{interface_info.host_ip}):#{interface_info.port}"
+            Logger.instance.info "#{@name}: Tcpip server lost write connection to #{interface_info.hostname}(#{interface_info.host_ip}):#{interface_info.port}"
             interface_info.interface.disconnect
             interface_info.interface.raw_logger_pair.stop if interface_info.interface.raw_logger_pair
             indexes_to_delete.unshift(index) # Put later indexes at front of array

data/lib/cosmos/io/io_multiplexer.rb

@@ -40,11 +40,15 @@ module Cosmos
       result = nil
       @streams.each do |stream|
         if first
-          result = stream.send(method_name, *args)
+          # Fortify Access Specifier Manipulation
+          # We're forwarding only public methods to the stream
+          result = stream.public_send(method_name, *args)
           result = self if result == stream
           first = false
         else
-          stream.send(method_name, *args)
+          # Fortify Access Specifier Manipulation
+          # We're forwarding only public methods to the stream
+          stream.public_send(method_name, *args)
         end
       end
       result

data/lib/cosmos/io/json_drb.rb

@@ -123,7 +123,7 @@ module Cosmos
     # @param object [Object] The object to send the DRb requests to. This
     #   object must either include the Cosmos::Script module or be the
     #   CmdTlmServer.
-    def start_service(hostname = nil, port = nil, object = nil, max_threads = 1000)
+    def start_service(hostname = nil, port = nil, object = nil, max_threads = 1000, system = nil)
       server_started = false
       @server_mutex.synchronize do
         server_started = true if @server
@@ -147,7 +147,7 @@ module Cosmos
             }
 
             # The run call will block until the server is stopped.
-            Rack::Handler::Puma.run(JsonDrbRack.new(self), server_config) do |server|
+            Rack::Handler::Puma.run(JsonDrbRack.new(self, system), server_config) do |server|
               @server_mutex.synchronize do
                 @server = server
               end
@@ -259,10 +259,10 @@ module Cosmos
         error_code = nil
         response_data = nil
 
-        if (@method_whitelist and @method_whitelist.include?(request.method)) or
-           (!@method_whitelist and !JsonRpcRequest::DANGEROUS_METHODS.include?(request.method))
+        if (@method_whitelist and @method_whitelist.include?(request.method.downcase())) or
+           (!@method_whitelist and !JsonRpcRequest::DANGEROUS_METHODS.include?(request.method.downcase()))
           begin
-            result = @object.send(request.method.intern, *request.params)
+            result = @object.public_send(request.method.downcase().intern, *request.params)
             if request.id
               response = JsonRpcSuccessResponse.new(result, request.id)
             end

data/lib/cosmos/io/json_drb_object.rb

@@ -38,7 +38,7 @@ module Cosmos
     # @param hostname [String] The name of the machine which has started
     #   the JSON service
     # @param port [Integer] The port number of the JSON service
-    def initialize(hostname, port, connect_timeout = 1.0)
+    def initialize(hostname, port, connect_timeout = 1.0, x_csrf_token = nil)
       hostname = '127.0.0.1' if (hostname.to_s.upcase == 'LOCALHOST')
       begin
         Socket.pack_sockaddr_in(port, hostname)
@@ -61,6 +61,7 @@ module Cosmos
       @connect_timeout = connect_timeout
       @connect_timeout = @connect_timeout.to_f if @connect_timeout
       @shutdown = false
+      @x_csrf_token = x_csrf_token
     end
 
     # Disconnects from http server
@@ -127,7 +128,11 @@ module Cosmos
         STDOUT.puts "\nRequest:\n" if JsonDRb.debug?
         STDOUT.puts @request_data if JsonDRb.debug?
         @request_in_progress = true
-        headers = {'Content-Type' => 'application/json-rpc'}
+        if @x_csrf_token
+          headers = {'Content-Type' => 'application/json-rpc', 'X-Csrf-Token' => @x_csrf_token}
+        else
+          headers = {'Content-Type' => 'application/json-rpc'}
+        end
         res = @http.post(@uri,
                          :body   => @request_data,
                          :header => headers)

data/lib/cosmos/io/json_drb_rack.rb

@@ -17,8 +17,9 @@ module Cosmos
   class JsonDrbRack
     # @param drb [JsonDRb] - An instance of the JsonDRb class that'll be used
     #   to process the JSON request and generate a response
-    def initialize(drb)
+    def initialize(drb, system = nil)
       @drb = drb
+      @system = system
     end
 
     # Handles a request.
@@ -32,22 +33,41 @@ module Cosmos
       # ACL allow_addr? function takes address in the form returned by
       # IPSocket.peeraddr.
       req_addr = ["AF_INET", request.port, request.host.to_s, request.ip.to_s]
+      status = nil
 
       if @drb.acl and !@drb.acl.allow_addr?(req_addr)
         status       = 403
         content_type = "text/plain"
         body         = "Forbidden"
       elsif request.post?
-        status, content_type, body = handle_post(request)
+        if @system
+          if @system.x_csrf_token and (request.env['HTTP_X_CSRF_TOKEN'] != @system.x_csrf_token)
+            status       = 403
+            content_type = "text/plain"
+            body         = "Forbidden: Bad X-Csrf-Token: #{request.env['HTTP_X_CSRF_TOKEN']}"
+          end
+          if !@system.allowed_hosts.include?(request.env['HTTP_HOST'])
+            status       = 403
+            content_type = "text/plain"
+            body         = "Forbidden: #{request.env['HTTP_HOST']} not in allowed hosts"
+          end
+          if request.env['HTTP_ORIGIN'] and !@system.allowed_origins.include?(request.env['HTTP_ORIGIN'])
+            status       = 403
+            content_type = "text/plain"
+            body         = "Forbidden: #{request.env['HTTP_ORIGIN']} not in allowed origins"
+          end
+        end
+
+        status, content_type, body = handle_post(request) unless status
       else
         status       = 405
         content_type = "text/plain"
         body         = "Request not allowed"
       end
-  
+
       return status, {'Content-Type' => content_type}, [body]
     end
-    
+
     # Handles an http post.
     #
     # @param request [Rack::Request] - A rack post request
@@ -57,7 +77,7 @@ module Cosmos
       request_data = request.body.read
       start_time = Time.now.sys
       response_data, error_code = @drb.process_request(request_data, start_time)
-  
+
       # Convert json error code into html status code
       # see http://www.jsonrpc.org/historical/json-rpc-over-http.html#errors
       if error_code

data/lib/cosmos/io/json_rpc.rb

@@ -269,7 +269,7 @@ module Cosmos
     # @param response_data [String] JSON encoded string representing the response
     # @return [JsonRpcResponse]
     def self.from_json(response_data)
-      msg = "Invalid JSON-RPC 2.0 Response"
+      msg = "Invalid JSON-RPC 2.0 Response: #{response_data.inspect}"
       begin
         hash = JSON.parse(response_data, :allow_nan => true, :create_additions => true)
       rescue

data/lib/cosmos/io/posix_serial_driver.rb

@@ -25,19 +25,20 @@ module Cosmos
                    write_timeout = 10.0,
                    read_timeout = nil,
                    flow_control = :NONE,
-                   data_bits = 8)
+                   data_bits = 8,
+                   struct = [])
 
       # Convert Baud Rate into Termios constant
       begin
         baud_rate = Object.const_get("Termios::B#{baud_rate}")
       rescue NameError
-        raise(ArgumentError, "Invalid Baud Rate, Not Defined by Termios: #{baud_rate}")
+        raise(ArgumentError, "Invalid baud rate: #{baud_rate}")
       end
 
       # Verify Parameters
-      raise(ArgumentError, "Invalid Data Bits: #{data_bits}") unless [5,6,7,8].include?(data_bits)
+      raise(ArgumentError, "Invalid data bits: #{data_bits}") unless [5,6,7,8].include?(data_bits)
       raise(ArgumentError, "Invalid parity: #{parity}") if parity and !SerialDriver::VALID_PARITY.include?(parity)
-      raise(ArgumentError, "Invalid Stop Bits: #{stop_bits}") unless [1,2].include?(stop_bits)
+      raise(ArgumentError, "Invalid stop bits: #{stop_bits}") unless [1,2].include?(stop_bits)
       @write_timeout = write_timeout
       @read_timeout = read_timeout
 
@@ -51,22 +52,61 @@ module Cosmos
 
       # Configure the serial Port
       tio = Termios::new_termios()
-      iflags = 0
-      iflags |= Termios::IGNPAR unless parity
-      cflags = 0
-      cflags |= Termios::CREAD # Enable receiver
-      cflags |= Termios.const_get("CS#{data_bits}") # data bits
-      cflags |= Termios::CLOCAL # Ignore Modem Control Lines
-      cflags |= Termios::CSTOPB if stop_bits == 2
-      cflags |= Termios::PARENB if parity
-      cflags |= Termios::PADODD if parity == :ODD
-      cflags |= Termios::CRTSCTS if flow_control == :RTSCTS
-      tio.iflag = iflags
-      tio.oflag = 0
-      tio.cflag = cflags
-      tio.lflag = 0
+      iflag = 0
+      iflag |= Termios::IGNPAR unless parity
+      oflag = 0
+      cflag = 0
+      cflag |= Termios::CREAD # Enable receiver
+      cflag |= Termios.const_get("CS#{data_bits}") # data bits
+      cflag |= Termios::CLOCAL # Ignore Modem Control Lines
+      cflag |= Termios::CSTOPB if stop_bits == 2
+      cflag |= Termios::PARENB if parity
+      cflag |= Termios::PARODD if parity == :ODD
+      cflag |= Termios::CRTSCTS if flow_control == :RTSCTS
+      lflag = 0
       tio.cc[Termios::VTIME] = 0
       tio.cc[Termios::VMIN] = 1
+      unless struct.empty?
+        struct.each do |field, key, value|
+          case field
+          when 'iflag'
+            if value == "0"
+              iflag &= ~Termios.const_get(key)
+            else
+              iflag |= Termios.const_get(key)
+            end
+          when 'oflag'
+            if value == "0"
+              oflag &= ~Termios.const_get(key)
+            else
+              oflag |= Termios.const_get(key)
+            end
+          when 'cflag'
+            if value == "0"
+              cflag &= ~Termios.const_get(key)
+            else
+              cflag |= Termios.const_get(key)
+            end
+          when 'lflag'
+            if value == "0"
+              lflag &= ~Termios.const_get(key)
+            else
+              lflag |= Termios.const_get(key)
+            end
+          when 'cc'
+            begin
+              value = Integer(value) # Try to convert to int
+            rescue ArgumentError
+              # Ignore this error and use the string
+            end
+            tio.cc[Termios.const_get(key)] = value
+          end
+        end
+      end
+      tio.iflag = iflag
+      tio.oflag = oflag
+      tio.cflag = cflag
+      tio.lflag = lflag
       tio.ispeed = baud_rate
       tio.ospeed = baud_rate
       @handle.tcflush(Termios::TCIOFLUSH)
@@ -143,7 +183,5 @@ module Cosmos
 
       data
     end
-
-  end # class PosixSerialDriver
-
-end # module Cosmos
+  end
+end

data/lib/cosmos/io/serial_driver.rb

@@ -32,8 +32,10 @@ module Cosmos
     #   complete or nil to block
     # @param read_timeout [Float|nil] Number of seconds to wait for the read to
     #   complete or nil to block
-    # @param flow_control [Symbol] Currently supported :NONE and :RTSCTS (default :NONE)
+    # @param flow_control [Symbol] Currently supported :NONE, :RTSCTS (default :NONE)
     # @param data_bits [Integer] Number of data bits (default 8)
+    # @param struct [Array] Array of arrays of fields and values to set in the
+    #   Windows DCB or POSIX structure
     def initialize(port_name,
                    baud_rate,
                    parity = :NONE,
@@ -41,7 +43,8 @@ module Cosmos
                    write_timeout = 10.0,
                    read_timeout = nil,
                    flow_control = :NONE,
-                   data_bits = 8)
+                   data_bits = 8,
+                   struct = [])
       raise(ArgumentError, "Invalid parity: #{parity}") unless VALID_PARITY.include? parity
       if Kernel.is_windows?
         @driver = Win32SerialDriver.new(port_name,
@@ -53,7 +56,8 @@ module Cosmos
                                         0.01,
                                         1000,
                                         flow_control,
-                                        data_bits)
+                                        data_bits,
+                                        struct)
       elsif RUBY_ENGINE == 'ruby'
         @driver = PosixSerialDriver.new(port_name,
                                         baud_rate,
@@ -62,7 +66,8 @@ module Cosmos
                                         write_timeout,
                                         read_timeout,
                                         flow_control,
-                                        data_bits)
+                                        data_bits,
+                                        struct)
       else
         @driver = nil # JRuby Serial on Linux not currently supported
       end
@@ -92,7 +97,5 @@ module Cosmos
     def read_nonblock
       @driver.read_nonblock
     end
-
-  end # class SerialDriver
-
-end # module Cosmos
+  end
+end

data/lib/cosmos/io/win32_serial_driver.rb

@@ -24,7 +24,8 @@ module Cosmos
                    read_polling_period = 0.01,
                    read_max_length = 1000,
                    flow_control = :NONE,
-                   data_bits = 8)
+                   data_bits = 8,
+                   struct = [])
 
       # Verify Parameters
       port_name = '\\\\.\\' + port_name if port_name =~ /^COM[0-9]{2,3}$/
@@ -78,10 +79,37 @@ module Cosmos
         # 0x03 - RTS_CONTROL_TOGGLE - Specifies that the RTS line will be high if bytes are available for transmission. After all buffered bytes have been sent, the RTS line will be low.
         dcb.write('fRtsControl', 0x03)
       end
+      # Allow the end user to write arbitrary values into the Windows DCB structure
+      unless struct.empty?
+        struct.each do |key, value|
+          dcb.write(key, value.to_i)
+        end
+      end
       Win32.set_comm_state(@handle, dcb)
 
-      # Configure Timeouts
-      Win32.set_comm_timeouts(@handle, 4294967295, 0, 0, 0, 0)
+      # Configure Timeouts, the WinAPI structure is COMMTIMEOUTS:
+      #   DWORD ReadIntervalTimeout;
+      #   DWORD ReadTotalTimeoutMultiplier;
+      #   DWORD ReadTotalTimeoutConstant;
+      #   DWORD WriteTotalTimeoutMultiplier;
+      #   DWORD WriteTotalTimeoutConstant;
+      # 0xFFFFFFFF, 0, 0 specifies that the read operation is to return immediately
+      # with the bytes that have already been received, even if no bytes have been received.
+      # The WriteTotalTimeoutMultiplier is multiplied by the number of bytes to be written
+      # and the WriteTotalTimeoutConstant is added to that total (both are in milliseconds).
+      bits_per_symbol = data_bits + 1 # 1 start bit
+      case stop_bits
+      when Win32::ONESTOPBIT
+        bits_per_symbol += 1
+      when Win32::TWOSTOPBITS
+        bits_per_symbol += 2
+      end
+      case parity
+      when Win32::ODDPARITY, Win32::EVENPARITY
+        bits_per_symbol += 1
+      end
+      delay = (1000.0 / (baud_rate / bits_per_symbol.to_f)).ceil
+      Win32.set_comm_timeouts(@handle, 0xFFFFFFFF, 0, 0, delay, 1000)
     end
 
     # (see SerialDriver#close)

data/lib/cosmos/packet_logs/packet_log_reader.rb

@@ -152,7 +152,7 @@ module Cosmos
 
       # Read Packet Data
       packet_data = @file.read_length_bytes(4, @max_read_size)
-      return nil unless packet_data and packet_data.length > 0
+      return nil unless packet_data and packet_data.length >= 0
 
       if identify_and_define
         packet = identify_and_define_packet_data(target_name, packet_name, received_time, packet_data)
@@ -275,7 +275,7 @@ module Cosmos
           end
           packet.buffer = packet_data
           packet.set_received_time_fast(received_time)
-        rescue
+        rescue Exception => error
           # Could not find a definition for this packet
           Logger.instance.error "Unknown packet #{target_name} #{packet_name}"
           packet = Packet.new(target_name, packet_name, :BIG_ENDIAN, nil, packet_data)

data/lib/cosmos/packets/packet.rb

@@ -186,9 +186,9 @@ module Cosmos
         @read_conversion_cache.clear if @read_conversion_cache
         @received_count
       end
-      
-    end # if RUBY_ENGINE != 'ruby' or ENV['COSMOS_NO_EXT']      
-      
+
+    end # if RUBY_ENGINE != 'ruby' or ENV['COSMOS_NO_EXT']
+
     # Tries to identify if a buffer represents the currently defined packet. It
     # does this by iterating over all the packet items that were created with
     # an ID value and checking whether that ID value is present at the correct
@@ -216,7 +216,7 @@ module Cosmos
 
       true
     end
-    
+
     # Reads the values from a buffer at the position of each id_item defined
     # in the packet.
     #
@@ -226,7 +226,7 @@ module Cosmos
       return [] unless buffer
       return [] unless @id_items
       values = []
-      
+
       @id_items.each do |item|
         begin
           values << read_item(item, :RAW, buffer)
@@ -234,10 +234,10 @@ module Cosmos
           values << nil
         end
       end
-      
+
       values
     end
-    
+
     # Returns @received_time unless a packet item called PACKET_TIME exists that returns
     # a Ruby Time object that represents a different timestamp for the packet
     def packet_time
@@ -259,7 +259,7 @@ module Cosmos
       end
 
       # Use the hashing algorithm established by Cosmos::System
-      digest = Digest.const_get(System.hashing_algorithm).send('new')
+      digest = Digest.const_get(System.hashing_algorithm).public_send('new')
       digest << string
       @config_name = digest.hexdigest
       @config_name
@@ -341,7 +341,7 @@ module Cosmos
       previous_item = nil
       warnings = []
       @sorted_items.each do |item|
-        if expected_next_offset and item.bit_offset < expected_next_offset
+        if expected_next_offset and (item.bit_offset < expected_next_offset) and !item.overlap
           msg = "Bit definition overlap at bit offset #{item.bit_offset} for packet #{@target_name} #{@packet_name} items #{item.name} and #{previous_item.name}"
           Logger.instance.warn(msg)
           warnings << msg

data/lib/cosmos/packets/packet_config.rb

@@ -198,14 +198,22 @@ module Cosmos
           #######################################################################
           # All the following keywords must have a current packet defined
           #######################################################################
-          when 'SELECT_ITEM', 'SELECT_PARAMETER', 'ITEM', 'PARAMETER', 'ID_ITEM', 'ID_PARAMETER', 'ARRAY_ITEM', 'ARRAY_PARAMETER', 'APPEND_ITEM', 'APPEND_PARAMETER', 'APPEND_ID_ITEM', 'APPEND_ID_PARAMETER', 'APPEND_ARRAY_ITEM', 'APPEND_ARRAY_PARAMETER', 'MACRO_APPEND_START', 'MACRO_APPEND_END', 'ALLOW_SHORT', 'HAZARDOUS', 'PROCESSOR', 'META', 'DISABLE_MESSAGES', 'HIDDEN', 'DISABLED'
+          when 'SELECT_ITEM', 'SELECT_PARAMETER', 'DELETE_ITEM', 'DELETE_PARAMETER', 'ITEM',\
+              'PARAMETER', 'ID_ITEM', 'ID_PARAMETER', 'ARRAY_ITEM', 'ARRAY_PARAMETER', 'APPEND_ITEM',\
+              'APPEND_PARAMETER', 'APPEND_ID_ITEM', 'APPEND_ID_PARAMETER', 'APPEND_ARRAY_ITEM',\
+              'APPEND_ARRAY_PARAMETER', 'MACRO_APPEND_START', 'MACRO_APPEND_END', 'ALLOW_SHORT',\
+              'HAZARDOUS', 'PROCESSOR', 'META', 'DISABLE_MESSAGES', 'HIDDEN', 'DISABLED'
             raise parser.error("No current packet for #{keyword}") unless @current_packet
             process_current_packet(parser, keyword, params)
 
           #######################################################################
           # All the following keywords must have a current item defined
           #######################################################################
-          when 'STATE', 'READ_CONVERSION', 'WRITE_CONVERSION', 'POLY_READ_CONVERSION', 'POLY_WRITE_CONVERSION', 'SEG_POLY_READ_CONVERSION', 'SEG_POLY_WRITE_CONVERSION', 'GENERIC_READ_CONVERSION_START', 'GENERIC_WRITE_CONVERSION_START', 'REQUIRED', 'LIMITS', 'LIMITS_RESPONSE', 'UNITS', 'FORMAT_STRING', 'DESCRIPTION', 'MINIMUM_VALUE', 'MAXIMUM_VALUE', 'DEFAULT_VALUE', 'OVERFLOW'
+          when 'STATE', 'READ_CONVERSION', 'WRITE_CONVERSION', 'POLY_READ_CONVERSION',\
+              'POLY_WRITE_CONVERSION', 'SEG_POLY_READ_CONVERSION', 'SEG_POLY_WRITE_CONVERSION',\
+              'GENERIC_READ_CONVERSION_START', 'GENERIC_WRITE_CONVERSION_START', 'REQUIRED',\
+              'LIMITS', 'LIMITS_RESPONSE', 'UNITS', 'FORMAT_STRING', 'DESCRIPTION',\
+              'MINIMUM_VALUE', 'MAXIMUM_VALUE', 'DEFAULT_VALUE', 'OVERFLOW', 'OVERLAP'
             raise parser.error("No current item for #{keyword}") unless @current_item
             process_current_item(parser, keyword, params)
 
@@ -327,25 +335,31 @@ module Cosmos
     def process_current_packet(parser, keyword, params)
       case keyword
 
-      # Select an item in the current telemetry packet for editing
-      when 'SELECT_PARAMETER', 'SELECT_ITEM'
+      # Select or delete an item in the current packet
+      when 'SELECT_PARAMETER', 'SELECT_ITEM', 'DELETE_PARAMETER', 'DELETE_ITEM'
         if (@current_cmd_or_tlm == COMMAND) && (keyword.split('_')[1] == 'ITEM')
-          raise parser.error("SELECT_ITEM only applies to telemetry packets")
+          raise parser.error("#{keyword} only applies to telemetry packets")
         end
         if (@current_cmd_or_tlm == TELEMETRY) && (keyword.split('_')[1] == 'PARAMETER')
-          raise parser.error("SELECT_PARAMETER only applies to command packets")
+          raise parser.error("#{keyword} only applies to command packets")
         end
         usage = "#{keyword} <#{keyword.split('_')[1]} NAME>"
         finish_item()
         parser.verify_num_parameters(1, 1, usage)
         begin
-          @current_item = @current_packet.get_item(params[0])
+          if keyword.include?("SELECT")
+            @current_item = @current_packet.get_item(params[0])
+          else # DELETE
+            @current_packet.delete_item(params[0])
+          end
         rescue # Rescue the default execption to provide a nicer error message
           raise parser.error("#{params[0]} not found in #{@current_cmd_or_tlm.downcase} packet #{@current_packet.target_name} #{@current_packet.packet_name}", usage)
         end
 
       # Start a new telemetry item in the current packet
-      when 'ITEM', 'PARAMETER', 'ID_ITEM', 'ID_PARAMETER', 'ARRAY_ITEM', 'ARRAY_PARAMETER', 'APPEND_ITEM', 'APPEND_PARAMETER', 'APPEND_ID_ITEM', 'APPEND_ID_PARAMETER', 'APPEND_ARRAY_ITEM', 'APPEND_ARRAY_PARAMETER'
+      when 'ITEM', 'PARAMETER', 'ID_ITEM', 'ID_PARAMETER', 'ARRAY_ITEM', 'ARRAY_PARAMETER',\
+          'APPEND_ITEM', 'APPEND_PARAMETER', 'APPEND_ID_ITEM', 'APPEND_ID_PARAMETER',\
+          'APPEND_ARRAY_ITEM', 'APPEND_ARRAY_PARAMETER'
         start_item(parser)
 
       # Start the creation of a macro-expanded list of items
@@ -429,7 +443,7 @@ module Cosmos
           klass = params[0].filename_to_class_name.to_class
           raise parser.error("#{params[0].filename_to_class_name} class not found. Did you require the file in target.txt?", usage) unless klass
           conversion = klass.new(*params[1..(params.length - 1)])
-          @current_item.send("#{keyword.downcase}=".to_sym, conversion)
+          @current_item.public_send("#{keyword.downcase}=".to_sym, conversion)
           if klass != ProcessorConversion and (conversion.converted_type.nil? or conversion.converted_bit_size.nil?)
             msg = "Read Conversion #{params[0].filename_to_class_name} on item #{@current_item.name} does not specify converted type or bit size. Will not be supported by DART"
             @warnings << msg
@@ -570,6 +584,10 @@ module Cosmos
         parser.verify_num_parameters(1, 1, usage)
         @current_item.overflow = params[0].to_s.upcase.intern
 
+      when 'OVERLAP'
+        parser.verify_num_parameters(0, 0, 'OVERLAP')
+        @current_item.overlap = true
+
       end
     end