diff options
Diffstat (limited to 'plugins/perl/makefile-512.mak')
0 files changed, 0 insertions, 0 deletions
index : torxchat.git | ||
Unnamed repository; edit this file 'description' to name the repository. | blog |
summary refs log tree commit diff stats |
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
/* X-Chat
* Copyright (C) 1998 Peter Zelezny.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>
#ifdef WIN32
#include <io.h>
#else
#include <unistd.h>
#endif
#include "hexchat.h"
#include "notify.h"
#include "cfgfiles.h"
#include "fe.h"
#include "server.h"
#include "text.h"
#include "util.h"
#include "hexchatc.h"
GSList *notify_list = 0;
int notify_tag = 0;
static char *
despacify_dup (char *str)
{
char *p, *res = g_malloc (strlen (str) + 1);
p = res;
while (1)
{
if (*str != ' ')
{
*p = *str;
if (*p == 0)
return res;
p++;
}
str++;
}
}
static int
notify_netcmp (char *str, void *serv)
{
char *net = despacify_dup (server_get_network (serv, TRUE));
if (rfc_casecmp (str, net) == 0)
{
g_free (net);
return 0; /* finish & return FALSE from token_foreach() */
}
g_free (net);
return 1; /* keep going... */
}
/* monitor this nick on this particular network? */
static gboolean
notify_do_network (struct notify *notify, server *serv)
{
if (!notify->networks) /* ALL networks for this nick */
return TRUE;
if (token_foreach (notify->networks, ',', notify_netcmp, serv))
return FALSE; /* network list doesn't contain this one */
return TRUE;
}
struct notify_per_server *
notify_find_server_entry (struct notify *notify, struct server *serv)
{
GSList *list = notify->server_list;
struct notify_per_server *servnot;
while (list)
{
servnot = (struct notify_per_server *) list->data;
if (servnot->server == serv)
return servnot;
list = list->next;
}
/* not found, should we add it, or is this not a network where
we're monitoring this nick? */
if (!notify_do_network (notify, serv))
return NULL;
servnot = g_new0 (struct notify_per_server, 1);
servnot->server = serv;
servnot->notify = notify;
notify->server_list = g_slist_prepend (notify->server_list, servnot);
return servnot;
}
void
notify_save (void)
{
int fh;
struct notify *notify;
GSList *list = notify_list;
fh = hexchat_open_file ("notify.conf", O_TRUNC | O_WRONLY | O_CREAT, 0600, XOF_DOMODE);
if (fh != -1)
{
while (list)
{
notify = (struct notify *) list->data;
write (fh, notify->name, strlen (notify->name));
if (notify->networks)
{
write (fh, " ", 1);
write (fh, notify->networks, strlen (notify->networks));
}
write (fh, "\n", 1);
list = list->next;
}
close (fh);
}
}
void
notify_load (void)
{
int fh;
char buf[256];
char *sep;
fh = hexchat_open_file ("notify.conf", O_RDONLY, 0, 0);
if (fh != -1)
{
while (waitline (fh, buf, sizeof buf, FALSE) != -1)
{
if (buf[0] != '#' && buf[0] != 0)
{
sep = strchr (buf, ' ');
if (sep)
{
sep[0] = 0;
notify_adduser (buf, sep + 1);
}
else
notify_adduser (buf, NULL);
}
}
close (fh);
}
}
static struct notify_per_server *
notify_find (server *serv, char *nick)
{
GSList *list = notify_list;
struct notify_per_server *servnot;
struct notify *notify;
while (list)
{
notify = (struct notify *) list->data;
servnot = notify_find_server_entry (notify, serv);
if (!servnot)
{
list = list->next;
continue;
}
if (!serv->p_cmp (notify->name, nick))
return servnot;
list = list->next;
}
return NULL;
}
static void
notify_announce_offline (server * serv, struct notify_per_server *servnot,
char *nick, int quiet,
const message_tags_data *tags_data)
{
session *sess;
sess = serv->front_session;
servnot->ison = FALSE;
servnot->lastoff = time (0);
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_NOTIFYOFFLINE, sess, nick, serv->servername,
server_get_network (serv, TRUE), NULL, 0,
tags_data->timestamp);
fe_notify_update (nick);
fe_notify_update (0);
}
static void
notify_announce_online (server * serv, struct notify_per_server *servnot,
char *nick, const message_tags_data *tags_data)
{
session *sess;
sess = serv->front_session;
servnot->lastseen = time (0);
if (servnot->ison)
return;
servnot->ison = TRUE;
servnot->laston = time (0);
EMIT_SIGNAL_TIMESTAMP (XP_TE_NOTIFYONLINE, sess, nick, serv->servername,
server_get_network (serv, TRUE), NULL, 0,
tags_data->timestamp);
fe_notify_update (nick);
fe_notify_update (0);
if (prefs.hex_notify_whois_online)
{
/* Let's do whois with idle time (like in /quote WHOIS %s %s) */
char *wii_str = g_strdup_printf ("%s %s", nick, nick);
serv->p_whois (serv, wii_str);
g_free (wii_str);
}
}
/* handles numeric 601 */
void
notify_set_offline (server * serv, char *nick, int quiet,
const message_tags_data *tags_data)
{
struct notify_per_server *servnot;
servnot = notify_find (serv, nick);
if (!servnot)
return;
notify_announce_offline (serv, servnot, nick, quiet, tags_data);
}
/* handles numeric 604 and 600 */
void
notify_set_online (server * serv, char *nick,
const message_tags_data *tags_data)
{
struct notify_per_server *servnot;
servnot = notify_find (serv, nick);
if (!servnot)
return;
notify_announce_online (serv, servnot, nick, tags_data);
}
/* monitor can send lists for numeric 730/731 */
void
notify_set_offline_list (server * serv, char *users, int quiet,
const message_tags_data *tags_data)
{
struct notify_per_server *servnot;
char nick[NICKLEN];
char *token, *chr;
token = strtok (users, ",");
while (token != NULL)
{
chr = strchr (token, '!');
if (chr != NULL)
*chr = '\0';
g_strlcpy (nick, token, sizeof(nick));
servnot = notify_find (serv, nick);
if (servnot)
notify_announce_offline (serv, servnot, nick, quiet, tags_data);
token = strtok (NULL, ",");
}
}
void
notify_set_online_list (server * serv, char *users,
const message_tags_data *tags_data)
{
struct notify_per_server *servnot;
char nick[NICKLEN];
char *token, *chr;
token = strtok (users, ",");
while (token != NULL)
{
chr = strchr (token, '!');
if (chr != NULL)
*chr = '\0';
g_strlcpy (nick, token, sizeof(nick));
servnot = notify_find (serv, nick);
if (servnot)
notify_announce_online (serv, servnot, nick, tags_data);
token = strtok (NULL, ",");
}
}
static void
notify_watch (server * serv, char *nick, int add)
{
char tbuf[256];
char addchar = '+';
if (!add)
addchar = '-';
if (serv->supports_monitor)
g_snprintf (tbuf, sizeof (tbuf), "MONITOR %c %s", addchar, nick);
else if (serv->supports_watch)
g_snprintf (tbuf, sizeof (tbuf), "WATCH %c%s", addchar, nick);
else
return;
serv->p_raw (serv, tbuf);
}
static void
notify_watch_all (struct notify *notify, int add)
{
server *serv;
GSList *list = serv_list;
while (list)
{
serv = list->data;
if (serv->connected && serv->end_of_motd && notify_do_network (notify, serv))
notify_watch (serv, notify->name, add);
list = list->next;
}
}
static void
notify_flush_watches (server * serv, GSList *from, GSList *end)
{
char tbuf[512];
GSList *list;
struct notify *notify;
serv->supports_monitor ? strcpy (tbuf, "MONITOR + ") : strcpy (tbuf, "WATCH");
list = from;
while (list != end)
{
notify = list->data;
if (serv->supports_monitor)
g_strlcat (tbuf, ",", sizeof(tbuf));
else
g_strlcat (tbuf, " +", sizeof(tbuf));
g_strlcat (tbuf, notify->name, sizeof(tbuf));
list = list->next;
}
serv->p_raw (serv, tbuf);
}
/* called when logging in. e.g. when End of motd. */
void
notify_send_watches (server * serv)
{
struct notify *notify;
const int format_len = serv->supports_monitor ? 1 : 2; /* just , for monitor or + and space for watch */
GSList *list;
GSList *point;
GSList *send_list = NULL;
int len = 0;
/* Only get the list for this network */
list = notify_list;
while (list)
{
notify = list->data;
if (notify_do_network (notify, serv))
{
send_list = g_slist_append (send_list, notify);
}
list = list->next;
}
/* Now send that list in batches */
point = list = send_list;
while (list)
{
notify = list->data;
len += strlen (notify->name) + format_len;
if (len > 500)
{
/* Too long send existing list */
notify_flush_watches (serv, point, list);
len = strlen (notify->name) + format_len;
point = list; /* We left off here */
}
list = g_slist_next (list);
}
if (len) /* We had leftovers under 500, send them all */
{
notify_flush_watches (serv, point, NULL);
}
g_slist_free (send_list);
}
/* called when receiving a ISON 303 - should this func go? */
void
notify_markonline (server *serv, char *word[], const message_tags_data *tags_data)
{
struct notify *notify;
struct notify_per_server *servnot;
GSList *list = notify_list;
int i, seen;
while (list)
{
notify = (struct notify *) list->data;
servnot = notify_find_server_entry (notify, serv);
if (!servnot)
{
list = list->next;
continue;
}
i = 4;
seen = FALSE;
while (*word[i])
{
if (!serv->p_cmp (notify->name, word[i]))
{
seen = TRUE;
notify_announce_online (serv, servnot, notify->name, tags_data);
break;
}
i++;
/* FIXME: word[] is only a 32 element array, limits notify list to
about 27 people */
if (i > PDIWORDS - 5)
{
/*fprintf (stderr, _("*** HEXCHAT WARNING: notify list too large.\n"));*/
break;
}
}
if (!seen && servnot->ison)
{
notify_announce_offline (serv, servnot, notify->name, FALSE, tags_data);
}
list = list->next;
}
fe_notify_update (0);
}
/* yuck! Old routine for ISON notify */
static void
notify_checklist_for_server (server *serv)
{
char outbuf[512];
struct notify *notify;
GSList *list = notify_list;
int i = 0;
strcpy (outbuf, "ISON ");
while (list)
{
notify = list->data;
if (notify_do_network (notify, serv))
{
i++;
strcat (outbuf, notify->name);
strcat (outbuf, " ");
if (strlen (outbuf) > 460)
{
/* LAME: we can't send more than 512 bytes to the server, but *
* if we split it in two packets, our offline detection wouldn't *
work */
/*fprintf (stderr, _("*** HEXCHAT WARNING: notify list too large.\n"));*/
break;
}
}
list = list->next;
}
if (i)
serv->p_raw (serv, outbuf);
}
int
notify_checklist (void) /* check ISON list */
{
struct server *serv;
GSList *list = serv_list;
while (list)
{
serv = list->data;
if (serv->connected && serv->end_of_motd && !serv->supports_watch && !serv->supports_monitor)
{
notify_checklist_for_server (serv);
}
list = list->next;
}
return 1;
}
void
notify_showlist (struct session *sess, const message_tags_data *tags_data)
{
char outbuf[256];
struct notify *notify;
GSList *list = notify_list;
struct notify_per_server *servnot;
int i = 0;
EMIT_SIGNAL_TIMESTAMP (XP_TE_NOTIFYHEAD, sess, NULL, NULL, NULL, NULL, 0,
tags_data->timestamp);
while (list)
{
i++;
notify = (struct notify *) list->data;
servnot = notify_find_server_entry (notify, sess->server);
if (servnot && servnot->ison)
g_snprintf (outbuf, sizeof (outbuf), _(" %-20s online\n"), notify->name);
else
g_snprintf (outbuf, sizeof (outbuf), _(" %-20s offline\n"), notify->name);
PrintTextTimeStamp (sess, outbuf, tags_data->timestamp);
list = list->next;
}
if (i)
{
sprintf (outbuf, "%d", i);
EMIT_SIGNAL_TIMESTAMP (XP_TE_NOTIFYNUMBER, sess, outbuf, NULL, NULL, NULL,
0, tags_data->timestamp);
} else
EMIT_SIGNAL_TIMESTAMP (XP_TE_NOTIFYEMPTY, sess, NULL, NULL, NULL, NULL, 0,
tags_data->timestamp);
}
int
notify_deluser (char *name)
{
struct notify *notify;
struct notify_per_server *servnot;
GSList *list = notify_list;
while (list)
{
notify = (struct notify *) list->data;
if (!rfc_casecmp (notify->name, name))
{
fe_notify_update (notify->name);
/* Remove the records for each server */
while (notify->server_list)
{
servnot = (struct notify_per_server *) notify->server_list->data;
notify->server_list =
g_slist_remove (notify->server_list, servnot);
g_free (servnot);
}
notify_list = g_slist_remove (notify_list, notify);
notify_watch_all (notify, FALSE);
g_free (notify->networks);
g_free (notify->name);
g_free (notify);
fe_notify_update (0);
return 1;
}
list = list->next;
}
return 0;
}
void
notify_adduser (char *name, char *networks)
{
struct notify *notify = g_new0 (struct notify, 1);
notify->name = g_strndup (name, NICKLEN - 1);
if (networks != NULL)
notify->networks = despacify_dup (networks);
notify->server_list = 0;
notify_list = g_slist_prepend (notify_list, notify);
notify_checklist ();
fe_notify_update (notify->name);
fe_notify_update (0);
notify_watch_all (notify, TRUE);
}
gboolean
notify_is_in_list (server *serv, char *name)
{
struct notify *notify;
GSList *list = notify_list;
while (list)
{
notify = (struct notify *) list->data;
if (!serv->p_cmp (notify->name, name))
return TRUE;
list = list->next;
}
return FALSE;
}
int
notify_isnotify (struct session *sess, char *name)
{
struct notify *notify;
struct notify_per_server *servnot;
GSList *list = notify_list;
while (list)
{
notify = (struct notify *) list->data;
if (!sess->server->p_cmp (notify->name, name))
{
servnot = notify_find_server_entry (notify, sess->server);
if (servnot && servnot->ison)
return TRUE;
}
list = list->next;
}
return FALSE;
}
void
notify_cleanup ()
{
GSList *list = notify_list;
GSList *nslist, *srvlist;
struct notify *notify;
struct notify_per_server *servnot;
struct server *serv;
int valid;
while (list)
{
/* Traverse the list of notify structures */
notify = (struct notify *) list->data;
nslist = notify->server_list;
while (nslist)
{
/* Look at each per-server structure */
servnot = (struct notify_per_server *) nslist->data;
/* Check the server is valid */
valid = FALSE;
srvlist = serv_list;
while (srvlist)
{
serv = (struct server *) srvlist->data;
if (servnot->server == serv)
{
valid = serv->connected; /* Only valid if server is too */
break;
}
srvlist = srvlist->next;
}
if (!valid)
{
notify->server_list =
g_slist_remove (notify->server_list, servnot);
g_free (servnot);
nslist = notify->server_list;
} else
{
nslist = nslist->next;
}
}
list = list->next;
}
fe_notify_update (0);
}