sock.h

// @file sock.h
 
/*    Copyright 2009 10gen Inc.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
 
#pragma once
 
#include "mongo/config.h"
 
#include <stdio.h>
 
#ifndef _WIN32
 
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include <errno.h>
 
#ifdef __openbsd__
# include <sys/uio.h>
#endif
 
#endif // not _WIN32
 
#include <boost/scoped_ptr.hpp>
#include <string>
#include <utility>
#include <vector>
 
#include "mongo/base/disallow_copying.h"
#include "mongo/logger/log_severity.h"
#include "mongo/platform/compiler.h"
#include "mongo/platform/cstdint.h"
#include "mongo/util/assert_util.h"
 
namespace mongo {
 
#ifdef MONGO_SSL
    class SSLManagerInterface;
    class SSLConnection;
#endif
 
    extern const int portSendFlags;
    extern const int portRecvFlags;
 
    const int SOCK_FAMILY_UNKNOWN_ERROR=13078;
 
    void disableNagle(int sock);
 
    void shutdownNetworking();
 
#if defined(_WIN32)
 
    typedef short sa_family_t;
    typedef int socklen_t;
 
    // This won't actually be used on windows
    struct sockaddr_un {
        short sun_family;
        char sun_path[108]; // length from unix header
    };
 
#else // _WIN32
 
    inline void closesocket(int s) { close(s); }
    const int INVALID_SOCKET = -1;
    typedef int SOCKET;
 
#endif // _WIN32
 
    // If an ip address is passed in, just return that.  If a hostname is passed
    // in, look up its ip and return that.  Returns "" on failure.
    std::string hostbyname(const char *hostname);
 
    void enableIPv6(bool state=true);
    bool IPv6Enabled();
    void setSockTimeouts(int sock, double secs);
 
    struct MONGO_CLIENT_API SockAddr {
        SockAddr();
        explicit SockAddr(int sourcePort); /* listener side */
        SockAddr(const char *ip, int port); /* EndPoint (remote) side, or if you want to specify which interface locally */
 
        template <typename T> T& as() { return *(T*)(&sa); }
        template <typename T> const T& as() const { return *(const T*)(&sa); }
        
        std::string toString(bool includePort=true) const;
 
        bool isValid() const { return _isValid; }
 
        sa_family_t getType() const;
 
        unsigned getPort() const;
 
        std::string getAddr() const;
 
        bool isLocalHost() const;
 
        bool operator==(const SockAddr& r) const;
 
        bool operator!=(const SockAddr& r) const;
 
        bool operator<(const SockAddr& r) const;
 
        const sockaddr* raw() const {return (sockaddr*)&sa;}
        sockaddr* raw() {return (sockaddr*)&sa;}
 
        socklen_t addressSize;
    private:
        struct sockaddr_storage sa;
        bool _isValid;
    };
 
    extern SockAddr unknownAddress; // ( "0.0.0.0", 0 )
 
    std::string getHostName();
 
    class MONGO_CLIENT_API SocketException : public DBException {
    public:
        const enum Type { CLOSED , RECV_ERROR , SEND_ERROR, RECV_TIMEOUT, SEND_TIMEOUT, FAILED_STATE, CONNECT_ERROR } _type;
        
        SocketException( Type t , const std::string& server , int code = 9001 , const std::string& extra="" ) 
            : DBException( std::string("socket exception [")  + _getStringType( t ) + "] for " + server, code ),
              _type(t),
              _server(server),
              _extra(extra)
        {}
 
        virtual ~SocketException() throw() {}
 
        bool shouldPrint() const { return _type != CLOSED; }
        virtual std::string toString() const;
        virtual const std::string* server() const { return &_server; }
    private:
 
        // TODO: Allow exceptions better control over their messages
        static std::string _getStringType( Type t ){
            switch (t) {
                case CLOSED:        return "CLOSED";
                case RECV_ERROR:    return "RECV_ERROR";
                case SEND_ERROR:    return "SEND_ERROR";
                case RECV_TIMEOUT:  return "RECV_TIMEOUT";
                case SEND_TIMEOUT:  return "SEND_TIMEOUT";
                case FAILED_STATE:  return "FAILED_STATE";
                case CONNECT_ERROR: return "CONNECT_ERROR";
                default:            return "UNKNOWN"; // should never happen
            }
        }
 
        std::string _server;
        std::string _extra;
    };
 
 
    class MONGO_CLIENT_API Socket {
        MONGO_DISALLOW_COPYING(Socket);
    public:
 
        static const int errorPollIntervalSecs;
 
        Socket(int sock, const SockAddr& farEnd);
 
        Socket(double so_timeout = 0, logger::LogSeverity logLevel = logger::LogSeverity::Log() );
 
        ~Socket();
 
        bool connect(SockAddr& farEnd);
 
        void close();
        void send( const char * data , int len, const char *context );
        void send( const std::vector< std::pair< char *, int > > &data, const char *context );
 
        // recv len or throw SocketException
        void recv( char * data , int len );
        int unsafe_recv( char *buf, int max );
        
        logger::LogSeverity getLogLevel() const { return _logLevel; }
        void setLogLevel( logger::LogSeverity ll ) { _logLevel = ll; }
 
        SockAddr remoteAddr() const { return _remote; }
        std::string remoteString() const { return _remote.toString(); }
        unsigned remotePort() const { return _remote.getPort(); }
 
        SockAddr localAddr() const { return _local; }
 
        void clearCounters() { _bytesIn = 0; _bytesOut = 0; }
        long long getBytesIn() const { return _bytesIn; }
        long long getBytesOut() const { return _bytesOut; }
        int rawFD() const { return _fd; }
 
        void setTimeout( double secs );
        bool isStillConnected();
 
        void setHandshakeReceived() {
            _awaitingHandshake = false;
        }
 
        bool isAwaitingHandshake() {
            return _awaitingHandshake;
        }
 
#ifdef MONGO_SSL
        bool secure( SSLManagerInterface* ssl, const std::string& remoteHost);
 
        void secureAccepted( SSLManagerInterface* ssl );
#endif
        
        std::string doSSLHandshake(const char* firstBytes = NULL, int len = 0);
        
        uint64_t getSockCreationMicroSec() const {
            return _fdCreationMicroSec;
        }
 
        void handleRecvError(int ret, int len);
        MONGO_COMPILER_NORETURN void handleSendError(int ret, const char* context);
 
    private:
        void _init();
 
        void _send( const std::vector< std::pair< char *, int > > &data, const char *context );
 
        int _send( const char * data , int len , const char * context );
 
        int _recv( char * buf , int max );
 
        int _fd;
        uint64_t _fdCreationMicroSec;
        SockAddr _local;
        SockAddr _remote;
        double _timeout;
 
        long long _bytesIn;
        long long _bytesOut;
        time_t _lastValidityCheckAtSecs;
 
#ifdef MONGO_SSL
        boost::scoped_ptr<SSLConnection> _sslConnection;
        SSLManagerInterface* _sslManager;
#endif
        logger::LogSeverity _logLevel; // passed to log() when logging errors
 
        bool _awaitingHandshake;
 
    };
 
 
} // namespace mongo