Exemple #1
0
/*
====================
IRC_Callback_Numeric

Libircclient event handler for numeric events.
====================
*/
static void IRC_Callback_Numeric(void *session, unsigned int event, const char *origin, const char **params, unsigned int count) {
    unsigned int i;
    irc_session_t *s = (irc_session_t*)irc_get_ctx(session);
    
    if(irc_eventlog.integer) {
        IRC_Printf("^1%i^7 [^5%i^7] origin: %s, params: \n", ((irc_session_t*)irc_get_ctx(session))->handle, event, origin);
        for(i = 0; i < count; ++i)
            IRC_Printf("    %i: ^2%s\n", i, params[i]);
    }
    
    IRC_Callback_QuakeC(SVVM_prog, s->handle, NULL, event, origin, params, count);
}
void event_connect (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);
	dump_event (session, event, origin, params, count);

	irc_cmd_join (session, ctx->channel, 0);
}
void event_numeric(irc_session_t *session,unsigned int event,const char *origin,
                   const char **params, unsigned count)
{
    CslIrcContext *context=(CslIrcContext*)irc_get_ctx(session);

    switch (event)
    {
        case LIBIRC_RFC_ERR_NICKNAMEINUSE:
        case LIBIRC_RFC_ERR_NICKCOLLISION:
            irc_auto_rename_nick(session);
            return;
        case LIBIRC_RFC_RPL_TOPIC: //topic notification on join
            if (count>2)
            {
                CslIrcEvent evt(context->Target,CslIrcEvent::TOPIC,A2U(params[1]));
                evt.Ints.Add(event);
                evt.AddCharData(params[2]);
                wxPostEvent(context->EvtHandler,evt);
            }
            return;
        case LIBIRC_RFC_RPL_NAMREPLY:
            if (count>3)
            {
                irc_notify_player_list(session,params[2],params[3]);
                return;
            }
            break;
        case LIBIRC_RFC_RPL_ENDOFNAMES:
            return;

        case LIBIRC_RFC_ERR_CANNOTSENDTOCHAN:
            if (count>2)
            {
                CslIrcEvent evt(context->Target,CslIrcEvent::NUMERIC,A2U(params[1]));
                evt.Ints.Add(event);
                evt.AddCharData(params[2]);
                wxPostEvent(context->EvtHandler,evt);
                return;
            }
            break;
    }

    wxUint32 i;
    wxString s,p;

    s<<event<<wxT(": ");

    for (i=0;i<count;i++)
    {
        p=A2U(params[i]);
        if (!p.CmpNoCase(context->Server->Network->Nick))
            continue;

        s<<p<<wxT(" ");
    }

    CslIrcEvent evt(context->Target,CslIrcEvent::NUMERIC,s);
    evt.Ints.Add(event);
    wxPostEvent(context->EvtHandler,evt);
}
Exemple #4
0
void event_connect (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	sprintf(botnick,"%s",ctx.nick);
	irc_ctx_t * ctx = (irc_ctx_t *) irc_get_ctx (session);
	irc_cmd_join (session, ctx->channel, 0);
	currentChannelCount++;
}
Exemple #5
0
void event_channel_notice(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count) {

	if (!origin || count != 2)
		return;

	struct ircbot_context * ctx = (struct ircbot_context *) irc_get_ctx(session);
	std::string message = params[1];
	std::string user = origin;
	std::string command;

	printf("%s\n", message.c_str());

	ctx->pLog->logMessage(&message);

	if (!ctx->pLog->mDatabase->existUser(&user))
		ctx->pLog->mDatabase->createUser(&user);

	ctx->pLog->mDatabase->updateUser(&user);

	DEBUG("Message:" << message);
	DEBUG("User:"******"Command:" << command);
		ctx->pController->executeCommand(&command, ctx, &user);
	}

}
Exemple #6
0
/*
====================
IRC_Callback_Default

Libircclient event handler for non-numeric events.
====================
*/
static void IRC_Callback_Default(void *session, const char *event, const char *origin, const char **params, unsigned int count) {
    unsigned int i;
    irc_session_t *s = (irc_session_t*)irc_get_ctx(session);
    char nick[MAX_INPUTLINE];
    
    
    if(irc_eventlog.integer) {
        IRC_Printf("^1%i^7 [^3%s^7] origin: %s, params: \n", s->handle, event, origin);
        for(i = 0; i < count; ++i)
            IRC_Printf("    %i: ^2%s\n", i, params[i]);
    }
    
    if(!strcmp(event, "CONNECT")) {
        // In case the server doesn't like our nickname
        strlcpy(s->nick, params[0], sizeof(s->nick));
    } else if(!strcmp(event, "NICK")) {
        irc_target_get_nick(origin, nick, sizeof(nick));
        if(!strcmp(s->nick, nick))  // our nickname changed
            strlcpy(s->nick, params[0], sizeof(s->nick));
    } else if(!strcmp(event, "CTCP") && !strncmp(params[0], "VERSION", 7)) {
        char ctcpreply[sizeof(engineversion) + 8];
        irc_target_get_nick(origin, nick, sizeof(nick));
        strlcpy(ctcpreply, "VERSION ", sizeof(ctcpreply));
        strlcat(ctcpreply, engineversion, sizeof(ctcpreply));
        irc_cmd_ctcp_reply(s->session, nick, ctcpreply);
    }
    
    IRC_Callback_QuakeC(SVVM_prog, s->handle, event, -1, origin, params, count);
}
Exemple #7
0
void GaMatchmakingState::event_ctcp_action(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	GaMatchmakingState* pBridge = reinterpret_cast< GaMatchmakingState* >( irc_get_ctx( session ) );
	BcScopedLock< BcMutex > Lock( pBridge->Lock_ );


}
Exemple #8
0
void irc_eventcode_callback(irc_session_t *s, unsigned int event, const char *origin, const char **p, unsigned int count) {
	dazeus::Server *server = (dazeus::Server*) irc_get_ctx(s);
	std::vector<std::string> params;
	for(unsigned int i = 0; i < count; ++i) {
		params.push_back(std::string(p[i]));
	}
	server->slotNumericMessageReceived(std::string(origin), event, params);
}
Exemple #9
0
void event_join(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) origin; (void) params; (void) count;
    (void) self;
}
void event_join( irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count )
{
    if ( !origin )
        return;

    IRCSessionContext* p_ctx = static_cast< IRCSessionContext* >( irc_get_ctx( session ) );
    p_ctx->_p_handler->joined( params[ 0 ], origin );
}
Exemple #11
0
void Kommunikater::event_connect (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_cmd_join (session, ctx->channel, 0);

	thread_id_t tid;
	CREATE_THREAD(&tid, myThread, &state);
}
void event_part( irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count )
{
    if ( !origin )
        return;

    IRCSessionContext* p_ctx = static_cast< IRCSessionContext* >( irc_get_ctx( session ) );
    p_ctx->_p_handler->left( params[ 0 ], std::string( origin ) );
}
Exemple #13
0
/**
* @brief Connect Event
* Funktion wird aufgerufen, sobald der Bot sich mit dem Server erfolgreich verbunden hat.
* @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
* @param params const char, Liste der Parameter
* @param count ein unsigned int, Anzahl der Parameter
*/
void event_connect (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_cmd_join (session, ctx->channel, 0);
	
	printf("Connected to Server!\n");
}
void event_kick( irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count )
{
    if ( !origin || ( count < 1 ) )
        return;

    IRCSessionContext* p_ctx = static_cast< IRCSessionContext* >( irc_get_ctx( session ) );
    p_ctx->_p_handler->recvKicked( params[ 0 ], std::string( origin ), std::string( params[ 1 ] ) );
}
void event_quit(irc_session_t *session,const char* WXUNUSED(event),
                const char *origin,const char **params,unsigned int count)
{
    CslIrcContext *context=(CslIrcContext*)irc_get_ctx(session);
    CslIrcEvent evt(context->Target,CslIrcEvent::QUIT,A2U(origin));
    if (count>0)
        evt.AddCharData(params[0]);
    wxPostEvent(context->EvtHandler,evt);
}
Exemple #16
0
void GaMatchmakingState::event_nick(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	GaMatchmakingState* pBridge = reinterpret_cast< GaMatchmakingState* >( irc_get_ctx( session ) );
	BcScopedLock< BcMutex > Lock( pBridge->Lock_ );
	for( unsigned int i = 0; i < count; ++i )
	{
		BcPrintf( "event_nick %s, %s\n", origin, params[i] );
	}
}
Exemple #17
0
Twitch::~Twitch() {
	if ( session ) {
		TwitchContext *ctx = ( TwitchContext * ) irc_get_ctx( session );
		if ( ctx ) {
			delete ctx;
		}

		Disconnect();
	}
}
Exemple #18
0
void event_connect(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) origin; (void) params; (void) count;

    irc_debug(self, "(%s) connected to irc", ctx->nick);
    irc_cmd_join(session, ctx->channel, 0);
}
Exemple #19
0
void
slack_handler_join(
    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);
    syslog(LOG_INFO, "%s connected to channel %s", origin, ctx->channel);
}
Exemple #20
0
void event_connect(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count) {
	struct ircbot_context * ctx = (struct ircbot_context *) irc_get_ctx(session);

	DEBUG("event connected")

	ctx->pConnection->mConnected = true;

	for (unsigned int i = 0; i < ctx->pConnection->mChannel.size(); i++)
		irc_cmd_join(session, ctx->pConnection->mChannel[i]->c_str(), 0);
}
Exemple #21
0
void GaMatchmakingState::event_privmsg(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	GaMatchmakingState* pBridge = reinterpret_cast< GaMatchmakingState* >( irc_get_ctx( session ) );
	BcScopedLock< BcMutex > Lock( pBridge->Lock_ );
	
	if ( pBridge->HandshakeState_ == HSS_WAIT_INVITE || pBridge->HandshakeState_ == HSS_WAIT_ADDR )
	{
		// Grab short name from origin.
		static BcChar NameCopy[ 256 ];
		BcStrCopy( NameCopy, origin );
		BcChar* pNameEnd = BcStrStr( NameCopy, "!" );

		if( pNameEnd != NULL )
		{
			*pNameEnd = '\0';
		}

		if(count > 1 && strstr( params[1], "ADDR:" ) == params[1] )
		{
			BcPrintf( "Recv: %s\n", params[1] );

			// We got send an address first, so send ours.
			if( ClientID_ == BcErrorCode )
			{
				if( pBridge->sendLocalAddress( NameCopy ) )
				{
					ClientID_ = 1;
				}
				else
				{
					// Failure :(
					pBridge->HandshakeState_ = HSS_WAIT_INVITE;
					return;
				}
			}

			BcU32 LA, LB, LC, LD, LE;
			BcU32 A, B, C, D, E;
			BcSScanf( params[1], "ADDR:%u.%u.%u.%u:%u/%u.%u.%u.%u:%u", &LA, &LB, &LC, &LD, &LE, &A, &B, &C, &D, &E );

			pBridge->LANHandshakeAddr_ = LA << 24 | LB << 16 | LC << 8 | LD;
			pBridge->LANHandshakePort_ = LE;

			pBridge->RemoteHandshakeAddr_ = A << 24 | B << 16 | C << 8 | D;
			pBridge->RemoteHandshakePort_ = E;
			pBridge->HandshakeState_ = HSS_COMPLETE;
		}
		else
		{
			pBridge->HandshakeState_ = HSS_WAIT_INVITE;
		}
	}

	BcPrintf("event_privmsg done.\n");
}
void event_connect(irc_session_t *session,const char* WXUNUSED(event),const char *origin,
                   const char** WXUNUSED(params),unsigned int WXUNUSED(count))
{
    CslIrcContext *context=(CslIrcContext*)irc_get_ctx(session);

    if (!context || !context->EvtHandler)
        return;

    CslIrcEvent evt(context->Target,CslIrcEvent::CONNECT);
    wxPostEvent(context->EvtHandler,evt);
}
void event_privmsg(irc_session_t *session,const char* WXUNUSED(event),
                   const char *origin,const char **params,unsigned int count)
{
    if (count<2 || !*params[1])
        return;

    CslIrcContext *context=(CslIrcContext*)irc_get_ctx(session);
    CslIrcEvent evt(context->Target,CslIrcEvent::PRIVMSG,A2U(origin));
    evt.AddCharData(params[1]);
    wxPostEvent(context->EvtHandler,evt);
}
void event_numeric( irc_session_t * session, unsigned int event, const char * origin, const char ** params, unsigned int count )
{
    IRCSessionContext* p_ctx = static_cast< IRCSessionContext* >( irc_get_ctx( session ) );

    // handle /names stuff
    if ( event == LIBIRC_RFC_RPL_NAMREPLY )
    {
        std::vector< std::string > names;
        std::string namestring( params[ 3 ] );
        
        yaf3d::explode( namestring, " ", &names );
        // fill the list
        p_ctx->_p_handler->_nickNames.clear();
        for ( size_t cnt = 0; cnt < names.size(); ++cnt )
            p_ctx->_p_handler->_nickNames.push_back( names[ cnt ] );
    }
    // this signalized the end of name list transmission
    else if ( event == LIBIRC_RFC_RPL_ENDOFNAMES )
    {
        p_ctx->_p_handler->recvMemberList( params[ 1 ] );
    }
    // handle /whois stuff
    else if ( event == LIBIRC_RFC_RPL_WHOISUSER )
    {
        if ( count > 1 )
        {
            std::string header( "WHOIS " );
            header += params[ 1 ];
            p_ctx->_p_handler->recvMessage( p_ctx->_channel, "* ", header );
            for ( unsigned int cnt = 2; cnt < count; cnt ++ )
                p_ctx->_p_handler->recvMessage( p_ctx->_channel, "- ", params[ cnt ] );
        }
    }
    else if ( event == LIBIRC_RFC_RPL_ENDOFWHOIS )
    {
        p_ctx->_p_handler->recvMessage( p_ctx->_channel, "* ", "--------" );
    }
    // just output system message
    else if ( event > 400 )
    {
        std::string msg;

        if ( count > 0 ) 
            msg += std::string( params[ 0 ] );

        if ( count > 1 )
            msg += " " + std::string( params[ 1 ] );

        if ( count > 2 )
            msg += " " + std::string( params[ 2 ] );

        p_ctx->_p_handler->recvSystemMessage( msg );
    }
}
Exemple #25
0
void
slack_handler_connect(
    irc_session_t *session,
    const char *event,
    const char *origin,
    const char **params,
    unsigned int count) {
    syslog(LOG_INFO, "Connecting To IRC Server");
    irc_ctx_t *ctx = (irc_ctx_t *)irc_get_ctx(session);
    irc_cmd_join(session, ctx->channel, NULL);
    //TODO: Add password handling from ctx object
}
void event_ctcp_action(irc_session_t *session,const char* WXUNUSED(event),const char *origin,
                       const char **params,unsigned int count)
{
    if (count<2)
        return;

    CslIrcContext *context=(CslIrcContext*)irc_get_ctx(session);
    CslIrcEvent evt(context->Target,CslIrcEvent::ACTION,A2U(params[0]));
    evt.AddCharData(origin);
    evt.AddCharData(params[1]);
    wxPostEvent(context->EvtHandler,evt);
}
Exemple #27
0
void GaMatchmakingState::event_numeric(irc_session_t * session, unsigned int event, const char * origin, const char ** params, unsigned int count)
{
	GaMatchmakingState* pBridge = reinterpret_cast< GaMatchmakingState* >( irc_get_ctx( session ) );
	BcScopedLock< BcMutex > Lock( pBridge->Lock_ );

	if( event == LIBIRC_RFC_RPL_NAMREPLY )
	{
		for( unsigned int i = 0; i < count; ++i )
		{
			BcPrintf( "event_numeric LIBIRC_RFC_RPL_NAMREPLY: %s, %s\n", origin, params[i] );
		}
	}
}
void event_join(irc_session_t *session,const char* WXUNUSED(event),const char *origin,
                const char **params,unsigned int WXUNUSED(count))
{
    CslIrcContext *context=(CslIrcContext*)irc_get_ctx(session);
    CslIrcEvent evt(context->Target);

    evt.Channel=A2U(params[0]);
    evt.Strings.Add(A2U(origin));
    evt.Type=context->Server->Network->Nick==A2U(origin) ?
             CslIrcEvent::JOIN : CslIrcEvent::JOINED;

    wxPostEvent(context->EvtHandler,evt);
}
Exemple #29
0
void GaMatchmakingState::event_connect(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	GaMatchmakingState* pBridge = reinterpret_cast< GaMatchmakingState* >( irc_get_ctx( session ) );
	BcScopedLock< BcMutex > Lock( pBridge->Lock_ );

	for( unsigned int i = 0; i < count; ++i )
	{
		BcPrintf( "event_connect %s, %s\n", origin, params[i] );
	}

	// Join the channel.
	irc_cmd_join( session, pBridge->Channel_, NULL );
}
Exemple #30
0
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);
	}

}