-#include "trusts.h"
-#include "../core/hooks.h"
#include <stdio.h>
-#include <time.h>
+#include <string.h>
+#include "../lib/version.h"
+#include "../core/hooks.h"
+#include "../core/error.h"
+#include "../core/nsmalloc.h"
+#include "../server/server.h"
+#include "trusts.h"
+
+MODULE_VERSION("");
+
+void trusts_registerevents(void);
+void trusts_deregisterevents(void);
-int trusts_loaddb(void);
-void trusts_closedb(void);
static void statusfn(int, void *);
+static void whoisfn(int, void *);
+
+static sstring *tgextnames[MAXTGEXTS];
+
+int trusts_thext, trusts_nextuserext;
+int trustsdbloaded;
void _init(void) {
- if(!trusts_loaddb())
+ trusts_thext = registernickext("trustth");
+ if(trusts_thext == -1) {
+ Error("trusts", ERR_ERROR, "Unable to register first nick extension.");
return;
+ }
+
+ trusts_nextuserext = registernickext("trustnext");
+ if(trusts_thext == -1) {
+ releasenickext(trusts_thext);
+ Error("trusts", ERR_ERROR, "Unable to register second nick extension.");
+ return;
+ }
registerhook(HOOK_CORE_STATSREQUEST, statusfn);
+ registerhook(HOOK_CONTROL_WHOISREQUEST, &whoisfn);
+ trusts_registerevents();
}
void _fini(void) {
- trusts_closedb();
+ if(trusts_thext != -1) {
+ releasenickext(trusts_thext);
+ releasenickext(trusts_nextuserext);
+ }
deregisterhook(HOOK_CORE_STATSREQUEST, statusfn);
+ deregisterhook(HOOK_CONTROL_WHOISREQUEST, &whoisfn);
+ trusts_deregisterevents();
+
+ nscheckfreeall(POOL_TRUSTS);
}
-char *trusts_timetostr(time_t t) {
- static char buf[100];
+static void whoisfn(int hooknum, void *arg) {
+ trusthost *th;
+ char message[512];
+ nick *np = (nick *)arg;
+
+ if(!np)
+ return;
+
+ th = gettrusthost(np);
+
+ if(!th)
+ return;
+
+ snprintf(message, sizeof(message), "Trustgroup: %s (#%d)", th->group->name->content, th->group->id);
+ triggerhook(HOOK_CONTROL_WHOISREPLY, message);
+
+ if (th->maxpernode > 0) {
+ snprintf(message, sizeof(message), "Node : %s", CIDRtostr(np->p_ipaddr, th->nodebits));
+ triggerhook(HOOK_CONTROL_WHOISREPLY, message);
+
+ patricia_node_t *node;
+ int usercount = 0;
+
+ node = refnode(iptree, &(np->p_ipaddr), th->nodebits);
+ usercount = node->usercount;
+ derefnode(iptree, node);
+
+ snprintf(message, sizeof(message), "Node : Usage: %d/%d", usercount, th->maxpernode);
+ triggerhook(HOOK_CONTROL_WHOISREPLY, message);
+ }
- strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", localtime(&t));
+ if (th->group->trustedfor > 0) {
+ snprintf(message, sizeof(message), "Trusthost : %s", CIDRtostr(th->ip, th->bits));
+ triggerhook(HOOK_CONTROL_WHOISREPLY, message);
- return buf;
+ snprintf(message, sizeof(message), "Trustgroup : Usage: %d/%d", th->group->count, th->group->trustedfor);
+ triggerhook(HOOK_CONTROL_WHOISREPLY, message);
+ }
}
static void statusfn(int hooknum, void *arg) {
if((long)arg > 10) {
char message[100];
- int groupcount = 0, hostcount = 0;
+ int groupcount = 0, hostcount = 0, usercount = 0;
trustgroup *tg;
trusthost *th;
for(tg=tglist;tg;tg=tg->next) {
+ usercount+=tg->count;
groupcount++;
for(th=tg->hosts;th;th=th->next)
hostcount++;
}
- snprintf(message, sizeof(message), "Trusts : %d trust groups, %d hosts", groupcount, hostcount);
+ snprintf(message, sizeof(message), "Trusts :%7d groups, %7d hosts, %7d users", groupcount, hostcount, usercount);
triggerhook(HOOK_CORE_STATSREPLY, message);
}
}
-int trusts_parsecidr(const char *host, uint32_t *ip, short *mask) {
- unsigned int octet1 = 0, octet2 = 0, octet3 = 0, octet4 = 0, umask = 32;
-
- if(sscanf(host, "%u.%u.%u.%u/%u", &octet1, &octet2, &octet3, &octet4, &umask) != 5)
- if(sscanf(host, "%u.%u.%u/%u", &octet1, &octet2, &octet3, &umask) != 4)
- if(sscanf(host, "%u.%u/%u", &octet1, &octet2, &umask) != 3)
- if(sscanf(host, "%u/%u", &octet1, &umask) != 2)
- if(sscanf(host, "%u.%u.%u.%u", &octet1, &octet2, &octet3, &octet4) != 4)
- return 0;
-
- if(octet1 > 255 || octet2 > 255 || octet3 > 255 || octet4 > 255 || umask > 32)
- return 0;
+int findtgext(const char *name) {
+ int i;
- *ip = (octet1 << 24) | (octet2 << 16) | (octet3 << 8) | octet4;
- *mask = umask;
+ for(i=0;i<MAXTGEXTS;i++)
+ if(tgextnames[i] && !strcmp(name, tgextnames[i]->content))
+ return i;
- return 1;
+ return -1;
}
-/* returns mask pre-anded */
-int trusts_str2cidr(const char *host, uint32_t *ip, uint32_t *mask) {
- uint32_t result;
- short smask;
+int registertgext(const char *name) {
+ int i;
- if(!trusts_parsecidr(host, &result, &smask))
- return 0;
+ if(findtgext(name) != -1) {
+ Error("trusts", ERR_WARNING, "Tried to register duplicate trust group extension: %s.", name);
+ return -1;
+ }
- if(smask == 0) {
- *mask = 0;
- } else {
- *mask = 0xffffffff << (32 - smask);
+ for(i=0;i<MAXNICKEXTS;i++) {
+ if(!tgextnames[i]) {
+ tgextnames[i] = getsstring(name, 100);
+ return i;
+ }
}
- *ip = result & *mask;
- return 1;
+ Error("trusts", ERR_WARNING, "Tried to register too many trust group extensions: %s.", name);
+ return -1;
}
-char *trusts_cidr2str(uint32_t ip, uint32_t mask) {
- static char buf[100];
- char maskbuf[10];
+void releasetgext(int index) {
+ trustgroup *tg;
- if(mask != 0) {
- /* count number of trailing zeros */
- float f = (float)(mask & -mask);
-
- mask = 32 - ((*(unsigned int *)&f >> 23) - 0x7f);
- }
+ freesstring(tgextnames[index]);
+ tgextnames[index] = NULL;
- if(mask < 32) {
- snprintf(maskbuf, sizeof(maskbuf), "/%u", mask);
- } else {
- maskbuf[0] = '\0';
- }
+ for(tg=tglist;tg;tg=tg->next)
+ tg->exts[index] = NULL;
+}
- snprintf(buf, sizeof(buf), "%u.%u.%u.%u%s", (ip >> 24) & 0xff, (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff, maskbuf);
+int trusts_fullyonline(void) {
+ if(myhub == -1)
+ return 0;
- return buf;
+ return serverlist[myhub].linkstate == LS_LINKED;
}
+
projects / irc / quakenet / newserv.git / blobdiff