hlmodmasterdlg.cpp

hl2 source code. Do not use it illegal.

}

void CHLModMasterDlg::NET_Init()
{
	netadr_t	address;
	WORD wVersionRequested;  
	WSADATA wsaData; 
	int err;
	//
	// find the port to run on
	//
	wVersionRequested = MAKEWORD(1, 1); 
	 
	err = WSAStartup(wVersionRequested, &wsaData); 
 	if (err != 0)
	{
		Sys_Error ("NET_Init: socket: %s %i", strerror(err), err);
		return;
	}
	
	//
	// open the socket
	//
	net_socket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if (net_socket == INVALID_SOCKET)
	{
		err = WSAGetLastError();
		Sys_Error ("NET_Init: socket: %s %i", strerror(err), err);
	}

	address.sin_family = AF_INET;
	address.sin_addr.s_addr = INADDR_ANY;
	address.sin_port = htons(net_hostport);
	if( bind (net_socket, (LPSOCKADDR)&address, sizeof(address)) == SOCKET_ERROR)
	{
		err = WSAGetLastError();
		Sys_Error ("NET_Init: bind: %s %i", strerror(errno), err);
	}

	//
	// determine local name & address
	//
	NET_GetLocalAddress ();
}

void CHLModMasterDlg::Master_Init()
{
	OpenNewLogfile ();
}

/*
===============
FindModByName
===============
*/
mod_t *CHLModMasterDlg::FindModByName ( char *modname )
{
	mod_t	*mod;
	const char *pdir;
	
	for (mod = modlist ; mod ; mod=mod->next)
	{
		pdir = GetValue( mod, "gamedir" );
		if ( pdir )
		{
			if ( !stricmp( pdir, modname ) )
			{
				return mod;
			}
		}
	}
	return NULL;
}

/*
===============
FindModByID
===============
*/
mod_t *CHLModMasterDlg::FindModByID ( int id )
{
	mod_t	*mod;
	const char *pId;
	
	for (mod = modlist ; mod ; mod=mod->next)
	{
		pId = GetValue( mod, "*uniqueid" );
		if ( pId )
		{
			if ( atoi( pId ) == id )
			{
				return mod;
			}
		}
	}
	return NULL;
}

int CHLModMasterDlg::ModSendSize( mod_t *pMod )
{
	int c = 0;
	keypair_t *kp;

	if ( !pMod )
	{
		return c;
	}

	kp = pMod->keys;
	while ( kp )
	{
		c += strlen( kp->key ) + 1;
		c += strlen( kp->value ) + 1;

		kp = kp->next;
	}

	return c;
}

/*
===============
Packet_GetModBatch
===============
*/
void CHLModMasterDlg::Packet_GetModBatch (void)
{
	mod_t	*mod;
	int		i = 0;
	int     nextid;
	int savepos;
	short numsent = 0;
	keypair_t *kp;
	const char *pId;

	msg_readcount = 1;

	// Read batch Start point
	nextid = (int)MSG_ReadLong();
	if ( nextid == 0 )  // First batch
	{
		UTIL_VPrintf ("Packet_GetBatch from %s\r\n", AdrToString (packet_from));
	}

	sprintf (reply, "%c%c%c%c%c\r\n", 255,255,255,255, M2A_MODLIST );
	i += 6;

	savepos = i;
	i += sizeof( int );
	i += sizeof( short ); // Save off # written, too

	mod = modlist;
	// If nextid was not zero, find the mod after the one requested:
	if ( nextid != 0 )
	{
		for ( ; mod ; mod=mod->next)
		{
			pId = GetValue( mod, "*uniqueid" );
			if ( pId )
			{
				if ( atoi( pId ) <= nextid )
				{
					break;
				}
			}
		}
	}
	
	for ( ; mod ; mod=mod->next)
	{
		// FIXME:  Need a function to estimate size of next mod.
		if ( ( i + ModSendSize( mod ) + 1 ) > sizeof( reply ) )
			break;

		kp = mod->keys;

		while ( kp )
		{
			strcpy( reply+i, kp->key );
			i += strlen( kp->key ) + 1;
			strcpy( reply+i, kp->value );
			i += strlen( kp->value ) + 1;

			kp = kp->next;
		}

		// Now write a terminal 0
		*(unsigned char *)&reply[i] = '\0';
		i += sizeof( unsigned char );

		numsent++;
	}

	// Now write the final one we got to, if any.
	if ( mod ) // Still more in list, had to abort early
	{
		pId = GetValue( mod, "*uniqueid" );
		*(int *)&reply[ savepos ] = atoi( pId );
	}
	else // Last packet, no more mods...
	{
		*(int *)&reply[ savepos ] = 0;  // FLAG that we are done sending.
	}
	
	*( short * )&reply[ savepos + sizeof(int ) ] = numsent;

	Sys_SendPacket (&packet_from, (unsigned char *)reply, i);	
}

/*
===============
Packet_RequestMod
===============
*/
void CHLModMasterDlg::Packet_RequestMod (void)
{
	mod_t	*mod;
	int     id;
	const char *pname, *pdir;
	const char *req;
	char szNumber[ 32 ];
	int requests;

	msg_readcount = 1;

	// Read batch Start point
	id = (int)MSG_ReadLong();

	mod = FindModByID( id );
	if ( !mod )
	{
		UTIL_VPrintf ("Packet_RequestMod bad id from %s\r\n", AdrToString (packet_from));
		return;
	}

	req = GetValue( mod, "requests" );
	if ( req )
	{
		requests = atoi( req );
		requests++;
		sprintf( szNumber, "%i", requests );

		SetKey( mod, "requests", szNumber );
	}

	pname = GetValue( mod, "game" );
	if ( !pname )
	{
		pname = "?";
	}

	pdir  = GetValue( mod, "gamedir" );
	if ( !pdir )
	{
		pdir = "?";
	}

	UTIL_VPrintf ("Packet_RequestMod %s:%s from %s\r\n", pdir, pname, AdrToString (packet_from) );

}

/*
===============
PacketFilter
Discard the packet if it is from the banned list
===============
*/
BOOL CHLModMasterDlg::PacketFilter (void)
{
	banned_sv_t* banned;

	banned = bannedips;
	while ( banned )
	{
		if ( CompareBaseAdr( banned->address, packet_from ) )
			{
			UTIL_VPrintf ("banned ip packet from: %s\r\n", AdrToString(packet_from));
			return FALSE;
			}
		banned = banned->next;
	}
	return TRUE;
}

/*
===============
PacketCommand
===============
*/
void CHLModMasterDlg::PacketCommand (void)
{
	curtime = (int)Sys_FloatTime(); // time(NULL);
	static char szChannel[1024];
	
	CheckForNewLogfile ();

	if (!PacketFilter())
		return;

	if (m_bShowPackets)
		UTIL_VPrintf ("%s\r\n", packet_data);

	msg_readcount = 2;		/*  skip command and \r\n */
	
	if (packet_length > 1400)
	{
		UTIL_VPrintf ("Bad packet size: %i\r\n", packet_length);
		return;
	}
	
	switch (packet_data[0])
	{
	case A2M_SELECTMOD:
		Packet_RequestMod();
		break;
	case A2M_GETMODLIST:
		Packet_GetModBatch ();
		break;	
	default:
		UTIL_VPrintf ("Bad PacketCommand from %s\r\n", AdrToString (packet_from));
		break;
	}	

	UpdateCount();
}

/*
===============
OpenNewLogfile
===============
*/
void CHLModMasterDlg::OpenNewLogfile (void)
{
	time_t	t;
	struct	tm	*tmv;
	char	name[32];
	int		iTry;

	if ( m_bGenerateLogs == FALSE )
		return;

	t = time(NULL);
	tmv = localtime(&t);
	
	m_nCurrentDay = tmv->tm_mday;
	for (iTry = 0 ; iTry < 999 ; iTry++)
	{
		sprintf (name, "%i_%i_%i_%i.log"
		, (int)tmv->tm_mon + 1, (int)tmv->tm_mday, (int)tmv->tm_year, iTry);
		logfile = fopen (name, "r");
		if (!logfile)
			break;
	}
	if (logfile)
		Sys_Error ("Logfile creation failed");

	logfile = fopen (name, "w");
	if (!logfile)
		Sys_Error ("Logfile creation failed");

	UTIL_VPrintf ("logfile %s created\r\n", name);
}

/*
===============
CheckForNewLogfile
===============
*/
void CHLModMasterDlg::CheckForNewLogfile (void)
{
	struct	tm	*tmv;
	time_t ct;

	if ( m_bGenerateLogs == FALSE )
		return;
	
	time (&ct);
	tmv = localtime (&ct);

	if (tmv->tm_mday == m_nCurrentDay)
		return;

	UTIL_VPrintf ("changing to new day logfile\r\n");
	if (logfile)
		{
		fclose(logfile);
		logfile = NULL;
		}
	OpenNewLogfile ();
}

/*
====================
Sys_Error
====================
*/
void CHLModMasterDlg::Sys_Error (char *string, ...)
{
	va_list		argptr;

	if (net_socket)
		closesocket (net_socket);
	if (logfile)
		{
		fclose(logfile);
		logfile = NULL;
		}

	UTIL_Printf ("\r\nSys_Error:\r\n");
	va_start (argptr, string);
	vprintf (string, argptr);
	
	AfxMessageBox(string);

	UTIL_Printf ("\r\n");
	va_end (argptr);

	exit (1);
}

void CHLModMasterDlg::NET_GetLocalAddress (void)
{
	struct hostent	*h;
	char	buff[MAXHOSTNAMELEN];
	struct sockaddr_in	address;
	int		namelen;

	if ( m_strLocalIPAddress != "" )
		{
		BOOL success;
		success = NET_StringToSockaddr((LPCTSTR)m_strLocalIPAddress,(sockaddr*)(&address));
		if ( success == FALSE )
			Sys_Error ("cannot parse ip address on command line");
		net_local_adr.sin_addr = address.sin_addr;
		}
	else
		{
		gethostname(buff, MAXHOSTNAMELEN);
		buff[MAXHOSTNAMELEN-1] = 0;

		if (! (h = gethostbyname(buff)) )
			Sys_Error ("gethostbyname failed");
		if ( h->h_addr_list[1] != NULL )
			Sys_Error ("multiple local ip addresses found. must specify one on the command line.");
		*(int *)&net_local_adr.sin_addr = *(int *)h->h_addr_list[0];
		}

	namelen = sizeof(address);
	if (getsockname (net_socket, (struct sockaddr *)&address, &namelen) == SOCKET_ERROR)
		Sys_Error ("NET_Init: getsockname:", strerror(errno));
	net_local_adr.sin_port = address.sin_port;

	UTIL_Printf("IP address %s\r\n", AdrToString (net_local_adr) );
}

void CHLModMasterDlg::UTIL_VPrintf (char *msg, ...)
{
	char szText[256];
	char szOrig[512];
	va_list	argptr;
	char szTime[32];
	char szDate[64];

	va_start (argptr, msg);
	vprintf (msg, argptr);
	
	vsprintf(szOrig, msg, argptr);

	_strtime( szTime );
	_strdate( szDate );
	sprintf( szText, "%s/%s:  %s", szDate, szTime, szOrig );

	// Add int the date and time
	if ( logfile )
		fprintf (logfile, szText);
	UTIL_Printf(szText);
	va_end (argptr);
}

void CHLModMasterDlg::UTIL_Printf (char *msg, ...)
{
	UpdateData(TRUE);
	if (!m_bShowTraffic)
		return;

	char szText[256];
	va_list	argptr;
	
	va_start (argptr, msg);
	vprintf (msg, argptr);
//	if ( logfile )
//		vfprintf (logfile, msg, argptr);
	vsprintf(szText, msg, argptr);
	va_end (argptr);
		
	CEdit *pEdit;

	pEdit = (CEdit *)GetDlgItem(IDC_EDIT1);
	if (pEdit)
	{
		CString curText;
		pEdit->GetWindowText(curText);
		int nLength;

		if ((curText.GetLength() + strlen(szText)) > 16384)
		{
			curText.Empty();
			pEdit->SetWindowText(curText);
		};

		nLength = curText.GetLength();
		
		pEdit->SetSel(nLength, nLength);
		pEdit->ReplaceSel(szText);
	};
}

/*
==============
Sys_SendPacket
==============
*/
void CHLModMasterDlg::Sys_SendPacket (netadr_t *to, byte *data, int len)
{
	int ret;

	ret = sendto (net_socket, (char *)data, len, 0, (struct sockaddr *)to, sizeof(*to));
	if (ret == -1)
	{
		errno = WSAGetLastError();
		UTIL_VPrintf ("ERROR: Sys_SendPacket: (%i) %s\r\n", errno, strerror(errno));
	}

	m_fBytesSent += len;
}

char *CHLModMasterDlg::MSG_ReadString (void)
{
	char	*start;
	BOOL    bMore;
	
	start = (char *)packet_data + msg_readcount;
	
	for ( ; msg_readcount < packet_length ; msg_readcount++)
		if (((packet_data[msg_readcount] == '\r') ||
		     (packet_data[msg_readcount] == '\n'))
		|| packet_data[msg_readcount] == 0)
			break;
	
	bMore = packet_data[msg_readcount] != '\0';

	packet_data[msg_readcount] = 0;
	msg_readcount++;
	
	// skip any \r\n
	if (bMore)
	{
		while (packet_data[msg_readcount] == '\r' ||
			   packet_data[msg_readcount] == '\n')
		{
		   msg_readcount++;
		};

	}
	return start;
}

unsigned char CHLModMasterDlg::MSG_ReadByte( void )
{
	unsigned char *c;

	if ( msg_readcount >= packet_length )
	{
		UTIL_Printf( "Overflow reading byte\n" );
		return (unsigned char)-1;
	}

	c = (unsigned char *)packet_data + msg_readcount;
	msg_readcount += sizeof( unsigned char );

	return *c;
}

unsigned short CHLModMasterDlg::MSG_ReadShort( void )
{
	unsigned char *c;
	unsigned short r;

	if ( msg_readcount >= packet_length )
	{
		UTIL_Printf( "Overflow reading short\n" );
		return (unsigned short)-1;
	}

	c = (unsigned char *)packet_data + msg_readcount;
	msg_readcount += sizeof( unsigned short );

	r = *(unsigned short *)c;

	return r;
}

unsigned int CHLModMasterDlg::MSG_ReadLong( void )
{
	unsigned char *c;
	unsigned int r;

	if ( msg_readcount >= packet_length )
	{
		UTIL_Printf( "Overflow reading int\n" );
		return (unsigned int)-1;
	}

	c = (unsigned char *)packet_data + msg_readcount;
	msg_readcount += sizeof( unsigned int );

	r = *(unsigned int *)c;

	return r;
}

/*
==============
GetPacketCommand
==============
*/
void CHLModMasterDlg::GetPacketCommand (void)
{