dnxStats.c

Go to the documentation of this file.

/*--------------------------------------------------------------------------

   Copyright (c) 2006-2010, Intellectual Reserve, Inc. All rights reserved.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation.

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  --------------------------------------------------------------------------*/

#include "dnxStats.h"
#include "dnxDebug.h"
#include "dnxError.h"

#include <pthread.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>

#define elemcount(x) (sizeof(x)/sizeof(*(x)))

typedef struct DnxNode
{
   struct DnxNode * next;     
   struct sockaddr * saddr;   
   DnxNodeData data;          
} DnxNode;

/* Global (static) variables managed by this module. */
static DnxNode * s_nodeHashTable[256];       
static unsigned s_serverStats[STATS_COUNT];  

/*--------------------------------------------------------------------------
                              IMPLEMENTATION
  --------------------------------------------------------------------------*/

static unsigned hashFunction(struct sockaddr * addr)
{
   unsigned hash = 0;
   switch (addr->sa_family)
   {
      case AF_INET:
         hash = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
         break;

      case AF_INET6:
      {
         int i;
         for (i = 0; i < 4; i++)
            hash += *((unsigned *)(((struct sockaddr_in6 *)addr)
                  ->sin6_addr.s6_addr + i * 4)) & 0xFFFFFFFF;
      }

      default:
         hash = addr->sa_data[2];   // try to skip the port
         break;
   }
   return hash & 0xFF;
}

//----------------------------------------------------------------------------

static int dnxAddrCompare(struct sockaddr * addr_a, struct sockaddr * addr_b)
{
   if (addr_a->sa_family != addr_b->sa_family)
      return addr_a->sa_family - addr_b->sa_family;

   switch(addr_a->sa_family)
   {
      case AF_INET:
         return (int)(((struct sockaddr_in *)addr_a)->sin_addr.s_addr 
               - ((struct sockaddr_in *)addr_b)->sin_addr.s_addr);

      case AF_INET6:
         return memcmp(((struct sockaddr_in6 *)addr_a)->sin6_addr.s6_addr,
               ((struct sockaddr_in6 *)addr_b)->sin6_addr.s6_addr, 16);
   }

   return memcmp(addr_a->sa_data + 2, addr_b->sa_data + 2, 
         sizeof(addr_a->sa_data) - 2);
}

//----------------------------------------------------------------------------

static DnxNode * dnxCreateNodeAt(DnxNode ** npp, struct sockaddr * saddr, 
      unsigned hashCode)
{
   DnxNode * np;

   // allocate and populate a new node
   if ((np = (DnxNode *)xmalloc(sizeof *np)) == 0)
      return 0;

   memset(np, 0, sizeof *np);
   memcpy(np->data.address, saddr, sizeof np->data.address);
   np->saddr = (struct sockaddr *)np->data.address;
   dnxNtop(saddr, np->data.addrstr, sizeof np->data.addrstr);

   return *npp = np;
}

//----------------------------------------------------------------------------

static DnxNode * dnxGetNode(struct sockaddr * saddr)
{
   DnxNode ** npp, * np;
   unsigned hashCode = hashFunction(saddr);

   for (npp = &s_nodeHashTable[hashCode]; 
         (np = *npp) && dnxAddrCompare(np->saddr, saddr); npp = &np->next)
      ;

   return np? np: dnxCreateNodeAt(npp, saddr, hashCode);
}

/*--------------------------------------------------------------------------
                                 INTERFACE
  --------------------------------------------------------------------------*/

void dnxStatsGetServerStats(unsigned * statsbuf)
{
   memcpy(statsbuf, s_serverStats, sizeof s_serverStats);
}

//----------------------------------------------------------------------------

void dnxStatsResetServerStats(void)
{
   memset(s_serverStats, 0, sizeof s_serverStats);
}

//----------------------------------------------------------------------------

void dnxStatsInc(char * addr, DnxStatsIndex member)
{
   if (addr)
   {
      DnxNode * np = dnxGetNode((struct sockaddr *)addr);
      assert(member >= 0 && member < STATS_COUNT);
      if (np) np->data.stats[member]++;
   }
   s_serverStats[member]++;
}

//----------------------------------------------------------------------------

int dnxStatsForEachNode(DnxStatsNodeCB * cb, void * data)
{
   int i, ret = 0;
   for (i = 0; i < elemcount(s_nodeHashTable); i++)
   {
      DnxNode * np;
      for (np = s_nodeHashTable[i]; np; np = np->next)
         if ((ret = cb(&np->data, data)) != 0)
            break;
   }
   return ret == DNX_CBCANCEL? 0: ret;
}

//----------------------------------------------------------------------------

int dnxStatsForNodeByAddrStr(char * addrstr, DnxStatsNodeCB * cb, void * data)
{
   struct addrinfo * aip, * curaip;
   DnxNode * np = 0;
   int ret;

   // convert addrstr to a sockaddr
   if ((ret = getaddrinfo(addrstr, 0, 0, &aip)) != 0)
      return ret;

   // search for the first node that matches one of the addresses found
   for (curaip = aip; !np && curaip; curaip = curaip->ai_next)
      if ((np = dnxGetNode(curaip->ai_addr)) != 0)
         ret = cb(&np->data, data);

   freeaddrinfo(aip);

   return ret;
}

//----------------------------------------------------------------------------

void dnxStatsCleanup()
{
   int i;
   for (i = 0; i < elemcount(s_nodeHashTable); i++)
   {
      DnxNode * np = s_nodeHashTable[i];

      while (np)
      {
         DnxNode * tmp = np->next;
         free(np);
         np = tmp;
      }
      s_nodeHashTable[i] = 0;
   }
}

//============================================================================