1 files changed, 150 insertions, 139 deletions

diff --git a/src/mevent_server_helpers.c b/src/mevent_server_helpers.c
index 17686e287..83ecc9f50 100644
--- a/src/mevent_server_helpers.c
+++ b/src/mevent_server_helpers.c
@@ -11,200 +11,211 @@
 #include "mevent.h"
 #include "mevent_server_helpers.h"
 
-static u32 mevent_receive_func(struct MysteryGiftLink *);
-static u32 mevent_send_func(struct MysteryGiftLink *);
+/*
+    Handles the link connection functions used by the Mystery Gift client/server.
+    Note: MysteryGiftLink is shortened to MGL for internal functions.
+*/
 
-u32 MysteryGiftLink_Recv(struct MysteryGiftLink * svr)
+struct SendRecvHeader
 {
-    return svr->recvFunc(svr);
+    u16 ident;
+    u16 crc;
+    u16 size;
+};
+
+static u32 MGL_Receive(struct MysteryGiftLink *);
+static u32 MGL_Send(struct MysteryGiftLink *);
+
+u32 MysteryGiftLink_Recv(struct MysteryGiftLink * link)
+{
+    return link->recvFunc(link);
 }
 
-u32 MysteryGiftLink_Send(struct MysteryGiftLink * svr)
+u32 MysteryGiftLink_Send(struct MysteryGiftLink * link)
 {
-    return svr->sendFunc(svr);
+    return link->sendFunc(link);
 }
 
-void MysteryGiftLink_Init(struct MysteryGiftLink * svr, u32 sendPlayerNo, u32 recvPlayerNo)
+void MysteryGiftLink_Init(struct MysteryGiftLink * link, u32 sendPlayerId, u32 recvPlayerId)
 {
-    svr->sendPlayerNo = sendPlayerNo;
-    svr->recvPlayerNo = recvPlayerNo;
-    svr->seqno = 0;
-    svr->sendCRC = 0;
-    svr->sendSize = 0;
-    svr->sendCounter = 0;
-    svr->recvCRC = 0;
-    svr->recvSize = 0;
-    svr->recvCounter = 0;
-    svr->sendBfr = NULL;
-    svr->recvBfr = NULL;
-    svr->sendFunc = mevent_send_func;
-    svr->recvFunc = mevent_receive_func;
+    link->sendPlayerId = sendPlayerId;
+    link->recvPlayerId = recvPlayerId;
+    link->state = 0;
+    link->sendCRC = 0;
+    link->sendSize = 0;
+    link->sendCounter = 0;
+    link->recvCRC = 0;
+    link->recvSize = 0;
+    link->recvCounter = 0;
+    link->sendBfr = NULL;
+    link->recvBfr = NULL;
+    link->sendFunc = MGL_Send;
+    link->recvFunc = MGL_Receive;
 }
 
-void MysteryGiftLink_InitSend(struct MysteryGiftLink * svr, u32 ident, const void * src, u32 size)
+void MysteryGiftLink_InitSend(struct MysteryGiftLink * link, u32 ident, const void * src, u32 size)
 {
-    svr->seqno = 0;
-    svr->sendIdent = ident;
-    svr->sendCounter = 0;
-    svr->sendCRC = 0;
+    link->state = 0;
+    link->sendIdent = ident;
+    link->sendCounter = 0;
+    link->sendCRC = 0;
     if (size != 0)
-        svr->sendSize = size;
+        link->sendSize = size;
     else
-        svr->sendSize = ME_SEND_BUF_SIZE;
-    svr->sendBfr = src;
+        link->sendSize = MG_LINK_BUFFER_SIZE;
+    link->sendBfr = src;
 }
 
-void MysteryGiftLink_InitRecv(struct MysteryGiftLink * svr, u32 ident, void * dest)
+void MysteryGiftLink_InitRecv(struct MysteryGiftLink * link, u32 ident, void * dest)
 {
-    svr->seqno = 0;
-    svr->recvIdent = ident;
-    svr->recvCounter = 0;
-    svr->recvCRC = 0;
-    svr->recvSize = 0;
-    svr->recvBfr = dest;
+    link->state = 0;
+    link->recvIdent = ident;
+    link->recvCounter = 0;
+    link->recvCRC = 0;
+    link->recvSize = 0;
+    link->recvBfr = dest;
 }
 
-static void mevent_recv_block(u32 recv_idx, void * dest, size_t size)
+static void MGL_ReceiveBlock(u32 playerId, void * dest, size_t size)
 {
-    memcpy(dest, gBlockRecvBuffer[recv_idx], size);
+    memcpy(dest, gBlockRecvBuffer[playerId], size);
 }
 
-static bool32 mevent_has_received(u32 recv_idx)
+static bool32 MGL_HasReceived(u32 playerId)
 {
-    if ((GetBlockReceivedStatus() >> recv_idx) & 1)
+    if ((GetBlockReceivedStatus() >> playerId) & 1)
         return TRUE;
     else
         return FALSE;
 }
 
-static void mevent_reset_recv(u32 recv_idx)
+static void MGL_ResetReceived(u32 playerId)
 {
-    ResetBlockReceivedFlag(recv_idx);
+    ResetBlockReceivedFlag(playerId);
 }
 
-static bool32 mevent_receive_func(struct MysteryGiftLink * svr)
+static bool32 MGL_Receive(struct MysteryGiftLink * link)
 {
-    struct send_recv_header header;
+    struct SendRecvHeader header;
 
-    switch (svr->seqno)
+    switch (link->state)
     {
-        case 0:
-            if (mevent_has_received(svr->recvPlayerNo))
-            {
-                mevent_recv_block(svr->recvPlayerNo, &header, sizeof(header));
-                svr->recvSize = header.size;
-                svr->recvCRC = header.crc;
-                if (svr->recvSize > ME_SEND_BUF_SIZE)
-                {
-                    LinkRfu_FatalError();
-                    return FALSE;
-                }
-                else if (svr->recvIdent != header.ident)
-                {
-                    LinkRfu_FatalError();
-                    return FALSE;
-                }
-                else
-                {
-                    svr->recvCounter = 0;
-                    mevent_reset_recv(svr->recvPlayerNo);
-                    ++svr->seqno;
-                }
-            }
-            break;
-        case 1:
-            if (mevent_has_received(svr->recvPlayerNo))
+    case 0:
+        if (MGL_HasReceived(link->recvPlayerId))
+        {
+            MGL_ReceiveBlock(link->recvPlayerId, &header, sizeof(header));
+            link->recvSize = header.size;
+            link->recvCRC = header.crc;
+            if (link->recvSize > MG_LINK_BUFFER_SIZE)
             {
-                size_t blocksiz = svr->recvCounter * 252;
-                if (svr->recvSize - blocksiz <= 252)
-                {
-                    mevent_recv_block(svr->recvPlayerNo, svr->recvBfr + blocksiz, svr->recvSize - blocksiz);
-                    ++svr->recvCounter;
-                    ++svr->seqno;
-                }
-                else
-                {
-                    mevent_recv_block(svr->recvPlayerNo, svr->recvBfr + blocksiz, 252);
-                    ++svr->recvCounter;
-                }
-                mevent_reset_recv(svr->recvPlayerNo);
+                LinkRfu_FatalError();
+                return FALSE;
             }
-            break;
-        case 2:
-            if (CalcCRC16WithTable(svr->recvBfr, svr->recvSize) != svr->recvCRC)
+            else if (link->recvIdent != header.ident)
             {
                 LinkRfu_FatalError();
                 return FALSE;
             }
             else
             {
-                svr->seqno = 0;
-                return TRUE;
+                link->recvCounter = 0;
+                MGL_ResetReceived(link->recvPlayerId);
+                link->state++;
             }
-            break;
-
+        }
+        break;
+    case 1:
+        if (MGL_HasReceived(link->recvPlayerId))
+        {
+            size_t blocksize = link->recvCounter * 252;
+            if (link->recvSize - blocksize <= 252)
+            {
+                MGL_ReceiveBlock(link->recvPlayerId, link->recvBfr + blocksize, link->recvSize - blocksize);
+                link->recvCounter++;
+                link->state++;
+            }
+            else
+            {
+                MGL_ReceiveBlock(link->recvPlayerId, link->recvBfr + blocksize, 252);
+                link->recvCounter++;
+            }
+            MGL_ResetReceived(link->recvPlayerId);
+        }
+        break;
+    case 2:
+        if (CalcCRC16WithTable(link->recvBfr, link->recvSize) != link->recvCRC)
+        {
+            LinkRfu_FatalError();
+            return FALSE;
+        }
+        else
+        {
+            link->state = 0;
+            return TRUE;
+        }
+        break;
     }
 
     return FALSE;
 }
 
-static bool32 mevent_send_func(struct MysteryGiftLink * svr)
+static bool32 MGL_Send(struct MysteryGiftLink * link)
 {
-    struct send_recv_header header;
+    struct SendRecvHeader header;
 
-    switch (svr->seqno)
+    switch (link->state)
     {
-        case 0:
-            if (IsLinkTaskFinished())
-            {
-                header.ident = svr->sendIdent;
-                header.size = svr->sendSize;
-                header.crc = CalcCRC16WithTable(svr->sendBfr, svr->sendSize);
-                svr->sendCRC = header.crc;
-                svr->sendCounter = 0;
-                SendBlock(0, &header, sizeof(header));
-                ++svr->seqno;
-            }
-            break;
-        case 1:
-            if (IsLinkTaskFinished())
+    case 0:
+        if (IsLinkTaskFinished())
+        {
+            header.ident = link->sendIdent;
+            header.size = link->sendSize;
+            header.crc = CalcCRC16WithTable(link->sendBfr, link->sendSize);
+            link->sendCRC = header.crc;
+            link->sendCounter = 0;
+            SendBlock(0, &header, sizeof(header));
+            link->state++;
+        }
+        break;
+    case 1:
+        if (IsLinkTaskFinished())
+        {
+            if (MGL_HasReceived(link->sendPlayerId))
             {
-                if (mevent_has_received(svr->sendPlayerNo))
+                size_t blocksize;
+                MGL_ResetReceived(link->sendPlayerId);
+                blocksize = 252 * link->sendCounter;
+                if (link->sendSize - blocksize <= 252)
                 {
-                    size_t blocksiz;
-                    mevent_reset_recv(svr->sendPlayerNo);
-                    blocksiz = 252 * svr->sendCounter;
-                    if (svr->sendSize - blocksiz <= 252)
-                    {
-                        SendBlock(0, svr->sendBfr + blocksiz, svr->sendSize - blocksiz);
-                        ++svr->sendCounter;
-                        ++svr->seqno;
-                    }
-                    else
-                    {
-                        SendBlock(0, svr->sendBfr + blocksiz, 252);
-                        ++svr->sendCounter;
-                    }
+                    SendBlock(0, link->sendBfr + blocksize, link->sendSize - blocksize);
+                    link->sendCounter++;
+                    link->state++;
                 }
-            }
-            break;
-        case 2:
-            if (IsLinkTaskFinished())
-            {
-                if (CalcCRC16WithTable(svr->sendBfr, svr->sendSize) != svr->sendCRC)
-                    LinkRfu_FatalError();
                 else
-                    ++svr->seqno;
-            }
-            break;
-        case 3:
-            if (mevent_has_received(svr->sendPlayerNo))
-            {
-                mevent_reset_recv(svr->sendPlayerNo);
-                svr->seqno = 0;
-                return TRUE;
+                {
+                    SendBlock(0, link->sendBfr + blocksize, 252);
+                    link->sendCounter++;
+                }
             }
-            break;
+        }
+        break;
+    case 2:
+        if (IsLinkTaskFinished())
+        {
+            if (CalcCRC16WithTable(link->sendBfr, link->sendSize) != link->sendCRC)
+                LinkRfu_FatalError();
+            else
+                link->state++;
+        }
+        break;
+    case 3:
+        if (MGL_HasReceived(link->sendPlayerId))
+        {
+            MGL_ResetReceived(link->sendPlayerId);
+            link->state = 0;
+            return TRUE;
+        }
+        break;
     }
 
     return FALSE;