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