static void set_print(SETTINGS_REC *rec)
{
const char *value;
char value_int[MAX_INT_STRLEN];
switch (rec->type) {
case SETTING_TYPE_BOOLEAN:
value = settings_get_bool(rec->key) ? "ON" : "OFF";
break;
case SETTING_TYPE_INT:
ltoa(value_int, settings_get_int(rec->key));
value = value_int;
break;
case SETTING_TYPE_STRING:
value = settings_get_str(rec->key);
break;
default:
value = "";
}
printformat(NULL, NULL, MSGLEVEL_CLIENTCRAP, TXT_SET_ITEM,
rec->key, value);
}
/* SYNTAX: QUIT [<message>] */
static void cmd_quit(const char *data)
{
GSList *tmp, *next;
const char *quitmsg;
char *str;
g_return_if_fail(data != NULL);
quitmsg = *data != '\0' ? data :
settings_get_str("quit_message");
/* disconnect from every server */
for (tmp = servers; tmp != NULL; tmp = next) {
next = tmp->next;
str = g_strdup_printf("* %s", quitmsg);
cmd_disconnect(str, tmp->data);
g_free(str);
}
signal_emit("gui exit", 0);
}
/* SYNTAX: WALL [<channel>] <message> */
static void cmd_wall(const char *data, IRC_SERVER_REC *server, WI_ITEM_REC *item)
{
char *channame, *msg, *args;
void *free_arg;
IRC_CHANNEL_REC *chanrec;
GSList *tmp, *nicks;
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 |
PARAM_FLAG_GETREST, item, &channame, &msg))
return;
if (*msg == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
chanrec = irc_channel_find(server, channame);
if (chanrec == NULL) cmd_param_error(CMDERR_CHAN_NOT_FOUND);
/* send notice to all ops */
nicks = NULL;
g_hash_table_foreach(chanrec->nicks, (GHFunc) cmd_wall_hash, &nicks);
args = g_strconcat(chanrec->name, " ", msg, NULL);
msg = parse_special_string(settings_get_str("wall_format"),
SERVER(server), item, args, NULL);
g_free(args);
for (tmp = nicks; tmp != NULL; tmp = tmp->next) {
NICK_REC *rec = tmp->data;
if (g_strcasecmp(rec->nick, server->nick) != 0)
irc_send_cmdv(server, "NOTICE %s :%s", rec->nick, msg);
}
g_free(msg);
g_slist_free(nicks);
cmd_params_free(free_arg);
}
static void event_default_command(const char *data, void *server,
WI_ITEM_REC *item)
{
const char *cmdchars, *ptr;
char *cmd, *p;
long diff;
cmdchars = settings_get_str("cmdchars");
ptr = data;
while (*ptr != '\0' && *ptr != ' ') {
if (strchr(cmdchars, *ptr)) {
/* command character inside command .. we probably
want to send this text to channel. for example
when pasting a path /usr/bin/xxx. */
signal_emit("send text", 3, current_cmdline, server, item);
return;
}
ptr++;
}
/* maybe we're copy+pasting text? check how long it was since the
last line */
diff = get_timeval_diff(&time_command_now, &time_command_last);
if (item != NULL && !last_command_cmd && diff < PASTE_CHECK_SPEED) {
signal_emit("send text", 3, current_cmdline, active_win->active_server, active_win->active);
command_cmd = FALSE;
return;
}
/* get the command part of the line, send "error command" signal */
cmd = g_strdup(data);
p = strchr(cmd, ' ');
if (p != NULL) *p = '\0';
signal_emit("error command", 2, GINT_TO_POINTER(CMDERR_UNKNOWN), cmd);
g_free(cmd);
}
static void read_settings(void)
{
const char *str;
int old_colors = term_use_colors;
int old_colors24 = term_use_colors24;
int old_type = term_type;
/* set terminal type */
str = settings_get_str("term_charset");
if (g_ascii_strcasecmp(str, "utf-8") == 0)
term_type = TERM_TYPE_UTF8;
else if (g_ascii_strcasecmp(str, "big5") == 0)
term_type = TERM_TYPE_BIG5;
else
term_type = TERM_TYPE_8BIT;
if (old_type != term_type)
term_set_input_type(term_type);
/* change color stuff */
if (force_colors != settings_get_bool("term_force_colors")) {
force_colors = settings_get_bool("term_force_colors");
term_force_colors(force_colors);
}
term_use_colors = settings_get_bool("colors") &&
(force_colors || term_has_colors());
#ifdef TERM_TRUECOLOR
term_use_colors24 = settings_get_bool("colors_ansi_24bit") &&
(force_colors || term_has_colors());
#else
term_use_colors24 = FALSE;
#endif
if (term_use_colors != old_colors || term_use_colors24 != old_colors24)
irssi_redraw();
}
char *recode_out(const SERVER_REC *server, const char *str, const char *target)
{
char *recoded = NULL;
const char *from = NULL;
const char *to = NULL;
char *translit_to = NULL;
gboolean translit, term_is_utf8, recode;
int len;
if (!str)
return NULL;
recode = settings_get_bool("recode");
if (!recode)
return g_strdup(str);
len = strlen(str);
translit = settings_get_bool("recode_transliterate");
to = find_conversion(server, target);
if (to == NULL)
/* default outgoing charset if set */
to = settings_get_str("recode_out_default_charset");
if (to && *to != '\0') {
if (translit && !is_translit(to))
to = translit_to = g_strconcat(to ,"//TRANSLIT", NULL);
term_is_utf8 = recode_get_charset(&from);
recoded = g_convert(str, len, to, from, NULL, NULL, NULL);
}
g_free(translit_to);
if (!recoded)
recoded = g_strdup(str);
return recoded;
}
/* SYNTAX: PART [<channels>] [<message>] */
static void cmd_part(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_GETREST |
PARAM_FLAG_OPTCHAN, item, &channame, &msg))
return;
if (*channame == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
if (*msg == '\0') msg = (char *) settings_get_str("part_message");
if (server->cmdcount > MAX_COMMANDS_ON_PART_UNTIL_PURGE)
irc_server_purge_output(server, channame);
irc_send_cmdv(server, *msg == '\0' ? "PART %s" : "PART %s :%s",
channame, msg);
cmd_params_free(free_arg);
}
/* SYNTAX: DISCONNECT *|<tag> [<message>] */
static void cmd_disconnect(const char *data, SERVER_REC *server)
{
char *tag, *msg;
void *free_arg;
g_return_if_fail(data != NULL);
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_GETREST, &tag, &msg))
return;
if (*tag != '\0' && strcmp(tag, "*") != 0) {
server = server_find_tag(tag);
if (server == NULL)
server = server_find_lookup_tag(tag);
}
if (server == NULL) cmd_param_error(CMDERR_NOT_CONNECTED);
if (*msg == '\0') msg = (char *) settings_get_str("quit_message");
signal_emit("server quit", 2, server, msg);
cmd_params_free(free_arg);
server_disconnect(server);
}
void log_stop_logging(LOG_REC *log)
{
g_return_if_fail(log != NULL);
if (log->handle == -1)
return;
signal_emit("log stopped", 1, log);
log_write_timestamp(log->handle,
settings_get_str("log_close_string"),
"\n", time(NULL));
#ifdef HAVE_FCNTL
memset(&lock, 0, sizeof(lock));
lock.l_type = F_UNLCK;
fcntl(log->handle, F_SETLK, &lock);
#endif
write_buffer_flush();
close(log->handle);
log->handle = -1;
}
/* your /userhost $N address (user@host) */
static char *expando_userhost(SERVER_REC *server, void *item, int *free_ret)
{
IRC_SERVER_REC *ircserver;
const char *username;
char hostname[100];
ircserver = IRC_SERVER(server);
/* prefer the _real_ /userhost reply */
if (ircserver != NULL && ircserver->userhost != NULL)
return ircserver->userhost;
/* haven't received userhost reply yet. guess something */
*free_ret = TRUE;
if (ircserver == NULL)
username = settings_get_str("user_name");
else
username = ircserver->connrec->username;
if (gethostname(hostname, sizeof(hostname)) != 0 || *hostname == '\0')
strcpy(hostname, "??");
return g_strconcat(username, "@", hostname, NULL);;
}
static void event_connected(IRC_SERVER_REC *server)
{
const char *nick;
g_return_if_fail(server != NULL);
nick = settings_get_str("nick");
if (*nick == '\0' || g_strcasecmp(server->nick, nick) == 0)
return;
/* someone has our nick, find out who. */
irc_send_cmdv(server, "WHOIS %s", nick);
server_redirect_event((SERVER_REC *) server, nick, 1,
"event 318", "event empty", 1,
"event 401", "event empty", 1,
"event 311", "nickfind event whois", 1,
"event 301", "event empty", 1,
"event 312", "event empty", 1,
"event 313", "event empty", 1,
"event 317", "event empty", 1,
"event 319", "event empty", 1, NULL);
}
static void server_setup_fill(SERVER_CONNECT_REC *conn,
const char *address, int port)
{
g_return_if_fail(conn != NULL);
g_return_if_fail(address != NULL);
conn->type = module_get_uniq_id("SERVER CONNECT", 0);
conn->address = g_strdup(address);
if (port > 0) conn->port = port;
if (strchr(address, '/') != NULL)
conn->unix_socket = TRUE;
if (!conn->nick) conn->nick = g_strdup(settings_get_str("nick"));
conn->username = g_strdup(settings_get_str("user_name"));
conn->realname = g_strdup(settings_get_str("real_name"));
/* proxy settings */
if (settings_get_bool("use_proxy")) {
conn->proxy = g_strdup(settings_get_str("proxy_address"));
conn->proxy_port = settings_get_int("proxy_port");
conn->proxy_string = g_strdup(settings_get_str("proxy_string"));
conn->proxy_string_after = g_strdup(settings_get_str("proxy_string_after"));
conn->proxy_password = g_strdup(settings_get_str("proxy_password"));
}
/* source IP */
if (source_host_ip4 != NULL) {
conn->own_ip4 = g_new(IPADDR, 1);
memcpy(conn->own_ip4, source_host_ip4, sizeof(IPADDR));
}
if (source_host_ip6 != NULL) {
conn->own_ip6 = g_new(IPADDR, 1);
memcpy(conn->own_ip6, source_host_ip6, sizeof(IPADDR));
}
signal_emit("server setup fill connect", 1, conn);
}
static void handle_client_connect_cmd(CLIENT_REC *client,
const char *cmd, const char *args)
{
const char *password;
password = settings_get_str("irssiproxy_password");
if (password != NULL && g_strcmp0(cmd, "PASS") == 0) {
if (g_strcmp0(password, args) == 0)
client->pass_sent = TRUE;
else {
/* wrong password! */
remove_client(client);
return;
}
} else if (g_strcmp0(cmd, "NICK") == 0) {
g_free_not_null(client->nick);
client->nick = g_strdup(args);
} else if (g_strcmp0(cmd, "USER") == 0) {
client->user_sent = TRUE;
}
if (client->nick != NULL && client->user_sent) {
if (*password != '\0' && !client->pass_sent) {
/* client didn't send us PASS, kill it */
remove_client(client);
} else {
signal_emit("proxy client connected", 1, client);
printtext(client->server, NULL, MSGLEVEL_CLIENTNOTICE,
"Proxy: Client %s:%d connected",
client->host, client->port);
client->connected = TRUE;
proxy_dump_data(client);
}
}
}
char *settings_get_print(SETTINGS_REC *rec)
{
char *value = NULL;
switch(rec->type) {
case SETTING_TYPE_CHOICE:
value = g_strdup(rec->choices[settings_get_choice(rec->key)]);
break;
case SETTING_TYPE_BOOLEAN:
value = g_strdup(settings_get_bool(rec->key) ? "ON" : "OFF");
break;
case SETTING_TYPE_INT:
value = g_strdup_printf("%d", settings_get_int(rec->key));
break;
case SETTING_TYPE_STRING:
case SETTING_TYPE_TIME:
case SETTING_TYPE_LEVEL:
case SETTING_TYPE_SIZE:
case SETTING_TYPE_ANY:
value = g_strdup(settings_get_str(rec->key));
break;
}
return value;
}
void proxy_outserver_all(IRC_SERVER_REC *server, const char *data, ...)
{
va_list args;
GSList *tmp;
char *str;
g_return_if_fail(server != NULL);
g_return_if_fail(data != NULL);
va_start(args, data);
str = g_strdup_vprintf(data, args);
for (tmp = proxy_clients; tmp != NULL; tmp = tmp->next) {
CLIENT_REC *rec = tmp->data;
if (rec->connected && rec->server == server) {
proxy_outdata(rec, ":%s!%s@proxy %s\n", rec->nick,
settings_get_str("user_name"), str);
}
}
g_free(str);
va_end(args);
}
static void init_userinfo(void)
{
const char *set, *nick, *user_name, *str;
/* check if nick/username/realname wasn't read from setup.. */
set = settings_get_str("real_name");
if (set == NULL || *set == '\0') {
str = g_getenv("IRCNAME");
settings_set_str("real_name",
str != NULL ? str : g_get_real_name());
}
/* username */
user_name = settings_get_str("user_name");
if (user_name == NULL || *user_name == '\0') {
str = g_getenv("IRCUSER");
settings_set_str("user_name",
str != NULL ? str : g_get_user_name());
user_name = settings_get_str("user_name");
}
/* nick */
nick = settings_get_str("nick");
if (nick == NULL || *nick == '\0') {
str = g_getenv("IRCNICK");
settings_set_str("nick", str != NULL ? str : user_name);
nick = settings_get_str("nick");
}
/* host name */
set = settings_get_str("hostname");
if (set == NULL || *set == '\0') {
str = g_getenv("IRCHOST");
if (str != NULL)
settings_set_str("hostname", str);
}
}
/* Create server connection record. `address' is required, rest can be NULL */
static IRC_SERVER_CONNECT_REC *
create_addr_conn(const char *address, int port, const char *password,
const char *nick)
{
IRC_SERVER_CONNECT_REC *conn;
SETUP_SERVER_REC *sserver;
IRCNET_REC *ircnet;
g_return_val_if_fail(address != NULL, NULL);
conn = g_new0(IRC_SERVER_CONNECT_REC, 1);
conn->address = g_strdup(address);
conn->port = port > 0 ? port : 6667;
if (password && *password) conn->password = g_strdup(password);
if (nick && *nick) conn->nick = g_strdup(nick);
if (!conn->nick) conn->nick = g_strdup(settings_get_str("default_nick"));
conn->alternate_nick = g_strdup(settings_get_str("alternate_nick"));
conn->username = g_strdup(settings_get_str("user_name"));
conn->realname = g_strdup(settings_get_str("real_name"));
/* proxy settings */
if (settings_get_bool("use_ircproxy")) {
conn->proxy = g_strdup(settings_get_str("proxy_address"));
conn->proxy_port = settings_get_int("proxy_port");
conn->proxy_string = g_strdup(settings_get_str("proxy_string"));
}
/* source IP */
get_source_host_ip();
if (source_host_ok) {
conn->own_ip = g_new(IPADDR, 1);
memcpy(conn->own_ip, source_host_ip, sizeof(IPADDR));
}
/* fill the information from setup */
sserver = server_setup_find(address, -1);
if (sserver == NULL) return conn;
server_setup_fill_conn(conn, sserver);
/* fill the rest from IRC network settings */
ircnet = sserver->ircnet == NULL ? NULL : ircnet_find(sserver->ircnet);
if (ircnet == NULL) return conn;
if (ircnet->nick && !(nick && *nick)) {
g_free(conn->nick);
conn->nick = g_strdup(ircnet->nick);;
}
if (ircnet->username) {
g_free(conn->username);
conn->username = g_strdup(ircnet->username);;
}
if (ircnet->realname) {
g_free(conn->realname);
conn->realname = g_strdup(ircnet->realname);;
}
if (ircnet->max_kicks > 0) conn->max_kicks = ircnet->max_kicks;
if (ircnet->max_msgs > 0) conn->max_msgs = ircnet->max_msgs;
if (ircnet->max_modes > 0) conn->max_modes = ircnet->max_modes;
if (ircnet->max_whois > 0) conn->max_whois = ircnet->max_whois;
if (ircnet->max_cmds_at_once > 0 && sserver->max_cmds_at_once <= 0)
conn->max_cmds_at_once = ircnet->max_cmds_at_once;
if (ircnet->cmd_queue_speed > 0 && sserver->cmd_queue_speed <= 0)
conn->cmd_queue_speed = ircnet->cmd_queue_speed;
if (sserver->own_host == NULL && ircnet->own_host != NULL)
conn_set_ip(conn, &ircnet->own_ip, ircnet->own_host);
return conn;
}
/* command: DCC SEND */
static void cmd_dcc_send(const char *data, IRC_SERVER_REC *server, WI_IRC_REC *item)
{
char *params, *target, *fname, *str, *ptr;
char host[MAX_IP_LEN];
int hfile, hlisten, port;
long fsize;
DCC_REC *dcc, *chat;
IPADDR own_ip;
g_return_if_fail(data != NULL);
params = cmd_get_params(data, 2 | PARAM_FLAG_GETREST, &target, &fname);
if (*target == '\0' || *fname == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
/* if we're in dcc chat, send the request via it. */
chat = item_get_dcc(item);
if (chat != NULL && (chat->mirc_ctcp || g_strcasecmp(target, chat->nick) != 0))
chat = NULL;
if ((server == NULL || !server->connected) && chat == NULL)
cmd_param_error(CMDERR_NOT_CONNECTED);
if (dcc_find_item(DCC_TYPE_SEND, target, fname)) {
signal_emit("dcc error send exists", 2, target, fname);
g_free(params);
return;
}
str = convert_home(fname);
if (!g_path_is_absolute(str)) {
char *path;
g_free(str);
path = convert_home(settings_get_str("dcc_upload_path"));
str = g_strconcat(path, G_DIR_SEPARATOR_S, fname, NULL);
g_free(path);
}
hfile = open(str, O_RDONLY);
g_free(str);
if (hfile == -1) {
signal_emit("dcc error file not found", 2, target, fname);
g_free(params);
return;
}
fsize = lseek(hfile, 0, SEEK_END);
lseek(hfile, 0, SEEK_SET);
/* get the IP address we use with IRC server */
if (net_getsockname(chat != NULL ? chat->handle : server->handle, &own_ip, NULL) == -1) {
close(hfile);
cmd_param_error(CMDERR_ERRNO);
}
/* start listening */
port = settings_get_int("dcc_port");
hlisten = net_listen(&own_ip, &port);
if (hlisten == -1) {
close(hfile);
cmd_param_error(CMDERR_ERRNO);
}
/* skip path, change all spaces to _ */
fname = g_strdup(g_basename(fname));
for (ptr = fname; *ptr != '\0'; ptr++)
if (*ptr == ' ') *ptr = '_';
dcc = dcc_create(DCC_TYPE_SEND, hlisten, target, fname, server, chat);
dcc->port = port;
dcc->size = fsize;
dcc->fhandle = hfile;
dcc->tagread = g_input_add(hlisten, G_INPUT_READ,
(GInputFunction) dcc_send_init, dcc);
/* send DCC request */
dcc_make_address(&own_ip, host);
str = g_strdup_printf("DCC SEND %s %s %d %lu",
fname, host, port, fsize);
dcc_ctcp_message(target, server, chat, FALSE, str);
g_free(str);
g_free(fname);
g_free(params);
}
char *recode_in(const SERVER_REC *server, const char *str, const char *target)
{
const char *from = NULL;
const char *to = NULL;
char *translit_to = NULL;
char *recoded = NULL;
gboolean term_is_utf8, str_is_utf8, translit, recode, autodetect;
int len;
int i;
if (!str)
return NULL;
recode = settings_get_bool("recode");
if (!recode)
return g_strdup(str);
len = strlen(str);
/* Only validate for UTF-8 if an 8-bit encoding. */
str_is_utf8 = 0;
for (i = 0; i < len; ++i) {
if (str[i] & 0x80) {
str_is_utf8 = g_utf8_validate(str, len, NULL);
break;
}
}
translit = settings_get_bool("recode_transliterate");
autodetect = settings_get_bool("recode_autodetect_utf8");
term_is_utf8 = recode_get_charset(&to);
if (autodetect && str_is_utf8)
if (term_is_utf8)
return g_strdup(str);
else
from = "UTF-8";
else {
from = find_conversion(server, target);
}
if (translit && !is_translit(to))
to = translit_to = g_strconcat(to, "//TRANSLIT", NULL);
if (from)
recoded = g_convert_with_fallback(str, len, to, from, NULL, NULL, NULL, NULL);
if (!recoded) {
if (term_is_utf8) {
if (!str_is_utf8)
from = settings_get_str("recode_fallback");
} else if (str_is_utf8)
from = "UTF-8";
if (from)
recoded = g_convert_with_fallback(str, len, to, from, NULL, NULL, NULL, NULL);
if (!recoded)
recoded = g_strdup(str);
}
g_free(translit_to);
return recoded;
}
/* Handle incoming DCC CTCP messages */
static void dcc_ctcp_msg(char *data, IRC_SERVER_REC *server, char *sender, char *sendaddr, char *target, DCC_REC *chat)
{
char *type, *arg, *addrstr, *portstr, *sizestr, *str;
void *free_arg;
const char *cstr;
DCC_REC *dcc, *olddcc;
long size;
int dcctype, port;
g_return_if_fail(data != NULL);
g_return_if_fail(sender != NULL);
if (!cmd_get_params(data, &free_arg, 5 | PARAM_FLAG_NOQUOTES,
&type, &arg, &addrstr, &portstr, &sizestr))
return;
if (sscanf(portstr, "%d", &port) != 1) port = 0;
if (sscanf(sizestr, "%ld", &size) != 1) size = 0;
dcctype = SWAP_SENDGET(dcc_str2type(type));
olddcc = dcc_find_item(dcctype, sender,
dcctype == DCC_TYPE_CHAT ? NULL : arg);
if (olddcc != NULL) {
/* same DCC request offered again */
if (olddcc->type == DCC_TYPE_CHAT &&
olddcc->handle != -1 && olddcc->starttime == 0) {
/* we requested dcc chat, they requested
dcc chat from us .. allow it. */
dcc_destroy(olddcc);
} else {
/* if the connection isn't open, update the port,
otherwise just ignore */
if (olddcc->handle == -1)
olddcc->port = port;
cmd_params_free(free_arg);
return;
}
}
dcc = dcc_create(dcctype, -1, sender, arg, server, chat);
dcc_get_address(addrstr, &dcc->addr);
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->size = size;
switch (dcc->type)
{
case DCC_TYPE_GET:
cstr = settings_get_str("dcc_autoget_masks");
/* check that autoget masks match */
if (settings_get_bool("dcc_autoget") && (*cstr == '\0' || masks_match(SERVER(server), cstr, sender, sendaddr)) &&
/* check file size limit, FIXME: it's possible to send a bogus file size and then just send what ever sized file.. */
(settings_get_int("dcc_max_autoget_size") <= 0 || (settings_get_int("dcc_max_autoget_size") > 0 && size <= settings_get_int("dcc_max_autoget_size")*1024)))
{
/* automatically get */
str = g_strdup_printf("GET %s %s", dcc->nick, dcc->arg);
signal_emit("command dcc", 2, str, server);
g_free(str);
}
else
{
/* send request */
signal_emit("dcc request", 1, dcc);
}
break;
case DCC_TYPE_CHAT:
cstr = settings_get_str("dcc_autochat_masks");
if (olddcc != NULL ||
(*cstr != '\0' && masks_match(SERVER(server), cstr, sender, sendaddr)))
{
/* automatically accept chat */
str = g_strdup_printf("CHAT %s", dcc->nick);
signal_emit("command dcc", 2, str, server);
g_free(str);
}
else
{
/* send request */
signal_emit("dcc request", 1, dcc);
}
break;
case DCC_TYPE_RESUME:
case DCC_TYPE_ACCEPT:
/* handle this in dcc-files.c */
dcc_destroy(dcc);
break;
default:
/* unknown DCC command */
signal_emit("dcc unknown ctcp", 3, data, sender, sendaddr);
dcc_destroy(dcc);
break;
}
cmd_params_free(free_arg);
}
/*
* Decrypt a base64 cipher text (using key for target)
*/
int FiSH_decrypt(const SERVER_REC * serverRec, char *msg_ptr,
const char *target, GString* decrypted_msg)
{
char contactName[CONTACT_SIZE] = "";
char theKey[KEYBUF_SIZE] = "";
char bf_dest[1000] = "";
char myMark[20] = "";
char *recoded;
int msg_len, i, mark_broken_block = 0, action_found = 0, markPos;
if (IsNULLorEmpty(msg_ptr) || decrypted_msg == NULL || IsNULLorEmpty(target))
return 0;
if (settings_get_bool("process_incoming") == 0)
return 0;
if (strncmp(msg_ptr, "+OK ", 4) == 0)
msg_ptr += 4;
// TODO: Maybe remove this?
else if (strncmp(msg_ptr, "mcps ", 5) == 0)
msg_ptr += 5;
else
return 0; // don't process, blowcrypt-prefix not found
// Verify base64 string
msg_len = strlen(msg_ptr);
if ((strspn(msg_ptr, B64) != (size_t) msg_len) || (msg_len < 12))
return 0;
if (getIniSectionForContact(serverRec, target, contactName) == FALSE)
return 0;
if (getContactKey(contactName, theKey) == FALSE)
return 0;
// usually a received message does not exceed 512 chars, but we want to prevent evil buffer overflow
if (msg_len >= (int)(sizeof(bf_dest) * 1.5))
msg_ptr[(int)(sizeof(bf_dest) * 1.5) - 20] = '\0';
// block-align blowcrypt strings if truncated by IRC server (each block is 12 chars long)
// such a truncated block is destroyed and not needed anymore
if (msg_len != (msg_len / 12) * 12) {
msg_len = (msg_len / 12) * 12;
msg_ptr[msg_len] = '\0';
strncpy(myMark, settings_get_str("mark_broken_block"),
sizeof(myMark));
if (*myMark == '\0' || isNoChar(*myMark))
mark_broken_block = 0;
else
mark_broken_block = 1;
}
decrypt_string(theKey, msg_ptr, bf_dest, msg_len);
ZeroMemory(theKey, KEYBUF_SIZE);
if (*bf_dest == '\0')
return 0; // don't process, decrypted msg is bad
// recode message again, last time it was the encrypted message...
if (settings_get_bool("recode") && serverRec != NULL) {
recoded = recode_in(serverRec, bf_dest, target);
if (recoded) {
strncpy(bf_dest, recoded, sizeof(bf_dest));
ZeroMemory(recoded, strlen(recoded));
g_free(recoded);
}
}
i = 0;
while (bf_dest[i] != 0x0A && bf_dest[i] != 0x0D && bf_dest[i] != '\0')
i++;
bf_dest[i] = '\0'; // in case of wrong key, decrypted message might have control characters -> cut message
if (strncmp(bf_dest, "\001ACTION ", 8) == 0) {
// ACTION message found
if (bf_dest[i - 1] == '\001')
bf_dest[i - 1] = '\0'; // remove 0x01 control character
action_found = 1;
}
// append broken-block-mark?
if (mark_broken_block)
strcat(bf_dest, myMark);
// append crypt-mark?
strncpy(myMark, settings_get_str("mark_encrypted"), sizeof(myMark));
if (*myMark != '\0') {
markPos = settings_get_int("mark_position");
if (markPos == 0 || action_found)
strcat(bf_dest, myMark); // append mark at the end (default for ACTION messages)
else { // prefix mark
i = strlen(myMark);
memmove(bf_dest + i, bf_dest, strlen(bf_dest) + 1);
strncpy(bf_dest, myMark, i);
}
}
g_string_assign(decrypted_msg, bf_dest);
ZeroMemory(bf_dest, sizeof(bf_dest));
return 1;
}
gboolean proxy_init(void)
{
gchar ipaddr[MAX_IP_LEN];
const char *password;
const char *addr;
int port;
proxy_settings_init();
proxy_data = g_new0(PLUGIN_DATA, 1);
password = settings_get_str("proxy_listen_password");
addr = settings_get_str("proxy_listen_addr");
port = settings_get_int("proxy_listen_port");
plug = module_find("proxy");
proxy_data->plugin = plug;
if (*password != '\0')
{
/* args = password */
proxy_data->password = g_strdup(password);
}
if (*addr != '\0')
{
/* specify ip address to listen */
net_host2ip(addr, &proxy_data->ip);
}
if (port != 0)
{
/* specify port to use */
proxy_data->port = port;
}
if (proxy_data->password == NULL)
{
/* no password - bad idea! */
printtext(NULL, NULL, MSGLEVEL_CLIENTNOTICE, "Warning!! Password not specified, everyone can use this proxy! Use /set proxy_listen_password <password> to set it");
}
if (servers == NULL)
{
/* FIXME: not good */
printtext(NULL, NULL, MSGLEVEL_CLIENTERROR, "You need to specify IP address to listen with /set proxy_listen_addr <address>");
deinit();
return FALSE;
}
else
{
SERVER_REC *server;
server = servers->data;
if (net_getsockname(net_sendbuffer_handle(server->handle), &proxy_data->ip, NULL))
{
deinit();
return FALSE;
}
}
net_ip2host(&proxy_data->ip, ipaddr);
printtext(NULL, NULL, MSGLEVEL_CLIENTNOTICE, "Proxy plugin loaded - listening in interface %s port %d", ipaddr, proxy_data->port);
plugin_proxy_listen_init(proxy_data);
proxy_data->loaded = TRUE;
return TRUE;
}
static void sig_complete_word(GList **list, WINDOW_REC *window,
const char *word, const char *linestart, int *want_space)
{
const char *newword, *cmdchars;
char *signal, *cmd, *args, *line;
g_return_if_fail(list != NULL);
g_return_if_fail(word != NULL);
g_return_if_fail(linestart != NULL);
/* check against "completion words" list */
newword = completion_find(word);
if (newword != NULL) {
*list = g_list_append(*list, g_strdup(newword));
signal_stop();
return;
}
/* command completion? */
cmdchars = settings_get_str("cmdchars");
if (strchr(cmdchars, *word) && *linestart == '\0') {
/* complete /command */
*list = completion_get_commands(word+1, *word);
if (*list != NULL) signal_stop();
return;
}
/* check only for /command completions from now on */
cmdchars = strchr(cmdchars, *linestart);
if (cmdchars == NULL) return;
/* check if there's aliases */
line = linestart[1] == *cmdchars ? g_strdup(linestart+2) :
expand_aliases(linestart+1);
cmd = line_get_command(line, &args, FALSE);
if (cmd == NULL) {
g_free(line);
return;
}
/* we're completing -option? */
if (*word == '-') {
*list = completion_get_options(cmd, word+1);
g_free(cmd);
g_free(line);
return;
}
/* complete parameters */
signal = g_strconcat("complete command ", cmd, NULL);
signal_emit(signal, 5, list, window, word, args, want_space);
if (command_have_sub(line)) {
/* complete subcommand */
g_free(cmd);
cmd = g_strconcat(line, " ", word, NULL);
*list = g_list_concat(completion_get_subcommands(cmd), *list);
if (*list != NULL) signal_stop();
}
g_free(signal);
g_free(cmd);
g_free(line);
}
/* Handle incoming DCC CTCP messages */
static void dcc_ctcp_msg(char *data, IRC_SERVER_REC *server, char *sender, char *sendaddr, char *target, DCC_REC *chat)
{
char *params, *type, *arg, *addrstr, *portstr, *sizestr, *str;
const char *cstr;
DCC_REC *dcc;
gulong size;
int port;
g_return_if_fail(data != NULL);
g_return_if_fail(sender != NULL);
params = cmd_get_params(data, 5 | PARAM_FLAG_NOQUOTES,
&type, &arg, &addrstr, &portstr, &sizestr);
if (sscanf(portstr, "%d", &port) != 1) port = 0;
if (sscanf(sizestr, "%lu", &size) != 1) size = 0;
dcc = dcc_create(SWAP_SENDGET(dcc_str2type(type)), -1, sender, arg, server, chat);
dcc_get_address(addrstr, &dcc->addr);
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->size = size;
switch (dcc->type)
{
case DCC_TYPE_GET:
cstr = settings_get_str("dcc_autoget_masks");
/* check that autoget masks match */
if (settings_get_bool("dcc_autoget") && (*cstr == '\0' || irc_masks_match(cstr, sender, sendaddr)) &&
/* check file size limit, FIXME: it's possible to send a bogus file size and then just send what ever sized file.. */
(settings_get_int("dcc_max_autoget_size") <= 0 || (settings_get_int("dcc_max_autoget_size") > 0 && size <= settings_get_int("dcc_max_autoget_size")*1024)))
{
/* automatically get */
str = g_strdup_printf("GET %s %s", dcc->nick, dcc->arg);
signal_emit("command dcc", 2, str, server);
g_free(str);
}
else
{
/* send request */
signal_emit("dcc request", 1, dcc);
}
break;
case DCC_TYPE_CHAT:
cstr = settings_get_str("dcc_autochat_masks");
if (*cstr != '\0' && irc_masks_match(cstr, sender, sendaddr))
{
/* automatically accept chat */
str = g_strdup_printf("CHAT %s", dcc->nick);
signal_emit("command dcc", 2, str, server);
g_free(str);
}
else
{
/* send request */
signal_emit("dcc request", 1, dcc);
}
break;
case DCC_TYPE_RESUME:
case DCC_TYPE_ACCEPT:
/* handle this in dcc-files.c */
dcc_destroy(dcc);
break;
default:
/* unknown DCC command */
signal_emit("dcc unknown ctcp", 3, data, sender, sendaddr);
dcc_destroy(dcc);
break;
}
g_free(params);
}
static void sig_log_new(LOG_REC *log)
{
if (!settings_get_bool("awaylog_colors") &&
g_strcmp0(log->fname, settings_get_str("awaylog_file")) == 0)
log->colorizer = log_colorizer_strip;
}
//------------------------------------------------------------------------------
int settings_get_int(settings_t* s, const char* name)
{
return atoi(settings_get_str(s, name));
}
/* current value of CMDCHARS */
static char *expando_cmdchars(SERVER_REC *server, void *item, int *free_ret)
{
return (char *) settings_get_str("cmdchars");
}
/* value of STATUS_OPER if you are an irc operator */
static char *expando_statusoper(SERVER_REC *server, void *item, int *free_ret)
{
return server == NULL || !server->server_operator ? "" :
(char *) settings_get_str("STATUS_OPER");
}
static void
sig_message_delay(SERVER_REC *server, const char *msg, const char *nick,
const char *target, time_t *t, gpointer gpointer_type)
{
void *item;
char *text, *freemsg = NULL;
char stamp[BUFSIZ];
int level, type;
g_return_if_fail(server != NULL);
g_return_if_fail(msg != NULL);
g_return_if_fail(nick != NULL);
g_return_if_fail(target != NULL);
type = GPOINTER_TO_INT(gpointer_type);
level = MSGLEVEL_NO_ACT | MSGLEVEL_NOHILIGHT
| (type == SEND_TARGET_CHANNEL ? MSGLEVEL_PUBLIC : MSGLEVEL_MSGS);
item = type == SEND_TARGET_CHANNEL ?
(void *)get_muc((XMPP_SERVER_REC *)server, target) :
query_find(server, nick);
if (settings_get_bool("emphasis"))
msg = freemsg = expand_emphasis(item, msg);
/* MUC */
if (type == SEND_TARGET_CHANNEL) {
CHANNEL_REC *chanrec = item;
int print_channel;
char *nickmode;
print_channel = chanrec == NULL ||
!window_item_is_active((WI_ITEM_REC *)chanrec);
if (!print_channel
&& settings_get_bool("print_active_channel")
&& window_item_window((WI_ITEM_REC *)chanrec)->items->next
!= NULL)
print_channel = TRUE;
nickmode = channel_get_nickmode(chanrec, nick);
text = !print_channel ?
format_get_text(CORE_MODULE_NAME, NULL, server,
target, TXT_PUBMSG, nick, msg, nickmode) :
format_get_text(CORE_MODULE_NAME, NULL, server,
target, TXT_PUBMSG_CHANNEL, nick, target, msg,
nickmode);
g_free(nickmode);
/* General */
} else
text = format_get_text(CORE_MODULE_NAME, NULL, server,
target, item == NULL ? TXT_MSG_PRIVATE :
TXT_MSG_PRIVATE_QUERY, nick, nick, msg);
if (strftime(stamp, sizeof(stamp)-1,
settings_get_str("xmpp_timestamp_format"), localtime(t)) == 0)
stamp[sizeof(stamp)-1] = '\0';
printformat_module(MODULE_NAME, server, target,
level, XMPPTXT_MESSAGE_TIMESTAMP,
stamp, text);
g_free_not_null(freemsg);
g_free(text);
}
/* manual word completion - called when TAB is pressed */
char *word_complete(WINDOW_REC *window, const char *line, int *pos, int erase, int backward)
{
static int startpos = 0, wordlen = 0;
int old_startpos, old_wordlen;
GString *result;
const char *cmdchars;
char *word, *wordstart, *linestart, *ret, *data;
int continue_complete, want_space, expand_escapes;
g_return_val_if_fail(line != NULL, NULL);
g_return_val_if_fail(pos != NULL, NULL);
continue_complete = complist != NULL && *pos == last_line_pos &&
g_strcmp0(line, last_line) == 0;
if (erase && !continue_complete)
return NULL;
old_startpos = startpos;
old_wordlen = wordlen;
if (!erase && continue_complete) {
word = NULL;
linestart = NULL;
} else {
char* old_wordstart;
/* get the word we want to complete */
word = get_word_at(line, *pos, &wordstart);
old_wordstart = wordstart;
startpos = (int) (wordstart-line);
wordlen = strlen(word);
/* remove trailing spaces from linestart */
while (wordstart > line && isseparator_space(wordstart[-1]))
wordstart--;
/* unless everything was spaces */
if (old_wordstart > line && wordstart == line)
wordstart = old_wordstart - 1;
linestart = g_strndup(line, (int) (wordstart-line));
/* completions usually add space after the word, that makes
things a bit harder. When continuing a completion
"/msg nick1 "<tab> we have to cycle to nick2, etc.
BUT if we start completion with "/msg "<tab>, we don't
want to complete the /msg word, but instead complete empty
word with /msg being in linestart. */
if (!erase && *pos > 0 && isseparator_space(line[*pos-1]) &&
(*linestart == '\0' || !isseparator_space(wordstart[-1]))) {
char *old;
old = linestart;
/* we want to move word into linestart */
if (*linestart == '\0') {
linestart = g_strdup(word);
} else {
GString *str = g_string_new(linestart);
if (old_wordstart[-1] != str->str[str->len - 1]) {
/* do not accidentally duplicate the word separator */
g_string_append_c(str, old_wordstart[-1]);
}
g_string_append(str, word);
linestart = g_string_free(str, FALSE);
}
g_free(old);
g_free(word);
word = g_strdup("");
startpos = *linestart == '\0' ? 0 :
strlen(linestart)+1;
wordlen = 0;
}
}
if (erase) {
signal_emit("complete erase", 3, window, word, linestart);
/* jump to next completion */
startpos = old_startpos;
wordlen = old_wordlen;
}
if (continue_complete) {
/* complete from old list */
if (backward)
complist = complist->prev != NULL ? complist->prev :
g_list_last(complist);
else
complist = complist->next != NULL ? complist->next :
g_list_first(complist);
want_space = last_want_space;
} else {
int keep_word = settings_get_bool("completion_keep_word");
/* get new completion list */
free_completions();
want_space = TRUE;
signal_emit("complete word", 5, &complist, window, word, linestart, &want_space);
last_want_space = want_space;
if (complist != NULL) {
/* Remove all nulls (from the signal) before doing further processing */
complist = g_list_remove_all(g_list_first(complist), NULL);
if (keep_word) {
complist = g_list_append(complist, g_strdup(word));
}
if (backward) {
complist = g_list_last(complist);
if (keep_word) {
complist = complist->prev;
}
}
}
}
g_free(linestart);
g_free(word);
if (complist == NULL)
return NULL;
/* get the cmd char */
cmdchars = settings_get_str("cmdchars");
/* get the expand_escapes setting */
expand_escapes = settings_get_bool("expand_escapes");
/* escape if the word doesn't begin with '/' and expand_escapes are turned on */
data = strchr(cmdchars, *line) == NULL && expand_escapes ?
escape_string_backslashes(complist->data) : g_strdup(complist->data);
/* word completed */
*pos = startpos + strlen(data);
/* replace the word in line - we need to return
a full new line */
result = g_string_new(line);
g_string_erase(result, startpos, wordlen);
g_string_insert(result, startpos, data);
if (want_space) {
if (!isseparator(result->str[*pos]))
g_string_insert_c(result, *pos, ' ');
(*pos)++;
}
wordlen = strlen(data);
last_line_pos = *pos;
g_free_not_null(last_line);
last_line = g_strdup(result->str);
ret = result->str;
g_string_free(result, FALSE);
/* free the data */
g_free(data);
return ret;
}
