Packets Abfangen und editieren

Wenn ihr bei eurem Plugin nicht weiter kommt, könnt ihr hier euer Problem beschreiben und um Hilfe bitten.

Packets Abfangen und editieren

Beitragvon Raytex » Sa 19. Mär 2016, 16:27

Sehr geehrte Community,
ich habe da ein kleines Problem, da ich nicht weiß wie ich ausgehende (OUT) Packets abfangen soll. Bei eingehenden Packets ist es relativ leicht und dies habe ich auch hinbekommen.

Könnte mir jemand dabei helfen die Ausgehenden Packets abzufangen? Bzw eine Klasse / mehrere Klassen auf NMS und Reflection angepasst bereitstellen. Ich weiß dass ich es mit einer neuen PlayerConnection machen könnte allerdings habe ich keine Ahnung davon wie ich ich die geerbte PlayerConnection Versions übergreifend programmieren kann.

Hier einmal meine Klassen zum abfangen der eingehend Packets:
PacketHandler
Code: Alles auswählen
  1. package de.raytex.core.packets;
  2. import org.bukkit.Bukkit;
  3. import org.bukkit.entity.Player;
  4. import de.raytex.core.packets.events.PacketRecieveEvent;
  5. import io.netty.channel.ChannelDuplexHandler;
  6. import io.netty.channel.ChannelHandlerContext;
  7. import io.netty.channel.ChannelPromise;
  8. public class PacketHandler extends ChannelDuplexHandler {
  9.    private Player p;
  10.    public PacketHandler(final Player p) {
  11.       this.p = p;
  12.    }
  13.    @Override
  14.    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
  15.       super.write(ctx, msg, promise);
  16.    }
  17.    @Override
  18.    public void channelRead(ChannelHandlerContext c, Object packet) throws Exception {
  19.       
  20.       PacketRecieveEvent pr = new PacketRecieveEvent(p, c, packet);
  21.       
  22.       Bukkit.getPluginManager().callEvent(pr);
  23.       
  24.       if(pr.isCancelled()){
  25.       
  26. //         if (packet.getClass().getSimpleName().equalsIgnoreCase("PacketPlayInResourcePackStatus")) {
  27. //            String s = NMSUtils.getFieldValue(packet, "b").toString();
  28. //            if (s.equals("DECLINED")) {
  29. //            }
  30. //            if (s.equals("FAILED_DOWNLOAD")) {
  31. //            }
  32. //            if (s.equals("ACCEPTED")) {
  33. //            }
  34. //            if (s.equals("SUCCESSFULLY_LOADED")) {
  35. //               this.p.sendMessage("You have our texture pack installed");
  36. //            return;
  37. //            }
  38. //         } else {
  39. //            super.channelRead(c, packet);
  40. //         }
  41.          
  42.          return;
  43.          
  44.       }else{
  45.          
  46.          super.channelRead(c, pr.getPacket());
  47.          
  48.       }
  49.       
  50.    }
  51. }

PacketInjector
Code: Alles auswählen
  1. package de.raytex.core.packets;
  2. import java.lang.reflect.Field;
  3. import org.bukkit.entity.Player;
  4. import de.raytex.core.utils.NMSUtils;
  5. import io.netty.channel.Channel;
  6. public class PacketInjector {
  7.    @SuppressWarnings("unused")
  8.    private Field EntityPlayer_playerConnection;
  9.    private Class<?> PlayerConnection;
  10.    @SuppressWarnings("unused")
  11.    private Field PlayerConnection_networkManager;
  12.    private Class<?> NetworkManager;
  13.    private Field k;
  14.    private Field m;
  15.    private Field i;
  16.    private Field channel;
  17.    public PacketInjector() {
  18.       try {
  19.          EntityPlayer_playerConnection = NMSUtils.getField(NMSUtils.getNMSClass("EntityPlayer"), "playerConnection");
  20.          PlayerConnection = NMSUtils.getNMSClass("PlayerConnection");
  21.          PlayerConnection_networkManager = NMSUtils.getField(PlayerConnection, "networkManager");
  22.          NetworkManager = NMSUtils.getNMSClass("NetworkManager");
  23.          
  24.          initClasses();
  25.          
  26.       } catch (Throwable t) {}
  27.    }
  28.    
  29.    private void initClasses(){
  30.       
  31.       try{
  32.          
  33.          k = NMSUtils.getField(NetworkManager, "k");
  34.          
  35.       }catch(Exception ex){}
  36.       
  37.       try{
  38.          
  39.          m = NMSUtils.getField(NetworkManager, "m");
  40.          
  41.       }catch(Exception ex){}
  42.       
  43.       try{
  44.          
  45.          i = NMSUtils.getField(NetworkManager, "i");
  46.          
  47.       }catch(Exception ex){}
  48.       
  49.       try{
  50.          
  51.          channel = NMSUtils.getField(NetworkManager, "channel");
  52.          
  53.       }catch(Exception ex){}
  54.       
  55.    }
  56.    public void addPlayer(Player p) {
  57.       try {
  58.          Channel ch = getChannel(getNetworkManager(p));
  59.          if (ch.pipeline().get("PacketInjector") == null) {
  60.             PacketHandler h = new PacketHandler(p);
  61.             ch.pipeline().addBefore("packet_handler", "PacketInjector", h);
  62.          }
  63.       } catch (Throwable t) {
  64.       }
  65.    }
  66.    public void removePlayer(Player p) {
  67.       try {
  68.          Channel ch = getChannel(getNetworkManager(p));
  69.          if (ch.pipeline().get("PacketInjector") != null) {
  70.             ch.pipeline().remove("PacketInjector");
  71.          }
  72.       } catch (Throwable t) {
  73.          t.printStackTrace();
  74.       }
  75.    }
  76.    private Object getNetworkManager(Player p) {
  77.       return NMSUtils.getNetworkManager(p);
  78.    }
  79.    private Channel getChannel(Object networkManager) {
  80.       Channel ch = null;
  81.       
  82.       if(ChannelExists(networkManager, channel)){
  83.          
  84.          ch = getChannel(networkManager, channel);
  85.          
  86.       }else if(ChannelExists(networkManager, i)){
  87.          
  88.          ch = getChannel(networkManager, i);
  89.          
  90.       }else if(ChannelExists(networkManager, k)){
  91.          
  92.          ch = getChannel(networkManager, k);
  93.          
  94.       }else if(ChannelExists(networkManager, m)){
  95.          
  96.          ch = getChannel(networkManager, m);
  97.          
  98.       }
  99.       
  100.       return ch;
  101.    }
  102.    
  103.    private boolean ChannelExists(Object networkManager, Field field){
  104.       
  105.       try{
  106.          
  107.          NMSUtils.getFieldValue(field, networkManager);
  108.          return true;
  109.          
  110.       }catch(Exception ex){
  111.          
  112.          return false;
  113.          
  114.       }
  115.       
  116.    }
  117.    
  118.    private Channel getChannel(Object networkManager, Field field){
  119.       
  120.       if(ChannelExists(networkManager, field)){
  121.          
  122.          return NMSUtils.getFieldValue(field, networkManager);
  123.          
  124.       }else{
  125.          
  126.          return null;
  127.          
  128.       }
  129.       
  130.    }
  131.    
  132. }
Benutzeravatar
Raytex
 
Beiträge: 13
Registriert: Mi 20. Aug 2014, 15:49

Zurück zu Hilfe und Support

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 16 Gäste

cron