int
socket_server_connect(struct socket_server *ss, uintptr_t opaque, const char * addr, int port) {
struct request_package request;
int len = open_request(ss, &request, opaque, addr, port);
send_request(ss, &request, 'O', sizeof(request.u.open) + len);
return request.u.open.id;
}
int socket_server::server_connect(uintptr_t opaque, const char * addr, int port)
{
struct request_package request;
int len = open_request(&request, opaque, addr, port);
if (len < 0) {
return -1;
}
send_request(&request, 'O', sizeof(request.u.open) + len);
return request.u.open.id;
}
int
socket_server_block_connect(struct socket_server *ss, uintptr_t opaque, const char * addr, int port) {
struct request_package request;
struct socket_message result;
open_request(ss, &request, opaque, addr, port);
int ret = open_socket(ss, &request.u.open, &result, true);
if (ret == SOCKET_OPEN) {
return result.id;
} else {
return -1;
}
}
void
handle(reg fd)
{
client.socket = accept_socket(fd,(server.http_sock == fd ? NULL : server.tls));
close(fd); // close the parent fd, as we'll never accept again
nodelay(client.socket->fd);
#ifdef LINUX
client.kq = epoll_create1(0);
#else
client.kq = kqueue();
#endif
client.request = open_request(client.socket);
add_read_socket(client.socket->fd);
timeout(IDLE_TIMEOUT,0);
timer();
while (!client.socket->closed && !client.alarm) run();
exit(JAWAS_EXIT_DONE);
}
static int open_handle (struct neon_handle * handle, uint64_t startbyte)
{
int ret;
char * proxy_host = NULL;
int proxy_port = 0;
bool_t use_proxy = aud_get_bool (NULL, "use_proxy");
bool_t use_proxy_auth = aud_get_bool (NULL, "use_proxy_auth");
if (use_proxy)
{
proxy_host = aud_get_str (NULL, "proxy_host");
proxy_port = aud_get_int (NULL, "proxy_port");
}
handle->redircount = 0;
_DEBUG ("<%p> Parsing URL", handle);
if (ne_uri_parse (handle->url, handle->purl) != 0)
{
_ERROR ("<%p> Could not parse URL '%s'", (void *) handle, handle->url);
return -1;
}
while (handle->redircount < 10)
{
if (! handle->purl->port)
handle->purl->port = ne_uri_defaultport (handle->purl->scheme);
_DEBUG ("<%p> Creating session to %s://%s:%d", handle,
handle->purl->scheme, handle->purl->host, handle->purl->port);
handle->session = ne_session_create (handle->purl->scheme,
handle->purl->host, handle->purl->port);
ne_redirect_register (handle->session);
ne_add_server_auth (handle->session, NE_AUTH_BASIC, server_auth_callback, (void *) handle);
ne_set_session_flag (handle->session, NE_SESSFLAG_ICYPROTO, 1);
ne_set_session_flag (handle->session, NE_SESSFLAG_PERSIST, 0);
#ifdef HAVE_NE_SET_CONNECT_TIMEOUT
ne_set_connect_timeout (handle->session, 10);
#endif
ne_set_read_timeout (handle->session, 10);
ne_set_useragent (handle->session, "Audacious/" PACKAGE_VERSION);
if (use_proxy)
{
_DEBUG ("<%p> Using proxy: %s:%d", handle, proxy_host, proxy_port);
ne_session_proxy (handle->session, proxy_host, proxy_port);
if (use_proxy_auth)
{
_DEBUG ("<%p> Using proxy authentication", handle);
ne_add_proxy_auth (handle->session, NE_AUTH_BASIC,
neon_proxy_auth_cb, (void *) handle);
}
}
if (! strcmp ("https", handle->purl->scheme))
{
ne_ssl_trust_default_ca (handle->session);
ne_ssl_set_verify (handle->session,
neon_vfs_verify_environment_ssl_certs, handle->session);
}
_DEBUG ("<%p> Creating request", handle);
ret = open_request (handle, startbyte);
if (! ret)
{
str_unref (proxy_host);
return 0;
}
if (ret == -1)
{
ne_session_destroy (handle->session);
handle->session = NULL;
str_unref (proxy_host);
return -1;
}
_DEBUG ("<%p> Following redirect...", handle);
ne_session_destroy (handle->session);
handle->session = NULL;
}
/* If we get here, our redirect count exceeded */
_ERROR ("<%p> Redirect count exceeded for URL %s", (void *) handle, handle->url);
str_unref (proxy_host);
return 1;
}
void
on_open_mi_activate (GtkMenuItem * menuitem, gpointer user_data)
{
open_request();
}
void
on_open_toolbutton_clicked (GtkToolButton * toolbutton, gpointer user_data)
{
open_request();
}
DWORD CALLBACK Thread()
{
IMDPROXY_CONNECT_REQ ConnectReq;
KdPrint(("ImDskSvc: Thread created.%n"));
if (Overlapped.BufRecv(hPipe, &ConnectReq.request_code,
sizeof ConnectReq.request_code) !=
sizeof ConnectReq.request_code)
{
KdPrintLastError(("Overlapped.BufRecv() failed"));
delete this;
return 0;
}
if (ConnectReq.request_code != IMDPROXY_REQ_CONNECT)
{
delete this;
return 0;
}
if (Overlapped.BufRecv(hPipe,
((PUCHAR)&ConnectReq) +
sizeof(ConnectReq.request_code),
sizeof(ConnectReq) -
sizeof(ConnectReq.request_code)) !=
sizeof(ConnectReq) -
sizeof(ConnectReq.request_code))
{
KdPrintLastError(("Overlapped.BufRecv() failed"));
delete this;
return 0;
}
if ((ConnectReq.length == 0) | (ConnectReq.length > 520))
{
KdPrint(("ImDskSvc: Bad connection string length received (%1!u!).%n",
ConnectReq.length));
delete this;
return 0;
}
WCRTMem<WCHAR> ConnectionString((size_t)ConnectReq.length + 2);
if (!ConnectionString)
{
KdPrintLastError(("malloc() failed"));
delete this;
return 0;
}
if (Overlapped.BufRecv(hPipe, ConnectionString,
(DWORD)ConnectReq.length) !=
ConnectReq.length)
{
KdPrintLastError(("Overlapped.BufRecv() failed"));
delete this;
return 0;
}
IMDPROXY_CONNECT_RESP connect_resp = { 0 };
ConnectionString[ConnectReq.length / sizeof *ConnectionString] = 0;
// Split server connection string and string that should be sent to server
// for server side connection to specific image file.
LPWSTR path_part = wcsstr(ConnectionString, L"://");
if (path_part != NULL)
{
path_part[0] = 0;
path_part++;
}
HANDLE hTarget;
switch (IMDISK_PROXY_TYPE(ConnectReq.flags))
{
case IMDISK_PROXY_TYPE_COMM:
{
LPWSTR FileName = wcstok(ConnectionString, L": ");
KdPrint(("ImDskSvc: Connecting to '%1!ws!'.%n", FileName));
hTarget = CreateFile(FileName,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
0,
NULL);
if (hTarget == INVALID_HANDLE_VALUE)
{
connect_resp.error_code = GetLastError();
KdPrintLastError(("CreateFile() failed"));
Overlapped.BufSend(hPipe, &connect_resp, sizeof connect_resp);
delete this;
return 0;
}
LPWSTR DCBAndTimeouts = wcstok(NULL, L"");
if (DCBAndTimeouts != NULL)
{
DCB dcb = { 0 };
COMMTIMEOUTS timeouts = { 0 };
if (DCBAndTimeouts[0] == L' ')
++DCBAndTimeouts;
KdPrint(("ImDskSvc: Configuring '%1!ws!'.%n", DCBAndTimeouts));
GetCommState(hTarget, &dcb);
GetCommTimeouts(hTarget, &timeouts);
BuildCommDCBAndTimeouts(DCBAndTimeouts, &dcb, &timeouts);
SetCommState(hTarget, &dcb);
SetCommTimeouts(hTarget, &timeouts);
}
KdPrint(("ImDskSvc: Connected to '%1!ws!' and configured.%n",
FileName));
break;
}
case IMDISK_PROXY_TYPE_TCP:
{
LPWSTR ServerName = wcstok(ConnectionString, L":");
LPWSTR PortName = wcstok(NULL, L"");
if (PortName == NULL)
PortName = L"9000";
KdPrint(("ImDskSvc: Connecting to '%1!ws!:%2!ws!'.%n",
ServerName, PortName));
hTarget = (HANDLE)ConnectTCP(ServerName, PortName);
if (hTarget == INVALID_HANDLE_VALUE)
{
connect_resp.error_code = GetLastError();
KdPrintLastError(("ConnectTCP() failed"));
Overlapped.BufSend(hPipe, &connect_resp, sizeof connect_resp);
delete this;
return 0;
}
bool b = true;
setsockopt((SOCKET)hTarget, IPPROTO_TCP, TCP_NODELAY, (LPCSTR)&b,
sizeof b);
KdPrint(("ImDskSvc: Connected to '%1!ws!:%2!ws!' and configured.%n",
ServerName, PortName));
break;
}
default:
KdPrint(("ImDskSvc: Unsupported connection type (%1!#x!).%n",
IMDISK_PROXY_TYPE(ConnectReq.flags)));
connect_resp.error_code = (ULONGLONG)-1;
Overlapped.BufSend(hPipe, &connect_resp, sizeof connect_resp);
delete this;
return 0;
}
// Connect to requested server side image path
if (path_part != NULL)
{
size_t path_size = wcslen(path_part) << 1;
size_t req_size = sizeof(IMDPROXY_CONNECT_REQ) +
path_size;
WCRTMem<IMDPROXY_CONNECT_REQ> open_request(req_size);
if (!open_request)
{
KdPrintLastError(("malloc() failed"));
connect_resp.error_code = (ULONGLONG)-1;
Overlapped.BufSend(hPipe, &connect_resp, sizeof connect_resp);
delete this;
return 0;
}
ZeroMemory(open_request, req_size);
open_request->request_code = IMDPROXY_REQ_CONNECT;
open_request->length = path_size;
memcpy(open_request + 1, path_part, path_size);
if (!Overlapped.BufSend(hTarget, open_request, (DWORD)req_size))
{
KdPrintLastError(("Failed to send connect request to server"));
connect_resp.error_code = (ULONGLONG)-1;
Overlapped.BufSend(hPipe, &connect_resp, sizeof connect_resp);
delete this;
return 0;
}
open_request.Free();
if (Overlapped.BufRecv(hTarget, &connect_resp, sizeof connect_resp) !=
sizeof connect_resp)
{
connect_resp.object_ptr = NULL;
if (connect_resp.error_code == 0)
{
connect_resp.error_code = (ULONGLONG)-1;
}
Overlapped.BufSend(hPipe, &connect_resp, sizeof connect_resp);
delete this;
return 0;
}
}
ConnectionString.Free();
HANDLE hDriver = CreateFile(IMDISK_CTL_DOSDEV_NAME,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
0,
NULL);
if (hDriver == INVALID_HANDLE_VALUE)
{
connect_resp.error_code = GetLastError();
KdPrintLastError(("Opening ImDiskCtl device failed"));
CloseHandle(hTarget);
Overlapped.BufSend(hPipe, &connect_resp, sizeof connect_resp);
delete this;
return 0;
}
DWORD dw;
if (!DeviceIoControl(hDriver,
IOCTL_IMDISK_REFERENCE_HANDLE,
&hTarget,
#pragma warning(suppress: 28132)
sizeof hTarget,
&connect_resp.object_ptr,
sizeof connect_resp.object_ptr,
&dw,
NULL))
{
connect_resp.error_code = GetLastError();
KdPrintLastError(("IOCTL_IMDISK_REFERENCE_HANDLE failed"));
CloseHandle(hDriver);
CloseHandle(hTarget);
Overlapped.BufSend(hPipe, &connect_resp, sizeof connect_resp);
delete this;
return 0;
}
CloseHandle(hDriver);
Overlapped.BufSend(hPipe, &connect_resp, sizeof connect_resp);
// This will fail when driver closes the pipe, but that just indicates that
// we should shut down this connection.
Overlapped.BufRecv(hPipe, &dw, sizeof dw);
KdPrint(("ImDskSvc: Cleaning up.%n"));
CloseHandle(hTarget);
delete this;
return 1;
}