openc3 5.17.0 → 5.18.0

data/lib/openc3/accessors/binary_accessor.rb

@@ -14,7 +14,7 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2022, OpenC3, Inc.
+# All changes Copyright 2024, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
@@ -85,8 +85,6 @@ module OpenC3
     # Valid overflow types
     OVERFLOW_TYPES = [:TRUNCATE, :SATURATE, :ERROR, :ERROR_ALLOW_HEX]
 
-    protected
-
     # Determines the endianness of the host running this code
     #
     # This method is protected to force the use of the constant
@@ -108,13 +106,175 @@ module OpenC3
       raise ArgumentError, "#{buffer.length} byte buffer insufficient to #{read_write} #{data_type} at bit_offset #{given_bit_offset} with bit_size #{given_bit_size}"
     end
 
-    public
-
     # Store the host endianness so that it only has to be determined once
     HOST_ENDIANNESS = get_host_endianness()
     # Valid endianess
     ENDIANNESS = [:BIG_ENDIAN, :LITTLE_ENDIAN]
 
+    def handle_read_variable_bit_size(item, _buffer)
+      length_value = @packet.read(item.variable_bit_size['length_item_name'], :CONVERTED)
+      if item.array_size
+        item.array_size = (length_value * item.variable_bit_size['length_bits_per_count']) + item.variable_bit_size['length_value_bit_offset']
+      else
+        if item.data_type == :INT or item.data_type == :UINT
+          # QUIC encoding is currently assumed for individual variable sized integers
+          # see https://datatracker.ietf.org/doc/html/rfc9000#name-variable-length-integer-enc
+          case length_value
+          when 0
+            item.bit_size = 6
+          when 1
+            item.bit_size = 14
+          when 2
+            item.bit_size = 30
+          else
+            item.bit_size = 62
+          end
+        else
+          item.bit_size = (length_value * item.variable_bit_size['length_bits_per_count']) + item.variable_bit_size['length_value_bit_offset']
+        end
+      end
+    end
+
+    def read_item(item, buffer)
+      return nil if item.data_type == :DERIVED
+      handle_read_variable_bit_size(item, buffer) if item.variable_bit_size
+      self.class.read_item(item, buffer)
+    end
+
+    def handle_write_variable_bit_size(item, value, buffer)
+      # Update length field to new size
+      if (item.data_type == :INT or item.data_type == :UINT) and not item.original_array_size
+        # QUIC encoding is currently assumed for individual variable sized integers
+        # see https://datatracker.ietf.org/doc/html/rfc9000#name-variable-length-integer-enc
+
+        # Calculate current bit size so we can preserve bytes after the item
+        length_item_value = @packet.read(item.variable_bit_size['length_item_name'], :CONVERTED)
+        case length_item_value
+        when 0
+          current_bit_size = 6
+        when 1
+          current_bit_size = 14
+        when 2
+          current_bit_size = 30
+        when 3
+          current_bit_size = 62
+        else
+          raise "Value #{item.variable_bit_size['length_item_name']} has unknown QUIC bit size encoding: #{length_item_value}"
+        end
+
+        if item.data_type == :UINT
+          if value <= 63
+            # Length = 0, value up to 6-bits
+            new_bit_size = 6
+            item.bit_size = new_bit_size
+            @packet.write(item.variable_bit_size['length_item_name'], 0)
+          elsif value <= 16383
+            # Length = 1, value up to 14-bits
+            new_bit_size = 14
+            item.bit_size = new_bit_size
+            @packet.write(item.variable_bit_size['length_item_name'], 1)
+          elsif value <= 1073741823
+            # Length = 2, value up to 30-bits
+            new_bit_size = 30
+            item.bit_size = new_bit_size
+            @packet.write(item.variable_bit_size['length_item_name'], 2)
+          else
+            # Length = 3, value up to 62-bits
+            new_bit_size = 62
+            item.bit_size = new_bit_size
+            @packet.write(item.variable_bit_size['length_item_name'], 3)
+          end
+        else
+          if value <= 31 and value >= -32
+            # Length = 0, value up to 6-bits
+            new_bit_size = 6
+            item.bit_size = new_bit_size
+            @packet.write(item.variable_bit_size['length_item_name'], 0)
+          elsif value <= 8191 and value >= -8192
+            # Length = 1, value up to 14-bits
+            new_bit_size = 14
+            item.bit_size = new_bit_size
+            @packet.write(item.variable_bit_size['length_item_name'], 1)
+          elsif value <= 536870911 and value >= -536870912
+            # Length = 2, value up to 30-bits
+            new_bit_size = 30
+            item.bit_size = new_bit_size
+            @packet.write(item.variable_bit_size['length_item_name'], 2)
+          else
+            # Length = 3, value up to 62-bits
+            new_bit_size = 62
+            item.bit_size = new_bit_size
+            @packet.write(item.variable_bit_size['length_item_name'], 3)
+          end
+        end
+
+        # Later items need their bit_offset adjusted by the change in this item
+        adjustment = new_bit_size - current_bit_size
+        bytes = (adjustment / 8)
+        item_offset = item.bit_offset / 8
+        if bytes > 0
+          original_length = buffer.length
+          # Add extra bytes because we're adjusting larger
+          buffer << ("\000" * bytes)
+          # We added bytes to the end so now we have to shift the buffer over
+          #   NOTE: buffer[offset, length]
+          # We copy to the shifted offset location with the remaining buffer length
+          buffer[item_offset + bytes, buffer.length - (item_offset + bytes)] =
+              # We copy from the original offset location with the original length minus the offset
+              buffer[item_offset, original_length - item_offset]
+        elsif bytes < 0
+          # Remove extra bytes because we're adjusting smaller
+          buffer[item_offset + 1, -bytes] = ''
+        end
+      # Probably not possible to get this condition because we don't allow 0 sized floats
+      # but check for it just to cover all the possible data_types
+      elsif item.data_type == :FLOAT
+        raise "Variable bit size not currently supported for FLOAT data type"
+      else
+        # STRING, BLOCK, or array types
+
+        # Calculate current bit size so we can preserve bytes after the item
+        length_item_value = @packet.read(item.variable_bit_size['length_item_name'], :CONVERTED)
+        current_bit_size = (length_item_value * item.variable_bit_size['length_bits_per_count']) + item.variable_bit_size['length_value_bit_offset']
+
+        # Calculate bits after this item
+        bits_with_item = item.bit_offset + current_bit_size
+        bits_after_item = (buffer.length * 8) - bits_with_item
+        if item.original_array_size
+          item.array_size = -bits_after_item
+        else
+          item.bit_size = -bits_after_item
+        end
+
+        new_bit_size = value.length * 8
+        length_value = (new_bit_size - item.variable_bit_size['length_value_bit_offset']) / item.variable_bit_size['length_bits_per_count']
+        @packet.write(item.variable_bit_size['length_item_name'], length_value)
+
+        # Later items need their bit_offset adjusted by the change in this item
+        adjustment = new_bit_size - current_bit_size
+      end
+
+      # Recalculate bit offsets after this item
+      if adjustment != 0 and item.bit_offset >= 0
+        @packet.sorted_items.each do |sitem|
+          if sitem.data_type == :DERIVED or sitem.bit_offset < item.bit_offset
+            # Skip items before this item and derived items and items with negative bit offsets
+            next
+          end
+          if sitem != item
+            sitem.bit_offset += adjustment
+          end
+        end
+      end
+    end
+
+    def write_item(item, value, buffer)
+      return nil if item.data_type == :DERIVED
+      handle_write_variable_bit_size(item, value, buffer) if item.variable_bit_size
+      self.class.write_item(item, value, buffer)
+    end
+
+    # Note: do not use directly - use instance read_item
     def self.read_item(item, buffer)
       return nil if item.data_type == :DERIVED
       if item.array_size
@@ -124,6 +284,7 @@ module OpenC3
       end
     end
 
+    # Note: do not use directly - use instance write_item
     def self.write_item(item, value, buffer)
       return nil if item.data_type == :DERIVED
       if item.array_size
@@ -388,7 +549,7 @@ module OpenC3
                 # String was completely empty
                 if end_bytes > 0
                   # Preserve bytes at end of buffer
-                  buffer << "\000" * value.length
+                  buffer << ("\000" * value.length)
                   buffer[lower_bound + value.length, end_bytes] = buffer[lower_bound, end_bytes]
                 end
               elsif bit_size == 0
@@ -400,7 +561,7 @@ module OpenC3
               elsif (upper_bound > old_upper_bound) && (end_bytes > 0)
                 # Preserve bytes at end of buffer
                 diff = upper_bound - old_upper_bound
-                buffer << "\000" * diff
+                buffer << ("\000" * diff)
                 buffer[upper_bound + 1, end_bytes] = buffer[old_upper_bound + 1, end_bytes]
               end
             else # given_bit_size > 0
@@ -587,7 +748,6 @@ module OpenC3
         return value
       end
 
-      protected
 
       # Check the bit size and bit offset for problems. Recalulate the bit offset
       # and return back through the passed in pointer.
@@ -705,7 +865,6 @@ module OpenC3
         (bit_size == 8) || (bit_size == 16) || (bit_size == 32) || (bit_size == 64)
       end
 
-      public
 
     end
 
@@ -948,7 +1107,7 @@ module OpenC3
             # Grow buffer and preserve bytes at end of buffer if necesssary
             buffer_length = buffer.length
             diff = upper_bound - old_upper_bound
-            buffer << ZERO_STRING * diff
+            buffer << (ZERO_STRING * diff)
             if end_bytes > 0
               buffer[(upper_bound + 1)..(buffer.length - 1)] = buffer[(old_upper_bound + 1)..(buffer_length - 1)]
             end
@@ -975,7 +1134,7 @@ module OpenC3
       end
 
       # Ensure the buffer has enough room
-      if bit_offset + num_writes * bit_size > buffer.length * 8
+      if bit_offset + (num_writes * bit_size) > buffer.length * 8
         raise_buffer_error(:write, buffer, data_type, given_bit_offset, given_bit_size)
       end
 

data/lib/openc3/api/cmd_api.rb

@@ -20,6 +20,7 @@
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
+require 'openc3/api/interface_api'
 require 'openc3/models/target_model'
 require 'openc3/topics/command_topic'
 require 'openc3/topics/command_decom_topic'
@@ -107,7 +108,7 @@ module OpenC3
     # Build a command binary
     #
     # @since 5.8.0
-    def build_cmd(*args, range_check: true, raw: false, scope: $openc3_scope, token: $openc3_token, **kwargs)
+    def build_cmd(*args, range_check: true, raw: false, manual: false, scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       case args.length
       when 1
@@ -127,31 +128,31 @@ module OpenC3
       target_name = target_name.upcase
       cmd_name = cmd_name.upcase
       cmd_params = cmd_params.transform_keys(&:upcase)
-      authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
+      authorize(permission: 'cmd_info', target_name: target_name, manual: manual, scope: scope, token: token)
       DecomInterfaceTopic.build_cmd(target_name, cmd_name, cmd_params, range_check, raw, scope: scope)
     end
     # build_command is DEPRECATED
     alias build_command build_cmd
 
     # Helper method for disable_cmd / enable_cmd
-    def _get_and_set_cmd(method, *args, scope: $openc3_scope, token: $openc3_token)
+    def _get_and_set_cmd(method, *args, manual:, scope:, token:)
       target_name, command_name = _extract_target_command_names(method, *args)
-      authorize(permission: 'admin', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+      authorize(permission: 'admin', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       command = yield TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       TargetModel.set_packet(target_name, command_name, command, type: :CMD, scope: scope)
     end
 
     # @since 5.15.1
-    def enable_cmd(*args, scope: $openc3_scope, token: $openc3_token)
-      _get_and_set_cmd('enable_cmd', *args, scope: scope, token: token) do |command|
+    def enable_cmd(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
+      _get_and_set_cmd('enable_cmd', *args, manual: manual, scope: scope, token: token) do |command|
         command['disabled'] = false
         command
       end
     end
 
     # @since 5.15.1
-    def disable_cmd(*args, scope: $openc3_scope, token: $openc3_token)
-      _get_and_set_cmd('disable_cmd', *args, scope: scope, token: token) do |command|
+    def disable_cmd(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
+      _get_and_set_cmd('disable_cmd', *args, manual: manual, scope: scope, token: token) do |command|
         command['disabled'] = true
         command
       end
@@ -161,10 +162,13 @@ module OpenC3
     #
     # @param interface_name [String] The interface to send the raw binary
     # @param data [String] The raw binary data
-    def send_raw(interface_name, data, scope: $openc3_scope, token: $openc3_token)
+    def send_raw(interface_name, data, manual: false, scope: $openc3_scope, token: $openc3_token)
       interface_name = interface_name.upcase
-      authorize(permission: 'cmd_raw', interface_name: interface_name, scope: scope, token: token)
-      get_interface(interface_name, scope: scope, token: token) # Check to make sure the interface exists
+      interface = get_interface(interface_name, scope: scope, token: token)
+      # Verify we have command authority on all the targets mapped to this interface
+      interface['cmd_target_names'].each do |target_name|
+        authorize(permission: 'cmd_raw', interface_name: interface_name, target_name: target_name, manual: manual, scope: scope, token: token)
+      end
       InterfaceTopic.write_raw(interface_name, data, scope: scope)
     end
 
@@ -173,9 +177,9 @@ module OpenC3
     # @param target_name [String] Target name of the command
     # @param command_name [String] Packet name of the command
     # @return [Hash] command hash with last command buffer
-    def get_cmd_buffer(*args, scope: $openc3_scope, token: $openc3_token)
+    def get_cmd_buffer(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, command_name = _extract_target_command_names('get_cmd_buffer', *args)
-      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       topic = "#{scope}__COMMAND__{#{target_name}}__#{command_name}"
       msg_id, msg_hash = Topic.get_newest_message(topic)
@@ -191,9 +195,9 @@ module OpenC3
     # @since 5.0.0
     # @param target_name [String] Name of the target
     # @return [Array<Hash>] Array of all commands as a hash
-    def get_all_cmds(target_name, scope: $openc3_scope, token: $openc3_token)
+    def get_all_cmds(target_name, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name = target_name.upcase
-      authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
+      authorize(permission: 'cmd_info', target_name: target_name, manual: manual, scope: scope, token: token)
       TargetModel.packets(target_name, type: :CMD, scope: scope)
     end
     # get_all_commands is DEPRECATED
@@ -204,7 +208,7 @@ module OpenC3
     # @since 5.0.6
     # @param target_name [String] Name of the target
     # @return [Array<String>] Array of all command packet names
-    def get_all_cmd_names(target_name, hidden: false, scope: $openc3_scope, token: $openc3_token)
+    def get_all_cmd_names(target_name, hidden: false, manual: false, scope: $openc3_scope, token: $openc3_token)
       begin
         packets = get_all_cmds(target_name, scope: scope, token: token)
       rescue RuntimeError
@@ -227,9 +231,9 @@ module OpenC3
     #
     # @since 5.0.0
     # @return [Hash] Command as a hash
-    def get_cmd(*args, scope: $openc3_scope, token: $openc3_token)
+    def get_cmd(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, command_name = _extract_target_command_names('get_cmd', *args)
-      authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
+      authorize(permission: 'cmd_info', target_name: target_name, manual: manual, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
     end
     # get_command is DEPRECATED
@@ -242,9 +246,9 @@ module OpenC3
     # @param command_name [String] Name of the packet
     # @param parameter_name [String] Name of the parameter
     # @return [Hash] Command parameter as a hash
-    def get_param(*args, scope: $openc3_scope, token: $openc3_token)
+    def get_param(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, command_name, parameter_name = _extract_target_command_parameter_names('get_param', *args)
-      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       TargetModel.packet_item(target_name, command_name, parameter_name, type: :CMD, scope: scope)
     end
     # get_parameter is DEPRECATED
@@ -258,7 +262,7 @@ module OpenC3
     #
     # @param args [String|Array<String>] See the description for calling style
     # @return [Boolean] Whether the command is hazardous
-    def get_cmd_hazardous(*args, scope: $openc3_scope, token: $openc3_token, **kwargs)
+    def get_cmd_hazardous(*args, manual: false, scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       case args.length
       when 1
@@ -279,7 +283,7 @@ module OpenC3
       command_name = command_name.upcase
       parameters = parameters.transform_keys(&:upcase)
 
-      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       packet = TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       return true if packet['hazardous']
 
@@ -307,7 +311,7 @@ module OpenC3
     #   get_cmd_value("TGT PKT ITEM", type: :RAW)
     #   get_cmd_value("TGT", "PKT", "ITEM", type: :RAW)
     #   get_cmd_value("TGT", "PKT", "ITEM", :RAW) # DEPRECATED
-    def get_cmd_value(*args, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token)
+    def get_cmd_value(*args, type: :CONVERTED, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name = nil
       command_name = nil
       parameter_name = nil
@@ -330,7 +334,7 @@ module OpenC3
       if target_name.nil? or command_name.nil? or parameter_name.nil?
         raise "ERROR: Target name, command name and parameter name required. Usage: get_cmd_value(\"TGT CMD PARAM\") or #{method_name}(\"TGT\", \"CMD\", \"PARAM\")"
       end
-      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       CommandDecomTopic.get_cmd_item(target_name, command_name, parameter_name, type: type, scope: scope)
     end
 
@@ -341,8 +345,8 @@ module OpenC3
     # @param command_name [String] Packet name of the command. If not given then
     #    then most recent time from the given target will be returned.
     # @return [Array<Target Name, Command Name, Time Seconds, Time Microseconds>]
-    def get_cmd_time(target_name = nil, command_name = nil, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+    def get_cmd_time(target_name = nil, command_name = nil, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       if target_name and command_name
         target_name = target_name.upcase
         command_name = command_name.upcase
@@ -379,9 +383,9 @@ module OpenC3
     # @param target_name [String] Target name of the command
     # @param command_name [String] Packet name of the command
     # @return [Numeric] Transmit count for the command
-    def get_cmd_cnt(*args, scope: $openc3_scope, token: $openc3_token)
+    def get_cmd_cnt(*args, manual: false, scope: $openc3_scope, token: $openc3_token)
       target_name, command_name = _extract_target_command_names('get_cmd_cnt', *args)
-      authorize(permission: 'system', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+      authorize(permission: 'system', target_name: target_name, packet_name: command_name, manual: manual, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       Topic.get_cnt("#{scope}__COMMAND__{#{target_name}}__#{command_name}")
     end
@@ -390,8 +394,8 @@ module OpenC3
     #
     # @param target_commands [Array<Array<String, String>>] Array of arrays containing target_name, packet_name
     # @return [Numeric] Transmit count for the command
-    def get_cmd_cnts(target_commands, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_cmd_cnts(target_commands, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       unless target_commands.is_a?(Array) and target_commands[0].is_a?(Array)
         raise "get_cmd_cnts takes an array of arrays containing target, packet_name, e.g. [['INST', 'COLLECT'], ['INST', 'ABORT']]"
       end
@@ -448,8 +452,8 @@ module OpenC3
       return [target_name, command_name, parameter_name]
     end
 
-    def _cmd_implementation(method_name, *args, range_check:, hazardous_check:, raw:, timeout: nil, log_message: nil,
-                           scope: $openc3_scope, token: $openc3_token, **kwargs)
+    def _cmd_implementation(method_name, *args, range_check:, hazardous_check:, raw:, timeout: nil, log_message: nil, manual: false,
+                            scope: $openc3_scope, token: $openc3_token, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       unless [nil, true, false].include?(log_message)
         raise "Invalid log_message parameter: #{log_message}. Must be true or false."
@@ -480,7 +484,7 @@ module OpenC3
       target_name = target_name.upcase
       cmd_name = cmd_name.upcase
       cmd_params = cmd_params.transform_keys(&:upcase)
-      authorize(permission: 'cmd', target_name: target_name, packet_name: cmd_name, scope: scope, token: token)
+      authorize(permission: 'cmd', target_name: target_name, packet_name: cmd_name, manual: manual, scope: scope, token: token)
       packet = TargetModel.packet(target_name, cmd_name, type: :CMD, scope: scope)
       if packet['disabled']
         error = DisabledError.new
@@ -503,7 +507,7 @@ module OpenC3
         log_message = false if packet["messages_disabled"]
         # Check if any of the parameters have DISABLE_MESSAGES
         cmd_params.each do |key, value|
-          item = packet['items'].find { |item| item['name'] == key.to_s }
+          item = packet['items'].find { |find_item| find_item['name'] == key.to_s }
           if item && item['states'] && item['states'][value] && item['states'][value]["messages_disabled"]
             log_message = false
           end
@@ -525,7 +529,7 @@ module OpenC3
         cmd_params.each do |key, value|
           next if Packet::RESERVED_ITEM_NAMES.include?(key)
 
-          item = packet['items'].find { |item| item['name'] == key.to_s }
+          item = packet['items'].find { |find_item| find_item['name'] == key.to_s }
 
           begin
             item_type = item['data_type'].intern

data/lib/openc3/api/config_api.rb

@@ -33,28 +33,28 @@ module OpenC3
       'delete_config'
     ])
 
-    def config_tool_names(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def config_tool_names(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       ToolConfigModel.config_tool_names(scope: scope)
     end
 
-    def list_configs(tool, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def list_configs(tool, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       ToolConfigModel.list_configs(tool, scope: scope)
     end
 
-    def load_config(tool, name, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def load_config(tool, name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       ToolConfigModel.load_config(tool, name, scope: scope)
     end
 
-    def save_config(tool, name, data, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', scope: scope, token: token)
+    def save_config(tool, name, data, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system_set', manual: manual, scope: scope, token: token)
       ToolConfigModel.save_config(tool, name, data, scope: scope)
     end
 
-    def delete_config(tool, name, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', scope: scope, token: token)
+    def delete_config(tool, name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system_set', manual: manual, scope: scope, token: token)
       ToolConfigModel.delete_config(tool, name, scope: scope)
     end
   end

data/lib/openc3/api/interface_api.rb

@@ -45,8 +45,8 @@ module OpenC3
     # @since 5.0.0
     # @param interface_name [String] Interface name
     # @return [Hash] Hash of all the interface information
-    def get_interface(interface_name, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', interface_name: interface_name, scope: scope, token: token)
+    def get_interface(interface_name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', interface_name: interface_name, manual: manual, scope: scope, token: token)
       interface = InterfaceModel.get(name: interface_name, scope: scope)
       raise "Interface '#{interface_name}' does not exist" unless interface
 
@@ -54,8 +54,8 @@ module OpenC3
     end
 
     # @return [Array<String>] All the interface names
-    def get_interface_names(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_interface_names(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       InterfaceModel.names(scope: scope)
     end
 
@@ -63,24 +63,27 @@ module OpenC3
     #
     # @param interface_name [String] The name of the interface
     # @param interface_params [Array] Optional parameters to pass to the interface
-    def connect_interface(interface_name, *interface_params, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
+    def connect_interface(interface_name, *interface_params, manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', interface_name: interface_name, manual: manual, scope: scope, token: token)
       InterfaceTopic.connect_interface(interface_name, *interface_params, scope: scope)
     end
 
     # Disconnects from an interface and kills its telemetry gathering thread
     #
     # @param interface_name [String] The name of the interface
-    def disconnect_interface(interface_name, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
+    def disconnect_interface(interface_name, manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', interface_name: interface_name, manual: manual, scope: scope, token: token)
       InterfaceTopic.disconnect_interface(interface_name, scope: scope)
     end
 
     # Starts raw logging for an interface
     #
     # @param interface_name [String] The name of the interface
-    def start_raw_logging_interface(interface_name = 'ALL', scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
+    def start_raw_logging_interface(interface_name = 'ALL', manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', interface_name: interface_name, manual: manual, scope: scope, token: token)
       if interface_name == 'ALL'
         get_interface_names().each do |interface_name|
           InterfaceTopic.start_raw_logging(interface_name, scope: scope)
@@ -93,8 +96,9 @@ module OpenC3
     # Stop raw logging for an interface
     #
     # @param interface_name [String] The name of the interface
-    def stop_raw_logging_interface(interface_name = 'ALL', scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
+    def stop_raw_logging_interface(interface_name = 'ALL', manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', interface_name: interface_name, manual: manual, scope: scope, token: token)
       if interface_name == 'ALL'
         get_interface_names().each do |interface_name|
           InterfaceTopic.stop_raw_logging(interface_name, scope: scope)
@@ -110,10 +114,10 @@ module OpenC3
     #   Numeric, Numeric>>] Array of Arrays containing \[name, state, num clients,
     #   TX queue size, RX queue size, TX bytes, RX bytes, Command count,
     #   Telemetry count] for all interfaces
-    def get_all_interface_info(scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system', scope: scope, token: token)
+    def get_all_interface_info(manual: false, scope: $openc3_scope, token: $openc3_token)
+      authorize(permission: 'system', manual: manual, scope: scope, token: token)
       info = []
-      InterfaceStatusModel.all(scope: scope).each do |int_name, int|
+      InterfaceStatusModel.all(scope: scope).each do |_int_name, int|
         info << [int['name'], int['state'], int['clients'], int['txsize'], int['rxsize'],
                  int['txbytes'], int['rxbytes'], int['txcnt'], int['rxcnt']]
       end
@@ -127,8 +131,9 @@ module OpenC3
     #
     # @param target_name [String/Array] The name of the target(s)
     # @param interface_name (see #connect_interface)
-    def map_target_to_interface(target_name, interface_name, cmd_only: false, tlm_only: false, unmap_old: true, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
+    def map_target_to_interface(target_name, interface_name, cmd_only: false, tlm_only: false, unmap_old: true, manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', interface_name: interface_name, manual: manual, scope: scope, token: token)
       new_interface = InterfaceModel.get_model(name: interface_name, scope: scope)
       if Array === target_name
         target_names = target_name
@@ -142,13 +147,15 @@ module OpenC3
       nil
     end
 
-    def interface_cmd(interface_name, cmd_name, *cmd_params, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
+    def interface_cmd(interface_name, cmd_name, *cmd_params, manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', interface_name: interface_name, manual: manual, scope: scope, token: token)
       InterfaceTopic.interface_cmd(interface_name, cmd_name, *cmd_params, scope: scope)
     end
 
-    def interface_protocol_cmd(interface_name, cmd_name, *cmd_params, read_write: :READ_WRITE, index: -1, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'system_set', interface_name: interface_name, scope: scope, token: token)
+    def interface_protocol_cmd(interface_name, cmd_name, *cmd_params, read_write: :READ_WRITE, index: -1, manual: false, scope: $openc3_scope, token: $openc3_token)
+      # TODO: Check if they have command authority for the targets mapped to this interface
+      authorize(permission: 'system_set', interface_name: interface_name, manual: manual, scope: scope, token: token)
       InterfaceTopic.protocol_cmd(interface_name, cmd_name, *cmd_params, read_write: read_write, index: index, scope: scope)
     end
   end