summaryrefslogtreecommitdiff
path: root/src/common/socket.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/common/socket.hpp')
-rw-r--r--src/common/socket.hpp120
1 files changed, 64 insertions, 56 deletions
diff --git a/src/common/socket.hpp b/src/common/socket.hpp
index 8a2ee3a..4d51604 100644
--- a/src/common/socket.hpp
+++ b/src/common/socket.hpp
@@ -29,7 +29,7 @@ struct SessionDeleter
// Struct declaration
-struct socket_data
+struct Session
{
/// Checks whether a newly-connected socket actually does anything
TimeT created;
@@ -54,17 +54,25 @@ struct socket_data
/// 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);
+ void (*func_recv)(Session *);
+ void (*func_send)(Session *);
/// 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);
+ void (*func_parse)(Session *);
/// Server-specific data type
std::unique_ptr<SessionData, SessionDeleter> session_data;
+
+ int fd;
};
+inline
+int convert_for_printf(Session *s)
+{
+ return s->fd;
+}
+
// save file descriptors for important stuff
constexpr int SOFT_LIMIT = FD_SETSIZE - 50;
@@ -73,21 +81,21 @@ 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;
+extern std::array<std::unique_ptr<Session>, 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);
+Session *make_listen_port(uint16_t port);
/// Connect to an address, return a connected socket or -1
// FIXME - this is IPv4 only!
-int make_connection(IP4Address ip, uint16_t port);
+Session *make_connection(IP4Address ip, uint16_t port);
/// free() the structure and close() the fd
-void delete_session(int);
+void delete_session(Session *);
/// Make a the internal queues bigger
-void realloc_fifo(int fd, size_t rfifo_size, size_t wfifo_size);
+void realloc_fifo(Session *s, 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
@@ -99,7 +107,7 @@ 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));
+void set_defaultparse(void(*defaultparse)(Session *));
template<class T>
uint8_t *pod_addressof_m(T& structure)
@@ -118,68 +126,68 @@ const uint8_t *pod_addressof_c(const T& structure)
/// Check how much can be read
inline
-size_t RFIFOREST(int fd)
+size_t RFIFOREST(Session *s)
{
- return session[fd]->rdata_size - session[fd]->rdata_pos;
+ return s->rdata_size - s->rdata_pos;
}
/// Read from the queue
inline
-const void *RFIFOP(int fd, size_t pos)
+const void *RFIFOP(Session *s, size_t pos)
{
- return &session[fd]->rdata[session[fd]->rdata_pos + pos];
+ return &s->rdata[s->rdata_pos + pos];
}
inline
-uint8_t RFIFOB(int fd, size_t pos)
+uint8_t RFIFOB(Session *s, size_t pos)
{
- return *static_cast<const uint8_t *>(RFIFOP(fd, pos));
+ return *static_cast<const uint8_t *>(RFIFOP(s, pos));
}
inline
-uint16_t RFIFOW(int fd, size_t pos)
+uint16_t RFIFOW(Session *s, size_t pos)
{
- return *static_cast<const uint16_t *>(RFIFOP(fd, pos));
+ return *static_cast<const uint16_t *>(RFIFOP(s, pos));
}
inline
-uint32_t RFIFOL(int fd, size_t pos)
+uint32_t RFIFOL(Session *s, size_t pos)
{
- return *static_cast<const uint32_t *>(RFIFOP(fd, pos));
+ return *static_cast<const uint32_t *>(RFIFOP(s, pos));
}
template<class T>
-void RFIFO_STRUCT(int fd, size_t pos, T& structure)
+void RFIFO_STRUCT(Session *s, size_t pos, T& structure)
{
- really_memcpy(pod_addressof_m(structure), static_cast<const uint8_t *>(RFIFOP(fd, pos)), sizeof(T));
+ really_memcpy(pod_addressof_m(structure), static_cast<const uint8_t *>(RFIFOP(s, pos)), sizeof(T));
}
inline
-IP4Address RFIFOIP(int fd, size_t pos)
+IP4Address RFIFOIP(Session *s, size_t pos)
{
IP4Address o;
- RFIFO_STRUCT(fd, pos, o);
+ RFIFO_STRUCT(s, pos, o);
return o;
}
template<uint8_t len>
inline
-VString<len-1> RFIFO_STRING(int fd, size_t pos)
+VString<len-1> RFIFO_STRING(Session *s, size_t pos)
{
- const char *const begin = static_cast<const char *>(RFIFOP(fd, pos));
+ const char *const begin = static_cast<const char *>(RFIFOP(s, pos));
const char *const end = begin + len-1;
const char *const mid = std::find(begin, end, '\0');
return XString(begin, mid, nullptr);
}
inline
-FString RFIFO_STRING(int fd, size_t pos, size_t len)
+FString RFIFO_STRING(Session *s, size_t pos, size_t len)
{
- const char *const begin = static_cast<const char *>(RFIFOP(fd, pos));
+ const char *const begin = static_cast<const char *>(RFIFOP(s, pos));
const char *const end = begin + len;
const char *const mid = std::find(begin, end, '\0');
return XString(begin, mid, nullptr);
}
inline
-void RFIFO_BUF_CLONE(int fd, uint8_t *buf, size_t len)
+void RFIFO_BUF_CLONE(Session *s, uint8_t *buf, size_t len)
{
- really_memcpy(buf, static_cast<const uint8_t *>(RFIFOP(fd, 0)), len);
+ really_memcpy(buf, static_cast<const uint8_t *>(RFIFOP(s, 0)), len);
}
/// Done reading
-void RFIFOSKIP(int fd, size_t len);
+void RFIFOSKIP(Session *s, size_t len);
/// Read from an arbitrary buffer
inline
@@ -236,65 +244,65 @@ FString RBUF_STRING(const uint8_t *p, size_t pos, size_t len)
/// Unused - check how much data can be written
// the existence of this seems scary
inline
-size_t WFIFOSPACE(int fd)
+size_t WFIFOSPACE(Session *s)
{
- return session[fd]->max_wdata - session[fd]->wdata_size;
+ return s->max_wdata - s->wdata_size;
}
/// Write to the queue
inline
-void *WFIFOP(int fd, size_t pos)
+void *WFIFOP(Session *s, size_t pos)
{
- return &session[fd]->wdata[session[fd]->wdata_size + pos];
+ return &s->wdata[s->wdata_size + pos];
}
inline
-uint8_t& WFIFOB(int fd, size_t pos)
+uint8_t& WFIFOB(Session *s, size_t pos)
{
- return *static_cast<uint8_t *>(WFIFOP(fd, pos));
+ return *static_cast<uint8_t *>(WFIFOP(s, pos));
}
inline
-uint16_t& WFIFOW(int fd, size_t pos)
+uint16_t& WFIFOW(Session *s, size_t pos)
{
- return *static_cast<uint16_t *>(WFIFOP(fd, pos));
+ return *static_cast<uint16_t *>(WFIFOP(s, pos));
}
inline
-uint32_t& WFIFOL(int fd, size_t pos)
+uint32_t& WFIFOL(Session *s, size_t pos)
{
- return *static_cast<uint32_t *>(WFIFOP(fd, pos));
+ return *static_cast<uint32_t *>(WFIFOP(s, pos));
}
template<class T>
-void WFIFO_STRUCT(int fd, size_t pos, T& structure)
+void WFIFO_STRUCT(Session *s, size_t pos, T& structure)
{
- really_memcpy(static_cast<uint8_t *>(WFIFOP(fd, pos)), pod_addressof_c(structure), sizeof(T));
+ really_memcpy(static_cast<uint8_t *>(WFIFOP(s, pos)), pod_addressof_c(structure), sizeof(T));
}
inline
-IP4Address& WFIFOIP(int fd, size_t pos)
+IP4Address& WFIFOIP(Session *s, size_t pos)
{
static_assert(is_trivially_copyable<IP4Address>::value, "That was the whole point");
- return *static_cast<IP4Address *>(WFIFOP(fd, pos));
+ return *static_cast<IP4Address *>(WFIFOP(s, pos));
}
inline
-void WFIFO_STRING(int fd, size_t pos, XString s, size_t len)
+void WFIFO_STRING(Session *s, size_t pos, XString str, size_t len)
{
- char *const begin = static_cast<char *>(WFIFOP(fd, pos));
+ char *const begin = static_cast<char *>(WFIFOP(s, pos));
char *const end = begin + len;
- char *const mid = std::copy(s.begin(), s.end(), begin);
+ char *const mid = std::copy(str.begin(), str.end(), begin);
std::fill(mid, end, '\0');
}
inline
-void WFIFO_ZERO(int fd, size_t pos, size_t len)
+void WFIFO_ZERO(Session *s, size_t pos, size_t len)
{
- uint8_t *b = static_cast<uint8_t *>(WFIFOP(fd, pos));
+ uint8_t *b = static_cast<uint8_t *>(WFIFOP(s, 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)
+void WFIFO_BUF_CLONE(Session *s, const uint8_t *buf, size_t len)
{
- really_memcpy(static_cast<uint8_t *>(WFIFOP(fd, 0)), buf, len);
+ really_memcpy(static_cast<uint8_t *>(WFIFOP(s, 0)), buf, len);
}
/// Finish writing
-void WFIFOSET(int fd, size_t len);
+void WFIFOSET(Session *s, size_t len);
/// Write to an arbitrary buffer
inline
@@ -344,10 +352,10 @@ void WBUF_ZERO(uint8_t *p, size_t pos, size_t len)
}
inline
-void RFIFO_WFIFO_CLONE(int rfd, int wfd, size_t len)
+void RFIFO_WFIFO_CLONE(Session *rs, Session *ws, size_t len)
{
- really_memcpy(static_cast<uint8_t *>(WFIFOP(wfd, 0)),
- static_cast<const uint8_t *>(RFIFOP(rfd, 0)), len);
+ really_memcpy(static_cast<uint8_t *>(WFIFOP(ws, 0)),
+ static_cast<const uint8_t *>(RFIFOP(rs, 0)), len);
}
#endif // SOCKET_HPP
generated by cgit v1.2.3-60-g2f50 (git 2.42.0) at 2024-07-01 15:44:25 +0000