//don't use this one //for server to use internally only! //-------------------------- bool ofxTCPClient::setup(int _index, bool blocking){ index = _index; //this fetches the port that the server //sets up the connection on //different to the server's listening port InetAddr addr; if( TCPClient.GetRemoteAddr(&addr) ){ port = addr.GetPort(); ipAddr = addr.DottedDecimal(); } TCPClient.SetNonBlocking(!blocking); connected = true; return true; }
void InetAddr::set (const InetAddr &sa) { if (sa.get_type () == -1) // Ugh, this is really a base class, so don't copy it. ::memset (&this->inet_addr_, 0, sizeof (this->inet_addr_)); else { // It's ok to make the copy. ::memcpy (&this->inet_addr_, &sa.inet_addr_, sa.get_size ()); this->set_type (sa.get_type()); this->set_size (sa.get_size()); } }
int SocketConnector::connect(SocketStream &stream, InetAddr const &addr, size_t) { Handle ret = ::connect(_handle, addr, addr.getSize()); if (ret == INVALID_HANDLE) return -1; stream.setHandle(_handle); return 0; }
int Socket::accept(InetAddr &addr) { struct sockaddr_in saddr; int connfd = acceptConn(fd_ , saddr); addr.setPureAddr(saddr); return connfd; }
bool NodeInfo::isReachable (const char **ppszInterfaces, NICInfo **ppNICInfos) { InetAddrWrapper *pIfaceWr = _ipAddresses.getFirst(); if (pIfaceWr == NULL || ppNICInfos == NULL) { return false; } do { for (int i = 0; ppNICInfos[i]; i++) { InetAddr addr (pIfaceWr->ifaceAddr.c_str()); if (NetUtils::areInSameNetwork (ppNICInfos[i]->ip.s_addr, ppNICInfos[i]->netmask.s_addr, addr.getIPAddress(), ppNICInfos[i]->netmask.s_addr)) { return true; } } } while ((pIfaceWr = _ipAddresses.getNext()) != NULL); return false; }
ssize_t SocketDgram::recv (void *buf, size_t n, InetAddr &addr, int flags) const { sockaddr* saddr = (sockaddr*)addr.getAddr(); int addrlen = addr.getSize(); ssize_t const status = OS::recvfrom(this->getHandle(), (char*)buf, n, flags, (sockaddr*)saddr, &addrlen); addr.setSize(addrlen); addr.setType(saddr->sa_family); return status; }
int Socket::connect(InetAddr& addr) { assert(INVALID_SOCKET != fd_); int rst = ::connect(fd_, (struct sockaddr*)&addr.getNetAddr(), sizeof(sockaddr_in)); if(-1 == rst) cout << "err: " << string(strerror(errno)) <<endl; return rst; }
void OSConfigurator_linux24::addVirtualAddressForNAT(const Network *nw) { FWOptions* options=fw->getOptionsObject(); if (options->getBool("manage_virtual_addr")) { if (virtual_addresses.empty() || find(virtual_addresses.begin(),virtual_addresses.end(), *(nw->getAddressPtr())) == virtual_addresses.end()) { Interface *iface = findInterfaceFor( nw, fw ); if (iface!=nullptr) { const InetAddr *addr = nw->getAddressPtr(); InetAddr first, last; InetAddr a; first = *addr; last = *(nw->getBroadcastAddressPtr()); QStringList addresses; for (a=first; a<last; a=a+1) { addresses.push_back(QString("%1/32").arg(a.toString().c_str())); } if (virtual_addresses_for_nat.count(iface->getName()) > 0) addresses.push_front(virtual_addresses_for_nat[iface->getName()].c_str()); virtual_addresses_for_nat[iface->getName()] = addresses.join(" ").toStdString(); virtual_addresses.push_back( *(nw->getAddressPtr()) ); registerVirtualAddressForNat(); } else warning("Can not add virtual address " + nw->getAddressPtr()->toString() + " (object " + nw->getName() + ")" ); } } }
void TcpServer::onNewConnectionCallback(int fd, const InetAddr& addr) { char buf[32]; bzero((void*)buf, 32); std::string name = snprintf(buf, 32, "%s:%d",addr.getIpPortStr(),connectId_); logger::console->info("NewConnection:{}",name); ++connectId_; InetAddr localAddr(serverAddr_); TcpConnection* tcpConnection= new TcpConnection(name, eventloop_, fd, serverAddr_, addr); connectionMap_[name] = tcpConnection; tcpConnection->setCloseCallback(boost::bind(&TcpServer::removeConnection, this,_1)); tcpConnection->setMessageCallback(messageCallback_); tcpConnection->setWriteCompleteCallback(writeCompleteCallback_); }
int StompConnection::connect(StompClient* client, const InetAddr& addr, const std::string& login, const std::string& passcode, const std::string& heartbeat) { fd_ = Socket::create(); if (fd_ < 0) { log_error("failed to create fd"); return -1; } int ret = Socket::connect(fd_, addr); if (ret == 0) { state_ = ConnectionState::ESTABLISHED; evloop_->add_event(this, EV_READ); } else if (ret == EINPROGRESS) { state_ = ConnectionState::CONNECTING; evloop_->add_event(this, EV_READ|EV_WRITE); } else { log_error("fd: " << fd_ << " failed to connect addr: " << addr.to_string()); return -1; } client_ = client; return 0; }
MulticastJoinSpec::MulticastJoinSpec(const InetAddr &mcast, const InetInterface &inter) throw() : fam(mcast.family()) { if (fam != inter.family()) { fam = InetAddr::Invalid; } else { switch (fam) { case InetAddr::Invalid: default: // fam is already invalid - just leave it that way break; case InetAddr::IPv4: ipv4.imr_multiaddr = mcast; ipv4.imr_interface = inter.getIPv4Interface(); break; case InetAddr::IPv6: ipv6.ipv6mr_multiaddr = mcast; ipv6.ipv6mr_interface = inter.getIPv6Interface(); break; } } }
int ProxyDatagramSocket::sendTo (uint32 ui32IPAddr, uint16 ui16Port, const void *pBuf, int iBufSize, const char *pszHints) { int rc; if (_bConnectedToServer) { if (iBufSize < 0) { checkAndLogMsg ("ProxyDatagramSocket::sendTo", Logger::L_MildError, "packet size cannot be negative\n"); return -1; } if (iBufSize > (MAXIMUM_PROXY_PACKET_SIZE - 17)) { checkAndLogMsg ("ProxyDatagramSocket::sendTo", Logger::L_MildError, "packet too large to be sent - maximum size is <%d>\n", (int) (MAXIMUM_PROXY_PACKET_SIZE - 17)); return -2; } try { bool bExcludeAddr = false; bool bIncludeAddr = false; InetAddr excludeAddr; InetAddr includeAddr; if (pszHints != NULL) { // Check to see if we can handle the hints StringTokenizer st (pszHints, ';'); const char *pszHint = NULL; while ((pszHint = st.getNextToken()) != NULL) { StringTokenizer st2 (pszHint, '='); const char *pszAttr = st2.getNextToken(); const char *pszValue = st2.getNextToken(); if ((pszAttr == NULL) || (pszValue == NULL)) { checkAndLogMsg ("ProxyDatagramSocket::sendTo", Logger::L_Warning, "could not parse hint <%s> - ignoring\n", pszHint); } // Check to see if an exclude address has been specified in the hints else if (0 == stricmp (pszAttr, "exclude")) { if (InetAddr::isIPv4Addr (pszValue)) { excludeAddr.setIPAddress (pszValue); bExcludeAddr = true; } else { checkAndLogMsg ("ProxyDatagramSocket::sendTo", Logger::L_Warning, "could not parse exclude address <%s> - ignoring\n", pszValue); } } // Check to see if an include address has been specified in the hints else if (0 == stricmp (pszAttr, "include")) { if (InetAddr::isIPv4Addr (pszValue)) { includeAddr.setIPAddress (pszValue); bIncludeAddr = true; } else { checkAndLogMsg ("ProxyDatagramSocket::sendTo", Logger::L_Warning, "could not parse include address <%s> - ignoring\n", pszValue); } } // Check to see if we are doing a forced unicast else if (0 == stricmp (pszAttr, "unicast")) { if (InetAddr::isIPv4Addr (pszValue)) { InetAddr unicastAddr (pszValue); ui32IPAddr = unicastAddr.getIPAddress(); checkAndLogMsg ("ProxyDatagramSocket::sendTo", Logger::L_Info, "overwrote destination address with unicast address %s\n", unicastAddr.getIPAsString()); } } else { checkAndLogMsg ("ProxyDatagramSocket::sendTo", Logger::L_Warning, "unknown hint attribute <%s> - ignoring\n", pszAttr); } } } /*!!*/ // Improve the efficiency of this by implementing a two-argument sendBlock() method // so that a memcpy is not needed uint8 aui8Buf [MAXIMUM_PROXY_PACKET_SIZE]; uint8 ui8Offset = 0; if (bIncludeAddr) { aui8Buf[ui8Offset] = 'I'; } else if (bExcludeAddr) { aui8Buf[ui8Offset] = 'X'; } else { aui8Buf[ui8Offset] = 'D'; } ui8Offset += 1; (*((uint32*)(aui8Buf+ui8Offset))) = _ui32LocalAddr; ui8Offset += 4; (*((uint16*)(aui8Buf+ui8Offset))) = EndianHelper::htons (_ui16LocalPort); ui8Offset += 2; (*((uint32*)(aui8Buf+ui8Offset))) = ui32IPAddr; ui8Offset += 4; if (bIncludeAddr) { (*((uint32*)(aui8Buf+ui8Offset))) = includeAddr.getIPAddress(); ui8Offset += 4; } else if (bExcludeAddr) { (*((uint32*)(aui8Buf+ui8Offset))) = excludeAddr.getIPAddress(); ui8Offset += 4; } (*((uint16*)(aui8Buf+ui8Offset))) = EndianHelper::htons (ui16Port); ui8Offset += 2; memcpy (aui8Buf+ui8Offset, pBuf, iBufSize); _pchToServer->sendBlock (aui8Buf, iBufSize + ui8Offset); _ui32SentPacketCount++; return iBufSize; } catch (Exception e) { checkAndLogMsg ("ProxyDatagramSocket::sendTo", Logger::L_MildError, "exception occurred when sending data to proxy server; message = <%s>\n", e.getMsg()); close(); rc = -3; } } else { checkAndLogMsg ("ProxyDatagramSocket::sendTo", Logger::L_MildError, "cannot send - not connected to the proxy server\n"); rc = -4; } connectToProxyServer(); return rc; }
int bindport(ACE_HANDLE handle, ACE_UINT32 ip_addr, int address_family) { InetAddr addr = InetAddr((u_short)0, ip_addr); return OS::bind(handle, (sockaddr*)addr.getAddr(), addr.getSize()); }
bool NodeInfo::setIPAddress (uint32 ui32IpAddress) { InetAddr addr (ui32IpAddress); return setIPAddress (addr.getIPAsString()); }
string PolicyCompiler_iosacl::PrintRule::_printAddr(Address *o) { PolicyCompiler_iosacl *iosacl_comp = dynamic_cast<PolicyCompiler_iosacl*>(compiler); if (Interface::cast(o)!=NULL) { Interface *interface_ = Interface::cast(o); if (interface_->isDyn()) { return string("interface ") + interface_->getLabel() + " "; } } ostringstream str; const InetAddr *srcaddr = o->getAddressPtr(); if (srcaddr) { const InetAddr *nm = o->getNetmaskPtr(); InetAddr srcmask; if (nm != NULL) { srcmask = *nm; } else { cerr << "Address object " << o << " " << o->getName() << " (" << o->getTypeName() << ") " << " has no netmask" << endl; srcmask = InetAddr(InetAddr::getAllOnes(srcaddr->addressFamily())); } // const InetAddr srcmask = *(o->getNetmaskPtr()); if (srcaddr->isAny() && srcmask.isAny()) { str << "any "; } else { if (Interface::cast(o)==NULL && Interface::cast(o->getParent())==NULL && o->dimension() > 1 && !srcmask.isHostMask()) { if (iosacl_comp->ipv6) { str << srcaddr->toString() << "/" << srcmask.getLength() << " "; } else { str << srcaddr->toString() << " "; // cisco uses "wildcards" instead of netmasks //long nm = srcmask.to32BitInt(); //struct in_addr na; //na.s_addr = ~nm; InetAddr nnm( ~srcmask ); str << nnm.toString() << " "; } } else { str << "host " << srcaddr->toString() << " "; } } return str.str(); } ostringstream errstr; errstr << "Object " << o->getName() << " (id=" << o->getId() << ") " << " has no ip address and can not be used " << "in the rule."; compiler->abort(errstr.str()); return ""; // to make compiler happy }
void Socket::bind(const InetAddr &addr) { bindOn(fd_ , addr.getPeerAddr()); }
void NATCompiler_pf::PrintRule::_printAddr(FWObject *o) { MultiAddressRunTime *atrt = MultiAddressRunTime::cast(o); if (atrt!=NULL) { if (atrt->getSubstitutionTypeName()==DNSName::TYPENAME) { compiler->output << atrt->getSourceName() << " "; return; } if (atrt->getSubstitutionTypeName()==AddressTable::TYPENAME) { compiler->output << "<" << o->getName() << "> "; return; } if (atrt->getSubstitutionTypeName()==AttachedNetworks::TYPENAME) { compiler->output << atrt->getSourceName() << ":network "; return ; } assert(atrt==NULL); } if (Interface::cast(o)!=NULL) { compiler->output << "(" << o->getName() << ") "; return; } if (o->getBool("pf_table")) { compiler->output << "<" << o->getName() << "> "; return; } Address *addr_obj = Address::cast(o); assert(addr_obj!=NULL); const InetAddr *addr = addr_obj->getAddressPtr(); if (addr) { InetAddr mask = *(addr_obj->getNetmaskPtr()); if (Interface::cast(o)!=NULL || Address::cast(o)->dimension()==1) { mask = InetAddr(InetAddr::getAllOnes()); } if (addr->isAny() && mask.isAny()) { compiler->output << "any "; } else { compiler->output << addr->toString(); if (!mask.isHostMask()) { compiler->output << "/" << mask.getLength(); } compiler->output << " "; } } }
string TableFactory::PrintTables() { if (tables.size() == 0) return ""; stringstream output; output << endl; output << "# Tables: (" << tables.size() << ")" << endl; for (map<string,string>::const_iterator i=tblnames.begin(); i!=tblnames.end(); i++) { string tblID = i->second; FWObject *grp = tables[tblID]; output << "table "; output << "<" << grp->getName() << "> "; MultiAddressRunTime *atrt = MultiAddressRunTime::cast(grp); if (atrt!=nullptr && atrt->getSubstitutionTypeName()==AddressTable::TYPENAME) { output << "persist"; if ( !atrt->getSourceName().empty() ) { string path = atrt->getSourceNameAsPath(firewall->getOptionsObject()); if (path.empty()) { compiler->abort("Error: Firewall's data directory not set for address table: " + atrt->getName()); } output << " file \"" << path << "\""; } output << endl; continue; } output << "{ "; for (FWObject::iterator i=grp->begin(); i!=grp->end(); i++) { if (i!=grp->begin()) output << ", "; FWObject *o = FWReference::getObject(*i); if (o==nullptr) compiler->abort("broken table object "); MultiAddressRunTime *atrt = MultiAddressRunTime::cast(o); if (atrt!=nullptr) { if (atrt->getSubstitutionTypeName()==DNSName::TYPENAME) { output << atrt->getSourceName() << " "; } if (atrt->getSubstitutionTypeName()==AttachedNetworks::TYPENAME) { output << atrt->getSourceName() << ":network "; } } else { if (Interface::cast(o)) { output << o->getName(); } else { Address *A=Address::cast( o ); if (A==nullptr) compiler->abort("table object must be an address: '" + o->getTypeName()+"'"); const InetAddr *addr = A->getAddressPtr(); InetAddr mask = *(A->getNetmaskPtr()); if (A->dimension()==1) { mask = InetAddr(InetAddr::getAllOnes()); } output << addr->toString(); if (!mask.isHostMask()) { output << "/" << mask.getLength(); } } } output << " "; } output << "} "; output << endl; } output << endl; return output.str(); }
int PublisherHandler::handleInput(ACE_HANDLE fd) { if (msg == 0) { msg = new Msg; } int result = MsgProtocol::parse(&stream, msg); if (result == -1) { ICC_ERROR("PublisherHandler::handleInput error: %s", OS::strerror(OS::map_errno(OS::last_error()))); delete msg; msg = 0; return -1; } else if (result == 1) { return 0; } assert(result == 0); if (msg->messageType == Msg_KeepAlive_Probe) { OutputStream os; MsgProtocol::start(Msg_KeepAlive_ACK, &os); std::string t("keepAlive"); os.write_string(t); InetAddr peerAddr; this->getStream().getRemoteAddr(peerAddr); // ICC_DEBUG("recved publisher keep alive probe, sending ack, peer: %s", peerAddr.toString().c_str()); int result = MsgProtocol::send(&this->getStream(), &os); if (result == 0) { // ICC_DEBUG("send keep alive probe ack succeeded, peer: %s", peerAddr.toString().c_str()); } delete msg; msg = 0; return result; } else if(msg->messageType == Msg_Publish) { OutputStream os; MsgProtocol::start(Msg_Publish_OK, &os); os.write_string("publishOK"); os.write_int(SubscriberHandler::keepAliveTryTimes); os.write_int(SubscriberHandler::keepAliveTimeSpan); os.write_boolean(SubscriberHandler::enableBuffering); InetAddr peerAddr; this->getStream().getRemoteAddr(peerAddr); ICC_DEBUG("sending Msg_Publish_OK, peer: %s", peerAddr.toString().c_str()); result = MsgProtocol::send(&this->getStream(), &os); delete msg; msg = 0; return result; } assert(msg->messageType == Msg_Event); assert(msg->topic != ""); // print log , temporary variable "type" is for info, string type; InputStream is(msg->is); is.read_string(type); ICC_DEBUG("recved publish event, topic: %s, type: %s", msg->topic.c_str(), type.c_str()); if(SubscriberHandler::enableBuffering) { TopicManager::instance()->addMessage_(msg); } else { TopicManager::instance()->addMessage(msg, SubscriberHandler::enableBuffering); } msg = 0; return result; }
void Connector::run (void) { int rc; started(); _pPDS->_bConnectedToServer = false; Socket *pSocketToServer = new TCPSocket(); if (0 != (rc = ((TCPSocket*)pSocketToServer)->connect (_pPDS->_proxyServerAddr.getIPAsString(), _pPDS->_proxyServerAddr.getPort()))) { checkAndLogMsg ("[ProxyDatagramSocket]Connector::run", Logger::L_Warning, "failed to connect to proxy server at %s:%d\n", _pPDS->_proxyServerAddr.getIPAsString(), (int) _pPDS->_proxyServerAddr.getPort()); delete pSocketToServer; setTerminatingResultCode (-1); terminating(); return; } checkAndLogMsg ("[ProxyDatagramSocket]Connector::run", Logger::L_Info, "connected to proxy server; LP:%d-RP:%d\n", pSocketToServer->getLocalPort(), pSocketToServer->getRemotePort()); pSocketToServer->bufferingMode (0); CommHelper2 *pchToServer = new CommHelper2(); if (0 != (rc = pchToServer->init (pSocketToServer))) { checkAndLogMsg ("[ProxyDatagramSocket]Connector::run", Logger::L_MildError, "failed to initialize CommHelper; rc = %d\n", rc); delete pchToServer; delete pSocketToServer; setTerminatingResultCode (-2); terminating(); return; } InetAddr localAddr; uint16 ui16AssignedPort; uint16 ui16MTU; try { uint8 aui8Buf [ProxyDatagramSocket::MAXIMUM_PROXY_PACKET_SIZE]; // Receive the Welcome message uint32 ui32PacketSize = pchToServer->receiveBlock (aui8Buf, ProxyDatagramSocket::MAXIMUM_PROXY_PACKET_SIZE); if ((ui32PacketSize < 1) || (aui8Buf[0] != 'w')) { throw ProtocolException ("expecting but did not receive a welcome message from server"); } checkAndLogMsg ("[ProxyDatagramSocket]Connector::run", Logger::L_MediumDetailDebug, "connected to proxy server at %s:%d\n", _pPDS->_proxyServerAddr.getIPAsString(), (int) _pPDS->_proxyServerAddr.getPort()); if (ui32PacketSize > 2) { aui8Buf[ui32PacketSize] = '\0'; // Just for safety checkAndLogMsg ("[ProxyDatagramSocket]Connector::run", Logger::L_MediumDetailDebug, "proxy server identification string is <%s>\n", (char*) aui8Buf+2); } // Receive the Address message ui32PacketSize = pchToServer->receiveBlock (aui8Buf, ProxyDatagramSocket::MAXIMUM_PROXY_PACKET_SIZE); if ((ui32PacketSize < 6) || (aui8Buf[0] != 'a')) { throw ProtocolException ("expecting but did not receive an address message from server"); } if (aui8Buf[1] != 0) { if (aui8Buf[1] == 4) { // Received a 4-byte address - store it as the local address localAddr = InetAddr (*((uint32*)(aui8Buf+2))); checkAndLogMsg ("[ProxyDatagramSocket]Connector::run", Logger::L_LowDetailDebug, "set local address to %s (%x)\n", localAddr.getIPAsString(), localAddr.getIPAddress()); } else { checkAndLogMsg ("[ProxyDatagramSocket]Connector::run", Logger::L_Warning, "received a local address of length %d - ignoring since it is not a 4 byte address\n", (int) aui8Buf[1]); } } // Receive the MTU message ui32PacketSize = pchToServer->receiveBlock (aui8Buf, ProxyDatagramSocket::MAXIMUM_PROXY_PACKET_SIZE); if ((ui32PacketSize < 3) || (aui8Buf[0] != 'm')) { throw ProtocolException ("expecting but did not receive an MTU message from server"); } ui16MTU = EndianHelper::ntohs (*((uint16*)(aui8Buf+1))); checkAndLogMsg ("[ProxyDatagramSocket]Connector::run", Logger::L_LowDetailDebug, "set MTU to %d\n", (int) ui16MTU); // Send the bind message checkAndLogMsg ("[ProxyDatagramSocket]Connector::run", Logger::L_LowDetailDebug, "sending a bind message; local port = %d\n", _pPDS->_ui16LocalPort); aui8Buf[0] = 'B'; (*((uint16*)(aui8Buf+1))) = EndianHelper::htons (_pPDS->_ui16LocalPort); pchToServer->sendBlock (aui8Buf, 3); // Receive the reply ui32PacketSize = pchToServer->receiveBlock (aui8Buf, ProxyDatagramSocket::MAXIMUM_PROXY_PACKET_SIZE); if ((ui32PacketSize < 3) || (aui8Buf[0] != 'b')) { throw ProtocolException ("expecting but did not receive a bind reply message from server"); } ui16AssignedPort = EndianHelper::ntohs (*((uint16*)(aui8Buf+1))); if (ui16AssignedPort == 0) { throw ProtocolException ("server failed to assign a port"); } _pPDS->_ui16LocalPort = ui16AssignedPort; checkAndLogMsg ("[ProxyDatagramSocket]Connector::run", Logger::L_MediumDetailDebug, "bound socket to local port <%d>\n", (int) _pPDS->_ui16LocalPort); } catch (Exception e) { checkAndLogMsg ("[ProxyDatagramSocket]Connector::run", Logger::L_MildError, "exception when establishing connection to proxy server; message = <%s>\n", e.getMsg()); delete pchToServer; delete pSocketToServer; this->setTerminatingResultCode (-3); terminating(); return; } _pPDS->_pchToServer = pchToServer; _pPDS->_pSocketToServer = pSocketToServer; _pPDS->_ui16MTU = ui16MTU; _pPDS->_ui32LocalAddr = localAddr.getIPAddress(); _pPDS->_ui16LocalPort = ui16AssignedPort; _pPDS->_bConnectedToServer = true; setTerminatingResultCode (0); terminating(); return; }
int udpServer (void) { int rc; uint32 ui32SeqNum; uint16 ui16ClientPort = 0; int lastSequenceNumber = -1; int numPacketsRecvd = 0; int numPacketsLost = 0; uint64 ui64FirstPacketTS = 0; uint64 ui64LastPacketTS = 0; uint64 ui64TotalBytesReceived = 0; int outOfOrderPackets = 0; while (true) { InetAddr clientAddr; // ui64LastPacketTS will be used when client port changes to calculate // how long it took to receive a chunk of data ui64LastPacketTS = getTimeInMilliseconds(); if ((rc = dgSocket.receive (buf, sizeof (buf), &clientAddr)) <= 0) { fprintf (stderr, "failed to receive from datagram socket; rc = %d\n", rc); continue; } ui32SeqNum = *( (uint32*)buf ); //printf ("udpServer:: received a packet with seq. number = %d and size %d from remote port %d\n", ui32SeqNum, rc, clientAddr.getPort()); if (ui16ClientPort != clientAddr.getPort()) { if ( (ui16ClientPort != 0) && (lastSequenceNumber >= 0) ) { // The statistics can be printed only when the second cycle starts //printf ("UDP done timestamp %llu\n", ui64LastPacketTS); sprintf (logbuf, "UDP::\t\tLoss = %d%\tOutOfOrder = %d\tThroughput = %5.2f bytes/sec\n", (numPacketsLost * 100)/(lastSequenceNumber + 1), outOfOrderPackets, (float) ui64TotalBytesReceived / (ui64LastPacketTS - ui64FirstPacketTS), ui64TotalBytesReceived ); printf ("%s", logbuf); fprintf (pLogFile, "%s", logbuf); } lastSequenceNumber = ui32SeqNum; numPacketsRecvd = 0; numPacketsLost = 0; outOfOrderPackets = 0; ui64FirstPacketTS = getTimeInMilliseconds(); //printf ("UDP ui64FirstPacketTS %llu\n", ui64FirstPacketTS); ui64TotalBytesReceived = 0; ui16ClientPort = clientAddr.getPort(); } numPacketsRecvd++; ui64TotalBytesReceived += rc; if (ui32SeqNum < lastSequenceNumber) { outOfOrderPackets++; } else if (ui32SeqNum != (lastSequenceNumber + 1)) { numPacketsLost += ui32SeqNum - lastSequenceNumber; } lastSequenceNumber = ui32SeqNum; } return 0; }
int SockConnector::connect(SockStream &stream, InetAddr &addr, TimeValue &tv) { int rv = 0; // non-block socket stream.set_nonblocking(); #ifdef _WIN32 // connect rv = ::connect(stream.get_handle(), (const struct sockaddr *) addr.get_addr(), (socklen_t)addr.get_addr_size()); if (rv != -1) { rv = 0; } else { if (WSAGetLastError() == WSAEWOULDBLOCK) { //printf("connect InProgress [%d]\n", sock); fd_set rset; fd_set wset; FD_ZERO(&rset); FD_ZERO(&wset); FD_SET(stream.get_handle(), &rset); FD_SET(stream.get_handle(), &wset); rv = ::select(0, &rset, &wset, NULL, (struct timeval*)tv.timeval()); if (rv == 0) { perror("connect timeout"); rv = -1; } else if (FD_ISSET(stream.get_handle(), &rset) || FD_ISSET(stream.get_handle(), &wset)) { int error = 0; socklen_t len = sizeof(error); if (getsockopt(stream.get_handle(), SOL_SOCKET, SO_ERROR, (char *)&error, &len) == 0) { // select error if (error == 0) { rv = 0; } else { closesocket(stream.get_handle()); perror("connect"); rv = -1; } } } else { perror("connect"); rv = -1; } } else { perror("connect"); rv = -1; } } #endif // restore file status flags stream.set_blocking(); return rv; }