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