bool BufferedSocket::Readable()
{
- return ((this->state != I_CONNECTING) && (this->WaitingForWriteEvent == false));
+ return (this->state != I_CONNECTING);
}
BufferedSocket::BufferedSocket(InspIRCd* SI)
this->Timeout = NULL;
this->state = I_DISCONNECTED;
this->fd = -1;
- this->WaitingForWriteEvent = false;
this->Instance = SI;
}
this->fd = newfd;
this->state = I_CONNECTED;
strlcpy(this->IP,ip,MAXBUF);
- this->WaitingForWriteEvent = false;
this->Instance = SI;
if (this->fd > -1)
this->Instance->SE->AddFd(this);
this->fd = -1;
this->Instance = SI;
strlcpy(host,ipaddr.c_str(),MAXBUF);
- this->WaitingForWriteEvent = false;
this->Timeout = NULL;
strlcpy(this->host,ipaddr.c_str(),MAXBUF);
else
{
strlcpy(this->IP,host,MAXBUF);
- timeout_val = maxtime;
- if (!this->DoConnect())
+ if (!this->DoConnect(maxtime))
{
this->OnError(I_ERR_CONNECT);
this->Close();
}
}
-void BufferedSocket::WantWrite()
-{
- this->Instance->SE->WantWrite(this);
- this->WaitingForWriteEvent = true;
-}
-
-void BufferedSocket::SetQueues(int nfd)
+void BufferedSocket::SetQueues()
{
// 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)))
+ if(setsockopt(this->fd,SOL_SOCKET,SO_SNDBUF,(const char *)&sendbuf,sizeof(sendbuf)) || setsockopt(this->fd,SOL_SOCKET,SO_RCVBUF,(const char *)&recvbuf,sizeof(sendbuf)))
{
//this->Instance->Log(DEFAULT, "Could not increase SO_SNDBUF/SO_RCVBUF for socket %u", GetFd());
; // do nothing. I'm a little sick of people trying to interpret this message as a result of why their incorrect setups don't work.
return true;
}
-bool BufferedSocket::DoConnect()
+bool BufferedSocket::DoConnect(unsigned long maxtime)
{
/* 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];
Instance->SE->NonBlocking(this->fd);
-#ifdef WIN32
- /* UGH for the LOVE OF ZOMBIE JESUS SOMEONE FIX THIS!!!!!!!!!!! */
- Instance->SE->Blocking(this->fd);
-#endif
-
if (Instance->SE->Connect(this, (sockaddr*)addr, size) == -1)
{
if (errno != EINPROGRESS)
return false;
}
- this->Timeout = new SocketTimeout(this->GetFd(), this->Instance, this, timeout_val, this->Instance->Time());
+ this->Timeout = new SocketTimeout(this->GetFd(), this->Instance, this, maxtime, this->Instance->Time());
this->Instance->Timers->AddTimer(this->Timeout);
}
-#ifdef WIN32
- /* CRAQ SMOKING STUFF TO BE FIXED */
- Instance->SE->NonBlocking(this->fd);
-#endif
+
this->state = I_CONNECTING;
if (this->fd > -1)
{
this->state = I_ERROR;
return false;
}
- this->SetQueues(this->fd);
+ this->SetQueues();
}
Instance->Logs->Log("SOCKET", DEBUG,"BufferedSocket::DoConnect success");
// connection.
this->sock->OnTimeout();
this->sock->OnError(I_ERR_TIMEOUT);
- this->sock->timeout = true;
/* NOTE: We must set this AFTER DelFd, as we added
* this socket whilst writeable. This means that we
this->sock->Timeout = NULL;
}
-bool BufferedSocket::Poll()
+bool BufferedSocket::InternalMarkConnected()
{
-#ifndef WINDOWS
- if (!Instance->SE->BoundsCheckFd(this))
- return false;
-#endif
-
- if (Instance->SE->GetRef(this->fd) != this)
- return false;
+ /* Our socket was in write-state, so delete it and re-add it
+ * in read-state.
+ */
+ this->SetState(I_CONNECTED);
- switch (this->state)
+ if (this->GetIOHook())
{
- 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);
- if (!this->Instance->SE->AddFd(this))
- return false;
- }
-#endif
- this->SetState(I_CONNECTED);
-
- if (this->GetIOHook())
- {
- Instance->Logs->Log("SOCKET",DEBUG,"Hook for raw connect");
- try
- {
- this->GetIOHook()->OnRawSocketConnect(this->fd);
- }
- catch (CoreException& modexcept)
- {
- Instance->Logs->Log("SOCKET",DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason());
- }
- }
- return this->OnConnected();
- break;
- case I_CONNECTED:
- /* Process the read event */
- return this->OnDataReady();
- break;
- default:
- break;
+ Instance->Logs->Log("SOCKET",DEBUG,"Hook for raw connect");
+ try
+ {
+ this->GetIOHook()->OnRawSocketConnect(this->fd);
+ }
+ catch (CoreException& modexcept)
+ {
+ Instance->Logs->Log("SOCKET",DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason());
+ return false;
+ }
}
- return true;
+ return this->OnConnected();
}
void BufferedSocket::SetState(BufferedSocketState s)
return this->state;
}
-int BufferedSocket::GetFd()
-{
- return this->fd;
-}
-
bool BufferedSocket::OnConnected() { return true; }
void BufferedSocket::OnError(BufferedSocketError) { return; }
int BufferedSocket::OnDisconnect() { return 0; }
bool BufferedSocket::OnDataReady() { return true; }
-bool BufferedSocket::OnWriteReady() { return true; }
+bool BufferedSocket::OnWriteReady()
+{
+ // Default behaviour: just try write some.
+ return !this->FlushWriteBuffer();
+}
void BufferedSocket::OnTimeout() { return; }
void BufferedSocket::OnClose() { return; }
switch (et)
{
case EVENT_ERROR:
+ {
switch (errornum)
{
case ETIMEDOUT:
this->OnError(I_ERR_TIMEOUT);
- break;
+ break;
case ECONNREFUSED:
case 0:
this->OnError(this->state == I_CONNECTING ? I_ERR_CONNECT : I_ERR_WRITE);
- break;
+ break;
case EADDRINUSE:
this->OnError(I_ERR_BIND);
- break;
+ break;
case EPIPE:
case EIO:
this->OnError(I_ERR_WRITE);
- break;
+ break;
}
+
if (this->Instance->SocketCull.find(this) == this->Instance->SocketCull.end())
this->Instance->SocketCull[this] = this;
return;
- break;
+ break;
+ }
case EVENT_READ:
- if (!this->Poll())
+ {
+ if (!this->OnDataReady())
{
if (this->Instance->SocketCull.find(this) == this->Instance->SocketCull.end())
this->Instance->SocketCull[this] = this;
return;
}
- break;
+ break;
+ }
case EVENT_WRITE:
- if (this->WaitingForWriteEvent)
+ {
+ if (this->state == I_CONNECTING)
{
- this->WaitingForWriteEvent = false;
- if (!this->OnWriteReady())
+ if (!this->InternalMarkConnected())
{
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
- * BufferedSocket used to work regarding write buffering in previous
- * versions of InspIRCd. - Brain
- */
- this->HandleEvent(EVENT_READ);
return;
}
else
{
- if (this->FlushWriteBuffer())
+ if (!this->OnWriteReady())
{
if (this->Instance->SocketCull.find(this) == this->Instance->SocketCull.end())
this->Instance->SocketCull[this] = this;
return;
}
}
- break;
+ break;
+ }
}
}
projects / user / henk / code / inspircd.git / blobdiff