src/flags.c File Reference

#include "main.h"

Include dependency graph for flags.c:

Go to the source code of this file.

Functions
int	logmodes (char *s)
char *	masktype (int x)
char *	maskname (int x)
int	sanity_check (int atr)
int	chan_sanity_check (int chatr, int atr)
char	geticon (int idx)
void	break_down_flags (const char *string, struct flag_record *plus, struct flag_record *minus)
static int	flag2str (char *string, int bot, int udef)
static int	bot2str (char *string, int bot)
int	build_flags (char *string, struct flag_record *plus, struct flag_record *minus)
int	flagrec_ok (struct flag_record *req, struct flag_record *have)
int	flagrec_eq (struct flag_record *req, struct flag_record *have)
void	set_user_flagrec (struct userrec *u, struct flag_record *fr, const char *chname)
void	get_user_flagrec (struct userrec *u, struct flag_record *fr, const char *chname)
static int	botfl_unpack (struct userrec *u, struct user_entry *e)
static int	botfl_pack (struct userrec *u, struct user_entry *e)
static int	botfl_kill (struct user_entry *e)
static int	botfl_write_userfile (FILE *f, struct userrec *u, struct user_entry *e)
static int	botfl_set (struct userrec *u, struct user_entry *e, void *buf)
static int	botfl_tcl_get (Tcl_Interp *interp, struct userrec *u, struct user_entry *e, int argc, char **argv)
static int	botfl_tcl_set (Tcl_Interp *irp, struct userrec *u, struct user_entry *e, int argc, char **argv)
static int	botfl_expmem (struct user_entry *e)
static void	botfl_display (int idx, struct user_entry *e)
Variables
int	raw_log
int	require_p
int	noshare
int	allow_dk_cmds
struct dcc_t *	dcc
struct user_entry_type	USERENTRY_BOTFL

---

Function Documentation

static int bot2str	(	char *	string,
		int	bot
	)			[static]

Definition at line 465 of file flags.c.

Referenced by build_flags().

{
  char x = 'a', *old = string;

  while (x < 'v') {
    if (bot & 1)
      *string++ = x;
    x++;
    bot >>= 1;
  }
  x = '0';
  while (x <= '9') {
    if (bot & 1)
      *string++ = x;
    x++;
    bot >>= 1;
  }
  if (string == old)
    *string++ = '-';
  return string - old;
}

Here is the caller graph for this function:

static void botfl_display	(	int	idx,
		struct user_entry *	e
	)			[static]

Definition at line 810 of file flags.c.

References flag_record::bot, build_flags, dprintf, FR_BOT, NULL, user_entry::u, and user_entry::ulong.

{
  struct flag_record fr = { FR_BOT, 0, 0, 0, 0, 0 };
  char x[100];

  fr.bot = e->u.ulong;
  build_flags(x, &fr, NULL);
  dprintf(idx, "  BOT FLAGS: %s\n", x);
}

static int botfl_expmem

(

struct user_entry *

e

)

[static]

Definition at line 805 of file flags.c.

{
  return 0;
}

static int botfl_kill

(

struct user_entry *

e

)

[static]

Definition at line 735 of file flags.c.

References nfree.

{
  nfree(e);
  return 1;
}

static int botfl_pack	(	struct userrec *	u,
		struct user_entry *	e
	)			[static]

Definition at line 722 of file flags.c.

References flag_record::bot, build_flags, list_type::extra, FR_BOT, user_entry::list, list_type::next, NULL, user_entry::u, user_entry::ulong, and user_malloc.

{
  char x[100];
  struct flag_record fr = { FR_BOT, 0, 0, 0, 0, 0 };

  fr.bot = e->u.ulong;
  e->u.list = user_malloc(sizeof(struct list_type));
  e->u.list->next = NULL;
  e->u.list->extra = user_malloc(build_flags(x, &fr, NULL) + 1);
  strcpy(e->u.list->extra, x);
  return 1;
}

static int botfl_set	(	struct userrec *	u,
		struct user_entry *	e,
		void *	buf
	)			[static]

Definition at line 754 of file flags.c.

References BOT_ALT, BOT_GLOBAL, BOT_HUB, BOT_REJECT, BOT_SHARE, BOT_VALID, userrec::flags, long(), user_entry::u, user_entry::ulong, and USER_BOT.

Referenced by botfl_tcl_set().

{
  register long atr = ((long) buf & BOT_VALID);

  if (!(u->flags & USER_BOT))
    return 1;                   /* Don't even bother trying to set the
                                 * flags for a non-bot */

  if ((atr & BOT_HUB) && (atr & BOT_ALT))
    atr &= ~BOT_ALT;
  if (atr & BOT_REJECT) {
    if (atr & BOT_SHARE)
      atr &= ~(BOT_SHARE | BOT_REJECT);
    if (atr & BOT_HUB)
      atr &= ~(BOT_HUB | BOT_REJECT);
    if (atr & BOT_ALT)
      atr &= ~(BOT_ALT | BOT_REJECT);
  }
  if (!(atr & BOT_SHARE))
    atr &= ~BOT_GLOBAL;
  e->u.ulong = atr;
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int botfl_tcl_get	(	Tcl_Interp *	interp,
		struct userrec *	u,
		struct user_entry *	e,
		int	argc,
		char **	argv
	)			[static]

Definition at line 778 of file flags.c.

References flag_record::bot, build_flags, FR_BOT, NULL, user_entry::u, and user_entry::ulong.

{
  char x[100];
  struct flag_record fr = { FR_BOT, 0, 0, 0, 0, 0 };

  fr.bot = e->u.ulong;
  build_flags(x, &fr, NULL);
  Tcl_AppendResult(interp, x, NULL);
  return TCL_OK;
}

static int botfl_tcl_set	(	Tcl_Interp *	irp,
		struct userrec *	u,
		struct user_entry *	e,
		int	argc,
		char **	argv
	)			[static]

Definition at line 790 of file flags.c.

References BADARGS, flag_record::bot, botfl_set(), break_down_flags, userrec::flags, FR_BOT, NULL, and USER_BOT.

{
  struct flag_record fr = { FR_BOT, 0, 0, 0, 0, 0 };

  BADARGS(4, 4, " handle BOTFL flags");

  if (u->flags & USER_BOT) {
    /* Silently ignore for users */
    break_down_flags(argv[3], &fr, NULL);
    botfl_set(u, e, (void *) fr.bot);
  }
  return TCL_OK;
}

Here is the call graph for this function:

static int botfl_unpack	(	struct userrec *	u,
		struct user_entry *	e
	)			[static]

Definition at line 712 of file flags.c.

References flag_record::bot, break_down_flags, list_type::extra, FR_BOT, user_entry::list, list_type_kill, NULL, user_entry::u, and user_entry::ulong.

{
  struct flag_record fr = { FR_BOT, 0, 0, 0, 0, 0 };

  break_down_flags(e->u.list->extra, &fr, NULL);
  list_type_kill(e->u.list);
  e->u.ulong = fr.bot;
  return 1;
}

static int botfl_write_userfile	(	FILE *	f,
		struct userrec *	u,
		struct user_entry *	e
	)			[static]

Definition at line 741 of file flags.c.

References flag_record::bot, build_flags, FR_BOT, user_entry_type::name, NULL, user_entry::type, user_entry::u, and user_entry::ulong.

{
  char x[100];
  struct flag_record fr = { FR_BOT, 0, 0, 0, 0, 0 };

  fr.bot = e->u.ulong;
  build_flags(x, &fr, NULL);
  if (fprintf(f, "--%s %s\n", e->type->name, x) == EOF)
    return 0;
  return 1;
}

void break_down_flags	(	const char *	string,
		struct flag_record *	plus,
		struct flag_record *	minus
	)

Definition at line 344 of file flags.c.

References flag_record::bot, BOT_FLAG0, BOT_VALID, flag_record::chan, CHAN_VALID, egg_bzero, FR_AND, FR_BOT, FR_CHAN, FR_GLOBAL, FR_OR, flag_record::global, flag_record::match, flag_record::udef_chan, flag_record::udef_global, and USER_VALID.

{
  struct flag_record *which = plus;
  int mode = 0;                 /* 0 = glob, 1 = chan, 2 = bot */
  int flags = plus->match;

  if (!(flags & FR_GLOBAL)) {
    if (flags & FR_BOT)
      mode = 2;
    else if (flags & FR_CHAN)
      mode = 1;
    else
      return;                   /* We dont actually want any..huh? */
  }
  egg_bzero(plus, sizeof(struct flag_record));

  if (minus)
    egg_bzero(minus, sizeof(struct flag_record));

  plus->match = FR_OR;          /* Default binding type OR */
  while (*string) {
    switch (*string) {
    case '+':
      which = plus;
      break;
    case '-':
      which = minus ? minus : plus;
      break;
    case '|':
    case '&':
      if (!mode) {
        if (*string == '|')
          plus->match = FR_OR;
        else
          plus->match = FR_AND;
      }
      which = plus;
      mode++;
      if ((mode == 2) && !(flags & (FR_CHAN | FR_BOT)))
        string = "";
      else if (mode == 3)
        mode = 1;
      break;
    default:
      if ((*string >= 'a') && (*string <= 'z')) {
        switch (mode) {
        case 0:
          which->global |=1 << (*string - 'a');

          break;
        case 1:
          which->chan |= 1 << (*string - 'a');
          break;
        case 2:
          which->bot |= 1 << (*string - 'a');
        }
      } else if ((*string >= 'A') && (*string <= 'Z')) {
        switch (mode) {
        case 0:
          which->udef_global |= 1 << (*string - 'A');
          break;
        case 1:
          which->udef_chan |= 1 << (*string - 'A');
          break;
        }
      } else if ((*string >= '0') && (*string <= '9')) {
        switch (mode) {
          /* Map 0->9 to A->K for glob/chan so they are not lost */
        case 0:
          which->udef_global |= 1 << (*string - '0');
          break;
        case 1:
          which->udef_chan |= 1 << (*string - '0');
          break;
        case 2:
          which->bot |= BOT_FLAG0 << (*string - '0');
          break;
        }
      }
    }
    string++;
  }
  for (which = plus; which; which = (which == plus ? minus : 0)) {
    which->global &=USER_VALID;

    which->udef_global &= 0x03ffffff;
    which->chan &= CHAN_VALID;
    which->udef_chan &= 0x03ffffff;
    which->bot &= BOT_VALID;
  }
  plus->match |= flags;
  if (minus) {
    minus->match |= flags;
    if (!(plus->match & (FR_AND | FR_OR)))
      plus->match |= FR_OR;
  }
}

int build_flags	(	char *	string,
		struct flag_record *	plus,
		struct flag_record *	minus
	)

Definition at line 487 of file flags.c.

References flag_record::bot, bot2str(), flag_record::chan, flag2str(), FR_AND, FR_BOT, FR_CHAN, FR_GLOBAL, flag_record::global, flag_record::match, flag_record::udef_chan, and flag_record::udef_global.

{
  char *old = string;

  if (plus->match & FR_GLOBAL) {
    if (minus && (plus->global ||plus->udef_global))
      *string++ = '+';
    string += flag2str(string, plus->global, plus->udef_global);

    if (minus && (minus->global ||minus->udef_global)) {
      *string++ = '-';
      string += flag2str(string, minus->global, minus->udef_global);
    }
  } else if (plus->match & FR_BOT) {
    if (minus && plus->bot)
      *string++ = '+';
    string += bot2str(string, plus->bot);
    if (minus && minus->bot) {
      *string++ = '-';
      string += bot2str(string, minus->bot);
    }
  }
  if (plus->match & FR_CHAN) {
    if (plus->match & (FR_GLOBAL | FR_BOT))
      *string++ = (plus->match & FR_AND) ? '&' : '|';
    if (minus && (plus->chan || plus->udef_chan))
      *string++ = '+';
    string += flag2str(string, plus->chan, plus->udef_chan);
    if (minus && (minus->chan || minus->udef_chan)) {
      *string++ = '-';
      string += flag2str(string, minus->global, minus->udef_chan);
    }
  }
  if (string == old) {
    *string++ = '-';
    *string = 0;
    return 0;
  }
  *string = 0;
  return string - old;
}

Here is the call graph for this function:

int chan_sanity_check	(	int	chatr,
		int	atr
	)

Definition at line 286 of file flags.c.

References BOT_SHARE, USER_AUTOHALFOP, USER_AUTOOP, USER_BOT, USER_DEHALFOP, USER_DEOP, USER_GVOICE, USER_HALFOP, USER_MASTER, USER_OP, USER_OWNER, USER_QUIET, and USER_VOICE.

Referenced by cmd_chattr(), and tcl_chattr().

{
  if ((chatr & USER_OP) && (chatr & USER_DEOP))
    chatr &= ~(USER_OP | USER_DEOP);
  if ((chatr & USER_HALFOP) && (chatr & USER_DEHALFOP))
    chatr &= ~(USER_HALFOP | USER_DEHALFOP);
  if ((chatr & USER_AUTOOP) && (chatr & USER_DEOP))
    chatr &= ~(USER_AUTOOP | USER_DEOP);
  if ((chatr & USER_AUTOHALFOP) && (chatr & USER_DEHALFOP))
    chatr &= ~(USER_AUTOHALFOP | USER_DEHALFOP);
  if ((chatr & USER_VOICE) && (chatr & USER_QUIET))
    chatr &= ~(USER_VOICE | USER_QUIET);
  if ((chatr & USER_GVOICE) && (chatr & USER_QUIET))
    chatr &= ~(USER_GVOICE | USER_QUIET);
  /* Can't be channel owner without also being channel master */
  if (chatr & USER_OWNER)
    chatr |= USER_MASTER;
  /* Master implies op */
  if (chatr & USER_MASTER)
    chatr |= USER_OP;
  /* Op implies halfop */
  if (chatr & USER_OP)
    chatr |= USER_HALFOP;
  /* Can't be +s on chan unless you're a bot */
  if (!(atr & USER_BOT))
    chatr &= ~BOT_SHARE;
  return chatr;
}

Here is the caller graph for this function:

static int flag2str	(	char *	string,
		int	bot,
		int	udef
	)			[static]

Definition at line 443 of file flags.c.

Referenced by build_flags().

{
  char x = 'a', *old = string;

  while (bot && (x <= 'z')) {
    if (bot & 1)
      *string++ = x;
    x++;
    bot = bot >> 1;
  }
  x = 'A';
  while (udef && (x <= 'Z')) {
    if (udef & 1)
      *string++ = x;
    udef = udef >> 1;
    x++;
  }
  if (string == old)
    *string++ = '-';
  return string - old;
}

Here is the caller graph for this function:

int flagrec_eq	(	struct flag_record *	req,
		struct flag_record *	have
	)

Definition at line 570 of file flags.c.

References flag_record::bot, flag_record::chan, FR_AND, FR_BOT, FR_CHAN, FR_GLOBAL, FR_OR, flag_record::global, flag_record::match, flag_record::udef_chan, and flag_record::udef_global.

{
  if (req->match & FR_AND) {
    if (req->match & FR_GLOBAL) {
      if ((req->global & have->global) !=req->global)
        return 0;
      if ((req->udef_global & have->udef_global) != req->udef_global)
        return 0;
    }
    if (req->match & FR_BOT)
      if ((req->bot & have->bot) != req->bot)
        return 0;
    if (req->match & FR_CHAN) {
      if ((req->chan & have->chan) != req->chan)
        return 0;
      if ((req->udef_chan & have->udef_chan) != req->udef_chan)
        return 0;
    }
    return 1;
  } else if (req->match & FR_OR) {
    if (!req->chan && !req->global && !req->udef_chan &&
        !req->udef_global && !req->bot)
      return 1;
    if (req->match & FR_GLOBAL) {
      if (have->global & req->global)
        return 1;
      if (have->udef_global & req->udef_global)
        return 1;
    }
    if (req->match & FR_BOT)
      if (have->bot & req->bot)
        return 1;
    if (req->match & FR_CHAN) {
      if (have->chan & req->chan)
        return 1;
      if (have->udef_chan & req->udef_chan)
        return 1;
    }
    return 0;
  }
  return 0;                     /* fr0k3 binding, dont pass it */
}

int flagrec_ok	(	struct flag_record *	req,
		struct flag_record *	have
	)

Definition at line 530 of file flags.c.

References allow_dk_cmds, flag_record::chan, chan_deop, chan_kick, flagrec_eq, FR_AND, FR_OR, glob_deop, glob_kick, glob_party, flag_record::global, flag_record::match, require_p, flag_record::udef_chan, flag_record::udef_global, USER_OP, USER_OWNER, and USER_PARTY.

{
  /* FIXME: flag masks with '&' in them won't be subject to
   *        further tests below. Example: 'o&j'
   */
  if (req->match & FR_AND)
    return flagrec_eq(req, have);
  else if (req->match & FR_OR) {
    int hav = have->global;

    /* Exception 1 - global +d/+k cant use -|-, unless they are +p */
    if (!req->chan && !req->global && !req->udef_global && !req->udef_chan) {
      if (!allow_dk_cmds) {
        if (glob_party(*have))
          return 1;
        if (glob_kick(*have) || chan_kick(*have))
          return 0;             /* +k cant use -|- commands */
        if (glob_deop(*have) || chan_deop(*have))
          return 0;             /* neither can +d's */
      }
      return 1;
    }
    /* The +n/+m checks aren't needed anymore because +n/+m
     * automatically adds lower flags
     */
    if (!require_p && ((hav & USER_OP) || (have->chan & USER_OWNER)))
      hav |= USER_PARTY;
    if (hav & req->global)
      return 1;
    if (have->chan & req->chan)
      return 1;
    if (have->udef_global & req->udef_global)
      return 1;
    if (have->udef_chan & req->udef_chan)
      return 1;
    return 0;
  }
  return 0;                     /* fr0k3 binding, dont pass it */
}

void get_user_flagrec	(	struct userrec *	u,
		struct flag_record *	fr,
		const char *	chname
	)

Definition at line 664 of file flags.c.

References flag_record::bot, flag_record::chan, chanuserrec::channel, userrec::chanrec, findchan_by_dname, chanuserrec::flags, userrec::flags, chanuserrec::flags_udef, userrec::flags_udef, FR_ANYWH, FR_BOT, FR_CHAN, FR_GLOBAL, get_user, flag_record::global, long(), flag_record::match, chanuserrec::next, NULL, rfc_casecmp, flag_record::udef_chan, flag_record::udef_global, and USERENTRY_BOTFL.

{
  struct chanuserrec *cr = NULL;

  if (!u) {
    fr->global = fr->udef_global = fr->chan = fr->udef_chan = fr->bot = 0;

    return;
  }
  if (fr->match & FR_GLOBAL) {
    fr->global = u->flags;

    fr->udef_global = u->flags_udef;
  } else {
    fr->global = 0;

    fr->udef_global = 0;
  }
  if (fr->match & FR_BOT) {
    fr->bot = (long) get_user(&USERENTRY_BOTFL, u);
  } else
    fr->bot = 0;
  if (fr->match & FR_CHAN) {
    if (fr->match & FR_ANYWH) {
      fr->chan = u->flags;
      fr->udef_chan = u->flags_udef;
      for (cr = u->chanrec; cr; cr = cr->next)
        if (findchan_by_dname(cr->channel)) {
          fr->chan |= cr->flags;
          fr->udef_chan |= cr->flags_udef;
        }
    } else {
      if (chname)
        for (cr = u->chanrec; cr; cr = cr->next)
          if (!rfc_casecmp(chname, cr->channel))
            break;
      if (cr) {
        fr->chan = cr->flags;
        fr->udef_chan = cr->flags_udef;
      } else {
        fr->chan = 0;
        fr->udef_chan = 0;
      }
    }
  }
}

Here is the call graph for this function:

char geticon

(

int

idx

)

Definition at line 324 of file flags.c.

References chan_halfop, chan_master, chan_op, chan_owner, FR_ANYWH, FR_CHAN, FR_GLOBAL, get_user_flagrec, glob_botmast, glob_halfop, glob_master, glob_op, glob_owner, and user.

{
  struct flag_record fr = { FR_GLOBAL | FR_CHAN | FR_ANYWH, 0, 0, 0, 0, 0 };

  if (!dcc[idx].user)
    return '-';
  get_user_flagrec(dcc[idx].user, &fr, 0);
  if (glob_owner(fr) || chan_owner(fr))
    return '*';
  if (glob_master(fr) || chan_master(fr))
    return '+';
  if (glob_botmast(fr))
    return '%';
  if (glob_op(fr) || chan_op(fr))
    return '@';
  if (glob_halfop(fr) || chan_halfop(fr))
    return '^';
  return '-';
}

int logmodes

(

char *

s

)

Definition at line 33 of file flags.c.

References LOG_ALL, LOG_BOTNET, LOG_BOTS, LOG_BOTSHARE, LOG_CMDS, LOG_DEBUG, LOG_FILES, LOG_JOIN, LOG_LEV1, LOG_LEV2, LOG_LEV3, LOG_LEV4, LOG_LEV5, LOG_LEV6, LOG_LEV7, LOG_LEV8, LOG_MISC, LOG_MODES, LOG_MSGS, LOG_PUBLIC, LOG_RAW, LOG_SERV, LOG_SRVOUT, LOG_WALL, and raw_log.

{
  int i;
  int res = 0;

  for (i = 0; i < strlen(s); i++)
    switch (s[i]) {
    case 'm':
    case 'M':
      res |= LOG_MSGS;
      break;
    case 'p':
    case 'P':
      res |= LOG_PUBLIC;
      break;
    case 'j':
    case 'J':
      res |= LOG_JOIN;
      break;
    case 'k':
    case 'K':
      res |= LOG_MODES;
      break;
    case 'c':
    case 'C':
      res |= LOG_CMDS;
      break;
    case 'o':
    case 'O':
      res |= LOG_MISC;
      break;
    case 'b':
    case 'B':
      res |= LOG_BOTS;
      break;
    case 'r':
    case 'R':
      res |= raw_log ? LOG_RAW : 0;
      break;
    case 'w':
    case 'W':
      res |= LOG_WALL;
      break;
    case 'x':
    case 'X':
      res |= LOG_FILES;
      break;
    case 's':
    case 'S':
      res |= LOG_SERV;
      break;
    case 'd':
    case 'D':
      res |= LOG_DEBUG;
      break;
    case 'v':
    case 'V':
      res |= raw_log ? LOG_SRVOUT : 0;
      break;
    case 't':
    case 'T':
      res |= raw_log ? LOG_BOTNET : 0;
      break;
    case 'h':
    case 'H':
      res |= raw_log ? LOG_BOTSHARE : 0;
      break;
    case '1':
      res |= LOG_LEV1;
      break;
    case '2':
      res |= LOG_LEV2;
      break;
    case '3':
      res |= LOG_LEV3;
      break;
    case '4':
      res |= LOG_LEV4;
      break;
    case '5':
      res |= LOG_LEV5;
      break;
    case '6':
      res |= LOG_LEV6;
      break;
    case '7':
      res |= LOG_LEV7;
      break;
    case '8':
      res |= LOG_LEV8;
      break;
    case '*':
      res |= LOG_ALL;
      break;
    }
  return res;
}

char* maskname

(

int

x

)

Definition at line 188 of file flags.c.

References LOG_BOTNET, LOG_BOTS, LOG_BOTSHARE, LOG_CMDS, LOG_DEBUG, LOG_FILES, LOG_JOIN, LOG_LEV1, LOG_LEV2, LOG_LEV3, LOG_LEV4, LOG_LEV5, LOG_LEV6, LOG_LEV7, LOG_LEV8, LOG_MISC, LOG_MODES, LOG_MSGS, LOG_PUBLIC, LOG_RAW, LOG_SERV, LOG_SRVOUT, LOG_WALL, my_strcpy, and raw_log.

Referenced by cmd_console(), and tell_settings().

{
  static char s[207];           /* Change this if you change the levels */
  int i = 0;

  s[0] = 0;
  if (x & LOG_MSGS)
    i += my_strcpy(s, "msgs, ");
  if (x & LOG_PUBLIC)
    i += my_strcpy(s + i, "public, ");
  if (x & LOG_JOIN)
    i += my_strcpy(s + i, "joins, ");
  if (x & LOG_MODES)
    i += my_strcpy(s + i, "kicks/modes, ");
  if (x & LOG_CMDS)
    i += my_strcpy(s + i, "cmds, ");
  if (x & LOG_MISC)
    i += my_strcpy(s + i, "misc, ");
  if (x & LOG_BOTS)
    i += my_strcpy(s + i, "bots, ");
  if ((x & LOG_RAW) && raw_log)
    i += my_strcpy(s + i, "raw, ");
  if (x & LOG_FILES)
    i += my_strcpy(s + i, "files, ");
  if (x & LOG_SERV)
    i += my_strcpy(s + i, "server, ");
  if (x & LOG_DEBUG)
    i += my_strcpy(s + i, "debug, ");
  if (x & LOG_WALL)
    i += my_strcpy(s + i, "wallops, ");
  if ((x & LOG_SRVOUT) && raw_log)
    i += my_strcpy(s + i, "server output, ");
  if ((x & LOG_BOTNET) && raw_log)
    i += my_strcpy(s + i, "botnet traffic, ");
  if ((x & LOG_BOTSHARE) && raw_log)
    i += my_strcpy(s + i, "share traffic, ");
  if (x & LOG_LEV1)
    i += my_strcpy(s + i, "level 1, ");
  if (x & LOG_LEV2)
    i += my_strcpy(s + i, "level 2, ");
  if (x & LOG_LEV3)
    i += my_strcpy(s + i, "level 3, ");
  if (x & LOG_LEV4)
    i += my_strcpy(s + i, "level 4, ");
  if (x & LOG_LEV5)
    i += my_strcpy(s + i, "level 5, ");
  if (x & LOG_LEV6)
    i += my_strcpy(s + i, "level 6, ");
  if (x & LOG_LEV7)
    i += my_strcpy(s + i, "level 7, ");
  if (x & LOG_LEV8)
    i += my_strcpy(s + i, "level 8, ");
  if (i)
    s[i - 2] = 0;
  else
    strcpy(s, "none");
  return s;
}

Here is the caller graph for this function:

char* masktype

(

int

x

)

Definition at line 131 of file flags.c.

References LOG_BOTNET, LOG_BOTS, LOG_BOTSHARE, LOG_CMDS, LOG_DEBUG, LOG_FILES, LOG_JOIN, LOG_LEV1, LOG_LEV2, LOG_LEV3, LOG_LEV4, LOG_LEV5, LOG_LEV6, LOG_LEV7, LOG_LEV8, LOG_MISC, LOG_MODES, LOG_MSGS, LOG_PUBLIC, LOG_RAW, LOG_SERV, LOG_SRVOUT, LOG_WALL, and raw_log.

{
  static char s[24];            /* Change this if you change the levels */
  char *p = s;

  if (x & LOG_MSGS)
    *p++ = 'm';
  if (x & LOG_PUBLIC)
    *p++ = 'p';
  if (x & LOG_JOIN)
    *p++ = 'j';
  if (x & LOG_MODES)
    *p++ = 'k';
  if (x & LOG_CMDS)
    *p++ = 'c';
  if (x & LOG_MISC)
    *p++ = 'o';
  if (x & LOG_BOTS)
    *p++ = 'b';
  if ((x & LOG_RAW) && raw_log)
    *p++ = 'r';
  if (x & LOG_FILES)
    *p++ = 'x';
  if (x & LOG_SERV)
    *p++ = 's';
  if (x & LOG_DEBUG)
    *p++ = 'd';
  if (x & LOG_WALL)
    *p++ = 'w';
  if ((x & LOG_SRVOUT) && raw_log)
    *p++ = 'v';
  if ((x & LOG_BOTNET) && raw_log)
    *p++ = 't';
  if ((x & LOG_BOTSHARE) && raw_log)
    *p++ = 'h';
  if (x & LOG_LEV1)
    *p++ = '1';
  if (x & LOG_LEV2)
    *p++ = '2';
  if (x & LOG_LEV3)
    *p++ = '3';
  if (x & LOG_LEV4)
    *p++ = '4';
  if (x & LOG_LEV5)
    *p++ = '5';
  if (x & LOG_LEV6)
    *p++ = '6';
  if (x & LOG_LEV7)
    *p++ = '7';
  if (x & LOG_LEV8)
    *p++ = '8';
  if (p == s)
    *p++ = '-';
  *p = 0;
  return s;
}

int sanity_check

(

int

atr

)

Definition at line 249 of file flags.c.

References USER_AUTOHALFOP, USER_AUTOOP, USER_BOT, USER_BOTMAST, USER_COMMON, USER_DEHALFOP, USER_DEOP, USER_GVOICE, USER_HALFOP, USER_JANITOR, USER_MASTER, USER_OP, USER_OWNER, USER_PARTY, USER_QUIET, USER_VOICE, and USER_XFER.

{
  if ((atr & USER_BOT) &&
      (atr & (USER_PARTY | USER_MASTER | USER_COMMON | USER_OWNER)))
    atr &= ~(USER_PARTY | USER_MASTER | USER_COMMON | USER_OWNER);
  if ((atr & USER_OP) && (atr & USER_DEOP))
    atr &= ~(USER_OP | USER_DEOP);
  if ((atr & USER_HALFOP) && (atr & USER_DEHALFOP))
    atr &= ~(USER_HALFOP | USER_DEHALFOP);
  if ((atr & USER_AUTOOP) && (atr & USER_DEOP))
    atr &= ~(USER_AUTOOP | USER_DEOP);
  if ((atr & USER_AUTOHALFOP) && (atr & USER_DEHALFOP))
    atr &= ~(USER_AUTOHALFOP | USER_DEHALFOP);
  if ((atr & USER_VOICE) && (atr & USER_QUIET))
    atr &= ~(USER_VOICE | USER_QUIET);
  if ((atr & USER_GVOICE) && (atr & USER_QUIET))
    atr &= ~(USER_GVOICE | USER_QUIET);
  /* Can't be owner without also being master */
  if (atr & USER_OWNER)
    atr |= USER_MASTER;
  /* Master implies botmaster, op and janitor */
  if (atr & USER_MASTER)
    atr |= USER_BOTMAST | USER_OP | USER_JANITOR;
  /* Can't be botnet master without party-line access */
  if (atr & USER_BOTMAST)
    atr |= USER_PARTY;
  /* Janitors can use the file area */
  if (atr & USER_JANITOR)
    atr |= USER_XFER;
  /* Ops should be halfops */
  if (atr & USER_OP)
    atr |= USER_HALFOP;
  return atr;
}

void set_user_flagrec	(	struct userrec *	u,
		struct flag_record *	fr,
		const char *	chname
	)

Definition at line 613 of file flags.c.

References flag_record::bot, build_flags, flag_record::chan, chanuserrec::channel, channel_shared, userrec::chanrec, egg_bzero, findchan_by_dname, chanuserrec::flags, userrec::flags, chanuserrec::flags_udef, userrec::flags_udef, FR_BOT, FR_CHAN, FR_GLOBAL, flag_record::global, userrec::handle, flag_record::match, chanuserrec::next, noshare, NULL, rfc_casecmp, set_user, shareout, strncpyz, flag_record::udef_chan, flag_record::udef_global, USER_BOT, user_malloc, USER_UNSHARED, and USERENTRY_BOTFL.

{
  struct chanuserrec *cr = NULL;
  int oldflags = fr->match;
  char buffer[100];
  struct chanset_t *ch;

  if (!u)
    return;
  if (oldflags & FR_GLOBAL) {
    u->flags = fr->global;

    u->flags_udef = fr->udef_global;
    if (!noshare && !(u->flags & USER_UNSHARED)) {
      fr->match = FR_GLOBAL;
      build_flags(buffer, fr, NULL);
      shareout(NULL, "a %s %s\n", u->handle, buffer);
    }
  }
  if ((oldflags & FR_BOT) && (u->flags & USER_BOT))
    set_user(&USERENTRY_BOTFL, u, (void *) fr->bot);
  /* Don't share bot attrs */
  if ((oldflags & FR_CHAN) && chname) {
    for (cr = u->chanrec; cr; cr = cr->next)
      if (!rfc_casecmp(chname, cr->channel))
        break;
    ch = findchan_by_dname(chname);
    if (!cr && ch) {
      cr = user_malloc(sizeof(struct chanuserrec));
      egg_bzero(cr, sizeof(struct chanuserrec));

      cr->next = u->chanrec;
      u->chanrec = cr;
      strncpyz(cr->channel, chname, sizeof cr->channel);
    }
    if (cr && ch) {
      cr->flags = fr->chan;
      cr->flags_udef = fr->udef_chan;
      if (!noshare && !(u->flags & USER_UNSHARED) && channel_shared(ch)) {
        fr->match = FR_CHAN;
        build_flags(buffer, fr, NULL);
        shareout(ch, "a %s %s %s\n", u->handle, buffer, chname);
      }
    }
  }
  fr->match = oldflags;
}

---

Variable Documentation

int allow_dk_cmds

Definition at line 77 of file tcl.c.

Referenced by flagrec_ok().

struct dcc_t* dcc

Definition at line 46 of file dcc.c.

int noshare

int raw_log

Definition at line 64 of file misc.c.

int require_p

Definition at line 50 of file dcc.c.

struct user_entry_type USERENTRY_BOTFL

Initial value:

 {
  0,                            
  0,
  def_dupuser,
  botfl_unpack,
  botfl_pack,
  botfl_write_userfile,
  botfl_kill,
  def_get,
  botfl_set,
  botfl_tcl_get,
  botfl_tcl_set,
  botfl_expmem,
  botfl_display,
  "BOTFL"
}

Definition at line 820 of file flags.c.