Added Nathan's patch for AFS and RX dissection.
[obnox/wireshark/wip.git] / packet-udp.c
1 /* packet-udp.c
2  * Routines for UDP packet disassembly
3  *
4  * $Id: packet-udp.c,v 1.30 1999/10/20 16:41:19 gram Exp $
5  *
6  * Ethereal - Network traffic analyzer
7  * By Gerald Combs <gerald@zing.org>
8  * Copyright 1998 Gerald Combs
9  *
10  * Richard Sharpe, 13-Feb-1999, added dispatch table support and 
11  *                              support for tftp.
12  * 
13  * This program is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU General Public License
15  * as published by the Free Software Foundation; either version 2
16  * of the License, or (at your option) any later version.
17  * 
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  * 
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
26  */
27  
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #ifdef HAVE_SYS_TYPES_H
33 # include <sys/types.h>
34 #endif
35
36 #ifdef HAVE_NETINET_IN_H
37 # include <netinet/in.h>
38 #endif
39
40 #include <stdio.h>
41 #include <stdlib.h>
42
43 #include <glib.h>
44 #include "packet.h"
45 #include "resolv.h"
46
47 int proto_udp = -1;             
48 int hf_udp_srcport = -1;
49 int hf_udp_dstport = -1;
50 int hf_udp_port = -1;
51 int hf_udp_length = -1;
52 int hf_udp_checksum = -1;
53
54 /* UDP structs and definitions */
55
56 typedef struct _e_udphdr {
57   guint16 uh_sport;
58   guint16 uh_dport;
59   guint16 uh_ulen;
60   guint16 uh_sum;
61 } e_udphdr;
62
63 /* UDP Ports -> should go in packet-udp.h */
64
65 #define UDP_PORT_DNS     53
66 #define UDP_PORT_BOOTPS  67
67 #define UDP_PORT_TFTP    69
68 #define UDP_PORT_IPX    213
69 #define UDP_PORT_NTP    123
70 #define UDP_PORT_NBNS   137
71 #define UDP_PORT_NBDGM  138
72 #define UDP_PORT_SNMP   161
73 #define UDP_PORT_ISAKMP 500
74 #define UDP_PORT_RIP    520
75 #define UDP_PORT_RIPNG  521
76 #define UDP_PORT_VINES  573
77 #define UDP_PORT_RADIUS 1645
78 #define UDP_PORT_RADIUS_NEW 1812
79 #define UDP_PORT_RADACCT 1646
80 #define UDP_PORT_RADACCT_NEW 1813
81 #define UDP_PORT_ICP    3130
82 #define UDP_PORT_RX_LOW 7000
83 #define UDP_PORT_RX_HIGH 7009
84 #define UDP_PORT_RX_AFS_BACKUPS 7021
85
86 struct hash_struct {
87   guint16 proto;
88   void (*dissect)(const u_char *, int, frame_data *, proto_tree *);
89   struct hash_struct *next;
90 };
91
92 static struct hash_struct *hash_table[256];
93
94 /*
95  * These routines are for UDP, will be generalized soon: RJS
96  *
97  * XXX - note that they should probably check the IP address as well as
98  * the port number, so that we don't mistakenly identify packets as, say,
99  * TFTP, merely because they have a source or destination port number
100  * equal to the port being used by a TFTP daemon on some machine other
101  * than the one they're going to or from.
102  */
103
104 struct hash_struct *udp_find_hash_ent(guint16 proto) {
105
106   int idx = proto % 256;
107   struct hash_struct *hash_ent = hash_table[idx];
108
109   while (hash_ent != NULL) {
110
111     if (hash_ent -> proto == proto)
112       return hash_ent;
113   
114     hash_ent = hash_ent -> next;
115
116   }
117
118   return NULL;
119
120 }
121
122 void udp_hash_add(guint16 proto,
123         void (*dissect)(const u_char *, int, frame_data *, proto_tree *)) {
124
125   int idx = proto % 256;   /* Simply take the remainder, hope for no collisions */
126   struct hash_struct *hash_ent = (struct hash_struct *)malloc(sizeof(struct hash_struct));
127   struct hash_struct *hash_ent2;
128   
129   hash_ent -> proto = proto;
130   hash_ent -> dissect = dissect;
131   hash_ent -> next = NULL;
132
133   if (hash_ent == NULL) {
134
135     fprintf(stderr, "Could not allocate space for hash structure in dissect_udp\n");
136     exit(1);
137   }
138
139   if (hash_table[idx]) {  /* Something, add on end */
140
141     hash_ent2 = hash_table[idx];
142
143     while (hash_ent2 -> next != NULL)
144       hash_ent2 = hash_ent2 -> next;
145
146     hash_ent2 -> next = hash_ent;     /* Bad in pathalogical cases */
147
148   }
149   else {
150
151     hash_table[idx] = hash_ent;
152
153   }
154
155 }
156
157 void init_dissect_udp(void) {
158
159   int i;
160
161   for (i = 0; i < 256; i++) {
162
163     hash_table[i] = NULL;
164
165   }
166
167   /* Now add the protocols we know about */
168
169   udp_hash_add(UDP_PORT_BOOTPS, dissect_bootp);
170   udp_hash_add(UDP_PORT_TFTP, dissect_tftp);
171
172 }
173
174 void
175 dissect_udp(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
176   e_udphdr  uh;
177   guint16    uh_sport, uh_dport, uh_ulen, uh_sum;
178   struct hash_struct *dissect_routine = NULL;
179   proto_tree *udp_tree;
180   proto_item *ti;
181
182   if (!BYTES_ARE_IN_FRAME(offset, sizeof(e_udphdr))) {
183     dissect_data(pd, offset, fd, tree);
184     return;
185   }
186
187   /* Avoids alignment problems on many architectures. */
188   memcpy(&uh, &pd[offset], sizeof(e_udphdr));
189   uh_sport = ntohs(uh.uh_sport);
190   uh_dport = ntohs(uh.uh_dport);
191   uh_ulen  = ntohs(uh.uh_ulen);
192   uh_sum   = ntohs(uh.uh_sum);
193   
194   if (check_col(fd, COL_PROTOCOL))
195     col_add_str(fd, COL_PROTOCOL, "UDP");
196   if (check_col(fd, COL_INFO))
197     col_add_fstr(fd, COL_INFO, "Source port: %s  Destination port: %s",
198             get_udp_port(uh_sport), get_udp_port(uh_dport));
199   if (check_col(fd, COL_RES_SRC_PORT))
200     col_add_str(fd, COL_RES_SRC_PORT, get_udp_port(uh_sport));
201   if (check_col(fd, COL_UNRES_SRC_PORT))
202     col_add_fstr(fd, COL_UNRES_SRC_PORT, "%u", uh_sport);
203   if (check_col(fd, COL_RES_DST_PORT))
204     col_add_str(fd, COL_RES_DST_PORT, get_udp_port(uh_dport));
205   if (check_col(fd, COL_UNRES_DST_PORT))
206     col_add_fstr(fd, COL_UNRES_DST_PORT, "%u", uh_dport);
207     
208   if (tree) {
209     ti = proto_tree_add_item(tree, proto_udp, offset, 8);
210     udp_tree = proto_item_add_subtree(ti, ETT_UDP);
211
212     proto_tree_add_item_format(udp_tree, hf_udp_srcport, offset, 2, uh_sport,
213         "Source port: %s (%u)", get_udp_port(uh_sport), uh_sport);
214     proto_tree_add_item_format(udp_tree, hf_udp_dstport, offset + 2, 2, uh_dport,
215         "Destination port: %s (%u)", get_udp_port(uh_dport), uh_dport);
216
217     proto_tree_add_item_hidden(udp_tree, hf_udp_port, offset, 2, uh_sport);
218     proto_tree_add_item_hidden(udp_tree, hf_udp_port, offset+2, 2, uh_dport);
219
220     proto_tree_add_item(udp_tree, hf_udp_length, offset + 4, 2,  uh_ulen);
221     proto_tree_add_item_format(udp_tree, hf_udp_checksum, offset + 6, 2, uh_sum,
222         "Checksum: 0x%04x", uh_sum);
223   }
224
225   /* Skip over header */
226   offset += 8;
227
228  pi.srcport = uh_sport;
229  pi.destport = uh_dport;
230
231   /* XXX - we should do all of this through the table of ports. */
232 #define PORT_IS(port)   (uh_sport == port || uh_dport == port)
233  if (PORT_IS(UDP_PORT_BOOTPS))
234       dissect_bootp(pd, offset, fd, tree);
235  else if (PORT_IS(UDP_PORT_DNS))
236       dissect_dns(pd, offset, fd, tree);
237  else if (PORT_IS(UDP_PORT_ISAKMP))
238       dissect_isakmp(pd, offset, fd, tree);
239  else if (PORT_IS(UDP_PORT_RIP)) {
240       /* we should check the source port too (RIP: UDP src and dst port 520) */
241       dissect_rip(pd, offset, fd, tree);
242  } else if (PORT_IS(UDP_PORT_RIPNG))
243       dissect_ripng(pd, offset, fd, tree);
244  else if (PORT_IS(UDP_PORT_NBNS))
245       dissect_nbns(pd, offset, fd, tree);
246  else if (PORT_IS(UDP_PORT_NBDGM))
247       dissect_nbdgm(pd, offset, fd, tree);
248  else if (PORT_IS(UDP_PORT_NTP))
249       dissect_ntp(pd, offset, fd, tree);
250  else if (PORT_IS(UDP_PORT_IPX)) /* RFC 1234 */
251       dissect_ipx(pd, offset, fd, tree);
252  else if ((uh_sport >= UDP_PORT_RX_LOW && uh_sport <= UDP_PORT_RX_HIGH) ||
253         (uh_dport >= UDP_PORT_RX_LOW && uh_dport <= UDP_PORT_RX_HIGH) ||
254         PORT_IS(UDP_PORT_RX_AFS_BACKUPS)) 
255       dissect_rx(pd, offset, fd, tree); /* transarc AFS's RX protocol */
256 #if defined(HAVE_UCD_SNMP_SNMP_H) || defined(HAVE_SNMP_SNMP_H)
257  else if (PORT_IS(UDP_PORT_SNMP))
258       dissect_snmp(pd, offset, fd, tree);
259 #endif
260  else if (PORT_IS(UDP_PORT_VINES)) {
261       /* FIXME: AFAIK, src and dst port must be the same */
262       dissect_vines_frp(pd, offset, fd, tree);
263  } else if (PORT_IS(UDP_PORT_TFTP)) {
264       /* This is the first point of call, but it adds a dynamic call */
265       udp_hash_add(MAX(uh_sport, uh_dport), dissect_tftp);  /* Add to table */
266       dissect_tftp(pd, offset, fd, tree);
267  } else if (PORT_IS(UDP_PORT_RADIUS) ||
268                 PORT_IS(UDP_PORT_RADACCT) ||
269                 PORT_IS(UDP_PORT_RADIUS_NEW) ||
270                 PORT_IS(UDP_PORT_RADACCT_NEW) ) {
271       dissect_radius(pd, offset, fd, tree);
272  } else if ( PORT_IS(UDP_PORT_ICP)) {
273         dissect_icp(pd,offset,fd,tree);
274  } else {
275       /* OK, find a routine in the table, else use the default */
276
277       if ((dissect_routine = udp_find_hash_ent(uh_sport))) {
278
279         struct hash_struct *dr2 = udp_find_hash_ent(uh_dport);
280
281         if (dr2 == NULL) {  /* Not in the table, add */
282
283           udp_hash_add(uh_dport, dissect_tftp);
284
285         }
286
287         dissect_routine -> dissect(pd, offset, fd, tree);
288       }
289       else if ((dissect_routine = udp_find_hash_ent(uh_dport))) {
290
291         dissect_routine -> dissect(pd, offset, fd, tree);
292
293       }
294       else {
295
296         dissect_data(pd, offset, fd, tree);
297       }
298   }
299 }
300
301 void
302 proto_register_udp(void)
303 {
304         static hf_register_info hf[] = {
305                 { &hf_udp_srcport,
306                 { "Source Port",        "udp.srcport", FT_UINT16, BASE_DEC, NULL, 0x0,
307                         "" }},
308
309                 { &hf_udp_dstport,
310                 { "Destination Port",   "udp.dstport", FT_UINT16, BASE_DEC, NULL, 0x0,
311                         "" }},
312
313                 { &hf_udp_port,
314                 { "Source or Destination Port", "udp.port", FT_UINT16, BASE_DEC,  NULL, 0x0,
315                         "" }},
316
317                 { &hf_udp_length,
318                 { "Length",             "udp.length", FT_UINT16, BASE_DEC, NULL, 0x0,
319                         "" }},
320
321                 { &hf_udp_checksum,
322                 { "Checksum",           "udp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
323                         "" }},
324         };
325
326         proto_udp = proto_register_protocol("User Datagram Protocol", "udp");
327         proto_register_field_array(proto_udp, hf, array_length(hf));
328 }
329