static void on_privmsg( irc_session_t *session,
const char *event,
const char *origin,
const char **params,
unsigned int count) {
char nick[256];
char host[256];
char *msg;
/* printf("<%s> %s \n", origin, params[1]); */
irc_target_get_nick(origin, nick, 256);
irc_target_get_host(origin, host, 256);
msg = irc_color_strip_from_mirc(params[1]);
if ( (!is_voice(nick) && !is_op(nick))
|| ((is_voice(nick) || is_op(nick)) && !botcmd_parse(session, msg, nick, host, 1))) {
send_to_log(nick, msg);
}
free(msg);
}
void event_channel (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
char nickbuf[128];
if ( count != 2 )
return;
printf ("'%s' said in channel %s: %s\n",
origin ? origin : "someone",
params[0], params[1] );
if ( !origin )
return;
irc_target_get_nick (origin, nickbuf, sizeof(nickbuf));
if ( !strcmp (params[1], "quit") )
irc_cmd_quit (session, "of course, Master!");
if ( !strcmp (params[1], "help") )
{
irc_cmd_msg (session, params[0], "quit, help, dcc chat, dcc send, ctcp");
}
if ( !strcmp (params[1], "ctcp") )
{
irc_cmd_ctcp_request (session, nickbuf, "PING 223");
irc_cmd_ctcp_request (session, nickbuf, "FINGER");
irc_cmd_ctcp_request (session, nickbuf, "VERSION");
irc_cmd_ctcp_request (session, nickbuf, "TIME");
}
if ( !strcmp (params[1], "dcc chat") )
{
irc_dcc_t dccid;
irc_dcc_chat (session, 0, nickbuf, dcc_recv_callback, &dccid);
printf ("DCC chat ID: %d\n", dccid);
}
if ( !strcmp (params[1], "dcc send") )
{
irc_dcc_t dccid;
irc_dcc_sendfile (session, 0, nickbuf, "irctest.c", dcc_file_recv_callback, &dccid);
printf ("DCC send ID: %d\n", dccid);
}
if ( !strcmp (params[1], "topic") )
irc_cmd_topic (session, params[0], 0);
else if ( strstr (params[1], "topic ") == params[1] )
irc_cmd_topic (session, params[0], params[1] + 6);
if ( strstr (params[1], "mode ") == params[1] )
irc_cmd_channel_mode (session, params[0], params[1] + 5);
if ( strstr (params[1], "nick ") == params[1] )
irc_cmd_nick (session, params[1] + 5);
if ( strstr (params[1], "whois ") == params[1] )
irc_cmd_whois (session, params[1] + 5);
}
void event_join( irc_session_t *irc_session, const char *event, const char *origin, const char **params, unsigned int count ) {
ConfigArrayPtr settings[2];
char nickbuf[128];
char buffer[512];
dump_event( irc_session, event, origin, params, count );
irc_cmd_user_mode( irc_session, "+i" );
irc_target_get_nick( origin, nickbuf, sizeof(nickbuf) );
settings[0] = GetSetting( "IRC Bot Nick" );
if( !strcmp( nickbuf, settings[0]->string_value ) ) {
info( "IRC Bot Joined Channel: %s", params[0] );
snprintf(buffer, sizeof(buffer), "op %s", params[0] );
irc_cmd_msg( irc_session, "ChanServ", buffer );
} else if( !strcmp( nickbuf, "ChanServ" ) ) {
settings[0] = GetSetting( "IRC Bot Pass" );
if( settings[0]->string_value ){
snprintf(buffer, sizeof(buffer), "identify %s", settings[0]->string_value );
irc_cmd_msg( irc_session, "NickServ", buffer);
}
snprintf(buffer, sizeof(buffer), "op %s", params[0] );
irc_cmd_msg( irc_session, "ChanServ", buffer );
}
return;
}
void cmd_say(irc_session_t* session, const char* cmd, const char* origin, char* args) {
if(args[0] != '\0') {
char* what_to_say = &args[1]; /* l'espace après 'say' */
irc_cmd_msg(session, channel, what_to_say);
char nick[20];
irc_target_get_nick(origin, nick, 20);
log_and_print("%s m'a dit de dire : %s", nick, what_to_say);
log_and_print_said(botnick, what_to_say);
}
}
void event_part (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
char nickbuf[128];
irc_ctx_t * ctx = (irc_ctx_t *) irc_get_ctx (session);
irc_target_get_nick (origin, nickbuf, sizeof(nickbuf));
if ( ctx->userLogged.find(nickbuf) != ctx->userLogged.end() )
{
ctx->userLogged.erase (nickbuf);
}
}
void cmd_quit(irc_session_t* session, const char* cmd, const char* origin, char* args) {
if(!strcmp(origin, master_origin)) {
if(args[0] == '\0') {
irc_cmd_msg(session, channel, "bien sûr, Maître !");
irc_cmd_quit(session, NULL);
}
} else {
char nick[20];
irc_target_get_nick(origin, nick, 20);
char msg[100];
sprintf(msg, "%s: bien essayé :>", nick);
irc_cmd_msg(session, channel, msg);
}
}
void event_ctcp_request(irc_session_t *session,const char* WXUNUSED(event),const char *origin,
const char **params,unsigned int WXUNUSED(count))
{
char nick[128];
irc_target_get_nick(origin,nick,sizeof(nick));
if (!strcasecmp(params[0],"VERSION"))
{
wxString s;
s<<wxT("VERSION ")<<CSL_NAME_STR<<wxT(" ")<<CSL_VERSION_LONG_STR<<CSL_WEBADDRFULL_STR;
irc_cmd_ctcp_reply(session,nick,U2A(s));
}
}
void event_channel( irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count )
{
char nickbuf[128];
if ( count != 2 )
return;
std::string sender( origin ? origin : "someone" );
IRCSessionContext* p_ctx = static_cast< IRCSessionContext* >( irc_get_ctx( session ) );
p_ctx->_p_handler->recvMessage( params[ 0 ], sender, params[1] );
if ( !origin )
return;
irc_target_get_nick( origin, nickbuf, sizeof( nickbuf ) );
}
void event_channel (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
irc_ctx_t * ctx = (irc_ctx_t *) irc_get_ctx (session);
if ( !origin || count != 2 )
return;
if ( strstr (params[1], "f**k") == 0 )
return;
char nickbuf[128], text[256];
irc_target_get_nick (origin, nickbuf, sizeof(nickbuf));
if ( ctx->insolents.find(nickbuf) == ctx->insolents.end() )
ctx->insolents[nickbuf] = 0;
ctx->insolents[nickbuf]++;
printf ("'%s' swears in the channel '%s' %d times\n",
nickbuf,
params[1],
ctx->insolents[nickbuf]);
switch (ctx->insolents[nickbuf])
{
case 1:
// Send a private message
sprintf (text, "%s, please do not swear in this channel.", nickbuf);
irc_cmd_msg (session, nickbuf, text);
break;
case 2:
// Send a channel message
sprintf (text, "%s, do not swear in this channel, or you'll leave it.", nickbuf);
irc_cmd_msg (session, params[0], text);
break;
default:
// Send a channel notice, and kick the insolent
sprintf (text, "kicked %s from %s for swearing.", nickbuf, params[0]);
irc_cmd_me (session, params[0], text);
irc_cmd_kick (session, nickbuf, params[0], "swearing");
break;
}
}
static void libirc_event_ctcp_internal (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
if ( origin )
{
char nickbuf[128], textbuf[256];
irc_target_get_nick (origin, nickbuf, sizeof(nickbuf));
if(is_lua_active(session))
if(lua_process_event(session,event,origin,params,count))
return;
if ( strstr (params[0], "PING") == params[0] ){
_snprintf(textbuf,sizeof(textbuf),"PONG%s",params[0]+4);
irc_cmd_ctcp_reply (session, nickbuf, textbuf);
printf("--->pong reply %s\n",textbuf);
}
else if ( !strcmp (params[0], "VERSION") )
{
unsigned int high, low;
irc_get_version (&high, &low);
sprintf (textbuf, "VERSION slimIRC client - using libirc by Georgy Yunaev ver.%d.%d", high, low);
irc_cmd_ctcp_reply (session, nickbuf, textbuf);
}
else if ( !strcmp (params[0], "FINGER") )
{
sprintf (textbuf, "FINGER %s (%s) Idle 0 seconds",
session->username ? session->username : "******",
session->realname ? session->realname : "noname");
irc_cmd_ctcp_reply (session, nickbuf, textbuf);
}
else if ( !strcmp (params[0], "TIME") )
{
time_t now = time(0);
#if defined (ENABLE_THREADS) && defined (HAVE_LOCALTIME_R)
struct tm tmtmp, *ltime = localtime_r (&now, &tmtmp);
#else
struct tm * ltime = localtime (&now);
#endif
strftime (textbuf, sizeof(textbuf), "%a %b %d %H:%M:%S %Z %Y", ltime);
irc_cmd_ctcp_reply (session, nickbuf, textbuf);
}
}
}
// internal callback functions
//----
void event_connect( irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count )
{
// auto-join after connection
IRCSessionContext* p_ctx = static_cast< IRCSessionContext* >( irc_get_ctx( session ) );
if ( p_ctx->_channel.length() )
irc_cmd_join( session, p_ctx->_channel.c_str(), 0 );
// start the callback mechanism for connection
p_ctx->_p_handler->connected();
// store actual nick name
char p_nickbuf[ 128 ];
irc_target_get_nick( params[ 0 ], p_nickbuf, sizeof( p_nickbuf ) );
p_ctx->_nickname = p_nickbuf;
// notify for nickname change
p_ctx->_p_handler->recvNicknameChange( p_ctx->_channel, p_ctx->_nickname, "" );
}
void event_nick (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
char nickbuf[128];
irc_ctx_t * ctx = (irc_ctx_t *) irc_get_ctx (session);
if ( !origin || count != 1 )
return;
irc_target_get_nick (origin, nickbuf, sizeof(nickbuf));
if ( ctx->insolents.find(nickbuf) != ctx->insolents.end() )
{
printf ("%s has changed its nick to %s to prevent penalties - no way!\n",
nickbuf, params[0]);
ctx->insolents[params[0]] = ctx->insolents[nickbuf];
ctx->insolents.erase (nickbuf);
}
}
/**
* @brief Quit Event
* Diese Funktion wird aufgerufen, wenn ein Client den Channel verlaesst.
* Loggt das Event.
* @param session ein Pointer von irc_session_t, Session von der ein Event erzeugt wird.
* @param event ein konstanter char Pointer, Event Name
* @param origin ein konstanter char Pointer, Herkunfts Name (Person die den Raum verlaesst)
* @param params const char, Liste der Parameter (0 - Grund des Verlassens)
* @param count ein unsigned int, Anzahl der Parameter
*/
void event_quit (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
if(logging==1)
{
char nickbuf[128];
irc_target_get_nick (origin, nickbuf, sizeof(nickbuf));
char theTime[100];
struct tm * clock;
time_t sec;
time(&sec);
clock = localtime(&sec);
strftime(theTime, sizeof(theTime), "%Y-%m-%d %H:%M:%S", clock);
char message[1024];
sprintf(message, "INSERT INTO log (name, chan, message, date) VALUES ('%s', 'quit', '%s', '%s');", nickbuf, "", theTime);
logSQL(message);
}
}
/**
* @brief Channel Event
* Funktion wird aufgerufen, sobald jemand etwas laut im Channel sagt/eine Nachricht schreibt.
* Loggt Event.
* Reagiert auf eigenen Namen.
* @param session ein Pointer von irc_session_t, Session von der ein Event erzeugt wird.
* @param event ein konstanter char Pointer, Event Name
* @param origin ein konstanter char Pointer, Herkunfts Name (Person die die Nachricht geschrieben hat)
* @param params const char, Liste der Parameter (0 - Channel Name, 1 - Nachricht Text)
* @param count ein unsigned int, Anzahl der Parameter
*/
void event_channel (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
if ( count != 2 )
return;
printf ("'%s' said in channel %s: %s\n",
origin ? origin : "someone",
params[0], params[1] );
if ( !origin )
return;
if(logging==1)
{
char nickbuf[128];
irc_target_get_nick (origin, nickbuf, sizeof(nickbuf));
char theTime[100];
struct tm * clock;
time_t sec;
time(&sec);
clock = localtime(&sec);
strftime(theTime, sizeof(theTime), "%Y-%m-%d %H:%M:%S", clock);
char message[1024];
sprintf(message, "INSERT INTO log (name, chan, message, date) VALUES ('%s', 'said in %s:', '%s', '%s');", nickbuf, params[0], params[1], theTime);
logSQL(message);
}
//Name des Bots in der Nachricht
if ( strncmp( params[1], bot_name, (unsigned)strlen(bot_name) ) == 0 )
{
irc_cmd_msg (session, params[0], "Whisper me: 'help'");
}
}
static void on_join( irc_session_t *session,
const char *event,
const char *origin,
const char **params,
unsigned int count) {
pthread_t refresh_th;
char nick[256];
irc_target_get_nick(origin, nick, 256);
printf("%s Joined %s\n", nick, params[0]);
irc_cmd_names(session, params[0]);
if (strcmp(params[0], bot_channel) == 0) {
pthread_create(&refresh_th, NULL, refresh_names, (void*)session);
}
if (greeter_on && strcmp(bot_nick, nick) != 0) {
printf("Greeting %s\n", nick);
botcmd_greet(session, nick, bot_channel);
}
}
void event_privmsg (irc_session_t * irc_session, const char * event, const char * origin, const char ** params, unsigned int count) {
char nickbuf[128], md5sum[MD5_HASHSUM_SIZE];
SessionPtr session;
//dump_event (irc_session, event, origin, params, count);
params[1] = irc_color_strip_from_mirc( params[1] );
addlog ("'%s' said to me (%s): %s", origin ? origin : "someone", params[0], params[1] );
if ( !origin )
return;
irc_target_get_nick( origin, nickbuf, sizeof(nickbuf) );
md5_string( origin, md5sum );
session = get_session( SESSION_IRC, md5sum );
if( !( session->dbuser ) ) {
irc_cmd_notice( sysconfig.irc_session, nickbuf, "You must be loged in to use any features." );
} else {
irc_cmd_notice( sysconfig.irc_session, nickbuf, "Now just how did you manage that..." );
}
return;
}
void event_privmsg(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
char *pch;
std::string comandos = params[1];
std::vector<std::string> notificar;
sql::Driver *driver;
sql::Connection *con;
sql::Statement *stmt;
sql::ResultSet *res;
driver = get_driver_instance();
con = driver->connect(direccion, usuario, password);
if ( !origin || count != 2 )
return;
irc_ctx_t * ctx = (irc_ctx_t *) irc_get_ctx (session);
char nickbuf[128], text[1024];
irc_target_get_nick (origin, nickbuf, sizeof(nickbuf));
pch = strtok ((char *)params[1]," ,.-/\r\n");
if(pch != NULL)
{
if(strcmp(pch,"login") == 0)
{
char *arg1;
char *arg2;
pch = strtok (NULL," ,.-/\r\n");
if(pch == NULL){return;}
arg1 = pch;
pch = strtok (NULL," ,.-/\r\n");
if(pch == NULL){return;}
arg2 = pch;
con->setSchema("bigbug");
stmt = con->createStatement();
char querysql[256];
sprintf (querysql, "SELECT * from users where usuario = '%s' and clave = md5('%s');", arg1,arg2);
res = stmt->executeQuery(querysql);
while (res->next()) {
if ( ctx->userLogged.find(nickbuf) == ctx->userLogged.end() )
ctx->userLogged[nickbuf] = arg1;
sprintf (text, "%s, estas loggeado.", nickbuf);
irc_cmd_notice (session, nickbuf, text);
}
delete res;
delete stmt;
delete con;
}
else if(strcmp(pch,"amilogin") == 0)
{
if ( ctx->userLogged.find(nickbuf) != ctx->userLogged.end() )
{
sprintf (text, "%s, estas loggeado. Usuario: %s", nickbuf,ctx->userLogged[nickbuf].c_str());
irc_cmd_notice (session, nickbuf, text);
}
}
else if(strcmp(pch,"plan") == 0)
{
if ( ctx->userLogged.find(nickbuf) != ctx->userLogged.end() )
{
Plan *plan = new Plan(direccion, usuario, password);
notificar = plan->procesar(ctx->userLogged[nickbuf],comandos.c_str());
for(size_t i=0; i<notificar.size(); i++)
{
irc_cmd_notice (session, nickbuf, irc_color_convert_to_mirc(notificar[i].c_str()));
}
delete plan;
}
}
}
}
void event_channel (irc_session_t * irc_session, const char * event, const char * origin, const char ** params, unsigned int count) {
char buffer[512];
char nickbuf[128];
char md5sum[MD5_HASHSUM_SIZE];
ConfigArrayPtr setting;
SessionPtr session;
if ( count != 2 )
return;
params[1] = irc_color_strip_from_mirc( params[1] );
addlog ("'%s' said in channel %s: %s", origin ? origin : "someone", params[0], params[1] );
if ( !origin )
return;
irc_target_get_nick( origin, nickbuf, sizeof(nickbuf) );
md5_string( origin, md5sum );
session = get_session( SESSION_IRC, md5sum );
if ( !strcmp (params[1], "help") ) {
if( ( session->dbuser ) && ( session->dbuser->level >= LEVEL_MODERATOR ) )
snprintf(buffer, sizeof(buffer), "%s", irc_color_convert_to_mirc( "[B]Usage[/B] - quit, help, dcc send, topic, mode, whois, nick" ) );
else
snprintf(buffer, sizeof(buffer), "%s", irc_color_convert_to_mirc( "[B]Usage[/B] - help, dcc send, login" ) );
irc_cmd_notice( irc_session, params[0], buffer );
}
if ( !strcmp (params[1], "ctcp") ) {
irc_cmd_ctcp_request (irc_session, nickbuf, "PING 223");
irc_cmd_ctcp_request (irc_session, nickbuf, "FINGER");
irc_cmd_ctcp_request (irc_session, nickbuf, "VERSION");
irc_cmd_ctcp_request (irc_session, nickbuf, "TIME");
}
if ( !strcmp (params[1], "dcc chat") ) {
irc_dcc_t dccid;
irc_dcc_chat (irc_session, 0, nickbuf, dcc_recv_callback, &dccid);
addlog ("DCC chat ID: %d", dccid);
}
if ( !strcmp (params[1], "dcc send") ) {
irc_dcc_t dccid;
setting = GetSetting( "HTTP Images" );
snprintf(buffer, sizeof(buffer), "%s/cookie.gif", setting->string_value );
irc_dcc_sendfile (irc_session, 0, nickbuf, buffer, dcc_file_send_callback, &dccid);
addlog ("DCC send ID: %d", dccid);
}
if( ( session->dbuser ) && ( session->dbuser->level >= LEVEL_MODERATOR ) ) {
if ( !strcmp (params[1], "quit") ) {
irc_cmd_quit (irc_session, "of course, Master!");
}
if ( !strcmp (params[1], "topic") ) {
irc_cmd_topic (irc_session, params[0], 0);
} else if ( strstr (params[1], "topic ") == params[1] ) {
irc_cmd_topic (irc_session, params[0], params[1] + 6);
}
if ( strstr (params[1], "mode ") == params[1] )
irc_cmd_channel_mode (irc_session, params[0], params[1] + 5);
if ( strstr (params[1], "nick ") == params[1] )
irc_cmd_nick (irc_session, params[1] + 5);
if ( strstr (params[1], "whois ") == params[1] )
irc_cmd_whois (irc_session, params[1] + 5);
}
return;
}
void cmd_np(irc_session_t* session, const char* cmd, const char* origin, char* args) {
struct mpd_connection* conn;
struct mpd_song* song;
char master_nick[20];
const char* title;
const char* album;
const char* artist;
int out_len = 20 + 18 /* master_nick + " is now playing: "*/;
char* out_str;
irc_target_get_nick(master_origin, master_nick, 20);
conn = mpd_connection_new(NULL, 0, 30000);
if(mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) {
log_and_print("Impossible de se connecter à MPD");
mpd_connection_free(conn);
return;
}
mpd_send_current_song(conn);
song = mpd_recv_song(conn);
if(song == NULL) {
out_len += strlen("THE GAME");
out_str = malloc(out_len * sizeof(char));
strcpy(out_str, master_nick);
strcat(out_str, " is now playing: THE GAME");
irc_cmd_msg(session, channel, out_str);
free(out_str);
return;
}
title = mpd_song_get_tag(song, MPD_TAG_TITLE, 0);
album = mpd_song_get_tag(song, MPD_TAG_ALBUM, 0);
artist = mpd_song_get_tag(song, MPD_TAG_ARTIST, 0);
if(title)
out_len += strlen(title) + 2;
if(album)
out_len += strlen(album) + 2;
if(artist)
out_len += strlen(artist) + 2;
out_str = malloc(out_len * sizeof(char));
strcpy(out_str, master_nick);
strcat(out_str, " is now playing: ");
if(title)
strcat(out_str, title);
if(artist) {
strcat(out_str, " - ");
strcat(out_str, artist);
}
if(album) {
strcat(out_str, " - ");
strcat(out_str, album);
}
irc_cmd_msg(session, channel, out_str);
free(out_str);
mpd_song_free(song);
mpd_connection_free(conn);
}
/**
* @brief Private Message Event
* Diese Funktion wird aufgerufen, wenn der Bot eine Private Message erhält.
* Loggt das Event.
* Überprüft ob die geschickte Nachricht ein Befehl ist, wenn ja wird dieser ausgeführt.
* Reagiert auf quit, help, topic <text>, nick <name>, log, logon, logoff, time, lastseen <name>, mode, whois.
* @param session ein Pointer von irc_session_t, Session von der ein Event erzeugt wird.
* @param event ein konstanter char Pointer, Event Name
* @param origin ein konstanter char Pointer, Herkunfts Name (Person die die Private Nachricht geschickt hat)
* @param params const char, Liste der Parameter (0 - Eigener Nick, 1 - Message Text)
* @param count ein unsigned int, Anzahl der Parameter
*/
void event_privmsg (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
printf ("'%s' said me (%s): %s\n",
origin ? origin : "someone",
params[0], params[1] );
if ( !origin )
return;
char nickbuf[128];
irc_target_get_nick (origin, nickbuf, sizeof(nickbuf));
if(logging==1)
{
char theTime[100];
struct tm * clock;
time_t sec;
time(&sec);
clock = localtime(&sec);
strftime(theTime, sizeof(theTime), "%Y-%m-%d %H:%M:%S", clock);
char message[1024];
sprintf(message, "INSERT INTO log (name, chan, message, date) VALUES ('%s', 'said me (%s):', '%s', '%s');", nickbuf, params[0], params[1], theTime);
logSQL(message);
}
if ( !strcmp (params[1], "quit") )
irc_cmd_quit (session, "of course, Master!");
if ( !strcmp (params[1], "help") )
{
irc_cmd_msg (session, nickbuf, "quit, help, topic <text>, nick <name>, log, logon, logoff, time, lastseen <name>");
}
if ( !strcmp (params[1], "time") )
{
char theTime[100];
struct tm * clock;
time_t sec;
time(&sec);
clock = localtime(&sec);
strftime(theTime, sizeof(theTime), "%Y-%m-%d %H:%M:%S", clock);
irc_cmd_msg (session, nickbuf, theTime);
}
if ( !strcmp (params[1], "logon") )
{
logging = 1;
irc_cmd_msg (session, nickbuf, "Logging eingeschaltet");
}
if ( !strcmp (params[1], "logoff") )
{
logging = 0;
irc_cmd_msg (session, nickbuf, "Logging ausgeschaltet");
}
if ( !strcmp (params[1], "log") )
{
sqlite3_stmt *vm;
sqlite3_open(DB_FILE, &dbhandle);
sqlite3_prepare(dbhandle, "SELECT * FROM log", -1, &vm, NULL);
while (sqlite3_step(vm) != SQLITE_DONE)
{
char text[1024];
sprintf(text, "(%s) %s %s %s", sqlite3_column_text(vm, 4), sqlite3_column_text(vm, 1),sqlite3_column_text(vm, 2),sqlite3_column_text(vm, 3));
irc_cmd_msg (session, nickbuf, text);
}
sqlite3_finalize(vm);
sqlite3_close(dbhandle);
}
if ( strstr (params[1], "lastseen ") == params[1] )
{
sqlite3_stmt *vm;
sqlite3_open(DB_FILE, &dbhandle);
char search[50];
char name[50];
sprintf(name, "%s", params[1] + 9);
if(name[(strlen(name)-1)] == ' ')
{
name[(strlen(name)-1)] = '\0';
}
sprintf(search, "SELECT * FROM log WHERE name = '%s' ORDER BY id DESC LIMIT 1", name);
sqlite3_prepare(dbhandle, search, -1, &vm, NULL);
sqlite3_step(vm);
char text[1024];
if(sqlite3_column_text(vm, 1)!=NULL)
{
sprintf(text, "%s last seen %s", sqlite3_column_text(vm, 1), sqlite3_column_text(vm, 4));
}
else
{
sprintf(text, "%s never seen", params[1]+9);
}
irc_cmd_msg (session, nickbuf, text);
sqlite3_finalize(vm);
sqlite3_close(dbhandle);
}
if ( !strcmp (params[1], "topic") )
irc_cmd_topic (session, params[0], 0);
else if ( strstr (params[1], "topic ") == params[1] )
irc_cmd_topic (session, params[0], params[1] + 6);
if ( strstr (params[1], "mode ") == params[1] )
irc_cmd_channel_mode (session, params[0], params[1] + 5);
if ( strstr (params[1], "nick ") == params[1] )
{
irc_cmd_nick (session, params[1] + 5);
}
if ( strstr (params[1], "whois ") == params[1] )
irc_cmd_whois (session, params[1] + 5);
}
void event_message(irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {
irc_ctx_t *ctx = (irc_ctx_t*)irc_get_ctx(session);
irc_thread_data *self = (irc_thread_data*)ctx->self;
// shutup compiler complaining about unused variables
(void) event; (void) count;
char *lin = NULL;
char *netid = NULL;
char *data = NULL;
char *nick = malloc(sizeof(char)*256);
char *st = NULL;
dbuf* buf = NULL;
irc_target_get_nick(origin, nick, 255);
if (self->d.id != 0) goto out;
if (params[1]) {
lin = strdup(params[1]);
netid = malloc(sizeof(char)*512);
data = malloc(sizeof(char)*512);
//if (!netid || !data || !lin) goto clean;
int vc[9];
int rc = 0;
// note: we assume the regex matches *always* the id and the data, for making the code smaller and simpler
rc = pcre_exec(self->regex_final, NULL, lin, (int)strlen(lin), 0, 0, vc, 9);
if (rc >= 0 && !parse)
goto clean; // failed parsing
if (rc >= 0) rc = DONE;
if (rc < 0) {
rc = pcre_exec(self->regex, NULL, lin, (int)strlen(lin), 0, 0, vc, 9);
if (rc < 0 || !parse)
goto clean; // no match with the final nor the "normal"
}
HASH_FIND_STR((ctx->ds), nick, buf);
if (!buf) {
irc_debug(self, "allocating a new buffer structure for %s", nick);
buf = malloc(sizeof(dbuf));
buf->dt = malloc(sizeof(char)*MTU*4);
memset(buf->dt, 0, MTU*4);
strncpy(buf->nick, nick, 127);
HASH_ADD_STR((ctx->ds), nick, buf);
}
// ugly workaround to a bug that comes from nonwhere, try to know why it doesn't work somewhen
{
char buffer[MTU*4] = {0};
snprintf(buffer, MTU*4-1, "%s%s", buf->dt, data);
snprintf(buf->dt, MTU*4-1, "%s", buffer);
}
if (rc != DONE) goto clean; // data already added, but there is still more data to come
int z, len = 0;
len = debase64(buf->dt, &st);
if (len < 1) {
irc_debug(self, "error when decoding base64 buffer (%d)", len);
goto iclean;
}
if ((z = zmq_send(ctx->data, st, len, 0)) < 0) {
irc_debug(self, "error when trying to send a message to the tun (warning, this WILL result in missing packets!)", zmq_strerror(errno));
}
iclean:
memset(buf->dt, 0, strlen(buf->dt));
clean:
if (lin) free(lin);
if (netid) free(netid);
if (data) free(data);
if (st) free(st);
}
out:
if (nick) free(nick);
}
static void libirc_process_incoming_data (irc_session_t * session, int process_length)
{
#define MAX_PARAMS_ALLOWED 10
char buf[2*512], *p, *s;
const char * command = 0, *prefix = 0, *params[MAX_PARAMS_ALLOWED+1];
int code = 0, paramindex = 0;
if ( process_length > (int)sizeof(buf) )
abort(); // should be impossible
memcpy (buf, session->incoming_buf, process_length);
buf[process_length] = '\0';
memset (params, 0, sizeof(params));
p = buf;
/*
* From RFC 1459:
* <message> ::= [':' <prefix> <SPACE> ] <command> <params> <crlf>
* <prefix> ::= <servername> | <nick> [ '!' <user> ] [ '@' <host> ]
* <command> ::= <letter> { <letter> } | <number> <number> <number>
* <SPACE> ::= ' ' { ' ' }
* <params> ::= <SPACE> [ ':' <trailing> | <middle> <params> ]
* <middle> ::= <Any *non-empty* sequence of octets not including SPACE
* or NUL or CR or LF, the first of which may not be ':'>
* <trailing> ::= <Any, possibly *empty*, sequence of octets not including
* NUL or CR or LF>
*/
// Parse <prefix>
if ( buf[0] == ':' )
{
while ( *p && *p != ' ')
p++;
*p++ = '\0';
// we use buf+1 to skip the leading colon
prefix = buf + 1;
// If LIBIRC_OPTION_STRIPNICKS is set, we should 'clean up' nick
// right here
if ( session->options & LIBIRC_OPTION_STRIPNICKS )
{
for ( s = buf + 1; *s; ++s )
{
if ( *s == '@' || *s == '!' )
{
*s = '\0';
break;
}
}
}
}
// Parse <command>
if ( isdigit (p[0]) && isdigit (p[1]) && isdigit (p[2]) )
{
p[3] = '\0';
code = atoi (p);
p += 4;
}
else
{
s = p;
while ( *p && *p != ' ')
++p;
*p++ = '\0';
command = s;
}
// Parse middle/params
while ( *p && paramindex < MAX_PARAMS_ALLOWED )
{
// beginning from ':', this is the last param
if ( *p == ':' )
{
params[paramindex++] = p + 1; // skip :
break;
}
// Just a param
for ( s = p; *p && *p != ' '; ++p )
;
params[paramindex++] = s;
if ( !*p )
break;
*p++ = '\0';
}
// Handle PING/PONG
if ( command && !strcmp (command, "PING") && params[0] )
{
irc_send_raw (session, "PONG %s", params[0]);
return;
}
// and dump
if ( code )
{
// We use session->motd_received to check whether it is the first
// RPL_ENDOFMOTD or ERR_NOMOTD after the connection.
if ( (code == 376 || code == 422) && !session->motd_received )
{
session->motd_received = 1;
if ( session->callbacks.event_connect )
(*session->callbacks.event_connect) (session, "CONNECT", prefix, params, paramindex);
}
if ( session->callbacks.event_numeric )
(*session->callbacks.event_numeric) (session, code, prefix, params, paramindex);
}
else
{
if ( !strcmp (command, "NICK") )
{
/*
* If we're changed our nick, we should save it.
*/
char nickbuf[256];
irc_target_get_nick (prefix, nickbuf, sizeof(nickbuf));
if ( !strcmp (nickbuf, session->nick) && paramindex > 0 )
{
free (session->nick);
session->nick = strdup (params[0]);
}
if ( session->callbacks.event_nick )
(*session->callbacks.event_nick) (session, command, prefix, params, paramindex);
}
else if ( !strcmp (command, "QUIT") )
{
if ( session->callbacks.event_quit )
(*session->callbacks.event_quit) (session, command, prefix, params, paramindex);
}
else if ( !strcmp (command, "JOIN") )
{
if ( session->callbacks.event_join )
(*session->callbacks.event_join) (session, command, prefix, params, paramindex);
}
else if ( !strcmp (command, "PART") )
{
if ( session->callbacks.event_part )
(*session->callbacks.event_part) (session, command, prefix, params, paramindex);
}
else if ( !strcmp (command, "MODE") )
{
if ( paramindex > 0 && !strcmp (params[0], session->nick) )
{
params[0] = params[1];
paramindex = 1;
if ( session->callbacks.event_umode )
(*session->callbacks.event_umode) (session, command, prefix, params, paramindex);
}
else
{
if ( session->callbacks.event_mode )
(*session->callbacks.event_mode) (session, command, prefix, params, paramindex);
}
}
else if ( !strcmp (command, "TOPIC") )
{
if ( session->callbacks.event_topic )
(*session->callbacks.event_topic) (session, command, prefix, params, paramindex);
}
else if ( !strcmp (command, "KICK") )
{
if ( session->callbacks.event_kick )
(*session->callbacks.event_kick) (session, command, prefix, params, paramindex);
}
else if ( !strcmp (command, "PRIVMSG") )
{
if ( paramindex > 1 )
{
unsigned int msglen = strlen (params[1]);
/*
* Check for CTCP request (a CTCP message starts from 0x01
* and ends by 0x01
*/
if ( params[1][0] == 0x01 && params[1][msglen-1] == 0x01 )
{
char ctcp_buf[ 128 ];
memset( ctcp_buf, 0, 128 );
msglen -= 2;
if ( msglen > sizeof(ctcp_buf) - 1 )
msglen = sizeof(ctcp_buf) - 1;
memcpy (ctcp_buf, params[1] + 1, msglen);
ctcp_buf[msglen] = '\0';
if ( strstr(ctcp_buf, "DCC ") == ctcp_buf )
libirc_dcc_request (session, prefix, ctcp_buf);
else if ( strstr(ctcp_buf, "ACTION ") == ctcp_buf
&& session->callbacks.event_ctcp_action )
{
params[0] = ctcp_buf + 7; // the length of "ACTION "
paramindex = 1;
(*session->callbacks.event_ctcp_action) (session, "ACTION", prefix, params, paramindex);
}
else
{
params[0] = ctcp_buf;
paramindex = 1;
if ( session->callbacks.event_ctcp_req )
(*session->callbacks.event_ctcp_req) (session, "CTCP", prefix, params, paramindex);
}
}
else if ( !strcmp (params[0], session->nick) )
{
if ( session->callbacks.event_privmsg )
(*session->callbacks.event_privmsg) (session, command, prefix, params, paramindex);
}
else
{
if ( session->callbacks.event_channel )
(*session->callbacks.event_channel) (session, command, prefix, params, paramindex);
}
}
}
else if ( !strcmp (command, "NOTICE") )
{
unsigned int msglen = strlen (params[1]);
/*
* Check for CTCP request (a CTCP message starts from 0x01
* and ends by 0x01
*/
if ( paramindex > 1 && params[1][0] == 0x01 && params[1][msglen-1] == 0x01 )
{
char ctcp_buf[512];
msglen -= 2;
if ( msglen > sizeof(ctcp_buf) - 1 )
msglen = sizeof(ctcp_buf) - 1;
memcpy (ctcp_buf, params[1] + 1, msglen);
ctcp_buf[msglen] = '\0';
params[0] = ctcp_buf;
paramindex = 1;
if ( session->callbacks.event_ctcp_rep )
(*session->callbacks.event_ctcp_rep) (session, "CTCP", prefix, params, paramindex);
}
else
{
if ( session->callbacks.event_notice )
(*session->callbacks.event_notice) (session, command, prefix, params, paramindex);
}
}
else if ( !strcmp (command, "INVITE") )
{
if ( session->callbacks.event_invite )
(*session->callbacks.event_invite) (session, command, prefix, params, paramindex);
}
else if ( !strcmp (command, "KILL") )
{
; /* ignore this event - not all servers generate this */
}
else
{
/*
* The "unknown" event is triggered upon receipt of any number of
* unclassifiable miscellaneous messages, which aren't handled by
* the library.
*/
if ( session->callbacks.event_unknown )
(*session->callbacks.event_unknown) (session, command, prefix, params, paramindex);
}
}
}
void IRC::event_channel(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
// what is this for?
if ( !origin || count != 2 )
return;
char nickbuf[128];
irc_target_get_nick (origin, nickbuf, sizeof(nickbuf));
std::string nick = std::string(nickbuf);
std::string msg = std::string(params[1]);
// find channel
bool found = false;
ConfigHandler::IRCOptions_Bridge b;
std::vector<ConfigHandler::IRCOptions_Bridge>::iterator it;
for(it = _sessionServerMap[session].channelVector.begin(); it != _sessionServerMap[session].channelVector.end(); it++)
{
b = *it;
if(b.ircChannelName == params[0])
{
found = true;
break;
}
}
if(!found)
{
std::cerr << "IRC::event_channel() can't find channel!" << std::endl;
std::cerr << " -- nick: " << nickbuf << ": " << params[1] << std::endl;
std::cerr << " -- event: " << event << std::endl;
std::cerr << " -- origin: " << origin << std::endl;
std::cerr << " -- params 0: " << params[0] << std::endl;
return;
}
#ifdef DEBUG
else
{
std::cerr << "IRC::event_channel() found channel!" << std::endl;
std::cerr << " -- nick: " << nickbuf << ": " << params[1] << std::endl;
std::cerr << " -- event: " << event << std::endl;
std::cerr << " -- origin: " << origin << std::endl;
std::cerr << " -- params 0: " << params[0] << std::endl;
std::cerr << std::endl;
std::cerr << " -- bridge rs: " << b.rsLobbyName << std::endl;
std::cerr << " -- bridge irc: " << b.ircChannelName << std::endl;
}
#endif
// put in queue
ircMsg ircMsg;
ircMsg.msg = msg;
ircMsg.nick = nick;
ircMsg.bridge = b;
ircMsg.session = session;
_msgQueue.push(ircMsg);
}
