class BufferedSocket;
class InspIRCd;
-using irc::sockets::insp_sockaddr;
-using irc::sockets::insp_inaddr;
-using irc::sockets::insp_ntoa;
-using irc::sockets::insp_aton;
-
/** Used to time out socket connections
*/
class CoreExport SocketTimeout : public Timer
/** BufferedSocket the class is attached to
*/
BufferedSocket* sock;
+
/** Server instance creating the timeout class
*/
InspIRCd* ServerInstance;
+
/** File descriptor of class this is attached to
*/
int sfd;
+
public:
/** Create a socket timeout class
* @param fd File descriptor of BufferedSocket
* @param now The current time
*/
SocketTimeout(int fd, InspIRCd* Instance, BufferedSocket* thesock, long secs_from_now, time_t now) : Timer(secs_from_now, now), sock(thesock), ServerInstance(Instance), sfd(fd) { };
+
/** Handle tick event
*/
virtual void Tick(time_t now);
* can use for TCP socket support. It is fully integrated
* into InspIRCds socket loop and attaches its sockets to
* the core's instance of the SocketEngine class, meaning
- * that any sockets you create have the same power and
- * abilities as a socket created by the core itself.
- * To use BufferedSocket, you must inherit a class from it,
- * and use the BufferedSocket constructors to establish connections
- * and bindings.
+ * that all use is fully asynchronous.
+ *
+ * To use BufferedSocket, you must inherit a class from it.
*/
class CoreExport BufferedSocket : public EventHandler
{
/** Instance we were created by
*/
- InspIRCd* Instance;
+ InspIRCd* ServerInstance;
/** Timeout class or NULL
*/
SocketTimeout* Timeout;
- /** Timeout length
- */
- unsigned long timeout_val;
-
/** Socket output buffer (binary safe)
*/
std::deque<std::string> outbuffer;
* more information without application-level queueing
* which was required in older software.
*/
- void SetQueues(int nfd);
+ void SetQueues();
/** When the socket has been marked as closing, this flag
* will be set to true, then the next time the socket is
* other end of the socket.
*
* Further write events will not be triggered
- * unless you call WantWrite().
+ * unless you call SocketEngine::WantWrite().
*
* The default behaviour of this method is to
* flush the write buffer, respecting the IO
*/
void SetState(BufferedSocketState s);
- /**
- * Call this to receive the next write event
- * that comes along for this fd to the OnWriteReady
- * method.
- */
- void WantWrite();
-
/**
* Returns the current socket state.
*/
BufferedSocketState GetState();
- /**
- * Only the core should call this function.
- * When called, it is assumed the socket is ready
- * to read data, and the method call routes the
- * event to the various methods of BufferedSocket
- * for you to handle. This can also cause the
- * socket's state to change.
+ /** Mark a socket as being connected and call appropriate events.
*/
- bool Poll();
+ bool InternalMarkConnected();
/**
* This method causes the socket to close, and may
/**
* This method attempts to connect to a hostname.
* This method is asyncronous.
+ * @param maxtime Number of seconds to wait, if connecting, before the connection times out and an OnTimeout() event is generated
*/
- virtual bool DoConnect();
+ virtual bool DoConnect(unsigned long maxtime);
/** Handle event from EventHandler parent class
*/
projects / user / henk / code / inspircd.git / blobdiff