ocrm.bsky.social
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
1#include "stdafx.h"
2
3#ifdef _WINDOWS64
4
5#include "WinsockNetLayer.h"
6#include "..\..\Common\Network\PlatformNetworkManagerStub.h"
7#include "..\..\..\Minecraft.World\Socket.h"
8
9SOCKET WinsockNetLayer::s_listenSocket = INVALID_SOCKET;
10SOCKET WinsockNetLayer::s_hostConnectionSocket = INVALID_SOCKET;
11HANDLE WinsockNetLayer::s_acceptThread = NULL;
12HANDLE WinsockNetLayer::s_clientRecvThread = NULL;
13
14bool WinsockNetLayer::s_isHost = false;
15bool WinsockNetLayer::s_connected = false;
16bool WinsockNetLayer::s_active = false;
17bool WinsockNetLayer::s_initialized = false;
18
19BYTE WinsockNetLayer::s_localSmallId = 0;
20BYTE WinsockNetLayer::s_hostSmallId = 0;
21BYTE WinsockNetLayer::s_nextSmallId = 1;
22
23CRITICAL_SECTION WinsockNetLayer::s_sendLock;
24CRITICAL_SECTION WinsockNetLayer::s_connectionsLock;
25
26std::vector<Win64RemoteConnection> WinsockNetLayer::s_connections;
27
28SOCKET WinsockNetLayer::s_advertiseSock = INVALID_SOCKET;
29HANDLE WinsockNetLayer::s_advertiseThread = NULL;
30volatile bool WinsockNetLayer::s_advertising = false;
31Win64LANBroadcast WinsockNetLayer::s_advertiseData = {};
32CRITICAL_SECTION WinsockNetLayer::s_advertiseLock;
33int WinsockNetLayer::s_hostGamePort = WIN64_NET_DEFAULT_PORT;
34
35SOCKET WinsockNetLayer::s_discoverySock = INVALID_SOCKET;
36HANDLE WinsockNetLayer::s_discoveryThread = NULL;
37volatile bool WinsockNetLayer::s_discovering = false;
38CRITICAL_SECTION WinsockNetLayer::s_discoveryLock;
39std::vector<Win64LANSession> WinsockNetLayer::s_discoveredSessions;
40
41CRITICAL_SECTION WinsockNetLayer::s_disconnectLock;
42std::vector<BYTE> WinsockNetLayer::s_disconnectedSmallIds;
43
44CRITICAL_SECTION WinsockNetLayer::s_freeSmallIdLock;
45std::vector<BYTE> WinsockNetLayer::s_freeSmallIds;
46
47bool g_Win64MultiplayerHost = false;
48bool g_Win64MultiplayerJoin = false;
49int g_Win64MultiplayerPort = WIN64_NET_DEFAULT_PORT;
50char g_Win64MultiplayerIP[256] = "127.0.0.1";
51
52bool WinsockNetLayer::Initialize()
53{
54 if (s_initialized) return true;
55
56 WSADATA wsaData;
57 int result = WSAStartup(MAKEWORD(2, 2), &wsaData);
58 if (result != 0)
59 {
60 app.DebugPrintf("WSAStartup failed: %d\n", result);
61 return false;
62 }
63
64 InitializeCriticalSection(&s_sendLock);
65 InitializeCriticalSection(&s_connectionsLock);
66 InitializeCriticalSection(&s_advertiseLock);
67 InitializeCriticalSection(&s_discoveryLock);
68 InitializeCriticalSection(&s_disconnectLock);
69 InitializeCriticalSection(&s_freeSmallIdLock);
70
71 s_initialized = true;
72
73 StartDiscovery();
74
75 return true;
76}
77
78void WinsockNetLayer::Shutdown()
79{
80 StopAdvertising();
81 StopDiscovery();
82
83 s_active = false;
84 s_connected = false;
85
86 if (s_listenSocket != INVALID_SOCKET)
87 {
88 closesocket(s_listenSocket);
89 s_listenSocket = INVALID_SOCKET;
90 }
91
92 if (s_hostConnectionSocket != INVALID_SOCKET)
93 {
94 closesocket(s_hostConnectionSocket);
95 s_hostConnectionSocket = INVALID_SOCKET;
96 }
97
98 EnterCriticalSection(&s_connectionsLock);
99 for (size_t i = 0; i < s_connections.size(); i++)
100 {
101 s_connections[i].active = false;
102 if (s_connections[i].tcpSocket != INVALID_SOCKET)
103 {
104 closesocket(s_connections[i].tcpSocket);
105 }
106 }
107 s_connections.clear();
108 LeaveCriticalSection(&s_connectionsLock);
109
110 if (s_acceptThread != NULL)
111 {
112 WaitForSingleObject(s_acceptThread, 2000);
113 CloseHandle(s_acceptThread);
114 s_acceptThread = NULL;
115 }
116
117 if (s_clientRecvThread != NULL)
118 {
119 WaitForSingleObject(s_clientRecvThread, 2000);
120 CloseHandle(s_clientRecvThread);
121 s_clientRecvThread = NULL;
122 }
123
124 if (s_initialized)
125 {
126 DeleteCriticalSection(&s_sendLock);
127 DeleteCriticalSection(&s_connectionsLock);
128 DeleteCriticalSection(&s_advertiseLock);
129 DeleteCriticalSection(&s_discoveryLock);
130 DeleteCriticalSection(&s_disconnectLock);
131 s_disconnectedSmallIds.clear();
132 DeleteCriticalSection(&s_freeSmallIdLock);
133 s_freeSmallIds.clear();
134 WSACleanup();
135 s_initialized = false;
136 }
137}
138
139bool WinsockNetLayer::HostGame(int port)
140{
141 if (!s_initialized && !Initialize()) return false;
142
143 s_isHost = true;
144 s_localSmallId = 0;
145 s_hostSmallId = 0;
146 s_nextSmallId = 1;
147 s_hostGamePort = port;
148
149 EnterCriticalSection(&s_freeSmallIdLock);
150 s_freeSmallIds.clear();
151 LeaveCriticalSection(&s_freeSmallIdLock);
152
153 struct addrinfo hints = {};
154 struct addrinfo *result = NULL;
155
156 hints.ai_family = AF_INET;
157 hints.ai_socktype = SOCK_STREAM;
158 hints.ai_protocol = IPPROTO_TCP;
159 hints.ai_flags = AI_PASSIVE;
160
161 char portStr[16];
162 sprintf_s(portStr, "%d", port);
163
164 int iResult = getaddrinfo(NULL, portStr, &hints, &result);
165 if (iResult != 0)
166 {
167 app.DebugPrintf("getaddrinfo failed: %d\n", iResult);
168 return false;
169 }
170
171 s_listenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
172 if (s_listenSocket == INVALID_SOCKET)
173 {
174 app.DebugPrintf("socket() failed: %d\n", WSAGetLastError());
175 freeaddrinfo(result);
176 return false;
177 }
178
179 int opt = 1;
180 setsockopt(s_listenSocket, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof(opt));
181
182 iResult = ::bind(s_listenSocket, result->ai_addr, (int)result->ai_addrlen);
183 freeaddrinfo(result);
184 if (iResult == SOCKET_ERROR)
185 {
186 app.DebugPrintf("bind() failed: %d\n", WSAGetLastError());
187 closesocket(s_listenSocket);
188 s_listenSocket = INVALID_SOCKET;
189 return false;
190 }
191
192 iResult = listen(s_listenSocket, SOMAXCONN);
193 if (iResult == SOCKET_ERROR)
194 {
195 app.DebugPrintf("listen() failed: %d\n", WSAGetLastError());
196 closesocket(s_listenSocket);
197 s_listenSocket = INVALID_SOCKET;
198 return false;
199 }
200
201 s_active = true;
202 s_connected = true;
203
204 s_acceptThread = CreateThread(NULL, 0, AcceptThreadProc, NULL, 0, NULL);
205
206 app.DebugPrintf("Win64 LAN: Hosting on port %d\n", port);
207 return true;
208}
209
210bool WinsockNetLayer::JoinGame(const char *ip, int port)
211{
212 if (!s_initialized && !Initialize()) return false;
213
214 s_isHost = false;
215 s_hostSmallId = 0;
216
217 struct addrinfo hints = {};
218 struct addrinfo *result = NULL;
219
220 hints.ai_family = AF_INET;
221 hints.ai_socktype = SOCK_STREAM;
222 hints.ai_protocol = IPPROTO_TCP;
223
224 char portStr[16];
225 sprintf_s(portStr, "%d", port);
226
227 int iResult = getaddrinfo(ip, portStr, &hints, &result);
228 if (iResult != 0)
229 {
230 app.DebugPrintf("getaddrinfo failed for %s:%d - %d\n", ip, port, iResult);
231 return false;
232 }
233
234 s_hostConnectionSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
235 if (s_hostConnectionSocket == INVALID_SOCKET)
236 {
237 app.DebugPrintf("socket() failed: %d\n", WSAGetLastError());
238 freeaddrinfo(result);
239 return false;
240 }
241
242 int noDelay = 1;
243 setsockopt(s_hostConnectionSocket, IPPROTO_TCP, TCP_NODELAY, (const char *)&noDelay, sizeof(noDelay));
244
245 iResult = connect(s_hostConnectionSocket, result->ai_addr, (int)result->ai_addrlen);
246 freeaddrinfo(result);
247 if (iResult == SOCKET_ERROR)
248 {
249 app.DebugPrintf("connect() to %s:%d failed: %d\n", ip, port, WSAGetLastError());
250 closesocket(s_hostConnectionSocket);
251 s_hostConnectionSocket = INVALID_SOCKET;
252 return false;
253 }
254
255 BYTE assignBuf[1];
256 int bytesRecv = recv(s_hostConnectionSocket, (char *)assignBuf, 1, 0);
257 if (bytesRecv != 1)
258 {
259 app.DebugPrintf("Failed to receive small ID assignment from host\n");
260 closesocket(s_hostConnectionSocket);
261 s_hostConnectionSocket = INVALID_SOCKET;
262 return false;
263 }
264 s_localSmallId = assignBuf[0];
265
266 app.DebugPrintf("Win64 LAN: Connected to %s:%d, assigned smallId=%d\n", ip, port, s_localSmallId);
267
268 s_active = true;
269 s_connected = true;
270
271 s_clientRecvThread = CreateThread(NULL, 0, ClientRecvThreadProc, NULL, 0, NULL);
272
273 return true;
274}
275
276bool WinsockNetLayer::SendOnSocket(SOCKET sock, const void *data, int dataSize)
277{
278 if (sock == INVALID_SOCKET || dataSize <= 0) return false;
279
280 EnterCriticalSection(&s_sendLock);
281
282 BYTE header[4];
283 header[0] = (BYTE)((dataSize >> 24) & 0xFF);
284 header[1] = (BYTE)((dataSize >> 16) & 0xFF);
285 header[2] = (BYTE)((dataSize >> 8) & 0xFF);
286 header[3] = (BYTE)(dataSize & 0xFF);
287
288 int totalSent = 0;
289 int toSend = 4;
290 while (totalSent < toSend)
291 {
292 int sent = send(sock, (const char *)header + totalSent, toSend - totalSent, 0);
293 if (sent == SOCKET_ERROR || sent == 0)
294 {
295 LeaveCriticalSection(&s_sendLock);
296 return false;
297 }
298 totalSent += sent;
299 }
300
301 totalSent = 0;
302 while (totalSent < dataSize)
303 {
304 int sent = send(sock, (const char *)data + totalSent, dataSize - totalSent, 0);
305 if (sent == SOCKET_ERROR || sent == 0)
306 {
307 LeaveCriticalSection(&s_sendLock);
308 return false;
309 }
310 totalSent += sent;
311 }
312
313 LeaveCriticalSection(&s_sendLock);
314 return true;
315}
316
317bool WinsockNetLayer::SendToSmallId(BYTE targetSmallId, const void *data, int dataSize)
318{
319 if (!s_active) return false;
320
321 if (s_isHost)
322 {
323 SOCKET sock = GetSocketForSmallId(targetSmallId);
324 if (sock == INVALID_SOCKET) return false;
325 return SendOnSocket(sock, data, dataSize);
326 }
327 else
328 {
329 return SendOnSocket(s_hostConnectionSocket, data, dataSize);
330 }
331}
332
333SOCKET WinsockNetLayer::GetSocketForSmallId(BYTE smallId)
334{
335 EnterCriticalSection(&s_connectionsLock);
336 for (size_t i = 0; i < s_connections.size(); i++)
337 {
338 if (s_connections[i].smallId == smallId && s_connections[i].active)
339 {
340 SOCKET sock = s_connections[i].tcpSocket;
341 LeaveCriticalSection(&s_connectionsLock);
342 return sock;
343 }
344 }
345 LeaveCriticalSection(&s_connectionsLock);
346 return INVALID_SOCKET;
347}
348
349static bool RecvExact(SOCKET sock, BYTE *buf, int len)
350{
351 int totalRecv = 0;
352 while (totalRecv < len)
353 {
354 int r = recv(sock, (char *)buf + totalRecv, len - totalRecv, 0);
355 if (r <= 0) return false;
356 totalRecv += r;
357 }
358 return true;
359}
360
361void WinsockNetLayer::HandleDataReceived(BYTE fromSmallId, BYTE toSmallId, unsigned char *data, unsigned int dataSize)
362{
363 INetworkPlayer *pPlayerFrom = g_NetworkManager.GetPlayerBySmallId(fromSmallId);
364 INetworkPlayer *pPlayerTo = g_NetworkManager.GetPlayerBySmallId(toSmallId);
365
366 if (pPlayerFrom == NULL || pPlayerTo == NULL) return;
367
368 if (s_isHost)
369 {
370 ::Socket *pSocket = pPlayerFrom->GetSocket();
371 if (pSocket != NULL)
372 pSocket->pushDataToQueue(data, dataSize, false);
373 }
374 else
375 {
376 ::Socket *pSocket = pPlayerTo->GetSocket();
377 if (pSocket != NULL)
378 pSocket->pushDataToQueue(data, dataSize, true);
379 }
380}
381
382DWORD WINAPI WinsockNetLayer::AcceptThreadProc(LPVOID param)
383{
384 while (s_active)
385 {
386 SOCKET clientSocket = accept(s_listenSocket, NULL, NULL);
387 if (clientSocket == INVALID_SOCKET)
388 {
389 if (s_active)
390 app.DebugPrintf("accept() failed: %d\n", WSAGetLastError());
391 break;
392 }
393
394 int noDelay = 1;
395 setsockopt(clientSocket, IPPROTO_TCP, TCP_NODELAY, (const char *)&noDelay, sizeof(noDelay));
396
397 extern QNET_STATE _iQNetStubState;
398 if (_iQNetStubState != QNET_STATE_GAME_PLAY)
399 {
400 app.DebugPrintf("Win64 LAN: Rejecting connection, game not ready\n");
401 closesocket(clientSocket);
402 continue;
403 }
404
405 BYTE assignedSmallId;
406 EnterCriticalSection(&s_freeSmallIdLock);
407 if (!s_freeSmallIds.empty())
408 {
409 assignedSmallId = s_freeSmallIds.back();
410 s_freeSmallIds.pop_back();
411 }
412 else if (s_nextSmallId < MINECRAFT_NET_MAX_PLAYERS)
413 {
414 assignedSmallId = s_nextSmallId++;
415 }
416 else
417 {
418 LeaveCriticalSection(&s_freeSmallIdLock);
419 app.DebugPrintf("Win64 LAN: Server full, rejecting connection\n");
420 closesocket(clientSocket);
421 continue;
422 }
423 LeaveCriticalSection(&s_freeSmallIdLock);
424
425 BYTE assignBuf[1] = { assignedSmallId };
426 int sent = send(clientSocket, (const char *)assignBuf, 1, 0);
427 if (sent != 1)
428 {
429 app.DebugPrintf("Failed to send small ID to client\n");
430 closesocket(clientSocket);
431 continue;
432 }
433
434 Win64RemoteConnection conn;
435 conn.tcpSocket = clientSocket;
436 conn.smallId = assignedSmallId;
437 conn.active = true;
438 conn.recvThread = NULL;
439
440 EnterCriticalSection(&s_connectionsLock);
441 s_connections.push_back(conn);
442 int connIdx = (int)s_connections.size() - 1;
443 LeaveCriticalSection(&s_connectionsLock);
444
445 app.DebugPrintf("Win64 LAN: Client connected, assigned smallId=%d\n", assignedSmallId);
446
447 IQNetPlayer *qnetPlayer = &IQNet::m_player[assignedSmallId];
448
449 extern void Win64_SetupRemoteQNetPlayer(IQNetPlayer *player, BYTE smallId, bool isHost, bool isLocal);
450 Win64_SetupRemoteQNetPlayer(qnetPlayer, assignedSmallId, false, false);
451
452 extern CPlatformNetworkManagerStub *g_pPlatformNetworkManager;
453 g_pPlatformNetworkManager->NotifyPlayerJoined(qnetPlayer);
454
455 DWORD *threadParam = new DWORD;
456 *threadParam = connIdx;
457 HANDLE hThread = CreateThread(NULL, 0, RecvThreadProc, threadParam, 0, NULL);
458
459 EnterCriticalSection(&s_connectionsLock);
460 if (connIdx < (int)s_connections.size())
461 s_connections[connIdx].recvThread = hThread;
462 LeaveCriticalSection(&s_connectionsLock);
463 }
464 return 0;
465}
466
467DWORD WINAPI WinsockNetLayer::RecvThreadProc(LPVOID param)
468{
469 DWORD connIdx = *(DWORD *)param;
470 delete (DWORD *)param;
471
472 EnterCriticalSection(&s_connectionsLock);
473 if (connIdx >= (DWORD)s_connections.size())
474 {
475 LeaveCriticalSection(&s_connectionsLock);
476 return 0;
477 }
478 SOCKET sock = s_connections[connIdx].tcpSocket;
479 BYTE clientSmallId = s_connections[connIdx].smallId;
480 LeaveCriticalSection(&s_connectionsLock);
481
482 BYTE *recvBuf = new BYTE[WIN64_NET_RECV_BUFFER_SIZE];
483
484 while (s_active)
485 {
486 BYTE header[4];
487 if (!RecvExact(sock, header, 4))
488 {
489 app.DebugPrintf("Win64 LAN: Client smallId=%d disconnected (header)\n", clientSmallId);
490 break;
491 }
492
493 int packetSize = (header[0] << 24) | (header[1] << 16) | (header[2] << 8) | header[3];
494
495 if (packetSize <= 0 || packetSize > WIN64_NET_RECV_BUFFER_SIZE)
496 {
497 app.DebugPrintf("Win64 LAN: Invalid packet size %d from client smallId=%d\n", packetSize, clientSmallId);
498 break;
499 }
500
501 if (!RecvExact(sock, recvBuf, packetSize))
502 {
503 app.DebugPrintf("Win64 LAN: Client smallId=%d disconnected (body)\n", clientSmallId);
504 break;
505 }
506
507 HandleDataReceived(clientSmallId, s_hostSmallId, recvBuf, packetSize);
508 }
509
510 delete[] recvBuf;
511
512 EnterCriticalSection(&s_connectionsLock);
513 for (size_t i = 0; i < s_connections.size(); i++)
514 {
515 if (s_connections[i].smallId == clientSmallId)
516 {
517 s_connections[i].active = false;
518 closesocket(s_connections[i].tcpSocket);
519 s_connections[i].tcpSocket = INVALID_SOCKET;
520 break;
521 }
522 }
523 LeaveCriticalSection(&s_connectionsLock);
524
525 EnterCriticalSection(&s_disconnectLock);
526 s_disconnectedSmallIds.push_back(clientSmallId);
527 LeaveCriticalSection(&s_disconnectLock);
528
529 return 0;
530}
531
532bool WinsockNetLayer::PopDisconnectedSmallId(BYTE *outSmallId)
533{
534 bool found = false;
535 EnterCriticalSection(&s_disconnectLock);
536 if (!s_disconnectedSmallIds.empty())
537 {
538 *outSmallId = s_disconnectedSmallIds.back();
539 s_disconnectedSmallIds.pop_back();
540 found = true;
541 }
542 LeaveCriticalSection(&s_disconnectLock);
543 return found;
544}
545
546void WinsockNetLayer::PushFreeSmallId(BYTE smallId)
547{
548 EnterCriticalSection(&s_freeSmallIdLock);
549 s_freeSmallIds.push_back(smallId);
550 LeaveCriticalSection(&s_freeSmallIdLock);
551}
552
553DWORD WINAPI WinsockNetLayer::ClientRecvThreadProc(LPVOID param)
554{
555 BYTE *recvBuf = new BYTE[WIN64_NET_RECV_BUFFER_SIZE];
556
557 while (s_active && s_hostConnectionSocket != INVALID_SOCKET)
558 {
559 BYTE header[4];
560 if (!RecvExact(s_hostConnectionSocket, header, 4))
561 {
562 app.DebugPrintf("Win64 LAN: Disconnected from host (header)\n");
563 break;
564 }
565
566 int packetSize = (header[0] << 24) | (header[1] << 16) | (header[2] << 8) | header[3];
567
568 if (packetSize <= 0 || packetSize > WIN64_NET_RECV_BUFFER_SIZE)
569 {
570 app.DebugPrintf("Win64 LAN: Invalid packet size %d from host\n", packetSize);
571 break;
572 }
573
574 if (!RecvExact(s_hostConnectionSocket, recvBuf, packetSize))
575 {
576 app.DebugPrintf("Win64 LAN: Disconnected from host (body)\n");
577 break;
578 }
579
580 HandleDataReceived(s_hostSmallId, s_localSmallId, recvBuf, packetSize);
581 }
582
583 delete[] recvBuf;
584
585 s_connected = false;
586 return 0;
587}
588
589bool WinsockNetLayer::StartAdvertising(int gamePort, const wchar_t *hostName, unsigned int gameSettings, unsigned int texPackId, unsigned char subTexId, unsigned short netVer)
590{
591 if (s_advertising) return true;
592 if (!s_initialized) return false;
593
594 EnterCriticalSection(&s_advertiseLock);
595 memset(&s_advertiseData, 0, sizeof(s_advertiseData));
596 s_advertiseData.magic = WIN64_LAN_BROADCAST_MAGIC;
597 s_advertiseData.netVersion = netVer;
598 s_advertiseData.gamePort = (WORD)gamePort;
599 wcsncpy_s(s_advertiseData.hostName, 32, hostName, _TRUNCATE);
600 s_advertiseData.playerCount = 1;
601 s_advertiseData.maxPlayers = MINECRAFT_NET_MAX_PLAYERS;
602 s_advertiseData.gameHostSettings = gameSettings;
603 s_advertiseData.texturePackParentId = texPackId;
604 s_advertiseData.subTexturePackId = subTexId;
605 s_advertiseData.isJoinable = 0;
606 s_hostGamePort = gamePort;
607 LeaveCriticalSection(&s_advertiseLock);
608
609 s_advertiseSock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
610 if (s_advertiseSock == INVALID_SOCKET)
611 {
612 app.DebugPrintf("Win64 LAN: Failed to create advertise socket: %d\n", WSAGetLastError());
613 return false;
614 }
615
616 BOOL broadcast = TRUE;
617 setsockopt(s_advertiseSock, SOL_SOCKET, SO_BROADCAST, (const char *)&broadcast, sizeof(broadcast));
618
619 s_advertising = true;
620 s_advertiseThread = CreateThread(NULL, 0, AdvertiseThreadProc, NULL, 0, NULL);
621
622 app.DebugPrintf("Win64 LAN: Started advertising on UDP port %d\n", WIN64_LAN_DISCOVERY_PORT);
623 return true;
624}
625
626void WinsockNetLayer::StopAdvertising()
627{
628 s_advertising = false;
629
630 if (s_advertiseSock != INVALID_SOCKET)
631 {
632 closesocket(s_advertiseSock);
633 s_advertiseSock = INVALID_SOCKET;
634 }
635
636 if (s_advertiseThread != NULL)
637 {
638 WaitForSingleObject(s_advertiseThread, 2000);
639 CloseHandle(s_advertiseThread);
640 s_advertiseThread = NULL;
641 }
642}
643
644void WinsockNetLayer::UpdateAdvertisePlayerCount(BYTE count)
645{
646 EnterCriticalSection(&s_advertiseLock);
647 s_advertiseData.playerCount = count;
648 LeaveCriticalSection(&s_advertiseLock);
649}
650
651void WinsockNetLayer::UpdateAdvertiseJoinable(bool joinable)
652{
653 EnterCriticalSection(&s_advertiseLock);
654 s_advertiseData.isJoinable = joinable ? 1 : 0;
655 LeaveCriticalSection(&s_advertiseLock);
656}
657
658DWORD WINAPI WinsockNetLayer::AdvertiseThreadProc(LPVOID param)
659{
660 struct sockaddr_in broadcastAddr;
661 memset(&broadcastAddr, 0, sizeof(broadcastAddr));
662 broadcastAddr.sin_family = AF_INET;
663 broadcastAddr.sin_port = htons(WIN64_LAN_DISCOVERY_PORT);
664 broadcastAddr.sin_addr.s_addr = INADDR_BROADCAST;
665
666 while (s_advertising)
667 {
668 EnterCriticalSection(&s_advertiseLock);
669 Win64LANBroadcast data = s_advertiseData;
670 LeaveCriticalSection(&s_advertiseLock);
671
672 int sent = sendto(s_advertiseSock, (const char *)&data, sizeof(data), 0,
673 (struct sockaddr *)&broadcastAddr, sizeof(broadcastAddr));
674
675 if (sent == SOCKET_ERROR && s_advertising)
676 {
677 app.DebugPrintf("Win64 LAN: Broadcast sendto failed: %d\n", WSAGetLastError());
678 }
679
680 Sleep(1000);
681 }
682
683 return 0;
684}
685
686bool WinsockNetLayer::StartDiscovery()
687{
688 if (s_discovering) return true;
689 if (!s_initialized) return false;
690
691 s_discoverySock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
692 if (s_discoverySock == INVALID_SOCKET)
693 {
694 app.DebugPrintf("Win64 LAN: Failed to create discovery socket: %d\n", WSAGetLastError());
695 return false;
696 }
697
698 BOOL reuseAddr = TRUE;
699 setsockopt(s_discoverySock, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuseAddr, sizeof(reuseAddr));
700
701 struct sockaddr_in bindAddr;
702 memset(&bindAddr, 0, sizeof(bindAddr));
703 bindAddr.sin_family = AF_INET;
704 bindAddr.sin_port = htons(WIN64_LAN_DISCOVERY_PORT);
705 bindAddr.sin_addr.s_addr = INADDR_ANY;
706
707 if (::bind(s_discoverySock, (struct sockaddr *)&bindAddr, sizeof(bindAddr)) == SOCKET_ERROR)
708 {
709 app.DebugPrintf("Win64 LAN: Discovery bind failed: %d\n", WSAGetLastError());
710 closesocket(s_discoverySock);
711 s_discoverySock = INVALID_SOCKET;
712 return false;
713 }
714
715 DWORD timeout = 500;
716 setsockopt(s_discoverySock, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout));
717
718 s_discovering = true;
719 s_discoveryThread = CreateThread(NULL, 0, DiscoveryThreadProc, NULL, 0, NULL);
720
721 app.DebugPrintf("Win64 LAN: Listening for LAN games on UDP port %d\n", WIN64_LAN_DISCOVERY_PORT);
722 return true;
723}
724
725void WinsockNetLayer::StopDiscovery()
726{
727 s_discovering = false;
728
729 if (s_discoverySock != INVALID_SOCKET)
730 {
731 closesocket(s_discoverySock);
732 s_discoverySock = INVALID_SOCKET;
733 }
734
735 if (s_discoveryThread != NULL)
736 {
737 WaitForSingleObject(s_discoveryThread, 2000);
738 CloseHandle(s_discoveryThread);
739 s_discoveryThread = NULL;
740 }
741
742 EnterCriticalSection(&s_discoveryLock);
743 s_discoveredSessions.clear();
744 LeaveCriticalSection(&s_discoveryLock);
745}
746
747std::vector<Win64LANSession> WinsockNetLayer::GetDiscoveredSessions()
748{
749 std::vector<Win64LANSession> result;
750 EnterCriticalSection(&s_discoveryLock);
751 result = s_discoveredSessions;
752 LeaveCriticalSection(&s_discoveryLock);
753 return result;
754}
755
756DWORD WINAPI WinsockNetLayer::DiscoveryThreadProc(LPVOID param)
757{
758 char recvBuf[512];
759
760 while (s_discovering)
761 {
762 struct sockaddr_in senderAddr;
763 int senderLen = sizeof(senderAddr);
764
765 int recvLen = recvfrom(s_discoverySock, recvBuf, sizeof(recvBuf), 0,
766 (struct sockaddr *)&senderAddr, &senderLen);
767
768 if (recvLen == SOCKET_ERROR)
769 {
770 continue;
771 }
772
773 if (recvLen < (int)sizeof(Win64LANBroadcast))
774 continue;
775
776 Win64LANBroadcast *broadcast = (Win64LANBroadcast *)recvBuf;
777 if (broadcast->magic != WIN64_LAN_BROADCAST_MAGIC)
778 continue;
779
780 char senderIP[64];
781 inet_ntop(AF_INET, &senderAddr.sin_addr, senderIP, sizeof(senderIP));
782
783 DWORD now = GetTickCount();
784
785 EnterCriticalSection(&s_discoveryLock);
786
787 bool found = false;
788 for (size_t i = 0; i < s_discoveredSessions.size(); i++)
789 {
790 if (strcmp(s_discoveredSessions[i].hostIP, senderIP) == 0 &&
791 s_discoveredSessions[i].hostPort == (int)broadcast->gamePort)
792 {
793 s_discoveredSessions[i].netVersion = broadcast->netVersion;
794 wcsncpy_s(s_discoveredSessions[i].hostName, 32, broadcast->hostName, _TRUNCATE);
795 s_discoveredSessions[i].playerCount = broadcast->playerCount;
796 s_discoveredSessions[i].maxPlayers = broadcast->maxPlayers;
797 s_discoveredSessions[i].gameHostSettings = broadcast->gameHostSettings;
798 s_discoveredSessions[i].texturePackParentId = broadcast->texturePackParentId;
799 s_discoveredSessions[i].subTexturePackId = broadcast->subTexturePackId;
800 s_discoveredSessions[i].isJoinable = (broadcast->isJoinable != 0);
801 s_discoveredSessions[i].lastSeenTick = now;
802 found = true;
803 break;
804 }
805 }
806
807 if (!found)
808 {
809 Win64LANSession session;
810 memset(&session, 0, sizeof(session));
811 strncpy_s(session.hostIP, sizeof(session.hostIP), senderIP, _TRUNCATE);
812 session.hostPort = (int)broadcast->gamePort;
813 session.netVersion = broadcast->netVersion;
814 wcsncpy_s(session.hostName, 32, broadcast->hostName, _TRUNCATE);
815 session.playerCount = broadcast->playerCount;
816 session.maxPlayers = broadcast->maxPlayers;
817 session.gameHostSettings = broadcast->gameHostSettings;
818 session.texturePackParentId = broadcast->texturePackParentId;
819 session.subTexturePackId = broadcast->subTexturePackId;
820 session.isJoinable = (broadcast->isJoinable != 0);
821 session.lastSeenTick = now;
822 s_discoveredSessions.push_back(session);
823
824 app.DebugPrintf("Win64 LAN: Discovered game \"%ls\" at %s:%d\n",
825 session.hostName, session.hostIP, session.hostPort);
826 }
827
828 for (size_t i = s_discoveredSessions.size(); i > 0; i--)
829 {
830 if (now - s_discoveredSessions[i - 1].lastSeenTick > 5000)
831 {
832 app.DebugPrintf("Win64 LAN: Session \"%ls\" at %s timed out\n",
833 s_discoveredSessions[i - 1].hostName, s_discoveredSessions[i - 1].hostIP);
834 s_discoveredSessions.erase(s_discoveredSessions.begin() + (i - 1));
835 }
836 }
837
838 LeaveCriticalSection(&s_discoveryLock);
839 }
840
841 return 0;
842}
843
844#endif