Hotfix api.rb (#2173)

* testing api

* formatting

core/api.rb

@@ -24,28 +24,28 @@ def initialize
       # Register timed API calls to an owner
       #
       # @param [Class] owner the owner of the API hook
-      # @param [Class] cla the API class the owner would like to hook into
+      # @param [Class] c the API class the owner would like to hook into
       # @param [String] method the method of the class the owner would like to execute
       # @param [Array] params an array of parameters that need to be matched before the owner will be called
       #
-      def register(owner, cla, method, params = [])
-        unless verify_api_path(cla, method)
-          print_error "API Registrar: Attempted to register non-existant API method #{cla} :#{method}"
+      def register(owner, c, method, params = [])
+        unless verify_api_path(c, method)
+          print_error "API Registrar: Attempted to register non-existant API method #{c} :#{method}"
           return
         end
 
-        if registered?(owner, cla, method, params)
-          print_debug "API Registrar: Attempting to re-register API call #{cla} :#{method}"
+        if registered?(owner, c, method, params)
+          print_debug "API Registrar: Attempting to re-register API call #{c} :#{method}"
           return
         end
 
         id = @count
         @registry << {
-          'id': id,
-          'owner': owner,
-          'class': cla,
-          'method': method,
-          'params': params
+          'id'     => id,
+          'owner'  => owner,
+          'class'  => c,
+          'method' => method,
+          'params' => params
         }
         @count += 1
 
@@ -56,19 +56,18 @@ def register(owner, cla, method, params = [])
       # Tests whether the owner is registered for an API hook
       #
       # @param [Class] owner the owner of the API hook
-      # @param [Class] cla the API class
+      # @param [Class] c the API class
       # @param [String] method the method of the class
       # @param [Array] params an array of parameters that need to be matched
       #
       # @return [Boolean] whether or not the owner is registered
       #
-      def registered?(owner, cla, method, params = [])
+      def registered?(owner, c, method, params = [])
         @registry.each do |r|
           next unless r['owner'] == owner
-          next unless r['class'] == cla
+          next unless r['class'] == c
           next unless r['method'] == method
           next unless is_matched_params? r, params
-
           return true
         end
         false
@@ -77,18 +76,17 @@ def registered?(owner, cla, method, params = [])
       #
       # Match a timed API call to determine if an API.fire() is required
       #
-      # @param [Class] cla the target API class
+      # @param [Class] c the target API class
       # @param [String] method the method of the target API class
       # @param [Array] params an array of parameters that need to be matched
       #
       # @return [Boolean] whether or not the arguments match an entry in the API registry
       #
-      def matched?(cla, method, params = [])
+      def matched?(c, method, params = [])
         @registry.each do |r|
-          next unless r['class'] == cla
+          next unless r['class'] == c
           next unless r['method'] == method
           next unless is_matched_params? r, params
-
           return true
         end
         false
@@ -105,20 +103,19 @@ def unregister(id)
 
       #
       # Retrieves all the owners and ID's of an API hook
-      # @param [Class] cla the target API class
+      # @param [Class] c the target API class
       # @param [String] method the method of the target API class
       # @param [Array] params an array of parameters that need to be matched
       #
       # @return [Array] an array of hashes consisting of two keys :owner and :id
       #
-      def get_owners(cla, method, params = [])
+      def get_owners(c, method, params = [])
         owners = []
         @registry.each do |r|
-          next unless r['class'] == cla
+          next unless r['class'] == c
           next unless r['method'] == method
           next unless is_matched_params? r, params
-
-          owners << { owner: r['owner'], id: r['id'] }
+          owners << { :owner => r['owner'], :id => r['id'] }
         end
         owners
       end
@@ -129,23 +126,23 @@ def get_owners(cla, method, params = [])
       #
       # @note This is a security precaution
       #
-      # @param [Class] cla the target API class to verify
-      # @param [String] met the target method to verify
+      # @param [Class] c the target API class to verify
+      # @param [String] m the target method to verify
       #
-      def verify_api_path(cla, met)
-        (cla.const_defined?('API_PATHS') && cla.const_get('API_PATHS').key?(met))
+      def verify_api_path(c, m)
+        (c.const_defined?('API_PATHS') && c.const_get('API_PATHS').key?(m))
       end
 
       #
       # Retrieves the registered symbol reference for an API hook
       #
-      # @param [Class] cla the target API class to verify
-      # @param [String] met the target method to verify
+      # @param [Class] c the target API class to verify
+      # @param [String] m the target method to verify
       #
       # @return [Symbol] the API path
       #
-      def get_api_path(cla, met)
-        verify_api_path(cla, met) ? cla.const_get('API_PATHS')[met] : nil
+      def get_api_path(c, m)
+        verify_api_path(c, m) ? c.const_get('API_PATHS')[m] : nil
       end
 
       #
@@ -174,32 +171,32 @@ def is_matched_params?(reg, params)
       #
       # Fires all owners registered to this API hook
       #
-      # @param [Class] cla the target API class
-      # @param [String] met the target API method
+      # @param [Class] c the target API class
+      # @param [String] m the target API method
       # @param [Array] *args parameters passed for the API call
       #
       # @return [Hash, NilClass] returns either a Hash of :api_id and :data
       #         if the owners return data, otherwise NilClass
       #
-      def fire(cla, met, *args)
-        mods = get_owners(cla, met, args)
+      def fire(c, m, *args)
+        mods = get_owners(c, m, args)
         return nil unless mods.length.positive?
 
-        unless verify_api_path(cla, met) && cla.ancestors[0].to_s > 'BeEF::API'
-          print_error "API Path not defined for Class: #{cla} method:#{method}"
+        unless verify_api_path(c, m) && c.ancestors[0].to_s > 'BeEF::API'
+          print_error "API Path not defined for Class: #{c} method:#{method}"
           return []
         end
 
         data = []
-        method = get_api_path(cla, met)
+        method = get_api_path(c, m)
         mods.each do |mod|
           begin
             # Only used for API Development (very verbose)
             # print_info "API: #{mod} fired #{method}"
 
             result = mod[:owner].method(method).call(*args)
             unless result.nil?
-              data << { api_id: mod[:id], data: result }
+              data << { :api_id => mod[:id], :data => result }
             end
           rescue => e
             print_error "API Fire Error: #{e.message} in #{mod}.#{method}()"
@@ -217,7 +214,7 @@ def fire(cla, met, *args)
 require 'core/api/extension'
 require 'core/api/extensions'
 require 'core/api/main/migration'
-require 'core/api/main/network_stack/assethandler'
+require 'core/api/main/network_stack/assethandler.rb'
 require 'core/api/main/server'
 require 'core/api/main/server/hook'
 require 'core/api/main/configuration'