// reset queues for new level
void network_state_reset( void )
{
#ifdef __BLACKBERRY__
#else
last_state_in_sync = last_state_out_sync = 0;
for (int i = 0; i < NET_PACKET_QUEUE; i++)
{
if (packet_state_in[i])
{
SDLNet_FreePacket(packet_state_in[i]);
packet_state_in[i] = NULL;
}
}
for (int i = 0; i < NET_PACKET_QUEUE; i++)
{
if (packet_state_in_xor[i])
{
SDLNet_FreePacket(packet_state_in_xor[i]);
packet_state_in_xor[i] = NULL;
}
}
for (int i = 0; i < NET_PACKET_QUEUE; i++)
{
if (packet_state_out[i])
{
SDLNet_FreePacket(packet_state_out[i]);
packet_state_out[i] = NULL;
}
}
last_state_in_tick = SDL_GetTicks();
#endif
}
void net_ip_t::close(){
delete inbound;
delete outbound;
SDLNet_FreePacket(inbound_packet);
outbound_packet->data = NULL;
SDLNet_FreePacket(outbound_packet);
SDLNet_Quit();
}
//Free the used memory and close the used socket
Server::~Server()
{
SDLNet_FreePacket(input);
SDLNet_FreePacket(output);
SDLNet_FreePacket(ret);
SDLNet_UDP_Close(sock);
SDLNet_Quit();
cout << "SERVER CLOSED";
}
/* I_ShutdownNetwork
*
* Shutdown the network code
*/
void I_ShutdownNetwork(void)
{
SDLNet_FreePacket(udp_packet);
/*
SDLNet_Quit();
*/
}
void UDPNetwork::Close()
{
SDLNet_UDP_Close(m_socket);
SDLNet_FreePacket(m_packet);
m_socket = nullptr;
m_packet = nullptr;
}
OSErr NetDDPCloseSocket(short portNumber)
{
//fdprintf("NetDDPCloseSocket\n");
// ZZZ: shut down receiving thread
if(sReceivingThread) {
sKeepListening = false;
SDL_WaitThread(sReceivingThread, NULL);
sReceivingThread = NULL;
}
if(sSocketSet) {
SDLNet_FreeSocketSet(sSocketSet);
sSocketSet = NULL;
}
// (CB's code follows)
if (sUDPPacketBuffer) {
SDLNet_FreePacket(sUDPPacketBuffer);
sUDPPacketBuffer = NULL;
SDLNet_UDP_Close(sSocket);
sSocket = NULL;
}
return 0;
}
bool UDPNetworkSocket::sendData(const uint8_t * _data, size_t _dataSize, const IPv4Address & _address) {
if (!isOpen())
return false;
#ifdef UTIL_HAVE_LIB_SDL2_NET
UDPpacket * p = SDLNet_AllocPacket(_dataSize);
std::copy(_data, _data + _dataSize, p->data);
p->len = _dataSize;
p->address = toSDLIPv4Address(_address);
int i = SDLNet_UDP_Send(data->udpsock, -1, p);
SDLNet_FreePacket(p);
p = nullptr;
return i > 0;
#elif defined(__linux__) || defined(__unix__) || defined(ANDROID)
sockaddr_in sockAddr = toSockaddr(_address);
ssize_t bytesSent = sendto(data->udpSocket, _data, _dataSize, 0, reinterpret_cast<const sockaddr *> (&sockAddr), sizeof(sockAddr));
if (bytesSent == -1) {
int error = errno;
WARN(std::string(strerror(error)));
return false;
}
return true;
#else
return false;
#endif
}
//! \return number of targets
int UDPNetworkSocket::sendData(const uint8_t * _data, size_t _dataSize) {
if (!isOpen() || data->targets.empty() )
return 0;
int sendCounter = 0;
#ifdef UTIL_HAVE_LIB_SDL2_NET
UDPpacket * p = SDLNet_AllocPacket(_dataSize);
if (p == nullptr) {
std::cerr << "SDLNet_AllocPacket: " << SDLNet_GetError() << "\n";
return sendCounter;
}
std::copy(_data, _data + _dataSize, p->data);
p->len = _dataSize;
for(const auto & target : data->targets) {
p->address = toSDLIPv4Address(target);
sendCounter += SDLNet_UDP_Send(data->udpsock, -1, p);
}
SDLNet_FreePacket(p);
p = nullptr;
#elif defined(__linux__) || defined(__unix__) || defined(ANDROID)
for(const auto & target : data->targets) {
sockaddr_in sockAddr = toSockaddr(target);
ssize_t bytesSent = sendto(data->udpSocket, _data, _dataSize, 0, reinterpret_cast<const sockaddr *> (&sockAddr), sizeof(sockaddr_in));
if (bytesSent == -1) {
int error = errno;
WARN(std::string(strerror(error)));
} else {
++sendCounter;
}
}
#endif
return sendCounter;
}
UDPNetworkSocket::Packet * UDPNetworkSocket::receive() {
if (!isOpen())
return nullptr;
#ifdef UTIL_HAVE_LIB_SDL2_NET
UDPpacket * p = SDLNet_AllocPacket(data->maxPktSize + 1);
if (p == nullptr) {
std::cerr << "SDLNet_AllocPacket: " << SDLNet_GetError() << "\n";
return nullptr;
}
int r = SDLNet_UDP_Recv(data->udpsock, p);
if (r <= 0) {
SDLNet_FreePacket(p);
return nullptr;
}
if (p->len == p->maxlen) {
WARN("Maximum UDP packet size exceeded.");
}
auto myPacket = new Packet(p->data, p->len);
myPacket->source = fromSDLIPv4Address(p->address);
SDLNet_FreePacket(p);
return myPacket;
#elif defined(__linux__) || defined(__unix__) || defined(ANDROID)
std::vector<uint8_t> buffer(data->maxPktSize + 1);
sockaddr_in sockAddr;
memset(&sockAddr, 0, sizeof(sockaddr_in));
socklen_t len = sizeof(sockAddr);
const ssize_t bytesReceived = recvfrom(data->udpSocket, buffer.data(), buffer.size(), 0, reinterpret_cast<sockaddr *>(&sockAddr), &len);
if (bytesReceived == -1) {
int error = errno;
if(error != EAGAIN && error != EWOULDBLOCK)
WARN(std::string(strerror(error)));
return nullptr;
}
if (bytesReceived == buffer.size()) {
WARN("Maximum UDP packet size exceeded.");
} else {
buffer.resize(bytesReceived);
}
Packet * packet = new Packet(std::move(buffer));
packet->source = fromSockaddr(sockAddr);
return packet;
#else
return nullptr;
#endif
}
void UDP_NetListener::threadFunc(UDP_NetListener * sh)
{
// Create UDP socket.
UDPsocket socket = SDLNet_UDP_Open(LISTENER_PORT_NUMBER);
if (socket == NULL) {
NETMSG("Failed to open UDP socket: %s", SDLNet_GetError());
return;
}
// Create packet.
UDPpacket * const packet = SDLNet_AllocPacket(MAX_PACKET_SIZE);
if (packet == NULL) {
NETMSG("Failed to create UDP packet: %s", SDLNet_GetError());
SDLNet_UDP_Close(socket);
return;
}
sh->cond.lock();
while (!sh->cond.shouldExit()) {
int result = SDLNet_UDP_Recv(socket, packet);
if (result == 1) {
//unlock to give signalExit() a chance in case we're receiving a large number of packets
sh->cond.unlock();
/*if (packet->len > broadcastMsgPrefix.size() &&
memcmp(packet->data, broadcastMsgPrefix.c_str(), broadcastMsgPrefix.size()) == 0) {
IPaddress addr;
addr.host = packet->address.host;
SDLNet_Write16(HOST_PORT_NUMBER, &addr.port);
packet->data[packet->len - 1] = 0; //prevent buffer overflow on invalid data
if (strlen(reinterpret_cast<char *>(packet->data)) > broadcastMsgPrefix.size()) {
SDL_LockMutex(sp->sessionsMutex);
sp->reportSession(addr, reinterpret_cast<char *>(packet->data) + broadcastMsgPrefix.size());
SDL_UnlockMutex(sp->sessionsMutex);
}
}*/
sh->cond.lock();
}
else {
if (result != 0) {
NETMSG("UDP receive error");
}
sh->cond.waitMs(SESSION_LISTENER_PERIOD);
}
}
sh->cond.unlock();
SDLNet_FreePacket(packet);
SDLNet_UDP_Close(socket);
}
void SDLNet_FreePacketV(UDPpacket **packetV)
{
if ( packetV ) {
int i;
for ( i=0; packetV[i]; ++i ) {
SDLNet_FreePacket(packetV[i]);
}
free(packetV);
}
}
void Peer::Update()
{
int toCheck = 0;
if (sockets.size())
{
toCheck = SDLNet_CheckSockets(watch, 0);
// Print(toCheck);
}
if (toCheck)
{
for(auto & i: sockets)
{
if (SDLNet_SocketReady(i))
{
UDPpacket * packet = SDLNet_AllocPacket(512);
if (SDLNet_UDP_Recv(i, packet))
{
if (packet != nullptr)
{
Print("PLEASE PROCESS THIS PACKET\n");
Print("%s:%s:%i %i\n", getIP(packet->address.host), std::to_string(SDLNet_Read16(&packet->address.port)), packet->channel, packet->data);
// Print(getIP(packet->address.host), ":", std::to_string(SDLNet_Read16(&packet->address.port)), ":", packet->channel, packet->data);
}
}
SDLNet_FreePacket(packet);
}
}
}
if (toCheck == -1)
Print("toCheck getting errors in update\n");
/*if (bound)
{
UDPpacket *packet = SDLNet_AllocPacket(512);
if (packet != nullptr)
{
int ans = SDLNet_UDP_Recv(sockets[0],packet);
if (ans)
{
//TODO: add handling of sent time in packet
//print(getIP(packet->address.host)<<":"<<std::to_string(SDLNet_Read16(packet->address.port))<<" ("<< packet->channel << "): " << packet->data);
}
else
{
if (ans == -1)
{
print("ERROR");
}
}
SDLNet_FreePacket(packet);
}
}//*/
}
void packets_shift_up( UDPpacket **packet, int max_packets )
{
if (packet[0])
{
SDLNet_FreePacket(packet[0]);
}
for (int i = 0; i < max_packets - 1; i++)
{
packet[i] = packet[i + 1];
}
packet[max_packets - 1] = NULL;
}
void packets_shift_down( UDPpacket **packet, int max_packets )
{
if (packet[max_packets - 1])
{
SDLNet_FreePacket(packet[max_packets - 1]);
}
for (int i = max_packets - 1; i > 0; i--)
{
packet[i] = packet[i - 1];
}
packet[0] = NULL;
}
bool UdpConnection::allocPacket(uint32_t packetSize) {
// free old packet memory
SDLNet_FreePacket(packet);
// allocate new packet memory
packet = SDLNet_AllocPacket(packetSize);
if (packet == nullptr) {
std::cout << "\tSDLNet_AllocPacket failed : " << SDLNet_GetError() << std::endl;
return false;
}
packet->address.host = serverIP.host;
packet->address.port = serverIP.port;
return true;
}
void I_QuitNetwork(void)
{
if (packet)
{
SDLNet_FreePacket(packet);
packet = NULL;
}
if (udpsocket)
{
SDLNet_UDP_Close(udpsocket);
udpsocket = NULL;
}
SDLNet_Quit();
}
// Most of this function by ZZZ.
// Incoming port number should be in network byte order.
OSErr NetDDPOpenSocket(short *ioPortNumber, PacketHandlerProcPtr packetHandler)
{
//fdprintf("NetDDPOpenSocket\n");
assert(packetHandler);
// Allocate packet buffer (this is Christian's part)
assert(!sUDPPacketBuffer);
sUDPPacketBuffer = SDLNet_AllocPacket(ddpMaxData);
if (sUDPPacketBuffer == NULL)
return -1;
//PORTGUESS
// Open socket (SDLNet_Open seems to like port in host byte order)
// NOTE: only SDLNet_UDP_Open wants port in host byte order. All other uses of port in SDL_net
// are in network byte order.
sSocket = SDLNet_UDP_Open(SDL_SwapBE16(*ioPortNumber));
if (sSocket == NULL) {
SDLNet_FreePacket(sUDPPacketBuffer);
sUDPPacketBuffer = NULL;
return -1;
}
// Set up socket set
sSocketSet = SDLNet_AllocSocketSet(1);
SDLNet_UDP_AddSocket(sSocketSet, sSocket);
// Set up receiver
sKeepListening = true;
sPacketHandler = packetHandler;
sReceivingThread = SDL_CreateThread(receive_thread_function, "NetDDPOpenSocket_ReceivingThread", NULL);
// Set receiving thread priority very high
bool theResult = BoostThreadPriority(sReceivingThread);
if(theResult == false)
fdprintf("warning: BoostThreadPriority() failed; network performance may suffer\n");
//PORTGUESS but we should generally keep port in network order, I think?
// We really ought to return the "real" port we bound to in *ioPortNumber...
// for now we just hand back whatever they handed us.
//*ioPortNumber = *ioPortNumber;
return 0;
}
/* Allocate/free a single UDP packet 'size' bytes long.
The new packet is returned, or NULL if the function ran out of memory.
*/
extern UDPpacket *SDLNet_AllocPacket(int size)
{
UDPpacket *packet;
int error;
error = 1;
packet = (UDPpacket *)malloc(sizeof(*packet));
if ( packet != NULL ) {
packet->maxlen = size;
packet->data = (u8 *)malloc(size);
if ( packet->data != NULL ) {
error = 0;
}
}
if ( error ) {
SDLNet_FreePacket(packet);
packet = NULL;
}
return(packet);
}
/* Allocate/free a single UDP packet 'size' bytes long.
The new packet is returned, or NULL if the function ran out of memory.
*/
extern UDPpacket *SDLNet_AllocPacket(int size)
{
UDPpacket *packet;
int error;
error = 1;
packet = (UDPpacket *)malloc(sizeof(*packet));
if ( packet != NULL ) {
packet->maxlen = size;
packet->data = (unsigned char *)malloc(size);
if ( packet->data != NULL ) {
error = 0;
}
}
if ( error ) {
SDLNet_SetError("Out of memory");
SDLNet_FreePacket(packet);
packet = NULL;
}
return(packet);
}
//
// free a socket
//
static __inline__ void FreeSocket(int s)
{
if ((s >= 0) &&
(s < lastHeapSocket) &&
(socketHeap[s]->type != unusedSocket))
{
if (UDPServerSocket == socketHeap[s]->type)
{
UDPpacket *p;
PacketQue *ub = &socketHeap[s]->q.ub;
while (-1 != DequePacket(ub, &p))
{
SDLNet_FreePacket(p);
}
}
socketHeap[s]->type = unusedSocket;
socketHeap[s]->state = unusedState;
socketHeap[s]->s.genSocket = NULL;
}
}
void I_FreePacket(UDP_PACKET *packet)
{
SDLNet_FreePacket(packet);
}
NetBaseUDP::~NetBaseUDP()
{
SDLNet_FreePacket(mPacket);
SDLNet_Quit();
}
int network_packet_free(UDPpacket* packet) {
SDLNet_FreePacket(packet);
packet = NULL;
return 0;
}
void Server::Quit()
{
SDLNet_FreePacket(p);
SDLNet_Quit();
}
void UdpConnection::freeResources() {
SDLNet_FreePacket(packet);
}
Message::~Message()
{
if ( packet != NULL ) SDLNet_FreePacket((UDPpacket*)packet);
}
int main(int argc, char **argv)
{
Uint16 port;
char *host,*fname,*fbasename;
Sint32 flen,pos,p2;
int len,blocks,i,err=0;
Uint32 ack;
IPaddress ip;
UDPsocket sock;
UDPpacket *in, *out;
FILE *f;
/* check our commandline */
if(argc<4)
{
printf("%s host port file\n",argv[0]);
exit(0);
}
/* initialize SDL */
if(SDL_Init(0)==-1)
{
printf("SDL_Init: %s\n",SDL_GetError());
exit(1);
}
/* initialize SDL_net */
if(SDLNet_Init()==-1)
{
printf("SDLNet_Init: %s\n",SDLNet_GetError());
exit(2);
}
/* get the host from the commandline */
host=argv[1];
/* get the port from the commandline */
port=(Uint16) strtol(argv[2],NULL,0);
if(!port)
{
printf("a server port cannot be 0.\n");
exit(3);
}
/* get filename to get from server from commandline */
fname=argv[3];
if(SDLNet_ResolveHost(&ip,host,port)==-1)
{
printf("SDLNet_ResolveHost: %s\n",SDLNet_GetError());
exit(4);
}
/* open udp client socket */
if(!(sock=SDLNet_UDP_Open(0)))
{
printf("SDLNet_UDP_Open: %s\n",SDLNet_GetError());
exit(5);
}
/* allocate max packet */
if(!(out=SDLNet_AllocPacket(65535)))
{
printf("SDLNet_AllocPacket: %s\n",SDLNet_GetError());
exit(6);
}
if(!(in=SDLNet_AllocPacket(65535)))
{
printf("SDLNet_AllocPacket: %s\n",SDLNet_GetError());
exit(6);
}
/* bind server address to channel 0 */
if(SDLNet_UDP_Bind(sock, 0, &ip)==-1)
{
printf("SDLNet_UDP_Bind: %s\n",SDLNet_GetError());
exit(7);
}
/* open output file */
fbasename=strrchr(fname,'/');
if(!fbasename)
fbasename=fname;
else
fbasename++;
printf("writting file: %s\n",fbasename);
if(!(f=fopen(fbasename,"wb")))
{
perror("fopen");
exit(8);
}
/* request file / expect filesize */
printf("requesting file=%s\n",fname);
out->data[0]=1<<4;
strcpy((char*)out->data+1,fname);
out->len=strlen(fname)+2;
if(udpsend(sock,0,out,in,200,1,TIMEOUT)<1)
exit(9);
flen=SDLNet_Read32(in->data+1);
len=SDLNet_Read32(in->data+5);
blocks=(flen+len-1)/len;
printf("flen=%d blocksize=%d blocks=%d\n",flen,len,blocks);
/* send ready / expect file */
printf("starting transfer\n");
out->data[0]=2<<4;
out->len=1;
if(udpsend(sock,0,out,in,10,2,TIMEOUT)<1)
exit(10);
if(flen<0)
{
printf("file not available...\n");
exit(11);
}
pos=0; /* count per 32 blocks */
while(pos*32<blocks && !err)
{
/*printf("pos=%d\n",pos); */
ack=0;
if((pos+1)*32>=blocks)
{
for(i=blocks%32;i<32;i++)
ack|=1<<i;
}
printf("\r "
"\r%3d%% %08x: ",(pos*3200)/blocks,pos*32*len);
while(ack!=0xffffffff && !err)
{
i=in->data[1];
p2=SDLNet_Read32(in->data+2);
/*printf("received %d,%d\n",i,p2); */
if(!(ack&1<<i) && p2>=pos*32*len)
{
fseek(f,p2,SEEK_SET);
fwrite(in->data+6,in->len-6,1,f);
ack|=1<<i;
printf(".");
fflush(stdout);
}
if(ack!=0xffffffff)
err=udprecv(sock,in,10,2,500);
if(err<0)
continue; /* error... */
if(!err)
{
/*printf("sending ack 0x%0X\n",ack); */
out->data[0]=3<<4;
SDLNet_Write32(pos*32*len,out->data+1);
SDLNet_Write32(ack,out->data+5);
out->len=9;
SDLNet_UDP_Send(sock,0,out);
}
err=0;
}
pos++;
}
printf("\ndone.\n");
fclose(f);
/* close the socket */
SDLNet_UDP_Close(sock);
/* free packets */
SDLNet_FreePacket(out);
SDLNet_FreePacket(in);
/* shutdown SDL_net */
SDLNet_Quit();
/* shutdown SDL */
SDL_Quit();
return(0);
}
static __inline__ void snUDPFreePacket(UDPpacket *p)
{
lockSDLNet();
SDLNet_FreePacket(p);
unlockSDLNet();
}
// poll for new packets received, check that connection is alive, resend queued packets if necessary
int network_check( void )
{
#ifdef __BLACKBERRY__
#else
if (!net_initialized)
return -1;
if (connected)
{
// timeout
if (!network_is_alive())
{
if (!quit)
network_tyrian_halt(2, false);
}
// keep-alive
static Uint32 keep_alive_tick = 0;
if (SDL_GetTicks() - keep_alive_tick > NET_KEEP_ALIVE)
{
network_prepare(PACKET_KEEP_ALIVE);
network_send_no_ack(4);
keep_alive_tick = SDL_GetTicks();
}
}
// retry
if (packet_out[0] && SDL_GetTicks() - last_out_tick > NET_RETRY)
{
if (!SDLNet_UDP_Send(socket, 0, packet_out[0]))
{
printf("SDLNet_UDP_Send: %s\n", SDL_GetError());
return -1;
}
last_out_tick = SDL_GetTicks();
}
switch (SDLNet_UDP_Recv(socket, packet_temp))
{
case -1:
printf("SDLNet_UDP_Recv: %s\n", SDL_GetError());
return -1;
break;
case 0:
break;
default:
if (packet_temp->channel == 0 && packet_temp->len >= 4)
{
switch (SDLNet_Read16(&packet_temp->data[0]))
{
case PACKET_ACKNOWLEDGE:
if ((Uint16)(SDLNet_Read16(&packet_temp->data[2]) - last_ack_sync) < NET_PACKET_QUEUE)
{
last_ack_sync = SDLNet_Read16(&packet_temp->data[2]);
}
{
Uint16 i = SDLNet_Read16(&packet_temp->data[2]) - queue_out_sync;
if (i < NET_PACKET_QUEUE)
{
if (packet_out[i])
{
SDLNet_FreePacket(packet_out[i]);
packet_out[i] = NULL;
}
}
}
// remove acknowledged packets from queue
while (packet_out[0] == NULL && (Uint16)(last_ack_sync - queue_out_sync) < NET_PACKET_QUEUE)
{
packets_shift_up(packet_out, NET_PACKET_QUEUE);
queue_out_sync++;
}
last_in_tick = SDL_GetTicks();
break;
case PACKET_CONNECT:
queue_in_sync = SDLNet_Read16(&packet_temp->data[2]);
for (int i = 0; i < NET_PACKET_QUEUE; i++)
{
if (packet_in[i])
{
SDLNet_FreePacket(packet_in[i]);
packet_in[i] = NULL;
}
}
case PACKET_DETAILS:
case PACKET_WAITING:
case PACKET_BUSY:
case PACKET_GAME_QUIT:
case PACKET_GAME_PAUSE:
case PACKET_GAME_MENU:
{
Uint16 i = SDLNet_Read16(&packet_temp->data[2]) - queue_in_sync;
if (i < NET_PACKET_QUEUE)
{
if (packet_in[i] == NULL)
packet_in[i] = SDLNet_AllocPacket(NET_PACKET_SIZE);
packet_copy(packet_in[i], packet_temp);
} else {
// inbound packet queue overflow/underflow
// under normal circumstances, this is okay
}
}
network_acknowledge(SDLNet_Read16(&packet_temp->data[2]));
case PACKET_KEEP_ALIVE:
last_in_tick = SDL_GetTicks();
break;
case PACKET_QUIT:
if (!quit)
{
network_prepare(PACKET_QUIT);
network_send(4); // PACKET_QUIT
}
network_acknowledge(SDLNet_Read16(&packet_temp->data[2]));
if (!quit)
network_tyrian_halt(1, true);
break;
case PACKET_STATE:
// place packet in queue if within limits
{
Uint16 i = SDLNet_Read16(&packet_temp->data[2]) - last_state_in_sync + 1;
if (i < NET_PACKET_QUEUE)
{
if (packet_state_in[i] == NULL)
packet_state_in[i] = SDLNet_AllocPacket(NET_PACKET_SIZE);
packet_copy(packet_state_in[i], packet_temp);
}
}
break;
case PACKET_STATE_XOR:
// place packet in queue if within limits
{
Uint16 i = SDLNet_Read16(&packet_temp->data[2]) - last_state_in_sync + 1;
if (i < NET_PACKET_QUEUE)
{
if (packet_state_in_xor[i] == NULL)
{
packet_state_in_xor[i] = SDLNet_AllocPacket(NET_PACKET_SIZE);
packet_copy(packet_state_in_xor[i], packet_temp);
} else if (SDLNet_Read16(&packet_state_in_xor[i]->data[0]) != PACKET_STATE_XOR) {
for (int j = 4; j < packet_state_in_xor[i]->len; j++)
packet_state_in_xor[i]->data[j] ^= packet_temp->data[j];
SDLNet_Write16(PACKET_STATE_XOR, &packet_state_in_xor[i]->data[0]);
}
}
}
break;
case PACKET_STATE_RESEND:
// resend requested state packet if still available
{
Uint16 i = last_state_out_sync - SDLNet_Read16(&packet_temp->data[2]);
if (i > 0 && i < NET_PACKET_QUEUE)
{
if (packet_state_out[i])
{
if (!SDLNet_UDP_Send(socket, 0, packet_state_out[i]))
{
printf("SDLNet_UDP_Send: %s\n", SDL_GetError());
return -1;
}
}
}
}
break;
default:
fprintf(stderr, "warning: bad packet %d received\n", SDLNet_Read16(&packet_temp->data[0]));
return 0;
break;
}
return 1;
}
break;
}
#endif
return 0;
}
void net_cleanup()
{
SDLNet_FreePacket(gPacket);
SDLNet_Quit();
}
