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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
|
// $Id$
#include "ace/SOCK_SEQPACK_Association.h"
#if defined (ACE_LACKS_INLINE_FUNCTIONS)
#include "ace/SOCK_SEQPACK_Association.i"
#endif
#include "ace/Auto_Ptr.h"
#include "ace/Log_Msg.h"
#include "ace/OS_NS_string.h"
ACE_RCSID(ace, SOCK_SEQPACK_Association, "$Id$")
ACE_ALLOC_HOOK_DEFINE(ACE_SOCK_SEQPACK_Association)
void
ACE_SOCK_SEQPACK_Association::dump (void) const
{
#if defined (ACE_HAS_DUMP)
ACE_TRACE ("ACE_SOCK_SEQPACK_Association::dump");
#endif /* ACE_HAS_DUMP */
}
int
ACE_SOCK_SEQPACK_Association::close (void)
{
#if defined (ACE_WIN32)
// We need the following call to make things work correctly on
// Win32, which requires use to do a <close_writer> before doing the
// close in order to avoid losing data. Note that we don't need to
// do this on UNIX since it doesn't have this "feature". Moreover,
// this will cause subtle problems on UNIX due to the way that
// fork() works.
this->close_writer ();
#endif /* ACE_WIN32 */
// Close down the socket.
return ACE_SOCK::close ();
}
int
ACE_SOCK_SEQPACK_Association::get_local_addrs (ACE_INET_Addr *addrs, size_t &size) const
{
ACE_TRACE ("ACE_SOCK_SEQPACK_Association::get_local_addrs");
#if defined (ACE_HAS_LKSCTP)
/*
The size of ACE_INET_Addr must be large enough to hold the number of
local addresses on the machine. If the array is too small, the function
will only return the number of addresses that will fit. If the array is
too large, the 'size' parameter will be modified to indicate the number
of addrs.
We will call sctp_getladdrs() which accepts 3 parameters
1. a socket fd
2. a sctp association_id which will be ignored since we are using
tcp sockets
3. a pointer to sockaddr
lksctp/draft will allocate memory and we are responsible for freeing
it by calling sctp_freeladdrs().
*/
sockaddr_in *si = 0;
sockaddr *laddrs = 0;
int err = 0;
size_t len = 0;
err = sctp_getladdrs(this->get_handle(), 0, &laddrs);
if (err > 0)
{
len = err;
// check to see if we have more addresses than we have
// space in our ACE_INET_Addr array
if (len > size)
{
// since our array is too small, we will only copy the first
// few that fit
len = size;
}
for (size_t i = 0; i < len; i++)
{
// first we cast the sockaddr to sockaddr_in
// since we only support ipv4 at this time.
si = (sockaddr_in *) (&(laddrs[i]));
// now we fillup the ace_inet_addr array
addrs[i].set_addr(si, sizeof(sockaddr_in));
addrs[i].set_type(si->sin_family);
addrs[i].set_size(sizeof(sockaddr_in));
}
}
else /* err < 0 */
{
// sctp_getladdrs will return -1 on error
return -1;
}
// indicate the num of addrs returned to the calling function
size = len;
// make sure we free the struct using the system function
sctp_freeladdrs(laddrs);
#else
/*
We will be calling ACE_OS::getsockname, which accepts (and
potentially modifies) two reference parameters:
1. a sockaddr_in* that points to a buffer
2. an int* that points to the size of this buffer
The OpenSS7 implementation of SCTP copies an array of ipv4
sockaddr_in into the buffer. Then, if the size of the buffer is
greater than the size used, the size parameter is reduced
accordingly.
*/
// The array of sockaddr_in will be stored in an ACE_Auto_Array_Ptr,
// which causes dynamically-allocated memory to be released as soon
// as the ACE_Auto_Array_Ptr goes out of scope.
ACE_Auto_Array_Ptr<sockaddr_in> addr_structs;
// Allocate memory for this array. Return -1 if the memory cannot
// be allocated. (This activity requires a temporary variable---a
// bare sockaddr_in* --- because ACE_NEW_RETURN cannot act directory on
// an ACE_Auto_Array_Ptr.)
{
sockaddr_in *addr_structs_bootstrap = 0;
ACE_NEW_RETURN(addr_structs_bootstrap,
sockaddr_in[size],
-1);
addr_structs.reset(addr_structs_bootstrap);
}
// Physical size of this array is its logical size multiplied by
// the physical size of one of its elements.
size_t physical_size = size * sizeof(sockaddr_in);
/* Clear the array */
ACE_OS::memset(addr_structs.get(),
0,
physical_size);
/*
** Populate the array with real values from the getsockname system
** call. addr_structs is modified, and name_size is modified to contain
** the number of bytes written to addr_structs.
** Use name_size to get the data types right across the call.
*/
int name_size = ACE_static_cast (int, physical_size);
if (ACE_OS::getsockname (this->get_handle (),
ACE_reinterpret_cast (sockaddr *,
addr_structs.get()),
&name_size) == -1)
return -1;
/* Calculate the NEW physical size of the array */
name_size /= sizeof (sockaddr_in);
size = ACE_static_cast (size_t, name_size);
/* Copy each sockaddr_in to the address structure of an ACE_Addr from
the passed-in array */
const int addrlen (ACE_static_cast (int, sizeof (sockaddr_in)));
for (int i = 0; i < name_size; ++i)
{
addrs[i].set_addr (&(addr_structs[i]), addrlen);
addrs[i].set_type (addr_structs[i].sin_family);
addrs[i].set_size (addrlen);
}
#endif /* ACE_HAS_LKSCTP */
return 0;
}
int
ACE_SOCK_SEQPACK_Association::get_remote_addrs (ACE_INET_Addr *addrs, size_t &size) const
{
ACE_TRACE ("ACE_SOCK_SEQPACK_Association::get_remote_addrs");
#if defined (ACE_HAS_LKSCTP)
/*
The size of ACE_INET_Addr must be large enough to hold the number of
remotes addresses in the association. If the array is too small, the
function will only return the number of addresses that will fit. If the
array is too large, the 'size' parameter will be modified to indicate
the number of addrs.
We will call sctp_getpaddrs() which accepts 3 parameters
1. a socket fd
2. a sctp association_id which will be ignored since we are using
tcp sockets
3. a pointer to a sockaddr
lksctp/draft will allocate memory and we are responsible for freeing
it by calling sctp_freepaddrs().
*/
sockaddr_in *si = 0;
sockaddr *paddrs = 0;
int err = 0;
size_t len = 0;
err = sctp_getpaddrs(this->get_handle(), 0, &paddrs);
if (err > 0)
{
len = err;
// check to see if we have more addresses than we have
// space in our ACE_INET_Addr array
if (len > size)
{
// since our array is too small, we will only copy the first
// few that fit
len = size;
}
for (size_t i = 0; i < len; i++)
{
// first we cast the sockaddr to sockaddr_in
// since we only support ipv4 at this time.
si = (sockaddr_in *) (&(paddrs[i]));
// now we fillup the ace_inet_addr array
addrs[i].set_addr(si, sizeof(sockaddr_in));
addrs[i].set_type(si->sin_family);
addrs[i].set_size(sizeof(sockaddr_in));
}
}
else /* err < 0 */
{
// sctp_getpaddrs will return -1 on error
return -1;
}
// indicate the num of addrs returned to the calling function
size = len;
// make sure we free the struct using the system function
sctp_freepaddrs(paddrs);
#else
/*
We will be calling ACE_OS::getpeername, which accepts (and
potentially modifies) two reference parameters:
1. a sockaddr_in* that points to a buffer
2. an int* that points to the size of this buffer
The OpenSS7 implementation of SCTP copies an array of ipv4
sockaddr_in into the buffer. Then, if the size of the buffer is
greater than the size used, the size parameter is reduced
accordingly.
*/
// The array of sockaddr_in will be stored in an ACE_Auto_Array_Ptr,
// which causes dynamically-allocated memory to be released as soon
// as the ACE_Auto_Array_Ptr goes out of scope.
ACE_Auto_Array_Ptr<sockaddr_in> addr_structs;
// Allocate memory for this array. Return -1 if the memory cannot
// be allocated. (This activity requires a temporary variable---a
// bare sockaddr_in* --- because ACE_NEW_RETURN cannot act directory on
// an ACE_Auto_Array_Ptr.)
{
sockaddr_in *addr_structs_bootstrap = 0;
ACE_NEW_RETURN(addr_structs_bootstrap,
sockaddr_in[size],
-1);
addr_structs.reset(addr_structs_bootstrap);
}
// Physical size of this array is its logical size multiplied by
// the physical size of one of its elements.
size_t physical_size = size * sizeof(sockaddr_in);
/* Clear the array */
ACE_OS::memset(addr_structs.get(),
0,
physical_size);
/*
** Populate the array with real values from the getpeername system
** call. addr_structs is modified, and name_size is modified to contain
** the number of bytes written to addr_structs.
** Use name_size to get the data types right across the call.
*/
int name_size = ACE_static_cast (int, physical_size);
if (ACE_OS::getpeername (this->get_handle (),
ACE_reinterpret_cast (sockaddr *,
addr_structs.get()),
&name_size) == -1)
return -1;
/* Calculate the NEW physical size of the array */
name_size /= sizeof (sockaddr_in);
size = ACE_static_cast (size_t, name_size);
/* Copy each sockaddr_in to the address structure of an ACE_Addr from
the passed-in array */
const int addrlen (ACE_static_cast (int, sizeof (sockaddr_in)));
for (int i = 0; i < name_size; ++i)
{
addrs[i].set_addr (&(addr_structs[i]), addrlen);
addrs[i].set_type (addr_structs[i].sin_family);
addrs[i].set_size (addrlen);
}
#endif /* ACE_HAS_LKSCTP */
return 0;
}
#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
template class ACE_Auto_Array_Ptr<sockaddr_in>;
template class ACE_Auto_Basic_Array_Ptr<sockaddr_in>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#pragma instantiate ACE_Auto_Array_Ptr<sockaddr_in>
#pragma instantiate ACE_Auto_Basic_Array_Ptr<sockaddr_in>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
|