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
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
/* -*- C++ -*- */
// $Id$
// ============================================================================
//
// = LIBRARY
// ace
//
// = FILENAME
// SOCK_Connector.h
//
// = AUTHOR
// Doug Schmidt
//
// ============================================================================
#ifndef ACE_SOCK_CONNECTOR_H
#define ACE_SOCK_CONNECTOR_H
#include "ace/pre.h"
#include "ace/SOCK_Stream.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "ace/Time_Value.h"
class ACE_Export ACE_SOCK_Connector
{
// = TITLE
// Defines a factory that creates new <ACE_Stream>s actively.
//
// = DESCRIPTION
// The <ACE_SOCK_Connector> doesn't have a socket of its own,
// i.e., it simply "borrows" the one from the ACE_SOCK_Stream
// that's being connected. The reason for this is that the
// underlying socket API doesn't use a "factory" socket to connect
// "data-mode" sockets. Therefore, there's no need to inherit
// <ACE_SOCK_Connector> from <ACE_SOCK>. A nice side-effect of
// this is that <ACE_SOCK_Connector>'s do not store state so they
// can be used reentrantly in multi-threaded programs.
public:
// = Initialization and termination methods.
ACE_SOCK_Connector (void);
// Default constructor.
ACE_SOCK_Connector (ACE_SOCK_Stream &new_stream,
const ACE_Addr &remote_sap,
ACE_Time_Value *timeout = 0,
const ACE_Addr &local_sap = ACE_Addr::sap_any,
int reuse_addr = 0,
int flags = 0,
int perms = 0,
int protocol_family = PF_INET,
int protocol = 0);
// Actively connect and produce a <new_stream> if things go well.
// The <remote_sap> is the address that we are trying to connect
// with. The <timeout> is the amount of time to wait to connect.
// If it's 0 then we block indefinitely. If *timeout == {0, 0} then
// the connection is done using non-blocking mode. In this case, if
// the connection can't be made immediately the value of -1 is
// returned with <errno == EWOULDBLOCK>. If *timeout > {0, 0} then
// this is the amount of time to wait before timing out. If the
// time expires before the connection is made <errno == ETIME>. The
// <local_sap> is the value of local address to bind to. If it's
// the default value of <ACE_Addr::sap_any> then the user is letting
// the OS do the binding. If <reuse_addr> == 1 then the
// <local_addr> is reused, even if it hasn't been cleanedup yet.
ACE_SOCK_Connector (ACE_SOCK_Stream &new_stream,
const ACE_Addr &remote_sap,
ACE_QoS_Params qos_params,
ACE_Time_Value *timeout = 0,
const ACE_Addr &local_sap = ACE_Addr::sap_any,
ACE_Protocol_Info *protocolinfo = 0,
ACE_SOCK_GROUP g = 0,
u_long flags = 0,
int reuse_addr = 0,
int perms = 0,
int protocol_family = PF_INET,
int protocol = 0);
// Actively connect and produce a <new_stream> if things go well.
// The <remote_sap> is the address that we are trying to connect
// with. The <qos_params> contains QoS parameters that are passed
// to the IntServ (RSVP) and DiffServ protocols. The <timeout> is
// the amount of time to wait to connect. If it's 0 then we block
// indefinitely. If *timeout == {0, 0} then the connection is done
// using non-blocking mode. In this case, if the connection can't
// be made immediately the value of -1 is returned with <errno ==
// EWOULDBLOCK>. If *timeout > {0, 0} then this is the amount of
// time to wait before timing out. If the time expires before the
// connection is made <errno == ETIME>. The <local_sap> is the
// value of local address to bind to. If it's the default value of
// <ACE_Addr::sap_any> then the user is letting the OS do the
// binding. If <reuse_addr> == 1 then the <local_addr> is reused,
// even if it hasn't been cleanedup yet.
int connect (ACE_SOCK_Stream &new_stream,
const ACE_Addr &remote_sap,
ACE_Time_Value *timeout = 0,
const ACE_Addr &local_sap = ACE_Addr::sap_any,
int reuse_addr = 0,
int flags = 0,
int perms = 0,
int protocol_family = PF_INET,
int protocol = 0);
// Actively connect and produce a <new_stream> if things go well.
// The <remote_sap> is the address that we are trying to connect
// with. The <timeout> is the amount of time to wait to connect.
// If it's 0 then we block indefinitely. If *timeout == {0, 0} then
// the connection is done using non-blocking mode. In this case, if
// the connection can't be made immediately the value of -1 is
// returned with <errno == EWOULDBLOCK>. If *timeout > {0, 0} then
// this is the amount of time to wait before timing out. If the
// time expires before the connection is made <errno == ETIME>. The
// <local_sap> is the value of local address to bind to. If it's
// the default value of <ACE_Addr::sap_any> then the user is letting
// the OS do the binding. If <reuse_addr> == 1 then the
// <local_addr> is reused, even if it hasn't been cleanedup yet.
// Note that the <new_stream> always starts out in blocking mode.
int connect (ACE_SOCK_Stream &new_stream,
const ACE_Addr &remote_sap,
ACE_QoS_Params qos_params,
ACE_Time_Value *timeout = 0,
const ACE_Addr &local_sap = ACE_Addr::sap_any,
ACE_Protocol_Info *protocolinfo = 0,
ACE_SOCK_GROUP g = 0,
u_long flags = 0,
int reuse_addr = 0,
int perms = 0,
int protocol_family = PF_INET,
int protocol = 0);
// Actively connect and produce a <new_stream> if things go well.
// The <remote_sap> is the address that we are trying to connect
// with. The <qos_params> contains QoS parameters that are passed
// to the IntServ (RSVP) and DiffServ protocols. The <timeout> is
// the amount of time to wait to connect. If it's 0 then we block
// indefinitely. If *timeout == {0, 0} then the connection is done
// using non-blocking mode. In this case, if the connection can't
// be made immediately the value of -1 is returned with <errno ==
// EWOULDBLOCK>. If *timeout > {0, 0} then this is the amount of
// time to wait before timing out. If the time expires before the
// connection is made <errno == ETIME>. The <local_sap> is the
// value of local address to bind to. If it's the default value of
// <ACE_Addr::sap_any> then the user is letting the OS do the
// binding. If <reuse_addr> == 1 then the <local_addr> is reused,
// even if it hasn't been cleanedup yet.
~ACE_SOCK_Connector (void);
// Default dtor.
// = Completion routine.
int complete (ACE_SOCK_Stream &new_stream,
ACE_Addr *remote_sap = 0,
ACE_Time_Value *timeout = 0);
// Try to complete a non-blocking connection.
// If connection completion is successful then <new_stream> contains
// the connected ACE_SOCK_Stream. If <remote_sap> is non-NULL then it
// will contain the address of the connected peer.
int reset_new_handle (ACE_HANDLE handle);
// Resets any event associations on this handle
// = Meta-type info
typedef ACE_INET_Addr PEER_ADDR;
typedef ACE_SOCK_Stream PEER_STREAM;
void dump (void) const;
// Dump the state of an object.
ACE_ALLOC_HOOK_DECLARE;
// Declare the dynamic allocation hooks.
protected:
int shared_open (ACE_SOCK_Stream &new_stream,
int protocol_family,
int protocol,
int reuse_addr);
// Perform operations that ensure the socket is opened using
// BSD-style semantics (no QoS).
int shared_open (ACE_SOCK_Stream &new_stream,
int protocol_family,
int protocol,
ACE_Protocol_Info *protocolinfo,
ACE_SOCK_GROUP g,
u_long flags,
int reuse_addr);
// Perform operations that ensure the socket is opened using
// QoS-enabled semantics.
int shared_connect_start (ACE_SOCK_Stream &new_stream,
ACE_Time_Value *timeout,
const ACE_Addr &local_sap);
// Perform operations that must be called before <ACE_OS::connect>.
int shared_connect_finish (ACE_SOCK_Stream &new_stream,
ACE_Time_Value *timeout,
int result);
// Perform operations that must be called after <ACE_OS::connect>.
};
#if !defined (ACE_LACKS_INLINE_FUNCTIONS)
#include "ace/SOCK_Connector.i"
#endif
#include "ace/post.h"
#endif /* ACE_SOCK_CONNECTOR_H */
|
