apps/irssi/src/core/channels.c

   1 /*
   2  channel.c : irssi
   3
   4     Copyright (C) 1999-2000 Timo Sirainen
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 #include "module.h"
  22 #include "signals.h"
  23 #include "misc.h"
  24 #include "special-vars.h"
  25
  26 #include "servers.h"
  27 #include "channels.h"
  28 #include "channels-setup.h"
  29 #include "nicklist.h"
  30
  31 GSList *channels; /* List of all channels */
  32
  33 static char *get_join_data(CHANNEL_REC *channel)
  34 {
  35         return g_strdup(channel->name);
  36 }
  37
  38 static const char *channel_get_target(WI_ITEM_REC *item)
  39 {
  40         return ((CHANNEL_REC *) item)->name;
  41 }
  42
  43 void channel_init(CHANNEL_REC *channel, SERVER_REC *server, const char *name,
  44                   const char *visible_name, int automatic)
  45 {
  46         g_return_if_fail(channel != NULL);
  47         g_return_if_fail(name != NULL);
  48         g_return_if_fail(server != NULL);
  49
  50         if (visible_name == NULL)
  51                 visible_name = name;
  52
  53         MODULE_DATA_INIT(channel);
  54         channel->type = module_get_uniq_id_str("WINDOW ITEM TYPE", "CHANNEL");
  55         channel->destroy = (void (*) (WI_ITEM_REC *)) channel_destroy;
  56         channel->get_target = channel_get_target;
  57         channel->get_join_data = get_join_data;
  58
  59         channel->chat_type = server->chat_type;
  60         channel->server = server;
  61         channel->name = g_strdup(name);
  62         channel->visible_name = g_strdup(visible_name);
  63         channel->mode = g_strdup("");
  64         channel->createtime = time(NULL);
  65
  66         channels = g_slist_append(channels, channel);
  67         server->channels = g_slist_append(server->channels, channel);
  68
  69         signal_emit("channel created", 2, channel, GINT_TO_POINTER(automatic));
  70 }
  71
  72 void channel_destroy(CHANNEL_REC *channel)
  73 {
  74         g_return_if_fail(IS_CHANNEL(channel));
  75
  76         if (channel->destroying) return;
  77         channel->destroying = TRUE;
  78
  79         channels = g_slist_remove(channels, channel);
  80         channel->server->channels =
  81                 g_slist_remove(channel->server->channels, channel);
  82
  83         signal_emit("channel destroyed", 1, channel);
  84
  85         MODULE_DATA_DEINIT(channel);
  86         g_free_not_null(channel->hilight_color);
  87         g_free_not_null(channel->topic);
  88         g_free_not_null(channel->topic_by);
  89         g_free_not_null(channel->key);
  90         g_free(channel->mode);
  91         g_free(channel->name);
  92         g_free(channel->visible_name);
  93
  94         channel->type = 0;
  95         g_free(channel);
  96 }
  97
  98 static CHANNEL_REC *channel_find_server(SERVER_REC *server,
  99                                         const char *name)
 100 {
 101         GSList *tmp;
 102
 103         g_return_val_if_fail(IS_SERVER(server), NULL);
 104
 105         if (server->channel_find_func != NULL) {
 106                 /* use the server specific channel find function */
 107                 return server->channel_find_func(server, name);
 108         }
 109
 110         for (tmp = server->channels; tmp != NULL; tmp = tmp->next) {
 111                 CHANNEL_REC *rec = tmp->data;
 112
 113                 if (g_strcasecmp(name, rec->name) == 0)
 114                         return rec;
 115         }
 116
 117         return NULL;
 118 }
 119
 120 CHANNEL_REC *channel_find(SERVER_REC *server, const char *name)
 121 {
 122         g_return_val_if_fail(server == NULL || IS_SERVER(server), NULL);
 123         g_return_val_if_fail(name != NULL, NULL);
 124
 125         if (server != NULL)
 126                 return channel_find_server(server, name);
 127
 128         /* find from any server */
 129         return gslist_foreach_find(servers,
 130                                    (FOREACH_FIND_FUNC) channel_find_server,
 131                                    (void *) name);
 132 }
 133
 134 void channel_change_name(CHANNEL_REC *channel, const char *name)
 135 {
 136         g_return_if_fail(IS_CHANNEL(channel));
 137
 138         g_free(channel->name);
 139         channel->name = g_strdup(name);
 140
 141         signal_emit("channel name changed", 1, channel);
 142 }
 143
 144 void channel_change_visible_name(CHANNEL_REC *channel, const char *name)
 145 {
 146         g_return_if_fail(IS_CHANNEL(channel));
 147
 148         g_free(channel->visible_name);
 149         channel->visible_name = g_strdup(name);
 150
 151         signal_emit("window item name changed", 1, channel);
 152 }
 153
 154 static CHANNEL_REC *channel_find_servers(GSList *servers, const char *name)
 155 {
 156         return gslist_foreach_find(servers,
 157                                    (FOREACH_FIND_FUNC) channel_find_server,
 158                                    (void *) name);
 159 }
 160
 161 static GSList *servers_find_chatnet_except(SERVER_REC *server)
 162 {
 163         GSList *tmp, *list;
 164
 165         list = NULL;
 166         for (tmp = servers; tmp != NULL; tmp = tmp->next) {
 167                 SERVER_REC *rec = tmp->data;
 168
 169                 if (server != rec && rec->connrec->chatnet != NULL &&
 170                     strcmp(server->connrec->chatnet,
 171                            rec->connrec->chatnet) == 0) {
 172                         /* chatnets match */
 173                         list = g_slist_append(list, rec);
 174                 }
 175         }
 176
 177         return list;
 178 }
 179
 180 /* connected to server, autojoin to channels. */
 181 static void event_connected(SERVER_REC *server)
 182 {
 183         GString *chans;
 184         GSList *tmp, *chatnet_servers;
 185
 186         g_return_if_fail(SERVER(server));
 187
 188         if (server->connrec->reconnection ||
 189             server->connrec->no_autojoin_channels)
 190                 return;
 191
 192         /* get list of servers in same chat network */
 193         chatnet_servers = server->connrec->chatnet == NULL ? NULL:
 194                 servers_find_chatnet_except(server);
 195
 196         /* join to the channels marked with autojoin in setup */
 197         chans = g_string_new(NULL);
 198         for (tmp = setupchannels; tmp != NULL; tmp = tmp->next) {
 199                 CHANNEL_SETUP_REC *rec = tmp->data;
 200
 201                 if (!rec->autojoin ||
 202                     !channel_chatnet_match(rec->chatnet,
 203                                            server->connrec->chatnet))
 204                         continue;
 205
 206                 /* check that we haven't already joined this channel in
 207                    same chat network connection.. */
 208                 if (channel_find_servers(chatnet_servers, rec->name) == NULL)
 209                         g_string_sprintfa(chans, "%s,", rec->name);
 210         }
 211         g_slist_free(chatnet_servers);
 212
 213         if (chans->len > 0) {
 214                 g_string_truncate(chans, chans->len-1);
 215                 server->channels_join(server, chans->str, TRUE);
 216         }
 217
 218         g_string_free(chans, TRUE);
 219 }
 220
 221 static int match_nick_flags(SERVER_REC *server, NICK_REC *nick, char flag)
 222 {
 223         const char *flags = server->get_nick_flags(server);
 224
 225         return strchr(flags, flag) == NULL ||
 226                 (flag == flags[0] && nick->op) ||
 227                 (flag == flags[1] && (nick->voice || nick->halfop ||
 228                                       nick->op)) ||
 229                 (flag == flags[2] && (nick->halfop || nick->op));
 230 }
 231
 232 /* Send the auto send command to channel */
 233 void channel_send_autocommands(CHANNEL_REC *channel)
 234 {
 235         CHANNEL_SETUP_REC *rec;
 236         NICK_REC *nick;
 237         char **bots, **bot;
 238
 239         g_return_if_fail(IS_CHANNEL(channel));
 240
 241         if (channel->session_rejoin)
 242                 return;
 243
 244         rec = channel_setup_find(channel->name, channel->server->connrec->chatnet);
 245         if (rec == NULL || rec->autosendcmd == NULL || !*rec->autosendcmd)
 246                 return;
 247
 248         if (rec->botmasks == NULL || !*rec->botmasks) {
 249                 /* just send the command. */
 250                 eval_special_string(rec->autosendcmd, "", channel->server, channel);
 251                 return;
 252         }
 253
 254         /* find first available bot.. */
 255         bots = g_strsplit(rec->botmasks, " ", -1);
 256         for (bot = bots; *bot != NULL; bot++) {
 257                 const char *botnick = *bot;
 258
 259                 if (*botnick == '\0')
 260                         continue;
 261
 262                 nick = nicklist_find_mask(channel,
 263                                           channel->server->isnickflag(channel->server, *botnick) ?
 264                                           botnick+1 : botnick);
 265                 if (nick != NULL &&
 266                     match_nick_flags(channel->server, nick, *botnick)) {
 267                         eval_special_string(rec->autosendcmd, nick->nick,
 268                                             channel->server, channel);
 269                         break;
 270                 }
 271         }
 272         g_strfreev(bots);
 273 }
 274
 275 void channels_init(void)
 276 {
 277         channels_setup_init();
 278
 279         signal_add("event connected", (SIGNAL_FUNC) event_connected);
 280 }
 281
 282 void channels_deinit(void)
 283 {
 284         channels_setup_deinit();
 285
 286         signal_remove("event connected", (SIGNAL_FUNC) event_connected);
 287 }