blob: 6415fed196692ba9631dc32faff7fd5ea05a25c7 (
plain)
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
|
// $Id$
#include "Client_i.h"
#include "ace/Message_Block.h"
#include "ace/INET_Addr.h"
#include "ace/SOCK_Connector.h"
// Simple constructor just remembers the endpoint information for use by open.
Client::Client( u_short _port, const char * _server)
: port_(_port), server_(_server)
{
;
}
/* Do nothing. This should probably call close() if we can make sure
that it's OK to close() multiple times.
*/
Client::~Client(void)
{
;
}
/* Open the connection to the server. This is traditional ACE. We
simply construct an endpoint and use a connector to establish the
link.
*/
int Client::open( void )
{
ACE_INET_Addr addr(port_,server_);
ACE_SOCK_Connector con;
if( con.connect(peer(),addr) == -1 )
{
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_SOCK_Connector::connect()"), -1);
}
// Something new here... We have to use the protocol stream
// to ensure that our data is in the correct format when
// received by the server. Thus, we open the stream and
// transfer ownership of the peer.
return stream().open( peer() );
}
// The remainder of the functions just delegate to the stream.
int Client::close( void )
{
return stream().close();
}
int Client::put( ACE_Message_Block * _message )
{
return stream().put(_message,0);
}
int Client::get( ACE_Message_Block * & _response )
{
return stream().get(_response);
}
|
