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; }