openc3 7.2.1 → 7.4.0

data/lib/openc3/api/limits_api.rb

@@ -134,7 +134,7 @@ module OpenC3
           break
         end
       end
-      raise "Item '#{target_name} #{packet_name} #{item_name}' does not exist" unless found_item
+      raise "Item '#{target_name} #{packet_name} #{item_name}' does not exist while enabling limits" unless found_item
 
       TargetModel.set_packet(target_name, packet_name, packet, scope: scope)
 
@@ -167,7 +167,7 @@ module OpenC3
           break
         end
       end
-      raise "Item '#{target_name} #{packet_name} #{item_name}' does not exist" unless found_item
+      raise "Item '#{target_name} #{packet_name} #{item_name}' does not exist while disabling limits" unless found_item
 
       TargetModel.set_packet(target_name, packet_name, packet, scope: scope)
 
@@ -239,7 +239,7 @@ module OpenC3
           end
         end
       end
-      raise "Item '#{target_name} #{packet_name} #{item_name}' does not exist" unless found_item
+      raise "Item '#{target_name} #{packet_name} #{item_name}' does not exist while setting limits" unless found_item
       message = "Setting '#{target_name} #{packet_name} #{item_name}' limits to #{red_low} #{yellow_low} #{yellow_high} #{red_high}"
       message << " #{green_low} #{green_high}" if green_low && green_high
       message << " in set #{limits_set} with persistence #{persistence} as enabled #{enabled}"
@@ -262,14 +262,19 @@ module OpenC3
     # @param packet_name [String] Packet name
     # @param item_name [String] Item name
     # @param state_name [String] Name of the state to change (e.g. 'CONNECTED')
-    # @param color [String] New color for the state. Must be GREEN, YELLOW, or RED.
+    # @param color [String, nil] New color for the state. Must be GREEN, YELLOW,
+    #   or RED. Pass nil to clear (remove) the state color. Setting a color also
+    #   enables limits for the item, but clearing the color (nil) does not change
+    #   whether limits are enabled.
     def set_state_color(target_name, packet_name, item_name, state_name, color,
                         manual: false, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       state_name = state_name.to_s.upcase
-      color = color.to_s.upcase
-      unless PacketItem::STATE_COLORS.include?(color.intern)
-        raise "Invalid state color #{color}. Must be one of #{PacketItem::STATE_COLORS.join(' ')}."
+      unless color.nil?
+        color = color.to_s.upcase
+        unless PacketItem::STATE_COLORS.include?(color.intern)
+          raise "Invalid state color '#{color}'. Must be one of #{PacketItem::STATE_COLORS.join(', ')}."
+        end
       end
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
       found_item = nil
@@ -278,16 +283,25 @@ module OpenC3
           unless item['states'] && item['states'][state_name]
             raise "State '#{state_name}' does not exist for item '#{target_name} #{packet_name} #{item_name}'"
           end
-          item['states'][state_name]['color'] = color
-          # Defining a state color implies limits are enabled for the item
-          item['limits'] ||= {}
-          item['limits']['enabled'] = true
+          if color.nil?
+            # Clear the state color
+            item['states'][state_name].delete('color')
+          else
+            item['states'][state_name]['color'] = color
+            # Defining a state color implies limits are enabled for the item
+            item['limits'] ||= {}
+            item['limits']['enabled'] = true
+          end
           found_item = item
           break
         end
       end
-      raise "Item '#{target_name} #{packet_name} #{item_name}' does not exist" unless found_item
-      message = "Setting '#{target_name} #{packet_name} #{item_name}' state #{state_name} color to #{color}"
+      raise "Item '#{target_name} #{packet_name} #{item_name}' does not exist while setting state color" unless found_item
+      if color.nil?
+        message = "Clearing '#{target_name} #{packet_name} #{item_name}' state #{state_name} color"
+      else
+        message = "Setting '#{target_name} #{packet_name} #{item_name}' state #{state_name} color to #{color}"
+      end
       Logger.info(message, scope: scope)
 
       TargetModel.set_packet(target_name, packet_name, packet, scope: scope)

data/lib/openc3/api/metrics_api.rb

@@ -1,6 +1,6 @@
 # encoding: ascii-8bit
 
-# Copyright 2023 OpenC3, Inc
+# Copyright 2026 OpenC3, Inc.
 # All Rights Reserved.
 #
 # This program is distributed in the hope that it will be useful,

data/lib/openc3/api/offline_access_api.rb

@@ -1,6 +1,6 @@
 # encoding: ascii-8bit
 
-# Copyright 2022 OpenC3, Inc
+# Copyright 2026 OpenC3, Inc.
 # All Rights Reserved.
 #
 # This program is distributed in the hope that it will be useful,

data/lib/openc3/api/router_api.rb

@@ -46,7 +46,7 @@ module OpenC3
     def get_router(router_name, manual: false, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'system', router_name: router_name, manual: manual, scope: scope, token: token)
       router = RouterModel.get(name: router_name, scope: scope)
-      raise "Router '#{router_name}' does not exist" unless router
+      raise "Router '#{router_name}' does not exist (get_router)" unless router
 
       router.merge(RouterStatusModel.get(name: router_name, scope: scope))
     end
@@ -144,7 +144,7 @@ module OpenC3
       # TODO: Check if they have command authority for the targets mapped to this router
       authorize(permission: 'system_set', router_name: router_name, manual: manual, scope: scope, token: token)
       router = RouterModel.get_model(name: router_name, scope: scope)
-      raise "Router '#{router_name}' does not exist" unless router
+      raise "Router '#{router_name}' does not exist (map_target_to_router)" unless router
 
       if Array === target_name
         target_names = target_name
@@ -167,7 +167,7 @@ module OpenC3
       # TODO: Check if they have command authority for the targets mapped to this router
       authorize(permission: 'system_set', router_name: router_name, manual: manual, scope: scope, token: token)
       router = RouterModel.get_model(name: router_name, scope: scope)
-      raise "Router '#{router_name}' does not exist" unless router
+      raise "Router '#{router_name}' does not exist (unmap_target_from_router)" unless router
 
       if Array === target_name
         target_names = target_name

data/lib/openc3/api/settings_api.rb

@@ -81,26 +81,30 @@ module OpenC3
 
     # Update the news feed on demand to respond to frontend setting changes
     def update_news(manual: false, scope: $openc3_scope, token: $openc3_token)
+      # Authorize outside the begin/rescue so AuthError propagates to the caller
+      # rather than being swallowed and written into the news feed
       authorize(permission: 'admin', manual: manual, scope: scope, token: token)
-      conn = Faraday.new(
-        url: 'https://news.openc3.com',
-        params: {version: VERSION, enterprise: ENTERPRISE},
-      )
-      response = conn.get('/news')
-      if response.success?
-        NewsModel.set(response.body)
-      else
-        NewsModel.news_error("Error contacting OpenC3 news feed (status: #{response.status})")
-      end
+      begin
+        conn = Faraday.new(
+          url: 'https://news.openc3.com',
+          params: {version: VERSION, enterprise: ENTERPRISE},
+        )
+        response = conn.get('/news')
+        if response.success?
+          NewsModel.set(response.body)
+        else
+          NewsModel.news_error("Error contacting OpenC3 news feed (status: #{response.status})")
+        end
 
-      # Test code to update the news feed with a dummy message
-      # data = NewsModel.all()
-      # json = JSON.parse(data)
-      # json.unshift( { date: Time.now.utc.iso8601, title: "News at #{Time.now}", body: "The news feed has been updated at #{Time.now}." })
-      # json.pop if json.length > 5
-      # NewsModel.set(json.to_json)
-    rescue Exception => e
-      NewsModel.news_error("Error contacting OpenC3 news feed. #{e.message})")
+        # Test code to update the news feed with a dummy message
+        # data = NewsModel.all()
+        # json = JSON.parse(data)
+        # json.unshift( { date: Time.now.utc.iso8601, title: "News at #{Time.now}", body: "The news feed has been updated at #{Time.now}." })
+        # json.pop if json.length > 5
+        # NewsModel.set(json.to_json)
+      rescue StandardError => e
+        NewsModel.news_error("Error contacting OpenC3 news feed. #{e.message}")
+      end
     end
 
     # Update the local copy of the plugin store data

data/lib/openc3/api/stash_api.rb

@@ -1,6 +1,6 @@
 # encoding: ascii-8bit
 
-# Copyright 2024 OpenC3, Inc
+# Copyright 2026 OpenC3, Inc.
 # All Rights Reserved.
 #
 # This program is distributed in the hope that it will be useful,

data/lib/openc3/api/tlm_api.rb

@@ -117,13 +117,14 @@ module OpenC3
     # @param packet_name [String] Packet name of the packet
     # @param item_hash [Hash] Hash of item_name and value for each item you want to change from the current value table
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED
-    def inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, stored: false, manual: false, scope: $openc3_scope, token: $openc3_token)
+    # @param received_time [Integer, nil] Optional received time as nanoseconds since Unix epoch
+    def inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, stored: false, received_time: nil, manual: false, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, manual: manual, scope: scope, token: token)
       type = type.to_s.intern
       target_name = target_name.upcase
       packet_name = packet_name.upcase
       unless CvtModel::VALUE_TYPES.include?(type)
-        raise "Unknown type '#{type}' for #{target_name} #{packet_name}"
+        raise "Unknown type '#{type}' for #{target_name} #{packet_name} (inject_tlm)"
       end
 
       if item_hash
@@ -155,9 +156,9 @@ module OpenC3
 
       # Use an interface microservice if it exists, other use the decom microservice
       if interface_name
-        InterfaceTopic.inject_tlm(interface_name, target_name, packet_name, item_hash, type: type, stored: stored, scope: scope)
+        InterfaceTopic.inject_tlm(interface_name, target_name, packet_name, item_hash, type: type, stored: stored, received_time: received_time, scope: scope)
       else
-        DecomInterfaceTopic.inject_tlm(target_name, packet_name, item_hash, type: type, stored: stored, scope: scope)
+        DecomInterfaceTopic.inject_tlm(target_name, packet_name, item_hash, type: type, stored: stored, received_time: received_time, scope: scope)
       end
     end
 

data/lib/openc3/config/config_parser.rb

@@ -166,19 +166,46 @@ module OpenC3
       return ERB.new(read_file(template_name).comment_erb(), trim_mode: "-").result(b)
     end
 
-    # Can be called during parsing to read a referenced file
+    # Can be called during parsing to read a referenced file. The filename must
+    # be relative to the configuration file being parsed and must resolve to a
+    # location inside that file's directory.
     def read_file(filename)
-      # Assume the file is there. If not we raise a pretty obvious error
-      if File.expand_path(filename) == filename # absolute path
-        path = filename
-      else # relative to the current @filename
-        path = File.join(File.dirname(@filename), filename)
-      end
+      path = resolve_config_path(filename)
       OpenC3.set_working_dir(File.dirname(path)) do
         return File.read(path).force_encoding("UTF-8")
       end
     end
 
+    # Resolves a filename referenced by a configuration file (TEMPLATE_FILE, ERB
+    # render, etc) into an absolute path contained by the directory of the file
+    # being parsed. Absolute paths and paths containing '..' are rejected so a
+    # configuration file can not read arbitrary files on the filesystem.
+    #
+    # @param filename [String] Relative path from the configuration file
+    # @return [String] Absolute path to the referenced file
+    private def resolve_config_path(filename)
+      filename = filename.to_s
+      raise Error.new(self, "Filename must be given") if filename.strip.empty?
+
+      if File.absolute_path?(filename) or File.expand_path(filename) == filename
+        raise Error.new(self, "Absolute paths are not allowed: #{filename}")
+      end
+      if filename.include?('..')
+        raise Error.new(self, "Path traversal is not allowed: #{filename}")
+      end
+      if @filename.nil? or @filename.to_s.empty?
+        raise Error.new(self, "No configuration file is being parsed, can not resolve: #{filename}")
+      end
+
+      base = File.expand_path(File.dirname(@filename))
+      path = File.expand_path(File.join(base, filename))
+      # Final containment check in case the OS or Ruby normalizes something unexpected
+      unless path.start_with?(base + File::SEPARATOR)
+        raise Error.new(self, "Path is outside the configuration directory: #{filename}")
+      end
+      path
+    end
+
     # Processes a file and yields |config| to the given block
     #
     # @param filename [String] The full name and path of the configuration file
@@ -307,6 +334,38 @@ module OpenC3
       return value
     end
 
+    # Values handle_true_false_strict accepts. Deliberately NOT shared with
+    # handle_true_false, which passes unrecognized values through and so can't
+    # tell the number 1 from a boolean - TABLE_MANAGER item defaults rely on 1
+    # staying 1. Named and scoped so they can't be mistaken for a truth table
+    # the whole parser honors.
+    STRICT_TRUE_VALUES = ['TRUE', '1']
+    STRICT_FALSE_VALUES = ['FALSE', '0', '']
+    private_constant :STRICT_TRUE_VALUES, :STRICT_FALSE_VALUES
+
+    # Converts a String containing 'TRUE', '1', 'FALSE', '0' or '' to a true or
+    # false Ruby primitive. Unlike handle_true_false, which returns anything it
+    # doesn't recognize unchanged, an unrecognized value raises.
+    #
+    # Use this for a flag where guessing is worse than failing - notably an
+    # environment variable that is enabled by presence elsewhere in COSMOS, so
+    # that 'VAR=false' (or 'VAR=0') means off here rather than the surprising on.
+    #
+    # @param value [Object] value to convert, nil returns the default
+    # @param description [String] what the value is, used in the error message
+    # @param default [true|false] returned when value is nil
+    # @return [true|false]
+    def self.handle_true_false_strict(value, description: 'value', default: false)
+      return default if value.nil?
+      normalized = value.to_s.strip.upcase
+      return true if STRICT_TRUE_VALUES.include?(normalized)
+      return false if STRICT_FALSE_VALUES.include?(normalized)
+      # Name empty explicitly - it is accepted (as false) but isn't a value
+      # anyone can read off the list
+      raise ArgumentError, "Invalid value #{value.to_s.strip.inspect} for #{description}. " \
+                           "Must be one of: #{(STRICT_TRUE_VALUES + STRICT_FALSE_VALUES - ['']).join(', ')}, or empty"
+    end
+
     # Converts a String containing '', 'NIL', 'NULL', 'TRUE' or 'FALSE' to nil,
     # true or false Ruby primitives. All other values are simply returned.
     #
@@ -321,6 +380,8 @@ module OpenC3
           return false
         when '', 'NIL', 'NULL'
           return nil
+        else
+          # All other strings are returned unmodified below
         end
       end
       return value
@@ -378,11 +439,12 @@ module OpenC3
           return Float::INFINITY
         when 'NEG_INFINITY'
           return -Float::INFINITY
+        else
+          # NOTE: The else case does not raise because of the following scenario:
+          # If the value type is a UINT but they have a WRITE_CONVERSION that takes a string
+          # then the default value will be a string. In that case we just want to return the string.
+          # For example, the IP_ADDRESS parameter in the TIME_OFFSET command in the Demo plugin.
         end
-        # NOTE: No else case because of the following scenario:
-        # If the value type is a UINT but they have a WRITE_CONVERSION that takes a string
-        # then the default value will be a string. In that case we just want to return the string.
-        # For example, the IP_ADDRESS parameter in the TIME_OFFSET command in the Demo plugin.
       end
       return value
     end
@@ -494,8 +556,8 @@ module OpenC3
         while true
           @line_number += 1
 
-          if @@progress_callback && ((@line_number % 10) == 0)
-            @@progress_callback.call(io.pos / size) if size > 0.0
+          if @@progress_callback && ((@line_number % 10) == 0) && size > 0.0
+            @@progress_callback.call(io.pos / size)
           end
 
           begin
@@ -586,10 +648,9 @@ module OpenC3
               # KEYWORD PARAM #This is a comment
               # But still process Ruby string interpolations such as:
               # KEYWORD PARAM #{var}
-              if (string.length > 0) && (string[0] == '#')
-                if !((string.length > 1) && (string[1] == '{'))
-                  break
-                end
+              if (string.length > 0) && (string[0] == '#') &&
+                 !((string.length > 1) && (string[1] == '{'))
+                break
               end
 
               if remove_quotes

data/lib/openc3/interfaces/http_client_interface.rb

@@ -237,7 +237,7 @@ module OpenC3
       result['read_timeout'] = @read_timeout
       result['connect_timeout'] = @connect_timeout
       result['include_request_in_response'] = @include_request_in_response
-      result['request_queue_length'] = @request_queue.length
+      result['response_queue_length'] = @response_queue.length
       return result
     end
   end

data/lib/openc3/interfaces/interface.rb

@@ -15,6 +15,7 @@
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
+require 'openc3/packets/packet'
 require 'openc3/api/api'
 require 'openc3/logs/stream_log_pair'
 require 'openc3/utilities/secrets'
@@ -433,8 +434,8 @@ module OpenC3
       config['name'] = @name
       config['state'] = @state
       config['clients'] = self.num_clients
-      config['txsize'] = @write_queue_size
-      config['rxsize'] = @read_queue_size
+      config['txsize'] = self.write_queue_size
+      config['rxsize'] = self.read_queue_size
       config['txbytes'] = @bytes_written
       config['rxbytes'] = @bytes_read
       config['txcnt'] = @write_count
@@ -677,12 +678,12 @@ module OpenC3
       result['read_raw_data'] = @read_raw_data
       result['written_raw_data'] = @written_raw_data
       if @read_raw_data_time
-        result['read_raw_data_time'] = @read_raw_data_time.iso8601
+        result['read_raw_data_time'] = @read_raw_data_time.getutc.iso8601(6)
       else
         result['read_raw_data_time'] = nil
       end
       if @written_raw_data_time
-        result['written_raw_data_time'] = @written_raw_data_time.iso8601
+        result['written_raw_data_time'] = @written_raw_data_time.getutc.iso8601(6)
       else
         result['written_raw_data_time'] = nil
       end

data/lib/openc3/interfaces/mqtt_stream_interface.rb

@@ -49,6 +49,8 @@ module OpenC3
 
     # Creates a new {SerialStream} using the parameters passed in the constructor
     def connect
+      # Cleanly close any existing stream rather than leaving it open
+      @stream.disconnect if @stream
       @stream = MqttStream.new(@hostname, @port, @ssl, @write_topic, @read_topic, @ack_timeout)
       @stream.username = @username if @username
       @stream.password = @password if @password

data/lib/openc3/interfaces/protocols/burst_protocol.rb

@@ -23,6 +23,14 @@ module OpenC3
   # Reads all data available on the interface and creates a packet
   # with that data.
   class BurstProtocol < Protocol
+    # Maximum number of bytes which will be buffered while waiting for a
+    # complete packet. This bounds the memory a peer can cause the interface
+    # to allocate by declaring an enormous packet length (LENGTH, PREIDENTIFIED)
+    # or by never sending a terminator (TERMINATED). Deliberately much larger
+    # than any realistic packet so it does not affect existing configurations.
+    # Override with the OPENC3_PROTOCOL_MAX_BUFFER_SIZE environment variable.
+    DEFAULT_MAX_BUFFER_SIZE = 100_000_000
+
     # @param discard_leading_bytes [Integer] The number of bytes to discard
     #   from the binary data after reading. Note that this is often
     #   used to remove a sync pattern from the final packet data.
@@ -37,6 +45,7 @@ module OpenC3
       @sync_pattern = ConfigParser.handle_nil(sync_pattern)
       @sync_pattern = @sync_pattern.hex_to_byte_string if @sync_pattern
       @fill_fields = ConfigParser.handle_true_false(fill_fields)
+      @max_buffer_size = Integer(ENV.fetch('OPENC3_PROTOCOL_MAX_BUFFER_SIZE', DEFAULT_MAX_BUFFER_SIZE))
     end
 
     def reset
@@ -60,6 +69,7 @@ module OpenC3
       # @return [String|nil] Data for a packet consisting of the bytes read
       def read_data(data, extra = nil)
         @data << data
+        check_buffer_size()
         @extra = extra unless (data.length == 0 and extra.nil?) # Maintain extra from last read read_data
 
         while true
@@ -192,6 +202,21 @@ module OpenC3
       return super(data, extra)
     end
 
+    # Raises if the accumulation buffer has grown past @max_buffer_size. Called
+    # from read_data by both the Ruby and the C implementations. Raising causes
+    # Interface#read to log the error and disconnect, which drops the offending
+    # peer and resets this protocol.
+    def check_buffer_size
+      length = @data.length
+      return if length <= @max_buffer_size
+
+      # Release the buffer and clear any partially reduced state now rather than
+      # waiting for the interface to disconnect and reset() us
+      reset()
+      raise "#{@interface ? @interface.name : ""}: Protocol buffer of #{length} bytes exceeds maximum of #{@max_buffer_size} bytes. " \
+            "Increase OPENC3_PROTOCOL_MAX_BUFFER_SIZE."
+    end
+
     def log_discard(length, found)
       Logger.error("#{@interface ? @interface.name : ""}: Sync #{'not ' unless found}found. Discarding #{length} bytes of data.")
       if @data.length >= 0
@@ -210,6 +235,7 @@ module OpenC3
       result['discard_leading_bytes'] = @discard_leading_bytes
       result['sync_pattern'] = @sync_pattern.inspect
       result['fill_fields'] = @fill_fields
+      result['max_buffer_size'] = @max_buffer_size
       return result
     end
 
@@ -218,6 +244,7 @@ module OpenC3
       result['discard_leading_bytes'] = @discard_leading_bytes
       result['sync_pattern'] = @sync_pattern.inspect
       result['fill_fields'] = @fill_fields
+      result['max_buffer_size'] = @max_buffer_size
       return result
     end
   end

data/lib/openc3/interfaces/protocols/length_protocol.rb

@@ -168,6 +168,13 @@ module OpenC3
       raise "Length value received larger than max_length: #{length} > #{@max_length}" if @max_length and length > @max_length
 
       packet_length = (length * @length_bytes_per_count) + @length_value_offset
+      # Reject up front rather than buffering the declared number of bytes first
+      if packet_length > @max_buffer_size
+        reset() # Drop the partial frame rather than holding it until disconnect
+        raise "Calculated packet length of #{packet_length} bytes exceeds maximum buffer size of #{@max_buffer_size} bytes. " \
+              "Increase OPENC3_PROTOCOL_MAX_BUFFER_SIZE."
+      end
+
       # Ensure the calculated packet length is long enough to support the location of the length field
       # without overlap into the next packet
       if (packet_length * 8) < (@length_bit_offset + @length_bit_size)