2005-09-04 20:30:31 +00:00
/* Do not modify this file. */
2006-05-24 12:24:54 +00:00
/* It is created automatically by the ASN.1 to Wireshark dissector compiler */
2007-10-22 17:03:09 +00:00
/* packet-ros.c */
2009-05-16 22:07:03 +00:00
/* ../../tools/asn2wrs.py -b -e -p ros -c ./ros.cnf -s ./packet-ros-template -D . ros.asn Remote-Operations-Information-Objects.asn */
2005-09-04 20:30:31 +00:00
/* Input file: packet-ros-template.c */
2005-12-08 23:29:21 +00:00
# line 1 "packet-ros-template.c"
2005-09-04 20:30:31 +00:00
/* packet-ros_asn1.c
* Routines for ROS packet dissection
* Graeme Lunt 2005
*
* $ Id $
*
2006-05-21 04:49:01 +00:00
* Wireshark - Network traffic analyzer
* By Gerald Combs < gerald @ wireshark . org >
2005-09-04 20:30:31 +00:00
* Copyright 1998 Gerald Combs
*
* This program is free software ; you can redistribute it and / or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation ; either version 2
* of the License , or ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with this program ; if not , write to the Free Software
* Foundation , Inc . , 59 Temple Place - Suite 330 , Boston , MA 02111 - 1307 , USA .
*/
# ifdef HAVE_CONFIG_H
# include "config.h"
# endif
# include <glib.h>
# include <epan/packet.h>
# include <epan/conversation.h>
2006-05-01 10:17:59 +00:00
# include <epan/emem.h>
2007-05-13 20:58:29 +00:00
# include <epan/asn1.h>
2009-05-20 09:27:45 +00:00
# include <epan/expert.h>
2005-09-04 20:30:31 +00:00
# include "packet-ber.h"
# include "packet-pres.h"
# include "packet-ros.h"
# define PNAME "X.880 OSI Remote Operations Service"
# define PSNAME "ROS"
# define PFNAME "ros"
/* Initialize the protocol and registered fields */
2009-10-11 16:24:29 +00:00
static int proto_ros = - 1 ;
2005-09-04 20:30:31 +00:00
static struct SESSION_DATA_STRUCTURE * session = NULL ;
static proto_tree * top_tree = NULL ;
static guint32 opcode ;
2006-05-01 10:17:59 +00:00
static guint32 invokeid ;
2005-09-04 20:30:31 +00:00
2005-10-24 21:42:19 +00:00
static dissector_handle_t ros_handle = NULL ;
2006-05-01 10:17:59 +00:00
typedef struct ros_conv_info_t {
struct ros_conv_info_t * next ;
GHashTable * unmatched ; /* unmatched operations */
GHashTable * matched ; /* matched operations */
} ros_conv_info_t ;
static ros_conv_info_t * ros_info_items = NULL ;
typedef struct ros_call_response {
gboolean is_request ;
guint32 req_frame ;
nstime_t req_time ;
guint32 rep_frame ;
guint invokeId ;
} ros_call_response_t ;
static int hf_ros_response_in = - 1 ;
static int hf_ros_response_to = - 1 ;
static int hf_ros_time = - 1 ;
2005-09-04 20:30:31 +00:00
/*--- Included file: packet-ros-hf.c ---*/
2005-12-08 23:29:21 +00:00
# line 1 "packet-ros-hf.c"
2005-09-04 20:30:31 +00:00
static int hf_ros_invoke = - 1 ; /* Invoke */
static int hf_ros_returnResult = - 1 ; /* ReturnResult */
static int hf_ros_returnError = - 1 ; /* ReturnError */
2008-04-13 16:11:15 +00:00
static int hf_ros_reject = - 1 ; /* T_reject */
2005-09-04 20:30:31 +00:00
static int hf_ros_bind_invoke = - 1 ; /* T_bind_invoke */
static int hf_ros_bind_result = - 1 ; /* T_bind_result */
static int hf_ros_bind_error = - 1 ; /* T_bind_error */
static int hf_ros_unbind_invoke = - 1 ; /* T_unbind_invoke */
static int hf_ros_unbind_result = - 1 ; /* T_unbind_result */
static int hf_ros_unbind_error = - 1 ; /* T_unbind_error */
static int hf_ros_invokeId = - 1 ; /* InvokeId */
static int hf_ros_linkedId = - 1 ; /* INTEGER */
2005-10-24 21:42:19 +00:00
static int hf_ros_opcode = - 1 ; /* OperationCode */
2005-09-04 20:30:31 +00:00
static int hf_ros_argument = - 1 ; /* T_argument */
static int hf_ros_result = - 1 ; /* T_result */
2005-10-24 21:42:19 +00:00
static int hf_ros_operationResult = - 1 ; /* OperationResult */
static int hf_ros_errcode = - 1 ; /* ErrorCode */
2005-09-04 20:30:31 +00:00
static int hf_ros_parameter = - 1 ; /* T_parameter */
static int hf_ros_problem = - 1 ; /* T_problem */
static int hf_ros_general = - 1 ; /* GeneralProblem */
2005-10-24 21:42:19 +00:00
static int hf_ros_invokeProblem = - 1 ; /* InvokeProblem */
static int hf_ros_rejectResult = - 1 ; /* ReturnResultProblem */
static int hf_ros_rejectError = - 1 ; /* ReturnErrorProblem */
2007-06-06 08:12:27 +00:00
static int hf_ros_present = - 1 ; /* T_present */
2005-09-04 20:30:31 +00:00
static int hf_ros_absent = - 1 ; /* NULL */
static int hf_ros_local = - 1 ; /* INTEGER */
static int hf_ros_global = - 1 ; /* OBJECT_IDENTIFIER */
/*--- End of included file: packet-ros-hf.c ---*/
2010-04-07 16:54:29 +00:00
# line 78 "packet-ros-template.c"
2005-09-04 20:30:31 +00:00
/* Initialize the subtree pointers */
static gint ett_ros = - 1 ;
/*--- Included file: packet-ros-ett.c ---*/
2005-12-08 23:29:21 +00:00
# line 1 "packet-ros-ett.c"
2005-09-04 20:30:31 +00:00
static gint ett_ros_ROS = - 1 ;
static gint ett_ros_Invoke = - 1 ;
static gint ett_ros_ReturnResult = - 1 ;
static gint ett_ros_T_result = - 1 ;
static gint ett_ros_ReturnError = - 1 ;
static gint ett_ros_Reject = - 1 ;
static gint ett_ros_T_problem = - 1 ;
static gint ett_ros_InvokeId = - 1 ;
static gint ett_ros_Code = - 1 ;
/*--- End of included file: packet-ros-ett.c ---*/
2010-04-07 16:54:29 +00:00
# line 82 "packet-ros-template.c"
2005-09-04 20:30:31 +00:00
static dissector_table_t ros_oid_dissector_table = NULL ;
2007-12-03 19:29:24 +00:00
2005-09-04 20:30:31 +00:00
static GHashTable * oid_table = NULL ;
2007-12-03 19:29:24 +00:00
static GHashTable * protocol_table = NULL ;
2005-09-04 20:30:31 +00:00
static gint ett_ros_unknown = - 1 ;
void
2005-10-24 21:42:19 +00:00
register_ros_oid_dissector_handle ( const char * oid , dissector_handle_t dissector , int proto _U_ , const char * name , gboolean uses_rtse )
2005-09-04 20:30:31 +00:00
{
dissector_add_string ( " ros.oid " , oid , dissector ) ;
g_hash_table_insert ( oid_table , ( gpointer ) oid , ( gpointer ) name ) ;
2005-10-24 21:42:19 +00:00
if ( ! uses_rtse )
/* if we are not using RTSE, then we must register ROS with BER (ACSE) */
register_ber_oid_dissector_handle ( oid , ros_handle , proto , name ) ;
2005-09-04 20:30:31 +00:00
}
2007-12-03 19:29:24 +00:00
void
register_ros_protocol_info ( const char * oid , const ros_info_t * rinfo , int proto _U_ , const char * name , gboolean uses_rtse )
{
2009-10-18 20:13:56 +00:00
g_hash_table_insert ( protocol_table , ( gpointer ) oid , ( gpointer ) rinfo ) ;
2007-12-03 19:29:24 +00:00
g_hash_table_insert ( oid_table , ( gpointer ) oid , ( gpointer ) name ) ;
if ( ! uses_rtse )
/* if we are not using RTSE, then we must register ROS with BER (ACSE) */
register_ber_oid_dissector_handle ( oid , ros_handle , proto , name ) ;
}
2010-01-28 14:43:01 +00:00
static new_dissector_t ros_lookup_opr_dissector ( gint32 opcode_lcl , const ros_opr_t * operations , gboolean argument )
2007-12-03 19:29:24 +00:00
{
/* we don't know what order asn2wrs/module definition is, so ... */
if ( operations ) {
2009-10-18 20:13:56 +00:00
for ( ; operations - > arg_pdu ! = ( new_dissector_t ) ( - 1 ) ; operations + + )
2010-01-28 14:43:01 +00:00
if ( operations - > opcode = = opcode_lcl )
2007-12-03 19:29:24 +00:00
return argument ? operations - > arg_pdu : operations - > res_pdu ;
2009-10-18 20:13:56 +00:00
2007-12-03 19:29:24 +00:00
}
return NULL ;
}
static new_dissector_t ros_lookup_err_dissector ( gint32 errcode , const ros_err_t * errors )
{
/* we don't know what order asn2wrs/module definition is, so ... */
if ( errors ) {
for ( ; errors - > err_pdu ! = ( new_dissector_t ) ( - 1 ) ; errors + + ) {
2009-10-18 20:13:56 +00:00
if ( errors - > errcode = = errcode )
2007-12-03 19:29:24 +00:00
return errors - > err_pdu ;
}
}
return NULL ;
}
static gboolean ros_try_string ( const char * oid , tvbuff_t * tvb , packet_info * pinfo , proto_tree * tree )
{
ros_info_t * rinfo ;
2010-01-28 14:43:01 +00:00
gint32 opcode_lcl = 0 ;
2007-12-03 19:29:24 +00:00
const gchar * opname = NULL ;
const gchar * suffix = NULL ;
int offset = 0 ;
new_dissector_t opdissector = NULL ;
const value_string * lookup ;
proto_item * item = NULL ;
proto_tree * ros_tree = NULL ;
if ( ( rinfo = ( ros_info_t * ) g_hash_table_lookup ( protocol_table , oid ) ) ! = NULL ) {
if ( tree ) {
item = proto_tree_add_item ( tree , * ( rinfo - > proto ) , tvb , 0 , - 1 , FALSE ) ;
ros_tree = proto_item_add_subtree ( item , * ( rinfo - > ett_proto ) ) ;
}
2010-01-27 14:54:48 +00:00
col_set_str ( pinfo - > cinfo , COL_PROTOCOL , rinfo - > name ) ;
2007-12-03 19:29:24 +00:00
/* if this is a bind operation */
if ( ( session - > ros_op & ROS_OP_TYPE_MASK ) = = ROS_OP_BIND ) {
/* use the in-built operation codes */
if ( ( session - > ros_op & ROS_OP_PDU_MASK ) = = ROS_OP_ERROR )
2010-01-28 14:43:01 +00:00
opcode_lcl = err_ros_bind ;
2007-12-03 19:29:24 +00:00
else
2010-01-28 14:43:01 +00:00
opcode_lcl = op_ros_bind ;
2009-10-18 20:13:56 +00:00
} else
2007-12-03 19:29:24 +00:00
/* otherwise just take the opcode */
2010-01-28 14:43:01 +00:00
opcode_lcl = session - > ros_op & ROS_OP_OPCODE_MASK ;
2007-12-03 19:29:24 +00:00
/* default lookup in the operations */
lookup = rinfo - > opr_code_strings ;
switch ( session - > ros_op & ROS_OP_PDU_MASK ) {
2009-10-18 20:13:56 +00:00
case ROS_OP_ARGUMENT :
2010-01-28 14:43:01 +00:00
opdissector = ros_lookup_opr_dissector ( opcode_lcl , rinfo - > opr_code_dissectors , TRUE ) ;
2007-12-03 19:29:24 +00:00
suffix = " _argument " ;
break ;
2009-10-18 20:13:56 +00:00
case ROS_OP_RESULT :
2010-01-28 14:43:01 +00:00
opdissector = ros_lookup_opr_dissector ( opcode_lcl , rinfo - > opr_code_dissectors , FALSE ) ;
2007-12-03 19:29:24 +00:00
suffix = " _result " ;
break ;
2009-10-18 20:13:56 +00:00
case ROS_OP_ERROR :
2010-01-28 14:43:01 +00:00
opdissector = ros_lookup_err_dissector ( opcode_lcl , rinfo - > err_code_dissectors ) ;
2007-12-03 19:29:24 +00:00
lookup = rinfo - > err_code_strings ;
break ;
default :
break ;
}
if ( opdissector ) {
2010-01-28 14:43:01 +00:00
opname = val_to_str ( opcode_lcl , lookup , " Unknown opcode (%d) " ) ;
2007-12-03 19:29:24 +00:00
if ( check_col ( pinfo - > cinfo , COL_INFO ) ) {
col_set_str ( pinfo - > cinfo , COL_INFO , opname ) ;
if ( suffix )
2008-10-31 17:27:51 +00:00
col_append_str ( pinfo - > cinfo , COL_INFO , suffix ) ;
2007-12-03 19:29:24 +00:00
}
2009-10-18 20:13:56 +00:00
2007-12-03 19:29:24 +00:00
offset = ( * opdissector ) ( tvb , pinfo , ros_tree ) ;
return TRUE ;
}
}
return FALSE ;
}
2005-09-04 20:30:31 +00:00
static int
call_ros_oid_callback ( const char * oid , tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree )
{
tvbuff_t * next_tvb ;
next_tvb = tvb_new_subset ( tvb , offset , tvb_length_remaining ( tvb , offset ) , tvb_reported_length_remaining ( tvb , offset ) ) ;
2007-12-03 19:29:24 +00:00
if ( ! ros_try_string ( oid , next_tvb , pinfo , tree ) & &
! dissector_try_string ( ros_oid_dissector_table , oid , next_tvb , pinfo , tree ) ) {
2009-05-20 09:27:45 +00:00
proto_item * 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 ) ;
proto_tree * next_tree = proto_item_add_subtree ( item , ett_ros_unknown ) ;
2005-09-04 20:30:31 +00:00
2009-05-20 09:27:45 +00:00
expert_add_info_format ( pinfo , item , PI_UNDECODED , PI_WARN ,
" ROS: Dissector for OID %s not implemented " , oid ) ;
2005-09-04 20:30:31 +00:00
dissect_unknown_ber ( pinfo , next_tvb , offset , next_tree ) ;
}
2009-10-18 20:13:56 +00:00
/*XXX until we change the #.REGISTER signature for _PDU()s
2005-09-04 20:30:31 +00:00
* into new_dissector_t we have to do this kludge with
* manually step past the content in the ANY type .
*/
offset + = tvb_length_remaining ( tvb , offset ) ;
return offset ;
}
2006-05-01 10:17:59 +00:00
static guint
ros_info_hash_matched ( gconstpointer k )
{
const ros_call_response_t * key = k ;
return key - > invokeId ;
}
static gint
ros_info_equal_matched ( gconstpointer k1 , gconstpointer k2 )
{
const ros_call_response_t * key1 = k1 ;
const ros_call_response_t * key2 = k2 ;
if ( key1 - > req_frame & & key2 - > req_frame & & ( key1 - > req_frame ! = key2 - > req_frame ) ) {
return 0 ;
}
/* a response may span multiple frames
if ( key1 - > rep_frame & & key2 - > rep_frame & & ( key1 - > rep_frame ! = key2 - > rep_frame ) ) {
return 0 ;
}
*/
return key1 - > invokeId = = key2 - > invokeId ;
}
static guint
ros_info_hash_unmatched ( gconstpointer k )
{
const ros_call_response_t * key = k ;
return key - > invokeId ;
}
static gint
ros_info_equal_unmatched ( gconstpointer k1 , gconstpointer k2 )
{
const ros_call_response_t * key1 = k1 ;
const ros_call_response_t * key2 = k2 ;
return key1 - > invokeId = = key2 - > invokeId ;
}
static ros_call_response_t *
ros_match_call_response ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * tree , guint invokeId , gboolean isInvoke )
{
ros_call_response_t rcr , * rcrp = NULL ;
ros_conv_info_t * ros_info = ros_info_items ;
/* first see if we have already matched this */
rcr . invokeId = invokeId ;
rcr . is_request = isInvoke ;
if ( isInvoke ) {
rcr . req_frame = pinfo - > fd - > num ;
rcr . rep_frame = 0 ;
} else {
rcr . req_frame = 0 ;
rcr . rep_frame = pinfo - > fd - > num ;
}
2009-10-18 20:13:56 +00:00
2006-05-01 10:17:59 +00:00
rcrp = g_hash_table_lookup ( ros_info - > matched , & rcr ) ;
if ( rcrp ) {
/* we have found a match */
rcrp - > is_request = rcr . is_request ;
} else {
2009-10-18 20:13:56 +00:00
2006-05-01 10:17:59 +00:00
/* we haven't found a match - try and match it up */
if ( isInvoke ) {
/* this a a request - add it to the unmatched list */
/* check that we dont already have one of those in the
unmatched list and if so remove it */
rcr . invokeId = invokeId ;
rcrp = g_hash_table_lookup ( ros_info - > unmatched , & rcr ) ;
if ( rcrp ) {
g_hash_table_remove ( ros_info - > unmatched , rcrp ) ;
}
2009-10-18 20:13:56 +00:00
2006-05-01 10:17:59 +00:00
/* if we cant reuse the old one, grab a new chunk */
if ( ! rcrp ) {
rcrp = se_alloc ( sizeof ( ros_call_response_t ) ) ;
}
rcrp - > invokeId = invokeId ;
rcrp - > req_frame = pinfo - > fd - > num ;
rcrp - > req_time = pinfo - > fd - > abs_ts ;
rcrp - > rep_frame = 0 ;
rcrp - > is_request = TRUE ;
g_hash_table_insert ( ros_info - > unmatched , rcrp , rcrp ) ;
return NULL ;
} else {
/* this is a result - it should be in our unmatched list */
rcr . invokeId = invokeId ;
rcrp = g_hash_table_lookup ( ros_info - > unmatched , & rcr ) ;
if ( rcrp ) {
if ( ! rcrp - > rep_frame ) {
g_hash_table_remove ( ros_info - > unmatched , rcrp ) ;
rcrp - > rep_frame = pinfo - > fd - > num ;
rcrp - > is_request = FALSE ;
g_hash_table_insert ( ros_info - > matched , rcrp , rcrp ) ;
}
}
}
}
if ( rcrp ) { /* we have found a match */
2007-11-13 10:26:30 +00:00
proto_item * item = NULL ;
2006-05-01 10:17:59 +00:00
if ( rcrp - > is_request ) {
2007-11-13 10:26:30 +00:00
item = proto_tree_add_uint ( tree , hf_ros_response_in , tvb , 0 , 0 , rcrp - > rep_frame ) ;
PROTO_ITEM_SET_GENERATED ( item ) ;
2006-05-01 10:17:59 +00:00
} else {
nstime_t ns ;
2007-11-13 10:26:30 +00:00
item = proto_tree_add_uint ( tree , hf_ros_response_to , tvb , 0 , 0 , rcrp - > req_frame ) ;
PROTO_ITEM_SET_GENERATED ( item ) ;
2006-05-01 10:17:59 +00:00
nstime_delta ( & ns , & pinfo - > fd - > abs_ts , & rcrp - > req_time ) ;
2007-11-13 10:26:30 +00:00
item = proto_tree_add_time ( tree , hf_ros_time , tvb , 0 , 0 , & ns ) ;
PROTO_ITEM_SET_GENERATED ( item ) ;
2006-05-01 10:17:59 +00:00
}
}
2009-10-18 20:13:56 +00:00
2006-05-01 10:17:59 +00:00
return rcrp ;
}
2005-09-04 20:30:31 +00:00
/*--- Included file: packet-ros-fn.c ---*/
2005-12-08 23:29:21 +00:00
# line 1 "packet-ros-fn.c"
2005-09-04 20:30:31 +00:00
static int
2007-06-06 08:12:27 +00:00
dissect_ros_T_present ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2007-05-15 05:49:43 +00:00
offset = dissect_ber_integer ( implicit_tag , actx , tree , tvb , offset , hf_index ,
2008-04-13 16:11:15 +00:00
& invokeid ) ;
2005-09-04 20:30:31 +00:00
return offset ;
}
static int
2007-05-13 20:58:29 +00:00
dissect_ros_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_ ) {
2007-05-15 05:49:43 +00:00
offset = dissect_ber_null ( implicit_tag , actx , tree , tvb , offset , hf_index ) ;
2005-09-04 20:30:31 +00:00
return offset ;
}
const value_string ros_InvokeId_vals [ ] = {
{ 0 , " present " } ,
{ 1 , " absent " } ,
{ 0 , NULL }
} ;
2007-10-22 17:03:09 +00:00
static const ber_choice_t InvokeId_choice [ ] = {
{ 0 , & hf_ros_present , BER_CLASS_UNI , BER_UNI_TAG_INTEGER , BER_FLAGS_NOOWNTAG , dissect_ros_T_present } ,
{ 1 , & hf_ros_absent , BER_CLASS_UNI , BER_UNI_TAG_NULL , BER_FLAGS_NOOWNTAG , dissect_ros_NULL } ,
{ 0 , NULL , 0 , 0 , 0 , NULL }
2005-09-04 20:30:31 +00:00
} ;
int
2007-05-13 20:58:29 +00:00
dissect_ros_InvokeId ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2007-10-22 17:03:09 +00:00
offset = dissect_ber_choice ( actx , tree , tvb , offset ,
InvokeId_choice , hf_index , ett_ros_InvokeId ,
NULL ) ;
2005-09-04 20:30:31 +00:00
return offset ;
}
2007-06-06 08:12:27 +00:00
static int
dissect_ros_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_ ) {
offset = dissect_ber_integer ( implicit_tag , actx , tree , tvb , offset , hf_index ,
2008-04-13 16:11:15 +00:00
NULL ) ;
2007-06-06 08:12:27 +00:00
return offset ;
}
2005-10-24 21:42:19 +00:00
static int
2007-05-13 20:58:29 +00:00
dissect_ros_OperationCode ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2007-05-15 05:49:43 +00:00
offset = dissect_ber_integer ( implicit_tag , actx , tree , tvb , offset , hf_index ,
2008-04-13 16:11:15 +00:00
& opcode ) ;
2005-10-24 21:42:19 +00:00
return offset ;
}
2005-09-04 20:30:31 +00:00
static int
2007-05-13 20:58:29 +00:00
dissect_ros_T_argument ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2008-07-23 21:55:56 +00:00
# line 30 "ros.cnf"
2005-09-04 20:30:31 +00:00
char * oid ;
/* not sure what the length should be - -1 for now */
proto_tree_add_text ( tree , tvb , offset , - 1 , " invoke argument " ) ;
2006-05-01 10:17:59 +00:00
2007-05-13 20:58:29 +00:00
ros_match_call_response ( tvb , actx - > pinfo , tree , invokeid , TRUE ) ;
2005-09-04 20:30:31 +00:00
2007-05-13 20:58:29 +00:00
if ( session & & session - > pres_ctx_id & & ( oid = find_oid_by_pres_ctx_id ( actx - > pinfo , session - > pres_ctx_id ) ) ) {
2005-09-04 20:30:31 +00:00
/* this should be ROS! */
session - > ros_op = ( ROS_OP_INVOKE | ROS_OP_ARGUMENT ) ;
/* now add the opcode */
session - > ros_op | = opcode ;
2007-05-13 20:58:29 +00:00
offset = call_ros_oid_callback ( oid , tvb , offset , actx - > pinfo , top_tree ) ;
2005-09-04 20:30:31 +00:00
}
2005-12-08 23:29:21 +00:00
2005-09-04 20:30:31 +00:00
return offset ;
}
2007-10-22 17:03:09 +00:00
static const ber_sequence_t Invoke_sequence [ ] = {
{ & hf_ros_invokeId , BER_CLASS_ANY /*choice*/ , - 1 /*choice*/ , BER_FLAGS_NOOWNTAG | BER_FLAGS_NOTCHKTAG , dissect_ros_InvokeId } ,
2007-12-03 19:29:24 +00:00
{ & hf_ros_linkedId , BER_CLASS_CON , 0 , BER_FLAGS_OPTIONAL | BER_FLAGS_IMPLTAG , dissect_ros_INTEGER } ,
2007-10-22 17:03:09 +00:00
{ & hf_ros_opcode , BER_CLASS_UNI , BER_UNI_TAG_INTEGER , BER_FLAGS_NOOWNTAG , dissect_ros_OperationCode } ,
{ & hf_ros_argument , BER_CLASS_ANY , 0 , BER_FLAGS_OPTIONAL | BER_FLAGS_NOOWNTAG , dissect_ros_T_argument } ,
{ NULL , 0 , 0 , 0 , NULL }
2005-09-04 20:30:31 +00:00
} ;
static int
2007-05-13 20:58:29 +00:00
dissect_ros_Invoke ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2007-10-22 17:03:09 +00:00
offset = dissect_ber_sequence ( implicit_tag , actx , tree , tvb , offset ,
Invoke_sequence , hf_index , ett_ros_Invoke ) ;
2005-09-04 20:30:31 +00:00
return offset ;
}
static int
2007-05-13 20:58:29 +00:00
dissect_ros_OperationResult ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2008-07-23 21:55:56 +00:00
# line 45 "ros.cnf"
2005-09-04 20:30:31 +00:00
char * oid ;
/* not sure what the length should be - -1 for now */
proto_tree_add_text ( tree , tvb , offset , - 1 , " return result " ) ;
2006-05-01 10:17:59 +00:00
2007-05-13 20:58:29 +00:00
ros_match_call_response ( tvb , actx - > pinfo , tree , invokeid , FALSE ) ;
2005-09-04 20:30:31 +00:00
2007-05-13 20:58:29 +00:00
if ( session & & session - > pres_ctx_id & & ( oid = find_oid_by_pres_ctx_id ( actx - > pinfo , session - > pres_ctx_id ) ) ) {
2005-09-04 20:30:31 +00:00
/* this should be ROS! */
session - > ros_op = ( ROS_OP_INVOKE | ROS_OP_RESULT ) ;
/* now add the opcode */
session - > ros_op | = opcode ;
2007-05-13 20:58:29 +00:00
offset = call_ros_oid_callback ( oid , tvb , offset , actx - > pinfo , top_tree ) ;
2005-09-04 20:30:31 +00:00
}
2005-12-08 23:29:21 +00:00
2005-09-04 20:30:31 +00:00
return offset ;
}
2007-10-22 17:03:09 +00:00
static const ber_sequence_t T_result_sequence [ ] = {
{ & hf_ros_opcode , BER_CLASS_UNI , BER_UNI_TAG_INTEGER , BER_FLAGS_NOOWNTAG , dissect_ros_OperationCode } ,
{ & hf_ros_operationResult , BER_CLASS_ANY , 0 , BER_FLAGS_NOOWNTAG , dissect_ros_OperationResult } ,
{ NULL , 0 , 0 , 0 , NULL }
2005-09-04 20:30:31 +00:00
} ;
static int
2007-05-13 20:58:29 +00:00
dissect_ros_T_result ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2007-10-22 17:03:09 +00:00
offset = dissect_ber_sequence ( implicit_tag , actx , tree , tvb , offset ,
T_result_sequence , hf_index , ett_ros_T_result ) ;
2005-09-04 20:30:31 +00:00
return offset ;
}
2007-10-22 17:03:09 +00:00
static const ber_sequence_t ReturnResult_sequence [ ] = {
{ & hf_ros_invokeId , BER_CLASS_ANY /*choice*/ , - 1 /*choice*/ , BER_FLAGS_NOOWNTAG | BER_FLAGS_NOTCHKTAG , dissect_ros_InvokeId } ,
{ & hf_ros_result , BER_CLASS_UNI , BER_UNI_TAG_SEQUENCE , BER_FLAGS_OPTIONAL | BER_FLAGS_NOOWNTAG , dissect_ros_T_result } ,
{ NULL , 0 , 0 , 0 , NULL }
2005-09-04 20:30:31 +00:00
} ;
static int
2007-05-13 20:58:29 +00:00
dissect_ros_ReturnResult ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2007-10-22 17:03:09 +00:00
offset = dissect_ber_sequence ( implicit_tag , actx , tree , tvb , offset ,
ReturnResult_sequence , hf_index , ett_ros_ReturnResult ) ;
2005-09-04 20:30:31 +00:00
return offset ;
}
2005-10-24 21:42:19 +00:00
static int
2007-05-13 20:58:29 +00:00
dissect_ros_ErrorCode ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2007-05-15 05:49:43 +00:00
offset = dissect_ber_integer ( implicit_tag , actx , tree , tvb , offset , hf_index ,
2008-04-13 16:11:15 +00:00
& opcode ) ;
2005-10-24 21:42:19 +00:00
return offset ;
}
2005-09-04 20:30:31 +00:00
static int
2007-05-13 20:58:29 +00:00
dissect_ros_T_parameter ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2008-07-23 21:55:56 +00:00
# line 60 "ros.cnf"
2005-09-04 20:30:31 +00:00
char * oid ;
/* not sure what the length should be - -1 for now */
proto_tree_add_text ( tree , tvb , offset , - 1 , " return result " ) ;
2006-05-01 10:17:59 +00:00
2007-05-13 20:58:29 +00:00
ros_match_call_response ( tvb , actx - > pinfo , tree , invokeid , FALSE ) ;
2005-09-04 20:30:31 +00:00
2007-05-13 20:58:29 +00:00
if ( session & & session - > pres_ctx_id & & ( oid = find_oid_by_pres_ctx_id ( actx - > pinfo , session - > pres_ctx_id ) ) ) {
2005-09-04 20:30:31 +00:00
/* this should be ROS! */
session - > ros_op = ( ROS_OP_INVOKE | ROS_OP_ERROR ) ;
2007-12-03 19:29:24 +00:00
/* now add the opcode (really the error code) */
2005-09-04 20:30:31 +00:00
session - > ros_op | = opcode ;
2007-05-13 20:58:29 +00:00
offset = call_ros_oid_callback ( oid , tvb , offset , actx - > pinfo , top_tree ) ;
2005-09-04 20:30:31 +00:00
}
2005-12-08 23:29:21 +00:00
2005-09-04 20:30:31 +00:00
return offset ;
}
2007-10-22 17:03:09 +00:00
static const ber_sequence_t ReturnError_sequence [ ] = {
{ & hf_ros_invokeId , BER_CLASS_ANY /*choice*/ , - 1 /*choice*/ , BER_FLAGS_NOOWNTAG | BER_FLAGS_NOTCHKTAG , dissect_ros_InvokeId } ,
{ & hf_ros_errcode , BER_CLASS_UNI , BER_UNI_TAG_INTEGER , BER_FLAGS_NOOWNTAG , dissect_ros_ErrorCode } ,
{ & hf_ros_parameter , BER_CLASS_ANY , 0 , BER_FLAGS_OPTIONAL | BER_FLAGS_NOOWNTAG , dissect_ros_T_parameter } ,
{ NULL , 0 , 0 , 0 , NULL }
2005-09-04 20:30:31 +00:00
} ;
static int
2007-05-13 20:58:29 +00:00
dissect_ros_ReturnError ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2007-10-22 17:03:09 +00:00
offset = dissect_ber_sequence ( implicit_tag , actx , tree , tvb , offset ,
ReturnError_sequence , hf_index , ett_ros_ReturnError ) ;
2005-09-04 20:30:31 +00:00
return offset ;
}
static const value_string ros_GeneralProblem_vals [ ] = {
{ 0 , " unrecognizedPDU " } ,
{ 1 , " mistypedPDU " } ,
{ 2 , " badlyStructuredPDU " } ,
{ 0 , NULL }
} ;
static int
2007-05-13 20:58:29 +00:00
dissect_ros_GeneralProblem ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2008-07-23 21:55:56 +00:00
# line 152 "ros.cnf"
2008-04-13 16:11:15 +00:00
guint32 problem ;
offset = dissect_ber_integer ( implicit_tag , actx , tree , tvb , offset , hf_index ,
& problem ) ;
if ( check_col ( actx - > pinfo - > cinfo , COL_INFO ) ) {
col_append_fstr ( actx - > pinfo - > cinfo , COL_INFO , " %s " , val_to_str ( problem , ros_GeneralProblem_vals , " GeneralProblem(%d) " ) ) ;
}
2005-09-04 20:30:31 +00:00
return offset ;
}
static const value_string ros_InvokeProblem_vals [ ] = {
{ 0 , " duplicateInvocation " } ,
{ 1 , " unrecognizedOperation " } ,
{ 2 , " mistypedArgument " } ,
{ 3 , " resourceLimitation " } ,
{ 4 , " releaseInProgress " } ,
{ 5 , " unrecognizedLinkedId " } ,
{ 6 , " linkedResponseUnexpected " } ,
{ 7 , " unexpectedLinkedOperation " } ,
{ 0 , NULL }
} ;
static int
2007-05-13 20:58:29 +00:00
dissect_ros_InvokeProblem ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2008-07-23 21:55:56 +00:00
# line 164 "ros.cnf"
2008-04-13 16:11:15 +00:00
guint32 problem ;
offset = dissect_ber_integer ( implicit_tag , actx , tree , tvb , offset , hf_index ,
& problem ) ;
if ( check_col ( actx - > pinfo - > cinfo , COL_INFO ) ) {
col_append_fstr ( actx - > pinfo - > cinfo , COL_INFO , " %s " , val_to_str ( problem , ros_InvokeProblem_vals , " InvokeProblem(%d) " ) ) ;
}
2005-09-04 20:30:31 +00:00
return offset ;
}
static const value_string ros_ReturnResultProblem_vals [ ] = {
{ 0 , " unrecognizedInvocation " } ,
{ 1 , " resultResponseUnexpected " } ,
{ 2 , " mistypedResult " } ,
{ 0 , NULL }
} ;
static int
2007-05-13 20:58:29 +00:00
dissect_ros_ReturnResultProblem ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2008-07-23 21:55:56 +00:00
# line 176 "ros.cnf"
2008-04-13 16:11:15 +00:00
guint32 problem ;
offset = dissect_ber_integer ( implicit_tag , actx , tree , tvb , offset , hf_index ,
& problem ) ;
if ( check_col ( actx - > pinfo - > cinfo , COL_INFO ) ) {
col_append_fstr ( actx - > pinfo - > cinfo , COL_INFO , " %s " , val_to_str ( problem , ros_ReturnResultProblem_vals , " ReturnResultProblem(%d) " ) ) ;
}
2005-09-04 20:30:31 +00:00
return offset ;
}
static const value_string ros_ReturnErrorProblem_vals [ ] = {
{ 0 , " unrecognizedInvocation " } ,
{ 1 , " errorResponseUnexpected " } ,
{ 2 , " unrecognizedError " } ,
{ 3 , " unexpectedError " } ,
{ 4 , " mistypedParameter " } ,
{ 0 , NULL }
} ;
static int
2007-05-13 20:58:29 +00:00
dissect_ros_ReturnErrorProblem ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2008-07-23 21:55:56 +00:00
# line 188 "ros.cnf"
2008-04-13 16:11:15 +00:00
guint32 problem ;
offset = dissect_ber_integer ( implicit_tag , actx , tree , tvb , offset , hf_index ,
& problem ) ;
if ( check_col ( actx - > pinfo - > cinfo , COL_INFO ) ) {
col_append_fstr ( actx - > pinfo - > cinfo , COL_INFO , " %s " , val_to_str ( problem , ros_ReturnErrorProblem_vals , " ReturnErrorProblem(%d) " ) ) ;
}
2005-09-04 20:30:31 +00:00
return offset ;
}
static const value_string ros_T_problem_vals [ ] = {
{ 0 , " general " } ,
{ 1 , " invoke " } ,
{ 2 , " returnResult " } ,
{ 3 , " returnError " } ,
{ 0 , NULL }
} ;
2007-10-22 17:03:09 +00:00
static const ber_choice_t T_problem_choice [ ] = {
2007-12-03 19:29:24 +00:00
{ 0 , & hf_ros_general , BER_CLASS_CON , 0 , BER_FLAGS_IMPLTAG , dissect_ros_GeneralProblem } ,
{ 1 , & hf_ros_invokeProblem , BER_CLASS_CON , 1 , BER_FLAGS_IMPLTAG , dissect_ros_InvokeProblem } ,
{ 2 , & hf_ros_rejectResult , BER_CLASS_CON , 2 , BER_FLAGS_IMPLTAG , dissect_ros_ReturnResultProblem } ,
{ 3 , & hf_ros_rejectError , BER_CLASS_CON , 3 , BER_FLAGS_IMPLTAG , dissect_ros_ReturnErrorProblem } ,
2007-10-22 17:03:09 +00:00
{ 0 , NULL , 0 , 0 , 0 , NULL }
2005-09-04 20:30:31 +00:00
} ;
static int
2007-05-13 20:58:29 +00:00
dissect_ros_T_problem ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2007-10-22 17:03:09 +00:00
offset = dissect_ber_choice ( actx , tree , tvb , offset ,
T_problem_choice , hf_index , ett_ros_T_problem ,
NULL ) ;
2005-09-04 20:30:31 +00:00
return offset ;
}
2007-10-22 17:03:09 +00:00
static const ber_sequence_t Reject_sequence [ ] = {
{ & hf_ros_invokeId , BER_CLASS_ANY /*choice*/ , - 1 /*choice*/ , BER_FLAGS_NOOWNTAG | BER_FLAGS_NOTCHKTAG , dissect_ros_InvokeId } ,
{ & hf_ros_problem , BER_CLASS_ANY /*choice*/ , - 1 /*choice*/ , BER_FLAGS_NOOWNTAG | BER_FLAGS_NOTCHKTAG , dissect_ros_T_problem } ,
{ NULL , 0 , 0 , 0 , NULL }
2005-09-04 20:30:31 +00:00
} ;
static int
2007-05-13 20:58:29 +00:00
dissect_ros_Reject ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2007-10-22 17:03:09 +00:00
offset = dissect_ber_sequence ( implicit_tag , actx , tree , tvb , offset ,
Reject_sequence , hf_index , ett_ros_Reject ) ;
2005-09-04 20:30:31 +00:00
return offset ;
}
2008-04-13 16:11:15 +00:00
static int
dissect_ros_T_reject ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2008-07-23 21:55:56 +00:00
# line 144 "ros.cnf"
2008-04-13 16:11:15 +00:00
if ( check_col ( actx - > pinfo - > cinfo , COL_INFO ) )
col_set_str ( actx - > pinfo - > cinfo , COL_INFO , " Reject " ) ;
offset = dissect_ros_Reject ( implicit_tag , tvb , offset , actx , tree , hf_index ) ;
return offset ;
}
2005-09-04 20:30:31 +00:00
static int
2007-05-13 20:58:29 +00:00
dissect_ros_T_bind_invoke ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2008-07-23 21:55:56 +00:00
# line 76 "ros.cnf"
2005-09-04 20:30:31 +00:00
char * oid ;
/* not sure what the length should be - -1 for now */
proto_tree_add_text ( tree , tvb , offset , - 1 , " bind-invoke " ) ;
2007-05-13 20:58:29 +00:00
if ( session & & session - > pres_ctx_id & & ( oid = find_oid_by_pres_ctx_id ( actx - > pinfo , session - > pres_ctx_id ) ) ) {
2005-09-04 20:30:31 +00:00
/* this should be ROS! */
session - > ros_op = ( ROS_OP_BIND | ROS_OP_ARGUMENT ) ;
2007-05-13 20:58:29 +00:00
offset = call_ros_oid_callback ( oid , tvb , offset , actx - > pinfo , top_tree ) ;
2005-09-04 20:30:31 +00:00
}
2005-12-08 23:29:21 +00:00
2005-09-04 20:30:31 +00:00
return offset ;
}
static int
2007-05-13 20:58:29 +00:00
dissect_ros_T_bind_result ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2008-07-23 21:55:56 +00:00
# line 87 "ros.cnf"
2005-09-04 20:30:31 +00:00
char * oid ;
/* not sure what the length should be - -1 for now */
proto_tree_add_text ( tree , tvb , offset , - 1 , " bind-result " ) ;
2007-05-13 20:58:29 +00:00
if ( session & & session - > pres_ctx_id & & ( oid = find_oid_by_pres_ctx_id ( actx - > pinfo , session - > pres_ctx_id ) ) ) {
2005-09-04 20:30:31 +00:00
/* this should be ROS! */
session - > ros_op = ( ROS_OP_BIND | ROS_OP_RESULT ) ;
2007-05-13 20:58:29 +00:00
offset = call_ros_oid_callback ( oid , tvb , offset , actx - > pinfo , top_tree ) ;
2005-09-04 20:30:31 +00:00
}
2005-12-08 23:29:21 +00:00
2005-09-04 20:30:31 +00:00
return offset ;
}
static int
2007-05-13 20:58:29 +00:00
dissect_ros_T_bind_error ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2008-07-23 21:55:56 +00:00
# line 98 "ros.cnf"
2005-09-04 20:30:31 +00:00
char * oid ;
/* not sure what the length should be - -1 for now */
proto_tree_add_text ( tree , tvb , offset , - 1 , " bind-error " ) ;
2007-05-13 20:58:29 +00:00
if ( session & & session - > pres_ctx_id & & ( oid = find_oid_by_pres_ctx_id ( actx - > pinfo , session - > pres_ctx_id ) ) ) {
2005-09-04 20:30:31 +00:00
/* this should be ROS! */
session - > ros_op = ( ROS_OP_BIND | ROS_OP_ERROR ) ;
2007-05-13 20:58:29 +00:00
offset = call_ros_oid_callback ( oid , tvb , offset , actx - > pinfo , top_tree ) ;
2005-09-04 20:30:31 +00:00
}
2005-12-08 23:29:21 +00:00
2005-09-04 20:30:31 +00:00
return offset ;
}
static int
2007-05-13 20:58:29 +00:00
dissect_ros_T_unbind_invoke ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2008-07-23 21:55:56 +00:00
# line 110 "ros.cnf"
2005-09-04 20:30:31 +00:00
char * oid ;
/* not sure what the length should be - -1 for now */
proto_tree_add_text ( tree , tvb , offset , - 1 , " unbind-invoke " ) ;
2007-05-13 20:58:29 +00:00
if ( session & & session - > pres_ctx_id & & ( oid = find_oid_by_pres_ctx_id ( actx - > pinfo , session - > pres_ctx_id ) ) ) {
2005-09-04 20:30:31 +00:00
/* this should be ROS! */
session - > ros_op = ( ROS_OP_UNBIND | ROS_OP_ARGUMENT ) ;
2007-05-13 20:58:29 +00:00
offset = call_ros_oid_callback ( oid , tvb , offset , actx - > pinfo , top_tree ) ;
2005-09-04 20:30:31 +00:00
}
2005-12-08 23:29:21 +00:00
2005-09-04 20:30:31 +00:00
return offset ;
}
static int
2007-05-13 20:58:29 +00:00
dissect_ros_T_unbind_result ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2008-07-23 21:55:56 +00:00
# line 122 "ros.cnf"
2005-09-04 20:30:31 +00:00
char * oid ;
/* not sure what the length should be - -1 for now */
proto_tree_add_text ( tree , tvb , offset , - 1 , " unbind-result " ) ;
2007-05-13 20:58:29 +00:00
if ( session & & session - > pres_ctx_id & & ( oid = find_oid_by_pres_ctx_id ( actx - > pinfo , session - > pres_ctx_id ) ) ) {
2005-09-04 20:30:31 +00:00
/* this should be ROS! */
session - > ros_op = ( ROS_OP_UNBIND | ROS_OP_RESULT ) ;
2007-05-13 20:58:29 +00:00
offset = call_ros_oid_callback ( oid , tvb , offset , actx - > pinfo , top_tree ) ;
2005-09-04 20:30:31 +00:00
}
2005-12-08 23:29:21 +00:00
2005-09-04 20:30:31 +00:00
return offset ;
}
static int
2007-05-13 20:58:29 +00:00
dissect_ros_T_unbind_error ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2008-07-23 21:55:56 +00:00
# line 133 "ros.cnf"
2005-09-04 20:30:31 +00:00
char * oid ;
/* not sure what the length should be - -1 for now */
proto_tree_add_text ( tree , tvb , offset , - 1 , " unbind-error " ) ;
2007-05-13 20:58:29 +00:00
if ( session & & session - > pres_ctx_id & & ( oid = find_oid_by_pres_ctx_id ( actx - > pinfo , session - > pres_ctx_id ) ) ) {
2005-09-04 20:30:31 +00:00
/* this should be ROS! */
session - > ros_op = ( ROS_OP_UNBIND | ROS_OP_ERROR ) ;
2007-05-13 20:58:29 +00:00
offset = call_ros_oid_callback ( oid , tvb , offset , actx - > pinfo , top_tree ) ;
2005-09-04 20:30:31 +00:00
}
2005-12-08 23:29:21 +00:00
2008-04-13 16:11:15 +00:00
2005-09-04 20:30:31 +00:00
return offset ;
}
2008-04-13 16:11:15 +00:00
const value_string ros_ROS_vals [ ] = {
2005-09-04 20:30:31 +00:00
{ 1 , " invoke " } ,
{ 2 , " returnResult " } ,
{ 3 , " returnError " } ,
{ 4 , " reject " } ,
{ 16 , " bind-invoke " } ,
{ 17 , " bind-result " } ,
{ 18 , " bind-error " } ,
{ 19 , " unbind-invoke " } ,
{ 20 , " unbind-result " } ,
{ 21 , " unbind-error " } ,
{ 0 , NULL }
} ;
2007-10-22 17:03:09 +00:00
static const ber_choice_t ROS_choice [ ] = {
2007-12-03 19:29:24 +00:00
{ 1 , & hf_ros_invoke , BER_CLASS_CON , 1 , BER_FLAGS_IMPLTAG , dissect_ros_Invoke } ,
{ 2 , & hf_ros_returnResult , BER_CLASS_CON , 2 , BER_FLAGS_IMPLTAG , dissect_ros_ReturnResult } ,
{ 3 , & hf_ros_returnError , BER_CLASS_CON , 3 , BER_FLAGS_IMPLTAG , dissect_ros_ReturnError } ,
2008-04-13 16:11:15 +00:00
{ 4 , & hf_ros_reject , BER_CLASS_CON , 4 , BER_FLAGS_IMPLTAG , dissect_ros_T_reject } ,
2007-12-03 19:29:24 +00:00
{ 16 , & hf_ros_bind_invoke , BER_CLASS_CON , 16 , BER_FLAGS_IMPLTAG , dissect_ros_T_bind_invoke } ,
{ 17 , & hf_ros_bind_result , BER_CLASS_CON , 17 , BER_FLAGS_IMPLTAG , dissect_ros_T_bind_result } ,
{ 18 , & hf_ros_bind_error , BER_CLASS_CON , 18 , BER_FLAGS_IMPLTAG , dissect_ros_T_bind_error } ,
{ 19 , & hf_ros_unbind_invoke , BER_CLASS_CON , 19 , BER_FLAGS_IMPLTAG , dissect_ros_T_unbind_invoke } ,
{ 20 , & hf_ros_unbind_result , BER_CLASS_CON , 20 , BER_FLAGS_IMPLTAG , dissect_ros_T_unbind_result } ,
{ 21 , & hf_ros_unbind_error , BER_CLASS_CON , 21 , BER_FLAGS_IMPLTAG , dissect_ros_T_unbind_error } ,
2007-10-22 17:03:09 +00:00
{ 0 , NULL , 0 , 0 , 0 , NULL }
2005-09-04 20:30:31 +00:00
} ;
2008-04-13 16:11:15 +00:00
int
2007-05-13 20:58:29 +00:00
dissect_ros_ROS ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2007-10-22 17:03:09 +00:00
offset = dissect_ber_choice ( actx , tree , tvb , offset ,
ROS_choice , hf_index , ett_ros_ROS ,
NULL ) ;
2005-09-04 20:30:31 +00:00
return offset ;
}
static int
2007-05-13 20:58:29 +00:00
dissect_ros_OBJECT_IDENTIFIER ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2007-05-15 05:49:43 +00:00
offset = dissect_ber_object_identifier ( implicit_tag , actx , tree , tvb , offset , hf_index , NULL ) ;
2005-09-04 20:30:31 +00:00
return offset ;
}
const value_string ros_Code_vals [ ] = {
{ 0 , " local " } ,
{ 1 , " global " } ,
{ 0 , NULL }
} ;
2007-10-22 17:03:09 +00:00
static const ber_choice_t Code_choice [ ] = {
{ 0 , & hf_ros_local , BER_CLASS_UNI , BER_UNI_TAG_INTEGER , BER_FLAGS_NOOWNTAG , dissect_ros_INTEGER } ,
{ 1 , & hf_ros_global , BER_CLASS_UNI , BER_UNI_TAG_OID , BER_FLAGS_NOOWNTAG , dissect_ros_OBJECT_IDENTIFIER } ,
{ 0 , NULL , 0 , 0 , 0 , NULL }
2005-09-04 20:30:31 +00:00
} ;
int
2007-05-13 20:58:29 +00:00
dissect_ros_Code ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
2007-10-22 17:03:09 +00:00
offset = dissect_ber_choice ( actx , tree , tvb , offset ,
Code_choice , hf_index , ett_ros_Code ,
NULL ) ;
2005-09-04 20:30:31 +00:00
return offset ;
}
/*--- End of included file: packet-ros-fn.c ---*/
2010-04-07 16:54:29 +00:00
# line 371 "packet-ros-template.c"
2005-09-04 20:30:31 +00:00
/*
* Dissect ROS PDUs inside a PPDU .
*/
static void
dissect_ros ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * parent_tree )
{
int offset = 0 ;
int old_offset ;
proto_item * item = NULL ;
proto_tree * tree = NULL ;
2008-04-13 16:11:15 +00:00
proto_tree * next_tree = NULL ;
2006-05-01 10:17:59 +00:00
conversation_t * conversation ;
ros_conv_info_t * ros_info = NULL ;
2007-05-13 20:58:29 +00:00
asn1_ctx_t asn1_ctx ;
asn1_ctx_init ( & asn1_ctx , ASN1_ENC_BER , TRUE , pinfo ) ;
2005-09-04 20:30:31 +00:00
/* save parent_tree so subdissectors can create new top nodes */
top_tree = parent_tree ;
/* do we have application context from the acse dissector? */
if ( ! pinfo - > private_data ) {
if ( parent_tree ) {
proto_tree_add_text ( parent_tree , tvb , offset , - 1 ,
" Internal error:can't get application context from ACSE dissector. " ) ;
2009-10-18 20:13:56 +00:00
}
2005-09-04 20:30:31 +00:00
return ;
} else {
session = ( ( struct SESSION_DATA_STRUCTURE * ) ( pinfo - > private_data ) ) ;
}
2006-05-01 10:17:59 +00:00
/*
* Do we have a conversation for this connection ?
*/
conversation = find_conversation ( pinfo - > fd - > num , & pinfo - > src , & pinfo - > dst ,
pinfo - > ptype , pinfo - > srcport ,
pinfo - > destport , 0 ) ;
if ( conversation = = NULL ) {
/* We don't yet have a conversation, so create one. */
conversation = conversation_new ( pinfo - > fd - > num , & pinfo - > src , & pinfo - > dst ,
pinfo - > ptype , pinfo - > srcport ,
pinfo - > destport , 0 ) ;
}
/*
* Do we already have our info
*/
ros_info = conversation_get_proto_data ( conversation , proto_ros ) ;
if ( ros_info = = NULL ) {
/* No. Attach that information to the conversation. */
2009-10-18 20:13:56 +00:00
ros_info = g_malloc ( sizeof ( ros_conv_info_t ) ) ;
2006-05-01 10:17:59 +00:00
ros_info - > matched = g_hash_table_new ( ros_info_hash_matched , ros_info_equal_matched ) ;
ros_info - > unmatched = g_hash_table_new ( ros_info_hash_unmatched , ros_info_equal_unmatched ) ;
2009-10-18 20:13:56 +00:00
2006-05-01 10:17:59 +00:00
conversation_add_proto_data ( conversation , proto_ros , ros_info ) ;
2009-10-18 20:13:56 +00:00
2006-05-01 10:17:59 +00:00
ros_info - > next = ros_info_items ;
ros_info_items = ros_info ;
}
/* pinfo->private_data = ros_info; */
2005-09-04 20:30:31 +00:00
if ( parent_tree ) {
item = proto_tree_add_item ( parent_tree , proto_ros , tvb , 0 , - 1 , FALSE ) ;
tree = proto_item_add_subtree ( item , ett_ros ) ;
}
2009-08-09 06:26:46 +00:00
col_set_str ( pinfo - > cinfo , COL_PROTOCOL , " ROS " ) ;
2009-08-09 07:36:13 +00:00
col_clear ( pinfo - > cinfo , COL_INFO ) ;
2005-09-04 20:30:31 +00:00
while ( tvb_reported_length_remaining ( tvb , offset ) > 0 ) {
old_offset = offset ;
2007-05-13 20:58:29 +00:00
offset = dissect_ros_ROS ( FALSE , tvb , offset , & asn1_ctx , tree , - 1 ) ;
2005-09-04 20:30:31 +00:00
if ( offset = = old_offset ) {
2008-04-13 16:11:15 +00:00
item = proto_tree_add_text ( tree , tvb , offset , - 1 , " Unknown ROS PDU " ) ;
if ( item ) {
2009-05-20 09:27:45 +00:00
expert_add_info_format ( pinfo , item , PI_UNDECODED , PI_WARN , " Unknown ROS PDU " ) ;
2008-04-13 16:11:15 +00:00
next_tree = proto_item_add_subtree ( item , ett_ros_unknown ) ;
dissect_unknown_ber ( pinfo , tvb , offset , next_tree ) ;
}
2005-09-04 20:30:31 +00:00
offset = tvb_length ( tvb ) ;
break ;
}
}
}
2006-05-01 10:17:59 +00:00
static void
ros_reinit ( void )
{
ros_conv_info_t * ros_info ;
/* Free up state attached to the ros_info structures */
2009-10-18 20:13:56 +00:00
for ( ros_info = ros_info_items ; ros_info ! = NULL ; ) {
ros_conv_info_t * last ;
2006-05-01 10:17:59 +00:00
g_hash_table_destroy ( ros_info - > matched ) ;
ros_info - > matched = NULL ;
g_hash_table_destroy ( ros_info - > unmatched ) ;
ros_info - > unmatched = NULL ;
2009-10-18 20:13:56 +00:00
last = ros_info ;
ros_info = ros_info - > next ;
g_free ( last ) ;
2006-05-01 10:17:59 +00:00
}
ros_info_items = NULL ;
}
2005-09-04 20:30:31 +00:00
/*--- proto_register_ros -------------------------------------------*/
void proto_register_ros ( void ) {
/* List of fields */
static hf_register_info hf [ ] =
{
2006-05-01 10:17:59 +00:00
{ & hf_ros_response_in ,
{ " Response In " , " ros.response_in " ,
2009-07-07 09:02:59 +00:00
FT_FRAMENUM , BASE_NONE , NULL , 0x0 ,
2006-05-01 10:17:59 +00:00
" The response to this remote operation invocation is in this frame " , HFILL } } ,
{ & hf_ros_response_to ,
{ " Response To " , " ros.response_to " ,
2009-07-07 09:02:59 +00:00
FT_FRAMENUM , BASE_NONE , NULL , 0x0 ,
2006-05-01 10:17:59 +00:00
" This is a response to the remote operation invocation in this frame " , HFILL } } ,
{ & hf_ros_time ,
{ " Time " , " ros.time " ,
FT_RELATIVE_TIME , BASE_NONE , NULL , 0x0 ,
" The time between the Invoke and the Response " , HFILL } } ,
2005-09-04 20:30:31 +00:00
/*--- Included file: packet-ros-hfarr.c ---*/
2005-12-08 23:29:21 +00:00
# line 1 "packet-ros-hfarr.c"
2005-09-04 20:30:31 +00:00
{ & hf_ros_invoke ,
{ " invoke " , " ros.invoke " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 02:51:39 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_returnResult ,
{ " returnResult " , " ros.returnResult " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 02:51:39 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_returnError ,
{ " returnError " , " ros.returnError " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 02:51:39 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_reject ,
{ " reject " , " ros.reject " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 03:53:31 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_bind_invoke ,
{ " bind-invoke " , " ros.bind_invoke " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 03:53:31 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_bind_result ,
{ " bind-result " , " ros.bind_result " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 03:53:31 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_bind_error ,
{ " bind-error " , " ros.bind_error " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 03:53:31 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_unbind_invoke ,
{ " unbind-invoke " , " ros.unbind_invoke " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 03:53:31 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_unbind_result ,
{ " unbind-result " , " ros.unbind_result " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 03:53:31 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_unbind_error ,
{ " unbind-error " , " ros.unbind_error " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 03:53:31 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_invokeId ,
{ " invokeId " , " ros.invokeId " ,
FT_UINT32 , BASE_DEC , VALS ( ros_InvokeId_vals ) , 0 ,
2010-05-11 02:51:39 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_linkedId ,
{ " linkedId " , " ros.linkedId " ,
FT_INT32 , BASE_DEC , NULL , 0 ,
2010-05-11 02:51:39 +00:00
" INTEGER " , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_opcode ,
{ " opcode " , " ros.opcode " ,
FT_INT32 , BASE_DEC , NULL , 0 ,
2010-05-11 02:51:39 +00:00
" OperationCode " , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_argument ,
{ " argument " , " ros.argument " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 03:53:31 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_result ,
{ " result " , " ros.result " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 03:53:31 +00:00
NULL , HFILL } } ,
2005-10-24 21:42:19 +00:00
{ & hf_ros_operationResult ,
2005-09-04 20:30:31 +00:00
{ " result " , " ros.result " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 02:51:39 +00:00
" OperationResult " , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_errcode ,
{ " errcode " , " ros.errcode " ,
FT_INT32 , BASE_DEC , NULL , 0 ,
2010-05-11 02:51:39 +00:00
" ErrorCode " , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_parameter ,
{ " parameter " , " ros.parameter " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 03:53:31 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_problem ,
{ " problem " , " ros.problem " ,
FT_UINT32 , BASE_DEC , VALS ( ros_T_problem_vals ) , 0 ,
2010-05-11 03:53:31 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_general ,
{ " general " , " ros.general " ,
FT_INT32 , BASE_DEC , VALS ( ros_GeneralProblem_vals ) , 0 ,
2010-05-11 02:51:39 +00:00
" GeneralProblem " , HFILL } } ,
2005-10-24 21:42:19 +00:00
{ & hf_ros_invokeProblem ,
2005-09-04 20:30:31 +00:00
{ " invoke " , " ros.invoke " ,
FT_INT32 , BASE_DEC , VALS ( ros_InvokeProblem_vals ) , 0 ,
2010-05-11 02:51:39 +00:00
" InvokeProblem " , HFILL } } ,
2005-10-24 21:42:19 +00:00
{ & hf_ros_rejectResult ,
2005-09-04 20:30:31 +00:00
{ " returnResult " , " ros.returnResult " ,
FT_INT32 , BASE_DEC , VALS ( ros_ReturnResultProblem_vals ) , 0 ,
2010-05-11 02:51:39 +00:00
" ReturnResultProblem " , HFILL } } ,
2005-10-24 21:42:19 +00:00
{ & hf_ros_rejectError ,
2005-09-04 20:30:31 +00:00
{ " returnError " , " ros.returnError " ,
FT_INT32 , BASE_DEC , VALS ( ros_ReturnErrorProblem_vals ) , 0 ,
2010-05-11 02:51:39 +00:00
" ReturnErrorProblem " , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_present ,
{ " present " , " ros.present " ,
FT_INT32 , BASE_DEC , NULL , 0 ,
2010-05-11 03:53:31 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_absent ,
{ " absent " , " ros.absent " ,
FT_NONE , BASE_NONE , NULL , 0 ,
2010-05-11 03:53:31 +00:00
NULL , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_local ,
{ " local " , " ros.local " ,
FT_INT32 , BASE_DEC , NULL , 0 ,
2010-05-11 02:51:39 +00:00
" INTEGER " , HFILL } } ,
2005-09-04 20:30:31 +00:00
{ & hf_ros_global ,
{ " global " , " ros.global " ,
2005-12-08 23:29:21 +00:00
FT_OID , BASE_NONE , NULL , 0 ,
2010-05-11 02:51:39 +00:00
" OBJECT_IDENTIFIER " , HFILL } } ,
2005-09-04 20:30:31 +00:00
/*--- End of included file: packet-ros-hfarr.c ---*/
2010-04-07 16:54:29 +00:00
# line 505 "packet-ros-template.c"
2005-09-04 20:30:31 +00:00
} ;
/* List of subtrees */
static gint * ett [ ] = {
& ett_ros ,
& ett_ros_unknown ,
/*--- Included file: packet-ros-ettarr.c ---*/
2005-12-08 23:29:21 +00:00
# line 1 "packet-ros-ettarr.c"
2005-09-04 20:30:31 +00:00
& ett_ros_ROS ,
& ett_ros_Invoke ,
& ett_ros_ReturnResult ,
& ett_ros_T_result ,
& ett_ros_ReturnError ,
& ett_ros_Reject ,
& ett_ros_T_problem ,
& ett_ros_InvokeId ,
& ett_ros_Code ,
/*--- End of included file: packet-ros-ettarr.c ---*/
2010-04-07 16:54:29 +00:00
# line 512 "packet-ros-template.c"
2005-09-04 20:30:31 +00:00
} ;
/* Register protocol */
proto_ros = proto_register_protocol ( PNAME , PSNAME , PFNAME ) ;
register_dissector ( " ros " , dissect_ros , proto_ros ) ;
/* Register fields and subtrees */
proto_register_field_array ( proto_ros , hf , array_length ( hf ) ) ;
proto_register_subtree_array ( ett , array_length ( ett ) ) ;
ros_oid_dissector_table = register_dissector_table ( " ros.oid " , " ROS OID Dissectors " , FT_STRING , BASE_NONE ) ;
oid_table = g_hash_table_new ( g_str_hash , g_str_equal ) ;
2007-12-03 19:29:24 +00:00
protocol_table = g_hash_table_new ( g_str_hash , g_str_equal ) ;
2005-12-16 06:47:22 +00:00
ros_handle = find_dissector ( " ros " ) ;
2006-05-01 10:17:59 +00:00
register_init_routine ( ros_reinit ) ;
2005-09-04 20:30:31 +00:00
}
/*--- proto_reg_handoff_ros --- */
void proto_reg_handoff_ros ( void ) {
2005-10-24 21:42:19 +00:00
2005-09-04 20:30:31 +00:00
}