src/utils/os_net.c

/*
 *			GPAC - Multimedia Framework C SDK
 *
 *			Authors: Jean Le Feuvre
 *			Copyright (c) Telecom ParisTech 2000-2026
 *					All rights reserved
 *
 *  This file is part of GPAC / common tools sub-project
 *
 *  GPAC is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  GPAC is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

#include <gpac/network.h>

#ifndef GPAC_DISABLE_NETWORK

#include <gpac/utf.h>

#if defined(WIN32) || defined(_WIN32_WCE)
#define _WINSOCK_DEPRECATED_NO_WARNINGS

#ifdef _WIN32_WCE
#include <winsock.h>

#if !defined(__GNUC__)
#pragma comment(lib, "winsock")
#endif
#else

#include <sys/timeb.h>
#include <winsock2.h>
#include <ws2tcpip.h>

#if !defined(__GNUC__)
#pragma comment(lib, "ws2_32")
#pragma comment(lib, "IPHLPAPI.lib")
#define GPAC_WIN_HAS_ADAPTER_INFO
#endif

#if !defined(POLLIN)
#ifdef GPAC_HAS_POLL
#undef GPAC_HAS_POLL
#endif
#endif

#ifdef GPAC_HAS_POLL
#define GF_POLLFD	WSAPOLLFD
#define poll WSAPoll
#endif

#endif

#include <windows.h>

#if defined(IPV6_MULTICAST_IF)
#define GPAC_HAS_IPV6 1
#else
#undef GPAC_HAS_IPV6
#endif

 /*
 #if !defined(__GNUC__)
#if defined(GPAC_HAS_IPV6)
#pragma message("Using WinSock IPV6")
#else
#pragma message("Using WinSock IPV4")
#endif

#endif
*/

#include <errno.h>

#ifndef EISCONN
/*common win32 redefs*/
#undef EAGAIN
#define EAGAIN				WSAEWOULDBLOCK
#define EISCONN				WSAEISCONN
#define ENOTCONN			WSAENOTCONN
#define ECONNRESET			WSAECONNRESET
#define EINPROGRESS			WSAEINPROGRESS
#define EALREADY			WSAEALREADY
#define EMSGSIZE			WSAEMSGSIZE
#define ECONNABORTED		WSAECONNABORTED
#define ENETDOWN			WSAENETDOWN
#undef EINTR
#define EINTR				WSAEINTR
#undef EBADF
#define EBADF				WSAEBADF
#endif


#define LASTSOCKERROR WSAGetLastError()

/*the number of sockets used. This because the WinSock lib needs init*/
static int wsa_init = 0;

/*end-win32*/
#define SOCKET_INVALID(_s) (_s==INVALID_SOCKET)

#else
/*non-win32*/
#include <unistd.h>
#include <fcntl.h>
#include <netdb.h>

#ifndef __BEOS__
#include <errno.h>
#endif

#ifndef __DARWIN__
#include <sys/time.h>
#endif

#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>

#if defined(__FreeBSD__)
#include <sys/stat.h>
#endif

/*not defined on solaris*/
#if !defined(INADDR_NONE)
# if (defined(sun) && defined(__SVR4))
#  define INADDR_NONE -1
# else
#  define INADDR_NONE ((unsigned long)-1)
# endif
#endif


#define SOCKET_INVALID(_s) (_s<0)
#define INVALID_SOCKET	-1

#define SOCKET_ERROR -1
#define LASTSOCKERROR errno

typedef s32 SOCKET;
#define closesocket(v) close(v)

#ifdef GPAC_HAS_POLL
#include <poll.h>

#define GF_POLLFD	struct pollfd

#endif

#endif /*WIN32||_WIN32_WCE*/

#ifdef GPAC_BUILD_FOR_WINXP

/* Added by M. Lackner to ensure Windows XP & XP x64 compatibility */
/* Adding PlibC's inet_ntop() function in a very slightly modified
and renamed variant for IPv6 address conversion support on Win XP's,
which is called by gf_sk_get_remote_address() further below.
The renamed function is called inet_ntop_xp().
Original source code taken from here:
https://sourceforge.net/projects/plibc/

This inet_ntop() implementation is (C) 1996-2001 Internet Software
Consortium and is licensed under the ISC license.
License text: https://opensource.org/licenses/ISC */
#define NS_INT16SZ   2
#define NS_IN6ADDRSZ  16

/*
* WARNING: Don't even consider trying to compile this on a system where
* sizeof(int) < 4.  sizeof(int) > 4 is fine; all the world's not a VAX.
*/

static const char *inet_ntop4(const unsigned char *src, char *dst, size_t size);

#ifdef AF_INET6
static const char *inet_ntop6(const unsigned char *src, char *dst, size_t size);
#endif

/* char *
* isc_net_ntop(af, src, dst, size)
*  convert a network format address to presentation format.
* return:
*  pointer to presentation format address (`dst'), or NULL (see errno).
* author:
*  Paul Vixie, 1996.
*/
const char * inet_ntop_xp(int af, const void *src, char *dst, size_t size)
{
	switch (af) {
	case AF_INET:
		return (inet_ntop4(src, dst, size));
#ifdef AF_INET6
	case AF_INET6:
		return (inet_ntop6(src, dst, size));
#endif
	default:
		errno = EAFNOSUPPORT;
		return (NULL);
	}
	/* NOTREACHED */
}

/* const char *
* inet_ntop4(src, dst, size)
*  format an IPv4 address
* return:
*  `dst' (as a const)
* notes:
*  (1) uses no statics
*  (2) takes a unsigned char* not an in_addr as input
* author:
*  Paul Vixie, 1996.
*/
static const char * inet_ntop4(const unsigned char *src, char *dst, size_t size)
{
	static const char *fmt = "%u.%u.%u.%u";
	char tmp[sizeof "255.255.255.255"];
	size_t len;

	len = snprintf(tmp, sizeof tmp, fmt, src[0], src[1], src[2], src[3]);
	if (len >= size) {
		errno = ENOSPC;
		return (NULL);
	}
	memcpy(dst, tmp, len + 1);

	return (dst);
}

/* const char *
* isc_inet_ntop6(src, dst, size)
*  convert IPv6 binary address into presentation (printable) format
* author:
*  Paul Vixie, 1996.
*/
#ifdef AF_INET6
static const char * inet_ntop6(const unsigned char *src, char *dst, size_t size)
{
	/*
	* Note that int32_t and int16_t need only be "at least" large enough
	* to contain a value of the specified size.  On some systems, like
	* Crays, there is no such thing as an integer variable with 16 bits.
	* Keep this in mind if you think this function should have been coded
	* to use pointer overlays.  All the world's not a VAX.
	*/
	char tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"], *tp;
	struct { int base, len; } best, cur;
	unsigned int words[NS_IN6ADDRSZ / NS_INT16SZ];
	int i, inc;

	/*
	* Preprocess:
	*  Copy the input (bytewise) array into a wordwise array.
	*  Find the longest run of 0x00's in src[] for :: shorthanding.
	*/
	memset(words, '\0', sizeof words);
	for (i = 0; i < NS_IN6ADDRSZ; i++)
		words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
	best.base = -1;
	best.len = 0;
	cur.base = -1;
	cur.len = 0;
	for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
		if (words[i] == 0) {
			if (cur.base == -1)
				cur.base = i, cur.len = 1;
			else
				cur.len++;
		}
		else {
			if (cur.base != -1) {
				if (best.base == -1 || cur.len > best.len)
					best = cur;
				cur.base = -1;
			}
		}
	}
	if (cur.base != -1) {
		if (best.base == -1 || cur.len > best.len)
			best = cur;
	}
	if (best.base != -1 && best.len < 2)
		best.base = -1;

	/*
	* Format the result.
	*/
	tp = tmp;
	for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
		/* Are we inside the best run of 0x00's? */
		if (best.base != -1 && i >= best.base && i < (best.base + best.len)) {
			if (i == best.base)
				*tp++ = ':';
			continue;
		}
		/* Are we following an initial run of 0x00s or any real hex? */
		if (i != 0)
			*tp++ = ':';
		/* Is this address an encapsulated IPv4? */
		if (i == 6 && best.base == 0 && (best.len == 6 || (best.len == 5 && words[5] == 0xffff))) {
			if (!inet_ntop4(src + 12, tp, sizeof tmp - (tp - tmp)))
				return (NULL);
			tp += strlen(tp);
			break;
		}
		inc = snprintf(tp, 5, "%x", words[i]);
		tp += inc;
	}
	/* Was it a trailing run of 0x00's? */
	if (best.base != -1 && (best.base + best.len) == (NS_IN6ADDRSZ / NS_INT16SZ))
		*tp++ = ':';
	*tp++ = '\0';

	/*
	* Check for overflow, copy, and we're done.
	*/
	if ((size_t)(tp - tmp) > size) {
		errno = ENOSPC;
		return (NULL);
	}
	memcpy(dst, tmp, tp - tmp);
	return (dst);
}
#endif /* AF_INET6 */
/* End of inet_ntop() reimplementation */


#endif //winxp

#ifdef GPAC_BUILD_FOR_WINXP
#define my_inet_ntop inet_ntop_xp
#else
#define my_inet_ntop inet_ntop
#endif


#ifdef GPAC_HAS_IPV6
# ifndef IPV6_ADD_MEMBERSHIP
#  define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
# endif
# ifndef IPV6_DROP_MEMBERSHIP
#  define IPV6_DROP_MEMBERSHIP   IPV6_LEAVE_GROUP
# endif
#endif


#ifdef __SYMBIAN32__
#define SSO_CAST
#else
#define SSO_CAST (const char *)
#endif


#ifdef GPAC_HAS_IPV6
static u32 ipv6_check_state = 0;
#endif

#ifdef GPAC_HAS_SOCK_UN
#include <sys/un.h>
#endif

/*internal flags*/
enum
{
	GF_SOCK_IS_TCP = 1<<9,
	GF_SOCK_IS_IPV6 = 1<<10,
	GF_SOCK_NON_BLOCKING = 1<<11,
	GF_SOCK_IS_MULTICAST = 1<<12,
	GF_SOCK_IS_LISTENING = 1<<13,
	/*socket is bound to a specific dest (server) or source (client) */
	GF_SOCK_HAS_PEER = 1<<14,
	GF_SOCK_IS_UN = 1<<15,
	GF_SOCK_HAS_CONNECT = 1<<16
};

#ifndef GPAC_DISABLE_NETCAP

typedef struct __netcap_filter GF_NetcapFilter;
static GF_NetcapFilter *gf_net_filter_get(const char *id);

typedef struct
{
	//local host info
	u32 host_addr_v4;
	bin128 host_addr_v6;
	u32 host_port;
	//remote peer info
	u32 peer_addr_v4;
	bin128 peer_addr_v6;
	u32 peer_port;

	u32 pck_idx_r, pck_idx_w, next_pck_range, next_rand;
	u32 patch_offset, patch_val;
	GF_NetcapFilter *nf;
} NetCapInfo;
#endif


struct __tag_socket
{
	u32 flags;
	SOCKET socket;
	/*destination address for sendto/recvfrom*/
#ifdef GPAC_HAS_IPV6
	struct sockaddr_storage dest_addr;
#else
	struct sockaddr_in dest_addr;
#endif
	u32 dest_addr_len;

	u32 usec_wait;
#ifdef GPAC_HAS_POLL
	u32 poll_idx;
#endif

#ifndef GPAC_DISABLE_NETCAP
	NetCapInfo *cap_info;
#endif
};



GF_EXPORT
u32 gf_net_has_ipv6()
{
#ifdef GPAC_HAS_IPV6
	if (!ipv6_check_state) {
		SOCKET s;
#ifdef WIN32
		if (!wsa_init) {
			WSADATA Data;
			if (WSAStartup(0x0202, &Data)!=0) {
				ipv6_check_state = 1;
				return 0;
			}
		}
#endif
		s = socket(PF_INET6, SOCK_STREAM, 0);
		if (!s) ipv6_check_state = 1;
		else {
			ipv6_check_state = 2;
			closesocket(s);
		}
#ifdef WIN32
		if (!wsa_init) WSACleanup();
#endif
	}
	return (ipv6_check_state==2);
#else
	return 0;
#endif
}

GF_EXPORT
Bool gf_net_is_ipv6(const char *address)
{
	u32 i, nb_seps=0, nb_dseps=0, nb_dig=0, count = address ? (u32) strlen(address) : 0;
	for (i=0;i<count; i++) {
		if (address[i]==':') {
			nb_seps++;
			nb_dig=0;
			if ((i+1<count) && (address[i+1]==':')) {
				nb_dseps++;
				i++;
			}
		}
		else if (strchr("0123456789ABCDEFabcdef",address[i])==NULL) {
			return GF_FALSE;
		} else {
			nb_dig++;
			if (nb_dig>4) return GF_FALSE;
		}
	}
	if (nb_seps>7) return GF_FALSE;
	if (nb_seps==7) return GF_TRUE;
	if (nb_dseps!=1) return GF_FALSE;
	return GF_TRUE;
}

#if defined(GPAC_WIN_HAS_ADAPTER_INFO)
#include <iphlpapi.h>
#endif

#if defined(GPAC_HAS_IFADDRS)
#include <ifaddrs.h>
#include <net/if.h>
#endif


#ifdef GPAC_HAS_IPV6
#define MAX_PEER_NAME_LEN 1024
static struct addrinfo *gf_sk_get_ipv6_addr(const char *PeerName, u16 PortNumber, int family, int flags, int sock_type)
{
	struct	addrinfo *res=NULL;
	struct	addrinfo hints;
	char node[MAX_PEER_NAME_LEN], portstring[20];
	char *service, *dest;
	service = dest = NULL;
#ifdef WIN32
	if (!wsa_init) {
		WSADATA Data;
		if (WSAStartup(0x0202, &Data)!=0) return NULL;
		wsa_init = 1;
	}
#endif

	service = dest = NULL;
	memset(&hints, 0, sizeof(hints));
	hints.ai_socktype = sock_type;
	hints.ai_family = family;
	hints.ai_flags = flags;

	if (PortNumber) {
		sprintf (portstring, "%d", PortNumber);
		service = (char *)portstring;
	}
	if (PeerName) {
		gf_strlcpy(node, PeerName, MAX_PEER_NAME_LEN);
		if (node[0]=='[') {
			node[strlen(node)-1] = 0;
			memmove(node, &node[1], MAX_PEER_NAME_LEN-1);
		}
		node[MAX_PEER_NAME_LEN - 1] = 0;
		dest = (char *) node;
	}
	if (getaddrinfo((const char *)dest, (const char *)service, &hints, &res) != 0) return NULL;
	return res;
}

static struct addrinfo *gf_sk_get_ifce_ipv6_addr(const char *ifce_name_or_ip, u16 PortNumber, int family, int flags, int sock_type)
{
	char szIP[100];
	Bool force_ipv6 = GF_FALSE;
	if (!ifce_name_or_ip || !ifce_name_or_ip[0] || gf_net_is_ipv6(ifce_name_or_ip) || strchr(ifce_name_or_ip, '.'))
		return gf_sk_get_ipv6_addr(ifce_name_or_ip, PortNumber, family, flags, sock_type);
	if (ifce_name_or_ip[0]=='+') {
		force_ipv6 = GF_TRUE;
		ifce_name_or_ip+=1;
		if (!ifce_name_or_ip[0]) {
			return gf_sk_get_ipv6_addr(ifce_name_or_ip, PortNumber, AF_INET6, flags, sock_type);
		}
	}
	if (family==AF_INET6) force_ipv6 = GF_TRUE;

	szIP[0] = 0;

#if defined(GPAC_WIN_HAS_ADAPTER_INFO)
	IP_ADAPTER_ADDRESSES *AdapterInfo = malloc(sizeof(IP_ADAPTER_ADDRESSES));
	ULONG ulOutBufLen = sizeof(AdapterInfo);
	if (AdapterInfo && (GetAdaptersAddresses(AF_UNSPEC, 0, NULL, AdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW)) {
		free(AdapterInfo);
		AdapterInfo = malloc(sizeof(IP_ADAPTER_ADDRESSES)*ulOutBufLen);
	}
	if (AdapterInfo)
		GetAdaptersAddresses(AF_UNSPEC, 0, NULL, AdapterInfo, &ulOutBufLen);
	IP_ADAPTER_ADDRESSES *ifa = AdapterInfo;
	while (ifa) {
		Bool match = GF_FALSE;
		if (!strcmp(ifa->AdapterName, ifce_name_or_ip)) match = GF_TRUE;
		char *name = gf_wcs_to_utf8(ifa->FriendlyName);
		if (name) {
			if (!strcmp(name, ifce_name_or_ip)) match = GF_TRUE;
			gf_free(name);
		}
		if (!match) {
			ifa = ifa->Next;
			szIP[0] = 0;
			continue;
		}
		IP_ADAPTER_UNICAST_ADDRESS_LH *ipadd = ifa->FirstUnicastAddress;
		while (ipadd) {
			if (!ipadd->Address.lpSockaddr) {
				ipadd = ipadd->Next;
				continue;
			}
			if (ipadd->Address.lpSockaddr->sa_family==AF_INET) {
				my_inet_ntop(ipadd->Address.lpSockaddr->sa_family, ipadd->Address.lpSockaddr, szIP, 100);
				free(AdapterInfo);
				return gf_sk_get_ipv6_addr(szIP, PortNumber, family, flags, sock_type);
			}
			if (ipadd->Address.lpSockaddr->sa_family == AF_INET6) {
				my_inet_ntop(ipadd->Address.lpSockaddr->sa_family, ipadd->Address.lpSockaddr, szIP, 100);
				if (force_ipv6) {
					free(AdapterInfo);
					return gf_sk_get_ipv6_addr(szIP, PortNumber, family, flags, sock_type);
				}
			}
			ipadd = ipadd->Next;
		}
		ifa = ifa->Next;
	}
	if (AdapterInfo)
		free(AdapterInfo);
#endif

#if defined(GPAC_HAS_IFADDRS)
	struct ifaddrs *ifap = NULL, *ifa;
	getifaddrs(&ifap);
	ifa = ifap;
	while (ifa) {
		if (!ifa->ifa_addr || strcmp(ifa->ifa_name, ifce_name_or_ip)) {
			ifa = ifa->ifa_next;
			continue;
		}
		if (ifa->ifa_addr->sa_family==AF_INET) {
			memset(szIP, 0, 100);
			inet_ntop(AF_INET, &( ((struct sockaddr_in *)ifa->ifa_addr)->sin_addr), szIP, 100);
			freeifaddrs(ifap);
			return gf_sk_get_ipv6_addr(szIP, PortNumber, family, flags, sock_type);
		}
		if (ifa->ifa_addr->sa_family==AF_INET6) {
			memset(szIP, 0, 100);
			inet_ntop(AF_INET6, &( ((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr), szIP, 100);
			if (force_ipv6) {
				freeifaddrs(ifap);
				return gf_sk_get_ipv6_addr(szIP, PortNumber, family, flags, sock_type);
			}
		}
		ifa = ifa->ifa_next;
	}
	freeifaddrs(ifap);
#endif

	if (szIP[0]) {
		return gf_sk_get_ipv6_addr(szIP, PortNumber, family, flags, sock_type);
	}
	return NULL;
}
#endif


GF_EXPORT
GF_Err gf_sk_get_host_name(char *buffer)
{
	s32 ret = gethostname(buffer, GF_MAX_IP_NAME_LEN);
	return (ret == SOCKET_ERROR) ? GF_IP_ADDRESS_NOT_FOUND : GF_OK;
}

GF_EXPORT
GF_Err gf_sk_get_local_ip(GF_Socket *sock, char buffer[GF_MAX_IP_NAME_LEN])
{
#ifdef GPAC_HAS_IPV6
	char clienthost[NI_MAXHOST];
	if (sock->flags & GF_SOCK_HAS_PEER) {
		if (getnameinfo((struct sockaddr *)&sock->dest_addr, sock->dest_addr_len, clienthost, sizeof(clienthost), NULL, 0, NI_NUMERICHOST))
			return GF_IP_NETWORK_FAILURE;
	} else {
		struct sockaddr_storage clientaddr;
		socklen_t addrlen = sizeof(clientaddr);
		if (sock->flags & GF_SOCK_IS_MULTICAST)
			return GF_BAD_PARAM;
		if (getsockname(sock->socket, (struct sockaddr *)&clientaddr, &addrlen)) return GF_IP_NETWORK_FAILURE;

		if (getnameinfo((struct sockaddr *)&clientaddr, addrlen, clienthost, sizeof(clienthost), NULL, 0, NI_NUMERICHOST))
			return GF_IP_NETWORK_FAILURE;
	}
	gf_strlcpy(buffer, clienthost, GF_MAX_IP_NAME_LEN);
#else
	char *ip;
	if (sock->flags & GF_SOCK_HAS_PEER) {
		ip = inet_ntoa(sock->dest_addr.sin_addr);
	} else {
		struct sockaddr_in name;
		u32 len = sizeof(struct sockaddr_in);
		if (getsockname(sock->socket, (struct sockaddr*) &name, &len)) return GF_IP_NETWORK_FAILURE;
		ip = inet_ntoa(name.sin_addr);
	}
	if (!ip) return GF_IP_NETWORK_FAILURE;
	gf_strlcpy(buffer, ip, GF_MAX_IP_NAME_LEN);
#endif
	return GF_OK;
}

#ifndef GPAC_DISABLE_NETCAP

#include <gpac/bitstream.h>
#include <gpac/list.h>

enum
{
	NETCAP_IS_MCAST = 1,
	NETCAP_IS_TCP = 1<<1,
	NETCAP_HAS_PEER = 1<<2,
	NETCAP_IS_IPV6 = 1<<3,
	NETCAP_HAS_EXT = 1<<6,
	NETCAP_DROP = 1<<7,
};

//capture mode only, target bitstream
u16 first_tcp_port=30000;

#define GF_GPC_MAGIC	GF_4CC('G','P','C', 0)

//playback vars


enum {
	NETCAP_NONE = 0,
	//read/write
	NETCAP_GPAC = 1,
	//read only
	NETCAP_PCAP = 2,
	NETCAP_PCAPNG = 3,
};

typedef struct
{
	u32 send_recv;
	u32 pck_start, pck_end;
	Bool pck_start_is_loop, pck_end_is_loop;
	s32 rand_every;
	u32 nb_pck;
	u32 port;
	s32 patch_offset, patch_val;
	s32 delay;
} NetFilterRule;

static GF_List *netcap_filters=NULL;
#ifdef GPAC_HAS_FD
GF_BitStream *gf_bs_from_fd(int fd, u32 mode);
#endif

struct __netcap_filter
{
	char *id;
	char *src;
	char *dst;
	s32 loops;
	Bool rt;
	GF_List *rules;
	u32 nb_rules;
	u32 nb_reloads;


	//target bitstream for read/write
	GF_BitStream *cap_bs;
	//playback mode only, set of created sockets, used to discard packets on non-bound sockets
	GF_List *read_socks;
	//playback mode only, set to socket corresponding to pending packet
	GF_Socket *read_sock_selected;
	//playback/capture, FILE pointer
	FILE *file;
#ifdef GPAC_HAS_FD
	//playback/capture, fd pointer
	int fd;
#endif

	//playback only, clock init value for RT regulation
	u64 init_time;
	Bool is_eos;

	u64 pck_start_offset;

	//loaded packet size in bytes - this is the payload of the UDP/TCP packet - if 0, packet fetch failed
	s32 pck_len;
	//gpac format only, flags of loaded packet
	u8 pck_flags;
	//time of loaded packet, relative to sys_clock_high_res
	u64 pck_time;
	//destination port of loaded packet - if 0, new packet needs to be loaded
	u16 dst_port;
	//ipv4 dest address or mcast address of loaded packet
	u32 dst_v4;
	//ipv6 dest address or mcast address of loaded packet
	bin128 dst_v6;
	//source port of loaded packet
	u16 src_port;
	//ipv4 source address of loaded packet
	u32 src_v4;
	//ipv6 source address of loaded packet
	bin128 src_v6;

	//source file type
	u32 cap_mode;
	//for pcap files, indicate if little endian
	Bool pcap_le;
	//for pcap files, indicate nano seconds are used
	Bool pcap_nano;
	//number of interfaces currently defined - for pcap, always, 1
	u32 pcap_num_interfaces;
	//all defined interfaces
	u32 link_types[20];
	//trailing bytes in pcapng packet record
	u32 pcapng_trail;
	//trailing bytes after packet in pcap (NOT in pcapng)
	u32 pcap_trail;

	u32 pck_idx_r;
	u32 pck_idx_w;
	u32 next_pck_range;
	u32 next_rand;

	u32 reorder_max_pck, reorder_nb_pck, delay_nb_pck;
	u64 reorder_seek_pos, reorder_resume_pos;
};

static GF_NetcapFilter *gf_net_filter_get(const char *id)
{
	u32 i, count;
	count = gf_list_count(netcap_filters);
	for (i=0; i<count; i++) {
		GF_NetcapFilter *f = gf_list_get(netcap_filters, i);
		if (f->id && id && !strcmp(f->id, id))
			return f;

		if (!f->id && !id)
			return f;
	}
	return NULL;
}
//end playback vars



void gf_net_close_capture()
{
	while (gf_list_count(netcap_filters)) {
		GF_NetcapFilter *nf = gf_list_pop_back(netcap_filters);

		if (nf->cap_bs) gf_bs_del(nf->cap_bs);

#ifdef GPAC_HAS_FD
		if (nf->fd>=0) close(nf->fd);
#endif
		if (nf->file) gf_fclose(nf->file);
		if (nf->read_socks) gf_list_del(nf->read_socks);

		if (nf->rules) {
			while (1) {
				NetFilterRule *r = gf_list_pop_back(nf->rules);
				if (!r) break;
				gf_free(r);
			}
			gf_list_del(nf->rules);
		}
		if (nf->id) gf_free(nf->id);
		if (nf->src) gf_free(nf->src);
		if (nf->dst) gf_free(nf->dst);
		gf_free(nf);
	}
	gf_list_del(netcap_filters);
	netcap_filters = NULL;
}

static GF_Err gf_netcap_record(GF_NetcapFilter *nf)
{
#ifdef GPAC_HAS_FD
	if (!gf_opts_get_bool("core", "no-fd")) {
		//make sure output dir exists
		gf_fopen(nf->dst, "mkdir");
		nf->fd = gf_fd_open(nf->dst, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH );
		if (nf->fd>=0) nf->cap_bs = gf_bs_from_fd(nf->fd, GF_BITSTREAM_WRITE);
	} else
#endif
	{
		nf->file = gf_fopen_ex(nf->dst, NULL, "w+b", GF_FALSE);
		if (nf->file) nf->cap_bs = gf_bs_from_file(nf->file, GF_BITSTREAM_WRITE);
	}
	if (!nf->cap_bs) {
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[NetCap] Failed to setup net capture\n"));
		return GF_IO_ERR;
	}
	char *ext = gf_file_ext_start(nf->dst);
	if (ext && !strcmp(ext, ".pcap")) {
		nf->cap_mode = NETCAP_PCAP;
		gf_bs_write_u32(nf->cap_bs, 0xA1B2C3D4);
		gf_bs_write_u16(nf->cap_bs, 2);
		gf_bs_write_u16(nf->cap_bs, 4);
		gf_bs_write_u32(nf->cap_bs, 0);
		gf_bs_write_u32(nf->cap_bs, 0);
		gf_bs_write_u32(nf->cap_bs, 0xFFFF); //snapLen
		gf_bs_write_u16(nf->cap_bs, 0); //FCS+f+reserved
		gf_bs_write_u16(nf->cap_bs, 0); //linktype
	} else if (ext && !strcmp(ext, ".pcapng")) {
		nf->cap_mode = NETCAP_PCAPNG;
		//SHB
		gf_bs_write_u32(nf->cap_bs, 0x0a0d0d0a);
		gf_bs_write_u32(nf->cap_bs, 12+16);
		gf_bs_write_u32(nf->cap_bs, 0x1A2B3C4D);
		gf_bs_write_u16(nf->cap_bs, 1);
		gf_bs_write_u16(nf->cap_bs, 0);
		gf_bs_write_u64(nf->cap_bs, 0);
		gf_bs_write_u32(nf->cap_bs, 12+16);
		//IDB
		gf_bs_write_u32(nf->cap_bs, 1);
		gf_bs_write_u32(nf->cap_bs, 12+8);
		gf_bs_write_u16(nf->cap_bs, 0); //linktype
		gf_bs_write_u16(nf->cap_bs, 0); //reserved
		gf_bs_write_u32(nf->cap_bs, 0); //snapLen
		gf_bs_write_u32(nf->cap_bs, 12+8);
	} else {
		nf->cap_mode = NETCAP_GPAC;
		gf_bs_write_u32(nf->cap_bs, GF_GPC_MAGIC);
		nf->init_time = gf_sys_clock_high_res();
		u32 sec, frac;
		gf_net_get_ntp(&sec, &frac);
		//NTP start time of capture
		gf_bs_write_u32(nf->cap_bs, sec);
		gf_bs_write_u32(nf->cap_bs, frac);
		//header extension size
		gf_bs_write_u32(nf->cap_bs, 0);
	}
	return GF_OK;
}

static void gf_netcap_load_pck_gpac(GF_NetcapFilter *nf)
{
	nf->pck_start_offset = gf_bs_get_position(nf->cap_bs);
	if (gf_bs_available(nf->cap_bs)>4)
		nf->pck_len = gf_bs_read_u32(nf->cap_bs);
	else
		nf->pck_len = 0;

	//we allow size to be equal to our magic for file concat
	//this means pck size= 1196442368 (for v0) so we should be way over captured MTU
	if (nf->pck_len == GF_GPC_MAGIC) {
		/*ntp_sec = */gf_bs_read_u32(nf->cap_bs);
		/*ntp_frac = */gf_bs_read_u32(nf->cap_bs);
		u32 hdr_len = gf_bs_read_u32(nf->cap_bs);
		gf_bs_skip_bytes(nf->cap_bs, hdr_len);
		nf->pck_flags = NETCAP_DROP;
		nf->pck_len = 0;
		nf->dst_port = 1;
		return;
	}

	if (nf->pck_len<1+8+4+2) {
		nf->dst_v4 = 0;
		nf->dst_port = 0;
		nf->pck_len = 0;
		nf->is_eos = GF_TRUE;
		return;
	}
	nf->pck_len -= 1+8+2;
	//read flags
	nf->pck_flags = gf_bs_read_u8(nf->cap_bs);
	nf->pck_time = gf_bs_read_u64(nf->cap_bs);
	//extensions
	if (nf->pck_flags & NETCAP_HAS_EXT) {
		u16 xlen = gf_bs_read_u16(nf->cap_bs);
		gf_bs_skip_bytes(nf->cap_bs, xlen);
		nf->pck_len -= 2 + xlen;
	}

	//init clock on first packet
	if (!nf->init_time) {
		nf->init_time = gf_sys_clock_high_res();
		nf->init_time -= nf->pck_time;
	}
	nf->pck_time += nf->init_time;
	if (nf->pck_flags & NETCAP_IS_IPV6) {
		nf->dst_v4 = 0;
		gf_bs_read_data(nf->cap_bs, nf->dst_v6, 16);
		nf->pck_len -= 16;
		if (nf->pck_flags & NETCAP_HAS_PEER) {
			gf_bs_read_data(nf->cap_bs, nf->src_v6, 16);
			nf->pck_len -= 16;
		}
	} else {
		nf->dst_v4 = gf_bs_read_u32(nf->cap_bs);
		nf->pck_len -= 4;
		if (nf->pck_flags & NETCAP_HAS_PEER) {
			nf->src_v4 = gf_bs_read_u32(nf->cap_bs);
			nf->pck_len -= 4;
		}
	}
	nf->dst_port = gf_bs_read_u16(nf->cap_bs);
	if (nf->pck_flags & NETCAP_HAS_PEER) {
		nf->src_port = gf_bs_read_u16(nf->cap_bs);
		nf->pck_len -= 2;
	} else {
		nf->src_port = 0;
	}

	if (gf_bs_is_overflow(nf->cap_bs)) {
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[NetCap] Corrupted netcap file, aborting\n"));
		nf->pck_len = -1;
	}

	//broken packet
	if (nf->pck_len <0) {
		nf->dst_v4 = 0;
		nf->dst_port = 0;
		nf->pck_len = 0;
		nf->is_eos = GF_TRUE;
	}
}

enum
{
	PCAP_LT_LOOPBACK=0,
	PCAP_LT_ETHERNET=1,
	PCAP_LT_CHAOS=5
};

static GF_Err pcapng_load_shb(GF_NetcapFilter *nf, Bool is_init)
{
	u32 blen = gf_bs_read_u32(nf->cap_bs);
	u32 le_magic = gf_bs_read_u32(nf->cap_bs);
	if (le_magic == GF_4CC(0x1A, 0x2B, 0x3C, 0x4D)) {
	} else if (le_magic == GF_4CC(0x4D, 0x3C, 0x2B, 0x1A)) {
		nf->pcap_le = GF_TRUE;
		blen = ntohl(blen);
	} else {
		if (is_init)
			gf_net_close_capture();
		else
			nf->is_eos = GF_TRUE;
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[NetCap] Corrrupted pacpng file\n"));
		return GF_NON_COMPLIANT_BITSTREAM;
	}
	gf_bs_skip_bytes(nf->cap_bs, blen-12);
	nf->pcap_num_interfaces = 0;
	return GF_OK;
}

static void pcapng_load_idb(GF_NetcapFilter *nf)
{
	if (nf->pcap_num_interfaces>=20) {
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[NetCap] Maximum 20 concurrent interfaces supported in pacpng, skipping packets\n"));
		return;
	}
	u32 blen = nf->pcap_le ? gf_bs_read_u32_le(nf->cap_bs) : gf_bs_read_u32(nf->cap_bs);
	nf->link_types[nf->pcap_num_interfaces] = nf->pcap_le ? gf_bs_read_u16_le(nf->cap_bs) : gf_bs_read_u16(nf->cap_bs);
	gf_bs_skip_bytes(nf->cap_bs, blen-10);

	switch (nf->link_types[nf->pcap_num_interfaces]) {
	case PCAP_LT_LOOPBACK:
	case PCAP_LT_ETHERNET:
	case PCAP_LT_CHAOS:
		break;
	default:
		GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[NetCap] Only ethernet and BSD-loopback pcap files are supported, skipping packets\n"));
		break;
	}
	nf->pcap_num_interfaces++;
}

#define SKIP_PCAP_PCK \
	if (clen<0) {\
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[NetCap] Corrupted PCAP file, aborting\n"));\
		nf->is_eos = GF_TRUE;\
		return;\
	}\
	gf_bs_skip_bytes(nf->cap_bs, clen);\
	clen=0;\
	goto refetch_pcap;


static void gf_netcap_load_pck_pcap(GF_NetcapFilter *nf)
{
	u32 s, frac;
	s32 clen=0, bsize=0;

refetch_pcap:
	nf->dst_port = 0;
	nf->pck_len = 0;
	if (nf->pcapng_trail) {
		gf_bs_skip_bytes(nf->cap_bs, nf->pcapng_trail);
		nf->pcapng_trail = 0;
	} else if (nf->pcap_trail) {
		gf_bs_skip_bytes(nf->cap_bs, nf->pcapng_trail);
		nf->pcap_trail = 0;
	}

	if (gf_bs_available(nf->cap_bs)<16) {
		nf->is_eos = GF_TRUE;
		return;
	}
	nf->pck_start_offset = gf_bs_get_position(nf->cap_bs);

	u32 link_type;
	if (nf->cap_mode==NETCAP_PCAPNG) {

		u32 btype = nf->pcap_le ? gf_bs_read_u32_le(nf->cap_bs) : gf_bs_read_u32(nf->cap_bs);
		if (btype==GF_4CC(0x0A, 0x0D, 0x0D, 0x0A)) {
			GF_Err e = pcapng_load_shb(nf, GF_FALSE);
			//if failure, nf is destroyed by gf_net_close_capture
			if (e) {
				return;
			}
			goto refetch_pcap;
		} else if (btype==0x00000001) {
			pcapng_load_idb(nf);
			goto refetch_pcap;
		}

		bsize = nf->pcap_le ? gf_bs_read_u32_le(nf->cap_bs) : gf_bs_read_u32(nf->cap_bs);
		if (bsize <= 8) {
			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[NetCap] Corrupted PCAP file, aborting\n"));
			nf->is_eos = GF_TRUE;
			return;
		}
		if (btype!=0x00000006) {
			gf_bs_skip_bytes(nf->cap_bs, bsize-8);
			nf->pcapng_trail = 0;
			goto refetch_pcap;
		}
		u32 ifce_idx = nf->pcap_le ? gf_bs_read_u32_le(nf->cap_bs) : gf_bs_read_u32(nf->cap_bs);
		if (ifce_idx<nf->pcap_num_interfaces)
			link_type = nf->link_types[0];
		else
			link_type = 0xFF;
	} else {
		link_type = nf->link_types[0];
	}

	if (nf->pcap_le) {
		s = gf_bs_read_u32_le(nf->cap_bs);
		frac = gf_bs_read_u32_le(nf->cap_bs);
		clen = gf_bs_read_u32_le(nf->cap_bs);
		/*olen = */gf_bs_read_u32_le(nf->cap_bs);
	} else {
		s = gf_bs_read_u32(nf->cap_bs);
		frac = gf_bs_read_u32(nf->cap_bs);
		clen = gf_bs_read_u32(nf->cap_bs);
		/*olen = */gf_bs_read_u32(nf->cap_bs);
	}
	if (clen<0) {
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[NetCap] Corrupted PCAP file, aborting\n"));
		nf->is_eos = GF_TRUE;
		return;
	}

	if (nf->cap_mode==NETCAP_PCAPNG) {
		nf->pcapng_trail = bsize - 28 - clen;
	}

	Bool ip_v6=GF_FALSE;
	if (link_type==0) {
		u32 type = nf->pcap_le ? gf_bs_read_u32_le(nf->cap_bs) : gf_bs_read_u32(nf->cap_bs);
		clen-=4;
		if (type==2) {
		} else if ((type==24) || (type==28) || (type==30)) {
			ip_v6=GF_TRUE;
		} else {
			SKIP_PCAP_PCK
		}
	}
	//Ethernet
	else if (link_type==1) {
		gf_bs_skip_bytes(nf->cap_bs, 12);
		u32 etype = gf_bs_read_u16(nf->cap_bs);
		clen-=14;
		if (etype==0x0800) {
		} else if (etype==0x86DD) {
			ip_v6=GF_TRUE;
		} else {
			SKIP_PCAP_PCK
		}
	}
	//raw IPv4
	else if (link_type==5) {
	}
	//not supported
	else {
		gf_bs_skip_bytes(nf->cap_bs, clen);
		goto refetch_pcap;
	}

	u8 protocol_type=0;
	if (ip_v6) {
		gf_bs_skip_bytes(nf->cap_bs, 4);
		/*pay_len = */gf_bs_read_u16(nf->cap_bs);
		u32 next_hdr = gf_bs_read_u8(nf->cap_bs);
		gf_bs_read_u8(nf->cap_bs);
		gf_bs_read_data(nf->cap_bs, nf->src_v6, 16);
		gf_bs_read_data(nf->cap_bs, nf->dst_v6, 16);
		clen -= 40;
		Bool has_hdr = 1;
		while (has_hdr) {
			u32 hdr_size;
			switch (next_hdr) {
			case 0:
			case 60:
			case 43:
			case 44:
			case 50:
			case 51:
			case 135:
			case 139:
			case 140:
				next_hdr = gf_bs_read_u8(nf->cap_bs);
				hdr_size = gf_bs_read_u8(nf->cap_bs);
				gf_bs_skip_bytes(nf->cap_bs, 2 + 8*hdr_size);
				hdr_size = 8*(hdr_size+1);
				clen -= hdr_size;
				break;
			case 6:
			case 17:
				protocol_type=next_hdr;
				has_hdr=0;
				break;
			default:
				SKIP_PCAP_PCK
			}
			if (gf_bs_is_overflow(nf->cap_bs)) {
				break;
			}
		}
	} else {
		gf_bs_skip_bytes(nf->cap_bs, 9);
		protocol_type = gf_bs_read_u8(nf->cap_bs);
		gf_bs_skip_bytes(nf->cap_bs, 2);
		nf->src_v4 = gf_bs_read_u32_le(nf->cap_bs);
		nf->dst_v4 = gf_bs_read_u32_le(nf->cap_bs);
		clen-=20;
	}
	//UDP
	if (protocol_type==17) {
		nf->src_port = gf_bs_read_u16(nf->cap_bs);
		nf->dst_port = gf_bs_read_u16(nf->cap_bs);
		gf_bs_skip_bytes(nf->cap_bs, 4);
		clen-=8;
	}
	//TCP
	else if (protocol_type==6) {
		nf->src_port = gf_bs_read_u16(nf->cap_bs);
		nf->dst_port = gf_bs_read_u16(nf->cap_bs);
		/*sn = */gf_bs_read_u32(nf->cap_bs);
		/*ack = */gf_bs_read_u32(nf->cap_bs);
		u32 data_offset = gf_bs_read_int(nf->cap_bs, 4);
		gf_bs_read_int(nf->cap_bs, 4);
		gf_bs_skip_bytes(nf->cap_bs, 7);
		if (data_offset>5)
			gf_bs_skip_bytes(nf->cap_bs, (data_offset-5)*4);
		clen -= data_offset*4;
	} else {
		//no support
		SKIP_PCAP_PCK
	}

	if ((clen<0)|| gf_bs_is_overflow(nf->cap_bs)) {
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[NetCap] Corrupted PCAP file, aborting\n"));
		nf->is_eos = GF_TRUE;
		return;
	}
	//for pcap, skip ethernet CRC
	if ((nf->cap_mode==NETCAP_PCAP) && (link_type==1))
		nf->pcap_trail = 4;

	if (nf->cap_mode==NETCAP_PCAP) {
		nf->pck_time = s;
		nf->pck_time *= 1000000;
		if (nf->pcap_nano)
			nf->pck_time+=frac/1000;
		else
			nf->pck_time+=frac;
	} else {
		nf->pck_time = s;
		nf->pck_time <<= 32;
		nf->pck_time |= frac;
		//in microsec since UTC epoch
	}
	if (!nf->init_time) {
		nf->init_time = gf_sys_clock_high_res();
		nf->init_time -= nf->pck_time;
	}
	nf->pck_time += nf->init_time;
	nf->pck_len = clen;
	if (!clen) goto refetch_pcap;
}

static GF_Err gf_netcap_playback(GF_NetcapFilter *nf);

GF_Err gf_netcap_setup(char *rules)
{
	char *id=NULL;
	char *src=NULL;
	char *dst=NULL;
	s32 cap_loop=0;
	Bool cap_rt=GF_TRUE;
	char *rsep = strchr(rules, '[');
	if (rsep) rsep[0] = 0;
	//extract src or dst, nrt flag and loop flag
	while (rules) {
		char *sep = strchr(rules, ',');
		if (sep) sep[0] = 0;
		if (!strncmp(rules, "id=", 3)) {
			id = gf_strdup(rules+3);
		} else if (!strncmp(rules, "src=", 4)) {
			src = gf_strdup(rules+4);
		} else if (!strncmp(rules, "dst=", 4)) {
			dst = gf_strdup(rules+4);
		} else if (!strcmp(rules, "loop")) {
			cap_loop = -1;
		} else if (!strncmp(rules, "loop=", 5)) {
			cap_loop = atoi(rules+5);
		} else if (!strcmp(rules, "nrt")) {
			cap_rt = GF_FALSE;
		}
		if (!sep) {
			rules=NULL;
			break;
		}
		sep[0] = ',';
		rules = sep+1;
		if (rules[0]=='[') break;
	}
	if (rsep) {
		rsep[0] = '[';
		rules = rsep;
	}
	if (!dst && !src && !rules) {
		if (id) gf_free(id);
		GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[NetCap] Invalid netcap rule, ignoring\n"));
		return GF_OK;
	}
	if (dst && src) {
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[NetCap] Invalid netcap, src and dst cannot be set at the same time\n"));
		if (id) gf_free(id);
		gf_free(src);
		gf_free(dst);
		return GF_BAD_PARAM;
	}

	GF_NetcapFilter *nf = gf_net_filter_get(id);
	if (nf) {
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[NetCap] Several netcap filters with same IDs are not supported, ignoring\n"));
		if (id) gf_free(id);
		if (src) gf_free(src);
		if (dst) gf_free(dst);
		return GF_BAD_PARAM;
	}

	GF_SAFEALLOC(nf, GF_NetcapFilter);
	if (!nf) {
		if (id) gf_free(id);
		if (src) gf_free(src);
		if (dst) gf_free(dst);
		return GF_OUT_OF_MEM;
	}
	nf->id = id;
	nf->src = src;
	nf->dst = dst;
	nf->loops = cap_loop;
	nf->rt = cap_rt;
	nf->rules = gf_list_new();
	if (!nf->rules) {
		if (id) gf_free(id);
		if (src) gf_free(src);
		if (dst) gf_free(dst);
		gf_free(nf);
		return GF_OUT_OF_MEM;
	}
	if (!netcap_filters) netcap_filters = gf_list_new();
	gf_list_add(netcap_filters, nf);

#ifdef GPAC_HAS_FD
	nf->fd = -1;
#endif

	while (rules) {
		u32 send_recv = 1; //default reception only
		u32 port=0;
		u32 num_pck=1;
		u32 pck_start=0;
		u32 pck_end=0;
		s32 patch_offset=-1;
		s32 patch_val=-1;
		s32 rand_every = 0;
		s32 delay = 0;
		Bool pck_start_is_loop = GF_FALSE;
		Bool pck_end_is_loop = GF_FALSE;

		char *rule_str;
		char *sep = strchr(rules, '[');
		if (!sep) break;
		sep = strchr(sep+1, ']');
		if (!sep) break;

		sep[0] = 0;
		rule_str = rules+1;
		while (rule_str[1]=='=') {
			char *sep2 = strchr(rule_str+2, ',');
			if (sep2) sep2[0]=0;

			switch (rule_str[0]) {
			case 'm':
				if (!strcmp(rule_str+2, "r")) send_recv = 1;
				else if (!strcmp(rule_str+2, "w")) send_recv = 2;
				else if (!strcmp(rule_str+2, "rw") || !strcmp(rule_str+2, "wr")) send_recv = 0;
				else {
					GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[NetCap] Unknown mode %s, using read/write\n", rule_str+2));
					send_recv=0;
				}
				break;
			case 'p':
				port = atoi(rule_str+2);
				break;
			case 'S':
				pck_start_is_loop = GF_TRUE;
			case 's':
				pck_start = atoi(rule_str+2);
				break;
			case 'E':
				pck_end_is_loop = GF_TRUE;
			case 'e':
				pck_end = atoi(rule_str+2);
				break;
			case 'n':
				num_pck = atoi(rule_str+2);
				break;
			case 'r':
				rand_every = atoi(rule_str+2);
				if (rand_every<0) rand_every = -rand_every;
				break;
			case 'f':
				rand_every = atoi(rule_str+2);
				if (rand_every>0) rand_every = -rand_every;
				break;
			case 'o':
				patch_offset = atoi(rule_str+2);
				break;
			case 'v':
				if (strchr(rule_str, '-')) patch_val =-1;
				else patch_val = strtol(rule_str+2, NULL, 16);
				break;
			case 'd':
				if (!nf->src) {
					GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[NetCap] Reorder rule only supported from pcap playback, ignoring\n"));
					break;
				}
				delay = atoi(rule_str+2);
				break;
			default:
				GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[NetCap] Unknown directive %c, ignoring\n", rule_str[0]));
			}

			if (!sep2) break;
			sep2[0] = ',';
			rule_str = sep2+1;
		}

		NetFilterRule *rule;
		GF_SAFEALLOC(rule, NetFilterRule);
		rule->send_recv = send_recv;
		rule->port = port;
		rule->patch_offset = patch_offset;
		rule->patch_val = patch_val;
		rule->pck_start = pck_start;
		rule->pck_end = pck_end>pck_start ? pck_end : 0;
		rule->pck_start_is_loop = pck_start_is_loop;
		rule->pck_end_is_loop = pck_end_is_loop;
		rule->rand_every = rand_every;
		rule->nb_pck = num_pck;
		rule->delay = delay;

		gf_list_add(nf->rules, rule);
		sep[0] = ']';
		rules = sep+1;
	}
	nf->nb_rules = gf_list_count(nf->rules);

	if (nf->dst) {
		GF_Err e = gf_netcap_record(nf);
		if (e) return e;
	}
	if (nf->src) {
		GF_Err e = gf_netcap_playback(nf);
		if (e) return e;
	}
	return GF_OK;
}

static Bool netcap_filter_pck(GF_Socket *sock, u32 pck_len, Bool for_send)
{
	u32 i=0;
	if (!sock || !sock->cap_info) return GF_FALSE;
	GF_NetcapFilter *nf = sock->cap_info->nf;

	if (for_send) {
		nf->pck_idx_w++;
		sock->cap_info->pck_idx_w++;
	} else {
		nf->pck_idx_r++;
		sock->cap_info->pck_idx_r++;
	}

	for (i=0; i<nf->nb_rules; i++) {
		NetFilterRule *r = gf_list_get(nf->rules, i);
		if (r->port && (r->port != nf->dst_port)) continue;
		if (for_send) {
			if (r->send_recv==1) continue;
		} else {
			if (r->send_recv==2) continue;
		}
		NetCapInfo *ci = r->port ? sock->cap_info : NULL;
		u32 cur_pck;
		if (ci) {
			cur_pck = for_send ? ci->pck_idx_w : ci->pck_idx_r;
		} else {
			cur_pck = for_send ? nf->pck_idx_w : nf->pck_idx_r;
		}
		//check range
		u32 pck_start = r->pck_start;
		if (r->pck_start && r->pck_start_is_loop)
			pck_start += nf->nb_reloads;
		if (!pck_start && r->pck_start_is_loop) continue;
		u32 pck_end = pck_start ? r->pck_end : 0;
		if (r->pck_end && r->pck_end_is_loop)
			pck_end += nf->nb_reloads;

		if (pck_start && (cur_pck < pck_start)) continue;
		if (pck_end && (cur_pck >= pck_end)) continue;

		//not repeated pattern case
		if (!r->rand_every) {
			if ((cur_pck >= pck_start) && (pck_start + r->nb_pck > cur_pck)) {}
			else continue;
		}
		//repeated pattern case
		else {
			u32 next_pck_range = ci ? ci->next_pck_range : nf->next_pck_range;
			u32 next_rand = ci ? ci->next_rand : nf->next_rand;
			//in range, check if we need to recompute
			if (next_pck_range < pck_start)
				next_pck_range = pck_start;

			if (next_pck_range <= cur_pck) {
				if (r->rand_every>0) {
					next_rand = next_pck_range + gf_rand() % r->rand_every;
					next_pck_range += r->rand_every;
				} else {
					next_rand = next_pck_range;
					next_pck_range += -r->rand_every;
				}

				if (ci) {
					ci->next_pck_range = next_pck_range;
					ci->next_rand = next_rand;
				} else {
					nf->next_pck_range = next_pck_range;
					nf->next_rand = next_rand;
				}
			}

			//ours
			if (r->nb_pck) {
				if ((next_rand<=cur_pck) && (next_rand+r->nb_pck>cur_pck)) {}
				else continue;
			} else {
				if (next_rand==cur_pck) {}
				else continue;
			}
		}

		if ((r->patch_offset==-1) && !(sock->flags & GF_SOCK_IS_TCP)) {
			if (r->delay) {
				if (!nf->reorder_seek_pos) {
					nf->reorder_seek_pos = nf->pck_start_offset;
					nf->reorder_max_pck = r->nb_pck;
					nf->delay_nb_pck = r->delay;
					nf->reorder_nb_pck = 0;
				}
				nf->reorder_nb_pck ++;
				return GF_TRUE;
			}
			GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[NetCap] Dropping packet %d\n", cur_pck));
			return GF_TRUE;
		}
		u32 bo = (r->patch_offset>=0) ? r->patch_offset : gf_rand();
		bo = bo % pck_len;
		sock->cap_info->patch_offset = 1+bo;

		u32 val = (r->patch_val>=0) ? r->patch_val : gf_rand();
		val = val % 256;

		sock->cap_info->patch_val = val;
		GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[NetCap] Patching packet %d byte offset %d to 0x%02X\n", cur_pck, bo, val));
		// we want to patch many bytes of same packet
		// return GF_FALSE;
	}
	return GF_FALSE;
}

static void gf_netcap_load_pck(GF_NetcapFilter *nf, u64 now)
{

refetch:
	//no packet loaded
	if (!nf->dst_port) {
		Bool discard=GF_FALSE;
		nf->pck_flags=0;
		nf->read_sock_selected = NULL;

		if (nf->loops && !gf_bs_available(nf->cap_bs)) {
			nf->nb_reloads++;
			if (nf->loops>0)
				nf->loops--;

			gf_bs_seek(nf->cap_bs, 0);
			nf->init_time = 0;
			if (nf->cap_mode==NETCAP_PCAP)
				gf_bs_skip_bytes(nf->cap_bs, 24);
		}

		if (nf->reorder_seek_pos) {
			//we passed all packets to reorder
			if (nf->reorder_nb_pck == nf->reorder_max_pck) {
				if (!nf->delay_nb_pck) {
					//remember pos after reorder
					nf->reorder_resume_pos = gf_bs_get_position(nf->cap_bs);
					gf_bs_seek(nf->cap_bs, nf->reorder_seek_pos);
					nf->reorder_seek_pos = 0;
					nf->pcapng_trail = nf->pcap_trail = 0;
					nf->reorder_nb_pck = 1;
				} else {
					nf->delay_nb_pck--;
				}
			}
		} else if (nf->reorder_resume_pos) {
			if (nf->reorder_nb_pck == nf->reorder_max_pck) {
				gf_bs_seek(nf->cap_bs, nf->reorder_resume_pos);
				nf->reorder_resume_pos = 0;
				nf->pcapng_trail = nf->pcap_trail = 0;
				nf->reorder_nb_pck = 0;
			} else {
				nf->reorder_nb_pck++;
			}
		}
		if (nf->cap_mode==NETCAP_GPAC)
			gf_netcap_load_pck_gpac(nf);
		else
			gf_netcap_load_pck_pcap(nf);

		//eof
		if (!nf->dst_port) return;
		//force discard
		if ((nf->pck_flags & NETCAP_DROP)) discard = GF_TRUE;

		if (discard) {
			gf_bs_skip_bytes(nf->cap_bs, nf->pck_len);
			nf->dst_port = 0;
			goto refetch;
		}
	}

	if (nf->rt && now && (nf->pck_time > now)) {
		GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[NetCap] Packet too early by %d ms\n", (u32) (nf->pck_time - now) / 1000));
		return;
	}

	//we already have the socket
	if (nf->read_sock_selected)
		return;

	//find destination socket
	u32 i=0;
	GF_Socket *s = NULL;
	while ((s=gf_list_enum(nf->read_socks, &i))) {
		//in pcap mode, check multicast - if enabled, match dst
		//in GPC mode with multicast, only multicast address is used, in host port/addr fields
		if ((nf->cap_mode!=NETCAP_GPAC) && (s->flags & GF_SOCK_IS_MULTICAST)) {
			if (s->cap_info->peer_port != nf->dst_port)
				continue;
			if (nf->pck_flags & NETCAP_IS_IPV6) {
				if (memcmp(s->cap_info->peer_addr_v6, nf->dst_v6, 16)) continue;
			} else {
				if (s->cap_info->peer_addr_v4 != nf->dst_v4) continue;
			}
			nf->read_sock_selected = s;
			s->cap_info->patch_offset = 0;
			break;
		}
		if (s->cap_info->host_port != nf->dst_port)
			continue;
		if (nf->pck_flags & NETCAP_IS_IPV6) {
			if (memcmp(s->cap_info->host_addr_v6, nf->dst_v6, 16)) continue;
		} else {
			//accept INADDR_ANY
			if (s->cap_info->host_addr_v4 && (s->cap_info->host_addr_v4 != nf->dst_v4)) continue;
			if (s->flags & GF_SOCK_IS_TCP) {
				if (s->cap_info->peer_addr_v4 != nf->src_v4) continue;
				if (!s->cap_info->peer_port) {
					s->cap_info->peer_port = nf->src_port;
				} else if (s->cap_info->peer_port != nf->src_port) {
					continue;
				}
			}
		}
		nf->read_sock_selected = s;
		s->cap_info->patch_offset = 0;
		break;
	}
	//apply rule(s) except when sending delayed packets
	if (!nf->reorder_resume_pos && netcap_filter_pck(nf->read_sock_selected, nf->pck_len, GF_FALSE))
		nf->read_sock_selected = NULL;

	if (!nf->read_sock_selected) {
		gf_bs_skip_bytes(nf->cap_bs, nf->pck_len);
		nf->dst_port = 0;
		goto refetch;
	}
}

static GF_Err gf_netcap_playback(GF_NetcapFilter *nf)
{
#ifdef GPAC_HAS_FD
	if (!gf_opts_get_bool("core", "no-fd")) {
		nf->fd = gf_fd_open(nf->src, O_RDONLY | O_BINARY , S_IRUSR | S_IWUSR);
		if (nf->fd>=0) nf->cap_bs = gf_bs_from_fd(nf->fd, GF_BITSTREAM_READ);
	} else
#endif
	{
		nf->file = gf_fopen_ex(nf->src, NULL, "rb", GF_FALSE);
		if (nf->file) nf->cap_bs = gf_bs_from_file(nf->file, GF_BITSTREAM_READ);
	}
	if (!nf->cap_bs) {
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[NetCap] Failed to setup capture playback\n"));
		return GF_IO_ERR;
	}
	nf->read_socks = gf_list_new();

	u32 magic = gf_bs_read_u32(nf->cap_bs);
	if (magic == GF_GPC_MAGIC) {
		nf->cap_mode = NETCAP_GPAC;
	} else if (magic==GF_4CC(0xD4, 0xC3, 0xB2, 0xA1)) {
		nf->cap_mode = NETCAP_PCAP;
		nf->pcap_le = GF_TRUE;
	} else if (magic==GF_4CC(0xA1, 0xB2, 0xC3, 0xD4)) {
		nf->cap_mode = NETCAP_PCAP;
	} else if (magic==GF_4CC(0x4D, 0x3C, 0xB2, 0xA1)) {
		nf->cap_mode = NETCAP_PCAP;
		nf->pcap_nano = GF_TRUE;
		nf->pcap_le = GF_TRUE;
	} else if (magic==GF_4CC(0xA1, 0xB2, 0x3C, 0x4D)) {
		nf->cap_mode = NETCAP_PCAP;
		nf->pcap_nano = GF_TRUE;
	} else if (magic==GF_4CC(0x0A, 0x0D, 0x0D, 0x0A)) {
		nf->cap_mode = NETCAP_PCAPNG;
		nf->pcap_nano = GF_TRUE;
	} else {
		gf_net_close_capture();
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[NetCap] Unsupported capture file magic %s\n", gf_4cc_to_str(magic)));
		return GF_NOT_SUPPORTED;
	}
	if (nf->cap_mode==NETCAP_GPAC) {
		/*ntp_sec = */gf_bs_read_u32(nf->cap_bs);
		/*ntp_frac = */gf_bs_read_u32(nf->cap_bs);
		magic = gf_bs_read_u32(nf->cap_bs);
		gf_bs_skip_bytes(nf->cap_bs, magic);
		return GF_OK;
	}

	if (nf->cap_mode==NETCAP_PCAP) {
		gf_bs_skip_bytes(nf->cap_bs, 16); //we ignore snapLen
		gf_bs_read_int(nf->cap_bs, 4);
		nf->link_types[0] = gf_bs_read_int(nf->cap_bs, 28);
		if (nf->pcap_le) nf->link_types[0] = ntohl(nf->link_types[0]);

		switch (nf->link_types[0]) {
		case PCAP_LT_LOOPBACK:
		case PCAP_LT_ETHERNET:
		case PCAP_LT_CHAOS:
			break;
		default:
			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[NetCap] Only ethernet and BSD-loopback pcap files are supported, got %u\n", nf->link_types[0]));
			gf_net_close_capture();
			return GF_NOT_SUPPORTED;
		}
	}
	//pcapng
	else if (nf->cap_mode==NETCAP_PCAPNG) {
		GF_Err e = pcapng_load_shb(nf, GF_TRUE);
		if (e) return e;

		u32 btype = nf->pcap_le ? gf_bs_read_u32_le(nf->cap_bs) : gf_bs_read_u32(nf->cap_bs);
		if (btype != 1) {
			gf_net_close_capture();
			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[NetCap] Missing IDB block after pacpng header\n"));
			return GF_NON_COMPLIANT_BITSTREAM;
		}
		pcapng_load_idb(nf);
	}
	return GF_OK;
}

static GF_Err gf_netcap_send_pcap(GF_NetcapFilter *nf, GF_Socket *sock, const u8 *buffer, u32 length, u32 *written, Bool is_ng)
{
	u32 sec, frac, pck_len, ng_size=0, ng_trail=0;
	if (!sock->cap_info->host_port) return GF_BAD_PARAM;

	pck_len = length;
	pck_len += 4;
	if (sock->flags & GF_SOCK_IS_IPV6) {
		pck_len += 40;
	} else {
		pck_len += 20;
	}
	if (sock->flags & GF_SOCK_IS_TCP) {
		pck_len += 20;
	} else {
		pck_len += 8;
	}

	if (is_ng) {
		ng_size = pck_len/4;
		ng_trail = pck_len%4;
		if (ng_trail) {
			ng_size++;
			ng_trail = 4-ng_trail;
		}
		ng_size += 5;
		ng_size *= 4;
		ng_size+=12;

		gf_bs_write_u32(nf->cap_bs, 6);
		gf_bs_write_u32(nf->cap_bs, ng_size);
		gf_bs_write_u32(nf->cap_bs, 0);
	}

	gf_net_get_ntp(&sec, &frac);
	gf_bs_write_u32(nf->cap_bs, sec);
	gf_bs_write_u32(nf->cap_bs, (u32) gf_timestamp_rescale(frac, 0xFFFFFFFF, 1000000));
	gf_bs_write_u32(nf->cap_bs, pck_len);
	gf_bs_write_u32(nf->cap_bs, pck_len);

	gf_bs_write_u32(nf->cap_bs, (sock->flags & GF_SOCK_IS_IPV6) ? 24 : 2);
	pck_len-=4;

	u8 protocol_type = (sock->flags & GF_SOCK_IS_TCP) ? 6 : 17;
	if (sock->flags & GF_SOCK_IS_IPV6) {
		gf_bs_write_int(nf->cap_bs, 6, 4);
		gf_bs_write_int(nf->cap_bs, 0, 4);
		gf_bs_write_u24(nf->cap_bs, 0);
		gf_bs_write_u16(nf->cap_bs, pck_len);
		gf_bs_write_u8(nf->cap_bs, protocol_type);
		gf_bs_write_u8(nf->cap_bs, 10);
		gf_bs_write_data(nf->cap_bs, sock->cap_info->host_addr_v6, 16);
		gf_bs_write_data(nf->cap_bs, sock->cap_info->peer_addr_v6, 16);
	} else {
		u32 chk_sum = 0x4500;
		gf_bs_write_int(nf->cap_bs, 4, 4);
		gf_bs_write_int(nf->cap_bs, 5, 4);
		gf_bs_write_u8(nf->cap_bs, 0);
		chk_sum += pck_len;
		gf_bs_write_u16(nf->cap_bs, pck_len);
		gf_bs_skip_bytes(nf->cap_bs, 4);
		gf_bs_write_u8(nf->cap_bs, 10);
		gf_bs_write_u8(nf->cap_bs, protocol_type);
		chk_sum += (0x0a00 | protocol_type);

		chk_sum += ((sock->cap_info->host_addr_v4&0xFF)<<8) | ((sock->cap_info->host_addr_v4>>8)&0xFF);
		chk_sum += (((sock->cap_info->host_addr_v4>>16)&0xFF)<<8) | ((sock->cap_info->host_addr_v4>>24)&0xFF);
		chk_sum += ((sock->cap_info->peer_addr_v4&0xFF)<<8) | ((sock->cap_info->peer_addr_v4>>8)&0xFF);
		chk_sum += (((sock->cap_info->peer_addr_v4>>16)&0xFF)<<8) | ((sock->cap_info->peer_addr_v4>>24)&0xFF);
		if (chk_sum>0xFFFF) {
			u32 high = chk_sum>0xFFFF;
			chk_sum += high;
		}
		gf_bs_write_u16(nf->cap_bs, ~chk_sum);
		gf_bs_write_u32_le(nf->cap_bs, sock->cap_info->host_addr_v4);
		gf_bs_write_u32_le(nf->cap_bs, sock->cap_info->peer_addr_v4);
	}
	//UDP
	if (protocol_type==17) {
		gf_bs_write_u16(nf->cap_bs, sock->cap_info->host_port);
		gf_bs_write_u16(nf->cap_bs, sock->cap_info->peer_port);
		gf_bs_write_u16(nf->cap_bs, 8+length);
		//skip checksum
		gf_bs_skip_bytes(nf->cap_bs, 2);
	}
	//TCP
	else if (protocol_type==6) {
		gf_bs_write_u16(nf->cap_bs, sock->cap_info->host_port);
		gf_bs_write_u16(nf->cap_bs, sock->cap_info->peer_port);
		/*sn = */gf_bs_write_u32(nf->cap_bs, 0);
		/*ack = */gf_bs_write_u32(nf->cap_bs, 0);
		gf_bs_write_int(nf->cap_bs, 5, 4);
		gf_bs_write_int(nf->cap_bs, 0, 4);
		gf_bs_skip_bytes(nf->cap_bs, 7);
	}

	gf_bs_write_data(nf->cap_bs, buffer, length);
	if (is_ng) {
		if (ng_trail) gf_bs_skip_bytes(nf->cap_bs, ng_trail);
		gf_bs_write_u32(nf->cap_bs, ng_size);
	}
	if (written) *written = length;
	return GF_OK;
}


static GF_Err gf_netcap_send_gpac(GF_NetcapFilter *nf, GF_Socket *sock, const u8 *buffer, u32 length, u32 *written)
{
	u64 now = gf_sys_clock_high_res();
	if (!sock->cap_info->host_port) return GF_BAD_PARAM;
	if (!nf->init_time) nf->init_time = now;
	now -= nf->init_time;

	//setup flags and size flags
	u32 size = 1+8+2+length;
	u8 flags=0;
	if (sock->flags & GF_SOCK_IS_MULTICAST) flags |= NETCAP_IS_MCAST;
	if (sock->flags & GF_SOCK_IS_TCP) flags |= NETCAP_IS_TCP;
	if (sock->flags & GF_SOCK_HAS_PEER) flags |= NETCAP_HAS_PEER;
	if (sock->flags & GF_SOCK_IS_IPV6) {
		size += 16;
		if (sock->flags & GF_SOCK_HAS_PEER) {
			size += 18;
		}
		flags |= NETCAP_IS_IPV6;
	} else {
		size += 4;
		if (sock->flags & GF_SOCK_HAS_PEER) {
			size += 6;
		}
	}
	gf_bs_write_u32(nf->cap_bs, size);
	gf_bs_write_u8(nf->cap_bs, flags);
	gf_bs_write_u64(nf->cap_bs, now);
	if (sock->flags & GF_SOCK_IS_IPV6) {
		gf_bs_write_data(nf->cap_bs, sock->cap_info->host_addr_v6, 16);
		if (sock->flags & GF_SOCK_HAS_PEER)
			gf_bs_write_data(nf->cap_bs, sock->cap_info->peer_addr_v6, 16);
	} else {
		gf_bs_write_u32(nf->cap_bs, sock->cap_info->host_addr_v4);
		if (sock->flags & GF_SOCK_HAS_PEER)
			gf_bs_write_u32(nf->cap_bs, sock->cap_info->peer_addr_v4);
	}
	gf_bs_write_u16(nf->cap_bs, sock->cap_info->host_port);
	if (sock->flags & GF_SOCK_HAS_PEER)
		gf_bs_write_u16(nf->cap_bs, sock->cap_info->peer_port);
	gf_bs_write_data(nf->cap_bs, buffer, length);
	if (written) *written = length;
	return GF_OK;
}

static GF_Err gf_netcap_send(GF_Socket *sock, const u8 *buffer, u32 length, u32 *written)
{
	GF_NetcapFilter *nf = sock->cap_info->nf;
	if (nf->cap_mode==NETCAP_PCAP) {
		return gf_netcap_send_pcap(nf, sock, buffer, length, written, GF_FALSE);
	} else if (nf->cap_mode==NETCAP_PCAPNG) {
		return gf_netcap_send_pcap(nf, sock, buffer, length, written, GF_TRUE);
	} else {
		return gf_netcap_send_gpac(nf, sock, buffer, length, written);
	}
}
#endif //GPAC_DISABLE_NETCAP

Bool gf_sk_has_nrt_netcap(GF_Socket *sk)
{
	if (sk && sk->cap_info && !sk->cap_info->nf->rt) return GF_TRUE;
	return GF_FALSE;
}

GF_EXPORT
GF_Socket *gf_sk_new_ex(u32 SocketType, const char *netcap_id)
{
	GF_Socket *tmp;

	/*init WinSock*/
#ifdef WIN32
	WSADATA Data;
	if (!wsa_init && (WSAStartup(0x0202, &Data)!=0) ) return NULL;
#endif
	switch (SocketType) {
	case GF_SOCK_TYPE_UDP:
	case GF_SOCK_TYPE_TCP:
#ifdef GPAC_HAS_SOCK_UN
	case GF_SOCK_TYPE_UDP_UN:
	case GF_SOCK_TYPE_TCP_UN:
#endif
		break;
	default:
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[Socket] unsupported socket type %d\n", SocketType));
		return NULL;
	}

	GF_SAFEALLOC(tmp, GF_Socket);
	if (!tmp) return NULL;
	if (SocketType == GF_SOCK_TYPE_TCP) tmp->flags |= GF_SOCK_IS_TCP;
#ifdef GPAC_HAS_SOCK_UN
	else if (SocketType == GF_SOCK_TYPE_TCP_UN) tmp->flags |= GF_SOCK_IS_TCP | GF_SOCK_IS_UN;
	else if (SocketType == GF_SOCK_TYPE_UDP_UN) tmp->flags |= GF_SOCK_IS_UN;
#endif

#ifdef GPAC_HAS_IPV6
	memset(&tmp->dest_addr, 0, sizeof(struct sockaddr_storage));
#else
	memset(&tmp->dest_addr, 0, sizeof(struct sockaddr_in));
	tmp->dest_addr_len = sizeof(struct sockaddr);
#endif

	tmp->usec_wait = 500;
#ifdef WIN32
	wsa_init ++;
#endif
	tmp->socket = INVALID_SOCKET;

#ifndef GPAC_DISABLE_NETCAP
	GF_NetcapFilter *nf = gf_net_filter_get(netcap_id);
	if (nf && (nf->cap_bs || nf->nb_rules)) {
		GF_SAFEALLOC(tmp->cap_info, NetCapInfo);
		if (!tmp->cap_info) {
			gf_free(tmp);
			return NULL;
		}
		if (nf->read_socks)
			gf_list_add(nf->read_socks, tmp);
		tmp->cap_info->nf = nf;
	}
#endif
	return tmp;
}

GF_EXPORT
GF_Socket *gf_sk_new(u32 SocketType)
{
	return gf_sk_new_ex(SocketType, NULL);
}

GF_EXPORT
GF_Err gf_sk_set_buffer_size(GF_Socket *sock, Bool SendBuffer, u32 NewSize)
{
	u32 nsize=0, psize;
	s32 res;
	if (!sock || SOCKET_INVALID(sock->socket)) return GF_BAD_PARAM;

	if (SendBuffer) {
		res = setsockopt(sock->socket, SOL_SOCKET, SO_SNDBUF, (char *) &NewSize, sizeof(u32) );
	} else {
		res = setsockopt(sock->socket, SOL_SOCKET, SO_RCVBUF, (char *) &NewSize, sizeof(u32) );
	}
	if (res<0) {
		GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[Socket] Couldn't set socket %s buffer size to %d: %s (%d)\n", SendBuffer ? "send" : "receive", NewSize, gf_errno_str(LASTSOCKERROR), LASTSOCKERROR));
	} else {
		GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[Socket] Set socket %s buffer size to %d\n", SendBuffer ? "send" : "receive", NewSize));
	}
	psize = sizeof(u32);
	if (SendBuffer) {
		res = getsockopt(sock->socket, SOL_SOCKET, SO_SNDBUF, (char *) &nsize, &psize );
	} else {
		res = getsockopt(sock->socket, SOL_SOCKET, SO_RCVBUF, (char *) &nsize, &psize );
	}
	if ((res>=0) && (nsize!=NewSize)) {
		GF_LOG(nsize <= NewSize ? GF_LOG_WARNING : GF_LOG_DEBUG, GF_LOG_NETWORK, ("[Socket] Asked to set socket %s buffer size to %d but system used %d\n", SendBuffer ? "send" : "receive", NewSize, nsize));
	}

	return GF_OK;
}

GF_EXPORT
GF_Err gf_sk_set_block_mode(GF_Socket *sock, Bool NonBlockingOn)
{
	s32 res;
#ifdef WIN32
	long val = NonBlockingOn;
	if (!SOCKET_INVALID(sock->socket)) {
		res = ioctlsocket(sock->socket, FIONBIO, &val);
		if (res) return GF_SERVICE_ERROR;
	}
#else
	if (!SOCKET_INVALID(sock->socket)) {
		s32 flags = fcntl(sock->socket, F_GETFL, 0);
		if (NonBlockingOn)
			flags |= O_NONBLOCK;
		else
			flags &= ~O_NONBLOCK;

		res = fcntl(sock->socket, F_SETFL, flags);
		if (res) return GF_SERVICE_ERROR;
	}
#endif
	if (NonBlockingOn) {
		sock->flags |= GF_SOCK_NON_BLOCKING;
	} else {
		sock->flags &= ~GF_SOCK_NON_BLOCKING;
	}
	return GF_OK;
}

#include <assert.h>

#ifndef GPAC_DISABLE_NETCAP
#define sock_close(_s) \
	closesocket(_s->socket);\
	_s->socket = INVALID_SOCKET;\
	if (_s->cap_info) _s->cap_info->host_port = 0; \

#else

#define sock_close(_s) \
	closesocket(_s->socket);\
	_s->socket = INVALID_SOCKET;

#endif

static void gf_sk_free(GF_Socket *sock)
{
	gf_assert( sock );
	if (SOCKET_INVALID(sock->socket)) return;

	/*leave multicast*/
	if (sock->flags & GF_SOCK_IS_MULTICAST) {
		struct ip_mreq mreq;
#ifdef GPAC_HAS_IPV6
		struct sockaddr *addr = (struct sockaddr *)&sock->dest_addr;
		if (addr->sa_family==AF_INET6) {
			struct ipv6_mreq mreq6;
			memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
			mreq6.ipv6mr_interface= 0;
			setsockopt(sock->socket, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, (char *) &mreq6, sizeof(mreq6));
		} else {
			mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
			mreq.imr_interface.s_addr = INADDR_ANY;
			setsockopt(sock->socket, IPPROTO_IP, IP_DROP_MEMBERSHIP, (char *) &mreq, sizeof(mreq));
		}
#else
		mreq.imr_multiaddr.s_addr = sock->dest_addr.sin_addr.s_addr;
		mreq.imr_interface.s_addr = INADDR_ANY;
		setsockopt(sock->socket, IPPROTO_IP, IP_DROP_MEMBERSHIP, (char *) &mreq, sizeof(mreq));
#endif
	}

	sock_close(sock);
}


GF_EXPORT
void gf_sk_del(GF_Socket *sock)
{
	gf_assert( sock );
	gf_sk_free(sock);
#ifdef WIN32
	wsa_init --;
	if (!wsa_init) WSACleanup();
#endif

#ifndef GPAC_DISABLE_NETCAP
	if (sock->cap_info) {
		if (sock->cap_info->nf->read_socks)
			gf_list_del_item(sock->cap_info->nf->read_socks, sock);
		gf_free(sock->cap_info);
	}
#endif
	gf_free(sock);
}

GF_EXPORT
void gf_sk_reset(GF_Socket *sock)
{
	if (sock) {
		u32 clear=0;
		setsockopt(sock->socket, SOL_SOCKET, SO_ERROR, (char *) &clear, sizeof(u32) );
	}
}

GF_EXPORT
s32 gf_sk_get_handle(GF_Socket *sock)
{
	return (s32) sock->socket;
}

GF_EXPORT
void gf_sk_set_usec_wait(GF_Socket *sock, u32 usec_wait)
{
	if (!sock) return;
	sock->usec_wait = (usec_wait>=1000000) ? 500 : usec_wait;
}

#ifdef GPAC_STATIC_BIN
struct hostent *gf_gethostbyname(const char *PeerName)
{
	GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("Static GPAC build has no DNS support, cannot resolve host %s !\n", PeerName));
	return NULL;
}
#else
#define gf_gethostbyname gethostbyname
#endif

static u32 inet_addr_from_name(const char *local_interface);

//connects a socket to a remote peer on a given port
GF_Err gf_sk_connect_ex(GF_Socket *sock, const char *PeerName, u16 PortNumber, const char *ifce_ip_or_name, Bool use_udp_connect)
{
	s32 ret;
#ifdef GPAC_HAS_IPV6
	u32 type;
	struct addrinfo *res, *aip, *lip;
#else
	struct hostent *Host = NULL;
#endif

	if (sock->flags & GF_SOCK_IS_UN) {
#ifdef GPAC_HAS_SOCK_UN
		struct sockaddr_un server_add;
		if (SOCKET_INVALID(sock->socket)) {
			sock->socket = socket(AF_UNIX, (sock->flags & GF_SOCK_IS_TCP) ? SOCK_STREAM : SOCK_DGRAM, 0);
			if (sock->flags & GF_SOCK_NON_BLOCKING)
				gf_sk_set_block_mode(sock, GF_TRUE);
		}
		server_add.sun_family = AF_UNIX;
		gf_strcpy(server_add.sun_path, PeerName);
		server_add.sun_path[sizeof(server_add.sun_path)-1]=0;
		if (connect(sock->socket, (struct sockaddr *)&server_add, sizeof(struct sockaddr_un)) < 0) {
			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[Socket] Failed to connect unix domain socket to %s\n", PeerName));
			return GF_IP_CONNECTION_FAILURE;
		}
		return GF_OK;
#else
	     return GF_NOT_SUPPORTED;
#endif
	}

#ifdef GPAC_HAS_IPV6
	type = (sock->flags & GF_SOCK_IS_TCP) ? SOCK_STREAM : SOCK_DGRAM;

	GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[Sock_IPV6] Solving %s address\n", PeerName));
	res = gf_sk_get_ipv6_addr(PeerName, PortNumber, AF_UNSPEC, AI_PASSIVE, type);
	if (!res) return GF_IP_CONNECTION_FAILURE;
	GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[Sock_IPV6] Host %s found\n", PeerName));

	lip = NULL;
	if (ifce_ip_or_name) {
		lip = gf_sk_get_ifce_ipv6_addr(ifce_ip_or_name, PortNumber, AF_UNSPEC, AI_PASSIVE, type);
		if (!lip) return GF_IP_CONNECTION_FAILURE;
	}

	/*for all interfaces*/
	for (aip=res; aip!=NULL; aip=aip->ai_next) {
		if (type != (u32) aip->ai_socktype) continue;


#ifndef GPAC_DISABLE_NETCAP
		if (sock->cap_info) {
			sock->cap_info->host_port = PortNumber;
			if (lip) {
				if (lip->ai_family==PF_INET) {
					sock->cap_info->host_addr_v4 = inet_addr_from_name(ifce_ip_or_name);
				} else {
					memcpy(sock->cap_info->host_addr_v6, (u8*) &((struct sockaddr_in6 *)lip->ai_addr)->sin6_addr, sizeof(bin128));
				}
			}
			if (aip->ai_family==AF_INET) {
				sock->cap_info->peer_addr_v4 = inet_addr_from_name(PeerName);
				sock->cap_info->peer_addr_v4 = ((struct sockaddr_in *)aip->ai_addr)->sin_addr.s_addr;
			} else {
				memcpy(sock->cap_info->peer_addr_v6, (u8*) &((struct sockaddr_in6 *)aip->ai_addr)->sin6_addr, sizeof(bin128));
			}
			//play/record, don't create socket
			if (sock->cap_info->nf->cap_mode) {
				if (sock->cap_info->nf->read_socks==NULL) {
					sock->cap_info->peer_port = first_tcp_port;
					first_tcp_port++;
				}
				sock->flags |= GF_SOCK_HAS_PEER;
				freeaddrinfo(res);
				if (lip) freeaddrinfo(lip);
				return GF_OK;
			}
		}
#endif
		if (SOCKET_INVALID(sock->socket)) {
			sock->socket = socket(aip->ai_family, aip->ai_socktype, aip->ai_protocol);
			if (SOCKET_INVALID(sock->socket)) {
				continue;
			}
			if (sock->flags & GF_SOCK_IS_TCP) {
				if (sock->flags & GF_SOCK_NON_BLOCKING)
					gf_sk_set_block_mode(sock, GF_TRUE);
			}

			if (aip->ai_family==PF_INET6) sock->flags |= GF_SOCK_IS_IPV6;
			else sock->flags &= ~GF_SOCK_IS_IPV6;

			if (lip) {
				ret = bind(sock->socket, lip->ai_addr, (int) lip->ai_addrlen);
				if (ret == SOCKET_ERROR) {
					sock_close(sock);
					continue;
				}
			}
		}


#if defined(WIN32) || defined(_WIN32_WCE)
			//on winsock we must check writability between two connects for non-blocking sockets
		if ((sock->flags & GF_SOCK_IS_TCP) &&  (sock->flags & GF_SOCK_HAS_CONNECT)) {
			if (gf_sk_select(sock, GF_SK_SELECT_WRITE) == GF_IP_NETWORK_EMPTY) {
				GF_Err e = gf_sk_probe(sock);
				if (e && (e != GF_IP_NETWORK_EMPTY)) return e;
				return GF_IP_NETWORK_EMPTY;
			}
		}
#endif

		if (sock->flags & GF_SOCK_IS_TCP) {
			GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[Sock_IPV6] Connecting to %s:%d\n", PeerName, PortNumber));
		} else if (!use_udp_connect) {
			goto conn_ok;
		}
		ret = connect(sock->socket, aip->ai_addr, (int) aip->ai_addrlen);
		if (ret == SOCKET_ERROR) {
			int err = LASTSOCKERROR;
			if (sock->flags & GF_SOCK_NON_BLOCKING) {
				switch (err) {
				case EINPROGRESS:
#if defined(WIN32) || defined(_WIN32_WCE)
				case WSAEWOULDBLOCK:
#endif
					freeaddrinfo(res);
					if (lip) freeaddrinfo(lip);
					//remember we issued a first connect
					sock->flags |= GF_SOCK_HAS_CONNECT;
					return GF_IP_NETWORK_EMPTY;

				case EISCONN:
				case EALREADY:
#if defined(WIN32) || defined(_WIN32_WCE)
				case WSAEISCONN:
#endif
					if (sock->flags & GF_SOCK_IS_TCP) {
						if (gf_sk_select(sock, GF_SK_SELECT_WRITE) == GF_OK)
							goto conn_ok;
					}
					freeaddrinfo(res);
					if (lip) freeaddrinfo(lip);
					return GF_IP_NETWORK_EMPTY;
				}
			}
			sock_close(sock);
			GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[Sock_IPV6] Failed to connect to host %s: %s (%d) - retrying with next host address\n", PeerName, gf_errno_str(err), err ));
			continue;
		}

conn_ok:
		if (sock->flags & GF_SOCK_IS_TCP) {
			GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[Sock_IPV6] Connected to %s:%d\n", PeerName, PortNumber));
		} else {
			//udp+connect, do not use HAS_PEER
			sock->flags &= ~GF_SOCK_HAS_PEER;
		}
		sock->flags &= ~GF_SOCK_HAS_CONNECT;

#ifdef SO_NOSIGPIPE
		int value = 1;
		setsockopt(sock->socket, SOL_SOCKET, SO_NOSIGPIPE, SSO_CAST &value, sizeof(value));
#endif
		memcpy(&sock->dest_addr, aip->ai_addr, aip->ai_addrlen);
		sock->dest_addr_len = (u32) aip->ai_addrlen;
		freeaddrinfo(res);
		if (lip) freeaddrinfo(lip);
		return GF_OK;
	}
	freeaddrinfo(res);
	if (lip) freeaddrinfo(lip);
	return GF_IP_CONNECTION_FAILURE;

#else

#ifndef GPAC_DISABLE_NETCAP
	if (sock->cap_info) {
		sock->cap_info->host_port = PortNumber;
		if (ifce_ip_or_name)
			sock->cap_info->host_addr_v4 = inet_addr_from_name(ifce_ip_or_name);

		sock->cap_info->peer_addr_v4 = inet_addr_from_name(PeerName);
		if (sock->cap_info->nf->read_socks==NULL) {
			sock->cap_info->peer_port = first_tcp_port;
			first_tcp_port++;
		}

		//play/record, don't create socket
		if (sock->cap_info->nf->cap_mode) {
			sock->flags |= GF_SOCK_HAS_PEER;
			return GF_OK;
		}
	}
#endif

	if (SOCKET_INVALID(sock->socket)) {
		sock->socket = socket(AF_INET, (sock->flags & GF_SOCK_IS_TCP) ? SOCK_STREAM : SOCK_DGRAM, 0);
		if (sock->flags & GF_SOCK_NON_BLOCKING)
			gf_sk_set_block_mode(sock, GF_TRUE);
	}

	/*setup the address*/
	sock->dest_addr.sin_family = AF_INET;
	sock->dest_addr.sin_port = htons(PortNumber);
	/*get the server IP*/
	sock->dest_addr.sin_addr.s_addr = inet_addr(PeerName);
	if (sock->dest_addr.sin_addr.s_addr==INADDR_NONE) {
		GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[Sock_IPV4] Solving %s address\n", PeerName));
		Host = gf_gethostbyname(PeerName);
		if (Host == NULL) {
			GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[Sock_IPV4] Failed to retrieve host %s address: %s\n", PeerName, gf_errno_str(LASTSOCKERROR) ));
			switch (LASTSOCKERROR) {
#ifndef __SYMBIAN32__
			case ENETDOWN:
				return GF_IP_NETWORK_FAILURE;
				//case ENOHOST: return GF_IP_ADDRESS_NOT_FOUND;
#endif
			default:
				return GF_IP_NETWORK_FAILURE;
			}
		}
		GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[Sock_IPV4] Host %s found\n", PeerName));
		memcpy(&sock->dest_addr.sin_addr, Host->h_addr_list[0], sizeof(u8)*Host->h_length);
	}

	if (ifce_ip_or_name) {
		GF_Err e = gf_sk_bind(sock, ifce_ip_or_name, PortNumber, PeerName, PortNumber, GF_SOCK_REUSE_PORT);
		if (e) return e;
	}

#if defined(WIN32) || defined(_WIN32_WCE)
	//on winsock we must check writability between two connects for non-blocking sockets
	if ((sock->flags & GF_SOCK_IS_TCP) && (sock->flags & GF_SOCK_HAS_CONNECT)) {
		if (gf_sk_select(sock, GF_SK_SELECT_WRITE) == GF_IP_NETWORK_EMPTY)
			return GF_IP_NETWORK_EMPTY;
	}
#endif

	if (sock->flags & GF_SOCK_IS_TCP) {
		GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[Sock_IPV4] Connecting to %s:%d\n", PeerName, PortNumber));
	} else if (!use_udp_connect) {
		return GF_OK;
	}
	ret = connect(sock->socket, (struct sockaddr *) &sock->dest_addr, sizeof(struct sockaddr));
	if (ret == SOCKET_ERROR) {
		u32 res = LASTSOCKERROR;

		if (sock->flags & GF_SOCK_NON_BLOCKING) {
			switch (res) {
			case EINPROGRESS:
#if defined(WIN32) || defined(_WIN32_WCE)
			case WSAEWOULDBLOCK:
#endif
				//remember we issued a first connect
				sock->flags |= GF_SOCK_HAS_CONNECT;
				return GF_IP_NETWORK_EMPTY;
			case EISCONN:
			case EALREADY:
#if defined(WIN32) || defined(_WIN32_WCE)
			case WSAEISCONN:
#endif
				if (sock->flags & GF_SOCK_IS_TCP) {
					if (gf_sk_select(sock, GF_SK_SELECT_WRITE) == GF_OK)
						return GF_OK;
				}
				return GF_IP_NETWORK_EMPTY;
			}
		}
		sock->flags &= ~GF_SOCK_HAS_CONNECT;

		switch (res) {
		case EAGAIN:
		case EINTR:
#if defined(WIN32) || defined(_WIN32_WCE)
		case WSAEWOULDBLOCK:
#endif
			return GF_IP_NETWORK_EMPTY;
#ifdef WIN32
		case WSAEINVAL:
			if (sock->flags & GF_SOCK_NON_BLOCKING)
				return GF_IP_NETWORK_EMPTY;
#endif
		case EISCONN:
			return GF_OK;
		default:
			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[Sock_IPV4] Couldn't connect socket: %s\n", gf_errno_str(res)));
			return GF_IP_CONNECTION_FAILURE;
		}
	}
	sock->flags &= ~GF_SOCK_HAS_CONNECT;
	if (sock->flags & GF_SOCK_IS_TCP) {
		GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[Sock_IPV4] Connected to %s:%d\n", PeerName, PortNumber));
	}
#endif
	return GF_OK;
}

GF_EXPORT
GF_Err gf_sk_connect(GF_Socket *sock, const char *PeerName, u16 PortNumber, const char *ifce_ip_or_name)
{
	return gf_sk_connect_ex(sock, PeerName, PortNumber, ifce_ip_or_name, GF_FALSE);

}
//binds the given socket to the specified port. If ReUse is true
//this will enable reuse of ports on a single machine
GF_EXPORT
GF_Err gf_sk_bind_ex(GF_Socket *sock, const char *ifce_ip_or_name, u16 port, const char *peer_name, u16 peer_port, u32 options,
	u8 **dst_sock_addr, u32 *dst_sock_addr_len, u8 **src_sock_addr, u32 *src_sock_addr_len)
{
#ifdef GPAC_HAS_IPV6
	struct addrinfo *res, *aip;
	int af;
	u32 type;
#else
	u32 ip_add;
	size_t addrlen;
	struct sockaddr_in LocalAdd;
	struct hostent *Host = NULL;
#endif
	s32 ret = 0;
	s32 optval;

	if (dst_sock_addr) {
		*dst_sock_addr = NULL;
		*dst_sock_addr_len = 0;
	}
	if (src_sock_addr) {
		*src_sock_addr = NULL;
		*src_sock_addr_len = 0;
	}
	//socket must not be created
	if (!sock || !SOCKET_INVALID(sock->socket)) return GF_BAD_PARAM;
	if (ifce_ip_or_name && !strcmp(ifce_ip_or_name, "127.0.0.1"))
		ifce_ip_or_name = NULL;

	if (sock->flags & GF_SOCK_IS_UN) {
#ifdef GPAC_HAS_SOCK_UN
		struct sockaddr_un server_un;
		sock->socket = socket(AF_UNIX, (sock->flags & GF_SOCK_IS_TCP) ? SOCK_STREAM : SOCK_DGRAM, 0);
		if (sock->flags & GF_SOCK_NON_BLOCKING)
			gf_sk_set_block_mode(sock, GF_TRUE);
		server_un.sun_family = AF_UNIX;
		gf_strcpy(server_un.sun_path, peer_name);
		ret = bind(sock->socket, (struct sockaddr *) &server_un, (int) sizeof(struct sockaddr_un));
		if (ret == SOCKET_ERROR) {
			if (LASTSOCKERROR == EADDRINUSE) {
				return gf_sk_connect(sock, peer_name, peer_port, NULL);
			}
			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[socket] cannot bind socket: %s\n", gf_errno_str(LASTSOCKERROR) ));
			return GF_IP_CONNECTION_FAILURE;
		}
		GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[socket] socket bound to unix domain %s\n", peer_name));
		return GF_OK;
#else
	    return GF_NOT_SUPPORTED;
#endif
	}


#ifndef WIN32
	if (!ifce_ip_or_name && (!peer_name || !strcmp(peer_name,"localhost"))) {
		peer_name="127.0.0.1";
	}
#endif

#ifdef GPAC_HAS_IPV6
	type = (sock->flags & GF_SOCK_IS_TCP) ? SOCK_STREAM : SOCK_DGRAM;
	af = (options & GF_SOCK_FORCE_IPV6) ? PF_INET6 : PF_UNSPEC;
	if (!gf_net_has_ipv6()) af = PF_INET;
	/*probe way to peer: is it V4 or V6? */
	if (peer_name && peer_port) {
		res = gf_sk_get_ipv6_addr(peer_name, peer_port, af, AI_PASSIVE, type);
		if (!res) {
			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[Socket] Cannot get IPV6 host name for %s:%d\n", peer_name, peer_port));
			return GF_IP_ADDRESS_NOT_FOUND;
		}
#ifdef WIN32
		/*win32 has troubles redirecting IPV4 datagrams to IPV6 sockets, so override
		local family type to avoid IPV4(S)->IPV6(C) UDP*/
		af = res->ai_family;
#endif
		memcpy(&sock->dest_addr, res->ai_addr, res->ai_addrlen);
		sock->dest_addr_len = (u32) res->ai_addrlen;
		freeaddrinfo(res);

		if (dst_sock_addr) {
			*dst_sock_addr = gf_malloc(sizeof(u8) * sock->dest_addr_len);
			memcpy(*dst_sock_addr, &sock->dest_addr, sock->dest_addr_len);
			*dst_sock_addr_len = sock->dest_addr_len;
		}
	}

	res = gf_sk_get_ifce_ipv6_addr(ifce_ip_or_name, port, af, AI_PASSIVE, type);
	if (!res) {
		if (dst_sock_addr && *dst_sock_addr) {
			gf_free(*dst_sock_addr);
			*dst_sock_addr = NULL;
		}
		return GF_IP_ADDRESS_NOT_FOUND;
	}

	/*for all interfaces*/
	for (aip=res; aip!=NULL; aip=aip->ai_next) {
		if (type != (u32) aip->ai_socktype) continue;

		if (aip->ai_next && (aip->ai_next->ai_family==PF_INET) && !gf_net_is_ipv6(peer_name)) continue;

#ifndef GPAC_DISABLE_NETCAP
		if (sock->cap_info) {
			sock->cap_info->host_port = port ? port : peer_port;
			if (aip->ai_family==PF_INET) {
				sock->cap_info->host_addr_v4 = inet_addr_from_name(peer_name ? peer_name : ifce_ip_or_name);
			} else {
				memcpy(sock->cap_info->host_addr_v6, (u8*) &((struct sockaddr_in6 *)aip->ai_addr)->sin6_addr, sizeof(bin128));
			}
			if (peer_name && peer_port) {
				if (sock->dest_addr.ss_family==AF_INET) {
					struct sockaddr_in *r_add = (struct sockaddr_in *) &sock->dest_addr;
					sock->cap_info->peer_port = ntohs(r_add->sin_port);
					sock->cap_info->peer_addr_v4 = r_add->sin_addr.s_addr;
				} else {
					struct sockaddr_in6 *r_add = (struct sockaddr_in6 *) &sock->dest_addr;
					sock->cap_info->peer_port = ntohs(r_add->sin6_port);
					memcpy(sock->cap_info->peer_addr_v6, &(r_add->sin6_addr), sizeof(bin128));
				}
			}
			//play/record, don't create socket
			if (sock->cap_info->nf->cap_mode) {
				if (aip->ai_family==PF_INET6) sock->flags |= GF_SOCK_IS_IPV6;
				else sock->flags &= ~GF_SOCK_IS_IPV6;

				freeaddrinfo(res);
				if (dst_sock_addr && *dst_sock_addr) {
					gf_free(*dst_sock_addr);
					*dst_sock_addr = NULL;
				}
				return GF_OK;
			}
		}
#endif
		sock->socket = socket(aip->ai_family, aip->ai_socktype, aip->ai_protocol);
		if (SOCKET_INVALID(sock->socket)) {
			continue;
		}
		if (options & GF_SOCK_REUSE_PORT) {
			optval = 1;
			setsockopt(sock->socket, SOL_SOCKET, SO_REUSEADDR, (const char *) &optval, sizeof(optval));
#ifdef SO_REUSEPORT
			optval = 1;
			setsockopt(sock->socket, SOL_SOCKET, SO_REUSEPORT, SSO_CAST &optval, sizeof(optval));
#endif
		}

		if (sock->flags & GF_SOCK_NON_BLOCKING)
			gf_sk_set_block_mode(sock, GF_TRUE);

		if (peer_name && peer_port) {
			sock->flags |= GF_SOCK_HAS_PEER;
		}

#if defined(GPAC_CONFIG_LINUX) || defined(GPAC_CONFIG_DARWIN)
		//we use implicit bind (assign on first sendto) - not doing so makes poll/select fail in readers lanched after the sender
		if (peer_name && !strcmp(peer_name, "127.0.0.1") && (options & GF_SOCK_IS_SENDER)) {
		} else
#endif
		{
			ret = bind(sock->socket, aip->ai_addr, (int) aip->ai_addrlen);
			if (ret == SOCKET_ERROR) {
				if (dst_sock_addr && *dst_sock_addr) {
					gf_free(*dst_sock_addr);
					*dst_sock_addr = NULL;
				}
				sock_close(sock);
				if (!(options & GF_SOCK_REUSE_PORT) && (LASTSOCKERROR == EADDRINUSE)) {
					return GF_IP_CONNECTION_FAILURE;
				}
				GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[socket] bind failed: %s\n", gf_errno_str(LASTSOCKERROR) ));
				continue;
			}
		}
		if (aip->ai_family==PF_INET6) sock->flags |= GF_SOCK_IS_IPV6;
		else sock->flags &= ~GF_SOCK_IS_IPV6;

		if (src_sock_addr) {
			*src_sock_addr = gf_malloc(sizeof(u8) * res->ai_addrlen);
			memcpy(*src_sock_addr, res->ai_addr, res->ai_addrlen);
			*src_sock_addr_len = (u32) res->ai_addrlen;
		}

		freeaddrinfo(res);
		return GF_OK;
	}
	freeaddrinfo(res);
	if (dst_sock_addr && *dst_sock_addr) {
		gf_free(*dst_sock_addr);
		*dst_sock_addr = NULL;
	}
	GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[Socket] Cannot bind to ifce %s port %d\n", ifce_ip_or_name ? ifce_ip_or_name : "any", port));
	return GF_IP_NETWORK_FAILURE;

#else

#ifndef GPAC_DISABLE_NETCAP
	if (sock->cap_info) {
		sock->cap_info->host_port = port ? port : peer_port;
		sock->cap_info->host_addr_v4 = inet_addr_from_name(ifce_ip_or_name);
		if (peer_name && peer_port) {
			sock->cap_info->peer_port = peer_port;
			sock->cap_info->peer_addr_v4 = inet_addr_from_name(peer_name);
			sock->flags |= GF_SOCK_HAS_PEER;
		}
		//play/record, don't create socket
		if (sock->cap_info->nf->cap_mode) {
			return GF_OK;
		}
	}
#endif

	sock->socket = socket(AF_INET, (sock->flags & GF_SOCK_IS_TCP) ? SOCK_STREAM : SOCK_DGRAM, 0);
	if (sock->flags & GF_SOCK_NON_BLOCKING)
		gf_sk_set_block_mode(sock, GF_TRUE);
	sock->flags &= ~GF_SOCK_IS_IPV6;

	memset((void *) &LocalAdd, 0, sizeof(LocalAdd));

	/*setup the address*/
	ip_add = inet_addr_from_name(ifce_ip_or_name);
	if (ip_add==0xFFFFFFFF) return GF_IP_CONNECTION_FAILURE;

	if (peer_name && peer_port) {
#ifdef WIN32
		if ((inet_addr(peer_name)== ip_add) || !strcmp(peer_name, "127.0.0.1") ) {
			optval = 1;
			setsockopt(sock->socket, SOL_SOCKET, SO_USELOOPBACK, SSO_CAST &optval, sizeof(optval));
		}
#endif
	}

	LocalAdd.sin_family = AF_INET;
	LocalAdd.sin_port = htons(port);
	LocalAdd.sin_addr.s_addr = ip_add;
	addrlen = sizeof(struct sockaddr_in);

	if (src_sock_addr) {
		*src_sock_addr = gf_malloc(sizeof(u8) * addrlen);
		memcpy(*src_sock_addr, &LocalAdd, addrlen);
		*src_sock_addr_len = addrlen;
	}

	if (options & GF_SOCK_REUSE_PORT) {
		optval = 1;
		setsockopt(sock->socket, SOL_SOCKET, SO_REUSEADDR, SSO_CAST &optval, sizeof(optval));
#ifdef SO_REUSEPORT
		optval = 1;
		setsockopt(sock->socket, SOL_SOCKET, SO_REUSEPORT, SSO_CAST &optval, sizeof(optval));
#endif
	}

	/*bind the socket*/
#ifdef GPAC_CONFIG_LINUX
	//see above comment
	if (peer_name && !strcmp(peer_name, "127.0.0.1") && (options & GF_SOCK_IS_SENDER) ) {
	} else
#endif
	{
		ret = bind(sock->socket, (struct sockaddr *) &LocalAdd, (int) addrlen);
		if (ret == SOCKET_ERROR) {
			if (!(options & GF_SOCK_REUSE_PORT) && (LASTSOCKERROR == EADDRINUSE)) {
				if (src_sock_addr && *src_sock_addr) {
					gf_free(*src_sock_addr);
					*src_sock_addr = NULL;
				}
				return GF_IP_CONNECTION_FAILURE;
			}
			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[socket] cannot bind socket: %s\n", gf_errno_str(LASTSOCKERROR) ));
			ret = GF_IP_NETWORK_FAILURE;
		}
	}

	if (peer_name && peer_port) {
		sock->dest_addr.sin_port = htons(peer_port);
		sock->dest_addr.sin_family = AF_INET;
		sock->dest_addr.sin_addr.s_addr = inet_addr(peer_name);
		if (sock->dest_addr.sin_addr.s_addr == INADDR_NONE) {
			Host = gf_gethostbyname(peer_name);
			if (Host == NULL) ret = GF_IP_ADDRESS_NOT_FOUND;
			else memcpy((char *) &sock->dest_addr.sin_addr, Host->h_addr_list[0], sizeof(u32));
		}
		sock->flags |= GF_SOCK_HAS_PEER;

		if (dst_sock_addr && !ret) {
			*dst_sock_addr = gf_malloc(sizeof(u8) * sock->dest_addr_len);
			memcpy(*dst_sock_addr, &sock->dest_addr, sock->dest_addr_len);
			*dst_sock_addr_len = sock->dest_addr_len;
		}
	}
	if (sock->flags & GF_SOCK_HAS_PEER) {
		GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[socket] socket bound to %08X - port %d - remote peer: %s:%d\n", ip_add, port, peer_name, peer_port));
	} else {
		GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[socket] socket bound to %08X - port %d\n", ip_add, port));
	}
	return ret;
#endif
}

GF_EXPORT
GF_Err gf_sk_bind(GF_Socket *sock, const char *ifce_ip_or_name, u16 port, const char *peer_name, u16 peer_port, u32 options)
{
	return gf_sk_bind_ex(sock, ifce_ip_or_name, port, peer_name, peer_port, options, NULL, NULL, NULL, NULL);
}

Bool gpac_use_poll=GF_TRUE;

static GF_Err poll_select(GF_Socket *sock, GF_SockSelectMode mode, u32 usec, Bool force_select)
{
#ifndef __SYMBIAN32__
	int ready;
	struct timeval timeout;

#ifdef GPAC_HAS_POLL
	if (!force_select && gpac_use_poll) {
		struct pollfd pfd;
		pfd.fd = sock->socket;
		pfd.revents = 0;
		if (mode == GF_SK_SELECT_WRITE) {
			//ugly patch, poll(timeout=0) sometimes crash on arm64 linux... (M4, ubuntu24 vm)
#if defined(GPAC_CONFIG_ARM) && defined(GPAC_CONFIG_LINUX)
			if (usec<1000) usec = 1000;
#endif
			pfd.events = POLLOUT;
		}
		else if (mode == GF_SK_SELECT_READ) pfd.events = POLLIN;
		else pfd.events = POLLIN|POLLOUT;

		ready = poll(&pfd, 1, usec/1000);
		if (ready<0) {
			switch (LASTSOCKERROR) {
			case EAGAIN:
			case EINTR:
				return GF_IP_NETWORK_EMPTY;
			default:
				GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[socket] cannot poll: %s\n", gf_errno_str(LASTSOCKERROR) ));
				return GF_IP_NETWORK_FAILURE;
			}
		}
		if (!ready)
			return GF_IP_NETWORK_EMPTY;

		if ((mode == GF_SK_SELECT_WRITE) && !(pfd.revents & POLLOUT))
			return GF_IP_NETWORK_EMPTY;
		if ((mode == GF_SK_SELECT_READ) && !(pfd.revents & POLLIN))
			return GF_IP_NETWORK_EMPTY;

		return GF_OK;
	}
#endif

	fd_set rgroup, wgroup;

	//can we write?
	FD_ZERO(&rgroup);
	FD_ZERO(&wgroup);
	if (mode != GF_SK_SELECT_WRITE)
		FD_SET(sock->socket, &rgroup);
	if (mode != GF_SK_SELECT_READ)
		FD_SET(sock->socket, &wgroup);
	timeout.tv_sec = 0;
	timeout.tv_usec = usec;

	ready = select((int) sock->socket+1,
		(mode != GF_SK_SELECT_WRITE) ? &rgroup : NULL,
		(mode != GF_SK_SELECT_READ) ? &wgroup : NULL,
		 NULL, &timeout);

	if (ready == SOCKET_ERROR) {
		switch (LASTSOCKERROR) {
		case EAGAIN:
		case EINTR:
			return GF_IP_NETWORK_EMPTY;
		default:
			GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[socket] select failure: %s\n", gf_errno_str(LASTSOCKERROR)));
			return GF_IP_NETWORK_FAILURE;
		}
	}
	if (!ready)
		return GF_IP_NETWORK_EMPTY;
	if ((mode == GF_SK_SELECT_WRITE) && !FD_ISSET(sock->socket, &wgroup))
		return GF_IP_NETWORK_EMPTY;
	if ((mode == GF_SK_SELECT_READ) && !FD_ISSET(sock->socket, &rgroup))
		return GF_IP_NETWORK_EMPTY;
	//if mode is both and we are ready, let's go
	return GF_OK;
#endif
}

//send length bytes of a buffer
static GF_Err gf_sk_send_internal(GF_Socket *sock, const u8 *buffer, u32 length, const u8 *address, u32 address_len, u32 *written)
{
	u32 count;
	s32 res;

	if (written) *written = 0;
#ifndef GPAC_DISABLE_NETCAP
	if (netcap_filter_pck(sock, length, GF_TRUE)) {
		if (written) *written = length;
		return GF_OK;
	}
	if (sock->cap_info) {
		if (sock->cap_info->patch_offset) {
			((u8*)buffer)[sock->cap_info->patch_offset-1] = sock->cap_info->patch_val;
			sock->cap_info->patch_offset = 0;
		}
		if (sock->cap_info->nf->read_socks==NULL)
			return gf_netcap_send(sock, buffer, length, written);

		if (sock->cap_info->nf->read_socks)
			return GF_OK;
	}
#endif

	//the socket must be bound or connected
	if (!sock || SOCKET_INVALID(sock->socket))
		return GF_BAD_PARAM;

	if (! (sock->flags & GF_SOCK_NON_BLOCKING)) {
		//check write
		GF_Err e = poll_select(sock, GF_SK_SELECT_WRITE, sock->usec_wait, GF_FALSE);
		if (e) return e;
	}

	//direct writing
	count = 0;
	while (count < length) {
		int sflags = 0;
#ifdef MSG_NOSIGNAL
		sflags = MSG_NOSIGNAL;
#endif
		if (sock->flags & GF_SOCK_HAS_PEER) {
			res = (s32) sendto(sock->socket, (char *) buffer+count,  length - count, 0, (struct sockaddr *) &sock->dest_addr, sock->dest_addr_len);
		} else if (address && address_len) {
			res = (s32) sendto(sock->socket, (char *) buffer+count,  length - count, 0, (struct sockaddr *) address, address_len);
		} else {
			res = (s32) send(sock->socket, (char *) buffer+count, length - count, sflags);
		}
		if (res == SOCKET_ERROR) {
			switch (res = LASTSOCKERROR) {
			case EAGAIN:
			case EINTR:
				return GF_IP_NETWORK_EMPTY;
#ifndef __SYMBIAN32__
			case ENOTCONN:
			case ECONNRESET:
			case EPIPE:
				GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[socket] send failure: %s\n", gf_errno_str(LASTSOCKERROR)));
				return GF_IP_CONNECTION_CLOSED;
#endif

#ifndef __DARWIN__
			case EPROTOTYPE:
				return GF_IP_NETWORK_EMPTY;
#endif
			case ENOBUFS:
				GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[socket] send failure: %s\n", gf_errno_str(LASTSOCKERROR)));
				return GF_BUFFER_TOO_SMALL;
			default:
				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[socket] send failure: %s\n", gf_errno_str(LASTSOCKERROR)));
				return GF_IP_NETWORK_FAILURE;
			}
		}
		count += res;
		if (written) *written += res;
		GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[socket] sent %u bytes\n", count ));
	}
	return GF_OK;
}

GF_EXPORT
GF_Err gf_sk_send_ex(GF_Socket *sock, const u8 *buffer, u32 length, u32 *written)
{
	return gf_sk_send_internal(sock, buffer, length, NULL, 0, written);
}
GF_EXPORT
GF_Err gf_sk_send(GF_Socket *sock, const u8 *buffer, u32 length)
{
	return gf_sk_send_internal(sock, buffer, length, NULL, 0, NULL);
}
GF_EXPORT
GF_Err gf_sk_send_to(GF_Socket *sock, const u8 *buffer, u32 length, const u8 *addr, u32 addr_len, u32 *written)
{
	return gf_sk_send_internal(sock, buffer, length, addr, addr_len, written);
}


GF_Err gf_sk_select(GF_Socket *sock, GF_SockSelectMode mode)
{
	//the socket must be bound or connected
	if (!sock || SOCKET_INVALID(sock->socket))
		return GF_BAD_PARAM;

	//check write and read
	return poll_select(sock, mode, sock->usec_wait, GF_FALSE);
}


GF_EXPORT
u32 gf_sk_is_multicast_address(const char *multi_IPAdd)
{
	if (!multi_IPAdd) return 0;
#ifdef GPAC_HAS_IPV6
	u32 val;
	char *sep;
	struct addrinfo *res;
	if (gf_net_is_ipv6(multi_IPAdd)) {
		/*IPV6 multicast address*/
		sep = strchr(multi_IPAdd, ':');
		if (sep) sep = strchr(multi_IPAdd, ':');
		if (sep && !strnicmp(multi_IPAdd, "ff", 2)) return 1;
		//mapped address
		if (!strnicmp(multi_IPAdd, "::ffff:", 7)) multi_IPAdd+=7;
		/*ipv4 multicast address*/
		res = gf_sk_get_ipv6_addr((char*)multi_IPAdd, 7000, AF_UNSPEC, AI_PASSIVE, SOCK_DGRAM);
		if (!res) return 0;
		val = 0;
		if (res->ai_addr->sa_family == AF_INET) {
			val = IN_MULTICAST(ntohl(((struct sockaddr_in *)res->ai_addr)->sin_addr.s_addr));
		} else if (res->ai_addr->sa_family == AF_INET6) {
			val = IN6_IS_ADDR_MULTICAST(& ((struct sockaddr_in6 *)res->ai_addr)->sin6_addr);
		}
		freeaddrinfo(res);
		return val;
	}
#endif
	return ((htonl(inet_addr(multi_IPAdd)) >> 8) & 0x00f00000) == 0x00e00000;
}

static GF_Err sk_join_ipv4(GF_Socket *sock, struct ip_mreq *M_req, u32 TTL, const char **src_ip_inc, u32 nb_src_ip_inc, const char **src_ip_exc, u32 nb_src_ip_exc)
{
	s32 ret;
	u32 flag;

	if (nb_src_ip_inc) {
#ifdef IP_ADD_SOURCE_MEMBERSHIP
		u32 i;
		struct ip_mreq_source M_req_src;
		M_req_src.imr_multiaddr = M_req->imr_multiaddr;
		M_req_src.imr_interface = M_req->imr_interface;

		for (i=0; i<nb_src_ip_inc; i++) {
			if (gf_net_is_ipv6(src_ip_inc[i])) {
				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] IPv6 SSM source on IPv4 Mcast address, ignoring\n", src_ip_inc[i]));
				continue;
			}
			M_req_src.imr_sourceaddr.s_addr = inet_addr(src_ip_inc[i]);
			ret = setsockopt(sock->socket, IPPROTO_IP, IP_ADD_SOURCE_MEMBERSHIP, (char *) &M_req_src, sizeof(M_req_src) );
			if (ret == SOCKET_ERROR) {
				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] cannot add source membership for %s: %s\n", src_ip_inc[i], gf_errno_str(LASTSOCKERROR)));
				return GF_IP_CONNECTION_FAILURE;
			}
		}
#else
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] SSM IPv4 not supported\n"));
		return GF_NOT_SUPPORTED;
#endif
	} else {
		ret = setsockopt(sock->socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) M_req, sizeof(*M_req));
		if (ret == SOCKET_ERROR) {
			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] cannot join multicast: %s\n", gf_errno_str(LASTSOCKERROR)));
			return GF_IP_CONNECTION_FAILURE;
		}
	}
	/*set the Time To Live*/
	if (TTL) {
		ret = setsockopt(sock->socket, IPPROTO_IP, IP_MULTICAST_TTL, (char *)&TTL, sizeof(TTL));
		if (ret == SOCKET_ERROR) {
			GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[Socket] Cannot set TTL: %s\n", gf_errno_str(LASTSOCKERROR) ));
			return GF_IP_CONNECTION_FAILURE;
		}
	}

	/*enable loopback*/
	flag = 1;
	ret = setsockopt(sock->socket, IPPROTO_IP, IP_MULTICAST_LOOP, (char *) &flag, sizeof(flag));
	if (ret == SOCKET_ERROR) {
		GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[Socket] Cannot enable multicast loop: %s - ignoring\n", gf_errno_str(LASTSOCKERROR) ));
	}

#ifdef IP_BLOCK_SOURCE
	if (nb_src_ip_exc) {
		u32 i, j;
		struct ip_mreq_source M_req_exc;
		M_req_exc.imr_multiaddr = M_req->imr_multiaddr;
		M_req_exc.imr_interface = M_req->imr_interface;
		for (i=0; i<nb_src_ip_exc; i++) {
			Bool match=GF_FALSE;
			if (gf_net_is_ipv6(src_ip_exc[i])) {
				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] IPv6 SSM source on IPv4 Mcast address, ignoring\n", src_ip_exc[i]));
				continue;
			}
			for (j=0; j<nb_src_ip_inc; j++) {
				if (!strcmp(src_ip_inc[j], src_ip_exc[i])) match=GF_TRUE;
			}
			if (match) continue;

			M_req_exc.imr_sourceaddr.s_addr = inet_addr(src_ip_exc[i]);
			ret = setsockopt(sock->socket, IPPROTO_IP, IP_BLOCK_SOURCE, (char *) &M_req_exc, sizeof(M_req_exc) );
			if (ret == SOCKET_ERROR) {
				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] cannot block source membership for %s: %s\n", src_ip_exc[i], gf_errno_str(LASTSOCKERROR)));
				return GF_IP_CONNECTION_FAILURE;
			}
		}
	}
#else
	GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[core] SSM IPv4 not supported\n"));
#endif
	return GF_OK;
}

static u32 inet_addr_from_name(const char *local_interface)
{
	if (!local_interface) return htonl(INADDR_ANY);

	if (strchr(local_interface, '.'))
		return inet_addr(local_interface);

	Bool name_match = GF_FALSE;
	u32 ret = 0;

#if defined(GPAC_WIN_HAS_ADAPTER_INFO)
	IP_ADAPTER_ADDRESSES *AdapterInfo = malloc(sizeof(IP_ADAPTER_ADDRESSES));
	IP_ADAPTER_ADDRESSES *ifa = NULL;
	ULONG ulOutBufLen = sizeof(AdapterInfo);
	if (AdapterInfo && (GetAdaptersAddresses(AF_INET, 0, NULL, AdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW)) {
		free(AdapterInfo);
		AdapterInfo = malloc(sizeof(IP_ADAPTER_ADDRESSES)*ulOutBufLen);
	}
	if (AdapterInfo)
		GetAdaptersAddresses(AF_INET, 0, NULL, AdapterInfo, &ulOutBufLen);

	ifa = AdapterInfo;
	while (ifa) {
		Bool match = GF_FALSE;
		if (!strcmp(ifa->AdapterName, local_interface)) match = GF_FALSE;
		char *name = gf_wcs_to_utf8(ifa->FriendlyName);
		if (name) {
			if (!strcmp(name, local_interface)) match = GF_TRUE;
			gf_free(name);
		}
		if (match) name_match = GF_TRUE;

		if (!match || !ifa->FirstUnicastAddress || !ifa->FirstUnicastAddress->Address.lpSockaddr) {
			ifa = ifa->Next;
			continue;
		}
		ret = ((struct sockaddr_in*)ifa->FirstUnicastAddress->Address.lpSockaddr)->sin_addr.s_addr;
		break;
	}
	if (AdapterInfo)
		free(AdapterInfo);
#endif

#if defined(GPAC_HAS_IFADDRS)
	struct ifaddrs *ifap=NULL, *res;
	getifaddrs(&ifap);
	res = ifap;
	while (res) {
		if (res->ifa_name && !strcmp(res->ifa_name, local_interface)) {
			name_match = GF_TRUE;
			if (res->ifa_addr && (res->ifa_addr->sa_family==AF_INET)) {
				ret = ((struct sockaddr_in*)res->ifa_addr)->sin_addr.s_addr;
				break;
			}
		}
		res = res->ifa_next;
	}
	freeifaddrs(ifap);
#endif
	if (!name_match) {
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] No such interface %s\n", local_interface));
		return 0xFFFFFFFF;
	}
	if (!ret) {
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] Interface %s found but has no IPv4 addressing, using INADDR_ANY\n", local_interface));
		return htonl(INADDR_ANY);
	}
	return ret;
}

GF_EXPORT
Bool gf_net_enum_interfaces(gf_net_ifce_enum do_enum, void *enum_cbk)
{
#if defined(GPAC_WIN_HAS_ADAPTER_INFO)
	IP_ADAPTER_ADDRESSES *AdapterInfo = malloc(sizeof(IP_ADAPTER_ADDRESSES));
	IP_ADAPTER_ADDRESSES *ifa = NULL;
	ULONG ulOutBufLen = sizeof(AdapterInfo);
	if (AdapterInfo && (GetAdaptersAddresses(AF_UNSPEC, 0, NULL, AdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW)) {
		free(AdapterInfo);
		AdapterInfo = malloc(sizeof(IP_ADAPTER_ADDRESSES)*ulOutBufLen);
	}
	if (AdapterInfo)
		GetAdaptersAddresses(AF_UNSPEC, 0, NULL, AdapterInfo, &ulOutBufLen);

	ifa = AdapterInfo;
	while (ifa) {
		if (ifa->FirstUnicastAddress) {
			char szIP[100];
			szIP[0] = 0;
			u32 flags = 0;
			if (ifa->OperStatus == 1) flags |= GF_NETIF_ACTIVE;
			if (ifa->Flags & IP_ADAPTER_NO_MULTICAST) flags |= GF_NETIF_NO_MCAST;
			if (ifa->Flags & IP_ADAPTER_RECEIVE_ONLY) flags |= GF_NETIF_RECV_ONLY;
			if (ifa->IfType == IF_TYPE_SOFTWARE_LOOPBACK) flags |= GF_NETIF_LOOPBACK;

			Bool abort=GF_FALSE;
			IP_ADAPTER_UNICAST_ADDRESS_LH *ipadd = ifa->FirstUnicastAddress;
			while (ipadd) {
				u32 sa_fam = ipadd->Address.lpSockaddr ? ipadd->Address.lpSockaddr->sa_family : AF_UNSPEC;
				if (ipadd->Flags & IP_ADAPTER_ADDRESS_TRANSIENT) sa_fam = AF_UNSPEC;
				if ((sa_fam == AF_INET) || (sa_fam == AF_INET6)) {
					my_inet_ntop(sa_fam, ipadd->Address.lpSockaddr, szIP, 100);
					char *name = gf_wcs_to_utf8(ifa->FriendlyName);
					Bool res = do_enum(enum_cbk, name ? name : ifa->AdapterName, szIP[0] ? szIP : NULL, flags | ((sa_fam==AF_INET6) ? GF_NETIF_IPV6 : 0));
					if (name) gf_free(name);
					if (res) break;
				}
				ipadd = ipadd->Next;
			}
			if (abort) break;
		}
		ifa = ifa->Next;
	}
	if (AdapterInfo)
		free(AdapterInfo);
	return GF_TRUE;
#endif

#if defined(GPAC_HAS_IFADDRS)
	struct ifaddrs *ifap=NULL, *res;
	getifaddrs(&ifap);
	res = ifap;
	while (res) {
		if (res->ifa_addr) {
			char szIP[100];
			szIP[0] = 0;
			u32 flags=0;
			if (res->ifa_flags & IFF_UP) flags |= GF_NETIF_ACTIVE;
			if (res->ifa_flags & IFF_LOOPBACK) flags |= GF_NETIF_LOOPBACK;
			if (!(res->ifa_flags & IFF_MULTICAST)) flags |= GF_NETIF_NO_MCAST;

			if (res->ifa_addr->sa_family==AF_INET) {
				inet_ntop(AF_INET, &( ((struct sockaddr_in *)res->ifa_addr)->sin_addr), szIP, 100);
				if (do_enum(enum_cbk, res->ifa_name, szIP[0] ? szIP : NULL, flags))
					break;
			}
			if (res->ifa_addr->sa_family==AF_INET6) {
				inet_ntop(AF_INET6, &( ((struct sockaddr_in6 *)res->ifa_addr)->sin6_addr), szIP, 100);
				if (do_enum(enum_cbk, res->ifa_name, szIP[0] ? szIP : NULL, flags|GF_NETIF_IPV6))
					break;
			}
		}
		res = res->ifa_next;
	}
	freeifaddrs(ifap);
	return GF_TRUE;
#endif
	return GF_FALSE;
}

typedef struct
{
	const char *ip_or_name;
	char *res_v6, *res_v4;
} GetIPInfo;

static Bool get_ifce_enum(void *cbk, const char *name, const char *IP, u32 flags)
{
	GetIPInfo *info = (GetIPInfo*)cbk;
	if (strcmp(info->ip_or_name, name) && strcmp(info->ip_or_name, IP)) return GF_FALSE;
	if (flags & GF_NETIF_IPV6) {
		if (!info->res_v6) info->res_v6 = gf_strdup(IP);
	} else {
		if (!info->res_v4) info->res_v4 = gf_strdup(IP);
	}
	return GF_FALSE;
}

Bool gf_net_get_adapter_ip(const char *ip_or_name, char **ipv4, char **ipv6)
{
	GetIPInfo info;
	info.ip_or_name = ip_or_name;
	info.res_v4 = info.res_v6 = NULL;
	if (ipv4) *ipv4 = NULL;
	if (ipv6) *ipv6 = NULL;
	if (!ip_or_name) return GF_FALSE;
	Bool res = gf_net_enum_interfaces(get_ifce_enum, &info);
	if (!res) return GF_FALSE;
	if (ipv4) *ipv4 = info.res_v4;
	else if (info.res_v4) gf_free(info.res_v4);
	if (ipv6) *ipv6 = info.res_v6;
	else if (info.res_v6) gf_free(info.res_v6);
	return GF_TRUE;
}

GF_EXPORT
GF_Err gf_sk_setup_multicast_ex(GF_Socket *sock, const char *multi_IPAdd, u16 MultiPortNumber, u32 TTL, Bool NoBind, const char *ifce_ip_or_name,
	const char **src_ip_inc, u32 nb_src_ip_inc, const char **src_ip_exc, u32 nb_src_ip_exc)
{
	s32 ret;
	struct ip_mreq M_req;
	u32 optval;
#ifdef GPAC_HAS_IPV6
	struct sockaddr *addr;
	Bool mcast_ipv6 = GF_FALSE;
	Bool ifce_ipv6 = GF_FALSE;
	u32 type;
#endif
	GF_Err e;
	u32 local_add_id;

	//socket must not be created
	if (!sock || !SOCKET_INVALID(sock->socket)) return GF_BAD_PARAM;

	if (TTL > 255) TTL = 255;

	/*check the address*/
	if (!gf_sk_is_multicast_address(multi_IPAdd)) return GF_BAD_PARAM;


#ifdef GPAC_HAS_IPV6
	mcast_ipv6 = gf_net_is_ipv6(multi_IPAdd);
	ifce_ipv6 = gf_net_is_ipv6(ifce_ip_or_name);
	if (ifce_ip_or_name && (ifce_ip_or_name[0]=='+')) {
		ifce_ip_or_name += 1;
		ifce_ipv6 = GF_TRUE;
	}
	if (ifce_ip_or_name && !ifce_ip_or_name[0])
		ifce_ip_or_name=NULL;

	type = (sock->flags & GF_SOCK_IS_TCP) ? SOCK_STREAM : SOCK_DGRAM;

	if (mcast_ipv6 || ifce_ipv6) {
		Bool is_mapped_v4=GF_FALSE;
		struct addrinfo *res, *aip;
		struct ipv6_mreq M_reqV6;
		memset(&M_reqV6, 0, sizeof(struct ipv6_mreq));

		//get interface index - force IPV6 when getting address and store result
		if (ifce_ip_or_name) {
#if defined(GPAC_WIN_HAS_ADAPTER_INFO)
			IP_ADAPTER_ADDRESSES *AdapterInfo = malloc(sizeof(IP_ADAPTER_ADDRESSES));
			ULONG ulOutBufLen = sizeof(AdapterInfo);
			if (AdapterInfo && (GetAdaptersAddresses(AF_UNSPEC, 0, NULL, AdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW)) {
				free(AdapterInfo);
				AdapterInfo = malloc(sizeof(IP_ADAPTER_ADDRESSES)*ulOutBufLen);
			}
			if (AdapterInfo)
				GetAdaptersAddresses(AF_UNSPEC, 0, NULL, AdapterInfo, &ulOutBufLen);

			IP_ADAPTER_ADDRESSES *ifa = AdapterInfo;
			while (ifa) {
				//match by adapter name
				if (!strcmp(ifa->AdapterName, ifce_ip_or_name)) {
					M_reqV6.ipv6mr_interface = ifa->Ipv6IfIndex;
					break;
				}
				char *name = gf_wcs_to_utf8(ifa->FriendlyName);
				if (name && !strcmp(name, ifce_ip_or_name)) {
					M_reqV6.ipv6mr_interface = ifa->Ipv6IfIndex;
					gf_free(name);
					break;
				}
				if (name) gf_free(name);
				name = gf_wcs_to_utf8(ifa->Description);
				if (!strcmp(name, ifce_ip_or_name)) {
					M_reqV6.ipv6mr_interface = ifa->Ipv6IfIndex;
					gf_free(name);
					break;
				}
				if (name) gf_free(name);

				//match by IP
				IP_ADAPTER_UNICAST_ADDRESS_LH *ipadd = ifa->FirstUnicastAddress;
				while (ipadd) {
					u32 sa_fam = ipadd->Address.lpSockaddr ? ipadd->Address.lpSockaddr->sa_family : AF_UNSPEC;
					if ((sa_fam == AF_INET) || (sa_fam == AF_INET6)) {
						char szIP[100];
						my_inet_ntop(sa_fam, ipadd->Address.lpSockaddr, szIP, 100);
						if (!strcmp(szIP, ifce_ip_or_name)) {
							M_reqV6.ipv6mr_interface = ifa->Ipv6IfIndex;
							break;
						}
					}
					ipadd = ipadd->Next;
				}

				ifa = ifa->Next;
			}
			if (AdapterInfo) free(AdapterInfo);
#endif

#if defined(GPAC_HAS_IFADDRS)
			//get sockaddr if this is an IP address and compare with enumerated interface
			aip = NULL;
			if (ifce_ip_or_name && strpbrk(ifce_ip_or_name, ".:")) {
				aip = gf_sk_get_ipv6_addr(ifce_ip_or_name, MultiPortNumber, ifce_ipv6 ? AF_INET6 : AF_UNSPEC, AI_PASSIVE, type);
			}
			struct ifaddrs *ifap=NULL, *ifa;
			getifaddrs(&ifap);
			ifa = ifap;
			while (ifa) {
				//match by ifce name
				if (ifa->ifa_addr && !strcmp(ifa->ifa_name, ifce_ip_or_name)
					&& ((ifa->ifa_addr->sa_family == AF_INET) || (ifa->ifa_addr->sa_family == AF_INET6))
				) {
					M_reqV6.ipv6mr_interface = if_nametoindex(ifa->ifa_name);
					break;
				}
				//match by ifce IP
				if (aip && ifa->ifa_addr) {
					struct sockaddr_in6 *in6_a = (struct sockaddr_in6 *)aip->ai_addr;
					struct sockaddr_in6 *in6_b = (struct sockaddr_in6 *)ifa->ifa_addr;
					if ((in6_a->sin6_family == in6_b->sin6_family)
						&& !memcmp(&in6_a->sin6_addr, &in6_b->sin6_addr, sizeof(struct in6_addr))
					) {

						M_reqV6.ipv6mr_interface = if_nametoindex(ifa->ifa_name);
						break;
					}
				}
				ifa = ifa->ifa_next;
			}
			if (ifap)
				freeifaddrs(ifap);
			if (aip)
				freeaddrinfo(aip);
#endif

			if (!M_reqV6.ipv6mr_interface) {
				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] Failed to query interface index for %s\n", ifce_ip_or_name ));
				return GF_IP_CONNECTION_FAILURE;
			}
		}

		//do not specify local_interface_ip address
		res = gf_sk_get_ipv6_addr(NULL, MultiPortNumber, ifce_ipv6 ? AF_INET6 : AF_UNSPEC, AI_PASSIVE, type);
		if (!res) return GF_IP_CONNECTION_FAILURE;

		/*for all interfaces*/
		for (aip=res; aip!=NULL; aip=aip->ai_next) {
			if (type != (u32) aip->ai_socktype) continue;
			//we have a v4 multicast address
			if (!gf_net_is_ipv6(multi_IPAdd)) {
				//if not v4 and next is v4, use next
				if ((aip->ai_family!=PF_INET) && aip->ai_next && (aip->ai_next->ai_family==PF_INET)) continue;
			} else {
				//we want v6, if v4 and next is v6, use next
				if ((aip->ai_family==PF_INET) && aip->ai_next && (aip->ai_next->ai_family==PF_INET6)) continue;
			}
			sock->socket = socket(aip->ai_family, aip->ai_socktype, aip->ai_protocol);
			if (SOCKET_INVALID(sock->socket)) {
				continue;
			}

			/*enable address reuse*/
			optval = 1;
			setsockopt(sock->socket, SOL_SOCKET, SO_REUSEADDR, (const char *) &optval, sizeof(optval));
#ifdef SO_REUSEPORT
			optval = 1;
			setsockopt(sock->socket, SOL_SOCKET, SO_REUSEPORT, SSO_CAST &optval, sizeof(optval));
#endif

			if (!mcast_ipv6 && (aip->ai_family == PF_INET6)) {
				optval = 0;
				ret = setsockopt(sock->socket, IPPROTO_IPV6, IPV6_V6ONLY, (const char *)&optval, sizeof(optval));
				if (ret == SOCKET_ERROR) {
					GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[Socket] Cannot disable ipv6only: %s\n", gf_errno_str(LASTSOCKERROR)));
				}
			}

			if (!NoBind) {
				ret = bind(sock->socket, (struct sockaddr *) aip->ai_addr, (int) aip->ai_addrlen);
				if (ret == SOCKET_ERROR) {
					GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] cannot bind socket: %s\n", gf_errno_str(LASTSOCKERROR)));
					return GF_IP_CONNECTION_FAILURE;
				}
			}
			if (aip->ai_family==PF_INET6) sock->flags |= GF_SOCK_IS_IPV6;
			else sock->flags &= ~GF_SOCK_IS_IPV6;
			break;
		}
		freeaddrinfo(res);

		if (SOCKET_INVALID(sock->socket) ) return GF_IP_CONNECTION_FAILURE;

		/*TODO: copy over other properties (recption buffer size & co)*/
		if (sock->flags & GF_SOCK_NON_BLOCKING)
			gf_sk_set_block_mode(sock, GF_TRUE);

		res = gf_sk_get_ipv6_addr(multi_IPAdd, MultiPortNumber, (sock->flags & GF_SOCK_IS_IPV6) ? AF_INET6 : AF_UNSPEC, 0, SOCK_DGRAM);
		if (!res) {
			if (sock->flags & GF_SOCK_IS_IPV6) {
				char szIP[100];
				gf_strcpy(szIP, "::ffff:");
				gf_strcat(szIP, multi_IPAdd);
				is_mapped_v4 = GF_TRUE;
				res = gf_sk_get_ipv6_addr(szIP, MultiPortNumber, AF_INET6, 0, SOCK_DGRAM);
			}
			if (!res)
				return GF_IP_CONNECTION_FAILURE;
		}
		//copy for sendto
		memcpy(&sock->dest_addr, res->ai_addr, res->ai_addrlen);
		sock->dest_addr_len = (u32) res->ai_addrlen;
		freeaddrinfo(res);

		addr = (struct sockaddr *)&sock->dest_addr;
		//ipv4
		if (is_mapped_v4) {
			local_add_id = inet_addr_from_name(ifce_ip_or_name);
			if (local_add_id==0xFFFFFFFF) return GF_IP_CONNECTION_FAILURE;

			M_req.imr_multiaddr.s_addr = inet_addr(multi_IPAdd);
			M_req.imr_interface.s_addr = local_add_id;

			e = sk_join_ipv4(sock, &M_req, TTL, src_ip_inc, nb_src_ip_inc, src_ip_exc, nb_src_ip_exc);
			if (e) return e;
			//keep sock->dest_addr untouched so that we still have a ipv6 sockaddr
			sock->flags |= GF_SOCK_IS_MULTICAST | GF_SOCK_HAS_PEER;
			return GF_OK;
		}
		else if (addr->sa_family != AF_INET6) {
			return GF_IP_CONNECTION_FAILURE;
		}

		memcpy(&M_reqV6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));

		/*set send IF index*/
		optval = M_reqV6.ipv6mr_interface;
		ret = setsockopt(sock->socket, IPPROTO_IPV6, IPV6_MULTICAST_IF, (const char *)&optval, sizeof(optval));
		if (ret == SOCKET_ERROR) {
		}

		if (nb_src_ip_inc) {
#ifdef MCAST_JOIN_SOURCE_GROUP
			u32 i;
			struct group_source_req M_reqV6_src;
			memset(&M_reqV6_src, 0, sizeof(struct group_source_req));
			M_reqV6_src.gsr_interface = 0;
			M_reqV6_src.gsr_group = sock->dest_addr;

			for (i=0; i<nb_src_ip_inc; i++) {
				res = gf_sk_get_ipv6_addr(src_ip_inc[i], MultiPortNumber, AF_INET6, 0, SOCK_DGRAM);
				if (!res) {
					GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] Failed to get address info for SSM source %s, ignoring\n", src_ip_inc[i]));
					continue;
				}
				memcpy(&M_reqV6_src.gsr_source, res->ai_addr, res->ai_addrlen);
				freeaddrinfo(res);
				ret = setsockopt(sock->socket, IPPROTO_IPV6, MCAST_JOIN_SOURCE_GROUP, (char *) &M_reqV6_src, sizeof(M_reqV6_src) );
				if (ret == SOCKET_ERROR) {
					GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] cannot join source group %s: %s\n", src_ip_inc[i], gf_errno_str(LASTSOCKERROR)));
					return GF_IP_CONNECTION_FAILURE;
				}
			}
#else
			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] SSM IPv6 not supported\n"));
			return GF_NOT_SUPPORTED;
#endif

		} else {
			ret = setsockopt(sock->socket, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, (char *) &M_reqV6, sizeof(M_reqV6));
			if (ret == SOCKET_ERROR) {
				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] Failed to join multicast: %s\n", gf_errno_str(LASTSOCKERROR) ));
				return GF_IP_CONNECTION_FAILURE;
			}
		}

		/*set TTL*/
		if (TTL != 0) {
			ret = setsockopt(sock->socket, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char *) &TTL, sizeof(TTL));
			if (ret == SOCKET_ERROR) return GF_IP_CONNECTION_FAILURE;
		}

		/*enable loopback*/
		optval = 1;
		ret = setsockopt(sock->socket, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *) &optval, sizeof(optval));
		if (ret == SOCKET_ERROR) {
			GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[Socket] Cannot enable multicast loop: %s\n", gf_errno_str(LASTSOCKERROR) ));
		}

		if (nb_src_ip_exc) {
#ifdef MCAST_BLOCK_SOURCE
			u32 i, j;
			struct group_source_req M_reqV6_src;
			M_reqV6_src.gsr_interface = 0;
			M_reqV6_src.gsr_group = sock->dest_addr;
			for (i=0; i<nb_src_ip_exc; i++) {
				Bool match=GF_FALSE;
				for (j=0; j<nb_src_ip_inc; j++) {
					if (!strcmp(src_ip_inc[j], src_ip_exc[i])) match=GF_TRUE;
				}
				if (match) continue;

				res = gf_sk_get_ipv6_addr(src_ip_exc[i], MultiPortNumber, AF_INET6, 0, SOCK_DGRAM);
				if (!res) {
					GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] Failed to get address info for SSM excluded source %s, ignoring\n", src_ip_exc[i]));
					continue;
				}
				memcpy(&M_reqV6_src.gsr_source, res->ai_addr, res->ai_addrlen);
				freeaddrinfo(res);

				ret = setsockopt(sock->socket, IPPROTO_IPV6, MCAST_BLOCK_SOURCE, (char *) &M_reqV6_src, sizeof(M_reqV6_src) );
				if (ret == SOCKET_ERROR) {
					GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[core] cannot block source membership for %s: %s\n", src_ip_exc[i], gf_errno_str(LASTSOCKERROR)));
					return GF_IP_CONNECTION_FAILURE;
				}
			}
#else
			GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[core] SSM IPv6 not supported\n"));
#endif
		}
		sock->flags |= GF_SOCK_IS_MULTICAST | GF_SOCK_HAS_PEER;
		return GF_OK;
	}
#endif

#ifndef GPAC_DISABLE_NETCAP
	if (sock->cap_info && sock->cap_info->nf->cap_mode) {
		//in GPC mode, store in host port/addr
		if (sock->cap_info->nf->cap_mode==NETCAP_GPAC) {
			sock->cap_info->host_port = MultiPortNumber;
			sock->cap_info->host_addr_v4 = inet_addr(multi_IPAdd);
		} else {
			sock->cap_info->host_port = MultiPortNumber;
			sock->cap_info->host_addr_v4 = inet_addr_from_name(ifce_ip_or_name ? ifce_ip_or_name : "127.0.0.1");
			sock->cap_info->peer_port = MultiPortNumber;
			sock->cap_info->peer_addr_v4 = inet_addr(multi_IPAdd);
		}
		sock->flags &= ~GF_SOCK_IS_IPV6;
		sock->flags |= GF_SOCK_IS_MULTICAST;
		return GF_OK;
	}
#endif


	//IPv4 setup
	sock->socket = socket(AF_INET, (sock->flags & GF_SOCK_IS_TCP) ? SOCK_STREAM : SOCK_DGRAM, 0);
	if (SOCKET_INVALID(sock->socket)) return GF_IP_NETWORK_FAILURE;

	if (sock->flags & GF_SOCK_NON_BLOCKING)
		gf_sk_set_block_mode(sock, GF_TRUE);
	sock->flags &= ~GF_SOCK_IS_IPV6;

	/*enable address reuse*/
	optval = 1;
	ret = setsockopt(sock->socket, SOL_SOCKET, SO_REUSEADDR, SSO_CAST &optval, sizeof(optval));
	if (ret == SOCKET_ERROR) {
		GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[core] Failed to set SO_REUSEADDR: %s\n", gf_errno_str(LASTSOCKERROR) ));
	}
#ifdef SO_REUSEPORT
	optval = 1;
	ret = setsockopt(sock->socket, SOL_SOCKET, SO_REUSEPORT, SSO_CAST &optval, sizeof(optval));
	if (ret == SOCKET_ERROR) {
		GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[core] Failed to set SO_REUSEPORT: %s\n", gf_errno_str(LASTSOCKERROR) ));
	}
#endif

	local_add_id = inet_addr_from_name(ifce_ip_or_name);
	if (local_add_id==0xFFFFFFFF) return GF_IP_CONNECTION_FAILURE;

	if (!NoBind) {
		struct sockaddr_in local_address;

		memset(&local_address, 0, sizeof(struct sockaddr_in ));
		local_address.sin_family = AF_INET;
		local_address.sin_addr.s_addr = htonl(INADDR_ANY);
		local_address.sin_port = htons( MultiPortNumber);

		ret = bind(sock->socket, (struct sockaddr *) &local_address, sizeof(local_address));
		if (ret == SOCKET_ERROR) {
			GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[core] Failed to bind socket: %s\n", gf_errno_str(LASTSOCKERROR) ));
			return GF_IP_CONNECTION_FAILURE;
		}
		/*setup local interface*/
		if (ifce_ip_or_name) {
			ret = setsockopt(sock->socket, IPPROTO_IP, IP_MULTICAST_IF, (void *) &local_add_id, sizeof(local_add_id));
			if (ret == SOCKET_ERROR) return GF_IP_CONNECTION_FAILURE;
		}
	}

	/*now join the multicast*/
	M_req.imr_multiaddr.s_addr = inet_addr(multi_IPAdd);
	M_req.imr_interface.s_addr = local_add_id;

	e = sk_join_ipv4(sock, &M_req, TTL, src_ip_inc, nb_src_ip_inc, src_ip_exc, nb_src_ip_exc);
	if (e) return e;

#ifdef GPAC_HAS_IPV6
	((struct sockaddr_in *) &sock->dest_addr)->sin_family = AF_INET;
	((struct sockaddr_in *) &sock->dest_addr)->sin_addr.s_addr = M_req.imr_multiaddr.s_addr;
	((struct sockaddr_in *) &sock->dest_addr)->sin_port = htons( MultiPortNumber);
	sock->dest_addr_len = sizeof(struct sockaddr);
#else
	sock->dest_addr.sin_family = AF_INET;
	sock->dest_addr.sin_addr.s_addr = M_req.imr_multiaddr.s_addr;
	sock->dest_addr.sin_port = htons( MultiPortNumber);
#endif

	sock->flags |= GF_SOCK_IS_MULTICAST | GF_SOCK_HAS_PEER;
	return GF_OK;
}

GF_EXPORT
GF_Err gf_sk_setup_multicast(GF_Socket *sock, const char *multi_IPAdd, u16 MultiPortNumber, u32 TTL, Bool NoBind, const char *ifce_ip_or_name)
{
	return gf_sk_setup_multicast_ex(sock, multi_IPAdd, MultiPortNumber, TTL, NoBind, ifce_ip_or_name, NULL, 0, NULL, 0);

}

#include <gpac/list.h>
struct __tag_sock_group
{
	GF_List *sockets;
	fd_set rgroup, wgroup;

#ifdef GPAC_HAS_POLL
	u32 last_mask;
	u32 nb_fds, alloc_fds;
	GF_POLLFD *fds;
#endif

#ifndef GPAC_DISABLE_NETCAP
	u32 nb_nfs;
	u32 nb_socks;
#endif
};

GF_SockGroup *gf_sk_group_new()
{
	GF_SockGroup *tmp;
	GF_SAFEALLOC(tmp, GF_SockGroup);
	if (!tmp) return NULL;
	FD_ZERO(&tmp->rgroup);
	FD_ZERO(&tmp->wgroup);

#ifdef GPAC_HAS_POLL
	tmp->last_mask = POLLIN;
#endif
	return tmp;
}

void gf_sk_group_del(GF_SockGroup *sg)
{
	gf_list_del(sg->sockets);
#ifdef GPAC_HAS_POLL
	if (sg->fds) gf_free(sg->fds);
#endif
	gf_free(sg);
}

void gf_sk_group_register(GF_SockGroup *sg, GF_Socket *sk)
{
	if (!sg || !sk) return;
	if (!sg->sockets) sg->sockets = gf_list_new();
	if (gf_list_find(sg->sockets, sk)>=0) return;
	gf_list_add(sg->sockets, sk);

#ifndef GPAC_DISABLE_NETCAP
	if (sk->cap_info) {
		sg->nb_nfs++;
		sg->nb_socks = gf_list_count(sg->sockets);
		if (sk->cap_info->nf && (gf_list_find(sk->cap_info->nf->read_socks, sk)<0))
			gf_list_add(sk->cap_info->nf->read_socks, sk);
		return;
	}
#endif

#ifdef GPAC_HAS_POLL
	if (!sg->fds && !gpac_use_poll)
		return;

	if (sg->nb_fds + 1 > sg->alloc_fds) {
		sg->fds = gf_realloc(sg->fds, (sg->nb_fds+1) * sizeof(GF_POLLFD));
		sg->alloc_fds = sg->nb_fds+1;
	}
	sg->fds[sg->nb_fds].fd = sk->socket;
	sg->fds[sg->nb_fds].events = sg->last_mask;
	sg->fds[sg->nb_fds].revents = 0;
	sk->poll_idx = sg->nb_fds+1;
	gf_assert(! SOCKET_INVALID(sg->fds[sg->nb_fds].fd) );
	sg->nb_fds++;
#endif
}

void gf_sk_group_unregister(GF_SockGroup *sg, GF_Socket *sk)
{
	if (!sg || !sk) return;
	s32 pidx = gf_list_del_item(sg->sockets, sk);

#ifndef GPAC_DISABLE_NETCAP
	if (sk->cap_info && sk->cap_info->nf->read_socks) {
		if (sg->nb_nfs && (pidx>=0))
			sg->nb_nfs--;
		sg->nb_socks = gf_list_count(sg->sockets);

		if (sk == sk->cap_info->nf->read_sock_selected) {
			gf_bs_skip_bytes(sk->cap_info->nf->cap_bs, sk->cap_info->nf->pck_len);
			sk->cap_info->nf->dst_port = 0;
			sk->cap_info->nf->read_sock_selected=NULL;
			//do not load a new packet here as this could go into infinite loop when netcap-loop=-1 ...
		}
		gf_list_del_item(sk->cap_info->nf->read_socks, sk);
		return;
	}
#endif

	if (!gf_list_count(sg->sockets)) {
		gf_list_del(sg->sockets);
		sg->sockets = NULL;
#ifdef GPAC_HAS_POLL
		if (sg->fds) {
			gf_free(sg->fds);
			sg->fds = NULL;
			sg->nb_fds = sg->alloc_fds = 0;
		}
#endif
		return;
	}
	if (pidx<0) return;

#ifdef GPAC_HAS_POLL
	sk->poll_idx=0;
	if (!sg->fds) return;
	memmove(&sg->fds[pidx], &sg->fds[pidx+1], sizeof(GF_POLLFD) * (sg->nb_fds-pidx-1));
	//reassign poll file descriptors and poll index
	sg->nb_fds--;
	while (1) {
		GF_Socket *asock = gf_list_get(sg->sockets, pidx);
		if (!asock) break;
		sg->fds[pidx].fd = asock->socket;
		asock->poll_idx = pidx+1;
		pidx++;
	}
#endif
}

GF_Err gf_sk_group_select(GF_SockGroup *sg, u32 usec_wait, GF_SockSelectMode mode)
{
	s32 ready;
	u32 i;
	struct timeval timeout;
	GF_Socket *sock;

	if (!sg->sockets)
		return GF_IP_NETWORK_EMPTY;

#ifndef GPAC_DISABLE_NETCAP
	if (sg->nb_nfs) {
		u32 nb_closed=0;
		u32 nb_write=0;
		u32 nb_nofs=0;
		u32 nb_tcp=0;
		u64 now = gf_sys_clock_high_res();
		for (i=0; i<sg->nb_socks; i++) {
			GF_Socket *s = gf_list_get(sg->sockets, i);
			if (!s->cap_info) {
				nb_nofs++;
				continue;
			}
			if (!s->cap_info->nf->read_socks) {
				nb_write++;
				continue;
			}

			gf_netcap_load_pck(s->cap_info->nf, now);
			if (!s->cap_info->nf->read_sock_selected) {
				if (s->cap_info->nf->is_eos) {
					if (s->flags & GF_SOCK_IS_TCP) nb_tcp++;
					nb_closed++;
				}
				continue;
			}

			if (s->cap_info->nf->rt && (s->cap_info->nf->pck_time > now))
				continue; // GF_IP_NETWORK_EMPTY;

			if (s == s->cap_info->nf->read_sock_selected)
				return GF_OK;
		}
		if (nb_closed==sg->nb_socks) return nb_tcp ? GF_IP_CONNECTION_CLOSED : GF_EOS;
		if (nb_write) return GF_OK;
		if (!nb_nofs) return GF_IP_NETWORK_EMPTY;
		//fallthrough
	}
#endif

#ifdef GPAC_HAS_POLL
	if (sg->fds) {
		u32 mask = 0;
		if (mode == GF_SK_SELECT_BOTH) mask = POLLIN | POLLOUT;
		else if (mode == GF_SK_SELECT_READ) mask = POLLIN;
		else mask = POLLOUT;
		if (sg->last_mask != mask) {
			sg->last_mask = mask;
			for (i=0; i<sg->nb_fds; i++) {
				sg->fds[i].events = mask;
				gf_assert(! SOCKET_INVALID(sg->fds[i].fd) );
			}
		}
		int res = poll(sg->fds, sg->nb_fds, usec_wait/1000);
		if (res<0) {
			switch (LASTSOCKERROR) {
			case EAGAIN:
			case EINTR:
				return GF_IP_NETWORK_EMPTY;
			default:
				GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[socket] cannot poll: %s\n", gf_errno_str(LASTSOCKERROR) ));
				return GF_IP_NETWORK_FAILURE;
			}
		}

		if (!res)
			return GF_IP_NETWORK_EMPTY;
		return GF_OK;
	}
#endif

	i=0;
	u32 max_fd=0;
	fd_set *rgroup=NULL, *wgroup=NULL;

	FD_ZERO(&sg->rgroup);
	FD_ZERO(&sg->wgroup);

	switch (mode) {
	case GF_SK_SELECT_BOTH:
		rgroup = &sg->rgroup;
		wgroup = &sg->wgroup;
		break;
	case GF_SK_SELECT_READ:
		rgroup = &sg->rgroup;
		break;
	case GF_SK_SELECT_WRITE:
		wgroup = &sg->wgroup;
		break;
	}
	while ((sock = gf_list_enum(sg->sockets, &i))) {
		if (rgroup)
			FD_SET(sock->socket, rgroup);

		if (wgroup)
			FD_SET(sock->socket, wgroup);

		if (max_fd < (u32) sock->socket) max_fd = (u32) sock->socket;
	}
	timeout.tv_sec = 0;
	timeout.tv_usec = usec_wait;
	ready = select((int) max_fd+1, rgroup, wgroup, NULL, &timeout);

	if (ready == SOCKET_ERROR) {
		switch (LASTSOCKERROR) {
		case EBADF:
			GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[socket] cannot select, BAD descriptor\n"));
			return GF_IP_CONNECTION_CLOSED;
		case EAGAIN:
		case EINTR:
			return GF_IP_NETWORK_EMPTY;
		default:
			GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[socket] cannot select: %s\n", gf_errno_str(LASTSOCKERROR) ));
			return GF_IP_NETWORK_FAILURE;
		}
	}
	if (!ready) {
		GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[socket] nothing to be read - ready %d\n", ready));
		return GF_IP_NETWORK_EMPTY;
	}
	return GF_OK;
}

Bool gf_sk_group_sock_is_set(GF_SockGroup *sg, GF_Socket *sk, GF_SockSelectMode mode)
{
	if (!sg || !sk) return GF_FALSE;

#ifndef GPAC_DISABLE_NETCAP
	if (sk->cap_info) {
		//write, always true
		if (!sk->cap_info->nf->read_socks) return GF_TRUE;
		//read
		if (sk->cap_info->nf->read_sock_selected != sk) return GF_FALSE;
		if (sk->cap_info->nf->rt && (sk->cap_info->nf->pck_time > gf_sys_clock_high_res()))
			return GF_FALSE;

		return GF_TRUE;
	}
#endif

#ifdef GPAC_HAS_POLL
	if (sg->fds && sk->poll_idx) {
		GF_POLLFD *pfd = &sg->fds[sk->poll_idx-1];
		//disconnected, consider ready to read/write
		if (pfd->revents & POLLHUP)
			return GF_TRUE;

		if ((mode!=GF_SK_SELECT_WRITE) && (pfd->revents & POLLIN))
			return GF_TRUE;

		if ((mode!=GF_SK_SELECT_READ) && (pfd->revents & POLLOUT))
			return GF_TRUE;

//		if (gf_sk_probe(sk) == GF_IP_CONNECTION_CLOSED)
//			return GF_TRUE;
		return GF_FALSE;
	}
#endif

	if ((mode!=GF_SK_SELECT_WRITE) && FD_ISSET(sk->socket, &sg->rgroup))
		return GF_TRUE;
	if ((mode!=GF_SK_SELECT_READ) && FD_ISSET(sk->socket, &sg->wgroup))
		return GF_TRUE;

	return GF_FALSE;
}

//fetch nb bytes on a socket and fill the buffer from startFrom
//length is the allocated size of the receiving buffer
//BytesRead is the number of bytes read from the network
GF_Err gf_sk_receive_internal(GF_Socket *sock, char *buffer, u32 length, u32 *BytesRead, Bool do_select)
{
	s32 res;

	if (BytesRead) *BytesRead = 0;
	if (!sock) return GF_BAD_PARAM;

#ifndef GPAC_DISABLE_NETCAP
	if (sock->cap_info) {
		if (!sock->cap_info->nf->read_socks) return GF_IP_NETWORK_EMPTY;

		GF_NetcapFilter *nf = sock->cap_info->nf;
		if (do_select && !(sock->flags & GF_SOCK_NON_BLOCKING)) {
			gf_netcap_load_pck(nf, gf_sys_clock_high_res() );
			if (!nf->read_sock_selected) return nf->is_eos ? GF_IP_CONNECTION_CLOSED : GF_IP_NETWORK_EMPTY;

			if (nf->rt && (nf->pck_time > gf_sys_clock_high_res()))
				return GF_IP_NETWORK_EMPTY;
		}
		if (!buffer) return GF_OK;

		if (sock!=nf->read_sock_selected) return GF_IP_NETWORK_EMPTY;
		u32 to_read = length;
		if ((s32) to_read > nf->pck_len) to_read = nf->pck_len;
		u32 res = gf_bs_read_data(nf->cap_bs, buffer, to_read);
		if (nf->read_sock_selected->cap_info->patch_offset) {
			if (nf->read_sock_selected->cap_info->patch_offset-1<res) {
				buffer[nf->read_sock_selected->cap_info->patch_offset-1] = nf->read_sock_selected->cap_info->patch_val;
				nf->read_sock_selected->cap_info->patch_offset = 0;
			} else {
				nf->read_sock_selected->cap_info->patch_offset -= res;
			}
		}
		nf->pck_len -= res;
		if (!nf->pck_len) {
			nf->dst_port = 0;
			//do not load packet once done as this could lead to packet drop if the target socket is not yet created
			//gf_netcap_load_pck(nf, 0);
		}

		if (BytesRead)
			*BytesRead = res;
		if (!res) return GF_IP_NETWORK_EMPTY;
		return GF_OK;
	}
#endif
	if (SOCKET_INVALID(sock->socket)) return GF_BAD_PARAM;

	if (do_select && !(sock->flags & GF_SOCK_NON_BLOCKING)) {
		//check read
		GF_Err e = poll_select(sock, GF_SK_SELECT_READ, sock->usec_wait, GF_FALSE);
		if (e) return e;
	}
	if (!buffer) return GF_OK;

	if ((sock->flags & GF_SOCK_HAS_PEER) || sock->dest_addr_len) {
		res = (s32) recvfrom(sock->socket, (char *) buffer, length, 0, (struct sockaddr *)&sock->dest_addr, &sock->dest_addr_len);
	} else {
		res = (s32) recv(sock->socket, (char *) buffer, length, 0);
	}
	if (!do_select && (res == 0))
		return GF_IP_CONNECTION_CLOSED;

	if (res == SOCKET_ERROR) {
		res = LASTSOCKERROR;
		switch (res) {
		case EAGAIN:
		case EINTR:
		case ECONNREFUSED:
			return GF_IP_NETWORK_EMPTY;

#if defined(WIN32) || defined(_WIN32_WCE)
		//may happen if no select
		case WSAEWOULDBLOCK:
			return GF_IP_NETWORK_EMPTY;
#endif

#ifndef __SYMBIAN32__
		case EMSGSIZE:
			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[socket] error reading: %s\n", gf_errno_str(LASTSOCKERROR)));
			return GF_OUT_OF_MEM;
		case ENOTCONN:
		case ECONNRESET:
		case ECONNABORTED:
#if defined(WIN32) || defined(_WIN32_WCE)
		case WSAECONNRESET:
#endif
			//log as debug, let higher level decide if this is an error or not
			GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[socket] error reading: %s\n", gf_errno_str(LASTSOCKERROR)));
			return GF_IP_CONNECTION_CLOSED;
#endif
		default:
			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[socket] error reading: %s\n", gf_errno_str(LASTSOCKERROR) ));
			return GF_IP_NETWORK_FAILURE;
		}
	}

#ifndef GPAC_DISABLE_NETCAP
	if (netcap_filter_pck(sock, res, GF_FALSE)) {
		res = 0;
	} else if (sock->cap_info && sock->cap_info->patch_offset) {
		buffer[sock->cap_info->patch_offset-1] = sock->cap_info->patch_val;
		sock->cap_info->patch_offset = 0;
	}
#endif

	if (!res) return GF_IP_NETWORK_EMPTY;
	GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[socket] read %u bytes\n", res ));

	if (BytesRead)
		*BytesRead = res;
	return GF_OK;
}

GF_EXPORT
GF_Err gf_sk_receive(GF_Socket *sock, u8 *buffer, u32 length, u32 *BytesRead)
{
	return gf_sk_receive_internal(sock, buffer, length, BytesRead, GF_TRUE);
}

GF_EXPORT
GF_Err gf_sk_receive_no_select(GF_Socket *sock, u8 *buffer, u32 length, u32 *BytesRead)
{
	return gf_sk_receive_internal(sock, buffer, length, BytesRead, GF_FALSE);
}

GF_EXPORT
GF_Err gf_sk_listen(GF_Socket *sock, u32 MaxConnection)
{
	s32 i;
	if (!sock || SOCKET_INVALID(sock->socket)) return GF_BAD_PARAM;

#ifndef GPAC_DISABLE_NETCAP
	if (sock->cap_info && sock->cap_info->nf->cap_mode) {
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[socket] Listening on socket is not supported when using network capture\n"));
		return GF_NOT_SUPPORTED;
	}
#endif

	if (!MaxConnection || (MaxConnection >= SOMAXCONN)) {
		MaxConnection = SOMAXCONN;
	}
	i = listen(sock->socket, MaxConnection);
	if (i == SOCKET_ERROR)
		return GF_IP_NETWORK_FAILURE;
	sock->flags |= GF_SOCK_IS_LISTENING;
	return GF_OK;
}

GF_EXPORT
GF_Err gf_sk_accept(GF_Socket *sock, GF_Socket **newConnection)
{
	u32 client_address_size;
	SOCKET sk;
	*newConnection = NULL;
	if (!sock || !(sock->flags & GF_SOCK_IS_LISTENING) ) return GF_BAD_PARAM;

	//check read
	GF_Err e = poll_select(sock, GF_SK_SELECT_READ, sock->usec_wait, GF_FALSE);
	if (e) return e;

#ifdef GPAC_HAS_IPV6
	client_address_size = sizeof(struct sockaddr_in6);
#else
	client_address_size = sizeof(struct sockaddr_in);
#endif
	sk = accept(sock->socket, (struct sockaddr *) &sock->dest_addr, &client_address_size);

	//we either have an error or we have no connections
	if (SOCKET_INVALID(sk)) {
		switch (LASTSOCKERROR) {
		case EAGAIN:
		case EINTR:
			return GF_IP_NETWORK_EMPTY;
		default:
			GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[socket] accept error: %s\n", gf_errno_str(LASTSOCKERROR)));
			return GF_IP_NETWORK_FAILURE;
		}
	}

	GF_SAFEALLOC((*newConnection), GF_Socket);
	(*newConnection)->socket = sk;
	(*newConnection)->flags = sock->flags & ~GF_SOCK_IS_LISTENING;
	(*newConnection)->usec_wait = sock->usec_wait;
#ifdef GPAC_HAS_IPV6
	memcpy( &(*newConnection)->dest_addr, &sock->dest_addr, client_address_size);
	memset(&sock->dest_addr, 0, sizeof(struct sockaddr_in6));
#else
	memcpy( &(*newConnection)->dest_addr, &sock->dest_addr, client_address_size);
	memset(&sock->dest_addr, 0, sizeof(struct sockaddr_in));
#endif

#ifdef SO_NOSIGPIPE
	int value = 1;
	setsockopt((*newConnection)->socket, SOL_SOCKET, SO_NOSIGPIPE, SSO_CAST &value, sizeof(value));
#endif

#if defined(WIN32) || defined(_WIN32_WCE)
	wsa_init++;
#endif

	(*newConnection)->dest_addr_len = client_address_size;
	return GF_OK;
}

GF_EXPORT
GF_Err gf_sk_get_local_info(GF_Socket *sock, u16 *Port, u32 *Familly)
{
#ifdef GPAC_HAS_IPV6
	struct sockaddr_in6 the_add;
#else
	struct sockaddr_in the_add;
#endif
	u32 size;

	if (!sock || SOCKET_INVALID(sock->socket)) return GF_BAD_PARAM;

	if (Port) {
#ifdef GPAC_HAS_IPV6
		size = sizeof(struct sockaddr_in6);
		if (getsockname(sock->socket, (struct sockaddr *) &the_add, &size) == SOCKET_ERROR) return GF_IP_NETWORK_FAILURE;
		*Port = (u32) ntohs(the_add.sin6_port);
#else
		size = sizeof(struct sockaddr_in);
		if (getsockname(sock->socket, (struct sockaddr *) &the_add, &size) == SOCKET_ERROR) return GF_IP_NETWORK_FAILURE;
		*Port = (u32) ntohs(the_add.sin_port);
#endif
	}
	if (Familly) {
		/*		size = 4;
				if (getsockopt(sock->socket, SOL_SOCKET, SO_TYPE, (char *) &fam, &size) == SOCKET_ERROR)
					return GF_IP_NETWORK_FAILURE;
				*Familly = fam;
		*/
		if (sock->flags & GF_SOCK_IS_TCP) *Familly = GF_SOCK_TYPE_TCP;
		else  *Familly = GF_SOCK_TYPE_UDP;
	}
	return GF_OK;
}

//we have to do this for the server sockets as we use only one thread
GF_EXPORT
GF_Err gf_sk_server_mode(GF_Socket *sock, Bool serverOn)
{
	u32 one;

	if (!sock || SOCKET_INVALID(sock->socket))
		return GF_BAD_PARAM;

	if (!(sock->flags & GF_SOCK_IS_TCP)) {
#if defined(IPV6_MTU_DISCOVER) || defined(IPV6_PMTUDISC_DO) || defined(IPV6_DONTFRAG) || defined(IP_MTU_DISCOVER) || defined(IP_DONTFRAG)
		int val;
#endif
#ifdef GPAC_HAS_IPV6
		sock->dest_addr_len = sizeof(struct sockaddr_storage);
#else
		sock->dest_addr_len = sizeof(struct sockaddr);
#endif
		if (sock->flags & GF_SOCK_IS_IPV6) {
#if defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO)
			val = IPV6_PMTUDISC_DO;
			if (setsockopt(sock->socket, IPPROTO_IPV6, IPV6_MTU_DISCOVER, SSO_CAST &val, sizeof(val)) == -1) {
				GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[socket] Failed to set IPV6_MTU_DISCOVER: %s\n", gf_errno_str(LASTSOCKERROR) ));
			}
#endif
#ifdef IPV6_DONTFRAG
			val = 1;
			if (setsockopt(sock->socket, IPPROTO_IPV6, IPV6_DONTFRAG, SSO_CAST &val, sizeof(val) ) == -1) {
				GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[socket] Failed to set IPV6_DONTFRAG: %s\n", gf_errno_str(LASTSOCKERROR) ));
			}
#endif
		} else {
#ifdef IP_MTU_DISCOVER
			val = IP_PMTUDISC_DO;
			if (setsockopt(sock->socket, IPPROTO_IP, IP_MTU_DISCOVER, SSO_CAST &val, sizeof(val)) == -1) {
				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[socket] Failed to set IP_MTU_DISCOVER: %s\n", gf_errno_str(LASTSOCKERROR) ));
				return GF_OK;
			}
#endif
#ifdef IP_DONTFRAG
			val = 1;
			if (setsockopt(sock->socket, IPPROTO_IP, IP_DONTFRAG, SSO_CAST &val, sizeof(val) ) == -1) {
				GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[socket] Failed to set IP_DONTFRAG: %s\n", gf_errno_str(LASTSOCKERROR) ));
			}
#endif
		}
		return GF_OK;
	}

	one = serverOn ? 1 : 0;
	setsockopt(sock->socket, IPPROTO_TCP, TCP_NODELAY, SSO_CAST &one, sizeof(u32));
#ifndef __SYMBIAN32__
	setsockopt(sock->socket, SOL_SOCKET, SO_KEEPALIVE, (char *) &one, sizeof(u32));
#endif
	return GF_OK;
}

GF_EXPORT
GF_Err gf_sk_get_remote_address_port(GF_Socket *sock, char buf[GF_MAX_IP_NAME_LEN], u32 *port)
{
#ifdef GPAC_HAS_IPV6
	char clienthost[NI_MAXHOST];
	char servname[NI_MAXHOST];
	struct sockaddr_in6 * addrptr = (struct sockaddr_in6 *)(&sock->dest_addr);
	if (!sock || SOCKET_INVALID(sock->socket)) return GF_BAD_PARAM;
	my_inet_ntop(AF_INET, addrptr, clienthost, NI_MAXHOST);
	gf_strlcpy(buf, clienthost, GF_MAX_IP_NAME_LEN);
	if (port) {
		*port = ntohs(addrptr->sin6_port);
	}
	if (getnameinfo((struct sockaddr *)addrptr, sock->dest_addr_len, clienthost, NI_MAXHOST, servname, NI_MAXHOST, NI_NUMERICHOST) == 0) {
		gf_strlcpy(buf, clienthost, GF_MAX_IP_NAME_LEN);
	}
#else
	if (!sock || SOCKET_INVALID(sock->socket)) return GF_BAD_PARAM;
	gf_strlcpy(buf, inet_ntoa(sock->dest_addr.sin_addr), GF_MAX_IP_NAME_LEN);
	if (port) {
		*port = ntohs(sock->dest_addr.sin_port);
	}
#endif
	return GF_OK;
}
GF_EXPORT
GF_Err gf_sk_get_remote_address(GF_Socket *sock, char *buf)
{
	return gf_sk_get_remote_address_port(sock, buf, NULL);
}

const u8 *gf_sk_get_address(GF_Socket *sock, u32 *addr_size)
{
	if (!sock || !addr_size) return NULL;
	*addr_size = sock->dest_addr_len;
	return (const u8 *) &sock->dest_addr;
}


#if 0 //unused

//send length bytes of a buffer
GF_Err gf_sk_send_to(GF_Socket *sock, const char *buffer, u32 length, char *remoteHost, u16 remotePort)
{
	u32 count, remote_add_len;
	s32 res;
#ifdef GPAC_HAS_IPV6
	struct sockaddr_storage remote_add;
#else
	struct sockaddr_in remote_add;
	struct hostent *Host;
#endif

	//the socket must be bound or connected
	if (!sock || SOCKET_INVALID(sock->socket)) return GF_BAD_PARAM;
	if (remoteHost && !remotePort) return GF_BAD_PARAM;

	//check write
	GF_Err e = poll_select(sock, GF_SK_SELECT_WRITE, sock->usec_wait, GF_FALSE);
	if (e) return e;

	/*setup the address*/
#ifdef GPAC_HAS_IPV6
	remote_add.ss_family = AF_INET6;
	//if a remote host is specified, use it. Otherwise use the default host
	if (remoteHost) {
		//setup the address
		struct addrinfo *res = gf_sk_get_ipv6_addr(remoteHost, remotePort, AF_UNSPEC, 0, (sock->flags & GF_SOCK_IS_TCP) ? SOCK_STREAM : SOCK_DGRAM);
		if (!res) return GF_IP_ADDRESS_NOT_FOUND;
		memcpy(&remote_add, res->ai_addr, res->ai_addrlen);
		remote_add_len = (u32) res->ai_addrlen;
		freeaddrinfo(res);
	} else {
		struct sockaddr_in6 *remotePtr = (struct sockaddr_in6 *)&remote_add;
		struct sockaddr_in6 * addrptr = (struct sockaddr_in6 *)(&sock->dest_addr);
		remotePtr->sin6_port = addrptr->sin6_port;
		remotePtr->sin6_addr = addrptr->sin6_addr;
		remote_add_len = sock->dest_addr_len;
	}
#else
	remote_add_len = sizeof(struct sockaddr_in);
	remote_add.sin_family = AF_INET;
	//if a remote host is specified, use it. Otherwise use the default host
	if (remoteHost) {
		//setup the address
		remote_add.sin_port = htons(remotePort);
		//get the server IP
		Host = gf_gethostbyname(remoteHost);
		if (Host == NULL) return GF_IP_ADDRESS_NOT_FOUND;
		memcpy((char *) &remote_add.sin_addr, Host->h_addr_list[0], sizeof(u32));
	} else {
		remote_add.sin_port = sock->dest_addr.sin_port;
		remote_add.sin_addr.s_addr = sock->dest_addr.sin_addr.s_addr;
	}
#endif
	count = 0;
	while (count < length) {
		res = (s32) sendto(sock->socket, (char *) buffer+count, length - count, 0, (struct sockaddr *) &remote_add, remote_add_len);
		if (res == SOCKET_ERROR) {
			switch (LASTSOCKERROR) {
			case EAGAIN:
			case EINTR:
				return GF_IP_NETWORK_EMPTY;
			default:
				GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[socket] sendto error: %s\n", gf_errno_str(LASTSOCKERROR)));
				return GF_IP_NETWORK_FAILURE;
			}
		}
		count += res;
	}
	return GF_OK;
}
#endif

GF_EXPORT
GF_Err gf_sk_probe(GF_Socket *sock)
{
	s32 res;
	u8 buffer[1];
	if (!sock) return GF_BAD_PARAM;

#ifndef GPAC_DISABLE_NETCAP
	if (sock->cap_info && sock->cap_info->nf->read_socks && sock->cap_info->nf->is_eos) return GF_IP_CONNECTION_CLOSED;
#endif

	//check read - force using select at least for windows, for which poll returns nothing on connection abort
	GF_Err e = poll_select(sock, GF_SK_SELECT_READ, 100, GF_TRUE);
	if (e) return e;

	//peek message
	res = (s32) recv(sock->socket, buffer, 1, MSG_PEEK);
	if (res > 0) return GF_OK;
#if 0
	res = LASTSOCKERROR;
	switch (res) {
	case 0:
	case EAGAIN:
	case EINTR:
		return GF_IP_NETWORK_EMPTY;
	default:
		GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[socket] probe error: %s\n", gf_errno_str(res)));
		return GF_IP_CONNECTION_CLOSED;
	}
#else
	return GF_IP_CONNECTION_CLOSED;
#endif

	return GF_OK;
}


GF_EXPORT
char *gf_net_bump_ip_address(const char *in_ip, u32 increment)
{
	if (!in_ip) return NULL;
	if (!gf_sk_is_multicast_address(in_ip)) return NULL;
	if (!increment) return gf_strdup(in_ip);

	u32 new_range=0;

	char *alloc_ip=NULL;
	if (!strnicmp(in_ip, "ff", 2)) {
		char *add_end = strstr(in_ip, "::");
		if (!add_end) add_end = 1 + strrchr(in_ip, ':');
		else add_end+=2;
		char *sep2 = strrchr(add_end, '/');
		if (sep2) sep2[0] = 0;
		u32 inc;
		if (!add_end[0]) {
			inc = 0;
			gf_dynstrcat(&alloc_ip, in_ip, NULL);
		} else {
			char c = add_end[0];
			add_end[0] = 0;
			gf_dynstrcat(&alloc_ip, in_ip, NULL);
			add_end[0] = c;
			inc = atoi(add_end);
		}
		new_range = inc + increment;
		char val[10];
		sprintf(val, ".%u", new_range);
		add_end[0] = 0;
		gf_dynstrcat(&alloc_ip, val, NULL);
		if (sep2) {
			sep2[0] = '/';
			gf_dynstrcat(&alloc_ip, sep2, NULL);
		}
	} else {
		char *sep = strrchr(in_ip, '.');
		sep[0]  =0;
		u32 inc = atoi(sep+1);
		new_range = inc + increment;
		char val[10];
		sep[0] = 0;
		gf_dynstrcat(&alloc_ip, in_ip, NULL);
		sep[0] = '.';
		sprintf(val, ".%u", new_range);
		gf_dynstrcat(&alloc_ip, val, NULL);
	}
	if (!alloc_ip) return NULL;
	if (new_range>0xFF) {
		GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[IP] Dumping IP address beyond 0xFF is not supported\n"));
		gf_free(alloc_ip);
		return NULL;
	}
	return alloc_ip;
}

#else
//for ntoh/hton
#include <arpa/inet.h>
#endif //GPAC_DISABLE_NETWORK

GF_EXPORT
GF_Err gf_net_reload_netcap()
{
#if !defined(GPAC_DISABLE_NETWORK) && !defined(GPAC_DISABLE_NETCAP)
	u32 i, count = gf_list_count(netcap_filters);
	for (i=0; i<count; i++) {
		GF_NetcapFilter *nf = gf_list_get(netcap_filters, i);

		if (nf->cap_bs) gf_bs_del(nf->cap_bs);
#ifdef GPAC_HAS_FD
		if (nf->fd>=0) close(nf->fd);
#endif
		if (nf->file) gf_fclose(nf->file);
		gf_list_del(nf->read_socks);
		nf->read_socks = NULL;
		nf->nb_reloads++;
		nf->init_time = 0;
		nf->is_eos = GF_FALSE;
		nf->pck_start_offset = 0;
		nf->pck_len = 0;
		nf->pck_flags = 0;
		nf->pck_time = 0;
		nf->pcap_num_interfaces = 0;
		nf->pcapng_trail = 0;
		nf->pcap_trail = 0;
		nf->pck_idx_r = 0;
		nf->pck_idx_w = 0;
		nf->next_pck_range = 0;
		nf->next_rand = 0;
		nf->reorder_max_pck = 0;
		nf->reorder_nb_pck = 0;
		nf->delay_nb_pck = 0;
		nf->reorder_seek_pos = 0;
		nf->reorder_resume_pos = 0;
		GF_Err e = GF_OK;
		if (nf->dst) {
			e = gf_netcap_record(nf);
		}
		else if (nf->src) {
			e = gf_netcap_playback(nf);
		}
		if (e) return e;
	}
#endif
	return GF_OK;
}

GF_EXPORT
u32 gf_htonl(u32 val)
{
	return htonl(val);
}


GF_EXPORT
u32 gf_ntohl(u32 val)
{
	return ntohl(val);
}

GF_EXPORT
u16 gf_htons(u16 val)
{
	return htons(val);
}


GF_EXPORT
u16 gf_ntohs(u16 val)
{
	return ntohs(val);
}

GF_EXPORT
const char *gf_errno_str(int errnoval)
{
	return strerror(errnoval);
}