ssize_t UDPInetSocket::recvfrom(SockAddr &from, void *buf, size_t count, int flags) throw() { union { sockaddr base; sockaddr_in ipv4; sockaddr_in6 ipv6; } u; socklen_t addrLen = sizeof(u); ssize_t read = ::recvfrom(sock, buf, count, flags, &u.base, &addrLen); if (read != -1) { switch (u.base.sa_family) { case AF_INET: from.setAddr(u.ipv4); break; case AF_INET6: from.setAddr(u.ipv6); break; default: read = -1; errno = ENOMSG; break; } } return read; }
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; }
ssize_t UDPInetSocket::recvfrom(SockAddr &from, iovec *iov, size_t num, int flags) throw() { union { sockaddr base; sockaddr_in ipv4; sockaddr_in6 ipv6; } u; struct msghdr msg = { &u.base, sizeof(u), // dest address iov, num, NULL, 0, // control buffer 0, // return flags (for recvmsg only) }; ssize_t read = ::recvmsg(sock, &msg, flags); if (read != -1) { switch (u.base.sa_family) { case AF_INET: from.setAddr(u.ipv4); break; case AF_INET6: from.setAddr(u.ipv6); break; default: read = -1; errno = ENOMSG; break; } } return read; }
bool SockAddr::operator<(const SockAddr& r) const { if (getType() < r.getType()) return true; else if (getType() > r.getType()) return false; if (getPort() < r.getPort()) return true; else if (getPort() > r.getPort()) return false; switch (getType()) { case AF_INET: return as<sockaddr_in>().sin_addr.s_addr < r.as<sockaddr_in>().sin_addr.s_addr; case AF_INET6: return memcmp(as<sockaddr_in6>().sin6_addr.s6_addr, r.as<sockaddr_in6>().sin6_addr.s6_addr, sizeof(in6_addr)) < 0; case AF_UNIX: return strcmp(as<sockaddr_un>().sun_path, r.as<sockaddr_un>().sun_path) < 0; case AF_UNSPEC: return false; default: massert(SOCK_FAMILY_UNKNOWN_ERROR, "unsupported address family", false); } return false; }
void ExternalIPCounter::CountIP( const SockAddr& addr, int weight ) { // ignore anyone who claims our external IP is // INADDR_ANY or on a local network if(addr.is_addr_any() || is_ip_local(addr)) return; // timestamp the first time we get a vote if(! _HeatStarted) _HeatStarted = time(NULL); // attempt to insert this vote std::pair<candidate_map::iterator, bool> inserted = _map.insert(std::make_pair(addr, weight)); // if the new IP wasn't inserted, it's already in there // increase the vote counter if (!inserted.second) inserted.first->second += weight; // if the IP vout count exceeds the current leader, replace it if(addr.isv4() && (_winnerV4 == _map.end() || inserted.first->second > _winnerV4->second)) _winnerV4 = inserted.first; if(addr.isv6() && (_winnerV6 == _map.end() || inserted.first->second > _winnerV6->second)) _winnerV6 = inserted.first; _TotalVotes += weight; Rotate(); }
SockAddr random_address() { SockAddr ret; memset(ret._in._in6, 0, 16); for (int i = 12; i < 16; ++i) { ret._in._in6[i] = rand() & 0xff; } ret.set_port((rand() % 1000) + 1024); return ret; }
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; }
IpPort getIpPortFromSockAddr(const SockAddr &sa){ const int family = sa.getFamily(); if(family == AF_INET){ if(sa.getSize() < sizeof(::sockaddr_in)){ LOG_POSEIDON_WARNING("Invalid IPv4 SockAddr: size = ", sa.getSize()); DEBUG_THROW(Exception, sslit("Invalid IPv4 SockAddr")); } char ip[INET_ADDRSTRLEN]; const char *const str = ::inet_ntop(AF_INET, &static_cast<const ::sockaddr_in *>(sa.getData())->sin_addr, ip, sizeof(ip)); if(!str){ DEBUG_THROW(SystemException); } return IpPort(SharedNts(str), loadBe(static_cast<const ::sockaddr_in *>(sa.getData())->sin_port)); } else if(family == AF_INET6){ if(sa.getSize() < sizeof(::sockaddr_in6)){ LOG_POSEIDON_WARNING("Invalid IPv6 SockAddr: size = ", sa.getSize()); DEBUG_THROW(Exception, sslit("Invalid IPv6 SockAddr")); } char ip[INET6_ADDRSTRLEN]; const char *const str = ::inet_ntop(AF_INET6, &static_cast<const ::sockaddr_in6 *>(sa.getData())->sin6_addr, ip, sizeof(ip)); if(!str){ DEBUG_THROW(SystemException); } return IpPort(SharedNts(str), loadBe(static_cast<const ::sockaddr_in6 *>(sa.getData())->sin6_port)); } LOG_POSEIDON_WARNING("Unknown IP protocol ", family); DEBUG_THROW(Exception, sslit("Unknown IP protocol")); }
bool UdpEndPoint::open(const SockAddr& sockaddr, int backlog, auto_ptr<base::net::HandlerCreatorStrategyBase> handler_stg, auto_ptr<base::net::FilterCreatorStrategyBase> sp_filter_stg, ErrorCode* ec) { int fd = ::socket(sockaddr.getType(), SOCK_DGRAM, 0); if (-1 == fd) RETURN_NET_ERROR_WITH(ec, errno, "addr=" << sockaddr, false); ScopedFD spfd(fd); if (sockaddr.getType() == AF_UNIX) { const sockaddr_un& un = sockaddr.as<sockaddr_un>(); unlink(un.sun_path); // in case it already exists } SocketHelper::setNonBlocking(fd, ec); SocketHelper::setReusable(fd, ec); if (-1 == ::bind(fd, sockaddr.raw(), sockaddr.size())) RETURN_NET_ERROR_WITH(ec, errno, "addr=" << sockaddr, false); boost::shared_ptr<Handler> newhandler; if (0 == sockaddr.getPort()) { struct sockaddr_in addr; socklen_t len = sizeof(addr); if (-1 == getsockname(fd, (struct sockaddr *)&addr, &len)) RETURN_NET_ERROR_WITH(ec, errno, "", false); SockAddr setaddr(ntohs(addr.sin_port)); handler_stg->create(fd, setaddr, sp_reactor_impl_, newhandler); } else handler_stg->create(fd, sockaddr, sp_reactor_impl_, newhandler); if (!newhandler) RETURN_NET_ERROR_WITH(ec, errno, "create handler failed" << sockaddr, false); newhandler->setConnected(); if (sp_filter_stg.get()) newhandler->setFilter(auto_ptr<Filter>(sp_filter_stg->create(false, newhandler.get()))); HandlerScoper<Handler> handler_scoper(newhandler); spfd.release(); if (!sp_reactor_impl_->registerHandler(newhandler, MASK_READ, ec)) return false; handler_scoper.release(); setUdpHandler(newhandler); return true; }
//----------------------------------------------------------------------- // //----------------------------------------------------------------------- size_t SocketOStream::sendto (const void* buf, const size_t size, const SockAddr& dstAddr) throw (IOException) { ssize_t result; result = ::sendto (m_fd, buf, size, 0, &(dstAddr.getSockaddr()), dstAddr.getSockaddrLen()); if (result == -1) throw IOException (errno); return result; }
void TcpServer::onConnection(int connfd, const SockAddr& peerAddr) { EventLoop* ioLoop = loopThreadPool_.getNextLoop(); if (!ioLoop) ioLoop = loop_; TcpConnectionPtr conn(new TcpConnection(ioLoop, connfd, peerAddr, ++connectionId_)); conn->setCloseCallback(simex::bind(&TcpServer::onClose, this, _1)); conn->setMessageCallback(messageCallback_); LOG_TRACE("new client|ip=%s|port=%u", peerAddr.ip().c_str(), peerAddr.port()); connectionManager_->Add(conn->id(), conn); conn->run(); if (connectionCallback_) connectionCallback_(conn); }
bool Socket::connect(SockAddr& remote) { _remote = remote; _fd = socket(remote.getType(), SOCK_STREAM, 0); if ( _fd == INVALID_SOCKET ) { LOG(_logLevel) << "ERROR: connect invalid socket " << errnoWithDescription() << endl; return false; } if ( _timeout > 0 ) { setTimeout( _timeout ); } static const unsigned int connectTimeoutMillis = 5000; ConnectBG bg(_fd, remote); bg.go(); if ( bg.wait(connectTimeoutMillis) ) { if ( bg.inError() ) { warning() << "Failed to connect to " << _remote.getAddr() << ":" << _remote.getPort() << ", reason: " << bg.getErrnoWithDescription() << endl; close(); return false; } } else { // time out the connect close(); bg.wait(); // so bg stays in scope until bg thread terminates warning() << "Failed to connect to " << _remote.getAddr() << ":" << _remote.getPort() << " after " << connectTimeoutMillis << " milliseconds, giving up." << endl; return false; } if (remote.getType() != AF_UNIX) disableNagle(_fd); #ifdef SO_NOSIGPIPE // ignore SIGPIPE signals on osx, to avoid process exit const int one = 1; setsockopt( _fd , SOL_SOCKET, SO_NOSIGPIPE, &one, sizeof(int)); #endif _local = getLocalAddrForBoundSocketFd(_fd); _fdCreationMicroSec = curTimeMicros64(); _awaitingHandshake = false; return true; }
bool NetChannelBase::FlushStream() { bool bError = false; while (m_StreamOut.GetSize() > 0) { int32 nLen = (int32)m_StreamOut.GetSize(); int32 nRet = m_socket.Send((char*)m_StreamOut.GetBufferStart(), nLen); if( nRet < 0 ) { int32 nError = Socket::GetSysError(); if( nError == MY_EWOULDBLOCK || nError == MY_EAGAIN ) break; else if( nError == MY_ECONNRESET ) nRet = 0; else { SockAddr addr; m_socket.GetSockAddr(addr); MyLog::error("[%s:%u] IO Error [%d] when sending data !", addr.GetIP().c_str(), addr.GetPort(), GetID(), nError); DisConnect(); nError = true; break; } } if( nRet == 0 ) { SockAddr addr; m_socket.GetPeerAddr(addr); MyLog::error("NetChannelBase::flushStream() [%s:%u][%u] connection is closed!", addr.GetIP().c_str(), addr.GetPort(), GetID()); DisConnect(); bError = true; break; } m_pMgr->BytesSend().Add(nRet); m_StreamOut.Remove(nRet); m_nTotalSendByte += nRet; if( nRet < nLen ) break; } return !bError; }
bool Acceptor::open(const SockAddr& sockaddr, int backlog, auto_ptr<HandlerCreatorStrategyBase> handler_creator_stg, auto_ptr<FilterCreatorStrategyBase> filter_stg, ErrorCode* ec) { if (!handler_creator_stg.get()) RETURN_ERROR_WITH(ec, E_NET_CREATE_NEW_HANDLER_FAILED, "addr=" << sockaddr, false); int fd = ::socket(sockaddr.getType(), SOCK_STREAM, 0); if (-1 == fd) RETURN_NET_ERROR_WITH(ec, errno, "addr=" << sockaddr, false); ScopedFD spfd(fd); if (sockaddr.getType() == AF_UNIX) { const sockaddr_un& un = sockaddr.as<sockaddr_un>(); unlink(un.sun_path); // in case it already exists } SocketHelper::setNonBlocking(fd, ec); SocketHelper::setReusable(fd, ec); if (flag_ & OPT_KEEPALIVE) SocketHelper::setKeepAlive(fd, ec); if (flag_ & OPT_NODELAY) SocketHelper::disableNagle(fd, ec); if (-1 == ::bind(fd, sockaddr.raw(), sockaddr.size())) RETURN_NET_ERROR_WITH(ec, errno, "addr=" << sockaddr, false); if (-1 == ::listen(fd, backlog)) RETURN_NET_ERROR_WITH(ec, errno, "addr=" << sockaddr, false); boost::shared_ptr<Handler> newhandler; newhandler.reset(new AcceptorHandler(fd, sockaddr, sp_reactor_impl_, handler_creator_stg, filter_stg)); HandlerScoper<Handler> handler_scoper(newhandler); spfd.release(); if (!sp_reactor_impl_->registerHandler(newhandler, MASK_ACCEPT, ec)) return false; LOG(info, "listen on "<< sockaddr); handler_scoper.release(); setAcceptorHandler(newhandler); return true; }
bool SockAddr::operator==(const SockAddr& r) const { if (getType() != r.getType()) return false; if (getPort() != r.getPort()) return false; switch (getType()) { case AF_INET: return as<sockaddr_in>().sin_addr.s_addr == r.as<sockaddr_in>().sin_addr.s_addr; case AF_INET6: return memcmp(as<sockaddr_in6>().sin6_addr.s6_addr, r.as<sockaddr_in6>().sin6_addr.s6_addr, sizeof(in6_addr)) == 0; case AF_UNIX: return strcmp(as<sockaddr_un>().sun_path, r.as<sockaddr_un>().sun_path) == 0; case AF_UNSPEC: return true; // assume all unspecified addresses are the same default: massert(SOCK_FAMILY_UNKNOWN_ERROR, "unsupported address family", false); } }
SocketError SocketImpl::bind(const SockAddr& sockAddr) { if (socket == INVALID_SOCKET) { return SocketError::NotInitialized; } sockaddr_storage storage; sockAddr.toNative(&storage); // For bind we also want to set the SO_EXCLUSIVEADDRUSE option DWORD opt = 1; int optRes = ::setsockopt(socket, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (const char*)&opt, sizeof(DWORD)); if (optRes != 0) { return getSocketError(::WSAGetLastError()); } int bindRes = ::bind(socket, (const sockaddr*)&storage, sizeof(sockaddr_storage)); if (bindRes != 0) { return getSocketError(::WSAGetLastError()); } // And then we need to fetch back the bound addr/port int nameLen = sizeof(sockaddr_storage); int nameRes = ::getsockname(socket, (sockaddr*)&storage, &nameLen); if (nameRes != 0) { return getSocketError(::WSAGetLastError()); } localAddr = SockAddr::fromNative(&storage); return SocketError::Ok; }
//------------------------------------------------------------------------------ utf8::String SockAddr::gethostname(bool noThrow,const utf8::String & def) { SockAddr addr; int32_t err = 0; utf8::String s; APIAutoInitializer ksockAPIAutoInitializer; #if defined(__WIN32__) || defined(__WIN64__) ksys::Array<IpInfo> addresses; getAdaptersAddresses(addresses); if( ksys::isWinXPorLater() || iphlpapi.GetAdaptersAddresses != NULL ){ IP_ADAPTER_ADDRESSES * pAddress = &addresses[0].addresses_; while( pAddress != NULL ){ // exclude loopback interface if( pAddress->IfType == MIB_IF_TYPE_LOOPBACK ) continue; if( pAddress->PhysicalAddressLength == 0 ) continue; PIP_ADAPTER_UNICAST_ADDRESS unicast = pAddress->FirstUnicastAddress; while( unicast != NULL ){ #ifdef IP_ADAPTER_ADDRESS_PRIMARY if( unicast->Flags & (IP_ADAPTER_ADDRESS_DNS_ELIGIBLE | IP_ADAPTER_ADDRESS_PRIMARY) ){ #else if( unicast->Flags & IP_ADAPTER_ADDRESS_DNS_ELIGIBLE ){ #endif addr.clear(); //ksys::reverseByteArray( memcpy( &addr.addr4_, unicast->Address.lpSockaddr, unicast->Address.iSockaddrLength ); //addr.addr4_.sin_family = unicast->Address.lpSockaddr->sa_family; try { err = 0; s = addr.resolveAddr(); } catch( ksys::ExceptionSP & e ){ err = e->code() >= ksys::errorOffset ? e->code() - ksys::errorOffset : e->code(); } if( err == 0 ) break; } unicast = unicast->Next; } if( err == 0 ) break; pAddress = pAddress->Next; } } else {
bool Connector::open(const SockAddr& sockaddr, boost::shared_ptr<Handler>* spout, ErrorCode* ec) { if (!sp_creator_stg_.get()) RETURN_ERROR_WITH(ec, E_NET_CREATE_NEW_HANDLER_FAILED, "addr=" << sockaddr, false); int fd = ::socket(sockaddr.getType(), SOCK_STREAM, 0); if (-1 == fd) RETURN_NET_ERROR_WITH(ec, errno, "addr=" << sockaddr, false); ScopedFD spfd(fd); SocketHelper::setNonBlocking(fd, ec); SocketHelper::setReusable(fd, ec); if (flag_ & OPT_KEEPALIVE) SocketHelper::setKeepAlive(fd, ec); if (flag_ & OPT_NODELAY) SocketHelper::disableNagle(fd, ec); LOG(info, "connect to " << sockaddr); if (-1 == ::connect(fd, sockaddr.raw(), sockaddr.size())) { if (EINTR != errno && EINPROGRESS != errno) RETURN_NET_ERROR_WITH(ec, errno, "addr=" << sockaddr, false); } boost::shared_ptr<Handler> spnewhandler; sp_creator_stg_->create(fd, sockaddr, sp_reactor_impl_, spnewhandler); if (!spnewhandler) RETURN_ERROR_WITH(ec, E_NET_CREATE_NEW_HANDLER_FAILED, "addr=" << sockaddr, false); HandlerScoper<Handler> handler_scoper(spnewhandler); spfd.release(); if (sp_filter_stg_.get()) spnewhandler->setFilter(auto_ptr<Filter>(sp_filter_stg_->create(true, spnewhandler.get()))); if (!sp_reactor_impl_->registerHandler(spnewhandler, MASK_CONNECT|MASK_READ|MASK_WRITE, ec)) RETURN_IF_ERROR_WITH(ec, false); handler_scoper.release(); if (spout) *spout = spnewhandler; return true; }
void Listener::listen() { SockAddr from; while ( 1 ) { int s = accept(sock, (sockaddr *) &from.sa, &from.addressSize); if ( s < 0 ) { if ( errno == ECONNABORTED || errno == EBADF ) { log() << "Listener on port " << port << " aborted" << endl; return; } log() << "Listener: accept() returns " << s << " errno:" << errno << ", strerror: " << strerror( errno ) << endl; continue; } disableNagle(s); log() << "connection accepted from " << from.toString() << endl; accepted( new MessagingPort(s, from) ); } }
int InetSocket::maxIPPayload(void) const throw() { SockAddr addr; if (getSockAddr(addr)) { switch (addr.family()) { case InetAddr::Invalid: default: break; case InetAddr::IPv4: return (mtu() - 20); case InetAddr::IPv6: return (mtu() - 40); } } return 0; }
bool allowed( const char * rq , vector<string>& headers, const SockAddr &from ){ if ( from.localhost() ) return true; if ( db.findOne( "admin.system.users" , BSONObj() ).isEmpty() ) return true; string auth = getHeader( rq , "Authorization" ); if ( auth.size() > 0 && auth.find( "Digest " ) == 0 ){ auth = auth.substr( 7 ) + ", "; map<string,string> parms; pcrecpp::StringPiece input( auth ); string name, val; pcrecpp::RE re("(\\w+)=\"?(.*?)\"?, "); while ( re.Consume( &input, &name, &val) ){ parms[name] = val; } BSONObj user = db.findOne( "admin.system.users" , BSON( "user" << parms["username"] ) ); if ( ! user.isEmpty() ){ string ha1 = user["pwd"].str(); string ha2 = md5simpledigest( (string)"GET" + ":" + parms["uri"] ); string r = ha1 + ":" + parms["nonce"]; if ( parms["nc"].size() && parms["cnonce"].size() && parms["qop"].size() ){ r += ":"; r += parms["nc"]; r += ":"; r += parms["cnonce"]; r += ":"; r += parms["qop"]; } r += ":"; r += ha2; r = md5simpledigest( r ); if ( r == parms["response"] ) return true; } } stringstream authHeader; authHeader << "WWW-Authenticate: " << "Digest realm=\"mongo\", " << "nonce=\"abc\", " << "algorithm=MD5, qop=\"auth\" " ; headers.push_back( authHeader.str() ); return 0; }
int SockConnector::connect ( SockStream& stream, const SockAddr& sockAddr, int reuseAddr, int protocolFamily, int protocol ) { TRACE_CALL; if (stream.handleInvalid ()) { // open on a new socket descriptor if (stream.open (SOCK_STREAM, protocolFamily, protocol, reuseAddr) < 0) return -1; // cannot open } sockaddr* remoteAddr = 0; if (sockAddr.clone (remoteAddr) != -1) { size_t size = sockAddr.size (); REACTOR_HANDLE handle = stream.handleGet (); if (::connect (handle, remoteAddr, size) < 0) stream.close (); #if 0 if (::bind (handle, remoteAddr, size) < 0) stream.close (); else if (::connect (handle, remoteAddr, size) < 0) stream.close (); #endif } delete remoteAddr; return stream.handleInvalid () ? -1 : 0; }
void Listener::listen() { static long connNumber = 0; SockAddr from; while ( ! inShutdown() ) { int s = accept(sock, (sockaddr *) &from.sa, &from.addressSize); if ( s < 0 ) { if ( errno == ECONNABORTED || errno == EBADF ) { log() << "Listener on port " << port << " aborted" << endl; return; } log() << "Listener: accept() returns " << s << " " << OUTPUT_ERRNO << endl; continue; } disableNagle(s); if ( ! cmdLine.quiet ) log() << "connection accepted from " << from.toString() << " #" << ++connNumber << endl; accepted( new MessagingPort(s, from) ); } }
Status doSaslStep(const ClientBasic* client, SaslAuthenticationSession* session, const BSONObj& cmdObj, BSONObjBuilder* result) { std::string payload; BSONType type = EOO; Status status = saslExtractPayload(cmdObj, &payload, &type); if (!status.isOK()) return status; std::string responsePayload; // Passing in a payload and extracting a responsePayload status = session->step(payload, &responsePayload); if (!status.isOK()) { const SockAddr clientAddr = client->port()->localAddr(); log() << session->getMechanism() << " authentication failed for " << session->getPrincipalId() << " on " << session->getAuthenticationDatabase() << " from client " << clientAddr.getAddr() << " ; " << status.toString() << std::endl; // All the client needs to know is that authentication has failed. return Status(ErrorCodes::AuthenticationFailed, "Authentication failed."); } status = buildResponse(session, responsePayload, type, result); if (!status.isOK()) return status; if (session->isDone()) { UserName userName(session->getPrincipalId(), session->getAuthenticationDatabase()); status = session->getAuthorizationSession()->addAndAuthorizeUser( session->getOpCtxt(), userName); if (!status.isOK()) { return status; } if (!serverGlobalParams.quiet) { log() << "Successfully authenticated as principal " << session->getPrincipalId() << " on " << session->getAuthenticationDatabase(); } } return Status::OK(); }
void ExternalIPCounter::CountIP( const SockAddr& addr, const SockAddr& voter, int weight ) { // Don't let local peers vote on our IP address if (is_ip_local(voter)) return; // Accept an empty voter address. if ( ! voter.is_addr_any() ) { // TODO: we should support IPv6 voters as well // If voter is in bloom filter, return uint32 vaddr = voter.get_addr4(); sha1_hash key = _sha_callback((const byte*)&vaddr, 4); if (_voterFilter.test(key)) return; _voterFilter.add(key); } CountIP(addr, weight); }
void MiniWebServer::run() { SockAddr from; while ( 1 ) { int s = accept(sock, from.getSockAddr(), &from.addressSize); if ( s < 0 ) { if ( errno == ECONNABORTED ) { log() << "Listener on port " << port << " aborted." << endl; return; } log() << "MiniWebServer: accept() returns " << s << " errno:" << errno << endl; sleepmillis(200); continue; } disableNagle(s); RARELY log() << "MiniWebServer: connection accepted from " << from.toString() << endl; accepted( s, from ); closesocket(s); } }
RpcStringBinding::RpcStringBinding ( const SockAddr& addr, PROTSEQ protocolSeq ) : m_ipAddress (0), m_portNumber (-1), m_protocolSeq (protocolSeq), m_strFormat (0), m_strFormatNoPortNumber (0) { char buf [MAXHOSTNAMELEN +1]; if (addr.hostAddrGet (buf, MAXHOSTNAMELEN) == 0) { m_ipAddress = copyString (buf); m_portNumber = addr.portGet (); } }
bool Socket::connect(SockAddr& remote) { _remote = remote; _fd = socket(remote.getType(), SOCK_STREAM, 0); if ( _fd == INVALID_SOCKET ) { LOG(_logLevel) << "ERROR: connect invalid socket " << errnoWithDescription() << endl; return false; } if ( _timeout > 0 ) { setTimeout( _timeout ); } ConnectBG bg(_fd, remote); bg.go(); if ( bg.wait(5000) ) { if ( bg.inError() ) { close(); return false; } } else { // time out the connect close(); bg.wait(); // so bg stays in scope until bg thread terminates return false; } if (remote.getType() != AF_UNIX) disableNagle(_fd); #ifdef SO_NOSIGPIPE // ignore SIGPIPE signals on osx, to avoid process exit const int one = 1; setsockopt( _fd , SOL_SOCKET, SO_NOSIGPIPE, &one, sizeof(int)); #endif _local = getLocalAddrForBoundSocketFd(_fd); _fdCreationMicroSec = curTimeMicros64(); return true; }
bool InetSocket::getSockAddr(SockAddr &sockAddr) const throw() { union { sockaddr base; sockaddr_in ipv4; sockaddr_in6 ipv6; } u; socklen_t addrLen = sizeof(u); if (::getsockname(sock, &u.base, &addrLen) == 0) { switch (u.base.sa_family) { case AF_INET: sockAddr.setAddr(u.ipv4); return true; case AF_INET6: sockAddr.setAddr(u.ipv6); return true; } } return false; }
bool UdpConnector::open(const SockAddr& sockaddr, boost::shared_ptr<Handler>* spout, ErrorCode* ec) { if (!sp_creator_stg_.get()) RETURN_ERROR_WITH(ec, E_NET_CREATE_NEW_HANDLER_FAILED, "addr=" << sockaddr, false); struct sockaddr_in address; bzero(&address,sizeof(address)); address.sin_family=AF_INET; address.sin_addr.s_addr=inet_addr(sockaddr.getAddr().data()); unsigned short port = sockaddr.getPort(); address.sin_port=htons(port); int fd = ::socket(sockaddr.getType(), SOCK_DGRAM, 0); if (-1 == fd) RETURN_NET_ERROR_WITH(ec, errno, "addr=" << sockaddr, false); ScopedFD spfd(fd); SocketHelper::setNonBlocking(fd, ec); SocketHelper::setReusable(fd, ec); boost::shared_ptr<Handler> spnewhandler; sp_creator_stg_->create(fd, sockaddr, sp_reactor_impl_, spnewhandler); if (!spnewhandler) RETURN_ERROR_WITH(ec, E_NET_CREATE_NEW_HANDLER_FAILED, "addr=" << sockaddr, false); HandlerScoper<Handler> handler_scoper(spnewhandler); spfd.release(); if (sp_filter_stg_.get()) spnewhandler->setFilter(auto_ptr<Filter>(sp_filter_stg_->create(true, spnewhandler.get()))); if (!sp_reactor_impl_->registerHandler(spnewhandler, MASK_CONNECT|MASK_READ|MASK_WRITE, ec)) RETURN_IF_ERROR_WITH(ec, false); handler_scoper.release(); if (spout) *spout = spnewhandler; return true; }