trusts/events.c

   1 #include "../core/hooks.h"
   2 #include "trusts.h"
   3
   4 static void __counthandler(int hooknum, void *arg);
   5
   6 void trusts_newnick(nick *sender, int moving) {
   7   uint32_t host;
   8   trusthost *th;
   9   void *arg[2];
  10   struct irc_in_addr ipaddress;
  11
  12   ip_canonicalize_6to4(&ipaddress, &sender->p_ipaddr);
  13
  14   if (irc_in_addr_is_ipv4(&ipaddress)) {
  15     host = irc_in_addr_v4_to_int(&ipaddress);
  16     th = th_getbyhost(host);
  17   } else
  18     th = NULL;
  19
  20   settrusthost(sender, th);
  21   if(!th) {
  22     setnextbytrust(sender, NULL);
  23   } else {
  24     setnextbytrust(sender, th->users);
  25     th->users = sender;
  26   }
  27
  28   arg[0] = sender;
  29   arg[1] = (void *)(long)moving;
  30
  31   /* sucks we have to do this, at least until we get priority hooks */
  32   __counthandler(HOOK_TRUSTS_NEWNICK, arg);
  33
  34   triggerhook(HOOK_TRUSTS_NEWNICK, arg);
  35 }
  36
  37 static void __newnick(int hooknum, void *arg) {
  38   trusts_newnick(arg, 0);
  39 }
  40
  41 void trusts_lostnick(nick *sender, int moving) {
  42   nick *np, *lp;
  43   trusthost *th = gettrusthost(sender);
  44   void *arg[2];
  45
  46   arg[0] = sender;
  47   arg[1] = (void *)(long)moving;
  48
  49   __counthandler(HOOK_TRUSTS_LOSTNICK, arg);
  50   triggerhook(HOOK_TRUSTS_LOSTNICK, arg);
  51
  52   if(!th)
  53     return;
  54
  55   /*
  56    * we need to erase this nick from the trusthost list
  57    * stored in the ->nextbytrust (ext) pointers in each nick
  58    */
  59
  60   for(np=th->users,lp=NULL;np;lp=np,np=nextbytrust(np)) {
  61     if(np != sender)
  62       continue;
  63
  64     if(lp) {
  65       setnextbytrust(lp, nextbytrust(np));
  66     } else {
  67       th->users = nextbytrust(np);
  68     }
  69
  70     break;
  71   }
  72 }
  73
  74 static void __lostnick(int hooknum, void *arg) {
  75   trusts_lostnick(arg, 0);
  76 }
  77
  78 static void __counthandler(int hooknum, void *arg) {
  79   time_t t = time(NULL);
  80   void **args = arg;
  81   trusthost *th = gettrusthost((nick *)args[0]);
  82   trustgroup *tg;
  83
  84   if(!th)
  85     return;
  86
  87   tg = th->group;
  88   tg->lastseen = th->lastseen = t;
  89   if(hooknum == HOOK_TRUSTS_NEWNICK) {
  90     th->count++;
  91     if(th->count > th->maxusage)
  92       th->maxusage = th->count;
  93
  94     tg->count++;
  95     if(tg->count > tg->maxusage)
  96       tg->maxusage = tg->count;
  97   } else {
  98     th->count--;
  99     tg->count--;
 100   }
 101 }
 102
 103 static int hooksregistered;
 104
 105 static void __dbloaded(int hooknum, void *arg) {
 106   int i;
 107   nick *np;
 108
 109   if(hooksregistered)
 110     return;
 111   hooksregistered = 1;
 112
 113   registerhook(HOOK_NICK_NEWNICK, __newnick);
 114   registerhook(HOOK_NICK_LOSTNICK, __lostnick);
 115
 116 /*  registerhook(HOOK_TRUSTS_NEWNICK, __counthandler);
 117   registerhook(HOOK_TRUSTS_LOSTNICK, __counthandler);
 118 */
 119
 120   /* we could do it by host, but hosts and ips are not bijective :( */
 121   for(i=0;i<NICKHASHSIZE;i++)
 122     for(np=nicktable[i];np;np=np->next)
 123       __newnick(0, np);
 124 }
 125
 126 static void __dbclosed(int hooknum, void *arg) {
 127   if(!hooksregistered)
 128     return;
 129   hooksregistered = 0;
 130
 131   deregisterhook(HOOK_NICK_NEWNICK, __newnick);
 132   deregisterhook(HOOK_NICK_LOSTNICK, __lostnick);
 133
 134 /*
 135   deregisterhook(HOOK_TRUSTS_NEWNICK, __counthandler);
 136   deregisterhook(HOOK_TRUSTS_LOSTNICK, __counthandler);
 137 */
 138 }
 139
 140 void trusts_deregisterevents(void) {
 141   deregisterhook(HOOK_TRUSTS_DB_LOADED, __dbloaded);
 142   deregisterhook(HOOK_TRUSTS_DB_CLOSED, __dbclosed);
 143
 144   __dbclosed(0, NULL);
 145 }
 146
 147 void trusts_registerevents(void) {
 148   registerhook(HOOK_TRUSTS_DB_LOADED, __dbloaded);
 149   registerhook(HOOK_TRUSTS_DB_CLOSED, __dbclosed);
 150
 151   if(trustsdbloaded)
 152     __dbloaded(0, NULL);
 153 }