src/utils_search.c

   1 /**
   2  * collection4 - utils_search.c
   3  * Copyright (C) 2010  Florian octo Forster
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA  02110-1301  USA
  19  *
  20  * Authors:
  21  *   Florian octo Forster <ff at octo.it>
  22  **/
  23
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <ctype.h>
  28 #include <errno.h>
  29
  30 #include "utils_search.h"
  31 #include "graph_ident.h"
  32 #include "graph_instance.h"
  33 #include "utils_array.h"
  34
  35 #include <fcgiapp.h>
  36 #include <fcgi_stdio.h>
  37
  38 struct search_info_s
  39 {
  40   char *host;
  41   char *plugin;
  42   char *plugin_instance;
  43   char *type;
  44   char *type_instance;
  45
  46   str_array_t *terms;
  47 };
  48
  49 /*
  50  * Private functions
  51  */
  52 static char *read_quoted_string (const char **buffer) /* {{{ */
  53 {
  54   const char *ptr = *buffer;
  55   char *ret;
  56   size_t ret_len;
  57
  58   if (ptr[0] != '"')
  59     return (NULL);
  60   ptr++;
  61
  62   ret_len = 0;
  63   while ((*ptr != '"') && (*ptr != 0))
  64   {
  65     ret_len++;
  66
  67     if (*ptr == '\\')
  68       ptr += 2;
  69     else
  70       ptr++;
  71   }
  72
  73   if ((ret_len < 1) || (*ptr != '"'))
  74     return (NULL);
  75
  76   ret = malloc (ret_len + 1);
  77   if (ret == NULL)
  78     return (NULL);
  79
  80   ptr = *buffer + 1;
  81   ret_len = 0;
  82   while ((*ptr != '"') && (*ptr != 0))
  83   {
  84     if (*ptr == '"')
  85       break;
  86
  87     if (*ptr == '\\')
  88       ptr++;
  89
  90     ret[ret_len] = *ptr;
  91
  92     ptr++;
  93     ret_len++;
  94   }
  95
  96   /* terminate string */
  97   ret[ret_len] = 0;
  98
  99   /* "ptr" points to the '"' sign, so advance one more */
 100   ptr++;
 101   *buffer = ptr;
 102
 103   return (ret);
 104 } /* }}} char *read_quoted_string */
 105
 106 static char *read_unquoted_word (const char **buffer) /* {{{ */
 107 {
 108   const char *ptr = *buffer;
 109   char *ret;
 110   size_t ret_len;
 111
 112   ret_len = 0;
 113   while (!isspace ((int) ptr[ret_len]) && (ptr[ret_len] != 0))
 114     ret_len++;
 115
 116   if (ret_len < 1)
 117     return (NULL);
 118
 119   ret = malloc (ret_len + 1);
 120   if (ret == NULL)
 121     return (NULL);
 122
 123   memcpy (ret, ptr, ret_len);
 124   ret[ret_len] = 0;
 125
 126   ptr += ret_len;
 127   *buffer = ptr;
 128
 129   return (ret);
 130 } /* }}} char *read_unquoted_word */
 131
 132 static char *next_token (const char **buffer) /* {{{ */
 133 {
 134   const char *ptr = *buffer;
 135   char *ret;
 136
 137   while (isspace ((int) (*ptr)))
 138     ptr++;
 139
 140   if (ptr[0] == 0)
 141     return (NULL);
 142   else if (ptr[0] == '"')
 143   {
 144     ret = read_quoted_string (&ptr);
 145     if (ret != NULL)
 146     {
 147       *buffer = ptr;
 148       return (ret);
 149     }
 150   }
 151
 152   ret = read_unquoted_word (&ptr);
 153   if (ret != NULL)
 154     *buffer = ptr;
 155
 156   return (ret);
 157 } /* }}} char *next_token */
 158
 159 static int store_token_field (char **field, const char *token) /* {{{ */
 160 {
 161   char *copy;
 162
 163   if ((field == NULL) || (token == NULL))
 164     return (EINVAL);
 165
 166   copy = strdup (token);
 167   if (copy == NULL)
 168     return (ENOMEM);
 169
 170   free (*field);
 171   *field = copy;
 172
 173   return (0);
 174 } /* }}} int store_token_field */
 175
 176 static int store_token (search_info_t *si, const char *token) /* {{{ */
 177 {
 178   if (strncmp ("host:", token, strlen ("host:")) == 0)
 179     return (store_token_field (&si->host, token + strlen ("host:")));
 180   else if (strncmp ("plugin:", token, strlen ("plugin:")) == 0)
 181     return (store_token_field (&si->plugin, token + strlen ("plugin:")));
 182   else if (strncmp ("plugin_instance:", token, strlen ("plugin_instance:")) == 0)
 183     return (store_token_field (&si->plugin_instance, token + strlen ("plugin_instance:")));
 184   else if (strncmp ("type:", token, strlen ("type:")) == 0)
 185     return (store_token_field (&si->type, token + strlen ("type:")));
 186   else if (strncmp ("type_instance:", token, strlen ("type_instance:")) == 0)
 187     return (store_token_field (&si->type_instance, token + strlen ("type_instance:")));
 188
 189   return (array_append (si->terms, token));
 190 } /* }}} int store_token */
 191
 192 /*
 193  * Public functions
 194  */
 195 search_info_t *search_parse (const char *search) /* {{{ */
 196 {
 197   const char *ptr;
 198   char *token;
 199   search_info_t *si;
 200
 201   if (search == NULL)
 202     return (NULL);
 203
 204   si = malloc (sizeof (*si));
 205   if (si == NULL)
 206     return (NULL);
 207   memset (si, 0, sizeof (*si));
 208
 209   si->terms = array_create ();
 210   if (si->terms == NULL)
 211   {
 212     free (si);
 213     return (NULL);
 214   }
 215
 216   ptr = search;
 217
 218   while ((token = next_token (&ptr)) != NULL)
 219   {
 220     store_token (si, token);
 221     free (token);
 222   }
 223
 224   return (si);
 225 } /* }}} search_info_t *search_parse */
 226
 227 void search_destroy (search_info_t *si) /* {{{ */
 228 {
 229   if (si == NULL)
 230     return;
 231
 232   free (si->host);
 233   free (si->plugin);
 234   free (si->plugin_instance);
 235   free (si->type);
 236   free (si->type_instance);
 237
 238   array_destroy (si->terms);
 239 } /* }}} void search_destroy */
 240
 241 _Bool search_has_selector (search_info_t *si) /* {{{ */
 242 {
 243   if (si == NULL)
 244     return (0);
 245
 246   if ((si->host != NULL)
 247       || (si->plugin != NULL) || (si->plugin_instance != NULL)
 248       || (si->type != NULL) || (si->type_instance != NULL))
 249     return (1);
 250
 251   return (0);
 252 } /* }}} _Bool search_has_selector */
 253
 254 graph_ident_t *search_to_ident (search_info_t *si) /* {{{ */
 255 {
 256   if (si == NULL)
 257     return (NULL);
 258
 259   return (ident_create ((si->host == NULL) ? ANY_TOKEN : si->host,
 260         (si->plugin == NULL) ? ANY_TOKEN : si->plugin,
 261         (si->plugin_instance == NULL) ? ANY_TOKEN : si->plugin_instance,
 262         (si->type == NULL) ? ANY_TOKEN : si->type,
 263         (si->type_instance == NULL) ? ANY_TOKEN : si->type_instance));
 264 } /* }}} graph_ident_t *search_to_ident */
 265
 266 search_info_t *search_from_ident (const graph_ident_t *ident) /* {{{ */
 267 {
 268   search_info_t *si;
 269
 270   if (ident == NULL)
 271     return (NULL);
 272
 273   si = malloc (sizeof (*si));
 274   if (si == NULL)
 275     return (NULL);
 276   memset (si, 0, sizeof (*si));
 277   si->terms = NULL;
 278
 279 #define COPY_FIELD(f) do {                                                   \
 280   const char *tmp = ident_get_##f (ident);                                   \
 281   if (tmp == NULL)                                                           \
 282     si->f = NULL;                                                            \
 283   else                                                                       \
 284     si->f = strdup (tmp);                                                    \
 285 } while (0)
 286
 287   COPY_FIELD(host);
 288   COPY_FIELD(plugin);
 289   COPY_FIELD(plugin_instance);
 290   COPY_FIELD(type);
 291   COPY_FIELD(type_instance);
 292
 293 #undef COPY_FIELD
 294
 295   return (si);
 296 } /* }}} search_info_t *search_from_ident */
 297
 298 _Bool search_graph_title_matches (search_info_t *si, /* {{{ */
 299     const char *title)
 300 {
 301   char **argv;
 302   int argc;
 303   int i;
 304
 305   if ((si == NULL) || (title == NULL))
 306     return (0);
 307
 308   if (si->terms == NULL)
 309     return (1);
 310
 311   argc = array_argc (si->terms);
 312   argv = array_argv (si->terms);
 313   for (i = 0; i < argc; i++)
 314     if (strstr (title, argv[i]) == NULL)
 315       return (0);
 316
 317   return (1);
 318 } /* }}} _Bool search_graph_title_matches */
 319
 320 _Bool search_graph_inst_matches (search_info_t *si, /* {{{ */
 321     graph_config_t *cfg, graph_instance_t *inst,
 322     const char *title)
 323 {
 324   char **argv;
 325   int argc;
 326   int i;
 327
 328   if ((si == NULL) || (cfg == NULL) || (inst == NULL))
 329     return (0);
 330
 331   if ((si->host != NULL)
 332       && !inst_matches_field (inst, GIF_HOST, si->host))
 333     return (0);
 334   else if ((si->plugin != NULL)
 335       && !inst_matches_field (inst, GIF_PLUGIN, si->plugin))
 336     return (0);
 337   else if ((si->plugin_instance != NULL)
 338       && !inst_matches_field (inst, GIF_PLUGIN_INSTANCE, si->plugin_instance))
 339     return (0);
 340   else if ((si->type != NULL)
 341       && !inst_matches_field (inst, GIF_TYPE, si->type))
 342     return (0);
 343   else if ((si->type_instance != NULL)
 344       && !inst_matches_field (inst, GIF_TYPE_INSTANCE, si->type_instance))
 345     return (0);
 346
 347   if (si->terms == NULL)
 348     return (1);
 349
 350   argc = array_argc (si->terms);
 351   argv = array_argv (si->terms);
 352   for (i = 0; i < argc; i++)
 353   {
 354     if (inst_matches_string (cfg, inst, argv[i]))
 355       continue;
 356
 357     if ((title != NULL) && (strstr (title, argv[i]) != NULL))
 358       continue;
 359
 360     return (0);
 361   }
 362
 363   return (1);
 364 } /* }}} _Bool search_graph_inst_matches */
 365
 366 /* vim: set sw=2 sts=2 et fdm=marker : */