Removed trailing whitespaces from .h and .c files using the
[obnox/wireshark/wip.git] / packet-dcerpc-ndr.c
1 /* packet-dcerpc-ndr.c
2  * Routines for DCERPC NDR dissection
3  * Copyright 2001, Todd Sabin <tas@webspan.net>
4  *
5  * $Id: packet-dcerpc-ndr.c,v 1.7 2002/08/02 23:35:48 jmayer Exp $
6  *
7  * Ethereal - Network traffic analyzer
8  * By Gerald Combs <gerald@ethereal.com>
9  * Copyright 1998 Gerald Combs
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 #include <string.h>
31 #include <ctype.h>
32
33 #include <glib.h>
34 #include <epan/packet.h>
35 #include "packet-dcerpc.h"
36
37
38 /*
39  * The NDR routines are for use by dcerpc subdissetors.  They're
40  * primarily for making sure things are aligned properly according
41  * to the rules of NDR.
42  */
43
44 int
45 dissect_ndr_uint8 (tvbuff_t *tvb, gint offset, packet_info *pinfo,
46                    proto_tree *tree, char *drep, 
47                    int hfindex, guint8 *pdata)
48 {
49     dcerpc_info *di;
50
51     di=pinfo->private_data;
52     if(di->conformant_run){
53       /* just a run to handle conformant arrays, no scalars to dissect */
54       return offset;
55     }
56
57     /* no alignment needed */
58     return dissect_dcerpc_uint8 (tvb, offset, pinfo, 
59                                  tree, drep, hfindex, pdata);
60 }
61
62 int
63 dissect_ndr_uint16 (tvbuff_t *tvb, gint offset, packet_info *pinfo,
64                     proto_tree *tree, char *drep, 
65                     int hfindex, guint16 *pdata)
66 {
67     dcerpc_info *di;
68
69     di=pinfo->private_data;
70     if(di->conformant_run){
71       /* just a run to handle conformant arrays, no scalars to dissect */
72       return offset;
73     }
74
75
76     if (offset % 2) {
77         offset++;
78     }
79     return dissect_dcerpc_uint16 (tvb, offset, pinfo, 
80                                   tree, drep, hfindex, pdata);
81 }
82
83 int
84 dissect_ndr_uint32 (tvbuff_t *tvb, gint offset, packet_info *pinfo,
85                     proto_tree *tree, char *drep, 
86                     int hfindex, guint32 *pdata)
87 {
88     dcerpc_info *di;
89
90     di=pinfo->private_data;
91     if(di->conformant_run){
92       /* just a run to handle conformant arrays, no scalars to dissect */
93       return offset;
94     }
95
96
97     if (offset % 4) {
98         offset += 4 - (offset % 4);
99     }
100     return dissect_dcerpc_uint32 (tvb, offset, pinfo, 
101                                   tree, drep, hfindex, pdata);
102 }
103
104 int
105 dissect_ndr_uint64 (tvbuff_t *tvb, gint offset, packet_info *pinfo,
106                     proto_tree *tree, char *drep, 
107                     int hfindex, unsigned char *pdata)
108 {
109     dcerpc_info *di;
110
111     di=pinfo->private_data;
112     if(di->conformant_run){
113       /* just a run to handle conformant arrays, no scalars to dissect */
114       return offset;
115     }
116
117     if (offset % 4) {
118         offset += 4 - (offset % 4);
119     }
120     return dissect_dcerpc_uint64 (tvb, offset, pinfo, 
121                                   tree, drep, hfindex, pdata);
122 }
123
124 int
125 dissect_ndr_uuid_t (tvbuff_t *tvb, gint offset, packet_info *pinfo,
126                     proto_tree *tree, char *drep, 
127                     int hfindex, e_uuid_t *pdata)
128 {
129     e_uuid_t uuid;
130     dcerpc_info *di;
131
132     di=pinfo->private_data;
133     if(di->conformant_run){
134       /* just a run to handle conformant arrays, no scalars to dissect */
135       return offset;
136     }
137
138     /* uuid's are aligned to 4 bytes, due to initial uint32 in struct */
139     if (offset % 4) {
140         offset += 4 - (offset % 4);
141     }
142     dcerpc_tvb_get_uuid (tvb, offset, drep, &uuid);
143     if (tree) {
144         proto_tree_add_string_format (tree, hfindex, tvb, offset, 16, "",
145                                       "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
146                                       uuid.Data1, uuid.Data2, uuid.Data3,
147                                       uuid.Data4[0], uuid.Data4[1],
148                                       uuid.Data4[2], uuid.Data4[3],
149                                       uuid.Data4[4], uuid.Data4[5],
150                                       uuid.Data4[6], uuid.Data4[7]);
151     }
152     if (pdata) {
153         *pdata = uuid;
154     }
155     return offset + 16;
156 }
157
158 int
159 dissect_ndr_ctx_hnd (tvbuff_t *tvb, gint offset, packet_info *pinfo,
160                      proto_tree *tree, char *drep, 
161                      int hfindex, e_ctx_hnd *pdata)
162 {
163     static e_ctx_hnd ctx_hnd;
164     dcerpc_info *di;
165
166     di=pinfo->private_data;
167     if(di->conformant_run){
168       /* just a run to handle conformant arrays, no scalars to dissect */
169       return offset;
170     }
171
172     if (offset % 4) {
173         offset += 4 - (offset % 4);
174     }
175     ctx_hnd.Data1 = dcerpc_tvb_get_ntohl (tvb, offset, drep);
176     dcerpc_tvb_get_uuid (tvb, offset+4, drep, &ctx_hnd.uuid);
177     if (tree) {
178         proto_tree_add_bytes (tree, hfindex, tvb, offset, 20,
179                               tvb_get_ptr (tvb, offset, 20));
180     }
181     if (pdata) {
182         *pdata = ctx_hnd;
183     }
184     return offset + 20;
185 }