#include <string.h> and/or #include <stdio.h> not needed.
[obnox/wireshark/wip.git] / epan / dissectors / packet-goose.c
1 /* Do not modify this file.                                                   */
2 /* It is created automatically by the ASN.1 to Wireshark dissector compiler   */
3 /* packet-goose.c                                                             */
4 /* ../../tools/asn2wrs.py -b -p goose -c ./goose.cnf -s ./packet-goose-template -D . goose.asn */
5
6 /* Input file: packet-goose-template.c */
7
8 #line 1 "packet-goose-template.c"
9 /* packet-goose.c
10  * Routines for IEC 61850 GOOSE packet dissection
11  * Martin Lutz 2008
12  *
13  * $Id$
14  *
15  * Wireshark - Network traffic analyzer
16  * By Gerald Combs <gerald@wireshark.org>
17  * Copyright 1998 Gerald Combs
18  *
19  * This program is free software; you can redistribute it and/or
20  * modify it under the terms of the GNU General Public License
21  * as published by the Free Software Foundation; either version 2
22  * of the License, or (at your option) any later version.
23  *
24  * This program is distributed in the hope that it will be useful,
25  * but WITHOUT ANY WARRANTY; without even the implied warranty of
26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
27  * GNU General Public License for more details.
28  *
29  * You should have received a copy of the GNU General Public License
30  * along with this program; if not, write to the Free Software
31  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
32  */
33
34 #ifdef HAVE_CONFIG_H
35 # include "config.h"
36 #endif
37
38 #include <glib.h>
39 #include <epan/packet.h>
40 #include <epan/asn1.h>
41 #include <epan/etypes.h>
42 #include <epan/expert.h>
43 #include <epan/nstime.h>
44
45 #include "packet-ber.h"
46 #include "packet-acse.h"
47
48 #define PNAME  "GOOSE"
49 #define PSNAME "GOOSE"
50 #define PFNAME "goose"
51
52 /* Initialize the protocol and registered fields */
53 static int proto_goose = -1;
54 static int hf_goose_appid = -1;
55 static int hf_goose_length = -1;
56 static int hf_goose_reserve1 = -1;
57 static int hf_goose_reserve2 = -1;
58
59
60 /*--- Included file: packet-goose-hf.c ---*/
61 #line 1 "packet-goose-hf.c"
62 static int hf_goose_gseMngtPdu = -1;              /* GSEMngtPdu */
63 static int hf_goose_goosePdu = -1;                /* IECGoosePdu */
64 static int hf_goose_stateID = -1;                 /* INTEGER */
65 static int hf_goose_requestResp = -1;             /* RequestResponse */
66 static int hf_goose_requests = -1;                /* GSEMngtRequests */
67 static int hf_goose_responses = -1;               /* GSEMngtResponses */
68 static int hf_goose_getGoReference = -1;          /* GetReferenceRequestPdu */
69 static int hf_goose_getGOOSEElementNumber = -1;   /* GetElementRequestPdu */
70 static int hf_goose_getGsReference = -1;          /* GetReferenceRequestPdu */
71 static int hf_goose_getGSSEDataOffset = -1;       /* GetElementRequestPdu */
72 static int hf_goose_gseMngtNotSupported = -1;     /* NULL */
73 static int hf_goose_gseMngtResponses_GetGOReference = -1;  /* GSEMngtResponsePdu */
74 static int hf_goose_gseMngtResponses_GetGOOSEElementNumber = -1;  /* GSEMngtResponsePdu */
75 static int hf_goose_gseMngtResponses_GetGSReference = -1;  /* GSEMngtResponsePdu */
76 static int hf_goose_gseMngtResponses_GetGSSEDataOffset = -1;  /* GSEMngtResponsePdu */
77 static int hf_goose_ident = -1;                   /* VisibleString */
78 static int hf_goose_getReferenceRequestPDU_offset = -1;  /* T_getReferenceRequestPDU_offset */
79 static int hf_goose_getReferenceRequestPDU_offset_item = -1;  /* INTEGER */
80 static int hf_goose_references = -1;              /* T_references */
81 static int hf_goose_references_item = -1;         /* VisibleString */
82 static int hf_goose_confRev = -1;                 /* INTEGER */
83 static int hf_goose_posNeg = -1;                  /* PositiveNegative */
84 static int hf_goose_responsePositive = -1;        /* T_responsePositive */
85 static int hf_goose_datSet = -1;                  /* VisibleString */
86 static int hf_goose_result = -1;                  /* SEQUENCE_OF_RequestResults */
87 static int hf_goose_result_item = -1;             /* RequestResults */
88 static int hf_goose_responseNegative = -1;        /* GlbErrors */
89 static int hf_goose_offset = -1;                  /* INTEGER */
90 static int hf_goose_reference = -1;               /* IA5String */
91 static int hf_goose_error = -1;                   /* ErrorReason */
92 static int hf_goose_gocbRef = -1;                 /* VisibleString */
93 static int hf_goose_timeAllowedtoLive = -1;       /* INTEGER */
94 static int hf_goose_goID = -1;                    /* VisibleString */
95 static int hf_goose_t = -1;                       /* UtcTime */
96 static int hf_goose_stNum = -1;                   /* INTEGER */
97 static int hf_goose_sqNum = -1;                   /* INTEGER */
98 static int hf_goose_test = -1;                    /* BOOLEAN */
99 static int hf_goose_ndsCom = -1;                  /* BOOLEAN */
100 static int hf_goose_numDatSetEntries = -1;        /* INTEGER */
101 static int hf_goose_allData = -1;                 /* SEQUENCE_OF_Data */
102 static int hf_goose_allData_item = -1;            /* Data */
103 static int hf_goose_array = -1;                   /* SEQUENCE_OF_Data */
104 static int hf_goose_array_item = -1;              /* Data */
105 static int hf_goose_structure = -1;               /* SEQUENCE_OF_Data */
106 static int hf_goose_structure_item = -1;          /* Data */
107 static int hf_goose_boolean = -1;                 /* BOOLEAN */
108 static int hf_goose_bit_string = -1;              /* BIT_STRING */
109 static int hf_goose_integer = -1;                 /* INTEGER */
110 static int hf_goose_unsigned = -1;                /* INTEGER */
111 static int hf_goose_floating_point = -1;          /* FloatingPoint */
112 static int hf_goose_real = -1;                    /* REAL */
113 static int hf_goose_octet_string = -1;            /* OCTET_STRING */
114 static int hf_goose_visible_string = -1;          /* VisibleString */
115 static int hf_goose_binary_time = -1;             /* TimeOfDay */
116 static int hf_goose_bcd = -1;                     /* INTEGER */
117 static int hf_goose_booleanArray = -1;            /* BIT_STRING */
118
119 /*--- End of included file: packet-goose-hf.c ---*/
120 #line 52 "packet-goose-template.c"
121
122 /* Initialize the subtree pointers */
123 static int ett_goose = -1;
124
125
126 /*--- Included file: packet-goose-ett.c ---*/
127 #line 1 "packet-goose-ett.c"
128 static gint ett_goose_GOOSEpdu = -1;
129 static gint ett_goose_GSEMngtPdu = -1;
130 static gint ett_goose_RequestResponse = -1;
131 static gint ett_goose_GSEMngtRequests = -1;
132 static gint ett_goose_GSEMngtResponses = -1;
133 static gint ett_goose_GetReferenceRequestPdu = -1;
134 static gint ett_goose_T_getReferenceRequestPDU_offset = -1;
135 static gint ett_goose_GetElementRequestPdu = -1;
136 static gint ett_goose_T_references = -1;
137 static gint ett_goose_GSEMngtResponsePdu = -1;
138 static gint ett_goose_PositiveNegative = -1;
139 static gint ett_goose_T_responsePositive = -1;
140 static gint ett_goose_SEQUENCE_OF_RequestResults = -1;
141 static gint ett_goose_RequestResults = -1;
142 static gint ett_goose_IECGoosePdu = -1;
143 static gint ett_goose_SEQUENCE_OF_Data = -1;
144 static gint ett_goose_Data = -1;
145
146 /*--- End of included file: packet-goose-ett.c ---*/
147 #line 57 "packet-goose-template.c"
148
149
150 /*--- Included file: packet-goose-fn.c ---*/
151 #line 1 "packet-goose-fn.c"
152 /*--- Cyclic dependencies ---*/
153
154 /* Data -> Data/array -> Data */
155 static int dissect_goose_Data(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_);
156
157
158
159
160 static int
161 dissect_goose_INTEGER(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
162   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
163                                                 NULL);
164
165   return offset;
166 }
167
168
169
170 static int
171 dissect_goose_VisibleString(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
172   offset = dissect_ber_restricted_string(implicit_tag, BER_UNI_TAG_VisibleString,
173                                             actx, tree, tvb, offset, hf_index,
174                                             NULL);
175
176   return offset;
177 }
178
179
180 static const ber_sequence_t T_getReferenceRequestPDU_offset_sequence_of[1] = {
181   { &hf_goose_getReferenceRequestPDU_offset_item, BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_goose_INTEGER },
182 };
183
184 static int
185 dissect_goose_T_getReferenceRequestPDU_offset(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
186   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
187                                       T_getReferenceRequestPDU_offset_sequence_of, hf_index, ett_goose_T_getReferenceRequestPDU_offset);
188
189   return offset;
190 }
191
192
193 static const ber_sequence_t GetReferenceRequestPdu_sequence[] = {
194   { &hf_goose_ident         , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_goose_VisibleString },
195   { &hf_goose_getReferenceRequestPDU_offset, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_goose_T_getReferenceRequestPDU_offset },
196   { NULL, 0, 0, 0, NULL }
197 };
198
199 static int
200 dissect_goose_GetReferenceRequestPdu(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
201   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
202                                    GetReferenceRequestPdu_sequence, hf_index, ett_goose_GetReferenceRequestPdu);
203
204   return offset;
205 }
206
207
208 static const ber_sequence_t T_references_sequence_of[1] = {
209   { &hf_goose_references_item, BER_CLASS_UNI, BER_UNI_TAG_VisibleString, BER_FLAGS_NOOWNTAG, dissect_goose_VisibleString },
210 };
211
212 static int
213 dissect_goose_T_references(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
214   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
215                                       T_references_sequence_of, hf_index, ett_goose_T_references);
216
217   return offset;
218 }
219
220
221 static const ber_sequence_t GetElementRequestPdu_sequence[] = {
222   { &hf_goose_ident         , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_goose_VisibleString },
223   { &hf_goose_references    , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_goose_T_references },
224   { NULL, 0, 0, 0, NULL }
225 };
226
227 static int
228 dissect_goose_GetElementRequestPdu(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
229   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
230                                    GetElementRequestPdu_sequence, hf_index, ett_goose_GetElementRequestPdu);
231
232   return offset;
233 }
234
235
236 static const value_string goose_GSEMngtRequests_vals[] = {
237   {   1, "getGoReference" },
238   {   2, "getGOOSEElementNumber" },
239   {   3, "getGsReference" },
240   {   4, "getGSSEDataOffset" },
241   { 0, NULL }
242 };
243
244 static const ber_choice_t GSEMngtRequests_choice[] = {
245   {   1, &hf_goose_getGoReference, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_goose_GetReferenceRequestPdu },
246   {   2, &hf_goose_getGOOSEElementNumber, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_goose_GetElementRequestPdu },
247   {   3, &hf_goose_getGsReference, BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_goose_GetReferenceRequestPdu },
248   {   4, &hf_goose_getGSSEDataOffset, BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_goose_GetElementRequestPdu },
249   { 0, NULL, 0, 0, 0, NULL }
250 };
251
252 static int
253 dissect_goose_GSEMngtRequests(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
254   offset = dissect_ber_choice(actx, tree, tvb, offset,
255                                  GSEMngtRequests_choice, hf_index, ett_goose_GSEMngtRequests,
256                                  NULL);
257
258   return offset;
259 }
260
261
262
263 static int
264 dissect_goose_NULL(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
265   offset = dissect_ber_null(implicit_tag, actx, tree, tvb, offset, hf_index);
266
267   return offset;
268 }
269
270
271
272 static int
273 dissect_goose_IA5String(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
274   offset = dissect_ber_restricted_string(implicit_tag, BER_UNI_TAG_IA5String,
275                                             actx, tree, tvb, offset, hf_index,
276                                             NULL);
277
278   return offset;
279 }
280
281
282 static const value_string goose_ErrorReason_vals[] = {
283   {   0, "other" },
284   {   1, "notFound" },
285   { 0, NULL }
286 };
287
288
289 static int
290 dissect_goose_ErrorReason(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
291   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
292                                                 NULL);
293
294   return offset;
295 }
296
297
298 static const value_string goose_RequestResults_vals[] = {
299   {   0, "offset" },
300   {   1, "reference" },
301   {   2, "error" },
302   { 0, NULL }
303 };
304
305 static const ber_choice_t RequestResults_choice[] = {
306   {   0, &hf_goose_offset        , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_goose_INTEGER },
307   {   1, &hf_goose_reference     , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_goose_IA5String },
308   {   2, &hf_goose_error         , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_goose_ErrorReason },
309   { 0, NULL, 0, 0, 0, NULL }
310 };
311
312 static int
313 dissect_goose_RequestResults(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
314   offset = dissect_ber_choice(actx, tree, tvb, offset,
315                                  RequestResults_choice, hf_index, ett_goose_RequestResults,
316                                  NULL);
317
318   return offset;
319 }
320
321
322 static const ber_sequence_t SEQUENCE_OF_RequestResults_sequence_of[1] = {
323   { &hf_goose_result_item   , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_goose_RequestResults },
324 };
325
326 static int
327 dissect_goose_SEQUENCE_OF_RequestResults(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
328   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
329                                       SEQUENCE_OF_RequestResults_sequence_of, hf_index, ett_goose_SEQUENCE_OF_RequestResults);
330
331   return offset;
332 }
333
334
335 static const ber_sequence_t T_responsePositive_sequence[] = {
336   { &hf_goose_datSet        , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_goose_VisibleString },
337   { &hf_goose_result        , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_goose_SEQUENCE_OF_RequestResults },
338   { NULL, 0, 0, 0, NULL }
339 };
340
341 static int
342 dissect_goose_T_responsePositive(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
343   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
344                                    T_responsePositive_sequence, hf_index, ett_goose_T_responsePositive);
345
346   return offset;
347 }
348
349
350 static const value_string goose_GlbErrors_vals[] = {
351   {   0, "other" },
352   {   1, "unknownControlBlock" },
353   {   2, "responseTooLarge" },
354   {   3, "controlBlockConfigurationError" },
355   { 0, NULL }
356 };
357
358
359 static int
360 dissect_goose_GlbErrors(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
361   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
362                                                 NULL);
363
364   return offset;
365 }
366
367
368 static const value_string goose_PositiveNegative_vals[] = {
369   {   2, "responsePositive" },
370   {   3, "responseNegative" },
371   { 0, NULL }
372 };
373
374 static const ber_choice_t PositiveNegative_choice[] = {
375   {   2, &hf_goose_responsePositive, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_goose_T_responsePositive },
376   {   3, &hf_goose_responseNegative, BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_goose_GlbErrors },
377   { 0, NULL, 0, 0, 0, NULL }
378 };
379
380 static int
381 dissect_goose_PositiveNegative(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
382   offset = dissect_ber_choice(actx, tree, tvb, offset,
383                                  PositiveNegative_choice, hf_index, ett_goose_PositiveNegative,
384                                  NULL);
385
386   return offset;
387 }
388
389
390 static const ber_sequence_t GSEMngtResponsePdu_sequence[] = {
391   { &hf_goose_ident         , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_goose_VisibleString },
392   { &hf_goose_confRev       , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_goose_INTEGER },
393   { &hf_goose_posNeg        , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_goose_PositiveNegative },
394   { NULL, 0, 0, 0, NULL }
395 };
396
397 static int
398 dissect_goose_GSEMngtResponsePdu(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
399   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
400                                    GSEMngtResponsePdu_sequence, hf_index, ett_goose_GSEMngtResponsePdu);
401
402   return offset;
403 }
404
405
406 static const value_string goose_GSEMngtResponses_vals[] = {
407   {   0, "gseMngtNotSupported" },
408   {   1, "getGoReference" },
409   {   2, "getGOOSEElementNumber" },
410   {   3, "getGsReference" },
411   {   4, "getGSSEDataOffset" },
412   { 0, NULL }
413 };
414
415 static const ber_choice_t GSEMngtResponses_choice[] = {
416   {   0, &hf_goose_gseMngtNotSupported, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_goose_NULL },
417   {   1, &hf_goose_gseMngtResponses_GetGOReference, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_goose_GSEMngtResponsePdu },
418   {   2, &hf_goose_gseMngtResponses_GetGOOSEElementNumber, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_goose_GSEMngtResponsePdu },
419   {   3, &hf_goose_gseMngtResponses_GetGSReference, BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_goose_GSEMngtResponsePdu },
420   {   4, &hf_goose_gseMngtResponses_GetGSSEDataOffset, BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_goose_GSEMngtResponsePdu },
421   { 0, NULL, 0, 0, 0, NULL }
422 };
423
424 static int
425 dissect_goose_GSEMngtResponses(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
426   offset = dissect_ber_choice(actx, tree, tvb, offset,
427                                  GSEMngtResponses_choice, hf_index, ett_goose_GSEMngtResponses,
428                                  NULL);
429
430   return offset;
431 }
432
433
434 static const value_string goose_RequestResponse_vals[] = {
435   {   1, "requests" },
436   {   2, "responses" },
437   { 0, NULL }
438 };
439
440 static const ber_choice_t RequestResponse_choice[] = {
441   {   1, &hf_goose_requests      , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_goose_GSEMngtRequests },
442   {   2, &hf_goose_responses     , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_goose_GSEMngtResponses },
443   { 0, NULL, 0, 0, 0, NULL }
444 };
445
446 static int
447 dissect_goose_RequestResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
448   offset = dissect_ber_choice(actx, tree, tvb, offset,
449                                  RequestResponse_choice, hf_index, ett_goose_RequestResponse,
450                                  NULL);
451
452   return offset;
453 }
454
455
456 static const ber_sequence_t GSEMngtPdu_sequence[] = {
457   { &hf_goose_stateID       , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_goose_INTEGER },
458   { &hf_goose_requestResp   , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_goose_RequestResponse },
459   { NULL, 0, 0, 0, NULL }
460 };
461
462 static int
463 dissect_goose_GSEMngtPdu(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
464   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
465                                    GSEMngtPdu_sequence, hf_index, ett_goose_GSEMngtPdu);
466
467   return offset;
468 }
469
470
471
472 static int
473 dissect_goose_UtcTime(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
474 #line 18 "goose.cnf"
475
476         guint32 len;
477         proto_item *cause;
478         guint32 seconds;
479         guint32 fraction;
480         guint32 nanoseconds;
481         nstime_t ts;
482         gchar * ptime;
483
484         len = tvb_length_remaining(tvb, offset);
485
486         if(len != 8)
487         {
488                 cause = proto_tree_add_text(tree, tvb, offset, len,
489                                 "BER Error: malformed UTCTime encoding, "
490                                 "length must be 8 bytes");
491                 proto_item_set_expert_flags(cause, PI_MALFORMED, PI_WARN);
492                 expert_add_info_format(actx->pinfo, cause, PI_MALFORMED, PI_WARN, "BER Error: malformed UTCTime encoding");
493                 if(hf_index >= 0)
494                 {
495                         proto_tree_add_string(tree, hf_index, tvb, offset, len, "????");
496                 }
497                 return offset;
498         }
499
500         seconds = tvb_get_ntohl(tvb, offset);
501         fraction = tvb_get_ntoh24(tvb, offset+4) * 0x100; /* Only 3 bytes are recommended */
502         nanoseconds = (guint32)( ((guint64)fraction * G_GINT64_CONSTANT(1000000000U)) / G_GINT64_CONSTANT(0x100000000U) ) ;
503
504         ts.secs = seconds;
505         ts.nsecs = nanoseconds;
506
507         ptime = abs_time_to_str(&ts, ABSOLUTE_TIME_UTC);
508
509         if(hf_index >= 0)
510         {
511                 proto_tree_add_string(tree, hf_index, tvb, offset, len, ptime);
512         }
513
514         return offset;
515
516
517
518
519
520   return offset;
521 }
522
523
524
525 static int
526 dissect_goose_BOOLEAN(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
527   offset = dissect_ber_boolean(implicit_tag, actx, tree, tvb, offset, hf_index, NULL);
528
529   return offset;
530 }
531
532
533 static const ber_sequence_t SEQUENCE_OF_Data_sequence_of[1] = {
534   { &hf_goose_allData_item  , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_goose_Data },
535 };
536
537 static int
538 dissect_goose_SEQUENCE_OF_Data(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
539   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
540                                       SEQUENCE_OF_Data_sequence_of, hf_index, ett_goose_SEQUENCE_OF_Data);
541
542   return offset;
543 }
544
545
546
547 static int
548 dissect_goose_BIT_STRING(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
549   offset = dissect_ber_bitstring(implicit_tag, actx, tree, tvb, offset,
550                                     NULL, hf_index, -1,
551                                     NULL);
552
553   return offset;
554 }
555
556
557
558 static int
559 dissect_goose_FloatingPoint(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
560   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
561                                        NULL);
562
563   return offset;
564 }
565
566
567
568 static int
569 dissect_goose_REAL(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
570   offset = dissect_ber_real(implicit_tag, actx, tree, tvb, offset, hf_index,
571                                NULL);
572
573   return offset;
574 }
575
576
577
578 static int
579 dissect_goose_OCTET_STRING(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
580   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
581                                        NULL);
582
583   return offset;
584 }
585
586
587
588 static int
589 dissect_goose_TimeOfDay(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
590   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
591                                        NULL);
592
593   return offset;
594 }
595
596
597 static const value_string goose_Data_vals[] = {
598   {   1, "array" },
599   {   2, "structure" },
600   {   3, "boolean" },
601   {   4, "bit-string" },
602   {   5, "integer" },
603   {   6, "unsigned" },
604   {   7, "floating-point" },
605   {   8, "real" },
606   {   9, "octet-string" },
607   {  10, "visible-string" },
608   {  12, "binary-time" },
609   {  13, "bcd" },
610   {  14, "booleanArray" },
611   { 0, NULL }
612 };
613
614 static const ber_choice_t Data_choice[] = {
615   {   1, &hf_goose_array         , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_goose_SEQUENCE_OF_Data },
616   {   2, &hf_goose_structure     , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_goose_SEQUENCE_OF_Data },
617   {   3, &hf_goose_boolean       , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_goose_BOOLEAN },
618   {   4, &hf_goose_bit_string    , BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_goose_BIT_STRING },
619   {   5, &hf_goose_integer       , BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_goose_INTEGER },
620   {   6, &hf_goose_unsigned      , BER_CLASS_CON, 6, BER_FLAGS_IMPLTAG, dissect_goose_INTEGER },
621   {   7, &hf_goose_floating_point, BER_CLASS_CON, 7, BER_FLAGS_IMPLTAG, dissect_goose_FloatingPoint },
622   {   8, &hf_goose_real          , BER_CLASS_CON, 8, BER_FLAGS_IMPLTAG, dissect_goose_REAL },
623   {   9, &hf_goose_octet_string  , BER_CLASS_CON, 9, BER_FLAGS_IMPLTAG, dissect_goose_OCTET_STRING },
624   {  10, &hf_goose_visible_string, BER_CLASS_CON, 10, BER_FLAGS_IMPLTAG, dissect_goose_VisibleString },
625   {  12, &hf_goose_binary_time   , BER_CLASS_CON, 12, BER_FLAGS_IMPLTAG, dissect_goose_TimeOfDay },
626   {  13, &hf_goose_bcd           , BER_CLASS_CON, 13, BER_FLAGS_IMPLTAG, dissect_goose_INTEGER },
627   {  14, &hf_goose_booleanArray  , BER_CLASS_CON, 14, BER_FLAGS_IMPLTAG, dissect_goose_BIT_STRING },
628   { 0, NULL, 0, 0, 0, NULL }
629 };
630
631 static int
632 dissect_goose_Data(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
633   offset = dissect_ber_choice(actx, tree, tvb, offset,
634                                  Data_choice, hf_index, ett_goose_Data,
635                                  NULL);
636
637   return offset;
638 }
639
640
641 static const ber_sequence_t IECGoosePdu_sequence[] = {
642   { &hf_goose_gocbRef       , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_goose_VisibleString },
643   { &hf_goose_timeAllowedtoLive, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_goose_INTEGER },
644   { &hf_goose_datSet        , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_goose_VisibleString },
645   { &hf_goose_goID          , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_goose_VisibleString },
646   { &hf_goose_t             , BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_goose_UtcTime },
647   { &hf_goose_stNum         , BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_goose_INTEGER },
648   { &hf_goose_sqNum         , BER_CLASS_CON, 6, BER_FLAGS_IMPLTAG, dissect_goose_INTEGER },
649   { &hf_goose_test          , BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_goose_BOOLEAN },
650   { &hf_goose_confRev       , BER_CLASS_CON, 8, BER_FLAGS_IMPLTAG, dissect_goose_INTEGER },
651   { &hf_goose_ndsCom        , BER_CLASS_CON, 9, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_goose_BOOLEAN },
652   { &hf_goose_numDatSetEntries, BER_CLASS_CON, 10, BER_FLAGS_IMPLTAG, dissect_goose_INTEGER },
653   { &hf_goose_allData       , BER_CLASS_CON, 11, BER_FLAGS_IMPLTAG, dissect_goose_SEQUENCE_OF_Data },
654   { NULL, 0, 0, 0, NULL }
655 };
656
657 static int
658 dissect_goose_IECGoosePdu(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
659   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
660                                    IECGoosePdu_sequence, hf_index, ett_goose_IECGoosePdu);
661
662   return offset;
663 }
664
665
666 static const value_string goose_GOOSEpdu_vals[] = {
667   {   0, "gseMngtPdu" },
668   {   1, "goosePdu" },
669   { 0, NULL }
670 };
671
672 static const ber_choice_t GOOSEpdu_choice[] = {
673   {   0, &hf_goose_gseMngtPdu    , BER_CLASS_APP, 0, BER_FLAGS_IMPLTAG, dissect_goose_GSEMngtPdu },
674   {   1, &hf_goose_goosePdu      , BER_CLASS_APP, 1, BER_FLAGS_IMPLTAG, dissect_goose_IECGoosePdu },
675   { 0, NULL, 0, 0, 0, NULL }
676 };
677
678 static int
679 dissect_goose_GOOSEpdu(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
680   offset = dissect_ber_choice(actx, tree, tvb, offset,
681                                  GOOSEpdu_choice, hf_index, ett_goose_GOOSEpdu,
682                                  NULL);
683
684   return offset;
685 }
686
687
688 /*--- End of included file: packet-goose-fn.c ---*/
689 #line 59 "packet-goose-template.c"
690
691 /*
692 * Dissect GOOSE PDUs inside a PPDU.
693 */
694 static void
695 dissect_goose(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree)
696 {
697         int offset = 0;
698         int old_offset;
699         guint16 data;
700         proto_item *item = NULL;
701         proto_tree *tree = NULL;
702         asn1_ctx_t asn1_ctx;
703         asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
704
705         if (parent_tree){
706                 item = proto_tree_add_item(parent_tree, proto_goose, tvb, 0, -1, FALSE);
707                 tree = proto_item_add_subtree(item, ett_goose);
708         }
709         col_set_str(pinfo->cinfo, COL_PROTOCOL, PNAME);
710         col_clear(pinfo->cinfo, COL_INFO);
711
712         /* APPID */
713         if (tree && tvb_reported_length_remaining(tvb, offset) >= 2) {
714                 data = tvb_get_ntohs(tvb, offset);
715                 proto_tree_add_uint(tree, hf_goose_appid, tvb, offset, 2, data);
716         }
717         /* Length */
718         if (tree && tvb_reported_length_remaining(tvb, offset) >= 4) {
719                 data = tvb_get_ntohs(tvb, offset + 2);
720                 proto_tree_add_uint(tree, hf_goose_length, tvb, offset + 2, 2, data);
721         }
722         /* Reserved 1 */
723         if (tree && tvb_reported_length_remaining(tvb, offset) >= 6) {
724                 data = tvb_get_ntohs(tvb, offset + 4);
725                 proto_tree_add_uint(tree, hf_goose_reserve1, tvb, offset + 4, 2, data);
726         }
727         /* Reserved 2 */
728         if (tree && tvb_reported_length_remaining(tvb, offset) >= 8) {
729                 data = tvb_get_ntohs(tvb, offset + 6);
730                 proto_tree_add_uint(tree, hf_goose_reserve2, tvb, offset + 6, 2, data);
731         }
732
733         offset = 8;
734         while (tree && tvb_reported_length_remaining(tvb, offset) > 0){
735                 old_offset = offset;
736                 offset = dissect_goose_GOOSEpdu(FALSE, tvb, offset, &asn1_ctx , tree, -1);
737                 if (offset == old_offset) {
738                         proto_tree_add_text(tree, tvb, offset, -1, "Internal error, zero-byte GOOSE PDU");
739                         break;
740                 }
741         }
742 }
743
744
745 /*--- proto_register_goose -------------------------------------------*/
746 void proto_register_goose(void) {
747
748   /* List of fields */
749   static hf_register_info hf[] =
750   {
751         { &hf_goose_appid,
752         { "APPID",      "goose.appid", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL }},
753
754         { &hf_goose_length,
755         { "Length",     "goose.length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }},
756
757         { &hf_goose_reserve1,
758         { "Reserved 1", "goose.reserve1", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL }},
759
760         { &hf_goose_reserve2,
761         { "Reserved 2", "goose.reserve2", FT_UINT16, BASE_HEX_DEC, NULL, 0x0, NULL, HFILL }},
762
763
764 /*--- Included file: packet-goose-hfarr.c ---*/
765 #line 1 "packet-goose-hfarr.c"
766     { &hf_goose_gseMngtPdu,
767       { "gseMngtPdu", "goose.gseMngtPdu",
768         FT_NONE, BASE_NONE, NULL, 0,
769         "goose.GSEMngtPdu", HFILL }},
770     { &hf_goose_goosePdu,
771       { "goosePdu", "goose.goosePdu",
772         FT_NONE, BASE_NONE, NULL, 0,
773         "goose.IECGoosePdu", HFILL }},
774     { &hf_goose_stateID,
775       { "stateID", "goose.stateID",
776         FT_INT32, BASE_DEC, NULL, 0,
777         "goose.INTEGER", HFILL }},
778     { &hf_goose_requestResp,
779       { "requestResp", "goose.requestResp",
780         FT_UINT32, BASE_DEC, VALS(goose_RequestResponse_vals), 0,
781         "goose.RequestResponse", HFILL }},
782     { &hf_goose_requests,
783       { "requests", "goose.requests",
784         FT_UINT32, BASE_DEC, VALS(goose_GSEMngtRequests_vals), 0,
785         "goose.GSEMngtRequests", HFILL }},
786     { &hf_goose_responses,
787       { "responses", "goose.responses",
788         FT_UINT32, BASE_DEC, VALS(goose_GSEMngtResponses_vals), 0,
789         "goose.GSEMngtResponses", HFILL }},
790     { &hf_goose_getGoReference,
791       { "getGoReference", "goose.getGoReference",
792         FT_NONE, BASE_NONE, NULL, 0,
793         "goose.GetReferenceRequestPdu", HFILL }},
794     { &hf_goose_getGOOSEElementNumber,
795       { "getGOOSEElementNumber", "goose.getGOOSEElementNumber",
796         FT_NONE, BASE_NONE, NULL, 0,
797         "goose.GetElementRequestPdu", HFILL }},
798     { &hf_goose_getGsReference,
799       { "getGsReference", "goose.getGsReference",
800         FT_NONE, BASE_NONE, NULL, 0,
801         "goose.GetReferenceRequestPdu", HFILL }},
802     { &hf_goose_getGSSEDataOffset,
803       { "getGSSEDataOffset", "goose.getGSSEDataOffset",
804         FT_NONE, BASE_NONE, NULL, 0,
805         "goose.GetElementRequestPdu", HFILL }},
806     { &hf_goose_gseMngtNotSupported,
807       { "gseMngtNotSupported", "goose.gseMngtNotSupported",
808         FT_NONE, BASE_NONE, NULL, 0,
809         "goose.NULL", HFILL }},
810     { &hf_goose_gseMngtResponses_GetGOReference,
811       { "getGoReference", "goose.getGoReference",
812         FT_NONE, BASE_NONE, NULL, 0,
813         "goose.GSEMngtResponsePdu", HFILL }},
814     { &hf_goose_gseMngtResponses_GetGOOSEElementNumber,
815       { "getGOOSEElementNumber", "goose.getGOOSEElementNumber",
816         FT_NONE, BASE_NONE, NULL, 0,
817         "goose.GSEMngtResponsePdu", HFILL }},
818     { &hf_goose_gseMngtResponses_GetGSReference,
819       { "getGsReference", "goose.getGsReference",
820         FT_NONE, BASE_NONE, NULL, 0,
821         "goose.GSEMngtResponsePdu", HFILL }},
822     { &hf_goose_gseMngtResponses_GetGSSEDataOffset,
823       { "getGSSEDataOffset", "goose.getGSSEDataOffset",
824         FT_NONE, BASE_NONE, NULL, 0,
825         "goose.GSEMngtResponsePdu", HFILL }},
826     { &hf_goose_ident,
827       { "ident", "goose.ident",
828         FT_STRING, BASE_NONE, NULL, 0,
829         "goose.VisibleString", HFILL }},
830     { &hf_goose_getReferenceRequestPDU_offset,
831       { "offset", "goose.offset",
832         FT_UINT32, BASE_DEC, NULL, 0,
833         "goose.T_getReferenceRequestPDU_offset", HFILL }},
834     { &hf_goose_getReferenceRequestPDU_offset_item,
835       { "offset item", "goose.offset_item",
836         FT_INT32, BASE_DEC, NULL, 0,
837         "goose.INTEGER", HFILL }},
838     { &hf_goose_references,
839       { "references", "goose.references",
840         FT_UINT32, BASE_DEC, NULL, 0,
841         "goose.T_references", HFILL }},
842     { &hf_goose_references_item,
843       { "references item", "goose.references_item",
844         FT_STRING, BASE_NONE, NULL, 0,
845         "goose.VisibleString", HFILL }},
846     { &hf_goose_confRev,
847       { "confRev", "goose.confRev",
848         FT_INT32, BASE_DEC, NULL, 0,
849         "goose.INTEGER", HFILL }},
850     { &hf_goose_posNeg,
851       { "posNeg", "goose.posNeg",
852         FT_UINT32, BASE_DEC, VALS(goose_PositiveNegative_vals), 0,
853         "goose.PositiveNegative", HFILL }},
854     { &hf_goose_responsePositive,
855       { "responsePositive", "goose.responsePositive",
856         FT_NONE, BASE_NONE, NULL, 0,
857         "goose.T_responsePositive", HFILL }},
858     { &hf_goose_datSet,
859       { "datSet", "goose.datSet",
860         FT_STRING, BASE_NONE, NULL, 0,
861         "goose.VisibleString", HFILL }},
862     { &hf_goose_result,
863       { "result", "goose.result",
864         FT_UINT32, BASE_DEC, NULL, 0,
865         "goose.SEQUENCE_OF_RequestResults", HFILL }},
866     { &hf_goose_result_item,
867       { "RequestResults", "goose.RequestResults",
868         FT_UINT32, BASE_DEC, VALS(goose_RequestResults_vals), 0,
869         "goose.RequestResults", HFILL }},
870     { &hf_goose_responseNegative,
871       { "responseNegative", "goose.responseNegative",
872         FT_INT32, BASE_DEC, VALS(goose_GlbErrors_vals), 0,
873         "goose.GlbErrors", HFILL }},
874     { &hf_goose_offset,
875       { "offset", "goose.offset",
876         FT_INT32, BASE_DEC, NULL, 0,
877         "goose.INTEGER", HFILL }},
878     { &hf_goose_reference,
879       { "reference", "goose.reference",
880         FT_STRING, BASE_NONE, NULL, 0,
881         "goose.IA5String", HFILL }},
882     { &hf_goose_error,
883       { "error", "goose.error",
884         FT_INT32, BASE_DEC, VALS(goose_ErrorReason_vals), 0,
885         "goose.ErrorReason", HFILL }},
886     { &hf_goose_gocbRef,
887       { "gocbRef", "goose.gocbRef",
888         FT_STRING, BASE_NONE, NULL, 0,
889         "goose.VisibleString", HFILL }},
890     { &hf_goose_timeAllowedtoLive,
891       { "timeAllowedtoLive", "goose.timeAllowedtoLive",
892         FT_INT32, BASE_DEC, NULL, 0,
893         "goose.INTEGER", HFILL }},
894     { &hf_goose_goID,
895       { "goID", "goose.goID",
896         FT_STRING, BASE_NONE, NULL, 0,
897         "goose.VisibleString", HFILL }},
898     { &hf_goose_t,
899       { "t", "goose.t",
900         FT_STRING, BASE_NONE, NULL, 0,
901         "goose.UtcTime", HFILL }},
902     { &hf_goose_stNum,
903       { "stNum", "goose.stNum",
904         FT_INT32, BASE_DEC, NULL, 0,
905         "goose.INTEGER", HFILL }},
906     { &hf_goose_sqNum,
907       { "sqNum", "goose.sqNum",
908         FT_INT32, BASE_DEC, NULL, 0,
909         "goose.INTEGER", HFILL }},
910     { &hf_goose_test,
911       { "test", "goose.test",
912         FT_BOOLEAN, BASE_NONE, NULL, 0,
913         "goose.BOOLEAN", HFILL }},
914     { &hf_goose_ndsCom,
915       { "ndsCom", "goose.ndsCom",
916         FT_BOOLEAN, BASE_NONE, NULL, 0,
917         "goose.BOOLEAN", HFILL }},
918     { &hf_goose_numDatSetEntries,
919       { "numDatSetEntries", "goose.numDatSetEntries",
920         FT_INT32, BASE_DEC, NULL, 0,
921         "goose.INTEGER", HFILL }},
922     { &hf_goose_allData,
923       { "allData", "goose.allData",
924         FT_UINT32, BASE_DEC, NULL, 0,
925         "goose.SEQUENCE_OF_Data", HFILL }},
926     { &hf_goose_allData_item,
927       { "Data", "goose.Data",
928         FT_UINT32, BASE_DEC, VALS(goose_Data_vals), 0,
929         "goose.Data", HFILL }},
930     { &hf_goose_array,
931       { "array", "goose.array",
932         FT_UINT32, BASE_DEC, NULL, 0,
933         "goose.SEQUENCE_OF_Data", HFILL }},
934     { &hf_goose_array_item,
935       { "Data", "goose.Data",
936         FT_UINT32, BASE_DEC, VALS(goose_Data_vals), 0,
937         "goose.Data", HFILL }},
938     { &hf_goose_structure,
939       { "structure", "goose.structure",
940         FT_UINT32, BASE_DEC, NULL, 0,
941         "goose.SEQUENCE_OF_Data", HFILL }},
942     { &hf_goose_structure_item,
943       { "Data", "goose.Data",
944         FT_UINT32, BASE_DEC, VALS(goose_Data_vals), 0,
945         "goose.Data", HFILL }},
946     { &hf_goose_boolean,
947       { "boolean", "goose.boolean",
948         FT_BOOLEAN, BASE_NONE, NULL, 0,
949         "goose.BOOLEAN", HFILL }},
950     { &hf_goose_bit_string,
951       { "bit-string", "goose.bit_string",
952         FT_BYTES, BASE_NONE, NULL, 0,
953         "goose.BIT_STRING", HFILL }},
954     { &hf_goose_integer,
955       { "integer", "goose.integer",
956         FT_INT32, BASE_DEC, NULL, 0,
957         "goose.INTEGER", HFILL }},
958     { &hf_goose_unsigned,
959       { "unsigned", "goose.unsigned",
960         FT_INT32, BASE_DEC, NULL, 0,
961         "goose.INTEGER", HFILL }},
962     { &hf_goose_floating_point,
963       { "floating-point", "goose.floating_point",
964         FT_BYTES, BASE_NONE, NULL, 0,
965         "goose.FloatingPoint", HFILL }},
966     { &hf_goose_real,
967       { "real", "goose.real",
968         FT_DOUBLE, BASE_NONE, NULL, 0,
969         "goose.REAL", HFILL }},
970     { &hf_goose_octet_string,
971       { "octet-string", "goose.octet_string",
972         FT_BYTES, BASE_NONE, NULL, 0,
973         "goose.OCTET_STRING", HFILL }},
974     { &hf_goose_visible_string,
975       { "visible-string", "goose.visible_string",
976         FT_STRING, BASE_NONE, NULL, 0,
977         "goose.VisibleString", HFILL }},
978     { &hf_goose_binary_time,
979       { "binary-time", "goose.binary_time",
980         FT_BYTES, BASE_NONE, NULL, 0,
981         "goose.TimeOfDay", HFILL }},
982     { &hf_goose_bcd,
983       { "bcd", "goose.bcd",
984         FT_INT32, BASE_DEC, NULL, 0,
985         "goose.INTEGER", HFILL }},
986     { &hf_goose_booleanArray,
987       { "booleanArray", "goose.booleanArray",
988         FT_BYTES, BASE_NONE, NULL, 0,
989         "goose.BIT_STRING", HFILL }},
990
991 /*--- End of included file: packet-goose-hfarr.c ---*/
992 #line 133 "packet-goose-template.c"
993   };
994
995   /* List of subtrees */
996   static gint *ett[] = {
997           &ett_goose,
998
999 /*--- Included file: packet-goose-ettarr.c ---*/
1000 #line 1 "packet-goose-ettarr.c"
1001     &ett_goose_GOOSEpdu,
1002     &ett_goose_GSEMngtPdu,
1003     &ett_goose_RequestResponse,
1004     &ett_goose_GSEMngtRequests,
1005     &ett_goose_GSEMngtResponses,
1006     &ett_goose_GetReferenceRequestPdu,
1007     &ett_goose_T_getReferenceRequestPDU_offset,
1008     &ett_goose_GetElementRequestPdu,
1009     &ett_goose_T_references,
1010     &ett_goose_GSEMngtResponsePdu,
1011     &ett_goose_PositiveNegative,
1012     &ett_goose_T_responsePositive,
1013     &ett_goose_SEQUENCE_OF_RequestResults,
1014     &ett_goose_RequestResults,
1015     &ett_goose_IECGoosePdu,
1016     &ett_goose_SEQUENCE_OF_Data,
1017     &ett_goose_Data,
1018
1019 /*--- End of included file: packet-goose-ettarr.c ---*/
1020 #line 139 "packet-goose-template.c"
1021   };
1022
1023         /* Register protocol */
1024         proto_goose = proto_register_protocol(PNAME, PSNAME, PFNAME);
1025         register_dissector("goose", dissect_goose, proto_goose);
1026
1027         /* Register fields and subtrees */
1028         proto_register_field_array(proto_goose, hf, array_length(hf));
1029         proto_register_subtree_array(ett, array_length(ett));
1030
1031 }
1032
1033 /*--- proto_reg_handoff_goose --- */
1034 void proto_reg_handoff_goose(void) {
1035
1036         dissector_handle_t goose_handle;
1037         goose_handle = find_dissector("goose");
1038         
1039         dissector_add("ethertype", ETHERTYPE_IEC61850_GOOSE, goose_handle);
1040 }