/*
* I_Socket
*
* Sets the given socket non-blocking, binds to the given port, or first
* available if none is given
*/
UDP_SOCKET I_Socket(Uint16 port)
{
if(port)
return (SDLNet_UDP_Open(port));
else {
UDP_SOCKET sock;
port = IPPORT_RESERVED;
while( (sock = SDLNet_UDP_Open(port)) == NULL )
port++;
return sock;
}
}
bool NET::Connect(string host, int port)
{
server = false;
bool err = false;
if (host == "Server")
server = true;
if (remote_socket != NULL)
{
SDLNet_UDP_Close(remote_socket);
remote_socket = NULL;
}
if (server)
remote_socket = SDLNet_UDP_Open(port);
else
remote_socket = SDLNet_UDP_Open(0);
if (!server)
{
SDLNet_ResolveHost(&remote_ip, host.c_str(), port);
SDLNet_UDP_Unbind(remote_socket, 0);
if (SDLNet_UDP_Bind(remote_socket, 0, &remote_ip)==-1)
{
err = true;
if (NET_DEBUG)
{
cout << "net: couldn't bind UDP socket to host " << host << " port " << port << endl;
printf("SDLNet_UDP_Bind: %s\n",SDLNet_GetError());
}
}
}
//try a handshake
if (pout == NULL)
pout = SDLNet_AllocPacket(MAX_PACKET_SIZE);
if (pin == NULL)
pin = SDLNet_AllocPacket(MAX_PACKET_SIZE);
if (server)
{
}
else
{
err = ClientHandshake();
}
return !err;
}
/*
* I_Socket
*
* Sets the given socket non-blocking, binds to the given port, or first
* available if none is given
*/
UDP_SOCKET I_Socket( uint16_t port) // Uint16 port)
{
printf("I_Socket port=%d\n", port);
if (port)
return (SDLNet_UDP_Open(port));
else {
UDP_SOCKET sock;
port = IPPORT_RESERVED;
while( (sock = SDLNet_UDP_Open(port)) == -1 ) // Vladimir NULL )
port++;
return sock;
}
}
void CUDPServer::sendAll(CUDPPacket poPacket)
{
UDPsocket oSocket;
int i, iResult;
IPaddress *poIPAddress;
oSocket=SDLNet_UDP_Open(0);
if(!oSocket)
{
printf("SDLNet_UDP_Open: %s\n", SDLNet_GetError());
}
for ( i = 0 ; i < goClientManager.getNumberClients() ; i++ )
{
poIPAddress = goClientManager.getIPAddress(i);
iResult = SDLNet_UDP_Bind( oSocket, -1, poIPAddress );
if( iResult == -1 )
{
printf("SDLNet_UDP_Bind: %s\n", SDLNet_GetError());
// do something because we failed to bind
}
poPacket.send(oSocket, MSG_TEXTMESSAGE);
SDLNet_UDP_Unbind( oSocket, iResult );
}
SDLNet_UDP_Close( oSocket );
}
bool UdpSocket::Open(int pPort, int pSize)
{
if(!mOpen)
{
mSize = pSize;
mPacket = SDLNet_AllocPacket(mSize);
if(mPacket == NULL)
{
SDL_Log("[UdpSocket::Open] Failed to allocated UDP packet: %s", SDLNet_GetError());
return false;
}
mSocket = SDLNet_UDP_Open(pPort);
if(mSocket == NULL)
{
SDL_Log("[UdpSocket::Open] Failed to UDP socket: %s", SDLNet_GetError());
return false;
}
mOpen = true;
}
return true;
}
void CUDPServer::listen(Uint32 uiTimeout)
{
Uint32 uiStop = SDL_GetTicks() + uiTimeout;
CUDPPacket oPacket;
UDPsocket oSocket;
char strUsername[32], strMessage[32];
oPacket.setLastMessageRecievedType(MSG_NOMESSAGE);
oSocket = SDLNet_UDP_Open(9998);
if ( !oSocket )
{
printf("SDLNet_UDP_Open: %s\n", SDLNet_GetError());
}
while (SDL_GetTicks() < uiStop)
{
oPacket.recieve(oSocket);
if ( oPacket.getLastMessageRecievedType() != MSG_NOMESSAGE )
{
printf("Last message recieved was %d\n", oPacket.getLastMessageRecievedType());
oPacket.getMessageData(strUsername, strMessage);
printf("Message was %s, %s\n", strUsername, strMessage);
//send message to other clients
go_UDPServer.sendAll(oPacket);
}
}
SDLNet_UDP_Close( oSocket );
}
static boolean NET_SDL_InitClient(void)
{
int p;
//!
// @category net
// @arg <n>
//
// Use the specified UDP port for communications, instead of
// the default (2342).
//
p = M_CheckParm("-port");
if (p > 0)
port = atoi(myargv[p+1]);
SDLNet_Init();
udpsocket = SDLNet_UDP_Open(0);
if (udpsocket == NULL)
{
I_Error("NET_SDL_InitClient: Unable to open a socket!");
}
recvpacket = SDLNet_AllocPacket(1500);
#ifdef DROP_PACKETS
srand(time(NULL));
#endif
return true;
}
void Server::Init()
{
/* Initialize SDL_net */
if (SDLNet_Init() < 0)
{
fprintf(stderr, "SDLNet_Init: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
/* Open a socket */
if (!(sd = SDLNet_UDP_Open(7777)))
{
fprintf(stderr, "SDLNet_UDP_Open: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
/* Make space for the packet */
if (!(p = SDLNet_AllocPacket(sizeof(Transform))))
{
fprintf(stderr, "SDLNet_AllocPacket: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
/* Wait for a connection, send data and term */
quit = 0;
}
static boolean NET_SDL_InitServer(void)
{
int p;
if (initted)
return true;
p = M_CheckParmWithArgs("-port", 1);
if (p > 0)
port = atoi(myargv[p+1]);
SDLNet_Init();
udpsocket = SDLNet_UDP_Open(port);
if (udpsocket == NULL)
{
I_Error("NET_SDL_InitServer: Unable to bind to port %i", port);
}
recvpacket = SDLNet_AllocPacket(1500);
#ifdef DROP_PACKETS
srand(time(NULL));
#endif
initted = true;
return true;
}
int Peer::addSocket(const int port)
{
Print("adding socket...\n");
int oldSize = sockets.size();
// if client only, port should be 0 (will open first avaliable port)
UDPsocket socket = SDLNet_UDP_Open(port);
if (!socket)
{
Print("SDLNet_UDP_Open: %s\n", SDLNet_GetError());
}
sockets.push_back(socket);
if (oldSize == sockets.size()) {
//print("socket error (SDLNet_UDP_Open)")
//Print("SDLNet_UDP_Open: %s\n", SDLNet_GetError());
return 0;
}
//SEG FAULT LOCATED
if (sockets.size())
{
//WATCH IS ALLOCATED NOW
int numused = SDLNet_UDP_AddSocket(watch, sockets.back());
if (numused == -1)
{
Print("SDLNet_UDP_AddSocket: %s\n", SDLNet_GetError());
}
return 1;
}
return 0;
}
void sock_init( sock_t* s, int port )
{
s->sset = SDLNet_AllocSocketSet(1);
s->sock = SDLNet_UDP_Open( port ); assert( s->sock );
int rez = SDLNet_UDP_AddSocket( s->sset, s->sock); assert( rez != -1 );
s->bytes_recv = 0;
s->bytes_sent = 0;
}
bool UdpConnection::openPort(uint16_t port) {
socket = SDLNet_UDP_Open(port);
if (!socket) {
std::cout << "Failed to open socket: " << SDLNet_GetError() << std::endl;
return false;
}
return true;
}
bool init() {
if (SDL_Init(SDL_INIT_VIDEO)<0) { printf("SDL init failure.\n"); return false;}
if (SDLNet_Init()<0) printf("SDL net init failure.\n");
int initFlags = IMG_INIT_PNG;
if (!(IMG_Init(initFlags) & initFlags)) { printf("IMG init failure.\n"); return false;}
if (!loadMedia()) { printf("Couldn't load meida.\n"); return false;}
udpSendSock = SDLNet_UDP_Open(0);
udpRecvSock = SDLNet_UDP_Open(0);
if (udpSendSock == NULL || udpRecvSock == NULL) { printf("Couldn't open UDP sockets.\n"); return false;}
IPaddress serverIP;
SDLNet_ResolveHost(&serverIP, NULL, 4444);
TCPsock = SDLNet_TCP_Open(&serverIP);
if (TCPsock==NULL) { printf("Couldn't open TCP socket.\n"); return false;}
packetOut = SDLNet_AllocPacket(1024);
//packetOut->data=gameData;
return true;
}
UDP_Socket::UDP_Socket(const unsigned short &port)
: sock(0)
{
get_Net();
sock = SDLNet_UDP_Open(port);
if(!sock)
throw UDP_Socket_Init_Failure();
}
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);
}
UDPsocket network_udp_open(int port) {
UDPsocket udp;
udp = SDLNet_UDP_Open(port);
if (udp == NULL) {
std::cerr << "Failed to open UDP on port " << port << ": " << SDLNet_GetError() << "\n";
return NULL;
}
return udp;
}
UDP_Socket::UDP_Socket(const Uint16 &port)
: sock(0)
{
get_Net();
sock = SDLNet_UDP_Open(port);
if(!sock)
throw UDP_Socket_Init_Failure();
}
static __inline__ UDPsocket snUDPOpen(int port)
{
UDPsocket socket = NULL ;
lockSDLNet();
socket = SDLNet_UDP_Open(port);
unlockSDLNet();
return socket;
}
bool ClientUDP::open()
{
/* Open a socket on random port */
if (!(m_socketDescriptor = SDLNet_UDP_Open(0)))
{
std::cerr << "SDLNet_UDP_Open: %s\n" << SDLNet_GetError() << std::endl;
return false;
}
return true;
}
void UDPNetwork::Open(int port, uint32_t sizePacket)
{
m_sizePacket = sizePacket;
m_socket = SDLNet_UDP_Open(port);
m_packet = SDLNet_AllocPacket(sizePacket);
if ( !m_socket || !m_packet )
{
Close();
throw(std::runtime_error("Failed to open UDPNetwork"));
}
}
/*
* network_udp_open() - Open a UDP socket on the given port
* ! Note that UDP sockets may be used for both sending and receiving data, just not at the same time
* ! Note that UDPsocket is a pointer internally
* @port: the port to use
*/
UDPsocket network_udp_open(int port) {
UDPsocket udp = nullptr; // Declare a socket data struct
udp = SDLNet_UDP_Open(port); // Attempt to open the socket
if (udp == nullptr) { // If the socket failed to open
std::cerr << "Failed to open UDP on port " << port << ": " << SDLNet_GetError() << "\n"; // Output the error message
return nullptr; // Return nullptr on failure
}
return udp; // Return the socket on success
}
void OpenPort( int32_t port )
{
printf("Opening port %d\n",port);
// Sets our sovket with our local port
gOurSocket = SDLNet_UDP_Open( port );
if ( gOurSocket == NULL )
{
printf("\tSDLNet_UDP_Open failed : ", SDLNet_GetError());
exit(1);
}
}
bool IPX_StartServer(Bit16u portnum) {
Bit16u i;
if(!SDLNet_ResolveHost(&ipxServerIp, NULL, portnum)) {
ipxServerSocket = SDLNet_UDP_Open(portnum);
if(!ipxServerSocket) return false;
for(i=0;i<SOCKETTABLESIZE;i++) connBuffer[i].connected = false;
return true;
}
return false;
}
void joinLobby(int *mode){
printf("DEBUG: JOINING LOBBY... REMOVE THIS LATER (inputhandler.c:242)\n");
bool success;
success = resolveIPPortFromStrings();
if(!success)
return;
client.TCPSock = SDLNet_TCP_Open(&ip);
if(client.TCPSock == NULL){
printf("TCP Open Failure\n");
//exit(EXIT_FAILURE);
return;
}
SDLNet_TCP_Send(client.TCPSock, textString[ENTERING_NAME], MAX_NAME_LENGTH);
client.UDPRecvSock = SDLNet_UDP_Open(0);
client.UDPSendSock = SDLNet_UDP_Open(0);
if(client.UDPRecvSock == NULL || client.UDPSendSock == NULL){
printf("Opening of UDP sockets failed!\n");
exit(EXIT_FAILURE);
}
//
// // Send the clients ports for UDP recieve and UDP send
// SDLNet_TCP_Send(client.TCPSock, 1234, sizeof(int)); printf("1\n");
// //SDLNet_TCP_Send(client.TCPSock, &(SDLNet_UDP_GetPeerAddress(client.UDPSendSock,-1)->port),sizeof(Uint16));
// SDLNet_TCP_Recv(client.TCPSock, &(client.ServerRecvUDPPort), sizeof(int));printf("2\n");
// printf("sENT: %x\nRecieved port: %x\n", (SDLNet_UDP_GetPeerAddress(client.UDPRecvSock,-1))->port, client.ServerRecvUDPPort);printf("3\n");
printf("CONNECTED\n"); exit(0);
chatRecv = SDL_CreateThread(chatRecieve, "BC ChatRecv", &client);
SDL_DetachThread(chatRecv);
isConnected = true;
//*******************************************************************************************
*mode = LOBBY;
clearTextStrings(6);
return;
}
int game_host::init_net()
{
if (SDLNet_Init() < 0)
{
fprintf(stderr, "SDLNet_Init: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
//maybe go through here and replace them with more easy to notice errors?
}
if (SDLNet_ResolveHost(&ip, NULL, this->port) < 0)
{
fprintf(stderr, "SDLNet_ResolveHost: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
if (!(sd = SDLNet_TCP_Open(&ip)))
{
fprintf(stderr, "SDLNet_TCP_Open: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
if (!(this->p1UDPsock = SDLNet_UDP_Open(this->port)))
{
cout << "UDP socket failed to open" << SDLNet_GetError() << "\n";
exit(EXIT_FAILURE);
}
if (!(this->UDPpack1 = SDLNet_AllocPacket(512)))
{
fprintf(stderr, "SDLNet_AllocPacket: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
if (!(this->UDPpack2 = SDLNet_AllocPacket(512)))
{
fprintf(stderr, "SDLNet_AllocPacket: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
if (!(this->UDPrpack = SDLNet_AllocPacket(512)))
{
fprintf(stderr, "SDLNet_AllocPacket: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
socketset = SDLNet_AllocSocketSet(4);
messageSizeMod = 0;
cout << "Init completed\n";
return 0; // temporary
}
udp_socket_t::udp_socket_t(array_id_t tmp_connection_info_id){
connection_info_id = tmp_connection_info_id;
net_ip_connection_info_t *tmp = (net_ip_connection_info_t*)find_pointer(connection_info_id);
socket = nullptr;
if(tmp == nullptr){
printf_("The net_ip_connection_info_t that this socket has to use does not exist (ID: " + std::to_string(tmp_connection_info_id) + ")\n", PRINTF_ERROR);
}else{
socket = SDLNet_UDP_Open(tmp->port);
if(unlikely(!socket)){
printf_("Socket will not open (port: " + std::to_string(tmp->port) + ")\n", PRINTF_VITAL);
assert(false);
}
}
}
bool NetInputChannelTryOpen(NetInputChannel *n, Uint16 port, Uint32 host)
{
n->sock = SDLNet_UDP_Open(port);
if (n->sock == NULL)
{
printf("SDLNet_UDP_Open: %s\n", SDLNet_GetError());
return false;
}
printf("Opened socket on port %d, other host %d.%d.%d.%d\n",
port, NET_IP_TO_CIDR_FORMAT(host));
n->state = CHANNEL_STATE_DISCONNECTED;
n->otherHost = host;
return true;
}
cearth_ctx *
cearthctx_new(void)
{
cearth_ctx *ctx = calloc(1, sizeof(cearth_ctx));
/* Connect to server. */
ctx->sk = SDLNet_UDP_Open(0);
IPaddress ip;
SDLNet_ResolveHost(&ip, haven_serv, HAVENSERV_PORT);
int success = SDLNet_UDP_Bind(ctx->sk, -1, &ip);
/* TEST */
printf("Success: %d\n", success);
return ctx;
}
bool IPX_StartServer(Bit16u portnum) {
Bit16u i;
if(!SDLNet_ResolveHost(&ipxServerIp, NULL, portnum)) {
//serverSocketSet = SDLNet_AllocSocketSet(SOCKETTABLESIZE);
ipxServerSocket = SDLNet_UDP_Open(portnum);
if(!ipxServerSocket) return false;
for(i=0;i<SOCKETTABLESIZE;i++) connBuffer[i].connected = false;
TIMER_AddTickHandler(&IPX_ServerLoop);
return true;
}
return false;
}
NetBaseUDP::NetBaseUDP(int pPort, int pSize)
{
if(SDLNet_Init() < 0)
std::cout << "Failed to initialize SDL_Net in NetBaseUDP." << std::endl;
else
std::cout << "Successfully initialized SDL_Net in NetBaseUDP." << std::endl;
if(!(mSocket = SDLNet_UDP_Open(pPort)))
std::cout << "Failed to open socket on port " << pPort << " in NetBaseUDP." << std::endl;
else
std::cout << "Successfully opened socket on port " << pPort << " in NetBaseUDP." << std::endl;
if(!(mPacket = SDLNet_AllocPacket(pSize)))
std::cout << "Failed to allocate packet of size " << pSize << " in NetBaseUDP." << std::endl;
else
std::cout << "Successfully allocated packet of size " << pSize << " in NetBaseUDP." << std::endl;
}
