src/mod/irc.mod/chan.c File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines
#define	CHANNEL_ID_LEN   5
Functions
static memberlist *	newmember (struct chanset_t *chan)
static void	sync_members (struct chanset_t *chan)
static void	update_idle (char *chname, char *nick)
static char *	getchanmode (struct chanset_t *chan)
static void	check_exemptlist (struct chanset_t *chan, char *from)
static void	do_mask (struct chanset_t *chan, masklist *m, char *mask, char mode)
static int	detect_chan_flood (char *floodnick, char *floodhost, char *from, struct chanset_t *chan, int which, char *victim)
static char *	quickban (struct chanset_t *chan, char *uhost)
static void	kick_all (struct chanset_t *chan, char *hostmask, char *comment, int bantype)
static void	refresh_ban_kick (struct chanset_t *chan, char *user, char *nick)
static void	refresh_exempt (struct chanset_t *chan, char *user)
static void	refresh_invite (struct chanset_t *chan, char *user)
static void	enforce_bans (struct chanset_t *chan)
static void	recheck_bans (struct chanset_t *chan)
static void	recheck_exempts (struct chanset_t *chan)
static void	recheck_invites (struct chanset_t *chan)
static void	resetmasks (struct chanset_t *chan, masklist *m, maskrec *mrec, maskrec *global_masks, char mode)
static void	check_this_ban (struct chanset_t *chan, char *banmask, int sticky)
static void	recheck_channel_modes (struct chanset_t *chan)
static void	check_this_member (struct chanset_t *chan, char *nick, struct flag_record *fr)
static void	check_this_user (char *hand, int delete, char *host)
static void	recheck_channel (struct chanset_t *chan, int dobans)
static int	got324 (char *from, char *msg)
static int	got352or4 (struct chanset_t *chan, char *user, char *host, char *nick, char *flags)
static int	got352 (char *from, char *msg)
static int	got354 (char *from, char *msg)
static int	got315 (char *from, char *msg)
static int	got367 (char *from, char *origmsg)
static int	got368 (char *from, char *msg)
static int	got348 (char *from, char *origmsg)
static int	got349 (char *from, char *msg)
static int	got346 (char *from, char *origmsg)
static int	got347 (char *from, char *msg)
static int	got405 (char *from, char *msg)
static int	got403 (char *from, char *msg)
static int	got471 (char *from, char *msg)
static int	got473 (char *from, char *msg)
static int	got474 (char *from, char *msg)
static int	got475 (char *from, char *msg)
static int	gotinvite (char *from, char *msg)
static void	set_topic (struct chanset_t *chan, char *k)
static int	gottopic (char *from, char *msg)
static int	got331 (char *from, char *msg)
static int	got332 (char *from, char *msg)
static void	set_delay (struct chanset_t *chan, char *nick)
static int	gotjoin (char *from, char *chname)
static int	gotpart (char *from, char *msg)
static int	gotkick (char *from, char *origmsg)
static int	gotnick (char *from, char *msg)
static int	gotquit (char *from, char *msg)
static int	gotmsg (char *from, char *msg)
static int	gotnotice (char *from, char *msg)
Variables
static time_t	last_ctcp = (time_t) 0L
static int	count_ctcp = 0
static time_t	last_invtime = (time_t) 0L
static char	last_invchan [300] = ""
static cmd_t	irc_raw []

---

Define Documentation

#define CHANNEL_ID_LEN   5

Definition at line 37 of file chan.c.

Referenced by got471(), got473(), got474(), got475(), and gotjoin().

---

Function Documentation

static void check_exemptlist	(	struct chanset_t *	chan,
		char *	from
	)			[static]

Definition at line 147 of file chan.c.

References add_mode, chanset_t::channel, e, chan_t::exempt, flush_mode(), maskstruct::mask, match_addr, maskstruct::next, prevent_mixing, QUICK, and use_exempts.

Referenced by check_this_member(), cmd_kickban(), detect_chan_flood(), gotjoin(), gotmsg(), gotnotice(), and refresh_ban_kick().

{
  masklist *e;
  int ok = 0;

  if (!use_exempts)
    return;

  for (e = chan->channel.exempt; e->mask[0]; e = e->next)
    if (match_addr(e->mask, from)) {
      add_mode(chan, '-', 'e', e->mask);
      ok = 1;
    }
  if (prevent_mixing && ok)
    flush_mode(chan, QUICK);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void check_this_ban	(	struct chanset_t *	chan,
		char *	banmask,
		int	sticky
	)			[static]

Definition at line 638 of file chan.c.

References add_mode, chanset_t::channel, channel_dynamicbans, chanset_t::exempts, global_exempts, HALFOP_CANTDOMODE, isbanned, match_addr, chan_t::member, memstruct::next, memstruct::nick, refresh_ban_kick(), u_match_mask(), UHOSTLEN, use_exempts, user, and memstruct::userhost.

{
  memberlist *m;
  char user[UHOSTLEN];

  if (HALFOP_CANTDOMODE('b'))
    return;

  for (m = chan->channel.member; m && m->nick[0]; m = m->next) {
    sprintf(user, "%s!%s", m->nick, m->userhost);
    if (match_addr(banmask, user) &&
        !(use_exempts &&
          (u_match_mask(global_exempts, user) ||
           u_match_mask(chan->exempts, user))))
      refresh_ban_kick(chan, user, m->nick);
  }
  if (!isbanned(chan, banmask) && (!channel_dynamicbans(chan) || sticky))
    add_mode(chan, '+', 'b', banmask);
}

Here is the call graph for this function:

static void check_this_member	(	struct chanset_t *	chan,
		char *	nick,
		struct flag_record *	fr
	)			[static]

Definition at line 750 of file chan.c.

References add_mode, chanset_t::aop_min, chanset_t::bans, chan_autohalfop, chan_autoop, chan_dehalfop, chan_deop, chan_gvoice, chan_halfop, chan_hashalfop, chan_hasop, chan_hasvoice, chan_kick, chan_op, chan_quiet, chan_sentkick, chan_sentop, chan_voice, channel_autohalfop, channel_autoop, channel_autovoice, channel_bitch, check_exemptlist(), DP_SERVER, dprintf, chanset_t::exempts, memstruct::flags, get_user, glob_autohalfop, glob_autoop, glob_dehalfop, glob_deop, glob_gvoice, glob_halfop, glob_kick, glob_op, glob_quiet, glob_voice, global_bans, global_exempts, global_invites, HALFOP_CANDOMODE, chanset_t::invites, IRC_POLITEKICK, ismember, match_my_nick(), me_halfop(), me_op(), chanset_t::name, memstruct::nick, NOHALFOPS_MODES, NULL, quickban(), refresh_ban_kick(), refresh_invite(), SENTHALFOP, SENTKICK, SENTOP, SENTVOICE, set_delay(), u_match_mask(), UHOSTLEN, use_exempts, use_invites, memstruct::user, USERENTRY_COMMENT, and memstruct::userhost.

Referenced by check_this_user(), gotnick(), and recheck_channel().

{
  memberlist *m;
  char s[UHOSTLEN], *p;

  m = ismember(chan, nick);
  if (!m || match_my_nick(nick) || (!me_op(chan) && !me_halfop(chan)))
    return;


#ifdef NO_HALFOP_CHANMODES
  if (me_op(chan)) {
#else
  if (me_op(chan) || me_halfop(chan)) {
#endif
    if (HALFOP_CANDOMODE('o')) {
      if (chan_hasop(m) && ((chan_deop(*fr) || (glob_deop(*fr) &&
          !chan_op(*fr))) || (channel_bitch(chan) && (!chan_op(*fr) &&
          !(glob_op(*fr) && !chan_deop(*fr)))))) {
        add_mode(chan, '-', 'o', m->nick);
      }
      if (!chan_hasop(m) && (chan_op(*fr) || (glob_op(*fr) &&
          !chan_deop(*fr))) && (channel_autoop(chan) || glob_autoop(*fr) ||
          chan_autoop(*fr))) {
        if (!chan->aop_min)
          add_mode(chan, '+', 'o', m->nick);
        else {
          set_delay(chan, m->nick);
          m->flags |= SENTOP;
        }
      }
    }

    if (HALFOP_CANDOMODE('h')) {
      if (chan_hashalfop(m) && ((chan_dehalfop(*fr) || (glob_dehalfop(*fr) &&
          !chan_halfop(*fr)) || (channel_bitch(chan) && (!chan_halfop(*fr) &&
          !(glob_halfop(*fr) && !chan_dehalfop(*fr)))))))
        add_mode(chan, '-', 'h', m->nick);
      if (!chan_sentop(m) && !chan_hasop(m) && !chan_hashalfop(m) &&
          (chan_halfop(*fr) || (glob_halfop(*fr) && !chan_dehalfop(*fr))) &&
          (channel_autohalfop(chan) || glob_autohalfop(*fr) ||
          chan_autohalfop(*fr))) {
        if (!chan->aop_min)
          add_mode(chan, '+', 'h', m->nick);
        else {
          set_delay(chan, m->nick);
          m->flags |= SENTHALFOP;
        }
      }
    }

    if (HALFOP_CANDOMODE('v')) {
      if (chan_hasvoice(m) && (chan_quiet(*fr) || (glob_quiet(*fr) &&
          !chan_voice(*fr))))
        add_mode(chan, '-', 'v', m->nick);
      if (!chan_hasvoice(m) && !chan_hasop(m) && !chan_hashalfop(m) &&
          (chan_voice(*fr) || (glob_voice(*fr) && !chan_quiet(*fr))) &&
          (channel_autovoice(chan) || glob_gvoice(*fr) || chan_gvoice(*fr))) {
        if (!chan->aop_min)
          add_mode(chan, '+', 'v', m->nick);
        else {
          set_delay(chan, m->nick);
          m->flags |= SENTVOICE;
        }
      }
    }
  }

  if (!me_op(chan) && (!me_halfop(chan) ||
      (strchr(NOHALFOPS_MODES, 'b') != NULL) ||
      (strchr(NOHALFOPS_MODES, 'e') != NULL) ||
      (strchr(NOHALFOPS_MODES, 'I') != NULL)))
    return;

  sprintf(s, "%s!%s", m->nick, m->userhost);
  if (use_invites && (u_match_mask(global_invites, s) ||
      u_match_mask(chan->invites, s)))
    refresh_invite(chan, s);
  if (!(use_exempts && (u_match_mask(global_exempts, s) ||
      u_match_mask(chan->exempts, s)))) {
    if (u_match_mask(global_bans, s) || u_match_mask(chan->bans, s))
      refresh_ban_kick(chan, s, m->nick);
    if (!chan_sentkick(m) && (chan_kick(*fr) || glob_kick(*fr)) &&
        (me_op(chan) || (me_halfop(chan) && !chan_hasop(m)))) {
      check_exemptlist(chan, s);
      quickban(chan, m->userhost);
      p = get_user(&USERENTRY_COMMENT, m->user);
      dprintf(DP_SERVER, "KICK %s %s :%s\n", chan->name, m->nick,
              p ? p : IRC_POLITEKICK);
      m->flags |= SENTKICK;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void check_this_user	(	char *	hand,
		int	delete,
		char *	host
	)			[static]

Definition at line 845 of file chan.c.

References chanset_t::channel, chanset, check_this_member(), chanset_t::dname, egg_strcasecmp, fixfrom, FR_CHAN, FR_GLOBAL, get_user_by_host, get_user_flagrec, userrec::handle, match_addr, chan_t::member, memstruct::next, chanset_t::next, memstruct::nick, NULL, UHOSTLEN, memstruct::user, and memstruct::userhost.

Referenced by cmd_adduser(), msg_addhost(), and msg_ident().

{
  char s[UHOSTLEN];
  memberlist *m;
  struct userrec *u;
  struct chanset_t *chan;
  struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };

  for (chan = chanset; chan; chan = chan->next)
    for (m = chan->channel.member; m && m->nick[0]; m = m->next) {
      sprintf(s, "%s!%s", m->nick, m->userhost);
      u = m->user ? m->user : get_user_by_host(s);
      if ((u && !egg_strcasecmp(u->handle, hand) && delete < 2) ||
          (!u && delete == 2 && match_addr(host, fixfrom(s)))) {
        u = delete ? NULL : u;
        get_user_flagrec(u, &fr, chan->dname);
        check_this_member(chan, m->nick, &fr);
      }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int detect_chan_flood	(	char *	floodnick,
		char *	floodhost,
		char *	from,
		struct chanset_t *	chan,
		int	which,
		char *	victim
	)			[static]

Definition at line 181 of file chan.c.

References chan_t::ban, chanset_t::ban_time, chanset_t::bans, botnetnick, botuserhost, chan_deop, CHAN_FLOOD, chan_friend, chan_hasop, CHAN_MASSDEOP, CHAN_MASSDEOP_KICK, chan_master, chan_op, chan_sentkick, chanset_t::channel, channel_dontkickops, channel_enforcebans, check_exemptlist(), check_tcl_flud(), chanset_t::deopd, chanset_t::dname, do_mask(), DP_MODE, DP_SERVER, dprintf, egg_strcasecmp, chanset_t::exempts, memstruct::flags, FLOOD_CHAN_MAX, FLOOD_CTCP, chanset_t::flood_ctcp_thr, chanset_t::flood_ctcp_time, FLOOD_DEOP, chanset_t::flood_deop_thr, chanset_t::flood_deop_time, FLOOD_JOIN, chanset_t::flood_join_thr, chanset_t::flood_join_time, FLOOD_KICK, chanset_t::flood_kick_thr, chanset_t::flood_kick_time, FLOOD_NICK, chanset_t::flood_nick_thr, chanset_t::flood_nick_time, FLOOD_NOTICE, FLOOD_PRIVMSG, chanset_t::flood_pub_thr, chanset_t::flood_pub_time, chanset_t::floodnum, chanset_t::floodtime, chanset_t::floodwho, FR_CHAN, FR_GLOBAL, get_user_by_host, get_user_flagrec, glob_bot, glob_friend, glob_master, glob_op, global_bans, global_exempts, IRC_FLOODIGNORE3, IRC_FLOODIGNORE4, IRC_FLOODKICK, IRC_JOIN_FLOOD, IRC_MASSKICK, IRC_NICK_FLOOD, isbanned, ismember, memstruct::joined, LOG_JOIN, LOG_MISC, LOG_MODES, match_my_nick(), me_halfop(), me_op(), chan_t::member, chanset_t::name, memstruct::next, memstruct::nick, now, putlog, rfc_casecmp, SENTKICK, simple_sprintf, u_addban(), u_match_mask(), UHOSTLEN, use_exempts, memstruct::userhost, and wild_match.

Referenced by got_deop(), gotjoin(), gotkick(), gotmsg(), gotnick(), and gotnotice().

{
  char h[UHOSTLEN], ftype[12], *p;
  struct userrec *u;
  memberlist *m;
  int thr = 0, lapse = 0;
  struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };

  if (!chan || (which < 0) || (which >= FLOOD_CHAN_MAX))
    return 0;

  /* Okay, make sure i'm not flood-checking myself */
  if (match_my_nick(floodnick))
    return 0;

  /* My user@host (?) */
  if (!egg_strcasecmp(floodhost, botuserhost))
    return 0;

  m = ismember(chan, floodnick);

  /* Do not punish non-existant channel members and IRC services like
   * ChanServ
   */
  if (!m && (which != FLOOD_JOIN))
    return 0;

  get_user_flagrec(get_user_by_host(from), &fr, chan->dname);
  if (glob_bot(fr) || ((which == FLOOD_DEOP) && (glob_master(fr) ||
      chan_master(fr)) && (glob_friend(fr) || chan_friend(fr))) ||
      ((which == FLOOD_KICK) && (glob_master(fr) || chan_master(fr)) &&
      (glob_friend(fr) || chan_friend(fr))) || ((which != FLOOD_DEOP) &&
      (which != FLOOD_KICK) && (glob_friend(fr) || chan_friend(fr))) ||
      (channel_dontkickops(chan) && (chan_op(fr) || (glob_op(fr) &&
      !chan_deop(fr)))))
    return 0;

  /* Determine how many are necessary to make a flood. */
  switch (which) {
  case FLOOD_PRIVMSG:
  case FLOOD_NOTICE:
    thr = chan->flood_pub_thr;
    lapse = chan->flood_pub_time;
    strcpy(ftype, "pub");
    break;
  case FLOOD_CTCP:
    thr = chan->flood_ctcp_thr;
    lapse = chan->flood_ctcp_time;
    strcpy(ftype, "pub");
    break;
  case FLOOD_NICK:
    thr = chan->flood_nick_thr;
    lapse = chan->flood_nick_time;
    strcpy(ftype, "nick");
    break;
  case FLOOD_JOIN:
    thr = chan->flood_join_thr;
    lapse = chan->flood_join_time;
    strcpy(ftype, "join");
    break;
  case FLOOD_DEOP:
    thr = chan->flood_deop_thr;
    lapse = chan->flood_deop_time;
    strcpy(ftype, "deop");
    break;
  case FLOOD_KICK:
    thr = chan->flood_kick_thr;
    lapse = chan->flood_kick_time;
    strcpy(ftype, "kick");
    break;
  }
  if ((thr == 0) || (lapse == 0))
    return 0;                   /* no flood protection */

  if ((which == FLOOD_KICK) || (which == FLOOD_DEOP))
    p = floodnick;
  else {
    p = strchr(floodhost, '@');
    if (p) {
      p++;
    }
    if (!p)
      return 0;
  }
  if (rfc_casecmp(chan->floodwho[which], p)) {  /* new */
    strncpy(chan->floodwho[which], p, 80);
    chan->floodwho[which][80] = 0;
    chan->floodtime[which] = now;
    chan->floodnum[which] = 1;
    return 0;
  }
  if (chan->floodtime[which] < now - lapse) {
    /* Flood timer expired, reset it */
    chan->floodtime[which] = now;
    chan->floodnum[which] = 1;
    return 0;
  }
  /* Deop'n the same person, sillyness ;) - so just ignore it */
  if (which == FLOOD_DEOP) {
    if (!rfc_casecmp(chan->deopd, victim))
      return 0;
    else
      strcpy(chan->deopd, victim);
  }
  chan->floodnum[which]++;
  if (chan->floodnum[which] >= thr) {   /* FLOOD */
    /* Reset counters */
    chan->floodnum[which] = 0;
    chan->floodtime[which] = 0;
    chan->floodwho[which][0] = 0;
    if (which == FLOOD_DEOP)
      chan->deopd[0] = 0;
    u = get_user_by_host(from);
    if (check_tcl_flud(floodnick, floodhost, u, ftype, chan->dname))
      return 0;
    switch (which) {
    case FLOOD_PRIVMSG:
    case FLOOD_NOTICE:
    case FLOOD_CTCP:
      /* Flooding chan! either by public or notice */
      if (!chan_sentkick(m) &&
          (me_op(chan) || (me_halfop(chan) && !chan_hasop(m)))) {
        putlog(LOG_MODES, chan->dname, IRC_FLOODKICK, floodnick);
        dprintf(DP_MODE, "KICK %s %s :%s\n", chan->name, floodnick, CHAN_FLOOD);
        m->flags |= SENTKICK;
      }
      return 1;
    case FLOOD_JOIN:
    case FLOOD_NICK:
      if (use_exempts && (u_match_mask(global_exempts, from) ||
          u_match_mask(chan->exempts, from)))
        return 1;
      simple_sprintf(h, "*!*@%s", p);
      if (!isbanned(chan, h) && (me_op(chan) || me_halfop(chan))) {
        check_exemptlist(chan, from);
        do_mask(chan, chan->channel.ban, h, 'b');
      }
      if ((u_match_mask(global_bans, from)) ||
          (u_match_mask(chan->bans, from)))
        return 1;               /* Already banned */
      if (which == FLOOD_JOIN)
        putlog(LOG_MISC | LOG_JOIN, chan->dname, IRC_FLOODIGNORE3, p);
      else
        putlog(LOG_MISC | LOG_JOIN, chan->dname, IRC_FLOODIGNORE4, p);
      strcpy(ftype + 4, " flood");
      u_addban(chan, h, botnetnick, ftype, now + (60 * chan->ban_time), 0);
      if (!channel_enforcebans(chan) && (me_op(chan) || me_halfop(chan))) {
        char s[UHOSTLEN];

        for (m = chan->channel.member; m && m->nick[0]; m = m->next) {
          sprintf(s, "%s!%s", m->nick, m->userhost);
          if (wild_match(h, s) && (m->joined >= chan->floodtime[which]) &&
              !chan_sentkick(m) && !match_my_nick(m->nick) && (me_op(chan) ||
              (me_halfop(chan) && !chan_hasop(m)))) {
            m->flags |= SENTKICK;
            if (which == FLOOD_JOIN)
              dprintf(DP_SERVER, "KICK %s %s :%s\n", chan->name, m->nick,
                      IRC_JOIN_FLOOD);
            else
              dprintf(DP_SERVER, "KICK %s %s :%s\n", chan->name, m->nick,
                      IRC_NICK_FLOOD);
          }
        }
      }
      return 1;
    case FLOOD_KICK:
      if ((me_op(chan) || (me_halfop(chan) && !chan_hasop(m))) &&
          !chan_sentkick(m)) {
        putlog(LOG_MODES, chan->dname, "Kicking %s, for mass kick.", floodnick);
        dprintf(DP_MODE, "KICK %s %s :%s\n", chan->name, floodnick,
                IRC_MASSKICK);
        m->flags |= SENTKICK;
      }
      return 1;
    case FLOOD_DEOP:
      if ((me_op(chan) || (me_halfop(chan) && !chan_hasop(m))) &&
          !chan_sentkick(m)) {
        putlog(LOG_MODES, chan->dname, CHAN_MASSDEOP, chan->dname, from);
        dprintf(DP_MODE, "KICK %s %s :%s\n",
                chan->name, floodnick, CHAN_MASSDEOP_KICK);
        m->flags |= SENTKICK;
      }
      return 1;
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void do_mask	(	struct chanset_t *	chan,
		masklist *	m,
		char *	mask,
		char	mode
	)			[static]

Definition at line 169 of file chan.c.

References add_mode, cmp_masks, flush_mode(), maskstruct::mask, maskstruct::next, QUICK, and rfc_casecmp.

Referenced by cmd_kickban(), detect_chan_flood(), quickban(), refresh_ban_kick(), refresh_exempt(), and refresh_invite().

{
  for (; m && m->mask[0]; m = m->next)
    if (cmp_masks(mask, m->mask) && rfc_casecmp(mask, m->mask))
      add_mode(chan, '-', mode, m->mask);
  add_mode(chan, '+', mode, mask);
  flush_mode(chan, QUICK);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void enforce_bans

(

struct chanset_t *

chan

)

[static]

Definition at line 518 of file chan.c.

References chan_t::ban, botname, botuserhost, chanset_t::channel, HALFOP_CANTDOMODE, IRC_YOUREBANNED, isexempted, kick_all(), maskstruct::mask, match_addr, maskstruct::next, simple_sprintf, and UHOSTLEN.

Referenced by recheck_channel().

{
  char me[UHOSTLEN];
  masklist *b;

  if (HALFOP_CANTDOMODE('b'))
    return;

  simple_sprintf(me, "%s!%s", botname, botuserhost);
  /* Go through all bans, kicking the users. */
  for (b = chan->channel.ban; b && b->mask[0]; b = b->next) {
    if (!match_addr(b->mask, me))
      if (!isexempted(chan, b->mask))
        kick_all(chan, b->mask, IRC_YOUREBANNED, 1);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* getchanmode

(

struct chanset_t *

chan

)

[static]

Definition at line 93 of file chan.c.

References CHANANON, CHANDELJN, CHANINV, CHANINVIS, CHANKEY, CHANLONLY, CHANMODER, CHANMODREG, chanset_t::channel, CHANNOAMSG, CHANNOCLR, CHANNOCTCP, CHANNOMSG, CHANNONOTC, CHANPRIV, CHANREGON, CHANSEC, CHANSTRIP, CHANTOPIC, chan_t::key, chan_t::maxmembers, and chan_t::mode.

Referenced by cmd_channel(), and status_log().

{
  static char s[121];
  int atr, i;

  s[0] = '+';
  i = 1;
  atr = chan->channel.mode;
  if (atr & CHANINV)
    s[i++] = 'i';
  if (atr & CHANPRIV)
    s[i++] = 'p';
  if (atr & CHANSEC)
    s[i++] = 's';
  if (atr & CHANMODER)
    s[i++] = 'm';
  if (atr & CHANNOCLR)
    s[i++] = 'c';
  if (atr & CHANNOCTCP)
    s[i++] = 'C';
  if (atr & CHANREGON)
    s[i++] = 'R';
  if (atr & CHANTOPIC)
    s[i++] = 't';
  if (atr & CHANMODREG)
    s[i++] = 'M';
  if (atr & CHANLONLY)
    s[i++] = 'r';
  if (atr & CHANDELJN)
    s[i++] = 'D';
  if (atr & CHANSTRIP)
    s[i++] = 'u';
  if (atr & CHANNONOTC)
    s[i++] = 'N';
  if (atr & CHANNOAMSG)
    s[i++] = 'T';
  if (atr & CHANINVIS)
    s[i++] = 'd';
  if (atr & CHANNOMSG)
    s[i++] = 'n';
  if (atr & CHANANON)
    s[i++] = 'a';
  if (atr & CHANKEY)
    s[i++] = 'k';
  if (chan->channel.maxmembers != 0)
    s[i++] = 'l';
  s[i] = 0;
  if (chan->channel.key[0])
    i += sprintf(s + i, " %s", chan->channel.key);
  if (chan->channel.maxmembers != 0)
    sprintf(s + i, " %d", chan->channel.maxmembers);
  return s;
}

Here is the caller graph for this function:

static int got315	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1126 of file chan.c.

References botname, CHAN_ACTIVE, CHAN_PEND, CHAN_STOP_CYCLE, chanset_t::channel, channel_pending, clear_channel(), chanset_t::dname, DP_SERVER, dprintf, findchan, ismember, chan_t::key, chanset_t::key, chanset_t::key_prot, LOG_JOIN, LOG_MISC, me_op(), chan_t::members, chanset_t::name, newsplit, putlog, recheck_channel(), chanset_t::status, and sync_members().

{
  char *chname, *key;
  struct chanset_t *chan;

  newsplit(&msg);
  chname = newsplit(&msg);
  chan = findchan(chname);
  if (!chan || !channel_pending(chan)) /* Left channel before we got a 315? */
    return 0;

  sync_members(chan);
  chan->status |= CHAN_ACTIVE;
  chan->status &= ~CHAN_PEND;
  if (!ismember(chan, botname)) {      /* Am I on the channel now?          */
    putlog(LOG_MISC | LOG_JOIN, chan->dname, "Oops, I'm not really on %s.",
           chan->dname);
    clear_channel(chan, 1);
    chan->status &= ~CHAN_ACTIVE;

    key = chan->channel.key[0] ? chan->channel.key : chan->key_prot;
    if (key[0])
      dprintf(DP_SERVER, "JOIN %s %s\n",
              chan->name[0] ? chan->name : chan->dname, key);
    else
      dprintf(DP_SERVER, "JOIN %s\n",
              chan->name[0] ? chan->name : chan->dname);
  } else if (me_op(chan))
    recheck_channel(chan, 1);
  else if (chan->channel.members == 1)
    chan->status |= CHAN_STOP_CYCLE;
  return 0;                            /* Don't check for I-Lines here.     */
}

Here is the call graph for this function:

static int got324	(	char *	from,
		char *	msg
	)			[static]

Definition at line 931 of file chan.c.

References CHAN_ASKEDMODES, CHANANON, CHANDELJN, CHANINV, CHANINVIS, CHANKEY, CHANLONLY, CHANMODER, CHANMODREG, chanset_t::channel, CHANNOAMSG, CHANNOCLR, CHANNOCTCP, CHANNOMSG, CHANNONOTC, CHANPRIV, CHANQUIET, CHANREGON, CHANSEC, CHANSTRIP, CHANTOPIC, DP_SERVER, dprintf, findchan, IRC_UNEXPECTEDMODE, chan_t::key, LOG_MISC, chan_t::maxmembers, chan_t::mode, newsplit, NULL, putlog, recheck_channel_modes(), set_key(), and chanset_t::status.

{
  int i = 1, ok = 0;
  char *p, *q, *chname;
  struct chanset_t *chan;

  newsplit(&msg);
  chname = newsplit(&msg);
  chan = findchan(chname);
  if (!chan) {
    putlog(LOG_MISC, "*", "%s: %s", IRC_UNEXPECTEDMODE, chname);
    dprintf(DP_SERVER, "PART %s\n", chname);
    return 0;
  }
  if (chan->status & CHAN_ASKEDMODES)
    ok = 1;
  chan->status &= ~CHAN_ASKEDMODES;
  chan->channel.mode = 0;
  while (msg[i] != 0) {
    if (msg[i] == 'i')
      chan->channel.mode |= CHANINV;
    if (msg[i] == 'p')
      chan->channel.mode |= CHANPRIV;
    if (msg[i] == 's')
      chan->channel.mode |= CHANSEC;
    if (msg[i] == 'm')
      chan->channel.mode |= CHANMODER;
    if (msg[i] == 'c')
      chan->channel.mode |= CHANNOCLR;
    if (msg[i] == 'C')
      chan->channel.mode |= CHANNOCTCP;
    if (msg[i] == 'R')
      chan->channel.mode |= CHANREGON;
    if (msg[i] == 'M')
      chan->channel.mode |= CHANMODREG;
    if (msg[i] == 'r')
      chan->channel.mode |= CHANLONLY;
    if (msg[i] == 'D')
      chan->channel.mode |= CHANDELJN;
    if (msg[i] == 'u')
      chan->channel.mode |= CHANSTRIP;
    if (msg[i] == 'N')
      chan->channel.mode |= CHANNONOTC;
    if (msg[i] == 'T')
      chan->channel.mode |= CHANNOAMSG;
    if (msg[i] == 'd')
      chan->channel.mode |= CHANINVIS;
    if (msg[i] == 't')
      chan->channel.mode |= CHANTOPIC;
    if (msg[i] == 'n')
      chan->channel.mode |= CHANNOMSG;
    if (msg[i] == 'a')
      chan->channel.mode |= CHANANON;
    if (msg[i] == 'q')
      chan->channel.mode |= CHANQUIET;
    if (msg[i] == 'k') {
      chan->channel.mode |= CHANKEY;
      p = strchr(msg, ' ');
      if (p != NULL) {          /* Test for null key assignment */
        p++;
        q = strchr(p, ' ');
        if (q != NULL) {
          *q = 0;
          set_key(chan, p);
          strcpy(p, q + 1);
        } else {
          set_key(chan, p);
          *p = 0;
        }
      }
      if ((chan->channel.mode & CHANKEY) && (!chan->channel.key[0] ||
          !strcmp("*", chan->channel.key)))
        /* Undernet use to show a blank channel key if one was set when
         * you first joined a channel; however, this has been replaced by
         * an asterisk and this has been agreed upon by other major IRC
         * networks so we'll check for an asterisk here as well
         * (guppy 22Dec2001) */
        chan->status |= CHAN_ASKEDMODES;
    }
    if (msg[i] == 'l') {
      p = strchr(msg, ' ');
      if (p != NULL) {          /* test for null limit assignment */
        p++;
        q = strchr(p, ' ');
        if (q != NULL) {
          *q = 0;
          chan->channel.maxmembers = atoi(p);
          strcpy(p, q + 1);
        } else {
          chan->channel.maxmembers = atoi(p);
          *p = 0;
        }
      }
    }
    i++;
  }
  if (ok)
    recheck_channel_modes(chan);
  return 0;
}

Here is the call graph for this function:

static int got331	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1580 of file chan.c.

References check_tcl_topc, chanset_t::dname, findchan, newsplit, NULL, and set_topic().

{
  char *chname;
  struct chanset_t *chan;

  newsplit(&msg);
  chname = newsplit(&msg);
  chan = findchan(chname);
  if (chan) {
    set_topic(chan, NULL);
    check_tcl_topc("*", "*", NULL, chan->dname, "");
  }
  return 0;
}

Here is the call graph for this function:

static int got332	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1598 of file chan.c.

References check_tcl_topc, chanset_t::dname, findchan, fixcolon, newsplit, NULL, and set_topic().

{
  struct chanset_t *chan;
  char *chname;

  newsplit(&msg);
  chname = newsplit(&msg);
  chan = findchan(chname);
  if (chan) {
    fixcolon(msg);
    set_topic(chan, msg);
    check_tcl_topc("*", "*", NULL, chan->dname, msg);
  }
  return 0;
}

Here is the call graph for this function:

static int got346	(	char *	from,
		char *	origmsg
	)			[static]

Definition at line 1256 of file chan.c.

References channel_active, channel_pending, findchan, newinvite, newsplit, and use_invites.

{
  char *invite, *who, *chname, buf[511], *msg;
  struct chanset_t *chan;

  strncpy(buf, origmsg, 510);
  buf[510] = 0;
  msg = buf;
  if (use_invites == 0)
    return 0;
  newsplit(&msg);
  chname = newsplit(&msg);
  chan = findchan(chname);
  if (!chan || !(channel_pending(chan) || channel_active(chan)))
    return 0;
  invite = newsplit(&msg);
  who = newsplit(&msg);
  /* Extended timestamp format? */
  if (who[0])
    newinvite(chan, invite, who);
  else
    newinvite(chan, invite, "existent");
  return 0;
}

static int got347	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1284 of file chan.c.

References CHAN_ASKED_INVITED, findchan, chanset_t::ircnet_status, newsplit, and use_invites.

{
  struct chanset_t *chan;
  char *chname;

  if (use_invites == 1) {
    newsplit(&msg);
    chname = newsplit(&msg);
    chan = findchan(chname);
    if (chan)
      chan->ircnet_status &= ~CHAN_ASKED_INVITED;
  }
  return 0;
}

static int got348	(	char *	from,
		char *	origmsg
	)			[static]

Definition at line 1209 of file chan.c.

References channel_active, channel_pending, findchan, newexempt, newsplit, and use_exempts.

{
  char *exempt, *who, *chname, buf[511], *msg;
  struct chanset_t *chan;

  if (use_exempts == 0)
    return 0;

  strncpy(buf, origmsg, 510);
  buf[510] = 0;
  msg = buf;
  newsplit(&msg);
  chname = newsplit(&msg);
  chan = findchan(chname);
  if (!chan || !(channel_pending(chan) || channel_active(chan)))
    return 0;
  exempt = newsplit(&msg);
  who = newsplit(&msg);
  /* Extended timestamp format? */
  if (who[0])
    newexempt(chan, exempt, who);
  else
    newexempt(chan, exempt, "existent");
  return 0;
}

static int got349	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1238 of file chan.c.

References CHAN_ASKED_EXEMPTS, findchan, chanset_t::ircnet_status, newsplit, and use_exempts.

{
  struct chanset_t *chan;
  char *chname;

  if (use_exempts == 1) {
    newsplit(&msg);
    chname = newsplit(&msg);
    chan = findchan(chname);
    if (chan)
      chan->ircnet_status &= ~CHAN_ASKED_EXEMPTS;
  }
  return 0;
}

static int got352	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1079 of file chan.c.

References findchan, got352or4(), newsplit, and user.

{
  char *nick, *user, *host, *chname, *flags;
  struct chanset_t *chan;

  newsplit(&msg);               /* Skip my nick - effeciently */
  chname = newsplit(&msg);      /* Grab the channel */
  chan = findchan(chname);      /* See if I'm on channel */
  if (chan) {                   /* Am I? */
    user = newsplit(&msg);      /* Grab the user */
    host = newsplit(&msg);      /* Grab the host */
    newsplit(&msg);             /* Skip the server */
    nick = newsplit(&msg);      /* Grab the nick */
    flags = newsplit(&msg);     /* Grab the flags */
    got352or4(chan, user, host, nick, flags);
  }
  return 0;
}

Here is the call graph for this function:

static int got352or4	(	struct chanset_t *	chan,
		char *	user,
		char *	host,
		char *	nick,
		char *	flags
	)			[static]

Definition at line 1032 of file chan.c.

References any_ops(), botuserhost, CHANHALFOP, CHANOP, CHANVOICE, check_tcl_need(), memstruct::delay, chanset_t::dname, do_tcl, memstruct::flags, get_user_by_host, ismember, memstruct::joined, memstruct::last, match_my_nick(), me_op(), chanset_t::need_op, newmember(), memstruct::nick, now, NULL, opchars, simple_sprintf, memstruct::split, STOPWHO, UHOSTLEN, memstruct::user, memstruct::userhost, WASHALFOP, WASOP, and WHO_SYNCED.

Referenced by got352(), and got354().

{
  char userhost[UHOSTLEN];
  memberlist *m;

  m = ismember(chan, nick);     /* In my channel list copy? */
  if (!m) {                     /* Nope, so update */
    m = newmember(chan);        /* Get a new channel entry */
    m->joined = m->split = m->delay = 0L;       /* Don't know when he joined */
    m->flags = 0;               /* No flags for now */
    m->last = now;              /* Last time I saw him */
  }
  strcpy(m->nick, nick);        /* Store the nick in list */
  /* Store the userhost */
  simple_sprintf(m->userhost, "%s@%s", user, host);
  simple_sprintf(userhost, "%s!%s", nick, m->userhost);
  /* Combine n!u@h */
  m->user = NULL;               /* No handle match (yet) */
  if (match_my_nick(nick))      /* Is it me? */
    strcpy(botuserhost, m->userhost);   /* Yes, save my own userhost */
  m->flags |= WHO_SYNCED;
  if (strpbrk(flags, opchars) != NULL)
    m->flags |= (CHANOP | WASOP);
  else
    m->flags &= ~(CHANOP | WASOP);
  if (strchr(flags, '%') != NULL)
    m->flags |= (CHANHALFOP | WASHALFOP);
  else
    m->flags &= ~(CHANHALFOP | WASHALFOP);
  if (strchr(flags, '+') != NULL)
    m->flags |= CHANVOICE;
  else
    m->flags &= ~CHANVOICE;
  if (!(m->flags & (CHANVOICE | CHANOP | CHANHALFOP)))
    m->flags |= STOPWHO;
  if (match_my_nick(nick) && any_ops(chan) && !me_op(chan)) {
    check_tcl_need(chan->dname, "op");
    if (chan->need_op[0])
      do_tcl("need-op", chan->need_op);
  }
  m->user = get_user_by_host(userhost);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int got354	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1100 of file chan.c.

References CHANMETA, findchan, got352or4(), newsplit, NULL, use_354, and user.

{
  char *nick, *user, *host, *chname, *flags;
  struct chanset_t *chan;

  if (use_354) {
    newsplit(&msg);             /* Skip my nick - effeciently */
    if (msg[0] && (strchr(CHANMETA, msg[0]) != NULL)) {
      chname = newsplit(&msg);  /* Grab the channel */
      chan = findchan(chname);  /* See if I'm on channel */
      if (chan) {               /* Am I? */
        user = newsplit(&msg);  /* Grab the user */
        host = newsplit(&msg);  /* Grab the host */
        nick = newsplit(&msg);  /* Grab the nick */
        flags = newsplit(&msg); /* Grab the flags */
        got352or4(chan, user, host, nick, flags);
      }
    }
  }
  return 0;
}

Here is the call graph for this function:

static int got367	(	char *	from,
		char *	origmsg
	)			[static]

Definition at line 1163 of file chan.c.

References channel_active, channel_pending, findchan, newban, and newsplit.

{
  char *ban, *who, *chname, buf[511], *msg;
  struct chanset_t *chan;

  strncpy(buf, origmsg, 510);
  buf[510] = 0;
  msg = buf;
  newsplit(&msg);
  chname = newsplit(&msg);
  chan = findchan(chname);
  if (!chan || !(channel_pending(chan) || channel_active(chan)))
    return 0;
  ban = newsplit(&msg);
  who = newsplit(&msg);
  /* Extended timestamp format? */
  if (who[0])
    newban(chan, ban, who);
  else
    newban(chan, ban, "existent");
  return 0;
}

static int got368	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1189 of file chan.c.

References CHAN_ASKEDBANS, findchan, newsplit, and chanset_t::status.

{
  struct chanset_t *chan;
  char *chname;

  /* Okay, now add bans that i want, which aren't set yet */
  newsplit(&msg);
  chname = newsplit(&msg);
  chan = findchan(chname);
  if (chan)
    chan->status &= ~CHAN_ASKEDBANS;
  /* If i sent a mode -b on myself (deban) in got367, either
   * resetbans() or recheck_bans() will flush that.
   */
  return 0;
}

static int got403	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1317 of file chan.c.

References chanset_t::dname, DP_SERVER, dprintf, findchan, findchan_by_dname, LOG_MISC, newsplit, and putlog.

{
  char *chname;
  struct chanset_t *chan;

  newsplit(&msg);
  chname = newsplit(&msg);
  if (chname && chname[0] == '!') {
    chan = findchan_by_dname(chname);
    if (!chan) {
      chan = findchan(chname);
      if (!chan)
        return 0;               /* Ignore it */
      /* We have the channel unique name, so we have attempted to join
       * a specific !channel that doesnt exist. Now attempt to join the
       * channel using it's short name.
       */
      putlog(LOG_MISC, "*",
             "Unique channel %s does not exist... Attempting to join with "
             "short name.", chname);
      dprintf(DP_SERVER, "JOIN %s\n", chan->dname);
    } else {
      /* We have found the channel, so the server has given us the short
       * name. Prefix another '!' to it, and attempt the join again...
       */
      putlog(LOG_MISC, "*",
             "Channel %s does not exist... Attempting to create it.", chname);
      dprintf(DP_SERVER, "JOIN !%s\n", chan->dname);
    }
  }
  return 0;
}

static int got405	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1301 of file chan.c.

References IRC_TOOMANYCHANS, LOG_MISC, newsplit, and putlog.

{
  char *chname;

  newsplit(&msg);
  chname = newsplit(&msg);
  putlog(LOG_MISC, "*", IRC_TOOMANYCHANS, chname);
  return 0;
}

static int got471	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1352 of file chan.c.

References CHANNEL_ID_LEN, check_tcl_need(), chanset_t::dname, do_tcl, findchan_by_dname, IRC_CHANFULL, LOG_JOIN, chanset_t::need_limit, newsplit, and putlog.

{
  char *chname;
  struct chanset_t *chan;

  newsplit(&msg);
  chname = newsplit(&msg);
  /* !channel short names (also referred to as 'description names'
   * can be received by skipping over the unique ID.
   */
  if ((chname[0] == '!') && (strlen(chname) > CHANNEL_ID_LEN)) {
    chname += CHANNEL_ID_LEN;
    chname[0] = '!';
  }
  /* We use dname because name is first set on JOIN and we might not
   * have joined the channel yet.
   */
  chan = findchan_by_dname(chname);
  if (chan) {
    putlog(LOG_JOIN, chan->dname, IRC_CHANFULL, chan->dname);
    check_tcl_need(chan->dname, "limit");

    chan = findchan_by_dname(chname);
    if (!chan)
      return 0;

    if (chan->need_limit[0])
      do_tcl("need-limit", chan->need_limit);
  } else
    putlog(LOG_JOIN, chname, IRC_CHANFULL, chname);
  return 0;
}

Here is the call graph for this function:

static int got473	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1387 of file chan.c.

References CHANNEL_ID_LEN, check_tcl_need(), chanset_t::dname, do_tcl, findchan_by_dname, IRC_CHANINVITEONLY, LOG_JOIN, chanset_t::need_invite, newsplit, and putlog.

{
  char *chname;
  struct chanset_t *chan;

  newsplit(&msg);
  chname = newsplit(&msg);
  /* !channel short names (also referred to as 'description names'
   * can be received by skipping over the unique ID.
   */
  if ((chname[0] == '!') && (strlen(chname) > CHANNEL_ID_LEN)) {
    chname += CHANNEL_ID_LEN;
    chname[0] = '!';
  }
  /* We use dname because name is first set on JOIN and we might not
   * have joined the channel yet.
   */
  chan = findchan_by_dname(chname);
  if (chan) {
    putlog(LOG_JOIN, chan->dname, IRC_CHANINVITEONLY, chan->dname);
    check_tcl_need(chan->dname, "invite");

    chan = findchan_by_dname(chname);
    if (!chan)
      return 0;

    if (chan->need_invite[0])
      do_tcl("need-invite", chan->need_invite);
  } else
    putlog(LOG_JOIN, chname, IRC_CHANINVITEONLY, chname);
  return 0;
}

Here is the call graph for this function:

static int got474	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1422 of file chan.c.

References CHANNEL_ID_LEN, check_tcl_need(), chanset_t::dname, do_tcl, findchan_by_dname, IRC_BANNEDFROMCHAN, LOG_JOIN, chanset_t::need_unban, newsplit, and putlog.

{
  char *chname;
  struct chanset_t *chan;

  newsplit(&msg);
  chname = newsplit(&msg);
  /* !channel short names (also referred to as 'description names'
   * can be received by skipping over the unique ID.
   */
  if ((chname[0] == '!') && (strlen(chname) > CHANNEL_ID_LEN)) {
    chname += CHANNEL_ID_LEN;
    chname[0] = '!';
  }
  /* We use dname because name is first set on JOIN and we might not
   * have joined the channel yet.
   */
  chan = findchan_by_dname(chname);
  if (chan) {
    putlog(LOG_JOIN, chan->dname, IRC_BANNEDFROMCHAN, chan->dname);
    check_tcl_need(chan->dname, "unban");

    chan = findchan_by_dname(chname);
    if (!chan)
      return 0;

    if (chan->need_unban[0])
      do_tcl("need-unban", chan->need_unban);
  } else
    putlog(LOG_JOIN, chname, IRC_BANNEDFROMCHAN, chname);
  return 0;
}

Here is the call graph for this function:

static int got475	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1457 of file chan.c.

References chanset_t::channel, CHANNEL_ID_LEN, channel_malloc(), check_tcl_need(), chanset_t::dname, do_tcl, DP_SERVER, dprintf, findchan_by_dname, IRC_BADCHANKEY, chan_t::key, chanset_t::key_prot, LOG_JOIN, chanset_t::need_key, newsplit, nfree, and putlog.

{
  char *chname;
  struct chanset_t *chan;

  newsplit(&msg);
  chname = newsplit(&msg);
  /* !channel short names (also referred to as 'description names'
   * can be received by skipping over the unique ID.
   */
  if ((chname[0] == '!') && (strlen(chname) > CHANNEL_ID_LEN)) {
    chname += CHANNEL_ID_LEN;
    chname[0] = '!';
  }
  /* We use dname because name is first set on JOIN and we might not
   * have joined the channel yet.
   */
  chan = findchan_by_dname(chname);
  if (chan) {
    putlog(LOG_JOIN, chan->dname, IRC_BADCHANKEY, chan->dname);
    if (chan->channel.key[0]) {
      nfree(chan->channel.key);
      chan->channel.key = (char *) channel_malloc(1);
      chan->channel.key[0] = 0;

      if (chan->key_prot[0])
        dprintf(DP_SERVER, "JOIN %s %s\n", chan->dname, chan->key_prot);
      else
        dprintf(DP_SERVER, "JOIN %s\n", chan->dname);
    } else {
      check_tcl_need(chan->dname, "key");

      chan = findchan_by_dname(chname);
      if (!chan)
        return 0;

      if (chan->need_key[0])
        do_tcl("need-key", chan->need_key);
    }
  } else
    putlog(LOG_JOIN, chname, IRC_BADCHANKEY, chname);
  return 0;
}

Here is the call graph for this function:

static int gotinvite	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1503 of file chan.c.

References chanset_t::channel, channel_active, channel_inactive, channel_pending, chanset_t::dname, DP_HELP, DP_SERVER, dprintf, findchan, findchan_by_dname, fixcolon, chan_t::key, chanset_t::key, chanset_t::key_prot, last_invchan, last_invtime, LOG_MISC, chanset_t::name, newsplit, now, putlog, rfc_casecmp, and splitnick.

{
  char *nick, *key;
  struct chanset_t *chan;

  newsplit(&msg);
  fixcolon(msg);
  nick = splitnick(&from);
  if (!rfc_casecmp(last_invchan, msg))
    if (now - last_invtime < 30)
      return 0; /* Two invites to the same channel in 30 seconds? */
  putlog(LOG_MISC, "*", "%s!%s invited me to %s", nick, from, msg);
  strncpy(last_invchan, msg, 299);
  last_invchan[299] = 0;
  last_invtime = now;
  chan = findchan(msg);
  if (!chan)
    /* Might be a short-name */
    chan = findchan_by_dname(msg);

  if (chan && (channel_pending(chan) || channel_active(chan)))
    dprintf(DP_HELP, "NOTICE %s :I'm already here.\n", nick);
  else if (chan && !channel_inactive(chan)) {

    key = chan->channel.key[0] ? chan->channel.key : chan->key_prot;
    if (key[0])
      dprintf(DP_SERVER, "JOIN %s %s\n",
              chan->name[0] ? chan->name : chan->dname, key);
    else
      dprintf(DP_SERVER, "JOIN %s\n",
              chan->name[0] ? chan->name : chan->dname);
  }
  return 0;
}

static int gotjoin	(	char *	from,
		char *	chname
	)			[static]

Definition at line 1670 of file chan.c.

References add_mode, chanset_t::aop_min, chan_t::ban, chanset_t::bans, CHAN_ACTIVE, chan_autohalfop, chan_autoop, chan_dehalfop, chan_deop, chan_friend, chan_gvoice, chan_halfop, chan_hashalfop, chan_hasop, CHAN_INACTIVE, CHAN_JUPED, chan_kick, chan_op, CHAN_PEND, chan_quiet, CHAN_RESETALL, CHAN_RESETTOPIC, chan_sentkick, CHAN_STOP_CYCLE, chan_voice, chanset_t::channel, channel_active, channel_autohalfop, channel_autoop, channel_autovoice, channel_enforcebans, channel_greet, CHANNEL_ID_LEN, channel_inactive, channel_pending, check_exemptlist(), check_tcl_join, check_tcl_rejn, memstruct::delay, detect_chan_flood(), chanset_t::dname, DP_HELP, DP_MODE, DP_SERVER, dprintf, egg_snprintf, egg_strcasecmp, chanset_t::exempts, findchan, findchan_by_dname, fixcolon, userrec::flags, memstruct::flags, FLOOD_JOIN, FR_CHAN, FR_GLOBAL, get_chanrec(), get_handle_chaninfo(), get_user, get_user_by_host, get_user_flagrec, glob_autohalfop, glob_autoop, glob_friend, glob_gvoice, glob_halfop, glob_kick, glob_op, glob_voice, global_bans, global_exempts, global_invites, userrec::handle, chanset_t::invites, IRC_COMMENTKICK, IRC_YOUREBANNED, isexempted, ismember, memstruct::joined, killmember(), memstruct::last, laston_info::laston, chanuserrec::laston, LOG_JOIN, LOG_MISC, maskstruct::mask, match_addr, match_my_nick(), me_halfop(), me_op(), chanset_t::name, newmember(), maskstruct::next, nfree, memstruct::nick, nmalloc, no_chanrec_info, NOHALFOPS_MODES, now, NULL, putlog, quickban(), refresh_ban_kick(), refresh_invite(), reset_chan_info(), SENTHALFOP, SENTKICK, SENTOP, SENTVOICE, set_delay(), set_handle_laston(), memstruct::split, splitnick, chanset_t::status, STOPWHO, u_match_mask(), UHOSTLEN, use_exempts, use_info, memstruct::user, USER_BOT, USERENTRY_COMMENT, USERENTRY_INFO, USERENTRY_LASTON, memstruct::userhost, wait_info, WASHALFOP, and WASOP.

{
  char *nick, *p, buf[UHOSTLEN], *uhost = buf;
  char *ch_dname = NULL;
  struct chanset_t *chan;
  memberlist *m;
  masklist *b;
  struct userrec *u;
  struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };

  fixcolon(chname);
  chan = findchan(chname);
  if (!chan && chname[0] == '!') {
    /* As this is a !channel, we need to search for it by display (short)
     * name now. This will happen when we initially join the channel, as we
     * dont know the unique channel name that the server has made up. <cybah>
     */
    int l_chname = strlen(chname);

    if (l_chname > (CHANNEL_ID_LEN + 1)) {
      ch_dname = nmalloc(l_chname + 1);
      if (ch_dname) {
        egg_snprintf(ch_dname, l_chname + 2, "!%s",
                     chname + (CHANNEL_ID_LEN + 1));
        chan = findchan_by_dname(ch_dname);
        if (!chan) {
          /* Hmm.. okay. Maybe the admin's a genius and doesn't know the
           * difference between id and descriptive channel names. Search
           * the channel name in the dname list using the id-name.
           */
          chan = findchan_by_dname(chname);
          if (chan) {
            /* Duh, I was right. Mark this channel as inactive and log
             * the incident.
             */
            chan->status |= CHAN_INACTIVE;
            putlog(LOG_MISC, "*", "Deactivated channel %s, because it uses "
                   "an ID channel-name. Use the descriptive name instead.",
                   chname);
            dprintf(DP_SERVER, "PART %s\n", chname);
            goto exit;
          }
        }
      }
    }
  } else if (!chan) {
    /* As this is not a !chan, we need to search for it by display name now.
     * Unlike !chan's, we dont need to remove the unique part.
     */
    chan = findchan_by_dname(chname);
  }

  if (!chan || channel_inactive(chan)) {
    strcpy(uhost, from);
    nick = splitnick(&uhost);
    if (match_my_nick(nick)) {
      putlog(LOG_MISC, "*", "joined %s but didn't want to!", chname);
      dprintf(DP_MODE, "PART %s\n", chname);
    }
  } else if (!channel_pending(chan)) {
    chan->status &= ~CHAN_STOP_CYCLE;
    strcpy(uhost, from);
    nick = splitnick(&uhost);
    detect_chan_flood(nick, uhost, from, chan, FLOOD_JOIN, NULL);

    chan = findchan(chname);
    if (!chan) {
      if (ch_dname)
        chan = findchan_by_dname(ch_dname);
      else
        chan = findchan_by_dname(chname);
    }
    if (!chan)
      /* The channel doesn't exist anymore, so get out of here. */
      goto exit;

    /* Grab last time joined before we update it */
    u = get_user_by_host(from);
    get_user_flagrec(u, &fr, chan->dname);      /* Lam: fix to work with !channels */
    if (!channel_active(chan) && !match_my_nick(nick)) {
      /* uh, what?!  i'm on the channel?! */
      putlog(LOG_MISC, chan->dname,
             "confused bot: guess I'm on %s and didn't realize it",
             chan->dname);
      chan->status |= CHAN_ACTIVE;
      chan->status &= ~CHAN_PEND;
      reset_chan_info(chan, CHAN_RESETALL);
    } else {
      m = ismember(chan, nick);
      if (m && m->split && !egg_strcasecmp(m->userhost, uhost)) {
        check_tcl_rejn(nick, uhost, u, chan->dname);

        chan = findchan(chname);
        if (!chan) {
          if (ch_dname)
            chan = findchan_by_dname(ch_dname);
          else
            chan = findchan_by_dname(chname);
        }
        if (!chan)
          /* The channel doesn't exist anymore, so get out of here. */
          goto exit;

        /* The tcl binding might have deleted the current user. Recheck. */
        u = get_user_by_host(from);
        m->split = 0;
        m->last = now;
        m->delay = 0L;
        m->flags = (chan_hasop(m) ? WASOP : 0) | (chan_hashalfop(m) ? WASHALFOP : 0);
        m->user = u;
        set_handle_laston(chan->dname, u, now);
        m->flags |= STOPWHO;
        putlog(LOG_JOIN, chan->dname, "%s (%s) returned to %s.", nick, uhost,
               chan->dname);
      } else {
        if (m)
          killmember(chan, nick);
        m = newmember(chan);
        m->joined = now;
        m->split = 0L;
        m->flags = 0;
        m->last = now;
        m->delay = 0L;
        strcpy(m->nick, nick);
        strcpy(m->userhost, uhost);
        m->user = u;
        m->flags |= STOPWHO;

        check_tcl_join(nick, uhost, u, chan->dname);

        /* The tcl binding might have deleted the current user and the
         * current channel, so we'll now have to re-check whether they
         * both still exist.
         */
        chan = findchan(chname);
        if (!chan) {
          if (ch_dname)
            chan = findchan_by_dname(ch_dname);
          else
            chan = findchan_by_dname(chname);
        }
        if (!chan)
          /* The channel doesn't exist anymore, so get out of here. */
          goto exit;

        /* The record saved in the channel record always gets updated,
         * so we can use that. */
        u = m->user;

        if (match_my_nick(nick)) {
          /* It was me joining! Need to update the channel record with the
           * unique name for the channel (as the server see's it). <cybah>
           */
          strncpy(chan->name, chname, 81);
          chan->name[80] = 0;
          chan->status &= ~CHAN_JUPED;

          /* ... and log us joining. Using chan->dname for the channel is
           * important in this case. As the config file will never contain
           * logs with the unique name.
           */
          if (chname[0] == '!')
            putlog(LOG_JOIN | LOG_MISC, chan->dname, "%s joined %s (%s)",
                   nick, chan->dname, chname);
          else
            putlog(LOG_JOIN | LOG_MISC, chan->dname, "%s joined %s.", nick,
                   chname);
          reset_chan_info(chan, (CHAN_RESETALL & ~CHAN_RESETTOPIC));
        } else {
          struct chanuserrec *cr;

          putlog(LOG_JOIN, chan->dname,
                 "%s (%s) joined %s.", nick, uhost, chan->dname);
          /* Don't re-display greeting if they've been on the channel
           * recently.
           */
          if (u) {
            struct laston_info *li = 0;

            cr = get_chanrec(m->user, chan->dname);
            if (!cr && no_chanrec_info)
              li = get_user(&USERENTRY_LASTON, m->user);
            if (channel_greet(chan) && use_info &&
                ((cr && now - cr->laston > wait_info) ||
                (no_chanrec_info && (!li || now - li->laston > wait_info)))) {
              char s1[512], *s;

              if (!(u->flags & USER_BOT)) {
                s = get_user(&USERENTRY_INFO, u);
                get_handle_chaninfo(u->handle, chan->dname, s1);
                /* Locked info line overides non-locked channel specific
                 * info line.
                 */
                if (!s || (s1[0] && (s[0] != '@' || s1[0] == '@')))
                  s = s1;
                if (s[0] == '@')
                  s++;
                if (s && s[0])
                  dprintf(DP_HELP, "PRIVMSG %s :[%s] %s\n", chan->name, nick,
                          s);
              }
            }
          }
          set_handle_laston(chan->dname, u, now);
        }
      }
      if (me_op(chan) || me_halfop(chan)) {
        /* Check for and reset exempts and invites.
         *
         * This will require further checking to account for when to use the
         * various modes.
         */
        if ((me_op(chan) || (strchr(NOHALFOPS_MODES, 'I') == NULL)) &&
            (u_match_mask(global_invites, from) ||
            u_match_mask(chan->invites, from)))
          refresh_invite(chan, from);
        if ((me_op(chan) || (strchr(NOHALFOPS_MODES, 'b') == NULL)) &&
            (!use_exempts || (!u_match_mask(global_exempts, from) &&
            !u_match_mask(chan->exempts, from)))) {
          if (channel_enforcebans(chan) && !chan_op(fr) && !glob_op(fr) &&
              !glob_friend(fr) && !chan_friend(fr) && !chan_sentkick(m) &&
              (!use_exempts || !isexempted(chan, from)) && (me_op(chan) ||
              (me_halfop(chan) && !chan_hasop(m)))) {
            for (b = chan->channel.ban; b->mask[0]; b = b->next) {
              if (match_addr(b->mask, from)) {
                dprintf(DP_SERVER, "KICK %s %s :%s\n", chname, m->nick,
                        IRC_YOUREBANNED);
                m->flags |= SENTKICK;
                goto exit;
              }
            }
          }
          /* If it matches a ban, dispose of them. */
          if (u_match_mask(global_bans, from) || u_match_mask(chan->bans, from))
            refresh_ban_kick(chan, from, nick);
          else if (!chan_sentkick(m) && (glob_kick(fr) || chan_kick(fr)) &&
                   (me_op(chan) || (me_halfop(chan) && !chan_hasop(m)))) {
            check_exemptlist(chan, from);
            quickban(chan, from);
            p = get_user(&USERENTRY_COMMENT, m->user);
            dprintf(DP_MODE, "KICK %s %s :%s\n", chname, nick,
                    (p && (p[0] != '@')) ? p : IRC_COMMENTKICK);
            m->flags |= SENTKICK;
          }
        }
#ifdef NO_HALFOP_CHANMODES
        if (me_op(chan)) {
#endif
        if ((me_op(chan) || (strchr(NOHALFOPS_MODES, 'o') == NULL)) &&
            (chan_op(fr) || (glob_op(fr) && !chan_deop(fr))) &&
            (channel_autoop(chan) || glob_autoop(fr) || chan_autoop(fr))) {
          if (!chan->aop_min)
            add_mode(chan, '+', 'o', nick);
          else {
            set_delay(chan, nick);
            m->flags |= SENTOP;
          }
        } else if ((me_op(chan) || (strchr(NOHALFOPS_MODES, 'h') == NULL)) &&
                   (chan_halfop(fr) || (glob_halfop(fr) &&
                   !chan_dehalfop(fr))) && (channel_autohalfop(chan) ||
                   glob_autohalfop(fr) || chan_autohalfop(fr))) {
          if (!chan->aop_min)
            add_mode(chan, '+', 'h', nick);
          else {
            set_delay(chan, nick);
            m->flags |= SENTHALFOP;
          }
        } else if ((me_op(chan) || (strchr(NOHALFOPS_MODES, 'v') == NULL)) &&
                   ((channel_autovoice(chan) && (chan_voice(fr) ||
                   (glob_voice(fr) && !chan_quiet(fr)))) ||
                   ((glob_gvoice(fr) || chan_gvoice(fr)) &&
                   !chan_quiet(fr)))) {
          if (!chan->aop_min)
            add_mode(chan, '+', 'v', nick);
          else {
            set_delay(chan, nick);
            m->flags |= SENTVOICE;
          }
        }
#ifdef NO_HALFOP_CHANMODES
        }
#endif
      }
    }
  }

exit:
  if (ch_dname)
    nfree(ch_dname);
  return 0;
}

Here is the call graph for this function:

static int gotkick	(	char *	from,
		char *	origmsg
	)			[static]

Definition at line 2029 of file chan.c.

References CHAN_ACTIVE, CHAN_PEND, chanset_t::channel, channel_active, channel_inactive, channel_pending, check_lonely_channel(), check_tcl_kick(), clear_channel(), detect_chan_flood(), chanset_t::dname, DP_SERVER, dprintf, findchan, fixcolon, FLOOD_KICK, FR_CHAN, FR_GLOBAL, get_user_by_host, get_user_flagrec, ismember, chan_t::key, chanset_t::key_prot, killmember(), memstruct::last, LOG_MODES, match_my_nick(), maybe_revenge(), chanset_t::name, newsplit, memstruct::nick, now, putlog, REVENGE_KICK, set_handle_laston(), simple_sprintf, splitnick, chanset_t::status, UHOSTLEN, and memstruct::userhost.

{
  char *nick, *whodid, *chname, s1[UHOSTLEN], buf[UHOSTLEN], *uhost = buf;
  char buf2[511], *msg, *key;
  memberlist *m;
  struct chanset_t *chan;
  struct userrec *u;
  struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };

  strncpy(buf2, origmsg, 510);
  buf2[510] = 0;
  msg = buf2;
  chname = newsplit(&msg);
  chan = findchan(chname);
  if (!chan)
    return 0;
  nick = newsplit(&msg);
  if (match_my_nick(nick) && channel_pending(chan) &&
      !channel_inactive(chan)) {
    chan->status &= ~(CHAN_ACTIVE | CHAN_PEND);

    key = chan->channel.key[0] ? chan->channel.key : chan->key_prot;
    if (key[0])
      dprintf(DP_SERVER, "JOIN %s %s\n",
              chan->name[0] ? chan->name : chan->dname, key);
    else
      dprintf(DP_SERVER, "JOIN %s\n",
              chan->name[0] ? chan->name : chan->dname);
    clear_channel(chan, 1);
    return 0;                   /* rejoin if kicked before getting needed info <Wcc[08/08/02]> */
  }
  if (channel_active(chan)) {
    fixcolon(msg);
    u = get_user_by_host(from);
    strcpy(uhost, from);
    whodid = splitnick(&uhost);
    detect_chan_flood(whodid, uhost, from, chan, FLOOD_KICK, nick);

    chan = findchan(chname);
    if (!chan)
      return 0;

    m = ismember(chan, whodid);
    if (m)
      m->last = now;
    /* This _needs_ to use chan->dname <cybah> */
    get_user_flagrec(u, &fr, chan->dname);
    set_handle_laston(chan->dname, u, now);
    check_tcl_kick(whodid, uhost, u, chan->dname, nick, msg);

    chan = findchan(chname);
    if (!chan)
      return 0;

    m = ismember(chan, nick);
    if (m) {
      struct userrec *u2;

      simple_sprintf(s1, "%s!%s", m->nick, m->userhost);
      u2 = get_user_by_host(s1);
      set_handle_laston(chan->dname, u2, now);
      maybe_revenge(chan, from, s1, REVENGE_KICK);
    }
    putlog(LOG_MODES, chan->dname, "%s kicked from %s by %s: %s", s1,
           chan->dname, from, msg);
    /* Kicked ME?!? the sods! */
    if (match_my_nick(nick) && !channel_inactive(chan)) {
      chan->status &= ~(CHAN_ACTIVE | CHAN_PEND);

      key = chan->channel.key[0] ? chan->channel.key : chan->key_prot;
      if (key[0])
        dprintf(DP_SERVER, "JOIN %s %s\n",
                chan->name[0] ? chan->name : chan->dname, key);
      else
        dprintf(DP_SERVER, "JOIN %s\n",
                chan->name[0] ? chan->name : chan->dname);
      clear_channel(chan, 1);
    } else {
      killmember(chan, nick);
      check_lonely_channel(chan);
    }
  }
  return 0;
}

Here is the call graph for this function:

static int gotmsg	(	char *	from,
		char *	msg
	)			[static]

Definition at line 2285 of file chan.c.

References addignore, answer_ctcp, ban_fun, chanset_t::ban_time, botnetnick, chan_deop, chan_friend, chan_hasop, chan_op, chan_sentkick, CHANMETA, channel_dontkickops, check_exemptlist(), check_tcl_ctcp, check_tcl_pub(), check_tcl_pubm(), count_ctcp, ctcp_mode, ctcp_reply, detect_avalanche(), detect_chan_flood(), chanset_t::dname, DP_HELP, DP_SERVER, dprintf, exclusive_binds, chanset_t::exempts, findchan, fixcolon, memstruct::flags, FLOOD_CTCP, FLOOD_PRIVMSG, flud_ctcp_thr, flud_ctcp_time, FR_CHAN, FR_GLOBAL, get_user_by_host, get_user_flagrec, glob_friend, glob_op, global_exempts, ignore_time, IRC_FUNKICK, ismember, kick_fun, last_ctcp, LOG_MODES, LOG_PUBLIC, match_ignore, me_halfop(), me_op(), chanset_t::name, newsplit, now, NULL, putlog, quickban(), SENTKICK, simple_sprintf, splitnick, trigger_on_ignore, u_addban(), u_match_mask(), UHOSTLEN, update_idle(), and use_exempts.

{
  char *to, *realto, buf[UHOSTLEN], *nick, buf2[512], *uhost = buf, *p, *p1,
       *code, *ctcp;
  int ctcp_count = 0, ignoring;
  struct chanset_t *chan;
  struct userrec *u;
  memberlist *m;
  struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };

  /* Only handle if message is to a channel, or to @#channel. */
  /* FIXME: Properly handle ovNotices (@+#channel), vNotices (+#channel), etc. */
  if (!strchr(CHANMETA "@", msg[0]))
    return 0;

  to = newsplit(&msg);
  realto = (to[0] == '@') ? to + 1 : to;
  chan = findchan(realto);
  if (!chan)
    return 0; /* Unknown channel; don't process. */

  fixcolon(msg);
  strcpy(uhost, from);
  nick = splitnick(&uhost);
  ignoring = match_ignore(from);
  /* Only check if flood-ctcp is active */
  if (flud_ctcp_thr && detect_avalanche(msg)) {
    u = get_user_by_host(from);
    get_user_flagrec(u, &fr, chan->dname);
    m = ismember(chan, nick);
    /* Discard -- kick user if it was to the channel */
    if (m && (me_op(chan) || (me_halfop(chan) && !chan_hasop(m))) &&
        !chan_sentkick(m) && !chan_friend(fr) && !glob_friend(fr) &&
        !(channel_dontkickops(chan) && (chan_op(fr) || (glob_op(fr) &&
        !chan_deop(fr)))) && !(use_exempts && ban_fun &&
        (u_match_mask(global_exempts, from) ||
        u_match_mask(chan->exempts, from)))) {
      if (ban_fun) {
        check_exemptlist(chan, from);
        u_addban(chan, quickban(chan, uhost), botnetnick, IRC_FUNKICK,
                 now + (60 * chan->ban_time), 0);
      }
      if (kick_fun) {
        /* This can induce kickflood - arthur2 */
        dprintf(DP_SERVER, "KICK %s %s :%s\n", chan->name, nick, IRC_FUNKICK);
        m->flags |= SENTKICK;
      }
    }
    if (!ignoring) {
      putlog(LOG_MODES, "*", "Avalanche from %s!%s in %s - ignoring",
             nick, uhost, chan->dname);
      p = strchr(uhost, '@');
      if (p)
        p++;
      else
        p = uhost;
      simple_sprintf(buf2, "*!*@%s", p);
      addignore(buf2, botnetnick, "ctcp avalanche", now + (60 * ignore_time));
    }
    return 0;
  }
  /* Check for CTCP: */
  ctcp_reply[0] = 0;
  p = strchr(msg, 1);
  while (p && *p) {
    p++;
    p1 = p;
    while ((*p != 1) && *p)
      p++;
    if (*p == 1) {
      *p = 0;
      ctcp = buf2;
      strcpy(ctcp, p1);
      strcpy(p1 - 1, p + 1);
      detect_chan_flood(nick, uhost, from, chan, strncmp(ctcp, "ACTION ", 7) ?
                        FLOOD_CTCP : FLOOD_PRIVMSG, NULL);

      chan = findchan(realto);
      if (!chan)
        return 0;

      /* Respond to the first answer_ctcp */
      p = strchr(msg, 1);
      if (ctcp_count < answer_ctcp) {
        ctcp_count++;
        if (ctcp[0] != ' ') {
          code = newsplit(&ctcp);
          u = get_user_by_host(from);
          if (!ignoring || trigger_on_ignore) {
            if (!check_tcl_ctcp(nick, uhost, u, to, code, ctcp)) {
              chan = findchan(realto);
              if (!chan)
                return 0;

              update_idle(chan->dname, nick);
            }
            if (!ignoring) {
              /* Log DCC, it's to a channel damnit! */
              if (!strcmp(code, "ACTION")) {
                putlog(LOG_PUBLIC, chan->dname, "Action: %s %s", nick, ctcp);
              } else {
                putlog(LOG_PUBLIC, chan->dname,
                       "CTCP %s: %s from %s (%s) to %s", code, ctcp, nick,
                       from, to);
              }
            }
          }
        }
      }
    }
  }

  /* Send out possible ctcp responses. */
  if (ctcp_reply[0]) {
    if (ctcp_mode != 2) {
      dprintf(DP_HELP, "NOTICE %s :%s\n", nick, ctcp_reply);
    } else {
      if (now - last_ctcp > flud_ctcp_time) {
        dprintf(DP_HELP, "NOTICE %s :%s\n", nick, ctcp_reply);
        count_ctcp = 1;
      } else if (count_ctcp < flud_ctcp_thr) {
        dprintf(DP_HELP, "NOTICE %s :%s\n", nick, ctcp_reply);
        count_ctcp++;
      }
      last_ctcp = now;
    }
  }

  if (msg[0]) {
    int result = 0;

    /* Check even if we're ignoring the host. (modified by Eule 17.7.99) */
    detect_chan_flood(nick, uhost, from, chan, FLOOD_PRIVMSG, NULL);

    chan = findchan(realto);
    if (!chan)
      return 0;

    update_idle(chan->dname, nick);

    if (!ignoring || trigger_on_ignore) {
      result = check_tcl_pubm(nick, uhost, chan->dname, msg);

      if (!result || !exclusive_binds)
        if (check_tcl_pub(nick, uhost, chan->dname, msg))
          return 0;
    }

    if (!ignoring && result != 2) {
      if (to[0] == '@')
        putlog(LOG_PUBLIC, chan->dname, "@<%s> %s", nick, msg);
      else
        putlog(LOG_PUBLIC, chan->dname, "<%s> %s", nick, msg);
    }
  }
  return 0;
}

Here is the call graph for this function:

static int gotnick	(	char *	from,
		char *	msg
	)			[static]

Definition at line 2116 of file chan.c.

References chan_sentdehalfop, chan_sentdeop, chan_sentdevoice, chan_senthalfop, chan_sentkick, chan_sentop, chan_sentvoice, chan_stopcheck, chanset, check_tcl_nick, check_this_member(), clear_chanlist_member, detect_chan_flood(), chanset_t::dname, findchan_by_dname, fixcolon, memstruct::flags, FLOOD_NICK, FR_CHAN, FR_GLOBAL, get_user_by_host, get_user_flagrec, ismember, killmember(), memstruct::last, LOG_JOIN, LOG_MISC, chanset_t::next, memstruct::nick, now, NULL, putlog, rfc_casecmp, SENTDEHALFOP, SENTDEOP, SENTDEVOICE, SENTHALFOP, SENTKICK, SENTOP, SENTVOICE, memstruct::split, splitnick, STOPCHECK, UHOSTLEN, and memstruct::user.

{
  char *nick, *chname, s1[UHOSTLEN], buf[UHOSTLEN], *uhost = buf;
  unsigned char found = 0;
  memberlist *m, *mm;
  struct chanset_t *chan, *oldchan = NULL;
  struct userrec *u;
  struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };

  strcpy(uhost, from);
  nick = splitnick(&uhost);
  fixcolon(msg);
  clear_chanlist_member(nick);  /* Cache for nick 'nick' is meaningless now. */
  for (chan = chanset; chan; chan = chan->next) {
    oldchan = chan;
    chname = chan->dname;
    m = ismember(chan, nick);
    if (m) {
      putlog(LOG_JOIN, chan->dname, "Nick change: %s -> %s", nick, msg);
      m->last = now;
      if (rfc_casecmp(nick, msg)) {
        /* Not just a capitalization change */
        mm = ismember(chan, msg);
        if (mm) {
          /* Someone on channel with old nick?! */
          if (mm->split)
            putlog(LOG_JOIN, chan->dname,
                   "Possible future nick collision: %s", mm->nick);
          else
            putlog(LOG_MISC, chan->dname,
                   "* Bug: nick change to existing nick");
          killmember(chan, mm->nick);
        }
      }
      /*
       * Banned?
       */
      /* Compose a nick!user@host for the new nick */
      sprintf(s1, "%s!%s", msg, uhost);
      strcpy(m->nick, msg);
      detect_chan_flood(msg, uhost, from, chan, FLOOD_NICK, NULL);

      if (!findchan_by_dname(chname)) {
        chan = oldchan;
        continue;
      }
      /* don't fill the serverqueue with modes or kicks in a nickflood */
      if (chan_sentkick(m) || chan_sentdeop(m) || chan_sentop(m) ||
          chan_sentdehalfop(m) || chan_senthalfop(m) || chan_sentdevoice(m) ||
          chan_sentvoice(m))
        m->flags |= STOPCHECK;
      /* Any pending kick or mode to the old nick is lost. */
      m->flags &= ~(SENTKICK | SENTDEOP | SENTOP | SENTDEHALFOP | SENTHALFOP |
                    SENTVOICE | SENTDEVOICE);
      /* nick-ban or nick is +k or something? */
      if (!chan_stopcheck(m)) {
        get_user_flagrec(m->user ? m->user : get_user_by_host(s1), &fr,
                         chan->dname);
        check_this_member(chan, m->nick, &fr);
      }
      /* Make sure this is in the loop, someone could have changed the record
       * in an earlier iteration of the loop. */
      u = get_user_by_host(from);
      found = 1;
      check_tcl_nick(nick, uhost, u, chan->dname, msg);

      if (!findchan_by_dname(chname)) {
        chan = oldchan;
        continue;
      }
    }
  }
  if (!found) {
    u = get_user_by_host(from);
    s1[0] = '*';
    s1[1] = 0;
    check_tcl_nick(nick, uhost, u, s1, msg);
  }
  return 0;
}

Here is the call graph for this function:

static int gotnotice	(	char *	from,
		char *	msg
	)			[static]

Definition at line 2445 of file chan.c.

References ban_fun, chanset_t::ban_time, botnetnick, chan_deop, chan_friend, chan_op, chan_sentkick, CHANMETA, channel_dontkickops, check_exemptlist(), check_tcl_ctcr, check_tcl_notc(), detect_avalanche(), detect_chan_flood(), chanset_t::dname, DP_SERVER, dprintf, chanset_t::exempts, findchan, fixcolon, memstruct::flags, FLOOD_CTCP, FLOOD_NOTICE, FLOOD_PRIVMSG, flud_ctcp_thr, FR_CHAN, FR_GLOBAL, get_user_by_host, get_user_flagrec, glob_friend, glob_op, global_exempts, IRC_FUNKICK, ismember, kick_fun, LOG_MODES, LOG_PUBLIC, match_ignore, me_op(), chanset_t::name, newsplit, now, NULL, putlog, quickban(), SENTKICK, splitnick, trigger_on_ignore, u_addban(), u_match_mask(), update_idle(), and use_exempts.

{
  char *to, *realto, *nick, buf2[512], *p, *p1, buf[512], *uhost = buf;
  char *ctcp, *code;
  struct userrec *u;
  memberlist *m;
  struct chanset_t *chan;
  struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };
  int ignoring;

  if (!strchr(CHANMETA "@", *msg))
    return 0;
  ignoring = match_ignore(from);
  to = newsplit(&msg);
  realto = (*to == '@') ? to + 1 : to;
  chan = findchan(realto);
  if (!chan)
    return 0;                   /* Notice to an unknown channel?? */
  fixcolon(msg);
  strcpy(uhost, from);
  nick = splitnick(&uhost);
  u = get_user_by_host(from);
  if (flud_ctcp_thr && detect_avalanche(msg)) {
    get_user_flagrec(u, &fr, chan->dname);
    m = ismember(chan, nick);
    /* Discard -- kick user if it was to the channel */
    if (me_op(chan) && m && !chan_sentkick(m) && !chan_friend(fr) &&
        !glob_friend(fr) && !(channel_dontkickops(chan) && (chan_op(fr) ||
        (glob_op(fr) && !chan_deop(fr)))) && !(use_exempts && ban_fun &&
        (u_match_mask(global_exempts, from) ||
        u_match_mask(chan->exempts, from)))) {
      if (ban_fun) {
        check_exemptlist(chan, from);
        u_addban(chan, quickban(chan, uhost), botnetnick,
                 IRC_FUNKICK, now + (60 * chan->ban_time), 0);
      }
      if (kick_fun) {
        /* This can induce kickflood - arthur2 */
        dprintf(DP_SERVER, "KICK %s %s :%s\n", chan->name, nick, IRC_FUNKICK);
        m->flags |= SENTKICK;
      }
    }
    if (!ignoring)
      putlog(LOG_MODES, "*", "Avalanche from %s", from);
    return 0;
  }
  /* Check for CTCP: */
  p = strchr(msg, 1);
  while (p && *p) {
    p++;
    p1 = p;
    while ((*p != 1) && *p)
      p++;
    if (*p == 1) {
      *p = 0;
      ctcp = buf2;
      strcpy(ctcp, p1);
      strcpy(p1 - 1, p + 1);
      p = strchr(msg, 1);
      detect_chan_flood(nick, uhost, from, chan,
                        strncmp(ctcp, "ACTION ", 7) ?
                        FLOOD_CTCP : FLOOD_PRIVMSG, NULL);

      chan = findchan(realto);
      if (!chan)
        return 0;

      if (ctcp[0] != ' ') {
        code = newsplit(&ctcp);
        if (!ignoring || trigger_on_ignore) {
          check_tcl_ctcr(nick, uhost, u, chan->dname, code, msg);

          chan = findchan(realto);
          if (!chan)
            return 0;

          if (!ignoring) {
            putlog(LOG_PUBLIC, chan->dname,
                   "CTCP reply %s: %s from %s (%s) to %s", code, msg, nick,
                   from, chan->dname);
            update_idle(chan->dname, nick);
          }
        }
      }
    }
  }
  if (msg[0]) {

    /* Check even if we're ignoring the host. (modified by Eule 17.7.99) */
    detect_chan_flood(nick, uhost, from, chan, FLOOD_NOTICE, NULL);

    chan = findchan(realto);
    if (!chan)
      return 0;

    update_idle(chan->dname, nick);

    if (!ignoring || trigger_on_ignore)
      if (check_tcl_notc(nick, uhost, u, to, msg) == 2)
        return 0;

    if (!ignoring)
      putlog(LOG_PUBLIC, chan->dname, "-%s:%s- %s", nick, to, msg);
  }
  return 0;
}

Here is the call graph for this function:

static int gotpart	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1964 of file chan.c.

References CHAN_ACTIVE, CHAN_PEND, CHAN_RESETALL, chanset_t::channel, channel_active, channel_inactive, channel_pending, check_lonely_channel(), check_tcl_part(), clear_channel(), chanset_t::dname, DP_SERVER, dprintf, findchan, fixcolon, get_user_by_host, chan_t::key, chanset_t::key_prot, killmember(), LOG_JOIN, LOG_MISC, match_my_nick(), chanset_t::name, newsplit, now, putlog, reset_chan_info(), set_handle_laston(), splitnick, and chanset_t::status.

{
  char *nick, *chname, *key;
  struct chanset_t *chan;
  struct userrec *u;

  chname = newsplit(&msg);
  fixcolon(chname);
  fixcolon(msg);
  chan = findchan(chname);
  if (chan && channel_inactive(chan)) {
    clear_channel(chan, 1);
    chan->status &= ~(CHAN_ACTIVE | CHAN_PEND);
    return 0;
  }
  if (chan && !channel_pending(chan)) {
    u = get_user_by_host(from);
    nick = splitnick(&from);
    if (!channel_active(chan)) {
      /* whoa! */
      putlog(LOG_MISC, chan->dname,
             "confused bot: guess I'm on %s and didn't realize it",
             chan->dname);
      chan->status |= CHAN_ACTIVE;
      chan->status &= ~CHAN_PEND;
      reset_chan_info(chan, CHAN_RESETALL);
    }
    set_handle_laston(chan->dname, u, now);
    /* This must be directly above the killmember, in case we're doing anything
     * to the record that would affect the above */
    check_tcl_part(nick, from, u, chan->dname, msg);

    chan = findchan(chname);
    if (!chan)
      return 0;

    killmember(chan, nick);
    if (msg[0])
      putlog(LOG_JOIN, chan->dname, "%s (%s) left %s (%s).", nick, from,
             chan->dname, msg);
    else
      putlog(LOG_JOIN, chan->dname, "%s (%s) left %s.", nick, from,
             chan->dname);
    /* If it was me, all hell breaks loose... */
    if (match_my_nick(nick)) {
      clear_channel(chan, 1);
      chan->status &= ~(CHAN_ACTIVE | CHAN_PEND);
      if (!channel_inactive(chan)) {

        key = chan->channel.key[0] ? chan->channel.key : chan->key_prot;
        if (key[0])
          dprintf(DP_SERVER, "JOIN %s %s\n",
                  chan->name[0] ? chan->name : chan->dname, key);
        else
          dprintf(DP_SERVER, "JOIN %s\n",
                  chan->name[0] ? chan->name : chan->dname);
      }
    } else
      check_lonely_channel(chan);
  }
  return 0;
}

Here is the call graph for this function:

static int gotquit	(	char *	from,
		char *	msg
	)			[static]

Definition at line 2199 of file chan.c.

References botname, chanset, check_lonely_channel(), check_tcl_sign, check_tcl_splt, chanset_t::dname, DP_SERVER, dprintf, findchan_by_dname, fixcolon, get_altbotnick(), get_user_by_host, IRC_GETALTNICK, IRC_GETORIGNICK, ismember, keepnick, killmember(), LOG_JOIN, LOG_MISC, chanset_t::next, NICKMAX, now, NULL, origbotname, putlog, rfc_casecmp, set_handle_laston(), memstruct::split, splitnick, and UHOSTMAX.

{
  char *nick, *chname, *p, *alt;
  int split = 0;
  char from2[NICKMAX + UHOSTMAX + 1];
  memberlist *m;
  struct chanset_t *chan, *oldchan = NULL;
  struct userrec *u;

  strcpy(from2, from);
  u = get_user_by_host(from2);
  nick = splitnick(&from);
  fixcolon(msg);
  /* Fred1: Instead of expensive wild_match on signoff, quicker method.
   *        Determine if signoff string matches "%.% %.%", and only one
   *        space.
   */
  p = strchr(msg, ' ');
  if (p && (p == strrchr(msg, ' '))) {
    char *z1, *z2;

    *p = 0;
    z1 = strchr(p + 1, '.');
    z2 = strchr(msg, '.');
    if (z1 && z2 && (*(z1 + 1) != 0) && (z1 - 1 != p) &&
        (z2 + 1 != p) && (z2 != msg)) {
      /* Server split, or else it looked like it anyway (no harm in
       * assuming)
       */
      split = 1;
    } else
      *p = ' ';
  }
  for (chan = chanset; chan; chan = chan->next) {
    oldchan = chan;
    chname = chan->dname;
    m = ismember(chan, nick);
    if (m) {
      u = get_user_by_host(from2);
      if (u)
        /* If you remove this, the bot will crash when the user record in
         * question is removed/modified during the tcl binds below, and the
         * users was on more than one monitored channel */
        set_handle_laston(chan->dname, u, now);
      if (split) {
        m->split = now;
        check_tcl_splt(nick, from, u, chan->dname);

        if (!findchan_by_dname(chname)) {
          chan = oldchan;
          continue;
        }
        putlog(LOG_JOIN, chan->dname, "%s (%s) got netsplit.", nick, from);
      } else {
        check_tcl_sign(nick, from, u, chan->dname, msg);

        if (!findchan_by_dname(chname)) {
          chan = oldchan;
          continue;
        }
        putlog(LOG_JOIN, chan->dname, "%s (%s) left irc: %s", nick, from, msg);
        killmember(chan, nick);
        check_lonely_channel(chan);
      }
    }
  }
  /* Our nick quit? if so, grab it. Heck, our altnick quit maybe, maybe
   * we want it.
   */
  if (keepnick) {
    alt = get_altbotnick();
    if (!rfc_casecmp(nick, origbotname)) {
      putlog(LOG_MISC, "*", IRC_GETORIGNICK, origbotname);
      dprintf(DP_SERVER, "NICK %s\n", origbotname);
    } else if (alt[0]) {
      if (!rfc_casecmp(nick, alt) && strcmp(botname, origbotname)) {
        putlog(LOG_MISC, "*", IRC_GETALTNICK, alt);
        dprintf(DP_SERVER, "NICK %s\n", alt);
      }
    }
  }
  return 0;
}

Here is the call graph for this function:

static int gottopic	(	char *	from,
		char *	msg
	)			[static]

Definition at line 1553 of file chan.c.

References check_tcl_topc, chanset_t::dname, findchan, fixcolon, get_user_by_host, ismember, memstruct::last, LOG_JOIN, newsplit, now, NULL, putlog, set_topic(), and splitnick.

{
  char *nick, *chname;
  memberlist *m;
  struct chanset_t *chan;
  struct userrec *u;

  chname = newsplit(&msg);
  fixcolon(msg);
  u = get_user_by_host(from);
  nick = splitnick(&from);
  chan = findchan(chname);
  if (chan) {
    putlog(LOG_JOIN, chan->dname, "Topic changed on %s by %s!%s: %s",
           chan->dname, nick, from, msg);
    m = ismember(chan, nick);
    if (m != NULL)
      m->last = now;
    set_topic(chan, msg);
    check_tcl_topc(nick, from, u, chan->dname, msg);
  }
  return 0;
}

Here is the call graph for this function:

static void kick_all	(	struct chanset_t *	chan,
		char *	hostmask,
		char *	comment,
		int	bantype
	)			[static]

Definition at line 384 of file chan.c.

References chan_deop, chan_friend, chan_hasop, chan_issplit, chan_op, chan_sentkick, chanset_t::channel, channel_dontkickops, chanset_t::dname, DP_SERVER, dprintf, chanset_t::exempts, memstruct::flags, flush_mode(), FR_CHAN, FR_GLOBAL, get_user_by_host, get_user_flagrec, glob_friend, glob_op, global_exempts, isexempted, kick_method, match_addr, match_my_nick(), me_halfop(), me_op(), chan_t::member, chanset_t::name, memstruct::next, memstruct::nick, QUICK, SENTKICK, u_match_mask(), UHOSTLEN, use_exempts, memstruct::user, and memstruct::userhost.

Referenced by enforce_bans(), got_ban(), and refresh_ban_kick().

{
  memberlist *m;
  char kicknick[512], s[UHOSTLEN];
  struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };
  int k, l, flushed;

  if (!me_op(chan) && !me_halfop(chan))
    return;

  k = 0;
  flushed = 0;
  kicknick[0] = 0;
  for (m = chan->channel.member; m && m->nick[0]; m = m->next) {
    sprintf(s, "%s!%s", m->nick, m->userhost);
    get_user_flagrec(m->user ? m->user : get_user_by_host(s), &fr, chan->dname);
    if ((me_op(chan) || (me_halfop(chan) && !chan_hasop(m))) &&
        match_addr(hostmask, s) && !chan_sentkick(m) &&
        !match_my_nick(m->nick) && !chan_issplit(m) &&
        !glob_friend(fr) && !chan_friend(fr) && !(use_exempts && ((bantype &&
        isexempted(chan, s)) || (u_match_mask(global_exempts, s) ||
        u_match_mask(chan->exempts, s)))) && !(channel_dontkickops(chan) &&
        (chan_op(fr) || (glob_op(fr) && !chan_deop(fr))))) {
      if (!flushed) {
        /* We need to kick someone, flush eventual bans first */
        flush_mode(chan, QUICK);
        flushed += 1;
      }
      m->flags |= SENTKICK;     /* Mark as pending kick */
      if (kicknick[0])
        strcat(kicknick, ",");
      strcat(kicknick, m->nick);
      k += 1;
      l = strlen(chan->name) + strlen(kicknick) + strlen(comment) + 5;
      if ((kick_method != 0 && k == kick_method) || (l > 480)) {
        dprintf(DP_SERVER, "KICK %s %s :%s\n", chan->name, kicknick, comment);
        k = 0;
        kicknick[0] = 0;
      }
    }
  }
  if (k > 0)
    dprintf(DP_SERVER, "KICK %s %s :%s\n", chan->name, kicknick, comment);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static memberlist* newmember

(

struct chanset_t *

chan

)

[static]

Definition at line 42 of file chan.c.

References chanset_t::channel, channel_malloc(), memstruct::delay, memstruct::last, chan_t::member, chan_t::members, memstruct::next, memstruct::nick, NULL, and memstruct::split.

Referenced by got352or4(), and gotjoin().

{
  memberlist *x;

  for (x = chan->channel.member; x && x->nick[0]; x = x->next);
  x->next = (memberlist *) channel_malloc(sizeof(memberlist));
  x->next->next = NULL;
  x->next->nick[0] = 0;
  x->next->split = 0L;
  x->next->last = 0L;
  x->next->delay = 0L;
  chan->channel.members++;
  return x;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* quickban	(	struct chanset_t *	chan,
		char *	uhost
	)			[static]

Definition at line 372 of file chan.c.

References chan_t::ban, chanset_t::ban_type, chanset_t::channel, do_mask(), and maskaddr.

Referenced by check_this_member(), cmd_kickban(), gotjoin(), gotmsg(), and gotnotice().

{
  static char s1[512];

  maskaddr(uhost, s1, chan->ban_type);
  do_mask(chan, chan->channel.ban, s1, 'b');
  return s1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void recheck_bans

(

struct chanset_t *

chan

)

[static]

Definition at line 540 of file chan.c.

References add_mode, chanset_t::bans, channel_dynamicbans, maskrec::flags, global_bans, isbanned, maskrec::mask, MASKREC_STICKY, and maskrec::next.

Referenced by recheck_channel(), and resetmasks().

{
  maskrec *u;
  int cycle;

  /* Check global bans in first cycle and channel bans in second cycle. */
  for (cycle = 0; cycle < 2; cycle++) {
    for (u = cycle ? chan->bans : global_bans; u; u = u->next)
      if (!isbanned(chan, u->mask) && (!channel_dynamicbans(chan) ||
          (u->flags & MASKREC_STICKY)))
        add_mode(chan, '+', 'b', u->mask);
  }
}

Here is the caller graph for this function:

static void recheck_channel	(	struct chanset_t *	chan,
		int	dobans
	)			[static]

Definition at line 868 of file chan.c.

References CHAN_ASKED_EXEMPTS, CHAN_ASKED_INVITED, CHAN_ASKEDMODES, chan_hasop, CHAN_RESETEXEMPTS, CHAN_RESETINVITED, chanset_t::channel, channel_enforcebans, channel_inactive, channel_nouserbans, channel_nouserexempts, channel_nouserinvites, check_this_member(), chanset_t::dname, DP_MODE, dprintf, enforce_bans(), memstruct::flags, FR_CHAN, FR_GLOBAL, get_user_by_host, get_user_flagrec, glob_bot, chanset_t::ircnet_status, match_my_nick(), chan_t::member, chanset_t::name, memstruct::next, memstruct::nick, recheck_bans(), recheck_channel_modes(), recheck_exempts(), recheck_invites(), reset_chan_info(), resetbans, resetexempts, resetinvites, SENTHALFOP, SENTKICK, chanset_t::status, memstruct::tried_getuser, UHOSTLEN, use_exempts, use_invites, memstruct::user, memstruct::userhost, and userlist.

Referenced by got315(), got_halfop(), and got_op().

{
  memberlist *m;
  char s[UHOSTLEN];
  struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };
  static int stacking = 0;
  int stop_reset = 0;

  if (stacking || !userlist)
    return;

  stacking++;
  /* Okay, sort through who needs to be deopped. */
  for (m = chan->channel.member; m && m->nick[0]; m = m->next) {
    sprintf(s, "%s!%s", m->nick, m->userhost);
    if (!m->user && !m->tried_getuser) {
      m->tried_getuser = 1;
      m->user = get_user_by_host(s);
    }
    get_user_flagrec(m->user, &fr, chan->dname);
    if (glob_bot(fr) && chan_hasop(m) && !match_my_nick(m->nick))
      stop_reset = 1;
    /* Perhaps we were halfop and tried to halfop/kick the user earlier but
     * the server rejected the request, so let's try again. */
    m->flags &= ~(SENTHALFOP | SENTKICK);
    check_this_member(chan, m->nick, &fr);
  }
  /* Most IRCDs nowadays require +h/+o for getting e/I lists,
   * so if we're still waiting for these, we'll request them here.
   * In case we got them on join, nothing will be done */
  if (chan->ircnet_status & (CHAN_ASKED_EXEMPTS | CHAN_ASKED_INVITED)) {
    chan->ircnet_status &= ~(CHAN_ASKED_EXEMPTS | CHAN_ASKED_INVITED);
    reset_chan_info(chan, CHAN_RESETEXEMPTS | CHAN_RESETINVITED);
  }
  if (dobans) {
    if (channel_nouserbans(chan) && !stop_reset)
      resetbans(chan);
    else
      recheck_bans(chan);
    if (use_invites) {
      if (channel_nouserinvites(chan) && !stop_reset)
        resetinvites(chan);
      else
        recheck_invites(chan);
    }
    if (use_exempts) {
      if (channel_nouserexempts(chan) && !stop_reset)
        resetexempts(chan);
      else
        recheck_exempts(chan);
    }
    if (channel_enforcebans(chan))
      enforce_bans(chan);
    if ((chan->status & CHAN_ASKEDMODES) && !channel_inactive(chan))
      dprintf(DP_MODE, "MODE %s\n", chan->name);
    recheck_channel_modes(chan);
  }
  stacking--;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void recheck_channel_modes

(

struct chanset_t *

chan

)

[static]

Definition at line 658 of file chan.c.

References add_mode, CHAN_ASKEDMODES, CHANANON, CHANDELJN, CHANINV, CHANKEY, CHANLIMIT, CHANLONLY, CHANMODER, CHANMODREG, chanset_t::channel, CHANNOAMSG, CHANNOCLR, CHANNOCTCP, CHANNOMSG, CHANNONOTC, CHANPRIV, CHANQUIET, CHANREGON, CHANSEC, CHANSTRIP, CHANTOPIC, chan_t::key, chanset_t::key_prot, chanset_t::limit_prot, chan_t::maxmembers, chan_t::mode, chanset_t::mode_mns_prot, chanset_t::mode_pls_prot, rfc_casecmp, and chanset_t::status.

Referenced by got324(), and recheck_channel().

{
  int cur = chan->channel.mode, mns = chan->mode_mns_prot,
      pls = chan->mode_pls_prot;

  if (!(chan->status & CHAN_ASKEDMODES)) {
    if (pls & CHANINV && !(cur & CHANINV))
      add_mode(chan, '+', 'i', "");
    else if (mns & CHANINV && cur & CHANINV)
      add_mode(chan, '-', 'i', "");
    if (pls & CHANPRIV && !(cur & CHANPRIV))
      add_mode(chan, '+', 'p', "");
    else if (mns & CHANPRIV && cur & CHANPRIV)
      add_mode(chan, '-', 'p', "");
    if (pls & CHANSEC && !(cur & CHANSEC))
      add_mode(chan, '+', 's', "");
    else if (mns & CHANSEC && cur & CHANSEC)
      add_mode(chan, '-', 's', "");
    if (pls & CHANMODER && !(cur & CHANMODER))
      add_mode(chan, '+', 'm', "");
    else if (mns & CHANMODER && cur & CHANMODER)
      add_mode(chan, '-', 'm', "");
    if (pls & CHANNOCLR && !(cur & CHANNOCLR))
      add_mode(chan, '+', 'c', "");
    else if (mns & CHANNOCLR && cur & CHANNOCLR)
      add_mode(chan, '-', 'c', "");
    if (pls & CHANNOCTCP && !(cur & CHANNOCTCP))
      add_mode(chan, '+', 'C', "");
    else if (mns & CHANNOCTCP && cur & CHANNOCTCP)
      add_mode(chan, '-', 'C', "");
    if (pls & CHANREGON && !(cur & CHANREGON))
      add_mode(chan, '+', 'R', "");
    else if (mns & CHANREGON && cur & CHANREGON)
      add_mode(chan, '-', 'R', "");
    if (pls & CHANMODREG && !(cur & CHANMODREG))
      add_mode(chan, '+', 'M', "");
    else if (mns & CHANMODREG && cur & CHANMODREG)
      add_mode(chan, '-', 'M', "");
    if (pls & CHANLONLY && !(cur & CHANLONLY))
      add_mode(chan, '+', 'r', "");
    else if (mns & CHANLONLY && cur & CHANLONLY)
      add_mode(chan, '-', 'r', "");
    if (pls & CHANDELJN && !(cur & CHANDELJN))
      add_mode(chan, '+', 'D', "");
    else if (mns & CHANDELJN && cur & CHANDELJN)
      add_mode(chan, '-', 'D', "");
    if (pls & CHANSTRIP && !(cur & CHANSTRIP))
      add_mode(chan, '+', 'u', "");
    else if (mns & CHANSTRIP && cur & CHANSTRIP)
      add_mode(chan, '-', 'u', "");
    if (pls & CHANNONOTC && !(cur & CHANNONOTC))
      add_mode(chan, '+', 'N', "");
    else if (mns & CHANNONOTC && cur & CHANNONOTC)
      add_mode(chan, '-', 'N', "");
    if (pls & CHANNOAMSG && !(cur & CHANNOAMSG))
      add_mode(chan, '+', 'T', "");
    else if (mns & CHANNOAMSG && cur & CHANNOAMSG)
      add_mode(chan, '-', 'T', "");
    if (pls & CHANTOPIC && !(cur & CHANTOPIC))
      add_mode(chan, '+', 't', "");
    else if (mns & CHANTOPIC && cur & CHANTOPIC)
      add_mode(chan, '-', 't', "");
    if (pls & CHANNOMSG && !(cur & CHANNOMSG))
      add_mode(chan, '+', 'n', "");
    else if ((mns & CHANNOMSG) && (cur & CHANNOMSG))
      add_mode(chan, '-', 'n', "");
    if ((pls & CHANANON) && !(cur & CHANANON))
      add_mode(chan, '+', 'a', "");
    else if ((mns & CHANANON) && (cur & CHANANON))
      add_mode(chan, '-', 'a', "");
    if ((pls & CHANQUIET) && !(cur & CHANQUIET))
      add_mode(chan, '+', 'q', "");
    else if ((mns & CHANQUIET) && (cur & CHANQUIET))
      add_mode(chan, '-', 'q', "");
    if ((chan->limit_prot != 0) && (chan->channel.maxmembers == 0)) {
      char s[50];

      sprintf(s, "%d", chan->limit_prot);
      add_mode(chan, '+', 'l', s);
    } else if ((mns & CHANLIMIT) && (chan->channel.maxmembers != 0))
      add_mode(chan, '-', 'l', "");
    if (chan->key_prot[0]) {
      if (rfc_casecmp(chan->channel.key, chan->key_prot) != 0) {
        if (chan->channel.key[0])
          add_mode(chan, '-', 'k', chan->channel.key);
        add_mode(chan, '+', 'k', chan->key_prot);
      }
    } else if ((mns & CHANKEY) && (chan->channel.key[0]))
      add_mode(chan, '-', 'k', chan->channel.key);
  }
}

Here is the caller graph for this function:

static void recheck_exempts

(

struct chanset_t *

chan

)

[static]

Definition at line 559 of file chan.c.

References add_mode, chan_t::ban, chanset_t::channel, channel_dynamicexempts, e, chanset_t::exempts, maskrec::flags, global_exempts, isexempted, maskstruct::mask, maskrec::mask, mask_match, MASKREC_STICKY, maskstruct::next, and maskrec::next.

Referenced by recheck_channel(), and resetmasks().

{
  maskrec *e;
  masklist *b;
  int cycle;

  /* Check global exempts in first cycle and channel exempts in second cycle. */
  for (cycle = 0; cycle < 2; cycle++) {
    for (e = cycle ? chan->exempts : global_exempts; e; e = e->next) {
      if (!isexempted(chan, e->mask) &&
          (!channel_dynamicexempts(chan) || (e->flags & MASKREC_STICKY)))
        add_mode(chan, '+', 'e', e->mask);
      for (b = chan->channel.ban; b && b->mask[0]; b = b->next) {
        if (mask_match(b->mask, e->mask) &&
            !isexempted(chan, e->mask))
          add_mode(chan, '+', 'e', e->mask);
        /* do_mask(chan, chan->channel.exempt, e->mask, 'e'); */
      }
    }
  }
}

Here is the caller graph for this function:

static void recheck_invites

(

struct chanset_t *

chan

)

[static]

Definition at line 586 of file chan.c.

References add_mode, CHANINV, chanset_t::channel, channel_dynamicinvites, maskrec::flags, global_invites, chanset_t::invites, isinvited, maskrec::mask, MASKREC_STICKY, chan_t::mode, and maskrec::next.

Referenced by recheck_channel(), and resetmasks().

{
  maskrec *ir;
  int cycle;

  /* Check global invites in first cycle and channel invites in second cycle. */
  for (cycle = 0; cycle < 2; cycle++) {
    for (ir = cycle ? chan->invites : global_invites; ir; ir = ir->next) {
      /* If invite isn't set and (channel is not dynamic invites and not invite
       * only) or invite is sticky.
       */
      if (!isinvited(chan, ir->mask) && ((!channel_dynamicinvites(chan) &&
          !(chan->channel.mode & CHANINV)) || ir->flags & MASKREC_STICKY))
        add_mode(chan, '+', 'I', ir->mask);
      /* do_mask(chan, chan->channel.invite, ir->mask, 'I'); */
    }
  }
}

Here is the caller graph for this function:

static void refresh_ban_kick	(	struct chanset_t *	chan,
		char *	user,
		char *	nick
	)			[static]

Definition at line 432 of file chan.c.

References add_mode, chan_t::ban, chanset_t::bans, chan_friend, chan_sentkick, chanset_t::channel, check_exemptlist(), maskrec::desc, chanset_t::dname, do_mask(), egg_snprintf, FR_CHAN, FR_GLOBAL, get_user_by_host, get_user_flagrec, glob_friend, global_bans, IRC_PREBANNED, IRC_YOUREBANNED, ismember, kick_all(), maskrec::lastactive, maskrec::mask, match_addr, maskrec::next, memstruct::nick, now, UHOSTLEN, memstruct::user, and memstruct::userhost.

Referenced by check_this_ban(), check_this_member(), and gotjoin().

{
  register maskrec *b;
  memberlist *m;
  int cycle;

  m = ismember(chan, nick);
  if (!m || chan_sentkick(m))
    return;

  /* Check global bans in first cycle and channel bans in second cycle. */
  for (cycle = 0; cycle < 2; cycle++) {
    for (b = cycle ? chan->bans : global_bans; b; b = b->next) {
      if (match_addr(b->mask, user)) {
        struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };
        char c[512];            /* The ban comment.     */
        char s[UHOSTLEN];

        sprintf(s, "%s!%s", m->nick, m->userhost);
        get_user_flagrec(m->user ? m->user : get_user_by_host(s), &fr,
                         chan->dname);
        if (!glob_friend(fr) && !chan_friend(fr)) {
          add_mode(chan, '-', 'o', nick);       /* Guess it can't hurt. */
          check_exemptlist(chan, user);
          do_mask(chan, chan->channel.ban, b->mask, 'b');
          b->lastactive = now;
          if (b->desc && b->desc[0] != '@')
            egg_snprintf(c, sizeof c, "%s %s", IRC_PREBANNED, b->desc);
          else
            c[0] = 0;
          kick_all(chan, b->mask, c[0] ? c : IRC_YOUREBANNED, 0);
          return;               /* Drop out on 1st ban. */
        }
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void refresh_exempt	(	struct chanset_t *	chan,
		char *	user
	)			[static]

Definition at line 473 of file chan.c.

References chan_t::ban, chanset_t::channel, do_mask(), e, chan_t::exempt, chanset_t::exempts, global_exempts, isexempted, maskrec::lastactive, maskstruct::mask, maskrec::mask, mask_match, maskstruct::next, maskrec::next, and now.

Referenced by got_ban().

{
  maskrec *e;
  masklist *b;
  int cycle;

  /* Check global exempts in first cycle and channel exempts in second cycle. */
  for (cycle = 0; cycle < 2; cycle++) {
    for (e = cycle ? chan->exempts : global_exempts; e; e = e->next) {
      if (mask_match(user, e->mask)) {
        for (b = chan->channel.ban; b && b->mask[0]; b = b->next) {
          if (mask_match(b->mask, user)) {
            if (e->lastactive < now - 60 && !isexempted(chan, e->mask)) {
              do_mask(chan, chan->channel.exempt, e->mask, 'e');
              e->lastactive = now;
            }
          }
        }
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void refresh_invite	(	struct chanset_t *	chan,
		char *	user
	)			[static]

Definition at line 496 of file chan.c.

References CHANINV, chanset_t::channel, do_mask(), maskrec::flags, global_invites, chan_t::invite, chanset_t::invites, isinvited, maskrec::lastactive, maskrec::mask, MASKREC_STICKY, match_addr, chan_t::mode, maskrec::next, and now.

Referenced by check_this_member(), and gotjoin().

{
  maskrec *i;
  int cycle;

  /* Check global invites in first cycle and channel invites in second cycle. */
  for (cycle = 0; cycle < 2; cycle++) {
    for (i = cycle ? chan->invites : global_invites; i; i = i->next) {
      if (match_addr(i->mask, user) &&
          ((i->flags & MASKREC_STICKY) || (chan->channel.mode & CHANINV))) {
        if (i->lastactive < now - 60 && !isinvited(chan, i->mask)) {
          do_mask(chan, chan->channel.invite, i->mask, 'I');
          i->lastactive = now;
          return;
        }
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void resetmasks	(	struct chanset_t *	chan,
		masklist *	m,
		maskrec *	mrec,
		maskrec *	global_masks,
		char	mode
	)			[static]

Definition at line 607 of file chan.c.

References add_mode, LOG_MISC, maskstruct::mask, me_halfop(), me_op(), maskstruct::next, NOHALFOPS_MODES, NULL, putlog, recheck_bans(), recheck_exempts(), recheck_invites(), and u_equals_mask().

{
  if (!me_op(chan) && (!me_halfop(chan) ||
      (strchr(NOHALFOPS_MODES, 'b') != NULL) ||
      (strchr(NOHALFOPS_MODES, 'e') != NULL) ||
      (strchr(NOHALFOPS_MODES, 'I') != NULL)))
    return;

  /* Remove masks we didn't put there */
  for (; m && m->mask[0]; m = m->next) {
    if (!u_equals_mask(global_masks, m->mask) && !u_equals_mask(mrec, m->mask))
      add_mode(chan, '-', mode, m->mask);
  }

  /* Make sure the intended masks are still there */
  switch (mode) {
  case 'b':
    recheck_bans(chan);
    break;
  case 'e':
    recheck_exempts(chan);
    break;
  case 'I':
    recheck_invites(chan);
    break;
  default:
    putlog(LOG_MISC, "*", "(!) Invalid mode '%c' in resetmasks()", mode);
    break;
  }
}

Here is the call graph for this function:

static void set_delay	(	struct chanset_t *	chan,
		char *	nick
	)			[static]

Definition at line 1616 of file chan.c.

References chanset_t::aop_max, chanset_t::aop_min, chanset_t::channel, count, memstruct::delay, memstruct::flags, FULL_DELAY, ismember, chan_t::member, modesperline, memstruct::next, memstruct::nick, now, randint, and time_t.

Referenced by check_this_member(), and gotjoin().

{
  time_t a_delay;
  int aop_min, aop_max, aop_diff, count = 0;
  memberlist *m, *m2;

  m = ismember(chan, nick);
  if (!m)
    return;

  /* aop-delay 5:30 -- aop_min:aop_max */
  aop_min = chan->aop_min;
  aop_max = chan->aop_max;
  aop_diff = aop_max - aop_min;

  /* If either min or max is less than or equal to 0 we don't delay. */
  if ((aop_min <= 0) || (aop_max <= 0)) {
    a_delay = now + 1;

  /* Use min value for delay if min greater then or equal to max or if the
   * difference of max and min is greater than RANDOM_MAX (sanity check).
   */
  } else if ((aop_min >= aop_max) || (aop_diff > RANDOM_MAX)) {
    a_delay = now + aop_min;

  /* Set a random delay based on the difference of max and min */
  } else {
    a_delay = now + randint(aop_diff) + aop_min + 1;
  }

  for (m2 = chan->channel.member; m2 && m2->nick[0]; m2 = m2->next)
    if (m2->delay && !(m2->flags & FULL_DELAY))
      count++;

  if (count) {
    for (m2 = chan->channel.member; m2 && m2->nick[0]; m2 = m2->next) {
      if (m2->delay && !(m2->flags & FULL_DELAY)) {
        m2->delay = a_delay;

        if (count + 1 >= modesperline)
          m2->flags |= FULL_DELAY;

      }
    }
  }

  if (count + 1 >= modesperline)
    m->flags |= FULL_DELAY;

  m->delay = a_delay;
}

Here is the caller graph for this function:

static void set_topic	(	struct chanset_t *	chan,
		char *	k
	)			[static]

Definition at line 1540 of file chan.c.

References chanset_t::channel, channel_malloc(), nfree, NULL, and chan_t::topic.

Referenced by got331(), got332(), and gottopic().

{
  if (chan->channel.topic)
    nfree(chan->channel.topic);
  if (k && k[0]) {
    chan->channel.topic = (char *) channel_malloc(strlen(k) + 1);
    strcpy(chan->channel.topic, k);
  } else
    chan->channel.topic = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sync_members

(

struct chanset_t *

chan

)

[inline, static]

Definition at line 58 of file chan.c.

References chan_whosynced, chanset_t::channel, chan_t::member, chan_t::members, memstruct::next, nfree, and memstruct::nick.

Referenced by got315().

{
  memberlist *m, *next, *prev;

  for (m = chan->channel.member, prev = 0; m && m->nick[0]; m = next) {
    next = m->next;
    if (!chan_whosynced(m)) {
      if (prev)
        prev->next = next;
      else
        chan->channel.member = next;
      nfree(m);
      chan->channel.members--;
    } else
      prev = m;
  }
}

Here is the caller graph for this function:

static void update_idle	(	char *	chname,
		char *	nick
	)			[static]

Definition at line 78 of file chan.c.

References findchan_by_dname, ismember, memstruct::last, and now.

Referenced by gotmsg(), and gotnotice().

{
  memberlist *m;
  struct chanset_t *chan;

  chan = findchan_by_dname(chname);
  if (chan) {
    m = ismember(chan, nick);
    if (m)
      m->last = now;
  }
}

Here is the caller graph for this function:

---

Variable Documentation

int count_ctcp = 0 [static]

Definition at line 31 of file chan.c.

Referenced by gotmsg().

cmd_t irc_raw[] [static]

Definition at line 2552 of file chan.c.

Referenced by irc_close(), and irc_start().

time_t last_ctcp = (time_t) 0L [static]

Definition at line 30 of file chan.c.

Referenced by gotmsg().

char last_invchan[300] = "" [static]

Definition at line 33 of file chan.c.

Referenced by gotinvite().

time_t last_invtime = (time_t) 0L [static]

Definition at line 32 of file chan.c.

Referenced by gotinvite().