This file is indexed.

/usr/include/sipxtapi/cp/CpGhostConnection.h is in libsipxtapi-dev 3.3.0~test17-2.1.

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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
//
// Copyright (C) 2005-2011 SIPez LLC.  All rights reserved.
// Licensed to SIPfoundry under a Contributor Agreement.
// 
// Copyright (C) 2004-2007 SIPfoundry Inc.
// Licensed by SIPfoundry under the LGPL license.
//
// Copyright (C) 2004-2006 Pingtel Corp.  All rights reserved.
// Licensed to SIPfoundry under a Contributor Agreement.
//
// $$
///////////////////////////////////////////////////////////////////////////////

// Author: Daniel Petrie dpetrie AT SIPez DOT com

#ifndef _CpGhostConnection_h_
#define _CpGhostConnection_h_

// SYSTEM INCLUDES
//#include <...>

// APPLICATION INCLUDES
#include <cp/Connection.h>
#include <net/SipContactDb.h>

// DEFINES
// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STRUCTS
// TYPEDEFS
// FORWARD DECLARATIONS


//:logical Connection within a call
// The Connection encapsulates the call setup protocol and state
// information for the leg of a call to a particular address.
class CpGhostConnection: public Connection
{
/* //////////////////////////// PUBLIC //////////////////////////////////// */
public:

   static const UtlContainableType TYPE;

/* ============================ CREATORS ================================== */

   CpGhostConnection(CpCallManager* callMgr = NULL,
              CpCall* call = NULL, const char* callId = NULL);
     //:Default constructor


   virtual
   ~CpGhostConnection();
     //:Destructor

/* ============================ MANIPULATORS ============================== */

   virtual UtlBoolean dequeue();

   virtual UtlBoolean dial(const char* dialString,
                           const char* callerId,
                           const char* callId,
                           const char* callController = NULL,
                           const char* originalCallConnection = NULL,
                           UtlBoolean requestQueuedCall = FALSE,
                           const void* pDisplay = NULL,
                           const void* pSecurity = NULL,
                           const char* locationHeader = NULL,
                           const int bandWidth = AUDIO_MICODEC_BW_DEFAULT,
                           UtlBoolean bOnHold = FALSE,
                           const char* originalCallId = NULL,
                           const RTP_TRANSPORT rtpTransportOptions = RTP_TRANSPORT_UDP);

   //! param: requestQueuedCall - indicates that the caller wishes to have the callee queue the call if busy

   virtual UtlBoolean originalCallTransfer(UtlString& transferTargetAddress,
                                                           const char* transferControllerAddress,
                                   const char* targetCallId);
   // Initiate blind transfer on transfer controller connection in
   // the original call.

   virtual UtlBoolean targetCallBlindTransfer(const char* transferTargetAddress,
                                                           const char* transferControllerAddress);
   // Communicate blind transfer on transfer controller connection in
   // the target call.  This is signaled by the transfer controller in the
   // original call.

   virtual UtlBoolean transfereeStatus(int connectionState, int response);
   // Method to communicate status to original call on transferee side

   virtual UtlBoolean transferControllerStatus(int connectionState, int cause);
   // Method to communicate status to target call on transfer
   // controller side

   virtual UtlBoolean answer(const void* hWnd = NULL);

   virtual void outOfFocus();

   virtual UtlBoolean hangUp();

   virtual UtlBoolean hold();

   virtual UtlBoolean reject(int errorCode = 0, const char* errorText = "");

   virtual UtlBoolean redirect(const char* forwardAddress);

   virtual UtlBoolean offHold();

   virtual UtlBoolean renegotiateCodecs();

   virtual UtlBoolean silentRemoteHold() ;

   virtual UtlBoolean accept(int forwardOnNoAnswerSeconds, 
                             const void *pSecurity = NULL,
                             const char* locationHeader = NULL,
                             const int bandWidth = AUDIO_MICODEC_BW_DEFAULT,
                             UtlBoolean sendEarlyMedia = FALSE);

   virtual UtlBoolean processMessage(OsMsg& eventMessage);

/* ============================ ACCESSORS ================================= */

   virtual UtlContainableType getContainableType() const;

   virtual UtlBoolean getRemoteAddress(UtlString* remoteAddress) const;
   //: get Connection address
   //! returns: TRUE/FALSE if the connection has an address.  The connection may not have an address assigned yet (i.e. if it is not fully setup).

   virtual UtlBoolean getRemoteAddress(UtlString* remoteAddress, UtlBoolean leaveFieldParametersIn) const;
   //: get Connection address
   //! returns: TRUE/FALSE if the connection has an address.  The connection may not have an address assigned yet (i.e. if it is not fully setup).
   
           virtual UtlBoolean getSession(SipSession& session);

    /**
     * Enumerate possible contact addresses
     */
    virtual void getLocalContactAddresses( SIPX_CONTACT_ADDRESS contacts[],
                                           size_t nMaxContacts,
                                           size_t& nActualContacts) ;

    virtual void getRemoteUserAgent(UtlString* pUserAgent);


/* ============================ INQUIRY =================================== */

   virtual UtlBoolean isInstanceOf(const UtlContainableType type) const;

   virtual UtlBoolean willHandleMessage(OsMsg& eventMessage) const;

   virtual UtlBoolean isConnection(const char* callId,
                                  const char* toTag,
                                  const char* fromTag,
                                  UtlBoolean strictCompare) const;

   virtual UtlBoolean isSameRemoteAddress(Url& remoteAddress) const;

/* //////////////////////////// PROTECTED ///////////////////////////////// */
protected:



/* //////////////////////////// PRIVATE /////////////////////////////////// */
private:

        CpGhostConnection(const CpGhostConnection& rCpGhostConnection);
     //:Copy constructor (disabled)
        CpGhostConnection& operator=(const CpGhostConnection& rhs);
     //:Assignment operator (disabled)

    UtlString mRemoteAddress;

};

/* ============================ INLINE METHODS ============================ */

#endif  // _CpGhostConnection_h_