ircu2/ircd/motd.c

/*
 * IRC - Internet Relay Chat, ircd/motd.c
 * Copyright (C) 1990 Jarkko Oikarinen and
 *                    University of Oulu, Computing Center
 * Copyright (C) 2000 Kevin L. Mitchell <klmitch@mit.edu>
 *
 * See file AUTHORS in IRC package for additional names of
 * the programmers.
 *
 * 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 Message-of-the-day manipulation implementation.
 * @version $Id: motd.c 1402 2005-05-10 03:43:09Z entrope $
 */
#include "config.h"

#include "motd.h"
#include "class.h"
#include "client.h"
#include "fileio.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_conf.h"
#include "s_debug.h"
#include "s_user.h"
#include "s_stats.h"
#include "send.h"

/* #include <assert.h> -- Now using assert in ircd_log.h */
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

/** Global list of messages of the day. */
static struct {
  struct Motd*	    local;     /**< Local MOTD. */
  struct Motd*	    remote;    /**< Remote MOTD. */
  struct Motd*      oper;      /**< Oper MOTD. */
  struct Motd*      rules;     /**< RULES MOTD. */
  struct Motd*	    other;     /**< MOTDs specified in configuration file. */
  struct Motd*	    freelist;  /**< Currently unused Motd structs. */
  struct MotdCache* cachelist; /**< List of MotdCache entries. */
} MotdList = { 0, 0, 0, 0, 0, 0, 0 };

/** Create a struct Motd and initialize it.
 * @param[in] hostmask Hostmask (or connection class name) to filter on.
 * @param[in] path Path to MOTD file.
 * @param[in] maxcount Maximum number of lines permitted for MOTD.
 */
static struct Motd *
motd_create(const char *hostmask, const char *path, int maxcount, int type)
{
  struct Motd* tmp;

  assert(0 != path);

  /* allocate memory and initialize the structure */
  if (MotdList.freelist)
  {
    tmp = MotdList.freelist;
    MotdList.freelist = tmp->next;
  } else
    tmp = (struct Motd *)MyMalloc(sizeof(struct Motd));
  tmp->next = 0;

  if (hostmask == NULL)
    tmp->type = MOTD_UNIVERSAL;
  else if (type == MOTD_COUNTRY)
    tmp->type = MOTD_COUNTRY;
  else if (type == MOTD_CONTINENT)
    tmp->type = MOTD_CONTINENT;
  else if (find_class(hostmask))
    tmp->type = MOTD_CLASS;
  else if (ipmask_parse(hostmask, &tmp->address, &tmp->addrbits))
    tmp->type = MOTD_IPMASK;
  else
    tmp->type = MOTD_HOSTMASK;

  if (hostmask != NULL)
    DupString(tmp->hostmask, hostmask);
  else
    tmp->hostmask = NULL;

  DupString(tmp->path, path);
  tmp->maxcount = maxcount;
  tmp->cache = 0;

  return tmp;
}

/** This function reads a motd out of a file (if needed) and caches it.
 * If a matching cache entry already exists, reuse it.  Otherwise,
 * allocate and populate a new MotdCache for it.
 * @param[in] motd Specification for MOTD file.
 * @return Matching MotdCache entry.
 */
static struct MotdCache *
motd_cache(struct Motd *motd)
{
  FBFILE*		file;
  struct MotdCache*	cache;
  struct stat		sb;
  char			line[MOTD_LINESIZE + 2]; /* \r\n */
  char*			tmp;
  int			i;

  assert(0 != motd);
  assert(0 != motd->path);

  if (motd->cache)
    return motd->cache;

  /* try to find it in the list of cached files... */
  for (cache = MotdList.cachelist; cache; cache = cache->next) {
    if (!strcmp(cache->path, motd->path) &&
	cache->maxcount == motd->maxcount) { /* found one... */
      cache->ref++; /* increase reference count... */
      motd->cache = cache; /* remember cache... */
      return motd->cache; /* return it */
    }
  }

  /* gotta read in the file, now */
  if (!(file = fbopen(motd->path, "r"))) {
    Debug((DEBUG_ERROR, "Couldn't open \"%s\": %s", motd->path,
	   strerror(errno)));
    return 0;
  }

  /* need the file's modification time */
  if (-1 == fbstat(&sb, file)) {
    fbclose(file);
    return 0;
  }

  /* Ok, allocate a structure; we'll realloc later to trim memory */
  cache = (struct MotdCache *)MyMalloc(sizeof(struct MotdCache) +
				       (MOTD_LINESIZE * (MOTD_MAXLINES - 1)));

  cache->ref = 1;
  DupString(cache->path, motd->path);
  cache->maxcount = motd->maxcount;

  cache->modtime = *localtime((time_t *) &sb.st_mtime); /* store modtime */

  cache->count = 0;
  while (cache->count < cache->maxcount && fbgets(line, sizeof(line), file)) {
    /* copy over line, stopping when we overflow or hit line end */
    for (tmp = line, i = 0;
	 i < (MOTD_LINESIZE - 1) && *tmp && *tmp != '\r' && *tmp != '\n';
	 tmp++, i++)
      cache->motd[cache->count][i] = *tmp;
    cache->motd[cache->count][i] = '\0';

    cache->count++;
  }

  fbclose(file); /* close the file */

  /* trim memory usage a little */
  motd->cache = (struct MotdCache*)MyMalloc(sizeof(struct MotdCache) +
                                            (MOTD_LINESIZE * (cache->count - 1)));
  memcpy(motd->cache, cache, sizeof(struct MotdCache) +
         (MOTD_LINESIZE * (cache->count - 1)));
  MyFree(cache);

  /* now link it in... */
  motd->cache->next = MotdList.cachelist;
  motd->cache->prev_p = &MotdList.cachelist;
  if (MotdList.cachelist)
    MotdList.cachelist->prev_p = &motd->cache->next;
  MotdList.cachelist = motd->cache;

  return motd->cache;
}

/** Clear and dereference the Motd::cache element of \a motd.
 * If the MotdCache::ref count goes to zero, free it.
 * @param[in] motd MOTD to uncache.
 */
static void
motd_decache(struct Motd *motd)
{
  struct MotdCache* cache;

  assert(0 != motd);


  if (!(cache = motd->cache)) /* we can be called for records with no cache */
    return;

  motd->cache = 0; /* zero the cache */

  if (!--cache->ref) { /* reduce reference count... */
    if (cache->next) /* ref is 0, delink from list and free */
      cache->next->prev_p = cache->prev_p;
    *cache->prev_p = cache->next;

    MyFree(cache->path); /* free path info... */

    MyFree(cache); /* very simple for a reason... */
  }
}

/** Deallocate a MOTD structure.
 * If it has cached content, uncache it.
 * @param[in] motd MOTD to destroy.
 */
static void
motd_destroy(struct Motd *motd)
{
  assert(0 != motd);

  MyFree(motd->path); /* we always must have a path */
  MyFree(motd->hostmask);
  if (motd->cache) /* drop the cache */
    motd_decache(motd);

  motd->next = MotdList.freelist;
  MotdList.freelist = motd;
}

/** Find the first matching MOTD block for a user.
 * If the user is remote, always use remote MOTD.
 * Otherwise, if there is a hostmask- or class-based MOTD that matches
 * the user, use it.
 * Otherwise, use the local MOTD.
 * @param[in] cptr Client to find MOTD for.
 * @return Pointer to first matching MOTD for the client.
 */
static struct Motd *
motd_lookup(struct Client *cptr)
{
  struct Motd *ptr;
  char *c_class = NULL;

  assert(0 != cptr);

  if (!MyUser(cptr)) /* not my user, always return remote motd */
    return MotdList.remote;

  c_class = get_client_class(cptr);
  assert(c_class != NULL);

  /* check the motd blocks first */
  for (ptr = MotdList.other; ptr; ptr = ptr->next)
  {
    if (ptr->type == MOTD_CLASS
        && !match(ptr->hostmask, c_class))
      return ptr;
    else if (ptr->type == MOTD_HOSTMASK
             && !match(ptr->hostmask, cli_sockhost(cptr)))
      return ptr;
    else if (ptr->type == MOTD_IPMASK
             && ipmask_check(&cli_ip(cptr), &ptr->address, ptr->addrbits))
      return ptr;
    else if (ptr->type == MOTD_COUNTRY
             && !match(ptr->hostmask, cli_countrycode(cptr)))
      return ptr;
    else if (ptr->type == MOTD_CONTINENT
             && !match(ptr->hostmask, cli_continentcode(cptr)))
      return ptr;
  }

  return MotdList.local; /* Ok, return the default motd */
}

/** Send the content of a MotdCache to a user.
 * If \a cache is NULL, simply send ERR_NOMOTD to the client.
 * @param[in] cptr Client to send MOTD to.
 * @param[in] cache MOTD body to send to client.
 */
static int
motd_forward(struct Client *cptr, struct MotdCache *cache)
{
  int i;

  assert(0 != cptr);

  if (!cache) /* no motd to send */
    return send_reply(cptr, ERR_NOMOTD);

  /* send the motd */
  send_reply(cptr, RPL_MOTDSTART, cli_name(&me));
  send_reply(cptr, SND_EXPLICIT | RPL_MOTD, ":- %d-%d-%d %d:%02d",
	     cache->modtime.tm_year + 1900, cache->modtime.tm_mon + 1,
	     cache->modtime.tm_mday, cache->modtime.tm_hour,
	     cache->modtime.tm_min);

  for (i = 0; i < cache->count; i++)
    send_reply(cptr, RPL_MOTD, cache->motd[i]);

  return send_reply(cptr, RPL_ENDOFMOTD); /* end */
}

/** Send the content of a MotdCache to a user.
 * If \a cache is NULL, simply send ERR_NOOMOTD to the client.
 * @param[in] cptr Client to send MOTD to.
 * @param[in] cache MOTD body to send to client.
 */
static int
motd_forward_type(struct Client *cptr, int type)
{
  int i;
  struct MotdCache *cache = NULL;

  assert(0 != cptr);

  if (type == MOTD_OPER)
    cache = motd_cache(MotdList.oper);
  else if (type == MOTD_RULES)
    cache = motd_cache(MotdList.rules);

  if (!cache) {/* no motd to send */
    if (type == MOTD_OPER)
      return send_reply(cptr, ERR_NOOMOTD);
    else if (type == MOTD_RULES)
      return send_reply(cptr, ERR_NORULES);
    else
      return send_reply(cptr, ERR_NOMOTD);
  }

  if (type == MOTD_OPER) {
    /* send the motd */
    send_reply(cptr, RPL_OMOTDSTART, cli_name(&me));
    send_reply(cptr, SND_EXPLICIT | RPL_OMOTD, ":- %d-%d-%d %d:%02d",
               cache->modtime.tm_year + 1900, cache->modtime.tm_mon + 1,
               cache->modtime.tm_mday, cache->modtime.tm_hour,
               cache->modtime.tm_min);

    for (i = 0; i < cache->count; i++)
      send_reply(cptr, RPL_OMOTD, cache->motd[i]);

    return send_reply(cptr, RPL_ENDOFOMOTD); /* end */
  } else if (type == MOTD_RULES) {
    /* send the motd */
    send_reply(cptr, RPL_RULESSTART, cli_name(&me));
    send_reply(cptr, SND_EXPLICIT | RPL_RULES, ":- %d-%d-%d %d:%02d",
               cache->modtime.tm_year + 1900, cache->modtime.tm_mon + 1,
               cache->modtime.tm_mday, cache->modtime.tm_hour,
               cache->modtime.tm_min);

    for (i = 0; i < cache->count; i++)
      send_reply(cptr, RPL_RULES, cache->motd[i]);

    return send_reply(cptr, RPL_ENDOFRULES); /* end */
  }else {
    return send_reply(cptr, ERR_NOMOTD);
  }
}


/** Find the MOTD for a client and send it.
 * @param[in] cptr Client being greeted.
 */
int
motd_send(struct Client* cptr)
{
  assert(0 != cptr);

  return motd_forward(cptr, motd_cache(motd_lookup(cptr)));
}

/** Find the MOTD for a client and send it.
 * @param[in] cptr Client being greeted.
 */
int
motd_send_type(struct Client* cptr, int type)
{
  assert(0 != cptr);

  return motd_forward_type(cptr, type);
}

/** Send the signon MOTD to a user.
 * If FEAT_NODEFAULTMOTD is true and a matching MOTD exists for the
 * user, direct the client to type /MOTD to read it.  Otherwise, call
 * motd_forward() for the user.
 * @param[in] cptr Client that has just connected.
 */
void
motd_signon(struct Client* cptr)
{
  struct MotdCache *cache;
  const char *banner = NULL;

  cache = motd_cache(motd_lookup(cptr));

  if (!feature_bool(FEAT_NODEFAULTMOTD) || !cache)
    motd_forward(cptr, cache);
  else {
    send_reply(cptr, RPL_MOTDSTART, cli_name(&me));
    if ((banner = feature_str(FEAT_MOTD_BANNER)))
      send_reply(cptr, SND_EXPLICIT | RPL_MOTD, ":%s", banner);
    send_reply(cptr, SND_EXPLICIT | RPL_MOTD, ":\002Type /MOTD to read the "
	       "AUP before continuing using this service.\002");
    send_reply(cptr, SND_EXPLICIT | RPL_MOTD, ":The message of the day was "
	       "last changed: %d-%d-%d %d:%d", cache->modtime.tm_year + 1900,
	       cache->modtime.tm_mon + 1, cache->modtime.tm_mday,
	       cache->modtime.tm_hour, cache->modtime.tm_min);
    send_reply(cptr, RPL_ENDOFMOTD);
  }
}

/** Clear all cached MOTD bodies.
 * The local and remote MOTDs are re-cached immediately.
 */
void
motd_recache(void)
{
  struct Motd* tmp;

  motd_decache(MotdList.local); /* decache local and remote MOTDs */
  motd_decache(MotdList.remote);
  motd_decache(MotdList.oper);
  motd_decache(MotdList.rules);

  for (tmp = MotdList.other; tmp; tmp = tmp->next) /* now all the others */
    motd_decache(tmp);

  /* now recache local and remote MOTDs */
  motd_cache(MotdList.local);
  motd_cache(MotdList.remote);
  motd_cache(MotdList.oper);
  motd_cache(MotdList.rules);
}

/** Re-cache the local and remote MOTDs.
 * If they already exist, they are deallocated first.
 */
void
motd_init(void)
{
  if (MotdList.local) /* destroy old local... */
    motd_destroy(MotdList.local);

  MotdList.local = motd_create(0, feature_str(FEAT_MPATH), MOTD_MAXLINES, 0);
  motd_cache(MotdList.local); /* init local and cache it */

  if (MotdList.remote) /* destroy old remote... */
    motd_destroy(MotdList.remote);

  MotdList.remote = motd_create(0, feature_str(FEAT_RPATH), MOTD_MAXREMOTE, 0);
  motd_cache(MotdList.remote); /* init remote and cache it */

  if (MotdList.oper) /* destroy old oper... */
    motd_destroy(MotdList.oper);

  MotdList.oper = motd_create(0, feature_str(FEAT_OMPATH), MOTD_MAXLINES, 0);
  motd_cache(MotdList.oper); /* init remote and cache it */

  if (MotdList.rules) /* destroy old rules... */
    motd_destroy(MotdList.rules);

  MotdList.rules = motd_create(0, feature_str(FEAT_EPATH), MOTD_MAXLINES, 0);
  motd_cache(MotdList.rules); /* init remote and cache it */
}

/** Add a new MOTD.
 * @param[in] hostmask Hostmask (or connection class name) to send this to.
 * @param[in] path Pathname of file to send.
 */
void
motd_add(const char *hostmask, const char *path, int type)
{
  struct Motd *tmp;

  tmp = motd_create(hostmask, path, MOTD_MAXLINES, type); /* create the motd */

  tmp->next = MotdList.other; /* link it into the list */
  MotdList.other = tmp;
}

/** Clear out all MOTDs.
 * Compared to motd_recache(), this destroys all hostmask- or
 * class-based MOTDs rather than simply uncaching them.
 * Re-cache the local and remote MOTDs.
 */
void
motd_clear(void)
{
  struct Motd *ptr, *next;

  motd_decache(MotdList.local); /* decache local and remote MOTDs */
  motd_decache(MotdList.remote);
  motd_decache(MotdList.oper);
  motd_decache(MotdList.rules);

  if (MotdList.other) /* destroy other MOTDs */
    for (ptr = MotdList.other; ptr; ptr = next)
    {
      next = ptr->next;
      motd_destroy(ptr);
    }

  MotdList.other = 0;

  /* now recache local and remote MOTDs */
  motd_cache(MotdList.local);
  motd_cache(MotdList.remote);
  motd_cache(MotdList.oper);
  motd_cache(MotdList.rules);
}

/** Report list of non-default MOTDs.
 * @param[in] to Client requesting statistics.
 * @param[in] sd Stats descriptor for request (ignored).
 * @param[in] param Extra parameter from user (ignored).
 */
void
motd_report(struct Client *to, const struct StatDesc *sd, char *param)
{
  struct Motd *ptr;

  for (ptr = MotdList.other; ptr; ptr = ptr->next)
    send_reply(to, SND_EXPLICIT | RPL_STATSTLINE, "T %s %s",
               ptr->hostmask, ptr->path);
}

/** Report MOTD memory usage to a client.
 * @param[in] cptr Client requesting memory usage.
 */
void
motd_memory_count(struct Client *cptr)
{
  struct Motd *ptr;
  struct MotdCache *cache;
  unsigned int mt = 0,   /* motd count */
               mtc = 0,  /* motd cache count */
               mtf = 0;  /* motd free list count */
  size_t mtm = 0,  /* memory consumed by motd */
         mtcm = 0; /* memory consumed by motd cache */
  if (MotdList.local)
  {
    mt++;
    mtm += sizeof(struct Motd);
    mtm += MotdList.local->path ? (strlen(MotdList.local->path) + 1) : 0;
  }

  if (MotdList.remote)
  {
    mt++;
    mtm += sizeof(struct Motd);
    mtm += MotdList.remote->path ? (strlen(MotdList.remote->path) + 1) : 0;
  }

  if (MotdList.oper)
  {
    mt++;
    mtm += sizeof(struct Motd);
    mtm += MotdList.oper->path ? (strlen(MotdList.oper->path) + 1) : 0;
  }

  if (MotdList.rules)
  {
    mt++;
    mtm += sizeof(struct Motd);
    mtm += MotdList.rules->path ? (strlen(MotdList.rules->path) + 1) : 0;
  }

  for (ptr = MotdList.other; ptr; ptr = ptr->next)
  {
    mt++;
    mtm += sizeof(struct Motd);
    mtm += ptr->path ? (strlen(ptr->path) + 1) : 0;
  }

  for (cache = MotdList.cachelist; cache; cache = cache->next)
  {
    mtc++;
    mtcm += sizeof(struct MotdCache) + (MOTD_LINESIZE * (cache->count - 1));
  }

  if (MotdList.freelist)
    for (ptr = MotdList.freelist; ptr; ptr = ptr->next)
      mtf++;

  send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
             ":Motds %d(%zu) Cache %d(%zu) Free %d(%zu)",
             mt, mtm, mtc, mtcm, mtf, (mtf * sizeof(struct Motd)));
}