INJECT    If set to true, this allows PowerView to work over 'stealthier' execution methods which have non-interactive contexts (e.g. WMI) (default: True)
344249
def  options(self, context, module_options):
        '''
            
        '''

        self.exec_methods = ['smbexec', 'atexec']
        self.inject = True
        if 'INJECT' in module_options:
            self.inject = bool(module_options['INJECT'])

        if self.inject: self.exec_methods = None
        self.ps_script1 = obfs_ps_script('cme_powershell_scripts/Invoke-PSInject.ps1')
        self.ps_script2 = obfs_ps_script('powersploit/Recon/PowerView.ps1')
209094
function inject (taskKey) {
    var taskName = task[taskKey]

    var num = parseFloat(taskName)

    if (!isNaN(num)) {
      funcs[taskName] = function () { return num }
    }
  }
203516
@DebugLog
    private void buildAndInject(){
        mComponent = DaggerAppComponent.builder()
                .appModule(new AppModule(this))
                .build();
        mComponent.inject(this);
    }
823371
void resolveInjectionBindings()
                    throws InjectionException
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "resolveInjectionBindings: " + this);

        Collection<InjectionBinding<A>> allInjectionBindings = ivAllAnnotationsCollection.values();
        for (InjectionBinding<A> injectionBinding : allInjectionBindings)
        {
            if (injectionBinding.ivResolveAttempted) // F87539
            {
                if (isTraceOn && tc.isDebugEnabled())
                    Tr.debug(tc, "skipping already resolved " + injectionBinding.toSimpleString());
                continue;
            }

            if (isTraceOn && tc.isDebugEnabled())
                Tr.debug(tc, "resolving " + injectionBinding.toSimpleString());

            injectionBinding.resolveJndiName(); // F743-29417
            resolve(injectionBinding);
            injectionBinding.ivResolveAttempted = true; // F87539

            InjectionScope scope = injectionBinding.getInjectionScope();
            if (scope != InjectionScope.COMP &&
                ivContext.ivSaveNonCompInjectionBindings) // F743-33811.2
            {
                if (isTraceOn && tc.isDebugEnabled())
                    Tr.debug(tc, "saving " + scope + " injection binding " + injectionBinding.toSimpleString());

                Map<Class<?>, Map<String, InjectionBinding<?>>> savedInjectionBindings;
                if (scope == InjectionScope.MODULE)
                {
                    savedInjectionBindings = ivContext.ivSavedModuleInjectionBindings;
                }
                else if (scope == InjectionScope.APP)
                {
                    savedInjectionBindings = ivContext.ivSavedAppInjectionBindings;
                }
                else
                {
                    savedInjectionBindings = ivContext.ivSavedGlobalInjectionBindings;
                }

                Map<String, InjectionBinding<A>> injectionBindingsMap = getSavedInjectionBindings(savedInjectionBindings, true);
                String jndiName = injectionBinding.getJndiName();
                InjectionBinding<A> savedBinding = injectionBindingsMap.get(jndiName);
                if (savedBinding == null)
                {
                    injectionBindingsMap.put(jndiName, injectionBinding);
                }
                else
                {
                    savedBinding.mergeSaved(injectionBinding);
                }
            }
        }

        // F743-21481
        // Add all of the InjectionBindings that this processor instance knows
        // about (these InjectionBinding instances are now resolved) so they can
        // later be used to determine the injection targets for a class.
        ivContext.ivProcessedInjectionBindings.addAll(allInjectionBindings); // F743-33811.1

        if (ivSimpleInjectionBindings != null) // F50309.5 PM88594
        {
            Collection<InjectionBinding<A>> injectionBindings = ivSimpleInjectionBindings.values();
            for (InjectionBinding<A> injectionBinding : injectionBindings)
            {
                if (isTraceOn && tc.isDebugEnabled())
                    Tr.debug(tc, "resolving " + injectionBinding.toSimpleString());

                resolve(injectionBinding);
            }

            ivContext.ivProcessedInjectionBindings.addAll(injectionBindings);
        }

        if (!ivMissingBindings.isEmpty()) {
            Iterator<String> missingBindingIter = ivMissingBindings.iterator();
            String resRefName;
            String displayName = ivNameSpaceConfig.getDisplayName();
            while (missingBindingIter.hasNext()) {
                resRefName = missingBindingIter.next();
                Tr.error(tc, "UNABLE_TO_RESOLVE_THE_RESOURCE_REFERENCE_CWNEN0044E", resRefName, displayName);
            }
            throw new InjectionException("CWNEN0044E: A resource reference binding could not be found for the following resource references " + ivMissingBindings.toString()
                                         + ", defined for the " + displayName + " component.");
        }

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "resolveInjectionBindings");
    }
682607
private static Main mainEmbeddedImpl(ContextFactory factory,
                                         Object scopeProvider,
                                         String title) {
        if (title == null) {
            title = "Rhino JavaScript Debugger (embedded usage)";
        }
        Main main = new Main(title);
        main.doBreak();
        main.setExitAction(new IProxy(IProxy.EXIT_ACTION));

        main.attachTo(factory);
        if (scopeProvider instanceof ScopeProvider) {
            main.setScopeProvider((ScopeProvider)scopeProvider);
        } else {
            Scriptable scope = (Scriptable)scopeProvider;
            if (scope instanceof Global) {
                Global global = (Global)scope;
                global.setIn(main.getIn());
                global.setOut(main.getOut());
                global.setErr(main.getErr());
            }
            main.setScope(scope);
        }

        main.pack();
        main.setSize(600, 460);
        main.setVisible(true);
        return main;
    }
583994
private static void injectImplicitly(Injector.Configuration config) {
		
		ImplicitInjectors.APPLICATION.inject(config);		
		ImplicitInjectors.RESOURCES.inject(config);
		ImplicitInjectors.SYSTEM_SERVICES.inject(config);
		ImplicitInjectors.ICKLE_SERVICES.inject(config);
		ImplicitInjectors.POJOS.inject(config);
	}
876463
private void configureFullscreen(Activity injectionActivity) {
		
		if(injectionActivity.getClass().isAnnotationPresent(Fullscreen.class)) {
			
			injectionActivity.requestWindowFeature(Window.FEATURE_NO_TITLE);
			injectionActivity.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, 
												   WindowManager.LayoutParams.FLAG_FULLSCREEN);
		}
	}
634013
@SuppressWarnings("rawtypes")
    public static void inject(final IPluginInterface plugin, final IJNRPEExecutionContext context) {

        try {
            Class clazz = plugin.getClass();
            inject(clazz, plugin, context);
            while (IPluginInterface.class.isAssignableFrom(clazz.getSuperclass())) {
                clazz = clazz.getSuperclass();
                inject(clazz, plugin, context);
            }
        } catch (Exception e) {
            throw new Error(e.getMessage(), e);
        }

    }
903324
private void injectCache(LongConsumer cacheAware) {
      if (cacheAware instanceof CacheAware) {
         ((CacheAware) cacheAware).injectCache(registry.getComponent(Cache.class));
      }
   }
124749
boolean executeInternal(String sql,
                          Map<String, ParameterBindingDTO> parameterBindings)
  throws SQLException
  {
    raiseSQLExceptionIfStatementIsClosed();
    connection.injectedDelay();

    logger.debug("execute: {}", sql);

    String trimmedSql = sql.trim();

    if (trimmedSql.length() >= 20
        && trimmedSql.toLowerCase().startsWith("set-sf-property"))
    {
      // deprecated: sfsql
      executeSetProperty(sql);
      return false;
    }

    SFBaseResultSet sfResultSet;
    try
    {
      sfResultSet = sfStatement.execute(sql, parameterBindings,
                                        SFStatement.CallingMethod.EXECUTE);
      sfResultSet.setSession(this.connection.getSfSession());
      if (resultSet != null)
      {
        openResultSets.add(resultSet);
      }
      resultSet = new SnowflakeResultSetV1(sfResultSet, this);
      queryID = sfResultSet.getQueryId();

      // Legacy behavior treats update counts as result sets for single-
      // statement execute, so we only treat update counts as update counts
      // if JDBC_EXECUTE_RETURN_COUNT_FOR_DML is set, or if a statement
      // is multi-statement
      if (!sfResultSet.getStatementType().isGenerateResultSet() &&
          (connection.getSfSession().isExecuteReturnCountForDML() ||
           sfStatement.hasChildren()))
      {
        updateCount = ResultUtil.calculateUpdateCount(sfResultSet);
        if (resultSet != null)
        {
          openResultSets.add(resultSet);
        }
        resultSet = null;
        return false;
      }

      updateCount = NO_UPDATES;
      return true;
    }
    catch (SFException ex)
    {
      throw new SnowflakeSQLException(ex.getCause(),
                                      ex.getSqlState(), ex.getVendorCode(), ex.getParams());
    }
  }
385100
private void injectAdditionalStyles() {

        try {
            Collection<String> stylesheets = OpenCms.getWorkplaceAppManager().getAdditionalStyleSheets();
            for (String stylesheet : stylesheets) {
                A_CmsUI.get().getPage().addDependency(new Dependency(Type.STYLESHEET, stylesheet));
            }
        } catch (Exception e) {
            LOG.warn(e.getLocalizedMessage(), e);
        }
    }
216813
function (instruction, evaluator, context) {
        return Promise
            .resolve(evaluator.call(context, instruction))
            .then(function () {
            if (!('viewPorts' in instruction.config)) {
                instruction.config.viewPorts = {
                    'default': {
                        moduleId: instruction.config.moduleId
                    }
                };
            }
            return instruction;
        });
    }
822017
private void configureWindowFeatures(Activity injectionActivity) {
		
		WindowFeatures windowFeatures = TypeUtils.getAnnotation(injectionActivity, WindowFeatures.class);
		
		if(windowFeatures != null) {
			
			int[] features = windowFeatures.value();
			
			for (int feature : features)
				injectionActivity.requestWindowFeature(feature);
		}
	}
1366074
function injectBefore(replServer, method, beforeFn) {
  var _orig = replServer[method];
  replServer[method] = function() {
    var args = Array.prototype.slice.call(arguments);
    var callback = args.pop();
    beforeFn.apply(null, args.concat(function(err, res) {
      if (err || res) {
        callback(err, res);
      } else {
        _orig.apply(replServer, args.concat(callback));
      }
    }));
  };
  return replServer;
}
382827
function inject() {
        if (!WIN || !needsInject) { return }
        needsInject = false;
        var style = Object.keys(byName)
          .map(function (k) { return byName[k]; })
          .concat(remainder).join('\n');
        /* istanbul ignore next */
        if (cssTextProp) { cssTextProp.cssText = style; }
        else { styleNode.innerHTML = style; }
      }
268949
function (less, pluginManager) {
        var injector = this.getInstance(less);

        // only auto inject after 2.4.0
        if (pluginManager.addPreProcessor) {
            pluginManager.addPreProcessor(injector);
        }
    }
925382
@Override
    public boolean isProcessDynamicNeeded(List<Class<?>> injectionClasses) {
        for (Class<?> klass : injectionClasses) {
            if (!ivProcessedInjectionClasses.contains(klass)) {
                return true;
            }
        }

        return false;
    }