apps/irssi/src/core/chat-commands.c

   1 /*
   2  chat-commands.c : irssi
   3
   4     Copyright (C) 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 "network.h"
  23 #include "signals.h"
  24 #include "commands.h"
  25 #include "special-vars.h"
  26 #include "settings.h"
  27
  28 #include "chat-protocols.h"
  29 #include "servers.h"
  30 #include "servers-setup.h"
  31 #include "servers-reconnect.h"
  32 #include "channels.h"
  33 #include "queries.h"
  34 #include "window-item-def.h"
  35
  36 static SERVER_CONNECT_REC *get_server_connect(const char *data, int *plus_addr)
  37 {
  38         CHAT_PROTOCOL_REC *proto;
  39         SERVER_CONNECT_REC *conn;
  40         GHashTable *optlist;
  41         char *addr, *portstr, *password, *nick, *chatnet, *host;
  42         void *free_arg;
  43
  44         g_return_val_if_fail(data != NULL, NULL);
  45
  46         if (!cmd_get_params(data, &free_arg, 4 | PARAM_FLAG_OPTIONS,
  47                             "connect", &optlist, &addr, &portstr,
  48                             &password, &nick))
  49                 return NULL;
  50         if (plus_addr != NULL) *plus_addr = *addr == '+';
  51         if (*addr == '+') addr++;
  52         if (*addr == '\0') {
  53                 signal_emit("error command", 1,
  54                             GINT_TO_POINTER(CMDERR_NOT_ENOUGH_PARAMS));
  55                 cmd_params_free(free_arg);
  56                 return NULL;
  57         }
  58
  59         if (strcmp(password, "-") == 0)
  60                 *password = '\0';
  61
  62         /* check if -<chatnet> option is used to specify chat protocol */
  63         proto = chat_protocol_find_net(optlist);
  64
  65         /* connect to server */
  66         chatnet = proto == NULL ? NULL :
  67                 g_hash_table_lookup(optlist, proto->chatnet);
  68         conn = server_create_conn(proto != NULL ? proto->id : -1, addr,
  69                                   atoi(portstr), chatnet, password, nick);
  70         if (proto == NULL)
  71                 proto = chat_protocol_find_id(conn->chat_type);
  72
  73         if (proto->not_initialized) {
  74                 /* trying to use protocol that isn't yet initialized */
  75                 signal_emit("chat protocol unknown", 1, proto->name);
  76                 server_connect_free(conn);
  77                 cmd_params_free(free_arg);
  78                 return NULL;
  79         }
  80
  81         if (g_hash_table_lookup(optlist, "6") != NULL)
  82                 conn->family = AF_INET6;
  83         else if (g_hash_table_lookup(optlist, "4") != NULL)
  84                 conn->family = AF_INET;
  85
  86         host = g_hash_table_lookup(optlist, "host");
  87         if (host != NULL && *host != '\0') {
  88                 IPADDR ip4, ip6;
  89
  90                 if (net_gethostbyname(host, &ip4, &ip6) == 0)
  91                         server_connect_own_ip_save(conn, &ip4, &ip6);
  92         }
  93
  94         cmd_params_free(free_arg);
  95         return conn;
  96 }
  97
  98 /* SYNTAX: CONNECT [-4 | -6] [-ircnet <ircnet>] [-host <hostname>]
  99                    <address>|<chatnet> [<port> [<password> [<nick>]]] */
 100 static void cmd_connect(const char *data)
 101 {
 102         SERVER_CONNECT_REC *conn;
 103
 104         conn = get_server_connect(data, NULL);
 105         if (conn != NULL)
 106                 CHAT_PROTOCOL(conn)->server_connect(conn);
 107 }
 108
 109 static RECONNECT_REC *find_reconnect_server(int chat_type,
 110                                             const char *addr, int port)
 111 {
 112         RECONNECT_REC *match, *last_proto_match;
 113         GSList *tmp;
 114         int count;
 115
 116         g_return_val_if_fail(addr != NULL, NULL);
 117
 118         /* check if there's a reconnection to the same host and maybe even
 119            the same port */
 120         match = last_proto_match = NULL; count = 0;
 121         for (tmp = reconnects; tmp != NULL; tmp = tmp->next) {
 122                 RECONNECT_REC *rec = tmp->data;
 123
 124                 if (rec->conn->chat_type == chat_type) {
 125                         count++; last_proto_match = rec;
 126                         if (g_strcasecmp(rec->conn->address, addr) == 0) {
 127                                 if (rec->conn->port == port)
 128                                         return rec;
 129                                 match = rec;
 130                         }
 131                 }
 132         }
 133
 134         if (count == 1) {
 135                 /* only one reconnection with wanted protocol,
 136                    we probably want to use it */
 137                 return last_proto_match;
 138         }
 139
 140         return match;
 141 }
 142
 143 static void update_reconnection(SERVER_CONNECT_REC *conn, SERVER_REC *server)
 144 {
 145         SERVER_CONNECT_REC *oldconn;
 146         RECONNECT_REC *recon;
 147
 148         if (server != NULL) {
 149                 oldconn = server->connrec;
 150                 reconnect_save_status(conn, server);
 151         } else {
 152                 /* maybe we can reconnect some server from
 153                    reconnection queue */
 154                 recon = find_reconnect_server(conn->chat_type,
 155                                               conn->address, conn->port);
 156                 if (recon == NULL) return;
 157
 158                 oldconn = recon->conn;
 159                 server_reconnect_destroy(recon, FALSE);
 160
 161                 conn->away_reason = g_strdup(oldconn->away_reason);
 162                 conn->channels = g_strdup(oldconn->channels);
 163         }
 164
 165         conn->reconnection = TRUE;
 166
 167         if (conn->chatnet == NULL && oldconn->chatnet != NULL)
 168                 conn->chatnet = g_strdup(oldconn->chatnet);
 169
 170         if (server != NULL) {
 171                 signal_emit("command disconnect", 2,
 172                             "* Changing server", server);
 173         } else {
 174                 server_connect_free(oldconn);
 175         }
 176 }
 177
 178 /* SYNTAX: SERVER [-4 | -6] [-ircnet <ircnet>] [-host <hostname>]
 179                   [+]<address>|<chatnet> [<port> [<password> [<nick>]]] */
 180 static void cmd_server(const char *data, SERVER_REC *server)
 181 {
 182         SERVER_CONNECT_REC *conn;
 183         int plus_addr;
 184
 185         g_return_if_fail(data != NULL);
 186
 187         /* create connection record */
 188         conn = get_server_connect(data, &plus_addr);
 189         if (conn != NULL) {
 190                 if (!plus_addr)
 191                         update_reconnection(conn, server);
 192                 CHAT_PROTOCOL(conn)->server_connect(conn);
 193         }
 194 }
 195
 196 /* SYNTAX: DISCONNECT *|<tag> [<message>] */
 197 static void cmd_disconnect(const char *data, SERVER_REC *server)
 198 {
 199         char *tag, *msg;
 200         void *free_arg;
 201
 202         g_return_if_fail(data != NULL);
 203
 204         if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_GETREST, &tag, &msg))
 205                 return;
 206
 207         if (*tag != '\0' && strcmp(tag, "*") != 0)
 208                 server = server_find_tag(tag);
 209         if (server == NULL) cmd_param_error(CMDERR_NOT_CONNECTED);
 210
 211         if (*msg == '\0') msg = (char *) settings_get_str("quit_message");
 212         signal_emit("server quit", 2, server, msg);
 213
 214         cmd_params_free(free_arg);
 215         server_disconnect(server);
 216 }
 217
 218 /* SYNTAX: QUIT [<message>] */
 219 static void cmd_quit(const char *data)
 220 {
 221         GSList *tmp, *next;
 222         const char *quitmsg;
 223         char *str;
 224
 225         g_return_if_fail(data != NULL);
 226
 227         quitmsg = *data != '\0' ? data :
 228                 settings_get_str("quit_message");
 229
 230         /* disconnect from every server */
 231         for (tmp = servers; tmp != NULL; tmp = next) {
 232                 next = tmp->next;
 233
 234                 str = g_strdup_printf("* %s", quitmsg);
 235                 cmd_disconnect(str, tmp->data);
 236                 g_free(str);
 237         }
 238
 239         signal_emit("gui exit", 0);
 240 }
 241
 242 /* SYNTAX: JOIN [-invite] [-<server tag>] <channels> [<keys>] */
 243 static void cmd_join(const char *data, SERVER_REC *server)
 244 {
 245         GHashTable *optlist;
 246         char *channels;
 247         void *free_arg;
 248
 249         g_return_if_fail(data != NULL);
 250         if (!IS_SERVER(server) || !server->connected)
 251                 cmd_return_error(CMDERR_NOT_CONNECTED);
 252
 253         if (!cmd_get_params(data, &free_arg, 1 | PARAM_FLAG_OPTIONS |
 254                             PARAM_FLAG_UNKNOWN_OPTIONS | PARAM_FLAG_GETREST,
 255                             "join", &optlist, &channels))
 256                 return;
 257
 258         if (g_hash_table_lookup(optlist, "invite"))
 259                 channels = server->last_invite;
 260         else {
 261                 if (*channels == '\0')
 262                         cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
 263
 264                 /* -<server tag> */
 265                 server = cmd_options_get_server("join", optlist, server);
 266         }
 267
 268         if (server != NULL && channels != NULL)
 269                 server->channels_join(server, channels, FALSE);
 270         cmd_params_free(free_arg);
 271 }
 272
 273 /* SYNTAX: MSG [-<server tag>] <targets> <message> */
 274 static void cmd_msg(const char *data, SERVER_REC *server, WI_ITEM_REC *item)
 275 {
 276         GHashTable *optlist;
 277         char *target, *origtarget, *msg;
 278         void *free_arg;
 279         int free_ret;
 280
 281         g_return_if_fail(data != NULL);
 282
 283         if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_OPTIONS |
 284                             PARAM_FLAG_UNKNOWN_OPTIONS | PARAM_FLAG_GETREST,
 285                             "msg", &optlist, &target, &msg))
 286                 return;
 287         if (*target == '\0' || *msg == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
 288
 289         server = cmd_options_get_server("msg", optlist, SERVER(server));
 290         if (server == NULL || !server->connected)
 291                 cmd_param_error(CMDERR_NOT_CONNECTED);
 292
 293         origtarget = target;
 294         free_ret = FALSE;
 295         if (strcmp(target, ",") == 0 || strcmp(target, ".") == 0) {
 296                 target = parse_special(&target, server, item,
 297                                        NULL, &free_ret, NULL, 0);
 298                 if (target != NULL && *target == '\0')
 299                         target = NULL;
 300         } else if (strcmp(target, "*") == 0 && item != NULL)
 301                 target = item->name;
 302
 303         if (target != NULL)
 304                 server->send_message(server, target, msg);
 305
 306         signal_emit(target != NULL && server->ischannel(target) ?
 307                     "message own_public" : "message own_private", 4,
 308                     server, msg, target, origtarget);
 309
 310         if (free_ret && target != NULL) g_free(target);
 311         cmd_params_free(free_arg);
 312 }
 313
 314 static void cmd_foreach(const char *data, SERVER_REC *server,
 315                         WI_ITEM_REC *item)
 316 {
 317         command_runsub("foreach", data, server, item);
 318 }
 319
 320 /* SYNTAX: FOREACH SERVER <command> */
 321 static void cmd_foreach_server(const char *data, SERVER_REC *server)
 322 {
 323         GSList *tmp;
 324
 325         for (tmp = servers; tmp != NULL; tmp = tmp->next)
 326                 signal_emit("send command", 3, data, tmp->data, NULL);
 327 }
 328
 329 /* SYNTAX: FOREACH CHANNEL <command> */
 330 static void cmd_foreach_channel(const char *data)
 331 {
 332         GSList *tmp;
 333
 334         for (tmp = channels; tmp != NULL; tmp = tmp->next) {
 335                 CHANNEL_REC *rec = tmp->data;
 336
 337                 signal_emit("send command", 3, data, rec->server, rec);
 338         }
 339 }
 340
 341 /* SYNTAX: FOREACH QUERY <command> */
 342 static void cmd_foreach_query(const char *data)
 343 {
 344         GSList *tmp;
 345
 346         for (tmp = queries; tmp != NULL; tmp = tmp->next) {
 347                 QUERY_REC *rec = tmp->data;
 348
 349                 signal_emit("send command", 3, data, rec->server, rec);
 350         }
 351 }
 352
 353 void chat_commands_init(void)
 354 {
 355         settings_add_str("misc", "quit_message", "leaving");
 356
 357         command_bind("server", NULL, (SIGNAL_FUNC) cmd_server);
 358         command_bind("connect", NULL, (SIGNAL_FUNC) cmd_connect);
 359         command_bind("disconnect", NULL, (SIGNAL_FUNC) cmd_disconnect);
 360         command_bind("quit", NULL, (SIGNAL_FUNC) cmd_quit);
 361         command_bind("join", NULL, (SIGNAL_FUNC) cmd_join);
 362         command_bind("msg", NULL, (SIGNAL_FUNC) cmd_msg);
 363         command_bind("foreach", NULL, (SIGNAL_FUNC) cmd_foreach);
 364         command_bind("foreach server", NULL, (SIGNAL_FUNC) cmd_foreach_server);
 365         command_bind("foreach channel", NULL, (SIGNAL_FUNC) cmd_foreach_channel);
 366         command_bind("foreach query", NULL, (SIGNAL_FUNC) cmd_foreach_query);
 367
 368         command_set_options("connect", "4 6 +host");
 369         command_set_options("join", "invite");
 370 }
 371
 372 void chat_commands_deinit(void)
 373 {
 374         command_unbind("server", (SIGNAL_FUNC) cmd_server);
 375         command_unbind("connect", (SIGNAL_FUNC) cmd_connect);
 376         command_unbind("disconnect", (SIGNAL_FUNC) cmd_disconnect);
 377         command_unbind("quit", (SIGNAL_FUNC) cmd_quit);
 378         command_unbind("join", (SIGNAL_FUNC) cmd_join);
 379         command_unbind("msg", (SIGNAL_FUNC) cmd_msg);
 380         command_unbind("foreach", (SIGNAL_FUNC) cmd_foreach);
 381         command_unbind("foreach server", (SIGNAL_FUNC) cmd_foreach_server);
 382         command_unbind("foreach channel", (SIGNAL_FUNC) cmd_foreach_channel);
 383         command_unbind("foreach query", (SIGNAL_FUNC) cmd_foreach_query);
 384 }