Move (Up/Down) & Save buttons
[obnox/wireshark/wip.git] / 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                            uat_copy_cb_t copy_cb,
60                            uat_update_cb_t update_cb,
61                            uat_free_cb_t free_cb,
62                            uat_field_t* flds_array) {
63         uat_t* uat = g_malloc(sizeof(uat_t));
64         guint i;
65         
66         if (!all_uats)
67                 all_uats = g_ptr_array_new();
68         
69         g_ptr_array_add(all_uats,uat);
70         
71         g_assert(name && size && filename && data_ptr && numitems_ptr);
72         
73         uat->name = g_strdup(name);
74         uat->record_size = size;
75         uat->filename = g_strdup(filename);
76         uat->user_ptr = data_ptr;
77         uat->nrows_p = numitems_ptr;
78         uat->copy_cb = copy_cb;
79         uat->update_cb = update_cb;
80         uat->free_cb = free_cb;
81         uat->fields = flds_array;
82         uat->user_data = g_array_new(FALSE,FALSE,uat->record_size);
83         uat->changed = FALSE;
84         uat->rep = NULL;
85         uat->free_rep = NULL;
86         
87         for (i=0;flds_array[i].name;i++) {
88                 fld_data_t* f = g_malloc(sizeof(fld_data_t));
89         
90                 f->colnum = i+1;
91                 f->rep = NULL;
92                 f->free_rep = NULL;
93                 
94                 flds_array[i].priv = f;
95         }
96         
97         uat->ncols = i;
98         
99         
100         *data_ptr = NULL;
101         *numitems_ptr = 0;
102         
103         return uat;
104 }
105
106 void* uat_add_record(uat_t* uat, const void* data) {
107         void* rec;
108
109         g_array_append_vals (uat->user_data, data, 1);
110         
111         rec = uat->user_data->data + (uat->record_size * (uat->user_data->len-1));
112         
113         if (uat->copy_cb) {
114                 uat->copy_cb(rec, data, uat->record_size);
115         }
116         
117         UAT_UPDATE(uat);
118         
119         return rec;
120 }
121
122 void uat_swap(uat_t* uat, guint a, guint b) {
123         guint s = uat->record_size;
124         void* tmp = ep_alloc(s);
125         
126         g_assert( a < uat->user_data->len && b < uat->user_data->len );
127
128         if (a == b) return;
129
130         memcpy(tmp, UAT_INDEX_PTR(uat,a), s);
131         memcpy(UAT_INDEX_PTR(uat,a), UAT_INDEX_PTR(uat,b), s);
132         memcpy(UAT_INDEX_PTR(uat,b), tmp, s);
133
134 }
135
136 void uat_remove_record_idx(uat_t* uat, guint idx) {
137         
138         g_assert( idx < uat->user_data->len );
139
140         if (uat->free_cb) {
141                 uat->free_cb(UAT_INDEX_PTR(uat,idx));
142         }
143         
144         g_array_remove_index(uat->user_data, idx);
145         
146         UAT_UPDATE(uat);
147
148 }
149
150 gchar* uat_get_actual_filename(uat_t* uat, gboolean for_writing) {
151         gchar* pers_fname =  get_persconffile_path(uat->filename,for_writing);
152
153         if (! for_writing ) {
154                 gchar* data_fname = get_datafile_path(uat->filename);
155                 
156                 if (file_exists(data_fname)) {
157                         return data_fname;
158                 }
159         }
160         
161         if ((! file_exists(pers_fname) ) && (! for_writing ) ) {
162                 return NULL;
163         }
164         
165         return pers_fname;
166 }
167
168 static void putfld(FILE* fp, void* rec, uat_field_t* f) {
169         guint fld_len;
170         char* fld_ptr;
171         
172         f->cb.tostr(rec,&fld_ptr,&fld_len,f->cbdata.tostr,f->fld_data);
173         
174         switch(f->mode){
175                 case  PT_TXTMOD_STRING: {
176                         guint i;
177                         
178                         putc('"',fp);
179                         
180                         for(i=0;i<fld_len;i++) {
181                                 char c = fld_ptr[i];
182                                 
183                                 if (c == '"' || c == '\\' || ! isprint(c) ) {
184                                         fprintf(fp,"\\x%.2x",c);
185                                 } else {
186                                         putc(c,fp);
187                                 }
188                         }
189                         
190                         putc('"',fp);
191                         return;
192                 }
193                 case PT_TXTMOD_HEXBYTES: {
194                         guint i;
195                         
196                         for(i=0;i<fld_len;i++) {
197                                 fprintf(fp,"%.2x",fld_ptr[i]);
198                         }
199                         
200                         return;
201                 }
202                 default:
203                         g_assert_not_reached();
204         }
205 }
206
207 gboolean uat_save(uat_t* uat, char** error) {
208         guint i;
209         gchar* fname = uat_get_actual_filename(uat,TRUE);
210         FILE* fp;
211         
212         if (! fname ) return FALSE;
213
214         fp = fopen(fname,"w");
215         
216         if (!fp) {
217                 *error = ep_strdup_printf("uat_save: error opening '%s': %s",fname,strerror(errno));
218                 return FALSE;
219         }
220
221         *error = NULL;
222
223         fprintf(fp,"# This file is automatically generated, DO NOT MODIFY.\n");
224         
225         for ( i = 0 ; i < uat->user_data->len ; i++ ) {
226                 void* rec = uat->user_data->data + (uat->record_size * i);
227                 uat_field_t* f;
228                 guint j;
229
230                 f = uat->fields;
231                 
232                         
233                 for( j=0 ; j < uat->ncols ; j++ ) {
234                         putfld(fp, rec, &(f[j]));
235                         fputs((j == uat->ncols - 1) ? "\n" : "," ,fp);
236                 }
237
238         }
239
240         fclose(fp);
241         
242         uat->changed = FALSE;
243         
244         return TRUE;
245 }
246
247 void uat_destroy(uat_t* uat) {
248         /* XXX still missing a destructor */
249         g_ptr_array_remove(all_uats,uat);
250         
251 }
252
253 void* uat_dup(uat_t* uat, guint* len_p) {
254         guint size = (uat->record_size * uat->user_data->len);
255         *len_p = size;
256         return size ? g_memdup(uat->user_data->data,size) : NULL ;
257 }
258
259 void* uat_se_dup(uat_t* uat, guint* len_p) {
260         guint size = (uat->record_size * uat->user_data->len);
261         *len_p = size;
262         return size ? se_memdup(uat->user_data->data,size) : NULL ;
263 }
264
265 void uat_cleanup(void) {
266         while( all_uats->len ) {
267                 uat_destroy((uat_t*)all_uats->pdata);
268         }
269
270         g_ptr_array_free(all_uats,TRUE);
271 }
272
273 void uat_load_all(void) {
274         guint i;
275         gchar* err;
276         
277         for (i=0; i < all_uats->len; i++) {
278                 uat_t* u = g_ptr_array_index(all_uats,i);
279                 err = NULL;
280                 
281                 uat_load(u, &err);
282                 
283                 if (err) {
284                         report_failure("Error loading table '%s': %s",u->name,err);
285                 }
286         }
287 }
288
289 gboolean uat_fld_chk_str(void* u1 _U_, const char* strptr, unsigned len _U_, void* u2 _U_, void* u3 _U_, char** err) {
290         if (strptr == NULL) {
291                 *err = "NULL pointer";
292                 return FALSE;
293         }
294         
295         *err = NULL;
296         return TRUE;
297 }
298
299 gboolean uat_fld_chk_proto(void* u1 _U_, const char* strptr, unsigned len, void* u2 _U_, void* u3 _U_, char** err) {
300         char* name = ep_strndup(strptr,len);
301         g_strdown(name);
302         g_strchug(name);
303         if (find_dissector(name)) {
304                 *err = NULL;
305                 return TRUE;
306         } else {
307                 *err = "dissector not found";
308                 return FALSE;
309         }
310 }
311
312 gboolean uat_fld_chk_num_dec(void* u1 _U_, const char* strptr, unsigned len, void* u2 _U_, void* u3 _U_, char** err) {
313         char* str = ep_strndup(strptr,len);
314         long i = strtol(str,&str,10);
315         
316         if ( ( i == 0) && (errno == ERANGE || errno == EINVAL) ) {
317                 *err = strerror(errno);
318                 return FALSE;
319         }
320         
321         *err = NULL;
322         return TRUE;
323 }
324
325 gboolean uat_fld_chk_num_hex(void* u1 _U_, const char* strptr, unsigned len, void* u2 _U_, void* u3 _U_, char** err) {
326         char* str = ep_strndup(strptr,len);
327         long i = strtol(str,&str,16);
328         
329         if ( ( i == 0) && (errno == ERANGE || errno == EINVAL) ) {
330                 *err = strerror(errno);
331                 return FALSE;
332         }
333         
334         *err = NULL;
335         return TRUE;
336 }
337
338 CHK_STR_IS_DEF(isprint)
339 CHK_STR_IS_DEF(isalpha)
340 CHK_STR_IS_DEF(isalnum)
341 CHK_STR_IS_DEF(isdigit)
342 CHK_STR_IS_DEF(isxdigit)
343