void irc_server_send_action(IRC_SERVER_REC *server, const char *target, const char *data)
{
char *recoded;
recoded = recode_out(SERVER(server), data, target);
irc_send_cmdv(server, "PRIVMSG %s :\001ACTION %s\001", target, recoded);
g_free(recoded);
}
static void command_self(const char *data, IRC_SERVER_REC *server)
{
g_return_if_fail(data != NULL);
if (!IS_IRC_SERVER(server) || !server->connected)
cmd_return_error(CMDERR_NOT_CONNECTED);
irc_send_cmdv(server, *data == '\0' ? "%s" : "%s %s", current_command, data);
}
static void event_oper(IRC_SERVER_REC *server, const char *data)
{
const char *opermode;
opermode = settings_get_str("opermode");
if (*opermode != '\0')
irc_send_cmdv(server, "MODE %s %s", server->nick, opermode);
}
void DH1080_received(SERVER_REC * server, char *msg, char *nick, char *address,
char *target)
{
int i;
char hisPubKey[300], contactName[CONTACT_SIZE] =
"", encryptedKey[KEYBUF_SIZE] = "";
if (ischannel(*target) || ischannel(*nick))
return; // no KeyXchange for channels...
i = strlen(msg);
if (i < 191 || i > 195)
return;
if (strncmp(msg, "DH1080_INIT ", 12) == 0) {
strcpy(hisPubKey, msg + 12);
if (strspn(hisPubKey, B64ABC) != strlen(hisPubKey))
return;
if (query_find(server, nick) == NULL) { // query window not found, lets create one
keyx_query_created = 1;
irc_query_create(server->tag, nick, TRUE);
keyx_query_created = 0;
}
printtext(server, nick, MSGLEVEL_CRAP,
"\002FiSH:\002 Received DH1080 public key from %s, sending mine...",
nick);
DH1080_gen(g_myPrivKey, g_myPubKey);
irc_send_cmdv((IRC_SERVER_REC *) server, "NOTICE %s :%s %s",
nick, "DH1080_FINISH", g_myPubKey);
} else if (strncmp(msg, "DH1080_FINISH ", 14) == 0)
strcpy(hisPubKey, msg + 14);
else
return;
if (DH1080_comp(g_myPrivKey, hisPubKey) == 0)
return;
signal_stop();
encrypt_key(hisPubKey, encryptedKey);
ZeroMemory(hisPubKey, sizeof(hisPubKey));
if (getIniSectionForContact(server, nick, contactName) == FALSE)
return;
if (setIniValue(contactName, "key", encryptedKey, iniPath) == -1) {
ZeroMemory(encryptedKey, KEYBUF_SIZE);
printtext(server, nick, MSGLEVEL_CRAP,
"\002FiSH ERROR:\002 Unable to write to blow.ini, probably out of space or permission denied.");
return;
}
ZeroMemory(encryptedKey, KEYBUF_SIZE);
printtext(server, nick, MSGLEVEL_CRAP,
"\002FiSH:\002 Key for %s successfully set!", nick);
}
/* SYNTAX: MODE <your nick>|<channel> [<mode> [<mode parameters>]] */
static void cmd_mode(const char *data, IRC_SERVER_REC *server,
IRC_CHANNEL_REC *channel)
{
IRC_CHANNEL_REC *chanrec;
char *target, *mode;
void *free_arg;
CMD_IRC_SERVER(server);
if (*data == '+' || *data == '-') {
target = "*";
if (!cmd_get_params(data, &free_arg, 1 | PARAM_FLAG_GETREST, &mode))
return;
} else {
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_GETREST, &target, &mode))
return;
}
if (strcmp(target, "*") == 0) {
if (!IS_IRC_CHANNEL(channel))
cmd_param_error(CMDERR_NOT_JOINED);
target = channel->name;
}
if (*target == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
if (*mode == '\0') {
chanrec = irc_channel_find(server, target);
if (chanrec != NULL)
target = chanrec->name;
irc_send_cmdv(server, "MODE %s", target);
} else if (ischannel(*target))
channel_set_mode(server, target, mode);
else {
if (g_strcasecmp(target, server->nick) == 0) {
server_redirect_event(server, "mode user", 1, target, -1, NULL,
"event mode", "requested usermode change", NULL);
}
irc_send_cmdv(server, "MODE %s %s", target, mode);
}
cmd_params_free(free_arg);
}
/* SYNTAX: ACCEPT [[-]nick,...] */
static void cmd_accept(const char *data, IRC_SERVER_REC *server)
{
CMD_IRC_SERVER(server);
if (*data == '\0')
irc_send_cmd(server, "ACCEPT *");
else
irc_send_cmdv(server, "ACCEPT %s", data);
}
/* SYNTAX: DEOP <nicks> */
static void cmd_deop(const char *data, IRC_SERVER_REC *server)
{
g_return_if_fail(data != NULL);
if (!IS_IRC_SERVER(server) || !server->connected)
cmd_return_error(CMDERR_NOT_CONNECTED);
if (*data == '\0')
irc_send_cmdv(server, "MODE %s -o", server->nick);
}
/* SYNTAX: SCONNECT <new server> [[<port>] <existing server>] */
static void cmd_sconnect(const char *data, IRC_SERVER_REC *server)
{
g_return_if_fail(data != NULL);
if (!IS_IRC_SERVER(server) || !server->connected)
cmd_return_error(CMDERR_NOT_CONNECTED);
if (*data == '\0') cmd_return_error(CMDERR_NOT_ENOUGH_PARAMS);
irc_send_cmdv(server, "CONNECT %s", data);
}
/* SYNTAX: UNSILENCE <nick!user@host> */
static void cmd_unsilence(const char *data, IRC_SERVER_REC *server)
{
CMD_IRC_SERVER(server);
if (*data == '\0')
cmd_return_error(CMDERR_NOT_ENOUGH_PARAMS);
irc_send_cmdv(server, "SILENCE -%s", data);
}
static void server_send_away(IRC_SERVER_REC *server, const char *reason)
{
if (!IS_IRC_SERVER(server))
return;
g_free_not_null(server->away_reason);
server->away_reason = g_strdup(reason);
irc_send_cmdv(server, "AWAY :%s", reason);
}
static void sig_connected(IRC_SERVER_REC *server)
{
if (!IS_IRC_SERVER(server) || !server->connrec->reconnection)
return;
if (server->connrec->away_reason != NULL) {
irc_send_cmdv(server, "AWAY :%s", server->connrec->away_reason);
g_free(server->away_reason);
server->away_reason = g_strdup(server->connrec->away_reason);
}
}
static void server_send_away(IRC_SERVER_REC *server, const char *reason)
{
if (!IS_IRC_SERVER(server))
return;
if (*reason != '\0' || server->usermode_away) {
g_free_and_null(server->away_reason);
if (*reason != '\0')
server->away_reason = g_strdup(reason);
irc_send_cmdv(server, "AWAY :%s", reason);
}
}
static void command_2self(const char *data, IRC_SERVER_REC *server)
{
char *target, *text;
void *free_arg;
CMD_IRC_SERVER(server);
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_GETREST, &target, &text))
return;
if (*target == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
irc_send_cmdv(server, "%s %s :%s", current_command, target, text);
cmd_params_free(free_arg);
}
static void cmd_action(const char *data, IRC_SERVER_REC *server)
{
char *params, *target, *text;
g_return_if_fail(data != NULL);
if (server == NULL || !server->connected) cmd_return_error(CMDERR_NOT_CONNECTED);
params = cmd_get_params(data, 3 | PARAM_FLAG_GETREST, &target, &text);
if (*target == '\0' || *text == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
printformat(server, target, MSGLEVEL_ACTIONS, IRCTXT_OWN_ME, server->nick, text);
irc_send_cmdv(server, "PRIVMSG %s :\001ACTION %s\001", target, text);
g_free(params);
}
static void cmd_me(gchar *data, IRC_SERVER_REC *server, WI_IRC_REC *item)
{
g_return_if_fail(data != NULL);
if (!irc_item_check(item))
return;
if (server == NULL || !server->connected) cmd_return_error(CMDERR_NOT_CONNECTED);
printformat(server, item->name, MSGLEVEL_ACTIONS,
IRCTXT_OWN_ME, server->nick, data);
irc_send_cmdv(server, "PRIVMSG %s :\001ACTION %s\001", item->name, data);
}
/* SYNTAX: OPER [<nick> [<password>]] */
static void cmd_oper(const char *data, IRC_SERVER_REC *server)
{
char *nick, *password;
void *free_arg;
CMD_IRC_SERVER(server);
/* asking for password is handled by fe-common */
if (!cmd_get_params(data, &free_arg, 2, &nick, &password))
return;
if (*password == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
irc_send_cmdv(server, "OPER %s %s", nick, password);
cmd_params_free(free_arg);
}
static void command_2self(const char *data, IRC_SERVER_REC *server)
{
char *target, *text;
void *free_arg;
g_return_if_fail(data != NULL);
if (!IS_IRC_SERVER(server) || !server->connected)
cmd_return_error(CMDERR_NOT_CONNECTED);
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_GETREST, &target, &text))
return;
if (*target == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
irc_send_cmdv(server, "%s %s :%s", current_command, target, text);
cmd_params_free(free_arg);
}
/* SYNTAX: MODE <your nick>|<channel> [<mode> [<mode parameters>]] */
static void cmd_mode(const char *data, IRC_SERVER_REC *server,
IRC_CHANNEL_REC *channel)
{
char *target, *mode;
void *free_arg;
g_return_if_fail(data != NULL);
if (server == NULL || !server->connected || !IS_IRC_SERVER(server))
cmd_return_error(CMDERR_NOT_CONNECTED);
if (*data == '+' || *data == '-') {
target = "*";
if (!cmd_get_params(data, &free_arg, 1 | PARAM_FLAG_GETREST, &mode))
return;
} else {
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_GETREST, &target, &mode))
return;
}
if (strcmp(target, "*") == 0) {
if (!IS_IRC_CHANNEL(channel))
cmd_param_error(CMDERR_NOT_JOINED);
target = channel->name;
}
if (*target == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
if (*mode == '\0')
irc_send_cmdv(server, "MODE %s", target);
else if (ischannel(*target))
channel_set_mode(server, target, mode);
else
irc_send_cmdv(server, "MODE %s %s", target, mode);
cmd_params_free(free_arg);
}
/* SYNTAX: CYCLE [<channel>] [<message>] */
static void cmd_cycle(const char *data, IRC_SERVER_REC *server, WI_ITEM_REC *item)
{
IRC_CHANNEL_REC *chanrec;
char *channame, *msg;
void *free_arg;
g_return_if_fail(data != NULL);
if (!IS_IRC_SERVER(server) || !server->connected)
cmd_return_error(CMDERR_NOT_CONNECTED);
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_OPTCHAN, item, &channame, &msg))
return;
if (*channame == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
chanrec = irc_channel_find(server, channame);
if (chanrec == NULL) cmd_param_error(CMDERR_CHAN_NOT_FOUND);
irc_send_cmdv(server, *msg == '\0' ? "PART %s" : "PART %s :%s",
channame, msg);
irc_send_cmdv(server, chanrec->key == NULL ? "JOIN %s" : "JOIN %s %s",
channame, chanrec->key);
cmd_params_free(free_arg);
}
static void event_connected(IRC_SERVER_REC *server)
{
const char *nick;
g_return_if_fail(server != NULL);
nick = server->connrec->nick;
if (g_strcasecmp(server->nick, nick) == 0)
return;
/* someone has our nick, find out who. */
server_redirect_event(server, "whois", 1, nick, TRUE, NULL,
"event 311", "nickfind event whois",
"", "event empty", NULL);
irc_send_cmdv(server, "WHOIS %s", nick);
}
/* SYNTAX: WALLCHOPS <channel> <message> */
static void cmd_wallchops(const char *data, IRC_SERVER_REC *server, WI_ITEM_REC *item)
{
char *channame, *msg;
void *free_arg;
CMD_IRC_SERVER(server);
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_OPTCHAN |
PARAM_FLAG_GETREST, item, &channame, &msg))
return;
if (*msg == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
irc_send_cmdv(server, "WALLCHOPS %s :%s", channame, msg);
cmd_params_free(free_arg);
}
static void sig_whois_not_found(const char *data, IRC_SERVER_REC *server)
{
char *params, *nick;
g_return_if_fail(data != NULL);
params = event_get_params(data, 2, NULL, &nick);
irc_send_cmdv(server, "WHOWAS %s 1", nick);
server->whowas_found = FALSE;
server_redirect_event(SERVER(server), nick, 1,
"event 369", "whowas event end", 1,
"event 314", "whowas event", 1,
"event 406", "event empty", 1, NULL);
g_free(params);
}
/*
* New command: /notice+ <nick/#channel> <notice message>
*/
void cmd_crypt_notice(const char *data, SERVER_REC * server, WI_ITEM_REC * item)
{
char bf_dest[1000] = "", *msg;
const char *target;
void *free_arg = NULL;
if (data == NULL || (strlen(data) < 3))
goto notice_error;
if (!cmd_get_params(data, &free_arg, 1, &target))
goto notice_error;
msg = strchr(data, ' ');
if (IsNULLorEmpty(target) || IsNULLorEmpty(msg))
goto notice_error;
msg++; // point to the notice message
// generally refuse a notice size of more than 512 byte, as everything above will never arrive complete anyway
if (strlen(msg) >= 512) {
printtext(server, target, MSGLEVEL_CRAP,
"\002FiSH:\002 /notice+ \002error\002: message argument exceeds buffer size!");
return;
}
if (FiSH_encrypt(server, msg, target, bf_dest) == 0) {
printtext(server, target, MSGLEVEL_CRAP,
"\002FiSH:\002 /notice+ \002error\002: Encryption disabled or no key found for %s.",
target);
return;
}
bf_dest[512] = '\0';
irc_send_cmdv((IRC_SERVER_REC *) server, "NOTICE %s :%s\n", target,
bf_dest);
signal_emit("message irc own_notice", 3, server, msg, target);
cmd_params_free(free_arg);
return;
notice_error:
if (free_arg)
cmd_params_free(free_arg);
printtext(server, item != NULL ? window_item_get_target(item) : NULL,
MSGLEVEL_CRAP,
"\002FiSH:\002 Usage: /notice+ <nick/#channel> <notice message>");
}
/* Reject a DCC request */
void dcc_reject(DCC_REC *dcc, IRC_SERVER_REC *server)
{
g_return_if_fail(dcc != NULL);
signal_emit("dcc rejected", 1, dcc);
if (dcc->server != NULL)
server = dcc->server;
if (server != NULL && !dcc_is_connected(dcc)) {
irc_send_cmdv(server, "NOTICE %s :\001DCC REJECT %s %s\001",
dcc->nick, dcc_type2str(dcc->orig_type),
dcc->arg);
}
dcc_close(dcc);
}
void irc_server_send_away(IRC_SERVER_REC *server, const char *reason)
{
char *recoded = NULL;
if (!IS_IRC_SERVER(server))
return;
if (*reason != '\0' || server->usermode_away) {
g_free_and_null(server->away_reason);
if (*reason != '\0') {
server->away_reason = g_strdup(reason);
reason = recoded = recode_out(SERVER(server), reason, NULL);
}
irc_send_cmdv(server, "AWAY :%s", reason);
}
g_free(recoded);
}
/* SYNTAX: NICK <new nick> */
static void cmd_nick(const char *data, IRC_SERVER_REC *server, WI_ITEM_REC *item)
{
char *nick;
void *free_arg;
g_return_if_fail(data != NULL);
CMD_IRC_SERVER(server);
if (!cmd_get_params(data, &free_arg, 1, &nick))
return;
g_free(server->last_nick);
server->last_nick = g_strdup(nick);
irc_send_cmdv(server, "NICK %s", nick);
cmd_params_free(free_arg);
}
static int sig_set_user_mode(IRC_SERVER_REC *server)
{
const char *mode;
char *newmode;
if (g_slist_find(servers, server) == NULL)
return 0; /* got disconnected */
mode = server->connrec->usermode;
if (mode == NULL) return 0;
newmode = server->usermode == NULL ? NULL :
modes_join(server->usermode, mode);
if (server->usermode != NULL && strcmp(newmode, server->usermode) != 0)
irc_send_cmdv(server, "MODE %s -%s+%s", server->nick, server->usermode, mode);
g_free_not_null(newmode);
return 0;
}
static void event_connected(IRC_SERVER_REC *server, const char *data, const char *from)
{
char *params, *nick;
GTimeVal now;
g_return_if_fail(server != NULL);
params = event_get_params(data, 1, &nick);
if (strcmp(server->nick, nick) != 0) {
/* nick changed unexpectedly .. connected via proxy, etc. */
g_free(server->nick);
server->nick = g_strdup(nick);
}
/* set the server address */
g_free(server->real_address);
server->real_address = from == NULL ?
g_strdup(server->connrec->address) : /* shouldn't happen.. */
g_strdup(from);
/* last welcome message found - commands can be sent to server now. */
server->connected = 1;
server->real_connect_time = time(NULL);
/* let the queue send now that we are identified */
g_get_current_time(&now);
memcpy(&server->wait_cmd, &now, sizeof(GTimeVal));
if (server->connrec->usermode != NULL) {
/* Send the user mode, before the autosendcmd.
* Do not pass this through cmd_mode because it
* is not known whether the resulting MODE message
* (if any) is the initial umode or a reply to this.
*/
irc_send_cmdv(server, "MODE %s %s", server->nick,
server->connrec->usermode);
g_free_not_null(server->wanted_usermode);
server->wanted_usermode = g_strdup(server->connrec->usermode);
}
signal_emit("event connected", 1, server);
g_free(params);
}
/* SYNTAX: SETHOST <host> <password> (non-ircops)
SETHOST <ident> <host> (ircops) */
static void cmd_sethost(const char *data, IRC_SERVER_REC *server)
{
GSList *tmp;
g_return_if_fail(data != NULL);
if (!IS_IRC_SERVER(server) || !server->connected)
cmd_return_error(CMDERR_NOT_CONNECTED);
/* Save all the joined channels in server to window binds, since
the server will soon /PART + /JOIN us in all channels. */
for (tmp = server->channels; tmp != NULL; tmp = tmp->next) {
CHANNEL_REC *channel = tmp->data;
window_bind_add(window_item_window(channel),
server->tag, channel->visible_name);
}
irc_send_cmdv(server, "SETHOST %s", data);
}
/* SYNTAX: TOPIC [-delete] [<channel>] [<topic>] */
static void cmd_topic(const char *data, IRC_SERVER_REC *server, WI_ITEM_REC *item)
{
GHashTable *optlist;
char *channame, *topic;
void *free_arg;
CMD_IRC_SERVER(server);
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_OPTCHAN |
PARAM_FLAG_OPTIONS | PARAM_FLAG_GETREST,
item, "topic", &optlist, &channame, &topic))
return;
irc_send_cmdv(server, *topic == '\0' &&
g_hash_table_lookup(optlist, "delete") == NULL ?
"TOPIC %s" : "TOPIC %s :%s", channame, topic);
cmd_params_free(free_arg);
}
