static void socketAccept(socket_t *sp)
{
struct sockaddr_in addr;
socket_t *nsp;
size_t len;
char *pString;
int newSock, nid;
#ifdef NW
NETINET_DEFINE_CONTEXT;
#endif
a_assert(sp);
/*
* Accept the connection and prevent inheriting by children (F_SETFD)
*/
len = sizeof(struct sockaddr_in);
if ((newSock = accept(sp->sock, (struct sockaddr *) &addr, (int *) &len)) < 0) {
return;
}
#ifndef __NO_FCNTL
fcntl(newSock, F_SETFD, FD_CLOEXEC);
#endif
socketHighestFd = max(socketHighestFd, newSock);
/*
* Create a socket structure and insert into the socket list
*/
nid = socketAlloc(sp->host, sp->port, sp->accept, sp->flags);
nsp = socketList[nid];
a_assert(nsp);
if (nsp == NULL)
return;
nsp->sock = newSock;
nsp->flags &= ~SOCKET_LISTENING;
/*
* Set the blocking mode before calling the accept callback.
*/
socketSetBlock(nid, (nsp->flags & SOCKET_BLOCK) ? 1: 0);
/*
* Call the user accept callback. The user must call socketCreateHandler
* to register for further events of interest.
*/
if (sp->accept != NULL) {
pString = inet_ntoa(addr.sin_addr);
if ((sp->accept)(nid, pString, ntohs(addr.sin_port), sp->sid) < 0) {
socketFree(nid);
}
#ifdef VXWORKS
free(pString);
#endif
}
}
/*
Accept a connection. Called as a callback on incoming connection.
*/
static void socketAccept(WebsSocket *sp)
{
struct sockaddr_storage addrStorage;
struct sockaddr *addr;
WebsSocket *nsp;
Socket newSock;
size_t len;
char ipbuf[1024];
int port, nid;
assert(sp);
/*
Accept the connection and prevent inheriting by children (F_SETFD)
*/
len = sizeof(addrStorage);
addr = (struct sockaddr*) &addrStorage;
if ((newSock = accept(sp->sock, addr, (Socklen*) &len)) == SOCKET_ERROR) {
return;
}
#if ME_COMPILER_HAS_FCNTL
fcntl(newSock, F_SETFD, FD_CLOEXEC);
#endif
socketHighestFd = max(socketHighestFd, newSock);
/*
Create a socket structure and insert into the socket list
*/
nid = socketAlloc(sp->ip, sp->port, sp->accept, sp->flags);
if ((nsp = socketList[nid]) == 0) {
return;
}
assert(nsp);
nsp->sock = newSock;
nsp->flags &= ~SOCKET_LISTENING;
socketSetBlock(nid, (nsp->flags & SOCKET_BLOCK));
if (nsp->flags & SOCKET_NODELAY) {
socketSetNoDelay(nid, 1);
}
/*
Call the user accept callback. The user must call socketCreateHandler to register for further events of interest.
*/
if (sp->accept != NULL) {
/* Get the remote client address */
socketAddress(addr, (int) len, ipbuf, sizeof(ipbuf), &port);
if ((sp->accept)(nid, ipbuf, port, sp->sid) < 0) {
socketFree(nid);
}
}
}
PUBLIC int socketConnect(char *ip, int port, int flags)
{
WebsSocket *sp;
struct sockaddr_storage addr;
socklen_t addrlen;
int family, protocol, sid, rc;
if (port > SOCKET_PORT_MAX) {
return -1;
}
if ((sid = socketAlloc(ip, port, NULL, flags)) < 0) {
return -1;
}
sp = socketList[sid];
assert(sp);
if (socketInfo(ip, port, &family, &protocol, &addr, &addrlen) < 0) {
return -1;
}
if ((sp->sock = socket(AF_INET, SOCK_STREAM, 0)) == SOCKET_ERROR) {
socketFree(sid);
return -1;
}
socketHighestFd = max(socketHighestFd, sp->sock);
#if ME_COMPILER_HAS_FCNTL
fcntl(sp->sock, F_SETFD, FD_CLOEXEC);
#endif
/*
Connect to the remote server in blocking mode, then go into non-blocking mode if desired.
*/
if (!(sp->flags & SOCKET_BLOCK)) {
#if ME_WIN_LIKE
/*
Set to non-blocking for an async connect
*/
int flag = 1;
if (ioctlsocket(sp->sock, FIONBIO, &flag) == SOCKET_ERROR) {
socketFree(sid);
return -1;
}
sp->flags |= SOCKET_ASYNC;
#else
socketSetBlock(sid, 1);
#endif
}
if ((rc = connect(sp->sock, (struct sockaddr*) &addr, sizeof(addr))) < 0 &&
(rc = tryAlternateConnect(sp->sock, (struct sockaddr*) &addr)) < 0) {
#if ME_WIN_LIKE
if (socketGetError() != EWOULDBLOCK) {
socketFree(sid);
return -1;
}
#else
socketFree(sid);
return -1;
#endif
}
socketSetBlock(sid, (flags & SOCKET_BLOCK));
return sid;
}
PUBLIC int socketListen(char *ip, int port, SocketAccept accept, int flags)
{
WebsSocket *sp;
struct sockaddr_storage addr;
Socklen addrlen;
char *sip;
int family, protocol, sid, rc, only;
if (port > SOCKET_PORT_MAX) {
return -1;
}
if ((sid = socketAlloc(ip, port, accept, flags)) < 0) {
return -1;
}
sp = socketList[sid];
assert(sp);
/*
Change null IP address to be an IPv6 endpoint if the system is dual-stack. That way we can listen on
both IPv4 and IPv6
*/
sip = ((ip == 0 || *ip == '\0') && socketHasDualNetworkStack()) ? "::" : ip;
/*
Bind to the socket endpoint and the call listen() to start listening
*/
if (socketInfo(sip, port, &family, &protocol, &addr, &addrlen) < 0) {
return -1;
}
if ((sp->sock = socket(family, SOCK_STREAM, protocol)) == SOCKET_ERROR) {
socketFree(sid);
return -1;
}
socketHighestFd = max(socketHighestFd, sp->sock);
#if ME_COMPILER_HAS_FCNTL
fcntl(sp->sock, F_SETFD, FD_CLOEXEC);
#endif
rc = 1;
#if ME_UNIX_LIKE || VXWORKS
setsockopt(sp->sock, SOL_SOCKET, SO_REUSEADDR, (char*) &rc, sizeof(rc));
#elif ME_WIN_LIKE && defined(SO_EXCLUSIVEADDRUSE)
setsockopt(sp->sock, SOL_SOCKET, SO_REUSEADDR | SO_EXCLUSIVEADDRUSE, (char*) &rc, sizeof(rc));
#endif
#if defined(IPV6_V6ONLY)
/*
By default, most stacks listen on both IPv6 and IPv4 if ip == 0, except windows which inverts this.
So we explicitly control.
*/
if (hasIPv6) {
if (ip == 0) {
only = 0;
setsockopt(sp->sock, IPPROTO_IPV6, IPV6_V6ONLY, (char*) &only, sizeof(only));
} else if (ipv6(ip)) {
only = 1;
setsockopt(sp->sock, IPPROTO_IPV6, IPV6_V6ONLY, (char*) &only, sizeof(only));
}
}
#endif
if (bind(sp->sock, (struct sockaddr*) &addr, addrlen) == SOCKET_ERROR) {
error("Can't bind to address %s:%d, errno %d", ip ? ip : "*", port, errno);
socketFree(sid);
return -1;
}
if (listen(sp->sock, SOMAXCONN) < 0) {
socketFree(sid);
return -1;
}
sp->flags |= SOCKET_LISTENING | SOCKET_NODELAY;
sp->handlerMask |= SOCKET_READABLE;
socketSetBlock(sid, (flags & SOCKET_BLOCK));
if (sp->flags & SOCKET_NODELAY) {
socketSetNoDelay(sid, 1);
}
return sid;
}
int socketOpenConnection(char *host, int port, socketAccept_t accept, int flags)
{
#if (!defined (NO_GETHOSTBYNAME) && !defined (VXWORKS))
struct hostent *hostent; /* Host database entry */
#endif /* ! (NO_GETHOSTBYNAME || VXWORKS) */
socket_t *sp;
struct sockaddr_in sockaddr;
int sid, bcast, dgram, rc;
#ifdef WF_USE_IPV6
int gaierr;
char portstr[10];
struct addrinfo hints;
struct addrinfo *ai, *ai2, *aiv6 = NULL;
struct sockaddr_in6 sockaddr6;
#endif
if (port > SOCKET_PORT_MAX) {
return -1;
}
/*
* Allocate a socket structure
*/
if ((sid = socketAlloc(host, port, accept, flags)) < 0) {
return -1;
}
sp = socketList[sid];
a_assert(sp);
/*
* Create the socket address structure
*/
#ifdef WF_USE_IPV6
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_flags = AI_PASSIVE;
hints.ai_socktype = SOCK_STREAM;
snprintf(portstr, sizeof(portstr), "%d", port);
if ((gaierr = getaddrinfo(host, portstr, &hints, &ai)) != 0) {
fprintf(stderr, "goahead: getaddrinfo - %s\n", gai_strerror(gaierr));
socketFree(sid);
return -1;
}
aiv6 = NULL;
for (ai2 = ai; ai2 != (struct addrinfo*)0; ai2 = ai2->ai_next) {
switch (ai2->ai_family) {
case AF_INET6:
if (aiv6 == NULL)
aiv6 = ai2;
break;
}
}
if (aiv6 == NULL) {
fprintf(stderr, "goahead: cannot find IPv6 addrinfo\n");
socketFree(sid);
return -1;
}
memcpy(&sockaddr6, aiv6->ai_addr, aiv6->ai_addrlen);
freeaddrinfo(ai);
#else /* WF_USE_IPV6 */
memset((char *) &sockaddr, '\0', sizeof(struct sockaddr_in));
sockaddr.sin_family = AF_INET;
sockaddr.sin_port = htons((short) (port & 0xFFFF));
if (host == NULL) {
sockaddr.sin_addr.s_addr = INADDR_ANY;
} else {
sockaddr.sin_addr.s_addr = inet_addr(host);
if (sockaddr.sin_addr.s_addr == INADDR_NONE) {
/*
* If the OS does not support gethostbyname functionality, the macro:
* NO_GETHOSTBYNAME should be defined to skip the use of gethostbyname.
* Unfortunatly there is no easy way to recover, the following code
* simply uses the basicGetHost IP for the sockaddr.
*/
#ifdef NO_GETHOSTBYNAME
if (strcmp(host, basicGetHost()) == 0) {
sockaddr.sin_addr.s_addr = inet_addr(basicGetAddress());
}
if (sockaddr.sin_addr.s_addr == INADDR_NONE) {
socketFree(sid);
return -1;
}
#elif (defined (VXWORKS))
sockaddr.sin_addr.s_addr = (unsigned long) hostGetByName(host);
if (sockaddr.sin_addr.s_addr == NULL) {
errno = ENXIO;
socketFree(sid);
return -1;
}
#else
hostent = gethostbyname(host);
if (hostent != NULL) {
memcpy((char *) &sockaddr.sin_addr,
(char *) hostent->h_addr_list[0],
(size_t) hostent->h_length);
} else {
char *asciiAddress;
char_t *address;
address = basicGetAddress();
asciiAddress = ballocUniToAsc(address, gstrlen(address));
sockaddr.sin_addr.s_addr = inet_addr(asciiAddress);
bfree(B_L, asciiAddress);
if (sockaddr.sin_addr.s_addr == INADDR_NONE) {
errno = ENXIO;
socketFree(sid);
return -1;
}
}
#endif /* (NO_GETHOSTBYNAME || VXWORKS) */
}
}
#endif /* WF_USE_IPV6 */
bcast = sp->flags & SOCKET_BROADCAST;
if (bcast) {
sp->flags |= SOCKET_DATAGRAM;
}
dgram = sp->flags & SOCKET_DATAGRAM;
/*
* Create the socket. Support for datagram sockets. Set the close on
* exec flag so children don't inherit the socket.
*/
#ifdef WF_USE_IPV6
sp->sock = socket(AF_INET6, SOCK_STREAM, 0);
#else
sp->sock = socket(AF_INET, dgram ? SOCK_DGRAM: SOCK_STREAM, 0);
#endif
if (sp->sock < 0) {
socketFree(sid);
return -1;
}
#ifndef __NO_FCNTL
fcntl(sp->sock, F_SETFD, FD_CLOEXEC);
#endif
socketHighestFd = max(socketHighestFd, sp->sock);
/*
* If broadcast, we need to turn on broadcast capability.
*/
if (bcast) {
int broadcastFlag = 1;
if (setsockopt(sp->sock, SOL_SOCKET, SO_BROADCAST,
(char *) &broadcastFlag, sizeof(broadcastFlag)) < 0) {
socketFree(sid);
return -1;
}
}
/*
* Host is set if we are the client
*/
if (host) {
/*
* Connect to the remote server in blocking mode, then go into
* non-blocking mode if desired.
*/
if (!dgram) {
if (! (sp->flags & SOCKET_BLOCK)) {
/*
* sockGen.c is only used for Windows products when blocking
* connects are expected. This applies to FieldUpgrader
* agents and open source webserver connectws. Therefore the
* asynchronous connect code here is not compiled.
*/
#if (defined (WIN) || defined (CE)) && (!defined (LITTLEFOOT) && !defined (WEBS))
int flag;
sp->flags |= SOCKET_ASYNC;
/*
* Set to non-blocking for an async connect
*/
flag = 1;
if (ioctlsocket(sp->sock, FIONBIO, &flag) == SOCKET_ERROR) {
socketFree(sid);
return -1;
}
#else
socketSetBlock(sid, 1);
#endif /* #if (WIN || CE) && !(LITTLEFOOT || WEBS) */
}
if ((rc = connect(sp->sock, (struct sockaddr *) &sockaddr,
sizeof(sockaddr))) < 0 &&
(rc = tryAlternateConnect(sp->sock,
(struct sockaddr *) &sockaddr)) < 0) {
#if (defined (WIN) || defined (CE))
if (socketGetError() != EWOULDBLOCK) {
socketFree(sid);
return -1;
}
#else
socketFree(sid);
return -1;
#endif /* WIN || CE */
}
}
} else {
/*
* Bind to the socket endpoint and the call listen() to start listening
*/
rc = 1;
setsockopt(sp->sock, SOL_SOCKET, SO_REUSEADDR, (char *)&rc, sizeof(rc));
#ifdef WF_USE_IPV6
if (bind(sp->sock, (struct sockaddr *) &sockaddr6,
sizeof(sockaddr6)) < 0) {
#else
if (bind(sp->sock, (struct sockaddr *) &sockaddr,
sizeof(sockaddr)) < 0) {
#endif
socketFree(sid);
return -1;
}
if (! dgram) {
if (listen(sp->sock, SOMAXCONN) < 0) {
socketFree(sid);
return -1;
}
sp->flags |= SOCKET_LISTENING;
}
sp->handlerMask |= SOCKET_READABLE;
}
/*
* Set the blocking mode
*/
if (flags & SOCKET_BLOCK) {
socketSetBlock(sid, 1);
} else {
socketSetBlock(sid, 0);
}
return sid;
}
/******************************************************************************/
/*
* If the connection failed, swap the first two bytes in the
* sockaddr structure. This is a kludge due to a change in
* VxWorks between versions 5.3 and 5.4, but we want the
* product to run on either.
*/
static int tryAlternateConnect(int sock, struct sockaddr *sockaddr)
{
#ifdef VXWORKS
char *ptr;
ptr = (char *)sockaddr;
*ptr = *(ptr+1);
*(ptr+1) = 0;
return connect(sock, sockaddr, sizeof(struct sockaddr));
#else
return -1;
#endif /* VXWORKS */
}
int socketOpenConnection(char *host, int port, socketAccept_t accept, int flags)
{
#if (!defined (NO_GETHOSTBYNAME) && !defined (VXWORKS))
struct hostent *hostent; /* Host database entry */
#endif /* ! (NO_GETHOSTBYNAME || VXWORKS) */
socket_t *sp;
struct sockaddr_in sockaddr;
int sid, bcast, dgram, rc;
if (port > SOCKET_PORT_MAX) {
return -1;
}
/*
* Allocate a socket structure
*/
if ((sid = socketAlloc(host, port, accept, flags)) < 0) {
return -1;
}
sp = socketList[sid];
a_assert(sp);
/*
* Create the socket address structure
*/
memset((char *) &sockaddr, '\0', sizeof(struct sockaddr_in));
sockaddr.sin_family = AF_INET;
sockaddr.sin_port = htons((short) (port & 0xFFFF));
if (host == NULL) {
sockaddr.sin_addr.s_addr = INADDR_ANY;
} else {
sockaddr.sin_addr.s_addr = inet_addr(host);
if (sockaddr.sin_addr.s_addr == INADDR_NONE) {
/*
* If the OS does not support gethostbyname functionality, the macro:
* NO_GETHOSTBYNAME should be defined to skip the use of gethostbyname.
* Unfortunatly there is no easy way to recover, the following code
* simply uses the basicGetHost IP for the sockaddr.
*/
#ifdef NO_GETHOSTBYNAME
if (strcmp(host, basicGetHost()) == 0) {
sockaddr.sin_addr.s_addr = inet_addr(basicGetAddress());
}
if (sockaddr.sin_addr.s_addr == INADDR_NONE) {
socketFree(sid);
return -1;
}
#elif (defined (VXWORKS))
sockaddr.sin_addr.s_addr = (unsigned long) hostGetByName(host);
if (sockaddr.sin_addr.s_addr == NULL) {
errno = ENXIO;
socketFree(sid);
return -1;
}
#else
hostent = gethostbyname(host);
if (hostent != NULL) {
memcpy((char *) &sockaddr.sin_addr,
(char *) hostent->h_addr_list[0],
(size_t) hostent->h_length);
} else {
char *asciiAddress;
char *address;
address = basicGetAddress();
asciiAddress = ballocUniToAsc(address, gstrlen(address));
sockaddr.sin_addr.s_addr = inet_addr(asciiAddress);
bfree(B_L, asciiAddress);
if (sockaddr.sin_addr.s_addr == INADDR_NONE) {
errno = ENXIO;
socketFree(sid);
return -1;
}
}
#endif /* (NO_GETHOSTBYNAME || VXWORKS) */
}
}
bcast = sp->flags & SOCKET_BROADCAST;
if (bcast) {
sp->flags |= SOCKET_DATAGRAM;
}
dgram = sp->flags & SOCKET_DATAGRAM;
/*
* Create the socket. Support for datagram sockets. Set the close on
* exec flag so children don't inherit the socket.
*/
sp->sock = socket(AF_INET, dgram ? SOCK_DGRAM: SOCK_STREAM, 0);
if (sp->sock < 0) {
socketFree(sid);
return -1;
}
#ifndef __NO_FCNTL
fcntl(sp->sock, F_SETFD, FD_CLOEXEC);
#endif
socketHighestFd = max(socketHighestFd, sp->sock);
/*
* If broadcast, we need to turn on broadcast capability.
*/
if (bcast) {
int broadcastFlag = 1;
if (setsockopt(sp->sock, SOL_SOCKET, SO_BROADCAST,
(char *) &broadcastFlag, sizeof(broadcastFlag)) < 0) {
socketFree(sid);
return -1;
}
}
/*
* Host is set if we are the client
*/
if (host) {
/*
* Connect to the remote server in blocking mode, then go into
* non-blocking mode if desired.
*/
if (!dgram) {
if (! (sp->flags & SOCKET_BLOCK)) {
/*
* sockGen.c is only used for Windows products when blocking
* connects are expected. This applies to FieldUpgrader
* agents and open source webserver connectws. Therefore the
* asynchronous connect code here is not compiled.
*/
#if (defined (WIN) || defined (CE)) && (!defined (LITTLEFOOT) && !defined (WEBS))
int flag;
sp->flags |= SOCKET_ASYNC;
/*
* Set to non-blocking for an async connect
*/
flag = 1;
if (ioctlsocket(sp->sock, FIONBIO, &flag) == SOCKET_ERROR) {
socketFree(sid);
return -1;
}
#else
socketSetBlock(sid, 1);
#endif /* #if (WIN || CE) && !(LITTLEFOOT || WEBS) */
}
if ((rc = connect(sp->sock, (struct sockaddr *) &sockaddr,
sizeof(sockaddr))) < 0 &&
(rc = tryAlternateConnect(sp->sock,
(struct sockaddr *) &sockaddr)) < 0) {
#if (defined (WIN) || defined (CE))
if (socketGetError() != EWOULDBLOCK) {
socketFree(sid);
return -1;
}
#else
socketFree(sid);
return -1;
#endif /* WIN || CE */
}
}
} else {
/*
* Bind to the socket endpoint and the call listen() to start listening
*/
rc = 1;
setsockopt(sp->sock, SOL_SOCKET, SO_REUSEADDR, (char *)&rc, sizeof(rc));
if (bind(sp->sock, (struct sockaddr *) &sockaddr,
sizeof(sockaddr)) < 0) {
socketFree(sid);
return -1;
}
if (! dgram) {
if (listen(sp->sock, SOMAXCONN) < 0) {
socketFree(sid);
return -1;
}
#ifndef UEMF
sp->fileHandle = emfCreateFileHandler(sp->sock, SOCKET_READABLE,
(emfFileProc *) socketAccept, (void *) sp);
#else
sp->flags |= SOCKET_LISTENING;
#endif
}
sp->handlerMask |= SOCKET_READABLE;
}
/*
* Set the blocking mode
*/
if (flags & SOCKET_BLOCK) {
socketSetBlock(sid, 1);
} else {
socketSetBlock(sid, 0);
}
return sid;
}
