src/common/notify.c

   1 /* X-Chat
   2  * Copyright (C) 1998 Peter Zelezny.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  17  */
  18
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <stdlib.h>
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <fcntl.h>
  25 #include <unistd.h>
  26 #include <time.h>
  27
  28 #include "xchat.h"
  29 #include "notify.h"
  30 #include "cfgfiles.h"
  31 #include "fe.h"
  32 #include "server.h"
  33 #include "text.h"
  34 #include "util.h"
  35 #include "xchatc.h"
  36
  37
  38 GSList *notify_list = 0;
  39 int notify_tag = 0;
  40
  41
  42 static char *
  43 despacify_dup (char *str)
  44 {
  45         char *p, *res = malloc (strlen (str) + 1);
  46
  47         p = res;
  48         while (1)
  49         {
  50                 if (*str != ' ')
  51                 {
  52                         *p = *str;
  53                         if (*p == 0)
  54                                 return res;
  55                         p++;
  56                 }
  57                 str++;
  58         }
  59 }
  60
  61 static int
  62 notify_netcmp (char *str, void *serv)
  63 {
  64         char *net = despacify_dup (server_get_network (serv, TRUE));
  65
  66         if (rfc_casecmp (str, net) == 0)
  67         {
  68                 free (net);
  69                 return 0;       /* finish & return FALSE from token_foreach() */
  70         }
  71
  72         free (net);
  73         return 1;       /* keep going... */
  74 }
  75
  76 /* monitor this nick on this particular network? */
  77
  78 static gboolean
  79 notify_do_network (struct notify *notify, server *serv)
  80 {
  81         if (!notify->networks)  /* ALL networks for this nick */
  82                 return TRUE;
  83
  84         if (token_foreach (notify->networks, ',', notify_netcmp, serv))
  85                 return FALSE;   /* network list doesn't contain this one */
  86
  87         return TRUE;
  88 }
  89
  90 struct notify_per_server *
  91 notify_find_server_entry (struct notify *notify, struct server *serv)
  92 {
  93         GSList *list = notify->server_list;
  94         struct notify_per_server *servnot;
  95
  96         while (list)
  97         {
  98                 servnot = (struct notify_per_server *) list->data;
  99                 if (servnot->server == serv)
 100                         return servnot;
 101                 list = list->next;
 102         }
 103
 104         /* not found, should we add it, or is this not a network where
 105       we're monitoring this nick? */
 106         if (!notify_do_network (notify, serv))
 107                 return NULL;
 108
 109         servnot = malloc (sizeof (struct notify_per_server));
 110         if (servnot)
 111         {
 112                 memset (servnot, 0, sizeof (struct notify_per_server));
 113                 servnot->server = serv;
 114                 servnot->notify = notify;
 115                 notify->server_list = g_slist_prepend (notify->server_list, servnot);
 116         }
 117         return servnot;
 118 }
 119
 120 void
 121 notify_save (void)
 122 {
 123         int fh;
 124         struct notify *notify;
 125         GSList *list = notify_list;
 126
 127         fh = xchat_open_file ("notify.conf", O_TRUNC | O_WRONLY | O_CREAT, 0600, XOF_DOMODE);
 128         if (fh != -1)
 129         {
 130                 while (list)
 131                 {
 132                         notify = (struct notify *) list->data;
 133                         write (fh, notify->name, strlen (notify->name));
 134                         if (notify->networks)
 135                         {
 136                                 write (fh, " ", 1);
 137                                 write (fh, notify->networks, strlen (notify->networks));
 138                         }
 139                         write (fh, "\n", 1);
 140                         list = list->next;
 141                 }
 142                 close (fh);
 143         }
 144 }
 145
 146 void
 147 notify_load (void)
 148 {
 149         int fh;
 150         char buf[256];
 151         char *sep;
 152
 153         fh = xchat_open_file ("notify.conf", O_RDONLY, 0, 0);
 154         if (fh != -1)
 155         {
 156                 while (waitline (fh, buf, sizeof buf, FALSE) != -1)
 157                 {
 158                         if (buf[0] != '#' && buf[0] != 0)
 159                         {
 160                                 sep = strchr (buf, ' ');
 161                                 if (sep)
 162                                 {
 163                                         sep[0] = 0;
 164                                         notify_adduser (buf, sep + 1);
 165                                 }
 166                                 else
 167                                         notify_adduser (buf, NULL);
 168                         }
 169                 }
 170                 close (fh);
 171         }
 172 }
 173
 174 static struct notify_per_server *
 175 notify_find (server *serv, char *nick)
 176 {
 177         GSList *list = notify_list;
 178         struct notify_per_server *servnot;
 179         struct notify *notify;
 180
 181         while (list)
 182         {
 183                 notify = (struct notify *) list->data;
 184
 185                 servnot = notify_find_server_entry (notify, serv);
 186                 if (!servnot)
 187                 {
 188                         list = list->next;
 189                         continue;
 190                 }
 191
 192                 if (!serv->p_cmp (notify->name, nick))
 193                         return servnot;
 194
 195                 list = list->next;
 196         }
 197
 198         return 0;
 199 }
 200
 201 static void
 202 notify_announce_offline (server * serv, struct notify_per_server *servnot,
 203                                                                 char *nick, int quiet)
 204 {
 205         session *sess;
 206
 207         sess = serv->front_session;
 208
 209         servnot->ison = FALSE;
 210         servnot->lastoff = time (0);
 211         if (!quiet)
 212                 EMIT_SIGNAL (XP_TE_NOTIFYOFFLINE, sess, nick, serv->servername,
 213                                                  server_get_network (serv, TRUE), NULL, 0);
 214         fe_notify_update (nick);
 215         fe_notify_update (0);
 216 }
 217
 218 static void
 219 notify_announce_online (server * serv, struct notify_per_server *servnot,
 220                                                                 char *nick)
 221 {
 222         session *sess;
 223
 224         sess = serv->front_session;
 225
 226         servnot->lastseen = time (0);
 227         if (servnot->ison)
 228                 return;
 229
 230         servnot->ison = TRUE;
 231         servnot->laston = time (0);
 232         EMIT_SIGNAL (XP_TE_NOTIFYONLINE, sess, nick, serv->servername,
 233                                          server_get_network (serv, TRUE), NULL, 0);
 234         fe_notify_update (nick);
 235         fe_notify_update (0);
 236
 237         if (prefs.whois_on_notifyonline)
 238         {
 239
 240             /* Let's do whois with idle time (like in /quote WHOIS %s %s) */
 241
 242             char *wii_str = malloc (strlen (nick) * 2 + 2);
 243             sprintf (wii_str, "%s %s", nick, nick);
 244             serv->p_whois (serv, wii_str);
 245             free (wii_str);
 246         }
 247 }
 248
 249 /* handles numeric 601 */
 250
 251 void
 252 notify_set_offline (server * serv, char *nick, int quiet)
 253 {
 254         struct notify_per_server *servnot;
 255
 256         servnot = notify_find (serv, nick);
 257         if (!servnot)
 258                 return;
 259
 260         notify_announce_offline (serv, servnot, nick, quiet);
 261 }
 262
 263 /* handles numeric 604 and 600 */
 264
 265 void
 266 notify_set_online (server * serv, char *nick)
 267 {
 268         struct notify_per_server *servnot;
 269
 270         servnot = notify_find (serv, nick);
 271         if (!servnot)
 272                 return;
 273
 274         notify_announce_online (serv, servnot, nick);
 275 }
 276
 277 static void
 278 notify_watch (server * serv, char *nick, int add)
 279 {
 280         char tbuf[256];
 281
 282         snprintf (tbuf, sizeof (tbuf), "WATCH +%s", nick);
 283         if (!add)
 284                 tbuf[6] = '-';
 285         serv->p_raw (serv, tbuf);
 286 }
 287
 288 static void
 289 notify_watch_all (struct notify *notify, int add)
 290 {
 291         server *serv;
 292         GSList *list = serv_list;
 293         while (list)
 294         {
 295                 serv = list->data;
 296                 if (serv->connected && serv->end_of_motd && serv->supports_watch &&
 297                          notify_do_network (notify, serv))
 298                         notify_watch (serv, notify->name, add);
 299                 list = list->next;
 300         }
 301 }
 302
 303 static void
 304 notify_flush_watches (server * serv, GSList *from, GSList *end)
 305 {
 306         char tbuf[512];
 307         GSList *list;
 308         struct notify *notify;
 309
 310         strcpy (tbuf, "WATCH");
 311
 312         list = from;
 313         while (list != end)
 314         {
 315                 notify = list->data;
 316                 strcat (tbuf, " +");
 317                 strcat (tbuf, notify->name);
 318                 list = list->next;
 319         }
 320         serv->p_raw (serv, tbuf);
 321 }
 322
 323 /* called when logging in. e.g. when End of motd. */
 324
 325 void
 326 notify_send_watches (server * serv)
 327 {
 328         struct notify *notify;
 329         GSList *list;
 330         GSList *point;
 331         int len;
 332
 333         len = 0;
 334         point = list = notify_list;
 335         while (list)
 336         {
 337                 notify = list->data;
 338
 339                 if (notify_do_network (notify, serv))
 340                 {
 341                         len += strlen (notify->name) + 2 /* + and space */;
 342                         if (len > 500)
 343                         {
 344                                 notify_flush_watches (serv, point, list);
 345                                 len = strlen (notify->name) + 2;
 346                                 point = list;
 347                         }
 348                 }
 349
 350                 list = list->next;
 351         }
 352
 353         if (point)
 354                 notify_flush_watches (serv, point, NULL);
 355 }
 356
 357 /* called when receiving a ISON 303 - should this func go? */
 358
 359 void
 360 notify_markonline (server *serv, char *word[])
 361 {
 362         struct notify *notify;
 363         struct notify_per_server *servnot;
 364         GSList *list = notify_list;
 365         int i, seen;
 366
 367         while (list)
 368         {
 369                 notify = (struct notify *) list->data;
 370                 servnot = notify_find_server_entry (notify, serv);
 371                 if (!servnot)
 372                 {
 373                         list = list->next;
 374                         continue;
 375                 }
 376                 i = 4;
 377                 seen = FALSE;
 378                 while (*word[i])
 379                 {
 380                         if (!serv->p_cmp (notify->name, word[i]))
 381                         {
 382                                 seen = TRUE;
 383                                 notify_announce_online (serv, servnot, notify->name);
 384                                 break;
 385                         }
 386                         i++;
 387                         /* FIXME: word[] is only a 32 element array, limits notify list to
 388                            about 27 people */
 389                         if (i > PDIWORDS - 5)
 390                         {
 391                                 /*fprintf (stderr, _("*** XCHAT WARNING: notify list too large.\n"));*/
 392                                 break;
 393                         }
 394                 }
 395                 if (!seen && servnot->ison)
 396                 {
 397                         notify_announce_offline (serv, servnot, notify->name, FALSE);
 398                 }
 399                 list = list->next;
 400         }
 401         fe_notify_update (0);
 402 }
 403
 404 /* yuck! Old routine for ISON notify */
 405
 406 static void
 407 notify_checklist_for_server (server *serv)
 408 {
 409         char outbuf[512];
 410         struct notify *notify;
 411         GSList *list = notify_list;
 412         int i = 0;
 413
 414         strcpy (outbuf, "ISON ");
 415         while (list)
 416         {
 417                 notify = list->data;
 418                 if (notify_do_network (notify, serv))
 419                 {
 420                         i++;
 421                         strcat (outbuf, notify->name);
 422                         strcat (outbuf, " ");
 423                         if (strlen (outbuf) > 460)
 424                         {
 425                                 /* LAME: we can't send more than 512 bytes to the server, but     *
 426                                  * if we split it in two packets, our offline detection wouldn't  *
 427                                  work                                                           */
 428                                 /*fprintf (stderr, _("*** XCHAT WARNING: notify list too large.\n"));*/
 429                                 break;
 430                         }
 431                 }
 432                 list = list->next;
 433         }
 434
 435         if (i)
 436                 serv->p_raw (serv, outbuf);
 437 }
 438
 439 int
 440 notify_checklist (void) /* check ISON list */
 441 {
 442         struct server *serv;
 443         GSList *list = serv_list;
 444
 445         while (list)
 446         {
 447                 serv = list->data;
 448                 if (serv->connected && serv->end_of_motd && !serv->supports_watch)
 449                 {
 450                         notify_checklist_for_server (serv);
 451                 }
 452                 list = list->next;
 453         }
 454         return 1;
 455 }
 456
 457 void
 458 notify_showlist (struct session *sess)
 459 {
 460         char outbuf[256];
 461         struct notify *notify;
 462         GSList *list = notify_list;
 463         struct notify_per_server *servnot;
 464         int i = 0;
 465
 466         EMIT_SIGNAL (XP_TE_NOTIFYHEAD, sess, NULL, NULL, NULL, NULL, 0);
 467         while (list)
 468         {
 469                 i++;
 470                 notify = (struct notify *) list->data;
 471                 servnot = notify_find_server_entry (notify, sess->server);
 472                 if (servnot && servnot->ison)
 473                         snprintf (outbuf, sizeof (outbuf), _("  %-20s online\n"), notify->name);
 474                 else
 475                         snprintf (outbuf, sizeof (outbuf), _("  %-20s offline\n"), notify->name);
 476                 PrintText (sess, outbuf);
 477                 list = list->next;
 478         }
 479         if (i)
 480         {
 481                 sprintf (outbuf, "%d", i);
 482                 EMIT_SIGNAL (XP_TE_NOTIFYNUMBER, sess, outbuf, NULL, NULL, NULL, 0);
 483         } else
 484                 EMIT_SIGNAL (XP_TE_NOTIFYEMPTY, sess, NULL, NULL, NULL, NULL, 0);
 485 }
 486
 487 int
 488 notify_deluser (char *name)
 489 {
 490         struct notify *notify;
 491         struct notify_per_server *servnot;
 492         GSList *list = notify_list;
 493
 494         while (list)
 495         {
 496                 notify = (struct notify *) list->data;
 497                 if (!rfc_casecmp (notify->name, name))
 498                 {
 499                         fe_notify_update (notify->name);
 500                         /* Remove the records for each server */
 501                         while (notify->server_list)
 502                         {
 503                                 servnot = (struct notify_per_server *) notify->server_list->data;
 504                                 notify->server_list =
 505                                         g_slist_remove (notify->server_list, servnot);
 506                                 free (servnot);
 507                         }
 508                         notify_list = g_slist_remove (notify_list, notify);
 509                         notify_watch_all (notify, FALSE);
 510                         if (notify->networks)
 511                                 free (notify->networks);
 512                         free (notify->name);
 513                         free (notify);
 514                         fe_notify_update (0);
 515                         return 1;
 516                 }
 517                 list = list->next;
 518         }
 519         return 0;
 520 }
 521
 522 void
 523 notify_adduser (char *name, char *networks)
 524 {
 525         struct notify *notify = malloc (sizeof (struct notify));
 526         if (notify)
 527         {
 528                 memset (notify, 0, sizeof (struct notify));
 529                 if (strlen (name) >= NICKLEN)
 530                 {
 531                         notify->name = malloc (NICKLEN);
 532                         safe_strcpy (notify->name, name, NICKLEN);
 533                 } else
 534                 {
 535                         notify->name = strdup (name);
 536                 }
 537                 if (networks)
 538                         notify->networks = despacify_dup (networks);
 539                 notify->server_list = 0;
 540                 notify_list = g_slist_prepend (notify_list, notify);
 541                 notify_checklist ();
 542                 fe_notify_update (notify->name);
 543                 fe_notify_update (0);
 544                 notify_watch_all (notify, TRUE);
 545         }
 546 }
 547
 548 gboolean
 549 notify_is_in_list (server *serv, char *name)
 550 {
 551         struct notify *notify;
 552         GSList *list = notify_list;
 553
 554         while (list)
 555         {
 556                 notify = (struct notify *) list->data;
 557                 if (!serv->p_cmp (notify->name, name))
 558                         return TRUE;
 559                 list = list->next;
 560         }
 561
 562         return FALSE;
 563 }
 564
 565 int
 566 notify_isnotify (struct session *sess, char *name)
 567 {
 568         struct notify *notify;
 569         struct notify_per_server *servnot;
 570         GSList *list = notify_list;
 571
 572         while (list)
 573         {
 574                 notify = (struct notify *) list->data;
 575                 if (!sess->server->p_cmp (notify->name, name))
 576                 {
 577                         servnot = notify_find_server_entry (notify, sess->server);
 578                         if (servnot && servnot->ison)
 579                                 return TRUE;
 580                 }
 581                 list = list->next;
 582         }
 583
 584         return FALSE;
 585 }
 586
 587 void
 588 notify_cleanup ()
 589 {
 590         GSList *list = notify_list;
 591         GSList *nslist, *srvlist;
 592         struct notify *notify;
 593         struct notify_per_server *servnot;
 594         struct server *serv;
 595         int valid;
 596
 597         while (list)
 598         {
 599                 /* Traverse the list of notify structures */
 600                 notify = (struct notify *) list->data;
 601                 nslist = notify->server_list;
 602                 while (nslist)
 603                 {
 604                         /* Look at each per-server structure */
 605                         servnot = (struct notify_per_server *) nslist->data;
 606
 607                         /* Check the server is valid */
 608                         valid = FALSE;
 609                         srvlist = serv_list;
 610                         while (srvlist)
 611                         {
 612                                 serv = (struct server *) srvlist->data;
 613                                 if (servnot->server == serv)
 614                                 {
 615                                         valid = serv->connected;        /* Only valid if server is too */
 616                                         break;
 617                                 }
 618                                 srvlist = srvlist->next;
 619                         }
 620                         if (!valid)
 621                         {
 622                                 notify->server_list =
 623                                         g_slist_remove (notify->server_list, servnot);
 624                                 free (servnot);
 625                                 nslist = notify->server_list;
 626                         } else
 627                         {
 628                                 nslist = nslist->next;
 629                         }
 630                 }
 631                 list = list->next;
 632         }
 633         fe_notify_update (0);
 634 }