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;
}
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, 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 IRC::ircEventLoop(irc_session_t* session)
{
if(irc_run(session))
irc_errno(session);
// is this needed?
while(_run)
{
sleep(1);
}
}
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 ChatNetworkingIRC::run()
{
IRCSessionContext* p_ctx = static_cast< IRCSessionContext* >( irc_get_ctx( _p_session ) );
// passing through an exception silently kills the process, very subtile source of error!
try
{
// start the IRC protocol loop
irc_run( _p_session );
}
catch ( ... )
{
log_error << "*** internal error occured in ChatNetworkingIRC::run" << std::endl;
irc_destroy_session( _p_session );
}
delete p_ctx;
irc_destroy_session( _p_session );
_p_session = NULL;
}
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;
}
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;
}
} );
}
//////////////////////////////////////////////////////////////////////////
// execute
//virtual
void GaMatchmakingState::execute()
{
irc_run( pSession_ );
}
void *wxLIRCCSession::Entry()
{
irc_run ( this->handle );
return NULL;
}
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;
}
char buffer[200];
std::string message;
if (event > 400) {
printf("ERROR %d: %s: %s %s %s %s\n", event, origin ? origin : "unknown", params[0], count > 1 ? params[1] : "", count > 2 ? params[2] : "", count > 3 ? params[3] : "");
sprintf(buffer, "ERROR %d: %s: %s %s %s %s\n", event, origin ? origin : "unknown", params[0], count > 1 ? params[1] : "", count > 2 ? params[2] : "", count > 3 ? params[3] : "");
message = buffer;
if (event != 412)
ctx->pConnection->sendMsg(&message, &ctx->pConnection->mlastCommandOrigin);
}
}
void *runSession(void *ptr) {
DEBUG("thread constructed")
int i = irc_run((irc_session_s*) ptr);
DEBUG("thread runfinised")
return (void*) i;
}
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
std::stringstream ss(s);
std::string item;
while (std::getline(ss, item, delim)) {
if (item.size() > 0)
elems.push_back(item);
}
return elems;
}
std::vector<std::string> split(const std::string &s, char delim) {
int main(int argc, char** argv)
{
irc_callbacks_t callbacks;
irc_session_t *s;
//Time init
time ( &rawtime );
ptm = gmtime ( &rawtime );
printf(" : - Bot wird gestartet...\n");
//-- SQLite Init
printf(" : - SQLite wird initialisiert...\n");
sqlite3_open(SQLITEFILE, &sqlitedb);
sql_createtables();
switch(argc)
{
case 2:
{
int tmp = -1;
tmp = configfileLaden(argv[1]);
if(tmp==0)
{
return 1;
}
printf(" : - Bot Configfile geladen \n");
}break;
case 4:
ctx.channel = argv[3];
ctx.nick = argv[2];
server = argv[1];
printf(" : - Bot configuriert (Parameter) \n");
break;
default:
printf ("!: - Parameter fehlen\n");
printf ("!: - %s <server> <nick> '<#channel>' \n",argv[0]);
printf ("!: - %s <configfile> \n",argv[0]);
return 1;
}
printf(" : - Server: %s \n",server);
printf(" : - Nick: %s \n",ctx.nick);
printf(" : - Channel: %s \n",ctx.channel);
memset(&callbacks, 0, sizeof(callbacks));
//-- Events --
callbacks.event_connect = event_connect;
callbacks.event_join = event_join;
callbacks.event_channel = event_channel;
callbacks.event_privmsg = event_privmsg;
//--
// ctx.channel = "#Bot";
// ctx.nick = "FH-BoT";
if(server == NULL)
{
printf("?: - setzt Standartserver\n");
server = "localhost";
}
s = irc_create_session(&callbacks);
if(!s)
{
printf("X: - Konnte keine IRC Session aufbauen...\n");
return 1;
}
irc_set_ctx (s,&ctx);
irc_option_set (s, LIBIRC_OPTION_STRIPNICKS);
if( irc_connect (s, server,port, 0,ctx.nick,0,0))
{
printf("X: - Konnte keine Verbindung zum Server aufbauen...\n");
return 1;
}
if( irc_run (s) )
{
printf (" : - SQLite wird geschlossen. \n");
sqlite3_close(sqlitedb);
printf (" : - Bot wurde beendet. \n");
return 1;
}
sqlite3_close(sqlitedb);
return 1;
}
/**
* @brief Main Funktion
* Setzt die Callback Funktionen.
* Initialisiert und Startet den IRC Bot
* @param argc ein Integer, Anzahl der Argumente
* @param argv ein Char, beinhaltet Argumente
* @return int
*/
int main (int argc, char **argv)
{
irc_callbacks_t callbacks;
irc_ctx_t ctx;
irc_session_t * s;
unsigned short port;
if ( argc != 5 )
{
printf ("Usage: %s <server> <nick> <'#channel'> <daemon:yes/no>\n", argv[0]);
return 1;
}
if ( !strcmp (argv[4], "yes") )
{
daemonize();
}
else if ( !( !strcmp (argv[4], "no") ))
{
printf ("Usage: %s <server> <nick> <'#channel'> <daemon:yes/no>\n", argv[0]);
return 1;
//Beispiel
// ./irc_bot irc.twice-irc.de:6667 test_bot328 '#qaywsx999' no
}
memset (&callbacks, 0, sizeof(callbacks));
callbacks.event_connect = event_connect;
callbacks.event_join = event_join;
callbacks.event_nick = event_nick_change;
callbacks.event_quit = event_quit;
callbacks.event_channel = event_channel;
callbacks.event_privmsg = event_privmsg;
s = irc_create_session (&callbacks);
if ( !s )
{
printf ("Could not create session\n");
return 1;
}
ctx.channel = argv[3];
ctx.nick = argv[2];
bot_name = ctx.nick;
irc_set_ctx (s, &ctx);
createSQLDB();
// 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;
}
// Used when there is only one session and we want the default handler
void IRCSession::run() {
if (irc_run(session))
throw std::runtime_error{"Could not start main irc listening loop."};
}
// Main function
int main(int argc, char** argv){
irc_callbacks_t irc_callbacks;
char* host_str;
int host_len, ssl;
I = 0;
if(argc != 2)
error(1, "Error: config file must be specified on comand line\n");
// load config from ini
conf_file = argv[1];
C = iniparser_load(conf_file);
// parse server config and generate a string to give to libircclient
ssl = iniparser_getboolean(C, "server:ssl", 0);
host_len = strlen(iniparser_getstring(C, "server:host", "")) + (ssl ? 1 : 0);
host_str = malloc(host_len + 1);
host_str[0] = '#';
host_str[host_len] = '\0';
strcpy(&host_str[ssl ? 1 : 0], iniparser_getstring(C, "server:host", ""));
// init local data structures
mem_init();
cbtable_init();
// init mysql
S = mysql_init(NULL);
if(mysql_real_connect(S,
iniparser_getstring(C, "mysql:host", "localhost"),
iniparser_getstring(C, "mysql:user", "root"),
iniparser_getstring(C, "mysql:pass", ""),
iniparser_getstring(C, "mysql:database", ""),
iniparser_getint(C, "mysql:port", 0), 0, 0) == NULL)
error(1, "Unable to connect to mysql: %s\n", mysql_error(S));
// init lua
L = luaL_newstate();
luaL_openlibs(L);
register_lua_functions();
if(luaL_dofile(L, iniparser_getstring(C,"bot:file","/dev/null"))){
size_t lua_errlen = 0;
const char* lua_error = luaL_checklstring(L, -1, &lua_errlen);
error(1, "Error processing Lua script:\n%s\n", lua_error);
}
// init libircclient
memset(&irc_callbacks, 0, sizeof(irc_callbacks));
irc_callbacks.event_connect = event_generic;
irc_callbacks.event_nick = event_generic;
irc_callbacks.event_quit = event_generic;
irc_callbacks.event_join = event_generic;
irc_callbacks.event_part = event_generic;
irc_callbacks.event_mode = event_generic;
irc_callbacks.event_umode = event_generic;
irc_callbacks.event_topic = event_generic;
irc_callbacks.event_kick = event_generic;
irc_callbacks.event_channel = event_command;
irc_callbacks.event_privmsg = event_command;
irc_callbacks.event_notice = event_generic;
irc_callbacks.event_unknown = event_generic;
irc_callbacks.event_invite = event_generic;
irc_callbacks.event_ctcp_req = event_generic;
irc_callbacks.event_ctcp_rep = event_generic;
irc_callbacks.event_ctcp_action = event_generic;
irc_callbacks.event_channel_notice = event_generic;
irc_callbacks.event_numeric = event_numeric;
do_quit = 0;
while(!do_quit){
if(I) irc_destroy_session(I);
I = irc_create_session(&irc_callbacks);
if(!I)
error(1, "Unable to create IRC session... probably out of memory\n");
irc_option_set(I, LIBIRC_OPTION_STRIPNICKS);
irc_option_set(I, LIBIRC_OPTION_SSL_NO_VERIFY);
//irc_option_set(I, LIBIRC_OPTION_DEBUG);
// initialize irc server connection
if(irc_connect(I,
host_str,
iniparser_getint(C,"server:port",6667), 0,
iniparser_getstring(C,"bot:nick","bot"),
iniparser_getstring(C,"bot:user","bot"),
"libircclient"
))
irc_error(I,1);
// not sure why we need to sleep here, but if we don't, we can't connect
sleep(1);
// run the irc client loop
if(irc_run(I))
irc_error(I,0);
}
// clean up
mysql_close(S);
irc_destroy_session(I);
lua_close(L);
cbtable_destroy();
iniparser_freedict(C);
free(host_str);
return EXIT_SUCCESS;
}
int main (int argc, char **argv)
{
bool daemon_deaktiv = false;
bool btipp = false;
int is=1, in=2, ic=3;
int i=1;
for(; i < argc; i++)
{
if ( !strncmp(argv[i], "-d",3) || !strncmp(argv[i], "-D",3) )
{
if(argc > 4)
btipp = true;
daemon_deaktiv = true;
printf("\n--------------------------------------------------\n");
printf("Daemon wird deaktiviert.");
if(i<2)
{
is = 2;
in = 3;
ic = 4;
}
}
else if ( !strncmp(argv[i], "-h",3) || !strncmp(argv[i], "-help",6) )
{
btipp = true;
printf("TEST: HELP ist da\n");
system("nroff -mandoc ./man/iman.pod | less");
}
}
if(btipp == false && argc != 4 )
{
printf("\nUsage: %s [options]\n", argv[0]);
printf("\n [ -h | -help ] Anleitung");
printf("\n [ <server> <nick> <#channel> ] Ircbot startet");
printf("\n [ -d .......... ] startet und Daemon wird deaktiviert\n\n");
exit(EXIT_SUCCESS);
}
irc_callbacks_t callbacks;
irc_ctx_t ctx;
irc_session_t * s;
memset (&callbacks, 0, sizeof(callbacks));
callbacks.event_connect = event_connect;
callbacks.event_join = event_join;
callbacks.event_channel = event_channel;
callbacks.event_quit = event_quit;
s = irc_create_session (&callbacks);
if ( !s )
{
printf ("Could not create session\n");
return 1;
}
ctx.channel = argv[ic];
ichanel = argv[ic];
ctx.nick = argv[in];
mynick = argv[in];
irc_set_ctx (s, &ctx);
irc_option_set(s, LIBIRC_OPTION_STRIPNICKS);
if ( irc_connect (s, argv[is], 6667, 0, argv[in], 0, 0) )
{
printf ("Es kann nicht verbinden: %s\n", irc_strerror (irc_errno(s)));
return 1;
}
else
{
if(daemon_deaktiv == false)
{
printf("\n--------------------------------------------------\n");
printf("Daemon wird aktiviert.");
}
printf("\nBot-Nickname: '%s'",argv[in]);
printf("\nChannel : '%s'",argv[ic]);
printf("\nEs verbindet: '%s'....\n", argv[is]);
}
if(daemon_deaktiv == false)
{
openlog (daemon_name, LOG_CONS | LOG_PID | LOG_NDELAY, LOG_DAEMON);
syslog (LOG_INFO, "Ircbot: Starting....");
start_daemon(daemon_name, LOG_USER);
}
irc_run (s);
syslog (LOG_INFO, "Ircbot: Terminating...");
closelog();
return 1;
}
