This file is indexed.

/usr/include/orbit-2.0/orbit/orb-core/orbit-small.h is in liborbit2-dev 1:2.14.19-0.3.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
/*
 * An attempt to shrink the beast to a managable size.
 */
#ifndef CORBA_SMALL_H
#define CORBA_SMALL_H 1

#include <glib-object.h>
#include <orbit/orb-core/orbit-interface.h>

G_BEGIN_DECLS

typedef struct {
	CORBA_unsigned_long           version;
	ORBit_IInterface            **interfaces;
	CORBA_sequence_CORBA_TypeCode types;
} ORBit_IModule;

const char    *ORBit_get_safe_tmp      (void);

/* Builtin allocators */
gpointer       ORBit_small_alloc       (CORBA_TypeCode      tc);
gpointer       ORBit_small_allocbuf    (CORBA_TypeCode      tc,
					CORBA_unsigned_long length);
void           ORBit_small_freekids    (CORBA_TypeCode      tc,
					gpointer            p,
					gpointer            d);

/* More friendly(?) sequence allocators */
gpointer       ORBit_sequence_alloc    (CORBA_TypeCode      sequence_tc,
					CORBA_unsigned_long length);
void           ORBit_sequence_append   (gpointer            sequence,
					gconstpointer       element);
void           ORBit_sequence_set_size (gpointer            sequence,
					CORBA_unsigned_long length);
#define        ORBit_sequence_index(sequence,idx) (sequence)->_buffer[(idx)]
void           ORBit_sequence_concat   (gpointer            sequence,
					gconstpointer       append);
void           ORBit_sequence_remove   (gpointer            sequence,
                                        guint               idx);

typedef enum {
	ORBIT_CONNECTION_CONNECTED,
	ORBIT_CONNECTION_CONNECTING,
	ORBIT_CONNECTION_DISCONNECTED,
	ORBIT_CONNECTION_IN_PROC
} ORBitConnectionStatus;

gpointer              ORBit_small_get_servant              (CORBA_Object obj);
ORBitConnectionStatus ORBit_small_get_connection_status    (CORBA_Object obj);
ORBitConnectionStatus ORBit_small_listen_for_broken        (CORBA_Object obj,
							    GCallback    fn,
							    gpointer     user_data);
ORBitConnectionStatus ORBit_small_unlisten_for_broken_full (CORBA_Object obj,
							    GCallback    fn,
							    gpointer     user_data);
/* old / stale */
ORBitConnectionStatus ORBit_small_unlisten_for_broken      (CORBA_Object obj,
							    GCallback    fn);

typedef struct _ORBitConnection ORBitConnection;

ORBitConnection      *ORBit_small_get_connection        (CORBA_Object     obj);
ORBitConnection      *ORBit_small_get_connection_ref    (CORBA_Object     obj);
void                  ORBit_small_connection_unref      (ORBitConnection *cnx);
void                  ORBit_connection_set_max_buffer   (ORBitConnection *cnx,
							 gulong           max_buffer_bytes);

#if defined(ORBIT2_INTERNAL_API) || defined (ORBIT2_STUBS_API)

#define ORBIT_SMALL_FAST_LOCALS           1
#define ORBIT_SMALL_FORCE_GENERIC_MARSHAL 2

extern int     ORBit_small_flags;

/* Deprecated - only for bin-compat with pre 2.4 stubs */
void           ORBit_small_invoke_stub (CORBA_Object        object,
					ORBit_IMethod      *m_data,
					gpointer            ret,
					gpointer           *args,
					CORBA_Context       ctx,
					CORBA_Environment  *ev);


void           ORBit_small_invoke_stub_n (CORBA_Object        object,
					  ORBit_IMethods     *methods,
					  glong               index,
					  gpointer            ret,
					  gpointer           *args,
					  CORBA_Context       ctx,
					  CORBA_Environment  *ev);

#endif /* defined(ORBIT2_INTERNAL_API) || defined (ORBIT2_STUBS_API) */

#ifdef ORBIT2_INTERNAL_API

#include <orbit/GIOP/giop.h>

void           ORBit_small_invoke_adaptor (ORBit_OAObject     adaptor_obj,
					   GIOPRecvBuffer    *recv_buffer,
					   ORBit_IMethod     *m_data,
					   gpointer           data,
					   CORBA_Environment *ev);

#endif /* ORBIT2_INTERNAL_API */

/* Type library work */
CORBA_char       *ORBit_small_get_type_id         (CORBA_Object       object,
						   CORBA_Environment *ev);
ORBit_IInterface *ORBit_small_get_iinterface      (CORBA_Object       opt_object,
					           const CORBA_char  *repo_id,
						   CORBA_Environment *ev);
gboolean          ORBit_small_load_typelib        (const char        *libname);
CORBA_sequence_CORBA_TypeCode *
                  ORBit_small_get_types           (const char        *name);
CORBA_sequence_ORBit_IInterface *
                  ORBit_small_get_iinterfaces     (const char        *name);

typedef struct _ORBitAsyncQueueEntry ORBitAsyncQueueEntry;

typedef void (*ORBitAsyncInvokeFunc) (CORBA_Object          object,
				      ORBit_IMethod        *m_data,
				      ORBitAsyncQueueEntry *aqe,
				      gpointer              user_data, 
				      CORBA_Environment    *ev);

/* Various bits for Async work */
void ORBit_small_invoke_async        (CORBA_Object           obj,
				      ORBit_IMethod         *m_data,
				      ORBitAsyncInvokeFunc   fn,
				      gpointer               user_data,
				      gpointer              *args,
				      CORBA_Context          ctx,
				      CORBA_Environment     *ev);

void ORBit_small_demarshal_async     (ORBitAsyncQueueEntry  *aqe,
				      gpointer               ret,
				      gpointer              *args,
				      CORBA_Environment     *ev);

G_END_DECLS

#endif /* CORBA_SMALL_H */