epan/uat.c

   1 /*
   2  *  uat.c
   3  *
   4  *  User Accessible Tables
   5  *  Maintain an array of user accessible data structures
   6  *
   7  * (c) 2007, Luis E. Garcia Ontanon <luis@ontanon.org>
   8  *
   9  * Wireshark - Network traffic analyzer
  10  * By Gerald Combs <gerald@wireshark.org>
  11  * Copyright 2001 Gerald Combs
  12  *
  13  * SPDX-License-Identifier: GPL-2.0-or-later
  14  */
  15 #include "config.h"
  16
  17 #include <stdlib.h>
  18 #include <stdio.h>
  19 #include <string.h>
  20 #include <errno.h>
  21 #include <stdarg.h>
  22
  23 #include <glib.h>
  24
  25 #include <wsutil/file_util.h>
  26 #include <wsutil/str_util.h>
  27 #include <wsutil/report_message.h>
  28
  29 #include <wsutil/filesystem.h>
  30 #include <epan/packet.h>
  31 #include <epan/range.h>
  32
  33 #include "uat-int.h"
  34
  35 /*
  36  * XXX Files are encoded as ASCII. We might want to encode them as UTF8
  37  * instead.
  38  */
  39
  40 static GPtrArray* all_uats = NULL;
  41
  42 uat_t* uat_new(const char* name,
  43                size_t size,
  44                const char* filename,
  45                gboolean from_profile,
  46                void* data_ptr,
  47                guint* numitems_ptr,
  48                guint flags,
  49                const char* help,
  50                uat_copy_cb_t copy_cb,
  51                uat_update_cb_t update_cb,
  52                uat_free_cb_t free_cb,
  53                uat_post_update_cb_t post_update_cb,
  54                uat_reset_cb_t reset_cb,
  55                uat_field_t* flds_array) {
  56     /* Create new uat */
  57     uat_t* uat = (uat_t *)g_malloc(sizeof(uat_t));
  58     guint i;
  59
  60     /* Add to global array of uats */
  61     if (!all_uats)
  62         all_uats = g_ptr_array_new();
  63
  64     g_ptr_array_add(all_uats,uat);
  65
  66     /* Check params */
  67     g_assert(name && size && filename && data_ptr && numitems_ptr);
  68
  69     /* Set uat values from inputs */
  70     uat->name = g_strdup(name);
  71     uat->record_size = size;
  72     uat->filename = g_strdup(filename);
  73     uat->from_profile = from_profile;
  74     /* Callers of uat_new() pass in (void*) for data_ptr, because
  75      * that is the "universal" pointer type that can be cast to
  76      * anything. However, for our purposes, we want a (void**).
  77      * So, we cast (void*) data_ptr to (void**) here. That keeps
  78      * gcc -fstrict-aliasing from complaining. */
  79     uat->user_ptr = (void**) data_ptr;
  80     uat->nrows_p = numitems_ptr;
  81     uat->copy_cb = copy_cb;
  82     uat->update_cb = update_cb;
  83     uat->free_cb = free_cb;
  84     uat->post_update_cb = post_update_cb;
  85     uat->reset_cb = reset_cb;
  86     uat->fields = flds_array;
  87     uat->user_data = g_array_new(FALSE,FALSE,(guint)uat->record_size);
  88     uat->raw_data = g_array_new(FALSE,FALSE,(guint)uat->record_size);
  89     uat->valid_data = g_array_new(FALSE,FALSE,sizeof(gboolean));
  90     uat->changed = FALSE;
  91     uat->loaded = FALSE;
  92     uat->from_global = FALSE;
  93     uat->rep = NULL;
  94     uat->free_rep = NULL;
  95     uat->help = g_strdup(help);
  96     uat->flags = flags;
  97
  98     for (i=0;flds_array[i].title;i++) {
  99         fld_data_t* f = (fld_data_t *)g_malloc(sizeof(fld_data_t));
 100
 101         f->colnum = i+1;
 102         f->rep = NULL;
 103         f->free_rep = NULL;
 104
 105         flds_array[i].priv = f;
 106     }
 107
 108     uat->ncols = i;
 109
 110     *((void**)data_ptr) = NULL;
 111     *numitems_ptr = 0;
 112
 113     return uat;
 114 }
 115
 116 void* uat_add_record(uat_t* uat, const void* data, gboolean valid_rec) {
 117     void* rec;
 118     gboolean* valid;
 119
 120     uat_insert_record_idx(uat, uat->raw_data->len, data);
 121
 122     if (valid_rec) {
 123         /* Add a "known good" record to the list to be used by the dissector */
 124         g_array_append_vals (uat->user_data, data, 1);
 125
 126         rec = UAT_USER_INDEX_PTR(uat, uat->user_data->len - 1);
 127
 128         if (uat->copy_cb) {
 129             uat->copy_cb(rec, data, (unsigned int) uat->record_size);
 130         }
 131
 132         UAT_UPDATE(uat);
 133
 134         valid = &g_array_index(uat->valid_data, gboolean, uat->valid_data->len-1);
 135         *valid = valid_rec;
 136     } else {
 137         rec = NULL;
 138     }
 139
 140     return rec;
 141 }
 142
 143 /* Updates the validity of a record. */
 144 void uat_update_record(uat_t *uat, const void *record, gboolean valid_rec) {
 145     guint pos;
 146     gboolean *valid;
 147
 148     /* Locate internal UAT data pointer. */
 149     for (pos = 0; pos < uat->raw_data->len; pos++) {
 150         if (UAT_INDEX_PTR(uat, pos) == record) {
 151             break;
 152         }
 153     }
 154     if (pos == uat->raw_data->len) {
 155         /* Data is not within list?! */
 156         g_assert_not_reached();
 157     }
 158
 159     valid = &g_array_index(uat->valid_data, gboolean, pos);
 160     *valid = valid_rec;
 161 }
 162
 163 void uat_swap(uat_t* uat, guint a, guint b) {
 164     size_t s = uat->record_size;
 165     void* tmp;
 166     gboolean tmp_bool;
 167
 168     g_assert( a < uat->raw_data->len && b < uat->raw_data->len );
 169
 170     if (a == b) return;
 171
 172     tmp = g_malloc(s);
 173     memcpy(tmp, UAT_INDEX_PTR(uat,a), s);
 174     memcpy(UAT_INDEX_PTR(uat,a), UAT_INDEX_PTR(uat,b), s);
 175     memcpy(UAT_INDEX_PTR(uat,b), tmp, s);
 176     g_free(tmp);
 177
 178     tmp_bool = *(gboolean*)(uat->valid_data->data + (sizeof(gboolean) * (a)));
 179     *(gboolean*)(uat->valid_data->data + (sizeof(gboolean) * (a))) = *(gboolean*)(uat->valid_data->data + (sizeof(gboolean) * (b)));
 180     *(gboolean*)(uat->valid_data->data + (sizeof(gboolean) * (b))) = tmp_bool;
 181
 182
 183 }
 184
 185 void uat_insert_record_idx(uat_t* uat, guint idx, const void *src_record) {
 186     /* Allow insert before an existing item or append after the last item. */
 187     g_assert( idx <= uat->raw_data->len );
 188
 189     /* Store a copy of the record and invoke copy_cb to clone pointers too. */
 190     g_array_insert_vals(uat->raw_data, idx, src_record, 1);
 191     void *rec = UAT_INDEX_PTR(uat, idx);
 192     if (uat->copy_cb) {
 193         uat->copy_cb(rec, src_record, (unsigned int) uat->record_size);
 194     } else {
 195         memcpy(rec, src_record, (unsigned int) uat->record_size);
 196     }
 197
 198     /* Initially assume that the record is invalid, it is not copied to the
 199      * user-visible records list. */
 200     gboolean valid_rec = FALSE;
 201     g_array_insert_val(uat->valid_data, idx, valid_rec);
 202 }
 203
 204 void uat_remove_record_idx(uat_t* uat, guint idx) {
 205
 206     g_assert( idx < uat->raw_data->len );
 207
 208     if (uat->free_cb) {
 209         uat->free_cb(UAT_INDEX_PTR(uat,idx));
 210     }
 211
 212     g_array_remove_index(uat->raw_data, idx);
 213     g_array_remove_index(uat->valid_data, idx);
 214 }
 215
 216 void uat_move_index(uat_t * uat, guint old_idx, guint new_idx)
 217 {
 218     guint dir = 1;
 219     guint start = old_idx;
 220     if ( old_idx > new_idx )
 221         dir = -1;
 222
 223     while ( start != new_idx )
 224     {
 225         uat_swap(uat, start, start + dir);
 226         start += dir;
 227     }
 228 }
 229
 230 /* The returned filename was g_malloc()'d so the caller must free it */
 231 gchar* uat_get_actual_filename(uat_t* uat, gboolean for_writing) {
 232     gchar *pers_fname = NULL;
 233
 234     if (! uat->from_global) {
 235         pers_fname =  get_persconffile_path(uat->filename, uat->from_profile);
 236     }
 237
 238     if ((! for_writing ) && (! file_exists(pers_fname) )) {
 239         gchar* data_fname = get_datafile_path(uat->filename);
 240
 241         if (file_exists(data_fname)) {
 242             g_free(pers_fname);
 243             return data_fname;
 244         }
 245
 246         g_free(data_fname);
 247         g_free(pers_fname);
 248         return NULL;
 249     }
 250
 251     return pers_fname;
 252 }
 253
 254 uat_t* uat_get_table_by_name(const char* name) {
 255     guint i;
 256
 257     for (i=0; i < all_uats->len; i++) {
 258         uat_t* u = (uat_t *)g_ptr_array_index(all_uats,i);
 259         if ( g_str_equal(u->name,name) ) {
 260             return (u);
 261         }
 262     }
 263
 264     return NULL;
 265 }
 266
 267 char *uat_fld_tostr(void *rec, uat_field_t *f) {
 268     guint        len;
 269     char       *ptr;
 270     char       *out;
 271
 272     f->cb.tostr(rec, &ptr, &len, f->cbdata.tostr, f->fld_data);
 273
 274     switch(f->mode) {
 275         case PT_TXTMOD_NONE:
 276         case PT_TXTMOD_STRING:
 277         case PT_TXTMOD_ENUM:
 278         case PT_TXTMOD_BOOL:
 279         case PT_TXTMOD_FILENAME:
 280         case PT_TXTMOD_DIRECTORYNAME:
 281         case PT_TXTMOD_DISPLAY_FILTER:
 282         case PT_TXTMOD_COLOR:
 283         case PT_TXTMOD_PROTO_FIELD:
 284             out = g_strndup(ptr, len);
 285             break;
 286         case PT_TXTMOD_HEXBYTES: {
 287             GString *s = g_string_sized_new( len*2 + 1 );
 288             guint i;
 289
 290             for (i=0; i<len;i++) g_string_append_printf(s, "%.2X", ((const guint8*)ptr)[i]);
 291
 292             out = g_strdup(s->str);
 293
 294             g_string_free(s, TRUE);
 295             break;
 296         }
 297         default:
 298             g_assert_not_reached();
 299             out = NULL;
 300             break;
 301     }
 302
 303     g_free(ptr);
 304     return out;
 305 }
 306
 307 static void putfld(FILE* fp, void* rec, uat_field_t* f) {
 308     guint fld_len;
 309     char* fld_ptr;
 310
 311     f->cb.tostr(rec,&fld_ptr,&fld_len,f->cbdata.tostr,f->fld_data);
 312
 313     switch(f->mode){
 314         case PT_TXTMOD_NONE:
 315         case PT_TXTMOD_ENUM:
 316         case PT_TXTMOD_FILENAME:
 317         case PT_TXTMOD_DIRECTORYNAME:
 318         case PT_TXTMOD_DISPLAY_FILTER:
 319         case PT_TXTMOD_PROTO_FIELD:
 320         case PT_TXTMOD_COLOR:
 321         case PT_TXTMOD_STRING: {
 322             guint i;
 323
 324             putc('"',fp);
 325
 326             for(i=0;i<fld_len;i++) {
 327                 char c = fld_ptr[i];
 328
 329                 if (c == '"' || c == '\\' || ! g_ascii_isprint((guchar)c) ) {
 330                     fprintf(fp,"\\x%02x", (guchar) c);
 331                 } else {
 332                     putc(c,fp);
 333                 }
 334             }
 335
 336             putc('"',fp);
 337             break;
 338         }
 339         case PT_TXTMOD_HEXBYTES: {
 340             guint i;
 341
 342             for(i=0;i<fld_len;i++) {
 343                 fprintf(fp,"%02x", (guchar)fld_ptr[i]);
 344             }
 345
 346             break;
 347         }
 348         case PT_TXTMOD_BOOL: {
 349             fprintf(fp,"\"%s\"", fld_ptr);
 350             break;
 351         }
 352         default:
 353             g_assert_not_reached();
 354     }
 355
 356     g_free(fld_ptr);
 357 }
 358
 359 gboolean uat_save(uat_t* uat, char** error) {
 360     guint i;
 361     gchar* fname = uat_get_actual_filename(uat,TRUE);
 362     FILE* fp;
 363
 364     if (! fname ) return FALSE;
 365
 366     fp = ws_fopen(fname,"w");
 367
 368     if (!fp && errno == ENOENT) {
 369         /* Parent directory does not exist, try creating first */
 370         gchar *pf_dir_path = NULL;
 371         if (create_persconffile_dir(&pf_dir_path) != 0) {
 372             *error = g_strdup_printf("uat_save: error creating '%s'", pf_dir_path);
 373             g_free (pf_dir_path);
 374             return FALSE;
 375         }
 376         fp = ws_fopen(fname,"w");
 377     }
 378
 379     if (!fp) {
 380         *error = g_strdup_printf("uat_save: error opening '%s': %s",fname,g_strerror(errno));
 381         return FALSE;
 382     }
 383
 384     *error = NULL;
 385     g_free (fname);
 386
 387     /* Ensure raw_data is synced with user_data and all "good" entries have been accounted for */
 388
 389     /* Start by clearing current user_data */
 390     for ( i = 0 ; i < uat->user_data->len ; i++ ) {
 391         if (uat->free_cb) {
 392             uat->free_cb(UAT_USER_INDEX_PTR(uat,i));
 393         }
 394     }
 395     g_array_set_size(uat->user_data,0);
 396
 397     *((uat)->user_ptr) = NULL;
 398     *((uat)->nrows_p) = 0;
 399
 400     /* Now copy "good" raw_data entries to user_data */
 401     for ( i = 0 ; i < uat->raw_data->len ; i++ ) {
 402         void *rec = UAT_INDEX_PTR(uat, i);
 403         gboolean valid = g_array_index(uat->valid_data, gboolean, i);
 404         if (valid) {
 405             g_array_append_vals(uat->user_data, rec, 1);
 406             if (uat->copy_cb) {
 407                 uat->copy_cb(UAT_USER_INDEX_PTR(uat, uat->user_data->len - 1),
 408                              rec, (unsigned int) uat->record_size);
 409             }
 410
 411             UAT_UPDATE(uat);
 412         }
 413     }
 414
 415
 416     fprintf(fp,"# This file is automatically generated, DO NOT MODIFY.\n");
 417
 418     for ( i = 0 ; i < uat->user_data->len ; i++ ) {
 419         void* rec = uat->user_data->data + (uat->record_size * i);
 420         uat_field_t* f;
 421         guint j;
 422
 423         f = uat->fields;
 424
 425
 426         for( j=0 ; j < uat->ncols ; j++ ) {
 427             putfld(fp, rec, &(f[j]));
 428             fputs((j == uat->ncols - 1) ? "\n" : "," ,fp);
 429         }
 430
 431     }
 432
 433     fclose(fp);
 434
 435     uat->changed = FALSE;
 436
 437     return TRUE;
 438 }
 439
 440 uat_t *uat_find(gchar *name) {
 441     guint i;
 442
 443     for (i=0; i < all_uats->len; i++) {
 444         uat_t* u = (uat_t *)g_ptr_array_index(all_uats,i);
 445
 446         if (strcmp(u->name, name) == 0 || strcmp(u->filename, name) == 0) {
 447             return u;
 448         }
 449     }
 450     return NULL;
 451 }
 452
 453 void uat_clear(uat_t* uat) {
 454     guint i;
 455
 456     for ( i = 0 ; i < uat->user_data->len ; i++ ) {
 457         if (uat->free_cb) {
 458             uat->free_cb(UAT_USER_INDEX_PTR(uat,i));
 459         }
 460     }
 461
 462     for ( i = 0 ; i < uat->raw_data->len ; i++ ) {
 463         if (uat->free_cb) {
 464             uat->free_cb(UAT_INDEX_PTR(uat,i));
 465         }
 466     }
 467
 468     g_array_set_size(uat->raw_data,0);
 469     g_array_set_size(uat->user_data,0);
 470     g_array_set_size(uat->valid_data,0);
 471
 472     *((uat)->user_ptr) = NULL;
 473     *((uat)->nrows_p) = 0;
 474
 475     if (uat->reset_cb) {
 476         uat->reset_cb();
 477     }
 478 }
 479
 480 void uat_unload_all(void) {
 481     guint i;
 482
 483     for (i=0; i < all_uats->len; i++) {
 484         uat_t* u = (uat_t *)g_ptr_array_index(all_uats,i);
 485         /* Do not unload if not in profile */
 486         if (u->from_profile) {
 487             uat_clear(u);
 488             u->loaded = FALSE;
 489         }
 490     }
 491 }
 492
 493 void uat_cleanup(void) {
 494     guint i;
 495     guint j;
 496     uat_t* uat;
 497
 498     for (i = 0; i < all_uats->len; i++) {
 499         uat = (uat_t *)g_ptr_array_index(all_uats, i);
 500         uat_clear(uat);
 501         g_free(uat->help);
 502         g_free(uat->name);
 503         g_free(uat->filename);
 504         g_array_free(uat->user_data, TRUE);
 505         g_array_free(uat->raw_data, TRUE);
 506         g_array_free(uat->valid_data, TRUE);
 507         for (j = 0; uat->fields[j].title; j++)
 508             g_free(uat->fields[j].priv);
 509         g_free(uat);
 510     }
 511
 512     g_ptr_array_free(all_uats,TRUE);
 513 }
 514
 515 void uat_foreach_table(uat_cb_t cb,void* user_data) {
 516     guint i;
 517
 518     for (i=0; i < all_uats->len; i++)
 519         cb(g_ptr_array_index(all_uats,i), user_data);
 520
 521 }
 522
 523 void uat_load_all(void) {
 524     guint i;
 525     gchar* err;
 526
 527     for (i=0; i < all_uats->len; i++) {
 528         uat_t* u = (uat_t *)g_ptr_array_index(all_uats,i);
 529
 530         if (!u->loaded) {
 531             err = NULL;
 532             if (!uat_load(u, &err)) {
 533                 report_failure("Error loading table '%s': %s",u->name,err);
 534                 g_free(err);
 535             }
 536         }
 537     }
 538 }
 539
 540
 541 gboolean uat_fld_chk_str(void* u1 _U_, const char* strptr, guint len _U_, const void* u2 _U_, const void* u3 _U_, char** err) {
 542     if (strptr == NULL) {
 543         *err = g_strdup("NULL pointer");
 544         return FALSE;
 545     }
 546
 547     *err = NULL;
 548     return TRUE;
 549 }
 550
 551 gboolean uat_fld_chk_oid(void* u1 _U_, const char* strptr, guint len, const void* u2 _U_, const void* u3 _U_, char** err) {
 552   unsigned int i;
 553     *err = NULL;
 554
 555     if (strptr == NULL) {
 556       *err = g_strdup("NULL pointer");
 557       return FALSE;
 558     }
 559
 560     if (len == 0) {
 561       *err = g_strdup("Empty OID");
 562       return FALSE;
 563     }
 564
 565     for(i = 0; i < len; i++)
 566       if(!(g_ascii_isdigit(strptr[i]) || strptr[i] == '.')) {
 567         *err = g_strdup("Only digits [0-9] and \".\" allowed in an OID");
 568         return FALSE;
 569       }
 570
 571     if(strptr[len-1] == '.') {
 572       *err = g_strdup("OIDs must not be terminated with a \".\"");
 573       return FALSE;
 574     }
 575
 576     if(!((*strptr == '0' || *strptr == '1' || *strptr =='2') && (len > 1 && strptr[1] == '.'))) {
 577       *err = g_strdup("OIDs must start with \"0.\" (ITU-T assigned), \"1.\" (ISO assigned) or \"2.\" (joint ISO/ITU-T assigned)");
 578       return FALSE;
 579     }
 580
 581     /* should also check that the second arc is in the range 0-39 */
 582
 583     return *err == NULL;
 584 }
 585
 586 gboolean uat_fld_chk_proto(void* u1 _U_, const char* strptr, guint len, const void* u2 _U_, const void* u3 _U_, char** err) {
 587     if (len) {
 588         char* name = g_strndup(strptr,len);
 589         ascii_strdown_inplace(name);
 590         g_strchug(name);
 591
 592         if (find_dissector(name)) {
 593             *err = NULL;
 594             g_free(name);
 595             return TRUE;
 596         } else {
 597             *err = g_strdup("dissector not found");
 598             g_free(name);
 599             return FALSE;
 600         }
 601     } else {
 602         *err = NULL;
 603         return TRUE;
 604     }
 605 }
 606
 607 static gboolean uat_fld_chk_num(int base, const char* strptr, guint len, char** err) {
 608     if (len > 0) {
 609         char* str = g_strndup(strptr,len);
 610         char* strn;
 611         long i;
 612
 613         errno = 0;
 614         i = strtol(str,&strn,base);
 615
 616         if (((i == G_MAXLONG || i == G_MINLONG) && errno == ERANGE)
 617             || (errno != 0 && i == 0)) {
 618             *err = g_strdup(g_strerror(errno));
 619             g_free(str);
 620             return FALSE;
 621         }
 622         if ((*strn != '\0') && (*strn != ' ')) {
 623             *err = g_strdup("Invalid value");
 624             g_free(str);
 625             return FALSE;
 626         }
 627         /* Allow only 32bit values */
 628         if ((sizeof(long) > 4) && ((i < G_MININT) || (i > G_MAXINT))) {
 629             *err = g_strdup("Value too large");
 630             g_free(str);
 631             return FALSE;
 632         }
 633
 634         g_free(str);
 635     }
 636
 637     *err = NULL;
 638     return TRUE;
 639 }
 640
 641 gboolean uat_fld_chk_num_dec(void* u1 _U_, const char* strptr, guint len, const void* u2 _U_, const void* u3 _U_, char** err) {
 642     return uat_fld_chk_num(10, strptr, len, err);
 643 }
 644
 645 gboolean uat_fld_chk_num_hex(void* u1 _U_, const char* strptr, guint len, const void* u2 _U_, const void* u3 _U_, char** err) {
 646     return uat_fld_chk_num(16, strptr, len, err);
 647 }
 648
 649 gboolean uat_fld_chk_bool(void* u1 _U_, const char* strptr, guint len, const void* u2 _U_, const void* u3 _U_, char** err)
 650 {
 651     char* str = g_strndup(strptr,len);
 652
 653     if ((g_strcmp0(str, "TRUE") == 0) ||
 654         (g_strcmp0(str, "FALSE") == 0)) {
 655         *err = NULL;
 656         g_free(str);
 657         return TRUE;
 658     }
 659
 660     *err = g_strdup_printf("invalid value: %s (must be TRUE or FALSE)", str);
 661     g_free(str);
 662     return FALSE;
 663 }
 664
 665
 666 gboolean uat_fld_chk_enum(void* u1 _U_, const char* strptr, guint len, const void* v, const void* u3 _U_, char** err) {
 667     char* str = g_strndup(strptr,len);
 668     guint i;
 669     const value_string* vs = (const value_string *)v;
 670
 671     for(i=0;vs[i].strptr;i++) {
 672         if (g_strcmp0(vs[i].strptr,str) == 0) {
 673             *err = NULL;
 674             g_free(str);
 675             return TRUE;
 676         }
 677     }
 678
 679     *err = g_strdup_printf("invalid value: %s",str);
 680     g_free(str);
 681     return FALSE;
 682 }
 683
 684 gboolean uat_fld_chk_range(void* u1 _U_, const char* strptr, guint len, const void* v _U_, const void* u3, char** err) {
 685     char* str = g_strndup(strptr,len);
 686     range_t* r = NULL;
 687     convert_ret_t ret = range_convert_str(NULL, &r, str,GPOINTER_TO_UINT(u3));
 688     gboolean ret_value = FALSE;
 689
 690     switch (  ret ) {
 691         case CVT_NO_ERROR:
 692             *err = NULL;
 693             ret_value = TRUE;
 694             break;
 695         case CVT_SYNTAX_ERROR:
 696             *err = g_strdup_printf("syntax error in range: %s",str);
 697             ret_value = FALSE;
 698             break;
 699         case CVT_NUMBER_TOO_BIG:
 700             *err = g_strdup_printf("value too large in range: '%s' (max = %u)",str,GPOINTER_TO_UINT(u3));
 701             ret_value = FALSE;
 702             break;
 703         default:
 704             *err = g_strdup("Unable to convert range. Please report this to wireshark-dev@wireshark.org");
 705             ret_value = FALSE;
 706             break;
 707     }
 708
 709     g_free(str);
 710     wmem_free(NULL, r);
 711     return ret_value;
 712 }
 713
 714 gboolean uat_fld_chk_color(void* u1 _U_, const char* strptr, guint len, const void* v _U_, const void* u3 _U_, char** err) {
 715
 716     if ((len != 7) || (*strptr != '#')) {
 717         *err = g_strdup("Color must be of the format #RRGGBB");
 718         return FALSE;
 719     }
 720
 721     /* Color is just # followed by hex string, so use hex verification */
 722     return uat_fld_chk_num(16, strptr + 1, len - 1, err);
 723 }
 724
 725 char* uat_unbinstring(const char* si, guint in_len, guint* len_p) {
 726     guint8* buf;
 727     guint len = in_len/2;
 728     int i = 0;
 729     int d0, d1;
 730
 731     if (in_len%2) {
 732         return NULL;
 733     }
 734
 735     buf= (guint8 *)g_malloc0(len+1);
 736     if (len_p) *len_p = len;
 737
 738     while(in_len) {
 739         d1 = ws_xton(*(si++));
 740         d0 = ws_xton(*(si++));
 741
 742         buf[i++] = (d1 * 16) + d0;
 743
 744         in_len -= 2;
 745     }
 746
 747     return (char*)buf;
 748 }
 749
 750 char* uat_unesc(const char* si, guint in_len, guint* len_p) {
 751     char* buf = (char *)g_malloc0(in_len+1);
 752     char* p = buf;
 753     guint len = 0;
 754     const char* s;
 755     const char* in_end = si+in_len;
 756
 757     for (s = (const char *)si; s < in_end; s++) {
 758         switch(*s) {
 759             case '\\':
 760                 switch(*(++s)) {
 761                     case 'a': *(p++) = '\a'; len++; break;
 762                     case 'b': *(p++) = '\b'; len++; break;
 763                     case 'e': *(p++) = '\033' /* '\e' is non ANSI-C */; len++; break;
 764                     case 'f': *(p++) = '\f'; len++; break;
 765                     case 'n': *(p++) = '\n'; len++; break;
 766                     case 'r': *(p++) = '\r'; len++; break;
 767                     case 't': *(p++) = '\t'; len++; break;
 768                     case 'v': *(p++) = '\v'; len++; break;
 769
 770                     case '0':
 771                     case '1':
 772                     case '2':
 773                     case '3':
 774                     case '4':
 775                     case '5':
 776                     case '6':
 777                     case '7':
 778                     {
 779                         int c0 = 0;
 780                         int c1 = 0;
 781                         int c2 = 0;
 782                         int c = 0;
 783
 784                         c0 = (*s) - '0';
 785
 786                         if ( s[1] >= '0' && s[1] <= '7' ) {
 787                             c1 = c0;
 788                             c0 = (*++s) - '0';
 789
 790                             if ( s[1] >= '0' && s[1] <= '7' ) {
 791                                 c2 = c1;
 792                                 c1 = c0;
 793                                 c0 = (*++s) - '0';
 794                             }
 795                         }
 796                         c = (64 * c2) + (8 * c1) + c0;
 797                         *(p++) = (char) (c > 255 ? 255 : c);
 798                         len++;
 799                         break;
 800                     }
 801
 802                     case 'x':
 803                     {
 804                         char c1 = *(s+1);
 805                         char c0 = *(s+2);
 806
 807                         if (g_ascii_isxdigit(c1) && g_ascii_isxdigit(c0)) {
 808                             *(p++) = (ws_xton(c1) * 0x10) + ws_xton(c0);
 809                             s += 2;
 810                         } else {
 811                             *(p++) = *s;
 812                         }
 813                         len++;
 814                         break;
 815                     }
 816                     default:
 817                         *p++ = *s;
 818                         break;
 819                 }
 820                 break;
 821             default:
 822                 *(p++) = *s;
 823                 len++;
 824                 break;
 825         }
 826     }
 827
 828     if (len_p) *len_p = len;
 829     return buf;
 830 }
 831
 832 char* uat_undquote(const char* si, guint in_len, guint* len_p) {
 833     return uat_unesc(si+1,in_len-2,len_p);
 834 }
 835
 836
 837 char* uat_esc(const char* buf, guint len) {
 838     const guint8* end = ((const guint8*)buf)+len;
 839     char* out = (char *)g_malloc0((4*len)+1);
 840     const guint8* b;
 841     char* s = out;
 842
 843     for (b = (const guint8 *)buf; b < end; b++) {
 844         if (*b == '"' || *b == '\\' || ! g_ascii_isprint(*b) ) {
 845             g_snprintf(s,5,"\\x%02x",((guint)*b));
 846             s+=4;
 847         } else {
 848             *(s++) = (*b);
 849         }
 850     }
 851
 852     return out;
 853
 854 }
 855
 856 gboolean uat_fld_chk_str_isprint(void* u1 _U_, const char* strptr, guint len, const void* u2 _U_, const void* u3 _U_, char** err) {
 857     guint i;
 858
 859     for (i = 0; i < len; i++) {
 860         char c = strptr[i];
 861         if (! g_ascii_isprint(c)) {
 862             *err = g_strdup_printf("invalid char pos=%d value=%02x", i, (guchar) c);
 863             return FALSE;
 864         }
 865     }
 866     *err = NULL;
 867     return TRUE;
 868 }
 869
 870 gboolean uat_fld_chk_str_isalpha(void* u1 _U_, const char* strptr, guint len, const void* u2 _U_, const void* u3 _U_, char** err) {
 871     guint i;
 872
 873     for (i = 0; i < len; i++) {
 874         char c = strptr[i];
 875         if (! g_ascii_isalpha(c)) {
 876             *err = g_strdup_printf("invalid char pos=%d value=%02x", i, (guchar) c);
 877             return FALSE;
 878         }
 879     }
 880     *err = NULL;
 881     return TRUE;
 882 }
 883
 884 gboolean uat_fld_chk_str_isalnum(void* u1 _U_, const char* strptr, guint len, const void* u2 _U_, const void* u3 _U_, char** err) {
 885     guint i;
 886
 887     for (i = 0; i < len; i++) {
 888         char c = strptr[i];
 889         if (! g_ascii_isalnum(c)) {
 890             *err = g_strdup_printf("invalid char pos=%d value=%02x", i, (guchar) c);
 891             return FALSE;
 892         }
 893     }
 894     *err = NULL;
 895     return TRUE;
 896 }
 897
 898 gboolean uat_fld_chk_str_isdigit(void* u1 _U_, const char* strptr, guint len, const void* u2 _U_, const void* u3 _U_, char** err) {
 899     guint i;
 900
 901     for (i = 0; i < len; i++) {
 902         char c = strptr[i];
 903         if (! g_ascii_isdigit(c)) {
 904             *err = g_strdup_printf("invalid char pos=%d value=%02x", i, (guchar) c);
 905             return FALSE;
 906         }
 907     }
 908     *err = NULL;
 909     return TRUE;
 910 }
 911
 912 gboolean uat_fld_chk_str_isxdigit(void* u1 _U_, const char* strptr, guint len, const void* u2 _U_, const void* u3 _U_, char** err) {
 913     guint i;
 914
 915     for (i = 0; i < len; i++) {
 916         char c = strptr[i];
 917         if (! g_ascii_isxdigit(c)) {
 918             *err = g_strdup_printf("invalid char pos=%d value=%02x", i, (guchar) c);
 919             return FALSE;
 920         }
 921     }
 922     *err = NULL;
 923     return TRUE;
 924 }
 925
 926
 927 /*
 928  * Editor modelines
 929  *
 930  * Local Variables:
 931  * c-basic-offset: 4
 932  * tab-width: 8
 933  * indent-tabs-mode: nil
 934  * End:
 935  *
 936  * ex: set shiftwidth=4 tabstop=8 expandtab:
 937  * :indentSize=4:tabSize=8:noTabs=true:
 938  */