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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
// **********************************************************************
//
// Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
#ifndef ICE_ENDPOINT_I_H
#define ICE_ENDPOINT_I_H
#include <IceUtil/Shared.h>
#include <IceUtil/Thread.h>
#include <IceUtil/Monitor.h>
#include <Ice/Endpoint.h>
#include <Ice/EndpointIF.h>
#include <Ice/InstanceF.h>
#include <Ice/TransceiverF.h>
#include <Ice/ConnectorF.h>
#include <Ice/AcceptorF.h>
#include <Ice/Protocol.h>
#ifdef _WIN32
# include <winsock2.h>
#else
# include <sys/socket.h> // For struct sockaddr_storage
#endif
#include <deque>
namespace IceInternal
{
class BasicStream;
class ICE_API EndpointI_connectors : public virtual IceUtil::Shared
{
public:
virtual ~EndpointI_connectors() { }
virtual void connectors(const std::vector<ConnectorPtr>&) = 0;
virtual void exception(const Ice::LocalException&) = 0;
};
typedef IceUtil::Handle<EndpointI_connectors> EndpointI_connectorsPtr;
class ICE_API EndpointI : public Ice::Endpoint
{
public:
//
// Marshal the endpoint.
//
virtual void streamWrite(BasicStream*) const = 0;
//
// Return the endpoint type.
//
virtual Ice::Short type() const = 0;
//
// Return the timeout for the endpoint in milliseconds. 0 means
// non-blocking, -1 means no timeout.
//
virtual Ice::Int timeout() const = 0;
//
// Return a new endpoint with a different timeout value, provided
// that timeouts are supported by the endpoint. Otherwise the same
// endpoint is returned.
//
virtual EndpointIPtr timeout(Ice::Int) const = 0;
//
// Return a new endpoint with a different connection id.
//
virtual EndpointIPtr connectionId(const ::std::string&) const = 0;
//
// Return true if the endpoints support bzip2 compress, or false
// otherwise.
//
virtual bool compress() const = 0;
//
// Return a new endpoint with a different compression value,
// provided that compression is supported by the
// endpoint. Otherwise the same endpoint is returned.
//
virtual EndpointIPtr compress(bool) const = 0;
//
// Return true if the endpoint is datagram-based.
//
virtual bool datagram() const = 0;
//
// Return true if the endpoint is secure.
//
virtual bool secure() const = 0;
//
// Return true if the endpoint type is unknown.
//
virtual bool unknown() const = 0;
//
// Return a server side transceiver for this endpoint, or null if a
// transceiver can only be created by an acceptor. In case a
// transceiver is created, this operation also returns a new
// "effective" endpoint, which might differ from this endpoint,
// for example, if a dynamic port number is assigned.
//
virtual TransceiverPtr transceiver(EndpointIPtr&) const = 0;
//
// Return connectors for this endpoint, or empty vector if no
// connector is available.
//
virtual std::vector<ConnectorPtr> connectors() const = 0;
virtual void connectors_async(const EndpointI_connectorsPtr&) const = 0;
//
// Return an acceptor for this endpoint, or null if no acceptors
// is available. In case an acceptor is created, this operation
// also returns a new "effective" endpoint, which might differ
// from this endpoint, for example, if a dynamic port number is
// assigned.
//
virtual AcceptorPtr acceptor(EndpointIPtr&, const std::string&) const = 0;
//
// Expand endpoint out in to separate endpoints for each local
// host if listening on INADDR_ANY on server side.
//
virtual std::vector<EndpointIPtr> expand() const = 0;
//
// Check whether the endpoint is equivalent to another one.
//
virtual bool equivalent(const EndpointIPtr&) const = 0;
//
// Compare endpoints for sorting purposes.
//
virtual bool operator==(const EndpointI&) const = 0;
virtual bool operator!=(const EndpointI&) const = 0;
virtual bool operator<(const EndpointI&) const = 0;
private:
virtual std::vector<ConnectorPtr> connectors(const std::vector<struct sockaddr_storage>&) const;
friend class EndpointHostResolver;
#if defined(__SUNPRO_CC) || defined(__HP_aCC)
//
// COMPILERFIX: prevent the compiler from emitting a warning about
// hidding these operators.
//
using LocalObject::operator==;
using LocalObject::operator<;
#endif
};
class ICE_API EndpointHostResolver : public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex>
{
public:
EndpointHostResolver(const InstancePtr&);
void resolve(const std::string&, int, const EndpointIPtr&, const EndpointI_connectorsPtr&);
void destroy();
virtual void run();
private:
struct ResolveEntry
{
std::string host;
int port;
EndpointIPtr endpoint;
EndpointI_connectorsPtr callback;
};
const InstancePtr _instance;
bool _destroyed;
std::deque<ResolveEntry> _queue;
};
}
#endif
|
