private void injectConsole() throws Exception { ConsoleCommandSender consoleSender = this.plugin.getServer().getConsoleSender(); // get the ServerCommandSender class Class<?> serverCommandSenderClass = ReflectionUtil.obcClass("command.ServerCommandSender"); // get the perm field Field permField = serverCommandSenderClass.getDeclaredField("perm"); permField.setAccessible(true); // get the PermissibleBase instance PermissibleBase permBase = (PermissibleBase) permField.get(consoleSender); // create a monitored instance which delegates to the previous PermissibleBase MonitoredPermissibleBase newPermBase = wrap(permBase, "internal/console"); // inject the monitored instance permField.set(consoleSender, newPermBase); }
private void injectEntity() throws Exception { // get the CraftEntity class Class<?> entityClass = ReflectionUtil.obcClass("entity.CraftEntity"); // get the method used to obtain a PermissibleBase // this method will initialise a new PB instance if one doesn't yet exist Method getPermissibleBaseMethod = entityClass.getDeclaredMethod("getPermissibleBase"); getPermissibleBaseMethod.setAccessible(true); // get the PermissibleBase instance PermissibleBase permBase = (PermissibleBase) getPermissibleBaseMethod.invoke(null); // get the perm field on CraftEntity Field permField = entityClass.getDeclaredField("perm"); permField.setAccessible(true); // create a monitored instance which delegates to the previous PermissibleBase MonitoredPermissibleBase newPermBase = wrap(permBase, "internal/entity"); // inject the monitored instance permField.set(null, newPermBase); }
public Permissible inject(Player player, Permissible permissible) throws NoSuchFieldException, IllegalAccessException { Field permField = null; try { permField = getPermissibleField(player); } catch (Exception e) { } if (permField == null) { return null; } Permissible oldPerm = (Permissible) permField.get(player); if (permissible instanceof PermissibleBase) { PermissibleBase newBase = (PermissibleBase) permissible; permField.set(player, newBase); } // Inject permissible permField.set(player, permissible); return oldPerm; }
public Permissible(CommandSender sender, PermissionEntity entity) { super(sender); this.sender = sender; this.entity = entity; permissions = new LinkedHashMap<String, PermissionAttachmentInfo>() { @Override public PermissionAttachmentInfo put(String k, PermissionAttachmentInfo v) { PermissionAttachmentInfo existing = this.get(k); if (existing != null) { return existing; } return super.put(k, v); } }; try { Field permissionsField = PermissibleBase.class.getField("permissions"); Reflection.setField(permissionsField, this, permissions); } catch (NoSuchFieldException e) { e.printStackTrace(); } }
@Override public synchronized void clearPermissions() { if (oldpermissible == null) { super.clearPermissions(); return; } if (oldpermissible instanceof PermissibleBase) { PermissibleBase base = (PermissibleBase) oldpermissible; base.clearPermissions(); } }
/** * Injects a {@link LPPermissible} into a {@link Player}. * * @param player the player to inject into * @param newPermissible the permissible to inject * @throws Exception propagates any exceptions which were thrown during injection */ public static void inject(Player player, LPPermissible newPermissible) throws Exception { // get the existing PermissibleBase held by the player PermissibleBase oldPermissible = (PermissibleBase) HUMAN_ENTITY_PERMISSIBLE_FIELD.get(player); // seems we have already injected into this player. if (oldPermissible instanceof LPPermissible) { throw new IllegalStateException("LPPermissible already injected into player " + player.toString()); } // Move attachments over from the old permissible //noinspection unchecked List<PermissionAttachment> attachments = (List<PermissionAttachment>) PERMISSIBLE_BASE_ATTACHMENTS_FIELD.get(oldPermissible); newPermissible.convertAndAddAttachments(attachments); attachments.clear(); oldPermissible.clearPermissions(); // Setup the new permissible newPermissible.getActive().set(true); newPermissible.setOldPermissible(oldPermissible); // inject the new instance HUMAN_ENTITY_PERMISSIBLE_FIELD.set(player, newPermissible); }
public MonitoredPermissibleBase(VerboseHandler verboseHandler, PermissibleBase delegate, String name) { super(null); DummyPermissibleBase.nullFields(this); this.verboseHandler = verboseHandler; this.delegate = delegate; this.name = name; this.initialised = true; // since we effectively cancel the execution of this call in the super // constructor we need to call it again. recalculatePermissions(); }
private MonitoredPermissibleBase wrap(PermissibleBase permBase, String name) { Objects.requireNonNull(permBase, "permBase"); // unwrap any previous injection if (permBase instanceof MonitoredPermissibleBase) { permBase = ((MonitoredPermissibleBase) permBase).getDelegate(); } // create a monitored instance which delegates to the previous PermissibleBase return new MonitoredPermissibleBase(this.plugin.getVerboseHandler(), permBase, name); }
public MessageReceiver (boolean op, String remote) { this.op = op; this.remote = remote; this.messages = new ArrayList<String>(); this.perm = new PermissibleBase(this); this.acceptingMessages = true; }
@Override public synchronized void clearPermissions() { if (oldPermissible instanceof PermissibleBase) { PermissibleBase base = (PermissibleBase) oldPermissible; base.clearPermissions(); } }
public void inject() { if (Injector.getPermissible(sender) == this) { return; } Statics.setField(PermissibleBase.class, oldPermissible, superperms, "permissions"); Statics.setField(PermissibleBase.class, this, permissions, "permissions"); Statics.setField(PermissibleBase.class, oldPermissible, opable, "opable"); Injector.inject(sender, this); recalculatePermissions(); }
public void uninject() { if (Injector.getPermissible(sender) != this) { return; } Statics.setField(PermissibleBase.class, oldPermissible, new HashMap<String, PermissionAttachmentInfo>(), "permissions"); Statics.setField(PermissibleBase.class, oldPermissible, oldOpable, "opable"); Injector.inject(sender, oldPermissible); recalculatePermissions(); }
public void injectBridge(Player p) { try { PermissibleBase playerPermissibleBase = (PermissibleBase) permField.get(p); permField.set(p, new PermissibleBaseUserBridge(p, new UserFetcher(p.getName()))); playerPermissibleBase.recalculatePermissions(); } catch (IllegalArgumentException | IllegalAccessException e) { e.printStackTrace(); } }
public DiscordConsoleCommandSender(CommandEvent e) { this.e = e; perm = new PermissibleBase(this); }
public DiscordCommandSender(CommandEvent e) { this.e = e; perm = new PermissibleBase(this); }
public PermissibleBase getOldPermissible() { return this.oldPermissible; }
public void setOldPermissible(PermissibleBase oldPermissible) { this.oldPermissible = oldPermissible; }
PermissibleBase getDelegate() { return this.delegate; }
public DiscordConsoleCommandSender(MessageReceivedEvent e) { this.e = e; perm = new PermissibleBase(this); }
public DiscordCommandSender(MessageReceivedEvent e) { this.e = e; perm = new PermissibleBase(this); }
public TestConsoleCommandSender() { this.perm = new PermissibleBase(this); }
public BPPermissible(CommandSender sender, User u, Permissible oldPermissible) { super(sender); this.sender = sender; this.oldPermissible = oldPermissible; permissions = new LinkedHashMap<String, PermissionAttachmentInfo>() { @Override public PermissionAttachmentInfo put(String k, PermissionAttachmentInfo v) { PermissionAttachmentInfo existing = this.get(k); if (existing != null) { return existing; } return super.put(k, v); } }; superperms = new LinkedHashMap<String, PermissionAttachmentInfo>() { @Override public PermissionAttachmentInfo put(String k, PermissionAttachmentInfo v) { PermissionAttachmentInfo existing = this.get(k); if (existing != null) { return existing; } return super.put(k, v); } }; //inject an opable oldOpable = Statics.getField(PermissibleBase.class, oldPermissible, ServerOperator.class, "opable"); opable = new ServerOperator() { @Override public boolean isOp() { BukkitConfig config = (BukkitConfig) BungeePerms.getInstance().getConfig(); if (opdisabled) { if (!config.isAllowops()) { return false; } } if (config.isDebug()) { BungeePerms.getLogger().info("op check: " + BPPermissible.this.sender.getName() + " has OP: " + oldOpable.isOp()); } return oldOpable.isOp(); } @Override public void setOp(boolean value) { oldOpable.setOp(value); } }; init = true; recalculatePermissions(); }