void UdpService::postinitService() {
createDatagramSocket();
// define hardcoded remote address:
remote_sockaddr_ipv4_ = sockaddr_ipv4_;
remote_sockaddr_ipv4_.sin_addr.s_addr = inet_addr(boardIP_.to_string());
if (timeout_.to_int64()) {
struct timeval tv;
#if defined(_WIN32) || defined(__CYGWIN__)
tv.tv_usec = 0;
tv.tv_sec = static_cast<long>(timeout_.to_int64());
#else
tv.tv_usec = (timeout_.to_int64() % 1000) * 1000;
tv.tv_sec = static_cast<long>(timeout_.to_int64()/1000);
#endif
setsockopt(hsock_, SOL_SOCKET, SO_RCVTIMEO,
(char *)&tv, sizeof(struct timeval));
}
/** By default socket was created with Blocking mode */
if (!blockmode_.to_bool()) {
setBlockingMode(hsock_, false);
}
}
COMPort::COMPort () : dcb (NULL) {
dcb = new char [sizeof(DCB)];
getState(); // Riempie il DCB con le impostazioni attuali della porta
setBlockingMode();
setHandshaking();
open = false;
}
Socket::Socket(int _handle, const std::string& _hostLocal, unsigned _portLocal,
struct sockaddr_storage* remoteAddr, IPVersion _ipVersion)
:ipVersion(_ipVersion), type(TCP_SERVERS_CLIENT), status(READY),
handle(_handle), hostLocal(_hostLocal), portLocal(_portLocal) {
readSockaddr(remoteAddr, hostRemote, portRemote);
setBlockingMode(false);
#if NETLINK_DEFAULT_INPUT_BUFFER_SIZE > 0
setInputBufferSize(NETLINK_DEFAULT_INPUT_BUFFER_SIZE);
#endif
#if NETLINK_DEFAULT_OUTPUT_BUFFER_SIZE > 0
setOutputBufferSize(NETLINK_DEFAULT_OUTPUT_BUFFER_SIZE);
#endif
}
int main( int argc, const char **argv )
{
rtError rc;
rtRemoteEnvironment *env= 0;
const char* srcName= 0;
const char* fileName= 0;
const char* endpointName= 0;
bool toFile= false;
bool toEndpoint= false;
int duration= -1;
int len;
printf("mediacapture-test v1.0\n");
if ( argc > 4 )
{
showUsage();
}
else
{
if ( argc > 1 )
{
len= strlen(argv[1]);
if ( (len == 4) && !strncmp( argv[1], "file", len) )
{
toFile= true;
}
else if ( (len == 8) && !strncmp( argv[1], "endpoint", len) )
{
toEndpoint= true;
}
}
if ( argc > 2 )
{
if ( toFile )
{
fileName= argv[2];
}
else
if ( toEndpoint )
{
endpointName= argv[2];
}
}
if ( argc > 3 )
{
duration= atoi(argv[3]);
}
if ( !toFile && !toEndpoint )
{
showUsage();
exit(0);
}
if ( duration < 0 )
{
duration= 30000;
}
printf("will capture to %s (%s)\n", (toFile?"file":"endpoint"), (toFile?fileName:endpointName));
env= rtEnvironmentGetGlobal();
rc= rtRemoteInit(env);
if ( rc == RT_OK )
{
rtObjectRef registry;
struct sigaction sigint;
rc= rtRemoteLocateObject(env, "mediacaptureregistry", registry);
if ( rc == RT_OK )
{
sigint.sa_handler= signalHandler;
sigemptyset(&sigint.sa_mask);
sigint.sa_flags= SA_RESETHAND;
sigaction(SIGINT, &sigint, NULL);
setBlockingMode(NON_BLOCKING_ENABLED);
listActions();
gRunning= true;
while( gRunning )
{
rtRemoteProcessSingleItem( env );
if ( isKeyHit() )
{
int src= -1;
int c= fgetc(stdin);
switch( c )
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
src= c-'0';
getAvailablePipelines(env, registry);
if ( toFile )
{
captureSourceToFile( src, fileName, duration, env );
}
else
{
startCaptureSourceToEndpoint( src, endpointName, duration, env );
}
break;
case 's':
if ( !toFile )
{
if ( gSrcActive != -1 )
{
stopCaptureSourceToEndpoint( gSrcActive, env );
}
}
break;
case 'l':
displayPipelineList(env, registry);
break;
case 'i':
displayMediaConsumptionInfo(env, registry);
break;
case 'c':
clearMediaConsumptionInfo(env, registry);
break;
case 'q':
gRunning= false;
break;
default:
listActions();
break;
}
}
usleep( 10000 );
}
setBlockingMode(NON_BLOCKING_DISABLED);
}
else
{
printf("error: unable to locate registry: %d", rc);
}
}
else
{
printf("error: rtRemoteInit rc %d\n", rc);
}
}
return 0;
}
void MprSocket::close(int timeout)
{
MprSelectService *ss;
Mpr *mpr;
char buf[1024];
int handlerFlags, timesUp;
mpr = mprGetMpr();
mprLog(7, log, "%d: close\n", sock);
ss = mpr->selectService;
lock();
mprAssert(!(flags & MPR_SOCKET_CLOSED));
if (flags & MPR_SOCKET_CLOSED) {
unlock();
return;
}
flags |= MPR_SOCKET_CLOSED;
handlerFlags = (handler) ? handler->getFlags() : 0;
if (handler) {
handler->dispose();
handler = 0;
}
if (sock >= 0) {
//
// Do a graceful shutdown. Read any outstanding read data to prevent
// resets. Then do a shutdown to send a FIN and read outstanding
// data. All non-blocking.
//
//TODO - what about WINCE?
#if WIN
if (ss->getFlags() & MPR_ASYNC_SELECT) {
if (handlerFlags & MPR_SELECT_CLIENT_CLOSED) {
//
// Client initiated close. We have already received an FD_CLOSE
//
closesocket(sock);
sock = -1;
} else {
if (shutdown(sock, SHUT_WR) == 0) {
//
// Do a graceful shutdown. Read any outstanding read data to
// prevent resets. Then do a shutdown to send a FIN and lastly
// read data when the FD_CLOSE is received (see select.cpp).
// All done non-blocking.
//
timesUp = mprGetTime(0) + timeout;
do {
if (recv(sock, buf, sizeof(buf), 0) <= 0) {
break;
}
} while (mprGetTime(0) < timesUp);
}
//
// Delayed close call must be first so we are ready when the
// FD_CLOSE arrives. Other way round and there is a race if
// multi-threaded.
//
ss->delayedClose(sock);
//
// We need to ensure we receive an FD_CLOSE to complete the
// delayed close. Despite disposing the hander above, socket
// messages will still be sent from windows and so select can
// cleanup the delayed close socket.
//
WSAAsyncSelect(sock, ss->getHwnd(), ss->getMessage(), FD_CLOSE);
}
} else {
#endif
if (shutdown(sock, SHUT_WR) < 0) {
ss->delayedClose(sock);
} else {
setBlockingMode(0);
timesUp = mprGetTime(0) + timeout;
do {
if (recv(sock, buf, sizeof(buf), 0) <= 0) {
break;
}
} while (mprGetTime(0) < timesUp);
}
//
// Use delayed close to prevent anyone else reusing the socket
// while select has not fully cleaned it out of its masks.
//
ss->delayedClose(sock);
ss->awaken(0);
}
#if WIN
}
#endif
//
// Re-initialize all socket variables so the Socket can be reused.
//
acceptCallback = 0;
acceptData = 0;
selectEvents = 0;
currentEvents = 0;
error = 0;
flags = MPR_SOCKET_CLOSED;
ioCallback = 0;
ioData = 0;
ioData2 = 0;
handlerMask = 0;
handlerPriority = MPR_NORMAL_PRIORITY;
interestEvents = 0;
port = -1;
sock = -1;
if (ipAddr) {
mprFree(ipAddr);
ipAddr = 0;
}
unlock();
}
int MprSocket::openClient(char *addr, int portNum, int initialFlags)
{
#if BLD_FEATURE_IPV6
struct addrinfo hints, *res;
struct sockaddr_storage remoteAddr6;
char portNum_string[MPR_MAX_IP_PORT];
char addrBuf[MPR_MAX_IP_ADDR];
#endif
struct sockaddr_in remoteAddr;
struct hostent *hostent;
struct sockaddr *sa;
MprSocklen addrlen;
int broadcast, datagram, rc, err;
mprLog(6, log, "openClient: %s:%d, flags %x\n", addr, portNum,
initialFlags);
#if BLD_FEATURE_IPV6
if (addr[0] == '[') {
ipv6 = 1;
mprStrcpy(addrBuf, sizeof(addr), &addr[1]);
mprAssert(addrBuf[strlen(addrBuf) - 2] == ']');
addrBuf[strlen(addrBuf) - 2] = '\0';
addr = addrBuf;
} else {
ipv6 = 0;
}
if (ipv6) {
memset((char*) &hints, '\0', sizeof(hints));
memset((char*) &remoteAddr6, '\0', sizeof(struct sockaddr_storage));
mprSprintf(portNum_string, sizeof(portNum_string), "%d", portNum);
hints.ai_socktype = SOCK_STREAM;
rc = getaddrinfo(addr, portNum_string, &hints, &res);
if (rc) {
/* no need to unlock yet */
return MPR_ERR_CANT_OPEN;
}
sa = (struct sockaddr*) &remoteAddr6;
memcpy(sa, res->ai_addr, res->ai_addrlen);
addrlen = res->ai_addrlen;
freeaddrinfo(res);
} else
#endif
{
memset((char *) &remoteAddr, '\0', sizeof(struct sockaddr_in));
remoteAddr.sin_family = AF_INET;
remoteAddr.sin_port = htons((short) (portNum & 0xFFFF));
sa = (struct sockaddr*) &remoteAddr;
addrlen = sizeof(remoteAddr);
}
lock();
port = portNum;
flags = (initialFlags &
(MPR_SOCKET_BROADCAST | MPR_SOCKET_DATAGRAM | MPR_SOCKET_BLOCK |
MPR_SOCKET_LISTENER | MPR_SOCKET_NOREUSE | MPR_SOCKET_NODELAY));
// Save copy of the address
ipAddr = mprStrdup(addr);
#if BLD_FEATURE_IPV6
if (!ipv6) {
// Nothing here
} else
#endif
{
remoteAddr.sin_addr.s_addr = inet_addr(ipAddr);
if (remoteAddr.sin_addr.s_addr == INADDR_NONE) {
hostent = mprGetHostByName(ipAddr);
if (hostent != 0) {
memcpy((char*) &remoteAddr.sin_addr, (char*) hostent->h_addr_list[0],
(size_t) hostent->h_length);
mprFreeGetHostByName(hostent);
} else {
unlock();
return MPR_ERR_NOT_FOUND;
}
}
}
broadcast = flags & MPR_SOCKET_BROADCAST;
if (broadcast) {
flags |= MPR_SOCKET_DATAGRAM;
}
datagram = flags & MPR_SOCKET_DATAGRAM;
//
// Create the O/S socket
//
sock = socket(sa->sa_family, datagram ? SOCK_DGRAM: SOCK_STREAM, 0);
if (sock < 0) {
err = getError();
unlock();
return -err;
}
#if !WIN && !WINCE && !VXWORKS
fcntl(sock, F_SETFD, FD_CLOEXEC); // Children won't inherit this fd
#endif
if (broadcast) {
int flag = 1;
if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *) &flag, sizeof(flag)) < 0) {
err = getError();
::closesocket(sock);
sock = -1;
unlock();
return -err;
}
}
if (!datagram) {
flags |= MPR_SOCKET_CONNECTING;
rc = connect(sock, sa, addrlen);
if (rc < 0) {
err = getError();
::closesocket(sock);
sock = -1;
unlock();
#if UNUSED
//
// If the listen backlog is too high, ECONNREFUSED is returned
//
if (err == EADDRINUSE || err == ECONNREFUSED) {
return MPR_ERR_BUSY;
}
#endif
return -err;
}
}
setBlockingMode((bool) (flags & MPR_SOCKET_BLOCK));
//
// TCP/IP stacks have the No delay option (nagle algorithm) on by default.
//
if (flags & MPR_SOCKET_NODELAY) {
setNoDelay(1);
}
unlock();
return sock;
}
int MprSocket::openServer(char *addr, int portNum, MprSocketAcceptProc acceptFn,
void *data, int initialFlags)
{
#if BLD_FEATURE_IPV6
struct addrinfo hints, *res;
struct sockaddr_storage sockAddr6;
char portNumString[MPR_MAX_IP_PORT];
char addrBuf[MPR_MAX_IP_ADDR];
char *bindName;
#endif
struct sockaddr_in sockAddr;
struct sockaddr *sa;
struct hostent *hostent;
MprSocklen addrlen;
int datagram, rc;
mprAssert(addr);
if (addr == 0 || *addr == '\0') {
mprLog(6, log, "openServer: *:%d, flags %x\n", portNum, initialFlags);
} else {
mprLog(6, log, "openServer: %s:%d, flags %x\n", addr, portNum, initialFlags);
}
#if BLD_FEATURE_IPV6
if (addr[0] == '[') {
ipv6 = 1;
mprStrcpy(addrBuf, sizeof(addrBuf), &addr[1]);
mprAssert(addrBuf[strlen(addrBuf) - 1] == ']');
addrBuf[strlen(addrBuf) - 1] = '\0';
addr = addrBuf;
}
if (ipv6) {
memset((char *) &hints, '\0', sizeof(hints));
memset((char *) &sockAddr6, '\0', sizeof(struct sockaddr_storage));
mprSprintf(portNumString, sizeof(portNumString), "%d", portNum);
hints.ai_socktype = SOCK_STREAM;
hints.ai_family = AF_INET6;
if (strcmp(addr, "") != 0) {
bindName = addr;
} else {
bindName = NULL;
hints.ai_flags |= AI_PASSIVE; /* Bind to 0.0.0.0 and :: */
/* Sets to IN6ADDR_ANY_INIT */
}
rc = getaddrinfo(bindName, portNumString, &hints, &res);
if (rc) {
return MPR_ERR_CANT_OPEN;
}
sa = (struct sockaddr*) &sockAddr6;
memcpy(sa, res->ai_addr, res->ai_addrlen);
addrlen = res->ai_addrlen;
freeaddrinfo(res);
} else
#endif
{
/*
* TODO could we use getaddrinfo in all cases. ie. merge with IPV6 code
*/
memset((char *) &sockAddr, '\0', sizeof(struct sockaddr_in));
addrlen = sizeof(struct sockaddr_in);
sockAddr.sin_family = AF_INET;
sockAddr.sin_port = htons((short) (portNum & 0xFFFF));
if (strcmp(addr, "") != 0) {
sockAddr.sin_addr.s_addr = inet_addr(addr);
if (sockAddr.sin_addr.s_addr == INADDR_NONE) {
hostent = mprGetHostByName(addr);
if (hostent != 0) {
memcpy((char*) &sockAddr.sin_addr, (char*) hostent->h_addr_list[0],
(size_t) hostent->h_length);
mprFreeGetHostByName(hostent);
} else {
return MPR_ERR_NOT_FOUND;
}
}
} else {
sockAddr.sin_addr.s_addr = INADDR_ANY;
}
sa = (struct sockaddr*) &sockAddr;
}
lock();
port = portNum;
acceptCallback = acceptFn;
acceptData = data;
flags = (initialFlags &
(MPR_SOCKET_BROADCAST | MPR_SOCKET_DATAGRAM | MPR_SOCKET_BLOCK |
MPR_SOCKET_LISTENER | MPR_SOCKET_NOREUSE | MPR_SOCKET_NODELAY));
ipAddr = mprStrdup(addr);
datagram = flags & MPR_SOCKET_DATAGRAM;
//
// Create the O/S socket
//
sock = socket(sa->sa_family, datagram ? SOCK_DGRAM: SOCK_STREAM, 0);
if (sock < 0) {
unlock();
return MPR_ERR_CANT_OPEN;
}
#if !WIN && !WINCE && !VXWORKS
fcntl(sock, F_SETFD, FD_CLOEXEC); // Children won't inherit this fd
#endif
#if CYGWIN || LINUX || MACOSX || VXWORKS || FREEBSD
if (!(flags & MPR_SOCKET_NOREUSE)) {
rc = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*) &rc, sizeof(rc));
}
#endif
rc = bind(sock, sa, addrlen);
// rc = bind(sock, res->ai_addr, res->ai_addrlen);
if (rc < 0) {
int err = errno;
err = err;
::closesocket(sock);
sock = -1;
unlock();
return MPR_ERR_CANT_OPEN;
}
if (! datagram) {
flags |= MPR_SOCKET_LISTENER;
if (listen(sock, SOMAXCONN) < 0) {
::closesocket(sock);
sock = -1;
unlock();
return MPR_ERR_CANT_OPEN;
}
handler = new MprSelectHandler(sock, MPR_SOCKET_READABLE,
(MprSelectProc) acceptProcWrapper, (void*) this, handlerPriority);
}
handlerMask |= MPR_SOCKET_READABLE;
//TODO - what about WINCE?
#if WIN
//
// Delay setting reuse until now so that we can be assured that we
// have exclusive use of the port.
//
if (!(flags & MPR_SOCKET_NOREUSE)) {
rc = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*) &rc, sizeof(rc));
}
#endif
setBlockingMode((bool) (flags & MPR_SOCKET_BLOCK));
//
// TCP/IP stacks have the No delay option (nagle algorithm) on by default.
//
if (flags & MPR_SOCKET_NODELAY) {
setNoDelay(1);
}
unlock();
return sock;
}
void Socket::initSocket(bool blockingConnect) {
AddrinfoContainer info;
if(type == TCP_CLIENT)
info = getSocketInfoFor(hostRemote.c_str(), portRemote, false);
else{
const char* host;
if(!hostLocal.compare("") || !hostLocal.compare("*"))
host = NULL;
else
host = hostLocal.c_str();
info = getSocketInfoFor(host, portLocal, true);
}
struct addrinfo* nextAddr = info.get();
while(nextAddr) {
handle = socket(nextAddr->ai_family, nextAddr->ai_socktype, nextAddr->ai_protocol);
if(handle == -1) {
nextAddr = nextAddr->ai_next;
continue;
}
setBlockingMode(blockingConnect);
#ifdef WIN32
char flag = 1;
#else
int flag = 1;
#endif
if(setsockopt(handle, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag)) == -1) {
disconnect();
throw Exception(Exception::ERROR_SET_SOCK_OPT);
}
switch(nextAddr->ai_family) {
case AF_INET:
ipVersion = IPv4;
break;
case AF_INET6:
ipVersion = IPv6;
break;
}
switch(type) {
case NONE:
case TCP_SERVERS_CLIENT:
disconnect();
throw Exception(Exception::BAD_TYPE);
case TCP_CLIENT:
if(connect(handle, nextAddr->ai_addr, nextAddr->ai_addrlen) == -1 && blockingConnect) {
closesocket(handle);
handle = -1;
}else if(blockingConnect)
status = READY;
else
status = CONNECTING;
break;
case TCP_SERVER: {
if(bind(handle, nextAddr->ai_addr, nextAddr->ai_addrlen) == -1) {
closesocket(handle);
handle = -1;
}
if(listen(handle, status) == -1) {
disconnect();
throw Exception(Exception::ERROR_INIT);
}
} break;
case UDP_PEER: {
if(bind(handle, nextAddr->ai_addr, nextAddr->ai_addrlen) == -1) {
closesocket(handle);
handle = -1;
}
status = READY;
} break;
}
if(handle == -1) {
nextAddr = nextAddr->ai_next;
continue;
}
if(blockingConnect)
setBlockingMode(false);
break;
}
if(handle == -1) {
disconnect();
throw Exception(Exception::ERROR_INIT);
}
struct sockaddr_storage localAddr;
#ifdef WIN32
int size = sizeof(localAddr);
#else
unsigned int size = sizeof(localAddr);
#endif
if(getsockname(handle, reinterpret_cast<struct sockaddr*>(&localAddr), &size) != 0) {
disconnect();
throw Exception(Exception::ERROR_GET_SOCK_NAME);
}
readSockaddr(&localAddr, hostLocal, portLocal);
}
void MSListener::doOpen(void)
{
if (fd()<0)
{
int lfd;
initRetryTimer();
if ((lfd=socket(domain(),type(),protocol()))<0)
{
MSMessageLog::warningMessage("MSListener::open(%s): error: socket()\n",name().string());
close();
return;
}
_openTod=todsec();
_openCount++;
MSChannel::fdsfresh(lfd);
_fd=lfd;
setBlockingMode(_fd);
int toggle=1;
if (setsockopt(fd(),SOL_SOCKET,SO_REUSEADDR,(char *)(&toggle),sizeof(toggle))<0)
{
MSMessageLog::warningMessage("MSListener::open(%s): warning: setsockopt(%d,REUSEADDR)\n",name().string(),fd());
}
if (establish()==MSFalse)
{
close();
return;
}
if (localName()==(struct sockaddr *)(0))
{
_localName=(struct sockaddr *)new char[localNamelen()];
memset((char *)(localName()),0,localNamelen());
}
else
{
if (bind(fd(),localName(),localNamelen())<0)
{
MSMessageLog::warningMessage("MSListener::open(%s): error: bind(%d)\n",name().string(),fd());
close();
return;
}
}
if (listen(fd(),5)<0)
{
MSMessageLog::warningMessage("MSListener::open(%s): error: listen(%d)\n",name().string(),fd());
close();
return;
}
#if defined(HAVE_SOCKLEN_T)
if (getsockname(fd(),localName(),(socklen_t *)&_localNamelen)<0)
#else
if (getsockname(fd(),localName(),&_localNamelen)<0)
#endif
{
MSMessageLog::warningMessage("MSListener::open(%s): error: getsockname(%d)\n",name().string(),fd());
close();
return;
}
if (publish()==MSFalse)
{
close();
return;
}
_listenTod=todsec();
_listenCount++;
createAcceptChannel();
_retryTime.reset();
}
}
