mirror of
https://github.com/WinampDesktop/winamp.git
synced 2024-12-18 17:15:51 +01:00
630 lines
16 KiB
C++
630 lines
16 KiB
C++
#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();
|
|
} |