Seite 1 von 1

Packets Abfangen und editieren

BeitragVerfasst: Sa 19. Mär 2016, 16:27
von Raytex
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. }