int logClient::process(ACE_CString* s){
ACE_SOCK_Stream logger;
ACE_SOCK_Connector connector;
ACE_INET_Addr addr(9876, "127.0.0.1");
if(connector.connect(logger, addr) == -1){
ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%p \n"), ACE_TEXT("open")), -1);
}
ACE_Log_Record record(LM_DEBUG,
ACE_OS::time ((time_t *) 0),
ACE_OS::getpid());
record.msg_data(s.c_str());
const size_t max_payload_size =
4
+ 8
+ 4
+ 4
+ ACE_Log_Record::MAXLOGMSGLEN
+ ACE_CDR::MAX_ALIGNMENT;
ACE_OutputCDR payload(max_payload_size);
payload<< record;
ACE_CDR::ULong length =
ACE_Utils::truncate_cast<ACE_CDR::ULong> (payload.total_length());
ACE_OutputCDR header (ACE_CDR::MAX_ALIGNMENT + 8);
header << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER);
header << ACE_CDR::ULong(length);
iovec iov[2];
iov[0].iov_base = header.begin() -> rd_ptr();
iov[0].iov_len = 8;
iov[1].iov_base = payload.begin() -> rd_ptr();
iov[1].iov_len = length;
if (logger.sendv_n(iov, 2) == -1)
ACE_ERROR_RETURN((LM_ERROR,"%p\n","send"), -1);
/*
*/
ACE_Message_Block* header_p;
auto_ptr<ACE_Message_Block> header(header_p);
ACE_CDR::mb_align(header.get());
ACE_Message_Block* payload_p;
ssize_t count = logger.recv_n(header->wr_ptr(),8);
switch(count){
default:
case -1:
case 0:
case 8:
break;
}
header->wr_ptr(8);
}
void
tofSession_i::tof_debug( const CORBA::WChar * text, const CORBA::WChar * key )
{
ACE_OutputCDR cdr;
cdr.write_wstring( text );
cdr.write_wstring( key );
ACE_Message_Block * mb = cdr.begin()->duplicate();
mb->msg_type( constants::MB_DEBUG );
pTask_->putq( mb );
}
/**
* UDPGenerator::gloveDgramWrite
*
* @param remotehost
* @param remoteport
* @param glovedata
*
* @return
*/
int UDPGenerator::gloveDgramWrite(
const ACE_TCHAR * remotehost,
u_short remoteport,
const DataGloveData &glovedata)
{
ACE_DEBUG ((LM_DEBUG, "Sender::initiate_write called\n"));
const size_t max_payload_size =
4 //boolean alignment flag
+ 4 //payload length
+ glovedata.length // Data Glove data length
+ ACE_CDR::MAX_ALIGNMENT; //pading
// Rescuer header
u_short myid = htons(5);
u_short mysize = htons(max_payload_size);
ACE_Message_Block* rescuerheader= 0;
ACE_NEW_RETURN(rescuerheader, ACE_Message_Block(4), -1);
rescuerheader->copy((const char *)&myid, 2);
rescuerheader->copy((const char *)&mysize, 2);
// My DGS stuff (header and payload)
ACE_OutputCDR header (ACE_CDR::MAX_ALIGNMENT + 8);
header << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER);
header << ACE_CDR::ULong(length);
// DGS Payload
ACE_OutputCDR payload (max_payload_size);
payload << glovedata;
ACE_CDR::ULong length = payload.total_length();
iovec iov[3];
iov[0].iov_base = rescuerheader->rd_ptr();
iov[0].iov_len = 4;
iov[1].iov_base = header.begin()->rd_ptr();
iov[1].iov_len = HEADER_SIZE;
iov[2].iov_base = payload.begin()->rd_ptr();
iov[2].iov_len = length;
ACE_INET_Addr serverAddr(remoteport, remotehost);
return sockDgram_.send(iov,3, serverAddr );
}
//FUZZ: disable check_for_lack_ACE_OS
int send (const ACE_Log_Record &log_record) {
//FUZZ: enable check_for_lack_ACE_OS
// Serialize the log record using a CDR stream, allocate
// enough space for the complete <ACE_Log_Record>.
const size_t max_payload_size =
4 // type()
+ 8 // timestamp
+ 4 // process id
+ 4 // data length
+ ACE_Log_Record::MAXLOGMSGLEN // data
+ ACE_CDR::MAX_ALIGNMENT; // padding;
// Insert contents of <log_record> into payload stream.
ACE_OutputCDR payload (max_payload_size);
payload << log_record;
// Get the number of bytes used by the CDR stream.
ACE_CDR::ULong length = payload.total_length ();
// Send a header so the receiver can determine the byte
// order and size of the incoming CDR stream.
ACE_OutputCDR header (ACE_CDR::MAX_ALIGNMENT + 8);
header << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER);
// Store the size of the payload that follows
header << ACE_CDR::ULong (length);
// Use an iovec to send both buffer and payload simultaneously.
iovec iov[2];
iov[0].iov_base = header.begin ()->rd_ptr ();
iov[0].iov_len = 8;
iov[1].iov_base = payload.begin ()->rd_ptr ();
iov[1].iov_len = length;
// Send header and payload efficiently using "gather-write".
return logging_peer_.sendv_n (iov, 2);
}
// send the test header (only contains number of iterations)
int sendHeader(ACE_SOCK_Stream & stream) {
// create an ACE CDR output stream and place the header information
// into it
ACE_OutputCDR hdrCDR;
hdrCDR << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER);
hdrCDR << ACE_CDR::ULong(Options_Manager::test_iterations+primerIterations);
if (!hdrCDR.good_bit())
return (0);
// send the header to the server (HEADER IS 8 BYTES LONG)
size_t bt;
if (stream.send_n(hdrCDR.begin(), 0, &bt) == -1)
return 0;
return 1;
}
int DataWrapper::write(const ACE_OutputCDR& cdr)
{
//This method writes to an ace socket stream. First, it will collect
//the appropriate header which includes the message length. It will then
//combine ACE blocks that hold the header and message, and send it.
//If preparing the block or sending fails, it returns an appropriate error.
//If the actual socket send fails, the connection will be closed (not sure what
//else to do, since it shouldn't fail under a good connection)
if(!cdr.good_bit())
ACE_ERROR_RETURN((LM_ERROR, "%s, %p\n",toString(theAddress).c_str(),"Failed while sending CDR"), -1);
ACE_OutputCDR aceHead(headerLength);
//Put header info into a CDR
if(!(aceHead << (ACE_CDR::ULong)bitsForward) || !(aceHead << (ACE_CDR::ULong)cdr.length()))
ACE_ERROR_RETURN( (LM_ERROR, "%s, %p\n",toString(theAddress).c_str(),"Failed while sending, CDR header"), -1 );
//Create a block with the header and message
const_cast<ACE_Message_Block*>(aceHead.begin())->cont(const_cast<ACE_Message_Block*>(cdr.begin()));
const ssize_t msgLength = headerLength + ACE_CDR::total_length(cdr.begin(), cdr.end());
// cout << toString(theAddress) << endl;
//Send the message
const ssize_t bytesSent = theStream.send_n(aceHead.begin());
// Clear the block
const_cast<ACE_Message_Block*>(aceHead.begin())->cont(NULL);
//Check whether the send succeeded (sent all the bytes). If not, we assume the socket has disconnected.
// cout << "Bytes sent: " << bytesSent << " | msgLength: " << msgLength << endl;
if( bytesSent != msgLength ) {
theStream.close_writer();
ACE_ERROR_RETURN((LM_ERROR, "%s - %p\n",toString(theAddress).c_str(),"Socket failed while sending"), -1);
}
//Everything sent successfully
return 0;
}
static int
short_stream (void)
{
// counter
u_int i;
// Build an output stream
ACE_OutputCDR os;
// Basic types for output
ACE_CDR::Char ch = 'A';
ACE_CDR::Char wchtmp[] = {"\xF3"};
ACE_CDR::WChar wch = *wchtmp;
ACE_CString str ("Test String");
ACE_CDR::Short s = -123;
ACE_CDR::UShort us = 123;
ACE_CDR::Long l = -65800L;
ACE_CDR::ULong ul = 65800UL;
ACE_CDR::Float f = 1.23f;
ACE_CDR::Double d = 123.456789;
// Arrays for output
ACE_CDR::Short s_array[3] = { -1, 0, 1 };
ACE_CDR::Long l_array[3] = { -345678, 0, 345678 };
ACE_CDR::Float f_array[3] = { -1.23f, 0.0f, 1.23f };
ACE_CDR::Double d_array[3] = { -123.456789, 0.0, 123.456789 };
ACE_OutputCDR::from_char fc (ch);
os << fc;
ACE_OutputCDR::from_wchar fwc (wch);
os << fwc;
os << str;
os << s;
os << us;
os << l;
os << ul;
os << f;
os << d;
os.write_short_array (s_array, 3);
os.write_long_array (l_array, 3);
os.write_float_array (f_array, 3);
os.write_double_array (d_array, 3);
const ACE_Message_Block *out_mb = os.begin ();
u_int len = out_mb->length ();
// Create an input stream (copy constructor)
ACE_InputCDR is (os);
const ACE_Message_Block *in_mb = is.start ();
if (in_mb->length () != len)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("buffer length not preserved")),
1);
u_long in_chunk, out_chunk;
for (i = 0; i < len; i++)
{
in_chunk = u_long (* (in_mb->rd_ptr () + i));
out_chunk = u_long (* (out_mb->rd_ptr () + i));
if (in_chunk != out_chunk )
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("buffer contents not preserved")),
1);
}
// Basic types for input
ACE_CDR::Char ch1 = '\0';
ACE_CDR::WChar wch1 = '\x00';
ACE_CString str1;
ACE_CDR::Short s1 = 0;
ACE_CDR::UShort us1 = 0;
ACE_CDR::Long l1 = 0L;
ACE_CDR::ULong ul1 = 0UL;
ACE_CDR::Float f1 = 0.0f;
ACE_CDR::Double d1 = 0.0;
// Arrays for input
ACE_CDR::Short s_array1[3];
ACE_CDR::Long l_array1[3];
ACE_CDR::Float f_array1[3];
ACE_CDR::Double d_array1[3];
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Checking operators and arrays\n\n")));
ACE_InputCDR::to_char tc (ch1);
is >> tc;
ACE_InputCDR::to_wchar twc (wch1);
is >> twc;
is >> str1;
is >> s1;
is >> us1;
is >> l1;
is >> ul1;
is >> f1;
is >> d1;
is.read_short_array (s_array1, 3);
is.read_long_array (l_array1, 3);
is.read_float_array (f_array1, 3);
is.read_double_array (d_array1, 3);
if (ch1 != ch)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("char transfer error")),
1);
if (wch1 != wch)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("wchar transfer error")),
1);
if (str1 != str)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("string transfer error")),
1);
if (s1 != s)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("short transfer error")),
1);
if (us1 != us)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("ushort transfer error")),
1);
if (l1 != l)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("long transfer error")),
1);
if (ul1 != ul)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("ulong transfer error")),
1);
if (f1 != f)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("float transfer error")),
1);
if (d1 != d)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("double transfer error")),
1);
for (i = 0 ; i < 3; i++)
if (s_array1[i] != s_array[i])
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("short array transfer error")),
1);
for (i = 0 ; i < 3; i++)
if (l_array1[i] != l_array[i])
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("long array transfer error")),
1);
for (i = 0 ; i < 3; i++)
if (f_array1[i] != f_array[i])
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("float array transfer error")),
1);
for (i = 0 ; i < 3; i++)
if (d_array1[i] != d_array[i])
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("double array transfer error")),
1);
return 0;
}
int
main (int argc, ACE_TCHAR *argv[])
{
ACE_START_TEST (ACE_TEXT ("CDR_Test"));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("This is ACE Version %u.%u.%u\n\n"),
ACE::major_version (),
ACE::minor_version(),
ACE::beta_version()));
ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("dn:l:"));
int opt;
int debug = 0;
while ((opt = get_opt ()) != EOF)
{
switch (opt)
{
case 'd':
debug++;
break;
case 'n':
n = ACE_OS::atoi (get_opt.optarg);
break;
case 'l':
nloops = ACE_OS::atoi (get_opt.optarg);
break;
case '?':
default:
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Usage: %s ")
ACE_TEXT ("-d debug")
ACE_TEXT ("-n <num> ")
ACE_TEXT ("-l <loops> ")
ACE_TEXT ("\n"),
argv[0]));
return -1;
}
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Testing ACE CDR functions - short stream\n\n")));
if (short_stream () != 0 )
return 1;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Short stream - no errors\n\n")
ACE_TEXT ("Testing basic types - long stream\n\n")));
for (int i = 0; i < nloops; ++i)
{
ACE_OutputCDR output;
CDR_Test_Types test_types;
if (test_types.test_put (output) != 0)
return 1;
ACE_InputCDR input (output);
if (debug > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Output CDR: \n")));
ACE_HEX_DUMP ((LM_DEBUG,
input.rd_ptr(),
64));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Input CDR: \n")));
ACE_HEX_DUMP ((LM_DEBUG,
input.rd_ptr(),
64));
}
if (test_types.test_get (input) != 0)
return 1;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Long stream - no errors\n\n")
ACE_TEXT ("Testing basic types - long stream[2]\n\n")));
for (int j = 0; j < nloops; ++j)
{
ACE_OutputCDR output;
CDR_Test_Types test_types;
if (test_types.test_put (output) != 0)
return 1;
ACE_InputCDR input (output.begin ());
if (debug > 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Output CDR: \n")));
ACE_HEX_DUMP ((LM_DEBUG,
input.rd_ptr(),
64));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Input CDR: \n")));
ACE_HEX_DUMP ((LM_DEBUG,
input.rd_ptr(),
64));
}
if (test_types.test_get (input) != 0)
return 1;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Long stream[2] - no errors\n\n")));
ACE_END_TEST;
return 0;
}
ssize_t
ACE_Log_Msg_IPC::log (ACE_Log_Record &log_record)
{
// Serialize the log record using a CDR stream, allocate enough
// space for the complete <ACE_Log_Record>.
size_t const max_payload_size =
4 // type
+ 4 // pid
+ 12 // timestamp
+ 4 // process id
+ 4 // data length
#if defined (ACE_USES_WCHAR)
+ (log_record.msg_data_len () * ACE_OutputCDR::wchar_maxbytes()) // message
#else
+ log_record.msg_data_len () // message
#endif
+ ACE_CDR::MAX_ALIGNMENT; // padding;
// Insert contents of <log_record> into payload stream.
ACE_OutputCDR payload (max_payload_size);
payload << log_record;
// Get the number of bytes used by the CDR stream. If it becomes desireable
// to support payloads more than 4GB, this field will need to be changed
// to a 64-bit value.
ACE_CDR::ULong length =
ACE_Utils::truncate_cast<ACE_CDR::ULong> (payload.total_length ());
// Send a header so the receiver can determine the byte order and
// size of the incoming CDR stream.
ACE_OutputCDR header (ACE_CDR::MAX_ALIGNMENT + 8);
header << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER);
// Store the size of the payload that follows
header << ACE_CDR::ULong (length);
// Use an iovec to send both buffer and payload simultaneously.
iovec iov[2];
iov[0].iov_base = header.begin ()->rd_ptr ();
iov[0].iov_len = 8;
iov[1].iov_base = payload.begin ()->rd_ptr ();
iov[1].iov_len = length;
#if defined (ACE_HAS_STREAM_PIPES)
// Use the <putpmsg> API if supported to ensure correct message
// queueing according to priority.
ACE_Str_Buf header_msg (static_cast<void *> (header.begin ()->rd_ptr ()),
static_cast<int> (8));
ACE_Str_Buf payload_msg (static_cast<void *> (payload.begin ()->rd_ptr ()),
static_cast<int> (length));
return this->message_queue_.send (&header_msg,
&payload_msg,
static_cast<int> (log_record.priority ()),
MSG_BAND);
#else
// We're running over sockets, so send header and payload
// efficiently using "gather-write".
return this->message_queue_.sendv_n (iov, 2);
#endif /* ACE_HAS_STREAM_PIPES */
}
template<class T, class H> void
CDR_Test<T, H>::do_test (int total, int niter, int use_array,
char* srcbuf, char* dstbuf,
int src_offset, int dst_offset)
{
if (!use_array)
{
dst_offset = src_offset = 0;
}
ACE_DEBUG((LM_DEBUG,
ACE_TEXT( "Starting Test for %s: %d elements " )
ACE_TEXT( "%susing arrays.\n" ),
H::name (),
total,
((use_array) ? ACE_TEXT( "" ) : ACE_TEXT( "not " ))));
if (!use_array && (total % 4) != 0)
{
int lasttotal = total;
total -= (total % 4);
ACE_DEBUG((LM_DEBUG,
ACE_TEXT( "Rounding from %d to %d elements.\n" ),
lasttotal,
total));
}
char* src = ACE_ptr_align_binary(srcbuf, H::size ());
T* idata = reinterpret_cast<T*> (src);
idata += src_offset;
src = reinterpret_cast<char*> (idata);
{
int i;
for (i = 0; i < total; i++)
{
idata[i] = CDR_Test<T, H>::checkval (i);
}
}
ACE_DEBUG((LM_DEBUG,
ACE_TEXT( "Writing data...\n" )));
char* toread = 0;
{
ACE_TEST_ASSERT(use_array || total % 4 == 0);
double totalsecs = 0.0;
int n;
for (n = 0; n < niter; n++)
{
size_t size = H::size () * (dst_offset + total) +
ACE_CDR::MAX_ALIGNMENT;
ACE_OutputCDR os (dstbuf, size);
// This is intrusive...
char* const end = os.begin ()->wr_ptr() + size;
do_seal (end);
double secs = 0.0;
if (use_array)
{
{
int i;
for (i = 0; i < dst_offset; i++)
{
os << T(0);
}
}
if (n == 0)
{
ACE_DEBUG((LM_DEBUG,
ACE_TEXT ("* src align = %d, dst align = %d\n"),
tellalign (src),
tellalign (os.begin ()->wr_ptr ())));
}
Crono crono;
crono.start ();
H::write_array (os, idata, total);
crono.stop ();
secs = crono.read_seconds ();
}
else
{
int i = 0;
for (; i < dst_offset; i++)
{
os << T(0);
}
i = 0;
Crono crono;
crono.start();
while (i < total)
{
os << idata[i++];
os << idata[i++];
os << idata[i++];
os << idata[i++];
// static char rs[32 + 1];
// CDR_Test<T,H>::ttoh (idata[i], rs);
// ACE_DEBUG ((LM_DEBUG, "Write idata[%d] = %s\n", i, rs));
// os << idata[i];
// i++;
}
crono.stop ();
secs = crono.read_seconds ();
}
if (!check_seal(end))
{
ACE_ERROR((LM_ERROR,
ACE_TEXT( "Broken seal, aborting.\n" )));
ACE_OS::exit(1);
}
totalsecs += secs;
if (n == niter - 1)
{
toread = os.begin ()->rd_ptr ();
}
}
totalsecs = totalsecs / niter;
ACE_DEBUG((LM_DEBUG,
ACE_TEXT ("Writing to stream %d %s values: %f seconds.\n"),
total,
H::name (),
totalsecs));
}
{
int i;
for (i = 0; i < total; i++)
{
idata[i] = 0;
}
}
ACE_DEBUG((LM_DEBUG,
ACE_TEXT( "Reading them back in opposing byte order...\n" )));
const int opposite_byte_order = 1 - ACE_CDR_BYTE_ORDER;
{
double totalsecs = 0.0;
int n;
for (n = 0; n < niter; n++)
{
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("====== Read iteration %d\n"), n));
size_t size = (total + dst_offset) * H::size ();
ACE_InputCDR is (toread, size, opposite_byte_order);
// This is intrusive...
char* const end = is.rd_ptr () + size;
do_seal (end);
double secs = 0.0;
if (use_array)
{
{
int i;
for (i = 0; i < dst_offset; i++)
{
T v;
is >> v;
}
}
if (n == 0)
{
ACE_DEBUG((LM_DEBUG,
ACE_TEXT ("* src align = %d, dst align = %d\n"),
tellalign (is.rd_ptr ()),
tellalign (src)));
}
Crono crono;
crono.start ();
H::read_array (is, idata, total);
crono.stop ();
secs = crono.read_seconds ();
// Testing for good bit value. Try reading atleast 10
// times the size of total. It should fail with good bit
// set to 0.
H::read_array (is, idata, 10 * total);
if (is.good_bit () != 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Test for good bit failed in %s Array_test\n"),
H::name ()));
}
}
else
{
int i = 0;
Crono crono;
crono.start ();
while (i < total)
{
#if 0
T v;
is >> v;
static char rs[32 + 1];
CDR_Test<T,H>::ttoh (v, rs);
ACE_DEBUG ((LM_DEBUG, "Read idata[%d] = %s\n", i, rs));
idata[i] = v;
i++;
#else
is >> idata[i++];
is >> idata[i++];
is >> idata[i++];
is >> idata[i++];
#endif /* 0 */
}
crono.stop ();
secs = crono.read_seconds ();
}
totalsecs += secs;
if (!check_seal (end))
{
ACE_ERROR((LM_ERROR,
ACE_TEXT( "Broken seal, aborting.\n" )));
ACE_OS::exit(1);
}
}
totalsecs = totalsecs / niter;
ACE_DEBUG((LM_DEBUG,
ACE_TEXT ("Reading from stream %d %s values")
ACE_TEXT (" (byte swapping): %f seconds.\n"),
total,
H::name (),
totalsecs));
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
const ACE_TCHAR *logger_host = argc > 1 ? argv[1] : LOGGER_HOST;
u_short logger_port = argc > 2 ? ACE_OS::atoi (argv[2]) : LOGGER_PORT;
int max_iterations = argc > 3 ? ACE_OS::atoi (argv[3]) : MAX_ITERATIONS;
ACE_SOCK_Stream logger;
ACE_SOCK_Connector connector;
ACE_INET_Addr addr (logger_port, logger_host);
if (connector.connect (logger, addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("open")), -1);
for (int i = 0; i < max_iterations; i++)
{
ACE_Log_Record log_record (LM_DEBUG,
ACE_OS::time ((time_t *) 0),
ACE_OS::getpid ());
ACE_TCHAR buf[BUFSIZ];
ACE_OS::sprintf (buf, ACE_TEXT ("message = %d\n"), i + 1);
log_record.msg_data (buf);
const size_t max_payload_size =
4 // type()
+ 8 // timestamp
+ 4 // process id
+ 4 // data length
+ ACE_Log_Record::MAXLOGMSGLEN // data
+ ACE_CDR::MAX_ALIGNMENT; // padding;
// Insert contents of <log_record> into payload stream.
ACE_OutputCDR payload (max_payload_size);
payload << log_record;
// Get the number of bytes used by the CDR stream.
ACE_CDR::ULong length =
ACE_Utils::truncate_cast<ACE_CDR::ULong> (payload.total_length ());
// Send a header so the receiver can determine the byte order and
// size of the incoming CDR stream.
ACE_OutputCDR header (ACE_CDR::MAX_ALIGNMENT + 8);
header << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER);
// Store the size of the payload that follows
header << ACE_CDR::ULong (length);
// Use an iovec to send both buffer and payload simultaneously.
iovec iov[2];
iov[0].iov_base = header.begin ()->rd_ptr ();
iov[0].iov_len = 8;
iov[1].iov_base = payload.begin ()->rd_ptr ();
iov[1].iov_len = length;
if (logger.sendv_n (iov, 2) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "send"), -1);
}
if (logger.close () == -1)
ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("close")), -1);
return 0;
}
