socket.h

// Copyright (c) 2018 IIS (The Internet Foundation in Sweden)
// Written by Göran Andersson <initgoran@gmail.com>
 
#pragma once
 
#ifdef _WIN32
#include <winsock2.h>
#endif
 
#include "pollstate.h"
#include "logger.h"
 
class Task;
 
class Socket : public Logger {
    friend class Engine;
public:
    Socket(const std::string &label, Task *owner,
           const std::string &hostname, uint16_t port);
 
    Socket(const std::string &label, Task *owner, int fd);
 
    Task *owner() const {
        return _owner;
    }
 
    std::string hostname() const {
        return _hostname;
    }
 
    uint16_t port() const {
        return _port;
    }
 
    PollState state() const {
        return _state;
    }
 
#ifndef _WIN32
    int getUnixDomainPeer() const {
        return unix_domain_peer;
    }
#endif
 
    virtual ~Socket();
 
    virtual std::string cacheLabel() {
        return _hostname + std::to_string(_port);
    }
 
    int id() const {
        return _socket;
    }
 
    virtual void setOwner(Task *t) {
        _owner = t;
    }
 
    void setExpiry(double s) {
        expiry = timeAfter(s);
    }
 
    bool hasExpired(const TimePoint &when) const {
        return (expiry < when);
    }
 
    const char *localIp() const {
        const char *ip = getIp(socket(), nullptr, false);
        return ip;
    }
 
    static const char *getIp(int fd, uint16_t *port = nullptr,
                             bool peer = true);
 
    static const char *getIp(struct sockaddr *address, uint16_t *port=nullptr);
 
    static const char *getIp(struct addrinfo *address, uint16_t *port=nullptr);
 
    struct addrinfo *getAddressInfo(uint16_t iptype = 0);
protected:
    static bool isTempError() {
#ifdef _WIN32
        if (WSAGetLastError() == WSAEWOULDBLOCK ||
            WSAGetLastError() == WSAEINPROGRESS ||
            WSAGetLastError() == WSAENOTCONN ||
            !WSAGetLastError())
#else
        if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINPROGRESS
            || errno == EINTR || !errno)
#endif
            return true;
        else
            return false;
    }
 
    virtual bool wantToSend() {
        return false;
    }
 
    virtual PollState checkReadBlock() {
        return PollState::READ_BLOCKED;
    }
 
    void setWantToSend() {
        if (_state != PollState::CLOSE)
            _state = PollState::READ_WRITE;
    }
 
    int socket() const {
        return _socket;
    }
 
    static int closeSocket(int fd);
 
    void closeMe() {
        _state = PollState::CLOSE;
    }
 
    void createNonBlockingSocket(struct addrinfo *addressEntry,
                                 struct addrinfo *localAddr=nullptr);
 
    bool setNonBlocking(int fd);
 
    static bool socketInError(int fd);
 
    bool inError() const {
        if (!socketInError(_socket))
            return false;
        errno_log() << "failed socket " << _socket;
        return true;
    }
private:
    void setState(PollState state) {
        if (_state != PollState::CLOSE)
            _state = state;
    }
 
    // Return false on failure:
    bool createServerSocket();
 
    static void clearCache();
 
    void killMe() {
        _state = PollState::KILL;
    }
 
    // Internal identifier used as key in dns_cache:
    std::string _peer_label;
 
    void setSocket(int fd) {
        _socket = fd;
    }
 
    Socket(const Socket &);
    Task *_owner;
    int _socket;
#ifndef _WIN32
    // If this is a Unix Domain socket, the peer socket descriptor will be
    // stored here:
    int unix_domain_peer = 0;
#endif
    std::string _hostname;
    uint16_t _port;
    PollState _state;
    TimePoint expiry = timeMax();
};