d40c8adba021cbb5480f2fe80cb603e191fb332b
[obnox/wireshark/wip.git] / packet.c
1 /* packet.c
2  * Routines for packet disassembly
3  *
4  * $Id: packet.c,v 1.68 2000/03/26 07:59:47 sharpe Exp $
5  *
6  * Ethereal - Network traffic analyzer
7  * By Gerald Combs <gerald@zing.org>
8  * Copyright 1998 Gerald Combs
9  *
10  * 
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  * 
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  * 
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  */
25
26 #ifdef HAVE_CONFIG_H
27 # include "config.h"
28 #endif
29
30 #ifdef HAVE_SYS_TYPES_H
31 # include <sys/types.h>
32 #endif
33
34 #ifdef HAVE_SYS_SOCKET_H
35 #include <sys/socket.h>
36 #endif
37
38 #ifdef HAVE_WINSOCK_H
39 #include <winsock.h>
40 #endif
41
42 #include <glib.h>
43
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <stdarg.h>
47 #include <string.h>
48 #include <ctype.h>
49 #include <time.h>
50
51 #ifdef NEED_SNPRINTF_H
52 # include "snprintf.h"
53 #endif
54
55 #ifdef HAVE_NETINET_IN_H
56 # include <netinet/in.h>
57 #endif
58
59 #ifdef HAVE_ARPA_INET_H
60 #include <arpa/inet.h>
61 #endif
62
63 #ifdef NEED_INET_V6DEFS_H
64 # include "inet_v6defs.h"
65 #endif
66
67 #include "packet.h"
68 #include "print.h"
69 #include "timestamp.h"
70 #include "file.h"
71
72 #include "packet-ascend.h"
73 #include "packet-atalk.h"
74 #include "packet-atm.h"
75 #include "packet-clip.h"
76 #include "packet-eth.h"
77 #include "packet-fddi.h"
78 #include "packet-ipv6.h"
79 #include "packet-lapb.h"
80 #include "packet-lapd.h"
81 #include "packet-null.h"
82 #include "packet-ppp.h"
83 #include "packet-raw.h"
84 #include "packet-sna.h"
85 #include "packet-tr.h"
86 #include "packet-v120.h"
87 #include "packet-vines.h"
88
89 #ifndef __RESOLV_H__
90 #include "resolv.h"
91 #endif
92
93 extern capture_file  cf;
94
95 static int proto_frame = -1;
96 static int hf_frame_arrival_time = -1;
97 static int hf_frame_time_delta = -1;
98 static int hf_frame_number = -1;
99 static int hf_frame_packet_len = -1;
100 static int hf_frame_capture_len = -1;
101
102 static gint ett_frame = -1;
103
104 /* Wrapper for the most common case of asking
105  * for a string using a colon as the hex-digit separator.
106  */
107 gchar *
108 ether_to_str(const guint8 *ad)
109 {
110         return ether_to_str_punct(ad, ':');
111 }
112
113 /* Places char punct in the string as the hex-digit separator.
114  * If punct is '\0', no punctuation is applied (and thus
115  * the resulting string is 5 bytes shorter)
116  */
117 gchar *
118 ether_to_str_punct(const guint8 *ad, char punct) {
119   static gchar  str[3][18];
120   static gchar *cur;
121   gchar        *p;
122   int          i;
123   guint32      octet;
124   static const gchar hex_digits[16] = "0123456789abcdef";
125
126   if (cur == &str[0][0]) {
127     cur = &str[1][0];
128   } else if (cur == &str[1][0]) {  
129     cur = &str[2][0];
130   } else {  
131     cur = &str[0][0];
132   }
133   p = &cur[18];
134   *--p = '\0';
135   i = 5;
136   for (;;) {
137     octet = ad[i];
138     *--p = hex_digits[octet&0xF];
139     octet >>= 4;
140     *--p = hex_digits[octet&0xF];
141     if (i == 0)
142       break;
143     if (punct)
144       *--p = punct;
145     i--;
146   }
147   return p;
148 }
149
150 gchar *
151 ip_to_str(const guint8 *ad) {
152   static gchar  str[3][16];
153   static gchar *cur;
154   gchar        *p;
155   int           i;
156   guint32       octet;
157   guint32       digit;
158
159   if (cur == &str[0][0]) {
160     cur = &str[1][0];
161   } else if (cur == &str[1][0]) {  
162     cur = &str[2][0];
163   } else {  
164     cur = &str[0][0];
165   }
166   p = &cur[16];
167   *--p = '\0';
168   i = 3;
169   for (;;) {
170     octet = ad[i];
171     *--p = (octet%10) + '0';
172     octet /= 10;
173     digit = octet%10;
174     octet /= 10;
175     if (digit != 0 || octet != 0)
176       *--p = digit + '0';
177     if (octet != 0)
178       *--p = octet + '0';
179     if (i == 0)
180       break;
181     *--p = '.';
182     i--;
183   }
184   return p;
185 }
186
187 gchar *
188 ip6_to_str(struct e_in6_addr *ad) {
189 #ifndef INET6_ADDRSTRLEN
190 #define INET6_ADDRSTRLEN 46
191 #endif
192   static gchar buf[INET6_ADDRSTRLEN];
193
194   inet_ntop(AF_INET6, (u_char*)ad, (gchar*)buf, sizeof(buf));
195   return buf;
196 }
197
198
199 #define PLURALIZE(n)    (((n) > 1) ? "s" : "")
200 #define COMMA(do_it)    ((do_it) ? ", " : "")
201
202 gchar *
203 time_secs_to_str(guint32 time)
204 {
205   static gchar  str[3][8+1+4+2+2+5+2+2+7+2+2+7+1];
206   static gchar *cur, *p;
207   int hours, mins, secs;
208   int do_comma;
209
210   if (cur == &str[0][0]) {
211     cur = &str[1][0];
212   } else if (cur == &str[1][0]) {  
213     cur = &str[2][0];
214   } else {  
215     cur = &str[0][0];
216   }
217
218   if (time == 0) {
219     sprintf(cur, "0 time");
220     return cur;
221   }
222
223   secs = time % 60;
224   time /= 60;
225   mins = time % 60;
226   time /= 60;
227   hours = time % 24;
228   time /= 24;
229
230   p = cur;
231   if (time != 0) {
232     sprintf(p, "%u day%s", time, PLURALIZE(time));
233     p += strlen(p);
234     do_comma = 1;
235   } else
236     do_comma = 0;
237   if (hours != 0) {
238     sprintf(p, "%s%u hour%s", COMMA(do_comma), hours, PLURALIZE(hours));
239     p += strlen(p);
240     do_comma = 1;
241   } else
242     do_comma = 0;
243   if (mins != 0) {
244     sprintf(p, "%s%u minute%s", COMMA(do_comma), mins, PLURALIZE(mins));
245     p += strlen(p);
246     do_comma = 1;
247   } else
248     do_comma = 0;
249   if (secs != 0)
250     sprintf(p, "%s%u second%s", COMMA(do_comma), secs, PLURALIZE(secs));
251   return cur;
252 }
253
254 /* Max string length for displaying byte string.  */
255 #define MAX_BYTE_STR_LEN        32
256
257 /* Turn an array of bytes into a string showing the bytes in hex. */
258 #define N_BYTES_TO_STR_STRINGS  6
259 gchar *
260 bytes_to_str(const guint8 *bd, int bd_len) {
261   static gchar  str[N_BYTES_TO_STR_STRINGS][MAX_BYTE_STR_LEN+3+1];
262   static int    cur_idx;
263   gchar        *cur;
264   gchar        *p;
265   int           len;
266   static const char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
267                                 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
268
269   cur_idx++;
270   if (cur_idx >= N_BYTES_TO_STR_STRINGS)
271     cur_idx = 0;
272   cur = &str[cur_idx][0];
273   p = cur;
274   len = MAX_BYTE_STR_LEN;
275   while (bd_len > 0 && len > 0) {
276     *p++ = hex[(*bd) >> 4];
277     *p++ = hex[(*bd) & 0xF];
278     len -= 2;
279     bd++;
280     bd_len--;
281   }
282   if (bd_len != 0) {
283     /* Note that we're not showing the full string.  */
284     *p++ = '.';
285     *p++ = '.';
286     *p++ = '.';
287   }
288   *p = '\0';
289   return cur;
290 }
291
292 static const char *mon_names[12] = {
293         "Jan",
294         "Feb",
295         "Mar",
296         "Apr",
297         "May",
298         "Jun",
299         "Jul",
300         "Aug",
301         "Sep",
302         "Oct",
303         "Nov",
304         "Dec"
305 };
306
307 gchar *
308 abs_time_to_str(struct timeval *abs_time)
309 {
310         struct tm *tmp;
311         static gchar *cur;
312         static char str[3][3+1+2+2+4+1+2+1+2+1+2+1+4+1 + 5 /* extra */];
313
314         if (cur == &str[0][0]) {
315                 cur = &str[1][0];
316         } else if (cur == &str[1][0]) {
317                 cur = &str[2][0];
318         } else {
319                 cur = &str[0][0];
320         }
321
322         tmp = localtime(&abs_time->tv_sec);
323         sprintf(cur, "%s %2d, %d %02d:%02d:%02d.%04ld",
324             mon_names[tmp->tm_mon],
325             tmp->tm_mday,
326             tmp->tm_year + 1900,
327             tmp->tm_hour,
328             tmp->tm_min,
329             tmp->tm_sec,
330             (long)abs_time->tv_usec/100);
331
332         return cur;
333 }
334
335 gchar *
336 rel_time_to_str(struct timeval *rel_time)
337 {
338         static gchar *cur;
339         static char str[3][10+1+6+1];
340
341         if (cur == &str[0][0]) {
342                 cur = &str[1][0];
343         } else if (cur == &str[1][0]) {
344                 cur = &str[2][0];
345         } else {
346                 cur = &str[0][0];
347         }
348
349         sprintf(cur, "%ld.%06ld", (long)rel_time->tv_sec,
350                 (long)rel_time->tv_usec);
351
352         return cur;
353 }
354
355 /*
356  * Given a pointer into a data buffer, and to the end of the buffer,
357  * find the end of the (putative) line at that position in the data
358  * buffer.
359  * Return a pointer to the EOL character(s) in "*eol".
360  */
361 const u_char *
362 find_line_end(const u_char *data, const u_char *dataend, const u_char **eol)
363 {
364   const u_char *lineend;
365
366   lineend = memchr(data, '\n', dataend - data);
367   if (lineend == NULL) {
368     /*
369      * No LF - line is probably continued in next TCP segment.
370      */
371     lineend = dataend;
372     *eol = dataend;
373   } else {
374     /*
375      * Is the LF at the beginning of the line?
376      */
377     if (lineend > data) {
378       /*
379        * No - is it preceded by a carriage return?
380        * (Perhaps it's supposed to be, but that's not guaranteed....)
381        */
382       if (*(lineend - 1) == '\r') {
383         /*
384          * Yes.  The EOL starts with the CR.
385          */
386         *eol = lineend - 1;
387       } else {
388         /*
389          * No.  The EOL starts with the LF.
390          */
391         *eol = lineend;
392
393         /*
394          * I seem to remember that we once saw lines ending with LF-CR
395          * in an HTTP request or response, so check if it's *followed*
396          * by a carriage return.
397          */
398         if (lineend < (dataend - 1) && *(lineend + 1) == '\r') {
399           /*
400            * It's <non-LF><LF><CR>; say it ends with the CR.
401            */
402           lineend++;
403         }
404       }
405     }
406
407     /*
408      * Point to the character after the last character.
409      */
410     lineend++;
411   }
412   return lineend;
413 }
414
415 #define MAX_COLUMNS_LINE_DETAIL 62
416
417 /*
418  * Get the length of the next token in a line, and the beginning of the
419  * next token after that (if any).
420  * Return 0 if there is no next token.
421  */
422 int
423 get_token_len(const u_char *linep, const u_char *lineend,
424               const u_char **next_token)
425 {
426   const u_char *tokenp;
427   int token_len;
428
429   tokenp = linep;
430   
431   /*
432    * Search for a blank, a CR or an LF, or the end of the buffer.
433    */
434   while (linep < lineend && *linep != ' ' && *linep != '\r' && *linep != '\n')
435       linep++;
436   token_len = linep - tokenp;
437
438   /*
439    * Skip trailing blanks.
440    */
441   while (linep < lineend && *linep == ' ')
442     linep++;
443
444   *next_token = linep;
445
446   return token_len;
447 }
448
449 /*
450  * Given a string, generate a string from it that shows non-printable
451  * characters as C-style escapes, and return a pointer to it.
452  */
453 gchar *
454 format_text(const u_char *string, int len)
455 {
456   static gchar fmtbuf[MAX_COLUMNS_LINE_DETAIL + 3 + 4 + 1];
457   gchar *fmtbufp;
458   int column;
459   const u_char *stringend = string + len;
460   u_char c;
461   int i;
462
463   column = 0;
464   fmtbufp = &fmtbuf[0];
465   while (string < stringend) {
466     if (column >= MAX_COLUMNS_LINE_DETAIL) {
467       /*
468        * Put "..." and quit.
469        */
470       strcpy(fmtbufp, " ...");
471       fmtbufp += 4;
472       break;
473     }
474     c = *string++;
475     if (isprint(c)) {
476       *fmtbufp++ = c;
477       column++;
478     } else {
479       *fmtbufp++ =  '\\';
480       column++;
481       switch (c) {
482
483       case '\\':
484         *fmtbufp++ = '\\';
485         column++;
486         break;
487
488       case '\a':
489         *fmtbufp++ = 'a';
490         column++;
491         break;
492
493       case '\b':
494         *fmtbufp++ = 'b';
495         column++;
496         break;
497
498       case '\f':
499         *fmtbufp++ = 'f';
500         column++;
501         break;
502
503       case '\n':
504         *fmtbufp++ = 'n';
505         column++;
506         break;
507
508       case '\r':
509         *fmtbufp++ = 'r';
510         column++;
511         break;
512
513       case '\t':
514         *fmtbufp++ = 't';
515         column++;
516         break;
517
518       case '\v':
519         *fmtbufp++ = 'v';
520         column++;
521         break;
522
523       default:
524         i = (c>>6)&03;
525         *fmtbufp++ = i + '0';
526         column++;
527         i = (c>>3)&07;
528         *fmtbufp++ = i + '0';
529         column++;
530         i = (c>>0)&07;
531         *fmtbufp++ = i + '0';
532         column++;
533         break;
534       }
535     }
536   }
537   *fmtbufp = '\0';
538   return fmtbuf;
539 }
540
541
542 /* Tries to match val against each element in the value_string array vs.
543    Returns the associated string ptr on a match.
544    Formats val with fmt, and returns the resulting string, on failure. */
545 gchar*
546 val_to_str(guint32 val, const value_string *vs, const char *fmt) {
547   gchar *ret;
548   static gchar  str[3][64];
549   static gchar *cur;
550
551   ret = match_strval(val, vs);
552   if (ret != NULL)
553     return ret;
554   if (cur == &str[0][0]) {
555     cur = &str[1][0];
556   } else if (cur == &str[1][0]) {  
557     cur = &str[2][0];
558   } else {  
559     cur = &str[0][0];
560   }
561   snprintf(cur, 64, fmt, val);
562   return cur;
563 }
564
565 /* Tries to match val against each element in the value_string array vs.
566    Returns the associated string ptr on a match, or NULL on failure. */
567 gchar*
568 match_strval(guint32 val, const value_string *vs) {
569   gint i = 0;
570   
571   while (vs[i].strptr) {
572     if (vs[i].value == val)
573       return(vs[i].strptr);
574     i++;
575   }
576
577   return(NULL);
578 }
579
580 /* Generate, into "buf", a string showing the bits of a bitfield.
581    Return a pointer to the character after that string. */
582 char *
583 decode_bitfield_value(char *buf, guint32 val, guint32 mask, int width)
584 {
585   int i;
586   guint32 bit;
587   char *p;
588
589   i = 0;
590   p = buf;
591   bit = 1 << (width - 1);
592   for (;;) {
593     if (mask & bit) {
594       /* This bit is part of the field.  Show its value. */
595       if (val & bit)
596         *p++ = '1';
597       else
598         *p++ = '0';
599     } else {
600       /* This bit is not part of the field. */
601       *p++ = '.';
602     }
603     bit >>= 1;
604     i++;
605     if (i >= width)
606       break;
607     if (i % 4 == 0)
608       *p++ = ' ';
609   }
610   strcpy(p, " = ");
611   p += 3;
612   return p;
613 }
614
615 /* Generate a string describing a Boolean bitfield (a one-bit field that
616    says something is either true of false). */
617 const char *
618 decode_boolean_bitfield(guint32 val, guint32 mask, int width,
619     const char *truedesc, const char *falsedesc)
620 {
621   static char buf[1025];
622   char *p;
623
624   p = decode_bitfield_value(buf, val, mask, width);
625   if (val & mask)
626     strcpy(p, truedesc);
627   else
628     strcpy(p, falsedesc);
629   return buf;
630 }
631
632 /* Generate a string describing an enumerated bitfield (an N-bit field
633    with various specific values having particular names). */
634 const char *
635 decode_enumerated_bitfield(guint32 val, guint32 mask, int width,
636     const value_string *tab, const char *fmt)
637 {
638   static char buf[1025];
639   char *p;
640
641   p = decode_bitfield_value(buf, val, mask, width);
642   sprintf(p, fmt, val_to_str(val & mask, tab, "Unknown"));
643   return buf;
644 }
645
646 /* Generate a string describing a numeric bitfield (an N-bit field whose
647    value is just a number). */
648 const char *
649 decode_numeric_bitfield(guint32 val, guint32 mask, int width,
650     const char *fmt)
651 {
652   static char buf[1025];
653   char *p;
654   int shift = 0;
655
656   /* Compute the number of bits we have to shift the bitfield right
657      to extract its value. */
658   while ((mask & (1<<shift)) == 0)
659     shift++;
660
661   p = decode_bitfield_value(buf, val, mask, width);
662   sprintf(p, fmt, (val & mask) >> shift);
663   return buf;
664 }
665
666 /* Checks to see if a particular packet information element is needed for
667    the packet list */
668 gint
669 check_col(frame_data *fd, gint el) {
670   int i;
671
672   if (fd->cinfo) {
673     for (i = 0; i < fd->cinfo->num_cols; i++) {
674       if (fd->cinfo->fmt_matx[i][el])
675         return TRUE;
676     }
677   }
678   return FALSE;
679 }
680
681 /* Adds a vararg list to a packet info string. */
682 void
683 col_add_fstr(frame_data *fd, gint el, gchar *format, ...) {
684   va_list ap;
685   int     i;
686   size_t  max_len;
687   
688   va_start(ap, format);
689   for (i = 0; i < fd->cinfo->num_cols; i++) {
690     if (fd->cinfo->fmt_matx[i][el]) {
691       if (el == COL_INFO)
692         max_len = COL_MAX_INFO_LEN;
693       else
694         max_len = COL_MAX_LEN;
695       vsnprintf(fd->cinfo->col_data[i], max_len, format, ap);
696     }
697   }
698 }
699
700 void
701 col_add_str(frame_data *fd, gint el, const gchar* str) {
702   int    i;
703   size_t max_len;
704
705   for (i = 0; i < fd->cinfo->num_cols; i++) {
706     if (fd->cinfo->fmt_matx[i][el]) {
707       if (el == COL_INFO)
708         max_len = COL_MAX_INFO_LEN;
709       else
710         max_len = COL_MAX_LEN;
711       strncpy(fd->cinfo->col_data[i], str, max_len);
712       fd->cinfo->col_data[i][max_len - 1] = 0;
713     }
714   }
715 }
716
717 /* Appends a vararg list to a packet info string. */
718 void
719 col_append_fstr(frame_data *fd, gint el, gchar *format, ...) {
720   va_list ap;
721   int     i;
722   size_t  len, max_len;
723   
724   va_start(ap, format);
725   for (i = 0; i < fd->cinfo->num_cols; i++) {
726     if (fd->cinfo->fmt_matx[i][el]) {
727       len = strlen(fd->cinfo->col_data[i]);
728       if (el == COL_INFO)
729         max_len = COL_MAX_INFO_LEN;
730       else
731         max_len = COL_MAX_LEN;
732       vsnprintf(&fd->cinfo->col_data[i][len], max_len - len, format, ap);
733     }
734   }
735 }
736
737 void
738 col_append_str(frame_data *fd, gint el, gchar* str) {
739   int    i;
740   size_t len, max_len;
741
742   for (i = 0; i < fd->cinfo->num_cols; i++) {
743     if (fd->cinfo->fmt_matx[i][el]) {
744       len = strlen(fd->cinfo->col_data[i]);
745       if (el == COL_INFO)
746         max_len = COL_MAX_LEN;
747       else
748         max_len = COL_MAX_INFO_LEN;
749       strncat(fd->cinfo->col_data[i], str, max_len - len);
750       fd->cinfo->col_data[i][max_len - 1] = 0;
751     }
752   }
753 }
754
755 /* To do: Add check_col checks to the col_add* routines */
756
757 static void
758 col_set_abs_time(frame_data *fd, int col)
759 {
760   struct tm *tmp;
761   time_t then;
762
763   then = fd->abs_secs;
764   tmp = localtime(&then);
765   snprintf(fd->cinfo->col_data[col], COL_MAX_LEN, "%02d:%02d:%02d.%04ld",
766     tmp->tm_hour,
767     tmp->tm_min,
768     tmp->tm_sec,
769     (long)fd->abs_usecs/100);
770 }
771
772 static void
773 col_set_rel_time(frame_data *fd, int col)
774 {
775   snprintf(fd->cinfo->col_data[col], COL_MAX_LEN, "%d.%06d", fd->rel_secs,
776     fd->rel_usecs);
777 }
778
779 static void
780 col_set_delta_time(frame_data *fd, int col)
781 {
782   snprintf(fd->cinfo->col_data[col], COL_MAX_LEN, "%d.%06d", fd->del_secs,
783     fd->del_usecs);
784 }
785
786 /* Add "command-line-specified" time.
787    XXX - this is called from "file.c" when the user changes the time
788    format they want for "command-line-specified" time; it's a bit ugly
789    that we have to export it, but if we go to a CList-like widget that
790    invokes callbacks to get the text for the columns rather than
791    requiring us to stuff the text into the widget from outside, we
792    might be able to clean this up. */
793 void
794 col_set_cls_time(frame_data *fd, int col)
795 {
796   switch (timestamp_type) {
797     case ABSOLUTE:
798       col_set_abs_time(fd, col);
799       break;
800
801     case RELATIVE:
802       col_set_rel_time(fd, col);
803       break;
804
805     case DELTA:
806       col_set_delta_time(fd, col);
807       break;
808   }
809 }
810
811 static void
812 col_set_addr(frame_data *fd, int col, address *addr, gboolean is_res)
813 {
814   u_int ipv4_addr;
815   struct e_in6_addr ipv6_addr;
816   struct atalk_ddp_addr ddp_addr;
817   struct sna_fid_type_4_addr sna_fid_type_4_addr;
818
819   switch (addr->type) {
820
821   case AT_ETHER:
822     if (is_res)
823       strncpy(fd->cinfo->col_data[col], get_ether_name(addr->data), COL_MAX_LEN);
824     else
825       strncpy(fd->cinfo->col_data[col], ether_to_str(addr->data), COL_MAX_LEN);
826     break;
827
828   case AT_IPv4:
829     memcpy(&ipv4_addr, addr->data, sizeof ipv4_addr);
830     if (is_res)
831       strncpy(fd->cinfo->col_data[col], get_hostname(ipv4_addr), COL_MAX_LEN);
832     else
833       strncpy(fd->cinfo->col_data[col], ip_to_str(addr->data), COL_MAX_LEN);
834     break;
835
836   case AT_IPv6:
837     memcpy(&ipv6_addr.s6_addr, addr->data, sizeof ipv6_addr.s6_addr);
838     if (is_res)
839       strncpy(fd->cinfo->col_data[col], get_hostname6(&ipv6_addr), COL_MAX_LEN);
840     else
841       strncpy(fd->cinfo->col_data[col], ip6_to_str(&ipv6_addr), COL_MAX_LEN);
842     break;
843
844   case AT_IPX:
845     strncpy(fd->cinfo->col_data[col],
846       ipx_addr_to_str(pntohl(&addr->data[0]), &addr->data[4]), COL_MAX_LEN);
847     break;
848
849   case AT_SNA:
850     switch (addr->len) {
851
852     case 1:
853       snprintf(fd->cinfo->col_data[col], COL_MAX_LEN, "%04X", addr->data[0]);
854       break;
855
856     case 2:
857       snprintf(fd->cinfo->col_data[col], COL_MAX_LEN, "%04X",
858         pntohs(&addr->data[0]));
859       break;
860
861     case SNA_FID_TYPE_4_ADDR_LEN:
862       memcpy(&sna_fid_type_4_addr, addr->data, SNA_FID_TYPE_4_ADDR_LEN);
863       strncpy(fd->cinfo->col_data[col],
864         sna_fid_type_4_addr_to_str(&sna_fid_type_4_addr), COL_MAX_LEN);
865       break;
866     }
867     break;
868
869   case AT_ATALK:
870     memcpy(&ddp_addr, addr->data, sizeof ddp_addr);
871     strncpy(fd->cinfo->col_data[col], atalk_addr_to_str(&ddp_addr),
872       COL_MAX_LEN);
873     break;
874
875   case AT_VINES:
876     strncpy(fd->cinfo->col_data[col], vines_addr_to_str(&addr->data[0]),
877       COL_MAX_LEN);
878     break;
879
880   default:
881     break;
882   }
883   fd->cinfo->col_data[col][COL_MAX_LEN - 1] = '\0';
884 }
885
886 static void
887 col_set_port(frame_data *fd, int col, port_type ptype, guint32 port,
888                 gboolean is_res)
889 {
890   switch (ptype) {
891
892   case PT_TCP:
893     if (is_res)
894       strncpy(fd->cinfo->col_data[col], get_tcp_port(port), COL_MAX_LEN);
895     else
896       snprintf(fd->cinfo->col_data[col], COL_MAX_LEN, "%u", port);
897     break;
898
899   case PT_UDP:
900     if (is_res)
901       strncpy(fd->cinfo->col_data[col], get_udp_port(port), COL_MAX_LEN);
902     else
903       snprintf(fd->cinfo->col_data[col], COL_MAX_LEN, "%u", port);
904     break;
905
906   default:
907     break;
908   }
909   fd->cinfo->col_data[col][COL_MAX_LEN - 1] = '\0';
910 }
911
912 void
913 fill_in_columns(frame_data *fd)
914 {
915   int i;
916
917   for (i = 0; i < fd->cinfo->num_cols; i++) {
918     switch (fd->cinfo->col_fmt[i]) {
919
920     case COL_NUMBER:
921       snprintf(fd->cinfo->col_data[i], COL_MAX_LEN, "%u", fd->num);
922       break;
923
924     case COL_CLS_TIME:
925       col_set_cls_time(fd, i);
926       break;
927
928     case COL_ABS_TIME:
929       col_set_abs_time(fd, i);
930       break;
931
932     case COL_REL_TIME:
933       col_set_rel_time(fd, i);
934       break;
935
936     case COL_DELTA_TIME:
937       col_set_delta_time(fd, i);
938       break;
939
940     case COL_DEF_SRC:
941     case COL_RES_SRC:   /* COL_DEF_SRC is currently just like COL_RES_SRC */
942       col_set_addr(fd, i, &pi.src, TRUE);
943       break;
944
945     case COL_UNRES_SRC:
946       col_set_addr(fd, i, &pi.src, FALSE);
947       break;
948
949     case COL_DEF_DL_SRC:
950     case COL_RES_DL_SRC:
951       col_set_addr(fd, i, &pi.dl_src, TRUE);
952       break;
953
954     case COL_UNRES_DL_SRC:
955       col_set_addr(fd, i, &pi.dl_src, FALSE);
956       break;
957
958     case COL_DEF_NET_SRC:
959     case COL_RES_NET_SRC:
960       col_set_addr(fd, i, &pi.net_src, TRUE);
961       break;
962
963     case COL_UNRES_NET_SRC:
964       col_set_addr(fd, i, &pi.net_src, FALSE);
965       break;
966
967     case COL_DEF_DST:
968     case COL_RES_DST:   /* COL_DEF_DST is currently just like COL_RES_DST */
969       col_set_addr(fd, i, &pi.dst, TRUE);
970       break;
971
972     case COL_UNRES_DST:
973       col_set_addr(fd, i, &pi.dst, FALSE);
974       break;
975
976     case COL_DEF_DL_DST:
977     case COL_RES_DL_DST:
978       col_set_addr(fd, i, &pi.dl_dst, TRUE);
979       break;
980
981     case COL_UNRES_DL_DST:
982       col_set_addr(fd, i, &pi.dl_dst, FALSE);
983       break;
984
985     case COL_DEF_NET_DST:
986     case COL_RES_NET_DST:
987       col_set_addr(fd, i, &pi.net_dst, TRUE);
988       break;
989
990     case COL_UNRES_NET_DST:
991       col_set_addr(fd, i, &pi.net_dst, FALSE);
992       break;
993
994     case COL_DEF_SRC_PORT:
995     case COL_RES_SRC_PORT:      /* COL_DEF_SRC_PORT is currently just like COL_RES_SRC_PORT */
996       col_set_port(fd, i, pi.ptype, pi.srcport, TRUE);
997       break;
998
999     case COL_UNRES_SRC_PORT:
1000       col_set_port(fd, i, pi.ptype, pi.srcport, FALSE);
1001       break;
1002
1003     case COL_DEF_DST_PORT:
1004     case COL_RES_DST_PORT:      /* COL_DEF_DST_PORT is currently just like COL_RES_DST_PORT */
1005       col_set_port(fd, i, pi.ptype, pi.destport, TRUE);
1006       break;
1007
1008     case COL_UNRES_DST_PORT:
1009       col_set_port(fd, i, pi.ptype, pi.destport, FALSE);
1010       break;
1011
1012     case COL_PROTOCOL:  /* currently done by dissectors */
1013     case COL_INFO:      /* currently done by dissectors */
1014       break;
1015
1016     case COL_PACKET_LENGTH:
1017       snprintf(fd->cinfo->col_data[i], COL_MAX_LEN, "%d", fd->pkt_len);
1018       break;
1019
1020     case NUM_COL_FMTS:  /* keep compiler happy - shouldn't get here */
1021       break;
1022     }
1023   }
1024 }
1025         
1026 void blank_packetinfo(void)
1027 {
1028   pi.dl_src.type = AT_NONE;
1029   pi.dl_dst.type = AT_NONE;
1030   pi.net_src.type = AT_NONE;
1031   pi.net_dst.type = AT_NONE;
1032   pi.src.type = AT_NONE;
1033   pi.dst.type = AT_NONE;
1034   pi.ipproto  = 0;
1035   pi.ptype = PT_NONE;
1036   pi.srcport  = 0;
1037   pi.destport = 0;
1038 }
1039
1040 /* Allow protocols to register "init" routines, which are called before
1041    we make a pass through a capture file and dissect all its packets
1042    (e.g., when we read in a new capture file, or run a "filter packets"
1043    or "colorize packets" pass over the current capture file). */
1044 static GSList *init_routines;
1045
1046 void
1047 register_init_routine(void (*func)(void))
1048 {
1049         init_routines = g_slist_append(init_routines, func);
1050 }
1051
1052 /* Call all the registered "init" routines. */
1053 static void
1054 call_init_routine(gpointer routine, gpointer dummy)
1055 {
1056         void (*func)(void) = routine;
1057
1058         (*func)();
1059 }
1060
1061 void
1062 init_all_protocols(void)
1063 {
1064         g_slist_foreach(init_routines, &call_init_routine, NULL);
1065 }
1066
1067 /* this routine checks the frame type from the cf structure */
1068 void
1069 dissect_packet(const u_char *pd, frame_data *fd, proto_tree *tree)
1070 {
1071         proto_tree *fh_tree;
1072         proto_item *ti;
1073         struct timeval tv;
1074
1075         /* Put in frame header information. */
1076         if (tree) {
1077           ti = proto_tree_add_protocol_format(tree, proto_frame, 0, fd->cap_len,
1078             "Frame %u (%u on wire, %u captured)", fd->num,
1079             fd->pkt_len, fd->cap_len);
1080
1081           fh_tree = proto_item_add_subtree(ti, ett_frame);
1082
1083           tv.tv_sec = fd->abs_secs;
1084           tv.tv_usec = fd->abs_usecs;
1085
1086           proto_tree_add_item(fh_tree, hf_frame_arrival_time,
1087                 0, 0, &tv);
1088
1089           tv.tv_sec = fd->del_secs;
1090           tv.tv_usec = fd->del_usecs;
1091
1092           proto_tree_add_item(fh_tree, hf_frame_time_delta,
1093                 0, 0, &tv);
1094
1095           proto_tree_add_item(fh_tree, hf_frame_number,
1096                 0, 0, fd->num);
1097
1098           proto_tree_add_uint_format(fh_tree, hf_frame_packet_len,
1099                 0, 0, fd->pkt_len, "Packet Length: %d byte%s", fd->pkt_len,
1100                 plurality(fd->pkt_len, "", "s"));
1101                 
1102           proto_tree_add_uint_format(fh_tree, hf_frame_capture_len,
1103                 0, 0, fd->cap_len, "Capture Length: %d byte%s", fd->cap_len,
1104                 plurality(fd->cap_len, "", "s"));
1105         }
1106
1107         blank_packetinfo();
1108
1109         /* Set the initial payload to the packet length, and the initial
1110            captured payload to the capture length (other protocols may
1111            reduce them if their headers say they're less). */
1112         pi.len = fd->pkt_len;
1113         pi.captured_len = fd->cap_len;
1114
1115         switch (fd->lnk_t) {
1116                 case WTAP_ENCAP_ETHERNET :
1117                         dissect_eth(pd, 0, fd, tree);
1118                         break;
1119                 case WTAP_ENCAP_FDDI :
1120                         dissect_fddi(pd, fd, tree, FALSE);
1121                         break;
1122                 case WTAP_ENCAP_FDDI_BITSWAPPED :
1123                         dissect_fddi(pd, fd, tree, TRUE);
1124                         break;
1125                 case WTAP_ENCAP_TR :
1126                         dissect_tr(pd, 0, fd, tree);
1127                         break;
1128                 case WTAP_ENCAP_NULL :
1129                         dissect_null(pd, fd, tree);
1130                         break;
1131                 case WTAP_ENCAP_PPP :
1132                         dissect_ppp(pd, fd, tree);
1133                         break;
1134                 case WTAP_ENCAP_LAPB :
1135                         dissect_lapb(pd, fd, tree);
1136                         break;
1137                 case WTAP_ENCAP_RAW_IP :
1138                         dissect_raw(pd, fd, tree);
1139                         break;
1140                 case WTAP_ENCAP_LINUX_ATM_CLIP :
1141                         dissect_clip(pd, fd, tree);
1142                         break;
1143                 case WTAP_ENCAP_ATM_SNIFFER :
1144                         dissect_atm(pd, fd, tree);
1145                         break;
1146                 case WTAP_ENCAP_ASCEND :
1147                         dissect_ascend(pd, fd, tree);
1148                         break;
1149                 case WTAP_ENCAP_LAPD :
1150                         dissect_lapd(pd, fd, tree);
1151                         break;
1152                 case WTAP_ENCAP_V120 :
1153                         dissect_v120(pd, fd, tree);
1154                         break;
1155         }
1156 }
1157
1158 gint p_compare(gconstpointer a, gconstpointer b)
1159 {
1160
1161   if (((frame_proto_data *)a) -> proto > ((frame_proto_data *)b) -> proto)
1162     return 1;
1163   else if (((frame_proto_data *)a) -> proto == ((frame_proto_data *)b) -> proto)
1164     return 0;
1165   else
1166     return -1;
1167
1168 }
1169
1170 void
1171 p_add_proto_data(frame_data *fd, int proto, void *proto_data)
1172 {
1173   frame_proto_data *p1 = malloc(sizeof(frame_proto_data)); /* FIXME */
1174  
1175   g_assert(p1 != NULL);
1176
1177   p1 -> proto = proto;
1178   p1 -> proto_data = proto_data;
1179
1180   /* Allocate a frame_proto_data struct and then add it to the GSLIST */
1181
1182
1183   fd -> pfd = g_slist_insert_sorted(fd -> pfd,
1184                                     (gpointer *)p1,
1185                                     p_compare);
1186
1187 }
1188
1189 void *
1190 p_get_proto_data(frame_data *fd, int proto)
1191 {
1192   frame_proto_data temp;
1193   GSList *item;
1194
1195   temp.proto = proto;
1196   temp.proto_data = NULL;
1197
1198   item = g_slist_find_custom(fd->pfd, (gpointer *)&temp, p_compare);
1199
1200   if (item) return (void *)item->data;
1201
1202   return NULL;
1203
1204 }
1205
1206 void
1207 p_rem_proto_data(frame_data *fd, int proto)
1208 {
1209
1210
1211 }
1212
1213 void
1214 proto_register_frame(void)
1215 {
1216         static hf_register_info hf[] = {
1217                 { &hf_frame_arrival_time,
1218                 { "Arrival Time",               "frame.time", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x0,
1219                         ""}},
1220
1221                 { &hf_frame_time_delta,
1222                 { "Time delta from previous packet",    "frame.time_delta", FT_RELATIVE_TIME, BASE_NONE, NULL,
1223                         0x0,
1224                         "" }},
1225
1226                 { &hf_frame_number,
1227                 { "Frame Number",               "frame.number", FT_UINT32, BASE_DEC, NULL, 0x0,
1228                         "" }},
1229
1230                 { &hf_frame_packet_len,
1231                 { "Total Frame Length",         "frame.pkt_len", FT_UINT32, BASE_DEC, NULL, 0x0,
1232                         "" }},
1233
1234                 { &hf_frame_capture_len,
1235                 { "Capture Frame Length",       "frame.cap_len", FT_UINT32, BASE_DEC, NULL, 0x0,
1236                         "" }},
1237         };
1238         static gint *ett[] = {
1239                 &ett_frame,
1240         };
1241
1242         proto_frame = proto_register_protocol("Frame", "frame");
1243         proto_register_field_array(proto_frame, hf, array_length(hf));
1244         proto_register_subtree_array(ett, array_length(ett));
1245 }