ServerPlugin Permissions setzen

Dieses Thema im Forum "Programmierung" wurde erstellt von Kronos197, 25. März 2015.

  1. Kronos197
    Offline

    Kronos197

    Registriert seit:
    20. Dezember 2013
    Beiträge:
    153
    Ort:
    Frankfurt
    Minecraft:
    Kronos197
    HI Leute,

    Wie ihr schon oben seht habe ich eine frage zu dem setzten von Permissions.
    Jedoch weiß ich, wie man einzelne Permission setzt (Attachement)
    Meine frage ist also, wie kann man *-Permissions setzten, also wie findet man die nachfolgenden Permissions raus?
    Dass heißt, wenn der User die Permissions Essentials.* angibt, wie finde ich heraus, was die nachfolgenden Permissions sind um sie zu setzten!
    Ich hoffe ihr könnt mir helfen.

    Vielen Dank für eure Antworten.
    LG
    Kronos197
     
    #1
  2. SilberRegen
    Offline

    SilberRegen

    Registriert seit:
    23. März 2012
    Beiträge:
    572
    Minecraft:
    SilberRegen
    Die Fragestellung ist mir nicht ganz klar.
    Möchtest du wissen, was eine Sternchenpermission macht oder möchtest du wissen, wo du herausfindest, was du alles mit einer Sternchenpermission freigibst?

    Das Sternchen selber steht für "alles-Mögliche-was-man-anstelle-des-Sternchens-schreiben-könnte". Es ist ein Platzhalter und wird zum Beispiel auch bei Suchanfragen verwendet. Man braucht(e) das zum Beispiel bei der Suche nach Dateien, wenn man nur einen Teil des Dateinamens wusste/weiß.
    *NAME* würde alle Dateien raussuchen, die "NAME" enthalten. NAME* alle Dateien, bei denen auf NAME noch etwas folgt, aber nichts davor steht.

    Entsprechend ist es bei Permissions:
    Wenn man nur "*" als Permission angibt, erhält der Nutzer sämtliche Permissions, die es gibt (ganz dumme Idee)
    essentials.* gibt dem Nutzer sämtliche Essentialspermission (auch keine gute Idee).
    essentials.kits.* würde dem Nutzer Rechte für alle existierenden Kits geben.
    essentials.kits.beispielkit würde dem Nutzer nur Rechte für das Kit Namens "beispielkit" geben.

    Nach diesem Schema arbeitet das. Man schreibt das Sternchen einfach hin, wenn man es vergeben will. Einzelpermissions sind aber grundsätzlich der sichere Weg.

    Für Essentials gibt es zum Beispiel eine Permissionsreferenz, in der man sämtliche Permissions zu den zugehörigen Befehlen und deren Wirkung nachlesen kann. (Vorne auf das Plus klicken)
    Permissionreferenz
     
    #2
    MrGoms gefällt das.
  3. [Dev] iTzSasukeHDxLP
    Offline

    [Dev] iTzSasukeHDxLP Ehem. Teammitglied

    Registriert seit:
    5. Januar 2014
    Beiträge:
    938
    Aufpassen, das stimmt nicht (immer)! Man kann den '*'-Wildcard nur benutzen, wenn der PluginProgrammierer das auch vernünftig eingearbeitet hat und alle Permissionschildren sauber und ordentlich notiert hat. Wenn du eine jar entpackst findest du gewöhnlich eine Datei 'plugin.yml' in der alle Commands des Plugins und ihre dazugehörigen Permissions notiert sind, notfalls musst du dich daran orientieren.
     
    #3
  4. Kronos197
    Offline

    Kronos197

    Registriert seit:
    20. Dezember 2013
    Beiträge:
    153
    Ort:
    Frankfurt
    Minecraft:
    Kronos197
    Genau das war meine Frage. Wie schreibt / macht man so etwas, das man auch den '*'-Wildcard angeben kann?
     
    #4
  5. [Dev] iTzSasukeHDxLP
    Offline

    [Dev] iTzSasukeHDxLP Ehem. Teammitglied

    Registriert seit:
    5. Januar 2014
    Beiträge:
    938
    Dazu musst du in der plugin.yml permissionschildren definieren.

    Beispiel:
    PHP:
    1.  
    2.      permissions:
    3.        inferno.*:
    4.          description: Gives access to all Inferno commands
    5.          children:
    6.            inferno.flagrate: true
    7.            inferno.burningdeaths: true
    8.            inferno.burningdeaths.others: true
    9.        inferno.flagrate:
    10.          description: Allows you to ignite yourself
    11.          default: true
    12.        inferno.burningdeaths:
    13.          description: Allows you to see how many times you have burned to death
    14.          default: true
    15.        inferno.burningdeaths.others:
    16.          description: Allows you to see how many times others have burned to death
    17.          default: op
    18.          children:
    19.            inferno.burningdeaths: true
    20.  
    21.  
    Quelle: http://wiki.bukkit.org/Plugin_YAML/de
     
    #5
  6. Kronos197
    Offline

    Kronos197

    Registriert seit:
    20. Dezember 2013
    Beiträge:
    153
    Ort:
    Frankfurt
    Minecraft:
    Kronos197
    Danke für die Antwort und den Link :D Ist schon sehr hilfreich
    Doch das meinte ich nicht (Wieso kann ich nur so schlecht fragen stellen :()
    Ich meine wie bekomme ich die folgenden Permissions heraus von anderen Plugins, da ich ein eigenes Permissions-Plugin schreibe und die * Funktion einfügen will/muss.
     
    #6
  7. [Dev] iTzSasukeHDxLP
    Offline

    [Dev] iTzSasukeHDxLP Ehem. Teammitglied

    Registriert seit:
    5. Januar 2014
    Beiträge:
    938
    Du kannst nicht mir nichts dir nichts Wildcards erstellen und sagen 'Der deckt alle möglichen children ab', das varriert je nach der plugin.yml des Plugins! Notfalls musst du das nachbessern, um den Wildcard zu nutzen. Mit deinem Plugin allein kannst du da fast nichts machen, es sei denn du hast Lust, dich per Reflection durch Bukkits halbes Permissionsystem zu graben.
     
    #7
  8. Kronos197
    Offline

    Kronos197

    Registriert seit:
    20. Dezember 2013
    Beiträge:
    153
    Ort:
    Frankfurt
    Minecraft:
    Kronos197
    wie wurde das dann, z.B. mit PermissionsEx oder GroupManager gemacht?
     
    #8
  9. [Dev] iTzSasukeHDxLP
    Offline

    [Dev] iTzSasukeHDxLP Ehem. Teammitglied

    Registriert seit:
    5. Januar 2014
    Beiträge:
    938
    https://github.com/PEXPlugins/PermissionsEx

    Außerdem kannst du zB PErmissionsEx dekompilieren und durchschauen. Ein basisches Element ist zum Beispiel das hier:
    PHP:
    1. package ru.tehkode.permissions.bukkit.regexperms;
    2.  
    3. import java.lang.reflect.InvocationTargetException;
    4. import java.lang.reflect.Method;
    5. import java.util.Collection;
    6. import java.util.Iterator;
    7. import java.util.LinkedHashMap;
    8. import java.util.LinkedHashSet;
    9. import java.util.List;
    10. import java.util.ListIterator;
    11. import java.util.Map;
    12. import java.util.Map.Entry;
    13. import java.util.Set;
    14. import java.util.concurrent.ConcurrentHashMap;
    15. import java.util.concurrent.atomic.AtomicBoolean;
    16. import java.util.logging.Logger;
    17. import org.apache.commons.lang.Validate;
    18. import org.bukkit.Server;
    19. import org.bukkit.entity.Player;
    20. import org.bukkit.permissions.Permissible;
    21. import org.bukkit.permissions.PermissibleBase;
    22. import org.bukkit.permissions.Permission;
    23. import org.bukkit.permissions.PermissionAttachment;
    24. import org.bukkit.permissions.PermissionAttachmentInfo;
    25. import org.bukkit.permissions.PermissionDefault;
    26. import org.bukkit.plugin.PluginManager;
    27. import ru.tehkode.permissions.PermissionCheckResult;
    28. import ru.tehkode.permissions.PermissionManager;
    29. import ru.tehkode.permissions.PermissionMatcher;
    30. import ru.tehkode.permissions.PermissionUser;
    31. import ru.tehkode.permissions.bukkit.ErrorReport;
    32. import ru.tehkode.permissions.bukkit.PermissionsEx;
    33. import ru.tehkode.utils.FieldReplacer;
    34.  
    35. public class PermissiblePEX
    36.   extends PermissibleBase
    37. {
    38.   private static final FieldReplacer<PermissibleBase, Map> PERMISSIONS_FIELD = new FieldReplacer(PermissibleBase.class, "permissions", Map.class);
    39.   private static final FieldReplacer<PermissibleBase, List> ATTACHMENTS_FIELD = new FieldReplacer(PermissibleBase.class, "attachments", List.class);
    40.   private static final Method CALC_CHILD_PERMS_METH;
    41.   private final Map<String, PermissionAttachmentInfo> permissions;
    42.   private final List<PermissionAttachment> attachments;
    43.  
    44.   static
    45.   {
    46.     try
    47.     {
    48.       CALC_CHILD_PERMS_METH = PermissibleBase.class.getDeclaredMethod("calculateChildPermissions", new Class[] { Map.class, Boolean.TYPE, PermissionAttachment.class });
    49.     }
    50.     catch (NoSuchMethodException e)
    51.     {
    52.       throw new ExceptionInInitializerError(e);
    53.     }
    54.     CALC_CHILD_PERMS_METH.setAccessible(true);
    55.   }
    56.  
    57.   private static final AtomicBoolean LAST_CALL_ERRORED = new AtomicBoolean(false);
    58.   protected final Player player;
    59.   protected final PermissionsEx plugin;
    60.   private Permissible previousPermissible = null;
    61.   protected final Map<String, PermissionCheckResult> cache = new ConcurrentHashMap();
    62.   private final Object permissionsLock = new Object();
    63.  
    64.   public PermissiblePEX(Player player, PermissionsEx plugin)
    65.   {
    66.     super(player);
    67.     this.player = player;
    68.     this.plugin = plugin;
    69.     this.permissions = new LinkedHashMap()
    70.     {
    71.       public PermissionAttachmentInfo put(String k, PermissionAttachmentInfo v)
    72.       {
    73.         PermissionAttachmentInfo existing = (PermissionAttachmentInfo)get(k);
    74.         if (existing != null) {
    75.           return existing;
    76.         }
    77.         return (PermissionAttachmentInfo)super.put(k, v);
    78.       }
    79.     };
    80.     PERMISSIONS_FIELD.set(this, this.permissions);
    81.     this.attachments = ((List)ATTACHMENTS_FIELD.get(this));
    82.     recalculatePermissions();
    83.   }
    84.  
    85.   public Permissible getPreviousPermissible()
    86.   {
    87.     return this.previousPermissible;
    88.   }
    89.  
    90.   public void setPreviousPermissible(Permissible previousPermissible)
    91.   {
    92.     this.previousPermissible = previousPermissible;
    93.   }
    94.  
    95.   public boolean isDebug()
    96.   {
    97.     boolean debug = this.plugin.isDebug();
    98.     try
    99.     {
    100.       PermissionUser user = this.plugin.getPermissionsManager().getUser(this.player);
    101.       if (user != null) {
    102.         debug |= user.isDebug();
    103.       }
    104.     }
    105.     catch (Throwable ignore) {}
    106.     return debug;
    107.   }
    108.  
    109.   public boolean hasPermission(String permission)
    110.   {
    111.     PermissionCheckResult res = permissionValue(permission);
    112.     switch (2.$SwitchMap$ru$tehkode$permissions$PermissionCheckResult[res.ordinal()])
    113.     {
    114.     case 1:
    115.     case 2:
    116.       return res.toBoolean();
    117.     }
    118.     if (super.isPermissionSet(permission))
    119.     {
    120.       boolean ret = super.hasPermission(permission);
    121.       if (isDebug()) {
    122.         this.plugin.getLogger().info("User " + this.player.getName() + " checked for permission '" + permission + "', superperms-matched a value of " + ret);
    123.       }
    124.       return ret;
    125.     }
    126.     Permission perm = this.player.getServer().getPluginManager().getPermission(permission);
    127.     return perm == null ? Permission.DEFAULT_PERMISSION.getValue(this.player.isOp()) : perm.getDefault().getValue(this.player.isOp());
    128.   }
    129.  
    130.   public boolean hasPermission(Permission permission)
    131.   {
    132.     PermissionCheckResult res = permissionValue(permission.getName());
    133.     switch (2.$SwitchMap$ru$tehkode$permissions$PermissionCheckResult[res.ordinal()])
    134.     {
    135.     case 1:
    136.     case 2:
    137.       return res.toBoolean();
    138.     }
    139.     if (super.isPermissionSet(permission.getName()))
    140.     {
    141.       boolean ret = super.hasPermission(permission);
    142.       if (isDebug()) {
    143.         this.plugin.getLogger().info("User " + this.player.getName() + " checked for permission '" + permission.getName() + "', superperms-matched a value of " + ret);
    144.       }
    145.       return ret;
    146.     }
    147.     return permission.getDefault().getValue(this.player.isOp());
    148.   }
    149.  
    150.   public void recalculatePermissions()
    151.   {
    152.     if ((this.cache != null) && (this.permissions != null) && (this.attachments != null))
    153.     {
    154.       ListIterator<PermissionAttachment> it;
    155.       synchronized (this.permissionsLock)
    156.       {
    157.         clearPermissions();
    158.         this.cache.clear();
    159.         for (it = this.attachments.listIterator(this.attachments.size()); it.hasPrevious();)
    160.         {
    161.           PermissionAttachment attach = (PermissionAttachment)it.previous();
    162.           calculateChildPerms(attach.getPermissions(), false, attach);
    163.         }
    164.         for (Permission p : this.player.getServer().getPluginManager().getDefaultPermissions(isOp()))
    165.         {
    166.           this.permissions.put(p.getName(), new PermissionAttachmentInfo(this.player, p.getName(), null, true));
    167.           calculateChildPerms(p.getChildren(), false, null);
    168.         }
    169.       }
    170.     }
    171.   }
    172.  
    173.   protected void calculateChildPerms(Map<String, Boolean> children, boolean invert, PermissionAttachment attachment)
    174.   {
    175.     try
    176.     {
    177.       CALC_CHILD_PERMS_METH.invoke(this, new Object[] { children, Boolean.valueOf(invert), attachment });
    178.     }
    179.     catch (IllegalAccessException e) {}catch (InvocationTargetException e)
    180.     {
    181.       throw new RuntimeException(e);
    182.     }
    183.   }
    184.  
    185.   public boolean isPermissionSet(String permission)
    186.   {
    187.     return (super.isPermissionSet(permission)) || (permissionValue(permission) != PermissionCheckResult.UNDEFINED);
    188.   }
    189.  
    190.   public Set<PermissionAttachmentInfo> getEffectivePermissions()
    191.   {
    192.     synchronized (this.permissionsLock)
    193.     {
    194.       return new LinkedHashSet(this.permissions.values());
    195.     }
    196.   }
    197.  
    198.   private PermissionCheckResult checkSingle(String expression, String permission, boolean value)
    199.   {
    200.     if (this.plugin.getPermissionsManager().getPermissionMatcher().isMatches(expression, permission))
    201.     {
    202.       PermissionCheckResult res = PermissionCheckResult.fromBoolean(value);
    203.       if (isDebug()) {
    204.         this.plugin.getLogger().info("User " + this.player.getName() + " checked for permission '" + permission + "', regex-matched a value of " + res + " from " + expression + " (CACHE MISS)");
    205.       }
    206.       return res;
    207.     }
    208.     return PermissionCheckResult.UNDEFINED;
    209.   }
    210.  
    211.   protected PermissionCheckResult permissionValue(String permission)
    212.   {
    213.     try
    214.     {
    215.       Validate.notNull(permission, "Permissions being checked must not be null!");
    216.       permission = permission.toLowerCase();
    217.       PermissionCheckResult res = (PermissionCheckResult)this.cache.get(permission);
    218.       if (res != null)
    219.       {
    220.         if (isDebug()) {
    221.           this.plugin.getLogger().info("User " + this.player.getName() + " checked for permission '" + permission + "', regex-matched a value of " + res + " from cache.");
    222.         }
    223.         return res;
    224.       }
    225.       res = PermissionCheckResult.UNDEFINED;
    226.       synchronized (this.permissionsLock)
    227.       {
    228.         for (PermissionAttachmentInfo pai : this.permissions.values()) {
    229.           if ((res = checkSingle(pai.getPermission(), permission, pai.getValue())) != PermissionCheckResult.UNDEFINED) {
    230.             break;
    231.           }
    232.         }
    233.       }
    234.       if (res == PermissionCheckResult.UNDEFINED) {
    235.         for (??? = this.plugin.getRegexPerms().getPermissionList().getParents(permission).iterator(); ???.hasNext();)
    236.         {
    237.           Object ent = (Map.Entry)???.next();
    238.           if ((res = permissionValue((String)((Map.Entry)ent).getKey())) != PermissionCheckResult.UNDEFINED)
    239.           {
    240.             res = PermissionCheckResult.fromBoolean(!(res.toBoolean() ^ ((Boolean)((Map.Entry)ent).getValue()).booleanValue()));
    241.             if (!isDebug()) {
    242.               break;
    243.             }
    244.             this.plugin.getLogger().info("User " + this.player.getName() + " checked for permission '" + permission + "', match from parent '" + (String)((Map.Entry)ent).getKey() + "' (CACHE MISS)"); break;
    245.           }
    246.         }
    247.       }
    248.       this.cache.put(permission, res);
    249.       if ((res == PermissionCheckResult.UNDEFINED) && (isDebug())) {
    250.         this.plugin.getLogger().info("User " + this.player.getName() + " checked for permission '" + permission + "', no match found (CACHE MISS)");
    251.       }
    252.       LAST_CALL_ERRORED.set(false);
    253.       return res;
    254.     }
    255.     catch (Throwable t)
    256.     {
    257.       if (LAST_CALL_ERRORED.compareAndSet(false, true)) {
    258.         ErrorReport.handleError("Permissible permissionValue for " + this.player.getName(), t);
    259.       }
    260.     }
    261.     return PermissionCheckResult.UNDEFINED;
    262.   }
    263. }
    264.  

    Wie gesagt, Wildcards ohne vernüntige plugin.yml sind durchaus realisierbar, wenn du dich durch das halbe Permissionsystem gräbst.
     
    #9
  10. Kronos197
    Offline

    Kronos197

    Registriert seit:
    20. Dezember 2013
    Beiträge:
    153
    Ort:
    Frankfurt
    Minecraft:
    Kronos197
    Danke für die Antwort :D
     
    #10