Java Code Examples for java.security.AccessController

/**
 * Set property to given value.
 * <p>
 * Specifying a null value will cause the property to be cleared
 *
 * @param name
 * @param value
 * @return previous value
 */
private static String setProperty(final String name, final String value) {

    final PrivilegedAction<String> action;
    if (value != null)
        action = new PrivilegedAction<String>() {

            @Override
            public String run() {

                return System.setProperty(name, value);
            }
        };
    else
        action = new PrivilegedAction<String>() {

            @Override
            public String run() {

                return System.clearProperty(name);
            }
        };
    return AccessController.doPrivileged(action);
}
 

/**
 * Clear all sessions from the Store.
 */
public void clearStore() {

    if (store == null)
        return;

    try {     
        if (SecurityUtil.isPackageProtectionEnabled()){
            try{
                AccessController.doPrivileged(new PrivilegedStoreClear());
            }catch(PrivilegedActionException ex){
                Exception exception = ex.getException();
                log.error("Exception clearing the Store: " + exception,
                        exception);
            }
        } else {
            store.clear();
        }
    } catch (IOException e) {
        log.error("Exception clearing the Store: " + e, e);
    }

}
 

/**
 * <p>
 * @return the java.ext.dirs property as a list of directory
 * </p>
 */
private static File[] getExtDirs() {
    String s = java.security.AccessController.doPrivileged(
            new sun.security.action.GetPropertyAction("java.ext.dirs"));

    File[] dirs;
    if (s != null) {
        StringTokenizer st =
            new StringTokenizer(s, File.pathSeparator);
        int count = st.countTokens();
        debug("getExtDirs count " + count);
        dirs = new File[count];
        for (int i = 0; i < count; i++) {
            dirs[i] = new File(st.nextToken());
            debug("getExtDirs dirs["+i+"] "+ dirs[i]);
        }
    } else {
        dirs = new File[0];
        debug("getExtDirs dirs " + dirs);
    }
    debug("getExtDirs dirs.length " + dirs.length);
    return dirs;
}
 

/**
 * Executes the method of the specified <code>ApplicationContext</code>
 * @param method The method object to be invoked.
 * @param context The AppliationContext object on which the method
 *                   will be invoked
 * @param params The arguments passed to the called method.
 */
private Object executeMethod(final Method method, 
                             final ApplicationContext context,
                             final Object[] params) 
        throws PrivilegedActionException, 
               IllegalAccessException,
               InvocationTargetException {
                                 
    if (SecurityUtil.isPackageProtectionEnabled()){
       return AccessController.doPrivileged(new PrivilegedExceptionAction<Object>(){
            @Override
            public Object run() throws IllegalAccessException, InvocationTargetException{
                return method.invoke(context,  params);
            }
        });
    } else {
        return method.invoke(context, params);
    }        
}
 

/**
 * Check if the system property org.newdawn.slick.verboseLog is set to true.
 * If this is the case we activate the verbose logging mode
 */
public static void checkVerboseLogSetting() {
	try {
		AccessController.doPrivileged(new PrivilegedAction() {
            public Object run() {
				String val = System.getProperty(Log.forceVerboseProperty);
				if ((val != null) && (val.equalsIgnoreCase(Log.forceVerbosePropertyOnValue))) {
					Log.setForcedVerboseOn();
				}
				
				return null;
            }
		});
	} catch (Throwable e) {
		// ignore, security failure - probably an applet
	}
}
 

private static URLStreamHandler lookupViaProviders(final String protocol) {
    if (gate.get() != null)
        throw new Error("Circular loading of URL stream handler providers detected");

    gate.set(gate);
    try {
        return AccessController.doPrivileged(
            new PrivilegedAction<>() {
                public URLStreamHandler run() {
                    Iterator<URLStreamHandlerProvider> itr = providers();
                    while (itr.hasNext()) {
                        URLStreamHandlerProvider f = itr.next();
                        URLStreamHandler h = f.createURLStreamHandler(protocol);
                        if (h != null)
                            return h;
                    }
                    return null;
                }
            });
    } finally {
        gate.set(null);
    }
}
 

/**
 * Initializes the input method selection key definition in preference trees
 */
private void initializeInputMethodSelectionKey() {
    AccessController.doPrivileged(new PrivilegedAction<Object>() {
        public Object run() {
            // Look in user's tree
            Preferences root = Preferences.userRoot();
            inputMethodSelectionKey = getInputMethodSelectionKeyStroke(root);

            if (inputMethodSelectionKey == null) {
                // Look in system's tree
                root = Preferences.systemRoot();
                inputMethodSelectionKey = getInputMethodSelectionKeyStroke(root);
            }
            return null;
        }
    });
}
 

@Override
public Object getAttribute(final String name, final int scope) {

	if (name == null) {
		throw new NullPointerException(Localizer.getMessage("jsp.error.attribute.null_name"));
	}

	if (SecurityUtil.isPackageProtectionEnabled()) {
		return AccessController.doPrivileged(new PrivilegedAction<Object>() {
			@Override
			public Object run() {
				return doGetAttribute(name, scope);
			}
		});
	} else {
		return doGetAttribute(name, scope);
	}

}
 

private static Method getDeclaredMethod(final Class cl, final String methodName, final Class[] args,
                                 final int requiredModifierMask,
                                 final int disallowedModifierMask) {
    return (Method) AccessController.doPrivileged(new PrivilegedAction() {
        public Object run() {
            Method method = null;
            try {
                method =
                    cl.getDeclaredMethod(methodName, args);
                    int mods = method.getModifiers();
                    if ((mods & disallowedModifierMask) != 0 ||
                        (mods & requiredModifierMask) != requiredModifierMask) {
                        method = null;
                    }
                    //if (!Modifier.isPrivate(mods) ||
                    //    Modifier.isStatic(mods)) {
                    //    method = null;
                    //}
            } catch (NoSuchMethodException e) {
            // Since it is alright if methodName does not exist,
            // no need to do anything special here.
            }
            return method;
        }
    });
}
 

public void handle(final Callback[] callbacks)
        throws java.io.IOException, UnsupportedCallbackException {
    try {
        java.security.AccessController.doPrivileged
            (new java.security.PrivilegedExceptionAction<Void>() {
            public Void run() throws java.io.IOException,
                                UnsupportedCallbackException {
                ch.handle(callbacks);
                return null;
            }
        }, acc);
    } catch (java.security.PrivilegedActionException pae) {
        if (pae.getException() instanceof java.io.IOException) {
            throw (java.io.IOException)pae.getException();
        } else {
            throw (UnsupportedCallbackException)pae.getException();
        }
    }
}
 

/**
 * Retrieve the configuration associated with the specified classloader. If
 * it does not exist, it will be created.
 * 
 * @param classLoader The classloader for which we will retrieve or build the 
 *                    configuration
 */
protected synchronized ClassLoaderLogInfo getClassLoaderInfo(ClassLoader classLoader) {
    
    if (classLoader == null) {
        classLoader = ClassLoader.getSystemClassLoader();
    }
    ClassLoaderLogInfo info = classLoaderLoggers.get(classLoader);
    if (info == null) {
        final ClassLoader classLoaderParam = classLoader;
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            @Override
            public Void run() {
                try {
                    readConfiguration(classLoaderParam);
                } catch (IOException e) {
                    // Ignore
                }
                return null;
            }
        });
        info = classLoaderLoggers.get(classLoader);
    }
    return info;
}
 

private static synchronized void registerCleaner(PoolCleaner cleaner) {
    unregisterCleaner(cleaner);
    cleaners.add(cleaner);
    if (poolCleanTimer == null) {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        try {
            Thread.currentThread().setContextClassLoader(ConnectionPool.class.getClassLoader());
            // Create the timer thread in a PrivilegedAction so that a
            // reference to the web application class loader is not created
            // via Thread.inheritedAccessControlContext
            PrivilegedAction<Timer> pa = new PrivilegedNewTimer();
            poolCleanTimer = AccessController.doPrivileged(pa);
        } finally {
            Thread.currentThread().setContextClassLoader(loader);
        }
    }
    poolCleanTimer.schedule(cleaner, cleaner.sleepTime,cleaner.sleepTime);
}
 

private final static void initMainAppContext() {
    // On the main Thread, we get the ThreadGroup, make a corresponding
    // AppContext, and instantiate the Java EventQueue.  This way, legacy
    // code is unaffected by the move to multiple AppContext ability.
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {
            ThreadGroup currentThreadGroup =
                    Thread.currentThread().getThreadGroup();
            ThreadGroup parentThreadGroup = currentThreadGroup.getParent();
            while (parentThreadGroup != null) {
                // Find the root ThreadGroup to construct our main AppContext
                currentThreadGroup = parentThreadGroup;
                parentThreadGroup = currentThreadGroup.getParent();
            }

            mainAppContext = SunToolkit.createNewAppContext(currentThreadGroup);
            return null;
        }
    });
}
 

/**
 * Registers a target for a tie. Adds the tie to an internal table and calls
 * {@link Tie#setTarget} on the tie object.
 * @param tie the tie to register.
 * @param target the target for the tie.
 */
public void registerTarget(javax.rmi.CORBA.Tie tie, java.rmi.Remote target)
{
    synchronized (exportedServants) {
        // Do we already have this target registered?
        if (lookupTie(target) == null) {
            // No, so register it and set the target...
            exportedServants.put(target,tie);
            tie.setTarget(target);

            // Do we need to instantiate our keep-alive thread?
            if (keepAlive == null) {
                // Yes. Instantiate our keep-alive thread and start
                // it up...
                keepAlive = (KeepAlive)AccessController.doPrivileged(new PrivilegedAction() {
                    public java.lang.Object run() {
                        return new KeepAlive();
                    }
                });
                keepAlive.start();
            }
        }
    }
}
 

WindowsFileSystem(WindowsFileSystemProvider provider,
                  String dir)
{
    this.provider = provider;

    // parse default directory and check it is absolute
    WindowsPathParser.Result result = WindowsPathParser.parse(dir);

    if ((result.type() != WindowsPathType.ABSOLUTE) &&
        (result.type() != WindowsPathType.UNC))
        throw new AssertionError("Default directory is not an absolute path");
    this.defaultDirectory = result.path();
    this.defaultRoot = result.root();

    PrivilegedAction<String> pa = new GetPropertyAction("os.version");
    String osversion = AccessController.doPrivileged(pa);
    String[] vers = Util.split(osversion, '.');
    int major = Integer.parseInt(vers[0]);
    int minor = Integer.parseInt(vers[1]);

    // symbolic links available on Vista and newer
    supportsLinks = (major >= 6);

    // enumeration of data streams available on Windows Server 2003 and newer
    supportsStreamEnumeration = (major >= 6) || (major == 5 && minor >= 2);
}
 

/** Load properties from a file.
    This method tries to load properties from the filename give into
    the passed properties object.
    If the file cannot be found or something else goes wrong,
    the method silently fails.
    @param properties The properties bundle to store the values of the
    properties file.
    @param filename The filename of the properties file to load. This
    filename is interpreted as relative to the subdirectory "lib" in
    the JRE directory.
 */
static void loadProperties(final Properties properties,
                           final String filename) {
    if(hasSecurityManager()) {
        try {
            // invoke the privileged action using 1.2 security
            PrivilegedAction<Void> action = new PrivilegedAction<Void>() {
                    public Void run() {
                        loadPropertiesImpl(properties, filename);
                        return null;
                    }
                };
            AccessController.doPrivileged(action);
            if(Printer.debug)Printer.debug("Loaded properties with JDK 1.2 security");
        } catch (Exception e) {
            if(Printer.debug)Printer.debug("Exception loading properties with JDK 1.2 security");
            // try without using JDK 1.2 security
            loadPropertiesImpl(properties, filename);
        }
    } else {
        // not JDK 1.2 security, assume we already have permission
        loadPropertiesImpl(properties, filename);
    }
}
 

private final static void initMainAppContext() {
    // On the main Thread, we get the ThreadGroup, make a corresponding
    // AppContext, and instantiate the Java EventQueue.  This way, legacy
    // code is unaffected by the move to multiple AppContext ability.
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {
            ThreadGroup currentThreadGroup =
                    Thread.currentThread().getThreadGroup();
            ThreadGroup parentThreadGroup = currentThreadGroup.getParent();
            while (parentThreadGroup != null) {
                // Find the root ThreadGroup to construct our main AppContext
                currentThreadGroup = parentThreadGroup;
                parentThreadGroup = currentThreadGroup.getParent();
            }

            mainAppContext = SunToolkit.createNewAppContext(currentThreadGroup);
            return null;
        }
    });
}
 

private static Long getSerialVersion(final long csuid, final Class cl)
{
    return (Long) AccessController.doPrivileged(new PrivilegedAction() {
      public Object run() {
        long suid;
        try {
            final Field f = cl.getDeclaredField("serialVersionUID");
            int mods = f.getModifiers();
            if (Modifier.isStatic(mods) &&
                Modifier.isFinal(mods) && Modifier.isPrivate(mods)) {
                suid = csuid;
             } else {
                suid = _computeSerialVersionUID(cl);
             }
          } catch (NoSuchFieldException ex) {
              suid = _computeSerialVersionUID(cl);
          //} catch (IllegalAccessException ex) {
          //     suid = _computeSerialVersionUID(cl);
          }
          return new Long(suid);
       }
    });
}
 

/**
 * Returns an output stream for this socket.
 *
 * <p> If this socket has an associated channel then the resulting output
 * stream delegates all of its operations to the channel.  If the channel
 * is in non-blocking mode then the output stream's {@code write}
 * operations will throw an {@link
 * java.nio.channels.IllegalBlockingModeException}.
 *
 * <p> Closing the returned {@link java.io.OutputStream OutputStream}
 * will close the associated socket.
 *
 * @return     an output stream for writing bytes to this socket.
 * @exception  IOException  if an I/O error occurs when creating the
 *               output stream or if the socket is not connected.
 * @revised 1.4
 * @spec JSR-51
 */
public OutputStream getOutputStream() throws IOException {
    if (isClosed())
        throw new SocketException("Socket is closed");
    if (!isConnected())
        throw new SocketException("Socket is not connected");
    if (isOutputShutdown())
        throw new SocketException("Socket output is shutdown");
    final Socket s = this;
    OutputStream os = null;
    try {
        os = AccessController.doPrivileged(
            new PrivilegedExceptionAction<OutputStream>() {
                public OutputStream run() throws IOException {
                    return impl.getOutputStream();
                }
            });
    } catch (java.security.PrivilegedActionException e) {
        throw (IOException) e.getException();
    }
    return os;
}
 

protected Class<?> loadClassMaybePrivileged(final String className, final ClassLoader classLoader) throws ClassNotFoundException {
    Class<?> clazz;
    if (SecurityUtil.isPackageProtectionEnabled()) {
        try {
            clazz = AccessController.doPrivileged(new PrivilegedExceptionAction<Class<?>>() {

                public Class<?> run() throws Exception {
                    return loadClass(className, classLoader);
                }
            });
        } catch (PrivilegedActionException e) {
            Throwable t = e.getCause();
            if (t instanceof ClassNotFoundException) {
                throw (ClassNotFoundException) t;
            }
            throw new RuntimeException(t);
        }
    } else {
        clazz = loadClass(className, classLoader);
    }
    checkAccess(clazz);
    return clazz;
}
 

private static void initDBBConstructor() {
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
                try {
                    Class<?> cl = Class.forName("java.nio.DirectByteBuffer");
                    Constructor<?> ctor = cl.getDeclaredConstructor(
                        new Class<?>[] { int.class,
                                         long.class,
                                         FileDescriptor.class,
                                         Runnable.class });
                    ctor.setAccessible(true);
                    directByteBufferConstructor = ctor;
                } catch (ClassNotFoundException   |
                         NoSuchMethodException    |
                         IllegalArgumentException |
                         ClassCastException x) {
                    throw new InternalError(x);
                }
                return null;
            }});
}
 

/**
 * Check if the system property org.newdawn.slick.verboseLog is set to true.
 * If this is the case we activate the verbose logging mode
 */
public static void checkVerboseLogSetting() {
	try {
		AccessController.doPrivileged(new PrivilegedAction() {
            public Object run() {
				String val = System.getProperty(Log.forceVerboseProperty);
				if ((val != null) && (val.equalsIgnoreCase(Log.forceVerbosePropertyOnValue))) {
					Log.setForcedVerboseOn();
				}
				
				return null;
            }
		});
	} catch (Throwable e) {
		// ignore, security failure - probably an applet
	}
}
 

/**
 * Helper method to execute a callback on a given field. This method encapsulates the error handling logic and the
 * handling of accessibility of the field. The difference to
 * {@link ReflectionUtils#accessField(Field, Callable, String)} is that this method takes a callback that doesn't
 * return anything but only creates a sideeffect.
 *
 * After the callback is executed the accessibility of the field will be reset to the originally state.
 *
 * @param field
 *            the field that is made accessible to run the callback
 * @param sideEffect
 *            the callback that will be executed.
 * @param errorMessage
 *            the error message that is used in the exception when something went wrong.
 *			
 * @throws IllegalStateException
 *             when something went wrong.
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
   public static void accessField(final Field field, final SideEffect sideEffect, String errorMessage) {
	if (sideEffect == null) {
		return;
	}
	AccessController.doPrivileged((PrivilegedAction) () -> {
		boolean wasAccessible = field.isAccessible();
		try {
			field.setAccessible(true);
			sideEffect.call();
		} catch (Exception exception) {
			throw new IllegalStateException(errorMessage, exception);
		} finally {
			field.setAccessible(wasAccessible);
		}
		return null;
	});
}
 

@Override
public void processDocument(String inputText, IngestDocument ingestDocument) throws Exception {
    // call /sentiment endpoint and set the top result in the field
    DocumentRequest<SentimentOptions> request = new DocumentRequest.Builder<SentimentOptions>().content(inputText).build();
    SentimentResponse response;
    try {
        // RosApi client binding's Jackson needs elevated privilege
        response = AccessController.doPrivileged((PrivilegedAction<SentimentResponse>) () ->
                rosAPI.getHttpRosetteAPI().perform(HttpRosetteAPI.SENTIMENT_SERVICE_PATH, request, SentimentResponse.class)
        );
    } catch (HttpRosetteAPIException ex) {
        LOGGER.error(ex.getErrorResponse().getMessage());
        throw new ElasticsearchException(ex.getErrorResponse().getMessage(), ex);
    }

    if (response.getDocument() != null
            && !Strings.isNullOrEmpty(response.getDocument().getLabel())) {
        ingestDocument.setFieldValue(targetField, response.getDocument().getLabel());
    } else {
        throw new ElasticsearchException(TYPE + " ingest processor failed to determine sentiment of document.");
    }
}
 

/**
 * Convenience function for getting system properties in a safe way
 *
 * @param name of integer property
 * @param defValue the default value if unset
 * @return integer property if set or default value
 */
public static int getIntProperty(final String name, final int defValue) {
    name.getClass(); // null check
    if (! name.startsWith("nashorn.")) {
        throw new IllegalArgumentException(name);
    }

    return AccessController.doPrivileged(
            new PrivilegedAction<Integer>() {
                @Override
                public Integer run() {
                    try {
                        return Integer.getInteger(name, defValue);
                    } catch (final SecurityException e) {
                        // if no permission to read, assume the default value
                        return defValue;
                    }
                }
            }, READ_PROPERTY_ACC_CTXT);
}
 

/**
 * Registers a target for a tie. Adds the tie to an internal table and calls
 * {@link Tie#setTarget} on the tie object.
 * @param tie the tie to register.
 * @param target the target for the tie.
 */
public void registerTarget(javax.rmi.CORBA.Tie tie, java.rmi.Remote target)
{
    synchronized (exportedServants) {
        // Do we already have this target registered?
        if (lookupTie(target) == null) {
            // No, so register it and set the target...
            exportedServants.put(target,tie);
            tie.setTarget(target);

            // Do we need to instantiate our keep-alive thread?
            if (keepAlive == null) {
                // Yes. Instantiate our keep-alive thread and start
                // it up...
                keepAlive = (KeepAlive)AccessController.doPrivileged(new PrivilegedAction() {
                    public java.lang.Object run() {
                        return new KeepAlive();
                    }
                });
                keepAlive.start();
            }
        }
    }
}
 

static String getProperty(final String key) {
   try {
       String value = AccessController.doPrivileged(new PrivilegedExceptionAction<String>() {
           public String run() {
               return System.getProperty(key);
           }
       });
       return value;
   }
   // Unwrap
   catch (final PrivilegedActionException pae) {
       final Throwable t = pae.getCause();
       // Rethrow
       if (t instanceof SecurityException) {
           throw (SecurityException) t;
       }
       if (t instanceof NullPointerException) {
           throw (NullPointerException) t;
       } else if (t instanceof IllegalArgumentException) {
           throw (IllegalArgumentException) t;
       } else {
           // No other checked Exception thrown by System.getProperty
           try {
               throw (RuntimeException) t;
           }
           // Just in case we've really messed up
           catch (final ClassCastException cce) {
               throw new RuntimeException("Obtained unchecked Exception; this code should never be reached", t);
           }
       }
   }
}
 

private static ClassLoader getContextClassLoader() {
    return (ClassLoader)
            AccessController.doPrivileged(new PrivilegedAction() {
                public Object run() {
                    ClassLoader cl = null;
                    try {
                        cl = Thread.currentThread().getContextClassLoader();
                    } catch (SecurityException ex) {
                    }
                    return cl;
                }
            });
}
 

/**
 * Returns the value of "sun.awt.disableGtkFileDialogs" property. Default
 * value is {@code false}.
 */
public synchronized static boolean getSunAwtDisableGtkFileDialogs() {
    if (sunAwtDisableGtkFileDialogs == null) {
        sunAwtDisableGtkFileDialogs = AccessController.doPrivileged(
                                          new GetBooleanAction("sun.awt.disableGtkFileDialogs"));
    }
    return sunAwtDisableGtkFileDialogs.booleanValue();
}
 

private static boolean maybeMultiAppContext() {
    Boolean appletSM = (Boolean)
        java.security.AccessController.doPrivileged(
            new java.security.PrivilegedAction() {
                    public Object run() {
                        SecurityManager sm = System.getSecurityManager();
                        return new Boolean
                            (sm instanceof sun.applet.AppletSecurity);
                    }
                });
    return appletSM.booleanValue();
}
 

public static boolean getFileExists(final File f) {
    return ((Boolean) AccessController.doPrivileged(new PrivilegedAction() {
                public Object run() {
                    return f.exists() ? Boolean.TRUE : Boolean.FALSE;
                }
            })).booleanValue();
}
 

PrivilegedThreadFactory() {
    super();
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        // Calls to getContextClassLoader from this class
        // never trigger a security check, but we check
        // whether our callers have this permission anyways.
        sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);

        // Fail fast
        sm.checkPermission(new RuntimePermission("setContextClassLoader"));
    }
    this.acc = AccessController.getContext();
    this.ccl = Thread.currentThread().getContextClassLoader();
}
 

private static boolean hostsEqual(URL u1, URL u2) {
    final String h1 = u1.getHost();
    final String h2 = u2.getHost();

    if (h1 == null) {
        return h2 == null;
    } else if (h2 == null) {
        return false;
    } else if (h1.equalsIgnoreCase(h2)) {
        return true;
    }
    // Have to resolve addresses before comparing, otherwise
    // names like tachyon and tachyon.eng would compare different
    final boolean result[] = {false};

    java.security.AccessController.doPrivileged(
        new java.security.PrivilegedAction<>() {
            public Void run() {
            try {
                InetAddress a1 = InetAddress.getByName(h1);
                InetAddress a2 = InetAddress.getByName(h2);
                result[0] = a1.equals(a2);
            } catch(UnknownHostException | SecurityException e) {
            }
            return null;
        }
    });

    return result[0];
}
 

String helperPath() {
    return AccessController.doPrivileged(
        (PrivilegedAction<String>) () ->
            helperPath(System.getProperty("java.home"),
                       System.getProperty("os.arch"))
    );
}
 

private String getLocalizeMessage(final String message) {
	if (SecurityUtil.isPackageProtectionEnabled()) {
		return AccessController.doPrivileged(new PrivilegedAction<String>() {
			@Override
			public String run() {
				return Localizer.getMessage(message);
			}
		});
	} else {
		return Localizer.getMessage(message);
	}
}
 

protected static void makeAccessible(AccessibleObject object) {
    if (!object.isAccessible()) {
        AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
            object.setAccessible(true);
            return null;
        });
    }
}
 

/**
 * Find the specified resource in our local repository, and return a
 * <code>URL</code> refering to it, or <code>null</code> if this resource
 * cannot be found.
 *
 * @param name Name of the resource to be found
 */
public URL findResource(final String name) {

    if (debug >= 3)
        log("    findResource(" + name + ")");

    URL url = null;

    ResourceEntry entry = (ResourceEntry) resourceEntries.get(name);
    if (entry == null) {
        if (securityManager != null) {
            PrivilegedAction dp =
                new PrivilegedFindResource(name, name);
            entry = (ResourceEntry)AccessController.doPrivileged(dp);
        } else {
            entry = findResourceInternal(name, name);
        }
    }
    if (entry != null) {
        url = entry.source;
    }

    if ((url == null) && hasExternalRepositories)
        url = super.findResource(name);

    if (debug >= 3) {
        if (url != null)
            log("    --> Returning '" + url.toString() + "'");
        else
            log("    --> Resource not found, returning null");
    }
    return (url);

}
 

private void startListeningForOtherDrags() {
    //System.out.println("Adding AWTEventListener");
    java.security.AccessController.doPrivileged(
        new java.security.PrivilegedAction<Object>() {
            public Object run() {
                nativeContainer.getToolkit().addAWTEventListener(
                    LightweightDispatcher.this,
                    AWTEvent.MOUSE_EVENT_MASK |
                    AWTEvent.MOUSE_MOTION_EVENT_MASK);
                return null;
            }
        }
    );
}
 

public static String getSystemProperty(final String propName) {
    return (String) AccessController.doPrivileged(new PrivilegedAction() {
        public Object run() {
            return System.getProperty(propName);
        }
    });
}
 

private static final String getProperty(final String propName,
    final String defVal) {
    return AccessController.doPrivileged(
        new PrivilegedAction<String>() {
        public String run() {
            try {
                return System.getProperty(propName, defVal);
            } catch (SecurityException e) {
                return defVal;
            }
        }
    });
}
 

static void loadSystemColors(int[] systemColors) {
    if ("Linux".equals(AccessController.doPrivileged(new GetPropertyAction("os.name")))) { // Load motif default colors on Linux.
        loadMotifDefaultColors(systemColors);
    }
    else
    {
        try {
            loadSystemColorsForCDE(systemColors);
        }
        catch (Exception e) // Failure to load CDE colors.
        {
            loadMotifDefaultColors(systemColors);
        }
    }
}
 

@Override
public void preInstantiateSingletons() throws BeansException {
	if (this.logger.isDebugEnabled()) {
		this.logger.debug("Pre-instantiating singletons in " + this);
	}
	List<String> beanNames;
	synchronized (this.beanDefinitionMap) {
		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		beanNames = new ArrayList<String>(this.beanDefinitionNames);
	}
	for (String beanName : beanNames) {
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			if (isFactoryBean(beanName)) {
				final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
				boolean isEagerInit;
				if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
					isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
						@Override
						public Boolean run() {
							return ((SmartFactoryBean<?>) factory).isEagerInit();
						}
					}, getAccessControlContext());
				}
				else {
					isEagerInit = (factory instanceof SmartFactoryBean &&
							((SmartFactoryBean<?>) factory).isEagerInit());
				}
				if (isEagerInit) {
					getBean(beanName);
				}
			}
			else {
				getBean(beanName);
			}
		}
	}
}
 

@Override
public void flushBuffer()
    throws IOException {

    if (isFinished()) {
        //            throw new IllegalStateException
        //                (/*sm.getString("responseFacade.finished")*/);
        return;
    }

    if (SecurityUtil.isPackageProtectionEnabled()){
        try{
            AccessController.doPrivileged(
                    new PrivilegedExceptionAction<Void>(){

                @Override
                public Void run() throws IOException{
                    response.setAppCommitted(true);

                    response.flushBuffer();
                    return null;
                }
            });
        } catch(PrivilegedActionException e){
            Exception ex = e.getException();
            if (ex instanceof IOException){
                throw (IOException)ex;
            }
        }
    } else {
        response.setAppCommitted(true);

        response.flushBuffer();
    }

}
 

public void updateSessionAccessTime(final HttpServerExchange exchange) {
    HttpSessionImpl httpSession = getSession(exchange, false);
    if (httpSession != null) {
        Session underlyingSession;
        if (System.getSecurityManager() == null) {
            underlyingSession = httpSession.getSession();
        } else {
            underlyingSession = AccessController.doPrivileged(new HttpSessionImpl.UnwrapSessionAction(httpSession));
        }
        underlyingSession.requestDone(exchange);
    }
}
 

/**
 * To be called from the workqueue to create worker threads when none
 * available.
 */
void createWorkerThread() {
    final String name = getName();
    synchronized (workQueue) {
        try {
            if (System.getSecurityManager() == null) {
                createWorkerThreadHelper(name);
            } else {
                // If we get here, we need to create a thread.
                AccessController.doPrivileged(
                        new PrivilegedAction() {
                    public Object run() {
                        return createWorkerThreadHelper(name);
                    }
                }
                );
            }
        } catch (Throwable t) {
            // Decrementing the count of current worker threads.
            // But, it will be increased in the finally block.
            decrementCurrentNumberOfThreads();
            wrapper.workerThreadCreationFailure(t);
        } finally {
            incrementCurrentNumberOfThreads();
        }
    }
}
 

boolean getFileExists(final File f) {
    return ((Boolean)
            AccessController.doPrivileged(new PrivilegedAction() {
                public Object run() {
                    return f.exists();
                }
            })).booleanValue();
}
 

/**
 * Write the provided session to the Store without modifying
 * the copy in memory or triggering passivation events. Does
 * nothing if the session is invalid or past its expiration.
 */
protected void writeSession(Session session) throws IOException {

    if (store == null || !session.isValid()) {
        return;
    }

    try {
        if (SecurityUtil.isPackageProtectionEnabled()){
            try{
                AccessController.doPrivileged(new PrivilegedStoreSave(session));
            }catch(PrivilegedActionException ex){
                Exception exception = ex.getException();
                log.error("Exception in the Store during writeSession: "
                          + exception);
                exception.printStackTrace();                        
            }
        } else {
             store.save(session);
        }   
    } catch (IOException e) {
        log.error(sm.getString
            ("persistentManager.serializeError", session.getIdInternal(), e));
        throw e;
    }

}
 

/**
 * Get a valid FontManager implementation for the current platform.
 *
 * @return a valid FontManager instance for the current platform
 */
public static synchronized FontManager getInstance() {

    if (instance != null) {
        return instance;
    }

    AccessController.doPrivileged(new PrivilegedAction() {

        public Object run() {
            try {
                String fmClassName =
                        System.getProperty("sun.font.fontmanager",
                                           DEFAULT_CLASS);
                ClassLoader cl = ClassLoader.getSystemClassLoader();
                Class fmClass = Class.forName(fmClassName, true, cl);
                instance = (FontManager) fmClass.newInstance();
            } catch (ClassNotFoundException |
                     InstantiationException |
                     IllegalAccessException ex) {
                throw new InternalError(ex);

            }
            return null;
        }
    });

    return instance;
}
 

private static MethodHandles.Lookup getCurrentLookup(final Supplier<MethodHandles.Lookup> lookupSupplier) {
    return AccessController.doPrivileged(new PrivilegedAction<MethodHandles.Lookup>() {
        @Override
        public MethodHandles.Lookup run() {
            return lookupSupplier.get();
        }
    }, GET_LOOKUP_PERMISSION_CONTEXT);
}
 

public static void doPrivilegedVoid(Runnable action) {
    SpecialPermission.check();
    AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
        action.run();
        return null;
    });
}
 

public static void main(String args[]) {
    TVPermission perm = new TVPermission("channel:5", "watch");
    try {
        AccessController.checkPermission(perm);
    } catch (SecurityException se) {
        throw new RuntimeException(se);
    }
}
 

/**
 * Returns any IPv4 address of the given network interface, or
 * null if the interface does not have any IPv4 addresses.
 */
static Inet4Address anyInet4Address(final NetworkInterface interf) {
    return AccessController.doPrivileged(new PrivilegedAction<Inet4Address>() {
        public Inet4Address run() {
            Enumeration<InetAddress> addrs = interf.getInetAddresses();
            while (addrs.hasMoreElements()) {
                InetAddress addr = addrs.nextElement();
                if (addr instanceof Inet4Address) {
                    return (Inet4Address)addr;
                }
            }
            return null;
        }
    });
}
 

synchronized void addReference(ObjectName name, Object mxbean)
throws InstanceAlreadyExistsException {
    ObjectName existing = mxbeanToObjectName.get(mxbean);
    if (existing != null) {
        String multiname = AccessController.doPrivileged(
                new GetPropertyAction("jmx.mxbean.multiname"));
        if (!"true".equalsIgnoreCase(multiname)) {
            throw new InstanceAlreadyExistsException(
                    "MXBean already registered with name " + existing);
        }
    }
    mxbeanToObjectName.put(mxbean, name);
}
 

/**
 * Starts the monitor.
 */
void doStart() {
        MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
            "doStart()", "start the monitor");

    synchronized (this) {
        if (isActive()) {
            MONITOR_LOGGER.logp(Level.FINER, Monitor.class.getName(),
                    "doStart()", "the monitor is already active");
            return;
        }

        isActive = true;

        // Reset the complex type attribute information
        // such that it is recalculated again.
        //
        cleanupIsComplexTypeAttribute();

        // Cache the AccessControlContext of the Monitor.start() caller.
        // The monitor tasks will be executed within this context.
        //
        acc = AccessController.getContext();

        // Start the scheduler.
        //
        cleanupFutures();
        schedulerTask.setMonitorTask(new MonitorTask());
        schedulerFuture = scheduler.schedule(schedulerTask,
                                             getGranularityPeriod(),
                                             TimeUnit.MILLISECONDS);
    }
}
 

/**
 * Returns the default charset of this Java virtual machine.
 *
 * <p> The default charset is determined during virtual-machine startup and
 * typically depends upon the locale and charset of the underlying
 * operating system.
 *
 * @return  A charset object for the default charset
 *
 * @since 1.5
 */
public static Charset defaultCharset() {
    if (defaultCharset == null) {
        synchronized (Charset.class) {
            String csn = AccessController.doPrivileged(
                new GetPropertyAction("file.encoding"));
            Charset cs = lookup(csn);
            if (cs != null)
                defaultCharset = cs;
            else
                defaultCharset = forName("UTF-8");
        }
    }
    return defaultCharset;
}
 

/**
 * Returns the default AsynchronousChannelProvider.
 */
public static AsynchronousChannelProvider create() {
    String osname = AccessController
        .doPrivileged(new GetPropertyAction("os.name"));
    if (osname.equals("SunOS"))
        return createProvider("sun.nio.ch.SolarisAsynchronousChannelProvider");
    if (osname.equals("Linux"))
        return createProvider("sun.nio.ch.LinuxAsynchronousChannelProvider");
    if (osname.contains("OS X"))
        return createProvider("sun.nio.ch.BsdAsynchronousChannelProvider");
    if (osname.equals("AIX"))
        return createProvider("sun.nio.ch.AixAsynchronousChannelProvider");
    throw new InternalError("platform not recognized");
}
 

private static ClassLoader getContextClassLoader() {
    return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
        @Override
        public ClassLoader run() {
            ClassLoader cl = null;
            try {
                cl = Thread.currentThread().getContextClassLoader();
            } catch (SecurityException ex) {
            }
            return cl;
        }
    });
}
 

protected String[] childrenNamesSpi() {
    return AccessController.doPrivileged(
        new PrivilegedAction<String[]>() {
            public String[] run() {
                List<String> result = new ArrayList<>();
                File[] dirContents = dir.listFiles();
                if (dirContents != null) {
                    for (int i = 0; i < dirContents.length; i++)
                        if (dirContents[i].isDirectory())
                            result.add(nodeName(dirContents[i].getName()));
                }
                return result.toArray(EMPTY_STRING_ARRAY);
           }
        });
}
 

@Override
public HttpSession getSession(boolean create) {

    if (request == null) {
        throw new IllegalStateException(
                        sm.getString("requestFacade.nullRequest"));
    }

    if (SecurityUtil.isPackageProtectionEnabled()){
        return AccessController.
            doPrivileged(new GetSessionPrivilegedAction(create));
    } else {
        return request.getSession(create);
    }
}
 

/** We have to defer full initialization of this class until after
    the static initializer is run since java.lang.reflect.Method's
    static initializer (more properly, that for
    java.lang.reflect.AccessibleObject) causes this class's to be
    run, before the system properties are set up. */
private static void checkInitted() {
    if (initted) return;
    AccessController.doPrivileged(new PrivilegedAction() {
            public Object run() {
                // Tests to ensure the system properties table is fully
                // initialized. This is needed because reflection code is
                // called very early in the initialization process (before
                // command-line arguments have been parsed and therefore
                // these user-settable properties installed.) We assume that
                // if System.out is non-null then the System class has been
                // fully initialized and that the bulk of the startup code
                // has been run.

                if (System.out == null) {
                    // java.lang.System not yet fully initialized
                    return null;
                }

                String val = System.getProperty("sun.reflect.noInflation");
                if (val != null && val.equals("true")) {
                    noInflation = true;
                }

                val = System.getProperty("sun.reflect.inflationThreshold");
                if (val != null) {
                    try {
                        inflationThreshold = Integer.parseInt(val);
                    } catch (NumberFormatException e) {
                        throw (RuntimeException)
                            new RuntimeException("Unable to parse property sun.reflect.inflationThreshold").
                                initCause(e);
                    }
                }

                initted = true;
                return null;
            }
        });
}