groupsock/include/GroupsockHelper.hh File Reference

#include "NetAddress.hh"

Include dependency graph for GroupsockHelper.hh:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
class	NoReuse
struct	_groupsockPriv
Defines
#define	SET_SOCKADDR_SIN_LEN(var)
#define	MAKE_SOCKADDR_IN(var, adr, prt)
Functions
int	setupDatagramSocket (UsageEnvironment &env, Port port)
int	setupStreamSocket (UsageEnvironment &env, Port port, Boolean makeNonBlocking=True)
int	readSocket (UsageEnvironment &env, int socket, unsigned char *buffer, unsigned bufferSize, struct sockaddr_in &fromAddress)
Boolean	writeSocket (UsageEnvironment &env, int socket, struct in_addr address, Port port, u_int8_t ttlArg, unsigned char *buffer, unsigned bufferSize)
unsigned	getSendBufferSize (UsageEnvironment &env, int socket)
unsigned	getReceiveBufferSize (UsageEnvironment &env, int socket)
unsigned	setSendBufferTo (UsageEnvironment &env, int socket, unsigned requestedSize)
unsigned	setReceiveBufferTo (UsageEnvironment &env, int socket, unsigned requestedSize)
unsigned	increaseSendBufferTo (UsageEnvironment &env, int socket, unsigned requestedSize)
unsigned	increaseReceiveBufferTo (UsageEnvironment &env, int socket, unsigned requestedSize)
Boolean	makeSocketNonBlocking (int sock)
Boolean	makeSocketBlocking (int sock)
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)
Boolean	getSourcePort (UsageEnvironment &env, int socket, Port &port)
netAddressBits	ourIPAddress (UsageEnvironment &env)
netAddressBits	chooseRandomIPv4SSMAddress (UsageEnvironment &env)
char const *	timestampString ()
_groupsockPriv *	groupsockPriv (UsageEnvironment &env)
void	reclaimGroupsockPriv (UsageEnvironment &env)
netAddressBits	our_inet_addr (char const *)
void	our_srandom (int x)
long	our_random ()
u_int32_t	our_random32 ()
Variables
netAddressBits	SendingInterfaceAddr
netAddressBits	ReceivingInterfaceAddr

---

Define Documentation

#define MAKE_SOCKADDR_IN	(	var,
		adr,
		prt		)

Value:

/*adr,prt must be in network order*/\
    struct sockaddr_in var;\
    var.sin_family = AF_INET;\
    var.sin_addr.s_addr = (adr);\
    var.sin_port = (prt);\
    SET_SOCKADDR_SIN_LEN(var);

Definition at line 90 of file GroupsockHelper.hh.

Referenced by RTSPClient::connectToServer(), MP3HTTPSource::createNew(), getSourcePort(), setupDatagramSocket(), setupStreamSocket(), and writeSocket().

#define SET_SOCKADDR_SIN_LEN

(

var

)

Definition at line 87 of file GroupsockHelper.hh.

---

Function Documentation

netAddressBits chooseRandomIPv4SSMAddress

(

UsageEnvironment &

env

)

Definition at line 644 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 ntohl(first + ((netAddressBits)our_random())%range);
}

unsigned getReceiveBufferSize	(	UsageEnvironment &	env,
		int	socket
	)

Definition at line 351 of file GroupsockHelper.cpp.

References env, and getBufferSize().

Referenced by continueAfterDESCRIBE().

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

unsigned getSendBufferSize	(	UsageEnvironment &	env,
		int	socket
	)

Definition at line 348 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 507 of file GroupsockHelper.cpp.

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

Referenced by MediaSubsession::initiate(), RTSPServer::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;
}

_groupsockPriv* groupsockPriv

(

UsageEnvironment &

env

)

Definition at line 53 of file GroupsockHelper.cpp.

References env, UsageEnvironment::groupsockPriv, NULL, _groupsockPriv::reuseFlag, and _groupsockPriv::socketTable.

Referenced by getSocketTable(), NoReuse::NoReuse(), setupDatagramSocket(), setupStreamSocket(), and NoReuse::~NoReuse().

                                                     {
  if (env.groupsockPriv == NULL) { // We need to create it
    _groupsockPriv* result = new _groupsockPriv;
    result->socketTable = NULL;
    result->reuseFlag = 1; // default value => allow reuse of socket numbers
    env.groupsockPriv = result;
  }
  return (_groupsockPriv*)(env.groupsockPriv);
}

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

Definition at line 396 of file GroupsockHelper.cpp.

References env, and increaseBufferTo().

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

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

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

Definition at line 392 of file GroupsockHelper.cpp.

References env, and increaseBufferTo().

Referenced by OnDemandServerMediaSubsession::getStreamParameters(), RTSPServer::incomingConnectionHandler(), RTPInterface::RTPInterface(), DarwinInjector::setDestination(), RTSPServer::setUpOurSocket(), and PassiveServerMediaSubsession::startStream().

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

Boolean makeSocketBlocking

(

int

sock

)

Definition at line 184 of file GroupsockHelper.cpp.

                                     {
#if defined(__WIN32__) || defined(_WIN32)
  unsigned long arg = 0;
  return ioctlsocket(sock, FIONBIO, &arg) == 0;
#elif defined(VXWORKS)
  int arg = 0;
  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
}

Boolean makeSocketNonBlocking

(

int

sock

)

Definition at line 171 of file GroupsockHelper.cpp.

Referenced by BasicUDPSource::BasicUDPSource(), ByteStreamFileSource::ByteStreamFileSource(), RTSPServer::incomingConnectionHandler(), RTPInterface::RTPInterface(), and setupStreamSocket().

                                        {
#if defined(__WIN32__) || defined(_WIN32)
  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 our_inet_addr

(

char const *

)

Definition at line 15 of file inet.c.

Referenced by MPEG2TransportUDPServerMediaSubsession::createNewStreamSource(), RTSPServer::RTSPClientSession::handleCmd_SETUP(), main(), NetAddressList::NetAddressList(), ourIPAddress(), and startReplicaUDPSink().

{
        return inet_addr(cp);
}

long our_random

(

)

Definition at line 388 of file inet.c.

References DEG_3, SEP_3, and TYPE_0.

Referenced by FileSink::addData(), chooseRandomIPv4SSMAddress(), MP3ADUdeinterleaver::doGetNextFrame(), MP3FromADUSource::doGetNextFrame(), drand30(), MediaSession::MediaSession(), MultiFramedRTPSource::networkReadHandler1(), our_random32(), our_srandom(), and MultiFramedRTPSink::sendPacketIfNecessary().

                  {
  long i;

  if (rand_type == TYPE_0) {
    i = state[0] = (state[0] * 1103515245 + 12345) & 0x7fffffff;
  } else {
    /* Make copies of "rptr" and "fptr" before working with them, in case we're being called concurrently by multiple threads: */
    long* rp = rptr;
    long* fp = fptr;

    /* Make sure "rp" and "fp" are separated by the correct distance (again, allowing for concurrent access): */
    if (!(fp == rp+SEP_3 || fp+DEG_3 == rp+SEP_3)) {
      /* A rare case that should occur only if we're being called concurrently by multiple threads. */
      /* Restore the proper separation between the pointers: */
      if (rp <= fp) rp = fp-SEP_3; else rp = fp+DEG_3-SEP_3;
    }

    *fp += *rp;
    i = (*fp >> 1) & 0x7fffffff;        /* chucking least random bit */
    if (++fp >= end_ptr) {
      fp = state;
      ++rp;
    } else if (++rp >= end_ptr) {
      rp = state;
    }

    /* Restore "rptr" and "fptr" from our working copies: */
    rptr = rp;
    fptr = fp;
  }

  return i;
}

u_int32_t our_random32

(

)

Definition at line 423 of file inet.c.

References our_random().

Referenced by RTSPServer::incomingConnectionHandler(), SIPClient::invite(), and DarwinInjector::setDestination().

                         {
  /* Return a 32-bit random number.
     Because "our_random()" returns a 31-bit random number, we call it a second
     time, to generate the high bit.
     (Actually, to increase the likelhood of randomness, we take the middle 16 bits of two successive calls to "our_random()")
  */
  long random_1 = our_random();
  u_int32_t random16_1 = (u_int32_t)(random_1&0x00FFFF00);

  long random_2 = our_random();
  u_int32_t random16_2 = (u_int32_t)(random_2&0x00FFFF00);

  return (random16_1<<8) | (random16_2>>8);
}

void our_srandom

(

int

x

)

Referenced by our_initstate(), and ourIPAddress().

netAddressBits ourIPAddress

(

UsageEnvironment &

env

)

Definition at line 534 of file GroupsockHelper.cpp.

References badAddressForUs(), closeSocket, NetAddress::data(), env, iter, 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;

      // Block until the socket is readable (with a 5-second timeout):
      fd_set rd_set;
      FD_ZERO(&rd_set);
      FD_SET((unsigned)sock, &rd_set);
      const unsigned numFds = sock+1;
      struct timeval timeout;
      timeout.tv_sec = 5;
      timeout.tv_usec = 0;
      int result = select(numFds, &rd_set, NULL, NULL, &timeout);
      if (result <= 0) break;

      unsigned char readBuffer[20];
      int bytesRead = readSocket(env, sock,
                                 readBuffer, sizeof readBuffer,
                                 fromAddr);
      if (bytesRead != (int)testStringLength
          || strncmp((char*)readBuffer, (char*)testString, testStringLength) != 0) {
        break;
      }

      loopbackWorks = 1;
    } while (0);

    if (sock >= 0) {
      socketLeaveGroup(env, sock, testAddr.s_addr);
      closeSocket(sock);
    }

    if (!loopbackWorks) do {
      // We couldn't find our address using multicast loopback,
      // so try instead to look it up directly - by first getting our host name, and then resolving this host name
      char hostname[100];
      hostname[0] = '\0';
      int result = gethostname(hostname, sizeof hostname);
      if (result != 0 || hostname[0] == '\0') {
        env.setResultErrMsg("initial gethostname() failed");
        break;
      }

      // Try to resolve "hostname" to an IP address:
      NetAddressList addresses(hostname);
      NetAddressList::Iterator iter(addresses);
      NetAddress const* address;

      // Take the first address that's not bad:
      netAddressBits addr = 0;
      while ((address = iter.nextAddress()) != NULL) {
        netAddressBits a = *(netAddressBits*)(address->data());
        if (!badAddressForUs(a)) {
          addr = a;
          break;
        }
      }

      // Assign the address that we found to "fromAddr" (as if the 'loopback' method had worked), to simplify the code below: 
      fromAddr.sin_addr.s_addr = addr;
    } while (0);

    // Make sure we have a good address:
    netAddressBits from = fromAddr.sin_addr.s_addr;
    if (badAddressForUs(from)) {
      char tmp[100];
      sprintf(tmp, "This computer has an invalid IP address: %s", AddressString(from).val());
      env.setResultMsg(tmp);
      from = 0;
    }

    ourAddress = from;

    // 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
	)

Definition at line 267 of file GroupsockHelper.cpp.

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

Referenced by Groupsock::handleRead(), RTPInterface::handleRead(), RTSPClient::incomingDataHandler1(), RTSPServer::RTSPClientSession::incomingRequestHandler1(), ourIPAddress(), and SocketDescriptor::tcpReadHandler1().

                                                {
  SOCKLEN_T addressSize = sizeof fromAddress;
  int 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 || err == EWOULDBLOCK
#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: ");
  }

  return bytesRead;
}

void reclaimGroupsockPriv

(

UsageEnvironment &

env

)

Definition at line 63 of file GroupsockHelper.cpp.

References env, UsageEnvironment::groupsockPriv, NULL, _groupsockPriv::reuseFlag, and _groupsockPriv::socketTable.

Referenced by setupDatagramSocket(), setupStreamSocket(), unsetGroupsockBySocket(), and NoReuse::~NoReuse().

                                                 {
  _groupsockPriv* priv = (_groupsockPriv*)(env.groupsockPriv);
  if (priv->socketTable == NULL && priv->reuseFlag == 1/*default value*/) {
    // We can delete the structure (to save space); it will get created again, if needed:
    delete priv;
    env.groupsockPriv = NULL;
  }
}

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

Definition at line 367 of file GroupsockHelper.cpp.

References env, and setBufferTo().

Referenced by continueAfterDESCRIBE().

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

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

Definition at line 363 of file GroupsockHelper.cpp.

References env, and setBufferTo().

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

int setupDatagramSocket	(	UsageEnvironment &	env,
		Port	port
	)

Definition at line 90 of file GroupsockHelper.cpp.

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

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

                                                          {
  if (!initializeWinsockIfNecessary()) {
    socketErr(env, "Failed to initialize 'winsock': ");
    return -1;
  }

  int newSocket = createSocket(SOCK_DGRAM);
  if (newSocket < 0) {
    socketErr(env, "unable to create datagram socket: ");
    return newSocket;
  }

  int reuseFlag = groupsockPriv(env)->reuseFlag;
  reclaimGroupsockPriv(env);
  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 = 1;
  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 = True
	)

Definition at line 197 of file GroupsockHelper.cpp.

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

Referenced by MP3HTTPSource::createNew(), RTSPClient::openConnection(), RTSPClient::responseHandlerForHTTP_GET1(), and RTSPServer::setUpOurSocket().

                                                          {
  if (!initializeWinsockIfNecessary()) {
    socketErr(env, "Failed to initialize 'winsock': ");
    return -1;
  }

  int newSocket = createSocket(SOCK_STREAM);
  if (newSocket < 0) {
    socketErr(env, "unable to create stream socket: ");
    return newSocket;
  }

  int reuseFlag = groupsockPriv(env)->reuseFlag;
  reclaimGroupsockPriv(env);
  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;
}

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

Definition at line 401 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 463 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 425 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 False;
  }

  return True;
}

Boolean socketLeaveGroupSSM	(	UsageEnvironment &	,
		int	socket,
		netAddressBits	groupAddress,
		netAddressBits	sourceFilterAddr
	)

Definition at line 481 of file GroupsockHelper.cpp.

References False, ip_mreq_source::imr_interface, ip_mreq_source::imr_multiaddr, ip_mreq_source::imr_sourceaddr, IP_DROP_SOURCE_MEMBERSHIP, IsMulticastAddress(), ReceivingInterfaceAddr, 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_DROP_SOURCE_MEMBERSHIP,
                 (const char*)&imr, sizeof (struct ip_mreq_source)) < 0) {
    return False;
  }

  return True;
}

char const* timestampString

(

)

Definition at line 656 of file GroupsockHelper.cpp.

References NULL.

Referenced by operator<<().

                              {
  struct timeval tvNow;
  gettimeofday(&tvNow, NULL);

#if !defined(_WIN32_WCE)
  static char timeString[9]; // holds hh:mm:ss plus trailing '\0'
  char const* ctimeResult = ctime((time_t*)&tvNow.tv_sec);
  if (ctimeResult == NULL) {
    sprintf(timeString, "??:??:??");
  } else {
    char const* from = &ctimeResult[11];
    int i;
    for (i = 0; i < 8; ++i) {
      timeString[i] = from[i];
    }
    timeString[i] = '\0';
  }
#else
  // WinCE apparently doesn't have "ctime()", so instead, construct
  // a timestamp string just using the integer and fractional parts
  // of "tvNow":
  static char timeString[50];
  sprintf(timeString, "%lu.%06ld", tvNow.tv_sec, tvNow.tv_usec);
#endif

  return (char const*)&timeString;
}

Boolean writeSocket	(	UsageEnvironment &	env,
		int	socket,
		struct in_addr	address,
		Port	port,
		u_int8_t	ttlArg,
		unsigned char *	buffer,
		unsigned	bufferSize
	)

Definition at line 300 of file GroupsockHelper.cpp.

References env, False, MAKE_SOCKADDR_IN, Port::num(), socketErr(), True, and TTL_TYPE.

Referenced by ourIPAddress(), and OutputSocket::write().

                                                                {
        do {
                if (ttlArg != 0) {
                        // Before sending, set the socket's TTL:
#if defined(__WIN32__) || defined(_WIN32)
#define TTL_TYPE int
#else
#define TTL_TYPE u_int8_t
#endif
                        TTL_TYPE ttl = (TTL_TYPE)ttlArg;
                        if (setsockopt(socket, IPPROTO_IP, IP_MULTICAST_TTL,
                                       (const char*)&ttl, sizeof ttl) < 0) {
                                socketErr(env, "setsockopt(IP_MULTICAST_TTL) error: ");
                                break;
                        }
                }

                MAKE_SOCKADDR_IN(dest, address.s_addr, port.num());
                int bytesSent = sendto(socket, (char*)buffer, bufferSize, 0,
                                       (struct sockaddr*)&dest, sizeof dest);
                if (bytesSent != (int)bufferSize) {
                        char tmpBuf[100];
                        sprintf(tmpBuf, "writeSocket(%d), sendTo() error: wrote %d bytes instead of %u: ", socket, bytesSent, bufferSize);
                        socketErr(env, tmpBuf);
                        break;
                }

                return True;
        } while (0);

        return False;
}

---

Variable Documentation

netAddressBits ReceivingInterfaceAddr

Definition at line 36 of file GroupsockHelper.cpp.

Referenced by RTSPServer::RTSPClientSession::handleCmd_SETUP(), main(), RTSPServer::rtspURLPrefix(), setupDatagramSocket(), setupStreamSocket(), socketJoinGroup(), socketJoinGroupSSM(), socketLeaveGroup(), and socketLeaveGroupSSM().

netAddressBits SendingInterfaceAddr

Definition at line 35 of file GroupsockHelper.cpp.

Referenced by RTSPServer::RTSPClientSession::handleCmd_SETUP(), and setupDatagramSocket().

---