include/inspsocket.h

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
   6  *                       E-mail:
   7  *                <brain@chatspike.net>
   8  *                <Craig@chatspike.net>
   9  *
  10  * Written by Craig Edwards, Craig McLure, and others.
  11  * This program is free but copyrighted software; see
  12  *            the file COPYING for details.
  13  *
  14  * ---------------------------------------------------
  15  */
  16
  17 #ifndef __INSP_SOCKET_H__
  18 #define __INSP_SOCKET_H__
  19
  20 #include <sstream>
  21 #include <string>
  22 #include <deque>
  23 #include "dns.h"
  24 #include "inspircd_config.h"
  25 #include "socket.h"
  26 #include "inspsocket.h"
  27 #include "timer.h"
  28
  29 /**
  30  * States which a socket may be in
  31  */
  32 enum InspSocketState { I_DISCONNECTED, I_CONNECTING, I_CONNECTED, I_LISTENING, I_ERROR };
  33
  34 /**
  35  * Error types which a socket may exhibit
  36  */
  37 enum InspSocketError { I_ERR_TIMEOUT, I_ERR_SOCKET, I_ERR_CONNECT, I_ERR_BIND, I_ERR_RESOLVE, I_ERR_WRITE, I_ERR_NOMOREFDS };
  38
  39 class InspSocket;
  40 class InspIRCd;
  41
  42 using irc::sockets::insp_sockaddr;
  43 using irc::sockets::insp_inaddr;
  44 using irc::sockets::insp_ntoa;
  45 using irc::sockets::insp_aton;
  46
  47 /** Used to time out socket connections
  48  */
  49 class SocketTimeout : public InspTimer
  50 {
  51  private:
  52         InspSocket* sock;
  53         InspIRCd* ServerInstance;
  54         int sfd;
  55  public:
  56         SocketTimeout(int fd, InspIRCd* Instance, InspSocket* thesock, long secs_from_now, time_t now) : InspTimer(secs_from_now, now), sock(thesock), ServerInstance(Instance), sfd(fd) { };
  57         virtual void Tick(time_t now);
  58 };
  59
  60 /**
  61  * InspSocket is an extendable socket class which modules
  62  * can use for TCP socket support. It is fully integrated
  63  * into InspIRCds socket loop and attaches its sockets to
  64  * the core's instance of the SocketEngine class, meaning
  65  * that any sockets you create have the same power and
  66  * abilities as a socket created by the core itself.
  67  * To use InspSocket, you must inherit a class from it,
  68  * and use the InspSocket constructors to establish connections
  69  * and bindings.
  70  */
  71 class InspSocket : public EventHandler
  72 {
  73  public:
  74         InspIRCd* Instance;
  75
  76         SocketTimeout* Timeout;
  77
  78         unsigned long timeout_val;
  79
  80         std::deque<std::string> outbuffer;
  81
  82         /**
  83          * The hostname connected to
  84          */
  85         char host[MAXBUF];
  86
  87         /**
  88          * The port connected to, or the port
  89          * this socket is listening on
  90          */
  91         int port;
  92
  93         /**
  94          * The state for this socket, either
  95          * listening, connecting, connected
  96          * or error.
  97          */
  98         InspSocketState state;
  99
 100         /**
 101          * The host being connected to,
 102          * in sockaddr form
 103          */
 104         insp_sockaddr addr;
 105
 106         /**
 107          * The host being connected to,
 108          * in in_addr form
 109          */
 110         insp_inaddr addy;
 111
 112         /**
 113          * This value is true if the
 114          * socket has timed out.
 115          */
 116         bool timeout;
 117
 118         /**
 119          * Socket input buffer, used by read(). The class which
 120          * extends InspSocket is expected to implement an extendable
 121          * buffer which can grow much larger than 64k,
 122          * this buffer is just designed to be temporary storage.
 123          * space.
 124          */
 125         char ibuf[65535];
 126
 127         /**
 128          * The IP address being connected
 129          * to stored in string form for
 130          * easy retrieval by accessors.
 131          */
 132         char IP[MAXBUF];
 133
 134         /**
 135          * Client sockaddr structure used
 136          * by accept()
 137          */
 138         insp_sockaddr client;
 139
 140         /**
 141          * Server sockaddr structure used
 142          * by accept()
 143          */
 144         insp_sockaddr server;
 145
 146         /**
 147          * Used by accept() to indicate the
 148          * sizes of the sockaddr_in structures
 149          */
 150         socklen_t length;
 151
 152         /** Flushes the write buffer
 153          */
 154         bool FlushWriteBuffer();
 155
 156         /** Set the queue sizes
 157          * This private method sets the operating system queue
 158          * sizes for this socket to 65535 so that it can queue
 159          * more information without application-level queueing
 160          * which was required in older software.
 161          */
 162         void SetQueues(int nfd);
 163
 164         /** When the socket has been marked as closing, this flag
 165          * will be set to true, then the next time the socket is
 166          * examined, the socket is deleted and closed.
 167          */
 168         bool ClosePending;
 169
 170         /** Set to true when we're waiting for a write event.
 171          * If this is true and a write event comes in, we
 172          * call the write instead of the read method.
 173          */
 174         bool WaitingForWriteEvent;
 175
 176         bool BindAddr();
 177
 178         /**
 179          * The default constructor does nothing
 180          * and should not be used.
 181          */
 182         InspSocket(InspIRCd* SI);
 183
 184         /**
 185          * This constructor is used to associate
 186          * an existing connecting with an InspSocket
 187          * class. The given file descriptor must be
 188          * valid, and when initialized, the InspSocket
 189          * will be set with the given IP address
 190          * and placed in CONNECTED state.
 191          */
 192         InspSocket(InspIRCd* SI, int newfd, const char* ip);
 193
 194         /**
 195          * This constructor is used to create a new
 196          * socket, either listening for connections, or an outbound connection to another host.
 197          * Note that if you specify a hostname in the 'ipaddr' parameter, this class will not
 198          * connect. You must resolve your hostnames before passing them to InspSocket. To do so,
 199          * you should use the nonblocking class 'Resolver'.
 200          * @param ipaddr The IP to connect to, or bind to
 201          * @param port The port number to connect to, or bind to
 202          * @param listening true to listen on the given host:port pair, or false to connect to them
 203          * @param maxtime Number of seconds to wait, if connecting, before the connection times out and an OnTimeout() event is generated
 204          */
 205         InspSocket(InspIRCd* SI, const std::string &ipaddr, int port, bool listening, unsigned long maxtime);
 206
 207         /**
 208          * This method is called when an outbound
 209          * connection on your socket is completed.
 210          * @return false to abort the connection, true to continue
 211          */
 212         virtual bool OnConnected();
 213
 214         /**
 215          * This method is called when an error occurs.
 216          * A closed socket in itself is not an error,
 217          * however errors also generate close events.
 218          * @param e The error type which occured
 219          */
 220         virtual void OnError(InspSocketError e);
 221
 222         /**
 223          * When an established connection is terminated,
 224          * the OnDisconnect method is triggered.
 225          */
 226         virtual int OnDisconnect();
 227
 228         /**
 229          * When there is data waiting to be read on a
 230          * socket, the OnDataReady() method is called.
 231          * Within this method, you *MUST* call the Read()
 232          * method to read any pending data. At its lowest
 233          * level, this event is signalled by the core via
 234          * the socket engine. If you return false from this
 235          * function, the core removes your socket from its
 236          * list and erases it from the socket engine, then
 237          * calls InspSocket::Close() and deletes it.
 238          * @return false to close the socket
 239          */
 240         virtual bool OnDataReady();
 241
 242         virtual bool OnWriteReady();
 243
 244         /**
 245          * When an outbound connection fails, and the
 246          * attempt times out, you will receive this event.
 247          * The method will trigger once maxtime seconds are
 248          * reached (as given in the constructor) just
 249          * before the socket's descriptor is closed.
 250          * A failed DNS lookup may cause this event if
 251          * the DNS server is not responding, as well as
 252          * a failed connect() call, because DNS lookups are
 253          * nonblocking as implemented by this class.
 254          */
 255         virtual void OnTimeout();
 256
 257         /**
 258          * Whenever close() is called, OnClose() will be
 259          * called first. Please note that this means
 260          * OnClose will be called alongside OnError(),
 261          * OnTimeout(), and Close(), and also when
 262          * cancelling a listening socket by calling
 263          * the destructor indirectly.
 264          */
 265         virtual void OnClose();
 266
 267         /**
 268          * Reads all pending bytes from the socket
 269          * into a char* array which can be up to
 270          * 16 kilobytes in length.
 271          */
 272         virtual char* Read();
 273
 274         /**
 275          * Returns the IP address associated with
 276          * this connection, or an empty string if
 277          * no IP address exists.
 278          */
 279         std::string GetIP();
 280
 281         /**
 282          * Writes a std::string to the socket. No carriage
 283          * returns or linefeeds are appended to the string.
 284          * @param data The data to send
 285          */
 286         virtual int Write(const std::string &data);
 287
 288         /**
 289          * If your socket is a listening socket, when a new
 290          * connection comes in on the socket this method will
 291          * be called. Given the new file descriptor in the
 292          * parameters, and the IP, it is recommended you copy
 293          * them to a new instance of your socket class,
 294          * e.g.:
 295          *
 296          * MySocket* newsocket = new MySocket(newfd,ip);
 297          *
 298          * Once you have done this, you can then associate the
 299          * new socket with the core using Server::AddSocket().
 300          */
 301         virtual int OnIncomingConnection(int newfd, char* ip);
 302
 303         /**
 304          * Changes the socket's state. The core uses this
 305          * to change socket states, and you should not call
 306          * it directly.
 307          */
 308         void SetState(InspSocketState s);
 309
 310         /**
 311          * Call this to receive the next write event
 312          * that comes along for this fd to the OnWriteReady
 313          * method.
 314          */
 315         void WantWrite();
 316
 317         /**
 318          * Returns the current socket state.
 319          */
 320         InspSocketState GetState();
 321
 322         /**
 323          * Only the core should call this function.
 324          * When called, it is assumed the socket is ready
 325          * to read data, and the method call routes the
 326          * event to the various methods of InspSocket
 327          * for you to handle. This can also cause the
 328          * socket's state to change.
 329          */
 330         bool Poll();
 331
 332         /**
 333          * This method returns the socket's file descriptor
 334          * as assigned by the operating system, or -1
 335          * if no descriptor has been assigned.
 336          */
 337         int GetFd();
 338
 339         /**
 340          * This method causes the socket to close, and may
 341          * also be triggered by other methods such as OnTimeout
 342          * and OnError.
 343          */
 344         virtual void Close();
 345
 346         /**
 347          * The destructor may implicitly call OnClose(), and
 348          * will close() and shutdown() the file descriptor
 349          * used for this socket.
 350          */
 351         virtual ~InspSocket();
 352
 353         /**
 354          * This method attempts to connect to a hostname.
 355          * This only occurs on a non-listening socket. This
 356          * method is asyncronous.
 357          */
 358         virtual bool DoConnect();
 359
 360         /**
 361          * This method marks the socket closed.
 362          * The next time the core examines a socket marked
 363          * as closed, the socket will be closed and the
 364          * memory reclaimed.
 365          */
 366         void MarkAsClosed();
 367
 368         void HandleEvent(EventType et, int errornum = 0);
 369
 370         bool Readable();
 371 };
 372
 373 #endif