*
* $Id$
*/
+#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_reply.h"
#include "ircd_string.h"
#include "match.h"
#include "s_conf.h"
#include "s_debug.h"
#include "s_user.h"
+#include "s_stats.h"
#include "send.h"
#include <assert.h>
#include <sys/stat.h>
static struct {
- struct Motd* local;
- struct Motd* remote;
- struct Motd* other;
-} MotdList;
+ struct Motd* local;
+ struct Motd* remote;
+ struct Motd* other;
+ struct Motd* freelist;
+ struct MotdCache* cachelist;
+} MotdList = { 0, 0, 0, 0, 0 };
/* Create a struct Motd and initialize it */
static struct Motd *
motd_create(const char *hostmask, const char *path, int maxcount)
{
struct Motd* tmp;
- int class = -1;
int type = MOTD_UNIVERSAL;
- const char* s;
-
+ const char *s;
+
assert(0 != path);
-
- if (hostmask) { /* figure out if it's a class or hostmask */
- for (s = hostmask; *s; s++)
- if (!IsDigit(*s)) { /* not a digit, not a class... */
- type = MOTD_HOSTMASK;
- break;
- }
-
- type = MOTD_CLASS; /* all digits, convert to class */
- class = atoi(hostmask);
- }
-
+
+ if (hostmask != NULL && find_class(hostmask))
+ type = MOTD_CLASS;
+ else
+ type = MOTD_HOSTMASK;
/* allocate memory and initialize the structure */
- tmp = (struct Motd *)MyMalloc(sizeof(struct Motd));
-
+ if (MotdList.freelist)
+ {
+ tmp = MotdList.freelist;
+ MotdList.freelist = tmp->next;
+ } else
+ tmp = (struct Motd *)MyMalloc(sizeof(struct Motd));
+
tmp->next = 0;
tmp->type = type;
- if (type == MOTD_HOSTMASK)
- DupString(tmp->id.hostmask, hostmask);
- else if (type == MOTD_CLASS)
- tmp->id.class = class;
+
+ if (hostmask != NULL)
+ DupString(tmp->hostmask, hostmask);
+
DupString(tmp->path, path);
tmp->maxcount = maxcount;
tmp->cache = 0;
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,
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 < motd->maxcount && fbgets(line, sizeof(line), file)) {
+ 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';
fbclose(file); /* close the file */
/* trim memory usage a little */
- motd->cache = (struct MotdCache *)MyRealloc(cache, sizeof(struct MotdCache) +
- (MOTD_LINESIZE *
- (cache->count - 1)));
+ 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;
}
motd->cache = 0; /* zero the cache */
- MyFree(cache); /* very simple for a reason... */
+ 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... */
+ }
}
/* This function destroys a struct Motd, destroying the cache if needed */
assert(0 != motd);
MyFree(motd->path); /* we always must have a path */
- if (motd->type == MOTD_HOSTMASK) /* free a host mask if any */
- MyFree(motd->id.hostmask);
+ MyFree(motd->hostmask);
if (motd->cache) /* drop the cache */
motd_decache(motd);
- MyFree(motd); /* free the structure */
+ motd->next = MotdList.freelist;
+ MotdList.freelist = motd;
}
/* We use this routine to look up the struct Motd to send to any given
motd_lookup(struct Client *cptr)
{
struct Motd *ptr;
- int class = -1;
+ char *c_class = NULL;
assert(0 != cptr);
if (!MyUser(cptr)) /* not my user, always return remote motd */
return MotdList.remote;
- class = get_client_class(cptr);
+ c_class = get_client_class(cptr);
- /* check the T-lines first */
- for (ptr = MotdList.other; ptr; ptr = ptr->next) {
- if (ptr->type == MOTD_CLASS && ptr->id.class == class)
+ /* 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->id.hostmask, cptr->sockhost))
+ else if (ptr->type == MOTD_HOSTMASK && c_class != NULL &&
+ !match(ptr->hostmask, cli_sockhost(cptr)))
return ptr;
}
return send_reply(cptr, ERR_NOMOTD);
/* send the motd */
- send_reply(cptr, RPL_MOTDSTART, me.name);
+ 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,
motd_signon(struct Client* cptr)
{
struct MotdCache *cache;
+ const char *banner = NULL;
cache = motd_cache(motd_lookup(cptr));
-#ifdef NODEFAULTMOTD
- send_reply(cptr, RPL_MOTDSTART, me.name);
- 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);
-#else
- motd_forward(cptr, cache);
-#endif
+ 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);
+ }
}
/* motd_recache causes all the MOTD caches to be cleared */
void
motd_init(void)
{
- MotdList.local = motd_create(0, MPATH, MOTD_MAXLINES); /* init local */
- motd_cache(MotdList.local); /* and cache it */
+ if (MotdList.local) /* destroy old local... */
+ motd_destroy(MotdList.local);
+
+ MotdList.local = motd_create(0, feature_str(FEAT_MPATH), MOTD_MAXLINES);
+ motd_cache(MotdList.local); /* init local and cache it */
- MotdList.remote = motd_create(0, RPATH, MOTD_MAXREMOTE); /* init remote */
- motd_cache(MotdList.remote); /* and cache it */
+ if (MotdList.remote) /* destroy old remote... */
+ motd_destroy(MotdList.remote);
- MotdList.other = 0; /* no T-lines processed yet */
+ MotdList.remote = motd_create(0, feature_str(FEAT_RPATH), MOTD_MAXREMOTE);
+ motd_cache(MotdList.remote); /* init remote and cache it */
}
/* This routine adds a MOTD */
motd_decache(MotdList.remote);
if (MotdList.other) /* destroy other MOTDs */
- for (ptr = MotdList.other; ptr; ptr = next) {
+ 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);
/* This is called to report T-lines */
void
-motd_report(struct Client *to)
+motd_report(struct Client *to, struct StatDesc *sd, int stat, char *param)
{
struct Motd *ptr;
- for (ptr = MotdList.other; ptr; ptr = ptr->next) {
- if (ptr->type == MOTD_CLASS) /* class requires special handling */
- send_reply(to, SND_EXPLICIT | RPL_STATSTLINE, "T %d %s", ptr->id.class,
- ptr->path);
- else if (ptr->type == MOTD_HOSTMASK)
- send_reply(to, RPL_STATSTLINE, 'T', ptr->id.hostmask, ptr->path);
+ for (ptr = MotdList.other; ptr; ptr = ptr->next)
+ send_reply(to, SND_EXPLICIT | RPL_STATSTLINE, "T %s %s",
+ ptr->hostmask, ptr->path);
+}
+
+void
+motd_memory_count(struct Client *cptr)
+{
+ struct Motd *ptr;
+ struct MotdCache *cache;
+ unsigned int mt = 0, /* motd count */
+ mtm = 0, /* memory consumed by motd */
+ mtc = 0, /* motd cache count */
+ mtcm = 0, /* memory consumed by motd cache */
+ mtf = 0; /* motd free list count */
+ 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;
+ }
+
+ 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)));
}
projects / ircu2.10.12-pk.git / blobdiff