Merge branch 'master' into feature/udp-scanner-mixin

Author: jvazquez-r7

lib/msf/core/module_set.rb

@@ -169,12 +169,14 @@ def on_module_reload(mod)
   end
 
   # @!attribute [rw] postpone_recalc
-  #   Whether or not recalculations should be postponed.  This is used from the context of the each_module_list
-  #   handler in order to prevent the demand # loader from calling recalc for each module if it's possible that more
-  #   than one module may be loaded.  This field is not initialized until used.
+  #   Whether or not recalculations should be postponed.  This is used
+  #   from the context of the {#each_module_list} handler in order to
+  #   prevent the demand loader from calling recalc for each module if
+  #   it's possible that more than one module may be loaded.  This field
+  #   is not initialized until used.
   #
-  #   @return [true] if recalculate should not be called immediately
-  #   @return [false] if recalculate should be called immediately
+  #   @return [true] if {#recalculate} should not be called immediately
+  #   @return [false] if {#recalculate} should be called immediately
   attr_accessor :postpone_recalculate
 
   # Dummy placeholder to recalculate aliases and other fun things.
@@ -217,10 +219,10 @@ def add_module(mod, name, modinfo = nil)
 
       # TODO this isn't terribly helpful since the refnames will always match, that's why they are ambiguous.
       wlog("The module #{mod.refname} is ambiguous with #{self[name].refname}.")
-    else
-      self[name] = mod
     end
 
+    self[name] = mod
+
     mod
   end
 

lib/msf/core/modules/loader/base.rb

@@ -125,7 +125,7 @@ def load_module(parent_path, type, module_reference_name, options={})
 	    return false
     end
 
-    loaded = namespace_module_transaction(type + "/" + module_reference_name, :reload => reload) { |namespace_module|
+    try_eval_module = lambda { |namespace_module|
       # set the parent_path so that the module can be reloaded with #load_module
       namespace_module.parent_path = parent_path
 
@@ -173,29 +173,22 @@ def load_module(parent_path, type, module_reference_name, options={})
         return false
       end
 
-      ilog("Loaded #{type} module #{module_reference_name} under #{parent_path}", 'core', LEV_2)
+      if reload
+        ilog("Reloading #{type} module #{module_reference_name}. Ambiguous module warnings are safe to ignore", 'core', LEV_2)
+      else
+        ilog("Loaded #{type} module #{module_reference_name} under #{parent_path}", 'core', LEV_2)
+      end
 
       module_manager.module_load_error_by_path.delete(module_path)
 
       true
     }
 
+    loaded = namespace_module_transaction(type + "/" + module_reference_name, :reload => reload, &try_eval_module)
     unless loaded
       return false
     end
 
-    if reload
-      # Delete the original copy of the module so that module_manager.on_load_module called from inside load_module does
-      # not trigger an ambiguous name warning, which would cause the reloaded module to not be stored in the
-      # ModuleManager.
-      module_manager.delete(module_reference_name)
-
-	    # Delete the original copy of the module in the type-specific module set stores the reloaded module and doesn't
-	    # trigger an ambiguous name warning
-	    module_set = module_manager.module_set(type)
-	    module_set.delete(module_reference_name)
-    end
-
     # Do some processing on the loaded module to get it into the right associations
     module_manager.on_module_load(
         metasploit_class,