docs: def execute(self, cmd, fname, codes=[0, None]):
          '''
          Execute a command against the specified file.
  
          @cmd   - Command to execute.
          @fname - File to run command against.
          @codes - List of return codes indicating cmd success.
  
          Returns True on success, False on failure, or None if the external extraction utility could not be found.
          '''
          tmp = None
          rval = 0
          retval = True
          command_list = []
  
          binwalk.core.common.debug("Running extractor '%s'" % str(cmd))
  
          try:
              if callable(cmd):
                  command_list.append(get_class_name_from_method(cmd))
  
                  try:
                      retval = cmd(fname)
                  except KeyboardInterrupt as e:
                      raise e
                  except Exception as e:
                      binwalk.core.common.warning("Internal extractor '%s' failed with exception: '%s'" % (str(cmd), str(e)))
              elif cmd:
                  # If not in debug mode, create a temporary file to redirect
                  # stdout and stderr to
                  if not binwalk.core.common.DEBUG:
                      tmp = tempfile.TemporaryFile()
  
                  # Generate unique file paths for all paths in the current
                  # command that are surrounded by UNIQUE_PATH_DELIMITER
                  while self.UNIQUE_PATH_DELIMITER in cmd:
                      need_unique_path = cmd.split(self.UNIQUE_PATH_DELIMITER)[
                          1].split(self.UNIQUE_PATH_DELIMITER)[0]
                      unique_path = binwalk.core.common.unique_file_name(need_unique_path)
                      cmd = cmd.replace(self.UNIQUE_PATH_DELIMITER + need_unique_path + self.UNIQUE_PATH_DELIMITER, unique_path)
  
                  # Execute.
                  for command in cmd.split("&&"):
  
                      # Replace all instances of FILE_NAME_PLACEHOLDER in the
                      # command with fname
                      command = command.strip().replace(self.FILE_NAME_PLACEHOLDER, fname)
  
                      binwalk.core.common.debug("subprocess.call(%s, stdout=%s, stderr=%s)" % (command, str(tmp), str(tmp)))
                      rval = subprocess.call(shlex.split(command), stdout=tmp, stderr=tmp)
  
                      if rval in codes:
                          retval = True
                      else:
                          retval = False
  
                      binwalk.core.common.debug('External extractor command "%s" completed with return code %d (success: %s)' % (cmd, rval, str(retval)))
                      command_list.append(command)
  
                      # TODO: Should errors from all commands in a command string be checked? Currently we only support
                      #       specifying one set of error codes, so at the moment, this is not done; it is up to the
                      #       final command to return success or failure (which presumably it will if previous necessary
                      #       commands were not successful, but this is an assumption).
                      # if retval == False:
                      #    break
  
          except KeyboardInterrupt as e:
              raise e
          except Exception as e:
              binwalk.core.common.warning("Extractor.execute failed to run external extractor '%s': %s, '%s' might not be installed correctly" % (str(cmd), str(e), str(cmd)))
              retval = None
  
          if tmp is not None:
              tmp.close()
  
          return (retval, '&&'.join(command_list))