Zero Hour rebuilt from EA's source: x64, Direct3D 11, VS2022/CMake, ~60 original bugs fixed, an AI that builds a base. Bring your own game.
C++ cmakecnccommand-and-conquercppdirectx11game-enginegame-preservationgeneralsrtssage-enginex64zero-hour
/*
** Command & Conquer Generals Zero Hour(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// Modified 2026 by İlyas Akın for the macOS/Linux port; see NOTICE.md and the git history.
////////////////////////////////////////////////////////////////////////////////
// //
// (c) 2001-2003 Electronic Arts Inc. //
// //
////////////////////////////////////////////////////////////////////////////////
// FILE: Udp.cpp //////////////////////////////////////////////////////////////
// Implementation of UDP socket wrapper class (taken from wnet lib)
// Author: Matthew D. Campbell, July 2001
///////////////////////////////////////////////////////////////////////////////
// SYSTEM INCLUDES ////////////////////////////////////////////////////////////
#include "PreRTS.h" // This must go first in EVERY cpp file int the GameEngine
// USER INCLUDES //////////////////////////////////////////////////////////////
#include "Common/GameEngine.h"
//#include "GameNetwork/NetworkInterface.h"
#include "GameNetwork/udp.h"
#if !defined(_WIN32)
#include <string.h> // strerror, for GetWSAErrorString's POSIX half
// winsock's name for closing a socket; POSIX closes it like any descriptor (ControlServer.cpp does the same)
#define closesocket close
#endif
#ifdef _INTERNAL
// for occasional debugging...
//#pragma optimize("", off)
//#pragma MESSAGE("************************************** WARNING, optimization disabled for debugging purposes")
#endif
//-------------------------------------------------------------------------
#ifdef DEBUG_LOGGING
#define CASE(x) case (x): return #x;
AsciiString GetWSAErrorString( Int error )
{
#if !defined(_WIN32)
// Off Windows the error is errno's, and the C library names it.
AsciiString ret;
ret.format("%s (%d)", strerror(error), error);
return ret;
#else
switch (error)
{
CASE(WSABASEERR)
CASE(WSAEINTR)
CASE(WSAEBADF)
CASE(WSAEACCES)
CASE(WSAEFAULT)
CASE(WSAEINVAL)
CASE(WSAEMFILE)
CASE(WSAEWOULDBLOCK)
CASE(WSAEINPROGRESS)
CASE(WSAEALREADY)
CASE(WSAENOTSOCK)
CASE(WSAEDESTADDRREQ)
CASE(WSAEMSGSIZE)
CASE(WSAEPROTOTYPE)
CASE(WSAENOPROTOOPT)
CASE(WSAEPROTONOSUPPORT)
CASE(WSAESOCKTNOSUPPORT)
CASE(WSAEOPNOTSUPP)
CASE(WSAEPFNOSUPPORT)
CASE(WSAEAFNOSUPPORT)
CASE(WSAEADDRINUSE)
CASE(WSAEADDRNOTAVAIL)
CASE(WSAENETDOWN)
CASE(WSAENETUNREACH)
CASE(WSAENETRESET)
CASE(WSAECONNABORTED)
CASE(WSAECONNRESET)
CASE(WSAENOBUFS)
CASE(WSAEISCONN)
CASE(WSAENOTCONN)
CASE(WSAESHUTDOWN)
CASE(WSAETOOMANYREFS)
CASE(WSAETIMEDOUT)
CASE(WSAECONNREFUSED)
CASE(WSAELOOP)
CASE(WSAENAMETOOLONG)
CASE(WSAEHOSTDOWN)
CASE(WSAEHOSTUNREACH)
CASE(WSAENOTEMPTY)
CASE(WSAEPROCLIM)
CASE(WSAEUSERS)
CASE(WSAEDQUOT)
CASE(WSAESTALE)
CASE(WSAEREMOTE)
CASE(WSAEDISCON)
CASE(WSASYSNOTREADY)
CASE(WSAVERNOTSUPPORTED)
CASE(WSANOTINITIALISED)
CASE(WSAHOST_NOT_FOUND)
CASE(WSATRY_AGAIN)
CASE(WSANO_RECOVERY)
CASE(WSANO_DATA)
default:
{
AsciiString ret;
ret.format("Not a Winsock error (%d)", error);
return ret;
}
}
return AsciiString::TheEmptyString; // will not be hit, ever.
#endif
}
#undef CASE
#endif // defined(_DEBUG) || defined(_INTERNAL)
//-------------------------------------------------------------------------
UDP::UDP()
{
fd=-1;
#if !defined(_WIN32)
m_shareAddress=FALSE;
m_broadcastsOnly=FALSE;
#endif
}
UDP::~UDP()
{
closeSocket();
}
/* -1 is no socket: what socket() returns on failure (SOCKET_ERROR on Windows, mapped to -1 in Bind). It
was 0, which is a valid descriptor off Windows, while a failed socket() left -1 for the destructor to
close. */
void UDP::closeSocket(void)
{
if (fd != -1)
closesocket(fd);
fd=-1;
}
Int UDP::Bind(const char *Host,UnsignedShort port)
{
char hostName[100];
struct hostent *hostStruct;
struct in_addr *hostNode;
if (isdigit(Host[0]))
return ( Bind( ntohl(inet_addr(Host)), port) );
strcpy(hostName, Host);
hostStruct = gethostbyname(Host);
if (hostStruct == NULL)
return (0);
hostNode = (struct in_addr *) hostStruct->h_addr;
return ( Bind(ntohl(hostNode->s_addr),port) );
}
// You must call bind, implicit binding is for sissies
// Well... you can get implicit binding if you pass 0 for either arg
Int UDP::Bind(UnsignedInt IP,UnsignedShort Port)
{
int retval;
int status;
IP=htonl(IP);
Port=htons(Port);
addr.sin_family=AF_INET;
addr.sin_port=Port;
addr.sin_addr.s_addr=IP;
/* Each Bind makes a new socket, so the one before it goes first, and one whose bind fails is closed
below. Transport::init retries Bind for up to a second while the port is taken, and every try left
its socket open: about 100,000 of them, on every platform, which on a Mac filled the whole system's
file table. */
closeSocket();
fd=socket(AF_INET,SOCK_DGRAM,DEFAULT_PROTOCOL);
#ifdef _WINDOWS
if (fd==SOCKET_ERROR)
fd=-1;
#endif
if (fd==-1)
return(UNKNOWN);
#if !defined(_WIN32)
// Port defect 29: the options have to be on the socket before bind (udp.h, BindForBroadcasts)
#if defined(__linux__)
// Linux's SO_REUSEADDR lets a second UDP socket bind the very same address and port, which BSD refuses,
// and a unicast datagram then goes to only one of them: two copies could share one address unseen. So
// the lobby socket shares nothing there - its listener binds the broadcast address instead of the
// wildcard (BindForBroadcasts), and no longer meets it on an address (W1, measured on Arch).
const Bool share = m_broadcastsOnly;
#else
const Bool share = m_shareAddress || m_broadcastsOnly;
#endif
if (share)
{
int on=1;
setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,(char *)&on,sizeof(on));
if (m_broadcastsOnly)
{
setsockopt(fd,SOL_SOCKET,SO_REUSEPORT,(char *)&on,sizeof(on));
#if defined(IP_RECVDSTADDR) // macOS and the BSDs
setsockopt(fd,IPPROTO_IP,IP_RECVDSTADDR,(char *)&on,sizeof(on));
#elif defined(IP_PKTINFO) // Linux
setsockopt(fd,IPPROTO_IP,IP_PKTINFO,(char *)&on,sizeof(on));
#else
#error "udp.cpp: this platform has neither IP_RECVDSTADDR nor IP_PKTINFO, so a broadcast cannot be told from a unicast datagram"
#endif
}
}
#endif
retval=bind(fd,(struct sockaddr *)&addr,sizeof(addr));
#ifdef _WINDOWS
if (retval==SOCKET_ERROR)
{
retval=-1;
m_lastError = WSAGetLastError();
}
#endif
#if !defined(_WIN32)
if (retval==-1)
m_lastError = errno; // the UNIX half never set it, so GetStatus() read a failed bind as OK
#endif
if (retval==-1)
{
status=GetStatus();
//CERR("Bind failure (" << status << ") IP " << IP << " PORT " << Port )
closeSocket();
return(status);
}
#if defined(_WIN32)
int namelen=sizeof(addr);
#else
socklen_t namelen=sizeof(addr);
#endif
getsockname(fd, (struct sockaddr *)&addr, &namelen);
myIP=ntohl(addr.sin_addr.s_addr);
myPort=ntohs(addr.sin_port);
retval=SetBlocking(FALSE);
if (retval==-1)
fprintf(stderr,"Couldn't set nonblocking mode!\n");
return(OK);
}
Int UDP::getLocalAddr(UnsignedInt &ip, UnsignedShort &port)
{
ip=myIP;
port=myPort;
return(OK);
}
// private function
Int UDP::SetBlocking(Int block)
{
#ifdef _WINDOWS
unsigned long flag=1;
if (block)
flag=0;
int retval;
retval=ioctlsocket(fd,FIONBIO,&flag);
if (retval==SOCKET_ERROR)
return(UNKNOWN);
else
return(OK);
#else // UNIX
int flags = fcntl(fd, F_GETFL, 0);
if (block==FALSE) // set nonblocking
flags |= O_NONBLOCK;
else // set blocking
flags &= ~(O_NONBLOCK);
if (fcntl(fd, F_SETFL, flags) < 0)
{
return(UNKNOWN);
}
return(OK);
#endif
}
Int UDP::Write(const unsigned char *msg,UnsignedInt len,UnsignedInt IP,UnsignedShort port)
{
Int retval;
struct sockaddr_in to;
// This happens frequently
if ((IP==0)||(port==0)) return(ADDRNOTAVAIL);
#ifdef _UNIX
errno=0;
#endif
to.sin_port=htons(port);
to.sin_addr.s_addr=htonl(IP);
to.sin_family=AF_INET;
ClearStatus();
retval=sendto(fd,(const char *)msg,len,0,(struct sockaddr *)&to,sizeof(to));
#ifdef _WINDOWS
if (retval==SOCKET_ERROR)
{
retval=-1;
m_lastError = WSAGetLastError();
#ifdef DEBUG_LOGGING
static Int errCount = 0;
#endif
DEBUG_ASSERTLOG(errCount++ > 100, ("UDP::Write() - WSA error is %s\n", GetWSAErrorString(WSAGetLastError()).str()));
}
#endif
#if !defined(_WIN32)
if (retval==-1)
m_lastError = errno;
#endif
return(retval);
}
Int UDP::Read(unsigned char *msg,UnsignedInt len,sockaddr_in *from)
{
Int retval;
#if defined(_WIN32)
int alen=sizeof(sockaddr_in);
#else
socklen_t alen=sizeof(sockaddr_in);
if (m_broadcastsOnly)
return(ReadBroadcast(msg,len,from));
#endif
if (from!=NULL)
{
retval=recvfrom(fd,(char *)msg,len,0,(struct sockaddr *)from,&alen);
#ifdef _WINDOWS
if (retval == SOCKET_ERROR)
{
if (WSAGetLastError() != WSAEWOULDBLOCK)
{
// failing because of a blocking error isn't really such a bad thing.
m_lastError = WSAGetLastError();
#ifdef DEBUG_LOGGING
static Int errCount = 0;
#endif
DEBUG_ASSERTLOG(errCount++ > 100, ("UDP::Read() - WSA error is %s\n", GetWSAErrorString(WSAGetLastError()).str()));
retval = -1;
} else {
retval = 0;
}
}
#endif
#if !defined(_WIN32)
if (retval==-1)
{
if (errno==EWOULDBLOCK || errno==EAGAIN)
retval=0; // nothing waiting on a non-blocking socket, as Windows' WSAEWOULDBLOCK above
else
m_lastError=errno;
}
#endif
}
else
{
retval=recvfrom(fd,(char *)msg,len,0,NULL,NULL);
#ifdef _WINDOWS
if (retval==SOCKET_ERROR)
{
if (WSAGetLastError() != WSAEWOULDBLOCK)
{
// failing because of a blocking error isn't really such a bad thing.
m_lastError = WSAGetLastError();
#ifdef DEBUG_LOGGING
static Int errCount = 0;
#endif
DEBUG_ASSERTLOG(errCount++ > 100, ("UDP::Read() - WSA error is %s\n", GetWSAErrorString(WSAGetLastError()).str()));
retval = -1;
} else {
retval = 0;
}
}
#endif
#if !defined(_WIN32)
if (retval==-1)
{
if (errno==EWOULDBLOCK || errno==EAGAIN)
retval=0; // nothing waiting on a non-blocking socket, as Windows' WSAEWOULDBLOCK above
else
m_lastError=errno;
}
#endif
}
return(retval);
}
#if !defined(_WIN32)
Int UDP::BindForBroadcasts(UnsignedShort port)
{
m_broadcastsOnly=TRUE;
#if defined(__linux__)
// Linux delivers a limited broadcast to a socket bound to 255.255.255.255, so the listener needs no
// wildcard and overlaps no lobby socket's address (see Bind). macOS refuses that bind (EADDRNOTAVAIL),
// so there the listener takes the wildcard and Read filters by destination.
return(Bind((UnsignedInt)INADDR_BROADCAST,port));
#else
return(Bind((UnsignedInt)INADDR_ANY,port));
#endif
}
/* Read for the wildcard listener (udp.h): the next datagram sent to 255.255.255.255, 0 when none is
waiting. Anything else, and anything whose destination the kernel did not report, is dropped. */
Int UDP::ReadBroadcast(unsigned char *msg,UnsignedInt len,sockaddr_in *from)
{
sockaddr_in source;
for (;;)
{
char control[64];
struct iovec part;
part.iov_base=msg;
part.iov_len=len;
struct msghdr header;
memset(&header,0,sizeof(header));
header.msg_name=&source;
header.msg_namelen=sizeof(source);
header.msg_iov=∂
header.msg_iovlen=1;
header.msg_control=control;
header.msg_controllen=sizeof(control);
Int retval=(Int)recvmsg(fd,&header,0);
if (retval==-1)
{
if (errno==EWOULDBLOCK || errno==EAGAIN)
return(0);
m_lastError=errno;
return(-1);
}
Bool toBroadcast=FALSE;
for (struct cmsghdr *c=CMSG_FIRSTHDR(&header); c!=NULL; c=CMSG_NXTHDR(&header,c))
{
#if defined(IP_RECVDSTADDR)
if (c->cmsg_level==IPPROTO_IP && c->cmsg_type==IP_RECVDSTADDR)
{
struct in_addr destination;
memcpy(&destination,CMSG_DATA(c),sizeof(destination));
toBroadcast=(destination.s_addr==htonl(INADDR_BROADCAST));
}
#else
if (c->cmsg_level==IPPROTO_IP && c->cmsg_type==IP_PKTINFO)
{
struct in_pktinfo info;
memcpy(&info,CMSG_DATA(c),sizeof(info));
toBroadcast=(info.ipi_addr.s_addr==htonl(INADDR_BROADCAST)); // the header's destination
}
#endif
}
if (!toBroadcast)
continue;
if (from!=NULL)
*from=source;
return(retval);
}
}
#endif
void UDP::ClearStatus(void)
{
#ifndef _WINDOWS
errno=0;
#endif
m_lastError = 0;
}
UDP::sockStat UDP::GetStatus(void)
{
Int status = m_lastError;
#ifdef _WINDOWS
//int status=WSAGetLastError();
if (status==0) return(OK);
else if (status==WSAEINTR) return(INTR);
else if (status==WSAEINPROGRESS) return(INPROGRESS);
else if (status==WSAECONNREFUSED) return(CONNREFUSED);
else if (status==WSAEINVAL) return(INVAL);
else if (status==WSAEISCONN) return(ISCONN);
else if (status==WSAENOTSOCK) return(NOTSOCK);
else if (status==WSAETIMEDOUT) return(TIMEDOUT);
else if (status==WSAEALREADY) return(ALREADY);
else if (status==WSAEWOULDBLOCK) return(WOULDBLOCK);
else if (status==WSAEBADF) return(BADF);
else return((UDP::sockStat)status);
#else
//int status=errno;
if (status==0) return(OK);
else if (status==EINTR) return(INTR);
else if (status==EINPROGRESS) return(INPROGRESS);
else if (status==ECONNREFUSED) return(CONNREFUSED);
else if (status==EINVAL) return(INVAL);
else if (status==EISCONN) return(ISCONN);
else if (status==ENOTSOCK) return(NOTSOCK);
else if (status==ETIMEDOUT) return(TIMEDOUT);
else if (status==EALREADY) return(ALREADY);
else if (status==EAGAIN) return(AGAIN);
else if (status==EWOULDBLOCK) return(WOULDBLOCK);
else if (status==EBADF) return(BADF);
else return(UNKNOWN);
#endif
}
/*
//
// Wait for net activity on this socket
//
int UDP::Wait(Int sec,Int usec,fd_set &returnSet)
{
fd_set inputSet;
FD_ZERO(&inputSet);
FD_SET(fd,&inputSet);
return(Wait(sec,usec,inputSet,returnSet));
}
*/
/*
//
// Wait for net activity on a list of sockets
//
int UDP::Wait(Int sec,Int usec,fd_set &givenSet,fd_set &returnSet)
{
Wtime timeout,timenow,timethen;
fd_set backupSet;
int retval=0,done,givenMax;
Bool noTimeout=FALSE;
timeval tv;
returnSet=givenSet;
backupSet=returnSet;
if ((sec==-1)&&(usec==-1))
noTimeout=TRUE;
timeout.SetSec(sec);
timeout.SetUsec(usec);
timethen+=timeout;
givenMax=fd;
for (UnsignedInt i=0; i<(sizeof(fd_set)*8); i++) // i=maxFD+1
{
if (FD_ISSET(i,&givenSet))
givenMax=i;
}
///DBGMSG("WAIT fd="<<fd<<" givenMax="<<givenMax);
done=0;
while( ! done)
{
if (noTimeout)
retval=select(givenMax+1,&returnSet,0,0,NULL);
else
{
timeout.GetTimevalMT(tv);
retval=select(givenMax+1,&returnSet,0,0,&tv);
}
if (retval>=0)
done=1;
else if ((retval==-1)&&(errno==EINTR)) // in case of signal
{
if (noTimeout==FALSE)
{
timenow.Update();
timeout=timethen-timenow;
}
if ((noTimeout==FALSE)&&(timenow.GetSec()==0)&&(timenow.GetUsec()==0))
done=1;
else
returnSet=backupSet;
}
else // maybe out of memory?
{
done=1;
}
}
///DBGMSG("Wait retval: "<<retval);
return(retval);
}
*/
// Set the kernel buffer sizes for incoming, and outgoing packets
//
// Linux seems to have a buffer max of 32767 bytes for this,
// (which is the default). If you try and set the size to
// greater than the default it just sets it to 32767.
Int UDP::SetInputBuffer(UnsignedInt bytes)
{
int retval,arg=bytes;
retval=setsockopt(fd,SOL_SOCKET,SO_RCVBUF,
(char *)&arg,sizeof(int));
if (retval==0)
return(TRUE);
else
return(FALSE);
}
// Same note goes for the output buffer
Int UDP::SetOutputBuffer(UnsignedInt bytes)
{
int retval,arg=bytes;
retval=setsockopt(fd,SOL_SOCKET,SO_SNDBUF,
(char *)&arg,sizeof(int));
if (retval==0)
return(TRUE);
else
return(FALSE);
}
// Get the system buffer sizes
int UDP::GetInputBuffer(void)
{
#if defined(_WIN32)
int retval,arg=0,len=sizeof(int);
#else
int retval,arg=0;
socklen_t len=sizeof(int);
#endif
retval=getsockopt(fd,SOL_SOCKET,SO_RCVBUF,
(char *)&arg,&len);
return(arg);
}
int UDP::GetOutputBuffer(void)
{
#if defined(_WIN32)
int retval,arg=0,len=sizeof(int);
#else
int retval,arg=0;
socklen_t len=sizeof(int);
#endif
retval=getsockopt(fd,SOL_SOCKET,SO_SNDBUF,
(char *)&arg,&len);
return(arg);
}
Int UDP::AllowBroadcasts(Bool status)
{
int retval;
#if defined(_WIN32)
BOOL val = status;
retval = setsockopt(fd, SOL_SOCKET, SO_BROADCAST, (char *)&val, sizeof(BOOL));
#else
int val = status; // SO_BROADCAST takes an int
retval = setsockopt(fd, SOL_SOCKET, SO_BROADCAST, (char *)&val, sizeof(int));
#endif
if (retval == 0)
return TRUE;
else
return FALSE;
}