Store pointers to previously displayed and captured packet, not nstime_t deltas.
[metze/wireshark/wip.git] / epan / column-utils.c
1 /* column-utils.c
2  * Routines for column utilities.
3  *
4  * $Id$
5  *
6  * Wireshark - Network traffic analyzer
7  * By Gerald Combs <gerald@wireshark.org>
8  * Copyright 1998 Gerald Combs
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23  */
24
25 #include "config.h"
26
27 #include <string.h>
28 #include <time.h>
29
30 #include "column-utils.h"
31 #include "timestamp.h"
32 #include "sna-utils.h"
33 #include "atalk-utils.h"
34 #include "to_str.h"
35 #include "packet_info.h"
36 #include "pint.h"
37 #include "addr_resolv.h"
38 #include "ipv6-utils.h"
39 #include "osi-utils.h"
40 #include "value_string.h"
41 #include "column_info.h"
42
43 #include <epan/strutil.h>
44 #include <epan/epan.h>
45
46 /* Allocate all the data structures for constructing column data, given
47    the number of columns. */
48 void
49 col_setup(column_info *cinfo, const gint num_cols)
50 {
51   int i;
52
53   cinfo->num_cols   = num_cols;
54   cinfo->col_fmt    = g_new(gint, num_cols);
55   cinfo->fmt_matx   = g_new(gboolean*, num_cols);
56   cinfo->col_first  = g_new(int, NUM_COL_FMTS);
57   cinfo->col_last   = g_new(int, NUM_COL_FMTS);
58   cinfo->col_title  = g_new(gchar*, num_cols);
59   cinfo->col_custom_field = g_new(gchar*, num_cols);
60   cinfo->col_custom_occurrence = g_new(gint, num_cols);
61   cinfo->col_custom_field_id = g_new(int, num_cols);
62   cinfo->col_custom_dfilter = g_new(dfilter_t*, num_cols);
63   cinfo->col_data   = (const gchar **)g_new(gchar*, num_cols);
64   cinfo->col_buf    = g_new(gchar*, num_cols);
65   cinfo->col_fence  = g_new(int, num_cols);
66   cinfo->col_expr.col_expr = (const gchar **) g_new(gchar*, num_cols + 1);
67   cinfo->col_expr.col_expr_val = g_new(gchar*, num_cols + 1);
68
69   for (i = 0; i < NUM_COL_FMTS; i++) {
70     cinfo->col_first[i] = -1;
71     cinfo->col_last[i] = -1;
72   }
73 }
74
75 /* Initialize the data structures for constructing column data. */
76 void
77 col_init(column_info *cinfo)
78 {
79   int i;
80
81   if (!cinfo)
82     return;
83
84   for (i = 0; i < cinfo->num_cols; i++) {
85     cinfo->col_buf[i][0] = '\0';
86     cinfo->col_data[i] = cinfo->col_buf[i];
87     cinfo->col_fence[i] = 0;
88     cinfo->col_expr.col_expr[i] = "";
89     cinfo->col_expr.col_expr_val[i][0] = '\0';
90   }
91   cinfo->writable = TRUE;
92 }
93
94 #define COL_GET_WRITABLE(cinfo) (cinfo ? cinfo->writable : FALSE)
95
96 gboolean
97 col_get_writable(column_info *cinfo)
98 {
99     return COL_GET_WRITABLE(cinfo);
100 }
101
102 void
103 col_set_writable(column_info *cinfo, const gboolean writable)
104 {
105     if (cinfo)
106         cinfo->writable = writable;
107 }
108
109 /* Checks to see if a particular packet information element is needed for the packet list */
110 #define CHECK_COL(cinfo, el) \
111     /* We are constructing columns, and they're writable */ \
112     (COL_GET_WRITABLE(cinfo) && \
113       /* There is at least one column in that format */ \
114     ((cinfo)->col_first[el] >= 0))
115
116 gint
117 check_col(column_info *cinfo, const gint el)
118 {
119   return CHECK_COL(cinfo, el);
120 }
121
122 /* Sets the fence for a column to be at the end of the column. */
123 void
124 col_set_fence(column_info *cinfo, const gint el)
125 {
126   int i;
127
128   if (!CHECK_COL(cinfo, el))
129     return;
130
131   for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
132     if (cinfo->fmt_matx[i][el]) {
133       cinfo->col_fence[i] = (int)strlen(cinfo->col_data[i]);
134     }
135   }
136 }
137
138 /* Use this to clear out a column, especially if you're going to be
139    appending to it later; at least on some platforms, it's more
140    efficient than using "col_add_str()" with a null string, and
141    more efficient than "col_set_str()" with a null string if you
142    later append to it, as the later append will cause a string
143    copy to be done. */
144 void
145 col_clear(column_info *cinfo, const gint el)
146 {
147   int    i;
148   int    fence;
149
150   if (!CHECK_COL(cinfo, el))
151     return;
152
153   for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
154     if (cinfo->fmt_matx[i][el]) {
155       /*
156        * At this point, either
157        *
158        *   1) col_data[i] is equal to col_buf[i], in which case we
159        *      don't have to worry about copying col_data[i] to
160        *      col_buf[i];
161        *
162        *   2) col_data[i] isn't equal to col_buf[i], in which case
163        *      the only thing that's been done to the column is
164        *      "col_set_str()" calls and possibly "col_set_fence()"
165        *      calls, in which case the fence is either unset and
166        *      at the beginning of the string or set and at the end
167        *      of the string - if it's at the beginning, we're just
168        *      going to clear the column, and if it's at the end,
169        *      we don't do anything.
170        */
171       fence = cinfo->col_fence[i];
172       if (cinfo->col_buf[i] == cinfo->col_data[i] || fence == 0) {
173         /*
174          * The fence isn't at the end of the column, or the column wasn't
175          * last set with "col_set_str()", so clear the column out.
176          */
177         cinfo->col_buf[i][fence] = '\0';
178         cinfo->col_data[i] = cinfo->col_buf[i];
179       }
180       cinfo->col_expr.col_expr[i] = "";
181       cinfo->col_expr.col_expr_val[i][0] = '\0';
182     }
183   }
184 }
185
186 #define COL_CHECK_APPEND(cinfo, i, max_len) \
187   if (cinfo->col_data[i] != cinfo->col_buf[i]) {        \
188     /* This was set with "col_set_str()"; copy the string they  \
189        set it to into the buffer, so we can append to it. */    \
190     g_strlcpy(cinfo->col_buf[i], cinfo->col_data[i], max_len);  \
191     cinfo->col_data[i] = cinfo->col_buf[i];         \
192   }
193
194 #define COL_CHECK_REF_TIME(fd, buf)         \
195   if(fd->flags.ref_time){                   \
196     g_strlcpy(buf, "*REF*", COL_MAX_LEN );  \
197     return;                                 \
198   }
199
200 /* The same as CHECK_COL(), but without the check to see if the column is writable. */
201 #define HAVE_CUSTOM_COLS(cinfo) ((cinfo) && (cinfo)->col_first[COL_CUSTOM] >= 0)
202
203 gboolean
204 have_custom_cols(column_info *cinfo)
205 {
206   return HAVE_CUSTOM_COLS(cinfo);
207 }
208
209 /* search in edt tree custom fields */
210 void col_custom_set_edt(epan_dissect_t *edt, column_info *cinfo)
211 {
212   int i;
213
214   if(!HAVE_CUSTOM_COLS(cinfo))
215       return;
216
217   for (i = cinfo->col_first[COL_CUSTOM];
218        i <= cinfo->col_last[COL_CUSTOM]; i++) {
219     if (cinfo->fmt_matx[i][COL_CUSTOM] &&
220         cinfo->col_custom_field[i] &&
221         cinfo->col_custom_field_id[i] != -1) {
222        cinfo->col_data[i] = cinfo->col_buf[i];
223        cinfo->col_expr.col_expr[i] = epan_custom_set(edt, cinfo->col_custom_field_id[i],
224                                      cinfo->col_custom_occurrence[i],
225                                      cinfo->col_buf[i],
226                                      cinfo->col_expr.col_expr_val[i],
227                                      COL_MAX_LEN);
228     }
229   }
230 }
231
232 void
233 col_custom_prime_edt(epan_dissect_t *edt, column_info *cinfo)
234 {
235   int i;
236
237   if(!HAVE_CUSTOM_COLS(cinfo))
238       return;
239
240   for (i = cinfo->col_first[COL_CUSTOM];
241        i <= cinfo->col_last[COL_CUSTOM]; i++) {
242
243     cinfo->col_custom_field_id[i] = -1;
244     if (cinfo->fmt_matx[i][COL_CUSTOM] &&
245         cinfo->col_custom_dfilter[i]){
246         epan_dissect_prime_dfilter(edt, cinfo->col_custom_dfilter[i]);
247         if (cinfo->col_custom_field) {
248             header_field_info* hfinfo = proto_registrar_get_byname(cinfo->col_custom_field[i]);
249             cinfo->col_custom_field_id[i] = hfinfo ? hfinfo->id : -1;
250         }
251     }
252   }
253 }
254
255 /*  Appends a vararg list to a packet info string.
256  *  This function's code is duplicated in col_append_sep_fstr() below because
257  *  the for() loop below requires us to call va_start/va_end so intermediate
258  *  functions are a problem.
259  */
260 void
261 col_append_fstr(column_info *cinfo, const gint el, const gchar *format, ...)
262 {
263   int  i;
264   int  len, max_len;
265   va_list ap;
266
267   if (!CHECK_COL(cinfo, el))
268     return;
269
270   if (el == COL_INFO)
271     max_len = COL_MAX_INFO_LEN;
272   else
273     max_len = COL_MAX_LEN;
274
275   for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
276     if (cinfo->fmt_matx[i][el]) {
277       /*
278        * First arrange that we can append, if necessary.
279        */
280       COL_CHECK_APPEND(cinfo, i, max_len);
281
282       len = (int) strlen(cinfo->col_buf[i]);
283
284       va_start(ap, format);
285       g_vsnprintf(&cinfo->col_buf[i][len], max_len - len, format, ap);
286       va_end(ap);
287     }
288   }
289
290 }
291
292 /*  Appends a vararg list to a packet info string.
293  *  Prefixes it with the given separator if the column is not empty.
294  *  Code is duplicated from col_append_fstr above().
295  */
296 void
297 col_append_sep_fstr(column_info *cinfo, const gint el, const gchar *separator,
298                     const gchar *format, ...)
299 {
300   int  i;
301   int  len, max_len, sep_len;
302   va_list ap;
303
304   if (!CHECK_COL(cinfo, el))
305     return;
306
307   if (separator == NULL)
308     separator = ", ";    /* default */
309
310   sep_len = (int) strlen(separator);
311
312   if (el == COL_INFO)
313     max_len = COL_MAX_INFO_LEN;
314   else
315     max_len = COL_MAX_LEN;
316
317   for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
318     if (cinfo->fmt_matx[i][el]) {
319       /*
320        * First arrange that we can append, if necessary.
321        */
322       COL_CHECK_APPEND(cinfo, i, max_len);
323
324       len = (int) strlen(cinfo->col_buf[i]);
325
326       /*
327        * If we have a separator, append it if the column isn't empty.
328        */
329       if (sep_len != 0) {
330         if (len != 0) {
331           g_strlcat(cinfo->col_buf[i], separator, max_len);
332           len += sep_len;
333         }
334       }
335       va_start(ap, format);
336       g_vsnprintf(&cinfo->col_buf[i][len], max_len - len, format, ap);
337       va_end(ap);
338     }
339   }
340 }
341
342 /* Prepends a vararg list to a packet info string. */
343 #define COL_BUF_MAX_LEN (((COL_MAX_INFO_LEN) > (COL_MAX_LEN)) ? \
344     (COL_MAX_INFO_LEN) : (COL_MAX_LEN))
345 void
346 col_prepend_fstr(column_info *cinfo, const gint el, const gchar *format, ...)
347 {
348   va_list     ap;
349   int         i;
350   char        orig_buf[COL_BUF_MAX_LEN];
351   const char *orig;
352   int         max_len;
353
354   if (!CHECK_COL(cinfo, el))
355     return;
356
357   if (el == COL_INFO)
358     max_len = COL_MAX_INFO_LEN;
359   else
360     max_len = COL_MAX_LEN;
361
362   for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
363     if (cinfo->fmt_matx[i][el]) {
364       if (cinfo->col_data[i] != cinfo->col_buf[i]) {
365         /* This was set with "col_set_str()"; which is effectively const */
366         orig = cinfo->col_data[i];
367       } else {
368         g_strlcpy(orig_buf, cinfo->col_buf[i], max_len);
369         orig = orig_buf;
370       }
371       va_start(ap, format);
372       g_vsnprintf(cinfo->col_buf[i], max_len, format, ap);
373       va_end(ap);
374
375       /*
376        * Move the fence, unless it's at the beginning of the string.
377        */
378       if (cinfo->col_fence[i] > 0)
379         cinfo->col_fence[i] += (int) strlen(cinfo->col_buf[i]);
380
381       g_strlcat(cinfo->col_buf[i], orig, max_len);
382       cinfo->col_data[i] = cinfo->col_buf[i];
383     }
384   }
385 }
386 void
387 col_prepend_fence_fstr(column_info *cinfo, const gint el, const gchar *format, ...)
388 {
389   va_list     ap;
390   int         i;
391   char        orig_buf[COL_BUF_MAX_LEN];
392   const char *orig;
393   int         max_len;
394
395   if (!CHECK_COL(cinfo, el))
396     return;
397
398   if (el == COL_INFO)
399     max_len = COL_MAX_INFO_LEN;
400   else
401     max_len = COL_MAX_LEN;
402
403   for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
404     if (cinfo->fmt_matx[i][el]) {
405       if (cinfo->col_data[i] != cinfo->col_buf[i]) {
406         /* This was set with "col_set_str()"; which is effectively const */
407         orig = cinfo->col_data[i];
408       } else {
409         g_strlcpy(orig_buf, cinfo->col_buf[i], max_len);
410         orig = orig_buf;
411       }
412       va_start(ap, format);
413       g_vsnprintf(cinfo->col_buf[i], max_len, format, ap);
414       va_end(ap);
415
416       /*
417        * Move the fence if it exists, else create a new fence at the
418        * end of the prepended data.
419        */
420       if (cinfo->col_fence[i] > 0) {
421         cinfo->col_fence[i] += (int) strlen(cinfo->col_buf[i]);
422       } else {
423         cinfo->col_fence[i]  = (int) strlen(cinfo->col_buf[i]);
424       }
425       g_strlcat(cinfo->col_buf[i], orig, max_len);
426       cinfo->col_data[i] = cinfo->col_buf[i];
427     }
428   }
429 }
430
431 /* Use this if "str" points to something that won't stay around (and
432    must thus be copied). */
433 void
434 col_add_str(column_info *cinfo, const gint el, const gchar* str)
435 {
436   int    i;
437   int    fence;
438   size_t max_len;
439
440   if (!CHECK_COL(cinfo, el))
441     return;
442
443   if (el == COL_INFO)
444     max_len = COL_MAX_INFO_LEN;
445   else
446     max_len = COL_MAX_LEN;
447
448   for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
449     if (cinfo->fmt_matx[i][el]) {
450       fence = cinfo->col_fence[i];
451       if (fence != 0) {
452         /*
453          * We will append the string after the fence.
454          * First arrange that we can append, if necessary.
455          */
456         COL_CHECK_APPEND(cinfo, i, max_len);
457       } else {
458         /*
459          * There's no fence, so we can just write to the string.
460          */
461         cinfo->col_data[i] = cinfo->col_buf[i];
462       }
463       g_strlcpy(&cinfo->col_buf[i][fence], str, max_len - fence);
464     }
465   }
466 }
467
468 /* Use this if "str" points to something that will stay around (and thus
469    needn't be copied). */
470 void
471 col_set_str(column_info *cinfo, const gint el, const gchar* str)
472 {
473   int i;
474   int fence;
475   size_t max_len;
476
477   DISSECTOR_ASSERT(str);
478
479   /* The caller is expected to pass in something that 'will stay around' and
480    * something from the ephemeral pool certainly doesn't fit the bill. */
481   DISSECTOR_ASSERT(!ep_verify_pointer(str));
482
483   if (!CHECK_COL(cinfo, el))
484     return;
485
486   if (el == COL_INFO)
487     max_len = COL_MAX_INFO_LEN;
488   else
489     max_len = COL_MAX_LEN;
490
491   for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
492     if (cinfo->fmt_matx[i][el]) {
493       fence = cinfo->col_fence[i];
494       if (fence != 0) {
495         /*
496          * We will append the string after the fence.
497          * First arrange that we can append, if necessary.
498          */
499         COL_CHECK_APPEND(cinfo, i, max_len);
500
501         g_strlcpy(&cinfo->col_buf[i][fence], str, max_len - fence);
502       } else {
503         /*
504          * There's no fence, so we can just set the column to point
505          * to the string.
506          */
507         cinfo->col_data[i] = str;
508       }
509     }
510   }
511 }
512
513 /* Adds a vararg list to a packet info string. */
514 void
515 col_add_fstr(column_info *cinfo, const gint el, const gchar *format, ...) {
516   va_list ap;
517   int     i;
518   int     fence;
519   int     max_len;
520
521   if (!CHECK_COL(cinfo, el))
522     return;
523
524   if (el == COL_INFO)
525     max_len = COL_MAX_INFO_LEN;
526   else
527     max_len = COL_MAX_LEN;
528
529   for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
530     if (cinfo->fmt_matx[i][el]) {
531       fence = cinfo->col_fence[i];
532       if (fence != 0) {
533         /*
534          * We will append the string after the fence.
535          * First arrange that we can append, if necessary.
536          */
537         COL_CHECK_APPEND(cinfo, i, max_len);
538       } else {
539         /*
540          * There's no fence, so we can just write to the string.
541          */
542         cinfo->col_data[i] = cinfo->col_buf[i];
543       }
544       va_start(ap, format);
545       g_vsnprintf(&cinfo->col_buf[i][fence], max_len - fence, format, ap);
546       va_end(ap);
547     }
548   }
549 }
550
551 static void
552 col_do_append_str(column_info *cinfo, const gint el, const gchar* separator,
553     const gchar* str)
554 {
555   int    i;
556   size_t len, max_len;
557
558   if (el == COL_INFO)
559     max_len = COL_MAX_INFO_LEN;
560   else
561     max_len = COL_MAX_LEN;
562
563   for (i = cinfo->col_first[el]; i <= cinfo->col_last[el]; i++) {
564     if (cinfo->fmt_matx[i][el]) {
565       /*
566        * First arrange that we can append, if necessary.
567        */
568       COL_CHECK_APPEND(cinfo, i, max_len);
569
570       len = cinfo->col_buf[i][0];
571
572       /*
573        * If we have a separator, append it if the column isn't empty.
574        */
575       if (separator != NULL) {
576         if (len != 0) {
577           g_strlcat(cinfo->col_buf[i], separator, max_len);
578         }
579       }
580       g_strlcat(cinfo->col_buf[i], str, max_len);
581     }
582   }
583 }
584
585 void
586 col_append_str(column_info *cinfo, const gint el, const gchar* str)
587 {
588   if (!CHECK_COL(cinfo, el))
589     return;
590
591   col_do_append_str(cinfo, el, NULL, str);
592 }
593
594 void
595 col_append_sep_str(column_info *cinfo, const gint el, const gchar* separator,
596     const gchar* str)
597 {
598   if (!CHECK_COL(cinfo, el))
599     return;
600
601   if (separator == NULL)
602     separator = ", ";    /* default */
603
604   col_do_append_str(cinfo, el, separator, str);
605 }
606
607 /* --------------------------------- */
608 gboolean
609 col_has_time_fmt(column_info *cinfo, const gint col)
610 {
611   return ((cinfo->fmt_matx[col][COL_CLS_TIME]) ||
612           (cinfo->fmt_matx[col][COL_ABS_TIME]) ||
613           (cinfo->fmt_matx[col][COL_ABS_DATE_TIME]) ||
614           (cinfo->fmt_matx[col][COL_UTC_TIME]) ||
615           (cinfo->fmt_matx[col][COL_UTC_DATE_TIME]) ||
616           (cinfo->fmt_matx[col][COL_REL_TIME]) ||
617           (cinfo->fmt_matx[col][COL_DELTA_TIME]) ||
618           (cinfo->fmt_matx[col][COL_DELTA_TIME_DIS]));
619 }
620
621 static void
622 set_abs_date_time(const frame_data *fd, gchar *buf, gboolean local)
623 {
624   struct tm *tmp;
625   time_t then;
626
627   if (fd->flags.has_ts) {
628     then = fd->abs_ts.secs;
629     if (local)
630        tmp = localtime(&then);
631     else
632        tmp = gmtime(&then);
633   } else
634     tmp = NULL;
635   if (tmp != NULL) {
636       switch(timestamp_get_precision()) {
637       case TS_PREC_FIXED_SEC:
638       case TS_PREC_AUTO_SEC:
639           g_snprintf(buf, COL_MAX_LEN,"%04d-%02d-%02d %02d:%02d:%02d",
640              tmp->tm_year + 1900,
641              tmp->tm_mon + 1,
642              tmp->tm_mday,
643              tmp->tm_hour,
644              tmp->tm_min,
645              tmp->tm_sec);
646           break;
647       case TS_PREC_FIXED_DSEC:
648       case TS_PREC_AUTO_DSEC:
649           g_snprintf(buf, COL_MAX_LEN,"%04d-%02d-%02d %02d:%02d:%02d.%01ld",
650              tmp->tm_year + 1900,
651              tmp->tm_mon + 1,
652              tmp->tm_mday,
653              tmp->tm_hour,
654              tmp->tm_min,
655              tmp->tm_sec,
656              (long)fd->abs_ts.nsecs / 100000000);
657           break;
658       case TS_PREC_FIXED_CSEC:
659       case TS_PREC_AUTO_CSEC:
660           g_snprintf(buf, COL_MAX_LEN,"%04d-%02d-%02d %02d:%02d:%02d.%02ld",
661              tmp->tm_year + 1900,
662              tmp->tm_mon + 1,
663              tmp->tm_mday,
664              tmp->tm_hour,
665              tmp->tm_min,
666              tmp->tm_sec,
667              (long)fd->abs_ts.nsecs / 10000000);
668           break;
669       case TS_PREC_FIXED_MSEC:
670       case TS_PREC_AUTO_MSEC:
671           g_snprintf(buf, COL_MAX_LEN, "%04d-%02d-%02d %02d:%02d:%02d.%03ld",
672              tmp->tm_year + 1900,
673              tmp->tm_mon + 1,
674              tmp->tm_mday,
675              tmp->tm_hour,
676              tmp->tm_min,
677              tmp->tm_sec,
678              (long)fd->abs_ts.nsecs / 1000000);
679           break;
680       case TS_PREC_FIXED_USEC:
681       case TS_PREC_AUTO_USEC:
682           g_snprintf(buf, COL_MAX_LEN, "%04d-%02d-%02d %02d:%02d:%02d.%06ld",
683              tmp->tm_year + 1900,
684              tmp->tm_mon + 1,
685              tmp->tm_mday,
686              tmp->tm_hour,
687              tmp->tm_min,
688              tmp->tm_sec,
689              (long)fd->abs_ts.nsecs / 1000);
690           break;
691       case TS_PREC_FIXED_NSEC:
692       case TS_PREC_AUTO_NSEC:
693           g_snprintf(buf, COL_MAX_LEN, "%04d-%02d-%02d %02d:%02d:%02d.%09ld",
694              tmp->tm_year + 1900,
695              tmp->tm_mon + 1,
696              tmp->tm_mday,
697              tmp->tm_hour,
698              tmp->tm_min,
699              tmp->tm_sec,
700              (long)fd->abs_ts.nsecs);
701           break;
702       default:
703           g_assert_not_reached();
704       }
705   } else {
706     buf[0] = '\0';
707   }
708 }
709
710 static void
711 col_set_abs_date_time(const frame_data *fd, column_info *cinfo, const int col)
712 {
713   set_abs_date_time(fd, cinfo->col_buf[col], TRUE);
714   cinfo->col_expr.col_expr[col] = "frame.time";
715   g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
716
717   cinfo->col_data[col] = cinfo->col_buf[col];
718 }
719
720 static void
721 col_set_utc_date_time(const frame_data *fd, column_info *cinfo, const int col)
722 {
723   set_abs_date_time(fd, cinfo->col_buf[col], FALSE);
724   cinfo->col_expr.col_expr[col] = "frame.time";
725   g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
726
727   cinfo->col_data[col] = cinfo->col_buf[col];
728 }
729
730 static void
731 set_time_seconds(const nstime_t *ts, gchar *buf)
732 {
733   switch(timestamp_get_precision()) {
734       case TS_PREC_FIXED_SEC:
735       case TS_PREC_AUTO_SEC:
736           display_signed_time(buf, COL_MAX_LEN,
737             (gint32) ts->secs, ts->nsecs / 1000000000, TO_STR_TIME_RES_T_SECS);
738           break;
739       case TS_PREC_FIXED_DSEC:
740       case TS_PREC_AUTO_DSEC:
741           display_signed_time(buf, COL_MAX_LEN,
742             (gint32) ts->secs, ts->nsecs / 100000000, TO_STR_TIME_RES_T_DSECS);
743           break;
744       case TS_PREC_FIXED_CSEC:
745       case TS_PREC_AUTO_CSEC:
746           display_signed_time(buf, COL_MAX_LEN,
747             (gint32) ts->secs, ts->nsecs / 10000000, TO_STR_TIME_RES_T_CSECS);
748           break;
749       case TS_PREC_FIXED_MSEC:
750       case TS_PREC_AUTO_MSEC:
751           display_signed_time(buf, COL_MAX_LEN,
752             (gint32) ts->secs, ts->nsecs / 1000000, TO_STR_TIME_RES_T_MSECS);
753           break;
754       case TS_PREC_FIXED_USEC:
755       case TS_PREC_AUTO_USEC:
756           display_signed_time(buf, COL_MAX_LEN,
757             (gint32) ts->secs, ts->nsecs / 1000, TO_STR_TIME_RES_T_USECS);
758           break;
759       case TS_PREC_FIXED_NSEC:
760       case TS_PREC_AUTO_NSEC:
761           display_signed_time(buf, COL_MAX_LEN,
762             (gint32) ts->secs, ts->nsecs, TO_STR_TIME_RES_T_NSECS);
763           break;
764       default:
765           g_assert_not_reached();
766   }
767 }
768
769 static void
770 set_time_hour_min_sec(const nstime_t *ts, gchar *buf)
771 {
772   time_t secs = ts->secs;
773   long nsecs = (long) ts->nsecs;
774   gboolean negative = FALSE;
775
776   if (secs < 0) {
777     secs = -secs;
778     negative = TRUE;
779   }
780   if (nsecs < 0) {
781     nsecs = -nsecs;
782     negative = TRUE;
783   }
784
785   switch(timestamp_get_precision()) {
786   case TS_PREC_FIXED_SEC:
787   case TS_PREC_AUTO_SEC:
788     if (secs >= (60*60)) {
789       g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2ds",
790                  negative ? "- " : "",
791                  (gint32) secs / (60 * 60),
792                  (gint32) (secs / 60) % 60,
793                  (gint32) secs % 60);
794     } else if (secs >= 60) {
795       g_snprintf(buf, COL_MAX_LEN, "%s%dm %2ds",
796                  negative ? "- " : "",
797                  (gint32) secs / 60,
798                  (gint32) secs % 60);
799     } else {
800       g_snprintf(buf, COL_MAX_LEN, "%s%ds",
801                  negative ? "- " : "",
802                  (gint32) secs);
803     }
804     break;
805   case TS_PREC_FIXED_DSEC:
806   case TS_PREC_AUTO_DSEC:
807     if (secs >= (60*60)) {
808       g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%01lds",
809                  negative ? "- " : "",
810                  (gint32) secs / (60 * 60),
811                  (gint32) (secs / 60) % 60,
812                  (gint32) secs % 60,
813                  nsecs / 100000000);
814     } else if (secs >= 60) {
815       g_snprintf(buf, COL_MAX_LEN, "%s%dm %2d.%01lds",
816                  negative ? "- " : "",
817                  (gint32) secs / 60,
818                  (gint32) secs % 60,
819                  nsecs / 100000000);
820     } else {
821       g_snprintf(buf, COL_MAX_LEN, "%s%d.%01lds",
822                  negative ? "- " : "",
823                  (gint32) secs,
824                  nsecs / 100000000);
825     }
826     break;
827   case TS_PREC_FIXED_CSEC:
828   case TS_PREC_AUTO_CSEC:
829     if (secs >= (60*60)) {
830       g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%02lds",
831                  negative ? "- " : "",
832                  (gint32) secs / (60 * 60),
833                  (gint32) (secs / 60) % 60,
834                  (gint32) secs % 60,
835                  nsecs / 10000000);
836     } else if (secs >= 60) {
837       g_snprintf(buf, COL_MAX_LEN, "%s%dm %2d.%02lds",
838                  negative ? "- " : "",
839                  (gint32) secs / 60,
840                  (gint32) secs % 60,
841                  nsecs / 10000000);
842     } else {
843       g_snprintf(buf, COL_MAX_LEN, "%s%d.%02lds",
844                  negative ? "- " : "",
845                  (gint32) secs,
846                  nsecs / 10000000);
847     }
848     break;
849   case TS_PREC_FIXED_MSEC:
850   case TS_PREC_AUTO_MSEC:
851     if (secs >= (60*60)) {
852       g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%03lds",
853                  negative ? "- " : "",
854                  (gint32) secs / (60 * 60),
855                  (gint32) (secs / 60) % 60,
856                  (gint32) secs % 60,
857                  nsecs / 1000000);
858     } else if (secs >= 60) {
859       g_snprintf(buf, COL_MAX_LEN, "%s%dm %2d.%03lds",
860                  negative ? "- " : "",
861                  (gint32) secs / 60,
862                  (gint32) secs % 60,
863                  nsecs / 1000000);
864     } else {
865       g_snprintf(buf, COL_MAX_LEN, "%s%d.%03lds",
866                  negative ? "- " : "",
867                  (gint32) secs,
868                  nsecs / 1000000);
869     }
870     break;
871   case TS_PREC_FIXED_USEC:
872   case TS_PREC_AUTO_USEC:
873     if (secs >= (60*60)) {
874       g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%06lds",
875                  negative ? "- " : "",
876                  (gint32) secs / (60 * 60),
877                  (gint32) (secs / 60) % 60,
878                  (gint32) secs % 60,
879                  nsecs / 1000);
880     } else if (secs >= 60) {
881       g_snprintf(buf, COL_MAX_LEN, "%s%dm %2d.%06lds",
882                  negative ? "- " : "",
883                  (gint32) secs / 60,
884                  (gint32) secs % 60,
885                  nsecs / 1000);
886     } else {
887       g_snprintf(buf, COL_MAX_LEN, "%s%d.%06lds",
888                  negative ? "- " : "",
889                  (gint32) secs,
890                  nsecs / 1000);
891     }
892     break;
893   case TS_PREC_FIXED_NSEC:
894   case TS_PREC_AUTO_NSEC:
895     if (secs >= (60*60)) {
896       g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%09lds",
897                  negative ? "- " : "",
898                  (gint32) secs / (60 * 60),
899                  (gint32) (secs / 60) % 60,
900                  (gint32) secs % 60,
901                  nsecs);
902     } else if (secs >= 60) {
903       g_snprintf(buf, COL_MAX_LEN, "%s%dm %2d.%09lds",
904                  negative ? "- " : "",
905                  (gint32) secs / 60,
906                  (gint32) secs % 60,
907                  nsecs);
908     } else {
909       g_snprintf(buf, COL_MAX_LEN, "%s%d.%09lds",
910                  negative ? "- " : "",
911                  (gint32) secs,
912                  nsecs);
913     }
914     break;
915   default:
916     g_assert_not_reached();
917   }
918 }
919
920 static void
921 col_set_rel_time(const frame_data *fd, column_info *cinfo, const int col)
922 {
923   if (!fd->flags.has_ts) {
924     cinfo->col_buf[col][0] = '\0';
925     return;
926   }
927   switch (timestamp_get_seconds_type()) {
928   case TS_SECONDS_DEFAULT:
929     set_time_seconds(&fd->rel_ts, cinfo->col_buf[col]);
930     cinfo->col_expr.col_expr[col] = "frame.time_relative";
931     g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
932     break;
933   case TS_SECONDS_HOUR_MIN_SEC:
934     set_time_hour_min_sec(&fd->rel_ts, cinfo->col_buf[col]);
935     cinfo->col_expr.col_expr[col] = "frame.time_relative";
936     set_time_seconds(&fd->rel_ts, cinfo->col_expr.col_expr_val[col]);
937     break;
938   default:
939     g_assert_not_reached();
940   }
941   cinfo->col_data[col] = cinfo->col_buf[col];
942 }
943
944 static void
945 col_set_delta_time(const frame_data *fd, column_info *cinfo, const int col)
946 {
947   nstime_t del_cap_ts;
948
949   frame_delta_abs_time(fd, fd->prev_cap, &del_cap_ts);
950
951   switch (timestamp_get_seconds_type()) {
952   case TS_SECONDS_DEFAULT:
953     set_time_seconds(&del_cap_ts, cinfo->col_buf[col]);
954     cinfo->col_expr.col_expr[col] = "frame.time_delta";
955     g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
956     break;
957   case TS_SECONDS_HOUR_MIN_SEC:
958     set_time_hour_min_sec(&del_cap_ts, cinfo->col_buf[col]);
959     cinfo->col_expr.col_expr[col] = "frame.time_delta";
960     set_time_seconds(&del_cap_ts, cinfo->col_expr.col_expr_val[col]);
961     break;
962   default:
963     g_assert_not_reached();
964   }
965
966   cinfo->col_data[col] = cinfo->col_buf[col];
967 }
968
969 static void
970 col_set_delta_time_dis(const frame_data *fd, column_info *cinfo, const int col)
971 {
972   nstime_t del_dis_ts;
973
974   if (!fd->flags.has_ts) {
975     cinfo->col_buf[col][0] = '\0';
976     return;
977   }
978
979   frame_delta_abs_time(fd, fd->prev_dis, &del_dis_ts);
980
981   switch (timestamp_get_seconds_type()) {
982   case TS_SECONDS_DEFAULT:
983     set_time_seconds(&del_dis_ts, cinfo->col_buf[col]);
984     cinfo->col_expr.col_expr[col] = "frame.time_delta_displayed";
985     g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
986     break;
987   case TS_SECONDS_HOUR_MIN_SEC:
988     set_time_hour_min_sec(&del_dis_ts, cinfo->col_buf[col]);
989     cinfo->col_expr.col_expr[col] = "frame.time_delta_displayed";
990     set_time_seconds(&del_dis_ts, cinfo->col_expr.col_expr_val[col]);
991     break;
992   default:
993     g_assert_not_reached();
994   }
995
996   cinfo->col_data[col] = cinfo->col_buf[col];
997 }
998
999 static void
1000 set_abs_time(const frame_data *fd, gchar *buf, gboolean local)
1001 {
1002   struct tm *tmp;
1003   time_t then;
1004
1005   if (fd->flags.has_ts) {
1006     then = fd->abs_ts.secs;
1007     if (local)
1008        tmp = localtime(&then);
1009     else
1010        tmp = gmtime(&then);
1011   } else
1012     tmp = NULL;
1013   if (tmp != NULL) {
1014       switch(timestamp_get_precision()) {
1015       case TS_PREC_FIXED_SEC:
1016       case TS_PREC_AUTO_SEC:
1017           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d",
1018              tmp->tm_hour,
1019              tmp->tm_min,
1020              tmp->tm_sec);
1021           break;
1022       case TS_PREC_FIXED_DSEC:
1023       case TS_PREC_AUTO_DSEC:
1024           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%01ld",
1025              tmp->tm_hour,
1026              tmp->tm_min,
1027              tmp->tm_sec,
1028              (long)fd->abs_ts.nsecs / 100000000);
1029           break;
1030       case TS_PREC_FIXED_CSEC:
1031       case TS_PREC_AUTO_CSEC:
1032           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%02ld",
1033              tmp->tm_hour,
1034              tmp->tm_min,
1035              tmp->tm_sec,
1036              (long)fd->abs_ts.nsecs / 10000000);
1037           break;
1038       case TS_PREC_FIXED_MSEC:
1039       case TS_PREC_AUTO_MSEC:
1040           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%03ld",
1041              tmp->tm_hour,
1042              tmp->tm_min,
1043              tmp->tm_sec,
1044              (long)fd->abs_ts.nsecs / 1000000);
1045           break;
1046       case TS_PREC_FIXED_USEC:
1047       case TS_PREC_AUTO_USEC:
1048           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%06ld",
1049              tmp->tm_hour,
1050              tmp->tm_min,
1051              tmp->tm_sec,
1052              (long)fd->abs_ts.nsecs / 1000);
1053           break;
1054       case TS_PREC_FIXED_NSEC:
1055       case TS_PREC_AUTO_NSEC:
1056           g_snprintf(buf, COL_MAX_LEN, "%02d:%02d:%02d.%09ld",
1057              tmp->tm_hour,
1058              tmp->tm_min,
1059              tmp->tm_sec,
1060              (long)fd->abs_ts.nsecs);
1061           break;
1062       default:
1063           g_assert_not_reached();
1064       }
1065
1066   } else {
1067     *buf = '\0';
1068   }
1069 }
1070
1071 static void
1072 col_set_abs_time(const frame_data *fd, column_info *cinfo, const int col)
1073 {
1074   set_abs_time(fd, cinfo->col_buf[col], TRUE);
1075   cinfo->col_expr.col_expr[col] = "frame.time";
1076   g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
1077
1078   cinfo->col_data[col] = cinfo->col_buf[col];
1079 }
1080
1081 static void
1082 col_set_utc_time(const frame_data *fd, column_info *cinfo, const int col)
1083 {
1084   set_abs_time(fd, cinfo->col_buf[col], FALSE);
1085   cinfo->col_expr.col_expr[col] = "frame.time";
1086   g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
1087
1088   cinfo->col_data[col] = cinfo->col_buf[col];
1089 }
1090
1091 static gboolean
1092 set_epoch_time(const frame_data *fd, gchar *buf)
1093 {
1094   if (!fd->flags.has_ts) {
1095     buf[0] = '\0';
1096     return FALSE;
1097   }
1098   switch(timestamp_get_precision()) {
1099       case TS_PREC_FIXED_SEC:
1100       case TS_PREC_AUTO_SEC:
1101           display_epoch_time(buf, COL_MAX_LEN,
1102             fd->abs_ts.secs, fd->abs_ts.nsecs / 1000000000, TO_STR_TIME_RES_T_SECS);
1103           break;
1104       case TS_PREC_FIXED_DSEC:
1105       case TS_PREC_AUTO_DSEC:
1106           display_epoch_time(buf, COL_MAX_LEN,
1107             fd->abs_ts.secs, fd->abs_ts.nsecs / 100000000, TO_STR_TIME_RES_T_DSECS);
1108           break;
1109       case TS_PREC_FIXED_CSEC:
1110       case TS_PREC_AUTO_CSEC:
1111           display_epoch_time(buf, COL_MAX_LEN,
1112             fd->abs_ts.secs, fd->abs_ts.nsecs / 10000000, TO_STR_TIME_RES_T_CSECS);
1113           break;
1114       case TS_PREC_FIXED_MSEC:
1115       case TS_PREC_AUTO_MSEC:
1116           display_epoch_time(buf, COL_MAX_LEN,
1117             fd->abs_ts.secs, fd->abs_ts.nsecs / 1000000, TO_STR_TIME_RES_T_MSECS);
1118           break;
1119       case TS_PREC_FIXED_USEC:
1120       case TS_PREC_AUTO_USEC:
1121           display_epoch_time(buf, COL_MAX_LEN,
1122             fd->abs_ts.secs, fd->abs_ts.nsecs / 1000, TO_STR_TIME_RES_T_USECS);
1123           break;
1124       case TS_PREC_FIXED_NSEC:
1125       case TS_PREC_AUTO_NSEC:
1126           display_epoch_time(buf, COL_MAX_LEN,
1127             fd->abs_ts.secs, fd->abs_ts.nsecs, TO_STR_TIME_RES_T_NSECS);
1128           break;
1129       default:
1130           g_assert_not_reached();
1131   }
1132   return TRUE;
1133 }
1134
1135 static void
1136 col_set_epoch_time(const frame_data *fd, column_info *cinfo, const int col)
1137 {
1138   if (set_epoch_time(fd, cinfo->col_buf[col])) {
1139     cinfo->col_expr.col_expr[col] = "frame.time_delta";
1140     g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
1141   }
1142   cinfo->col_data[col] = cinfo->col_buf[col];
1143 }
1144
1145 void
1146 set_fd_time(frame_data *fd, gchar *buf)
1147 {
1148
1149   switch (timestamp_get_type()) {
1150     case TS_ABSOLUTE:
1151       set_abs_time(fd, buf, TRUE);
1152       break;
1153
1154     case TS_ABSOLUTE_WITH_DATE:
1155       set_abs_date_time(fd, buf, TRUE);
1156       break;
1157
1158     case TS_RELATIVE:
1159       if (fd->flags.has_ts) {
1160         switch (timestamp_get_seconds_type()) {
1161         case TS_SECONDS_DEFAULT:
1162           set_time_seconds(&fd->rel_ts, buf);
1163           break;
1164         case TS_SECONDS_HOUR_MIN_SEC:
1165           set_time_seconds(&fd->rel_ts, buf);
1166           break;
1167         default:
1168           g_assert_not_reached();
1169         }
1170       } else {
1171         buf[0] = '\0';
1172       }
1173       break;
1174
1175     case TS_DELTA:
1176       if (fd->flags.has_ts) {
1177         nstime_t del_cap_ts;
1178
1179         frame_delta_abs_time(fd, fd->prev_cap, &del_cap_ts);
1180
1181         switch (timestamp_get_seconds_type()) {
1182         case TS_SECONDS_DEFAULT:
1183           set_time_seconds(&del_cap_ts, buf);
1184           break;
1185         case TS_SECONDS_HOUR_MIN_SEC:
1186           set_time_hour_min_sec(&del_cap_ts, buf);
1187           break;
1188         default:
1189           g_assert_not_reached();
1190         }
1191       } else {
1192         buf[0] = '\0';
1193       }
1194       break;
1195
1196     case TS_DELTA_DIS:
1197       if (fd->flags.has_ts) {
1198         nstime_t del_dis_ts;
1199
1200         frame_delta_abs_time(fd, fd->prev_dis, &del_dis_ts);
1201
1202         switch (timestamp_get_seconds_type()) {
1203         case TS_SECONDS_DEFAULT:
1204           set_time_seconds(&del_dis_ts, buf);
1205           break;
1206         case TS_SECONDS_HOUR_MIN_SEC:
1207           set_time_hour_min_sec(&del_dis_ts, buf);
1208           break;
1209         default:
1210           g_assert_not_reached();
1211         }
1212       } else {
1213         buf[0] = '\0';
1214       }
1215       break;
1216
1217     case TS_EPOCH:
1218       set_epoch_time(fd, buf);
1219       break;
1220
1221     case TS_UTC:
1222       set_abs_time(fd, buf, FALSE);
1223       break;
1224
1225     case TS_UTC_WITH_DATE:
1226       set_abs_date_time(fd, buf, FALSE);
1227       break;
1228
1229     case TS_NOT_SET:
1230       /* code is missing for this case, but I don't know which [jmayer20051219] */
1231       g_assert(FALSE);
1232       break;
1233   }
1234 }
1235
1236 static void
1237 col_set_cls_time(const frame_data *fd, column_info *cinfo, const gint col)
1238 {
1239   switch (timestamp_get_type()) {
1240     case TS_ABSOLUTE:
1241       col_set_abs_time(fd, cinfo, col);
1242       break;
1243
1244     case TS_ABSOLUTE_WITH_DATE:
1245       col_set_abs_date_time(fd, cinfo, col);
1246       break;
1247
1248     case TS_RELATIVE:
1249       col_set_rel_time(fd, cinfo, col);
1250       break;
1251
1252     case TS_DELTA:
1253       col_set_delta_time(fd, cinfo, col);
1254       break;
1255
1256     case TS_DELTA_DIS:
1257       col_set_delta_time_dis(fd, cinfo, col);
1258       break;
1259
1260     case TS_EPOCH:
1261       col_set_epoch_time(fd, cinfo, col);
1262       break;
1263
1264     case TS_UTC:
1265       col_set_utc_time(fd, cinfo, col);
1266       break;
1267
1268     case TS_UTC_WITH_DATE:
1269       col_set_utc_date_time(fd, cinfo, col);
1270       break;
1271
1272     case TS_NOT_SET:
1273       /* code is missing for this case, but I don't know which [jmayer20051219] */
1274       g_assert_not_reached();
1275       break;
1276   }
1277 }
1278
1279 /* Set the format of the variable time format. */
1280 static void
1281 col_set_fmt_time(const frame_data *fd, column_info *cinfo, const gint fmt, const gint col)
1282 {
1283   COL_CHECK_REF_TIME(fd, cinfo->col_buf[col]);
1284
1285   switch (fmt) {
1286     case COL_CLS_TIME:
1287       col_set_cls_time(fd, cinfo, col);
1288       break;
1289
1290     case COL_ABS_TIME:
1291       col_set_abs_time(fd, cinfo, col);
1292       break;
1293
1294     case COL_ABS_DATE_TIME:
1295       col_set_abs_date_time(fd, cinfo, col);
1296       break;
1297
1298     case COL_REL_TIME:
1299       col_set_rel_time(fd, cinfo, col);
1300       break;
1301
1302     case COL_DELTA_TIME:
1303       col_set_delta_time(fd, cinfo, col);
1304       break;
1305
1306     case COL_DELTA_TIME_DIS:
1307       col_set_delta_time_dis(fd, cinfo, col);
1308       break;
1309
1310     case COL_UTC_TIME:
1311       col_set_utc_time(fd, cinfo, col);
1312       break;
1313
1314     case COL_UTC_DATE_TIME:
1315       col_set_utc_date_time(fd, cinfo, col);
1316       break;
1317
1318     default:
1319       g_assert_not_reached();
1320       break;
1321   }
1322 }
1323
1324 /* --------------------------- */
1325 /* Set the given (relative) time to a column element.
1326  *
1327  * Used by multiple dissectors to set the time in the column
1328  * COL_DELTA_CONV_TIME
1329  *
1330  * @param cinfo         the current packet row
1331  * @param col           the column to use, e.g. COL_INFO
1332  * @param ts            the time to set in the column
1333  * @param fieldname     the fieldname to use for creating a filter (when
1334  *                        applying/preparing/copying as filter)
1335  */
1336 void
1337 col_set_time(column_info *cinfo, const gint el, const nstime_t *ts, char *fieldname)
1338 {
1339   int col;
1340
1341   if (!CHECK_COL(cinfo, el))
1342     return;
1343
1344   /** @todo TODO: We don't respect fd->flags.ref_time (no way to access 'fd')
1345   COL_CHECK_REF_TIME(fd, buf);
1346   */
1347
1348   for (col = cinfo->col_first[el]; col <= cinfo->col_last[el]; col++) {
1349     if (cinfo->fmt_matx[col][el]) {
1350       switch(timestamp_get_precision()) {
1351     case TS_PREC_FIXED_SEC:
1352     case TS_PREC_AUTO_SEC:
1353       display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
1354         (gint32) ts->secs, ts->nsecs / 1000000000, TO_STR_TIME_RES_T_SECS);
1355       break;
1356     case TS_PREC_FIXED_DSEC:
1357     case TS_PREC_AUTO_DSEC:
1358       display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
1359         (gint32) ts->secs, ts->nsecs / 100000000, TO_STR_TIME_RES_T_DSECS);
1360       break;
1361     case TS_PREC_FIXED_CSEC:
1362     case TS_PREC_AUTO_CSEC:
1363       display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
1364         (gint32) ts->secs, ts->nsecs / 10000000, TO_STR_TIME_RES_T_CSECS);
1365       break;
1366     case TS_PREC_FIXED_MSEC:
1367     case TS_PREC_AUTO_MSEC:
1368       display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
1369         (gint32) ts->secs, ts->nsecs / 1000000, TO_STR_TIME_RES_T_MSECS);
1370       break;
1371     case TS_PREC_FIXED_USEC:
1372     case TS_PREC_AUTO_USEC:
1373       display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
1374         (gint32) ts->secs, ts->nsecs / 1000, TO_STR_TIME_RES_T_USECS);
1375       break;
1376     case TS_PREC_FIXED_NSEC:
1377     case TS_PREC_AUTO_NSEC:
1378       display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
1379         (gint32) ts->secs, ts->nsecs, TO_STR_TIME_RES_T_NSECS);
1380       break;
1381     default:
1382       g_assert_not_reached();
1383       }
1384       cinfo->col_data[col] = cinfo->col_buf[col];
1385       cinfo->col_expr.col_expr[col] = fieldname;
1386       g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
1387     }
1388   }
1389 }
1390
1391 static void
1392 col_set_addr(packet_info *pinfo, const int col, const address *addr, const gboolean is_src, const gboolean fill_col_exprs)
1393 {
1394   if (addr->type == AT_NONE) {
1395     /* No address, nothing to do */
1396     return;
1397   }
1398
1399   pinfo->cinfo->col_data[col] = se_get_addr_name(addr);
1400
1401   if (!fill_col_exprs)
1402     return;
1403
1404   switch (addr->type) {
1405
1406   case AT_AX25:
1407     if (is_src)
1408       pinfo->cinfo->col_expr.col_expr[col] = "ax25.src";
1409     else
1410       pinfo->cinfo->col_expr.col_expr[col] = "ax25.dst";
1411     g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], ax25_to_str(addr->data), COL_MAX_LEN);
1412     break;
1413
1414   case AT_ETHER:
1415     switch(addr->subtype) {
1416     default:
1417       if (is_src)
1418         pinfo->cinfo->col_expr.col_expr[col] = "eth.src";
1419       else
1420         pinfo->cinfo->col_expr.col_expr[col] = "eth.dst";
1421       address_to_str_buf(addr, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
1422       break;
1423     case AT_SUB_IEEE80211:
1424       if (is_src)
1425         pinfo->cinfo->col_expr.col_expr[col] = "wlan.sa";
1426       else
1427         pinfo->cinfo->col_expr.col_expr[col] = "wlan.da";
1428       address_to_str_buf(addr, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
1429       break;
1430     }
1431     break;
1432
1433   case AT_IPv4:
1434     if (is_src)
1435       pinfo->cinfo->col_expr.col_expr[col] = "ip.src";
1436     else
1437       pinfo->cinfo->col_expr.col_expr[col] = "ip.dst";
1438     ip_to_str_buf(addr->data, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
1439     break;
1440
1441   case AT_IPv6:
1442     if (is_src)
1443       pinfo->cinfo->col_expr.col_expr[col] = "ipv6.src";
1444     else
1445       pinfo->cinfo->col_expr.col_expr[col] = "ipv6.dst";
1446     address_to_str_buf(addr, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
1447     break;
1448
1449   case AT_ATALK:
1450     if (is_src)
1451       pinfo->cinfo->col_expr.col_expr[col] = "ddp.src";
1452     else
1453       pinfo->cinfo->col_expr.col_expr[col] = "ddp.dst";
1454     g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], pinfo->cinfo->col_buf[col], COL_MAX_LEN);
1455     break;
1456
1457   case AT_ARCNET:
1458     if (is_src)
1459       pinfo->cinfo->col_expr.col_expr[col] = "arcnet.src";
1460     else
1461       pinfo->cinfo->col_expr.col_expr[col] = "arcnet.dst";
1462     g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], pinfo->cinfo->col_buf[col], COL_MAX_LEN);
1463     break;
1464
1465   case AT_URI:
1466     if (is_src)
1467       pinfo->cinfo->col_expr.col_expr[col] = "uri.src";
1468     else
1469       pinfo->cinfo->col_expr.col_expr[col] = "uri.dst";
1470     address_to_str_buf(addr, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
1471     break;
1472
1473   default:
1474     break;
1475   }
1476 }
1477
1478 /* ------------------------ */
1479 static void
1480 col_set_port(packet_info *pinfo, const int col, const gboolean is_res, const gboolean is_src, const gboolean fill_col_exprs _U_)
1481 {
1482   guint32 port;
1483
1484   if (is_src)
1485     port = pinfo->srcport;
1486   else
1487     port = pinfo->destport;
1488
1489   /* TODO: Use fill_col_exprs */
1490
1491   switch (pinfo->ptype) {
1492   case PT_SCTP:
1493     if (is_res)
1494       g_strlcpy(pinfo->cinfo->col_buf[col], get_sctp_port(port), COL_MAX_LEN);
1495     else
1496       guint32_to_str_buf(port, pinfo->cinfo->col_buf[col], COL_MAX_LEN);
1497     break;
1498
1499   case PT_TCP:
1500     guint32_to_str_buf(port, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
1501     if (is_res)
1502       g_strlcpy(pinfo->cinfo->col_buf[col], get_tcp_port(port), COL_MAX_LEN);
1503     else
1504       g_strlcpy(pinfo->cinfo->col_buf[col], pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
1505     if (is_src)
1506       pinfo->cinfo->col_expr.col_expr[col] = "tcp.srcport";
1507     else
1508       pinfo->cinfo->col_expr.col_expr[col] = "tcp.dstport";
1509     break;
1510
1511   case PT_UDP:
1512     guint32_to_str_buf(port, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
1513     if (is_res)
1514       g_strlcpy(pinfo->cinfo->col_buf[col], get_udp_port(port), COL_MAX_LEN);
1515     else
1516       g_strlcpy(pinfo->cinfo->col_buf[col], pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
1517     if (is_src)
1518       pinfo->cinfo->col_expr.col_expr[col] = "udp.srcport";
1519     else
1520       pinfo->cinfo->col_expr.col_expr[col] = "udp.dstport";
1521     break;
1522
1523   case PT_DDP:
1524     if (is_src)
1525       pinfo->cinfo->col_expr.col_expr[col] = "ddp.src_socket";
1526     else
1527       pinfo->cinfo->col_expr.col_expr[col] = "ddp.dst_socket";
1528     guint32_to_str_buf(port, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
1529     g_strlcpy(pinfo->cinfo->col_buf[col], pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
1530     break;
1531
1532   case PT_IPX:
1533     /* XXX - resolve IPX socket numbers */
1534     g_snprintf(pinfo->cinfo->col_buf[col], COL_MAX_LEN, "0x%04x", port);
1535     g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], pinfo->cinfo->col_buf[col],COL_MAX_LEN);
1536     if (is_src)
1537       pinfo->cinfo->col_expr.col_expr[col] = "ipx.src.socket";
1538     else
1539       pinfo->cinfo->col_expr.col_expr[col] = "ipx.dst.socket";
1540     break;
1541
1542   case PT_IDP:
1543     /* XXX - resolve IDP socket numbers */
1544     g_snprintf(pinfo->cinfo->col_buf[col], COL_MAX_LEN, "0x%04x", port);
1545     g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], pinfo->cinfo->col_buf[col],COL_MAX_LEN);
1546     if (is_src)
1547       pinfo->cinfo->col_expr.col_expr[col] = "idp.src.socket";
1548     else
1549       pinfo->cinfo->col_expr.col_expr[col] = "idp.dst.socket";
1550     break;
1551
1552   case PT_USB:
1553     /* XXX - resolve USB endpoint numbers */
1554     g_snprintf(pinfo->cinfo->col_buf[col], COL_MAX_LEN, "0x%08x", port);
1555     g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], pinfo->cinfo->col_buf[col],COL_MAX_LEN);
1556     if (is_src)
1557       pinfo->cinfo->col_expr.col_expr[col] = "usb.src.endpoint";
1558     else
1559       pinfo->cinfo->col_expr.col_expr[col] = "usb.dst.endpoint";
1560     break;
1561
1562   default:
1563     break;
1564   }
1565   pinfo->cinfo->col_data[col] = pinfo->cinfo->col_buf[col];
1566 }
1567
1568 gboolean
1569 col_based_on_frame_data(column_info *cinfo, const gint col)
1570 {
1571     g_assert(cinfo);
1572     g_assert(col < cinfo->num_cols);
1573
1574     switch (cinfo->col_fmt[col]) {
1575
1576     case COL_NUMBER:
1577     case COL_CLS_TIME:
1578     case COL_ABS_TIME:
1579     case COL_ABS_DATE_TIME:
1580     case COL_UTC_TIME:
1581     case COL_UTC_DATE_TIME:
1582     case COL_REL_TIME:
1583     case COL_DELTA_TIME:
1584     case COL_DELTA_TIME_DIS:
1585     case COL_PACKET_LENGTH:
1586     case COL_CUMULATIVE_BYTES:
1587       return TRUE;
1588
1589     default:
1590         return FALSE;
1591     }
1592 }
1593
1594 void
1595 col_fill_in_frame_data(const frame_data *fd, column_info *cinfo, const gint col, const gboolean fill_col_exprs)
1596 {
1597     switch (cinfo->col_fmt[col]) {
1598
1599     case COL_NUMBER:
1600       guint32_to_str_buf(fd->num, cinfo->col_buf[col], COL_MAX_LEN);
1601       cinfo->col_data[col] = cinfo->col_buf[col];
1602       break;
1603
1604     case COL_CLS_TIME:
1605     case COL_ABS_TIME:
1606     case COL_ABS_DATE_TIME:
1607     case COL_UTC_TIME:
1608     case COL_UTC_DATE_TIME:
1609     case COL_REL_TIME:
1610     case COL_DELTA_TIME:
1611     case COL_DELTA_TIME_DIS:
1612        /* TODO: Pass on fill_col_exprs */
1613       col_set_fmt_time(fd, cinfo, cinfo->col_fmt[col], col);
1614       break;
1615
1616     case COL_PACKET_LENGTH:
1617       guint32_to_str_buf(fd->pkt_len, cinfo->col_buf[col], COL_MAX_LEN);
1618       cinfo->col_data[col] = cinfo->col_buf[col];
1619       break;
1620
1621     case COL_CUMULATIVE_BYTES:
1622       guint32_to_str_buf(fd->cum_bytes, cinfo->col_buf[col], COL_MAX_LEN);
1623       cinfo->col_data[col] = cinfo->col_buf[col];
1624       break;
1625
1626     default:
1627       break;
1628     }
1629
1630     if (!fill_col_exprs)
1631         return;
1632
1633     switch (cinfo->col_fmt[col]) {
1634
1635     case COL_NUMBER:
1636       cinfo->col_expr.col_expr[col] = "frame.number";
1637       g_strlcpy(cinfo->col_expr.col_expr_val[col], cinfo->col_buf[col], COL_MAX_LEN);
1638       break;
1639
1640     case COL_CLS_TIME:
1641     case COL_ABS_TIME:
1642     case COL_ABS_DATE_TIME:
1643     case COL_UTC_TIME:
1644     case COL_UTC_DATE_TIME:
1645     case COL_REL_TIME:
1646     case COL_DELTA_TIME:
1647     case COL_DELTA_TIME_DIS:
1648       /* Already handled above */
1649       break;
1650
1651     case COL_PACKET_LENGTH:
1652       cinfo->col_expr.col_expr[col] = "frame.len";
1653       g_strlcpy(cinfo->col_expr.col_expr_val[col], cinfo->col_buf[col], COL_MAX_LEN);
1654       break;
1655
1656     case COL_CUMULATIVE_BYTES:
1657       break;
1658
1659     default:
1660       break;
1661     }
1662 }
1663
1664 void
1665 col_fill_in(packet_info *pinfo, const gboolean fill_col_exprs, const gboolean fill_fd_colums)
1666 {
1667   int i;
1668
1669   if (!pinfo->cinfo)
1670     return;
1671
1672   for (i = 0; i < pinfo->cinfo->num_cols; i++) {
1673     switch (pinfo->cinfo->col_fmt[i]) {
1674
1675     case COL_NUMBER:
1676     case COL_CLS_TIME:
1677     case COL_ABS_TIME:
1678     case COL_ABS_DATE_TIME:
1679     case COL_UTC_TIME:
1680     case COL_UTC_DATE_TIME:
1681     case COL_REL_TIME:
1682     case COL_DELTA_TIME:
1683     case COL_DELTA_TIME_DIS:
1684     case COL_PACKET_LENGTH:
1685     case COL_CUMULATIVE_BYTES:
1686       if (fill_fd_colums)
1687         col_fill_in_frame_data(pinfo->fd, pinfo->cinfo, i, fill_col_exprs);
1688       break;
1689
1690     case COL_DEF_SRC:
1691     case COL_RES_SRC:   /* COL_DEF_SRC is currently just like COL_RES_SRC */
1692       col_set_addr(pinfo, i, &pinfo->src, TRUE, fill_col_exprs);
1693       break;
1694
1695     case COL_UNRES_SRC:
1696       col_set_addr(pinfo, i, &pinfo->src, TRUE, fill_col_exprs);
1697       break;
1698
1699     case COL_DEF_DL_SRC:
1700     case COL_RES_DL_SRC:
1701       col_set_addr(pinfo, i, &pinfo->dl_src, TRUE, fill_col_exprs);
1702       break;
1703
1704     case COL_UNRES_DL_SRC:
1705       col_set_addr(pinfo, i, &pinfo->dl_src, TRUE, fill_col_exprs);
1706       break;
1707
1708     case COL_DEF_NET_SRC:
1709     case COL_RES_NET_SRC:
1710       col_set_addr(pinfo, i, &pinfo->net_src, TRUE, fill_col_exprs);
1711       break;
1712
1713     case COL_UNRES_NET_SRC:
1714       col_set_addr(pinfo, i, &pinfo->net_src, TRUE, fill_col_exprs);
1715       break;
1716
1717     case COL_DEF_DST:
1718     case COL_RES_DST:   /* COL_DEF_DST is currently just like COL_RES_DST */
1719       col_set_addr(pinfo, i, &pinfo->dst, FALSE, fill_col_exprs);
1720       break;
1721
1722     case COL_UNRES_DST:
1723       col_set_addr(pinfo, i, &pinfo->dst, FALSE, fill_col_exprs);
1724       break;
1725
1726     case COL_DEF_DL_DST:
1727     case COL_RES_DL_DST:
1728       col_set_addr(pinfo, i, &pinfo->dl_dst, FALSE, fill_col_exprs);
1729       break;
1730
1731     case COL_UNRES_DL_DST:
1732       col_set_addr(pinfo, i, &pinfo->dl_dst, FALSE, fill_col_exprs);
1733       break;
1734
1735     case COL_DEF_NET_DST:
1736     case COL_RES_NET_DST:
1737       col_set_addr(pinfo, i, &pinfo->net_dst, FALSE, fill_col_exprs);
1738       break;
1739
1740     case COL_UNRES_NET_DST:
1741       col_set_addr(pinfo, i, &pinfo->net_dst, FALSE, fill_col_exprs);
1742       break;
1743
1744     case COL_DEF_SRC_PORT:
1745     case COL_RES_SRC_PORT:  /* COL_DEF_SRC_PORT is currently just like COL_RES_SRC_PORT */
1746       col_set_port(pinfo, i, TRUE, TRUE, fill_col_exprs);
1747       break;
1748
1749     case COL_UNRES_SRC_PORT:
1750       col_set_port(pinfo, i, FALSE, TRUE, fill_col_exprs);
1751       break;
1752
1753     case COL_DEF_DST_PORT:
1754     case COL_RES_DST_PORT:  /* COL_DEF_DST_PORT is currently just like COL_RES_DST_PORT */
1755       col_set_port(pinfo, i, TRUE, FALSE, fill_col_exprs);
1756       break;
1757
1758     case COL_UNRES_DST_PORT:
1759       col_set_port(pinfo, i, FALSE, FALSE, fill_col_exprs);
1760       break;
1761
1762     case COL_VSAN:
1763       guint32_to_str_buf(pinfo->vsan, pinfo->cinfo->col_buf[i], COL_MAX_LEN);
1764       pinfo->cinfo->col_data[i] = pinfo->cinfo->col_buf[i];
1765       break;
1766
1767     case NUM_COL_FMTS:  /* keep compiler happy - shouldn't get here */
1768       g_assert_not_reached();
1769       break;
1770     default:
1771       if (pinfo->cinfo->col_fmt[i] >= NUM_COL_FMTS) {
1772         g_assert_not_reached();
1773       }
1774       /*
1775        * Formatting handled by col_custom_set_edt() (COL_CUSTOM), expert.c
1776        * (COL_EXPERT), or individual dissectors.
1777        */
1778       break;
1779     }
1780   }
1781 }
1782
1783 /*
1784  * Fill in columns if we got an error reading the packet.
1785  * We set most columns to "???", and set the Info column to an error
1786  * message.
1787  */
1788 void
1789 col_fill_in_error(column_info *cinfo, frame_data *fdata, const gboolean fill_col_exprs, const gboolean fill_fd_colums)
1790 {
1791   int i;
1792
1793   if (!cinfo)
1794     return;
1795
1796   for (i = 0; i < cinfo->num_cols; i++) {
1797     switch (cinfo->col_fmt[i]) {
1798
1799     case COL_NUMBER:
1800     case COL_CLS_TIME:
1801     case COL_ABS_TIME:
1802     case COL_ABS_DATE_TIME:
1803     case COL_UTC_TIME:
1804     case COL_UTC_DATE_TIME:
1805     case COL_REL_TIME:
1806     case COL_DELTA_TIME:
1807     case COL_DELTA_TIME_DIS:
1808     case COL_PACKET_LENGTH:
1809     case COL_CUMULATIVE_BYTES:
1810       if (fill_fd_colums)
1811         col_fill_in_frame_data(fdata, cinfo, i, fill_col_exprs);
1812       break;
1813
1814     case COL_INFO:
1815       /* XXX - say more than this */
1816       cinfo->col_data[i] = "Read error";
1817       break;
1818
1819     case NUM_COL_FMTS:  /* keep compiler happy - shouldn't get here */
1820       g_assert_not_reached();
1821       break;
1822     default:
1823       if (cinfo->col_fmt[i] >= NUM_COL_FMTS) {
1824         g_assert_not_reached();
1825       }
1826       /*
1827        * No dissection was done, and these columns are set as the
1828        * result of the dissection, so....
1829        */
1830       cinfo->col_data[i] = "???";
1831       break;
1832     }
1833   }
1834 }
1835
1836 #if 0
1837 XXX this needs more rework?
1838 /* --------------------------- */
1839
1840 static  gchar *
1841 set_addr(address *addr, gboolean is_res)
1842 {
1843   if (addr->type == AT_NONE)
1844     return "";  /* no address, nothing to do */
1845
1846   if (is_res) {
1847     return se_get_addr_name(addr /*, COL_MAX_LEN*/);
1848   }
1849   return se_address_to_str(addr);
1850 }
1851
1852 /* Fills col_text in the frame data structure */
1853 void
1854 col_fill_fdata(packet_info *pinfo)
1855 {
1856   int i;
1857   frame_data *fdata;
1858   gboolean res;
1859
1860   if (!pinfo->cinfo)
1861     return;
1862
1863   fdata = pinfo->fd;
1864
1865   res =FALSE;
1866
1867   for (i = 0; i < pinfo->cinfo->num_cols; i++) {
1868
1869     switch (pinfo->cinfo->col_fmt[i]) {
1870     case COL_NUMBER:           /* frame number */
1871     case COL_PACKET_LENGTH:    /* fd->pkt_len */
1872     case COL_CUMULATIVE_BYTES: /* fd->cum_bytes */
1873     case COL_CLS_TIME:
1874     case COL_ABS_TIME:
1875     case COL_ABS_DATE_TIME:
1876     case COL_UTC_TIME:
1877     case COL_UTC_DATE_TIME:  /* from fd structures */
1878     case COL_REL_TIME:
1879     case COL_DELTA_TIME:
1880     case COL_DELTA_TIME_DIS:
1881       break;
1882
1883     case COL_DEF_SRC:
1884     case COL_RES_SRC:   /* COL_DEF_SRC is currently just like COL_RES_SRC */
1885       res = TRUE;
1886     case COL_UNRES_SRC:
1887       fdata->col_text[i] = set_addr(&pinfo->src, res);
1888       break;
1889
1890     case COL_DEF_DL_SRC:
1891     case COL_RES_DL_SRC:
1892       res = TRUE;
1893     case COL_UNRES_DL_SRC:
1894       fdata->col_text[i] = set_addr (&pinfo->dl_src, res);
1895       break;
1896
1897     case COL_DEF_NET_SRC:
1898     case COL_RES_NET_SRC:
1899       res = TRUE;
1900     case COL_UNRES_NET_SRC:
1901       fdata->col_text[i] = set_addr (&pinfo->net_src, res);
1902       break;
1903
1904     case COL_DEF_DST:
1905     case COL_RES_DST:   /* COL_DEF_DST is currently just like COL_RES_DST */
1906       res = TRUE;
1907     case COL_UNRES_DST:
1908       fdata->col_text[i] = set_addr (&pinfo->dst, res);
1909       break;
1910
1911     case COL_DEF_DL_DST:
1912     case COL_RES_DL_DST:
1913       res = TRUE;
1914     case COL_UNRES_DL_DST:
1915       fdata->col_text[i] = set_addr (&pinfo->dl_dst, res);
1916       break;
1917
1918     case COL_DEF_NET_DST:
1919     case COL_RES_NET_DST:
1920       res = TRUE;
1921     case COL_UNRES_NET_DST:
1922       fdata->col_text[i] = set_addr (&pinfo->net_dst, res);
1923       break;
1924
1925     case COL_DEF_SRC_PORT:
1926     case COL_RES_SRC_PORT:  /* COL_DEF_SRC_PORT is currently just like COL_RES_SRC_PORT */
1927       fdata->col_text[i] = set_port(pinfo, TRUE, pinfo->srcport);
1928       break;
1929     case COL_UNRES_SRC_PORT:
1930       fdata->col_text[i] = set_port(pinfo, FALSE, pinfo->srcport);
1931       break;
1932
1933     case COL_DEF_DST_PORT:
1934     case COL_RES_DST_PORT:  /* COL_DEF_DST_PORT is currently just like COL_RES_DST_PORT */
1935       fdata->col_text[i] = set_port(pinfo, TRUE, pinfo->destport);
1936       break;
1937
1938     case COL_UNRES_DST_PORT:
1939       fdata->col_text[i] = set_port(pinfo, FALSE, pinfo->destport);
1940       break;
1941
1942     case COL_IF_DIR:    /* currently done by dissectors */
1943     case COL_PROTOCOL:
1944     case COL_INFO:
1945     case COL_HPUX_SUBSYS:
1946     case COL_HPUX_DEVID:
1947     case COL_DCE_CALL:
1948     case COL_8021Q_VLAN_ID:
1949     case COL_DSCP_VALUE:
1950     case COL_COS_VALUE:
1951     case COL_FR_DLCI:
1952     case COL_BSSGP_TLLI:
1953     case COL_EXPERT:
1954     case COL_CUSTOM:
1955     case COL_FREQ_CHAN:
1956       if (pinfo->cinfo->col_data[i] != pinfo->cinfo->col_buf[i]) {
1957          /* XXX assume it's a constant */
1958          fdata->col_text[i] = (gchar *)pinfo->cinfo->col_data[i];
1959       }
1960       else {
1961          /* copy */
1962          fdata->col_text[i] = se_strdup(pinfo->cinfo->col_data[i]);
1963       }
1964       break;
1965     case COL_OXID:
1966       fdata->col_text[i] = (gchar *)(GUINT_TO_POINTER((guint)pinfo->oxid));
1967       break;
1968     case COL_RXID:
1969       fdata->col_text[i] = (gchar *)(GUINT_TO_POINTER((guint)pinfo->rxid));
1970       break;
1971     case COL_CIRCUIT_ID:
1972       set_circuit_id(pinfo);
1973       break;
1974     case COL_SRCIDX:
1975       fdata->col_text[i] = (gchar *)(GUINT_TO_POINTER((guint)pinfo->src_idx));
1976       break;
1977     case COL_DSTIDX:
1978       fdata->col_text[i] = (gchar *)(GUINT_TO_POINTER((guint)pinfo->dst_idx));
1979       break;
1980     case COL_VSAN:
1981       fdata->col_text[i] = (gchar *)(GUINT_TO_POINTER((guint)pinfo->vsan));
1982       break;
1983
1984     case NUM_COL_FMTS:  /* keep compiler happy - shouldn't get here */
1985       g_assert_not_reached();
1986       break;
1987     }
1988   }
1989 }
1990
1991 /* XXX Gets/creates the text from col_text in frame data */
1992 /* --------------------- */
1993 gchar *
1994 col_get_text(frame_data *fd, column_info *cinfo, gint col)
1995 {
1996 static gchar fmtbuf[3][COL_MAX_LEN];
1997 static int idx;
1998 gchar  *buf;
1999 gchar  *ptr;
2000
2001     idx = (idx + 1) % 3;
2002     buf = fmtbuf[idx];
2003     *buf = 0;
2004     ptr = buf;
2005
2006     switch (cinfo->col_fmt[col]) {
2007     case COL_NUMBER: /* frame number */
2008       guint32_to_str_buf(fd->num, buf, COL_MAX_LEN);
2009       break;
2010
2011     case COL_CLS_TIME:
2012       set_cls_time(fd, buf);
2013       break;
2014     case COL_ABS_TIME:
2015       set_abs_time(fd, buf, TRUE);
2016       break;
2017     case COL_UTC_TIME:
2018       set_abs_time(fd, buf, FALSE);
2019       break;
2020     case COL_ABS_DATE_TIME:
2021       set_abs_date_time(fd, buf, TRUE);
2022       break;
2023     case COL_UTC_DATE_TIME:
2024       set_abs_date_time(fd, buf, FALSE);
2025       break;
2026     case COL_REL_TIME:
2027       set_rel_time(fd, buf);
2028       break;
2029     case COL_DELTA_TIME:
2030       set_delta_time(fd, buf);
2031       break;
2032     case COL_DELTA_TIME_DIS:
2033       set_delta_time_dis(fd, buf);
2034       break;
2035
2036     case COL_PACKET_LENGTH: /* fd->pkt_len */
2037       guint32_to_str_buf(fd->pkt_len, buf, COL_MAX_LEN);
2038       break;
2039
2040     case COL_CUMULATIVE_BYTES: /* fd->cum_bytes */
2041       guint32_to_str_buf(fd->cum_bytes, buf, COL_MAX_LEN);
2042       break;
2043
2044     case COL_DEF_SRC:
2045     case COL_RES_SRC:   /* network address */
2046     case COL_UNRES_SRC:
2047     case COL_DEF_DL_SRC:
2048     case COL_RES_DL_SRC:
2049     case COL_UNRES_DL_SRC:
2050     case COL_DEF_NET_SRC:
2051     case COL_RES_NET_SRC:
2052     case COL_UNRES_NET_SRC:
2053     case COL_DEF_DST:
2054     case COL_RES_DST:
2055     case COL_UNRES_DST:
2056     case COL_DEF_DL_DST:
2057     case COL_RES_DL_DST:
2058     case COL_UNRES_DL_DST:
2059     case COL_DEF_NET_DST:
2060     case COL_RES_NET_DST:
2061     case COL_UNRES_NET_DST:
2062
2063     case COL_IF_DIR:
2064     case COL_CIRCUIT_ID:
2065     case COL_PROTOCOL:
2066     case COL_INFO:
2067     case COL_HPUX_SUBSYS:
2068     case COL_HPUX_DEVID:
2069     case COL_DCE_CALL:
2070     case COL_8021Q_VLAN_ID:
2071     case COL_DSCP_VALUE:
2072     case COL_COS_VALUE:
2073     case COL_FR_DLCI:
2074     case COL_BSSGP_TLLI:
2075     case COL_EXPERT:
2076     case COL_CUSTOM:
2077     case COL_FREQ_CHAN:
2078       ptr = fd->col_text[col];
2079       break;
2080
2081     case COL_DEF_SRC_PORT:
2082     case COL_RES_SRC_PORT:
2083     case COL_UNRES_SRC_PORT:
2084     case COL_DEF_DST_PORT:
2085     case COL_RES_DST_PORT:
2086     case COL_UNRES_DST_PORT:
2087       /* hack */
2088       if (GPOINTER_TO_UINT(fd->col_text[col]) <= 65536)
2089           guint32_to_str_buf(GPOINTER_TO_UINT(fd->col_text[col], buf, COL_MAX_LEN));
2090       else
2091           ptr = fd->col_text[col];
2092       break;
2093
2094     case COL_OXID:
2095     case COL_RXID:
2096     case COL_SRCIDX:
2097     case COL_DSTIDX:
2098       g_snprintf(buf, COL_MAX_LEN, "0x%x", GPOINTER_TO_UINT(fd->col_text[col]));
2099       break;
2100
2101     case COL_VSAN:
2102       guint32_to_str_buf(GPOINTER_TO_UINT(fd->col_text[col]), buf, COL_MAX_LEN);
2103       break;
2104
2105     case NUM_COL_FMTS:  /* keep compiler happy - shouldn't get here */
2106       g_assert_not_reached();
2107       break;
2108     }
2109     return ptr;
2110 }
2111 #endif