react-native-queue-player 1.0.0

package/android/src/main/cpp/third_party/crosstools/cross_net.c

@@ -0,0 +1,1139 @@
+/*
+ * Network-type utilities
+ *
+ * (c) Philippe, philippe_44@outlook.com
+ *
+ * See LICENSE file
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "platform.h"
+
+#if LINUX || OSX || FREEBSD || SUNOS
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <netdb.h>
+#include <ctype.h>
+#include <ifaddrs.h>
+#include <unistd.h>
+#if FREEBSD || SUNOS
+#if SUNOS
+#include <sys/sockio.h>
+#endif
+#include <net/if_dl.h>
+#include <net/if_types.h>
+#endif
+#if OSX
+#include <sys/sysctl.h>
+#include <net/if_dl.h>
+#include <net/if_types.h>
+#include <net/route.h>
+#include <netinet/if_ether.h>
+#endif
+#elif WIN
+#include <iphlpapi.h>
+#include <process.h>
+#endif
+
+#include "cross_net.h"
+#include "cross_log.h"
+
+/*----------------------------------------------------------------------------*/
+/* globals */
+/*----------------------------------------------------------------------------*/
+extern log_level	util_loglevel;
+
+/*----------------------------------------------------------------------------*/
+/* locals */
+/*----------------------------------------------------------------------------*/
+static log_level 		*loglevel = &util_loglevel;
+
+/*----------------------------------------------------------------------------*/
+/* 																			  */
+/* NETWORK management													 	  */
+/* 																			  */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+// mac address
+#if LINUX
+// search first 4 interfaces returned by IFCONF
+void get_mac(uint8_t mac[]) {
+	struct ifconf ifc;
+	struct ifreq *ifr, *ifend;
+	struct ifreq ifreq;
+	struct ifreq ifs[4];
+
+	memset(mac, 0, 6);
+
+	int s = socket(AF_INET, SOCK_DGRAM, 0);
+
+	ifc.ifc_len = sizeof(ifs);
+	ifc.ifc_req = ifs;
+
+	if (ioctl(s, SIOCGIFCONF, &ifc) == 0) {
+		ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
+
+		for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
+			if (ifr->ifr_addr.sa_family == AF_INET) {
+
+				strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
+				if (ioctl (s, SIOCGIFHWADDR, &ifreq) == 0) {
+					memcpy(mac, ifreq.ifr_hwaddr.sa_data, 6);
+					if (mac[0]+mac[1]+mac[2] != 0) {
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	close(s);
+}
+#elif OSX || FREEBSD || SUNOS
+void get_mac(uint8_t mac[]) {
+	struct ifaddrs *addrs, *ptr;
+	const struct sockaddr_dl *dlAddr;
+	const unsigned char *base;
+
+	memset(mac, 0, 6);
+
+	if (getifaddrs(&addrs) == 0) {
+		ptr = addrs;
+		while (ptr) {
+			if (ptr->ifa_addr->sa_family == AF_LINK && ((const struct sockaddr_dl *) ptr->ifa_addr)->sdl_type == IFT_ETHER) {
+				dlAddr = (const struct sockaddr_dl *)ptr->ifa_addr;
+				base = (const unsigned char*) &dlAddr->sdl_data[dlAddr->sdl_nlen];
+				memcpy(mac, base, min(dlAddr->sdl_alen, 6));
+				break;
+			}
+			ptr = ptr->ifa_next;
+		}
+		freeifaddrs(addrs);
+	}
+}
+#elif WIN
+#pragma comment(lib, "IPHLPAPI.lib")
+void get_mac(uint8_t mac[]) {
+	IP_ADAPTER_INFO AdapterInfo[16];
+	DWORD dwBufLen = sizeof(AdapterInfo);
+	DWORD dwStatus = GetAdaptersInfo(AdapterInfo, &dwBufLen);
+
+	memset(mac, 0, 6);
+
+	if (GetAdaptersInfo(AdapterInfo, &dwBufLen) == ERROR_SUCCESS) {
+		memcpy(mac, AdapterInfo[0].Address, 6);
+	}
+}
+#endif
+
+/*----------------------------------------------------------------------------*/
+#if LINUX
+int SendARP(in_addr_t src, in_addr_t dst, uint8_t mac[], uint32_t * size) {
+	int                 s;
+	struct arpreq       areq;
+	struct sockaddr_in *sin;
+
+	/* Get an internet domain socket. */
+	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
+		return -1;
+	}
+
+	/* Make the ARP request. */
+	memset(&areq, 0, sizeof(areq));
+	sin = (struct sockaddr_in *) &areq.arp_pa;
+	sin->sin_family = AF_INET;
+
+	sin->sin_addr.s_addr = src;
+	sin = (struct sockaddr_in *) &areq.arp_ha;
+	sin->sin_family = ARPHRD_ETHER;
+
+	strncpy(areq.arp_dev, "eth0", 15);
+
+	if (ioctl(s, SIOCGARP, (caddr_t) &areq) == -1) {
+		return -1;
+	}
+
+	memcpy(mac, &(areq.arp_ha.sa_data), *size);
+	return 0;
+}
+#elif OSX
+int SendARP(in_addr_t src, in_addr_t dst, uint8_t mac[], uint32_t* size) {
+	int mib[6];
+	size_t needed;
+	char *lim, *buf, *next;
+	struct rt_msghdr *rtm;
+	struct sockaddr_inarp *sin;
+	struct sockaddr_dl *sdl;
+	int found_entry = -1;
+
+	mib[0] = CTL_NET;
+	mib[1] = PF_ROUTE;
+	mib[2] = 0;
+	mib[3] = AF_INET;
+	mib[4] = NET_RT_FLAGS;
+	mib[5] = RTF_LLINFO;
+
+	if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
+		return (found_entry);
+
+	if ((buf = malloc(needed)) == NULL)
+		return (found_entry);
+
+	if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0)
+		return (found_entry);
+
+	lim = buf + needed;
+	for (next = buf; next < lim; next += rtm->rtm_msglen)
+	{
+		rtm = (struct rt_msghdr *)next;
+		sin = (struct sockaddr_inarp *)(rtm + 1);
+		sdl = (struct sockaddr_dl *)(sin + 1);
+
+		if (src)
+		{
+			if (src != sin->sin_addr.s_addr)
+				continue;
+		}
+
+		if (sdl->sdl_alen)
+		{
+			found_entry = 0;
+			memcpy(mac,  LLADDR(sdl), sdl->sdl_alen);
+		}
+	}
+
+	free(buf);
+	return (found_entry);
+}
+#elif !WIN
+int SendARP(in_addr_t src, in_addr_t dst, uint8_t mac[], uint32_t * size) {
+	LOG_WARN("No SendARP build for this platform", NULL);
+	return 1;
+}
+#endif
+
+/*---------------------------------------------------------------------------*/
+struct in_addr get_interface(char* in, char **iface, uint32_t *mask) {
+	struct in_addr addr;
+
+	// try to get the address from the parameter
+	addr.s_addr = in && *in ? inet_addr(in) : INADDR_NONE;
+
+#if WIN
+	bool done = false;
+	ULONG size = sizeof(IP_ADAPTER_ADDRESSES) * 64;
+
+	// otherwise we need to loop and find somethign that works
+	IP_ADAPTER_ADDRESSES* adapters = (IP_ADAPTER_ADDRESSES*)malloc(size);
+	int ret = GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_GATEWAYS | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_ANYCAST, 0, adapters, &size);
+
+	for (PIP_ADAPTER_ADDRESSES adapter = adapters; ret == ERROR_SUCCESS && adapter && !done; adapter = adapter->Next) {
+		if (adapter->TunnelType == TUNNEL_TYPE_TEREDO || adapter->OperStatus != IfOperStatusUp)	continue;
+
+		char name[256];
+		wcstombs(name, adapter->FriendlyName, sizeof(name));
+
+		// we are looking for an addr from an iface
+		if (addr.s_addr == INADDR_NONE) {
+			if (in && *in && strcasecmp(in, name)) continue;
+
+			for (IP_ADAPTER_UNICAST_ADDRESS* unicast = adapter->FirstUnicastAddress; unicast && !done; unicast = unicast->Next) {
+				if (adapter->FirstGatewayAddress && unicast->Address.lpSockaddr->sa_family == AF_INET) {
+					addr = ((struct sockaddr_in*)unicast->Address.lpSockaddr)->sin_addr;
+					if (mask) *mask = htonl(0xFFFFFFFF << (32 - unicast->OnLinkPrefixLength));
+					if (iface) *iface = strdup(name);
+					done = true;
+				}
+			}
+		} else {
+			for (IP_ADAPTER_UNICAST_ADDRESS* unicast = adapter->FirstUnicastAddress; unicast && !done; unicast = unicast->Next) {
+				if (adapter->FirstGatewayAddress && unicast->Address.lpSockaddr->sa_family == AF_INET && 
+					((struct sockaddr_in*)unicast->Address.lpSockaddr)->sin_addr.s_addr == addr.s_addr) {
+					addr = ((struct sockaddr_in*)unicast->Address.lpSockaddr)->sin_addr;
+					if (mask) *mask = htonl(0xFFFFFFFF << (32 - unicast->OnLinkPrefixLength));
+					if (iface) *iface = strdup(name);
+					done = true;
+				}
+			}
+
+		}
+	}
+
+	free(adapters);
+	return addr;
+#else
+	struct ifaddrs* ifaddr;
+
+	if (getifaddrs(&ifaddr) == -1) 	return addr;
+
+	for (struct ifaddrs* ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
+		if (ifa->ifa_addr == NULL || ifa->ifa_addr->sa_family != AF_INET ||
+			!(ifa->ifa_flags & IFF_UP) || !(ifa->ifa_flags & IFF_MULTICAST) ||
+			(ifa->ifa_flags & IFF_LOOPBACK)) continue;
+
+		// we are looking for an addr from an iface
+		if (addr.s_addr == INADDR_NONE) {
+			if (in && *in && strcasecmp(in, ifa->ifa_name)) continue;
+		} else {
+			if (((struct sockaddr_in*)ifa->ifa_addr)->sin_addr.s_addr != addr.s_addr) continue;
+		}
+
+		addr = ((struct sockaddr_in*)ifa->ifa_addr)->sin_addr;
+		if (mask) *mask = ((struct sockaddr_in*)ifa->ifa_netmask)->sin_addr.s_addr;
+		if (iface) *iface = strdup(ifa->ifa_name);
+		break;
+	}
+
+	freeifaddrs(ifaddr);
+	return addr;
+#endif
+}
+
+/*---------------------------------------------------------------------------*/
+#define MAX_INTERFACES 256
+#define DEFAULT_INTERFACE 1
+#if !defined(_WIN32)
+#define INVALID_SOCKET (-1)
+#endif
+in_addr_t get_localhost(char **name) {
+#ifdef _WIN32
+	char buf[256];
+	struct hostent *h = NULL;
+	struct sockaddr_in LocalAddr;
+
+	memset(&LocalAddr, 0, sizeof(LocalAddr));
+
+	gethostname(buf, 256);
+	h = gethostbyname(buf);
+
+	if (name) *name = strdup(buf);
+
+	if (h != NULL) {
+		memcpy(&LocalAddr.sin_addr, h->h_addr_list[0], 4);
+		return LocalAddr.sin_addr.s_addr;
+	}
+	else return INADDR_ANY;
+#elif defined (__APPLE__) || defined(__FreeBSD__)
+	struct ifaddrs *ifap, *ifa;
+
+	if (name) {
+		*name = malloc(256);
+		gethostname(*name, 256);
+	}
+
+	if (getifaddrs(&ifap) != 0) return INADDR_ANY;
+
+	/* cycle through available interfaces */
+	for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
+		/* Skip loopback, point-to-point and down interfaces,
+		 * except don't skip down interfaces
+		 * if we're trying to get a list of configurable interfaces. */
+		if ((ifa->ifa_flags & IFF_LOOPBACK) ||
+			(!( ifa->ifa_flags & IFF_UP))) {
+			continue;
+		}
+		if (ifa->ifa_addr->sa_family == AF_INET) {
+			/* We don't want the loopback interface. */
+			if (((struct sockaddr_in *)(ifa->ifa_addr))->sin_addr.s_addr ==
+				htonl(INADDR_LOOPBACK)) {
+				continue;
+			}
+			return ((struct sockaddr_in *)(ifa->ifa_addr))->sin_addr.s_addr;
+			break;
+		}
+	}
+	freeifaddrs(ifap);
+
+	return INADDR_ANY;
+#elif defined(__linux__) || defined(sun)
+	char szBuffer[MAX_INTERFACES * sizeof (struct ifreq)];
+	struct ifconf ifConf;
+	struct ifreq ifReq;
+	int nResult;
+	long unsigned int i;
+	int LocalSock;
+	struct sockaddr_in LocalAddr;
+	int j = 0;
+
+	if (name) {
+		*name = malloc(256);
+		gethostname(*name, 256);
+	}
+
+	/* purify */
+	memset(&ifConf,  0, sizeof(ifConf));
+	memset(&ifReq,   0, sizeof(ifReq));
+	memset(szBuffer, 0, sizeof(szBuffer));
+	memset(&LocalAddr, 0, sizeof(LocalAddr));
+
+	/* Create an unbound datagram socket to do the SIOCGIFADDR ioctl on.  */
+	LocalSock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+	if (LocalSock == INVALID_SOCKET) return false;
+	/* Get the interface configuration information... */
+	ifConf.ifc_len = (int)sizeof szBuffer;
+	ifConf.ifc_ifcu.ifcu_buf = (caddr_t) szBuffer;
+	nResult = ioctl(LocalSock, SIOCGIFCONF, &ifConf);
+	if (nResult < 0) {
+		close(LocalSock);
+		return INADDR_ANY;
+	}
+
+	/* Cycle through the list of interfaces looking for IP addresses. */
+	for (i = 0lu; i < (long unsigned int)ifConf.ifc_len && j < DEFAULT_INTERFACE; ) {
+		struct ifreq *pifReq =
+			(struct ifreq *)((caddr_t)ifConf.ifc_req + i);
+		i += sizeof *pifReq;
+		/* See if this is the sort of interface we want to deal with. */
+		memset(ifReq.ifr_name, 0, sizeof(ifReq.ifr_name));
+		memcpy(ifReq.ifr_name, pifReq->ifr_name,
+			sizeof(ifReq.ifr_name) - 1);
+		/* Skip loopback, point-to-point and down interfaces,
+		 * except don't skip down interfaces
+		 * if we're trying to get a list of configurable interfaces. */
+		ioctl(LocalSock, SIOCGIFFLAGS, &ifReq);
+		if ((ifReq.ifr_flags & IFF_LOOPBACK) ||
+			(!(ifReq.ifr_flags & IFF_UP))) {
+			continue;
+		}
+		if (pifReq->ifr_addr.sa_family == AF_INET) {
+			/* Get a pointer to the address...*/
+			memcpy(&LocalAddr, &pifReq->ifr_addr,
+				sizeof pifReq->ifr_addr);
+			/* We don't want the loopback interface. */
+			if (LocalAddr.sin_addr.s_addr ==
+				htonl(INADDR_LOOPBACK)) {
+				continue;
+			}
+		}
+		/* increment j if we found an address which is not loopback
+		 * and is up */
+		j++;
+	}
+	close(LocalSock);
+
+	return LocalAddr.sin_addr.s_addr;
+#else
+	// missing platform here ...
+	return INADDR_ANY;
+#endif
+}
+
+#define IP_HEADER_SIZE 20
+#define ICMP_HEADER_SIZE 8
+#define ICMP_ECHO 8
+#define ICMP_REPLY 0
+
+/*----------------------------------------------------------------------------*/
+static uint16_t checksum(void* b, int len) {
+	unsigned short* buf = b;
+	unsigned int sum = 0;
+
+	for (sum = 0; len > 1; len -= 2) sum += *buf++;
+	if (len == 1) sum += *(unsigned char*)buf;
+
+	sum = (sum >> 16) + (sum & 0xFFFF);
+	sum += (sum >> 16);
+	return ~sum;
+}
+
+/*----------------------------------------------------------------------------*/
+bool ping_host(struct in_addr host, int wait) {
+	struct icmp_s {
+		uint8_t  type, code;
+		uint16_t checksum, id, sequence;
+	} icmp;
+
+	int sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
+	bool alive = false;
+
+	struct sockaddr_in addr;
+	memset(&addr, 0, sizeof(addr));
+	addr.sin_family = AF_INET;
+	addr.sin_addr = host;
+
+	memset(&icmp, 0, sizeof(icmp));
+	icmp.type = ICMP_ECHO;
+	icmp.id = getpid();
+	icmp.sequence = 1;
+	icmp.checksum = checksum(&icmp, sizeof(icmp));
+
+	// Send the packet
+	sendto(sock, (void*)&icmp, sizeof(icmp), 0, (struct sockaddr*)&addr, sizeof(addr));
+
+	fd_set rfds;
+	FD_ZERO(&rfds);
+	FD_SET(sock, &rfds);
+	struct timeval timeout = { 0, wait * 1000 };
+
+	if (!wait || select(sock, &rfds, NULL, NULL, &timeout) > 0) {
+		socklen_t addrlen = sizeof(addr);
+		char buffer[sizeof(icmp) + IP_HEADER_SIZE];
+
+		if (recvfrom(sock, (void*)&buffer, sizeof(buffer), 0, (struct sockaddr*)&addr, &addrlen) > 0) {
+			struct icmp_s* icmp = (struct icmp_s*)(buffer + IP_HEADER_SIZE);
+			if (icmp->type == 0) alive = true;
+		}
+	}
+
+	closesocket(sock);
+	return alive;
+}
+
+/*----------------------------------------------------------------------------*/
+void netsock_init(void) {
+#if WIN
+	WSADATA wsaData;
+	WORD wVersionRequested = MAKEWORD(2, 2);
+	int WSerr = WSAStartup(wVersionRequested, &wsaData);
+	if (WSerr != 0) {
+		LOG_ERROR("Bad winsock version", NULL);
+		exit(1);
+	}
+#endif
+}
+
+/*----------------------------------------------------------------------------*/
+void netsock_close(void) {
+#if WIN
+	WSACleanup();
+#endif
+}
+
+/*----------------------------------------------------------------------------*/
+int shutdown_socket(int sd) {
+	if (sd <= 0) return -1;
+
+#if WIN
+	shutdown(sd, SD_BOTH);
+#else
+	shutdown(sd, SHUT_RDWR);
+#endif
+	return closesocket(sd);
+}
+
+/*----------------------------------------------------------------------------*/
+void set_nonblock(int sd) {
+#if WIN
+	u_long iMode = 1;
+	ioctlsocket(sd, FIONBIO, &iMode);
+#else
+	int flags = fcntl(sd, F_GETFL, 0);
+	fcntl(sd, F_SETFL, flags | O_NONBLOCK);
+#endif
+}
+
+/*----------------------------------------------------------------------------*/
+void set_block(int sd) {
+#if WIN
+	u_long iMode = 0;
+	ioctlsocket(sd, FIONBIO, &iMode);
+#else
+	int flags = fcntl(sd, F_GETFL, 0);
+	fcntl(sd, F_SETFL, flags & ~O_NONBLOCK);
+#endif
+}
+
+/*----------------------------------------------------------------------------*/
+void set_nosigpipe(int sd) {
+#if OSX
+	int set = 1;
+	setsockopt(sd, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int));
+#endif
+}
+
+/*----------------------------------------------------------------------------*/
+bool tcp_connect(int sd, struct sockaddr_in peer) {
+	for (size_t count = 0; count < 2; count++) {
+		if (connect(sd, (struct sockaddr*) &peer, sizeof(struct sockaddr)) < 0) {
+			return true;
+		}
+		usleep(100 * 1000);
+	}
+
+	LOG_ERROR("cannot connect addr=%s, port=%d", inet_ntoa(peer.sin_addr), ntohs(peer.sin_port));
+	return false;
+}
+
+/*----------------------------------------------------------------------------*/
+bool tcp_connect_by_host(int sd, struct in_addr peer, unsigned short port) {
+	struct sockaddr_in addr;
+
+	addr.sin_family = AF_INET;
+	addr.sin_addr.s_addr = peer.s_addr;
+	addr.sin_port = htons(port);
+
+	return tcp_connect(sd, addr);
+}
+
+/*----------------------------------------------------------------------------*/
+int tcp_connect_loopback(unsigned short port) {
+	struct sockaddr_in addr;
+	int sd;
+
+	sd = socket(AF_INET, SOCK_STREAM, 0);
+
+	addr.sin_family = AF_INET;
+	addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+	addr.sin_port = htons(port);
+
+	if (sd < 0 || connect(sd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+		close(sd);
+		return -1;
+	}
+
+	LOG_DEBUG("created socket %d", sd);
+
+	return sd;
+}
+
+/*----------------------------------------------------------------------------*/
+// connect for socket already set to non blocking with timeout in ms
+int tcp_connect_timeout(int sd, const struct sockaddr_in addr, int ms) {
+	fd_set w, e;
+	struct timeval tval;
+	socklen_t addrlen = sizeof(addr);
+
+	if (connect(sd, (struct sockaddr*) &addr, addrlen) < 0) {
+#if WIN
+		if (last_error() != WSAEWOULDBLOCK) {
+#else
+		if (last_error() != EINPROGRESS) {
+#endif
+			LOG_ERROR("failed connect() socket %d (errno: %d)", sd, last_error());
+			return -1;
+		}
+	}
+
+	FD_ZERO(&w);
+	FD_SET(sd, &w);
+	e = w;
+	tval.tv_sec = ms / 1000;
+	tval.tv_usec = (ms - tval.tv_sec * 1000) * 1000;
+
+	// only return 0 if w set and sock error is zero, otherwise return error code
+	if (select(sd + 1, NULL, &w, &e, ms ? &tval : NULL) == 1 && FD_ISSET(sd, &w)) {
+		int	error = 0;
+		socklen_t len = sizeof(error);
+		getsockopt(sd, SOL_SOCKET, SO_ERROR, (void*) &error, &len);
+		return error;
+	}
+
+	LOG_ERROR("failed connecting on select() socket %d", sd);
+	return -1;
+}
+
+/*----------------------------------------------------------------------------*/
+int open_tcp_socket(struct in_addr host, unsigned short* port, bool blocking) {
+	int sd;
+	int optval = 1;
+
+	/* socket creation */
+	sd = socket(AF_INET, SOCK_STREAM, 0);
+
+	if (blocking) set_block(sd);
+	else set_nonblock(sd);
+
+	if (sd < 0) {
+		LOG_ERROR("cannot create tcp socket %x", host);
+		return -1;
+	}
+
+	setsockopt(sd, SOL_SOCKET, SO_KEEPALIVE, (void*)&optval, sizeof(optval));
+#if 0 //only Linux supports this
+	optval = 120;
+	optval = setsockopt(sd, SOL_TCP, TCP_KEEPIDLE, &optval, sizeof(optval));
+	optval = 60;
+	optval = setsockopt(sd, SOL_TCP, TCP_KEEPINTVL, &optval, sizeof(optval));
+	optval = 10;
+	optval = setsockopt(sd, SOL_TCP, TCP_KEEPCNT, &optval, sizeof(optval));
+#endif
+
+	if (!bind_host(sd, host, port)) {
+		closesocket(sd);
+		return -1;
+	}
+
+	return sd;
+}
+
+/*----------------------------------------------------------------------------*/
+int open_udp_socket(struct in_addr host, unsigned short* port, bool blocking) {
+	int sd;
+
+	/*socket creation*/
+	sd = socket(AF_INET, SOCK_DGRAM, 0);
+	if (!blocking) set_nonblock(sd);
+
+	if (sd < 0) {
+		LOG_ERROR("cannot create udp socket %x", host);
+		return -1;
+	}
+
+	if (!bind_host(sd, host, port)) {
+		closesocket(sd);
+		return -1;
+	}
+	return sd;
+}
+
+/*----------------------------------------------------------------------------*/
+int bind_socket(struct in_addr host, unsigned short* port, int mode) {
+	int sock;
+
+	if ((sock = socket(AF_INET, mode, 0)) < 0) {
+		LOG_ERROR("cannot create socket %d", sock);
+		return sock;
+	}
+
+	if (!bind_host(sock, host, port)) {
+		closesocket(sock);
+		return -1;
+	}
+
+	LOG_INFO("socket binding %d on port %d", sock, *port);
+
+	return sock;
+}
+
+/*----------------------------------------------------------------------------*/
+bool bind_host(int sd, struct in_addr host, unsigned short* port) {
+	struct sockaddr_in addr;
+	socklen_t nlen = sizeof(struct sockaddr);
+
+	memset(&addr, 0, sizeof(addr));
+
+	addr.sin_addr.s_addr = host.s_addr;
+	addr.sin_family = AF_INET;
+	addr.sin_port = port ? htons(*port) : 0;
+#ifdef SIN_LEN
+	addr.sin_len = sizeof(si);
+#endif
+
+	if (bind(sd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+		if (!*port) LOG_ERROR("cannot bind: %s", strerror(errno));
+		return false;
+	}
+
+	if (port && *port == 0) {
+		getsockname(sd, (struct sockaddr*)&addr, &nlen);
+		*port = ntohs(addr.sin_port);
+	}
+
+	return true;
+}
+
+/*----------------------------------------------------------------------------*/
+/* 																			  */
+/* HTTP pico server														 	  */
+/* 																			  */
+/*----------------------------------------------------------------------------*/
+
+static struct {
+	cross_queue_t sources, clients;
+	bool running;
+	pthread_t thread;
+	int sock;
+	uint16_t port;
+	struct in_addr host;
+} picoServer;
+
+struct http_pico_source_s {
+	char* body;
+	int len;
+	char* url, * content_type;
+	uint32_t expiration;
+	int clients;
+};
+
+struct http_pico_client_s {
+	struct http_pico_source_s* source;
+	size_t position;
+	int sock;
+	uint32_t expiration;
+};
+
+static void* http_pico_thread(void* arg);
+static struct http_pico_source_s* handle_connection(int sock);
+static void free_source(void* p);
+static void free_client(void* p);
+
+/*----------------------------------------------------------------------------*/
+bool http_pico_init(struct in_addr host, uint16_t* port, uint16_t count) {
+	for (picoServer.sock = -1; count--; (*port)++) {
+		if ((picoServer.sock = bind_socket(host, port, SOCK_STREAM)) == -1) continue;
+		
+		picoServer.host = host;
+		picoServer.port = *port;
+		listen(picoServer.sock, 1);
+
+		queue_init(&picoServer.sources, true, free_source);
+		queue_init(&picoServer.clients, true, free_client);
+
+		pthread_create(&picoServer.thread, NULL, http_pico_thread, NULL);
+		return true;
+	}
+
+	LOG_INFO("cannot find a socket for pico http server");
+	return false;
+}
+
+/*----------------------------------------------------------------------------*/
+void http_pico_close(void) {
+	picoServer.running = false;
+	pthread_join(picoServer.thread, NULL);
+	queue_flush(&picoServer.clients);
+	queue_flush(&picoServer.sources);
+}
+
+/*----------------------------------------------------------------------------*/
+char* http_pico_add_source(char* url, char* content_type, uint8_t* body, size_t len, uint32_t expiration) {
+	if (!picoServer.running) return NULL;
+	struct http_pico_source_s* item = malloc(sizeof(struct http_pico_source_s));
+
+	item->expiration = expiration ? gettime_ms() + expiration * 1000 : 0;
+	item->clients = 0;
+	item->url = strdup(url);
+	item->content_type = strdup(content_type);
+	item->body = malloc(len);
+	item->len = len;
+	memcpy(item->body, body, len);
+	queue_insert(&picoServer.sources, item);
+
+	char* uri = NULL;
+	(void)!asprintf(&uri, "http://%s:%hu%s", inet_ntoa(picoServer.host), picoServer.port, url);
+
+	LOG_INFO("source %s added", url);
+	return uri;
+}
+
+/*----------------------------------------------------------------------------*/
+void http_pico_del_source(char* url) {
+	queue_lock(&picoServer.sources);
+	for (struct _cross_queue_s* walker = &picoServer.sources.head; walker->item; walker = walker->next) {
+		struct http_pico_source_s* source = (struct http_pico_source_s*)walker->item;
+		if (!strcasecmp(url, source->url)) {
+			source->expiration = gettime_ms();
+			break;
+		}
+	}
+	queue_unlock(&picoServer.sources);
+}
+
+/*----------------------------------------------------------------------------*/
+static void free_source(void* p) {
+	struct http_pico_source_s* item = (struct http_pico_source_s*)p;
+	if (item->clients == 0) {
+		LOG_INFO("source %s released", item->url);
+		free(item->body);
+		free(item->url);
+		free(item->content_type);
+		free(item);
+	} else {
+		LOG_WARN("source %s cannot be released (%d clients active)", item->url, item->clients);
+	}
+}
+
+/*----------------------------------------------------------------------------*/
+static void free_client(void* p) {
+	struct http_pico_client_s* item = (struct http_pico_client_s*)p;
+	if (item->sock != -1) closesocket(item->sock);
+	if (item->source->clients) item->source->clients--;
+	LOG_INFO("release client %u for source %s", item->sock, item->source->url);
+	free(item);
+}
+
+/*----------------------------------------------------------------------------*/
+static void* http_pico_thread(void* arg) {
+	picoServer.running = true;
+	fd_set rfds, wfds;
+
+	FD_ZERO(&rfds);
+	FD_ZERO(&wfds);
+	FD_SET(picoServer.sock, &rfds);
+	int maxSock = picoServer.sock;
+
+	while (picoServer.running) {
+		struct timeval timeout = { 0, 250 * 1000 };
+
+		// only check read status on main server's socket
+		FD_ZERO(&rfds);
+		FD_SET(picoServer.sock, &rfds);
+		int n = select(maxSock + 1, &rfds, &wfds, NULL, &timeout);
+		maxSock = picoServer.sock;
+
+		// if we have nothing to read, write and no source or client then just loop
+		if (n <= 0 && !queue_count(&picoServer.clients) && !queue_count(&picoServer.sources)) {
+			FD_ZERO(&wfds);
+			continue;
+		}
+
+		uint32_t now = gettime_ms();
+
+		// serve new incoming requests
+		if (n > 0 && FD_ISSET(picoServer.sock, &rfds)) {
+			int sock = accept(picoServer.sock, NULL, NULL);
+
+			if (sock != -1 && picoServer.running) {
+				struct http_pico_source_s* source = handle_connection(sock);
+				if (source) {
+					struct http_pico_client_s* client = malloc(sizeof(struct http_pico_client_s));
+					client->position = 0;
+					client->sock = sock;
+					client->source = source;
+					client->expiration = now + 60 * 1000;
+					queue_insert(&picoServer.clients, client);
+					source->clients++;
+					LOG_INFO("got artwork %s connection %u", source->url, sock);
+				} else {
+					LOG_INFO("source not found or HEAD request %u", sock);
+					if (sock != -1) shutdown_socket(sock);
+				}
+			}
+		}
+		
+		// review active clients
+		for (struct http_pico_client_s* client = queue_walk_start(&picoServer.clients); client; client = queue_walk_next(&picoServer.clients)) {
+			// remove clients that are timedout
+			if (now > client->expiration) {
+				queue_walk_extract(&picoServer.clients);
+				free_client(client);
+				continue;
+			} 
+			
+			// send data to all writable clients
+			if (n > 0 && FD_ISSET(client->sock, &wfds)) {
+				size_t bytes = min(8192, client->source->len - client->position);
+				int sent = send(client->sock, client->source->body + client->position, bytes, 0);
+				if (sent > 0) client->position += bytes;
+
+				// close connection and erase context if done
+				if (sent <= 0 || client->position == client->source->len) {
+					LOG_INFO("served artwork %s", client->source->url);
+					queue_walk_extract(&picoServer.clients);
+					FD_CLR(client->sock, &wfds);
+					free_client(client);
+					continue;
+				}
+			}
+
+			// update wfds and maxsock
+			if (client->sock != -1) {
+				FD_SET(client->sock, &wfds);
+				maxSock = max(maxSock, client->sock);
+			}
+		}
+		queue_walk_end(&picoServer.clients);
+
+		// review active sources and remove expired ones
+		for (struct http_pico_source_s* source = queue_walk_start(&picoServer.sources); source; source = queue_walk_next(&picoServer.sources)) {
+			if (source->expiration && now > source->expiration && source->clients == 0) {
+				queue_walk_extract(&picoServer.sources);
+				free_source(source);
+			}
+		}
+		queue_walk_end(&picoServer.sources);
+	}
+
+	closesocket(picoServer.sock);
+	return NULL;
+}
+
+/*----------------------------------------------------------------------------*/
+static struct http_pico_source_s* handle_connection(int sock) {
+	char method[16], resource[64] = "";
+	key_data_t headers[16], resp[8] = { {NULL, NULL} };
+	struct http_pico_source_s* source = NULL;
+	int len;
+	uint32_t now = gettime_ms();
+	
+	if (!http_parse(sock, method, resource, NULL, headers, NULL, &len)) {
+		kd_free(headers);
+		return NULL;
+	}
+
+	// find a source that can serve that url
+	queue_lock(&picoServer.sources);
+	for (struct _cross_queue_s* walker = &picoServer.sources.head; walker->item; walker = walker->next) {
+		struct http_pico_source_s* item = (struct http_pico_source_s*)walker->item;
+		if (strcasecmp(resource, item->url) || (item->expiration && now > item->expiration)) continue;
+
+		source = item;
+		kd_add(resp, "Server", "picohttp");
+		kd_add(resp, "Content-Type", item->content_type);
+		kd_add(resp, "Connection", "close");
+		kd_vadd(resp, "Content-Length", "%zu", item->len);
+		break;
+	}
+	queue_unlock(&picoServer.sources);
+
+	char *buf = http_send(sock, source ? "HTTP/1.0 200 OK" : "HTTP/1.0 404 Not Found", resp);
+	LOG_INFO("url %s request:\n%s", resource, buf);
+		
+	NFREE(buf);
+	kd_free(resp);
+	kd_free(headers);
+
+	// only return a source if this is not a HEAD request
+	return strcasecmp(method, "HEAD") ? source : NULL;
+}
+
+/*----------------------------------------------------------------------------*/
+/* 																			  */
+/* HTTP management														 	  */
+/* 																			  */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+bool http_parse(int sock, char* method, char* resource, char* proto, key_data_t* rkd, char** body, int* len) {
+	char* request = NULL;
+	bool res = http_parse_simple(sock, &request, rkd, body, len);
+
+	if (res && request) {
+		if (method) sscanf(request, "%s", method);
+		if (resource) sscanf(request, "%*s%s", resource);
+		if (proto) sscanf(request, "%*s%*s%s", proto);
+	}
+
+	if (request) free(request);
+
+	return res;
+}
+
+/*----------------------------------------------------------------------------*/
+bool http_parse_simple(int sock, char **request, key_data_t* rkd, char** body, int* len) {
+	char line[1024];
+	int i, timeout = 250;
+
+	rkd[0].key = NULL;
+
+	if ((i = http_read_line(sock, line, sizeof(line), timeout, true)) <= 0) {
+		if (i < 0) {
+			LOG_ERROR("cannot read method", NULL);
+		}
+		return false;
+	}
+
+	if (request) *request = strdup(line);
+
+	i = *len = 0;
+		
+	while (http_read_line(sock, line, sizeof(line), timeout, true) > 0) {
+
+		LOG_DEBUG("sock: %u, received %s", sock, line);
+
+		// line folding should be deprecated
+		if (i && rkd[i].key && (line[0] == ' ' || line[0] == '\t')) {
+			unsigned j;
+			for (j = 0; j < strlen(line); j++) if (line[j] != ' ' && line[j] != '\t') break;
+			rkd[i].data = realloc(rkd[i].data, strlen(rkd[i].data) + strlen(line + j) + 1);
+			strcat(rkd[i].data, line + j);
+			continue;
+		}
+
+		char* dp = strstr(line, ":");
+
+		if (!dp) {
+			LOG_ERROR("Request failed, bad header", NULL);
+			kd_free(rkd);
+			return false;
+		}
+
+		*dp = 0;
+		rkd[i].key = strdup(line);
+		rkd[i].data = strdup(strltrim(dp + 1));
+
+		if (len && !strcasecmp(rkd[i].key, "Content-Length")) *len = atol(rkd[i].data);
+
+		i++;
+		rkd[i].key = NULL;
+	}
+
+	if (len && *len) {
+		int size = 0;
+
+		*body = malloc(*len + 1);
+		while (*body && size < *len) {
+			int bytes = recv(sock, *body + size, *len - size, 0);
+			if (bytes <= 0) break;
+			size += bytes;
+		}
+
+		(*body)[*len] = '\0';
+
+		if (!*body || size != *len) {
+			LOG_ERROR("content length receive error %d %d", *len, size);
+		}
+	}
+
+	return true;
+}
+
+/*----------------------------------------------------------------------------*/
+int http_read_line(int fd, char* line, int maxlen, int timeout, bool polling) {
+	int i, rval;
+	int count = 0;
+	struct pollfd pfds;
+	char ch;
+
+	*line = 0;
+	pfds.fd = fd;
+	pfds.events = POLLIN;
+
+	for (i = 0; i < maxlen; i++) {
+		if (!polling || poll(&pfds, 1, timeout)) rval = recv(fd, &ch, 1, 0);
+		else return 0;
+
+		if (rval == -1) {
+			if (errno == EAGAIN) return 0;
+			LOG_ERROR("fd: %d read error: %s", fd, strerror(errno));
+			return -1;
+		}
+
+		if (rval == 0) {
+			LOG_INFO("disconnected on the other end %u", fd);
+			return 0;
+		}
+
+		if (ch == '\n') {
+			*line = 0;
+			return count;
+		}
+
+		if (ch == '\r') continue;
+
+		*line++ = ch;
+		count++;
+		if (count >= maxlen - 1) break;
+	}
+
+	*line = 0;
+	return count;
+}
+
+/*----------------------------------------------------------------------------*/
+char* http_send(int sock, const char* method, key_data_t* rkd) {
+	unsigned sent, len;
+	char* resp = kd_dump(rkd);
+	char* data = malloc(strlen(method) + 2 + strlen(resp) + 2 + 1);
+
+	len = sprintf(data, "%s\r\n%s\r\n", method, resp);
+	NFREE(resp);
+
+	sent = send(sock, data, len, 0);
+
+	if (sent != len) {
+		LOG_ERROR("HTTP send() error:%s %u (strlen=%u)", data, sent, len);
+		NFREE(data);
+	}
+
+	return data;
+}
+