Remove "text2pcap-scanner.obj" and "tools\lemon\lemon.obj" when a "nmake
[obnox/wireshark/wip.git] / packet-giop.h
1 /* packet-giop.h
2  * Declaration of routines for GIOP/IIOP (CDR) dissection
3  * Copyright 2000, Frank Singleton <frank.singleton@ericsson.com>
4  *
5  * Based on CORBAv2.4.2  Chapter 15 GIOP Description.
6  *
7  * $Id: packet-giop.h,v 1.7 2001/10/31 07:47:25 guy Exp $
8  *
9  * Ethereal - Network traffic analyzer
10  * By Gerald Combs <gerald@ethereal.com>
11  * Copyright 1998 Gerald Combs
12  * 
13  * This program is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU General Public License
15  * as published by the Free Software Foundation; either version 2
16  * of the License, or (at your option) any later version.
17  * 
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  * 
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
26  */
27
28 #ifndef PACKET_GIOP_H
29 #define PACKET_GIOP_H
30
31 /*
32  * Useful visible data/structs
33  */
34
35 #define GIOP_HEADER_SIZE    12
36
37 typedef struct Version {
38   guint8 major;
39   guint8 minor;
40 } Version;
41
42
43 /* 
44  * Useful data collected from message header. Note, this
45  * struct encapsulates useful data from GIOP header, as well
46  * as request_id and reply_status for use by sub dissectors.
47  */
48
49 typedef struct MessageHeader {
50
51   /* Common Data */
52
53   guint8 magic[4];
54   Version GIOP_version;
55   guint8 flags;                 /* byte_order in 1.0 */
56   guint8 message_type;
57   guint32 message_size;
58   guint32 req_id;               /* request id in MSG  */
59
60   /* MSG dependant data */
61   
62   guint32 rep_status;           /* reply status in MSG if available */
63   gchar *exception_id;             /* exception string if a USER EXCEPTION occurs  */
64
65 } MessageHeader;
66
67 typedef enum MsgType {
68   Request = 0,
69   Reply,
70   CancelRequest,
71   LocateRequest,
72   LocateReply,
73   CloseConnection,
74   MessageError,
75   Fragment                      /* GIOP 1.1 only */
76
77 } MsgType;
78
79
80
81 /*
82  * Reply Status
83  *
84  */
85
86 typedef enum ReplyStatusType {
87   NO_EXCEPTION = 0,
88   USER_EXCEPTION,
89   SYSTEM_EXCEPTION,
90   LOCATION_FORWARD,
91   LOCATION_FORWARD_PERM,        /* new for GIOP 1.2 */
92   NEEDS_ADDRESSING_MODE         /* new for GIOP 1.2 */
93 } ReplyStatusType;
94
95 /*
96  * Prototype for sub dissector function calls.
97  */
98
99 typedef gboolean (giop_sub_dissector_t)(tvbuff_t *, packet_info *, proto_tree *, int *,
100                                   MessageHeader *, gchar * , gchar *);
101
102 /*
103  * Generic Subdissector handle, wraps user info.
104  */
105
106 typedef struct giop_sub_handle {
107   giop_sub_dissector_t *sub_fn;  /* ptr to sub dissector function */
108   gchar *sub_name;               /* subdissector string name */
109   int sub_proto;                /* proto_XXX value from proto_register_protocol() */
110 } giop_sub_handle_t;
111
112 /* Main GIOP entry point */
113
114 extern gboolean dissect_giop(tvbuff_t *, packet_info *, proto_tree *); /* new interface */
115
116 /*
117  * GIOP Users register interest via this function.
118  * This is for heuristic dissection
119  */
120
121 extern void register_giop_user(giop_sub_dissector_t *sub, gchar *name,
122     int sub_proto);
123
124 /*
125  * GIOP Users remove interest via this function.
126  * This is for heuristic dissection
127  */
128
129 extern void delete_giop_user(giop_sub_dissector_t *sub, gchar *name);
130
131
132 /*
133  * GIOP Users register their module and interface names via this function.
134  * This is for explicit dissection.
135  */
136
137 extern void register_giop_user_module(giop_sub_dissector_t *sub, gchar *name,
138     gchar *module, int sub_proto);
139
140 /*
141  * GIOP Users remove their module and interface names via this function.
142  * This is for explicit dissection.
143  */
144
145 extern void delete_giop_user_module(giop_sub_dissector_t *sub, gchar *name,
146     gchar *module);
147
148
149 /*
150  * General CDR accessors start here. They are listed in alphabetical
151  * order. They may however, belong to 1 of 3 distinct CDR data types.
152  *
153  * - Primitive
154  * - OMG IDL Constructed Types
155  * - Pseudo Object Types
156  *
157  *
158  * Altough some of these look redundant, I have separated them
159  * out for all CDR types, to assist in auto generation of
160  * IDL dissectors later, see idl2eth -- FS
161  *
162  */
163
164
165 /*
166  * Gets data of type any. This is encoded as a TypeCode
167  * followed by the encoded value.
168  *
169  * Data is added to tree directly if present.
170  */
171
172 extern void get_CDR_any(tvbuff_t *tvb, proto_tree *tree, gint *offset,
173     gboolean stream_is_big_endian, int boundary, MessageHeader * header );
174
175
176 /* Copy a 1 octet sequence from the tvbuff 
177  * which represents a boolean value, and convert
178  * it to a boolean value.
179  * Offset is then incremented by 1, to indicate the 1 octet which
180  * has been processed.
181  */
182
183 extern gboolean get_CDR_boolean(tvbuff_t *tvb, int *offset);
184
185
186 /* Copy a 1 octet sequence from the tvbuff 
187  * which represents a char, and convert
188  * it to an char value.
189  * offset is then incremented by 1, to indicate the 1 octet which
190  * has been processed.
191  */
192
193 extern guint8 get_CDR_char(tvbuff_t *tvb, int *offset);
194
195
196
197 /* 
198  * Floating Point Data Type double IEEE 754-1985 
199  *
200  * Copy an 8 octet sequence from the tvbuff 
201  * which represents a double value, and convert
202  * it to a double value, taking into account byte order.
203  * offset is first incremented so that it falls on a proper alignment
204  * boundary for double values.
205  * offset is then incremented by 8, to indicate the 8 octets which
206  * have been processed.
207  */
208
209 extern gdouble get_CDR_double(tvbuff_t *tvb, int *offset,
210     gboolean stream_is_big_endian, int boundary);
211
212
213 /* Copy a 4 octet sequence from the tvbuff 
214  * which represents an enum value, and convert
215  * it to an enum value, taking into account byte order.
216  * offset is first incremented so that it falls on a proper alignment
217  * boundary for an enum (4)
218  * offset is then incremented by 4, to indicate the 4 octets which
219  * have been processed.
220  *
221  * Enum values are encoded as unsigned long.
222  */
223
224 extern guint32 get_CDR_enum(tvbuff_t *tvb, int *offset,
225     gboolean stream_is_big_endian, int boundary);
226
227
228
229 /*
230  * Copy an octet sequence from the tvbuff
231  * which represents a Fixed point decimal type, and create a string representing
232  * a Fixed point decimal type. There are no alignment restrictions.
233  * Size and scale of fixed decimal type is determined by IDL.
234  * 
235  * digits - IDL specified number of "digits" for this fixed type
236  * scale  - IDL specified "scale" for this fixed type
237  *
238  *
239  * eg: typedef fixed <5,2> fixed_t;
240  *     could represent numbers like 123.45, 789.12, 
241  *
242  *
243  * As the fixed type could be any size, I will not try to fit it into our
244  * simple types like gdouble or glong etc. I will just create a string buffer holding
245  * a  representation (after scale is applied), and with a decimal point or zero padding
246  * inserted at the right place if necessary. The string is null terminated
247  *
248  * so string may look like 
249  *
250  *
251  *  "+1.234" or "-3456.78" or "1234567309475760377365465897891" or "-2789000000" etc
252  *
253  * According to spec, digits <= 31
254  * and scale is positive (except for constants eg: 1000 has digit=1 and implied scale = -3)
255  * or <4,0> ?
256  *
257  * User must remember to free the buffer
258  *
259  */
260
261 extern void get_CDR_fixed(tvbuff_t *tvb, gchar **seq, gint *offset,
262     guint32 digits, gint32 scale);
263
264
265
266 /*
267  * Floating Point Data Type float IEEE 754-1985 
268  * 
269  * Copy a 4 octet sequence from the tvbuff 
270  * which represents a float value, and convert
271  * it to a float value, taking into account byte order.
272  * offset is first incremented so that it falls on a proper alignment
273  * boundary for float values.
274  * offset is then incremented by 4, to indicate the 4 octets which
275  * have been processed.
276  */
277
278 extern gfloat get_CDR_float(tvbuff_t *tvb, int *offset,
279     gboolean stream_is_big_endian, int boundary);
280
281
282 /*
283  * Decode an Interface type, and display it on the tree.
284  */
285
286 extern void get_CDR_interface(tvbuff_t *tvb, packet_info *pinfo,
287     proto_tree *tree, int *offset, gboolean stream_is_big_endian, int boundary);
288
289
290 /* Copy a 4 octet sequence from the tvbuff 
291  * which represents a signed long value, and convert
292  * it to an signed long vaule, taking into account byte order.
293  * offset is first incremented so that it falls on a proper alignment
294  * boundary for long values.
295  * offset is then incremented by 4, to indicate the 4 octets which
296  * have been processed.
297  */
298
299 extern gint32 get_CDR_long(tvbuff_t *tvb, int *offset,
300     gboolean stream_is_big_endian, int boundary);
301
302
303
304 /* Copy a 16 octet sequence from the tvbuff 
305  * which represents a long double value, and convert
306  * it to a long double value, taking into account byte order.
307  * offset is first incremented so that it falls on a proper alignment
308  * boundary for  long double values.
309  * offset is then incremented by 16, to indicate the 16 octets which
310  * have been processed.
311  */
312
313 #ifdef G_HAVE_GLONG_DOUBLE
314
315 extern glong_double get_CDR_long_double(tvbuff_t *tvb, int *offset,
316     gboolean stream_is_big_endian, int boundary);
317 #else
318
319 /* FIX -- Cast long double to gdouble until I figure this out -- FS*/
320
321 extern gdouble get_CDR_long_double(tvbuff_t *tvb, int *offset,
322     gboolean stream_is_big_endian, int boundary);
323
324 #endif
325
326
327 /* Copy an 8 octet sequence from the tvbuff 
328  * which represents a signed long long value, and convert
329  * it to a signed long long value, taking into account byte order.
330  * offset is first incremented so that it falls on a proper alignment
331  * boundary for long long values.
332  * offset is then incremented by 8, to indicate the 8 octets which
333  * have been processed.
334  */
335
336 #ifdef G_HAVE_GINT64
337 extern gint64 get_CDR_long_long(tvbuff_t *tvb, int *offset,
338     gboolean stream_is_big_endian, int boundary);
339 #endif
340
341 /*
342  * Decode an Object type, and display it on the tree.
343  */
344
345 extern void get_CDR_object(tvbuff_t *tvb, packet_info *pinfo,
346     proto_tree *tree, int *offset, gboolean stream_is_big_endian, int boundary);
347
348
349 /* Copy a 1 octet sequence from the tvbuff 
350  * which represents a octet, and convert
351  * it to an octet value.
352  * offset is then incremented by 1, to indicate the 1 octet which
353  * has been processed.
354  */
355
356 extern guint8 get_CDR_octet(tvbuff_t *tvb, int *offset);
357
358
359 /* Copy a sequence of octets from the tvbuff.
360  * Caller of this function must remember to free the 
361  * array pointed to by seq.
362  * This function also increments offset by len. 
363  */
364
365 extern void get_CDR_octet_seq(tvbuff_t *tvb, gchar **seq, int *offset, int len);
366
367 /* Copy a 2 octet sequence from the tvbuff 
368  * which represents a signed short value, and convert
369  * it to a signed short value, taking into account byte order.
370  * offset is first incremented so that it falls on a proper alignment
371  * boundary for short values.
372  * offset is then incremented by 2, to indicate the 2 octets which
373  * have been processed.
374  */
375
376 extern gint16 get_CDR_short(tvbuff_t *tvb, int *offset,
377     gboolean stream_is_big_endian, int boundary);
378
379
380 /* Copy an octet sequence from the tvbuff 
381  * which represents a string, and convert
382  * it to an string value, taking into account byte order.
383  * offset is first incremented so that it falls on a proper alignment
384  * boundary for string values. (begins with an unsigned long LI)
385  *
386  * String sequence is copied to a  buffer "seq". This must
387  * be freed by the calling program.
388  * offset is then incremented  , to indicate the  octets which
389  * have been processed.
390  *
391  * returns number of octets in the sequence
392  *
393  * Note: This function only supports single byte encoding at the
394  *       moment until I get a handle on multibyte encoding etc.
395  *
396  */
397
398 extern guint32 get_CDR_string(tvbuff_t *tvb, gchar **seq, int *offset,
399     gboolean stream_is_big_endian, int boundary);
400
401
402 /* Process a sequence of octets that represent the 
403  * Pseudo Object Type "TypeCode". Typecodes are used for example,
404  * by "Any values". 
405  * This function also increments offset to the correct position.
406  *
407  * It will parse the TypeCode and output data to the "tree" provided
408  * by the user
409  *
410  * It returns a guint32 representing a TCKind value. 
411  */
412
413 extern guint32 get_CDR_typeCode(tvbuff_t *tvb, proto_tree *tree, gint *offset,
414     gboolean stream_is_big_endian, int boundary, MessageHeader * header );
415
416 /* Copy a 4 octet sequence from the tvbuff 
417  * which represents an unsigned long value, and convert
418  * it to an unsigned long value, taking into account byte order.
419  * offset is first incremented so that it falls on a proper alignment
420  * boundary for unsigned long values.
421  * offset is then incremented by 4, to indicate the 4 octets which
422  * have been processed.
423  */
424
425 extern guint32 get_CDR_ulong(tvbuff_t *tvb, int *offset,
426     gboolean stream_is_big_endian, int boundary);
427
428
429 /* Copy an 8 octet sequence from the tvbuff 
430  * which represents an unsigned long long value, and convert
431  * it to an unsigned long long value, taking into account byte order.
432  * offset is first incremented so that it falls on a proper alignment
433  * boundary for unsigned long long values.
434  * offset is then incremented by 8, to indicate the 8 octets which
435  * have been processed.
436  */
437
438 #ifdef G_HAVE_GINT64
439 extern guint64 get_CDR_ulong_long(tvbuff_t *tvb, int *offset,
440     gboolean stream_is_big_endian, int boundary);
441 #endif
442
443
444 /* Copy a 2 octet sequence from the tvbuff 
445  * which represents an unsigned short value, and convert
446  * it to an unsigned short value, taking into account byte order.
447  * offset is first incremented so that it falls on a proper alignment
448  * boundary for unsigned short values.
449  * offset is then incremented by 2, to indicate the 2 octets which
450  * have been processed.
451  */
452
453 extern guint16 get_CDR_ushort(tvbuff_t *tvb, int *offset,
454     gboolean stream_is_big_endian, int boundary);
455
456
457 /* Copy a wchar from the tvbuff.
458  * Caller of this function must remember to free the 
459  * array pointed to by seq.
460  * This function also increments offset according to
461  * the wchar size.
462  *
463  * For GIOP 1.1 read 2 octets and return size -2. The
464  * negation means there is no size element in the packet
465  * and therefore no size to add to the tree.
466  *
467  * For GIOP 1.2 read size of wchar and the size
468  * octets. size is returned as a gint8.
469  *
470  * For both GIOP versions the wchar is returned
471  * as a printable string.
472  *
473  */
474
475 /* NOTE: This is very primitive in that it just reads
476  * the wchar as a series of octets and returns them
477  * to the user. No translation is attempted based on
478  * byte orientation, nor on code set. I.e it only 
479  * really reads past the wchar and increments the offset
480  * by the length of the octet sequence.
481  */
482
483 /* The "decoding" is done according to CORBA chapter 15.
484  * Wchar is not supported for GIOP 1.0.
485  */
486
487 extern gint8 get_CDR_wchar(tvbuff_t *tvb, gchar **seq, int *offset,
488     MessageHeader * header);
489
490
491 /* Copy a wstring from the tvbuff.
492  * Caller of this function must remember to free the 
493  * array pointed to by seq.
494  * This function also increments offset, according to
495  * wstring length. length is returned as guint32
496  */
497
498 /* NOTE: This is very primitive in that it just reads
499  * the wstring as a series of octets and returns them
500  * to the user. No translation is attempted based on
501  * byte orientation, nor on code set. I.e it only 
502  * really reads past the wstring and increments the offset
503  * by the length of the octet sequence.
504  */
505
506 /* The "decoding" is done according to CORBA chapter 15.
507  * Wstring is not supported for GIOP 1.0.
508  */
509
510 extern guint32 get_CDR_wstring(tvbuff_t *tvb, gchar **seq, int *offset,
511     gboolean stream_is_big_endian, int boundary, MessageHeader * header);
512
513
514
515 /*
516  *
517  * End of get_CDR_xxx accessors.
518  *
519  */
520
521
522
523 /* Determine the byte order from the GIOP MessageHeader */
524
525 extern gboolean is_big_endian (MessageHeader * header);
526
527 /*
528  * get_encap_info() for any encapsulation  (eg:sequences)
529  * we come across. updates the new boundary and endianess
530  * and *offset, and returns the sequence length.
531  */
532
533 extern guint32 get_CDR_encap_info(tvbuff_t *tvb, proto_tree *tree, gint *offset, 
534                            gboolean old_stream_is_big_endian, guint32 old_boundary,
535                            gboolean *new_stream_is_big_endian_ptr, guint32 *new_boundary_ptr );
536
537
538
539 /*
540  * Enums for TCkind
541  */
542
543 enum TCKind {
544   tk_null = 0,
545   tk_void,
546   tk_short,
547   tk_long,
548   tk_ushort,
549   tk_ulong,
550   tk_float,
551   tk_double,
552   tk_boolean,
553   tk_char,
554   tk_octet,
555   tk_any,
556   tk_TypeCode,
557   tk_Principal,
558   tk_objref,
559   tk_struct,
560   tk_union,
561   tk_enum,
562   tk_string,
563   tk_sequence,
564   tk_array,
565   tk_alias,
566   tk_except,
567   tk_longlong,
568   tk_ulonglong,
569   tk_longdouble,
570   tk_wchar,
571   tk_wstring,
572   tk_fixed,
573   tk_value,
574   tk_value_box,
575   tk_native,
576   tk_abstract_interface,
577
578   /* - none -   0xffffffff TODO */
579 };
580
581 #define tk_none  0xffffffff
582
583 typedef enum TCKind TCKind_t;
584
585
586 /*
587  * ServiceId's for ServiceContextList
588  *
589  * Chapter 13 Corba 2.4.2
590  */
591
592 #define IOP_ServiceId_TransactionService                0
593 #define IOP_ServiceId_CodeSets                          1
594 #define IOP_ServiceId_ChainBypassCheck                  2
595 #define IOP_ServiceId_ChainBypassInfo                   3
596 #define IOP_ServiceId_LogicalThreadId                   4
597 #define IOP_ServiceId_BI_DIR_IIOP                       5
598 #define IOP_ServiceId_SendingContextRunTime             6
599 #define IOP_ServiceId_INVOCATION_POLICIES               7
600 #define IOP_ServiceId_FORWARD_IDENTITY                  8
601 #define IOP_ServiceId_UnknownExceptionInfo              9
602
603 #endif /* PACKET_GIOP_H */