apps/irssi/src/silc/core/silc-servers.c

   1 /*
   2   silc-server.c : irssi
   3
   4   Copyright (C) 2000 - 2001 Timo Sirainen
   5                             Pekka Riikonen <priikone@poseidon.pspt.fi>
   6
   7   This program is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU General Public License as published by
   9   the Free Software Foundation; either version 2 of the License, or
  10   (at your option) any later version.
  11
  12   This program is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15   GNU General Public License for more details.
  16
  17   You should have received a copy of the GNU General Public License
  18   along with this program; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20 */
  21
  22 #include "module.h"
  23
  24 #include "net-nonblock.h"
  25 #include "net-sendbuffer.h"
  26 #include "signals.h"
  27 #include "servers.h"
  28 #include "commands.h"
  29 #include "levels.h"
  30 #include "modules.h"
  31 #include "rawlog.h"
  32 #include "misc.h"
  33 #include "settings.h"
  34
  35 #include "servers-setup.h"
  36
  37 #include "silc-servers.h"
  38 #include "silc-channels.h"
  39 #include "silc-queries.h"
  40 #include "window-item-def.h"
  41
  42 #include "fe-common/core/printtext.h"
  43
  44 void silc_servers_reconnect_init(void);
  45 void silc_servers_reconnect_deinit(void);
  46
  47 static void silc_send_channel(SILC_SERVER_REC *server,
  48                               char *channel, char *msg)
  49 {
  50   SILC_CHANNEL_REC *rec;
  51
  52   rec = silc_channel_find(server, channel);
  53   if (rec == NULL)
  54     return;
  55
  56   silc_client_send_channel_message(silc_client, server->conn, rec->entry,
  57                                    NULL, 0, msg, strlen(msg), TRUE);
  58 }
  59
  60 typedef struct {
  61   char *nick;
  62   char *msg;
  63 } PRIVMSG_REC;
  64
  65 static void silc_send_msg_clients(SilcClient client,
  66                                   SilcClientConnection conn,
  67                                   SilcClientEntry *clients,
  68                                   uint32 clients_count,
  69                                   void *context)
  70 {
  71   PRIVMSG_REC *rec = context;
  72   SilcClientEntry target;
  73
  74   if (clients_count == 0) {
  75     printtext(NULL, NULL, MSGLEVEL_CLIENTERROR, "Unknown nick: %s", rec->nick);
  76   } else {
  77     target = clients[0]; /* FIXME: not a good idea :) */
  78
  79     silc_client_send_private_message(client, conn, target, 0,
  80                                      rec->msg, strlen(rec->msg),
  81                                      TRUE);
  82   }
  83
  84   g_free(rec->nick);
  85   g_free(rec->msg);
  86   g_free(rec);
  87 }
  88
  89 static void silc_send_msg(SILC_SERVER_REC *server, char *nick, char *msg)
  90 {
  91   PRIVMSG_REC *rec;
  92
  93   rec = g_new0(PRIVMSG_REC, 1);
  94   rec->nick = g_strdup(nick);
  95   rec->msg = g_strdup(msg);
  96
  97   silc_client_get_clients(silc_client, server->conn,
  98                           nick, "", silc_send_msg_clients, rec);
  99 }
 100
 101 static int isnickflag_func(char flag)
 102 {
 103   return flag == '@' || flag == '+';
 104 }
 105
 106 static int ischannel_func(const char *data)
 107 {
 108   return *data == '#';
 109 }
 110
 111 const char *get_nick_flags(void)
 112 {
 113   return "@\0\0";
 114 }
 115
 116 static void send_message(SILC_SERVER_REC *server, char *target, char *msg)
 117 {
 118   g_return_if_fail(server != NULL);
 119   g_return_if_fail(target != NULL);
 120   g_return_if_fail(msg != NULL);
 121
 122   if (*target == '#')
 123     silc_send_channel(server, target, msg);
 124   else
 125     silc_send_msg(server, target, msg);
 126 }
 127
 128 static void sig_connected(SILC_SERVER_REC *server)
 129 {
 130   SilcClientConnection conn;
 131   int fd;
 132
 133   if (!IS_SILC_SERVER(server))
 134     return;
 135
 136   conn = silc_client_add_connection(silc_client,
 137                                     server->connrec->address,
 138                                     server->connrec->port,
 139                                     server);
 140   server->conn = conn;
 141
 142   fd = g_io_channel_unix_get_fd(net_sendbuffer_handle(server->handle));
 143   if (!silc_client_start_key_exchange(silc_client, conn, fd)) {
 144     /* some internal error occured */
 145     server_disconnect(SERVER(server));
 146     signal_stop();
 147     return;
 148   }
 149
 150   server->isnickflag = isnickflag_func;
 151   server->ischannel = ischannel_func;
 152   server->get_nick_flags = get_nick_flags;
 153   server->send_message = (void *) send_message;
 154 }
 155
 156 static void sig_disconnected(SILC_SERVER_REC *server)
 157 {
 158   if (!IS_SILC_SERVER(server) || server->conn == NULL)
 159     return;
 160
 161   if (server->conn->sock != NULL) {
 162     silc_client_close_connection(silc_client, NULL, server->conn);
 163
 164     /* SILC closes the handle */
 165     g_io_channel_unref(net_sendbuffer_handle(server->handle));
 166     net_sendbuffer_destroy(server->handle, FALSE);
 167     server->handle = NULL;
 168   }
 169 }
 170
 171 SILC_SERVER_REC *silc_server_connect(SILC_SERVER_CONNECT_REC *conn)
 172 {
 173   SILC_SERVER_REC *server;
 174
 175   g_return_val_if_fail(IS_SILC_SERVER_CONNECT(conn), NULL);
 176   if (conn->address == NULL || *conn->address == '\0')
 177     return NULL;
 178   if (conn->nick == NULL || *conn->nick == '\0') {
 179     printtext(NULL, NULL, MSGLEVEL_CLIENTERROR,
 180               "Cannot connect: nickname is not set");
 181     return NULL;
 182   }
 183
 184   server = g_new0(SILC_SERVER_REC, 1);
 185   server->chat_type = SILC_PROTOCOL;
 186   server->connrec = conn;
 187   if (server->connrec->port <= 0)
 188     server->connrec->port = 706;
 189
 190   if (!server_start_connect((SERVER_REC *) server)) {
 191     server_connect_free(SERVER_CONNECT(conn));
 192     g_free(server);
 193     return NULL;
 194   }
 195
 196   return server;
 197 }
 198
 199 /* Return a string of all channels in server in server->channels_join()
 200    format */
 201
 202 char *silc_server_get_channels(SILC_SERVER_REC *server)
 203 {
 204   GSList *tmp;
 205   GString *chans;
 206   char *ret;
 207
 208   g_return_val_if_fail(server != NULL, FALSE);
 209
 210   chans = g_string_new(NULL);
 211   for (tmp = server->channels; tmp != NULL; tmp = tmp->next) {
 212     CHANNEL_REC *channel = tmp->data;
 213
 214     g_string_sprintfa(chans, "%s,", channel->name);
 215   }
 216
 217   if (chans->len > 0)
 218     g_string_truncate(chans, chans->len-1);
 219
 220   ret = chans->str;
 221   g_string_free(chans, FALSE);
 222
 223   return ret;
 224 }
 225
 226 void silc_command_exec(SILC_SERVER_REC *server,
 227                        const char *command, const char *args)
 228 {
 229   uint32 argc = 0;
 230   unsigned char **argv;
 231   uint32 *argv_lens, *argv_types;
 232   char *data, *tmpcmd;
 233   SilcClientCommand *cmd;
 234   SilcClientCommandContext ctx;
 235
 236   g_return_if_fail(server != NULL);
 237
 238   tmpcmd = g_strdup(command); g_strup(tmpcmd);
 239   cmd = silc_client_command_find(tmpcmd);
 240   g_free(tmpcmd);
 241   if (cmd == NULL)
 242     return;
 243
 244   /* Now parse all arguments */
 245   data = g_strconcat(command, " ", args, NULL);
 246   silc_parse_command_line(data, &argv, &argv_lens,
 247                           &argv_types, &argc, cmd->max_args);
 248   g_free(data);
 249
 250   /* Allocate command context. This and its internals must be free'd
 251      by the command routine receiving it. */
 252   ctx = silc_client_command_alloc();
 253   ctx->client = silc_client;
 254   ctx->conn = server->conn;
 255   ctx->command = cmd;
 256   ctx->argc = argc;
 257   ctx->argv = argv;
 258   ctx->argv_lens = argv_lens;
 259   ctx->argv_types = argv_types;
 260
 261   /* Execute command */
 262   (*cmd->cb)(ctx);
 263 }
 264
 265 static void command_users(const char *data, SILC_SERVER_REC *server,
 266                           WI_ITEM_REC *item)
 267 {
 268   signal_emit("command names", 3, data, server, item);
 269 }
 270
 271 static void command_self(const char *data, SILC_SERVER_REC *server)
 272 {
 273   if (!IS_SILC_SERVER(server) || !server->connected) {
 274     printtext(NULL, NULL, MSGLEVEL_CLIENTERROR, "Not connected to server");
 275     return;
 276   }
 277
 278   silc_command_exec(server, current_command, data);
 279   signal_stop();
 280 }
 281
 282 static void event_text(const char *line, SILC_SERVER_REC *server,
 283                        WI_ITEM_REC *item)
 284 {
 285   char *str;
 286
 287   g_return_if_fail(line != NULL);
 288
 289   if (!IS_SILC_ITEM(item))
 290     return;
 291
 292   str = g_strdup_printf("%s %s", item->name, line);
 293   signal_emit("command msg", 3, str, server, item);
 294   g_free(str);
 295
 296   signal_stop();
 297 }
 298
 299 void silc_server_init(void)
 300 {
 301   silc_servers_reconnect_init();
 302
 303   signal_add_first("server connected", (SIGNAL_FUNC) sig_connected);
 304   signal_add("server disconnected", (SIGNAL_FUNC) sig_disconnected);
 305   signal_add("send text", (SIGNAL_FUNC) event_text);
 306   command_bind("whois", MODULE_NAME, (SIGNAL_FUNC) command_self);
 307   command_bind("whowas", MODULE_NAME, (SIGNAL_FUNC) command_self);
 308   command_bind("nick", MODULE_NAME, (SIGNAL_FUNC) command_self);
 309   command_bind("topic", MODULE_NAME, (SIGNAL_FUNC) command_self);
 310   command_bind("cmode", MODULE_NAME, (SIGNAL_FUNC) command_self);
 311   command_bind("cumode", MODULE_NAME, (SIGNAL_FUNC) command_self);
 312   command_bind("users", MODULE_NAME, (SIGNAL_FUNC) command_self);
 313   command_bind("list", MODULE_NAME, (SIGNAL_FUNC) command_self);
 314   command_bind("ban", MODULE_NAME, (SIGNAL_FUNC) command_self);
 315   command_bind("silcoper", MODULE_NAME, (SIGNAL_FUNC) command_self);
 316   command_bind("umode", MODULE_NAME, (SIGNAL_FUNC) command_self);
 317   command_bind("invite", MODULE_NAME, (SIGNAL_FUNC) command_self);
 318   command_bind("kill", MODULE_NAME, (SIGNAL_FUNC) command_self);
 319   command_bind("kick", MODULE_NAME, (SIGNAL_FUNC) command_self);
 320   command_bind("info", MODULE_NAME, (SIGNAL_FUNC) command_self);
 321   command_bind("connect", MODULE_NAME, (SIGNAL_FUNC) command_self);
 322   command_bind("ping", MODULE_NAME, (SIGNAL_FUNC) command_self);
 323   command_bind("motd", MODULE_NAME, (SIGNAL_FUNC) command_self);
 324   command_bind("close", MODULE_NAME, (SIGNAL_FUNC) command_self);
 325   command_bind("shutdown", MODULE_NAME, (SIGNAL_FUNC) command_self);
 326   command_bind("getkey", MODULE_NAME, (SIGNAL_FUNC) command_self);
 327
 328   command_set_options("connect", "+silcnet");
 329 }
 330
 331 void silc_server_deinit(void)
 332 {
 333   silc_servers_reconnect_deinit();
 334
 335   signal_remove("server connected", (SIGNAL_FUNC) sig_connected);
 336   signal_remove("server disconnected", (SIGNAL_FUNC) sig_disconnected);
 337   signal_remove("send text", (SIGNAL_FUNC) event_text);
 338   command_unbind("whois", (SIGNAL_FUNC) command_self);
 339   command_unbind("whowas", (SIGNAL_FUNC) command_self);
 340   command_unbind("nick", (SIGNAL_FUNC) command_self);
 341   command_unbind("topic", (SIGNAL_FUNC) command_self);
 342   command_unbind("cmode", (SIGNAL_FUNC) command_self);
 343   command_unbind("cumode", (SIGNAL_FUNC) command_self);
 344   command_unbind("users", (SIGNAL_FUNC) command_self);
 345   command_unbind("list", (SIGNAL_FUNC) command_self);
 346   command_unbind("silcoper", (SIGNAL_FUNC) command_self);
 347   command_unbind("umode", (SIGNAL_FUNC) command_self);
 348   command_unbind("invite", (SIGNAL_FUNC) command_self);
 349   command_unbind("kill", (SIGNAL_FUNC) command_self);
 350   command_unbind("kick", (SIGNAL_FUNC) command_self);
 351   command_unbind("info", (SIGNAL_FUNC) command_self);
 352   command_unbind("connect", (SIGNAL_FUNC) command_self);
 353   command_unbind("ping", (SIGNAL_FUNC) command_self);
 354   command_unbind("motd", (SIGNAL_FUNC) command_self);
 355   command_unbind("ban", (SIGNAL_FUNC) command_self);
 356   command_unbind("close", (SIGNAL_FUNC) command_self);
 357   command_unbind("shutdown", (SIGNAL_FUNC) command_self);
 358   command_unbind("getkey", (SIGNAL_FUNC) command_self);
 359 }