Apply fallback skins to custom skulls with invalid or empty texture values (#3515)

core/src/main/java/org/geysermc/geyser/entity/type/player/SkullPlayerEntity.java

@@ -26,17 +26,20 @@
 package org.geysermc.geyser.entity.type.player;
 
 import com.nukkitx.math.vector.Vector3f;
+import com.nukkitx.math.vector.Vector3i;
 import com.nukkitx.protocol.bedrock.data.GameType;
 import com.nukkitx.protocol.bedrock.data.PlayerPermission;
 import com.nukkitx.protocol.bedrock.data.command.CommandPermission;
 import com.nukkitx.protocol.bedrock.data.entity.EntityData;
 import com.nukkitx.protocol.bedrock.data.entity.EntityFlag;
 import com.nukkitx.protocol.bedrock.packet.AddPlayerPacket;
+import lombok.Getter;
 import org.geysermc.geyser.level.block.BlockStateValues;
 import org.geysermc.geyser.session.GeyserSession;
 import org.geysermc.geyser.session.cache.SkullCache;
 import org.geysermc.geyser.skin.SkullSkinManager;
 
+import java.util.Objects;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
@@ -46,6 +49,12 @@ import java.util.concurrent.TimeUnit;
  */
 public class SkullPlayerEntity extends PlayerEntity {
 
+    @Getter
+    private UUID skullUUID;
+
+    @Getter
+    private Vector3i skullPosition;
+
     public SkullPlayerEntity(GeyserSession session, long geyserId) {
         super(session, 0, geyserId, UUID.randomUUID(), Vector3f.ZERO, Vector3f.ZERO, 0, 0, 0, "", null);
     }
@@ -102,11 +111,14 @@ public class SkullPlayerEntity extends PlayerEntity {
     }
 
     public void updateSkull(SkullCache.Skull skull) {
-        if (!skull.getTexturesProperty().equals(getTexturesProperty())) {
+        skullPosition = skull.getPosition();
+
+        if (!Objects.equals(skull.getTexturesProperty(), getTexturesProperty()) || !Objects.equals(skullUUID, skull.getUuid())) {
             // Make skull invisible as we change skins
             setFlag(EntityFlag.INVISIBLE, true);
             updateBedrockMetadata();
 
+            skullUUID = skull.getUuid();
             setTexturesProperty(skull.getTexturesProperty());
 
             SkullSkinManager.requestAndHandleSkin(this, session, (skin -> session.scheduleInEventLoop(() -> {

core/src/main/java/org/geysermc/geyser/session/cache/SkullCache.java

@@ -71,8 +71,9 @@ public class SkullCache {
         this.skullRenderDistanceSquared = distance * distance;
     }
 
-    public void putSkull(Vector3i position, String texturesProperty, int blockState) {
+    public void putSkull(Vector3i position, UUID uuid, String texturesProperty, int blockState) {
         Skull skull = skulls.computeIfAbsent(position, Skull::new);
+        skull.uuid = uuid;
         skull.texturesProperty = texturesProperty;
         skull.blockState = blockState;
 
@@ -201,6 +202,7 @@ public class SkullCache {
     @RequiredArgsConstructor
     @Data
     public static class Skull {
+        private UUID uuid;
         private String texturesProperty;
         private int blockState;
         private SkullPlayerEntity entity;

core/src/main/java/org/geysermc/geyser/skin/SkinManager.java

@@ -35,6 +35,7 @@ import com.nukkitx.protocol.bedrock.packet.PlayerListPacket;
 import com.nukkitx.protocol.bedrock.packet.PlayerSkinPacket;
 import org.geysermc.geyser.GeyserImpl;
 import org.geysermc.geyser.entity.type.player.PlayerEntity;
+import org.geysermc.geyser.entity.type.player.SkullPlayerEntity;
 import org.geysermc.geyser.session.GeyserSession;
 import org.geysermc.geyser.session.auth.BedrockClientData;
 import org.geysermc.geyser.text.GeyserLocale;
@@ -69,7 +70,7 @@ public class SkinManager {
             // The server either didn't have a texture to send, or we didn't have the texture ID cached.
             // Let's see if this player is a Bedrock player, and if so, let's pull their skin.
             // Otherwise, grab the default player skin
-            SkinProvider.SkinData fallbackSkinData = SkinProvider.determineFallbackSkinData(playerEntity);
+            SkinProvider.SkinData fallbackSkinData = SkinProvider.determineFallbackSkinData(playerEntity.getUuid());
             if (skin == null) {
                 skin = fallbackSkinData.skin();
                 geometry = fallbackSkinData.geometry();
@@ -255,24 +256,28 @@ public class SkinManager {
          * @return The built GameProfileData
          */
         public static @Nullable GameProfileData from(PlayerEntity entity) {
-            try {
+            String texturesProperty = entity.getTexturesProperty();
-                String texturesProperty = entity.getTexturesProperty();
+            if (texturesProperty == null) {
+                // Likely offline mode
+                return null;
+            }
 
-                if (texturesProperty == null) {
+            try {
-                    // Likely offline mode
-                    return null;
-                }
                 return loadFromJson(texturesProperty);
-            } catch (IOException exception) {
+            } catch (Exception exception) {
-                GeyserImpl.getInstance().getLogger().debug("Something went wrong while processing skin for " + entity.getUsername());
+                if (entity instanceof SkullPlayerEntity skullEntity) {
+                    GeyserImpl.getInstance().getLogger().debug("Something went wrong while processing skin for skull at " + skullEntity.getSkullPosition() + " with Value: " + texturesProperty);
+                } else {
+                    GeyserImpl.getInstance().getLogger().debug("Something went wrong while processing skin for " + entity.getUsername() + " with Value: " + texturesProperty);
+                }
                 if (GeyserImpl.getInstance().getConfig().isDebugMode()) {
                     exception.printStackTrace();
                 }
-                return null;
             }
+            return null;
         }
 
-        private static GameProfileData loadFromJson(String encodedJson) throws IOException {
+        private static GameProfileData loadFromJson(String encodedJson) throws IOException, IllegalArgumentException {
             JsonNode skinObject = GeyserImpl.JSON_MAPPER.readTree(new String(Base64.getDecoder().decode(encodedJson), StandardCharsets.UTF_8));
             JsonNode textures = skinObject.get("textures");
 
@@ -285,14 +290,23 @@ public class SkinManager {
                 return null;
             }
 
-            String skinUrl = skinTexture.get("url").asText().replace("http://", "https://");
+            String skinUrl;
+            JsonNode skinUrlNode = skinTexture.get("url");
+            if (skinUrlNode != null && skinUrlNode.isTextual()) {
+                skinUrl = skinUrlNode.asText().replace("http://", "https://");
+            } else {
+                return null;
+            }
 
             boolean isAlex = skinTexture.has("metadata");
 
             String capeUrl = null;
             JsonNode capeTexture = textures.get("CAPE");
             if (capeTexture != null) {
-                capeUrl = capeTexture.get("url").asText().replace("http://", "https://");
+                JsonNode capeUrlNode = capeTexture.get("url");
+                if (capeUrlNode != null && capeUrlNode.isTextual()) {
+                    capeUrl = capeUrlNode.asText().replace("http://", "https://");
+                }
             }
 
             return new GameProfileData(skinUrl, capeUrl, isAlex);

core/src/main/java/org/geysermc/geyser/skin/SkinProvider.java

@@ -26,9 +26,6 @@
 package org.geysermc.geyser.skin;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.github.steveice10.opennbt.tag.builtin.CompoundTag;
-import com.github.steveice10.opennbt.tag.builtin.IntArrayTag;
-import com.github.steveice10.opennbt.tag.builtin.Tag;
 import com.google.common.cache.Cache;
 import com.google.common.cache.CacheBuilder;
 import it.unimi.dsi.fastutil.bytes.ByteArrays;
@@ -172,14 +169,13 @@ public class SkinProvider {
     /**
      * If skin data fails to apply, or there is no skin data to apply, determine what skin we should give as a fallback.
      */
-    static SkinData determineFallbackSkinData(PlayerEntity entity) {
+    static SkinData determineFallbackSkinData(UUID uuid) {
         Skin skin = null;
         Cape cape = null;
         SkinGeometry geometry = SkinGeometry.WIDE;
 
         if (GeyserImpl.getInstance().getConfig().getRemote().authType() != AuthType.ONLINE) {
             // Let's see if this player is a Bedrock player, and if so, let's pull their skin.
-            UUID uuid = entity.getUuid();
             GeyserSession session = GeyserImpl.getInstance().connectionByUuid(uuid);
             if (session != null) {
                 String skinId = session.getClientData().getSkinId();
@@ -192,7 +188,7 @@ public class SkinProvider {
 
         if (skin == null) {
             // We don't have a skin for the player right now. Fall back to a default.
-            ProvidedSkins.ProvidedSkin providedSkin = ProvidedSkins.getDefaultPlayerSkin(entity.getUuid());
+            ProvidedSkins.ProvidedSkin providedSkin = ProvidedSkins.getDefaultPlayerSkin(uuid);
             skin = providedSkin.getData();
             geometry = providedSkin.isSlim() ? SkinProvider.SkinGeometry.SLIM : SkinProvider.SkinGeometry.WIDE;
         }
@@ -232,7 +228,7 @@ public class SkinProvider {
         SkinManager.GameProfileData data = SkinManager.GameProfileData.from(entity);
         if (data == null) {
             // This player likely does not have a textures property
-            return CompletableFuture.completedFuture(determineFallbackSkinData(entity));
+            return CompletableFuture.completedFuture(determineFallbackSkinData(entity.getUuid()));
         }
 
         return requestSkinAndCape(entity.getUuid(), data.skinUrl(), data.capeUrl())
@@ -597,48 +593,23 @@ public class SkinProvider {
     }
 
     /**
-     * If a skull has a username but no textures, request them.
+     * Request textures from a player's UUID
      *
-     * @param skullOwner the CompoundTag of the skull with no textures
+     * @param uuid the player's UUID without any hyphens
      * @return a completable GameProfile with textures included
      */
-    public static CompletableFuture<String> requestTexturesFromUsername(CompoundTag skullOwner) {
+    public static CompletableFuture<String> requestTexturesFromUUID(String uuid) {
         return CompletableFuture.supplyAsync(() -> {
-            Tag uuidTag = skullOwner.get("Id");
-            String uuidToString = "";
-            JsonNode node;
-            boolean retrieveUuidFromInternet = !(uuidTag instanceof IntArrayTag); // also covers null check
-
-            if (!retrieveUuidFromInternet) {
-                int[] uuidAsArray = ((IntArrayTag) uuidTag).getValue();
-                // thank u viaversion
-                UUID uuid = new UUID((long) uuidAsArray[0] << 32 | ((long) uuidAsArray[1] & 0xFFFFFFFFL),
-                        (long) uuidAsArray[2] << 32 | ((long) uuidAsArray[3] & 0xFFFFFFFFL));
-                retrieveUuidFromInternet = uuid.version() != 4;
-                uuidToString = uuid.toString().replace("-", "");
-            }
-
             try {
-                if (retrieveUuidFromInternet) {
+                JsonNode node = WebUtils.getJson("https://sessionserver.mojang.com/session/minecraft/profile/" + uuid);
-                    // Offline skin, or no present UUID
-                    node = WebUtils.getJson("https://api.mojang.com/users/profiles/minecraft/" + skullOwner.get("Name").getValue());
-                    JsonNode id = node.get("id");
-                    if (id == null) {
-                        GeyserImpl.getInstance().getLogger().debug("No UUID found in Mojang response for " + skullOwner.get("Name").getValue());
-                        return null;
-                    }
-                    uuidToString = id.asText();
-                }
-
-                // Get textures from UUID
-                node = WebUtils.getJson("https://sessionserver.mojang.com/session/minecraft/profile/" + uuidToString);
                 JsonNode properties = node.get("properties");
                 if (properties == null) {
-                    GeyserImpl.getInstance().getLogger().debug("No properties found in Mojang response for " + uuidToString);
+                    GeyserImpl.getInstance().getLogger().debug("No properties found in Mojang response for " + uuid);
                     return null;
                 }
                 return node.get("properties").get(0).get("value").asText();
             } catch (Exception e) {
+                GeyserImpl.getInstance().getLogger().debug("Unable to request textures for " + uuid);
                 if (GeyserImpl.getInstance().getConfig().isDebugMode()) {
                     e.printStackTrace();
                 }
@@ -647,6 +618,37 @@ public class SkinProvider {
         }, EXECUTOR_SERVICE);
     }
 
+    /**
+     * Request textures from a player's username
+     *
+     * @param username the player's username
+     * @return a completable GameProfile with textures included
+     */
+    public static CompletableFuture<String> requestTexturesFromUsername(String username) {
+        return CompletableFuture.supplyAsync(() -> {
+            try {
+                // Offline skin, or no present UUID
+                JsonNode node = WebUtils.getJson("https://api.mojang.com/users/profiles/minecraft/" + username);
+                JsonNode id = node.get("id");
+                if (id == null) {
+                    GeyserImpl.getInstance().getLogger().debug("No UUID found in Mojang response for " + username);
+                    return null;
+                }
+                return id.asText();
+            } catch (Exception e) {
+                if (GeyserImpl.getInstance().getConfig().isDebugMode()) {
+                    e.printStackTrace();
+                }
+                return null;
+            }
+        }, EXECUTOR_SERVICE).thenCompose(uuid -> {
+            if (uuid == null) {
+                return CompletableFuture.completedFuture(null);
+            }
+            return requestTexturesFromUUID(uuid);
+        });
+    }
+
     private static BufferedImage downloadImage(String imageUrl, CapeProvider provider) throws IOException {
         if (provider == CapeProvider.FIVEZIG)
             return readFiveZigCape(imageUrl);

core/src/main/java/org/geysermc/geyser/skin/SkullSkinManager.java

@@ -29,11 +29,12 @@ import com.nukkitx.protocol.bedrock.data.skin.ImageData;
 import com.nukkitx.protocol.bedrock.data.skin.SerializedSkin;
 import com.nukkitx.protocol.bedrock.packet.PlayerSkinPacket;
 import org.geysermc.geyser.GeyserImpl;
-import org.geysermc.geyser.entity.type.player.PlayerEntity;
+import org.geysermc.geyser.entity.type.player.SkullPlayerEntity;
 import org.geysermc.geyser.session.GeyserSession;
 import org.geysermc.geyser.text.GeyserLocale;
 
 import java.util.Collections;
+import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 
 public class SkullSkinManager extends SkinManager {
@@ -48,28 +49,37 @@ public class SkullSkinManager extends SkinManager {
         );
     }
 
-    public static void requestAndHandleSkin(PlayerEntity entity, GeyserSession session,
+    public static void requestAndHandleSkin(SkullPlayerEntity entity, GeyserSession session,
                                             Consumer<SkinProvider.Skin> skinConsumer) {
+        BiConsumer<SkinProvider.Skin, Throwable> applySkin = (skin, throwable) -> {
+            try {
+                PlayerSkinPacket packet = new PlayerSkinPacket();
+                packet.setUuid(entity.getUuid());
+                packet.setOldSkinName("");
+                packet.setNewSkinName(skin.getTextureUrl());
+                packet.setSkin(buildSkullEntryManually(skin.getTextureUrl(), skin.getSkinData()));
+                packet.setTrustedSkin(true);
+                session.sendUpstreamPacket(packet);
+            } catch (Exception e) {
+                GeyserImpl.getInstance().getLogger().error(GeyserLocale.getLocaleStringLog("geyser.skin.fail", entity.getUuid()), e);
+            }
+
+            if (skinConsumer != null) {
+                skinConsumer.accept(skin);
+            }
+        };
+
         GameProfileData data = GameProfileData.from(entity);
-
+        if (data == null) {
-        SkinProvider.requestSkin(entity.getUuid(), data.skinUrl(), true)
+            GeyserImpl.getInstance().getLogger().debug("Using fallback skin for skull at " + entity.getSkullPosition() +
-                .whenCompleteAsync((skin, throwable) -> {
+                    " with texture value: " + entity.getTexturesProperty() + " and UUID: " + entity.getSkullUUID());
-                    try {
+            // No texture available, fallback using the UUID
-                        PlayerSkinPacket packet = new PlayerSkinPacket();
+            SkinProvider.SkinData fallback = SkinProvider.determineFallbackSkinData(entity.getSkullUUID());
-                        packet.setUuid(entity.getUuid());
+            applySkin.accept(fallback.skin(), null);
-                        packet.setOldSkinName("");
+        } else {
-                        packet.setNewSkinName(skin.getTextureUrl());
+            SkinProvider.requestSkin(entity.getUuid(), data.skinUrl(), true)
-                        packet.setSkin(buildSkullEntryManually(skin.getTextureUrl(), skin.getSkinData()));
+                    .whenCompleteAsync(applySkin);
-                        packet.setTrustedSkin(true);
+        }
-                        session.sendUpstreamPacket(packet);
-                    } catch (Exception e) {
-                        GeyserImpl.getInstance().getLogger().error(GeyserLocale.getLocaleStringLog("geyser.skin.fail", entity.getUuid()), e);
-                    }
-
-                    if (skinConsumer != null) {
-                        skinConsumer.accept(skin);
-                    }
-                });
     }
 
 }

core/src/main/java/org/geysermc/geyser/translator/level/block/entity/SkullBlockEntityTranslator.java

@@ -27,6 +27,7 @@ package org.geysermc.geyser.translator.level.block.entity;
 
 import com.github.steveice10.mc.protocol.data.game.level.block.BlockEntityType;
 import com.github.steveice10.opennbt.tag.builtin.CompoundTag;
+import com.github.steveice10.opennbt.tag.builtin.IntArrayTag;
 import com.github.steveice10.opennbt.tag.builtin.ListTag;
 import com.github.steveice10.opennbt.tag.builtin.StringTag;
 import com.nukkitx.math.vector.Vector3i;
@@ -35,7 +36,10 @@ import org.geysermc.geyser.level.block.BlockStateValues;
 import org.geysermc.geyser.session.GeyserSession;
 import org.geysermc.geyser.skin.SkinProvider;
 
+import java.nio.charset.StandardCharsets;
 import java.util.LinkedHashMap;
+import java.util.Locale;
+import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 
 @BlockEntity(type = BlockEntityType.SKULL)
@@ -53,33 +57,54 @@ public class SkullBlockEntityTranslator extends BlockEntityTranslator implements
         builder.put("SkullType", skullVariant);
     }
 
-    private static CompletableFuture<String> getTextures(CompoundTag tag) {
+    private static UUID getUUID(CompoundTag owner) {
-        CompoundTag owner = tag.get("SkullOwner");
+        if (owner.get("Id") instanceof IntArrayTag uuidTag && uuidTag.length() == 4) {
-        if (owner != null) {
+            int[] uuidAsArray = uuidTag.getValue();
-            CompoundTag properties = owner.get("Properties");
+            // thank u viaversion
-            if (properties == null) {
+            return new UUID((long) uuidAsArray[0] << 32 | ((long) uuidAsArray[1] & 0xFFFFFFFFL),
-                return SkinProvider.requestTexturesFromUsername(owner);
+                    (long) uuidAsArray[2] << 32 | ((long) uuidAsArray[3] & 0xFFFFFFFFL));
-            }
-
-            ListTag textures = properties.get("textures");
-            LinkedHashMap<?,?> tag1 = (LinkedHashMap<?,?>) textures.get(0).getValue();
-            StringTag texture = (StringTag) tag1.get("Value");
-            return CompletableFuture.completedFuture(texture.getValue());
         }
-        return CompletableFuture.completedFuture(null);
+        // Convert username to an offline UUID
+        String username = null;
+        if (owner.get("Name") instanceof StringTag nameTag) {
+            username = nameTag.getValue().toLowerCase(Locale.ROOT);
+        }
+        return UUID.nameUUIDFromBytes(("OfflinePlayer:" + username).getBytes(StandardCharsets.UTF_8));
+    }
+
+    private static CompletableFuture<String> getTextures(CompoundTag owner, UUID uuid) {
+        CompoundTag properties = owner.get("Properties");
+        if (properties == null) {
+            if (uuid != null && uuid.version() == 4) {
+                String uuidString = uuid.toString().replace("-", "");
+                return SkinProvider.requestTexturesFromUUID(uuidString);
+            } else if (owner.get("Name") instanceof StringTag nameTag) {
+                // Fall back to username if UUID was missing or was an offline mode UUID
+                return SkinProvider.requestTexturesFromUsername(nameTag.getValue());
+            }
+            return CompletableFuture.completedFuture(null);
+        }
+
+        ListTag textures = properties.get("textures");
+        LinkedHashMap<?,?> tag1 = (LinkedHashMap<?,?>) textures.get(0).getValue();
+        StringTag texture = (StringTag) tag1.get("Value");
+        return CompletableFuture.completedFuture(texture.getValue());
     }
 
     public static void translateSkull(GeyserSession session, CompoundTag tag, int posX, int posY, int posZ, int blockState) {
         Vector3i blockPosition = Vector3i.from(posX, posY, posZ);
-        getTextures(tag).whenComplete((texturesProperty, throwable) -> {
+        CompoundTag owner = tag.get("SkullOwner");
-            if (texturesProperty == null) {
+        if (owner == null) {
-                session.getGeyser().getLogger().debug("Custom skull with invalid SkullOwner tag: " + blockPosition + " " + tag);
+            session.getSkullCache().removeSkull(blockPosition);
-                return;
+            return;
-            }
+        }
+
+        UUID uuid = getUUID(owner);
+        getTextures(owner, uuid).whenComplete((texturesProperty, throwable) -> {
             if (session.getEventLoop().inEventLoop()) {
-                session.getSkullCache().putSkull(blockPosition, texturesProperty, blockState);
+                session.getSkullCache().putSkull(blockPosition, uuid, texturesProperty, blockState);
             } else {
-                session.executeInEventLoop(() -> session.getSkullCache().putSkull(blockPosition, texturesProperty, blockState));
+                session.executeInEventLoop(() -> session.getSkullCache().putSkull(blockPosition, uuid, texturesProperty, blockState));
             }
         });
     }