bool Database::_GetChatroom(Statement &s, Chatroom &Out) { Nullable<std::string> Name; Nullable<std::string> OwnerUsername; Nullable<std::string> Password; Nullable<std::string> Description; Nullable<int> ServerFamily; Nullable<std::string> ServerIP; Nullable<int> ServerPort; if (!s.GetString("Name", Name) || !s.GetString("OwnerUsername", OwnerUsername) || !s.GetString("Password", Password) || !s.GetString("Description", Description) || !s.GetInt("ServerFamily", ServerFamily) || !s.GetString("ServerIP", ServerIP) || !s.GetInt("ServerPort", ServerPort)) return false; if (Name.Null || OwnerUsername.Null || ServerIP.Null || ServerFamily.Null || ServerPort.Null) return false; Net::Address Address; Address.Load(ServerFamily.Value, ServerIP.Value, ServerPort.Value); Out.Name = Name.Value; Out.OwnerUsername = OwnerUsername.Value; Out.ServerAddress = Address; Out.Password = Password; Out.Description = Description; return true; }
bool IPBlockList::blocked(const net::Address& addr) const { if (addr.protocol() == QAbstractSocket::IPv6Protocol || blocks.empty()) return false; // Binary search the list of blocks which are sorted quint32 ip = addr.toIPv4Address(); int begin = 0; int end = blocks.size() - 1; while (true) { if (begin == end) return blocks[begin].constains(ip); else if (begin == end - 1) return blocks[begin].constains(ip) || blocks[end].constains(ip); int pivot = begin + (end - begin) / 2; if (blocks[pivot].constains(ip)) return true; else if (ip < blocks[pivot].ip1) end = pivot - 1; // continue in the range [begin, pivot - 1] else // ip > blocks[pivot].ip2 begin = pivot + 1; // continue in the range [pivot + 1, end] } return false; }
void TCPClient::sendData(const char* data, std::size_t size, const net::Address& peerAddress) { TraceL << "Send data to " << peerAddress << endl; // Ensure permissions exist for the peer. if (!hasPermission(peerAddress.host())) throw std::runtime_error("No permission exists for peer: " + peerAddress.host()); auto conn = connections().get(peerAddress, nullptr); if (!conn) throw std::runtime_error("No peer exists for: " + peerAddress.toString()); conn->send(data, size); }
void HttpServer::newConnection(int fd, const net::Address& addr) { HttpClientHandler* handler = new HttpClientHandler(this,fd); connect(handler,SIGNAL(closed()),this,SLOT(slotConnectionClosed())); Out(SYS_WEB|LOG_NOTICE) << "connection from "<< addr.toString() << endl; clients.append(handler); }
void UDPAllocation::onPeerDataReceived(void*, const MutableBuffer& buffer, const net::Address& peerAddress) { //auto source = reinterpret_cast<net::PacketInfo*>(packet.info); TraceL << "Received UDP Datagram from " << peerAddress << endl; if (!hasPermission(peerAddress.host())) { TraceL << "No Permission: " << peerAddress.host() << endl; return; } updateUsage(buffer.size()); // Check that we have not exceeded out lifetime and bandwidth quota. if (IAllocation::deleted()) return; stun::Message message(stun::Message::Indication, stun::Message::DataIndication); // Try to use the externalIP value for the XorPeerAddress // attribute to overcome proxy and NAT issues. std::string peerHost(server().options().externalIP); if (peerHost.empty()) { peerHost.assign(peerAddress.host()); assert(0 && "external IP not set"); } auto peerAttr = new stun::XorPeerAddress; peerAttr->setAddress(net::Address(peerHost, peerAddress.port())); message.add(peerAttr); auto dataAttr = new stun::Data; dataAttr->copyBytes(bufferCast<const char*>(buffer), buffer.size()); message.add(dataAttr); //Mutex::ScopedLock lock(_mutex); TraceL << "Send data indication:" << "\n\tFrom: " << peerAddress << "\n\tTo: " << _tuple.remote() //<< "\n\tData: " << std::string(packet.data(), packet.size()) << endl; server().udpSocket().sendPacket(message, _tuple.remote()); //net::Address tempAddress("58.7.41.244", _tuple.remote().port()); //server().udpSocket().send(message, tempAddress); }
void TCPSocket::bind(const net::Address& address, unsigned flags) { TraceLS(this) << "Binding on " << address << endl; init(); int r; switch (address.af()) { case AF_INET: r = uv_tcp_bind(ptr<uv_tcp_t>(), address.addr(), flags); break; //case AF_INET6: // r = uv_tcp_bind6(ptr<uv_tcp_t>(), *reinterpret_cast<const sockaddr_in6*>(address.addr())); // break; default: throw std::runtime_error("Unexpected address family"); } if (r) setAndThrowError("TCP bind failed", r); }
void TCPSocket::connect(const net::Address& peerAddress) { TraceLS(this) << "Connecting to " << peerAddress << endl; init(); auto req = new uv_connect_t; req->data = this; int r = uv_tcp_connect(req, ptr<uv_tcp_t>(), peerAddress.addr(), internal::onConnect); if (r) setAndThrowError("TCP connect failed", r); }
bool Database::_GetServer(Statement &s, Server &Out) { Nullable<std::string> Name; Nullable<int> Family; Nullable<std::string> IP; Nullable<int> Port; if (!s.GetString("Name", Name) || !s.GetInt("Family", Family) || !s.GetString("IP", IP) || !s.GetInt("Port", Port)) return false; if (Family.Null || IP.Null || Port.Null || Name.Null) return false; Net::Address Address; Address.Load(Family.Value, IP.Value, Port.Value); Out.Address = Address; Out.Name = Name.Value; return true; }
virtual void dataReceived(bt::Buffer::Ptr ptr, const net::Address& addr) { try { // read and decode the packet BDecoder bdec(ptr->get(), ptr->size(), false); boost::scoped_ptr<BNode> n(bdec.decode()); if (!n || n->getType() != BNode::DICT) return; // try to make a RPCMsg of it RPCMsg::Ptr msg = factory.build((BDictNode*)n.get(), this); if (msg) { if (addr.ipVersion() == 6 && addr.isIPv4Mapped()) msg->setOrigin(addr.convertIPv4Mapped()); else msg->setOrigin(addr); msg->apply(dh_table); // erase an existing call if (msg->getType() == RSP_MSG && calls.contains(msg->getMTID())) { // delete the call, but first notify it off the response RPCCall* c = calls.find(msg->getMTID()); c->response(msg); calls.erase(msg->getMTID()); c->deleteLater(); doQueuedCalls(); } } } catch (bt::Error & err) { Out(SYS_DHT | LOG_DEBUG) << "Error happened during parsing : " << err.toString() << endl; } }
bool ClientHasAlreadyConnected( net::Address & clientAddress ) { bool clientHasAlreadyConnected = false; map<net::Address, net::ServerSocket*>::iterator itr = serverConnections.find( clientAddress ); if( itr != serverConnections.end() ) { clientHasAlreadyConnected = true; printf( "The client %s has already connected\n", clientAddress.ToString().c_str() ); } return clientHasAlreadyConnected; }
bool GUIHandler::sendPacket(const ssl_visualizer_packet &p) { ParameterManager* pm = ParameterManager::getInstance(); string buffer; p.SerializeToString(&buffer); Net::Address multiaddr; multiaddr.setHost(pm->get<string>("network.VISUALIZER_ADDRESS").c_str(), pm->get<int>("network.VISUALIZER_PORT")); bool result; mtx_.lock(); result = this->send(buffer.c_str(), buffer.length(), multiaddr); mtx_.unlock(); if (result==false) { cerr << "Sending Visualizer data failed (maybe too large?). Size was: " << buffer.length() << endl; } else { // cout << buffer.length() << " Bytes of ( Visualizer Packet ) sent." << endl; } return(result); }
void runUDPSocketTest() { // Notes: Sending over home wireless network via // ADSL to US server round trip stays around 200ms // when sending 1450kb packets at 50ms intervals. // At 40ms send intervals latency increated to around 400ms. TraceL << "UDP Socket Test: Starting" << endl; //UDPPacketSize = 10000; UDPPacketSize = 1450; UDPNumPacketsWanted = 100; UDPNumPacketsReceived = 0; //serverBindAddr.swap(net::Address("0.0.0.0", 1337)); // udpServerAddr.swap(net::Address("74.207.248.97", 1337)); // //udpServerAddr.swap(net::Address("127.0.0.1", 1337)); // //clientBindAddr.swap(net::Address("0.0.0.0", 1338)); //clientSendAddr.swap(net::Address("58.7.41.244", 1337)); // //clientSendAddr.swap(net::Address("127.0.0.1", 1337)); // //net::UDPSocket serverSock; //serverSock.Recv += sdelegate(this, &Tests::onUDPSocketServerRecv); //serverSock.bind(serverBindAddr); //this->serverSock = &serverSock; net::UDPSocket clientSock; //clientSock.Recv += sdelegate(this, &Tests::onUDPClientSocketRecv); assert(0 && "fixme"); clientSock.bind(net::Address("0.0.0.0", 0)); clientSock.connect(udpServerAddr); this->udpClientSock = &clientSock; //for (unsigned i = 0; i < UDPNumPacketsWanted; i++) // clientSock.send("bounce", 6, serverBindAddr); // Start the send timer Timer timer; timer.Timeout += sdelegate(this, &Tests::onUDPClientSendTimer); timer.start(50, 50); timer.handle().ref(); runLoop(); //this->serverSock = nullptr; this->udpClientSock = nullptr; }
bool UTPServer::Private::bind(const net::Address& addr) { net::ServerSocket::Ptr sock(new net::ServerSocket(this)); if (!sock->bind(addr)) { return false; } else { Out(SYS_UTP | LOG_NOTICE) << "UTP: bound to " << addr.toString() << endl; sock->setTOS(tos); sock->setReadNotificationsEnabled(false); sock->setWriteNotificationsEnabled(false); sockets.append(sock); return true; } }
bool Database::GetServer(const Net::Address Address, Server &Out) { const std::string Query = "SELECT * FROM Server WHERE Family = :Family AND IP = :IP AND Port = :Port"; Statement s; if (!s.Prepare(Inner, Query)) return false; if (!s.Bind(":Family", Address.Family) || !s.Bind(":IP", Address.GetPrintableIP()) || !s.Bind(":Port", Address.Port)) return false; if (!s.Step()) return false; if (!_GetServer(s, Out)) return false; return true; }