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() ); } }