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;
}
