/*
* ignore.c: handles the ingore command for irc
*
* Written By Michael Sandrof
*
* Copyright (c) 1990 Michael Sandrof.
* Copyright (c) 1991, 1992 Troy Rollo.
* Copyright (c) 1992-2003 Matthew R. Green.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: ignore.c,v 1.17 2005/12/22 16:53:25 f Exp $
*/
#include "irc.h"
#include "ignore.h"
#include "ircaux.h"
#include "list.h"
#include "vars.h"
#include "output.h"
/**************************** PATCHED by Flier *****************************/
#include "parse.h"
#include "myvars.h"
extern int matchmcommand _((char *, int));
/***************************************************************************/
/**************************** Patched by Flier ******************************/
/*#define NUMBER_OF_IGNORE_LEVELS 9*/
#define NUMBER_OF_IGNORE_LEVELS 11
/****************************************************************************/
#define IGNORE_REMOVE 1
#define IGNORE_DONT 2
#define IGNORE_HIGH -1
int ignore_usernames = 0;
char highlight_char = '\0';
static int ignore_usernames_sums[NUMBER_OF_IGNORE_LEVELS] =
/**************************** Patched by Flier ******************************/
/*{ 0, 0, 0, 0, 0, 0, 0, 0, 0 };*/
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
/****************************************************************************/
/**************************** PATCHED by Flier ******************************/
/*static int remove_ignore _((char *));*/
static void remove_ignore _((char *));
/****************************************************************************/
static void ignore_list _((char *));
static int ignore_usernames_mask _((int, int));
/**************************** PATCHED by Flier ******************************/
/*static void ignore_nickname _((char *, int, int));*/
static void ignore_nickname _((char *, int, int, char *));
/****************************************************************************/
/*
* Ignore: the ignore list structure, consists of the nickname, and the type
* of ignorance which is to take place
*/
typedef struct IgnoreStru
{
struct IgnoreStru *next;
char *nick;
int type;
int dont;
int high;
/**************************** Patched by Flier ******************************/
int perm;
/****************************************************************************/
} Ignore;
/* ignored_nicks: pointer to the head of the ignore list */
static Ignore *ignored_nicks = NULL;
static int
ignore_usernames_mask(mask, thing)
int mask;
int thing;
{
int i;
int p;
for (i = 0, p = 1; i < NUMBER_OF_IGNORE_LEVELS; i++, p *= 2)
if (mask & p)
ignore_usernames_sums[i] += thing;
mask = 0;
for (i = 0, p = 1; i < NUMBER_OF_IGNORE_LEVELS; i++, p *= 2)
if (ignore_usernames_sums[i])
mask += p;
return (mask);
}
/*
* ignore_nickname: adds nick to the ignore list, using type as the type of
* ignorance to take place.
*/
static void
/**************************** PATCHED by Flier *****************************/
/*ignore_nickname(nick, type, flag)
char *nick;
int type;
int flag;*/
ignore_nickname(nick, type, flag, timedignore)
char *nick;
int type;
int flag;
char *timedignore;
/***************************************************************************/
{
Ignore *new;
char *msg,
*ptr;
char buffer[BIG_BUFFER_SIZE+1];
while (nick)
{
if ((ptr = index(nick, ',')) != NULL)
*ptr = '\0';
if (index(nick, '@'))
ignore_usernames = ignore_usernames_mask(type, 1);
if (*nick)
{
if (!(new = (Ignore *) list_lookup((List **) &ignored_nicks, nick, !USE_WILDCARDS, !REMOVE_FROM_LIST)))
{
if (flag == IGNORE_REMOVE)
{
say("%s is not on the ignorance list",
nick);
if (ptr)
*(ptr++) = ',';
nick = ptr;
continue;
}
else
{
if ((new = (Ignore *) remove_from_list((List **) &ignored_nicks, nick)) != NULL)
{
new_free(&(new->nick));
new_free(&new);
}
new = (Ignore *)
new_malloc(sizeof(Ignore));
new->nick = (char *) 0;
new->type = 0;
new->dont = 0;
new->high = 0;
malloc_strcpy(&(new->nick), nick);
/**************************** PATCHED by Flier ******************************/
/*upper(new->nick);*/
new->perm = timedignore ? 0 : 1;
/****************************************************************************/
add_to_list((List **) &ignored_nicks, (List *) new);
}
}
switch (flag)
{
case IGNORE_REMOVE:
new->type &= (~type);
new->high &= (~type);
new->dont &= (~type);
msg = "Not ignoring";
break;
case IGNORE_DONT:
new->dont |= type;
new->type &= (~type);
new->high &= (~type);
msg = "Never ignoring";
break;
case IGNORE_HIGH:
new->high |= type;
new->type &= (~type);
new->dont &= (~type);
msg = "Highlighting";
break;
default:
new->type |= type;
new->high &= (~type);
new->dont &= (~type);
msg = "Ignoring";
break;
}
if (type == IGNORE_ALL)
{
switch (flag)
{
case IGNORE_REMOVE:
say("%s removed from ignorance list", new->nick);
remove_ignore(new->nick);
break;
case IGNORE_HIGH:
say("Highlighting ALL messages from %s",
new->nick);
break;
case IGNORE_DONT:
say("Never ignoring messages from %s",
new->nick);
break;
default:
/**************************** PATCHED by Flier *******************************/
/*say("Ignoring ALL messages from %s",
new->nick);*/
if (timedignore)
say("Ignoring ALL messages from %s for %s seconds",
new->nick, timedignore);
else say("Ignoring ALL messages from %s", new->nick);
/*****************************************************************************/
break;
}
return;
}
else if (type)
{
/**************************** PATCHED by Flier ******************************/
/*strcpy(buffer, msg);
if (type & IGNORE_MSGS)
strcat(buffer, " MSGS");
if (type & IGNORE_PUBLIC)
strcat(buffer, " PUBLIC");
if (type & IGNORE_WALLS)
strcat(buffer, " WALLS");
if (type & IGNORE_WALLOPS)
strcat(buffer, " WALLOPS");
if (type & IGNORE_INVITES)
strcat(buffer, " INVITES");
if (type & IGNORE_NOTICES)
strcat(buffer, " NOTICES");
if (type & IGNORE_NOTES)
strcat(buffer, " NOTES");
if (type & IGNORE_CTCPS)
strcat(buffer, " CTCPS");
if (type & IGNORE_CRAP)
strcat(buffer, " CRAP");
say("%s from %s", buffer, new->nick);*/
strmcpy(buffer, msg, sizeof(buffer));
if (type & IGNORE_MSGS)
strmcat(buffer, " MSGS", sizeof(buffer));
if (type & IGNORE_PUBLIC)
strmcat(buffer, " PUBLIC", sizeof(buffer));
if (type & IGNORE_WALLS)
strmcat(buffer, " WALLS", sizeof(buffer));
if (type & IGNORE_WALLOPS)
strmcat(buffer, " WALLOPS", sizeof(buffer));
if (type & IGNORE_INVITES)
strmcat(buffer, " INVITES", sizeof(buffer));
if (type & IGNORE_NOTICES)
strmcat(buffer, " NOTICES", sizeof(buffer));
if (type & IGNORE_NOTES)
strmcat(buffer, " NOTES", sizeof(buffer));
if (type & IGNORE_CTCPS)
strmcat(buffer, " CTCPS", sizeof(buffer));
if (type & IGNORE_CRAP)
strmcat(buffer, " CRAP", sizeof(buffer));
if (type & IGNORE_PART)
strmcat(buffer, " PART", sizeof(buffer));
if (type & IGNORE_JOIN)
strmcat(buffer, " JOIN", sizeof(buffer));
if (timedignore) say("%s from %s for %s seconds", buffer, new->nick, timedignore);
else say("%s from %s", buffer, new->nick);
/****************************************************************************/
}
if ((new->type == 0) && (new->high == 0))
remove_ignore(new->nick);
}
if (ptr)
*(ptr++) = ',';
nick = ptr;
}
}
/*
* remove_ignore: removes the given nick from the ignore list and returns 0.
* If the nick wasn't in the ignore list to begin with, 1 is returned.
*/
/**************************** PATCHED by Flier ******************************/
/*static int*/
static void
/****************************************************************************/
remove_ignore(nick)
char *nick;
{
Ignore *tmp;
/**************************** PATCHED by Flier ******************************/
int i;
int notfound=1;
Ignore *last=NULL;
Ignore *remove;
/*if ((tmp = (Ignore *) list_lookup((List **) &ignored_nicks, nick, !USE_WILDCARDS, REMOVE_FROM_LIST)) != NULL)
{
if (index(nick, '@'))
ignore_usernames = ignore_usernames_mask(tmp->type, -1);
new_free(&(tmp->nick));
new_free(&tmp);
return (0);
}
return (1);*/
for (i = 1, tmp = ignored_nicks; tmp; i++) {
if ((*nick == '#' && matchmcommand(nick, i)) || wild_match(nick, tmp->nick)) {
remove = tmp;
if (last) last->next = tmp->next;
else ignored_nicks = tmp->next;
tmp = tmp->next;
say("%s removed from ignore list", remove->nick);
new_free(&(remove->nick));
new_free(&remove);
notfound = 0;
}
else {
last = tmp;
tmp = tmp->next;
}
}
if (notfound) say("No match found for %s in ignore list", nick);
/****************************************************************************/
}
/*
* is_ignored: checks to see if nick is being ignored (poor nick). Checks
* against type to see if ignorance is to take place. If nick is marked as
* IGNORE_ALL or ignorace types match, 1 is returned, otherwise 0 is
* returned.
*/
int
is_ignored(nick, type)
char *nick;
int type;
{
Ignore *tmp;
/**************************** PATCHED by Flier ******************************/
if (nick == NULL) return 0;
/****************************************************************************/
if (ignored_nicks)
{
if ((tmp = (Ignore *) list_lookup((List **) &ignored_nicks, nick, USE_WILDCARDS, !REMOVE_FROM_LIST)) != NULL)
{
if (tmp->dont & type)
return (DONT_IGNORE);
if (tmp->type & type)
return (IGNORED);
if (tmp->high & type)
return (HIGHLIGHTED);
}
}
return (0);
}
/* ignore_list: shows the entired ignorance list */
static void
ignore_list(nick)
char *nick;
{
Ignore *tmp;
size_t len = 0;
char buffer[BIG_BUFFER_SIZE+1];
/**************************** PATCHED by Flier ******************************/
int i;
/****************************************************************************/
if (ignored_nicks)
{
say("Ignorance List:");
/**************************** PATCHED by Flier ******************************/
/*if (nick)
{
len = strlen(nick);
upper(nick);
}
for (tmp = ignored_nicks; tmp; tmp = tmp->next)*/
if (nick) len = strlen(nick);
for (i = 1, tmp = ignored_nicks; tmp; i++, tmp = tmp->next)
/****************************************************************************/
{
char s[BIG_BUFFER_SIZE+1];
if (nick)
{
/**************************** Patched by Flier ******************************/
/*if (strncmp(nick, tmp->nick, len))*/
if (my_strnicmp(nick, tmp->nick, len))
/****************************************************************************/
continue;
}
*buffer = (char) 0;
if (tmp->type == IGNORE_ALL)
strmcat(buffer," ALL",BIG_BUFFER_SIZE);
else if (tmp->high == IGNORE_ALL)
{
snprintf(s, sizeof s, " %cALL%c", highlight_char,
highlight_char);
strmcat(buffer, s, BIG_BUFFER_SIZE);
}
else if (tmp->dont == IGNORE_ALL)
strmcat(buffer," DONT-ALL", BIG_BUFFER_SIZE);
else
{
if (tmp->type & IGNORE_PUBLIC)
strmcat(buffer, " PUBLIC",
BIG_BUFFER_SIZE);
else if (tmp->high & IGNORE_PUBLIC)
{
snprintf(s, sizeof s, " %cPUBLIC%c",
highlight_char, highlight_char);
strmcat(buffer, s, BIG_BUFFER_SIZE);
}
else if (tmp->dont & IGNORE_PUBLIC)
strmcat(buffer, " DONT-PUBLIC",
BIG_BUFFER_SIZE);
if (tmp->type & IGNORE_MSGS)
strmcat(buffer, " MSGS",
BIG_BUFFER_SIZE);
else if (tmp->high & IGNORE_MSGS)
{
snprintf(s, sizeof s, " %cMSGS%c",
highlight_char, highlight_char);
strmcat(buffer, s, BIG_BUFFER_SIZE);
}
else if (tmp->dont & IGNORE_MSGS)
strmcat(buffer, " DONT-MSGS",
BIG_BUFFER_SIZE);
if (tmp->type & IGNORE_WALLS)
strmcat(buffer, " WALLS",
BIG_BUFFER_SIZE);
else if (tmp->high & IGNORE_WALLS)
{
snprintf(s, sizeof s, " %cWALLS%c",
highlight_char, highlight_char);
strmcat(buffer, s, BIG_BUFFER_SIZE);
}
else if (tmp->dont & IGNORE_WALLS)
strmcat(buffer, " DONT-WALLS",
BIG_BUFFER_SIZE);
if (tmp->type & IGNORE_WALLOPS)
strmcat(buffer, " WALLOPS",
BIG_BUFFER_SIZE);
else if (tmp->high & IGNORE_WALLOPS)
{
snprintf(s, sizeof s, " %cWALLOPS%c",
highlight_char, highlight_char);
strmcat(buffer, s, BIG_BUFFER_SIZE);
}
else if (tmp->dont & IGNORE_WALLOPS)
strmcat(buffer, " DONT-WALLOPS",
BIG_BUFFER_SIZE);
if (tmp->type & IGNORE_INVITES)
strmcat(buffer, " INVITES",
BIG_BUFFER_SIZE);
else if (tmp->high & IGNORE_INVITES)
{
snprintf(s, sizeof s, " %cINVITES%c",
highlight_char, highlight_char);
strmcat(buffer, s, BIG_BUFFER_SIZE);
}
else if (tmp->dont & IGNORE_INVITES)
strmcat(buffer, " DONT-INVITES",
BIG_BUFFER_SIZE);
if (tmp->type & IGNORE_NOTICES)
strmcat(buffer, " NOTICES",
BIG_BUFFER_SIZE);
else if (tmp->high & IGNORE_NOTICES)
{
snprintf(s, sizeof s, " %cNOTICES%c",
highlight_char, highlight_char);
strmcat(buffer, s, BIG_BUFFER_SIZE);
}
else if (tmp->dont & IGNORE_NOTICES)
strmcat(buffer, " DONT-NOTICES",
BIG_BUFFER_SIZE);
if (tmp->type & IGNORE_NOTES)
strmcat(buffer, " NOTES",
BIG_BUFFER_SIZE);
else if (tmp->high & IGNORE_NOTES)
{
snprintf(s, sizeof s, " %cNOTES%c",
highlight_char, highlight_char);
strmcat(buffer, s, BIG_BUFFER_SIZE);
}
else if (tmp->dont & IGNORE_NOTES)
strmcat(buffer, " DONT-NOTES",
BIG_BUFFER_SIZE);
if (tmp->type & IGNORE_CTCPS)
strmcat(buffer, " CTCPS",
BIG_BUFFER_SIZE);
else if (tmp->high & IGNORE_CTCPS)
{
snprintf(s, sizeof s, " %cCTCPS%c",
highlight_char, highlight_char);
strmcat(buffer, s, BIG_BUFFER_SIZE);
}
else if (tmp->dont & IGNORE_CTCPS)
strmcat(buffer, " DONT-CTCPS",
BIG_BUFFER_SIZE);
if (tmp->type & IGNORE_CRAP)
strmcat(buffer, " CRAP",
BIG_BUFFER_SIZE);
else if (tmp->high & IGNORE_CRAP)
{
snprintf(s, sizeof s, " %cCRAP%c",
highlight_char, highlight_char);
strmcat(buffer, s, BIG_BUFFER_SIZE);
}
else if (tmp->dont & IGNORE_CRAP)
strmcat(buffer, " DONT-CRAP",
BIG_BUFFER_SIZE);
/**************************** Patched by Flier ******************************/
if (tmp->type & IGNORE_PART)
strmcat(buffer, " PART", BIG_BUFFER_SIZE);
else if (tmp->high & IGNORE_PART)
{
snprintf(s, sizeof s, " %cPART%c",
highlight_char, highlight_char);
strmcat(buffer, s, BIG_BUFFER_SIZE);
}
else if (tmp->dont & IGNORE_PART)
strmcat(buffer, " DONT-PART",
BIG_BUFFER_SIZE);
if (tmp->type & IGNORE_JOIN)
strmcat(buffer, " JOIN", BIG_BUFFER_SIZE);
else if (tmp->high & IGNORE_JOIN)
{
snprintf(s, sizeof s, " %cJOIN%c",
highlight_char, highlight_char);
strmcat(buffer, s, BIG_BUFFER_SIZE);
}
else if (tmp->dont & IGNORE_JOIN)
strmcat(buffer, " DONT-JOIN",
BIG_BUFFER_SIZE);
/****************************************************************************/
}
/**************************** PATCHED by Flier ******************************/
/*say("\t%s:\t%s", tmp->nick, buffer);*/
say("%2d) %-30s %s", i, tmp->nick, buffer);
/****************************************************************************/
}
}
else
say("There is nothing on the ignorance list.");
}
/*
* ignore: does the /IGNORE command. Figures out what type of ignoring the
* user wants to do and calls the proper ignorance command to do it.
*/
/*ARGSUSED*/
void
ignore(command, args, subargs)
char *command,
*args,
*subargs;
{
char *nick,
*type;
int flag, no_flags, ignore_type;
if ((nick = next_arg(args, &args)) != NULL)
{
no_flags = 1;
while ((type = next_arg(args, &args)) != NULL)
{
no_flags = 0;
upper(type);
switch (*type)
{
case '^':
flag = IGNORE_DONT;
type++;
break;
case '-':
flag = IGNORE_REMOVE;
type++;
break;
case '+':
flag = IGNORE_HIGH;
type++;
break;
default:
flag = 0;
break;
}
ignore_type = get_ignore_type(type);
if (ignore_type != -1)
/**************************** PATCHED by Flier ******************************/
/*ignore_nickname(nick, ignore_type, flag);*/
ignore_nickname(nick, ignore_type, flag, subargs);
/****************************************************************************/
else if (ignore_type == -1)
{
char *ptr;
while (nick)
{
if ((ptr = index(nick, ',')) != NULL)
*ptr = (char) 0;
if (*nick)
{
/**************************** PATCHED by Flier ******************************/
/*if (remove_ignore(nick))
say("%s is not in the ignorance list!", nick);
else
say("%s removed from ignorance list", nick);*/
remove_ignore(nick);
/****************************************************************************/
}
if (ptr)
*(ptr++) = ',';
nick = ptr;
}
}
else
{
say("You must specify one of the following:");
/**************************** Patched by Flier ******************************/
/*say("\tALL MSGS PUBLIC WALLS WALLOPS INVITES \
NOTICES NOTES CTCPS CRAP NONE");*/
say("\tALL MSGS PUBLIC WALLS WALLOPS INVITES \
NOTICES NOTES CTCPS CRAP PART JOIN NONE");
/****************************************************************************/
}
}
if (no_flags)
ignore_list(nick);
} else
ignore_list((char *) 0);
}
/*
* set_highlight_char: what the name says.. the character to use
* for highlighting.. either BOLD, INVERSE, or UNDERLINE..
*/
void
set_highlight_char(s)
char *s;
{
size_t len;
len = strlen(s);
upper(s);
if (!strncmp(s, "BOLD", len))
{
set_string_var(HIGHLIGHT_CHAR_VAR, "BOLD");
highlight_char = BOLD_TOG;
}
else if (!strncmp(s, "INVERSE", len))
{
set_string_var(HIGHLIGHT_CHAR_VAR, "INVERSE");
highlight_char = REV_TOG;
}
else if (!strncmp(s, "UNDERLINE", len))
{
set_string_var(HIGHLIGHT_CHAR_VAR, "UNDERLINE");
highlight_char = UND_TOG;
}
else
say("HIGHLIGHT_CHAR must be one of BOLD, INVERSE, or \
UNDERLINE");
}
int
ignore_combo(flag1, flag2)
int flag1;
int flag2;
{
if (flag1 == DONT_IGNORE || flag2 == DONT_IGNORE)
return DONT_IGNORE;
if (flag1 == IGNORED || flag2 == IGNORED)
return IGNORED;
if (flag1 == HIGHLIGHTED || flag2 == HIGHLIGHTED)
return HIGHLIGHTED;
return 0;
}
/*
* double_ignore - makes live simpiler when using doing ignore code
* added, april 1993, phone.
*/
int
double_ignore(nick, userhost, type)
char *nick,
*userhost;
int type;
{
/**************************** Patched by Flier ******************************/
if (nick && userhost && is_channel(userhost)) {
char tmpbuf[mybufsize / 4 + 1];
strmcpy(tmpbuf, nick, mybufsize / 4);
strmcat(tmpbuf, "!", mybufsize / 4);
strmcat(tmpbuf, userhost, mybufsize / 4);
return(is_ignored(tmpbuf, type));
}
else if (nick && userhost) {
char tmpbuf[mybufsize / 4 + 1];
strmcpy(tmpbuf, nick, mybufsize / 4);
strmcat(tmpbuf, "!", mybufsize / 4);
strmcat(tmpbuf, userhost, mybufsize / 4);
return(is_ignored(tmpbuf, type));
}
/****************************************************************************/
if (userhost)
return (ignore_combo(is_ignored(nick, type),
is_ignored(userhost, type)));
else
return (is_ignored(nick, type));
}
int
get_ignore_type(type)
char *type;
{
size_t len = strlen(type);
int rv;
if (len == 0)
rv = 0;
if (my_strnicmp(type, "ALL", len) == 0)
rv = IGNORE_ALL;
else if (my_strnicmp(type, "MSGS", len) == 0)
rv = IGNORE_MSGS;
else if (my_strnicmp(type, "PUBLIC", len) == 0)
rv = IGNORE_PUBLIC;
else if (my_strnicmp(type, "WALLS", len) == 0)
rv = IGNORE_WALLS;
else if (my_strnicmp(type, "WALLOPS", len) == 0)
rv = IGNORE_WALLOPS;
else if (my_strnicmp(type, "INVITES", len) == 0)
rv = IGNORE_INVITES;
else if (my_strnicmp(type, "NOTICES", len) == 0)
rv = IGNORE_NOTICES;
else if (my_strnicmp(type, "NOTES", len) == 0)
rv = IGNORE_NOTES;
else if (my_strnicmp(type, "CTCPS", len) == 0)
rv = IGNORE_CTCPS;
else if (my_strnicmp(type, "CRAP", len) == 0)
rv = IGNORE_CRAP;
/**************************** Patched by Flier ******************************/
else if (my_strnicmp(type, "PART", len) == 0)
rv = IGNORE_PART;
else if (my_strnicmp(type, "JOIN", len) == 0)
rv = IGNORE_JOIN;
/****************************************************************************/
else if (my_strnicmp(type, "NONE", len) == 0)
rv = -1;
else
rv = 0;
return (rv);
}
/**************************** PATCHED by Flier ******************************/
/* Clean up allocated memory */
void CleanUpIgnore() {
Ignore *tmpignore;
while (ignored_nicks) {
tmpignore = ignored_nicks;
ignored_nicks = ignored_nicks->next;
new_free(&(tmpignore->nick));
new_free(&tmpignore);
}
}
/* Save ignore list */
int IgnoreSave(fp)
FILE *fp;
{
int count = 0;
char *tmpstr;
char tmpbuf[mybufsize / 2 + 1];
Ignore *tmp;
for (tmp = ignored_nicks; tmp; tmp = tmp->next) {
if (!(tmp->perm)) continue;
*tmpbuf = '\0';
if (tmp->type == IGNORE_ALL) strmcpy(tmpbuf, "ALL", mybufsize / 2);
else {
if (tmp->type & IGNORE_PUBLIC) strmcat(tmpbuf, ",PUBLIC", mybufsize / 2);
if (tmp->type & IGNORE_MSGS) strmcat(tmpbuf, ",MSGS", mybufsize / 2);
if (tmp->type & IGNORE_WALLS) strmcat(tmpbuf, ",WALLS", mybufsize / 2);
if (tmp->type & IGNORE_WALLOPS) strmcat(tmpbuf, ",WALLOPS", mybufsize / 2);
if (tmp->type & IGNORE_INVITES) strmcat(tmpbuf, ",INVITES", mybufsize / 2);
if (tmp->type & IGNORE_NOTICES) strmcat(tmpbuf, ",NOTICES", mybufsize / 2);
if (tmp->type & IGNORE_NOTES) strmcat(tmpbuf, ",NOTES", mybufsize / 2);
if (tmp->type & IGNORE_CTCPS) strmcat(tmpbuf, ",CTCPS", mybufsize / 2);
if (tmp->type & IGNORE_CRAP) strmcat(tmpbuf, ",CRAP", mybufsize / 2);
if (tmp->type & IGNORE_PART) strmcat(tmpbuf, ",PART", mybufsize / 2);
if (tmp->type & IGNORE_JOIN) strmcat(tmpbuf, ",JOIN", mybufsize / 2);
}
tmpstr = tmpbuf;
if (*tmpstr == ',') tmpstr++;
fprintf(fp, "IGN %s %s\n", tmp->nick, tmpstr);
count++;
}
return(count);
}
/****************************************************************************/
syntax highlighted by Code2HTML, v. 0.9.1