[irc/quakenet/snircd.git] / ircd / jupe.c

/*
 * IRC - Internet Relay Chat, ircd/jupe.c
 * Copyright (C) 1990 Jarkko Oikarinen and
 *                    University of Oulu, Finland
 * Copyright (C) 2000 Kevin L. Mitchell <klmitch@mit.edu>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 1, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
/** @file
 * @brief Implementation of juped server handling functions.
 * @version $Id: jupe.c,v 1.20 2004/12/11 05:13:45 klmitch Exp $
 */
#include "config.h"

#include "jupe.h"
#include "client.h"
#include "hash.h"
#include "ircd.h"
#include "ircd_alloc.h"
#include "ircd_features.h"
#include "ircd_log.h"
#include "ircd_reply.h"
#include "ircd_string.h"
#include "match.h"
#include "msg.h"
#include "numeric.h"
#include "numnicks.h"
#include "s_bsd.h"
#include "s_misc.h"
#include "send.h"
#include "struct.h"
#include "sys.h"    /* FALSE bleah */

/* #include <assert.h> -- Now using assert in ircd_log.h */
#include <string.h>

/** List of jupes. */
static struct Jupe *GlobalJupeList = 0;

/** Allocate a new jupe with the given parameters.
 * @param[in] server Server name to jupe.
 * @param[in] reason Reason for jupe.
 * @param[in] expire Expiration time for jupe.
 * @param[in] lastmod Last modification time for jupe.
 * @param[in] flags Flags to set for the jupe.
 */
static struct Jupe *
make_jupe(char *server, char *reason, time_t expire, time_t lastmod,
	  unsigned int flags)
{
  struct Jupe *ajupe;

  ajupe = (struct Jupe*) MyMalloc(sizeof(struct Jupe)); /* alloc memory */
  assert(0 != ajupe);

  DupString(ajupe->ju_server, server); /* copy vital information */
  DupString(ajupe->ju_reason, reason);
  ajupe->ju_expire = expire;
  ajupe->ju_lastmod = lastmod;
  ajupe->ju_flags = flags & JUPE_MASK; /* set jupe flags */

  ajupe->ju_next = GlobalJupeList; /* link it into the list */
  ajupe->ju_prev_p = &GlobalJupeList;
  if (GlobalJupeList)
    GlobalJupeList->ju_prev_p = &ajupe->ju_next;
  GlobalJupeList = ajupe;

  return ajupe;
}

/** Apply a jupe.
 * @param[in] cptr Local client that sent us the jupe.
 * @param[in] sptr Originator of the jupe.
 * @param[in] jupe Jupe to check.
 */
static int
do_jupe(struct Client *cptr, struct Client *sptr, struct Jupe *jupe)
{
  struct Client *acptr;

  if (!JupeIsActive(jupe)) /* no action to be taken on inactive jupes */
    return 0;

  acptr = FindServer(jupe->ju_server);

  /* server isn't online or isn't local or is me */
  if (!acptr || !MyConnect(acptr) || IsMe(acptr))
    return 0;

  return exit_client_msg(cptr, acptr, &me, "Juped: %s", jupe->ju_reason);
}

/** Forward a jupe to another server.
 * @param[in] cptr Local client that sent us the jupe.
 * @param[in] sptr Originator of the jupe.
 * @param[in] jupe Jupe to forward.
 */
static void
propagate_jupe(struct Client *cptr, struct Client *sptr, struct Jupe *jupe)
{
  if (JupeIsLocal(jupe)) /* don't propagate local jupes */
    return;

  sendcmdto_serv_butone(sptr, CMD_JUPE, cptr, "* %c%s %Tu %Tu :%s",
			JupeIsRemActive(jupe) ? '+' : '-', jupe->ju_server,
			jupe->ju_expire - CurrentTime, jupe->ju_lastmod,
			jupe->ju_reason);
}

/** Add a new server jupe.
 * @param[in] cptr Local client that sent us the jupe.
 * @param[in] sptr Originator of the jupe.
 * @param[in] server Server name to jupe.
 * @param[in] reason Reason for the jupe.
 * @param[in] expire Jupe duration in seconds.
 * @param[in] lastmod Last modification timestamp (or NULL).
 * @param[in] flags Flags to set on jupe.
 * @return Zero, unless the jupe causes \a cptr to be SQUIT, in which
 * case CPTR_KILLED.
 */
int
jupe_add(struct Client *cptr, struct Client *sptr, char *server, char *reason,
	 time_t expire, time_t lastmod, unsigned int flags)
{
  struct Jupe *ajupe;

  assert(0 != server);
  assert(0 != reason);

  /*
   * You cannot set a negative (or zero) expire time, nor can you set an
   * expiration time for greater than JUPE_MAX_EXPIRE.
   */
  if (expire <= 0 || expire > JUPE_MAX_EXPIRE) {
    if (!IsServer(cptr) && MyConnect(cptr))
      send_reply(cptr, ERR_BADEXPIRE, expire);
    return 0;
  }

  expire += CurrentTime; /* convert from lifetime to timestamp */

  /* Inform ops and log it */
  sendto_opmask_butone(0, SNO_NETWORK, "%s adding %sJUPE for %s, expiring at "
                       "%Tu: %s",
                       (feature_bool(FEAT_HIS_SNOTICES) || IsServer(sptr)) ?
                         cli_name(sptr) :
                         cli_name((cli_user(sptr))->server),
		       flags & JUPE_LOCAL ? "local " : "", server,
		       expire + TSoffset, reason);

  log_write(LS_JUPE, L_INFO, LOG_NOSNOTICE,
	    "%#C adding %sJUPE for %s, expiring at %Tu: %s", sptr,
	    flags & JUPE_LOCAL ? "local " : "", server, expire + TSoffset,
	    reason);

  /* make the jupe */
  ajupe = make_jupe(server, reason, expire, lastmod, flags);

  propagate_jupe(cptr, sptr, ajupe);

  return do_jupe(cptr, sptr, ajupe); /* remove server if necessary */
}

/** Activate a jupe, optionally changing its lastmod and flags.
 * @param[in] cptr Local client that sent us the jupe.
 * @param[in] sptr Originator of the jupe.
 * @param[in] jupe Jupe to activate.
 * @param[in] lastmod New timestamp for last modification of the jupe.
 * @param[in] flags Flags to set on the jupe.
 * @return Zero, unless the jupe causes \a cptr to be SQUIT, in which
 * case CPTR_KILLED.
 */
int
jupe_activate(struct Client *cptr, struct Client *sptr, struct Jupe *jupe,
	      time_t lastmod, unsigned int flags)
{
  unsigned int saveflags = 0;

  assert(0 != jupe);

  saveflags = jupe->ju_flags;

  if (flags & JUPE_LOCAL)
    jupe->ju_flags &= ~JUPE_LDEACT;
  else {
    jupe->ju_flags |= JUPE_ACTIVE;

    if (jupe->ju_lastmod >= lastmod) /* force lastmod to increase */
      jupe->ju_lastmod++;
    else
      jupe->ju_lastmod = lastmod;
  }

  if ((saveflags & JUPE_ACTMASK) == JUPE_ACTIVE)
    return 0; /* was active to begin with */

  /* Inform ops and log it */
  sendto_opmask_butone(0, SNO_NETWORK, "%s activating JUPE for %s, expiring "
		       "at %Tu: %s",
                       (feature_bool(FEAT_HIS_SNOTICES) || IsServer(sptr)) ?
                         cli_name(sptr) :
                         cli_name((cli_user(sptr))->server),
		       jupe->ju_server, jupe->ju_expire + TSoffset,
		       jupe->ju_reason);

  log_write(LS_JUPE, L_INFO, LOG_NOSNOTICE,
	    "%#C activating JUPE for %s, expiring at %Tu: %s",sptr,
	    jupe->ju_server, jupe->ju_expire + TSoffset, jupe->ju_reason);

  if (!(flags & JUPE_LOCAL)) /* don't propagate local changes */
    propagate_jupe(cptr, sptr, jupe);

  return do_jupe(cptr, sptr, jupe);
}

/** Deactivate a jupe.
 * @param[in] cptr Local client that sent us the jupe.
 * @param[in] sptr Originator of the jupe.
 * @param[in] jupe Jupe to deactivate.
 * @param[in] lastmod New timestamp for last modification of the jupe.
 * @param[in] flags Flags to set on the jupe.
 * @return Zero.
 */
int
jupe_deactivate(struct Client *cptr, struct Client *sptr, struct Jupe *jupe,
		time_t lastmod, unsigned int flags)
{
  unsigned int saveflags = 0;

  assert(0 != jupe);

  saveflags = jupe->ju_flags;

  if (!JupeIsLocal(jupe)) {
    if (flags & JUPE_LOCAL)
      jupe->ju_flags |= JUPE_LDEACT;
    else {
      jupe->ju_flags &= ~JUPE_ACTIVE;

      if (jupe->ju_lastmod >= lastmod) /* force lastmod to increase */
	jupe->ju_lastmod++;
      else
	jupe->ju_lastmod = lastmod;
    }

    if ((saveflags & JUPE_ACTMASK) != JUPE_ACTIVE)
      return 0; /* was inactive to begin with */
  }

  /* Inform ops and log it */
  sendto_opmask_butone(0, SNO_NETWORK, "%s %s JUPE for %s, expiring at %Tu: "
		       "%s",
                       (feature_bool(FEAT_HIS_SNOTICES) || IsServer(sptr)) ?
                         cli_name(sptr) :
                         cli_name((cli_user(sptr))->server),
		       JupeIsLocal(jupe) ? "removing local" : "deactivating",
		       jupe->ju_server, jupe->ju_expire + TSoffset,
		       jupe->ju_reason);

  log_write(LS_JUPE, L_INFO, LOG_NOSNOTICE,
	    "%#C %s JUPE for %s, expiring at %Tu: %s", sptr,
	    JupeIsLocal(jupe) ? "removing local" : "deactivating",
	    jupe->ju_server, jupe->ju_expire + TSoffset, jupe->ju_reason);

  if (JupeIsLocal(jupe))
    jupe_free(jupe);
  else if (!(flags & JUPE_LOCAL)) /* don't propagate local changes */
    propagate_jupe(cptr, sptr, jupe);

  return 0;
}

/** Find a jupe by name.
 * @param[in] server %Jupe name to search for.
 * @return Matching jupe (or NULL if none match).
 */
struct Jupe *
jupe_find(char *server)
{
  struct Jupe* jupe;
  struct Jupe* sjupe;

  for (jupe = GlobalJupeList; jupe; jupe = sjupe) { /* go through jupes */
    sjupe = jupe->ju_next;

    if (jupe->ju_expire <= CurrentTime) /* expire any that need expiring */
      jupe_free(jupe);
    else if (0 == ircd_strcmp(server, jupe->ju_server)) /* found it yet? */
      return jupe;
  }

  return 0;
}

/** Unlink and free an unused jupe.
 * @param[in] jupe Server jupe to free.
 */
void
jupe_free(struct Jupe* jupe)
{
  assert(0 != jupe);

  *jupe->ju_prev_p = jupe->ju_next; /* squeeze this jupe out */
  if (jupe->ju_next)
    jupe->ju_next->ju_prev_p = jupe->ju_prev_p;

  MyFree(jupe->ju_server);  /* and free up the memory */
  MyFree(jupe->ju_reason);
  MyFree(jupe);
}

/** Send the full list of active global jupes to \a cptr.
 * @param[in] cptr Local server to send jupes to.
 */
void
jupe_burst(struct Client *cptr)
{
  struct Jupe *jupe;
  struct Jupe *sjupe;

  for (jupe = GlobalJupeList; jupe; jupe = sjupe) { /* go through jupes */
    sjupe = jupe->ju_next;

    if (jupe->ju_expire <= CurrentTime) /* expire any that need expiring */
      jupe_free(jupe);
    else if (!JupeIsLocal(jupe)) /* forward global jupes */
      sendcmdto_one(&me, CMD_JUPE, cptr, "* %c%s %Tu %Tu :%s",
		    JupeIsRemActive(jupe) ? '+' : '-', jupe->ju_server,
		    jupe->ju_expire - CurrentTime, jupe->ju_lastmod,
		    jupe->ju_reason);
  }
}

/** Forward a jupe to another server.
 * @param[in] cptr %Server to send jupe to.
 * @param[in] jupe Jupe to forward.
 */
int
jupe_resend(struct Client *cptr, struct Jupe *jupe)
{
  if (JupeIsLocal(jupe)) /* don't propagate local jupes */
    return 0;

  sendcmdto_one(&me, CMD_JUPE, cptr, "* %c%s %Tu %Tu :%s",
		JupeIsRemActive(jupe) ? '+' : '-', jupe->ju_server,
		jupe->ju_expire - CurrentTime, jupe->ju_lastmod,
		jupe->ju_reason);

  return 0;
}

/** Send a jupe (or a list of jupes) to a server.
 * @param[in] sptr Client searching for jupes.
 * @param[in] server Name of jupe to search for (if NULL, list all).
 * @return Zero.
 */
int
jupe_list(struct Client *sptr, char *server)
{
  struct Jupe *jupe;
  struct Jupe *sjupe;

  if (server) {
    if (!(jupe = jupe_find(server))) /* no such jupe */
      return send_reply(sptr, ERR_NOSUCHJUPE, server);

    /* send jupe information along */
    send_reply(sptr, RPL_JUPELIST, jupe->ju_server, jupe->ju_expire + TSoffset,
	       JupeIsLocal(jupe) ? cli_name(&me) : "*",
	       JupeIsActive(jupe) ? '+' : '-', jupe->ju_reason);
  } else {
    for (jupe = GlobalJupeList; jupe; jupe = sjupe) { /* go through jupes */
      sjupe = jupe->ju_next;

      if (jupe->ju_expire <= CurrentTime) /* expire any that need expiring */
	jupe_free(jupe);
      else /* send jupe information along */
	send_reply(sptr, RPL_JUPELIST, jupe->ju_server,
		   jupe->ju_expire + TSoffset,
		   JupeIsLocal(jupe) ? cli_name(&me) : "*",
		   JupeIsActive(jupe) ? '+' : '-', jupe->ju_reason);
    }
  }

  /* end of jupe information */
  return send_reply(sptr, RPL_ENDOFJUPELIST);
}

/** Count jupes and memory used by them.
 * @param[out] ju_size Receives total number of bytes allocated for jupes.
 * @return Number of jupes currently allocated.
 */
int
jupe_memory_count(size_t *ju_size)
{
  struct Jupe *jupe;
  unsigned int ju = 0;

  for (jupe = GlobalJupeList; jupe; jupe = jupe->ju_next)
  {
    ju++;
    *ju_size += sizeof(struct Jupe);
    *ju_size += jupe->ju_server ? (strlen(jupe->ju_server) + 1) : 0;
    *ju_size += jupe->ju_reason ? (strlen(jupe->ju_reason) + 1) : 0;
  }
  return ju;
}
Commit	Line	Data
189935b1	1	/*
	2	* IRC - Internet Relay Chat, ircd/jupe.c
	3	* Copyright (C) 1990 Jarkko Oikarinen and
	4	* University of Oulu, Finland
	5	* Copyright (C) 2000 Kevin L. Mitchell <klmitch@mit.edu>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 1, or (at your option)
	10	* any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	20	*/
	21	/** @file
	22	* @brief Implementation of juped server handling functions.
	23	* @version $Id: jupe.c,v 1.20 2004/12/11 05:13:45 klmitch Exp $
	24	*/
	25	#include "config.h"
	26
	27	#include "jupe.h"
	28	#include "client.h"
	29	#include "hash.h"
	30	#include "ircd.h"
	31	#include "ircd_alloc.h"
	32	#include "ircd_features.h"
	33	#include "ircd_log.h"
	34	#include "ircd_reply.h"
	35	#include "ircd_string.h"
	36	#include "match.h"
	37	#include "msg.h"
	38	#include "numeric.h"
	39	#include "numnicks.h"
	40	#include "s_bsd.h"
	41	#include "s_misc.h"
	42	#include "send.h"
	43	#include "struct.h"
	44	#include "sys.h" /* FALSE bleah */
	45
	46	/* #include <assert.h> -- Now using assert in ircd_log.h */
	47	#include <string.h>
	48
	49	/** List of jupes. */
	50	static struct Jupe *GlobalJupeList = 0;
	51
	52	/** Allocate a new jupe with the given parameters.
	53	* @param[in] server Server name to jupe.
	54	* @param[in] reason Reason for jupe.
	55	* @param[in] expire Expiration time for jupe.
	56	* @param[in] lastmod Last modification time for jupe.
	57	* @param[in] flags Flags to set for the jupe.
	58	*/
	59	static struct Jupe *
	60	make_jupe(char server, char reason, time_t expire, time_t lastmod,
	61	unsigned int flags)
	62	{
	63	struct Jupe *ajupe;
	64
65	ajupe = (struct Jupe) MyMalloc(sizeof(struct Jupe)); / alloc memory */
66	assert(0 != ajupe);
67
68	DupString(ajupe->ju_server, server); /* copy vital information */
69	DupString(ajupe->ju_reason, reason);
70	ajupe->ju_expire = expire;
71	ajupe->ju_lastmod = lastmod;
72	ajupe->ju_flags = flags & JUPE_MASK; /* set jupe flags */
73
74	ajupe->ju_next = GlobalJupeList; /* link it into the list */
75	ajupe->ju_prev_p = &GlobalJupeList;
76	if (GlobalJupeList)
77	GlobalJupeList->ju_prev_p = &ajupe->ju_next;
78	GlobalJupeList = ajupe;
79
80	return ajupe;
81	}
82
83	/** Apply a jupe.
84	* @param[in] cptr Local client that sent us the jupe.
85	* @param[in] sptr Originator of the jupe.
86	* @param[in] jupe Jupe to check.
87	*/
88	static int
89	do_jupe(struct Client cptr, struct Client sptr, struct Jupe *jupe)
90	{
91	struct Client *acptr;
92
93	if (!JupeIsActive(jupe)) /* no action to be taken on inactive jupes */
94	return 0;
95
96	acptr = FindServer(jupe->ju_server);
97
98	/* server isn't online or isn't local or is me */
99	if (!acptr \|\| !MyConnect(acptr) \|\| IsMe(acptr))
100	return 0;
101
102	return exit_client_msg(cptr, acptr, &me, "Juped: %s", jupe->ju_reason);
103	}
104
105	/** Forward a jupe to another server.
106	* @param[in] cptr Local client that sent us the jupe.
107	* @param[in] sptr Originator of the jupe.
108	* @param[in] jupe Jupe to forward.
109	*/
110	static void
111	propagate_jupe(struct Client cptr, struct Client sptr, struct Jupe *jupe)
112	{
113	if (JupeIsLocal(jupe)) /* don't propagate local jupes */
114	return;
115
116	sendcmdto_serv_butone(sptr, CMD_JUPE, cptr, "* %c%s %Tu %Tu :%s",
117	JupeIsRemActive(jupe) ? '+' : '-', jupe->ju_server,
118	jupe->ju_expire - CurrentTime, jupe->ju_lastmod,
119	jupe->ju_reason);
120	}
121
122	/** Add a new server jupe.
123	* @param[in] cptr Local client that sent us the jupe.
124	* @param[in] sptr Originator of the jupe.
125	* @param[in] server Server name to jupe.
126	* @param[in] reason Reason for the jupe.
127	* @param[in] expire Jupe duration in seconds.
128	* @param[in] lastmod Last modification timestamp (or NULL).
129	* @param[in] flags Flags to set on jupe.
130	* @return Zero, unless the jupe causes \a cptr to be SQUIT, in which
131	* case CPTR_KILLED.
132	*/
133	int
134	jupe_add(struct Client cptr, struct Client sptr, char server, char reason,
135	time_t expire, time_t lastmod, unsigned int flags)
136	{
137	struct Jupe *ajupe;
138
139	assert(0 != server);
140	assert(0 != reason);
141
142	/*
143	* You cannot set a negative (or zero) expire time, nor can you set an
144	* expiration time for greater than JUPE_MAX_EXPIRE.
145	*/
146	if (expire <= 0 \|\| expire > JUPE_MAX_EXPIRE) {
147	if (!IsServer(cptr) && MyConnect(cptr))
148	send_reply(cptr, ERR_BADEXPIRE, expire);
149	return 0;
150	}
151
152	expire += CurrentTime; /* convert from lifetime to timestamp */
153
154	/* Inform ops and log it */
155	sendto_opmask_butone(0, SNO_NETWORK, "%s adding %sJUPE for %s, expiring at "
156	"%Tu: %s",
157	(feature_bool(FEAT_HIS_SNOTICES) \|\| IsServer(sptr)) ?
158	cli_name(sptr) :
159	cli_name((cli_user(sptr))->server),
160	flags & JUPE_LOCAL ? "local " : "", server,
161	expire + TSoffset, reason);
162
163	log_write(LS_JUPE, L_INFO, LOG_NOSNOTICE,
164	"%#C adding %sJUPE for %s, expiring at %Tu: %s", sptr,
165	flags & JUPE_LOCAL ? "local " : "", server, expire + TSoffset,
166	reason);
167
168	/* make the jupe */
169	ajupe = make_jupe(server, reason, expire, lastmod, flags);
170
171	propagate_jupe(cptr, sptr, ajupe);
172
173	return do_jupe(cptr, sptr, ajupe); /* remove server if necessary */
174	}
175
176	/** Activate a jupe, optionally changing its lastmod and flags.
177	* @param[in] cptr Local client that sent us the jupe.
178	* @param[in] sptr Originator of the jupe.
179	* @param[in] jupe Jupe to activate.
180	* @param[in] lastmod New timestamp for last modification of the jupe.
181	* @param[in] flags Flags to set on the jupe.
182	* @return Zero, unless the jupe causes \a cptr to be SQUIT, in which
183	* case CPTR_KILLED.
184	*/
185	int
186	jupe_activate(struct Client cptr, struct Client sptr, struct Jupe *jupe,
187	time_t lastmod, unsigned int flags)
188	{
189	unsigned int saveflags = 0;
190
191	assert(0 != jupe);
192
193	saveflags = jupe->ju_flags;
194
195	if (flags & JUPE_LOCAL)
196	jupe->ju_flags &= ~JUPE_LDEACT;
197	else {
198	jupe->ju_flags \|= JUPE_ACTIVE;
199
200	if (jupe->ju_lastmod >= lastmod) /* force lastmod to increase */
201	jupe->ju_lastmod++;
202	else
203	jupe->ju_lastmod = lastmod;
204	}
205
206	if ((saveflags & JUPE_ACTMASK) == JUPE_ACTIVE)
207	return 0; /* was active to begin with */
208
209	/* Inform ops and log it */
210	sendto_opmask_butone(0, SNO_NETWORK, "%s activating JUPE for %s, expiring "
211	"at %Tu: %s",
212	(feature_bool(FEAT_HIS_SNOTICES) \|\| IsServer(sptr)) ?
213	cli_name(sptr) :
214	cli_name((cli_user(sptr))->server),
215	jupe->ju_server, jupe->ju_expire + TSoffset,
216	jupe->ju_reason);
217
218	log_write(LS_JUPE, L_INFO, LOG_NOSNOTICE,
219	"%#C activating JUPE for %s, expiring at %Tu: %s",sptr,
220	jupe->ju_server, jupe->ju_expire + TSoffset, jupe->ju_reason);
221
222	if (!(flags & JUPE_LOCAL)) /* don't propagate local changes */
223	propagate_jupe(cptr, sptr, jupe);
224
225	return do_jupe(cptr, sptr, jupe);
226	}
227
228	/** Deactivate a jupe.
229	* @param[in] cptr Local client that sent us the jupe.
230	* @param[in] sptr Originator of the jupe.
231	* @param[in] jupe Jupe to deactivate.
232	* @param[in] lastmod New timestamp for last modification of the jupe.
233	* @param[in] flags Flags to set on the jupe.
234	* @return Zero.
235	*/
236	int
237	jupe_deactivate(struct Client cptr, struct Client sptr, struct Jupe *jupe,
238	time_t lastmod, unsigned int flags)
239	{
240	unsigned int saveflags = 0;
241
242	assert(0 != jupe);
243
244	saveflags = jupe->ju_flags;
245
246	if (!JupeIsLocal(jupe)) {
247	if (flags & JUPE_LOCAL)
248	jupe->ju_flags \|= JUPE_LDEACT;
249	else {
250	jupe->ju_flags &= ~JUPE_ACTIVE;
251
252	if (jupe->ju_lastmod >= lastmod) /* force lastmod to increase */
253	jupe->ju_lastmod++;
254	else
255	jupe->ju_lastmod = lastmod;
256	}
257
258	if ((saveflags & JUPE_ACTMASK) != JUPE_ACTIVE)
259	return 0; /* was inactive to begin with */
260	}
261
262	/* Inform ops and log it */
263	sendto_opmask_butone(0, SNO_NETWORK, "%s %s JUPE for %s, expiring at %Tu: "
264	"%s",
265	(feature_bool(FEAT_HIS_SNOTICES) \|\| IsServer(sptr)) ?
266	cli_name(sptr) :
267	cli_name((cli_user(sptr))->server),
268	JupeIsLocal(jupe) ? "removing local" : "deactivating",
269	jupe->ju_server, jupe->ju_expire + TSoffset,
270	jupe->ju_reason);
271
272	log_write(LS_JUPE, L_INFO, LOG_NOSNOTICE,
273	"%#C %s JUPE for %s, expiring at %Tu: %s", sptr,
274	JupeIsLocal(jupe) ? "removing local" : "deactivating",
275	jupe->ju_server, jupe->ju_expire + TSoffset, jupe->ju_reason);
276
277	if (JupeIsLocal(jupe))
278	jupe_free(jupe);
279	else if (!(flags & JUPE_LOCAL)) /* don't propagate local changes */
280	propagate_jupe(cptr, sptr, jupe);
281
282	return 0;
283	}
284
285	/** Find a jupe by name.
286	* @param[in] server %Jupe name to search for.
287	* @return Matching jupe (or NULL if none match).
288	*/
289	struct Jupe *
290	jupe_find(char *server)
291	{
292	struct Jupe* jupe;
293	struct Jupe* sjupe;
294
295	for (jupe = GlobalJupeList; jupe; jupe = sjupe) { /* go through jupes */
296	sjupe = jupe->ju_next;
297
298	if (jupe->ju_expire <= CurrentTime) /* expire any that need expiring */
299	jupe_free(jupe);
300	else if (0 == ircd_strcmp(server, jupe->ju_server)) /* found it yet? */
301	return jupe;
302	}
303
304	return 0;
305	}
306
307	/** Unlink and free an unused jupe.
308	* @param[in] jupe Server jupe to free.
309	*/
310	void
311	jupe_free(struct Jupe* jupe)
312	{
313	assert(0 != jupe);
314
315	jupe->ju_prev_p = jupe->ju_next; / squeeze this jupe out */
316	if (jupe->ju_next)
317	jupe->ju_next->ju_prev_p = jupe->ju_prev_p;
318
319	MyFree(jupe->ju_server); /* and free up the memory */
320	MyFree(jupe->ju_reason);
321	MyFree(jupe);
322	}
323
324	/** Send the full list of active global jupes to \a cptr.
325	* @param[in] cptr Local server to send jupes to.
326	*/
327	void
328	jupe_burst(struct Client *cptr)
329	{
330	struct Jupe *jupe;
331	struct Jupe *sjupe;
332
333	for (jupe = GlobalJupeList; jupe; jupe = sjupe) { /* go through jupes */
334	sjupe = jupe->ju_next;
335
336	if (jupe->ju_expire <= CurrentTime) /* expire any that need expiring */
337	jupe_free(jupe);
338	else if (!JupeIsLocal(jupe)) /* forward global jupes */
339	sendcmdto_one(&me, CMD_JUPE, cptr, "* %c%s %Tu %Tu :%s",
340	JupeIsRemActive(jupe) ? '+' : '-', jupe->ju_server,
341	jupe->ju_expire - CurrentTime, jupe->ju_lastmod,
342	jupe->ju_reason);
343	}
344	}
345
346	/** Forward a jupe to another server.
347	* @param[in] cptr %Server to send jupe to.
348	* @param[in] jupe Jupe to forward.
349	*/
350	int
351	jupe_resend(struct Client cptr, struct Jupe jupe)
352	{
353	if (JupeIsLocal(jupe)) /* don't propagate local jupes */
354	return 0;
355
356	sendcmdto_one(&me, CMD_JUPE, cptr, "* %c%s %Tu %Tu :%s",
357	JupeIsRemActive(jupe) ? '+' : '-', jupe->ju_server,
358	jupe->ju_expire - CurrentTime, jupe->ju_lastmod,
359	jupe->ju_reason);
360
361	return 0;
362	}
363
364	/** Send a jupe (or a list of jupes) to a server.
365	* @param[in] sptr Client searching for jupes.
366	* @param[in] server Name of jupe to search for (if NULL, list all).
367	* @return Zero.
368	*/
369	int
370	jupe_list(struct Client sptr, char server)
371	{
372	struct Jupe *jupe;
373	struct Jupe *sjupe;
374
375	if (server) {
376	if (!(jupe = jupe_find(server))) /* no such jupe */
377	return send_reply(sptr, ERR_NOSUCHJUPE, server);
378
379	/* send jupe information along */
380	send_reply(sptr, RPL_JUPELIST, jupe->ju_server, jupe->ju_expire + TSoffset,
381	JupeIsLocal(jupe) ? cli_name(&me) : "*",
382	JupeIsActive(jupe) ? '+' : '-', jupe->ju_reason);
383	} else {
384	for (jupe = GlobalJupeList; jupe; jupe = sjupe) { /* go through jupes */
385	sjupe = jupe->ju_next;
386
387	if (jupe->ju_expire <= CurrentTime) /* expire any that need expiring */
388	jupe_free(jupe);
389	else /* send jupe information along */
390	send_reply(sptr, RPL_JUPELIST, jupe->ju_server,
391	jupe->ju_expire + TSoffset,
392	JupeIsLocal(jupe) ? cli_name(&me) : "*",
393	JupeIsActive(jupe) ? '+' : '-', jupe->ju_reason);
394	}
395	}
396
397	/* end of jupe information */
398	return send_reply(sptr, RPL_ENDOFJUPELIST);
399	}
400
401	/** Count jupes and memory used by them.
402	* @param[out] ju_size Receives total number of bytes allocated for jupes.
403	* @return Number of jupes currently allocated.
404	*/
405	int
406	jupe_memory_count(size_t *ju_size)
407	{
408	struct Jupe *jupe;
409	unsigned int ju = 0;
410
411	for (jupe = GlobalJupeList; jupe; jupe = jupe->ju_next)
412	{
413	ju++;
414	*ju_size += sizeof(struct Jupe);
415	*ju_size += jupe->ju_server ? (strlen(jupe->ju_server) + 1) : 0;
416	*ju_size += jupe->ju_reason ? (strlen(jupe->ju_reason) + 1) : 0;
417	}
418	return ju;
419	}