blob: 966dada4de8dfe39e409fd7518d5d190fc337c57 [file] [log] [blame] [edit]
// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#include "platform/globals.h"
#if defined(DART_HOST_OS_WINDOWS)
#include "bin/socket_base.h"
#include "bin/builtin.h"
#include "bin/eventhandler.h"
#include "bin/file.h"
#include "bin/lockers.h"
#include "bin/socket_base_win.h"
#include "bin/thread.h"
#include "bin/utils.h"
#include "bin/utils_win.h"
#include "platform/syslog.h"
namespace dart {
namespace bin {
SocketAddress::SocketAddress(struct sockaddr* sockaddr,
bool unnamed_unix_socket) {
// Unix domain sockets not supported on Win. Remove this assert if enabled.
ASSERT(!unnamed_unix_socket);
ASSERT(INET6_ADDRSTRLEN >= INET_ADDRSTRLEN);
RawAddr* raw = reinterpret_cast<RawAddr*>(sockaddr);
// Clear the port before calling WSAAddressToString as WSAAddressToString
// includes the port in the formatted string.
int err =
SocketBase::FormatNumericAddress(*raw, as_string_, INET6_ADDRSTRLEN);
if (err != 0) {
as_string_[0] = 0;
}
memmove(reinterpret_cast<void*>(&addr_), sockaddr,
SocketAddress::GetAddrLength(*raw));
}
static Mutex* init_mutex = new Mutex();
static bool socket_initialized = false;
bool SocketBase::Initialize() {
MutexLocker lock(init_mutex);
if (socket_initialized) {
return true;
}
int err;
WSADATA winsock_data;
WORD version_requested = MAKEWORD(2, 2);
err = WSAStartup(version_requested, &winsock_data);
if (err == 0) {
socket_initialized = true;
} else {
Syslog::PrintErr("Unable to initialize Winsock: %d\n", WSAGetLastError());
}
return (err == 0);
}
bool SocketBase::FormatNumericAddress(const RawAddr& addr,
char* address,
int len) {
socklen_t salen = SocketAddress::GetAddrLength(addr);
DWORD l = len;
RawAddr& raw = const_cast<RawAddr&>(addr);
wchar_t* waddress = reinterpret_cast<wchar_t*>(
Dart_ScopeAllocate((salen + 1) * sizeof(wchar_t)));
intptr_t result =
WSAAddressToStringW(&raw.addr, salen, nullptr, waddress, &l);
if (result != 0) {
return true;
}
WideToUtf8Scope wide_name(waddress);
strncpy(address, wide_name.utf8(), l);
return false;
}
intptr_t SocketBase::Available(intptr_t fd) {
ClientSocket* client_socket = reinterpret_cast<ClientSocket*>(fd);
return client_socket->Available();
}
intptr_t SocketBase::Read(intptr_t fd,
void* buffer,
intptr_t num_bytes,
SocketOpKind sync) {
Handle* handle = reinterpret_cast<Handle*>(fd);
return handle->Read(buffer, num_bytes);
}
intptr_t SocketBase::RecvFrom(intptr_t fd,
void* buffer,
intptr_t num_bytes,
RawAddr* addr,
SocketOpKind sync) {
Handle* handle = reinterpret_cast<Handle*>(fd);
socklen_t addr_len = sizeof(addr->ss);
return handle->RecvFrom(buffer, num_bytes, &addr->addr, addr_len);
}
bool SocketControlMessage::is_file_descriptors_control_message() {
return false;
}
intptr_t SocketBase::ReceiveMessage(intptr_t fd,
void* buffer,
int64_t* p_buffer_num_bytes,
SocketControlMessage** p_messages,
SocketOpKind sync,
OSError* p_oserror) {
errno = ENOSYS;
return -1;
}
bool SocketBase::AvailableDatagram(intptr_t fd,
void* buffer,
intptr_t num_bytes) {
ClientSocket* client_socket = reinterpret_cast<ClientSocket*>(fd);
return client_socket->DataReady();
}
bool SocketBase::HasPendingWrite(intptr_t fd) {
Handle* handle = reinterpret_cast<Handle*>(fd);
return handle->HasPendingWrite();
}
intptr_t SocketBase::Write(intptr_t fd,
const void* buffer,
intptr_t num_bytes,
SocketOpKind sync) {
Handle* handle = reinterpret_cast<Handle*>(fd);
return handle->Write(buffer, num_bytes);
}
intptr_t SocketBase::SendTo(intptr_t fd,
const void* buffer,
intptr_t num_bytes,
const RawAddr& addr,
SocketOpKind sync) {
Handle* handle = reinterpret_cast<Handle*>(fd);
RawAddr& raw = const_cast<RawAddr&>(addr);
return handle->SendTo(buffer, num_bytes, &raw.addr,
SocketAddress::GetAddrLength(addr));
}
intptr_t SocketBase::SendMessage(intptr_t fd,
void* buffer,
size_t num_bytes,
SocketControlMessage* messages,
intptr_t num_messages,
SocketOpKind sync,
OSError* p_oserror) {
errno = ENOSYS;
return -1;
}
bool SocketBase::GetSocketName(intptr_t fd, SocketAddress* p_sa) {
ASSERT(fd >= 0);
ASSERT(p_sa != nullptr);
RawAddr raw;
socklen_t size = sizeof(raw);
if (getsockname(fd, &raw.addr, &size) == SOCKET_ERROR) {
return false;
}
// sockaddr_un contains sa_family_t sun_family and char[] sun_path.
// If size is the size of sa_family_t, this is an unnamed socket and
// sun_path contains garbage.
new (p_sa) SocketAddress(&raw.addr,
/*unnamed_unix_socket=*/size == sizeof(u_short));
return true;
}
intptr_t SocketBase::GetPort(intptr_t fd) {
ASSERT(reinterpret_cast<Handle*>(fd)->is_socket());
SocketHandle* socket_handle = reinterpret_cast<SocketHandle*>(fd);
RawAddr raw;
socklen_t size = sizeof(raw);
if (getsockname(socket_handle->socket(), &raw.addr, &size) == SOCKET_ERROR) {
return 0;
}
return SocketAddress::GetAddrPort(raw);
}
SocketAddress* SocketBase::GetRemotePeer(intptr_t fd, intptr_t* port) {
ASSERT(reinterpret_cast<Handle*>(fd)->is_socket());
SocketHandle* socket_handle = reinterpret_cast<SocketHandle*>(fd);
RawAddr raw;
if (socket_handle->is_client_socket() &&
reinterpret_cast<ClientSocket*>(fd)->PopulateRemoteAddr(raw)) {
// `raw` was populated by `ClientSocket::PopulateRemoteAddr`.
} else {
socklen_t size = sizeof(raw);
if (getpeername(socket_handle->socket(), &raw.addr, &size)) {
return nullptr;
}
}
*port = SocketAddress::GetAddrPort(raw);
// Clear the port before calling WSAAddressToString as WSAAddressToString
// includes the port in the formatted string.
SocketAddress::SetAddrPort(&raw, 0);
return new SocketAddress(&raw.addr);
}
bool SocketBase::IsBindError(intptr_t error_number) {
return error_number == WSAEADDRINUSE || error_number == WSAEADDRNOTAVAIL ||
error_number == WSAEINVAL;
}
void SocketBase::GetError(intptr_t fd, OSError* os_error) {
Handle* handle = reinterpret_cast<Handle*>(fd);
os_error->SetCodeAndMessage(OSError::kSystem, handle->last_error());
}
int SocketBase::GetType(intptr_t fd) {
Handle* handle = reinterpret_cast<Handle*>(fd);
switch (GetFileType(handle->handle())) {
case FILE_TYPE_CHAR:
return File::kTerminal;
case FILE_TYPE_PIPE:
return File::kPipe;
case FILE_TYPE_DISK:
return File::kFile;
default:
return GetLastError() == NO_ERROR ? File::kOther : -1;
}
}
intptr_t SocketBase::GetStdioHandle(intptr_t num) {
if (num != 0) {
return -1;
}
HANDLE handle = GetStdHandle(STD_INPUT_HANDLE);
if (handle == INVALID_HANDLE_VALUE) {
return -1;
}
StdHandle* std_handle = StdHandle::Stdin(handle);
std_handle->Retain();
return reinterpret_cast<intptr_t>(std_handle);
}
AddressList<SocketAddress>* SocketBase::LookupAddress(const char* host,
int type,
OSError** os_error) {
Initialize();
// Perform a name lookup for a host name.
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = SocketAddress::FromType(type);
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_ADDRCONFIG;
hints.ai_protocol = IPPROTO_TCP;
struct addrinfo* info = nullptr;
int status = getaddrinfo(host, 0, &hints, &info);
if (status != 0) {
// We failed, try without AI_ADDRCONFIG. This can happen when looking up
// e.g. '::1', when there are no global IPv6 addresses.
hints.ai_flags = 0;
status = getaddrinfo(host, 0, &hints, &info);
}
if (status != 0) {
ASSERT(*os_error == nullptr);
DWORD error_code = WSAGetLastError();
SetLastError(error_code);
*os_error = new OSError();
return nullptr;
}
intptr_t count = 0;
for (struct addrinfo* c = info; c != nullptr; c = c->ai_next) {
if ((c->ai_family == AF_INET) || (c->ai_family == AF_INET6)) {
count++;
}
}
AddressList<SocketAddress>* addresses = new AddressList<SocketAddress>(count);
intptr_t i = 0;
for (struct addrinfo* c = info; c != nullptr; c = c->ai_next) {
if ((c->ai_family == AF_INET) || (c->ai_family == AF_INET6)) {
addresses->SetAt(i, new SocketAddress(c->ai_addr));
i++;
}
}
freeaddrinfo(info);
return addresses;
}
bool SocketBase::ReverseLookup(const RawAddr& addr,
char* host,
intptr_t host_len,
OSError** os_error) {
ASSERT(host_len >= NI_MAXHOST);
int status = getnameinfo(&addr.addr, SocketAddress::GetAddrLength(addr), host,
host_len, nullptr, 0, NI_NAMEREQD);
if (status != 0) {
ASSERT(*os_error == nullptr);
DWORD error_code = WSAGetLastError();
SetLastError(error_code);
*os_error = new OSError();
return false;
}
return true;
}
bool SocketBase::ParseAddress(int type, const char* address, RawAddr* addr) {
int result;
const auto system_address = Utf8ToWideChar(address);
if (type == SocketAddress::TYPE_IPV4) {
result = InetPton(AF_INET, system_address.get(), &addr->in.sin_addr);
} else {
ASSERT(type == SocketAddress::TYPE_IPV6);
result = InetPton(AF_INET6, system_address.get(), &addr->in6.sin6_addr);
}
return result == 1;
}
bool SocketBase::RawAddrToString(RawAddr* addr, char* str) {
// According to InetNtopW(), buffer should be large enough for at least 46
// characters for IPv6 and 16 for IPv4.
COMPILE_ASSERT(INET6_ADDRSTRLEN >= 46);
wchar_t tmp_buffer[INET6_ADDRSTRLEN];
if (addr->addr.sa_family == AF_INET) {
if (InetNtop(AF_INET, &addr->in.sin_addr, tmp_buffer, INET_ADDRSTRLEN) ==
nullptr) {
return false;
}
} else {
ASSERT(addr->addr.sa_family == AF_INET6);
if (InetNtop(AF_INET6, &addr->in6.sin6_addr, tmp_buffer,
INET6_ADDRSTRLEN) == nullptr) {
return false;
}
}
WideToUtf8Scope wide_to_utf8_scope(tmp_buffer);
if (wide_to_utf8_scope.length() <= INET6_ADDRSTRLEN) {
strncpy(str, wide_to_utf8_scope.utf8(), INET6_ADDRSTRLEN);
return true;
}
return false;
}
AddressList<InterfaceSocketAddress>* SocketBase::ListInterfaces(
int type,
OSError** os_error) {
Initialize();
ULONG size = 0;
DWORD flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST |
GAA_FLAG_SKIP_DNS_SERVER;
// Query the size needed.
int status = GetAdaptersAddresses(SocketAddress::FromType(type), flags,
nullptr, nullptr, &size);
IP_ADAPTER_ADDRESSES* addrs = nullptr;
if (status == ERROR_BUFFER_OVERFLOW) {
addrs = reinterpret_cast<IP_ADAPTER_ADDRESSES*>(malloc(size));
// Get the addresses now we have the right buffer.
status = GetAdaptersAddresses(SocketAddress::FromType(type), flags, nullptr,
addrs, &size);
}
if (status != NO_ERROR) {
ASSERT(*os_error == nullptr);
DWORD error_code = WSAGetLastError();
SetLastError(error_code);
*os_error = new OSError();
return nullptr;
}
intptr_t count = 0;
for (IP_ADAPTER_ADDRESSES* a = addrs; a != nullptr; a = a->Next) {
for (IP_ADAPTER_UNICAST_ADDRESS* u = a->FirstUnicastAddress; u != nullptr;
u = u->Next) {
count++;
}
}
AddressList<InterfaceSocketAddress>* addresses =
new AddressList<InterfaceSocketAddress>(count);
intptr_t i = 0;
for (IP_ADAPTER_ADDRESSES* a = addrs; a != nullptr; a = a->Next) {
for (IP_ADAPTER_UNICAST_ADDRESS* u = a->FirstUnicastAddress; u != nullptr;
u = u->Next) {
ASSERT(type != AF_INET || a->Flags & IP_ADAPTER_IPV4_ENABLED);
ASSERT(type != AF_INET6 || a->Flags & IP_ADAPTER_IPV6_ENABLED);
ASSERT(a->IfIndex == a->Ipv6IfIndex ||
!(a->Flags & IP_ADAPTER_IPV4_ENABLED) ||
!(a->Flags & IP_ADAPTER_IPV6_ENABLED));
addresses->SetAt(i,
new InterfaceSocketAddress(
u->Address.lpSockaddr,
StringUtilsWin::WideToUtf8(a->FriendlyName),
a->Ipv6IfIndex != 0 ? a->Ipv6IfIndex : a->IfIndex));
i++;
}
}
free(addrs);
return addresses;
}
void SocketBase::Close(intptr_t fd) {
ClientSocket* client_socket = reinterpret_cast<ClientSocket*>(fd);
client_socket->Close();
}
bool SocketBase::GetNoDelay(intptr_t fd, bool* enabled) {
SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
int on;
socklen_t len = sizeof(on);
int err = getsockopt(handle->socket(), IPPROTO_TCP, TCP_NODELAY,
reinterpret_cast<char*>(&on), &len);
if (err == 0) {
*enabled = (on == 1);
}
return (err == 0);
}
bool SocketBase::SetNoDelay(intptr_t fd, bool enabled) {
SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
int on = enabled ? 1 : 0;
return setsockopt(handle->socket(), IPPROTO_TCP, TCP_NODELAY,
reinterpret_cast<char*>(&on), sizeof(on)) == 0;
}
bool SocketBase::GetMulticastLoop(intptr_t fd,
intptr_t protocol,
bool* enabled) {
SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
uint8_t on;
socklen_t len = sizeof(on);
int level = protocol == SocketAddress::TYPE_IPV4 ? IPPROTO_IP : IPPROTO_IPV6;
int optname = protocol == SocketAddress::TYPE_IPV4 ? IP_MULTICAST_LOOP
: IPV6_MULTICAST_LOOP;
if (getsockopt(handle->socket(), level, optname, reinterpret_cast<char*>(&on),
&len) == 0) {
*enabled = (on == 1);
return true;
}
return false;
}
bool SocketBase::SetMulticastLoop(intptr_t fd,
intptr_t protocol,
bool enabled) {
SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
int on = enabled ? 1 : 0;
int level = protocol == SocketAddress::TYPE_IPV4 ? IPPROTO_IP : IPPROTO_IPV6;
int optname = protocol == SocketAddress::TYPE_IPV4 ? IP_MULTICAST_LOOP
: IPV6_MULTICAST_LOOP;
return setsockopt(handle->socket(), level, optname,
reinterpret_cast<char*>(&on), sizeof(on)) == 0;
}
bool SocketBase::GetMulticastHops(intptr_t fd, intptr_t protocol, int* value) {
SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
uint8_t v;
socklen_t len = sizeof(v);
int level = protocol == SocketAddress::TYPE_IPV4 ? IPPROTO_IP : IPPROTO_IPV6;
int optname = protocol == SocketAddress::TYPE_IPV4 ? IP_MULTICAST_TTL
: IPV6_MULTICAST_HOPS;
if (getsockopt(handle->socket(), level, optname, reinterpret_cast<char*>(&v),
&len) == 0) {
*value = v;
return true;
}
return false;
}
bool SocketBase::SetMulticastHops(intptr_t fd, intptr_t protocol, int value) {
SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
int v = value;
int level = protocol == SocketAddress::TYPE_IPV4 ? IPPROTO_IP : IPPROTO_IPV6;
int optname = protocol == SocketAddress::TYPE_IPV4 ? IP_MULTICAST_TTL
: IPV6_MULTICAST_HOPS;
return setsockopt(handle->socket(), level, optname,
reinterpret_cast<char*>(&v), sizeof(v)) == 0;
}
bool SocketBase::GetBroadcast(intptr_t fd, bool* enabled) {
SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
int on;
socklen_t len = sizeof(on);
int err = getsockopt(handle->socket(), SOL_SOCKET, SO_BROADCAST,
reinterpret_cast<char*>(&on), &len);
if (err == 0) {
*enabled = (on == 1);
}
return (err == 0);
}
bool SocketBase::SetBroadcast(intptr_t fd, bool enabled) {
SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
int on = enabled ? 1 : 0;
return setsockopt(handle->socket(), SOL_SOCKET, SO_BROADCAST,
reinterpret_cast<char*>(&on), sizeof(on)) == 0;
}
bool SocketBase::SetOption(intptr_t fd,
int level,
int option,
const char* data,
int length) {
SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
return setsockopt(handle->socket(), level, option, data, length) == 0;
}
bool SocketBase::GetOption(intptr_t fd,
int level,
int option,
char* data,
unsigned int* length) {
SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
int optlen = static_cast<int>(*length);
auto result = getsockopt(handle->socket(), level, option, data, &optlen);
*length = static_cast<unsigned int>(optlen);
return result == 0;
}
bool SocketBase::JoinMulticast(intptr_t fd,
const RawAddr& addr,
const RawAddr&,
int interfaceIndex) {
SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
int proto = addr.addr.sa_family == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
struct group_req mreq;
mreq.gr_interface = interfaceIndex;
memmove(&mreq.gr_group, &addr.ss, SocketAddress::GetAddrLength(addr));
return setsockopt(handle->socket(), proto, MCAST_JOIN_GROUP,
reinterpret_cast<char*>(&mreq), sizeof(mreq)) == 0;
}
bool SocketBase::LeaveMulticast(intptr_t fd,
const RawAddr& addr,
const RawAddr&,
int interfaceIndex) {
SocketHandle* handle = reinterpret_cast<SocketHandle*>(fd);
int proto = addr.addr.sa_family == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
struct group_req mreq;
mreq.gr_interface = interfaceIndex;
memmove(&mreq.gr_group, &addr.ss, SocketAddress::GetAddrLength(addr));
return setsockopt(handle->socket(), proto, MCAST_LEAVE_GROUP,
reinterpret_cast<char*>(&mreq), sizeof(mreq)) == 0;
}
} // namespace bin
} // namespace dart
#endif // defined(DART_HOST_OS_WINDOWS)