Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

InspSocket Class Reference

InspSocket is an extendable socket class which modules can use for TCP socket support. More...

#include <inspsocket.h>

Inheritance diagram for InspSocket:

[legend]Collaboration diagram for InspSocket:

[legend]List of all members.

Public Member Functions
bool	FlushWriteBuffer ()
	Flushes the write buffer.
void	SetQueues (int nfd)
	Set the queue sizes This private method sets the operating system queue sizes for this socket to 65535 so that it can queue more information without application-level queueing which was required in older software.
bool	BindAddr (const std::string &ip)
	Bind to an address.
	InspSocket (InspIRCd *SI)
	The default constructor does nothing and should not be used.
	InspSocket (InspIRCd *SI, int newfd, const char *ip)
	This constructor is used to associate an existing connecting with an InspSocket class.
	InspSocket (InspIRCd *SI, const std::string &ipaddr, int port, bool listening, unsigned long maxtime, const std::string &connectbindip="")
	This constructor is used to create a new socket, either listening for connections, or an outbound connection to another host.
virtual bool	OnConnected ()
	This method is called when an outbound connection on your socket is completed.
virtual void	OnError (InspSocketError e)
	This method is called when an error occurs.
virtual int	OnDisconnect ()
	When an established connection is terminated, the OnDisconnect method is triggered.
virtual bool	OnDataReady ()
	When there is data waiting to be read on a socket, the OnDataReady() method is called.
virtual bool	OnWriteReady ()
	When it is ok to write to the socket, and a write event was requested, this method is triggered.
virtual void	OnTimeout ()
	When an outbound connection fails, and the attempt times out, you will receive this event.
virtual void	OnClose ()
	Whenever close() is called, OnClose() will be called first.
virtual char *	Read ()
	Reads all pending bytes from the socket into a char* array which can be up to 16 kilobytes in length.
std::string	GetIP ()
	Returns the IP address associated with this connection, or an empty string if no IP address exists.
virtual void	Write (const std::string &data)
	Writes a std::string to the socket.
virtual int	OnIncomingConnection (int newfd, char *ip)
	If your socket is a listening socket, when a new connection comes in on the socket this method will be called.
void	SetState (InspSocketState s)
	Changes the socket's state.
void	WantWrite ()
	Call this to receive the next write event that comes along for this fd to the OnWriteReady method.
InspSocketState	GetState ()
	Returns the current socket state.
bool	Poll ()
	Only the core should call this function.
int	GetFd ()
	This method returns the socket's file descriptor as assigned by the operating system, or -1 if no descriptor has been assigned.
virtual void	Close ()
	This method causes the socket to close, and may also be triggered by other methods such as OnTimeout and OnError.
virtual	~InspSocket ()
	The destructor may implicitly call OnClose(), and will close() and shutdown() the file descriptor used for this socket.
virtual bool	DoConnect ()
	This method attempts to connect to a hostname.
void	MarkAsClosed ()
	This method marks the socket closed.
void	HandleEvent (EventType et, int errornum=0)
	Handle event from EventHandler parent class.
bool	Readable ()
	Returns true if this socket is readable.
Public Attributes
std::string	cbindip
	Bind IP.
bool	IsIOHooked
	Is hooked by a module for low level IO.
InspIRCd *	Instance
	Instance we were created by.
SocketTimeout *	Timeout
	Timeout class or NULL.
unsigned long	timeout_val
	Timeout length.
std::deque< std::string >	outbuffer
	Socket output buffer (binary safe).
char	host [MAXBUF]
	The hostname connected to.
int	port
	The port connected to, or the port this socket is listening on.
InspSocketState	state
	The state for this socket, either listening, connecting, connected or error.
bool	timeout
	This value is true if the socket has timed out.
char	ibuf [65535]
	Socket input buffer, used by read().
char	IP [MAXBUF]
	The IP address being connected to stored in string form for easy retrieval by accessors.
socklen_t	length
	Used by accept() to indicate the sizes of the sockaddr_in structures.
bool	ClosePending
	When the socket has been marked as closing, this flag will be set to true, then the next time the socket is examined, the socket is deleted and closed.
bool	WaitingForWriteEvent
	Set to true when we're waiting for a write event.

---

Detailed Description

InspSocket is an extendable socket class which modules 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 InspSocket, you must inherit a class from it, and use the InspSocket constructors to establish connections and bindings.

Definition at line 112 of file inspsocket.h.

---

Constructor & Destructor Documentation

InspSocket::InspSocket (  InspIRCd *  SI  )

The default constructor does nothing and should not be used. Definition at line 28 of file inspsocket.cpp. References EventHandler::fd, I_DISCONNECTED, Instance, IsIOHooked, state, Timeout, and WaitingForWriteEvent. { this->Timeout = NULL; this->state = I_DISCONNECTED; this->fd = -1; this->WaitingForWriteEvent = false; this->Instance = SI; this->IsIOHooked = false; }

InspSocket::InspSocket (  InspIRCd *  SI, int  newfd, const char *  ip )

This constructor is used to associate an existing connecting with an InspSocket class. The given file descriptor must be valid, and when initialized, the InspSocket will be set with the given IP address and placed in CONNECTED state. Definition at line 38 of file inspsocket.cpp. References SocketEngine::AddFd(), EventHandler::fd, I_CONNECTED, Instance, IsIOHooked, MAXBUF, InspIRCd::SE, state, strlcpy(), Timeout, and WaitingForWriteEvent. { this->Timeout = NULL; this->fd = newfd; this->state = I_CONNECTED; strlcpy(this->IP,ip,MAXBUF); this->WaitingForWriteEvent = false; this->Instance = SI; this->IsIOHooked = false; if (this->fd > -1) this->Instance->SE->AddFd(this); }

InspSocket::InspSocket (  InspIRCd *  SI, const std::string &  ipaddr, int  port, bool  listening, unsigned long  maxtime, const std::string &  connectbindip = "" )

This constructor is used to create a new socket, either listening for connections, or an outbound connection to another host. Note that if you specify a hostname in the 'ipaddr' parameter, this class will not connect. You must resolve your hostnames before passing them to InspSocket. To do so, you should use the nonblocking class 'Resolver'. Parameters: ipaddr  The IP to connect to, or bind to port  The port number to connect to, or bind to listening  true to listen on the given host:port pair, or false to connect to them maxtime  Number of seconds to wait, if connecting, before the connection times out and an OnTimeout() event is generated connectbindip  When creating an outbound connection, the IP to bind the connection to. If not defined, the port is not bound. Returns: On exit, GetState() returns I_ERROR if an error occured, and errno can be used to read the socket error. Definition at line 51 of file inspsocket.cpp. References InspIRCd::BindSocket(), cbindip, Close(), ClosePending, DEBUG, ERROR, EventHandler::fd, host, I_ERR_BIND, I_ERR_CONNECT, I_ERR_NOMOREFDS, I_ERR_SOCKET, I_ERROR, I_LISTENING, Instance, IsIOHooked, InspIRCd::Log(), MAXBUF, OnError(), irc::sockets::OpenTCPSocket(), port, state, strlcpy(), Timeout, timeout_val, and WaitingForWriteEvent. { this->cbindip = connectbindip; this->fd = -1; this->Instance = SI; strlcpy(host,ipaddr.c_str(),MAXBUF); this->WaitingForWriteEvent = false; this->IsIOHooked = false; this->Timeout = NULL; if (listening) { if ((this->fd = OpenTCPSocket(host)) == ERROR) { this->fd = -1; this->state = I_ERROR; this->OnError(I_ERR_SOCKET); return; } else { if (!SI->BindSocket(this->fd,aport,(char*)ipaddr.c_str())) { this->Close(); this->fd = -1; this->state = I_ERROR; this->OnError(I_ERR_BIND); this->ClosePending = true; return; } else { this->state = I_LISTENING; this->port = aport; if (this->fd > -1) { if (!this->Instance->SE->AddFd(this)) { this->Close(); this->state = I_ERROR; this->OnError(I_ERR_NOMOREFDS); } } return; } } } else { strlcpy(this->host,ipaddr.c_str(),MAXBUF); this->port = aport; bool ipvalid = true; #ifdef IPV6 if (strchr(host,':')) { in6_addr n; if (inet_pton(AF_INET6, host, &n) < 1) ipvalid = false; } else #endif { in_addr n; if (inet_aton(host,&n) < 1) ipvalid = false; } if (!ipvalid) { this->Instance->Log(DEBUG,"BUG: Hostname passed to InspSocket, rather than an IP address!"); this->OnError(I_ERR_CONNECT); this->Close(); this->fd = -1; this->state = I_ERROR; return; } else { strlcpy(this->IP,host,MAXBUF); timeout_val = maxtime; if (!this->DoConnect()) { this->OnError(I_ERR_CONNECT); this->Close(); this->fd = -1; this->state = I_ERROR; return; } } } }

InspSocket::~InspSocket (   )  [virtual]

The destructor may implicitly call OnClose(), and will close() and shutdown() the file descriptor used for this socket. Definition at line 708 of file inspsocket.cpp. References Close(), TimerManager::DelTimer(), Instance, Timeout, and InspIRCd::Timers. { this->Close(); if (Timeout) { Instance->Timers->DelTimer(Timeout); Timeout = NULL; } }

---

Member Function Documentation

bool InspSocket::BindAddr (  const std::string &  ip  )

Bind to an address. Parameters: ip  IP to bind to Returns: True is the binding succeeded Definition at line 168 of file inspsocket.cpp. References Conf, ConfigReader::Enumerate(), EventHandler::fd, I_ERR_BIND, I_ERROR, IP, OnError(), ConfigReader::ReadValue(), and state. { ConfigReader Conf(this->Instance); socklen_t size = sizeof(sockaddr_in); #ifdef IPV6 bool v6 = false; /* Are we looking for a binding to fit an ipv6 host? */ if ((ip.empty()) || (ip.find(':') != std::string::npos)) v6 = true; #endif int j = 0; while (j < Conf.Enumerate("bind") || (!ip.empty())) { std::string IP = ip.empty() ? Conf.ReadValue("bind","address",j) : ip; if (!ip.empty() || Conf.ReadValue("bind","type",j) == "servers") { if (!ip.empty() || ((IP != "*") && (IP != "127.0.0.1") && (!IP.empty()) && (IP != "::1"))) { /* The [2] is required because we may write a sockaddr_in6 here, and sockaddr_in6 is larger than sockaddr, where sockaddr_in4 is not. */ sockaddr* s = new sockaddr[2]; #ifdef IPV6 if (v6) { in6_addr n; if (inet_pton(AF_INET6, IP.c_str(), &n) > 0) { memcpy(&((sockaddr_in6*)s)->sin6_addr, &n, sizeof(sockaddr_in6)); ((sockaddr_in6*)s)->sin6_port = 0; ((sockaddr_in6*)s)->sin6_family = AF_INET6; size = sizeof(sockaddr_in6); } else { delete[] s; j++; continue; } } else #endif { in_addr n; if (inet_aton(IP.c_str(), &n) > 0) { ((sockaddr_in*)s)->sin_addr = n; ((sockaddr_in*)s)->sin_port = 0; ((sockaddr_in*)s)->sin_family = AF_INET; } else { delete[] s; j++; continue; } } if (bind(this->fd, s, size) < 0) { this->state = I_ERROR; this->OnError(I_ERR_BIND); this->fd = -1; delete[] s; return false; } delete[] s; return true; } } j++; } return true; }

void InspSocket::Close (   )  [virtual]

This method causes the socket to close, and may also be triggered by other methods such as OnTimeout and OnError. Definition at line 352 of file inspsocket.cpp. References InspIRCd::Config, DEFAULT, ServerConfig::GetIOHook(), CoreException::GetReason(), CoreException::GetSource(), I_LISTENING, Instance, InspIRCd::Log(), OnClose(), Module::OnRawSocketClose(), and InspIRCd::SocketCull. Referenced by DoConnect(), ModuleSpanningTree::DoPingChecks(), FlushWriteBuffer(), cmd_rsquit::Handle(), ModuleSpanningTree::HandleSquit(), TreeSocket::Inbound_Server(), InspSocket(), SpanningTreeUtilities::ReadConfiguration(), ~InspSocket(), and SpanningTreeUtilities::~SpanningTreeUtilities(). { /* Save this, so we dont lose it, * otherise on failure, error messages * might be inaccurate. */ int save = errno; if (this->fd > -1) { if (this->IsIOHooked && Instance->Config->GetIOHook(this)) { try { if (this->state != I_LISTENING) Instance->Config->GetIOHook(this)->OnRawSocketClose(this->fd); } catch (CoreException& modexcept) { Instance->Log(DEFAULT,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); } } shutdown(this->fd,2); if (close(this->fd) != -1) this->OnClose(); if (Instance->SocketCull.find(this) == Instance->SocketCull.end()) Instance->SocketCull[this] = this; } errno = save; }

bool InspSocket::DoConnect (   )  [virtual]

This method attempts to connect to a hostname. This only occurs on a non-listening socket. This method is asyncronous. Definition at line 242 of file inspsocket.cpp. References TimerManager::AddTimer(), Close(), EventHandler::fd, I_CONNECTING, I_ERR_CONNECT, I_ERR_NOMOREFDS, I_ERR_SOCKET, I_ERROR, Instance, OnError(), SetQueues(), state, InspIRCd::Time(), Timeout, timeout_val, and InspIRCd::Timers. { /* The [2] is required because we may write a sockaddr_in6 here, and sockaddr_in6 is larger than sockaddr, where sockaddr_in4 is not. */ sockaddr* addr = new sockaddr[2]; socklen_t size = sizeof(sockaddr_in); #ifdef IPV6 bool v6 = false; if ((!*this->host) || strchr(this->host, ':')) v6 = true; if (v6) { this->fd = socket(AF_INET6, SOCK_STREAM, 0); if ((this->fd > -1) && ((strstr(this->IP,"::ffff:") != (char*)&this->IP) && (strstr(this->IP,"::FFFF:") != (char*)&this->IP))) { if (!this->BindAddr(this->cbindip)) { delete[] addr; return false; } } } else #endif { this->fd = socket(AF_INET, SOCK_STREAM, 0); if (this->fd > -1) { if (!this->BindAddr(this->cbindip)) { delete[] addr; return false; } } } if (this->fd == -1) { this->state = I_ERROR; this->OnError(I_ERR_SOCKET); delete[] addr; return false; } #ifdef IPV6 if (v6) { in6_addr addy; if (inet_pton(AF_INET6, this->host, &addy) > 0) { ((sockaddr_in6*)addr)->sin6_family = AF_INET6; memcpy(&((sockaddr_in6*)addr)->sin6_addr, &addy, sizeof(addy)); ((sockaddr_in6*)addr)->sin6_port = htons(this->port); size = sizeof(sockaddr_in6); } } else #endif { in_addr addy; if (inet_aton(this->host, &addy) > 0) { ((sockaddr_in*)addr)->sin_family = AF_INET; ((sockaddr_in*)addr)->sin_addr = addy; ((sockaddr_in*)addr)->sin_port = htons(this->port); } } #ifndef WIN32 int flags = fcntl(this->fd, F_GETFL, 0); fcntl(this->fd, F_SETFL, flags | O_NONBLOCK); #else unsigned long flags = 0; ioctlsocket(this->fd, FIONBIO, &flags); #endif if (connect(this->fd, (sockaddr*)addr, size) == -1) { if (errno != EINPROGRESS) { this->OnError(I_ERR_CONNECT); this->Close(); this->state = I_ERROR; delete[] addr; return false; } this->Timeout = new SocketTimeout(this->GetFd(), this->Instance, this, timeout_val, this->Instance->Time()); this->Instance->Timers->AddTimer(this->Timeout); } #ifdef WIN32 /* Set nonblocking mode after the connect() call */ flags = 0; ioctlsocket(this->fd, FIONBIO, &flags); #endif this->state = I_CONNECTING; delete[] addr; if (this->fd > -1) { if (!this->Instance->SE->AddFd(this)) { this->OnError(I_ERR_NOMOREFDS); this->Close(); this->state = I_ERROR; return false; } this->SetQueues(this->fd); } return true; }

bool InspSocket::FlushWriteBuffer (   )

Flushes the write buffer. Definition at line 471 of file inspsocket.cpp. References Close(), InspIRCd::Config, DEBUG, SocketEngine::DelFd(), EventHandler::fd, ServerConfig::GetIOHook(), CoreException::GetReason(), CoreException::GetSource(), I_CONNECTED, I_ERR_WRITE, I_ERROR, Instance, length, InspIRCd::Log(), OnError(), Module::OnRawSocketWrite(), outbuffer, InspIRCd::SE, state, and SocketEngine::WantWrite(). Referenced by HttpServerSocket::Page(), TreeSocket::SendError(), HttpServerSocket::SendHeaders(), and HttpServerSocket::ServeData(). { errno = 0; if ((this->fd > -1) && (this->state == I_CONNECTED)) { if (this->IsIOHooked) { while (outbuffer.size() && (errno != EAGAIN)) { try { /* XXX: The lack of buffering here is NOT a bug, modules implementing this interface have to * implement their own buffering mechanisms */ Instance->Config->GetIOHook(this)->OnRawSocketWrite(this->fd, outbuffer[0].c_str(), outbuffer[0].length()); outbuffer.pop_front(); } catch (CoreException& modexcept) { Instance->Log(DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); return true; } } } else { /* If we have multiple lines, try to send them all, * not just the first one -- Brain */ while (outbuffer.size() && (errno != EAGAIN)) { /* Send a line */ #ifndef WIN32 int result = write(this->fd,outbuffer[0].c_str(),outbuffer[0].length()); #else int result = send(this->fd,outbuffer[0].c_str(),outbuffer[0].length(), 0); #endif if (result > 0) { if ((unsigned int)result >= outbuffer[0].length()) { /* The whole block was written (usually a line) * Pop the block off the front of the queue, * dont set errno, because we are clear of errors * and want to try and write the next block too. */ outbuffer.pop_front(); } else { std::string temp = outbuffer[0].substr(result); outbuffer[0] = temp; /* We didnt get the whole line out. arses. * Try again next time, i guess. Set errno, * because we shouldnt be writing any more now, * until the socketengine says its safe to do so. */ errno = EAGAIN; } } else if (result == 0) { this->Instance->SE->DelFd(this); this->Close(); return true; } else if ((result == -1) && (errno != EAGAIN)) { this->OnError(I_ERR_WRITE); this->state = I_ERROR; this->Instance->SE->DelFd(this); this->Close(); return true; } } } } if ((errno == EAGAIN) && (fd > -1)) { this->Instance->SE->WantWrite(this); } return (fd < 0); }

int InspSocket::GetFd (   )

This method returns the socket's file descriptor as assigned by the operating system, or -1 if no descriptor has been assigned. Reimplemented from EventHandler. Definition at line 694 of file inspsocket.cpp. References EventHandler::fd. Referenced by ModuleSpanningTree::ConnectServer(), HandshakeTimer::HandshakeTimer(), ServernameResolver::OnLookupComplete(), ModuleSSLOpenSSL::OnRequest(), and ModuleSSLGnuTLS::OnRequest(). { return this->fd; }

std::string InspSocket::GetIP (   )

Returns the IP address associated with this connection, or an empty string if no IP address exists. Definition at line 383 of file inspsocket.cpp. References IP. Referenced by TreeSocket::OnConnected(), and TreeSocket::SendError(). { return this->IP; }

InspSocketState InspSocket::GetState (   )

Returns the current socket state. Definition at line 689 of file inspsocket.cpp. References state. Referenced by SpanningTreeUtilities::ReadConfiguration(). { return this->state; }

void InspSocket::HandleEvent (  EventType  et, int  errornum = 0 )  [virtual]

Handle event from EventHandler parent class. Implements EventHandler. Definition at line 718 of file inspsocket.cpp. References EVENT_ERROR, EVENT_READ, EVENT_WRITE, I_CONNECTING, I_ERR_BIND, I_ERR_CONNECT, I_ERR_TIMEOUT, I_ERR_WRITE, Instance, OnError(), InspIRCd::SocketCull, and WaitingForWriteEvent. { switch (et) { case EVENT_ERROR: switch (errornum) { case ETIMEDOUT: this->OnError(I_ERR_TIMEOUT); break; case ECONNREFUSED: case 0: this->OnError(this->state == I_CONNECTING ? I_ERR_CONNECT : I_ERR_WRITE); break; case EADDRINUSE: this->OnError(I_ERR_BIND); break; case EPIPE: case EIO: this->OnError(I_ERR_WRITE); break; } if (this->Instance->SocketCull.find(this) == this->Instance->SocketCull.end()) this->Instance->SocketCull[this] = this; return; break; case EVENT_READ: if (!this->Poll()) { if (this->Instance->SocketCull.find(this) == this->Instance->SocketCull.end()) this->Instance->SocketCull[this] = this; return; } break; case EVENT_WRITE: if (this->WaitingForWriteEvent) { this->WaitingForWriteEvent = false; if (!this->OnWriteReady()) { if (this->Instance->SocketCull.find(this) == this->Instance->SocketCull.end()) this->Instance->SocketCull[this] = this; return; } } if (this->state == I_CONNECTING) { /* This might look wrong as if we should be actually calling * with EVENT_WRITE, but trust me it is correct. There are some * writeability-state things in the read code, because of how * InspSocket used to work regarding write buffering in previous * versions of InspIRCd. - Brain */ this->HandleEvent(EVENT_READ); return; } else { if (this->FlushWriteBuffer()) { if (this->Instance->SocketCull.find(this) == this->Instance->SocketCull.end()) this->Instance->SocketCull[this] = this; return; } } break; } }

void InspSocket::MarkAsClosed (   )

This method marks the socket closed. The next time the core examines a socket marked as closed, the socket will be closed and the memory reclaimed. NOTE: This method is DEPRECIATED and will be ignored if called! Definition at line 447 of file inspsocket.cpp. { }

void InspSocket::OnClose (   )  [virtual]

Whenever close() is called, OnClose() will be called first. Please note that this means OnClose will be called alongside OnError(), OnTimeout(), and Close(), and also when cancelling a listening socket by calling the destructor indirectly. Reimplemented in HttpServerSocket, and TreeSocket. Definition at line 706 of file inspsocket.cpp. Referenced by Close(). { return; }

bool InspSocket::OnConnected (   )  [virtual]

This method is called when an outbound connection on your socket is completed. Returns: false to abort the connection, true to continue Reimplemented in TreeSocket. Definition at line 699 of file inspsocket.cpp. Referenced by Poll(). { return true; }

bool InspSocket::OnDataReady (   )  [virtual]

When there is data waiting to be read on a socket, the OnDataReady() method is called. Within this method, you *MUST* call the Read() method to read any pending data. At its lowest level, this event is signalled by the core via the socket engine. If you return false from this function, the core removes your socket from its list and erases it from the socket engine, then calls InspSocket::Close() and deletes it. Returns: false to close the socket Reimplemented in HttpServerSocket, Notifier, and TreeSocket. Definition at line 703 of file inspsocket.cpp. Referenced by Poll(). { return true; }

int InspSocket::OnDisconnect (   )  [virtual]

When an established connection is terminated, the OnDisconnect method is triggered. Reimplemented in TreeSocket. Definition at line 701 of file inspsocket.cpp. { return 0; }

void InspSocket::OnError (  InspSocketError  e  )  [virtual]

This method is called when an error occurs. A closed socket in itself is not an error, however errors also generate close events. Parameters: e  The error type which occured Reimplemented in TreeSocket. Definition at line 700 of file inspsocket.cpp. Referenced by BindAddr(), DoConnect(), FlushWriteBuffer(), HandleEvent(), InspSocket(), SocketTimeout::Tick(), and ModuleSQLite3::~ModuleSQLite3(). { return; }

int InspSocket::OnIncomingConnection (  int  newfd, char *  ip )  [virtual]

If your socket is a listening socket, when a new connection comes in on the socket this method will be called. Given the new file descriptor in the parameters, and the IP, it is recommended you copy them to a new instance of your socket class, e.g.: MySocket* newsocket = new MySocket(newfd,ip); Once you have done this, you can then associate the new socket with the core using Server::AddSocket(). Reimplemented in HttpServerSocket, Notifier, ResultNotifier, and TreeSocket. Definition at line 702 of file inspsocket.cpp. Referenced by Poll(). { return 0; }

void InspSocket::OnTimeout (   )  [virtual]

When an outbound connection fails, and the attempt times out, you will receive this event. The method will trigger once maxtime seconds are reached (as given in the constructor) just before the socket's descriptor is closed. A failed DNS lookup may cause this event if the DNS server is not responding, as well as a failed connect() call, because DNS lookups are nonblocking as implemented by this class. Reimplemented in TreeSocket. Definition at line 705 of file inspsocket.cpp. Referenced by SocketTimeout::Tick(). { return; }

bool InspSocket::OnWriteReady (   )  [virtual]

When it is ok to write to the socket, and a write event was requested, this method is triggered. Within this method you should call write() or send() etc, to send data to the other end of the socket. Further write events will not be triggered unless you call WantWrite(). Returns: false to close the socket Reimplemented in HttpServerSocket. Definition at line 704 of file inspsocket.cpp. { return true; }

bool InspSocket::Poll (   )

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 InspSocket for you to handle. This can also cause the socket's state to change. Definition at line 585 of file inspsocket.cpp. References _accept, InspIRCd::Config, DEBUG, SocketEngine::DelFd(), EventHandler::fd, ServerConfig::GetIOHook(), CoreException::GetReason(), SocketEngine::GetRef(), CoreException::GetSource(), I_CONNECTED, I_CONNECTING, I_LISTENING, Instance, length, InspIRCd::Log(), MAX_DESCRIPTORS, irc::sockets::NonBlocking(), OnConnected(), OnDataReady(), OnIncomingConnection(), Module::OnRawSocketAccept(), Module::OnRawSocketConnect(), port, InspIRCd::SE, SetQueues(), and SetState(). { #ifdef WINDOWS if(Instance->SE->GetRef(this->fd) != this) return false; int incoming = -1; #else if (this->Instance->SE->GetRef(this->fd) != this) return false; int incoming = -1; if ((fd < 0) || (fd > MAX_DESCRIPTORS)) return false; #endif switch (this->state) { case I_CONNECTING: /* Our socket was in write-state, so delete it and re-add it * in read-state. */ #ifndef WINDOWS if (this->fd > -1) { this->Instance->SE->DelFd(this); this->SetState(I_CONNECTED); if (!this->Instance->SE->AddFd(this)) return false; } #else this->SetState(I_CONNECTED); #endif Instance->Log(DEBUG,"Inspsocket I_CONNECTING state"); if (Instance->Config->GetIOHook(this)) { Instance->Log(DEBUG,"Hook for raw connect"); try { Instance->Config->GetIOHook(this)->OnRawSocketConnect(this->fd); } catch (CoreException& modexcept) { Instance->Log(DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); } } return this->OnConnected(); break; case I_LISTENING: { /* The [2] is required because we may write a sockaddr_in6 here, and sockaddr_in6 is larger than sockaddr, where sockaddr_in4 is not. */ sockaddr* client = new sockaddr[2]; length = sizeof (sockaddr_in); std::string recvip; #ifdef IPV6 if ((!*this->host) || strchr(this->host, ':')) length = sizeof(sockaddr_in6); #endif incoming = _accept (this->fd, client, &length); #ifdef IPV6 if ((!*this->host) || strchr(this->host, ':')) { char buf[1024]; recvip = inet_ntop(AF_INET6, &((sockaddr_in6*)client)->sin6_addr, buf, sizeof(buf)); } else #endif recvip = inet_ntoa(((sockaddr_in*)client)->sin_addr); this->OnIncomingConnection(incoming, (char*)recvip.c_str()); NonBlocking(incoming); if (this->IsIOHooked) { try { Instance->Config->GetIOHook(this)->OnRawSocketAccept(incoming, recvip.c_str(), this->port); } catch (CoreException& modexcept) { Instance->Log(DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); } } this->SetQueues(incoming); delete[] client; return true; } break; case I_CONNECTED: /* Process the read event */ return this->OnDataReady(); break; default: break; } return true; }

char * InspSocket::Read (   )  [virtual]

Reads all pending bytes from the socket into a char* array which can be up to 16 kilobytes in length. Definition at line 388 of file inspsocket.cpp. References InspIRCd::Config, DEFAULT, EventHandler::fd, ServerConfig::GetIOHook(), CoreException::GetReason(), CoreException::GetSource(), ibuf, Instance, InspIRCd::Log(), MAX_DESCRIPTORS, and Module::OnRawSocketRead(). Referenced by TreeSocket::OnDataReady(), and HttpServerSocket::OnDataReady(). { #ifdef WINDOWS if ((fd < 0) || (m_internalFd > MAX_DESCRIPTORS)) #else if ((fd < 0) || (fd > MAX_DESCRIPTORS)) #endif return NULL; int n = 0; if (this->IsIOHooked) { int result2 = 0; int MOD_RESULT = 0; try { MOD_RESULT = Instance->Config->GetIOHook(this)->OnRawSocketRead(this->fd,this->ibuf,sizeof(this->ibuf) - 1,result2); } catch (CoreException& modexcept) { Instance->Log(DEFAULT,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); } if (MOD_RESULT < 0) { n = -1; errno = EAGAIN; } else { n = result2; } } else { n = recv(this->fd,this->ibuf,sizeof(this->ibuf) - 1,0); } /* * This used to do some silly bounds checking instead of just passing bufsize - 1 to recv. * Not only does that make absolutely no sense, but it could potentially result in a read buffer's worth * of data being thrown into the bit bucket for no good reason, which is just *stupid*.. do things correctly now. * --w00t (july 2, 2008) */ if (n > 0) { ibuf[n] = 0; return ibuf; } else { int err = errno; if (err == EAGAIN) return ""; else return NULL; } }

bool InspSocket::Readable (   )  [virtual]

Returns true if this socket is readable. Reimplemented from EventHandler. Definition at line 23 of file inspsocket.cpp. References I_CONNECTING. { return ((this->state != I_CONNECTING) && (this->WaitingForWriteEvent == false)); }

void InspSocket::SetQueues (  int  nfd  )

Set the queue sizes This private method sets the operating system queue sizes for this socket to 65535 so that it can queue more information without application-level queueing which was required in older software. Definition at line 148 of file inspsocket.cpp. Referenced by DoConnect(), and Poll(). { // attempt to increase socket sendq and recvq as high as its possible int sendbuf = 32768; int recvbuf = 32768; if(setsockopt(nfd,SOL_SOCKET,SO_SNDBUF,(const char *)&sendbuf,sizeof(sendbuf)) || setsockopt(nfd,SOL_SOCKET,SO_RCVBUF,(const char *)&recvbuf,sizeof(sendbuf))) { //this->Instance->Log(DEFAULT, "Could not increase SO_SNDBUF/SO_RCVBUF for socket %u", GetFd()); // per 1.2 change, commenting this out .. sick of people trying to interpret this } }

void InspSocket::SetState (  InspSocketState  s  )

Changes the socket's state. The core uses this to change socket states, and you should not call it directly. Definition at line 684 of file inspsocket.cpp. References state. Referenced by Poll(). { this->state = s; }

void InspSocket::WantWrite (   )

Call this to receive the next write event that comes along for this fd to the OnWriteReady method. Definition at line 142 of file inspsocket.cpp. References Instance, InspIRCd::SE, WaitingForWriteEvent, and SocketEngine::WantWrite(). { this->Instance->SE->WantWrite(this); this->WaitingForWriteEvent = true; }

void InspSocket::Write (  const std::string &  data  )  [virtual]

Writes a std::string to the socket. No carriage returns or linefeeds are appended to the string. Parameters: data  The data to send Definition at line 463 of file inspsocket.cpp. References Instance, outbuffer, InspIRCd::SE, and SocketEngine::WantWrite(). Referenced by HttpServerSocket::Page(), HttpServerSocket::SendHeaders(), HttpServerSocket::ServeData(), and TreeSocket::WriteLine(). { /* Try and append the data to the back of the queue, and send it on its way */ outbuffer.push_back(data); this->Instance->SE->WantWrite(this); }

---

Member Data Documentation

std::string InspSocket::cbindip

Bind IP. Definition at line 119 of file inspsocket.h. Referenced by InspSocket().

bool InspSocket::ClosePending

When the socket has been marked as closing, this flag will be set to true, then the next time the socket is examined, the socket is deleted and closed. Definition at line 208 of file inspsocket.h. Referenced by InspSocket(), and ModuleSQLite3::~ModuleSQLite3().

char InspSocket::host[MAXBUF]

The hostname connected to. Definition at line 149 of file inspsocket.h. Referenced by InspSocket().

char InspSocket::ibuf[65535]

Socket input buffer, used by read(). The class which extends InspSocket is expected to implement an extendable buffer which can grow much larger than 64k, this buffer is just designed to be temporary storage. space. Definition at line 177 of file inspsocket.h. Referenced by Read().

InspIRCd* InspSocket::Instance

Instance we were created by. Definition at line 129 of file inspsocket.h. Referenced by TreeSocket::AddLine(), TreeSocket::Admin(), TreeSocket::Capab(), TreeSocket::ChangeHost(), TreeSocket::ChangeName(), Close(), TreeSocket::ComparePass(), TreeSocket::DoBurst(), DoConnect(), TreeSocket::Error(), FlushWriteBuffer(), TreeSocket::ForceJoin(), TreeSocket::ForceMode(), TreeSocket::ForceNick(), TreeSocket::ForceTopic(), HandleEvent(), TreeSocket::HandleSetTime(), TreeSocket::Inbound_Server(), InspSocket(), TreeSocket::IntroduceClient(), TreeSocket::LocalPong(), TreeSocket::MakePass(), TreeSocket::MetaData(), TreeSocket::Modules(), TreeSocket::Motd(), TreeSocket::MyCapabilities(), TreeSocket::OnClose(), TreeSocket::OnConnected(), TreeSocket::OnIncomingConnection(), TreeSocket::OperQuit(), TreeSocket::OperType(), TreeSocket::Outbound_Reply_Server(), Poll(), TreeSocket::ProcessLine(), TreeSocket::Push(), Read(), TreeSocket::RemoteKill(), TreeSocket::RemoteRehash(), TreeSocket::RemoteServer(), TreeSocket::RemoveStatus(), TreeSocket::SendCapabilities(), TreeSocket::SendChannelModes(), TreeSocket::SendFJoins(), HttpServerSocket::SendHeaders(), TreeSocket::SendUsers(), TreeSocket::SendXLines(), TreeSocket::ServiceJoin(), TreeSocket::ServicePart(), HttpServerSocket::SetWrite(), TreeSocket::Squit(), TreeSocket::Stats(), TreeSocket::Time(), TreeSocket::TreeSocket(), WantWrite(), TreeSocket::Whois(), Write(), TreeSocket::WriteLine(), and ~InspSocket().

char InspSocket::IP[MAXBUF]

The IP address being connected to stored in string form for easy retrieval by accessors. Definition at line 184 of file inspsocket.h. Referenced by BindAddr(), and GetIP().

bool InspSocket::IsIOHooked

Is hooked by a module for low level IO. Definition at line 124 of file inspsocket.h. Referenced by ServerConfig::AddIOHook(), and InspSocket().

socklen_t InspSocket::length

Used by accept() to indicate the sizes of the sockaddr_in structures. Definition at line 190 of file inspsocket.h. Referenced by FlushWriteBuffer(), TreeSocket::IntroduceClient(), and Poll().

std::deque<std::string> InspSocket::outbuffer

Socket output buffer (binary safe). Definition at line 144 of file inspsocket.h. Referenced by FlushWriteBuffer(), and Write().

int InspSocket::port

The port connected to, or the port this socket is listening on. Definition at line 155 of file inspsocket.h. Referenced by InspSocket(), and Poll().

InspSocketState InspSocket::state

The state for this socket, either listening, connecting, connected or error. Definition at line 162 of file inspsocket.h. Referenced by BindAddr(), DoConnect(), FlushWriteBuffer(), GetState(), InspSocket(), SetState(), SocketTimeout::Tick(), and ModuleSQLite3::~ModuleSQLite3().

bool InspSocket::timeout

This value is true if the socket has timed out. Definition at line 168 of file inspsocket.h. Referenced by SocketTimeout::Tick().

SocketTimeout* InspSocket::Timeout

Timeout class or NULL. Definition at line 134 of file inspsocket.h. Referenced by DoConnect(), InspSocket(), SocketTimeout::Tick(), and ~InspSocket().

unsigned long InspSocket::timeout_val

Timeout length. Definition at line 139 of file inspsocket.h. Referenced by DoConnect(), and InspSocket().

bool InspSocket::WaitingForWriteEvent

Set to true when we're waiting for a write event. If this is true and a write event comes in, we call the write instead of the read method. Definition at line 214 of file inspsocket.h. Referenced by HandleEvent(), InspSocket(), HttpServerSocket::SetWrite(), and WantWrite().

---

The documentation for this class was generated from the following files:

• inspsocket.h
• inspsocket.cpp