diff options
Diffstat (limited to 'src/common/socket.hpp')
| -rw-r--r-- | src/common/socket.hpp | 192 |
1 files changed, 129 insertions, 63 deletions
diff --git a/src/common/socket.hpp b/src/common/socket.hpp index 00f2df0..d7c6b9c 100644 --- a/src/common/socket.hpp +++ b/src/common/socket.hpp @@ -3,62 +3,19 @@ # include "sanity.hpp" -# include <stdio.h> - -# include <sys/types.h> -# include <sys/socket.h> # include <netinet/in.h> -# include <time.h> +# include <cstdio> -/// Check how much can be read -# define RFIFOREST(fd) (session[fd]->rdata_size-session[fd]->rdata_pos) -/// Read from the queue -# define RFIFOP(fd,pos) (session[fd]->rdata+session[fd]->rdata_pos+(pos)) -# define RFIFOB(fd,pos) (*(uint8_t*)(RFIFOP(fd, pos))) -# define RFIFOW(fd,pos) (*(uint16_t*)(RFIFOP(fd, pos))) -# define RFIFOL(fd,pos) (*(uint32_t*)(RFIFOP(fd, pos))) -/// Done reading -void RFIFOSKIP (int fd, size_t len); -/// Internal - clean up by discarding handled bytes -// Atm this is also called in char/char.c, but that is unnecessary -# define RFIFOFLUSH(fd) (memmove(session[fd]->rdata,RFIFOP(fd,0),RFIFOREST(fd)),\ -session[fd]->rdata_size=RFIFOREST(fd),\ -session[fd]->rdata_pos=0) - -/// Used internally - how much room there is to read more data -# define RFIFOSPACE(fd) (session[fd]->max_rdata-session[fd]->rdata_size) - -/// Read from an arbitrary buffer -# define RBUFP(p,pos) (((uint8_t*)(p))+(pos)) -# define RBUFB(p,pos) (*(uint8_t*)RBUFP((p),(pos))) -# define RBUFW(p,pos) (*(uint16_t*)RBUFP((p),(pos))) -# define RBUFL(p,pos) (*(uint32_t*)RBUFP((p),(pos))) - - - -/// Unused - check how much data can be written -# define WFIFOSPACE(fd) (session[fd]->max_wdata-session[fd]->wdata_size) -/// Write to the queue -# define WFIFOP(fd,pos) (session[fd]->wdata+session[fd]->wdata_size+(pos)) -# define WFIFOB(fd,pos) (*(uint8_t*)(WFIFOP(fd,pos))) -# define WFIFOW(fd,pos) (*(uint16_t*)(WFIFOP(fd,pos))) -# define WFIFOL(fd,pos) (*(uint32_t*)(WFIFOP(fd,pos))) -/// Finish writing -void WFIFOSET (int fd, size_t len); - -/// Write to an arbitrary buffer -#define WBUFP(p,pos) (((uint8_t*)(p))+(pos)) -#define WBUFB(p,pos) (*(uint8_t*)WBUFP((p),(pos))) -#define WBUFW(p,pos) (*(uint16_t*)WBUFP((p),(pos))) -#define WBUFL(p,pos) (*(uint32_t*)WBUFP((p),(pos))) +# include "utils.hpp" +# include "timer.t.hpp" // Struct declaration struct socket_data { /// Checks whether a newly-connected socket actually does anything - time_t created; + TimeT created; bool connected; /// Flag needed since structure must be freed in a server-dependent manner @@ -80,22 +37,22 @@ 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)(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); + void(*func_parse)(int); /// Server-specific data type void *session_data; }; // save file descriptors for important stuff -# define SOFT_LIMIT (FD_SETSIZE - 50) +constexpr int SOFT_LIMIT = FD_SETSIZE - 50; // socket timeout to establish a full connection in seconds -# define CONNECT_TIMEOUT 15 +constexpr int CONNECT_TIMEOUT = 15; /// Everyone who has connected // note: call delete_session(i) to null out an element @@ -106,30 +63,139 @@ 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); +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); +int make_connection(uint32_t ip, uint16_t port); /// free() the structure and close() the fd -void delete_session (int); +void delete_session(int); /// Make a the internal queues bigger -void realloc_fifo (int fd, size_t rfifo_size, size_t wfifo_size); +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 (uint32_t next); +void do_sendrecv(interval_t next); /// Call the parser function for every socket that has read data -void do_parsepacket (void); +void do_parsepacket(void); /// An init function -void do_socket (void); +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)(int)); /// Wrappers to track number of free FDs -void fclose_ (FILE * fp); -FILE *fopen_ (const char *path, const char *mode); -bool free_fds (void); +void fclose_(FILE * fp); +FILE *fopen_(const char *path, const char *mode); + +bool free_fds(void); + + + +/// 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)); +} + +/// 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)); +} + + +/// 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)); +} +/// 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)); +} #endif // SOCKET_HPP |