Sending data from the Spigot server to the Fabric 1.21 client

[Salwarex]

Description

Hi! I'm new to this topic. I want to make a connection between the server on Spigot and the Fabric client mod (API 1.21). I tried to follow the information from the wiki, but in my case, only the transfer from the client to the server works, but the data does not arrive from the server to the client. Does anyone know what the problem is?

Fabric (client):

  @Override
    public void onInitializeClient() {
        ClientPlayConnectionEvents.JOIN.register((handler, sender, client) -> {
            PayloadTypeRegistry.playC2S().register(PacketServer.ID, PacketServer.CODEC);
            PayloadTypeRegistry.playS2C().register(PacketServer.ID, PacketServer.CODEC);

            ClientPlayNetworking.registerGlobalReceiver(PacketServer.ID, (payload, context) -> {
                String receivedData = payload.toString();
                context.client().execute(() -> {
                    System.out.println("Received from server: " + receivedData);
                });
            });
        });
    }

public record PacketServer(String message) implements CustomPayload {
    public static final CustomPayload.Id<PacketServer> ID = new CustomPayload.Id<>(Identifier.of("beemanity", "mod_channel"));
    public static final PacketCodec<PacketByteBuf, PacketServer> CODEC = PacketCodec.of(
            (buf, packet) -> packet.writeString(buf.message),
            buf -> new PacketServer(buf.readString())
    );

    @Override
    public Id<? extends CustomPayload> getId() {
        return ID;
    }
}

Spigot:

public static void sendData(Player player, String data) {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        DataOutputStream out = new DataOutputStream(byteArrayOutputStream);

        try {
            out.writeUTF(data);
        } catch (IOException e) {
            e.printStackTrace();
        }

        player.sendPluginMessage(MainClass.getInstance(), CHANNEL, byteArrayOutputStream.toByteArray());

    }

[JoshieGemFinder]

Do you think you could provide a bit more information about your server?

BungeeCord (and forks) can redirect plugin messages through bungeecord:main, and Velocity will also communicate through it. I also believe that PaperMC messes with things in its own unique way. Any information about that (even if it's just "I'm not using a proxy, bungeecord, or paper") would probably help narrow down the issue.

[TwistyLime]

I too am facing the same issue, just want to check if you found any work around.

[Salwarex]

No, I couldn't fix it. I tried to find a solution from people with the same problem from the Fabric discord, but they also did not find a solution.

[JoshieGemFinder]

At the time of my previous comment I was also actually running into this same issue, but I have developed a temporary solution until Fabric fixes this bug.
Please Note: I did this for 1.21.1 using Mojang Mappings; no guarantees it'll be the same in later versions; you'll have to manually change the mappings yourself if you're not using Mojang Mappings.

I had to manually mixin net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket (net.minecraft.network.packet.s2c.common.CustomPayloadS2CPacket if you're using Yarn mappings) to manually handle my packet.

Step 1: Mixin <clinit> to intercept the FallbackProvider passed to CustomPacketPayload.codec(), you'll need to make a new one with a manual check for the id of your packet(s).

	/**
	 * @author JoshieGemFinder
	 * @reason Aggressively hook our packet codec into the clientbound codec to receive packets from bukkit/velocity plugins
	 */
	@SuppressWarnings("rawtypes") // only have to worry about RegistryFriendlyByteBuf/FriendlyByteBuf here
	@ModifyArg(
			method = "<clinit>",
			at = @At(
					value = "INVOKE",
					target = "Lnet/minecraft/network/protocol/common/custom/CustomPacketPayload;codec(Lnet/minecraft/network/protocol/common/custom/CustomPacketPayload$FallbackProvider;Ljava/util/List;)Lnet/minecraft/network/codec/StreamCodec;"
					//, ordinal = 0 /* for targeting only the PLAY phase */
					//, ordinal = 1 /* for targeting only the CONFIGURATION phase */
					// No ordinal means it'll target both PLAY and CONFIGURATION
				),
			index = 0
		)
	private static FallbackProvider replaceFallbackProvider(FallbackProvider original) {
		return (resourceLocation) -> {
			// YourPacket.CHANNEL is a non-null ResourceLocation of your packet id
			if(YourPacket.CHANNEL.equals(resourceLocation)) {
				// YourPacket.CODEC should be a StreamCodec<FriendlyByteBuf, YourPacket>
				return YourPacket.CODEC;
			} else {
				return original.create(resourceLocation);
			}
		};
	}

Alternatively, you could mixin inject the HEAD of method_56460 for the play phase and method_56461 for the configuration phase instead of using the ordinals; however, these are synthetic methods and as such are more likely to have their mappings change between versions.

Step 2: Now the packet is being decoded we have to also add an inject to actually handle it, because in the current state fabric will just discard it.

	@Shadow
	public CustomPacketPayload payload() { return null; }

	/**
	 * @author JoshieGemFinder
	 * @reason Handle our packet early, because fabric will discard it it's from a bukkit/velocity plugin
	 */
	@Inject(method = "handle(Lnet/minecraft/network/protocol/common/ClientCommonPacketListener;)V", at = @At("HEAD"), cancellable = true)
	private void handleCustomPayload(ClientCommonPacketListener clientCommonPacketListener, CallbackInfo ci) {
		if(this.payload() instanceof YourPacket payload) {
			// any type of method to handle your custom packet payload, I'm assuming you probably have one of these already
			YourPacketHandler.handleYourPacket(clientCommonPacketListener, payload);
			ci.cancel();
		}
	}

Finally, putting it all together:

package your.package.for.mixins;

import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.ModifyArg;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import net.minecraft.network.protocol.common.ClientCommonPacketListener;
import net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket;
import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
import net.minecraft.network.protocol.common.custom.CustomPacketPayload.FallbackProvider;

/**
 * @author JoshieGemFinder
 * @reason Due to issues with fabric api, we have to aggressively hook our packet in to receive data from bukkit/velocity plugins
 */
@Mixin(ClientboundCustomPayloadPacket.class)
public class ClientboundCustomPayloadPacketMixin {

	/**
	 * @author JoshieGemFinder
	 * @reason Aggressively hook our packet codec into the clientbound codec to receive packets from bukkit/velocity plugins
	 */
	@SuppressWarnings("rawtypes") // only have to worry about RegistryFriendlyByteBuf/FriendlyByteBuf here
	@ModifyArg(
			method = "<clinit>",
			at = @At(
					value = "INVOKE",
					target = "Lnet/minecraft/network/protocol/common/custom/CustomPacketPayload;codec(Lnet/minecraft/network/protocol/common/custom/CustomPacketPayload$FallbackProvider;Ljava/util/List;)Lnet/minecraft/network/codec/StreamCodec;"
					//, ordinal = 0 /* for targeting only the PLAY phase */
					//, ordinal = 1 /* for targeting only the CONFIGURATION phase */
					// No ordinal means it'll target both PLAY and CONFIGURATION
				),
			index = 0
		)
	private static FallbackProvider replaceFallbackProvider(FallbackProvider original) {
		return (resourceLocation) -> {
			// YourPacket.CHANNEL is a non-null ResourceLocation of your packet id
			if(YourPacket.CHANNEL.equals(resourceLocation)) {
				// YourPacket.CODEC should be a StreamCodec<FriendlyByteBuf, YourPacket>
				return YourPacket.CODEC;
			} else {
				return original.create(resourceLocation);
			}
		};
	}

	@Shadow
	public CustomPacketPayload payload() { return null; }

	/**
	 * @author JoshieGemFinder
	 * @reason Handle our packet early, because fabric will discard it it's from a bukkit/velocity plugin
	 */
	@Inject(method = "handle(Lnet/minecraft/network/protocol/common/ClientCommonPacketListener;)V", at = @At("HEAD"), cancellable = true)
	private void handleCustomPayload(ClientCommonPacketListener clientCommonPacketListener, CallbackInfo ci) {
		if(this.payload() instanceof YourPacket payload) {
			// any type of method to handle your custom packet payload, I'm assuming you probably have one of these already
			YourPacketHandler.handleYourPacket(clientCommonPacketListener, payload);
			ci.cancel();
		}
	}
	
}

[TwistyLime]

I a relatively new to the fabric networking stuff, but I wanted to check if I am doing something wrong here, as I still am able to send the data but not receive.
Mod:

package com.temp.testfmj.client;

import net.fabricmc.api.ClientModInitializer;
import net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents;
import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
import net.fabricmc.fabric.api.networking.v1.PayloadTypeRegistry;

public class TestfmjClient implements ClientModInitializer {

    @Override
    public void onInitializeClient() {
        PayloadTypeRegistry.playC2S().register(PacketServer.TYPE, PacketServer.CODEC);
        PayloadTypeRegistry.playS2C().register(PacketServer.TYPE, PacketServer.CODEC);

        ClientPlayConnectionEvents.JOIN.register((handler, sender, client) -> {
            sendToServer("Hello from client");
        });
    }

    public void sendToServer(String message){
        ClientPlayNetworking.send(new PacketServer(message));
    }
}

package com.temp.testfmj.client;

import net.minecraft.network.FriendlyByteBuf;
import net.minecraft.network.codec.StreamCodec;
import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
import net.minecraft.resources.ResourceLocation;
import org.jetbrains.annotations.NotNull;

public record PacketServer(String message) implements CustomPacketPayload {
    public static final ResourceLocation ID = ResourceLocation.fromNamespaceAndPath("temp", "mod_channel");

    public static final Type<PacketServer> TYPE = new Type<>(ID);

    public static final StreamCodec<FriendlyByteBuf, PacketServer> CODEC = StreamCodec.of(
            (buf, packet) -> buf.writeUtf(packet.message),
            buf -> new PacketServer(buf.readUtf())
    );

    @Override
    public @NotNull Type<? extends CustomPacketPayload> type() {
        return TYPE;
    }
}

package com.temp.testfmj.client;

import net.minecraft.client.Minecraft;
import net.minecraft.network.protocol.common.ClientCommonPacketListener;

public class PacketHandler {

    public static void handleYourPacket(ClientCommonPacketListener listener, PacketServer packet) {
        Minecraft client = Minecraft.getInstance();

        client.execute(() -> {
            TestfmjClient cli = new TestfmjClient();
            cli.sendToServer("This is a response: "+packet.message());
        });
    }
}

package com.temp.testfmj.mixin;

import com.temp.testfmj.client.PacketHandler;
import com.temp.testfmj.client.PacketServer;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.ModifyArg;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import net.minecraft.network.protocol.common.ClientCommonPacketListener;
import net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket;
import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
import net.minecraft.network.protocol.common.custom.CustomPacketPayload.FallbackProvider;

@Mixin(ClientboundCustomPayloadPacket.class)
public class ClientboundCustomPayloadPacketMixin {
    @SuppressWarnings("rawtypes")
    @ModifyArg(
            method = "<clinit>",
            at = @At(
                    value = "INVOKE",
                    target = "Lnet/minecraft/network/protocol/common/custom/CustomPacketPayload;codec(Lnet/minecraft/network/protocol/common/custom/CustomPacketPayload$FallbackProvider;Ljava/util/List;)Lnet/minecraft/network/codec/StreamCodec;"
            ),
            index = 0
    )
    private static FallbackProvider replaceFallbackProvider(FallbackProvider original) {
        return (resourceLocation) -> {
            if(PacketServer.ID.equals(resourceLocation)) {
                return PacketServer.CODEC;
            } else {
                return original.create(resourceLocation);
            }
        };
    }

    @Shadow
    public CustomPacketPayload payload() { return null; }

    @Inject(method = "handle(Lnet/minecraft/network/protocol/common/ClientCommonPacketListener;)V", at = @At("HEAD"), cancellable = true)
    private void handleCustomPayload(ClientCommonPacketListener clientCommonPacketListener, CallbackInfo ci) {
        if(this.payload() instanceof PacketServer payload) {
            PacketHandler.handleYourPacket(clientCommonPacketListener, payload);
            ci.cancel();
        }
    }
}

And the plugin is

package com.temp.testS;

import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.plugin.messaging.PluginMessageListener;

import java.io.IOException;
import java.io.ByteArrayOutputStream;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

import com.google.common.io.ByteArrayDataInput;
import com.google.common.io.ByteStreams;

public final class TestS extends JavaPlugin implements PluginMessageListener {

    public static final String CHANNEL = "temp:mod_channel";
    private static PrintWriter debugWriter;
    private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss.SSS");

    @Override
    public void onEnable() {
        try {
            debugWriter = new PrintWriter(new FileWriter("debug_server.log", true));
            debugLog("=== SERVER DEBUG LOGGER INITIALIZED ===");
        } catch (IOException e) {
            e.printStackTrace();
        }

        getServer().getMessenger().registerIncomingPluginChannel(this, CHANNEL, this);
        getServer().getMessenger().registerOutgoingPluginChannel(this, CHANNEL);
        getLogger().info("Listening for plugin messages...");
        debugLog("Server plugin enabled, channels registered");
    }

    @Override
    public void onDisable() {
        getLogger().info("TestfReceiver disabled.");
        if (debugWriter != null) {
            debugLog("=== SERVER SHUTTING DOWN ===");
            debugWriter.close();
        }
    }

    private void debugLog(String message) {
        if (debugWriter != null) {
            String timestamp = LocalDateTime.now().format(formatter);
            debugWriter.println("[" + timestamp + "] " + message);
            debugWriter.flush();
        }
    }

    private void debugLogBytes(String prefix, byte[] bytes) {
        if (debugWriter != null) {
            StringBuilder sb = new StringBuilder();
            sb.append(prefix).append(" [").append(bytes.length).append(" bytes]: ");
            for (int i = 0; i < Math.min(bytes.length, 50); i++) {
                sb.append(String.format("%02X ", bytes[i]));
            }
            if (bytes.length > 50) sb.append("...");
            debugLog(sb.toString());
        }
    }

    private int readVarInt(ByteArrayDataInput in) {
        int value = 0;
        int position = 0;
        byte currentByte;
        while (true) {
            currentByte = in.readByte();
            value |= (currentByte & 0x7F) << position;
            if ((currentByte & 0x80) == 0) break;
            position += 7;
            if (position >= 32) throw new RuntimeException("VarInt is too big");
        }
        return value;
    }

    private byte[] writeMinecraftString(String message) throws IOException {
        byte[] stringBytes = message.getBytes("UTF-8");
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        writeVarInt(out, stringBytes.length);
        out.write(stringBytes);
        byte[] result = out.toByteArray();
        debugLogBytes("Created packet for: " + message, result);
        return result;
    }

    private void writeVarInt(ByteArrayOutputStream out, int value) throws IOException {
        while (true) {
            if ((value & ~0x7F) == 0) {
                out.write(value);
                return;
            }
            out.write((value & 0x7F) | 0x80);
            value >>>= 7;
        }
    }

    private void sendMessageToClient(Player player, String message) throws IOException {
        debugLog("ATTEMPTING TO SEND TO CLIENT: " + message);
        byte[] data = writeMinecraftString(message);
        debugLog("Packet data created, sending via plugin message");
        player.sendPluginMessage(this, CHANNEL, data);
        getLogger().info("Sent to " + player.getName() + ": " + message);
        debugLog("Plugin message sent successfully");
    }

    @Override
    public void onPluginMessageReceived(String channel, Player player, byte[] message) {
        debugLog("PLUGIN MESSAGE RECEIVED from " + player.getName());
        debugLog("Channel: " + channel);
        debugLogBytes("Received raw data", message);

        if (!channel.equals(CHANNEL)) {
            getLogger().info("Channel is different " + channel);
            debugLog("Channel mismatch, ignoring");
            return;
        }
        try {
            ByteArrayDataInput in = ByteStreams.newDataInput(message);
            int length = readVarInt(in);
            debugLog("Read VarInt length: " + length);
            byte[] stringBytes = new byte[length];
            in.readFully(stringBytes);
            String msg = new String(stringBytes, "UTF-8");
            getLogger().info("Received from " + player.getName() + ": " + msg);
            debugLog("Decoded message: " + msg);
            getLogger().info("Sending data in return");
            debugLog("About to send response...");
            sendMessageToClient(player, "How you doing");
            getLogger().info("Data sent");
            debugLog("Response sent successfully");
        } catch (Exception e) {
            debugLog("ERROR processing message: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

I don't know what I am doing wrong here.