modules/server/party_commands.c File Reference

#include "server.h"

Go to the source code of this file.

Functions
static int	party_servers (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static void	parse_server (const char *text, char **host, int *port, char **pass)
static int	party_plus_server (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_minus_server (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_dump (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_jump (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_chanmembermode (partymember_t *p, user_t *u, const char *cmd, const char *text, const char *flags, const char *mode)
static int	party_op (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_deop (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_halfop (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_dehalfop (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_voice (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_devoice (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_msg (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_act (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static void	parse_chanset (channel_t *chan, const char *settings)
static int	party_pls_chan (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_minus_chan (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	channel_get_modes (channel_t *chan, char *buf, int maxlen)
static char	channel_get_prefix (channel_member_t *m)
static int	party_channels (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_chanset (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_chaninfo (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_chansave (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_plus_mask (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_list_masks (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
static int	party_minus_mask (partymember_t *p, const char *nick, user_t *u, const char *cmd, const char *text)
Variables
static const char	rcsid [] = "$Id: party_commands.c,v 1.28 2008-10-17 15:57:43 sven Exp $"
bind_list_t	server_party_commands []

---

Function Documentation

static int channel_get_modes	(	channel_t *	chan,
		char *	buf,
		int	maxlen
	)			[static]

Definition at line 355 of file party_commands.c.

References channel::args, flag_to_str(), channel::mode, channel::nargs, channel_mode_arg::type, and channel_mode_arg::value.

Referenced by party_channels().

{
  int i, len, l;

  flag_to_str(&chan->mode, buf);
  len = strlen(buf);
  for (i = 0; i < chan->nargs; ++i) {
    if (!chan->args[i].value) continue;
    buf[len++] = chan->args[i].type;
    if (len + 1 > maxlen) {
      buf[len] = 0;
      return 1;
    }
  }
  buf[len] = 0;
  for (i = 0; i < chan->nargs; ++i) {
    if (!chan->args[i].value) continue;
    l = strlen(chan->args[i].value);
    if (len + 2 + l > maxlen) return 1;
    buf[len++] = ' ';
    strcpy(buf + len, chan->args[i].value);
    len += l;
  }
  return 0;
}

static char channel_get_prefix

(

channel_member_t *

m

)

[static]

Definition at line 381 of file party_commands.c.

References current_server, flag_to_str(), and channel_member::mode.

Referenced by party_channels().

{
  int i, len;
  char buf[256];

  flag_to_str(&m->mode, buf);
  len = strlen(current_server.modeprefix);
  for (i = 0; i < len; ++i) {
    if (strchr(buf, current_server.modeprefix[i])) return current_server.whoprefix[i];
  }
  return ' ';
}

static void parse_chanset	(	channel_t *	chan,
		const char *	settings
	)			[static]

Definition at line 265 of file party_commands.c.

References channel_set, egg_get_arg(), and NULL.

Referenced by party_chanset(), and party_pls_chan().

{
  char *name, *value;
  char flagbuf[2] = {0, 0};

  while (settings) {
    egg_get_arg(settings, &settings, &name);
    if (!name) break;
    if (*name == '+' || *name == '-') {
      if (*name == '+') flagbuf[0] = '1';
      else flagbuf[0] = '0';
      value = flagbuf;
      if (*(name+1)) channel_set(chan, flagbuf, name+1, 0, NULL);
    }
    else {
      egg_get_arg(settings, &settings, &value);
      channel_set(chan, value, name, 0, NULL);
      if (value) free(value);
    }
    free(name);
  }
}

static void parse_server	(	const char *	text,
		char **	host,
		int *	port,
		char **	pass
	)			[static]

Definition at line 44 of file party_commands.c.

References NULL.

Referenced by party_jump(), party_minus_server(), and party_plus_server().

{
  char *sep, *sport = NULL;

  *pass = NULL;
  *port = 0;
  while (isspace(*text)) text++;
  *host = strdup(text);
  sep = strchr(*host, ' ');
  if (sep) {
    *sep++ = 0;
    while (isspace(*sep)) sep++;
    sport = sep;
    sep = strchr(sep, ' ');
    if (sep) {
      *sep++ = 0;
      while (isspace(*sep)) sep++;
      *pass = sep;
    }
    *port = atoi(sport);
  }
}

static int party_act	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 247 of file party_commands.c.

References _, BIND_RET_LOG, egg_get_arg(), partymember_printf(), printserv, and SERVER_NORMAL.

{
  char *dest;
  const char *next;

  egg_get_arg(text, &next, &dest);
  if (!next || !*next || !dest || !*dest) {
    partymember_printf(p, _("Syntax: act <nick/chan> <action>"));
    if (dest) free(dest);
    return(0);
  }

  printserv(SERVER_NORMAL, "PRIVMSG %s :\001ACTION %s\001\r\n", dest, next);
  partymember_printf(p, _("Action to %1$s: %2$s"), dest, next);
  free(dest);
  return(BIND_RET_LOG);
}

static int party_chaninfo	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 464 of file party_commands.c.

References BIND_RET_LOG, channel_get, channel_probe, CHANNEL_STATIC, egg_get_arg(), channel::flags, channel::name, NULL, partymember_printf(), and server_config.

{
  channel_t *chan;
  char *next, *item, *value;

  while (text && isspace(*text)) text++;

  if (!text || !*text) {
    partymember_printf(p, "Syntax: %s <channel>", cmd);
    return(0);
  }

  chan = channel_probe(text, 0);
  if (!chan) {
    partymember_printf(p, "Channel not found!");
    return(0);
  }

  partymember_printf(p, "Information about '%s':", chan->name);
  if (!(chan->flags & CHANNEL_STATIC)) {
    partymember_printf(p, "Saved settings: none (not a static channel)");
  }
  else {
    next = server_config.chaninfo_items;
    while (next && *next) {
      egg_get_arg(next, &next, &item);
      if (!item) break;
      channel_get(chan, &value, item, 0, NULL);
      if (value) {
        partymember_printf(p, "%s: %s", item, value);
      }
      free(item);
    }
  }
  return(BIND_RET_LOG);
}

static int party_chanmembermode	(	partymember_t *	p,
		user_t *	u,
		const char *	cmd,
		const char *	text,
		const char *	flags,
		const char *	mode
	)			[static]

Definition at line 146 of file party_commands.c.

References BIND_RET_LOG, channel_probe, egg_get_arg(), channel::name, partychan::name, NULL, partychan_get_default(), partymember_printf(), printserv, SERVER_NORMAL, user_check_flags_str(), and user_check_partial_flags_str().

Referenced by party_dehalfop(), party_deop(), party_devoice(), party_halfop(), party_op(), and party_voice().

{
  char *nick, *chan;
  partychan_t *pchan;
  channel_t *ircchan;

  egg_get_arg(text, &text, &chan);

  if (!chan) {
    partymember_printf(p, "Syntax: %s [channel] <nick>", cmd);
    return(0);
  }

  if (text && *text) nick = strdup(text);
  else {
    nick = chan;
    pchan = partychan_get_default(p);
    if (pchan) chan = strdup(pchan->name);
    else {
      partymember_printf(p, "You are not on a partyline channel! Please specify a channel: %s [channel] <nick>", cmd);
      free(nick);
      return(0);
    }
  }

  ircchan = channel_probe(chan, 0);
  if (!ircchan) {
    partymember_printf(p, "I'm not on '%s', as far as I know!", chan);
    free(nick);
    free(chan);
    return(0);
  }

  if (user_check_partial_flags_str(u, NULL, flags) || user_check_flags_str(u, chan, flags)) {
    partymember_printf(p, "Setting mode %s for %s on %s", mode, nick, ircchan->name);
    printserv(SERVER_NORMAL, "MODE %s %s %s", ircchan->name, mode, nick);
  }
  else {
    partymember_printf(p, "You need +%s to set that mode!", flags);
  }
  free(nick);
  free(chan);
  return(BIND_RET_LOG);
}

static int party_channels	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 395 of file party_commands.c.

References _, BIND_RET_LOG, channel_get_modes(), channel_get_prefix(), channel_head, channel_probe, user::handle, channel::member_head, channel::name, nchannels, channel_member::next, channel::next, channel_member::nick, channel::nmembers, partymember_printf(), channel::topic, channel_member::uhost, and user_lookup_by_irchost().

{
  char buf[512];
  user_t *user;
  channel_t *chan;
  channel_member_t *m;

  if ( !text || !*text) {
    if (nchannels <= 0) {
      partymember_printf(p, _("The channel list is empty."));
      return BIND_RET_LOG;
    }

    for (chan = channel_head; chan; chan = chan->next) {
      partymember_printf(p, "   %s : %d member%s", chan->name, chan->nmembers, chan->nmembers == 1 ? "" : "s");
    }
    return BIND_RET_LOG;
  }

  chan = channel_probe(text, 0);
  if (!chan) {
    partymember_printf(p, "Channel not found!");
    return 0;
  }

  if (!chan->nmembers) {
    partymember_printf(p, "Not in channel.");
    return 0;
  }

  channel_get_modes(chan, buf, 512);
  partymember_printf(p, "Channel %s, %d member%s, mode +%s:", chan->name, chan->nmembers, chan->nmembers == 1 ? "" : "s", buf);
  partymember_printf(p, "Channel Topic: %s", chan->topic);
  partymember_printf(p, "(n = owner, m = master, o = op, d = deop, b = bot)");
  partymember_printf(p, " NICKNAME        HANDLE          JOIN  IDLE  USER@HOST");
  for (m = chan->member_head; m; m = m->next) {
    snprintf(buf, 512, "%s!%s", m->nick, m->uhost);
    user = user_lookup_by_irchost(buf);
    partymember_printf(p, "%c%-15s %-15s %-5s %-5s %s", channel_get_prefix(m), m->nick, user ? user->handle : "*", "N/A", "N/A", m->uhost);
  }
  partymember_printf(p, "End of channel info.");
  return BIND_RET_LOG;
}

static int party_chansave	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 502 of file party_commands.c.

References BIND_RET_LOG, channel_save, and server_config.

{
  while (text && isspace(*text)) text++;

  channel_save(text && *text ? text : server_config.chanfile);
  return(BIND_RET_LOG);
}

static int party_chanset	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 440 of file party_commands.c.

References BIND_RET_LOG, channel_probe, egg_get_arg(), parse_chanset(), and partymember_printf().

{
  const char *settings;
  char *name;
  channel_t *chan;

  egg_get_arg(text, &settings, &name);
  if (!name) {
    partymember_printf(p, "Syntax: %s <channel> [settings]", cmd);
    return(0);
  }

  chan = channel_probe(name, 0);
  free(name);
  if (!chan) {
    partymember_printf(p, "Channel not found! Use +chan if you want to create a new channel.");
    return(0);
  }

  parse_chanset(chan, settings);
  return(BIND_RET_LOG);
}

static int party_dehalfop	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 210 of file party_commands.c.

References party_chanmembermode().

{
  return party_chanmembermode(p, u, cmd, text, "lo", "-l");
}

static int party_deop	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 198 of file party_commands.c.

References party_chanmembermode().

{
  return party_chanmembermode(p, u, cmd, text, "o", "-o");
}

static int party_devoice	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 222 of file party_commands.c.

References party_chanmembermode().

{
  return party_chanmembermode(p, u, cmd, text, "lo", "-v");
}

static int party_dump	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 114 of file party_commands.c.

References _, BIND_RET_LOG, partymember_printf(), printserv, and SERVER_NORMAL.

{
  if (!text || !*text) {
    partymember_printf(p, _("Syntax: dump <commands>"));
    return(0);
  }

  printserv(SERVER_NORMAL, "%s\r\n", text);
  return(BIND_RET_LOG);
}

static int party_halfop	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 204 of file party_commands.c.

References party_chanmembermode().

{
  return party_chanmembermode(p, u, cmd, text, "lo", "+l");
}

static int party_jump	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 126 of file party_commands.c.

References _, BIND_RET_LOG, kill_server, parse_server(), partymember_printf(), server_add, server_config, server_find, server_list_index, and server_set_next.

{
  char *host, *pass;
  int port, num;

  if (text && *text) {
    parse_server(text, &host, &port, &pass);
    num = server_find(host, port, pass);
    if (num < 0) {
      num = server_add(host, port, pass);
      partymember_printf(p, _("Added %s/%d as server #%d.\n"), host, port ? port : server_config.default_port, num+1);
    }
    free(host);
  }
  else num = server_list_index+1;
  server_set_next(num);
  kill_server("changing servers");
  return(BIND_RET_LOG);
}

static int party_list_masks	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 519 of file party_commands.c.

References BIND_RET_LOG.

{
  return(BIND_RET_LOG);
}

static int party_minus_chan	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 336 of file party_commands.c.

References BIND_RET_LOG, channel_remove, partymember_printf(), printserv, and SERVER_NORMAL.

{
  while (text && isspace(*text)) text++;

  if (!text || !*text) {
    partymember_printf(p, "Syntax: -chan <channel>");
    return(0);
  }

  if (channel_remove(text)) {
    partymember_printf(p, "Channel not found!");
    return(0);
  }

  partymember_printf(p, "Channel '%s' has been removed.", text);
  printserv(SERVER_NORMAL, "PART %s", text);
  return(BIND_RET_LOG);
}

static int party_minus_mask	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 526 of file party_commands.c.

References BIND_RET_LOG.

{
  return(BIND_RET_LOG);
}

static int party_minus_server	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 92 of file party_commands.c.

References _, BIND_RET_LOG, parse_server(), partymember_printf(), server_del, and server_find.

{
  char *host, *pass;
  int port, i;

  if (!text || !*text) {
    partymember_printf(p, _("Syntax: -server <host> [port] [pass]"));
    return(0);
  }

  parse_server(text, &host, &port, &pass);
  i = server_find(host, port, pass);
  free(host);
  if (i < 0) partymember_printf(p, _("No matching servers."));
  else {
    server_del(i);
    partymember_printf(p, _("Deleted server %d."), i+1);
  }
  return(BIND_RET_LOG);
}

static int party_msg	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 228 of file party_commands.c.

References _, BIND_RET_LOG, egg_get_arg(), partymember_printf(), printserv, and SERVER_NORMAL.

{
  char *dest;
  const char *next;

  egg_get_arg(text, &next, &dest);
  if (!next || !*next || !dest || !*dest) {
    partymember_printf(p, _("Syntax: %s <nick/chan> <message>"), cmd);
    if (dest) free(dest);
    return(0);
  }

  printserv(SERVER_NORMAL, "PRIVMSG %s :%s\r\n", dest, next);
  partymember_printf(p, _("Msg to %1$s: %2$s"), dest, next);
  free(dest);
  return(BIND_RET_LOG);
}

static int party_op	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 192 of file party_commands.c.

References party_chanmembermode().

{
  return party_chanmembermode(p, u, cmd, text, "o", "+o");
}

static int party_pls_chan	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 289 of file party_commands.c.

References _, BIND_RET_LOG, channel_add, channel_get, channel_lookup, CHANNEL_STATIC, egg_get_arg(), channel::flags, channel::name, NULL, parse_chanset(), partymember_printf(), printserv, SERVER_NORMAL, and server_support.

{
  const char *settings, *chantypes;
  char *name, *key;
  channel_t *chan;

  egg_get_arg(text, &settings, &name);
  if (!name) {
    partymember_printf(p, "Syntax: +chan <channel> [settings]");
    return(0);
  }

  if (server_support("CHANTYPES", &chantypes) == -1) chantypes = "#&";

  if (!strchr(chantypes, *name)) {
    partymember_printf(p, _("Error: '%c' is not a valid channel prefix."), *name);
    partymember_printf(p, _("       This server supports '%s'"), chantypes);
    free(name);
    return(0);
  }

  chan = channel_lookup(name);
  if (chan) {
    if (chan->flags & CHANNEL_STATIC) {
      partymember_printf(p, _("Error: Channel '%s' already exists!"), name);
      free(name);
      return(0);
    }
    chan->flags |= CHANNEL_STATIC;
    partymember_printf(p, _("Channel '%s' has been made permanent."), name);
    return(BIND_RET_LOG);
  }

  chan = channel_add(name);
  partymember_printf(p, _("Channel '%s' has been created."), name);
  free(name);

  parse_chanset(chan, settings);

  channel_get(chan, &key, "key", 0, NULL);
  if (key && strlen(key)) printserv(SERVER_NORMAL, "JOIN %s %s", chan->name, key);
  else printserv(SERVER_NORMAL, "JOIN %s", chan->name);

  return(BIND_RET_LOG);
}

static int party_plus_mask	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 512 of file party_commands.c.

References BIND_RET_LOG.

{
  return(BIND_RET_LOG);
}

static int party_plus_server	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 68 of file party_commands.c.

References _, BIND_RET_LOG, parse_server(), partymember_printf(), server_add, and server_config.

{
  char *host, *pass;
  int port;

  if (!text || !*text) {
    partymember_printf(p, _("Syntax: +server <host> [port] [pass]"));
    return(0);
  }

  parse_server(text, &host, &port, &pass);
  if (!strlen(host)) {
    partymember_printf(p, _("Please specify a valid host."));
    free(host);
    return(0);
  }

  server_add(host, port, pass);
  partymember_printf(p, _("Added %s/%d.\n"), host, port ? port : server_config.default_port);
  free(host);
  return(BIND_RET_LOG);
}

static int party_servers	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 27 of file party_commands.c.

References _, BIND_RET_LOG, server::host, server::next, partymember_printf(), server::pass, server::port, server_list, and server_list_len.

{
  server_t *s;

  if (server_list_len <= 0) {
    partymember_printf(p, _("The server list is empty."));
    return(BIND_RET_LOG);
  }

  partymember_printf(p, _("%d server%s:"), server_list_len, (server_list_len != 1) ? "s" : "");
  for (s = server_list; s; s = s->next) {
    if (s->port) partymember_printf(p, _("   %s (port %d)%s"), s->host, s->port, s->pass ? _(" (password set)") : "");
    else partymember_printf(p, _("   %s (default port)%s"), s->host, s->pass ? _(" (password set)") : "");
  }
  return(BIND_RET_LOG);
}

static int party_voice	(	partymember_t *	p,
		const char *	nick,
		user_t *	u,
		const char *	cmd,
		const char *	text
	)			[static]

Definition at line 216 of file party_commands.c.

References party_chanmembermode().

{
  return party_chanmembermode(p, u, cmd, text, "lo", "+v");
}

---

Variable Documentation

const char rcsid[] = "$Id: party_commands.c,v 1.28 2008-10-17 15:57:43 sven Exp $" [static]

Definition at line 21 of file party_commands.c.

bind_list_t server_party_commands[]

Definition at line 532 of file party_commands.c.