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