/*
====================
IRC_Frame
Called every host frame.
Used to poll IRC connections.
====================
*/
void IRC_Frame(void) {
struct timeval tv;
fd_set in, out;
int maxfd = 0;
int i, err;
if(!irc_initialized.integer || !irc_enabled.integer)
return;
tv.tv_usec = 0;
tv.tv_sec = 0;
FD_ZERO(&in);
FD_ZERO(&out);
FOR_ACTIVE_IRC_SESSIONS(i)
irc_add_select_descriptors(irc_sessions[i].session, &in, &out, &maxfd);
select(maxfd + 1, &in, &out, 0, &tv);
FOR_ACTIVE_IRC_SESSIONS(i)
if(irc_process_select_descriptors(irc_sessions[i].session, &in, &out)) {
err = irc_errno(irc_sessions[i].session);
if(err)
IRC_Printf("Error on session %i: %s\n", i, irc_strerror(err));
}
}
int irc_run(irc_session_t * session) {
if (session->state != LIBIRC_STATE_CONNECTING) {
session->lasterror = LIBIRC_ERR_STATE;
return 1;
}
while (irc_is_connected(session)) {
const long timeout_ms = 750;
fdwatch_zero();
fdwatch_add_fd(session->sock);
irc_add_select_descriptors(session);
if (fdwatch(timeout_ms) < 0) {
if (socket_error() == EINTR)
continue;
session->lasterror = LIBIRC_ERR_TERMINATED;
return 1;
}
if (session->callbacks.keep_alive_callback) {
session->callbacks.keep_alive_callback(session);
}
if (irc_process_select_descriptors(session))
return 1;
}
return 0;
}
void ServerState::prepareConnecting(Server &server, fd_set &setinput, fd_set &setoutput, int &maxfd)
{
/*
* The connect function will either fail if the hostname wasn't resolved
* or if any of the internal functions fail.
*
* It returns success if the connection was successful but it does not
* mean that connection is established.
*
* Because this function will be called repeatidly from the
* ServerManager, if the connection was started and we're still not
* connected in the specified timeout time, we mark the server
* as disconnected.
*
* Otherwise, the libircclient event_connect will change the state.
*/
const ServerInfo &info = server.info();
if (m_started) {
const ServerSettings &settings = server.settings();
if (m_timer.elapsed() > static_cast<unsigned>(settings.recotimeout * 1000)) {
Logger::warning() << "server " << info.name << ": timeout while connecting" << std::endl;
server.next(ServerState::Disconnected);
} else if (!irc_is_connected(server.session())) {
Logger::warning() << "server " << info.name << ": error while connecting: "
<< irc_strerror(irc_errno(server.session())) << std::endl;
if (settings.recotimeout > 0) {
Logger::warning() << "server " << info.name << ": retrying in " << settings.recotimeout << " seconds" << std::endl;
}
server.next(ServerState::Disconnected);
} else {
irc_add_select_descriptors(server.session(), &setinput, &setoutput, &maxfd);
}
} else {
/*
* This is needed if irccd is started before DHCP or if
* DNS cache is outdated.
*
* For more information see bug #190.
*/
#if !defined(_WIN32)
(void)res_init();
#endif
Logger::info() << "server " << info.name << ": trying to connect to " << info.host << ", port " << info.port << std::endl;
if (!connect(server)) {
Logger::warning() << "server " << info.name << ": disconnected while connecting: "
<< irc_strerror(irc_errno(server.session())) << std::endl;
server.next(ServerState::Disconnected);
} else {
m_started = true;
}
}
}
void ServerState::prepareConnected(Server &server, fd_set &setinput, fd_set &setoutput, int &maxfd)
{
if (!irc_is_connected(server.session())) {
const ServerSettings &settings = server.settings();
Logger::warning() << "server " << server.info().name << ": disconnected" << std::endl;
if (settings.recotimeout > 0) {
Logger::warning() << "server " << server.info().name << ": retrying in "
<< settings.recotimeout << " seconds" << std::endl;
}
server.next(ServerState::Disconnected);
} else {
irc_add_select_descriptors(server.session(), &setinput, &setoutput, &maxfd);
}
}
int irc_run (irc_session_t * session)
{
if ( session->state != LIBIRC_STATE_CONNECTING )
{
session->lasterror = LIBIRC_ERR_STATE;
return 1;
}
while ( irc_is_connected(session) )
{
struct timeval tv;
fd_set in_set, out_set;
int maxfd = 0;
tv.tv_usec = 250000;
tv.tv_sec = 0;
// Init sets
FD_ZERO (&in_set);
FD_ZERO (&out_set);
irc_add_select_descriptors (session, &in_set, &out_set, &maxfd);
if ( select (maxfd + 1, &in_set, &out_set, 0, &tv) < 0 )
{
if ( socket_error() == EINTR )
continue;
session->lasterror = LIBIRC_ERR_TERMINATED;
return 1;
}
if ( irc_process_select_descriptors (session, &in_set, &out_set) )
return 1;
}
return 0;
}
void IRCSelect() {
// Make sure that all the IRC sessions are connected
if( !irc_is_connected( sysconfig.irc_session ) ) {
return;
}
// Create the structures for select()
struct timeval tv;
fd_set in_set, out_set;
int maxfd = 0;
// Wait 0.25 sec for the events
tv.tv_usec = 250000;
tv.tv_sec = 0;
// Initialize the sets
FD_ZERO (&in_set);
FD_ZERO (&out_set);
// Add the IRC session descriptors - call irc_add_select_descriptors() for each active session
irc_add_select_descriptors( sysconfig.irc_session, &in_set, &out_set, &maxfd );
// Call select()
if( ( select(maxfd + 1, &in_set, &out_set, 0, &tv) < 0 ) && ( sysconfig.shutdown == false ) ) {
error("IRC Select error");
return;
}
// Call irc_process_select_descriptors() for each session with the descriptor set
if ( irc_process_select_descriptors(sysconfig.irc_session, &in_set, &out_set) && ( sysconfig.shutdown == false ) ) {
error("IRC Session Error");
}
return;
}
wxThread::ExitCode CslIrcThread::Entry()
{
int maxfd,error;
struct timeval timeout;
fd_set readSet,writeSet;
CslIrcContext *context=NULL;
wxInt32 pos=0,count=0,termcount=10;
m_mutex.Lock();
while (termcount)
{
if (m_terminate)
termcount--;
m_section.Enter();
count=m_contexts.GetCount();
if (count)
context=m_contexts.Item((pos=pos+1>=count ? 0:pos+1));
else
context=NULL;
m_section.Leave();
if (!context)
{
if (!m_terminate)
m_condition->Wait();
continue;
}
if (!context->Disconnecting && !irc_is_connected(context->Session))
{
if (irc_connect(context->Session,U2A(context->Server->Address),
context->Server->Port,NULL,U2A(context->Server->Network->Nick),
U2A(CSL_NAME_SHORT_STR),NULL))
{
LibIrcError(context,irc_errno(context->Session));
continue;
}
}
FD_ZERO(&readSet);
FD_ZERO(&writeSet);
timeout.tv_sec=0;
timeout.tv_usec=max(50000,200000/count);
maxfd=0;
irc_add_select_descriptors(context->Session,&readSet,&writeSet,&maxfd);
if (select(maxfd+1,&readSet,&writeSet,NULL,&timeout)<0)
{
LOG_DEBUG("select failed: %s\n",strerror(errno));
if (errno==EINTR)
continue;
}
if (irc_process_select_descriptors(context->Session,&readSet,&writeSet))
if ((error=irc_errno(context->Session)))
LibIrcError(context,error);
}
m_mutex.Unlock();
return 0;
}
void dazeus::Server::addDescriptors(fd_set *in_set, fd_set *out_set, int *maxfd) {
irc_add_select_descriptors(IRC, in_set, out_set, maxfd);
}
static int
add_select(module_t *module, fd_set *in_set, fd_set *out_set, int *maxfd) {
irc_t *irc = (irc_t *)module;
return irc_add_select_descriptors(irc->session, in_set, out_set, maxfd);
}
// Functions wrapping select statements
void IRCSession::add_select_descriptors(fd_set* in_set, fd_set* out_set, int* maxfd) {
if (irc_add_select_descriptors(session, in_set, out_set, maxfd))
throw std::runtime_error{"Could not add select descriptors; session not connected."};
}
