void
SocketUnixCreate(TSocket ** const socketPP) {
struct socketUnix * socketUnixP;
MALLOCVAR(socketUnixP);
if (socketUnixP) {
int rc;
rc = socket(AF_INET, SOCK_STREAM, 0);
if (rc < 0)
*socketPP = NULL;
else {
socketUnixP->fd = rc;
socketUnixP->userSuppliedFd = FALSE;
{
int32_t n = 1;
int rc;
rc = setsockopt(socketUnixP->fd, SOL_SOCKET, SO_REUSEADDR,
(char*)&n, sizeof(n));
if (rc < 0)
*socketPP = NULL;
else
SocketCreate(&vtbl, socketUnixP, socketPP);
}
if (!*socketPP)
close(socketUnixP->fd);
}
if (!*socketPP)
free(socketUnixP);
} else
*socketPP = NULL;
}
void ServerNetInit(TServer *srv)
{
/* sanity */
if (!srv) {
return;
}
if( srv->port == 0 ) {
srv->listensock.fd = -1;
return;
}
/********* Must check errors from these functions *************/
if (!SocketInit())
TraceExit("Can't initialize TCP sockets\n");;
if (!SocketCreate(&srv->listensock))
TraceExit("Can't create a socket\n");;
if (!SocketBind(&srv->listensock,NULL,srv->port))
TraceExit("Can't bind\n");
if (!SocketListen(&srv->listensock,srv->max_conn))
TraceExit("Can't listen\n");
}
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;
}
bool CSocket::Connect(const char *a_szPath)
{
m_enError = SOCK_OK;
m_strErrorMsg.clear();
errno = 0;
if (m_enType != UN_TCP && m_enType != UN_UDP) {
m_enError = SOCK_TYPE;
m_strErrorMsg = "invalid socket type";
return false;
}
// 연결된 socket close
Close();
if (SocketCreate() == false) {
return false;
}
struct sockaddr_un addru;
socklen_t addrlen = sizeof(addru);
memset(&addru, 0x00, sizeof(addru));
addru.sun_family = AF_LOCAL;
strncpy(addru.sun_path, a_szPath, sizeof(addru.sun_path)-1);
for (int i=0; i < 5; i++) {
int ret = connect(m_nSockFd, (sockaddr*)&addru, addrlen);
if (ret >= 0) {
break;
} else {
switch (errno) {
case EISCONN :
return true;
case EINPROGRESS : // 연결 진행 중
case EALREADY :
sleep(1);
break;
default :
m_enError = SOCK_ERROR;
m_strErrorMsg = "socket connect error";
return false;
}
}
}
return true;
}
void
SocketUnixCreateFd(int const fd,
TSocket ** const socketPP) {
struct socketUnix * socketUnixP;
MALLOCVAR(socketUnixP);
if (socketUnixP) {
socketUnixP->fd = fd;
socketUnixP->userSuppliedFd = TRUE;
SocketCreate(&vtbl, socketUnixP, socketPP);
if (!*socketPP)
free(socketUnixP);
} else
*socketPP = NULL;
}
void
SocketWinCreateWinsock(SOCKET const winsock,
TSocket ** const socketPP) {
struct socketWin * socketWinP;
MALLOCVAR(socketWinP);
if (socketWinP) {
socketWinP->fd = winsock;
socketWinP->userSuppliedWinsock = TRUE;
SocketCreate(&vtbl, socketWinP, socketPP);
if (!*socketPP)
free(socketWinP);
} else
*socketPP = NULL;
}
THREAD(PlayMp3StreamThread, arg)
{
u_short mss = 1460;
u_long rx_to = 3000;
u_short tcpbufsiz = 8000;
FILE *stream;
sock = SocketCreate(sock,mss,rx_to,tcpbufsiz);
/*Connect the radio station.*/
u_long radio_ip = inet_addr(RADIO_IPADDR);
stream = ConnectStation(sock, radio_ip, RADIO_PORT, &metaint);
if(stream)
{
PlayMp3Stream(stream,metaint);
fclose(stream);
}
NutTcpCloseSocket(sock);
NutThreadExit();
for (;;);
}
bool CSocket::Connect(const char* a_szIP, int a_nPort, int a_nTimeoutSec)
{
m_enError = SOCK_OK;
m_strErrorMsg.clear();
errno = 0;
switch(m_enType) {
case IP_TCP :
case IP_UDP :
case IP6_TCP :
case IP6_UDP :
case UN_TCP :
case UN_UDP :
break ;
default :
m_enError = SOCK_TYPE;
m_strErrorMsg = "invalid socket type";
return false;
}
// 연결된 session은 close
Close();
if (SocketCreate() == false) {
return false;
}
socklen_t addrlen = 0;
sockaddr* addr = NULL;
sockaddr_in addr4;
sockaddr_in6 addr6;
if (m_enType == IP_TCP || m_enType == IP_UDP) {
memset(&addr4, 0x00, sizeof(addr4));
addrlen = sizeof(addr4);
addr4.sin_family = AF_INET;
if (inet_pton(AF_INET, a_szIP, &addr4.sin_addr) != 1) {
Close();
m_enError = SOCK_ERROR;
m_strErrorMsg = "invalied IP4 address format";
return false;
}
addr4.sin_port = htons(a_nPort);
addr = (sockaddr*)&addr4;
} else {
memset(&addr6, 0x00, sizeof(addr6));
addrlen = sizeof(addr6);
addr6.sin6_family = AF_INET6;
if (inet_pton(AF_INET6, a_szIP, &addr6.sin6_addr) != 1) {
Close();
m_enError = SOCK_ERROR;
m_strErrorMsg = "invalied IP4 address format";
return false;
}
addr6.sin6_port = htons(a_nPort);
addr = (sockaddr*)&addr6;
}
// connect시 timeout을 처리를 위한 NONBLOCK 설정
int oflags = fcntl(m_nSockFd, F_GETFL, 0);
fcntl(m_nSockFd, F_SETFL, oflags | O_NONBLOCK);
if (connect(m_nSockFd, addr, addrlen) == 0) {
fcntl(m_nSockFd, F_SETFL, oflags); // BLOCK 설정 해제
return true;
} else {
fcntl(m_nSockFd, F_SETFL, oflags);
switch (errno) {
case EISCONN :
return true;
case EINPROGRESS : // 연결 진행 중
case EALREADY :
break;
default :
Close();
m_enError = SOCK_ERROR;
m_strErrorMsg = "socket connect error";
return false;
}
}
// connect 진행 중일 경우 timeout 처리
fd_set rset, wset;
FD_ZERO(&rset);
FD_ZERO(&wset);
FD_SET(m_nSockFd, &rset);
wset = rset;
timeval tval;
if (a_nTimeoutSec > 0) {
tval.tv_sec = a_nTimeoutSec;
tval.tv_usec = 0;
} else if (a_nTimeoutSec < 0) {
tval.tv_sec = 0;
tval.tv_usec = 1;
}
int ret = select(m_nSockFd + 1, &rset, &wset, NULL, ((a_nTimeoutSec == 0) ? NULL : &tval));
if (ret <= 0) {
Close();
m_enError = SOCK_TIMEOUT;
m_strErrorMsg = "socket connect timeout";
return false;
} else {
if (FD_ISSET(m_nSockFd, &rset) || FD_ISSET(m_nSockFd, &wset)) {
int sockerr = 0;
socklen_t socklen = sizeof(sockerr);
if (getsockopt(m_nSockFd, SOL_SOCKET, SO_ERROR, &sockerr, &socklen) < 0) {
Close();
m_enError = SOCK_ERROR;
m_strErrorMsg = "socket connect failed, call getsockopt";
return false;
} else if (sockerr) {
Close();
m_enError = SOCK_ERROR;
m_strErrorMsg = "socket connect failed";
return false;
}
}
}
return true;
}
static void
socketAccept(TSocket * const listenSocketP,
abyss_bool * const connectedP,
abyss_bool * const failedP,
TSocket ** const acceptedSocketPP,
TIPAddr * const ipAddrP) {
/*----------------------------------------------------------------------------
Accept a connection on the listening socket 'listenSocketP'. Return as
*acceptedSocketPP the socket for the accepted connection.
If no connection is waiting on 'listenSocketP', wait until one is.
If we receive a signal while waiting, return immediately.
Return *connectedP true iff we accepted a connection. Return
*failedP true iff we were unable to accept a connection for some
reason other than that we were interrupted. Return both false if
our wait for a connection was interrupted by a signal.
-----------------------------------------------------------------------------*/
struct socketUnix * const listenSocketUnixP = listenSocketP->implP;
abyss_bool connected, failed, interrupted;
connected = FALSE;
failed = FALSE;
interrupted = FALSE;
while (!connected && !failed && !interrupted) {
struct sockaddr_in sa;
socklen_t size = sizeof(sa);
int rc;
rc = accept(listenSocketUnixP->fd, (struct sockaddr *)&sa, &size);
if (rc >= 0) {
int const acceptedFd = rc;
struct socketUnix * acceptedSocketUnixP;
MALLOCVAR(acceptedSocketUnixP);
if (acceptedSocketUnixP) {
acceptedSocketUnixP->fd = acceptedFd;
acceptedSocketUnixP->userSuppliedFd = FALSE;
SocketCreate(&vtbl, acceptedSocketUnixP, acceptedSocketPP);
if (!*acceptedSocketPP)
failed = TRUE;
else {
connected = TRUE;
*ipAddrP = sa.sin_addr;
}
if (failed)
free(acceptedSocketUnixP);
} else
failed = TRUE;
if (failed)
close(acceptedFd);
} else if (errno == EINTR)
interrupted = TRUE;
else
failed = TRUE;
}
*failedP = failed;
*connectedP = connected;
}
static void *tcp_thread(void *data)
{
int sockfd, fromSock, n;
socklen_t addrLen;
char bufArray[BUF_16K];
struct sockaddr_in addr;
IXML_Document *dom = NULL;
IXML_Node *node = NULL;
char *op = NULL;
char *value = NULL;
gint speed;
gulong nsecs, systemnsecs;
SYNC_STATE syncState = SYNC_STATE_STOPPED;
gboolean isVisible;
ZKPlayerView *view = ZKPLAYER_VIEW(data);
sockfd = SocketCreate(ZKPLAYER_IP, ZKPLAYER_PORT, SOCKET_TCP, SOCKET_LISTENER);
if(sockfd < 0)
goto funcOut;
addrLen = sizeof(addr);
while(1) {
ZInfo1(DBG_INIT, "Listening for new event...");
memset(bufArray, 0, BUF_16K);
fromSock = accept(sockfd, (struct sockaddr *)&addr, &addrLen);
n = read(fromSock, bufArray, BUF_16K);
ZInfo1(DBG_INIT, "Receive TCP XML -> %s\n", bufArray);
if(n <= 0)
goto funcNextCmd;
dom = ixmlParseBuffer(bufArray);
if(dom ==NULL) {
ZError(DBG_INIT, "Invalid xml string.");
goto funcNextCmd;
}
node = ixmlGetFirstNodeByTagName(dom, "cmd");
if(node == NULL) {
ZError(DBG_INIT, "Cannot find cmd tag.");
ResponseCMD(fromSock, "Unknown", 2);
goto funcContinue;
}
op = GetNodeAttributeByName(node, "op");
if(op == NULL) {
ZError(DBG_INIT, "Cannot find op attribute.");
ResponseCMD(fromSock, "Unknown", 2);
goto funcContinue;
}
/* Handle op */
if(!strcasecmp(op, "playuri")) {
value = GetChildValueByName(node, "lrcuri");
if(value == NULL) {
ResponseCMD(fromSock, op, 3);
goto funcContinue;
}
zkplayer_view_play_uri(view, value);
}
else if(!strcasecmp(op, "setnexturi")) {
value = GetChildValueByName(node, "lrcuri");
if(value == NULL) {
ResponseCMD(fromSock, op, 3);
goto funcContinue;
}
zkplayer_view_set_next_uri(view, value);
}
else if(!strcasecmp(op, "play")) {
value = GetChildValueByName(node, "speed");
if(value == NULL) {
ResponseCMD(fromSock, op, 4);
goto funcContinue;
}
speed = atoi(value);
/** NOTE: Remember to remove when bug done 090208 **/
//zkplayer_view_play(view, speed);
}
else if(!strcasecmp(op, "pause")) {
zkplayer_view_pause(view);
}
else if(!strcasecmp(op, "stop")) {
zkplayer_view_stop(view);
}
else if(!strcasecmp(op, "sync")) {
//get syncState
value = GetChildValueByName(node, "status");
if(value == NULL) {
ResponseCMD(fromSock, op, 9);
goto funcContinue;
}
if(!strcasecmp(value, "STARTING"))
syncState = SYNC_STATE_START;
else if(!strcasecmp(value, "PLAYING"))
syncState = SYNC_STATE_PLAYING;
else if(!strcasecmp(value, "STOPPED"))
syncState = SYNC_STATE_STOPPED;
//get nsecs
value = GetChildValueByName(node, "nsecs");
if(value == NULL) {
ResponseCMD(fromSock, op, 5);
goto funcContinue;
}
nsecs = (gulong)strtoul(value, NULL, 10);
//get systemnsecs
value = GetChildValueByName(node, "systemnsecs");
if(value == NULL) {
ResponseCMD(fromSock, op, 6);
goto funcContinue;
}
systemnsecs = (gulong)strtoul(value, NULL, 10);
zkplayer_view_sync(view, syncState, nsecs, systemnsecs);
/* NOTE: We don't give response to zplayer */
goto funcContinue;
}
else if(!strcasecmp(op, "seek")) {
//get secs
value = GetChildValueByName(node, "secs");
if(value == NULL) {
ResponseCMD(fromSock, op, 7);
goto funcContinue;
}
nsecs = (gulong)strtoul(value, NULL, 10);
zkplayer_view_seek(view, nsecs);
}
else if(!strcasecmp(op, "visible")) {
value = GetChildValueByName(node, "flag");
if(value == NULL) {
ResponseCMD(fromSock, op, 8);
goto funcContinue;
}
isVisible = !strcasecmp(value, "FALSE") ? FALSE : TRUE;
zkplayer_view_visible(view, isVisible);
}
else {
ZInfo1(DBG_INIT, "Unknown op -> %s", op);
ResponseCMD(fromSock, op, 1);
goto funcContinue;
}
/* Ok, it's right */
ResponseCMD(fromSock, op, 0);
funcContinue:
ixmlDocument_free(dom);
funcNextCmd:
close(fromSock);
}
close(sockfd);
funcOut:
ZInfo4(DBG_INIT, "The thead exit.");
pthread_exit((void *)0);
}
