std::string SocketMultiplexer::DispatchCommand(int uid, const std::string& line) {
std::istringstream iss(line);
std::string command, arg;
iss >> command >> std::ws;
std::getline(iss, arg);
if (command.empty()) {
return "";
}
if (command == "QUIT") {
// FIXME: should check uid? (allow only process owner?)
return Shutdown();
}
if (command == "ADD") {
return AddSocket(uid, arg);
}
if (command == "DELETE") {
return DeleteSocket(uid, arg);
}
if (command == "LIST") {
return ListSocket(uid);
}
LOG(ERROR) << "Unknwon command '" << command << "(" << arg << ")'";
return "Unknwon command " + command + "\n";
}
//-----------------------------------------------------------------------------
// Starts in the server mode
int TestThread::StartServer() {
int ret;
if(_connection == 's') { // Stream
_listen = new Socket();
printf("Listeing on %s, port %d\n", _address.c_str(), _port);
ret = Listen(_listen, _address.c_str(), _port);
if(ret) {
printf("Can't listen: %s\n", _errorDescr);
return ret;
}
} else if(_connection == 'm') { // Multicast
_server = new Socket();
ret = _server->MulticastIn(_address.c_str(), _port);
if(ret) {
printf("Can't listen: %s\n", _server->_errorDescr);
return ret;
}
ret = AddSocket(_server);
if(ret) {
_error = ret;
return ret;
}
} else {
printf("Unknown connection type: %c\n", _connection);
return -1;
}
return 0;
}
//-----------------------------------------------------------------------------
// Starts in the client mode
int TestThread::StartClient() {
int ret;
if(_connection == 's') { // Stream
_client = new Socket();
printf("Connecting to %s, port %d\n", _address.c_str(), _port);
ret = Connect(_client, _address.c_str(), _port);
if(ret) {
printf("Can't connect: %s\n", _errorDescr);
return ret;
}
} else if(_connection == 'm') { // Multicast
_client = new Socket();
ret = _client->MulticastOut(_address.c_str(), _port);
if(ret) {
printf("Can't connect: %s\n", _client->_errorDescr);
return ret;
}
ret = AddSocket(_client);
if(ret) {
_error = ret;
return ret;
}
} else {
printf("Unknown connection type: %c\n", _connection);
return -1;
}
return 0;
}
double tcpaccept(double sockid, double mode)
{
CSocket*sock = (CSocket*)sockets.item((int)sockid);
if(sock == NULL)return -1;
CSocket*sock2 = sock->tcpaccept((int)mode);
if(sock2 != NULL)return AddSocket(sock2);
return -1;
}
double tcplisten(double port, double max, double mode)
{
CSocket* sock = new CSocket();
if(sock->tcplisten((int)port, (int) max,(int)mode))
return AddSocket(sock);
delete sock;
return -1;
}
//Sockets
double tcpconnect(char*ip, double port, double mode)
{
CSocket* sock = new CSocket();
if(sock->tcpconnect(ip, (int)port, (int)mode))
return AddSocket(sock);
delete sock;
return -1;
}
double udpconnect(double port, double mode)
{
CSocket* sock = new CSocket();
if(sock->udpconnect((int)port, (int)mode))
return AddSocket(sock);
delete sock;
return -1;
}
void ConnPoolAlloc(int tpindex, LPSESS newsess) {
/*#ifdef _WIN32
LPGENSESS sigcp;
struct sockaddr_in name;
#endif*/
LPCONNPOOL newcp;
//unsigned long on = 1;
newcp = malloc(sizeof(CONNPOOL));
newcp->nconns = 2;
newcp->sessions[0] = (LPSESS)alert_sess;
newcp->sessions[1] = newsess;
//newcp->n_connupdates = 0;
threadpool = VectorAdd(threadpool, newcp);
#if defined(_USE_EPOLL)
#elif defined(_USE_DEVPOLL)
#elif defined(_USE_POLL)
#elif defined(_USE_WSAEVENTS)
#elif defined(_USE_SELECT)
FD_ZERO(&newcp->rdfds);
#endif
#if _SM_NEED_INIT
newcp->smfd = InitSocketMultiplexing();
if (newcp->smfd == -1) {
printf("Couldn't open socket multiplexing file descriptor!\n");
free(newcp);
return;
}
#endif
AddSocket(alert_sck, newcp);
AddSocket(newsess->sck, newcp);
if (!_CreateWaitObject(&newcp->readyevent)) {
printf("[T%02d] Couldn't create wait object, err %d\n", tpindex, err());
return;
}
newcp->tid = _CreateThread(RecvThreadProc, (void *)tpindex);
}
bool TcpServer::Register(TcpHandler *pHandler)
{
if(pHandler == NULL)
return false;
AddSocket(pHandler);
pHandler->server(this);
pHandler->handle_OnConnected();
return true;
}
bool ClientSocketManager::Connect() {
if (!BaseSocketManager::Init())
return false;
RemoteEventSocket* pSocket = GCC_NEW RemoteEventSocket;
if (!pSocket->Connect(GetHostByName(m_HostName), m_Port)) {
SAFE_DELETE(pSocket);
return false;
}
AddSocket(pSocket);
return true;
}
int main()
{
// Setup
int screenWidth = 800;
int screenHeight = 450;
InitWindow(
screenWidth, screenHeight, "raylib [network] example - udp server");
SetTargetFPS(60);
SetTraceLogLevel(LOG_DEBUG);
// Networking
InitNetwork();
// Create the server
//
// Performs
// getaddrinfo
// socket
// setsockopt
// bind
// listen
server_res = AllocSocketResult();
if (!SocketCreate(&server_cfg, server_res)) {
TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d",
server_res->status, server_res->socket->status);
} else {
if (!SocketBind(&server_cfg, server_res)) {
TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d",
server_res->status, server_res->socket->status);
}
}
// Create & Add sockets to the socket set
socket_set = AllocSocketSet(1);
msglen = strlen(pingmsg) + 1;
memset(recvBuffer, '\0', sizeof(recvBuffer));
AddSocket(socket_set, server_res->socket);
// Main game loop
while (!WindowShouldClose()) {
BeginDrawing();
ClearBackground(RAYWHITE);
NetworkUpdate();
EndDrawing();
}
// Cleanup
CloseWindow();
return 0;
}
nuiSocket::nuiSocket(nuiSocket::SocketType Socket)
: mSocket(Socket), mpPool(NULL)
{
mNonBlocking = false;
mMaxIdleTime = 0; // Default = do nothing about idling sockets
#if (!defined _LINUX_)
if (Socket != -1)
{
int n = 0;
int res = setsockopt(mSocket, SOL_SOCKET, SO_NOSIGPIPE, &n, sizeof(n));
DumpError(res, __FUNC__);
}
#endif
AddSocket(this);
}
int TcpServer::handle_accept()
{
SOCKET conn_fd;
do
{
if((conn_fd = CSocker::ServerAccept(m_listen_fd)) == INVALID_SOCKET)
{
break;
}
CSocker::SetSocketMem(conn_fd,16*1024);
if(CSocker::SocketNoBlock(conn_fd) < 0)
{
log_error("SetNonblock faild \n");
CSocker::SocketClose(conn_fd);
assert(false);
continue;
}
if(CSocker::SetTcpKeepLive(conn_fd) < 0)
{
log_error("SetTcpKeepLive faild \n");
CSocker::SocketClose(conn_fd);
assert(false);
continue;
}
TcpHandler* sh = AllocSocketHandler(conn_fd);
if(sh == NULL)
{
log_error("sh is null \n");
CSocker::SocketClose(conn_fd);
assert(false);
continue;
}
AddSocket(sh);
sh->handle_OnConnected();
} while(conn_fd > 0);
return 0;
}
void CAmuledGSocketFuncTable::Install_Callback(GSocket *sock, GSocketEvent e)
{
AddSocket(sock, e);
}
void CIPCServer::OnLocalConnection()
{
AddSocket(new CIPCSocket(m_Local->nextPendingConnection(), true));
}
void CWebserverGSocketFuncTable::Install_Callback(GSocket *sock, GSocketEvent e)
{
AddSocket(sock, e);
}
void CIPCServer::OnRemoteConnection()
{
AddSocket(new CIPCSocket(m_Remote->nextPendingConnection(), true));
}
