epan/ftypes/ftype-integer.c

   1 /*
   2  * $Id$
   3  *
   4  * Ethereal - Network traffic analyzer
   5  * By Gerald Combs <gerald@ethereal.com>
   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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <stdlib.h>
  28 #include <errno.h>
  29 #include "ftypes-int.h"
  30 #include <epan/addr_resolv.h>
  31
  32 #ifdef NEED_G_ASCII_STRTOULL_H
  33 #include "g_ascii_strtoull.h"
  34 #endif
  35
  36 /*
  37  * GLib 1.2[.x] doesn't define G_MAXUINT32 or G_MAXUINT64; if they're
  38  * not defined, we define them as the maximum 32-bit and 32-bit
  39  * unsigned numbers.
  40  */
  41 #ifndef G_MAXUINT32
  42 #define G_MAXUINT32     ((guint32)0xFFFFFFFFU)
  43 #endif
  44 #ifndef G_MAXUINT64
  45 #define G_MAXUINT64     ((guint64)G_GINT64_CONSTANT(0xFFFFFFFFFFFFFFFFU))
  46 #endif
  47
  48 static void
  49 int_fvalue_new(fvalue_t *fv)
  50 {
  51         fv->value.integer = 0;
  52 }
  53
  54 static void
  55 set_integer(fvalue_t *fv, guint32 value)
  56 {
  57         fv->value.integer = value;
  58 }
  59
  60 static guint32
  61 get_integer(fvalue_t *fv)
  62 {
  63         return fv->value.integer;
  64 }
  65
  66 static gboolean
  67 val_from_unparsed(fvalue_t *fv, char *s, gboolean allow_partial_value _U_, LogFunc logfunc)
  68 {
  69         unsigned long value;
  70         char    *endptr;
  71
  72         errno = 0;
  73         value = strtoul(s, &endptr, 0);
  74
  75         if (errno == EINVAL || endptr == s || *endptr != '\0') {
  76                 /* This isn't a valid number. */
  77                 if (logfunc != NULL)
  78                         logfunc("\"%s\" is not a valid number.", s);
  79                 return FALSE;
  80         }
  81         if (errno == ERANGE) {
  82                 if (logfunc != NULL) {
  83                         if (value == ULONG_MAX) {
  84                                 logfunc("\"%s\" causes an integer overflow.",
  85                                     s);
  86                         }
  87                         else {
  88                                 /*
  89                                  * XXX - can "strtoul()" set errno to
  90                                  * ERANGE without returning ULONG_MAX?
  91                                  */
  92                                 logfunc("\"%s\" is not an integer.", s);
  93                         }
  94                 }
  95                 return FALSE;
  96         }
  97         if (value > G_MAXUINT32) {
  98                 /*
  99                  * Fits in an unsigned long, but not in a guint32
 100                  * (an unsigned long might be 64 bits).
 101                  */
 102                 if (logfunc != NULL)
 103                         logfunc("\"%s\" causes an integer overflow.", s);
 104                 return FALSE;
 105         }
 106
 107         fv->value.integer = value;
 108         return TRUE;
 109 }
 110
 111 static int
 112 integer_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
 113 {
 114         return 11;      /* enough for 12^31-1, in decimal */
 115 }
 116
 117 static void
 118 integer_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
 119 {
 120         sprintf(buf, "%d", fv->value.integer);
 121 }
 122
 123 static int
 124 uinteger_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
 125 {
 126         return 10;      /* enough for 2^32-1, in decimal */
 127 }
 128
 129 static void
 130 uinteger_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
 131 {
 132         sprintf(buf, "%u", fv->value.integer);
 133 }
 134
 135 static gboolean
 136 ipxnet_from_unparsed(fvalue_t *fv, char *s, gboolean allow_partial_value _U_, LogFunc logfunc)
 137 {
 138         guint32         val;
 139         gboolean        known;
 140
 141         /*
 142          * Don't log a message if this fails; we'll try looking it
 143          * up as an IPX network name if it does, and if that fails,
 144          * we'll log a message.
 145          */
 146         if (val_from_unparsed(fv, s, TRUE, NULL)) {
 147                 return TRUE;
 148         }
 149
 150         val = get_ipxnet_addr(s, &known);
 151         if (known) {
 152                 fv->value.integer = val;
 153                 return TRUE;
 154         }
 155
 156         logfunc("\"%s\" is not a valid IPX network name or address.", s);
 157         return FALSE;
 158 }
 159
 160 static int
 161 ipxnet_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
 162 {
 163         return 2+8;     /* 0xXXXXXXXX */
 164 }
 165
 166 static void
 167 ipxnet_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
 168 {
 169         sprintf(buf, "0x%08x", fv->value.integer);
 170 }
 171
 172 static gboolean
 173 cmp_eq(fvalue_t *a, fvalue_t *b)
 174 {
 175         return a->value.integer == b->value.integer;
 176 }
 177
 178 static gboolean
 179 cmp_ne(fvalue_t *a, fvalue_t *b)
 180 {
 181         return a->value.integer != b->value.integer;
 182 }
 183
 184 static gboolean
 185 u_cmp_gt(fvalue_t *a, fvalue_t *b)
 186 {
 187         return (int)a->value.integer > (int)b->value.integer;
 188 }
 189
 190 static gboolean
 191 u_cmp_ge(fvalue_t *a, fvalue_t *b)
 192 {
 193         return (int)a->value.integer >= (int)b->value.integer;
 194 }
 195
 196 static gboolean
 197 u_cmp_lt(fvalue_t *a, fvalue_t *b)
 198 {
 199         return (int)a->value.integer < (int)b->value.integer;
 200 }
 201
 202 static gboolean
 203 u_cmp_le(fvalue_t *a, fvalue_t *b)
 204 {
 205         return (int)a->value.integer <= (int)b->value.integer;
 206 }
 207
 208 static gboolean
 209 s_cmp_gt(fvalue_t *a, fvalue_t *b)
 210 {
 211         return a->value.integer > b->value.integer;
 212 }
 213
 214 static gboolean
 215 s_cmp_ge(fvalue_t *a, fvalue_t *b)
 216 {
 217         return a->value.integer >= b->value.integer;
 218 }
 219
 220 static gboolean
 221 s_cmp_lt(fvalue_t *a, fvalue_t *b)
 222 {
 223         return a->value.integer < b->value.integer;
 224 }
 225
 226 static gboolean
 227 s_cmp_le(fvalue_t *a, fvalue_t *b)
 228 {
 229         return a->value.integer <= b->value.integer;
 230 }
 231
 232 static gboolean
 233 cmp_bitwise_and(fvalue_t *a, fvalue_t *b)
 234 {
 235         return ((a->value.integer & b->value.integer) != 0);
 236 }
 237
 238 static void
 239 int64_fvalue_new(fvalue_t *fv)
 240 {
 241         fv->value.integer64 = 0;
 242 }
 243
 244 static void
 245 set_integer64(fvalue_t *fv, guint64 value)
 246 {
 247         fv->value.integer64 = value;
 248 }
 249
 250 static guint64
 251 get_integer64(fvalue_t *fv)
 252 {
 253         return fv->value.integer64;
 254 }
 255
 256 static gboolean
 257 val64_from_unparsed(fvalue_t *fv, char *s, gboolean allow_partial_value _U_, LogFunc logfunc)
 258 {
 259         guint64 value;
 260         char    *endptr;
 261
 262         errno = 0;
 263         value = g_ascii_strtoull(s, &endptr, 0);
 264
 265         if (errno == EINVAL || endptr == s || *endptr != '\0') {
 266                 /* This isn't a valid number. */
 267                 if (logfunc != NULL)
 268                         logfunc("\"%s\" is not a valid number.", s);
 269                 return FALSE;
 270         }
 271         if (errno == ERANGE) {
 272                 if (logfunc != NULL) {
 273                         if (value == ULONG_MAX) {
 274                                 logfunc("\"%s\" causes an integer overflow.",
 275                                     s);
 276                         }
 277                         else {
 278                                 /*
 279                                  * XXX - can "strtoul()" set errno to
 280                                  * ERANGE without returning ULONG_MAX?
 281                                  */
 282                                 logfunc("\"%s\" is not an integer.", s);
 283                         }
 284                 }
 285                 return FALSE;
 286         }
 287         if (value > G_MAXUINT64) {
 288                 /*
 289                  * Fits in an unsigned long, but not in a guint64
 290                  * (unlikely, but not impossible).
 291                  */
 292                 if (logfunc != NULL)
 293                         logfunc("\"%s\" causes an integer overflow.", s);
 294                 return FALSE;
 295         }
 296
 297         fv->value.integer64 = value;
 298         return TRUE;
 299 }
 300
 301 static int
 302 integer64_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
 303 {
 304         return 20;      /* enough for -2^63-1, in decimal */
 305 }
 306
 307 static void
 308 integer64_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
 309 {
 310         sprintf(buf, PRId64, fv->value.integer64);
 311 }
 312
 313 static int
 314 uinteger64_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
 315 {
 316         return 20;      /* enough for 2^64-1, in decimal */
 317 }
 318
 319 static void
 320 uinteger64_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
 321 {
 322         sprintf(buf, PRIu64, fv->value.integer64);
 323 }
 324
 325 static gboolean
 326 cmp_eq64(fvalue_t *a, fvalue_t *b)
 327 {
 328         return a->value.integer64 == b->value.integer64;
 329 }
 330
 331 static gboolean
 332 cmp_ne64(fvalue_t *a, fvalue_t *b)
 333 {
 334         return a->value.integer64 != b->value.integer64;
 335 }
 336
 337 static gboolean
 338 u_cmp_gt64(fvalue_t *a, fvalue_t *b)
 339 {
 340         return (gint64)a->value.integer64 > (gint64)b->value.integer64;
 341 }
 342
 343 static gboolean
 344 u_cmp_ge64(fvalue_t *a, fvalue_t *b)
 345 {
 346         return (gint64)a->value.integer64 >= (gint64)b->value.integer64;
 347 }
 348
 349 static gboolean
 350 u_cmp_lt64(fvalue_t *a, fvalue_t *b)
 351 {
 352         return (gint64)a->value.integer64 < (gint64)b->value.integer64;
 353 }
 354
 355 static gboolean
 356 u_cmp_le64(fvalue_t *a, fvalue_t *b)
 357 {
 358         return (gint64)a->value.integer64 <= (gint64)b->value.integer64;
 359 }
 360
 361 static gboolean
 362 s_cmp_gt64(fvalue_t *a, fvalue_t *b)
 363 {
 364         return a->value.integer64 > b->value.integer64;
 365 }
 366
 367 static gboolean
 368 s_cmp_ge64(fvalue_t *a, fvalue_t *b)
 369 {
 370         return a->value.integer64 >= b->value.integer64;
 371 }
 372
 373 static gboolean
 374 s_cmp_lt64(fvalue_t *a, fvalue_t *b)
 375 {
 376         return a->value.integer64 < b->value.integer64;
 377 }
 378
 379 static gboolean
 380 s_cmp_le64(fvalue_t *a, fvalue_t *b)
 381 {
 382         return a->value.integer64 <= b->value.integer64;
 383 }
 384
 385 static gboolean
 386 cmp_bitwise_and64(fvalue_t *a, fvalue_t *b)
 387 {
 388         return ((a->value.integer64 & b->value.integer64) != 0);
 389 }
 390
 391 /* BOOLEAN-specific */
 392
 393 static void
 394 boolean_fvalue_new(fvalue_t *fv)
 395 {
 396         fv->value.integer = TRUE;
 397 }
 398
 399 static int
 400 boolean_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
 401 {
 402         return 1;
 403 }
 404
 405 static void
 406 boolean_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
 407 {
 408         sprintf(buf, "%s", fv->value.integer ? "1" : "0");
 409 }
 410
 411 /* Checks for equality with zero or non-zero */
 412 static gboolean
 413 bool_eq(fvalue_t *a, fvalue_t *b)
 414 {
 415         if (a->value.integer) {
 416                 if (b->value.integer) {
 417                         return TRUE;
 418                 }
 419                 else {
 420                         return FALSE;
 421                 }
 422         }
 423         else {
 424                 if (b->value.integer) {
 425                         return FALSE;
 426                 }
 427                 else {
 428                         return TRUE;
 429                 }
 430         }
 431 }
 432
 433 /* Checks for inequality with zero or non-zero */
 434 static gboolean
 435 bool_ne(fvalue_t *a, fvalue_t *b)
 436 {
 437         return (!bool_eq(a,b));
 438 }
 439
 440
 441
 442 void
 443 ftype_register_integers(void)
 444 {
 445
 446         static ftype_t uint8_type = {
 447                 "FT_UINT8",                     /* name */
 448                 "unsigned, 1 byte",             /* pretty name */
 449                 1,                              /* wire_size */
 450                 int_fvalue_new,                 /* new_value */
 451                 NULL,                           /* free_value */
 452                 val_from_unparsed,              /* val_from_unparsed */
 453                 NULL,                           /* val_from_string */
 454                 uinteger_to_repr,               /* val_to_string_repr */
 455                 uinteger_repr_len,              /* len_string_repr */
 456
 457                 NULL,                           /* set_value */
 458                 set_integer,                    /* set_value_integer */
 459                 NULL,                           /* set_value_integer64 */
 460                 NULL,                           /* set_value_floating */
 461
 462                 NULL,                           /* get_value */
 463                 get_integer,                    /* get_value_integer */
 464                 NULL,                           /* get_value_integer64 */
 465                 NULL,                           /* get_value_floating */
 466
 467                 cmp_eq,
 468                 cmp_ne,
 469                 u_cmp_gt,
 470                 u_cmp_ge,
 471                 u_cmp_lt,
 472                 u_cmp_le,
 473                 cmp_bitwise_and,
 474                 NULL,                           /* cmp_contains */
 475                 NULL,                           /* cmp_matches */
 476
 477                 NULL,                           /* len */
 478                 NULL,                           /* slice */
 479         };
 480         static ftype_t uint16_type = {
 481                 "FT_UINT16",                    /* name */
 482                 "unsigned, 2 bytes",            /* pretty_name */
 483                 2,                              /* wire_size */
 484                 int_fvalue_new,                 /* new_value */
 485                 NULL,                           /* free_value */
 486                 val_from_unparsed,              /* val_from_unparsed */
 487                 NULL,                           /* val_from_string */
 488                 uinteger_to_repr,               /* val_to_string_repr */
 489                 uinteger_repr_len,              /* len_string_repr */
 490
 491                 NULL,                           /* set_value */
 492                 set_integer,                    /* set_value_integer */
 493                 NULL,                           /* set_value_integer64 */
 494                 NULL,                           /* set_value_floating */
 495
 496                 NULL,                           /* get_value */
 497                 get_integer,                    /* get_value_integer */
 498                 NULL,                           /* get_value_integer64 */
 499                 NULL,                           /* get_value_floating */
 500
 501                 cmp_eq,
 502                 cmp_ne,
 503                 u_cmp_gt,
 504                 u_cmp_ge,
 505                 u_cmp_lt,
 506                 u_cmp_le,
 507                 cmp_bitwise_and,
 508                 NULL,                           /* cmp_contains */
 509                 NULL,                           /* cmp_matches */
 510
 511                 NULL,                           /* len */
 512                 NULL,                           /* slice */
 513         };
 514         static ftype_t uint24_type = {
 515                 "FT_UINT24",                    /* name */
 516                 "unsigned, 3 bytes",            /* pretty_name */
 517                 3,                              /* wire_size */
 518                 int_fvalue_new,                 /* new_value */
 519                 NULL,                           /* free_value */
 520                 val_from_unparsed,              /* val_from_unparsed */
 521                 NULL,                           /* val_from_string */
 522                 uinteger_to_repr,               /* val_to_string_repr */
 523                 uinteger_repr_len,              /* len_string_repr */
 524
 525                 NULL,                           /* set_value */
 526                 set_integer,                    /* set_value_integer */
 527                 NULL,                           /* set_value_integer64 */
 528                 NULL,                           /* set_value_floating */
 529
 530                 NULL,                           /* get_value */
 531                 get_integer,                    /* get_value_integer */
 532                 NULL,                           /* get_value_integer64 */
 533                 NULL,                           /* get_value_floating */
 534
 535                 cmp_eq,
 536                 cmp_ne,
 537                 u_cmp_gt,
 538                 u_cmp_ge,
 539                 u_cmp_lt,
 540                 u_cmp_le,
 541                 cmp_bitwise_and,
 542                 NULL,                           /* cmp_contains */
 543                 NULL,                           /* cmp_matches */
 544
 545                 NULL,                           /* len */
 546                 NULL,                           /* slice */
 547         };
 548         static ftype_t uint32_type = {
 549                 "FT_UINT32",                    /* name */
 550                 "unsigned, 4 bytes",            /* pretty_name */
 551                 4,                              /* wire_size */
 552                 int_fvalue_new,                 /* new_value */
 553                 NULL,                           /* free_value */
 554                 val_from_unparsed,              /* val_from_unparsed */
 555                 NULL,                           /* val_from_string */
 556                 uinteger_to_repr,               /* val_to_string_repr */
 557                 uinteger_repr_len,              /* len_string_repr */
 558
 559                 NULL,                           /* set_value */
 560                 set_integer,                    /* set_value_integer */
 561                 NULL,                           /* set_value_integer64 */
 562                 NULL,                           /* set_value_floating */
 563
 564                 NULL,                           /* get_value */
 565                 get_integer,                    /* get_value_integer */
 566                 NULL,                           /* get_value_integer64 */
 567                 NULL,                           /* get_value_floating */
 568
 569                 cmp_eq,
 570                 cmp_ne,
 571                 u_cmp_gt,
 572                 u_cmp_ge,
 573                 u_cmp_lt,
 574                 u_cmp_le,
 575                 cmp_bitwise_and,
 576                 NULL,                           /* cmp_contains */
 577                 NULL,                           /* cmp_matches */
 578
 579                 NULL,                           /* len */
 580                 NULL,                           /* slice */
 581         };
 582         static ftype_t uint64_type = {
 583                 "FT_UINT64",                    /* name */
 584                 "unsigned, 8 bytes",            /* pretty_name */
 585                 8,                              /* wire_size */
 586                 int64_fvalue_new,               /* new_value */
 587                 NULL,                           /* free_value */
 588                 val64_from_unparsed,            /* val_from_unparsed */
 589                 NULL,                           /* val_from_string */
 590                 uinteger64_to_repr,             /* val_to_string_repr */
 591                 uinteger64_repr_len,            /* len_string_repr */
 592
 593                 NULL,                           /* set_value */
 594                 NULL,                           /* set_value_integer */
 595                 set_integer64,                  /* set_value_integer64 */
 596                 NULL,                           /* set_value_floating */
 597
 598                 NULL,                           /* get_value */
 599                 NULL,                           /* get_value_integer */
 600                 get_integer64,                  /* get_value_integer64 */
 601                 NULL,                           /* get_value_floating */
 602
 603                 cmp_eq64,
 604                 cmp_ne64,
 605                 u_cmp_gt64,
 606                 u_cmp_ge64,
 607                 u_cmp_lt64,
 608                 u_cmp_le64,
 609                 cmp_bitwise_and64,
 610                 NULL,                           /* cmp_contains */
 611                 NULL,                           /* cmp_matches */
 612
 613                 NULL,
 614                 NULL,
 615         };
 616         static ftype_t int8_type = {
 617                 "FT_INT8",                      /* name */
 618                 "signed, 1 byte",               /* pretty_name */
 619                 1,                              /* wire_size */
 620                 int_fvalue_new,                 /* new_value */
 621                 NULL,                           /* free_value */
 622                 val_from_unparsed,              /* val_from_unparsed */
 623                 NULL,                           /* val_from_string */
 624                 integer_to_repr,                /* val_to_string_repr */
 625                 integer_repr_len,               /* len_string_repr */
 626
 627                 NULL,                           /* set_value */
 628                 set_integer,                    /* set_value_integer */
 629                 NULL,                           /* set_value_integer64 */
 630                 NULL,                           /* set_value_floating */
 631
 632                 NULL,                           /* get_value */
 633                 get_integer,                    /* get_value_integer */
 634                 NULL,                           /* get_value_integer64 */
 635                 NULL,                           /* get_value_floating */
 636
 637                 cmp_eq,
 638                 cmp_ne,
 639                 s_cmp_gt,
 640                 s_cmp_ge,
 641                 s_cmp_lt,
 642                 s_cmp_le,
 643                 cmp_bitwise_and,
 644                 NULL,                           /* cmp_contains */
 645                 NULL,                           /* cmp_matches */
 646
 647                 NULL,                           /* len */
 648                 NULL,                           /* slice */
 649         };
 650         static ftype_t int16_type = {
 651                 "FT_INT16",                     /* name */
 652                 "signed, 2 bytes",              /* pretty_name */
 653                 2,                              /* wire_size */
 654                 int_fvalue_new,                 /* new_value */
 655                 NULL,                           /* free_value */
 656                 val_from_unparsed,              /* val_from_unparsed */
 657                 NULL,                           /* val_from_string */
 658                 integer_to_repr,                /* val_to_string_repr */
 659                 integer_repr_len,               /* len_string_repr */
 660
 661                 NULL,                           /* set_value */
 662                 set_integer,                    /* set_value_integer */
 663                 NULL,                           /* set_value_integer64 */
 664                 NULL,                           /* set_value_floating */
 665
 666                 NULL,                           /* get_value */
 667                 get_integer,                    /* get_value_integer */
 668                 NULL,                           /* get_value_integer64 */
 669                 NULL,                           /* get_value_floating */
 670
 671                 cmp_eq,
 672                 cmp_ne,
 673                 s_cmp_gt,
 674                 s_cmp_ge,
 675                 s_cmp_lt,
 676                 s_cmp_le,
 677                 cmp_bitwise_and,
 678                 NULL,                           /* cmp_contains */
 679                 NULL,                           /* cmp_matches */
 680
 681                 NULL,                           /* len */
 682                 NULL,                           /* slice */
 683         };
 684         static ftype_t int24_type = {
 685                 "FT_INT24",                     /* name */
 686                 "signed, 3 bytes",              /* pretty_name */
 687                 3,                              /* wire_size */
 688                 int_fvalue_new,                 /* new_value */
 689                 NULL,                           /* free_value */
 690                 val_from_unparsed,              /* val_from_unparsed */
 691                 NULL,                           /* val_from_string */
 692                 integer_to_repr,                /* val_to_string_repr */
 693                 integer_repr_len,               /* len_string_repr */
 694
 695                 NULL,                           /* set_value */
 696                 set_integer,                    /* set_value_integer */
 697                 NULL,                           /* set_value_integer64 */
 698                 NULL,                           /* set_value_floating */
 699
 700                 NULL,                           /* get_value */
 701                 get_integer,                    /* get_value_integer */
 702                 NULL,                           /* get_value_integer64 */
 703                 NULL,                           /* get_value_floating */
 704
 705                 cmp_eq,
 706                 cmp_ne,
 707                 s_cmp_gt,
 708                 s_cmp_ge,
 709                 s_cmp_lt,
 710                 s_cmp_le,
 711                 cmp_bitwise_and,
 712                 NULL,                           /* cmp_contains */
 713                 NULL,                           /* cmp_matches */
 714
 715                 NULL,                           /* len */
 716                 NULL,                           /* slice */
 717         };
 718         static ftype_t int32_type = {
 719                 "FT_INT32",                     /* name */
 720                 "signed, 4 bytes",              /* pretty_name */
 721                 4,                              /* wire_size */
 722                 int_fvalue_new,                 /* new_value */
 723                 NULL,                           /* free_value */
 724                 val_from_unparsed,              /* val_from_unparsed */
 725                 NULL,                           /* val_from_string */
 726                 integer_to_repr,                /* val_to_string_repr */
 727                 integer_repr_len,               /* len_string_repr */
 728
 729                 NULL,                           /* set_value */
 730                 set_integer,                    /* set_value_integer */
 731                 NULL,                           /* set_value_integer64 */
 732                 NULL,                           /* set_value_floating */
 733
 734                 NULL,                           /* get_value */
 735                 get_integer,                    /* get_value_integer */
 736                 NULL,                           /* get_value_integer64 */
 737                 NULL,                           /* get_value_floating */
 738
 739                 cmp_eq,
 740                 cmp_ne,
 741                 s_cmp_gt,
 742                 s_cmp_ge,
 743                 s_cmp_lt,
 744                 s_cmp_le,
 745                 cmp_bitwise_and,
 746                 NULL,                           /* cmp_contains */
 747                 NULL,                           /* cmp_matches */
 748
 749                 NULL,                           /* len */
 750                 NULL,                           /* slice */
 751         };
 752         static ftype_t int64_type = {
 753                 "FT_INT64",                     /* name */
 754                 "signed, 8 bytes",              /* pretty_name */
 755                 8,                              /* wire_size */
 756                 int64_fvalue_new,               /* new_value */
 757                 NULL,                           /* free_value */
 758                 val64_from_unparsed,            /* val_from_unparsed */
 759                 NULL,                           /* val_from_string */
 760                 integer64_to_repr,              /* val_to_string_repr */
 761                 integer64_repr_len,             /* len_string_repr */
 762
 763                 NULL,                           /* set_value */
 764                 NULL,                           /* set_value_integer */
 765                 set_integer64,                  /* set_value_integer64 */
 766                 NULL,                           /* set_value_floating */
 767
 768                 NULL,                           /* get_value */
 769                 NULL,                           /* get_value_integer */
 770                 get_integer64,                  /* get_value_integer64 */
 771                 NULL,                           /* get_value_floating */
 772
 773                 cmp_eq64,
 774                 cmp_ne64,
 775                 s_cmp_gt64,
 776                 s_cmp_ge64,
 777                 s_cmp_lt64,
 778                 s_cmp_le64,
 779                 cmp_bitwise_and64,
 780                 NULL,                           /* cmp_contains */
 781                 NULL,                           /* cmp_matches */
 782
 783                 NULL,
 784                 NULL,
 785         };
 786         static ftype_t boolean_type = {
 787                 "FT_BOOLEAN",                   /* name */
 788                 "Boolean",                      /* pretty_name */
 789                 0,                              /* wire_size */
 790                 boolean_fvalue_new,             /* new_value */
 791                 NULL,                           /* free_value */
 792                 val_from_unparsed,              /* val_from_unparsed */
 793                 NULL,                           /* val_from_string */
 794                 boolean_to_repr,                /* val_to_string_repr */
 795                 boolean_repr_len,               /* len_string_repr */
 796
 797                 NULL,                           /* set_value */
 798                 set_integer,                    /* set_value_integer */
 799                 NULL,                           /* set_value_integer64 */
 800                 NULL,                           /* set_value_floating */
 801
 802                 NULL,                           /* get_value */
 803                 get_integer,                    /* get_value_integer */
 804                 NULL,                           /* get_value_integer64 */
 805                 NULL,                           /* get_value_floating */
 806
 807                 bool_eq,                        /* cmp_eq */
 808                 bool_ne,                        /* cmp_ne */
 809                 NULL,                           /* cmp_gt */
 810                 NULL,                           /* cmp_ge */
 811                 NULL,                           /* cmp_lt */
 812                 NULL,                           /* cmp_le */
 813                 NULL,                           /* cmp_bitwise_and */
 814                 NULL,                           /* cmp_contains */
 815                 NULL,                           /* cmp_matches */
 816
 817                 NULL,                           /* len */
 818                 NULL,                           /* slice */
 819         };
 820
 821         static ftype_t ipxnet_type = {
 822                 "FT_IPXNET",                    /* name */
 823                 "IPX network number",           /* pretty_name */
 824                 4,                              /* wire_size */
 825                 int_fvalue_new,                 /* new_value */
 826                 NULL,                           /* free_value */
 827                 ipxnet_from_unparsed,           /* val_from_unparsed */
 828                 NULL,                           /* val_from_string */
 829                 ipxnet_to_repr,                 /* val_to_string_repr */
 830                 ipxnet_repr_len,                /* len_string_repr */
 831
 832                 NULL,                           /* set_value */
 833                 set_integer,                    /* set_value_integer */
 834                 NULL,                           /* set_value_integer64 */
 835                 NULL,                           /* set_value_floating */
 836
 837                 NULL,                           /* get_value */
 838                 get_integer,                    /* get_value_integer */
 839                 NULL,                           /* get_value_integer64 */
 840                 NULL,                           /* get_value_floating */
 841
 842                 cmp_eq,
 843                 cmp_ne,
 844                 u_cmp_gt,
 845                 u_cmp_ge,
 846                 u_cmp_lt,
 847                 u_cmp_le,
 848                 cmp_bitwise_and,
 849                 NULL,                           /* cmp_contains */
 850                 NULL,                           /* cmp_matches */
 851
 852                 NULL,                           /* len */
 853                 NULL,                           /* slice */
 854         };
 855
 856         static ftype_t framenum_type = {
 857                 "FT_FRAMENUM",                  /* name */
 858                 "frame number",                 /* pretty_name */
 859                 4,                              /* wire_size */
 860                 int_fvalue_new,                 /* new_value */
 861                 NULL,                           /* free_value */
 862                 val_from_unparsed,              /* val_from_unparsed */
 863                 NULL,                           /* val_from_string */
 864                 uinteger_to_repr,               /* val_to_string_repr */
 865                 uinteger_repr_len,              /* len_string_repr */
 866
 867                 NULL,                           /* set_value */
 868                 set_integer,                    /* set_value_integer */
 869                 NULL,                           /* set_value_integer64 */
 870                 NULL,                           /* set_value_floating */
 871
 872                 NULL,                           /* get_value */
 873                 get_integer,                    /* get_value_integer */
 874                 NULL,                           /* get_value_integer64 */
 875                 NULL,                           /* get_value_floating */
 876
 877                 cmp_eq,
 878                 cmp_ne,
 879                 u_cmp_gt,
 880                 u_cmp_ge,
 881                 u_cmp_lt,
 882                 u_cmp_le,
 883                 NULL,                           /* cmp_bitwise_and */
 884                 NULL,                           /* cmp_contains */
 885                 NULL,                           /* cmp_matches */
 886
 887                 NULL,                           /* len */
 888                 NULL,                           /* slice */
 889         };
 890
 891         ftype_register(FT_UINT8, &uint8_type);
 892         ftype_register(FT_UINT16, &uint16_type);
 893         ftype_register(FT_UINT24, &uint24_type);
 894         ftype_register(FT_UINT32, &uint32_type);
 895         ftype_register(FT_UINT64, &uint64_type);
 896         ftype_register(FT_INT8, &int8_type);
 897         ftype_register(FT_INT16, &int16_type);
 898         ftype_register(FT_INT24, &int24_type);
 899         ftype_register(FT_INT32, &int32_type);
 900         ftype_register(FT_INT64, &int64_type);
 901         ftype_register(FT_BOOLEAN, &boolean_type);
 902         ftype_register(FT_IPXNET, &ipxnet_type);
 903         ftype_register(FT_FRAMENUM, &framenum_type);
 904 }