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