int autoconnect(fd_set *master, int *fdmax, servlist *serv) // XXX broken in the face of asynch nl [I have forgotten what was meant by this; I'm not aware of anything broken about this function]
{
servlist *curr=serv;
if(!curr) return(0);
#if ASYNCH_NL
char cstr[36+strlen(serv->name)+strlen(serv->portno)];
sprintf(cstr, "Connecting to %s on port %s...", serv->name, serv->portno);
nl_list *list=irc_connect(serv->name, serv->portno);
if(!list) return(autoconnect(master, fdmax, serv->next));
add_to_buffer(0, STA, QUIET, 0, false, cstr, "auto: ");
list->reconn_b=0;
list->autoent=serv;
#else /* ASYNCH_NL */
char cstr[36+strlen(serv->name)+strlen(serv->portno)];
sprintf(cstr, "Connecting to %s on port %s...", serv->name, serv->portno);
add_to_buffer(0, STA, QUIET, 0, false, cstr, "auto: ");
int serverhandle=irc_connect(serv->name, serv->portno, master, fdmax);
if(serverhandle)
{
bufs=(buffer *)realloc(bufs, ++nbufs*sizeof(buffer));
cbuf=nbufs-1;
init_buffer(cbuf, SERVER, serv->name, buflines);
bufs[cbuf].handle=serverhandle;
bufs[cbuf].nick=strdup(serv->nick);
bufs[cbuf].autoent=serv;
if(serv) bufs[cbuf].ilist=n_dup(serv->igns);
bufs[cbuf].server=cbuf;
bufs[cbuf].conninpr=true;
add_to_buffer(cbuf, STA, QUIET, 0, false, cstr, "auto: ");
redraw_buffer();
}
#endif /* ASYNCH_NL */
autoconnect(master, fdmax, serv->next);
return(1);
}
void *ircbot_connect() {
char *list[] = { "IRC Host", "IRC Port", "IRC Bot Nick" };
ConfigArrayPtr settings;
if( ircbot_prepare() ) {
sysconfig.irc_enabled = false;
sysconfig.irc_session = NULL;
goto EXIT;
}
// Initiate the IRC server connection
settings = ListSettings( list );
if ( irc_connect( sysconfig.irc_session, settings[0].string_value, (int)settings[1].num_value, 0, settings[2].string_value, settings[2].string_value, settings[2].string_value ) ) {
sysconfig.irc_enabled = false;
sysconfig.irc_session = NULL;
error("Connecting to IRC Network");
free( settings );
goto EXIT;
}
free( settings );
#if MULTI_THREAD_SUPPORT
irc_run( sysconfig.irc_session );
#endif
EXIT:
return NULL;
}
/*
====================
IRC_ConnectSession
Connects a session handle created by IRC_CreateSession to an IRC server.
Returns 0 on success, -1 on invalid handle, error code on libircclient error.
====================
*/
int IRC_ConnectSession(int handle, const char *server, unsigned short port, const char *server_password, const char *nick, const char *username, const char *realname) {
irc_session_t *s;
int err;
if(!IS_VALID_IRC_SESSION(handle)) {
IRC_Printf("Attempted to connect an invalid session %i\n", handle);
return -1;
}
if(IRC_SessionIsConnected(handle))
IRC_DisconnectSession(handle, "Changing server");
s = &irc_sessions[handle];
strlcpy(s->server, server, sizeof(s->server));
strlcpy(s->nick, nick, sizeof(s->nick));
strlcpy(s->username, username, sizeof(s->username));
strlcpy(s->realname, realname, sizeof(s->realname));
if(server_password)
strlcpy(s->password, server_password, sizeof(s->password));
else
memset(s->password, 0, sizeof(s->password));
irc_disconnect(s->session);
if(irc_connect(s->session, server, port, server_password, nick, username, realname)) {
err = irc_errno(s->session);
IRC_Printf("Connection error on session %i: %s\n", handle, irc_strerror(err));
return err;
}
return 0;
}
int main(int argc, char **argv) {
char* server, *port;
if (argc != 3) {
printf("Usage: %s <server> <port>\n", argv[0]);
exit(EXIT_FAILURE);
}
server = argv[1]; /* The IRC server */
port = argv[2]; /* The IRC server port */
/* Bind message commands to custom functions */
irc_bind_command("!op", (Callback) give_op);
irc_bind_command("!deop", (Callback) take_op);
irc_bind_command("!voice", (Callback) give_voice);
irc_bind_command("!devoice", (Callback) take_voice);
/* Connect, login and join the configured channel */
irc_connect(server, port);
irc_login(CONF_NICK, "Circus", "Circus IRC bot");
irc_join(CONF_CHAN);
/* Start listening to events.
* This method blocks until a quit signal is received */
irc_listen();
/* Send quit message and close connection */
irc_quit("Bye");
irc_disconnect();
return 0;
}
bool ServerState::connect(Server &server)
{
const ServerInfo &info = server.info();
const ServerIdentity &identity = server.identity();
const char *password = info.password.empty() ? nullptr : info.password.c_str();
std::string host = info.host;
int code;
// libircclient requires # for SSL connection
if (info.ssl) {
host.insert(0, 1, '#');
}
if (info.ipv6) {
code = irc_connect6(server.session(), host.c_str(), info.port, password,
identity.nickname.c_str(),
identity.username.c_str(),
identity.realname.c_str());
} else {
code = irc_connect(server.session(), host.c_str(), info.port, password,
identity.nickname.c_str(),
identity.username.c_str(),
identity.realname.c_str());
}
return code == 0;
}
int main(int argc, char **argv) {
char* server, *port;
if (argc != 3) {
printf("Usage: %s <server> <port>\n", argv[0]);
exit(EXIT_FAILURE);
}
server = argv[1]; /* The IRC server */
port = argv[2]; /* The IRC server port */
/* Bind IRC event to custom functions.
* All bindable events are defined in codes.h */
irc_bind_event(ERR_NICKNAMEINUSE, (Callback) on_nick_in_use);
irc_bind_event(ERROR, (Callback) on_error);
irc_bind_event(JOIN, (Callback) on_join);
irc_bind_event(ALL, (Callback) on_message);
/* Connect, login and join the configured channel */
irc_connect(server, port);
irc_login(CONF_NICK, "Circus", "Circus IRC bot");
irc_join(CONF_CHAN);
/* Start listening to events.
* This method blocks until a quit signal is received */
irc_listen();
/* Send quit message and close connection */
irc_quit("Bye");
irc_disconnect();
return 0;
}
int wxLIRCCSession::Connect( const wxString& server, unsigned short port,
const wxString& server_password, const wxString& nickname,
const wxString& username, const wxString& realname )
{
m_port = port;
m_nick = nickname.mb_str();
m_server = server.mb_str();
username.IsEmpty() ? m_user = 0 : m_user = username.mb_str();
realname.IsEmpty() ? m_name = 0 : m_user = realname.mb_str();
server_password.IsEmpty() ? m_svrpwd = 0 : m_svrpwd = server_password.mb_str();
m_eState = CONNECTING;
wxLogDebug("<wxLIRCCSession::Connect> Connecting");
int retcode = irc_connect( this->handle, m_server, port, m_svrpwd,
m_nick, m_user, m_name );
if ( retcode == 0 )
{
m_eState = CONNECTED;
wxLogDebug("<wxLIRCCSession::Connect> Connected");
}
else
{
m_eState = DISCONNECTED;
wxLogDebug("<wxLIRCCSession::Connect> Disconnected (retcode = %i)", retcode );
}
return retcode;
}
int main(int argc, char *argv[]) {
Irc freenode;
struct pollfd pfd[4];
int i, ready, murm_listenfd = -1;
initialize(argc, argv);
for (i = 0; i < SIZE(pfd); i++) {
pfd[i].fd = -1;
pfd[i].events = POLLIN;
}
if (add_murmur_callbacks(cfg.murmur_port))
pfd[MURM_LISTEN].fd = murm_listenfd = sock_listen(LOCALHOST, CB_LISTEN_PORT_S);
else
fprintf(stderr, "Could not connect to Murmur\n");
if ((pfd[MPD].fd = mpdfd = mpd_connect(cfg.mpd_port)) < 0)
fprintf(stderr, "Could not connect to MPD\n");
// Connect to server and set IRC details
if (!(freenode = irc_connect(cfg.server, cfg.port)))
exit_msg("Irc connection failed");
pfd[IRC].fd = get_socket(freenode);
set_nick(freenode, cfg.nick);
set_user(freenode, cfg.user);
for (i = 0; i < cfg.channels_set; i++)
join_channel(freenode, cfg.channels[i]);
while ((ready = poll(pfd, SIZE(pfd), TIMEOUT)) > 0) {
// Keep reading & parsing lines as long the connection is active and act on any registered actions found
if (pfd[IRC].revents & POLLIN)
while (parse_irc_line(freenode) > 0);
if (pfd[MURM_LISTEN].revents & POLLIN)
if ((pfd[MURM_ACCEPT].fd = accept_murmur_connection(murm_listenfd)) > 0)
pfd[MURM_LISTEN].fd = -1; // Stop listening for connections
if (pfd[MURM_ACCEPT].revents & POLLIN) {
if (!listen_murmur_callbacks(freenode, pfd[MURM_ACCEPT].fd)) {
pfd[MURM_ACCEPT].fd = -1;
pfd[MURM_LISTEN].fd = murm_listenfd; // Start listening again for Murmur connections
}
}
if (pfd[MPD].revents & POLLIN)
if (!print_song(freenode, default_channel(freenode)))
pfd[MPD].fd = mpdfd = mpd_connect(cfg.mpd_port);
}
// If we reach here, it means we got disconnected from server. Exit with error (1)
if (ready == -1)
perror("poll");
else
fprintf(stderr, "%d minutes passed without getting a message, exiting...\n", TIMEOUT / 1000 / 60);
quit_server(freenode, cfg.quit_msg);
cleanup();
return 1;
}
static void irc_disconnect(void) {
close(irc_fd);
fprintf(stderr, "fifoirc: disconnection from %s\n", server);
if(reconnect) irc_connect();
else exit(EXIT_FAILURE);
}
int main (int argc, char **argv)
{
irc_callbacks_t callbacks;
irc_ctx_t ctx;
irc_session_t * s;
if ( argc != 4 )
{
printf ("Usage: %s <server> <nick> <channel>\n", argv[0]);
return 1;
}
memset (&callbacks, 0, sizeof(callbacks));
callbacks.event_connect = event_connect;
callbacks.event_join = event_join;
callbacks.event_nick = dump_event;
callbacks.event_quit = dump_event;
callbacks.event_part = dump_event;
callbacks.event_mode = dump_event;
callbacks.event_topic = dump_event;
callbacks.event_kick = dump_event;
callbacks.event_channel = event_channel;
callbacks.event_privmsg = event_privmsg;
callbacks.event_notice = dump_event;
callbacks.event_invite = dump_event;
callbacks.event_umode = dump_event;
callbacks.event_ctcp_rep = dump_event;
callbacks.event_ctcp_action = dump_event;
callbacks.event_unknown = dump_event;
callbacks.event_numeric = event_numeric;
callbacks.event_dcc_chat_req = irc_event_dcc_chat;
callbacks.event_dcc_send_req = irc_event_dcc_send;
s = irc_create_session (&callbacks);
if ( !s )
{
printf ("Could not create session\n");
return 1;
}
ctx.channel = argv[3];
ctx.nick = argv[2];
irc_set_ctx (s, &ctx);
if ( irc_connect (s, argv[1], 6667, 0, argv[2], 0, 0) )
{
printf ("Could not connect: %s\n", irc_strerror (irc_errno(s)));
return 1;
}
irc_run (s);
return 1;
}
void dazeus::Server::connectToServer()
{
printf("Connecting to server: %s\n", toString(this).c_str());
assert( !config_->network->nickName.length() == 0 );
irc_callbacks_t callbacks;
memset(&callbacks, 0, sizeof(irc_callbacks_t));
callbacks.event_connect = irc_callback;
callbacks.event_nick = irc_callback;
callbacks.event_quit = irc_callback;
callbacks.event_join = irc_callback;
callbacks.event_part = irc_callback;
callbacks.event_mode = irc_callback;
callbacks.event_umode = irc_callback;
callbacks.event_topic = irc_callback;
callbacks.event_kick = irc_callback;
callbacks.event_channel = irc_callback;
#if LIBIRC_VERSION_HIGH > 1 || LIBIRC_VERSION_LOW >= 6
callbacks.event_channel_notice = irc_callback;
#endif
callbacks.event_privmsg = irc_callback;
callbacks.event_notice = irc_callback;
callbacks.event_invite = irc_callback;
callbacks.event_ctcp_req = irc_callback;
callbacks.event_ctcp_rep = irc_callback;
callbacks.event_ctcp_action = irc_callback;
callbacks.event_unknown = irc_callback;
callbacks.event_numeric = irc_eventcode_callback;
irc_ = (void*)irc_create_session(&callbacks);
if(!irc_) {
std::cerr << "Couldn't create IRC session in Server.";
abort();
}
irc_set_ctx(IRC, this);
assert( config_->network->nickName.length() != 0 );
std::string host = config_->host;
if(config_->ssl) {
#if defined(LIBIRC_OPTION_SSL_NO_VERIFY)
host = "#" + host;
if(!config_->ssl_verify) {
std::cerr << "Warning: connecting without SSL certificate verification." << std::endl;
irc_option_set(IRC, LIBIRC_OPTION_SSL_NO_VERIFY);
}
#else
std::cerr << "Error: Your version of libircclient does not support SSL. Failing connection." << std::endl;
slotDisconnected();
return;
#endif
}
irc_connect(IRC, host.c_str(),
config_->port,
config_->network->password.c_str(),
config_->network->nickName.c_str(),
config_->network->userName.c_str(),
config_->network->fullName.c_str());
}
void* irc_thread_net(void *data) {
irc_thread_data *self = (irc_thread_data*)data;
irc_callbacks_t callbacks;
irc_ctx_t ctx;
irc_session_t *irc_s;
void *socket = zmq_socket(self->d.context, ZMQ_PUSH); // "server" from irc -> tun
int ret = zmq_connect(socket, "inproc://#irc_to_#tun");
if (ret) {
irc_debug(self, "(irc_thread_net) error when creating IPC socket - %s", zmq_strerror(errno));
goto exit;
}
memset (&callbacks, 0, sizeof(callbacks));
callbacks.event_connect = event_connect;
callbacks.event_join = event_join;
callbacks.event_privmsg = event_message;
callbacks.event_channel = event_message;
ctx.channel = strdup(self->chan);
ctx.nick = malloc(sizeof(char)*512);
snprintf(ctx.nick, 511, self->nick, rand());
ctx.self = self;
ctx.buffer = malloc(sizeof(char)*MTU*4);
ctx.data = socket; // WE ARE PASSING A NON-THREAD-SAFE SOCKET HERE! </redwarning>
irc_s = irc_create_session(&callbacks);
if (!irc_s) {
irc_debug(self, "error when creating irc_session");
goto exit;
}
self->irc_s = irc_s;
irc_debug(self, "created irc_session!");
irc_set_ctx(self->irc_s, &ctx);
if (irc_connect (self->irc_s, self->server, 6667, self->pass, ctx.nick, "ipoirc", "IP over IRC - http://github.com/EXio4/IPoIRC")) {
irc_debug(self, "error when connecting to irc (%s)", irc_strerror(irc_errno(self->irc_s)));
goto exit;
}
sleep(1); // wait for the network to answer THIS SHOULD BE DONE IN A RIGHT WAY!
int rc = irc_run(self->irc_s);
(void) rc;
exit:
if (self->irc_s) {
irc_destroy_session(self->irc_s);
}
if (socket) {
zmq_close(socket);
}
pthread_exit(NULL);
}
int main(int argc, const char **argv)
{
base_eventloop = mowgli_eventloop_create ();
irc_connect(argv[1], argv[2]);
mowgli_eventloop_run (base_eventloop);
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
int socketfd, n;
char in[BUF+1], out[BUF+1], c[512];
char *pos, *action;
if(argc != 5) {
printf("Usage: %s <address> <port> <nick> <owner>\n", argv[0]);
exit(1);
} else if(atoi(argv[2]) < 1 || atoi(argv[2]) > 50000) {
printf("Invalid port specified.\n");
exit(1);
} else if(irc_connect(argv[1], atoi(argv[2]), &socketfd) == 0) {
printf("Failed to connect to %s.\n", argv[1]);
exit(1);
}
nick = argv[3];
owner = argv[4];
if(strlen(nick)>48) {
printf("Error: irc bot nickname too long\n");
exit(1);
}
if(strlen(owner)>48) {
printf("Error: bot owner nickname too long\n");
exit(1);
}
/* write to buffer */
sprintf(c, "NICK %s\r\n", nick);
irc_send(socketfd, c);
sprintf(c, "USER %s %s %s :%s\r\n", nick, nick, nick, nick);
irc_send(socketfd, c);
/* do the service jobs */
if(join_channels(socketfd, "./owners.log") == 2) {
return 1;
}
while(1) {
in[0] = 0;
n = irc_read(socketfd, in);
if (n > 0) {
char *str = process_string(in, n);
if(strncmp(str, "0", 1)!=0) {
irc_send(socketfd, str);
}
if(strncmp(str, "QUIT", 4)==0) {
break;
}
} // if(n > 0)
} // while(1)
return 0;
}
static int sslconnect_hook(int argc, char *argv[])
{
int buf;
if (argc == 1) {
cio_out("current server is: %s\n",
server_name != NULL ? server_name : "(none)");
return 0;
}
if (argc < 3) {
irc_connect(6697, argv[1], 1);
} else {
buf = atoi(argv[2]);
irc_connect(buf, argv[1], 1);
}
return 0;
}
bool IRC::start()
{
if(IRC::_sessionServerMap.size() == 0)
{
std::cout << "IRC::start() empty server list - skipping" << std::endl;
return true;
}
_run = true;
irc_session_t* session;
ConfigHandler::IRCOptions_Server* options;
int32_t rc;
uint_fast8_t failCounter = 0; // 255 should be enough
std::thread t;
std::map<irc_session_t*, ConfigHandler::IRCOptions_Server>::iterator it;
for(it = IRC::_sessionServerMap.begin(); it !=IRC::_sessionServerMap.end(); it++)
{
session = it->first;
options = &it->second;
std::cout << "IRC: connecting to " << options->address << std::endl;
// add # for ssl connection
// todo add option
std::string addr = "#" + options->address;
//rc = irc_connect(session, addr.c_str(), options->port, options->password.c_str(), options->nickName.c_str(), options->userName.c_str(), options->realName.c_str());
rc = irc_connect(session, options->address.c_str(), options->port, /*options->password.c_str()*/ NULL, options->nickName.c_str(), options->userName.c_str(), options->realName.c_str());
if(rc) // rc != 0
{
std::cerr << "IRC::start() connecting to " << options->address << " failed - code: " << rc << std::endl;
failCounter++;
}
else
{
//std::cerr << "IRC::start() connecting to " << options->address << " seems ok - code: " << rc << std::endl;
_ircEventThread = std::thread( &IRC::ircEventLoop, this, session);
// for now only one server!
break;
}
}
// check if every server failed to connect
if( failCounter == IRC::_sessionServerMap.size())
return false;
return true;
}
int
main(int argc, char *argv[])
{
// Compile some regexes.
if (regcomp(&new_pr_regex, NEW_PR_PATTERN, REG_EXTENDED)) {
fprintf(stderr, "Failed to compile regex.\n");
return 1;
}
// Initialize SQLite gunk.
int retval;
retval = sqlite3_open(DATABASE_NAME, &db);
if (retval) {
fprintf(stderr, "Failed to open database: %s\n", sqlite3_errmsg(db));
return 1;
}
retval = sqlite3_exec(db, INITIALIZE_DB, 0, 0, 0);
if (retval) {
fprintf(stderr, "Failed to initialize database: %s\n", sqlite3_errmsg(db));
return 1;
}
// Kick off the IRC connection.
char buf[BUF_LEN];
struct ircbuf ircbuf;
ircbuf_init(&ircbuf, buf, BUF_LEN);
int fd = irc_connect(IRC_HOST, IRC_PORT);
if (fd < 0) {
fprintf(stderr, "Failed to open connection.\n");
return 1;
}
irc_nick(fd, IRC_NICK, NULL);
irc_join(fd, IRC_CHANNEL);
char *line;
while ((line = irc_getline(fd, &ircbuf))) {
printf("%s\n", line);
struct ircmsg msg;
irc_parseline(line, &msg);
if (!dispatch_handler(fd, &msg))
return 2;
}
return 0;
}
void Kommunikater::commitServer()
{
callbacks.event_connect = event_connect;
callbacks.event_channel = event_channel;
session = irc_create_session (&callbacks);
irc_set_ctx (session, &ctx);
irc_option_set (session, LIBIRC_OPTION_STRIPNICKS);
irc_connect (session, iam.server, 6667, 0, iam.nick, 0, 0);
state.session = session;
if(irc_run (session) && !state.stop)
printf ("Could not connect or I/O error");
}
void init_conf (irc_t * irc, FILE * conf) {
char *servname = NULL, *servport = NULL, *line = NULL, *tok = NULL, ch = 0;
int state = 0;
do {
line = getln(conf);
ch = 0;
tok = NULL;
if (line != NULL)
tok = strtok(line, " :");
if (tok != NULL) {
if (strcmp(tok, "") == 0)
tok = NULL;
if (tok != NULL)
ch = tok[0];
}
if (ch == '{') {
state = 1;
}
else if (ch == '}') {
state = 0;
}
else if (state == 0 && tok != NULL) {
servname = tok;
servport = strtok(NULL, " :");
if ( irc_connect(irc, servname, servport) < 0 ) {
fprintf(stderr, "Connection to %s:%sfailed.\n", servname, servport);
}
else {
if ( irc_login(irc, BOTNAME) < 0 ) {
fprintf(stderr, "Couldn't log in.\n");
}
}
}
else if (state == 1 && ch == '#') {
char *chan = malloc(strlen(tok)+1);
strcpy(chan, tok);
irc_join(irc, chan);
}
if (line != NULL) {
free(line);
}
} while (line != NULL);
}
int main(int argc, char *argv[])
{
struct sigaction sa;
g_type_init();
notify_info.argv = argv;
init_preferences(argc, argv);
/* Fork when wanted */
if (prefs.fork)
daemonize();
log_init();
g_log_set_default_handler(notify_log, NULL);
loop = g_main_loop_new(NULL, FALSE);
g_message(PACKAGE_STRING " started");
/* Fire up listening sockets */
if (!start_listener()) {
cleanup();
exit(EXIT_FAILURE);
}
/* Connect to IRC */
irc_connect(NULL);
/* Signal handler */
ns_open_signal_pipe();
sa.sa_handler = ns_sighandler;
sigfillset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
sigaction(SIGQUIT, &sa, NULL);
sigaction(SIGHUP, &sa, NULL);
g_main_loop_run(loop);
cleanup();
}
void network_connect(struct network *net)
{
struct channel *tmp;
irc_connect(net);
if (net->close_network)
return ;
irc_nick(net);
network_write_nick(net);
irc_user(net);
network_write_realname(net);
if (net->password)
irc_pass(net);
network_foreach_channel(net, tmp)
irc_join(net, tmp->name);
network_write_joined(net);
}
int main (int argc, char **argv)
{
irc_callbacks_t callbacks;
irc_ctx_t ctx;
irc_session_t * s;
if ( argc != 4 )
{
printf ("Usage: %s <server> <nick> <channel>\n", argv[0]);
return 1;
}
memset (&callbacks, 0, sizeof(callbacks));
callbacks.event_connect = event_connect;
callbacks.event_join = event_join;
callbacks.event_channel = event_channel;
callbacks.event_numeric = event_numeric;
s = irc_create_session (&callbacks);
if ( !s )
{
printf ("Could not create session\n");
return 1;
}
ctx.channel = argv[3];
ctx.nick = argv[2];
irc_set_ctx (s, &ctx);
if ( irc_connect (s, argv[1], 6667, 0, argv[2], 0, 0) )
{
printf ("Could not connect: %s\n", irc_strerror (irc_errno(s)));
return 1;
}
irc_run (s);
return 1;
}
IRCSession::IRCSession(char const* servername,
unsigned int port,
char const* password,
const char* nick,
const char* username,
const char* realname)
: session{nullptr}
{
session = irc_create_session(&IRC::callbacks);
if (session == nullptr)
throw std::runtime_error{"Could not create IRC session."};
irc_option_set( session, LIBIRC_OPTION_STRIPNICKS );
if (irc_connect(session, servername, port, password, nick,
username, realname))
throw std::runtime_error{"Could not initiate connection to server."};
IRC::session_map[session] = this;
}
static bool
tryconnect(void)
{
struct srvlist_s *s = g_srvlist;
while (s) {
irc_set_server(g_irc, s->host, s->port);
D("trying '%s:%"PRIu16"'",
irc_get_host(g_irc), irc_get_port(g_irc));
if (!irc_set_ssl(g_irc, s->ssl) && s->ssl)
C("failed to enable SSL");
if (irc_connect(g_irc))
return true;
s = s->next;
}
return false;
}
int irc_exec(char *hostname, int port, char *channel) {
int fd;
int nb;
char *buff;
pthread_t tid;
fd = irc_connect(hostname, port);
if (fd == -1)
return 0;
nb = pthread_create(&tid, NULL, irc_handle_activity, &fd);
if (nb != 0) {
sock_close(fd);
return 0;
}
/* join channel */
usleep(IRC_JOINDELAY * 1000000);
nb = strlen(channel) + 8;
buff = calloc(nb, sizeof(char));
sprintf(buff, "JOIN %s\r\n", channel);
send(fd, buff, strlen(buff), 0);
free(buff);
/* terminal input to IRC server */
buff = calloc(IRC_TERMWIDTH, sizeof(char));
while (fgets(buff, IRC_TERMWIDTH, stdin) != NULL) {
send(fd, buff, strlen(buff) - 1, 0);
send(fd, "\r\n", 2, 0);
}
free(buff);
/* IRC disconnect */
irc_close(fd);
pthread_join(tid, NULL);
return 1;
}
/*
====================
IRC_ReconnectSession
Reconnects the session to the last server it connected to.
Returns 0 on success, -1 on invalid handle, error code on libircclient error.
====================
*/
int IRC_ReconnectSession(int handle) {
irc_session_t *s;
int err;
if(!IS_VALID_IRC_SESSION(handle)) {
IRC_Printf("Attempted to reconnect an invalid session %i\n", handle);
return -1;
}
if(IRC_SessionIsConnected(handle))
IRC_DisconnectSession(handle, "Reconnecting");
s = &irc_sessions[handle];
irc_disconnect(s->session);
if(irc_connect(s->session, s->server, s->port, s->password, s->nick, s->username, s->realname)) {
err = irc_errno(s->session);
IRC_Printf("Connection error on session %i: %s\n", handle, irc_strerror(err));
return err;
}
return 0;
}
std::thread Twitch::Connect( const std::string &user, const std::string &password ) {
return std::thread( [this, user, password] {
this->user = user;
this->channel = "#" + user;
irc_callbacks_t callbacks;
memset( &callbacks, 0, sizeof( callbacks ) );
callbacks.event_connect = event_connect;
callbacks.event_channel = event_channel;
callbacks.event_numeric = event_numeric;
session = irc_create_session( &callbacks );
if ( !session ) {
OnError( -1, "Failed to create IRC session" );
return;
}
TwitchContext *ctx = new TwitchContext();
ctx->twitch = this;
irc_set_ctx( session, ctx );
irc_option_set( session, LIBIRC_OPTION_STRIPNICKS );
status = TWITCH_CONNECTING;
if ( irc_connect( session, "irc.chat.twitch.tv", 6667, password.c_str(), user.c_str(), user.c_str(), user.c_str() ) ) {
OnError( irc_errno( session ), irc_strerror( irc_errno( session ) ) );
status = TWITCH_DISCONNECTED;
return;
}
if ( irc_run( session ) ) {
OnError( irc_errno( session ), irc_strerror( irc_errno( session ) ) );
status = TWITCH_DISCONNECTED;
return;
}
} );
}
int establish_connection() {
/* For connecting */
char *hostname, *port;
/* For introduction purposes */
char *nickname, *username, *realname;
hostname = getconf("server", NULL);
port = getconf("port", "6667");
nickname = getconf("nickname", NULL);
username = getconf("username", NULL);
realname = getconf("realname", NULL);
if (!hostname || !nickname || !username || !realname) {
printlog("You are missing some variables from the configuration file, "
"please check the configuration file for the missing values of: %s%s%s%s%s%s%s",
!hostname ? "server" : "", !hostname ? " " : "", !nickname ? "nickname" : "",
!nickname ? " " : "", !username ? "username" : "", !username ? " " : "",
!realname ? "realname" : "");
exit(1);
}
if (irc_connect(hostname, atoi(port))) {
/* If we connected, lets introduce ourselves to the server */
/* Only copy the nickname until we use USERHOST on the server to find out our real host */
bi.botuser = addtouser(NULL, nickname, NULL, NULL);
irc_write(QUEUE_SERVER, "USER %s 127.0.0.1 localhost :%s", username, realname);
irc_write(QUEUE_SERVER, "NICK %s", nickname);
return 1;
}
return 0;
}
int main (int argc, char **argv)
{
irc_callbacks_t callbacks;
irc_ctx_t ctx;
irc_session_t * s;
unsigned short port = 6667;
if ( argc != 4 )
{
printf ("Usage: %s <server> <nick> <channel>\n", argv[0]);
return 1;
}
memset (&callbacks, 0, sizeof(callbacks));
callbacks.event_connect = event_connect;
callbacks.event_join = event_join;
callbacks.event_channel = event_channel;
callbacks.event_numeric = event_numeric;
s = irc_create_session (&callbacks);
if ( !s )
{
printf ("Could not create session\n");
return 1;
}
ctx.channel = argv[3];
ctx.nick = argv[2];
printf("nick:%s and channel:%s\n",ctx.nick,ctx.channel);
irc_set_ctx (s, &ctx);
// If the port number is specified in the server string, use the port 0 so it gets parsed
if ( strchr( argv[1], ':' ) != 0 )
port = 0;
// To handle the "SSL certificate verify failed" from command line we allow passing ## in front
// of the server name, and in this case tell libircclient not to verify the cert
if ( argv[1][0] == '#' && argv[1][1] == '#' )
{
// Skip the first character as libircclient needs only one # for SSL support, i.e. #irc.freenode.net
argv[1]++;
irc_option_set( s, LIBIRC_OPTION_SSL_NO_VERIFY );
}
// Initiate the IRC server connection
if ( irc_connect (s, argv[1], port, 0, argv[2], 0, 0) )
{
printf ("Could not connect: %s\n", irc_strerror (irc_errno(s)));
return 1;
}
// and run into forever loop, generating events
if ( irc_run (s) )
{
printf ("Could not connect or I/O error: %s\n", irc_strerror (irc_errno(s)));
return 1;
}
return 1;
}
int main(int argc, char *argv[])
{
int err;
int max_descr;
fd_set sock_set;
struct timeval select_timeout;
int running = 1;
irc_connection con;
unsigned irc_port;
char *irc_server;
conf = config_from_filename("ircb.conf");
assert(conf);
if (argc == 3) {
irc_server = argv[1];
irc_port = atoi(argv[2]);
}
if (argc == 2) {
irc_server = argv[1];
irc_port = 6667;
}
else if (argc == 1) {
config_group *g = config_get_group(conf, "irc");
irc_server = Conf("server", "INVALID");
if (!strcmp(irc_server, "INVALID")) {
Printerr("No IRC server address given!\n");
return 1;
}
char *portstr = Conf("port", "6667");
assert(irc_server && portstr);
irc_port = atoi(portstr);
}
else
return 1;
err = irc_connect(&con, irc_server, irc_port);
if (err) {
Printerr("Got no connection to IRC server!\n");
return 1;
}
module_load_module_dir(&con, conf);
config_group *g = config_get_group(conf, "bot");
irc_set_nick(&con, Conf("nickname", "cbot"));
irc_set_user(&con,
Conf("username", "cbot_user"),
Conf("hostname", "cbot_host"),
Conf("servername", "cbot_server"),
Conf("realname", "The CBot!"));
max_descr = MAX(STDIN_FILENO, con.sockfd) + 1;
while (running) {
FD_ZERO(&sock_set);
FD_SET(STDIN_FILENO, &sock_set);
FD_SET(con.sockfd, &sock_set);
select_timeout.tv_sec = 120;
select_timeout.tv_usec = 0;
err = select(max_descr, &sock_set, NULL, NULL, &select_timeout);
if (!err) {
/* Handle timeout */
}
if (FD_ISSET(con.sockfd, &sock_set))
/* Incoming data from IRC network */
running = !handle_irc_messages(&con);
if (FD_ISSET(STDIN_FILENO, &sock_set))
/* Local user input */
running = handle_keyboard_input(&con) != -2;
}
module_unload_all(&con);
irc_close(&con, "bye.");
return 0;
}
