Decode SMB requests inside NetBIOS Datagram Service packets.
[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.15 1999/05/10 21:50:12 guy 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 extern packet_info pi;
48
49 /* UDP structs and definitions */
50
51 typedef struct _e_udphdr {
52   guint16 uh_sport;
53   guint16 uh_dport;
54   guint16 uh_ulen;
55   guint16 uh_sum;
56 } e_udphdr;
57
58 /* UDP Ports -> should go in packet-udp.h */
59
60 #define UDP_PORT_DNS     53
61 #define UDP_PORT_BOOTPS  67
62 #define UDP_PORT_TFTP    69
63 #define UDP_PORT_IPX    213
64 #define UDP_PORT_NBNS   137
65 #define UDP_PORT_NBDGM  138
66 #define UDP_PORT_RIP    520
67 #define UDP_PORT_VINES  573
68
69
70 struct hash_struct {
71   guint16 proto;
72   void (*dissect)(const u_char *, int, frame_data *, proto_tree *);
73   struct hash_struct *next;
74 };
75
76 struct hash_struct *hash_table[256];
77
78 /*
79  * These routines are for UDP, will be generalized soon: RJS
80  *
81  * XXX - note that they should probably check the IP address as well as
82  * the port number, so that we don't mistakenly identify packets as, say,
83  * TFTP, merely because they have a source or destination port number
84  * equal to the port being used by a TFTP daemon on some machine other
85  * than the one they're going to or from.
86  */
87
88 struct hash_struct *udp_find_hash_ent(guint16 proto) {
89
90   int idx = proto % 256;
91   struct hash_struct *hash_ent = hash_table[idx];
92
93   while (hash_ent != NULL) {
94
95     if (hash_ent -> proto == proto)
96       return hash_ent;
97   
98     hash_ent = hash_ent -> next;
99
100   }
101
102   return NULL;
103
104 }
105
106 void udp_hash_add(guint16 proto,
107         void (*dissect)(const u_char *, int, frame_data *, proto_tree *)) {
108
109   int idx = proto % 256;   /* Simply take the remainder, hope for no collisions */
110   struct hash_struct *hash_ent = (struct hash_struct *)malloc(sizeof(struct hash_struct));
111   struct hash_struct *hash_ent2;
112   
113   hash_ent -> proto = proto;
114   hash_ent -> dissect = dissect;
115   hash_ent -> next = NULL;
116
117   if (hash_ent == NULL) {
118
119     fprintf(stderr, "Could not allocate space for hash structure in dissect_udp\n");
120     exit(1);
121   }
122
123   if (hash_table[idx]) {  /* Something, add on end */
124
125     hash_ent2 = hash_table[idx];
126
127     while (hash_ent2 -> next != NULL)
128       hash_ent2 = hash_ent2 -> next;
129
130     hash_ent2 -> next = hash_ent;     /* Bad in pathalogical cases */
131
132   }
133   else {
134
135     hash_table[idx] = hash_ent;
136
137   }
138
139 }
140
141 void init_dissect_udp(void) {
142
143   int i;
144
145   for (i = 0; i < 256; i++) {
146
147     hash_table[i] = NULL;
148
149   }
150
151   /* Now add the protocols we know about */
152
153   udp_hash_add(UDP_PORT_BOOTPS, dissect_bootp);
154   udp_hash_add(UDP_PORT_TFTP, dissect_tftp);
155
156 }
157
158 void
159 dissect_udp(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
160   e_udphdr  uh;
161   guint16    uh_sport, uh_dport, uh_ulen, uh_sum;
162   struct hash_struct *dissect_routine = NULL;
163   proto_tree *udp_tree;
164   proto_item *ti;
165   guint      payload;
166
167   /* To do: Check for {cap len,pkt len} < struct len */
168   /* Avoids alignment problems on many architectures. */
169   memcpy(&uh, &pd[offset], sizeof(e_udphdr));
170   uh_sport = ntohs(uh.uh_sport);
171   uh_dport = ntohs(uh.uh_dport);
172   uh_ulen  = ntohs(uh.uh_ulen);
173   uh_sum   = ntohs(uh.uh_sum);
174   
175   payload = pi.payload - sizeof(e_udphdr);
176
177   if (check_col(fd, COL_PROTOCOL))
178     col_add_str(fd, COL_PROTOCOL, "UDP");
179   if (check_col(fd, COL_INFO))
180     col_add_fstr(fd, COL_INFO, "Source port: %s  Destination port: %s",
181             get_udp_port(uh_sport), get_udp_port(uh_dport));
182   if (check_col(fd, COL_RES_SRC_PORT))
183     col_add_str(fd, COL_RES_SRC_PORT, get_udp_port(uh_sport));
184   if (check_col(fd, COL_UNRES_SRC_PORT))
185     col_add_fstr(fd, COL_UNRES_SRC_PORT, "%u", uh_sport);
186   if (check_col(fd, COL_RES_DST_PORT))
187     col_add_str(fd, COL_RES_DST_PORT, get_udp_port(uh_dport));
188   if (check_col(fd, COL_UNRES_DST_PORT))
189     col_add_fstr(fd, COL_UNRES_DST_PORT, "%u", uh_dport);
190     
191   if (tree) {
192     ti = proto_tree_add_item(tree, offset, 8, "User Datagram Protocol");
193     udp_tree = proto_tree_new();
194     proto_item_add_subtree(ti, udp_tree, ETT_UDP);
195     proto_tree_add_item(udp_tree, offset,     2, "Source port: %s (%u)",
196       get_udp_port(uh_sport), uh_sport);
197     proto_tree_add_item(udp_tree, offset + 2, 2, "Destination port: %s (%u)",
198       get_udp_port(uh_dport), uh_dport);
199     proto_tree_add_item(udp_tree, offset + 4, 2, "Length: %u", uh_ulen);
200     proto_tree_add_item(udp_tree, offset + 6, 2, "Checksum: 0x%04x", uh_sum);
201   }
202
203   /* Skip over header */
204   offset += 8;
205
206   /* To do: make sure we aren't screwing ourselves with the MIN call. */
207   switch (MIN(uh_sport, uh_dport)) {
208     case UDP_PORT_BOOTPS:
209       dissect_bootp(pd, offset, fd, tree);
210       break;
211     case UDP_PORT_DNS:
212       dissect_dns(pd, offset, fd, tree);
213       break;
214     case UDP_PORT_RIP:
215       /* we should check the source port too (RIP: UDP src and dst port 520) */
216       dissect_rip(pd, offset, fd, tree);
217       break;
218     case UDP_PORT_NBNS:
219       dissect_nbns(pd, offset, fd, tree);
220       break;
221     case UDP_PORT_NBDGM:
222       dissect_nbdgm(pd, offset, fd, tree, payload);
223       break;
224     case UDP_PORT_IPX: /* RFC 1234 */
225       dissect_ipx(pd, offset, fd, tree);
226       break;
227     case UDP_PORT_VINES:
228       /* FIXME: AFAIK, src and dst port must be the same */
229       dissect_vines_frp(pd, offset, fd, tree);
230       break;
231     case UDP_PORT_TFTP:
232       /* This is the first point of call, but it adds a dynamic call */
233       udp_hash_add(MAX(uh_sport, uh_dport), dissect_tftp);  /* Add to table */
234       dissect_tftp(pd, offset, fd, tree);
235       break;
236     default:
237
238       /* OK, find a routine in the table, else use the default */
239
240       if ((dissect_routine = udp_find_hash_ent(uh_sport))) {
241
242         struct hash_struct *dr2 = udp_find_hash_ent(uh_dport);
243
244         if (dr2 == NULL) {  /* Not in the table, add */
245
246           udp_hash_add(uh_dport, dissect_tftp);
247
248         }
249
250         dissect_routine -> dissect(pd, offset, fd, tree);
251       }
252       else if ((dissect_routine = udp_find_hash_ent(uh_dport))) {
253
254         dissect_routine -> dissect(pd, offset, fd, tree);
255
256       }
257       else {
258
259         dissect_data(pd, offset, fd, tree);
260       }
261   }
262 }