epan/ftypes/ftype-tvbuff.c

   1 /*
   2  * $Id$
   3  *
   4  * Wireshark - Network traffic analyzer
   5  * By Gerald Combs <gerald@wireshark.org>
   6  * Copyright 2001 Gerald Combs
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdio.h>
  26 #include <ftypes-int.h>
  27 #include <string.h>
  28
  29 #include <epan/exceptions.h>
  30
  31 #define CMP_MATCHES cmp_matches
  32
  33 #define tvb_is_private  fvalue_gboolean1
  34
  35 static void
  36 value_new(fvalue_t *fv)
  37 {
  38         fv->value.tvb = NULL;
  39         fv->tvb_is_private = FALSE;
  40 }
  41
  42 static void
  43 value_free(fvalue_t *fv)
  44 {
  45         if (fv->value.tvb && fv->tvb_is_private) {
  46                 tvb_free_chain(fv->value.tvb);
  47         }
  48 }
  49
  50 static void
  51 value_set(fvalue_t *fv, gpointer value, gboolean already_copied)
  52 {
  53         g_assert(already_copied);
  54
  55         /* Free up the old value, if we have one */
  56         value_free(fv);
  57
  58         fv->value.tvb = (tvbuff_t *)value;
  59 }
  60
  61 static void
  62 free_tvb_data(void *data)
  63 {
  64         g_free(data);
  65 }
  66
  67 static gboolean
  68 val_from_string(fvalue_t *fv, char *s, LogFunc logfunc _U_)
  69 {
  70         tvbuff_t *new_tvb;
  71         guint8 *private_data;
  72
  73         /* Free up the old value, if we have one */
  74         value_free(fv);
  75
  76         /* Make a tvbuff from the string. We can drop the
  77          * terminating NUL. */
  78         private_data = (guint8 *)g_memdup(s, (guint)strlen(s));
  79         new_tvb = tvb_new_real_data(private_data,
  80                         (guint)strlen(s), (gint)strlen(s));
  81
  82         /* Let the tvbuff know how to delete the data. */
  83         tvb_set_free_cb(new_tvb, free_tvb_data);
  84
  85         /* And let us know that we need to free the tvbuff */
  86         fv->tvb_is_private = TRUE;
  87         fv->value.tvb = new_tvb;
  88         return TRUE;
  89 }
  90
  91 static gboolean
  92 val_from_unparsed(fvalue_t *fv, char *s, gboolean allow_partial_value _U_, LogFunc logfunc)
  93 {
  94         fvalue_t *fv_bytes;
  95         tvbuff_t *new_tvb;
  96         guint8 *private_data;
  97
  98         /* Free up the old value, if we have one */
  99         value_free(fv);
 100
 101         /* Does this look like a byte string? */
 102         fv_bytes = fvalue_from_unparsed(FT_BYTES, s, TRUE, NULL);
 103         if (fv_bytes) {
 104                 /* Make a tvbuff from the bytes */
 105                 private_data = (guint8 *)g_memdup(fv_bytes->value.bytes->data,
 106                                 fv_bytes->value.bytes->len);
 107                 new_tvb = tvb_new_real_data(private_data,
 108                                 fv_bytes->value.bytes->len,
 109                                 fv_bytes->value.bytes->len);
 110
 111                 /* Let the tvbuff know how to delete the data. */
 112                 tvb_set_free_cb(new_tvb, free_tvb_data);
 113
 114                 /* And let us know that we need to free the tvbuff */
 115                 fv->tvb_is_private = TRUE;
 116                 fv->value.tvb = new_tvb;
 117                 return TRUE;
 118         }
 119
 120         /* Treat it as a string. */
 121         return val_from_string(fv, s, logfunc);
 122 }
 123
 124 static int
 125 val_repr_len(fvalue_t *fv, ftrepr_t rtype)
 126 {
 127         volatile guint length = 0;
 128
 129         if (rtype != FTREPR_DFILTER) return -1;
 130
 131         TRY {
 132                 /* 3 bytes for each byte of the byte "NN:" minus 1 byte
 133                  * as there's no trailing ":". */
 134                 length = tvb_length(fv->value.tvb) * 3 - 1;
 135         }
 136         CATCH_ALL {
 137                 /* nothing */
 138         }
 139         ENDTRY;
 140
 141         return (int) length;
 142 }
 143
 144 static void
 145 val_to_repr(fvalue_t *fv, ftrepr_t rtype, char * volatile buf)
 146 {
 147         guint length;
 148         const guint8 *c;
 149         unsigned int i;
 150
 151         g_assert(rtype == FTREPR_DFILTER);
 152
 153         TRY {
 154                 length = tvb_length(fv->value.tvb);
 155                 c = tvb_get_ptr(fv->value.tvb, 0, length);
 156
 157                 for (i = 0; i < length; i++) {
 158                         if (i == 0) {
 159                                 sprintf((char *)buf, "%02x", *c++);
 160                                 buf += 2;
 161                         }
 162                         else {
 163                                 sprintf((char *)buf, ":%02x", *c++);
 164                                 buf += 3;
 165                         }
 166                 }
 167         }
 168         CATCH_ALL {
 169                 /* nothing */
 170         }
 171         ENDTRY;
 172 }
 173
 174 static gpointer
 175 value_get(fvalue_t *fv)
 176 {
 177         return fv->value.tvb;
 178 }
 179
 180 static guint
 181 len(fvalue_t *fv)
 182 {
 183         volatile guint length = 0;
 184
 185         TRY {
 186                 if (fv->value.tvb)
 187                         length = tvb_length(fv->value.tvb);
 188         }
 189         CATCH_ALL {
 190                 /* nothing */
 191         }
 192         ENDTRY;
 193
 194         return length;
 195 }
 196
 197 static void
 198 slice(fvalue_t *fv, GByteArray *bytes, guint offset, guint length)
 199 {
 200         const guint8* data;
 201
 202         if (fv->value.tvb) {
 203                 TRY {
 204                         data = tvb_get_ptr(fv->value.tvb, offset, length);
 205                         g_byte_array_append(bytes, data, length);
 206                 }
 207                 CATCH_ALL {
 208                         /* nothing */
 209                 }
 210                 ENDTRY;
 211
 212         }
 213 }
 214
 215 static gboolean
 216 cmp_eq(const fvalue_t *fv_a, const fvalue_t *fv_b)
 217 {
 218         tvbuff_t        *a = fv_a->value.tvb;
 219         tvbuff_t        *b = fv_b->value.tvb;
 220         volatile gboolean       eq = FALSE;
 221
 222         TRY {
 223                 guint   a_len = tvb_length(a);
 224
 225                 if (a_len == tvb_length(b))
 226                         eq = (memcmp(tvb_get_ptr(a, 0, a_len), tvb_get_ptr(b, 0, a_len), a_len) == 0);
 227         }
 228         CATCH_ALL {
 229                 /* nothing */
 230         }
 231         ENDTRY;
 232
 233         return eq;
 234 }
 235
 236 static gboolean
 237 cmp_ne(const fvalue_t *fv_a, const fvalue_t *fv_b)
 238 {
 239         tvbuff_t        *a = fv_a->value.tvb;
 240         tvbuff_t        *b = fv_b->value.tvb;
 241         volatile gboolean       ne = TRUE;
 242
 243         TRY {
 244                 guint   a_len = tvb_length(a);
 245
 246                 if (a_len == tvb_length(b)) {
 247                         ne = (memcmp(tvb_get_ptr(a, 0, a_len), tvb_get_ptr(b, 0, a_len), a_len) != 0);
 248                 }
 249         }
 250         CATCH_ALL {
 251                 /* nothing */
 252         }
 253         ENDTRY;
 254
 255         return ne;
 256 }
 257
 258 static gboolean
 259 cmp_gt(const fvalue_t *fv_a, const fvalue_t *fv_b)
 260 {
 261         tvbuff_t        *a = fv_a->value.tvb;
 262         tvbuff_t        *b = fv_b->value.tvb;
 263         volatile gboolean       gt = FALSE;
 264
 265         TRY {
 266                 guint   a_len = tvb_length(a);
 267                 guint   b_len = tvb_length(b);
 268
 269                 if (a_len > b_len) {
 270                         gt = TRUE;
 271                 } else if (a_len == b_len) {
 272                         gt = (memcmp(tvb_get_ptr(a, 0, a_len), tvb_get_ptr(b, 0, a_len), a_len) > 0);
 273                 }
 274         }
 275         CATCH_ALL {
 276                 /* nothing */
 277         }
 278         ENDTRY;
 279
 280         return gt;
 281 }
 282
 283 static gboolean
 284 cmp_ge(const fvalue_t *fv_a, const fvalue_t *fv_b)
 285 {
 286         tvbuff_t        *a = fv_a->value.tvb;
 287         tvbuff_t        *b = fv_b->value.tvb;
 288         volatile gboolean       ge = FALSE;
 289
 290         TRY {
 291                 guint   a_len = tvb_length(a);
 292                 guint   b_len = tvb_length(b);
 293
 294                 if (a_len > b_len) {
 295                         ge = TRUE;
 296                 } else if (a_len == b_len) {
 297                         ge = (memcmp(tvb_get_ptr(a, 0, a_len), tvb_get_ptr(b, 0, a_len), a_len) >= 0);
 298                 }
 299         }
 300         CATCH_ALL {
 301                 /* nothing */
 302         }
 303         ENDTRY;
 304
 305         return ge;
 306 }
 307
 308 static gboolean
 309 cmp_lt(const fvalue_t *fv_a, const fvalue_t *fv_b)
 310 {
 311         tvbuff_t        *a = fv_a->value.tvb;
 312         tvbuff_t        *b = fv_b->value.tvb;
 313         volatile gboolean       lt = FALSE;
 314
 315         TRY {
 316                 guint   a_len = tvb_length(a);
 317                 guint   b_len = tvb_length(b);
 318
 319                 if (a_len < b_len) {
 320                         lt = TRUE;
 321                 } else if (a_len == b_len) {
 322                         lt = (memcmp(tvb_get_ptr(a, 0, a_len), tvb_get_ptr(b, 0, a_len), a_len) < 0);
 323                 }
 324         }
 325         CATCH_ALL {
 326                 /* nothing */
 327         }
 328         ENDTRY;
 329
 330         return lt;
 331 }
 332
 333 static gboolean
 334 cmp_le(const fvalue_t *fv_a, const fvalue_t *fv_b)
 335 {
 336         tvbuff_t        *a = fv_a->value.tvb;
 337         tvbuff_t        *b = fv_b->value.tvb;
 338         volatile gboolean       le = FALSE;
 339
 340         TRY {
 341                 guint   a_len = tvb_length(a);
 342                 guint   b_len = tvb_length(b);
 343
 344                 if (a_len < b_len) {
 345                         le = TRUE;
 346                 } else if (a_len == b_len) {
 347                         le = (memcmp(tvb_get_ptr(a, 0, a_len), tvb_get_ptr(b, 0, a_len), a_len) <= 0);
 348                 }
 349         }
 350         CATCH_ALL {
 351                 /* nothing */
 352         }
 353         ENDTRY;
 354
 355         return le;
 356 }
 357
 358 static gboolean
 359 cmp_contains(const fvalue_t *fv_a, const fvalue_t *fv_b)
 360 {
 361         volatile gboolean       contains = FALSE;
 362
 363         TRY {
 364                 if (tvb_find_tvb(fv_a->value.tvb, fv_b->value.tvb, 0) > -1) {
 365                         contains = TRUE;
 366                 }
 367         }
 368         CATCH_ALL {
 369                 /* nothing */
 370         }
 371         ENDTRY;
 372
 373         return contains;
 374 }
 375
 376 static gboolean
 377 cmp_matches(const fvalue_t *fv_a, const fvalue_t *fv_b)
 378 {
 379         tvbuff_t *tvb = fv_a->value.tvb;
 380         GRegex *regex = fv_b->value.re;
 381         volatile gboolean rc = FALSE;
 382         const char *data = NULL; /* tvb data */
 383         guint32 tvb_len; /* tvb length */
 384
 385         /* fv_b is always a FT_PCRE, otherwise the dfilter semcheck() would have
 386          * warned us. For the same reason (and because we're using g_malloc()),
 387          * fv_b->value.re is not NULL.
 388          */
 389         if (strcmp(fv_b->ftype->name, "FT_PCRE") != 0) {
 390                 return FALSE;
 391         }
 392         if (! regex) {
 393                 return FALSE;
 394         }
 395         TRY {
 396                 tvb_len = tvb_length(tvb);
 397                 data = (const char *)tvb_get_ptr(tvb, 0, tvb_len);
 398                 rc = g_regex_match_full(
 399                         regex,          /* Compiled PCRE */
 400                         data,           /* The data to check for the pattern... */
 401                         tvb_len,        /* ... and its length */
 402                         0,              /* Start offset within data */
 403                         (GRegexMatchFlags)0,            /* GRegexMatchFlags */
 404                         NULL,           /* We are not interested in the match information */
 405                         NULL            /* We don't want error information */
 406                         );
 407                 /* NOTE - DO NOT g_free(data) */
 408         }
 409         CATCH_ALL {
 410                 return FALSE;
 411         }
 412         ENDTRY;
 413         return rc;
 414 }
 415
 416 void
 417 ftype_register_tvbuff(void)
 418 {
 419
 420         static ftype_t protocol_type = {
 421                 FT_PROTOCOL,                    /* ftype */
 422                 "FT_PROTOCOL",                  /* name */
 423                 "Protocol",                     /* pretty_name */
 424                 0,                              /* wire_size */
 425                 value_new,                      /* new_value */
 426                 value_free,                     /* free_value */
 427                 val_from_unparsed,              /* val_from_unparsed */
 428                 val_from_string,                /* val_from_string */
 429                 val_to_repr,                    /* val_to_string_repr */
 430                 val_repr_len,                   /* len_string_repr */
 431
 432                 value_set,                      /* set_value */
 433                 NULL,                           /* set_value_uinteger */
 434                 NULL,                           /* set_value_sinteger */
 435                 NULL,                           /* set_value_integer64 */
 436                 NULL,                           /* set_value_floating */
 437
 438                 value_get,                      /* get_value */
 439                 NULL,                           /* get_value_uinteger */
 440                 NULL,                           /* get_value_sinteger */
 441                 NULL,                           /* get_value_integer64 */
 442                 NULL,                           /* get_value_floating */
 443
 444                 cmp_eq,
 445                 cmp_ne,
 446                 cmp_gt,
 447                 cmp_ge,
 448                 cmp_lt,
 449                 cmp_le,
 450                 NULL,                           /* cmp_bitwise_and */
 451                 cmp_contains,
 452                 CMP_MATCHES,
 453
 454                 len,
 455                 slice,
 456
 457         };
 458
 459
 460         ftype_register(FT_PROTOCOL, &protocol_type);
 461 }