bool repeaterClient::connect ()
{
int status;
if ( ! makeSocket ( PORT_ANY, false, & this->sock ) ) {
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
fprintf ( stderr, "%s: no client sock because \"%s\"\n",
__FILE__, sockErrBuf );
return false;
}
status = ::connect ( this->sock, &this->from.sa, sizeof ( this->from.sa ) );
if ( status < 0 ) {
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
fprintf ( stderr, "%s: unable to connect client sock because \"%s\"\n",
__FILE__, sockErrBuf );
return false;
}
return true;
}
void BlockingUDPTransport::setMutlicastNIF(const osiSockAddr & nifAddr, bool loopback)
{
// set the multicast outgoing interface
int status = ::setsockopt(_channel, IPPROTO_IP, IP_MULTICAST_IF,
(char*)&nifAddr.ia.sin_addr, sizeof(struct in_addr));
if (status)
{
char errStr[64];
epicsSocketConvertErrnoToString(errStr, sizeof(errStr));
throw std::runtime_error(
string("Failed to set multicast network inteface '") +
inetAddressToString(nifAddr, false) + "': " + errStr);
}
// send multicast traffic to myself too
unsigned char mcast_loop = (loopback ? 1 : 0);
status = ::setsockopt(_channel, IPPROTO_IP, IP_MULTICAST_LOOP,
(char*)&mcast_loop, sizeof(unsigned char));
if (status)
{
char errStr[64];
epicsSocketConvertErrnoToString(errStr, sizeof(errStr));
throw std::runtime_error(
string("Failed to enable multicast loopback on network inteface '") +
inetAddressToString(nifAddr, false) + "': " + errStr);
}
}
Transport::shared_pointer BlockingUDPConnector::connect(TransportClient::shared_pointer const & /*client*/,
auto_ptr<ResponseHandler>& responseHandler, osiSockAddr& bindAddress,
int8 transportRevision, int16 /*priority*/) {
LOG(logLevelDebug, "Creating datagram socket to: %s.",
inetAddressToString(bindAddress).c_str());
SOCKET socket = epicsSocketCreate(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if(socket==INVALID_SOCKET) {
char errStr[64];
epicsSocketConvertErrnoToString(errStr, sizeof(errStr));
LOG(logLevelError, "Error creating socket: %s.", errStr);
return Transport::shared_pointer();
}
int optval = _broadcast ? 1 : 0;
int retval = ::setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *)&optval, sizeof(optval));
if(retval<0)
{
char errStr[64];
epicsSocketConvertErrnoToString(errStr, sizeof(errStr));
LOG(logLevelError, "Error setting SO_BROADCAST: %s.", errStr);
epicsSocketDestroy (socket);
return Transport::shared_pointer();
}
/*
IPv4 multicast addresses are defined by the leading address bits of 1110,
originating from the classful network design of the early Internet when this
group of addresses was designated as Class D. The Classless Inter-Domain Routing (CIDR)
prefix of this group is 224.0.0.0/4.
The group includes the addresses from 224.0.0.0 to 239.255.255.255.
Address assignments from within this range are specified in RFC 5771,
an Internet Engineering Task Force (IETF) Best Current Practice document (BCP 51).*/
// set SO_REUSEADDR or SO_REUSEPORT, OS dependant
if (_reuseSocket)
epicsSocketEnableAddressUseForDatagramFanout(socket);
retval = ::bind(socket, (sockaddr*)&(bindAddress.sa), sizeof(sockaddr));
if(retval<0) {
char errStr[64];
epicsSocketConvertErrnoToString(errStr, sizeof(errStr));
LOG(logLevelError, "Error binding socket: %s.", errStr);
epicsSocketDestroy (socket);
return Transport::shared_pointer();
}
// sockets are blocking by default
Transport::shared_pointer transport = BlockingUDPTransport::create(_serverFlag,
responseHandler, socket, bindAddress, transportRevision);
return transport;
}
bool repeaterClient::sendMessage ( const void *pBuf, unsigned bufSize ) // X aCC 361
{
int status;
status = send ( this->sock, (char *) pBuf, bufSize, 0 );
if ( status >= 0 ) {
assert ( static_cast <unsigned> ( status ) == bufSize );
#ifdef DEBUG
epicsUInt16 port = ntohs ( this->from.ia.sin_port );
debugPrintf ( ("Sent to %u\n", port ) );
#endif
return true;
}
else {
int errnoCpy = SOCKERRNO;
if ( errnoCpy == SOCK_ECONNREFUSED ) {
#ifdef DEBUG
epicsUInt16 port = ntohs ( this->from.ia.sin_port );
debugPrintf ( ("Client refused message %u\n", port ) );
#endif
}
else {
char sockErrBuf[64];
epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
debugPrintf ( ( "CA Repeater: UDP send err was \"%s\"\n", sockErrBuf) );
}
return false;
}
}
BlockingUDPTransport::BlockingUDPTransport(
bool serverFlag,
auto_ptr<ResponseHandler>& responseHandler, SOCKET channel,
osiSockAddr& bindAddress,
short /*remoteTransportRevision*/) :
_closed(),
_responseHandler(responseHandler),
_channel(channel),
_bindAddress(bindAddress),
_sendAddresses(0),
_ignoredAddresses(0),
_sendToEnabled(false),
_receiveBuffer(new ByteBuffer(MAX_UDP_RECV)),
_sendBuffer(new ByteBuffer(MAX_UDP_RECV)),
_lastMessageStartPosition(0),
_threadId(0),
_clientServerWithEndianFlag(
(serverFlag ? 0x40 : 0x00) | ((EPICS_BYTE_ORDER == EPICS_ENDIAN_BIG) ? 0x80 : 0x00))
{
PVACCESS_REFCOUNT_MONITOR_CONSTRUCT(blockingUDPTransport);
osiSocklen_t sockLen = sizeof(sockaddr);
// read the actual socket info
int retval = ::getsockname(_channel, &_remoteAddress.sa, &sockLen);
if(retval<0) {
// error obtaining remote address, fallback to bindAddress
_remoteAddress = _bindAddress;
char strBuffer[64];
epicsSocketConvertErrnoToString(strBuffer, sizeof(strBuffer));
LOG(logLevelDebug, "getsockname error: %s.", strBuffer);
}
}
bool BlockingUDPTransport::send(ByteBuffer* buffer, InetAddressType target) {
if(!_sendAddresses) return false;
buffer->flip();
bool allOK = true;
for(size_t i = 0; i<_sendAddresses->size(); i++) {
// filter
if (target != inetAddressType_all)
if ((target == inetAddressType_unicast && !_isSendAddressUnicast[i]) ||
(target == inetAddressType_broadcast_multicast && _isSendAddressUnicast[i]))
continue;
int retval = sendto(_channel, buffer->getArray(),
buffer->getLimit(), 0, &((*_sendAddresses)[i].sa),
sizeof(sockaddr));
if(unlikely(retval<0))
{
char errStr[64];
epicsSocketConvertErrnoToString(errStr, sizeof(errStr));
LOG(logLevelDebug, "Socket sendto error: %s.", errStr);
allOK = false;
}
}
// all sent
buffer->setPosition(buffer->getLimit());
return allOK;
}
/*
* logClientMakeSock ()
*/
static void logClientMakeSock (logClient *pClient)
{
# ifdef DEBUG
fprintf (stderr, "log client: creating socket...");
# endif
epicsMutexMustLock (pClient->mutex);
/*
* allocate a socket
*/
pClient->sock = epicsSocketCreate ( AF_INET, SOCK_STREAM, 0 );
if ( pClient->sock == INVALID_SOCKET ) {
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
fprintf ( stderr, "log client: no socket error %s\n",
sockErrBuf );
}
epicsMutexUnlock (pClient->mutex);
# ifdef DEBUG
fprintf (stderr, "done\n");
# endif
}
bool repeaterClient::sendConfirm () // X aCC 361
{
int status;
caHdr confirm;
memset ( (char *) &confirm, '\0', sizeof (confirm) );
AlignedWireRef < epicsUInt16 > ( confirm.m_cmmd ) = REPEATER_CONFIRM;
confirm.m_available = this->from.ia.sin_addr.s_addr;
status = send ( this->sock, (char *) &confirm,
sizeof (confirm), 0 );
if ( status >= 0 ) {
assert ( status == sizeof ( confirm ) );
return true;
}
else if ( SOCKERRNO == SOCK_ECONNREFUSED ) {
return false;
}
else {
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
debugPrintf ( ( "CA Repeater: confirm req err was \"%s\"\n", sockErrBuf) );
return false;
}
}
int Eiger::connect (void)
{
const char *functionName = "connect";
if(!mSockClosed)
return EXIT_SUCCESS;
mSockFd = epicsSocketCreate(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(mSockFd == INVALID_SOCKET)
{
ERR("couldn't create socket");
return EXIT_FAILURE;
}
setNonBlock(true);
if(::connect(mSockFd, (struct sockaddr*)&mAddress, sizeof(mAddress)) < 0)
{
// Connection actually failed
if(errno != EINPROGRESS)
{
char error[MAX_BUF_SIZE];
epicsSocketConvertErrnoToString(error, sizeof(error));
ERR_ARGS("failed to connect to %s:%d [%s]", mHostname, HTTP_PORT, error);
epicsSocketDestroy(mSockFd);
return EXIT_FAILURE;
}
// Server didn't respond immediately, wait a little
else
{
fd_set set;
struct timeval tv;
int ret;
FD_ZERO(&set);
FD_SET(mSockFd, &set);
tv.tv_sec = DEFAULT_TIMEOUT_CONNECT;
tv.tv_usec = 0;
ret = select(mSockFd + 1, NULL, &set, NULL, &tv);
if(ret <= 0)
{
const char *error = ret == 0 ? "TIMEOUT" : "select failed";
ERR_ARGS("failed to connect to %s:%d [%s]", mHostname, HTTP_PORT, error);
epicsSocketDestroy(mSockFd);
return EXIT_FAILURE;
}
}
}
setNonBlock(false);
mSockClosed = false;
return EXIT_SUCCESS;
}
epicsShareFunc void epicsShareAPI epicsSocketDestroy ( SOCKET s )
{
int status = close ( s );
if ( status < 0 ) {
char buf [ 64 ];
epicsSocketConvertErrnoToString ( buf, sizeof ( buf ) );
errlogPrintf (
"epicsSocketDestroy: failed to "
"close a socket because \"%s\"\n",
buf );
}
}
void udpiiu :: SearchDestUDP :: searchRequest (
epicsGuard < epicsMutex > & guard, const char * pBuf, size_t bufSize )
{
guard.assertIdenticalMutex ( _udpiiu.cacMutex );
assert ( bufSize <= INT_MAX );
int bufSizeAsInt = static_cast < int > ( bufSize );
while ( true ) {
// This const_cast is needed for vxWorks:
int status = sendto ( _udpiiu.sock, const_cast<char *>(pBuf), bufSizeAsInt, 0,
& _destAddr.sa, sizeof ( _destAddr.sa ) );
if ( status == bufSizeAsInt ) {
break;
}
if ( status >= 0 ) {
errlogPrintf ( "CAC: UDP sendto () call returned strange xmit count?\n" );
break;
}
else {
int localErrno = SOCKERRNO;
if ( localErrno == SOCK_EINTR ) {
if ( _udpiiu.shutdownCmd ) {
break;
}
else {
continue;
}
}
else if ( localErrno == SOCK_SHUTDOWN ) {
break;
}
else if ( localErrno == SOCK_ENOTSOCK ) {
break;
}
else if ( localErrno == SOCK_EBADF ) {
break;
}
else {
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
char buf[64];
sockAddrToDottedIP ( &_destAddr.sa, buf, sizeof ( buf ) );
errlogPrintf (
"CAC: error = \"%s\" sending UDP msg to %s\n",
sockErrBuf, buf);
break;
}
}
}
}
SOCKET BlockingTCPConnector::tryConnect(osiSockAddr& address, int tries) {
char strBuffer[64];
ipAddrToDottedIP(&address.ia, strBuffer, sizeof(strBuffer));
for(int tryCount = 0; tryCount<tries; tryCount++) {
LOG(logLevelDebug,
"Opening socket to PVA server %s, attempt %d.",
strBuffer, tryCount+1);
SOCKET socket = epicsSocketCreate(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (socket == INVALID_SOCKET)
{
epicsSocketConvertErrnoToString(strBuffer, sizeof(strBuffer));
std::ostringstream temp;
temp<<"Socket create error: "<<strBuffer;
THROW_EXCEPTION2(std::runtime_error, temp.str());
}
else {
// TODO: use non-blocking connect() to have controllable timeout
if(::connect(socket, &address.sa, sizeof(sockaddr))==0) {
return socket;
}
else {
epicsSocketConvertErrnoToString(strBuffer, sizeof(strBuffer));
char saddr[32];
sockAddrToDottedIP(&address.sa, saddr, sizeof(saddr));
epicsSocketDestroy (socket);
std::ostringstream temp;
temp<<"error connecting to "<<saddr<<" : "<<strBuffer;
throw std::runtime_error(temp.str());
}
}
}
return INVALID_SOCKET;
}
void udpRecvThread::run ()
{
epicsThreadPrivateSet ( caClientCallbackThreadId, &this->iiu );
if ( this->iiu._searchDestList.count () == 0 ) {
callbackManager mgr ( this->ctxNotify, this->cbMutex );
epicsGuard < epicsMutex > guard ( this->iiu.cacMutex );
genLocalExcep ( mgr.cbGuard, guard,
this->iiu.cacRef, ECA_NOSEARCHADDR, NULL );
}
do {
osiSockAddr src;
osiSocklen_t src_size = sizeof ( src );
int status = recvfrom ( this->iiu.sock,
this->iiu.recvBuf, sizeof ( this->iiu.recvBuf ), 0,
& src.sa, & src_size );
if ( status <= 0 ) {
if ( status < 0 ) {
int errnoCpy = SOCKERRNO;
if (
errnoCpy != SOCK_EINTR &&
errnoCpy != SOCK_SHUTDOWN &&
errnoCpy != SOCK_ENOTSOCK &&
errnoCpy != SOCK_EBADF &&
// Avoid spurious ECONNREFUSED bug in linux
errnoCpy != SOCK_ECONNREFUSED &&
// Avoid ECONNRESET from disconnected socket bug
// in windows
errnoCpy != SOCK_ECONNRESET ) {
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
errlogPrintf ( "CAC: UDP recv error was \"%s\"\n",
sockErrBuf );
}
}
}
else if ( status > 0 ) {
this->iiu.postMsg ( src, this->iiu.recvBuf,
(arrayElementCount) status, epicsTime::getCurrent() );
}
} while ( ! this->iiu.shutdownCmd );
}
bool repeaterClient::verify () // X aCC 361
{
SOCKET tmpSock;
bool success = makeSocket ( this->port (), false, & tmpSock );
if ( success ) {
epicsSocketDestroy ( tmpSock );
}
else {
if ( SOCKERRNO != SOCK_EADDRINUSE ) {
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
fprintf ( stderr, "CA Repeater: bind test err was \"%s\"\n",
sockErrBuf );
}
}
return ! success;
}
bool BlockingUDPTransport::send(ByteBuffer* buffer, const osiSockAddr& address) {
buffer->flip();
int retval = sendto(_channel, buffer->getArray(),
buffer->getLimit(), 0, &(address.sa), sizeof(sockaddr));
if(unlikely(retval<0))
{
char errStr[64];
epicsSocketConvertErrnoToString(errStr, sizeof(errStr));
LOG(logLevelDebug, "Socket sendto error: %s.", errStr);
return false;
}
// all sent
buffer->setPosition(buffer->getLimit());
return true;
}
size_t BlockingUDPTransport::getSocketReceiveBufferSize() const {
// Get value of the SO_RCVBUF option for this DatagramSocket,
// that is the buffer size used by the platform for input on
// this DatagramSocket.
int sockBufSize = -1;
osiSocklen_t intLen = sizeof(int);
int retval = getsockopt(_channel, SOL_SOCKET, SO_RCVBUF, (char *)&sockBufSize, &intLen);
if(unlikely(retval<0))
{
char errStr[64];
epicsSocketConvertErrnoToString(errStr, sizeof(errStr));
LOG(logLevelError, "Socket getsockopt SO_RCVBUF error: %s.", errStr);
}
return (size_t)sockBufSize;
}
static void readFromClient(void *pParam)
{
struct iocLogClient *pclient = (struct iocLogClient *)pParam;
int recvLength;
int size;
logTime(pclient);
size = (int) (sizeof(pclient->recvbuf) - pclient->nChar);
recvLength = recv(pclient->insock,
&pclient->recvbuf[pclient->nChar],
size,
0);
if (recvLength <= 0) {
if (recvLength<0) {
int errnoCpy = SOCKERRNO;
if (errnoCpy==SOCK_EWOULDBLOCK || errnoCpy==SOCK_EINTR) {
return;
}
if (errnoCpy != SOCK_ECONNRESET &&
errnoCpy != SOCK_ECONNABORTED &&
errnoCpy != SOCK_EPIPE &&
errnoCpy != SOCK_ETIMEDOUT
) {
char sockErrBuf[64];
epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
fprintf(stderr,
"%s:%d socket=%d size=%d read error=%s\n",
__FILE__, __LINE__, pclient->insock,
size, sockErrBuf);
}
}
/*
* disconnect
*/
freeLogClient (pclient);
return;
}
pclient->nChar += (size_t) recvLength;
writeMessagesToLog (pclient);
}
void epicsShareAPI logClientFlush ( logClientId id )
{
logClient * pClient = ( logClient * ) id;
if ( ! pClient ) {
return;
}
epicsMutexMustLock ( pClient->mutex );
while ( pClient->nextMsgIndex && pClient->connected ) {
int status = send ( pClient->sock, pClient->msgBuf,
pClient->nextMsgIndex, 0 );
if ( status > 0 ) {
unsigned nSent = (unsigned) status;
if ( nSent < pClient->nextMsgIndex ) {
unsigned newNextMsgIndex = pClient->nextMsgIndex - nSent;
memmove ( pClient->msgBuf, & pClient->msgBuf[nSent],
newNextMsgIndex );
pClient->nextMsgIndex = newNextMsgIndex;
}
else {
pClient->nextMsgIndex = 0u;
}
}
else {
if ( ! pClient->shutdown ) {
char sockErrBuf[64];
if ( status ) {
epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
}
else {
strcpy ( sockErrBuf, "server initiated disconnect" );
}
fprintf ( stderr, "log client: lost contact with log server at \"%s\" because \"%s\"\n",
pClient->name, sockErrBuf );
}
logClientClose ( pClient );
break;
}
}
epicsMutexUnlock ( pClient->mutex );
}
void BlockingUDPTransport::join(const osiSockAddr & mcastAddr, const osiSockAddr & nifAddr)
{
struct ip_mreq imreq;
memset(&imreq, 0, sizeof(struct ip_mreq));
imreq.imr_multiaddr.s_addr = mcastAddr.ia.sin_addr.s_addr;
imreq.imr_interface.s_addr = nifAddr.ia.sin_addr.s_addr;
// join multicast group on default interface
int status = ::setsockopt(_channel, IPPROTO_IP, IP_ADD_MEMBERSHIP,
(char*)&imreq, sizeof(struct ip_mreq));
if (status)
{
char errStr[64];
epicsSocketConvertErrnoToString(errStr, sizeof(errStr));
throw std::runtime_error(
string("Failed to join to the multicast group '") +
inetAddressToString(mcastAddr) + "' on network interface '" +
inetAddressToString(nifAddr, false) + "': " + errStr);
}
}
epicsShareFunc int epicsShareAPI epicsSocketAccept (
int sock, struct sockaddr * pAddr, osiSocklen_t * addrlen )
{
int newSock = accept ( sock, pAddr, addrlen );
if ( newSock < 0 ) {
newSock = INVALID_SOCKET;
}
else {
int status = fcntl ( newSock, F_SETFD, FD_CLOEXEC );
if ( status < 0 ) {
char buf [ 64 ];
epicsSocketConvertErrnoToString ( buf, sizeof ( buf ) );
errlogPrintf (
"epicsSocketCreate: failed to "
"fcntl FD_CLOEXEC because \"%s\"\n",
buf );
close ( newSock );
newSock = INVALID_SOCKET;
}
}
return newSock;
}
/*
* this version sets the file control flags so that
* the socket will be closed if the user uses exec()
* as is the case with third party tools such as TCL/TK
*/
epicsShareFunc SOCKET epicsShareAPI epicsSocketCreate (
int domain, int type, int protocol )
{
SOCKET sock = socket ( domain, type, protocol );
if ( sock < 0 ) {
sock = INVALID_SOCKET;
}
else {
int status = fcntl ( sock, F_SETFD, FD_CLOEXEC );
if ( status < 0 ) {
char buf [ 64 ];
epicsSocketConvertErrnoToString ( buf, sizeof ( buf ) );
errlogPrintf (
"epicsSocketCreate: failed to "
"fcntl FD_CLOEXEC because \"%s\"\n",
buf );
close ( sock );
sock = INVALID_SOCKET;
}
}
return sock;
}
/*
* register_new_client()
*/
static void register_new_client ( osiSockAddr & from,
tsFreeList < repeaterClient, 0x20 > & freeList )
{
bool newClient = false;
int status;
if ( from.sa.sa_family != AF_INET ) {
return;
}
/*
* the repeater and its clients must be on the same host
*/
if ( INADDR_LOOPBACK != ntohl ( from.ia.sin_addr.s_addr ) ) {
static SOCKET testSock = INVALID_SOCKET;
static bool init = false;
if ( ! init ) {
SOCKET sock;
if ( ! makeSocket ( PORT_ANY, true, & sock ) ) {
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
fprintf ( stderr, "%s: Unable to create repeater bind test socket because \"%s\"\n",
__FILE__, sockErrBuf );
}
else {
testSock = sock;
}
init = true;
}
/*
* Unfortunately on 3.13 beta 11 and before the
* repeater would not always allow the loopback address
* as a local client address so current clients alternate
* between the address of the first non-loopback interface
* found and the loopback addresss when subscribing with
* the CA repeater until all CA repeaters have been updated
* to current code.
*/
if ( testSock != INVALID_SOCKET ) {
osiSockAddr addr;
addr = from;
addr.ia.sin_port = PORT_ANY;
/* we can only bind to a local address */
status = bind ( testSock, &addr.sa, sizeof ( addr ) );
if ( status ) {
return;
}
}
else {
return;
}
}
tsDLIter < repeaterClient > pclient = client_list.firstIter ();
while ( pclient.valid () ) {
if ( pclient->identicalPort ( from ) ) {
break;
}
pclient++;
}
repeaterClient *pNewClient;
if ( pclient.valid () ) {
pNewClient = pclient.pointer ();
}
else {
pNewClient = new ( freeList ) repeaterClient ( from );
if ( ! pNewClient ) {
fprintf ( stderr, "%s: no memory for new client\n", __FILE__ );
return;
}
if ( ! pNewClient->connect () ) {
pNewClient->~repeaterClient ();
freeList.release ( pNewClient );
return;
}
client_list.add ( *pNewClient );
newClient = true;
}
if ( ! pNewClient->sendConfirm () ) {
client_list.remove ( *pNewClient );
pNewClient->~repeaterClient ();
freeList.release ( pNewClient );
# ifdef DEBUG
epicsUInt16 port = ntohs ( from.ia.sin_port );
debugPrintf ( ( "Deleted repeater client=%u (error while sending ack)\n",
port ) );
# endif
}
/*
* send a noop message to all other clients so that we dont
* accumulate sockets when there are no beacons
*/
caHdr noop;
memset ( (char *) &noop, '\0', sizeof ( noop ) );
AlignedWireRef < epicsUInt16 > ( noop.m_cmmd ) = CA_PROTO_VERSION;
fanOut ( from, &noop, sizeof ( noop ), freeList );
if ( newClient ) {
/*
* For HPUX and Solaris we need to verify that the clients
* have not gone away - because an ICMP error return does not
* get through to send(), which returns no error code.
*
* This is done each time that a new client is created.
* See also the note in the file header.
*
* This is done here in order to avoid deleting a client
* prior to sending its confirm message.
*/
verifyClients ( freeList );
}
}
/*
* ca_repeater ()
*/
void ca_repeater ()
{
tsFreeList < repeaterClient, 0x20 > freeList;
int size;
SOCKET sock;
osiSockAddr from;
unsigned short port;
char * pBuf;
pBuf = new char [MAX_UDP_RECV];
{
bool success = osiSockAttach();
assert ( success );
}
port = envGetInetPortConfigParam ( & EPICS_CA_REPEATER_PORT,
static_cast <unsigned short> (CA_REPEATER_PORT) );
if ( ! makeSocket ( port, true, & sock ) ) {
/*
* test for server was already started
*/
if ( SOCKERRNO == SOCK_EADDRINUSE ) {
osiSockRelease ();
debugPrintf ( ( "CA Repeater: exiting because a repeater is already running\n" ) );
return;
}
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
fprintf ( stderr, "%s: Unable to create repeater socket because \"%s\" - fatal\n",
__FILE__, sockErrBuf );
osiSockRelease ();
delete [] pBuf;
return;
}
debugPrintf ( ( "CA Repeater: Attached and initialized\n" ) );
while ( true ) {
osiSocklen_t from_size = sizeof ( from );
size = recvfrom ( sock, pBuf, MAX_UDP_RECV, 0,
&from.sa, &from_size );
if ( size < 0 ) {
int errnoCpy = SOCKERRNO;
// Avoid spurious ECONNREFUSED bug in linux
if ( errnoCpy == SOCK_ECONNREFUSED ) {
continue;
}
// Avoid ECONNRESET from connected socket in windows
if ( errnoCpy == SOCK_ECONNRESET ) {
continue;
}
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
fprintf ( stderr, "CA Repeater: unexpected UDP recv err: %s\n",
sockErrBuf );
continue;
}
caHdr * pMsg = ( caHdr * ) pBuf;
/*
* both zero length message and a registration message
* will register a new client
*/
if ( ( (size_t) size) >= sizeof (*pMsg) ) {
if ( AlignedWireRef < epicsUInt16 > ( pMsg->m_cmmd ) == REPEATER_REGISTER ) {
register_new_client ( from, freeList );
/*
* strip register client message
*/
pMsg++;
size -= sizeof ( *pMsg );
if ( size==0 ) {
continue;
}
}
else if ( AlignedWireRef < epicsUInt16 > ( pMsg->m_cmmd ) == CA_PROTO_RSRV_IS_UP ) {
if ( pMsg->m_available == 0u ) {
pMsg->m_available = from.ia.sin_addr.s_addr;
}
}
}
else if ( size == 0 ) {
register_new_client ( from, freeList );
continue;
}
fanOut ( from, pMsg, size, freeList );
}
}
/*
* cas_send_dg_msg()
*
* (channel access server send udp message)
*/
void cas_send_dg_msg ( struct client * pclient )
{
int status;
int sizeDG;
char * pDG;
caHdr * pMsg;
if ( CASDEBUG > 2 && pclient->send.stk ) {
errlogPrintf ( "CAS: Sending a udp message of %d bytes\n", pclient->send.stk );
}
SEND_LOCK ( pclient );
if ( pclient->send.stk <= sizeof (caHdr) ) {
SEND_UNLOCK(pclient);
return;
}
pDG = pclient->send.buf;
pMsg = ( caHdr * ) pDG;
sizeDG = pclient->send.stk;
assert ( ntohs ( pMsg->m_cmmd ) == CA_PROTO_VERSION );
if ( CA_V411 ( pclient->minor_version_number ) ) {
pMsg->m_cid = htonl ( pclient->seqNoOfReq );
pMsg->m_dataType = htons ( sequenceNoIsValid );
}
else {
pDG += sizeof (caHdr);
sizeDG -= sizeof (caHdr);
}
status = sendto ( pclient->sock, pDG, sizeDG, 0,
(struct sockaddr *)&pclient->addr, sizeof(pclient->addr) );
if ( status >= 0 ) {
if ( status >= sizeDG ) {
epicsTimeGetCurrent ( &pclient->time_at_last_send );
}
else {
errlogPrintf (
"CAS: System failed to send entire udp frame?\n" );
}
}
else {
char sockErrBuf[64];
char buf[128];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
ipAddrToDottedIP ( &pclient->addr, buf, sizeof(buf) );
errlogPrintf( "CAS: UDP send to %s failed - %s\n",
buf, sockErrBuf);
}
pclient->send.stk = 0u;
/*
* add placeholder for the first version message should it be needed
*/
rsrv_version_reply ( pclient );
SEND_UNLOCK(pclient);
DLOG ( 3, ( "------------------------------\n\n" ) );
return;
}
/*
*
* req_server()
*
* CA server task
*
* Waits for connections at the CA port and spawns a task to
* handle each of them
*
*/
static void req_server (void *pParm)
{
unsigned priorityOfSelf = epicsThreadGetPrioritySelf ();
unsigned priorityOfBeacons;
epicsThreadBooleanStatus tbs;
struct sockaddr_in serverAddr; /* server's address */
osiSocklen_t addrSize;
int status;
SOCKET clientSock;
epicsThreadId tid;
int portChange;
epicsSignalInstallSigPipeIgnore ();
taskwdInsert ( epicsThreadGetIdSelf (), NULL, NULL );
rsrvCurrentClient = epicsThreadPrivateCreate ();
if ( envGetConfigParamPtr ( &EPICS_CAS_SERVER_PORT ) ) {
ca_server_port = envGetInetPortConfigParam ( &EPICS_CAS_SERVER_PORT,
(unsigned short) CA_SERVER_PORT );
}
else {
ca_server_port = envGetInetPortConfigParam ( &EPICS_CA_SERVER_PORT,
(unsigned short) CA_SERVER_PORT );
}
if (IOC_sock != 0 && IOC_sock != INVALID_SOCKET) {
epicsSocketDestroy ( IOC_sock );
}
/*
* Open the socket. Use ARPA Internet address format and stream
* sockets. Format described in <sys/socket.h>.
*/
if ( ( IOC_sock = epicsSocketCreate (AF_INET, SOCK_STREAM, 0) ) == INVALID_SOCKET ) {
errlogPrintf ("CAS: Socket creation error\n");
epicsThreadSuspendSelf ();
}
epicsSocketEnableAddressReuseDuringTimeWaitState ( IOC_sock );
/* Zero the sock_addr structure */
memset ( (void *) &serverAddr, 0, sizeof ( serverAddr ) );
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = htonl (INADDR_ANY);
serverAddr.sin_port = htons ( ca_server_port );
/* get server's Internet address */
status = bind ( IOC_sock, (struct sockaddr *) &serverAddr, sizeof ( serverAddr ) );
if ( status < 0 ) {
if ( SOCKERRNO == SOCK_EADDRINUSE ) {
/*
* enable assignment of a default port
* (so the getsockname() call below will
* work correctly)
*/
serverAddr.sin_port = ntohs (0);
status = bind ( IOC_sock,
(struct sockaddr *) &serverAddr, sizeof ( serverAddr ) );
}
if ( status < 0 ) {
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
errlogPrintf ( "CAS: Socket bind error was \"%s\"\n",
sockErrBuf );
epicsThreadSuspendSelf ();
}
portChange = 1;
}
else {
portChange = 0;
}
addrSize = ( osiSocklen_t ) sizeof ( serverAddr );
status = getsockname ( IOC_sock,
(struct sockaddr *)&serverAddr, &addrSize);
if ( status ) {
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
errlogPrintf ( "CAS: getsockname() error %s\n",
sockErrBuf );
epicsThreadSuspendSelf ();
}
ca_server_port = ntohs (serverAddr.sin_port);
if ( portChange ) {
errlogPrintf ( "cas warning: Configured TCP port was unavailable.\n");
errlogPrintf ( "cas warning: Using dynamically assigned TCP port %hu,\n",
ca_server_port );
errlogPrintf ( "cas warning: but now two or more servers share the same UDP port.\n");
errlogPrintf ( "cas warning: Depending on your IP kernel this server may not be\n" );
errlogPrintf ( "cas warning: reachable with UDP unicast (a host's IP in EPICS_CA_ADDR_LIST)\n" );
}
/* listen and accept new connections */
if ( listen ( IOC_sock, 20 ) < 0 ) {
errlogPrintf ("CAS: Listen error\n");
epicsSocketDestroy (IOC_sock);
epicsThreadSuspendSelf ();
}
tbs = epicsThreadHighestPriorityLevelBelow ( priorityOfSelf, &priorityOfBeacons );
if ( tbs != epicsThreadBooleanStatusSuccess ) {
priorityOfBeacons = priorityOfSelf;
}
beacon_startStopEvent = epicsEventMustCreate(epicsEventEmpty);
beacon_ctl = ctlPause;
tid = epicsThreadCreate ( "CAS-beacon", priorityOfBeacons,
epicsThreadGetStackSize (epicsThreadStackSmall),
rsrv_online_notify_task, 0 );
if ( tid == 0 ) {
epicsPrintf ( "CAS: unable to start beacon thread\n" );
}
epicsEventMustWait(beacon_startStopEvent);
epicsEventSignal(castcp_startStopEvent);
while (TRUE) {
struct sockaddr sockAddr;
osiSocklen_t addLen = sizeof(sockAddr);
while (castcp_ctl == ctlPause) {
epicsThreadSleep(0.1);
}
clientSock = epicsSocketAccept ( IOC_sock, &sockAddr, &addLen );
if ( clientSock == INVALID_SOCKET ) {
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
errlogPrintf("CAS: Client accept error was \"%s\"\n",
sockErrBuf );
epicsThreadSleep(15.0);
continue;
}
else {
epicsThreadId id;
struct client *pClient;
/* socket passed in is closed if unsuccessful here */
pClient = create_tcp_client ( clientSock );
if ( ! pClient ) {
epicsThreadSleep ( 15.0 );
continue;
}
LOCK_CLIENTQ;
ellAdd ( &clientQ, &pClient->node );
UNLOCK_CLIENTQ;
id = epicsThreadCreate ( "CAS-client", epicsThreadPriorityCAServerLow,
epicsThreadGetStackSize ( epicsThreadStackBig ),
camsgtask, pClient );
if ( id == 0 ) {
LOCK_CLIENTQ;
ellDelete ( &clientQ, &pClient->node );
UNLOCK_CLIENTQ;
destroy_tcp_client ( pClient );
errlogPrintf ( "CAS: task creation for new client failed\n" );
epicsThreadSleep ( 15.0 );
continue;
}
}
}
}
/*
* cas_send_bs_msg()
*
* (channel access server send message)
*/
void cas_send_bs_msg ( struct client *pclient, int lock_needed )
{
int status;
if ( CASDEBUG > 2 && pclient->send.stk ) {
errlogPrintf ( "CAS: Sending a message of %d bytes\n", pclient->send.stk );
}
if ( pclient->disconnect ) {
if ( CASDEBUG > 2 ) {
errlogPrintf ( "CAS: msg Discard for sock %d addr %x\n",
pclient->sock, (unsigned) pclient->addr.sin_addr.s_addr );
}
pclient->send.stk = 0u;
return;
}
if ( lock_needed ) {
SEND_LOCK ( pclient );
}
while ( pclient->send.stk && ! pclient->disconnect ) {
status = send ( pclient->sock, pclient->send.buf, pclient->send.stk, 0 );
if ( status >= 0 ) {
unsigned transferSize = (unsigned) status;
if ( transferSize >= pclient->send.stk ) {
pclient->send.stk = 0;
epicsTimeGetCurrent ( &pclient->time_at_last_send );
break;
}
else {
unsigned bytesLeft = pclient->send.stk - transferSize;
memmove ( pclient->send.buf, &pclient->send.buf[transferSize],
bytesLeft );
pclient->send.stk = bytesLeft;
}
}
else {
int causeWasSocketHangup = 0;
int anerrno = SOCKERRNO;
char buf[64];
if ( pclient->disconnect ) {
pclient->send.stk = 0u;
break;
}
if ( anerrno == SOCK_EINTR ) {
continue;
}
if ( anerrno == SOCK_ENOBUFS ) {
errlogPrintf (
"CAS: Out of network buffers, retrying send in 15 seconds\n" );
epicsThreadSleep ( 15.0 );
continue;
}
ipAddrToDottedIP ( &pclient->addr, buf, sizeof(buf) );
if (
anerrno == SOCK_ECONNABORTED ||
anerrno == SOCK_ECONNRESET ||
anerrno == SOCK_EPIPE ||
anerrno == SOCK_ETIMEDOUT ) {
causeWasSocketHangup = 1;
}
else {
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
errlogPrintf ( "CAS: TCP send to %s failed - %s\n",
buf, sockErrBuf);
}
pclient->disconnect = TRUE;
pclient->send.stk = 0u;
/*
* wakeup the receive thread
*/
if ( ! causeWasSocketHangup ) {
enum epicsSocketSystemCallInterruptMechanismQueryInfo info =
epicsSocketSystemCallInterruptMechanismQuery ();
switch ( info ) {
case esscimqi_socketCloseRequired:
if ( pclient->sock != INVALID_SOCKET ) {
epicsSocketDestroy ( pclient->sock );
pclient->sock = INVALID_SOCKET;
}
break;
case esscimqi_socketBothShutdownRequired:
{
int status = shutdown ( pclient->sock, SHUT_RDWR );
if ( status ) {
char sockErrBuf[64];
epicsSocketConvertErrnoToString (
sockErrBuf, sizeof ( sockErrBuf ) );
errlogPrintf ("CAS: Socket shutdown error - %s\n",
sockErrBuf );
}
}
break;
case esscimqi_socketSigAlarmRequired:
epicsSignalRaiseSigAlarm ( pclient->tid );
break;
default:
break;
};
break;
}
}
}
if ( lock_needed ) {
SEND_UNLOCK(pclient);
}
DLOG ( 3, ( "------------------------------\n\n" ) );
return;
}
/*
* acceptNewClient()
*
*/
static void acceptNewClient ( void *pParam )
{
struct ioc_log_server *pserver = (struct ioc_log_server *) pParam;
struct iocLogClient *pclient;
osiSocklen_t addrSize;
struct sockaddr_in addr;
int status;
osiSockIoctl_t optval;
pclient = ( struct iocLogClient * ) malloc ( sizeof ( *pclient ) );
if ( ! pclient ) {
return;
}
addrSize = sizeof ( addr );
pclient->insock = epicsSocketAccept ( pserver->sock, (struct sockaddr *)&addr, &addrSize );
if ( pclient->insock==INVALID_SOCKET || addrSize < sizeof (addr) ) {
static unsigned acceptErrCount;
static int lastErrno;
int thisErrno;
free ( pclient );
if ( SOCKERRNO == SOCK_EWOULDBLOCK || SOCKERRNO == SOCK_EINTR ) {
return;
}
thisErrno = SOCKERRNO;
if ( acceptErrCount % 1000 || lastErrno != thisErrno ) {
fprintf ( stderr, "Accept Error %d\n", SOCKERRNO );
}
acceptErrCount++;
lastErrno = thisErrno;
return;
}
/*
* Set non blocking IO
* to prevent dead locks
*/
optval = TRUE;
status = socket_ioctl(
pclient->insock,
FIONBIO,
&optval);
if(status<0){
char sockErrBuf[64];
epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
fprintf(stderr, "%s:%d ioctl FBIO client er %s\n",
__FILE__, __LINE__, sockErrBuf);
epicsSocketDestroy ( pclient->insock );
free(pclient);
return;
}
pclient->pserver = pserver;
pclient->nChar = 0u;
ipAddrToA (&addr, pclient->name, sizeof(pclient->name));
logTime(pclient);
#if 0
status = fprintf(
pclient->pserver->poutfile,
"%s %s ----- Client Connect -----\n",
pclient->name,
pclient->ascii_time);
if(status<0){
handleLogFileError();
}
#endif
/*
* turn on KEEPALIVE so if the client crashes
* this task will find out and exit
*/
{
long true = 1;
status = setsockopt(
pclient->insock,
SOL_SOCKET,
SO_KEEPALIVE,
(char *)&true,
sizeof(true) );
if(status<0){
fprintf(stderr, "Keepalive option set failed\n");
}
}
status = shutdown(pclient->insock, SHUT_WR);
if(status<0){
char sockErrBuf[64];
epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
fprintf (stderr, "%s:%d shutdown err %s\n", __FILE__, __LINE__,
sockErrBuf);
epicsSocketDestroy ( pclient->insock );
free(pclient);
return;
}
status = fdmgr_add_callback(
pserver->pfdctx,
pclient->insock,
fdi_read,
readFromClient,
pclient);
if (status<0) {
epicsSocketDestroy ( pclient->insock );
free(pclient);
fprintf(stderr, "%s:%d client fdmgr_add_callback() failed\n",
__FILE__, __LINE__);
return;
}
}
void BlockingTCPAcceptor::run() {
// rise level if port is assigned dynamically
char ipAddrStr[48];
ipAddrToDottedIP(&_bindAddress.ia, ipAddrStr, sizeof(ipAddrStr));
LOG(logLevelDebug, "Accepting connections at %s.", ipAddrStr);
bool socketOpen = true;
char strBuffer[64];
while(socketOpen) {
{
Lock guard(_mutex);
if (_destroyed)
break;
}
osiSockAddr address;
osiSocklen_t len = sizeof(sockaddr);
SOCKET newClient = epicsSocketAccept(_serverSocketChannel, &address.sa, &len);
if(newClient!=INVALID_SOCKET) {
// accept succeeded
ipAddrToDottedIP(&address.ia, ipAddrStr, sizeof(ipAddrStr));
LOG(logLevelDebug, "Accepted connection from PVA client: %s.", ipAddrStr);
// enable TCP_NODELAY (disable Nagle's algorithm)
int optval = 1; // true
int retval = ::setsockopt(newClient, IPPROTO_TCP, TCP_NODELAY, (char *)&optval, sizeof(int));
if(retval<0) {
epicsSocketConvertErrnoToString(strBuffer, sizeof(strBuffer));
LOG(logLevelDebug, "Error setting TCP_NODELAY: %s.", strBuffer);
}
// enable TCP_KEEPALIVE
retval = ::setsockopt(newClient, SOL_SOCKET, SO_KEEPALIVE, (char *)&optval, sizeof(int));
if(retval<0) {
epicsSocketConvertErrnoToString(strBuffer, sizeof(strBuffer));
LOG(logLevelDebug, "Error setting SO_KEEPALIVE: %s.", strBuffer);
}
// do NOT tune socket buffer sizes, this will disable auto-tunning
// get TCP send buffer size
osiSocklen_t intLen = sizeof(int);
int _socketSendBufferSize;
retval = getsockopt(newClient, SOL_SOCKET, SO_SNDBUF, (char *)&_socketSendBufferSize, &intLen);
if(retval<0) {
epicsSocketConvertErrnoToString(strBuffer, sizeof(strBuffer));
LOG(logLevelDebug, "Error getting SO_SNDBUF: %s.", strBuffer);
}
/**
* Create transport, it registers itself to the registry.
*/
detail::BlockingServerTCPTransportCodec::shared_pointer transport =
detail::BlockingServerTCPTransportCodec::create(
_context,
newClient,
_responseHandler,
_socketSendBufferSize,
_receiveBufferSize);
// validate connection
if(!validateConnection(transport, ipAddrStr)) {
// TODO
// wait for negative response to be sent back and
// hold off the client for retrying at very high rate
epicsThreadSleep(1.0);
transport->close();
LOG(
logLevelDebug,
"Connection to PVA client %s failed to be validated, closing it.",
ipAddrStr);
continue;
}
LOG(logLevelDebug, "Serving to PVA client: %s.", ipAddrStr);
}// accept succeeded
else
socketOpen = false;
} // while
}
/*
*
* main()
*
*/
int main(void)
{
struct sockaddr_in serverAddr; /* server's address */
struct timeval timeout;
int status;
struct ioc_log_server *pserver;
osiSockIoctl_t optval;
status = getConfig();
if (status<0) {
fprintf(stderr, "iocLogServer: EPICS environment underspecified\n");
fprintf(stderr, "iocLogServer: failed to initialize\n");
return IOCLS_ERROR;
}
pserver = (struct ioc_log_server *)
calloc(1, sizeof *pserver);
if (!pserver) {
fprintf(stderr, "iocLogServer: %s\n", strerror(errno));
return IOCLS_ERROR;
}
pserver->pfdctx = (void *) fdmgr_init();
if (!pserver->pfdctx) {
fprintf(stderr, "iocLogServer: %s\n", strerror(errno));
return IOCLS_ERROR;
}
/*
* Open the socket. Use ARPA Internet address format and stream
* sockets. Format described in <sys/socket.h>.
*/
pserver->sock = epicsSocketCreate(AF_INET, SOCK_STREAM, 0);
if (pserver->sock == INVALID_SOCKET) {
char sockErrBuf[64];
epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
fprintf(stderr, "iocLogServer: sock create err: %s\n", sockErrBuf);
free(pserver);
return IOCLS_ERROR;
}
epicsSocketEnableAddressReuseDuringTimeWaitState ( pserver->sock );
/* Zero the sock_addr structure */
memset((void *)&serverAddr, 0, sizeof serverAddr);
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(ioc_log_port);
/* get server's Internet address */
status = bind ( pserver->sock,
(struct sockaddr *)&serverAddr,
sizeof (serverAddr) );
if (status < 0) {
char sockErrBuf[64];
epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
fprintf(stderr, "iocLogServer: bind err: %s\n", sockErrBuf );
fprintf (stderr,
"iocLogServer: a server is already installed on port %u?\n",
(unsigned)ioc_log_port);
return IOCLS_ERROR;
}
/* listen and accept new connections */
status = listen(pserver->sock, 10);
if (status < 0) {
char sockErrBuf[64];
epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
fprintf(stderr, "iocLogServer: listen err %s\n", sockErrBuf);
return IOCLS_ERROR;
}
/*
* Set non blocking IO
* to prevent dead locks
*/
optval = TRUE;
status = socket_ioctl(
pserver->sock,
FIONBIO,
&optval);
if (status < 0){
char sockErrBuf[64];
epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
fprintf(stderr, "iocLogServer: ioctl FIONBIO err %s\n", sockErrBuf);
return IOCLS_ERROR;
}
# ifdef UNIX
status = setupSIGHUP(pserver);
if (status < 0) {
return IOCLS_ERROR;
}
# endif
status = openLogFile(pserver);
if (status < 0) {
fprintf(stderr,
"File access problems to `%s' because `%s'\n",
ioc_log_file_name,
strerror(errno));
return IOCLS_ERROR;
}
status = fdmgr_add_callback(
pserver->pfdctx,
pserver->sock,
fdi_read,
acceptNewClient,
pserver);
if (status < 0) {
fprintf(stderr,
"iocLogServer: failed to add read callback\n");
return IOCLS_ERROR;
}
while (TRUE) {
timeout.tv_sec = 60; /* 1 min */
timeout.tv_usec = 0;
fdmgr_pend_event(pserver->pfdctx, &timeout);
fflush(pserver->poutfile);
}
}
int BlockingTCPAcceptor::initialize() {
char ipAddrStr[48];
ipAddrToDottedIP(&_bindAddress.ia, ipAddrStr, sizeof(ipAddrStr));
int tryCount = 0;
while(tryCount<2) {
char strBuffer[64];
LOG(logLevelDebug, "Creating acceptor to %s.", ipAddrStr);
_serverSocketChannel = epicsSocketCreate(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(_serverSocketChannel==INVALID_SOCKET) {
epicsSocketConvertErrnoToString(strBuffer, sizeof(strBuffer));
ostringstream temp;
temp<<"Socket create error: "<<strBuffer;
LOG(logLevelError, "%s", temp.str().c_str());
THROW_BASE_EXCEPTION(temp.str().c_str());
}
else {
//epicsSocketEnableAddressReuseDuringTimeWaitState(_serverSocketChannel);
// try to bind
int retval = ::bind(_serverSocketChannel, &_bindAddress.sa, sizeof(sockaddr));
if(retval<0) {
epicsSocketConvertErrnoToString(strBuffer, sizeof(strBuffer));
LOG(logLevelDebug, "Socket bind error: %s.", strBuffer);
if(_bindAddress.ia.sin_port!=0) {
// failed to bind to specified bind address,
// try to get port dynamically, but only once
LOG(
logLevelDebug,
"Configured TCP port %d is unavailable, trying to assign it dynamically.",
ntohs(_bindAddress.ia.sin_port));
_bindAddress.ia.sin_port = htons(0);
}
else {
epicsSocketDestroy(_serverSocketChannel);
break; // exit while loop
}
}
else { // if(retval<0)
// bind succeeded
// update bind address, if dynamically port selection was used
if(ntohs(_bindAddress.ia.sin_port)==0) {
osiSocklen_t sockLen = sizeof(sockaddr);
// read the actual socket info
retval = ::getsockname(_serverSocketChannel, &_bindAddress.sa, &sockLen);
if(retval<0) {
// error obtaining port number
epicsSocketConvertErrnoToString(strBuffer, sizeof(strBuffer));
LOG(logLevelDebug, "getsockname error: %s", strBuffer);
}
else {
LOG(
logLevelInfo,
"Using dynamically assigned TCP port %d.",
ntohs(_bindAddress.ia.sin_port));
}
}
retval = ::listen(_serverSocketChannel, 4);
if(retval<0) {
epicsSocketConvertErrnoToString(strBuffer, sizeof(strBuffer));
ostringstream temp;
temp<<"Socket listen error: "<<strBuffer;
LOG(logLevelError, "%s", temp.str().c_str());
THROW_BASE_EXCEPTION(temp.str().c_str());
}
_thread.start();
// all OK, return
return ntohs(_bindAddress.ia.sin_port);
} // successful bind
} // successfully obtained socket
tryCount++;
} // while
ostringstream temp;
temp<<"Failed to create acceptor to "<<ipAddrStr;
THROW_BASE_EXCEPTION(temp.str().c_str());
}
