Example #1
0
int NET_GetPacket(netsrc_t sock, netadr_t *net_from, sizebuf_t *net_message)
{
#ifndef DEDICATED_ONLY
	if (NET_GetLoopPacket (sock, net_from, net_message))
		return 1;
#endif

	int net_socket = ip_sockets[sock];

	if (!net_socket)
		return 0;

	// TODO: failed packets?

	uint16_t packetSize = fuzzReadUint16();
	uint16_t port = fuzzReadUint16();
	uint32_t ip4 = fuzzReadUint32();

	packetSize = std::min(packetSize, static_cast<uint16_t>(net_message->maxsize));

	net_from->type = NA_IP;
	net_from->port = port;
	net_from->ip[0] = ((ip4      ) & 0xFF);
	net_from->ip[1] = ((ip4 >>  8) & 0xFF);
	net_from->ip[2] = ((ip4 >> 16) & 0xFF);
	net_from->ip[3] = ((ip4 >> 24) & 0xFF);
	fuzzRead(reinterpret_cast<char *>(net_message->data), packetSize);
	net_message->cursize = packetSize;

	return 1;
}
Example #2
0
qboolean NET_GetPacket(struct qw_connection *qwc, enum netsrc sock, struct sizebuf_s *message, struct netaddr *from)
{
	int ret;
	struct SysSocket *net_socket;

	if (NET_GetLoopPacket(qwc, sock, message, from))
		return true;

	net_socket = qwc->netdata->sockets[sock];
	if (net_socket == 0)
		return false;

	ret = Sys_Net_Receive(qwc->netdata->sysnetdata, net_socket, message->data, message->maxsize, from);

	if (ret <= 0)
	{
		if (ret < 0)
			Com_Printf("%s: Network error.\n", __func__);

		return false;
	}

	message->cursize = ret;

	return true;
}
Example #3
0
qbool NET_GetPacketEx (netsrc_t netsrc, qbool delay)
{
#ifndef SERVERONLY
	if (delay)
		return NET_PacketQueueRemove(&delay_queue_get, &net_message, &net_from);
#endif

#ifndef SERVERONLY
	if (NET_GetLoopPacket(netsrc, &net_from, &net_message))
		return true;
#endif

	if (NET_GetUDPPacket(netsrc, &net_from, &net_message))
		return true;

// TCPCONNECT -->
#ifndef SERVERONLY
	if (netsrc == NS_CLIENT && cls.sockettcp != INVALID_SOCKET && NET_GetTCPPacket_CL(netsrc, &net_from, &net_message))
		return true;
#endif

#ifndef CLIENTONLY
	if (netsrc == NS_SERVER && svs.tcpstreams && NET_GetTCPPacket_SV(netsrc, &net_from, &net_message))
		return true;
#endif
// <--TCPCONNECT

	return false;
}
Example #4
0
qboolean NET_GetPacket (netsrc_t sock) {
	int ret;
	struct sockaddr_in	from;
	int fromlen;
	int net_socket;

	if (NET_GetLoopPacket (sock))
		return true;

	net_socket = ip_sockets[sock];
	if (net_socket == -1)
		return false;

	fromlen = sizeof(from);
	ret = recvfrom (net_socket, net_message_buffer, sizeof(net_message_buffer), 0, (struct sockaddr *)&from, &fromlen);
	if (ret == -1) {
		if (errno == EWOULDBLOCK)
			return false;
		if (errno == ECONNREFUSED)
			return false;
		Sys_Printf ("NET_GetPacket: %s\n", strerror(errno));
		return false;
	}

	net_message.cursize = ret;
	SockadrToNetadr (&from, &net_from);

	return ret;
}
Example #5
0
qboolean	NET_GetPacket (netsrc_t sock, netadr_t *net_from, sizebuf_t *net_message)
{
	int 	ret;
	struct sockaddr_storage	from;
	socklen_t	fromlen;
	int		net_socket;
	int		protocol;
	int		err;

	if (NET_GetLoopPacket (sock, net_from, net_message))
		return true;

	for (protocol = 0 ; protocol < 3 ; protocol++)
	{
		if (protocol == 0)
			net_socket = ip_sockets[sock];
		else if (protocol == 1)
                        net_socket = ip6_sockets[sock];
                else
			net_socket = ipx_sockets[sock];

		if (!net_socket)
			continue;

		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;
	}

	return false;
}
Example #6
0
/* <d40a2> ../engine/net_ws.c:1391 */
qboolean NET_GetPacket_internal(netsrc_t sock)
{
	net_messages_t *pmsg;                                        //  1393
	qboolean bret;                                                //  1396

	NET_AdjustLag();
	NET_ThreadLock();
	if (NET_GetLoopPacket(sock, &in_from, &in_message))
	{
		bret = NET_LagPacket(1, sock, &in_from, &in_message);
	}
	else
	{
		if (!use_thread)
		{
			bret = NET_QueuePacket(sock);
			if (!bret)
				bret = NET_LagPacket(0, sock, 0, 0);
		}
		else
		{
			bret = NET_LagPacket(0, sock, 0, 0);
		}
	}
	
	if (bret)
	{
		Q_memcpy(net_message.data, in_message.data, in_message.cursize);
		net_message.cursize = in_message.cursize;
		Q_memcpy(&net_from, &in_from, 0x14u);
		NET_ThreadUnlock();
		return bret;
	}

	pmsg = messages[sock];
	if (pmsg)
	{
		net_message.cursize = pmsg->buffersize;
		messages[sock] = pmsg->next;
		Q_memcpy(net_message.data, pmsg->buffer, net_message.cursize);
		net_from = pmsg->from;
		msg_readcount = 0;
		NET_FreeMsg(pmsg);
		bret = 1;
	}
	NET_ThreadUnlock();
	return bret;
}
/*
 ==================
 NET_GetPacket
 ==================
*/
bool NET_GetPacket (netSrc_t sock, netAdr_t *from, msg_t *msg){

	struct sockaddr	adr;
	int				adrLen = sizeof(adr);
	int 			result, error;

	if (NET_GetLoopPacket(sock, from, msg))
		return true;

	if (net.sockets[sock] == INVALID_SOCKET)
		return false;

	result = recvfrom(net.sockets[sock], (char *)msg->data, msg->maxSize, 0, (struct sockaddr *)&adr, &adrLen);

	NET_SockAdrToNetAdr(&adr, from);

	if (result == SOCKET_ERROR){
		error = WSAGetLastError();

		// WSAEWOULDBLOCK and WSAECONNRESET are silent
		if (error == WSAEWOULDBLOCK || error == WSAECONNRESET)
			return false;

		Com_Printf(S_COLOR_RED "NET_GetPacket: %s from %s\n", NET_ErrorString(), NET_AddressToString(*from));
		return false;
	}

	if (result == msg->maxSize){
		Com_Printf(S_COLOR_RED "NET_GetPacket: oversize packet from %s\n", NET_AddressToString(*from));
		return false;
	}

	msg->curSize = result;

	net.packetsReceived[sock]++;
	net.bytesReceived[sock] += result;

	return true;
}
Example #8
0
int	NET_GetPacket (netsrc_t sock, netadr_t *net_from, sizebuf_t *net_message)
{
	if (NET_GetLoopPacket (sock, net_from, net_message))
		return 1;

	if (!wsState) {
		// not initialized yet
		return 0;
	}

	if (wsState->pendingData.empty()) {
#ifdef EMSCRIPTEN

		return 0;

#else  // EMSCRIPTEN

		libwebsocket_service(wsState->websocketContext, 0);

#endif  // EMSCRIPTEN
	}

	// don't iterate via reference, recvPacket will alter the data structure
	for (auto conn : wsState->pendingData) {
		if (conn->recvPacket(net_message)) {
			*net_from = conn->addr;

			net_packets_in++;
			net_total_in += net_message->cursize;

			return 1;
		}
		// not enough data for a complete packet, try next connection
	}

	return 0;
}
Example #9
0
/*
=================
Com_EventLoop

Returns last event time
=================
*/
int Com_EventLoop( void ) {
	sysEvent_t	ev;
	netadr_t	evFrom;
	byte		bufData[MAX_MSGLEN];
	msg_t		buf;

	MSG_Init( &buf, bufData, sizeof( bufData ) );

	while ( 1 ) {
		ev = Com_GetEvent();

		// if no more events are available
		if ( ev.evType == SE_NONE ) {
			// manually send packet events for the loopback channel
			while ( NET_GetLoopPacket( NS_CLIENT, &evFrom, &buf ) ) {
				CL_PacketEvent( evFrom, &buf );
			}

			while ( NET_GetLoopPacket( NS_SERVER, &evFrom, &buf ) ) {
				// if the server just shut down, flush the events
				if ( com_sv_running->integer ) {
					Com_RunAndTimeServerPacket( &evFrom, &buf );
				}
			}

			return ev.evTime;
		}


		switch ( ev.evType ) {
		default:
			Com_Error( ERR_FATAL, "Com_EventLoop: bad event type %i", ev.evType );
			break;
        case SE_NONE:
            break;
		case SE_KEY:
			CL_KeyEvent( ev.evValue, ev.evValue2, ev.evTime );
			break;
		case SE_CHAR:
			CL_CharEvent( ev.evValue );
			break;
		case SE_MOUSE:
			CL_MouseEvent( ev.evValue, ev.evValue2, ev.evTime );
			break;
		case SE_JOYSTICK_AXIS:
			CL_JoystickEvent( ev.evValue, ev.evValue2, ev.evTime );
			break;
		case SE_CONSOLE:
			Cbuf_AddText( (char *)ev.evPtr );
			Cbuf_AddText( "\n" );
			break;
		case SE_PACKET:
			evFrom = *(netadr_t *)ev.evPtr;
			buf.cursize = ev.evPtrLength - sizeof( evFrom );

			// we must copy the contents of the message out, because
			// the event buffers are only large enough to hold the
			// exact payload, but channel messages need to be large
			// enough to hold fragment reassembly
			if ( (unsigned)buf.cursize > (unsigned)buf.maxsize ) {
				Com_Printf("Com_EventLoop: oversize packet\n");
				continue;
			}
			memcpy( buf.data, (byte *)((netadr_t *)ev.evPtr + 1), buf.cursize );
			if ( com_sv_running->integer ) {
				Com_RunAndTimeServerPacket( &evFrom, &buf );
			} else {
				CL_PacketEvent( evFrom, &buf );
			}
			break;
		}

		// free any block data
		if ( ev.evPtr ) {
			Z_Free( ev.evPtr );
		}
	}
}
Example #10
0
/*
=============
NET_GetPacket
=============
*/
int NET_GetPacket (netsrc_t sock, netadr_t *net_from, sizebuf_t *net_message)
{
	int 	ret, err;
	socklen_t fromlen;
	struct sockaddr from;

	if (NET_GetLoopPacket (sock, net_from, net_message))
		return 1;

	if (ip_sockets[sock] == INVALID_SOCKET)
		return 0;

	fromlen = sizeof(from);
	ret = recvfrom (ip_sockets[sock], (char *)net_message->data, net_message->maxsize
		, 0, (struct sockaddr *)&from, &fromlen);

	SockadrToNetadr (&from, net_from);

	if (ret == SOCKET_ERROR)
	{
#ifdef _WIN32
		err = WSAGetLastError();

		switch( err ) {
		case WSAEWOULDBLOCK:
			// wouldblock is silent
			break;
		case WSAECONNRESET:
			if( !net_ignore_icmp->integer ) {
				return -1;
			}
			break;
		case WSAEMSGSIZE:
			Com_Printf ("NET_GetPacket: Oversize packet from %s\n", NET_AdrToString(net_from));
			break;
		default:
			Com_Printf ("NET_GetPacket: %s from %s\n", NET_ErrorString(), NET_AdrToString(net_from));
			break;
		}
#else
		err = errno;

		switch( err ) {
		case EWOULDBLOCK:
			// wouldblock is silent
			break;
		case ECONNREFUSED:
			if( !net_ignore_icmp->integer ) {
				return -1;
			}
			break;
		default:
			Com_Printf ("NET_GetPacket: %s from %s\n", NET_ErrorString(), NET_AdrToString(net_from));
			break;
		}
#endif
		return 0;
	}

	if (ret == net_message->maxsize) {
		Com_Printf ("Oversize packet from %s\n", NET_AdrToString (net_from));
		return 0;
	}

	net_message->cursize = ret;
	return 1;
}
Example #11
0
qboolean
NET_GetPacket(netsrc_t sock, netadr_t *net_from, sizebuf_t *net_message)
{
	int ret;
	struct sockaddr_storage from;
	socklen_t fromlen;
	int net_socket;
	int protocol;
	int err;

	if (NET_GetLoopPacket(sock, net_from, net_message))
	{
		return true;
	}

	for (protocol = 0; protocol < 3; protocol++)
	{
		if (protocol == 0)
		{
			net_socket = ip_sockets[sock];
		}
		else if (protocol == 1)
		{
			net_socket = ip6_sockets[sock];
		}
		else
		{
			net_socket = ipx_sockets[sock];
		}

		if (!net_socket)
		{
			continue;
		}

		fromlen = sizeof(from);
		ret = recvfrom(net_socket, (char *)net_message->data,
				net_message->maxsize, 0, (struct sockaddr *)&from,
				&fromlen);

		SockadrToNetadr(&from, net_from);

		if (ret == -1)
		{
			err = WSAGetLastError();

			if (err == WSAEWOULDBLOCK)
			{
				continue;
			}

			if (err == WSAEMSGSIZE)
			{
				Com_Printf("Warning:  Oversize packet from %s\n",
						NET_AdrToString(*net_from));
				continue;
			}

			if (dedicated->value) /* let dedicated servers continue after errors */
			{
				Com_Printf("NET_GetPacket: %s from %s\n", NET_ErrorString(),
						NET_AdrToString(*net_from));
			}
			else
			{
				Com_Printf("NET_GetPacket: %s from %s",
						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;
	}

	return false;
}
Example #12
0
int	NET_GetPacket (netsrc_t sock, netadr_t *net_from, sizebuf_t *net_message)
{
	if (NET_GetLoopPacket (sock, net_from, net_message))
		return 1;

	int net_socket = ip_sockets[sock];

	if (!net_socket)
		return 0;

	struct sockaddr_in	from;
	uint32 fromlen = sizeof(from);

	int ret = recvfrom (net_socket, net_message->data, net_message->maxsize
		, 0, (struct sockaddr *)&from, &fromlen);

	if (ret == -1)
	{
		//linux makes this needlessly complex, couldn't just return the source of the error in from, oh no...
		struct probehdr	rcvbuf;
		struct iovec	iov;
		struct msghdr	msg;
		struct cmsghdr	*cmsg;

		char		cbuf[1024];

#ifdef SOCK_EXTENDED_ERR
		struct sock_extended_err *e;
#endif  // SOCK_EXTENDED_ERR

		int err = errno;

		memset (&rcvbuf, 0, sizeof(rcvbuf));

		iov.iov_base = &rcvbuf;
		iov.iov_len = sizeof (rcvbuf);

		memset (&from, 0, sizeof(from));

		msg.msg_name = (void *)&from;
		msg.msg_namelen = sizeof (from);
		msg.msg_iov = &iov;
		msg.msg_iovlen = 1;
		msg.msg_flags = 0;
		msg.msg_control = cbuf;
		msg.msg_controllen = sizeof (cbuf);

		for (;;)
		{
			ret = recvmsg (net_socket, &msg, MSG_ERRQUEUE);
			if (ret == -1)
			{
				if (errno == EWOULDBLOCK || errno == EAGAIN)
				{
					if (err == EWOULDBLOCK || err == EAGAIN)
					{
						return 0;
					}
					else
					{
						errno = err;
						Com_Printf ("NET_GetPacket: %s\n", LOG_NET, NET_ErrorString());
						return 0;
					}
				}
				else
				{
					Com_DPrintf ("NET_GetPacket: recvmsg(): %s\n", NET_ErrorString());
					return 0;
				}
			}
			else if (!ret)
			{
				Com_DPrintf ("NET_GetPacket: recvmsg(): EOF\n");
				return 0;
			}

			errno = err;
			Com_DPrintf ("NET_GetPacket: Called recvmsg() for extended error details for %s\n", NET_ErrorString());

			//linux 2.2 (maybe others) fails to properly fill in the msg_name structure.
			Com_DPrintf ("(msgname) family %d, host: %s, port: %d, flags: %d\n", from.sin_family, inet_ntoa (from.sin_addr), from.sin_port, msg.msg_flags);

#ifdef SOCK_EXTENDED_ERR
			e = NULL;

			for (cmsg = CMSG_FIRSTHDR (&msg); cmsg; cmsg = CMSG_NXTHDR (&msg, cmsg))
			{
				if (cmsg->cmsg_level == SOL_IP)
				{
					if (cmsg->cmsg_type == IP_RECVERR)
					{
						e = (struct sock_extended_err *) CMSG_DATA (cmsg);
					}
					else
						Com_DPrintf ("cmsg type = %d\n", cmsg->cmsg_type);
				}
			}

			if (!e)
			{
				Com_DPrintf ("NET_GetPacket: recvmsg(): no extended info available\n");
				continue;
			}

			if (e->ee_origin == SO_EE_ORIGIN_ICMP)
			{
				//for some unknown reason, the kernel zeroes out the port in SO_EE_OFFENDER, so this is pretty much useless
				struct sockaddr_in *sin = (struct sockaddr_in *)SO_EE_OFFENDER(e);
				Com_DPrintf ("(ICMP) family %d, host: %s, port: %d\n", sin->sin_family, inet_ntoa (sin->sin_addr), sin->sin_port);

				//but better than nothing if using  buggy kernel?
				if (from.sin_family == AF_UNSPEC)
				{
					memcpy (&from, sin, sizeof(from));
					//can't trust port, may be buggy kernel (again)
					from.sin_port = 0;
				}
			}
			else
			{
				Com_DPrintf ("NET_GetPacket: recvmsg(): error origin is %d\n", e->ee_origin);
				continue;
			}

			SockadrToNetadr (&from, net_from);

			switch (e->ee_errno)
			{
				case ECONNREFUSED:
				case EHOSTUNREACH:
				case ENETUNREACH:
					Com_Printf ("NET_GetPacket: %s from %s\n", LOG_NET, strerror(e->ee_errno), NET_AdrToString (net_from));
					if (net_ignore_icmp->intvalue)
						return 0;
					else
						return -1;
				default:
					Com_Printf ("NET_GetPacket: %s from %s\n", LOG_NET, strerror(e->ee_errno), NET_AdrToString (net_from));
					continue;
			}
#endif  // SOCK_EXTENDED_ERR
		}

		//errno = err;
		//Com_Printf ("NET_GetPacket: %s\n", LOG_NET, NET_ErrorString());
		return 0;
	}

	net_packets_in++;
	net_total_in += ret;

	SockadrToNetadr (&from, net_from);

	if (ret == net_message->maxsize)
	{
		Com_Printf ("Oversize packet from %s\n", LOG_NET, NET_AdrToString (net_from));
		return 0;
	}

	net_message->cursize = ret;
	
	return 1;
}
Example #13
0
int	NET_GetPacket (netsrc_t sock, netadr_t *net_from, sizebuf_t *net_message)
{
	int 	ret;
	struct sockaddr from;
	int		fromlen;
	int		err;

#ifndef DEDICATED_ONLY
	if (NET_GetLoopPacket (sock, net_from, net_message))
		return 1;
#endif

	if (!ip_sockets[sock])
		return 0;

	fromlen = sizeof(from);
	ret = recvfrom (ip_sockets[sock], (char *)net_message->data, net_message->maxsize
		, 0, (struct sockaddr *)&from, &fromlen);

	if (ret == -1)
	{
		err = WSAGetLastError();

		if (err == WSAEWOULDBLOCK)// || (err == WSAECONNRESET && Com_ServerState()))
			return 0;

		if (err == WSAECONNRESET)
		{
			if (net_ignore_icmp->intvalue)
			{
				return -2;
			}
			else
			{
				SockadrToNetadr (&from, net_from);
				return -1; 
			}
		}
#ifndef NO_SERVER
		if (dedicated->intvalue)	// let dedicated servers continue after errors
			Com_Printf ("NET_GetPacket: %s\n", LOG_NET, NET_ErrorString());
		else
#endif

			//r1: WSAEMSGSIZE can be caused by someone UDP packeting a client.
			//FIXME: somehow get the current clients connected server address
			//       here and if any packets that didn't originate from the server
			//       cause errors, silently ignore them.
			if (err != WSAEMSGSIZE)
				Com_Printf ("WARNING! NET_GetPacket: %s\n", LOG_NET, NET_ErrorString());
			return 0;
	}

	net_packets_in++;
	net_total_in += ret;

	SockadrToNetadr (&from, net_from);

	if (ret == net_message->maxsize)
	{
		Com_Printf ("Oversize packet from %s\n", LOG_NET, NET_AdrToString (net_from));
		return 0;
	}

	net_message->cursize = ret;
	return 1;
}
Example #14
0
qboolean	NET_GetPacket (netsrc_t sock, netadr_t *net_from, sizebuf_t *net_message)
{
	int 	ret;
	struct sockaddr_in	from;
	int		fromlen;
	int		net_socket;
	int		protocol;
	int		err;

	if (NET_GetLoopPacket (sock, net_from, net_message))
		return true;

	for (protocol = 0 ; protocol < 2 ; protocol++)
	{
		if (protocol == 0)
			net_socket = ip_sockets[sock];
		else
			net_socket = ipx_sockets[sock];

		if (!net_socket)
			continue;

		fromlen = sizeof(from);
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Switching to the equivalent function (and data structures) in the platform:
		//ret = recvfrom (net_socket, net_message->data, net_message->maxsize
		//	, 0, (struct sockaddr *)&from, &fromlen);
		//if (ret == -1)
		ret = net_recvfrom (net_socket, net_message->data, net_message->maxsize > 4096 ? 4096 : net_message->maxsize
			, 0, (struct sockaddr *)&from, &fromlen);
		if (ret < 0)
// <<< FIX
		{
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Switching to the equivalent data structures in the platform:
			//err = errno;

			//if (err == EWOULDBLOCK || err == ECONNREFUSED)
			if (ret == -EWOULDBLOCK || ret == -ECONNREFUSED)
// <<< FIX
				continue;
			Com_Printf ("NET_GetPacket: %s from %s\n", NET_ErrorString(),
						NET_AdrToString(*net_from));
			continue;
		}

// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Adjusting for previous fixes:
		//if (ret == net_message->maxsize)
		if((ret == net_message->maxsize)||(ret >= 4096))
// <<< FIX
		{
			Com_Printf ("Oversize packet from %s\n", NET_AdrToString (*net_from));
			continue;
		}

		net_message->cursize = ret;
		SockadrToNetadr (&from, net_from);
		return true;
	}

	return false;
}
Example #15
0
qboolean	NET_GetPacket (netsrc_t sock, netadr_t *net_from, sizebuf_t *net_message)
{
	int 	ret;
	struct	sockaddr from;
	int		fromlen;
	int		net_socket;
	int		protocol;
	int		err;

	if (NET_GetLoopPacket (sock, net_from, net_message))
		return true;

	for (protocol = 0 ; protocol < 2 ; protocol++)
	{
		if (protocol == 0)
			net_socket = ip_sockets[sock];
		else
			net_socket = ipx_sockets[sock];

		if (!net_socket)
			continue;

		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 = WSAGetLastError();
 
			if (err == WSAEWOULDBLOCK)
				continue;
			if (err == WSAEMSGSIZE)
			{
				Com_Printf (S_COLOR_YELLOW"Warning:  Oversize packet from %s\n",
						NET_AdrToString(*net_from));
				continue;
			}
			// Knightmare- added Jitspoe's fix for WSAECONNRESET bomb-out
			if (err == WSAECONNRESET)
			{
				Com_Printf ("NET_GetPacket: %s from %s\n", NET_ErrorString(),
					NET_AdrToString(*net_from));
				// drop this client to not flood the console with above message
				SV_DropClientFromAdr (*net_from);
				continue;
			}
			//if (dedicated->value)	// let dedicated servers continue after errors
			// let servers continue after errors
				Com_Printf ("NET_GetPacket: %s from %s\n", NET_ErrorString(),
					NET_AdrToString(*net_from));
			//else
			//	Com_Error (ERR_DROP, "NET_GetPacket: %s from %s", 
			//		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;
	}

	return false;
}