react-native-queue-player 1.0.0

package/android/src/main/cpp/third_party/crosstools/cross_util.h

@@ -0,0 +1,125 @@
+/*
+ * Misc utilities
+ *
+ * (c) Philippe, philippe_44@outlook.com
+ *
+ * See LICENSE file
+ *
+ */
+
+#pragma once
+
+#include <stdint.h>
+#if __has_include("pthread.h")
+#include "pthread.h"
+#define HAS_PTHREAD
+#else 
+#endif
+
+#include "platform.h"
+
+#define NFREE(p) do {	\
+	if (p) {			\
+		free(p);		\
+		p = NULL;		\
+	}					\
+} while (0)
+
+/*
+Queues (N+1 elements in a linked list, pointed item = NULL means last element)
+*/
+typedef struct {
+#ifdef HAS_PTHREAD
+	pthread_mutex_t* mutex;
+#elif defined(_WIN32)
+	HANDLE* mutex;
+#else 
+	void* mutex;
+#endif
+	void (*cleanup)(void*);
+	struct _cross_queue_s {
+		struct _cross_queue_s* next;
+		void* item;
+	} head, *walker;
+	bool walk;
+} cross_queue_t;
+
+void	queue_init(cross_queue_t *queue, bool mutex, void (*f)(void*));
+void	queue_insert(cross_queue_t *queue, void *item);
+void	queue_insert_first(cross_queue_t* queue, void* item);
+void	queue_lock(cross_queue_t* queue);
+void	queue_unlock(cross_queue_t* queue);
+void*	queue_extract(cross_queue_t *queue);
+void	queue_flush(cross_queue_t *queue);
+void	queue_free_item(cross_queue_t* queue, void* item);
+bool	queue_extract_item(cross_queue_t* queue, void* item);
+size_t	queue_count(cross_queue_t* queue);
+
+// these are needed if current item is deleted during walk - this is not thread-safe
+void*	queue_walk_start(cross_queue_t* queue);
+void	queue_walk_end(cross_queue_t* queue);
+void*	queue_walk_next(cross_queue_t* queue);
+void*   queue_walk_extract(cross_queue_t* queue);
+
+
+/*
+Linked lists (each item can be cast to a list core structure)
+*/
+typedef struct cross_list_s {
+	struct cross_list_s* next;
+} cross_list_t;
+
+cross_list_t*	list_push(cross_list_t *item, cross_list_t **list);
+cross_list_t*	list_add_tail(cross_list_t *item, cross_list_t **list);
+cross_list_t*	list_add_ordered(cross_list_t *item, cross_list_t **list, int (*compare)(void *a, void *b));
+cross_list_t*	list_pop(cross_list_t **list);
+cross_list_t*   list_remove(cross_list_t *item, cross_list_t **list);
+void 			list_clear(cross_list_t **list, void (*free_func)(void *));
+
+/* 
+Key-Value tools
+*/
+typedef struct key_data_s {
+
+	char *key;
+	char *data;
+} key_data_t;
+
+char*		kd_lookup(key_data_t *kd, char *key);
+bool 		kd_add(key_data_t *kd, const char *key, const char *value);
+bool 		kd_vadd(key_data_t *kd, const char *key, const char *fmt, ...);
+char* 		kd_dump(key_data_t *kd);
+void 		kd_free(key_data_t *kd);
+
+/*
+String tools
+*/
+char* strextract(char* s1, char* beg, char* end);
+char* strltrim(char* s);
+char* strrtrim(char* s);
+char* strtrim(char* s);
+int   strremovechar(char* str, char c);
+
+/*
+WWW tools
+*/
+char* url_encode(char* str);
+char* url_decode(char* str);
+char* xml_encode(char* src);
+
+/*
+Base64 tools
+*/
+int base64_encode(const void* data, int size, char** str);
+int base64_decode(const char* str, void* data);
+
+/*
+Kitchen sink
+*/
+uint32_t	gettime_ms(void);
+uint64_t	gettime_ms64(void);
+uint64_t 	gettime_us(void);
+uint32_t	hash32(char* str);
+int			hex2bytes(char* hex, uint8_t** bytes);
+int			bytes2hex(uint8_t* bytes, size_t len, char** hex);
+void		touch_memory(uint8_t* buf, size_t size);

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

@@ -0,0 +1,227 @@
+/*
+ * Cross-platform functions
+ * 
+ * (c) Philippe, philippe_44@outlook.com: 
+ *
+ * See LICENSE
+ * 
+ */
+ 
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "platform.h"
+
+#if WIN
+#include <VersionHelpers.h>
+#endif
+
+/*----------------------------------------------------------------------------*/
+/* 																			  */
+/* Network																 	  */
+/* 																			  */
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+#if WIN
+int poll(struct pollfd *fds, unsigned long numfds, int timeout) {
+	// WSAPoll is broken till Windows 10, see NOTe on https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsapoll
+	if (numfds > 1 || IsWindows10OrGreater()) {
+		return WSAPoll(fds, numfds, timeout);
+	} else {
+		fd_set r, w;
+		struct timeval tv;
+
+		FD_ZERO(&r);
+		FD_ZERO(&w);
+
+		if (fds[0].events & POLLIN) FD_SET(fds[0].fd, &r);
+		if (fds[0].events & POLLOUT) FD_SET(fds[0].fd, &w);
+
+		tv.tv_sec = timeout / 1000;
+		tv.tv_usec = 1000 * (timeout % 1000);
+
+		int ret = select(fds[0].fd + 1, &r, &w, NULL, &tv);
+
+		if (ret < 0) return ret;
+
+		fds[0].revents = 0;
+		if (FD_ISSET(fds[0].fd, &r)) fds[0].revents |= POLLIN;
+		if (FD_ISSET(fds[0].fd, &w)) fds[0].revents |= POLLOUT;
+
+		return ret;
+	}
+}
+#endif
+
+/*----------------------------------------------------------------------------*/
+/* 																			  */
+/* stdlib/string														 	  */
+/* 																			  */
+/*----------------------------------------------------------------------------*/
+
+#if WIN
+/*----------------------------------------------------------------------------*/
+int asprintf(char** strp, const char* fmt, ...) {
+	va_list args;
+
+	va_start(args, fmt);
+	int len = vasprintf(strp, fmt, args);
+	va_end(args);
+
+	return len;
+}
+
+/*----------------------------------------------------------------------------*/
+int vasprintf(char** strp, const char* fmt, va_list args) {
+	int len = vsnprintf(NULL, 0, fmt, args);
+	*strp = malloc(len + 1);
+
+	if (*strp) len = vsprintf(*strp, fmt, args);
+	else len = 0;
+
+	return len;
+}
+#endif
+
+#if !WIN
+/*---------------------------------------------------------------------------*/
+char* strlwr(char* str) {
+	char* p = str;
+	while (*p) {
+		*p = tolower(*p);
+		p++;
+	}
+	return str;
+}
+#endif
+
+#if WIN
+/*---------------------------------------------------------------------------*/
+char* strcasestr(const char* haystack, const char* needle) {
+	char* haystack_lwr, * needle_lwr, * p;
+
+	haystack_lwr = strlwr(strdup(haystack));
+	needle_lwr = strlwr(strdup(needle));
+	p = strstr(haystack_lwr, needle_lwr);
+
+	if (p) p = (char*)haystack + (p - haystack_lwr);
+	free(haystack_lwr);
+	free(needle_lwr);
+	return p;
+}
+
+/*---------------------------------------------------------------------------*/
+char* strsep(char** stringp, const char* delim) {
+	char* start = *stringp;
+	char* p;
+
+	p = (start != NULL) ? strpbrk(start, delim) : NULL;
+
+	if (p == NULL) {
+		*stringp = NULL;
+	}
+	else {
+		*p = '\0';
+		*stringp = p + 1;
+	}
+
+	return start;
+}
+
+/*---------------------------------------------------------------------------*/
+char* strndup(const char* s, size_t n) {
+	char* p = malloc(n + 1);
+	strncpy(p, s, n);
+	p[n] = '\0';
+
+	return p;
+}
+#endif
+
+#if !WIN
+/*---------------------------------------------------------------------------*/
+char* itoa(int value, char* str, int radix) {
+	static char dig[] =
+		"0123456789"
+		"abcdefghijklmnopqrstuvwxyz";
+	int n = 0, neg = 0;
+	unsigned int v;
+	char* p, * q;
+	char c;
+
+	if (radix == 10 && value < 0) {
+		value = -value;
+		neg = 1;
+	}
+	v = value;
+	do {
+		str[n++] = dig[v % radix];
+		v /= radix;
+	} while (v);
+	if (neg)
+		str[n++] = '-';
+	str[n] = '\0';
+
+	for (p = str, q = p + (n - 1); p < q; ++p, --q)
+		c = *p, * p = *q, * q = c;
+	return str;
+}
+#endif
+
+
+/*----------------------------------------------------------------------------*/
+/* 																			  */
+/* SYSTEM utils															 	  */
+/* 																			  */
+/*----------------------------------------------------------------------------*/
+
+#if WIN
+/*----------------------------------------------------------------------------*/
+void* dlopen(const char* filename, int flag) {
+	SetLastError(0);
+	return LoadLibraryA(filename);
+}
+
+/*----------------------------------------------------------------------------*/
+void dlclose(void* handle) {
+	FreeLibrary(handle);
+}
+
+/*----------------------------------------------------------------------------*/
+void* dlsym(void* handle, const char* symbol) {
+	SetLastError(0);
+	return (void*)GetProcAddress(handle, symbol);
+}
+
+/*----------------------------------------------------------------------------*/
+char* dlerror(void) {
+	static char ret[32];
+	int last = GetLastError();
+	if (last) {
+		sprintf(ret, "code: %i", last);
+		SetLastError(0);
+		return ret;
+	}
+	return NULL;
+}
+
+/*----------------------------------------------------------------------------*/
+int on_exit(void (*function)(int, void*), void* arg) {
+	return 0;
+}
+#endif
+
+/*----------------------------------------------------------------------------*/
+#if !WIN
+char* GetTempPath(uint16_t size, char* path) {
+	strncpy(path, P_tmpdir, size);
+	if (!strlen(path)) strncpy(path, "/var/tmp", size);
+	path[size - 1] = '\0';
+	return path;
+}
+#endif

package/android/src/main/cpp/third_party/crosstools/platform.h

@@ -0,0 +1,127 @@
+/*
+ *  Platform setting definition
+ *
+ *  (c) Philippe, philippe_44@outlook.com
+ *
+ * See LICENSE
+ *
+ */
+
+#pragma once
+
+#if defined(__linux__)
+#define LINUX     1
+#define OSX       0
+#define WIN       0
+#define FREEBSD   0
+#define SUNOS	  0
+#elif defined (__APPLE__)
+#define LINUX     0
+#define OSX       1
+#define WIN       0
+#define FREEBSD   0
+#define SUNOS	  0
+#elif defined (_MSC_VER) || defined(__BORLANDC__)
+#define LINUX     0
+#define OSX       0
+#define WIN       1
+#define FREEBSD   0
+#define SUNOS	  0
+#elif defined(__FreeBSD__)
+#define LINUX     0
+#define OSX       0
+#define WIN       0
+#define FREEBSD   1
+#define SUNOS	  0
+#elif defined(sun)
+#define LINUX     0
+#define OSX       0
+#define WIN       0
+#define FREEBSD   0
+#define SUNOS	  1
+#else
+#error unknown target
+#endif
+
+#include <stdbool.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#if LINUX || OSX || FREEBSD || SUNOS
+#include <strings.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <sys/poll.h>
+#include <poll.h>
+#include <dlfcn.h>
+#include <pthread.h>
+#include <errno.h>
+#include <limits.h>
+
+#define min(a,b) (((a) < (b)) ? (a) : (b))
+#define max(a,b) (((a) > (b)) ? (a) : (b))
+
+// for now
+#define VALGRIND_MAKE_MEM_DEFINED(x,y)
+
+int SendARP(in_addr_t src, in_addr_t dst, uint8_t mac[], uint32_t *size);
+#define fresize(f,s) ftruncate(fileno(f), s)
+char *strlwr(char *str);
+char* itoa(int value, char* str, int radix);
+#define closesocket(s) close(s)
+
+#endif
+
+#if WIN
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <io.h>
+#include <iphlpapi.h>
+#include <sys/timeb.h>
+
+#define __attribute__(X)
+typedef SSIZE_T	ssize_t;
+
+#define usleep(x) Sleep((x)/1000)
+#define sleep(x) Sleep((x)*1000)
+
+#define open _open
+#define read _read
+
+#define fresize(f, s) chsize(fileno(f), s)
+
+void* dlopen(const char* filename, int flag);
+void  dlclose(void* handle);
+void* dlsym(void* handle, const char* symbol);
+char* dlerror(void);
+
+int on_exit(void (*function)(int, void*), void* arg);
+
+typedef uint32_t in_addr_t;
+#define socklen_t int
+
+int poll(struct pollfd* fds, unsigned long numfds, int timeout);
+
+int asprintf(char** s, const char* fmt, ...);
+int vasprintf(char** strp, const char* fmt, va_list args);
+
+#define strcasecmp stricmp
+#define strncasecmp strnicmp
+char* strcasestr(const char* haystack, const char* needle);
+char* strsep(char** stringp, const char* delim);
+char* strndup(const char* s, size_t n);
+
+#define VALGRIND_MAKE_MEM_DEFINED(x,y)
+
+#define RTLD_NOW 0
+
+#endif

package/android/src/main/cpp/third_party/curve25519/include/curve25519_dh.h

@@ -0,0 +1,53 @@
+/* The MIT License (MIT)
+ * 
+ * Copyright (c) 2015 mehdi sotoodeh
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining 
+ * a copy of this software and associated documentation files (the 
+ * "Software"), to deal in the Software without restriction, including 
+ * without limitation the rights to use, copy, modify, merge, publish, 
+ * distribute, sublicense, and/or sell copies of the Software, and to 
+ * permit persons to whom the Software is furnished to do so, subject to 
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included 
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __curve25519_dh_key_exchange_h__
+#define __curve25519_dh_key_exchange_h__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Return public key associated with sk */
+/* sk will be trimmed on return */
+void curve25519_dh_CalculatePublicKey(
+    unsigned char *pk,          /* [32-bytes] OUT: Public key */
+    unsigned char *sk);         /* [32-bytes] IN/OUT: Your secret key */
+
+/* Faster alternative for curve25519_dh_CalculatePublicKey */
+/* sk will be trimmed on return */
+void curve25519_dh_CalculatePublicKey_fast(
+    unsigned char *pk,          /* [32-bytes] OUT: Public key */
+    unsigned char *sk);         /* [32-bytes] IN/OUT: Your secret key */
+
+/* sk will be trimmed on return */
+void curve25519_dh_CreateSharedKey(
+    unsigned char *shared,      /* [32-bytes] OUT: Created shared key */
+    const unsigned char *pk,    /* [32-bytes] IN: Other side's public key */
+    unsigned char *sk);         /* [32-bytes] IN/OUT: Your secret key */
+
+#ifdef __cplusplus
+}
+#endif
+#endif  /* __curve25519_dh_key_exchange_h__ */

package/android/src/main/cpp/third_party/curve25519/include/ed25519_signature.h

@@ -0,0 +1,98 @@
+/* The MIT License (MIT)
+ * 
+ * Copyright (c) 2015 mehdi sotoodeh
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining 
+ * a copy of this software and associated documentation files (the 
+ * "Software"), to deal in the Software without restriction, including 
+ * without limitation the rights to use, copy, modify, merge, publish, 
+ * distribute, sublicense, and/or sell copies of the Software, and to 
+ * permit persons to whom the Software is furnished to do so, subject to 
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included 
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ed25519_signature_h__
+#define __ed25519_signature_h__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* -- ed25519-sign ------------------------------------------------------------- */
+
+#define ed25519_public_key_size     32
+#define ed25519_secret_key_size     32
+#define ed25519_private_key_size    64
+#define ed25519_signature_size      64
+
+/* Generate public key associated with the secret key */
+void ed25519_CreateKeyPair(
+    unsigned char *pubKey,              /* OUT: public key */
+    unsigned char *privKey,             /* OUT: private key */
+    const void *blinding,               /* IN: [optional] null or blinding context */
+    const unsigned char *sk);           /* IN: secret key (32 bytes) */
+
+/* Generate message signature */
+void ed25519_SignMessage(
+    unsigned char *signature,           /* OUT:[64 bytes] signature (R,S) */
+    const unsigned char *privKey,       /* IN: [64 bytes] private key (sk,pk) */
+    const void *blinding,               /* IN: [optional] null or blinding context */
+    const unsigned char *msg,           /* IN: [msg_size bytes] message to sign */
+    size_t msg_size);                   /* IN: size of message */
+
+void *ed25519_Blinding_Init(
+    void *context,                      /* IO: null or ptr blinding context */
+    const unsigned char *seed,          /* IN: [size bytes] random blinding seed */
+    size_t size);                       /* IN: size of blinding seed */
+
+void ed25519_Blinding_Finish(
+    void *context);                     /* IN: blinding context */
+
+/* -- ed25519-verify ----------------------------------------------------------- */
+
+/*  Single-phased signature validation.
+    Returns 1 for SUCCESS and 0 for FAILURE
+*/
+int ed25519_VerifySignature(
+    const unsigned char *signature,     /* IN: [64 bytes] signature (R,S) */
+    const unsigned char *publicKey,     /* IN: [32 bytes] public key */
+    const unsigned char *msg,           /* IN: [msg_size bytes] message to sign */
+    size_t msg_size);                   /* IN: size of message */
+
+/*  First part of two-phase signature validation.
+    This function creates context specifc to a given public key.
+    Needs to be called once per public key
+*/
+void * ed25519_Verify_Init(
+    void *context,                      /* IO: null or verify context to use */
+    const unsigned char *publicKey);    /* IN: [32 bytes] public key */
+
+/*  Second part of two-phase signature validation.
+    Input context is output of ed25519_Verify_Init() for associated public key.
+    Call it once for each message/signature pairs
+    Returns 1 for SUCCESS and 0 for FAILURE
+*/
+int ed25519_Verify_Check(
+    const void          *context,       /* IN: created by ed25519_Verify_Init */
+    const unsigned char *signature,     /* IN: signature (R,S) */
+    const unsigned char *msg,           /* IN: message to sign */
+    size_t msg_size);                   /* IN: size of message */
+
+/* Free up context memory */
+void ed25519_Verify_Finish(void *ctx);
+
+#ifdef __cplusplus
+}
+#endif
+#endif  /* __ed25519_signature_h__ */

package/android/src/main/cpp/third_party/curve25519/include/external_calls.h

@@ -0,0 +1,36 @@
+/* The MIT License (MIT)
+ * 
+ * Copyright (c) 2015 mehdi sotoodeh
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining 
+ * a copy of this software and associated documentation files (the 
+ * "Software"), to deal in the Software without restriction, including 
+ * without limitation the rights to use, copy, modify, merge, publish, 
+ * distribute, sublicense, and/or sell copies of the Software, and to 
+ * permit persons to whom the Software is furnished to do so, subject to 
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included 
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __external_calls_h__
+#define __external_calls_h__
+
+#include <memory.h>
+#include <stdlib.h>
+
+#define	mem_alloc(size)				malloc(size)
+#define	mem_free(addr)				free(addr)
+#define mem_clear(addr,size)		memset(addr,0,size)
+#define mem_fill(addr,data,size)	memset(addr,data,size)
+
+#endif  /* __external_calls_h__ */