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@gmail.com>
  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 #include <epan/emem.h>
  42 #include <epan/report_err.h>
  43 #include <epan/filesystem.h>
  44 #include <epan/packet.h>
  45 #include <epan/range.h>
  46 #include <wsutil/file_util.h>
  47
  48 #include "uat-int.h"
  49
  50 static GPtrArray* all_uats = NULL;
  51
  52 void uat_init(void) {
  53         all_uats = g_ptr_array_new();
  54 }
  55
  56 uat_t* uat_new(const char* name,
  57                            size_t size,
  58                            const char* filename,
  59                            gboolean from_profile,
  60                            void** data_ptr,
  61                            guint* numitems_ptr,
  62                            const char* category,
  63                            const char* help,
  64                            uat_copy_cb_t copy_cb,
  65                            uat_update_cb_t update_cb,
  66                            uat_free_cb_t free_cb,
  67                            uat_field_t* flds_array) {
  68         uat_t* uat = g_malloc(sizeof(uat_t));
  69         guint i;
  70
  71         if (!all_uats)
  72                 all_uats = g_ptr_array_new();
  73
  74         g_ptr_array_add(all_uats,uat);
  75
  76         g_assert(name && size && filename && data_ptr && numitems_ptr);
  77
  78         uat->name = g_strdup(name);
  79         uat->record_size = size;
  80         uat->filename = g_strdup(filename);
  81         uat->from_profile = from_profile;
  82         uat->user_ptr = data_ptr;
  83         uat->nrows_p = numitems_ptr;
  84         uat->copy_cb = copy_cb;
  85         uat->update_cb = update_cb;
  86         uat->free_cb = free_cb;
  87         uat->fields = flds_array;
  88         uat->user_data = g_array_new(FALSE,FALSE,uat->record_size);
  89         uat->changed = FALSE;
  90         uat->loaded = FALSE;
  91         uat->rep = NULL;
  92         uat->free_rep = NULL;
  93         uat->help = help;
  94         uat->category = category;
  95
  96         for (i=0;flds_array[i].name;i++) {
  97                 fld_data_t* f = g_malloc(sizeof(fld_data_t));
  98
  99                 f->colnum = i+1;
 100                 f->rep = NULL;
 101                 f->free_rep = NULL;
 102
 103                 flds_array[i].priv = f;
 104         }
 105
 106         uat->ncols = i;
 107
 108
 109         *data_ptr = NULL;
 110         *numitems_ptr = 0;
 111
 112         return uat;
 113 }
 114
 115 void* uat_add_record(uat_t* uat, const void* data) {
 116         void* rec;
 117
 118         g_array_append_vals (uat->user_data, data, 1);
 119
 120         rec = uat->user_data->data + (uat->record_size * (uat->user_data->len-1));
 121
 122         if (uat->copy_cb) {
 123                 uat->copy_cb(rec, data, uat->record_size);
 124         }
 125
 126         UAT_UPDATE(uat);
 127
 128         return rec;
 129 }
 130
 131 void uat_swap(uat_t* uat, guint a, guint b) {
 132         guint s = uat->record_size;
 133         void* tmp = ep_alloc(s);
 134
 135         g_assert( a < uat->user_data->len && b < uat->user_data->len );
 136
 137         if (a == b) return;
 138
 139         memcpy(tmp, UAT_INDEX_PTR(uat,a), s);
 140         memcpy(UAT_INDEX_PTR(uat,a), UAT_INDEX_PTR(uat,b), s);
 141         memcpy(UAT_INDEX_PTR(uat,b), tmp, s);
 142
 143 }
 144
 145 void uat_remove_record_idx(uat_t* uat, guint idx) {
 146
 147         g_assert( idx < uat->user_data->len );
 148
 149         if (uat->free_cb) {
 150                 uat->free_cb(UAT_INDEX_PTR(uat,idx));
 151         }
 152
 153         g_array_remove_index(uat->user_data, idx);
 154
 155         UAT_UPDATE(uat);
 156
 157 }
 158
 159 /* The returned filename was g_malloc()'d so the caller must free it */
 160 gchar* uat_get_actual_filename(uat_t* uat, gboolean for_writing) {
 161
 162         gchar* pers_fname =  get_persconffile_path(uat->filename, uat->from_profile, for_writing);
 163
 164         if (! for_writing ) {
 165                 gchar* data_fname = get_datafile_path(uat->filename);
 166
 167                 if ((! file_exists(pers_fname) ) && file_exists(data_fname)) {
 168                         g_free(pers_fname);
 169                         return data_fname;
 170                 }
 171
 172                 g_free(data_fname);
 173         }
 174
 175         if ((! file_exists(pers_fname) ) && (! for_writing ) ) {
 176                 g_free(pers_fname);
 177                 return NULL;
 178         }
 179
 180         return pers_fname;
 181 }
 182
 183 uat_t* uat_get_table_by_name(const char* name) {
 184         guint i;
 185
 186         for (i=0; i < all_uats->len; i++) {
 187                 uat_t* u = g_ptr_array_index(all_uats,i);
 188                 if ( g_str_equal(u->name,name) ) {
 189                         return (u);
 190                 }
 191         }
 192
 193         return NULL;
 194 }
 195
 196 static void putfld(FILE* fp, void* rec, uat_field_t* f) {
 197         guint fld_len;
 198         const char* fld_ptr;
 199
 200         f->cb.tostr(rec,&fld_ptr,&fld_len,f->cbdata.tostr,f->fld_data);
 201
 202         switch(f->mode){
 203                 case  PT_TXTMOD_ENUM:
 204                 case  PT_TXTMOD_STRING: {
 205                         guint i;
 206
 207                         putc('"',fp);
 208
 209                         for(i=0;i<fld_len;i++) {
 210                                 char c = fld_ptr[i];
 211
 212                                 if (c == '"' || c == '\\' || ! isprint((guchar)c) ) {
 213                                         fprintf(fp,"\\x%.2x",c);
 214                                 } else {
 215                                         putc(c,fp);
 216                                 }
 217                         }
 218
 219                         putc('"',fp);
 220                         return;
 221                 }
 222                 case PT_TXTMOD_HEXBYTES: {
 223                         guint i;
 224
 225                         for(i=0;i<fld_len;i++) {
 226                                 fprintf(fp,"%.2x",((guint8*)fld_ptr)[i]);
 227                         }
 228
 229                         return;
 230                 }
 231                 default:
 232                         g_assert_not_reached();
 233         }
 234 }
 235
 236 gboolean uat_save(uat_t* uat, char** error) {
 237         guint i;
 238         gchar* fname = uat_get_actual_filename(uat,TRUE);
 239         FILE* fp;
 240
 241         if (! fname ) return FALSE;
 242
 243         fp = ws_fopen(fname,"w");
 244
 245         if (!fp) {
 246                 *error = ep_strdup_printf("uat_save: error opening '%s': %s",fname,strerror(errno));
 247                 return FALSE;
 248         }
 249
 250         *error = NULL;
 251
 252         fprintf(fp,"# This file is automatically generated, DO NOT MODIFY.\n");
 253
 254         for ( i = 0 ; i < uat->user_data->len ; i++ ) {
 255                 void* rec = uat->user_data->data + (uat->record_size * i);
 256                 uat_field_t* f;
 257                 guint j;
 258
 259                 f = uat->fields;
 260
 261
 262                 for( j=0 ; j < uat->ncols ; j++ ) {
 263                         putfld(fp, rec, &(f[j]));
 264                         fputs((j == uat->ncols - 1) ? "\n" : "," ,fp);
 265                 }
 266
 267         }
 268
 269         fclose(fp);
 270
 271         uat->changed = FALSE;
 272
 273         return TRUE;
 274 }
 275
 276 void uat_destroy(uat_t* uat) {
 277         /* XXX still missing a destructor */
 278         g_ptr_array_remove(all_uats,uat);
 279
 280 }
 281
 282 uat_t *uat_find(gchar *name) {
 283     guint i;
 284
 285         for (i=0; i < all_uats->len; i++) {
 286                 uat_t* u = g_ptr_array_index(all_uats,i);
 287
 288         if (strcmp(u->name, name) == 0 || strcmp(u->filename, name) == 0) {
 289             return u;
 290         }
 291         }
 292     return NULL;
 293 }
 294
 295 void uat_clear(uat_t* uat) {
 296         guint i;
 297
 298         for ( i = 0 ; i < uat->user_data->len ; i++ ) {
 299                 if (uat->free_cb) {
 300                         uat->free_cb(UAT_INDEX_PTR(uat,i));
 301                 }
 302         }
 303
 304         g_array_set_size(uat->user_data,0);
 305
 306         *((uat)->user_ptr) = NULL;
 307         *((uat)->nrows_p) = 0;
 308 }
 309
 310 void* uat_dup(uat_t* uat, guint* len_p) {
 311         guint size = (uat->record_size * uat->user_data->len);
 312         *len_p = size;
 313         return size ? g_memdup(uat->user_data->data,size) : NULL ;
 314 }
 315
 316 void* uat_se_dup(uat_t* uat, guint* len_p) {
 317         guint size = (uat->record_size * uat->user_data->len);
 318         *len_p = size;
 319         return size ? se_memdup(uat->user_data->data,size) : NULL ;
 320 }
 321
 322 void uat_unload_all(void) {
 323         guint i;
 324
 325         for (i=0; i < all_uats->len; i++) {
 326                 uat_t* u = g_ptr_array_index(all_uats,i);
 327         /* Do not unload if not in profile */
 328         if (u->from_profile) {
 329             uat_clear(u);
 330             u->loaded = FALSE;
 331         }
 332         }
 333 }
 334
 335 void uat_cleanup(void) {
 336         while( all_uats->len ) {
 337                 uat_destroy((uat_t*)all_uats->pdata);
 338         }
 339
 340         g_ptr_array_free(all_uats,TRUE);
 341 }
 342
 343
 344 void uat_foreach_table(uat_cb_t cb,void* user_data) {
 345         guint i;
 346
 347         for (i=0; i < all_uats->len; i++)
 348                 cb(g_ptr_array_index(all_uats,i), user_data);
 349
 350 }
 351
 352
 353 void uat_load_all(void) {
 354         guint i;
 355         gchar* err;
 356
 357         for (i=0; i < all_uats->len; i++) {
 358                 uat_t* u = g_ptr_array_index(all_uats,i);
 359                 err = NULL;
 360
 361                 if (!u->loaded)
 362                         uat_load(u, &err);
 363
 364                 if (err) {
 365                         report_failure("Error loading table '%s': %s",u->name,err);
 366                 }
 367         }
 368 }
 369
 370
 371 gboolean uat_fld_chk_str(void* u1 _U_, const char* strptr, unsigned len _U_, void* u2 _U_, void* u3 _U_, const char** err) {
 372         if (strptr == NULL) {
 373                 *err = "NULL pointer";
 374                 return FALSE;
 375         }
 376
 377         *err = NULL;
 378         return TRUE;
 379 }
 380
 381 gboolean uat_fld_chk_proto(void* u1 _U_, const char* strptr, unsigned len, void* u2 _U_, void* u3 _U_, const char** err) {
 382         if (len) {
 383                 char* name = ep_strndup(strptr,len);
 384                 g_strdown(name);
 385                 g_strchug(name);
 386
 387                 if (find_dissector(name)) {
 388                         *err = NULL;
 389                         return TRUE;
 390                 } else {
 391                         *err = "dissector not found";
 392                         return FALSE;
 393                 }
 394         } else {
 395                 *err = NULL;
 396                 return TRUE;
 397         }
 398 }
 399
 400 gboolean uat_fld_chk_num_dec(void* u1 _U_, const char* strptr, unsigned len, void* u2 _U_, void* u3 _U_, const char** err) {
 401         char* str = ep_strndup(strptr,len);
 402         long i = strtol(str,&str,10);
 403
 404         if ( ( i == 0) && (errno == ERANGE || errno == EINVAL) ) {
 405                 *err = strerror(errno);
 406                 return FALSE;
 407         }
 408
 409         *err = NULL;
 410         return TRUE;
 411 }
 412
 413 gboolean uat_fld_chk_num_hex(void* u1 _U_, const char* strptr, unsigned len, void* u2 _U_, void* u3 _U_, const char** err) {
 414         char* str = ep_strndup(strptr,len);
 415         long i = strtol(str,&str,16);
 416
 417         if ( ( i == 0) && (errno == ERANGE || errno == EINVAL) ) {
 418                 *err = strerror(errno);
 419                 return FALSE;
 420         }
 421
 422         *err = NULL;
 423         return TRUE;
 424 }
 425
 426 gboolean uat_fld_chk_enum(void* u1 _U_, const char* strptr, unsigned len, void* v, void* u3 _U_, const char** err) {
 427         char* str = ep_strndup(strptr,len);
 428         guint i;
 429         value_string* vs = v;
 430
 431         for(i=0;vs[i].strptr;i++) {
 432                 if (g_str_equal(vs[i].strptr,str)) {
 433                         *err = NULL;
 434                         return TRUE;
 435                 }
 436         }
 437
 438         *err = ep_strdup_printf("invalid value: %s",str);
 439         return FALSE;
 440 }
 441
 442 gboolean uat_fld_chk_range(void* u1 _U_, const char* strptr, unsigned len, void* v _U_, void* u3, const char** err) {
 443         char* str = ep_strndup(strptr,len);
 444         range_t* r = NULL;
 445         convert_ret_t ret = range_convert_str(&r, str,GPOINTER_TO_UINT(u3));
 446
 447         switch (  ret ) {
 448                 case CVT_NO_ERROR:
 449                         *err = NULL;
 450                         return TRUE;
 451                 case CVT_SYNTAX_ERROR:
 452                         *err = ep_strdup_printf("syntax error in range: %s",str);
 453                         return FALSE;
 454                 case CVT_NUMBER_TOO_BIG:
 455                         *err = ep_strdup_printf("value too large in range: '%s' (max = %u)",str,GPOINTER_TO_UINT(u3));
 456                         return FALSE;
 457                 default:
 458                         *err = "This should not happen, it is a bug in wireshark! please report to wireshark-dev@wireshark.org";
 459                         return FALSE;
 460         }
 461 }
 462
 463 static int xton(char d) {
 464         switch(d) {
 465                 case '0': return 0;
 466                 case '1': return 1;
 467                 case '2': return 2;
 468                 case '3': return 3;
 469                 case '4': return 4;
 470                 case '5': return 5;
 471                 case '6': return 6;
 472                 case '7': return 7;
 473                 case '8': return 8;
 474                 case '9': return 9;
 475                 case 'a':  case 'A': return 10;
 476                 case 'b':  case 'B': return 11;
 477                 case 'c':  case 'C': return 12;
 478                 case 'd':  case 'D': return 13;
 479                 case 'e':  case 'E': return 14;
 480                 case 'f':  case 'F': return 15;
 481                 default: return -1;
 482         }
 483 }
 484
 485 char* uat_unbinstring(const char* si, guint in_len, guint* len_p) {
 486         guint8* buf;
 487         guint len = in_len/2;
 488         int i = 0;
 489         int d0, d1;
 490
 491         if (in_len%2) {
 492                 return NULL;
 493         }
 494
 495         buf= g_malloc0(len+1);
 496         if (len_p) *len_p = len;
 497
 498         while(in_len) {
 499                 d1 = xton(*(si++));
 500                 d0 = xton(*(si++));
 501
 502                 buf[i++] = (d1 * 16) + d0;
 503
 504                 in_len -= 2;
 505         }
 506
 507         return (char*)buf;
 508 }
 509
 510 char* uat_unesc(const char* si, guint in_len, guint* len_p) {
 511         char* buf = g_malloc0(in_len+1);
 512         char* p = buf;
 513         guint len = 0;
 514         const char* s;
 515         const char* in_end = si+in_len;
 516
 517         for (s = (void*)si; s < in_end; s++) {
 518                 switch(*s) {
 519                         case '\\':
 520                                 switch(*(++s)) {
 521                                         case 'a': *(p++) = '\a'; len++; break;
 522                                         case 'b': *(p++) = '\b'; len++; break;
 523                                         case 'e': *(p++) = '\033' /* '\e' is non ANSI-C */; len++; printf("."); break;
 524                                         case 'f': *(p++) = '\f'; len++; break;
 525                                         case 'n': *(p++) = '\n'; len++; break;
 526                                         case 'r': *(p++) = '\r'; len++; break;
 527                                         case 't': *(p++) = '\t'; len++; break;
 528                                         case 'v': *(p++) = '\v'; len++; break;
 529
 530                                         case '0':
 531                                         case '1':
 532                                         case '2':
 533                                         case '3':
 534                                         case '4':
 535                                         case '5':
 536                                         case '6':
 537                                         case '7':
 538                                         {
 539                                                 int c0 = 0;
 540                                                 int c1 = 0;
 541                                                 int c2 = 0;
 542                                                 int c = 0;
 543
 544                                                 c0 = (*s) - '0';
 545
 546                                                 if ( s[1] >= '0' && s[1] <= '7' ) {
 547                                                         c1 = c0;
 548                                                         c0 = (*++s) - '0';
 549
 550                                                         if ( s[1] >= '0' && s[1] <= '7' ) {
 551                                                                 c2 = c1;
 552                                                                 c1 = c0;
 553                                                                 c0 = (*++s) - '0';
 554                                                         }
 555                                                 }
 556                                                 c = (64 * c2) + (8 * c1) + c0;
 557                                                 *(p++) = (char) (c > 255 ? 255 : c);
 558                                                 len++;
 559                                                 break;
 560                                         }
 561
 562                                         case 'x':
 563                                         {
 564                                                 char c1 = *(s+1);
 565                                                 char c0 = *(s+2);
 566
 567                                                 if (isxdigit((guchar)c1) && isxdigit((guchar)c0)) {
 568                                                         *(p++) = (xton(c1) * 0x10) + xton(c0);
 569                                                         s += 2;
 570                                                 } else {
 571                                                         *(p++) = *s;
 572                                                 }
 573                                                 len++;
 574                                                 break;
 575                                         }
 576                                         default:
 577                                                 *p++ = *s;
 578                                                 break;
 579                                 }
 580                                 break;
 581                         default:
 582                                 *(p++) = *s;
 583                                 len++;
 584                                 break;
 585                 }
 586         }
 587
 588         if (len_p) *len_p = len;
 589         return buf;
 590 }
 591
 592 char* uat_undquote(const char* si, guint in_len, guint* len_p) {
 593         return uat_unesc(si+1,in_len-2,len_p);
 594 }
 595
 596
 597 char* uat_esc(const char* buf, guint len) {
 598         const guint8* end = ((guint8*)buf)+len;
 599         char* out = ep_alloc0((4*len)+1);
 600         const guint8* b;
 601         char* s = out;
 602
 603         for (b = (void*)buf; b < end; b++) {
 604                 if (isprint(*b) ) {
 605                         *(s++) = (*b);
 606                 } else {
 607                         g_snprintf(s,5,"\\x%.2x",((guint)*b));
 608                         s+=4;
 609                 }
 610         }
 611
 612         return out;
 613
 614 }
 615
 616 CHK_STR_IS_DEF(isprint)
 617 CHK_STR_IS_DEF(isalpha)
 618 CHK_STR_IS_DEF(isalnum)
 619 CHK_STR_IS_DEF(isdigit)
 620 CHK_STR_IS_DEF(isxdigit)
 621
 622 /*
 623  * Editor modelines
 624  *
 625  * Local Variables:
 626  * c-basic-offset: 4
 627  * tab-width: 4
 628  * indent-tabs-mode: nil
 629  * End:
 630  *
 631  * ex: set shiftwidth=4 tabstop=4 expandtab
 632  * :indentSize=4:tabSize=4:noTabs=true:
 633  */