TEST(AsyncSocketTest, duplicateBind) {
EventBase base;
auto server1 = AsyncServerSocket::newSocket(&base);
server1->bind(0);
server1->listen(10);
SocketAddress address;
server1->getAddress(std::addressof(address));
auto server2 = AsyncServerSocket::newSocket(&base);
EXPECT_THROW(server2->bind(address.getPort()), std::exception);
}
HTTPClientSession::HTTPClientSession(const SocketAddress& address):
_host(address.host().toString()),
_port(address.port()),
_proxyPort(HTTPSession::HTTP_PORT),
_keepAliveTimeout(DEFAULT_KEEP_ALIVE_TIMEOUT, 0),
_reconnect(false),
_mustReconnect(false),
_expectResponseBody(false),
_pRequestStream(0),
_pResponseStream(0)
{
}
nsapi_size_or_error_t AT_CellularStack::socket_sendto(nsapi_socket_t handle, const SocketAddress &addr, const void *data, unsigned size)
{
CellularSocket *socket = (CellularSocket *)handle;
if (!socket) {
return NSAPI_ERROR_DEVICE_ERROR;
}
if (socket->closed && !socket->rx_avail) {
tr_info("sendto socket %d closed", socket->id);
return NSAPI_ERROR_NO_CONNECTION;
}
if (size == 0) {
if (socket->proto == NSAPI_UDP) {
return NSAPI_ERROR_UNSUPPORTED;
} else if (socket->proto == NSAPI_TCP) {
return 0;
}
}
nsapi_size_or_error_t ret_val = NSAPI_ERROR_OK;
if (!socket->created) {
_at.lock();
ret_val = create_socket_impl(socket);
_at.unlock();
if (ret_val != NSAPI_ERROR_OK) {
tr_error("Socket %d create %s error %d", find_socket_index(socket), addr.get_ip_address(), ret_val);
return ret_val;
}
}
/* Check parameters */
if (addr.get_ip_version() == NSAPI_UNSPEC) {
return NSAPI_ERROR_DEVICE_ERROR;
}
_at.lock();
ret_val = socket_sendto_impl(socket, addr, data, size);
_at.unlock();
if (ret_val >= 0) {
tr_info("Socket %d sent %d bytes to %s port %d", find_socket_index(socket), ret_val, addr.get_ip_address(), addr.get_port());
} else if (ret_val != NSAPI_ERROR_WOULD_BLOCK) {
tr_error("Socket %d sendto %s error %d", find_socket_index(socket), addr.get_ip_address(), ret_val);
}
return ret_val;
}
void TCPServerSocket::bind(const SocketAddress &localAddress)
throw(SocketException) {
createSocket(localAddress, SOCK_STREAM, IPPROTO_TCP);
if (::bind(sockDesc, localAddress.getSockaddr(),
localAddress.getSockaddrLen()) < 0)
throw SocketException(string("Call to bind() failed : ") +
strerror(errno));
// This is temporary.
setListen(5);
}
nsapi_size_or_error_t UDPSocket::sendto(const char *host, uint16_t port, const void *data, nsapi_size_t size)
{
SocketAddress address;
nsapi_size_or_error_t err = _stack->gethostbyname(host, &address);
if (err) {
return NSAPI_ERROR_DNS_FAILURE;
}
address.set_port(port);
// sendto is thread safe
return sendto(address, data, size);
}
void CheckPrefixMatch(
const SocketAddress& first,
const SocketAddress& second,
unsigned matchingPrefixLen) {
unsigned i;
for (i = 0; i <= matchingPrefixLen; i++) {
EXPECT_TRUE(first.prefixMatch(second, i));
}
unsigned addrLen = (first.getFamily() == AF_INET6) ? 128 : 32;
for (; i <= addrLen; i++) {
EXPECT_TRUE(!first.prefixMatch(second, i));
}
}
TEST(SocketAddress, IPv4ToStringConversion) {
// testing addresses *.5.5.5, 5.*.5.5, 5.5.*.5, 5.5.5.*
SocketAddress addr;
for (int pos = 0; pos < 4; ++pos) {
for (int i = 0; i < 256; ++i) {
auto fragments = folly::make_array(5, 5, 5, 5);
fragments[pos] = i;
auto ipString = folly::join(".", fragments);
addr.setFromIpPort(ipString, 1234);
EXPECT_EQ(addr.getAddressStr(), ipString);
}
}
}
void StreamServerSocket::bind( const SocketAddress& sockaddr ) {
if ( m_fd < 0 ) m_fd = socket( sockaddr.linkProtocol(), SOCK_STREAM, 0 );
if ( m_fd < 0 ) {
throw CException("Error creating socket", m_fd);
}
const struct sockaddr* raw = sockaddr.raw();
socklen_t socklen = sockaddr.rawlen();
int rc = ::bind( m_fd, raw, socklen );
if( rc ) {
throw BindException("Error on bind", errno);
}
}
nsapi_error_t TCPSocket::connect(const char *host, uint16_t port)
{
SocketAddress address;
nsapi_error_t err = _stack->gethostbyname(host, &address);
if (err) {
return NSAPI_ERROR_DNS_FAILURE;
}
address.set_port(port);
// connect is thread safe
return connect(address);
}
//Al principio el estado de la red es UNINITIALIZED
NetworkClient::NetworkClient(std::string _addressServer, std::string _addressClient, std::string _nick):nick(_nick), networkState(NetworkState::UNINITIALIZED)
{
saServer.SetAddress(_addressServer);
SocketAddress myAddress;
myAddress.SetAddress(_addressClient);
int errBind = udpSocket.Bind(myAddress);
int errBlock = udpSocket.NonBlocking(true);
if (errBind > -1 && errBlock > -1)
{
//Si podemos hacer BIND y NONBLOCKING, pasamos a estado SAYINGHELLO
//Este cliente empezará a buscar al servidor.
networkState = NetworkState::SAYINGHELLO;
}
}
/*! Spcify the network interface for outgoing multicast
packages
*/
void DgramSocket::setMCastInterface(const SocketAddress &interf)
{
int rc = setsockopt(_sd,
IPPROTO_IP,
IP_MULTICAST_IF,
reinterpret_cast<SocketOptT*>(interf.getSockAddr()),
interf.getSockAddrSize());
if(rc < 0)
{
throw SocketError("setsockopt(IPPROTO_IP,IP_MULTICAST_IF)");
}
}
int main(int argc, char** argv) {
gflags::ParseCommandLineFlags(&argc, &argv, true);
if (FLAGS_port == 0) {
LOG(ERROR) << "Must specify port";
exit(EXIT_FAILURE);
}
// Prep the socket
EventBase evb;
AsyncSocket::UniquePtr socket;
if (FLAGS_ssl) {
auto sslContext = std::make_shared<SSLContext>();
socket = AsyncSocket::UniquePtr(new AsyncSSLSocket(sslContext, &evb));
} else {
socket = AsyncSocket::UniquePtr(new AsyncSocket(&evb));
}
socket->detachEventBase();
if (FLAGS_tfo) {
#if FOLLY_ALLOW_TFO
socket->enableTFO();
#endif
}
// Keep this around
auto sockAddr = socket.get();
BlockingSocket sock(std::move(socket));
SocketAddress addr;
addr.setFromHostPort(FLAGS_host, FLAGS_port);
sock.setAddress(addr);
sock.open();
LOG(INFO) << "connected to " << addr.getAddressStr();
sock.write((const uint8_t*)FLAGS_msg.data(), FLAGS_msg.size());
LOG(ERROR) << "TFO attempted: " << sockAddr->getTFOAttempted();
LOG(ERROR) << "TFO finished: " << sockAddr->getTFOFinished();
std::array<char, 1024> buf;
int32_t bytesRead = 0;
while ((bytesRead = sock.read((uint8_t*)buf.data(), buf.size())) != 0) {
std::cout << std::string(buf.data(), bytesRead);
}
sock.close();
return 0;
}
int ICMPClient::ping(SocketAddress& address, int repeat) const
{
if (repeat <= 0) return 0;
ICMPSocket icmpSocket(_family);
SocketAddress returnAddress;
ICMPEventArgs eventArgs(address, repeat, icmpSocket.dataSize(), icmpSocket.ttl());
pingBegin.notify(this, eventArgs);
for (int i = 0; i < repeat; ++i)
{
icmpSocket.sendTo(address);
++eventArgs;
try
{
int t = icmpSocket.receiveFrom(returnAddress);
eventArgs.setReplyTime(i, t);
pingReply.notify(this, eventArgs);
}
catch (TimeoutException&)
{
std::ostringstream os;
os << address.host().toString() << ": Request timed out.";
eventArgs.setError(i, os.str());
pingError.notify(this, eventArgs);
continue;
}
catch (ICMPException& ex)
{
std::ostringstream os;
os << address.host().toString() << ": " << ex.what();
eventArgs.setError(i, os.str());
pingError.notify(this, eventArgs);
continue;
}
catch (Exception& ex)
{
std::ostringstream os;
os << ex.displayText();
eventArgs.setError(i, os.str());
pingError.notify(this, eventArgs);
continue;
}
}
pingEnd.notify(this, eventArgs);
return eventArgs.received();
}
int TCPSocket::bindAddr(SocketAddress &serveraddr)
{
if( m_iIpType == IPV4)
{
struct sockaddr_in addr;
memset(&addr,0,sizeof(addr));
addr.sin_family = PF_INET;
if(serveraddr.ifAnyAddr())
addr.sin_addr.s_addr = htons(INADDR_ANY);
else if((inet_aton(serveraddr.getIP(),(in_addr *)&addr.sin_addr.s_addr)) == 0)
{
handleSyscallError("TCPSocket::bindAddr");
return FAILED;
}
if(serveraddr.getPort()==0)
{
handleError("TCPSocket::getPort");
return FAILED;
}
addr.sin_port = htons(serveraddr.getPort());
if(bind(m_iSockFd,(const struct sockaddr *)&addr,sizeof(addr)) <0)
{
handleSyscallError("TCPSocket::bindAddr");
return FAILED;
}
} else
{
struct sockaddr_in6 addr;
memset(&addr,0,sizeof(addr));
addr.sin6_family = PF_INET6;
addr.sin6_scope_id = 2;
if( serveraddr.ifAnyAddr())
addr.sin6_addr = in6addr_any;
else
{
if( inet_pton(PF_INET6,serveraddr.getIP(),&(addr.sin6_addr)) < 0)
{
handleSyscallError("TCPSocket::bindAddr");
return FAILED;
}
}
if(serveraddr.getPort()==0)
{
handleError("TCPSocket::getPort");
return FAILED;
}
addr.sin6_port = htons(serveraddr.getPort());
if(bind(m_iSockFd,(const struct sockaddr *)&addr,sizeof(addr)) <0)
{
handleSyscallError("TCPSocket::bindAddr");
return FAILED;
}
}
return SUCCESSFUL;
}
void ServerSocket::listen(const SocketAddress& local, int backlog,
bool reuseAddr, bool blocking) throw (IOException&)
{
close();
int sock = mxos::openSocket(AF_INET, SOCK_STREAM, 0);
if (-1 == sock)
{
THROW3(IOException, "Can't open socket", mxos::getLastSocketError());
}
if (reuseAddr)
{
int val = 1;
if (0 != mxos::setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &val,
sizeof(val)))
{
mxos::closeSocket(sock);
THROW3(IOException, "Can't reuse addr", mxos::getLastSocketError());
}
}
if (0 != mxos::bind(sock, local.sockAddress(), local.length()))
{
mxos::closeSocket(sock);
THROW3(IOException, std::string("Can't bind socket to:") + local.toString(), mxos::getLastSocketError());
}
if (!blocking)
{
try
{
IOUtil::configBlocking(sock, false);
} catch (mxcore::IOException& e)
{
mxos::closeSocket(sock);
throw e;
}
}
if (0 != mxos::listen(sock, backlog))
{
mxos::closeSocket(sock);
THROW3(IOException, "Can't listen socket", mxos::getLastSocketError());
}
handle_ = sock;
}
void DatagramSocketTest::testSendToReceiveFrom()
{
UDPEchoServer echoServer(SocketAddress("localhost", 0));
DatagramSocket ss(SocketAddress::IPv4);
int n = ss.sendTo("hello", 5, SocketAddress("localhost", echoServer.port()));
assert (n == 5);
char buffer[256];
SocketAddress sa;
n = ss.receiveFrom(buffer, sizeof(buffer), sa);
assert (sa.host() == echoServer.address().host());
assert (sa.port() == echoServer.port());
assert (n == 5);
assert (std::string(buffer, n) == "hello");
ss.close();
}
int Socket::listen(const SocketAddress& addr, int backlog) const
{
createSocket(addr);
const SOCKET& socket = impl->fd;
BOOL yes=1;
QPID_WINSOCK_CHECK(setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (char *)&yes, sizeof(yes)));
if (::bind(socket, getAddrInfo(addr).ai_addr, getAddrInfo(addr).ai_addrlen) == SOCKET_ERROR)
throw Exception(QPID_MSG("Can't bind to " << addr.asString() << ": " << strError(WSAGetLastError())));
if (::listen(socket, backlog) == SOCKET_ERROR)
throw Exception(QPID_MSG("Can't listen on " <<addr.asString() << ": " << strError(WSAGetLastError())));
return getLocalPort(socket);
}
ssize_t
SocketDescriptor::Write(const void *buffer, size_t length,
SocketAddress address)
{
int flags = 0;
#ifdef HAVE_POSIX
flags |= MSG_DONTWAIT;
#endif
#ifdef __linux__
flags |= MSG_NOSIGNAL;
#endif
return ::sendto(Get(), (const char *)buffer, length, flags,
address.GetAddress(), address.GetSize());
}
TEST_F (SocketAddressTest, Set)
{
SocketAddress sa;
ASSERT_TRUE (sa.SetToLocalhost (AF_INET, 1138));
ASSERT_STREQ ("127.0.0.1", sa.GetIPAddress ().c_str ());
ASSERT_EQ (1138, sa.GetPort ());
ASSERT_TRUE (sa.SetToAnyAddress (AF_INET, 0));
ASSERT_STREQ ("0.0.0.0", sa.GetIPAddress ().c_str ());
ASSERT_EQ (0, sa.GetPort ());
ASSERT_TRUE (sa.SetToLocalhost (AF_INET6, 1139));
ASSERT_STREQ ("::1", sa.GetIPAddress ().c_str ());
ASSERT_EQ (1139, sa.GetPort ());
}
bool ControlPoint::addPortMapping(PortMapping& pm, Service& wipcs)
{
bool rval = true;
// if internal client is not specified, get it by connecting to gateway
if(!pm->hasMember("NewInternalClient") ||
pm["NewInternalClient"]->length() == 0)
{
// get the control url for the service
Url url;
url.format("%s%s",
wipcs["rootURL"]->getString(),
wipcs["controlURL"]->getString());
HttpConnectionRef conn = HttpClient::createConnection(&url);
if(!conn.isNull())
{
SocketAddress* addr = conn->getLocalAddress();
pm["NewInternalClient"] = addr->getAddress();
conn->close();
}
else
{
MO_CAT_ERROR(MO_UPNP_CAT,
"Could not add port mapping, could not connect to '%s'.",
url.toString().c_str());
rval = false;
}
}
if(rval)
{
MO_CAT_DEBUG(MO_UPNP_CAT,
"Adding port mapping: %s", JsonWriter::writeToString(pm).c_str());
}
// perform the action
ActionResult result;
rval = rval && performAction("AddPortMapping", pm, wipcs, result);
if(!rval)
{
MO_CAT_ERROR(MO_UPNP_CAT,
"Failed to add port mapping: %s, %s",
JsonWriter::writeToString(pm).c_str(),
JsonWriter::writeToString(Exception::getAsDynamicObject()).c_str());
}
return rval;
}
TEST(SocketAddress, SetFromSocketUnixExplicit) {
// Pick two temporary path names.
TemporaryDirectory tempDirectory("SocketAddressTest");
std::string serverPath = (tempDirectory.path() / "server").string();
std::string clientPath = (tempDirectory.path() / "client").string();
SocketAddress serverBindAddr;
SocketAddress clientBindAddr;
SocketAddress listenAddr;
SocketAddress acceptAddr;
SocketAddress serverAddr;
SocketAddress serverPeerAddr;
SocketAddress clientAddr;
SocketAddress clientPeerAddr;
try {
serverBindAddr.setFromPath(serverPath.c_str());
clientBindAddr.setFromPath(clientPath.c_str());
testSetFromSocket(
&serverBindAddr,
&clientBindAddr,
&listenAddr,
&acceptAddr,
&serverAddr,
&serverPeerAddr,
&clientAddr,
&clientPeerAddr);
} catch (...) {
// Remove the socket files after we are done
unlink(serverPath.c_str());
unlink(clientPath.c_str());
throw;
}
unlink(serverPath.c_str());
unlink(clientPath.c_str());
// The server socket's local address should be the same as the listen
// address.
EXPECT_EQ(serverAddr, listenAddr);
// The client's peer address should always be the same as the server
// socket's address.
EXPECT_EQ(clientPeerAddr, serverAddr);
EXPECT_EQ(serverPeerAddr, clientAddr);
EXPECT_EQ(serverPeerAddr, acceptAddr);
EXPECT_EQ(acceptAddr, clientAddr);
}
TEST(SocketAddress, IPv4ToStringConversion) {
// testing addresses *.5.5.5, 5.*.5.5, 5.5.*.5, 5.5.5.*
SocketAddress addr;
for (int pos = 0; pos < 4; ++pos) {
for (int i = 0; i < 256; ++i) {
int fragments[] = {5,5,5,5};
fragments[pos] = i;
std::ostringstream ss;
ss << fragments[0] << "." << fragments[1] << "."
<< fragments[2] << "." << fragments[3];
string ipString = ss.str();
addr.setFromIpPort(ipString, 1234);
EXPECT_EQ(addr.getAddressStr(), ipString);
}
}
}
bool Acceptor::canAccept(const SocketAddress& address) {
if (!connectionCounter_) {
return true;
}
uint64_t maxConnections = connectionCounter_->getMaxConnections();
if (maxConnections == 0) {
return true;
}
uint64_t currentConnections = connectionCounter_->getNumConnections();
if (currentConnections < maxConnections) {
return true;
}
if (loadShedConfig_.isWhitelisted(address)) {
return true;
}
// Take care of comparing connection count against max connections across
// all acceptors. Expensive since a lock must be taken to get the counter.
auto connectionCountForLoadShedding = getConnectionCountForLoadShedding();
if (connectionCountForLoadShedding < loadShedConfig_.getMaxConnections()) {
return true;
}
VLOG(4) << address.describe() << " not whitelisted";
return false;
}
void FTPClientSession::sendPORT(const SocketAddress& addr)
{
std::string arg(addr.host().toString());
for (std::string::iterator it = arg.begin(); it != arg.end(); ++it)
{
if (*it == '.') *it = ',';
}
arg += ',';
Poco::UInt16 port = addr.port();
arg += NumberFormatter::format(port/256);
arg += ',';
arg += NumberFormatter::format(port % 256);
std::string response;
int status = sendCommand("PORT", arg, response);
if (!isPositiveCompletion(status)) throw FTPException("PORT command failed", response, status);
}
int SocketImpl::sendTo(const void* buffer, int length, const SocketAddress& address, int flags)
{
int rc;
do
{
if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
#if defined(POCO_VXWORKS)
rc = ::sendto(_sockfd, (char*) buffer, length, flags, (sockaddr*) address.addr(), address.length());
#else
rc = ::sendto(_sockfd, reinterpret_cast<const char*>(buffer), length, flags, address.addr(), address.length());
#endif
}
while (_blocking && rc < 0 && lastError() == POCO_EINTR);
if (rc < 0) error();
return rc;
}
nsapi_error_t LWIP::socket_connect(nsapi_socket_t handle, const SocketAddress &address)
{
struct mbed_lwip_socket *s = (struct mbed_lwip_socket *)handle;
ip_addr_t ip_addr;
nsapi_addr_t addr = address.get_addr();
if (!convert_mbed_addr_to_lwip(&ip_addr, &addr)) {
return NSAPI_ERROR_PARAMETER;
}
netconn_set_nonblocking(s->conn, false);
err_t err = netconn_connect(s->conn, &ip_addr, address.get_port());
netconn_set_nonblocking(s->conn, true);
return err_remap(err);
}
void UnixDatagramSocketImpl::setMulticastInterface(SocketAddress interfaceAddress)
{
UnixSocketAddressImpl *addrImpl = dynamic_cast<ios_fc::UnixSocketAddressImpl *>(interfaceAddress.getImpl());
in_addr_t interface_addr = htonl(addrImpl->getAddress());
if (setsockopt (socketFd, IPPROTO_IP, IP_MULTICAST_IF, &interface_addr, sizeof(in_addr)) != 0)
throw Exception("setMulticastInterface: setsockopt failed!\n");
}
nsapi_error_t AT_CellularStack::socket_bind(nsapi_socket_t handle, const SocketAddress &addr)
{
struct CellularSocket *socket = (CellularSocket *)handle;
if (!socket) {
return NSAPI_ERROR_DEVICE_ERROR;
}
if (addr) {
return NSAPI_ERROR_UNSUPPORTED;
}
_at.lock();
uint16_t port = addr.get_port();
if (port != socket->localAddress.get_port()) {
if (port && (get_socket_index_by_port(port) == -1)) {
socket->localAddress.set_port(port);
} else {
_at.unlock();
return NSAPI_ERROR_PARAMETER;
}
}
if (!socket->created) {
create_socket_impl(socket);
}
return _at.unlock_return_error();
}
int NanostackInterface::socket_bind(void *handle, const SocketAddress &address)
{
// Validate parameters
NanostackSocket * socket = static_cast<NanostackSocket *>(handle);
if (NULL == handle) {
MBED_ASSERT(false);
return NSAPI_ERROR_NO_SOCKET;
}
nanostack_lock();
ns_address_t ns_address;
ns_address.type = ADDRESS_IPV6;
memset(ns_address.address, 0, sizeof ns_address.address);
ns_address.identifier = address.get_port();
int ret = NSAPI_ERROR_DEVICE_ERROR;
if (0 == ::socket_bind(socket->socket_id, &ns_address)) {
socket->set_bound();
ret = 0;
}
nanostack_unlock();
tr_debug("socket_bind(socket=%p) sock_id=%d, ret=%i", socket, socket->socket_id, ret);
return ret;
}
void NetworkManagerServer::HandlePacketFromNewClient( InputMemoryBitStream& inInputStream, const SocketAddress& inFromAddress )
{
//read the beginning- is it a hello?
uint32_t packetType;
inInputStream.Read( packetType );
if( packetType == kHelloCC )
{
//read the name
string name;
inInputStream.Read( name );
ClientProxyPtr newClientProxy = std::make_shared< ClientProxy >( inFromAddress, name, mNewPlayerId++ );
mAddressToClientMap[ inFromAddress ] = newClientProxy;
mPlayerIdToClientMap[ newClientProxy->GetPlayerId() ] = newClientProxy;
//tell the server about this client, spawn a cat, etc...
//if we had a generic message system, this would be a good use for it...
//instead we'll just tell the server directly
static_cast< Server* > ( Engine::sInstance.get() )->HandleNewClient( newClientProxy );
//and welcome the client...
SendWelcomePacket( newClientProxy );
//and now init the replication manager with everything we know about!
for( const auto& pair: mNetworkIdToGameObjectMap )
{
newClientProxy->GetReplicationManagerServer().ReplicateCreate( pair.first, pair.second->GetAllStateMask() );
}
}
else
{
//bad incoming packet from unknown client- we're under attack!!
LOG( "Bad incoming packet from unknown client at socket %s", inFromAddress.ToString().c_str() );
}
}