/*  This file is a part of JRTPLIB  Copyright (c) 1999-2007 Jori Liesenborgs  Contact: jori.liesenborgs@gmail.com  This library was developed at the "Expertisecentrum Digitale Media"  (http://www.edm.uhasselt.be), a research center of the Hasselt University  (http://www.uhasselt.be). The library is based upon work done for   my thesis at the School for Knowledge Technology (Belgium/The Netherlands).  Permission is hereby granted, free of charge, to any person obtaining a  copy of this software and associated documentation files (the "Software"),  to deal in the Software without restriction, including without limitation  the rights to use, copy, modify, merge, publish, distribute, sublicense,  and/or sell copies of the Software, and to permit persons to whom the  Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included  in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS  IN THE SOFTWARE.*/#include "rtpudpv6transmitter.h"#ifdef RTP_SUPPORT_IPV6#include "rtprawpacket.h"#include "rtpipv6address.h"#include "rtptimeutilities.h"#include "rtpdefines.h"#include <stdio.h>#if (defined(WIN32) || defined(_WIN32_WCE))	#define RTPSOCKERR								INVALID_SOCKET	#define RTPCLOSE(x)								closesocket(x)	#define RTPSOCKLENTYPE								int	#define RTPIOCTL								ioctlsocket#else // not Win32	#include <sys/socket.h>	#include <netinet/in.h>	#include <arpa/inet.h>	#include <sys/ioctl.h>	#include <net/if.h>	#include <string.h>	#include <netdb.h>	#include <unistd.h>	#ifdef RTP_HAVE_SYS_FILIO		#include <sys/filio.h>	#endif // RTP_HAVE_SYS_FILIO	#ifdef RTP_HAVE_SYS_SOCKIO		#include <sys/sockio.h>	#endif // RTP_HAVE_SYS_SOCKIO	#ifdef RTP_SUPPORT_IFADDRS		#include <ifaddrs.h>	#endif // RTP_SUPPORT_IFADDRS	#define RTPSOCKERR								-1	#define RTPCLOSE(x)								close(x)	#ifdef RTP_SOCKLENTYPE_UINT		#define RTPSOCKLENTYPE							unsigned int	#else		#define RTPSOCKLENTYPE							int	#endif // RTP_SOCKLENTYPE_UINT	#define RTPIOCTL								ioctl#endif // WIN32#include "rtpdebug.h"#define RTPUDPV6TRANS_MAXPACKSIZE							65535#define RTPUDPV6TRANS_IFREQBUFSIZE							8192#define RTPUDPV6TRANS_IS_MCASTADDR(x)							(x.s6_addr[0] == 0xFF)#define RTPUDPV6TRANS_MCASTMEMBERSHIP(socket,type,mcastip,status)	{\										struct ipv6_mreq mreq;\										\										mreq.ipv6mr_multiaddr = mcastip;\										mreq.ipv6mr_interface = mcastifidx;\										status = setsockopt(socket,IPPROTO_IPV6,type,(const char *)&mreq,sizeof(struct ipv6_mreq));\									}#ifdef RTP_SUPPORT_THREAD	#define MAINMUTEX_LOCK 		{ if (threadsafe) mainmutex.Lock(); }	#define MAINMUTEX_UNLOCK	{ if (threadsafe) mainmutex.Unlock(); }	#define WAITMUTEX_LOCK		{ if (threadsafe) waitmutex.Lock(); }	#define WAITMUTEX_UNLOCK	{ if (threadsafe) waitmutex.Unlock(); }#else	#define MAINMUTEX_LOCK	#define MAINMUTEX_UNLOCK	#define WAITMUTEX_LOCK	#define WAITMUTEX_UNLOCK#endif // RTP_SUPPORT_THREAD	inline bool operator==(const in6_addr &ip1,const in6_addr &ip2){	if (memcmp(&ip1,&ip2,sizeof(in6_addr)) == 0)		return true;	return false;}RTPUDPv6Transmitter::RTPUDPv6Transmitter(RTPMemoryManager *mgr) : RTPTransmitter(mgr),								  destinations(GetMemoryManager(),RTPMEM_TYPE_CLASS_DESTINATIONLISTHASHELEMENT),								  multicastgroups(GetMemoryManager(),RTPMEM_TYPE_CLASS_MULTICASTHASHELEMENT),								  acceptignoreinfo(GetMemoryManager(),RTPMEM_TYPE_CLASS_ACCEPTIGNOREHASHELEMENT){	created = false;	init = false;#if (defined(WIN32) || defined(_WIN32_WCE))	timeinit.Dummy();#endif // WIN32 || _WIN32_WCE}RTPUDPv6Transmitter::~RTPUDPv6Transmitter(){	Destroy();}int RTPUDPv6Transmitter::Init(bool tsafe){	if (init)		return ERR_RTP_UDPV6TRANS_ALREADYINIT;	#ifdef RTP_SUPPORT_THREAD	threadsafe = tsafe;	if (threadsafe)	{		int status;				status = mainmutex.Init();		if (status < 0)			return ERR_RTP_UDPV6TRANS_CANTINITMUTEX;		status = waitmutex.Init();		if (status < 0)			return ERR_RTP_UDPV6TRANS_CANTINITMUTEX;	}#else	if (tsafe)		return ERR_RTP_NOTHREADSUPPORT;#endif // RTP_SUPPORT_THREAD	init = true;	return 0;}int RTPUDPv6Transmitter::Create(size_t maximumpacketsize,const RTPTransmissionParams *transparams){	const RTPUDPv6TransmissionParams *params,defaultparams;	struct sockaddr_in6 addr;	RTPSOCKLENTYPE size;	int status;	if (!init)		return ERR_RTP_UDPV6TRANS_NOTINIT;		MAINMUTEX_LOCK	if (created)	{		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_ALREADYCREATED;	}		// Obtain transmission parameters		if (transparams == 0)		params = &defaultparams;	else	{		if (transparams->GetTransmissionProtocol() != RTPTransmitter::IPv6UDPProto)		{			MAINMUTEX_UNLOCK			return ERR_RTP_UDPV6TRANS_ILLEGALPARAMETERS;		}		params = (const RTPUDPv6TransmissionParams *)transparams;	}	// Check if portbase is even	if (params->GetPortbase()%2 != 0)	{		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_PORTBASENOTEVEN;	}	// create sockets		rtpsock = socket(PF_INET6,SOCK_DGRAM,0);	if (rtpsock == RTPSOCKERR)	{		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_CANTCREATESOCKET;	}	rtcpsock = socket(PF_INET6,SOCK_DGRAM,0);	if (rtcpsock == RTPSOCKERR)	{		RTPCLOSE(rtpsock);		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_CANTCREATESOCKET;	}		// set socket buffer sizes		size = params->GetRTPReceiveBuffer();	if (setsockopt(rtpsock,SOL_SOCKET,SO_RCVBUF,(const char *)&size,sizeof(int)) != 0)	{		RTPCLOSE(rtpsock);		RTPCLOSE(rtcpsock);		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_CANTSETRTPRECEIVEBUF;	}	size = params->GetRTPSendBuffer();	if (setsockopt(rtpsock,SOL_SOCKET,SO_SNDBUF,(const char *)&size,sizeof(int)) != 0)	{		RTPCLOSE(rtpsock);		RTPCLOSE(rtcpsock);		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_CANTSETRTPTRANSMITBUF;	}	size = params->GetRTCPReceiveBuffer();	if (setsockopt(rtcpsock,SOL_SOCKET,SO_RCVBUF,(const char *)&size,sizeof(int)) != 0)	{		RTPCLOSE(rtpsock);		RTPCLOSE(rtcpsock);		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_CANTSETRTCPRECEIVEBUF;	}	size = params->GetRTCPSendBuffer();	if (setsockopt(rtcpsock,SOL_SOCKET,SO_SNDBUF,(const char *)&size,sizeof(int)) != 0)	{		RTPCLOSE(rtpsock);		RTPCLOSE(rtcpsock);		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_CANTSETRTCPTRANSMITBUF;	}		// bind sockets	bindIP = params->GetBindIP();	mcastifidx = params->GetMulticastInterfaceIndex();		memset(&addr,0,sizeof(struct sockaddr_in6));	addr.sin6_family = AF_INET6;	addr.sin6_port = htons(params->GetPortbase());	addr.sin6_addr = bindIP;	if (bind(rtpsock,(struct sockaddr *)&addr,sizeof(struct sockaddr_in6)) != 0)	{		RTPCLOSE(rtpsock);		RTPCLOSE(rtcpsock);		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_CANTBINDRTPSOCKET;	}	memset(&addr,0,sizeof(struct sockaddr_in6));	addr.sin6_family = AF_INET6;	addr.sin6_port = htons(params->GetPortbase()+1);	addr.sin6_addr = bindIP;	if (bind(rtcpsock,(struct sockaddr *)&addr,sizeof(struct sockaddr_in6)) != 0)	{		RTPCLOSE(rtpsock);		RTPCLOSE(rtcpsock);		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_CANTBINDRTCPSOCKET;	}	// Try to obtain local IP addresses	localIPs = params->GetLocalIPList();	if (localIPs.empty()) // User did not provide list of local IP addresses, calculate them	{		int status;				if ((status = CreateLocalIPList()) < 0)		{			RTPCLOSE(rtpsock);			RTPCLOSE(rtcpsock);			MAINMUTEX_UNLOCK			return status;		}#ifdef RTPDEBUG		std::cout << "Found these local IP addresses:" << std::endl;				std::list<in6_addr>::const_iterator it;		for (it = localIPs.begin() ; it != localIPs.end() ; it++)		{			RTPIPv6Address a(*it);			std::cout << a.GetAddressString() << std::endl;		}#endif // RTPDEBUG	}#ifdef RTP_SUPPORT_IPV6MULTICAST	if (SetMulticastTTL(params->GetMulticastTTL()))		supportsmulticasting = true;	else		supportsmulticasting = false;#else // no multicast support enabled	supportsmulticasting = false;#endif // RTP_SUPPORT_IPV6MULTICAST	if ((status = CreateAbortDescriptors()) < 0)	{		RTPCLOSE(rtpsock);		RTPCLOSE(rtcpsock);		MAINMUTEX_UNLOCK		return status;	}		if (maximumpacketsize > RTPUDPV6TRANS_MAXPACKSIZE)	{		RTPCLOSE(rtpsock);		RTPCLOSE(rtcpsock);		DestroyAbortDescriptors();		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_SPECIFIEDSIZETOOBIG;	}		maxpacksize = maximumpacketsize;	portbase = params->GetPortbase();	multicastTTL = params->GetMulticastTTL();	receivemode = RTPTransmitter::AcceptAll;	localhostname = 0;	localhostnamelength = 0;	waitingfordata = false;	created = true;	MAINMUTEX_UNLOCK	return 0;}void RTPUDPv6Transmitter::Destroy(){	if (!init)		return;	MAINMUTEX_LOCK	if (!created)	{		MAINMUTEX_UNLOCK;		return;	}	if (localhostname)	{		RTPDeleteByteArray(localhostname,GetMemoryManager());		localhostname = 0;		localhostnamelength = 0;	}		RTPCLOSE(rtpsock);	RTPCLOSE(rtcpsock);	destinations.Clear();#ifdef RTP_SUPPORT_IPV6MULTICAST	multicastgroups.Clear();#endif // RTP_SUPPORT_IPV6MULTICAST	FlushPackets();	ClearAcceptIgnoreInfo();	localIPs.clear();	created = false;		if (waitingfordata)	{		AbortWaitInternal();		DestroyAbortDescriptors();		MAINMUTEX_UNLOCK		WAITMUTEX_LOCK // to make sure that the WaitForIncomingData function ended		WAITMUTEX_UNLOCK	}	else		DestroyAbortDescriptors();	MAINMUTEX_UNLOCK}RTPTransmissionInfo *RTPUDPv6Transmitter::GetTransmissionInfo(){	if (!init)		return 0;	MAINMUTEX_LOCK	RTPTransmissionInfo *tinf = RTPNew(GetMemoryManager(),RTPMEM_TYPE_CLASS_RTPTRANSMISSIONINFO) RTPUDPv6TransmissionInfo(localIPs,rtpsock,rtcpsock);	MAINMUTEX_UNLOCK	return tinf;}int RTPUDPv6Transmitter::GetLocalHostName(uint8_t *buffer,size_t *bufferlength){	if (!init)		return ERR_RTP_UDPV6TRANS_NOTINIT;	MAINMUTEX_LOCK	if (!created)	{		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_NOTCREATED;	}	if (localhostname == 0)	{		if (localIPs.empty())		{			MAINMUTEX_UNLOCK			return ERR_RTP_UDPV6TRANS_NOLOCALIPS;		}				std::list<in6_addr>::const_iterator it;		std::list<std::string> hostnames;			for (it = localIPs.begin() ; it != localIPs.end() ; it++)		{			bool founddouble = false;			bool foundentry = true;			while (!founddouble && foundentry)			{				struct hostent *he;				in6_addr ip = (*it);								he = gethostbyaddr((char *)&ip,sizeof(in6_addr),AF_INET6);				if (he != 0)				{					std::string hname = std::string(he->h_name);					std::list<std::string>::const_iterator it;					for (it = hostnames.begin() ; !founddouble && it != hostnames.end() ; it++)						if ((*it) == hname)							founddouble = true;					if (!founddouble)						hostnames.push_back(hname);					int i = 0;					while (!founddouble && he->h_aliases[i] != 0)					{						std::string hname = std::string(he->h_aliases[i]);												for (it = hostnames.begin() ; !founddouble && it != hostnames.end() ; it++)							if ((*it) == hname)								founddouble = true;						if (!founddouble)						{							hostnames.push_back(hname);							i++;						}					}				}				else					foundentry = false;			}		}			bool found  = false;				if (!hostnames.empty())	// try to select the most appropriate hostname		{			std::list<std::string>::const_iterator it;						hostnames.sort();			for (it = hostnames.begin() ; !found && it != hostnames.end() ; it++)			{				if ((*it).find('.') != std::string::npos)				{					found = true;					localhostnamelength = (*it).length();					localhostname = RTPNew(GetMemoryManager(),RTPMEM_TYPE_OTHER) uint8_t [localhostnamelength+1];					if (localhostname == 0)					{						MAINMUTEX_UNLOCK						return ERR_RTP_OUTOFMEM;					}					memcpy(localhostname,(*it).c_str(),localhostnamelength);					localhostname[localhostnamelength] = 0;				}			}		}			if (!found) // use an IP address		{			in6_addr ip;			int len;			char str[48];			uint16_t ip16[8];			int i,j;							it = localIPs.begin();			ip = (*it);						for (i = 0,j = 0 ; j < 8 ; j++,i += 2)			{				ip16[j] = (((uint16_t)ip.s6_addr[i])<<8);				ip16[j] |= ((uint16_t)ip.s6_addr[i+1]);			}									RTP_SNPRINTF(str,48,"%04X:%04X:%04X:%04X:%04X:%04X:%04X:%04X",(int)ip16[0],(int)ip16[1],(int)ip16[2],(int)ip16[3],(int)ip16[4],(int)ip16[5],(int)ip16[6],(int)ip16[7]);			len = strlen(str);				localhostnamelength = len;			localhostname = RTPNew(GetMemoryManager(),RTPMEM_TYPE_OTHER) uint8_t [localhostnamelength+1];			if (localhostname == 0)			{				MAINMUTEX_UNLOCK				return ERR_RTP_OUTOFMEM;			}			memcpy(localhostname,str,localhostnamelength);			localhostname[localhostnamelength] = 0;		}	}		if ((*bufferlength) < localhostnamelength)	{		*bufferlength = localhostnamelength; // tell the application the required size of the buffer		MAINMUTEX_UNLOCK		return ERR_RTP_TRANS_BUFFERLENGTHTOOSMALL;	}	memcpy(buffer,localhostname,localhostnamelength);	*bufferlength = localhostnamelength;		MAINMUTEX_UNLOCK	return 0;}bool RTPUDPv6Transmitter::ComesFromThisTransmitter(const RTPAddress *addr){	if (!init)		return false;	if (addr == 0)		return false;		MAINMUTEX_LOCK		bool v;			if (created && addr->GetAddressType() == RTPAddress::IPv6Address)	{			const RTPIPv6Address *addr2 = (const RTPIPv6Address *)addr;		bool found = false;		std::list<in6_addr>::const_iterator it;			it = localIPs.begin();		while (!found && it != localIPs.end())		{			in6_addr itip = *it;			in6_addr addrip = addr2->GetIP();			if (memcmp(&addrip,&itip,sizeof(in6_addr)) == 0)				found = true;			else				++it;		}			if (!found)			v = false;		else		{			if (addr2->GetPort() == portbase) // check for RTP port				v = true;			else if (addr2->GetPort() == (portbase+1)) // check for RTCP port				v = true;			else 				v = false;		}	}	else		v = false;	MAINMUTEX_UNLOCK	return v;}int RTPUDPv6Transmitter::Poll(){	if (!init)		return ERR_RTP_UDPV6TRANS_NOTINIT;	int status;		MAINMUTEX_LOCK	if (!created)	{		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_NOTCREATED;	}	status = PollSocket(true); // poll RTP socket	if (status >= 0)		status = PollSocket(false); // poll RTCP socket	MAINMUTEX_UNLOCK	return status;}int RTPUDPv6Transmitter::WaitForIncomingData(const RTPTime &delay,bool *dataavailable){	if (!init)		return ERR_RTP_UDPV6TRANS_NOTINIT;		MAINMUTEX_LOCK		fd_set fdset;	struct timeval tv;		if (!created)	{		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_NOTCREATED;	}	if (waitingfordata)	{		MAINMUTEX_UNLOCK		return ERR_RTP_UDPV6TRANS_ALREADYWAITING;	}		FD_ZERO(&fdset);	FD_SET(rtpsock,&fdset);	FD_SET(rtcpsock,&fdset);	FD_SET(abortdesc[0],&fdset);	tv.tv_sec = delay.GetSeconds();