src/mod/channels.mod/channels.c File Reference

#include <sys/stat.h>
#include "src/mod/module.h"
#include "channels.h"
#include "cmdschan.c"
#include "tclchan.c"
#include "userchan.c"
#include "udefchan.c"

Include dependency graph for channels.c:

Go to the source code of this file.

Defines
#define	MODULE_NAME   "channels"
#define	MAKING_CHANNELS
#define	PLSMNS(x)   (x ? '+' : '-')
Functions
static void *	channel_malloc (int size, char *file, int line)
static void	set_mode_protect (struct chanset_t *chan, char *set)
static void	get_mode_protect (struct chanset_t *chan, char *s)
static int	ismodeline (masklist *m, char *user)
static int	ismasked (masklist *m, char *user)
static int	chanset_unlink (struct chanset_t *chan)
static void	remove_channel (struct chanset_t *chan)
static int	channels_chon (char *handle, int idx)
static char *	convert_element (char *src, char *dst)
static void	write_channels ()
static void	read_channels (int create, int reload)
static void	backup_chanfile ()
static void	channels_prerehash ()
static void	channels_rehash ()
static void	channels_report (int idx, int details)
static int	expmem_masklist (masklist *m)
static int	channels_expmem ()
static char *	traced_globchanset (ClientData cdata, Tcl_Interp *irp, char *name1, char *name2, int flags)
static char *	channels_close ()
EXPORT_SCOPE char *	channels_start ()
char *	channels_start (Function *global_funcs)
Variables
static Function *	global = 0
static char	chanfile [121]
static char	glob_chanmode [64]
static char *	lastdeletedmask
static struct udef_struct *	udef
static int	use_info
static int	chan_hack
static int	quiet_save
static int	global_revenge_mode
static int	global_stopnethack_mode
static int	global_idle_kick
static int	global_aop_min
static int	global_aop_max
static int	global_ban_time
static int	global_exempt_time
static int	global_invite_time
static int	global_ban_type
static int	allow_ps
static char	glob_chanset [512]
static int	gfld_chan_thr
static int	gfld_chan_time
static int	gfld_deop_thr
static int	gfld_deop_time
static int	gfld_kick_thr
static int	gfld_kick_time
static int	gfld_join_thr
static int	gfld_join_time
static int	gfld_ctcp_thr
static int	gfld_ctcp_time
static int	gfld_nick_thr
static int	gfld_nick_time
static cmd_t	my_chon []
static tcl_ints	my_tcl_ints []
static tcl_coups	mychan_tcl_coups []
static tcl_strings	my_tcl_strings []
static Function	channels_table []

---

Define Documentation

#define MAKING_CHANNELS

Definition at line 27 of file channels.c.

#define MODULE_NAME   "channels"

Definition at line 26 of file channels.c.

#define PLSMNS

(

x

)

(x ? '+' : '-')

Definition at line 379 of file channels.c.

Referenced by write_channels().

---

Function Documentation

static void backup_chanfile

(

)

[static]

Definition at line 531 of file channels.c.

References chanfile, copyfile, egg_snprintf, LOG_MISC, putlog, and quiet_save.

Referenced by channels_close(), and channels_start().

{
  char s[125];

  if (quiet_save < 2)
    putlog(LOG_MISC, "*", "Backing up channel file...");
  egg_snprintf(s, sizeof s, "%s~bak", chanfile);
  copyfile(chanfile, s);
}

Here is the caller graph for this function:

static void* channel_malloc	(	int	size,
		char *	file,
		int	line
	)			[static]

Definition at line 59 of file channels.c.

References egg_bzero, global, MODULE_NAME, and nmalloc.

Referenced by got475(), killmember(), newmask(), newmember(), real_add_mode(), reset_chan_info(), set_key(), and set_topic().

{
  char *p;

#ifdef DEBUG_MEM
  p = ((void *) (global[0] (size, MODULE_NAME, file, line)));
#else
  p = nmalloc(size);
#endif
  egg_bzero(p, size);
  return p;
}

Here is the caller graph for this function:

static int channels_chon	(	char *	handle,
		int	idx
	)			[static]

Definition at line 328 of file channels.c.

References flag_record::chan, chan_master, chan_owner, chanset, dcc, DCC_CHAT, chanset_t::dname, findchan_by_dname, FR_ANYWH, FR_CHAN, FR_GLOBAL, get_user_flagrec, glob_op, flag_record::match, chanset_t::next, NULL, chanset_t::type, user, USER_MASTER, USER_OP, and USER_OWNER.

{
  struct flag_record fr = { FR_CHAN | FR_ANYWH | FR_GLOBAL, 0, 0, 0, 0, 0 };
  int find, found = 0;
  struct chanset_t *chan = chanset;

  if (dcc[idx].type == &DCC_CHAT) {
    if (!findchan_by_dname(dcc[idx].u.chat->con_chan) &&
        ((dcc[idx].u.chat->con_chan[0] != '*') ||
         (dcc[idx].u.chat->con_chan[1] != 0))) {
      get_user_flagrec(dcc[idx].user, &fr, NULL);
      if (glob_op(fr))
        found = 1;
      if (chan_owner(fr))
        find = USER_OWNER;
      else if (chan_master(fr))
        find = USER_MASTER;
      else
        find = USER_OP;
      fr.match = FR_CHAN;
      while (chan && !found) {
        get_user_flagrec(dcc[idx].user, &fr, chan->dname);
        if (fr.chan & find)
          found = 1;
        else
          chan = chan->next;
      }
      if (!chan)
        chan = chanset;
      if (chan)
        strcpy(dcc[idx].u.chat->con_chan, chan->dname);
      else
        strcpy(dcc[idx].u.chat->con_chan, "*");
    }
  }
  return 0;
}

static char* channels_close

(

)

[static]

Definition at line 845 of file channels.c.

References backup_chanfile(), C_dcc_irc, channels_prerehash(), channels_rehash(), channels_writeuserfile(), check_expired_bans(), check_expired_exempts(), check_expired_invites(), del_hook, free_udef(), H_chon, H_dcc, HOOK_BACKUP, HOOK_MINUTELY, HOOK_PRE_REHASH, HOOK_REHASH, HOOK_USERFILE, interp, lastdeletedmask, MODULE_NAME, module_undepend, nfree, NULL, rem_builtins, rem_help_reference, rem_tcl_commands, rem_tcl_coups, rem_tcl_ints, rem_tcl_strings, traced_globchanset(), and write_channels().

{
  write_channels();
  free_udef(udef);
  if (lastdeletedmask)
    nfree(lastdeletedmask);
  rem_builtins(H_chon, my_chon);
  rem_builtins(H_dcc, C_dcc_irc);
  rem_tcl_commands(channels_cmds);
  rem_tcl_strings(my_tcl_strings);
  rem_tcl_ints(my_tcl_ints);
  rem_tcl_coups(mychan_tcl_coups);
  del_hook(HOOK_USERFILE, (Function) channels_writeuserfile);
  del_hook(HOOK_BACKUP, (Function) backup_chanfile);
  del_hook(HOOK_REHASH, (Function) channels_rehash);
  del_hook(HOOK_PRE_REHASH, (Function) channels_prerehash);
  del_hook(HOOK_MINUTELY, (Function) check_expired_bans);
  del_hook(HOOK_MINUTELY, (Function) check_expired_exempts);
  del_hook(HOOK_MINUTELY, (Function) check_expired_invites);
  Tcl_UntraceVar(interp, "global-chanset",
                 TCL_TRACE_READS | TCL_TRACE_WRITES | TCL_TRACE_UNSETS,
                 traced_globchanset, NULL);
  rem_help_reference("channels.help");
  rem_help_reference("chaninfo.help");
  module_undepend(MODULE_NAME);
  return NULL;
}

Here is the call graph for this function:

static int channels_expmem

(

)

[static]

Definition at line 739 of file channels.c.

References chan_t::ban, chanset_t::channel, chanset, chanset_t::cmode, chan_t::exempt, expmem_masklist(), expmem_udef(), chan_t::invite, chanset_t::key, chan_t::key, lastdeletedmask, chan_t::members, MODES_PER_LINE_MAX, chanset_t::next, chanset_t::op, chanset_t::rmkey, and chan_t::topic.

{
  int tot = 0, i;
  struct chanset_t *chan;

  for (chan = chanset; chan; chan = chan->next) {
    tot += sizeof(struct chanset_t);

    tot += strlen(chan->channel.key) + 1;
    if (chan->channel.topic)
      tot += strlen(chan->channel.topic) + 1;
    tot += (sizeof(struct memstruct) * (chan->channel.members + 1));

    tot += expmem_masklist(chan->channel.ban);
    tot += expmem_masklist(chan->channel.exempt);
    tot += expmem_masklist(chan->channel.invite);

    for (i = 0; i < MODES_PER_LINE_MAX && chan->cmode[i].op; i++)
      tot += strlen(chan->cmode[i].op) + 1;
    if (chan->key)
      tot += strlen(chan->key) + 1;
    if (chan->rmkey)
      tot += strlen(chan->rmkey) + 1;
  }
  tot += expmem_udef(udef);
  if (lastdeletedmask)
    tot += strlen(lastdeletedmask) + 1;
  return tot;
}

Here is the call graph for this function:

static void channels_prerehash

(

)

[static]

Definition at line 541 of file channels.c.

References write_channels().

Referenced by channels_close(), and channels_start().

{
  write_channels();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void channels_rehash

(

)

[static]

Definition at line 546 of file channels.c.

References read_channels(), and write_channels().

Referenced by channels_close(), and channels_start().

{
  /* add channels from the chanfile but don't remove missing ones */
  read_channels(1, 0);
  write_channels();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void channels_report	(	int	idx,
		int	details
	)			[static]

Definition at line 558 of file channels.c.

References chanset_t::ban_time, chanset_t::ban_type, chan_master, chanset_t::channel, channel_active, channel_autohalfop, channel_autoop, channel_autovoice, channel_bitch, channel_cycle, channel_dontkickops, channel_dynamicbans, channel_dynamicexempts, channel_dynamicinvites, channel_enforcebans, channel_greet, channel_inactive, channel_logstatus, channel_nodesynch, channel_nouserbans, channel_nouserexempts, channel_nouserinvites, channel_pending, channel_protectfriends, channel_protecthalfops, channel_protectops, channel_revenge, channel_secret, channel_seen, channel_shared, channel_static, chanset, dcc, chanset_t::dname, DP_STDOUT, dprintf, chanset_t::exempt_time, FR_CHAN, FR_GLOBAL, get_mode_protect(), get_user_flagrec, glob_master, chanset_t::idle_kick, chanset_t::invite_time, chan_t::members, my_strcpy, chanset_t::name, chanset_t::need_invite, chanset_t::need_key, chanset_t::need_limit, chanset_t::need_op, chanset_t::need_unban, chanset_t::next, chanset_t::revenge_mode, chanset_t::stopnethack_mode, and user.

{
  int i;
  char s[1024], s1[100], s2[100];
  struct chanset_t *chan;
  struct flag_record fr = { FR_CHAN | FR_GLOBAL, 0, 0, 0, 0, 0 };

  for (chan = chanset; chan; chan = chan->next) {

    /* Get user's flags if output isn't going to stdout */
    if (idx != DP_STDOUT)
      get_user_flagrec(dcc[idx].user, &fr, chan->dname);

    /* Don't show channel information to someone who isn't a master */
    if ((idx != DP_STDOUT) && !glob_master(fr) && !chan_master(fr))
      continue;

    s[0] = 0;

    sprintf(s, "    %-20s: ", chan->dname);

    if (channel_inactive(chan))
      strcat(s, "(inactive)");
    else if (channel_pending(chan))
      strcat(s, "(pending)");
    else if (!channel_active(chan))
      strcat(s, "(not on channel)");
    else {

      s1[0] = 0;
      sprintf(s1, "%3d member%s", chan->channel.members,
              (chan->channel.members == 1) ? "" : "s");
      strcat(s, s1);

      s2[0] = 0;
      get_mode_protect(chan, s2);

      if (s2[0]) {
        s1[0] = 0;
        sprintf(s1, ", enforcing \"%s\"", s2);
        strcat(s, s1);
      }

      s2[0] = 0;

      if (channel_greet(chan))
        strcat(s2, "greet, ");
      if (channel_autoop(chan))
        strcat(s2, "auto-op, ");
      if (channel_bitch(chan))
        strcat(s2, "bitch, ");

      if (s2[0]) {
        s2[strlen(s2) - 2] = 0;

        s1[0] = 0;
        sprintf(s1, " (%s)", s2);
        strcat(s, s1);
      }

      /* If it's a !chan, we want to display it's unique name too <cybah> */
      if (chan->dname[0] == '!') {
        s1[0] = 0;
        sprintf(s1, ", unique name %s", chan->name);
        strcat(s, s1);
      }
    }

    dprintf(idx, "%s\n", s);

    if (details) {
      s[0] = 0;
      i = 0;

      if (channel_enforcebans(chan))
        i += my_strcpy(s + i, "enforcebans ");
      if (channel_dynamicbans(chan))
        i += my_strcpy(s + i, "dynamicbans ");
      if (!channel_nouserbans(chan))
        i += my_strcpy(s + i, "userbans ");
      if (channel_autoop(chan))
        i += my_strcpy(s + i, "autoop ");
      if (channel_bitch(chan))
        i += my_strcpy(s + i, "bitch ");
      if (channel_greet(chan))
        i += my_strcpy(s + i, "greet ");
      if (channel_protectops(chan))
        i += my_strcpy(s + i, "protectops ");
      if (channel_protecthalfops(chan))
        i += my_strcpy(s + i, "protecthalfops ");
      if (channel_protectfriends(chan))
        i += my_strcpy(s + i, "protectfriends ");
      if (channel_dontkickops(chan))
        i += my_strcpy(s + i, "dontkickops ");
      if (channel_logstatus(chan))
        i += my_strcpy(s + i, "statuslog ");
      if (channel_revenge(chan))
        i += my_strcpy(s + i, "revenge ");
      if (channel_revenge(chan))
        i += my_strcpy(s + i, "revengebot ");
      if (channel_secret(chan))
        i += my_strcpy(s + i, "secret ");
      if (channel_shared(chan))
        i += my_strcpy(s + i, "shared ");
      if (!channel_static(chan))
        i += my_strcpy(s + i, "dynamic ");
      if (channel_autovoice(chan))
        i += my_strcpy(s + i, "autovoice ");
      if (channel_autohalfop(chan))
        i += my_strcpy(s + i, "autohalfop ");
      if (channel_cycle(chan))
        i += my_strcpy(s + i, "cycle ");
      if (channel_seen(chan))
        i += my_strcpy(s + i, "seen ");
      if (channel_dynamicexempts(chan))
        i += my_strcpy(s + i, "dynamicexempts ");
      if (!channel_nouserexempts(chan))
        i += my_strcpy(s + i, "userexempts ");
      if (channel_dynamicinvites(chan))
        i += my_strcpy(s + i, "dynamicinvites ");
      if (!channel_nouserinvites(chan))
        i += my_strcpy(s + i, "userinvites ");
      if (channel_inactive(chan))
        i += my_strcpy(s + i, "inactive ");
      if (channel_nodesynch(chan))
        i += my_strcpy(s + i, "nodesynch ");

      dprintf(idx, "      Options: %s\n", s);

      if (chan->need_op[0])
        dprintf(idx, "      To get ops, I do: %s\n", chan->need_op);

      if (chan->need_invite[0])
        dprintf(idx, "      To get invited, I do: %s\n", chan->need_invite);

      if (chan->need_limit[0])
        dprintf(idx, "      To get the channel limit raised, I do: %s\n",
                chan->need_limit);

      if (chan->need_unban[0])
        dprintf(idx, "      To get unbanned, I do: %s\n", chan->need_unban);

      if (chan->need_key[0])
        dprintf(idx, "      To get the channel key, I do: %s\n",
                chan->need_key);

      if (chan->idle_kick)
        dprintf(idx, "      Kicking idle users after %d minute%s\n",
                chan->idle_kick, (chan->idle_kick != 1) ? "s" : "");

      if (chan->stopnethack_mode)
        dprintf(idx, "      stopnethack-mode: %d\n", chan->stopnethack_mode);

      if (chan->revenge_mode)
        dprintf(idx, "      revenge-mode: %d\n", chan->revenge_mode);

      dprintf(idx, "      ban-type: %d\n", chan->ban_type);
      dprintf(idx, "      Bans last %d minute%s.\n", chan->ban_time,
               (chan->ban_time == 1) ? "" : "s");
      dprintf(idx, "      Exemptions last %d minute%s.\n", chan->exempt_time,
               (chan->exempt_time == 1) ? "" : "s");
      dprintf(idx, "      Invitations last %d minute%s.\n", chan->invite_time,
               (chan->invite_time == 1) ? "" : "s");
    }
  }
}

Here is the call graph for this function:

char* channels_start

(

Function *

global_funcs

)

Definition at line 940 of file channels.c.

References add_builtins, add_help_reference, add_hook, add_tcl_commands, add_tcl_coups, add_tcl_ints, add_tcl_strings, allow_ps, backup_chanfile(), C_dcc_irc, chan_hack, chanfile, channels_prerehash(), channels_rehash(), channels_writeuserfile(), check_expired_bans(), check_expired_exempts(), check_expired_invites(), gfld_chan_thr, gfld_chan_time, gfld_ctcp_thr, gfld_ctcp_time, gfld_deop_thr, gfld_deop_time, gfld_join_thr, gfld_join_time, gfld_kick_thr, gfld_kick_time, glob_chanmode, glob_chanset, global, global_aop_max, global_aop_min, global_ban_time, global_ban_type, global_exempt_time, global_idle_kick, global_invite_time, global_revenge_mode, global_stopnethack_mode, H_chon, H_dcc, HOOK_BACKUP, HOOK_MINUTELY, HOOK_PRE_REHASH, HOOK_REHASH, HOOK_USERFILE, interp, lastdeletedmask, module_depend, MODULE_NAME, module_register, module_undepend, NULL, quiet_save, read_channels(), share_greet, traced_globchanset(), use_info, and _tcl_int::val.

{
  global = global_funcs;

  gfld_chan_thr = 10;
  gfld_chan_time = 60;
  gfld_deop_thr = 3;
  gfld_deop_time = 10;
  gfld_kick_thr = 3;
  gfld_kick_time = 10;
  gfld_join_thr = 5;
  gfld_join_time = 60;
  gfld_ctcp_thr = 5;
  gfld_ctcp_time = 60;
  global_idle_kick = 0;
  global_aop_min = 5;
  global_aop_max = 30;
  allow_ps = 0;
  lastdeletedmask = 0;
  use_info = 1;
  strcpy(chanfile, "chanfile");
  chan_hack = 0;
  quiet_save = 0;
  strcpy(glob_chanmode, "nt");
  udef = NULL;
  global_stopnethack_mode = 0;
  global_revenge_mode = 0;
  global_ban_type = 3;
  global_ban_time = 120;
  global_exempt_time = 60;
  global_invite_time = 60;
  strcpy(glob_chanset,
         "-enforcebans "
         "+dynamicbans "
         "+userbans "
         "-autoop "
         "-bitch "
         "+greet "
         "+protectops "
         "+statuslog "
         "-revenge "
         "-secret "
         "-autovoice "
         "+cycle "
         "+dontkickops "
         "-inactive "
         "-protectfriends "
         "+shared "
         "-seen "
         "+userexempts "
         "+dynamicexempts "
         "+userinvites "
         "+dynamicinvites "
         "-revengebot "
         "-protecthalfops "
         "-autohalfop "
         "-nodesynch "
         "-static ");
  module_register(MODULE_NAME, channels_table, 1, 1);
  if (!module_depend(MODULE_NAME, "eggdrop", 106, 20)) {
    module_undepend(MODULE_NAME);
    return "This module requires Eggdrop 1.6.20 or later.";
  }
  add_hook(HOOK_MINUTELY, (Function) check_expired_bans);
  add_hook(HOOK_MINUTELY, (Function) check_expired_exempts);
  add_hook(HOOK_MINUTELY, (Function) check_expired_invites);
  add_hook(HOOK_USERFILE, (Function) channels_writeuserfile);
  add_hook(HOOK_BACKUP, (Function) backup_chanfile);
  add_hook(HOOK_REHASH, (Function) channels_rehash);
  add_hook(HOOK_PRE_REHASH, (Function) channels_prerehash);
  Tcl_TraceVar(interp, "global-chanset",
               TCL_TRACE_READS | TCL_TRACE_WRITES | TCL_TRACE_UNSETS,
               traced_globchanset, NULL);
  add_builtins(H_chon, my_chon);
  add_builtins(H_dcc, C_dcc_irc);
  add_tcl_commands(channels_cmds);
  add_tcl_strings(my_tcl_strings);
  add_help_reference("channels.help");
  add_help_reference("chaninfo.help");
  my_tcl_ints[0].val = &share_greet;
  add_tcl_ints(my_tcl_ints);
  add_tcl_coups(mychan_tcl_coups);
  read_channels(0, 1);
  return NULL;
}

Here is the call graph for this function:

EXPORT_SCOPE char* channels_start

(

)

static int chanset_unlink

(

struct chanset_t *

chan

)

[inline, static]

Definition at line 268 of file channels.c.

References chanset, chanset_t::next, and NULL.

Referenced by remove_channel().

{
  struct chanset_t *c, *c_old = NULL;

  for (c = chanset; c; c_old = c, c = c->next) {
    if (c == chan) {
      if (c_old)
        c_old->next = c->next;
      else
        chanset = c->next;
      return 1;
    }
  }
  return 0;
}

Here is the caller graph for this function:

static char* convert_element	(	char *	src,
		char *	dst
	)			[static]

Definition at line 366 of file channels.c.

Referenced by write_channels().

{
  int flags;

  Tcl_ScanElement(src, &flags);
/* Work around Tcl bug 3371644 (only present in 8.5.10) */
#ifdef TCL_DONT_QUOTE_HASH
  flags |= TCL_DONT_QUOTE_HASH;
#endif
  Tcl_ConvertElement(src, dst, flags);
  return dst;
}

Here is the caller graph for this function:

static int expmem_masklist

(

masklist *

m

)

[static]

Definition at line 725 of file channels.c.

References maskstruct::mask, maskstruct::next, and maskstruct::who.

Referenced by channels_expmem().

{
  int result = 0;

  for (; m; m = m->next) {
    result += sizeof(masklist);
    if (m->mask)
      result += strlen(m->mask) + 1;
    if (m->who)
      result += strlen(m->who) + 1;
  }
  return result;
}

Here is the caller graph for this function:

static void get_mode_protect	(	struct chanset_t *	chan,
		char *	s
	)			[static]

Definition at line 175 of file channels.c.

References CHANANON, CHANDELJN, CHANINV, CHANKEY, CHANLIMIT, CHANLONLY, CHANMODER, CHANMODREG, CHANNOAMSG, CHANNOCLR, CHANNOCTCP, CHANNOMSG, CHANNONOTC, CHANPRIV, CHANQUIET, CHANREGON, CHANSEC, CHANSTRIP, CHANTOPIC, chanset_t::key_prot, chanset_t::limit_prot, chanset_t::mode_mns_prot, and chanset_t::mode_pls_prot.

Referenced by channels_report(), cmd_chaninfo(), and write_channels().

{
  char *p = s, s1[121];
  int i, tst;

  s1[0] = 0;
  for (i = 0; i < 2; i++) {
    if (i == 0) {
      tst = chan->mode_pls_prot;
      if ((tst) || (chan->limit_prot != 0) || (chan->key_prot[0]))
        *p++ = '+';
      if (chan->limit_prot != 0) {
        *p++ = 'l';
        sprintf(&s1[strlen(s1)], "%d ", chan->limit_prot);
      }
      if (chan->key_prot[0]) {
        *p++ = 'k';
        sprintf(&s1[strlen(s1)], "%s ", chan->key_prot);
      }
    } else {
      tst = chan->mode_mns_prot;
      if (tst)
        *p++ = '-';
      if (tst & CHANKEY)
        *p++ = 'k';
      if (tst & CHANLIMIT)
        *p++ = 'l';
    }
    if (tst & CHANINV)
      *p++ = 'i';
    if (tst & CHANPRIV)
      *p++ = 'p';
    if (tst & CHANSEC)
      *p++ = 's';
    if (tst & CHANMODER)
      *p++ = 'm';
    if (tst & CHANNOCLR)
      *p++ = 'c';
    if (tst & CHANNOCTCP)
      *p++ = 'C';
    if (tst & CHANREGON)
      *p++ = 'R';
    if (tst & CHANMODREG)
      *p++ = 'M';
    if (tst & CHANLONLY)
      *p++ = 'r';
    if (tst & CHANDELJN)
      *p++ = 'D';
    if (tst & CHANSTRIP)
      *p++ = 'u';
    if (tst & CHANNONOTC)
      *p++ = 'N';
    if (tst & CHANNOAMSG)
      *p++ = 'T';
    if (tst & CHANTOPIC)
      *p++ = 't';
    if (tst & CHANNOMSG)
      *p++ = 'n';
    if (tst & CHANANON)
      *p++ = 'a';
    if (tst & CHANQUIET)
      *p++ = 'q';
  }
  *p = 0;
  if (s1[0]) {
    s1[strlen(s1) - 1] = 0;
    strcat(s, " ");
    strcat(s, s1);
  }
}

Here is the caller graph for this function:

static int ismasked	(	masklist *	m,
		char *	user
	)			[static]

Definition at line 258 of file channels.c.

References maskstruct::mask, match_addr, and maskstruct::next.

{
  for (; m && m->mask[0]; m = m->next)
    if (match_addr(m->mask, user))
      return 1;
  return 0;
}

static int ismodeline	(	masklist *	m,
		char *	user
	)			[static]

Definition at line 248 of file channels.c.

References maskstruct::mask, maskstruct::next, and rfc_casecmp.

{
  for (; m && m->mask[0]; m = m->next)
    if (!rfc_casecmp(m->mask, user))
      return 1;
  return 0;
}

static void read_channels	(	int	create,
		int	reload
	)			[static]

Definition at line 495 of file channels.c.

References CHAN_FLAGGED, chan_hack, chanfile, chanset, chanset_t::dname, LOG_MISC, chanset_t::next, putlog, readtclprog, remove_channel(), and chanset_t::status.

Referenced by channels_rehash(), channels_start(), and cmd_chanload().

{
  struct chanset_t *chan, *chan_next;

  if (!chanfile[0])
    return;

  if (reload)
    for (chan = chanset; chan; chan = chan->next)
      chan->status |= CHAN_FLAGGED;

  chan_hack = 1;
  if (!readtclprog(chanfile) && create) {
    FILE *f;

    /* Assume file isnt there & therfore make it */
    putlog(LOG_MISC, "*", "Creating channel file");
    f = fopen(chanfile, "w");
    if (!f)
      putlog(LOG_MISC, "*", "Couldn't create channel file: %s.  Dropping",
             chanfile);
    else
      fclose(f);
  }
  chan_hack = 0;
  if (!reload)
    return;
  for (chan = chanset; chan; chan = chan_next) {
    chan_next = chan->next;
    if (chan->status & CHAN_FLAGGED) {
      putlog(LOG_MISC, "*", "No longer supporting channel %s", chan->dname);
      remove_channel(chan);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void remove_channel

(

struct chanset_t *

chan

)

[static]

Definition at line 289 of file channels.c.

References chanset_t::bans, chanset_t::channel, chanset_unlink(), clear_channel(), chanset_t::cmode, chanset_t::dname, chanset_t::exempts, _module_entry::funcs, chanset_t::invites, IRC_DO_CHANNEL_PART, chanset_t::key, chan_t::key, maskrec::mask, MODES_PER_LINE_MAX, module_find, nfree, noshare, NULL, chanset_t::op, chanset_t::rmkey, u_delban(), u_delexempt(), u_delinvite(), user_del_chan, and void().

Referenced by cmd_mns_chan(), and read_channels().

{
  int i;
  module_entry *me;

  /* Remove the channel from the list, so that noone can pull it
   * away from under our feet during the check_tcl_part() call. */
  (void) chanset_unlink(chan);

  if ((me = module_find("irc", 1, 3)) != NULL)
    (me->funcs[IRC_DO_CHANNEL_PART]) (chan);

  clear_channel(chan, 0);
  noshare = 1;
  /* Remove channel-bans */
  while (chan->bans)
    u_delban(chan, chan->bans->mask, 1);
  /* Remove channel-exempts */
  while (chan->exempts)
    u_delexempt(chan, chan->exempts->mask, 1);
  /* Remove channel-invites */
  while (chan->invites)
    u_delinvite(chan, chan->invites->mask, 1);
  /* Remove channel specific user flags */
  user_del_chan(chan->dname);
  noshare = 0;
  nfree(chan->channel.key);
  for (i = 0; i < MODES_PER_LINE_MAX && chan->cmode[i].op; i++)
    nfree(chan->cmode[i].op);
  if (chan->key)
    nfree(chan->key);
  if (chan->rmkey)
    nfree(chan->rmkey);
  nfree(chan);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void set_mode_protect	(	struct chanset_t *	chan,
		char *	set
	)			[static]

Definition at line 72 of file channels.c.

References allow_ps, CHANANON, CHANDELJN, CHANINV, CHANKEY, CHANLIMIT, CHANLONLY, CHANMODER, CHANMODREG, CHANNOAMSG, CHANNOCLR, CHANNOCTCP, CHANNOMSG, CHANNONOTC, CHANPRIV, CHANQUIET, CHANREGON, CHANSEC, CHANSTRIP, CHANTOPIC, chanset_t::key_prot, chanset_t::limit_prot, chanset_t::mode_mns_prot, chanset_t::mode_pls_prot, and newsplit.

{
  int i, pos = 1;
  char *s, *s1;

  /* Clear old modes */
  chan->mode_mns_prot = chan->mode_pls_prot = 0;
  chan->limit_prot = 0;
  chan->key_prot[0] = 0;
  for (s = newsplit(&set); *s; s++) {
    i = 0;
    switch (*s) {
    case '+':
      pos = 1;
      break;
    case '-':
      pos = 0;
      break;
    case 'i':
      i = CHANINV;
      break;
    case 'p':
      i = CHANPRIV;
      break;
    case 's':
      i = CHANSEC;
      break;
    case 'm':
      i = CHANMODER;
      break;
    case 'c':
      i = CHANNOCLR;
      break;
    case 'C':
      i = CHANNOCTCP;
      break;
    case 'R':
      i = CHANREGON;
      break;
    case 'M':
      i = CHANMODREG;
      break;
    case 'r':
      i = CHANLONLY;
      break;
    case 'D':
      i = CHANDELJN;
      break;
    case 'u':
      i = CHANSTRIP;
      break;
    case 'N':
      i = CHANNONOTC;
      break;
    case 'T':
      i = CHANNOAMSG;
      break;
    case 't':
      i = CHANTOPIC;
      break;
    case 'n':
      i = CHANNOMSG;
      break;
    case 'a':
      i = CHANANON;
      break;
    case 'q':
      i = CHANQUIET;
      break;
    case 'l':
      i = CHANLIMIT;
      chan->limit_prot = 0;
      if (pos) {
        s1 = newsplit(&set);
        if (s1[0])
          chan->limit_prot = atoi(s1);
      }
      break;
    case 'k':
      i = CHANKEY;
      chan->key_prot[0] = 0;
      if (pos) {
        s1 = newsplit(&set);
        if (s1[0])
          strcpy(chan->key_prot, s1);
      }
      break;
    }
    if (i) {
      if (pos) {
        chan->mode_pls_prot |= i;
        chan->mode_mns_prot &= ~i;
      } else {
        chan->mode_pls_prot &= ~i;
        chan->mode_mns_prot |= i;
      }
    }
  }
  /* Prevents a +s-p +p-s flood  (fixed by drummer) */
  if (chan->mode_pls_prot & CHANSEC && !allow_ps)
    chan->mode_pls_prot &= ~CHANPRIV;
}

static char* traced_globchanset	(	ClientData	cdata,
		Tcl_Interp *	irp,
		char *	name1,
		char *	name2,
		int	flags
	)			[static]

Definition at line 769 of file channels.c.

References EGG_CONST, glob_chanset, interp, NULL, and Tcl_Free.

Referenced by channels_close(), and channels_start().

{
  int i, items;
  char *t, *s;
  EGG_CONST char **item, *s2;

  if (flags & (TCL_TRACE_READS | TCL_TRACE_UNSETS)) {
    Tcl_SetVar2(interp, name1, name2, glob_chanset, TCL_GLOBAL_ONLY);
    if (flags & TCL_TRACE_UNSETS)
      Tcl_TraceVar(interp, "global-chanset",
                   TCL_TRACE_READS | TCL_TRACE_WRITES | TCL_TRACE_UNSETS,
                   traced_globchanset, NULL);
  } else {                        /* Write */
    s2 = Tcl_GetVar2(interp, name1, name2, TCL_GLOBAL_ONLY);
    Tcl_SplitList(interp, s2, &items, &item);
    for (i = 0; i < items; i++) {
      if (!(item[i]) || (strlen(item[i]) < 2))
        continue;
      s = glob_chanset;
      while (s[0]) {
        t = strchr(s, ' ');     /* Can't be NULL coz of the extra space */
        t[0] = 0;
        if (!strcmp(s + 1, item[i] + 1)) {
          s[0] = item[i][0];    /* +- */
          t[0] = ' ';
          break;
        }
        t[0] = ' ';
        s = t + 1;
      }
    }
    if (item)                   /* hmm it cant be 0 */
      Tcl_Free((char *) item);
    Tcl_SetVar2(interp, name1, name2, glob_chanset, TCL_GLOBAL_ONLY);
  }
  return NULL;
}

Here is the caller graph for this function:

static void write_channels

(

void

)

[static]

Definition at line 387 of file channels.c.

References chanset_t::aop_max, chanset_t::aop_min, chanset_t::ban_time, chanset_t::ban_type, botnetnick, chanfile, channel_autohalfop, channel_autoop, channel_autovoice, channel_bitch, channel_cycle, channel_dontkickops, channel_dynamicbans, channel_dynamicexempts, channel_dynamicinvites, channel_enforcebans, channel_greet, channel_inactive, channel_logstatus, channel_nodesynch, channel_nouserbans, channel_nouserexempts, channel_nouserinvites, channel_protectfriends, channel_protecthalfops, channel_protectops, channel_revenge, channel_revengebot, channel_secret, channel_seen, channel_shared, channel_static, chanset, convert_element(), debug1, udef_struct::defined, chanset_t::dname, chanset_t::exempt_time, chanset_t::flood_ctcp_thr, chanset_t::flood_ctcp_time, chanset_t::flood_deop_thr, chanset_t::flood_deop_time, chanset_t::flood_join_thr, chanset_t::flood_join_time, chanset_t::flood_kick_thr, chanset_t::flood_kick_time, chanset_t::flood_nick_thr, chanset_t::flood_nick_time, chanset_t::flood_pub_thr, chanset_t::flood_pub_time, get_mode_protect(), getudef(), chanset_t::idle_kick, chanset_t::invite_time, LOG_MISC, movefile, udef_struct::name, chanset_t::name, chanset_t::need_invite, chanset_t::need_key, chanset_t::need_limit, chanset_t::need_op, chanset_t::need_unban, udef_struct::next, chanset_t::next, now, NULL, PLSMNS, putlog, quiet_save, chanset_t::revenge_mode, chanset_t::stopnethack_mode, udef_struct::type, UDEF_FLAG, UDEF_INT, UDEF_STR, userfile_perm, udef_struct::values, and ver.

Referenced by channels_close(), channels_prerehash(), channels_rehash(), channels_writeuserfile(), and cmd_chansave().

{
  FILE *f;
  char s[121], w[1024], w2[1024], name[163];
  char need1[242], need2[242], need3[242], need4[242], need5[242];
  struct chanset_t *chan;
  struct udef_struct *ul;

  if (!chanfile[0])
    return;
  sprintf(s, "%s~new", chanfile);
  f = fopen(s, "w");
  chmod(s, userfile_perm);
  if (f == NULL) {
    putlog(LOG_MISC, "*", "ERROR writing channel file.");
    return;
  }
  if (!quiet_save)
    putlog(LOG_MISC, "*", "Writing channel file...");
  fprintf(f, "#Dynamic Channel File for %s (%s) -- written %s\n",
          botnetnick, ver, ctime(&now));
  for (chan = chanset; chan; chan = chan->next) {
    convert_element(chan->dname, name);
    get_mode_protect(chan, w);
    convert_element(w, w2);
    convert_element(chan->need_op, need1);
    convert_element(chan->need_invite, need2);
    convert_element(chan->need_key, need3);
    convert_element(chan->need_unban, need4);
    convert_element(chan->need_limit, need5);
    fprintf(f,
            "channel add %s { chanmode %s idle-kick %d stopnethack-mode %d "
            "revenge-mode %d need-op %s need-invite %s need-key %s "
            "need-unban %s need-limit %s flood-chan %d:%d flood-ctcp %d:%d "
            "flood-join %d:%d flood-kick %d:%d flood-deop %d:%d "
            "flood-nick %d:%d aop-delay %d:%d ban-type %d ban-time %d "
            "exempt-time %d invite-time %d %cenforcebans %cdynamicbans "
            "%cuserbans %cautoop %cautohalfop %cbitch %cgreet %cprotectops "
            "%cprotecthalfops %cprotectfriends %cdontkickops %cstatuslog "
            "%crevenge %crevengebot %cautovoice %csecret %cshared %ccycle "
            "%cseen %cinactive %cdynamicexempts %cuserexempts %cdynamicinvites "
            "%cuserinvites %cnodesynch %cstatic }" "\n",
            name, w2, chan->idle_kick, chan->stopnethack_mode,
            chan->revenge_mode, need1, need2, need3, need4, need5,
            chan->flood_pub_thr, chan->flood_pub_time,
            chan->flood_ctcp_thr, chan->flood_ctcp_time,
            chan->flood_join_thr, chan->flood_join_time,
            chan->flood_kick_thr, chan->flood_kick_time,
            chan->flood_deop_thr, chan->flood_deop_time,
            chan->flood_nick_thr, chan->flood_nick_time,
            chan->aop_min, chan->aop_max, chan->ban_type, chan->ban_time,
            chan->exempt_time, chan->invite_time,
            PLSMNS(channel_enforcebans(chan)),
            PLSMNS(channel_dynamicbans(chan)),
            PLSMNS(!channel_nouserbans(chan)),
            PLSMNS(channel_autoop(chan)),
            PLSMNS(channel_autohalfop(chan)),
            PLSMNS(channel_bitch(chan)),
            PLSMNS(channel_greet(chan)),
            PLSMNS(channel_protectops(chan)),
            PLSMNS(channel_protecthalfops(chan)),
            PLSMNS(channel_protectfriends(chan)),
            PLSMNS(channel_dontkickops(chan)),
            PLSMNS(channel_logstatus(chan)),
            PLSMNS(channel_revenge(chan)),
            PLSMNS(channel_revengebot(chan)),
            PLSMNS(channel_autovoice(chan)),
            PLSMNS(channel_secret(chan)),
            PLSMNS(channel_shared(chan)),
            PLSMNS(channel_cycle(chan)),
            PLSMNS(channel_seen(chan)),
            PLSMNS(channel_inactive(chan)),
            PLSMNS(channel_dynamicexempts(chan)),
            PLSMNS(!channel_nouserexempts(chan)),
            PLSMNS(channel_dynamicinvites(chan)),
            PLSMNS(!channel_nouserinvites(chan)),
            PLSMNS(channel_nodesynch(chan)),
            PLSMNS(channel_static(chan)));
    for (ul = udef; ul; ul = ul->next) {
      if (ul->defined && ul->name) {
        if (ul->type == UDEF_FLAG)
          fprintf(f, "channel set %s %c%s%s\n", name, getudef(ul->values,
                  chan->dname) ? '+' : '-', "udef-flag-", ul->name);
        else if (ul->type == UDEF_INT)
          fprintf(f, "channel set %s %s%s %d\n", name, "udef-int-", ul->name,
                  (int) getudef(ul->values, chan->dname));
        else if (ul->type == UDEF_STR) {
          char *p = (char *) getudef(ul->values, chan->dname);

          if (!p)
            p = "{}";

          fprintf(f, "channel set %s udef-str-%s %s\n", name, ul->name, p);
        } else
          debug1("UDEF-ERROR: unknown type %d", ul->type);
      }
    }
    if (fflush(f)) {
      putlog(LOG_MISC, "*", "ERROR writing channel file.");
      fclose(f);
      return;
    }
  }
  fclose(f);
  unlink(chanfile);
  movefile(s, chanfile);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

int allow_ps [static]

Definition at line 39 of file channels.c.

Referenced by channels_start(), and set_mode_protect().

int chan_hack [static]

Definition at line 39 of file channels.c.

Referenced by channels_start(), and read_channels().

char chanfile[121] [static]

Definition at line 34 of file channels.c.

Referenced by backup_chanfile(), channels_start(), cmd_chanload(), cmd_chansave(), read_channels(), and write_channels().

Function channels_table[] [static]

Definition at line 875 of file channels.c.

int gfld_chan_thr [static]

Definition at line 48 of file channels.c.

Referenced by channels_start().

int gfld_chan_time [static]

Definition at line 48 of file channels.c.

Referenced by channels_start().

int gfld_ctcp_thr [static]

Definition at line 48 of file channels.c.

Referenced by channels_start().

int gfld_ctcp_time [static]

Definition at line 48 of file channels.c.

Referenced by channels_start().

int gfld_deop_thr [static]

Definition at line 48 of file channels.c.

Referenced by channels_start().

int gfld_deop_time [static]

Definition at line 48 of file channels.c.

Referenced by channels_start().

int gfld_join_thr [static]

Definition at line 48 of file channels.c.

Referenced by channels_start().

int gfld_join_time [static]

Definition at line 48 of file channels.c.

Referenced by channels_start().

int gfld_kick_thr [static]

Definition at line 48 of file channels.c.

Referenced by channels_start().

int gfld_kick_time [static]

Definition at line 48 of file channels.c.

Referenced by channels_start().

int gfld_nick_thr [static]

Definition at line 48 of file channels.c.

int gfld_nick_time [static]

Definition at line 48 of file channels.c.

char glob_chanmode[64] [static]

Definition at line 34 of file channels.c.

Referenced by channels_start().

char glob_chanset[512] [static]

Definition at line 45 of file channels.c.

Referenced by channels_start(), and traced_globchanset().

Function* global = 0 [static]

Definition at line 32 of file channels.c.

int global_aop_max [static]

Definition at line 39 of file channels.c.

Referenced by channels_start().

int global_aop_min [static]

Definition at line 39 of file channels.c.

Referenced by channels_start().

int global_ban_time [static]

Definition at line 39 of file channels.c.

Referenced by channels_start().

int global_ban_type [static]

Definition at line 39 of file channels.c.

Referenced by channels_start().

int global_exempt_time [static]

Definition at line 39 of file channels.c.

Referenced by channels_start().

int global_idle_kick [static]

Definition at line 39 of file channels.c.

Referenced by channels_start().

int global_invite_time [static]

Definition at line 39 of file channels.c.

Referenced by channels_start().

int global_revenge_mode [static]

Definition at line 39 of file channels.c.

Referenced by channels_start().

int global_stopnethack_mode [static]

Definition at line 39 of file channels.c.

Referenced by channels_start().

char* lastdeletedmask [static]

Definition at line 35 of file channels.c.

Referenced by channels_close(), channels_expmem(), channels_start(), cmd_mns_ban(), cmd_mns_exempt(), cmd_mns_invite(), u_delban(), u_delexempt(), and u_delinvite().

cmd_t my_chon[] [static]

Initial value:

 {
  {"*",  "",   (IntFunc) channels_chon, "channels:chon"},
  { 0 ,  0 ,  0 ,                                 0 }
}

Definition at line 553 of file channels.c.

tcl_ints my_tcl_ints[] [static]

Initial value:

 {
  {"share-greet",              0 ,                     0},
  {"use-info",                &use_info,                0},
  {"quiet-save",              &quiet_save,              0},
  {"allow-ps",                &allow_ps,                0},
  {"global-stopnethack-mode", &global_stopnethack_mode, 0},
  {"global-revenge-mode",     &global_revenge_mode,     0},
  {"global-idle-kick",        &global_idle_kick,        0},
  {"global-ban-time",         &global_ban_time,         0},
  {"global-exempt-time",      &global_exempt_time,      0},
  {"global-invite-time",      &global_invite_time,      0},
  {"global-ban-type",         &global_ban_type,         0},
  
  {"ban-time",                &global_ban_time,         0},
  {"exempt-time",             &global_exempt_time,      0},
  {"invite-time",             &global_invite_time,      0},
  { 0 ,                       0 ,                     0}
}

Definition at line 809 of file channels.c.

tcl_strings my_tcl_strings[] [static]

Initial value:

 {
  {"chanfile",        chanfile,      120,  2 },
  {"global-chanmode", glob_chanmode, 64,            0},
  { 0 ,               0 ,          0,             0}
}

Definition at line 839 of file channels.c.

tcl_coups mychan_tcl_coups[] [static]

Initial value:

 {
  {"global-flood-chan", &gfld_chan_thr,  &gfld_chan_time},
  {"global-flood-deop", &gfld_deop_thr,  &gfld_deop_time},
  {"global-flood-kick", &gfld_kick_thr,  &gfld_kick_time},
  {"global-flood-join", &gfld_join_thr,  &gfld_join_time},
  {"global-flood-ctcp", &gfld_ctcp_thr,  &gfld_ctcp_time},
  {"global-flood-nick", &gfld_nick_thr,  &gfld_nick_time},
  {"global-aop-delay",  &global_aop_min, &global_aop_max},
  { 0 ,                 0 ,                        0 }
}

Definition at line 828 of file channels.c.

int quiet_save [static]

Definition at line 39 of file channels.c.

struct udef_struct* udef [static]

Definition at line 37 of file channels.c.

Referenced by cmd_chaninfo(), initudef(), and ngetudef().

int use_info [static]

Definition at line 39 of file channels.c.

Referenced by channels_start(), cmd_chinfo(), cmd_info(), gotjoin(), msg_info(), and msg_who().