@Override
  public void checkAccess(ThreadGroup g) {
    if (!isSecutityOn) {
      return;
    }
    Thread c = Thread.currentThread();

    if (isSafeThread(c)) {
      return;
    }
    super.checkAccess(g);

    final ThreadGroup cg = c.getThreadGroup();

    if (cg == null) {
      // What the heck is going on here?  JDK 1.3 is sending me a dead thread.
      // This crashes the entire jvm if I don't return here.
      return;
    }

    IHostedThread robotProxy = threadManager.getLoadedOrLoadingRobotProxy(c);

    if (robotProxy == null) {
      throw new AccessControlException(
          "Preventing " + c.getName() + " from access to " + g.getName());
    }

    if (cg.activeCount() > 5) {
      String message = "Robots are only allowed to create up to 5 threads!";

      robotProxy.punishSecurityViolation(message);
      throw new AccessControlException(message);
    }
  }
  @Override
  public void checkAccess(Thread t) {
    if (!isSecutityOn) {
      return;
    }

    Thread c = Thread.currentThread();

    if (isSafeThread(c)) {
      return;
    }
    super.checkAccess(t);

    // Threads belonging to other thread groups is not allowed to access threads belonging to other
    // thread groups
    // Bug fix [3021140] Possible for robot to kill other robot threads.
    // In the following the thread group of the current thread must be in the thread group hierarchy
    // of the
    // attacker thread; otherwise an AccessControlException must be thrown.

    boolean found = false;

    ThreadGroup cg = c.getThreadGroup();
    ThreadGroup tg = t.getThreadGroup();

    while (tg != null) {
      if (tg == cg) {
        found = true;
        break;
      }
      try {
        tg = tg.getParent();
      } catch (AccessControlException e) {
        // We expect an AccessControlException due to missing RuntimePermission modifyThreadGroup
        break;
      }
    }
    if (!found) {
      String message = "Preventing " + c.getName() + " from access to " + t.getName();
      IHostedThread robotProxy = threadManager.getLoadedOrLoadingRobotProxy(c);

      if (robotProxy != null) {
        robotProxy.punishSecurityViolation(message);
      }
      throw new AccessControlException(message);
    }
  }
 @Override
 public void checkAccess(final ThreadGroup pG) {
   if (finalSecurityManager != null) finalSecurityManager.checkAccess(pG);
 }
 @Override
 public void checkAccess(final ThreadGroup g) {
   if (securityManager != null) securityManager.checkAccess(g);
 }
 @Override
 public void checkAccess(final Thread t) {
   // it's still possible to kill us with Thread.currentThread().interrupt()
   // but I don't know how to restrict thread access to this kind of operations only
   if (securityManager != null) securityManager.checkAccess(t);
 }
 /**
  * Determines if the currently running thread has permission to modify this thread group.
  *
  * <p>If there is a security manager, its <code>checkAccess</code> method is called with this
  * thread group as its argument. This may result in throwing a <code>SecurityException</code>.
  *
  * @exception SecurityException if the current thread is not allowed to access this thread group.
  * @see java.lang.SecurityManager#checkAccess(java.lang.ThreadGroup)
  * @since JDK1.0
  */
 public final void checkAccess() {
   SecurityManager security = System.getSecurityManager();
   if (security != null) {
     security.checkAccess(this);
   }
 }