bool MiniWebServer::init(const string &ip, int _port) {
port = _port;
SockAddr me;
if ( ip.empty() )
me = SockAddr( port );
else
me = SockAddr( ip.c_str(), port );
sock = ::socket(AF_INET, SOCK_STREAM, 0);
if ( sock == INVALID_SOCKET ) {
log() << "ERROR: MiniWebServer listen(): invalid socket? " << OUTPUT_ERRNO << endl;
return false;
}
prebindOptions( sock );
if ( ::bind(sock, (sockaddr *) &me.sa, me.addressSize) != 0 ) {
log() << "MiniWebServer: bind() failed port:" << port << " " << OUTPUT_ERRNO << endl;
if ( errno == EADDRINUSE )
log() << " addr already in use" << endl;
closesocket(sock);
return false;
}
if ( ::listen(sock, 16) != 0 ) {
log() << "MiniWebServer: listen() failed " << OUTPUT_ERRNO << endl;
closesocket(sock);
return false;
}
return true;
}
bool MiniWebServer::init(const string &ip, int _port) {
port = _port;
SockAddr me;
if ( ip.empty() )
me = SockAddr( port );
else
me = SockAddr( ip.c_str(), port );
sock = ::socket(me.family, SOCK_STREAM, 0);
if ( sock == INVALID_SOCKET ) {
log() << "ERROR: MiniWebServer listen(): invalid socket? " << errno << endl;
return false;
}
prebindOptions( sock );
if ( ::bind(sock, me.getSockAddr(), me.addressSize) != 0 ) {
log() << "MiniWebServer: bind() failed port:" << port << " errno:" << errno << endl;
if ( errno == 98 )
log() << "98 == addr already in use" << endl;
closesocket(sock);
return false;
}
if ( ::listen(sock, 16) != 0 ) {
log() << "MiniWebServer: listen() failed " << errno << endl;
closesocket(sock);
return false;
}
return true;
}
bool Listener::init() {
SockAddr me;
if ( ip.empty() )
me = SockAddr( port );
else
me = SockAddr( ip.c_str(), port );
sock = ::socket(AF_INET, SOCK_STREAM, 0);
if ( sock == INVALID_SOCKET ) {
log() << "ERROR: listen(): invalid socket? " << errno << endl;
return false;
}
prebindOptions( sock );
if ( ::bind(sock, (sockaddr *) &me.sa, me.addressSize) != 0 ) {
log() << "listen(): bind() failed errno:" << errno << endl;
if ( errno == 98 )
log() << "98 == addr already in use" << endl;
closesocket(sock);
return false;
}
if ( ::listen(sock, 128) != 0 ) {
log() << "listen(): listen() failed " << errno << endl;
closesocket(sock);
return false;
}
return true;
}
/**
* Creates the a listen socket on the bfd listen port.
*
* @param listenAddr [in] - May be "ANY" (0.0.0.0 or ::)
*
* outSocket will be empty on failure.
*
*
*/
void Beacon::makeListenSocket(const IpAddr &listenAddr, Socket &outSocket)
{
Socket listenSocket;
outSocket.Close();
// Any socket error will get logged, so we don't need to log them again.
listenSocket.SetLogName(FormatShortStr("BFD %s listen socket", listenAddr.ToString()));
listenSocket.OpenUDP(listenAddr.Type());
if (listenSocket.empty())
return;
if (!listenSocket.SetTTLOrHops(bfd::TTLValue))
return;
if (!listenSocket.SetRecieveTTLOrHops(true))
return;
if (!listenSocket.SetReceiveDestinationAddress(true))
return;
if (listenAddr.Type() == Addr::IPv6)
{
if (!listenSocket.SetIPv6Only(true))
return;
}
if (!listenSocket.Bind(SockAddr(listenAddr, bfd::ListenPort)))
return;
// Take ownership
outSocket.Transfer(listenSocket);
outSocket.SetLogName(listenSocket.LogName());
gLog.Optional(Log::App, "Listening for BFD connections on %s", SockAddr(listenAddr, bfd::ListenPort).ToString());
}
SockAddr::SockAddr(const char * _iporhost , int port) {
string target = _iporhost;
if( target == "localhost" ) {
target = "127.0.0.1";
}
if( mongoutils::str::contains(target, '/') ) {
#ifdef _WIN32
uassert(13080, "no unix socket support on windows", false);
#endif
uassert(13079, "path to unix socket too long",
target.size() < sizeof(as<sockaddr_un>().sun_path));
as<sockaddr_un>().sun_family = AF_UNIX;
strcpy(as<sockaddr_un>().sun_path, target.c_str());
addressSize = sizeof(sockaddr_un);
}
else {
addrinfo* addrs = NULL;
addrinfo hints;
memset(&hints, 0, sizeof(addrinfo));
hints.ai_socktype = SOCK_STREAM;
//hints.ai_flags = AI_ADDRCONFIG; // This is often recommended but don't do it.
// SERVER-1579
hints.ai_flags |= AI_NUMERICHOST; // first pass tries w/o DNS lookup
hints.ai_family = (IPv6Enabled() ? AF_UNSPEC : AF_INET);
StringBuilder ss;
ss << port;
int ret = getaddrinfo(target.c_str(), ss.str().c_str(), &hints, &addrs);
// old C compilers on IPv6-capable hosts return EAI_NODATA error
#ifdef EAI_NODATA
int nodata = (ret == EAI_NODATA);
#else
int nodata = false;
#endif
if ( (ret == EAI_NONAME || nodata) ) {
// iporhost isn't an IP address, allow DNS lookup
hints.ai_flags &= ~AI_NUMERICHOST;
ret = getaddrinfo(target.c_str(), ss.str().c_str(), &hints, &addrs);
}
if (ret) {
// we were unsuccessful
if( target != "0.0.0.0" ) { // don't log if this as it is a
// CRT construction and log() may not work yet.
log() << "getaddrinfo(\"" << target << "\") failed: " <<
gai_strerror(ret) << endl;
}
*this = SockAddr(port);
}
else {
//TODO: handle other addresses in linked list;
fassert(16501, addrs->ai_addrlen <= sizeof(sa));
memcpy(&sa, addrs->ai_addr, addrs->ai_addrlen);
addressSize = addrs->ai_addrlen;
freeaddrinfo(addrs);
}
}
}
// If an ip address is passed in, just return that. If a hostname is passed
// in, look up its ip and return that. Returns "" on failure.
string hostbyname(const char *hostname) {
string addr = SockAddr(hostname, 0).getAddr();
if (addr == "0.0.0.0")
return "";
else
return addr;
}
bool Acceptor::open(int listen_port,
int backlog,
auto_ptr<HandlerCreatorStrategyBase> handler_creator_stg,
ErrorCode* ec)
{
return open(SockAddr(listen_port), backlog, handler_creator_stg, auto_ptr<FilterCreatorStrategyBase>(), ec);
}
SockAddr getSockAddrFromIpPort(const IpPort &addr){
::sockaddr_in sin;
if(::inet_pton(AF_INET, addr.ip.get(), &sin.sin_addr) == 1){
sin.sin_family = AF_INET;
storeBe(sin.sin_port, addr.port);
return SockAddr(&sin, sizeof(sin));
}
::sockaddr_in6 sin6;
if(::inet_pton(AF_INET6, addr.ip.get(), &sin6.sin6_addr) == 1){
sin6.sin6_family = AF_INET6;
storeBe(sin6.sin6_port, addr.port);
return SockAddr(&sin6, sizeof(sin6));
}
LOG_POSEIDON_ERROR("Unknown address format: ", addr.ip);
DEBUG_THROW(Exception, sslit("Unknown address format"));
}
static SockAddr getLocalAddrForBoundSocketFd(int fd) {
SockAddr result;
int rc = getsockname(fd, result.raw(), &result.addressSize);
if (rc != 0) {
warning() << "Could not resolve local address for socket with fd " << fd << ": " <<
getAddrInfoStrError(socketGetLastError());
result = SockAddr();
}
return result;
}
SockAddr::SockAddr(const char * iporhost , int port) {
if (!strcmp(iporhost, "localhost"))
iporhost = "127.0.0.1";
if (strchr(iporhost, '/')) {
#ifdef _WIN32
uassert(13080, "no unix socket support on windows", false);
#endif
uassert(13079, "path to unix socket too long", strlen(iporhost) < sizeof(as<sockaddr_un>().sun_path));
as<sockaddr_un>().sun_family = AF_UNIX;
strcpy(as<sockaddr_un>().sun_path, iporhost);
addressSize = sizeof(sockaddr_un);
}
else {
addrinfo* addrs = NULL;
addrinfo hints;
memset(&hints, 0, sizeof(addrinfo));
hints.ai_socktype = SOCK_STREAM;
//hints.ai_flags = AI_ADDRCONFIG; // This is often recommended but don't do it. SERVER-1579
hints.ai_flags |= AI_NUMERICHOST; // first pass tries w/o DNS lookup
hints.ai_family = (IPv6Enabled() ? AF_UNSPEC : AF_INET);
stringstream ss;
ss << port;
int ret = getaddrinfo(iporhost, ss.str().c_str(), &hints, &addrs);
// old C compilers on IPv6-capable hosts return EAI_NODATA error
#ifdef EAI_NODATA
int nodata = (ret == EAI_NODATA);
#else
int nodata = false;
#endif
if (ret == EAI_NONAME || nodata) {
// iporhost isn't an IP address, allow DNS lookup
hints.ai_flags &= ~AI_NUMERICHOST;
ret = getaddrinfo(iporhost, ss.str().c_str(), &hints, &addrs);
}
if (ret) {
log() << "getaddrinfo(\"" << iporhost << "\") failed: " << gai_strerror(ret) << endl;
*this = SockAddr(port);
}
else {
//TODO: handle other addresses in linked list;
assert(addrs->ai_addrlen <= sizeof(sa));
memcpy(&sa, addrs->ai_addr, addrs->ai_addrlen);
addressSize = addrs->ai_addrlen;
freeaddrinfo(addrs);
}
}
}
vector<SockAddr> ipToAddrs(const char* ips, int port, bool useUnixSockets) {
vector<SockAddr> out;
if (*ips == '\0') {
out.push_back(SockAddr("0.0.0.0", port)); // IPv4 all
if (IPv6Enabled())
out.push_back(SockAddr("::", port)); // IPv6 all
#ifndef _WIN32
if (useUnixSockets)
out.push_back(SockAddr(makeUnixSockPath(port).c_str(), port)); // Unix socket
#endif
return out;
}
while(*ips) {
string ip;
const char * comma = strchr(ips, ',');
if (comma) {
ip = string(ips, comma - ips);
ips = comma + 1;
}
else {
ip = string(ips);
ips = "";
}
SockAddr sa(ip.c_str(), port);
out.push_back(sa);
#ifndef _WIN32
if (useUnixSockets && (sa.getAddr() == "127.0.0.1" || sa.getAddr() == "0.0.0.0")) // only IPv4
out.push_back(SockAddr(makeUnixSockPath(port).c_str(), port));
#endif
}
return out;
}
// ****************************************************************************
// *** ProviderListenerLoop
// ****************************************************************************
void
khResourceManager::ProviderListenerLoop(void) throw()
{
try {
TCPListener serverSock(SockAddr(InetAddr::IPv4Any,
FusionConnection::khResourceManagerPort));
while (1) {
try {
FusionConnection::Handle provider
(FusionConnection::AcceptClient(serverSock));
if (theSystemManager.WantExit()) {
break;
}
// get initial info about provider
// will throw exception if times out
ProviderConnectMsg connreq;
provider->ReceiveNotify(connreq, SYSMAN_PROVIDER_TIMEOUT);
{
khLockGuard lock(mutex);
// will link himself into my providers list
// and will spawn own handler thread for reading
(void) new khResourceProviderProxy(connreq, provider);
}
} catch (const std::exception &e) {
notify(NFY_WARN,
"Caught exception in resource manager server loop: %s",
e.what());
} catch (...) {
notify(NFY_WARN, "Caught exception in resource manager server loop");
}
}
} catch (const std::exception &e) {
notify(NFY_WARN, "Unable to open server socket: %s", e.what());
} catch (...) {
notify(NFY_WARN, "Unable to open server socket");
}
theSystemManager.SetWantExit();
}
bool LuaNetworkClient::Open(const char* id, const char* registryKey,
lua_State* state, SockAddr* outSockAddr, DWORD serverPort)
{
m_registryKey = SimpleString("Software\\") + registryKey;
m_state = state;
m_id = id;
m_serverPort = serverPort;
m_listenerThread = new LuaClientListenerThread(this);
m_listenerThread->ThreadCreate();
WaitForSingleObject( ((LuaClientListenerThread*)m_listenerThread)->m_socketCreatedEvent, INFINITE );
SockAddr sockAddr;
if (outSockAddr)
sockAddr = *outSockAddr;
else
sockAddr = SockAddr("127.0.0.1", 0);
m_connectSockAddr = sockAddr;
m_autoConnectThread = new AutoConnectThread(this);
m_autoConnectThread->ThreadCreate();
return true;
}
ConnectionPtr Instance::createConnection(const string& name, const string& addr, unsigned options)
{
ConnectionPtr conn(new Connection(this, SockAddr(addr), options));
conn_map_[name] = conn;
return conn;
}
//Windows Firewall Test
bool __fastcall FirewallTest(const uint16_t Protocol)
{
//Initialization
std::shared_ptr<sockaddr_storage> SockAddr(new sockaddr_storage());
memset(SockAddr.get(), 0, sizeof(sockaddr_storage));
SYSTEM_SOCKET FirewallSocket = 0;
//Ramdom number distribution initialization
std::uniform_int_distribution<int> RamdomDistribution(DYNAMIC_MIN_PORT, UINT16_MAX - 1U);
//IPv6
if (Protocol == AF_INET6)
{
((PSOCKADDR_IN6)SockAddr.get())->sin6_addr = in6addr_any;
((PSOCKADDR_IN6)SockAddr.get())->sin6_port = htons((uint16_t)RamdomDistribution(*Parameter.RamdomEngine));
SockAddr->ss_family = AF_INET6;
FirewallSocket = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
//Bind local socket.
if (FirewallSocket == INVALID_SOCKET)
{
return false;
}
else if (bind(FirewallSocket, (PSOCKADDR)SockAddr.get(), sizeof(sockaddr_in6)) == SOCKET_ERROR)
{
((PSOCKADDR_IN6)SockAddr.get())->sin6_port = htons((uint16_t)RamdomDistribution(*Parameter.RamdomEngine));
size_t Index = 0;
while (bind(FirewallSocket, (PSOCKADDR)SockAddr.get(), sizeof(sockaddr_in6)) == SOCKET_ERROR)
{
if (Index < LOOP_MAX_TIMES && WSAGetLastError() == WSAEADDRINUSE)
{
((PSOCKADDR_IN6)SockAddr.get())->sin6_port = htons((uint16_t)RamdomDistribution(*Parameter.RamdomEngine));
++Index;
continue;
}
else {
closesocket(FirewallSocket);
return false;
}
}
}
}
//IPv4
else {
((PSOCKADDR_IN)SockAddr.get())->sin_addr.s_addr = INADDR_ANY;
((PSOCKADDR_IN)SockAddr.get())->sin_port = htons((uint16_t)RamdomDistribution(*Parameter.RamdomEngine));
SockAddr->ss_family = AF_INET;
FirewallSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
//Bind local socket.
if (FirewallSocket == INVALID_SOCKET)
{
return false;
}
else if (bind(FirewallSocket, (PSOCKADDR)SockAddr.get(), sizeof(sockaddr_in)) == SOCKET_ERROR)
{
((PSOCKADDR_IN)SockAddr.get())->sin_port = htons((uint16_t)RamdomDistribution(*Parameter.RamdomEngine));
size_t Index = 0;
while (bind(FirewallSocket, (PSOCKADDR)SockAddr.get(), sizeof(sockaddr_in)) == SOCKET_ERROR)
{
if (Index < LOOP_MAX_TIMES && WSAGetLastError() == WSAEADDRINUSE)
{
((PSOCKADDR_IN)SockAddr.get())->sin_port = htons((uint16_t)RamdomDistribution(*Parameter.RamdomEngine));
++Index;
continue;
}
else {
closesocket(FirewallSocket);
return false;
}
}
}
}
closesocket(FirewallSocket);
return true;
}
void __fastcall CaptureFilterRulesInit(std::string &FilterRules)
{
//Initialization(Part 1)
std::vector<PDNS_SERVER_DATA> AddrList;
auto RepeatingItem = false;
//IPv6
if (Parameter.RequestMode_Network == REQUEST_MODE_NETWORK_BOTH || Parameter.RequestMode_Network == REQUEST_MODE_IPV6 || //IPv6
Parameter.RequestMode_Network == REQUEST_MODE_IPV4 && Parameter.DNSTarget.IPv4.AddressData.Storage.ss_family == 0) //Non-IPv4
{
//Main
if (Parameter.DNSTarget.IPv6.AddressData.Storage.ss_family > 0)
AddrList.push_back(&Parameter.DNSTarget.IPv6);
//Alternate
if (Parameter.DNSTarget.Alternate_IPv6.AddressData.Storage.ss_family > 0)
{
//Check repeating items.
for (auto DNSServerDataIter:AddrList)
{
if (DNSServerDataIter->AddressData.Storage.ss_family == Parameter.DNSTarget.Alternate_IPv6.AddressData.Storage.ss_family &&
memcmp(&DNSServerDataIter->AddressData.IPv6.sin6_addr, &Parameter.DNSTarget.Alternate_IPv6.AddressData.IPv6.sin6_addr, sizeof(in6_addr)) == EXIT_SUCCESS)
{
RepeatingItem = true;
break;
}
}
//Add to address list.
if (!RepeatingItem)
AddrList.push_back(&Parameter.DNSTarget.Alternate_IPv6);
RepeatingItem = false;
}
//Other(Multi)
if (Parameter.DNSTarget.IPv6_Multi != nullptr)
{
for (auto &DNSServerDataIter:*Parameter.DNSTarget.IPv6_Multi)
{
//Check repeating items.
for (auto DNSServerDataInnerIter:AddrList)
{
if (DNSServerDataInnerIter->AddressData.Storage.ss_family == DNSServerDataIter.AddressData.Storage.ss_family &&
memcmp(&DNSServerDataInnerIter->AddressData.IPv6.sin6_addr, &DNSServerDataIter.AddressData.IPv6.sin6_addr, sizeof(in6_addr)) == EXIT_SUCCESS)
{
RepeatingItem = true;
break;
}
}
//Add to address list.
if (!RepeatingItem)
AddrList.push_back(&DNSServerDataIter);
RepeatingItem = false;
}
}
}
//IPv4
if (Parameter.RequestMode_Network == REQUEST_MODE_NETWORK_BOTH || Parameter.RequestMode_Network == REQUEST_MODE_IPV4 || //IPv4
Parameter.RequestMode_Network == REQUEST_MODE_IPV6 && Parameter.DNSTarget.IPv6.AddressData.Storage.ss_family == 0) //Non-IPv6
{
//Main
if (Parameter.DNSTarget.IPv4.AddressData.Storage.ss_family > 0)
AddrList.push_back(&Parameter.DNSTarget.IPv4);
//Alternate
if (Parameter.DNSTarget.Alternate_IPv4.AddressData.Storage.ss_family > 0)
{
//Check repeating items.
for (auto DNSServerDataIter:AddrList)
{
if (DNSServerDataIter->AddressData.Storage.ss_family == Parameter.DNSTarget.Alternate_IPv4.AddressData.Storage.ss_family &&
DNSServerDataIter->AddressData.IPv4.sin_addr.s_addr == Parameter.DNSTarget.Alternate_IPv4.AddressData.IPv4.sin_addr.s_addr)
{
RepeatingItem = true;
break;
}
}
//Add to address list.
if (!RepeatingItem)
AddrList.push_back(&Parameter.DNSTarget.Alternate_IPv4);
RepeatingItem = false;
}
//Other(Multi)
if (Parameter.DNSTarget.IPv4_Multi != nullptr)
{
for (auto &DNSServerDataIter:*Parameter.DNSTarget.IPv4_Multi)
{
//Check repeating items.
for (auto DNSServerDataInnerIter:AddrList)
{
if (DNSServerDataInnerIter->AddressData.Storage.ss_family == DNSServerDataIter.AddressData.Storage.ss_family &&
DNSServerDataInnerIter->AddressData.IPv4.sin_addr.s_addr == DNSServerDataIter.AddressData.IPv4.sin_addr.s_addr)
{
RepeatingItem = true;
break;
}
}
//Add to address list.
if (!RepeatingItem)
AddrList.push_back(&DNSServerDataIter);
RepeatingItem = false;
}
}
}
//Initialization(Part 2)
std::string AddrString;
std::shared_ptr<char> Addr(new char[ADDR_STRING_MAXSIZE]());
memset(Addr.get(), 0, ADDR_STRING_MAXSIZE);
FilterRules.clear();
FilterRules.append("(src host ");
//Minimum supported system of inet_ntop() and inet_pton() is Windows Vista(Windows XP with SP3 support). [Roy Tam]
#if (defined(PLATFORM_WIN32) && !defined(PLATFORM_WIN64))
std::shared_ptr<sockaddr_storage> SockAddr(new sockaddr_storage());
memset(SockAddr.get(), 0, sizeof(sockaddr_storage));
DWORD BufferLength = ADDR_STRING_MAXSIZE;
#endif
//List all target addresses.
RepeatingItem = false;
for (auto DNSServerDataIter:AddrList)
{
//IPv6
if (DNSServerDataIter->AddressData.Storage.ss_family == AF_INET6)
{
if (RepeatingItem)
AddrString.append(" or ");
RepeatingItem = true;
#if (defined(PLATFORM_WIN32) && !defined(PLATFORM_WIN64))
if (Parameter.FunctionPTR_InetNtop != nullptr)
{
(*Parameter.FunctionPTR_InetNtop)(AF_INET6, &DNSServerDataIter->AddressData.IPv6.sin6_addr, Addr.get(), ADDR_STRING_MAXSIZE);
}
else {
BufferLength = ADDR_STRING_MAXSIZE;
SockAddr->ss_family = AF_INET6;
((PSOCKADDR_IN6)SockAddr.get())->sin6_addr = DNSServerDataIter->AddressData.IPv6.sin6_addr;
WSAAddressToStringA((PSOCKADDR)SockAddr.get(), sizeof(sockaddr_in6), nullptr, Addr.get(), &BufferLength);
}
#else
inet_ntop(AF_INET6, &DNSServerDataIter->AddressData.IPv6.sin6_addr, Addr.get(), ADDR_STRING_MAXSIZE);
#endif
AddrString.append(Addr.get());
memset(Addr.get(), 0, ADDR_STRING_MAXSIZE);
}
//IPv4
else if (DNSServerDataIter->AddressData.Storage.ss_family == AF_INET)
{
if (RepeatingItem)
AddrString.append(" or ");
RepeatingItem = true;
#if (defined(PLATFORM_WIN32) && !defined(PLATFORM_WIN64))
if (Parameter.FunctionPTR_InetNtop != nullptr)
{
(*Parameter.FunctionPTR_InetNtop)(AF_INET, &DNSServerDataIter->AddressData.IPv4.sin_addr, Addr.get(), ADDR_STRING_MAXSIZE);
}
else {
BufferLength = ADDR_STRING_MAXSIZE;
SockAddr->ss_family = AF_INET;
((PSOCKADDR_IN)SockAddr.get())->sin_addr = DNSServerDataIter->AddressData.IPv4.sin_addr;
WSAAddressToStringA((PSOCKADDR)SockAddr.get(), sizeof(sockaddr_in), nullptr, Addr.get(), &BufferLength);
}
#else
inet_ntop(AF_INET, &DNSServerDataIter->AddressData.IPv4.sin_addr, Addr.get(), ADDR_STRING_MAXSIZE);
#endif
AddrString.append(Addr.get());
memset(Addr.get(), 0, ADDR_STRING_MAXSIZE);
}
}
//End of address list
FilterRules.append(AddrString);
FilterRules.append(") or (pppoes and src host ");
FilterRules.append(AddrString);
FilterRules.append(")");
return;
}
int CGSocket::Connect( const struct in_addr & ip, WORD wPort )
{
CSocketAddress SockAddr( ip.s_addr, wPort );
return( Connect( SockAddr ));
}
