Merge pull request #5 from WinampDesktop/community

Merge to main

1 files changed, 630 insertions, 0 deletions

diff --git a/Src/replicant/jnetlib/jnetlib.cpp b/Src/replicant/jnetlib/jnetlib.cpp
new file mode 100644
index 00000000..00fcfbdb
--- /dev/null
+++ b/Src/replicant/jnetlib/jnetlib.cpp
@@ -0,0 +1,630 @@
+#include "jnetlib.h"
+#include "httpget.h"
+#include "sslconnection.h"
+#include "asyncdns.h"
+#include "util.h"
+#include "httpserv.h"
+#include "httpuserv.h"
+#include "listen.h"
+#include "multicastlisten.h"
+
+#include "foundation/error.h"
+
+#include <new>
+
+int jnl_init()
+{
+	return JNL::open_socketlib();
+}
+
+void jnl_quit()
+{
+	JNL::close_socketlib();
+}
+
+/* --- Connection --- */
+jnl_connection_t jnl_connection_create(jnl_dns_t dns, size_t sendbufsize, size_t recvbufsize)
+{
+	JNL_Connection *connection = new (std::nothrow) JNL_Connection((JNL_AsyncDNS *)dns, sendbufsize, recvbufsize);
+	return (jnl_connection_t)connection;
+}
+
+jnl_connection_t jnl_sslconnection_create(jnl_dns_t dns, size_t sendbufsize, size_t recvbufsize)
+{
+	JNL_SSL_Connection *connection = new (std::nothrow) JNL_SSL_Connection(NULL, (JNL_AsyncDNS *)dns, sendbufsize, recvbufsize);
+	return (jnl_connection_t)connection;
+}
+
+void jnl_connection_run(jnl_connection_t _connection, size_t max_send_bytes, size_t max_receive_bytes, size_t *bytes_sent, size_t *bytes_received)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	connection->run(max_send_bytes, max_receive_bytes, bytes_sent, bytes_received); 
+}
+
+int jnl_connection_get_state(jnl_connection_t _connection)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	return connection->get_state();
+}
+
+size_t jnl_connection_send_bytes_available(jnl_connection_t _connection)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	return connection->send_bytes_available();
+}
+
+size_t jnl_connection_receive_bytes_available(jnl_connection_t _connection)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	return connection->recv_bytes_available();
+}
+
+int jnl_connection_send(jnl_connection_t _connection, const void *bytes, size_t size)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	return connection->send(bytes, size);
+}
+
+JNL_API int jnl_connection_send_string(jnl_connection_t _connection, const char *str)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	return connection->send_string(str);
+}
+
+size_t jnl_connection_send_bytes_in_queue(jnl_connection_t _connection)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	return connection->send_bytes_in_queue();
+}
+
+size_t jnl_connection_receive(jnl_connection_t _connection, void *bytes, size_t size)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	return connection->recv_bytes(bytes, size);
+}
+
+size_t jnl_connection_peek(jnl_connection_t _connection, void *bytes, size_t size)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	return connection->peek_bytes(bytes, size);
+}
+
+void jnl_connection_release(jnl_connection_t _connection)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	if (connection)
+		connection->Release();
+}
+
+int jnl_connection_receive_line(jnl_connection_t _connection, void *bytes, size_t size)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	return connection->recv_line((char *)bytes, size);
+}
+
+size_t jnl_connection_receive_lines_available(jnl_connection_t _connection)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	return connection->recv_lines_available();
+}
+
+void jnl_connection_close(jnl_connection_t _connection, int fast)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	connection->close(fast);
+}
+
+void jnl_connection_connect(jnl_connection_t _connection, const char *hostname, int port)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	connection->connect(hostname, port);
+}
+
+const char *jnl_connection_get_error(jnl_connection_t _connection)
+{
+	JNL_Connection *connection = (JNL_Connection *)_connection;
+	return connection->get_errstr();
+}
+
+/* ---- UDP ----- */
+int jnl_udp_create_multicast_listener(jnl_udp_t *connection, const char *mcast_ip, unsigned short port)
+{
+	JNL_UDPConnection *udp =  0;
+	JNL::open_socketlib(); // TODO: cut
+
+	int ret = CreateMulticastListener(&udp, mcast_ip, port);
+	if (ret != NErr_Success)
+	{
+		JNL::close_socketlib(); // TODO: cut
+
+		return ret;
+	}
+	*connection = (jnl_udp_t)udp;
+	return NErr_Success;
+}
+
+void jnl_udp_release(jnl_udp_t _connection)
+{
+	JNL_UDPConnection *connection = (JNL_UDPConnection *)_connection;
+	delete connection; // TODO: reference count
+	JNL::close_socketlib(); // TODO: cut
+}
+
+void jnl_udp_run(jnl_udp_t _connection, size_t max_send_bytes, size_t max_recv_bytes, size_t *bytes_sent, size_t *bytes_rcvd)
+{
+	JNL_UDPConnection *connection = (JNL_UDPConnection *)_connection;
+	if (connection)
+	{
+		connection->run(max_send_bytes, max_recv_bytes, bytes_sent, bytes_rcvd);
+	}
+}
+
+size_t jnl_udp_recv_bytes(jnl_udp_t _connection, void *buf, size_t len)
+{
+	JNL_UDPConnection *connection = (JNL_UDPConnection *)_connection;
+	if (connection)
+	{
+		return connection->recv_bytes(buf, len);
+	}
+	else
+		return 0;
+}
+
+int jnl_udp_send(jnl_udp_t _connection, const void *bytes, size_t size)
+{
+	JNL_UDPConnection *connection = (JNL_UDPConnection *)_connection;
+	return connection->send(bytes, size);
+}
+
+void jnl_udp_set_peer(jnl_udp_t _connection, const char *hostname, unsigned short port)
+{
+	JNL_UDPConnection *connection = (JNL_UDPConnection *)_connection;
+	connection->setpeer(hostname, port);
+}
+
+void jnl_udp_set_peer_address(jnl_udp_t _connection, sockaddr *addr, socklen_t length)
+{
+	JNL_UDPConnection *connection = (JNL_UDPConnection *)_connection;
+	connection->setpeer(addr, length);
+}
+
+int jnl_udp_get_address(jnl_udp_t _connection, sockaddr **addr, socklen_t *length)
+{
+	JNL_UDPConnection *connection = (JNL_UDPConnection *)_connection;
+	connection->get_last_recv_msg_addr(addr, length);
+	return NErr_Success;
+}
+
+/* ---- HTTP ---- */
+jnl_http_t jnl_http_create(int recvbufsize, int sendbufsize)
+{
+	JNL_HTTPGet *http = new (std::nothrow) JNL_HTTPGet(recvbufsize, sendbufsize);
+	return (jnl_http_t)http;
+}
+
+int jnl_http_set_recv_buffer_size(jnl_http_t _http, size_t new_size)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	return http->set_recv_buffer_size(new_size);
+}
+
+int jnl_http_run(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	return http->run();
+}
+
+size_t jnl_http_get_bytes(jnl_http_t _http, void *buf, size_t len)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	return http->get_bytes(static_cast<char *>(buf), len);
+}
+
+size_t jnl_http_peek_bytes(jnl_http_t _http, void *buf, size_t len)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	return http->peek_bytes(static_cast<char *>(buf), len);
+}
+
+size_t jnl_http_bytes_available(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	return http->bytes_available();
+}
+
+uint64_t jnl_http_content_length(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	return http->content_length();
+}
+
+int jnl_http_get_status(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	return http->get_status();
+}
+
+int jnl_http_getreplycode(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	return http->getreplycode();
+}
+
+const char *jnl_http_getreply(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	return http->getreply();
+}
+
+const char *jnl_http_getheader(jnl_http_t _http, const char *header)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	return http->getheader(header);
+}
+
+const char *jnl_http_get_all_headers(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	return http->getallheaders();
+}
+
+void jnl_http_addheader(jnl_http_t _http, const char *header)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	http->addheader(header);
+}
+
+void jnl_http_addheadervalue(jnl_http_t _http, const char *header, const char *value)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	http->addheadervalue(header, value);
+}
+
+void jnl_http_connect(jnl_http_t _http, const char *url, int http_version, const char *method)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	http->connect(url, http_version, method);
+}
+
+void jnl_http_release(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+
+	if (http)
+		http->Release();
+}
+
+jnl_http_t jnl_http_retain(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	if (http)
+		http->Retain();
+	return _http;
+}
+
+const char *jnl_http_get_url(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	return http->get_url();
+}
+
+void jnl_http_reset_headers(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	http->reset_headers();
+}
+
+void jnl_http_set_persistent(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	http->set_persistent();
+}
+
+void jnl_http_allow_compression(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	http->AllowCompression();
+}
+
+void jnl_http_allow_accept_all_reply_codes(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	http->set_accept_all_reply_codes();
+}
+
+jnl_connection_t jnl_http_get_connection(jnl_http_t _http)
+{
+	JNL_HTTPGet *http = (JNL_HTTPGet *)_http;
+	return (jnl_connection_t)http->get_con();
+}
+
+void jnl_http_set_proxy(const char *proxy)
+{
+	JNL_HTTPGet::set_proxy(proxy);
+}
+
+/* ------- HTTP Request Parser ------- */
+int jnl_http_request_create(jnl_http_request_t *_http, jnl_connection_t _connection)
+{
+	JNL_HTTPServ *http = new (std::nothrow) JNL_HTTPServ((JNL_Connection *)_connection);;
+	if (!http)
+		return NErr_OutOfMemory;
+
+	*_http = (jnl_http_request_t) http;
+	return NErr_Success;
+}
+
+void jnl_http_request_release(jnl_http_request_t _http)
+{
+	JNL_HTTPServ *http = (JNL_HTTPServ *)_http;
+	if (http)
+		http->Release();
+}
+
+int jnl_http_request_run(jnl_http_request_t _http)
+{
+	JNL_HTTPServ *http = (JNL_HTTPServ *)_http;
+	return http->run();
+}
+
+int jnl_htt_request_get_keep_alive(jnl_http_request_t _http)
+{
+	JNL_HTTPServ *http = (JNL_HTTPServ *)_http;
+	return http->get_keep_alive();
+}
+
+const char *jnl_http_request_get_header(jnl_http_request_t _http, const char *header)
+{
+	JNL_HTTPServ *http = (JNL_HTTPServ *)_http;
+	return http->getheader(header);
+}
+
+void jnl_http_request_reset(jnl_http_request_t _http)
+{
+	JNL_HTTPServ *http = (JNL_HTTPServ *)_http;
+	http->reset();
+}
+
+void jnl_http_request_addheader(jnl_http_request_t _http, const char *header)
+{
+	JNL_HTTPServ *http = (JNL_HTTPServ *)_http;
+	http->add_reply_header(header);
+}
+
+void jnl_http_request_set_reply_string(jnl_http_request_t _http, const char *reply)
+{
+	JNL_HTTPServ *http = (JNL_HTTPServ *)_http;
+	http->set_reply_string(reply);
+}
+
+void jnl_http_request_send_reply(jnl_http_request_t _http)
+{
+	JNL_HTTPServ *http = (JNL_HTTPServ *)_http;
+	http->send_reply();
+}
+
+const char *jnl_http_request_get_uri(jnl_http_request_t _http)
+{
+	JNL_HTTPServ *http = (JNL_HTTPServ *)_http;
+	return http->get_request_file();
+}
+
+const char *jnl_http_request_get_parameter(jnl_http_request_t _http, const char *parameter)
+{
+	JNL_HTTPServ *http = (JNL_HTTPServ *)_http;
+	return http->get_request_parm(parameter);
+}
+
+jnl_connection_t jnl_http_request_get_connection(jnl_http_request_t _http)
+{
+		JNL_HTTPServ *http = (JNL_HTTPServ *)_http;
+		JNL_Connection *connection = http->get_con();
+		if (connection)
+		{
+			connection->Retain();
+			return (jnl_connection_t)connection;
+		}
+		else
+			return 0;
+}
+
+const char *jnl_http_request_get_method(jnl_http_request_t _http)
+{
+	JNL_HTTPServ *http = (JNL_HTTPServ *)_http;
+	return http->get_method();
+}
+
+/* ------- HTTPU Request Parser ------- */
+int jnl_httpu_request_create(jnl_httpu_request_t *_httpu)
+{
+	JNL_HTTPUServ *httpu = new (std::nothrow) JNL_HTTPUServ;
+	if (!httpu)
+		return NErr_OutOfMemory;
+
+	*_httpu = (jnl_httpu_request_t) httpu;
+	return NErr_Success;
+}
+
+void jnl_httpu_request_release(jnl_httpu_request_t _httpu)
+{
+	JNL_HTTPUServ *httpu = (JNL_HTTPUServ *)_httpu;
+	delete httpu; // TODO: reference count
+}
+
+int jnl_httpu_request_process(jnl_httpu_request_t _httpu, jnl_udp_t _udp)
+{
+	JNL_HTTPUServ *httpu = (JNL_HTTPUServ *)_httpu;
+	return httpu->process((JNL_UDPConnection *)_udp);
+}
+
+const char *jnl_httpu_request_get_method(jnl_httpu_request_t _httpu)
+{
+	JNL_HTTPUServ *httpu = (JNL_HTTPUServ *)_httpu;
+	return httpu->get_method();
+}
+
+
+const char *jnl_httpu_request_get_uri(jnl_httpu_request_t _httpu)
+{
+	JNL_HTTPUServ *httpu = (JNL_HTTPUServ *)_httpu;
+	return httpu->get_request_uri();
+}
+
+const char *jnl_httpu_request_get_header(jnl_httpu_request_t _httpu, const char *header)
+{
+	JNL_HTTPUServ *httpu = (JNL_HTTPUServ *)_httpu;
+	return httpu->getheader(header);
+}
+
+/* ----- DNS ----- */
+int jnl_dns_create(jnl_dns_t *out_dns)
+{
+	JNL_AsyncDNS *dns = new (std::nothrow)JNL_AsyncDNS;
+	if (!dns)
+		return NErr_OutOfMemory;
+
+	*out_dns = (jnl_dns_t)dns;
+	return NErr_Success;
+}
+
+void jnl_dns_release(jnl_dns_t _dns)
+{
+	JNL_AsyncDNS *dns = (JNL_AsyncDNS *)_dns;
+	delete dns; // TODO: reference counting
+}
+
+int jnl_dns_resolve(jnl_dns_t _dns, const char *hostname, unsigned short port, addrinfo **addr, int sockettype)
+{
+	JNL_AsyncDNS *dns = (JNL_AsyncDNS *)_dns;
+	int ret = dns->resolve(hostname, port, addr, sockettype);
+	if (ret == 0)
+		return NErr_Success;
+	else if (ret == -1)
+		return NErr_TryAgain;
+	else
+		return NErr_Unknown;
+}
+
+int jnl_dns_resolve_now(const char *hostname, unsigned short port, addrinfo **addr, int sockettype)
+{
+	int ret = JNL_AsyncDNS::resolvenow(hostname, port, addr, sockettype);
+	if (ret == 0)
+		return NErr_Success;
+	else
+		return NErr_Unknown;
+}
+
+
+void jnl_dns_freeaddrinfo(addrinfo *addr)
+{
+	freeaddrinfo(addr);
+}
+
+void jnl_dns_gethostname(char *name, size_t cch)
+{
+	gethostname(name, (int)cch);
+}
+
+#ifdef _WIN32
+PCSTR WSAAPI inet_ntop_xp(INT af, PVOID src, PSTR dst, size_t cnt)
+{
+	struct sockaddr_in srcaddr;
+
+	memset(&srcaddr, 0, sizeof(struct sockaddr_in));
+	memcpy(&(srcaddr.sin_addr), src, sizeof(srcaddr.sin_addr));
+
+	srcaddr.sin_family = af;
+	if (WSAAddressToStringA((struct sockaddr*) &srcaddr, sizeof(struct sockaddr_in), 0, dst, (LPDWORD) &cnt) != 0) {
+		return NULL;
+	}
+	return dst;
+}
+
+PCSTR WSAAPI inet_ntop_win32(INT Family, PVOID pAddr, PSTR pStringBuf, size_t StringBufSize) {
+    typedef PCSTR (WSAAPI * win32_inet_ntop)(INT, PVOID, PSTR, size_t);
+    static win32_inet_ntop pwin32_inet_ntop = NULL;
+
+	if (!pwin32_inet_ntop){
+		HMODULE hlib = LoadLibrary(L"WS2_32.DLL");
+		pwin32_inet_ntop = (win32_inet_ntop)GetProcAddress(hlib, "inet_ntop");
+		if (!pwin32_inet_ntop) {
+			pwin32_inet_ntop = inet_ntop_xp;
+		}
+	}
+
+	return (*pwin32_inet_ntop)(Family, pAddr, pStringBuf, StringBufSize);
+}
+
+#endif
+
+void jnl_dns_ntop(int af, const void *src, char *dst, socklen_t size)
+{
+#ifdef _WIN32
+	// TODO need to revist this at a later date
+	// [22:01:08] audiodsp: i will make a tweak for IPv6 compatability at some point
+	// [22:01:49] audiodsp: just change references from sockaddr_in to sockaddr_storage
+	// [22:02:24] audiodsp: keep it as is
+	// [22:02:32] audiodsp: we're only using it in IPv4 mode at the moment
+	// [22:02:40] audiodsp: i will fix when we need IPv6 server support
+	// [22:03:58] audiodsp: the memcpy is what makes it non-trivial
+	// [22:04:05] audiodsp: i have to switch on family and do different memcpy's accordingly
+	// [22:04:16] audiodsp: or change the method to require a length
+	// [22:04:19] audiodsp: which makes more sense
+	// [22:04:29] audiodsp: and just not pass it to the linux function
+	// [22:05:08] audiodsp: anyway not important. 
+	inet_ntop_win32(af, (PVOID)src, dst, size);
+#else
+	inet_ntop(af, src, dst, size);
+#endif
+}
+/* Listen */
+
+int jnl_listen_create(jnl_listen_t *_listen, unsigned short port)
+{
+	JNL_Listen *l = new (std::nothrow) JNL_Listen();
+	if (!l)
+		return NErr_OutOfMemory;
+	int ret = l->Initialize(port);
+	if (ret != NErr_Success)
+	{
+		delete l;
+		return ret;
+	}
+	*_listen = (jnl_listen_t)l;
+	return NErr_Success;
+}
+
+int jnl_listen_create_from_address(jnl_listen_t *_listen, struct addrinfo *addr, size_t index)
+{
+	JNL_Listen *l = new (std::nothrow) JNL_Listen();
+	if (!l)
+		return NErr_OutOfMemory;
+	int ret = l->Initialize(addr, index);
+	if (ret != NErr_Success)
+	{
+		delete l;
+		return ret;
+	}
+	*_listen = (jnl_listen_t)l;
+	return NErr_Success;
+}
+
+jnl_connection_t jnl_listen_get_connection(jnl_listen_t _listen)
+{
+	JNL_Listen *listen = (JNL_Listen *)_listen;
+	JNL_Connection *connection = listen->get_connect();
+	return (jnl_connection_t)connection;
+}
+
+unsigned short jnl_listen_get_port(jnl_listen_t _listen)
+{
+	JNL_Listen *listen = (JNL_Listen *)_listen;
+	return listen->get_port();
+}
+
+void jnl_listen_release(jnl_listen_t _listen)
+{
+	JNL_Listen *listen = (JNL_Listen *)_listen;
+	if (listen)
+		listen->Release();
+}
\ No newline at end of file