Skip to content

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.

17.3 KB
Raw Blame
/*
**	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=&part;
    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;
}