[sandbox] Print error message on seccomp sandbox violation

Co-authored-by: cpunch <sethtstubbs@gmail.com>

.github/workflows/check-builds.yaml

@@ -29,7 +29,7 @@ jobs:
           submodules: recursive
           fetch-depth: 0
       - name: Install dependencies
-        run: sudo apt install clang cmake snap libsqlite3-dev -y && sudo snap install powershell --classic
+        run: sudo apt install clang cmake snap -y && sudo snap install powershell --classic
       - name: Check compilation
         run: |
           $versions = "104", "728", "1013"
@@ -113,7 +113,7 @@ jobs:
 
   copy-artifacts:
     if: github.event_name != 'pull_request' && github.ref == 'refs/heads/master'
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     needs: [windows-build, ubuntu-build]
     env:
       BOT_SSH_KEY: ${{ secrets.BOT_SSH_KEY }}

.github/workflows/push-docker-image.yml

@@ -11,6 +11,11 @@ jobs:
     runs-on: ubuntu-latest
     permissions:
       contents: read
+    strategy:
+      matrix:
+        platforms:
+          - linux/amd64
+          - linux/arm64
     steps:
       - uses: actions/checkout@v4
       - name: Retrieve major version
@@ -26,13 +31,11 @@ jobs:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
       - name: Build and push the Docker image
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v5
         with:
           context: .
           file: ./Dockerfile
-          platforms: linux/amd64,linux/arm64
+          platforms: ${{ matrix.platforms }}
           push: true
           tags: ${{ secrets.DOCKERHUB_REPOSITORY }}:${{ github.ref_name }},${{ secrets.DOCKERHUB_REPOSITORY }}:${{ steps.split.outputs._0 }},${{ secrets.DOCKERHUB_REPOSITORY }}:latest

Dockerfile

@@ -1,41 +1,32 @@
 # build
-FROM alpine:3 as build
+FROM debian:stable-slim as build
 
 WORKDIR /usr/src/app
 
-RUN apk update && apk upgrade && apk add \
-linux-headers \
+RUN apt-get -y update && apt-get install -y \
 git \
-clang18 \
+clang \
 make \
-sqlite-dev
+libsqlite3-dev
 
 COPY src ./src
 COPY vendor ./vendor
 COPY .git ./.git
 COPY Makefile CMakeLists.txt version.h.in ./
 
-RUN sed -i 's/^CC=clang$/&-18/' Makefile
-RUN sed -i 's/^CXX=clang++$/&-18/' Makefile
-
-RUN make nosandbox -j$(nproc)
+RUN make -j8
 
 # prod
-FROM alpine:3
+FROM debian:stable-slim
 
 WORKDIR /usr/src/app
 
-RUN apk update && apk upgrade && apk add \
-libstdc++ \
-sqlite-dev
+RUN apt-get -y update && apt-get install -y \
+libsqlite3-dev
 
 COPY --from=build /usr/src/app/bin/fusion /bin/fusion
 COPY sql ./sql
 
 CMD ["/bin/fusion"]
 
-EXPOSE 23000/tcp
-EXPOSE 23001/tcp
-EXPOSE 8003/tcp
-
-LABEL Name=openfusion Version=1.6.0
+LABEL Name=openfusion Version=0.0.2

Makefile

@@ -115,7 +115,6 @@ CXXHDR=\
 	src/settings.hpp\
 	src/Transport.hpp\
 	src/TableData.hpp\
-	src/Bucket.hpp\
 	src/Chunking.hpp\
 	src/Buddies.hpp\
 	src/Groups.hpp\

config.ini

@@ -18,8 +18,8 @@ acceptallcustomnames=true
 # automatically create them?
 autocreateaccounts=true
 # list of supported authentication methods (comma-separated)
-# password = allow logging in with plaintext passwords
-# cookie = allow logging in with one-shot auth cookies
+# password = allow login type 1 with plaintext passwords
+# cookie = allow login type 2 with one-shot auth cookies
 authmethods=password
 # how often should everything be flushed to the database?
 # the default is 4 minutes
@@ -102,8 +102,5 @@ eventmode=0
 enabled=false
 # the port to listen for connections on
 port=8003
-# The local IP to listen on.
-# Do not change this unless you know what you're doing.
-listenip=127.0.0.1
 # how often the listeners should be updated (in milliseconds)
 interval=5000

docker-compose.yml

@@ -1,9 +1,11 @@
+version: '3.4'
+
 services:
   openfusion:
+    image: openfusion
     build:
       context: .
       dockerfile: ./Dockerfile
-    image: openfusion/openfusion:latest
     volumes:
       - ./config.ini:/usr/src/app/config.ini
       - ./database.db:/usr/src/app/database.db

sql/migration5.sql

@@ -1,8 +0,0 @@
-BEGIN TRANSACTION;
--- New Columns
-ALTER TABLE Accounts ADD Email TEXT DEFAULT '' NOT NULL;
-ALTER TABLE Accounts ADD LastPasswordReset INTEGER DEFAULT 0 NOT NULL;
--- Update DB Version
-UPDATE Meta SET Value = 6 WHERE Key = 'DatabaseVersion';
-UPDATE Meta SET Value = strftime('%s', 'now') WHERE Key = 'LastMigration';
-COMMIT;

sql/tables.sql

@@ -9,8 +9,6 @@ CREATE TABLE IF NOT EXISTS Accounts (
     BannedUntil  INTEGER DEFAULT 0 NOT NULL,
     BannedSince  INTEGER DEFAULT 0 NOT NULL,
     BanReason    TEXT    DEFAULT '' NOT NULL,
-    Email             TEXT    DEFAULT '' NOT NULL,
-    LastPasswordReset INTEGER DEFAULT 0 NOT NULL,
     PRIMARY KEY(AccountID AUTOINCREMENT)
 );
 

src/Abilities.cpp

@@ -334,8 +334,8 @@ void Abilities::useNanoSkill(CNSocket* sock, SkillData* skill, sNano& nano, std:
     size_t resplen = sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC);
     for(SkillResult& sr : results)
         resplen += sr.size;
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_NANO_SKILL_USE_SUCC* pkt = (sP_FE2CL_NANO_SKILL_USE_SUCC*)respbuf;
     pkt->iPC_ID = plr->iID;
@@ -379,8 +379,8 @@ void Abilities::useNPCSkill(EntityRef npc, int skillID, std::vector<ICombatant*>
     size_t resplen = sizeof(sP_FE2CL_NPC_SKILL_HIT);
     for(SkillResult& sr : results)
         resplen += sr.size;
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_NPC_SKILL_HIT* pkt = (sP_FE2CL_NPC_SKILL_HIT*)respbuf;
     pkt->iNPC_ID = npc.id;

src/Bucket.hpp

@@ -1,40 +0,0 @@
-#pragma once
-
-#include <array>
-#include <optional>
-
-#include <assert.h>
-
-template<class T, size_t N>
-class Bucket {
-    std::array<T, N> buf;
-    size_t sz;
-public:
-    Bucket() {
-        sz = 0;
-    }
-
-    void add(const T& item) {
-        assert(sz < N);
-        buf[sz++] = item;
-    }
-
-    std::optional<T> get(size_t idx) const {
-        if (idx < sz) {
-            return buf[idx];
-        }
-        return std::nullopt;
-    }
-
-    size_t size() const {
-        return sz;
-    }
-
-    bool isFull() const {
-        return sz == N;
-    }
-
-    void clear() {
-        sz = 0;
-    }
-};

src/Buddies.cpp

@@ -41,9 +41,9 @@ void Buddies::sendBuddyList(CNSocket* sock) {
 
     // initialize response struct
     size_t resplen = sizeof(sP_FE2CL_REP_PC_BUDDYLIST_INFO_SUCC) + buddyCnt * sizeof(sBuddyBaseInfo);
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
 
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_REP_PC_BUDDYLIST_INFO_SUCC* resp = (sP_FE2CL_REP_PC_BUDDYLIST_INFO_SUCC*)respbuf;
     sBuddyBaseInfo* respdata = (sBuddyBaseInfo*)(respbuf + sizeof(sP_FE2CL_REP_PC_BUDDYLIST_INFO_SUCC));

src/Buffs.cpp

@@ -178,9 +178,9 @@ void Buffs::tickDrain(EntityRef self, Buff* buff, int mult) {
     int dealt = combatant->takeDamage(buff->getLastSource(), damage);
 
     size_t resplen = sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK) + sizeof(sSkillResult_Damage);
-    assert(resplen < CN_PACKET_BODY_SIZE);
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK *pkt = (sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK*)respbuf;
     pkt->iID = self.id;

src/Chunking.cpp

@@ -1,9 +1,7 @@
 #include "Chunking.hpp"
 
-#include "Player.hpp"
 #include "MobAI.hpp"
 #include "NPCManager.hpp"
-#include "Bucket.hpp"
 
 #include <assert.h>
 
@@ -13,12 +11,6 @@ using namespace Chunking;
  * The initial chunkPos value before a player is placed into the world.
  */
 const ChunkPos Chunking::INVALID_CHUNK = {};
-constexpr size_t MAX_PC_PER_AROUND = (CN_PACKET_BODY_SIZE - sizeof(int32_t)) / sizeof(sPCAppearanceData);
-constexpr size_t MAX_NPC_PER_AROUND = (CN_PACKET_BODY_SIZE - sizeof(int32_t)) / sizeof(sNPCAppearanceData);
-constexpr size_t MAX_SHINY_PER_AROUND = (CN_PACKET_BODY_SIZE - sizeof(int32_t)) / sizeof(sShinyAppearanceData);
-constexpr size_t MAX_TRANSPORTATION_PER_AROUND = (CN_PACKET_BODY_SIZE - sizeof(int32_t)) / sizeof(sTransportationAppearanceData);
-constexpr size_t MAX_IDS_PER_AROUND_DEL = (CN_PACKET_BODY_SIZE - sizeof(int32_t)) / sizeof(int32_t);
-constexpr size_t MAX_TRANSPORTATION_IDS_PER_AROUND_DEL = MAX_IDS_PER_AROUND_DEL - 1; // 1 less for eTT
 
 std::map<ChunkPos, Chunk*> Chunking::chunks;
 
@@ -83,80 +75,11 @@ void Chunking::untrackEntity(ChunkPos chunkPos, const EntityRef ref) {
         deleteChunk(chunkPos);
 }
 
-template<class T, size_t N>
-static void sendAroundPackets(const EntityRef recipient, std::vector<Bucket<T, N>>& buckets, uint32_t packetId) {
-    assert(recipient.kind == EntityKind::PLAYER);
-
-    uint8_t pktBuf[CN_PACKET_BODY_SIZE];
-    for (const auto& bucket : buckets) {
-        memset(pktBuf, 0, CN_PACKET_BODY_SIZE);
-        int count = bucket.size();
-        *((int32_t*)pktBuf) = count;
-        T* data = (T*)(pktBuf + sizeof(int32_t));
-        for (size_t i = 0; i < count; i++) {
-            data[i] = bucket.get(i).value();
-        }
-        recipient.sock->sendPacket(pktBuf, packetId, sizeof(int32_t) + (count * sizeof(T)));
-    }
-}
-
-template<size_t N>
-static void sendAroundDelPackets(const EntityRef recipient, std::vector<Bucket<int32_t, N>>& buckets, uint32_t packetId) {
-    assert(recipient.kind == EntityKind::PLAYER);
-
-    uint8_t pktBuf[CN_PACKET_BODY_SIZE];
-    for (const auto& bucket : buckets) {
-        memset(pktBuf, 0, CN_PACKET_BODY_SIZE);
-        int count = bucket.size();
-        assert(count <= N);
-
-        size_t baseSize;
-        if (packetId == P_FE2CL_AROUND_DEL_TRANSPORTATION) {
-            sP_FE2CL_AROUND_DEL_TRANSPORTATION* pkt = (sP_FE2CL_AROUND_DEL_TRANSPORTATION*)pktBuf;
-            pkt->eTT = 3;
-            pkt->iCnt = count;
-            baseSize = sizeof(sP_FE2CL_AROUND_DEL_TRANSPORTATION);
-        } else {
-            *((int32_t*)pktBuf) = count;
-            baseSize = sizeof(int32_t);
-        }
-        int32_t* ids = (int32_t*)(pktBuf + baseSize);
-
-        for (size_t i = 0; i < count; i++) {
-            ids[i] = bucket.get(i).value();
-        }
-        recipient.sock->sendPacket(pktBuf, packetId, baseSize + (count * sizeof(int32_t)));
-    }
-}
-
-template<class T, size_t N>
-static void bufferAppearanceData(std::vector<Bucket<T, N>>& buckets, const T& data) {
-    if (buckets.empty())
-        buckets.push_back({});
-    auto& bucket = buckets[buckets.size() - 1];
-    bucket.add(data);
-    if (bucket.isFull())
-        buckets.push_back({});
-}
-
-template<size_t N>
-static void bufferIdForDisappearance(std::vector<Bucket<int32_t, N>>& buckets, int32_t id) {
-    if (buckets.empty())
-        buckets.push_back({});
-    auto& bucket = buckets[buckets.size() - 1];
-    bucket.add(id);
-    if (bucket.isFull())
-        buckets.push_back({});
-}
-
 void Chunking::addEntityToChunks(std::set<Chunk*> chnks, const EntityRef ref) {
     Entity *ent = ref.getEntity();
     bool alive = ent->isExtant();
 
-    std::vector<Bucket<sPCAppearanceData, MAX_PC_PER_AROUND>> pcAppearances;
-    std::vector<Bucket<sNPCAppearanceData, MAX_NPC_PER_AROUND>> npcAppearances;
-    std::vector<Bucket<sShinyAppearanceData, MAX_SHINY_PER_AROUND>> shinyAppearances;
-    std::vector<Bucket<sTransportationAppearanceData, MAX_TRANSPORTATION_PER_AROUND>> transportationAppearances;
+    // TODO: maybe optimize this, potentially using AROUND packets?
     for (Chunk *chunk : chnks) {
         for (const EntityRef otherRef : chunk->entities) {
             // skip oneself
@@ -172,38 +95,7 @@ void Chunking::addEntityToChunks(std::set<Chunk*> chnks, const EntityRef ref) {
 
             // notify this *player* of the existence of all visible Entities
             if (ref.kind == EntityKind::PLAYER && other->isExtant()) {
-                sPCAppearanceData pcData;
-                sNPCAppearanceData npcData;
-                sShinyAppearanceData eggData;
-                sTransportationAppearanceData busData;
-                switch(otherRef.kind) {
-                case EntityKind::PLAYER:
-                    pcData = dynamic_cast<Player*>(other)->getAppearanceData();
-                    bufferAppearanceData(pcAppearances, pcData);
-                    break;
-                case EntityKind::SIMPLE_NPC:
-                    npcData = dynamic_cast<BaseNPC*>(other)->getAppearanceData();
-                    bufferAppearanceData(npcAppearances, npcData);
-                    break;
-                case EntityKind::COMBAT_NPC:
-                    npcData = dynamic_cast<CombatNPC*>(other)->getAppearanceData();
-                    bufferAppearanceData(npcAppearances, npcData);
-                    break;
-                case EntityKind::MOB:
-                    npcData = dynamic_cast<Mob*>(other)->getAppearanceData();
-                    bufferAppearanceData(npcAppearances, npcData);
-                    break;
-                case EntityKind::EGG:
-                    eggData = dynamic_cast<Egg*>(other)->getShinyAppearanceData();
-                    bufferAppearanceData(shinyAppearances, eggData);
-                    break;
-                case EntityKind::BUS:
-                    busData = dynamic_cast<Bus*>(other)->getTransportationAppearanceData();
-                    bufferAppearanceData(transportationAppearances, busData);
-                    break;
-                default:
-                    break;
-                }
+                other->enterIntoViewOf(ref.sock);
             }
 
             // for mobs, increment playersInView
@@ -213,27 +105,13 @@ void Chunking::addEntityToChunks(std::set<Chunk*> chnks, const EntityRef ref) {
                 ((Mob*)other)->playersInView++;
         }
     }
-
-    if (ref.kind == EntityKind::PLAYER) {
-        if (!pcAppearances.empty())
-            sendAroundPackets(ref, pcAppearances, P_FE2CL_PC_AROUND);
-        if (!npcAppearances.empty())
-            sendAroundPackets(ref, npcAppearances, P_FE2CL_NPC_AROUND);
-        if (!shinyAppearances.empty())
-            sendAroundPackets(ref, shinyAppearances, P_FE2CL_SHINY_AROUND);
-        if (!transportationAppearances.empty())
-            sendAroundPackets(ref, transportationAppearances, P_FE2CL_TRANSPORTATION_AROUND);
-    }
 }
 
 void Chunking::removeEntityFromChunks(std::set<Chunk*> chnks, const EntityRef ref) {
     Entity *ent = ref.getEntity();
     bool alive = ent->isExtant();
 
-    std::vector<Bucket<int32_t, MAX_IDS_PER_AROUND_DEL>> pcDisappearances;
-    std::vector<Bucket<int32_t, MAX_IDS_PER_AROUND_DEL>> npcDisappearances;
-    std::vector<Bucket<int32_t, MAX_IDS_PER_AROUND_DEL>> shinyDisappearances;
-    std::vector<Bucket<int32_t, MAX_TRANSPORTATION_IDS_PER_AROUND_DEL>> transportationDisappearances;
+    // TODO: same as above
     for (Chunk *chunk : chnks) {
         for (const EntityRef otherRef : chunk->entities) {
             // skip oneself
@@ -249,29 +127,7 @@ void Chunking::removeEntityFromChunks(std::set<Chunk*> chnks, const EntityRef re
 
             // notify this *player* of the departure of all visible Entities
             if (ref.kind == EntityKind::PLAYER && other->isExtant()) {
-                int32_t id;
-                switch(otherRef.kind) {
-                case EntityKind::PLAYER:
-                    id = dynamic_cast<Player*>(other)->iID;
-                    bufferIdForDisappearance(pcDisappearances, id);
-                    break;
-                case EntityKind::SIMPLE_NPC:
-                case EntityKind::COMBAT_NPC:
-                case EntityKind::MOB:
-                    id = dynamic_cast<BaseNPC*>(other)->id;
-                    bufferIdForDisappearance(npcDisappearances, id);
-                    break;
-                case EntityKind::EGG:
-                    id = dynamic_cast<Egg*>(other)->id;
-                    bufferIdForDisappearance(shinyDisappearances, id);
-                    break;
-                case EntityKind::BUS:
-                    id = dynamic_cast<Bus*>(other)->id;
-                    bufferIdForDisappearance(transportationDisappearances, id);
-                    break;
-                default:
-                    break;
-                }
+                other->disappearFromViewOf(ref.sock);
             }
 
             // for mobs, decrement playersInView
@@ -281,17 +137,6 @@ void Chunking::removeEntityFromChunks(std::set<Chunk*> chnks, const EntityRef re
                 ((Mob*)other)->playersInView--;
         }
     }
-
-    if (ref.kind == EntityKind::PLAYER) {
-        if (!pcDisappearances.empty())
-            sendAroundDelPackets(ref, pcDisappearances, P_FE2CL_AROUND_DEL_PC);
-        if (!npcDisappearances.empty())
-            sendAroundDelPackets(ref, npcDisappearances, P_FE2CL_AROUND_DEL_NPC);
-        if (!shinyDisappearances.empty())
-            sendAroundDelPackets(ref, shinyDisappearances, P_FE2CL_AROUND_DEL_SHINY);
-        if (!transportationDisappearances.empty())
-            sendAroundDelPackets(ref, transportationDisappearances, P_FE2CL_AROUND_DEL_TRANSPORTATION);
-    }
 }
 
 static void emptyChunk(ChunkPos chunkPos) {

src/Combat.cpp

@@ -539,9 +539,9 @@ static void dealGooDamage(CNSocket *sock) {
         return; // ignore completely
 
     size_t resplen = sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK) + sizeof(sSkillResult_DotDamage);
-    assert(resplen < CN_PACKET_BODY_SIZE);
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK *pkt = (sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK*)respbuf;
     sSkillResult_DotDamage *dmg = (sSkillResult_DotDamage*)(respbuf + sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK));
@@ -633,9 +633,9 @@ static void pcAttackChars(CNSocket *sock, CNPacketData *data) {
 
     // initialize response struct
     size_t resplen = sizeof(sP_FE2CL_PC_ATTACK_CHARs_SUCC) + pkt->iTargetCnt * sizeof(sAttackResult);
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
 
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_PC_ATTACK_CHARs_SUCC *resp = (sP_FE2CL_PC_ATTACK_CHARs_SUCC*)respbuf;
     sAttackResult *respdata = (sAttackResult*)(respbuf+sizeof(sP_FE2CL_PC_ATTACK_CHARs_SUCC));
@@ -847,9 +847,9 @@ static void projectileHit(CNSocket* sock, CNPacketData* data) {
      */
 
     size_t resplen = sizeof(sP_FE2CL_PC_GRENADE_STYLE_HIT) + pkt->iTargetCnt * sizeof(sAttackResult);
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
 
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_PC_GRENADE_STYLE_HIT* resp = (sP_FE2CL_PC_GRENADE_STYLE_HIT*)respbuf;
     sAttackResult* respdata = (sAttackResult*)(respbuf + sizeof(sP_FE2CL_PC_GRENADE_STYLE_HIT));

src/Eggs.cpp

@@ -87,8 +87,8 @@ void Eggs::eggBuffPlayer(CNSocket* sock, int skillId, int eggId, int duration) {
 
     // initialize response struct
     size_t resplen = sizeof(sP_FE2CL_NPC_SKILL_HIT) + result.size;
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_NPC_SKILL_HIT* pkt = (sP_FE2CL_NPC_SKILL_HIT*)respbuf;
     pkt->iNPC_ID = eggId;
@@ -126,6 +126,15 @@ static void eggStep(CNServer* serv, time_t currTime) {
 
 }
 
+void Eggs::npcDataToEggData(int x, int y, int z, sNPCAppearanceData* npc, sShinyAppearanceData* egg) {
+    egg->iX = x;
+    egg->iY = y;
+    egg->iZ = z;
+    // client doesn't care about egg->iMapNum
+    egg->iShinyType = npc->iNPCType;
+    egg->iShiny_ID = npc->iNPC_ID;
+}
+
 static void eggPickup(CNSocket* sock, CNPacketData* data) {
     auto pickup = (sP_CL2FE_REQ_SHINY_PICKUP*)data->buf;
     Player* plr = PlayerManager::getPlayer(sock);
@@ -183,7 +192,7 @@ static void eggPickup(CNSocket* sock, CNPacketData* data) {
     // drop
     if (type->dropCrateId != 0) {
         const size_t resplen = sizeof(sP_FE2CL_REP_REWARD_ITEM) + sizeof(sItemReward);
-        assert(resplen < CN_PACKET_BODY_SIZE);
+        assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
         // we know it's only one trailing struct, so we can skip full validation
 
         uint8_t respbuf[resplen]; // not a variable length array, don't worry

src/Eggs.hpp

@@ -15,4 +15,5 @@ namespace Eggs {
     void init();
 
     void eggBuffPlayer(CNSocket* sock, int skillId, int eggId, int duration);
+    void npcDataToEggData(int x, int y, int z, sNPCAppearanceData* npc, sShinyAppearanceData* egg);
 }

src/Entities.cpp

@@ -70,7 +70,11 @@ void Bus::enterIntoViewOf(CNSocket *sock) {
     INITSTRUCT(sP_FE2CL_TRANSPORTATION_ENTER, pkt);
 
     // TODO: Potentially decouple this from BaseNPC?
-    pkt.AppearanceData = getTransportationAppearanceData();
+    pkt.AppearanceData = {
+        3, id, type,
+        x, y, z
+    };
+
     sock->sendPacket(pkt, P_FE2CL_TRANSPORTATION_ENTER);
 }
 
@@ -78,22 +82,12 @@ void Egg::enterIntoViewOf(CNSocket *sock) {
     INITSTRUCT(sP_FE2CL_SHINY_ENTER, pkt);
 
     // TODO: Potentially decouple this from BaseNPC?
-    pkt.ShinyAppearanceData = getShinyAppearanceData();
-    sock->sendPacket(pkt, P_FE2CL_SHINY_ENTER);
-}
-
-sTransportationAppearanceData Bus::getTransportationAppearanceData() {
-    return sTransportationAppearanceData {
-        3, id, type,
-        x, y, z
-    };
-}
-
-sShinyAppearanceData Egg::getShinyAppearanceData() {
-    return sShinyAppearanceData {
+    pkt.ShinyAppearanceData = {
         id, type, 0, // client doesn't care about map num
         x, y, z
     };
+
+    sock->sendPacket(pkt, P_FE2CL_SHINY_ENTER);
 }
 
 sNano* Player::getActiveNano() {

src/Entities.hpp

@@ -161,8 +161,6 @@ struct Egg : public BaseNPC {
 
     virtual void enterIntoViewOf(CNSocket *sock) override;
     virtual void disappearFromViewOf(CNSocket *sock) override;
-
-    sShinyAppearanceData getShinyAppearanceData();
 };
 
 struct Bus : public BaseNPC {
@@ -174,6 +172,4 @@ struct Bus : public BaseNPC {
 
     virtual void enterIntoViewOf(CNSocket *sock) override;
     virtual void disappearFromViewOf(CNSocket *sock) override;
-
-    sTransportationAppearanceData getTransportationAppearanceData();
 };

src/Groups.cpp

@@ -87,8 +87,8 @@ void Groups::addToGroup(Group* group, EntityRef member) {
         size_t pcCount = pcs.size();
         size_t npcCount = npcs.size();
 
-        uint8_t respbuf[CN_PACKET_BODY_SIZE];
-        memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+        uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
+        memset(respbuf, 0, CN_PACKET_BUFFER_SIZE);
         sP_FE2CL_PC_GROUP_JOIN* pkt = (sP_FE2CL_PC_GROUP_JOIN*)respbuf;
 
         pkt->iID_NewMember = PlayerManager::getPlayer(member.sock)->iID;
@@ -143,8 +143,8 @@ bool Groups::removeFromGroup(Group* group, EntityRef member) {
         size_t pcCount = pcs.size();
         size_t npcCount = npcs.size();
 
-        uint8_t respbuf[CN_PACKET_BODY_SIZE];
-        memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+        uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
+        memset(respbuf, 0, CN_PACKET_BUFFER_SIZE);
         sP_FE2CL_PC_GROUP_LEAVE* pkt = (sP_FE2CL_PC_GROUP_LEAVE*)respbuf;
 
         pkt->iID_LeaveMember = PlayerManager::getPlayer(member.sock)->iID;
@@ -288,8 +288,8 @@ void Groups::groupTickInfo(CNSocket* sock) {
     size_t pcCount = pcs.size();
     size_t npcCount = npcs.size();
 
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
+    memset(respbuf, 0, CN_PACKET_BUFFER_SIZE);
     sP_FE2CL_PC_GROUP_MEMBER_INFO* pkt = (sP_FE2CL_PC_GROUP_MEMBER_INFO*)respbuf;
 
     pkt->iID = plr->iID;

src/Items.cpp

@@ -46,7 +46,7 @@ static void nanoCapsuleHandler(CNSocket* sock, int slot, sItemBase *chest) {
 
     // in order to remove capsule form inventory, we have to send item reward packet with empty item
     const size_t resplen = sizeof(sP_FE2CL_REP_REWARD_ITEM) + sizeof(sItemReward);
-    assert(resplen < CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
 
     // we know it's only one trailing struct, so we can skip full validation
     uint8_t respbuf[resplen]; // not a variable length array, don't worry
@@ -475,8 +475,8 @@ static void itemUseHandler(CNSocket* sock, CNPacketData* data) {
     if (gumball.iOpt == 0)
         gumball = {};
 
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_REP_PC_ITEM_USE_SUCC *resp = (sP_FE2CL_REP_PC_ITEM_USE_SUCC*)respbuf;
     sSkillResult_Buff *respdata = (sSkillResult_Buff*)(respbuf+sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC));
@@ -556,7 +556,7 @@ static void chestOpenHandler(CNSocket *sock, CNPacketData *data) {
 
     // item giving packet
     const size_t resplen = sizeof(sP_FE2CL_REP_REWARD_ITEM) + sizeof(sItemReward);
-    assert(resplen < CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
     // we know it's only one trailing struct, so we can skip full validation
 
     uint8_t respbuf[resplen]; // not a variable length array, don't worry
@@ -645,7 +645,7 @@ void Items::checkItemExpire(CNSocket* sock, Player* player) {
     */
 
     const size_t resplen = sizeof(sP_FE2CL_PC_DELETE_TIME_LIMIT_ITEM) + sizeof(sTimeLimitItemDeleteInfo2CL);
-    assert(resplen < CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
     // we know it's only one trailing struct, so we can skip full validation
     uint8_t respbuf[resplen]; // not a variable length array, don't worry
     auto packet = (sP_FE2CL_PC_DELETE_TIME_LIMIT_ITEM*)respbuf;
@@ -715,7 +715,7 @@ static void giveSingleDrop(CNSocket *sock, Mob* mob, int mobDropId, const DropRo
     Player *plr = PlayerManager::getPlayer(sock);
 
     const size_t resplen = sizeof(sP_FE2CL_REP_REWARD_ITEM) + sizeof(sItemReward);
-    assert(resplen < CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
     // we know it's only one trailing struct, so we can skip full validation
 
     uint8_t respbuf[resplen]; // not a variable length array, don't worry

src/Missions.cpp

@@ -64,7 +64,7 @@ static bool isQuestItemFull(CNSocket* sock, int itemId, int itemCount) {
 static void dropQuestItem(CNSocket *sock, int task, int count, int id, int mobid) {
     std::cout << "Altered item id " << id << " by " << count << " for task id " << task << std::endl;
     const size_t resplen = sizeof(sP_FE2CL_REP_REWARD_ITEM) + sizeof(sItemReward);
-    assert(resplen < CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE);
     // we know it's only one trailing struct, so we can skip full validation
 
     Player *plr = PlayerManager::getPlayer(sock);
@@ -152,14 +152,14 @@ static int giveMissionReward(CNSocket *sock, int task, int choice=0) {
         plr->Inven[slots[i]] = { 999, 999, 999, 0 }; // temp item; overwritten later
     }
 
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
     size_t resplen = sizeof(sP_FE2CL_REP_REWARD_ITEM) + nrewards * sizeof(sItemReward);
-    assert(resplen < CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE);
     sP_FE2CL_REP_REWARD_ITEM *resp = (sP_FE2CL_REP_REWARD_ITEM *)respbuf;
     sItemReward *item = (sItemReward *)(respbuf + sizeof(sP_FE2CL_REP_REWARD_ITEM));
 
     // don't forget to zero the buffer!
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     // update player
     plr->money += reward->money;

src/MobAI.cpp

@@ -238,8 +238,8 @@ static void dealCorruption(Mob *mob, std::vector<int> targetData, int skillID, i
         return;
     }
 
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_NPC_SKILL_CORRUPTION_HIT *resp = (sP_FE2CL_NPC_SKILL_CORRUPTION_HIT*)respbuf;
     sCAttackResult *respdata = (sCAttackResult*)(respbuf+sizeof(sP_FE2CL_NPC_SKILL_CORRUPTION_HIT));
@@ -478,14 +478,6 @@ void MobAI::deadStep(CombatNPC* npc, time_t currTime) {
     if (self->groupLeader == self->id)
         roamingStep(self, currTime);
 
-    /*
-     * If the mob hasn't fully despanwed yet, don't try to respawn it. This protects
-     * against the edge case where mobs with a very short regenTime would try to respawn
-     * before they've faded away; and would respawn even if they were meant to be removed.
-     */
-    if (!self->despawned)
-        return;
-
     if (self->killedTime != 0 && currTime - self->killedTime < self->regenTime * 100)
         return;
 

src/PlayerManager.cpp

@@ -396,14 +396,6 @@ static void heartbeatPlayer(CNSocket* sock, CNPacketData* data) {
 
 static void exitGame(CNSocket* sock, CNPacketData* data) {
     auto exitData = (sP_CL2FE_REQ_PC_EXIT*)data->buf;
-
-    // Refresh any auth cookie, in case "change character" was used
-    Player* plr = getPlayer(sock);
-    if (plr != nullptr) {
-        // 5 seconds should be enough to log in again
-        Database::refreshCookie(plr->accountId, 5);
-    }
-
     INITSTRUCT(sP_FE2CL_REP_PC_EXIT_SUCC, response);
 
     response.iID = exitData->iID;

src/Transport.cpp

@@ -388,21 +388,8 @@ NPCPath* Transport::findApplicablePath(int32_t id, int32_t type, int taskID) {
 
 void Transport::constructPathNPC(int32_t id, NPCPath* path) {
     BaseNPC* npc = NPCManager::NPCs[id];
-
-    if (npc->kind == EntityKind::MOB) {
-        auto mob = (Mob*)npc;
-        mob->staticPath = true;
-
-        Vec3 firstPoint = path->points.front();
-
-        // Ensure that the first point coincides with the mob's spawn point.
-        if (mob->spawnX != firstPoint.x || mob->spawnY != firstPoint.y) {
-            std::cout << "[FATAL] The first point of the route for mob " << mob->id << " (type " << mob->type
-                << ") does not correspond with its spawn point." << std::endl;
-            exit(1);
-        }
-    }
-
+    if (npc->kind == EntityKind::MOB)
+        ((Mob*)(npc))->staticPath = true;
     npc->loopingPath = path->isLoop;
 
     // Interpolate

src/core/CNProtocol.cpp

@@ -428,7 +428,7 @@ void CNServer::removePollFD(int fd) {
 }
 
 void CNServer::start() {
-    std::cout << "Starting " << serverType << " server at *:" << port << std::endl;
+    std::cout << "Starting server at *:" << port << std::endl;
     while (active) {
         // the timeout is to ensure shard timers are ticking
         int n = poll(fds.data(), fds.size(), 50);

src/core/CNProtocol.hpp

@@ -95,14 +95,14 @@ inline constexpr bool isOutboundPacketID(uint32_t id) {
 // for outbound packets
 inline constexpr bool validOutVarPacket(size_t base, size_t npayloads, size_t plsize) {
     // check for multiplication overflow
-    if (npayloads > 0 && (CN_PACKET_BODY_SIZE) / (size_t)npayloads < plsize)
+    if (npayloads > 0 && (CN_PACKET_BUFFER_SIZE - 8) / (size_t)npayloads < plsize)
         return false;
 
     // it's safe to multiply
     size_t trailing = npayloads * plsize;
 
     // does it fit in a packet?
-    if (base + trailing > CN_PACKET_BODY_SIZE)
+    if (base + trailing > CN_PACKET_BUFFER_SIZE - 8)
         return false;
 
     // everything is a-ok!
@@ -112,14 +112,14 @@ inline constexpr bool validOutVarPacket(size_t base, size_t npayloads, size_t pl
 // for inbound packets
 inline constexpr bool validInVarPacket(size_t base, size_t npayloads, size_t plsize, size_t datasize) {
     // check for multiplication overflow
-    if (npayloads > 0 && CN_PACKET_BODY_SIZE / (size_t)npayloads < plsize)
+    if (npayloads > 0 && (CN_PACKET_BUFFER_SIZE - 8) / (size_t)npayloads < plsize)
         return false;
 
     // it's safe to multiply
     size_t trailing = npayloads * plsize;
 
     // make sure size is exact
-    // datasize has already been validated against CN_PACKET_BODY_SIZE
+    // datasize has already been validated against CN_PACKET_BUFFER_SIZE
     if (datasize != base + trailing)
         return false;
 

src/core/CNStructs.hpp

@@ -29,8 +29,8 @@
 #define INITSTRUCT(T, x) T x; \
     memset(&x, 0, sizeof(T));
 
-#define INITVARPACKET(_buf, _Pkt, _pkt, _Trailer, _trailer) uint8_t _buf[CN_PACKET_BODY_SIZE]; \
-    memset(&_buf, 0, CN_PACKET_BODY_SIZE); \
+#define INITVARPACKET(_buf, _Pkt, _pkt, _Trailer, _trailer) uint8_t _buf[CN_PACKET_BUFFER_SIZE]; \
+    memset(&_buf, 0, CN_PACKET_BUFFER_SIZE); \
     auto _pkt = (_Pkt*)_buf; \
     auto _trailer = (_Trailer*)(_pkt + 1);
 
@@ -49,7 +49,6 @@ std::string U16toU8(char16_t* src, size_t max);
 size_t U8toU16(std::string src, char16_t* des, size_t max); // returns number of char16_t that was written at des
 time_t getTime();
 time_t getTimestamp();
-int timingSafeStrcmp(const char* a, const char* b);
 void terminate(int);
 
 // The PROTOCOL_VERSION definition can be defined by the build system.

src/core/Defines.hpp

@@ -1,8 +1,6 @@
 /* enum definitions from the client */
 #pragma once
 
-#include "core/CNStructs.hpp"
-
 // floats
 const float VALUE_BATTERY_EMPTY_PENALTY = 0.5f;
 const float CN_EP_RANK_1 = 0.8f;
@@ -412,13 +410,7 @@ enum {
     SEND_ANYCAST_NEW = 3,
     SEND_BROADCAST = 4,
 
-#if PROTOCOL_VERSION == 728
-    CN_PACKET_BUFFER_SIZE = 8192,
-#elif PROTOCOL_VERSION == 1013
-    CN_PACKET_BUFFER_SIZE = 8192,
-#else
     CN_PACKET_BUFFER_SIZE = 4096,
-#endif
 
     P_CL2LS_REQ_LOGIN = 0x12000001,		// 301989889
     P_CL2LS_REQ_CHECK_CHAR_NAME = 0x12000002,		// 301989890
@@ -942,8 +934,3 @@ enum {
 
     N_PACKETS = N_CL2LS + N_CL2FE + N_FE2CL + N_LS2CL
 };
-
-/*
- * Usable space in the packet buffer = CN_PACKET_BUFFER_SIZE - type - size
- */
-constexpr size_t CN_PACKET_BODY_SIZE = CN_PACKET_BUFFER_SIZE - 2 * sizeof(int32_t);

src/core/Packets.cpp

@@ -235,7 +235,7 @@ std::map<uint32_t, PacketDesc> Packets::packets = {
     PACKET(P_FE2CL_REP_PC_EXIT_FAIL),
     PACKET(P_FE2CL_REP_PC_EXIT_SUCC),
     PACKET(P_FE2CL_PC_EXIT),
-    VAR_PACKET(P_FE2CL_PC_AROUND, iPCCnt, sPCAppearanceData),
+    PACKET(P_FE2CL_PC_AROUND),
     PACKET(P_FE2CL_PC_MOVE),
     PACKET(P_FE2CL_PC_STOP),
     PACKET(P_FE2CL_PC_JUMP),
@@ -243,9 +243,9 @@ std::map<uint32_t, PacketDesc> Packets::packets = {
     PACKET(P_FE2CL_NPC_EXIT),
     PACKET(P_FE2CL_NPC_MOVE),
     PACKET(P_FE2CL_NPC_NEW),
-    VAR_PACKET(P_FE2CL_NPC_AROUND, iNPCCnt, sNPCAppearanceData),
-    VAR_PACKET(P_FE2CL_AROUND_DEL_PC, iPCCnt, int32_t),
-    VAR_PACKET(P_FE2CL_AROUND_DEL_NPC, iNPCCnt, int32_t),
+    PACKET(P_FE2CL_NPC_AROUND),
+    PACKET(P_FE2CL_AROUND_DEL_PC),
+    PACKET(P_FE2CL_AROUND_DEL_NPC),
     PACKET(P_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC),
     PACKET(P_FE2CL_REP_SEND_FREECHAT_MESSAGE_FAIL),
     VAR_PACKET(P_FE2CL_PC_ATTACK_NPCs_SUCC, iNPCCnt, sAttackResult),
@@ -387,8 +387,8 @@ std::map<uint32_t, PacketDesc> Packets::packets = {
     PACKET(P_FE2CL_TRANSPORTATION_EXIT),
     PACKET(P_FE2CL_TRANSPORTATION_MOVE),
     PACKET(P_FE2CL_TRANSPORTATION_NEW),
-    VAR_PACKET(P_FE2CL_TRANSPORTATION_AROUND, iCnt, sTransportationAppearanceData),
-    VAR_PACKET(P_FE2CL_AROUND_DEL_TRANSPORTATION, iCnt, int32_t),
+    PACKET(P_FE2CL_TRANSPORTATION_AROUND),
+    PACKET(P_FE2CL_AROUND_DEL_TRANSPORTATION),
     PACKET(P_FE2CL_REP_EP_RANK_LIST),
     PACKET(P_FE2CL_REP_EP_RANK_DETAIL),
     PACKET(P_FE2CL_REP_EP_RANK_PC_INFO),
@@ -404,8 +404,8 @@ std::map<uint32_t, PacketDesc> Packets::packets = {
     PACKET(P_FE2CL_SHINY_ENTER),
     PACKET(P_FE2CL_SHINY_EXIT),
     PACKET(P_FE2CL_SHINY_NEW),
-    VAR_PACKET(P_FE2CL_SHINY_AROUND, iShinyCnt, sShinyAppearanceData),
-    VAR_PACKET(P_FE2CL_AROUND_DEL_SHINY, iShinyCnt, int32_t),
+    PACKET(P_FE2CL_SHINY_AROUND),
+    PACKET(P_FE2CL_AROUND_DEL_SHINY),
     PACKET(P_FE2CL_REP_SHINY_PICKUP_FAIL),
     PACKET(P_FE2CL_REP_SHINY_PICKUP_SUCC),
     PACKET(P_FE2CL_PC_MOVETRANSPORTATION),

src/db/Database.hpp

@@ -5,7 +5,7 @@
 #include <string>
 #include <vector>
 
-#define DATABASE_VERSION 6
+#define DATABASE_VERSION 5
 
 namespace Database {
 
@@ -56,7 +56,6 @@ namespace Database {
     // return true if cookie is valid for the account.
     // invalidates the stored cookie afterwards
     bool checkCookie(int accountId, const char *cookie);
-    void refreshCookie(int accountId, int durationSec);
 
     // interface for the /ban command
     bool banPlayer(int playerId, std::string& reason);

src/db/login.cpp

@@ -1,5 +1,3 @@
-#include "core/CNStructs.hpp"
-
 #include "db/internal.hpp"
 
 #include "bcrypt/BCrypt.hpp"
@@ -132,46 +130,23 @@ bool Database::checkCookie(int accountId, const char *tryCookie) {
         return false;
     }
 
-    bool match = (timingSafeStrcmp(cookie, tryCookie) == 0);
+    /*
+     * since cookies are immediately invalidated, we don't need to be concerned about
+     * timing-related side channel attacks, so strcmp is fine here
+     */
+    bool match = (strcmp(cookie, tryCookie) == 0);
     sqlite3_finalize(stmt);
 
-    /*
-     * Only invalidate the cookie if it was correct. This prevents
-     * replay attacks without enabling DOS attacks on accounts.
-     */
-    if (match) {
     sqlite3_prepare_v2(db, sql_invalidate, -1, &stmt, NULL);
     sqlite3_bind_int(stmt, 1, accountId);
     rc = sqlite3_step(stmt);
     sqlite3_finalize(stmt);
     if (rc != SQLITE_DONE)
         std::cout << "[WARN] Database fail on checkCookie(): " << sqlite3_errmsg(db) << std::endl;
-    }
 
     return match;
 }
 
-void Database::refreshCookie(int accountId, int durationSec) {
-    std::lock_guard<std::mutex> lock(dbCrit);
-
-    const char* sql = R"(
-        UPDATE Auth
-        SET Expires = ?
-        WHERE AccountID = ?;
-        )";
-    
-    int expires = getTimestamp() + durationSec;
-
-    sqlite3_stmt* stmt;
-    sqlite3_prepare_v2(db, sql, -1, &stmt, NULL);
-    sqlite3_bind_int(stmt, 1, expires);
-    sqlite3_bind_int(stmt, 2, accountId);
-    int rc = sqlite3_step(stmt);
-    sqlite3_finalize(stmt);
-    if (rc != SQLITE_DONE)
-        std::cout << "[WARN] Database fail on refreshCookie(): " << sqlite3_errmsg(db) << std::endl;
-}
-
 void Database::updateSelected(int accountId, int slot) {
     std::lock_guard<std::mutex> lock(dbCrit);
 

src/main.cpp

@@ -222,17 +222,6 @@ time_t getTimestamp() {
     return (time_t)value.count();
 }
 
-// timing safe strcmp implementation for e.g. cookie validation
-int timingSafeStrcmp(const char* a, const char* b) {
-    int diff = 0;
-    while (*a && *b) {
-        diff |= *a++ ^ *b++;
-    }
-    diff |= *a;
-    diff |= *b;
-    return diff;
-}
-
 // convert integer timestamp (in s) to FF systime struct
 sSYSTEMTIME timeStampToStruct(uint64_t time) {
 

src/sandbox/seccomp.cpp

@@ -391,7 +391,7 @@ static bool landlock_detect() {
         exit(1);
     }
 
-    std::cout << "[INFO] Detected Landlock ABI version: " << abi << std::endl;
+    std::cout << "[INFO] Landlock ABI version: " << abi << std::endl;
 
     switch (abi) {
     case 1:

src/servers/CNLoginServer.cpp

@@ -109,17 +109,11 @@ void CNLoginServer::login(CNSocket* sock, CNPacketData* data) {
     std::string userLogin;
     std::string userToken; // could be password or auth cookie
 
-    /*
-     * In this context, "cookie auth" just means the credentials were sent
-     * in the szCookie fields instead of szID and szPassword.
-     */
-    bool isCookieAuth = login->iLoginType == USE_COOKIE_FIELDS;
-
     /*
      * The std::string -> char* -> std::string maneuver should remove any
      * trailing garbage after the null terminator.
      */
-    if (isCookieAuth) {
+    if (login->iLoginType == (int32_t)LoginType::COOKIE) {
         userLogin = std::string(AUTOU8(login->szCookie_TEGid).c_str());
         userToken = std::string(AUTOU8(login->szCookie_authid).c_str());
     } else {
@@ -127,13 +121,54 @@ void CNLoginServer::login(CNSocket* sock, CNPacketData* data) {
         userToken = std::string(AUTOU16TOU8(login->szPassword).c_str());
     }
 
-    if (!CNLoginServer::checkUsername(sock, userLogin)) {
+    // check username regex
+    if (!CNLoginServer::isUsernameGood(userLogin)) {
+        // send a custom error message
+        INITSTRUCT(sP_FE2CL_GM_REP_PC_ANNOUNCE, msg);
+        std::string text = "Invalid login\n";
+        text += "Login has to be 4 - 32 characters long and can't contain special characters other than dash and underscore";
+        U8toU16(text, msg.szAnnounceMsg, sizeof(msg.szAnnounceMsg));
+        msg.iDuringTime = 10;
+        sock->sendPacket(msg, P_FE2CL_GM_REP_PC_ANNOUNCE);
+
+        // we still have to send login fail to prevent softlock
         return loginFail(LoginError::LOGIN_ERROR, userLogin, sock);
     }
 
+    // we only interpret the token as a cookie if cookie login was used and it's allowed.
+    // otherwise we interpret it as a password, and this maintains compatibility with
+    // the auto-login trick used on older clients
+    bool isCookieAuth = login->iLoginType == (int32_t)LoginType::COOKIE
+                        && CNLoginServer::isLoginTypeAllowed(LoginType::COOKIE);
+
+    // password login checks
     if (!isCookieAuth) {
-        // password was sent in plaintext
-        if (!CNLoginServer::checkPassword(sock, userToken)) {
+        // bail if password auth isn't allowed
+        if (!CNLoginServer::isLoginTypeAllowed(LoginType::PASSWORD)) {
+            // send a custom error message
+            INITSTRUCT(sP_FE2CL_GM_REP_PC_ANNOUNCE, msg);
+            std::string text = "Password login disabled\n";
+            text += "This server has disabled logging in with plaintext passwords.\n";
+            text += "Please contact an admin for assistance.";
+            U8toU16(text, msg.szAnnounceMsg, sizeof(msg.szAnnounceMsg));
+            msg.iDuringTime = 12;
+            sock->sendPacket(msg, P_FE2CL_GM_REP_PC_ANNOUNCE);
+
+            // we still have to send login fail to prevent softlock
+            return loginFail(LoginError::LOGIN_ERROR, userLogin, sock);
+        }
+
+        // check regex
+        if (!CNLoginServer::isPasswordGood(userToken)) {
+            // send a custom error message
+            INITSTRUCT(sP_FE2CL_GM_REP_PC_ANNOUNCE, msg);
+            std::string text = "Invalid password\n";
+            text += "Password has to be 8 - 32 characters long";
+            U8toU16(text, msg.szAnnounceMsg, sizeof(msg.szAnnounceMsg));
+            msg.iDuringTime = 10;
+            sock->sendPacket(msg, P_FE2CL_GM_REP_PC_ANNOUNCE);
+
+            // we still have to send login fail to prevent softlock
             return loginFail(LoginError::LOGIN_ERROR, userLogin, sock);
         }
     }
@@ -143,25 +178,42 @@ void CNLoginServer::login(CNSocket* sock, CNPacketData* data) {
     
     // account was not found
     if (findUser.AccountID == 0) {
-        /*
-         * Don't auto-create accounts if it's a cookie login.
-         * It'll either be a bad cookie or a plaintext password sent by auto-login;
-         * either way, we only want to allow auto-creation if the user explicitly entered their credentials.
-         */
-        if (settings::AUTOCREATEACCOUNTS && !isCookieAuth) {
+        // don't auto-create an account if it's a cookie auth for whatever reason
+        if (settings::AUTOCREATEACCOUNTS && !isCookieAuth)
             return newAccount(sock, userLogin, userToken, login->iClientVerC);
-        }
 
         return loginFail(LoginError::ID_DOESNT_EXIST, userLogin, sock);
     }
 
-    // make sure either a valid cookie or password was sent
-    if (!CNLoginServer::checkToken(sock, findUser, userToken, isCookieAuth)) {
+    if (isCookieAuth) {
+        const char *cookie = userToken.c_str();
+        if (!Database::checkCookie(findUser.AccountID, cookie))
+            return loginFail(LoginError::ID_AND_PASSWORD_DO_NOT_MATCH, userLogin, sock);
+    } else {
+        // simple password check
+        if (!CNLoginServer::isPasswordCorrect(findUser.Password, userToken))
             return loginFail(LoginError::ID_AND_PASSWORD_DO_NOT_MATCH, userLogin, sock);
     }
 
-    if (CNLoginServer::checkBan(sock, findUser)) {
-        return; // don't send fail packet
+    // is the account banned
+    if (findUser.BannedUntil > getTimestamp()) {
+        // send a custom error message
+        INITSTRUCT(sP_FE2CL_GM_REP_PC_ANNOUNCE, msg);
+
+        // ceiling devision
+        int64_t remainingDays = (findUser.BannedUntil-getTimestamp()) / 86400 + ((findUser.BannedUntil - getTimestamp()) % 86400 != 0);
+
+        std::string text = "Your account has been banned. \nReason: ";
+        text += findUser.BanReason;
+        text += "\nBan expires in " + std::to_string(remainingDays) + " day";
+        if (remainingDays > 1)
+            text += "s";
+
+        U8toU16(text, msg.szAnnounceMsg, sizeof(msg.szAnnounceMsg));
+        msg.iDuringTime = 99999999;
+        sock->sendPacket(msg, P_FE2CL_GM_REP_PC_ANNOUNCE);
+        // don't send fail packet
+        return;
     }
 
     /* 
@@ -607,12 +659,12 @@ bool CNLoginServer::exitDuplicate(int accountId) {
     return false;
 }
 
-bool CNLoginServer::isUsernameGood(std::string& login) {
+bool CNLoginServer::isUsernameGood(std::string login) {
     const std::regex loginRegex("[a-zA-Z0-9_-]{4,32}");
     return (std::regex_match(login, loginRegex));
 }
 
-bool CNLoginServer::isPasswordGood(std::string& password) {
+bool CNLoginServer::isPasswordGood(std::string password) {
     const std::regex passwordRegex("[a-zA-Z0-9!@#$%^&*()_+]{8,32}");
     return (std::regex_match(password, passwordRegex));
 }
@@ -628,107 +680,16 @@ bool CNLoginServer::isCharacterNameGood(std::string Firstname, std::string Lastn
     return (std::regex_match(Firstname, firstnamecheck) && std::regex_match(Lastname, lastnamecheck));
 }
 
-bool CNLoginServer::isAuthMethodAllowed(AuthMethod authMethod) {
+bool CNLoginServer::isLoginTypeAllowed(LoginType loginType) {
     // the config file specifies "comma-separated" but tbh we don't care
-    switch (authMethod) {
-    case AuthMethod::PASSWORD:
+    switch (loginType) {
+    case LoginType::PASSWORD:
         return settings::AUTHMETHODS.find("password") != std::string::npos;
-    case AuthMethod::COOKIE:
+    case LoginType::COOKIE:
         return settings::AUTHMETHODS.find("cookie") != std::string::npos;
     default:
         break;
     }
     return false;
 }
-
-bool CNLoginServer::checkPassword(CNSocket* sock, std::string& password) {
-    // check password auth allowed
-    if (!CNLoginServer::isAuthMethodAllowed(AuthMethod::PASSWORD)) {
-        // send a custom error message
-        INITSTRUCT(sP_FE2CL_GM_REP_PC_ANNOUNCE, msg);
-        std::string text = "Password login disabled\n";
-        text += "This server has disabled logging in with plaintext passwords.\n";
-        text += "Please contact an admin for assistance.";
-        U8toU16(text, msg.szAnnounceMsg, sizeof(msg.szAnnounceMsg));
-        msg.iDuringTime = 12;
-        sock->sendPacket(msg, P_FE2CL_GM_REP_PC_ANNOUNCE);
-
-        return false;
-    }
-
-    // check regex
-    if (!CNLoginServer::isPasswordGood(password)) {
-        // send a custom error message
-        INITSTRUCT(sP_FE2CL_GM_REP_PC_ANNOUNCE, msg);
-        std::string text = "Invalid password\n";
-        text += "Password has to be 8 - 32 characters long";
-        U8toU16(text, msg.szAnnounceMsg, sizeof(msg.szAnnounceMsg));
-        msg.iDuringTime = 10;
-        sock->sendPacket(msg, P_FE2CL_GM_REP_PC_ANNOUNCE);
-
-        return false;
-    }
-
-    return true;
-}
-
-bool CNLoginServer::checkUsername(CNSocket* sock, std::string& username) {
-    // check username regex
-    if (!CNLoginServer::isUsernameGood(username)) {
-        // send a custom error message
-        INITSTRUCT(sP_FE2CL_GM_REP_PC_ANNOUNCE, msg);
-        std::string text = "Invalid login\n";
-        text += "Login has to be 4 - 32 characters long and can't contain special characters other than dash and underscore";
-        U8toU16(text, msg.szAnnounceMsg, sizeof(msg.szAnnounceMsg));
-        msg.iDuringTime = 10;
-        sock->sendPacket(msg, P_FE2CL_GM_REP_PC_ANNOUNCE);
-
-        return false;
-    }
-
-    return true;
-}
-
-bool CNLoginServer::checkToken(CNSocket* sock, Database::Account& account, std::string& token, bool isCookieAuth) {
-    // check for valid cookie first
-    if (isCookieAuth && CNLoginServer::isAuthMethodAllowed(AuthMethod::COOKIE)) {
-        const char *cookie = token.c_str();
-        if (Database::checkCookie(account.AccountID, cookie)) {
-            return true;
-        }
-    }
-
-    // cookie check disabled or failed; check to see if it's a plaintext password
-    if (CNLoginServer::isAuthMethodAllowed(AuthMethod::PASSWORD)
-        && CNLoginServer::isPasswordCorrect(account.Password, token)) {
-        return true;
-    }
-
-    return false;
-}
-
-bool CNLoginServer::checkBan(CNSocket* sock, Database::Account& account) {
-    // check if the account is banned
-    if (account.BannedUntil > getTimestamp()) {
-        // send a custom error message
-        INITSTRUCT(sP_FE2CL_GM_REP_PC_ANNOUNCE, msg);
-
-        // ceiling devision
-        int64_t remainingDays = (account.BannedUntil-getTimestamp()) / 86400 + ((account.BannedUntil - getTimestamp()) % 86400 != 0);
-
-        std::string text = "Your account has been banned. \nReason: ";
-        text += account.BanReason;
-        text += "\nBan expires in " + std::to_string(remainingDays) + " day";
-        if (remainingDays > 1)
-            text += "s";
-
-        U8toU16(text, msg.szAnnounceMsg, sizeof(msg.szAnnounceMsg));
-        msg.iDuringTime = 99999999;
-        sock->sendPacket(msg, P_FE2CL_GM_REP_PC_ANNOUNCE);
-
-        return true;
-    }
-
-    return false;
-}
 #pragma endregion

src/servers/CNLoginServer.hpp

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "core/Core.hpp"
-#include "db/Database.hpp"
 
 #include "Player.hpp"
 
@@ -24,9 +23,7 @@ enum class LoginError {
     UPDATED_EUALA_REQUIRED = 9
 };
 
-#define USE_COOKIE_FIELDS 2
-
-enum class AuthMethod {
+enum class LoginType {
     PASSWORD = 1,
     COOKIE = 2
 };
@@ -47,17 +44,12 @@ private:
     static void changeName(CNSocket* sock, CNPacketData* data);
     static void duplicateExit(CNSocket* sock, CNPacketData* data);
 
-    static bool isUsernameGood(std::string& login);
-    static bool isPasswordGood(std::string& password);
+    static bool isUsernameGood(std::string login);
+    static bool isPasswordGood(std::string password);
     static bool isPasswordCorrect(std::string actualPassword, std::string tryPassword);
     static bool isAccountInUse(int accountId);
     static bool isCharacterNameGood(std::string Firstname, std::string Lastname);
-    static bool isAuthMethodAllowed(AuthMethod authMethod);
-    static bool checkUsername(CNSocket* sock, std::string& username);
-    static bool checkPassword(CNSocket* sock, std::string& password);
-    static bool checkToken(CNSocket* sock, Database::Account& account, std::string& token, bool isCookieAuth);
-    static bool checkBan(CNSocket* sock, Database::Account& account);
-
+    static bool isLoginTypeAllowed(LoginType loginType);
     static void newAccount(CNSocket* sock, std::string userLogin, std::string userPassword, int32_t clientVerC);
     // returns true if success
     static bool exitDuplicate(int accountId);

src/servers/Monitor.cpp

@@ -180,14 +180,9 @@ SOCKET Monitor::init() {
     }
 
     address.sin_family = AF_INET;
+    address.sin_addr.s_addr = INADDR_ANY;
     address.sin_port = htons(settings::MONITORPORT);
 
-    if (!inet_pton(AF_INET, settings::MONITORLISTENIP.c_str(), &address.sin_addr)) {
-        std::cout << "Failed to set monitor listen address" << std::endl;
-        printSocketError("inet_pton");
-        exit(1);
-    }
-
     if (SOCKETERROR(bind(listener, (struct sockaddr*)&address, sizeof(address)))) {
         std::cout << "Failed to bind to monitor port" << std::endl;
         printSocketError("bind");
@@ -211,7 +206,7 @@ SOCKET Monitor::init() {
         exit(EXIT_FAILURE);
     }
 
-    std::cout << "Monitor listening on " << settings::MONITORLISTENIP << ":" << settings::MONITORPORT << std::endl;
+    std::cout << "Monitor listening on *:" << settings::MONITORPORT << std::endl;
 
     REGISTER_SHARD_TIMER(tick, settings::MONITORINTERVAL);
 

src/settings.cpp

@@ -64,7 +64,6 @@ bool settings::DISABLEFIRSTUSEFLAG = true;
 // monitor settings
 bool settings::MONITORENABLED = false;
 int settings::MONITORPORT = 8003;
-std::string settings::MONITORLISTENIP = "127.0.0.1";
 int settings::MONITORINTERVAL = 5000;
 
 // event mode settings
@@ -122,6 +121,5 @@ void settings::init() {
     IZRACESCORECAPPED = reader.GetBoolean("shard", "izracescorecapped", IZRACESCORECAPPED);
     MONITORENABLED = reader.GetBoolean("monitor", "enabled", MONITORENABLED);
     MONITORPORT = reader.GetInteger("monitor", "port", MONITORPORT);
-    MONITORLISTENIP = reader.Get("monitor", "listenip", MONITORLISTENIP);
     MONITORINTERVAL = reader.GetInteger("monitor", "interval", MONITORINTERVAL);
 }

src/settings.hpp

@@ -1,8 +1,6 @@
 #pragma once
 
-#include <stdint.h>
 #include <string>
-#include <time.h>
 
 namespace settings {
     extern int VERBOSITY;
@@ -40,7 +38,6 @@ namespace settings {
     extern int EVENTMODE;
     extern bool MONITORENABLED;
     extern int MONITORPORT;
-    extern std::string MONITORLISTENIP;
     extern int MONITORINTERVAL;
     extern bool DISABLEFIRSTUSEFLAG;
     extern bool IZRACESCORECAPPED;