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