2007-01-28 10:31:32 +00:00
|
|
|
/*
|
|
|
|
* uat.c
|
|
|
|
*
|
2007-01-29 04:47:58 +00:00
|
|
|
* $Id$
|
|
|
|
*
|
2007-01-28 10:31:32 +00:00
|
|
|
* User Accessible Tables
|
|
|
|
* Mantain an array of user accessible data strucures
|
|
|
|
*
|
2007-01-29 04:47:58 +00:00
|
|
|
* (c) 2007, Luis E. Garcia Ontanon <luis.ontanon@gmail.com>
|
|
|
|
*
|
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
|
|
|
* Copyright 2001 Gerald Combs
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
2007-01-28 10:31:32 +00:00
|
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <stdarg.h>
|
|
|
|
|
|
|
|
#include <glib.h>
|
|
|
|
#include <epan/emem.h>
|
2007-02-03 14:25:02 +00:00
|
|
|
#include <epan/report_err.h>
|
2007-01-28 10:31:32 +00:00
|
|
|
#include <epan/filesystem.h>
|
2007-02-03 14:25:02 +00:00
|
|
|
#include <epan/packet.h>
|
2007-01-28 10:31:32 +00:00
|
|
|
|
|
|
|
#include "uat-int.h"
|
|
|
|
|
|
|
|
static GPtrArray* all_uats = NULL;
|
|
|
|
|
|
|
|
void uat_init(void) {
|
|
|
|
all_uats = g_ptr_array_new();
|
|
|
|
}
|
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
uat_t* uat_new(const char* name,
|
|
|
|
size_t size,
|
|
|
|
char* filename,
|
|
|
|
void** data_ptr,
|
|
|
|
guint* numitems_ptr,
|
2007-02-07 14:54:35 +00:00
|
|
|
char* category,
|
2007-02-05 05:06:21 +00:00
|
|
|
char* help,
|
2007-02-03 14:25:02 +00:00
|
|
|
uat_copy_cb_t copy_cb,
|
|
|
|
uat_update_cb_t update_cb,
|
|
|
|
uat_free_cb_t free_cb,
|
|
|
|
uat_field_t* flds_array) {
|
2007-01-28 10:31:32 +00:00
|
|
|
uat_t* uat = g_malloc(sizeof(uat_t));
|
2007-02-03 14:25:02 +00:00
|
|
|
guint i;
|
|
|
|
|
2007-01-29 10:23:38 +00:00
|
|
|
if (!all_uats)
|
|
|
|
all_uats = g_ptr_array_new();
|
|
|
|
|
2007-01-28 10:31:32 +00:00
|
|
|
g_ptr_array_add(all_uats,uat);
|
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
g_assert(name && size && filename && data_ptr && numitems_ptr);
|
2007-01-28 10:31:32 +00:00
|
|
|
|
|
|
|
uat->name = g_strdup(name);
|
|
|
|
uat->record_size = size;
|
|
|
|
uat->filename = g_strdup(filename);
|
|
|
|
uat->user_ptr = data_ptr;
|
2007-02-03 14:25:02 +00:00
|
|
|
uat->nrows_p = numitems_ptr;
|
2007-01-28 10:31:32 +00:00
|
|
|
uat->copy_cb = copy_cb;
|
|
|
|
uat->update_cb = update_cb;
|
|
|
|
uat->free_cb = free_cb;
|
2007-02-03 14:25:02 +00:00
|
|
|
uat->fields = flds_array;
|
2007-01-28 10:31:32 +00:00
|
|
|
uat->user_data = g_array_new(FALSE,FALSE,uat->record_size);
|
2007-02-04 05:19:02 +00:00
|
|
|
uat->changed = FALSE;
|
2007-01-28 10:31:32 +00:00
|
|
|
uat->rep = NULL;
|
|
|
|
uat->free_rep = NULL;
|
2007-02-05 05:06:21 +00:00
|
|
|
uat->help = help;
|
2007-02-07 14:54:35 +00:00
|
|
|
uat->category = category;
|
2007-01-28 10:31:32 +00:00
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
for (i=0;flds_array[i].name;i++) {
|
|
|
|
fld_data_t* f = g_malloc(sizeof(fld_data_t));
|
2007-01-28 10:31:32 +00:00
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
f->colnum = i+1;
|
|
|
|
f->rep = NULL;
|
|
|
|
f->free_rep = NULL;
|
2007-01-28 10:31:32 +00:00
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
flds_array[i].priv = f;
|
|
|
|
}
|
2007-01-28 10:31:32 +00:00
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
uat->ncols = i;
|
2007-01-28 10:31:32 +00:00
|
|
|
|
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
*data_ptr = NULL;
|
|
|
|
*numitems_ptr = 0;
|
2007-01-29 04:47:58 +00:00
|
|
|
|
2007-01-28 10:31:32 +00:00
|
|
|
return uat;
|
|
|
|
}
|
|
|
|
|
|
|
|
void* uat_add_record(uat_t* uat, const void* data) {
|
|
|
|
void* rec;
|
2007-02-03 14:25:02 +00:00
|
|
|
|
2007-01-28 10:31:32 +00:00
|
|
|
g_array_append_vals (uat->user_data, data, 1);
|
|
|
|
|
|
|
|
rec = uat->user_data->data + (uat->record_size * (uat->user_data->len-1));
|
|
|
|
|
|
|
|
if (uat->copy_cb) {
|
|
|
|
uat->copy_cb(rec, data, uat->record_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
UAT_UPDATE(uat);
|
|
|
|
|
|
|
|
return rec;
|
|
|
|
}
|
|
|
|
|
2007-02-04 05:19:02 +00:00
|
|
|
void uat_swap(uat_t* uat, guint a, guint b) {
|
|
|
|
guint s = uat->record_size;
|
|
|
|
void* tmp = ep_alloc(s);
|
|
|
|
|
|
|
|
g_assert( a < uat->user_data->len && b < uat->user_data->len );
|
|
|
|
|
|
|
|
if (a == b) return;
|
|
|
|
|
|
|
|
memcpy(tmp, UAT_INDEX_PTR(uat,a), s);
|
|
|
|
memcpy(UAT_INDEX_PTR(uat,a), UAT_INDEX_PTR(uat,b), s);
|
|
|
|
memcpy(UAT_INDEX_PTR(uat,b), tmp, s);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2007-01-28 10:31:32 +00:00
|
|
|
void uat_remove_record_idx(uat_t* uat, guint idx) {
|
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
g_assert( idx < uat->user_data->len );
|
2007-01-28 10:31:32 +00:00
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
if (uat->free_cb) {
|
|
|
|
uat->free_cb(UAT_INDEX_PTR(uat,idx));
|
|
|
|
}
|
|
|
|
|
2007-01-28 10:31:32 +00:00
|
|
|
g_array_remove_index(uat->user_data, idx);
|
|
|
|
|
|
|
|
UAT_UPDATE(uat);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
gchar* uat_get_actual_filename(uat_t* uat, gboolean for_writing) {
|
|
|
|
gchar* pers_fname = get_persconffile_path(uat->filename,for_writing);
|
2007-02-03 14:25:02 +00:00
|
|
|
|
|
|
|
if (! for_writing ) {
|
2007-01-28 10:31:32 +00:00
|
|
|
gchar* data_fname = get_datafile_path(uat->filename);
|
|
|
|
|
|
|
|
if (file_exists(data_fname)) {
|
|
|
|
return data_fname;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
if ((! file_exists(pers_fname) ) && (! for_writing ) ) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-01-28 10:31:32 +00:00
|
|
|
return pers_fname;
|
|
|
|
}
|
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
static void putfld(FILE* fp, void* rec, uat_field_t* f) {
|
2007-01-28 10:31:32 +00:00
|
|
|
guint fld_len;
|
|
|
|
char* fld_ptr;
|
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
f->cb.tostr(rec,&fld_ptr,&fld_len,f->cbdata.tostr,f->fld_data);
|
2007-01-28 10:31:32 +00:00
|
|
|
|
|
|
|
switch(f->mode){
|
2007-02-07 03:39:40 +00:00
|
|
|
case PT_TXTMOD_ENUM:
|
2007-01-28 10:31:32 +00:00
|
|
|
case PT_TXTMOD_STRING: {
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
putc('"',fp);
|
|
|
|
|
|
|
|
for(i=0;i<fld_len;i++) {
|
|
|
|
char c = fld_ptr[i];
|
|
|
|
|
2007-02-04 02:29:06 +00:00
|
|
|
if (c == '"' || c == '\\' || ! isprint(c) ) {
|
2007-01-28 10:31:32 +00:00
|
|
|
fprintf(fp,"\\x%.2x",c);
|
2007-02-04 02:29:06 +00:00
|
|
|
} else {
|
|
|
|
putc(c,fp);
|
2007-01-28 10:31:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
putc('"',fp);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case PT_TXTMOD_HEXBYTES: {
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
for(i=0;i<fld_len;i++) {
|
2007-02-07 03:39:40 +00:00
|
|
|
fprintf(fp,"%.2x",((guint8*)fld_ptr)[i]);
|
2007-01-28 10:31:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean uat_save(uat_t* uat, char** error) {
|
|
|
|
guint i;
|
|
|
|
gchar* fname = uat_get_actual_filename(uat,TRUE);
|
2007-02-03 14:25:02 +00:00
|
|
|
FILE* fp;
|
2007-01-28 10:31:32 +00:00
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
if (! fname ) return FALSE;
|
2007-01-28 10:31:32 +00:00
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
fp = fopen(fname,"w");
|
|
|
|
|
2007-01-28 10:31:32 +00:00
|
|
|
if (!fp) {
|
|
|
|
*error = ep_strdup_printf("uat_save: error opening '%s': %s",fname,strerror(errno));
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
*error = NULL;
|
|
|
|
|
2007-02-04 02:29:06 +00:00
|
|
|
fprintf(fp,"# This file is automatically generated, DO NOT MODIFY.\n");
|
|
|
|
|
2007-01-29 14:11:44 +00:00
|
|
|
for ( i = 0 ; i < uat->user_data->len ; i++ ) {
|
|
|
|
void* rec = uat->user_data->data + (uat->record_size * i);
|
2007-02-03 14:25:02 +00:00
|
|
|
uat_field_t* f;
|
|
|
|
guint j;
|
|
|
|
|
2007-01-28 10:31:32 +00:00
|
|
|
f = uat->fields;
|
|
|
|
|
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
for( j=0 ; j < uat->ncols ; j++ ) {
|
|
|
|
putfld(fp, rec, &(f[j]));
|
|
|
|
fputs((j == uat->ncols - 1) ? "\n" : "," ,fp);
|
2007-01-28 10:31:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
fclose(fp);
|
|
|
|
|
2007-02-04 05:19:02 +00:00
|
|
|
uat->changed = FALSE;
|
|
|
|
|
2007-01-28 10:31:32 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void uat_destroy(uat_t* uat) {
|
2007-02-03 14:25:02 +00:00
|
|
|
/* XXX still missing a destructor */
|
2007-01-28 10:31:32 +00:00
|
|
|
g_ptr_array_remove(all_uats,uat);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2007-02-11 16:09:21 +00:00
|
|
|
void uat_clear(uat_t* uat) {
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
for ( i = 0 ; i < uat->user_data->len ; i++ ) {
|
|
|
|
if (uat->free_cb) {
|
|
|
|
uat->free_cb(UAT_INDEX_PTR(uat,i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
g_array_set_size(uat->user_data,0);
|
|
|
|
|
|
|
|
*((uat)->user_ptr) = NULL;
|
|
|
|
*((uat)->nrows_p) = 0;
|
|
|
|
}
|
|
|
|
|
2007-01-28 10:31:32 +00:00
|
|
|
void* uat_dup(uat_t* uat, guint* len_p) {
|
|
|
|
guint size = (uat->record_size * uat->user_data->len);
|
|
|
|
*len_p = size;
|
|
|
|
return size ? g_memdup(uat->user_data->data,size) : NULL ;
|
|
|
|
}
|
|
|
|
|
|
|
|
void* uat_se_dup(uat_t* uat, guint* len_p) {
|
|
|
|
guint size = (uat->record_size * uat->user_data->len);
|
|
|
|
*len_p = size;
|
|
|
|
return size ? se_memdup(uat->user_data->data,size) : NULL ;
|
|
|
|
}
|
|
|
|
|
|
|
|
void uat_cleanup(void) {
|
|
|
|
while( all_uats->len ) {
|
|
|
|
uat_destroy((uat_t*)all_uats->pdata);
|
|
|
|
}
|
|
|
|
|
|
|
|
g_ptr_array_free(all_uats,TRUE);
|
|
|
|
}
|
|
|
|
|
2007-02-08 10:15:04 +00:00
|
|
|
|
|
|
|
void uat_foreach_table(uat_cb_t cb,void* user_data) {
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
for (i=0; i < all_uats->len; i++)
|
|
|
|
cb(g_ptr_array_index(all_uats,i), user_data);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
void uat_load_all(void) {
|
|
|
|
guint i;
|
|
|
|
gchar* err;
|
|
|
|
|
|
|
|
for (i=0; i < all_uats->len; i++) {
|
|
|
|
uat_t* u = g_ptr_array_index(all_uats,i);
|
|
|
|
err = NULL;
|
|
|
|
|
|
|
|
uat_load(u, &err);
|
|
|
|
|
|
|
|
if (err) {
|
|
|
|
report_failure("Error loading table '%s': %s",u->name,err);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-08 10:15:04 +00:00
|
|
|
|
2007-02-03 14:25:02 +00:00
|
|
|
gboolean uat_fld_chk_str(void* u1 _U_, const char* strptr, unsigned len _U_, void* u2 _U_, void* u3 _U_, char** err) {
|
|
|
|
if (strptr == NULL) {
|
|
|
|
*err = "NULL pointer";
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
*err = NULL;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean uat_fld_chk_proto(void* u1 _U_, const char* strptr, unsigned len, void* u2 _U_, void* u3 _U_, char** err) {
|
2007-02-07 20:45:14 +00:00
|
|
|
if (len) {
|
|
|
|
char* name = ep_strndup(strptr,len);
|
|
|
|
g_strdown(name);
|
|
|
|
g_strchug(name);
|
|
|
|
|
|
|
|
if (find_dissector(name)) {
|
|
|
|
*err = NULL;
|
|
|
|
return TRUE;
|
|
|
|
} else {
|
|
|
|
*err = "dissector not found";
|
|
|
|
return FALSE;
|
|
|
|
}
|
2007-02-03 14:25:02 +00:00
|
|
|
} else {
|
2007-02-07 20:45:14 +00:00
|
|
|
*err = NULL;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean uat_fld_chk_num_dec(void* u1 _U_, const char* strptr, unsigned len, void* u2 _U_, void* u3 _U_, char** err) {
|
|
|
|
char* str = ep_strndup(strptr,len);
|
|
|
|
long i = strtol(str,&str,10);
|
|
|
|
|
|
|
|
if ( ( i == 0) && (errno == ERANGE || errno == EINVAL) ) {
|
|
|
|
*err = strerror(errno);
|
2007-02-03 14:25:02 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2007-02-07 20:45:14 +00:00
|
|
|
|
|
|
|
*err = NULL;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean uat_fld_chk_num_hex(void* u1 _U_, const char* strptr, unsigned len, void* u2 _U_, void* u3 _U_, char** err) {
|
|
|
|
char* str = ep_strndup(strptr,len);
|
|
|
|
long i = strtol(str,&str,16);
|
|
|
|
|
|
|
|
if ( ( i == 0) && (errno == ERANGE || errno == EINVAL) ) {
|
|
|
|
*err = strerror(errno);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
*err = NULL;
|
|
|
|
return TRUE;
|
2007-02-03 14:25:02 +00:00
|
|
|
}
|
|
|
|
|
2007-02-07 03:39:40 +00:00
|
|
|
gboolean uat_fld_chk_enum(void* u1 _U_, const char* strptr, unsigned len, void* v, void* u3 _U_, char** err) {
|
2007-02-03 14:25:02 +00:00
|
|
|
char* str = ep_strndup(strptr,len);
|
2007-02-07 03:39:40 +00:00
|
|
|
guint i;
|
|
|
|
value_string* vs = v;
|
2007-02-03 14:25:02 +00:00
|
|
|
|
2007-02-07 03:39:40 +00:00
|
|
|
for(i=0;vs[i].strptr;i++) {
|
|
|
|
if (g_str_equal(vs[i].strptr,str)) {
|
|
|
|
*err = NULL;
|
|
|
|
return TRUE;
|
|
|
|
}
|
2007-02-03 14:25:02 +00:00
|
|
|
}
|
|
|
|
|
2007-02-07 03:39:40 +00:00
|
|
|
*err = ep_strdup_printf("invalid value: %s",str);
|
|
|
|
return FALSE;
|
2007-02-03 14:25:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
CHK_STR_IS_DEF(isprint)
|
|
|
|
CHK_STR_IS_DEF(isalpha)
|
|
|
|
CHK_STR_IS_DEF(isalnum)
|
|
|
|
CHK_STR_IS_DEF(isdigit)
|
|
|
|
CHK_STR_IS_DEF(isxdigit)
|
|
|
|
|