mirrors
/
CnC_Remastered_Collection
mirror of https://github.com/electronicarts/CnC_Remastered_Collection.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
CnC_Remastered_Collection/REDALERT/WSPIPX.CPP

447 lines
17 KiB
C++
Raw Normal View History

Initial Source Code commit Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.
2020-05-27 20:16:20 +01:00
//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code 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.
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : Command & Conquer *
* *
* $Archive:: /Sun/WSPIPX.cpp $*
* *
* $Author:: Joe_b $*
* *
* $Modtime:: 8/20/97 10:54a $*
* *
* $Revision:: 6 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* *
* IPXInterfaceClass::IPXInterfaceClass -- Class constructor *
* IPXInterfaceClass::Get_Network_Card_Address -- Get the ID of the installed net card *
* IPXInterfaceClass::Open_Socket -- Opens an IPX socket for reading & writing *
* IPXInterfaceClass::Message_Handler -- Handler for windows messages relating to IPX *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "function.h"
#include "wspipx.h"
#include "ipxaddr.h"
#include <assert.h>
#include <stdio.h>
/***********************************************************************************************
* IPXInterfaceClass::IPXInterfaceClass -- Class constructor *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/4/97 11:41AM ST : Created *
*=============================================================================================*/
IPXInterfaceClass::IPXInterfaceClass (void) : WinsockInterfaceClass()
{
/*
** Set the net and node addressed to their default values.
*/
memset ( BroadcastNet, 0xff, sizeof (BroadcastNet) );
memset ( BroadcastNode, 0xff, sizeof (BroadcastNode) );
memset ( MyNode, 0xff, sizeof (MyNode) );
}
/***********************************************************************************************
* IPXInterfaceClass::Get_Network_Card_Address -- Get the ID of the installed net card *
* *
* *
* *
* INPUT: card number to retrieve ID for *
* ptr to addr to return ID in *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/1/97 3:04PM ST : Created *
*=============================================================================================*/
bool IPXInterfaceClass::Get_Network_Card_Address (int card_number, SOCKADDR_IPX *addr)
{
int cbOpt;
int cbAddr = sizeof( SOCKADDR_IPX );
SOCKET s;
SOCKADDR_IPX Addr;
IPX_ADDRESS_DATA IpxData;
/*
** Create a temporary IPX socket.
*/
s = socket( AF_IPX, SOCK_DGRAM, NSPROTO_IPX );
if ( s == SOCKET_ERROR ) {
assert ( s != SOCKET_ERROR );
return (false);
}
/*
** Socket must be bound prior to calling IPX_MAX_ADAPTER_NUM
*/
memset( &Addr, 0, sizeof( Addr ));
Addr.sa_family = AF_IPX;
int err = bind( s, (SOCKADDR*) &Addr, cbAddr);
if ( err == SOCKET_ERROR ) {
assert ( err != SOCKET_ERROR );
closesocket (s);
return (false);
}
memset( &IpxData, 0, sizeof(IpxData));
/*
** Specify which adapter to check.
*/
IpxData.adapternum = card_number;
cbOpt = sizeof( IpxData );
/*
** Get information for the current adapter.
*/
err = getsockopt( s, NSPROTO_IPX, IPX_ADDRESS, (char*) &IpxData, &cbOpt );
if ( err == SOCKET_ERROR ) {
assert ( err != SOCKET_ERROR );
closesocket (s);
return (false);
}
/*
** IpxData contains the address for the current adapter.
** The network number will be needed later for broadcasts as the net number ff,ff,ff,ff
** doesn't work under NT.
**
** Note: Due to a bug in Win95s implementation of Winsock, only the netnum & nodenum
** values are correctly returned. NT returns all expected values. ST - 7/31/97 0:57AM
*/
memcpy (addr->sa_netnum, IpxData.netnum, sizeof (addr->sa_netnum));
memcpy (BroadcastNet, IpxData.netnum, sizeof (addr->sa_netnum));
memcpy (addr->sa_nodenum, IpxData.nodenum, sizeof (addr->sa_nodenum));
closesocket (s);
return (true);
}
/***********************************************************************************************
* IPXInterfaceClass::Open_Socket -- Opens an IPX socket for reading & writing *
* *
* *
* *
* INPUT: SOCKET number to open. This is usually VIRGIN_SOCKET *
* *
* OUTPUT: true if socket was opened without error *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/4/97 5:54PM ST : Created *
*=============================================================================================*/
bool IPXInterfaceClass::Open_Socket( SOCKET socketnum )
{
SOCKADDR_IPX addr;
bool delay = true;
int err;
/*
** If Winsock is not initialised then do it now.
*/
if ( !WinsockInitialised ) {
if ( !Init()) return ( false );;
}
IPXSocketNumber = socketnum;
/*
** Set up the addr structure for the IPX socket
*/
addr.sa_family = AF_IPX;
memset (addr.sa_netnum, 0, sizeof (addr.sa_netnum));
memset (addr.sa_nodenum, -1, sizeof (addr.sa_nodenum));
addr.sa_socket = htons ( socketnum );
/*
** Create the socket.
*/
Socket = socket (AF_NS, SOCK_DGRAM, NSPROTO_IPX);
if (Socket == INVALID_SOCKET) {
char out[128];
sprintf (out, "TS: Failed to create IPX socket - error code %d.\n", GetLastError() );
OutputDebugString (out);
assert ( Socket != INVALID_SOCKET );
closesocket(Socket);
return ( false );
}
/*
** Get the network card address. This is needed so we can bind the socket to the net card.
*/
if ( !Get_Network_Card_Address (0, &addr)){
closesocket ( Socket );
return ( false );
}
/*
** Bind the IPX socket to the network card.
*/
if (bind ( Socket, (const struct sockaddr *) &addr, 16) == SOCKET_ERROR ){
char out[128];
sprintf (out, "TS: IPX socket bind failed with error code %d.\n", GetLastError() );
OutputDebugString (out);
assert ( false );
closesocket(Socket);
return ( false );;
}
/*
** Set the various options for this IPX socket
*/
unsigned long optval = true;
int packet_type = 4;
/*
** The SO_BROADCAST option allows broadcasting on this socket. This shouldn't be needed
** except for the bug in the Win95 implementation of Winsock which causes broadcasts to
** fail if it isn't set.
*/
if ( setsockopt ( Socket, SOL_SOCKET, SO_BROADCAST, (char*)&optval, sizeof(optval) ) == SOCKET_ERROR ) {
char out[128];
sprintf (out, "TS: Failed to set IPX socket option SO_BROADCAST - error code %d.\n", GetLastError() );
OutputDebugString (out);
assert ( false );
}
/*
** Set the value in the packet type field for outgoing packets.
*/
err = setsockopt ( Socket, NSPROTO_IPX, IPX_PTYPE, (char*)&packet_type, sizeof(packet_type));
if ( err == INVALID_SOCKET ) {
char out[128];
sprintf (out, "TS: Failed to set IPX protocol option IPX_PTYPE - error code %d.\n", GetLastError() );
OutputDebugString (out);
assert ( err != INVALID_SOCKET );
}
/*
** Ignore all incoming packets not of this type.
*/
err = setsockopt ( Socket, NSPROTO_IPX, IPX_FILTERPTYPE, (char*)&packet_type, sizeof(packet_type));
if ( err == INVALID_SOCKET ) {
char out[128];
sprintf (out, "TS: Failed to set IPX protocol option IPX_FILTERTYPE - error code %d.\n", GetLastError() );
OutputDebugString (out);
assert ( err != INVALID_SOCKET );
}
/*
** Set the the base class socket options for buffer sizes.
*/
WinsockInterfaceClass::Set_Socket_Options();
/*
** Woohoo!
*/
return ( true );
}
/***********************************************************************************************
* IPXInterfaceClass::Message_Handler -- Handler for windows messages relating to IPX *
* *
* *
* *
* INPUT: Usual windoze message handler stuff *
* *
* OUTPUT: 0 if message was handled *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/4/97 5:55PM ST : Created *
*=============================================================================================*/
long IPXInterfaceClass::Message_Handler(HWND , UINT message, UINT , LONG lParam)
{
int addr_len; // Length of address structure
int rc; // Result code
SOCKADDR_IPX addr; // Winsock IPX addressing structure
WinsockBufferType *packet; // Ptr to packet
NetNumType netnum;
NetNodeType nodenum;
/*
** We only handle IPX events.
*/
if ( message != WM_IPXASYNCEVENT ) return ( 1 );
switch ( WSAGETSELECTEVENT(lParam) ) {
/*
** Read event. Winsock has data it would like to give us.
*/
case FD_READ:
/*
** Clear any outstanding errors on the socket.
*/
rc = WSAGETSELECTERROR(lParam);
if (rc != 0) {
Clear_Socket_Error (Socket);
return(0);
}
/*
** Call the Winsock recvfrom function to get the outstanding packet.
*/
addr_len = sizeof(addr);
rc = recvfrom ( Socket, (char*) ReceiveBuffer, sizeof (ReceiveBuffer), 0, (LPSOCKADDR)&addr, &addr_len );
if (rc == SOCKET_ERROR) {
if (WSAGetLastError() != WSAEWOULDBLOCK) {
Clear_Socket_Error (Socket);
}
return(0);
}
/*
** rc is the number of bytes received from Winsock
*/
if ( rc ) {
/*
** Make a copy of the address that this packet came from.
*/
memcpy ( netnum, addr.sa_netnum, sizeof (netnum) );
memcpy ( nodenum, addr.sa_nodenum, sizeof (nodenum) );
/*
** If this packet was from me then ignore it.
*/
if ( !memcmp (netnum, BroadcastNet, sizeof (BroadcastNet)) && !memcmp(nodenum, MyNode, sizeof (MyNode)) ) {
return (0);
}
/*
** Create a new buffer and store this packet in it.
*/
packet = new WinsockBufferType;
packet->BufferLen = rc;
memcpy ( packet->Buffer, ReceiveBuffer, rc );
IPXAddressClass *paddress = (IPXAddressClass*) (&packet->Address[0]);
paddress->Set_Address ( netnum, nodenum );
InBuffers.Add ( packet );
}
return(0);
/*
** Write event. We send ourselves this event when we have more data to send. This
** event will also occur automatically when a packet has finished being sent.
*/
case FD_WRITE:
/*
** Clear any outstanding erros on the socket.
*/
rc = WSAGETSELECTERROR(lParam);
if (rc != 0) {
Clear_Socket_Error ( Socket );
return(0);
}
/*
** If there are no packets waiting to be sent then bail.
*/
while ( OutBuffers.Count() != 0 ) {
int packetnum = 0;
/*
** Get a pointer to the packet.
*/
packet = OutBuffers [ packetnum ];
/*
** Set up the address structure of the outgoing packet
*/
addr.sa_family = AF_IPX;
addr.sa_socket = htons ( IPXSocketNumber );
/*
** Set up the address as either a broadcast address or the given address
*/
if ( packet->IsBroadcast ) {
memcpy ( addr.sa_netnum, BroadcastNet, sizeof (BroadcastNet) );
memcpy ( addr.sa_nodenum, BroadcastNode, sizeof (BroadcastNode) );
}else{
IPXAddressClass *paddress = (IPXAddressClass*) (&packet->Address[0]);
paddress->Get_Address ( netnum, nodenum );
memcpy ( addr.sa_netnum, netnum, sizeof (netnum) );
memcpy ( addr.sa_nodenum, nodenum, sizeof (nodenum) );
}
/*
** Send it.
** If we get a WSAWOULDBLOCK error it means that Winsock is unable to accept the packet
** at this time. In this case, we clear the socket error and just exit. Winsock will
** send us another WRITE message when it is ready to receive more data.
*/
rc = sendto ( Socket, (const char*) packet->Buffer, packet->BufferLen, 0, (LPSOCKADDR)&addr, sizeof (addr) );
if (rc == SOCKET_ERROR){
if (WSAGetLastError() != WSAEWOULDBLOCK) {
Clear_Socket_Error (Socket);
break;
}
}
/*
** Delete the sent packet.
*/
OutBuffers.Delete ( packetnum );
delete packet;
}
return(0);
}
return (0);
}