path: root/src/common/socket.hpp

#ifndef SOCKET_HPP
#define SOCKET_HPP

# include "sanity.hpp"

# include <netinet/in.h>

# include <cstdio>

# include <array>

# include "dumb_ptr.hpp"
# include "utils.hpp"
# include "timer.t.hpp"

struct SessionData
{
};
struct SessionDeleter
{
    // defined per-server
    void operator()(SessionData *sd);
};

// Struct declaration

struct socket_data
{
    /// Checks whether a newly-connected socket actually does anything
    TimeT created;
    bool connected;

    /// Flag needed since structure must be freed in a server-dependent manner
    bool eof;

    /// Since this is a single-threaded application, it can't block
    /// These are the read/write queues
    dumb_ptr<uint8_t[]> rdata, wdata;
    size_t max_rdata, max_wdata;
    /// How much is actually in the queue
    size_t rdata_size, wdata_size;
    /// How much has already been read from the queue
    /// Note that there is no need for a wdata_pos
    size_t rdata_pos;

    struct sockaddr_in client_addr;

    /// Send or recieve
    /// Only called when select() indicates the socket is ready
    /// If, after that, nothing is read, it sets eof
    // These could probably be hard-coded with a little work
    void (*func_recv)(int);
    void (*func_send)(int);
    /// This is the important one
    /// Set to different functions depending on whether the connection
    /// is a player or a server/ladmin
    /// Can be set explicitly or via set_defaultparse
    void (*func_parse)(int);
    /// Server-specific data type
    std::unique_ptr<SessionData, SessionDeleter> session_data;
};

// save file descriptors for important stuff
constexpr int SOFT_LIMIT = FD_SETSIZE - 50;

// socket timeout to establish a full connection in seconds
constexpr int CONNECT_TIMEOUT = 15;

/// Everyone who has connected
// note: call delete_session(i) to null out an element
extern std::array<std::unique_ptr<socket_data>, FD_SETSIZE> session;

/// Maximum used FD, +1
extern int fd_max;

/// open a socket, bind, and listen. Return an fd, or -1 if socket() fails,
/// but exit if bind() or listen() fails
int make_listen_port(uint16_t port);
/// Connect to an address, return a connected socket or -1
// FIXME - this is IPv4 only!
int make_connection(uint32_t ip, uint16_t port);
/// free() the structure and close() the fd
void delete_session(int);
/// Make a the internal queues bigger
void realloc_fifo(int fd, size_t rfifo_size, size_t wfifo_size);
/// Update all sockets that can be read/written from the queues
void do_sendrecv(interval_t next);
/// Call the parser function for every socket that has read data
void do_parsepacket(void);

/// An init function
void do_socket(void);

/// Change the default parser for newly connected clients
// typically called once per server, but individual clients may identify
// themselves as servers
void set_defaultparse(void(*defaultparse)(int));

/// Wrappers to track number of free FDs
void fclose_(FILE * fp);
FILE *fopen_(const char *path, const char *mode);

bool free_fds(void);

template<class T>
uint8_t *pod_addressof(T& structure)
{
    static_assert(is_trivially_copyable<T>::value, "Can only byte-copy POD-ish structs");
    return &reinterpret_cast<uint8_t&>(structure);
}



/// Check how much can be read
inline
size_t RFIFOREST(int fd)
{
    return session[fd]->rdata_size - session[fd]->rdata_pos;
}
/// Read from the queue
inline
const void *RFIFOP(int fd, size_t pos)
{
    return &session[fd]->rdata[session[fd]->rdata_pos + pos];
}
inline
uint8_t RFIFOB(int fd, size_t pos)
{
    return *static_cast<const uint8_t *>(RFIFOP(fd, pos));
}
inline
uint16_t RFIFOW(int fd, size_t pos)
{
    return *static_cast<const uint16_t *>(RFIFOP(fd, pos));
}
inline
uint32_t RFIFOL(int fd, size_t pos)
{
    return *static_cast<const uint32_t *>(RFIFOP(fd, pos));
}
template<class T>
void RFIFO_STRUCT(int fd, size_t pos, T& structure)
{
    really_memcpy(pod_addressof(structure), static_cast<const uint8_t *>(RFIFOP(fd, pos)), sizeof(T));
}
inline
void RFIFO_STRING(int fd, size_t pos, char *out, size_t len)
{
    strzcpy(out, static_cast<const char *>(RFIFOP(fd, pos)), len);
}
inline
void RFIFO_BUF_CLONE(int fd, uint8_t *buf, size_t len)
{
    really_memcpy(buf, static_cast<const uint8_t *>(RFIFOP(fd, 0)), len);
}

/// Done reading
void RFIFOSKIP(int fd, size_t len);

/// Read from an arbitrary buffer
inline
const void *RBUFP(const uint8_t *p, size_t pos)
{
    return p + pos;
}
inline
uint8_t RBUFB(const uint8_t *p, size_t pos)
{
    return *static_cast<const uint8_t *>(RBUFP(p, pos));
}
inline
uint16_t RBUFW(const uint8_t *p, size_t pos)
{
    return *static_cast<const uint16_t *>(RBUFP(p, pos));
}
inline
uint32_t RBUFL(const uint8_t *p, size_t pos)
{
    return *static_cast<const uint32_t *>(RBUFP(p, pos));
}
template<class T>
void RBUF_STRUCT(const uint8_t *p, size_t pos, T& structure)
{
    really_memcpy(pod_addressof(structure), p + pos, sizeof(T));
}
inline
void RBUF_STRING(const uint8_t *p, size_t pos, char *out, size_t len)
{
    strzcpy(out, static_cast<const char *>(RBUFP(p, pos)), len);
}


/// Unused - check how much data can be written
inline
size_t WFIFOSPACE(int fd)
{
    return session[fd]->max_wdata - session[fd]->wdata_size;
}
/// Write to the queue
inline
void *WFIFOP(int fd, size_t pos)
{
    return &session[fd]->wdata[session[fd]->wdata_size + pos];
}
inline
uint8_t& WFIFOB(int fd, size_t pos)
{
    return *static_cast<uint8_t *>(WFIFOP(fd, pos));
}
inline
uint16_t& WFIFOW(int fd, size_t pos)
{
    return *static_cast<uint16_t *>(WFIFOP(fd, pos));
}
inline
uint32_t& WFIFOL(int fd, size_t pos)
{
    return *static_cast<uint32_t *>(WFIFOP(fd, pos));
}
template<class T>
void WFIFO_STRUCT(int fd, size_t pos, T& structure)
{
    really_memcpy(static_cast<uint8_t *>(WFIFOP(fd, pos)), pod_addressof(structure), sizeof(T));
}
inline
void WFIFO_STRING(int fd, size_t pos, const char *s, size_t len)
{
    strzcpy(static_cast<char *>(WFIFOP(fd, pos)), s, len);
}
inline
void WFIFO_ZERO(int fd, size_t pos, size_t len)
{
    uint8_t *b = static_cast<uint8_t *>(WFIFOP(fd, pos));
    uint8_t *e = b + len;
    std::fill(b, e, '\0');
}
inline
void WFIFO_BUF_CLONE(int fd, const uint8_t *buf, size_t len)
{
    really_memcpy(static_cast<uint8_t *>(WFIFOP(fd, 0)), buf, len);
}

/// Finish writing
void WFIFOSET(int fd, size_t len);

/// Write to an arbitrary buffer
inline
void *WBUFP(uint8_t *p, size_t pos)
{
    return p + pos;
}
inline
uint8_t& WBUFB(uint8_t *p, size_t pos)
{
    return *static_cast<uint8_t *>(WBUFP(p, pos));
}
inline
uint16_t& WBUFW(uint8_t *p, size_t pos)
{
    return *static_cast<uint16_t *>(WBUFP(p, pos));
}
inline
uint32_t& WBUFL(uint8_t *p, size_t pos)
{
    return *static_cast<uint32_t *>(WBUFP(p, pos));
}
template<class T>
void WBUF_STRUCT(uint8_t *p, size_t pos, T& structure)
{
    really_memcpy(p + pos, pod_addressof(structure), sizeof(T));
}
inline
void WBUF_STRING(uint8_t *p, size_t pos, const char *s, size_t len)
{
    strzcpy(static_cast<char *>(WBUFP(p, pos)), s, len);
}
inline
void WBUF_ZERO(uint8_t *p, size_t pos, size_t len)
{
    uint8_t *b = static_cast<uint8_t *>(WBUFP(p, pos));
    uint8_t *e = b + len;
    std::fill(b, e, '\0');
}

inline
void RFIFO_WFIFO_CLONE(int rfd, int wfd, size_t len)
{
    really_memcpy(static_cast<uint8_t *>(WFIFOP(wfd, 0)),
            static_cast<const uint8_t *>(RFIFOP(rfd, 0)), len);
}

#endif // SOCKET_HPP