groupsock/GroupsockHelper.cpp File Reference

#include "GroupsockHelper.hh"
#include <stdarg.h>
#include <time.h>
#include <fcntl.h>
#include <stdio.h>

Include dependency graph for GroupsockHelper.cpp:

Go to the source code of this file.

Data Structures
struct	ip_mreq_source
Defines
#define	initializeWinsockIfNecessary()   1
#define	TTL_TYPE   u_int8_t
#define	IP_ADD_SOURCE_MEMBERSHIP   25
#define	IP_DROP_SOURCE_MEMBERSHIP   26
Functions
static void	socketErr (UsageEnvironment &env, char *errorMsg)
int	setupDatagramSocket (UsageEnvironment &env, Port port, Boolean)
Boolean	makeSocketNonBlocking (int sock)
int	setupStreamSocket (UsageEnvironment &env, Port port, Boolean makeNonBlocking)
static int	blockUntilReadable (UsageEnvironment &env, int socket, struct timeval *timeout)
int	readSocket (UsageEnvironment &env, int socket, unsigned char *buffer, unsigned bufferSize, struct sockaddr_in &fromAddress, struct timeval *timeout)
int	readSocketExact (UsageEnvironment &env, int socket, unsigned char *buffer, unsigned bufferSize, struct sockaddr_in &fromAddress, struct timeval *timeout)
Boolean	writeSocket (UsageEnvironment &env, int socket, struct in_addr address, Port port, u_int8_t ttlArg, unsigned char *buffer, unsigned bufferSize)
static unsigned	getBufferSize (UsageEnvironment &env, int bufOptName, int socket)
unsigned	getSendBufferSize (UsageEnvironment &env, int socket)
unsigned	getReceiveBufferSize (UsageEnvironment &env, int socket)
static unsigned	setBufferTo (UsageEnvironment &env, int bufOptName, int socket, unsigned requestedSize)
unsigned	setSendBufferTo (UsageEnvironment &env, int socket, unsigned requestedSize)
unsigned	setReceiveBufferTo (UsageEnvironment &env, int socket, unsigned requestedSize)
static unsigned	increaseBufferTo (UsageEnvironment &env, int bufOptName, int socket, unsigned requestedSize)
unsigned	increaseSendBufferTo (UsageEnvironment &env, int socket, unsigned requestedSize)
unsigned	increaseReceiveBufferTo (UsageEnvironment &env, int socket, unsigned requestedSize)
Boolean	socketJoinGroup (UsageEnvironment &env, int socket, netAddressBits groupAddress)
Boolean	socketLeaveGroup (UsageEnvironment &, int socket, netAddressBits groupAddress)
Boolean	socketJoinGroupSSM (UsageEnvironment &env, int socket, netAddressBits groupAddress, netAddressBits sourceFilterAddr)
Boolean	socketLeaveGroupSSM (UsageEnvironment &, int socket, netAddressBits groupAddress, netAddressBits sourceFilterAddr)
static Boolean	getSourcePort0 (int socket, portNumBits &resultPortNum)
Boolean	getSourcePort (UsageEnvironment &env, int socket, Port &port)
static Boolean	badAddress (netAddressBits addr)
netAddressBits	ourIPAddress (UsageEnvironment &env)
netAddressBits	chooseRandomIPv4SSMAddress (UsageEnvironment &env)
char const *	timestampString ()
Variables
netAddressBits	SendingInterfaceAddr = INADDR_ANY
netAddressBits	ReceivingInterfaceAddr = INADDR_ANY
static int	reuseFlag = 1
Boolean	loopbackWorks = 1

---

Define Documentation

 

#define initializeWinsockIfNecessary

(

)

1

Definition at line 30 of file GroupsockHelper.cpp.

Referenced by BasicUsageEnvironment::BasicUsageEnvironment(), our_gethostbyname(), setupDatagramSocket(), and setupStreamSocket().

#define IP_ADD_SOURCE_MEMBERSHIP   25

Definition at line 490 of file GroupsockHelper.cpp.

Referenced by socketJoinGroupSSM().

#define IP_DROP_SOURCE_MEMBERSHIP   26

Definition at line 491 of file GroupsockHelper.cpp.

Referenced by socketLeaveGroupSSM().

#define TTL_TYPE   u_int8_t

Referenced by writeSocket().

---

Function Documentation

static Boolean badAddress

(

netAddressBits

addr

)

[static]

Definition at line 557 of file GroupsockHelper.cpp.

Referenced by ourIPAddress().

                                               {
  // Check for some possible erroneous addresses:
  netAddressBits hAddr = ntohl(addr);
  return (hAddr == 0x7F000001 /* 127.0.0.1 */
          || hAddr == 0
          || hAddr == (netAddressBits)(~0));
}

static int blockUntilReadable	(	UsageEnvironment &	env,
		int	socket,
		struct timeval *	timeout
	)			[static]

Definition at line 219 of file GroupsockHelper.cpp.

References env, NULL, and socketErr().

Referenced by readSocket().

                                                                   {
  int result = -1;
  do {
    fd_set rd_set;
    FD_ZERO(&rd_set);
    if (socket < 0) break;
    FD_SET((unsigned) socket, &rd_set);
    const unsigned numFds = socket+1;
    
    result = select(numFds, &rd_set, NULL, NULL, timeout);
    if (timeout != NULL && result == 0) {
      break; // this is OK - timeout occurred
    } else if (result <= 0) {
#if defined(__WIN32__) || defined(_WIN32)
#else
      if (errno == EINTR || errno == EAGAIN) continue;
#endif
      socketErr(env, "select() error: ");
      break;
    }
    
    if (!FD_ISSET(socket, &rd_set)) {
      socketErr(env, "select() error - !FD_ISSET");
      break;
    }
  } while (0);

  return result;
}

netAddressBits chooseRandomIPv4SSMAddress

(

UsageEnvironment &

env

)

Definition at line 688 of file GroupsockHelper.cpp.

References env, our_random(), and ourIPAddress().

Referenced by main().

                                                                 {
  // First, a hack to ensure that our random number generator is seeded:
  (void) ourIPAddress(env);

  // Choose a random address in the range [232.0.1.0, 232.255.255.255)
  // i.e., [0xE8000100, 0xE8FFFFFF)
  netAddressBits const first = 0xE8000100, lastPlus1 = 0xE8FFFFFF;
  netAddressBits const range = lastPlus1 - first;

  return htonl(first + ((netAddressBits)our_random())%range);
}

static unsigned getBufferSize	(	UsageEnvironment &	env,
		int	bufOptName,
		int	socket
	)			[static]

Definition at line 360 of file GroupsockHelper.cpp.

References env, socketErr(), and SOCKLEN_T.

Referenced by getReceiveBufferSize(), getSendBufferSize(), increaseBufferTo(), and setBufferTo().

                                          {
  unsigned curSize;
  SOCKLEN_T sizeSize = sizeof curSize;
  if (getsockopt(socket, SOL_SOCKET, bufOptName,
                 (char*)&curSize, &sizeSize) < 0) {
    socketErr(env, "getBufferSize() error: ");
    return 0;
  }

  return curSize;
}

unsigned getReceiveBufferSize	(	UsageEnvironment &	env,
		int	socket
	)

Definition at line 375 of file GroupsockHelper.cpp.

References env, and getBufferSize().

Referenced by main().

                                                                 {
  return getBufferSize(env, SO_RCVBUF, socket);
}

unsigned getSendBufferSize	(	UsageEnvironment &	env,
		int	socket
	)

Definition at line 372 of file GroupsockHelper.cpp.

References env, and getBufferSize().

                                                              {
  return getBufferSize(env, SO_SNDBUF, socket);
}

Boolean getSourcePort	(	UsageEnvironment &	env,
		int	socket,
		Port &	port
	)

Definition at line 540 of file GroupsockHelper.cpp.

References env, False, getSourcePort0(), MAKE_SOCKADDR_IN, socketErr(), and True.

Referenced by MediaSubsession::initiate(), RTSPServer::setUpOurSocket(), RTSPOverHTTPServer::setUpOurSocket(), HTTPSink::setUpOurSocket(), SIPClient::SIPClient(), and OutputSocket::write().

                                                                     {
  portNumBits portNum = 0;
  if (!getSourcePort0(socket, portNum) || portNum == 0) {
    // Hack - call bind(), then try again:
    MAKE_SOCKADDR_IN(name, INADDR_ANY, 0);
    bind(socket, (struct sockaddr*)&name, sizeof name);

    if (!getSourcePort0(socket, portNum) || portNum == 0) {
      socketErr(env, "getsockname() error: ");
      return False;
    }
  }
  
  port = Port(portNum);
  return True;
}

static Boolean getSourcePort0	(	int	socket,
		portNumBits &	resultPortNum
	)			[static]

Definition at line 531 of file GroupsockHelper.cpp.

References False, SOCKLEN_T, and True.

Referenced by getSourcePort().

                                                                                    {
  sockaddr_in test; test.sin_port = 0;
  SOCKLEN_T len = sizeof test;
  if (getsockname(socket, (struct sockaddr*)&test, &len) < 0) return False;
  
  resultPortNum = ntohs(test.sin_port);
  return True;
}

static unsigned increaseBufferTo	(	UsageEnvironment &	env,
		int	bufOptName,
		int	socket,
		unsigned	requestedSize
	)			[static]

Definition at line 396 of file GroupsockHelper.cpp.

References env, getBufferSize(), and SOCKLEN_T.

Referenced by increaseReceiveBufferTo(), and increaseSendBufferTo().

                                                                     {
  // First, get the current buffer size.  If it's already at least
  // as big as what we're requesting, do nothing.
  unsigned curSize = getBufferSize(env, bufOptName, socket);

  // Next, try to increase the buffer to the requested size,
  // or to some smaller size, if that's not possible:
  while (requestedSize > curSize) {
    SOCKLEN_T sizeSize = sizeof requestedSize;
    if (setsockopt(socket, SOL_SOCKET, bufOptName,
                   (char*)&requestedSize, sizeSize) >= 0) {
      // success
      return requestedSize;
    }
    requestedSize = (requestedSize+curSize)/2;
  }

  return getBufferSize(env, bufOptName, socket);
}

unsigned increaseReceiveBufferTo	(	UsageEnvironment &	env,
		int	socket,
		unsigned	requestedSize
	)

Definition at line 420 of file GroupsockHelper.cpp.

References env, and increaseBufferTo().

Referenced by BasicUDPSource::BasicUDPSource(), MP3HTTPSource::createNew(), and MultiFramedRTPSource::MultiFramedRTPSource().

                                                                     {
  return increaseBufferTo(env, SO_RCVBUF, socket, requestedSize);
}

unsigned increaseSendBufferTo	(	UsageEnvironment &	env,
		int	socket,
		unsigned	requestedSize
	)

Definition at line 416 of file GroupsockHelper.cpp.

References env, and increaseBufferTo().

Referenced by RTSPServer::incomingConnectionHandler1(), RTSPOverHTTPServer::incomingConnectionHandler1(), RTPInterface::RTPInterface(), DarwinInjector::setDestination(), RTSPServer::setUpOurSocket(), RTSPOverHTTPServer::setUpOurSocket(), and HTTPSink::setUpOurSocket().

                                                                  {
  return increaseBufferTo(env, SO_SNDBUF, socket, requestedSize);
}

Boolean makeSocketNonBlocking

(

int

sock

)

Definition at line 137 of file GroupsockHelper.cpp.

Referenced by BasicUDPSource::BasicUDPSource(), RTSPServer::incomingConnectionHandler1(), RTSPOverHTTPServer::incomingConnectionHandler1(), RTPInterface::RTPInterface(), and setupStreamSocket().

                                        {
#if defined(__WIN32__) || defined(_WIN32) || defined(IMN_PIM)
  unsigned long arg = 1;
  return ioctlsocket(sock, FIONBIO, &arg) == 0;
#elif defined(VXWORKS)
  int arg = 1;
  return ioctl(sock, FIONBIO, (int)&arg) == 0;
#else
  int curFlags = fcntl(sock, F_GETFL, 0);
  return fcntl(sock, F_SETFL, curFlags|O_NONBLOCK) >= 0;
#endif
}

netAddressBits ourIPAddress

(

UsageEnvironment &

env

)

Definition at line 567 of file GroupsockHelper.cpp.

References badAddress(), closeSocket, env, if(), loopbackWorks, NULL, our_inet_addr(), our_srandom(), readSocket(), UsageEnvironment::setResultErrMsg(), UsageEnvironment::setResultMsg(), setupDatagramSocket(), socketJoinGroup(), socketLeaveGroup(), and writeSocket().

Referenced by chooseRandomIPv4SSMAddress(), ServerMediaSession::generateSDPDescription(), Groupsock::Groupsock(), Groupsock::output(), RTSPServer::rtspURLPrefix(), SIPClient::SIPClient(), and Groupsock::wasLoopedBackFromUs().

                                                   {
  static netAddressBits ourAddress = 0;
  int sock = -1;
  struct in_addr testAddr;
  
  if (ourAddress == 0) {
    // We need to find our source address
    struct sockaddr_in fromAddr;
    fromAddr.sin_addr.s_addr = 0;
    
    // Get our address by sending a (0-TTL) multicast packet,
    // receiving it, and looking at the source address used.
    // (This is kinda bogus, but it provides the best guarantee
    // that other nodes will think our address is the same as we do.)
    do {
      loopbackWorks = 0; // until we learn otherwise

      testAddr.s_addr = our_inet_addr("228.67.43.91"); // arbitrary
      Port testPort(15947); // ditto
      
      sock = setupDatagramSocket(env, testPort);
      if (sock < 0) break;
      
      if (!socketJoinGroup(env, sock, testAddr.s_addr)) break;
      
      unsigned char testString[] = "hostIdTest";
      unsigned testStringLength = sizeof testString;
      
      if (!writeSocket(env, sock, testAddr, testPort, 0,
                       testString, testStringLength)) break;
      
      unsigned char readBuffer[20];
      struct timeval timeout;
      timeout.tv_sec = 5;
      timeout.tv_usec = 0;
      int bytesRead = readSocket(env, sock,
                                 readBuffer, sizeof readBuffer,
                                 fromAddr, &timeout);
      if (bytesRead == 0 // timeout occurred
          || bytesRead != (int)testStringLength
          || strncmp((char*)readBuffer, (char*)testString,
                     testStringLength) != 0) {
        break;
      }

      loopbackWorks = 1;
    } while (0);

    if (!loopbackWorks) do {
      // We couldn't find our address using multicast loopback
      // so try instead to look it up directly.
      char hostname[100];
      hostname[0] = '\0';
#ifndef CRIS
      gethostname(hostname, sizeof hostname);
#endif
      if (hostname[0] == '\0') {
        env.setResultErrMsg("initial gethostname() failed");
        break;
      }
      
#if defined(VXWORKS)
#include <hostLib.h>
      if (ERROR == (ourAddress = hostGetByName( hostname ))) break;
#else
      struct hostent* hstent
        = (struct hostent*)gethostbyname(hostname);
      if (hstent == NULL || hstent->h_length != 4) {
        env.setResultErrMsg("initial gethostbyname() failed");
        break;
      }
      // Take the first address that's not bad
      // (This code, like many others, won't handle IPv6)
      netAddressBits addr = 0;
      for (unsigned i = 0; ; ++i) {
        char* addrPtr = hstent->h_addr_list[i];
        if (addrPtr == NULL) break;
        
        netAddressBits a = *(netAddressBits*)addrPtr;
        if (!badAddress(a)) {
          addr = a;
          break;
        }
      }
      if (addr != 0) {
        fromAddr.sin_addr.s_addr = addr;
      } else {
        env.setResultMsg("no address");
        break;
      }
    } while (0);
    
    // Make sure we have a good address:
    netAddressBits from = fromAddr.sin_addr.s_addr;
    if (badAddress(from)) {
      char tmp[100];
      sprintf(tmp,
              "This computer has an invalid IP address: 0x%x",
              (netAddressBits)(ntohl(from)));
      env.setResultMsg(tmp);
      from = 0;
    }
    
    ourAddress = from;
#endif
    
    if (sock >= 0) {
      socketLeaveGroup(env, sock, testAddr.s_addr);
      closeSocket(sock);
    }
    
    // Use our newly-discovered IP address, and the current time,
    // to initialize the random number generator's seed:
    struct timeval timeNow;
    gettimeofday(&timeNow, NULL);
    unsigned seed = ourAddress^timeNow.tv_sec^timeNow.tv_usec;
    our_srandom(seed);
  }
  return ourAddress;
}

int readSocket	(	UsageEnvironment &	env,
		int	socket,
		unsigned char *	buffer,
		unsigned	bufferSize,
		struct sockaddr_in &	fromAddress,
		struct timeval *	timeout
	)

Definition at line 254 of file GroupsockHelper.cpp.

References blockUntilReadable(), env, UsageEnvironment::getErrno(), NULL, socketErr(), and SOCKLEN_T.

Referenced by RTSPClient::describeURL(), RTSPClient::getMediaSessionParameter(), RTSPClient::getResponse1(), RTPInterface::handleRead(), Groupsock::handleRead(), RTSPServer::RTSPClientSession::incomingRequestHandler1(), RTSPOverHTTPServer::HTTPClientConnection::incomingRequestHandler1(), ourIPAddress(), readSocketExact(), and SocketDescriptor::tcpReadHandler().

                                        {
  int bytesRead = -1;
  do {
    int result = blockUntilReadable(env, socket, timeout);
    if (timeout != NULL && result == 0) {
      bytesRead = 0;
      break;
    } else if (result <= 0) {
      break;
    }
    
    SOCKLEN_T addressSize = sizeof fromAddress;
    bytesRead = recvfrom(socket, (char*)buffer, bufferSize, 0,
                         (struct sockaddr*)&fromAddress,
                         &addressSize);
    if (bytesRead < 0) {
      //##### HACK to work around bugs in Linux and Windows:
      int err = env.getErrno();
      if (err == 111 /*ECONNREFUSED (Linux)*/
#if defined(__WIN32__) || defined(_WIN32)
          // What a piece of crap Windows is.  Sometimes
          // recvfrom() returns -1, but with an 'errno' of 0.
          // This appears not to be a real error; just treat
          // it as if it were a read of zero bytes, and hope
          // we don't have to do anything else to 'reset'
          // this alleged error:
          || err == 0
#else
          || err == EAGAIN
#endif
          || err == 113 /*EHOSTUNREACH (Linux)*/) {
                                //Why does Linux return this for datagram sock?
        fromAddress.sin_addr.s_addr = 0;
        return 0;
      }
      //##### END HACK
      socketErr(env, "recvfrom() error: ");
      break;
    }
  } while (0);
  
  return bytesRead;
}

int readSocketExact	(	UsageEnvironment &	env,
		int	socket,
		unsigned char *	buffer,
		unsigned	bufferSize,
		struct sockaddr_in &	fromAddress,
		struct timeval *	timeout
	)

Definition at line 302 of file GroupsockHelper.cpp.

References env, and readSocket().

Referenced by RTSPClient::getResponse1(), and SocketDescriptor::tcpReadHandler().

                                             {
  /* read EXACTLY bufferSize bytes from the socket into the buffer.
     fromaddress is address of last read.
     return the number of bytes acually read when an error occurs
  */
  int bsize = bufferSize;
  int bytesRead = 0;
  int totBytesRead =0;
  do {
    bytesRead = readSocket (env, socket, buffer + totBytesRead, bsize,
                            fromAddress, timeout);
    if (bytesRead <= 0) break;
    totBytesRead += bytesRead;
    bsize -= bytesRead;
  } while (bsize != 0);

  return totBytesRead;
}

static unsigned setBufferTo	(	UsageEnvironment &	env,
		int	bufOptName,
		int	socket,
		unsigned	requestedSize
	)			[static]

Definition at line 379 of file GroupsockHelper.cpp.

References env, getBufferSize(), and SOCKLEN_T.

Referenced by setReceiveBufferTo(), and setSendBufferTo().

                                                                {
  SOCKLEN_T sizeSize = sizeof requestedSize;
  setsockopt(socket, SOL_SOCKET, bufOptName, (char*)&requestedSize, sizeSize);

  // Get and return the actual, resulting buffer size:
  return getBufferSize(env, bufOptName, socket);
}

unsigned setReceiveBufferTo	(	UsageEnvironment &	env,
		int	socket,
		unsigned	requestedSize
	)

Definition at line 391 of file GroupsockHelper.cpp.

References env, and setBufferTo().

Referenced by main().

                                                                {
        return setBufferTo(env, SO_RCVBUF, socket, requestedSize);
}

unsigned setSendBufferTo	(	UsageEnvironment &	env,
		int	socket,
		unsigned	requestedSize
	)

Definition at line 387 of file GroupsockHelper.cpp.

References env, and setBufferTo().

                                                             {
        return setBufferTo(env, SO_SNDBUF, socket, requestedSize);
}

int setupDatagramSocket	(	UsageEnvironment &	env,
		Port	port,
		Boolean
	)

Definition at line 52 of file GroupsockHelper.cpp.

References closeSocket, env, initializeWinsockIfNecessary, MAKE_SOCKADDR_IN, Port::num(), ReceivingInterfaceAddr, reuseFlag, SendingInterfaceAddr, and socketErr().

Referenced by Socket::changePort(), ourIPAddress(), and Socket::Socket().

  {
  if (!initializeWinsockIfNecessary()) {
    socketErr(env, "Failed to initialize 'winsock': ");
    return -1;
  }
  
  int newSocket = socket(AF_INET, SOCK_DGRAM, 0);
  if (newSocket < 0) {
    socketErr(env, "unable to create datagram socket: ");
    return newSocket;
  }
  
  if (setsockopt(newSocket, SOL_SOCKET, SO_REUSEADDR,
                 (const char*)&reuseFlag, sizeof reuseFlag) < 0) {
    socketErr(env, "setsockopt(SO_REUSEADDR) error: ");
    closeSocket(newSocket);
    return -1;
  }
  
#if defined(__WIN32__) || defined(_WIN32)
  // Windoze doesn't properly handle SO_REUSEPORT or IP_MULTICAST_LOOP
#else
#ifdef SO_REUSEPORT
  if (setsockopt(newSocket, SOL_SOCKET, SO_REUSEPORT,
                 (const char*)&reuseFlag, sizeof reuseFlag) < 0) {
    socketErr(env, "setsockopt(SO_REUSEPORT) error: ");
    closeSocket(newSocket);
    return -1;
  }
#endif
  
#ifdef IP_MULTICAST_LOOP
  const u_int8_t loop = (u_int8_t)setLoopback;
  if (setsockopt(newSocket, IPPROTO_IP, IP_MULTICAST_LOOP,
                 (const char*)&loop, sizeof loop) < 0) {
    socketErr(env, "setsockopt(IP_MULTICAST_LOOP) error: ");
    closeSocket(newSocket);
    return -1;
  }
#endif
#endif
  
  // Note: Windoze requires binding, even if the port number is 0
  netAddressBits addr = INADDR_ANY;
#if defined(__WIN32__) || defined(_WIN32)
#else
  if (port.num() != 0 || ReceivingInterfaceAddr != INADDR_ANY) {
#endif
    if (port.num() == 0) addr = ReceivingInterfaceAddr;
    MAKE_SOCKADDR_IN(name, addr, port.num());
    if (bind(newSocket, (struct sockaddr*)&name, sizeof name) != 0) {
      char tmpBuffer[100];
      sprintf(tmpBuffer, "bind() error (port number: %d): ",
              ntohs(port.num()));
      socketErr(env, tmpBuffer);
      closeSocket(newSocket);
      return -1;
    }
#if defined(__WIN32__) || defined(_WIN32)
#else
  }
#endif
  
  // Set the sending interface for multicasts, if it's not the default:
  if (SendingInterfaceAddr != INADDR_ANY) {
    struct in_addr addr;
    addr.s_addr = SendingInterfaceAddr;
    
    if (setsockopt(newSocket, IPPROTO_IP, IP_MULTICAST_IF,
                   (const char*)&addr, sizeof addr) < 0) {
      socketErr(env, "error setting outgoing multicast interface: ");
      closeSocket(newSocket);
      return -1;
    }
  }
  
  return newSocket;
}

int setupStreamSocket	(	UsageEnvironment &	env,
		Port	port,
		Boolean	makeNonBlocking
	)

Definition at line 150 of file GroupsockHelper.cpp.

References closeSocket, env, initializeWinsockIfNecessary, MAKE_SOCKADDR_IN, makeSocketNonBlocking(), Port::num(), ReceivingInterfaceAddr, reuseFlag, and socketErr().

Referenced by MP3HTTPSource::createNew(), RTSPClient::openConnectionFromURL(), RTSPClient::setupHTTPTunneling(), RTSPServer::setUpOurSocket(), RTSPOverHTTPServer::setUpOurSocket(), and HTTPSink::setUpOurSocket().

                                                          {
  if (!initializeWinsockIfNecessary()) {
    socketErr(env, "Failed to initialize 'winsock': ");
    return -1;
  }
  
  int newSocket = socket(AF_INET, SOCK_STREAM, 0);
  if (newSocket < 0) {
    socketErr(env, "unable to create stream socket: ");
    return newSocket;
  }
  
  if (setsockopt(newSocket, SOL_SOCKET, SO_REUSEADDR,
                 (const char*)&reuseFlag, sizeof reuseFlag) < 0) {
    socketErr(env, "setsockopt(SO_REUSEADDR) error: ");
    closeSocket(newSocket);
    return -1;
  }
  
  // SO_REUSEPORT doesn't really make sense for TCP sockets, so we
  // normally don't set them.  However, if you really want to do this
  // #define REUSE_FOR_TCP
#ifdef REUSE_FOR_TCP
#if defined(__WIN32__) || defined(_WIN32)
  // Windoze doesn't properly handle SO_REUSEPORT
#else
#ifdef SO_REUSEPORT
  if (setsockopt(newSocket, SOL_SOCKET, SO_REUSEPORT,
                 (const char*)&reuseFlag, sizeof reuseFlag) < 0) {
    socketErr(env, "setsockopt(SO_REUSEPORT) error: ");
    closeSocket(newSocket);
    return -1;
  }
#endif
#endif
#endif

  // Note: Windoze requires binding, even if the port number is 0
#if defined(__WIN32__) || defined(_WIN32)
#else
  if (port.num() != 0 || ReceivingInterfaceAddr != INADDR_ANY) {
#endif
    MAKE_SOCKADDR_IN(name, ReceivingInterfaceAddr, port.num());
    if (bind(newSocket, (struct sockaddr*)&name, sizeof name) != 0) {
      char tmpBuffer[100];
      sprintf(tmpBuffer, "bind() error (port number: %d): ",
              ntohs(port.num()));
      socketErr(env, tmpBuffer);
      closeSocket(newSocket);
      return -1;
    }
#if defined(__WIN32__) || defined(_WIN32)
#else
  }
#endif

  if (makeNonBlocking) {
    if (!makeSocketNonBlocking(newSocket)) {
      socketErr(env, "failed to make non-blocking: ");
      closeSocket(newSocket);
      return -1;
    }
  }

  return newSocket;
}

static void socketErr	(	UsageEnvironment &	env,
		char *	errorMsg
	)			[static]

Definition at line 38 of file GroupsockHelper.cpp.

References env, and UsageEnvironment::setResultErrMsg().

Referenced by blockUntilReadable(), getBufferSize(), getSourcePort(), readSocket(), setupDatagramSocket(), setupStreamSocket(), socketJoinGroup(), socketJoinGroupSSM(), and writeSocket().

                                                             {
        env.setResultErrMsg(errorMsg);
}

Boolean socketJoinGroup	(	UsageEnvironment &	env,
		int	socket,
		netAddressBits	groupAddress
	)

Definition at line 425 of file GroupsockHelper.cpp.

References env, False, UsageEnvironment::getErrno(), IsMulticastAddress(), ReceivingInterfaceAddr, socketErr(), and True.

Referenced by Groupsock::changeDestinationParameters(), Groupsock::Groupsock(), and ourIPAddress().

                                                    {
  if (!IsMulticastAddress(groupAddress)) return True; // ignore this case

  struct ip_mreq imr;
  imr.imr_multiaddr.s_addr = groupAddress;
  imr.imr_interface.s_addr = ReceivingInterfaceAddr;
  if (setsockopt(socket, IPPROTO_IP, IP_ADD_MEMBERSHIP,
                 (const char*)&imr, sizeof (struct ip_mreq)) < 0) {
#if defined(__WIN32__) || defined(_WIN32)
    if (env.getErrno() != 0) {
      // That piece-of-shit toy operating system (Windows) sometimes lies
      // about setsockopt() failing!
#endif
      socketErr(env, "setsockopt(IP_ADD_MEMBERSHIP) error: ");
      return False;
#if defined(__WIN32__) || defined(_WIN32)
    }
#endif
  }
  
  return True;
}

Boolean socketJoinGroupSSM	(	UsageEnvironment &	env,
		int	socket,
		netAddressBits	groupAddress,
		netAddressBits	sourceFilterAddr
	)

Definition at line 496 of file GroupsockHelper.cpp.

References env, False, ip_mreq_source::imr_interface, ip_mreq_source::imr_multiaddr, ip_mreq_source::imr_sourceaddr, IP_ADD_SOURCE_MEMBERSHIP, IsMulticastAddress(), ReceivingInterfaceAddr, socketErr(), and True.

Referenced by Groupsock::Groupsock().

                                                            {
  if (!IsMulticastAddress(groupAddress)) return True; // ignore this case

  struct ip_mreq_source imr;
  imr.imr_multiaddr.s_addr = groupAddress;
  imr.imr_sourceaddr.s_addr = sourceFilterAddr;
  imr.imr_interface.s_addr = ReceivingInterfaceAddr;
  if (setsockopt(socket, IPPROTO_IP, IP_ADD_SOURCE_MEMBERSHIP,
                 (const char*)&imr, sizeof (struct ip_mreq_source)) < 0) {
    socketErr(env, "setsockopt(IP_ADD_SOURCE_MEMBERSHIP) error: ");
    return False;
  }
  
  return True;
}

Boolean socketLeaveGroup	(	UsageEnvironment &	,
		int	socket,
		netAddressBits	groupAddress
	)

Definition at line 449 of file GroupsockHelper.cpp.

References False, IsMulticastAddress(), ReceivingInterfaceAddr, and True.

Referenced by Groupsock::changeDestinationParameters(), Groupsock::multicastSendOnly(), ourIPAddress(), and Groupsock::~Groupsock().

                                                      {
  if (!IsMulticastAddress(groupAddress)) return True; // ignore this case

  struct ip_mreq imr;
  imr.imr_multiaddr.s_addr = groupAddress;
  imr.imr_interface.s_addr = ReceivingInterfaceAddr;
  if (setsockopt(socket, IPPROTO_IP, IP_DROP_MEMBERSHIP,
                 (const char*)&imr, sizeof (struct ip_mreq)) < 0) {
    return