src/dns.c

   1 /**
   2  * collectd - src/dns.c
   3  * Copyright (C) 2006-2011  Florian octo Forster
   4  * Copyright (C) 2009       Mirko Buffoni
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; only version 2 of the License is applicable.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  *
  19  * Authors:
  20  *   Florian octo Forster <octo at collectd.org>
  21  *   Mirko Buffoni <briareos at eswat.org>
  22  **/
  23
  24 #define _BSD_SOURCE
  25
  26 #include "collectd.h"
  27 #include "common.h"
  28 #include "plugin.h"
  29 #include "configfile.h"
  30
  31 #include "utils_dns.h"
  32 #include <pthread.h>
  33 #include <poll.h>
  34
  35 #include <pcap.h>
  36 #include <pcap-bpf.h>
  37
  38 /*
  39  * Private data types
  40  */
  41 struct counter_list_s
  42 {
  43         unsigned int key;
  44         unsigned int value;
  45         struct counter_list_s *next;
  46 };
  47 typedef struct counter_list_s counter_list_t;
  48
  49 /*
  50  * Private variables
  51  */
  52 static const char *config_keys[] =
  53 {
  54         "Interface",
  55         "IgnoreSource",
  56         "SelectNumericQueryTypes"
  57 };
  58 static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
  59 static int select_numeric_qtype = 1;
  60
  61 #define PCAP_SNAPLEN 1460
  62 static char   *pcap_device = NULL;
  63
  64 static derive_t       tr_queries;
  65 static derive_t       tr_responses;
  66 static counter_list_t *qtype_list;
  67 static counter_list_t *opcode_list;
  68 static counter_list_t *rcode_list;
  69
  70 static pthread_t       listen_thread;
  71 static int             listen_thread_init = 0;
  72 /* The `traffic' mutex if for `tr_queries' and `tr_responses' */
  73 static pthread_mutex_t traffic_mutex = PTHREAD_MUTEX_INITIALIZER;
  74 static pthread_mutex_t qtype_mutex   = PTHREAD_MUTEX_INITIALIZER;
  75 static pthread_mutex_t opcode_mutex  = PTHREAD_MUTEX_INITIALIZER;
  76 static pthread_mutex_t rcode_mutex   = PTHREAD_MUTEX_INITIALIZER;
  77
  78 /*
  79  * Private functions
  80  */
  81 static counter_list_t *counter_list_search (counter_list_t **list, unsigned int key)
  82 {
  83         counter_list_t *entry;
  84
  85         for (entry = *list; entry != NULL; entry = entry->next)
  86                 if (entry->key == key)
  87                         break;
  88
  89         return (entry);
  90 }
  91
  92 static counter_list_t *counter_list_create (counter_list_t **list,
  93                 unsigned int key, unsigned int value)
  94 {
  95         counter_list_t *entry;
  96
  97         entry = (counter_list_t *) malloc (sizeof (counter_list_t));
  98         if (entry == NULL)
  99                 return (NULL);
 100
 101         memset (entry, 0, sizeof (counter_list_t));
 102         entry->key = key;
 103         entry->value = value;
 104
 105         if (*list == NULL)
 106         {
 107                 *list = entry;
 108         }
 109         else
 110         {
 111                 counter_list_t *last;
 112
 113                 last = *list;
 114                 while (last->next != NULL)
 115                         last = last->next;
 116
 117                 last->next = entry;
 118         }
 119
 120         return (entry);
 121 }
 122
 123 static void counter_list_add (counter_list_t **list,
 124                 unsigned int key, unsigned int increment)
 125 {
 126         counter_list_t *entry;
 127
 128         entry = counter_list_search (list, key);
 129
 130         if (entry != NULL)
 131         {
 132                 entry->value += increment;
 133         }
 134         else
 135         {
 136                 counter_list_create (list, key, increment);
 137         }
 138 }
 139
 140 static int dns_config (const char *key, const char *value)
 141 {
 142         if (strcasecmp (key, "Interface") == 0)
 143         {
 144                 if (pcap_device != NULL)
 145                         free (pcap_device);
 146                 if ((pcap_device = strdup (value)) == NULL)
 147                         return (1);
 148         }
 149         else if (strcasecmp (key, "IgnoreSource") == 0)
 150         {
 151                 if (value != NULL)
 152                         ignore_list_add_name (value);
 153         }
 154         else if (strcasecmp (key, "SelectNumericQueryTypes") == 0)
 155         {
 156                 if ((value != NULL) && IS_FALSE (value))
 157                         select_numeric_qtype = 0;
 158                 else
 159                         select_numeric_qtype = 1;
 160         }
 161         else
 162         {
 163                 return (-1);
 164         }
 165
 166         return (0);
 167 }
 168
 169 static void dns_child_callback (const rfc1035_header_t *dns)
 170 {
 171         if (dns->qr == 0)
 172         {
 173                 /* This is a query */
 174                 int skip = 0;
 175                 if (!select_numeric_qtype)
 176                 {
 177                         const char *str = qtype_str(dns->qtype);
 178                         if ((str == NULL) || (str[0] == '#'))
 179                                 skip = 1;
 180                 }
 181
 182                 pthread_mutex_lock (&traffic_mutex);
 183                 tr_queries += dns->length;
 184                 pthread_mutex_unlock (&traffic_mutex);
 185
 186                 if (skip == 0)
 187                 {
 188                         pthread_mutex_lock (&qtype_mutex);
 189                         counter_list_add (&qtype_list, dns->qtype,  1);
 190                         pthread_mutex_unlock (&qtype_mutex);
 191                 }
 192         }
 193         else
 194         {
 195                 /* This is a reply */
 196                 pthread_mutex_lock (&traffic_mutex);
 197                 tr_responses += dns->length;
 198                 pthread_mutex_unlock (&traffic_mutex);
 199
 200                 pthread_mutex_lock (&rcode_mutex);
 201                 counter_list_add (&rcode_list,  dns->rcode,  1);
 202                 pthread_mutex_unlock (&rcode_mutex);
 203         }
 204
 205         /* FIXME: Are queries, replies or both interesting? */
 206         pthread_mutex_lock (&opcode_mutex);
 207         counter_list_add (&opcode_list, dns->opcode, 1);
 208         pthread_mutex_unlock (&opcode_mutex);
 209 }
 210
 211 static void *dns_child_loop (__attribute__((unused)) void *dummy)
 212 {
 213         pcap_t *pcap_obj;
 214         char    pcap_error[PCAP_ERRBUF_SIZE];
 215         struct  bpf_program fp;
 216
 217         int status;
 218
 219         /* Don't block any signals */
 220         {
 221                 sigset_t sigmask;
 222                 sigemptyset (&sigmask);
 223                 pthread_sigmask (SIG_SETMASK, &sigmask, NULL);
 224         }
 225
 226         /* Passing `pcap_device == NULL' is okay and the same as passign "any" */
 227         DEBUG ("dns plugin: Creating PCAP object..");
 228         pcap_obj = pcap_open_live ((pcap_device != NULL) ? pcap_device : "any",
 229                         PCAP_SNAPLEN,
 230                         0 /* Not promiscuous */,
 231                         (int) CDTIME_T_TO_MS (plugin_get_interval () / 2),
 232                         pcap_error);
 233         if (pcap_obj == NULL)
 234         {
 235                 ERROR ("dns plugin: Opening interface `%s' "
 236                                 "failed: %s",
 237                                 (pcap_device != NULL) ? pcap_device : "any",
 238                                 pcap_error);
 239                 return (NULL);
 240         }
 241
 242         memset (&fp, 0, sizeof (fp));
 243         if (pcap_compile (pcap_obj, &fp, "udp port 53", 1, 0) < 0)
 244         {
 245                 ERROR ("dns plugin: pcap_compile failed");
 246                 return (NULL);
 247         }
 248         if (pcap_setfilter (pcap_obj, &fp) < 0)
 249         {
 250                 ERROR ("dns plugin: pcap_setfilter failed");
 251                 return (NULL);
 252         }
 253
 254         DEBUG ("dns plugin: PCAP object created.");
 255
 256         dnstop_set_pcap_obj (pcap_obj);
 257         dnstop_set_callback (dns_child_callback);
 258
 259         status = pcap_loop (pcap_obj,
 260                         -1 /* loop forever */,
 261                         handle_pcap /* callback */,
 262                         NULL /* Whatever this means.. */);
 263         if (status < 0)
 264                 ERROR ("dns plugin: Listener thread is exiting "
 265                                 "abnormally: %s", pcap_geterr (pcap_obj));
 266
 267         DEBUG ("dns plugin: Child is exiting.");
 268
 269         pcap_close (pcap_obj);
 270         listen_thread_init = 0;
 271         pthread_exit (NULL);
 272
 273         return (NULL);
 274 } /* static void dns_child_loop (void) */
 275
 276 static int dns_init (void)
 277 {
 278         /* clean up an old thread */
 279         int status;
 280
 281         pthread_mutex_lock (&traffic_mutex);
 282         tr_queries   = 0;
 283         tr_responses = 0;
 284         pthread_mutex_unlock (&traffic_mutex);
 285
 286         if (listen_thread_init != 0)
 287                 return (-1);
 288
 289         status = plugin_thread_create (&listen_thread, NULL, dns_child_loop,
 290                         (void *) 0);
 291         if (status != 0)
 292         {
 293                 char errbuf[1024];
 294                 ERROR ("dns plugin: pthread_create failed: %s",
 295                                 sstrerror (errno, errbuf, sizeof (errbuf)));
 296                 return (-1);
 297         }
 298
 299         listen_thread_init = 1;
 300
 301         return (0);
 302 } /* int dns_init */
 303
 304 static void submit_derive (const char *type, const char *type_instance,
 305                 derive_t value)
 306 {
 307         value_t values[1];
 308         value_list_t vl = VALUE_LIST_INIT;
 309
 310         values[0].derive = value;
 311
 312         vl.values = values;
 313         vl.values_len = 1;
 314         sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 315         sstrncpy (vl.plugin, "dns", sizeof (vl.plugin));
 316         sstrncpy (vl.type, type, sizeof (vl.type));
 317         sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
 318
 319         plugin_dispatch_values (&vl);
 320 } /* void submit_derive */
 321
 322 static void submit_octets (derive_t queries, derive_t responses)
 323 {
 324         value_t values[2];
 325         value_list_t vl = VALUE_LIST_INIT;
 326
 327         values[0].derive = queries;
 328         values[1].derive = responses;
 329
 330         vl.values = values;
 331         vl.values_len = 2;
 332         sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 333         sstrncpy (vl.plugin, "dns", sizeof (vl.plugin));
 334         sstrncpy (vl.type, "dns_octets", sizeof (vl.type));
 335
 336         plugin_dispatch_values (&vl);
 337 } /* void submit_octets */
 338
 339 static int dns_read (void)
 340 {
 341         unsigned int keys[T_MAX];
 342         unsigned int values[T_MAX];
 343         int len;
 344         int i;
 345
 346         counter_list_t *ptr;
 347
 348         pthread_mutex_lock (&traffic_mutex);
 349         values[0] = tr_queries;
 350         values[1] = tr_responses;
 351         pthread_mutex_unlock (&traffic_mutex);
 352
 353         if ((values[0] != 0) || (values[1] != 0))
 354                 submit_octets (values[0], values[1]);
 355
 356         pthread_mutex_lock (&qtype_mutex);
 357         for (ptr = qtype_list, len = 0;
 358                         (ptr != NULL) && (len < T_MAX);
 359                         ptr = ptr->next, len++)
 360         {
 361                 keys[len]   = ptr->key;
 362                 values[len] = ptr->value;
 363         }
 364         pthread_mutex_unlock (&qtype_mutex);
 365
 366         for (i = 0; i < len; i++)
 367         {
 368                 DEBUG ("dns plugin: qtype = %u; counter = %u;", keys[i], values[i]);
 369                 submit_derive ("dns_qtype", qtype_str (keys[i]), values[i]);
 370         }
 371
 372         pthread_mutex_lock (&opcode_mutex);
 373         for (ptr = opcode_list, len = 0;
 374                         (ptr != NULL) && (len < T_MAX);
 375                         ptr = ptr->next, len++)
 376         {
 377                 keys[len]   = ptr->key;
 378                 values[len] = ptr->value;
 379         }
 380         pthread_mutex_unlock (&opcode_mutex);
 381
 382         for (i = 0; i < len; i++)
 383         {
 384                 DEBUG ("dns plugin: opcode = %u; counter = %u;", keys[i], values[i]);
 385                 submit_derive ("dns_opcode", opcode_str (keys[i]), values[i]);
 386         }
 387
 388         pthread_mutex_lock (&rcode_mutex);
 389         for (ptr = rcode_list, len = 0;
 390                         (ptr != NULL) && (len < T_MAX);
 391                         ptr = ptr->next, len++)
 392         {
 393                 keys[len]   = ptr->key;
 394                 values[len] = ptr->value;
 395         }
 396         pthread_mutex_unlock (&rcode_mutex);
 397
 398         for (i = 0; i < len; i++)
 399         {
 400                 DEBUG ("dns plugin: rcode = %u; counter = %u;", keys[i], values[i]);
 401                 submit_derive ("dns_rcode", rcode_str (keys[i]), values[i]);
 402         }
 403
 404         return (0);
 405 } /* int dns_read */
 406
 407 void module_register (void)
 408 {
 409         plugin_register_config ("dns", dns_config, config_keys, config_keys_num);
 410         plugin_register_init ("dns", dns_init);
 411         plugin_register_read ("dns", dns_read);
 412 } /* void module_register */