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 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 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");
}
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;
}
bool CslIrcThread::Connect(const CslIrcContext& context)
{
m_section.Enter();
if (FindContext(context))
return false;
CslIrcContext *ctx=new CslIrcContext(context);
m_contexts.Add(ctx);
irc_set_ctx(ctx->Session,ctx);
m_section.Leave();
if (m_mutex.TryLock()!=wxMUTEX_NO_ERROR)
return true;
m_condition->Signal();
m_mutex.Unlock();
return true;
}
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 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;
}
/*
====================
IRC_CreateSession
Initiates a new IRC session and returns a handle to it.
Call IRC_ConnectSession to connect to an IRC server.
====================
*/
int IRC_CreateSession(void) {
int handle = -1, i;
irc_callbacks_t cb;
irc_session_t *c;
if(!irc_initialized.integer) {
IRC_Printf("Error: Failed to create session: IRC module is not initialized\n");
return -1;
}
if(!irc_enabled.integer) {
IRC_Printf("Error: Failed to create session: irc_enabled is off\n");
return -1;
}
for(i = 0; i < IRC_MAX_SESSIONS; ++i)
if(!irc_sessions[i].session) {
handle = i;
break;
}
if(handle < 0) {
IRC_Printf("Error: Failed to create session: Session limit exceeded\n");
return handle;
}
c = &irc_sessions[handle];
memset(&cb, 0, sizeof(cb));
cb.event_numeric = IRC_Callback_Numeric;
cb.event_connect = IRC_Callback_Default;
cb.event_nick = IRC_Callback_Default;
cb.event_quit = IRC_Callback_Default;
cb.event_join = IRC_Callback_Default;
cb.event_part = IRC_Callback_Default;
cb.event_mode = IRC_Callback_Default;
cb.event_umode = IRC_Callback_Default;
cb.event_topic = IRC_Callback_Default;
cb.event_kick = IRC_Callback_Default;
cb.event_channel = IRC_Callback_Default;
cb.event_privmsg = IRC_Callback_Default;
cb.event_notice = IRC_Callback_Default;
cb.event_channel_notice = IRC_Callback_Default;
cb.event_invite = IRC_Callback_Default;
cb.event_ctcp_req = IRC_Callback_Default;
cb.event_ctcp_rep = IRC_Callback_Default;
cb.event_ctcp_action = IRC_Callback_Default;
cb.event_unknown = IRC_Callback_Default;
c->session = irc_create_session(&cb);
if(!c->session) {
IRC_Printf("Failed to create an IRC session: %s\n", irc_strerror(irc_errno(c->session)));
return -1;
}
// irc_option_set(c->session, LIBIRC_OPTION_DEBUG);
irc_set_ctx(c->session, (void*)c);
IRC_Printf("Created an IRC session with handle %i\n", handle);
return handle;
}
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;
}
void ChatNetworkingIRC::createConnection( const ChatConnectionConfig& conf ) throw ( ChatExpection )
{
if ( conf._port == 0 )
{
throw ChatExpection( "Invalid Port" );
}
if ( !conf._serverURL.length() )
{
throw ChatExpection( "Invalid Server URL" );
}
if ( !conf._channel.length() )
{
throw ChatExpection( "Invalid Channel" );
}
#ifdef WIN32
// start up winsock
WORD version;
WSADATA data;
int err;
version = MAKEWORD( 2, 2 );
err = WSAStartup( version, &data );
if ( err != 0 )
{
throw ChatExpection( "Cannot setup ms winsock" );
}
#endif
irc_callbacks_t callbacks;
memset( &callbacks, 0, sizeof( callbacks ) );
// set up the callbacks
callbacks.event_connect = event_connect;
callbacks.event_nick = event_nick;
callbacks.event_join = event_join;
callbacks.event_numeric = event_numeric;
callbacks.event_channel = event_channel;
callbacks.event_kick = event_kick;
callbacks.event_part = event_part;
irc_session_t* p_session = NULL;
p_session = irc_create_session( &callbacks );
if ( !p_session )
{
throw ChatExpection( "Could not create networking session" );
}
// store the context information
IRCSessionContext* p_ctx = new IRCSessionContext;
p_ctx->_p_handler = this;
p_ctx->_channel = conf._channel;
irc_set_ctx( p_session, p_ctx );
_p_session = p_session;
irc_option_set( p_session, LIBIRC_OPTION_STRIPNICKS );
// initiate the IRC server connection
if ( irc_connect(
p_session,
conf._serverURL.c_str(),
conf._port,
conf._password.length() ? conf._password.c_str() : NULL,
conf._nickname.c_str(),
conf._username.length() ? conf._username.c_str() : NULL,
conf._realname.length() ? conf._realname.c_str() : NULL ) )
{
throw ChatExpection( std::string( irc_strerror( irc_errno( p_session ) ) ) );
}
// store the configuration
_p_config = new ChatConnectionConfig;
*_p_config = conf;
_p_config->_p_protocolHandler = this;
// start the thread -- the method run() below is called in a new created thread
start();
}
////////////////////////////////////////////////////////////////////////////////
// update
eSysStateReturn GaMatchmakingState::main()
{
BcScopedLock< BcMutex > Lock( Lock_ );
BcReal Delta = SysKernel::pImpl()->getFrameTime();
switch( HandshakeState_ )
{
case HSS_STUN:
{
// Only do once.
if( MappedHandshakeAddr_ == 0 )
{
if( doSTUN() )
{
SysID_ = static_cast< BcU32 >( BcHash( (BcU8*)&MappedHandshakeAddr_, sizeof( MappedHandshakeAddr_ ) ) ); // Hash the mapped address to we don't broadcast it.
if( MappedHandshakeAddr_ != 0 )
{
HandshakeState_ = HSS_IDLE;
}
}
else
{
HandshakeState_ = HSS_STUN;
}
}
else
{
HandshakeState_ = HSS_IDLE;
}
}
break;
case HSS_IDLE:
{
ConnectTimer_ -= Delta;
if( ConnectTimer_ < 0.0f )
{
if( pSession_ == NULL )
{
pSession_ = irc_create_session( &Callbacks_ );
}
if( pSession_ != NULL && !irc_is_connected( pSession_ ) )
{
irc_set_ctx( pSession_, this );
std::string Channel = "#testchannel";
BcFile File;
if( File.open( "config.json" ) )
{
char* pData = new char[ File.size() ];
File.read( pData, File.size() );
Json::Reader Reader;
Json::Value Root;
if( Reader.parse( pData, pData + File.size(), Root ) )
{
Channel = Root["channel"].asCString();
}
delete [] pData;
}
BcSPrintf( ScreenName_, "%s_%x", "PSY", BcRandom::Global.rand() );
BcSPrintf( Channel_, Channel.c_str() );
// Connect to the server.
int RetVal = irc_connect( pSession_, "www.neilo.gd", 8000, NULL, ScreenName_, ScreenName_, ScreenName_ );
if( RetVal == 0 )
{
// Start the thread to tick the client.
BcThread::start( "EvtBridgeIRC" );
ClientID_ = BcErrorCode;
RemoteHandshakeAddr_ = 0;
RemoteHandshakePort_ = 0;
//LocalHandshakeAddr_ = 0;
//LocalHandshakePort_ = 0;
//MappedHandshakeAddr_ = 0;
//MappedHandshakePort_ = 0;
HandshakeState_ = HSS_WAIT_INVITE;
}
else
{
BcThread::join();
irc_destroy_session( pSession_ );
pSession_ = NULL;
}
}
}
}
break;
case HSS_WAIT_INVITE:
{
InviteTimer_ -= Delta;
if( InviteTimer_ < 0.0f )
{
InviteTimer_ = BcAbs( BcRandom::Global.randReal() ) * 5.0f + 5.0f;
// Send play with me message to channel.
BcChar PlayBuffer[256];
BcSPrintf( PlayBuffer, "REQ:%u", SysID_ );
irc_cmd_msg( pSession_, Channel_, PlayBuffer );
}
}
break;
case HSS_WAIT_ADDR:
{
HandshakeTimer_ -= Delta;
if( HandshakeTimer_ < 0.0f )
{
HandshakeState_ = HSS_WAIT_INVITE;
}
}
break;
case HSS_COMPLETE:
{
BcPrintf("GaMatchmakingState: Complete! ClientID of ours is %u\n", ClientID_);
return sysSR_FINISHED;
}
break;
}
if( HandshakeState_ != HSS_STUN )
{
if( HandshakeState_ != HSS_IDLE && ( pSession_ == NULL || !irc_is_connected( pSession_ ) ) )
{
BcSleep( 0.1f );
BcThread::join();
BcSleep( 0.1f );
if( pSession_ != NULL )
{
irc_destroy_session( pSession_ );
pSession_ = NULL;
}
HandshakeState_ = HSS_IDLE;
ConnectTimer_ = 10.0f;
}
}
return sysSR_CONTINUE;
}
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;
}
