Socket::Status UdpSocket::receive(void* data, std::size_t size, std::size_t& received, IpAddress& remoteAddress, unsigned short& remotePort) { // First clear the variables to fill received = 0; remoteAddress = IpAddress(); remotePort = 0; // Check the destination buffer if (!data) { err() << "Cannot receive data from the network (the destination buffer is invalid)" << std::endl; return Error; } // Data that will be filled with the other computer's address sockaddr_in address = priv::SocketImpl::createAddress(INADDR_ANY, 0); // Receive a chunk of bytes priv::SocketImpl::AddrLength addressSize = sizeof(address); int sizeReceived = recvfrom(getHandle(), static_cast<char*>(data), static_cast<int>(size), 0, reinterpret_cast<sockaddr*>(&address), &addressSize); // Check for errors if (sizeReceived < 0) return priv::SocketImpl::getErrorStatus(); // Fill the sender informations received = static_cast<std::size_t>(sizeReceived); remoteAddress = IpAddress(ntohl(address.sin_addr.s_addr)); remotePort = ntohs(address.sin_port); return Done; }
void ClusterMembership::Tick() { // Called every 1s or so to time out // to handle expired nodes etc struct timeval now; gettimeofday(&now, 0); // Set the local node effective weight. int timesincestart = timevalSub(now, starttime); if (timesincestart < ZeroWeightTime) { effectiveWeight = 0; } else { effectiveWeight = weight; } // Store the effective weight so we can take it into account // determining if we are to be master or not nodes[localaddr].weight = effectiveWeight; // Calculate IP of the new master, to see if it's // us. IpAddress newMaster; IpNodeMap::iterator nodeToForget(0); for (IpNodeMap::iterator i=nodes.begin(); i != nodes.end(); i++) { const IpAddress & ip = (*i).first; NodeInfo &ni = (*i).second; int age = timevalSub(now, ni.lastheard); if (ni.isup && ! ni.isme) { if (age > MaxNodeAge) { std::cout << "Node down:" << ip << std::endl; ni.isup = false; } } if (ni.isup && (ni.weight > 0)) { if (newMaster == IpAddress()) { newMaster = ip; } } if ((age > ForgetNodeAge) && ! (ni.isup || ni.isme)) { nodeToForget = i; } } // If we have a node which has timed out, and needs to // be "forgotten", forget it. if (nodeToForget != IpNodeMap::iterator(0)) { std::cout << "Forgetting node: " << nodeToForget->first << std::endl; nodes.erase(nodeToForget); } if (newMaster != master) { master = newMaster; std::cout << "New master: " << master << std::endl; if (newMaster == IpAddress()) { // no master at all, oh dear. // set our own boundaries to 0 so we don't handle anything. setNewLocalBoundaries(0,0); } } SendAnnouncement(); }
void initializeTransportFactories() { #ifdef RCF_USE_IPV6 const bool compileTimeIpv6 = true; ExceptionPtr ePtr; IpAddress("::1").resolve(ePtr); const bool runTimeIpv6 = (ePtr.get() == NULL); #else const bool compileTimeIpv6 = false; const bool runTimeIpv6 = false; #endif #if defined(BOOST_WINDOWS) getTransportFactories().push_back( TransportFactoryPtr( new Win32NamedPipeTransportFactory())); #endif getTransportFactories().push_back( TransportFactoryPtr( new TcpAsioTransportFactory(IpAddress::V4))); getIpTransportFactories().push_back( TransportFactoryPtr( new TcpAsioTransportFactory(IpAddress::V4))); if (compileTimeIpv6 && runTimeIpv6) { getTransportFactories().push_back( TransportFactoryPtr( new TcpAsioTransportFactory(IpAddress::V6))); getIpTransportFactories().push_back( TransportFactoryPtr( new TcpAsioTransportFactory(IpAddress::V6))); } #ifdef RCF_HAS_LOCAL_SOCKETS getTransportFactories().push_back( TransportFactoryPtr( new UnixLocalTransportFactory())); #endif #ifndef RCF_TEST_NO_UDP getTransportFactories().push_back( TransportFactoryPtr( new UdpTransportFactory(IpAddress::V4))); getIpTransportFactories().push_back( TransportFactoryPtr( new UdpTransportFactory(IpAddress::V4))); if (compileTimeIpv6 && runTimeIpv6) { getTransportFactories().push_back( TransportFactoryPtr( new UdpTransportFactory(IpAddress::V6))); getIpTransportFactories().push_back( TransportFactoryPtr( new UdpTransportFactory(IpAddress::V6))); } #endif }
void runTest() { m_strategy = new OpenConnectionStrategy(this); m_client_listener = new ClientTcpListener(this); m_server_listener = new ServerTcpListener(this); m_evmanager = new EventManager(); m_client = new TcpConnection(IpAddress("127.0.0.1", 9999)); m_listener = new TcpListener(); m_listener->listen(9999); m_listener->setListener(this); m_client->setEventManager(m_evmanager); m_client->setListener(m_client_listener); m_client->open(); m_evmanager->registerClient(m_listener); m_evmanager->registerClient(m_client); m_evmanager->execute(); delete m_strategy; delete m_client_listener; delete m_server_listener; delete m_client; delete m_server; delete m_listener; delete m_evmanager; }
IpAddress SocketImpl::QuerySocketAddress(SocketHandle handle, SocketError* error) { NazaraAssert(handle != InvalidHandle, "Invalid handle"); IpAddressImpl::SockAddrBuffer nameBuffer; int bufferLength = static_cast<int>(nameBuffer.size()); if (getsockname(handle, reinterpret_cast<sockaddr*>(nameBuffer.data()), &bufferLength) == SOCKET_ERROR) { if (error) { int errorCode = WSAGetLastError(); if (errorCode == WSAEINVAL) *error = SocketError_NoError; else *error = TranslateWSAErrorToSocketError(errorCode); } return IpAddress(); } if (error) *error = SocketError_NoError; return IpAddressImpl::FromSockAddr(reinterpret_cast<sockaddr*>(nameBuffer.data())); }
TransportPair UdpTransportFactory::createTransports() { typedef boost::shared_ptr<UdpServerTransport> UdpServerTransportPtr; UdpServerTransportPtr udpServerTransportPtr( new UdpServerTransport( IpAddress(mLoopback, 0) )); udpServerTransportPtr->open(); int port = udpServerTransportPtr->getPort(); ClientTransportAutoPtrPtr clientTransportAutoPtrPtr( new ClientTransportAutoPtr( new UdpClientTransport( IpAddress(mLoopback, port) ))); return std::make_pair( ServerTransportPtr(udpServerTransportPtr), clientTransportAutoPtrPtr); }
IpAddress IpAddress::getPublicAddress(Time timeout) { // The trick here is more complicated, because the only way // to get our public IP address is to get it from a distant computer. // Here we get the web page from http://www.sfml-dev.org/ip-provider.php // and parse the result to extract our IP address // (not very hard: the web page contains only our IP address). Http server("www.sfml-dev.org"); Http::Request request("/ip-provider.php", Http::Request::Get); Http::Response page = server.sendRequest(request, timeout); if (page.getStatus() == Http::Response::Ok) return IpAddress(page.getBody()); // Something failed: return an invalid address return IpAddress(); }
TransportPair TcpAsioTransportFactory::createTransports() { typedef boost::shared_ptr<TcpAsioServerTransport> TcpAsioServerTransportPtr; TcpAsioServerTransportPtr tcpServerTransportPtr( new TcpAsioServerTransport( IpAddress(mLoopback, 0))); tcpServerTransportPtr->open(); int port = tcpServerTransportPtr->getPort(); ClientTransportAutoPtrPtr clientTransportAutoPtrPtr( new ClientTransportAutoPtr( new TcpClientTransport( IpAddress(mLoopback, port)))); return std::make_pair( ServerTransportPtr(tcpServerTransportPtr), clientTransportAutoPtrPtr); }
void CShdrEchoInstance::Init(std::string devicesxmlfilename, std::string shdrfilename, int ipport, double dOverride, std::string devicename) { DevicesXmlFilename()=devicesxmlfilename; ShdrFilename() =shdrfilename; IpAddress() ="127.0.0.1"; // really cant be anything else IpPort()=ipport; DeviceName() = devicename; Override()=dOverride; _bFaultThread=false; if(DevicesXmlFilename().empty()) DevicesXmlFilename()=ExeDirectory() + "devices.xml"; _bRepeat=true; _backend = new CoComMTCShdrBackEnd(); _backend->Init(_bstr_t(IpAddress().c_str()), IpPort(), _bstr_t(DeviceName().c_str())); _backend->MyLogger().AddListener(boost::bind(&CShdrEchoInstance::EchoShdr, this,_1)); _dict = _deviceparser.ReadDeviceDescription(DevicesXmlFilename()); std::string storemap,itemlist, typelist; int i=0; for(DataDictionary::iterator it = _dict.begin(); it!=_dict.end(); it++, i++) { if((*it).first.empty()) { i--; continue; } if(i>0) itemlist+=","; if(i>0) typelist+=","; storemap+=(*it).first+"="+(*it).first+"\n"; // isomorphic: alias = name itemlist+=(*it).first; typelist+=_dict[(*it).first]; } _backend->StoreTagMap(_bstr_t(storemap.c_str())); _backend->StoreTypeMap(_bstr_t(itemlist.c_str()),bstr_t(typelist.c_str())); Open(); _state=Ready; }
IpAddress SocketBase::getLocalAddr() const { socket_details::sockaddr_t addr; ::memset(&addr, 0, sizeof addr); socklen_t addrlen = static_cast<socklen_t>(sizeof addr); if (getsockname(mHandle, reinterpret_cast<sockaddr*>(&addr), &addrlen) < 0) { Debug::Log("SOCKET","getsockname error: %d\n", socket_details::getError()); } return IpAddress(addr); }
IpAddress IpAddress::getLocalAddress() { #ifdef OS_WINDOWS std::cerr << "IpAddress::getLocalAddress() : Win32Implementation is broken" << std::endl; #elif defined OS_UNIX std::cerr << "IpAddress::getLocalAddress() : UNIXImplementation is broken" << std::endl; #else #error "Unknown Operating System on IpAddress::getLocalAddress()" #endif return (IpAddress()); }
IpAddress TcpSocket::getRemoteAddr() const { socket_details::sockaddr_t addr; ::memset(&addr, 0, sizeof addr); socklen_t addrlen = static_cast<socklen_t>(sizeof addr); if (getpeername(mHandle, reinterpret_cast<sockaddr*>(&addr), &addrlen) < 0) { Debug::Error("SOCKET","getpeername error: %d\n", socket_details::getError()); } return IpAddress(addr); }
bool StatStore::recordStart(VERMONT::IpfixRecord::SourceID sourceId) { if (beginMonitoring != true) return false; packet_nb = byte_nb = 0; e_source = e_dest = EndPoint(IpAddress(0,0,0,0),0,0); return true; }
int Interpreteur( char *Buffer, struct Global *g) { char arg0[80],arg1[80],arg2[80],arg3[80],arg4[80] ; int rc ; bzero(arg0,sizeof(arg1)); bzero(arg1,sizeof(arg1)); bzero(arg2,sizeof(arg2)); bzero(arg3,sizeof(arg3)); bzero(arg4,sizeof(arg4)); fprintf(stderr,"Interpreteur ;") ; sscanf(Buffer,"%s %s %s %s %s\n",arg0,arg1,arg2,arg3,arg4) ; fprintf(stderr,"arg0 %s \n",arg0 ) ; /* ATTENTIO? NE PAS OUBLIER ELSE SINON ERREUR DE SYTAXE */ if (strcmp(arg0,"connexion")==0) rc=Connexion(Buffer,arg1,arg2,arg3, arg4,g) ; else if (strcmp(arg0,"ip")==0 &&( strcmp(arg1,"address")==0) ) rc=IpAddress(Buffer,arg1,arg2,arg3, arg4,g) ; else if (strcmp(arg0,"netmask")==0 ) rc = Netmask(Buffer,arg1,arg2,arg3, arg4,g) ; else if (strcmp(arg0,"gateway")==0 ) rc = Gateway(Buffer,arg1,arg2,arg3, arg4,g) ; else if (strcmp(arg0,"dns")==0 ) rc = Dns(Buffer,arg1,arg2,arg3, arg4,g) ; else if (strcmp(arg0,"ports")==0 ) rc = Ports(Buffer,arg1,arg2,arg3, arg4,g) ; else if (strcmp(arg0,"ping")==0 ) rc = Ping(Buffer,arg1,arg2,arg3, arg4,g) ; else if (strcmp(arg0,"send")==0 ) rc = Send(Buffer,arg1,arg2,arg3, arg4,g) ; else if (strcmp(arg0,"bind")==0) rc = Bind(Buffer,arg1,arg2,arg3, arg4,g) ; else if (strcmp(arg0,"nslookup")==0 ) rc= NsLookup(Buffer,arg1,arg2,arg3, arg4,g) ; else if (strcmp(arg0,"waitreceive")==0 ) rc=WaitReceive(g) ; else if (strcmp(arg0,"read")==0) rc = LireMessage( g ) ; else if (strcmp(arg0,"exit")==0) exit(0); else if (strcmp(arg0,"ipconfig")==0) rc = AfficherParametres( g ) ; else if (strcmp(arg0,"help")==0) rc = Help() ; else if (Blanc1013(Buffer)) { fprintf(stderr,"Ligne vide \n" ) ; rc = 1 ; } else rc = 0 ; fprintf(stderr,"fin Interpeteur\n") ; return(rc) ; }
bool Configurator::readIp (std::istream &stream, IpAddress &address) { int family; if (!readInt(stream, family)) return false; unsigned int size = IpAddress::familySize(family); if (size > 0) { std::uint8_t *buffer = new std::uint8_t[size]; if (stream.readsome(reinterpret_cast<char *>(buffer), size) != size || !stream.good()) { delete[] buffer; return false; } address = IpAddress(buffer, family); delete[] buffer; } else address = IpAddress(); return true; }
IpAddress TcpSocket::getRemoteAddress() const { if (getHandle() != priv::SocketImpl::invalidSocket()) { // Retrieve informations about the remote end of the socket sockaddr_in address; priv::SocketImpl::AddrLength size = sizeof(address); if (getpeername(getHandle(), reinterpret_cast<sockaddr*>(&address), &size) != -1) { return IpAddress(ntohl(address.sin_addr.s_addr)); } } // We failed to retrieve the address return IpAddress::None; }
/* * Destructor: * 1. If our previous effective weight was more than 0, and * there was at least one other node, send out a packet with zero * weight so that the other nodes know we're off. * 2. Clean up sockets etc */ ClusterMembership::~ClusterMembership() { std::cout << "ClusterMembership destructor" << std::endl; if (effectiveWeight > 0) { weight = 0; effectiveWeight = 0; // If the master was us, make sure it isn't any more. master = IpAddress(); // We need to ensure we don't throw in the destructor, // as if we did, it would terminate() try { SendAnnouncement(); } catch (std::runtime_error &err) { // Ingore this error. } } close(sock); }
void ClusterMembership::HandleMessage() { char buf[1024]; // Read message from sock struct sockaddr_in sender; socklen_t senderlen = sizeof(sender); int len = recvfrom(sock, buf, sizeof(buf), 0 /* flags */ , (struct sockaddr *) &sender, &senderlen); // If we get EAGAIN, ignore if (len == -1) { if (errno == EAGAIN) { return; } throw std::runtime_error("recv failed"); } // decide what to do with it etc decodePacket(buf,len, IpAddress(& sender.sin_addr)); }
IpAddress IpAddress::getLocalAddress() { // The method here is to connect a UDP socket to anyone (here to localhost), // and get the local socket address with the getsockname function. // UDP connection will not send anything to the network, so this function won't cause any overhead. IpAddress localAddress; // Create the socket SocketHandle sock = socket(PF_INET, SOCK_DGRAM, 0); if (sock == priv::SocketImpl::invalidSocket()) return localAddress; // Connect the socket to localhost on any port sockaddr_in address = priv::SocketImpl::createAddress(ntohl(INADDR_LOOPBACK), 0); if (connect(sock, reinterpret_cast<sockaddr*>(&address), sizeof(address)) == -1) { priv::SocketImpl::close(sock); return localAddress; } // Get the local address of the socket connection priv::SocketImpl::AddrLength size = sizeof(address); int temp = size; if (getsockname(sock, reinterpret_cast<sockaddr*>(&address), &temp) == -1) { priv::SocketImpl::close(sock); return localAddress; } // Close the socket priv::SocketImpl::close(sock); // Finally build the IP address localAddress = IpAddress(ntohl(address.sin_addr.s_addr)); return localAddress; }
SnmpSocket CNotifyEventQueue::get_notify_fd(const UdpAddress match_addr) const { SnmpSocket found_fd = INVALID_SOCKET; int max_bits_matched = 0; IpAddress ip_match = IpAddress(match_addr); for (int i = 0; i < m_notify_fd_count; i++) { IpAddress ip = m_notify_addrs[i]; int bits = ip_match.get_match_bits(ip); debugprintf(5, "Compared %s to %s, bits %d", ip.get_printable(), ip_match.get_printable(), bits); if (bits > max_bits_matched) { max_bits_matched = bits; found_fd = m_notify_fds[i]; } } return found_fd; }
void StatStore::addFieldData(int id, uint8_t* fieldData, int fieldDataLength, VERMONT::IpfixRecord::FieldInfo::Type::EnterpriseNo eid) { // we subscribed to: see Stat::init_*()-functions // addFieldData will be executed until there are no more fieldData // in the current IPFIX record; so we are sure to get everything // we subscribed to (so don't get worried because of // the "breaks" in the "switch" loop hereafter) IpAddress SourceIP = IpAddress(0,0,0,0); IpAddress DestIP = IpAddress(0,0,0,0); switch (id) { case IPFIX_TYPEID_protocolIdentifier: if (fieldDataLength != IPFIX_LENGTH_protocolIdentifier) { msgStr << MsgStream::ERROR << "Got IPFIX field (id=" << id << ") with unsupported length " << fieldDataLength << ". Skipping record." << MsgStream::endl; return; } e_source.setProtocolID(*fieldData); e_dest.setProtocolID(*fieldData); break; case IPFIX_TYPEID_sourceIPv4Address: if (fieldDataLength != IPFIX_LENGTH_sourceIPv4Address) { msgStr << MsgStream::ERROR << "Got IPFIX field (id=" << id << ") with unsupported length " << fieldDataLength << ". Skipping record." << MsgStream::endl; return; } SourceIP.setAddress(fieldData[0],fieldData[1],fieldData[2],fieldData[3]); SourceIP.remanent_mask(netmask); e_source.setIpAddress(SourceIP); break; case IPFIX_TYPEID_destinationIPv4Address: if (fieldDataLength != IPFIX_LENGTH_destinationIPv4Address) { msgStr << MsgStream::ERROR << "Got IPFIX field (id=" << id << ") with unsupported length " << fieldDataLength << ". Skipping record." << MsgStream::endl; return; } DestIP.setAddress(fieldData[0],fieldData[1],fieldData[2],fieldData[3]); DestIP.remanent_mask(netmask); e_dest.setIpAddress(DestIP); break; // Ports do only matter, if endpoint_key contains "port" // AND (endpoint_key contains "protocol" AND TCP and/or UDP are selected // OR protocols dont matter) case IPFIX_TYPEID_sourceTransportPort: if (fieldDataLength != IPFIX_LENGTH_sourceTransportPort && fieldDataLength != IPFIX_LENGTH_sourceTransportPort-1) { msgStr << MsgStream::ERROR << "Got IPFIX field (id=" << id << ") with unsupported length " << fieldDataLength << ". Skipping record." << MsgStream::endl; return; } e_source.setPortNr((int)fieldToInt(fieldData, fieldDataLength)); break; case IPFIX_TYPEID_destinationTransportPort: if (fieldDataLength != IPFIX_LENGTH_destinationTransportPort && fieldDataLength != IPFIX_LENGTH_destinationTransportPort-1) { std::cerr << "Error! Got invalid IPFIX field data (destination port)! " << "Skipping record.\n"; return; } e_dest.setPortNr((int)fieldToInt(fieldData, fieldDataLength)); break; case IPFIX_TYPEID_packetDeltaCount: if (fieldDataLength != IPFIX_LENGTH_packetDeltaCount) { std::cerr << "Error! Got invalid IPFIX field data (#packets)! " << "Skipping record.\n"; return; } packet_nb = ntohll(*(uint64_t*)fieldData); break; case IPFIX_TYPEID_octetDeltaCount: if (fieldDataLength != IPFIX_LENGTH_octetDeltaCount) { std::cerr << "Error! Got invalid IPFIX field data (#octets)! " << "Skipping record.\n"; return; } byte_nb = ntohll(*(uint64_t*)fieldData); break; default: std::cerr <<"Warning! Got unknown record in StatStore::addFieldData(...)!\n" <<"A programmer has probably added some record type in Stat::init()\n" <<"but has forgotten to ensure its support in StatStore::addFieldData().\n" <<"I'll try to keep working, but I can't tell for sure I won't crash.\n"; } return; }
IpAddress TcpSocket::peerAddress()const { return IpAddress(); }
void UdpServerTransport::cycle( int timeoutMs, const volatile bool &) //stopFlag { // poll the UDP socket for messages, and read a message if one is available fd_set fdSet; FD_ZERO(&fdSet); FD_SET( static_cast<SOCKET>(mFd), &fdSet); timeval timeout; timeout.tv_sec = timeoutMs/1000; timeout.tv_usec = 1000*(timeoutMs%1000); int ret = Platform::OS::BsdSockets::select( mFd+1, &fdSet, NULL, NULL, timeoutMs < 0 ? NULL : &timeout); int err = Platform::OS::BsdSockets::GetLastError(); if (ret == 1) { SessionStatePtr sessionStatePtr = getCurrentUdpSessionStatePtr(); if (sessionStatePtr.get() == NULL) { sessionStatePtr = SessionStatePtr(new SessionState(*this)); SessionPtr sessionPtr = getSessionManager().createSession(); sessionPtr->setSessionState(*sessionStatePtr); sessionStatePtr->mSessionPtr = sessionPtr; setCurrentUdpSessionStatePtr(sessionStatePtr); } { // read a message ReallocBufferPtr &readVecPtr = sessionStatePtr->mReadVecPtr; if (readVecPtr.get() == NULL || !readVecPtr.unique()) { readVecPtr.reset( new ReallocBuffer()); } ReallocBuffer &buffer = *readVecPtr; SockAddrStorage from; int fromlen = sizeof(from); memset(&from, 0, sizeof(from)); buffer.resize(4); int len = Platform::OS::BsdSockets::recvfrom( mFd, &buffer[0], 4, MSG_PEEK, (sockaddr *) &from, &fromlen); err = Platform::OS::BsdSockets::GetLastError(); sessionStatePtr->mRemoteAddress = IpAddress( (sockaddr&) from, fromlen, mIpAddress.getType()); if (!isIpAllowed(sessionStatePtr->mRemoteAddress)) { RCF_LOG_2()(sessionStatePtr->mRemoteAddress.getIp()) << "Client IP does not match server's IP access rules. Closing connection."; discardPacket(mFd); } else if ( len == 4 || (len == -1 && err == Platform::OS::BsdSockets::ERR_EMSGSIZE)) { unsigned int dataLength = 0; memcpy(&dataLength, &buffer[0], 4); networkToMachineOrder(&dataLength, 4, 1); if ( 0 < dataLength && dataLength <= static_cast<unsigned int>(getMaxMessageLength())) { buffer.resize(4+dataLength); memset(&from, 0, sizeof(from)); fromlen = sizeof(from); len = Platform::OS::BsdSockets::recvfrom( mFd, &buffer[0], 4+dataLength, 0, (sockaddr *) &from, &fromlen); if (static_cast<unsigned int>(len) == 4+dataLength) { getSessionManager().onReadCompleted(sessionStatePtr->mSessionPtr); } } else { ByteBuffer byteBuffer; encodeServerError(getSessionManager(), byteBuffer, RcfError_ServerMessageLength); byteBuffer.expandIntoLeftMargin(4); * (boost::uint32_t *) ( byteBuffer.getPtr() ) = static_cast<boost::uint32_t>(byteBuffer.getLength()-4); RCF::machineToNetworkOrder(byteBuffer.getPtr(), 4, 1); char *buffer = byteBuffer.getPtr(); std::size_t bufferLen = byteBuffer.getLength(); sockaddr * pRemoteAddr = NULL; Platform::OS::BsdSockets::socklen_t remoteAddrSize = 0; sessionStatePtr->mRemoteAddress.getSockAddr(pRemoteAddr, remoteAddrSize); int len = sendto( mFd, buffer, static_cast<int>(bufferLen), 0, pRemoteAddr, remoteAddrSize); RCF_UNUSED_VARIABLE(len); discardPacket(mFd); } } else { discardPacket(mFd); } } } else if (ret == 0) { //RCF_LOG_4()(mFd)(mPort)(timeoutMs) << "UdpServerTransport - no messages received within polling interval."; } else if (ret == -1) { Exception e( _RcfError_Socket(), err, RcfSubsystem_Os, "udp server select() failed "); RCF_THROW(e)(mFd)(mIpAddress.string())(err); } }
UdpEndpoint & UdpEndpoint::listenOnMulticast(const std::string & multicastIp) { return listenOnMulticast(IpAddress(multicastIp)); }
void UdpClientTransport::connect( I_ClientTransportCallback &clientStub, unsigned int timeoutMs) { RCF_LOG_4()(mSock)(mDestIp.string()) << "UdpClientTransport - creating socket."; RCF_UNUSED_VARIABLE(timeoutMs); RCF_ASSERT(!mAsync); // TODO: replace throw with return value if (mSock == -1) { int ret = 0; int err = 0; // remote address mDestIp.resolve(); // local address if (mLocalIp.empty()) { std::string localIp = mDestIp.getType() == IpAddress::V4 ? "0.0.0.0" : "::0" ; mSrcIp = IpAddress(localIp, 0); } else { mSrcIp = mLocalIp; } mSrcIp.resolve(); mSock = mSrcIp.createSocket(SOCK_DGRAM, IPPROTO_UDP); sockaddr * pSrcAddr = NULL; Platform::OS::BsdSockets::socklen_t srcAddrSize = 0; mSrcIp.getSockAddr(pSrcAddr, srcAddrSize); ret = ::bind(mSock, pSrcAddr, srcAddrSize); err = Platform::OS::BsdSockets::GetLastError(); RCF_VERIFY( ret == 0, Exception( _RcfError_Socket("bind()"), err, RcfSubsystem_Os)); mAssignedLocalIp = IpAddress(mSock, mSrcIp.getType()); #if defined(BOOST_WINDOWS) && defined(SIO_UDP_CONNRESET) // On Windows XP and later, disable the SIO_UDP_CONNRESET socket option. BOOL enable = FALSE; DWORD dwBytesRet = 0; DWORD dwStatus = WSAIoctl(mSock, SIO_UDP_CONNRESET, &enable, sizeof(enable), NULL, 0, &dwBytesRet, NULL, NULL); err = Platform::OS::BsdSockets::GetLastError(); RCF_VERIFY( dwStatus == 0, Exception( _RcfError_Socket("WSAIoctl() with SIO_UDP_CONNRESET"), err, RcfSubsystem_Os)); #endif // BOOST_WINDOWS if (mDestIp.isBroadcast()) { // set socket option to allow transmission of broadcast messages int enable = 1; int ret = setsockopt(mSock, SOL_SOCKET, SO_BROADCAST, (char *) &enable, sizeof(enable)); int err = Platform::OS::BsdSockets::GetLastError(); RCF_VERIFY( ret == 0, Exception( _RcfError_Socket("setsockopt() with SO_BROADCAST"), err, RcfSubsystem_Os)); } if (mDestIp.isMulticast()) { // char for Solaris, int for everyone else. #if defined(__SVR4) && defined(__sun) char hops = 16; #else int hops = 16; #endif int ret = setsockopt(mSock, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &hops, sizeof (hops)); int err = Platform::OS::BsdSockets::GetLastError(); RCF_VERIFY( ret == 0, Exception( _RcfError_Socket("setsockopt() with IPPROTO_IP/IP_MULTICAST_TTL"), err, RcfSubsystem_Os))(hops); } } clientStub.onConnectCompleted(); }
void TunnelDecapOrch::doTask(Consumer& consumer) { SWSS_LOG_ENTER(); if (!gPortsOrch->isInitDone()) { return; } auto it = consumer.m_toSync.begin(); while (it != consumer.m_toSync.end()) { KeyOpFieldsValuesTuple t = it->second; string key = kfvKey(t); string op = kfvOp(t); IpAddresses ip_addresses; IpAddress src_ip; string tunnel_type; string dscp_mode; string ecn_mode; string ttl_mode; bool valid = true; // checking to see if the tunnel already exists bool exists = (tunnelTable.find(key) != tunnelTable.end()); if (op == SET_COMMAND) { for (auto i : kfvFieldsValues(t)) { if (fvField(i) == "tunnel_type") { tunnel_type = fvValue(i); if (tunnel_type != "IPINIP") { SWSS_LOG_ERROR("Invalid tunnel type %s", tunnel_type.c_str()); valid = false; break; } } else if (fvField(i) == "dst_ip") { try { ip_addresses = IpAddresses(fvValue(i)); } catch (const std::invalid_argument &e) { SWSS_LOG_ERROR("%s", e.what()); valid = false; break; } if (exists) { setIpAttribute(key, ip_addresses, tunnelTable.find(key)->second.tunnel_id); } } else if (fvField(i) == "src_ip") { try { src_ip = IpAddress(fvValue(i)); } catch (const std::invalid_argument &e) { SWSS_LOG_ERROR("%s", e.what()); valid = false; break; } if (exists) { SWSS_LOG_ERROR("cannot modify src ip for existing tunnel"); } } else if (fvField(i) == "dscp_mode") { dscp_mode = fvValue(i); if (dscp_mode != "uniform" && dscp_mode != "pipe") { SWSS_LOG_ERROR("Invalid dscp mode %s\n", dscp_mode.c_str()); valid = false; break; } if (exists) { setTunnelAttribute(fvField(i), dscp_mode, tunnelTable.find(key)->second.tunnel_id); } } else if (fvField(i) == "ecn_mode") { ecn_mode = fvValue(i); if (ecn_mode != "copy_from_outer" && ecn_mode != "standard") { SWSS_LOG_ERROR("Invalid ecn mode %s\n", ecn_mode.c_str()); valid = false; break; } if (exists) { setTunnelAttribute(fvField(i), ecn_mode, tunnelTable.find(key)->second.tunnel_id); } } else if (fvField(i) == "ttl_mode") { ttl_mode = fvValue(i); if (ttl_mode != "uniform" && ttl_mode != "pipe") { SWSS_LOG_ERROR("Invalid ttl mode %s\n", ttl_mode.c_str()); valid = false; break; } if (exists) { setTunnelAttribute(fvField(i), ttl_mode, tunnelTable.find(key)->second.tunnel_id); } } } // create new tunnel if it doesn't exists already if (valid && !exists) { if (addDecapTunnel(key, tunnel_type, ip_addresses, src_ip, dscp_mode, ecn_mode, ttl_mode)) { SWSS_LOG_NOTICE("Tunnel(s) added to ASIC_DB."); } else { SWSS_LOG_ERROR("Failed to add tunnels to ASIC_DB."); } } } if (op == DEL_COMMAND) { if (exists) { removeDecapTunnel(key); } else { SWSS_LOG_ERROR("Tunnel cannot be removed since it doesn't exist."); } } it = consumer.m_toSync.erase(it); } }
int CNotifyEventQueue::AddEntry(Snmp *snmp, const OidCollection &trapids, const TargetCollection &targets) { SnmpSynchronize _synchronize(*this); // instead of REENTRANT() if (snmp != m_snmpSession) { debugprintf(0, "WARNING: Adding notification event for other Snmp object"); } if (!m_msgCount) { m_notify_addr = snmp->get_listen_address(); m_notify_addr.set_port(m_listen_port); int status = SNMP_CLASS_SUCCESS; // This is the first request to receive notifications // Set up the socket for the snmp trap port (162) or the // specified port through set_listen_port() bool is_v4_address = (m_notify_addr.get_ip_version() == Address::version_ipv4); if (is_v4_address) { struct sockaddr_in mgr_addr; // open a socket to be used for the session if ((m_notify_fd = socket(AF_INET, SOCK_DGRAM,0)) < 0) { #ifdef WIN32 int werr = WSAGetLastError(); if (EMFILE == werr ||WSAENOBUFS == werr || ENFILE == werr) status = SNMP_CLASS_RESOURCE_UNAVAIL; else if (WSAEHOSTDOWN == werr) status = SNMP_CLASS_TL_FAILED; else status = SNMP_CLASS_TL_UNSUPPORTED; #else if (EMFILE == errno || ENOBUFS == errno || ENFILE == errno) status = SNMP_CLASS_RESOURCE_UNAVAIL; else if (EHOSTDOWN == errno) status = SNMP_CLASS_TL_FAILED; else status = SNMP_CLASS_TL_UNSUPPORTED; #endif cleanup(); return status; } // set up the manager socket attributes unsigned long inaddr = inet_addr(IpAddress(m_notify_addr).get_printable()); memset(&mgr_addr, 0, sizeof(mgr_addr)); mgr_addr.sin_family = AF_INET; mgr_addr.sin_addr.s_addr = inaddr; // was htonl( INADDR_ANY); mgr_addr.sin_port = htons(m_notify_addr.get_port()); #ifdef CYGPKG_NET_OPENBSD_STACK mgr_addr.sin_len = sizeof(mgr_addr); #endif // bind the socket if (bind(m_notify_fd, (struct sockaddr *) &mgr_addr, sizeof(mgr_addr)) < 0) { #ifdef WIN32 int werr = WSAGetLastError(); if (WSAEADDRINUSE == werr) status = SNMP_CLASS_TL_IN_USE; else if (WSAENOBUFS == werr) status = SNMP_CLASS_RESOURCE_UNAVAIL; else if (werr == WSAEAFNOSUPPORT) status = SNMP_CLASS_TL_UNSUPPORTED; else if (werr == WSAENETUNREACH) status = SNMP_CLASS_TL_FAILED; else if (werr == EACCES) status = SNMP_CLASS_TL_ACCESS_DENIED; else status = SNMP_CLASS_INTERNAL_ERROR; #else if (EADDRINUSE == errno) status = SNMP_CLASS_TL_IN_USE; else if (ENOBUFS == errno) status = SNMP_CLASS_RESOURCE_UNAVAIL; else if (errno == EAFNOSUPPORT) status = SNMP_CLASS_TL_UNSUPPORTED; else if (errno == ENETUNREACH) status = SNMP_CLASS_TL_FAILED; else if (errno == EACCES) status = SNMP_CLASS_TL_ACCESS_DENIED; else { debugprintf(0, "Uncatched errno value %d, returning internal error.", errno); status = SNMP_CLASS_INTERNAL_ERROR; } #endif debugprintf(0, "Fatal: could not bind to %s", m_notify_addr.get_printable()); cleanup(); return status; } debugprintf(3, "Bind to %s for notifications, fd %d.", m_notify_addr.get_printable(), m_notify_fd); } // is_v4_address else { // not is_v4_address #ifdef SNMP_PP_IPv6 // open a socket to be used for the session if ((m_notify_fd = socket(AF_INET6, SOCK_DGRAM,0)) < 0) { #ifdef WIN32 int werr = WSAGetLastError(); if (EMFILE == werr ||WSAENOBUFS == werr || ENFILE == werr) status = SNMP_CLASS_RESOURCE_UNAVAIL; else if (WSAEHOSTDOWN == werr) status = SNMP_CLASS_TL_FAILED; else status = SNMP_CLASS_TL_UNSUPPORTED; #else if (EMFILE == errno || ENOBUFS == errno || ENFILE == errno) status = SNMP_CLASS_RESOURCE_UNAVAIL; else if (EHOSTDOWN == errno) status = SNMP_CLASS_TL_FAILED; else status = SNMP_CLASS_TL_UNSUPPORTED; #endif cleanup(); return status; } #ifdef NOTIFY_SET_IPV6_V6ONLY int on = 1; if (setsockopt(m_notify_fd, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&on, sizeof(on)) == -1) { LOG_BEGIN(loggerModuleName, WARNING_LOG | 1); LOG("Could not set option IPV6_V6ONLY on notify socket (errno)"); LOG(errno); LOG_END; } else { LOG_BEGIN(loggerModuleName, INFO_LOG | 3); LOG("Have set IPV6_V6ONLY option on notify socket"); LOG_END; } #endif // set up the manager socket attributes struct sockaddr_in6 mgr_addr; memset(&mgr_addr, 0, sizeof(mgr_addr)); unsigned int scope = 0; OctetStr addrstr = ((IpAddress &)m_notify_addr).IpAddress::get_printable(); if (m_notify_addr.has_ipv6_scope()) { scope = m_notify_addr.get_scope(); int y = addrstr.len() - 1; while ((y>0) && (addrstr[y] != '%')) { addrstr.set_len(addrstr.len() - 1); y--; } if (addrstr[y] == '%') addrstr.set_len(addrstr.len() - 1); } if (inet_pton(AF_INET6, addrstr.get_printable(), &mgr_addr.sin6_addr) < 0) { LOG_BEGIN(loggerModuleName, ERROR_LOG | 1); LOG("Notify transport: inet_pton returns (errno) (str)"); LOG(errno); LOG(strerror(errno)); LOG_END; cleanup(); return SNMP_CLASS_INVALID_ADDRESS; } mgr_addr.sin6_family = AF_INET6; mgr_addr.sin6_port = htons(m_notify_addr.get_port()); mgr_addr.sin6_scope_id = scope; // bind the socket if (bind(m_notify_fd, (struct sockaddr *) &mgr_addr, sizeof(mgr_addr)) < 0) { #ifdef WIN32 int werr = WSAGetLastError(); if (WSAEADDRINUSE == werr) status = SNMP_CLASS_TL_IN_USE; else if (WSAENOBUFS == werr) status = SNMP_CLASS_RESOURCE_UNAVAIL; else if (werr == WSAEAFNOSUPPORT) status = SNMP_CLASS_TL_UNSUPPORTED; else if (werr == WSAENETUNREACH) status = SNMP_CLASS_TL_FAILED; else if (werr == EACCES) status = SNMP_CLASS_TL_ACCESS_DENIED; else status = SNMP_CLASS_INTERNAL_ERROR; #else if (EADDRINUSE == errno) status = SNMP_CLASS_TL_IN_USE; else if (ENOBUFS == errno) status = SNMP_CLASS_RESOURCE_UNAVAIL; else if (errno == EAFNOSUPPORT) status = SNMP_CLASS_TL_UNSUPPORTED; else if (errno == ENETUNREACH) status = SNMP_CLASS_TL_FAILED; else if (errno == EACCES) status = SNMP_CLASS_TL_ACCESS_DENIED; else { debugprintf(0, "Uncatched errno value %d, returning internal error.", errno); status = SNMP_CLASS_INTERNAL_ERROR; } #endif debugprintf(0, "Fatal: could not bind to %s", m_notify_addr.get_printable()); cleanup(); return status; } debugprintf(3, "Bind to %s for notifications, fd %d.", m_notify_addr.get_printable(), m_notify_fd); #else debugprintf(0, "User error: Enable IPv6 and recompile snmp++."); cleanup(); return SNMP_CLASS_TL_UNSUPPORTED; #endif } // not is_v4_address } CNotifyEvent *newEvent = new CNotifyEvent(snmp, trapids, targets); /*---------------------------------------------------------*/ /* Insert entry at head of list, done automagically by the */ /* constructor function, so don't use the return value. */ /*---------------------------------------------------------*/ (void) new CNotifyEventQueueElt(newEvent, m_head.GetNext(), &m_head); m_msgCount++; return SNMP_CLASS_SUCCESS; }
void initializeTransportFactories() { #if RCF_FEATURE_IPV6==1 const bool compileTimeIpv6 = true; ExceptionPtr ePtr; IpAddress("::1").resolve(ePtr); const bool runTimeIpv6 = (ePtr.get() == NULL); #else const bool compileTimeIpv6 = false; const bool runTimeIpv6 = false; #endif #if RCF_FEATURE_NAMEDPIPE==1 getTransportFactories().push_back( TransportFactoryPtr( new Win32NamedPipeTransportFactory())); #endif #if RCF_FEATURE_TCP==1 getTransportFactories().push_back( TransportFactoryPtr( new TcpAsioTransportFactory(IpAddress::V4))); getIpTransportFactories().push_back( TransportFactoryPtr( new TcpAsioTransportFactory(IpAddress::V4))); if (compileTimeIpv6 && runTimeIpv6) { getTransportFactories().push_back( TransportFactoryPtr( new TcpAsioTransportFactory(IpAddress::V6))); getIpTransportFactories().push_back( TransportFactoryPtr( new TcpAsioTransportFactory(IpAddress::V6))); } #endif #if RCF_FEATURE_LOCALSOCKET==1 getTransportFactories().push_back( TransportFactoryPtr( new UnixLocalTransportFactory())); #endif #if RCF_FEATURE_UDP==1 getTransportFactories().push_back( TransportFactoryPtr( new UdpTransportFactory(IpAddress::V4))); getIpTransportFactories().push_back( TransportFactoryPtr( new UdpTransportFactory(IpAddress::V4))); if (compileTimeIpv6 && runTimeIpv6) { getTransportFactories().push_back( TransportFactoryPtr( new UdpTransportFactory(IpAddress::V6))); getIpTransportFactories().push_back( TransportFactoryPtr( new UdpTransportFactory(IpAddress::V6))); } #endif }
TransportPair UdpTransportFactory::createNonListeningTransports() { return std::make_pair( ServerTransportPtr( new UdpServerTransport( IpAddress(mLoopback, 0) ) ), ClientTransportAutoPtrPtr()); }
TransportPair createNonListeningTransports() { return std::make_pair( ServerTransportPtr( new TcpAsioServerTransport( IpAddress(mLoopback, 0)) ), ClientTransportAutoPtrPtr()); }