epan/uat.c

   1 /*
   2  *  uat.c
   3  *
   4  * $Id$
   5  *
   6  *  User Accessible Tables
   7  *  Mantain an array of user accessible data strucures
   8  *
   9  * (c) 2007, Luis E. Garcia Ontanon <luis@ontanon.org>
  10  *
  11  * Wireshark - Network traffic analyzer
  12  * By Gerald Combs <gerald@wireshark.org>
  13  * Copyright 2001 Gerald Combs
  14  *
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License
  17  * as published by the Free Software Foundation; either version 2
  18  * of the License, or (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  28  */
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #include <stdlib.h>
  34 #include <stdio.h>
  35 #include <string.h>
  36 #include <errno.h>
  37 #include <ctype.h>
  38 #include <stdarg.h>
  39
  40 #include <glib.h>
  41
  42 #include <wsutil/file_util.h>
  43 #include <wsutil/str_util.h>
  44
  45 #include <epan/emem.h>
  46 #include <epan/report_err.h>
  47 #include <epan/filesystem.h>
  48 #include <epan/packet.h>
  49 #include <epan/range.h>
  50
  51 #include "uat-int.h"
  52
  53 static GPtrArray* all_uats = NULL;
  54
  55 void uat_init(void) {
  56         all_uats = g_ptr_array_new();
  57 }
  58
  59 uat_t* uat_new(const char* name,
  60                            size_t size,
  61                            const char* filename,
  62                            gboolean from_profile,
  63                            void** data_ptr,
  64                            guint* numitems_ptr,
  65                            const char* category,
  66                            const char* help,
  67                            uat_copy_cb_t copy_cb,
  68                            uat_update_cb_t update_cb,
  69                            uat_free_cb_t free_cb,
  70                            uat_post_update_cb_t post_update_cb,
  71                            uat_field_t* flds_array) {
  72         /* Create new uat */
  73         uat_t* uat = g_malloc(sizeof(uat_t));
  74         guint i;
  75
  76         /* Add to global array of uats */
  77         if (!all_uats)
  78                 all_uats = g_ptr_array_new();
  79
  80         g_ptr_array_add(all_uats,uat);
  81
  82         /* Check params */
  83         g_assert(name && size && filename && data_ptr && numitems_ptr);
  84
  85         /* Set uat values from inputs */
  86         uat->name = g_strdup(name);
  87         uat->record_size = size;
  88         uat->filename = g_strdup(filename);
  89         uat->from_profile = from_profile;
  90         uat->user_ptr = data_ptr;
  91         uat->nrows_p = numitems_ptr;
  92         uat->copy_cb = copy_cb;
  93         uat->update_cb = update_cb;
  94         uat->free_cb = free_cb;
  95         uat->post_update_cb = post_update_cb;
  96         uat->fields = flds_array;
  97         uat->user_data = g_array_new(FALSE,FALSE,(guint)uat->record_size);
  98         uat->changed = FALSE;
  99         uat->loaded = FALSE;
 100         uat->rep = NULL;
 101         uat->free_rep = NULL;
 102         uat->help = help;
 103         uat->category = category;
 104
 105         for (i=0;flds_array[i].title;i++) {
 106                 fld_data_t* f = g_malloc(sizeof(fld_data_t));
 107
 108                 f->colnum = i+1;
 109                 f->rep = NULL;
 110                 f->free_rep = NULL;
 111
 112                 flds_array[i].priv = f;
 113         }
 114
 115         uat->ncols = i;
 116
 117         *data_ptr = NULL;
 118         *numitems_ptr = 0;
 119
 120         return uat;
 121 }
 122
 123 void* uat_add_record(uat_t* uat, const void* data) {
 124         void* rec;
 125
 126         g_array_append_vals (uat->user_data, data, 1);
 127
 128         rec = uat->user_data->data + (uat->record_size * (uat->user_data->len-1));
 129
 130         if (uat->copy_cb) {
 131                 uat->copy_cb(rec, data, (unsigned int) uat->record_size);
 132         }
 133
 134         UAT_UPDATE(uat);
 135
 136         return rec;
 137 }
 138
 139 void uat_swap(uat_t* uat, guint a, guint b) {
 140         size_t s = uat->record_size;
 141         void* tmp = ep_alloc(s);
 142
 143         g_assert( a < uat->user_data->len && b < uat->user_data->len );
 144
 145         if (a == b) return;
 146
 147         memcpy(tmp, UAT_INDEX_PTR(uat,a), s);
 148         memcpy(UAT_INDEX_PTR(uat,a), UAT_INDEX_PTR(uat,b), s);
 149         memcpy(UAT_INDEX_PTR(uat,b), tmp, s);
 150
 151 }
 152
 153 void uat_remove_record_idx(uat_t* uat, guint idx) {
 154
 155         g_assert( idx < uat->user_data->len );
 156
 157         if (uat->free_cb) {
 158                 uat->free_cb(UAT_INDEX_PTR(uat,idx));
 159         }
 160
 161         g_array_remove_index(uat->user_data, idx);
 162
 163         UAT_UPDATE(uat);
 164
 165 }
 166
 167 /* The returned filename was g_malloc()'d so the caller must free it */
 168 gchar* uat_get_actual_filename(uat_t* uat, gboolean for_writing) {
 169
 170         gchar* pers_fname =  get_persconffile_path(uat->filename, uat->from_profile, for_writing);
 171
 172         if (! for_writing ) {
 173                 gchar* data_fname = get_datafile_path(uat->filename);
 174
 175                 if ((! file_exists(pers_fname) ) && file_exists(data_fname)) {
 176                         g_free(pers_fname);
 177                         return data_fname;
 178                 }
 179
 180                 g_free(data_fname);
 181         }
 182
 183         if ((! file_exists(pers_fname) ) && (! for_writing ) ) {
 184                 g_free(pers_fname);
 185                 return NULL;
 186         }
 187
 188         return pers_fname;
 189 }
 190
 191 uat_t* uat_get_table_by_name(const char* name) {
 192         guint i;
 193
 194         for (i=0; i < all_uats->len; i++) {
 195                 uat_t* u = g_ptr_array_index(all_uats,i);
 196                 if ( g_str_equal(u->name,name) ) {
 197                         return (u);
 198                 }
 199         }
 200
 201         return NULL;
 202 }
 203
 204 static void putfld(FILE* fp, void* rec, uat_field_t* f) {
 205         guint fld_len;
 206         const char* fld_ptr;
 207
 208         f->cb.tostr(rec,&fld_ptr,&fld_len,f->cbdata.tostr,f->fld_data);
 209
 210         switch(f->mode){
 211                 case PT_TXTMOD_ENUM:
 212                 case PT_TXTMOD_FILENAME:
 213                 case PT_TXTMOD_DIRECTORYNAME:
 214                 case PT_TXTMOD_STRING: {
 215                         guint i;
 216
 217                         putc('"',fp);
 218
 219                         for(i=0;i<fld_len;i++) {
 220                                 char c = fld_ptr[i];
 221
 222                                 if (c == '"' || c == '\\' || ! isprint((guchar)c) ) {
 223                                         fprintf(fp,"\\x%.2x",c);
 224                                 } else {
 225                                         putc(c,fp);
 226                                 }
 227                         }
 228
 229                         putc('"',fp);
 230                         return;
 231                 }
 232                 case PT_TXTMOD_HEXBYTES: {
 233                         guint i;
 234
 235                         for(i=0;i<fld_len;i++) {
 236                                 fprintf(fp,"%.2x",((guint8*)fld_ptr)[i]);
 237                         }
 238
 239                         return;
 240                 }
 241                 default:
 242                         g_assert_not_reached();
 243         }
 244 }
 245
 246 gboolean uat_save(uat_t* uat, char** error) {
 247         guint i;
 248         gchar* fname = uat_get_actual_filename(uat,TRUE);
 249         FILE* fp;
 250
 251         if (! fname ) return FALSE;
 252
 253         fp = ws_fopen(fname,"w");
 254
 255     if (!fp && errno == ENOENT) {
 256         /* Parent directory does not exist, try creating first */
 257         gchar *pf_dir_path = NULL;
 258         if (create_persconffile_dir(&pf_dir_path) != 0) {
 259             *error = ep_strdup_printf("uat_save: error creating '%s'", pf_dir_path);
 260             g_free (pf_dir_path);
 261             return FALSE;
 262         }
 263         fp = ws_fopen(fname,"w");
 264     }
 265
 266         if (!fp) {
 267                 *error = ep_strdup_printf("uat_save: error opening '%s': %s",fname,g_strerror(errno));
 268                 return FALSE;
 269         }
 270
 271         *error = NULL;
 272         g_free (fname);
 273
 274         fprintf(fp,"# This file is automatically generated, DO NOT MODIFY.\n");
 275
 276         for ( i = 0 ; i < uat->user_data->len ; i++ ) {
 277                 void* rec = uat->user_data->data + (uat->record_size * i);
 278                 uat_field_t* f;
 279                 guint j;
 280
 281                 f = uat->fields;
 282
 283
 284                 for( j=0 ; j < uat->ncols ; j++ ) {
 285                         putfld(fp, rec, &(f[j]));
 286                         fputs((j == uat->ncols - 1) ? "\n" : "," ,fp);
 287                 }
 288
 289         }
 290
 291         fclose(fp);
 292
 293         uat->changed = FALSE;
 294
 295         return TRUE;
 296 }
 297
 298 void uat_destroy(uat_t* uat) {
 299         /* XXX still missing a destructor */
 300         g_ptr_array_remove(all_uats,uat);
 301
 302 }
 303
 304 uat_t *uat_find(gchar *name) {
 305     guint i;
 306
 307         for (i=0; i < all_uats->len; i++) {
 308                 uat_t* u = g_ptr_array_index(all_uats,i);
 309
 310         if (strcmp(u->name, name) == 0 || strcmp(u->filename, name) == 0) {
 311             return u;
 312         }
 313         }
 314     return NULL;
 315 }
 316
 317 void uat_clear(uat_t* uat) {
 318         guint i;
 319
 320         for ( i = 0 ; i < uat->user_data->len ; i++ ) {
 321                 if (uat->free_cb) {
 322                         uat->free_cb(UAT_INDEX_PTR(uat,i));
 323                 }
 324         }
 325
 326         g_array_set_size(uat->user_data,0);
 327
 328         *((uat)->user_ptr) = NULL;
 329         *((uat)->nrows_p) = 0;
 330 }
 331
 332 void* uat_dup(uat_t* uat, guint* len_p) {
 333         guint size = (guint) (uat->record_size * uat->user_data->len);
 334         *len_p = size;
 335         return size ? g_memdup(uat->user_data->data,size) : NULL ;
 336 }
 337
 338 void* uat_se_dup(uat_t* uat, guint* len_p) {
 339         guint size = (guint) (uat->record_size * uat->user_data->len);
 340         *len_p = (guint) size;
 341         return size ? se_memdup(uat->user_data->data,size) : NULL ;
 342 }
 343
 344 void uat_unload_all(void) {
 345         guint i;
 346
 347         for (i=0; i < all_uats->len; i++) {
 348                 uat_t* u = g_ptr_array_index(all_uats,i);
 349         /* Do not unload if not in profile */
 350         if (u->from_profile) {
 351             uat_clear(u);
 352             u->loaded = FALSE;
 353         }
 354         }
 355 }
 356
 357 void uat_cleanup(void) {
 358         while( all_uats->len ) {
 359                 uat_destroy((uat_t*)all_uats->pdata);
 360         }
 361
 362         g_ptr_array_free(all_uats,TRUE);
 363 }
 364
 365
 366 void uat_foreach_table(uat_cb_t cb,void* user_data) {
 367         guint i;
 368
 369         for (i=0; i < all_uats->len; i++)
 370                 cb(g_ptr_array_index(all_uats,i), user_data);
 371
 372 }
 373
 374
 375 void uat_load_all(void) {
 376         guint i;
 377         gchar* err;
 378
 379         for (i=0; i < all_uats->len; i++) {
 380                 uat_t* u = g_ptr_array_index(all_uats,i);
 381                 err = NULL;
 382
 383                 if (!u->loaded)
 384                         uat_load(u, &err);
 385
 386                 if (err) {
 387                         report_failure("Error loading table '%s': %s",u->name,err);
 388                 }
 389         }
 390 }
 391
 392
 393 gboolean uat_fld_chk_str(void* u1 _U_, const char* strptr, unsigned len _U_, const void* u2 _U_, const void* u3 _U_, const char** err) {
 394         if (strptr == NULL) {
 395                 *err = "NULL pointer";
 396                 return FALSE;
 397         }
 398
 399         *err = NULL;
 400         return TRUE;
 401 }
 402
 403 gboolean uat_fld_chk_oid(void* u1 _U_, const char* strptr, unsigned len, const void* u2 _U_, const void* u3 _U_, const char** err) {
 404   unsigned int i;
 405         *err = NULL;
 406
 407         if (strptr == NULL) {
 408           *err = "NULL pointer";
 409           return FALSE;
 410         }
 411
 412         for(i = 0; i < len; i++)
 413           if(!(isdigit(strptr[i]) || strptr[i] == '.')) {
 414             *err = "Only digits [0-9] and \".\" allowed in an OID";
 415             break;
 416           }
 417
 418         if(strptr[len-1] == '.')
 419           *err = "OIDs must not be terminated with a \".\"";
 420
 421         if(!((*strptr == '0' || *strptr == '1' || *strptr =='2') && (len > 1 && strptr[1] == '.')))
 422           *err = "OIDs must start with \"0.\" (ITU-T assigned), \"1.\" (ISO assigned) or \"2.\" (joint ISO/ITU-T assigned)";
 423
 424         /* should also check that the second arc is in the range 0-39 */
 425
 426         return *err == NULL;
 427 }
 428
 429 gboolean uat_fld_chk_proto(void* u1 _U_, const char* strptr, unsigned len, const void* u2 _U_, const void* u3 _U_, const char** err) {
 430         if (len) {
 431                 char* name = ep_strndup(strptr,len);
 432                 ascii_strdown_inplace(name);
 433                 g_strchug(name);
 434
 435                 if (find_dissector(name)) {
 436                         *err = NULL;
 437                         return TRUE;
 438                 } else {
 439                         *err = "dissector not found";
 440                         return FALSE;
 441                 }
 442         } else {
 443                 *err = NULL;
 444                 return TRUE;
 445         }
 446 }
 447
 448 gboolean uat_fld_chk_num_dec(void* u1 _U_, const char* strptr, unsigned len, const void* u2 _U_, const void* u3 _U_, const char** err) {
 449     if (len > 0) {
 450         char* str = ep_strndup(strptr,len);
 451         long i = strtol(str,&str,10);
 452
 453         if ( ( i == 0) && (errno == ERANGE || errno == EINVAL) ) {
 454             *err = g_strerror(errno);
 455             return FALSE;
 456         }
 457     }
 458
 459         *err = NULL;
 460         return TRUE;
 461 }
 462
 463 gboolean uat_fld_chk_num_hex(void* u1 _U_, const char* strptr, unsigned len, const void* u2 _U_, const void* u3 _U_, const char** err) {
 464     if (len > 0) {
 465         char* str = ep_strndup(strptr,len);
 466         long i = strtol(str,&str,16);
 467
 468         if ( ( i == 0) && (errno == ERANGE || errno == EINVAL) ) {
 469             *err = g_strerror(errno);
 470             return FALSE;
 471         }
 472     }
 473
 474         *err = NULL;
 475         return TRUE;
 476 }
 477
 478 gboolean uat_fld_chk_enum(void* u1 _U_, const char* strptr, unsigned len, const void* v, const void* u3 _U_, const char** err) {
 479         char* str = ep_strndup(strptr,len);
 480         guint i;
 481         const value_string* vs = v;
 482
 483         for(i=0;vs[i].strptr;i++) {
 484                 if (g_str_equal(vs[i].strptr,str)) {
 485                         *err = NULL;
 486                         return TRUE;
 487                 }
 488         }
 489
 490         *err = ep_strdup_printf("invalid value: %s",str);
 491         return FALSE;
 492 }
 493
 494 gboolean uat_fld_chk_range(void* u1 _U_, const char* strptr, unsigned len, const void* v _U_, const void* u3, const char** err) {
 495         char* str = ep_strndup(strptr,len);
 496         range_t* r = NULL;
 497         convert_ret_t ret = range_convert_str(&r, str,GPOINTER_TO_UINT(u3));
 498
 499         switch (  ret ) {
 500                 case CVT_NO_ERROR:
 501                         *err = NULL;
 502                         return TRUE;
 503                 case CVT_SYNTAX_ERROR:
 504                         *err = ep_strdup_printf("syntax error in range: %s",str);
 505                         return FALSE;
 506                 case CVT_NUMBER_TOO_BIG:
 507                         *err = ep_strdup_printf("value too large in range: '%s' (max = %u)",str,GPOINTER_TO_UINT(u3));
 508                         return FALSE;
 509                 default:
 510                         *err = "This should not happen, it is a bug in wireshark! please report to wireshark-dev@wireshark.org";
 511                         return FALSE;
 512         }
 513 }
 514
 515 static int xton(char d) {
 516         switch(d) {
 517                 case '0': return 0;
 518                 case '1': return 1;
 519                 case '2': return 2;
 520                 case '3': return 3;
 521                 case '4': return 4;
 522                 case '5': return 5;
 523                 case '6': return 6;
 524                 case '7': return 7;
 525                 case '8': return 8;
 526                 case '9': return 9;
 527                 case 'a':  case 'A': return 10;
 528                 case 'b':  case 'B': return 11;
 529                 case 'c':  case 'C': return 12;
 530                 case 'd':  case 'D': return 13;
 531                 case 'e':  case 'E': return 14;
 532                 case 'f':  case 'F': return 15;
 533                 default: return -1;
 534         }
 535 }
 536
 537 char* uat_unbinstring(const char* si, guint in_len, guint* len_p) {
 538         guint8* buf;
 539         guint len = in_len/2;
 540         int i = 0;
 541         int d0, d1;
 542
 543         if (in_len%2) {
 544                 return NULL;
 545         }
 546
 547         buf= g_malloc0(len+1);
 548         if (len_p) *len_p = len;
 549
 550         while(in_len) {
 551                 d1 = xton(*(si++));
 552                 d0 = xton(*(si++));
 553
 554                 buf[i++] = (d1 * 16) + d0;
 555
 556                 in_len -= 2;
 557         }
 558
 559         return (char*)buf;
 560 }
 561
 562 char* uat_unesc(const char* si, guint in_len, guint* len_p) {
 563         char* buf = g_malloc0(in_len+1);
 564         char* p = buf;
 565         guint len = 0;
 566         const char* s;
 567         const char* in_end = si+in_len;
 568
 569         for (s = (void*)si; s < in_end; s++) {
 570                 switch(*s) {
 571                         case '\\':
 572                                 switch(*(++s)) {
 573                                         case 'a': *(p++) = '\a'; len++; break;
 574                                         case 'b': *(p++) = '\b'; len++; break;
 575                                         case 'e': *(p++) = '\033' /* '\e' is non ANSI-C */; len++; break;
 576                                         case 'f': *(p++) = '\f'; len++; break;
 577                                         case 'n': *(p++) = '\n'; len++; break;
 578                                         case 'r': *(p++) = '\r'; len++; break;
 579                                         case 't': *(p++) = '\t'; len++; break;
 580                                         case 'v': *(p++) = '\v'; len++; break;
 581
 582                                         case '0':
 583                                         case '1':
 584                                         case '2':
 585                                         case '3':
 586                                         case '4':
 587                                         case '5':
 588                                         case '6':
 589                                         case '7':
 590                                         {
 591                                                 int c0 = 0;
 592                                                 int c1 = 0;
 593                                                 int c2 = 0;
 594                                                 int c = 0;
 595
 596                                                 c0 = (*s) - '0';
 597
 598                                                 if ( s[1] >= '0' && s[1] <= '7' ) {
 599                                                         c1 = c0;
 600                                                         c0 = (*++s) - '0';
 601
 602                                                         if ( s[1] >= '0' && s[1] <= '7' ) {
 603                                                                 c2 = c1;
 604                                                                 c1 = c0;
 605                                                                 c0 = (*++s) - '0';
 606                                                         }
 607                                                 }
 608                                                 c = (64 * c2) + (8 * c1) + c0;
 609                                                 *(p++) = (char) (c > 255 ? 255 : c);
 610                                                 len++;
 611                                                 break;
 612                                         }
 613
 614                                         case 'x':
 615                                         {
 616                                                 char c1 = *(s+1);
 617                                                 char c0 = *(s+2);
 618
 619                                                 if (isxdigit((guchar)c1) && isxdigit((guchar)c0)) {
 620                                                         *(p++) = (xton(c1) * 0x10) + xton(c0);
 621                                                         s += 2;
 622                                                 } else {
 623                                                         *(p++) = *s;
 624                                                 }
 625                                                 len++;
 626                                                 break;
 627                                         }
 628                                         default:
 629                                                 *p++ = *s;
 630                                                 break;
 631                                 }
 632                                 break;
 633                         default:
 634                                 *(p++) = *s;
 635                                 len++;
 636                                 break;
 637                 }
 638         }
 639
 640         if (len_p) *len_p = len;
 641         return buf;
 642 }
 643
 644 char* uat_undquote(const char* si, guint in_len, guint* len_p) {
 645         return uat_unesc(si+1,in_len-2,len_p);
 646 }
 647
 648
 649 char* uat_esc(const char* buf, guint len) {
 650         const guint8* end = ((guint8*)buf)+len;
 651         char* out = ep_alloc0((4*len)+1);
 652         const guint8* b;
 653         char* s = out;
 654
 655         for (b = (void*)buf; b < end; b++) {
 656                 if (isprint(*b) ) {
 657                         *(s++) = (*b);
 658                 } else {
 659                         g_snprintf(s,5,"\\x%.2x",((guint)*b));
 660                         s+=4;
 661                 }
 662         }
 663
 664         return out;
 665
 666 }
 667
 668 CHK_STR_IS_DEF(isprint)
 669 CHK_STR_IS_DEF(isalpha)
 670 CHK_STR_IS_DEF(isalnum)
 671 CHK_STR_IS_DEF(isdigit)
 672 CHK_STR_IS_DEF(isxdigit)
 673
 674 /*
 675  * Editor modelines
 676  *
 677  * Local Variables:
 678  * c-basic-offset: 4
 679  * tab-width: 4
 680  * indent-tabs-mode: nil
 681  * End:
 682  *
 683  * ex: set shiftwidth=4 tabstop=4 expandtab
 684  * :indentSize=4:tabSize=4:noTabs=true:
 685  */