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