src/os_xml/os_xml_variables.c

   1 /*   $OSSEC, os_xml_node_variables.c, v0.3, 2005/04/12, Daniel B. Cid$   */
   2
   3 /* Copyright (C) 2009 Trend Micro Inc.
   4  * All rights reserved.
   5  *
   6  * This program is a free software; you can redistribute it
   7  * and/or modify it under the terms of the GNU General Public
   8  * License (version 2) as published by the FSF - Free Software
   9  * Foundation
  10  */
  11
  12 /* os_xml C Library.
  13  * Available at http://www.ossec.net/
  14  */
  15
  16
  17 #include <stdio.h>
  18 #include <string.h>
  19 #include <stdlib.h>
  20
  21 #include "os_xml.h"
  22
  23 int OS_ApplyVariables(OS_XML *_lxml)
  24 {
  25     int i = 0,j = 0,s = 0;
  26     char **var = NULL;
  27     char **value = NULL;
  28
  29
  30     /* No variables. */
  31     if(!_lxml->cur)
  32         return(0);
  33
  34
  35     /* Getting all variables */
  36     for(;i<_lxml->cur;i++)
  37     {
  38         if(_lxml->tp[i] == XML_VARIABLE_BEGIN)
  39         {
  40             int _found_var = 0;
  41
  42             j = i+1;
  43             for(;j<_lxml->cur;j++)
  44             {
  45                 if(_lxml->rl[j] < _lxml->rl[i])
  46                     break;
  47
  48                 else if(_lxml->tp[j] == XML_ATTR)
  49                 {
  50                     if((_lxml->el[j])&&(strcasecmp(_lxml->el[j],"name") == 0))
  51                     {
  52                         if(!_lxml->ct[j])
  53                             break;
  54
  55                         /* If not used, it will be cleaned latter */
  56                         snprintf(_lxml->err, 128, "XML_ERR: Memory error");
  57
  58                         var = (char**)realloc(var,(s+1)*sizeof(char *));
  59                         if(var == NULL)
  60                             return (-1);
  61
  62                         var[s] = strdup(_lxml->ct[j]);
  63                         if(var[s] == NULL)
  64                             return(-1);
  65
  66                         /* Cleaning the lxml->err */
  67                         strncpy(_lxml->err," ", 3);
  68
  69                         _found_var = 1;
  70                         break;
  71                     }
  72                     else
  73                     {
  74                         snprintf(_lxml->err, 128,
  75                                  "XML_ERR: Only \"name\" is allowed"
  76                                  " as an attribute for a variable");
  77                         return(-1);
  78                     }
  79                 }
  80             } /* Attribute FOR */
  81
  82
  83             if((_found_var == 0)||(!_lxml->ct[i]))
  84             {
  85                 snprintf(_lxml->err,128,
  86                          "XML_ERR: Bad formed variable. No value set");
  87                 return(-1);
  88             }
  89
  90
  91             snprintf(_lxml->err,128, "XML_ERR: Memory error");
  92
  93             value = (char**)realloc(value,(s+1)*sizeof(char *));
  94             if (value == NULL)
  95                 return(-1);
  96
  97             value[s] = strdup(_lxml->ct[i]);
  98             if(value[s] == NULL)
  99                 return(-1);
 100
 101             strncpy(_lxml->err," ", 3);
 102             s++;
 103         }
 104     } /* initial FOR to get the variables  */
 105
 106
 107     /* No variable */
 108     if(s == 0)
 109         return(0);
 110
 111
 112     /* Looping again and modifying where found the variables */
 113     i = 0;
 114     for(;i<_lxml->cur;i++)
 115     {
 116         if(((_lxml->tp[i] == XML_ELEM) || (_lxml->tp[i] == XML_ATTR))&&
 117             (_lxml->ct[i]))
 118         {
 119             int tp = 0,init = 0,final = 0;
 120             char *p = NULL;
 121             char *p2= NULL;
 122             char lvar[256]; /* MAX Var size */
 123
 124
 125             if(strlen(_lxml->ct[i]) <= 2)
 126                 continue;
 127
 128
 129             /* Duplicating string */
 130             p = strdup(_lxml->ct[i]);
 131             p2= p;
 132
 133             if(p == NULL)
 134             {
 135                 snprintf(_lxml->err, 128, "XML_ERR: Memory error");
 136                 return(-1);
 137             }
 138
 139
 140             /* Reading the whole string */
 141             while(*p != '\0')
 142             {
 143                 if(*p == XML_VARIABLE_BEGIN)
 144                 {
 145                     tp = 0;
 146                     p++;
 147                     memset(lvar, '\0', 256);
 148
 149                     while(1)
 150                     {
 151                         if((*p == XML_VARIABLE_BEGIN)
 152                             ||(*p == '\0')
 153                             ||(*p == '.')
 154                             ||(*p == '|')
 155                             ||(*p == ',')
 156                             ||(*p == ' '))
 157                         {
 158                             lvar[tp]='\0';
 159
 160                             final = init+tp;
 161
 162                             /* Looking for var */
 163                             for(j=0; j<s; j++)
 164                             {
 165                                 int tsize = 0;
 166
 167                                 /* Store everything up the variable name */
 168                                 char *var_placeh;
 169
 170
 171                                 if(var[j] == NULL)
 172                                     break;
 173
 174                                 if(strcasecmp(var[j], lvar) != 0)
 175                                 {
 176                                     continue;
 177                                 }
 178
 179
 180                                 tsize = strlen(_lxml->ct[i]) +
 181                                         strlen(value[j]) - tp + 1;
 182
 183                                 var_placeh = strdup(_lxml->ct[i]);
 184
 185                                 free(_lxml->ct[i]);
 186
 187                                 _lxml->ct[i] = (char*)calloc(tsize +2,
 188                                                              sizeof(char));
 189
 190                                 if(_lxml->ct[i] == NULL || var_placeh == NULL)
 191                                 {
 192                                     snprintf(_lxml->err,128, "XML_ERR: Memory "
 193                                                              "error");
 194                                     return(-1);
 195                                 }
 196
 197
 198                                 strncpy(_lxml->ct[i], var_placeh, tsize);
 199
 200
 201                                 _lxml->ct[i][init] = '\0';
 202                                 strncat(_lxml->ct[i], value[j],tsize - init);
 203
 204
 205                                 init = strlen(_lxml->ct[i]);
 206                                 strncat(_lxml->ct[i], p,
 207                                          tsize - strlen(_lxml->ct[i]));
 208
 209
 210                                 free(var_placeh);
 211
 212                                 break;
 213                             }
 214
 215                             /* Variale not found */
 216                             if((j == s) && (strlen(lvar) >= 1))
 217                             {
 218                                 snprintf(_lxml->err,128,
 219                                                 "XML_ERR: Unknown variable"
 220                                                 ": %s", lvar);
 221                                 return(-1);
 222                             }
 223                             else if(j == s)
 224                             {
 225                                 init++;
 226                             }
 227
 228                             goto go_next;
 229                         }
 230
 231                         /* Maximum size for a variable */
 232                         if(tp >= 255)
 233                         {
 234                             snprintf(_lxml->err,128, "XML_ERR: Invalid "
 235                                                      "variable size.");
 236                             return(-1);
 237
 238                         }
 239
 240                         lvar[tp] = *p;
 241                         tp++;
 242                         p++;
 243                     }
 244                 } /* IF XML_VAR_BEGIN */
 245
 246                 p++;
 247                 init++;
 248
 249                 go_next:
 250                 continue;
 251
 252             } /* WHILE END */
 253
 254             if(p2 != NULL)
 255             {
 256                 free(p2);
 257                 p2 = NULL;
 258                 p = NULL;
 259             }
 260         }
 261     }
 262
 263
 264     /* Cleaning the variables */
 265     for(i=0;i<s;i++)
 266     {
 267         if((var)&&(var[i]))
 268         {
 269             free(var[i]);
 270             var[i] = NULL;
 271         }
 272         if((value)&&(value[i]))
 273         {
 274             free(value[i]);
 275             value[i] = NULL;
 276         }
 277     }
 278
 279     if(var != NULL)
 280     {
 281         free(var);
 282         var = NULL;
 283     }
 284     if(value != NULL)
 285     {
 286         free(value);
 287         value = NULL;
 288     }
 289
 290     return(0);
 291 }
 292
 293 /* UFA :) or EOF */