int irc_cmd_user_mode (irc_session_t * session, const char * mode)
{
if ( mode )
return irc_send_raw (session, "MODE %s %s", session->nick, mode);
else
return irc_send_raw (session, "MODE %s", session->nick);
}
int irc_cmd_list (irc_session_t * session, const char * channel)
{
if ( channel )
return irc_send_raw (session, "LIST %s", channel);
else
return irc_send_raw (session, "LIST");
}
int irc_cmd_channel_mode(irc_session_t * session, const char * channel, const char * mode) {
if (!channel) {
session->lasterror = LIBIRC_ERR_INVAL;
return 1;
}
if (mode)
return irc_send_raw(session, "MODE %s %s", channel, mode);
else
return irc_send_raw(session, "MODE %s", channel);
}
int irc_cmd_kick(irc_session_t * session, const char * nick, const char * channel, const char * comment) {
if (!channel || !nick) {
session->lasterror = LIBIRC_ERR_STATE;
return 1;
}
if (comment)
return irc_send_raw(session, "KICK %s %s :%s", channel, nick, comment);
else
return irc_send_raw(session, "KICK %s %s", channel, nick);
}
int irc_cmd_topic(irc_session_t * session, const char * channel, const char * topic) {
if (!channel) {
session->lasterror = LIBIRC_ERR_STATE;
return 1;
}
if (topic)
return irc_send_raw(session, "TOPIC %s :%s", channel, topic);
else
return irc_send_raw(session, "TOPIC %s", channel);
}
int irc_cmd_join(irc_session_t * session, const char * channel, const char * key) {
if (!channel) {
session->lasterror = LIBIRC_ERR_STATE;
return 1;
}
if (key)
return irc_send_raw(session, "JOIN %s :%s", channel, key);
else
return irc_send_raw(session, "JOIN %s", channel);
}
bool CslIrcSession::SendRawCommand(const wxString& command)
{
if (!CslIrcEngine::GetThread() || m_state!=STATE_CONNECTED)
return false;
return irc_send_raw(m_context.Session,U2A(command))==0;
}
static void irc_ping_command(irc_session_t *session, const char *command, irc_parser_result_t *result) {
if (result->params[0] == NULL) {
return;
}
irc_send_raw(session, "PONG %s", result->params[0]);
}
/*
====================
IRC_SendRaw
Sends a raw irc command to the server.
====================
*/
int IRC_SendRaw(int handle, const char *fmt, ...) {
int err;
va_list args;
char cmd[MAX_INPUTLINE];
va_start(args, fmt);
dpvsnprintf(cmd, sizeof(cmd), fmt, args);
va_end(args);
if(developer.integer)
Con_DPrintf("IRC_SendRaw(%i): %s\n", handle, cmd);
if(!IS_VALID_IRC_SESSION(handle)) {
IRC_Printf("IRC_SendRaw: %i is not a valid session\n", handle);
return -1;
}
if(irc_send_raw(irc_sessions[handle].session, "%s", cmd)) {
err = irc_errno(irc_sessions[handle].session);
if(err) {
IRC_Printf("IRC_SendRaw: Error: %s\n", irc_strerror(err));
return err;
}
}
return 0;
}
int irc_cmd_whois(irc_session_t * session, const char * nick) {
if (!nick) {
session->lasterror = LIBIRC_ERR_INVAL;
return 1;
}
return irc_send_raw(session, "WHOIS %s %s", nick, nick);
}
int irc_cmd_nick(irc_session_t * session, const char * newnick) {
if (!newnick) {
session->lasterror = LIBIRC_ERR_INVAL;
return 1;
}
return irc_send_raw(session, "NICK %s", newnick);
}
int irc_cmd_me(irc_session_t * session, const char * nch, const char * text) {
if (!nch || !text) {
session->lasterror = LIBIRC_ERR_STATE;
return 1;
}
return irc_send_raw(session, "PRIVMSG %s :\x01" "ACTION %s\x01", nch, text);
}
int irc_cmd_ctcp_reply(irc_session_t * session, const char * nick, const char * reply) {
if (!nick || !reply) {
session->lasterror = LIBIRC_ERR_STATE;
return 1;
}
return irc_send_raw(session, "NOTICE %s :\x01%s\x01", nick, reply);
}
int irc_cmd_notice(irc_session_t * session, const char * nch, const char * text) {
if (!nch || !text) {
session->lasterror = LIBIRC_ERR_STATE;
return 1;
}
return irc_send_raw(session, "NOTICE %s :%s", nch, text);
}
int irc_cmd_invite(irc_session_t * session, const char * nick, const char * channel) {
if (!channel || !nick) {
session->lasterror = LIBIRC_ERR_STATE;
return 1;
}
return irc_send_raw(session, "INVITE %s %s", nick, channel);
}
int irc_cmd_names(irc_session_t * session, const char * channel) {
if (!channel) {
session->lasterror = LIBIRC_ERR_STATE;
return 1;
}
return irc_send_raw(session, "NAMES %s", channel);
}
static int lua_irc_send_raw(lua_State *L)
{
void *session;
const char *str;
int result=LIBIRC_ERR_INVAL;
if(lua_gettop(L)==2){
session=lua_touserdata(L,1);
str=lua_tostring(L,2);
if(session && str)
result=irc_send_raw(session,str);
}
lua_pushinteger(L,result);
return 1;
}
static void on_notice( irc_session_t *session,
const char *event,
const char *origin,
const char **params,
unsigned int count) {
printf("<%s> %s \n", origin, params[1]);
if (strcmp(NS_PASSWD_CORRECT, params[1]) == 0) {
printf("Correct password entered...\n");
irc_cmd_join(session, bot_channel, NULL);
} else if (!bot_identified) {
irc_send_raw(session, "NICKSERV IDENTIFY %s", ns_pass);
bot_identified = true;
}
//irc_cmd_join(bot_session, "#fct", NULL);
}
int irc_cmd_005(t_ircconnection* irc)
{
unsigned int i;
i = 0;
while (i < irc->cmd.argc)
{
if (!strcmp("NAMESX", irc->cmd.args[i]) &&
irc_send_raw(irc, "PROTOCTL NAMESX\r\n", 17))
return (1);
else if (!strncmp("PREFIX=", irc->cmd.args[i], 7) &&
cmd_005_prefix(irc, irc->cmd.args[i]))
return (1);
++i;
}
return (0);
}
static int handle_connecting_state(irc_session_t * session) {
char buf[256], hname[256];
// Now we have to determine whether the socket is connected
// or the connect is failed
struct sockaddr_storage saddr, laddr;
socklen_t slen = sizeof (saddr);
socklen_t llen = sizeof (laddr);
if (getsockname(session->sock, (struct sockaddr*) &laddr, &llen) < 0
|| getpeername(session->sock, (struct sockaddr*) &saddr, &slen) < 0) {
// connection failed
DBG_WARN("connection failed");
session->state = LIBIRC_STATE_DISCONNECTED;
session->lasterror = LIBIRC_ERR_CONNECT;
return 1;
}
if (saddr.ss_family == AF_INET)
memcpy(&session->local_addr.v4, &((struct sockaddr_in *) &laddr)->sin_addr, sizeof (struct in_addr));
#if defined (ENABLE_IPV6)
else
memcpy(&session->local_addr.v6, &((struct sockaddr_in6 *) &laddr)->sin6_addr, sizeof (struct in6_addr));
#endif
#if defined (ENABLE_DEBUG)
if (IS_DEBUG_ENABLED(session)) {
if (saddr.ss_family == AF_INET)
fprintf(stderr, "[DEBUG] Detected local address: %s\n", inet_ntoa(session->local_addr.v4));
#if defined (ENABLE_IPV6)
else
fprintf(stderr, "[DEBUG] Detected local address: %s\n", inet_ntoa(session->local_addr.v6));
#endif
}
#endif
session->state = LIBIRC_STATE_CONNECTED;
// Get the hostname
if (gethostname(hname, sizeof (hname)) < 0)
strcpy(hname, "unknown");
// Prepare the data, which should be sent to the server
if (session->server_password) {
snprintf(buf, sizeof (buf), "PASS %s", session->server_password);
irc_send_raw(session, buf);
}
snprintf(buf, sizeof (buf), "NICK %s", session->nick);
irc_send_raw(session, buf);
/*
* RFC 1459 states that "hostname and servername are normally
* ignored by the IRC server when the USER command comes from
* a directly connected client (for security reasons)", therefore
* we don't need them.
*/
snprintf(buf, sizeof (buf), "USER %s %s unknown :%s",
session->nick, session->nick,
session->realname ? session->realname : "realname");
irc_send_raw(session, buf);
return 0;
}
/* Credits to lastdance */
void botcmd_slots(irc_session_t* session, const char* send_to, const char* sender) {
int option;
char buf[256];
buf[0] = 0;
option = rand() % 11;
printf("Doing Slots: %d came out...\n", option);
switch (option) {
case 1:
irc_cmd_kick(session, sender, send_to, "WIN!!1!11!ONE");
break;
case 2:
irc_cmd_msg(session, send_to, "ENORMES SEIOS!");
break;
case 3:
sprintf(buf, "MODE %s -v %s", bot_channel, sender);
irc_send_raw(session, buf);
sprintf(buf, "MODE %s -o %s", bot_channel, sender);
irc_send_raw(session, buf);
/* sprintf(buf, "CHANSERV ACCESS %s DEL %s", bot_channel, sender);
irc_send_raw(session, buf); */
break;
case 4:
sprintf(buf, "MODE %s +o %s", bot_channel, sender);
irc_send_raw(session, buf);
irc_cmd_msg(session, send_to, "GANHASTE OP!");
irc_cmd_kick(session, sender, bot_channel, "solved");
break;
case 5:
/* botcmd_fortune(session, send_to); */
irc_cmd_msg(session, send_to, "YOU WON...!");
break;
case 6:
irc_cmd_msg(session, send_to, "It's time to kick bubble gum and chew some ass!");
botcmd_randkick(session);
break;
case 7:
irc_cmd_msg(session, send_to, ".|.");
break;
case 8:
irc_cmd_msg(session, send_to, "Nao mandas em mim!");
break;
case 9:
irc_cmd_msg(session, send_to, "http://www.youtube.com/watch?v=oHg5SJYRHA0");
break;
case 10:
botcmd_goatsex(session, send_to);
break;
case 0:
irc_cmd_msg(session, send_to, "Perdeste.");
break;
}
}
void dazeus::Server::ping() {
irc_send_raw(IRC, "PING");
}
int irc_cmd_quit (irc_session_t * session, const char * reason)
{
return irc_send_raw (session, "QUIT :%s", reason ? reason : "quit");
}
int irc_process_select_descriptors (irc_session_t * session, fd_set *in_set, fd_set *out_set)
{
char buf[256], hname[256];
if ( session->sock < 0
|| session->state == LIBIRC_STATE_INIT
|| session->state == LIBIRC_STATE_DISCONNECTED )
{
session->lasterror = LIBIRC_ERR_STATE;
return 1;
}
libirc_dcc_process_descriptors (session, in_set, out_set);
// Handle "connection succeed" / "connection failed"
if ( session->state == LIBIRC_STATE_CONNECTING
&& FD_ISSET (session->sock, out_set) )
{
// Now we have to determine whether the socket is connected
// or the connect is failed
struct sockaddr_in saddr, laddr;
socklen_t slen = sizeof(saddr);
socklen_t llen = sizeof(laddr);
if ( getsockname (session->sock, (struct sockaddr*)&laddr, &llen) < 0
|| getpeername (session->sock, (struct sockaddr*)&saddr, &slen) < 0 )
{
// connection failed
session->lasterror = LIBIRC_ERR_CONNECT;
session->state = LIBIRC_STATE_DISCONNECTED;
return 1;
}
memcpy (&session->local_addr, &laddr.sin_addr, sizeof(session->local_addr));
#if defined (ENABLE_DEBUG)
if ( IS_DEBUG_ENABLED(session) )
fprintf (stderr, "[DEBUG] Detected local address: %s\n", inet_ntoa(session->local_addr));
#endif
session->state = LIBIRC_STATE_CONNECTED;
// Get the hostname
if ( gethostname (hname, sizeof(hname)) < 0 )
strcpy (hname, "unknown");
// Prepare the data, which should be sent to the server
if ( session->server_password )
{
snprintf (buf, sizeof(buf), "PASS %s", session->server_password);
irc_send_raw (session, buf);
}
snprintf (buf, sizeof(buf), "NICK %s", session->nick);
irc_send_raw (session, buf);
/*
* RFC 1459 states that "hostname and servername are normally
* ignored by the IRC server when the USER command comes from
* a directly connected client (for security reasons)", therefore
* we don't need them.
*/
snprintf (buf, sizeof(buf), "USER %s unknown unknown :%s",
session->username ? session->username : "******",
session->realname ? session->realname : "noname");
irc_send_raw (session, buf);
return 0;
}
if ( session->state != LIBIRC_STATE_CONNECTED )
return 1;
// Hey, we've got something to read!
if ( FD_ISSET (session->sock, in_set) )
{
int length, offset;
unsigned int amount = (sizeof (session->incoming_buf) - 1) - session->incoming_offset;
length = socket_recv (&session->sock, session->incoming_buf + session->incoming_offset, amount);
if ( length <= 0 )
{
session->lasterror = (length == 0 ? LIBIRC_ERR_CLOSED : LIBIRC_ERR_TERMINATED);
session->state = LIBIRC_STATE_DISCONNECTED;
return 1;
}
session->incoming_offset += length;
// process the incoming data
while ( (offset = libirc_findcrlf (session->incoming_buf, session->incoming_offset)) > 0 )
{
#if defined (ENABLE_DEBUG)
if ( IS_DEBUG_ENABLED(session) )
libirc_dump_data ("RECV", session->incoming_buf, offset);
#endif
// parse the string
libirc_process_incoming_data (session, offset - 2);
if ( session->incoming_offset - offset > 0 )
memmove (session->incoming_buf, session->incoming_buf + offset, session->incoming_offset - offset);
session->incoming_offset -= offset;
}
}
// We can write a stored buffer
if ( FD_ISSET (session->sock, out_set) )
{
int length;
// Because outgoing_buf could be changed asynchronously, we should
// lock any change
libirc_mutex_lock (&session->mutex_session);
length = socket_send (&session->sock, session->outgoing_buf, session->outgoing_offset);
if ( length <= 0 )
{
session->lasterror = (length == 0 ? LIBIRC_ERR_CLOSED : LIBIRC_ERR_TERMINATED);
session->state = LIBIRC_STATE_DISCONNECTED;
libirc_mutex_unlock (&session->mutex_session);
return 1;
}
#if defined (ENABLE_DEBUG)
if ( IS_DEBUG_ENABLED(session) )
libirc_dump_data ("SEND", session->outgoing_buf, length);
#endif
if ( session->outgoing_offset - length > 0 )
memmove (session->outgoing_buf, session->outgoing_buf + length, session->outgoing_offset - length);
session->outgoing_offset -= length;
libirc_mutex_unlock (&session->mutex_session);
}
return 0;
}
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 ChatNetworkingIRC::send( const std::string& msg, const std::string& channel )
{
// ignore input if no valid session exists
if ( !_p_session )
return;
if ( !msg.length() )
return;
if ( msg[ 0 ] == '/' )
{
// check for /msg commands, send them raw
if ( ( msg.length() > 4 ) && !msg.compare( 0, 4, "/msg" ) )
{
std::string cmd = msg.substr( 4, msg.length() );
irc_send_raw( _p_session, cmd.c_str() );
return;
}
std::vector< std::string > args;
yaf3d::explode( msg, " ", &args );
// all commands without arguments go here
if ( args.size() == 1 )
{
if ( args[ 0 ] == "/names" )
{
requestMemberList( channel );
}
else if ( args[ 0 ] == "/part" )
{
requestLeaveChannel( channel );
}
else
{
recvMessage( channel, "* ", IRC_CMD_LIST );
}
}
// all commands with one single argument go here
else if ( args.size() == 2 )
{
if ( args[ 0 ] == "/nick" )
{
irc_cmd_nick( _p_session, args[ 1 ].c_str() );
}
else if ( args[ 0 ] == "/join" )
{
//! TODO: what is "key" about?
irc_cmd_join( _p_session, args[ 1 ].c_str(), NULL );
}
else if ( args[ 0 ] == "/whois" )
{
irc_cmd_whois( _p_session, args[ 1 ].c_str() );
}
else
{
recvMessage( channel, "* ", IRC_CMD_LIST );
}
}
}
else
{
irc_cmd_msg( _p_session, channel.c_str(), msg.c_str() );
}
}
