C++ Endpoint::port方法代码示例

            void resolve_no_block(
                implementation_type & impl, 
                NetName const & name, 
                error_code & ec)
            {
                Endpoint svc;
                svc_cache_.find(name, svc, ec);
                if (ec) {
                    impl->ec = ec;
                    impl->state = ResolveTask::finished;
                    return;
                }
                // 可能service只有一种
                impl->name = name;
                impl->name.protocol((NetName::ProtocolEnum)svc.protocol());
                impl->endpoints.clear();
                impl->ec.clear();
                bool found = host_cache_.find(impl->name, impl->endpoints);
                if (found) {
                    for (size_t i = 0; i < impl->endpoints.size(); ++i) {
                        impl->endpoints[i].port(svc.port());
                    }
                } else {
                    ec = boost::asio::error::would_block;
                }
#ifndef FRAMEWORK_NETWORK_WITH_SERVICE_CACHE
                impl->name.svc(format(svc.port()));
#endif
                impl->state = ResolveTask::waiting;
                tasks_.push_back(impl);
                if (tasks_.size() == 1 && tasks2_.empty()) {
                    sync_data_->cond.notify_one();
                }
            }

bool operator<(const Endpoint& a, const Endpoint& b)
{
    int ret = memcmp(a._ipv6, b._ipv6, sizeof(a._ipv6));
    if (ret < 0)
        return true;
    else if (ret == 0)
    {
        if (ntohl(a.address().to_v4().to_ulong()) < ntohl(b.address().to_v4().to_ulong()))
            return true;
        else if (a.address() == b.address())
            return ntohs(a.port()) < ntohs(b.port());
    }
    return false;
}

void SaslConnection::close()
{
    Endpoint client = peer();
    Connection::close();

    if ( !u || logged ||
         !client.valid() || client.protocol() == Endpoint::Unix )
        return;

    logged = true;

    Query * q = new Query(
        "insert into connections "
        "(username,address,port,mechanism,authfailures,"
        "syntaxerrors,started_at,ended_at,userid) "
        "values ($1,$2,$3,$4,$5,$6,"
        "$7::interval + 'epoch'::timestamptz,"
        "$8::interval + 'epoch'::timestamptz,$9)", 0
    );

    q->bind( 1, u->login() );
    q->bind( 2, client.address() );
    q->bind( 3, client.port() );
    q->bind( 4, m );
    q->bind( 5, af );
    q->bind( 6, sf );
    q->bind( 7, s );
    q->bind( 8, (uint)time( 0 ) );
    q->bind( 9, u->id() );
    q->execute();

}

int Connection::listen( const Endpoint &e, bool silent )
{
    if ( !e.valid() )
        return -1;

    if ( !valid() ) {
        init( socket( e.protocol() ) );
        if ( !valid() )
            return -1;
    }

    int i = 1;
    ::setsockopt( d->fd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof (int) );

    if ( e.protocol() == Endpoint::Unix )
        unlink( File::chrooted( e.address() ).cstr() );

    int retcode = ::bind( d->fd, e.sockaddr(), e.sockaddrSize() );
    if ( retcode < 0 ) {
        if ( errno == EADDRINUSE ) {
            if ( !silent )
                log( "Cannot listen to " +
                     e.address() + " port " + fn( e.port() ) +
                     " because another process is occupying it", Log::Error );
            return -1;
        }
        if ( !silent )
            log( "bind( " + fn( d->fd ) + ", " +
                 e.address() + " port " + fn( e.port() ) +
                 " ) returned errno " + fn( errno ), Log::Debug );
        return -1;
    }
    if ( ::listen( d->fd, 64 ) < 0 ) {
        if ( !silent )
            log( "listen( " + fn( d->fd ) + ", 64 ) for address " +
                 e.address() + " port " + fn( e.port() ) +
                 " ) returned errno " + fn( errno ), Log::Debug );
        return -1;
    }

    setState( Listening );
    d->self = e;
    return 1;
}

//------------------------------------------------------------------------------
//!
RCP<ConnectedSocketDevice>
Socket::connect( const Endpoint& ep )
{
#if BASE_SOCKET_USE_BSD || BASE_SOCKET_USE_WINSOCK
   state( STATE_CONNECTING );

   addrinfo* candidates = getAddrInfo( *this, ep.hostname().cstr(), ep.port() );
   if( candidates == NULL )
   {
      return NULL;
   }

   Family   family   = fromAPI_family  ( candidates->ai_family   );
   Type     type     = fromAPI_type    ( candidates->ai_socktype );
   Protocol protocol = fromAPI_protocol( candidates->ai_protocol );

   RCP<Socket>  socket = new Socket( family, type, protocol );

   int err = ::connect( socket->_impl->_sock, candidates->ai_addr, SocketSSizeT(candidates->ai_addrlen) );
   if( err != 0 )
   {
      printAPIError( "ERROR - Socket::connect() - connect failed" );
      freeaddrinfo( candidates );
      return NULL;
   }

   RCP<ConnectedSocketDevice>  device = new ConnectedSocketDevice( socket.ptr() );
   device->_remoteEndpoint = ep;

   freeaddrinfo( candidates );

   state( STATE_CONNECTED );

   return device;
#else
   return NULL;
#endif
}

bool DelegateService::deliver(const Endpoint& src, const Endpoint& dst, MemoryReference data) const {
    // Check from most to least specific

    PortMap const* pm = getPortMap(dst.spaceObject());
    if (pm != NULL) {
        PortMap::const_iterator it = pm->find(dst.port());

        if (it != pm->end())
        {
            DelegatePort* port = it->second;
            bool delivered = port->deliver(src, dst, data);
            if (delivered)
                return true;
        }
    }

    // And finally, the default handler
    if (mDefaultHandler != 0) {
        mDefaultHandler(src, dst, data);
        return true;
    }

    return false;
}

		void write_endpoint(Endpoint const& e, OutIt& out)
		{
			write_address(e.address(), out);
			write_uint16(e.port(), out);
		}

bool operator==(const Endpoint& a, const Endpoint& b)
{
    return (memcmp(a._ipv6, b._ipv6, sizeof(a._ipv6)) == 0 &&
            a.address()   == b.address() &&
            a.port() == b.port());
}

ostream& operator<<(ostream& os, const Peer& p) {
    /// when NTP implemented, change to just nTime = GetAdjustedTime()
    int64_t nTime = (p._inbound ? GetAdjustedTime() : UnixTime::s());
    //    Endpoint remote = _socket.remote_endpoint();
    Endpoint local = p._socket.local_endpoint();
    Endpoint addrYou = (p._proxy ? Endpoint("0.0.0.0") : p.addr);
    Endpoint addrMe = (p._proxy ? Endpoint("0.0.0.0") : local);
    // hack to avoid serializing the time
    if (p._version)
        os << const_binary<int>(p._version);
    else // not initialized - we assume we are sending the version info
        os << const_binary<int>(p._chain.protocol_version());
    os << const_binary<uint64_t>(NODE_NETWORK) << const_binary<int64_t>(nTime);
    os << const_binary<uint64_t>(addrYou.getServices()) << const_binary<boost::asio::ip::address_v6::bytes_type>(addrYou.getIPv6()) << const_binary<unsigned short>(htons(addrYou.port()));
    os << const_binary<uint64_t>(addrMe.getServices()) << const_binary<boost::asio::ip::address_v6::bytes_type>(addrMe.getIPv6()) << const_binary<unsigned short>(htons(addrMe.port()));
    os << const_binary<uint64_t>(p._nonce) << const_varstr(p._sub_version);
    os << const_binary<int>(p._peerManager.getBestHeight());
    os << const_binary<bool>(true);
    return os;
}