change the signature that asn2wrs generates for functions to marm all parameters...
[obnox/wireshark/wip.git] / epan / dissectors / packet-ros.c
1 /* Do not modify this file.                                                   */
2 /* It is created automatically by the ASN.1 to Wireshark dissector compiler   */
3 /* ./packet-ros.c                                                             */
4 /* ../../tools/asn2wrs.py -b -e -p ros -c ros.cnf -s packet-ros-template ros.asn */
5
6 /* Input file: packet-ros-template.c */
7
8 #line 1 "packet-ros-template.c"
9 /* packet-ros_asn1.c
10  * Routines for ROS packet dissection
11  * Graeme Lunt 2005
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/conversation.h>
41 #include <epan/emem.h>
42
43 #include <stdio.h>
44 #include <string.h>
45
46 #include "packet-ber.h"
47 #include "packet-pres.h"
48 #include "packet-ros.h"
49
50 #define PNAME  "X.880 OSI Remote Operations Service"
51 #define PSNAME "ROS"
52 #define PFNAME "ros"
53
54 /* Initialize the protocol and registered fields */
55 int proto_ros = -1;
56
57 static struct SESSION_DATA_STRUCTURE* session = NULL;
58
59 static proto_tree *top_tree=NULL;
60 static guint32 opcode;
61 static guint32 invokeid;
62
63 static  dissector_handle_t ros_handle = NULL;
64
65 typedef struct ros_conv_info_t {
66   struct ros_conv_info_t *next;
67   GHashTable *unmatched; /* unmatched operations */
68   GHashTable *matched;   /* matched operations */
69 } ros_conv_info_t;
70
71 static ros_conv_info_t *ros_info_items = NULL;
72
73 typedef struct ros_call_response {
74   gboolean is_request;
75   guint32 req_frame;
76   nstime_t req_time;
77   guint32 rep_frame;
78   guint invokeId;
79 } ros_call_response_t;
80
81 static int hf_ros_response_in = -1;
82 static int hf_ros_response_to = -1;
83 static int hf_ros_time = -1;
84
85
86
87 /*--- Included file: packet-ros-hf.c ---*/
88 #line 1 "packet-ros-hf.c"
89 static int hf_ros_invoke = -1;                    /* Invoke */
90 static int hf_ros_returnResult = -1;              /* ReturnResult */
91 static int hf_ros_returnError = -1;               /* ReturnError */
92 static int hf_ros_reject = -1;                    /* Reject */
93 static int hf_ros_bind_invoke = -1;               /* T_bind_invoke */
94 static int hf_ros_bind_result = -1;               /* T_bind_result */
95 static int hf_ros_bind_error = -1;                /* T_bind_error */
96 static int hf_ros_unbind_invoke = -1;             /* T_unbind_invoke */
97 static int hf_ros_unbind_result = -1;             /* T_unbind_result */
98 static int hf_ros_unbind_error = -1;              /* T_unbind_error */
99 static int hf_ros_invokeId = -1;                  /* InvokeId */
100 static int hf_ros_linkedId = -1;                  /* INTEGER */
101 static int hf_ros_opcode = -1;                    /* OperationCode */
102 static int hf_ros_argument = -1;                  /* T_argument */
103 static int hf_ros_result = -1;                    /* T_result */
104 static int hf_ros_operationResult = -1;           /* OperationResult */
105 static int hf_ros_errcode = -1;                   /* ErrorCode */
106 static int hf_ros_parameter = -1;                 /* T_parameter */
107 static int hf_ros_problem = -1;                   /* T_problem */
108 static int hf_ros_general = -1;                   /* GeneralProblem */
109 static int hf_ros_invokeProblem = -1;             /* InvokeProblem */
110 static int hf_ros_rejectResult = -1;              /* ReturnResultProblem */
111 static int hf_ros_rejectError = -1;               /* ReturnErrorProblem */
112 static int hf_ros_present = -1;                   /* INTEGER */
113 static int hf_ros_absent = -1;                    /* NULL */
114 static int hf_ros_local = -1;                     /* INTEGER */
115 static int hf_ros_global = -1;                    /* OBJECT_IDENTIFIER */
116
117 /*--- End of included file: packet-ros-hf.c ---*/
118 #line 79 "packet-ros-template.c"
119
120 /* Initialize the subtree pointers */
121 static gint ett_ros = -1;
122
123 /*--- Included file: packet-ros-ett.c ---*/
124 #line 1 "packet-ros-ett.c"
125 static gint ett_ros_ROS = -1;
126 static gint ett_ros_Invoke = -1;
127 static gint ett_ros_ReturnResult = -1;
128 static gint ett_ros_T_result = -1;
129 static gint ett_ros_ReturnError = -1;
130 static gint ett_ros_Reject = -1;
131 static gint ett_ros_T_problem = -1;
132 static gint ett_ros_InvokeId = -1;
133 static gint ett_ros_Code = -1;
134
135 /*--- End of included file: packet-ros-ett.c ---*/
136 #line 83 "packet-ros-template.c"
137
138 static dissector_table_t ros_oid_dissector_table=NULL;
139 static GHashTable *oid_table=NULL;
140 static gint ett_ros_unknown = -1;
141
142 void
143 register_ros_oid_dissector_handle(const char *oid, dissector_handle_t dissector, int proto _U_, const char *name, gboolean uses_rtse)
144 {
145         dissector_add_string("ros.oid", oid, dissector);
146         g_hash_table_insert(oid_table, (gpointer)oid, (gpointer)name);
147
148         if(!uses_rtse)
149           /* if we are not using RTSE, then we must register ROS with BER (ACSE) */
150           register_ber_oid_dissector_handle(oid, ros_handle, proto, name);
151 }
152
153 static int
154 call_ros_oid_callback(const char *oid, tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
155 {
156         tvbuff_t *next_tvb;
157
158         next_tvb = tvb_new_subset(tvb, offset, tvb_length_remaining(tvb, offset), tvb_reported_length_remaining(tvb, offset));
159         if(!dissector_try_string(ros_oid_dissector_table, oid, next_tvb, pinfo, tree)){
160                 proto_item *item=NULL;
161                 proto_tree *next_tree=NULL;
162
163                 item=proto_tree_add_text(tree, next_tvb, 0, tvb_length_remaining(tvb, offset), "ROS: Dissector for OID:%s not implemented. Contact Wireshark developers if you want this supported", oid);
164                 if(item){
165                         next_tree=proto_item_add_subtree(item, ett_ros_unknown);
166                 }
167                 dissect_unknown_ber(pinfo, next_tvb, offset, next_tree);
168         }
169
170         /*XXX until we change the #.REGISTER signature for _PDU()s 
171          * into new_dissector_t   we have to do this kludge with
172          * manually step past the content in the ANY type.
173          */
174         offset+=tvb_length_remaining(tvb, offset);
175
176         return offset;
177 }
178
179
180 static guint
181 ros_info_hash_matched(gconstpointer k)
182 {
183   const ros_call_response_t *key = k;
184
185   return key->invokeId;
186 }
187
188 static gint
189 ros_info_equal_matched(gconstpointer k1, gconstpointer k2)
190 {
191   const ros_call_response_t *key1 = k1;
192   const ros_call_response_t *key2 = k2;
193
194   if( key1->req_frame && key2->req_frame && (key1->req_frame!=key2->req_frame) ){
195     return 0;
196   }
197   /* a response may span multiple frames
198   if( key1->rep_frame && key2->rep_frame && (key1->rep_frame!=key2->rep_frame) ){
199     return 0;
200   }
201   */
202
203   return key1->invokeId==key2->invokeId;
204 }
205
206 static guint
207 ros_info_hash_unmatched(gconstpointer k)
208 {
209   const ros_call_response_t *key = k;
210
211   return key->invokeId;
212 }
213
214 static gint
215 ros_info_equal_unmatched(gconstpointer k1, gconstpointer k2)
216 {
217   const ros_call_response_t *key1 = k1;
218   const ros_call_response_t *key2 = k2;
219
220   return key1->invokeId==key2->invokeId;
221 }
222
223 static ros_call_response_t *
224 ros_match_call_response(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint invokeId, gboolean isInvoke)
225 {
226   ros_call_response_t rcr, *rcrp=NULL;
227   ros_conv_info_t *ros_info = ros_info_items;
228
229   /* first see if we have already matched this */
230
231   rcr.invokeId=invokeId;
232   rcr.is_request = isInvoke;
233
234   if(isInvoke) {
235     rcr.req_frame=pinfo->fd->num;
236     rcr.rep_frame=0;
237   } else {
238     rcr.req_frame=0;
239     rcr.rep_frame=pinfo->fd->num;
240   }
241   
242   rcrp=g_hash_table_lookup(ros_info->matched, &rcr);
243
244   if(rcrp) {
245     /* we have found a match */
246     rcrp->is_request=rcr.is_request;
247
248   } else {
249     
250     /* we haven't found a match - try and match it up */
251
252     if(isInvoke) {
253       /* this a a request - add it to the unmatched list */
254
255       /* check that we dont already have one of those in the
256          unmatched list and if so remove it */
257
258       rcr.invokeId=invokeId;
259
260       rcrp=g_hash_table_lookup(ros_info->unmatched, &rcr);
261
262       if(rcrp){
263         g_hash_table_remove(ros_info->unmatched, rcrp);
264       }
265       
266       /* if we cant reuse the old one, grab a new chunk */
267       if(!rcrp){
268         rcrp=se_alloc(sizeof(ros_call_response_t));
269       }
270       rcrp->invokeId=invokeId;
271       rcrp->req_frame=pinfo->fd->num;
272       rcrp->req_time=pinfo->fd->abs_ts;
273       rcrp->rep_frame=0;
274       rcrp->is_request=TRUE;
275       g_hash_table_insert(ros_info->unmatched, rcrp, rcrp);
276       return NULL;
277
278     } else {
279
280       /* this is a result - it should be in our unmatched list */
281
282       rcr.invokeId=invokeId;
283       rcrp=g_hash_table_lookup(ros_info->unmatched, &rcr);
284
285       if(rcrp){
286
287         if(!rcrp->rep_frame){
288           g_hash_table_remove(ros_info->unmatched, rcrp);
289           rcrp->rep_frame=pinfo->fd->num;
290           rcrp->is_request=FALSE;
291           g_hash_table_insert(ros_info->matched, rcrp, rcrp);
292         }
293       }
294     }
295   }
296
297   if(rcrp){ /* we have found a match */
298
299     if(rcrp->is_request){
300       proto_tree_add_uint(tree, hf_ros_response_in, tvb, 0, 0, rcrp->rep_frame);
301     } else {
302       nstime_t ns;
303       proto_tree_add_uint(tree, hf_ros_response_to, tvb, 0, 0, rcrp->req_frame);
304       nstime_delta(&ns, &pinfo->fd->abs_ts, &rcrp->req_time);
305       proto_tree_add_time(tree, hf_ros_time, tvb, 0, 0, &ns);
306     }
307   }
308   
309   return rcrp;
310 }
311
312
313 /*--- Included file: packet-ros-fn.c ---*/
314 #line 1 "packet-ros-fn.c"
315 /*--- Fields for imported types ---*/
316
317
318
319
320 static int
321 dissect_ros_INTEGER(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
322   offset = dissect_ber_integer(implicit_tag, pinfo, tree, tvb, offset, hf_index,
323                                   &invokeid);
324
325   return offset;
326 }
327 static int dissect_linkedId_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
328   return dissect_ros_INTEGER(TRUE, tvb, offset, pinfo, tree, hf_ros_linkedId);
329 }
330 static int dissect_present(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
331   return dissect_ros_INTEGER(FALSE, tvb, offset, pinfo, tree, hf_ros_present);
332 }
333 static int dissect_local(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
334   return dissect_ros_INTEGER(FALSE, tvb, offset, pinfo, tree, hf_ros_local);
335 }
336
337
338
339 static int
340 dissect_ros_NULL(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
341   offset = dissect_ber_null(implicit_tag, pinfo, tree, tvb, offset, hf_index);
342
343   return offset;
344 }
345 static int dissect_absent(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
346   return dissect_ros_NULL(FALSE, tvb, offset, pinfo, tree, hf_ros_absent);
347 }
348
349
350 const value_string ros_InvokeId_vals[] = {
351   {   0, "present" },
352   {   1, "absent" },
353   { 0, NULL }
354 };
355
356 static const ber_choice_t InvokeId_choice[] = {
357   {   0, BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_present },
358   {   1, BER_CLASS_UNI, BER_UNI_TAG_NULL, BER_FLAGS_NOOWNTAG, dissect_absent },
359   { 0, 0, 0, 0, NULL }
360 };
361
362 int
363 dissect_ros_InvokeId(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
364   offset = dissect_ber_choice(pinfo, tree, tvb, offset,
365                                  InvokeId_choice, hf_index, ett_ros_InvokeId,
366                                  NULL);
367
368   return offset;
369 }
370 static int dissect_invokeId(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
371   return dissect_ros_InvokeId(FALSE, tvb, offset, pinfo, tree, hf_ros_invokeId);
372 }
373
374
375
376 static int
377 dissect_ros_OperationCode(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
378   offset = dissect_ber_integer(implicit_tag, pinfo, tree, tvb, offset, hf_index,
379                                   &opcode);
380
381   return offset;
382 }
383 static int dissect_opcode(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
384   return dissect_ros_OperationCode(FALSE, tvb, offset, pinfo, tree, hf_ros_opcode);
385 }
386
387
388
389 static int
390 dissect_ros_T_argument(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
391 #line 21 "ros.cnf"
392   char *oid;
393   /* not sure what the length should be - -1 for now */
394   proto_tree_add_text(tree, tvb, offset,-1, "invoke argument");
395
396   ros_match_call_response(tvb, pinfo, tree, invokeid, TRUE);
397         
398   if(session && session->pres_ctx_id && (oid = find_oid_by_pres_ctx_id(pinfo, session->pres_ctx_id))) {
399         /* this should be ROS! */
400         session->ros_op = (ROS_OP_INVOKE | ROS_OP_ARGUMENT);
401         /* now add the opcode */
402         session->ros_op |= opcode;
403         offset = call_ros_oid_callback(oid, tvb, offset, pinfo, top_tree);
404   }
405
406
407
408   return offset;
409 }
410 static int dissect_argument(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
411   return dissect_ros_T_argument(FALSE, tvb, offset, pinfo, tree, hf_ros_argument);
412 }
413
414
415 static const ber_sequence_t Invoke_sequence[] = {
416   { BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_invokeId },
417   { BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_linkedId_impl },
418   { BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_opcode },
419   { BER_CLASS_ANY, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_argument },
420   { 0, 0, 0, NULL }
421 };
422
423 static int
424 dissect_ros_Invoke(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
425   offset = dissect_ber_sequence(implicit_tag, pinfo, tree, tvb, offset,
426                                    Invoke_sequence, hf_index, ett_ros_Invoke);
427
428   return offset;
429 }
430 static int dissect_invoke_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
431   return dissect_ros_Invoke(TRUE, tvb, offset, pinfo, tree, hf_ros_invoke);
432 }
433
434
435
436 static int
437 dissect_ros_OperationResult(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
438 #line 36 "ros.cnf"
439   char *oid;
440   /* not sure what the length should be - -1 for now */
441   proto_tree_add_text(tree, tvb, offset,-1, "return result");
442
443   ros_match_call_response(tvb, pinfo, tree, invokeid, FALSE);
444         
445   if(session && session->pres_ctx_id && (oid = find_oid_by_pres_ctx_id(pinfo, session->pres_ctx_id))) {
446         /* this should be ROS! */
447         session->ros_op = (ROS_OP_INVOKE | ROS_OP_RESULT);
448         /* now add the opcode */
449         session->ros_op |= opcode;
450         offset = call_ros_oid_callback(oid, tvb, offset, pinfo, top_tree);
451   }
452
453
454
455   return offset;
456 }
457 static int dissect_operationResult(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
458   return dissect_ros_OperationResult(FALSE, tvb, offset, pinfo, tree, hf_ros_operationResult);
459 }
460
461
462 static const ber_sequence_t T_result_sequence[] = {
463   { BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_opcode },
464   { BER_CLASS_ANY, 0, BER_FLAGS_NOOWNTAG, dissect_operationResult },
465   { 0, 0, 0, NULL }
466 };
467
468 static int
469 dissect_ros_T_result(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
470   offset = dissect_ber_sequence(implicit_tag, pinfo, tree, tvb, offset,
471                                    T_result_sequence, hf_index, ett_ros_T_result);
472
473   return offset;
474 }
475 static int dissect_result(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
476   return dissect_ros_T_result(FALSE, tvb, offset, pinfo, tree, hf_ros_result);
477 }
478
479
480 static const ber_sequence_t ReturnResult_sequence[] = {
481   { BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_invokeId },
482   { BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_result },
483   { 0, 0, 0, NULL }
484 };
485
486 static int
487 dissect_ros_ReturnResult(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
488   offset = dissect_ber_sequence(implicit_tag, pinfo, tree, tvb, offset,
489                                    ReturnResult_sequence, hf_index, ett_ros_ReturnResult);
490
491   return offset;
492 }
493 static int dissect_returnResult_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
494   return dissect_ros_ReturnResult(TRUE, tvb, offset, pinfo, tree, hf_ros_returnResult);
495 }
496
497
498
499 static int
500 dissect_ros_ErrorCode(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
501   offset = dissect_ber_integer(implicit_tag, pinfo, tree, tvb, offset, hf_index,
502                                   &opcode);
503
504   return offset;
505 }
506 static int dissect_errcode(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
507   return dissect_ros_ErrorCode(FALSE, tvb, offset, pinfo, tree, hf_ros_errcode);
508 }
509
510
511
512 static int
513 dissect_ros_T_parameter(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
514 #line 51 "ros.cnf"
515   char *oid;
516   /* not sure what the length should be - -1 for now */
517   proto_tree_add_text(tree, tvb, offset,-1, "return result");
518
519   ros_match_call_response(tvb, pinfo, tree, invokeid, FALSE);
520         
521   if(session && session->pres_ctx_id && (oid = find_oid_by_pres_ctx_id(pinfo, session->pres_ctx_id))) {
522         /* this should be ROS! */
523         session->ros_op = (ROS_OP_INVOKE | ROS_OP_ERROR);
524         /* now add the opcode  (really the errode) */
525         session->ros_op |= opcode;
526         offset = call_ros_oid_callback(oid, tvb, offset, pinfo, top_tree);
527   }
528
529
530
531
532   return offset;
533 }
534 static int dissect_parameter(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
535   return dissect_ros_T_parameter(FALSE, tvb, offset, pinfo, tree, hf_ros_parameter);
536 }
537
538
539 static const ber_sequence_t ReturnError_sequence[] = {
540   { BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_invokeId },
541   { BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_errcode },
542   { BER_CLASS_ANY, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_parameter },
543   { 0, 0, 0, NULL }
544 };
545
546 static int
547 dissect_ros_ReturnError(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
548   offset = dissect_ber_sequence(implicit_tag, pinfo, tree, tvb, offset,
549                                    ReturnError_sequence, hf_index, ett_ros_ReturnError);
550
551   return offset;
552 }
553 static int dissect_returnError_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
554   return dissect_ros_ReturnError(TRUE, tvb, offset, pinfo, tree, hf_ros_returnError);
555 }
556
557
558 static const value_string ros_GeneralProblem_vals[] = {
559   {   0, "unrecognizedPDU" },
560   {   1, "mistypedPDU" },
561   {   2, "badlyStructuredPDU" },
562   { 0, NULL }
563 };
564
565
566 static int
567 dissect_ros_GeneralProblem(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
568   offset = dissect_ber_integer(implicit_tag, pinfo, tree, tvb, offset, hf_index,
569                                   NULL);
570
571   return offset;
572 }
573 static int dissect_general_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
574   return dissect_ros_GeneralProblem(TRUE, tvb, offset, pinfo, tree, hf_ros_general);
575 }
576
577
578 static const value_string ros_InvokeProblem_vals[] = {
579   {   0, "duplicateInvocation" },
580   {   1, "unrecognizedOperation" },
581   {   2, "mistypedArgument" },
582   {   3, "resourceLimitation" },
583   {   4, "releaseInProgress" },
584   {   5, "unrecognizedLinkedId" },
585   {   6, "linkedResponseUnexpected" },
586   {   7, "unexpectedLinkedOperation" },
587   { 0, NULL }
588 };
589
590
591 static int
592 dissect_ros_InvokeProblem(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
593   offset = dissect_ber_integer(implicit_tag, pinfo, tree, tvb, offset, hf_index,
594                                   NULL);
595
596   return offset;
597 }
598 static int dissect_invokeProblem_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
599   return dissect_ros_InvokeProblem(TRUE, tvb, offset, pinfo, tree, hf_ros_invokeProblem);
600 }
601
602
603 static const value_string ros_ReturnResultProblem_vals[] = {
604   {   0, "unrecognizedInvocation" },
605   {   1, "resultResponseUnexpected" },
606   {   2, "mistypedResult" },
607   { 0, NULL }
608 };
609
610
611 static int
612 dissect_ros_ReturnResultProblem(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
613   offset = dissect_ber_integer(implicit_tag, pinfo, tree, tvb, offset, hf_index,
614                                   NULL);
615
616   return offset;
617 }
618 static int dissect_rejectResult_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
619   return dissect_ros_ReturnResultProblem(TRUE, tvb, offset, pinfo, tree, hf_ros_rejectResult);
620 }
621
622
623 static const value_string ros_ReturnErrorProblem_vals[] = {
624   {   0, "unrecognizedInvocation" },
625   {   1, "errorResponseUnexpected" },
626   {   2, "unrecognizedError" },
627   {   3, "unexpectedError" },
628   {   4, "mistypedParameter" },
629   { 0, NULL }
630 };
631
632
633 static int
634 dissect_ros_ReturnErrorProblem(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
635   offset = dissect_ber_integer(implicit_tag, pinfo, tree, tvb, offset, hf_index,
636                                   NULL);
637
638   return offset;
639 }
640 static int dissect_rejectError_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
641   return dissect_ros_ReturnErrorProblem(TRUE, tvb, offset, pinfo, tree, hf_ros_rejectError);
642 }
643
644
645 static const value_string ros_T_problem_vals[] = {
646   {   0, "general" },
647   {   1, "invoke" },
648   {   2, "returnResult" },
649   {   3, "returnError" },
650   { 0, NULL }
651 };
652
653 static const ber_choice_t T_problem_choice[] = {
654   {   0, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_general_impl },
655   {   1, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_invokeProblem_impl },
656   {   2, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_rejectResult_impl },
657   {   3, BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_rejectError_impl },
658   { 0, 0, 0, 0, NULL }
659 };
660
661 static int
662 dissect_ros_T_problem(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
663   offset = dissect_ber_choice(pinfo, tree, tvb, offset,
664                                  T_problem_choice, hf_index, ett_ros_T_problem,
665                                  NULL);
666
667   return offset;
668 }
669 static int dissect_problem(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
670   return dissect_ros_T_problem(FALSE, tvb, offset, pinfo, tree, hf_ros_problem);
671 }
672
673
674 static const ber_sequence_t Reject_sequence[] = {
675   { BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_invokeId },
676   { BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_problem },
677   { 0, 0, 0, NULL }
678 };
679
680 static int
681 dissect_ros_Reject(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
682   offset = dissect_ber_sequence(implicit_tag, pinfo, tree, tvb, offset,
683                                    Reject_sequence, hf_index, ett_ros_Reject);
684
685   return offset;
686 }
687 static int dissect_reject_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
688   return dissect_ros_Reject(TRUE, tvb, offset, pinfo, tree, hf_ros_reject);
689 }
690
691
692
693 static int
694 dissect_ros_T_bind_invoke(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
695 #line 67 "ros.cnf"
696   char *oid;
697   /* not sure what the length should be - -1 for now */
698   proto_tree_add_text(tree, tvb, offset,-1, "bind-invoke");
699
700   if(session && session->pres_ctx_id && (oid = find_oid_by_pres_ctx_id(pinfo, session->pres_ctx_id))) {
701     /* this should be ROS! */
702     session->ros_op = (ROS_OP_BIND | ROS_OP_ARGUMENT);
703     offset = call_ros_oid_callback(oid, tvb, offset, pinfo, top_tree);
704   }
705
706
707
708   return offset;
709 }
710 static int dissect_bind_invoke_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
711   return dissect_ros_T_bind_invoke(TRUE, tvb, offset, pinfo, tree, hf_ros_bind_invoke);
712 }
713
714
715
716 static int
717 dissect_ros_T_bind_result(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
718 #line 78 "ros.cnf"
719   char *oid;
720   /* not sure what the length should be - -1 for now */
721   proto_tree_add_text(tree, tvb, offset,-1, "bind-result");
722
723   if(session && session->pres_ctx_id && (oid = find_oid_by_pres_ctx_id(pinfo, session->pres_ctx_id))) {
724     /* this should be ROS! */
725     session->ros_op = (ROS_OP_BIND | ROS_OP_RESULT);
726     offset = call_ros_oid_callback(oid, tvb, offset, pinfo, top_tree);
727   }
728
729
730
731   return offset;
732 }
733 static int dissect_bind_result_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
734   return dissect_ros_T_bind_result(TRUE, tvb, offset, pinfo, tree, hf_ros_bind_result);
735 }
736
737
738
739 static int
740 dissect_ros_T_bind_error(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
741 #line 89 "ros.cnf"
742   char *oid;
743   /* not sure what the length should be - -1 for now */
744   proto_tree_add_text(tree, tvb, offset,-1, "bind-error");
745
746   if(session && session->pres_ctx_id && (oid = find_oid_by_pres_ctx_id(pinfo, session->pres_ctx_id))) {
747     /* this should be ROS! */
748     session->ros_op = (ROS_OP_BIND | ROS_OP_ERROR);
749     offset = call_ros_oid_callback(oid, tvb, offset, pinfo, top_tree);
750   }
751
752
753
754
755   return offset;
756 }
757 static int dissect_bind_error_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
758   return dissect_ros_T_bind_error(TRUE, tvb, offset, pinfo, tree, hf_ros_bind_error);
759 }
760
761
762
763 static int
764 dissect_ros_T_unbind_invoke(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
765 #line 101 "ros.cnf"
766   char *oid;
767   /* not sure what the length should be - -1 for now */
768   proto_tree_add_text(tree, tvb, offset,-1, "unbind-invoke");
769
770   if(session && session->pres_ctx_id && (oid = find_oid_by_pres_ctx_id(pinfo, session->pres_ctx_id))) {
771     /* this should be ROS! */
772     session->ros_op = (ROS_OP_UNBIND | ROS_OP_ARGUMENT);
773     offset = call_ros_oid_callback(oid, tvb, offset, pinfo, top_tree);
774   }
775
776
777
778
779   return offset;
780 }
781 static int dissect_unbind_invoke_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
782   return dissect_ros_T_unbind_invoke(TRUE, tvb, offset, pinfo, tree, hf_ros_unbind_invoke);
783 }
784
785
786
787 static int
788 dissect_ros_T_unbind_result(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
789 #line 113 "ros.cnf"
790   char *oid;
791   /* not sure what the length should be - -1 for now */
792   proto_tree_add_text(tree, tvb, offset,-1, "unbind-result");
793
794   if(session && session->pres_ctx_id && (oid = find_oid_by_pres_ctx_id(pinfo, session->pres_ctx_id))) {
795     /* this should be ROS! */
796     session->ros_op = (ROS_OP_UNBIND | ROS_OP_RESULT);
797     offset = call_ros_oid_callback(oid, tvb, offset, pinfo, top_tree);
798   }
799
800
801
802   return offset;
803 }
804 static int dissect_unbind_result_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
805   return dissect_ros_T_unbind_result(TRUE, tvb, offset, pinfo, tree, hf_ros_unbind_result);
806 }
807
808
809
810 static int
811 dissect_ros_T_unbind_error(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
812 #line 124 "ros.cnf"
813   char *oid;
814   /* not sure what the length should be - -1 for now */
815   proto_tree_add_text(tree, tvb, offset,-1, "unbind-error");
816
817   if(session && session->pres_ctx_id && (oid = find_oid_by_pres_ctx_id(pinfo, session->pres_ctx_id))) {
818     /* this should be ROS! */
819     session->ros_op = (ROS_OP_UNBIND | ROS_OP_ERROR);
820     offset = call_ros_oid_callback(oid, tvb, offset, pinfo, top_tree);
821   }
822
823
824   return offset;
825 }
826 static int dissect_unbind_error_impl(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
827   return dissect_ros_T_unbind_error(TRUE, tvb, offset, pinfo, tree, hf_ros_unbind_error);
828 }
829
830
831 static const value_string ros_ROS_vals[] = {
832   {   1, "invoke" },
833   {   2, "returnResult" },
834   {   3, "returnError" },
835   {   4, "reject" },
836   {  16, "bind-invoke" },
837   {  17, "bind-result" },
838   {  18, "bind-error" },
839   {  19, "unbind-invoke" },
840   {  20, "unbind-result" },
841   {  21, "unbind-error" },
842   { 0, NULL }
843 };
844
845 static const ber_choice_t ROS_choice[] = {
846   {   1, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_invoke_impl },
847   {   2, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_returnResult_impl },
848   {   3, BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_returnError_impl },
849   {   4, BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_reject_impl },
850   {  16, BER_CLASS_CON, 16, BER_FLAGS_IMPLTAG, dissect_bind_invoke_impl },
851   {  17, BER_CLASS_CON, 17, BER_FLAGS_IMPLTAG, dissect_bind_result_impl },
852   {  18, BER_CLASS_CON, 18, BER_FLAGS_IMPLTAG, dissect_bind_error_impl },
853   {  19, BER_CLASS_CON, 19, BER_FLAGS_IMPLTAG, dissect_unbind_invoke_impl },
854   {  20, BER_CLASS_CON, 20, BER_FLAGS_IMPLTAG, dissect_unbind_result_impl },
855   {  21, BER_CLASS_CON, 21, BER_FLAGS_IMPLTAG, dissect_unbind_error_impl },
856   { 0, 0, 0, 0, NULL }
857 };
858
859 static int
860 dissect_ros_ROS(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
861   offset = dissect_ber_choice(pinfo, tree, tvb, offset,
862                                  ROS_choice, hf_index, ett_ros_ROS,
863                                  NULL);
864
865   return offset;
866 }
867
868
869
870 static int
871 dissect_ros_OBJECT_IDENTIFIER(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
872   offset = dissect_ber_object_identifier(implicit_tag, pinfo, tree, tvb, offset, hf_index, NULL);
873
874   return offset;
875 }
876 static int dissect_global(packet_info *pinfo _U_, proto_tree *tree _U_, tvbuff_t *tvb _U_, int offset _U_) {
877   return dissect_ros_OBJECT_IDENTIFIER(FALSE, tvb, offset, pinfo, tree, hf_ros_global);
878 }
879
880
881 const value_string ros_Code_vals[] = {
882   {   0, "local" },
883   {   1, "global" },
884   { 0, NULL }
885 };
886
887 static const ber_choice_t Code_choice[] = {
888   {   0, BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_local },
889   {   1, BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_global },
890   { 0, 0, 0, 0, NULL }
891 };
892
893 int
894 dissect_ros_Code(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, packet_info *pinfo _U_, proto_tree *tree _U_, int hf_index _U_) {
895   offset = dissect_ber_choice(pinfo, tree, tvb, offset,
896                                  Code_choice, hf_index, ett_ros_Code,
897                                  NULL);
898
899   return offset;
900 }
901
902
903 /*--- End of included file: packet-ros-fn.c ---*/
904 #line 259 "packet-ros-template.c"
905
906 /*
907 * Dissect ROS PDUs inside a PPDU.
908 */
909 static void
910 dissect_ros(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree)
911 {
912         int offset = 0;
913         int old_offset;
914         proto_item *item=NULL;
915         proto_tree *tree=NULL;
916         conversation_t *conversation;
917         ros_conv_info_t *ros_info = NULL;
918
919         /* save parent_tree so subdissectors can create new top nodes */
920         top_tree=parent_tree;
921
922         /* do we have application context from the acse dissector?  */
923         if( !pinfo->private_data ){
924                 if(parent_tree){
925                         proto_tree_add_text(parent_tree, tvb, offset, -1,
926                                 "Internal error:can't get application context from ACSE dissector.");
927                 } 
928                 return  ;
929         } else {
930                 session  = ( (struct SESSION_DATA_STRUCTURE*)(pinfo->private_data) );
931
932         }
933
934         /*
935          * Do we have a conversation for this connection?
936          */
937         conversation = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst,
938                                          pinfo->ptype, pinfo->srcport,
939                                          pinfo->destport, 0);
940         if (conversation == NULL) {
941           /* We don't yet have a conversation, so create one. */
942           conversation = conversation_new(pinfo->fd->num, &pinfo->src, &pinfo->dst,
943                                           pinfo->ptype, pinfo->srcport,
944                                           pinfo->destport, 0);
945
946         }
947
948         /*
949          * Do we already have our info
950          */
951         ros_info = conversation_get_proto_data(conversation, proto_ros);
952         if (ros_info == NULL) {
953
954           /* No.  Attach that information to the conversation. */
955
956           ros_info = se_alloc(sizeof(ros_conv_info_t));
957           ros_info->matched=g_hash_table_new(ros_info_hash_matched, ros_info_equal_matched);
958           ros_info->unmatched=g_hash_table_new(ros_info_hash_unmatched, ros_info_equal_unmatched);
959           
960           conversation_add_proto_data(conversation, proto_ros, ros_info);
961           
962           ros_info->next = ros_info_items;
963           ros_info_items = ros_info;
964           }
965
966         /* pinfo->private_data = ros_info; */
967
968         if(parent_tree){
969                 item = proto_tree_add_item(parent_tree, proto_ros, tvb, 0, -1, FALSE);
970                 tree = proto_item_add_subtree(item, ett_ros);
971         }
972         if (check_col(pinfo->cinfo, COL_PROTOCOL))
973                 col_set_str(pinfo->cinfo, COL_PROTOCOL, "ROS");
974         if (check_col(pinfo->cinfo, COL_INFO))
975                 col_clear(pinfo->cinfo, COL_INFO);
976
977         while (tvb_reported_length_remaining(tvb, offset) > 0){
978                 old_offset=offset;
979                 offset=dissect_ros_ROS(FALSE, tvb, offset, pinfo , tree, -1);
980                 if(offset == old_offset){
981                         proto_tree_add_text(tree, tvb, offset, -1,"Internal error, zero-byte ROS PDU");
982                         offset = tvb_length(tvb);
983                         break;
984                 }
985         }
986 }
987
988 static void
989 ros_reinit(void)
990 {
991   ros_conv_info_t *ros_info;
992
993   /* Free up state attached to the ros_info structures */
994   for (ros_info = ros_info_items; ros_info != NULL; ros_info = ros_info->next) {
995     g_hash_table_destroy(ros_info->matched);
996     ros_info->matched=NULL;
997     g_hash_table_destroy(ros_info->unmatched);
998     ros_info->unmatched=NULL;
999   }
1000
1001   ros_info_items = NULL;
1002
1003 }
1004
1005 /*--- proto_register_ros -------------------------------------------*/
1006 void proto_register_ros(void) {
1007
1008   /* List of fields */
1009   static hf_register_info hf[] =
1010   {
1011     { &hf_ros_response_in,
1012       { "Response In", "ros.response_in",
1013         FT_FRAMENUM, BASE_DEC, NULL, 0x0,
1014         "The response to this remote operation invocation is in this frame", HFILL }},
1015     { &hf_ros_response_to,
1016       { "Response To", "ros.response_to",
1017         FT_FRAMENUM, BASE_DEC, NULL, 0x0,
1018         "This is a response to the remote operation invocation in this frame", HFILL }},
1019     { &hf_ros_time,
1020       { "Time", "ros.time",
1021         FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0,
1022         "The time between the Invoke and the Response", HFILL }},
1023
1024
1025 /*--- Included file: packet-ros-hfarr.c ---*/
1026 #line 1 "packet-ros-hfarr.c"
1027     { &hf_ros_invoke,
1028       { "invoke", "ros.invoke",
1029         FT_NONE, BASE_NONE, NULL, 0,
1030         "ros.Invoke", HFILL }},
1031     { &hf_ros_returnResult,
1032       { "returnResult", "ros.returnResult",
1033         FT_NONE, BASE_NONE, NULL, 0,
1034         "ros.ReturnResult", HFILL }},
1035     { &hf_ros_returnError,
1036       { "returnError", "ros.returnError",
1037         FT_NONE, BASE_NONE, NULL, 0,
1038         "ros.ReturnError", HFILL }},
1039     { &hf_ros_reject,
1040       { "reject", "ros.reject",
1041         FT_NONE, BASE_NONE, NULL, 0,
1042         "ros.Reject", HFILL }},
1043     { &hf_ros_bind_invoke,
1044       { "bind-invoke", "ros.bind_invoke",
1045         FT_NONE, BASE_NONE, NULL, 0,
1046         "ros.T_bind_invoke", HFILL }},
1047     { &hf_ros_bind_result,
1048       { "bind-result", "ros.bind_result",
1049         FT_NONE, BASE_NONE, NULL, 0,
1050         "ros.T_bind_result", HFILL }},
1051     { &hf_ros_bind_error,
1052       { "bind-error", "ros.bind_error",
1053         FT_NONE, BASE_NONE, NULL, 0,
1054         "ros.T_bind_error", HFILL }},
1055     { &hf_ros_unbind_invoke,
1056       { "unbind-invoke", "ros.unbind_invoke",
1057         FT_NONE, BASE_NONE, NULL, 0,
1058         "ros.T_unbind_invoke", HFILL }},
1059     { &hf_ros_unbind_result,
1060       { "unbind-result", "ros.unbind_result",
1061         FT_NONE, BASE_NONE, NULL, 0,
1062         "ros.T_unbind_result", HFILL }},
1063     { &hf_ros_unbind_error,
1064       { "unbind-error", "ros.unbind_error",
1065         FT_NONE, BASE_NONE, NULL, 0,
1066         "ros.T_unbind_error", HFILL }},
1067     { &hf_ros_invokeId,
1068       { "invokeId", "ros.invokeId",
1069         FT_UINT32, BASE_DEC, VALS(ros_InvokeId_vals), 0,
1070         "ros.InvokeId", HFILL }},
1071     { &hf_ros_linkedId,
1072       { "linkedId", "ros.linkedId",
1073         FT_INT32, BASE_DEC, NULL, 0,
1074         "ros.INTEGER", HFILL }},
1075     { &hf_ros_opcode,
1076       { "opcode", "ros.opcode",
1077         FT_INT32, BASE_DEC, NULL, 0,
1078         "ros.OperationCode", HFILL }},
1079     { &hf_ros_argument,
1080       { "argument", "ros.argument",
1081         FT_NONE, BASE_NONE, NULL, 0,
1082         "ros.T_argument", HFILL }},
1083     { &hf_ros_result,
1084       { "result", "ros.result",
1085         FT_NONE, BASE_NONE, NULL, 0,
1086         "ros.T_result", HFILL }},
1087     { &hf_ros_operationResult,
1088       { "result", "ros.result",
1089         FT_NONE, BASE_NONE, NULL, 0,
1090         "ros.OperationResult", HFILL }},
1091     { &hf_ros_errcode,
1092       { "errcode", "ros.errcode",
1093         FT_INT32, BASE_DEC, NULL, 0,
1094         "ros.ErrorCode", HFILL }},
1095     { &hf_ros_parameter,
1096       { "parameter", "ros.parameter",
1097         FT_NONE, BASE_NONE, NULL, 0,
1098         "ros.T_parameter", HFILL }},
1099     { &hf_ros_problem,
1100       { "problem", "ros.problem",
1101         FT_UINT32, BASE_DEC, VALS(ros_T_problem_vals), 0,
1102         "ros.T_problem", HFILL }},
1103     { &hf_ros_general,
1104       { "general", "ros.general",
1105         FT_INT32, BASE_DEC, VALS(ros_GeneralProblem_vals), 0,
1106         "ros.GeneralProblem", HFILL }},
1107     { &hf_ros_invokeProblem,
1108       { "invoke", "ros.invoke",
1109         FT_INT32, BASE_DEC, VALS(ros_InvokeProblem_vals), 0,
1110         "ros.InvokeProblem", HFILL }},
1111     { &hf_ros_rejectResult,
1112       { "returnResult", "ros.returnResult",
1113         FT_INT32, BASE_DEC, VALS(ros_ReturnResultProblem_vals), 0,
1114         "ros.ReturnResultProblem", HFILL }},
1115     { &hf_ros_rejectError,
1116       { "returnError", "ros.returnError",
1117         FT_INT32, BASE_DEC, VALS(ros_ReturnErrorProblem_vals), 0,
1118         "ros.ReturnErrorProblem", HFILL }},
1119     { &hf_ros_present,
1120       { "present", "ros.present",
1121         FT_INT32, BASE_DEC, NULL, 0,
1122         "ros.INTEGER", HFILL }},
1123     { &hf_ros_absent,
1124       { "absent", "ros.absent",
1125         FT_NONE, BASE_NONE, NULL, 0,
1126         "ros.NULL", HFILL }},
1127     { &hf_ros_local,
1128       { "local", "ros.local",
1129         FT_INT32, BASE_DEC, NULL, 0,
1130         "ros.INTEGER", HFILL }},
1131     { &hf_ros_global,
1132       { "global", "ros.global",
1133         FT_OID, BASE_NONE, NULL, 0,
1134         "ros.OBJECT_IDENTIFIER", HFILL }},
1135
1136 /*--- End of included file: packet-ros-hfarr.c ---*/
1137 #line 379 "packet-ros-template.c"
1138   };
1139
1140   /* List of subtrees */
1141   static gint *ett[] = {
1142     &ett_ros,
1143     &ett_ros_unknown,
1144
1145 /*--- Included file: packet-ros-ettarr.c ---*/
1146 #line 1 "packet-ros-ettarr.c"
1147     &ett_ros_ROS,
1148     &ett_ros_Invoke,
1149     &ett_ros_ReturnResult,
1150     &ett_ros_T_result,
1151     &ett_ros_ReturnError,
1152     &ett_ros_Reject,
1153     &ett_ros_T_problem,
1154     &ett_ros_InvokeId,
1155     &ett_ros_Code,
1156
1157 /*--- End of included file: packet-ros-ettarr.c ---*/
1158 #line 386 "packet-ros-template.c"
1159   };
1160
1161   /* Register protocol */
1162   proto_ros = proto_register_protocol(PNAME, PSNAME, PFNAME);
1163   register_dissector("ros", dissect_ros, proto_ros);
1164   /* Register fields and subtrees */
1165   proto_register_field_array(proto_ros, hf, array_length(hf));
1166   proto_register_subtree_array(ett, array_length(ett));
1167
1168   ros_oid_dissector_table = register_dissector_table("ros.oid", "ROS OID Dissectors", FT_STRING, BASE_NONE);
1169   oid_table=g_hash_table_new(g_str_hash, g_str_equal);
1170
1171   ros_handle = find_dissector("ros");
1172
1173   register_init_routine(ros_reinit);
1174 }
1175
1176
1177 /*--- proto_reg_handoff_ros --- */
1178 void proto_reg_handoff_ros(void) {
1179
1180
1181 }