path: root/src/jake2/sys/NET.java

/*
 * NET.java
 * Copyright (C) 2003
 * 
 * $Id: NET.java,v 1.1 2004-07-07 19:59:51 hzi Exp $
 */
/*
Copyright (C) 1997-2001 Id Software, 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 2
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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
package jake2.sys;

import jake2.Defines;
import jake2.Globals;
import jake2.game.cvar_t;
import jake2.qcommon.*;
import jake2.util.Lib;

import java.net.*;
import java.util.Arrays;

public final class NET extends Defines {

	public static netadr_t net_local_adr = new netadr_t();

	// 127.0.0.1
	public final static int LOOPBACK = 0x7f000001;

	public final static int MAX_LOOPBACK = 4;

	public static class loopmsg_t {
		byte data[] = new byte[Defines.MAX_MSGLEN];
		int datalen;
	};

	public static class loopback_t {
		public loopback_t()
		{
			msgs = new loopmsg_t[MAX_LOOPBACK];
			for (int n=0; n < MAX_LOOPBACK;n++)
			{
				msgs[n] = new loopmsg_t();
			}
		}
		loopmsg_t msgs[];
		
		int get, send;
	};

	public static loopback_t loopbacks[] = new loopback_t[2];
	static {
		loopbacks[0] = new loopback_t();
		loopbacks[1] = new loopback_t();
	}
	public static DatagramSocket ip_sockets[] = {null,null};
	//public static DatagramSocket ipx_sockets[] = new int[2];

	// we dont need beschissene sockaddr_in structs in java !

	//=============================================================================
	
//	void NetadrToSockadr (netadr_t *a, struct sockaddr_in *s)
//	{
//		memset (s, 0, sizeof(*s));
//	
//		if (a.type == NA_BROADCAST)
//		{
//			s.sin_family = AF_INET;
//	
//			s.sin_port = a.port;
//			*(int *)&s.sin_addr = -1;
//		}
//		else if (a.type == NA_IP)
//		{
//			s.sin_family = AF_INET;
//	
//			*(int *)&s.sin_addr = *(int *)&a.ip;
//			s.sin_port = a.port;
//		}
//	}
//	
//	void SockadrToNetadr (struct sockaddr_in *s, netadr_t *a)
//	{
//		*(int *)&a.ip = *(int *)&s.sin_addr;
//		a.port = s.sin_port;
//		a.type = NA_IP;
//	}
//	
	
	public static boolean CompareAdr(netadr_t a, netadr_t b) {
		if (a.ip[0] == b.ip[0] && a.ip[1] == b.ip[1] && a.ip[2] == b.ip[2] && a.ip[3] == b.ip[3] && a.port == b.port)
			return true;
		return false;
	}

	/*
	===================
	NET_CompareBaseAdr
	
	Compares without the port
	===================
	*/
	public static boolean NET_CompareBaseAdr(netadr_t a, netadr_t b) {
		if (a.type != b.type)
			return false;

		if (a.type == Defines.NA_LOOPBACK)
			return true;

		if (a.type == Defines.NA_IP) {
			if (a.ip[0] == b.ip[0] && a.ip[1] == b.ip[1] && a.ip[2] == b.ip[2] && a.ip[3] == b.ip[3])
				return true;
			return false;
		}

		/*
		if (a.type == Defines.NA_IPX) {
			for (int n = 0; n < 10; n++)
				if (a.ipx[n] != b.ipx[n])
					return false;

			//was:
			//if ((memcmp(a.ipx, b.ipx, 10) == 0)) 	return true;
			return true;
		}
		*/

		return false;
	}
	
	
	
	public static String AdrToString(netadr_t a) {
		//was:
		//static	char	s[64];
		//Com_sprintf (s, sizeof(s), "%i.%i.%i.%i:%i", a.ip[0], a.ip[1], a.ip[2], a.ip[3], ntohs(a.port));

		return "" + (a.ip[0] & 0xff) + "." + (a.ip[1] & 0xff) + "." + (a.ip[2] & 0xff) + "." + (a.ip[3] & 0xff) + ":" + a.port;
	}



	public static String NET_BaseAdrToString(netadr_t a) {
		//was:
		//static	char	s[64];
		//Com_sprintf (s, sizeof(s), "%i.%i.%i.%i", a.ip[0], a.ip[1], a.ip[2], a.ip[3]);
		return "" + (a.ip[0] & 0xff) + "." + (a.ip[1] & 0xff) + "." + (a.ip[2] & 0xff) + "." + (a.ip[3] & 0xff);
	}
	
	/*
	=============
	NET_StringToAdr
	
	localhost
	idnewt
	idnewt:28000
	192.246.40.70
	192.246.40.70:28000
	=============
	*/
//	boolean	NET_StringToSockaddr (char *s, struct sockaddr *sadr)
//	{
//		struct hostent	*h;
//		char	*colon;
//		char	copy[128];
//		
//		memset (sadr, 0, sizeof(*sadr));
//		((struct sockaddr_in *)sadr).sin_family = AF_INET;
//		
//		((struct sockaddr_in *)sadr).sin_port = 0;
//	
//		strcpy (copy, s);
//		// strip off a trailing :port if present
//		for (colon = copy ; *colon ; colon++)
//			if (*colon == ':')
//			{
//				*colon = 0;
//				((struct sockaddr_in *)sadr).sin_port = htons((short)atoi(colon+1));	
//			}
//		
//		if (copy[0] >= '0' && copy[0] <= '9')
//		{
//			*(int *)&((struct sockaddr_in *)sadr).sin_addr = inet_addr(copy);
//		}
//		else
//		{
//			if (! (h = gethostbyname(copy)) )
//				return 0;
//			*(int *)&((struct sockaddr_in *)sadr).sin_addr = *(int *)h.h_addr_list[0];
//		}
//		
//		return true;
//	}
//	
//	/*
//	=============
//	NET_StringToAdr
//	
//	localhost
//	idnewt
//	idnewt:28000
//	192.246.40.70
//	192.246.40.70:28000
//	=============
//	*/
//	boolean	NET_StringToAdr (char *s, netadr_t *a)
//	{
//		struct sockaddr_in sadr;
//		
//		if (!strcmp (s, "localhost"))
//		{
//			memset (a, 0, sizeof(*a));
//			a.type = NA_LOOPBACK;
//			return true;
//		}
//	
//		if (!NET_StringToSockaddr (s, (struct sockaddr *)&sadr))
//			return false;
//		
//		SockadrToNetadr (&sadr, a);
//	
//		return true;
//	}
//	
	
	public static boolean StringToAdr( String s, netadr_t a)
	{
		
		// bugfix bzw. hack cwei
		if (s.equalsIgnoreCase("localhost")) {
			a.type = Defines.NA_LOOPBACK;
			Arrays.fill(a.ip, (byte)0);
			a.port = 0;
			return true;
		}
		try
		{
			String[] address = s.split(":");
			InetAddress ia = InetAddress.getByName(address[0]);
			a.ip = ia.getAddress();
			a.type= NA_IP;
			if (address.length == 2) a.port = Integer.parseInt(address[1]); 
			return true;
		}
		catch
		(
			Exception e)
		{
			e.printStackTrace();
			return false;
		}		
	}
	
	
	
	public static boolean	IsLocalAddress (netadr_t adr)
	{
		return CompareAdr (adr, net_local_adr);
	}
	
	/*
	=============================================================================
	
	LOOPBACK BUFFERS FOR LOCAL PLAYER
	
	=============================================================================
	*/
	
	// trivial! this SHOULD work !
	public static boolean	NET_GetLoopPacket (int sock, netadr_t net_from, sizebuf_t net_message)
	{
		int		i;
		loopback_t	loop;
	
		loop = loopbacks[sock];
	
		if (loop.send - loop.get > MAX_LOOPBACK)
			loop.get = loop.send - MAX_LOOPBACK;
	
		if (loop.get >= loop.send)
			return false;
	
		i = loop.get & (MAX_LOOPBACK-1);
		loop.get++;
	
		//memcpy (net_message.data, loop.msgs[i].data, loop.msgs[i].datalen);
		System.arraycopy(loop.msgs[i].data, 0, net_message.data, 0, loop.msgs[i].datalen);
		net_message.cursize = loop.msgs[i].datalen;
		
		net_from.ip = net_local_adr.ip;
		net_from.port = net_local_adr.port;
		net_from.type = net_local_adr.type;
		
		return true;
	
	}
	
	
	// trivial! this SHOULD work !
	public static void NET_SendLoopPacket (int sock, int length, byte [] data, netadr_t to)
	{
		int		i;
		loopback_t	loop;
	
		loop = loopbacks[sock^1];
	
		// modulo 4
		i = loop.send & (MAX_LOOPBACK-1);
		loop.send++;
	
		//memcpy (loop.msgs[i].data, data, length);
		
		System.arraycopy(data,0,loop.msgs[i].data,0,length);
		loop.msgs[i].datalen = length;
	}
	
	
	private static DatagramPacket receivedatagrampacket = new DatagramPacket(new byte[65507], 65507);
	
	//=============================================================================	
	public static boolean GetPacket (int sock, netadr_t net_from, sizebuf_t net_message)
	{
		DatagramSocket	net_socket;
//		int 	ret;
//		struct sockaddr_in	from;
//		int			fromlen;
//		
//		int			protocol;
//		int			err;
	
		
		if (NET_GetLoopPacket (sock, net_from, net_message))
		{
			//Com.DPrintf("received packet on sock=" + sock + "  len=" + net_message.cursize+"\n");
			return true;
		}
		net_socket = ip_sockets[sock];
			
		if (net_socket == null)
			return false;
	
		try
		{
			net_socket.receive(receivedatagrampacket);
			
			// no timeout...

			net_from.ip = receivedatagrampacket.getAddress().getAddress();
			net_from.port = receivedatagrampacket.getPort();
			net_from.type = NA_IP;

			if (receivedatagrampacket.getLength() > net_message.maxsize)
			{
				Com.Printf ("Oversize packet from " + AdrToString(net_from) + "\n");
				return false;
			}
			int length = receivedatagrampacket.getLength();
			System.arraycopy(receivedatagrampacket.getData(), 0, net_message.data, 0, length);
			
			// bugfix cwei
			net_message.cursize = length; // set the size
			net_message.data[length] = 0; // sentinel
			
			
			//Com.DPrintf(Lib.hexDump(net_message.data, Math.max(length, length - (length % 16) + 16), false));
			//Com.DPrintf("\n");
			
			return true;

		}
		catch (SocketTimeoutException e1)
		{
			return false;
		}
		
		catch(Exception e)
		{
			Com.DPrintf ("NET_GetPacket: " + e + " from " + 	AdrToString(net_from) + "\n");
			return false;
		}
		
		
			//fromlen = sizeof(from);
			//ret = recvfrom (net_socket, net_message.data, net_message.maxsize
			//	, 0, (struct sockaddr *)&from, &fromlen);
				
			//SockadrToNetadr (&from, net_from);
	
//			if (ret == -1)
//			{
//				err = errno;
//	
//				if (err == EWOULDBLOCK || err == ECONNREFUSED)
//					continue;
//				Com_Printf ("NET_GetPacket: %s from %s\n", NET_ErrorString(),
//							NET_AdrToString(*net_from));
//				continue;
//			}
//	
//			if (ret == net_message.maxsize)
//			{
//				Com_Printf ("Oversize packet from %s\n", NET_AdrToString (*net_from));
//				continue;
//			}
//	
//			net_message.cursize = ret;
//			return true;
		 
	}
	
//	=============================================================================
	
	public static void SendPacket (int sock, int length, byte [] data, netadr_t to)
	{
		//Com.Printf("NET_SendPacket: sock=" + sock  + " len=" + length + "\n");
		//Com.DPrintf(Lib.hexDump(data, Math.max(length, length - (length % 16) + 16), false));
		//Com.DPrintf("\n");
		
		int		ret;
		//struct sockaddr_in	addr;
		
		DatagramSocket	net_socket;
	
		if ( to.type == NA_LOOPBACK )
		{
			NET_SendLoopPacket (sock, length, data, to);
			return;
		}
	
		if (to.type == NA_BROADCAST)
		{
			net_socket = ip_sockets[sock];
			if (net_socket==null)
				return;
		}
		else if (to.type == NA_IP)
		{
			net_socket = ip_sockets[sock];
			if (net_socket==null)
				return;
		}
		/*
		else if (to.type == NA_IPX)
		{
			net_socket = ipx_sockets[sock];
			if (net_socket==null)
				return;
		}
		else if (to.type == NA_BROADCAST_IPX)
		{
			net_socket = ipx_sockets[sock];
			if (!net_socket)
				return;
		}
		*/
		else
		{
			Com.Error (ERR_FATAL, "NET_SendPacket: bad address type");
			return;
		}
	
		//was:
		//NetadrToSockadr (&to, &addr);
	
		try
		{	//was:
			//ret = sendto (net_socket, data, length, 0, (struct sockaddr *)&addr, sizeof(addr) );
			
			DatagramPacket dp;
			
			if (to.type == NA_BROADCAST)
			{
				dp = new DatagramPacket(data, length, InetAddress.getByAddress(new byte[]{-1,-1,-1,-1}), to.port);
			}
			else
				dp = new DatagramPacket(data, length, to.getInetAddress(), to.port);
				
			net_socket.send(dp);
		}
		catch(Exception e)
		{
			Com.Printf ("NET_SendPacket ERROR: " + e + " to " + AdrToString (to) + "\n");
		}
	}
	
	
	//=============================================================================
	
	
	
	
	/*
	====================
	NET_OpenIP
	====================
	*/
	public static void NET_OpenIP ()
	{
		cvar_t	port, ip;
	
		port = Cvar.Get ("port", "" + Defines.PORT_SERVER, CVAR_NOSET);
		ip = Cvar.Get ("ip", "localhost", CVAR_NOSET);
	
		if (ip_sockets[NS_SERVER]==null)
			ip_sockets[NS_SERVER] = NET_Socket (ip.string, (int)port.value);
			
		if (ip_sockets[NS_CLIENT]==null)
			ip_sockets[NS_CLIENT] = NET_Socket (ip.string, Defines.PORT_ANY);
	}
	
	/*
	====================
	NET_OpenIPX
	====================
	*/
	public static void NET_OpenIPX ()
	{
	}
	
	
	/*
	====================
	NET_Config
	
	A single player game will only use the loopback code
	====================
	*/
	public static void Config (boolean multiplayer)
	{
		int i;
	
		if (!multiplayer)
		{	// shut down any existing sockets
			for (i=0 ; i<2 ; i++)
			{
				if (ip_sockets[i]!=null)
				{
					ip_sockets[i].close();
					ip_sockets[i] = null;
				}
				/*
				if (ipx_sockets[i])
				{
					ipx_sockets[i].close();
					ipx_sockets[i] = null;
				}
				*/
			}
		}
		else
		{	// open sockets
			NET_OpenIP ();
		}
	}
	
	
	//===================================================================
	
	
	/*
	====================
	NET_Init
	====================
	*/
	public static void NET_Init ()
	{
		//empty
	}	
	
	/*
	====================
	NET_Socket
	====================
	*/
	public static DatagramSocket NET_Socket (String ip, int port)
	{
		
		DatagramSocket newsocket = null;
		try
		{
			if (ip==null || ip.length()==0 || ip.equals("localhost"))
			{
				if (port == PORT_ANY)
				{
					newsocket = new DatagramSocket();
				}
				else
				{
					newsocket = new DatagramSocket(port);
				}
			}
			else
			{
				InetAddress ia = InetAddress.getByName(ip);
				newsocket = new DatagramSocket(port, ia);
			}
			
			newsocket.setBroadcast(true);
			// nonblocking (1 ms), 0== neverending infinite timeout
			newsocket.setSoTimeout(1);			
		}
		catch (Exception e)
		{
			newsocket = null;
		}
		
		return newsocket;
		
//		int newsocket;
//		//struct sockaddr_in address;
//		qboolean _true = true;
//		int	i = 1;
//	
//		if ((newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
//		{
//			Com.Printf ("ERROR: UDP_OpenSocket: socket: ", NET_ErrorString());
//			return 0;
//		}
//	
//		// make it non-blocking
//		if (ioctl (newsocket, FIONBIO, &_true) == -1)
//		{
//			Com_Printf ("ERROR: UDP_OpenSocket: ioctl FIONBIO:%s\n", NET_ErrorString());
//			return 0;
//		}
//	
//		// make it broadcast capable
//		if (setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) == -1)
//		{
//			Com_Printf ("ERROR: UDP_OpenSocket: setsockopt SO_BROADCAST:%s\n", NET_ErrorString());
//			return 0;
//		}
//	
//		if (!net_interface || !net_interface[0] || !stricmp(net_interface, "localhost"))
//			address.sin_addr.s_addr = INADDR_ANY;
//		else
//			NET_StringToSockaddr (net_interface, (struct sockaddr *)&address);
//	
//		if (port == PORT_ANY)
//			address.sin_port = 0;
//		else
//			address.sin_port = htons((short)port);
//	
//		address.sin_family = AF_INET;
//	
//		if( bind (newsocket, (void *)&address, sizeof(address)) == -1)
//		{
//			Com_Printf ("ERROR: UDP_OpenSocket: bind: %s\n", NET_ErrorString());
//			close (newsocket);
//			return 0;
//		}
//	
//		return newsocket;
	}
	
	
	/*
	====================
	NET_Shutdown
	====================
	*/
	public static void NET_Shutdown ()
	{
		Config (false);	// close sockets
	}
	
	
	/*
	====================
	NET_ErrorString
	====================
	*/
	public static String NET_ErrorString() {
		int code;

		//code = errno;
		//return strerror (code);
		return "errno can not yet resolved in java";
	}
	
	// sleeps msec or until net socket is ready
	public static void NET_Sleep(int msec)
	{
		if (ip_sockets[NS_SERVER]==null || (Globals.dedicated!=null && Globals.dedicated.value == 0))
			return; // we're not a server, just run full speed
		
		try {
			//TODO: check for 
			Thread.sleep(msec);
		}
		catch (InterruptedException e) {
		}
		//ip_sockets[NS_SERVER].
		
		
		// this should wait up to 100ms until a packet 
		/*
	    struct timeval timeout;
		fd_set	fdset;
		extern cvar_t *dedicated;
		extern qboolean stdin_active;
	
		if (!ip_sockets[NS_SERVER] || (dedicated && !dedicated.value))
			return; // we're not a server, just run full speed
	
		FD_ZERO(&fdset);
		if (stdin_active)
			FD_SET(0, &fdset); // stdin is processed too
		FD_SET(ip_sockets[NS_SERVER], &fdset); // network socket
		timeout.tv_sec = msec/1000;
		timeout.tv_usec = (msec%1000)*1000;
		select(ip_sockets[NS_SERVER]+1, &fdset, NULL, NULL, &timeout);
		*/
	}

}