ioquake
/
jedi-academy
mirror of https://github.com/ioquake/jedi-academy.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
jedi-academy/code/mac/mac_net.c

528 lines
11 KiB
C
Raw Blame History

#include "../client/client.h"
#include "mac_local.h"
#include <OpenTransport.h>
#include <OpenTptInternet.h>
static qboolean gOTInited;
static EndpointRef endpoint = kOTInvalidEndpointRef;
static EndpointRef resolverEndpoint = kOTInvalidEndpointRef;
#define MAX_IPS 16
static int numIP;
static InetInterfaceInfo sys_inetInfo[MAX_IPS];
static TUDErr uderr;
void RcvUDErr( void ) {
memset( &uderr, 0, sizeof( uderr ) );
uderr.addr.maxlen = 0;
uderr.opt.maxlen = 0;
OTRcvUDErr( endpoint, &uderr );
}
void HandleOTError( int err, const char *func ) {
int r;
static int lastErr;
if ( err != lastErr ) {
Com_Printf( "%s: error %i\n", func, err );
}
// if we don't call OTLook, things wedge
r = OTLook( endpoint );
if ( err != lastErr ) {
Com_DPrintf( "%s: OTLook %i\n", func, r );
}
switch( r ) {
case T_UDERR:
RcvUDErr();
if ( err != lastErr ) {
Com_DPrintf( "%s: OTRcvUDErr %i\n", func, uderr.error );
}
break;
default:
// Com_Printf( "%s: Unknown OTLook error %i\n", func, r );
break;
}
lastErr = err; // don't spew tons of messages
}
/*
=================
NotifyProc
=================
*/
pascal void NotifyProc(void* contextPtr, OTEventCode code,
OTResult result, void* cookie) {
switch( code ) {
case T_OPENCOMPLETE:
endpoint = cookie;
break;
case T_UDERR:
RcvUDErr();
break;
}
}
/*
=================
GetFourByteOption
=================
*/
static OTResult GetFourByteOption(EndpointRef ep,
OTXTILevel level,
OTXTIName name,
UInt32 *value)
{
OTResult err;
TOption option;
TOptMgmt request;
TOptMgmt result;
/* Set up the option buffer */
option.len = kOTFourByteOptionSize;
option.level= level;
option.name = name;
option.status = 0;
option.value[0] = 0;// Ignored because we're getting the value.
/* Set up the request parameter for OTOptionManagement to point
to the option buffer we just filled out */
request.opt.buf= (UInt8 *) &option;
request.opt.len= sizeof(option);
request.flags= T_CURRENT;
/* Set up the reply parameter for OTOptionManagement. */
result.opt.buf = (UInt8 *) &option;
result.opt.maxlen = sizeof(option);
err = OTOptionManagement(ep, &request, &result);
if (err == noErr) {
switch (option.status)
{
case T_SUCCESS:
case T_READONLY:
*value = option.value[0];
break;
default:
err = option.status;
break;
}
}
return (err);
}
/*
=================
SetFourByteOption
=================
*/
static OTResult SetFourByteOption(EndpointRef ep,
OTXTILevel level,
OTXTIName name,
UInt32 value)
{
OTResult err;
TOption option;
TOptMgmt request;
TOptMgmt result;
/* Set up the option buffer to specify the option and value to
set. */
option.len = kOTFourByteOptionSize;
option.level= level;
option.name = name;
option.status = 0;
option.value[0] = value;
/* Set up request parameter for OTOptionManagement */
request.opt.buf= (UInt8 *) &option;
request.opt.len= sizeof(option);
request.flags = T_NEGOTIATE;
/* Set up reply parameter for OTOptionManagement. */
result.opt.buf = (UInt8 *) &option;
result.opt.maxlen = sizeof(option);
err = OTOptionManagement(ep, &request, &result);
if (err == noErr) {
if (option.status != T_SUCCESS)
err = option.status;
}
return (err);
}
/*
=====================
NET_GetLocalAddress
=====================
*/
void NET_GetLocalAddress( void ) {
OSStatus err;
for ( numIP = 0 ; numIP < MAX_IPS ; numIP++ ) {
err = OTInetGetInterfaceInfo( &sys_inetInfo[ numIP ], numIP );
if ( err ) {
break;
}
Com_Printf( "LocalAddress: %i.%i.%i.%i\n",
((byte *)&sys_inetInfo[numIP].fAddress)[0],
((byte *)&sys_inetInfo[numIP].fAddress)[1],
((byte *)&sys_inetInfo[numIP].fAddress)[2],
((byte *)&sys_inetInfo[numIP].fAddress)[3] );
Com_Printf( "Netmask: %i.%i.%i.%i\n",
((byte *)&sys_inetInfo[numIP].fNetmask)[0],
((byte *)&sys_inetInfo[numIP].fNetmask)[1],
((byte *)&sys_inetInfo[numIP].fNetmask)[2],
((byte *)&sys_inetInfo[numIP].fNetmask)[3] );
}
}
/*
==================
Sys_InitNetworking
struct InetAddress
{
OTAddressType fAddressType; // always AF_INET
InetPort fPort; // Port number
InetHost fHost; // Host address in net byte order
UInt8 fUnused[8]; // Traditional unused bytes
};
typedef struct InetAddress InetAddress;
==================
*/
void Sys_InitNetworking( void ) {
OSStatus err;
OTConfiguration *config;
TBind bind, bindOut;
InetAddress in, out;
int i;
Com_Printf( "----- Sys_InitNetworking -----\n" );
// init OpenTransport
Com_Printf( "... InitOpenTransport()\n" );
err = InitOpenTransport();
if ( err != noErr ) {
Com_Printf( "InitOpenTransport() failed\n" );
Com_Printf( "------------------------------\n" );
return;
}
gOTInited = true;
// get an endpoint
Com_Printf( "... OTOpenEndpoint()\n" );
config = OTCreateConfiguration( kUDPName );
#if 1
endpoint = OTOpenEndpoint( config, 0, nil, &err);
#else
err = OTAsyncOpenEndpoint( config, 0, 0, NotifyProc, 0 );
if ( !endpoint ) {
err = 1;
}
#endif
if ( err != noErr ) {
endpoint = 0;
Com_Printf( "OTOpenEndpoint() failed\n" );
Com_Printf( "------------------------------\n" );
return;
}
// set non-blocking
err = OTSetNonBlocking( endpoint );
// scan for a valid port in our range
Com_Printf( "... OTBind()\n" );
for ( i = 0 ; i < 10 ; i++ ) {
in.fAddressType = AF_INET;
in.fPort = PORT_SERVER + i;
in.fHost = 0;
bind.addr.maxlen = sizeof( in );
bind.addr.len = sizeof( in );
bind.addr.buf = (unsigned char *)&in;
bind.qlen = 0;
bindOut.addr.maxlen = sizeof( out );
bindOut.addr.len = sizeof( out );
bindOut.addr.buf = (unsigned char *)&out;
bindOut.qlen = 0;
err = OTBind( endpoint, &bind, &bindOut );
if ( err == noErr ) {
Com_Printf( "Opened UDP endpoint at port %i\n",
out.fPort );
break;
}
}
if ( err != noErr ) {
Com_Printf( "Couldn't bind a local port\n" );
}
// get the local address for LAN client detection
NET_GetLocalAddress();
// set to allow broadcasts
err = SetFourByteOption( endpoint, INET_IP, IP_BROADCAST, T_YES );
if ( err != noErr ) {
Com_Printf( "IP_BROADCAST failed\n" );
}
// get an endpoint just for resolving addresses, because
// I was having crashing problems doing it on the same endpoint
config = OTCreateConfiguration( kUDPName );
resolverEndpoint = OTOpenEndpoint( config, 0, nil, &err);
if ( err != noErr ) {
resolverEndpoint = 0;
Com_Printf( "OTOpenEndpoint() for resolver failed\n" );
Com_Printf( "------------------------------\n" );
return;
}
in.fAddressType = AF_INET;
in.fPort = 0;
in.fHost = 0;
bind.addr.maxlen = sizeof( in );
bind.addr.len = sizeof( in );
bind.addr.buf = (unsigned char *)&in;
bind.qlen = 0;
bindOut.addr.maxlen = sizeof( out );
bindOut.addr.len = sizeof( out );
bindOut.addr.buf = (unsigned char *)&out;
bindOut.qlen = 0;
err = OTBind( resolverEndpoint, &bind, &bindOut );
Com_Printf( "------------------------------\n" );
}
/*
==================
Sys_ShutdownNetworking
==================
*/
void Sys_ShutdownNetworking( void ) {
Com_Printf( "Sys_ShutdownNetworking();\n" );
if ( endpoint != kOTInvalidEndpointRef ) {
OTUnbind( endpoint );
OTCloseProvider( endpoint );
endpoint = kOTInvalidEndpointRef;
}
if ( resolverEndpoint != kOTInvalidEndpointRef ) {
OTUnbind( resolverEndpoint );
OTCloseProvider( resolverEndpoint );
resolverEndpoint = kOTInvalidEndpointRef;
}
if (gOTInited) {
CloseOpenTransport();
gOTInited = false;
}
}
/*
=============
Sys_StringToAdr
Does NOT parse port numbers
idnewt
192.246.40.70
=============
*/
qboolean Sys_StringToAdr( const char *s, netadr_t *a ) {
OSStatus err;
TBind in, out;
InetAddress inAddr;
DNSAddress dnsAddr;
if ( !resolverEndpoint ) {
return qfalse;
}
memset( &in, 0, sizeof( in ) );
in.addr.buf = (UInt8 *) &dnsAddr;
in.addr.len = OTInitDNSAddress(&dnsAddr, (char *)s );
in.qlen = 0;
memset( &out, 0, sizeof( out ) );
out.addr.buf = (byte *)&inAddr;
out.addr.maxlen = sizeof( inAddr );
out.qlen = 0;
err = OTResolveAddress( resolverEndpoint, &in, &out, 10000 );
if ( err ) {
HandleOTError( err, "Sys_StringToAdr" );
return qfalse;
}
a->type = NA_IP;
*(int *)a->ip = inAddr.fHost;
return qtrue;
}
/*
==================
Sys_SendPacket
==================
*/
#define MAX_PACKETLEN 1400
void Sys_SendPacket( int length, const void *data, netadr_t to ) {
TUnitData d;
InetAddress inAddr;
OSStatus err;
if ( !endpoint ) {
return;
}
if ( length > MAX_PACKETLEN ) {
Com_Error( ERR_DROP, "Sys_SendPacket: length > MAX_PACKETLEN" );
}
inAddr.fAddressType = AF_INET;
inAddr.fPort = to.port;
if ( to.type == NA_BROADCAST ) {
inAddr.fHost = -1;
} else {
inAddr.fHost = *(int *)&to.ip;
}
memset( &d, 0, sizeof( d ) );
d.addr.len = sizeof( inAddr );
d.addr.maxlen = sizeof( inAddr );
d.addr.buf = (unsigned char *)&inAddr;
d.opt.len = 0;
d.opt.maxlen = 0;
d.opt.buf = NULL;
d.udata.len = length;
d.udata.maxlen = length;
d.udata.buf = (unsigned char *)data;
err = OTSndUData( endpoint, &d );
if ( err ) {
HandleOTError( err, "Sys_SendPacket" );
}
}
/*
==================
Sys_GetPacket
Never called by the game logic, just the system event queing
==================
*/
qboolean Sys_GetPacket ( netadr_t *net_from, msg_t *net_message ) {
TUnitData d;
InetAddress inAddr;
OSStatus err;
OTFlags flags;
if ( !endpoint ) {
return qfalse;
}
inAddr.fAddressType = AF_INET;
inAddr.fPort = 0;
inAddr.fHost = 0;
memset( &d, 0, sizeof( d ) );
d.addr.len = sizeof( inAddr );
d.addr.maxlen = sizeof( inAddr );
d.addr.buf = (unsigned char *)&inAddr;
d.opt.len = 0;
d.opt.maxlen = 0;
d.opt.buf = 0;
d.udata.len = net_message->maxsize;
d.udata.maxlen = net_message->maxsize;
d.udata.buf = net_message->data;
err = OTRcvUData( endpoint, &d, &flags );
if ( err ) {
if ( err == kOTNoDataErr ) {
return false;
}
HandleOTError( err, "Sys_GetPacket" );
return qfalse;
}
net_from->type = NA_IP;
net_from->port = inAddr.fPort;
*(int *)net_from->ip = inAddr.fHost;
net_message->cursize = d.udata.len;
return qtrue;
}
/*
==================
Sys_IsLANAddress
LAN clients will have their rate var ignored
==================
*/
qboolean Sys_IsLANAddress (netadr_t adr) {
int i;
int ip;
if ( adr.type == NA_LOOPBACK ) {
return qtrue;
}
if ( adr.type != NA_IP ) {
return qfalse;
}
for ( ip = 0 ; ip < numIP ; ip++ ) {
for ( i = 0 ; i < 4 ; i++ ) {
if ( ( adr.ip[i] & ((byte *)&sys_inetInfo[ip].fNetmask)[i] )
!= ( ((byte *)&sys_inetInfo[ip].fAddress)[i] & ((byte *)&sys_inetInfo[ip].fNetmask)[i] ) ) {
break;
}
}
if ( i == 4 ) {
return qtrue; // matches this subnet
}
}
return qfalse;
}
void NET_Sleep( int i ) {
}
Reference in New Issue View Git Blame Copy Permalink